D:/Zythum/DinoKod/Render/Shader.h

//---------------------------------------------------------------------------------------------
//      This file is a part of "DinoKod".
//      Copyright © 2003 Dino Productions. All Rights Reserved.
//      
//      File                    : Shader.h
//      Author                  : Sebastien LEIX        sebastien.leix@wanadoo.fr
//      Date                    : 09/09/2002
//      Modification    :
//
//---------------------------------------------------------------------------------------------
#ifndef __SHADER_H__
#define __SHADER_H__

#include "Render/RenderDll.h"
#include "Common/Types.h"
#include "Common/Bank.h"
#include "Render/Texture.h"
#include "Render/RenderDefs.h"

typedef KHANDLE                                 KSHADER;
#define KSHADER_NO                              ((KSHADER)KHANDLE_INVALID)

class KRender;
class KShaderBank;

//--------------------------------------------------------------------------------------------------------------------------------
// ShaderFlags
#define KSF_NONE                                0x00000000
#define KSF_LIGHTMAP                    0x00000001
#define KSF_RGBGEN                              0x00000002
#define KSF_TCMOD                               0x00000004
                                                                
// SurfaceParm                                  
#define KSSP_NONE                               0x00000000
#define KSSP_ALPHASHADOW                0x00000001
#define KSSP_AREAPORTAL                 0x00000002      
#define KSSP_CLUSTERPORTAL              0x00000004
#define KSSP_DONOTENTER                 0x00000008
#define KSSP_FLESH                              0x00000010
#define KSSP_FOG                                0x00000020
#define KSSP_LAVA                               0x00000040
#define KSSP_METALSTEPS                 0x00000080
#define KSSP_NODAMAGE                   0x00000100
#define KSSP_NODLIGHT                   0x00000200
#define KSSP_NODRAW                             0x00000400
#define KSSP_NODROP                             0x00000800
#define KSSP_NOIMPACT                   0x00001000
#define KSSP_NOMARKS                    0x00002000
#define KSSP_NOLIGHTMAP                 0x00004000
#define KSSP_NOSTEPS                    0x00008000
#define KSSP_NONSOLID                   0x00010000
#define KSSP_ORIGIN                             0x00020000
#define KSSP_PLAYERCLIP                 0x00040000
#define KSSP_SLICK                              0x00080000
#define KSSP_SLIME                              0x00100000
#define KSSP_STRUCTURAL                 0x00200000
#define KSSP_TRANS                              0x00400000
#define KSSP_WATER                              0x00800000
#define KSSP_SKY                                0x01000000
                                                                
// Shader Stage flags                   
#define KSSF_TEXTURE                    0x00000001
#define KSSF_LIGHTMAP                   0x00000002
#define KSSF_MAP                                0x00000004
#define KSSF_CLAMPMAP                   0x00000008
#define KSSF_ANIMMAP                    0x00000010
#define KSSF_BLEND                              0x00000020
#define KSSF_DEPTHTEST                  0x00000040
#define KSSF_ALPHATEST                  0x00000080
#define KSSF_BUMPMAP                    0x00000100
#define KSSF_ENVMAP                             0x00000200
                                                                
// Shader Stage TCMOD                   
#define KSST_NO                                 0x00000000
#define KSST_ROTATE                             0x00000001
#define KSST_SCALE                              0x00000002
#define KSST_SCROLL                             0x00000003
#define KSST_STRETCH                    0x00000004
#define KSST_TRANSFORM                  0x00000005
#define KSST_TURB                               0x00000006

// Shader Stage TCMODFUNC
#define KSSTF_NO                                0x00000000
#define KSSTF_SIN                               0x00000001
#define KSSTF_TRIANGLE                  0x00000002
#define KSSTF_SQUARE                    0x00000003
#define KSSTF_SAWTOOTH                  0x00000004
#define KSSTF_INVERSESAWTOOTH   0x00000005

// Shader Stage RGBGEN
#define KSSR_NO                                 0x00000000
#define KSSR_IDENTITYLIGHTING   0x00000001
#define KSSR_IDENTITY                   0x00000002
#define KSSR_WAVE                               0x00000003
#define KSSR_ENTITY                             0x00000004
#define KSSR_ONEMINUSENTITY             0x00000005
#define KSSR_VERTEX                             0x00000006
#define KSSR_ONEMINUSVERTEX             0x00000007
#define KSSR_LIGHTINGDIFFUSE    0x00000008

// Shader Stage RGBGEN WAVEFUNC
#define KSSTW_NO                                0x00000000
#define KSSTW_SIN                               0x00000001
#define KSSTW_TRIANGLE                  0x00000002
#define KSSTW_SQUARE                    0x00000003
#define KSSTW_SAWTOOTH                  0x00000004
#define KSSTW_INVERSESAWTOOTH   0x00000005


// Shader General
// Cull
#define KSGC_CW                                 0x00000001
#define KSGC_CCW                                0x00000002
#define KSGC_NONE                               0x00000004

//--------------------------------------------------------------------------------------------------------------------------------
class RENDER_API KShaderTcMod
{
public:
        u8                                              m_TcMod;
        u8                                              m_TcModFunc;
        float                                   m_TcModParam1;
        float                                   m_TcModParam2;
        float                                   m_TcModParam3;
        float                                   m_TcModParam4;
        float                                   m_TcModParam5;
        float                                   m_TcModParam6;

        KShaderTcMod()
        {
                m_TcMod                 = KSST_NO;
                m_TcModFunc             = KSSTF_NO;
                m_TcModParam1   = 0.0f;
                m_TcModParam2   = 0.0f;
                m_TcModParam3   = 0.0f;
                m_TcModParam4   = 0.0f;
                m_TcModParam5   = 0.0f;
                m_TcModParam6   = 0.0f;
        }
};

//--------------------------------------------------------------------------------------------------------------------------------
class RENDER_API KShaderStage
{
public:
        char*                                   m_pMapName;
        KTEXTURE*                               m_pTextureList;
        u32                                             m_nTextures;
        u32                                             m_StageFlags;
        float                                   m_Frequency;
        KRBLEND                                 m_BlendSrc;
        KRBLEND                                 m_BlendDst;
        u32                                             m_AlphaRef;
        KRCMPFUNC                               m_AlphaFunc;
        bool                                    m_bDepthWrite;
        KRCMPFUNC                               m_DepthFunc;
        KTable<KShaderTcMod*>   m_TcModList;
        u32                                             m_RgbGen;
        u32                                             m_RgbGenWaveFunc;
        float                                   m_RgbGenWaveParam1;
        float                                   m_RgbGenWaveParam2;
        float                                   m_RgbGenWaveParam3;
        float                                   m_RgbGenWaveParam4;
        u32                                             m_TexCoordIndex;

        KShaderStage()
        {
                m_AlphaRef                      = 128;
                m_AlphaFunc                     = KRCMP_ALWAYS;
                m_DepthFunc                     = KRCMP_LESSEQUAL;
                m_pMapName                      = NULL;
                m_pTextureList          = NULL;
                m_nTextures                     = 0;
                m_Frequency                     = 0.0f;
                m_BlendSrc                      = KRBLEND_ONE;
                m_BlendDst                      = KRBLEND_ZERO;
                m_StageFlags            = KSSF_TEXTURE;
                m_RgbGen                        = KSSR_NO;
                m_RgbGenWaveFunc        = KSSTW_NO;
                m_RgbGenWaveParam1      = 0.0f;
                m_RgbGenWaveParam2      = 0.0f;
                m_RgbGenWaveParam3      = 0.0f;
                m_RgbGenWaveParam4      = 0.0f;
                m_TexCoordIndex         = 0;
                m_bDepthWrite           = true;
        }

        ~KShaderStage()
        {
                if( m_pTextureList )    Deletev( m_pTextureList );
                if( m_pMapName )                free( m_pMapName );

                for( u32 t = 0; t < m_TcModList.GetSize(); t ++ )
                {
                        if( m_TcModList[t] )
                                Deletep( m_TcModList[t] );
                }
                m_TcModList.Clear();
        }
};

//--------------------------------------------------------------------------------------------------------------------------------
class RENDER_API KShader
{
public: 
        KRender*                                m_pRender;
        KShaderBank*                    m_pShaderBank;
        u32                                             m_Flags;
        char*                                   m_pName;
        u32                                             m_SurfaceParm;
        u32                                             m_Cull;
        KTable<KShaderStage*>   m_StageList;
        bool                                    m_bMipMap;
        u16                                             m_SortValue;
        KSHADER                                 m_hShader;
        KTEXTURE                                m_hTexture;
        bool                                    m_bAlpha;
        s32                                             m_nInstances;

        KShader( KRender* pRender, KShaderBank* pShaderBank )
        {
                m_pRender                       = pRender;
                m_pShaderBank           = pShaderBank;
                m_Flags                         = KSF_NONE;
                m_hShader                       = KSHADER_NO;
                m_hTexture                      = KTEXTURE_NO;
                m_pName                         = NULL;
                m_SurfaceParm           = KSSP_NONE;
                m_Cull                          = KSGC_CCW;
                m_bMipMap                       = true;
                m_SortValue                     = 0;
                m_bAlpha                        = false;
                m_nInstances            = 0;
        }

        ~KShader()
        {
                if( m_pName )
                        free( m_pName );

                FlushAllStages();
        }

        void FlushAllStages();
        void FlushAllTextures();
        void LoadTextures( u32 Size );
        void AddStage( char* pMapName, KRBLEND BlendSrc = KRBLEND_ONE, KRBLEND BlendDst = KRBLEND_ONE );
        void SetStageBlend( u32 Stage, KRBLEND BlendSrc = KRBLEND_ONE, KRBLEND BlendDst = KRBLEND_ONE );

        KShaderBank*                    GetpShaderBank()        { return m_pShaderBank;                 }
        u32                                             GetnStages()            { return m_StageList.GetSize(); }
        
        void                                    AddInstance()           { m_nInstances ++;                                                              }
        void                                    RemoveInstance()        { KASSERT( m_nInstances > 0); m_nInstances --;  }
        s32                                             GetnInstances()         { return m_nInstances;                                                  }
};

//--------------------------------------------------------------------------------------------------------------------------------
class RENDER_API KShaderBank : public KBank< KShader, KSHADER >
{
protected:
        KRender*                                m_pRender;

        bool                                    LoadFile( char* pFileName );
        static KRBLEND                  GetBlendByText( char* pBlendText );
                                                        
public:                                         
                                                        KShaderBank( KRender* pRender );
        virtual                                 ~KShaderBank();
                                                        
        bool                                    PreLoad();
        KSHADER                                 LoadShader( char* pShaderName, u32 Size = 1 );
        void                                    UnloadShader( KSHADER& hShader );
        KSHADER                                 CreateShader( char* pShaderName );
        KTEXTURE                                GetTexture( char* pFileName, bool GenerateMipMap = true, u32 Size = 1 );
        void                                    FlushShader( KSHADER ShaderId );
        KShader*                                GetpShader( KSHADER Handle )    { return GetpData( Handle ); }
        void                                    DumpUsed();
        void                                    UnloadTexture( KTEXTURE hTexture );
};

#endif  __SHADER_H__

---