doc/api/_gx_script_8h_source.html

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

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

#pragma once


GX_CORE_NAMESPACE_BEGIN()

class GxScriptRuntime;


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

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


class GxScript : public GxClassBase

{

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

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

public:

    class GxArgument;

    class GxBlock;

    class GxBlockCommand;

    class GxBlockCommandFunction;

    class GxBlockCommandFunctionDynamic;

    class GxBlockCommandSet;

    class GxBlockStart;

    class GxBlockEnd;

    class GxBlockBranch;

    class GxBlockIf;

    class GxBlockIfElse;

    class GxBlockLoop;

    class GxBlockParameter;

    class GxBlockParameterProperty;

    class GxBlockParameterPropertyDynamic;

    class GxBlockParameterFunction;

    class GxBlockParameterFunctionDynamic;


    GX_RTTI_CLASS(GxScript, GxClassBase)

    // ClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxScript)


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

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

public:

    GxScript(void);

    ~GxScript(void) override;


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

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

public:

    void replaceData(const GxArrayClassBase& staticFunctions, const GxArrayClassBase& eventFunctions, const GxArrayClassBase& dynamicProperties);

    GxFunction::GxValue execute(GxClassBaseRoot* pObject, GxScriptRuntime& runtime, u32 argumentCount = 0, GxFunction::GxValue* pValues = nullptr) const;

#if GX_DEVELOP

    void render(const GxPoint2& offset, f32 zoom);

    GxBlock* addBlock(GxRtti* pRtti, GxFunction* pFunction = nullptr, GxProperty* pProperty = nullptr, GxScript* pScript = nullptr);

    void addBlock(GxBlock* pBlock);

    void changeBottomBlock(GxBlock* pBlock);

    GxBlockBranch* removeFromBranch(GxBlockCommand* pBlockCommand, s32* pBranchIndex = nullptr) const;

    void removeSelectBlocks(void);

    void removeBlock(GxBlock* pBlock);

    void removeBlocks(GxFunction* pFunction);

    void removeBlocks(GxProperty* pProperty);

#endif //GX_DEVELOP

private:

    GxFunction::GxValue reExecute(GxClassBaseRoot* pObject, GxScriptRuntime& runtime) const;


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

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

public:

    constexpr GxBlockStart* getBlockStart(void) const { return _pBlockStart; }

#if GX_DEVELOP

    GxBlock* getBlock(const GxPoint2& position);

    static GxBlock* getTopParentBlock(GxBlockParameter* pBlockParameter);

    void getSelectBlocks(GxArrayClassBase& blocks) const;

#endif //GX_DEVELOP

    template<class T>


    void getBlocks(GxArrayClassBase& blocks) const

    {

        for (auto* pObject : _blocks)

        {

            auto* pBlock = gx_cast<T*>(pObject);

            if (pBlock)

            {

                blocks.addBottom(pBlock);

            }

        }

    }


    GX_FORCE_INLINE GxArrayClassBase& getBlocks(void) { return _blocks; }

    b32 isUsingFunction(GxFunction* pFunction) const;

    b32 isUsingProperty(GxProperty* pProperty) const;


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

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

private:

    GxArrayClassBase    _blocks;

    GxBlockStart*       _pBlockStart;


};


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

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


class GxScript::GxArgument : public GxClassBase

{

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

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

public:

    GX_RTTI_CLASS(GxArgument, GxClassBase)

    // ClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxArgument)


#if GX_DEVELOP

    static constexpr u32 MARGIN_WIDTH = 2;

    static constexpr u32 MARGIN_HEIGHT = 2;

    static constexpr u32 MARGIN_HEIGHT_HALF = MARGIN_HEIGHT / 2;

#endif //GX_DEVELOP


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

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

public:


    GxArgument(void) : _pBlock(nullptr)

#if GX_DEVELOP

        , _pEnum(nullptr), _enumCount(0)

#endif //GX_DEVELOP

    {}


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

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

#if GX_DEVELOP

    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index);

#endif //GX_DEVELOP


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

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

public:

    constexpr GxBlockParameter* getBlock(void) const { return _pBlock; }

    GX_FORCE_INLINE GxFunction::GxValue getValue(void) const { return _value; }

    GX_FORCE_INLINE GxFunction::GxType getType(void) const { return _type; }

#if GX_DEVELOP

    u32 getWidth(void) const;

    constexpr void setBlock(GxBlockParameter* pBlock) { _pBlock = pBlock; }

    GX_FORCE_INLINE void setValue(GxFunction::GxValue value) { _value = value; }

    GX_FORCE_INLINE void setType(GxFunction::GxType type) { _type = type; }

    constexpr void setEnum(const GX_ENUM* pEnum) { _pEnum = pEnum; }

    constexpr void setEnumCount(u32 count) { _enumCount = count; }

#endif //GX_DEVELOP


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

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

private:

    GxBlockParameter*   _pBlock;

    GxFunction::GxValue _value;

    GxFunction::GxType  _type;

#if GX_DEVELOP

    const GX_ENUM*      _pEnum;

    u32                 _enumCount;

#endif //GX_DEVELOP


};


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

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


class GxScript::GxBlock : public GxClassBaseReference

{

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

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

public:

    GX_RTTI_ABSTRACT_CLASS(GxBlock, GxClassBaseReference)

    // ClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxBlock)


#if GX_DEVELOP

    enum class CONNECT

    {

        NONE,

        PREVIOUS,

        NEXT,

        BRANCH_FIRST,

        BRANCH_SECOND,

        ARGUMENT_START,

        ARGUMENT_1 = ARGUMENT_START,

        ARGUMENT_2,

        ARGUMENT_3,

        ARGUMENT_4,

        ARGUMENT_END = ARGUMENT_4,

        MAX,

    };


    static constexpr u32 CHAR_WIDTH = 10;

    static constexpr u32 CONNECT_HEIGHT = 8;

    static constexpr u32 HIT_CONNECT_WIDTH = 2;

    static constexpr u32 ARGUMENT_EDGE_WIDTH = 2;

    static const u32 FONT_HEIGHT;

    static const u32 FONT_WIDTH;

    static const GxColor COLOR_TEXT;

    static const GxColor COLOR_SELECT;

    static const GxColor COLOR_EXECUTED;

    static const GxColor COLOR_HIT_CONNECT;

    static const GxColor COLOR_COMMAND;

    static const GxColor COLOR_SYSTEM;

#endif //GX_DEVELOP


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

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

public:

    GxBlock(void);

    void cleanup(void) override;

    virtual void initialize(void) = 0;


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

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

public:

    GX_FORCE_INLINE virtual GxFunction::GxValue execute(GxClassBaseRoot* /*pObject*/, GxScriptRuntime& /*runtime*/, u32 /*argumentIndex*/ = 0, GxFunction::GxValue* /*pValues*/ = nullptr) const { return GxFunction::GxValue(); }

#if GX_DEVELOP

    GX_FORCE_INLINE void updatePosition(void) { updatePositionSub(_position._x); }

    virtual void updateSize(void);

    virtual void render(const GxPoint2& offset, f32 zoom);

    virtual void renderBlock(const GxPoint2& position, f32 zoom) = 0;

    void renderArguments(const GxPoint2& position, f32 zoom);

    GX_FORCE_INLINE void addArgument(GxArgument& argument) { _arguments.addBottom(&argument); }

    GX_FORCE_INLINE virtual void addMenuItems(GxPropertyTable& /*propertyTable*/) {}

    GX_FORCE_INLINE virtual CONNECT isHit(const GxBlock& /*block*/) const { return CONNECT::NONE; }

    GX_FORCE_INLINE virtual s32 isHitArgument(const GxBlock& /*block*/) const { return -1; }

    s32 isHitPositionArgument(const GxPoint2& position) const;

    GX_FORCE_INLINE virtual b32 isIncluding(const GxPoint2& position) const { return GxRect(_position, _size).isIncluding(position); }

    GX_FORCE_INLINE virtual void connect(CONNECT /*connect*/, GxBlock* /*pBlock*/) {}

protected:

    GX_FORCE_INLINE virtual void updatePositionSub(s32 /*x*/) {}

    void updatePositionArgument(const GxPoint2& position);

#endif //GX_DEVELOP


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

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

public:

    virtual void getConnectBlocksSub(GxArrayClassBase& blocks, b32 isUnique = false) const;

    constexpr GxBlock* getParent(void) const { return _pParent; }

    GxBlockCommand* getParentCommand(void) const;

#if GX_DEVELOP

    constexpr void setParent(GxBlock* pParent) { _pParent = pParent; }

#endif //GX_DEVELOP

    constexpr u32 getArgumentCount(void) const { return _arguments.getCount(); }

    GX_FORCE_INLINE GxArgument* getArgument(u32 index) const { return static_cast<GxArgument*>(_arguments[index]); }

#if GX_DEVELOP

    void setArgumentBlock(u32 index, GxBlockParameter* pBlockParameter);

    u32 getArgumentDepth(void) const;

    GX_FORCE_INLINE const GxPoint2& getPosition(void) const { return _position; }

    GX_FORCE_INLINE void setPosition(const GxPoint2& position) { _position = position; }

    GX_FORCE_INLINE const GxSize& getSize(void) const { return _size; }

    GX_FORCE_INLINE void setSize(const GxSize& size) { _size = size; }

    GX_FORCE_INLINE b32 isSelect(void) const { return _isSelect; }

    GX_FORCE_INLINE void setSelect(b32 enable) { _isSelect = enable; }

    constexpr CONNECT getHitConnect(void) const { return _hitConnect; }

    constexpr void setHitConnect(CONNECT connect) { _hitConnect = connect; }

    GX_FORCE_INLINE virtual b32 isMovable(void) const { return true; }

    GX_FORCE_INLINE virtual b32 isRemovable(void) const { return true; }

    static const GxColor& getTypeColor(GxFunction::TYPE type);

    GX_FORCE_INLINE virtual void getHelp(GxString& /*help*/) const {}

#endif //GX_DEVELOP


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

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

private:

    GxBlock*                _pParent;

    GxArrayClassBase        _arguments;

    GxPoint2                _position;

    GxSize                  _size;

#if GX_DEVELOP

    b32                     _isSelect;

    CONNECT                 _hitConnect;

#endif //GX_DEVELOP


};


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

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


class GxScript::GxBlockCommand : public GxScript::GxBlock

{

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

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

public:

    GX_RTTI_ABSTRACT_CLASS(GxBlockCommand, GxBlock)

    // ClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxBlockCommand)


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

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

public:


    GxBlockCommand(GxFunction& function) : _pPrevious(nullptr), _pNext(nullptr), _pFunction(&function), _isBreak(false)

#if GX_DEVELOP

        , _isExecuted(false)

#endif //GX_DEVELOP

    {}


protected:


    GxBlockCommand(void) : _pPrevious(nullptr), _pNext(nullptr), _pFunction(nullptr), _isBreak(false)

#if GX_DEVELOP

        , _isExecuted(false)

#endif //GX_DEVELOP

    {}


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

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

public:

    GxFunction::GxValue execute(GxClassBaseRoot* pObject, GxScriptRuntime& runtime, u32 argumentIndex = 0, GxFunction::GxValue* pValues = nullptr) const override;

#if GX_DEVELOP

    CONNECT isHit(const GxBlock& block) const override;

    void connect(CONNECT connect, GxBlock* pBlock) override;

    void render(const GxPoint2& offset, f32 zoom) override;

protected:

    void updatePositionSub(s32 x) override;

#endif //GX_DEVELOP


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

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

public:

    constexpr GxBlockCommand* getPrevious(void) const { return _pPrevious; }

    constexpr GxBlockCommand* getNext(void) const { return _pNext; }

    GxBlockCommand* getFirst(void) const;

    GxBlockCommand* getLast(void) const;

    void getConnectBlocks(GxArrayClassBase& blocks, b32 isUnique = false) const;

    constexpr GxFunction* getFunction(void) const { return _pFunction; }

    void setFunction(GxFunction& function);

#if GX_DEVELOP

    constexpr void setPrevious(GxBlockCommand* pBlock) { _pPrevious = pBlock; }

    constexpr void setNext(GxBlockCommand* pBlock) { _pNext = pBlock; }

    GxSize getConnectBlocksSize(void) const;

    GX_FORCE_INLINE void setBreak(b32 enable) { _isBreak = enable; }

    GX_FORCE_INLINE b32 isBreak(void) const { return _isBreak; }

    GX_FORCE_INLINE void setExecuted(b32 enable) { _isExecuted = enable; }

    GX_FORCE_INLINE b32 isExecuted(void) const { return _isExecuted; }

    void getHelp(GxString& help) const override;

#endif //GX_DEVELOP


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

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

private:

    GxBlockCommand* _pPrevious;

    GxBlockCommand* _pNext;

    GxFunction*     _pFunction;

    b32             _isBreak;

#if GX_DEVELOP

    b32             _isExecuted;

#endif //GX_DEVELOP


};


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

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


class GxScript::GxBlockCommandFunction : public GxScript::GxBlockCommand

{

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

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

public:

    GX_RTTI_CLASS(GxBlockCommandFunction, GxBlockCommand)

    // ClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxBlockCommandFunction)


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

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

public:

    GxBlockCommandFunction(GxFunction& function);

    void initialize(void) override;

protected:

    GxBlockCommandFunction(void) {}


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

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

#if GX_DEVELOP

public:

    void updateSize(void) override;

    void renderBlock(const GxPoint2& position, f32 zoom) override;

protected:

    void updatePositionSub(s32 x) override;

    s32 isHitArgument(const GxBlock& block) const override;

#endif //GX_DEVELOP


};


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

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


class GxScript::GxBlockCommandFunctionDynamic : public GxScript::GxBlockCommandFunction

{

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

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

public:

    GX_RTTI_CLASS(GxBlockCommandFunctionDynamic, GxBlockCommandFunction)

    // ClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxBlockCommandFunctionDynamic)


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

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

public:

    GxBlockCommandFunctionDynamic(GxFunction& function, GxScript& script);

protected:

    GxBlockCommandFunctionDynamic(void) : _pScript(nullptr){}


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

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

public:

    GxFunction::GxValue execute(GxClassBaseRoot* pObject, GxScriptRuntime& runtime, u32 argumentIndex = 0, GxFunction::GxValue* pValues = nullptr) const override;


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

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

public:

    GX_FORCE_INLINE void setScript(GxScript& script) { _pScript = &script; }


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

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

private:

    GxScript* _pScript;


};


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

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


class GxScript::GxBlockCommandSet : public GxScript::GxBlockCommand

{

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

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

public:

    GX_RTTI_CLASS(GxBlockCommandSet, GxBlockCommand)

    // ClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxBlockCommandSet)


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

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

public:

    GxBlockCommandSet(GxProperty& property);

    void initialize(void) override;

private:

    GxBlockCommandSet(void) : _pProperty(nullptr), _propertyId(GxProperty::DEFAULT_ID) {}


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

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

public:

    GxFunction::GxValue execute(GxClassBaseRoot* pObject, GxScriptRuntime& runtime, u32 argumentIndex = 0, GxFunction::GxValue* pValues = nullptr) const override;

#if GX_DEVELOP

    void renderBlock(const GxPoint2& position, f32 zoom) override;

    void updateSize(void) override;

protected:

    void updatePositionSub(s32 x) override;

    s32 isHitArgument(const GxBlock& block) const override;

#endif //GX_DEVELOP


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

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

public:

    constexpr GxProperty* getProperty(void) const { return _pProperty; }

    constexpr void setProperty(GxProperty& property) { _pProperty = &property; _propertyId = property.getId(); }

    constexpr u32 getPropertyId(void) const { return _propertyId; }

private:

    GX_FORCE_INLINE b32 isDynamic(void) const { return !_pProperty->getOwnerRtti(); }


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

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

private:

    GxProperty* _pProperty;

    u32         _propertyId;


};


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

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


class GxScript::GxBlockStart : public GxScript::GxBlockCommand

{

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

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

public:

    GX_RTTI_CLASS(GxBlockStart, GxBlockCommand)

    // ClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxBlockStart)


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

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

public:

    GxBlockStart(GxFunction& function);

    void cleanup(void) override;

    void initialize(void) override;

private:

    GxBlockStart(void);


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

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

public:

    GX_FORCE_INLINE GxFunction::GxValue execute(GxClassBaseRoot* /*pObject*/, GxScriptRuntime& /*runtime*/, u32 /*argumentIndex*/ = 0, GxFunction::GxValue* /*pValues*/ = nullptr) const override { return GxFunction::GxValue(); }

#if GX_DEVELOP

    void renderBlock(const GxPoint2& position, f32 zoom) override;

    CONNECT isHit(const GxBlock& block) const override;

    void updateSize(void) override;

#endif //GX_DEVELOP


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

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

public:

#if GX_DEVELOP

    GX_FORCE_INLINE b32 isRemovable(void) const override { return false; }

#endif //GX_DEVELOP

    constexpr GxProperty* getProperty(u32 index) const { return _pProperties[index]; }

    GxProperty* getPropertyFromId(u32 id) const;


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

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

private:

    GxProperty* _pProperties[GxFunction::ARGUMENT_MAX];

    u32         _propertyId[GxFunction::ARGUMENT_MAX];


};


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

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


class GxScript::GxBlockEnd : public GxScript::GxBlockCommand

{

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

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

public:

    GX_RTTI_CLASS(GxBlockEnd, GxBlockCommand)

    // ClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxBlockEnd)


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

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

public:

    GxBlockEnd(GxFunction& function) : Super(function) {}

    void initialize(void) override;

private:

    GxBlockEnd(void) {}


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

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

public:

    GxFunction::GxValue execute(GxClassBaseRoot* pObject, GxScriptRuntime& runtime, u32 argumentIndex = 0, GxFunction::GxValue* pValues = nullptr) const override;

#if GX_DEVELOP

    void renderBlock(const GxPoint2& position, f32 zoom) override;

    CONNECT isHit(const GxBlock& block) const override;

    s32 isHitArgument(const GxBlock& block) const override;

    void updateSize(void) override;

    void updatePositionSub(s32 x) override;

#endif //GX_DEVELOP


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

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

public:

#if GX_DEVELOP

    GX_FORCE_INLINE b32 isMovable(void) const override { return false; }

    GX_FORCE_INLINE b32 isRemovable(void) const override { return false; }

#endif //GX_DEVELOP


};


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

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


class GxScript::GxBlockBranch : public GxScript::GxBlockCommand

{

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

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

public:

    GX_RTTI_ABSTRACT_CLASS(GxBlockBranch, GxBlockCommand)

    // ClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxBlockBranch)


#if GX_DEVELOP

    static constexpr u32 MARGIN_BRANCH_LEFT = 1;

#endif //GX_DEVELOP


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

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

public:

    GxBlockBranch(u32 branchCount) : _branchCount(branchCount){ _pBranch[0] = nullptr; _pBranch[1] = nullptr; }

    void initialize(void) override;

private:

    GxBlockBranch(void) : _branchCount(1) { _pBranch[0] = nullptr; _pBranch[1] = nullptr; }


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

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

#if GX_DEVELOP

public:

    void updateSize(void) override;

    void renderBlock(const GxPoint2& position, f32 zoom) override;

    CONNECT isHit(const GxBlock& block) const override;

    b32 isIncluding(const GxPoint2& position) const override;

    void connect(CONNECT connect, GxBlock* pBlock) override;

protected:

    void updatePositionSub(s32 x) override;

    s32 isHitArgument(const GxBlock& block) const override;

#endif //GX_DEVELOP


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

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

public:

    constexpr GxBlockCommand* getBranch(u32 index = 0) const { return _pBranch[index]; }

#if GX_DEVELOP

    void setBranch(GxBlockCommand* pBlock, u32 index = 0);

#endif //GX_DEVELOP

    s32 isBranch(GxBlockCommand* pBlock) const;

    constexpr u32 getBranchCount(void) const { return _branchCount; }

    void getConnectBlocksSub(GxArrayClassBase& blocks, b32 isUnique = false) const override;

protected:

#if GX_DEVELOP

    // 名前用の幅を取得

    virtual u32 getNameWidth(void) const = 0;

#endif //GX_DEVELOP


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

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

private:

    GxBlockCommand* _pBranch[2];

    u32             _branchCount;


};


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

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


class GxScript::GxBlockIf : public GxScript::GxBlockBranch

{

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

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

public:

    GX_RTTI_CLASS(GxBlockIf, GxBlockBranch)

    // ClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxBlockIf)


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

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

public:

    GxBlockIf(void) : Super(1) {}

    GxBlockIf(u32 branchCount) : Super(branchCount){}


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

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

public:

    GxFunction::GxValue execute(GxClassBaseRoot* pObject, GxScriptRuntime& runtime, u32 argumentIndex = 0, GxFunction::GxValue* pValues = nullptr) const override;

#if GX_DEVELOP

    void renderBlock(const GxPoint2& position, f32 zoom) override;

#endif //GX_DEVELOP


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

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

public:

    constexpr GxBlockCommand* getTrue(void) const { return getBranch(); }

#if GX_DEVELOP

    GX_FORCE_INLINE void setTrue(GxBlockCommand* pBlock) { setBranch(pBlock); }

protected:

    GX_FORCE_INLINE u32 getNameWidth(void) const override { return GX_STRLEN("if") * FONT_WIDTH; }

#endif //GX_DEVELOP


};


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

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


class GxScript::GxBlockIfElse : public GxScript::GxBlockIf

{

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

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

public:

    GX_RTTI_CLASS(GxBlockIfElse, GxBlockIf)

    // ClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxBlockIfElse)


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

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

public:

    GxBlockIfElse(void) : Super(2) {}


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

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

public:

    GxFunction::GxValue execute(GxClassBaseRoot* pObject, GxScriptRuntime& runtime, u32 argumentIndex = 0, GxFunction::GxValue* pValues = nullptr) const override;

#if GX_DEVELOP

    void renderBlock(const GxPoint2& position, f32 zoom) override;

#endif //GX_DEVELOP


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

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

public:

    constexpr GxBlockCommand* getFalse(void) const { return getBranch(1); }

#if GX_DEVELOP

    GX_FORCE_INLINE void setFalse(GxBlockCommand* pBlock) { setBranch(pBlock, 1); }

#endif //GX_DEVELOP


};


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

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


class GxScript::GxBlockLoop : public GxScript::GxBlockBranch

{

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

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

public:

    GX_RTTI_CLASS(GxBlockLoop, GxBlockBranch)

    // ClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxBlockLoop)


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

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

public:

    GxBlockLoop(void) : Super(1){}


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

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

public:

    GxFunction::GxValue execute(GxClassBaseRoot* pObject, GxScriptRuntime& runtime, u32 argumentIndex = 0, GxFunction::GxValue* pValues = nullptr) const override;

#if GX_DEVELOP

    void renderBlock(const GxPoint2& position, f32 zoom) override;

#endif //GX_DEVELOP


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

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

protected:

#if GX_DEVELOP

    GX_FORCE_INLINE u32 getNameWidth(void) const override { return GX_STRLEN("while") * FONT_WIDTH; }

#endif //GX_DEVELOP


};


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

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


class GxScript::GxBlockParameter : public GxScript::GxBlock

{

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

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

public:

    GX_RTTI_ABSTRACT_CLASS(GxBlockParameter, GxBlock)

    // ClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxBlockParameter)


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

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

public:

    GxBlockParameter(GxFunction::GxType type) : _argumentIndex(-1), _type(type) {}

    GX_FORCE_INLINE void initialize(void) override {}

protected:

    GxBlockParameter(void) : _argumentIndex(-1){}


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

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

public:

#if GX_DEVELOP

    void renderBlock(const GxPoint2& position, f32 zoom) override;

    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index);

#endif //GX_DEVELOP


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

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

public:

    constexpr s32 getArgumentIndex(void) const { return _argumentIndex; }

#if GX_DEVELOP

    constexpr void setArgumentIndex(s32 index) { _argumentIndex = index; }

#endif //GX_DEVELOP

    GX_FORCE_INLINE GxFunction::GxType getType(void) const { return _type; }

    GX_FORCE_INLINE void setType(GxFunction::GxType type) { _type = type; }


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

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

private:

    s32                 _argumentIndex;

    GxFunction::GxType  _type;


};


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

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


class GxScript::GxBlockParameterProperty : public GxScript::GxBlockParameter

{

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

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

public:

    GX_RTTI_CLASS(GxBlockParameterProperty, GxBlockParameter)

    // ClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxBlockParameterProperty)


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

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

public:

    GxBlockParameterProperty(GxProperty& property);

protected:

    GxBlockParameterProperty(void) : _pProperty(nullptr), _propertyId(GxProperty::DEFAULT_ID){}


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

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

public:

    GxFunction::GxValue execute(GxClassBaseRoot* pObject, GxScriptRuntime& runtime, u32 argumentIndex = 0, GxFunction::GxValue* pValues = nullptr) const override;

#if GX_DEVELOP

    void renderBlock(const GxPoint2& position, f32 zoom) override;

protected:

    void updateSize(void) override;

#endif //GX_DEVELOP


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

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

public:

    constexpr GxProperty* getProperty(void) const { return _pProperty; }

    constexpr void setProperty(GxProperty& property) { _pProperty = &property; _propertyId = property.getId(); }

    constexpr u32 getPropertyId(void) const { return _propertyId; }

    static b32 isSupport(GxProperty& property);

private:

    GX_FORCE_INLINE b32 isDynamic(void) const { return !_pProperty->getOwnerRtti(); }


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

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

private:

    GxProperty* _pProperty;

    u32         _propertyId;


};


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

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


class GxScript::GxBlockParameterFunction : public GxScript::GxBlockParameter

{

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

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

public:

    GX_RTTI_CLASS(GxBlockParameterFunction, GxBlockParameter)

    // ClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxBlockParameterFunction)


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

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

public:

    GxBlockParameterFunction(GxFunction& function);

    void initialize(void) override;

protected:

    GxBlockParameterFunction(void) : _pFunction(nullptr){}


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

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

public:

    GxFunction::GxValue execute(GxClassBaseRoot* pObject, GxScriptRuntime& runtime, u32 argumentIndex = 0, GxFunction::GxValue* pValues = nullptr) const override;

#if GX_DEVELOP

    void renderBlock(const GxPoint2& position, f32 zoom) override;

protected:

    void updatePositionSub(s32 x) override;

    void updateSize(void) override;

    s32 isHitArgument(const GxBlock& block) const override;

#endif //GX_DEVELOP


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

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

public:

    constexpr GxFunction* getFunction(void) const { return _pFunction; }

    constexpr void setFunction(GxFunction& function) { _pFunction = &function; }

#if GX_DEVELOP

    GX_FORCE_INLINE void getHelp(GxString& text) const override { _pFunction->getHelp(text); }

#endif //GX_DEVELOP


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

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

private:

    GxFunction* _pFunction;


};


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

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


class GxScript::GxBlockParameterFunctionDynamic : public GxScript::GxBlockParameterFunction

{

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

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

public:

    GX_RTTI_CLASS(GxBlockParameterFunctionDynamic, GxBlockParameterFunction)

    // ClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxBlockParameterFunctionDynamic)


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

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

public:

    GxBlockParameterFunctionDynamic(GxFunction& function, GxScript& script);

private:

    GxBlockParameterFunctionDynamic(void) : _pScript(nullptr){}


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

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

public:

    GxFunction::GxValue execute(GxClassBaseRoot* pObject, GxScriptRuntime& runtime, u32 argumentIndex = 0, GxFunction::GxValue* pValues = nullptr) const override;


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

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

public:

    constexpr void setScript(GxScript& script) { _pScript = &script; }


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

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

private:

    GxScript* _pScript;


};


GX_CORE_NAMESPACE_END()

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

gx_cast
T gx_cast(GxClassBaseRoot *pObject)
Definition GxBase.h:264

GX_PROHIBIT_CLASS_BASE
#define GX_PROHIBIT_CLASS_BASE(__CLASS__)
GxClassBase継承の禁止宣言
Definition GxBase.h:240

OUTPUT_TYPE::MAX
@ MAX
定義数

GxTypedObject
void GxTypedObject
その他
Definition GxDefine.h:213

INIT::NONE
@ NONE
何もしない

GX_STRLEN
#define GX_STRLEN(__STRING__)
文字列の長さ取得
Definition GxString.h:604

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

GxArrayClassBase::addBottom
void addBottom(GxClassBaseRoot *pObject)
末尾に追加
Definition GxArrayClassBase.cpp:59

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

GxClassBaseReference
参照オブジェクト基底クラス
Definition GxBase.h:122

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

GxFunction::GxType
型情報
Definition GxFunction.h:48

GxFunction
関数型情報
Definition GxFunction.h:18

GxFunction::TYPE
TYPE
型定義
Definition GxFunction.h:28

GxFunction::ARGUMENT_MAX
static const u32 ARGUMENT_MAX
引数の最大数
Definition GxFunction.h:234

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

GxProperty::getOwnerRtti
constexpr GxRtti * getOwnerRtti(void) const
所持者のRTTIを取得
Definition GxProperty.h:1031

GxProperty::DEFAULT_ID
static constexpr u32 DEFAULT_ID
デフォルトID
Definition GxProperty.h:126

GxPropertyTable
プロパティテーブルクラス
Definition GxProperty.h:1641

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

GxScript::GxArgument
引数クラス
Definition GxScript.h:144

GxScript::GxArgument::GxArgument
GxArgument(void)
デフォルトコンストラクタ
Definition GxScript.h:167

GxScript::GxArgument::getType
GX_FORCE_INLINE GxFunction::GxType getType(void) const
型を取得
Definition GxScript.h:194

GxScript::GxArgument::getValue
GX_FORCE_INLINE GxFunction::GxValue getValue(void) const
値を取得
Definition GxScript.h:192

GxScript::GxArgument::getBlock
constexpr GxBlockParameter * getBlock(void) const
ブロックを取得
Definition GxScript.h:190

GxScript::GxBlockBranch
分岐ブロッククラス
Definition GxScript.h:828

GxScript::GxBlockBranch::GxBlockBranch
GxBlockBranch(u32 branchCount)
コンストラクタ
Definition GxScript.h:849

GxScript::GxBlockBranch::initialize
void initialize(void) override
初期化
Definition GxScript.cpp:1989

GxScript::GxBlockBranch::getBranch
constexpr GxBlockCommand * getBranch(u32 index=0) const
分岐先のブロックを取得
Definition GxScript.h:887

GxScript::GxBlockBranch::getConnectBlocksSub
void getConnectBlocksSub(GxArrayClassBase &blocks, b32 isUnique=false) const override
接続ブロックリストを取得
Definition GxScript.cpp:2334

GxScript::GxBlockBranch::getBranchCount
constexpr u32 getBranchCount(void) const
分岐数を取得
Definition GxScript.h:895

GxScript::GxBlockCommandFunctionDynamic
命令動的関数ブロッククラス
Definition GxScript.h:558

GxScript::GxBlockCommandFunctionDynamic::setScript
GX_FORCE_INLINE void setScript(GxScript &script)
スクリプトを設定
Definition GxScript.h:596

GxScript::GxBlockCommandFunctionDynamic::GxBlockCommandFunctionDynamic
GxBlockCommandFunctionDynamic(void)
デフォルトコンストラクタ
Definition GxScript.h:578

GxScript::GxBlockCommandFunctionDynamic::execute
GxFunction::GxValue execute(GxClassBaseRoot *pObject, GxScriptRuntime &runtime, u32 argumentIndex=0, GxFunction::GxValue *pValues=nullptr) const override
実行
Definition GxScript.cpp:1416

GxScript::GxBlockCommandFunction
命令関数ブロッククラス
Definition GxScript.h:509

GxScript::GxBlockCommandFunction::initialize
void initialize(void) override
初期化
Definition GxScript.cpp:1280

GxScript::GxBlockCommandFunction::GxBlockCommandFunction
GxBlockCommandFunction(void)
デフォルトコンストラクタ
Definition GxScript.h:531

GxScript::GxBlockCommand
命令ブロッククラス
Definition GxScript.h:399

GxScript::GxBlockCommand::getPrevious
constexpr GxBlockCommand * getPrevious(void) const
前のブロックを取得
Definition GxScript.h:456

GxScript::GxBlockCommand::GxBlockCommand
GxBlockCommand(void)
デフォルトコンストラクタ
Definition GxScript.h:423

GxScript::GxBlockCommand::GxBlockCommand
GxBlockCommand(GxFunction &function)
コンストラクタ
Definition GxScript.h:416

GxScript::GxBlockCommand::getFirst
GxBlockCommand * getFirst(void) const
先頭のブロックを取得
Definition GxScript.cpp:1088

GxScript::GxBlockCommand::setFunction
void setFunction(GxFunction &function)
関数を設定
Definition GxScript.cpp:1131

GxScript::GxBlockCommand::execute
GxFunction::GxValue execute(GxClassBaseRoot *pObject, GxScriptRuntime &runtime, u32 argumentIndex=0, GxFunction::GxValue *pValues=nullptr) const override
実行
Definition GxScript.cpp:1030

GxScript::GxBlockCommand::getFunction
constexpr GxFunction * getFunction(void) const
関数を取得
Definition GxScript.h:466

GxScript::GxBlockCommand::getNext
constexpr GxBlockCommand * getNext(void) const
次のブロックを取得
Definition GxScript.h:458

GxScript::GxBlockCommand::getConnectBlocks
void getConnectBlocks(GxArrayClassBase &blocks, b32 isUnique=false) const
接続ブロックリストを取得
Definition GxScript.cpp:1117

GxScript::GxBlockCommand::getLast
GxBlockCommand * getLast(void) const
最後のブロックを取得
Definition GxScript.cpp:1102

GxScript::GxBlockCommandSet
代入ブロッククラス
Definition GxScript.h:613

GxScript::GxBlockCommandSet::setProperty
constexpr void setProperty(GxProperty &property)
プロパティを設定
Definition GxScript.h:666

GxScript::GxBlockCommandSet::getPropertyId
constexpr u32 getPropertyId(void) const
プロパティIDを取得
Definition GxScript.h:668

GxScript::GxBlockCommandSet::execute
GxFunction::GxValue execute(GxClassBaseRoot *pObject, GxScriptRuntime &runtime, u32 argumentIndex=0, GxFunction::GxValue *pValues=nullptr) const override
実行
Definition GxScript.cpp:1499

GxScript::GxBlockCommandSet::initialize
void initialize(void) override
初期化
Definition GxScript.cpp:1479

GxScript::GxBlockCommandSet::getProperty
constexpr GxProperty * getProperty(void) const
プロパティを取得
Definition GxScript.h:664

GxScript::GxBlockEnd
終了ブロッククラス
Definition GxScript.h:763

GxScript::GxBlockEnd::GxBlockEnd
GxBlockEnd(GxFunction &function)
コンストラクタ
Definition GxScript.h:780

GxScript::GxBlockEnd::execute
GxFunction::GxValue execute(GxClassBaseRoot *pObject, GxScriptRuntime &runtime, u32 argumentIndex=0, GxFunction::GxValue *pValues=nullptr) const override
実行
Definition GxScript.cpp:1864

GxScript::GxBlockEnd::initialize
void initialize(void) override
初期化
Definition GxScript.cpp:1842

GxScript::GxBlock
標準ブロッククラス
Definition GxScript.h:231

GxScript::GxBlock::execute
virtual GX_FORCE_INLINE GxFunction::GxValue execute(GxClassBaseRoot *, GxScriptRuntime &, u32=0, GxFunction::GxValue *=nullptr) const
実行
Definition GxScript.h:293

GxScript::GxBlock::getConnectBlocksSub
virtual void getConnectBlocksSub(GxArrayClassBase &blocks, b32 isUnique=false) const
接続ブロックリストを取得
Definition GxScript.cpp:971

GxScript::GxBlock::getParent
constexpr GxBlock * getParent(void) const
設定したブロックを取得
Definition GxScript.h:335

GxScript::GxBlock::getParentCommand
GxBlockCommand * getParentCommand(void) const
設定したコマンドブロックを取得
Definition GxScript.cpp:910

GxScript::GxBlock::GxBlock
GxBlock(void)
デフォルトコンストラクタ
Definition GxScript.cpp:786

GxScript::GxBlock::cleanup
void cleanup(void) override
delete直前に呼び出される関数
Definition GxScript.cpp:799

GxScript::GxBlock::getArgument
GX_FORCE_INLINE GxArgument * getArgument(u32 index) const
引数を取得
Definition GxScript.h:345

GxScript::GxBlock::initialize
virtual void initialize(void)=0
初期化

GxScript::GxBlockIfElse
条件分岐2ブロッククラス
Definition GxScript.h:977

GxScript::GxBlockIfElse::getFalse
constexpr GxBlockCommand * getFalse(void) const
偽のブロックを取得
Definition GxScript.h:1016

GxScript::GxBlockIfElse::execute
GxFunction::GxValue execute(GxClassBaseRoot *pObject, GxScriptRuntime &runtime, u32 argumentIndex=0, GxFunction::GxValue *pValues=nullptr) const override
実行
Definition GxScript.cpp:2438

GxScript::GxBlockIfElse::GxBlockIfElse
GxBlockIfElse(void)
デフォルトコンストラクタ
Definition GxScript.h:994

GxScript::GxBlockIf
条件分岐1ブロッククラス
Definition GxScript.h:920

GxScript::GxBlockIf::GxBlockIf
GxBlockIf(u32 branchCount)
コンストラクタ
Definition GxScript.h:939

GxScript::GxBlockIf::getTrue
constexpr GxBlockCommand * getTrue(void) const
真のブロックを取得
Definition GxScript.h:961

GxScript::GxBlockIf::execute
GxFunction::GxValue execute(GxClassBaseRoot *pObject, GxScriptRuntime &runtime, u32 argumentIndex=0, GxFunction::GxValue *pValues=nullptr) const override
実行
Definition GxScript.cpp:2357

GxScript::GxBlockIf::GxBlockIf
GxBlockIf(void)
デフォルトコンストラクタ
Definition GxScript.h:937

GxScript::GxBlockLoop
繰り返しブロッククラス
Definition GxScript.h:1029

GxScript::GxBlockLoop::GxBlockLoop
GxBlockLoop(void)
デフォルトコンストラクタ
Definition GxScript.h:1046

GxScript::GxBlockLoop::execute
GxFunction::GxValue execute(GxClassBaseRoot *pObject, GxScriptRuntime &runtime, u32 argumentIndex=0, GxFunction::GxValue *pValues=nullptr) const override
実行
Definition GxScript.cpp:2521

GxScript::GxBlockParameterFunctionDynamic
パラメータ動的関数ブロッククラス
Definition GxScript.h:1295

GxScript::GxBlockParameterFunctionDynamic::setScript
constexpr void setScript(GxScript &script)
スクリプトを設定
Definition GxScript.h:1333

GxScript::GxBlockParameterFunctionDynamic::execute
GxFunction::GxValue execute(GxClassBaseRoot *pObject, GxScriptRuntime &runtime, u32 argumentIndex=0, GxFunction::GxValue *pValues=nullptr) const override
実行
Definition GxScript.cpp:3038

GxScript::GxBlockParameterFunction
パラメータ関数ブロッククラス
Definition GxScript.h:1221

GxScript::GxBlockParameterFunction::GxBlockParameterFunction
GxBlockParameterFunction(void)
デフォルトコンストラクタ
Definition GxScript.h:1243

GxScript::GxBlockParameterFunction::initialize
void initialize(void) override
初期化
Definition GxScript.cpp:2803

GxScript::GxBlockParameterFunction::execute
GxFunction::GxValue execute(GxClassBaseRoot *pObject, GxScriptRuntime &runtime, u32 argumentIndex=0, GxFunction::GxValue *pValues=nullptr) const override
実行
Definition GxScript.cpp:2831

GxScript::GxBlockParameterFunction::getFunction
constexpr GxFunction * getFunction(void) const
関数を取得
Definition GxScript.h:1272

GxScript::GxBlockParameterFunction::setFunction
constexpr void setFunction(GxFunction &function)
関数を設定
Definition GxScript.h:1274

GxScript::GxBlockParameter
パラメータブロッククラス
Definition GxScript.h:1079

GxScript::GxBlockParameter::initialize
GX_FORCE_INLINE void initialize(void) override
初期化
Definition GxScript.h:1098

GxScript::GxBlockParameter::GxBlockParameter
GxBlockParameter(void)
デフォルトコンストラクタ
Definition GxScript.h:1101

GxScript::GxBlockParameter::getArgumentIndex
constexpr s32 getArgumentIndex(void) const
設定した引数のインデックスを取得
Definition GxScript.h:1123

GxScript::GxBlockParameter::GxBlockParameter
GxBlockParameter(GxFunction::GxType type)
コンストラクタ
Definition GxScript.h:1096

GxScript::GxBlockParameter::setType
GX_FORCE_INLINE void setType(GxFunction::GxType type)
型を設定
Definition GxScript.h:1131

GxScript::GxBlockParameterProperty
パラメータプロパティブロッククラス
Definition GxScript.h:1149

GxScript::GxBlockParameterProperty::execute
GxFunction::GxValue execute(GxClassBaseRoot *pObject, GxScriptRuntime &runtime, u32 argumentIndex=0, GxFunction::GxValue *pValues=nullptr) const override
実行
Definition GxScript.cpp:2690

GxScript::GxBlockParameterProperty::setProperty
constexpr void setProperty(GxProperty &property)
プロパティを設定
Definition GxScript.h:1196

GxScript::GxBlockParameterProperty::GxBlockParameterProperty
GxBlockParameterProperty(void)
デフォルトコンストラクタ
Definition GxScript.h:1169

GxScript::GxBlockParameterProperty::getPropertyId
constexpr u32 getPropertyId(void) const
プロパティIDを取得
Definition GxScript.h:1198

GxScript::GxBlockParameterProperty::getProperty
constexpr GxProperty * getProperty(void) const
プロパティを取得
Definition GxScript.h:1194

GxScript::GxBlockParameterProperty::isSupport
static b32 isSupport(GxProperty &property)
サポートしているプロパティ判定
Definition GxScript.cpp:2758

GxScript::GxBlockStart
開始ブロッククラス
Definition GxScript.h:689

GxScript::GxBlockStart::initialize
void initialize(void) override
初期化
Definition GxScript.cpp:1723

GxScript::GxBlockStart::cleanup
void cleanup(void) override
delete直前に呼び出される関数
Definition GxScript.cpp:1710

GxScript::GxBlockStart::execute
GX_FORCE_INLINE GxFunction::GxValue execute(GxClassBaseRoot *, GxScriptRuntime &, u32=0, GxFunction::GxValue *=nullptr) const override
実行
Definition GxScript.h:722

GxScript::GxBlockStart::getPropertyFromId
GxProperty * getPropertyFromId(u32 id) const
IDからプロパティを取得
Definition GxScript.cpp:1821

GxScript
スクリプトクラス
Definition GxScript.h:19

GxScript::getBlockStart
constexpr GxBlockStart * getBlockStart(void) const
開始ブロックを取得
Definition GxScript.h:99

GxScript::getBlocks
GX_FORCE_INLINE GxArrayClassBase & getBlocks(void)
ブロックリストを取得
Definition GxScript.h:122

GxScript::getBlocks
void getBlocks(GxArrayClassBase &blocks) const
ブロックリストを取得
Definition GxScript.h:110

GxScriptRuntime
スクリプトランタイムクラス
Definition GxScriptRuntime.h:19

GX_ENUM
GUI用
Definition GxDefine.h:194

GxColor
色
Definition GxColor.h:21

GxFunction::GxValue
値の共用体
Definition GxFunction.h:81

GxPoint2
座標
Definition GxStruct.h:867

GxPoint2::_x
s32 _x
X値
Definition GxStruct.h:941

GxRect
矩形
Definition GxStruct.h:951

GxRect::isIncluding
GX_INLINE b32 isIncluding(const GxRect &rect) const
内包判定
Definition GxStruct.inl:1801

GxSize
サイズ
Definition GxStruct.h:730

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

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