Drawing.hpp

Go to the documentation of this file.

#pragma once

#include <etk/Color.hpp>

#include <ewol/debug.hpp>
#include <ewol/compositing/Compositing.hpp>
#include <gale/resource/Program.hpp>


namespace ewol {
    namespace compositing {
        class Drawing : public ewol::Compositing {
            private:
                vec3 m_position;         
                vec3 m_clippingPosStart; 
                vec3 m_clippingPosStop;  
                bool m_clippingEnable;   
            private:
                etk::Color<> m_color;   
                etk::Color<> m_colorBg; 
            private:
                ememory::SharedPtr<gale::resource::Program> m_GLprogram;  
                int32_t m_GLPosition; 
                int32_t m_GLMatrix; 
                int32_t m_GLMatrixPosition; 
                int32_t m_GLColor; 
            public: // Background Color (display only when needed)
                std::vector<vec3 > m_coord; 
                std::vector<etk::Color<float> > m_coordColor; 
            public:
                Drawing();
                virtual ~Drawing();
            private:
                void loadProgram();
                void unLoadProgram();
                float m_thickness; 
                int32_t m_triElement; 
                vec3 m_triangle[3]; 
                etk::Color<float> m_tricolor[3]; 
            // internal API for the generation abstraction of triangles
                void generateTriangle();
                void resetCount();
                void internalSetColor(const etk::Color<>& _color);
                void setPoint(const vec3& point);
                
            public:
                void draw(bool _disableDepthTest=true);
                void clear();
                const vec3& getPos() {
                    return m_position;
                };
                void setPos(const vec3& _pos) {
                    m_position = _pos;
                };
                inline void setPos(const vec2& _pos) {
                    setPos(vec3(_pos.x(), _pos.y(), 0));
                };
                void setRelPos(const vec3& _pos) {
                    m_position += _pos;
                };
                inline void setRelPos(const vec2& _pos) {
                    setRelPos(vec3(_pos.x(), _pos.y(), 0));
                };
                void setColor(const etk::Color<>& _color) {
                    m_color = _color;
                };
                const etk::Color<>& getColor() {
                    return m_color;
                };
                void setColorBg(const etk::Color<>& _color) {
                    m_colorBg = _color;
                };
                const etk::Color<>& getColorBg() {
                    return m_colorBg;
                };
                void setClippingWidth(const vec3& _pos, const vec3& _width) {
                    setClipping(_pos, _pos+_width);
                };
                inline void setClippingWidth(const vec2& _pos, const vec2& _width) {
                    setClippingWidth(vec3(_pos.x(),_pos.y(),-1), vec3(_width.x(),_width.y(), 2));
                };
                void setClipping(const vec3& _pos, const vec3& _posEnd);
                inline void setClipping(const vec2& _pos, const vec2& _posEnd) {
                    setClipping(vec3(_pos.x(),_pos.y(),-1), vec3(_posEnd.x(),_posEnd.y(), 1));
                };
                void setClippingMode(bool _newMode) {
                    m_clippingEnable = _newMode;
                };
                void setThickness(float _thickness);
                void addVertex();
                void lineTo(const vec3& _dest);
                inline void lineTo(const vec2& _dest) {
                    lineTo(vec3(_dest.x(), _dest.y(), 0));
                };
                void lineRel(const vec3& _vect) {
                    lineTo(m_position+_vect);
                };
                inline void lineRel(const vec2& _vect) {
                    lineRel(vec3(_vect.x(), _vect.y(), 0));
                };
                void rectangle(const vec3& _dest);
                inline void rectangle(const vec2& _dest) {
                    rectangle(vec3(_dest.x(), _dest.y(), 0));
                };
                void rectangleWidth(const vec3& _size) {
                    rectangle(m_position+_size);
                };
                inline void rectangleWidth(const vec2& _size) {
                    rectangleWidth(vec3(_size.x(), _size.y(), 0));
                };
                void cube(const vec3& _dest);
                void circle(float _radius, float _angleStart = 0, float _angleStop = 2*M_PI);
        };
    };
};