doc/api/_gx_res_real_time_demo_8h_source.html

//===========================================================================

//===========================================================================

#pragma once


GX_UTILITY_NAMESPACE_BEGIN()


#if GX_DEVELOP

class GxRealTimeDemoEditInterface;

#endif //GX_DEVELOP


//===========================================================================

//===========================================================================


class GxResRealTimeDemo : public GxResBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI定義

    GX_RTTI_RESOURCE_NAME_ICON(GxResRealTimeDemo, GxResBase, "RTDリソース", GxRtti::ICON_TYPE::UNIT_MOVIE)

    // ClassBaseReference用禁止処理

    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxResRealTimeDemo)


    class GxRtdProp;

    class GxRtdKeyBase;

    class GxRtdKeyB32;

    class GxRtdKeyS32;

    class GxRtdKeyU32;

    class GxRtdKeyF32;

    class GxRtdKeyVector2;

    class GxRtdKeyVector3;

    class GxRtdKeyQuaternion;

    class GxRtdKeyColor;

    class GxRtdKeyColorHDR;

    class GxRtdKeyString;

    class GxRtdKeyResource;

    class GxRtdKeyEvent;

#if GX_DEVELOP

    friend class GxRealTimeDemoEditInterface;

    class GxRtdColumnMarker;

#endif


    class GxRtdUnit : public GxClassBase

    {

        //-----------------------------------------------------------

        //-----------------------------------------------------------

        friend class GxResRealTimeDemo;

    public:

        // RTTI定義

        GX_RTTI_CLASS(GxResRealTimeDemo::GxRtdUnit, GxClassBase)

        // new, delete定義

        GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::RESOURCE)


        //-----------------------------------------------------------

        //-----------------------------------------------------------

    public:

        GxRtdUnit(void);

        GxRtdUnit(u32 nodeId, GxRtti* pUnitRtti);

        ~GxRtdUnit(void) override;


        //-----------------------------------------------------------

        //-----------------------------------------------------------


        constexpr u32 getPropertyNum(void) const { return _propertyArray.getCount(); }

        GX_FORCE_INLINE void setPropertyNum(u32 num){ _propertyArray.setCount(num); }

        GX_FORCE_INLINE void getProperty(void* const pValue, u32 index){ *static_cast<GxResRealTimeDemo::GxRtdProp**>(pValue) = (_propertyArray.getCount() > index) ? reinterpret_cast<GxResRealTimeDemo::GxRtdProp*>(_propertyArray[index]) : nullptr; }

        void setProperty(const void* const pValue, u32 index);

        constexpr u32 getNodeId(void) const { return _nodeId; }

        void initializeAfterRttiLoaded(void);

#if GX_DEVELOP

        constexpr void getPropertyRttiName(void* const pValue){ *static_cast<GX_CSTR*>(pValue) = (nullptr !=_pRtti) ? _pRtti->getName() : ""; }

#endif  //GX_DEVELOP


        //-----------------------------------------------------------

        //-----------------------------------------------------------

    public:

        GxRtti*             _pRtti;

        GxArrayClassBase    _propertyArray;

        s32                 _discrimID;

        GxString            _userData;

        GxString            _type;


#if GX_DEVELOP

        GxColor             _unitRowColor;

        b32                 _guiExpand;

#endif  //GX_DEVELOP

    private:

        u32                 _nodeId;

    };


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GxResRealTimeDemo(void);

    void cleanup(void) override;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    b32 load(GxStream&, u32);

#if GX_DEVELOP

    b32 save(GxStream&);

#if GX_EDITOR

    void getToolRtti( GxArray& arrayTool ) const override;

#endif //GX_EDITOR

#endif //GX_DEVELOP


private:

    constexpr u32 newNodeId(void) { return ++_reservedNodeIdMax; }


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    constexpr u32 getStartFrame(void) const { return _startFrame; }

    constexpr u32 getEndFrame(void) const { return _endFrame; }

    constexpr u32 getSceneFPS(void) const { return _sceneFPS; }

    void getMinMaxKeyFrame(u32& minFrame, u32& maxFrame, b32 considerPlayRange = true);

    // プロパティタイプから対応するキークラスの型を取得

    static GxRtti* getKeyType(GxProperty::TYPE type);

    GX_FORCE_INLINE GxArrayClassBase* getUnitArray(void){ return &_unitArray; }

    GxRtdUnit* getUnitFromNodeId(u32 UnitNodeId);

    GxRtdProp* getPropertyFromNodeId(u32 PropNodeId);

    GxRtdProp* getPropertyFromNodeId(u32 UnitNodeId, u32 propertyNodeId);

    GxRtdProp* getPropertyFromNodeId(GxRtdUnit* pUnit, u32 propertyNodeId);

    b32 getPropertyHierarchyFromNodeId(u32 propertyNodeId, GxArrayClassBase& result);

    b32 isDescendantProperty(u32 parentPropertyNodeId, u32 descendantPropertyNodeId);

    b32 isDescendantProperty(GxRtdProp* pParentProperty, u32 descendantPropertyNodeId);

    b32 isDescendantProperty(GxRtdProp* pParentProperty, GxRtdProp* pDescendantProperty);

    b32 getPropertyParent(GxRtdUnit*& pParentUnit, GxRtdProp*& pParentProperty, u32 childPropertyNodeId);

#if GX_DEVELOP

    constexpr u32 getColumnMarkerNum(void) const { return _columnMarker.getCount(); }

    GX_FORCE_INLINE const GxRtdColumnMarker* getColumnMarkerInfo(u32 index) const { return reinterpret_cast<GxRtdColumnMarker*>(_columnMarker[index]); }

    // ColumnMarker更新

    void updateColumnMarkerInfo(void);

    // 対象フレームにColumnMarkerがあったらその文字列を取得する(なければnullptr)

    const GxString* getMarkerString(s32 frame) const;

#endif //GX_DEVELOP

private:

    void getMinMaxFrameSub(GxRtdProp* pRtdProperty, u32& minFrame, u32& maxFrame);


    constexpr u32 getPropertyNum(void) const { return _unitArray.getCount(); }

    GX_FORCE_INLINE void setPropertyNum(u32 num) { _unitArray.setCount(num); }

    GX_FORCE_INLINE void getProperty(void* const pValue, u32 index) const { *static_cast<GxResRealTimeDemo**>(pValue) = (_unitArray.getCount() > index) ? static_cast<GxResRealTimeDemo*>(_unitArray[index]) : nullptr; }

    void setProperty(const void* const pValue, u32 index);

    GxRtdProp* getPropertyFromNodeIdSub(u32 propertyNodeId, GxRtdProp* pProperty);

    b32 getPropertyHierarchyFromNodeIdSub(u32 propertyNodeId, GxRtdProp* pParentProperty, GxArrayClassBase& result);

    b32 deletePropertySub(GxRtdProp* pProperty, u32 propertyNodeId);

    b32 isDescendantPropertySub(GxRtdProp* pParentProperty, u32 descendantPropertyNodeId);

    b32 getPropertyParentSub(GxRtdProp*& pResult, u32 childPropertyNodeId, GxRtdProp* pParentProperty);

#if GX_DEVELOP

    GX_FORCE_INLINE void setColumnMarkerNum(u32 num) { _columnMarker.setCount(num); }

    void addColumnMarker(void);


    GX_FORCE_INLINE void getColumnMarker(void* const pValue, u32 index) { *static_cast<GxRtdColumnMarker**>(pValue) = (_columnMarker.getCount() > index) ? reinterpret_cast<GxRtdColumnMarker*>(_columnMarker[index]) : nullptr; }

    void setColumnMarker(const void* const pValue, u32 index);

#endif //GX_DEVELOP


    //-----------------------------------------------------------

    //-----------------------------------------------------------

protected:

    GxArrayClassBase    _unitArray;

#if GX_DEVELOP

    GxArrayClassBase    _columnMarker;

#endif //GX_DEVELOP

private:

    u32                 _startFrame;

    u32                 _endFrame;

    u32                 _sceneFPS;

    u32                 _reservedNodeIdMax;


};


//===========================================================================

//===========================================================================


class GxResRealTimeDemo::GxRtdProp  : public GxClassBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

    friend class GxResRealTimeDemo;

public:

    // RTTI定義

    GX_RTTI_CLASS(GxResRealTimeDemo::GxRtdProp, GxClassBase)

    // new, delete定義

    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::RESOURCE)


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GxRtdProp(void);

    GxRtdProp(u32 nodeId, GxProperty* pProperty, s32 arrayIndex = -1);

    ~GxRtdProp(void) override;


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    constexpr u32 getPropertyNum(void) const { return _keyArray.getCount(); }

    GX_FORCE_INLINE void setPropertyNum(u32 num){ _keyArray.setCount(num); }

    constexpr void getProperty(void* const pValue, u32 index){ *static_cast<GxRtdKeyBase**>(pValue) = (_keyArray.getCount() > index) ? reinterpret_cast<GxRtdKeyBase*>(_keyArray[index]) : nullptr; }

    void setProperty(const void* const pValue, u32 index);

    constexpr u32 getChildNum(void) const { return _childArray.getCount(); }

    GX_FORCE_INLINE void setChildNum(u32 num){ _childArray.setCount(num); }

    constexpr void getChildren(void* const pValue, u32 index){ *static_cast<GxRtdProp**>(pValue) = (_childArray.getCount() > index) ? reinterpret_cast<GxRtdProp*>(_childArray[index]) : nullptr; }

    void setChildren(const void* const pValue, u32 index);


    b32 isKeyable(void) const;

    b32 isArrayParent(void) const;

    b32 isArrayElement(void) const;


    constexpr u32 getNodeId(void) const { return _nodeId; }


    constexpr s32 getArrayIndex(void) const { return _arrayIndex; }


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

#if GX_DEVELOP

    constexpr void getPropertyPropertyName(void* const pValue){ *static_cast<GX_CSTR*>(pValue) = (nullptr !=_pProperty) ? _pProperty->getName() : ""; }

    constexpr void getPropertyRttiName(void* const pValue){ *static_cast<GX_CSTR*>(pValue) = (nullptr !=_pRtti) ? _pRtti->getName() : ""; }

#endif //GX_DEVELOP


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GxProperty* _pProperty;

    GxRtti* _pRtti;

    s32 _interpolateType;

    s32 _arrayIndex;

    GxArrayClassBase _keyArray;

    GxArrayClassBase _childArray;

#if GX_DEVELOP

    b32 _guiExpand;

#endif //GX_DEVELOP

private:

    u32 _nodeId;


};


//===========================================================================

//===========================================================================


class GxResRealTimeDemo::GxRtdKeyBase : public GxClassBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------


    friend class GxResRealTimeDemo;


public:

    // RTTI定義

    GX_RTTI_CLASS(GxResRealTimeDemo::GxRtdKeyBase, GxClassBase)

    // new, delete定義

    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::RESOURCE)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxRtdKeyBase(void) : _frame(0){}

    ~GxRtdKeyBase(void) override {}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE virtual void* getValueAddress(void){ return nullptr; }


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    u32 _frame;


};


//===========================================================================

//===========================================================================


class GxResRealTimeDemo::GxRtdKeyB32 : public GxResRealTimeDemo::GxRtdKeyBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI定義

    GX_RTTI_CLASS(GxResRealTimeDemo::GxRtdKeyB32, GxResRealTimeDemo::GxRtdKeyBase)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxRtdKeyB32(void) : _value(false){}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE void* getValueAddress(void) override { return &(_value); }

#if GX_DEVELOP

#if defined(_WINDOWS)

    constexpr void getPropertyValue(const void* pValue){ *static_cast<b32*>(const_cast<void*>(pValue)) = _value; }

    void setPropertyValue(void* pValue);

#endif //_WINDOWS

#endif //GX_DEVELOP


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    b32 _value;


};


//===========================================================================

//===========================================================================


class GxResRealTimeDemo::GxRtdKeyS32 : public GxResRealTimeDemo::GxRtdKeyBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI定義

    GX_RTTI_CLASS(GxResRealTimeDemo::GxRtdKeyS32, GxResRealTimeDemo::GxRtdKeyBase)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxRtdKeyS32(void) : _value(0){}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE void* getValueAddress(void) override { return &(_value); }

#if GX_DEVELOP

#if defined(_WINDOWS)

    constexpr void getPropertyValue(const void* pValue){ *static_cast<s32*>(const_cast<void*>(pValue)) = _value; }

    void setPropertyValue(void* pValue);

#endif //_WINDOWS

#endif //GX_DEVELOP


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    s32 _value;


};


//===========================================================================

//===========================================================================


class GxResRealTimeDemo::GxRtdKeyU32 : public GxResRealTimeDemo::GxRtdKeyBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI定義

    GX_RTTI_CLASS(GxResRealTimeDemo::GxRtdKeyU32, GxResRealTimeDemo::GxRtdKeyBase)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxRtdKeyU32(void) : _value(0){}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE void* getValueAddress(void) override { return &(_value); }

#if GX_DEVELOP

#if defined(_WINDOWS)

    constexpr void getPropertyValue(const void* pValue){ *static_cast<u32*>(const_cast<void*>(pValue)) = _value; }

    void setPropertyValue(void* pValue);

#endif //_WINDOWS

#endif //GX_DEVELOP


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    u32 _value;


};


//===========================================================================

//===========================================================================


class GxResRealTimeDemo::GxRtdKeyF32 : public GxResRealTimeDemo::GxRtdKeyBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI定義

    GX_RTTI_CLASS(GxResRealTimeDemo::GxRtdKeyF32, GxResRealTimeDemo::GxRtdKeyBase)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxRtdKeyF32(void) : _value(0.f){}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE void* getValueAddress(void) override { return &(_value); }

#if GX_DEVELOP

#if defined(_WINDOWS)

    constexpr void getPropertyValue(const void* pValue){ *static_cast<f32*>(const_cast<void*>(pValue)) = _value; }

    void setPropertyValue(void* pValue);

#endif //_WINDOWS

#endif //GX_DEVELOP


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    f32 _value;


};


//===========================================================================

//===========================================================================


class GxResRealTimeDemo::GxRtdKeyVector2 : public GxResRealTimeDemo::GxRtdKeyBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI定義

    GX_RTTI_CLASS(GxResRealTimeDemo::GxRtdKeyVector2, GxResRealTimeDemo::GxRtdKeyBase)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxRtdKeyVector2(void) {}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE void* getValueAddress(void) override { return &(_value); }

#if GX_DEVELOP

#if defined(_WINDOWS)

    constexpr void getPropertyValue(const void* pValue){ *static_cast<GxVector2**>(const_cast<void*>(pValue)) = static_cast<GxVector2*>(&_value); }

    void setPropertyValue(void* pValue);

#endif //_WINDOWS

#endif //GX_DEVELOP


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxVector2 _value;


};


//===========================================================================

//===========================================================================


class GxResRealTimeDemo::GxRtdKeyVector3 : public GxResRealTimeDemo::GxRtdKeyBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI定義

    GX_RTTI_CLASS(GxResRealTimeDemo::GxRtdKeyVector3, GxResRealTimeDemo::GxRtdKeyBase)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxRtdKeyVector3(void) {}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE void* getValueAddress(void) override { return &(_value); }

#if GX_DEVELOP

#if defined(_WINDOWS)

    constexpr void getPropertyValue(const void* pValue){ *static_cast<GxVector3**>(const_cast<void*>(pValue)) = static_cast<GxVector3*>(&_value); }

    void setPropertyValue(void* pValue);

#endif //_WINDOWS

#endif //GX_DEVELOP


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxVector3 _value;


};


//===========================================================================

//===========================================================================


class GxResRealTimeDemo::GxRtdKeyQuaternion : public GxResRealTimeDemo::GxRtdKeyBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI定義

    GX_RTTI_CLASS(GxResRealTimeDemo::GxRtdKeyQuaternion, GxResRealTimeDemo::GxRtdKeyBase)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxRtdKeyQuaternion(void) : _value(GxQuaternion::IDENTITY){}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE void* getValueAddress(void) override { return &(_value); }

#if GX_DEVELOP

#if defined(_WINDOWS)

    constexpr void getPropertyValue(const void* pValue){ *static_cast<GxQuaternion**>(const_cast<void*>(pValue)) = static_cast<GxQuaternion*>(&_value); }

    void setPropertyValue(void* pValue);

#endif //_WINDOWS

#endif //GX_DEVELOP


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxQuaternion _value;


};


//===========================================================================

//===========================================================================


class GxResRealTimeDemo::GxRtdKeyColor : public GxResRealTimeDemo::GxRtdKeyBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI定義

    GX_RTTI_CLASS(GxResRealTimeDemo::GxRtdKeyColor, GxResRealTimeDemo::GxRtdKeyBase)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxRtdKeyColor(void) : _value(GxColor::WHITE){}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE void* getValueAddress(void) override { return &(_value); }

#if GX_DEVELOP

#if defined(_WINDOWS)

    constexpr void getPropertyValue(const void* pValue){ *static_cast<GxColor**>(const_cast<void*>(pValue)) = static_cast<GxColor*>(&_value); }

    void setPropertyValue(void* pValue);

#endif //_WINDOWS

#endif //GX_DEVELOP


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxColor _value;


};


//===========================================================================

//===========================================================================


class GxResRealTimeDemo::GxRtdKeyColorHDR : public GxResRealTimeDemo::GxRtdKeyBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI定義

    GX_RTTI_CLASS(GxResRealTimeDemo::GxRtdKeyColorHDR, GxResRealTimeDemo::GxRtdKeyBase)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxRtdKeyColorHDR(void) : _value(GxColorHDR(1.f, 1.f, 1.f, 1.f)){}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE void* getValueAddress(void) override { return &(_value); }

#if GX_DEVELOP

#if defined(_WINDOWS)

    constexpr void getPropertyValue(const void* pValue){ *static_cast<GxColorHDR**>(const_cast<void*>(pValue)) = static_cast<GxColorHDR*>(&_value); }

    void setPropertyValue(void* pValue);

#endif //_WINDOWS

#endif //GX_DEVELOP


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxColorHDR _value;


};


//===========================================================================

//===========================================================================


class GxResRealTimeDemo::GxRtdKeyString : public GxResRealTimeDemo::GxRtdKeyBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI定義

    GX_RTTI_CLASS(GxResRealTimeDemo::GxRtdKeyString, GxResRealTimeDemo::GxRtdKeyBase)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxRtdKeyString(void) : _value(""){}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE void* getValueAddress(void) override { return &(_value); }

#if GX_DEVELOP

#if defined(_WINDOWS)

    void getPropertyValue(const void* pValue);

    void setPropertyValue(void* pValue);

#endif //_WINDOWS

#endif //GX_DEVELOP


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxString _value;


};


//===========================================================================

//===========================================================================


class GxResRealTimeDemo::GxRtdKeyResource : public GxResRealTimeDemo::GxRtdKeyBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI定義

    GX_RTTI_CLASS(GxResRealTimeDemo::GxRtdKeyResource, GxResRealTimeDemo::GxRtdKeyBase)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxRtdKeyResource(void) : _pRtti(nullptr){}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxString        _path;

    GxRttiResource* _pRtti;


};


//===========================================================================

//===========================================================================


class GxResRealTimeDemo::GxRtdKeyEvent : public GxResRealTimeDemo::GxRtdKeyBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI定義

    GX_RTTI_CLASS(GxResRealTimeDemo::GxRtdKeyEvent, GxResRealTimeDemo::GxRtdKeyBase)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxRtdKeyEvent(void){}


};


#if GX_DEVELOP

//===========================================================================

//===========================================================================

class GxResRealTimeDemoXml : public GxResRealTimeDemo

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI定義

    GX_RTTI_RESOURCE(GxResRealTimeDemoXml, GxResRealTimeDemo)


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GxResRealTimeDemoXml(void){}

    ~GxResRealTimeDemoXml(void) override {}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    b32 load(GxStream&, u32);

    b32 save(GxStream&);

    b32 build(void);


private:

    void convertResourceRtti(GxRtdProp* pProperty);


};


//===========================================================================

//===========================================================================

class GxRealTimeDemoEditInterface : public GxClassBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI定義

    GX_RTTI_CLASS(GxRealTimeDemoEditInterface, GxClassBase)


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GxRealTimeDemoEditInterface(void) : _pRes(nullptr){}

    GxRealTimeDemoEditInterface(GxResRealTimeDemo* pRes):_pRes(pRes){}

    ~GxRealTimeDemoEditInterface(void) override {}


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    constexpr void setResource(GxResRealTimeDemo* pRes){ _pRes = pRes; }


    GxResRealTimeDemo::GxRtdUnit* addUnit(GxRtti* pUnitType);

    void deleteUnit(u32 unitNodeId);


    GxResRealTimeDemo::GxRtdProp* addProperty(u32 unitNodeId, GxProperty* pProperty, u32 elementCount = 0);

    GxResRealTimeDemo::GxRtdProp* addPropertyChild(u32 parentPropertyNodeId, GxProperty* pProperty, u32 elementCount = 0);

    b32 setArrayPropertyElementCount(u32 propertyNodeId, u32 elementNum);

    void deleteProperty(u32 propertyNodeId);


    GxResRealTimeDemo::GxRtdKeyBase* addKey(u32 propertyNodeId, u32 frame, GxUnitBase* pOwner);

    void deleteKey(u32 propertyNodeId, u32 frame);

    GxResRealTimeDemo::GxRtdKeyBase* getKey(u32 propertyNodeId, u32 frame, GxUnitBase* pOwner);


    GxClassBaseRoot* getObjectPointerPropertyValue(GxUnitBase* pUnit, u32 propertyNodeId);


    //-----------------------------------------------------------

    //-----------------------------------------------------------

private:

    GxResRealTimeDemo::GxRtdKeyBase* createTypedKey(u32 propertyNodeId, GxUnitBase* pOwner);


    //-----------------------------------------------------------

    //-----------------------------------------------------------

private:

    GxResRealTimeDemo* _pRes;

};


//===========================================================================

//===========================================================================

class GxResRealTimeDemo::GxRtdColumnMarker : public GxClassBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI定義

    GX_RTTI_CLASS(GxResRealTimeDemo::GxRtdColumnMarker, GxClassBase)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxRtdColumnMarker(void){}


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    s32 _frame;

    GxColor _color;

    GxString _string;


};

#endif  //GX_DEVELOP


GX_UTILITY_NAMESPACE_END()

GX_PROHIBIT_CLASS_BASE_REFERENCE
#define GX_PROHIBIT_CLASS_BASE_REFERENCE(__CLASS__)
GxClassBaseReference継承の禁止宣言(new以外の生成禁止 + コピー禁止)
Definition GxBase.h:244

INIT::IDENTITY
@ IDENTITY
基礎値で初期化

RENDER_SAMPLER_BORDER_COLOR::WHITE
@ WHITE
白

GX_RTTI_RESOURCE
#define GX_RTTI_RESOURCE(__THIS__, __BASE__)
リソースクラス型情報宣言
Definition GxRttiResource.h:102

GxAllocatorList::ALLOCATOR_TYPE::RESOURCE
@ RESOURCE
リソース

GxArrayClassBase
配列クラス
Definition GxArrayClassBase.h:18

GxArrayClassBase::getCount
constexpr u32 getCount(void) const
配列数を取得
Definition GxArrayClassBase.h:109

GxArrayClassBase::setCount
void setCount(u32 count)
配列数を設定
Definition GxArrayClassBase.cpp:246

GxArray
配列クラス
Definition GxArray.h:18

GxClassBase
オブジェクト基底クラス
Definition GxBase.h:88

GxClassBaseRoot
基底クラス
Definition GxBase.h:51

GxProperty
プロパティクラス
Definition GxProperty.h:48

GxProperty::TYPE
TYPE
タイプ定義
Definition GxProperty.h:56

GxResBase
リソース基底クラス
Definition GxResBase.h:23

GxResRealTimeDemo::GxRtdKeyB32
RTD再生用キー(B32)
Definition GxResRealTimeDemo.h:405

GxResRealTimeDemo::GxRtdKeyB32::getValueAddress
GX_FORCE_INLINE void * getValueAddress(void) override
値のアドレスを取得
Definition GxResRealTimeDemo.h:430

GxResRealTimeDemo::GxRtdKeyB32::_value
b32 _value
値
Definition GxResRealTimeDemo.h:446

GxResRealTimeDemo::GxRtdKeyBase
RTD再生用キー
Definition GxResRealTimeDemo.h:356

GxResRealTimeDemo::GxRtdKeyBase::~GxRtdKeyBase
~GxRtdKeyBase(void) override
デストラクタ
Definition GxResRealTimeDemo.h:379

GxResRealTimeDemo::GxRtdKeyBase::_frame
u32 _frame
フレーム
Definition GxResRealTimeDemo.h:396

GxResRealTimeDemo::GxRtdKeyBase::getValueAddress
virtual GX_FORCE_INLINE void * getValueAddress(void)
値のアドレスを取得
Definition GxResRealTimeDemo.h:388

GxResRealTimeDemo::GxRtdKeyColorHDR
RTD再生用キー(ColorHDR)
Definition GxResRealTimeDemo.h:805

GxResRealTimeDemo::GxRtdKeyColorHDR::_value
GxColorHDR _value
値
Definition GxResRealTimeDemo.h:846

GxResRealTimeDemo::GxRtdKeyColorHDR::getValueAddress
GX_FORCE_INLINE void * getValueAddress(void) override
値のアドレスを取得
Definition GxResRealTimeDemo.h:830

GxResRealTimeDemo::GxRtdKeyColor
RTD再生用キー(Color)
Definition GxResRealTimeDemo.h:755

GxResRealTimeDemo::GxRtdKeyColor::getValueAddress
GX_FORCE_INLINE void * getValueAddress(void) override
値のアドレスを取得
Definition GxResRealTimeDemo.h:780

GxResRealTimeDemo::GxRtdKeyColor::_value
GxColor _value
値
Definition GxResRealTimeDemo.h:796

GxResRealTimeDemo::GxRtdKeyEvent
RTD再生用キー(イベント)
Definition GxResRealTimeDemo.h:939

GxResRealTimeDemo::GxRtdKeyF32
RTD再生用キー(F32)
Definition GxResRealTimeDemo.h:555

GxResRealTimeDemo::GxRtdKeyF32::_value
f32 _value
値
Definition GxResRealTimeDemo.h:596

GxResRealTimeDemo::GxRtdKeyF32::getValueAddress
GX_FORCE_INLINE void * getValueAddress(void) override
値のアドレスを取得
Definition GxResRealTimeDemo.h:580

GxResRealTimeDemo::GxRtdKeyQuaternion
RTD再生用キー(Quaternion)
Definition GxResRealTimeDemo.h:705

GxResRealTimeDemo::GxRtdKeyQuaternion::_value
GxQuaternion _value
値
Definition GxResRealTimeDemo.h:746

GxResRealTimeDemo::GxRtdKeyQuaternion::getValueAddress
GX_FORCE_INLINE void * getValueAddress(void) override
値のアドレスを取得
Definition GxResRealTimeDemo.h:730

GxResRealTimeDemo::GxRtdKeyResource
RTD再生用キー(リソース)
Definition GxResRealTimeDemo.h:905

GxResRealTimeDemo::GxRtdKeyResource::_path
GxString _path
パス
Definition GxResRealTimeDemo.h:929

GxResRealTimeDemo::GxRtdKeyResource::_pRtti
GxRttiResource * _pRtti
RTTI.
Definition GxResRealTimeDemo.h:930

GxResRealTimeDemo::GxRtdKeyS32
RTD再生用キー(S32)
Definition GxResRealTimeDemo.h:455

GxResRealTimeDemo::GxRtdKeyS32::getValueAddress
GX_FORCE_INLINE void * getValueAddress(void) override
値のアドレスを取得
Definition GxResRealTimeDemo.h:480

GxResRealTimeDemo::GxRtdKeyS32::_value
s32 _value
値
Definition GxResRealTimeDemo.h:496

GxResRealTimeDemo::GxRtdKeyString
RTD再生用キー(String)
Definition GxResRealTimeDemo.h:855

GxResRealTimeDemo::GxRtdKeyString::_value
GxString _value
値
Definition GxResRealTimeDemo.h:896

GxResRealTimeDemo::GxRtdKeyString::getValueAddress
GX_FORCE_INLINE void * getValueAddress(void) override
値のアドレスを取得
Definition GxResRealTimeDemo.h:880

GxResRealTimeDemo::GxRtdKeyU32
RTD再生用キー(U32)
Definition GxResRealTimeDemo.h:505

GxResRealTimeDemo::GxRtdKeyU32::_value
u32 _value
値
Definition GxResRealTimeDemo.h:546

GxResRealTimeDemo::GxRtdKeyU32::getValueAddress
GX_FORCE_INLINE void * getValueAddress(void) override
値のアドレスを取得
Definition GxResRealTimeDemo.h:530

GxResRealTimeDemo::GxRtdKeyVector2
RTD再生用キー(Vector2)
Definition GxResRealTimeDemo.h:605

GxResRealTimeDemo::GxRtdKeyVector2::getValueAddress
GX_FORCE_INLINE void * getValueAddress(void) override
値のアドレスを取得
Definition GxResRealTimeDemo.h:630

GxResRealTimeDemo::GxRtdKeyVector2::_value
GxVector2 _value
値
Definition GxResRealTimeDemo.h:646

GxResRealTimeDemo::GxRtdKeyVector3
RTD再生用キー(Vector3)
Definition GxResRealTimeDemo.h:655

GxResRealTimeDemo::GxRtdKeyVector3::getValueAddress
GX_FORCE_INLINE void * getValueAddress(void) override
値のアドレスを取得
Definition GxResRealTimeDemo.h:680

GxResRealTimeDemo::GxRtdKeyVector3::_value
GxVector3 _value
値
Definition GxResRealTimeDemo.h:696

GxResRealTimeDemo::GxRtdProp
RTD再生用プロパティ
Definition GxResRealTimeDemo.h:257

GxResRealTimeDemo::GxRtdProp::~GxRtdProp
~GxRtdProp(void) override
デストラクタ
Definition GxResRealTimeDemo.cpp:934

GxResRealTimeDemo::GxRtdProp::_childArray
GxArrayClassBase _childArray
子プロパティ配列
Definition GxResRealTimeDemo.h:342

GxResRealTimeDemo::GxRtdProp::isKeyable
b32 isKeyable(void) const
直接キー設定可能か判定
Definition GxResRealTimeDemo.cpp:985

GxResRealTimeDemo::GxRtdProp::setProperty
void setProperty(const void *const pValue, u32 index)
キーを設定(プロパティ用)
Definition GxResRealTimeDemo.cpp:956

GxResRealTimeDemo::GxRtdProp::_pRtti
GxRtti * _pRtti
プロパティのRTTI
Definition GxResRealTimeDemo.h:338

GxResRealTimeDemo::GxRtdProp::_keyArray
GxArrayClassBase _keyArray
キー配列
Definition GxResRealTimeDemo.h:341

GxResRealTimeDemo::GxRtdProp::getNodeId
constexpr u32 getNodeId(void) const
ノードIDを取得
Definition GxResRealTimeDemo.h:313

GxResRealTimeDemo::GxRtdProp::getProperty
constexpr void getProperty(void *const pValue, u32 index)
キーを取得(プロパティ用)
Definition GxResRealTimeDemo.h:293

GxResRealTimeDemo::GxRtdProp::getChildren
constexpr void getChildren(void *const pValue, u32 index)
子プロパティを取得(プロパティ用)
Definition GxResRealTimeDemo.h:301

GxResRealTimeDemo::GxRtdProp::_arrayIndex
s32 _arrayIndex
配列インデックス
Definition GxResRealTimeDemo.h:340

GxResRealTimeDemo::GxRtdProp::getChildNum
constexpr u32 getChildNum(void) const
子プロパティ配列の要素数を取得(プロパティ用)
Definition GxResRealTimeDemo.h:297

GxResRealTimeDemo::GxRtdProp::_interpolateType
s32 _interpolateType
補間タイプ
Definition GxResRealTimeDemo.h:339

GxResRealTimeDemo::GxRtdProp::setPropertyNum
GX_FORCE_INLINE void setPropertyNum(u32 num)
キー配列の要素数を設定(プロパティ用)
Definition GxResRealTimeDemo.h:291

GxResRealTimeDemo::GxRtdProp::getPropertyNum
constexpr u32 getPropertyNum(void) const
キー配列の要素数を取得(プロパティ用)
Definition GxResRealTimeDemo.h:289

GxResRealTimeDemo::GxRtdProp::_pProperty
GxProperty * _pProperty
プロパティ
Definition GxResRealTimeDemo.h:337

GxResRealTimeDemo::GxRtdProp::GxRtdProp
GxRtdProp(void)
デフォルトコンストラクタ
Definition GxResRealTimeDemo.cpp:887

GxResRealTimeDemo::GxRtdProp::isArrayElement
b32 isArrayElement(void) const
配列の要素か判定
Definition GxResRealTimeDemo.cpp:1047

GxResRealTimeDemo::GxRtdProp::getArrayIndex
constexpr s32 getArrayIndex(void) const
配列のindex取得
Definition GxResRealTimeDemo.h:316

GxResRealTimeDemo::GxRtdProp::isArrayParent
b32 isArrayParent(void) const
配列の親か判定
Definition GxResRealTimeDemo.cpp:1034

GxResRealTimeDemo::GxRtdProp::setChildNum
GX_FORCE_INLINE void setChildNum(u32 num)
子プロパティ配列の要素数を設定(プロパティ用)
Definition GxResRealTimeDemo.h:299

GxResRealTimeDemo::GxRtdProp::setChildren
void setChildren(const void *const pValue, u32 index)
子プロパティを設定(プロパティ用)
Definition GxResRealTimeDemo.cpp:971

GxResRealTimeDemo::GxRtdUnit
RTDユニット
Definition GxResRealTimeDemo.h:54

GxResRealTimeDemo::GxRtdUnit::getProperty
GX_FORCE_INLINE void getProperty(void *const pValue, u32 index)
プロパティを取得
Definition GxResRealTimeDemo.h:90

GxResRealTimeDemo::GxRtdUnit::setPropertyNum
GX_FORCE_INLINE void setPropertyNum(u32 num)
プロパティ数を設定
Definition GxResRealTimeDemo.h:88

GxResRealTimeDemo::GxRtdUnit::_propertyArray
GxArrayClassBase _propertyArray
ユニットに対してキー設定するプロパティ配列
Definition GxResRealTimeDemo.h:109

GxResRealTimeDemo::GxRtdUnit::_userData
GxString _userData
ユーザーがDCCツール上で自由に設定できる文字列(アプリケーションで任意で使用できるパラメータ)
Definition GxResRealTimeDemo.h:111

GxResRealTimeDemo::GxRtdUnit::_discrimID
s32 _discrimID
自由に設定できるユニット識別用ID
Definition GxResRealTimeDemo.h:110

GxResRealTimeDemo::GxRtdUnit::setProperty
void setProperty(const void *const pValue, u32 index)
プロパティを設定
Definition GxResRealTimeDemo.cpp:874

GxResRealTimeDemo::GxRtdUnit::GxRtdUnit
GxRtdUnit(void)
デフォルトコンストラクタ
Definition GxResRealTimeDemo.cpp:815

GxResRealTimeDemo::GxRtdUnit::getNodeId
constexpr u32 getNodeId(void) const
ノードIDを取得
Definition GxResRealTimeDemo.h:94

GxResRealTimeDemo::GxRtdUnit::_pRtti
GxRtti * _pRtti
ユニットのRtti
Definition GxResRealTimeDemo.h:108

GxResRealTimeDemo::GxRtdUnit::~GxRtdUnit
~GxRtdUnit(void) override
デストラクタ
Definition GxResRealTimeDemo.cpp:845

GxResRealTimeDemo::GxRtdUnit::_type
GxString _type
表示名の変更(type)
Definition GxResRealTimeDemo.h:112

GxResRealTimeDemo::GxRtdUnit::getPropertyNum
constexpr u32 getPropertyNum(void) const
プロパティ数を取得
Definition GxResRealTimeDemo.h:86

GxResRealTimeDemo::GxRtdUnit::initializeAfterRttiLoaded
void initializeAfterRttiLoaded(void)
RTTIとリソース読み込み後の_typeの更新
Definition GxResRealTimeDemo.cpp:858

GxResRealTimeDemo
リアルタイムデモ設定リソース
Definition GxResRealTimeDemo.h:23

GxResRealTimeDemo::load
b32 load(GxStream &, u32)
読み込み
Definition GxResRealTimeDemo.cpp:258

GxResRealTimeDemo::getPropertyFromNodeId
GxRtdProp * getPropertyFromNodeId(u32 PropNodeId)
ノードIDからプロパティを取得
Definition GxResRealTimeDemo.cpp:435

GxResRealTimeDemo::getKeyType
static GxRtti * getKeyType(GxProperty::TYPE type)
Definition GxResRealTimeDemo.cpp:361

GxResRealTimeDemo::getUnitArray
GX_FORCE_INLINE GxArrayClassBase * getUnitArray(void)
ユニットの配列を取得
Definition GxResRealTimeDemo.h:171

GxResRealTimeDemo::_unitArray
GxArrayClassBase _unitArray
ユニットArray
Definition GxResRealTimeDemo.h:240

GxResRealTimeDemo::getEndFrame
constexpr u32 getEndFrame(void) const
終了フレームの取得
Definition GxResRealTimeDemo.h:163

GxResRealTimeDemo::getStartFrame
constexpr u32 getStartFrame(void) const
開始フレームの取得
Definition GxResRealTimeDemo.h:161

GxResRealTimeDemo::GxResRealTimeDemo
GxResRealTimeDemo(void)
デフォルトコンストラクタ
Definition GxResRealTimeDemo.cpp:220

GxResRealTimeDemo::getUnitFromNodeId
GxRtdUnit * getUnitFromNodeId(u32 UnitNodeId)
ノードIDからユニットを取得
Definition GxResRealTimeDemo.cpp:413

GxResRealTimeDemo::getPropertyHierarchyFromNodeId
b32 getPropertyHierarchyFromNodeId(u32 propertyNodeId, GxArrayClassBase &result)
ノードIDからプロパティを検索し、親Unitから順に配列に取得
Definition GxResRealTimeDemo.cpp:555

GxResRealTimeDemo::getMinMaxKeyFrame
void getMinMaxKeyFrame(u32 &minFrame, u32 &maxFrame, b32 considerPlayRange=true)
キーの存在する最小/最大フレームを取得
Definition GxResRealTimeDemo.cpp:299

GxResRealTimeDemo::getPropertyParent
b32 getPropertyParent(GxRtdUnit *&pParentUnit, GxRtdProp *&pParentProperty, u32 childPropertyNodeId)
プロパティの親か判定
Definition GxResRealTimeDemo.cpp:748

GxResRealTimeDemo::getSceneFPS
constexpr u32 getSceneFPS(void) const
シーンに設定されたFPSの取得
Definition GxResRealTimeDemo.h:165

GxResRealTimeDemo::cleanup
void cleanup(void) override
解放処理
Definition GxResRealTimeDemo.cpp:231

GxResRealTimeDemo::isDescendantProperty
b32 isDescendantProperty(u32 parentPropertyNodeId, u32 descendantPropertyNodeId)
プロパティがプロパティの子孫であるか判定
Definition GxResRealTimeDemo.cpp:687

GxRtti
実行時型情報クラス
Definition GxRtti.h:154

GxRtti::ICON_TYPE::UNIT_MOVIE
@ UNIT_MOVIE
ムービーユニット

GxRttiResource
リソース実行時型情報クラス
Definition GxRttiResource.h:188

GxStream
ストリーム基礎クラス
Definition GxStream.h:20

GxUnitBase
ユニット基礎クラス
Definition GxUnitBase.h:45

GxColorHDR
色(HDR)
Definition GxColor.h:241

GxColor
色
Definition GxColor.h:21

GxQuaternion
クォータニオン
Definition GxQuaternion.h:19

GxString
文字列型クラス
Definition GxString.h:18

GxVector2
2次元ベクトル
Definition GxVector.h:34

GxVector3
3次元ベクトル
Definition GxVector.h:245

b32
32bitブーリアン
Definition GxDefine.h:173