GxResMotionSequence.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_MOTION_NAMESPACE_BEGIN()
 
//===========================================================================
//===========================================================================
class GxResMotionSequence : public GxResBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI宣言
    GX_RTTI_RESOURCE_NAME( GxResMotionSequence, GxResBase, "モーションシーケンスリソース");
    // GxClassBaseReference継承禁止処理
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResMotionSequence)
 
    
    static constexpr u32    SEQUENCE_LINE_MAX = GxMath::VALUE_32;   // GxModMotionSequence::Play::_seqがu32なので
 
    static constexpr u32    LINE_INDEX_ERROR    = 0xffffffff;
 
    struct GxFileHeader 
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxFileHeader(void) : _frameMax(0), _lineCount(0), _offsetTableOffset(0){}
        
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        constexpr u32 getFrameMax(void) const { return _frameMax; }
        constexpr u32 getLineMax(void) const { return _lineMax; }
        constexpr u32 getLineCount(void) const { return _lineCount; }
        constexpr u32 getOffsetTableOffset(void) const { return _offsetTableOffset; }
 
#if GX_DEVELOP
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        constexpr void setFrameMax(u32 frameMax){ _frameMax = frameMax; }
        constexpr void setLineMax(u32 lineMax){ _lineMax = lineMax; }
        constexpr void setLineCount(u32 lineCount){ _lineCount = lineCount; }
        constexpr void setOffsetTableOffset(u32 offsetTableOffset){ _offsetTableOffset = offsetTableOffset; }
 
#endif
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    private:
        u32     _frameMax;                          
        u32     _lineMax;                           
        u32     _lineCount;                         
        u32     _offsetTableOffset;                 
 
    };
 
    struct GxDataHeader
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxDataHeader(void) : _lineNumber(0), _param(0), _dataSize(0) {}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        constexpr u32 getLineNumber(void) const { return _lineNumber; }
        constexpr u32 getParam(void) const { return _param; }
        constexpr u32 getParam0(void) const { return _param0; }
        constexpr u32 getParam1(void) const { return _param1; }
        constexpr u32 getParam2(void) const { return _param2; }
        constexpr u32 getParam3(void) const { return _param3; }
        constexpr u32 getDataSize(void) const { return _dataSize; }
 
#if GX_DEVELOP
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        constexpr void setLineNumber(u32 lineNumber){ _lineNumber = lineNumber; }
        constexpr void setParam(u32 param){ _param = param; }
        constexpr void setDataSize(u32 dataSize){ _dataSize = dataSize; }
 
#endif //GX_DEVELOP
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    private:
        u32     _lineNumber;            
 
        union 
        {
            u32     _param;             
            struct
            {
#if GX_BITFIELD_LITTLEENDIAN
                    u32 _param0 : 8;    
                    u32 _param1 : 8;    
                    u32 _param2 : 8;    
                    u32 _param3 : 8;    
#else //GX_BITFIELD_LITTLEENDIAN
                    u32 _param3 : 8;    
                    u32 _param2 : 8;    
                    u32 _param1 : 8;    
                    u32 _param0 : 8;    
#endif // !GX_BITFIELD_LITTLEENDIAN
            };
        };
        u32     _dataSize;              
 
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxResMotionSequence(void);
    void cleanup(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    constexpr u32 getFrameMax(void) const { if( !_pFileHeader ){ return 0; } return _pFileHeader->getFrameMax(); }
    constexpr u32 getLineMax(void) const { if (!_pFileHeader){ return 0; } return _pFileHeader->getLineMax(); }
    constexpr u32 getLineCount(void) const { if( !_pFileHeader ){ return 0; } return _pFileHeader->getLineCount(); }
    const GxDataHeader* getDataHeader(u32 lineIndex) const;
    const s32* getDataAddress(u32 lineIndex) const;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    b32 load(GxStream& stream, u32 dataSize);
#if GX_DEVELOP
    b32 save(GxStream& out);
#endif //GX_DEVELOP
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void*               _pBuffer;           
    u32                 _bufferSize;        
    GxFileHeader const* _pFileHeader;       
    u32 const *         _pOffsetTable;      
 
};
 
#if GX_DEVELOP
 
//===========================================================================
//===========================================================================
class GxResMotionSequenceXml : public GxResMotionSequence
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI宣言
    GX_RTTI_RESOURCE_NAME(GxResMotionSequenceXml, GxResMotionSequence, "モーションシーケンスXML");
    // GxClassBaseReference継承禁止処理
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResMotionSequenceXml)
 
    
    struct GxLineData : public GxClassBase
    {
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    public:
        // RTTI宣言
        GX_RTTI_CLASS(GxResMotionSequenceXml::GxLineData, GxClassBase)
 
        
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        GxLineData(void);
 
        ~GxLineData(void) override;
 
        static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index = 0);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        constexpr u32 getFrameMax(void) const { return _frameMax; }
 
        constexpr u32 getFrameCount(void) const { return _frameMax + 1; }
 
        void setFrameMax(u32 frameMax);
 
        GX_FORCE_INLINE void setFrameCount(u32 frameCount) { if (frameCount) { setFrameMax(frameCount - 1); } else { setFrameMax(0); } }
 
        void getSequence(void* pValue, u32 index);
 
        void setSequence(const void* pValue, u32 index);
        void switchSequence(u32 index);
 
        void clear(void);
 
        constexpr void setLineNumber(u32 lineNumber) { _lineNumber = lineNumber; }
 
        constexpr u32 getLineNumber(void) const { return _lineNumber; }
 
        constexpr u32 getParam(void) { return _param; }
 
        constexpr void setParam0(void* pValue) { _param0 = *static_cast<u32*>(pValue); }
        constexpr void setParam1(void* pValue) { _param1 = *static_cast<u32*>(pValue); }
        constexpr void setParam2(void* pValue) { _param2 = *static_cast<u32*>(pValue); }
        constexpr void setParam3(void* pValue) { _param3 = *static_cast<u32*>(pValue); }
 
        constexpr void getParam0(const void* pValue) { *static_cast<u32*>(const_cast<void*>(pValue)) = _param0; }
        constexpr void getParam1(const void* pValue) { *static_cast<u32*>(const_cast<void*>(pValue)) = _param1; }
        constexpr void getParam2(const void* pValue) { *static_cast<u32*>(const_cast<void*>(pValue)) = _param2; }
        constexpr void getParam3(const void* pValue) { *static_cast<u32*>(const_cast<void*>(pValue)) = _param3; }
 
#if MOVE_SEQNAME_TO_SEQUENCEXML
        GX_FORCE_INLINE GxString getSequenceName(void) { return _seqName; }
        GX_FORCE_INLINE void setSequenceName(GX_CSTR name) { _seqName = name; }
#endif //MOVE_SEQNAME_TO_SEQUENCEXML
 
        u32 calcSequenceSize(void);
 
        constexpr u32 getSequenceSize(void) const { return _dataSize; }
 
        s32* writeSequence(s32* pBuffer);
#if GX_DEVELOP
        constexpr void clearData(void) { _pData = nullptr; _frameMax = 0; }
#endif //GX_DEVELOP
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    private:
        u32             _frameMax;      
        u32             _lineNumber;    
 
        union
        {
            u32         _param;         
            struct
            {
#if GX_BITFIELD_LITTLEENDIAN
                u32 _param0 : 8;    
                u32 _param1 : 8;    
                u32 _param2 : 8;    
                u32 _param3 : 8;    
#else //GX_BITFIELD_LITTLEENDIAN
                u32 _param3 : 8;    
                u32 _param2 : 8;    
                u32 _param1 : 8;    
                u32 _param0 : 8;    
#endif // !GX_BITFIELD_LITTLEENDIAN
            };
        };
        b32* _pData;            
        u32             _dataSize;      
 
#if MOVE_SEQNAME_TO_SEQUENCEXML
        GxString _seqName;              
#endif //MOVE_SEQNAME_TO_SEQUENCEXML
 
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxResMotionSequenceXml(void);
 
    void cleanup(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void setFrameMax(u32 frameMax);
 
    constexpr u32 getFrameMax(void) const { return _frameMax; }
 
    GxLineData* getLineData(u32 lineNumber);
 
    b32 getSequence(u32 lineNumber, u32 frame);
 
    void setSequence(u32 lineNumber, u32 frame, b32 value);
    void switchSequence(u32 lineNumber, u32 frame);
 
    void                            setPropertyLineData(const void* const pValue, u32 index);
    void                            getPropertyLineData(void* const pValue, u32 index);
    constexpr void                  setPropertyLineDataCount(u32 /*count*/) {}
    GX_FORCE_INLINE u32             getPropertyLineDataCount(void) { return getGxSysResource()->getMotionSequenceLineMax(); }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    u32 calcLineCount(void);
 
    u32 calcFileSize(u32 lineCount);
 
    void* buildFinalizedData(void* pBufferTop, u32 lineCount);
 
protected:
    b32 load(GxStream& in, u32 dataSize);
    b32 save(GxStream& out);
 
    b32 finalize(void);
private:
    void convertToDynamic(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxLineData  _data[SEQUENCE_LINE_MAX];   
    GxLineData** _ppDataArray;              
    GxArray _dataSurplus;                   
    u32         _frameMax;                  
 
};
 
#endif // GX_DEVELOP
 
GX_MOTION_NAMESPACE_END()