Application.h

Zobrazit dokumentaci tohoto souboru.

#ifndef _CAPP_H_
#define _CAPP_H_

#include "main.h"
#include "GameStateManager.h"

#include "Singleton.h"
#include "Cube.h"

#include "Collection.h"
#include "TextureManager.h"
#include "GameObject3DManager.h"
#include "GameObject2DManager.h"
#include "FontManager.h"
#include "FontPrinter.h"
#include "Renderer.h"

template<class T>
class CApplication: public CSingleton<T> {

public:

        void init(int *argc, char **argv);

        bool initDevIL(void); // inicializace knihovny DevIL

        void initManagers(); // inicializace spravcu

        void run(void);

        static void clear(void);

        void changeState(int state);

        CApplication(void);

        ~CApplication(void);

        void setTitle(string str) {
                m_title = str;
        }

        void setTitle(const char *str) {
                m_title = str;
        }

        string getTitle() {
                return m_title;
        }

        virtual void terminate();

protected:

        void loadResources(void); // nacteni zdroju pro hru

        virtual void loadTextures(void) = 0; // nacteni textur

        virtual void loadFonts(void) = 0; // nacteni fontu

        virtual void createScenes() = 0; // vytvoreni scen hry


        void mouseMove(int x, int y); // mouse move

        void mouseButtons(int button, int state, int x, int y); // mouse button action

        void keyboard(unsigned char key, int x, int y); // keyboard

        void keyboardSpecial(int key, int x, int y);

        void timer(int value);

        void renderScene(void); // scene render

        void changeSize(int width, int height); // resize

        bool isCallTerminate() {
                return m_terminate;
        }

        void cleanUp();

        static void mouseMoveWrapper(int x, int y);
        static void mouseButtonsWrapper(int button, int state, int x, int y);
        static void keyboardWrapper(unsigned char key, int x, int y);
        static void keyboardSpecialWrapper(int key, int x, int y);
        static void renderSceneWrapper(void);
        static void changeSizeWrapper(int width, int height);
        static void timerWrapper(int value);


        string m_title;

        bool m_terminate;

        CGameStateManager* m_gameStateManager;

};

template<class T>
CApplication<T>::CApplication(void) {
        m_terminate = false;
        m_gameStateManager = new CGameStateManager();
}

template<class T>
CApplication<T>::~CApplication(void) {
        if (m_gameStateManager != NULL) {
                delete m_gameStateManager;
        }
}

template<class T>
void CApplication<T>::init(int *argc, char **argv) {

        cout << "* Core initialization" << endl;

        glutInit(argc, argv); // inicializace knihovny GLUT (OpenGL Utility Toolkit)

        /*
         * inicializace zobrazení:
         * depth buffer - hloubkový zásobník
         * double buffering - required to have smooth animation
         * color model - mód barev - RGBA (červená, zelená, modrá, alfa kanál - průhlednost)
         *
         * Podrobnosti: http://www.opengl.org/documentation/specs/glut/spec3/node12.html
         *
         */

        glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA | GLUT_STENCIL);
        glutInitWindowSize(800, 600); // nastavení velikosti okna
        glutCreateWindow(getTitle().c_str()); // vytvoříme okno s příslušným titulkem

        glutSetCursor(GLUT_CURSOR_NONE); // schováme kurzor

        // Nastavení callbacků funkcí
        // - vždy ukazatel na statickou metodu dané třídy, která následně volá příslušné nestatické funkce

        glutDisplayFunc(renderSceneWrapper); // vykreslování
        glutReshapeFunc(changeSizeWrapper); // změna velikosti okna
        glutKeyboardFunc(keyboardWrapper); // obsluha klávesnice (ASCII)
        glutSpecialFunc(keyboardSpecialWrapper); // obsluha klávesnice (speciální vsupty - např. šipky, F1, F2, ...)
        glutPassiveMotionFunc(mouseMoveWrapper); // obsluha pohybu myši
        glutMouseFunc(mouseButtonsWrapper); // obsluha stisknutí tlačítek myši
        glutTimerFunc(10, timerWrapper, 0); // časovač

        initDevIL(); // inicializace knihovny DevIL
        loadResources(); // načtení zdrojů
        createScenes(); // vytvoreni scen

        // inicializace kamery
        CCamera* camera = CCamera::getInstance();

        // nastaveni renderu
        CRenderer* renderer = CRenderer::getInstance();
        renderer->blendingEnable();
        renderer->setViewport(800, 600);
        renderer->setCamera(camera);

        // nastaveni vypisovace pisma
        CFontPrinter* fontPrinter = CFontPrinter::getInstance();
        fontPrinter->setFontManager(CFontManager::getInstance());
}

template<class T>
void CApplication<T>::initManagers() {
        m_gameStateManager = new CGameStateManager();
}

template<class T>
bool CApplication<T>::initDevIL() {

        // Otestujeme zdali stavíme na správné verzi knihovny DevIL
        // Zdroj: http://openil.sourceforge.net/tuts/tut_step/index.htm
        //

        if (ilGetInteger(IL_VERSION_NUM) < IL_VERSION || iluGetInteger(
                        ILU_VERSION_NUM) < ILU_VERSION || ilutGetInteger(ILUT_VERSION_NUM)
                        < ILUT_VERSION) {
                cerr << "DevIL version is different...exiting!\n" << endl;
                return false;
        }

        cout << "DevIL initialization ... ";

        // inicializace knihoven
        // il - slouží k načítání a ukládání obrázků
        // ilu - slouží k modifikaci obrázků
        // ilut - propojuje knihovku DevIL s OpenGL

        ilInit();
        iluInit();
        ilutRenderer(ILUT_OPENGL); // podpora OPENGL

        cout << "succeed" << endl;

        return true;
}

template<class T>
void CApplication<T>::run(void) {
        glutMainLoop(); // hlavní smyčka aplikace
}

// states

template<class T>
void CApplication<T>::changeState(int state) {
        if (m_gameStateManager != NULL) {
                m_gameStateManager->switchStateTo(state);
        }
}

template<class T>
void CApplication<T>::loadResources(void) {
        cout << "*Resources loading" << endl;
        cout << "**Textures loading" << endl;
        loadTextures(); // načtení textur
        cout << "**Font loading" << endl;
        loadFonts(); // načtení písem
}

// service methods

template<class T>
void CApplication<T>::timer(int value) {
        glutPostRedisplay(); // překresli scénu
        glutTimerFunc(1000 / 60, timerWrapper, 1); // zavolej časovač
}

template<class T>
void CApplication<T>::keyboard(unsigned char key, int x, int y) {
        if (m_gameStateManager != NULL) {
                this->m_gameStateManager->getCurrentState()->keyboard(key, x, y);
        }
}

template<class T>
void CApplication<T>::keyboardSpecial(int key, int x, int y) {
        if (m_gameStateManager != NULL) {
                this->m_gameStateManager->getCurrentState()->keyboardSpecial(key, x, y);
        }
}

template<class T>
void CApplication<T>::mouseMove(int x, int y) {
        if (m_gameStateManager != NULL) {
                this->m_gameStateManager->getCurrentState()->mouseMove(x, y);
        }
}

template<class T>
void CApplication<T>::mouseButtons(int button, int state, int x, int y) {
        if (m_gameStateManager != NULL) {
                this->m_gameStateManager->getCurrentState()->mouseButtons(button,
                                state, x, y);
        }
}

template<class T>
void CApplication<T>::renderScene(void) {

        if (this->isCallTerminate()) {
                this->cleanUp();
        }

        if (m_gameStateManager != NULL) {
                m_gameStateManager->update();
                m_gameStateManager->render();
        }
}

template<class T>
void CApplication<T>::changeSize(int width, int height) {

        glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // nejlepsi korekce perspektivy

        if (height == 0) // prevent a divide by zero
                height = 1;

        GLfloat ratio = (GLfloat) width / (GLfloat) height; // screen ratio

        glViewport(0, 0, (GLsizei) width, (GLsizei) height); // set the viewport to be the entire window
        glMatrixMode(GL_PROJECTION); // use matrix projection
        glLoadIdentity(); // reset matrix
        gluPerspective(60, ratio, 0.1, 1000); // set the correct perspective
        glMatrixMode(GL_MODELVIEW); // use model projection

        glEnable(GL_DEPTH_TEST); // hloubkove testovani
        glDepthFunc(GL_LEQUAL); // typ hloubkoveho testovani


}

/*      statické metody        */

template<class T>
void CApplication<T>::clear(void) {

        cout << "Exit application" << endl;

        if (CSingleton<T>::m_instance != NULL)
                delete CSingleton<T>::m_instance;

        exit(0);

}

/*      statické wrappery      */

template<class T>
void CApplication<T>::keyboardWrapper(unsigned char key, int x, int y) {

        if (CSingleton<T>::m_instance != NULL) {
                CSingleton<T>::m_instance->keyboard(key, x, y);
        }

}

template<class T>
void CApplication<T>::keyboardSpecialWrapper(int key, int x, int y) {
        if (CSingleton<T>::m_instance != NULL) {
                CSingleton<T>::m_instance->keyboardSpecial(key, x, y);
        }
}

template<class T>
void CApplication<T>::mouseMoveWrapper(int x, int y) {

        if (CSingleton<T>::m_instance != NULL)
                CSingleton<T>::m_instance->mouseMove(x, y);

}

template<class T>
void CApplication<T>::mouseButtonsWrapper(int button, int state, int x, int y) {

        if (CSingleton<T>::m_instance != NULL)
                CSingleton<T>::m_instance->mouseButtons(button, state, x, y);

}

template<class T>
void CApplication<T>::renderSceneWrapper(void) {

        if (CSingleton<T>::m_instance != NULL)
                CSingleton<T>::m_instance->renderScene();

}

template<class T>
void CApplication<T>::changeSizeWrapper(int width, int height) {

        if (CSingleton<T>::m_instance != NULL)
                CSingleton<T>::m_instance->changeSize(width, height);

}

template<class T>
void CApplication<T>::timerWrapper(int value) {

        if (CSingleton<T>::m_instance != NULL)
                CSingleton<T>::m_instance->timer(value);

}

template<class T>
void CApplication<T>::terminate() {
        this->m_terminate = true;
}

template<class T>
void CApplication<T>::cleanUp() {

        cout << "DISCONNECT GAME STATE MANAGER" << endl;
        if (m_gameStateManager != NULL) {
                CGameStateManager* gm = m_gameStateManager;
                gm->clean();
                m_gameStateManager = NULL;
        }

        cout << "DISCONNECT RENDERS" << endl;
        CRenderer* renderer = CRenderer::getInstance();
        if (renderer != NULL) {
                renderer->disconnect();
                delete renderer;
        }

        cout << "DELETE 2D MANAGER OBJECTS" << endl;
        CGameObject2DManager* object2DManager = CGameObject2DManager::getInstance();
        if (object2DManager != NULL) {
                object2DManager->clean();
                delete object2DManager;
        }

        cout << "DELETE 3D MANAGER OBJECTS" << endl;
        CGameObject3DManager* object3DManager = CGameObject3DManager::getInstance();
        if (object3DManager != NULL) {
                object3DManager->clean();
                delete object3DManager;
        }

        cout << "DELETE TEXTURE MANAGER" << endl;

        CTextureManager* textureManager = CTextureManager::getInstance();
        if (textureManager != NULL)
                ;
        {
                textureManager->clean();
                delete textureManager;
        }

        cout << "DELETE FONT MANAGER" << endl;
        CFontManager::deleteInstance();
        CCamera::deleteInstance();

        clear();

}

#endif

---