Engine.h

Go to the documentation of this file.

#ifndef GlobeEngine_Engine_h
#define GlobeEngine_Engine_h

#include "OpenGL_Includes.h"
#include "Camera.h"
#include "TextureHandle.h"
#include "Timer.h"
#include <vmmlib/matrix.hpp>
#include <vector>

namespace ge {
    class Engine
    {
    public:
        enum eTEXTURE_UNITS { eUNIT0, eUNIT1, eUNIT2, eUNIT3, eUNIT4, eUNIT5 , eUNIT6, eUNIT7 };
        
    public:
        enum PICKINGSTATE {
            IDLE=0,     
            PICKEVENT,  
            PICKED      
        };
        enum DEBUGSTATE {
            NOTACTIVE,  
            ACTIVE      
        };
        enum PROGRAMMSTATE {
            NOTLOADED,  
            LOADED,     
            RUNNING,    
        };
         
    public:
        Engine();
        ~Engine();
        // virtual overloads
        virtual void clear();
        virtual void create();

        // necessary overloads for engine classes
        virtual void initializeScene(std::string _initFilePath=0) = 0;
        virtual void update() = 0;
        virtual void resize(int _w, int _h) = 0;
        void draw();
        
        void initExtension();

        void setProgrammState(enum PROGRAMMSTATE state);
        enum PROGRAMMSTATE getProgrammState(){
            return programstate;
        };
        
        void setDebugState(enum DEBUGSTATE state);
        enum DEBUGSTATE getDebugState(){
            return debugstate;
        };
        
        void enablePicking(bool _in);
        bool isPickingEnabled();
        
        void enableWireframe(bool _in);
        bool isWireframeEnabled();
        
        void enableAnimationLoop(bool _in);
        bool isAnimationLoopEnabled();

        void setUIFramebufferID(unsigned int _id);
        const std::shared_ptr<TextureHandle>& getUIFramebufferHandle();
        bool isUIFramebufferActive();
        void enableUIFramebuffer(bool _in = true);
        void disableUIFramebuffer();
        
        int getCameraCount();
        std::shared_ptr<ge::Camera> getCamera(int _index);
        std::shared_ptr<ge::Camera> getSelectedCam();
        int getSelectedCamID() const;
        void setSelectedCamID(int _id);
        
        float getDevicePixelRatio();
        void setDevicePixelRatio(float _in);
        
        double getElapsedTimeForLastFrame();
 
        inline void getOpenGLError(std::string const& _input)   {
#ifdef GENGINE_GLAPI_410_AND_LOWER
            GLenum err;
            err = glGetError();
#ifdef GENGINE_GL_ES
            if (err != GL_NO_ERROR) {
                printf(_input.c_str(), gluErrorString(err));
            }
#endif
#endif
        }

        inline void getOpenGLError(char const* _input)
        {
#ifdef GENGINE_GLAPI_410_AND_LOWER
            GLenum err;
            err = glGetError();
#ifdef GENGINE_GL_ES
            if (err != GL_NO_ERROR) {
                printf(_input, gluErrorString(err));
            }
#endif
#endif
        }

    protected:
        // draw method to override from derived engines
        virtual void drawScene() = 0;
        // Print out engine state
        void printLineRenderingInfo();
        void printTextureInfo();
        void printFramebufferInfo();
        void printBufferInformation();
    
        std::vector< std::shared_ptr<ge::Camera> > cameras;
        int selectedCameraID;

        enum PROGRAMMSTATE programstate; 
        enum DEBUGSTATE debugstate;      
        enum PICKINGSTATE pickingState;  
    
        bool pickingEnabled;
        bool animationsEnabled;
        
    private:
        std::shared_ptr<TextureHandle> uifboid;
        bool uifboActive;
        float devicePixelRatio; 
        
        bool wireframeMode;
        
        ge::Timer frameTimer;
        
    };
}
#endif