GxColladaReader.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
#if GX_DEVELOP
 
GX_CORE_NAMESPACE_BEGIN()
 
// COLLADAファイル読み込み解析通知基底クラス宣言
class GxColladaReaderNotifierBase;
 
//===========================================================================
//===========================================================================
class GxColladaReader : public GxXmlReader
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxColladaReader, GxXmlReader)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxColladaReader)
 
    
    enum class ROTATE_ORDER_SHIFT
    {
        _1 = 0x0,                           
        _2 = 0x4,                           
        _3 = 0x8                            
    };
 
    enum class ROTATE_ORDER_VALUE
    {
        NONE = 0,                           
        X,                                  
        Y,                                  
        Z                                   
    };
 
    enum class ROTATE_ORDER_TYPE
    {
        NONE = 0x0000,                      
        XYZ  = 0x0321,                      
        XZY  = 0x0231,                      
        YXZ  = 0x0312,                      
        YZX  = 0x0132,                      
        ZXY  = 0x0213,                      
        ZYX  = 0x0123                       
    };
 
protected:
    static GX_CCHAR     COLLADA_DATA_DELIMITER      = ' ';      
 
    struct MaterialTable
    {
        GX_CSTR                     _pSymbol;                   
        u32                         _materialId;                
    };
 
    struct SkinTable
    {
        GX_CSTR                     _pName;                     
        u32                         _shapeId;                   
    };
 
public:
    struct GxColladaCommonAsset
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        enum class METER_TYPE
        {
            METER = 0,                              
            CENTI,                                  
 
            MAX                                     
        };
 
        enum class AXIS_TYPE
        {
            X_UP = 0,                               
            Y_UP,                                   
            Z_UP,                                   
 
            MAX                                     
        };
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        GxColladaCommonAsset(void)
            : _meterValue(1.0f)
            , _meterType(METER_TYPE::METER)
            , _axisType(AXIS_TYPE::X_UP)
        {}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        f32                         _meterValue;                
        METER_TYPE                  _meterType;                 
        AXIS_TYPE                   _axisType;                  
 
    };
 
    struct GxColladaCamera
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxColladaCamera(void)
            : _yfov(0.0f)
            , _aspect(0.0f)
            , _znear(0.0f)
            , _zfar(0.0f)
        {}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        f32                         _yfov;                      
        f32                         _aspect;                    
        f32                         _znear;                     
        f32                         _zfar;                      
 
    };
 
    struct GxColladaTexture
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxColladaTexture(void)
            : _pFilePath(nullptr)
        {}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GX_CSTR                     _pFilePath;                 
 
    };
 
    struct GxColladaRootNode
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxColladaRootNode(void)
            : _matrix(GxMatrix44::IDENTITY)
            , _translate(GxVector3::ZERO)
            , _rotate(GxVector3::ZERO)
            , _orient(GxVector3::ZERO)
            , _scale(GxVector3::ONE)
            , _rotateOrderType(GxColladaReader::ROTATE_ORDER_TYPE::NONE)
            , _orientOrderType(GxColladaReader::ROTATE_ORDER_TYPE::NONE)
        {}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxMatrix44                          _matrix;            
        GxVector3                           _translate;         
        GxVector3                           _rotate;            
        GxVector3                           _orient;            
        GxVector3                           _scale;             
        GxColladaReader::ROTATE_ORDER_TYPE  _rotateOrderType;   
        GxColladaReader::ROTATE_ORDER_TYPE  _orientOrderType;   
 
    };
 
    struct GxColladaJoint
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        static constexpr u32 ROTATE_NUM = 3;
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxColladaJoint(void)
            : _pName(nullptr)
            , _myId(GX_INVALID_HANDLE)
            , _parentId(GX_INVALID_HANDLE)
            , _matrix(GxMatrix44::IDENTITY)
            , _translate(GxVector3::ZERO)
            , _rotate(GxVector3::ZERO)
            , _orient(GxVector3::ZERO)
            , _scale(GxVector3::ONE)
            , _rotateOrderType(ROTATE_ORDER_TYPE::NONE)
            , _orientOrderType(ROTATE_ORDER_TYPE::NONE)
        {}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GX_CSTR                             _pName;             
        u32                                 _myId;              
        u32                                 _parentId;          
        GxMatrix44                          _matrix;            
        GxVector3                           _translate;         
        GxVector3                           _rotate;            
        GxVector3                           _orient;            
        GxVector3                           _scale;             
        GxColladaReader::ROTATE_ORDER_TYPE  _rotateOrderType;   
        GxColladaReader::ROTATE_ORDER_TYPE  _orientOrderType;   
 
    };
 
    //---- パーツ情報
 
    struct GxColladaParts
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxColladaParts(void)
            : _pName(nullptr)
            , _shapeId(GX_INVALID_HANDLE)
            , _partsId(0xFFFF)
            , _lodMask(0xFFFF)
        {}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GX_CSTR                     _pName;                     
        u32                         _shapeId;                   
        u16                         _partsId;                   
        u16                         _lodMask;                   
 
    };
 
    static constexpr u32 DESTRUCTION_PARTS_MAX = 256;
 
    struct GxColladaWeight
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        static constexpr u32 EFFECT_JOINT_NUM = 4;
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxColladaWeight(void)
            : _count(0)
        {
            GX_MEMSET(_joint, 0xFFFFFFF, sizeof(_joint));
            GX_MEMSET(_weight, 0, sizeof(_weight));
        }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        u32                         _count;                     
        u32                         _joint[EFFECT_JOINT_NUM];   
        f32                         _weight[EFFECT_JOINT_NUM];  
 
    };
 
    struct GxColladaBindMatrix
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
        
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxColladaBindMatrix(void)
            : _matrix(GxMatrix44::IDENTITY)
            , _joint(0)
        {}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxMatrix44                  _matrix;                    
        u32                         _joint;                     
 
    };
 
    struct GxColladaSkin
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxColladaSkin(void)
            : _shapeId(0)
            , _bindShapeMatrix(GxMatrix44::IDENTITY)
            , _pBindPoseMatrixArray(nullptr)
            , _bindPoseMatrixCount(0)
            , _pWeightArray(nullptr)
            , _weightCount(0)
        {
        }
        ~GxColladaSkin(void)
        {
            GX_SAFE_DELETE_ARRAY(_pWeightArray);
            GX_SAFE_DELETE_ARRAY(_pBindPoseMatrixArray);
        }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        u32                         _shapeId;                   
        GxMatrix44                  _bindShapeMatrix;           
        GxColladaBindMatrix*        _pBindPoseMatrixArray;      
        u32                         _bindPoseMatrixCount;       
        GxColladaWeight*            _pWeightArray;              
        u32                         _weightCount;               
 
    };
 
    //---- ジオメトリ情報
 
    struct GxColladaTriangleElement
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    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:
        GxColladaTriangleElement(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 GxColladaTriangles
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxColladaTriangles(void)
            : _materialId(0)
            , _triangleCount(0)
            , _pTriangleElementArray(nullptr)
            , _triangleElementCount(0)
            , _pPrimitiveArray(nullptr)
            , _primitiveCount(0)
            , _primitiveOneSize(0)
        {
        }
        ~GxColladaTriangles(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(GxColladaTriangleElement::VERTICES_ELEMENT elementType) const
        {
            for( u32 i=0; i < _triangleElementCount; ++i )
            {
                if( _pTriangleElementArray[i]._type == elementType )
                {
                    return i;
                }
            }
            return -1;
        }
        const GxColladaTriangleElement* getTriangleElement(GX_CSTR elementName) const
        {
            s32 index = getTriangleElementIndex(elementName);
            if( index < 0 )
            {
                return nullptr;
            }
            else
            {
                return &_pTriangleElementArray[index];
            }
        }
        const GxColladaTriangleElement* getTriangleElement(GxColladaTriangleElement::VERTICES_ELEMENT elementType) const
        {
            s32 index = getTriangleElementIndex(elementType);
            if( index < 0 )
            {
                return nullptr;
            }
            else
            {
                return &_pTriangleElementArray[index];
            }
        }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        u32                         _materialId;                
        u32                         _triangleCount;             
        GxColladaTriangleElement*   _pTriangleElementArray;     
        u32                         _triangleElementCount;      
        u32*                        _pPrimitiveArray;           
        u32                         _primitiveCount;            
        u32                         _primitiveOneSize;          
 
    };
 
    struct GxColladaColor
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxColladaColor(void)
            : _pValueArray(nullptr)
            , _valueCount(0)
        {
        }
        ~GxColladaColor(void)
        {
            GX_SAFE_FREE_MEMORY(_pValueArray);
        }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxColorHDR*                 _pValueArray;               
        u32                         _valueCount;                
 
    };
 
    struct GxColladaTexcoord
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxColladaTexcoord(void)
            : _pValueArray(nullptr)
            , _valueCount(0)
        {
        }
        ~GxColladaTexcoord(void){ GX_SAFE_FREE_MEMORY(_pValueArray); }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxVector2*                  _pValueArray;               
        u32                         _valueCount;                
 
    };
 
    struct GxColladaTexTangent
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxColladaTexTangent(void)
            : _pValueArray(nullptr)
            , _valueCount(0)
        {}
 
        ~GxColladaTexTangent(void){ GX_SAFE_FREE_MEMORY(_pValueArray); }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxVector3*                  _pValueArray;               
        u32                         _valueCount;                
 
    };
 
    struct GxColladaTexBinormal
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxColladaTexBinormal(void)
            : _pValueArray(nullptr)
            , _valueCount(0)
        {}
        ~GxColladaTexBinormal(void){ GX_SAFE_FREE_MEMORY(_pValueArray); }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxVector3*                  _pValueArray;               
        u32                         _valueCount;                
 
    };
 
    struct GxColladaGeometry
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxColladaGeometry(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)
        {}
 
        ~GxColladaGeometry(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 GxColladaTriangleElement* getTriangleElement(GX_CSTR elementName) const
        {
            for( u32 i = 0; i < _trianglesCount; ++i )
            {
                const auto* pColladaTriangleElement = _pTrianglesArray[i].getTriangleElement(elementName);
                if( pColladaTriangleElement )
                {
                    return pColladaTriangleElement;
                }
            }
            return nullptr;
        }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxColladaTriangles*         _pTrianglesArray;           
        u32                         _trianglesCount;            
        GxVector3*                  _pPositionArray;            
        u32                         _positionCount;             
        GxVector3*                  _pNormalArray;              
        u32                         _normalCount;               
        GxColladaColor*             _pColorArray;               
        u8                          _colorCount;                
        GxColladaTexcoord*          _pTexcoordArray;            
        u8                          _texcoordCount;             
        GxColladaTexTangent*        _pTexTangentArray;          
        u8                          _texTangentCount;           
        GxColladaTexBinormal*       _pTexBinormalArray;         
        u8                          _texBinormalCount;          
 
    };
 
    struct GxColladaMaterialParameter
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    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:
        GxColladaMaterialParameter(void)
            : _pRef(nullptr)
            , _type(PARAMETER_TYPE::UNKNOWN)
            , _int(0)
            , _float(0.f)
        {}
 
        ~GxColladaMaterialParameter(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 GxColladaMaterialExtra
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxColladaMaterialExtra(void)
            : _hitFlag(0)
            , _hitMaterial(0)
        {}
        ~GxColladaMaterialExtra(void){}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        u32                         _hitFlag;                   
        s32                         _hitMaterial;               
 
    };
 
    struct GxColladaMaterial
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxColladaMaterial(void)
            : _pTechniqueHintArray(nullptr)
            , _techniqueHintCount(0)
            , _pSetParameterArray(nullptr)
            , _setParameterCount(0)
            , _pExtraData(nullptr)
        {}
 
        ~GxColladaMaterial(void)
        {
            GX_SAFE_FREE_MEMORY(_pTechniqueHintArray);
            GX_SAFE_DELETE_ARRAY(_pSetParameterArray);
            GX_SAFE_DELETE(_pExtraData);
        }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GX_CSTR*                    _pTechniqueHintArray;       
        u32                         _techniqueHintCount;        
        GxColladaMaterialParameter* _pSetParameterArray;        
        u32                         _setParameterCount;         
        GxColladaMaterialExtra*     _pExtraData;                
 
    };
 
    struct GxColladaUVEffect
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        static constexpr u32 NUM_UVEFFECT_STAGES = 16;
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxColladaUVEffect(void)
        {
            for ( s32 i = 0; i < static_cast<s32>(NUM_UVEFFECT_STAGES); i ++ )
            {
                _repeatUV[i] = GxVector2::ONE;
                _offsetUV[i] = GxVector2::ZERO;
                _rotateUV[i] = 0.f;
            }
        }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxVector2               _repeatUV[NUM_UVEFFECT_STAGES];     
        GxVector2               _offsetUV[NUM_UVEFFECT_STAGES];     
        f32                     _rotateUV[NUM_UVEFFECT_STAGES];     
 
    };
 
    struct GxColladaEffect
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        struct Texture
        {
            //-----------------------------------------------------------
            //-----------------------------------------------------------
        public:
            Texture(void)
                : _pTexcoordName(nullptr)
                , _repeatUV(1.f,1.f)
                , _offsetUV(0.f,0.f)
                , _rotateUV(0.f)
            {}
 
            //-----------------------------------------------------------
            //-----------------------------------------------------------
        public:
            GX_CSTR                 _pTexcoordName;             
            GxVector2               _repeatUV;                  
            GxVector2               _offsetUV;                  
            f32                     _rotateUV;                  
 
        };
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxColladaEffect(void)
            : _pEffectTextureArray(nullptr)
            , _effectTextureCount(0)
        {}
        ~GxColladaEffect(void){ GX_SAFE_DELETE_ARRAY(_pEffectTextureArray); }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        Texture*                _pEffectTextureArray;               
        u32                     _effectTextureCount;                
 
    };
 
    struct GxColladaAnimationTangentKey
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxVector3                   _vector0;                       
        GxVector3                   _vector1;                       
 
    };
 
    struct GxColladaAnimations
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        enum class ANIMATION_ELEMENT
        {
            INVALID = -1,                   
            INPUT = 0,                      
            OUTPUT,                         
            INTANGENT,                      
            OUTTANGENT,                     
            INTERPOLATION,                  
 
            MAX                             
        };
 
        enum class OUTPUT_TYPE
        {
            FLOAT = 0,                      
            VECTOR2,                        
            VECTOR3,                        
            VECTOR4                         
        };
 
        enum class INTERPOLATION_TYPE
        {
            LINEAR = 0,                     
            BEZIER,                         
            HELMITE,                        
            CARDINAL,                       
            BSPLINE,                        
            STEP,                           
            NURBS                           
        };
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxColladaAnimations(void)
            : _pName(nullptr)
            , _keyCount(0)
            , _outputType(OUTPUT_TYPE::FLOAT)
            , _pInputKeyArray(nullptr)
            , _pOutputKeyArray(nullptr)
            , _pInTangentKeyArray(nullptr)
            , _pOutTangentKeyArray(nullptr)
            , _pInterpolationKeyArray(nullptr)
        {}
        ~GxColladaAnimations(void)
        {
            GX_SAFE_FREE_MEMORY(_pInputKeyArray);
            GX_SAFE_FREE_MEMORY(_pOutputKeyArray);
            GX_SAFE_DELETE_ARRAY(_pInTangentKeyArray);
            GX_SAFE_DELETE_ARRAY(_pOutTangentKeyArray);
            GX_SAFE_FREE_MEMORY(_pInterpolationKeyArray);
        }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GX_CSTR                         _pName;                     
        u32                             _keyCount;                  
        OUTPUT_TYPE                     _outputType;                
 
        f32*                            _pInputKeyArray;            
        void*                           _pOutputKeyArray;           
        GxColladaAnimationTangentKey*   _pInTangentKeyArray;        
        GxColladaAnimationTangentKey*   _pOutTangentKeyArray;       
        INTERPOLATION_TYPE*             _pInterpolationKeyArray;    
 
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxColladaReader(void);
    ~GxColladaReader(void) override;
 
    b32 initialize(GxStream& stream, GxColladaReaderNotifierBase* pNotifier = nullptr);
    void terminate(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    b32 read(void);
 
protected:
    virtual b32 analyseCollada(const GxXmlParser* pXmlParser);
    virtual b32 analyseCustom(const GxXmlParser* pXmlParser);
 
    virtual b32 analyseCommonAsset(const GxXmlParser::GxNode* pNode);
    virtual b32 analyseLibraryCameras(const GxXmlParser::GxNode* pNode);
    virtual b32 analyseLibraryImages(const GxXmlParser::GxNode* pNode);
    virtual b32 analyseLibraryVisualScenesJoint(const GxXmlParser::GxNode* pNode);
    virtual b32 analyseLibraryMaterials(const GxXmlParser::GxNode* pNode);
    virtual b32 analyseLibraryEffects(const GxXmlParser::GxNode* pNode);
    virtual b32 analyseLibraryVisualScenesBindMaterial(const GxXmlParser::GxNode* pNode);
    virtual b32 analyseLibraryGeometories(const GxXmlParser::GxNode* pNode);
    virtual b32 analyseLibraryControllers(const GxXmlParser::GxNode* pNode);
    virtual b32 analyseLibraryVisualScenesParts(const GxXmlParser::GxNode* pNode);
    virtual b32 analyseLibraryAnimations(const GxXmlParser::GxNode* pNode);
 
    virtual b32 analyseLibraryMaterialSubRoutineTechniqueHint(GxColladaMaterial* pColladaMaterial, const GxXmlParser::GxNode*& pNodeTechniqueHint);
    virtual b32 analyseLibraryMaterialSubRoutineSetParam(GxColladaMaterial* pColladaMaterial, const GxXmlParser::GxNode*& pNodeSetParam);
    virtual b32 analyseLibraryMaterialSubRoutineExtra(GxColladaMaterial* pColladaMaterial, const GxXmlParser::GxNode* pNodeExtra);
    virtual b32 analyseLibraryGeometrySubRoutineMesh(GxColladaGeometry* pColladaGeometry, const GxXmlParser::GxNode* pNodeMesh);
    virtual b32 analyseLibraryVisualScenesSubRoutineRootNode(const GxXmlParser::GxNode* pNodeRoot);
    virtual b32 analyseLibraryVisualScenesSubRoutineJoint(const GxXmlParser::GxNode* pNodeJoint, u32 parentId = GX_INVALID_HANDLE);
    virtual b32 analyseLibraryVisualScenesSubRoutineParts(GxColladaParts* pColladaParts, const GxXmlParser::GxNode* pNodeParts, u16 partsId, u16 lodMask);
 
    static s32 checkPartsKeyWord(GX_CSTR src);
    static s32 checkLODKeyWord(GX_CSTR src);
    static s32 checkHavokKeyWord(GX_CSTR src);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE const GxColladaCommonAsset* getCommonAsset(void) const { return &_commonData; };        
 
    constexpr GxColladaCamera* getCameraArray(void) const { return _pCameraData; };
    constexpr u32 getCameraCount(void) const { return _cameraCount; };
 
    constexpr GxColladaTexture* getTextureArray(void) const { return _pTextureData; }
    constexpr u32 getTextureCount(void) const { return _textureCount; }
 
    constexpr GxColladaMaterial* getMaterialArray(void) const { return _pMaterialData; }
    constexpr u32 getMaterialCount(void) const { return _materialCount; }
    constexpr GxColladaMaterial* getMaterialData(u32 id) const { return _pMaterialData ? &_pMaterialData[id] : nullptr; }
    constexpr GxColladaMaterial* getMaterialData(GX_CSTR name) const { return getMaterialData(getMaterialId(name)); }
    constexpr GX_CSTR getMaterialName(u32 id) const { return _pMaterialTable ? _pMaterialTable[id] : nullptr; }
    constexpr GX_CSTR getMaterialName(const GxColladaTriangles& triangles) const { return getMaterialName(triangles._materialId); }
 
    constexpr GxColladaGeometry* getGeometryArray(void) const { return _pGeometryData; }
    constexpr u32 getGeometryCount(void) const { return _geometryCount; }
 
    GX_FORCE_INLINE const GxColladaRootNode* getRootNode(void) const { return &_rootNodeData; }
 
    constexpr GxColladaJoint* getJointArray(void) const { return _pJointData; }
    constexpr u32 getJointCount(void) const { return _jointCount; }
 
    constexpr GxColladaSkin* getSkinArray(void) const { return _pSkinData; }
    constexpr u32 getSkinCount(void) const { return _skinCount; }
 
    constexpr GxColladaParts* getPartsArray(void) const { return _pPartsData; }
    constexpr u32 getPartsCount(void) const { return _partsCount; }
 
    constexpr GxColladaAnimations* getAnimationArray(void) const { return _pAnimationData; }
    constexpr u32 getAnimationCount(void) const { return _animationCount; }
 
    constexpr u32* getDestructionPartsCount(void) const { return _pDestructionPartsCount; }
 
protected:
    u32 getCameraId(GX_CSTR cameraName)                 const;
    u32 getTextureId(GX_CSTR textureName)               const;
    u32 getMaterialId(GX_CSTR materialName)             const;
    u32 getMaterialIdBySymbol(GX_CSTR materialSymbol)   const;
    u32 getShapeId(GX_CSTR shapeName)                   const;
    u32 getShapeIdBySkinName(GX_CSTR skinName)          const;
    u32 getJointIdBySymbol(GX_CSTR jointSymbol)         const;
    u32 getAnimationId(GX_CSTR animationName)           const;
 
    //---- GxColladaUVEffect用
 
    void setColladaUVEffect(u32 mateIndex, GX_CSTR semaName, GX_CSTR inputSet);
    b32 getUVEffectById(u32 mateIndex, u32 inputSet, GxVector2& retRepeatUV, GxVector2& outOffsetUV, f32& outRotateUV) const;
 
    static void getColladaAnimationTangentKeyFromXmlData(GxColladaAnimationTangentKey* pDst, GX_CSTR src, u32 count = 1);
    static GxColladaMaterialParameter::FILTER_TYPE getFilterType(GX_CSTR filterName);
    static b32 isJointNode(const GxXmlParser::GxNode* pNodeJoint);
    static GX_CSTR getLastWord(GX_CSTR src);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxXmlParser*                    _pXmlParser;                
    GxColladaReaderNotifierBase*    _pNotifier;                 
 
    GX_CSTR*                        _pCameraTable;              
    GX_CSTR*                        _pTextureTable;             
    GX_CSTR*                        _pMaterialTable;            
    GX_CSTR*                        _pMaterialSymbolTable;      
    GX_CSTR*                        _pMaterialInsEffectTable;   
    GX_CSTR*                        _pEffectTable;              
    GX_CSTR*                        _pShapeTable;               
    SkinTable*                      _pSkinTable;                
    GX_CSTR*                        _pJointSubIdTable;          
    GX_CSTR*                        _pAnimationTable;           
    
    GxColladaCommonAsset            _commonData;                
    GxColladaCamera*                _pCameraData;               
    GxColladaTexture*               _pTextureData;              
    GxColladaMaterial*              _pMaterialData;             
    GxColladaEffect*                _pEffectData;               
    GxColladaUVEffect*              _pUVEffectData;             
    GxColladaGeometry*              _pGeometryData;             
    GxColladaSkin*                  _pSkinData;                 
    GxColladaRootNode               _rootNodeData;              
    GxColladaJoint*                 _pJointData;                
    GxColladaParts*                 _pPartsData;                
    GxColladaAnimations*            _pAnimationData;            
    u32*                            _pDestructionPartsCount;    
 
    u32                             _cameraCount;               
    u32                             _textureCount;              
    u32                             _materialCount;             
    u32                             _effectCount;               
    u32                             _geometryCount;             
    u32                             _skinCount;                 
    u32                             _jointCount;                
    u32                             _partsCount;                
    u32                             _animationCount;            
 
    u32                             _jointIndex;                
 
};
 
//===========================================================================
//===========================================================================
class GxColladaReaderNotifierBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP)
 
public:
    struct GxColladaCommonAssetCallback
    {
        GxColladaReader::GxColladaCommonAsset   _commonAsset;       
    };
 
    struct GxColladaCameraCallback
    {
        GxColladaReader::GxColladaCamera*       _pCameraArray;      
        u32                                     _cameraCount;       
    };
 
    struct GxColladaTextureCallback
    {
        GxColladaReader::GxColladaTexture*      _pTextureArray;     
        u32                                     _textureCount;      
    };
 
    struct GxColladaMaterialCallback
    {
        GxColladaReader::GxColladaMaterial*     _pMaterialArray;    
        u32                                     _materialCount;     
    };
 
    struct GxColladaGeometryCallback
    {
        GxColladaReader::GxColladaGeometry*     _pGeometryArray;    
        u32                                     _geometryCount;     
    };
 
    struct GxColladaRootNodeCallback
    {
        GxColladaReader::GxColladaRootNode*     _pRootNode;         
    };
 
    struct GxColladaJointCallback
    {
        GxColladaReader::GxColladaJoint*        _pJointArray;       
        u32                                     _jointCount;        
    };
 
    struct GxColladaSkinCallback
    {
        GxColladaReader::GxColladaSkin*         _pSkinArray;        
        u32                                     _skinCount;         
    };
 
    struct GxColladaPartsCallback
    {
        GxColladaReader::GxColladaParts*        _pPartsArray;           
        u32                                     _partsCount;            
        u32                                     _destructionMeshCount;  
        u32                                     _normalPartsCount;      
    };
 
    struct GxColladaAnimationCallback
    {
        GxColladaReader::GxColladaAnimations*   _pAnimationArray;   
        u32                                     _animationCount;    
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
public:
    GxColladaReaderNotifierBase(void){}
    virtual ~GxColladaReaderNotifierBase(void){}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    /* ※下記記述順序はコールバック発生順序を表す */
 
    virtual void onColladaCommonAsset(const GxColladaCommonAssetCallback& /*value*/)    {}
    virtual void onColladaCamera(const GxColladaCameraCallback& /*value*/)              {}
    virtual void onColladaTexture(const GxColladaTextureCallback& /*value*/)            {}
    virtual void onColladaRootNode(const GxColladaRootNodeCallback& /*value*/)          {}
    virtual void onColladaJoint(const GxColladaJointCallback& /*value*/)                {}
    virtual void onColladaMaterial(const GxColladaMaterialCallback& /*value*/)          {}
    virtual void onColladaGeometry(const GxColladaGeometryCallback& /*value*/)          {}
    virtual void onColladaSkin(const GxColladaSkinCallback& /*value*/)                  {}
    virtual void onColladaParts(const GxColladaPartsCallback& /*value*/)                {}
    virtual void onColladaAnimation(const GxColladaAnimationCallback& /*value*/)        {}
 
    // COLLADA解析結果TTY出力処理 (デバッグ用)
    static void printColladaCommonAsset(const GxColladaCommonAssetCallback& value);
    static void printColladaCamera(const GxColladaCameraCallback& value);
    static void printColladaTexture(const GxColladaTextureCallback& value);
    static void printColladaMaterial(const GxColladaMaterialCallback& value);
    static void printColladaGeometry(const GxColladaGeometryCallback& value);
    static void printColladaRootNode(const GxColladaRootNodeCallback& value);
    static void printColladaJoint(const GxColladaJointCallback& value);
    static void printColladaSkin(const GxColladaSkinCallback& value);
    static void printColladaParts(const GxColladaPartsCallback& value);
    static void printColladaAnimation(const GxColladaAnimationCallback& value);
 
};
 
GX_CORE_NAMESPACE_END()
 
#endif  // GX_DEVELOP