tgEngine.h

Go to the documentation of this file.

#ifndef TG_ENGINE
#define TG_ENGINE

#include <blort/TomGine/headers.h>

#include <blort/GLWindow/GLWindow.h>
#include <blort/TomGine/tgCamera.h>
#include <blort/TomGine/tgLighting.h>
#include <blort/TomGine/tgRenderModel.h>
#include <blort/TomGine/tgPose.h>
#include <blort/TomGine/tgTimer.h>
#include <blort/TomGine/tgVector3.h>
#include <blort/TomGine/tgMathlib.h>

namespace TomGine{

class tgEngine
{
private:
        unsigned m_width;
        unsigned m_height;
        float m_far;
        float m_near;
        
        float m_input_rotation_speed;
        float m_input_translation_speed;
        float m_input_zoom_speed;
        
        blortGLWindow::GLWindow* m_window;
        tgTexture* m_background_image;
        
        tgCamera                m_cam[6];
        tgCamera                m_camera;
        tgCamera                m_cam_ortho;

        tgLighting              m_lighting;
        tgLight                 m_light0;
        tgTimer                 m_timer;
        tgVector3               m_cor;                  
        
        int m_mouse_pos[2];
        bool p_pressed;
        
        float m_frametime;
        bool m_bfc;
        bool m_button_left, m_button_middle, m_button_right;
        bool m_wireframe;
        bool m_smoothshading;
        bool m_show_background_image;
        bool m_flip_background_image;
        
//      FTTextureFont* m_font_tf;
        tgFont m_font;
        
        void DrawBackgroundImage();
        
public:
        tgEngine(       unsigned width=640,
                                unsigned height=480,
                                float far=10.0f,
                                float near=0.01f,
                                const char* name="TomGine",
                                bool bfc=false);
                                
        ~tgEngine();
        
        void Welcome();
        
        bool Update();
        bool Update(float &fTime);
        bool Update(std::vector<blortGLWindow::Event> &eventlist);
        bool Update(float &fTime, std::vector<blortGLWindow::Event> &eventlist);
        
        
        bool InputControl(blortGLWindow::Event &event);
        
        void DrawCoordinates();
        
        void SetCamera(tgCamera cam);
        void UpdateCameraViews(tgCamera cam);
        
        void SetCenterOfRotation(float x, float y, float z);
        
        void Activate3D();

        void Activate2D();
        
        void Swap();
        
        void LoadBackgroundImage(unsigned char* image_data, int width, int height, GLenum format=GL_RGB, bool flip=false);
        void UnloadBackgroundImage();
        
        vec3 GetCameraPosition(){ tgVector3 tgv = m_camera.GetPos(); return vec3(tgv.x, tgv.y, tgv.z); }

        void GetCamera0(tgCamera &cam){ cam = m_camera; }
        
        bool GetWireframeMode(){ return m_wireframe; }
        
        void PrintText3D(std::string text, vec3 pos, int size=16);
        void PrintText2D(std::string text, vec2 pos, int size=16);
        
        void SetInputRotationSpeed(float v){ m_input_rotation_speed = v; }
        void SetInputTranslationSpeed(float v){ m_input_translation_speed = v; }
        void SetInputZoomSpeed(float v){ m_input_zoom_speed = v; }
        void SetSpeeds(float rotation, float translation, float zoom){ 
                m_input_rotation_speed  = rotation;
                m_input_translation_speed = translation;
                m_input_zoom_speed = zoom;
        }
                
        tgVector3 Get3DPointFrom2D(int x, int y);
        bool GetNewPoint(vec3& v);

};

} // namespace TomGine

#endif