gls_es20_effect.h

Go to the documentation of this file.

/*! \file
  \brief The disti::GlsEffect class. Holds information pertaining to shader programs and their uniform/attribute data
 
  \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_ES20_EFFECT_H_INCLUDED
#define DISTI_GLS_ES20_EFFECT_H_INCLUDED
 
#include "dynamic_array.h"
#include "gls_es20_effect_params.h"
#include "gls_es20_uniform.h"
#include "gls_gl.h"
 
#include <map>
 
namespace disti
{
/** The GlsEffect Class. This class stores program objects and lists of uniforms.
* Because all construction methods are private, Effects can be only created with the
* friend Factory class.
*/
class GlsEffect
{
    /** Only the effect factory should be creating new effects. */
    friend class GlsEffectFactoryImpl;
    friend class std::map<GLuint, GlsEffect>;
    friend class DynamicArray<GlsEffect, false>;
 
public:
    /** Get uniform data for one of the standard uniforms.
      * \param[in] uniform The standard uniform enum (\see StdUniforms_e)
      * \pre uniform is a valid StdUniforms_e
      * \return the uniform
      */
    GLS_EXPORT GlsUniform* GetStdUniform( StdUniforms_e uniform );
 
    /** Get uniform data for one of the custom uniforms.
      * \param[in] uniform The custom uniform's ID
      * \return the uniform
      */
    GLS_EXPORT GlsUniform* GetCustomUniform( GLint uniform );
 
    /** Get attribute location
      * \param[in] attribute The standard attribute to query (\see StdAttribs_e)
      * \pre attribute is a valid StdAttribs_e
      * \return The attribute's location
      */
    GLS_EXPORT GLuint GetAttribLocation( StdAttribs_e attribute );
 
    /** Compile and link vertex and fragment shaders, creating a program object.
      * \param[in] vertexShader The vertex shader.
      * \param[in] fragmentShader The fragment shader.
      * \return The newly created program object, or 0 on error.
      */
    GLS_EXPORT GLuint CreateShader( const GLchar* vertexShader, const GLchar* fragmentShader );
 
    /** Create a custom uniform to add to this effect's list of custom uniforms
      * \param[in] uniformName The string representing the name of this uniform
      * \return the ID corresponding to this custom uniform's position in the array, or -1 on failure
      */
    GLS_EXPORT GLint CreateCustomUniform( const char* uniformName );
 
    /** Indicates if this effect was successfully loaded or not
      * \return true if the effect has been successfully loaded
      */
    GLS_EXPORT bool IsInitialized();
 
    /** Use the program for this effect.
      */
    GLS_EXPORT void UseProgram();
 
    /** Get the program object associated with this effect.
      * \return the program object
      */
    GLS_EXPORT GLuint GetProgramObject();
 
    /** dtor */
    GLS_EXPORT ~GlsEffect();
 
protected:
    /// Delete/destroy the shader program and its shaders.
    /// \param vertObject GL index of the vertex shader program.
    /// \param fragObject GL index of the fragment shader program.
    /// \pre none
    /// \post shaders are deleted
    /// \post _programObject == 0
    void FreeShaders( GLuint vertObject, GLuint fragObject );
 
    /** Load and compile a new shader.
      * \param[in] shaderType The type of shader this is
      * \param[in] shaderSource The code for the shader
      * \pre shaderType is GL_VERTEX_SHADER or GL_FRAGMENT_SHADER
      * \return The shader object's ID or 0 on failure.
      */
    GLuint LoadAndCompileShader( GLenum shaderType, const char* shaderSource );
 
    /// Hashes the shader programs, used to determine the filename of the precompiled shader
    /// for platforms that do not support inline shader compilation.
    /// \param vertexShader The vertex shader program source code.
    /// \param fragmentShader The fragment shader program source code.
    /// \return A hash of the shader programs.
    std::size_t HashShader( const GLchar* vertexShader, const GLchar* fragmentShader );
 
    /** This effect's program object. */
    GLuint _programObject;
 
    /** Standard uniform types. Index values can be acquired from the factory. */
    GlsUniform _stdUniforms[ MAX_STD_UNIFORMS ];
 
    /** Custom uniform types for custom shaders. */
    DynamicArray<GlsUniform, false> _customUniforms;
 
    /** The attributes for this effect. */
    GLint _attribLocations[ MAX_STD_ATTRIBS ];
 
private:
    /** Private constructor.
      * This class should only be instantiated by the GlsEffectFactory class.
      */
    GlsEffect();
 
    // disallow
    GlsEffect( const GlsEffect& src );
    GlsEffect& operator=( const GlsEffect& rhs );
};
 
} // namespace disti
 
#endif // DISTI_GLS_ES20_EFFECT_H_INCLUDED