axmol/cocos/editor-support/cocostudio/CSParseBinary_generated.h

/****************************************************************************
 Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
 
 http://www.cocos2d-x.org
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ****************************************************************************/

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

#ifndef FLATBUFFERS_GENERATED_CSPARSEBINARY_FLATBUFFERS_H_
#define FLATBUFFERS_GENERATED_CSPARSEBINARY_FLATBUFFERS_H_

#include "flatbuffers/flatbuffers.h"


namespace flatbuffers {

struct CSParseBinary;
struct NodeTree;
struct Options;
struct WidgetOptions;
struct LayoutComponentTable;
struct SingleNodeOptions;
struct SpriteOptions;
struct ParticleSystemOptions;
struct GameMapOptions;
struct ButtonOptions;
struct CheckBoxOptions;
struct ImageViewOptions;
struct TextAtlasOptions;
struct TextBMFontOptions;
struct TextOptions;
struct TextFieldOptions;
struct LoadingBarOptions;
struct SliderOptions;
struct PanelOptions;
struct ScrollViewOptions;
struct PageViewOptions;
struct ListViewOptions;
struct ProjectNodeOptions;
struct ComponentOptions;
struct ComAudioOptions;
struct AnimationInfo;
struct NodeAction;
struct TimeLine;
struct Frame;
struct PointFrame;
struct ScaleFrame;
struct ColorFrame;
struct TextureFrame;
struct EventFrame;
struct IntFrame;
struct BoolFrame;
struct InnerActionFrame;
struct EasingData;
struct RotationSkew;
struct Position;
struct Scale;
struct AnchorPoint;
struct Color;
struct ColorVector;
struct FlatSize;
struct CapInsets;
struct BlendFunc;
struct ResourceData;
struct BlendFrame;

MANUALLY_ALIGNED_STRUCT(4) RotationSkew {
 private:
  float rotationSkewX_;
  float rotationSkewY_;

 public:
  RotationSkew(float rotationSkewX, float rotationSkewY)
    : rotationSkewX_(flatbuffers::EndianScalar(rotationSkewX)), rotationSkewY_(flatbuffers::EndianScalar(rotationSkewY)) { }

  float rotationSkewX() const { return flatbuffers::EndianScalar(rotationSkewX_); }
  float rotationSkewY() const { return flatbuffers::EndianScalar(rotationSkewY_); }
};
STRUCT_END(RotationSkew, 8);

MANUALLY_ALIGNED_STRUCT(4) Position {
 private:
  float x_;
  float y_;

 public:
  Position(float x, float y)
    : x_(flatbuffers::EndianScalar(x)), y_(flatbuffers::EndianScalar(y)) { }

  float x() const { return flatbuffers::EndianScalar(x_); }
  float y() const { return flatbuffers::EndianScalar(y_); }
};
STRUCT_END(Position, 8);

MANUALLY_ALIGNED_STRUCT(4) Scale {
 private:
  float scaleX_;
  float scaleY_;

 public:
  Scale(float scaleX, float scaleY)
    : scaleX_(flatbuffers::EndianScalar(scaleX)), scaleY_(flatbuffers::EndianScalar(scaleY)) { }

  float scaleX() const { return flatbuffers::EndianScalar(scaleX_); }
  float scaleY() const { return flatbuffers::EndianScalar(scaleY_); }
};
STRUCT_END(Scale, 8);

MANUALLY_ALIGNED_STRUCT(4) AnchorPoint {
 private:
  float scaleX_;
  float scaleY_;

 public:
  AnchorPoint(float scaleX, float scaleY)
    : scaleX_(flatbuffers::EndianScalar(scaleX)), scaleY_(flatbuffers::EndianScalar(scaleY)) { }

  float scaleX() const { return flatbuffers::EndianScalar(scaleX_); }
  float scaleY() const { return flatbuffers::EndianScalar(scaleY_); }
};
STRUCT_END(AnchorPoint, 8);

MANUALLY_ALIGNED_STRUCT(1) Color {
 private:
  uint8_t a_;
  uint8_t r_;
  uint8_t g_;
  uint8_t b_;

 public:
  Color(uint8_t a, uint8_t r, uint8_t g, uint8_t b)
    : a_(flatbuffers::EndianScalar(a)), r_(flatbuffers::EndianScalar(r)), g_(flatbuffers::EndianScalar(g)), b_(flatbuffers::EndianScalar(b)) { }

  uint8_t a() const { return flatbuffers::EndianScalar(a_); }
  uint8_t r() const { return flatbuffers::EndianScalar(r_); }
  uint8_t g() const { return flatbuffers::EndianScalar(g_); }
  uint8_t b() const { return flatbuffers::EndianScalar(b_); }
};
STRUCT_END(Color, 4);

MANUALLY_ALIGNED_STRUCT(4) ColorVector {
 private:
  float vectorX_;
  float vectorY_;

 public:
  ColorVector(float vectorX, float vectorY)
    : vectorX_(flatbuffers::EndianScalar(vectorX)), vectorY_(flatbuffers::EndianScalar(vectorY)) { }

  float vectorX() const { return flatbuffers::EndianScalar(vectorX_); }
  float vectorY() const { return flatbuffers::EndianScalar(vectorY_); }
};
STRUCT_END(ColorVector, 8);

MANUALLY_ALIGNED_STRUCT(4) FlatSize {
 private:
  float width_;
  float height_;

 public:
  FlatSize(float width, float height)
    : width_(flatbuffers::EndianScalar(width)), height_(flatbuffers::EndianScalar(height)) { }

  float width() const { return flatbuffers::EndianScalar(width_); }
  float height() const { return flatbuffers::EndianScalar(height_); }
};
STRUCT_END(FlatSize, 8);

MANUALLY_ALIGNED_STRUCT(4) CapInsets {
 private:
  float x_;
  float y_;
  float width_;
  float height_;

 public:
  CapInsets(float x, float y, float width, float height)
    : x_(flatbuffers::EndianScalar(x)), y_(flatbuffers::EndianScalar(y)), width_(flatbuffers::EndianScalar(width)), height_(flatbuffers::EndianScalar(height)) { }

  float x() const { return flatbuffers::EndianScalar(x_); }
  float y() const { return flatbuffers::EndianScalar(y_); }
  float width() const { return flatbuffers::EndianScalar(width_); }
  float height() const { return flatbuffers::EndianScalar(height_); }
};
STRUCT_END(CapInsets, 16);

MANUALLY_ALIGNED_STRUCT(4) BlendFunc {
 private:
  int32_t src_;
  int32_t dst_;

 public:
  BlendFunc(int32_t src, int32_t dst)
    : src_(flatbuffers::EndianScalar(src)), dst_(flatbuffers::EndianScalar(dst)) { }

  int32_t src() const { return flatbuffers::EndianScalar(src_); }
  int32_t dst() const { return flatbuffers::EndianScalar(dst_); }
};
STRUCT_END(BlendFunc, 8);

struct CSParseBinary : private flatbuffers::Table {
  const flatbuffers::String *version() const { return GetPointer<const flatbuffers::String *>(4); }
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *textures() const { return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(6); }
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *texturePngs() const { return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(8); }
  const NodeTree *nodeTree() const { return GetPointer<const NodeTree *>(10); }
  const NodeAction *action() const { return GetPointer<const NodeAction *>(12); }
  const flatbuffers::Vector<flatbuffers::Offset<AnimationInfo>> *animationList() const { return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<AnimationInfo>> *>(14); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* version */) &&
           verifier.Verify(version()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* textures */) &&
           verifier.Verify(textures()) &&
           verifier.VerifyVectorOfStrings(textures()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* texturePngs */) &&
           verifier.Verify(texturePngs()) &&
           verifier.VerifyVectorOfStrings(texturePngs()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* nodeTree */) &&
           verifier.VerifyTable(nodeTree()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 12 /* action */) &&
           verifier.VerifyTable(action()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 14 /* animationList */) &&
           verifier.Verify(animationList()) &&
           verifier.VerifyVectorOfTables(animationList()) &&
           verifier.EndTable();
  }
};

struct CSParseBinaryBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_version(flatbuffers::Offset<flatbuffers::String> version) { fbb_.AddOffset(4, version); }
  void add_textures(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> textures) { fbb_.AddOffset(6, textures); }
  void add_texturePngs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> texturePngs) { fbb_.AddOffset(8, texturePngs); }
  void add_nodeTree(flatbuffers::Offset<NodeTree> nodeTree) { fbb_.AddOffset(10, nodeTree); }
  void add_action(flatbuffers::Offset<NodeAction> action) { fbb_.AddOffset(12, action); }
  void add_animationList(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<AnimationInfo>>> animationList) { fbb_.AddOffset(14, animationList); }
  CSParseBinaryBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  CSParseBinaryBuilder &operator=(const CSParseBinaryBuilder &);
  flatbuffers::Offset<CSParseBinary> Finish() {
    auto o = flatbuffers::Offset<CSParseBinary>(fbb_.EndTable(start_, 6));
    return o;
  }
};

inline flatbuffers::Offset<CSParseBinary> CreateCSParseBinary(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<flatbuffers::String> version = 0,
   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> textures = 0,
   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> texturePngs = 0,
   flatbuffers::Offset<NodeTree> nodeTree = 0,
   flatbuffers::Offset<NodeAction> action = 0,
   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<AnimationInfo>>> animationList = 0) {
  CSParseBinaryBuilder builder_(_fbb);
  builder_.add_animationList(animationList);
  builder_.add_action(action);
  builder_.add_nodeTree(nodeTree);
  builder_.add_texturePngs(texturePngs);
  builder_.add_textures(textures);
  builder_.add_version(version);
  return builder_.Finish();
}

struct NodeTree : private flatbuffers::Table {
  const flatbuffers::String *classname() const { return GetPointer<const flatbuffers::String *>(4); }
  const flatbuffers::Vector<flatbuffers::Offset<NodeTree>> *children() const { return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<NodeTree>> *>(6); }
  const Options *options() const { return GetPointer<const Options *>(8); }
  const flatbuffers::String *customClassName() const { return GetPointer<const flatbuffers::String *>(10); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* classname */) &&
           verifier.Verify(classname()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* children */) &&
           verifier.Verify(children()) &&
           verifier.VerifyVectorOfTables(children()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* options */) &&
           verifier.VerifyTable(options()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* customClassName */) &&
           verifier.Verify(customClassName()) &&
           verifier.EndTable();
  }
};

struct NodeTreeBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_classname(flatbuffers::Offset<flatbuffers::String> classname) { fbb_.AddOffset(4, classname); }
  void add_children(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<NodeTree>>> children) { fbb_.AddOffset(6, children); }
  void add_options(flatbuffers::Offset<Options> options) { fbb_.AddOffset(8, options); }
  void add_customClassName(flatbuffers::Offset<flatbuffers::String> customClassName) { fbb_.AddOffset(10, customClassName); }
  NodeTreeBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  NodeTreeBuilder &operator=(const NodeTreeBuilder &);
  flatbuffers::Offset<NodeTree> Finish() {
    auto o = flatbuffers::Offset<NodeTree>(fbb_.EndTable(start_, 4));
    return o;
  }
};

inline flatbuffers::Offset<NodeTree> CreateNodeTree(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<flatbuffers::String> classname = 0,
   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<NodeTree>>> children = 0,
   flatbuffers::Offset<Options> options = 0,
   flatbuffers::Offset<flatbuffers::String> customClassName = 0) {
  NodeTreeBuilder builder_(_fbb);
  builder_.add_customClassName(customClassName);
  builder_.add_options(options);
  builder_.add_children(children);
  builder_.add_classname(classname);
  return builder_.Finish();
}

struct Options : private flatbuffers::Table {
  const Table *data() const { return GetPointer<const Table *>(4); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* data */) &&
//           verifier.VerifyTable(data()) &&
           verifier.EndTable();
  }
};

struct OptionsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_data(flatbuffers::Offset<Table> data) { fbb_.AddOffset(4, data); }
  OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  OptionsBuilder &operator=(const OptionsBuilder &);
  flatbuffers::Offset<Options> Finish() {
    auto o = flatbuffers::Offset<Options>(fbb_.EndTable(start_, 1));
    return o;
  }
};

inline flatbuffers::Offset<Options> CreateOptions(flatbuffers::FlatBufferBuilder &_fbb,
  flatbuffers::Offset<Table> data = 0) {
  OptionsBuilder builder_(_fbb);
  builder_.add_data(data);
  return builder_.Finish();
}

struct WidgetOptions : private flatbuffers::Table {
  const flatbuffers::String *name() const { return GetPointer<const flatbuffers::String *>(4); }
  int32_t actionTag() const { return GetField<int32_t>(6, 0); }
  const RotationSkew *rotationSkew() const { return GetStruct<const RotationSkew *>(8); }
  int32_t zOrder() const { return GetField<int32_t>(10, 0); }
  uint8_t visible() const { return GetField<uint8_t>(12, 1); }
  uint8_t alpha() const { return GetField<uint8_t>(14, 255); }
  int32_t tag() const { return GetField<int32_t>(16, 0); }
  const Position *position() const { return GetStruct<const Position *>(18); }
  const Scale *scale() const { return GetStruct<const Scale *>(20); }
  const AnchorPoint *anchorPoint() const { return GetStruct<const AnchorPoint *>(22); }
  const Color *color() const { return GetStruct<const Color *>(24); }
  const FlatSize *size() const { return GetStruct<const FlatSize *>(26); }
  uint8_t flipX() const { return GetField<uint8_t>(28, 0); }
  uint8_t flipY() const { return GetField<uint8_t>(30, 0); }
  uint8_t ignoreSize() const { return GetField<uint8_t>(32, 0); }
  uint8_t touchEnabled() const { return GetField<uint8_t>(34, 0); }
  const flatbuffers::String *frameEvent() const { return GetPointer<const flatbuffers::String *>(36); }
  const flatbuffers::String *customProperty() const { return GetPointer<const flatbuffers::String *>(38); }
  const flatbuffers::String *callBackType() const { return GetPointer<const flatbuffers::String *>(40); }
  const flatbuffers::String *callBackName() const { return GetPointer<const flatbuffers::String *>(42); }
  const LayoutComponentTable *layoutComponent() const { return GetPointer<const LayoutComponentTable *>(44); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* name */) &&
           verifier.Verify(name()) &&
           VerifyField<int32_t>(verifier, 6 /* actionTag */) &&
           VerifyField<RotationSkew>(verifier, 8 /* rotationSkew */) &&
           VerifyField<int32_t>(verifier, 10 /* zOrder */) &&
           VerifyField<uint8_t>(verifier, 12 /* visible */) &&
           VerifyField<uint8_t>(verifier, 14 /* alpha */) &&
           VerifyField<int32_t>(verifier, 16 /* tag */) &&
           VerifyField<Position>(verifier, 18 /* position */) &&
           VerifyField<Scale>(verifier, 20 /* scale */) &&
           VerifyField<AnchorPoint>(verifier, 22 /* anchorPoint */) &&
           VerifyField<Color>(verifier, 24 /* color */) &&
           VerifyField<FlatSize>(verifier, 26 /* size */) &&
           VerifyField<uint8_t>(verifier, 28 /* flipX */) &&
           VerifyField<uint8_t>(verifier, 30 /* flipY */) &&
           VerifyField<uint8_t>(verifier, 32 /* ignoreSize */) &&
           VerifyField<uint8_t>(verifier, 34 /* touchEnabled */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 36 /* frameEvent */) &&
           verifier.Verify(frameEvent()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 38 /* customProperty */) &&
           verifier.Verify(customProperty()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 40 /* callBackType */) &&
           verifier.Verify(callBackType()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 42 /* callBackName */) &&
           verifier.Verify(callBackName()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 44 /* layoutComponent */) &&
           verifier.VerifyTable(layoutComponent()) &&
           verifier.EndTable();
  }
};

struct WidgetOptionsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(4, name); }
  void add_actionTag(int32_t actionTag) { fbb_.AddElement<int32_t>(6, actionTag, 0); }
  void add_rotationSkew(const RotationSkew *rotationSkew) { fbb_.AddStruct(8, rotationSkew); }
  void add_zOrder(int32_t zOrder) { fbb_.AddElement<int32_t>(10, zOrder, 0); }
  void add_visible(uint8_t visible) { fbb_.AddElement<uint8_t>(12, visible, 1); }
  void add_alpha(uint8_t alpha) { fbb_.AddElement<uint8_t>(14, alpha, 255); }
  void add_tag(int32_t tag) { fbb_.AddElement<int32_t>(16, tag, 0); }
  void add_position(const Position *position) { fbb_.AddStruct(18, position); }
  void add_scale(const Scale *scale) { fbb_.AddStruct(20, scale); }
  void add_anchorPoint(const AnchorPoint *anchorPoint) { fbb_.AddStruct(22, anchorPoint); }
  void add_color(const Color *color) { fbb_.AddStruct(24, color); }
  void add_size(const FlatSize *size) { fbb_.AddStruct(26, size); }
  void add_flipX(uint8_t flipX) { fbb_.AddElement<uint8_t>(28, flipX, 0); }
  void add_flipY(uint8_t flipY) { fbb_.AddElement<uint8_t>(30, flipY, 0); }
  void add_ignoreSize(uint8_t ignoreSize) { fbb_.AddElement<uint8_t>(32, ignoreSize, 0); }
  void add_touchEnabled(uint8_t touchEnabled) { fbb_.AddElement<uint8_t>(34, touchEnabled, 0); }
  void add_frameEvent(flatbuffers::Offset<flatbuffers::String> frameEvent) { fbb_.AddOffset(36, frameEvent); }
  void add_customProperty(flatbuffers::Offset<flatbuffers::String> customProperty) { fbb_.AddOffset(38, customProperty); }
  void add_callBackType(flatbuffers::Offset<flatbuffers::String> callBackType) { fbb_.AddOffset(40, callBackType); }
  void add_callBackName(flatbuffers::Offset<flatbuffers::String> callBackName) { fbb_.AddOffset(42, callBackName); }
  void add_layoutComponent(flatbuffers::Offset<LayoutComponentTable> layoutComponent) { fbb_.AddOffset(44, layoutComponent); }
  WidgetOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  WidgetOptionsBuilder &operator=(const WidgetOptionsBuilder &);
  flatbuffers::Offset<WidgetOptions> Finish() {
    auto o = flatbuffers::Offset<WidgetOptions>(fbb_.EndTable(start_, 21));
    return o;
  }
};

inline flatbuffers::Offset<WidgetOptions> CreateWidgetOptions(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<flatbuffers::String> name = 0,
   int32_t actionTag = 0,
   const RotationSkew *rotationSkew = 0,
   int32_t zOrder = 0,
   uint8_t visible = 1,
   uint8_t alpha = 255,
   int32_t tag = 0,
   const Position *position = 0,
   const Scale *scale = 0,
   const AnchorPoint *anchorPoint = 0,
   const Color *color = 0,
   const FlatSize *size = 0,
   uint8_t flipX = 0,
   uint8_t flipY = 0,
   uint8_t ignoreSize = 0,
   uint8_t touchEnabled = 0,
   flatbuffers::Offset<flatbuffers::String> frameEvent = 0,
   flatbuffers::Offset<flatbuffers::String> customProperty = 0,
   flatbuffers::Offset<flatbuffers::String> callBackType = 0,
   flatbuffers::Offset<flatbuffers::String> callBackName = 0,
   flatbuffers::Offset<LayoutComponentTable> layoutComponent = 0) {
  WidgetOptionsBuilder builder_(_fbb);
  builder_.add_layoutComponent(layoutComponent);
  builder_.add_callBackName(callBackName);
  builder_.add_callBackType(callBackType);
  builder_.add_customProperty(customProperty);
  builder_.add_frameEvent(frameEvent);
  builder_.add_size(size);
  builder_.add_color(color);
  builder_.add_anchorPoint(anchorPoint);
  builder_.add_scale(scale);
  builder_.add_position(position);
  builder_.add_tag(tag);
  builder_.add_zOrder(zOrder);
  builder_.add_rotationSkew(rotationSkew);
  builder_.add_actionTag(actionTag);
  builder_.add_name(name);
  builder_.add_touchEnabled(touchEnabled);
  builder_.add_ignoreSize(ignoreSize);
  builder_.add_flipY(flipY);
  builder_.add_flipX(flipX);
  builder_.add_alpha(alpha);
  builder_.add_visible(visible);
  return builder_.Finish();
}

struct LayoutComponentTable : private flatbuffers::Table {
  uint8_t positionXPercentEnabled() const { return GetField<uint8_t>(4, 0); }
  uint8_t positionYPercentEnabled() const { return GetField<uint8_t>(6, 0); }
  float positionXPercent() const { return GetField<float>(8, 0); }
  float positionYPercent() const { return GetField<float>(10, 0); }
  uint8_t sizeXPercentEnable() const { return GetField<uint8_t>(12, 0); }
  uint8_t sizeYPercentEnable() const { return GetField<uint8_t>(14, 0); }
  float sizeXPercent() const { return GetField<float>(16, 0); }
  float sizeYPercent() const { return GetField<float>(18, 0); }
  uint8_t stretchHorizontalEnabled() const { return GetField<uint8_t>(20, 0); }
  uint8_t stretchVerticalEnabled() const { return GetField<uint8_t>(22, 0); }
  const flatbuffers::String *horizontalEdge() const { return GetPointer<const flatbuffers::String *>(24); }
  const flatbuffers::String *verticalEdge() const { return GetPointer<const flatbuffers::String *>(26); }
  float leftMargin() const { return GetField<float>(28, 0); }
  float rightMargin() const { return GetField<float>(30, 0); }
  float topMargin() const { return GetField<float>(32, 0); }
  float bottomMargin() const { return GetField<float>(34, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, 4 /* positionXPercentEnabled */) &&
           VerifyField<uint8_t>(verifier, 6 /* positionYPercentEnabled */) &&
           VerifyField<float>(verifier, 8 /* positionXPercent */) &&
           VerifyField<float>(verifier, 10 /* positionYPercent */) &&
           VerifyField<uint8_t>(verifier, 12 /* sizeXPercentEnable */) &&
           VerifyField<uint8_t>(verifier, 14 /* sizeYPercentEnable */) &&
           VerifyField<float>(verifier, 16 /* sizeXPercent */) &&
           VerifyField<float>(verifier, 18 /* sizeYPercent */) &&
           VerifyField<uint8_t>(verifier, 20 /* stretchHorizontalEnabled */) &&
           VerifyField<uint8_t>(verifier, 22 /* stretchVerticalEnabled */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 24 /* horizontalEdge */) &&
           verifier.Verify(horizontalEdge()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 26 /* verticalEdge */) &&
           verifier.Verify(verticalEdge()) &&
           VerifyField<float>(verifier, 28 /* leftMargin */) &&
           VerifyField<float>(verifier, 30 /* rightMargin */) &&
           VerifyField<float>(verifier, 32 /* topMargin */) &&
           VerifyField<float>(verifier, 34 /* bottomMargin */) &&
           verifier.EndTable();
  }
};

struct LayoutComponentTableBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_positionXPercentEnabled(uint8_t positionXPercentEnabled) { fbb_.AddElement<uint8_t>(4, positionXPercentEnabled, 0); }
  void add_positionYPercentEnabled(uint8_t positionYPercentEnabled) { fbb_.AddElement<uint8_t>(6, positionYPercentEnabled, 0); }
  void add_positionXPercent(float positionXPercent) { fbb_.AddElement<float>(8, positionXPercent, 0); }
  void add_positionYPercent(float positionYPercent) { fbb_.AddElement<float>(10, positionYPercent, 0); }
  void add_sizeXPercentEnable(uint8_t sizeXPercentEnable) { fbb_.AddElement<uint8_t>(12, sizeXPercentEnable, 0); }
  void add_sizeYPercentEnable(uint8_t sizeYPercentEnable) { fbb_.AddElement<uint8_t>(14, sizeYPercentEnable, 0); }
  void add_sizeXPercent(float sizeXPercent) { fbb_.AddElement<float>(16, sizeXPercent, 0); }
  void add_sizeYPercent(float sizeYPercent) { fbb_.AddElement<float>(18, sizeYPercent, 0); }
  void add_stretchHorizontalEnabled(uint8_t stretchHorizontalEnabled) { fbb_.AddElement<uint8_t>(20, stretchHorizontalEnabled, 0); }
  void add_stretchVerticalEnabled(uint8_t stretchVerticalEnabled) { fbb_.AddElement<uint8_t>(22, stretchVerticalEnabled, 0); }
  void add_horizontalEdge(flatbuffers::Offset<flatbuffers::String> horizontalEdge) { fbb_.AddOffset(24, horizontalEdge); }
  void add_verticalEdge(flatbuffers::Offset<flatbuffers::String> verticalEdge) { fbb_.AddOffset(26, verticalEdge); }
  void add_leftMargin(float leftMargin) { fbb_.AddElement<float>(28, leftMargin, 0); }
  void add_rightMargin(float rightMargin) { fbb_.AddElement<float>(30, rightMargin, 0); }
  void add_topMargin(float topMargin) { fbb_.AddElement<float>(32, topMargin, 0); }
  void add_bottomMargin(float bottomMargin) { fbb_.AddElement<float>(34, bottomMargin, 0); }
  LayoutComponentTableBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  LayoutComponentTableBuilder &operator=(const LayoutComponentTableBuilder &);
  flatbuffers::Offset<LayoutComponentTable> Finish() {
    auto o = flatbuffers::Offset<LayoutComponentTable>(fbb_.EndTable(start_, 16));
    return o;
  }
};

inline flatbuffers::Offset<LayoutComponentTable> CreateLayoutComponentTable(flatbuffers::FlatBufferBuilder &_fbb,
   uint8_t positionXPercentEnabled = 0,
   uint8_t positionYPercentEnabled = 0,
   float positionXPercent = 0,
   float positionYPercent = 0,
   uint8_t sizeXPercentEnable = 0,
   uint8_t sizeYPercentEnable = 0,
   float sizeXPercent = 0,
   float sizeYPercent = 0,
   uint8_t stretchHorizontalEnabled = 0,
   uint8_t stretchVerticalEnabled = 0,
   flatbuffers::Offset<flatbuffers::String> horizontalEdge = 0,
   flatbuffers::Offset<flatbuffers::String> verticalEdge = 0,
   float leftMargin = 0,
   float rightMargin = 0,
   float topMargin = 0,
   float bottomMargin = 0) {
  LayoutComponentTableBuilder builder_(_fbb);
  builder_.add_bottomMargin(bottomMargin);
  builder_.add_topMargin(topMargin);
  builder_.add_rightMargin(rightMargin);
  builder_.add_leftMargin(leftMargin);
  builder_.add_verticalEdge(verticalEdge);
  builder_.add_horizontalEdge(horizontalEdge);
  builder_.add_sizeYPercent(sizeYPercent);
  builder_.add_sizeXPercent(sizeXPercent);
  builder_.add_positionYPercent(positionYPercent);
  builder_.add_positionXPercent(positionXPercent);
  builder_.add_stretchVerticalEnabled(stretchVerticalEnabled);
  builder_.add_stretchHorizontalEnabled(stretchHorizontalEnabled);
  builder_.add_sizeYPercentEnable(sizeYPercentEnable);
  builder_.add_sizeXPercentEnable(sizeXPercentEnable);
  builder_.add_positionYPercentEnabled(positionYPercentEnabled);
  builder_.add_positionXPercentEnabled(positionXPercentEnabled);
  return builder_.Finish();
}

struct SingleNodeOptions : private flatbuffers::Table {
  const WidgetOptions *nodeOptions() const { return GetPointer<const WidgetOptions *>(4); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* nodeOptions */) &&
           verifier.VerifyTable(nodeOptions()) &&
           verifier.EndTable();
  }
};

struct SingleNodeOptionsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_nodeOptions(flatbuffers::Offset<WidgetOptions> nodeOptions) { fbb_.AddOffset(4, nodeOptions); }
  SingleNodeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  SingleNodeOptionsBuilder &operator=(const SingleNodeOptionsBuilder &);
  flatbuffers::Offset<SingleNodeOptions> Finish() {
    auto o = flatbuffers::Offset<SingleNodeOptions>(fbb_.EndTable(start_, 1));
    return o;
  }
};

inline flatbuffers::Offset<SingleNodeOptions> CreateSingleNodeOptions(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<WidgetOptions> nodeOptions = 0) {
  SingleNodeOptionsBuilder builder_(_fbb);
  builder_.add_nodeOptions(nodeOptions);
  return builder_.Finish();
}

struct SpriteOptions : private flatbuffers::Table {
  const WidgetOptions *nodeOptions() const { return GetPointer<const WidgetOptions *>(4); }
  const ResourceData *fileNameData() const { return GetPointer<const ResourceData *>(6); }
  const BlendFunc *blendFunc() const { return GetStruct<const BlendFunc *>(8); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* nodeOptions */) &&
           verifier.VerifyTable(nodeOptions()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* fileNameData */) &&
           verifier.VerifyTable(fileNameData()) &&
           VerifyField<BlendFunc>(verifier, 8 /* blendFunc */) &&
           verifier.EndTable();
  }
};

struct SpriteOptionsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_nodeOptions(flatbuffers::Offset<WidgetOptions> nodeOptions) { fbb_.AddOffset(4, nodeOptions); }
  void add_fileNameData(flatbuffers::Offset<ResourceData> fileNameData) { fbb_.AddOffset(6, fileNameData); }
  void add_blendFunc(const BlendFunc *blendFunc) { fbb_.AddStruct(8, blendFunc); }
  SpriteOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  SpriteOptionsBuilder &operator=(const SpriteOptionsBuilder &);
  flatbuffers::Offset<SpriteOptions> Finish() {
    auto o = flatbuffers::Offset<SpriteOptions>(fbb_.EndTable(start_, 3));
    return o;
  }
};

inline flatbuffers::Offset<SpriteOptions> CreateSpriteOptions(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<WidgetOptions> nodeOptions = 0,
   flatbuffers::Offset<ResourceData> fileNameData = 0,
   const BlendFunc *blendFunc = 0) {
  SpriteOptionsBuilder builder_(_fbb);
  builder_.add_blendFunc(blendFunc);
  builder_.add_fileNameData(fileNameData);
  builder_.add_nodeOptions(nodeOptions);
  return builder_.Finish();
}

struct ParticleSystemOptions : private flatbuffers::Table {
  const WidgetOptions *nodeOptions() const { return GetPointer<const WidgetOptions *>(4); }
  const ResourceData *fileNameData() const { return GetPointer<const ResourceData *>(6); }
  const BlendFunc *blendFunc() const { return GetStruct<const BlendFunc *>(8); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* nodeOptions */) &&
           verifier.VerifyTable(nodeOptions()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* fileNameData */) &&
           verifier.VerifyTable(fileNameData()) &&
           VerifyField<BlendFunc>(verifier, 8 /* blendFunc */) &&
           verifier.EndTable();
  }
};

struct ParticleSystemOptionsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_nodeOptions(flatbuffers::Offset<WidgetOptions> nodeOptions) { fbb_.AddOffset(4, nodeOptions); }
  void add_fileNameData(flatbuffers::Offset<ResourceData> fileNameData) { fbb_.AddOffset(6, fileNameData); }
  void add_blendFunc(const BlendFunc *blendFunc) { fbb_.AddStruct(8, blendFunc); }
  ParticleSystemOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  ParticleSystemOptionsBuilder &operator=(const ParticleSystemOptionsBuilder &);
  flatbuffers::Offset<ParticleSystemOptions> Finish() {
    auto o = flatbuffers::Offset<ParticleSystemOptions>(fbb_.EndTable(start_, 3));
    return o;
  }
};

inline flatbuffers::Offset<ParticleSystemOptions> CreateParticleSystemOptions(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<WidgetOptions> nodeOptions = 0,
   flatbuffers::Offset<ResourceData> fileNameData = 0,
   const BlendFunc *blendFunc = 0) {
  ParticleSystemOptionsBuilder builder_(_fbb);
  builder_.add_blendFunc(blendFunc);
  builder_.add_fileNameData(fileNameData);
  builder_.add_nodeOptions(nodeOptions);
  return builder_.Finish();
}

struct GameMapOptions : private flatbuffers::Table {
  const WidgetOptions *nodeOptions() const { return GetPointer<const WidgetOptions *>(4); }
  const ResourceData *fileNameData() const { return GetPointer<const ResourceData *>(6); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* nodeOptions */) &&
           verifier.VerifyTable(nodeOptions()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* fileNameData */) &&
           verifier.VerifyTable(fileNameData()) &&
           verifier.EndTable();
  }
};

struct GameMapOptionsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_nodeOptions(flatbuffers::Offset<WidgetOptions> nodeOptions) { fbb_.AddOffset(4, nodeOptions); }
  void add_fileNameData(flatbuffers::Offset<ResourceData> fileNameData) { fbb_.AddOffset(6, fileNameData); }
  GameMapOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  GameMapOptionsBuilder &operator=(const GameMapOptionsBuilder &);
  flatbuffers::Offset<GameMapOptions> Finish() {
    auto o = flatbuffers::Offset<GameMapOptions>(fbb_.EndTable(start_, 2));
    return o;
  }
};

inline flatbuffers::Offset<GameMapOptions> CreateGameMapOptions(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<WidgetOptions> nodeOptions = 0,
   flatbuffers::Offset<ResourceData> fileNameData = 0) {
  GameMapOptionsBuilder builder_(_fbb);
  builder_.add_fileNameData(fileNameData);
  builder_.add_nodeOptions(nodeOptions);
  return builder_.Finish();
}

struct ButtonOptions : private flatbuffers::Table {
  const WidgetOptions *widgetOptions() const { return GetPointer<const WidgetOptions *>(4); }
  const ResourceData *normalData() const { return GetPointer<const ResourceData *>(6); }
  const ResourceData *pressedData() const { return GetPointer<const ResourceData *>(8); }
  const ResourceData *disabledData() const { return GetPointer<const ResourceData *>(10); }
  const ResourceData *fontResource() const { return GetPointer<const ResourceData *>(12); }
  const flatbuffers::String *text() const { return GetPointer<const flatbuffers::String *>(14); }
  const flatbuffers::String *fontName() const { return GetPointer<const flatbuffers::String *>(16); }
  int32_t fontSize() const { return GetField<int32_t>(18, 0); }
  const Color *textColor() const { return GetStruct<const Color *>(20); }
  const CapInsets *capInsets() const { return GetStruct<const CapInsets *>(22); }
  const FlatSize *scale9Size() const { return GetStruct<const FlatSize *>(24); }
  uint8_t scale9Enabled() const { return GetField<uint8_t>(26, 0); }
  uint8_t displaystate() const { return GetField<uint8_t>(28, 1); }
  uint8_t outlineEnabled() const { return GetField<uint8_t>(30, 0); }
  const Color *outlineColor() const { return GetStruct<const Color *>(32); }
  int32_t outlineSize() const { return GetField<int32_t>(34, 1); }
  uint8_t shadowEnabled() const { return GetField<uint8_t>(36, 0); }
  const Color *shadowColor() const { return GetStruct<const Color *>(38); }
  float shadowOffsetX() const { return GetField<float>(40, 2); }
  float shadowOffsetY() const { return GetField<float>(42, -2); }
  int32_t shadowBlurRadius() const { return GetField<int32_t>(44, 0); }
  uint8_t isLocalized() const { return GetField<uint8_t>(46, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* widgetOptions */) &&
           verifier.VerifyTable(widgetOptions()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* normalData */) &&
           verifier.VerifyTable(normalData()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* pressedData */) &&
           verifier.VerifyTable(pressedData()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* disabledData */) &&
           verifier.VerifyTable(disabledData()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 12 /* fontResource */) &&
           verifier.VerifyTable(fontResource()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 14 /* text */) &&
           verifier.Verify(text()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 16 /* fontName */) &&
           verifier.Verify(fontName()) &&
           VerifyField<int32_t>(verifier, 18 /* fontSize */) &&
           VerifyField<Color>(verifier, 20 /* textColor */) &&
           VerifyField<CapInsets>(verifier, 22 /* capInsets */) &&
           VerifyField<FlatSize>(verifier, 24 /* scale9Size */) &&
           VerifyField<uint8_t>(verifier, 26 /* scale9Enabled */) &&
           VerifyField<uint8_t>(verifier, 28 /* displaystate */) &&
           VerifyField<uint8_t>(verifier, 30 /* outlineEnabled */) &&
           VerifyField<Color>(verifier, 32 /* outlineColor */) &&
           VerifyField<int32_t>(verifier, 34 /* outlineSize */) &&
           VerifyField<uint8_t>(verifier, 36 /* shadowEnabled */) &&
           VerifyField<Color>(verifier, 38 /* shadowColor */) &&
           VerifyField<float>(verifier, 40 /* shadowOffsetX */) &&
           VerifyField<float>(verifier, 42 /* shadowOffsetY */) &&
           VerifyField<int32_t>(verifier, 44 /* shadowBlurRadius */) &&
           VerifyField<uint8_t>(verifier, 46 /* isLocalized */) &&
           verifier.EndTable();
  }
};

struct ButtonOptionsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions) { fbb_.AddOffset(4, widgetOptions); }
  void add_normalData(flatbuffers::Offset<ResourceData> normalData) { fbb_.AddOffset(6, normalData); }
  void add_pressedData(flatbuffers::Offset<ResourceData> pressedData) { fbb_.AddOffset(8, pressedData); }
  void add_disabledData(flatbuffers::Offset<ResourceData> disabledData) { fbb_.AddOffset(10, disabledData); }
  void add_fontResource(flatbuffers::Offset<ResourceData> fontResource) { fbb_.AddOffset(12, fontResource); }
  void add_text(flatbuffers::Offset<flatbuffers::String> text) { fbb_.AddOffset(14, text); }
  void add_fontName(flatbuffers::Offset<flatbuffers::String> fontName) { fbb_.AddOffset(16, fontName); }
  void add_fontSize(int32_t fontSize) { fbb_.AddElement<int32_t>(18, fontSize, 0); }
  void add_textColor(const Color *textColor) { fbb_.AddStruct(20, textColor); }
  void add_capInsets(const CapInsets *capInsets) { fbb_.AddStruct(22, capInsets); }
  void add_scale9Size(const FlatSize *scale9Size) { fbb_.AddStruct(24, scale9Size); }
  void add_scale9Enabled(uint8_t scale9Enabled) { fbb_.AddElement<uint8_t>(26, scale9Enabled, 0); }
  void add_displaystate(uint8_t displaystate) { fbb_.AddElement<uint8_t>(28, displaystate, 1); }
  void add_outlineEnabled(uint8_t outlineEnabled) { fbb_.AddElement<uint8_t>(30, outlineEnabled, 0); }
  void add_outlineColor(const Color *outlineColor) { fbb_.AddStruct(32, outlineColor); }
  void add_outlineSize(int32_t outlineSize) { fbb_.AddElement<int32_t>(34, outlineSize, 1); }
  void add_shadowEnabled(uint8_t shadowEnabled) { fbb_.AddElement<uint8_t>(36, shadowEnabled, 0); }
  void add_shadowColor(const Color *shadowColor) { fbb_.AddStruct(38, shadowColor); }
  void add_shadowOffsetX(float shadowOffsetX) { fbb_.AddElement<float>(40, shadowOffsetX, 2); }
  void add_shadowOffsetY(float shadowOffsetY) { fbb_.AddElement<float>(42, shadowOffsetY, -2); }
  void add_shadowBlurRadius(int32_t shadowBlurRadius) { fbb_.AddElement<int32_t>(44, shadowBlurRadius, 0); }
  void add_isLocalized(uint8_t isLocalized) { fbb_.AddElement<uint8_t>(46, isLocalized, 0); }
  ButtonOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  ButtonOptionsBuilder &operator=(const ButtonOptionsBuilder &);
  flatbuffers::Offset<ButtonOptions> Finish() {
    auto o = flatbuffers::Offset<ButtonOptions>(fbb_.EndTable(start_, 22));
    return o;
  }
};

inline flatbuffers::Offset<ButtonOptions> CreateButtonOptions(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<WidgetOptions> widgetOptions = 0,
   flatbuffers::Offset<ResourceData> normalData = 0,
   flatbuffers::Offset<ResourceData> pressedData = 0,
   flatbuffers::Offset<ResourceData> disabledData = 0,
   flatbuffers::Offset<ResourceData> fontResource = 0,
   flatbuffers::Offset<flatbuffers::String> text = 0,
   flatbuffers::Offset<flatbuffers::String> fontName = 0,
   int32_t fontSize = 0,
   const Color *textColor = 0,
   const CapInsets *capInsets = 0,
   const FlatSize *scale9Size = 0,
   uint8_t scale9Enabled = 0,
   uint8_t displaystate = 1,
   uint8_t outlineEnabled = 0,
   const Color *outlineColor = 0,
   int32_t outlineSize = 1,
   uint8_t shadowEnabled = 0,
   const Color *shadowColor = 0,
   float shadowOffsetX = 2,
   float shadowOffsetY = -2,
   int32_t shadowBlurRadius = 0,
   uint8_t isLocalized = 0) {
  ButtonOptionsBuilder builder_(_fbb);
  builder_.add_shadowBlurRadius(shadowBlurRadius);
  builder_.add_shadowOffsetY(shadowOffsetY);
  builder_.add_shadowOffsetX(shadowOffsetX);
  builder_.add_shadowColor(shadowColor);
  builder_.add_outlineSize(outlineSize);
  builder_.add_outlineColor(outlineColor);
  builder_.add_scale9Size(scale9Size);
  builder_.add_capInsets(capInsets);
  builder_.add_textColor(textColor);
  builder_.add_fontSize(fontSize);
  builder_.add_fontName(fontName);
  builder_.add_text(text);
  builder_.add_fontResource(fontResource);
  builder_.add_disabledData(disabledData);
  builder_.add_pressedData(pressedData);
  builder_.add_normalData(normalData);
  builder_.add_widgetOptions(widgetOptions);
  builder_.add_isLocalized(isLocalized);
  builder_.add_shadowEnabled(shadowEnabled);
  builder_.add_outlineEnabled(outlineEnabled);
  builder_.add_displaystate(displaystate);
  builder_.add_scale9Enabled(scale9Enabled);
  return builder_.Finish();
}

struct CheckBoxOptions : private flatbuffers::Table {
  const WidgetOptions *widgetOptions() const { return GetPointer<const WidgetOptions *>(4); }
  const ResourceData *backGroundBoxData() const { return GetPointer<const ResourceData *>(6); }
  const ResourceData *backGroundBoxSelectedData() const { return GetPointer<const ResourceData *>(8); }
  const ResourceData *frontCrossData() const { return GetPointer<const ResourceData *>(10); }
  const ResourceData *backGroundBoxDisabledData() const { return GetPointer<const ResourceData *>(12); }
  const ResourceData *frontCrossDisabledData() const { return GetPointer<const ResourceData *>(14); }
  uint8_t selectedState() const { return GetField<uint8_t>(16, 1); }
  uint8_t displaystate() const { return GetField<uint8_t>(18, 1); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* widgetOptions */) &&
           verifier.VerifyTable(widgetOptions()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* backGroundBoxData */) &&
           verifier.VerifyTable(backGroundBoxData()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* backGroundBoxSelectedData */) &&
           verifier.VerifyTable(backGroundBoxSelectedData()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* frontCrossData */) &&
           verifier.VerifyTable(frontCrossData()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 12 /* backGroundBoxDisabledData */) &&
           verifier.VerifyTable(backGroundBoxDisabledData()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 14 /* frontCrossDisabledData */) &&
           verifier.VerifyTable(frontCrossDisabledData()) &&
           VerifyField<uint8_t>(verifier, 16 /* selectedState */) &&
           VerifyField<uint8_t>(verifier, 18 /* displaystate */) &&
           verifier.EndTable();
  }
};

struct CheckBoxOptionsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions) { fbb_.AddOffset(4, widgetOptions); }
  void add_backGroundBoxData(flatbuffers::Offset<ResourceData> backGroundBoxData) { fbb_.AddOffset(6, backGroundBoxData); }
  void add_backGroundBoxSelectedData(flatbuffers::Offset<ResourceData> backGroundBoxSelectedData) { fbb_.AddOffset(8, backGroundBoxSelectedData); }
  void add_frontCrossData(flatbuffers::Offset<ResourceData> frontCrossData) { fbb_.AddOffset(10, frontCrossData); }
  void add_backGroundBoxDisabledData(flatbuffers::Offset<ResourceData> backGroundBoxDisabledData) { fbb_.AddOffset(12, backGroundBoxDisabledData); }
  void add_frontCrossDisabledData(flatbuffers::Offset<ResourceData> frontCrossDisabledData) { fbb_.AddOffset(14, frontCrossDisabledData); }
  void add_selectedState(uint8_t selectedState) { fbb_.AddElement<uint8_t>(16, selectedState, 1); }
  void add_displaystate(uint8_t displaystate) { fbb_.AddElement<uint8_t>(18, displaystate, 1); }
  CheckBoxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  CheckBoxOptionsBuilder &operator=(const CheckBoxOptionsBuilder &);
  flatbuffers::Offset<CheckBoxOptions> Finish() {
    auto o = flatbuffers::Offset<CheckBoxOptions>(fbb_.EndTable(start_, 8));
    return o;
  }
};

inline flatbuffers::Offset<CheckBoxOptions> CreateCheckBoxOptions(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<WidgetOptions> widgetOptions = 0,
   flatbuffers::Offset<ResourceData> backGroundBoxData = 0,
   flatbuffers::Offset<ResourceData> backGroundBoxSelectedData = 0,
   flatbuffers::Offset<ResourceData> frontCrossData = 0,
   flatbuffers::Offset<ResourceData> backGroundBoxDisabledData = 0,
   flatbuffers::Offset<ResourceData> frontCrossDisabledData = 0,
   uint8_t selectedState = 1,
   uint8_t displaystate = 1) {
  CheckBoxOptionsBuilder builder_(_fbb);
  builder_.add_frontCrossDisabledData(frontCrossDisabledData);
  builder_.add_backGroundBoxDisabledData(backGroundBoxDisabledData);
  builder_.add_frontCrossData(frontCrossData);
  builder_.add_backGroundBoxSelectedData(backGroundBoxSelectedData);
  builder_.add_backGroundBoxData(backGroundBoxData);
  builder_.add_widgetOptions(widgetOptions);
  builder_.add_displaystate(displaystate);
  builder_.add_selectedState(selectedState);
  return builder_.Finish();
}

struct ImageViewOptions : private flatbuffers::Table {
  const WidgetOptions *widgetOptions() const { return GetPointer<const WidgetOptions *>(4); }
  const ResourceData *fileNameData() const { return GetPointer<const ResourceData *>(6); }
  const CapInsets *capInsets() const { return GetStruct<const CapInsets *>(8); }
  const FlatSize *scale9Size() const { return GetStruct<const FlatSize *>(10); }
  uint8_t scale9Enabled() const { return GetField<uint8_t>(12, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* widgetOptions */) &&
           verifier.VerifyTable(widgetOptions()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* fileNameData */) &&
           verifier.VerifyTable(fileNameData()) &&
           VerifyField<CapInsets>(verifier, 8 /* capInsets */) &&
           VerifyField<FlatSize>(verifier, 10 /* scale9Size */) &&
           VerifyField<uint8_t>(verifier, 12 /* scale9Enabled */) &&
           verifier.EndTable();
  }
};

struct ImageViewOptionsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions) { fbb_.AddOffset(4, widgetOptions); }
  void add_fileNameData(flatbuffers::Offset<ResourceData> fileNameData) { fbb_.AddOffset(6, fileNameData); }
  void add_capInsets(const CapInsets *capInsets) { fbb_.AddStruct(8, capInsets); }
  void add_scale9Size(const FlatSize *scale9Size) { fbb_.AddStruct(10, scale9Size); }
  void add_scale9Enabled(uint8_t scale9Enabled) { fbb_.AddElement<uint8_t>(12, scale9Enabled, 0); }
  ImageViewOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  ImageViewOptionsBuilder &operator=(const ImageViewOptionsBuilder &);
  flatbuffers::Offset<ImageViewOptions> Finish() {
    auto o = flatbuffers::Offset<ImageViewOptions>(fbb_.EndTable(start_, 5));
    return o;
  }
};

inline flatbuffers::Offset<ImageViewOptions> CreateImageViewOptions(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<WidgetOptions> widgetOptions = 0,
   flatbuffers::Offset<ResourceData> fileNameData = 0,
   const CapInsets *capInsets = 0,
   const FlatSize *scale9Size = 0,
   uint8_t scale9Enabled = 0) {
  ImageViewOptionsBuilder builder_(_fbb);
  builder_.add_scale9Size(scale9Size);
  builder_.add_capInsets(capInsets);
  builder_.add_fileNameData(fileNameData);
  builder_.add_widgetOptions(widgetOptions);
  builder_.add_scale9Enabled(scale9Enabled);
  return builder_.Finish();
}

struct TextAtlasOptions : private flatbuffers::Table {
  const WidgetOptions *widgetOptions() const { return GetPointer<const WidgetOptions *>(4); }
  const ResourceData *charMapFileData() const { return GetPointer<const ResourceData *>(6); }
  const flatbuffers::String *stringValue() const { return GetPointer<const flatbuffers::String *>(8); }
  const flatbuffers::String *startCharMap() const { return GetPointer<const flatbuffers::String *>(10); }
  int32_t itemWidth() const { return GetField<int32_t>(12, 0); }
  int32_t itemHeight() const { return GetField<int32_t>(14, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* widgetOptions */) &&
           verifier.VerifyTable(widgetOptions()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* charMapFileData */) &&
           verifier.VerifyTable(charMapFileData()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* stringValue */) &&
           verifier.Verify(stringValue()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* startCharMap */) &&
           verifier.Verify(startCharMap()) &&
           VerifyField<int32_t>(verifier, 12 /* itemWidth */) &&
           VerifyField<int32_t>(verifier, 14 /* itemHeight */) &&
           verifier.EndTable();
  }
};

struct TextAtlasOptionsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions) { fbb_.AddOffset(4, widgetOptions); }
  void add_charMapFileData(flatbuffers::Offset<ResourceData> charMapFileData) { fbb_.AddOffset(6, charMapFileData); }
  void add_stringValue(flatbuffers::Offset<flatbuffers::String> stringValue) { fbb_.AddOffset(8, stringValue); }
  void add_startCharMap(flatbuffers::Offset<flatbuffers::String> startCharMap) { fbb_.AddOffset(10, startCharMap); }
  void add_itemWidth(int32_t itemWidth) { fbb_.AddElement<int32_t>(12, itemWidth, 0); }
  void add_itemHeight(int32_t itemHeight) { fbb_.AddElement<int32_t>(14, itemHeight, 0); }
  TextAtlasOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  TextAtlasOptionsBuilder &operator=(const TextAtlasOptionsBuilder &);
  flatbuffers::Offset<TextAtlasOptions> Finish() {
    auto o = flatbuffers::Offset<TextAtlasOptions>(fbb_.EndTable(start_, 6));
    return o;
  }
};

inline flatbuffers::Offset<TextAtlasOptions> CreateTextAtlasOptions(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<WidgetOptions> widgetOptions = 0,
   flatbuffers::Offset<ResourceData> charMapFileData = 0,
   flatbuffers::Offset<flatbuffers::String> stringValue = 0,
   flatbuffers::Offset<flatbuffers::String> startCharMap = 0,
   int32_t itemWidth = 0,
   int32_t itemHeight = 0) {
  TextAtlasOptionsBuilder builder_(_fbb);
  builder_.add_itemHeight(itemHeight);
  builder_.add_itemWidth(itemWidth);
  builder_.add_startCharMap(startCharMap);
  builder_.add_stringValue(stringValue);
  builder_.add_charMapFileData(charMapFileData);
  builder_.add_widgetOptions(widgetOptions);
  return builder_.Finish();
}

struct TextBMFontOptions : private flatbuffers::Table {
  const WidgetOptions *widgetOptions() const { return GetPointer<const WidgetOptions *>(4); }
  const ResourceData *fileNameData() const { return GetPointer<const ResourceData *>(6); }
  const flatbuffers::String *text() const { return GetPointer<const flatbuffers::String *>(8); }
  uint8_t isLocalized() const { return GetField<uint8_t>(10, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* widgetOptions */) &&
           verifier.VerifyTable(widgetOptions()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* fileNameData */) &&
           verifier.VerifyTable(fileNameData()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* text */) &&
           verifier.Verify(text()) &&
           VerifyField<uint8_t>(verifier, 10 /* isLocalized */) &&
           verifier.EndTable();
  }
};

struct TextBMFontOptionsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions) { fbb_.AddOffset(4, widgetOptions); }
  void add_fileNameData(flatbuffers::Offset<ResourceData> fileNameData) { fbb_.AddOffset(6, fileNameData); }
  void add_text(flatbuffers::Offset<flatbuffers::String> text) { fbb_.AddOffset(8, text); }
  void add_isLocalized(uint8_t isLocalized) { fbb_.AddElement<uint8_t>(10, isLocalized, 0); }
  TextBMFontOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  TextBMFontOptionsBuilder &operator=(const TextBMFontOptionsBuilder &);
  flatbuffers::Offset<TextBMFontOptions> Finish() {
    auto o = flatbuffers::Offset<TextBMFontOptions>(fbb_.EndTable(start_, 4));
    return o;
  }
};

inline flatbuffers::Offset<TextBMFontOptions> CreateTextBMFontOptions(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<WidgetOptions> widgetOptions = 0,
   flatbuffers::Offset<ResourceData> fileNameData = 0,
   flatbuffers::Offset<flatbuffers::String> text = 0,
   uint8_t isLocalized = 0) {
  TextBMFontOptionsBuilder builder_(_fbb);
  builder_.add_text(text);
  builder_.add_fileNameData(fileNameData);
  builder_.add_widgetOptions(widgetOptions);
  builder_.add_isLocalized(isLocalized);
  return builder_.Finish();
}

struct TextOptions : private flatbuffers::Table {
  const WidgetOptions *widgetOptions() const { return GetPointer<const WidgetOptions *>(4); }
  const ResourceData *fontResource() const { return GetPointer<const ResourceData *>(6); }
  const flatbuffers::String *fontName() const { return GetPointer<const flatbuffers::String *>(8); }
  int32_t fontSize() const { return GetField<int32_t>(10, 0); }
  const flatbuffers::String *text() const { return GetPointer<const flatbuffers::String *>(12); }
  int32_t areaWidth() const { return GetField<int32_t>(14, 0); }
  int32_t areaHeight() const { return GetField<int32_t>(16, 0); }
  int32_t hAlignment() const { return GetField<int32_t>(18, 0); }
  int32_t vAlignment() const { return GetField<int32_t>(20, 0); }
  uint8_t touchScaleEnable() const { return GetField<uint8_t>(22, 0); }
  uint8_t isCustomSize() const { return GetField<uint8_t>(24, 0); }
  uint8_t outlineEnabled() const { return GetField<uint8_t>(26, 0); }
  const Color *outlineColor() const { return GetStruct<const Color *>(28); }
  int32_t outlineSize() const { return GetField<int32_t>(30, 1); }
  uint8_t shadowEnabled() const { return GetField<uint8_t>(32, 0); }
  const Color *shadowColor() const { return GetStruct<const Color *>(34); }
  float shadowOffsetX() const { return GetField<float>(36, 2); }
  float shadowOffsetY() const { return GetField<float>(38, -2); }
  int32_t shadowBlurRadius() const { return GetField<int32_t>(40, 0); }
  uint8_t isLocalized() const { return GetField<uint8_t>(42, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* widgetOptions */) &&
           verifier.VerifyTable(widgetOptions()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* fontResource */) &&
           verifier.VerifyTable(fontResource()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* fontName */) &&
           verifier.Verify(fontName()) &&
           VerifyField<int32_t>(verifier, 10 /* fontSize */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 12 /* text */) &&
           verifier.Verify(text()) &&
           VerifyField<int32_t>(verifier, 14 /* areaWidth */) &&
           VerifyField<int32_t>(verifier, 16 /* areaHeight */) &&
           VerifyField<int32_t>(verifier, 18 /* hAlignment */) &&
           VerifyField<int32_t>(verifier, 20 /* vAlignment */) &&
           VerifyField<uint8_t>(verifier, 22 /* touchScaleEnable */) &&
           VerifyField<uint8_t>(verifier, 24 /* isCustomSize */) &&
           VerifyField<uint8_t>(verifier, 26 /* outlineEnabled */) &&
           VerifyField<Color>(verifier, 28 /* outlineColor */) &&
           VerifyField<int32_t>(verifier, 30 /* outlineSize */) &&
           VerifyField<uint8_t>(verifier, 32 /* shadowEnabled */) &&
           VerifyField<Color>(verifier, 34 /* shadowColor */) &&
           VerifyField<float>(verifier, 36 /* shadowOffsetX */) &&
           VerifyField<float>(verifier, 38 /* shadowOffsetY */) &&
           VerifyField<int32_t>(verifier, 40 /* shadowBlurRadius */) &&
           VerifyField<uint8_t>(verifier, 42 /* isLocalized */) &&
           verifier.EndTable();
  }
};

struct TextOptionsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions) { fbb_.AddOffset(4, widgetOptions); }
  void add_fontResource(flatbuffers::Offset<ResourceData> fontResource) { fbb_.AddOffset(6, fontResource); }
  void add_fontName(flatbuffers::Offset<flatbuffers::String> fontName) { fbb_.AddOffset(8, fontName); }
  void add_fontSize(int32_t fontSize) { fbb_.AddElement<int32_t>(10, fontSize, 0); }
  void add_text(flatbuffers::Offset<flatbuffers::String> text) { fbb_.AddOffset(12, text); }
  void add_areaWidth(int32_t areaWidth) { fbb_.AddElement<int32_t>(14, areaWidth, 0); }
  void add_areaHeight(int32_t areaHeight) { fbb_.AddElement<int32_t>(16, areaHeight, 0); }
  void add_hAlignment(int32_t hAlignment) { fbb_.AddElement<int32_t>(18, hAlignment, 0); }
  void add_vAlignment(int32_t vAlignment) { fbb_.AddElement<int32_t>(20, vAlignment, 0); }
  void add_touchScaleEnable(uint8_t touchScaleEnable) { fbb_.AddElement<uint8_t>(22, touchScaleEnable, 0); }
  void add_isCustomSize(uint8_t isCustomSize) { fbb_.AddElement<uint8_t>(24, isCustomSize, 0); }
  void add_outlineEnabled(uint8_t outlineEnabled) { fbb_.AddElement<uint8_t>(26, outlineEnabled, 0); }
  void add_outlineColor(const Color *outlineColor) { fbb_.AddStruct(28, outlineColor); }
  void add_outlineSize(int32_t outlineSize) { fbb_.AddElement<int32_t>(30, outlineSize, 1); }
  void add_shadowEnabled(uint8_t shadowEnabled) { fbb_.AddElement<uint8_t>(32, shadowEnabled, 0); }
  void add_shadowColor(const Color *shadowColor) { fbb_.AddStruct(34, shadowColor); }
  void add_shadowOffsetX(float shadowOffsetX) { fbb_.AddElement<float>(36, shadowOffsetX, 2); }
  void add_shadowOffsetY(float shadowOffsetY) { fbb_.AddElement<float>(38, shadowOffsetY, -2); }
  void add_shadowBlurRadius(int32_t shadowBlurRadius) { fbb_.AddElement<int32_t>(40, shadowBlurRadius, 0); }
  void add_isLocalized(uint8_t isLocalized) { fbb_.AddElement<uint8_t>(42, isLocalized, 0); }
  TextOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  TextOptionsBuilder &operator=(const TextOptionsBuilder &);
  flatbuffers::Offset<TextOptions> Finish() {
    auto o = flatbuffers::Offset<TextOptions>(fbb_.EndTable(start_, 20));
    return o;
  }
};

inline flatbuffers::Offset<TextOptions> CreateTextOptions(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<WidgetOptions> widgetOptions = 0,
   flatbuffers::Offset<ResourceData> fontResource = 0,
   flatbuffers::Offset<flatbuffers::String> fontName = 0,
   int32_t fontSize = 0,
   flatbuffers::Offset<flatbuffers::String> text = 0,
   int32_t areaWidth = 0,
   int32_t areaHeight = 0,
   int32_t hAlignment = 0,
   int32_t vAlignment = 0,
   uint8_t touchScaleEnable = 0,
   uint8_t isCustomSize = 0,
   uint8_t outlineEnabled = 0,
   const Color *outlineColor = 0,
   int32_t outlineSize = 1,
   uint8_t shadowEnabled = 0,
   const Color *shadowColor = 0,
   float shadowOffsetX = 2,
   float shadowOffsetY = -2,
   int32_t shadowBlurRadius = 0,
   uint8_t isLocalized = 0) {
  TextOptionsBuilder builder_(_fbb);
  builder_.add_shadowBlurRadius(shadowBlurRadius);
  builder_.add_shadowOffsetY(shadowOffsetY);
  builder_.add_shadowOffsetX(shadowOffsetX);
  builder_.add_shadowColor(shadowColor);
  builder_.add_outlineSize(outlineSize);
  builder_.add_outlineColor(outlineColor);
  builder_.add_vAlignment(vAlignment);
  builder_.add_hAlignment(hAlignment);
  builder_.add_areaHeight(areaHeight);
  builder_.add_areaWidth(areaWidth);
  builder_.add_text(text);
  builder_.add_fontSize(fontSize);
  builder_.add_fontName(fontName);
  builder_.add_fontResource(fontResource);
  builder_.add_widgetOptions(widgetOptions);
  builder_.add_isLocalized(isLocalized);
  builder_.add_shadowEnabled(shadowEnabled);
  builder_.add_outlineEnabled(outlineEnabled);
  builder_.add_isCustomSize(isCustomSize);
  builder_.add_touchScaleEnable(touchScaleEnable);
  return builder_.Finish();
}

struct TextFieldOptions : private flatbuffers::Table {
  const WidgetOptions *widgetOptions() const { return GetPointer<const WidgetOptions *>(4); }
  const ResourceData *fontResource() const { return GetPointer<const ResourceData *>(6); }
  const flatbuffers::String *fontName() const { return GetPointer<const flatbuffers::String *>(8); }
  int32_t fontSize() const { return GetField<int32_t>(10, 0); }
  const flatbuffers::String *text() const { return GetPointer<const flatbuffers::String *>(12); }
  const flatbuffers::String *placeHolder() const { return GetPointer<const flatbuffers::String *>(14); }
  uint8_t passwordEnabled() const { return GetField<uint8_t>(16, 0); }
  const flatbuffers::String *passwordStyleText() const { return GetPointer<const flatbuffers::String *>(18); }
  uint8_t maxLengthEnabled() const { return GetField<uint8_t>(20, 0); }
  int32_t maxLength() const { return GetField<int32_t>(22, 0); }
  int32_t areaWidth() const { return GetField<int32_t>(24, 0); }
  int32_t areaHeight() const { return GetField<int32_t>(26, 0); }
  uint8_t isCustomSize() const { return GetField<uint8_t>(28, 0); }
  uint8_t isLocalized() const { return GetField<uint8_t>(30, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* widgetOptions */) &&
           verifier.VerifyTable(widgetOptions()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* fontResource */) &&
           verifier.VerifyTable(fontResource()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* fontName */) &&
           verifier.Verify(fontName()) &&
           VerifyField<int32_t>(verifier, 10 /* fontSize */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 12 /* text */) &&
           verifier.Verify(text()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 14 /* placeHolder */) &&
           verifier.Verify(placeHolder()) &&
           VerifyField<uint8_t>(verifier, 16 /* passwordEnabled */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 18 /* passwordStyleText */) &&
           verifier.Verify(passwordStyleText()) &&
           VerifyField<uint8_t>(verifier, 20 /* maxLengthEnabled */) &&
           VerifyField<int32_t>(verifier, 22 /* maxLength */) &&
           VerifyField<int32_t>(verifier, 24 /* areaWidth */) &&
           VerifyField<int32_t>(verifier, 26 /* areaHeight */) &&
           VerifyField<uint8_t>(verifier, 28 /* isCustomSize */) &&
           VerifyField<uint8_t>(verifier, 30 /* isLocalized */) &&
           verifier.EndTable();
  }
};

struct TextFieldOptionsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions) { fbb_.AddOffset(4, widgetOptions); }
  void add_fontResource(flatbuffers::Offset<ResourceData> fontResource) { fbb_.AddOffset(6, fontResource); }
  void add_fontName(flatbuffers::Offset<flatbuffers::String> fontName) { fbb_.AddOffset(8, fontName); }
  void add_fontSize(int32_t fontSize) { fbb_.AddElement<int32_t>(10, fontSize, 0); }
  void add_text(flatbuffers::Offset<flatbuffers::String> text) { fbb_.AddOffset(12, text); }
  void add_placeHolder(flatbuffers::Offset<flatbuffers::String> placeHolder) { fbb_.AddOffset(14, placeHolder); }
  void add_passwordEnabled(uint8_t passwordEnabled) { fbb_.AddElement<uint8_t>(16, passwordEnabled, 0); }
  void add_passwordStyleText(flatbuffers::Offset<flatbuffers::String> passwordStyleText) { fbb_.AddOffset(18, passwordStyleText); }
  void add_maxLengthEnabled(uint8_t maxLengthEnabled) { fbb_.AddElement<uint8_t>(20, maxLengthEnabled, 0); }
  void add_maxLength(int32_t maxLength) { fbb_.AddElement<int32_t>(22, maxLength, 0); }
  void add_areaWidth(int32_t areaWidth) { fbb_.AddElement<int32_t>(24, areaWidth, 0); }
  void add_areaHeight(int32_t areaHeight) { fbb_.AddElement<int32_t>(26, areaHeight, 0); }
  void add_isCustomSize(uint8_t isCustomSize) { fbb_.AddElement<uint8_t>(28, isCustomSize, 0); }
  void add_isLocalized(uint8_t isLocalized) { fbb_.AddElement<uint8_t>(30, isLocalized, 0); }
  TextFieldOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  TextFieldOptionsBuilder &operator=(const TextFieldOptionsBuilder &);
  flatbuffers::Offset<TextFieldOptions> Finish() {
    auto o = flatbuffers::Offset<TextFieldOptions>(fbb_.EndTable(start_, 14));
    return o;
  }
};

inline flatbuffers::Offset<TextFieldOptions> CreateTextFieldOptions(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<WidgetOptions> widgetOptions = 0,
   flatbuffers::Offset<ResourceData> fontResource = 0,
   flatbuffers::Offset<flatbuffers::String> fontName = 0,
   int32_t fontSize = 0,
   flatbuffers::Offset<flatbuffers::String> text = 0,
   flatbuffers::Offset<flatbuffers::String> placeHolder = 0,
   uint8_t passwordEnabled = 0,
   flatbuffers::Offset<flatbuffers::String> passwordStyleText = 0,
   uint8_t maxLengthEnabled = 0,
   int32_t maxLength = 0,
   int32_t areaWidth = 0,
   int32_t areaHeight = 0,
   uint8_t isCustomSize = 0,
   uint8_t isLocalized = 0) {
  TextFieldOptionsBuilder builder_(_fbb);
  builder_.add_areaHeight(areaHeight);
  builder_.add_areaWidth(areaWidth);
  builder_.add_maxLength(maxLength);
  builder_.add_passwordStyleText(passwordStyleText);
  builder_.add_placeHolder(placeHolder);
  builder_.add_text(text);
  builder_.add_fontSize(fontSize);
  builder_.add_fontName(fontName);
  builder_.add_fontResource(fontResource);
  builder_.add_widgetOptions(widgetOptions);
  builder_.add_isLocalized(isLocalized);
  builder_.add_isCustomSize(isCustomSize);
  builder_.add_maxLengthEnabled(maxLengthEnabled);
  builder_.add_passwordEnabled(passwordEnabled);
  return builder_.Finish();
}

struct LoadingBarOptions : private flatbuffers::Table {
  const WidgetOptions *widgetOptions() const { return GetPointer<const WidgetOptions *>(4); }
  const ResourceData *textureData() const { return GetPointer<const ResourceData *>(6); }
  int32_t percent() const { return GetField<int32_t>(8, 80); }
  int32_t direction() const { return GetField<int32_t>(10, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* widgetOptions */) &&
           verifier.VerifyTable(widgetOptions()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* textureData */) &&
           verifier.VerifyTable(textureData()) &&
           VerifyField<int32_t>(verifier, 8 /* percent */) &&
           VerifyField<int32_t>(verifier, 10 /* direction */) &&
           verifier.EndTable();
  }
};

struct LoadingBarOptionsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions) { fbb_.AddOffset(4, widgetOptions); }
  void add_textureData(flatbuffers::Offset<ResourceData> textureData) { fbb_.AddOffset(6, textureData); }
  void add_percent(int32_t percent) { fbb_.AddElement<int32_t>(8, percent, 80); }
  void add_direction(int32_t direction) { fbb_.AddElement<int32_t>(10, direction, 0); }
  LoadingBarOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  LoadingBarOptionsBuilder &operator=(const LoadingBarOptionsBuilder &);
  flatbuffers::Offset<LoadingBarOptions> Finish() {
    auto o = flatbuffers::Offset<LoadingBarOptions>(fbb_.EndTable(start_, 4));
    return o;
  }
};

inline flatbuffers::Offset<LoadingBarOptions> CreateLoadingBarOptions(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<WidgetOptions> widgetOptions = 0,
   flatbuffers::Offset<ResourceData> textureData = 0,
   int32_t percent = 80,
   int32_t direction = 0) {
  LoadingBarOptionsBuilder builder_(_fbb);
  builder_.add_direction(direction);
  builder_.add_percent(percent);
  builder_.add_textureData(textureData);
  builder_.add_widgetOptions(widgetOptions);
  return builder_.Finish();
}

struct SliderOptions : private flatbuffers::Table {
  const WidgetOptions *widgetOptions() const { return GetPointer<const WidgetOptions *>(4); }
  const ResourceData *barFileNameData() const { return GetPointer<const ResourceData *>(6); }
  const ResourceData *ballNormalData() const { return GetPointer<const ResourceData *>(8); }
  const ResourceData *ballPressedData() const { return GetPointer<const ResourceData *>(10); }
  const ResourceData *ballDisabledData() const { return GetPointer<const ResourceData *>(12); }
  const ResourceData *progressBarData() const { return GetPointer<const ResourceData *>(14); }
  int32_t percent() const { return GetField<int32_t>(16, 50); }
  uint8_t displaystate() const { return GetField<uint8_t>(18, 1); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* widgetOptions */) &&
           verifier.VerifyTable(widgetOptions()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* barFileNameData */) &&
           verifier.VerifyTable(barFileNameData()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* ballNormalData */) &&
           verifier.VerifyTable(ballNormalData()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* ballPressedData */) &&
           verifier.VerifyTable(ballPressedData()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 12 /* ballDisabledData */) &&
           verifier.VerifyTable(ballDisabledData()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 14 /* progressBarData */) &&
           verifier.VerifyTable(progressBarData()) &&
           VerifyField<int32_t>(verifier, 16 /* percent */) &&
           VerifyField<uint8_t>(verifier, 18 /* displaystate */) &&
           verifier.EndTable();
  }
};

struct SliderOptionsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions) { fbb_.AddOffset(4, widgetOptions); }
  void add_barFileNameData(flatbuffers::Offset<ResourceData> barFileNameData) { fbb_.AddOffset(6, barFileNameData); }
  void add_ballNormalData(flatbuffers::Offset<ResourceData> ballNormalData) { fbb_.AddOffset(8, ballNormalData); }
  void add_ballPressedData(flatbuffers::Offset<ResourceData> ballPressedData) { fbb_.AddOffset(10, ballPressedData); }
  void add_ballDisabledData(flatbuffers::Offset<ResourceData> ballDisabledData) { fbb_.AddOffset(12, ballDisabledData); }
  void add_progressBarData(flatbuffers::Offset<ResourceData> progressBarData) { fbb_.AddOffset(14, progressBarData); }
  void add_percent(int32_t percent) { fbb_.AddElement<int32_t>(16, percent, 50); }
  void add_displaystate(uint8_t displaystate) { fbb_.AddElement<uint8_t>(18, displaystate, 1); }
  SliderOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  SliderOptionsBuilder &operator=(const SliderOptionsBuilder &);
  flatbuffers::Offset<SliderOptions> Finish() {
    auto o = flatbuffers::Offset<SliderOptions>(fbb_.EndTable(start_, 8));
    return o;
  }
};

inline flatbuffers::Offset<SliderOptions> CreateSliderOptions(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<WidgetOptions> widgetOptions = 0,
   flatbuffers::Offset<ResourceData> barFileNameData = 0,
   flatbuffers::Offset<ResourceData> ballNormalData = 0,
   flatbuffers::Offset<ResourceData> ballPressedData = 0,
   flatbuffers::Offset<ResourceData> ballDisabledData = 0,
   flatbuffers::Offset<ResourceData> progressBarData = 0,
   int32_t percent = 50,
   uint8_t displaystate = 1) {
  SliderOptionsBuilder builder_(_fbb);
  builder_.add_percent(percent);
  builder_.add_progressBarData(progressBarData);
  builder_.add_ballDisabledData(ballDisabledData);
  builder_.add_ballPressedData(ballPressedData);
  builder_.add_ballNormalData(ballNormalData);
  builder_.add_barFileNameData(barFileNameData);
  builder_.add_widgetOptions(widgetOptions);
  builder_.add_displaystate(displaystate);
  return builder_.Finish();
}

struct PanelOptions : private flatbuffers::Table {
  const WidgetOptions *widgetOptions() const { return GetPointer<const WidgetOptions *>(4); }
  const ResourceData *backGroundImageData() const { return GetPointer<const ResourceData *>(6); }
  uint8_t clipEnabled() const { return GetField<uint8_t>(8, 0); }
  const Color *bgColor() const { return GetStruct<const Color *>(10); }
  const Color *bgStartColor() const { return GetStruct<const Color *>(12); }
  const Color *bgEndColor() const { return GetStruct<const Color *>(14); }
  int32_t colorType() const { return GetField<int32_t>(16, 0); }
  uint8_t bgColorOpacity() const { return GetField<uint8_t>(18, 255); }
  const ColorVector *colorVector() const { return GetStruct<const ColorVector *>(20); }
  const CapInsets *capInsets() const { return GetStruct<const CapInsets *>(22); }
  const FlatSize *scale9Size() const { return GetStruct<const FlatSize *>(24); }
  uint8_t backGroundScale9Enabled() const { return GetField<uint8_t>(26, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* widgetOptions */) &&
           verifier.VerifyTable(widgetOptions()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* backGroundImageData */) &&
           verifier.VerifyTable(backGroundImageData()) &&
           VerifyField<uint8_t>(verifier, 8 /* clipEnabled */) &&
           VerifyField<Color>(verifier, 10 /* bgColor */) &&
           VerifyField<Color>(verifier, 12 /* bgStartColor */) &&
           VerifyField<Color>(verifier, 14 /* bgEndColor */) &&
           VerifyField<int32_t>(verifier, 16 /* colorType */) &&
           VerifyField<uint8_t>(verifier, 18 /* bgColorOpacity */) &&
           VerifyField<ColorVector>(verifier, 20 /* colorVector */) &&
           VerifyField<CapInsets>(verifier, 22 /* capInsets */) &&
           VerifyField<FlatSize>(verifier, 24 /* scale9Size */) &&
           VerifyField<uint8_t>(verifier, 26 /* backGroundScale9Enabled */) &&
           verifier.EndTable();
  }
};

struct PanelOptionsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions) { fbb_.AddOffset(4, widgetOptions); }
  void add_backGroundImageData(flatbuffers::Offset<ResourceData> backGroundImageData) { fbb_.AddOffset(6, backGroundImageData); }
  void add_clipEnabled(uint8_t clipEnabled) { fbb_.AddElement<uint8_t>(8, clipEnabled, 0); }
  void add_bgColor(const Color *bgColor) { fbb_.AddStruct(10, bgColor); }
  void add_bgStartColor(const Color *bgStartColor) { fbb_.AddStruct(12, bgStartColor); }
  void add_bgEndColor(const Color *bgEndColor) { fbb_.AddStruct(14, bgEndColor); }
  void add_colorType(int32_t colorType) { fbb_.AddElement<int32_t>(16, colorType, 0); }
  void add_bgColorOpacity(uint8_t bgColorOpacity) { fbb_.AddElement<uint8_t>(18, bgColorOpacity, 255); }
  void add_colorVector(const ColorVector *colorVector) { fbb_.AddStruct(20, colorVector); }
  void add_capInsets(const CapInsets *capInsets) { fbb_.AddStruct(22, capInsets); }
  void add_scale9Size(const FlatSize *scale9Size) { fbb_.AddStruct(24, scale9Size); }
  void add_backGroundScale9Enabled(uint8_t backGroundScale9Enabled) { fbb_.AddElement<uint8_t>(26, backGroundScale9Enabled, 0); }
  PanelOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  PanelOptionsBuilder &operator=(const PanelOptionsBuilder &);
  flatbuffers::Offset<PanelOptions> Finish() {
    auto o = flatbuffers::Offset<PanelOptions>(fbb_.EndTable(start_, 12));
    return o;
  }
};

inline flatbuffers::Offset<PanelOptions> CreatePanelOptions(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<WidgetOptions> widgetOptions = 0,
   flatbuffers::Offset<ResourceData> backGroundImageData = 0,
   uint8_t clipEnabled = 0,
   const Color *bgColor = 0,
   const Color *bgStartColor = 0,
   const Color *bgEndColor = 0,
   int32_t colorType = 0,
   uint8_t bgColorOpacity = 255,
   const ColorVector *colorVector = 0,
   const CapInsets *capInsets = 0,
   const FlatSize *scale9Size = 0,
   uint8_t backGroundScale9Enabled = 0) {
  PanelOptionsBuilder builder_(_fbb);
  builder_.add_scale9Size(scale9Size);
  builder_.add_capInsets(capInsets);
  builder_.add_colorVector(colorVector);
  builder_.add_colorType(colorType);
  builder_.add_bgEndColor(bgEndColor);
  builder_.add_bgStartColor(bgStartColor);
  builder_.add_bgColor(bgColor);
  builder_.add_backGroundImageData(backGroundImageData);
  builder_.add_widgetOptions(widgetOptions);
  builder_.add_backGroundScale9Enabled(backGroundScale9Enabled);
  builder_.add_bgColorOpacity(bgColorOpacity);
  builder_.add_clipEnabled(clipEnabled);
  return builder_.Finish();
}

struct ScrollViewOptions : private flatbuffers::Table {
  const WidgetOptions *widgetOptions() const { return GetPointer<const WidgetOptions *>(4); }
  const ResourceData *backGroundImageData() const { return GetPointer<const ResourceData *>(6); }
  uint8_t clipEnabled() const { return GetField<uint8_t>(8, 0); }
  const Color *bgColor() const { return GetStruct<const Color *>(10); }
  const Color *bgStartColor() const { return GetStruct<const Color *>(12); }
  const Color *bgEndColor() const { return GetStruct<const Color *>(14); }
  int32_t colorType() const { return GetField<int32_t>(16, 0); }
  uint8_t bgColorOpacity() const { return GetField<uint8_t>(18, 255); }
  const ColorVector *colorVector() const { return GetStruct<const ColorVector *>(20); }
  const CapInsets *capInsets() const { return GetStruct<const CapInsets *>(22); }
  const FlatSize *scale9Size() const { return GetStruct<const FlatSize *>(24); }
  uint8_t backGroundScale9Enabled() const { return GetField<uint8_t>(26, 0); }
  const FlatSize *innerSize() const { return GetStruct<const FlatSize *>(28); }
  int32_t direction() const { return GetField<int32_t>(30, 0); }
  uint8_t bounceEnabled() const { return GetField<uint8_t>(32, 0); }
  uint8_t scrollbarEnabeld() const { return GetField<uint8_t>(34, 1); }
  uint8_t scrollbarAutoHide() const { return GetField<uint8_t>(36, 1); }
  float scrollbarAutoHideTime() const { return GetField<float>(38, 0.2); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* widgetOptions */) &&
           verifier.VerifyTable(widgetOptions()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* backGroundImageData */) &&
           verifier.VerifyTable(backGroundImageData()) &&
           VerifyField<uint8_t>(verifier, 8 /* clipEnabled */) &&
           VerifyField<Color>(verifier, 10 /* bgColor */) &&
           VerifyField<Color>(verifier, 12 /* bgStartColor */) &&
           VerifyField<Color>(verifier, 14 /* bgEndColor */) &&
           VerifyField<int32_t>(verifier, 16 /* colorType */) &&
           VerifyField<uint8_t>(verifier, 18 /* bgColorOpacity */) &&
           VerifyField<ColorVector>(verifier, 20 /* colorVector */) &&
           VerifyField<CapInsets>(verifier, 22 /* capInsets */) &&
           VerifyField<FlatSize>(verifier, 24 /* scale9Size */) &&
           VerifyField<uint8_t>(verifier, 26 /* backGroundScale9Enabled */) &&
           VerifyField<FlatSize>(verifier, 28 /* innerSize */) &&
           VerifyField<int32_t>(verifier, 30 /* direction */) &&
           VerifyField<uint8_t>(verifier, 32 /* bounceEnabled */) &&
           VerifyField<uint8_t>(verifier, 34 /* scrollbarEnabeld */) &&
           VerifyField<uint8_t>(verifier, 36 /* scrollbarAutoHide */) &&
           VerifyField<float>(verifier, 38 /* scrollbarAutoHideTime */) &&
           verifier.EndTable();
  }
};

struct ScrollViewOptionsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions) { fbb_.AddOffset(4, widgetOptions); }
  void add_backGroundImageData(flatbuffers::Offset<ResourceData> backGroundImageData) { fbb_.AddOffset(6, backGroundImageData); }
  void add_clipEnabled(uint8_t clipEnabled) { fbb_.AddElement<uint8_t>(8, clipEnabled, 0); }
  void add_bgColor(const Color *bgColor) { fbb_.AddStruct(10, bgColor); }
  void add_bgStartColor(const Color *bgStartColor) { fbb_.AddStruct(12, bgStartColor); }
  void add_bgEndColor(const Color *bgEndColor) { fbb_.AddStruct(14, bgEndColor); }
  void add_colorType(int32_t colorType) { fbb_.AddElement<int32_t>(16, colorType, 0); }
  void add_bgColorOpacity(uint8_t bgColorOpacity) { fbb_.AddElement<uint8_t>(18, bgColorOpacity, 255); }
  void add_colorVector(const ColorVector *colorVector) { fbb_.AddStruct(20, colorVector); }
  void add_capInsets(const CapInsets *capInsets) { fbb_.AddStruct(22, capInsets); }
  void add_scale9Size(const FlatSize *scale9Size) { fbb_.AddStruct(24, scale9Size); }
  void add_backGroundScale9Enabled(uint8_t backGroundScale9Enabled) { fbb_.AddElement<uint8_t>(26, backGroundScale9Enabled, 0); }
  void add_innerSize(const FlatSize *innerSize) { fbb_.AddStruct(28, innerSize); }
  void add_direction(int32_t direction) { fbb_.AddElement<int32_t>(30, direction, 0); }
  void add_bounceEnabled(uint8_t bounceEnabled) { fbb_.AddElement<uint8_t>(32, bounceEnabled, 0); }
  void add_scrollbarEnabeld(uint8_t scrollbarEnabeld) { fbb_.AddElement<uint8_t>(34, scrollbarEnabeld, 1); }
  void add_scrollbarAutoHide(uint8_t scrollbarAutoHide) { fbb_.AddElement<uint8_t>(36, scrollbarAutoHide, 1); }
  void add_scrollbarAutoHideTime(float scrollbarAutoHideTime) { fbb_.AddElement<float>(38, scrollbarAutoHideTime, 0.2); }
  ScrollViewOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  ScrollViewOptionsBuilder &operator=(const ScrollViewOptionsBuilder &);
  flatbuffers::Offset<ScrollViewOptions> Finish() {
    auto o = flatbuffers::Offset<ScrollViewOptions>(fbb_.EndTable(start_, 18));
    return o;
  }
};

inline flatbuffers::Offset<ScrollViewOptions> CreateScrollViewOptions(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<WidgetOptions> widgetOptions = 0,
   flatbuffers::Offset<ResourceData> backGroundImageData = 0,
   uint8_t clipEnabled = 0,
   const Color *bgColor = 0,
   const Color *bgStartColor = 0,
   const Color *bgEndColor = 0,
   int32_t colorType = 0,
   uint8_t bgColorOpacity = 255,
   const ColorVector *colorVector = 0,
   const CapInsets *capInsets = 0,
   const FlatSize *scale9Size = 0,
   uint8_t backGroundScale9Enabled = 0,
   const FlatSize *innerSize = 0,
   int32_t direction = 0,
   uint8_t bounceEnabled = 0,
   uint8_t scrollbarEnabeld = 1,
   uint8_t scrollbarAutoHide = 1,
   float scrollbarAutoHideTime = 0.2) {
  ScrollViewOptionsBuilder builder_(_fbb);
  builder_.add_scrollbarAutoHideTime(scrollbarAutoHideTime);
  builder_.add_direction(direction);
  builder_.add_innerSize(innerSize);
  builder_.add_scale9Size(scale9Size);
  builder_.add_capInsets(capInsets);
  builder_.add_colorVector(colorVector);
  builder_.add_colorType(colorType);
  builder_.add_bgEndColor(bgEndColor);
  builder_.add_bgStartColor(bgStartColor);
  builder_.add_bgColor(bgColor);
  builder_.add_backGroundImageData(backGroundImageData);
  builder_.add_widgetOptions(widgetOptions);
  builder_.add_scrollbarAutoHide(scrollbarAutoHide);
  builder_.add_scrollbarEnabeld(scrollbarEnabeld);
  builder_.add_bounceEnabled(bounceEnabled);
  builder_.add_backGroundScale9Enabled(backGroundScale9Enabled);
  builder_.add_bgColorOpacity(bgColorOpacity);
  builder_.add_clipEnabled(clipEnabled);
  return builder_.Finish();
}

struct PageViewOptions : private flatbuffers::Table {
  const WidgetOptions *widgetOptions() const { return GetPointer<const WidgetOptions *>(4); }
  const ResourceData *backGroundImageData() const { return GetPointer<const ResourceData *>(6); }
  uint8_t clipEnabled() const { return GetField<uint8_t>(8, 0); }
  const Color *bgColor() const { return GetStruct<const Color *>(10); }
  const Color *bgStartColor() const { return GetStruct<const Color *>(12); }
  const Color *bgEndColor() const { return GetStruct<const Color *>(14); }
  int32_t colorType() const { return GetField<int32_t>(16, 0); }
  uint8_t bgColorOpacity() const { return GetField<uint8_t>(18, 255); }
  const ColorVector *colorVector() const { return GetStruct<const ColorVector *>(20); }
  const CapInsets *capInsets() const { return GetStruct<const CapInsets *>(22); }
  const FlatSize *scale9Size() const { return GetStruct<const FlatSize *>(24); }
  uint8_t backGroundScale9Enabled() const { return GetField<uint8_t>(26, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* widgetOptions */) &&
           verifier.VerifyTable(widgetOptions()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* backGroundImageData */) &&
           verifier.VerifyTable(backGroundImageData()) &&
           VerifyField<uint8_t>(verifier, 8 /* clipEnabled */) &&
           VerifyField<Color>(verifier, 10 /* bgColor */) &&
           VerifyField<Color>(verifier, 12 /* bgStartColor */) &&
           VerifyField<Color>(verifier, 14 /* bgEndColor */) &&
           VerifyField<int32_t>(verifier, 16 /* colorType */) &&
           VerifyField<uint8_t>(verifier, 18 /* bgColorOpacity */) &&
           VerifyField<ColorVector>(verifier, 20 /* colorVector */) &&
           VerifyField<CapInsets>(verifier, 22 /* capInsets */) &&
           VerifyField<FlatSize>(verifier, 24 /* scale9Size */) &&
           VerifyField<uint8_t>(verifier, 26 /* backGroundScale9Enabled */) &&
           verifier.EndTable();
  }
};

struct PageViewOptionsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions) { fbb_.AddOffset(4, widgetOptions); }
  void add_backGroundImageData(flatbuffers::Offset<ResourceData> backGroundImageData) { fbb_.AddOffset(6, backGroundImageData); }
  void add_clipEnabled(uint8_t clipEnabled) { fbb_.AddElement<uint8_t>(8, clipEnabled, 0); }
  void add_bgColor(const Color *bgColor) { fbb_.AddStruct(10, bgColor); }
  void add_bgStartColor(const Color *bgStartColor) { fbb_.AddStruct(12, bgStartColor); }
  void add_bgEndColor(const Color *bgEndColor) { fbb_.AddStruct(14, bgEndColor); }
  void add_colorType(int32_t colorType) { fbb_.AddElement<int32_t>(16, colorType, 0); }
  void add_bgColorOpacity(uint8_t bgColorOpacity) { fbb_.AddElement<uint8_t>(18, bgColorOpacity, 255); }
  void add_colorVector(const ColorVector *colorVector) { fbb_.AddStruct(20, colorVector); }
  void add_capInsets(const CapInsets *capInsets) { fbb_.AddStruct(22, capInsets); }
  void add_scale9Size(const FlatSize *scale9Size) { fbb_.AddStruct(24, scale9Size); }
  void add_backGroundScale9Enabled(uint8_t backGroundScale9Enabled) { fbb_.AddElement<uint8_t>(26, backGroundScale9Enabled, 0); }
  PageViewOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  PageViewOptionsBuilder &operator=(const PageViewOptionsBuilder &);
  flatbuffers::Offset<PageViewOptions> Finish() {
    auto o = flatbuffers::Offset<PageViewOptions>(fbb_.EndTable(start_, 12));
    return o;
  }
};

inline flatbuffers::Offset<PageViewOptions> CreatePageViewOptions(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<WidgetOptions> widgetOptions = 0,
   flatbuffers::Offset<ResourceData> backGroundImageData = 0,
   uint8_t clipEnabled = 0,
   const Color *bgColor = 0,
   const Color *bgStartColor = 0,
   const Color *bgEndColor = 0,
   int32_t colorType = 0,
   uint8_t bgColorOpacity = 255,
   const ColorVector *colorVector = 0,
   const CapInsets *capInsets = 0,
   const FlatSize *scale9Size = 0,
   uint8_t backGroundScale9Enabled = 0) {
  PageViewOptionsBuilder builder_(_fbb);
  builder_.add_scale9Size(scale9Size);
  builder_.add_capInsets(capInsets);
  builder_.add_colorVector(colorVector);
  builder_.add_colorType(colorType);
  builder_.add_bgEndColor(bgEndColor);
  builder_.add_bgStartColor(bgStartColor);
  builder_.add_bgColor(bgColor);
  builder_.add_backGroundImageData(backGroundImageData);
  builder_.add_widgetOptions(widgetOptions);
  builder_.add_backGroundScale9Enabled(backGroundScale9Enabled);
  builder_.add_bgColorOpacity(bgColorOpacity);
  builder_.add_clipEnabled(clipEnabled);
  return builder_.Finish();
}

struct ListViewOptions : private flatbuffers::Table {
  const WidgetOptions *widgetOptions() const { return GetPointer<const WidgetOptions *>(4); }
  const ResourceData *backGroundImageData() const { return GetPointer<const ResourceData *>(6); }
  uint8_t clipEnabled() const { return GetField<uint8_t>(8, 0); }
  const Color *bgColor() const { return GetStruct<const Color *>(10); }
  const Color *bgStartColor() const { return GetStruct<const Color *>(12); }
  const Color *bgEndColor() const { return GetStruct<const Color *>(14); }
  int32_t colorType() const { return GetField<int32_t>(16, 0); }
  uint8_t bgColorOpacity() const { return GetField<uint8_t>(18, 255); }
  const ColorVector *colorVector() const { return GetStruct<const ColorVector *>(20); }
  const CapInsets *capInsets() const { return GetStruct<const CapInsets *>(22); }
  const FlatSize *scale9Size() const { return GetStruct<const FlatSize *>(24); }
  uint8_t backGroundScale9Enabled() const { return GetField<uint8_t>(26, 0); }
  const FlatSize *innerSize() const { return GetStruct<const FlatSize *>(28); }
  int32_t direction() const { return GetField<int32_t>(30, 0); }
  uint8_t bounceEnabled() const { return GetField<uint8_t>(32, 0); }
  int32_t itemMargin() const { return GetField<int32_t>(34, 0); }
  const flatbuffers::String *directionType() const { return GetPointer<const flatbuffers::String *>(36); }
  const flatbuffers::String *horizontalType() const { return GetPointer<const flatbuffers::String *>(38); }
  const flatbuffers::String *verticalType() const { return GetPointer<const flatbuffers::String *>(40); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* widgetOptions */) &&
           verifier.VerifyTable(widgetOptions()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* backGroundImageData */) &&
           verifier.VerifyTable(backGroundImageData()) &&
           VerifyField<uint8_t>(verifier, 8 /* clipEnabled */) &&
           VerifyField<Color>(verifier, 10 /* bgColor */) &&
           VerifyField<Color>(verifier, 12 /* bgStartColor */) &&
           VerifyField<Color>(verifier, 14 /* bgEndColor */) &&
           VerifyField<int32_t>(verifier, 16 /* colorType */) &&
           VerifyField<uint8_t>(verifier, 18 /* bgColorOpacity */) &&
           VerifyField<ColorVector>(verifier, 20 /* colorVector */) &&
           VerifyField<CapInsets>(verifier, 22 /* capInsets */) &&
           VerifyField<FlatSize>(verifier, 24 /* scale9Size */) &&
           VerifyField<uint8_t>(verifier, 26 /* backGroundScale9Enabled */) &&
           VerifyField<FlatSize>(verifier, 28 /* innerSize */) &&
           VerifyField<int32_t>(verifier, 30 /* direction */) &&
           VerifyField<uint8_t>(verifier, 32 /* bounceEnabled */) &&
           VerifyField<int32_t>(verifier, 34 /* itemMargin */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 36 /* directionType */) &&
           verifier.Verify(directionType()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 38 /* horizontalType */) &&
           verifier.Verify(horizontalType()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 40 /* verticalType */) &&
           verifier.Verify(verticalType()) &&
           verifier.EndTable();
  }
};

struct ListViewOptionsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions) { fbb_.AddOffset(4, widgetOptions); }
  void add_backGroundImageData(flatbuffers::Offset<ResourceData> backGroundImageData) { fbb_.AddOffset(6, backGroundImageData); }
  void add_clipEnabled(uint8_t clipEnabled) { fbb_.AddElement<uint8_t>(8, clipEnabled, 0); }
  void add_bgColor(const Color *bgColor) { fbb_.AddStruct(10, bgColor); }
  void add_bgStartColor(const Color *bgStartColor) { fbb_.AddStruct(12, bgStartColor); }
  void add_bgEndColor(const Color *bgEndColor) { fbb_.AddStruct(14, bgEndColor); }
  void add_colorType(int32_t colorType) { fbb_.AddElement<int32_t>(16, colorType, 0); }
  void add_bgColorOpacity(uint8_t bgColorOpacity) { fbb_.AddElement<uint8_t>(18, bgColorOpacity, 255); }
  void add_colorVector(const ColorVector *colorVector) { fbb_.AddStruct(20, colorVector); }
  void add_capInsets(const CapInsets *capInsets) { fbb_.AddStruct(22, capInsets); }
  void add_scale9Size(const FlatSize *scale9Size) { fbb_.AddStruct(24, scale9Size); }
  void add_backGroundScale9Enabled(uint8_t backGroundScale9Enabled) { fbb_.AddElement<uint8_t>(26, backGroundScale9Enabled, 0); }
  void add_innerSize(const FlatSize *innerSize) { fbb_.AddStruct(28, innerSize); }
  void add_direction(int32_t direction) { fbb_.AddElement<int32_t>(30, direction, 0); }
  void add_bounceEnabled(uint8_t bounceEnabled) { fbb_.AddElement<uint8_t>(32, bounceEnabled, 0); }
  void add_itemMargin(int32_t itemMargin) { fbb_.AddElement<int32_t>(34, itemMargin, 0); }
  void add_directionType(flatbuffers::Offset<flatbuffers::String> directionType) { fbb_.AddOffset(36, directionType); }
  void add_horizontalType(flatbuffers::Offset<flatbuffers::String> horizontalType) { fbb_.AddOffset(38, horizontalType); }
  void add_verticalType(flatbuffers::Offset<flatbuffers::String> verticalType) { fbb_.AddOffset(40, verticalType); }
  ListViewOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  ListViewOptionsBuilder &operator=(const ListViewOptionsBuilder &);
  flatbuffers::Offset<ListViewOptions> Finish() {
    auto o = flatbuffers::Offset<ListViewOptions>(fbb_.EndTable(start_, 19));
    return o;
  }
};

inline flatbuffers::Offset<ListViewOptions> CreateListViewOptions(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<WidgetOptions> widgetOptions = 0,
   flatbuffers::Offset<ResourceData> backGroundImageData = 0,
   uint8_t clipEnabled = 0,
   const Color *bgColor = 0,
   const Color *bgStartColor = 0,
   const Color *bgEndColor = 0,
   int32_t colorType = 0,
   uint8_t bgColorOpacity = 255,
   const ColorVector *colorVector = 0,
   const CapInsets *capInsets = 0,
   const FlatSize *scale9Size = 0,
   uint8_t backGroundScale9Enabled = 0,
   const FlatSize *innerSize = 0,
   int32_t direction = 0,
   uint8_t bounceEnabled = 0,
   int32_t itemMargin = 0,
   flatbuffers::Offset<flatbuffers::String> directionType = 0,
   flatbuffers::Offset<flatbuffers::String> horizontalType = 0,
   flatbuffers::Offset<flatbuffers::String> verticalType = 0) {
  ListViewOptionsBuilder builder_(_fbb);
  builder_.add_verticalType(verticalType);
  builder_.add_horizontalType(horizontalType);
  builder_.add_directionType(directionType);
  builder_.add_itemMargin(itemMargin);
  builder_.add_direction(direction);
  builder_.add_innerSize(innerSize);
  builder_.add_scale9Size(scale9Size);
  builder_.add_capInsets(capInsets);
  builder_.add_colorVector(colorVector);
  builder_.add_colorType(colorType);
  builder_.add_bgEndColor(bgEndColor);
  builder_.add_bgStartColor(bgStartColor);
  builder_.add_bgColor(bgColor);
  builder_.add_backGroundImageData(backGroundImageData);
  builder_.add_widgetOptions(widgetOptions);
  builder_.add_bounceEnabled(bounceEnabled);
  builder_.add_backGroundScale9Enabled(backGroundScale9Enabled);
  builder_.add_bgColorOpacity(bgColorOpacity);
  builder_.add_clipEnabled(clipEnabled);
  return builder_.Finish();
}

struct ProjectNodeOptions : private flatbuffers::Table {
  const WidgetOptions *nodeOptions() const { return GetPointer<const WidgetOptions *>(4); }
  const flatbuffers::String *fileName() const { return GetPointer<const flatbuffers::String *>(6); }
  float innerActionSpeed() const { return GetField<float>(8, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* nodeOptions */) &&
           verifier.VerifyTable(nodeOptions()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* fileName */) &&
           verifier.Verify(fileName()) &&
           VerifyField<float>(verifier, 8 /* innerActionSpeed */) &&
           verifier.EndTable();
  }
};

struct ProjectNodeOptionsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_nodeOptions(flatbuffers::Offset<WidgetOptions> nodeOptions) { fbb_.AddOffset(4, nodeOptions); }
  void add_fileName(flatbuffers::Offset<flatbuffers::String> fileName) { fbb_.AddOffset(6, fileName); }
  void add_innerActionSpeed(float innerActionSpeed) { fbb_.AddElement<float>(8, innerActionSpeed, 0); }
  ProjectNodeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  ProjectNodeOptionsBuilder &operator=(const ProjectNodeOptionsBuilder &);
  flatbuffers::Offset<ProjectNodeOptions> Finish() {
    auto o = flatbuffers::Offset<ProjectNodeOptions>(fbb_.EndTable(start_, 3));
    return o;
  }
};

inline flatbuffers::Offset<ProjectNodeOptions> CreateProjectNodeOptions(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<WidgetOptions> nodeOptions = 0,
   flatbuffers::Offset<flatbuffers::String> fileName = 0,
   float innerActionSpeed = 0) {
  ProjectNodeOptionsBuilder builder_(_fbb);
  builder_.add_innerActionSpeed(innerActionSpeed);
  builder_.add_fileName(fileName);
  builder_.add_nodeOptions(nodeOptions);
  return builder_.Finish();
}

struct ComponentOptions : private flatbuffers::Table {
  const WidgetOptions *nodeOptions() const { return GetPointer<const WidgetOptions *>(4); }
  const flatbuffers::String *type() const { return GetPointer<const flatbuffers::String *>(6); }
  const ComAudioOptions *comAudioOptions() const { return GetPointer<const ComAudioOptions *>(8); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* nodeOptions */) &&
           verifier.VerifyTable(nodeOptions()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* type */) &&
           verifier.Verify(type()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* comAudioOptions */) &&
           verifier.VerifyTable(comAudioOptions()) &&
           verifier.EndTable();
  }
};

struct ComponentOptionsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_nodeOptions(flatbuffers::Offset<WidgetOptions> nodeOptions) { fbb_.AddOffset(4, nodeOptions); }
  void add_type(flatbuffers::Offset<flatbuffers::String> type) { fbb_.AddOffset(6, type); }
  void add_comAudioOptions(flatbuffers::Offset<ComAudioOptions> comAudioOptions) { fbb_.AddOffset(8, comAudioOptions); }
  ComponentOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  ComponentOptionsBuilder &operator=(const ComponentOptionsBuilder &);
  flatbuffers::Offset<ComponentOptions> Finish() {
    auto o = flatbuffers::Offset<ComponentOptions>(fbb_.EndTable(start_, 3));
    return o;
  }
};

inline flatbuffers::Offset<ComponentOptions> CreateComponentOptions(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<WidgetOptions> nodeOptions = 0,
   flatbuffers::Offset<flatbuffers::String> type = 0,
   flatbuffers::Offset<ComAudioOptions> comAudioOptions = 0) {
  ComponentOptionsBuilder builder_(_fbb);
  builder_.add_comAudioOptions(comAudioOptions);
  builder_.add_type(type);
  builder_.add_nodeOptions(nodeOptions);
  return builder_.Finish();
}

struct ComAudioOptions : private flatbuffers::Table {
  const WidgetOptions *nodeOptions() const { return GetPointer<const WidgetOptions *>(4); }
  const flatbuffers::String *name() const { return GetPointer<const flatbuffers::String *>(6); }
  uint8_t enabled() const { return GetField<uint8_t>(8, 0); }
  uint8_t loop() const { return GetField<uint8_t>(10, 0); }
  int32_t volume() const { return GetField<int32_t>(12, 0); }
  const ResourceData *fileNameData() const { return GetPointer<const ResourceData *>(14); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* nodeOptions */) &&
           verifier.VerifyTable(nodeOptions()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* name */) &&
           verifier.Verify(name()) &&
           VerifyField<uint8_t>(verifier, 8 /* enabled */) &&
           VerifyField<uint8_t>(verifier, 10 /* loop */) &&
           VerifyField<int32_t>(verifier, 12 /* volume */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 14 /* fileNameData */) &&
           verifier.VerifyTable(fileNameData()) &&
           verifier.EndTable();
  }
};

struct ComAudioOptionsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_nodeOptions(flatbuffers::Offset<WidgetOptions> nodeOptions) { fbb_.AddOffset(4, nodeOptions); }
  void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(6, name); }
  void add_enabled(uint8_t enabled) { fbb_.AddElement<uint8_t>(8, enabled, 0); }
  void add_loop(uint8_t loop) { fbb_.AddElement<uint8_t>(10, loop, 0); }
  void add_volume(int32_t volume) { fbb_.AddElement<int32_t>(12, volume, 0); }
  void add_fileNameData(flatbuffers::Offset<ResourceData> fileNameData) { fbb_.AddOffset(14, fileNameData); }
  ComAudioOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  ComAudioOptionsBuilder &operator=(const ComAudioOptionsBuilder &);
  flatbuffers::Offset<ComAudioOptions> Finish() {
    auto o = flatbuffers::Offset<ComAudioOptions>(fbb_.EndTable(start_, 6));
    return o;
  }
};

inline flatbuffers::Offset<ComAudioOptions> CreateComAudioOptions(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<WidgetOptions> nodeOptions = 0,
   flatbuffers::Offset<flatbuffers::String> name = 0,
   uint8_t enabled = 0,
   uint8_t loop = 0,
   int32_t volume = 0,
   flatbuffers::Offset<ResourceData> fileNameData = 0) {
  ComAudioOptionsBuilder builder_(_fbb);
  builder_.add_fileNameData(fileNameData);
  builder_.add_volume(volume);
  builder_.add_name(name);
  builder_.add_nodeOptions(nodeOptions);
  builder_.add_loop(loop);
  builder_.add_enabled(enabled);
  return builder_.Finish();
}

struct AnimationInfo : private flatbuffers::Table {
  const flatbuffers::String *name() const { return GetPointer<const flatbuffers::String *>(4); }
  int32_t startIndex() const { return GetField<int32_t>(6, 0); }
  int32_t endIndex() const { return GetField<int32_t>(8, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* name */) &&
           verifier.Verify(name()) &&
           VerifyField<int32_t>(verifier, 6 /* startIndex */) &&
           VerifyField<int32_t>(verifier, 8 /* endIndex */) &&
           verifier.EndTable();
  }
};

struct AnimationInfoBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(4, name); }
  void add_startIndex(int32_t startIndex) { fbb_.AddElement<int32_t>(6, startIndex, 0); }
  void add_endIndex(int32_t endIndex) { fbb_.AddElement<int32_t>(8, endIndex, 0); }
  AnimationInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  AnimationInfoBuilder &operator=(const AnimationInfoBuilder &);
  flatbuffers::Offset<AnimationInfo> Finish() {
    auto o = flatbuffers::Offset<AnimationInfo>(fbb_.EndTable(start_, 3));
    return o;
  }
};

inline flatbuffers::Offset<AnimationInfo> CreateAnimationInfo(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<flatbuffers::String> name = 0,
   int32_t startIndex = 0,
   int32_t endIndex = 0) {
  AnimationInfoBuilder builder_(_fbb);
  builder_.add_endIndex(endIndex);
  builder_.add_startIndex(startIndex);
  builder_.add_name(name);
  return builder_.Finish();
}

struct NodeAction : private flatbuffers::Table {
  int32_t duration() const { return GetField<int32_t>(4, 0); }
  float speed() const { return GetField<float>(6, 0); }
  const flatbuffers::Vector<flatbuffers::Offset<TimeLine>> *timeLines() const { return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<TimeLine>> *>(8); }
  const flatbuffers::String *currentAnimationName() const { return GetPointer<const flatbuffers::String *>(10); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, 4 /* duration */) &&
           VerifyField<float>(verifier, 6 /* speed */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* timeLines */) &&
           verifier.Verify(timeLines()) &&
           verifier.VerifyVectorOfTables(timeLines()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* currentAnimationName */) &&
           verifier.Verify(currentAnimationName()) &&
           verifier.EndTable();
  }
};

struct NodeActionBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_duration(int32_t duration) { fbb_.AddElement<int32_t>(4, duration, 0); }
  void add_speed(float speed) { fbb_.AddElement<float>(6, speed, 0); }
  void add_timeLines(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TimeLine>>> timeLines) { fbb_.AddOffset(8, timeLines); }
  void add_currentAnimationName(flatbuffers::Offset<flatbuffers::String> currentAnimationName) { fbb_.AddOffset(10, currentAnimationName); }
  NodeActionBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  NodeActionBuilder &operator=(const NodeActionBuilder &);
  flatbuffers::Offset<NodeAction> Finish() {
    auto o = flatbuffers::Offset<NodeAction>(fbb_.EndTable(start_, 4));
    return o;
  }
};

inline flatbuffers::Offset<NodeAction> CreateNodeAction(flatbuffers::FlatBufferBuilder &_fbb,
   int32_t duration = 0,
   float speed = 0,
   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TimeLine>>> timeLines = 0,
   flatbuffers::Offset<flatbuffers::String> currentAnimationName = 0) {
  NodeActionBuilder builder_(_fbb);
  builder_.add_currentAnimationName(currentAnimationName);
  builder_.add_timeLines(timeLines);
  builder_.add_speed(speed);
  builder_.add_duration(duration);
  return builder_.Finish();
}

struct TimeLine : private flatbuffers::Table {
  const flatbuffers::String *property() const { return GetPointer<const flatbuffers::String *>(4); }
  int32_t actionTag() const { return GetField<int32_t>(6, 0); }
  const flatbuffers::Vector<flatbuffers::Offset<Frame>> *frames() const { return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Frame>> *>(8); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* property */) &&
           verifier.Verify(property()) &&
           VerifyField<int32_t>(verifier, 6 /* actionTag */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* frames */) &&
           verifier.Verify(frames()) &&
           verifier.VerifyVectorOfTables(frames()) &&
           verifier.EndTable();
  }
};

struct TimeLineBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_property(flatbuffers::Offset<flatbuffers::String> property) { fbb_.AddOffset(4, property); }
  void add_actionTag(int32_t actionTag) { fbb_.AddElement<int32_t>(6, actionTag, 0); }
  void add_frames(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Frame>>> frames) { fbb_.AddOffset(8, frames); }
  TimeLineBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  TimeLineBuilder &operator=(const TimeLineBuilder &);
  flatbuffers::Offset<TimeLine> Finish() {
    auto o = flatbuffers::Offset<TimeLine>(fbb_.EndTable(start_, 3));
    return o;
  }
};

inline flatbuffers::Offset<TimeLine> CreateTimeLine(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<flatbuffers::String> property = 0,
   int32_t actionTag = 0,
   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Frame>>> frames = 0) {
  TimeLineBuilder builder_(_fbb);
  builder_.add_frames(frames);
  builder_.add_actionTag(actionTag);
  builder_.add_property(property);
  return builder_.Finish();
}

struct Frame : private flatbuffers::Table {
  const PointFrame *pointFrame() const { return GetPointer<const PointFrame *>(4); }
  const ScaleFrame *scaleFrame() const { return GetPointer<const ScaleFrame *>(6); }
  const ColorFrame *colorFrame() const { return GetPointer<const ColorFrame *>(8); }
  const TextureFrame *textureFrame() const { return GetPointer<const TextureFrame *>(10); }
  const EventFrame *eventFrame() const { return GetPointer<const EventFrame *>(12); }
  const IntFrame *intFrame() const { return GetPointer<const IntFrame *>(14); }
  const BoolFrame *boolFrame() const { return GetPointer<const BoolFrame *>(16); }
  const InnerActionFrame *innerActionFrame() const { return GetPointer<const InnerActionFrame *>(18); }
  const BlendFrame *blendFrame() const { return GetPointer<const BlendFrame *>(20); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* pointFrame */) &&
           verifier.VerifyTable(pointFrame()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* scaleFrame */) &&
           verifier.VerifyTable(scaleFrame()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* colorFrame */) &&
           verifier.VerifyTable(colorFrame()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* textureFrame */) &&
           verifier.VerifyTable(textureFrame()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 12 /* eventFrame */) &&
           verifier.VerifyTable(eventFrame()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 14 /* intFrame */) &&
           verifier.VerifyTable(intFrame()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 16 /* boolFrame */) &&
           verifier.VerifyTable(boolFrame()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 18 /* innerActionFrame */) &&
           verifier.VerifyTable(innerActionFrame()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 20 /* blendFrame */) &&
           verifier.VerifyTable(blendFrame()) &&
           verifier.EndTable();
  }
};

struct FrameBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_pointFrame(flatbuffers::Offset<PointFrame> pointFrame) { fbb_.AddOffset(4, pointFrame); }
  void add_scaleFrame(flatbuffers::Offset<ScaleFrame> scaleFrame) { fbb_.AddOffset(6, scaleFrame); }
  void add_colorFrame(flatbuffers::Offset<ColorFrame> colorFrame) { fbb_.AddOffset(8, colorFrame); }
  void add_textureFrame(flatbuffers::Offset<TextureFrame> textureFrame) { fbb_.AddOffset(10, textureFrame); }
  void add_eventFrame(flatbuffers::Offset<EventFrame> eventFrame) { fbb_.AddOffset(12, eventFrame); }
  void add_intFrame(flatbuffers::Offset<IntFrame> intFrame) { fbb_.AddOffset(14, intFrame); }
  void add_boolFrame(flatbuffers::Offset<BoolFrame> boolFrame) { fbb_.AddOffset(16, boolFrame); }
  void add_innerActionFrame(flatbuffers::Offset<InnerActionFrame> innerActionFrame) { fbb_.AddOffset(18, innerActionFrame); }
  void add_blendFrame(flatbuffers::Offset<BlendFrame> blendFrame) { fbb_.AddOffset(20, blendFrame); }
  FrameBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  FrameBuilder &operator=(const FrameBuilder &);
  flatbuffers::Offset<Frame> Finish() {
    auto o = flatbuffers::Offset<Frame>(fbb_.EndTable(start_, 9));
    return o;
  }
};

inline flatbuffers::Offset<Frame> CreateFrame(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<PointFrame> pointFrame = 0,
   flatbuffers::Offset<ScaleFrame> scaleFrame = 0,
   flatbuffers::Offset<ColorFrame> colorFrame = 0,
   flatbuffers::Offset<TextureFrame> textureFrame = 0,
   flatbuffers::Offset<EventFrame> eventFrame = 0,
   flatbuffers::Offset<IntFrame> intFrame = 0,
   flatbuffers::Offset<BoolFrame> boolFrame = 0,
   flatbuffers::Offset<InnerActionFrame> innerActionFrame = 0,
   flatbuffers::Offset<BlendFrame> blendFrame = 0) {
  FrameBuilder builder_(_fbb);
  builder_.add_blendFrame(blendFrame);
  builder_.add_innerActionFrame(innerActionFrame);
  builder_.add_boolFrame(boolFrame);
  builder_.add_intFrame(intFrame);
  builder_.add_eventFrame(eventFrame);
  builder_.add_textureFrame(textureFrame);
  builder_.add_colorFrame(colorFrame);
  builder_.add_scaleFrame(scaleFrame);
  builder_.add_pointFrame(pointFrame);
  return builder_.Finish();
}

struct PointFrame : private flatbuffers::Table {
  int32_t frameIndex() const { return GetField<int32_t>(4, 0); }
  uint8_t tween() const { return GetField<uint8_t>(6, 1); }
  const Position *position() const { return GetStruct<const Position *>(8); }
  const EasingData *easingData() const { return GetPointer<const EasingData *>(10); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, 4 /* frameIndex */) &&
           VerifyField<uint8_t>(verifier, 6 /* tween */) &&
           VerifyField<Position>(verifier, 8 /* position */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* easingData */) &&
           verifier.VerifyTable(easingData()) &&
           verifier.EndTable();
  }
};

struct PointFrameBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_frameIndex(int32_t frameIndex) { fbb_.AddElement<int32_t>(4, frameIndex, 0); }
  void add_tween(uint8_t tween) { fbb_.AddElement<uint8_t>(6, tween, 1); }
  void add_postion(const Position *position) { fbb_.AddStruct(8, position); }
  void add_easingData(flatbuffers::Offset<EasingData> easingData) { fbb_.AddOffset(10, easingData); }
  PointFrameBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  PointFrameBuilder &operator=(const PointFrameBuilder &);
  flatbuffers::Offset<PointFrame> Finish() {
    auto o = flatbuffers::Offset<PointFrame>(fbb_.EndTable(start_, 4));
    return o;
  }
};

inline flatbuffers::Offset<PointFrame> CreatePointFrame(flatbuffers::FlatBufferBuilder &_fbb,
   int32_t frameIndex = 0,
   uint8_t tween = 1,
   const Position *position = 0,
   flatbuffers::Offset<EasingData> easingData = 0) {
  PointFrameBuilder builder_(_fbb);
  builder_.add_easingData(easingData);
  builder_.add_postion(position);
  builder_.add_frameIndex(frameIndex);
  builder_.add_tween(tween);
  return builder_.Finish();
}

struct ScaleFrame : private flatbuffers::Table {
  int32_t frameIndex() const { return GetField<int32_t>(4, 0); }
  uint8_t tween() const { return GetField<uint8_t>(6, 1); }
  const Scale *scale() const { return GetStruct<const Scale *>(8); }
  const EasingData *easingData() const { return GetPointer<const EasingData *>(10); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, 4 /* frameIndex */) &&
           VerifyField<uint8_t>(verifier, 6 /* tween */) &&
           VerifyField<Scale>(verifier, 8 /* scale */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* easingData */) &&
           verifier.VerifyTable(easingData()) &&
           verifier.EndTable();
  }
};

struct ScaleFrameBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_frameIndex(int32_t frameIndex) { fbb_.AddElement<int32_t>(4, frameIndex, 0); }
  void add_tween(uint8_t tween) { fbb_.AddElement<uint8_t>(6, tween, 1); }
  void add_scale(const Scale *scale) { fbb_.AddStruct(8, scale); }
  void add_easingData(flatbuffers::Offset<EasingData> easingData) { fbb_.AddOffset(10, easingData); }
  ScaleFrameBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  ScaleFrameBuilder &operator=(const ScaleFrameBuilder &);
  flatbuffers::Offset<ScaleFrame> Finish() {
    auto o = flatbuffers::Offset<ScaleFrame>(fbb_.EndTable(start_, 4));
    return o;
  }
};

inline flatbuffers::Offset<ScaleFrame> CreateScaleFrame(flatbuffers::FlatBufferBuilder &_fbb,
   int32_t frameIndex = 0,
   uint8_t tween = 1,
   const Scale *scale = 0,
   flatbuffers::Offset<EasingData> easingData = 0) {
  ScaleFrameBuilder builder_(_fbb);
  builder_.add_easingData(easingData);
  builder_.add_scale(scale);
  builder_.add_frameIndex(frameIndex);
  builder_.add_tween(tween);
  return builder_.Finish();
}

struct ColorFrame : private flatbuffers::Table {
  int32_t frameIndex() const { return GetField<int32_t>(4, 0); }
  uint8_t tween() const { return GetField<uint8_t>(6, 1); }
  const Color *color() const { return GetStruct<const Color *>(8); }
  const EasingData *easingData() const { return GetPointer<const EasingData *>(10); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, 4 /* frameIndex */) &&
           VerifyField<uint8_t>(verifier, 6 /* tween */) &&
           VerifyField<Color>(verifier, 8 /* color */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* easingData */) &&
           verifier.VerifyTable(easingData()) &&
           verifier.EndTable();
  }
};

struct ColorFrameBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_frameIndex(int32_t frameIndex) { fbb_.AddElement<int32_t>(4, frameIndex, 0); }
  void add_tween(uint8_t tween) { fbb_.AddElement<uint8_t>(6, tween, 1); }
  void add_color(const Color *color) { fbb_.AddStruct(8, color); }
  void add_easingData(flatbuffers::Offset<EasingData> easingData) { fbb_.AddOffset(10, easingData); }
  ColorFrameBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  ColorFrameBuilder &operator=(const ColorFrameBuilder &);
  flatbuffers::Offset<ColorFrame> Finish() {
    auto o = flatbuffers::Offset<ColorFrame>(fbb_.EndTable(start_, 4));
    return o;
  }
};

inline flatbuffers::Offset<ColorFrame> CreateColorFrame(flatbuffers::FlatBufferBuilder &_fbb,
   int32_t frameIndex = 0,
   uint8_t tween = 1,
   const Color *color = 0,
   flatbuffers::Offset<EasingData> easingData = 0) {
  ColorFrameBuilder builder_(_fbb);
  builder_.add_easingData(easingData);
  builder_.add_color(color);
  builder_.add_frameIndex(frameIndex);
  builder_.add_tween(tween);
  return builder_.Finish();
}

struct TextureFrame : private flatbuffers::Table {
  int32_t frameIndex() const { return GetField<int32_t>(4, 0); }
  uint8_t tween() const { return GetField<uint8_t>(6, 1); }
  const ResourceData *textureFile() const { return GetPointer<const ResourceData *>(8); }
  const EasingData *easingData() const { return GetPointer<const EasingData *>(10); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, 4 /* frameIndex */) &&
           VerifyField<uint8_t>(verifier, 6 /* tween */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* textureFile */) &&
           verifier.VerifyTable(textureFile()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* easingData */) &&
           verifier.VerifyTable(easingData()) &&
           verifier.EndTable();
  }
};

struct TextureFrameBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_frameIndex(int32_t frameIndex) { fbb_.AddElement<int32_t>(4, frameIndex, 0); }
  void add_tween(uint8_t tween) { fbb_.AddElement<uint8_t>(6, tween, 1); }
  void add_textureFile(flatbuffers::Offset<ResourceData> textureFile) { fbb_.AddOffset(8, textureFile); }
  void add_easingData(flatbuffers::Offset<EasingData> easingData) { fbb_.AddOffset(10, easingData); }
  TextureFrameBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  TextureFrameBuilder &operator=(const TextureFrameBuilder &);
  flatbuffers::Offset<TextureFrame> Finish() {
    auto o = flatbuffers::Offset<TextureFrame>(fbb_.EndTable(start_, 4));
    return o;
  }
};

inline flatbuffers::Offset<TextureFrame> CreateTextureFrame(flatbuffers::FlatBufferBuilder &_fbb,
   int32_t frameIndex = 0,
   uint8_t tween = 1,
   flatbuffers::Offset<ResourceData> textureFile = 0,
   flatbuffers::Offset<EasingData> easingData = 0) {
  TextureFrameBuilder builder_(_fbb);
  builder_.add_easingData(easingData);
  builder_.add_textureFile(textureFile);
  builder_.add_frameIndex(frameIndex);
  builder_.add_tween(tween);
  return builder_.Finish();
}

struct EventFrame : private flatbuffers::Table {
  int32_t frameIndex() const { return GetField<int32_t>(4, 0); }
  uint8_t tween() const { return GetField<uint8_t>(6, 1); }
  const flatbuffers::String *value() const { return GetPointer<const flatbuffers::String *>(8); }
  const EasingData *easingData() const { return GetPointer<const EasingData *>(10); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, 4 /* frameIndex */) &&
           VerifyField<uint8_t>(verifier, 6 /* tween */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* value */) &&
           verifier.Verify(value()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* easingData */) &&
           verifier.VerifyTable(easingData()) &&
           verifier.EndTable();
  }
};

struct EventFrameBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_frameIndex(int32_t frameIndex) { fbb_.AddElement<int32_t>(4, frameIndex, 0); }
  void add_tween(uint8_t tween) { fbb_.AddElement<uint8_t>(6, tween, 1); }
  void add_value(flatbuffers::Offset<flatbuffers::String> value) { fbb_.AddOffset(8, value); }
  void add_easingData(flatbuffers::Offset<EasingData> easingData) { fbb_.AddOffset(10, easingData); }
  EventFrameBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  EventFrameBuilder &operator=(const EventFrameBuilder &);
  flatbuffers::Offset<EventFrame> Finish() {
    auto o = flatbuffers::Offset<EventFrame>(fbb_.EndTable(start_, 4));
    return o;
  }
};

inline flatbuffers::Offset<EventFrame> CreateEventFrame(flatbuffers::FlatBufferBuilder &_fbb,
   int32_t frameIndex = 0,
   uint8_t tween = 1,
   flatbuffers::Offset<flatbuffers::String> value = 0,
   flatbuffers::Offset<EasingData> easingData = 0) {
  EventFrameBuilder builder_(_fbb);
  builder_.add_easingData(easingData);
  builder_.add_value(value);
  builder_.add_frameIndex(frameIndex);
  builder_.add_tween(tween);
  return builder_.Finish();
}

struct IntFrame : private flatbuffers::Table {
  int32_t frameIndex() const { return GetField<int32_t>(4, 0); }
  uint8_t tween() const { return GetField<uint8_t>(6, 1); }
  int32_t value() const { return GetField<int32_t>(8, 0); }
  const EasingData *easingData() const { return GetPointer<const EasingData *>(10); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, 4 /* frameIndex */) &&
           VerifyField<uint8_t>(verifier, 6 /* tween */) &&
           VerifyField<int32_t>(verifier, 8 /* value */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* easingData */) &&
           verifier.VerifyTable(easingData()) &&
           verifier.EndTable();
  }
};

struct IntFrameBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_frameIndex(int32_t frameIndex) { fbb_.AddElement<int32_t>(4, frameIndex, 0); }
  void add_tween(uint8_t tween) { fbb_.AddElement<uint8_t>(6, tween, 1); }
  void add_value(int32_t value) { fbb_.AddElement<int32_t>(8, value, 0); }
  void add_easingData(flatbuffers::Offset<EasingData> easingData) { fbb_.AddOffset(10, easingData); }
  IntFrameBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  IntFrameBuilder &operator=(const IntFrameBuilder &);
  flatbuffers::Offset<IntFrame> Finish() {
    auto o = flatbuffers::Offset<IntFrame>(fbb_.EndTable(start_, 4));
    return o;
  }
};

inline flatbuffers::Offset<IntFrame> CreateIntFrame(flatbuffers::FlatBufferBuilder &_fbb,
   int32_t frameIndex = 0,
   uint8_t tween = 1,
   int32_t value = 0,
   flatbuffers::Offset<EasingData> easingData = 0) {
  IntFrameBuilder builder_(_fbb);
  builder_.add_easingData(easingData);
  builder_.add_value(value);
  builder_.add_frameIndex(frameIndex);
  builder_.add_tween(tween);
  return builder_.Finish();
}

struct BoolFrame : private flatbuffers::Table {
  int32_t frameIndex() const { return GetField<int32_t>(4, 0); }
  uint8_t tween() const { return GetField<uint8_t>(6, 1); }
  uint8_t value() const { return GetField<uint8_t>(8, 1); }
  const EasingData *easingData() const { return GetPointer<const EasingData *>(10); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, 4 /* frameIndex */) &&
           VerifyField<uint8_t>(verifier, 6 /* tween */) &&
           VerifyField<uint8_t>(verifier, 8 /* value */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* easingData */) &&
           verifier.VerifyTable(easingData()) &&
           verifier.EndTable();
  }
};

struct BoolFrameBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_frameIndex(int32_t frameIndex) { fbb_.AddElement<int32_t>(4, frameIndex, 0); }
  void add_tween(uint8_t tween) { fbb_.AddElement<uint8_t>(6, tween, 1); }
  void add_value(uint8_t value) { fbb_.AddElement<uint8_t>(8, value, 1); }
  void add_easingData(flatbuffers::Offset<EasingData> easingData) { fbb_.AddOffset(10, easingData); }
  BoolFrameBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  BoolFrameBuilder &operator=(const BoolFrameBuilder &);
  flatbuffers::Offset<BoolFrame> Finish() {
    auto o = flatbuffers::Offset<BoolFrame>(fbb_.EndTable(start_, 4));
    return o;
  }
};

inline flatbuffers::Offset<BoolFrame> CreateBoolFrame(flatbuffers::FlatBufferBuilder &_fbb,
   int32_t frameIndex = 0,
   uint8_t tween = 1,
   uint8_t value = 1,
   flatbuffers::Offset<EasingData> easingData = 0) {
  BoolFrameBuilder builder_(_fbb);
  builder_.add_easingData(easingData);
  builder_.add_frameIndex(frameIndex);
  builder_.add_value(value);
  builder_.add_tween(tween);
  return builder_.Finish();
}

struct InnerActionFrame : private flatbuffers::Table {
  int32_t frameIndex() const { return GetField<int32_t>(4, 0); }
  uint8_t tween() const { return GetField<uint8_t>(6, 1); }
  int32_t innerActionType() const { return GetField<int32_t>(8, 0); }
  const flatbuffers::String *currentAniamtionName() const { return GetPointer<const flatbuffers::String *>(10); }
  int32_t singleFrameIndex() const { return GetField<int32_t>(12, 0); }
  const EasingData *easingData() const { return GetPointer<const EasingData *>(14); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, 4 /* frameIndex */) &&
           VerifyField<uint8_t>(verifier, 6 /* tween */) &&
           VerifyField<int32_t>(verifier, 8 /* innerActionType */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* currentAniamtionName */) &&
           verifier.Verify(currentAniamtionName()) &&
           VerifyField<int32_t>(verifier, 12 /* singleFrameIndex */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 14 /* easingData */) &&
           verifier.VerifyTable(easingData()) &&
           verifier.EndTable();
  }
};

struct InnerActionFrameBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_frameIndex(int32_t frameIndex) { fbb_.AddElement<int32_t>(4, frameIndex, 0); }
  void add_tween(uint8_t tween) { fbb_.AddElement<uint8_t>(6, tween, 1); }
  void add_innerActionType(int32_t innerActionType) { fbb_.AddElement<int32_t>(8, innerActionType, 0); }
  void add_currentAniamtionName(flatbuffers::Offset<flatbuffers::String> currentAniamtionName) { fbb_.AddOffset(10, currentAniamtionName); }
  void add_singleFrameIndex(int32_t singleFrameIndex) { fbb_.AddElement<int32_t>(12, singleFrameIndex, 0); }
  void add_easingData(flatbuffers::Offset<EasingData> easingData) { fbb_.AddOffset(14, easingData); }
  InnerActionFrameBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  InnerActionFrameBuilder &operator=(const InnerActionFrameBuilder &);
  flatbuffers::Offset<InnerActionFrame> Finish() {
    auto o = flatbuffers::Offset<InnerActionFrame>(fbb_.EndTable(start_, 6));
    return o;
  }
};

inline flatbuffers::Offset<InnerActionFrame> CreateInnerActionFrame(flatbuffers::FlatBufferBuilder &_fbb,
   int32_t frameIndex = 0,
   uint8_t tween = 1,
   int32_t innerActionType = 0,
   flatbuffers::Offset<flatbuffers::String> currentAniamtionName = 0,
   int32_t singleFrameIndex = 0,
   flatbuffers::Offset<EasingData> easingData = 0) {
  InnerActionFrameBuilder builder_(_fbb);
  builder_.add_easingData(easingData);
  builder_.add_singleFrameIndex(singleFrameIndex);
  builder_.add_currentAniamtionName(currentAniamtionName);
  builder_.add_innerActionType(innerActionType);
  builder_.add_frameIndex(frameIndex);
  builder_.add_tween(tween);
  return builder_.Finish();
}

struct EasingData : private flatbuffers::Table {
  int32_t type() const { return GetField<int32_t>(4, -1); }
  const flatbuffers::Vector<const Position *> *points() const { return GetPointer<const flatbuffers::Vector<const Position *> *>(6); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, 4 /* type */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* points */) &&
           verifier.Verify(points()) &&
           verifier.EndTable();
  }
};

struct EasingDataBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_type(int32_t type) { fbb_.AddElement<int32_t>(4, type, -1); }
  void add_points(flatbuffers::Offset<flatbuffers::Vector<const Position *>> points) { fbb_.AddOffset(6, points); }
  EasingDataBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  EasingDataBuilder &operator=(const EasingDataBuilder &);
  flatbuffers::Offset<EasingData> Finish() {
    auto o = flatbuffers::Offset<EasingData>(fbb_.EndTable(start_, 2));
    return o;
  }
};

inline flatbuffers::Offset<EasingData> CreateEasingData(flatbuffers::FlatBufferBuilder &_fbb,
   int32_t type = -1,
   flatbuffers::Offset<flatbuffers::Vector<const Position *>> points = 0) {
  EasingDataBuilder builder_(_fbb);
  builder_.add_points(points);
  builder_.add_type(type);
  return builder_.Finish();
}

struct ResourceData : private flatbuffers::Table {
  const flatbuffers::String *path() const { return GetPointer<const flatbuffers::String *>(4); }
  const flatbuffers::String *plistFile() const { return GetPointer<const flatbuffers::String *>(6); }
  int32_t resourceType() const { return GetField<int32_t>(8, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* path */) &&
           verifier.Verify(path()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* plistFile */) &&
           verifier.Verify(plistFile()) &&
           VerifyField<int32_t>(verifier, 8 /* resourceType */) &&
           verifier.EndTable();
  }
};

struct ResourceDataBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_path(flatbuffers::Offset<flatbuffers::String> path) { fbb_.AddOffset(4, path); }
  void add_plistFile(flatbuffers::Offset<flatbuffers::String> plistFile) { fbb_.AddOffset(6, plistFile); }
  void add_resourceType(int32_t resourceType) { fbb_.AddElement<int32_t>(8, resourceType, 0); }
  ResourceDataBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  ResourceDataBuilder &operator=(const ResourceDataBuilder &);
  flatbuffers::Offset<ResourceData> Finish() {
    auto o = flatbuffers::Offset<ResourceData>(fbb_.EndTable(start_, 3));
    return o;
  }
};

inline flatbuffers::Offset<ResourceData> CreateResourceData(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<flatbuffers::String> path = 0,
   flatbuffers::Offset<flatbuffers::String> plistFile = 0,
   int32_t resourceType = 0) {
  ResourceDataBuilder builder_(_fbb);
  builder_.add_resourceType(resourceType);
  builder_.add_plistFile(plistFile);
  builder_.add_path(path);
  return builder_.Finish();
}

struct BlendFrame : private flatbuffers::Table {
  int32_t frameIndex() const { return GetField<int32_t>(4, 0); }
  uint8_t tween() const { return GetField<uint8_t>(6, 1); }
  const BlendFunc *blendFunc() const { return GetStruct<const BlendFunc *>(8); }
  const EasingData *easingData() const { return GetPointer<const EasingData *>(10); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, 4 /* frameIndex */) &&
           VerifyField<uint8_t>(verifier, 6 /* tween */) &&
           VerifyField<BlendFunc>(verifier, 8 /* blendFunc */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* easingData */) &&
           verifier.VerifyTable(easingData()) &&
           verifier.EndTable();
  }
};

struct BlendFrameBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_frameIndex(int32_t frameIndex) { fbb_.AddElement<int32_t>(4, frameIndex, 0); }
  void add_tween(uint8_t tween) { fbb_.AddElement<uint8_t>(6, tween, 1); }
  void add_blendFunc(const BlendFunc *blendFunc) { fbb_.AddStruct(8, blendFunc); }
  void add_easingData(flatbuffers::Offset<EasingData> easingData) { fbb_.AddOffset(10, easingData); }
  BlendFrameBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  BlendFrameBuilder &operator=(const BlendFrameBuilder &);
  flatbuffers::Offset<BlendFrame> Finish() {
    auto o = flatbuffers::Offset<BlendFrame>(fbb_.EndTable(start_, 4));
    return o;
  }
};

inline flatbuffers::Offset<BlendFrame> CreateBlendFrame(flatbuffers::FlatBufferBuilder &_fbb,
   int32_t frameIndex = 0,
   uint8_t tween = 1,
   const BlendFunc *blendFunc = 0,
   flatbuffers::Offset<EasingData> easingData = 0) {
  BlendFrameBuilder builder_(_fbb);
  builder_.add_easingData(easingData);
  builder_.add_blendFunc(blendFunc);
  builder_.add_frameIndex(frameIndex);
  builder_.add_tween(tween);
  return builder_.Finish();
}

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

inline bool VerifyCSParseBinaryBuffer(flatbuffers::Verifier &verifier) { return verifier.VerifyBuffer<CSParseBinary>(); }

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

}  // namespace flatbuffers

#endif  // FLATBUFFERS_GENERATED_CSPARSEBINARY_FLATBUFFERS_H_