// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: meta.proto

// This CPP symbol can be defined to use imports that match up to the framework
// imports needed when using CocoaPods.
#if !defined(GPB_USE_PROTOBUF_FRAMEWORK_IMPORTS)
 #define GPB_USE_PROTOBUF_FRAMEWORK_IMPORTS 0
#endif

#if GPB_USE_PROTOBUF_FRAMEWORK_IMPORTS
 #import <Protobuf/GPBProtocolBuffers_RuntimeSupport.h>
#else
 #import "GPBProtocolBuffers_RuntimeSupport.h"
#endif

#import "Meta.pbobjc.h"
#import "Vector.pbobjc.h"
#import "Spatial.pbobjc.h"
// @@protoc_insertion_point(imports)

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
#pragma clang diagnostic ignored "-Wdollar-in-identifier-extension"

#pragma mark - Objective C Class declarations
// Forward declarations of Objective C classes that we can use as
// static values in struct initializers.
// We don't use [Foo class] because it is not a static value.
GPBObjCClassDeclaration(Extrema);
GPBObjCClassDeclaration(GraphicsControl);
GPBObjCClassDeclaration(Representation);
GPBObjCClassDeclaration(Revision);
GPBObjCClassDeclaration(Vector32);
GPBObjCClassDeclaration(Visual);
GPBObjCClassDeclaration(Zone);

#pragma mark - MetaRoot

@implementation MetaRoot

// No extensions in the file and none of the imports (direct or indirect)
// defined extensions, so no need to generate +extensionRegistry.

@end

#pragma mark - MetaRoot_FileDescriptor

static GPBFileDescriptor *MetaRoot_FileDescriptor(void) {
  // This is called by +initialize so there is no need to worry
  // about thread safety of the singleton.
  static GPBFileDescriptor *descriptor = NULL;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    descriptor = [[GPBFileDescriptor alloc] initWithPackage:@"Messages"
                                                     syntax:GPBFileSyntaxProto3];
  }
  return descriptor;
}

#pragma mark - GraphicsControl

@implementation GraphicsControl

@dynamic mode;
@dynamic style;
@dynamic colorArray, colorArray_Count;
@dynamic alpha;
@dynamic pointWidth;
@dynamic lineWidth;
@dynamic visible;

typedef struct GraphicsControl__storage_ {
  uint32_t _has_storage_[1];
  uint32_t mode;
  uint32_t style;
  float alpha;
  float pointWidth;
  float lineWidth;
  GPBFloatArray *colorArray;
} GraphicsControl__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "mode",
        .dataTypeSpecific.clazz = Nil,
        .number = GraphicsControl_FieldNumber_Mode,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(GraphicsControl__storage_, mode),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "style",
        .dataTypeSpecific.clazz = Nil,
        .number = GraphicsControl_FieldNumber_Style,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(GraphicsControl__storage_, style),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "colorArray",
        .dataTypeSpecific.clazz = Nil,
        .number = GraphicsControl_FieldNumber_ColorArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(GraphicsControl__storage_, colorArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "alpha",
        .dataTypeSpecific.clazz = Nil,
        .number = GraphicsControl_FieldNumber_Alpha,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(GraphicsControl__storage_, alpha),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "pointWidth",
        .dataTypeSpecific.clazz = Nil,
        .number = GraphicsControl_FieldNumber_PointWidth,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(GraphicsControl__storage_, pointWidth),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "lineWidth",
        .dataTypeSpecific.clazz = Nil,
        .number = GraphicsControl_FieldNumber_LineWidth,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(GraphicsControl__storage_, lineWidth),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "visible",
        .dataTypeSpecific.clazz = Nil,
        .number = GraphicsControl_FieldNumber_Visible,
        .hasIndex = 5,
        .offset = 6,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GraphicsControl class]
                                     rootClass:[MetaRoot class]
                                          file:MetaRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(GraphicsControl__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - Representation

@implementation Representation

@dynamic propertyKey;
@dynamic colorMap;
@dynamic component;
@dynamic autoRange;
@dynamic useDefaultKey;
@dynamic colorOutOfRange;
@dynamic useMagnitude;
@dynamic displacementMultiplier;
@dynamic rangeArray, rangeArray_Count;

typedef struct Representation__storage_ {
  uint32_t _has_storage_[1];
  uint32_t colorMap;
  uint32_t component;
  float displacementMultiplier;
  NSString *propertyKey;
  GPBFloatArray *rangeArray;
} Representation__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "propertyKey",
        .dataTypeSpecific.clazz = Nil,
        .number = Representation_FieldNumber_PropertyKey,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(Representation__storage_, propertyKey),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "colorMap",
        .dataTypeSpecific.clazz = Nil,
        .number = Representation_FieldNumber_ColorMap,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(Representation__storage_, colorMap),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "component",
        .dataTypeSpecific.clazz = Nil,
        .number = Representation_FieldNumber_Component,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(Representation__storage_, component),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "autoRange",
        .dataTypeSpecific.clazz = Nil,
        .number = Representation_FieldNumber_AutoRange,
        .hasIndex = 3,
        .offset = 4,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "useDefaultKey",
        .dataTypeSpecific.clazz = Nil,
        .number = Representation_FieldNumber_UseDefaultKey,
        .hasIndex = 5,
        .offset = 6,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "colorOutOfRange",
        .dataTypeSpecific.clazz = Nil,
        .number = Representation_FieldNumber_ColorOutOfRange,
        .hasIndex = 7,
        .offset = 8,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "useMagnitude",
        .dataTypeSpecific.clazz = Nil,
        .number = Representation_FieldNumber_UseMagnitude,
        .hasIndex = 9,
        .offset = 10,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "displacementMultiplier",
        .dataTypeSpecific.clazz = Nil,
        .number = Representation_FieldNumber_DisplacementMultiplier,
        .hasIndex = 11,
        .offset = (uint32_t)offsetof(Representation__storage_, displacementMultiplier),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "rangeArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Representation_FieldNumber_RangeArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Representation__storage_, rangeArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeFloat,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[Representation class]
                                     rootClass:[MetaRoot class]
                                          file:MetaRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(Representation__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - Visual

@implementation Visual

@dynamic hasRegion, region;
@dynamic hasControl, control;
@dynamic hasRepresentation, representation;
@dynamic pointsArray, pointsArray_Count;
@dynamic linesArray, linesArray_Count;
@dynamic trianglesArray, trianglesArray_Count;
@dynamic indicesPerElementArray, indicesPerElementArray_Count;
@dynamic elementsToIndicesArray, elementsToIndicesArray_Count;
@dynamic indicesToElementsArray, indicesToElementsArray_Count;
@dynamic extrasArray, extrasArray_Count;

typedef struct Visual__storage_ {
  uint32_t _has_storage_[1];
  Zone *region;
  GraphicsControl *control;
  Representation *representation;
  GPBUInt32Array *pointsArray;
  GPBUInt32Array *linesArray;
  GPBUInt32Array *trianglesArray;
  GPBUInt32Array *indicesPerElementArray;
  GPBUInt32Array *elementsToIndicesArray;
  GPBUInt32Array *indicesToElementsArray;
  NSMutableArray *extrasArray;
} Visual__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "region",
        .dataTypeSpecific.clazz = GPBObjCClass(Zone),
        .number = Visual_FieldNumber_Region,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(Visual__storage_, region),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "control",
        .dataTypeSpecific.clazz = GPBObjCClass(GraphicsControl),
        .number = Visual_FieldNumber_Control,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(Visual__storage_, control),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "representation",
        .dataTypeSpecific.clazz = GPBObjCClass(Representation),
        .number = Visual_FieldNumber_Representation,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(Visual__storage_, representation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "pointsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Visual_FieldNumber_PointsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Visual__storage_, pointsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "linesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Visual_FieldNumber_LinesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Visual__storage_, linesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "trianglesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Visual_FieldNumber_TrianglesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Visual__storage_, trianglesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "indicesPerElementArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Visual_FieldNumber_IndicesPerElementArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Visual__storage_, indicesPerElementArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "elementsToIndicesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Visual_FieldNumber_ElementsToIndicesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Visual__storage_, elementsToIndicesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "indicesToElementsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Visual_FieldNumber_IndicesToElementsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Visual__storage_, indicesToElementsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "extrasArray",
        .dataTypeSpecific.clazz = GPBObjCClass(Vector32),
        .number = Visual_FieldNumber_ExtrasArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Visual__storage_, extrasArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[Visual class]
                                     rootClass:[MetaRoot class]
                                          file:MetaRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(Visual__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - Meta

@implementation Meta

@dynamic name;
@dynamic uid;
@dynamic directory;
@dynamic symbol;
@dynamic owner;
@dynamic comments;
@dynamic series;
@dynamic sysInfo;
@dynamic geomInfo;
@dynamic parent;
@dynamic created;
@dynamic saved;
@dynamic modified;
@dynamic iteration;
@dynamic saveInterval;
@dynamic enabled;
@dynamic locked;
@dynamic autoSave;
@dynamic lightweight;
@dynamic hasRevision, revision;
@dynamic hasVersion, version;
@dynamic hasBounds, bounds;
@dynamic URL;
@dynamic hasAppearance, appearance;
@dynamic childrenArray, childrenArray_Count;
@dynamic groupsArray, groupsArray_Count;
@dynamic loopsArray, loopsArray_Count;
@dynamic surfacesArray, surfacesArray_Count;
@dynamic volumesArray, volumesArray_Count;
@dynamic globalTransformArray, globalTransformArray_Count;
@dynamic globalRateArray, globalRateArray_Count;
@dynamic globalAccelArray, globalAccelArray_Count;
@dynamic propertiesArray, propertiesArray_Count;
@dynamic mediaArray, mediaArray_Count;
@dynamic symbolTransformArray, symbolTransformArray_Count;
@dynamic lengthUnits;

typedef struct Meta__storage_ {
  uint32_t _has_storage_[1];
  uint32_t lengthUnits;
  NSString *name;
  NSString *directory;
  NSString *symbol;
  NSString *owner;
  NSString *comments;
  NSString *series;
  NSString *sysInfo;
  NSString *geomInfo;
  Revision *revision;
  Revision *version;
  Extrema *bounds;
  NSString *URL;
  GraphicsControl *appearance;
  GPBInt64Array *childrenArray;
  GPBInt32Array *groupsArray;
  GPBInt32Array *loopsArray;
  GPBInt32Array *surfacesArray;
  GPBInt32Array *volumesArray;
  GPBDoubleArray *globalTransformArray;
  GPBDoubleArray *globalRateArray;
  GPBDoubleArray *globalAccelArray;
  NSMutableArray *propertiesArray;
  NSMutableArray *mediaArray;
  GPBFloatArray *symbolTransformArray;
  int64_t uid;
  int64_t parent;
  int64_t created;
  int64_t saved;
  int64_t modified;
  uint64_t iteration;
  uint64_t saveInterval;
} Meta__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "name",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_Name,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(Meta__storage_, name),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "uid",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_Uid,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(Meta__storage_, uid),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt64,
      },
      {
        .name = "directory",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_Directory,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(Meta__storage_, directory),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "symbol",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_Symbol,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(Meta__storage_, symbol),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "owner",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_Owner,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(Meta__storage_, owner),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "comments",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_Comments,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(Meta__storage_, comments),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "series",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_Series,
        .hasIndex = 6,
        .offset = (uint32_t)offsetof(Meta__storage_, series),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "sysInfo",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_SysInfo,
        .hasIndex = 7,
        .offset = (uint32_t)offsetof(Meta__storage_, sysInfo),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "geomInfo",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_GeomInfo,
        .hasIndex = 8,
        .offset = (uint32_t)offsetof(Meta__storage_, geomInfo),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "parent",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_Parent,
        .hasIndex = 9,
        .offset = (uint32_t)offsetof(Meta__storage_, parent),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt64,
      },
      {
        .name = "created",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_Created,
        .hasIndex = 10,
        .offset = (uint32_t)offsetof(Meta__storage_, created),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt64,
      },
      {
        .name = "saved",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_Saved,
        .hasIndex = 11,
        .offset = (uint32_t)offsetof(Meta__storage_, saved),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt64,
      },
      {
        .name = "modified",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_Modified,
        .hasIndex = 12,
        .offset = (uint32_t)offsetof(Meta__storage_, modified),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt64,
      },
      {
        .name = "iteration",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_Iteration,
        .hasIndex = 13,
        .offset = (uint32_t)offsetof(Meta__storage_, iteration),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt64,
      },
      {
        .name = "saveInterval",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_SaveInterval,
        .hasIndex = 14,
        .offset = (uint32_t)offsetof(Meta__storage_, saveInterval),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt64,
      },
      {
        .name = "enabled",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_Enabled,
        .hasIndex = 15,
        .offset = 16,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "locked",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_Locked,
        .hasIndex = 17,
        .offset = 18,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "autoSave",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_AutoSave,
        .hasIndex = 19,
        .offset = 20,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "lightweight",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_Lightweight,
        .hasIndex = 21,
        .offset = 22,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "revision",
        .dataTypeSpecific.clazz = GPBObjCClass(Revision),
        .number = Meta_FieldNumber_Revision,
        .hasIndex = 23,
        .offset = (uint32_t)offsetof(Meta__storage_, revision),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "version",
        .dataTypeSpecific.clazz = GPBObjCClass(Revision),
        .number = Meta_FieldNumber_Version,
        .hasIndex = 24,
        .offset = (uint32_t)offsetof(Meta__storage_, version),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "bounds",
        .dataTypeSpecific.clazz = GPBObjCClass(Extrema),
        .number = Meta_FieldNumber_Bounds,
        .hasIndex = 25,
        .offset = (uint32_t)offsetof(Meta__storage_, bounds),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "URL",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_URL,
        .hasIndex = 26,
        .offset = (uint32_t)offsetof(Meta__storage_, URL),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "appearance",
        .dataTypeSpecific.clazz = GPBObjCClass(GraphicsControl),
        .number = Meta_FieldNumber_Appearance,
        .hasIndex = 27,
        .offset = (uint32_t)offsetof(Meta__storage_, appearance),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "childrenArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_ChildrenArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Meta__storage_, childrenArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt64,
      },
      {
        .name = "groupsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_GroupsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Meta__storage_, groupsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "loopsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_LoopsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Meta__storage_, loopsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "surfacesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_SurfacesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Meta__storage_, surfacesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "volumesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_VolumesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Meta__storage_, volumesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "globalTransformArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_GlobalTransformArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Meta__storage_, globalTransformArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeDouble,
      },
      {
        .name = "globalRateArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_GlobalRateArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Meta__storage_, globalRateArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeDouble,
      },
      {
        .name = "globalAccelArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_GlobalAccelArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Meta__storage_, globalAccelArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeDouble,
      },
      {
        .name = "propertiesArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_PropertiesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Meta__storage_, propertiesArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "mediaArray",
        .dataTypeSpecific.clazz = GPBObjCClass(Visual),
        .number = Meta_FieldNumber_MediaArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Meta__storage_, mediaArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "symbolTransformArray",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_SymbolTransformArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(Meta__storage_, symbolTransformArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "lengthUnits",
        .dataTypeSpecific.clazz = Nil,
        .number = Meta_FieldNumber_LengthUnits,
        .hasIndex = 28,
        .offset = (uint32_t)offsetof(Meta__storage_, lengthUnits),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[Meta class]
                                     rootClass:[MetaRoot class]
                                          file:MetaRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(Meta__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\001\027!!!\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - SliceControl

@implementation SliceControl

@dynamic name;
@dynamic centerArray, centerArray_Count;
@dynamic normalArray, normalArray_Count;
@dynamic intersect;
@dynamic negative;
@dynamic positive;

typedef struct SliceControl__storage_ {
  uint32_t _has_storage_[1];
  NSString *name;
  GPBDoubleArray *centerArray;
  GPBDoubleArray *normalArray;
} SliceControl__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "name",
        .dataTypeSpecific.clazz = Nil,
        .number = SliceControl_FieldNumber_Name,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(SliceControl__storage_, name),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "centerArray",
        .dataTypeSpecific.clazz = Nil,
        .number = SliceControl_FieldNumber_CenterArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(SliceControl__storage_, centerArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeDouble,
      },
      {
        .name = "normalArray",
        .dataTypeSpecific.clazz = Nil,
        .number = SliceControl_FieldNumber_NormalArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(SliceControl__storage_, normalArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeDouble,
      },
      {
        .name = "intersect",
        .dataTypeSpecific.clazz = Nil,
        .number = SliceControl_FieldNumber_Intersect,
        .hasIndex = 1,
        .offset = 2,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "negative",
        .dataTypeSpecific.clazz = Nil,
        .number = SliceControl_FieldNumber_Negative,
        .hasIndex = 3,
        .offset = 4,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "positive",
        .dataTypeSpecific.clazz = Nil,
        .number = SliceControl_FieldNumber_Positive,
        .hasIndex = 5,
        .offset = 6,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[SliceControl class]
                                     rootClass:[MetaRoot class]
                                          file:MetaRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(SliceControl__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - CameraControl

@implementation CameraControl

@dynamic subjectArray, subjectArray_Count;
@dynamic offsetArray, offsetArray_Count;
@dynamic angleArray, angleArray_Count;
@dynamic sceneTime;
@dynamic magnification;
@dynamic timeConstant;
@dynamic panSensitivity;
@dynamic rotationSensitivity;
@dynamic zoomSensitivity;
@dynamic znear;
@dynamic zfar;
@dynamic aov;
@dynamic resolutionArray, resolutionArray_Count;
@dynamic perspective;
@dynamic smooth;
@dynamic orbit;
@dynamic follow;

typedef struct CameraControl__storage_ {
  uint32_t _has_storage_[1];
  float sceneTime;
  float magnification;
  float timeConstant;
  float panSensitivity;
  float rotationSensitivity;
  float zoomSensitivity;
  float znear;
  float zfar;
  float aov;
  GPBFloatArray *subjectArray;
  GPBFloatArray *offsetArray;
  GPBFloatArray *angleArray;
  GPBUInt32Array *resolutionArray;
} CameraControl__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "subjectArray",
        .dataTypeSpecific.clazz = Nil,
        .number = CameraControl_FieldNumber_SubjectArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(CameraControl__storage_, subjectArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "offsetArray",
        .dataTypeSpecific.clazz = Nil,
        .number = CameraControl_FieldNumber_OffsetArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(CameraControl__storage_, offsetArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "angleArray",
        .dataTypeSpecific.clazz = Nil,
        .number = CameraControl_FieldNumber_AngleArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(CameraControl__storage_, angleArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "sceneTime",
        .dataTypeSpecific.clazz = Nil,
        .number = CameraControl_FieldNumber_SceneTime,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(CameraControl__storage_, sceneTime),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "magnification",
        .dataTypeSpecific.clazz = Nil,
        .number = CameraControl_FieldNumber_Magnification,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(CameraControl__storage_, magnification),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "timeConstant",
        .dataTypeSpecific.clazz = Nil,
        .number = CameraControl_FieldNumber_TimeConstant,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(CameraControl__storage_, timeConstant),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "panSensitivity",
        .dataTypeSpecific.clazz = Nil,
        .number = CameraControl_FieldNumber_PanSensitivity,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(CameraControl__storage_, panSensitivity),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "rotationSensitivity",
        .dataTypeSpecific.clazz = Nil,
        .number = CameraControl_FieldNumber_RotationSensitivity,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(CameraControl__storage_, rotationSensitivity),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "zoomSensitivity",
        .dataTypeSpecific.clazz = Nil,
        .number = CameraControl_FieldNumber_ZoomSensitivity,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(CameraControl__storage_, zoomSensitivity),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "znear",
        .dataTypeSpecific.clazz = Nil,
        .number = CameraControl_FieldNumber_Znear,
        .hasIndex = 6,
        .offset = (uint32_t)offsetof(CameraControl__storage_, znear),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "zfar",
        .dataTypeSpecific.clazz = Nil,
        .number = CameraControl_FieldNumber_Zfar,
        .hasIndex = 7,
        .offset = (uint32_t)offsetof(CameraControl__storage_, zfar),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "aov",
        .dataTypeSpecific.clazz = Nil,
        .number = CameraControl_FieldNumber_Aov,
        .hasIndex = 8,
        .offset = (uint32_t)offsetof(CameraControl__storage_, aov),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeFloat,
      },
      {
        .name = "resolutionArray",
        .dataTypeSpecific.clazz = Nil,
        .number = CameraControl_FieldNumber_ResolutionArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(CameraControl__storage_, resolutionArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeUInt32,
      },
      {
        .name = "perspective",
        .dataTypeSpecific.clazz = Nil,
        .number = CameraControl_FieldNumber_Perspective,
        .hasIndex = 9,
        .offset = 10,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "smooth",
        .dataTypeSpecific.clazz = Nil,
        .number = CameraControl_FieldNumber_Smooth,
        .hasIndex = 11,
        .offset = 12,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "orbit",
        .dataTypeSpecific.clazz = Nil,
        .number = CameraControl_FieldNumber_Orbit,
        .hasIndex = 13,
        .offset = 14,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "follow",
        .dataTypeSpecific.clazz = Nil,
        .number = CameraControl_FieldNumber_Follow,
        .hasIndex = 15,
        .offset = 16,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[CameraControl class]
                                     rootClass:[MetaRoot class]
                                          file:MetaRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(CameraControl__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end


#pragma clang diagnostic pop

// @@protoc_insertion_point(global_scope)
