Singleton class holding all OpenGL states. More...

#include <SLGLState.h>

Public Member Functions
void	onInitialize (const SLCol4f &clearColor)
	On init GL. More...

void	initAll ()

bool	hasMultiSampling () const

void	unbindAnythingAndFlush ()
	finishes all GL commands More...

SLbool	pixelFormatIsSupported (SLint pixelFormat)
	Returns true if the according GL pixel format is valid in the GL context. More...

void	readPixels (void *buffer)
	Reads the front framebuffer pixels into the passed buffer. More...

void	depthTest (SLbool state)

void	depthMask (SLbool state)

void	depthFunc (SLenum func)

void	cullFace (SLbool state)

void	blend (SLbool state)

void	blendFunc (SLenum blendFuncSFactor, SLenum blendFuncDFactor)
	Sets new blend function source and destination factors. More...

void	multiSample (SLbool state)

void	polygonLine (SLbool state)

void	polygonOffsetPoint (SLbool enabled, SLfloat factor=-1.0f, SLfloat units=-1.0f)

void	polygonOffsetLine (SLbool enabled, SLfloat factor=-1.0f, SLfloat units=-1.0f)

void	polygonOffsetFill (SLbool enabled, SLfloat factor=-1.0f, SLfloat units=-1.0f)

void	viewport (SLint x, SLint y, SLsizei width, SLsizei height)

void	colorMask (GLboolean r, GLboolean g, GLboolean b, GLboolean a)

void	useProgram (SLuint progID)

void	bindTexture (SLenum target, SLuint textureID)

void	activeTexture (SLenum textureUnit)

void	clearColor (const SLCol4f &c)

void	currentMaterial (SLMaterial *mat)

void	clearColorBuffer ()

void	clearDepthBuffer ()

void	clearColorDepthBuffer ()

SLbool	blend () const

SLstring	glVersion ()

SLstring	glVersionNO ()

SLfloat	glVersionNOf () const

SLstring	glVendor ()

SLstring	glRenderer ()

SLstring	glSLVersion ()

SLstring	glSLVersionNO ()

SLbool	glIsES () const

SLbool	glIsES2 () const

SLbool	glIsES3 () const

SLint	glMaxTexUnits () const

SLint	glMaxTexSize () const

SLbool	glHasGeometryShaders () const

SLbool	hasExtension (const SLstring &e)

SLVec4i	viewport ()

SLMat4f	viewportMatrix ()

SLMaterial *	currentMaterial ()

SLstring	getGLVersionNO ()
	Returns the OpenGL version number as a string. More...

SLstring	getSLVersionNO ()
	Returns the OpenGL Shading Language version number as a string. More...

Static Public Member Functions
static SLGLState *	instance ()
	Public static instance getter for singleton pattern. More...

static void	deleteInstance ()
	global destruction More...

static void	getGLError (const char *file, int line, bool quit)
	Checks if an OpenGL error occurred. More...

Public Attributes
SLMat4f	modelMatrix
	Init all states. More...

SLMat4f	projectionMatrix
	matrix for projection transform More...

SLMat4f	viewMatrix
	matrix for the active cameras view transform More...

SLMat4f	textureMatrix
	matrix for the texture transform More...

Private Member Functions
	SLGLState ()
	private onetime constructor More...

	~SLGLState ()
	destruction in ~SLScene More...

Private Attributes
SLbool	_isInitialized
	flag for first init More...

SLstring	_glVersion
	OpenGL Version string. More...

SLstring	_glVersionNO
	OpenGL Version number string. More...

SLfloat	_glVersionNOf
	OpenGL Version number as float. More...

SLstring	_glVendor
	OpenGL Vendor string. More...

SLstring	_glRenderer
	OpenGL Renderer string. More...

SLstring	_glSLVersion
	GLSL Version string. More...

SLstring	_glSLVersionNO
	GLSL Version number string. More...

SLstring	_glExtensions
	OpenGL extensions string. More...

SLbool	_glIsES2
	Flag if OpenGL ES2. More...

SLbool	_glIsES3
	Flag if OpenGL ES3. More...

SLint	_glMaxTexUnits
	glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &_glMaxTexUnits); More...

SLint	_glMaxTexSize
	glGetIntegerv(GL_MAX_TEXTURE_SIZE, &_glMaxTexSize); More...

SLbool	_blend
	blending default false; More...

SLenum	_blendFuncSfactor
	blend function source factor enum More...

SLenum	_blendFuncDfactor
	blend function destination factor enum More...

SLbool	_depthTest
	GL_DEPTH_TEST state. More...

SLbool	_depthMask
	glDepthMask state More...

SLenum	_depthFunc
	depth buffer comparison function More...

SLbool	_cullFace
	Face culling state. More...

SLbool	_multisample
	Multisampling state. More...

SLint	_multiSampleSamples
	NO. of multisampling samples. More...

SLbool	_polygonLine
	Line polygon state. More...

SLbool	_polygonOffsetPointEnabled
	GL_POLYGON_OFFSET_POINT state enabled. More...

SLbool	_polygonOffsetLineEnabled
	GL_POLYGON_OFFSET_LINE state enabled. More...

SLbool	_polygonOffsetFillEnabled
	GL_POLYGON_OFFSET_FILL state enabled. More...

SLVec4i	_viewport
	viewport size (x,y,w,h) of the framebuffer More...

SLCol4f	_clearColor
	clear color More...

SLuint	_programID
	current shader program id More...

SLenum	_textureUnit
	current texture unit More...

SLenum	_textureTarget
	current texture target More...

SLuint	_textureID
	current texture id More...

GLboolean	_colorMaskR
	current color mask for R More...

GLboolean	_colorMaskG
	current color mask for G More...

GLboolean	_colorMaskB
	current color mask for B More...

GLboolean	_colorMaskA
	current color mask for A More...

SLVstring	errorTexts
	vector for error texts collected in getGLError More...

SLVlong	errorCounts
	vector for counts for the corresponding errorTexts More...

SLMaterial *	_currentMaterial

Static Private Attributes
static SLGLState *	_instance = nullptr
	global singleton object More...

Detailed Description

Singleton class holding all OpenGL states.

The main purpose of the SLGLState class is to replace all the OpenGL states and functionality that has been removed from the core profile of OpenGL. The core profile started from OpenGL version 3.0 has e.g. no more internal matrices, lighting or material states. It also has no more fixed function pipeline on the GPU witch means, that core profile OpenGL only works with custom shader programs written in OpenGL Shading Language (GLSL). The second purpose is to concentrate OpenGL functionality and to reduce redundant state changes.

Definition at line 70 of file SLGLState.h.

Constructor & Destructor Documentation

◆ SLGLState()

SLGLState::SLGLState ( )

private

private onetime constructor

Private constructor should be called only once for a singleton class.

Definition at line 35 of file SLGLState.cpp.

 {
     initAll();
 }

◆ ~SLGLState()

SLGLState::~SLGLState ( )

private

destruction in ~SLScene

The destructor only empties the stacks

Definition at line 123 of file SLGLState.cpp.

 {
 #if _DEBUG
     SL_LOG("--------------------- Collected OpenGL Error: --------------------");
     SL_LOG("Destructor       : ~SLGLState");
     for (size_t i = 0; i < errorTexts.size(); ++i)
         SL_LOG("(%04d) %s", errorCounts[i], errorTexts[i].c_str());
     if (errorTexts.size() == 0) SL_LOG("None");
     SL_LOG("------------------------------------------------------------------");
 #endif
 }

Member Function Documentation

◆ activeTexture()

void SLGLState::activeTexture ( SLenum textureUnit )

SLGLState::activeTexture sets the current active texture unit

Definition at line 445 of file SLGLState.cpp.

 {
     if (((SLint)textureUnit - GL_TEXTURE0) > _glMaxTexUnits)
         SL_LOG("******* To many texture units: %i used of %i",
                (SLint)textureUnit - GL_TEXTURE0,
                _glMaxTexUnits);
  
     assert((textureUnit - GL_TEXTURE0) <= _glMaxTexUnits &&
            "To many texture units!");
  
     glActiveTexture(textureUnit);
     _textureUnit = textureUnit;
  
     GET_GL_ERROR;
 }

◆ bindTexture()

void SLGLState::bindTexture	(	SLenum	target,
		SLuint	textureID
	)

SLGLState::bindTexture sets the current active texture.

Definition at line 423 of file SLGLState.cpp.

 {
     // (luc) If we call glActiveTexture and glBindTexture from outside,
     // This will lead to problems as the global state in SLGLState will not be
     // equivalent to the OpenGL state.
     // We should solve this by querying opengl for the last bound texture.
     // glGetIntegeriv(GL_ACTIVE_TEXTURE, active_texture)
     // glGetIntegeriv(GL_TEXTURE_BINDING_2D, textureID)
  
     // if (target != _textureTarget || textureID != _textureID)
     {
         glBindTexture(target, textureID);
  
         _textureTarget = target;
         _textureID     = textureID;
  
         GET_GL_ERROR;
     }
 }

◆ blend() [1/2]

SLbool SLGLState::blend ( ) const

inline

Definition at line 126 of file SLGLState.h.

126 { return _blend; }

SLGLState::_blend

SLbool _blend

blending default false;

Definition: SLGLState.h:182

◆ blend() [2/2]

void SLGLState::blend ( SLbool stateNew )

SLGLState::blend enables or disables alpha blending but only if the state really changes.

Definition at line 236 of file SLGLState.cpp.

 {
     if (_blend != stateNew)
     {
         if (stateNew)
             glEnable(GL_BLEND);
         else
             glDisable(GL_BLEND);
         _blend = stateNew;
         GET_GL_ERROR;
     }
 }

◆ blendFunc()

void SLGLState::blendFunc	(	SLenum	blendFuncSFactor,
		SLenum	blendFuncDFactor
	)

Sets new blend function source and destination factors.

Definition at line 250 of file SLGLState.cpp.

 {
     if (_blendFuncSfactor != newBlendFuncSFactor ||
         _blendFuncDfactor != newBlendFuncDFactor)
     {
         glBlendFunc(newBlendFuncSFactor, newBlendFuncDFactor);
         _blendFuncSfactor = newBlendFuncSFactor;
         _blendFuncDfactor = newBlendFuncDFactor;
         GET_GL_ERROR;
     }
 }

◆ clearColor()

void SLGLState::clearColor ( const SLCol4f & c )

Definition at line 157 of file SLGLState.cpp.

 {
     if (_clearColor != newColor)
     {
         glClearColor(newColor.r, newColor.g, newColor.b, newColor.a);
         _clearColor = newColor;
  
         GET_GL_ERROR;
     }
 }

◆ clearColorBuffer()

void SLGLState::clearColorBuffer ( )

inline

Definition at line 121 of file SLGLState.h.

121 { glClear(GL_COLOR_BUFFER_BIT); }

◆ clearColorDepthBuffer()

void SLGLState::clearColorDepthBuffer ( )

inline

Definition at line 123 of file SLGLState.h.

123 { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); }

◆ clearDepthBuffer()

void SLGLState::clearDepthBuffer ( )

inline

Definition at line 122 of file SLGLState.h.

122 { glClear(GL_DEPTH_BUFFER_BIT); }

◆ colorMask()

void SLGLState::colorMask	(	GLboolean	r,
		GLboolean	g,
		GLboolean	b,
		GLboolean	a
	)

SLGLState::colorMask sets the OpenGL colorMask for framebuffer masking

Definition at line 394 of file SLGLState.cpp.

 {
     if (r != _colorMaskR || g != _colorMaskG || b != _colorMaskB || a != _colorMaskA)
     {
         glColorMask(r, g, b, a);
         _colorMaskR = r;
         _colorMaskG = g;
         _colorMaskB = b;
         _colorMaskA = a;
  
         GET_GL_ERROR;
     }
 }

◆ cullFace()

void SLGLState::cullFace ( SLbool stateNew )

SLGLState::cullFace sets the GL_CULL_FACE state but only if the state really changes. If face culling is turned on no back faces are processed.

Definition at line 219 of file SLGLState.cpp.

 {
     if (_cullFace != stateNew)
     {
         if (stateNew)
             glEnable(GL_CULL_FACE);
         else
             glDisable(GL_CULL_FACE);
         _cullFace = stateNew;
  
         GET_GL_ERROR;
     }
 }

◆ currentMaterial() [1/2]

SLMaterial* SLGLState::currentMaterial ( )

inline

Definition at line 152 of file SLGLState.h.

152 { return _currentMaterial; }

SLGLState::_currentMaterial

SLMaterial * _currentMaterial

Definition: SLGLState.h:211

◆ currentMaterial() [2/2]

void SLGLState::currentMaterial ( SLMaterial * mat )

inline

Definition at line 120 of file SLGLState.h.

120 { _currentMaterial = mat; }

◆ deleteInstance()

void SLGLState::deleteInstance ( )

static

global destruction

Public static destruction.

Definition at line 27 of file SLGLState.cpp.

 {
     delete _instance;
     _instance = nullptr;
 }

◆ depthFunc()

void SLGLState::depthFunc ( SLenum func )

SLGLState::depthFunc specifies the depth comparison function. Symbolic constants GL_NEVER, GL_LESS, GL_EQUAL, GL_LEQUAL, GL_GREATER, GL_NOTEQUAL, GL_GEQUAL, and GL_ALWAYS are accepted. The initial value is GL_LESS.

Definition at line 205 of file SLGLState.cpp.

 {
     if (_depthFunc != func)
     {
         glDepthFunc(func);
         _depthFunc = func;
  
         GET_GL_ERROR;
     }
 }

◆ depthMask()

void SLGLState::depthMask ( SLbool stateNew )

SLGLState::depthTest enables or disables depth buffer writing but only if the state really changes. Turning on depth masking freezes the depth test but keeps all values in the depth buffer.

Definition at line 190 of file SLGLState.cpp.

 {
     if (_depthMask != stateNew)
     {
         glDepthMask(stateNew ? GL_TRUE : GL_FALSE);
         _depthMask = stateNew;
  
         GET_GL_ERROR;
     }
 }

◆ depthTest()

void SLGLState::depthTest ( SLbool stateNew )

SLGLState::depthTest enables or disables depth testing but only if the state really changes. The depth test decides for each pixel in the depth buffer which polygon is the closest to the eye.

Definition at line 172 of file SLGLState.cpp.

 {
     if (_depthTest != stateNew)
     {
         if (stateNew)
             glEnable(GL_DEPTH_TEST);
         else
             glDisable(GL_DEPTH_TEST);
         _depthTest = stateNew;
  
         GET_GL_ERROR;
     }
 }

◆ getGLError()

void SLGLState::getGLError	(	const char *	file,
		int	line,
		bool	quit
	)

static

Checks if an OpenGL error occurred.

Definition at line 484 of file SLGLState.cpp.

 {
     GLenum err = glGetError();
     if (err != GL_NO_ERROR)
     {
         string errStr;
         switch (err)
         {
             case GL_INVALID_ENUM:
                 errStr = "GL_INVALID_ENUM";
                 break;
             case GL_INVALID_VALUE:
                 errStr = "GL_INVALID_VALUE";
                 break;
             case GL_INVALID_OPERATION:
                 errStr = "GL_INVALID_OPERATION";
                 break;
             case GL_INVALID_FRAMEBUFFER_OPERATION:
                 errStr = "GL_INVALID_FRAMEBUFFER_OPERATION";
                 break;
             case GL_OUT_OF_MEMORY:
                 errStr = "GL_OUT_OF_MEMORY";
                 break;
             default:
                 errStr = "Unknown error";
         }
  
         // Build error string as a concatenation of file, line & error
         string newErr("OpenGL Error in scene: ");
         newErr += std::to_string(AppCommon::sceneID);
         newErr += ": file: ";
         newErr += Utils::getFileName(file);
         newErr += ": line:";
         newErr += std::to_string(line);
         newErr += ": ";
         newErr += errStr;
  
         // Check if error exists already
         SLGLState* state    = SLGLState::instance();
         auto       foundErr = std::find(state->errorTexts.begin(),
                                   state->errorTexts.end(),
                                   newErr);
  
         // Add error if not found in errorTexts
         if (foundErr == state->errorTexts.end())
         {
             state->errorTexts.push_back(newErr);
             state->errorCounts.push_back(1);
             SL_LOG("**** %s ****", newErr.c_str());
         }
         else // error occurred already
         {
             long errorIndex = foundErr - state->errorTexts.begin();
             state->errorCounts[errorIndex]++;
         }
  
         if (quit)
             exit(1);
     }
 }

◆ getGLVersionNO()

SLstring SLGLState::getGLVersionNO ( )

Returns the OpenGL version number as a string.

The string returned by glGetString can contain additional vendor information such as the build number and the brand name. For the OpenGL version string "4.5.0 NVIDIA 347.68" the function returns "4.5"

Definition at line 552 of file SLGLState.cpp.

 {
     SLstring versionStr = SLstring((const char*)glGetString(GL_VERSION));
     size_t   dotPos     = versionStr.find('.');
     SLchar   NO[4];
     NO[0] = versionStr[dotPos - 1];
     NO[1] = '.';
     NO[2] = versionStr[dotPos + 1];
     NO[3] = 0;
  
     if (versionStr.find("OpenGL ES") != string::npos)
     {
         return SLstring(NO) + "ES";
     }
     else
         return SLstring(NO);
 }

◆ getSLVersionNO()

SLstring SLGLState::getSLVersionNO ( )

Returns the OpenGL Shading Language version number as a string.

The string returned by glGetString can contain additional vendor information such as the build number and the brand name. For the shading language string "Nvidia GLSL 4.5" the function returns "450"

Definition at line 575 of file SLGLState.cpp.

 {
     SLstring versionStr = SLstring((const char*)glGetString(GL_SHADING_LANGUAGE_VERSION));
     size_t   dotPos     = versionStr.find('.');
     SLchar   NO[4];
     NO[0] = versionStr[dotPos - 1];
     NO[1] = versionStr[dotPos + 1];
     NO[2] = '0';
     NO[3] = 0;
     return SLstring(NO);
 }

◆ glHasGeometryShaders()

SLbool SLGLState::glHasGeometryShaders ( ) const

inline

Definition at line 139 of file SLGLState.h.

139 { return (_glIsES3 && _glVersionNOf >= 3.2f) ||

140 (!glIsES() && _glVersionNOf >= 4.1f); }

SLGLState::_glVersionNOf

SLfloat _glVersionNOf

OpenGL Version number as float.

Definition: SLGLState.h:170

SLGLState::_glIsES3

SLbool _glIsES3

Flag if OpenGL ES3.

Definition: SLGLState.h:177

SLGLState::glIsES

SLbool glIsES() const

Definition: SLGLState.h:134

◆ glIsES()

SLbool SLGLState::glIsES ( ) const

inline

Definition at line 134 of file SLGLState.h.

134 { return _glIsES2 || _glIsES3; }

SLGLState::_glIsES2

SLbool _glIsES2

Flag if OpenGL ES2.

Definition: SLGLState.h:176

◆ glIsES2()

SLbool SLGLState::glIsES2 ( ) const

inline

Definition at line 135 of file SLGLState.h.

135 { return _glIsES2; }

◆ glIsES3()

SLbool SLGLState::glIsES3 ( ) const

inline

Definition at line 136 of file SLGLState.h.

136 { return _glIsES3; }

◆ glMaxTexSize()

SLint SLGLState::glMaxTexSize ( ) const

inline

Definition at line 138 of file SLGLState.h.

138 { return _glMaxTexSize; }

SLGLState::_glMaxTexSize

SLint _glMaxTexSize

glGetIntegerv(GL_MAX_TEXTURE_SIZE, &_glMaxTexSize);

Definition: SLGLState.h:179

◆ glMaxTexUnits()

SLint SLGLState::glMaxTexUnits ( ) const

inline

Definition at line 137 of file SLGLState.h.

137 { return _glMaxTexUnits; }

◆ glRenderer()

SLstring SLGLState::glRenderer ( )

inline

Definition at line 131 of file SLGLState.h.

131 { return _glRenderer; }

SLGLState::_glRenderer

SLstring _glRenderer

OpenGL Renderer string.

Definition: SLGLState.h:172

◆ glSLVersion()

SLstring SLGLState::glSLVersion ( )

inline

Definition at line 132 of file SLGLState.h.

132 { return _glSLVersion; }

SLGLState::_glSLVersion

SLstring _glSLVersion

GLSL Version string.

Definition: SLGLState.h:173

◆ glSLVersionNO()

SLstring SLGLState::glSLVersionNO ( )

inline

Definition at line 133 of file SLGLState.h.

133 { return _glSLVersionNO; }

SLGLState::_glSLVersionNO

SLstring _glSLVersionNO

GLSL Version number string.

Definition: SLGLState.h:174

◆ glVendor()

SLstring SLGLState::glVendor ( )

inline

Definition at line 130 of file SLGLState.h.

130 { return _glVendor; }

SLGLState::_glVendor

SLstring _glVendor

OpenGL Vendor string.

Definition: SLGLState.h:171

◆ glVersion()

SLstring SLGLState::glVersion ( )

inline

Definition at line 127 of file SLGLState.h.

127 { return _glVersion; }

SLGLState::_glVersion

SLstring _glVersion

OpenGL Version string.

Definition: SLGLState.h:168

◆ glVersionNO()

SLstring SLGLState::glVersionNO ( )

inline

Definition at line 128 of file SLGLState.h.

128 { return _glVersionNO; }

SLGLState::_glVersionNO

SLstring _glVersionNO

OpenGL Version number string.

Definition: SLGLState.h:169

◆ glVersionNOf()

SLfloat SLGLState::glVersionNOf ( ) const

inline

Definition at line 129 of file SLGLState.h.

129 { return _glVersionNOf; }

◆ hasExtension()

SLbool SLGLState::hasExtension ( const SLstring & e )

inline

Definition at line 141 of file SLGLState.h.

141 { return _glExtensions.find(e) != string::npos; }

SLGLState::_glExtensions

SLstring _glExtensions

OpenGL extensions string.

Definition: SLGLState.h:175

◆ hasMultiSampling()

bool SLGLState::hasMultiSampling ( ) const

inline

Definition at line 95 of file SLGLState.h.

95 { return _multiSampleSamples > 0; }

SLGLState::_multiSampleSamples

SLint _multiSampleSamples

NO. of multisampling samples.

Definition: SLGLState.h:190

◆ initAll()

void SLGLState::initAll ( )

Initializes all states.

Definition at line 42 of file SLGLState.cpp.

 {
     viewMatrix.identity();
     modelMatrix.identity();
     projectionMatrix.identity();
     textureMatrix.identity();
  
     _glVersion     = SLstring((const char*)glGetString(GL_VERSION));
     _glVersionNO   = getGLVersionNO();
     _glVersionNOf  = (SLfloat)atof(_glVersionNO.c_str());
     _glVendor      = SLstring((const char*)glGetString(GL_VENDOR));
     _glRenderer    = SLstring((const char*)glGetString(GL_RENDERER));
     _glSLVersion   = SLstring((const char*)glGetString(GL_SHADING_LANGUAGE_VERSION));
     _glSLVersionNO = getSLVersionNO();
     _glIsES2       = (_glVersion.find("OpenGL ES 2") != string::npos);
     _glIsES3       = (_glVersion.find("OpenGL ES 3") != string::npos);
     glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &_glMaxTexUnits);
     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &_glMaxTexSize);
  
 // Get extensions
 #ifndef APP_USES_GLES
     if (_glVersionNOf > 3.0f)
     {
         GLint n;
         glGetIntegerv(GL_NUM_EXTENSIONS, &n);
         for (SLuint i = 0; i < (SLuint)n; i++)
             _glExtensions += SLstring((const char*)glGetStringi(GL_EXTENSIONS, i)) + ", ";
     }
     else
 #endif
     {
         const GLubyte* ext = glGetString(GL_EXTENSIONS);
         if (ext) _glExtensions = SLstring((const char*)ext);
     }
  
     // initialize states a unset
     _blend                     = false;
     _blendFuncSfactor          = GL_SRC_ALPHA;
     _blendFuncDfactor          = GL_ONE_MINUS_SRC_ALPHA;
     _cullFace                  = false;
     _depthTest                 = false;
     _depthMask                 = false;
     _depthFunc                 = GL_LESS;
     _multisample               = false;
     _polygonLine               = false;
     _polygonOffsetPointEnabled = false;
     _polygonOffsetLineEnabled  = false;
     _polygonOffsetFillEnabled  = false;
     _viewport.set(-1, -1, -1, -1);
     _clearColor.set(-1, -1, -1, -1);
  
     // Reset all cached states to an invalid state
     _programID  = 0;
     _colorMaskR = -1;
     _colorMaskG = -1;
     _colorMaskB = -1;
     _colorMaskA = -1;
  
     _isInitialized = true;
  
     glGetIntegerv(GL_SAMPLES, &_multiSampleSamples);
  
     /* After over 10 years of OpenGL experience I used once a texture that is
      not divisible by 4 and this caused distorted texture displays. By default
      OpenGL has a pixel alignment of 4 which means that all images must be
      divisible by 4! If you want to use textures of any size you have to set
      a pixel alignment of 1:*/
     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
     glPixelStorei(GL_PACK_ALIGNMENT, 1);
  
 #ifndef SL_GLES
     glEnable(GL_PROGRAM_POINT_SIZE);
 #endif
  
     GET_GL_ERROR;
  
     _currentMaterial = nullptr;
 }

◆ instance()

static SLGLState* SLGLState::instance ( )

inlinestatic

Public static instance getter for singleton pattern.

Definition at line 74 of file SLGLState.h.

     {
         if (!_instance)
         {
             _instance = new SLGLState();
             return _instance;
         }
         else
             return _instance;
     }

◆ multiSample()

void SLGLState::multiSample ( SLbool stateNew )

SLGLState::multiSample enables or disables multisampling but only if the state really changes. Multisampling turns on fullscreen anti aliasing on the GPU witch produces smooth polygon edges, lines and points.

Definition at line 267 of file SLGLState.cpp.

 {
 #ifndef SL_GLES3
     if (_multisample != stateNew)
     {
         if (_multiSampleSamples > 0)
         {
             if (stateNew)
                 glEnable(GL_MULTISAMPLE);
             else
                 glDisable(GL_MULTISAMPLE);
             _multisample = stateNew;
         }
  
         GET_GL_ERROR;
     }
 #endif
 }

◆ onInitialize()

void SLGLState::onInitialize ( const SLCol4f & clearColor )

On init GL.

One time initialization

Definition at line 137 of file SLGLState.cpp.

 {
     // Reset all internal states
     if (!_isInitialized) initAll();
  
     // enable depth_test
     glDepthFunc(GL_LESS);
     glEnable(GL_DEPTH_TEST);
  
     // set blend function for classic transparency
     glBlendFunc(_blendFuncSfactor, _blendFuncDfactor);
  
     // set background color
     glClearColor(clearColor.r,
                  clearColor.g,
                  clearColor.b,
                  clearColor.a);
     GET_GL_ERROR;
 }

◆ pixelFormatIsSupported()

SLbool SLGLState::pixelFormatIsSupported ( SLint pixelFormat )

Returns true if the according GL pixel format is valid in the GL context.

Definition at line 588 of file SLGLState.cpp.

 { /*
      #define SL_ALPHA 0x1906             // ES2 ES3 GL2
      #define SL_LUMINANCE 0x1909         // ES2 ES3 GL2
      #define SL_LUMINANCE_ALPHA 0x190A   // ES2 ES3 GL2
      #define SL_INTENSITY 0x8049         //         GL2
      #define SL_GREEN 0x1904             //         GL2
      #define SL_BLUE 0x1905              //         GL2
  
      #define SL_RED  0x1903              //     ES3 GL2 GL3 GL4
      #define SL_RG   0x8227              //     ES3     GL3 GL4
      #define SL_RGB  0x1907              // ES2 ES3 GL2 GL3 GL4
      #define SL_RGBA 0x1908              // ES2 ES3 GL2 GL3 GL4
      #define SL_BGR  0x80E0              //         GL2 GL3 GL4
      #define SL_BGRA 0x80E1              //         GL2 GL3 GL4 (iOS defines it but it doesn't work)
  
      #define SL_RG_INTEGER 0x8228        //     ES3         GL4
      #define SL_RED_INTEGER 0x8D94       //     ES3         GL4
      #define SL_RGB_INTEGER 0x8D98       //     ES3         GL4
      #define SL_RGBA_INTEGER 0x8D99      //     ES3         GL4
      #define SL_BGR_INTEGER 0x8D9A       //                 GL4
      #define SL_BGRA_INTEGER 0x8D9B      //                 GL4
      */
     switch (pixelFormat)
     {
         case PF_rgb:
         case PF_rgba: return true;
         case PF_red: return (!_glIsES2);
         case PF_bgr:
         case PF_bgra: return (!_glIsES2 && !_glIsES3);
         case PF_luminance:
         case PF_luminance_alpha:
         case PF_alpha: return (_glIsES2 || _glIsES3 || (((SLint)_glVersionNOf) == 2));
         case PF_intensity:
         case PF_green:
         case PF_blue: return (!_glIsES2 && !_glIsES3 && (((SLint)_glVersionNOf) == 2));
         case PF_rg: return (!_glIsES2 && _glVersionNOf >= 3);
         case PF_rg_integer:
         case PF_red_integer:
         case PF_rgb_integer:
         case PF_rgba_integer: return (!_glIsES2 && _glVersionNOf >= 4);
         case PF_bgr_integer:
         case PF_bgra_integer: return (_glVersionNOf >= 4);
         default: return false;
     }
 }

◆ polygonLine()

void SLGLState::polygonLine ( SLbool stateNew )

SLGLState::polygonMode sets the polygonMode to GL_LINE but only if the state really changes. OpenGL ES doesn't support glPolygonMode. It has to be mimicked with GL_LINE_LOOP drawing.

Definition at line 290 of file SLGLState.cpp.

 {
 #ifndef SL_GLES3
     if (_polygonLine != stateNew)
     {
         if (stateNew)
             glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
         else
             glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
         _polygonLine = stateNew;
  
         GET_GL_ERROR;
     }
 #endif
 }

◆ polygonOffsetFill()

void SLGLState::polygonOffsetFill	(	SLbool	enabled,
		SLfloat	factor = `-1.0f`,
		SLfloat	units = `-1.0f`
	)

SLGLState::polygonOffsetFill turns on/off polygon offset for filled polygons and sets the factor and unit for glPolygonOffset but only if the state really changes. Polygon offset is used to reduce z-fighting due to parallel planes or lines. See: http://www.zeuscmd.com/tutorials/opengl/15-PolygonOffset.php

Definition at line 359 of file SLGLState.cpp.

 {
     if (_polygonOffsetFillEnabled != enabled)
     {
         if (enabled)
         {
             glEnable(GL_POLYGON_OFFSET_FILL);
             glPolygonOffset(factor, units);
         }
         else
             glDisable(GL_POLYGON_OFFSET_FILL);
         _polygonOffsetFillEnabled = enabled;
  
         GET_GL_ERROR;
     }
 }

◆ polygonOffsetLine()

void SLGLState::polygonOffsetLine	(	SLbool	enabled,
		SLfloat	factor = `-1.0f`,
		SLfloat	units = `-1.0f`
	)

SLGLState::polygonOffsetLine turns on/off polygon offset for lines and sets the factor and unit for glPolygonOffset but only if the state really changes. Polygon offset is used to reduce z-fighting due to parallel planes or lines. See: http://www.zeuscmd.com/tutorials/opengl/15-PolygonOffset.php

Definition at line 335 of file SLGLState.cpp.

 {
 #ifndef SL_GLES3
     if (_polygonOffsetLineEnabled != enabled)
     {
         if (enabled)
         {
             glEnable(GL_POLYGON_OFFSET_LINE);
             glPolygonOffset(factor, units);
         }
         else
             glDisable(GL_POLYGON_OFFSET_LINE);
         _polygonOffsetLineEnabled = enabled;
  
         GET_GL_ERROR;
     }
 #endif
 }

◆ polygonOffsetPoint()

void SLGLState::polygonOffsetPoint	(	SLbool	enabled,
		SLfloat	factor = `-1.0f`,
		SLfloat	units = `-1.0f`
	)

SLGLState::polygonOffsetPoint turns on/off polygon offset for points and sets the factor and unit for glPolygonOffset but only if the state really changes. Polygon offset is used to reduce z-fighting due to parallel planes or lines. See: http://www.zeuscmd.com/tutorials/opengl/15-PolygonOffset.php

Definition at line 311 of file SLGLState.cpp.

 {
 #ifndef SL_GLES3
     if (_polygonOffsetPointEnabled != enabled)
     {
         if (enabled)
         {
             glEnable(GL_POLYGON_OFFSET_POINT);
             glPolygonOffset(factor, units);
         }
         else
             glDisable(GL_POLYGON_OFFSET_POINT);
         _polygonOffsetPointEnabled = enabled;
  
         GET_GL_ERROR;
     }
 #endif
 }

◆ readPixels()

void SLGLState::readPixels ( void * buffer )

Reads the front framebuffer pixels into the passed buffer.

Parameters

buffer Pointer to a 4 byte aligned buffer with the correct size.

Definition at line 639 of file SLGLState.cpp.

 {
     glPixelStorei(GL_PACK_ALIGNMENT, 4);
  
 #ifndef SL_EMSCRIPTEN
     glReadBuffer(GL_FRONT);
 #endif
  
     // Get viewport size
     GLint vp[4];
     glGetIntegerv(GL_VIEWPORT, vp);
  
     glReadPixels(vp[0],
                  vp[1],
                  vp[2],
                  vp[3],
                  SL_READ_PIXELS_GL_FORMAT,
                  GL_UNSIGNED_BYTE,
                  buffer);
 }

◆ unbindAnythingAndFlush()

void SLGLState::unbindAnythingAndFlush ( )

finishes all GL commands

SLGLState::unbindAnythingAndFlush unbinds all shaderprograms and buffers in use and calls glFinish. This should be the last call to GL before buffer swapping.

Definition at line 465 of file SLGLState.cpp.

 {
     useProgram(0);
  
     // reset the bound texture unit
     // This is needed since leaving one texture unit bound over multiple windows
     // sometimes (most of the time) causes bugs
     // glBindTexture(GL_TEXTURE_2D, 0);
     // glBindVertexArray(0);
     // glBindBuffer(GL_ARRAY_BUFFER, 0);
     // glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
  
     // The iOS OpenGL ES Analyzer suggests not to use flush or finish
     // glFlush();
     // glFinish();
  
     GET_GL_ERROR;
 }

◆ useProgram()

void SLGLState::useProgram ( SLuint progID )

SLGLState::useProgram sets the _rent active shader program

Definition at line 410 of file SLGLState.cpp.

 {
     if (_programID != progID)
     {
         glUseProgram(progID);
         _programID = progID;
  
         GET_GL_ERROR;
     }
 }

◆ viewport() [1/2]

SLVec4i SLGLState::viewport ( )

inline

Definition at line 142 of file SLGLState.h.

142 { return _viewport; }

◆ viewport() [2/2]

void SLGLState::viewport	(	SLint	x,
		SLint	y,
		SLsizei	width,
		SLsizei	height
	)

SLGLState::viewport sets the OpenGL viewport position and size

Definition at line 378 of file SLGLState.cpp.

 {
     if (_viewport.x != x ||
         _viewport.y != y ||
         _viewport.z != width ||
         _viewport.w != height)
     {
         glViewport(x, y, width, height);
         _viewport.set(x, y, width, height);
  
         GET_GL_ERROR;
     }
 }

◆ viewportMatrix()

SLMat4f SLGLState::viewportMatrix ( )

inline

Definition at line 143 of file SLGLState.h.

     {
         SLMat4f vpm;
         vpm.viewport((SLfloat)_viewport.x,
                      (SLfloat)_viewport.y,
                      (SLfloat)_viewport.z,
                      (SLfloat)_viewport.w);
         return vpm;
     }

Member Data Documentation

◆ _blend

SLbool SLGLState::_blend

private

blending default false;

Definition at line 182 of file SLGLState.h.

◆ _blendFuncDfactor

SLenum SLGLState::_blendFuncDfactor

private

blend function destination factor enum

Definition at line 184 of file SLGLState.h.

◆ _blendFuncSfactor

SLenum SLGLState::_blendFuncSfactor

private

blend function source factor enum

Definition at line 183 of file SLGLState.h.

◆ _clearColor

SLCol4f SLGLState::_clearColor

private

clear color

Definition at line 196 of file SLGLState.h.

◆ _colorMaskA

GLboolean SLGLState::_colorMaskA

private

current color mask for A

Definition at line 206 of file SLGLState.h.

◆ _colorMaskB

GLboolean SLGLState::_colorMaskB

private

current color mask for B

Definition at line 205 of file SLGLState.h.

◆ _colorMaskG

GLboolean SLGLState::_colorMaskG

private

current color mask for G

Definition at line 204 of file SLGLState.h.

◆ _colorMaskR

GLboolean SLGLState::_colorMaskR

private

current color mask for R

Definition at line 203 of file SLGLState.h.

◆ _cullFace

SLbool SLGLState::_cullFace

private

Face culling state.

Definition at line 188 of file SLGLState.h.

◆ _currentMaterial

SLMaterial* SLGLState::_currentMaterial

private

Definition at line 211 of file SLGLState.h.

◆ _depthFunc

SLenum SLGLState::_depthFunc

private

depth buffer comparison function

Definition at line 187 of file SLGLState.h.

◆ _depthMask

SLbool SLGLState::_depthMask

private

glDepthMask state

Definition at line 186 of file SLGLState.h.

◆ _depthTest

SLbool SLGLState::_depthTest

private

GL_DEPTH_TEST state.

Definition at line 185 of file SLGLState.h.

◆ _glExtensions

SLstring SLGLState::_glExtensions

private

OpenGL extensions string.

Definition at line 175 of file SLGLState.h.

◆ _glIsES2

SLbool SLGLState::_glIsES2

private

Flag if OpenGL ES2.

Definition at line 176 of file SLGLState.h.

◆ _glIsES3

SLbool SLGLState::_glIsES3

private

Flag if OpenGL ES3.

Definition at line 177 of file SLGLState.h.

◆ _glMaxTexSize

SLint SLGLState::_glMaxTexSize

private

glGetIntegerv(GL_MAX_TEXTURE_SIZE, &_glMaxTexSize);

Definition at line 179 of file SLGLState.h.

◆ _glMaxTexUnits

SLint SLGLState::_glMaxTexUnits

private

glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &_glMaxTexUnits);

Definition at line 178 of file SLGLState.h.

◆ _glRenderer

SLstring SLGLState::_glRenderer

private

OpenGL Renderer string.

Definition at line 172 of file SLGLState.h.

◆ _glSLVersion

SLstring SLGLState::_glSLVersion

private

GLSL Version string.

Definition at line 173 of file SLGLState.h.

◆ _glSLVersionNO

SLstring SLGLState::_glSLVersionNO

private

GLSL Version number string.

Definition at line 174 of file SLGLState.h.

◆ _glVendor

SLstring SLGLState::_glVendor

private

OpenGL Vendor string.

Definition at line 171 of file SLGLState.h.

◆ _glVersion

SLstring SLGLState::_glVersion

private

OpenGL Version string.

Definition at line 168 of file SLGLState.h.

◆ _glVersionNO

SLstring SLGLState::_glVersionNO

private

OpenGL Version number string.

Definition at line 169 of file SLGLState.h.

◆ _glVersionNOf

SLfloat SLGLState::_glVersionNOf

private

OpenGL Version number as float.

Definition at line 170 of file SLGLState.h.

◆ _instance

SLGLState * SLGLState::_instance = nullptr

staticprivate

global singleton object

Definition at line 164 of file SLGLState.h.

◆ _isInitialized

SLbool SLGLState::_isInitialized

private

flag for first init

Definition at line 166 of file SLGLState.h.

◆ _multisample

SLbool SLGLState::_multisample

private

Multisampling state.

Definition at line 189 of file SLGLState.h.

◆ _multiSampleSamples

SLint SLGLState::_multiSampleSamples

private

NO. of multisampling samples.

Definition at line 190 of file SLGLState.h.

◆ _polygonLine

SLbool SLGLState::_polygonLine

private

Line polygon state.

Definition at line 191 of file SLGLState.h.

◆ _polygonOffsetFillEnabled

SLbool SLGLState::_polygonOffsetFillEnabled

private

GL_POLYGON_OFFSET_FILL state enabled.

Definition at line 194 of file SLGLState.h.

◆ _polygonOffsetLineEnabled

SLbool SLGLState::_polygonOffsetLineEnabled

private

GL_POLYGON_OFFSET_LINE state enabled.

Definition at line 193 of file SLGLState.h.

◆ _polygonOffsetPointEnabled

SLbool SLGLState::_polygonOffsetPointEnabled

private

GL_POLYGON_OFFSET_POINT state enabled.

Definition at line 192 of file SLGLState.h.

◆ _programID

SLuint SLGLState::_programID

private

current shader program id

Definition at line 199 of file SLGLState.h.

◆ _textureID

SLuint SLGLState::_textureID

private

current texture id

Definition at line 202 of file SLGLState.h.

◆ _textureTarget

SLenum SLGLState::_textureTarget

private

current texture target

Definition at line 201 of file SLGLState.h.

◆ _textureUnit

SLenum SLGLState::_textureUnit

private

current texture unit

Definition at line 200 of file SLGLState.h.

◆ _viewport

SLVec4i SLGLState::_viewport

private

viewport size (x,y,w,h) of the framebuffer

Definition at line 195 of file SLGLState.h.

◆ errorCounts

SLVlong SLGLState::errorCounts

private

vector for counts for the corresponding errorTexts

Definition at line 209 of file SLGLState.h.

◆ errorTexts

SLVstring SLGLState::errorTexts

private

vector for error texts collected in getGLError

Definition at line 208 of file SLGLState.h.

◆ modelMatrix

SLMat4f SLGLState::modelMatrix

Init all states.

matrix for model to world transform

Definition at line 89 of file SLGLState.h.

◆ projectionMatrix

SLMat4f SLGLState::projectionMatrix

matrix for projection transform

Definition at line 90 of file SLGLState.h.

◆ textureMatrix

SLMat4f SLGLState::textureMatrix

matrix for the texture transform

Definition at line 92 of file SLGLState.h.

◆ viewMatrix

SLMat4f SLGLState::viewMatrix

matrix for the active cameras view transform

Definition at line 91 of file SLGLState.h.

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SLGLState()

◆ ~SLGLState()

Member Function Documentation

◆ activeTexture()

◆ bindTexture()

◆ blend() [1/2]

◆ blend() [2/2]

◆ blendFunc()

◆ clearColor()

◆ clearColorBuffer()

◆ clearColorDepthBuffer()

◆ clearDepthBuffer()

◆ colorMask()

◆ cullFace()

◆ currentMaterial() [1/2]

◆ currentMaterial() [2/2]

◆ deleteInstance()

◆ depthFunc()

◆ depthMask()

◆ depthTest()

◆ getGLError()

◆ getGLVersionNO()

◆ getSLVersionNO()

◆ glHasGeometryShaders()

◆ glIsES()

◆ glIsES2()

◆ glIsES3()

◆ glMaxTexSize()

◆ glMaxTexUnits()

◆ glRenderer()

◆ glSLVersion()

◆ glSLVersionNO()

◆ glVendor()

◆ glVersion()

◆ glVersionNO()

◆ glVersionNOf()

◆ hasExtension()

◆ hasMultiSampling()

◆ initAll()

◆ instance()

◆ multiSample()

◆ onInitialize()

◆ pixelFormatIsSupported()

◆ polygonLine()

◆ polygonOffsetFill()

◆ polygonOffsetLine()

◆ polygonOffsetPoint()

◆ readPixels()

◆ unbindAnythingAndFlush()

◆ useProgram()

◆ viewport() [1/2]

◆ viewport() [2/2]

◆ viewportMatrix()

Member Data Documentation

◆ _blend

◆ _blendFuncDfactor

◆ _blendFuncSfactor

◆ _clearColor

◆ _colorMaskA

◆ _colorMaskB

◆ _colorMaskG

◆ _colorMaskR

◆ _cullFace

◆ _currentMaterial

◆ _depthFunc

◆ _depthMask

◆ _depthTest

◆ _glExtensions

◆ _glIsES2

◆ _glIsES3

◆ _glMaxTexSize

◆ _glMaxTexUnits