DrawableComponent.h

Go to the documentation of this file.

#ifndef GlobeEngine_DrawableComponent_h
#define GlobeEngine_DrawableComponent_h

#include "OpenGL_Includes.h"
#include "GlobeComponent.h"
#include "BoundingBox.h"
#include "BoundingSphere.h"
#include "Shader.h"
#include "Buffer.h"
#include "BufferArray.h"
#include "VertexArrayObject.h"
#include <vmmlib/vmmlib.hpp>

class Camera;

namespace ge {
    
    class DrawableComponent : public GlobeComponent
    {
    public:
        enum RENDERSTATE { STENCILPASS, DEPTHPASS, RENDER, OCCLUSIONTEST, OCCLUSIONGROUNDTEST, OCCLUSIONRESULT, EMPTY, DECALPASS};
        
    public:
        DrawableComponent();
        ~DrawableComponent();
        DrawableComponent(const DrawableComponent& _in) = delete;
        DrawableComponent& operator=(const DrawableComponent& _in) = delete;

        virtual void clear();
        virtual void draw(std::shared_ptr<ge::Camera> _cam);
        virtual void setPosition(vmml::Vector3d _position);
        vmml::Vector3d getPosition() const;
        virtual void setScale(vmml::Vector3d _scale);
        vmml::Vector3d getScale() const;
        virtual void setRotation(vmml::Vector3d _rotations);
        vmml::Vector3d getRotation() const;

        void setBoundingSphere(BoundingSphere _boundingSphere);
        void setBoundingBox(BoundingBox3d _boundingBox);
        const BoundingSphere* getBoundingSphere() const;
        const BoundingBox3d* getBoundingBox() const;
        bool isVisible() const;
        virtual void isVisible(bool _input);
        bool isGeometryReady() const;
        virtual void isGeometryReady(bool _input);

        virtual void setColor(vmml::Vector3f _color);
        const vmml::Vector3f getColor() const;
        
        virtual void setColorPerVertex(unsigned int _in){
            this->colorPerVertex = _in;
        };
        unsigned int getColorPerVertex() const {
            return this->colorPerVertex;
        }
        
        void setTextured(bool _in);
        bool isTextured();
        void setTextureHandle(GLuint _handle);
        GLuint getTextureHandle() const;

        void setNormalTextureHandle(GLuint _handle);
        GLuint getNormalTextureHandle() const;
        void setNormalMapped(bool _in);
        bool isNormalMapped();

        virtual void setShader(std::shared_ptr<ge::Shader> _shader);
        void setStandardUniforms();
        const std::shared_ptr<ge::Shader> getShader() const;
        // only use this if you what you are doing. :)
        void recompileShader();

        void setNormalMatrix();
        void setModelMatrices();
        vmml::Matrix4d getModelMatrix() const;
        vmml::Matrix4d getInverseModelMatrix() const;
        void setViewProjMatrices(const std::shared_ptr<ge::Camera> _cam);
        void setMVPMatrix(const std::shared_ptr<ge::Camera> _cam);

        virtual void enableOcclusionQueries(bool _in);
#if defined(GENGINE_GL_ES)
#else
        void beginOcclusionQuery(RENDERSTATE _state);
        void endOcclusionQuery(RENDERSTATE _state);
        GLuint getQueryResult();

        /* point sprites */
        void enablePointSprites();
        void disablePointSprites();
#endif
        void fillIndexBufferWithLinearValues();

        void enableVertexAttributes(int vaaSize = 2);
        void disableVertexAttributes(int vaaSize = 2);
        void setNumberOfVertexAttributes(unsigned int _in);

        void generateVertexHandlesFromShader(int _bufferCount = 0);
        void setVertexAttributePointer(GLuint _bufferID, GLuint _index, GLint _size, GLenum _type);
        /* maps attribute values between 0.0 and 1.0 if values are not float */
        void setVertexAttributePointerNormalized(GLuint _bufferID, GLuint _index, GLint _size, GLenum _type);
        void setVertexLongAttributePointer(GLuint _bufferID, GLuint _index, GLint _size, GLenum _type);

        void unbindVertexBuffers();

        /* copy attribute data */
        void setAttributeBuffer1i(int _bufferID, int _input);
        void setAttributeBuffer1i(int _bufferID, std::vector<int> _input);
        void setAttributeBuffer1f(int _bufferID, float _value);
        void setAttributeBuffer1f(int _bufferID, std::vector<float> _input);
        void addVertex3fAttribute(unsigned int _bufferPos, unsigned int _size, const vmml::Vector3d _value);
        void addVertex3fAttribute(unsigned int _bufferPos, unsigned int _size, const vmml::Vector3d* _values);
        void addCustomVertexAttributef(unsigned int _bufferPos, unsigned int _attributeCount, unsigned int _sizePerAttribute, float** _values);
        
        /* shadow map */
        void setDepthMatrix(vmml::Matrix4d _mat);
        void setDepthMatrixUniform();
        void setDepthTextureHandle(GLuint _handle);
        //void setDepthTextureHandleUniform();
        void setDepthUniforms();
        GLuint getDepthTextureHandle() const;
        
        /* set picking shader information */
        void setPickingInformation();
        
        /* For multidraw components */
        void createMultiDrawPointerList(GLuint _numberOfDrawObjects, GLsizei* _stripLenghts);
        void createMultiDrawPointerList(GLuint _numberOfDrawObjects, GLsizei _stripLenghts);
        void drawMultiElements(GLenum _mode, const GLsizei* _count, GLsizei _drawcount);
        
        void drawArrays(GLenum _mode, GLint _first, GLsizei _count);
        void drawElements(GLenum _mode, GLsizei _count, const GLvoid * _indices);
        void drawMultiArrays(GLenum _mode, const GLsizei* _count, GLsizei _drawcount);

        /* primitive restart */
        void enablePrimitiveRestart();
        void disablePrimitiveRestart();
        void setPrimitiveRestartIndex(GLuint _in);

        unsigned int getVertexCount() const { return vertexCount; }
        
        void setVertexAttributePointerForBuffer(unsigned int _bufferID, unsigned int _size, GLenum _type);
        
    private:
        void clearInitial();
        void deleteMemory();
      
    private: 
        bool visible;
        bool geometryready;

    protected:
        std::shared_ptr<ge::Shader> shader;
        vmml::Vector3d position;
        vmml::Vector3d scale;
        vmml::Vector3d rotations;
        vmml::Vector3f color;
        unsigned int colorPerVertex; //per object, per Vertex
        
        // texture stuff
        bool textured;
        GLuint colorTexHandle;
        bool normalMapped;
        GLuint normalTexHandle;

        BoundingSphere* boundingSphere;
        BoundingBox3d* boundingBox;
        
        // Matrix information
        vmml::Matrix4d modelMatrix;
        vmml::Matrix4d mvpMatrix;
        vmml::Matrix3d normalMatrix;
        
        // Shadow
        vmml::Matrix4d depthTextureMatrix;
        GLuint depthTextureHandle;
        
        // Rendering structs
        ge::VertexArrayObject vao;
        ge::VertexBufferArray attributes;
        //GLuint* bufferHandles;
        
        // vertex information
        GLuint vertexCount;

        // index structs
        GLuint indexCount;
        ge::IndexBuffer indexBuffer;
        
        GLuint multiDrawPointerListSize;
        const GLvoid** multiDrawPointerList;
        GLint* multiDrawArraysList;
        
        /* Hardware occlusion queries
         *  0 = no query requested
         *  1 = query requested
         *  2 = glBeginQuery called
         *  3 = wait for result
         *  4 = result ready, query deleted
         */
        GLuint occlusionQueryState;
        GLuint occlusionQueryID;
        GLuint queryResultPixelCount;
        
        // Uniform locations
        GLint uniformViewMatrixLocation;
        GLint uniformProjectionMatrixLocation;
        GLint uniformModelMatrixLocation;
        GLint uniformMVPMatrixLocation;
        
        GLint uniformObjectColorLocation;
        GLint uniformColorPerVertexLocation;
        GLint uniformObjectIDLocation;
        GLint uniformObjectGroupIDLocation;
    };
}
#endif