physxDebugHelper.cpp

#include "main.h"
#include "physxDebugHelper.h"



// used by irrlichtUpdate()
static bool isPhysxDebugRenderingEnabled = false;

void switchPhysxDebugRenderingEnabled()
{
        isPhysxDebugRenderingEnabled = !isPhysxDebugRenderingEnabled;
}
bool getPhysxDebugRenderingEnabled()
{
        return isPhysxDebugRenderingEnabled;
}





// output physX errors, reported by the SDK
void NxDebugOutput::reportError(NxErrorCode code, const char* message, const char* file, int line)
{
        stringc error("*** physX error *** ");
        error += code;
        error += " ";
        error += message;
        error += " in ";
        error += file;
        error += " at ";
        error += line;

        logger->log( error.c_str() );
}


// output physX errors, reported by the SDK
NxAssertResponse NxDebugOutput::reportAssertViolation(const char* message, const char* file, int line)
{
        NxAssertResponse status = NX_AR_BREAKPOINT;

        stringc error("*** physX Assert failed *** ");
        error += message;
        error += " in ";
        error += file;
        error += " at ";
        error += line;

        logger->log( error.c_str() );

        return status;
}


// output physX errors, reported by the SDK
void NxDebugOutput::print(const char* message)
{
        stringc msg("physX debug: ");
        msg += message;

        logger->log( msg.c_str() );
}






// uses irrlicht to render debug data (triangles), given from physX debug visualization
NxDebugRenderer::NxDebugRenderer()
{
}

NxDebugRenderer::~NxDebugRenderer()
{
}



// must be called from irrlicht update()
// i.e. "within beginScene() and endScene()"
// because irrlicht must be in proper render state to draw below lines
ERR_TYPE NxDebugRenderer::update( f32 timeMS )
{
        const NxDebugRenderable* nxDebugRenderable;
        u32 nLines = 0;
        u32 nTriangles = 0;
        u32 nPoints = 0;

        if ( nxScene )
        {
                // the renderable from physX must be obtained every frame
                nxDebugRenderable = nxScene->getDebugRenderable();
                if ( NULL == nxDebugRenderable )
                {
                        logger->log( "*** can not get NxDebugRenderable ***" );
                }
                else
                {
                        nLines =                nxDebugRenderable->getNbLines();
                        nTriangles =    nxDebugRenderable->getNbTriangles();
                        nPoints =               nxDebugRenderable->getNbPoints();
                }
        }

        // tell irrlicht to draw in world coordinates with center (0,0,0)
        // setup a identity matrix
        matrix4 identity;
        driver->setTransform( ETS_WORLD, identity );

        // tell irrlicht to use this material for drawing
        // setup a default material, but turn dynamic lighting OFF
        SMaterial defaultMaterial;
        defaultMaterial.Lighting = false;
        driver->setMaterial( defaultMaterial );

        // draw lines, retrieved by nxDebugRenderable
        if ( nLines )
        {
                const NxDebugLine* nxDebugLines = nxDebugRenderable->getLines();

                while ( nLines-- )
                {
                        vector3df start( nxDebugLines->p0.x, nxDebugLines->p0.y, nxDebugLines->p0.z );
                        vector3df end( nxDebugLines->p1.x, nxDebugLines->p1.y, nxDebugLines->p1.z );
                        SColor color( nxDebugLines->color );    // a rgb
                        driver->draw3DLine( start, end, color );
                        nxDebugLines++;
                }
        }

        // draw triangles, retrieved by nxDebugRenderable
        if ( nTriangles )
        {
                const NxDebugTriangle* nxDebugTriangles = nxDebugRenderable->getTriangles();

                while ( nTriangles-- )
                {
                        vector3df v0( nxDebugTriangles->p0.x, nxDebugTriangles->p0.y, nxDebugTriangles->p0.z );
                        vector3df v1( nxDebugTriangles->p1.x, nxDebugTriangles->p1.y, nxDebugTriangles->p1.z );
                        vector3df v2( nxDebugTriangles->p2.x, nxDebugTriangles->p2.y, nxDebugTriangles->p2.z );
                        triangle3df triangle( v0, v1, v2 );
                        SColor color( nxDebugTriangles->color );        // a rgb
                        driver->draw3DTriangle( triangle, color );
                        nxDebugTriangles++;
                }
        }

        // draw points, retrieved by nxDebugRenderable
        if ( nPoints )
        {
                const NxDebugPoint* nxDebugPoints = nxDebugRenderable->getPoints();

                while ( nPoints-- )
                {
                        vector3df p( nxDebugPoints->p.x, nxDebugPoints->p.y, nxDebugPoints->p.z );
                        aabbox3df  aabbox( p - vector3df(1.0f, 1.0f, 1.0f), p + vector3df(1.0f, 1.0f, 1.0f) );
                        SColor color( nxDebugPoints->color );   // a rgb
                        driver->draw3DBox( aabbox, color );
                        nxDebugPoints++;
                }
        }

        return ERR_OK;
}






// output physX errors, reported by the NXU_helper
void NxuDebugOutput::NXU_errorMessage(bool isError, const char* str)
{
        stringc msg("physX util error: ");
        msg += str;

        logger->log( msg.c_str() );
}



// Notifies the application that a new scene has been created.
void NxuUserNotify::NXU_notifyScene(NxU32 sno, NxScene* scene,const char* userProperties)
{
        stringc msg( "NXU_notifyScene() scene created" );
        logger->log( msg.c_str() );
}

//brief Notifies the application that a new actor has been created.
void NxuUserNotify::NXU_notifyActor(NxActor* actor, const char* userProperties)
{
        stringc msg( "NXU_notifyActor() actor created. name=" );
        msg += actor->getName();
        logger->log( msg.c_str() );
}

//brief Notifies the application that a new TriangleMesh that has been created.
void NxuUserNotify:: NXU_notifyTriangleMesh(NxTriangleMesh* t,const char* userProperties)
{
        NxReal mass = 0.0f;
        NxMat33 localInertia;
        NxVec3 localCenterOfMass;
        t->getMassInformation( mass, localInertia, localCenterOfMass );
        stringc msg( "NXU_notifyTriangleMesh() triangle mesh created. mass=" );
        msg += mass;
        logger->log( msg.c_str() );
}

// brief Pre-notification event before a new scene is about to be created.
// return a NULL pointer to have the instantiator create the scene.  A non-null pointer is the NxScene the application wants the data to be loaded into.
NxScene* NxuUserNotify::NXU_preNotifyScene(unsigned int sno, NxSceneDesc& scene, const char* userProperties)
{
        stringc msg( "NXU_preNotifyScene() scene is about to be created" );
        logger->log( msg.c_str() );
        return NULL;
}

// brief Pre-notification event before an actor is created.
// return true to create the actor or false to skip it.
bool NxuUserNotify::NXU_preNotifyActor(NxActorDesc& actor, const char* userProperties)
{
        stringc msg( "NXU_preNotifyActor() actor is about to be created" );
        logger->log( msg.c_str() );
        return true;
}

// brief Pre-notification event before a triangle mesh is created.
// return true to create the triangle mesh or false to skip it.
bool NxuUserNotify::NXU_preNotifyTriangleMesh(NxTriangleMeshDesc& t,const char* userProperties)
{
        stringc msg( "NXU_preNotifyTriangleMesh() triangle mesh is about to be created" );
        logger->log( msg.c_str() );
        return true;
}

// brief Pre-notification event before a SceneInstance is executed.
// return true to execute the scene instance.
bool NxuUserNotify::NXU_preNotifySceneInstance(const char* name,const char* sceneName,const char* userProperties,NxMat34& rootNode,NxU32 depth)
{
        stringc msg( "NXU_preNotifySceneInstance() scene is about to be instantiated" );
        logger->log( msg.c_str() );
        return true;
}

// brief Notification event because a scene failed to be created.
void NxuUserNotify::NXU_notifySceneFailed(unsigned int sno, NxSceneDesc& scene, const char* userProperties)
{
        stringc msg( "NXU_notifySceneFailed() scene create failed" );
        logger->log( msg.c_str() );
}

// brief Notification event that an actor failed to be created.
void NxuUserNotify::NXU_notifyActorFailed(NxActorDesc& actor, const char* userProperties)
{
        stringc msg( "NXU_notifyActorFailed() actor create failed. name=" );
        msg += actor.name;
        logger->log( msg.c_str() );
}

// brief Notification event that a triangle mesh failed to be created.
void NxuUserNotify::NXU_notifyTriangleMeshFailed(NxTriangleMeshDesc& t,const char* userProperties)
{
        stringc msg( "NXU_notifyTriangleMeshFailed() triangle mesh create failed" );
        logger->log( msg.c_str() );
}

---