GxResModel.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
class GxResMaterial;
 
//===========================================================================
//===========================================================================
class GxResModel : public GxResBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_RESOURCE_ICON(GxResModel, GxResBase, GxRtti::ICON_TYPE::MESH)
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResModel)
 
    
    enum class LOD
    {
        SUPER_HIGH,     
        HIGH,           
        MIDDLE,         
        LOW,            
        SUPER_LOW,      
        AUTO,           
        MAX = AUTO,     
        DISTANCE_MAX = MAX - 1, 
    };
#if GX_DEVELOP
    GX_ENUM_TABLE_COUNT(LOD, static_cast<s32>(LOD::MAX) + 1)
#endif //GX_DEVELOP
 
    enum class VERTEX_DECLARATION_ELEMENT_PRECISION_GROUP
    {
        POSITION,           
        COLOR,              
        TEXCOORD,           
        NORMAL,             
        BINORMAL,           
        TANGENT = BINORMAL, 
        BINORMAL_TANGENT = BINORMAL,    
        BLEND_WEIGHT,       
        BLEND_INDICES,      
        MAX,                
    };
 
    enum class VERTEX_DECLARATION_ELEMENT_PRECISION_TYPE
    {
        FLOAT,  
        HALF,   
        MAX,    
    };
#if GX_DEVELOP
    GX_ENUM_TABLE_MAX(VERTEX_DECLARATION_ELEMENT_PRECISION_TYPE)
#endif //GX_DEVELOP
 
    struct GxImportSetting : public GxStructBase
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // RTTI定義
        GX_RTTI_STRUCT(GxResModel::GxImportSetting)
 
        
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        GxImportSetting(void);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
#if GX_DEVELOP
        b32 write(GxStreamWriter& writer);
#endif //GX_DEVELOP
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        GxVector3   _boundingSphereCenter;  
        f32         _boundingSphereRadius;  
        f32         _lodDistance[static_cast<s32>(LOD::DISTANCE_MAX)];  
        VERTEX_DECLARATION_ELEMENT_PRECISION_TYPE _vertexDeclarationPrecisionType[static_cast<s32>(GxResModel::VERTEX_DECLARATION_ELEMENT_PRECISION_GROUP::MAX)];   
 
    };
 
#include "GxResModel.inl"
 
    struct GxModelCreateCallbackData
    {
        b32 _enableRemapVertexBuffer;   
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxResModel(void);
public:
    void cleanup(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    b32 load(GxStream& stream, u32 dataSize);
#if GX_DEVELOP
    b32 save(GxStream& stream);
#endif  // GX_DEVELOP
 
    void* mapPartsVertexBuffer(u32 index, u16 vertexStream, u32 /*RENDER_MAPPING*/ mappingType);
    void                            unmapPartsVertexBuffer(u32 index, u16 vertexStream);
    void* mapPartsIndexBuffer(u32 index, u32 /*RENDER_MAPPING*/ mappingType);
    void                            unmapPartsIndexBuffer(u32 index);
 
    void createCallback(void* pUser);
 
protected:
    b32             loadMesh(const GxMeshFile* pMeshFile);
    b32             loadMeshGroup(const GxMeshGroupFile* pMeshGroupFile, const void* pVertexBufferFile, const void* pIndexBufferFile, const GxRenderVertexElement* pVertexElementFile);
 
#if GX_DEVELOP
    b32             saveMesh(GxMeshFile* pMeshFile);
    b32             saveMeshGroup(GxMeshGroupFile* pMeshGroupFile, void* pVertexBufferFile, void* pIndexBufferFile, GxRenderVertexElement* pVertexElementFile);
    b32             loadImportSetting(void);
    void            saveImportSetting(void);
#endif  // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
#if GX_DEVELOP
#if GX_EDITOR
    void getToolRtti(GxArray& arrayTool) const override;
#endif //GX_EDITOR
    GxRtti* getUnitRtti(void) override;
#endif  // GX_DEVELOP
    constexpr const GX_CHAR* getStringTable(void) const { return _pStringTable; }
    constexpr u32 getJointCount(void) const { return _pHeader ? _pHeader->_jointCount : 0; }
    constexpr GxJoint* getJoint(u32 index) const { GX_ASSERT(index < getJointCount(), "指定されたインデックスがオーバーしています"); return &_pJoint[index]; }
    constexpr GxMatrixAffine* getOrientMatrix(u32 index) const { GX_ASSERT(index < getJointCount(), "指定されたインデックスがオーバーしています"); return &_pOrientMatrix[index]; }
    constexpr GxMatrixAffine* getInversMatrix(u32 index) const { GX_ASSERT(index < getJointCount(), "指定されたインデックスがオーバーしています"); return &_pInversMatrix[index]; }
    constexpr u32 getPartsCount(void) const { return _pHeader ? _pHeader->_partsCount : 0; }
    s32 getPartsIndex(GX_CSTR partsName) const;
    constexpr u32 getMeshCount(void) const { return _pHeader ? _pHeader->_meshCount : 0; }
    constexpr const GxMesh* getMesh(u32 index) const { GX_ASSERT(index < getMeshCount(), "指定されたインデックスがオーバーしています"); return &_pMesh[index]; }
    constexpr u32 getMeshGroupCount(void) const { return _pHeader ? _pHeader->_meshGroupCount : 0; }
    constexpr GxMeshGroup* getMeshGroup(u32 index) const { GX_ASSERT(index < getMeshGroupCount(), "指定されたインデックスがオーバーしています"); return &_pMeshGroup[index]; }
    constexpr u32 getMaterialCount(void) const { return _pHeader ? _pHeader->_materialCount : 0; }
    constexpr GxCriticalSection* getMaterialCriticalSection(void) { return &_materialCriticalSection; }
    GX_FORCE_INLINE b32 isEnableRemapVertexBuffer(void) { return _enableRemapVertexBuffer; }
 
    u32                             getMeshIndexFromPartsIndex(u32 partsIndex) const;
    u32                             getMeshGroupIndexFromMeshIndex(u32 meshIndex) const;
    GxRenderVertexDeclaration*      getPartsVertexDeclaration(u32 index) const;
    u32                             getPartsVertexCount(u32 index) const;
    u32                             getPartsVertexStride(u32 index, u16 vertexStream) const;
    RENDER_INDEX_TYPE               getPartsIndexType(u32 index) const;
    u32                             getPartsIndexOffset(u32 index) const;
    u32                             getPartsIndexCount(u32 index) const;
    u32                             getPartsIndexMinimum(u32 index) const;
    GX_FORCE_INLINE const GxVector3& getBoundingSphereCenter(void) const { return _pHeader ? _pHeader->_importSetting._boundingSphereCenter : GxVector3::ZERO; }
    GX_FORCE_INLINE void            setBoundingSphereCenter(const GxVector3& center) { _pHeader->_importSetting._boundingSphereCenter = center; }
    constexpr f32                   getBoundingSphereRadius(void) const { return _pHeader ? _pHeader->_importSetting._boundingSphereRadius : 0; }
    constexpr void                  setBoundingSphereRadius(f32 radius) { _pHeader->_importSetting._boundingSphereRadius = radius; }
    GX_FORCE_INLINE f32                     getLodDistance(u32 index) const
    {
        GX_ASSERT(index < static_cast<s32>(GxResModel::LOD::DISTANCE_MAX), "範囲外のインデックスにアクセスしました");
        return _pHeader->_importSetting._lodDistance[index];
    }
    GX_FORCE_INLINE void                    setLodDistance(u32 index, f32 distance)
    {
        GX_ASSERT(index < static_cast<s32>(GxResModel::LOD::DISTANCE_MAX), "範囲外のインデックスにアクセスしました");
        _pHeader->_importSetting._lodDistance[index] = distance;
    }
#if GX_DEVELOP
    GX_FORCE_INLINE GxResModel::VERTEX_DECLARATION_ELEMENT_PRECISION_TYPE getVertexDeclarationPrecisionType(GxResModel::VERTEX_DECLARATION_ELEMENT_PRECISION_GROUP index) const
    {
        GX_ASSERT(static_cast<s32>(index) < static_cast<s32>(GxResModel::VERTEX_DECLARATION_ELEMENT_PRECISION_GROUP::MAX), "範囲外のインデックスにアクセスしました");
        return _pHeader->_importSetting._vertexDeclarationPrecisionType[static_cast<s32>(index)];
    }
    GX_FORCE_INLINE void setVertexDeclarationPrecisionType(GxResModel::VERTEX_DECLARATION_ELEMENT_PRECISION_GROUP index, GxResModel::VERTEX_DECLARATION_ELEMENT_PRECISION_TYPE accuracyType)
    {
        GX_ASSERT(static_cast<s32>(index) < static_cast<s32>(GxResModel::VERTEX_DECLARATION_ELEMENT_PRECISION_GROUP::MAX), "範囲外のインデックスにアクセスしました");
        _pHeader->_importSetting._vertexDeclarationPrecisionType[static_cast<s32>(index)] = accuracyType;
    }
#endif  // GX_DEVELOP
#if GX_DEVELOP
    static void                     getImportSettingPath(GxString& path, GX_CSTR resourcePath);
#endif  // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    u32                     _finalizedDataSize;     
    void*                   _pFinalizedData;        
 
    GxHeader*               _pHeader;               
    GX_CHAR*                _pStringTable;          
    u16*                    _pJointIndexTable;      
    GxJoint*                _pJoint;                
    GxMatrixAffine*         _pOrientMatrix;         
    GxMatrixAffine*         _pInversMatrix;         
    u32*                    _pDestructionPartsCount;    
    GxMesh*                 _pMesh;                 
    GxMeshGroup*            _pMeshGroup;            
    GxCriticalSection       _materialCriticalSection;   
    b32                     _enableRemapVertexBuffer;   
#if GX_DEVELOP
    GxImportSetting         _importSetting;         
#endif //GX_DEVELOP
 
};
 
GX_CORE_NAMESPACE_END()