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"
 
/// The maximum number of lights, matching the fixed function pipeline.
#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.
    /// \param srcColor Function to use for source color.
    /// \param dstColor Function to use for destination color.
    /// \param srcAlpha Function to use for source alpha.
    /// \param dstAlpha Function to use for destination alpha.
    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.
    /// \param src Function to use for source color.
    /// \param dst Function to use for destination color.
    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.
    /// \param m The matrix to load onto the projeciton matrix.
    GLS_EXPORT virtual void LoadProjectionMatrixf( const GlsMatrixType& m ) = 0;
 
    /// Set the current projection matrix to the identity matrix.
    /// \post The projection matrix becomes the identity matrix.
    GLS_EXPORT virtual void LoadProjectionIdentityMatrix() = 0;
 
    /// Adds a projection matrix to the top of the stack.
    /// \pre Current projection matrix stack index is < ( PROJECTION_STACK_DEPTH - 1u ).
    /// \post Project matrix stack is pushed.
    GLS_EXPORT virtual void PushProjectionMatrix() = 0;
 
    /// Removes a projection matrix from the top of the stack.
    /// \pre Current projection matrix stack index is > 0u.
    /// \post Projection matrix stack is popped.
    GLS_EXPORT virtual void PopProjectionMatrix() = 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.
    /// \param m The matrix to push onto the stack.
    GLS_EXPORT virtual void LoadModelViewMatrixf( const GlsMatrixType& m ) = 0;
 
    /// Set the current model view matrix to the identity matrix.
    GLS_EXPORT virtual void LoadModelViewIdentityMatrix() = 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 pushed.
    GLS_EXPORT virtual void PushModelViewMatrix() = 0;
 
    /// Pop the matrix stack.
    /// \pre Current matrix stack index is > 0u.
    /// \post Matrix stack is popped.
    GLS_EXPORT virtual void PopModelViewMatrix() = 0;
 
    /// Load the given matrix to the top of the texture matrix stack.
    /// \pre GLMatrixAffineFIsValid( m ).
    /// \post The given matrix is on the top of the texture matrix stack.
    /// \param m The matrix to load to the top of the texture matrix stack.
    GLS_EXPORT virtual void LoadTextureMatrixf( const GlsMatrixType& m ) = 0;
 
    /// Sets the current texture matrix to the identity matrix.
    GLS_EXPORT virtual void LoadTextureIdentityMatrix() = 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 pushed.
    GLS_EXPORT virtual void PushTextureMatrix() = 0;
 
    /// Pop the texture matrix stack.
    /// \pre Current matrix stack index is > 0u.
    /// \post Matrix stack is popped.
    GLS_EXPORT virtual void PopTextureMatrix() = 0;
 
    ////////////////////////////////////////////////////////////////
    //
    // The following methods manage the various OpenGL state calls
    //
    ////////////////////////////////////////////////////////////////
 
    /// Updates OpenGL to enable or disable alpha blending.
    /// \param val If true, then alpha blend is enabled. Otherwise, it'll disable alpha blend.
    GLS_EXPORT virtual void AlphaBlendEnabled( bool val ) = 0;
 
    /// Enables or disables the shader alpha test. When testing, the fragment shaders will
    /// check the transparency of the fragment. If it's nearly invisible, the shader instructions
    /// will be discarded and will not update the buffer.
    /// \param val If true, then the shader alpha test is enabled. Otherwise, it's disabled.
    GLS_EXPORT virtual void AlphaTestEnabled( bool val ) = 0;
 
    /// Specifies the alpha comparison function. Fragments may be discarded depending on the outcome of this function comparison.
    /// \param func Determines the type of comparison to conduct.
    /// \param val Determines the threshold when the comparison passes or not.
    GLS_EXPORT virtual void AlphaTestFunc( GLenum func, GLfloat val ) = 0;
 
    /// Updates OpenGL to enable or disable the depth test. The depth test will determine if fragments
    /// behind other surfaces should be discarded or not.
    /// \param val If true, then the depth test is enabled. Otherwise, it'll disable the depth test.
    GLS_EXPORT virtual void DepthTestEnabled( bool val ) = 0;
 
    /// Notifies OpenGL to enable or disable writing to the depth buffer.
    /// \param val If true, then writing to the depth buffer is enabled. Otherwise, it'll be disabled.
    GLS_EXPORT virtual void DepthMaskEnabled( bool val ) = 0;
 
    /// \return True if writing to the depth buffer is enabled. Otherwise, false is returned if it's disabled.
    GLS_EXPORT virtual bool IsDepthMaskEnabled() = 0;
 
    /// Determines the comparison function to use when performing a depth test.
    /// \param func Determines the type of comparison to conduct when performing a depth test.
    GLS_EXPORT virtual void DepthFunc( GLenum func ) = 0;
 
    /// Specifies a linear mapping of the normalized depth coordinates.
    /// \param min The mapping of the near clipping plane.
    /// \param max The mapping of the far clipping plane.
    GLS_EXPORT virtual void DepthRange( GLfloat min, GLfloat max ) = 0;
 
    /// Notifies OpenGL to enable or disable backface culling. If enabled, triangles facing away from
    /// the camera are not rendered.
    /// \param val If true, then backface culling is enabled. Otherwise, it's disabled.
    GLS_EXPORT virtual void BackfaceCullingEnabled( bool val ) = 0;
 
    /// Enables or disables textures. When enabled, shaders can leverage the diffuse map.
    /// \param val If true, then textures are enabled. Otherwise, it's disabled.
    GLS_EXPORT virtual void Texture2DEnabled( bool val ) = 0;
 
    /// Notifies OpenGL the active texture. All subsequent texture state calls will affect the active texture
    /// \param textureUnit the texture unit to make active.
    GLS_EXPORT virtual void ActiveTexture( GLenum textureUnit ) = 0;
 
    /// Binds the given texture to the current active texture unit.
    /// \param texture the texture to bind to the active texture unit.
    GLS_EXPORT virtual void BindTexture( IFontImage* texture ) = 0;
 
    /// Unbinds and deletes the specified texture.
    /// \param texture the texture to unbind from OpenGL and delete.
    GLS_EXPORT virtual void DeleteTexture( IFontImage* texture ) = 0;
 
    /// Determines the horizontal wrapping behavior of the active texture.
    /// \param mode The type of wrapping behavior. Common ones are clamping and repeat.
    GLS_EXPORT virtual void SetTextureWrapS( GLenum mode ) = 0;
 
    /// Determines the vertical wrapping behavior of the active texture.
    /// \param mode The type of wrapping behavior. Common ones are clamping and repeat.
    GLS_EXPORT virtual void SetTextureWrapT( GLenum mode ) = 0;
 
    /// Equivalent to calling glTexEnv. This updates the texture environment mode to determine shader functions should run.
    /// \param mode The type of feature to run. For GLES 2.0, the valid values are GLS_TEXTURE_MAP_MODE_MODULATE,
    /// GLS_TEXTURE_MAP_MODE_REPLACE, GLS_TEXTURE_MAP_MODE_BLEND, and GLS_TEXTURE_MAP_MODE_DECAL.
    /// Otherwise mode may refer to one of six texture functions: GL_ADD, GL_MODULATE, GL_DECAL, GL_BLEND, GL_REPLACE, or GL_COMBINE.
    /// Any other value will disable this feature.
    GLS_EXPORT virtual void SetTextureEnvMode( GLenum mode ) = 0;
 
    /// Updates the shader to blend the specified color.
    /// \param color the new color to blend against.
    GLS_EXPORT virtual void SetTextureBlendColor( GLfloat* color ) = 0;
 
    /// Specifies the active texture's minification function whenever the pixel being textured maps to an area greater than one texture element.
    /// \param mode The function to use when scaling down. Valid values are GL_NEAREST, GL_LINEAR
    /// GL_NEAREST_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR, GL_LINEAR_MIPMAP_LINEAR.
    GLS_EXPORT virtual void SetTextureMinFilter( GLenum mode ) = 0;
 
    /// Specifies the active texture's magnification function whenever the pixel being texture maps to an area less than or equal to one texture element.
    /// \param mode The function to use when scaling up. Valid values are GL_NEAREST, GL_LINEAR.
    GLS_EXPORT virtual void SetTextureMagFilter( GLenum mode ) = 0;
 
    /// Binds the vertex array buffer to an OpenGL context.
    /// \param handle The handle to map to the OpenGL context.
    GLS_EXPORT virtual void BindIndexBuffer( unsigned int handle ) = 0;
 
    /// Binds the vertex attribute array buffer to an OpenGL context.
    /// \param handle The handle to map to the OpenGL context.
    GLS_EXPORT virtual void BindVertexBuffer( unsigned int handle ) = 0;
 
    /// Enables or disables the vertex shader position attribute.
    /// \param val If true, then the shader position attribute is enabled. Otherwise, it's disabled.
    GLS_EXPORT virtual void VertexArrayEnabled( bool val ) = 0;
 
    /// Enables or disables the vertex shader normal attribute.
    /// \param val If true, then the shader normal attribute is enabled. Otherwise, it's disabled.
    GLS_EXPORT virtual void NormalArrayEnabled( bool val ) = 0;
 
    /// Enables or disables the vertex shader texture coordinates attribute.
    /// \param val If true, then the shader texture coordinates are enabled. Otherwise, it's disabled.
    GLS_EXPORT virtual void TextureArrayEnabled( bool val ) = 0;
 
    /// Enables or disables the vertex shader color attribute.
    /// \param val If true, then the shader color attribute is enabled. Otherwise, it's disabled.
    GLS_EXPORT virtual void ColorArrayEnabled( bool val ) = 0;
 
    /// Update the vertex shader's position attribute with the new parameters.
    /// \param size The number of components per generic vertex attribute.
    /// \param type The data type of each component in the array.
    /// \param stride The byte offset between consecutive generic vertex attributes.
    /// \param pointer A pointer to the first component of the first generic vertex attribute in the array.
    GLS_EXPORT virtual void VertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid* pointer ) = 0;
 
    /// Update the vertex shader's texture coordinates attribute with the new parameters.
    /// \param size The number of components per generic vertex attribute.
    /// \param type The data type of each component in the array.
    /// \param stride The byte offset between consecutive generic vertex attributes.
    /// \param pointer A pointer to the first component of the first generic vertex attribute in the array.
    GLS_EXPORT virtual void TexCoordPointer( GLint size, GLenum type, GLsizei stride, const GLvoid* pointer ) = 0;
 
    /// Update the vertex shader's normal attribute with the new parameters.
    /// \param type The data type of each component in the array.
    /// \param stride The byte offset between consecutive generic vertex attributes.
    /// \param pointer A pointer to the first component of the first generic vertex attribute in the array.
    GLS_EXPORT virtual void NormalPointer( GLenum type, GLsizei stride, const GLvoid* pointer ) = 0;
 
    /// Update the vertex shader's color attribute with the new parameters.
    /// \param size The number of components per generic vertex attribute.
    /// \param type The data type of each component in the array.
    /// \param stride The byte offset between consecutive generic vertex attributes.
    /// \param pointer A pointer to the first component of the first generic vertex attribute in the array.
    GLS_EXPORT virtual void ColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid* pointer ) = 0;
 
    /// Enables or disables antialiasing for lines. If enabled, jagged edges will be smoothed out.
    /// \param val If true, then lines are antialiased.
    GLS_EXPORT virtual void LineSmoothEnabled( bool val ) = 0;
 
    /// Determines the width of aliased and antialiased lines. If antialiasing is disabled, the actual width is determined by rounding the
    /// nearest integer. The width may be clamped. See GetMaximumLineWidth.
    /// \param width The number of pixels to fill across the line. This must be a positive value.
    GLS_EXPORT virtual void LineWidth( float width ) = 0;
 
    /// \return The implementation-dependent maximum width for aliased lines the current platform supports.
    GLS_EXPORT virtual float GetMaximumLineWidth() = 0;
 
    /// Specifies the diameter of rasterized points.
    /// \param size Determines the point diameter. This value must be a positive number.
    GLS_EXPORT virtual void PointSize( float size ) = 0;
 
    /// Specifies the render pattern for lines.
    /// \param pattern Determines which fragments of a line will be drawn. The default pattern is all 1's.
    /// \param multiplier Specifies the 'scale' for each bit in the line pattern. For example, if the multiplier is 2,
    /// then the pattern stretches out twice as large. This value is clamped to the range 1 to 256.
    GLS_EXPORT virtual void LineStipple( unsigned short pattern, unsigned int multiplier ) = 0;
 
    /// Updates the color for subsequent drawing commands when rendering primitives.
    /// \param color Updates the current color with this specified color.
    GLS_EXPORT virtual void SetColor( const glsColor& color ) = 0;
 
    /// Sets the current normal vector. Passing in a unit length vector is not required.
    /// \param x The x-axis of the normal vector.
    /// \param y The y-axis of the normal vector.
    /// \param z The z-axis of the normal vector.
    GLS_EXPORT virtual void Normal3f( float x, float y, float z ) = 0;
 
    /// Updates the ambient material parameter to the new color.
    /// \param color The new color to use for the ambient material parameter.
    GLS_EXPORT virtual void AmbientMaterial( const glsColor& color ) = 0;
 
    /// Updates the diffuse material parameter to the new color.
    /// \param color The new color to use for the diffuse material parameter.
    GLS_EXPORT virtual void DiffuseMaterial( const glsColor& color ) = 0;
 
    /// Updates the specular material parameter to the new color.
    /// \param color The new color to use for the specular material parameter.
    GLS_EXPORT virtual void SpecularMaterial( const glsColor& color ) = 0;
 
    /// Updates the emission material parameter to the new color.
    /// \param color The new color to use for the emission material parameter.
    GLS_EXPORT virtual void EmissionMaterial( const glsColor& color ) = 0;
 
    /// Updates the shininess material parameter to the new value.
    /// \param shininess The new shiny value to use for the material. The higher the value, the shinier the material becomes.
    GLS_EXPORT virtual void ShininessMaterial( float shininess ) = 0;
 
    /// Enables or disables lighting.
    /// \param val If true, then lighting is enabled.
    GLS_EXPORT virtual void LightingEnabled( bool val ) = 0;
 
    /// Determines if the shading model should be flat or smooth. When smooth, the colors between vertices are interpolated.
    /// If flat, then only one color from the vertex is chosen for the surface.
    /// \param val If true, then it'll use smooth shading. Otherwise, it'll use flat shading.
    GLS_EXPORT virtual void GouraudShadingEnabled( bool val ) = 0;
 
    /// \return True if lighting is enabled.
    GLS_EXPORT virtual bool IsLightingEnabled() = 0;
 
    /// \param index Index to the light source to check.
    /// \return True if the light source associated with the specified index is enabled.
    GLS_EXPORT virtual bool IsLightSourceEnabled( unsigned int index ) = 0;
 
    /// \return The maximum number of possible lights this platform supports.
    GLS_EXPORT virtual unsigned int GetMaxNumLights() = 0;
 
    /// Sets the specified light source to be active or not.
    /// \param index Index to the light source to update.
    /// \param enabled If true, then the light source will be activated. Otherwise, it'll be deactivated.
    GLS_EXPORT virtual void SetLightEnabled( unsigned int index, bool enabled ) = 0;
 
    /// Sets the ambient color parameter for the specified light source.
    /// \param[in] index Determines which light source should have their ambient color updated.
    /// \param[in] color The new color to use. There must be four floats for the RGBA.
    GLS_EXPORT virtual void SetLightAmbientColor( unsigned int index, GLfloat* color ) = 0;
 
    /// Retrieves the ambient color parameter from the specified light source.
    /// \param[in] index Determines which light source to access.
    /// \param[out] color Copies the ambient color value to this parameter.
    GLS_EXPORT virtual void GetLightAmbientColor( unsigned int index, GLfloat* color ) = 0;
 
    /// Sets the diffuse color parameter for the specified light source.
    /// \param[in] index Determines which light source should have their diffuse color updated.
    /// \param[in] color The new color to use. There must be four floats for the RGBA.
    GLS_EXPORT virtual void SetLightDiffuseColor( unsigned int index, GLfloat* color ) = 0;
 
    /// Retrieves the diffuse color parameter from the specified light source.
    /// \param[in] index Determines which light source to access.
    /// \param[out] color Copies the diffuse color value to this parameter.
    GLS_EXPORT virtual void GetLightDiffuseColor( unsigned int index, GLfloat* color ) = 0;
 
    /// Sets the specular color parameter for the specified light source.
    /// \param[in] index Determines which light source should have their specular color updated.
    /// \param[in] color The new color to use. There must be four floats for the RGBA.
    GLS_EXPORT virtual void SetLightSpecularColor( unsigned int index, GLfloat* color ) = 0;
 
    /// Retrieves the specular color parameter from the specified light source.
    /// \param[in] index Determines which light source to access.
    /// \param[out] color Copies the specular color value to this parameter.
    GLS_EXPORT virtual void GetLightSpecularColor( unsigned int index, GLfloat* color ) = 0;
 
    /// Sets the light position. This is set in local space.
    /// \param[in] index Determines which light source should have their position updated.
    /// \param[in] position The new position in local space. There must be three floats for the XYZ.
    GLS_EXPORT virtual void SetLightPosition( unsigned int index, GLfloat* position ) = 0;
 
    /// Retrieves the position of the specified light source. This is retrieved in eye space.
    /// The retrieved value is different than the set value unless the modelview matrix is identity.
    /// \param[in] index Determines which light source to access.
    /// \param[out] position Copies the position value to this parameter. This is in eye space.
    GLS_EXPORT virtual void GetLightPosition( unsigned int index, GLfloat* position ) = 0;
 
    /// Specifies the direction of the light. This is retrieved in eye space.
    /// The retrieved value is different than the set value unless the modelview matrix is identity.
    /// \param[in] index Determines which light source to access.
    /// \param[in] direction The new light direction in local space. There must be three floats for the XYZ.
    GLS_EXPORT virtual void SetSpotlightDirection( unsigned int index, GLfloat* direction ) = 0;
 
    /// Retrieves the light direction of the specified light source. This is retrieved in eye space.
    /// The retrieved value is different than the set value unless the modelview matrix is identity.
    /// \param[in] index Determines which light source to access.
    /// \param[out] direction Copies the light direction value to this parameter. This is in eye space.
    GLS_EXPORT virtual void GetSpotlightDirection( unsigned int index, GLfloat* direction ) = 0;
 
    /// Specifies the maximum spread angle of the light source.
    /// \param[in] index Determines which light source to access.
    /// \param[in] cutoff The maximum spread angle. Only values within 90 and 180 are accepted where 180 results in uniform light distribution.
    GLS_EXPORT virtual void SetSpotlightCutoff( unsigned int index, GLfloat cutoff ) = 0;
 
    /// \param[in] index Determines which light source to access.
    /// \return The light cutoff / maximum spread angle of the light source.
    GLS_EXPORT virtual GLfloat GetSpotlightCutoff( unsigned int index ) = 0;
 
    /// Updates the light source's intensity distribution of the light.
    /// \param[in] index Determines which light source to access.
    /// \param[in] exponent Specifies the intensity distribution of the light where higher values results in a more focused light source,
    /// and 0 resulting in a more uniformed light distribution.
    GLS_EXPORT virtual void SetSpotlightExponent( unsigned int index, GLfloat exponent ) = 0;
 
    /// \param[in] index Determines which light source to access.
    /// \return The light source intensity distribution from the specified light.
    GLS_EXPORT virtual GLfloat GetSpotlightExponent( unsigned int index ) = 0;
 
    /// Sets the light attenuation factor parameters for the specified light source.
    /// \param[in] index Determines which light source should have their attenuation factor updated.
    /// \param[in] constant Set the new constant factor that is independent from the light distance.
    /// \param[in] linear Sets the new linear attenuation factor.
    /// \param[in] quadratic Sets the new quadratic attenuation factor.
    GLS_EXPORT virtual void SetLightAttenuation( unsigned int index, GLfloat constant, GLfloat linear, GLfloat quadratic ) = 0;
 
    /// Retrieves the light attenuation factors from the specified light.
    /// \param[in] index Determines which light source to access.
    /// \param[out] constant The constant attenuation factor is written to this parameter.
    /// \param[out] linear The linear attenuation factor is written to this parameter.
    /// \param[out] quadratic The quadratic attenuation factor is written to this parameter.
    GLS_EXPORT virtual void GetLightAttenuation( unsigned int index, GLfloat& constant, GLfloat& linear, GLfloat& quadratic ) = 0;
 
    /// \return The maximum number of clip planes supported by the current driver.
    GLS_EXPORT virtual unsigned int GetMaxClipPlanes() = 0;
 
    /// Updates the equation of a clip plane. The equation is set in local space and retrieved in eye space.
    /// The retrieved value is different from the set value unless the modelview matrix is identity.
    /// \param[in] index Determines which plane to access. This must be less than the GetMaxClipPlanes.
    /// \param[in] equation The new equation that defines the plane. Four floats are used to define the plane. This is in local space.
    GLS_EXPORT virtual void ClipPlanef( unsigned int index, float* equation ) = 0;
 
    /// Retrieves the clip plane equation. This is retrieved in eye space, which may be different from the setter.
    /// \param[in] index Determines which plane to access.
    /// \param[out] equation The resulting equation that defines the associated plane is copied to this parameter. There must be four floats.
    GLS_EXPORT virtual void GetClipPlanef( unsigned int index, float* equation ) = 0;
 
    /// Activates the plane associated with the specified index.
    /// \param[in] index Determines which plane to enable.
    GLS_EXPORT virtual void EnableClipPlane( unsigned int index ) = 0;
 
    /// Deactivates the plane associated with the specified index.
    /// \param[in] index Determines which plane to disable.
    GLS_EXPORT virtual void DisableClipPlane( unsigned int index ) = 0;
 
    /// \param[in] index Determines which plane to check.
    /// \return True if the plane associated with the specified index is enabled.
    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