Engine.hpp

Go to the documentation of this file.

#pragma once

namespace ege {
    namespace physics {
        class Engine;
    };
};
#include <etk/types.hpp>
#include <etk/math/Vector3D.hpp>
#include <etk/math/Matrix4.hpp>
#include <vector>
#include <ewol/debug.hpp>
#include <ege/camera/Camera.hpp>
#include <ewol/widget/Widget.hpp>
#include <gale/renderer/openGL/openGL.hpp>
#include <gale/resource/Manager.hpp>
#include <gale/Dimension.hpp>


class btBroadphaseInterface;
class btCollisionShape;
class btOverlappingPairCache;
class btCollisionDispatcher;
class btConstraintSolver;
struct btCollisionAlgorithmCreateFunc;
class btDefaultCollisionConfiguration;
class btDynamicsWorld;
#include <LinearMath/btScalar.h>
class btVector3;


//#include <ege/elements/Element.h>

namespace ege {
    namespace physics {
        class Engine {
            private:
                ememory::SharedPtr<btDefaultCollisionConfiguration> m_collisionConfiguration;
                ememory::SharedPtr<btCollisionDispatcher> m_dispatcher;
                ememory::SharedPtr<btBroadphaseInterface> m_broadphase;
                ememory::SharedPtr<btConstraintSolver> m_solver;
                ememory::SharedPtr<btDynamicsWorld> m_dynamicsWorld;
            public:
                Engine();
                ~Engine();
                void setBulletConfig(ememory::SharedPtr<btDefaultCollisionConfiguration> _collisionConfiguration=nullptr,
                                     ememory::SharedPtr<btCollisionDispatcher> _dispatcher=nullptr,
                                     ememory::SharedPtr<btBroadphaseInterface> _broadphase=nullptr,
                                     ememory::SharedPtr<btConstraintSolver> _solver=nullptr,
                                     ememory::SharedPtr<btDynamicsWorld> _dynamicsWorld=nullptr);
                void setDynamicWorld(const ememory::SharedPtr<btDynamicsWorld>& _newWorld) {
                    m_dynamicsWorld=_newWorld;
                };
                ememory::SharedPtr<btDynamicsWorld> getDynamicWorld() {
                    return m_dynamicsWorld;
                };
            public:
                // Define a collision point ==> for debug only ...
                class collisionPoints {
                    public:
                        ememory::SharedPtr<ege::Element> elem1;
                        ememory::SharedPtr<ege::Element> elem2;
                        vec3 positionElem1;
                        vec3 positionElem2;
                        vec3 normalElem2;
                        collisionPoints(const ememory::SharedPtr<ege::Element>& _elem1,
                                        const ememory::SharedPtr<ege::Element>& _elem2,
                                        const vec3& _pos1,
                                        const vec3& _pos2,
                                        const vec3& _normal) :
                          elem1(_elem1),
                          elem2(_elem2),
                          positionElem1(_pos1),
                          positionElem2(_pos2),
                          normalElem2(_normal) { }
                };
                std::vector<ege::physics::Engine::collisionPoints> getListOfCollision();
        };
    }
}