GxGmlReader.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
#if GX_DEVELOP
 
GX_UTILITY_NAMESPACE_BEGIN()
 
// GMLファイル読み込み解析通知基底クラス宣言
class GxGmlReaderNotifierBase;
 
//===========================================================================
//===========================================================================
class GxGmlReader : public GxXmlReader
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxGmlReader, GxXmlReader)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxGmlReader)
 
    
    enum class DATA_TYPE
    {
        BLDG,   
        BRID,   
        DEM,    
        TRAN,   
        VEG,    
        FRN,    
        MAX,    
    };
    static const GX_CSTR DATA_TYPE_TEXTS[static_cast<u32>(DATA_TYPE::MAX)];
 
protected:
    // protected定数定義
    static GX_CCHAR     GML_DATA_DELIMITER      = ' ';      
 
    struct MaterialTable
    {
        GX_CSTR                     _pSymbol;                   
        u32                         _materialId;                
    };
 
public:
    struct GxGmlCommonAsset
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        GxGmlCommonAsset(void) {}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        GX_FORCE_INLINE GxVector3d getCenter(void) const { return (_lowerCorner + _upperCorner) / 2; }
        GxVector3d getLowerCornerMeter(void) const;
        GxVector3d getUpperCornerMeter(void) const;
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxVector3d  _lowerCorner;   
        GxVector3d  _upperCorner;   
 
    };
 
    struct GxGmlTexture
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxGmlTexture(void) : _pFilePath(nullptr) {}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GX_CSTR _pFilePath;         
 
    };
 
    struct GxGmlParts
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxGmlParts(void)
            : _pName(nullptr)
            , _shapeId(GX_INVALID_HANDLE)
            , _partsId(0xFFFF)
            , _lodMask(0xFFFF)
        {}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GX_CSTR                     _pName;                     
        u32                         _shapeId;                   
        u16                         _partsId;                   
        u16                         _lodMask;                   
 
    };
 
    struct GxGmlTriangleElement
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
    public:
        enum class VERTICES_ELEMENT
        {
            POSITION = 0,                   
            NORMAL,                         
            COLOR,                          
            TEXCOORD,                       
            TEXTANGENT,                     
            TEXBINORMAL,                    
 
            MAX                             
        };
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxGmlTriangleElement(void)
            : _pName(nullptr)
            , _type(VERTICES_ELEMENT::POSITION)
            , _offset(0)
            , _set(0)
            , _index(0)
            , _padding(0)
        {}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GX_CSTR                     _pName;                     
        VERTICES_ELEMENT            _type;                      
        u8                          _offset;                    
        u8                          _set;                       
        u8                          _index;                     
        u8                          _padding;                   
 
    };
 
    struct GxGmlTriangles
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxGmlTriangles(void)
            : _materialId(0)
            , _triangleCount(0)
            , _pTriangleElementArray(nullptr)
            , _triangleElementCount(0)
            , _pPrimitiveArray(nullptr)
            , _primitiveCount(0)
            , _primitiveOneSize(0)
            , _kind(GxResModelGmlMeta::GxMultiSurface::KIND::INVALID)
        {
        }
        ~GxGmlTriangles(void)
        {
            GX_SAFE_DELETE_ARRAY(_pTriangleElementArray);
            GX_SAFE_FREE_MEMORY(_pPrimitiveArray);
        }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        s32 getTriangleElementIndex(GX_CSTR elementName) const
        {
            for( u32 i=0; i < _triangleElementCount; ++i )
            {
                if( (_pTriangleElementArray[i]._pName != nullptr) && (GX_STRCMP(_pTriangleElementArray[i]._pName, elementName) == 0) )
                {
                    return i;
                }
            }
            return -1;
        }
        s32 getTriangleElementIndex(GxGmlTriangleElement::VERTICES_ELEMENT elementType) const
        {
            for( u32 i=0; i < _triangleElementCount; ++i )
            {
                if( _pTriangleElementArray[i]._type == elementType )
                {
                    return i;
                }
            }
            return -1;
        }
        const GxGmlTriangleElement* getTriangleElement(GX_CSTR elementName) const
        {
            s32 index = getTriangleElementIndex(elementName);
            if( index < 0 )
            {
                return nullptr;
            }
            else
            {
                return &_pTriangleElementArray[index];
            }
        }
        const GxGmlTriangleElement* getTriangleElement(GxGmlTriangleElement::VERTICES_ELEMENT elementType) const
        {
            s32 index = getTriangleElementIndex(elementType);
            if( index < 0 )
            {
                return nullptr;
            }
            else
            {
                return &_pTriangleElementArray[index];
            }
        }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        u32                         _materialId;                
        u32                         _triangleCount;             
        GxGmlTriangleElement*       _pTriangleElementArray;     
        u32                         _triangleElementCount;      
        u32*                        _pPrimitiveArray;           
        u32                         _primitiveCount;            
        u32                         _primitiveOneSize;          
 
        GxResModelGmlMeta::GxMultiSurface::KIND _kind;          
 
    };
 
    struct GxGmlColor
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxGmlColor(void)
            : _pValueArray(nullptr)
            , _valueCount(0)
        {
        }
        ~GxGmlColor(void)
        {
            GX_SAFE_FREE_MEMORY(_pValueArray);
        }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxColorHDR*                 _pValueArray;               
        u32                         _valueCount;                
 
    };
 
    struct GxGmlTexcoord
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxGmlTexcoord(void)
            : _pValueArray(nullptr)
            , _valueCount(0)
        {
        }
        ~GxGmlTexcoord(void){ GX_SAFE_FREE_MEMORY(_pValueArray); }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxVector2*                  _pValueArray;               
        u32                         _valueCount;                
 
    };
 
    struct GxGmlTexTangent
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxGmlTexTangent(void)
            : _pValueArray(nullptr)
            , _valueCount(0)
        {}
 
        ~GxGmlTexTangent(void){ GX_SAFE_FREE_MEMORY(_pValueArray); }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxVector3*                  _pValueArray;               
        u32                         _valueCount;                
 
    };
 
    struct GxGmlTexBinormal
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxGmlTexBinormal(void)
            : _pValueArray(nullptr)
            , _valueCount(0)
        {}
        ~GxGmlTexBinormal(void){ GX_SAFE_FREE_MEMORY(_pValueArray); }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxVector3*                  _pValueArray;               
        u32                         _valueCount;                
 
    };
 
    struct GxGmlGeometry
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxGmlGeometry(void)
            : _pTrianglesArray(nullptr)
            , _trianglesCount(0)
            , _pPositionArray(nullptr)
            , _positionCount(0)
            , _pNormalArray(nullptr)
            , _normalCount(0)
            , _pColorArray(nullptr)
            , _colorCount(0)
            , _pTexcoordArray(nullptr)
            , _texcoordCount(0)
            , _pTexTangentArray(nullptr)
            , _texTangentCount(0)
            , _pTexBinormalArray(nullptr)
            , _texBinormalCount(0)
            , _kind(GxResModelGmlMeta::GxCityObject::KIND::INVALID)
        {}
 
        ~GxGmlGeometry(void)
        {
            GX_SAFE_DELETE_ARRAY(_pTrianglesArray);
            GX_SAFE_FREE_MEMORY(_pPositionArray);
            GX_SAFE_FREE_MEMORY(_pNormalArray);
            GX_SAFE_DELETE_ARRAY(_pColorArray);
            GX_SAFE_DELETE_ARRAY(_pTexcoordArray);
            GX_SAFE_DELETE_ARRAY(_pTexTangentArray);
            GX_SAFE_DELETE_ARRAY(_pTexBinormalArray);
        }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        const GxGmlTriangleElement* getTriangleElement(GX_CSTR elementName) const
        {
            for( u32 i = 0; i < _trianglesCount; ++i )
            {
                const auto* pGmlTriangleElement = _pTrianglesArray[i].getTriangleElement(elementName);
                if( pGmlTriangleElement )
                {
                    return pGmlTriangleElement;
                }
            }
            return nullptr;
        }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxGmlTriangles*         _pTrianglesArray;           
        u32                     _trianglesCount;            
        GxVector3*              _pPositionArray;            
        u32                     _positionCount;             
        GxVector3*              _pNormalArray;              
        u32                     _normalCount;               
        GxGmlColor*             _pColorArray;               
        u8                      _colorCount;                
        GxGmlTexcoord*          _pTexcoordArray;            
        u8                      _texcoordCount;             
        GxGmlTexTangent*        _pTexTangentArray;          
        u8                      _texTangentCount;           
        GxGmlTexBinormal*       _pTexBinormalArray;         
        u8                      _texBinormalCount;          
 
        GxString                                _name;      
        GxResModelGmlMeta::GxCityObject::KIND   _kind;      
 
    };
 
    struct GxGmlMaterialParameter
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        enum class PARAMETER_TYPE
        {
            UNKNOWN = -1,                       
            BOOL = 0,                           
            INT,                                
            FLOAT,                              
            FLOAT2,                             
            FLOAT3,                             
            FLOAT4,                             
            FLOAT4x4,                           
            SAMPLER_2D,                         
            SAMPLER_CUBE,                       
            SURFACE                             
        };
 
        enum class FILTER_TYPE
        {
            UNKNOWN = -1,                           
            POINT = 0,                              
            LINEAR                                  
        };
 
        struct Sampler
        {
            //-----------------------------------------------------------
            //-----------------------------------------------------------
        public:
            Sampler(void)
                : _pSurfaceName(nullptr)
                , _minFilter(FILTER_TYPE::UNKNOWN)
                , _magFilter(FILTER_TYPE::UNKNOWN)
            {}
 
            //-----------------------------------------------------------
            //-----------------------------------------------------------
        public:
            GX_CSTR                 _pSurfaceName;              
            FILTER_TYPE             _minFilter;                 
            FILTER_TYPE             _magFilter;                 
 
        };
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxGmlMaterialParameter(void)
            : _pRef(nullptr)
            , _type(PARAMETER_TYPE::UNKNOWN)
            , _int(0)
            , _float(0.f)
        {}
 
        ~GxGmlMaterialParameter(void){}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GX_CSTR                     _pRef;                      
        PARAMETER_TYPE              _type;                      
        b32                         _bool;                      
        u32                         _int;                       
        f32                         _float;                     
        GxVector2                   _float2;                    
        GxVector3                   _float3;                    
        GxVector4                   _float4;                    
        GxMatrix44                  _float4x4;                  
        Sampler                     _sampler;                   
 
    };
 
    struct GxGmlMaterialExtra
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxGmlMaterialExtra(void)
            : _hitFlag(0)
            , _hitMaterial(0)
        {}
        ~GxGmlMaterialExtra(void){}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        u32                         _hitFlag;                   
        s32                         _hitMaterial;               
 
    };
 
    struct GxGmlMaterial
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxGmlMaterial(void)
            : _pTechniqueHintArray(nullptr)
            , _techniqueHintCount(0)
            , _pSetParameterArray(nullptr)
            , _setParameterCount(0)
            , _pExtraData(nullptr)
        {}
 
        ~GxGmlMaterial(void)
        {
            GX_SAFE_FREE_MEMORY(_pTechniqueHintArray);
            GX_SAFE_DELETE_ARRAY(_pSetParameterArray);
            GX_SAFE_DELETE(_pExtraData);
        }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GX_CSTR*                _pTechniqueHintArray;       
        u32                     _techniqueHintCount;        
        GxGmlMaterialParameter* _pSetParameterArray;        
        u32                     _setParameterCount;         
        GxGmlMaterialExtra*     _pExtraData;                
 
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxGmlReader(void);
    ~GxGmlReader(void) override;
 
    b32 initialize(GxStream& stream, GxGmlReaderNotifierBase* pNotifier = nullptr);
    void terminate(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    b32 read(void);
 
protected:
    virtual b32 analyseGml(const GxXmlParser* pXmlParser);
    virtual b32 analyseCustom(const GxXmlParser* pXmlParser);
 
    virtual b32 analyseCommonAsset(const GxXmlParser::GxNode* pNode);
    b32 analyseDataType(const GxXmlParser::GxNode* pNode);
    virtual b32 analyseLibraryMaterials(const GxXmlParser::GxNode* pNode);
    virtual b32 analyseLibraryGeometories(const GxXmlParser::GxNode* pNode);
    virtual b32 analyseLibraryVisualScenesParts(const GxXmlParser::GxNode* pNode);
 
    virtual b32 analyseLibraryGeometrySubRoutineMesh(GxGmlGeometry* pGmlGeometry, const GxXmlParser::GxNode* pNodeMesh);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE const GxGmlCommonAsset* getCommonAsset(void) const { return &_commonData; };        
 
    constexpr GxGmlTexture* getTextureArray(void) const { return _pTextureData; }
    constexpr u32 getTextureCount(void) const { return _textureCount; }
 
    constexpr GxGmlMaterial* getMaterialArray(void) const { return _pMaterialData; }
    constexpr u32 getMaterialCount(void) const { return _materialCount; }
    constexpr GX_CSTR getMaterialName(u32 id) const { return _pMaterialTable ? _pMaterialTable[id] : nullptr; }
    constexpr GX_CSTR getMaterialName(const GxGmlTriangles& triangles) const { return getMaterialName(triangles._materialId); }
 
    constexpr GxGmlGeometry* getGeometryArray(void) const { return _pGeometryData; }
    constexpr u32 getGeometryCount(void) const { return _geometryCount; }
 
    constexpr GxGmlParts* getPartsArray(void) const { return _pPartsData; }
    constexpr u32 getPartsCount(void) const { return _partsCount; }
 
protected:
    u32 getShapeId(GX_CSTR shapeName) const;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxXmlParser*                _pXmlParser;                
    GxGmlReaderNotifierBase*    _pNotifier;                 
 
    DATA_TYPE                   _dataType;                  
    GX_CSTR*                    _pTextureTable;             
    GX_CSTR*                    _pMaterialTable;            
    GX_CSTR*                    _pMaterialSymbolTable;      
    GX_CSTR*                    _pMaterialInsEffectTable;   
    GX_CSTR*                    _pEffectTable;              
    GX_CSTR*                    _pShapeTable;               
    
    GxGmlCommonAsset            _commonData;                
    GxGmlTexture*               _pTextureData;              
    GxGmlMaterial*              _pMaterialData;             
    GxGmlGeometry*              _pGeometryData;             
    GxGmlParts*                 _pPartsData;                
 
    u32                         _textureCount;              
    u32                         _materialCount;             
    u32                         _effectCount;               
    u32                         _geometryCount;             
    u32                         _partsCount;                
 
};
 
//===========================================================================
//===========================================================================
class GxGmlReaderNotifierBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP)
 
public:
    struct GxGmlCommonAssetCallback
    {
        GxGmlReader::GxGmlCommonAsset   _commonAsset;       
    };
 
    struct GxGmlTextureCallback
    {
        GxGmlReader::GxGmlTexture*      _pTextureArray;     
        u32                             _textureCount;      
    };
 
    struct GxGmlGeometryCallback
    {
        GxGmlReader::GxGmlGeometry*     _pGeometryArray;    
        u32                             _geometryCount;     
    };
 
    struct GxGmlPartsCallback
    {
        GxGmlReader::GxGmlParts*        _pPartsArray;           
        u32                             _partsCount;            
        u32                             _normalPartsCount;      
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
public:
    GxGmlReaderNotifierBase(void){}
    virtual ~GxGmlReaderNotifierBase(void){}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    virtual void onGmlCommonAsset(const GxGmlCommonAssetCallback& /*value*/){}
    virtual void onGmlTexture(const GxGmlTextureCallback& /*value*/){}
    virtual void onGmlGeometry(const GxGmlGeometryCallback& /*value*/){}
    virtual void onGmlParts(const GxGmlPartsCallback& /*value*/){}
 
    // GML解析結果TTY出力処理 (デバッグ用)
    static void printGmlCommonAsset(const GxGmlCommonAssetCallback& value);
    static void printGmlTexture(const GxGmlTextureCallback& value);
    static void printGmlGeometry(const GxGmlGeometryCallback& value);
    static void printGmlParts(const GxGmlPartsCallback& value);
 
};
 
GX_UTILITY_NAMESPACE_END()
 
#endif  // GX_DEVELOP