// 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"

// Ensure the included flatbuffers.h is the same version as when this file was
// generated, otherwise it may not be compatible.
static_assert(FLATBUFFERS_VERSION_MAJOR == 2 &&
              FLATBUFFERS_VERSION_MINOR == 0 &&
              FLATBUFFERS_VERSION_REVISION == 8,
             "Non-compatible flatbuffers version included");

#include "CSParseBinary_generated.h"

namespace flatbuffers {

struct CSArmatureNodeOption;
struct CSArmatureNodeOptionBuilder;

struct ResourceItemData;
struct ResourceItemDataBuilder;

struct CSArmatureNodeOption FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef CSArmatureNodeOptionBuilder Builder;
  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 flatbuffers::WidgetOptions *nodeOptions() const {
    return GetPointer<const flatbuffers::WidgetOptions *>(VT_NODEOPTIONS);
  }
  const flatbuffers::ResourceItemData *fileData() const {
    return GetPointer<const flatbuffers::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, 1) &&
           VerifyField<uint8_t>(verifier, VT_ISAUTOPLAY, 1) &&
           VerifyOffset(verifier, VT_CURRENTANIMATIONNAME) &&
           verifier.VerifyString(currentAnimationName()) &&
           VerifyOffset(verifier, VT_CURRENTARMATURENAME) &&
           verifier.VerifyString(currentArmatureName()) &&
           VerifyField<float>(verifier, VT_TIMESCALE, 4) &&
           VerifyField<float>(verifier, VT_ARMATURESCALE, 4) &&
           verifier.EndTable();
  }
};

struct CSArmatureNodeOptionBuilder {
  typedef CSArmatureNodeOption Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_nodeOptions(flatbuffers::Offset<flatbuffers::WidgetOptions> nodeOptions) {
    fbb_.AddOffset(CSArmatureNodeOption::VT_NODEOPTIONS, nodeOptions);
  }
  void add_fileData(flatbuffers::Offset<flatbuffers::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();
  }
  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<flatbuffers::WidgetOptions> nodeOptions = 0,
    flatbuffers::Offset<flatbuffers::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<flatbuffers::WidgetOptions> nodeOptions = 0,
    flatbuffers::Offset<flatbuffers::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 {
  typedef ResourceItemDataBuilder Builder;
  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, 4) &&
           VerifyOffset(verifier, VT_PATH) &&
           verifier.VerifyString(path()) &&
           verifier.EndTable();
  }
};

struct ResourceItemDataBuilder {
  typedef ResourceItemData Table;
  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();
  }
  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_