PhysX 3.2 crasht bei Kollisions Kontakt

Werbeanzeige

LukasBanana

Alter Hase

Beiträge: 1 097

Beruf: Shader Tools Programmer

20.06.2012, 22:56

PhysX 3.2 crasht bei Kollisions Kontakt

Hi,
ich habe vor zwei Tagen angefangen mich in das PhysX SDK ein zu arbeiten, aber leider stoße ich jetzt schon auf ein sehr merkwürdiges Problem.
Sobald meine RigidBodies (PxRigidDynamic) mit dem Boden (PxRigidStatic) - einer einfachen Plane - kollidieren, stürtzt das Program ab wegen 'Access violation' in der Datei "mlock.c":

	C-/C++-Quelltext
1 2 3 4 5 6 7 8 9	void __cdecl _unlock ( int locknum ) { /* * leave the critical section. */ LeaveCriticalSection( _locktable[locknum].lock ); }

Ich nehme mal an, die Datei ist von MSVC. Leider kann mir der VisualDebugger von MSVC9 auch nicht weiter helfen.

Hier ist mein Code zum Aufbau der Szene:

C-/C++-Quelltext

class PhysXErrorCallback : public PxErrorCallback
{
    
    public:
        
        PhysXErrorCallback()
        {
        }
        ~PhysXErrorCallback()
        {
        }
        
        void reportError(PxErrorCode::Enum Code, const char *Message, const char *File, int Line)
        {
            io::Log::error("[ PhysX ] " + io::stringc(Message));
        }
        
};

static PxDefaultAllocator DefaultAllocatorCallback;
static PhysXErrorCallback DefaultErrorCallback;
static PxSimulationFilterShader DefaultFilterShader;

PhysXSimulator::PhysXSimulator()
{
    PxFoundation_ = PxCreateFoundation(PX_PHYSICS_VERSION, DefaultAllocatorCallback, DefaultErrorCallback);
    if (!PxFoundation_)
        io::Log::error("Coudl not create PhysX foundation");
    
    PxProfile_ = &PxProfileZoneManager::createProfileZoneManager(PxFoundation_);
    if (!PxProfile_)
        io::Log::error("Could not create PhysX profile zone manager");
    
    bool RecordMemoryAllocations = true;
    
    PxDevice_ = PxCreatePhysics(
        PX_PHYSICS_VERSION, *PxFoundation_, PxTolerancesScale(), RecordMemoryAllocations, PxProfile_
    );
    if (!PxDevice_)
        io::Log::error("Could not create PhysX device");
    
    PxCooking_ = PxCreateCooking(PX_PHYSICS_VERSION, *PxFoundation_, PxCookingParams());
    if (!PxCooking_)
        io::Log::error("Could not create PhysX cooking device");
    
    if (!PxInitExtensions(*PxDevice_))
        io::Log::error("Could not initialize PhysX extensions");
    
    PxScene_ = createScene();
    
    PxMaterial_ = PxDevice->createMaterial(StaticFriction, DynamicFriction, Restitution);
    if (!PxMaterial_)
        io::Log::error("Could not create PhysX material");
}

PxScene* PhysXSimulator::createScene()
{
    PxSceneDesc SceneDesc(PxDevice_->getTolerancesScale());
    
    SceneDesc.gravity       = convert(Gravity_);
    SceneDesc.cpuDispatcher = PxDefaultCpuDispatcherCreate(1);
    SceneDesc.filterShader  = DefaultFilterShader;
    
    if (!SceneDesc.cpuDispatcher)
        io::Log::error("Could not create PhysX CPU dispatcher");
    
    PxScene* NewScene = PxDevice_->createScene(SceneDesc);
    
    if (!NewScene)
        io::Log::error("Could not create PhysX scene");
    
    NewScene->setVisualizationParameter(PxVisualizationParameter::eSCALE, 1.0f);
    NewScene->setVisualizationParameter(PxVisualizationParameter::eCOLLISION_SHAPES, 1.0f);
    
    return NewScene;
}

void PhysXSimulator::CreateRigidBody(const float* Matrix4x4, float Mass)
{
    PxRigidDynamic* Actor = PxDevice->createRigidDynamic(PxTransform(PxMat44(Matrix4x4)));
    
    if (Actor)
    {
        Actor->createShape(
            PxBoxGeometry(Construct.Size.X, Construct.Size.Y, Construct.Size.Z),
            *PxMaterial_
        );
        
        Actor->setMass(Mass);
        PxRigidBodyExt::updateMassAndInertia(*Actor, Mass);
    }
}

void PhysXSimulator::CreateStaticObject()
{
    PxRigidStatic* Actor = PxDevice->createRigidStatic(
        PxTransform(PxVec3(0.0f), PxQuat(PxHalfPi, PxVec3(0.0f, 0.0f, 1.0f)))
    );
    
    if (Actor)
        Actor->createShape(PxPlaneGeometry(), *PxMaterial_);
}

void PhysXSimulator::UpdateSimulation()
{
    if (PxScene_)
    {
        PxScene_->simulate(StepTime);
        PxScene_->fetchResults(true);
    }
}