physxWrapper.cpp

#include "main.h"
#include "NXU_helper.h"
#include "registry.h"
#include "physxDebugHelper.h"
#include "physxWrapper.h"



// only visible within this file
static NxDebugOutput*   nxDebugOutput   = NULL;
static NxuDebugOutput*  nxuDebugOutput  = NULL;
static NxuUserNotify*   nxuUserNotify   = NULL;


// init physX and setup global symbols from main.h
ERR_TYPE physxInit()
{
        // check if physX is installed on this machine
        Registry reg;
        stringc corePath("");
        u32 version = 0;
        ERR_TYPE result = ERR_OK;
        stringc logOutput("");
        result = reg.queryValue( "SOFTWARE\\AGEIA Technologies", "PhysXCore Path", &corePath );
        if ( ERR_OK == result )
        {
                logOutput = "Found PhysXCore Path: ";
                logOutput += corePath;
                logger->log( logOutput.c_str() );
        }
        result = reg.queryValue( "SOFTWARE\\AGEIA Technologies", "PhysX Version", &version );
        if ( ERR_OK == result )
        {
                logOutput = "Found PhysX Version: ";
                logOutput += version;
                logger->log( logOutput.c_str() );
        }

        logOutput = "Compiled PhysX version = ";
        logOutput += NX_SDK_VERSION_MAJOR;
        logOutput += ".";
        logOutput += NX_SDK_VERSION_MINOR;
        logOutput += ".";
        logOutput += NX_SDK_VERSION_BUGFIX;
        logger->log( logOutput.c_str() );

        if ( ERR_OK != result )
        {
                // physiX is not installed
                logger->log( "PhysX is not installed..." );
                {
                        // set fake "PhysXCore Path"
                        logger->log( "Trying to create temporary key in registry: HKEY_LOCAL_MACHINE\\SOFTWARE\\AGEIA Technologies\\PhysXCore Path" );
                        stringc key("SOFTWARE\\AGEIA Technologies");
                        stringc name("PhysXCore Path");
                        stringc value("");
                        reg.getProcessPath( &value );
                        result = reg.addValue( key.c_str(), name.c_str(), value.c_str() );
                        if ( ERR_OK != result )
                        {
                                logger->log( "Failed to create fake-key: PhysXCore Path" );
                        }
                }
                {
                        // set fake "PhysX Version"
                        logger->log( "Trying to create temporary key in registry: HKEY_LOCAL_MACHINE\\SOFTWARE\\AGEIA Technologies\\PhysX Version" );
                        stringc key("SOFTWARE\\AGEIA Technologies");
                        stringc name("PhysX Version");
                        u32 value = 70625;      // seems to be some magic number :)
                        result = reg.addValue( key.c_str(), name.c_str(), value );
                        if ( ERR_OK != result )
                        {
                                logger->log( "Failed to create fake-key: PhysX Version" );
                        }
                }
                {
                        // set fake "enableLocalPhysXCore"
                        logger->log( "Trying to create temporary key in registry: HKEY_LOCAL_MACHINE\\SOFTWARE\\AGEIA Technologies\\enableLocalPhysXCore" );
                        stringc key("SOFTWARE\\AGEIA Technologies");
                        stringc name("enableLocalPhysXCore");
                        u32 value = 1;
                        result = reg.addValue( key.c_str(), name.c_str(), value );
                        if ( ERR_OK != result )
                        {
                                logger->log( "Failed to create fake-key: enableLocalPhysXCore" );
                        }
                }
        }

    // Create the physics SDK
        NxUserAllocator* allocator = NULL;
        const NxPhysicsSDKDesc& desc = NxPhysicsSDKDesc();
        NxSDKCreateError errorCode = NXCE_NO_ERROR;
        
        nxDebugOutput = new NxDebugOutput();

        // searchs for several keys in: hkey_local_machine\software\ageia technologies
        // if not found errorCode is: NXCE_PHYSX_NOT_FOUND
        // and returns NULL
        nxSDK = NxCreatePhysicsSDK( NX_PHYSICS_SDK_VERSION,             // version 2.7.2
                                                                allocator,
                                                                nxDebugOutput,
                                                                desc,
                                                                &errorCode );
    if ( NULL == nxSDK )
    {
                stringc error("*** physX createSDK() failed *** errorCode = ");
        error += errorCode;

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

        return ERR_PHYSX_INIT_FAILED;
    }



#if(0) // below is replaced by XML file
        
        // Set physical parameters
    NxReal scale = 1.0f;   // scale is meters per PhysX units
    nxSDK->setParameter( NX_SKIN_WIDTH, 0.05f *(1.0f / scale) );
    nxSDK->setParameter( NX_DEFAULT_SLEEP_LIN_VEL_SQUARED, 1.41f * 1.41f * (1.0f/scale)*(1.0f/scale) );
    nxSDK->setParameter( NX_BOUNCE_THRESHOLD, -2.0f * (1.0f / scale) );

    // Set the debug visualization parameters
    nxSDK->setParameter( NX_VISUALIZATION_SCALE, 60.0f * (1.0f / scale) );
        nxSDK->setParameter( NX_VISUALIZE_COLLISION_SHAPES, 1 );
    nxSDK->setParameter( NX_VISUALIZE_ACTOR_AXES, 1 );
        nxSDK->setParameter( NX_VISUALIZE_COLLISION_FNORMALS, 1 );
        nxSDK->setParameter( NX_VISUALIZE_JOINT_LIMITS, 1 );
        nxSDK->setParameter( NX_VISUALIZE_JOINT_WORLD_AXES, 1 );

#endif



        // setup XLM data error output handler
        nxuDebugOutput = new NxuDebugOutput();
        NXU::setErrorReport( nxuDebugOutput );

        // create XML create/preCreate/failed notification callback
        nxuUserNotify = new NxuUserNotify();

        // load XML data-driven scene
        NXU::NxuPhysicsCollection* nxuCollection = NULL;
        nxuCollection = NXU::loadCollection( "../../media/table_v5.xml", NXU::FT_XML );
        if ( NULL == nxuCollection )
        {
                logger->log( "Failed loading PhysX XML dataset" );
                return ERR_PHYSX_INIT_FAILED;
        }

        // create scene from XML data
        NxScene* dummyScene = NULL;
        NxMat34* dummyRootNode = NULL;
        bool status = NXU::instantiateCollection(       nxuCollection,
                                                                                                *nxSDK,
                                                                                                dummyScene,
                                                                                                dummyRootNode,
                                                                                                nxuUserNotify );
        if ( status != true )
        {
                logger->log( "Cannot create NxScene from PhysX XML dataset" );
                return ERR_PHYSX_INIT_FAILED;   
        }

        // get the XML created scene
        nxScene = nxSDK->getScene( 0 );
    if ( NULL == nxScene )
    {
        return ERR_PHYSX_INIT_FAILED;
    }


#if(0)
        // dump some info about loaded actors
        u32 nActors = nxScene->getNbActors();
        NxActor** actors = nxScene->getActors();
        for (u32 i=0; i<nActors; i++)
        {
                NxActor* tempActor = *actors;
                stringc actorName( tempActor->getName() );

                stringc info( "found actor[" );
                info += i;
                info += "] name=";
                info += actorName;
                info += "  mass=";
                info += tempActor->getMass();
                logger->log( info.c_str() );

                if ( actorName.equals_ignore_case( "Box01" ) )
                {
                                // temp tweak
                                //tempActor->setGlobalOrientation( 3*PI/2 );
                }

                *actors++;
        }
#endif  


#if(0)  // below is replaced by XML file
    
        // Create the scene
    NxSceneDesc sceneDesc;

        // set gravity
    sceneDesc.gravity = NxVec3(0.0f, -9.8f, 0.0f);;

        // we use software physics, no hardware accelerator
    sceneDesc.simType = NX_SIMULATION_SW;

        // setting proper scene bounds speeds up raycasts against dynamic actors
        NxBounds3 sceneBounds;
        sceneBounds.min = NxVec3( -1000.0f, -1000.0f, -1000.0f );       // 1k left from center, 1k down, 1k to user
        sceneBounds.max = NxVec3(  1000.0f,  1000.0f,  1000.0f );       // 1k right from center, 1k up, 1k into space
        sceneDesc.maxBounds = &sceneBounds;
        sceneDesc.boundsPlanes = true;
    
    nxScene = nxSDK->createScene(sceneDesc);
    if ( NULL == nxScene )
    {
        return ERR_PHYSX_INIT_FAILED;
    }

    // Create the default material
    NxMaterial* defaultMaterial = nxScene->getMaterialFromIndex( 0 );
    defaultMaterial->setRestitution( 0.5f );            // bounce of objects
    defaultMaterial->setStaticFriction( 0.5f );         // friction causes heat
    defaultMaterial->setDynamicFriction( 0.5f );

#endif  // testing scene loading from XML dataset


        // iterate all found materials in XML and apply own settings
        for ( NxMaterialIndex i=0; i<nxScene->getHighestMaterialIndex(); i++ )
        {
                NxMaterial* material = nxScene->getMaterialFromIndex( i );
                if ( NULL != material )
                {
                        material->setRestitution( 0.2f );               // bounce of objects
                        material->setStaticFriction( 0.1f );    // friction causes heat
                        material->setDynamicFriction( 0.1f );
                }
        }

        // lets talk to physX remote debugger by socket communication
        nxSDK->getFoundationSDK().getRemoteDebugger()->connect( "localhost", 5425 );

    return ERR_OK;
}


// to be called every frame
ERR_TYPE physxUpdate()
{
    // Start collision and dynamics for delta time since the last frame
        nxScene->simulate( physxGetDeltaTime() / 100.0f );
    nxScene->flushStream();

        // Get results from nxScene->simulate(deltaTime)
        while ( ! nxScene->fetchResults(NX_RIGID_BODY_FINISHED, false) )
        {
                // loops usually up to 20 times
        }

    return ERR_OK;
}


// destroy physX
ERR_TYPE physxDeinit()
{
    if ( nxScene && nxSDK )
    {
        //TODO GetPhysicsResults();  // Make sure to fetchResults() before shutting down
        nxSDK->releaseScene( *nxScene );
                nxScene = NULL;
    }
    if ( nxSDK )
    {
        nxSDK->release();
                nxSDK = NULL;
    }
        if ( nxDebugOutput )
        {
                delete nxDebugOutput;
                nxDebugOutput = NULL;
        }
        if ( nxuDebugOutput )
        {
                delete nxuDebugOutput;
                nxuDebugOutput = NULL;
        }
        if ( nxuUserNotify )
        {
                delete nxuUserNotify;
                nxuUserNotify = NULL;
        }
        
    return ERR_OK;
}


// returns milliseconds since last call
u32 physxGetDeltaTime()
{
        static u32 oldTime = timer->getRealTime();

    // Update the time step
        // getRealTime() is the irrlicht QueryPerformancCounter() Win32 imlpementation
        u32 now = timer->getRealTime();
        u32 deltaTime = now - oldTime;
        oldTime = now;

        return deltaTime;
}

---