K3dEngine.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007 by Jan Koci   *
 *   honza.koci@email.cz   *
 *   http://kengine.sourceforge.net/tutorial/
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "K3dEngine.h"

K3dEngine::K3dEngine()
{
        cout << "K3dEngine::K3dEngine()" << endl;
}

K3dEngine::~K3dEngine()
{
        cout << "K3dEngine::~K3dEngine()" << endl;
}

bool K3dEngine::Init(int _argc, char *_argv[], bool _bReinit)
{
        if(!InitEngine(_argc,_argv,_bReinit))
        {
                Destroy();
                return false;
        }
        // Draw info
        printf("\n");
        m_pScene->PrintGraphicDriverName();
        m_pScene->PrintGraphicDriverInfo();
        m_pScene->PrintModes();
        return true;
}

bool K3dEngine::InitEngine(int _argc, char *_argv[], bool _bReinit)
{
        cout << "bool K3dEngine::Init(int _argc, char *_argv[], bool _bReinit=false)" << endl;
        // Inicializace SDL
        if(SDL_Init(SDL_SUBSYSTEMS) == -1)
        {
                fprintf(stderr, "Unable to initialize SDL: %s\n",
                        SDL_GetError());
                return false;
        }

        // Create game data
        m_pGameData = new K3dGameData();
        // Create scene with global game data and set
        m_pScene = new K3dScene(m_pGameData, _argc, _argv);
        // Create virtual machine
        m_pVM = new K3dVM(m_pGameData, m_pScene);

        // Get loaded graphics info
        TGraphicOption *ptGOption = m_pGameData->GetGraphicOption();

        int iWidth = ptGOption->iWidth;
        int iHeight = ptGOption->iHeight;
        int iBpp = ptGOption->iColorBits;
        Uint32 uiFlags = ptGOption->uiFlags;
        if(_bReinit)
        {
        uiFlags = m_uiFlags;       
    }
    else
    {
        m_bIsFullscreen = ptGOption->bFullscreen;
    }
        printf("SDL was initialized\n");
        m_pScene->PrintParams(iWidth, iHeight, iBpp, true);
        printf("Checking window parameters...\n");
        iBpp = SDL_VideoModeOK(iWidth, iHeight, iBpp, uiFlags);
        // If incorrect video mode
        if(iBpp == 0)
        {
                // Get optimal color depth by SDL
                iBpp = SDL_GetVideoInfo()->vfmt->BitsPerPixel;
                printf("SDL_VideoModeOK(): Parameters are not valid, "
                        "checking new color depth...\n");
                printf("SDL_GetVideoInfo()->vfmt->BitsPerPixel: %d\n", iBpp);
                iBpp = SDL_VideoModeOK(iWidth, iHeight, iBpp, uiFlags);
                if(iBpp == 0)
                {
                        printf("SDL_VideoModeOK(): Parameters are not "
                                "valid, finding new dimensions\n");
                        // Set optimal value form SDL
                        iBpp = SDL_GetVideoInfo()->vfmt->BitsPerPixel;
                        // Try getting available resolution flags
                        SDL_Rect **pptModes;
                        pptModes = SDL_ListModes(NULL, uiFlags);
                        // If no any modes
                        if(pptModes == (SDL_Rect **)0)
                        {
                                printf("SDL_ListModes(): No modes available\n");
                                return false;
                        }
                        else if(pptModes == (SDL_Rect **)-1)// Use minimal resolution
                        {
                                printf("SDL_ListModes(): All resolutions "
                                        "available, using 640x480.\n");
                                iWidth = 640;
                                iHeight = 480;
                        }
                        else// Using maximal resolution
                        {
                                printf("SDL_ListModes(): Using maximal "
                                        "available dimensions\n");
                                iWidth = pptModes[0]->w;
                                iHeight = pptModes[0]->h;
                        }
                        printf("Everything should be OK now, but some "
                                "other check would be great :]\n");
                        m_pScene->PrintParams(iWidth, iHeight, iBpp, true);
                        iBpp = SDL_VideoModeOK(iWidth, iHeight, iBpp, uiFlags);
                        if(iBpp == 0)
                        {
                                printf("SDL_VideoModeOK(): Something is still "
                                        "not valid :-(((((\n");
                                m_pScene->PrintParams(iWidth, iHeight, iBpp, false);
                                return false;
                        }
                }
        }
        printf("SDL_VideoModeOK(): Parameters are valid\n");
        printf("Creating window...\n");
        // Set OpenGL rendering context
        SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
        SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 24);
        SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
        SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 0);
        SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, 0);
        SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, 0);
        SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, 0);
        SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, 0);
#ifdef FSAA
        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, FSAA);
#endif
        m_pScreen = SDL_SetVideoMode(iWidth, iHeight, iBpp, uiFlags);
        if(m_pScreen == NULL)
        {
                printf("Window creation failed\n");
                m_pScene->PrintParams(iWidth, iHeight, iBpp, false);
                fprintf(stderr, "SDL_GetError(): %s\n", SDL_GetError());
                cerr << SDL_GetError() << endl;
                return false;
        }
        printf("Window was successfuly created\n");
        m_pScene->PrintParams(iWidth, iHeight, iBpp, true);
        // Initialize OpenGL
        if(!m_pScene->InitGL())
        {
                return false;
        }
        // Set window title
        SDL_WM_SetCaption(WIN_TITLE, NULL);
        // Get script options
        cout << "LoadScript()" << endl;
        TScriptOption *ptOption = m_pGameData->GetScriptOption();
        // Load default script
        m_pVM->LoadScript(ptOption->strDefault);
        // Call Lua function Init() from script
        m_pVM->Engine_Init();
        // Set perspective projection
        m_pScene->ResizeGL(ptGOption->iWidth, ptGOption->iHeight);
        return true;
}

void K3dEngine::Destroy()
{
        // Call Lua function Delete() from script
        if(m_pVM)
        {
                m_pVM->Engine_Delete();
        }
        if(m_pScene)
        {
                m_pScene->Delete();
                SDL_Quit();
                m_pScene->DeleteOptions();
                delete m_pScene;
                m_pScene = NULL;
        }
        if(m_pGameData)
        {
                delete m_pGameData;
                m_pGameData = NULL;
        }
        if(m_pVM)
        {
                delete m_pVM;
                m_pVM = NULL;
        }
}

bool K3dEngine::ToggleFullscreen()
{

    m_bIsFullscreen = !m_bIsFullscreen;
        if(!m_bIsFullscreen)// From fullscreen to the window
        {
        m_uiFlags = SDL_OPENGL|SDL_RESIZABLE;
        }
        else// From window to the fullscreen
        {
                m_uiFlags = SDL_OPENGL|SDL_RESIZABLE|SDL_FULLSCREEN;
        }
        // Try toggle (works only in x11)
        if(SDL_WM_ToggleFullScreen(m_pScreen) == 0)
        {
                fprintf(stderr, "Unable to toggle fullscreen,""Trying to recreate window\n");
        cerr << "SDL_WM_ToggleFullScreen doesn`t work in win32. I must reinit engine..." << endl;
                SDL_FreeSurface(m_pScreen);
                cout << "SDL_FreeSurface(m_pScreen); -- OK" << endl;
                Destroy();
        // Reinit engine
        if(!Init(m_argc, m_argv, true))
        {
                Destroy();
                return false;
        }
    }

        return true;
}

bool K3dEngine::ProcessEvent()
{
        SDL_Event event;
        while(SDL_PollEvent(&event))
        {
                switch(event.type)
                {
                case SDL_KEYDOWN:
                        
                        switch(event.key.keysym.sym)
                        {
                        case SDLK_ESCAPE:
                                //return false;
                                break;

                        // F1 - toggle fullscreen/window
                        case SDLK_F1:
                                if(!ToggleFullscreen())
                                        return false;
                                break;
                        
                        case SDL_BUTTON_WHEELUP:
                        printf("Wheel Up\n");
                        break;

                        default:
                                break;
                        }
                        break;
                        // Change screen size
                case SDL_VIDEORESIZE:
                        {
                                TGraphicOption *ptGOption = m_pGameData->GetGraphicOption();
                                int iBpp = ptGOption->iColorBits;
                                unsigned int uiFlags = ptGOption->uiFlags;
                                m_pScreen = SDL_SetVideoMode(event.resize.w, event.resize.h, iBpp, uiFlags);
                                if(m_pScreen == NULL)
                                {
                                        printf("Window creation failed\n");
                                        m_pScene->PrintParams(event.resize.w, event.resize.h, iBpp, false);
                                        fprintf(stderr, "SDL_GetError(): %s\n", SDL_GetError());
                                        cerr << SDL_GetError() << endl;
                                }
                                // Set screen to the graphics options
                                ptGOption->ptScreen = m_pScreen;
                                // Set new perspective projection
                                m_pScene->ResizeGL(event.resize.w, event.resize.h);
                                // Set target plane if resize window
                                m_pScene->SetTargetPlane(event.resize.w, event.resize.h);
                        }
                        break;

                case SDL_QUIT:
                        return false;
                        break;
                
                case SDL_MOUSEMOTION:
                        // Get relative mouse cursor position
                        m_pGameData->GetMouse()->MousePositionRel()[0] = event.motion.xrel;
                        m_pGameData->GetMouse()->MousePositionRel()[1] = event.motion.yrel;
                        // Get mouse cursor position
                        m_pGameData->GetMouse()->MousePosition()[0] = event.motion.x;
                        m_pGameData->GetMouse()->MousePosition()[1] = event.motion.y;
                        break;

                case SDL_MOUSEBUTTONDOWN:
                        if(event.button.button == SDL_BUTTON_WHEELUP)
                        {
                                m_pGameData->GetMouse()->MouseWheelButtonUp() = true;
                                //m_pGameData->GetMouse()->MouseWheelButtonDown() = false;
                        }
                        if(event.button.button == SDL_BUTTON_WHEELDOWN)
                        {       
                                m_pGameData->GetMouse()->MouseWheelButtonDown() = true;
                                //m_pGameData->GetMouse()->MouseWheelButtonUp() = false;
                        }
                        break;

                case SDL_MOUSEBUTTONUP:
                        if(event.button.button == SDL_BUTTON_WHEELUP)
                        {
                                //m_pGameData->GetMouse()->MouseWheelButtonUp() = false;
                        }
                        else if(event.button.button == SDL_BUTTON_WHEELDOWN)
                        {       
                                //m_pGameData->GetMouse()->MouseWheelButtonDown() = false;
                        }
                        break;
                
                default:
                        break;
                }
                if(m_pScene->GetExit() == true)
                {
                        return false;
                }
                /*
                 * Now that we are done polling and using SDL events we pass
                 * the leftovers to the SDLInput object to later be handled by
                 * the Gui.
                 */
                gcn::SDLInput* pGuiInput = m_pScene->GetInput();
                if(pGuiInput)
                {
                        pGuiInput->pushInput(event);
                }
        }
        return true;
}

int K3dEngine::Start()
{
        // Main program loop
        bool done = false;
        while(!done)
        {
                done = !ProcessEvent();
                // Update scene
                m_pScene->Update();
                // Call Lua function Update() from script
                m_pVM->Engine_Update();
                // Draw scene
                m_pScene->Draw();
                // Update the screen
                glFlush();
                SDL_GL_SwapBuffers();
        }
        Destroy();
        return 0;
}

---