moGLManager.h

Go to the documentation of this file.

/*******************************************************************************

                                moGLManager.h

  ****************************************************************************
  *                                                                          *
  *   This source 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 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      *
  *   General Public License for more details.                               *
  *                                                                          *
  *   A copy of the GNU General Public License is available on the World     *
  *   Wide Web at <http://www.gnu.org/copyleft/gpl.html>. You can also       *
  *   obtain it by writing to the Free Software Foundation,                  *
  *   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.         *
  *                                                                          *
  ****************************************************************************

  Copyright(C) 2006 Fabricio Costa

  Authors:
  Fabricio Costa
  Andrés Colubri

*******************************************************************************/

#ifndef __MO_GLMANAGER_H__
#define __MO_GLMANAGER_H__

#define MO_GPU_NV 0
#define MO_GPU_ATI 1
#define MO_GPU_INTEL 2
#define MO_GPU_OTHER 3

#include "moTypes.h"
#include "moText.h"
#include "moMathMatrix.h"
#include "moShaderGLSL.h"
#include "moFBO.h"

#include "moResourceManager.h"


typedef void* moGLContext;
typedef void* moDisplayServer;
typedef void* moDisplayScreen;
typedef void* moDisplayWindow;

/*
class moGLContext {

    public:
        moGLContext();
        virtual ~moGLContext();

    void *m_Context;
};
*/



class  LIBMOLDEO_API moGLMatrixf : public moMatrix4f {

  public:
    moGLMatrixf(bool bZero = true) : moMatrix4f(bZero) {}
    moGLMatrixf( const moMatrix4f& p_src ) : moMatrix4f( p_src ) {}
    moGLMatrixf( const moGLMatrixf& rkM );
    moGLMatrixf& operator= (const moGLMatrixf& rkM );
    virtual ~moGLMatrixf() {}
    //const moGLMatrixf& operator= (const moMatrix4f& p_src );

//    operator const moMatrix4f* () const { return (moMatrix4f*) this; }
    inline operator const float* () const { return moMatrix4f::GetPointer(); }
    inline operator float* () { return moMatrix4f::GetPointer(); }
    //inline const float* operator[] (int iRow) const { return moMatrix4f::GetRow(iRow); }
    //inline float* operator[] (int iRow) { return moMatrix4f::GetRow(iRow); }
   // inline float operator() (int iRow, int iCol) const { return moMatrix4f::Get( iRow, iCol); }
   // inline float& operator() (int iRow, int iCol) { return m_afEntry[iCol+4*iRow]; }

    moGLMatrixf& MakeIdentity();
    moGLMatrixf& MakeZero();
    moGLMatrixf& MakePerspective( float fovy,  float aspect,  float zNear,  float zFar );
    moGLMatrixf& MakeLookAt( float eyeX=0.0,  float eyeY=0.0,  float eyeZ=-10.0,  float centerX=0.0,  float centerY=0.0,  float centerZ=0.0,  float upX=0.0,  float upY=0.0,  float upZ=1.0 );
    moGLMatrixf& MakeFrustrum( float left=-1.0, float right=1.0, float bottom=-1.0, float top=1.0, float near=0.0001, float far=1000.0f  );
    moGLMatrixf& MakeOrthographic( float left=-1.0, float right=1.0, float bottom=-1.0, float top=1.0, float near=0.0001, float far=1000.0f  );
    moGLMatrixf& Translate( float x, float y, float z );
    moGLMatrixf& Translate( const moGLMatrixf& m, float x, float y, float z );
    moGLMatrixf& Rotate( float angle, float vx, float vy, float vz );
    moGLMatrixf& Rotate( const moGLMatrixf& m, float rx, float ry, float rz );
    moGLMatrixf& Scale( float sx, float sy, float sz );
    moGLMatrixf& Scale( const moGLMatrixf& m, float sx, float sy, float sz );

    moText ToJSON() const;
    static const moGLMatrixf ZERO;
    static const moGLMatrixf IDENTITY;

};


class  LIBMOLDEO_API moGLMatrixd : public moMatrix4d {
  public:
    moGLMatrixd() : moMatrix4d() {  }
    virtual ~moGLMatrixd() { }
};

class  LIBMOLDEO_API moGLViewport : public moVector2f {

  public:
    moGLViewport( float p_width=1.0, float p_height=1.0 ): moVector2f() {
      X()=p_width;
      Y()=p_height;
      Proportion = 1.0;
      if (Y()>0.0) {
        Proportion = X()/Y();
      }
  }
    virtual ~moGLViewport() {}

    moGLViewport( const moGLViewport& p_src ): moVector2f() {
      (*this) = p_src;
    }

    moGLViewport& operator= ( const moGLViewport& p_src ) {
      X() = p_src.X();
      Y() = p_src.Y();
      Proportion = p_src.Proportion;
      return (*this);
    }

    float GetWidth() { return X(); }
    float GetHeight() { return Y(); }
    float GetProportion() { return Proportion; }
    float GetProportionInvert() { return 1.0/Proportion; }

    float Proportion;

};



class LIBMOLDEO_API moGLManager : public moResource
{
    public:
        moGLManager();
        virtual ~moGLManager();

        virtual MOboolean Init();
        virtual MOboolean Finish();

        MOboolean CheckErrors(moText p_location);

        MOuint GetGPUVendorCode() { return m_gpu_vendor_code; }
        const moText& GetGPUVendorString() { return m_gpu_vendor_string; }
        const moText& GetGPURendererString() { return m_gpu_renderer_string; }

        void SetPerspectiveView(MOint p_width, MOint p_height, double fovy=60.0,  double aspect=1.0,  double znear=0.1,  double zfar=4000.0 );
    void LookAt( float eyeX=0.0,  float eyeY=0.0,  float eyeZ=-10.0,  float centerX=0.0,  float centerY=0.0,  float centerZ=0.0,  float upX=0.0,  float upY=0.0,  float upZ=1.0 );

        void SetDefaultPerspectiveView(MOint p_width, MOint p_height);

        void SetOrthographicView(MOint p_width=0, MOint p_height=0, float left=0.0, float right=1.0, float bottom=0.0, float top=1.0, float znear=-1.0, float zfar=1.0);

    void SetDefaultOrthographicView( MOint p_width=0, MOint p_height=0 );

        MOint GetRenderMode();
        void SetRenderMode(MOint p_mode);

        void SetMoldeoGLState();
        void SetDefaultGLState();
        void SetDefaultPixelStorageModes();
        void SaveGLState();
        void SaveGLMatrices();
        void SaveView();
        void SaveFramebuffer();
        void RestoreGLState();
        void RestoreGLMatrices();
        void RestoreView();
        void RestoreFramebuffer();

        moTexParam BuildFPTexParam(MOboolean p_16bits = true, MOushort p_num_components = 4);
        MOboolean RectTexture(GLenum p_target)  const;
        MOboolean FPTexture(GLint p_internal_format);
        MOboolean MipMapTexture(GLint p_min_filter);

        void SetCurrentFBO(MOuint m_fbo);
        MOuint GetCurrentFBO() { return m_current_fbo; }

        void SetCurrentReadBuffer(MOint p_buffer);
        MOint GetCurrentReadBuffer() { return m_current_read_buffer; }
        void SetCurrentDrawBuffer(MOint p_buffer);
        MOint GetCurrentDrawBuffer() { return m_current_draw_buffer; }
        void SaveFBOState();
        void RestoreFBOState();

    const moText& GetGLVersion() {
      return m_gl_version;
    }

    int GetGLMajorVersion() {
      return m_gl_major_version;
    }
    int GetGLMinorVersion() {
     return m_gl_minor_version;
    }

        int CreateContext( int p_width, int p_height );
    moGLContext GetContext();
    void SetContext(moGLContext p_Context);
    moDisplayServer GetDisplayServer();
    moDisplayScreen  GetDisplayScreen();
    moDisplayWindow  GetDisplayWindow();

        void SetFrameBufferObjectActive( bool active = true );

    moGLMatrixf& GetModelMatrix();
    moGLMatrixf& SetModelMatrix( const moGLMatrixf& p_mat4 );
    moGLMatrixf& GetProjectionMatrix();
    moGLMatrixf& SetProjectionMatrix( const moGLMatrixf& p_mat4 );
    const moGLViewport& GetViewport() const { return m_Viewport; }

    private:

    moGLContext m_Context;
    moDisplayServer m_DisplayServer;
    moDisplayScreen  m_DisplayScreen;
    moDisplayWindow  m_DisplayWindow;

        MOuint m_gpu_vendor_code;
        moText m_gpu_vendor_string;
        moText m_gpu_renderer_string;

    moText m_gl_version;
        MOint m_gl_major_version;
        MOint m_gl_minor_version;

        MOuint m_current_fbo;
        MOint m_current_read_buffer;
        MOint m_current_draw_buffer;
        MOuint m_previous_fbo;
        MOint m_previous_read_buffer;
        MOint m_previous_draw_buffer;
        MOuint m_saved_fbo;
        MOint m_saved_read_buffer;
        MOint m_saved_draw_buffer;

    moGLViewport m_Viewport;
    moGLMatrixf m_ModelMatrix;
    moGLMatrixf m_ProjectionMatrix;
    moGLMatrixf* m_StackModelMatrices;
    moGLMatrixf* m_StackProjectionMatrices;

        bool    m_bFrameBufferObjectActive;

        void QueryGPUVendorString();
};


#endif