PhysXManager.h

Go to the documentation of this file.

#pragma once

#include <NxPhysics.h>
#include "SweepSurface.h"
#include "Utils.h"
#include "Hoop.h"
#include <Windows.h>
#include <ctime>
#include "DAEnvironment.h"

#pragma comment(lib, "PhysXLoader.lib")

namespace APDYNAMICART
{

struct SimulationParameters 
{
    double detailCoef;
    double hoopDensity;
    double stringSpring;
    double stringDamper;

    SimulationParameters() :
        detailCoef(0.70),
        hoopDensity(900),
        stringSpring(0),
        stringDamper(0)
    {}
};

class PhysXManager
{

public:
    static PhysXManager* get()
    {
        static PhysXManager manager;
        return &manager;
    }

    static inline NxQuat toNxQuat( const osg::Quat& qRot );
    static inline NxVec3 toNxVec3( const osg::Vec3& point );
    static inline osg::Vec3 toOsgVec3( const NxVec3& point);
    static inline osg::Quat toOsgQuat( const NxQuat& qRot);
    static inline osg::Matrix getDAMatrix();


    void releasePhysics();
    bool init();
    bool createScene();
    void getPhysicsResult();
    void startPhysics();
    NxActor* addHoopActorToScene( Hoop* hoop, NxVec3 linearVelocity = NxVec3(0.2,0.0,-1.0) );
    void setStringJoints(HoopPtr first, HoopPtr second, Vec3ArrayPtr points);
    void setActorPosition(HoopPtr hoop);
    void setActorOrientation(HoopPtr hoop);
    void addForceToHoop(HoopPtr hoop, const osg::Vec3& direction);
    void resetScene();
    void releaseHoopActor(HoopPtr hoop);
    void releaseHoopJoints();
    void createRope(HoopPtr hoop, const osg::Vec3& pos, double segHeight, double radius, unsigned int segments);
    const std::vector<NxActor*>&  getRopeActors() const;
    SimulationParameters& getSimualtionParameters() { return _parameters; }

    bool isRunning() const { return _simulationRunning; }
    void setSimulationRun(bool val) { _simulationRunning = val; }

protected:
    PhysXManager();

    inline NxVec3 transformToLocalCoord( Hoop* hoop, const osg::Vec3& point );
    NxSphericalJoint* createRopeSphericalJoint(NxActor* a0, NxActor* a1, const NxVec3& globalAnchor, const NxVec3& globalAxis);
    NxActor* createCapsule(const NxVec3& pos, const NxReal height, const NxReal radius);   

    NxPhysicsSDK* _physicsSDK;
    NxScene*      _scene;
    float         _deltaTime;
    bool          _simulationRunning;
    NxVec3        _linearVelocity;
    SimulationParameters _parameters;
    
    std::vector<NxJoint*>          _joints;
    std::vector<NxActor*>          _ropeSegs;
    std::vector<NxSphericalJoint*> _ropeLinks;
};

NxQuat PhysXManager::toNxQuat( const osg::Quat &qRot )
{
    NxQuat result;
    result.x=qRot.x();
    result.y=qRot.y();
    result.z=qRot.z();
    result.w=qRot.w();

    return result;
}

NxVec3 PhysXManager::toNxVec3( const osg::Vec3& point )
{
    return point._v;
}

osg::Vec3 PhysXManager::toOsgVec3( const NxVec3& point )
{
    return osg::Vec3(point.x, point.y, point.z);
}

osg::Quat PhysXManager::toOsgQuat( const NxQuat& qRot )
{
    return osg::Quat(qRot.x, qRot.y, qRot.z, qRot.w);
}

inline NxVec3 PhysXManager::transformToLocalCoord( Hoop* hoop, const osg::Vec3& point )
{
    osg::Vec3 localPoint = hoop->getMatrix().getRotate().inverse() * (point - hoop->getPosition());
    return toNxVec3(localPoint);
}

osg::Matrix PhysXManager::getDAMatrix()
{
    EnvironmentObject* eo = (EnvironmentObject*)(DAEnvironment::getInstance()->getOwner());
    return eo->getMatrix();
}

}