src/backend/glutApp.h

Go to the documentation of this file.

#ifndef GLUTAPP_H
#define GLUTAPP_H

#include <string>
#include <vector>
#include <iostream>
#include <boost/shared_ptr.hpp>

// This should ALWAYS use glut headers, so just include them
// rather than include "GLHeaders.h"
#include "GLHeaders.h"
#include "util/Error.h"
#include "Application.h"

namespace green
{
        class glutApp
        {
        public:
                glutApp() {
                        if(!glutApp::initialized)
                                glutApp::_initialize();
                        mWindowID = -1;
                }

                virtual ~glutApp() {}
                
                int CreateWindow(std::string name, unsigned int displayMode, 
                                                        int width, int height);
                                                        
                
                virtual void RegisterGLUTCallbacks();
                
                void SetCurrent(ApplicationPtr app) {
                        if(glutApp::currentApp.get())
                                THROW_ERROR("there is already a running application");
                        glutApp::currentApp = app;
                }
                
                virtual void Init();
                
                virtual void Run();
                
                int WindowWidth() const;
                int WindowHeight() const;
                

                
        protected:
                static inline
                Application::MouseButton ConvertGLUTButton(int glutButton) {
                        Application::MouseButton button;
                        switch(glutButton)
                        {
                                case GLUT_LEFT_BUTTON:
                                        button = Application::LEFT_BUTTON;
                                        break;
                                case GLUT_RIGHT_BUTTON:
                                        button = Application::RIGHT_BUTTON;
                                        break;
                                case GLUT_MIDDLE_BUTTON:
                                        button = Application::MIDDLE_BUTTON;
                                        break;
                                default:
                                        THROW_ERROR("unknown glut button type");
                                        break;
                        }
                        return button;
                }
                
                static inline
                Application::MouseState ConvertGLUTState(int state) {
                        Application::MouseState ret;
                        switch(state)
                        {
                                case GLUT_UP:
                                        ret = Application::UP;
                                        break;
                                case GLUT_DOWN:
                                        ret = Application::DOWN;
                                        break;
                                default:
                                        THROW_ERROR("unknown glut mouse state");
                                        break;
                        }
                        return ret;
                }
                
                // mWindowIDs contains all the window ID's this app has created
                // these are the ID's returned from glutCreateWindow
                // std::vector<int> mWindowIDs; 
                int mWindowID;
                                
                static ApplicationPtr currentApp; 
                static bool initialized; 
                
                static void _initialize();

                // these are the callback functions that get registered to glut
                // see above for descriptions of these functions, they are the same
                
                static void _display();
                static void _reshape(int width, int height);
                static void _motion(int x, int y);
                static void _mouse(int button, int state, int x, int y);
                static void _keyboard(unsigned char ch, int x, int y);
                static void _keyboard_up(unsigned char ch, int x, int y);
                
        };
        typedef boost::shared_ptr<glutApp> glutAppPtr;
}

#endif

---