text:
namespace TSCH {

namespace {

const ::google::protobuf::Descriptor* Chart3DEnvironmentPackageArchive_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Chart3DEnvironmentPackageArchive_reflection_ = NULL;
const ::google::protobuf::Descriptor* Chart3DFillArchive_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Chart3DFillArchive_reflection_ = NULL;
const ::google::protobuf::Descriptor* Chart3DPointLightArchive_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Chart3DPointLightArchive_reflection_ = NULL;
const ::google::protobuf::Descriptor* Chart3DDirectionalLightArchive_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Chart3DDirectionalLightArchive_reflection_ = NULL;
const ::google::protobuf::Descriptor* Chart3DSpotLightArchive_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Chart3DSpotLightArchive_reflection_ = NULL;
const ::google::protobuf::Descriptor* Chart3DLightArchive_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Chart3DLightArchive_reflection_ = NULL;
const ::google::protobuf::Descriptor* Chart3DLightingModelArchive_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Chart3DLightingModelArchive_reflection_ = NULL;
const ::google::protobuf::Descriptor* Chart3DLightingPackageArchive_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Chart3DLightingPackageArchive_reflection_ = NULL;
const ::google::protobuf::Descriptor* Chart3DTexturesMaterialArchive_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Chart3DTexturesMaterialArchive_reflection_ = NULL;
const ::google::protobuf::Descriptor* Chart3DEmissiveMaterialArchive_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Chart3DEmissiveMaterialArchive_reflection_ = NULL;
const ::google::protobuf::Descriptor* Chart3DDiffuseMaterialArchive_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Chart3DDiffuseMaterialArchive_reflection_ = NULL;
const ::google::protobuf::Descriptor* Chart3DModulateMaterialArchive_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Chart3DModulateMaterialArchive_reflection_ = NULL;
const ::google::protobuf::Descriptor* Chart3DSpecularMaterialArchive_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Chart3DSpecularMaterialArchive_reflection_ = NULL;
const ::google::protobuf::Descriptor* Chart3DShininessMaterialArchive_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Chart3DShininessMaterialArchive_reflection_ = NULL;
const ::google::protobuf::Descriptor* Chart3DEnvironmentMaterialArchive_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Chart3DEnvironmentMaterialArchive_reflection_ = NULL;
const ::google::protobuf::Descriptor* Chart3DFixedFunctionLightingModelArchive_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Chart3DFixedFunctionLightingModelArchive_reflection_ = NULL;
const ::google::protobuf::Descriptor* Chart3DPhongLightingModelArchive_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Chart3DPhongLightingModelArchive_reflection_ = NULL;
const ::google::protobuf::Descriptor* Chart3DPhongMaterialPackageArchive_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Chart3DPhongMaterialPackageArchive_reflection_ = NULL;
const ::google::protobuf::Descriptor* Chart3DTSPImageDataTextureArchive_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Chart3DTSPImageDataTextureArchive_reflection_ = NULL;
const ::google::protobuf::Descriptor* Chart3DBaseImageTextureTilingArchive_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Chart3DBaseImageTextureTilingArchive_reflection_ = NULL;
const ::google::protobuf::Descriptor* Chart3DImageTextureTilingArchive_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Chart3DImageTextureTilingArchive_reflection_ = NULL;
const ::google::protobuf::Descriptor* Chart3DVectorArchive_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Chart3DVectorArchive_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* TextureTilingMode_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* TextureTilingFace_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* TextureTilingWrap_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* TextureTilingXPosition_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* TextureTilingYPosition_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* TextureTilingContinuity_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* FillPropertyType_descriptor_ = NULL;

}  // namespace

void protobuf_AssignDesc_TSCH3DArchives_2eproto() {
  protobuf_AddDesc_TSCH3DArchives_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "TSCH3DArchives.proto");
  GOOGLE_CHECK(file != NULL);
  Chart3DEnvironmentPackageArchive_descriptor_ = file->message_type(0);
  static const int Chart3DEnvironmentPackageArchive_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DEnvironmentPackageArchive, materials_),
  };
  Chart3DEnvironmentPackageArchive_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Chart3DEnvironmentPackageArchive_descriptor_,
      Chart3DEnvironmentPackageArchive::default_instance_,
      Chart3DEnvironmentPackageArchive_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DEnvironmentPackageArchive, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DEnvironmentPackageArchive, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Chart3DEnvironmentPackageArchive));
  Chart3DFillArchive_descriptor_ = file->message_type(1);
  static const int Chart3DFillArchive_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DFillArchive, lightingmodel_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DFillArchive, textureset_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DFillArchive, fill_type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DFillArchive, series_index_),
  };
  Chart3DFillArchive_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Chart3DFillArchive_descriptor_,
      Chart3DFillArchive::default_instance_,
      Chart3DFillArchive_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DFillArchive, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DFillArchive, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Chart3DFillArchive));
  Chart3DPointLightArchive_descriptor_ = file->message_type(2);
  static const int Chart3DPointLightArchive_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DPointLightArchive, position_),
  };
  Chart3DPointLightArchive_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Chart3DPointLightArchive_descriptor_,
      Chart3DPointLightArchive::default_instance_,
      Chart3DPointLightArchive_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DPointLightArchive, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DPointLightArchive, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Chart3DPointLightArchive));
  Chart3DDirectionalLightArchive_descriptor_ = file->message_type(3);
  static const int Chart3DDirectionalLightArchive_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DDirectionalLightArchive, direction_),
  };
  Chart3DDirectionalLightArchive_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Chart3DDirectionalLightArchive_descriptor_,
      Chart3DDirectionalLightArchive::default_instance_,
      Chart3DDirectionalLightArchive_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DDirectionalLightArchive, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DDirectionalLightArchive, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Chart3DDirectionalLightArchive));
  Chart3DSpotLightArchive_descriptor_ = file->message_type(4);
  static const int Chart3DSpotLightArchive_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DSpotLightArchive, position_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DSpotLightArchive, direction_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DSpotLightArchive, cutoff_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DSpotLightArchive, dropoff_),
  };
  Chart3DSpotLightArchive_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Chart3DSpotLightArchive_descriptor_,
      Chart3DSpotLightArchive::default_instance_,
      Chart3DSpotLightArchive_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DSpotLightArchive, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DSpotLightArchive, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Chart3DSpotLightArchive));
  Chart3DLightArchive_descriptor_ = file->message_type(5);
  static const int Chart3DLightArchive_offsets_[11] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DLightArchive, name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DLightArchive, ambient_color_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DLightArchive, diffuse_color_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DLightArchive, specular_color_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DLightArchive, intensity_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DLightArchive, attenuation_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DLightArchive, coordinate_space_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DLightArchive, enabled_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DLightArchive, point_light_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DLightArchive, directional_light_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DLightArchive, spot_light_),
  };
  Chart3DLightArchive_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Chart3DLightArchive_descriptor_,
      Chart3DLightArchive::default_instance_,
      Chart3DLightArchive_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DLightArchive, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DLightArchive, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Chart3DLightArchive));
  Chart3DLightingModelArchive_descriptor_ = file->message_type(6);
  static const int Chart3DLightingModelArchive_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DLightingModelArchive, phong_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DLightingModelArchive, fixed_function_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DLightingModelArchive, environment_),
  };
  Chart3DLightingModelArchive_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Chart3DLightingModelArchive_descriptor_,
      Chart3DLightingModelArchive::default_instance_,
      Chart3DLightingModelArchive_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DLightingModelArchive, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DLightingModelArchive, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Chart3DLightingModelArchive));
  Chart3DLightingPackageArchive_descriptor_ = file->message_type(7);
  static const int Chart3DLightingPackageArchive_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DLightingPackageArchive, name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DLightingPackageArchive, lights_),
  };
  Chart3DLightingPackageArchive_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Chart3DLightingPackageArchive_descriptor_,
      Chart3DLightingPackageArchive::default_instance_,
      Chart3DLightingPackageArchive_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DLightingPackageArchive, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DLightingPackageArchive, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Chart3DLightingPackageArchive));
  Chart3DTexturesMaterialArchive_descriptor_ = file->message_type(8);
  static const int Chart3DTexturesMaterialArchive_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DTexturesMaterialArchive, color_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DTexturesMaterialArchive, textures_),
  };
  Chart3DTexturesMaterialArchive_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Chart3DTexturesMaterialArchive_descriptor_,
      Chart3DTexturesMaterialArchive::default_instance_,
      Chart3DTexturesMaterialArchive_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DTexturesMaterialArchive, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DTexturesMaterialArchive, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Chart3DTexturesMaterialArchive));
  Chart3DEmissiveMaterialArchive_descriptor_ = file->message_type(9);
  static const int Chart3DEmissiveMaterialArchive_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DEmissiveMaterialArchive, super_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DEmissiveMaterialArchive, tilings_),
  };
  Chart3DEmissiveMaterialArchive_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Chart3DEmissiveMaterialArchive_descriptor_,
      Chart3DEmissiveMaterialArchive::default_instance_,
      Chart3DEmissiveMaterialArchive_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DEmissiveMaterialArchive, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DEmissiveMaterialArchive, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Chart3DEmissiveMaterialArchive));
  Chart3DDiffuseMaterialArchive_descriptor_ = file->message_type(10);
  static const int Chart3DDiffuseMaterialArchive_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DDiffuseMaterialArchive, super_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DDiffuseMaterialArchive, tilings_),
  };
  Chart3DDiffuseMaterialArchive_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Chart3DDiffuseMaterialArchive_descriptor_,
      Chart3DDiffuseMaterialArchive::default_instance_,
      Chart3DDiffuseMaterialArchive_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DDiffuseMaterialArchive, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DDiffuseMaterialArchive, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Chart3DDiffuseMaterialArchive));
  Chart3DModulateMaterialArchive_descriptor_ = file->message_type(11);
  static const int Chart3DModulateMaterialArchive_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DModulateMaterialArchive, super_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DModulateMaterialArchive, tilings_),
  };
  Chart3DModulateMaterialArchive_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Chart3DModulateMaterialArchive_descriptor_,
      Chart3DModulateMaterialArchive::default_instance_,
      Chart3DModulateMaterialArchive_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DModulateMaterialArchive, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DModulateMaterialArchive, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Chart3DModulateMaterialArchive));
  Chart3DSpecularMaterialArchive_descriptor_ = file->message_type(12);
  static const int Chart3DSpecularMaterialArchive_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DSpecularMaterialArchive, super_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DSpecularMaterialArchive, tilings_),
  };
  Chart3DSpecularMaterialArchive_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Chart3DSpecularMaterialArchive_descriptor_,
      Chart3DSpecularMaterialArchive::default_instance_,
      Chart3DSpecularMaterialArchive_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DSpecularMaterialArchive, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DSpecularMaterialArchive, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Chart3DSpecularMaterialArchive));
  Chart3DShininessMaterialArchive_descriptor_ = file->message_type(13);
  static const int Chart3DShininessMaterialArchive_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DShininessMaterialArchive, super_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DShininessMaterialArchive, tilings_),
  };
  Chart3DShininessMaterialArchive_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Chart3DShininessMaterialArchive_descriptor_,
      Chart3DShininessMaterialArchive::default_instance_,
      Chart3DShininessMaterialArchive_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DShininessMaterialArchive, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DShininessMaterialArchive, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Chart3DShininessMaterialArchive));
  Chart3DEnvironmentMaterialArchive_descriptor_ = file->message_type(14);
  static const int Chart3DEnvironmentMaterialArchive_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DEnvironmentMaterialArchive, super_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DEnvironmentMaterialArchive, obsolete_tilings_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DEnvironmentMaterialArchive, decalmode_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DEnvironmentMaterialArchive, tilings_),
  };
  Chart3DEnvironmentMaterialArchive_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Chart3DEnvironmentMaterialArchive_descriptor_,
      Chart3DEnvironmentMaterialArchive::default_instance_,
      Chart3DEnvironmentMaterialArchive_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DEnvironmentMaterialArchive, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DEnvironmentMaterialArchive, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Chart3DEnvironmentMaterialArchive));
  Chart3DFixedFunctionLightingModelArchive_descriptor_ = file->message_type(15);
  static const int Chart3DFixedFunctionLightingModelArchive_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DFixedFunctionLightingModelArchive, materials_),
  };
  Chart3DFixedFunctionLightingModelArchive_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Chart3DFixedFunctionLightingModelArchive_descriptor_,
      Chart3DFixedFunctionLightingModelArchive::default_instance_,
      Chart3DFixedFunctionLightingModelArchive_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DFixedFunctionLightingModelArchive, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DFixedFunctionLightingModelArchive, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Chart3DFixedFunctionLightingModelArchive));
  Chart3DPhongLightingModelArchive_descriptor_ = file->message_type(16);
  static const int Chart3DPhongLightingModelArchive_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DPhongLightingModelArchive, materials_),
  };
  Chart3DPhongLightingModelArchive_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Chart3DPhongLightingModelArchive_descriptor_,
      Chart3DPhongLightingModelArchive::default_instance_,
      Chart3DPhongLightingModelArchive_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DPhongLightingModelArchive, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DPhongLightingModelArchive, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Chart3DPhongLightingModelArchive));
  Chart3DPhongMaterialPackageArchive_descriptor_ = file->message_type(17);
  static const int Chart3DPhongMaterialPackageArchive_offsets_[5] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DPhongMaterialPackageArchive, emissive_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DPhongMaterialPackageArchive, diffuse_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DPhongMaterialPackageArchive, modulate_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DPhongMaterialPackageArchive, specular_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DPhongMaterialPackageArchive, shininess_),
  };
  Chart3DPhongMaterialPackageArchive_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Chart3DPhongMaterialPackageArchive_descriptor_,
      Chart3DPhongMaterialPackageArchive::default_instance_,
      Chart3DPhongMaterialPackageArchive_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DPhongMaterialPackageArchive, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DPhongMaterialPackageArchive, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Chart3DPhongMaterialPackageArchive));
  Chart3DTSPImageDataTextureArchive_descriptor_ = file->message_type(18);
  static const int Chart3DTSPImageDataTextureArchive_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DTSPImageDataTextureArchive, data_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DTSPImageDataTextureArchive, mipmapdata_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DTSPImageDataTextureArchive, database_data_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DTSPImageDataTextureArchive, database_mipmapdata_),
  };
  Chart3DTSPImageDataTextureArchive_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Chart3DTSPImageDataTextureArchive_descriptor_,
      Chart3DTSPImageDataTextureArchive::default_instance_,
      Chart3DTSPImageDataTextureArchive_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DTSPImageDataTextureArchive, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DTSPImageDataTextureArchive, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Chart3DTSPImageDataTextureArchive));
  Chart3DBaseImageTextureTilingArchive_descriptor_ = file->message_type(19);
  static const int Chart3DBaseImageTextureTilingArchive_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DBaseImageTextureTilingArchive, scale_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DBaseImageTextureTilingArchive, rotation_),
  };
  Chart3DBaseImageTextureTilingArchive_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Chart3DBaseImageTextureTilingArchive_descriptor_,
      Chart3DBaseImageTextureTilingArchive::default_instance_,
      Chart3DBaseImageTextureTilingArchive_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DBaseImageTextureTilingArchive, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DBaseImageTextureTilingArchive, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Chart3DBaseImageTextureTilingArchive));
  Chart3DImageTextureTilingArchive_descriptor_ = file->message_type(20);
  static const int Chart3DImageTextureTilingArchive_offsets_[9] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DImageTextureTilingArchive, super_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DImageTextureTilingArchive, mode_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DImageTextureTilingArchive, wrap_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DImageTextureTilingArchive, face_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DImageTextureTilingArchive, xposition_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DImageTextureTilingArchive, yposition_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DImageTextureTilingArchive, scontinuity_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DImageTextureTilingArchive, tcontinuity_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DImageTextureTilingArchive, reveal_),
  };
  Chart3DImageTextureTilingArchive_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Chart3DImageTextureTilingArchive_descriptor_,
      Chart3DImageTextureTilingArchive::default_instance_,
      Chart3DImageTextureTilingArchive_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DImageTextureTilingArchive, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DImageTextureTilingArchive, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Chart3DImageTextureTilingArchive));
  Chart3DVectorArchive_descriptor_ = file->message_type(21);
  static const int Chart3DVectorArchive_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DVectorArchive, x_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DVectorArchive, y_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DVectorArchive, z_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DVectorArchive, w_),
  };
  Chart3DVectorArchive_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Chart3DVectorArchive_descriptor_,
      Chart3DVectorArchive::default_instance_,
      Chart3DVectorArchive_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DVectorArchive, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Chart3DVectorArchive, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Chart3DVectorArchive));
  TextureTilingMode_descriptor_ = file->enum_type(0);
  TextureTilingFace_descriptor_ = file->enum_type(1);
  TextureTilingWrap_descriptor_ = file->enum_type(2);
  TextureTilingXPosition_descriptor_ = file->enum_type(3);
  TextureTilingYPosition_descriptor_ = file->enum_type(4);
  TextureTilingContinuity_descriptor_ = file->enum_type(5);
  FillPropertyType_descriptor_ = file->enum_type(6);
}

namespace {

GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
inline void protobuf_AssignDescriptorsOnce() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
                 &protobuf_AssignDesc_TSCH3DArchives_2eproto);
}

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Chart3DEnvironmentPackageArchive_descriptor_, &Chart3DEnvironmentPackageArchive::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Chart3DFillArchive_descriptor_, &Chart3DFillArchive::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Chart3DPointLightArchive_descriptor_, &Chart3DPointLightArchive::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Chart3DDirectionalLightArchive_descriptor_, &Chart3DDirectionalLightArchive::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Chart3DSpotLightArchive_descriptor_, &Chart3DSpotLightArchive::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Chart3DLightArchive_descriptor_, &Chart3DLightArchive::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Chart3DLightingModelArchive_descriptor_, &Chart3DLightingModelArchive::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Chart3DLightingPackageArchive_descriptor_, &Chart3DLightingPackageArchive::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Chart3DTexturesMaterialArchive_descriptor_, &Chart3DTexturesMaterialArchive::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Chart3DEmissiveMaterialArchive_descriptor_, &Chart3DEmissiveMaterialArchive::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Chart3DDiffuseMaterialArchive_descriptor_, &Chart3DDiffuseMaterialArchive::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Chart3DModulateMaterialArchive_descriptor_, &Chart3DModulateMaterialArchive::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Chart3DSpecularMaterialArchive_descriptor_, &Chart3DSpecularMaterialArchive::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Chart3DShininessMaterialArchive_descriptor_, &Chart3DShininessMaterialArchive::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Chart3DEnvironmentMaterialArchive_descriptor_, &Chart3DEnvironmentMaterialArchive::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Chart3DFixedFunctionLightingModelArchive_descriptor_, &Chart3DFixedFunctionLightingModelArchive::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Chart3DPhongLightingModelArchive_descriptor_, &Chart3DPhongLightingModelArchive::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Chart3DPhongMaterialPackageArchive_descriptor_, &Chart3DPhongMaterialPackageArchive::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Chart3DTSPImageDataTextureArchive_descriptor_, &Chart3DTSPImageDataTextureArchive::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Chart3DBaseImageTextureTilingArchive_descriptor_, &Chart3DBaseImageTextureTilingArchive::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Chart3DImageTextureTilingArchive_descriptor_, &Chart3DImageTextureTilingArchive::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Chart3DVectorArchive_descriptor_, &Chart3DVectorArchive::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_TSCH3DArchives_2eproto() {
  delete Chart3DEnvironmentPackageArchive::default_instance_;
  delete Chart3DEnvironmentPackageArchive_reflection_;
  delete Chart3DFillArchive::default_instance_;
  delete Chart3DFillArchive_reflection_;
  delete Chart3DPointLightArchive::default_instance_;
  delete Chart3DPointLightArchive_reflection_;
  delete Chart3DDirectionalLightArchive::default_instance_;
  delete Chart3DDirectionalLightArchive_reflection_;
  delete Chart3DSpotLightArchive::default_instance_;
  delete Chart3DSpotLightArchive_reflection_;
  delete Chart3DLightArchive::default_instance_;
  delete Chart3DLightArchive_reflection_;
  delete Chart3DLightingModelArchive::default_instance_;
  delete Chart3DLightingModelArchive_reflection_;
  delete Chart3DLightingPackageArchive::default_instance_;
  delete Chart3DLightingPackageArchive_reflection_;
  delete Chart3DTexturesMaterialArchive::default_instance_;
  delete Chart3DTexturesMaterialArchive_reflection_;
  delete Chart3DEmissiveMaterialArchive::default_instance_;
  delete Chart3DEmissiveMaterialArchive_reflection_;
  delete Chart3DDiffuseMaterialArchive::default_instance_;
  delete Chart3DDiffuseMaterialArchive_reflection_;
  delete Chart3DModulateMaterialArchive::default_instance_;
  delete Chart3DModulateMaterialArchive_reflection_;
  delete Chart3DSpecularMaterialArchive::default_instance_;
  delete Chart3DSpecularMaterialArchive_reflection_;
  delete Chart3DShininessMaterialArchive::default_instance_;
  delete Chart3DShininessMaterialArchive_reflection_;
  delete Chart3DEnvironmentMaterialArchive::default_instance_;
  delete Chart3DEnvironmentMaterialArchive_reflection_;
  delete Chart3DFixedFunctionLightingModelArchive::default_instance_;
  delete Chart3DFixedFunctionLightingModelArchive_reflection_;
  delete Chart3DPhongLightingModelArchive::default_instance_;
  delete Chart3DPhongLightingModelArchive_reflection_;
  delete Chart3DPhongMaterialPackageArchive::default_instance_;
  delete Chart3DPhongMaterialPackageArchive_reflection_;
  delete Chart3DTSPImageDataTextureArchive::default_instance_;
  delete Chart3DTSPImageDataTextureArchive_reflection_;
  delete Chart3DBaseImageTextureTilingArchive::default_instance_;
  delete Chart3DBaseImageTextureTilingArchive_reflection_;
  delete Chart3DImageTextureTilingArchive::default_instance_;
  delete Chart3DImageTextureTilingArchive_reflection_;
  delete Chart3DVectorArchive::default_instance_;
  delete Chart3DVectorArchive_reflection_;
}

void protobuf_AddDesc_TSCH3DArchives_2eproto() {
  static bool already_here = false;
  if (already_here) return;
  already_here = true;
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::TSP::protobuf_AddDesc_TSPMessages_2eproto();
  ::TSD::protobuf_AddDesc_TSDArchives_2eproto();
  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\024TSCH3DArchives.proto\022\004TSCH\032\021TSPMessage"
    "s.proto\032\021TSDArchives.proto\"^\n Chart3DEnv"
    "ironmentPackageArchive\022:\n\tmaterials\030\001 \003("
    "\0132\'.TSCH.Chart3DEnvironmentMaterialArchi"
    "ve\"\246\001\n\022Chart3DFillArchive\0228\n\rlightingmod"
    "el\030\001 \001(\0132!.TSCH.Chart3DLightingModelArch"
    "ive\022\025\n\rtextureset_id\030\002 \001(\t\022)\n\tfill_type\030"
    "\003 \001(\0162\026.TSCH.FillPropertyType\022\024\n\014series_"
    "index\030\004 \001(\r\"H\n\030Chart3DPointLightArchive\022"
    ",\n\010position\030\001 \002(\0132\032.TSCH.Chart3DVectorAr"
    "chive\"O\n\036Chart3DDirectionalLightArchive\022"
    "-\n\tdirection\030\001 \002(\0132\032.TSCH.Chart3DVectorA"
    "rchive\"\227\001\n\027Chart3DSpotLightArchive\022,\n\010po"
    "sition\030\001 \002(\0132\032.TSCH.Chart3DVectorArchive"
    "\022-\n\tdirection\030\002 \002(\0132\032.TSCH.Chart3DVector"
    "Archive\022\016\n\006cutoff\030\003 \002(\002\022\017\n\007dropoff\030\004 \002(\002"
    "\"\325\003\n\023Chart3DLightArchive\022\014\n\004name\030\001 \002(\t\0221"
    "\n\rambient_color\030\002 \002(\0132\032.TSCH.Chart3DVect"
    "orArchive\0221\n\rdiffuse_color\030\003 \002(\0132\032.TSCH."
    "Chart3DVectorArchive\0222\n\016specular_color\030\004"
    " \002(\0132\032.TSCH.Chart3DVectorArchive\022\021\n\tinte"
    "nsity\030\005 \002(\002\022/\n\013attenuation\030\006 \002(\0132\032.TSCH."
    "Chart3DVectorArchive\022\030\n\020coordinate_space"
    "\030\007 \002(\r\022\017\n\007enabled\030\010 \002(\010\0223\n\013point_light\030\t"
    " \001(\0132\036.TSCH.Chart3DPointLightArchive\022\?\n\021"
    "directional_light\030\n \001(\0132$.TSCH.Chart3DDi"
    "rectionalLightArchive\0221\n\nspot_light\030\013 \001("
    "\0132\035.TSCH.Chart3DSpotLightArchive\"\331\001\n\033Cha"
    "rt3DLightingModelArchive\0225\n\005phong\030\001 \001(\0132"
    "&.TSCH.Chart3DPhongLightingModelArchive\022"
    "F\n\016fixed_function\030\002 \001(\0132..TSCH.Chart3DFi"
    "xedFunctionLightingModelArchive\022;\n\013envir"
    "onment\030\003 \001(\0132&.TSCH.Chart3DEnvironmentPa"
    "ckageArchive\"X\n\035Chart3DLightingPackageAr"
    "chive\022\014\n\004name\030\001 \002(\t\022)\n\006lights\030\002 \003(\0132\031.TS"
    "CH.Chart3DLightArchive\"\206\001\n\036Chart3DTextur"
    "esMaterialArchive\022)\n\005color\030\001 \002(\0132\032.TSCH."
    "Chart3DVectorArchive\0229\n\010textures\030\002 \003(\0132\'"
    ".TSCH.Chart3DTSPImageDataTextureArchive\""
    "\216\001\n\036Chart3DEmissiveMaterialArchive\0223\n\005su"
    "per\030\001 \002(\0132$.TSCH.Chart3DTexturesMaterial"
    "Archive\0227\n\007tilings\030\002 \003(\0132&.TSCH.Chart3DI"
    "mageTextureTilingArchive\"\215\001\n\035Chart3DDiff"
    "useMaterialArchive\0223\n\005super\030\001 \002(\0132$.TSCH"
    ".Chart3DTexturesMaterialArchive\0227\n\007tilin"
    "gs\030\002 \003(\0132&.TSCH.Chart3DImageTextureTilin"
    "gArchive\"\216\001\n\036Chart3DModulateMaterialArch"
    "ive\0223\n\005super\030\001 \002(\0132$.TSCH.Chart3DTexture"
    "sMaterialArchive\0227\n\007tilings\030\002 \003(\0132&.TSCH"
    ".Chart3DImageTextureTilingArchive\"\216\001\n\036Ch"
    "art3DSpecularMaterialArchive\0223\n\005super\030\001 "
    "\002(\0132$.TSCH.Chart3DTexturesMaterialArchiv"
    "e\0227\n\007tilings\030\002 \003(\0132&.TSCH.Chart3DImageTe"
    "xtureTilingArchive\"\217\001\n\037Chart3DShininessM"
    "aterialArchive\0223\n\005super\030\001 \002(\0132$.TSCH.Cha"
    "rt3DTexturesMaterialArchive\0227\n\007tilings\030\002"
    " \003(\0132&.TSCH.Chart3DImageTextureTilingArc"
    "hive\"\352\001\n!Chart3DEnvironmentMaterialArchi"
    "ve\0223\n\005super\030\001 \002(\0132$.TSCH.Chart3DTextures"
    "MaterialArchive\022D\n\020OBSOLETE_tilings\030\002 \003("
    "\0132*.TSCH.Chart3DBaseImageTextureTilingAr"
    "chive\022\021\n\tdecalMode\030\003 \001(\010\0227\n\007tilings\030\004 \003("
    "\0132&.TSCH.Chart3DImageTextureTilingArchiv"
    "e\"g\n(Chart3DFixedFunctionLightingModelAr"
    "chive\022;\n\tmaterials\030\001 \002(\0132(.TSCH.Chart3DP"
    "hongMaterialPackageArchive\"_\n Chart3DPho"
    "ngLightingModelArchive\022;\n\tmaterials\030\001 \002("
    "\0132(.TSCH.Chart3DPhongMaterialPackageArch"
    "ive\"\274\002\n\"Chart3DPhongMaterialPackageArchi"
    "ve\0226\n\010emissive\030\001 \001(\0132$.TSCH.Chart3DEmiss"
    "iveMaterialArchive\0224\n\007diffuse\030\002 \001(\0132#.TS"
    "CH.Chart3DDiffuseMaterialArchive\0226\n\010modu"
    "late\030\003 \001(\0132$.TSCH.Chart3DModulateMateria"
    "lArchive\0226\n\010specular\030\004 \001(\0132$.TSCH.Chart3"
    "DSpecularMaterialArchive\0228\n\tshininess\030\005 "
    "\001(\0132%.TSCH.Chart3DShininessMaterialArchi"
    "ve\"\301\001\n!Chart3DTSPImageDataTextureArchive"
    "\022 \n\004data\030\003 \001(\0132\022.TSP.DataReference\022&\n\nmi"
    "pmapdata\030\004 \001(\0132\022.TSP.DataReference\022%\n\rda"
    "tabase_data\030\001 \001(\0132\016.TSP.Reference\022+\n\023dat"
    "abase_mipmapdata\030\002 \001(\0132\016.TSP.Reference\"c"
    "\n$Chart3DBaseImageTextureTilingArchive\022)"
    "\n\005scale\030\001 \001(\0132\032.TSCH.Chart3DVectorArchiv"
    "e\022\020\n\010rotation\030\002 \001(\002\"\254\003\n Chart3DImageText"
    "ureTilingArchive\0229\n\005super\030\001 \002(\0132*.TSCH.C"
    "hart3DBaseImageTextureTilingArchive\022%\n\004m"
    "ode\030\002 \001(\0162\027.TSCH.TextureTilingMode\022%\n\004wr"
    "ap\030\003 \001(\0162\027.TSCH.TextureTilingWrap\022%\n\004fac"
    "e\030\004 \001(\0162\027.TSCH.TextureTilingFace\022/\n\txpos"
    "ition\030\005 \001(\0162\034.TSCH.TextureTilingXPositio"
    "n\022/\n\typosition\030\006 \001(\0162\034.TSCH.TextureTilin"
    "gYPosition\0222\n\013scontinuity\030\007 \001(\0162\035.TSCH.T"
    "extureTilingContinuity\0222\n\013tcontinuity\030\010 "
    "\001(\0162\035.TSCH.TextureTilingContinuity\022\016\n\006re"
    "veal\030\t \001(\010\"B\n\024Chart3DVectorArchive\022\t\n\001x\030"
    "\001 \002(\002\022\t\n\001y\030\002 \002(\002\022\t\n\001z\030\003 \002(\002\022\t\n\001w\030\004 \002(\002*L"
    "\n\021TextureTilingMode\022\031\n\025textureTilingMode"
    "None\020\000\022\034\n\030textureTilingModeTallest\020\001*k\n\021"
    "TextureTilingFace\022\030\n\024textureTilingFaceAl"
    "l\020\000\022!\n\035textureTilingFaceTopAndBottom\020\001\022\031"
    "\n\025textureTilingFaceSide\020\002*R\n\021TextureTili"
    "ngWrap\022\036\n\032textureTilingWrapProjected\020\000\022\035"
    "\n\031textureTilingWrapFaceWrap\020\001*{\n\026Texture"
    "TilingXPosition\022\036\n\032textureTilingXPositio"
    "nLeft\020\000\022 \n\034textureTilingXPositionCenter\020"
    "\001\022\037\n\033textureTilingXPositionRight\020\002*{\n\026Te"
    "xtureTilingYPosition\022\035\n\031textureTilingYPo"
    "sitionTop\020\000\022 \n\034textureTilingYPositionMid"
    "dle\020\001\022 \n\034textureTilingYPositionBottom\020\002*"
    "\245\001\n\027TextureTilingContinuity\022\037\n\033textureTi"
    "lingContinuityNone\020\000\022!\n\035textureTilingCon"
    "tinuityGlobal\020\001\022!\n\035textureTilingContinui"
    "tySeries\020\002\022#\n\037textureTilingContinuityJit"
    "tered\020\003*\263\001\n\020FillPropertyType\022\035\n\031fillProp"
    "ertyTypeUndefined\020\000\022\030\n\024fillPropertyTypeA"
    "rea\020\001\022\027\n\023fillPropertyTypeBar\020\002\022\032\n\026fillPr"
    "opertyTypeColumn\020\003\022\030\n\024fillPropertyTypeLi"
    "ne\020\004\022\027\n\023fillPropertyTypePie\020\005::\n\006fill3d\022"
    "\020.TSD.FillArchive\030d \001(\0132\030.TSCH.Chart3DFi"
    "llArchive", 4769);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "TSCH3DArchives.proto", &protobuf_RegisterTypes);
  Chart3DEnvironmentPackageArchive::default_instance_ = new Chart3DEnvironmentPackageArchive();
  Chart3DFillArchive::default_instance_ = new Chart3DFillArchive();
  Chart3DPointLightArchive::default_instance_ = new Chart3DPointLightArchive();
  Chart3DDirectionalLightArchive::default_instance_ = new Chart3DDirectionalLightArchive();
  Chart3DSpotLightArchive::default_instance_ = new Chart3DSpotLightArchive();
  Chart3DLightArchive::default_instance_ = new Chart3DLightArchive();
  Chart3DLightingModelArchive::default_instance_ = new Chart3DLightingModelArchive();
  Chart3DLightingPackageArchive::default_instance_ = new Chart3DLightingPackageArchive();
  Chart3DTexturesMaterialArchive::default_instance_ = new Chart3DTexturesMaterialArchive();
  Chart3DEmissiveMaterialArchive::default_instance_ = new Chart3DEmissiveMaterialArchive();
  Chart3DDiffuseMaterialArchive::default_instance_ = new Chart3DDiffuseMaterialArchive();
  Chart3DModulateMaterialArchive::default_instance_ = new Chart3DModulateMaterialArchive();
  Chart3DSpecularMaterialArchive::default_instance_ = new Chart3DSpecularMaterialArchive();
  Chart3DShininessMaterialArchive::default_instance_ = new Chart3DShininessMaterialArchive();
  Chart3DEnvironmentMaterialArchive::default_instance_ = new Chart3DEnvironmentMaterialArchive();
  Chart3DFixedFunctionLightingModelArchive::default_instance_ = new Chart3DFixedFunctionLightingModelArchive();
  Chart3DPhongLightingModelArchive::default_instance_ = new Chart3DPhongLightingModelArchive();
  Chart3DPhongMaterialPackageArchive::default_instance_ = new Chart3DPhongMaterialPackageArchive();
  Chart3DTSPImageDataTextureArchive::default_instance_ = new Chart3DTSPImageDataTextureArchive();
  Chart3DBaseImageTextureTilingArchive::default_instance_ = new Chart3DBaseImageTextureTilingArchive();
  Chart3DImageTextureTilingArchive::default_instance_ = new Chart3DImageTextureTilingArchive();
  Chart3DVectorArchive::default_instance_ = new Chart3DVectorArchive();
  ::google::protobuf::internal::ExtensionSet::RegisterMessageExtension(
    &::TSD::FillArchive::default_instance(),
    100, 11, false, false,
    &::TSCH::Chart3DFillArchive::default_instance());
  Chart3DEnvironmentPackageArchive::default_instance_->InitAsDefaultInstance();
  Chart3DFillArchive::default_instance_->InitAsDefaultInstance();
  Chart3DPointLightArchive::default_instance_->InitAsDefaultInstance();
  Chart3DDirectionalLightArchive::default_instance_->InitAsDefaultInstance();
  Chart3DSpotLightArchive::default_instance_->InitAsDefaultInstance();
  Chart3DLightArchive::default_instance_->InitAsDefaultInstance();
  Chart3DLightingModelArchive::default_instance_->InitAsDefaultInstance();
  Chart3DLightingPackageArchive::default_instance_->InitAsDefaultInstance();
  Chart3DTexturesMaterialArchive::default_instance_->InitAsDefaultInstance();
  Chart3DEmissiveMaterialArchive::default_instance_->InitAsDefaultInstance();
  Chart3DDiffuseMaterialArchive::default_instance_->InitAsDefaultInstance();
  Chart3DModulateMaterialArchive::default_instance_->InitAsDefaultInstance();
  Chart3DSpecularMaterialArchive::default_instance_->InitAsDefaultInstance();
  Chart3DShininessMaterialArchive::default_instance_->InitAsDefaultInstance();
  Chart3DEnvironmentMaterialArchive::default_instance_->InitAsDefaultInstance();
  Chart3DFixedFunctionLightingModelArchive::default_instance_->InitAsDefaultInstance();
  Chart3DPhongLightingModelArchive::default_instance_->InitAsDefaultInstance();
  Chart3DPhongMaterialPackageArchive::default_instance_->InitAsDefaultInstance();
  Chart3DTSPImageDataTextureArchive::default_instance_->InitAsDefaultInstance();
  Chart3DBaseImageTextureTilingArchive::default_instance_->InitAsDefaultInstance();
  Chart3DImageTextureTilingArchive::default_instance_->InitAsDefaultInstance();
  Chart3DVectorArchive::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_TSCH3DArchives_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_TSCH3DArchives_2eproto {
  StaticDescriptorInitializer_TSCH3DArchives_2eproto() {
    protobuf_AddDesc_TSCH3DArchives_2eproto();
  }
} static_descriptor_initializer_TSCH3DArchives_2eproto_;
const ::google::protobuf::EnumDescriptor* TextureTilingMode_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return TextureTilingMode_descriptor_;
}
bool TextureTilingMode_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* TextureTilingFace_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return TextureTilingFace_descriptor_;
}
bool TextureTilingFace_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* TextureTilingWrap_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return TextureTilingWrap_descriptor_;
}
bool TextureTilingWrap_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* TextureTilingXPosition_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return TextureTilingXPosition_descriptor_;
}
bool TextureTilingXPosition_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* TextureTilingYPosition_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return TextureTilingYPosition_descriptor_;
}
bool TextureTilingYPosition_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* TextureTilingContinuity_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return TextureTilingContinuity_descriptor_;
}
bool TextureTilingContinuity_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* FillPropertyType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return FillPropertyType_descriptor_;
}
bool FillPropertyType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return true;
    default:
      return false;
  }
}

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

#ifndef _MSC_VER
const int Chart3DEnvironmentPackageArchive::kMaterialsFieldNumber;
#endif  // !_MSC_VER

Chart3DEnvironmentPackageArchive::Chart3DEnvironmentPackageArchive()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Chart3DEnvironmentPackageArchive::InitAsDefaultInstance() {
}

Chart3DEnvironmentPackageArchive::Chart3DEnvironmentPackageArchive(const Chart3DEnvironmentPackageArchive& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Chart3DEnvironmentPackageArchive::SharedCtor() {
  _cached_size_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Chart3DEnvironmentPackageArchive::~Chart3DEnvironmentPackageArchive() {
  SharedDtor();
}

void Chart3DEnvironmentPackageArchive::SharedDtor() {
  if (this != default_instance_) {
  }
}

void Chart3DEnvironmentPackageArchive::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Chart3DEnvironmentPackageArchive::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Chart3DEnvironmentPackageArchive_descriptor_;
}

const Chart3DEnvironmentPackageArchive& Chart3DEnvironmentPackageArchive::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_TSCH3DArchives_2eproto();
  return *default_instance_;
}

Chart3DEnvironmentPackageArchive* Chart3DEnvironmentPackageArchive::default_instance_ = NULL;

Chart3DEnvironmentPackageArchive* Chart3DEnvironmentPackageArchive::New() const {
  return new Chart3DEnvironmentPackageArchive;
}

void Chart3DEnvironmentPackageArchive::Clear() {
  materials_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Chart3DEnvironmentPackageArchive::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .TSCH.Chart3DEnvironmentMaterialArchive materials = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_materials:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_materials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(10)) goto parse_materials;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Chart3DEnvironmentPackageArchive::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // repeated .TSCH.Chart3DEnvironmentMaterialArchive materials = 1;
  for (int i = 0; i < this->materials_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->materials(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Chart3DEnvironmentPackageArchive::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // repeated .TSCH.Chart3DEnvironmentMaterialArchive materials = 1;
  for (int i = 0; i < this->materials_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->materials(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Chart3DEnvironmentPackageArchive::ByteSize() const {
  int total_size = 0;

  // repeated .TSCH.Chart3DEnvironmentMaterialArchive materials = 1;
  total_size += 1 * this->materials_size();
  for (int i = 0; i < this->materials_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->materials(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Chart3DEnvironmentPackageArchive::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Chart3DEnvironmentPackageArchive* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Chart3DEnvironmentPackageArchive*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Chart3DEnvironmentPackageArchive::MergeFrom(const Chart3DEnvironmentPackageArchive& from) {
  GOOGLE_CHECK_NE(&from, this);
  materials_.MergeFrom(from.materials_);
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Chart3DEnvironmentPackageArchive::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Chart3DEnvironmentPackageArchive::CopyFrom(const Chart3DEnvironmentPackageArchive& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Chart3DEnvironmentPackageArchive::IsInitialized() const {

  for (int i = 0; i < materials_size(); i++) {
    if (!this->materials(i).IsInitialized()) return false;
  }
  return true;
}

void Chart3DEnvironmentPackageArchive::Swap(Chart3DEnvironmentPackageArchive* other) {
  if (other != this) {
    materials_.Swap(&other->materials_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Chart3DEnvironmentPackageArchive::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Chart3DEnvironmentPackageArchive_descriptor_;
  metadata.reflection = Chart3DEnvironmentPackageArchive_reflection_;
  return metadata;
}

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

#ifndef _MSC_VER
const int Chart3DFillArchive::kLightingmodelFieldNumber;
const int Chart3DFillArchive::kTexturesetIdFieldNumber;
const int Chart3DFillArchive::kFillTypeFieldNumber;
const int Chart3DFillArchive::kSeriesIndexFieldNumber;
#endif  // !_MSC_VER

Chart3DFillArchive::Chart3DFillArchive()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Chart3DFillArchive::InitAsDefaultInstance() {
  lightingmodel_ = const_cast< ::TSCH::Chart3DLightingModelArchive*>(&::TSCH::Chart3DLightingModelArchive::default_instance());
}

Chart3DFillArchive::Chart3DFillArchive(const Chart3DFillArchive& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Chart3DFillArchive::SharedCtor() {
  _cached_size_ = 0;
  lightingmodel_ = NULL;
  textureset_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  fill_type_ = 0;
  series_index_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Chart3DFillArchive::~Chart3DFillArchive() {
  SharedDtor();
}

void Chart3DFillArchive::SharedDtor() {
  if (textureset_id_ != &::google::protobuf::internal::kEmptyString) {
    delete textureset_id_;
  }
  if (this != default_instance_) {
    delete lightingmodel_;
  }
}

void Chart3DFillArchive::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Chart3DFillArchive::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Chart3DFillArchive_descriptor_;
}

const Chart3DFillArchive& Chart3DFillArchive::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_TSCH3DArchives_2eproto();
  return *default_instance_;
}

Chart3DFillArchive* Chart3DFillArchive::default_instance_ = NULL;

Chart3DFillArchive* Chart3DFillArchive::New() const {
  return new Chart3DFillArchive;
}

void Chart3DFillArchive::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_lightingmodel()) {
      if (lightingmodel_ != NULL) lightingmodel_->::TSCH::Chart3DLightingModelArchive::Clear();
    }
    if (has_textureset_id()) {
      if (textureset_id_ != &::google::protobuf::internal::kEmptyString) {
        textureset_id_->clear();
      }
    }
    fill_type_ = 0;
    series_index_ = 0u;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Chart3DFillArchive::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .TSCH.Chart3DLightingModelArchive lightingmodel = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_lightingmodel()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_textureset_id;
        break;
      }

      // optional string textureset_id = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_textureset_id:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_textureset_id()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->textureset_id().data(), this->textureset_id().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_fill_type;
        break;
      }

      // optional .TSCH.FillPropertyType fill_type = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_fill_type:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::TSCH::FillPropertyType_IsValid(value)) {
            set_fill_type(static_cast< ::TSCH::FillPropertyType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(3, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_series_index;
        break;
      }

      // optional uint32 series_index = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_series_index:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &series_index_)));
          set_has_series_index();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Chart3DFillArchive::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .TSCH.Chart3DLightingModelArchive lightingmodel = 1;
  if (has_lightingmodel()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->lightingmodel(), output);
  }

  // optional string textureset_id = 2;
  if (has_textureset_id()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->textureset_id().data(), this->textureset_id().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->textureset_id(), output);
  }

  // optional .TSCH.FillPropertyType fill_type = 3;
  if (has_fill_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->fill_type(), output);
  }

  // optional uint32 series_index = 4;
  if (has_series_index()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->series_index(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Chart3DFillArchive::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .TSCH.Chart3DLightingModelArchive lightingmodel = 1;
  if (has_lightingmodel()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->lightingmodel(), target);
  }

  // optional string textureset_id = 2;
  if (has_textureset_id()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->textureset_id().data(), this->textureset_id().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->textureset_id(), target);
  }

  // optional .TSCH.FillPropertyType fill_type = 3;
  if (has_fill_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      3, this->fill_type(), target);
  }

  // optional uint32 series_index = 4;
  if (has_series_index()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->series_index(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Chart3DFillArchive::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .TSCH.Chart3DLightingModelArchive lightingmodel = 1;
    if (has_lightingmodel()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->lightingmodel());
    }

    // optional string textureset_id = 2;
    if (has_textureset_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->textureset_id());
    }

    // optional .TSCH.FillPropertyType fill_type = 3;
    if (has_fill_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->fill_type());
    }

    // optional uint32 series_index = 4;
    if (has_series_index()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->series_index());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Chart3DFillArchive::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Chart3DFillArchive* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Chart3DFillArchive*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Chart3DFillArchive::MergeFrom(const Chart3DFillArchive& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_lightingmodel()) {
      mutable_lightingmodel()->::TSCH::Chart3DLightingModelArchive::MergeFrom(from.lightingmodel());
    }
    if (from.has_textureset_id()) {
      set_textureset_id(from.textureset_id());
    }
    if (from.has_fill_type()) {
      set_fill_type(from.fill_type());
    }
    if (from.has_series_index()) {
      set_series_index(from.series_index());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Chart3DFillArchive::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Chart3DFillArchive::CopyFrom(const Chart3DFillArchive& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Chart3DFillArchive::IsInitialized() const {

  if (has_lightingmodel()) {
    if (!this->lightingmodel().IsInitialized()) return false;
  }
  return true;
}

void Chart3DFillArchive::Swap(Chart3DFillArchive* other) {
  if (other != this) {
    std::swap(lightingmodel_, other->lightingmodel_);
    std::swap(textureset_id_, other->textureset_id_);
    std::swap(fill_type_, other->fill_type_);
    std::swap(series_index_, other->series_index_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Chart3DFillArchive::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Chart3DFillArchive_descriptor_;
  metadata.reflection = Chart3DFillArchive_reflection_;
  return metadata;
}

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

#ifndef _MSC_VER
const int Chart3DPointLightArchive::kPositionFieldNumber;
#endif  // !_MSC_VER

Chart3DPointLightArchive::Chart3DPointLightArchive()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Chart3DPointLightArchive::InitAsDefaultInstance() {
  position_ = const_cast< ::TSCH::Chart3DVectorArchive*>(&::TSCH::Chart3DVectorArchive::default_instance());
}

Chart3DPointLightArchive::Chart3DPointLightArchive(const Chart3DPointLightArchive& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Chart3DPointLightArchive::SharedCtor() {
  _cached_size_ = 0;
  position_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Chart3DPointLightArchive::~Chart3DPointLightArchive() {
  SharedDtor();
}

void Chart3DPointLightArchive::SharedDtor() {
  if (this != default_instance_) {
    delete position_;
  }
}

void Chart3DPointLightArchive::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Chart3DPointLightArchive::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Chart3DPointLightArchive_descriptor_;
}

const Chart3DPointLightArchive& Chart3DPointLightArchive::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_TSCH3DArchives_2eproto();
  return *default_instance_;
}

Chart3DPointLightArchive* Chart3DPointLightArchive::default_instance_ = NULL;

Chart3DPointLightArchive* Chart3DPointLightArchive::New() const {
  return new Chart3DPointLightArchive;
}

void Chart3DPointLightArchive::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_position()) {
      if (position_ != NULL) position_->::TSCH::Chart3DVectorArchive::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Chart3DPointLightArchive::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .TSCH.Chart3DVectorArchive position = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_position()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Chart3DPointLightArchive::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .TSCH.Chart3DVectorArchive position = 1;
  if (has_position()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->position(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Chart3DPointLightArchive::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .TSCH.Chart3DVectorArchive position = 1;
  if (has_position()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->position(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Chart3DPointLightArchive::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .TSCH.Chart3DVectorArchive position = 1;
    if (has_position()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->position());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Chart3DPointLightArchive::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Chart3DPointLightArchive* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Chart3DPointLightArchive*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Chart3DPointLightArchive::MergeFrom(const Chart3DPointLightArchive& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_position()) {
      mutable_position()->::TSCH::Chart3DVectorArchive::MergeFrom(from.position());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Chart3DPointLightArchive::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Chart3DPointLightArchive::CopyFrom(const Chart3DPointLightArchive& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Chart3DPointLightArchive::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (has_position()) {
    if (!this->position().IsInitialized()) return false;
  }
  return true;
}

void Chart3DPointLightArchive::Swap(Chart3DPointLightArchive* other) {
  if (other != this) {
    std::swap(position_, other->position_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Chart3DPointLightArchive::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Chart3DPointLightArchive_descriptor_;
  metadata.reflection = Chart3DPointLightArchive_reflection_;
  return metadata;
}

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

#ifndef _MSC_VER
const int Chart3DDirectionalLightArchive::kDirectionFieldNumber;
#endif  // !_MSC_VER

Chart3DDirectionalLightArchive::Chart3DDirectionalLightArchive()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Chart3DDirectionalLightArchive::InitAsDefaultInstance() {
  direction_ = const_cast< ::TSCH::Chart3DVectorArchive*>(&::TSCH::Chart3DVectorArchive::default_instance());
}

Chart3DDirectionalLightArchive::Chart3DDirectionalLightArchive(const Chart3DDirectionalLightArchive& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Chart3DDirectionalLightArchive::SharedCtor() {
  _cached_size_ = 0;
  direction_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Chart3DDirectionalLightArchive::~Chart3DDirectionalLightArchive() {
  SharedDtor();
}

void Chart3DDirectionalLightArchive::SharedDtor() {
  if (this != default_instance_) {
    delete direction_;
  }
}

void Chart3DDirectionalLightArchive::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Chart3DDirectionalLightArchive::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Chart3DDirectionalLightArchive_descriptor_;
}

const Chart3DDirectionalLightArchive& Chart3DDirectionalLightArchive::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_TSCH3DArchives_2eproto();
  return *default_instance_;
}

Chart3DDirectionalLightArchive* Chart3DDirectionalLightArchive::default_instance_ = NULL;

Chart3DDirectionalLightArchive* Chart3DDirectionalLightArchive::New() const {
  return new Chart3DDirectionalLightArchive;
}

void Chart3DDirectionalLightArchive::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_direction()) {
      if (direction_ != NULL) direction_->::TSCH::Chart3DVectorArchive::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Chart3DDirectionalLightArchive::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .TSCH.Chart3DVectorArchive direction = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_direction()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Chart3DDirectionalLightArchive::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .TSCH.Chart3DVectorArchive direction = 1;
  if (has_direction()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->direction(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Chart3DDirectionalLightArchive::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .TSCH.Chart3DVectorArchive direction = 1;
  if (has_direction()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->direction(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Chart3DDirectionalLightArchive::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .TSCH.Chart3DVectorArchive direction = 1;
    if (has_direction()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->direction());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Chart3DDirectionalLightArchive::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Chart3DDirectionalLightArchive* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Chart3DDirectionalLightArchive*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Chart3DDirectionalLightArchive::MergeFrom(const Chart3DDirectionalLightArchive& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_direction()) {
      mutable_direction()->::TSCH::Chart3DVectorArchive::MergeFrom(from.direction());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Chart3DDirectionalLightArchive::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Chart3DDirectionalLightArchive::CopyFrom(const Chart3DDirectionalLightArchive& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Chart3DDirectionalLightArchive::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (has_direction()) {
    if (!this->direction().IsInitialized()) return false;
  }
  return true;
}

void Chart3DDirectionalLightArchive::Swap(Chart3DDirectionalLightArchive* other) {
  if (other != this) {
    std::swap(direction_, other->direction_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Chart3DDirectionalLightArchive::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Chart3DDirectionalLightArchive_descriptor_;
  metadata.reflection = Chart3DDirectionalLightArchive_reflection_;
  return metadata;
}

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

#ifndef _MSC_VER
const int Chart3DSpotLightArchive::kPositionFieldNumber;
const int Chart3DSpotLightArchive::kDirectionFieldNumber;
const int Chart3DSpotLightArchive::kCutoffFieldNumber;
const int Chart3DSpotLightArchive::kDropoffFieldNumber;
#endif  // !_MSC_VER

Chart3DSpotLightArchive::Chart3DSpotLightArchive()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Chart3DSpotLightArchive::InitAsDefaultInstance() {
  position_ = const_cast< ::TSCH::Chart3DVectorArchive*>(&::TSCH::Chart3DVectorArchive::default_instance());
  direction_ = const_cast< ::TSCH::Chart3DVectorArchive*>(&::TSCH::Chart3DVectorArchive::default_instance());
}

Chart3DSpotLightArchive::Chart3DSpotLightArchive(const Chart3DSpotLightArchive& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Chart3DSpotLightArchive::SharedCtor() {
  _cached_size_ = 0;
  position_ = NULL;
  direction_ = NULL;
  cutoff_ = 0;
  dropoff_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Chart3DSpotLightArchive::~Chart3DSpotLightArchive() {
  SharedDtor();
}

void Chart3DSpotLightArchive::SharedDtor() {
  if (this != default_instance_) {
    delete position_;
    delete direction_;
  }
}

void Chart3DSpotLightArchive::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Chart3DSpotLightArchive::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Chart3DSpotLightArchive_descriptor_;
}

const Chart3DSpotLightArchive& Chart3DSpotLightArchive::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_TSCH3DArchives_2eproto();
  return *default_instance_;
}

Chart3DSpotLightArchive* Chart3DSpotLightArchive::default_instance_ = NULL;

Chart3DSpotLightArchive* Chart3DSpotLightArchive::New() const {
  return new Chart3DSpotLightArchive;
}

void Chart3DSpotLightArchive::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_position()) {
      if (position_ != NULL) position_->::TSCH::Chart3DVectorArchive::Clear();
    }
    if (has_direction()) {
      if (direction_ != NULL) direction_->::TSCH::Chart3DVectorArchive::Clear();
    }
    cutoff_ = 0;
    dropoff_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Chart3DSpotLightArchive::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .TSCH.Chart3DVectorArchive position = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_position()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_direction;
        break;
      }

      // required .TSCH.Chart3DVectorArchive direction = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_direction:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_direction()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(29)) goto parse_cutoff;
        break;
      }

      // required float cutoff = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_cutoff:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &cutoff_)));
          set_has_cutoff();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(37)) goto parse_dropoff;
        break;
      }

      // required float dropoff = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_dropoff:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &dropoff_)));
          set_has_dropoff();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Chart3DSpotLightArchive::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .TSCH.Chart3DVectorArchive position = 1;
  if (has_position()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->position(), output);
  }

  // required .TSCH.Chart3DVectorArchive direction = 2;
  if (has_direction()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->direction(), output);
  }

  // required float cutoff = 3;
  if (has_cutoff()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->cutoff(), output);
  }

  // required float dropoff = 4;
  if (has_dropoff()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->dropoff(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Chart3DSpotLightArchive::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .TSCH.Chart3DVectorArchive position = 1;
  if (has_position()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->position(), target);
  }

  // required .TSCH.Chart3DVectorArchive direction = 2;
  if (has_direction()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->direction(), target);
  }

  // required float cutoff = 3;
  if (has_cutoff()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->cutoff(), target);
  }

  // required float dropoff = 4;
  if (has_dropoff()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->dropoff(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Chart3DSpotLightArchive::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .TSCH.Chart3DVectorArchive position = 1;
    if (has_position()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->position());
    }

    // required .TSCH.Chart3DVectorArchive direction = 2;
    if (has_direction()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->direction());
    }

    // required float cutoff = 3;
    if (has_cutoff()) {
      total_size += 1 + 4;
    }

    // required float dropoff = 4;
    if (has_dropoff()) {
      total_size += 1 + 4;
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Chart3DSpotLightArchive::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Chart3DSpotLightArchive* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Chart3DSpotLightArchive*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Chart3DSpotLightArchive::MergeFrom(const Chart3DSpotLightArchive& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_position()) {
      mutable_position()->::TSCH::Chart3DVectorArchive::MergeFrom(from.position());
    }
    if (from.has_direction()) {
      mutable_direction()->::TSCH::Chart3DVectorArchive::MergeFrom(from.direction());
    }
    if (from.has_cutoff()) {
      set_cutoff(from.cutoff());
    }
    if (from.has_dropoff()) {
      set_dropoff(from.dropoff());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Chart3DSpotLightArchive::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Chart3DSpotLightArchive::CopyFrom(const Chart3DSpotLightArchive& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Chart3DSpotLightArchive::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;

  if (has_position()) {
    if (!this->position().IsInitialized()) return false;
  }
  if (has_direction()) {
    if (!this->direction().IsInitialized()) return false;
  }
  return true;
}

void Chart3DSpotLightArchive::Swap(Chart3DSpotLightArchive* other) {
  if (other != this) {
    std::swap(position_, other->position_);
    std::swap(direction_, other->direction_);
    std::swap(cutoff_, other->cutoff_);
    std::swap(dropoff_, other->dropoff_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Chart3DSpotLightArchive::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Chart3DSpotLightArchive_descriptor_;
  metadata.reflection = Chart3DSpotLightArchive_reflection_;
  return metadata;
}

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

#ifndef _MSC_VER
const int Chart3DLightArchive::kNameFieldNumber;
const int Chart3DLightArchive::kAmbientColorFieldNumber;
const int Chart3DLightArchive::kDiffuseColorFieldNumber;
const int Chart3DLightArchive::kSpecularColorFieldNumber;
const int Chart3DLightArchive::kIntensityFieldNumber;
const int Chart3DLightArchive::kAttenuationFieldNumber;
const int Chart3DLightArchive::kCoordinateSpaceFieldNumber;
const int Chart3DLightArchive::kEnabledFieldNumber;
const int Chart3DLightArchive::kPointLightFieldNumber;
const int Chart3DLightArchive::kDirectionalLightFieldNumber;
const int Chart3DLightArchive::kSpotLightFieldNumber;
#endif  // !_MSC_VER

Chart3DLightArchive::Chart3DLightArchive()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Chart3DLightArchive::InitAsDefaultInstance() {
  ambient_color_ = const_cast< ::TSCH::Chart3DVectorArchive*>(&::TSCH::Chart3DVectorArchive::default_instance());
  diffuse_color_ = const_cast< ::TSCH::Chart3DVectorArchive*>(&::TSCH::Chart3DVectorArchive::default_instance());
  specular_color_ = const_cast< ::TSCH::Chart3DVectorArchive*>(&::TSCH::Chart3DVectorArchive::default_instance());
  attenuation_ = const_cast< ::TSCH::Chart3DVectorArchive*>(&::TSCH::Chart3DVectorArchive::default_instance());
  point_light_ = const_cast< ::TSCH::Chart3DPointLightArchive*>(&::TSCH::Chart3DPointLightArchive::default_instance());
  directional_light_ = const_cast< ::TSCH::Chart3DDirectionalLightArchive*>(&::TSCH::Chart3DDirectionalLightArchive::default_instance());
  spot_light_ = const_cast< ::TSCH::Chart3DSpotLightArchive*>(&::TSCH::Chart3DSpotLightArchive::default_instance());
}

Chart3DLightArchive::Chart3DLightArchive(const Chart3DLightArchive& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Chart3DLightArchive::SharedCtor() {
  _cached_size_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ambient_color_ = NULL;
  diffuse_color_ = NULL;
  specular_color_ = NULL;
  intensity_ = 0;
  attenuation_ = NULL;
  coordinate_space_ = 0u;
  enabled_ = false;
  point_light_ = NULL;
  directional_light_ = NULL;
  spot_light_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Chart3DLightArchive::~Chart3DLightArchive() {
  SharedDtor();
}

void Chart3DLightArchive::SharedDtor() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    delete name_;
  }
  if (this != default_instance_) {
    delete ambient_color_;
    delete diffuse_color_;
    delete specular_color_;
    delete attenuation_;
    delete point_light_;
    delete directional_light_;
    delete spot_light_;
  }
}

void Chart3DLightArchive::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Chart3DLightArchive::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Chart3DLightArchive_descriptor_;
}

const Chart3DLightArchive& Chart3DLightArchive::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_TSCH3DArchives_2eproto();
  return *default_instance_;
}

Chart3DLightArchive* Chart3DLightArchive::default_instance_ = NULL;

Chart3DLightArchive* Chart3DLightArchive::New() const {
  return new Chart3DLightArchive;
}

void Chart3DLightArchive::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::kEmptyString) {
        name_->clear();
      }
    }
    if (has_ambient_color()) {
      if (ambient_color_ != NULL) ambient_color_->::TSCH::Chart3DVectorArchive::Clear();
    }
    if (has_diffuse_color()) {
      if (diffuse_color_ != NULL) diffuse_color_->::TSCH::Chart3DVectorArchive::Clear();
    }
    if (has_specular_color()) {
      if (specular_color_ != NULL) specular_color_->::TSCH::Chart3DVectorArchive::Clear();
    }
    intensity_ = 0;
    if (has_attenuation()) {
      if (attenuation_ != NULL) attenuation_->::TSCH::Chart3DVectorArchive::Clear();
    }
    coordinate_space_ = 0u;
    enabled_ = false;
  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (has_point_light()) {
      if (point_light_ != NULL) point_light_->::TSCH::Chart3DPointLightArchive::Clear();
    }
    if (has_directional_light()) {
      if (directional_light_ != NULL) directional_light_->::TSCH::Chart3DDirectionalLightArchive::Clear();
    }
    if (has_spot_light()) {
      if (spot_light_ != NULL) spot_light_->::TSCH::Chart3DSpotLightArchive::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Chart3DLightArchive::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string name = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_ambient_color;
        break;
      }

      // required .TSCH.Chart3DVectorArchive ambient_color = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_ambient_color:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_ambient_color()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_diffuse_color;
        break;
      }

      // required .TSCH.Chart3DVectorArchive diffuse_color = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_diffuse_color:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_diffuse_color()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_specular_color;
        break;
      }

      // required .TSCH.Chart3DVectorArchive specular_color = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_specular_color:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_specular_color()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(45)) goto parse_intensity;
        break;
      }

      // required float intensity = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_intensity:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &intensity_)));
          set_has_intensity();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(50)) goto parse_attenuation;
        break;
      }

      // required .TSCH.Chart3DVectorArchive attenuation = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_attenuation:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_attenuation()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(56)) goto parse_coordinate_space;
        break;
      }

      // required uint32 coordinate_space = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_coordinate_space:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &coordinate_space_)));
          set_has_coordinate_space();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(64)) goto parse_enabled;
        break;
      }

      // required bool enabled = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_enabled:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &enabled_)));
          set_has_enabled();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(74)) goto parse_point_light;
        break;
      }

      // optional .TSCH.Chart3DPointLightArchive point_light = 9;
      case 9: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_point_light:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_point_light()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(82)) goto parse_directional_light;
        break;
      }

      // optional .TSCH.Chart3DDirectionalLightArchive directional_light = 10;
      case 10: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_directional_light:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_directional_light()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(90)) goto parse_spot_light;
        break;
      }

      // optional .TSCH.Chart3DSpotLightArchive spot_light = 11;
      case 11: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_spot_light:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_spot_light()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Chart3DLightArchive::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->name(), output);
  }

  // required .TSCH.Chart3DVectorArchive ambient_color = 2;
  if (has_ambient_color()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->ambient_color(), output);
  }

  // required .TSCH.Chart3DVectorArchive diffuse_color = 3;
  if (has_diffuse_color()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->diffuse_color(), output);
  }

  // required .TSCH.Chart3DVectorArchive specular_color = 4;
  if (has_specular_color()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->specular_color(), output);
  }

  // required float intensity = 5;
  if (has_intensity()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->intensity(), output);
  }

  // required .TSCH.Chart3DVectorArchive attenuation = 6;
  if (has_attenuation()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      6, this->attenuation(), output);
  }

  // required uint32 coordinate_space = 7;
  if (has_coordinate_space()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->coordinate_space(), output);
  }

  // required bool enabled = 8;
  if (has_enabled()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(8, this->enabled(), output);
  }

  // optional .TSCH.Chart3DPointLightArchive point_light = 9;
  if (has_point_light()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      9, this->point_light(), output);
  }

  // optional .TSCH.Chart3DDirectionalLightArchive directional_light = 10;
  if (has_directional_light()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      10, this->directional_light(), output);
  }

  // optional .TSCH.Chart3DSpotLightArchive spot_light = 11;
  if (has_spot_light()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      11, this->spot_light(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Chart3DLightArchive::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->name(), target);
  }

  // required .TSCH.Chart3DVectorArchive ambient_color = 2;
  if (has_ambient_color()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->ambient_color(), target);
  }

  // required .TSCH.Chart3DVectorArchive diffuse_color = 3;
  if (has_diffuse_color()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->diffuse_color(), target);
  }

  // required .TSCH.Chart3DVectorArchive specular_color = 4;
  if (has_specular_color()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->specular_color(), target);
  }

  // required float intensity = 5;
  if (has_intensity()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->intensity(), target);
  }

  // required .TSCH.Chart3DVectorArchive attenuation = 6;
  if (has_attenuation()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        6, this->attenuation(), target);
  }

  // required uint32 coordinate_space = 7;
  if (has_coordinate_space()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->coordinate_space(), target);
  }

  // required bool enabled = 8;
  if (has_enabled()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(8, this->enabled(), target);
  }

  // optional .TSCH.Chart3DPointLightArchive point_light = 9;
  if (has_point_light()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        9, this->point_light(), target);
  }

  // optional .TSCH.Chart3DDirectionalLightArchive directional_light = 10;
  if (has_directional_light()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        10, this->directional_light(), target);
  }

  // optional .TSCH.Chart3DSpotLightArchive spot_light = 11;
  if (has_spot_light()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        11, this->spot_light(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Chart3DLightArchive::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string name = 1;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

    // required .TSCH.Chart3DVectorArchive ambient_color = 2;
    if (has_ambient_color()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->ambient_color());
    }

    // required .TSCH.Chart3DVectorArchive diffuse_color = 3;
    if (has_diffuse_color()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->diffuse_color());
    }

    // required .TSCH.Chart3DVectorArchive specular_color = 4;
    if (has_specular_color()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->specular_color());
    }

    // required float intensity = 5;
    if (has_intensity()) {
      total_size += 1 + 4;
    }

    // required .TSCH.Chart3DVectorArchive attenuation = 6;
    if (has_attenuation()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->attenuation());
    }

    // required uint32 coordinate_space = 7;
    if (has_coordinate_space()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->coordinate_space());
    }

    // required bool enabled = 8;
    if (has_enabled()) {
      total_size += 1 + 1;
    }

  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    // optional .TSCH.Chart3DPointLightArchive point_light = 9;
    if (has_point_light()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->point_light());
    }

    // optional .TSCH.Chart3DDirectionalLightArchive directional_light = 10;
    if (has_directional_light()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->directional_light());
    }

    // optional .TSCH.Chart3DSpotLightArchive spot_light = 11;
    if (has_spot_light()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->spot_light());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Chart3DLightArchive::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Chart3DLightArchive* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Chart3DLightArchive*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Chart3DLightArchive::MergeFrom(const Chart3DLightArchive& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_name()) {
      set_name(from.name());
    }
    if (from.has_ambient_color()) {
      mutable_ambient_color()->::TSCH::Chart3DVectorArchive::MergeFrom(from.ambient_color());
    }
    if (from.has_diffuse_color()) {
      mutable_diffuse_color()->::TSCH::Chart3DVectorArchive::MergeFrom(from.diffuse_color());
    }
    if (from.has_specular_color()) {
      mutable_specular_color()->::TSCH::Chart3DVectorArchive::MergeFrom(from.specular_color());
    }
    if (from.has_intensity()) {
      set_intensity(from.intensity());
    }
    if (from.has_attenuation()) {
      mutable_attenuation()->::TSCH::Chart3DVectorArchive::MergeFrom(from.attenuation());
    }
    if (from.has_coordinate_space()) {
      set_coordinate_space(from.coordinate_space());
    }
    if (from.has_enabled()) {
      set_enabled(from.enabled());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_point_light()) {
      mutable_point_light()->::TSCH::Chart3DPointLightArchive::MergeFrom(from.point_light());
    }
    if (from.has_directional_light()) {
      mutable_directional_light()->::TSCH::Chart3DDirectionalLightArchive::MergeFrom(from.directional_light());
    }
    if (from.has_spot_light()) {
      mutable_spot_light()->::TSCH::Chart3DSpotLightArchive::MergeFrom(from.spot_light());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Chart3DLightArchive::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Chart3DLightArchive::CopyFrom(const Chart3DLightArchive& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Chart3DLightArchive::IsInitialized() const {
  if ((_has_bits_[0] & 0x000000ff) != 0x000000ff) return false;

  if (has_ambient_color()) {
    if (!this->ambient_color().IsInitialized()) return false;
  }
  if (has_diffuse_color()) {
    if (!this->diffuse_color().IsInitialized()) return false;
  }
  if (has_specular_color()) {
    if (!this->specular_color().IsInitialized()) return false;
  }
  if (has_attenuation()) {
    if (!this->attenuation().IsInitialized()) return false;
  }
  if (has_point_light()) {
    if (!this->point_light().IsInitialized()) return false;
  }
  if (has_directional_light()) {
    if (!this->directional_light().IsInitialized()) return false;
  }
  if (has_spot_light()) {
    if (!this->spot_light().IsInitialized()) return false;
  }
  return true;
}

void Chart3DLightArchive::Swap(Chart3DLightArchive* other) {
  if (other != this) {
    std::swap(name_, other->name_);
    std::swap(ambient_color_, other->ambient_color_);
    std::swap(diffuse_color_, other->diffuse_color_);
    std::swap(specular_color_, other->specular_color_);
    std::swap(intensity_, other->intensity_);
    std::swap(attenuation_, other->attenuation_);
    std::swap(coordinate_space_, other->coordinate_space_);
    std::swap(enabled_, other->enabled_);
    std::swap(point_light_, other->point_light_);
    std::swap(directional_light_, other->directional_light_);
    std::swap(spot_light_, other->spot_light_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Chart3DLightArchive::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Chart3DLightArchive_descriptor_;
  metadata.reflection = Chart3DLightArchive_reflection_;
  return metadata;
}

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

#ifndef _MSC_VER
const int Chart3DLightingModelArchive::kPhongFieldNumber;
const int Chart3DLightingModelArchive::kFixedFunctionFieldNumber;
const int Chart3DLightingModelArchive::kEnvironmentFieldNumber;
#endif  // !_MSC_VER

Chart3DLightingModelArchive::Chart3DLightingModelArchive()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Chart3DLightingModelArchive::InitAsDefaultInstance() {
  phong_ = const_cast< ::TSCH::Chart3DPhongLightingModelArchive*>(&::TSCH::Chart3DPhongLightingModelArchive::default_instance());
  fixed_function_ = const_cast< ::TSCH::Chart3DFixedFunctionLightingModelArchive*>(&::TSCH::Chart3DFixedFunctionLightingModelArchive::default_instance());
  environment_ = const_cast< ::TSCH::Chart3DEnvironmentPackageArchive*>(&::TSCH::Chart3DEnvironmentPackageArchive::default_instance());
}

Chart3DLightingModelArchive::Chart3DLightingModelArchive(const Chart3DLightingModelArchive& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Chart3DLightingModelArchive::SharedCtor() {
  _cached_size_ = 0;
  phong_ = NULL;
  fixed_function_ = NULL;
  environment_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Chart3DLightingModelArchive::~Chart3DLightingModelArchive() {
  SharedDtor();
}

void Chart3DLightingModelArchive::SharedDtor() {
  if (this != default_instance_) {
    delete phong_;
    delete fixed_function_;
    delete environment_;
  }
}

void Chart3DLightingModelArchive::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Chart3DLightingModelArchive::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Chart3DLightingModelArchive_descriptor_;
}

const Chart3DLightingModelArchive& Chart3DLightingModelArchive::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_TSCH3DArchives_2eproto();
  return *default_instance_;
}

Chart3DLightingModelArchive* Chart3DLightingModelArchive::default_instance_ = NULL;

Chart3DLightingModelArchive* Chart3DLightingModelArchive::New() const {
  return new Chart3DLightingModelArchive;
}

void Chart3DLightingModelArchive::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_phong()) {
      if (phong_ != NULL) phong_->::TSCH::Chart3DPhongLightingModelArchive::Clear();
    }
    if (has_fixed_function()) {
      if (fixed_function_ != NULL) fixed_function_->::TSCH::Chart3DFixedFunctionLightingModelArchive::Clear();
    }
    if (has_environment()) {
      if (environment_ != NULL) environment_->::TSCH::Chart3DEnvironmentPackageArchive::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Chart3DLightingModelArchive::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .TSCH.Chart3DPhongLightingModelArchive phong = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_phong()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_fixed_function;
        break;
      }

      // optional .TSCH.Chart3DFixedFunctionLightingModelArchive fixed_function = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_fixed_function:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_fixed_function()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_environment;
        break;
      }

      // optional .TSCH.Chart3DEnvironmentPackageArchive environment = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_environment:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_environment()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Chart3DLightingModelArchive::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .TSCH.Chart3DPhongLightingModelArchive phong = 1;
  if (has_phong()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->phong(), output);
  }

  // optional .TSCH.Chart3DFixedFunctionLightingModelArchive fixed_function = 2;
  if (has_fixed_function()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->fixed_function(), output);
  }

  // optional .TSCH.Chart3DEnvironmentPackageArchive environment = 3;
  if (has_environment()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->environment(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Chart3DLightingModelArchive::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .TSCH.Chart3DPhongLightingModelArchive phong = 1;
  if (has_phong()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->phong(), target);
  }

  // optional .TSCH.Chart3DFixedFunctionLightingModelArchive fixed_function = 2;
  if (has_fixed_function()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->fixed_function(), target);
  }

  // optional .TSCH.Chart3DEnvironmentPackageArchive environment = 3;
  if (has_environment()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->environment(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Chart3DLightingModelArchive::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .TSCH.Chart3DPhongLightingModelArchive phong = 1;
    if (has_phong()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->phong());
    }

    // optional .TSCH.Chart3DFixedFunctionLightingModelArchive fixed_function = 2;
    if (has_fixed_function()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->fixed_function());
    }

    // optional .TSCH.Chart3DEnvironmentPackageArchive environment = 3;
    if (has_environment()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->environment());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Chart3DLightingModelArchive::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Chart3DLightingModelArchive* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Chart3DLightingModelArchive*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Chart3DLightingModelArchive::MergeFrom(const Chart3DLightingModelArchive& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_phong()) {
      mutable_phong()->::TSCH::Chart3DPhongLightingModelArchive::MergeFrom(from.phong());
    }
    if (from.has_fixed_function()) {
      mutable_fixed_function()->::TSCH::Chart3DFixedFunctionLightingModelArchive::MergeFrom(from.fixed_function());
    }
    if (from.has_environment()) {
      mutable_environment()->::TSCH::Chart3DEnvironmentPackageArchive::MergeFrom(from.environment());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Chart3DLightingModelArchive::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Chart3DLightingModelArchive::CopyFrom(const Chart3DLightingModelArchive& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Chart3DLightingModelArchive::IsInitialized() const {

  if (has_phong()) {
    if (!this->phong().IsInitialized()) return false;
  }
  if (has_fixed_function()) {
    if (!this->fixed_function().IsInitialized()) return false;
  }
  if (has_environment()) {
    if (!this->environment().IsInitialized()) return false;
  }
  return true;
}

void Chart3DLightingModelArchive::Swap(Chart3DLightingModelArchive* other) {
  if (other != this) {
    std::swap(phong_, other->phong_);
    std::swap(fixed_function_, other->fixed_function_);
    std::swap(environment_, other->environment_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Chart3DLightingModelArchive::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Chart3DLightingModelArchive_descriptor_;
  metadata.reflection = Chart3DLightingModelArchive_reflection_;
  return metadata;
}

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

#ifndef _MSC_VER
const int Chart3DLightingPackageArchive::kNameFieldNumber;
const int Chart3DLightingPackageArchive::kLightsFieldNumber;
#endif  // !_MSC_VER

Chart3DLightingPackageArchive::Chart3DLightingPackageArchive()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Chart3DLightingPackageArchive::InitAsDefaultInstance() {
}

Chart3DLightingPackageArchive::Chart3DLightingPackageArchive(const Chart3DLightingPackageArchive& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Chart3DLightingPackageArchive::SharedCtor() {
  _cached_size_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Chart3DLightingPackageArchive::~Chart3DLightingPackageArchive() {
  SharedDtor();
}

void Chart3DLightingPackageArchive::SharedDtor() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    delete name_;
  }
  if (this != default_instance_) {
  }
}

void Chart3DLightingPackageArchive::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Chart3DLightingPackageArchive::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Chart3DLightingPackageArchive_descriptor_;
}

const Chart3DLightingPackageArchive& Chart3DLightingPackageArchive::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_TSCH3DArchives_2eproto();
  return *default_instance_;
}

Chart3DLightingPackageArchive* Chart3DLightingPackageArchive::default_instance_ = NULL;

Chart3DLightingPackageArchive* Chart3DLightingPackageArchive::New() const {
  return new Chart3DLightingPackageArchive;
}

void Chart3DLightingPackageArchive::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::kEmptyString) {
        name_->clear();
      }
    }
  }
  lights_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Chart3DLightingPackageArchive::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string name = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_lights;
        break;
      }

      // repeated .TSCH.Chart3DLightArchive lights = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_lights:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_lights()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_lights;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Chart3DLightingPackageArchive::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->name(), output);
  }

  // repeated .TSCH.Chart3DLightArchive lights = 2;
  for (int i = 0; i < this->lights_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->lights(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Chart3DLightingPackageArchive::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->name(), target);
  }

  // repeated .TSCH.Chart3DLightArchive lights = 2;
  for (int i = 0; i < this->lights_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->lights(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Chart3DLightingPackageArchive::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string name = 1;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

  }
  // repeated .TSCH.Chart3DLightArchive lights = 2;
  total_size += 1 * this->lights_size();
  for (int i = 0; i < this->lights_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->lights(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Chart3DLightingPackageArchive::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Chart3DLightingPackageArchive* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Chart3DLightingPackageArchive*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Chart3DLightingPackageArchive::MergeFrom(const Chart3DLightingPackageArchive& from) {
  GOOGLE_CHECK_NE(&from, this);
  lights_.MergeFrom(from.lights_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_name()) {
      set_name(from.name());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Chart3DLightingPackageArchive::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Chart3DLightingPackageArchive::CopyFrom(const Chart3DLightingPackageArchive& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Chart3DLightingPackageArchive::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  for (int i = 0; i < lights_size(); i++) {
    if (!this->lights(i).IsInitialized()) return false;
  }
  return true;
}

void Chart3DLightingPackageArchive::Swap(Chart3DLightingPackageArchive* other) {
  if (other != this) {
    std::swap(name_, other->name_);
    lights_.Swap(&other->lights_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Chart3DLightingPackageArchive::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Chart3DLightingPackageArchive_descriptor_;
  metadata.reflection = Chart3DLightingPackageArchive_reflection_;
  return metadata;
}

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

#ifndef _MSC_VER
const int Chart3DTexturesMaterialArchive::kColorFieldNumber;
const int Chart3DTexturesMaterialArchive::kTexturesFieldNumber;
#endif  // !_MSC_VER

Chart3DTexturesMaterialArchive::Chart3DTexturesMaterialArchive()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Chart3DTexturesMaterialArchive::InitAsDefaultInstance() {
  color_ = const_cast< ::TSCH::Chart3DVectorArchive*>(&::TSCH::Chart3DVectorArchive::default_instance());
}

Chart3DTexturesMaterialArchive::Chart3DTexturesMaterialArchive(const Chart3DTexturesMaterialArchive& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Chart3DTexturesMaterialArchive::SharedCtor() {
  _cached_size_ = 0;
  color_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Chart3DTexturesMaterialArchive::~Chart3DTexturesMaterialArchive() {
  SharedDtor();
}

void Chart3DTexturesMaterialArchive::SharedDtor() {
  if (this != default_instance_) {
    delete color_;
  }
}

void Chart3DTexturesMaterialArchive::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Chart3DTexturesMaterialArchive::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Chart3DTexturesMaterialArchive_descriptor_;
}

const Chart3DTexturesMaterialArchive& Chart3DTexturesMaterialArchive::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_TSCH3DArchives_2eproto();
  return *default_instance_;
}

Chart3DTexturesMaterialArchive* Chart3DTexturesMaterialArchive::default_instance_ = NULL;

Chart3DTexturesMaterialArchive* Chart3DTexturesMaterialArchive::New() const {
  return new Chart3DTexturesMaterialArchive;
}

void Chart3DTexturesMaterialArchive::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_color()) {
      if (color_ != NULL) color_->::TSCH::Chart3DVectorArchive::Clear();
    }
  }
  textures_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Chart3DTexturesMaterialArchive::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .TSCH.Chart3DVectorArchive color = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_color()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_textures;
        break;
      }

      // repeated .TSCH.Chart3DTSPImageDataTextureArchive textures = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_textures:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_textures()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_textures;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Chart3DTexturesMaterialArchive::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .TSCH.Chart3DVectorArchive color = 1;
  if (has_color()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->color(), output);
  }

  // repeated .TSCH.Chart3DTSPImageDataTextureArchive textures = 2;
  for (int i = 0; i < this->textures_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->textures(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Chart3DTexturesMaterialArchive::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .TSCH.Chart3DVectorArchive color = 1;
  if (has_color()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->color(), target);
  }

  // repeated .TSCH.Chart3DTSPImageDataTextureArchive textures = 2;
  for (int i = 0; i < this->textures_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->textures(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Chart3DTexturesMaterialArchive::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .TSCH.Chart3DVectorArchive color = 1;
    if (has_color()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->color());
    }

  }
  // repeated .TSCH.Chart3DTSPImageDataTextureArchive textures = 2;
  total_size += 1 * this->textures_size();
  for (int i = 0; i < this->textures_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->textures(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Chart3DTexturesMaterialArchive::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Chart3DTexturesMaterialArchive* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Chart3DTexturesMaterialArchive*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Chart3DTexturesMaterialArchive::MergeFrom(const Chart3DTexturesMaterialArchive& from) {
  GOOGLE_CHECK_NE(&from, this);
  textures_.MergeFrom(from.textures_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_color()) {
      mutable_color()->::TSCH::Chart3DVectorArchive::MergeFrom(from.color());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Chart3DTexturesMaterialArchive::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Chart3DTexturesMaterialArchive::CopyFrom(const Chart3DTexturesMaterialArchive& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Chart3DTexturesMaterialArchive::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (has_color()) {
    if (!this->color().IsInitialized()) return false;
  }
  for (int i = 0; i < textures_size(); i++) {
    if (!this->textures(i).IsInitialized()) return false;
  }
  return true;
}

void Chart3DTexturesMaterialArchive::Swap(Chart3DTexturesMaterialArchive* other) {
  if (other != this) {
    std::swap(color_, other->color_);
    textures_.Swap(&other->textures_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Chart3DTexturesMaterialArchive::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Chart3DTexturesMaterialArchive_descriptor_;
  metadata.reflection = Chart3DTexturesMaterialArchive_reflection_;
  return metadata;
}

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

#ifndef _MSC_VER
const int Chart3DEmissiveMaterialArchive::kSuperFieldNumber;
const int Chart3DEmissiveMaterialArchive::kTilingsFieldNumber;
#endif  // !_MSC_VER

Chart3DEmissiveMaterialArchive::Chart3DEmissiveMaterialArchive()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Chart3DEmissiveMaterialArchive::InitAsDefaultInstance() {
  super_ = const_cast< ::TSCH::Chart3DTexturesMaterialArchive*>(&::TSCH::Chart3DTexturesMaterialArchive::default_instance());
}

Chart3DEmissiveMaterialArchive::Chart3DEmissiveMaterialArchive(const Chart3DEmissiveMaterialArchive& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Chart3DEmissiveMaterialArchive::SharedCtor() {
  _cached_size_ = 0;
  super_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Chart3DEmissiveMaterialArchive::~Chart3DEmissiveMaterialArchive() {
  SharedDtor();
}

void Chart3DEmissiveMaterialArchive::SharedDtor() {
  if (this != default_instance_) {
    delete super_;
  }
}

void Chart3DEmissiveMaterialArchive::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Chart3DEmissiveMaterialArchive::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Chart3DEmissiveMaterialArchive_descriptor_;
}

const Chart3DEmissiveMaterialArchive& Chart3DEmissiveMaterialArchive::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_TSCH3DArchives_2eproto();
  return *default_instance_;
}

Chart3DEmissiveMaterialArchive* Chart3DEmissiveMaterialArchive::default_instance_ = NULL;

Chart3DEmissiveMaterialArchive* Chart3DEmissiveMaterialArchive::New() const {
  return new Chart3DEmissiveMaterialArchive;
}

void Chart3DEmissiveMaterialArchive::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_super()) {
      if (super_ != NULL) super_->::TSCH::Chart3DTexturesMaterialArchive::Clear();
    }
  }
  tilings_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Chart3DEmissiveMaterialArchive::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_super()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_tilings;
        break;
      }

      // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_tilings:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_tilings()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_tilings;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Chart3DEmissiveMaterialArchive::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
  if (has_super()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->super(), output);
  }

  // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 2;
  for (int i = 0; i < this->tilings_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->tilings(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Chart3DEmissiveMaterialArchive::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
  if (has_super()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->super(), target);
  }

  // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 2;
  for (int i = 0; i < this->tilings_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->tilings(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Chart3DEmissiveMaterialArchive::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
    if (has_super()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->super());
    }

  }
  // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 2;
  total_size += 1 * this->tilings_size();
  for (int i = 0; i < this->tilings_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->tilings(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Chart3DEmissiveMaterialArchive::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Chart3DEmissiveMaterialArchive* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Chart3DEmissiveMaterialArchive*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Chart3DEmissiveMaterialArchive::MergeFrom(const Chart3DEmissiveMaterialArchive& from) {
  GOOGLE_CHECK_NE(&from, this);
  tilings_.MergeFrom(from.tilings_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_super()) {
      mutable_super()->::TSCH::Chart3DTexturesMaterialArchive::MergeFrom(from.super());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Chart3DEmissiveMaterialArchive::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Chart3DEmissiveMaterialArchive::CopyFrom(const Chart3DEmissiveMaterialArchive& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Chart3DEmissiveMaterialArchive::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (has_super()) {
    if (!this->super().IsInitialized()) return false;
  }
  for (int i = 0; i < tilings_size(); i++) {
    if (!this->tilings(i).IsInitialized()) return false;
  }
  return true;
}

void Chart3DEmissiveMaterialArchive::Swap(Chart3DEmissiveMaterialArchive* other) {
  if (other != this) {
    std::swap(super_, other->super_);
    tilings_.Swap(&other->tilings_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Chart3DEmissiveMaterialArchive::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Chart3DEmissiveMaterialArchive_descriptor_;
  metadata.reflection = Chart3DEmissiveMaterialArchive_reflection_;
  return metadata;
}

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

#ifndef _MSC_VER
const int Chart3DDiffuseMaterialArchive::kSuperFieldNumber;
const int Chart3DDiffuseMaterialArchive::kTilingsFieldNumber;
#endif  // !_MSC_VER

Chart3DDiffuseMaterialArchive::Chart3DDiffuseMaterialArchive()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Chart3DDiffuseMaterialArchive::InitAsDefaultInstance() {
  super_ = const_cast< ::TSCH::Chart3DTexturesMaterialArchive*>(&::TSCH::Chart3DTexturesMaterialArchive::default_instance());
}

Chart3DDiffuseMaterialArchive::Chart3DDiffuseMaterialArchive(const Chart3DDiffuseMaterialArchive& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Chart3DDiffuseMaterialArchive::SharedCtor() {
  _cached_size_ = 0;
  super_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Chart3DDiffuseMaterialArchive::~Chart3DDiffuseMaterialArchive() {
  SharedDtor();
}

void Chart3DDiffuseMaterialArchive::SharedDtor() {
  if (this != default_instance_) {
    delete super_;
  }
}

void Chart3DDiffuseMaterialArchive::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Chart3DDiffuseMaterialArchive::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Chart3DDiffuseMaterialArchive_descriptor_;
}

const Chart3DDiffuseMaterialArchive& Chart3DDiffuseMaterialArchive::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_TSCH3DArchives_2eproto();
  return *default_instance_;
}

Chart3DDiffuseMaterialArchive* Chart3DDiffuseMaterialArchive::default_instance_ = NULL;

Chart3DDiffuseMaterialArchive* Chart3DDiffuseMaterialArchive::New() const {
  return new Chart3DDiffuseMaterialArchive;
}

void Chart3DDiffuseMaterialArchive::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_super()) {
      if (super_ != NULL) super_->::TSCH::Chart3DTexturesMaterialArchive::Clear();
    }
  }
  tilings_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Chart3DDiffuseMaterialArchive::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_super()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_tilings;
        break;
      }

      // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_tilings:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_tilings()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_tilings;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Chart3DDiffuseMaterialArchive::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
  if (has_super()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->super(), output);
  }

  // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 2;
  for (int i = 0; i < this->tilings_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->tilings(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Chart3DDiffuseMaterialArchive::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
  if (has_super()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->super(), target);
  }

  // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 2;
  for (int i = 0; i < this->tilings_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->tilings(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Chart3DDiffuseMaterialArchive::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
    if (has_super()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->super());
    }

  }
  // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 2;
  total_size += 1 * this->tilings_size();
  for (int i = 0; i < this->tilings_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->tilings(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Chart3DDiffuseMaterialArchive::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Chart3DDiffuseMaterialArchive* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Chart3DDiffuseMaterialArchive*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Chart3DDiffuseMaterialArchive::MergeFrom(const Chart3DDiffuseMaterialArchive& from) {
  GOOGLE_CHECK_NE(&from, this);
  tilings_.MergeFrom(from.tilings_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_super()) {
      mutable_super()->::TSCH::Chart3DTexturesMaterialArchive::MergeFrom(from.super());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Chart3DDiffuseMaterialArchive::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Chart3DDiffuseMaterialArchive::CopyFrom(const Chart3DDiffuseMaterialArchive& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Chart3DDiffuseMaterialArchive::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (has_super()) {
    if (!this->super().IsInitialized()) return false;
  }
  for (int i = 0; i < tilings_size(); i++) {
    if (!this->tilings(i).IsInitialized()) return false;
  }
  return true;
}

void Chart3DDiffuseMaterialArchive::Swap(Chart3DDiffuseMaterialArchive* other) {
  if (other != this) {
    std::swap(super_, other->super_);
    tilings_.Swap(&other->tilings_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Chart3DDiffuseMaterialArchive::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Chart3DDiffuseMaterialArchive_descriptor_;
  metadata.reflection = Chart3DDiffuseMaterialArchive_reflection_;
  return metadata;
}

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

#ifndef _MSC_VER
const int Chart3DModulateMaterialArchive::kSuperFieldNumber;
const int Chart3DModulateMaterialArchive::kTilingsFieldNumber;
#endif  // !_MSC_VER

Chart3DModulateMaterialArchive::Chart3DModulateMaterialArchive()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Chart3DModulateMaterialArchive::InitAsDefaultInstance() {
  super_ = const_cast< ::TSCH::Chart3DTexturesMaterialArchive*>(&::TSCH::Chart3DTexturesMaterialArchive::default_instance());
}

Chart3DModulateMaterialArchive::Chart3DModulateMaterialArchive(const Chart3DModulateMaterialArchive& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Chart3DModulateMaterialArchive::SharedCtor() {
  _cached_size_ = 0;
  super_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Chart3DModulateMaterialArchive::~Chart3DModulateMaterialArchive() {
  SharedDtor();
}

void Chart3DModulateMaterialArchive::SharedDtor() {
  if (this != default_instance_) {
    delete super_;
  }
}

void Chart3DModulateMaterialArchive::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Chart3DModulateMaterialArchive::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Chart3DModulateMaterialArchive_descriptor_;
}

const Chart3DModulateMaterialArchive& Chart3DModulateMaterialArchive::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_TSCH3DArchives_2eproto();
  return *default_instance_;
}

Chart3DModulateMaterialArchive* Chart3DModulateMaterialArchive::default_instance_ = NULL;

Chart3DModulateMaterialArchive* Chart3DModulateMaterialArchive::New() const {
  return new Chart3DModulateMaterialArchive;
}

void Chart3DModulateMaterialArchive::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_super()) {
      if (super_ != NULL) super_->::TSCH::Chart3DTexturesMaterialArchive::Clear();
    }
  }
  tilings_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Chart3DModulateMaterialArchive::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_super()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_tilings;
        break;
      }

      // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_tilings:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_tilings()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_tilings;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Chart3DModulateMaterialArchive::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
  if (has_super()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->super(), output);
  }

  // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 2;
  for (int i = 0; i < this->tilings_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->tilings(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Chart3DModulateMaterialArchive::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
  if (has_super()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->super(), target);
  }

  // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 2;
  for (int i = 0; i < this->tilings_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->tilings(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Chart3DModulateMaterialArchive::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
    if (has_super()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->super());
    }

  }
  // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 2;
  total_size += 1 * this->tilings_size();
  for (int i = 0; i < this->tilings_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->tilings(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Chart3DModulateMaterialArchive::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Chart3DModulateMaterialArchive* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Chart3DModulateMaterialArchive*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Chart3DModulateMaterialArchive::MergeFrom(const Chart3DModulateMaterialArchive& from) {
  GOOGLE_CHECK_NE(&from, this);
  tilings_.MergeFrom(from.tilings_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_super()) {
      mutable_super()->::TSCH::Chart3DTexturesMaterialArchive::MergeFrom(from.super());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Chart3DModulateMaterialArchive::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Chart3DModulateMaterialArchive::CopyFrom(const Chart3DModulateMaterialArchive& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Chart3DModulateMaterialArchive::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (has_super()) {
    if (!this->super().IsInitialized()) return false;
  }
  for (int i = 0; i < tilings_size(); i++) {
    if (!this->tilings(i).IsInitialized()) return false;
  }
  return true;
}

void Chart3DModulateMaterialArchive::Swap(Chart3DModulateMaterialArchive* other) {
  if (other != this) {
    std::swap(super_, other->super_);
    tilings_.Swap(&other->tilings_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Chart3DModulateMaterialArchive::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Chart3DModulateMaterialArchive_descriptor_;
  metadata.reflection = Chart3DModulateMaterialArchive_reflection_;
  return metadata;
}

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

#ifndef _MSC_VER
const int Chart3DSpecularMaterialArchive::kSuperFieldNumber;
const int Chart3DSpecularMaterialArchive::kTilingsFieldNumber;
#endif  // !_MSC_VER

Chart3DSpecularMaterialArchive::Chart3DSpecularMaterialArchive()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Chart3DSpecularMaterialArchive::InitAsDefaultInstance() {
  super_ = const_cast< ::TSCH::Chart3DTexturesMaterialArchive*>(&::TSCH::Chart3DTexturesMaterialArchive::default_instance());
}

Chart3DSpecularMaterialArchive::Chart3DSpecularMaterialArchive(const Chart3DSpecularMaterialArchive& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Chart3DSpecularMaterialArchive::SharedCtor() {
  _cached_size_ = 0;
  super_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Chart3DSpecularMaterialArchive::~Chart3DSpecularMaterialArchive() {
  SharedDtor();
}

void Chart3DSpecularMaterialArchive::SharedDtor() {
  if (this != default_instance_) {
    delete super_;
  }
}

void Chart3DSpecularMaterialArchive::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Chart3DSpecularMaterialArchive::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Chart3DSpecularMaterialArchive_descriptor_;
}

const Chart3DSpecularMaterialArchive& Chart3DSpecularMaterialArchive::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_TSCH3DArchives_2eproto();
  return *default_instance_;
}

Chart3DSpecularMaterialArchive* Chart3DSpecularMaterialArchive::default_instance_ = NULL;

Chart3DSpecularMaterialArchive* Chart3DSpecularMaterialArchive::New() const {
  return new Chart3DSpecularMaterialArchive;
}

void Chart3DSpecularMaterialArchive::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_super()) {
      if (super_ != NULL) super_->::TSCH::Chart3DTexturesMaterialArchive::Clear();
    }
  }
  tilings_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Chart3DSpecularMaterialArchive::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_super()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_tilings;
        break;
      }

      // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_tilings:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_tilings()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_tilings;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Chart3DSpecularMaterialArchive::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
  if (has_super()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->super(), output);
  }

  // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 2;
  for (int i = 0; i < this->tilings_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->tilings(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Chart3DSpecularMaterialArchive::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
  if (has_super()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->super(), target);
  }

  // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 2;
  for (int i = 0; i < this->tilings_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->tilings(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Chart3DSpecularMaterialArchive::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
    if (has_super()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->super());
    }

  }
  // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 2;
  total_size += 1 * this->tilings_size();
  for (int i = 0; i < this->tilings_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->tilings(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Chart3DSpecularMaterialArchive::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Chart3DSpecularMaterialArchive* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Chart3DSpecularMaterialArchive*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Chart3DSpecularMaterialArchive::MergeFrom(const Chart3DSpecularMaterialArchive& from) {
  GOOGLE_CHECK_NE(&from, this);
  tilings_.MergeFrom(from.tilings_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_super()) {
      mutable_super()->::TSCH::Chart3DTexturesMaterialArchive::MergeFrom(from.super());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Chart3DSpecularMaterialArchive::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Chart3DSpecularMaterialArchive::CopyFrom(const Chart3DSpecularMaterialArchive& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Chart3DSpecularMaterialArchive::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (has_super()) {
    if (!this->super().IsInitialized()) return false;
  }
  for (int i = 0; i < tilings_size(); i++) {
    if (!this->tilings(i).IsInitialized()) return false;
  }
  return true;
}

void Chart3DSpecularMaterialArchive::Swap(Chart3DSpecularMaterialArchive* other) {
  if (other != this) {
    std::swap(super_, other->super_);
    tilings_.Swap(&other->tilings_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Chart3DSpecularMaterialArchive::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Chart3DSpecularMaterialArchive_descriptor_;
  metadata.reflection = Chart3DSpecularMaterialArchive_reflection_;
  return metadata;
}

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

#ifndef _MSC_VER
const int Chart3DShininessMaterialArchive::kSuperFieldNumber;
const int Chart3DShininessMaterialArchive::kTilingsFieldNumber;
#endif  // !_MSC_VER

Chart3DShininessMaterialArchive::Chart3DShininessMaterialArchive()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Chart3DShininessMaterialArchive::InitAsDefaultInstance() {
  super_ = const_cast< ::TSCH::Chart3DTexturesMaterialArchive*>(&::TSCH::Chart3DTexturesMaterialArchive::default_instance());
}

Chart3DShininessMaterialArchive::Chart3DShininessMaterialArchive(const Chart3DShininessMaterialArchive& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Chart3DShininessMaterialArchive::SharedCtor() {
  _cached_size_ = 0;
  super_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Chart3DShininessMaterialArchive::~Chart3DShininessMaterialArchive() {
  SharedDtor();
}

void Chart3DShininessMaterialArchive::SharedDtor() {
  if (this != default_instance_) {
    delete super_;
  }
}

void Chart3DShininessMaterialArchive::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Chart3DShininessMaterialArchive::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Chart3DShininessMaterialArchive_descriptor_;
}

const Chart3DShininessMaterialArchive& Chart3DShininessMaterialArchive::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_TSCH3DArchives_2eproto();
  return *default_instance_;
}

Chart3DShininessMaterialArchive* Chart3DShininessMaterialArchive::default_instance_ = NULL;

Chart3DShininessMaterialArchive* Chart3DShininessMaterialArchive::New() const {
  return new Chart3DShininessMaterialArchive;
}

void Chart3DShininessMaterialArchive::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_super()) {
      if (super_ != NULL) super_->::TSCH::Chart3DTexturesMaterialArchive::Clear();
    }
  }
  tilings_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Chart3DShininessMaterialArchive::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_super()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_tilings;
        break;
      }

      // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_tilings:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_tilings()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_tilings;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Chart3DShininessMaterialArchive::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
  if (has_super()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->super(), output);
  }

  // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 2;
  for (int i = 0; i < this->tilings_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->tilings(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Chart3DShininessMaterialArchive::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
  if (has_super()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->super(), target);
  }

  // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 2;
  for (int i = 0; i < this->tilings_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->tilings(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Chart3DShininessMaterialArchive::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
    if (has_super()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->super());
    }

  }
  // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 2;
  total_size += 1 * this->tilings_size();
  for (int i = 0; i < this->tilings_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->tilings(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Chart3DShininessMaterialArchive::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Chart3DShininessMaterialArchive* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Chart3DShininessMaterialArchive*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Chart3DShininessMaterialArchive::MergeFrom(const Chart3DShininessMaterialArchive& from) {
  GOOGLE_CHECK_NE(&from, this);
  tilings_.MergeFrom(from.tilings_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_super()) {
      mutable_super()->::TSCH::Chart3DTexturesMaterialArchive::MergeFrom(from.super());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Chart3DShininessMaterialArchive::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Chart3DShininessMaterialArchive::CopyFrom(const Chart3DShininessMaterialArchive& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Chart3DShininessMaterialArchive::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (has_super()) {
    if (!this->super().IsInitialized()) return false;
  }
  for (int i = 0; i < tilings_size(); i++) {
    if (!this->tilings(i).IsInitialized()) return false;
  }
  return true;
}

void Chart3DShininessMaterialArchive::Swap(Chart3DShininessMaterialArchive* other) {
  if (other != this) {
    std::swap(super_, other->super_);
    tilings_.Swap(&other->tilings_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Chart3DShininessMaterialArchive::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Chart3DShininessMaterialArchive_descriptor_;
  metadata.reflection = Chart3DShininessMaterialArchive_reflection_;
  return metadata;
}

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

#ifndef _MSC_VER
const int Chart3DEnvironmentMaterialArchive::kSuperFieldNumber;
const int Chart3DEnvironmentMaterialArchive::kOBSOLETETilingsFieldNumber;
const int Chart3DEnvironmentMaterialArchive::kDecalModeFieldNumber;
const int Chart3DEnvironmentMaterialArchive::kTilingsFieldNumber;
#endif  // !_MSC_VER

Chart3DEnvironmentMaterialArchive::Chart3DEnvironmentMaterialArchive()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Chart3DEnvironmentMaterialArchive::InitAsDefaultInstance() {
  super_ = const_cast< ::TSCH::Chart3DTexturesMaterialArchive*>(&::TSCH::Chart3DTexturesMaterialArchive::default_instance());
}

Chart3DEnvironmentMaterialArchive::Chart3DEnvironmentMaterialArchive(const Chart3DEnvironmentMaterialArchive& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Chart3DEnvironmentMaterialArchive::SharedCtor() {
  _cached_size_ = 0;
  super_ = NULL;
  decalmode_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Chart3DEnvironmentMaterialArchive::~Chart3DEnvironmentMaterialArchive() {
  SharedDtor();
}

void Chart3DEnvironmentMaterialArchive::SharedDtor() {
  if (this != default_instance_) {
    delete super_;
  }
}

void Chart3DEnvironmentMaterialArchive::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Chart3DEnvironmentMaterialArchive::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Chart3DEnvironmentMaterialArchive_descriptor_;
}

const Chart3DEnvironmentMaterialArchive& Chart3DEnvironmentMaterialArchive::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_TSCH3DArchives_2eproto();
  return *default_instance_;
}

Chart3DEnvironmentMaterialArchive* Chart3DEnvironmentMaterialArchive::default_instance_ = NULL;

Chart3DEnvironmentMaterialArchive* Chart3DEnvironmentMaterialArchive::New() const {
  return new Chart3DEnvironmentMaterialArchive;
}

void Chart3DEnvironmentMaterialArchive::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_super()) {
      if (super_ != NULL) super_->::TSCH::Chart3DTexturesMaterialArchive::Clear();
    }
    decalmode_ = false;
  }
  obsolete_tilings_.Clear();
  tilings_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Chart3DEnvironmentMaterialArchive::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_super()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_OBSOLETE_tilings;
        break;
      }

      // repeated .TSCH.Chart3DBaseImageTextureTilingArchive OBSOLETE_tilings = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_OBSOLETE_tilings:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_obsolete_tilings()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_OBSOLETE_tilings;
        if (input->ExpectTag(24)) goto parse_decalMode;
        break;
      }

      // optional bool decalMode = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_decalMode:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &decalmode_)));
          set_has_decalmode();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_tilings;
        break;
      }

      // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_tilings:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_tilings()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_tilings;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Chart3DEnvironmentMaterialArchive::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
  if (has_super()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->super(), output);
  }

  // repeated .TSCH.Chart3DBaseImageTextureTilingArchive OBSOLETE_tilings = 2;
  for (int i = 0; i < this->obsolete_tilings_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->obsolete_tilings(i), output);
  }

  // optional bool decalMode = 3;
  if (has_decalmode()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->decalmode(), output);
  }

  // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 4;
  for (int i = 0; i < this->tilings_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->tilings(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Chart3DEnvironmentMaterialArchive::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
  if (has_super()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->super(), target);
  }

  // repeated .TSCH.Chart3DBaseImageTextureTilingArchive OBSOLETE_tilings = 2;
  for (int i = 0; i < this->obsolete_tilings_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->obsolete_tilings(i), target);
  }

  // optional bool decalMode = 3;
  if (has_decalmode()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->decalmode(), target);
  }

  // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 4;
  for (int i = 0; i < this->tilings_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->tilings(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Chart3DEnvironmentMaterialArchive::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .TSCH.Chart3DTexturesMaterialArchive super = 1;
    if (has_super()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->super());
    }

    // optional bool decalMode = 3;
    if (has_decalmode()) {
      total_size += 1 + 1;
    }

  }
  // repeated .TSCH.Chart3DBaseImageTextureTilingArchive OBSOLETE_tilings = 2;
  total_size += 1 * this->obsolete_tilings_size();
  for (int i = 0; i < this->obsolete_tilings_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->obsolete_tilings(i));
  }

  // repeated .TSCH.Chart3DImageTextureTilingArchive tilings = 4;
  total_size += 1 * this->tilings_size();
  for (int i = 0; i < this->tilings_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->tilings(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Chart3DEnvironmentMaterialArchive::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Chart3DEnvironmentMaterialArchive* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Chart3DEnvironmentMaterialArchive*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Chart3DEnvironmentMaterialArchive::MergeFrom(const Chart3DEnvironmentMaterialArchive& from) {
  GOOGLE_CHECK_NE(&from, this);
  obsolete_tilings_.MergeFrom(from.obsolete_tilings_);
  tilings_.MergeFrom(from.tilings_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_super()) {
      mutable_super()->::TSCH::Chart3DTexturesMaterialArchive::MergeFrom(from.super());
    }
    if (from.has_decalmode()) {
      set_decalmode(from.decalmode());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Chart3DEnvironmentMaterialArchive::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Chart3DEnvironmentMaterialArchive::CopyFrom(const Chart3DEnvironmentMaterialArchive& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Chart3DEnvironmentMaterialArchive::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (has_super()) {
    if (!this->super().IsInitialized()) return false;
  }
  for (int i = 0; i < obsolete_tilings_size(); i++) {
    if (!this->obsolete_tilings(i).IsInitialized()) return false;
  }
  for (int i = 0; i < tilings_size(); i++) {
    if (!this->tilings(i).IsInitialized()) return false;
  }
  return true;
}

void Chart3DEnvironmentMaterialArchive::Swap(Chart3DEnvironmentMaterialArchive* other) {
  if (other != this) {
    std::swap(super_, other->super_);
    obsolete_tilings_.Swap(&other->obsolete_tilings_);
    std::swap(decalmode_, other->decalmode_);
    tilings_.Swap(&other->tilings_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Chart3DEnvironmentMaterialArchive::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Chart3DEnvironmentMaterialArchive_descriptor_;
  metadata.reflection = Chart3DEnvironmentMaterialArchive_reflection_;
  return metadata;
}

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

#ifndef _MSC_VER
const int Chart3DFixedFunctionLightingModelArchive::kMaterialsFieldNumber;
#endif  // !_MSC_VER

Chart3DFixedFunctionLightingModelArchive::Chart3DFixedFunctionLightingModelArchive()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Chart3DFixedFunctionLightingModelArchive::InitAsDefaultInstance() {
  materials_ = const_cast< ::TSCH::Chart3DPhongMaterialPackageArchive*>(&::TSCH::Chart3DPhongMaterialPackageArchive::default_instance());
}

Chart3DFixedFunctionLightingModelArchive::Chart3DFixedFunctionLightingModelArchive(const Chart3DFixedFunctionLightingModelArchive& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Chart3DFixedFunctionLightingModelArchive::SharedCtor() {
  _cached_size_ = 0;
  materials_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Chart3DFixedFunctionLightingModelArchive::~Chart3DFixedFunctionLightingModelArchive() {
  SharedDtor();
}

void Chart3DFixedFunctionLightingModelArchive::SharedDtor() {
  if (this != default_instance_) {
    delete materials_;
  }
}

void Chart3DFixedFunctionLightingModelArchive::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Chart3DFixedFunctionLightingModelArchive::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Chart3DFixedFunctionLightingModelArchive_descriptor_;
}

const Chart3DFixedFunctionLightingModelArchive& Chart3DFixedFunctionLightingModelArchive::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_TSCH3DArchives_2eproto();
  return *default_instance_;
}

Chart3DFixedFunctionLightingModelArchive* Chart3DFixedFunctionLightingModelArchive::default_instance_ = NULL;

Chart3DFixedFunctionLightingModelArchive* Chart3DFixedFunctionLightingModelArchive::New() const {
  return new Chart3DFixedFunctionLightingModelArchive;
}

void Chart3DFixedFunctionLightingModelArchive::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_materials()) {
      if (materials_ != NULL) materials_->::TSCH::Chart3DPhongMaterialPackageArchive::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Chart3DFixedFunctionLightingModelArchive::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .TSCH.Chart3DPhongMaterialPackageArchive materials = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_materials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Chart3DFixedFunctionLightingModelArchive::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .TSCH.Chart3DPhongMaterialPackageArchive materials = 1;
  if (has_materials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->materials(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Chart3DFixedFunctionLightingModelArchive::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .TSCH.Chart3DPhongMaterialPackageArchive materials = 1;
  if (has_materials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->materials(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Chart3DFixedFunctionLightingModelArchive::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .TSCH.Chart3DPhongMaterialPackageArchive materials = 1;
    if (has_materials()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->materials());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Chart3DFixedFunctionLightingModelArchive::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Chart3DFixedFunctionLightingModelArchive* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Chart3DFixedFunctionLightingModelArchive*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Chart3DFixedFunctionLightingModelArchive::MergeFrom(const Chart3DFixedFunctionLightingModelArchive& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_materials()) {
      mutable_materials()->::TSCH::Chart3DPhongMaterialPackageArchive::MergeFrom(from.materials());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Chart3DFixedFunctionLightingModelArchive::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Chart3DFixedFunctionLightingModelArchive::CopyFrom(const Chart3DFixedFunctionLightingModelArchive& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Chart3DFixedFunctionLightingModelArchive::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (has_materials()) {
    if (!this->materials().IsInitialized()) return false;
  }
  return true;
}

void Chart3DFixedFunctionLightingModelArchive::Swap(Chart3DFixedFunctionLightingModelArchive* other) {
  if (other != this) {
    std::swap(materials_, other->materials_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Chart3DFixedFunctionLightingModelArchive::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Chart3DFixedFunctionLightingModelArchive_descriptor_;
  metadata.reflection = Chart3DFixedFunctionLightingModelArchive_reflection_;
  return metadata;
}

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

#ifndef _MSC_VER
const int Chart3DPhongLightingModelArchive::kMaterialsFieldNumber;
#endif  // !_MSC_VER

Chart3DPhongLightingModelArchive::Chart3DPhongLightingModelArchive()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Chart3DPhongLightingModelArchive::InitAsDefaultInstance() {
  materials_ = const_cast< ::TSCH::Chart3DPhongMaterialPackageArchive*>(&::TSCH::Chart3DPhongMaterialPackageArchive::default_instance());
}

Chart3DPhongLightingModelArchive::Chart3DPhongLightingModelArchive(const Chart3DPhongLightingModelArchive& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Chart3DPhongLightingModelArchive::SharedCtor() {
  _cached_size_ = 0;
  materials_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Chart3DPhongLightingModelArchive::~Chart3DPhongLightingModelArchive() {
  SharedDtor();
}

void Chart3DPhongLightingModelArchive::SharedDtor() {
  if (this != default_instance_) {
    delete materials_;
  }
}

void Chart3DPhongLightingModelArchive::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Chart3DPhongLightingModelArchive::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Chart3DPhongLightingModelArchive_descriptor_;
}

const Chart3DPhongLightingModelArchive& Chart3DPhongLightingModelArchive::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_TSCH3DArchives_2eproto();
  return *default_instance_;
}

Chart3DPhongLightingModelArchive* Chart3DPhongLightingModelArchive::default_instance_ = NULL;

Chart3DPhongLightingModelArchive* Chart3DPhongLightingModelArchive::New() const {
  return new Chart3DPhongLightingModelArchive;
}

void Chart3DPhongLightingModelArchive::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_materials()) {
      if (materials_ != NULL) materials_->::TSCH::Chart3DPhongMaterialPackageArchive::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Chart3DPhongLightingModelArchive::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .TSCH.Chart3DPhongMaterialPackageArchive materials = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_materials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Chart3DPhongLightingModelArchive::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .TSCH.Chart3DPhongMaterialPackageArchive materials = 1;
  if (has_materials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->materials(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Chart3DPhongLightingModelArchive::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .TSCH.Chart3DPhongMaterialPackageArchive materials = 1;
  if (has_materials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->materials(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Chart3DPhongLightingModelArchive::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .TSCH.Chart3DPhongMaterialPackageArchive materials = 1;
    if (has_materials()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->materials());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Chart3DPhongLightingModelArchive::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Chart3DPhongLightingModelArchive* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Chart3DPhongLightingModelArchive*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Chart3DPhongLightingModelArchive::MergeFrom(const Chart3DPhongLightingModelArchive& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_materials()) {
      mutable_materials()->::TSCH::Chart3DPhongMaterialPackageArchive::MergeFrom(from.materials());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Chart3DPhongLightingModelArchive::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Chart3DPhongLightingModelArchive::CopyFrom(const Chart3DPhongLightingModelArchive& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Chart3DPhongLightingModelArchive::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (has_materials()) {
    if (!this->materials().IsInitialized()) return false;
  }
  return true;
}

void Chart3DPhongLightingModelArchive::Swap(Chart3DPhongLightingModelArchive* other) {
  if (other != this) {
    std::swap(materials_, other->materials_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Chart3DPhongLightingModelArchive::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Chart3DPhongLightingModelArchive_descriptor_;
  metadata.reflection = Chart3DPhongLightingModelArchive_reflection_;
  return metadata;
}

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

#ifndef _MSC_VER
const int Chart3DPhongMaterialPackageArchive::kEmissiveFieldNumber;
const int Chart3DPhongMaterialPackageArchive::kDiffuseFieldNumber;
const int Chart3DPhongMaterialPackageArchive::kModulateFieldNumber;
const int Chart3DPhongMaterialPackageArchive::kSpecularFieldNumber;
const int Chart3DPhongMaterialPackageArchive::kShininessFieldNumber;
#endif  // !_MSC_VER

Chart3DPhongMaterialPackageArchive::Chart3DPhongMaterialPackageArchive()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Chart3DPhongMaterialPackageArchive::InitAsDefaultInstance() {
  emissive_ = const_cast< ::TSCH::Chart3DEmissiveMaterialArchive*>(&::TSCH::Chart3DEmissiveMaterialArchive::default_instance());
  diffuse_ = const_cast< ::TSCH::Chart3DDiffuseMaterialArchive*>(&::TSCH::Chart3DDiffuseMaterialArchive::default_instance());
  modulate_ = const_cast< ::TSCH::Chart3DModulateMaterialArchive*>(&::TSCH::Chart3DModulateMaterialArchive::default_instance());
  specular_ = const_cast< ::TSCH::Chart3DSpecularMaterialArchive*>(&::TSCH::Chart3DSpecularMaterialArchive::default_instance());
  shininess_ = const_cast< ::TSCH::Chart3DShininessMaterialArchive*>(&::TSCH::Chart3DShininessMaterialArchive::default_instance());
}

Chart3DPhongMaterialPackageArchive::Chart3DPhongMaterialPackageArchive(const Chart3DPhongMaterialPackageArchive& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Chart3DPhongMaterialPackageArchive::SharedCtor() {
  _cached_size_ = 0;
  emissive_ = NULL;
  diffuse_ = NULL;
  modulate_ = NULL;
  specular_ = NULL;
  shininess_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Chart3DPhongMaterialPackageArchive::~Chart3DPhongMaterialPackageArchive() {
  SharedDtor();
}

void Chart3DPhongMaterialPackageArchive::SharedDtor() {
  if (this != default_instance_) {
    delete emissive_;
    delete diffuse_;
    delete modulate_;
    delete specular_;
    delete shininess_;
  }
}

void Chart3DPhongMaterialPackageArchive::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Chart3DPhongMaterialPackageArchive::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Chart3DPhongMaterialPackageArchive_descriptor_;
}

const Chart3DPhongMaterialPackageArchive& Chart3DPhongMaterialPackageArchive::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_TSCH3DArchives_2eproto();
  return *default_instance_;
}

Chart3DPhongMaterialPackageArchive* Chart3DPhongMaterialPackageArchive::default_instance_ = NULL;

Chart3DPhongMaterialPackageArchive* Chart3DPhongMaterialPackageArchive::New() const {
  return new Chart3DPhongMaterialPackageArchive;
}

void Chart3DPhongMaterialPackageArchive::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_emissive()) {
      if (emissive_ != NULL) emissive_->::TSCH::Chart3DEmissiveMaterialArchive::Clear();
    }
    if (has_diffuse()) {
      if (diffuse_ != NULL) diffuse_->::TSCH::Chart3DDiffuseMaterialArchive::Clear();
    }
    if (has_modulate()) {
      if (modulate_ != NULL) modulate_->::TSCH::Chart3DModulateMaterialArchive::Clear();
    }
    if (has_specular()) {
      if (specular_ != NULL) specular_->::TSCH::Chart3DSpecularMaterialArchive::Clear();
    }
    if (has_shininess()) {
      if (shininess_ != NULL) shininess_->::TSCH::Chart3DShininessMaterialArchive::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Chart3DPhongMaterialPackageArchive::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .TSCH.Chart3DEmissiveMaterialArchive emissive = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_emissive()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_diffuse;
        break;
      }

      // optional .TSCH.Chart3DDiffuseMaterialArchive diffuse = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_diffuse:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_diffuse()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_modulate;
        break;
      }

      // optional .TSCH.Chart3DModulateMaterialArchive modulate = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_modulate:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_modulate()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_specular;
        break;
      }

      // optional .TSCH.Chart3DSpecularMaterialArchive specular = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_specular:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_specular()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_shininess;
        break;
      }

      // optional .TSCH.Chart3DShininessMaterialArchive shininess = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_shininess:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_shininess()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Chart3DPhongMaterialPackageArchive::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .TSCH.Chart3DEmissiveMaterialArchive emissive = 1;
  if (has_emissive()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->emissive(), output);
  }

  // optional .TSCH.Chart3DDiffuseMaterialArchive diffuse = 2;
  if (has_diffuse()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->diffuse(), output);
  }

  // optional .TSCH.Chart3DModulateMaterialArchive modulate = 3;
  if (has_modulate()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->modulate(), output);
  }

  // optional .TSCH.Chart3DSpecularMaterialArchive specular = 4;
  if (has_specular()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->specular(), output);
  }

  // optional .TSCH.Chart3DShininessMaterialArchive shininess = 5;
  if (has_shininess()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, this->shininess(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Chart3DPhongMaterialPackageArchive::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .TSCH.Chart3DEmissiveMaterialArchive emissive = 1;
  if (has_emissive()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->emissive(), target);
  }

  // optional .TSCH.Chart3DDiffuseMaterialArchive diffuse = 2;
  if (has_diffuse()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->diffuse(), target);
  }

  // optional .TSCH.Chart3DModulateMaterialArchive modulate = 3;
  if (has_modulate()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->modulate(), target);
  }

  // optional .TSCH.Chart3DSpecularMaterialArchive specular = 4;
  if (has_specular()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->specular(), target);
  }

  // optional .TSCH.Chart3DShininessMaterialArchive shininess = 5;
  if (has_shininess()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        5, this->shininess(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Chart3DPhongMaterialPackageArchive::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .TSCH.Chart3DEmissiveMaterialArchive emissive = 1;
    if (has_emissive()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->emissive());
    }

    // optional .TSCH.Chart3DDiffuseMaterialArchive diffuse = 2;
    if (has_diffuse()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->diffuse());
    }

    // optional .TSCH.Chart3DModulateMaterialArchive modulate = 3;
    if (has_modulate()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->modulate());
    }

    // optional .TSCH.Chart3DSpecularMaterialArchive specular = 4;
    if (has_specular()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->specular());
    }

    // optional .TSCH.Chart3DShininessMaterialArchive shininess = 5;
    if (has_shininess()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->shininess());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Chart3DPhongMaterialPackageArchive::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Chart3DPhongMaterialPackageArchive* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Chart3DPhongMaterialPackageArchive*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Chart3DPhongMaterialPackageArchive::MergeFrom(const Chart3DPhongMaterialPackageArchive& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_emissive()) {
      mutable_emissive()->::TSCH::Chart3DEmissiveMaterialArchive::MergeFrom(from.emissive());
    }
    if (from.has_diffuse()) {
      mutable_diffuse()->::TSCH::Chart3DDiffuseMaterialArchive::MergeFrom(from.diffuse());
    }
    if (from.has_modulate()) {
      mutable_modulate()->::TSCH::Chart3DModulateMaterialArchive::MergeFrom(from.modulate());
    }
    if (from.has_specular()) {
      mutable_specular()->::TSCH::Chart3DSpecularMaterialArchive::MergeFrom(from.specular());
    }
    if (from.has_shininess()) {
      mutable_shininess()->::TSCH::Chart3DShininessMaterialArchive::MergeFrom(from.shininess());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Chart3DPhongMaterialPackageArchive::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Chart3DPhongMaterialPackageArchive::CopyFrom(const Chart3DPhongMaterialPackageArchive& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Chart3DPhongMaterialPackageArchive::IsInitialized() const {

  if (has_emissive()) {
    if (!this->emissive().IsInitialized()) return false;
  }
  if (has_diffuse()) {
    if (!this->diffuse().IsInitialized()) return false;
  }
  if (has_modulate()) {
    if (!this->modulate().IsInitialized()) return false;
  }
  if (has_specular()) {
    if (!this->specular().IsInitialized()) return false;
  }
  if (has_shininess()) {
    if (!this->shininess().IsInitialized()) return false;
  }
  return true;
}

void Chart3DPhongMaterialPackageArchive::Swap(Chart3DPhongMaterialPackageArchive* other) {
  if (other != this) {
    std::swap(emissive_, other->emissive_);
    std::swap(diffuse_, other->diffuse_);
    std::swap(modulate_, other->modulate_);
    std::swap(specular_, other->specular_);
    std::swap(shininess_, other->shininess_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Chart3DPhongMaterialPackageArchive::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Chart3DPhongMaterialPackageArchive_descriptor_;
  metadata.reflection = Chart3DPhongMaterialPackageArchive_reflection_;
  return metadata;
}

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

#ifndef _MSC_VER
const int Chart3DTSPImageDataTextureArchive::kDataFieldNumber;
const int Chart3DTSPImageDataTextureArchive::kMipmapdataFieldNumber;
const int Chart3DTSPImageDataTextureArchive::kDatabaseDataFieldNumber;
const int Chart3DTSPImageDataTextureArchive::kDatabaseMipmapdataFieldNumber;
#endif  // !_MSC_VER

Chart3DTSPImageDataTextureArchive::Chart3DTSPImageDataTextureArchive()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Chart3DTSPImageDataTextureArchive::InitAsDefaultInstance() {
  data_ = const_cast< ::TSP::DataReference*>(&::TSP::DataReference::default_instance());
  mipmapdata_ = const_cast< ::TSP::DataReference*>(&::TSP::DataReference::default_instance());
  database_data_ = const_cast< ::TSP::Reference*>(&::TSP::Reference::default_instance());
  database_mipmapdata_ = const_cast< ::TSP::Reference*>(&::TSP::Reference::default_instance());
}

Chart3DTSPImageDataTextureArchive::Chart3DTSPImageDataTextureArchive(const Chart3DTSPImageDataTextureArchive& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Chart3DTSPImageDataTextureArchive::SharedCtor() {
  _cached_size_ = 0;
  data_ = NULL;
  mipmapdata_ = NULL;
  database_data_ = NULL;
  database_mipmapdata_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Chart3DTSPImageDataTextureArchive::~Chart3DTSPImageDataTextureArchive() {
  SharedDtor();
}

void Chart3DTSPImageDataTextureArchive::SharedDtor() {
  if (this != default_instance_) {
    delete data_;
    delete mipmapdata_;
    delete database_data_;
    delete database_mipmapdata_;
  }
}

void Chart3DTSPImageDataTextureArchive::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Chart3DTSPImageDataTextureArchive::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Chart3DTSPImageDataTextureArchive_descriptor_;
}

const Chart3DTSPImageDataTextureArchive& Chart3DTSPImageDataTextureArchive::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_TSCH3DArchives_2eproto();
  return *default_instance_;
}

Chart3DTSPImageDataTextureArchive* Chart3DTSPImageDataTextureArchive::default_instance_ = NULL;

Chart3DTSPImageDataTextureArchive* Chart3DTSPImageDataTextureArchive::New() const {
  return new Chart3DTSPImageDataTextureArchive;
}

void Chart3DTSPImageDataTextureArchive::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_data()) {
      if (data_ != NULL) data_->::TSP::DataReference::Clear();
    }
    if (has_mipmapdata()) {
      if (mipmapdata_ != NULL) mipmapdata_->::TSP::DataReference::Clear();
    }
    if (has_database_data()) {
      if (database_data_ != NULL) database_data_->::TSP::Reference::Clear();
    }
    if (has_database_mipmapdata()) {
      if (database_mipmapdata_ != NULL) database_mipmapdata_->::TSP::Reference::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Chart3DTSPImageDataTextureArchive::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .TSP.Reference database_data = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_database_data()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_database_mipmapdata;
        break;
      }

      // optional .TSP.Reference database_mipmapdata = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_database_mipmapdata:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_database_mipmapdata()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_data;
        break;
      }

      // optional .TSP.DataReference data = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_data()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_mipmapdata;
        break;
      }

      // optional .TSP.DataReference mipmapdata = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_mipmapdata:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_mipmapdata()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Chart3DTSPImageDataTextureArchive::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .TSP.Reference database_data = 1;
  if (has_database_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->database_data(), output);
  }

  // optional .TSP.Reference database_mipmapdata = 2;
  if (has_database_mipmapdata()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->database_mipmapdata(), output);
  }

  // optional .TSP.DataReference data = 3;
  if (has_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->data(), output);
  }

  // optional .TSP.DataReference mipmapdata = 4;
  if (has_mipmapdata()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->mipmapdata(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Chart3DTSPImageDataTextureArchive::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .TSP.Reference database_data = 1;
  if (has_database_data()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->database_data(), target);
  }

  // optional .TSP.Reference database_mipmapdata = 2;
  if (has_database_mipmapdata()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->database_mipmapdata(), target);
  }

  // optional .TSP.DataReference data = 3;
  if (has_data()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->data(), target);
  }

  // optional .TSP.DataReference mipmapdata = 4;
  if (has_mipmapdata()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->mipmapdata(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Chart3DTSPImageDataTextureArchive::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .TSP.DataReference data = 3;
    if (has_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->data());
    }

    // optional .TSP.DataReference mipmapdata = 4;
    if (has_mipmapdata()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->mipmapdata());
    }

    // optional .TSP.Reference database_data = 1;
    if (has_database_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->database_data());
    }

    // optional .TSP.Reference database_mipmapdata = 2;
    if (has_database_mipmapdata()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->database_mipmapdata());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Chart3DTSPImageDataTextureArchive::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Chart3DTSPImageDataTextureArchive* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Chart3DTSPImageDataTextureArchive*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Chart3DTSPImageDataTextureArchive::MergeFrom(const Chart3DTSPImageDataTextureArchive& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_data()) {
      mutable_data()->::TSP::DataReference::MergeFrom(from.data());
    }
    if (from.has_mipmapdata()) {
      mutable_mipmapdata()->::TSP::DataReference::MergeFrom(from.mipmapdata());
    }
    if (from.has_database_data()) {
      mutable_database_data()->::TSP::Reference::MergeFrom(from.database_data());
    }
    if (from.has_database_mipmapdata()) {
      mutable_database_mipmapdata()->::TSP::Reference::MergeFrom(from.database_mipmapdata());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Chart3DTSPImageDataTextureArchive::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Chart3DTSPImageDataTextureArchive::CopyFrom(const Chart3DTSPImageDataTextureArchive& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Chart3DTSPImageDataTextureArchive::IsInitialized() const {

  if (has_data()) {
    if (!this->data().IsInitialized()) return false;
  }
  if (has_mipmapdata()) {
    if (!this->mipmapdata().IsInitialized()) return false;
  }
  if (has_database_data()) {
    if (!this->database_data().IsInitialized()) return false;
  }
  if (has_database_mipmapdata()) {
    if (!this->database_mipmapdata().IsInitialized()) return false;
  }
  return true;
}

void Chart3DTSPImageDataTextureArchive::Swap(Chart3DTSPImageDataTextureArchive* other) {
  if (other != this) {
    std::swap(data_, other->data_);
    std::swap(mipmapdata_, other->mipmapdata_);
    std::swap(database_data_, other->database_data_);
    std::swap(database_mipmapdata_, other->database_mipmapdata_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Chart3DTSPImageDataTextureArchive::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Chart3DTSPImageDataTextureArchive_descriptor_;
  metadata.reflection = Chart3DTSPImageDataTextureArchive_reflection_;
  return metadata;
}

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

#ifndef _MSC_VER
const int Chart3DBaseImageTextureTilingArchive::kScaleFieldNumber;
const int Chart3DBaseImageTextureTilingArchive::kRotationFieldNumber;
#endif  // !_MSC_VER

Chart3DBaseImageTextureTilingArchive::Chart3DBaseImageTextureTilingArchive()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Chart3DBaseImageTextureTilingArchive::InitAsDefaultInstance() {
  scale_ = const_cast< ::TSCH::Chart3DVectorArchive*>(&::TSCH::Chart3DVectorArchive::default_instance());
}

Chart3DBaseImageTextureTilingArchive::Chart3DBaseImageTextureTilingArchive(const Chart3DBaseImageTextureTilingArchive& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Chart3DBaseImageTextureTilingArchive::SharedCtor() {
  _cached_size_ = 0;
  scale_ = NULL;
  rotation_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Chart3DBaseImageTextureTilingArchive::~Chart3DBaseImageTextureTilingArchive() {
  SharedDtor();
}

void Chart3DBaseImageTextureTilingArchive::SharedDtor() {
  if (this != default_instance_) {
    delete scale_;
  }
}

void Chart3DBaseImageTextureTilingArchive::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Chart3DBaseImageTextureTilingArchive::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Chart3DBaseImageTextureTilingArchive_descriptor_;
}

const Chart3DBaseImageTextureTilingArchive& Chart3DBaseImageTextureTilingArchive::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_TSCH3DArchives_2eproto();
  return *default_instance_;
}

Chart3DBaseImageTextureTilingArchive* Chart3DBaseImageTextureTilingArchive::default_instance_ = NULL;

Chart3DBaseImageTextureTilingArchive* Chart3DBaseImageTextureTilingArchive::New() const {
  return new Chart3DBaseImageTextureTilingArchive;
}

void Chart3DBaseImageTextureTilingArchive::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_scale()) {
      if (scale_ != NULL) scale_->::TSCH::Chart3DVectorArchive::Clear();
    }
    rotation_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Chart3DBaseImageTextureTilingArchive::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .TSCH.Chart3DVectorArchive scale = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_scale()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(21)) goto parse_rotation;
        break;
      }

      // optional float rotation = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_rotation:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &rotation_)));
          set_has_rotation();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Chart3DBaseImageTextureTilingArchive::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .TSCH.Chart3DVectorArchive scale = 1;
  if (has_scale()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->scale(), output);
  }

  // optional float rotation = 2;
  if (has_rotation()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->rotation(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Chart3DBaseImageTextureTilingArchive::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .TSCH.Chart3DVectorArchive scale = 1;
  if (has_scale()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->scale(), target);
  }

  // optional float rotation = 2;
  if (has_rotation()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->rotation(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Chart3DBaseImageTextureTilingArchive::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .TSCH.Chart3DVectorArchive scale = 1;
    if (has_scale()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->scale());
    }

    // optional float rotation = 2;
    if (has_rotation()) {
      total_size += 1 + 4;
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Chart3DBaseImageTextureTilingArchive::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Chart3DBaseImageTextureTilingArchive* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Chart3DBaseImageTextureTilingArchive*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Chart3DBaseImageTextureTilingArchive::MergeFrom(const Chart3DBaseImageTextureTilingArchive& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_scale()) {
      mutable_scale()->::TSCH::Chart3DVectorArchive::MergeFrom(from.scale());
    }
    if (from.has_rotation()) {
      set_rotation(from.rotation());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Chart3DBaseImageTextureTilingArchive::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Chart3DBaseImageTextureTilingArchive::CopyFrom(const Chart3DBaseImageTextureTilingArchive& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Chart3DBaseImageTextureTilingArchive::IsInitialized() const {

  if (has_scale()) {
    if (!this->scale().IsInitialized()) return false;
  }
  return true;
}

void Chart3DBaseImageTextureTilingArchive::Swap(Chart3DBaseImageTextureTilingArchive* other) {
  if (other != this) {
    std::swap(scale_, other->scale_);
    std::swap(rotation_, other->rotation_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Chart3DBaseImageTextureTilingArchive::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Chart3DBaseImageTextureTilingArchive_descriptor_;
  metadata.reflection = Chart3DBaseImageTextureTilingArchive_reflection_;
  return metadata;
}

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

#ifndef _MSC_VER
const int Chart3DImageTextureTilingArchive::kSuperFieldNumber;
const int Chart3DImageTextureTilingArchive::kModeFieldNumber;
const int Chart3DImageTextureTilingArchive::kWrapFieldNumber;
const int Chart3DImageTextureTilingArchive::kFaceFieldNumber;
const int Chart3DImageTextureTilingArchive::kXpositionFieldNumber;
const int Chart3DImageTextureTilingArchive::kYpositionFieldNumber;
const int Chart3DImageTextureTilingArchive::kScontinuityFieldNumber;
const int Chart3DImageTextureTilingArchive::kTcontinuityFieldNumber;
const int Chart3DImageTextureTilingArchive::kRevealFieldNumber;
#endif  // !_MSC_VER

Chart3DImageTextureTilingArchive::Chart3DImageTextureTilingArchive()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Chart3DImageTextureTilingArchive::InitAsDefaultInstance() {
  super_ = const_cast< ::TSCH::Chart3DBaseImageTextureTilingArchive*>(&::TSCH::Chart3DBaseImageTextureTilingArchive::default_instance());
}

Chart3DImageTextureTilingArchive::Chart3DImageTextureTilingArchive(const Chart3DImageTextureTilingArchive& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Chart3DImageTextureTilingArchive::SharedCtor() {
  _cached_size_ = 0;
  super_ = NULL;
  mode_ = 0;
  wrap_ = 0;
  face_ = 0;
  xposition_ = 0;
  yposition_ = 0;
  scontinuity_ = 0;
  tcontinuity_ = 0;
  reveal_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Chart3DImageTextureTilingArchive::~Chart3DImageTextureTilingArchive() {
  SharedDtor();
}

void Chart3DImageTextureTilingArchive::SharedDtor() {
  if (this != default_instance_) {
    delete super_;
  }
}

void Chart3DImageTextureTilingArchive::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Chart3DImageTextureTilingArchive::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Chart3DImageTextureTilingArchive_descriptor_;
}

const Chart3DImageTextureTilingArchive& Chart3DImageTextureTilingArchive::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_TSCH3DArchives_2eproto();
  return *default_instance_;
}

Chart3DImageTextureTilingArchive* Chart3DImageTextureTilingArchive::default_instance_ = NULL;

Chart3DImageTextureTilingArchive* Chart3DImageTextureTilingArchive::New() const {
  return new Chart3DImageTextureTilingArchive;
}

void Chart3DImageTextureTilingArchive::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_super()) {
      if (super_ != NULL) super_->::TSCH::Chart3DBaseImageTextureTilingArchive::Clear();
    }
    mode_ = 0;
    wrap_ = 0;
    face_ = 0;
    xposition_ = 0;
    yposition_ = 0;
    scontinuity_ = 0;
    tcontinuity_ = 0;
  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    reveal_ = false;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Chart3DImageTextureTilingArchive::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .TSCH.Chart3DBaseImageTextureTilingArchive super = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_super()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_mode;
        break;
      }

      // optional .TSCH.TextureTilingMode mode = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_mode:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::TSCH::TextureTilingMode_IsValid(value)) {
            set_mode(static_cast< ::TSCH::TextureTilingMode >(value));
          } else {
            mutable_unknown_fields()->AddVarint(2, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_wrap;
        break;
      }

      // optional .TSCH.TextureTilingWrap wrap = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_wrap:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::TSCH::TextureTilingWrap_IsValid(value)) {
            set_wrap(static_cast< ::TSCH::TextureTilingWrap >(value));
          } else {
            mutable_unknown_fields()->AddVarint(3, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_face;
        break;
      }

      // optional .TSCH.TextureTilingFace face = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_face:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::TSCH::TextureTilingFace_IsValid(value)) {
            set_face(static_cast< ::TSCH::TextureTilingFace >(value));
          } else {
            mutable_unknown_fields()->AddVarint(4, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_xposition;
        break;
      }

      // optional .TSCH.TextureTilingXPosition xposition = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_xposition:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::TSCH::TextureTilingXPosition_IsValid(value)) {
            set_xposition(static_cast< ::TSCH::TextureTilingXPosition >(value));
          } else {
            mutable_unknown_fields()->AddVarint(5, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_yposition;
        break;
      }

      // optional .TSCH.TextureTilingYPosition yposition = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_yposition:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::TSCH::TextureTilingYPosition_IsValid(value)) {
            set_yposition(static_cast< ::TSCH::TextureTilingYPosition >(value));
          } else {
            mutable_unknown_fields()->AddVarint(6, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(56)) goto parse_scontinuity;
        break;
      }

      // optional .TSCH.TextureTilingContinuity scontinuity = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_scontinuity:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::TSCH::TextureTilingContinuity_IsValid(value)) {
            set_scontinuity(static_cast< ::TSCH::TextureTilingContinuity >(value));
          } else {
            mutable_unknown_fields()->AddVarint(7, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(64)) goto parse_tcontinuity;
        break;
      }

      // optional .TSCH.TextureTilingContinuity tcontinuity = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_tcontinuity:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::TSCH::TextureTilingContinuity_IsValid(value)) {
            set_tcontinuity(static_cast< ::TSCH::TextureTilingContinuity >(value));
          } else {
            mutable_unknown_fields()->AddVarint(8, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(72)) goto parse_reveal;
        break;
      }

      // optional bool reveal = 9;
      case 9: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_reveal:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &reveal_)));
          set_has_reveal();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Chart3DImageTextureTilingArchive::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .TSCH.Chart3DBaseImageTextureTilingArchive super = 1;
  if (has_super()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->super(), output);
  }

  // optional .TSCH.TextureTilingMode mode = 2;
  if (has_mode()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->mode(), output);
  }

  // optional .TSCH.TextureTilingWrap wrap = 3;
  if (has_wrap()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->wrap(), output);
  }

  // optional .TSCH.TextureTilingFace face = 4;
  if (has_face()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      4, this->face(), output);
  }

  // optional .TSCH.TextureTilingXPosition xposition = 5;
  if (has_xposition()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      5, this->xposition(), output);
  }

  // optional .TSCH.TextureTilingYPosition yposition = 6;
  if (has_yposition()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      6, this->yposition(), output);
  }

  // optional .TSCH.TextureTilingContinuity scontinuity = 7;
  if (has_scontinuity()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      7, this->scontinuity(), output);
  }

  // optional .TSCH.TextureTilingContinuity tcontinuity = 8;
  if (has_tcontinuity()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      8, this->tcontinuity(), output);
  }

  // optional bool reveal = 9;
  if (has_reveal()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->reveal(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Chart3DImageTextureTilingArchive::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .TSCH.Chart3DBaseImageTextureTilingArchive super = 1;
  if (has_super()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->super(), target);
  }

  // optional .TSCH.TextureTilingMode mode = 2;
  if (has_mode()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      2, this->mode(), target);
  }

  // optional .TSCH.TextureTilingWrap wrap = 3;
  if (has_wrap()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      3, this->wrap(), target);
  }

  // optional .TSCH.TextureTilingFace face = 4;
  if (has_face()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      4, this->face(), target);
  }

  // optional .TSCH.TextureTilingXPosition xposition = 5;
  if (has_xposition()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      5, this->xposition(), target);
  }

  // optional .TSCH.TextureTilingYPosition yposition = 6;
  if (has_yposition()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      6, this->yposition(), target);
  }

  // optional .TSCH.TextureTilingContinuity scontinuity = 7;
  if (has_scontinuity()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      7, this->scontinuity(), target);
  }

  // optional .TSCH.TextureTilingContinuity tcontinuity = 8;
  if (has_tcontinuity()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      8, this->tcontinuity(), target);
  }

  // optional bool reveal = 9;
  if (has_reveal()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(9, this->reveal(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Chart3DImageTextureTilingArchive::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .TSCH.Chart3DBaseImageTextureTilingArchive super = 1;
    if (has_super()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->super());
    }

    // optional .TSCH.TextureTilingMode mode = 2;
    if (has_mode()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->mode());
    }

    // optional .TSCH.TextureTilingWrap wrap = 3;
    if (has_wrap()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->wrap());
    }

    // optional .TSCH.TextureTilingFace face = 4;
    if (has_face()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->face());
    }

    // optional .TSCH.TextureTilingXPosition xposition = 5;
    if (has_xposition()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->xposition());
    }

    // optional .TSCH.TextureTilingYPosition yposition = 6;
    if (has_yposition()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->yposition());
    }

    // optional .TSCH.TextureTilingContinuity scontinuity = 7;
    if (has_scontinuity()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->scontinuity());
    }

    // optional .TSCH.TextureTilingContinuity tcontinuity = 8;
    if (has_tcontinuity()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->tcontinuity());
    }

  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    // optional bool reveal = 9;
    if (has_reveal()) {
      total_size += 1 + 1;
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Chart3DImageTextureTilingArchive::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Chart3DImageTextureTilingArchive* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Chart3DImageTextureTilingArchive*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Chart3DImageTextureTilingArchive::MergeFrom(const Chart3DImageTextureTilingArchive& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_super()) {
      mutable_super()->::TSCH::Chart3DBaseImageTextureTilingArchive::MergeFrom(from.super());
    }
    if (from.has_mode()) {
      set_mode(from.mode());
    }
    if (from.has_wrap()) {
      set_wrap(from.wrap());
    }
    if (from.has_face()) {
      set_face(from.face());
    }
    if (from.has_xposition()) {
      set_xposition(from.xposition());
    }
    if (from.has_yposition()) {
      set_yposition(from.yposition());
    }
    if (from.has_scontinuity()) {
      set_scontinuity(from.scontinuity());
    }
    if (from.has_tcontinuity()) {
      set_tcontinuity(from.tcontinuity());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_reveal()) {
      set_reveal(from.reveal());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Chart3DImageTextureTilingArchive::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Chart3DImageTextureTilingArchive::CopyFrom(const Chart3DImageTextureTilingArchive& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Chart3DImageTextureTilingArchive::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (has_super()) {
    if (!this->super().IsInitialized()) return false;
  }
  return true;
}

void Chart3DImageTextureTilingArchive::Swap(Chart3DImageTextureTilingArchive* other) {
  if (other != this) {
    std::swap(super_, other->super_);
    std::swap(mode_, other->mode_);
    std::swap(wrap_, other->wrap_);
    std::swap(face_, other->face_);
    std::swap(xposition_, other->xposition_);
    std::swap(yposition_, other->yposition_);
    std::swap(scontinuity_, other->scontinuity_);
    std::swap(tcontinuity_, other->tcontinuity_);
    std::swap(reveal_, other->reveal_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Chart3DImageTextureTilingArchive::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Chart3DImageTextureTilingArchive_descriptor_;
  metadata.reflection = Chart3DImageTextureTilingArchive_reflection_;
  return metadata;
}

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

#ifndef _MSC_VER
const int Chart3DVectorArchive::kXFieldNumber;
const int Chart3DVectorArchive::kYFieldNumber;
const int Chart3DVectorArchive::kZFieldNumber;
const int Chart3DVectorArchive::kWFieldNumber;
#endif  // !_MSC_VER

Chart3DVectorArchive::Chart3DVectorArchive()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Chart3DVectorArchive::InitAsDefaultInstance() {
}

Chart3DVectorArchive::Chart3DVectorArchive(const Chart3DVectorArchive& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Chart3DVectorArchive::SharedCtor() {
  _cached_size_ = 0;
  x_ = 0;
  y_ = 0;
  z_ = 0;
  w_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Chart3DVectorArchive::~Chart3DVectorArchive() {
  SharedDtor();
}

void Chart3DVectorArchive::SharedDtor() {
  if (this != default_instance_) {
  }
}

void Chart3DVectorArchive::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Chart3DVectorArchive::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Chart3DVectorArchive_descriptor_;
}

const Chart3DVectorArchive& Chart3DVectorArchive::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_TSCH3DArchives_2eproto();
  return *default_instance_;
}

Chart3DVectorArchive* Chart3DVectorArchive::default_instance_ = NULL;

Chart3DVectorArchive* Chart3DVectorArchive::New() const {
  return new Chart3DVectorArchive;
}

void Chart3DVectorArchive::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    x_ = 0;
    y_ = 0;
    z_ = 0;
    w_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Chart3DVectorArchive::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required float x = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &x_)));
          set_has_x();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(21)) goto parse_y;
        break;
      }

      // required float y = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_y:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &y_)));
          set_has_y();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(29)) goto parse_z;
        break;
      }

      // required float z = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_z:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &z_)));
          set_has_z();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(37)) goto parse_w;
        break;
      }

      // required float w = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_w:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &w_)));
          set_has_w();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Chart3DVectorArchive::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required float x = 1;
  if (has_x()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->x(), output);
  }

  // required float y = 2;
  if (has_y()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->y(), output);
  }

  // required float z = 3;
  if (has_z()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->z(), output);
  }

  // required float w = 4;
  if (has_w()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->w(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Chart3DVectorArchive::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required float x = 1;
  if (has_x()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->x(), target);
  }

  // required float y = 2;
  if (has_y()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->y(), target);
  }

  // required float z = 3;
  if (has_z()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->z(), target);
  }

  // required float w = 4;
  if (has_w()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->w(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Chart3DVectorArchive::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required float x = 1;
    if (has_x()) {
      total_size += 1 + 4;
    }

    // required float y = 2;
    if (has_y()) {
      total_size += 1 + 4;
    }

    // required float z = 3;
    if (has_z()) {
      total_size += 1 + 4;
    }

    // required float w = 4;
    if (has_w()) {
      total_size += 1 + 4;
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Chart3DVectorArchive::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Chart3DVectorArchive* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Chart3DVectorArchive*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Chart3DVectorArchive::MergeFrom(const Chart3DVectorArchive& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_x()) {
      set_x(from.x());
    }
    if (from.has_y()) {
      set_y(from.y());
    }
    if (from.has_z()) {
      set_z(from.z());
    }
    if (from.has_w()) {
      set_w(from.w());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Chart3DVectorArchive::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Chart3DVectorArchive::CopyFrom(const Chart3DVectorArchive& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Chart3DVectorArchive::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;

  return true;
}

void Chart3DVectorArchive::Swap(Chart3DVectorArchive* other) {
  if (other != this) {
    std::swap(x_, other->x_);
    std::swap(y_, other->y_);
    std::swap(z_, other->z_);
    std::swap(w_, other->w_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Chart3DVectorArchive::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Chart3DVectorArchive_descriptor_;
  metadata.reflection = Chart3DVectorArchive_reflection_;
  return metadata;
}

::google::protobuf::internal::ExtensionIdentifier< ::TSD::FillArchive,
    ::google::protobuf::internal::MessageTypeTraits< ::TSCH::Chart3DFillArchive >, 11, false >
  fill3d(kFill3DFieldNumber, ::TSCH::Chart3DFillArchive::default_instance());

// @@protoc_insertion_point(namespace_scope)

}  // namespace TSCH

// @@protoc_insertion_point(global_scope)

redpajama_set_name: RedPajamaGithub