root / branches / cpp-ode / src / mmpong-gl / client_gl.cc @ 537

#include "client_gl.h"

using namespace mmp;

ClientGL::ClientGL(std::string _host, std::string _port, std::string _player,
                   int _win_width, int _win_height, bool _full) :
                netclient(NetGameCreator::pointer(new NetGameCreatorGL(_player, "/usr/share/mmpong-gl/")), _host, _port),
                win_width(_win_width), win_height(_win_height), full(_full), grab(false) {
                
        //init SDL
        if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0)
                throw runtime_error(string("Renderer: Unable to initialize SDL: ") + SDL_GetError());

        SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
        SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, 1);
        //SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
        //SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, 4);
        //SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, 4);
        //SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, 4);
        //SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, 4);

        //use SDL_GetVideoInfo call before SDL_SetVideoMode to get screen resolution
        const SDL_VideoInfo *info = SDL_GetVideoInfo();
        if (!info)
                throw runtime_error("ClientGL: Unable to get video info");
        full_width = info->current_w;
        full_height = info->current_h;
        video_flags = SDL_OPENGL | (info->hw_available ? SDL_HWSURFACE : SDL_SWSURFACE);

        SDL_WM_SetCaption("MMPong", NULL);
        /*SDL_Surface *icon = IMG_Load(Res::get("icon/mmpong.png").c_str());
        if (icon)
                SDL_WM_SetIcon(icon, NULL);
        else
                cerr << "could not load bitmap: "<< Res::get("icon/mmpong.png") << endl;
        */

        SDL_ShowCursor(0);

        resize();
        
# if !(defined(__APPLE__) || defined(WIN32))
        renderer.init();
# endif
}

ClientGL::~ClientGL() {
        renderer.quit();
        SDL_Quit();
}

void ClientGL::run() {

        SDL_Event event;
        uint8_t *key_state;
        uint32_t mouse_state;
        int mouse_x, mouse_y;

        const boost::posix_time::time_duration framedur=boost::posix_time::milliseconds(1000.0/FRAMERATE);
        
        while (netclient.get_con_active()) {
                NetGame::pointer game=netclient.get_game();
                
                while (SDL_PollEvent(&event)) {
                        if (event.type == SDL_QUIT) {
                                return;
                        }
                        if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_q) {
                                return;
                        }                               
                        if (event.type == SDL_VIDEORESIZE) {
                                win_width = event.resize.w;
                                win_height = event.resize.h;
                                resize();
                        }
                        if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_RETURN) {
                                full = !full;
                                resize();
                        }
                        if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_SPACE) {
                                grab = !grab;
                                SDL_WM_GrabInput(grab ? SDL_GRAB_ON : SDL_GRAB_OFF);
                                SDL_WM_SetCaption(grab ? "MMPong (Press space bar to release pointer)" : "MMPong", NULL);
                        }                       
                        if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_HOME) {
                                renderer.reset_view();
                        }
                        
                }
                
                key_state = SDL_GetKeyState(NULL);
                mouse_state = SDL_GetRelativeMouseState(&mouse_x, &mouse_y);

                if (key_state[SDLK_PAGEUP]) {
                        renderer.change_view(0.0f, 3.0f*CAM_SPEED);
                }
                if (key_state[SDLK_PAGEDOWN]) {
                        renderer.change_view(0.0f, -3.0f*CAM_SPEED);
                }
                if ((mouse_state & SDL_BUTTON(3)) && (mouse_x != 0 || mouse_y != 0)) {
                        renderer.change_view(mouse_x*CAM_SPEED, mouse_y*CAM_SPEED);
                }
                else if (mouse_x != 0 || mouse_y != 0) {
                        //paddle control here!
                }

                boost::posix_time::ptime renderbegin = boost::posix_time::microsec_clock::universal_time();
                
                renderer.begin();
                if (game)
                        game->render();
                renderer.end();
                
                boost::posix_time::ptime renderend = boost::posix_time::microsec_clock::universal_time();
                boost::posix_time::time_duration renderdur=renderend-renderbegin, waitdur=framedur-renderdur;
                LOG("Rendering: " << renderdur << " => Waiting " << waitdur);
                boost::this_thread::sleep(waitdur);
        }       
}

void ClientGL::resize() {
        //gui.prepare();
        
        if ((surface = SDL_SetVideoMode(get_width(), get_height(), 0, video_flags | (full ? SDL_FULLSCREEN : SDL_RESIZABLE))) == NULL)
                throw runtime_error(std::string("ClientGL: Unable to create OpenGL screen: ") + SDL_GetError());

        //gui.resize(get_width(), get_height());
        renderer.resize(get_width(), get_height());
}