OpenGLModule.h

Go to the documentation of this file.

/*
  OpenGL Module
  1.0-1.0
  
  Copyright (C) 2006-2010 Alexandre R.J. Francois
  
  Author: Alexandre R.J. Francois - alexandrefrancois@yahoo.com
  www.alexandrefrancois.org
  
  Modular Flow Scheduling Middleware
  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 OPENGL_MODULE_H
#define OPENGL_MODULE_H

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

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

#include "FsfCell.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

#include <iostream>

namespace ogl{
    



    void registerFactories();

    class CCamera : public fsf::CNode {
    private:
        fsf::CMutex m_csCamera; 


        double m_dX,m_dY,m_dZ; // Position of the camera center
        double m_dRefX,m_dRefY,m_dRefZ; // Position of the reference point
        double m_dUpX,m_dUpY,m_dUpZ; // Up vector

        double m_dNear;
        double m_dFar;
        

        double m_dLeft; 
        double m_dRight; 
        double m_dBottom; 
        double m_dTop; 

        
    public:


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



        CCamera& operator=(const CCamera&);

        void lockCamera() { m_csCamera.lock(); }
        void unlockCamera() { m_csCamera.unlock(); }

        void setX(double d) { m_dX=d; }
        void setY(double d) { m_dY=d; }
        void setZ(double d) { m_dZ=d; }
        
        void setRefX(double d) { m_dRefX=d; }
        void setRefY(double d) { m_dRefY=d; }
        void setRefZ(double d) { m_dRefZ=d; }

        void setUpX(double d) { m_dUpX=d; }
        void setUpY(double d) { m_dUpY=d; }
        void setUpZ(double d) { m_dUpZ=d; }

        void setNearDistance(double dNear) { m_dNear=dNear; }
        void setFarDistance(double dFar) { m_dFar=dFar; }

        void setLeft(double dLeft) { m_dLeft=dLeft; }
        void setRight(double dRight) { m_dRight=dRight; }
        void setBottom(double dBottom) { m_dBottom=dBottom; }
        void setTop(double dTop) { m_dTop=dTop; }

        void frustum(){
            glFrustum(m_dLeft,m_dRight,m_dBottom,m_dTop,m_dNear,m_dFar);
        }
        void ortho(){
            glOrtho(m_dLeft,m_dRight,m_dBottom,m_dTop,m_dNear,m_dFar);
        }
        void lookAt(){
            gluLookAt(m_dX,m_dY,m_dZ,
                      m_dRefX,m_dRefY,m_dRefZ,
                      m_dUpX,m_dUpY,m_dUpZ);
        }
        

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

        double getX() const { return m_dX; }
        double getY() const { return m_dY; }
        double getZ() const { return m_dZ; }

        double getRefX() const { return m_dRefX; }
        double getRefY() const { return m_dRefY; }
        double getRefZ() const { return m_dRefZ; }

        double getUpX() const { return m_dUpX; }
        double getUpY() const { return m_dUpY; }
        double getUpZ() const { return m_dUpZ; }
        
        double getNearDistance() const { return m_dNear; }
        double getFarDistance() const { return m_dFar; }
        
        double getLeft() const { return m_dLeft; }
        double getRight() const { return m_dRight; }
        double getBottom() const { return m_dBottom; }
        double getTop() const { return m_dTop; }
    };


} // namespace ogl

#endif // OPENGL_MODULE_H

---