E:/Programming/MyProject/K_Game_hg/GameEngine/include/physics/PhysicsManager.h

Go to the documentation of this file.

// Copyright 2006-2011 by Kat'Oun

#ifndef _PHYSICS_MANAGER_H_
#define _PHYSICS_MANAGER_H_

#include <EngineConfig.h>
#include <core/Types.h>
#include <core/Singleton.h>
#include <core/Vector3d.h>
#include <core/Quaternion.h>
#include <resource/Resource.h>
#include <resource/ResourceManager.h>
#include <physics/CollisionEventReceiver.h>
#include <engine/Object.h>

#include <string>
#include <map>

namespace scene
{
class Node;
}

namespace physics
{

class Body;
class BodyFactory;
class BodyData;
class BodyDataFactory;
class Shape;
class ShapeFactory;
class Joint;
class JointFactory;
class Material;
class PhysicsDriver;
struct CollisionPoint;
struct CollisionEvent;
enum BodyType;
enum ShapeType;
enum JointType;

class ENGINE_PUBLIC_EXPORT PhysicsManager: public engine::Object, public core::Singleton<PhysicsManager>
{
        friend class PhysicsDriver;

public:

        // Default Constructor
        PhysicsManager();

        ~PhysicsManager();

        void initialize();
        
        void start();

        void stop();

        void setHardware(bool state);

        void setCollisionAccuracy(f32 accuracy);
        void setSolverAccuracy(f32 accuracy);

        void setGravity(const core::vector3d& gravity);

        Body* createBody(const std::string& bodyFilename, scene::Node* parent = NULL);
        Body* createBody(const std::string& name, const std::string& bodyFilename, scene::Node* parent = NULL);

        Body* createBody(BodyData* bodyData, scene::Node* parent = NULL);
        Body* createBody(const std::string& name, BodyData* bodyData, scene::Node* parent = NULL);

        Body* getBody(const u32& id);

        u32 getNumberOfBodies() const;

        void removeBody(Body *actor);
        void removeBody(const u32& id);
        void removeAllBodies();

        Shape* createShape(ShapeType type);

        Joint* createJoint(JointType type);
        Joint* createJoint(const std::string& name, JointType type);

        Joint* getJoint(const u32& id);

        u32 getNumberOfJoints() const;

        void removeJoint(Joint *joint);
        void removeJoint(const u32& id);
        void removeAllJoints();

        Material* createMaterial(const std::string& materialFilename);

        void addCollisionEventReceiver(CollisionEventReceiver* newEventReceiver);
        void removeCollisionEventReceiver(CollisionEventReceiver* oldEventReceiver);

        void setPhysicsDriver(PhysicsDriver* driver);
        void removePhysicsDriver();

        void setBodyFactory(BodyFactory* factory);
        void removeBodyFactory();

        void setShapeFactory(ShapeFactory* factory);
        void removeShapeFactory();

        void setJointFactory(JointFactory* factory);
        void removeJointFactory();

        void registerDefaultFactories();
        void removeDefaultFactories();

        static PhysicsManager* getInstance();

private:

        static void fireCollisionStarted(Body* body1, Body* body2, const std::vector<CollisionPoint*>& points);

        static void fireCollisionUpdate(Body* body1, Body* body2, const std::vector<CollisionPoint*>& points);

        static void fireCollisionEnded(Body* body1, Body* body2);

protected:

        void initializeImpl();
        void uninitializeImpl();
        void updateImpl(f32 elapsedTime);

        BodyDataFactory* mDefaultBodyDataFactory;
        
        PhysicsDriver* mPhysicsDriver;

        static CollisionEvent* mCollisionEvent;
        static std::list<CollisionEventReceiver*> mCollisionEventReceivers;

        std::map<u32, Body*> mBodies;

        std::map<u32, Joint*> mJoints;

        std::map<u32, Material*> mMaterials;

        BodyFactory* mBodyFactory;
        ShapeFactory* mShapeFactory;
        JointFactory* mJointFactory;

        bool mUpdatePhysics;

        bool mHardware;
        f32 mCollisionAccuracy;
        f32 mSolverAccuracy;

        core::vector3d mGravity;
};

} // end namespace physics

#endif