Shaper.hpp

Go to the documentation of this file.

#pragma once

#include <ewol/debug.hpp>
#include <ewol/compositing/Compositing.hpp>
#include <gale/resource/Program.hpp>
#include <ewol/resource/ConfigFile.hpp>
#include <ewol/resource/ColorFile.hpp>
#include <ewol/resource/Image.hpp>
#include <ewol/event/Time.hpp>
#include <ewol/Padding.hpp>

namespace ewol {
    namespace compositing {
        enum renderMode {
            renderSingleSquare, 
            renderBorder, 
            renderOneBorder,
        };
        #define SHAPER_NB_MAX_QUAD (5*5)
        #define SHAPER_NB_MAX_TRIANGLE (SHAPER_NB_MAX_QUAD*2)
        #define SHAPER_NB_MAX_VERTEX (SHAPER_NB_MAX_TRIANGLE*3)
        enum shaperPos {
            shaperPosLeft,
            shaperPosRight,
            shaperPosTop,
            shaperPosButtom,
            shaperPosCount,
        };
        // TODO : load image
        // TODO : Abstaraction between states (call by name and the system greate IDs
        class Shaper : public ewol::Compositing {
            private:
                std::string m_name; 
                // External theme config:
                ememory::SharedPtr<ewol::resource::ConfigFile> m_config; 
                int32_t m_confIdPaddingOut[shaperPosCount]; 
                int32_t m_confIdBorder[shaperPosCount]; 
                int32_t m_confIdPaddingIn[shaperPosCount]; 
                int32_t m_confIdMode; 
                int32_t m_confIdDisplayOutside; 
                int32_t m_confIdChangeTime;    
                int32_t m_confProgramFile;     
                int32_t m_confColorFile;       
                int32_t m_confImageFile;       
                // openGL shaders programs:
                ememory::SharedPtr<gale::resource::Program> m_GLprogram; 
                int32_t m_GLPosition;           
                int32_t m_GLMatrix;             
                int32_t m_GLPropertyPos;       
                int32_t m_GLStateActivate;      
                int32_t m_GLStateOld;           
                int32_t m_GLStateNew;           
                int32_t m_GLStateTransition;    
                int32_t m_GLtexID;              
                // For the Image :
                ememory::SharedPtr<ewol::resource::TextureFile> m_resourceTexture; 
                // internal needed data :
                int32_t m_nextStatusRequested;    
                vec2    m_propertyOrigin;         
                vec2    m_propertySize;           
                vec2    m_propertyInsidePosition; 
                vec2    m_propertyInsideSize;     
                int32_t m_stateActivate;          
                int32_t m_stateOld;               
                int32_t m_stateNew;               
                float   m_stateTransition;        
                vec2    m_coord[SHAPER_NB_MAX_VERTEX]; 
                vec2    m_pos[SHAPER_NB_MAX_VERTEX]; 
                int32_t m_nbVertexToDisplay;
                // color management theme:
                ememory::SharedPtr<ewol::resource::ColorFile> m_colorProperty; 
                std::vector<ivec2> m_listAssiciatedId; 
            private:
                void loadProgram();
                void unLoadProgram();
            public:
                Shaper(const std::string& _shaperName="");
                virtual ~Shaper();
            public:
                void draw(bool _disableDepthTest=true);
                void clear();
                bool setState(int32_t _newState);
                bool changeStatusIn(int32_t _newStatusId);
                int32_t getCurrentDisplayedStatus() {
                    return m_stateNew;
                };
                int32_t getNextDisplayedStatus() {
                    return m_nextStatusRequested;
                };
                float getTransitionStatus() {
                    return m_stateTransition;
                };
                bool periodicCall(const ewol::event::Time& _event);
                ewol::Padding getPadding();
                ewol::Padding getPaddingIn();
                ewol::Padding getPaddingOut();
                ewol::Padding getBorder();
                void setSource(const std::string& _newFile);
                const std::string& getSource() const {
                    return m_name;
                };
                bool hasSources();
            public:
                void setShape(const vec2& _origin, const vec2& _size, const vec2& _insidePos, const vec2& _insideSize);
                // @previous
                void setShape(const vec2& _origin, const vec2& _size) {
                    ewol::Padding tmp = getPadding();
                    setShape(_origin, _size, _origin+vec2(tmp.xLeft(), tmp.yButtom()), _size - vec2(tmp.x(), tmp.y()));
                }
            public:
                int32_t requestColor(const std::string& _name);
                const etk::Color<float>& getColor(int32_t _id);
            public:
                int32_t requestConfig(const std::string& _name);
                double getConfigNumber(int32_t _id);
            public:
                void setActivateState(int32_t _status) {
                    m_stateActivate = _status;
                }
            private:
                void addVertexLine(float _yTop,
                                   float _yButtom,
                                   float _x1,
                                   float _x2,
                                   float _x3,
                                   float _x4,
                                   float _x5,
                                   float _x6,
                                   float _x7,
                                   float _x8,
                                   float _yValTop,
                                   float _yValButtom,
                                   const float* _table,
                                   bool _displayOutside);
            public:
                /* ****************************************************
                 *    == operator
                 *****************************************************/
                bool operator== (const Shaper& _obj) const {
                    return _obj.m_name == m_name;
                }
                bool operator!= (const Shaper& _obj) const {
                    return _obj.m_name != m_name;
                }
        };
    }
}