GxResShader.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
class GxShaderCompiler;
//===========================================================================
//===========================================================================
#if GX_USE_HLSL
#define GX_SHADER_PACKAGE_DIR(_Dir, _ShaderFile) (_Dir "/shader_hlsl/" _ShaderFile)
#elif GX_USE_OPENGL
#define GX_SHADER_PACKAGE_DIR(_Dir, _ShaderFile) (_Dir "/shader_glsl/" _ShaderFile)
#endif  // !GX_USE_OPENGL
 
//===========================================================================
//===========================================================================
class GxResShaderBase : public GxResBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_ABSTRACT_RESOURCE(GxResShaderBase, GxResBase)
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResShaderBase)
 
public:
    struct GxResShaderHeader
    {
        u32             _shaderSize;            
        u32             _constantBufferSize;    
        u32             _usageInputSemantics;   
        u32             _registerTableTotal;    
        u32             _registerTableCount[static_cast<s32>(GxRenderShader::REGISTER_SET_TYPE::MAX)];  
        u32             _registerCount[static_cast<s32>(GxRenderShader::REGISTER_SET_TYPE::MAX)];       
        u32             _registerStart[static_cast<s32>(GxRenderShader::REGISTER_SET_TYPE::MAX)];       
    };
 
    struct GxCreateCallbackArgument
    {
        b32 _usePragma;                 
        GX_CSTR _entryName;             
#if GX_USE_DX11
        b32 _backwardsCompatibility;    
#endif //GX_USE_DX11
    };
protected:
    static GX_CSTR          SHADER_ENTRYPOINT;  
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxResShaderBase(void)
        : _pRenderShader(nullptr)
        , _pShaderCode(nullptr)
        , _usePragma(true)
        , _entryName(SHADER_ENTRYPOINT)
#if GX_USE_DX11
        , _backwardsCompatibility(false)
#endif //GX_USE_DX11
    {
        GX_MEMSET(&_header, 0, sizeof(GxResShaderHeader));
    }
 
public:
    void cleanup(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    b32 load(GxStream& stream, u32 dataSize);
#if GX_DEVELOP
    b32 save(GxStream& stream);
#endif  // GX_DEVELOP
 
protected:
    GX_FORCE_INLINE virtual b32 createShader(void) { return false; }
    void createCallback(void* pUser);
 
    b32 readShaderCode(GxStreamReader& reader);
    b32 readConstantRegisterTable(GxStreamReader& reader);
 
#if GX_DEVELOP
    b32 writeShaderCode(GxStreamWriter& writer);
    b32 writeConstantRegisterTable(GxStreamWriter& writer);
 
    b32 setHeaderFromCompiler(const GxShaderCompiler& shaderCompiler);
    b32 setShaderCodeFromCompiler(const GxShaderCompiler& shaderCompiler);
    b32 setConstantRegisterTableFromCompiler(const GxShaderCompiler& shaderCompiler);
#endif  // GX_DEVELOP
 
    void setConstantRegisterSetInformation(GxRenderShader::GxRegisterSet* pConstantRegisterSet, void* pConstantRegisterParameterTable);
#if GX_DEVELOP
    void setConstantRegisterParameterInformation(void* pConstantRegisterParameterTable, const GxShaderCompiler& shaderCompiler);
 
    static b32 isCommentCode(GX_CSTR string, u32& codeSize);
    static void* allocateCompilerMemory(size_t size);
    static void  freeCompilerMemory(void* pAddress);
#endif  // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxRenderShader*         _pRenderShader;             
    GxResShaderHeader       _header;                    
    void*                   _pShaderCode;               
 
    b32                     _usePragma;                 
    GX_CSTR                 _entryName;                 
#if GX_USE_DX11
    b32                     _backwardsCompatibility;    
#endif //GX_USE_DX11
 
};
 
//===========================================================================
//===========================================================================
class GxResShaderVertex : public GxResShaderBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_RESOURCE(GxResShaderVertex, GxResShaderBase)
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResShaderVertex)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxResShaderVertex(void) {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE GxRenderVertexShader* getVertexShader(void) const { return gx_cast<GxRenderVertexShader*>(_pRenderShader); }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    b32 createShader(void) override;
 
};
 
#if GX_DEVELOP
//===========================================================================
//===========================================================================
class GxResShaderVertexVsh : public GxResShaderVertex
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_RESOURCE(GxResShaderVertexVsh, GxResShaderVertex)
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResShaderVertexVsh)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxResShaderVertexVsh(void) {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    b32 load(GxStream& stream, u32 size);
 
};
#endif  // GX_DEVELOP
 
//===========================================================================
//===========================================================================
class GxResShaderPixel : public GxResShaderBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_RESOURCE(GxResShaderPixel, GxResShaderBase)
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResShaderPixel)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxResShaderPixel(void) {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE GxRenderPixelShader* getPixelShader(void) const { return gx_cast<GxRenderPixelShader*>(_pRenderShader); }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    b32 createShader(void) override;
 
};
 
#if GX_DEVELOP
//===========================================================================
//===========================================================================
class GxResShaderPixelPsh : public GxResShaderPixel
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_RESOURCE(GxResShaderPixelPsh, GxResShaderPixel)
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResShaderPixelPsh)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxResShaderPixelPsh(void) {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    b32 load(GxStream& stream, u32 size);
 
};
#endif  // GX_DEVELOP
 
#if GX_ENABLE_TESSELLATION
//===========================================================================
//===========================================================================
class GxResShaderHull : public GxResShaderBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_RESOURCE(GxResShaderHull, GxResShaderBase)
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResShaderHull)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxResShaderHull(void) {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE GxRenderHullShader* getHullShader(void) const { return gx_cast<GxRenderHullShader*>(_pRenderShader); }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    b32 createShader(void) override;
 
};
 
#if GX_DEVELOP
//===========================================================================
//===========================================================================
class GxResShaderHullHsh : public GxResShaderHull
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_RESOURCE(GxResShaderHullHsh, GxResShaderHull)
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResShaderHullHsh)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxResShaderHullHsh(void) {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    b32 load(GxStream& stream, u32 size);
 
};
#endif  // GX_DEVELOP
 
//===========================================================================
//===========================================================================
class GxResShaderDomain : public GxResShaderBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_RESOURCE(GxResShaderDomain, GxResShaderBase)
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResShaderDomain)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxResShaderDomain(void) {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE GxRenderDomainShader* getDomainShader(void) const { return gx_cast<GxRenderDomainShader*>(_pRenderShader); }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    b32 createShader(void) override;
 
};
 
#if GX_DEVELOP
//===========================================================================
//===========================================================================
class GxResShaderDomainDsh : public GxResShaderDomain
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_RESOURCE(GxResShaderDomainDsh, GxResShaderDomain)
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResShaderDomainDsh)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxResShaderDomainDsh(void) {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    b32 load(GxStream& stream, u32 size);
 
};
#endif  // GX_DEVELOP
#endif //GX_ENABLE_TESSELLATION
 
#if GX_ENABLE_COMPUTE_SHADER
//===========================================================================
//===========================================================================
class GxResShaderCompute : public GxResShaderBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_RESOURCE(GxResShaderCompute, GxResShaderBase)
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResShaderCompute)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxResShaderCompute(void) {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE GxRenderComputeShader* getComputeShader(void) const { return gx_cast<GxRenderComputeShader*>(_pRenderShader); }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    b32 createShader(void) override;
 
};
 
#if GX_DEVELOP
//===========================================================================
//===========================================================================
class GxResShaderComputeCsh : public GxResShaderCompute
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_RESOURCE(GxResShaderComputeCsh, GxResShaderCompute)
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResShaderComputeCsh)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxResShaderComputeCsh(void) {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    b32 load(GxStream& stream, u32 size);
 
};
#endif  // GX_DEVELOP
#endif  // GX_ENABLE_COMPUTE_SHADER
 
GX_CORE_NAMESPACE_END()