GxShaderPackage.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
class GxRenderVertexShader;
class GxRenderPixelShader;
#if GX_ENABLE_TESSELLATION
class GxRenderHullShader;
class GxRenderDomainShader;
#endif //GX_ENABLE_TESSELLATION
#if GX_ENABLE_COMPUTE_SHADER
class GxRenderComputeShader;
#endif  // GX_ENABLE_COMPUTE_SHADER
 
//===========================================================================
//===========================================================================
class GxShaderPackage : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_CLASS(GxShaderPackage, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxShaderPackage)
 
    friend class GxSysShader;
 
    struct GxShaderCodeHeader
    {
        u32                 _hash;                  
        GxShaderPackage*    _pShaderPackage;        
        u32*                _pPass;                 
        u8*                 _pProgramFunctions;     
        u8*                 _pMaterialFunctions;    
    };
 
    struct GxShaderCode
    {
        //-------------------------------------------------------------
        //-------------------------------------------------------------
 
        static GX_FORCE_INLINE b32  compare(const GxShaderCode* pShaderCode0, const GxShaderCode* pShaderCode1);
        static GX_FORCE_INLINE b32  compareWithOptimizedData( const GxShaderCode* pShaderCode0, const GxShaderCode* pShaderCode1, u32 hash, u8* pCodeBuffer );
 
        static GX_FORCE_INLINE void copy(GxShaderCode* pDst, const GxShaderCode* pSrc);
 
        GX_FORCE_INLINE void update(void);
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
 
        constexpr GxShaderPackage* getShaderPackage(void) const { return _header._pShaderPackage; }
 
        GX_FORCE_INLINE u32         getProgramFunctions(GX_HANDLE handle);
        GX_FORCE_INLINE void        setProgramFunctions(GX_HANDLE handle, u32 value);
        GX_FORCE_INLINE u32         getMaterialFunctions(GX_HANDLE handle);
        GX_FORCE_INLINE void        setMaterialFunctions(GX_HANDLE handle, u32 value);
        GX_FORCE_INLINE void        setPass(u32 pass);
 
        GX_FORCE_INLINE void*       getCodeAddress(void) const;
        GX_FORCE_INLINE const void* getCodeAddressConst(void) const;
        GX_FORCE_INLINE u32         getSize(void) const;
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
 
        GxShaderCodeHeader  _header;                
 
    };
 
protected:  
    struct GxShaderPackageHeader
    {
        u32             _programFunctionsCount;     
        u32             _materialFunctionsCount;    
        u32             _programParameterCount;     
        u32             _materialParameterCount;    
        u32             _functionCount;             
        u32             _passCount;                 
        u32             _shaderCount[static_cast<u32>(RENDER_SHADER::MAX)]; 
        u32             _nodeCount;                 
        u32             _shaderCodeCount;           
        u32             _stringDataSize;            
    };
        
    struct GxShaderInfo
    {
        u32             _shaderAssembledCodeSize;   
        u32             _constantBufferSize;        
        u32             _usageInputSemantics;       
        u32             _registerTableTotal;        
        u32             _registerTableCount[static_cast<s32>(GxRenderShader::REGISTER_SET_TYPE::MAX)];  
        u32             _registerStart[static_cast<s32>(GxRenderShader::REGISTER_SET_TYPE::MAX)];       
        u32             _registerCount[static_cast<s32>(GxRenderShader::REGISTER_SET_TYPE::MAX)];       
    };
 
    static constexpr u32    INVALID_INDEX = 0xFFFFFFFFUL;
    static constexpr u32    CODE_COUNT_IN_NODE = 16;        
 
    struct GxShaderNode
    {
        u32             _shaderCodeIndex[CODE_COUNT_IN_NODE];   
        s32             _shaderIndex[static_cast<u32>(RENDER_SHADER::MAX)][CODE_COUNT_IN_NODE]; 
        u32             _smallIndex;                            
        u32             _largeIndex;                            
    };
 
    struct GxShaderObject
    {
        GxShaderCode*           _pShaderCode;       
        GxRenderShader*         _pShader[static_cast<u32>(RENDER_SHADER::MAX)];     
        u32                     _shaderHash[static_cast<u32>(RENDER_SHADER::MAX)];  
    };
 
    struct GxParameter
    {
        GX_CSTR                                     _name;          
        GX_CSTR                                     _virtualName;   
        GxShaderLanguage::PARAMETER_TYPE            _type;          
        GxShaderLanguage::GxParameterDefaultValue   _defaultValue;  
    };
 
    struct GxParameterFile
    {
        size_t                                      _nameOffset;        
        size_t                                      _virtualNameOffset; 
        GxShaderLanguage::PARAMETER_TYPE            _type;              
        GxShaderLanguage::GxParameterDefaultValue   _defaultValue;      
    };
 
    struct GxFunction
    {
        GX_CSTR             _name;              
        GX_CSTR             _virtualName;       
    };
 
    struct GxFunctionFile
    {
        size_t              _nameOffset;        
        size_t              _virtualNameOffset; 
    };
 
    struct GxFunctions
    {
        GX_CSTR             _name;              
        GX_CSTR             _virtualName;       
        GxFunction*         _pFunction;         
        u32                 _functionCount;     
    };
 
    struct GxFunctionsFile
    {
        size_t              _nameOffset;        
        size_t              _virtualNameOffset; 
        size_t              _functionIndex;     
        u32                 _functionCount;     
    };
 
#if GX_DEVELOP
    enum class CONFIG_FILE_FORMAT
    {
        BINARY,         
        SINGLE_TEXT,    
        XML,            
        UNKNOWN,        
        NOT_FOUND,      
    };
#endif //GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxShaderPackage(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
#if GX_DEVELOP
    b32             initialize(GX_CSTR shaderSource, const GxCallback::GxHandlerBase& includeCallbackHandler, const GxCallback::GxHandlerBase& saveResourceCallbackHandler, b32 isOriginalResource, class GxResShaderPackage* pResShaderPackage = nullptr, GX_CSTR shaderPath = nullptr);
#endif  // GX_DEVELOP
    b32             initialize(void);
    
    void            terminate(void);
 
    GxShaderCode*   allocateShaderCode(void);
    
    void            freeShaderCode(GxShaderCode* pShaderCode);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE void            setPropertyVertexShaderCount(const void* const /*pValue*/) {}
    GX_FORCE_INLINE void            getPropertyVertexShaderCount(void* const pValue) { *static_cast<u32*>(pValue) = _header._shaderCount[static_cast<u32>(RENDER_SHADER::VERTEX)]; }
 
    GX_FORCE_INLINE void            setPropertyPixelShaderCount(const void* const /*pValue*/) {}
    GX_FORCE_INLINE void            getPropertyPixelShaderCount(void* const pValue) { *static_cast<u32*>(pValue) = _header._shaderCount[static_cast<u32>(RENDER_SHADER::PIXEL)]; }
 
#if GX_ENABLE_TESSELLATION
    GX_FORCE_INLINE void            setPropertyHullShaderCount(const void* const /*pValue*/) {}
    GX_FORCE_INLINE void            getPropertyHullShaderCount(void* const pValue) { *static_cast<u32*>(pValue) = _header._shaderCount[static_cast<u32>(RENDER_SHADER::HULL)]; }
 
    GX_FORCE_INLINE void            setPropertyDomainShaderCount(const void* const /*pValue*/) {}
    GX_FORCE_INLINE void            getPropertyDomainShaderCount(void* const pValue) { *static_cast<u32*>(pValue) = _header._shaderCount[static_cast<u32>(RENDER_SHADER::DOMAIN_)]; }
#endif //GX_ENABLE_TESSELLATION
 
#if GX_ENABLE_COMPUTE_SHADER
    GX_FORCE_INLINE void            setPropertyComputeShaderCount(const void* const /*pValue*/) {}
    GX_FORCE_INLINE void            getPropertyComputeShaderCount(void* const pValue) { *static_cast<u32*>(pValue) = _header._shaderCount[static_cast<u32>(RENDER_SHADER::COMPUTE)]; }
#endif //GX_ENABLE_COMPUTE_SHADER
 
    GX_FORCE_INLINE void            setPropertyProgramFunctionsCount(const void* const /*pValue*/) {}
    GX_FORCE_INLINE void            getPropertyProgramFunctionsCount(void* const pValue) { *static_cast<u32*>(pValue) = getProgramFunctionsCount(); }
 
    GX_FORCE_INLINE void            setPropertyMaterialFunctionsCount(const void* const /*pValue*/) {}
    GX_FORCE_INLINE void            getPropertyMaterialFunctionsCount(void* const pValue) { *static_cast<u32*>(pValue) = getMaterialFunctionsCount(); }
 
    GX_FORCE_INLINE void            setPropertyProgramParameterCount(const void* const /*pValue*/) {}
    GX_FORCE_INLINE void            getPropertyProgramParameterCount(void* const pValue) { *static_cast<u32*>(pValue) = getProgramParameterCount(); }
 
    GX_FORCE_INLINE void            setPropertyMaterialParameterCount(const void* const /*pValue*/) {}
    GX_FORCE_INLINE void            getPropertyMaterialParameterCount(void* const pValue) { *static_cast<u32*>(pValue) = getMaterialParameterCount(); }
 
    GxRenderVertexShader*   getVertexShader(GxShaderCode* pShaderCode);
    GxRenderPixelShader*    getPixelShader(GxShaderCode* pShaderCode);
#if GX_ENABLE_TESSELLATION
    GxRenderHullShader*     getHullShader(GxShaderCode* pShaderCode);
    GxRenderDomainShader*   getDomainShader(GxShaderCode* pShaderCode);
    b32                     getShader(GxShaderCode* pShaderCode, GxRenderVertexShader*& pVertexShader, GxRenderPixelShader*& pPixelShader, GxRenderHullShader*& pHullShader, GxRenderDomainShader*& pDomainShader);
#else //GX_ENABLE_TESSELLATION
    b32                     getShader(GxShaderCode* pShaderCode, GxRenderVertexShader*& pVertexShader, GxRenderPixelShader*& pPixelShader);
#endif // !GX_ENABLE_TESSELLATION
#if GX_ENABLE_COMPUTE_SHADER
    b32                     getComputeShader(GxShaderCode* pShaderCode, GxRenderComputeShader*& pComputeShader);
#endif  // GX_ENABLE_COMPUTE_SHADER
    u32                     getOptimizedShaderCodeHash( GxShaderCode* pShaderCode, u8* pCodeBuffer );
    GxShaderCode*           getOptimizedShaderCode( GxShaderCode* pShaderCode );
 
    constexpr u32           getProgramFunctionsCount(void) const { return _header._programFunctionsCount; }
    constexpr u32           getMaterialFunctionsCount(void) const { return _header._materialFunctionsCount; }
 
    constexpr u32           getProgramParameterCount(void) const { return _header._programParameterCount; }
    constexpr u32           getMaterialParameterCount(void) const { return _header._materialParameterCount; }
 
    constexpr u32           getPassCount(void) const { return _header._passCount; }
 
    GX_HANDLE               getProgramFunctionsHandleByName(GX_CSTR name) const;
    GX_HANDLE               getMaterialFunctionsHandleByName(GX_CSTR name) const;
 
    GX_HANDLE               getProgramFunctionsHandleByVirtualName(GX_CSTR name) const;
    GX_HANDLE               getMaterialFunctionsHandleByVirtualName(GX_CSTR name) const;
 
    GX_FORCE_INLINE GX_CSTR getProgramFunctionsName(GX_HANDLE handle) const;
    GX_FORCE_INLINE GX_CSTR getMaterialFunctionsName(GX_HANDLE handle) const;
 
    GX_FORCE_INLINE GX_CSTR getProgramFunctionsVirtualName(GX_HANDLE handle) const;
    GX_FORCE_INLINE GX_CSTR getMaterialFunctionsVirtualName(GX_HANDLE handle) const;
 
    GX_FORCE_INLINE GX_CSTR getProgramFunctionsValueName(GX_HANDLE handle, u32 value) const;
    GX_FORCE_INLINE GX_CSTR getMaterialFunctionsValueName(GX_HANDLE handle, u32 value) const;
 
    GX_FORCE_INLINE GX_CSTR getProgramFunctionsValueVirtualName(GX_HANDLE handle, u32 value) const;
    GX_FORCE_INLINE GX_CSTR getMaterialFunctionsValueVirtualName(GX_HANDLE handle, u32 value) const;
 
    u32                     getProgramFunctionsValueByName(GX_HANDLE handle, GX_CSTR name) const;
    u32                     getMaterialFunctionsValueByName(GX_HANDLE handle, GX_CSTR name) const;
 
    u32                     getProgramFunctionsValueByVirtualName(GX_HANDLE handle, GX_CSTR name) const;
    u32                     getMaterialFunctionsValueByVirtualName(GX_HANDLE handle, GX_CSTR name) const;
 
#if GX_DEVELOP
    GX_FORCE_INLINE const GX_ENUM*  getProgramFunctionsValueGxEnum(GX_HANDLE handle) const { return _compiler.getProgramFunctionsValueGxEnum(handle); }
    GX_FORCE_INLINE const GX_ENUM*  getMaterialFunctionsValueGxEnum(GX_HANDLE handle) const { return _compiler.getMaterialFunctionsValueGxEnum(handle); }
#endif //GX_DEVELOP
 
    GX_FORCE_INLINE u32     getProgramFunctionsValueCount(GX_HANDLE handle) const;
    GX_FORCE_INLINE u32     getMaterialFunctionsValueCount(GX_HANDLE handle) const;
 
    GX_HANDLE               getProgramParameterHandleByName(GX_CSTR name) const;
    GX_HANDLE               getMaterialParameterHandleByName(GX_CSTR name) const;
 
    GX_HANDLE               getProgramParameterHandleByVirtualName(GX_CSTR name) const;
    GX_HANDLE               getMaterialParameterHandleByVirtualName(GX_CSTR name) const;
 
    GX_FORCE_INLINE GX_CSTR getProgramParameterName(GX_HANDLE handle) const;
    GX_FORCE_INLINE GX_CSTR getMaterialParameterName(GX_HANDLE handle) const;
 
    GX_FORCE_INLINE GX_CSTR getProgramParameterVirtualName(GX_HANDLE handle) const;
    GX_FORCE_INLINE GX_CSTR getMaterialParameterVirtualName(GX_HANDLE handle) const;
 
    GX_FORCE_INLINE GxShaderLanguage::PARAMETER_TYPE getProgramParameterType(GX_HANDLE handle) const;
    GX_FORCE_INLINE GxShaderLanguage::PARAMETER_TYPE getMaterialParameterType(GX_HANDLE handle) const;
 
    GX_FORCE_INLINE const GxShaderLanguage::GxParameterDefaultValue& getMaterialParameterDefaultValue(GX_HANDLE handle) const;
 
#if GX_DEVELOP
    GX_FORCE_INLINE GxShaderLanguage::GxParameterAnnotation getMaterialParameterAnnotation(GX_HANDLE handle) const { return _compiler.getMaterialParameterAnnotation(handle); }
 
    GX_FORCE_INLINE const GxShaderLanguage& GetShaderLanguage(void){ return _compiler;}
#endif //GX_DEVELOP
 
    void setUseOptimizedShaderVariation( b32 isUse );
    void setOptimizedProgramFunctionsBits( u32 pass, u8* pBits );
    void setOptimizedMaterialFunctionsBits( u32 pass, u8* pBits );
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    b32 load(GxStream& stream);
#if GX_DEVELOP
    b32 save(GxStream& stream);
    b32 saveResource(void);
    b32 loadConfig(GxStream& stream);
    b32 saveConfig(GxStream& streama);
    CONFIG_FILE_FORMAT checkConfigVersion(GxStream& stream);
    static constexpr CONFIG_FILE_FORMAT CONFIG_SAVE_FORMAT = CONFIG_FILE_FORMAT::BINARY;
    b32 loadConfigBinary(GxStream& stream);
    b32 loadConfigSingleText(GxStream& stream);
    b32 loadConfigXml(GxStream& stream);
    b32 saveConfigBinary(GxStream& stream);
    b32 saveConfigSingleText(GxStream& stream);
    b32 saveConfigXml(GxStream& stream);
#endif  // GX_DEVELOP
 
protected:
    GxShaderNode*       searchNode(GxShaderCode* pShaderCode);
    GxShaderNode*       searchNode(u32 hash);
 
    GxShaderNode*       addNode(GxShaderCode* pShaderCode);
 
    u32                 addShaderCode(GxShaderCode* pShaderCode);
 
    GxShaderCode*       getShaderCodeFromIndex(u32 index) { return static_cast<GxShaderCode*>(GX_POINTER_ADD(_pShaderCodeBuffer, index * _shaderCodeSize)); }
 
#if GX_DEVELOP
    GxShaderObject      createShader(GxShaderCode* pShaderCode);
    GxShaderObject      createShader(GxShaderCode* pShaderCode, GxShaderLanguage& language);
    b32                 addShader(GxShaderObject& shaderObject);
    void                createVertexShader(GxShaderCompiler& shaderCompiler, u32 outputSemantics, GxRenderVertexShader** ppOutVertexShader, u32* pOutVertexShaderHash, GxShaderLanguage& language);
    void                createPixelShader(GxShaderCompiler& shaderCompiler, GxRenderPixelShader** ppOutPixelShader, u32* pOutPixelShaderHash, GxShaderLanguage& language);
#if GX_ENABLE_TESSELLATION
    void                createHullShader(GxShaderCompiler& shaderCompiler, u32 outputSemantics, GxRenderHullShader** ppOutVertexShader, u32* pOutHullShaderHash, GxShaderLanguage& language);
    void                createDomainShader(GxShaderCompiler& shaderCompiler, u32 outputSemantics, GxRenderDomainShader** ppOutDomainShader, u32* pOutDomainShaderHash, GxShaderLanguage& language);
#endif //GX_ENABLE_TESSELLATION
#if GX_ENABLE_COMPUTE_SHADER
    void                createComputeShader(GxShaderCompiler& shaderCompiler, u32 outputSemantics, GxRenderComputeShader** ppOutComputeShader, u32* pOutComputeShaderHash, GxShaderLanguage& language);
#endif  // GX_ENABLE_COMPUTE_SHADER
    s32                 findShaderByBinaryCode(void* pBinaryCode, u32 size, const GxArray& hashArray, const GxArrayClassBaseReference& shaderArray);
    s32                 findShader(GxRenderShader* pShaderNew, const GxArray& hashArray, const GxArrayClassBaseReference& shaderArray);
    b32                 setConstantRegisterTableFromCompiler(const GxShaderCompiler& shaderCompiler, GxRenderShader* pRenderShader);
#endif //GX_DEVELOP
 
    void                setConstantRegisterSetInformation(GxRenderShader::GxRegisterSet* pConstantRegisterSet, void* pConstantRegisterParameterTable, const GxShaderInfo& shaderInfo);
 
#if GX_DEVELOP
    void                setConstantRegisterParameterInformation(void* pConstantRegisterParameterTable, const GxShaderCompiler& shaderCompiler);
#endif //GX_DEVELOP
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxShaderPackageHeader           _header;                            
    GxShaderNode*                   _pNode;                             
    u32                             _nodeAllocateCount;                 
    void*                           _pStringData;                       
    void*                           _pShaderCodeBuffer;                 
    u32                             _shaderCodeAllocateCount;           
    u32                             _shaderCodeSize;                    
    GxArrayClassBaseReference       _shaderArray[static_cast<u32>(RENDER_SHADER::MAX)];     
    GxArray                         _shaderHashArray[static_cast<u32>(RENDER_SHADER::MAX)]; 
    void*                           _pParameterFunctionBuffer;          
    GxParameter*                    _pProgramParameter;                 
    GxFunctions*                    _pProgramFunctions;                 
    GxParameter*                    _pMaterialParameter;                
    GxFunctions*                    _pMaterialFunctions;                
    GxFunction*                     _pFunction;                         
    b32                             _enableRuntimeCompile;              
    GxCriticalSection               _criticalSection;                   
 
#if GX_DEVELOP
    GxShaderLanguage                _compiler;                          
    GxCallback::GxHandlerBase       _saveResourceCallbackHandler;       
    GxResShaderPackage*             _pResShaderPackage;                 
#endif  // GX_DEVELOP
 
    b32                             _isUseOptimizedShaderVariation;                                         
    u8*                             _pOptimizedProgramFunctionsBits[static_cast<s32>(RENDER_PASS::MAX)];    
    u8*                             _pOptimizedMaterialFunctionsBits[static_cast<s32>(RENDER_PASS::MAX)];   
 
};
 
#define GX_SAFE_FREE_SHADER_CODE(pShaderCode)                           \
    if( pShaderCode )                                                   \
    {                                                                   \
        pShaderCode->getShaderPackage()->freeShaderCode(pShaderCode);   \
        pShaderCode = nullptr;                                          \
    }
 
//---------------------------------------------------------------------------
// 比較
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxShaderPackage::GxShaderCode::compare(const GxShaderPackage::GxShaderCode* pShaderCode0, const GxShaderPackage::GxShaderCode* pShaderCode1)
{
    if (pShaderCode0->_header._pShaderPackage != pShaderCode1->_header._pShaderPackage)
    {
        return false;
    }
    else if (pShaderCode0->_header._hash != pShaderCode1->_header._hash)
    {
        return false;
    }
    else if (GX_MEMCMP(pShaderCode0->getCodeAddressConst(), pShaderCode1->getCodeAddressConst(), pShaderCode0->getSize()) != 0)
    {
        return false;
    }
    return true;
}
 
//---------------------------------------------------------------------------
// 比較
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxShaderPackage::GxShaderCode::compareWithOptimizedData( const GxShaderPackage::GxShaderCode* pShaderCode0, const GxShaderPackage::GxShaderCode* pShaderCode1, u32 hash, u8* pCodeBuffer )
{
    if (pShaderCode0->_header._pShaderPackage != pShaderCode1->_header._pShaderPackage)
    {
        return false;
    }
    else if (hash != pShaderCode1->_header._hash)
    {
        return false;
    }
    else if (GX_MEMCMP(pCodeBuffer, pShaderCode1->getCodeAddressConst(), pShaderCode0->getSize()) != 0)
    {
        return false;
    }
    return true;
}
 
//---------------------------------------------------------------------------
// コピー
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxShaderPackage::GxShaderCode::copy(GxShaderPackage::GxShaderCode* pDst, const GxShaderPackage::GxShaderCode* pSrc)
{
    GX_MEMCPY(pDst->getCodeAddress(), pSrc->getCodeAddressConst(), pSrc->getSize());
 
    pDst->update();
}
 
//---------------------------------------------------------------------------
// シェーダコードアップデート
//---------------------------------------------------------------------------
void GxShaderPackage::GxShaderCode::update(void)
{
    _header._hash = GxMath::getHash32(getCodeAddress(), getSize());
}
 
//---------------------------------------------------------------------------
// プログラムで設定する関数の取得
//---------------------------------------------------------------------------
u32 GxShaderPackage::GxShaderCode::getProgramFunctions(GX_HANDLE handle)
{
    if( _header._pShaderPackage->getProgramFunctionsCount() <= handle )
    {
        GX_ERROR(false, "未定義の program functions handle");
        return 0;
    }
    return _header._pProgramFunctions[handle];
}
 
//---------------------------------------------------------------------------
// プログラムで設定する関数の設定
//
//---------------------------------------------------------------------------
void GxShaderPackage::GxShaderCode::setProgramFunctions(GX_HANDLE handle, u32 value)
{
    if( _header._pShaderPackage->getProgramFunctionsCount() <= handle )
    {
        GX_ERROR(false, "未定義の program functions handle");
        return;
    }
#if GX_DEVELOP
    else if( _header._pShaderPackage->getProgramFunctionsValueCount(handle) <= value )
    {
        GX_ERROR(false, "未定義の program functions value");
        return;
    }
#endif //GX_DEVELOP
    _header._pProgramFunctions[handle] = static_cast<u8>(value);
}
 
//---------------------------------------------------------------------------
// マテリアルで設定する関数の取得
//---------------------------------------------------------------------------
u32 GxShaderPackage::GxShaderCode::getMaterialFunctions(GX_HANDLE handle)
{
    if( _header._pShaderPackage->getMaterialFunctionsCount() <= handle )
    {
        GX_ERROR(false, "未定義の material functions handle");
        return 0;
    }
    return _header._pMaterialFunctions[handle];
}
 
//---------------------------------------------------------------------------
// マテリアルで設定する関数の設定
//
//---------------------------------------------------------------------------
void GxShaderPackage::GxShaderCode::setMaterialFunctions(GX_HANDLE handle, u32 value)
{
    if( _header._pShaderPackage->getMaterialFunctionsCount() <= handle )
    {
        GX_ERROR(false, "未定義の material functions handle");
        return;
    }
#if GX_DEVELOP
    else if( _header._pShaderPackage->getMaterialFunctionsValueCount(handle) <= value )
    {
        GX_ERROR(false, "未定義の material functions value");
        return;
    }
#endif //GX_DEVELOP
    _header._pMaterialFunctions[handle] = static_cast<u8>(value);
}
 
//---------------------------------------------------------------------------
// パスの設定
//
//---------------------------------------------------------------------------
void GxShaderPackage::GxShaderCode::setPass(u32 pass)
{
    if( _header._pShaderPackage->getPassCount() <= pass )
    {
        GX_ERROR(false, "未定義のパス");
    }
    else
    {
        *(_header._pPass) = pass;
    }
}
 
//---------------------------------------------------------------------------
// シェーダコード本体のアドレスを取得
//---------------------------------------------------------------------------
void* GxShaderPackage::GxShaderCode::getCodeAddress(void) const
{
    return GX_POINTER_ADD(this, sizeof(GxShaderCode));
}
 
//---------------------------------------------------------------------------
// シェーダコード本体のアドレスを取得(const)
//---------------------------------------------------------------------------
const void* GxShaderPackage::GxShaderCode::getCodeAddressConst(void) const
{
    return getCodeAddress();
}
 
//---------------------------------------------------------------------------
// ヘッダを除くサイズを取得
//---------------------------------------------------------------------------
u32 GxShaderPackage::GxShaderCode::getSize(void) const
{
    return sizeof(u32)
            + GxMath::getRoundUpFast(_header._pShaderPackage->getProgramFunctionsCount()  * static_cast<u32>(sizeof(u8)), GxMath::VALUE_4)
            + GxMath::getRoundUpFast(_header._pShaderPackage->getMaterialFunctionsCount() * static_cast<u32>(sizeof(u8)), GxMath::VALUE_4);
}
 
//---------------------------------------------------------------------------
// プログラムで設定する関数の名前を取得
//---------------------------------------------------------------------------
GX_CSTR GxShaderPackage::getProgramFunctionsName(GX_HANDLE handle) const
{
    if( _header._programFunctionsCount <= handle )
    {
        GX_ERROR(false, "未定義の program functions handle");
        return nullptr;
    }
 
    return _pProgramFunctions[handle]._name;
}
 
//---------------------------------------------------------------------------
// マテリアルで設定する関数の名前を取得
//---------------------------------------------------------------------------
GX_CSTR GxShaderPackage::getMaterialFunctionsName(GX_HANDLE handle) const
{
    if( _header._materialFunctionsCount <= handle )
    {
        GX_ERROR(false, "未定義の material functions handle");
        return nullptr;
    }
 
    return _pMaterialFunctions[handle]._name;
}
 
//---------------------------------------------------------------------------
// プログラムで設定する関数の仮想名を取得
//---------------------------------------------------------------------------
GX_CSTR GxShaderPackage::getProgramFunctionsVirtualName(GX_HANDLE handle) const
{
    if( _header._programFunctionsCount <= handle )
    {
        GX_ERROR(false, "未定義の program functions handle");
        return nullptr;
    }
 
    return _pProgramFunctions[handle]._virtualName;
}
 
//---------------------------------------------------------------------------
// マテリアルで設定する関数の仮想名を取得
//---------------------------------------------------------------------------
GX_CSTR GxShaderPackage::getMaterialFunctionsVirtualName(GX_HANDLE handle) const
{
    if( _header._materialFunctionsCount <= handle )
    {
        GX_ERROR(false, "未定義の material functions handle");
        return nullptr;
    }
 
    return _pMaterialFunctions[handle]._virtualName;
}
 
//---------------------------------------------------------------------------
// プログラムで設定する関数の値の名前を取得
//---------------------------------------------------------------------------
GX_CSTR GxShaderPackage::getProgramFunctionsValueName(GX_HANDLE handle, u32 value) const
{
    if( _header._programFunctionsCount <= handle )
    {
        GX_ERROR(false, "未定義の program functions handle");
        return nullptr;
    }
    else if( _pProgramFunctions[handle]._functionCount <= value )
    {
        GX_ERROR(false, "未定義の program functions value");
        return nullptr;
    }
 
    return _pProgramFunctions[handle]._pFunction[value]._name;
}
 
//---------------------------------------------------------------------------
// マテリアルで設定する関数の値の名前を取得
//---------------------------------------------------------------------------
GX_CSTR GxShaderPackage::getMaterialFunctionsValueName(GX_HANDLE handle, u32 value) const
{
    if( _header._materialFunctionsCount <= handle )
    {
        GX_ERROR(false, "未定義の material functions handle");
        return nullptr;
    }
    else if( _pMaterialFunctions[handle]._functionCount <= value )
    {
        GX_ERROR(false, "未定義の material functions value");
        return nullptr;
    }
 
    return _pMaterialFunctions[handle]._pFunction[value]._name;
}
 
//---------------------------------------------------------------------------
// プログラムで設定する関数の値の仮想名を取得
//---------------------------------------------------------------------------
GX_CSTR GxShaderPackage::getProgramFunctionsValueVirtualName(GX_HANDLE handle, u32 value) const
{
    if( _header._programFunctionsCount <= handle )
    {
        GX_ERROR(false, "未定義の program functions handle");
        return nullptr;
    }
    else if( _pProgramFunctions[handle]._functionCount <= value )
    {
        GX_ERROR(false, "未定義の program functions value");
        return nullptr;
    }
 
    return _pProgramFunctions[handle]._pFunction[value]._virtualName;
}
 
//---------------------------------------------------------------------------
// マテリアルで設定する関数の値の仮想名を取得
//---------------------------------------------------------------------------
GX_CSTR GxShaderPackage::getMaterialFunctionsValueVirtualName(GX_HANDLE handle, u32 value) const
{
    if( _header._materialFunctionsCount <= handle )
    {
        GX_ERROR(false, "未定義の material functions handle");
        return nullptr;
    }
 
    return _pMaterialFunctions[handle]._pFunction[value]._virtualName;
}
 
//---------------------------------------------------------------------------
// プログラムで設定する関数の値数を取得
//---------------------------------------------------------------------------
u32 GxShaderPackage::getProgramFunctionsValueCount(GX_HANDLE handle) const
{
    if( _header._programFunctionsCount <= handle )
    {
        GX_ERROR(false, "未定義の program functions handle");
        return 0;
    }
 
    return _pProgramFunctions[handle]._functionCount;
}
 
//---------------------------------------------------------------------------
// マテリアルで設定する関数の値数を取得
//---------------------------------------------------------------------------
u32 GxShaderPackage::getMaterialFunctionsValueCount(GX_HANDLE handle) const
{
    if( _header._materialFunctionsCount <= handle )
    {
        GX_ERROR(false, "未定義の material functions handle");
        return 0;
    }
 
    return _pMaterialFunctions[handle]._functionCount;
}
 
//---------------------------------------------------------------------------
// プログラムで設定するパラメータの名前を取得
//---------------------------------------------------------------------------
GX_CSTR GxShaderPackage::getProgramParameterName(GX_HANDLE handle) const
{
    if( _header._programParameterCount <= handle )
    {
        GX_ERROR(false, "未定義の program parameter handle");
        return nullptr;
    }
 
    return _pProgramParameter[handle]._name;
}
 
//---------------------------------------------------------------------------
// マテリアルで設定するパラメータの名前を取得
//---------------------------------------------------------------------------
GX_CSTR GxShaderPackage::getMaterialParameterName(GX_HANDLE handle) const
{
    if( _header._materialParameterCount <= handle )
    {
        GX_ERROR(false, "未定義の material parameter handle");
        return nullptr;
    }
 
    return _pMaterialParameter[handle]._name;
}
 
//---------------------------------------------------------------------------
// プログラムで設定するパラメータの仮想名を取得
//---------------------------------------------------------------------------
GX_CSTR GxShaderPackage::getProgramParameterVirtualName(GX_HANDLE handle) const
{
    if( _header._programParameterCount <= handle )
    {
        GX_ERROR(false, "未定義の program parameter handle");
        return nullptr;
    }
 
    return _pProgramParameter[handle]._virtualName;
}
 
//---------------------------------------------------------------------------
// マテリアルで設定するパラメータの仮想名を取得
//---------------------------------------------------------------------------
GX_CSTR GxShaderPackage::getMaterialParameterVirtualName(GX_HANDLE handle) const
{
    if( _header._materialParameterCount <= handle )
    {
        GX_ERROR(false, "未定義の material parameter handle");
        return nullptr;
    }
 
    return _pMaterialParameter[handle]._virtualName;
}
 
//---------------------------------------------------------------------------
// プログラムで設定するパラメータのタイプを取得
//---------------------------------------------------------------------------
GxShaderLanguage::PARAMETER_TYPE GxShaderPackage::getProgramParameterType(GX_HANDLE handle) const
{
    if (_header._programParameterCount <= handle)
    {
        GX_ERROR(false, "未定義の program parameter handle");
        return GxShaderLanguage::PARAMETER_TYPE::FLOAT4;
    }
 
    return _pProgramParameter[handle]._type;
}
 
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
GxShaderLanguage::PARAMETER_TYPE GxShaderPackage::getMaterialParameterType(GX_HANDLE handle) const
{
    if (_header._materialParameterCount <= handle)
    {
        GX_ERROR(false, "未定義の material parameter handle");
        return GxShaderLanguage::PARAMETER_TYPE::FLOAT4;
    }
 
    return _pMaterialParameter[handle]._type;
}
 
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
const GxShaderLanguage::GxParameterDefaultValue& GxShaderPackage::getMaterialParameterDefaultValue(GX_HANDLE handle) const
{
    if (_header._materialParameterCount <= handle)
    {
        GX_ERROR(false, "未定義の material parameter handle");
        static auto defaultValue = GxShaderLanguage::GxParameterDefaultValue();
        return defaultValue;
    }
 
    return _pMaterialParameter[handle]._defaultValue;
}
 
GX_CORE_NAMESPACE_END()