D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/Framework/Physics/spPhysicsSimulator.hpp

Go to the documentation of this file.

/*
 * Physics simulator header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_PHYSICS_SYSTEM_H__
#define __SP_PHYSICS_SYSTEM_H__


#include "Base/spStandard.hpp"

#ifdef SP_COMPILE_WITH_PHYSICS


#include "Base/spDimensionVector3D.hpp"
#include "Framework/Physics/spPhysicsRigidBody.hpp"
#include "Framework/Physics/spPhysicsStaticObject.hpp"
#include "Framework/Physics/spPhysicsMaterial.hpp"
#include "Framework/Physics/spPhysicsJoint.hpp"

#include <boost/function.hpp>


namespace sp
{
namespace scene
{
    class Mesh;
}
namespace physics
{


typedef boost::function<void (const dim::vector3df &Point, const dim::vector3df &Normal, f32 Velocity)> PhysicsContactCallback;


enum EPhysicsSimulators
{
    SIMULATOR_NEWTON,   
    SIMULATOR_PHYSX,    
    SIMULATOR_BULLET,   
};


class SP_EXPORT PhysicsSimulator
{
    
    public:
        
        virtual ~PhysicsSimulator();
        
        virtual io::stringc getVersion() const = 0;
        
        virtual void updateSimulation(const f32 StepTime = 1.0f / 60.0f) = 0;
        
        virtual void setGravity(const dim::vector3df &Gravity);
        
        /*
        Creates a new physics material
        \param StaticFriction: Specifies the static friction factor in the range [0.0 .. 1.0].
        \param DynamicFriction: Specifies the dynamic friction factor in the range [0.0 .. 1.0].
        \param Restitution: Specifies the restitution factor (or rather bounce factor) in the range [0.0 .. 1.0].
        \return Pointer to the new PhysicsMaterial object.
        */
        virtual PhysicsMaterial* createMaterial(
            f32 StaticFriction = 0.5f, f32 DynamicFriction = 0.5f, f32 Restitution = 0.3f
        ) = 0;
        virtual void deleteMaterial(PhysicsMaterial* Material);
        
        virtual StaticPhysicsObject* createStaticObject(PhysicsMaterial* Material, scene::Mesh* Mesh) = 0;
        
        virtual void deleteStaticObject(StaticPhysicsObject* Object);
        
        virtual RigidBody* createRigidBody(
            PhysicsMaterial* Material, const ERigidBodies Type, scene::SceneNode* RootNode,
            const SRigidBodyConstruction &Construct = SRigidBodyConstruction()
        ) = 0;
        
        virtual RigidBody* createRigidBody(PhysicsMaterial* Material, scene::Mesh* Mesh) = 0;
        
        virtual void deleteRigidBody(RigidBody* Object);
        
        virtual PhysicsJoint* createJoint(
            const EPhysicsJoints Type, PhysicsBaseObject* Object, const SPhysicsJointConstruct &Construct
        ) = 0;
        
        virtual PhysicsJoint* createJoint(
            const EPhysicsJoints Type, PhysicsBaseObject* ObjectA, PhysicsBaseObject* ObjectB, const SPhysicsJointConstruct &Construct
        ) = 0;
        
        virtual void deleteJoint(PhysicsJoint* Object);
        
        virtual void clearScene(bool RigidBodies = true, bool StaticObjects = true, bool Joints = true);
        
        virtual void setThreadCount(s32 Count);
        virtual s32 getThreadCount() const;
        
        virtual void setSolverModel(s32 Model);
        
        static void setContactCallback(const PhysicsContactCallback &Callback);
        
        static PhysicsContactCallback getContactCallback();
        
        /* === Inline functions === */
        
        inline EPhysicsSimulators getType() const
        {
            return Type_;
        }
        
        inline dim::vector3df getGravity() const
        {
            return Gravity_;
        }
        
        inline std::list<RigidBody*> getRigidBodyList() const
        {
            return RigidBodyList_;
        }
        inline std::list<StaticPhysicsObject*> getStaticBodyList() const
        {
            return StaticBodyList_;
        }
        inline std::list<PhysicsMaterial*> getMaterialList() const
        {
            return MaterialList_;
        }
        inline std::list<PhysicsJoint*> getJointList() const
        {
            return JointList_;
        }
        
    protected:
        
        /* === Functions === */
        
        PhysicsSimulator(const EPhysicsSimulators Type);
        
        /* === Members === */
        
        EPhysicsSimulators Type_;
        
        std::list<RigidBody*> RigidBodyList_;
        std::list<StaticPhysicsObject*> StaticBodyList_;
        std::list<PhysicsMaterial*> MaterialList_;
        std::list<PhysicsJoint*> JointList_;
        
        dim::vector3df Gravity_;
        
        static PhysicsContactCallback ContactCallback_;
        
};


} // /namespace physics

} // /namespace sp


#endif

#endif



// ================================================================================