axmol/extensions/cocostudio/WidgetReader/ArmatureNodeReader/CSArmatureNode_generated.h

// automatically generated by the FlatBuffers compiler, do not modify

#ifndef FLATBUFFERS_GENERATED_CSARMATURENODE_FLATBUFFERS_H_
#define FLATBUFFERS_GENERATED_CSARMATURENODE_FLATBUFFERS_H_

#include "flatbuffers/flatbuffers.h"

#include "CSParseBinary_generated.h"

namespace flatbuffers
{

struct CSArmatureNodeOption;

struct ResourceItemData;

struct CSArmatureNodeOption FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_NODEOPTIONS          = 4,
        VT_FILEDATA             = 6,
        VT_ISLOOP               = 8,
        VT_ISAUTOPLAY           = 10,
        VT_CURRENTANIMATIONNAME = 12,
        VT_CURRENTARMATURENAME  = 14,
        VT_TIMESCALE            = 16,
        VT_ARMATURESCALE        = 18
    };
    const WidgetOptions* nodeOptions() const { return GetPointer<const WidgetOptions*>(VT_NODEOPTIONS); }
    const ResourceItemData* fileData() const { return GetPointer<const ResourceItemData*>(VT_FILEDATA); }
    bool isLoop() const { return GetField<uint8_t>(VT_ISLOOP, 1) != 0; }
    bool isAutoPlay() const { return GetField<uint8_t>(VT_ISAUTOPLAY, 1) != 0; }
    const flatbuffers::String* currentAnimationName() const
    {
        return GetPointer<const flatbuffers::String*>(VT_CURRENTANIMATIONNAME);
    }
    const flatbuffers::String* currentArmatureName() const
    {
        return GetPointer<const flatbuffers::String*>(VT_CURRENTARMATURENAME);
    }
    float timeScale() const { return GetField<float>(VT_TIMESCALE, 0.0f); }
    float armatureScale() const { return GetField<float>(VT_ARMATURESCALE, 0.0f); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NODEOPTIONS) &&
               verifier.VerifyTable(nodeOptions()) && VerifyOffset(verifier, VT_FILEDATA) &&
               verifier.VerifyTable(fileData()) && VerifyField<uint8_t>(verifier, VT_ISLOOP) &&
               VerifyField<uint8_t>(verifier, VT_ISAUTOPLAY) && VerifyOffset(verifier, VT_CURRENTANIMATIONNAME) &&
               verifier.VerifyString(currentAnimationName()) && VerifyOffset(verifier, VT_CURRENTARMATURENAME) &&
               verifier.VerifyString(currentArmatureName()) && VerifyField<float>(verifier, VT_TIMESCALE) &&
               VerifyField<float>(verifier, VT_ARMATURESCALE) && verifier.EndTable();
    }
};

struct CSArmatureNodeOptionBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_nodeOptions(flatbuffers::Offset<WidgetOptions> nodeOptions)
    {
        fbb_.AddOffset(CSArmatureNodeOption::VT_NODEOPTIONS, nodeOptions);
    }
    void add_fileData(flatbuffers::Offset<ResourceItemData> fileData)
    {
        fbb_.AddOffset(CSArmatureNodeOption::VT_FILEDATA, fileData);
    }
    void add_isLoop(bool isLoop)
    {
        fbb_.AddElement<uint8_t>(CSArmatureNodeOption::VT_ISLOOP, static_cast<uint8_t>(isLoop), 1);
    }
    void add_isAutoPlay(bool isAutoPlay)
    {
        fbb_.AddElement<uint8_t>(CSArmatureNodeOption::VT_ISAUTOPLAY, static_cast<uint8_t>(isAutoPlay), 1);
    }
    void add_currentAnimationName(flatbuffers::Offset<flatbuffers::String> currentAnimationName)
    {
        fbb_.AddOffset(CSArmatureNodeOption::VT_CURRENTANIMATIONNAME, currentAnimationName);
    }
    void add_currentArmatureName(flatbuffers::Offset<flatbuffers::String> currentArmatureName)
    {
        fbb_.AddOffset(CSArmatureNodeOption::VT_CURRENTARMATURENAME, currentArmatureName);
    }
    void add_timeScale(float timeScale) { fbb_.AddElement<float>(CSArmatureNodeOption::VT_TIMESCALE, timeScale, 0.0f); }
    void add_armatureScale(float armatureScale)
    {
        fbb_.AddElement<float>(CSArmatureNodeOption::VT_ARMATURESCALE, armatureScale, 0.0f);
    }
    explicit CSArmatureNodeOptionBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb)
    {
        start_ = fbb_.StartTable();
    }
    CSArmatureNodeOptionBuilder& operator=(const CSArmatureNodeOptionBuilder&);
    flatbuffers::Offset<CSArmatureNodeOption> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<CSArmatureNodeOption>(end);
        return o;
    }
};

inline flatbuffers::Offset<CSArmatureNodeOption> CreateCSArmatureNodeOption(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> nodeOptions                = 0,
    flatbuffers::Offset<ResourceItemData> fileData                = 0,
    bool isLoop                                                   = true,
    bool isAutoPlay                                               = true,
    flatbuffers::Offset<flatbuffers::String> currentAnimationName = 0,
    flatbuffers::Offset<flatbuffers::String> currentArmatureName  = 0,
    float timeScale                                               = 0.0f,
    float armatureScale                                           = 0.0f)
{
    CSArmatureNodeOptionBuilder builder_(_fbb);
    builder_.add_armatureScale(armatureScale);
    builder_.add_timeScale(timeScale);
    builder_.add_currentArmatureName(currentArmatureName);
    builder_.add_currentAnimationName(currentAnimationName);
    builder_.add_fileData(fileData);
    builder_.add_nodeOptions(nodeOptions);
    builder_.add_isAutoPlay(isAutoPlay);
    builder_.add_isLoop(isLoop);
    return builder_.Finish();
}

inline flatbuffers::Offset<CSArmatureNodeOption> CreateCSArmatureNodeOptionDirect(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> nodeOptions = 0,
    flatbuffers::Offset<ResourceItemData> fileData = 0,
    bool isLoop                                    = true,
    bool isAutoPlay                                = true,
    const char* currentAnimationName               = nullptr,
    const char* currentArmatureName                = nullptr,
    float timeScale                                = 0.0f,
    float armatureScale                            = 0.0f)
{
    auto currentAnimationName__ = currentAnimationName ? _fbb.CreateString(currentAnimationName) : 0;
    auto currentArmatureName__  = currentArmatureName ? _fbb.CreateString(currentArmatureName) : 0;
    return flatbuffers::CreateCSArmatureNodeOption(_fbb, nodeOptions, fileData, isLoop, isAutoPlay,
                                                   currentAnimationName__, currentArmatureName__, timeScale,
                                                   armatureScale);
}

struct ResourceItemData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_TYPE = 4,
        VT_PATH = 6
    };
    int32_t type() const { return GetField<int32_t>(VT_TYPE, 0); }
    const flatbuffers::String* path() const { return GetPointer<const flatbuffers::String*>(VT_PATH); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_TYPE) &&
               VerifyOffset(verifier, VT_PATH) && verifier.VerifyString(path()) && verifier.EndTable();
    }
};

struct ResourceItemDataBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_type(int32_t type) { fbb_.AddElement<int32_t>(ResourceItemData::VT_TYPE, type, 0); }
    void add_path(flatbuffers::Offset<flatbuffers::String> path) { fbb_.AddOffset(ResourceItemData::VT_PATH, path); }
    explicit ResourceItemDataBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    ResourceItemDataBuilder& operator=(const ResourceItemDataBuilder&);
    flatbuffers::Offset<ResourceItemData> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<ResourceItemData>(end);
        return o;
    }
};

inline flatbuffers::Offset<ResourceItemData> CreateResourceItemData(flatbuffers::FlatBufferBuilder& _fbb,
                                                                    int32_t type                                  = 0,
                                                                    flatbuffers::Offset<flatbuffers::String> path = 0)
{
    ResourceItemDataBuilder builder_(_fbb);
    builder_.add_path(path);
    builder_.add_type(type);
    return builder_.Finish();
}

inline flatbuffers::Offset<ResourceItemData> CreateResourceItemDataDirect(flatbuffers::FlatBufferBuilder& _fbb,
                                                                          int32_t type     = 0,
                                                                          const char* path = nullptr)
{
    auto path__ = path ? _fbb.CreateString(path) : 0;
    return flatbuffers::CreateResourceItemData(_fbb, type, path__);
}

inline const flatbuffers::CSArmatureNodeOption* GetCSArmatureNodeOption(const void* buf)
{
    return flatbuffers::GetRoot<flatbuffers::CSArmatureNodeOption>(buf);
}

inline const flatbuffers::CSArmatureNodeOption* GetSizePrefixedCSArmatureNodeOption(const void* buf)
{
    return flatbuffers::GetSizePrefixedRoot<flatbuffers::CSArmatureNodeOption>(buf);
}

inline bool VerifyCSArmatureNodeOptionBuffer(flatbuffers::Verifier& verifier)
{
    return verifier.VerifyBuffer<flatbuffers::CSArmatureNodeOption>(nullptr);
}

inline bool VerifySizePrefixedCSArmatureNodeOptionBuffer(flatbuffers::Verifier& verifier)
{
    return verifier.VerifySizePrefixedBuffer<flatbuffers::CSArmatureNodeOption>(nullptr);
}

inline void FinishCSArmatureNodeOptionBuffer(flatbuffers::FlatBufferBuilder& fbb,
                                             flatbuffers::Offset<flatbuffers::CSArmatureNodeOption> root)
{
    fbb.Finish(root);
}

inline void FinishSizePrefixedCSArmatureNodeOptionBuffer(flatbuffers::FlatBufferBuilder& fbb,
                                                         flatbuffers::Offset<flatbuffers::CSArmatureNodeOption> root)
{
    fbb.FinishSizePrefixed(root);
}

}  // namespace flatbuffers

#endif  // FLATBUFFERS_GENERATED_CSARMATURENODE_FLATBUFFERS_H_