gls_state_manager_interface.h

Go to the documentation of this file.

/*! \file
  \brief IGlsStateManager, interface to a state manager that manages the GL Studio
runtime library's use of the OpenGL context, minimizing unnecessary state changes.

  \par Copyright Information

  Copyright (c) 2017 by The DiSTI Corporation.<br>
  11301 Corporate Blvd; Suite 100<br>
  Orlando, Florida 32817<br>
  USA<br>
  <br>
  All rights reserved.<br>

  This Software contains proprietary trade secrets of DiSTI and may not be
reproduced, in whole or part, in any form, or by any means of electronic,
mechanical, or otherwise, without the written permission of DiSTI.  Said
permission may be derived through the purchase of applicable DiSTI product
licenses which detail the distribution rights of this content and any
Derivative Works based on this or other copyrighted DiSTI Software.

  NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.

  LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
OF SUCH DAMAGES.  DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
EXCEED FIVE DOLLARS (US$5.00).

 The aforementioned terms and restrictions are governed by the laws of the
State of Florida and the United States of America. Use, distribution,
duplication, or disclosure by the U. S. Government is subject to
"Restricted Rights" as set forth in DFARS 252.227-7014(c)(1)(ii).

*/

#ifndef DISTI_GLS_STATE_MANAGER_INTERFACE_H_INCLUDED
#define DISTI_GLS_STATE_MANAGER_INTERFACE_H_INCLUDED

#include "IFontImage.h"
#include "gls_color.h"
#include "gls_gl.h"
#include "gls_include.h"
#include "gls_matrix_affine.h"
#include "non_copyable.h"
#include "scoped_ptr.h"

#ifndef LESS_MAX_LIGHTS
#    define MAX_LIGHTS 8
#else
#    define MAX_LIGHTS 6
#endif

namespace disti
{
/** \interface IGlsStateManager
  * The interface to a state manager that manages the GL Studio
  * runtime library's use of the OpenGL context, minimizing unnecessary state changes
  */
class IGlsStateManager : public NonCopyable
{
public:
    /** Wrapper for glBlendFuncSeparate if supported, or glBlendFunc (ignoring the last two parameters) if
      * glBlendFuncSeparate is not supported.  Parameters are equivalent to glBlendFuncSeparate
      */
    GLS_EXPORT virtual void AlphaBlendFuncSeparate( GLenum srcColor, GLenum dstColor, GLenum srcAlpha, GLenum dstAlpha ) = 0;
    /** sets the default blend function for GL Studio */
    GLS_EXPORT virtual void SetDefaultAlphaBlendFunc() = 0;
    /** pushes the current alpha blend func onto an internal stack.  Can restore the pushed alpha blend func by calling PopAlphaBlendFunc */
    GLS_EXPORT virtual void PushAlphaBlendFunc() = 0;
    /** pops the previously pushed alpha blend func from the stack and restores its state to the opengl context */
    GLS_EXPORT virtual void PopAlphaBlendFunc() = 0;
    /** Wrapper for glBlendFunc. Parameters are equivalent to glBlendFunc */
    GLS_EXPORT virtual void AlphaBlendFunc( GLenum src, GLenum dst ) = 0;

#ifdef GLES
    /** supported texture mapping modes */
    enum {
        GLS_TEXTURE_MAP_MODE_MODULATE = 0x2100, // = GL_MODULATE
        GLS_TEXTURE_MAP_MODE_DECAL    = 0x2101, // = GL_DECAL
        GLS_TEXTURE_MAP_MODE_BLEND    = 0x0BE2, // = GL_BLEND
        GLS_TEXTURE_MAP_MODE_REPLACE  = 0x1E01  // = GL_REPLACE
    };

    /** Initializes the state manager to its default states and then sends that state
      * to the OpenGL context
      * \param forceResetUnmanagedState force the reset of all GL state, even state unmanaged by GL Studio
      */
    GLS_EXPORT virtual void SetDefaultState( bool forceResetUnmanagedState = false ) = 0;

    ////////////////////////////////////////////////////////////////
    //
    // Matrix Stack
    //
    ////////////////////////////////////////////////////////////////
    enum {
        MATRIX_STACK_DEPTH                = 64u, /**< depth of model view matrix stack */
        PROJECTION_STACK_DEPTH            = 64u, /**< depth of projection matrix stack */
        TEXTURE_STACK_DEPTH               = 64u, /**< depth of texture matrix stack */
        CUSTOM_SHADER_PROGRAM_STACK_DEPTH = 64u  /**< depth of custom shader stack */
    };

    /** load the given matrix into the projection matrix
      * \pre GLMatrixAffineFIsValid( m )
      * \post the given matrix is the projection matrix
      */
    GLS_EXPORT virtual void LoadProjectionMatrixf( const GlsMatrixType& m ) = 0;

    GLS_EXPORT virtual void LoadProjectionIdentityMatrix( void ) = 0;

    GLS_EXPORT virtual void PushProjectionMatrix( void ) = 0;

    GLS_EXPORT virtual void PopProjectionMatrix( void ) = 0;

    /** load the given matrix on to the top of the matrix stack
      * \pre GLMatrixAffineFIsValid( m )
      * \post the given matrix is on the top of the matrix stack
      */
    GLS_EXPORT virtual void LoadModelViewMatrixf( const GlsMatrixType& m ) = 0;

    GLS_EXPORT virtual void LoadModelViewIdentityMatrix( void ) = 0;

    /** Multiply (and optionally push) the top of the stack by the given matrix such that if
      * t is the top of the matrix then t=t*m . If pushMatrix is true then the matrix stack
      * is pushed before the multiplication.
      * \param m matrix to multiply by
      * \param pushMatrix true to push the matrix stack before multiplying
      * \pre GLMatrixAffineFIsValid( m ), current matrix stack index is < ( MATRIX_STACK_DEPTH - 1u ) if pushMatrix is true
      * \post the top of the stack is multiplied by the given matrix
      */
    GLS_EXPORT virtual void MultModelViewMatrixf( const GlsMatrixType& m, const GLboolean pushMatrix ) = 0;

    /** apply a translation to the top of the model view matrix stack
      * \param x the x-coordinate of the translation vector
      * \param y the y-coordinate of the translation vector
      * \param z the z-coordinate of the translation vector
      */
    GLS_EXPORT virtual void TranslateModelViewMatrixf( GLfloat x, GLfloat y, GLfloat z ) = 0;

    /** push the matrix stack
      * \pre current matrix stack index is < ( MATRIX_STACK_DEPTH - 1u )
      * \post matrix stack is popped
      */
    GLS_EXPORT virtual void PushModelViewMatrix( void ) = 0;

    /** pop the matrix stack
      * \pre current matrix stack index is > 0u
      * \post matrix stack is popped
      */
    GLS_EXPORT virtual void PopModelViewMatrix( void ) = 0;

    /** load the given matrix on to the top of the texture matrix stack
      * \pre GLMatrixAffineFIsValid( m )
      * \post the given matrix is on the top of the texture matrix stack
      */
    GLS_EXPORT virtual void LoadTextureMatrixf( const GlsMatrixType& m ) = 0;

    GLS_EXPORT virtual void LoadTextureIdentityMatrix( void ) = 0;

    /** apply a scale factor to the top of the texture matrix stack
      * \param x the x-coordinate of the scale vector
      * \param y the y-coordinate of the scale vector
      * \param z the z-coordinate of the scale vector
      */
    GLS_EXPORT virtual void ScaleTextureMatrixf( GLfloat x, GLfloat y, GLfloat z ) = 0;

    /** apply a translation to the top of the texture matrix stack
      * \param x the x-coordinate of the translation vector
      * \param y the y-coordinate of the translation vector
      * \param z the z-coordinate of the translation vector
      */
    GLS_EXPORT virtual void TranslateTextureMatrixf( GLfloat x, GLfloat y, GLfloat z ) = 0;

    /** push the texture matrix stack
      * \pre current matrix stack index is < ( MATRIX_STACK_DEPTH - 1u )
      * \post matrix stack is popped
      */
    GLS_EXPORT virtual void PushTextureMatrix( void ) = 0;

    /** pop the texture matrix stack
      * \pre current matrix stack index is > 0u
      * \post matrix stack is popped
      */
    GLS_EXPORT virtual void PopTextureMatrix( void ) = 0;

    ////////////////////////////////////////////////////////////////
    //
    // The following methods manage the various OpenGL state calls
    //
    ////////////////////////////////////////////////////////////////
    GLS_EXPORT virtual void AlphaBlendEnabled( bool val )             = 0;
    GLS_EXPORT virtual void AlphaTestEnabled( bool val )              = 0;
    GLS_EXPORT virtual void AlphaTestFunc( GLenum func, GLfloat val ) = 0;

    GLS_EXPORT virtual void DepthTestEnabled( bool val )           = 0;
    GLS_EXPORT virtual void DepthMaskEnabled( bool val )           = 0;
    GLS_EXPORT virtual bool IsDepthMaskEnabled( void )             = 0;
    GLS_EXPORT virtual void DepthFunc( GLenum func )               = 0;
    GLS_EXPORT virtual void DepthRange( GLfloat min, GLfloat max ) = 0;

    GLS_EXPORT virtual void BackfaceCullingEnabled( bool val ) = 0;

    GLS_EXPORT virtual void Texture2DEnabled( bool val )           = 0;
    GLS_EXPORT virtual void ActiveTexture( GLenum textureUnit )    = 0;
    GLS_EXPORT virtual void BindTexture( IFontImage* texture )     = 0;
    GLS_EXPORT virtual void DeleteTexture( IFontImage* texture )   = 0;
    GLS_EXPORT virtual void SetTextureWrapS( GLenum mode )         = 0;
    GLS_EXPORT virtual void SetTextureWrapT( GLenum mode )         = 0;
    GLS_EXPORT virtual void SetTextureEnvMode( GLenum mode )       = 0;
    GLS_EXPORT virtual void SetTextureBlendColor( GLfloat* color ) = 0;
    GLS_EXPORT virtual void SetTextureMinFilter( GLenum mode )     = 0;
    GLS_EXPORT virtual void SetTextureMagFilter( GLenum mode )     = 0;

    GLS_EXPORT virtual void BindIndexBuffer( unsigned int handle )  = 0;
    GLS_EXPORT virtual void BindVertexBuffer( unsigned int handle ) = 0;

    GLS_EXPORT virtual void VertexArrayEnabled( bool val )  = 0;
    GLS_EXPORT virtual void NormalArrayEnabled( bool val )  = 0;
    GLS_EXPORT virtual void TextureArrayEnabled( bool val ) = 0;
    GLS_EXPORT virtual void ColorArrayEnabled( bool val )   = 0;

    GLS_EXPORT virtual void VertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid* pointer )   = 0;
    GLS_EXPORT virtual void TexCoordPointer( GLint size, GLenum type, GLsizei stride, const GLvoid* pointer ) = 0;
    GLS_EXPORT virtual void NormalPointer( GLenum type, GLsizei stride, const GLvoid* pointer )               = 0;
    GLS_EXPORT virtual void ColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid* pointer )    = 0;

    GLS_EXPORT virtual void LineSmoothEnabled( bool val )                                  = 0;
    GLS_EXPORT virtual void LineWidth( float width )                                       = 0;
    GLS_EXPORT virtual void PointSize( float size )                                        = 0;
    GLS_EXPORT virtual void LineStipple( unsigned short pattern, unsigned int multiplier ) = 0;
    GLS_EXPORT virtual void SetColor( const glsColor& color )                              = 0;
    GLS_EXPORT virtual void Normal3f( float x, float y, float z )                          = 0;

    GLS_EXPORT virtual void AmbientMaterial( const glsColor& color )  = 0;
    GLS_EXPORT virtual void DiffuseMaterial( const glsColor& color )  = 0;
    GLS_EXPORT virtual void SpecularMaterial( const glsColor& color ) = 0;
    GLS_EXPORT virtual void EmissionMaterial( const glsColor& color ) = 0;
    GLS_EXPORT virtual void ShininessMaterial( float shininess )      = 0;

    GLS_EXPORT virtual void         LightingEnabled( bool val )                         = 0;
    GLS_EXPORT virtual void         GouraudShadingEnabled( bool val )                   = 0;
    GLS_EXPORT virtual bool         IsLightingEnabled( void )                           = 0;
    GLS_EXPORT virtual bool         IsLightSourceEnabled( unsigned int index )          = 0;
    GLS_EXPORT virtual unsigned int GetMaxNumLights( void )                             = 0;
    GLS_EXPORT virtual void         SetLightEnabled( unsigned int index, bool enabled ) = 0;

    // These functions work similar to glLightfv / glGetLightfv.  For spacial data, the data is always set in local space and
    // retrieved in eye space (so the retrieved value is different than the set value unless the modelview matrix is identity) */
    GLS_EXPORT virtual void    SetLightAmbientColor( unsigned int index, GLfloat* color )                                        = 0;
    GLS_EXPORT virtual void    GetLightAmbientColor( unsigned int index, GLfloat* color )                                        = 0;
    GLS_EXPORT virtual void    SetLightDiffuseColor( unsigned int index, GLfloat* color )                                        = 0;
    GLS_EXPORT virtual void    GetLightDiffuseColor( unsigned int index, GLfloat* color )                                        = 0;
    GLS_EXPORT virtual void    SetLightSpecularColor( unsigned int index, GLfloat* color )                                       = 0;
    GLS_EXPORT virtual void    GetLightSpecularColor( unsigned int index, GLfloat* color )                                       = 0;
    GLS_EXPORT virtual void    SetLightPosition( unsigned int index, GLfloat* position )                                         = 0;
    GLS_EXPORT virtual void    GetLightPosition( unsigned int index, GLfloat* position )                                         = 0;
    GLS_EXPORT virtual void    SetSpotlightDirection( unsigned int index, GLfloat* direction )                                   = 0;
    GLS_EXPORT virtual void    GetSpotlightDirection( unsigned int index, GLfloat* direction )                                   = 0;
    GLS_EXPORT virtual void    SetSpotlightCutoff( unsigned int index, GLfloat cutoff )                                          = 0;
    GLS_EXPORT virtual GLfloat GetSpotlightCutoff( unsigned int index )                                                          = 0;
    GLS_EXPORT virtual void    SetSpotlightExponent( unsigned int index, GLfloat exponent )                                      = 0;
    GLS_EXPORT virtual GLfloat GetSpotlightExponent( unsigned int index )                                                        = 0;
    GLS_EXPORT virtual void    SetLightAttenuation( unsigned int index, GLfloat constant, GLfloat linear, GLfloat quadratic )    = 0;
    GLS_EXPORT virtual void    GetLightAttenuation( unsigned int index, GLfloat& constant, GLfloat& linear, GLfloat& quadratic ) = 0;

    GLS_EXPORT virtual unsigned int GetMaxClipPlanes( void ) = 0;

    // These functions work similar to glClipPlane / glGetClipPlane.  The equation is always set in local space and retrieved in eye space
    // (so the retrieved value is different than the set value unless the modelview matrix is identity) */
    GLS_EXPORT virtual void ClipPlanef( unsigned int index, float* equation )    = 0;
    GLS_EXPORT virtual void GetClipPlanef( unsigned int index, float* equation ) = 0;

    GLS_EXPORT virtual void EnableClipPlane( unsigned int index )    = 0;
    GLS_EXPORT virtual void DisableClipPlane( unsigned int index )   = 0;
    GLS_EXPORT virtual bool IsClipPlaneEnabled( unsigned int index ) = 0;

    /** equivalent to glDrawArrays call
      * \param mode primitive mode to draw ( GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, or GL_TRIANGLES )
      * \param first starting index in the enabled arrays
      * \param count the number of indices to be rendered
      * \pre mode must be GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, or GL_TRIANGLES
      * \pre first >= 0
      * \post (GLES20) updated shader program is selected if needed
      * \post primitives are drawn to GL
      */
    GLS_EXPORT virtual void DrawArrays( const GLenum mode, const GLint first, const GLsizei count ) = 0;

    /** equivalent to glDrawElements call
      * \param mode primitive mode to draw ( GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, or GL_TRIANGLES )
      * \param count the number of elements to be rendered
      * \param type Specifies the type of the values in indices ( GL_UNSIGNED_BYTE or GL_UNSIGNED_SHORT )
      * \param indices pointer to the location where the indices are stored else an offset in bytes into the
      *                the currently bound element array buffer
      * \pre mode must be GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, or GL_TRIANGLES
      * \pre type must be GL_UNSIGNED_BYTE or GL_UNSIGNED_SHORT
      * \post (GLES20) updated shader program is selected if needed
      * \post primitives are drawn to GL
      */
    GLS_EXPORT virtual void DrawElements( const GLenum mode, const GLsizei count, const GLenum type, const GLvoid* indices ) = 0;
#endif

protected:
    /** default ctor */
    IGlsStateManager() {}

    /** dtor is protected but virtual so that users cannot delete instances of it,
      * but ScopedPtr can inside GlsGlobals 
      */
    virtual ~IGlsStateManager() {}
    friend class ScopedPtr<IGlsStateManager>;
};

} // namespace disti

#endif // DISTI_GLS_STATE_MANAGER_INTERFACE_H_INCLUDED