GxUnitModelBase.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
class GxUnitCameraBase;
//===========================================================================
//===========================================================================
class GxUnitModelBase : public GxUnitLocate
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_CLASS_NAME_ICON(GxUnitModelBase, GxUnitLocate, "モデル基礎", GxRtti::ICON_TYPE::MESH)
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::UNIT)
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxUnitModelBase)
 
    struct GxJoint;
 
#if GX_DEVELOP
    struct GxRenderShaderDevInfo;
#endif // GX_DEVELOP
 
    enum class PASSINFO
    {
        NORMAL = 0,         
        SHADOW,             
        POINTSHADOW,        
        PREZ,               
        MOTIONBLUR,         
        ENV,                
        POLYGONLINE,        
        MAX,                
    };
    
    enum class MODEL_ATTRIBUTE
    {
        MESH_CULLING_ENABLE,                
        MESH_SHADOW_CULLING_ENABLE,         
        MESH_ENVIRONMENT_CULLING_ENABLE,    
        ORTHO_RENDER,                       
        MAX,                                
    };
 
#if GX_DEVELOP
    GX_FLAG_TABLE_MAX(MODEL_ATTRIBUTE)
 
    
    enum class DEVELOP_FLAG
    {
        SHOW_MODEL,                     
        SHOW_JOINT_DETAIL,              
        SHOW_JOINT_LINE,                
        SHOW_JOINT_NAME,                
        SHOW_JOINT_INDEX,               
        SHOW_JOINT_MATRIX,              
        SHOW_MESH_BOUNDING_BOX,         
        SHOW_MESH_VERTEX_NORMAL,        
        SHOW_MESH_VERTEX_TBN,           
        JOINT_HANDLE_CONTROL,           
        SHOW_SPECIFIED_JOINT_MATRIX,    
        BLINK_SPECIFIED_MATERIAL,       
        BLINK_SPECIFIED_MESH,           
        SHOW_BOUNDING_SPHERE,           
        UPDATE_RENDER_SHADER_DEVELOP_INFO,  
        DRAW_JOINT_OVERLAY,             
        MAX,                            
    };
    GX_FLAG_TABLE_MAX(DEVELOP_FLAG)
#endif // GX_DEVELOP
 
protected:
    struct GxInstanceData
    {
        GxVector3                   _position;          
        GxQuaternion                _quaternion;        
        GxVector3                   _scale;             
        GxMatrixAffine              _offsetMatrix;      
        GxMatrixAffine              _matrix;            
#if GX_DEVELOP
        GxMatrixAffine              _parentMatrix;      
#endif  // GX_DEVELOP
        void updateMatrix(void);                        
        void clear(void);                               
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxUnitModelBase(void);
 
    void cleanup(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    void buildSpaceGraph(void* pOctree) override;
    void eraseSpaceGraph(void* pOctree) override;
 
    void frustumCulling( void* pFrustum ) override;
    void forceSetCullingFlag( u32 argument ) override;
 
    b32 frustumCullingMesh( GxShapeFrustum* pFrustum , RENDER_VIEW view, CULLING_FRUSTUM frustumType);
    b32 frustumCullingInstance( GxShapeFrustum* pFrustum , RENDER_VIEW view, CULLING_FRUSTUM frustumType);
    b32 setRenderShaderWithInfo(GxShaderPackage::GxShaderCode* pShaderCode, const GxRenderMaterial* pMaterial, PASSINFO index);
 
    b32 setup(void) override;
    void preAsyncUpdate(void) override;
    void forceAsyncUpdate(void) override;
    void render(void) override;
 
public:
    void updateLocalMatrix(void) override;
    void updateWorldMatrix(void) override;
 
#if GX_DEVELOP
    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index);
    void setResource(GxResBase* pResource) override;
 
    b32 isUseTexture( GxRenderTexture* pTexture ) override;
 
protected:
    void developRender(void) override;
 
    void developRenderJointHandle(void);
#endif //GX_DEVELOP
 
public:
    virtual b32                     setModelResource(GxResModel* pResModel);
    GX_FORCE_INLINE virtual GxResModel* getModelResource(void) const { return _pResModel; }
    constexpr GxResMaterial*        getMaterialResource(u32 index = 0) { return _ppResMaterial ? _ppResMaterial[index] : nullptr; }
    void                            setMaterialResource(u32 index, GxResMaterial* pResMaterial);
    void                            setMaterialResourceAll(void);
 
public:
    virtual b32                     recoveryMaterial(void);
    void                            writeBackMaterial(void);
 
    GX_FORCE_INLINE void* mapPartsIndexBuffer(u32 index, u32 mappingType) { GX_ASSERT(_pResModel, "モデルリソースが設定されていません"); return _pResModel->mapPartsIndexBuffer(index, mappingType); }
    GX_FORCE_INLINE void            unmapPartsIndexBuffer(u32 index) { GX_ASSERT(_pResModel, "モデルリソースが設定されていません"); return _pResModel->unmapPartsIndexBuffer(index); }
 
    b32                             copyMaterial(void);
protected:
    void                            setJointCount(u32 count);
    virtual void                    setRenderMatrixCount(u32 count);
    void                            setJointMultiplyMatrixCount(u32 count);
    void                            setPartsFlagCount(u32 count);
    void                            setPartsMatrix(u32 count);
    void                            setMeshCullingFlagCount(u32 count);
    void                            setMeshRenderFlagCount(u32 count);
#if GX_ENABLE_OCCLUSION_CULLING
    void                            setOcclusionQueryIndexCount(u32 count);
#endif //GX_ENABLE_OCCLUSION_CULLING
 
    virtual b32                     renderInitialize(RENDER_VIEW view, RENDER_SUB_VIEW subView);
    virtual void                    renderMeshGroupAll(void);
    virtual void                    renderMeshGroup(const GxResModel::GxMeshGroup* pMeshGroup);
    virtual void                    renderMesh(u32 startIndex, u32 count, const GxRenderMaterial* pMaterial, u32 instanceStartIndex, u32 instanceCount);
    virtual void                    drawIndexed(u32 startIndex, u32 count, u32 instanceStartIndex, u32 instanceCount, RENDER_PRIMITIVE_TYPE primitiveType = RENDER_PRIMITIVE_TYPE::TRIANGLE_LIST, s32* pQueryIndex = nullptr);
 
    virtual b32                     setRenderProjectionMatrix(void);
    b32                             setRenderMaterial(GxRenderMaterial* pMaterial, const GxResModel::GxMeshGroup* pMeshGroup) override;
    b32                             setRenderGxSLMaterial(GxRenderMaterial* pMaterial);
    virtual b32                     setRenderPass(const GxRenderMaterial* pMaterial);
    virtual b32                     setRenderState(const GxRenderMaterial* pMaterial);
#if GX_ENABLE_TESSELLATION
    b32                             setRenderShader(GxShaderPackage::GxShaderCode* pShaderCode, u32* pRenderVertexShaderSize = nullptr, u32* pRenderPixelShaderSize = nullptr, u32* pRenderHullShaderSize = nullptr, u32* pRenderDomainShaderSize = nullptr);
#else //GX_ENABLE_TESSELLATION
    b32                             setRenderShader(GxShaderPackage::GxShaderCode* pShaderCode, u32* pRenderVertexShaderSize = nullptr, u32* pRenderPixelShaderSize = nullptr);
#endif // !GX_ENABLE_TESSELLATION
#if GX_ENABLE_COMPUTE_SHADER
    b32                             setComputeShader(GxShaderPackage::GxShaderCode* pShaderCode);
#endif  // GX_ENABLE_COMPUTE_SHADER
    virtual void                    updateRenderMatrix(void);
    virtual void                    updateInstanceRenderMatrix(RENDER_VIEW view, RENDER_SUB_VIEW subView);
 
    virtual void                    updateShowLod(const GxUnitCameraBase* pCamera);
 
    virtual void                    updateMeshRenderFlag(RENDER_VIEW view, CULLING_FRUSTUM renderSubView);
    virtual void                    updateInstanceCullingFlag(const GxUnitCameraBase* pCamera, RENDER_VIEW view, CULLING_FRUSTUM frustumType);
 
    void                            setCullingAllMeshs(void);
    void                            clearMeshCullingFlag(const RENDER_VIEW& view, const CULLING_FRUSTUM& frustumType);
 
    GX_FORCE_INLINE void            clearMeshRenderFlag(void) { return GxFlag32Array::clear(_pMeshRenderFlag, getMeshRenderFlagCount()); }
 
    void                            setCullingAllInstances(RENDER_VIEW view, CULLING_FRUSTUM pass);
    void                            clearInstanceCullingFlag(RENDER_VIEW view, CULLING_FRUSTUM pass);
 
    static s32                      commitVertexBufferData(void* pSource, void* pArgument);
 
    void                            loadShaderHandlesBase(void);
private:
    void                            setJointId(u32 jointIndex, GX_CSTR name);
 
#if GX_DEVELOP
public:
    void                            saveMaterial(void);
    void                            convertModel(void);
 
protected:
    void                            controlJointHandle(void);
    void                            selectJointRecursively(GxJoint* pJoint);
 
    void                            renderMeshVertexTBN(u32 meshIndex);
 
    void                            addUnitOwnProperty(GxPropertyTable& table) override;
 
    void                            updateSpecifiedJointIndexSafe(void);
#endif // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GX_FORCE_INLINE void            setPropertyModelResource(const void* const pValue)  { setModelResource(*static_cast<GxResModel**>(const_cast<void*>(pValue))); }
    GX_FORCE_INLINE void            getPropertyModelResource(void* const pValue) { *static_cast<GxResModel**>(pValue) = getModelResource(); }
 
    GX_FORCE_INLINE void            getPropertyMaterialResource(void* const pValue, u32 index) { *static_cast<GxResMaterial**>(pValue) = getMaterialResource(index); }
    GX_FORCE_INLINE void            setPropertyMaterialResource(const void* const pValue, u32 index) { setMaterialResource(index, *static_cast<GxResMaterial**>(const_cast<void*>(pValue))); }
    constexpr u32                   getPropertyMaterialResourceCount(void) { return _pResModel ? _pResModel->getMaterialCount() : 0; }
    constexpr void                  setPropertyMaterialResourceCount(const void* const /*pValue*/, u32 /*index*/) {}
 
    void                            setPropertyLODDistance(const void* const pValue, u32 index);
    GX_FORCE_INLINE void            getPropertyLODDistance(void* const pValue, u32 index) { *static_cast<f32*>(pValue) = _pResModel ? _pResModel->getLodDistance(index) : 0; }
    constexpr u32                   getPropertyLODDistanceCount(void) { return static_cast<u32>(GxResModel::LOD::DISTANCE_MAX); }
    constexpr void                  setPropertyLODDistanceCount(const void* const /*pValue*/, u32 /*index*/) {}
 
    void                            setPropertyJoint(const void* const pValue, u32 index);
    GX_FORCE_INLINE void            getPropertyJoint(void* const pValue, u32 index) { *static_cast<GxJoint**>(pValue) = getJointFromIndex(index); }
    constexpr void                  setPropertyJointCount(u32 /*count*/) {}
    GX_FORCE_INLINE u32             getPropertyJointCount(void) { return getJointCount(); }
 
    GX_FORCE_INLINE void            setPropertyPartsFlag(const void* const pValue, u32 index) { setPartsFlag(index, *static_cast<b32*>(const_cast<void*>(pValue))); }
    GX_FORCE_INLINE void            getPropertyPartsFlag(void* const pValue, u32 index) { *static_cast<b32*>(pValue) = isPartsFlag(index); }
    GX_FORCE_INLINE void            setPropertyPartsFlagCount(u32 count) { setPartsFlagCount(count); }
    GX_FORCE_INLINE u32             getPropertyPartsFlagCount(void) { return getPartsFlagCount(); }
    GX_FORCE_INLINE void            setPropertyPartsMatrix(const void* const pValue, u32 index) { setPartsMatrix(index, *static_cast<GxMatrixAffine*>(const_cast<void*>(pValue))); }
    GX_FORCE_INLINE void            getPropertyPartsMatrix(void* const pValue, u32 index) { *static_cast<GxMatrixAffine**>(pValue) = &getPartsMatrix(index); }
 
    GX_FORCE_INLINE void            setPropertyMeshCullingFlag(const void* const /*pValue*/, u32 index, u32 view, u32 pass) { _pMeshCullingFlag8[view][pass][index] = true; }
    GX_FORCE_INLINE void            getPropertyMeshCullingFlag(void* const pValue, u32 index, u32 view, u32 pass) { *static_cast<u8*>(pValue) = _pMeshCullingFlag8[view][pass][index]; }
    GX_FORCE_INLINE void            setPropertyMeshCullingFlagCount(u32 count) { setMeshCullingFlagCount(count); }
    GX_FORCE_INLINE u32             getPropertyMeshCullingFlagCount(void) { return getMeshCullingFlagCount(); }
 
    GX_FORCE_INLINE void            setPropertyMeshRenderFlag(const void* const pValue, u32 index) { GxFlag32Array::setFlag(_pMeshRenderFlag, index, *static_cast<b32*>(const_cast<void*>(pValue))); }
    GX_FORCE_INLINE void            getPropertyMeshRenderFlag(void* const pValue, u32 index) { *static_cast<b32*>(pValue) = isMeshRenderFlag(index); }
    GX_FORCE_INLINE void            setPropertyMeshRenderFlagCount(u32 count) { setMeshRenderFlagCount(count); }
    GX_FORCE_INLINE u32             getPropertyMeshRenderFlagCount(void) { return getMeshRenderFlagCount(); }
 
    GX_FORCE_INLINE void            setPropertyMaterial(const void* const /*pValue*/, u32 /*index*/) {}
    GX_FORCE_INLINE void            getPropertyMaterial(void* const pValue, u32 index) { *static_cast<GxRenderMaterial**>(pValue) = getMaterial(index); }
    constexpr void                  setPropertyMaterialCount(u32 /*count*/) {}
    GX_FORCE_INLINE u32             getPropertyMaterialCount(void) { if( _pResModel ) { return _pResModel->getMaterialCount(); } else { return 0; } }
 
#if GX_DEVELOP
    GX_FORCE_INLINE void            eventConvertModel(void) { convertModel(); }
#endif //GX_DEVELOP
 
    GX_FORCE_INLINE void            setPropertyInstanceCount(const void* const pValue) { setInstanceCount(*static_cast<u32*>(const_cast<void*>(pValue))); }
    GX_FORCE_INLINE void            getPropertyInstanceCount(void* const pValue) { *static_cast<u32*>(pValue) = getInstanceCount(); }
    
    GX_FORCE_INLINE void            setPropertyInstancePosition(const void* const pValue, u32 index) { if( getInstanceCount() > 0 ) { GX_ASSERT(index < getInstanceCount(), "インスタンスインデックスエラー"); _pInstanceDataArray[index]._position = *static_cast<GxVector3*>(const_cast<void*>(pValue)); } }
    GX_FORCE_INLINE void            getPropertyInstancePosition(void* const pValue, u32 index) { if( getInstanceCount() > 0 ) { GX_ASSERT(index < getInstanceCount(), "インスタンスインデックスエラー"); *static_cast<GxVector3**>(pValue) = &_pInstanceDataArray[index]._position; } }
    GX_FORCE_INLINE void            setPropertyInstancePositionCount(u32 count) { setInstanceCount(count); }
    GX_FORCE_INLINE u32             getPropertyInstancePositionCount(void) { return getInstanceCount(); }
 
    GX_FORCE_INLINE void            setPropertyInstanceQuaternion(const void* const pValue, u32 index) { if( getInstanceCount() > 0 ) { GX_ASSERT(index < getInstanceCount(), "インスタンスインデックスエラー"); _pInstanceDataArray[index]._quaternion = *static_cast<GxQuaternion*>(const_cast<void*>(pValue)); } }
    GX_FORCE_INLINE void            getPropertyInstanceQuaternion(void* const pValue, u32 index) { if( getInstanceCount() > 0 ) { GX_ASSERT(index < getInstanceCount(), "インスタンスインデックスエラー"); *static_cast<GxQuaternion**>(pValue) = &_pInstanceDataArray[index]._quaternion; } }
    GX_FORCE_INLINE void            setPropertyInstanceQuaternionCount(u32 count) { setInstanceCount(count); }
    GX_FORCE_INLINE u32             getPropertyInstanceQuaternionCount(void) { return getInstanceCount(); }
 
    GX_FORCE_INLINE void            setPropertyInstanceScale(const void* const pValue, u32 index) {  if( getInstanceCount() > 0 ) { GX_ASSERT(index < getInstanceCount(), "インスタンスインデックスエラー"); _pInstanceDataArray[index]._scale = *static_cast<GxVector3*>(const_cast<void*>(pValue)); } }
    GX_FORCE_INLINE void            getPropertyInstanceScale(void* const pValue, u32 index) { if( getInstanceCount() > 0 ) { GX_ASSERT(index < getInstanceCount(), "インスタンスインデックスエラー"); *static_cast<GxVector3**>(pValue) = &_pInstanceDataArray[index]._scale; } }
    GX_FORCE_INLINE void            setPropertyInstanceScaleCount(u32 count) { setInstanceCount(count); }
    GX_FORCE_INLINE u32             getPropertyInstanceScaleCount(void) { return getInstanceCount(); }
 
    GX_FORCE_INLINE void            setPropertyInstanceOffsetMatrix(const void* const pValue, u32 index) { setInstanceOffsetMatrix(index, *static_cast<GxMatrixAffine*>(const_cast<void*>(pValue))); }
    GX_FORCE_INLINE void            getPropertyInstanceOffsetMatrix(void* const pValue, u32 index) { *static_cast<GxMatrixAffine**>(pValue) = &getInstanceOffsetMatrix(index); }
    constexpr void                  setPropertyInstanceOffsetMatrixCount(u32 /*count*/) {}
    GX_FORCE_INLINE u32             getPropertyInstanceOffsetMatrixCount(void) { return 1 < getInstanceCount() ? getInstanceCount() : 0; }
 
#if GX_DEVELOP
    GX_FORCE_INLINE void            setPropertyInstanceParentMatrix(const void* const pValue, u32 index) { if( getInstanceCount() > 0 ) { GX_ASSERT(index < getInstanceCount(), "インスタンスインデックスエラー"); _pInstanceDataArray[index]._parentMatrix = *static_cast<GxMatrixAffine*>(const_cast<void*>(pValue)); } }
    GX_FORCE_INLINE void            getPropertyInstanceParentMatrix(void* const pValue, u32 index) { if( getInstanceCount() > 0 ) { GX_ASSERT(index < getInstanceCount(), "インスタンスインデックスエラー"); *static_cast<GxMatrixAffine**>(pValue) = &_pInstanceDataArray[index]._parentMatrix; } }
    constexpr void                  setPropertyInstanceParentMatrixCount(u32 /*count*/) {}
    GX_FORCE_INLINE u32             getPropertyInstanceParentMatrixCount(void) { return 1 < getInstanceCount() ? getInstanceCount() : 0; }
#endif // GX_DEVELOP
 
    GX_FORCE_INLINE void            setPropertyInstanceShowFlag(const void* const pValue, u32 index) { if( getInstanceCount() > 0 ) { setInstanceShowFlag(index, *static_cast<b32*>(const_cast<void*>(pValue))); } }
    GX_FORCE_INLINE void            getPropertyInstanceShowFlag(void* const pValue, u32 index) { if( getInstanceCount() > 0 ) { *static_cast<b32*>(pValue) = isInstanceShowFlag(index); } }
    constexpr void                  setPropertyInstanceShowFlagCount(u32 /*count*/) {}
    GX_FORCE_INLINE u32             getPropertyInstanceShowFlagCount(void) { return 1 < getInstanceCount() ? getInstanceCount() : 0; }
 
#if GX_DEVELOP
    GX_FORCE_INLINE void            getPropertyRenderDevelopInfoNormal(void* const pValue, u32 index) { *static_cast<GxRenderShaderDevInfo**>(pValue) = getRenderPassInfo(PASSINFO::NORMAL, index); }
    GX_FORCE_INLINE void            getPropertyRenderDevelopInfoShadow(void* const pValue, u32 index) { *static_cast<GxRenderShaderDevInfo**>(pValue) = getRenderPassInfo(PASSINFO::SHADOW, index); }
    GX_FORCE_INLINE void            getPropertyRenderDevelopInfoPointShadow(void* const pValue, u32 index) { *static_cast<GxRenderShaderDevInfo**>(pValue) = getRenderPassInfo(PASSINFO::POINTSHADOW, index); }
    GX_FORCE_INLINE void            getPropertyRenderDevelopInfoPreZ(void* const pValue, u32 index) { *static_cast<GxRenderShaderDevInfo**>(pValue) = getRenderPassInfo(PASSINFO::PREZ, index); }
    GX_FORCE_INLINE void            getPropertyRenderDevelopInfoMotionBlur(void* const pValue, u32 index) { *static_cast<GxRenderShaderDevInfo**>(pValue) = getRenderPassInfo(PASSINFO::MOTIONBLUR, index); }
    GX_FORCE_INLINE void            getPropertyRenderDevelopInfoEnvironment(void* const pValue, u32 index) { *static_cast<GxRenderShaderDevInfo**>(pValue) = getRenderPassInfo(PASSINFO::ENV, index); }
    GX_FORCE_INLINE void            getPropertyRenderDevelopInfoPolygonLine(void* const pValue, u32 index) { *static_cast<GxRenderShaderDevInfo**>(pValue) = getRenderPassInfo(PASSINFO::POLYGONLINE, index); }
    GX_FORCE_INLINE u32             getPropertyRenderDevelopInfoCount(void) { if( _pResModel ) { return _pResModel->getMaterialCount(); } else { return 0; } }
    constexpr void                  setPropertyRenderDevelopInfoCount(void* const /*pValue*/, u32 /*index*/) {}
    constexpr void                  setPropertyRenderDevelopInfo(void* const /*pValue*/, u32 /*index*/ ) {}
    void                            getPropertySpecifiedJointId(void* const pValue);
    void                            setPropertySpecifiedJointId(const void* const pValue);
 
    GX_FORCE_INLINE void            getPropertyVertexDeclarationPrecisionTypeTexcoord(void* const pValue)                   { if( getModelResource() && getModelResource()->getConfig() ) { *(GxResModel::VERTEX_DECLARATION_ELEMENT_PRECISION_TYPE*)pValue = getModelResource()->getVertexDeclarationPrecisionType( GxResModel::VERTEX_DECLARATION_ELEMENT_PRECISION_GROUP::TEXCOORD ); } }
    GX_FORCE_INLINE void            setPropertyVertexDeclarationPrecisionTypeTexcoord(const void* const pValue)         { if( getModelResource() && getModelResource()->getConfig() ) { getModelResource()->setVertexDeclarationPrecisionType( GxResModel::VERTEX_DECLARATION_ELEMENT_PRECISION_GROUP::TEXCOORD, *static_cast<GxResModel::VERTEX_DECLARATION_ELEMENT_PRECISION_TYPE*>(const_cast<void*>(pValue)) ); } }
    GX_FORCE_INLINE void            getPropertyVertexDeclarationPrecisionTypeNormal(void* const pValue)                 { if( getModelResource() && getModelResource()->getConfig() ) { *(GxResModel::VERTEX_DECLARATION_ELEMENT_PRECISION_TYPE*)pValue = getModelResource()->getVertexDeclarationPrecisionType( GxResModel::VERTEX_DECLARATION_ELEMENT_PRECISION_GROUP::NORMAL ); } }
    GX_FORCE_INLINE void            setPropertyVertexDeclarationPrecisionTypeNormal(const void* const pValue)               { if( getModelResource() && getModelResource()->getConfig() ) { getModelResource()->setVertexDeclarationPrecisionType( GxResModel::VERTEX_DECLARATION_ELEMENT_PRECISION_GROUP::NORMAL, *static_cast<GxResModel::VERTEX_DECLARATION_ELEMENT_PRECISION_TYPE*>(const_cast<void*>(pValue)) ); } }
    GX_FORCE_INLINE void            getPropertyVertexDeclarationPrecisionTypeBinormalTangent(void* const pValue)            { if( getModelResource() && getModelResource()->getConfig() ) { *(GxResModel::VERTEX_DECLARATION_ELEMENT_PRECISION_TYPE*)pValue = getModelResource()->getVertexDeclarationPrecisionType( GxResModel::VERTEX_DECLARATION_ELEMENT_PRECISION_GROUP::BINORMAL_TANGENT ); } }
    GX_FORCE_INLINE void            setPropertyVertexDeclarationPrecisionTypeBinormalTangent(const void* const pValue)  { if( getModelResource() && getModelResource()->getConfig() ) { getModelResource()->setVertexDeclarationPrecisionType( GxResModel::VERTEX_DECLARATION_ELEMENT_PRECISION_GROUP::BINORMAL_TANGENT, *static_cast<GxResModel::VERTEX_DECLARATION_ELEMENT_PRECISION_TYPE*>(const_cast<void*>(pValue)) ); } }
#endif // GX_DEVELOP
 
public:
    GX_FORCE_INLINE virtual u32     getJointCount(void) const { if( _pResModel ) { return _pResModel->getJointCount(); } else { return 0; } }
    GxJoint*                        getJointFromIndex(u32 index) const;
 
    GxJoint*                        getJointFromId(u32 id) const;
    u32                             getJointIndexFromId(u32 id) const;
 
    GX_FORCE_INLINE u32             getPartsFlagCount(void) const { if( _pResModel ) { return _pResModel->getPartsCount(); } else { return 0; } }
    GX_FORCE_INLINE b32             isPartsFlag(u32 index) const { return GxFlag32Array::isFlag(_pPartsFlag, index); }
    GX_FORCE_INLINE void            setPartsFlag(u32 index, b32 enable) { GxFlag32Array::setFlag(_pPartsFlag, index, enable); }
    GX_FORCE_INLINE s32             getPartsIndex(GX_CSTR partsName) const { return _pResModel ? _pResModel->getPartsIndex(partsName) : -1; }
    GX_FORCE_INLINE b32             isUsePartsMatrix(void){ return _usePartsMatrixFlag; }
    GX_FORCE_INLINE void            setUsePartsMatrix(b32 on){ _usePartsMatrixFlag = on; }
    GxMatrixAffine&                 getPartsMatrix(u32 index) const;
    void                            setPartsMatrix(u32 index, const GxMatrixAffine& matrix);
    
    GxRenderVertexDeclaration* getPartsVertexDeclaration(u32 index) const;
    GX_FORCE_INLINE u32             getPartsVertexCount(u32 index) const { GX_ASSERT(_pResModel, "モデルリソースが設定されていません"); return _pResModel->getPartsVertexCount(index); }
    GX_FORCE_INLINE u32             getPartsVertexStride(u32 index, u16 vertexStream) const { GX_ASSERT(_pResModel, "モデルリソースが設定されていません"); return _pResModel->getPartsVertexStride(index, vertexStream); }
 
    GX_FORCE_INLINE RENDER_INDEX_TYPE   getPartsIndexType(u32 index) const { GX_ASSERT(_pResModel, "モデルリソースが設定されていません"); return _pResModel->getPartsIndexType(index); }
    GX_FORCE_INLINE u32             getPartsIndexOffset(u32 index) const { GX_ASSERT(_pResModel, "モデルリソースが設定されていません"); return _pResModel->getPartsIndexOffset(index); }
    GX_FORCE_INLINE u32             getPartsIndexCount(u32 index) const { GX_ASSERT(_pResModel, "モデルリソースが設定されていません"); return _pResModel->getPartsIndexCount(index); }
    GX_FORCE_INLINE u32             getPartsIndexMinimum(u32 index) const { GX_ASSERT(_pResModel, "モデルリソースが設定されていません"); return _pResModel->getPartsIndexMinimum(index); }
 
    void                            getMeshWorldMatrix( GxMatrixAffine& world, const u32& meshIndex );
 
    GX_FORCE_INLINE u32             getMeshIndexFromPartsIndex(u32 partsIndex) const { GX_ASSERT(_pResModel, "モデルリソースが設定されていません"); return _pResModel->getMeshIndexFromPartsIndex(partsIndex); }
    GX_FORCE_INLINE u32             getMeshGroupIndexFromMeshIndex(u32 meshIndex) const { GX_ASSERT(_pResModel, "モデルリソースが設定されていません"); return _pResModel->getMeshGroupIndexFromMeshIndex(meshIndex); }
 
    constexpr u32                   getMeshCullingFlagCount(void) const { if( _pResModel ) { return _pResModel->getMeshCount(); } else { return 0; } }
    GX_FORCE_INLINE b32             isMeshCullingFlag(u32 index, RENDER_VIEW view, CULLING_FRUSTUM pass) const { return _pMeshCullingFlag8[static_cast<s32>(view)][static_cast<s32>(pass)][index] > 0 ? true : false; }
    constexpr u32                   getMeshRenderFlagCount(void) const { if( _pResModel ) { return _pResModel->getMeshCount(); } else { return 0; } }
    GX_FORCE_INLINE b32             isMeshRenderFlag(u32 index) const { return GxFlag32Array::isFlag(_pMeshRenderFlag, index); }
 
    constexpr u32                   getMaterialCount(void) const { if( _pResModel ) { return _pResModel->getMaterialCount(); } else { return 0; } }
    GxRenderMaterial*               getMaterial(u32 index);
 
    GX_FORCE_INLINE b32             isModelAttribute(MODEL_ATTRIBUTE attribute) const { return _modelAttribute.isFlag(attribute); }
    GX_FORCE_INLINE void            setModelAttribute(MODEL_ATTRIBUTE attribute, b32 enable) { _modelAttribute.setFlag(attribute, enable); }
 
    constexpr GxResModel::LOD       getShowLod(void) const { return _showLod; }
    constexpr void                  setShowLod(GxResModel::LOD showLod) { _showLod = showLod; }
 
    constexpr GxResModel::LOD       getLodMode(void) const { return _lodMode; }
    constexpr void                  setLodMode(GxResModel::LOD lodMode) { _lodMode = lodMode; }
 
    const GxMatrixAffine&           getInstanceMatrix(u32 index) const;
    GxMatrixAffine&                 getInstanceMatrix(u32 index);
    void                            setInstanceMatrix(u32 index, const GxMatrixAffine& matrix);
    constexpr u32                   getInstanceCount(void) const { return _instanceCount; }
    virtual void                    setInstanceCount(u32 count);
    void                            reserveInstanceMemory(u32 count);
    void                            freeInstanceMemory(void);
    GX_FORCE_INLINE b32             isInstanced(void) const { return 0 < _instanceCount; }
    GX_FORCE_INLINE void            setUseJointMultiplyMatrix(b32 use) { _useJointMultiplyMatrix = use; }
    GX_FORCE_INLINE b32             getUseJointMultiplyMatrix(void) { return _useJointMultiplyMatrix; }
    void                            setJointMultiplyMatrix(u32 index, const GxMatrixAffine& matrix);
    void                            resetJointMultiplyMatrix(void);
    void                            updateJointMultiplyMatrix(void);
    GX_FORCE_INLINE GxCriticalSection* getMaterialCriticalSection(void) { if (_pResModel) { return  _pResModel->getMaterialCriticalSection(); } else { return nullptr; } }
 
#if GX_DEVELOP
    GxRenderShaderDevInfo * getRenderPassInfo(PASSINFO index, u32 materialIndex);
 
    GX_FORCE_INLINE void            setInstancePosition(const GxVector3& position, u32 index) { GX_ASSERT(index < getInstanceCount(), "インスタンスインデックスエラー"); _pInstanceDataArray[index]._position = position; }
    GX_FORCE_INLINE GxVector3&      getInstancePosition(u32 index) { GX_ASSERT(index < getInstanceCount(), "インスタンスインデックスエラー"); return _pInstanceDataArray[index]._position; }
 
    GX_FORCE_INLINE void            setInstanceQuaternion(const GxQuaternion& quaternion, u32 index) { GX_ASSERT(index < getInstanceCount(), "インスタンスインデックスエラー"); _pInstanceDataArray[index]._quaternion = quaternion; }
    GX_FORCE_INLINE GxQuaternion&   getInstanceQuaternion(u32 index) { GX_ASSERT(index < getInstanceCount(), "インスタンスインデックスエラー"); return _pInstanceDataArray[index]._quaternion; }
 
    GX_FORCE_INLINE void            setInstanceScale(const GxVector3& scale, u32 index) { GX_ASSERT(index < getInstanceCount(), "インスタンスインデックスエラー"); _pInstanceDataArray[index]._scale = scale; }
    GX_FORCE_INLINE GxVector3&      getInstanceScale(u32 index) { GX_ASSERT(index < getInstanceCount(), "インスタンスインデックスエラー"); return _pInstanceDataArray[index]._scale; }
#endif // GX_DEVELOP
 
    const GxMatrixAffine&           getInstanceOffsetMatrix(u32 index) const;
    GxMatrixAffine&                 getInstanceOffsetMatrix(u32 index);
    void                            setInstanceOffsetMatrix(u32 index, const GxMatrixAffine& matrix);
    GX_FORCE_INLINE b32             isInstanceShowFlag(u32 index) const { return GxFlag32Array::isFlag(_pInstanceShowFlag, index); }
    GX_FORCE_INLINE void            setInstanceShowFlag(u32 index, b32 enable) { GxFlag32Array::setFlag(_pInstanceShowFlag, index, enable); }
    GX_FORCE_INLINE b32             isInstanceCullingFlag(u32 index, RENDER_VIEW view, u32 pass) const { return _pppInstanceCullingFlag8[static_cast<s32>(view)][pass][index] ? true : false; }
    b32                             hasSkin(void) const;
 
#if GX_DEVELOP
    GxJoint*                        getNearestJoint( const GxVector3& rayStart, const GxVector3& rayEnd );
    void                            setHandleJoint( const s32 jointIndex );
 
    GX_FORCE_INLINE b32             isDevelopFlag(DEVELOP_FLAG flag) { return _developFlag.isFlag(flag); }
    GX_FORCE_INLINE void            setDevelopFlag(DEVELOP_FLAG flag, b32 enable) { _developFlag.setFlag(flag, enable); }
 
    constexpr u32                   getSpecifiedJointIndex(void) const { return _specifiedJointIndex; }
    constexpr void                  setSpecifiedJointIndex(u32 index) { _specifiedJointIndex = index; }
    constexpr u32                   getSpecifiedMaterialIndex(void) const { return _specifiedMaterialIndex; }
    constexpr void                  setSpecifiedMaterialIndex(u32 index) { _specifiedMaterialIndex = index; }
 
#endif // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxJoint*                        _pJoint;                    
 
    GxResModel*                     _pResModel;                 
    GxResMaterial**                 _ppResMaterial;             
 
    GxRenderMaterial*               _pMaterial;                 
 
    GxMatrixAffine                  _renderViewMatrix;          
    GxMatrix44                      _renderProjMatrix;          
    GxMatrixAffineGpu*              _pRenderMatrix;             
    GxMatrixAffineGpu               _defaultRenderMatrix;       
 
    // TODO: ここをまとめる
    u32*                            _pPartsFlag;                
    u32                             _defaultPartsFlag;          
    b32                             _usePartsMatrixFlag;        
 
    u32                             _viewNum;                   
    u32                             _passNum;                   
    b32                             _useJointMultiplyMatrix;    
    GxMatrixAffine*                 _pJointMultiplyMatrix;      
    GxMatrixAffine                  _defaultJointMultiplyMatrix;    
 
    u8*                             _pMeshCullingFlag8[static_cast<s32>(RENDER_VIEW::_3D_MAX)][static_cast<s32>(CULLING_FRUSTUM::MAX)];         
    u8*                             _pMeshCullingFlag8Buffer;   
    u8***                           _pppInstanceCullingFlag8;   
    b32                             _isInstanceCullingFlag;     
    u32*                            _pMeshRenderFlag;           
    u32                             _defaultMeshRenderFlag;     
    u32*                            _pInstanceShowFlag;         
#if GX_ENABLE_OCCLUSION_CULLING
    s32*                            _pOcclusionQueryIndex[RENDER_BUFFER_COUNT_MAX]; 
    s32                             _defaultOcclusionQueryIndex[RENDER_BUFFER_COUNT_MAX];   
#endif //GX_ENABLE_OCCLUSION_CULLING
 
    GxFlag32Index<MODEL_ATTRIBUTE>  _modelAttribute;            
    GxResModel::LOD                 _showLod;                   
    GxResModel::LOD                 _lodMode;                   
 
    GxInstanceData*                 _pInstanceDataArray;        
    GxInstanceData*                 _pSaveInstanceDataArray;    
#if GX_DEVELOP
    u32                             _saveInstanceCount;         
#endif  // GX_DEVELOP
    u32                             _reservedInstanceCount;     
    GxMatrixAffine*                 _pPartsMatrix;              
    GxMatrixAffine                  _defaultPartsMatrix;        
    GxMatrixAffineGpu*              _pRenderInstanceMatrix;     
    GxVector4*                      _pInstanceData;             
    GxVector4*                      _pRenderInstanceData;       
    GxVector4                       _instanceData;              
    u32                             _instanceCount;             
    u32                             _renderInstanceCount;       
    GxRenderVertexDeclaration**     _ppInstanceVertexDeclaration;   
 
#if GX_DEVELOP
    GxFlag32Index<DEVELOP_FLAG>     _developFlag;               
 
    GxHandle*                       _pJointHandle;              
    u32                             _specifiedJointIndex;       
    u32                             _specifiedMaterialIndex;    
    u32                             _specifiedMeshIndex;        
    u32                             _blinkCounter;              
 
    b32                             _isAllMeshBlink;            
    b32                             _isAlreadyBlink;            
    f32                             _blinkTimer;                
    GxRenderShaderDevInfo*          _pRenderPassInfo[static_cast<s32>(PASSINFO::MAX)];  
    GxRenderShaderDevInfo*          _pRenderPassInfoBuffer;     
 
    u32                             _jointFontSize;             
    GxColor                         _jointFontColor;            
#endif // GX_DEVELOP
 
    // シェーダハンドル
    static b32                              _isUsableShaderHandleBase;          
    static GX_HANDLE                        _handleProjectionMatrix;            
    static GX_HANDLE                        _handleWorldViewMatrix;             
    static GX_HANDLE                        _handleLightParameter;              
    static GX_HANDLE                        _handleInstanceData;                
    static GX_HANDLE                        _handleInverseScale;                
    static GX_HANDLE                        _handleEnvironmentMapSampler;       
    static GX_HANDLE                        _handleCubeMapSampler;              
#if GX_USE_HLSL
    static GX_HANDLE                        _handleCubeMapSamplerState;         
#endif  // GX_USE_HLSL
private:
    static GxCriticalSection                _shaderHandleCriticalSectionBase;   
 
};
 
#if GX_DEVELOP
//===========================================================================
//===========================================================================
struct GxUnitModelBase::GxRenderShaderDevInfo : public GxStructBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_STRUCT(GxRenderShaderDevInfo)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxRenderShaderDevInfo(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    u32 vertexShaderSize;                   
    u32 pixelShaderSize;                    
 
};
#endif // GX_DEVELOP
 
//===========================================================================
//===========================================================================
struct GxUnitModelBase::GxJoint : public GxStructBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_STRUCT(GxJoint)
    // new, delete定義
    GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::UNIT)
 
    // 属性定義
    enum class ATTRIBUTE
    {
        WORLD,                              
        SEGMENT_SCALE_COMPENSATE,           
        MAX,                                
    };
#if GX_DEVELOP
    GX_FLAG_TABLE_MAX(ATTRIBUTE)
#endif //GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxJoint(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    void                                    updateLocalMatrix(void);
    void                                    updateWorldMatrix(const GxMatrixAffine& worldMatrix);
 
#if GX_DEVELOP
    void                                    developRenderJointDetail(b32 isOverlay = false);
    void                                    developRenderJointLine(b32 isOverlay = false);
 
    void                                    developRenderJointNameAndIndex(u32 size, GxColor color);
    void                                    developRenderJointName(u32 size, GxColor color);
    void                                    developRenderJointIndex(u32 size, GxColor color);
    void                                    developRenderJointMatrix(b32 isOverlay = false);
 
    static GxGuiBase*                       createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index);
 
    b32                                     isHitRay(const GxVector3& rayStart, const GxVector3& rayEnd, f32& param);
#endif //GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    constexpr u32                   getIndex(void) const { return _index; }
    constexpr void                  setIndex(u32 index) { _index = index; }
    constexpr s32                   getId(void) const { return _id; }
    constexpr void                  setId(s32 id) { _id = id; }
    constexpr GX_CSTR               getName(void) const { return _name; }
    constexpr void                  setName(GX_CSTR name) { _name = name; }
    constexpr GxJoint*              getParentJoint(void) const { return _pParentJoint; }
    constexpr void                  setParentJoint(GxJoint* pJoint) { _pParentJoint = pJoint; }
    constexpr GxJoint*              getChildJoint(void) const { return _pChildJoint; }
    constexpr void                  setChildJoint(GxJoint* pJoint) { _pChildJoint = pJoint; }
    constexpr GxJoint*              getBrotherJoint(void) const { return _pBrotherJoint; }
    constexpr void                  setBrotherJoint(GxJoint* pJoint) { _pBrotherJoint = pJoint; }
 
    GX_FORCE_INLINE const GxMatrixAffine&   getLocalMatrix(void) const { return _localMatrix; }
    GX_FORCE_INLINE void                    setLocalMatrix(const GxMatrixAffine& localMatrix) { _localMatrix = localMatrix; }
    GX_FORCE_INLINE void                    setLocalMatrix(const GxMatrixAffine& localMatrix, const GxVector3& offset) { _localMatrix = localMatrix; _localMatrix.setPosition( offset ); }
 
    GX_FORCE_INLINE const GxMatrixAffine&   getWorldMatrix(void) const { return _worldMatrix; }
    GX_FORCE_INLINE void                    setWorldMatrix(const GxMatrixAffine& worldMatrix) { _worldMatrix = worldMatrix; }
 
    GX_FORCE_INLINE const GxMatrixAffine&   getOrientMatrix(void) const { return *_pOrientMatrix; }
    GX_FORCE_INLINE void                    setOrientMatrix(const GxMatrixAffine* pMatrix) { _pOrientMatrix = pMatrix; }
    GX_FORCE_INLINE const GxMatrixAffine&   getInversMatrix(void) const { return *_pInversMatrix; }
    GX_FORCE_INLINE void                    setInversMatrix(const GxMatrixAffine* pMatrix) { _pInversMatrix = pMatrix; }
 
    GX_FORCE_INLINE const GxVector3&        getPosition(void) const{ return _position; }
    GX_FORCE_INLINE void                    setPosition(const GxVector3& position){ _position = position; }
    GX_FORCE_INLINE const GxQuaternion&     getQuaternion(void) const { return _quaternion; }
    GX_FORCE_INLINE void                    setQuaternion(const GxQuaternion& quaternion){ _quaternion = quaternion; }
    GX_FORCE_INLINE const GxVector3&        getScale(void) const { return _scale; }
    GX_FORCE_INLINE void                    setScale(const GxVector3& scale) { _scale = scale; }
 
    GX_FORCE_INLINE b32                     isAttribute(ATTRIBUTE attribute) const { return _attribute.isFlag(attribute); }
    GX_FORCE_INLINE void                    setAttribute(ATTRIBUTE attribute, b32 enable) { _attribute.setFlag(attribute, enable); }
 
#if GX_DEVELOP
    GX_FORCE_INLINE b32                     isHandleSelected(void) const { return _isHandleSelected; }
    GX_FORCE_INLINE void                    setIsHandleSelected(b32 isSelected) { _isHandleSelected = isSelected; }
    void                                    setHandleParam(GxHandle& handle);
#endif // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    u32                             _index;                     
    s32                             _id;                        
    GX_CSTR                         _name;                      
    GxJoint*                        _pParentJoint;              
    GxJoint*                        _pChildJoint;               
    GxJoint*                        _pBrotherJoint;             
    GxMatrixAffine                  _localMatrix;               
    GxMatrixAffine                  _worldMatrix;               
    GxVector3                       _position;                  
    GxQuaternion                    _quaternion;                
    GxVector3                       _scale;                     
    const GxMatrixAffine*           _pOrientMatrix;             
    const GxMatrixAffine*           _pInversMatrix;             
    GxFlag32Index<ATTRIBUTE>        _attribute;                 
#if GX_DEVELOP
    b32                             _isHandleSelected;          
#endif // GX_DEVELOP
 
};
 
GX_CORE_NAMESPACE_END()