effect_diff_norm_spec_refl.h

Go to the documentation of this file.

/*! \file
  \brief Render effect that supports diffuse, normal, specular, and reflection maps
 
  \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 INCLUDED_EFFECT_DIFF_NORM_SPEC_REF_H
#define INCLUDED_EFFECT_DIFF_NORM_SPEC_REF_H
 
#include "gls_matrix_affine.h"
#include "gls_render_effect.h"
 
#ifdef GLES
#    include "gls_state_manager.h"
#endif
 
//////////////////// Provides support for creating DLLs ////////////////////////
#if( defined( GLSGEN_EXPORT_GLSADVANCEDMESH ) || defined( GLSGEN_IMPORT_GLSADVANCEDMESH ) || defined( GLS_EXPORT_GENERATED ) || defined( GLS_IMPORT_GENERATED ) ) \
    && defined( _MSC_VER )
#    if defined( GLSGEN_EXPORT_GLSADVANCEDMESH ) || defined( GLS_EXPORT_GENERATED )
#        define GLSGEN_GlsAdvancedMesh_EXPORT __declspec( dllexport )
#    else
#        define GLSGEN_GlsAdvancedMesh_EXPORT __declspec( dllimport )
#    endif
#else
#    define GLSGEN_GlsAdvancedMesh_EXPORT
#endif
///////////////////////////////////////////////////////////////////////////////
 
namespace disti
{
#ifndef GLES
class MaxLike_Shader;
#endif
 
/** Render effect that supports diffuse, normal, specular, and reflection maps. */
class Effect_DiffNormSpecRefl : public GlsRenderEffect
{
public:
    static const std::string EFFECT_TYPE_NAME; ///< Backing storage for the human readable string for this effect type.
 
    /// \details The TextureUVWMatrix class. Describes a texture transformation.
    class TextureUVWMatrix
    {
        bool _isIdentity; ///< Is true if the matrix is identity.
 
        float _uOffset; ///< Texture U (X) offset.
        float _vOffset; ///< Texture V (Y) offset.
        float _uTiling; ///< Texture scaling on U (X) axis.
        float _vTiling; ///< Texture scaling on V (Y) axis.
        float _angle;   ///< Texture rotation angle in degrees.
 
        GlsMatrixAffineF _matrix; ///< Texture transform matrix.
 
    public:
        TextureUVWMatrix();
 
        /// Equality operator
        /// \param rhs The object to compare.
        /// \return Whether or not the objects are equal.
        bool operator==( const TextureUVWMatrix& rhs ) const;
 
        /// Sets the U offset for this texture.
        /// \param val The new U offset to set.
        void UOffset( float val ) { _uOffset = val; }
 
        /// \return The U offset for this texture.
        float UOffset() const { return _uOffset; }
 
        /// Sets the V offset for this texture.
        /// \param val The new V offset to set.
        void VOffset( float val ) { _vOffset = val; }
 
        /// \return The V offset for this texture.
        float VOffset() const { return _vOffset; }
 
        /// Sets the U scale for this texture.
        /// \param val The new U scale to set.
        void UTiling( float val ) { _uTiling = val; }
 
        /// \return The U scale for this texture.
        float UTiling() const { return _uTiling; }
 
        /// Sets the V scale for this texture.
        /// \param val The new V scale to set.
        void VTiling( float val ) { _vTiling = val; }
 
        /// \return The V scale for this texture.
        float VTiling() const { return _vTiling; }
 
        /// Set the rotation angle in degrees for this texture.
        /// \param val The new rotation angle to set.
        void Angle( float val ) { _angle = val; }
 
        /// \return The rotation angle for this texture.
        float Angle() const { return _angle; }
 
        /// Should be called after changing the parameters.
        void RecalcTransformMatrix();
 
        /// \return True if the matrix is identity.
        inline bool IsIdentity() { return _isIdentity; }
 
        /// \note Matrix must be an array of [16].
        /// \return The underlying matrix data.
        inline float* GetTransformMatrix() { return _matrix.Data(); }
    };
 
protected:
    unsigned int _ref_count; ///< Reference count
 
#ifdef GLES20
    GlsEffect* _shader;              /**< The current active effect in the system. If NULL, then no effect is active.
                          *    Effects are retrieved from the GlsEffectFactory class. */
    bool       _userHasCustomShader; /** whether or not the user already had a custom shader set up */
#elif !defined( GLES )
    MaxLike_Shader* _shader; ///< shader program to use (if any)
#endif
 
    unsigned int _materialIndex;          ///< The material index to use
    int          _diffuseTextureIndex;    ///< INVALID_INDEX, or the texture index to use
    int          _normalTextureIndex;     ///< INVALID_INDEX, or the texture index to use
    int          _specularTextureIndex;   ///< INVALID_INDEX, or the texture index to use
    int          _reflectionTextureIndex; ///< INVALID_INDEX, or the texture index to use
 
    float _diffuseAmount;    ///< [0.0,1.0] "Weight" of the diffuse map
    float _normalAmount;     ///< [0.0,1.0] "Weight" of the normal map
    float _specularAmount;   ///< [0.0,1.0] "Weight" of the specular map
    float _reflectionAmount; ///< [0.0,1.0] "Weight" of the reflection map
 
    bool _useVertexColors; ///< true: use vertex color for diffuse rather than material diffuse
 
    /// true: expect 'DirectX' format normal maps (positive Green points down)
    /// false: expect 'OpenGL' format normal maps (positive Green points up)
    /// Note: the sense is backwards from the Max 'Normal Bump' 'Flip Green' option because
    /// Max defaults to 'DirectX' format and GL Studio defaults to 'OpenGL' format
    bool _normalMapFlipGreen;
 
    DistiAttribDict* _attribDict; ///< The attribute dictionary for this object.
 
    TextureUVWMatrix _diffuseUVWMatrix;  ///< The texture transform for the diffuse texture.
    TextureUVWMatrix _normalUVWMatrix;   ///< The texture transform for the normal texture.
    TextureUVWMatrix _specularUVWMatrix; ///< The texture transform for the specular texture.
 
    /// Called to add this object's attributes to the dictionary.
    /// \note Not normally called by users.
    void SetupAttribDict();
 
public:
#ifdef GLES20
    static const GLenum NORMAL_MAP_TEXTURE_UNIT     = GL_TEXTURE1; ///< the texture unit that the normal map should be bound to, \see glActiveTexture
    static const GLenum SPECULAR_MAP_TEXTURE_UNIT   = GL_TEXTURE2; ///< the texture unit that the specular map should be bound to, \see glActiveTexture
    static const GLenum REFLECTION_MAP_TEXTURE_UNIT = GL_TEXTURE3; ///< the texture unit that the reflection map should be bound to, \see glActiveTexture
 
    /** Get the index for the sampler uniform for the given texture unit
      * \param textureUnit the texture unit (e.g. GL_TEXTURE1)
      * \return the index for the sampler uniform
      */
    static inline unsigned int TextureUnitIndex( GLenum textureUnit ) { return textureUnit - GL_TEXTURE0; }
#endif // GLES20
 
    static const int INVALID_INDEX = -1; ///< Value to represent an invalid texture index.
 
    GLSGEN_GlsAdvancedMesh_EXPORT Effect_DiffNormSpecRefl();
    GLSGEN_GlsAdvancedMesh_EXPORT ~Effect_DiffNormSpecRefl();
 
    /// Copy constructor
    GLSGEN_GlsAdvancedMesh_EXPORT Effect_DiffNormSpecRefl( const Effect_DiffNormSpecRefl& );
 
    /// Assignment operator
    /// \return the resulting object (this)
    GLSGEN_GlsAdvancedMesh_EXPORT const Effect_DiffNormSpecRefl& operator=( const Effect_DiffNormSpecRefl& );
 
    /// Equality operator
    /// \return Whether or not the objects are equal.
    GLSGEN_GlsAdvancedMesh_EXPORT bool operator==( const Effect_DiffNormSpecRefl& ) const;
 
    /// Inequality operator
    /// \param o The object to compare.
    /// \return Whether or not the objects are not equal.
    inline bool operator!=( const Effect_DiffNormSpecRefl& o ) const { return !( *this == o ); }
 
    /// Set the material index for this effect.
    /// \param materialIndex The new material index for this effect.
    inline void SetMaterialIndex( unsigned int materialIndex ) { _materialIndex = materialIndex; }
 
    /// \return The current material index for this effect.
    inline unsigned int GetMaterialIndex() const { return _materialIndex; }
 
    /// Set whether or not to use vertex colors, rather than material colors.
    /// \param value The new value to set.
    inline void SetUseVertexColor( bool value )
    {
        _useVertexColors = value;
#ifndef GLES
        SelectShader();
#endif
    }
 
    /// \return Whether the effect is using vertex colors, rather than material colors.
    inline bool GetUseVertexColor() const { return _useVertexColors; }
 
    /// Set the texture index that will provide the diffuse color for the effect.
    /// \param textureIndex The new texture index to set.
    inline void SetDiffuseTextureIndex( int textureIndex )
    {
        _diffuseTextureIndex = textureIndex;
#ifndef GLES
        SelectShader();
#endif
    }
 
    /// \return The current diffuse color texture index for this effect.
    inline int GetDiffuseTextureIndex() const { return _diffuseTextureIndex; }
 
    /// Set the texture index that will provide normals for the effect
    /// \param textureIndex The new texture index to set.
    inline void SetNormalTextureIndex( int textureIndex )
    {
        _normalTextureIndex = textureIndex;
#ifndef GLES
        SelectShader();
#endif
    }
 
    /// \return The current normal texture index for this effect.
    inline int GetNormalTextureIndex() const { return _normalTextureIndex; }
 
    /// Set the texture index that will provide specular for this effect.
    /// \param textureIndex The new texture index to set.
    inline void SetSpecularTextureIndex( int textureIndex )
    {
        _specularTextureIndex = textureIndex;
#ifndef GLES
        SelectShader();
#endif
    }
 
    /// \returns The current specular texture index for this effect.
    inline int GetSpecularTextureIndex() const { return _specularTextureIndex; }
 
    /// Set the texture index that will provide reflections for this effect.
    /// \param textureIndex The new texture index to set.
    inline void SetReflectionTextureIndex( int textureIndex )
    {
        _reflectionTextureIndex = textureIndex;
#ifndef GLES
        SelectShader();
#endif
    }
 
    /// \returns The current reflection texture index for this effect.
    inline int GetReflectionTextureIndex() const { return _reflectionTextureIndex; }
 
    /// Set the weight of the diffuse texture from 0.0 to 1.0.
    /// \param value The new weight to set.
    inline void SetDiffuseAmount( float value )
    {
        _diffuseAmount = value;
#ifndef GLES
        SelectShader();
#endif
    }
 
    /// \return The current weight for the diffuse texture.
    inline float GetDiffuseAmount() const { return _diffuseAmount; }
 
    /// Set the weight of the normal texture from 0.0 to 1.0.
    /// \param value The new weight to set.
    inline void SetNormalAmount( float value )
    {
        _normalAmount = value;
#ifndef GLES
        SelectShader();
#endif
    }
 
    /// \return The current weight for the normal texture.
    inline float GetNormalAmount() const { return _normalAmount; }
 
    /// Set the weight of the specular texture from 0.0 to 1.0.
    /// \param value The new weight to set.
    inline void SetSpecularAmount( float value )
    {
        _specularAmount = value;
#ifndef GLES
        SelectShader();
#endif
    }
 
    /// \return The current weight for the specular texture.
    inline float GetSpecularAmount() const { return _specularAmount; }
 
    /// Set the weight of the reflection texture from 0.0 to 1.0.
    /// \param value The new weight to set.
    inline void SetReflectionAmount( float value )
    {
        _reflectionAmount = value;
#ifndef GLES
        SelectShader();
#endif
    }
 
    /// \return The current weight for the reflection texture.
    inline float GetReflectionAmount() const { return _reflectionAmount; }
 
    /// Set flipping the normal map green channel for DirectX textures (true) or OpenGL textures (false).
    /// \param value The new flip value.
    inline void SetNormalMapFlipGreen( bool value )
    {
        _normalMapFlipGreen = value;
#ifndef GLES
        SelectShader();
#endif
    }
 
    /// \return The current normal map green channel flip: true for DirectX textures, false for OpenGL textures.
    inline bool GetNormalMapFlipGreen() const { return _normalMapFlipGreen; }
 
    /// Set Diffuse Map UV transform parameters.
    /// \note Scaling and rotation are performed from the center of the texture.
    /// \param uOffset U axis translation.
    /// \param vOffset V axis translation.
    /// \param uTiling U axis scaling.
    /// \param vTiling V axis scaling.
    /// \param angle X axis rotation in degrees.
    GLSGEN_GlsAdvancedMesh_EXPORT void SetDiffuseUVWSettings( float uOffset, float vOffset, float uTiling, float vTiling, float angle );
 
    /// Get Diffuse Map UV transform parameters.
    /// \param uOffset Returned u axis translation.
    /// \param vOffset Returned v axis translation.
    /// \param uTiling Returned u axis scaling.
    /// \param vTiling Returned v axis scaling.
    /// \param angle Returned x axis rotation in degrees.
    GLSGEN_GlsAdvancedMesh_EXPORT void GetDiffuseUVWSettings( float& uOffset, float& vOffset, float& uTiling, float& vTiling, float& angle );
 
    /// Set Normal Map UV transform parameters.
    /// \note Scaling and rotation are performed from the center of the texture.
    /// \param uOffset U axis translation.
    /// \param vOffset V axis translation.
    /// \param uTiling U axis scaling.
    /// \param vTiling V axis scaling.
    /// \param angle W-axis rotation in degrees.
    GLSGEN_GlsAdvancedMesh_EXPORT void SetNormalUVWSettings( float uOffset, float vOffset, float uTiling, float vTiling, float angle );
 
    /// Get Normal Map UV transform parameters.
    /// \param uOffset Returned u axis translation.
    /// \param vOffset Returned v axis translation.
    /// \param uTiling Returned u axis scaling.
    /// \param vTiling Returned v axis scaling.
    /// \param angle Returned W-axis rotation in degrees.
    GLSGEN_GlsAdvancedMesh_EXPORT void GetNormalUVWSettings( float& uOffset, float& vOffset, float& uTiling, float& vTiling, float& angle );
 
    /// Set Specular Map UV transform parameters.
    /// \note Scaling and rotation are performed from the center of the texture.
    /// \param uOffset U axis translation.
    /// \param vOffset V axis translation.
    /// \param uTiling U axis scaling.
    /// \param vTiling V axis scaling.
    /// \param angle W-axis rotation in degrees.
    GLSGEN_GlsAdvancedMesh_EXPORT void SetSpecularUVWSettings( float uOffset, float vOffset, float uTiling, float vTiling, float angle );
 
    /// Get Specular Map UV transform parameters.
    /// \param uOffset Returned u axis translation.
    /// \param vOffset Returned v axis translation.
    /// \param uTiling Returned u axis scaling.
    /// \param vTiling Returned v axis scaling.
    /// \param angle Returned W-axis rotation in degrees.
    GLSGEN_GlsAdvancedMesh_EXPORT void GetSpecularUVWSettings( float& uOffset, float& vOffset, float& uTiling, float& vTiling, float& angle );
 
    /// Selects the shader to use based on the current effect parameters.
    /// \note Not normally called by users.
    GLSGEN_GlsAdvancedMesh_EXPORT void SelectShader();
 
    /// Recalculate the texture transform matrices.
    /// \note Not normally called by users.
    GLSGEN_GlsAdvancedMesh_EXPORT void TextureUVWSettingsChanged();
 
    /// \return true if the effect has non-default texture transform settings
    /// \note Not normally called by users.
    GLSGEN_GlsAdvancedMesh_EXPORT bool UsesTextureTransforms();
 
    /// \return A reference to the effect's attribute dictionary.
    inline DistiAttribDict& Attributes() DISTI_METHOD_OVERRIDE
    {
        if( !_attribDict )
        {
            SetupAttribDict();
        }
        return *_attribDict;
    }
 
    /// \return This effect's type as a readable string.
    inline const std::string& EffectTypeName() DISTI_METHOD_OVERRIDE
    {
        return EFFECT_TYPE_NAME;
    }
 
    /////////////////////////////////////////////
    // VertexAttribIndexLookup Interface
    /////////////////////////////////////////////
 
    virtual GLint GetVertexAttribIndexForSemantic( int semanticEnum ) DISTI_METHOD_OVERRIDE;
 
    ///////////////////////////////////////////////////////////////////////////
    // GlsRenderEffect overrides
    ///////////////////////////////////////////////////////////////////////////
    virtual void         AddRef() DISTI_METHOD_OVERRIDE;
    virtual void         Release() DISTI_METHOD_OVERRIDE;
    virtual unsigned int GlsRenderEffect_ClassID() const DISTI_METHOD_OVERRIDE;
    virtual void         SetupEffect(
                DynamicArray<Material>& materialPalette,
                TexturePalette*         texturePalette,
                const TextureSettings&  textureSettings,
                float*                  viewToWorld3x3, // 3x3 matrix (float[9])
                unsigned int            maxLightNum,
                unsigned int            activeLightMask ) DISTI_METHOD_OVERRIDE;
 
    virtual void             CleanupEffect() DISTI_METHOD_OVERRIDE;
    virtual int              Compare( const GlsRenderEffect* ) const DISTI_METHOD_OVERRIDE;
    virtual GlsRenderEffect* Clone() const DISTI_METHOD_OVERRIDE;
    virtual void             GetReferencedTextures( ReferencedTextureArray& referencedTextures ) DISTI_METHOD_OVERRIDE;
    virtual void             GetReferencedMaterials( ReferencedMaterialArray& referencedMaterials ) DISTI_METHOD_OVERRIDE;
};
 
} // namespace disti
 
#endif