Environement.hpp

Go to the documentation of this file.

#pragma once

namespace ege {
    class Environement;
    class ElementInteraction;
};
#include <ege/camera/Camera.hpp>
#include <ege/ParticuleEngine.hpp>

#include <etk/types.hpp>
#include <BulletDynamics/Dynamics/btActionInterface.h>
class btDynamicsWorld;

#include <vector>
#include <etk/math/Vector3D.hpp>
#include <ejson/ejson.hpp>
#include <exml/exml.hpp>
#include <ewol/object/Object.hpp>
#include <esignal/Signal.hpp>
#include <ewol/event/Time.hpp>
#include <eproperty/Value.hpp>
#include <ege/resource/Mesh.hpp>
#include <ege/physics/Engine.hpp>

namespace ege {
    class Element;
    class Environement;
    typedef ememory::SharedPtr<ege::Element> (*createElement_tf)(const ememory::SharedPtr<ege::Environement>& _env);
    
    enum gameStatus {
        gameStart,
        gamePause,
        gameStop
    };
    
    class ElementInteraction {
        protected:
            int32_t m_type;
        public:
            int32_t getType() {
                return m_type;
            };
        protected:
            int32_t m_groupSource;
        public:
            int32_t getSourceGroup() {
                return m_groupSource;
            };
        protected:
            std::vector<int32_t> m_groupDestination;
        public:
            const std::vector<int32_t>& getDestinationGroup() {
                return m_groupDestination;
            };
            void addGroupDestination(int32_t _id) {
                m_groupDestination.push_back(_id);
            };
        protected:
            vec3 m_positionSource;
        public:
            const vec3& getSourcePosition() {
                return m_positionSource;
            };
        public:
            ElementInteraction(int32_t _type, int32_t _groupSource, const vec3& _pos) : 
                m_type(_type),
                m_groupSource(_groupSource),
                m_positionSource(_pos)
            { };
        public:
            virtual void applyEvent(ege::Element& _element) { };
    };
    
    class Environement : public ewol::Object {
        public:
            // Signals
            esignal::Signal<float> signalPlayTimeChange;
            // properties:
            eproperty::List<enum gameStatus> propertyStatus; 
            eproperty::Value<float> propertyRatio; 
        private:
            //ememory::SharedPtr<btDynamicsWorld> m_dynamicsWorld; //!< curent system world description
            ege::physics::Engine m_physicEngine; 
            std::vector<ememory::SharedPtr<ege::Element>> m_listElement; 
        protected:
            Environement();
        public:
            DECLARE_FACTORY(Environement);
            virtual ~Environement() { };
        protected:
        protected:
            std::map<std::string, ememory::SharedPtr<ege::Camera>> m_listCamera; 
        public:
            void addCamera(const std::string& _name, const ememory::SharedPtr<ege::Camera>& _camera);
            ememory::SharedPtr<ege::Camera> getCamera(const std::string& _name);
            std::map<std::string, ememory::SharedPtr<ege::Camera>> getCameraList() const {
                return m_listCamera;
            }
        public:
            void clear();
            static void addCreator(const std::string& _type, ege::createElement_tf _creator);
            ememory::SharedPtr<ege::Element> createElement(const std::string& _type, const std::string& _description, bool _autoAddElement=true);
            ememory::SharedPtr<ege::Element> createElement(const std::string& _type, const ejson::Value& _value, bool _autoAddElement=true);
            ememory::SharedPtr<ege::Element> createElement(const std::string& _type, const exml::Node& _node, bool _autoAddElement=true);
            ememory::SharedPtr<ege::Element> createElement(const std::string& _type, void* _data, bool _autoAddElement=true);
            ememory::SharedPtr<ege::Element> createElement(const std::string& _type, bool _autoAddElement=true);
        public:
            class ResultNearestElement {
                public:
                    ememory::SharedPtr<ege::Element> element;
                    float dist;
            };
            #if 0

            void setDynamicWorld(const ememory::SharedPtr<btDynamicsWorld>& _newWorld) {
                m_dynamicsWorld=_newWorld;
            };
            ememory::SharedPtr<btDynamicsWorld> getDynamicWorld() {
                return m_dynamicsWorld;
            };
            #endif
            ege::physics::Engine& getPhysicEngine() {
                return m_physicEngine;
            }
            std::vector<ememory::SharedPtr<ege::Element>>& getElement() {
                return m_listElement;
            };
            ememory::SharedPtr<ege::Element> getElementNearest(ememory::SharedPtr<ege::Element> _sourceRequest, float& _distance);
            
            void getElementNearest(const vec3& _sourcePosition,
                                   float _distanceMax,
                                   std::vector<ege::Environement::ResultNearestElement>& _resultList);
            void getElementNearestFixed(const vec3& _sourcePosition,
                                        float _distanceMax,
                                        std::vector<ege::Environement::ResultNearestElement>& _resultList);
            void addElement(ememory::SharedPtr<ege::Element> _newElement);
            void rmElement(ememory::SharedPtr<ege::Element> _removeElement);
            void getOrderedElementForDisplay(std::vector<ege::Environement::ResultNearestElement>& _resultList, const vec3& _position, const vec3& _direction);
            void generateInteraction(ege::ElementInteraction& _event);
        private:
            ege::ParticuleEngine m_particuleEngine; 
        public:
            ege::ParticuleEngine& getParticuleEngine() {
                return m_particuleEngine;
            };
        protected:
            int64_t m_gameTime; 
        public:
            esignal::Connection m_periodicCallConnection;
        private:
            void onCallbackPeriodicCall(const ewol::event::Time& _event);
        protected:
            std::vector<ememory::SharedPtr<ege::resource::Mesh>> m_listMeshToDrawFirst;
        public:
            void addStaticMeshToDraw(const ememory::SharedPtr<ege::resource::Mesh>& _mesh) {
                m_listMeshToDrawFirst.push_back(_mesh);
            }
            std::vector<ememory::SharedPtr<ege::resource::Mesh>>& getStaticMeshToDraw() {
                return m_listMeshToDrawFirst;
            }
            virtual void onChangePropertyStatus();
    };
}