GlutIOModule.h

Go to the documentation of this file.

/*
  GLUT I/O Module
  1.0-0.5
  
  Copyright (C) 2006-2010 Alexandre R.J. Francois
  
  Author: Alexandre R.J. Francois - alexandrefrancois@yahoo.com
  alexandrefrancois.org
  
  OpenVE: Open Virtuality Engine
  openve.sourceForge.net
  
  This code is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
  
  This code 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
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this code; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef GLUTIO_MODULE_H
#define GLUTIO_MODULE_H


// This module contains platform dependent code
// Mac OS X: Carbon OpenGL extensions
// Linux: GLX extensions


// define only one of the following
// ideally in a platform-specific Makefile
// #define GLUTIO_CARBON
// #define GLUTIO_X11
// #define GLUTIO_WIN32

#include "FsfCell.h"
#include "ImageModule.h"

// Include the OpenGL headers

#ifdef GLUTIO_CARBON
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#include <OpenGL/OpenGL.h>
#include <GLUT/glut.h>
#endif

#ifdef GLUTIO_X11
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glx.h>
#include <GL/glut.h>
#endif

#ifdef GLUTIO_WIN32
#include <windows.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <glut.h>
#endif

// for debugging
#include <iostream>

namespace glutio{


    

    using namespace std;

    void registerFactories();

    // declare input cell types
    class CListenKeyboard;
    class CListenMouse;
    class CListenJoystick;


    // GlutIO //

    class CGlutIO{
    private:
        static CGlutIO *m_pSingle; 
        CGlutIO() {} 

        static fsf::CMutex m_csContext; 
        static int m_nWidth; 
        static int m_nHeight; 

#ifdef GLUTIO_CARBON
        static CGLContextObj m_context; 
#endif

#ifdef GLUTIO_X11
        static Display* m_display; 
        static GLXDrawable m_drawable; 
        static GLXContext m_context; 
#endif

#ifdef GLUTIO_WIN32
        static HDC m_hdc; 
        static HGLRC m_context; 
#endif


        static CListenKeyboard *m_pKb; 
        static CListenMouse *m_pMs; 
        static CListenJoystick *m_pJs; 

        
    public:

        static CGlutIO* getInstance(){
            if(m_pSingle!=NULL)
                return m_pSingle;
            else
                return (m_pSingle=new CGlutIO);
        }
        static void deleteInstance(){
            if(m_pSingle!=NULL){
                delete m_pSingle;
                m_pSingle=NULL;
            }
        }
        ~CGlutIO() {}



        static void init(bool bKeyboard=true, bool bMouse=false, bool bMotion=false, bool bPassiveMotion=false, bool bJoystick=false);
        static void mainLoop() { glutMainLoop(); }

        static int getWidth() { return m_nWidth; }
        static int getHeight() { return m_nHeight; }

        static void registerListenKeyboardCell(CListenKeyboard *pKb);
        static void registerListenMouseCell(CListenMouse *pMs, bool bClick=true, bool bMotion=false, bool bActiveMotion=false);
        static void registerListenJoystickCell(CListenJoystick *pJs, int pollInterval); // poll interval in ms



        static void displayCb(void);
        static void idleCb();
        static void reshapeCb(int width, int height);
        static void keyCb(unsigned char key, int x, int y);
        static void specialKeyCb(int key, int x, int y);
        static void mouseCb(int button, int state, int x, int y);
        static void motionCb(int x, int y);
        static void passiveMotionCb(int x, int y);
        static void joystickCb(unsigned int buttonMask, int x, int y, int z);


#ifdef GLUTIO_CARBON
        static void obtainContext() { m_csContext.lock(); CGLSetCurrentContext(m_context); }
        static void releaseContext() { CGLSetCurrentContext(NULL); m_csContext.unlock(); }
#endif

#ifdef GLUTIO_X11
        static void ObtainContext() {
            m_csContext.lock();
            XFlush(m_display);
            glXMakeCurrent(m_display,m_drawable,m_context);
            glXWaitX();
        }
        static void ReleaseContext() {
            glXWaitGL();
            glXMakeCurrent(m_display,None,NULL);
            m_csContext.unlock();
        }
#endif

#ifdef GLUTIO_WIN32
        static void ObtainContext() { m_csContext.lock(); wglMakeCurrent(m_hdc,m_context); }
        static void ReleaseContext() { wglMakeCurrent(NULL,NULL); m_csContext.unlock(); }
#endif

    };
        
    
    // Keyboard input //
    
    class CKeyboardEvent : public fsf::CNode {
    private:
        unsigned char m_key; 
        int m_special; 
        int m_modif; 
        int m_x; 
        int m_y; 
    public:



        CKeyboardEvent() : CNode(), m_key(0), m_special(-1), m_modif(0), m_x(-1), m_y(-1) {}
        CKeyboardEvent(fsf::CNode *pParent, fsf::Time tTime=0) : CNode(pParent,tTime), m_key(0), m_special(-1), m_modif(0), m_x(-1), m_y(-1) {}
        CKeyboardEvent(std::string &strName, fsf::CNode *pParent=NULL, fsf::Time tTime=0)
            : CNode(strName,pParent,tTime), m_key(0), m_special(-1), m_modif(0), m_x(-1), m_y(-1) {}
        CKeyboardEvent(unsigned char key, int modif, int x, int y, fsf::CNode *pParent=NULL, fsf::Time tTime=0)
            : CNode(pParent,tTime), m_key(key), m_special(-1), m_modif(modif), m_x(x), m_y(y) {}
        CKeyboardEvent(std::string &strName, unsigned char key, int modif, int x, int y, fsf::CNode *pParent=NULL, fsf::Time tTime=0)
            : CNode(strName,pParent,tTime), m_key(key), m_special(-1), m_modif(modif), m_x(x), m_y(y) {}
        CKeyboardEvent(int special, int modif, int x, int y, fsf::CNode *pParent=NULL, fsf::Time tTime=0)
            : CNode(pParent,tTime), m_key(0), m_special(special), m_modif(modif), m_x(x), m_y(y) {}
        CKeyboardEvent(std::string &strName, int special, int modif, int x, int y, fsf::CNode *pParent=NULL, fsf::Time tTime=0)
            : CNode(strName,pParent,tTime), m_key(0), m_special(special), m_modif(modif), m_x(x), m_y(y) {}
        CKeyboardEvent(const CKeyboardEvent &rhs) : CNode(rhs) {
            m_key=rhs.m_key; m_special=rhs.m_special; m_modif=rhs.m_modif; m_x=rhs.m_x; m_y=rhs.m_y;
        }
        // Cloning: necessary for run-time polymorphism
        virtual fsf::CNode *clone() const { return new CKeyboardEvent(*this); } 
        


        CKeyboardEvent& operator=(const CKeyboardEvent&);

        void setKey(unsigned char key) { m_key=key; }
        void setSpecial(int special) { m_special=special; }
        void setModifier(int modif) { m_modif=modif; }
        void setX(int x) { m_x=x; }
        void setY(int y) { m_y=y; }     

        bool isSpecial() { return (m_special>0); }



        virtual void getTypeID(std::string &str) const { str.assign("GLUTIO_KEYBOARD_EVENT"); }

        unsigned char getKey() const { return m_key; }
        int getSpecial() const { return m_special; }
        int getModifier() const { return m_modif; }
        int getX() const { return m_x; }
        int getY() const { return m_y; }
    };
    
    class CListenKeyboard : public fsf::CCell {
    public:
        CListenKeyboard();
        virtual void getTypeID(std::string &str) const { str.assign("GLUTIO_LISTEN_KEYBOARD"); }
        void makePulse(CKeyboardEvent *pNode);
    };
    
    

    // Mouse input //
    
    class CMouseEvent : public fsf::CNode {
    private:
        int m_button; 
        int m_state; 
        int m_x; 
        int m_y; 
    public:


        CMouseEvent() : CNode(), m_button(-1), m_state(-1), m_x(-1), m_y(-1) {}
        CMouseEvent(fsf::CNode *pParent, fsf::Time tTime=0) : CNode(pParent,tTime), m_button(-1), m_state(-1), m_x(-1), m_y(-1) {}
        CMouseEvent(std::string &strName, fsf::CNode *pParent=NULL, fsf::Time tTime=0)
            : CNode(strName,pParent,tTime), m_button(-1), m_state(-1), m_x(-1), m_y(-1) {}
        CMouseEvent(int button, int state, int x, int y, fsf::CNode *pParent=NULL, fsf::Time tTime=0)
            : CNode(pParent,tTime), m_button(button), m_state(state), m_x(x), m_y(y) {}
        CMouseEvent(std::string &strName, int button, int state, int x, int y, fsf::CNode *pParent=NULL, fsf::Time tTime=0)
            : CNode(strName,pParent,tTime), m_button(button), m_state(state), m_x(x), m_y(y) {}
        CMouseEvent(const CMouseEvent &rhs) : CNode(rhs) {
            m_button=rhs.m_button; m_state=rhs.m_state; m_x=rhs.m_x; m_y=rhs.m_y;
        }
        


        CMouseEvent& operator=(const CMouseEvent&);
        void setButton(int button) { m_button=button; }
        void setState(int state) { m_state=state; }
        void setX(int x) { m_x=x; }
        void setY(int y) { m_y=y; }



        virtual fsf::CNode *clone() const { return new CMouseEvent(*this); }
        virtual void getTypeID(std::string &str) const { str.assign("GLUTIO_MOUSE_EVENT"); }
        int getButton() const { return m_button; }
        int getState() const { return m_state; }
        int getX() const { return m_x; }
        int getY() const { return m_y; }
    };
    
    class CListenMouse : public fsf::CCell {
    public:
        CListenMouse();
        virtual void getTypeID(std::string &str) const { str.assign("GLUTIO_LISTEN_MOUSE"); }
        void makePulse(CMouseEvent *pNode);
    };
    

    // Joystick input //
    
    class CJoystickState : public fsf::CNode {
    private:
        int m_buttonMask; 
        int m_x;      
        int m_y;      
        int m_z;      
    public:


        CJoystickState() : CNode(), m_buttonMask(0), m_x(0), m_y(0), m_z(0) {}
        CJoystickState(fsf::CNode *pParent, fsf::Time tTime=0) : CNode(pParent,tTime), m_buttonMask(0), m_x(0), m_y(0), m_z(0) {}
        CJoystickState(std::string &strName, fsf::CNode *pParent=NULL, fsf::Time tTime=0)
            : CNode(strName,pParent,tTime), m_buttonMask(0), m_x(0), m_y(0), m_z(0) {}
        CJoystickState(int buttonMask, int x, int y, int z, fsf::CNode *pParent=NULL, fsf::Time tTime=0)
            : CNode(pParent,tTime), m_buttonMask(buttonMask), m_x(x), m_y(y), m_z(z) {}
        CJoystickState(std::string &strName, int buttonMask, int x, int y, int z, fsf::CNode *pParent=NULL, fsf::Time tTime=0)
            : CNode(strName,pParent,tTime), m_buttonMask(buttonMask), m_x(x), m_y(y), m_z(z) {}
        CJoystickState(const CJoystickState &rhs) : CNode(rhs) {
            m_buttonMask=rhs.m_buttonMask; m_x=rhs.m_x; m_y=rhs.m_y; m_z=rhs.m_z;
        }
        virtual fsf::CNode *clone() const { return new CJoystickState(*this); }



        CJoystickState& operator=(const CJoystickState&);

        void setButtonMask(int buttonMask) { m_buttonMask=buttonMask; }
        void setX(int x) { m_x=x; }
        void setY(int y) { m_y=y; }
        void setZ(int z) { m_z=z; }



        // Factory mapping key
        virtual void getTypeID(std::string &str) const { str.assign("GLUTIO_JOYSTICK_STATE"); }

        // Access
        int getButtonMask() const { return m_buttonMask; }
        int getX() const { return m_x; }
        int getY() const { return m_y; }
        int getZ() const { return m_z; }

    };
    
    class CListenJoystick : public fsf::CCell {
    public:
        CListenJoystick();
        virtual void getTypeID(std::string &str) const { str.assign("GLUTIO_LISTEN_JOYSTICK"); }
        void makePulse(CJoystickState *pNode);
    };
    




    // Image display //


    class CDisplayRaster : public fsf::CCell {
    public:
        CDisplayRaster();
        // Gets this cell's factory mapping key
        virtual void getTypeID(std::string &str) { str.assign("GLUTIO_DISPLAY_RASTER"); }
        // Custom processing function
        virtual void process(fsf::CPassiveHandle *pPassiveHandle, fsf::CActiveHandle *pActiveHandle, fsf::CActivePulse *pActivePulse);  
    };


    // Display surface node
    class CSurface : public fsf::CNode {
    private:
        fsf::CMutex m_csSurface; 


        double m_x; 
        double m_y; 
        double m_w; 
        double m_h; 



        double m_u1; 
        double m_v1; 
        double m_u2; 
        double m_v2; 

        GLuint m_texture; 

    public:


        CSurface();
        CSurface(fsf::CNode *pParent, fsf::Time tTime=0);
        CSurface(const std::string &strName, fsf::CNode *pParent=NULL, fsf::Time tTime=0);
        CSurface(const CSurface&);
        virtual ~CSurface();
        virtual fsf::CNode *clone() const { return new CSurface(*this); }



        CSurface& operator=(const CSurface&);
        void setCanvas(double x, double y, double w, double h){
            m_x=x;
            m_y=y;
            m_w=w;
            m_h=h;
        }
        void setTexture(double u1, double v1, double u2, double v2){
            m_u1=u1;
            m_v1=v1;
            m_u2=u2;
            m_v2=v2;
        }
        void refreshTexture(image::CImage *pImage);
        void draw();



        virtual void getTypeID(string &str) const { str.assign("GLUTIO_SURFACE"); }
        double getX() const { return m_x; }
        double getY() const { return m_y; }
        double getW() const { return m_w; }
        double getH() const { return m_h; }

    };

    class CDisplaySurface : public fsf::CCell {
    public:
        CDisplaySurface();
        // Gets this cell's factory mapping key
        virtual void getTypeID(std::string &str) const { str.assign("GLUTIO_DISPLAY_SURFACE"); }
        // Custom processing function:
        virtual void process(fsf::CPassiveHandle *pPassiveHandle, fsf::CActiveHandle *pActiveHandle, fsf::CActivePulse *pActivePulse);  
    };

} // namespace glutio

#endif

---