OpenGLUtilities.h

Go to the documentation of this file.

/*

Copyright (c) 2017, Dr Franck P. Vidal (franck.p.vidal@fpvidal.net),
http://www.fpvidal.net/
All rights reserved.

Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.

3. Neither the name of the Bangor University nor the names of its contributors
may be used to endorse or promote products derived from this software without
specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/


#ifndef __OpenGLUtilities_h
#define __OpenGLUtilities_h


//******************************************************************************
//  Include
//******************************************************************************
#ifndef __gVirtualXRayConfig_h
#include "gVirtualXRay/gVirtualXRayConfig.h"
#endif

#include <vector>

#ifndef __Matrix4x4_h
#include "gVirtualXRay/Matrix4x4.h"
#endif

#ifndef __Types_h
#include "gVirtualXRay/Types.h"
#endif

#ifndef __VBO_h
#include "gVirtualXRay/VBO.h"
#endif

#ifndef __OpenGL2VBO_h
#include "gVirtualXRay/OpenGL2VBO.h"
#endif

#ifndef __OpenGL3VBO_h
#include "gVirtualXRay/OpenGL3VBO.h"
#endif


//******************************************************************************
//  namespace
//******************************************************************************
namespace gVirtualXRay {

  class OpenGL2VBO;
  class OpenGL3VBO;


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void initialiseGLAD(const std::string& anAPI);


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void initializeGLAD(const std::string& anAPI);


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void initialiseGLEW();


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void initializeGLEW();


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
void checkOpenGLErrorStatus(const char* aFileName,
                            const char* aFunctionName,
                            int aLineNumber);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
void checkFBOErrorStatus(const char* aFileName,
                         const char* aFunctionName,
                         int aLineNumber);


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void pushProjectionMatrix();


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void pushModelViewMatrix();


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void pushFBO();


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void pushTexture1D();


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void pushTexture2D();


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void pushTextureRectangle();


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void pushTexture3D();


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
void pushEnableDisableState(int aParameter);


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void pushShaderProgram();


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void popProjectionMatrix();


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void popModelViewMatrix();


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void popFBO();


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void popTexture();


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void popEnableDisableState();


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void popShaderProgram();


//--------------------------------------------------------------------------

//--------------------------------------------------------------------------
gVirtualXRay::Matrix4x4<float> getCurrentOpenGLMatrix();


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void loadIdentityProjectionMatrix();


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void loadIdentityModelViewMatrix();


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
void loadFrustumProjectionMatrix(double left,
        double right,
        double bottom,
        double top,
        double near,
        double far);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
void loadPerspectiveProjectionMatrix(double fovy,
                                     double aspect,
                                     double zNear,
                                     double zFar);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
void loadOrthoProjectionMatrix(double left,
        double right,
        double bottom,
        double top,
        double near,
        double far);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
MATRIX4 buildOrthoProjectionMatrix(double left,
        double right,
        double bottom,
        double top,
        double near,
        double far);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
MATRIX4 buildFrustumProjectionMatrix(double left,
        double right,
        double bottom,
        double top,
        double near,
        double far);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
MATRIX4 buildPerspectiveProjectionMatrix(double fovy,
        double aspect,
        double zNear,
        double zFar);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
void loadLookAtModelViewMatrix(const VEC3& eye,
        const VEC3& centre,
        const VEC3& up);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
void loadLookAtModelViewMatrix(double eyeX,
        double eyeY,
        double eyeZ,
        double centreX,
        double centreY,
        double centreZ,
        double upX,
        double upY,
        double upZ);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
MATRIX4 buildLookAtModelViewMatrix(const VEC3& eye,
          const VEC3& centre,
          const VEC3& up);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
MATRIX4 buildLookAtModelViewMatrix(double eyeX,
        double eyeY,
        double eyeZ,
        double centreX,
        double centreY,
        double centreZ,
        double upX,
        double upY,
        double upZ);


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void loadProjectionMatrixFromOpenGL();


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void loadModelViewMatrixFromOpenGL();


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void applyModelViewMatrix();


//------------------------------------------------------------------------------
/*
* @return   true if the current OpenGL context supports OpenGL 4.5,
*           false otherwise
*/
//------------------------------------------------------------------------------
bool useOpenGL45();


//------------------------------------------------------------------------------
/*
* @return   true if the current OpenGL context supports OpenGL 3.2,
*           false otherwise
*/
//------------------------------------------------------------------------------
bool useOpenGL32();


//------------------------------------------------------------------------------
/*
* @return   true if the current OpenGL context supports Compute Shaders,
*           false otherwise
*/
//------------------------------------------------------------------------------
bool useOpenGLCompute();


//------------------------------------------------------------------------------
/*
* @return the new OpenGL VBO
*/
//------------------------------------------------------------------------------
VBO* createVBO();


//------------------------------------------------------------------------------
/*
* @return the new OpenGL VBO
*/
//------------------------------------------------------------------------------
OpenGL2VBO* createOpenGL2VBO();


//------------------------------------------------------------------------------
/*
* @return the new OpenGL VBO
*/
//------------------------------------------------------------------------------
OpenGL3VBO* createOpenGL3VBO();


std::string getShaderTypeID(const std::type_info& aTypeID);
std::string getShaderImageType(const std::type_info& aTypeID);
std::string getShaderPixelType(const std::type_info& aTypeID);
std::string getShaderRGBAPixelType(const std::type_info& aTypeID);

extern std::vector<MATRIX4> g_p_modelview_matrix_stack;


extern std::vector<MATRIX4> g_p_projection_matrix_stack;


extern MATRIX4 g_current_modelview_matrix;


extern MATRIX4 g_current_projection_matrix;


extern std::vector<int> g_frame_buffer_object_stack;


extern std::vector<std::pair<int, int> > g_texture_stack;


extern std::vector<std::pair<int, bool> > g_enable_disable_state_stack;


extern std::vector<int> g_shader_program_stack;


} // namespace gVirtualXRay


//******************************************************************************
#include "OpenGLUtilities.inl"


#endif // __OpenGLUtilities_h