ElementPhysic.hpp

Go to the documentation of this file.

#pragma once

#include <etk/types.hpp>
#include <etk/math/Vector3D.hpp>
#include <etk/math/Matrix4.hpp>
#include <vector>
#include <ewol/debug.hpp>
#include <ewol/widget/Widget.hpp>
#include <gale/renderer/openGL/openGL.hpp>
#include <ewol/resource/Colored3DObject.hpp>
#include <ege/resource/Mesh.hpp>
#include <ege/camera/Camera.hpp>
#include <ewol/compositing/Text.hpp>
#include <ege/Environement.hpp>
#include <ege/elements/Element.hpp>

#include <LinearMath/btDefaultMotionState.h>

#define INDEX_RIGHT_AXIS   (0)
#define INDEX_FORWARD_AXIS (1)
#define INDEX_UP_AXIS      (2)

#define ELEMENT_SCALE     (1.0f/8.0f)

namespace ege {
    class ElementPhysic : public ege::Element {
        private:
            static void FunctionFreeShape(void* _pointer);
        protected:
            btRigidBody* m_body; 
        public:
            void createRigidBody(float _mass=400000000.0f);
        public:
            ElementPhysic(const ememory::SharedPtr<ege::Environement>& _env, bool _autoRigidBody=true);
            virtual ~ElementPhysic();
            virtual const std::string& getType() const;
        protected:
            btCollisionShape* m_shape; 
        public:
            bool setShape(btCollisionShape* _shape);
            inline btCollisionShape* getShape() {
                return m_shape;
            };
        private:
            void removeShape();
        public:
            virtual bool setMesh(ememory::SharedPtr<ege::resource::Mesh> _mesh);
            virtual void draw(int32_t _pass=0);
            
            // virtual void drawLife(const ememory::SharedPtr<ewol::resource::Colored3DObject>& _draw, const ememory::SharedPtr<ege::Camera>& _camera);
        // TODO : Remove this ...
        protected:
            vec3 m_theoricPosition;
        public:
            virtual vec3 getPositionTheoric() {
                return m_theoricPosition;
            };
            virtual void setPositionTheoric(const vec3& _pos) { m_theoricPosition = _pos; };
        
            const vec3& getSpeed();
        
            const float getInvMass();
            
            virtual void setMass(float _value);
            virtual void setLinearVelocity(const vec3& _value);
            virtual void setTorqueImpulse(const vec3& _value);
            virtual void setAngularVelocity(const vec3& _value);
            
            btQuaternion getOrientation() const;
            
        protected:
            bool m_elementInPhysicsSystem;
        public:
            virtual void dynamicEnable();
            virtual void dynamicDisable();
        private:
            class localIA : public btActionInterface {
                private:
                    ege::ElementPhysic& m_element;
                public:
                    localIA(ElementPhysic& _element) :
                      m_element(_element) {
                        
                    };
                    virtual ~localIA() {
                        
                    };
                public: // herited function
                    void debugDraw(btIDebugDraw* _debugDrawer) {
                        
                    };
                    void updateAction(btCollisionWorld* _collisionWorld, btScalar _step) {
                        m_element.iaAction(_step);
                    };
            };
            localIA* m_IA;
        public:
            void iaEnable();
            void iaDisable();
            virtual void iaAction(float _step) { };
            virtual void onDestroy() {};
            virtual const vec3& getPosition();
            virtual void setPosition(const vec3& _pos);
            virtual void drawDebug(ememory::SharedPtr<ewol::resource::Colored3DObject> _draw, ememory::SharedPtr<ege::Camera> _camera);
        protected:
            void drawShape(const btCollisionShape* _shape,
                           ememory::SharedPtr<ewol::resource::Colored3DObject> _draw,
                           mat4 _transformationMatrix,
                           std::vector<vec3> _tmpVertices);
        protected:
            bool m_detectCollisionEnable; 
        public:
            bool getCollisionDetectionStatus() {
                return m_detectCollisionEnable;
            }
            void setCollisionDetectionStatus(bool _status=true);
            virtual void onCollisionDetected(const ememory::SharedPtr<ege::Element>& _obj, const vec3& _point, const vec3& _normal) {};
    };
}