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 _EFFECT_DIFF_NORM_SPEC_REF_H_INCLUDED
#define _EFFECT_DIFF_NORM_SPEC_REF_H_INCLUDED

#include "gls_render_effect.h"

#ifdef _MSC_VER
    // Disable warning in gls_matrix_affine.h (DR 2156)
#    pragma warning( push )
#    pragma warning( disable : 4244 )
#endif
#include "gls_matrix_affine.h"
#ifdef _MSC_VER
#    pragma warning( pop )
#endif

#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;

    class TextureUVWMatrix
    {
        bool _isIdentity;

        float _uOffset;
        float _vOffset;
        float _uTiling;
        float _vTiling;
        float _angle;

        GlsMatrixAffineF _matrix;

    public:
        TextureUVWMatrix();

        bool operator==( const TextureUVWMatrix& rhs ) const;

        // Transform parameters
        void  UOffset( float val ) { _uOffset = val; }
        float UOffset() const { return _uOffset; }
        void  VOffset( float val ) { _vOffset = val; }
        float VOffset() const { return _vOffset; }
        void  UTiling( float val ) { _uTiling = val; }
        float UTiling() const { return _uTiling; }
        void  VTiling( float val ) { _vTiling = val; }
        float VTiling() const { return _vTiling; }
        void  Angle( float val ) { _angle = val; }
        float Angle() const { return _angle; }

        // Should be called after changing the parameters
        void RecalcTransformMatrix();

        // returns true if the matrix is identity
        inline bool IsIdentity() { return _isIdentity; }

        // matrix must be an array of [16]
        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;

    TextureUVWMatrix _diffuseUVWMatrix;
    TextureUVWMatrix _normalUVWMatrix;
    TextureUVWMatrix _specularUVWMatrix;

    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;

    GLSGEN_GlsAdvancedMesh_EXPORT Effect_DiffNormSpecRefl();
    GLSGEN_GlsAdvancedMesh_EXPORT ~Effect_DiffNormSpecRefl();

    /** Assignment operator */
    GLSGEN_GlsAdvancedMesh_EXPORT       Effect_DiffNormSpecRefl( const Effect_DiffNormSpecRefl& );
    GLSGEN_GlsAdvancedMesh_EXPORT const Effect_DiffNormSpecRefl& operator=( const Effect_DiffNormSpecRefl& );

    GLSGEN_GlsAdvancedMesh_EXPORT bool operator==( const Effect_DiffNormSpecRefl& ) const;
    inline bool                        operator!=( const Effect_DiffNormSpecRefl& o ) const { return !( *this == o ); }

    inline void         SetMaterialIndex( unsigned int materialIndex ) { _materialIndex = materialIndex; }
    inline unsigned int GetMaterialIndex() const { return _materialIndex; }

    inline void SetUseVertexColor( bool value )
    {
        _useVertexColors = value;
#ifndef GLES
        SelectShader();
#endif
    }
    inline bool GetUseVertexColor() const { return _useVertexColors; }

    inline void SetDiffuseTextureIndex( int textureIndex )
    {
        _diffuseTextureIndex = textureIndex;
#ifndef GLES
        SelectShader();
#endif
    }
    inline int GetDiffuseTextureIndex() const { return _diffuseTextureIndex; }

    inline void SetNormalTextureIndex( int textureIndex )
    {
        _normalTextureIndex = textureIndex;
#ifndef GLES
        SelectShader();
#endif
    }
    inline int GetNormalTextureIndex() const { return _normalTextureIndex; }

    inline void SetSpecularTextureIndex( int textureIndex )
    {
        _specularTextureIndex = textureIndex;
#ifndef GLES
        SelectShader();
#endif
    }
    inline int GetSpecularTextureIndex() const { return _specularTextureIndex; }

    inline void SetReflectionTextureIndex( int textureIndex )
    {
        _reflectionTextureIndex = textureIndex;
#ifndef GLES
        SelectShader();
#endif
    }
    inline int GetReflectionTextureIndex() const { return _reflectionTextureIndex; }

    inline void SetDiffuseAmount( float value )
    {
        _diffuseAmount = value;
#ifndef GLES
        SelectShader();
#endif
    }
    inline float GetDiffuseAmount() const { return _diffuseAmount; }

    inline void SetNormalAmount( float value )
    {
        _normalAmount = value;
#ifndef GLES
        SelectShader();
#endif
    }
    inline float GetNormalAmount() const { return _normalAmount; }

    inline void SetSpecularAmount( float value )
    {
        _specularAmount = value;
#ifndef GLES
        SelectShader();
#endif
    }
    inline float GetSpecularAmount() const { return _specularAmount; }

    inline void SetReflectionAmount( float value )
    {
        _reflectionAmount = value;
#ifndef GLES
        SelectShader();
#endif
    }
    inline float GetReflectionAmount() const { return _reflectionAmount; }

    inline void SetNormalMapFlipGreen( bool value )
    {
        _normalMapFlipGreen = value;
#ifndef GLES
        SelectShader();
#endif
    }
    inline bool GetNormalMapFlipGreen() const { return _normalMapFlipGreen; }

    /* Set Diffuse Map UV transform parameters
     * Note that 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 );
    GLSGEN_GlsAdvancedMesh_EXPORT void GetDiffuseUVWSettings( float& uOffset, float& vOffset, float& uTiling, float& vTiling, float& angle );

    /* Set Normal Map UV transform parameters
     * Note that 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 );
    GLSGEN_GlsAdvancedMesh_EXPORT void GetNormalUVWSettings( float& uOffset, float& vOffset, float& uTiling, float& vTiling, float& angle );

    /* Set Specular Map UV transform parameters
     * Note that 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 );
    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
    // Not normally called by users
    GLSGEN_GlsAdvancedMesh_EXPORT void SelectShader();

    // Recalculate the texture transform matrices
    // Not normally called by users
    GLSGEN_GlsAdvancedMesh_EXPORT void TextureUVWSettingsChanged();

    // Returns true if the effect has non-default texture transform settings
    // Not normally called by users
    GLSGEN_GlsAdvancedMesh_EXPORT bool UsesTextureTransforms();

    // Returns reference to the effect attribute dictionary
    inline DistiAttribDict& Attributes()
    {
        if( !_attribDict )
        {
            SetupAttribDict();
        }
        return *_attribDict;
    }

    // Return this effect's type as a readable string
    inline const std::string& EffectTypeName()
    {
        return EFFECT_TYPE_NAME;
    }

    /////////////////////////////////////////////
    // VertexAttribIndexLookup Interface
    /////////////////////////////////////////////

    virtual GLint GetVertexAttribIndexForSemantic( int semanticEnum );

    ///////////////////////////////////////////////////////////////////////////
    // GlsRenderEffect overrides
    ///////////////////////////////////////////////////////////////////////////
    virtual void         AddRef();
    virtual void         Release();
    virtual unsigned int GlsRenderEffect_ClassID() const;
    virtual void         SetupEffect(
                DynamicArray<Material, false>& materialPalette,
                TexturePalette*                texturePalette,
                const TextureSettings&         textureSettings,
                float*                         viewToWorld3x3 // 3x3 matrix (float[9])
#if !( ( GLS_VERSION_MAJOR == 4 && ( GLS_VERSION_MINOR == 1 || GLS_VERSION_MINOR == 0 ) ) || GLS_VERSION_MAJOR <= 3 )
        ,
        unsigned int maxLightNum,
        unsigned int activeLightMask
#endif
    );

    virtual void             CleanupEffect();
    virtual int              Compare( const GlsRenderEffect* ) const;
    virtual GlsRenderEffect* Clone() const;
    virtual void             GetReferencedTextures( ReferencedTextureArray& referencedTextures );
    virtual void             GetReferencedMaterials( ReferencedMaterialArray& referencedMaterials );
};

} // namespace disti

#endif