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

#include "rocktree.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG
namespace geo_globetrotter_proto_rocktree {
constexpr BulkMetadataRequest::BulkMetadataRequest(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : node_key_(nullptr){}
struct BulkMetadataRequestDefaultTypeInternal {
  constexpr BulkMetadataRequestDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~BulkMetadataRequestDefaultTypeInternal() {}
  union {
    BulkMetadataRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BulkMetadataRequestDefaultTypeInternal _BulkMetadataRequest_default_instance_;
constexpr NodeDataRequest::NodeDataRequest(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : node_key_(nullptr)
  , imagery_epoch_(0u)
  , texture_format_(1)
{}
struct NodeDataRequestDefaultTypeInternal {
  constexpr NodeDataRequestDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~NodeDataRequestDefaultTypeInternal() {}
  union {
    NodeDataRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NodeDataRequestDefaultTypeInternal _NodeDataRequest_default_instance_;
constexpr NodeKey::NodeKey(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : path_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , epoch_(0u){}
struct NodeKeyDefaultTypeInternal {
  constexpr NodeKeyDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~NodeKeyDefaultTypeInternal() {}
  union {
    NodeKey _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NodeKeyDefaultTypeInternal _NodeKey_default_instance_;
constexpr CopyrightRequest::CopyrightRequest(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : epoch_(0u){}
struct CopyrightRequestDefaultTypeInternal {
  constexpr CopyrightRequestDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~CopyrightRequestDefaultTypeInternal() {}
  union {
    CopyrightRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CopyrightRequestDefaultTypeInternal _CopyrightRequest_default_instance_;
constexpr TextureDataRequest::TextureDataRequest(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : node_key_(nullptr)
  , view_direction_(0)

  , texture_format_(1)
{}
struct TextureDataRequestDefaultTypeInternal {
  constexpr TextureDataRequestDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~TextureDataRequestDefaultTypeInternal() {}
  union {
    TextureDataRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT TextureDataRequestDefaultTypeInternal _TextureDataRequest_default_instance_;
constexpr BulkMetadata::BulkMetadata(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : node_metadata_()
  , head_node_center_()
  , meters_per_texel_()
  , head_node_key_(nullptr)
  , default_imagery_epoch_(0u)
  , default_available_texture_formats_(0u)
  , default_available_view_dependent_textures_(0u)
  , default_available_view_dependent_texture_formats_(0u){}
struct BulkMetadataDefaultTypeInternal {
  constexpr BulkMetadataDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~BulkMetadataDefaultTypeInternal() {}
  union {
    BulkMetadata _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BulkMetadataDefaultTypeInternal _BulkMetadata_default_instance_;
constexpr NodeMetadata::NodeMetadata(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : processing_oriented_bounding_box_()
  , oriented_bounding_box_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , path_and_flags_(0u)
  , epoch_(0u)
  , meters_per_texel_(0)
  , bulk_metadata_epoch_(0u)
  , imagery_epoch_(0u)
  , available_texture_formats_(0u)
  , available_view_dependent_textures_(0u)
  , available_view_dependent_texture_formats_(0u){}
struct NodeMetadataDefaultTypeInternal {
  constexpr NodeMetadataDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~NodeMetadataDefaultTypeInternal() {}
  union {
    NodeMetadata _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NodeMetadataDefaultTypeInternal _NodeMetadata_default_instance_;
constexpr NodeData::NodeData(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : matrix_globe_from_mesh_()
  , meshes_()
  , copyright_ids_()
  , kml_bounding_box_()
  , overlay_surface_meshes_()
  , for_normals_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , node_key_(nullptr)
  , water_mesh_(nullptr){}
struct NodeDataDefaultTypeInternal {
  constexpr NodeDataDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~NodeDataDefaultTypeInternal() {}
  union {
    NodeData _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NodeDataDefaultTypeInternal _NodeData_default_instance_;
constexpr Mesh::Mesh(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : texture_()
  , uv_offset_and_scale_()
  , vertices_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , texture_coords_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , indices_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , octant_ranges_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , layer_counts_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , texture_coordinates_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , layer_and_octant_counts_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , vertex_alphas_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , normals_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , skirt_flags_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , normals_dev_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , mesh_id_(0u){}
struct MeshDefaultTypeInternal {
  constexpr MeshDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MeshDefaultTypeInternal() {}
  union {
    Mesh _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MeshDefaultTypeInternal _Mesh_default_instance_;
constexpr Texture::Texture(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : data_()
  , view_direction_(0)

  , mesh_id_(0u)
  , height_(256u)
  , format_(1)

  , width_(256u){}
struct TextureDefaultTypeInternal {
  constexpr TextureDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~TextureDefaultTypeInternal() {}
  union {
    Texture _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT TextureDefaultTypeInternal _Texture_default_instance_;
constexpr TextureData::TextureData(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : textures_()
  , node_key_(nullptr){}
struct TextureDataDefaultTypeInternal {
  constexpr TextureDataDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~TextureDataDefaultTypeInternal() {}
  union {
    TextureData _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT TextureDataDefaultTypeInternal _TextureData_default_instance_;
constexpr Copyrights::Copyrights(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : copyrights_(){}
struct CopyrightsDefaultTypeInternal {
  constexpr CopyrightsDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~CopyrightsDefaultTypeInternal() {}
  union {
    Copyrights _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CopyrightsDefaultTypeInternal _Copyrights_default_instance_;
constexpr Copyright::Copyright(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : text_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , text_clean_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , id_(0u){}
struct CopyrightDefaultTypeInternal {
  constexpr CopyrightDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~CopyrightDefaultTypeInternal() {}
  union {
    Copyright _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CopyrightDefaultTypeInternal _Copyright_default_instance_;
constexpr PlanetoidMetadata::PlanetoidMetadata(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : root_node_metadata_(nullptr)
  , radius_(0)
  , min_terrain_altitude_(0)
  , max_terrain_altitude_(0){}
struct PlanetoidMetadataDefaultTypeInternal {
  constexpr PlanetoidMetadataDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~PlanetoidMetadataDefaultTypeInternal() {}
  union {
    PlanetoidMetadata _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PlanetoidMetadataDefaultTypeInternal _PlanetoidMetadata_default_instance_;
}  // namespace geo_globetrotter_proto_rocktree
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_rocktree_2eproto[14];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_rocktree_2eproto[5];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_rocktree_2eproto = nullptr;

const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_rocktree_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::BulkMetadataRequest, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::BulkMetadataRequest, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::BulkMetadataRequest, node_key_),
  0,
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeDataRequest, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeDataRequest, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeDataRequest, node_key_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeDataRequest, texture_format_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeDataRequest, imagery_epoch_),
  0,
  2,
  1,
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeKey, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeKey, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeKey, path_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeKey, epoch_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::CopyrightRequest, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::CopyrightRequest, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::CopyrightRequest, epoch_),
  0,
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::TextureDataRequest, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::TextureDataRequest, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::TextureDataRequest, node_key_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::TextureDataRequest, texture_format_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::TextureDataRequest, view_direction_),
  0,
  2,
  1,
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::BulkMetadata, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::BulkMetadata, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::BulkMetadata, node_metadata_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::BulkMetadata, head_node_key_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::BulkMetadata, head_node_center_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::BulkMetadata, meters_per_texel_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::BulkMetadata, default_imagery_epoch_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::BulkMetadata, default_available_texture_formats_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::BulkMetadata, default_available_view_dependent_textures_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::BulkMetadata, default_available_view_dependent_texture_formats_),
  ~0u,
  0,
  ~0u,
  ~0u,
  1,
  2,
  3,
  4,
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeMetadata, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeMetadata, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeMetadata, path_and_flags_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeMetadata, epoch_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeMetadata, bulk_metadata_epoch_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeMetadata, oriented_bounding_box_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeMetadata, meters_per_texel_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeMetadata, processing_oriented_bounding_box_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeMetadata, imagery_epoch_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeMetadata, available_texture_formats_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeMetadata, available_view_dependent_textures_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeMetadata, available_view_dependent_texture_formats_),
  1,
  2,
  4,
  0,
  3,
  ~0u,
  5,
  6,
  7,
  8,
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeData, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeData, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeData, matrix_globe_from_mesh_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeData, meshes_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeData, copyright_ids_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeData, node_key_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeData, kml_bounding_box_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeData, water_mesh_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeData, overlay_surface_meshes_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::NodeData, for_normals_),
  ~0u,
  ~0u,
  ~0u,
  1,
  ~0u,
  2,
  ~0u,
  0,
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Mesh, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Mesh, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Mesh, vertices_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Mesh, vertex_alphas_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Mesh, texture_coords_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Mesh, indices_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Mesh, octant_ranges_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Mesh, layer_counts_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Mesh, texture_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Mesh, texture_coordinates_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Mesh, uv_offset_and_scale_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Mesh, layer_and_octant_counts_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Mesh, normals_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Mesh, normals_dev_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Mesh, mesh_id_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Mesh, skirt_flags_),
  0,
  7,
  1,
  2,
  3,
  4,
  ~0u,
  5,
  ~0u,
  6,
  8,
  10,
  11,
  9,
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Texture, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Texture, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Texture, data_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Texture, format_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Texture, width_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Texture, height_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Texture, view_direction_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Texture, mesh_id_),
  ~0u,
  3,
  4,
  2,
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::TextureData, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::TextureData, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::TextureData, node_key_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::TextureData, textures_),
  0,
  ~0u,
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Copyrights, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Copyrights, copyrights_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Copyright, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Copyright, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Copyright, id_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Copyright, text_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::Copyright, text_clean_),
  2,
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::PlanetoidMetadata, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::PlanetoidMetadata, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::PlanetoidMetadata, root_node_metadata_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::PlanetoidMetadata, radius_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::PlanetoidMetadata, min_terrain_altitude_),
  PROTOBUF_FIELD_OFFSET(::geo_globetrotter_proto_rocktree::PlanetoidMetadata, max_terrain_altitude_),
  0,
  1,
  2,
  3,
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 6, sizeof(::geo_globetrotter_proto_rocktree::BulkMetadataRequest)},
  { 7, 15, sizeof(::geo_globetrotter_proto_rocktree::NodeDataRequest)},
  { 18, 25, sizeof(::geo_globetrotter_proto_rocktree::NodeKey)},
  { 27, 33, sizeof(::geo_globetrotter_proto_rocktree::CopyrightRequest)},
  { 34, 42, sizeof(::geo_globetrotter_proto_rocktree::TextureDataRequest)},
  { 45, 58, sizeof(::geo_globetrotter_proto_rocktree::BulkMetadata)},
  { 66, 81, sizeof(::geo_globetrotter_proto_rocktree::NodeMetadata)},
  { 91, 104, sizeof(::geo_globetrotter_proto_rocktree::NodeData)},
  { 112, 131, sizeof(::geo_globetrotter_proto_rocktree::Mesh)},
  { 145, 156, sizeof(::geo_globetrotter_proto_rocktree::Texture)},
  { 162, 169, sizeof(::geo_globetrotter_proto_rocktree::TextureData)},
  { 171, -1, sizeof(::geo_globetrotter_proto_rocktree::Copyrights)},
  { 177, 185, sizeof(::geo_globetrotter_proto_rocktree::Copyright)},
  { 188, 197, sizeof(::geo_globetrotter_proto_rocktree::PlanetoidMetadata)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::geo_globetrotter_proto_rocktree::_BulkMetadataRequest_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::geo_globetrotter_proto_rocktree::_NodeDataRequest_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::geo_globetrotter_proto_rocktree::_NodeKey_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::geo_globetrotter_proto_rocktree::_CopyrightRequest_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::geo_globetrotter_proto_rocktree::_TextureDataRequest_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::geo_globetrotter_proto_rocktree::_BulkMetadata_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::geo_globetrotter_proto_rocktree::_NodeMetadata_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::geo_globetrotter_proto_rocktree::_NodeData_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::geo_globetrotter_proto_rocktree::_Mesh_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::geo_globetrotter_proto_rocktree::_Texture_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::geo_globetrotter_proto_rocktree::_TextureData_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::geo_globetrotter_proto_rocktree::_Copyrights_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::geo_globetrotter_proto_rocktree::_Copyright_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::geo_globetrotter_proto_rocktree::_PlanetoidMetadata_default_instance_),
};

const char descriptor_table_protodef_rocktree_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n\016rocktree.proto\022\037geo_globetrotter_proto"
  "_rocktree\"Q\n\023BulkMetadataRequest\022:\n\010node"
  "_key\030\001 \001(\0132(.geo_globetrotter_proto_rock"
  "tree.NodeKey\"\255\001\n\017NodeDataRequest\022:\n\010node"
  "_key\030\001 \001(\0132(.geo_globetrotter_proto_rock"
  "tree.NodeKey\022G\n\016texture_format\030\002 \001(\0162/.g"
  "eo_globetrotter_proto_rocktree.Texture.F"
  "ormat\022\025\n\rimagery_epoch\030\003 \001(\r\"&\n\007NodeKey\022"
  "\014\n\004path\030\001 \001(\t\022\r\n\005epoch\030\002 \001(\r\"!\n\020Copyrigh"
  "tRequest\022\r\n\005epoch\030\001 \001(\r\"\351\001\n\022TextureDataR"
  "equest\022:\n\010node_key\030\001 \001(\0132(.geo_globetrot"
  "ter_proto_rocktree.NodeKey\022G\n\016texture_fo"
  "rmat\030\002 \001(\0162/.geo_globetrotter_proto_rock"
  "tree.Texture.Format\022N\n\016view_direction\030\003 "
  "\001(\01626.geo_globetrotter_proto_rocktree.Te"
  "xture.ViewDirection\"\210\003\n\014BulkMetadata\022D\n\r"
  "node_metadata\030\001 \003(\0132-.geo_globetrotter_p"
  "roto_rocktree.NodeMetadata\022\?\n\rhead_node_"
  "key\030\002 \001(\0132(.geo_globetrotter_proto_rockt"
  "ree.NodeKey\022\034\n\020head_node_center\030\003 \003(\001B\002\020"
  "\001\022\034\n\020meters_per_texel\030\004 \003(\002B\002\020\001\022\035\n\025defau"
  "lt_imagery_epoch\030\005 \001(\r\022)\n!default_availa"
  "ble_texture_formats\030\006 \001(\r\0221\n)default_ava"
  "ilable_view_dependent_textures\030\007 \001(\r\0228\n0"
  "default_available_view_dependent_texture"
  "_formats\030\010 \001(\r\"\252\003\n\014NodeMetadata\022\026\n\016path_"
  "and_flags\030\001 \001(\r\022\r\n\005epoch\030\002 \001(\r\022\033\n\023bulk_m"
  "etadata_epoch\030\005 \001(\r\022\035\n\025oriented_bounding"
  "_box\030\003 \001(\014\022\030\n\020meters_per_texel\030\004 \001(\002\022,\n "
  "processing_oriented_bounding_box\030\006 \003(\001B\002"
  "\020\001\022\025\n\rimagery_epoch\030\007 \001(\r\022!\n\031available_t"
  "exture_formats\030\010 \001(\r\022)\n!available_view_d"
  "ependent_textures\030\t \001(\r\0220\n(available_vie"
  "w_dependent_texture_formats\030\n \001(\r\"X\n\005Fla"
  "gs\022\017\n\013RICH3D_LEAF\020\001\022\021\n\rRICH3D_NODATA\020\002\022\010"
  "\n\004LEAF\020\004\022\n\n\006NODATA\020\010\022\025\n\021USE_IMAGERY_EPOC"
  "H\020\020\"\355\002\n\010NodeData\022\"\n\026matrix_globe_from_me"
  "sh\030\001 \003(\001B\002\020\001\0225\n\006meshes\030\002 \003(\0132%.geo_globe"
  "trotter_proto_rocktree.Mesh\022\025\n\rcopyright"
  "_ids\030\003 \003(\r\022:\n\010node_key\030\004 \001(\0132(.geo_globe"
  "trotter_proto_rocktree.NodeKey\022\034\n\020kml_bo"
  "unding_box\030\005 \003(\001B\002\020\001\0229\n\nwater_mesh\030\006 \001(\013"
  "2%.geo_globetrotter_proto_rocktree.Mesh\022"
  "E\n\026overlay_surface_meshes\030\007 \003(\0132%.geo_gl"
  "obetrotter_proto_rocktree.Mesh\022\023\n\013for_no"
  "rmals\030\010 \001(\014\"\241\005\n\004Mesh\022\020\n\010vertices\030\001 \001(\014\022\025"
  "\n\rvertex_alphas\030\t \001(\014\022\026\n\016texture_coords\030"
  "\002 \001(\014\022\017\n\007indices\030\003 \001(\014\022\025\n\roctant_ranges\030"
  "\004 \001(\014\022\024\n\014layer_counts\030\005 \001(\014\0229\n\007texture\030\006"
  " \003(\0132(.geo_globetrotter_proto_rocktree.T"
  "exture\022\033\n\023texture_coordinates\030\007 \001(\014\022\037\n\023u"
  "v_offset_and_scale\030\n \003(\002B\002\020\001\022\037\n\027layer_an"
  "d_octant_counts\030\010 \001(\014\022\017\n\007normals\030\013 \001(\014\022\023"
  "\n\013normals_dev\030\020 \001(\014\022\017\n\007mesh_id\030\014 \001(\r\022\023\n\013"
  "skirt_flags\030\r \001(\014\"\326\001\n\005Layer\022\016\n\nOVERGROUN"
  "D\020\000\022\027\n\023TERRAIN_BELOW_WATER\020\001\022\027\n\023TERRAIN_"
  "ABOVE_WATER\020\002\022\022\n\016TERRAIN_HIDDEN\020\003\022\t\n\005WAT"
  "ER\020\004\022\020\n\014WATER_SKIRTS\020\005\022\031\n\025WATER_SKIRTS_I"
  "NVERTED\020\006\022\023\n\017OVERLAY_SURFACE\020\007\022\032\n\026OVERLA"
  "Y_SURFACE_SKIRTS\020\010\022\016\n\nNUM_LAYERS\020\t\"[\n\tLa"
  "yerMask\022\033\n\027TERRAIN_WITH_OVERGROUND\020\007\022\026\n\022"
  "TERRAIN_WITH_WATER\020\034\022\031\n\025TERRAIN_WITHOUT_"
  "WATER\020\016\"\201\003\n\007Texture\022\014\n\004data\030\001 \003(\014\022\?\n\006for"
  "mat\030\002 \001(\0162/.geo_globetrotter_proto_rockt"
  "ree.Texture.Format\022\022\n\005width\030\003 \001(\r:\003256\022\023"
  "\n\006height\030\004 \001(\r:\003256\022N\n\016view_direction\030\005 "
  "\001(\01626.geo_globetrotter_proto_rocktree.Te"
  "xture.ViewDirection\022\017\n\007mesh_id\030\006 \001(\r\"K\n\006"
  "Format\022\007\n\003JPG\020\001\022\010\n\004DXT1\020\002\022\010\n\004ETC1\020\003\022\n\n\006P"
  "VRTC2\020\004\022\n\n\006PVRTC4\020\005\022\014\n\010CRN_DXT1\020\006\"P\n\rVie"
  "wDirection\022\t\n\005NADIR\020\000\022\014\n\010NORTH_45\020\001\022\013\n\007E"
  "AST_45\020\002\022\014\n\010SOUTH_45\020\003\022\013\n\007WEST_45\020\004\"\205\001\n\013"
  "TextureData\022:\n\010node_key\030\001 \001(\0132(.geo_glob"
  "etrotter_proto_rocktree.NodeKey\022:\n\010textu"
  "res\030\002 \003(\0132(.geo_globetrotter_proto_rockt"
  "ree.Texture\"L\n\nCopyrights\022>\n\ncopyrights\030"
  "\001 \003(\0132*.geo_globetrotter_proto_rocktree."
  "Copyright\"9\n\tCopyright\022\n\n\002id\030\001 \001(\r\022\014\n\004te"
  "xt\030\002 \001(\t\022\022\n\ntext_clean\030\003 \001(\t\"\252\001\n\021Planeto"
  "idMetadata\022I\n\022root_node_metadata\030\001 \001(\0132-"
  ".geo_globetrotter_proto_rocktree.NodeMet"
  "adata\022\016\n\006radius\030\002 \001(\002\022\034\n\024min_terrain_alt"
  "itude\030\003 \001(\002\022\034\n\024max_terrain_altitude\030\004 \001("
  "\002"
  ;
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_rocktree_2eproto_once;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_rocktree_2eproto = {
  false, false, 3321, descriptor_table_protodef_rocktree_2eproto, "rocktree.proto", 
  &descriptor_table_rocktree_2eproto_once, nullptr, 0, 14,
  schemas, file_default_instances, TableStruct_rocktree_2eproto::offsets,
  file_level_metadata_rocktree_2eproto, file_level_enum_descriptors_rocktree_2eproto, file_level_service_descriptors_rocktree_2eproto,
};
PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_rocktree_2eproto_getter() {
  return &descriptor_table_rocktree_2eproto;
}

// Force running AddDescriptors() at dynamic initialization time.
PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_rocktree_2eproto(&descriptor_table_rocktree_2eproto);
namespace geo_globetrotter_proto_rocktree {
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NodeMetadata_Flags_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_rocktree_2eproto);
  return file_level_enum_descriptors_rocktree_2eproto[0];
}
bool NodeMetadata_Flags_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 4:
    case 8:
    case 16:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr NodeMetadata_Flags NodeMetadata::RICH3D_LEAF;
constexpr NodeMetadata_Flags NodeMetadata::RICH3D_NODATA;
constexpr NodeMetadata_Flags NodeMetadata::LEAF;
constexpr NodeMetadata_Flags NodeMetadata::NODATA;
constexpr NodeMetadata_Flags NodeMetadata::USE_IMAGERY_EPOCH;
constexpr NodeMetadata_Flags NodeMetadata::Flags_MIN;
constexpr NodeMetadata_Flags NodeMetadata::Flags_MAX;
constexpr int NodeMetadata::Flags_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Mesh_Layer_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_rocktree_2eproto);
  return file_level_enum_descriptors_rocktree_2eproto[1];
}
bool Mesh_Layer_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr Mesh_Layer Mesh::OVERGROUND;
constexpr Mesh_Layer Mesh::TERRAIN_BELOW_WATER;
constexpr Mesh_Layer Mesh::TERRAIN_ABOVE_WATER;
constexpr Mesh_Layer Mesh::TERRAIN_HIDDEN;
constexpr Mesh_Layer Mesh::WATER;
constexpr Mesh_Layer Mesh::WATER_SKIRTS;
constexpr Mesh_Layer Mesh::WATER_SKIRTS_INVERTED;
constexpr Mesh_Layer Mesh::OVERLAY_SURFACE;
constexpr Mesh_Layer Mesh::OVERLAY_SURFACE_SKIRTS;
constexpr Mesh_Layer Mesh::NUM_LAYERS;
constexpr Mesh_Layer Mesh::Layer_MIN;
constexpr Mesh_Layer Mesh::Layer_MAX;
constexpr int Mesh::Layer_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Mesh_LayerMask_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_rocktree_2eproto);
  return file_level_enum_descriptors_rocktree_2eproto[2];
}
bool Mesh_LayerMask_IsValid(int value) {
  switch (value) {
    case 7:
    case 14:
    case 28:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr Mesh_LayerMask Mesh::TERRAIN_WITH_OVERGROUND;
constexpr Mesh_LayerMask Mesh::TERRAIN_WITH_WATER;
constexpr Mesh_LayerMask Mesh::TERRAIN_WITHOUT_WATER;
constexpr Mesh_LayerMask Mesh::LayerMask_MIN;
constexpr Mesh_LayerMask Mesh::LayerMask_MAX;
constexpr int Mesh::LayerMask_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Texture_Format_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_rocktree_2eproto);
  return file_level_enum_descriptors_rocktree_2eproto[3];
}
bool Texture_Format_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr Texture_Format Texture::JPG;
constexpr Texture_Format Texture::DXT1;
constexpr Texture_Format Texture::ETC1;
constexpr Texture_Format Texture::PVRTC2;
constexpr Texture_Format Texture::PVRTC4;
constexpr Texture_Format Texture::CRN_DXT1;
constexpr Texture_Format Texture::Format_MIN;
constexpr Texture_Format Texture::Format_MAX;
constexpr int Texture::Format_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Texture_ViewDirection_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_rocktree_2eproto);
  return file_level_enum_descriptors_rocktree_2eproto[4];
}
bool Texture_ViewDirection_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr Texture_ViewDirection Texture::NADIR;
constexpr Texture_ViewDirection Texture::NORTH_45;
constexpr Texture_ViewDirection Texture::EAST_45;
constexpr Texture_ViewDirection Texture::SOUTH_45;
constexpr Texture_ViewDirection Texture::WEST_45;
constexpr Texture_ViewDirection Texture::ViewDirection_MIN;
constexpr Texture_ViewDirection Texture::ViewDirection_MAX;
constexpr int Texture::ViewDirection_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)

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

class BulkMetadataRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<BulkMetadataRequest>()._has_bits_);
  static const ::geo_globetrotter_proto_rocktree::NodeKey& node_key(const BulkMetadataRequest* msg);
  static void set_has_node_key(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::geo_globetrotter_proto_rocktree::NodeKey&
BulkMetadataRequest::_Internal::node_key(const BulkMetadataRequest* msg) {
  return *msg->node_key_;
}
BulkMetadataRequest::BulkMetadataRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:geo_globetrotter_proto_rocktree.BulkMetadataRequest)
}
BulkMetadataRequest::BulkMetadataRequest(const BulkMetadataRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_node_key()) {
    node_key_ = new ::geo_globetrotter_proto_rocktree::NodeKey(*from.node_key_);
  } else {
    node_key_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:geo_globetrotter_proto_rocktree.BulkMetadataRequest)
}

inline void BulkMetadataRequest::SharedCtor() {
node_key_ = nullptr;
}

BulkMetadataRequest::~BulkMetadataRequest() {
  // @@protoc_insertion_point(destructor:geo_globetrotter_proto_rocktree.BulkMetadataRequest)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void BulkMetadataRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete node_key_;
}

void BulkMetadataRequest::ArenaDtor(void* object) {
  BulkMetadataRequest* _this = reinterpret_cast< BulkMetadataRequest* >(object);
  (void)_this;
}
void BulkMetadataRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void BulkMetadataRequest::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void BulkMetadataRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:geo_globetrotter_proto_rocktree.BulkMetadataRequest)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(node_key_ != nullptr);
    node_key_->Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* BulkMetadataRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_node_key(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* BulkMetadataRequest::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:geo_globetrotter_proto_rocktree.BulkMetadataRequest)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::node_key(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:geo_globetrotter_proto_rocktree.BulkMetadataRequest)
  return target;
}

size_t BulkMetadataRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:geo_globetrotter_proto_rocktree.BulkMetadataRequest)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *node_key_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BulkMetadataRequest::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    BulkMetadataRequest::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BulkMetadataRequest::GetClassData() const { return &_class_data_; }

void BulkMetadataRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<BulkMetadataRequest *>(to)->MergeFrom(
      static_cast<const BulkMetadataRequest &>(from));
}


void BulkMetadataRequest::MergeFrom(const BulkMetadataRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:geo_globetrotter_proto_rocktree.BulkMetadataRequest)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_node_key()) {
    _internal_mutable_node_key()->::geo_globetrotter_proto_rocktree::NodeKey::MergeFrom(from._internal_node_key());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void BulkMetadataRequest::CopyFrom(const BulkMetadataRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:geo_globetrotter_proto_rocktree.BulkMetadataRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool BulkMetadataRequest::IsInitialized() const {
  return true;
}

void BulkMetadataRequest::InternalSwap(BulkMetadataRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(node_key_, other->node_key_);
}

::PROTOBUF_NAMESPACE_ID::Metadata BulkMetadataRequest::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_rocktree_2eproto_getter, &descriptor_table_rocktree_2eproto_once,
      file_level_metadata_rocktree_2eproto[0]);
}

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

class NodeDataRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<NodeDataRequest>()._has_bits_);
  static const ::geo_globetrotter_proto_rocktree::NodeKey& node_key(const NodeDataRequest* msg);
  static void set_has_node_key(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_texture_format(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_imagery_epoch(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::geo_globetrotter_proto_rocktree::NodeKey&
NodeDataRequest::_Internal::node_key(const NodeDataRequest* msg) {
  return *msg->node_key_;
}
NodeDataRequest::NodeDataRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:geo_globetrotter_proto_rocktree.NodeDataRequest)
}
NodeDataRequest::NodeDataRequest(const NodeDataRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_node_key()) {
    node_key_ = new ::geo_globetrotter_proto_rocktree::NodeKey(*from.node_key_);
  } else {
    node_key_ = nullptr;
  }
  ::memcpy(&imagery_epoch_, &from.imagery_epoch_,
    static_cast<size_t>(reinterpret_cast<char*>(&texture_format_) -
    reinterpret_cast<char*>(&imagery_epoch_)) + sizeof(texture_format_));
  // @@protoc_insertion_point(copy_constructor:geo_globetrotter_proto_rocktree.NodeDataRequest)
}

inline void NodeDataRequest::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&node_key_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&imagery_epoch_) -
    reinterpret_cast<char*>(&node_key_)) + sizeof(imagery_epoch_));
texture_format_ = 1;
}

NodeDataRequest::~NodeDataRequest() {
  // @@protoc_insertion_point(destructor:geo_globetrotter_proto_rocktree.NodeDataRequest)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void NodeDataRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete node_key_;
}

void NodeDataRequest::ArenaDtor(void* object) {
  NodeDataRequest* _this = reinterpret_cast< NodeDataRequest* >(object);
  (void)_this;
}
void NodeDataRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void NodeDataRequest::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void NodeDataRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:geo_globetrotter_proto_rocktree.NodeDataRequest)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(node_key_ != nullptr);
    node_key_->Clear();
  }
  if (cached_has_bits & 0x00000006u) {
    imagery_epoch_ = 0u;
    texture_format_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* NodeDataRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_node_key(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .geo_globetrotter_proto_rocktree.Texture.Format texture_format = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::geo_globetrotter_proto_rocktree::Texture_Format_IsValid(val))) {
            _internal_set_texture_format(static_cast<::geo_globetrotter_proto_rocktree::Texture_Format>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional uint32 imagery_epoch = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_imagery_epoch(&has_bits);
          imagery_epoch_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* NodeDataRequest::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:geo_globetrotter_proto_rocktree.NodeDataRequest)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::node_key(this), target, stream);
  }

  // optional .geo_globetrotter_proto_rocktree.Texture.Format texture_format = 2;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_texture_format(), target);
  }

  // optional uint32 imagery_epoch = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_imagery_epoch(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:geo_globetrotter_proto_rocktree.NodeDataRequest)
  return target;
}

size_t NodeDataRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:geo_globetrotter_proto_rocktree.NodeDataRequest)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *node_key_);
    }

    // optional uint32 imagery_epoch = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_imagery_epoch());
    }

    // optional .geo_globetrotter_proto_rocktree.Texture.Format texture_format = 2;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_texture_format());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NodeDataRequest::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    NodeDataRequest::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NodeDataRequest::GetClassData() const { return &_class_data_; }

void NodeDataRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<NodeDataRequest *>(to)->MergeFrom(
      static_cast<const NodeDataRequest &>(from));
}


void NodeDataRequest::MergeFrom(const NodeDataRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:geo_globetrotter_proto_rocktree.NodeDataRequest)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_node_key()->::geo_globetrotter_proto_rocktree::NodeKey::MergeFrom(from._internal_node_key());
    }
    if (cached_has_bits & 0x00000002u) {
      imagery_epoch_ = from.imagery_epoch_;
    }
    if (cached_has_bits & 0x00000004u) {
      texture_format_ = from.texture_format_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void NodeDataRequest::CopyFrom(const NodeDataRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:geo_globetrotter_proto_rocktree.NodeDataRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NodeDataRequest::IsInitialized() const {
  return true;
}

void NodeDataRequest::InternalSwap(NodeDataRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(NodeDataRequest, imagery_epoch_)
      + sizeof(NodeDataRequest::imagery_epoch_)
      - PROTOBUF_FIELD_OFFSET(NodeDataRequest, node_key_)>(
          reinterpret_cast<char*>(&node_key_),
          reinterpret_cast<char*>(&other->node_key_));
  swap(texture_format_, other->texture_format_);
}

::PROTOBUF_NAMESPACE_ID::Metadata NodeDataRequest::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_rocktree_2eproto_getter, &descriptor_table_rocktree_2eproto_once,
      file_level_metadata_rocktree_2eproto[1]);
}

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

class NodeKey::_Internal {
 public:
  using HasBits = decltype(std::declval<NodeKey>()._has_bits_);
  static void set_has_path(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_epoch(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

NodeKey::NodeKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:geo_globetrotter_proto_rocktree.NodeKey)
}
NodeKey::NodeKey(const NodeKey& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_path()) {
    path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_path(), 
      GetArenaForAllocation());
  }
  epoch_ = from.epoch_;
  // @@protoc_insertion_point(copy_constructor:geo_globetrotter_proto_rocktree.NodeKey)
}

inline void NodeKey::SharedCtor() {
path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
epoch_ = 0u;
}

NodeKey::~NodeKey() {
  // @@protoc_insertion_point(destructor:geo_globetrotter_proto_rocktree.NodeKey)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void NodeKey::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  path_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void NodeKey::ArenaDtor(void* object) {
  NodeKey* _this = reinterpret_cast< NodeKey* >(object);
  (void)_this;
}
void NodeKey::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void NodeKey::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void NodeKey::Clear() {
// @@protoc_insertion_point(message_clear_start:geo_globetrotter_proto_rocktree.NodeKey)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    path_.ClearNonDefaultToEmpty();
  }
  epoch_ = 0u;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* NodeKey::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional string path = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_path();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "geo_globetrotter_proto_rocktree.NodeKey.path");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 epoch = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_epoch(&has_bits);
          epoch_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* NodeKey::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:geo_globetrotter_proto_rocktree.NodeKey)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string path = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_path().data(), static_cast<int>(this->_internal_path().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "geo_globetrotter_proto_rocktree.NodeKey.path");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_path(), target);
  }

  // optional uint32 epoch = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_epoch(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:geo_globetrotter_proto_rocktree.NodeKey)
  return target;
}

size_t NodeKey::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:geo_globetrotter_proto_rocktree.NodeKey)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional string path = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_path());
    }

    // optional uint32 epoch = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_epoch());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NodeKey::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    NodeKey::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NodeKey::GetClassData() const { return &_class_data_; }

void NodeKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<NodeKey *>(to)->MergeFrom(
      static_cast<const NodeKey &>(from));
}


void NodeKey::MergeFrom(const NodeKey& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:geo_globetrotter_proto_rocktree.NodeKey)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_path(from._internal_path());
    }
    if (cached_has_bits & 0x00000002u) {
      epoch_ = from.epoch_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void NodeKey::CopyFrom(const NodeKey& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:geo_globetrotter_proto_rocktree.NodeKey)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NodeKey::IsInitialized() const {
  return true;
}

void NodeKey::InternalSwap(NodeKey* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &path_, GetArenaForAllocation(),
      &other->path_, other->GetArenaForAllocation()
  );
  swap(epoch_, other->epoch_);
}

::PROTOBUF_NAMESPACE_ID::Metadata NodeKey::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_rocktree_2eproto_getter, &descriptor_table_rocktree_2eproto_once,
      file_level_metadata_rocktree_2eproto[2]);
}

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

class CopyrightRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<CopyrightRequest>()._has_bits_);
  static void set_has_epoch(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

CopyrightRequest::CopyrightRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:geo_globetrotter_proto_rocktree.CopyrightRequest)
}
CopyrightRequest::CopyrightRequest(const CopyrightRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  epoch_ = from.epoch_;
  // @@protoc_insertion_point(copy_constructor:geo_globetrotter_proto_rocktree.CopyrightRequest)
}

inline void CopyrightRequest::SharedCtor() {
epoch_ = 0u;
}

CopyrightRequest::~CopyrightRequest() {
  // @@protoc_insertion_point(destructor:geo_globetrotter_proto_rocktree.CopyrightRequest)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void CopyrightRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void CopyrightRequest::ArenaDtor(void* object) {
  CopyrightRequest* _this = reinterpret_cast< CopyrightRequest* >(object);
  (void)_this;
}
void CopyrightRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void CopyrightRequest::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void CopyrightRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:geo_globetrotter_proto_rocktree.CopyrightRequest)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  epoch_ = 0u;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* CopyrightRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional uint32 epoch = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_epoch(&has_bits);
          epoch_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* CopyrightRequest::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:geo_globetrotter_proto_rocktree.CopyrightRequest)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 epoch = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_epoch(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:geo_globetrotter_proto_rocktree.CopyrightRequest)
  return target;
}

size_t CopyrightRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:geo_globetrotter_proto_rocktree.CopyrightRequest)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional uint32 epoch = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_epoch());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CopyrightRequest::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    CopyrightRequest::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CopyrightRequest::GetClassData() const { return &_class_data_; }

void CopyrightRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<CopyrightRequest *>(to)->MergeFrom(
      static_cast<const CopyrightRequest &>(from));
}


void CopyrightRequest::MergeFrom(const CopyrightRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:geo_globetrotter_proto_rocktree.CopyrightRequest)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_epoch()) {
    _internal_set_epoch(from._internal_epoch());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void CopyrightRequest::CopyFrom(const CopyrightRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:geo_globetrotter_proto_rocktree.CopyrightRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CopyrightRequest::IsInitialized() const {
  return true;
}

void CopyrightRequest::InternalSwap(CopyrightRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(epoch_, other->epoch_);
}

::PROTOBUF_NAMESPACE_ID::Metadata CopyrightRequest::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_rocktree_2eproto_getter, &descriptor_table_rocktree_2eproto_once,
      file_level_metadata_rocktree_2eproto[3]);
}

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

class TextureDataRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<TextureDataRequest>()._has_bits_);
  static const ::geo_globetrotter_proto_rocktree::NodeKey& node_key(const TextureDataRequest* msg);
  static void set_has_node_key(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_texture_format(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_view_direction(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::geo_globetrotter_proto_rocktree::NodeKey&
TextureDataRequest::_Internal::node_key(const TextureDataRequest* msg) {
  return *msg->node_key_;
}
TextureDataRequest::TextureDataRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:geo_globetrotter_proto_rocktree.TextureDataRequest)
}
TextureDataRequest::TextureDataRequest(const TextureDataRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_node_key()) {
    node_key_ = new ::geo_globetrotter_proto_rocktree::NodeKey(*from.node_key_);
  } else {
    node_key_ = nullptr;
  }
  ::memcpy(&view_direction_, &from.view_direction_,
    static_cast<size_t>(reinterpret_cast<char*>(&texture_format_) -
    reinterpret_cast<char*>(&view_direction_)) + sizeof(texture_format_));
  // @@protoc_insertion_point(copy_constructor:geo_globetrotter_proto_rocktree.TextureDataRequest)
}

inline void TextureDataRequest::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&node_key_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&view_direction_) -
    reinterpret_cast<char*>(&node_key_)) + sizeof(view_direction_));
texture_format_ = 1;
}

TextureDataRequest::~TextureDataRequest() {
  // @@protoc_insertion_point(destructor:geo_globetrotter_proto_rocktree.TextureDataRequest)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void TextureDataRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete node_key_;
}

void TextureDataRequest::ArenaDtor(void* object) {
  TextureDataRequest* _this = reinterpret_cast< TextureDataRequest* >(object);
  (void)_this;
}
void TextureDataRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void TextureDataRequest::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void TextureDataRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:geo_globetrotter_proto_rocktree.TextureDataRequest)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(node_key_ != nullptr);
    node_key_->Clear();
  }
  if (cached_has_bits & 0x00000006u) {
    view_direction_ = 0;
    texture_format_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* TextureDataRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_node_key(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .geo_globetrotter_proto_rocktree.Texture.Format texture_format = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::geo_globetrotter_proto_rocktree::Texture_Format_IsValid(val))) {
            _internal_set_texture_format(static_cast<::geo_globetrotter_proto_rocktree::Texture_Format>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional .geo_globetrotter_proto_rocktree.Texture.ViewDirection view_direction = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::geo_globetrotter_proto_rocktree::Texture_ViewDirection_IsValid(val))) {
            _internal_set_view_direction(static_cast<::geo_globetrotter_proto_rocktree::Texture_ViewDirection>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* TextureDataRequest::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:geo_globetrotter_proto_rocktree.TextureDataRequest)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::node_key(this), target, stream);
  }

  // optional .geo_globetrotter_proto_rocktree.Texture.Format texture_format = 2;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_texture_format(), target);
  }

  // optional .geo_globetrotter_proto_rocktree.Texture.ViewDirection view_direction = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      3, this->_internal_view_direction(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:geo_globetrotter_proto_rocktree.TextureDataRequest)
  return target;
}

size_t TextureDataRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:geo_globetrotter_proto_rocktree.TextureDataRequest)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *node_key_);
    }

    // optional .geo_globetrotter_proto_rocktree.Texture.ViewDirection view_direction = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_view_direction());
    }

    // optional .geo_globetrotter_proto_rocktree.Texture.Format texture_format = 2;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_texture_format());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TextureDataRequest::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    TextureDataRequest::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TextureDataRequest::GetClassData() const { return &_class_data_; }

void TextureDataRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<TextureDataRequest *>(to)->MergeFrom(
      static_cast<const TextureDataRequest &>(from));
}


void TextureDataRequest::MergeFrom(const TextureDataRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:geo_globetrotter_proto_rocktree.TextureDataRequest)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_node_key()->::geo_globetrotter_proto_rocktree::NodeKey::MergeFrom(from._internal_node_key());
    }
    if (cached_has_bits & 0x00000002u) {
      view_direction_ = from.view_direction_;
    }
    if (cached_has_bits & 0x00000004u) {
      texture_format_ = from.texture_format_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void TextureDataRequest::CopyFrom(const TextureDataRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:geo_globetrotter_proto_rocktree.TextureDataRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TextureDataRequest::IsInitialized() const {
  return true;
}

void TextureDataRequest::InternalSwap(TextureDataRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(TextureDataRequest, view_direction_)
      + sizeof(TextureDataRequest::view_direction_)
      - PROTOBUF_FIELD_OFFSET(TextureDataRequest, node_key_)>(
          reinterpret_cast<char*>(&node_key_),
          reinterpret_cast<char*>(&other->node_key_));
  swap(texture_format_, other->texture_format_);
}

::PROTOBUF_NAMESPACE_ID::Metadata TextureDataRequest::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_rocktree_2eproto_getter, &descriptor_table_rocktree_2eproto_once,
      file_level_metadata_rocktree_2eproto[4]);
}

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

class BulkMetadata::_Internal {
 public:
  using HasBits = decltype(std::declval<BulkMetadata>()._has_bits_);
  static const ::geo_globetrotter_proto_rocktree::NodeKey& head_node_key(const BulkMetadata* msg);
  static void set_has_head_node_key(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_default_imagery_epoch(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_default_available_texture_formats(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_default_available_view_dependent_textures(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_default_available_view_dependent_texture_formats(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
};

const ::geo_globetrotter_proto_rocktree::NodeKey&
BulkMetadata::_Internal::head_node_key(const BulkMetadata* msg) {
  return *msg->head_node_key_;
}
BulkMetadata::BulkMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  node_metadata_(arena),
  head_node_center_(arena),
  meters_per_texel_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:geo_globetrotter_proto_rocktree.BulkMetadata)
}
BulkMetadata::BulkMetadata(const BulkMetadata& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      node_metadata_(from.node_metadata_),
      head_node_center_(from.head_node_center_),
      meters_per_texel_(from.meters_per_texel_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_head_node_key()) {
    head_node_key_ = new ::geo_globetrotter_proto_rocktree::NodeKey(*from.head_node_key_);
  } else {
    head_node_key_ = nullptr;
  }
  ::memcpy(&default_imagery_epoch_, &from.default_imagery_epoch_,
    static_cast<size_t>(reinterpret_cast<char*>(&default_available_view_dependent_texture_formats_) -
    reinterpret_cast<char*>(&default_imagery_epoch_)) + sizeof(default_available_view_dependent_texture_formats_));
  // @@protoc_insertion_point(copy_constructor:geo_globetrotter_proto_rocktree.BulkMetadata)
}

inline void BulkMetadata::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&head_node_key_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&default_available_view_dependent_texture_formats_) -
    reinterpret_cast<char*>(&head_node_key_)) + sizeof(default_available_view_dependent_texture_formats_));
}

BulkMetadata::~BulkMetadata() {
  // @@protoc_insertion_point(destructor:geo_globetrotter_proto_rocktree.BulkMetadata)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void BulkMetadata::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete head_node_key_;
}

void BulkMetadata::ArenaDtor(void* object) {
  BulkMetadata* _this = reinterpret_cast< BulkMetadata* >(object);
  (void)_this;
}
void BulkMetadata::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void BulkMetadata::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void BulkMetadata::Clear() {
// @@protoc_insertion_point(message_clear_start:geo_globetrotter_proto_rocktree.BulkMetadata)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  node_metadata_.Clear();
  head_node_center_.Clear();
  meters_per_texel_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(head_node_key_ != nullptr);
    head_node_key_->Clear();
  }
  if (cached_has_bits & 0x0000001eu) {
    ::memset(&default_imagery_epoch_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&default_available_view_dependent_texture_formats_) -
        reinterpret_cast<char*>(&default_imagery_epoch_)) + sizeof(default_available_view_dependent_texture_formats_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* BulkMetadata::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .geo_globetrotter_proto_rocktree.NodeMetadata node_metadata = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_node_metadata(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // optional .geo_globetrotter_proto_rocktree.NodeKey head_node_key = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_head_node_key(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated double head_node_center = 3 [packed = true];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_head_node_center(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 25) {
          _internal_add_head_node_center(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // repeated float meters_per_texel = 4 [packed = true];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_meters_per_texel(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37) {
          _internal_add_meters_per_texel(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // optional uint32 default_imagery_epoch = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_default_imagery_epoch(&has_bits);
          default_imagery_epoch_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 default_available_texture_formats = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_default_available_texture_formats(&has_bits);
          default_available_texture_formats_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 default_available_view_dependent_textures = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          _Internal::set_has_default_available_view_dependent_textures(&has_bits);
          default_available_view_dependent_textures_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 default_available_view_dependent_texture_formats = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
          _Internal::set_has_default_available_view_dependent_texture_formats(&has_bits);
          default_available_view_dependent_texture_formats_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* BulkMetadata::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:geo_globetrotter_proto_rocktree.BulkMetadata)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .geo_globetrotter_proto_rocktree.NodeMetadata node_metadata = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_node_metadata_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_node_metadata(i), target, stream);
  }

  cached_has_bits = _has_bits_[0];
  // optional .geo_globetrotter_proto_rocktree.NodeKey head_node_key = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::head_node_key(this), target, stream);
  }

  // repeated double head_node_center = 3 [packed = true];
  if (this->_internal_head_node_center_size() > 0) {
    target = stream->WriteFixedPacked(3, _internal_head_node_center(), target);
  }

  // repeated float meters_per_texel = 4 [packed = true];
  if (this->_internal_meters_per_texel_size() > 0) {
    target = stream->WriteFixedPacked(4, _internal_meters_per_texel(), target);
  }

  // optional uint32 default_imagery_epoch = 5;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_default_imagery_epoch(), target);
  }

  // optional uint32 default_available_texture_formats = 6;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_default_available_texture_formats(), target);
  }

  // optional uint32 default_available_view_dependent_textures = 7;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_default_available_view_dependent_textures(), target);
  }

  // optional uint32 default_available_view_dependent_texture_formats = 8;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(8, this->_internal_default_available_view_dependent_texture_formats(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:geo_globetrotter_proto_rocktree.BulkMetadata)
  return target;
}

size_t BulkMetadata::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:geo_globetrotter_proto_rocktree.BulkMetadata)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .geo_globetrotter_proto_rocktree.NodeMetadata node_metadata = 1;
  total_size += 1UL * this->_internal_node_metadata_size();
  for (const auto& msg : this->node_metadata_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated double head_node_center = 3 [packed = true];
  {
    unsigned int count = static_cast<unsigned int>(this->_internal_head_node_center_size());
    size_t data_size = 8UL * count;
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    total_size += data_size;
  }

  // repeated float meters_per_texel = 4 [packed = true];
  {
    unsigned int count = static_cast<unsigned int>(this->_internal_meters_per_texel_size());
    size_t data_size = 4UL * count;
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    total_size += data_size;
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional .geo_globetrotter_proto_rocktree.NodeKey head_node_key = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *head_node_key_);
    }

    // optional uint32 default_imagery_epoch = 5;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_default_imagery_epoch());
    }

    // optional uint32 default_available_texture_formats = 6;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_default_available_texture_formats());
    }

    // optional uint32 default_available_view_dependent_textures = 7;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_default_available_view_dependent_textures());
    }

    // optional uint32 default_available_view_dependent_texture_formats = 8;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_default_available_view_dependent_texture_formats());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData BulkMetadata::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    BulkMetadata::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*BulkMetadata::GetClassData() const { return &_class_data_; }

void BulkMetadata::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<BulkMetadata *>(to)->MergeFrom(
      static_cast<const BulkMetadata &>(from));
}


void BulkMetadata::MergeFrom(const BulkMetadata& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:geo_globetrotter_proto_rocktree.BulkMetadata)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  node_metadata_.MergeFrom(from.node_metadata_);
  head_node_center_.MergeFrom(from.head_node_center_);
  meters_per_texel_.MergeFrom(from.meters_per_texel_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_head_node_key()->::geo_globetrotter_proto_rocktree::NodeKey::MergeFrom(from._internal_head_node_key());
    }
    if (cached_has_bits & 0x00000002u) {
      default_imagery_epoch_ = from.default_imagery_epoch_;
    }
    if (cached_has_bits & 0x00000004u) {
      default_available_texture_formats_ = from.default_available_texture_formats_;
    }
    if (cached_has_bits & 0x00000008u) {
      default_available_view_dependent_textures_ = from.default_available_view_dependent_textures_;
    }
    if (cached_has_bits & 0x00000010u) {
      default_available_view_dependent_texture_formats_ = from.default_available_view_dependent_texture_formats_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void BulkMetadata::CopyFrom(const BulkMetadata& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:geo_globetrotter_proto_rocktree.BulkMetadata)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool BulkMetadata::IsInitialized() const {
  return true;
}

void BulkMetadata::InternalSwap(BulkMetadata* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  node_metadata_.InternalSwap(&other->node_metadata_);
  head_node_center_.InternalSwap(&other->head_node_center_);
  meters_per_texel_.InternalSwap(&other->meters_per_texel_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(BulkMetadata, default_available_view_dependent_texture_formats_)
      + sizeof(BulkMetadata::default_available_view_dependent_texture_formats_)
      - PROTOBUF_FIELD_OFFSET(BulkMetadata, head_node_key_)>(
          reinterpret_cast<char*>(&head_node_key_),
          reinterpret_cast<char*>(&other->head_node_key_));
}

::PROTOBUF_NAMESPACE_ID::Metadata BulkMetadata::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_rocktree_2eproto_getter, &descriptor_table_rocktree_2eproto_once,
      file_level_metadata_rocktree_2eproto[5]);
}

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

class NodeMetadata::_Internal {
 public:
  using HasBits = decltype(std::declval<NodeMetadata>()._has_bits_);
  static void set_has_path_and_flags(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_epoch(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_bulk_metadata_epoch(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_oriented_bounding_box(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_meters_per_texel(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_imagery_epoch(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_available_texture_formats(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_available_view_dependent_textures(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static void set_has_available_view_dependent_texture_formats(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
};

NodeMetadata::NodeMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  processing_oriented_bounding_box_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:geo_globetrotter_proto_rocktree.NodeMetadata)
}
NodeMetadata::NodeMetadata(const NodeMetadata& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      processing_oriented_bounding_box_(from.processing_oriented_bounding_box_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  oriented_bounding_box_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_oriented_bounding_box()) {
    oriented_bounding_box_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_oriented_bounding_box(), 
      GetArenaForAllocation());
  }
  ::memcpy(&path_and_flags_, &from.path_and_flags_,
    static_cast<size_t>(reinterpret_cast<char*>(&available_view_dependent_texture_formats_) -
    reinterpret_cast<char*>(&path_and_flags_)) + sizeof(available_view_dependent_texture_formats_));
  // @@protoc_insertion_point(copy_constructor:geo_globetrotter_proto_rocktree.NodeMetadata)
}

inline void NodeMetadata::SharedCtor() {
oriented_bounding_box_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&path_and_flags_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&available_view_dependent_texture_formats_) -
    reinterpret_cast<char*>(&path_and_flags_)) + sizeof(available_view_dependent_texture_formats_));
}

NodeMetadata::~NodeMetadata() {
  // @@protoc_insertion_point(destructor:geo_globetrotter_proto_rocktree.NodeMetadata)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void NodeMetadata::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  oriented_bounding_box_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void NodeMetadata::ArenaDtor(void* object) {
  NodeMetadata* _this = reinterpret_cast< NodeMetadata* >(object);
  (void)_this;
}
void NodeMetadata::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void NodeMetadata::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void NodeMetadata::Clear() {
// @@protoc_insertion_point(message_clear_start:geo_globetrotter_proto_rocktree.NodeMetadata)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  processing_oriented_bounding_box_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    oriented_bounding_box_.ClearNonDefaultToEmpty();
  }
  if (cached_has_bits & 0x000000feu) {
    ::memset(&path_and_flags_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&available_view_dependent_textures_) -
        reinterpret_cast<char*>(&path_and_flags_)) + sizeof(available_view_dependent_textures_));
  }
  available_view_dependent_texture_formats_ = 0u;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* NodeMetadata::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional uint32 path_and_flags = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_path_and_flags(&has_bits);
          path_and_flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 epoch = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_epoch(&has_bits);
          epoch_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes oriented_bounding_box = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          auto str = _internal_mutable_oriented_bounding_box();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional float meters_per_texel = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) {
          _Internal::set_has_meters_per_texel(&has_bits);
          meters_per_texel_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // optional uint32 bulk_metadata_epoch = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_bulk_metadata_epoch(&has_bits);
          bulk_metadata_epoch_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated double processing_oriented_bounding_box = 6 [packed = true];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_processing_oriented_bounding_box(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 49) {
          _internal_add_processing_oriented_bounding_box(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional uint32 imagery_epoch = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          _Internal::set_has_imagery_epoch(&has_bits);
          imagery_epoch_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 available_texture_formats = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
          _Internal::set_has_available_texture_formats(&has_bits);
          available_texture_formats_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 available_view_dependent_textures = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) {
          _Internal::set_has_available_view_dependent_textures(&has_bits);
          available_view_dependent_textures_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 available_view_dependent_texture_formats = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) {
          _Internal::set_has_available_view_dependent_texture_formats(&has_bits);
          available_view_dependent_texture_formats_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* NodeMetadata::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:geo_globetrotter_proto_rocktree.NodeMetadata)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 path_and_flags = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_path_and_flags(), target);
  }

  // optional uint32 epoch = 2;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_epoch(), target);
  }

  // optional bytes oriented_bounding_box = 3;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        3, this->_internal_oriented_bounding_box(), target);
  }

  // optional float meters_per_texel = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_meters_per_texel(), target);
  }

  // optional uint32 bulk_metadata_epoch = 5;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_bulk_metadata_epoch(), target);
  }

  // repeated double processing_oriented_bounding_box = 6 [packed = true];
  if (this->_internal_processing_oriented_bounding_box_size() > 0) {
    target = stream->WriteFixedPacked(6, _internal_processing_oriented_bounding_box(), target);
  }

  // optional uint32 imagery_epoch = 7;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(7, this->_internal_imagery_epoch(), target);
  }

  // optional uint32 available_texture_formats = 8;
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(8, this->_internal_available_texture_formats(), target);
  }

  // optional uint32 available_view_dependent_textures = 9;
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(9, this->_internal_available_view_dependent_textures(), target);
  }

  // optional uint32 available_view_dependent_texture_formats = 10;
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(10, this->_internal_available_view_dependent_texture_formats(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:geo_globetrotter_proto_rocktree.NodeMetadata)
  return target;
}

size_t NodeMetadata::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:geo_globetrotter_proto_rocktree.NodeMetadata)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated double processing_oriented_bounding_box = 6 [packed = true];
  {
    unsigned int count = static_cast<unsigned int>(this->_internal_processing_oriented_bounding_box_size());
    size_t data_size = 8UL * count;
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    total_size += data_size;
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional bytes oriented_bounding_box = 3;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_oriented_bounding_box());
    }

    // optional uint32 path_and_flags = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_path_and_flags());
    }

    // optional uint32 epoch = 2;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_epoch());
    }

    // optional float meters_per_texel = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 4;
    }

    // optional uint32 bulk_metadata_epoch = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_bulk_metadata_epoch());
    }

    // optional uint32 imagery_epoch = 7;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_imagery_epoch());
    }

    // optional uint32 available_texture_formats = 8;
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_available_texture_formats());
    }

    // optional uint32 available_view_dependent_textures = 9;
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_available_view_dependent_textures());
    }

  }
  // optional uint32 available_view_dependent_texture_formats = 10;
  if (cached_has_bits & 0x00000100u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_available_view_dependent_texture_formats());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NodeMetadata::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    NodeMetadata::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NodeMetadata::GetClassData() const { return &_class_data_; }

void NodeMetadata::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<NodeMetadata *>(to)->MergeFrom(
      static_cast<const NodeMetadata &>(from));
}


void NodeMetadata::MergeFrom(const NodeMetadata& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:geo_globetrotter_proto_rocktree.NodeMetadata)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  processing_oriented_bounding_box_.MergeFrom(from.processing_oriented_bounding_box_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_oriented_bounding_box(from._internal_oriented_bounding_box());
    }
    if (cached_has_bits & 0x00000002u) {
      path_and_flags_ = from.path_and_flags_;
    }
    if (cached_has_bits & 0x00000004u) {
      epoch_ = from.epoch_;
    }
    if (cached_has_bits & 0x00000008u) {
      meters_per_texel_ = from.meters_per_texel_;
    }
    if (cached_has_bits & 0x00000010u) {
      bulk_metadata_epoch_ = from.bulk_metadata_epoch_;
    }
    if (cached_has_bits & 0x00000020u) {
      imagery_epoch_ = from.imagery_epoch_;
    }
    if (cached_has_bits & 0x00000040u) {
      available_texture_formats_ = from.available_texture_formats_;
    }
    if (cached_has_bits & 0x00000080u) {
      available_view_dependent_textures_ = from.available_view_dependent_textures_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00000100u) {
    _internal_set_available_view_dependent_texture_formats(from._internal_available_view_dependent_texture_formats());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void NodeMetadata::CopyFrom(const NodeMetadata& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:geo_globetrotter_proto_rocktree.NodeMetadata)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NodeMetadata::IsInitialized() const {
  return true;
}

void NodeMetadata::InternalSwap(NodeMetadata* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  processing_oriented_bounding_box_.InternalSwap(&other->processing_oriented_bounding_box_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &oriented_bounding_box_, GetArenaForAllocation(),
      &other->oriented_bounding_box_, other->GetArenaForAllocation()
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(NodeMetadata, available_view_dependent_texture_formats_)
      + sizeof(NodeMetadata::available_view_dependent_texture_formats_)
      - PROTOBUF_FIELD_OFFSET(NodeMetadata, path_and_flags_)>(
          reinterpret_cast<char*>(&path_and_flags_),
          reinterpret_cast<char*>(&other->path_and_flags_));
}

::PROTOBUF_NAMESPACE_ID::Metadata NodeMetadata::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_rocktree_2eproto_getter, &descriptor_table_rocktree_2eproto_once,
      file_level_metadata_rocktree_2eproto[6]);
}

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

class NodeData::_Internal {
 public:
  using HasBits = decltype(std::declval<NodeData>()._has_bits_);
  static const ::geo_globetrotter_proto_rocktree::NodeKey& node_key(const NodeData* msg);
  static void set_has_node_key(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::geo_globetrotter_proto_rocktree::Mesh& water_mesh(const NodeData* msg);
  static void set_has_water_mesh(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_for_normals(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::geo_globetrotter_proto_rocktree::NodeKey&
NodeData::_Internal::node_key(const NodeData* msg) {
  return *msg->node_key_;
}
const ::geo_globetrotter_proto_rocktree::Mesh&
NodeData::_Internal::water_mesh(const NodeData* msg) {
  return *msg->water_mesh_;
}
NodeData::NodeData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  matrix_globe_from_mesh_(arena),
  meshes_(arena),
  copyright_ids_(arena),
  kml_bounding_box_(arena),
  overlay_surface_meshes_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:geo_globetrotter_proto_rocktree.NodeData)
}
NodeData::NodeData(const NodeData& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      matrix_globe_from_mesh_(from.matrix_globe_from_mesh_),
      meshes_(from.meshes_),
      copyright_ids_(from.copyright_ids_),
      kml_bounding_box_(from.kml_bounding_box_),
      overlay_surface_meshes_(from.overlay_surface_meshes_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  for_normals_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_for_normals()) {
    for_normals_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_for_normals(), 
      GetArenaForAllocation());
  }
  if (from._internal_has_node_key()) {
    node_key_ = new ::geo_globetrotter_proto_rocktree::NodeKey(*from.node_key_);
  } else {
    node_key_ = nullptr;
  }
  if (from._internal_has_water_mesh()) {
    water_mesh_ = new ::geo_globetrotter_proto_rocktree::Mesh(*from.water_mesh_);
  } else {
    water_mesh_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:geo_globetrotter_proto_rocktree.NodeData)
}

inline void NodeData::SharedCtor() {
for_normals_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&node_key_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&water_mesh_) -
    reinterpret_cast<char*>(&node_key_)) + sizeof(water_mesh_));
}

NodeData::~NodeData() {
  // @@protoc_insertion_point(destructor:geo_globetrotter_proto_rocktree.NodeData)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void NodeData::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  for_normals_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete node_key_;
  if (this != internal_default_instance()) delete water_mesh_;
}

void NodeData::ArenaDtor(void* object) {
  NodeData* _this = reinterpret_cast< NodeData* >(object);
  (void)_this;
}
void NodeData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void NodeData::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void NodeData::Clear() {
// @@protoc_insertion_point(message_clear_start:geo_globetrotter_proto_rocktree.NodeData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  matrix_globe_from_mesh_.Clear();
  meshes_.Clear();
  copyright_ids_.Clear();
  kml_bounding_box_.Clear();
  overlay_surface_meshes_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      for_normals_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(node_key_ != nullptr);
      node_key_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(water_mesh_ != nullptr);
      water_mesh_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* NodeData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated double matrix_globe_from_mesh = 1 [packed = true];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_matrix_globe_from_mesh(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 9) {
          _internal_add_matrix_globe_from_mesh(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // repeated .geo_globetrotter_proto_rocktree.Mesh meshes = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_meshes(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated uint32 copyright_ids = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_copyright_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<24>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_copyright_ids(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_node_key(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated double kml_bounding_box = 5 [packed = true];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_kml_bounding_box(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 41) {
          _internal_add_kml_bounding_box(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional .geo_globetrotter_proto_rocktree.Mesh water_mesh = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_water_mesh(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .geo_globetrotter_proto_rocktree.Mesh overlay_surface_meshes = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_overlay_surface_meshes(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr));
        } else goto handle_unusual;
        continue;
      // optional bytes for_normals = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          auto str = _internal_mutable_for_normals();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* NodeData::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:geo_globetrotter_proto_rocktree.NodeData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated double matrix_globe_from_mesh = 1 [packed = true];
  if (this->_internal_matrix_globe_from_mesh_size() > 0) {
    target = stream->WriteFixedPacked(1, _internal_matrix_globe_from_mesh(), target);
  }

  // repeated .geo_globetrotter_proto_rocktree.Mesh meshes = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_meshes_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, this->_internal_meshes(i), target, stream);
  }

  // repeated uint32 copyright_ids = 3;
  for (int i = 0, n = this->_internal_copyright_ids_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_copyright_ids(i), target);
  }

  cached_has_bits = _has_bits_[0];
  // optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 4;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::node_key(this), target, stream);
  }

  // repeated double kml_bounding_box = 5 [packed = true];
  if (this->_internal_kml_bounding_box_size() > 0) {
    target = stream->WriteFixedPacked(5, _internal_kml_bounding_box(), target);
  }

  // optional .geo_globetrotter_proto_rocktree.Mesh water_mesh = 6;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        6, _Internal::water_mesh(this), target, stream);
  }

  // repeated .geo_globetrotter_proto_rocktree.Mesh overlay_surface_meshes = 7;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_overlay_surface_meshes_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(7, this->_internal_overlay_surface_meshes(i), target, stream);
  }

  // optional bytes for_normals = 8;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        8, this->_internal_for_normals(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:geo_globetrotter_proto_rocktree.NodeData)
  return target;
}

size_t NodeData::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:geo_globetrotter_proto_rocktree.NodeData)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated double matrix_globe_from_mesh = 1 [packed = true];
  {
    unsigned int count = static_cast<unsigned int>(this->_internal_matrix_globe_from_mesh_size());
    size_t data_size = 8UL * count;
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    total_size += data_size;
  }

  // repeated .geo_globetrotter_proto_rocktree.Mesh meshes = 2;
  total_size += 1UL * this->_internal_meshes_size();
  for (const auto& msg : this->meshes_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated uint32 copyright_ids = 3;
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      UInt32Size(this->copyright_ids_);
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_copyright_ids_size());
    total_size += data_size;
  }

  // repeated double kml_bounding_box = 5 [packed = true];
  {
    unsigned int count = static_cast<unsigned int>(this->_internal_kml_bounding_box_size());
    size_t data_size = 8UL * count;
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    total_size += data_size;
  }

  // repeated .geo_globetrotter_proto_rocktree.Mesh overlay_surface_meshes = 7;
  total_size += 1UL * this->_internal_overlay_surface_meshes_size();
  for (const auto& msg : this->overlay_surface_meshes_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional bytes for_normals = 8;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_for_normals());
    }

    // optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 4;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *node_key_);
    }

    // optional .geo_globetrotter_proto_rocktree.Mesh water_mesh = 6;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *water_mesh_);
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NodeData::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    NodeData::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NodeData::GetClassData() const { return &_class_data_; }

void NodeData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<NodeData *>(to)->MergeFrom(
      static_cast<const NodeData &>(from));
}


void NodeData::MergeFrom(const NodeData& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:geo_globetrotter_proto_rocktree.NodeData)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  matrix_globe_from_mesh_.MergeFrom(from.matrix_globe_from_mesh_);
  meshes_.MergeFrom(from.meshes_);
  copyright_ids_.MergeFrom(from.copyright_ids_);
  kml_bounding_box_.MergeFrom(from.kml_bounding_box_);
  overlay_surface_meshes_.MergeFrom(from.overlay_surface_meshes_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_for_normals(from._internal_for_normals());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_node_key()->::geo_globetrotter_proto_rocktree::NodeKey::MergeFrom(from._internal_node_key());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_water_mesh()->::geo_globetrotter_proto_rocktree::Mesh::MergeFrom(from._internal_water_mesh());
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void NodeData::CopyFrom(const NodeData& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:geo_globetrotter_proto_rocktree.NodeData)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NodeData::IsInitialized() const {
  return true;
}

void NodeData::InternalSwap(NodeData* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  matrix_globe_from_mesh_.InternalSwap(&other->matrix_globe_from_mesh_);
  meshes_.InternalSwap(&other->meshes_);
  copyright_ids_.InternalSwap(&other->copyright_ids_);
  kml_bounding_box_.InternalSwap(&other->kml_bounding_box_);
  overlay_surface_meshes_.InternalSwap(&other->overlay_surface_meshes_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &for_normals_, GetArenaForAllocation(),
      &other->for_normals_, other->GetArenaForAllocation()
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(NodeData, water_mesh_)
      + sizeof(NodeData::water_mesh_)
      - PROTOBUF_FIELD_OFFSET(NodeData, node_key_)>(
          reinterpret_cast<char*>(&node_key_),
          reinterpret_cast<char*>(&other->node_key_));
}

::PROTOBUF_NAMESPACE_ID::Metadata NodeData::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_rocktree_2eproto_getter, &descriptor_table_rocktree_2eproto_once,
      file_level_metadata_rocktree_2eproto[7]);
}

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

class Mesh::_Internal {
 public:
  using HasBits = decltype(std::declval<Mesh>()._has_bits_);
  static void set_has_vertices(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_vertex_alphas(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static void set_has_texture_coords(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_indices(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_octant_ranges(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_layer_counts(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_texture_coordinates(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_layer_and_octant_counts(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_normals(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static void set_has_normals_dev(HasBits* has_bits) {
    (*has_bits)[0] |= 1024u;
  }
  static void set_has_mesh_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2048u;
  }
  static void set_has_skirt_flags(HasBits* has_bits) {
    (*has_bits)[0] |= 512u;
  }
};

Mesh::Mesh(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  texture_(arena),
  uv_offset_and_scale_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:geo_globetrotter_proto_rocktree.Mesh)
}
Mesh::Mesh(const Mesh& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      texture_(from.texture_),
      uv_offset_and_scale_(from.uv_offset_and_scale_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  vertices_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_vertices()) {
    vertices_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_vertices(), 
      GetArenaForAllocation());
  }
  texture_coords_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_texture_coords()) {
    texture_coords_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_texture_coords(), 
      GetArenaForAllocation());
  }
  indices_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_indices()) {
    indices_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_indices(), 
      GetArenaForAllocation());
  }
  octant_ranges_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_octant_ranges()) {
    octant_ranges_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_octant_ranges(), 
      GetArenaForAllocation());
  }
  layer_counts_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_layer_counts()) {
    layer_counts_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_layer_counts(), 
      GetArenaForAllocation());
  }
  texture_coordinates_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_texture_coordinates()) {
    texture_coordinates_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_texture_coordinates(), 
      GetArenaForAllocation());
  }
  layer_and_octant_counts_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_layer_and_octant_counts()) {
    layer_and_octant_counts_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_layer_and_octant_counts(), 
      GetArenaForAllocation());
  }
  vertex_alphas_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_vertex_alphas()) {
    vertex_alphas_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_vertex_alphas(), 
      GetArenaForAllocation());
  }
  normals_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_normals()) {
    normals_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_normals(), 
      GetArenaForAllocation());
  }
  skirt_flags_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_skirt_flags()) {
    skirt_flags_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_skirt_flags(), 
      GetArenaForAllocation());
  }
  normals_dev_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_normals_dev()) {
    normals_dev_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_normals_dev(), 
      GetArenaForAllocation());
  }
  mesh_id_ = from.mesh_id_;
  // @@protoc_insertion_point(copy_constructor:geo_globetrotter_proto_rocktree.Mesh)
}

inline void Mesh::SharedCtor() {
vertices_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
texture_coords_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
indices_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
octant_ranges_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
layer_counts_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
texture_coordinates_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
layer_and_octant_counts_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
vertex_alphas_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
normals_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
skirt_flags_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
normals_dev_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
mesh_id_ = 0u;
}

Mesh::~Mesh() {
  // @@protoc_insertion_point(destructor:geo_globetrotter_proto_rocktree.Mesh)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Mesh::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  vertices_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  texture_coords_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  indices_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  octant_ranges_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  layer_counts_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  texture_coordinates_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  layer_and_octant_counts_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  vertex_alphas_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  normals_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  skirt_flags_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  normals_dev_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void Mesh::ArenaDtor(void* object) {
  Mesh* _this = reinterpret_cast< Mesh* >(object);
  (void)_this;
}
void Mesh::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Mesh::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Mesh::Clear() {
// @@protoc_insertion_point(message_clear_start:geo_globetrotter_proto_rocktree.Mesh)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  texture_.Clear();
  uv_offset_and_scale_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      vertices_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      texture_coords_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000004u) {
      indices_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000008u) {
      octant_ranges_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000010u) {
      layer_counts_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000020u) {
      texture_coordinates_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000040u) {
      layer_and_octant_counts_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000080u) {
      vertex_alphas_.ClearNonDefaultToEmpty();
    }
  }
  if (cached_has_bits & 0x00000700u) {
    if (cached_has_bits & 0x00000100u) {
      normals_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000200u) {
      skirt_flags_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000400u) {
      normals_dev_.ClearNonDefaultToEmpty();
    }
  }
  mesh_id_ = 0u;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Mesh::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional bytes vertices = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_vertices();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes texture_coords = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_texture_coords();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes indices = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          auto str = _internal_mutable_indices();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes octant_ranges = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          auto str = _internal_mutable_octant_ranges();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes layer_counts = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          auto str = _internal_mutable_layer_counts();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .geo_globetrotter_proto_rocktree.Texture texture = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_texture(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
        } else goto handle_unusual;
        continue;
      // optional bytes texture_coordinates = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          auto str = _internal_mutable_texture_coordinates();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes layer_and_octant_counts = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          auto str = _internal_mutable_layer_and_octant_counts();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes vertex_alphas = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
          auto str = _internal_mutable_vertex_alphas();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated float uv_offset_and_scale = 10 [packed = true];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_uv_offset_and_scale(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 85) {
          _internal_add_uv_offset_and_scale(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // optional bytes normals = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
          auto str = _internal_mutable_normals();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 mesh_id = 12;
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 96)) {
          _Internal::set_has_mesh_id(&has_bits);
          mesh_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes skirt_flags = 13;
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
          auto str = _internal_mutable_skirt_flags();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes normals_dev = 16;
      case 16:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) {
          auto str = _internal_mutable_normals_dev();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Mesh::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:geo_globetrotter_proto_rocktree.Mesh)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bytes vertices = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->WriteBytesMaybeAliased(
        1, this->_internal_vertices(), target);
  }

  // optional bytes texture_coords = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->WriteBytesMaybeAliased(
        2, this->_internal_texture_coords(), target);
  }

  // optional bytes indices = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->WriteBytesMaybeAliased(
        3, this->_internal_indices(), target);
  }

  // optional bytes octant_ranges = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->WriteBytesMaybeAliased(
        4, this->_internal_octant_ranges(), target);
  }

  // optional bytes layer_counts = 5;
  if (cached_has_bits & 0x00000010u) {
    target = stream->WriteBytesMaybeAliased(
        5, this->_internal_layer_counts(), target);
  }

  // repeated .geo_globetrotter_proto_rocktree.Texture texture = 6;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_texture_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(6, this->_internal_texture(i), target, stream);
  }

  // optional bytes texture_coordinates = 7;
  if (cached_has_bits & 0x00000020u) {
    target = stream->WriteBytesMaybeAliased(
        7, this->_internal_texture_coordinates(), target);
  }

  // optional bytes layer_and_octant_counts = 8;
  if (cached_has_bits & 0x00000040u) {
    target = stream->WriteBytesMaybeAliased(
        8, this->_internal_layer_and_octant_counts(), target);
  }

  // optional bytes vertex_alphas = 9;
  if (cached_has_bits & 0x00000080u) {
    target = stream->WriteBytesMaybeAliased(
        9, this->_internal_vertex_alphas(), target);
  }

  // repeated float uv_offset_and_scale = 10 [packed = true];
  if (this->_internal_uv_offset_and_scale_size() > 0) {
    target = stream->WriteFixedPacked(10, _internal_uv_offset_and_scale(), target);
  }

  // optional bytes normals = 11;
  if (cached_has_bits & 0x00000100u) {
    target = stream->WriteBytesMaybeAliased(
        11, this->_internal_normals(), target);
  }

  // optional uint32 mesh_id = 12;
  if (cached_has_bits & 0x00000800u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(12, this->_internal_mesh_id(), target);
  }

  // optional bytes skirt_flags = 13;
  if (cached_has_bits & 0x00000200u) {
    target = stream->WriteBytesMaybeAliased(
        13, this->_internal_skirt_flags(), target);
  }

  // optional bytes normals_dev = 16;
  if (cached_has_bits & 0x00000400u) {
    target = stream->WriteBytesMaybeAliased(
        16, this->_internal_normals_dev(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:geo_globetrotter_proto_rocktree.Mesh)
  return target;
}

size_t Mesh::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:geo_globetrotter_proto_rocktree.Mesh)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .geo_globetrotter_proto_rocktree.Texture texture = 6;
  total_size += 1UL * this->_internal_texture_size();
  for (const auto& msg : this->texture_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated float uv_offset_and_scale = 10 [packed = true];
  {
    unsigned int count = static_cast<unsigned int>(this->_internal_uv_offset_and_scale_size());
    size_t data_size = 4UL * count;
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    total_size += data_size;
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional bytes vertices = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_vertices());
    }

    // optional bytes texture_coords = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_texture_coords());
    }

    // optional bytes indices = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_indices());
    }

    // optional bytes octant_ranges = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_octant_ranges());
    }

    // optional bytes layer_counts = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_layer_counts());
    }

    // optional bytes texture_coordinates = 7;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_texture_coordinates());
    }

    // optional bytes layer_and_octant_counts = 8;
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_layer_and_octant_counts());
    }

    // optional bytes vertex_alphas = 9;
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_vertex_alphas());
    }

  }
  if (cached_has_bits & 0x00000f00u) {
    // optional bytes normals = 11;
    if (cached_has_bits & 0x00000100u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_normals());
    }

    // optional bytes skirt_flags = 13;
    if (cached_has_bits & 0x00000200u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_skirt_flags());
    }

    // optional bytes normals_dev = 16;
    if (cached_has_bits & 0x00000400u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->_internal_normals_dev());
    }

    // optional uint32 mesh_id = 12;
    if (cached_has_bits & 0x00000800u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_mesh_id());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Mesh::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Mesh::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Mesh::GetClassData() const { return &_class_data_; }

void Mesh::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<Mesh *>(to)->MergeFrom(
      static_cast<const Mesh &>(from));
}


void Mesh::MergeFrom(const Mesh& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:geo_globetrotter_proto_rocktree.Mesh)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  texture_.MergeFrom(from.texture_);
  uv_offset_and_scale_.MergeFrom(from.uv_offset_and_scale_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_vertices(from._internal_vertices());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_set_texture_coords(from._internal_texture_coords());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_set_indices(from._internal_indices());
    }
    if (cached_has_bits & 0x00000008u) {
      _internal_set_octant_ranges(from._internal_octant_ranges());
    }
    if (cached_has_bits & 0x00000010u) {
      _internal_set_layer_counts(from._internal_layer_counts());
    }
    if (cached_has_bits & 0x00000020u) {
      _internal_set_texture_coordinates(from._internal_texture_coordinates());
    }
    if (cached_has_bits & 0x00000040u) {
      _internal_set_layer_and_octant_counts(from._internal_layer_and_octant_counts());
    }
    if (cached_has_bits & 0x00000080u) {
      _internal_set_vertex_alphas(from._internal_vertex_alphas());
    }
  }
  if (cached_has_bits & 0x00000f00u) {
    if (cached_has_bits & 0x00000100u) {
      _internal_set_normals(from._internal_normals());
    }
    if (cached_has_bits & 0x00000200u) {
      _internal_set_skirt_flags(from._internal_skirt_flags());
    }
    if (cached_has_bits & 0x00000400u) {
      _internal_set_normals_dev(from._internal_normals_dev());
    }
    if (cached_has_bits & 0x00000800u) {
      mesh_id_ = from.mesh_id_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Mesh::CopyFrom(const Mesh& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:geo_globetrotter_proto_rocktree.Mesh)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Mesh::IsInitialized() const {
  return true;
}

void Mesh::InternalSwap(Mesh* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  texture_.InternalSwap(&other->texture_);
  uv_offset_and_scale_.InternalSwap(&other->uv_offset_and_scale_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &vertices_, GetArenaForAllocation(),
      &other->vertices_, other->GetArenaForAllocation()
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &texture_coords_, GetArenaForAllocation(),
      &other->texture_coords_, other->GetArenaForAllocation()
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &indices_, GetArenaForAllocation(),
      &other->indices_, other->GetArenaForAllocation()
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &octant_ranges_, GetArenaForAllocation(),
      &other->octant_ranges_, other->GetArenaForAllocation()
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &layer_counts_, GetArenaForAllocation(),
      &other->layer_counts_, other->GetArenaForAllocation()
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &texture_coordinates_, GetArenaForAllocation(),
      &other->texture_coordinates_, other->GetArenaForAllocation()
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &layer_and_octant_counts_, GetArenaForAllocation(),
      &other->layer_and_octant_counts_, other->GetArenaForAllocation()
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &vertex_alphas_, GetArenaForAllocation(),
      &other->vertex_alphas_, other->GetArenaForAllocation()
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &normals_, GetArenaForAllocation(),
      &other->normals_, other->GetArenaForAllocation()
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &skirt_flags_, GetArenaForAllocation(),
      &other->skirt_flags_, other->GetArenaForAllocation()
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &normals_dev_, GetArenaForAllocation(),
      &other->normals_dev_, other->GetArenaForAllocation()
  );
  swap(mesh_id_, other->mesh_id_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Mesh::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_rocktree_2eproto_getter, &descriptor_table_rocktree_2eproto_once,
      file_level_metadata_rocktree_2eproto[8]);
}

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

class Texture::_Internal {
 public:
  using HasBits = decltype(std::declval<Texture>()._has_bits_);
  static void set_has_format(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_width(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_height(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_view_direction(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_mesh_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

Texture::Texture(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  data_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:geo_globetrotter_proto_rocktree.Texture)
}
Texture::Texture(const Texture& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      data_(from.data_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&view_direction_, &from.view_direction_,
    static_cast<size_t>(reinterpret_cast<char*>(&width_) -
    reinterpret_cast<char*>(&view_direction_)) + sizeof(width_));
  // @@protoc_insertion_point(copy_constructor:geo_globetrotter_proto_rocktree.Texture)
}

inline void Texture::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&view_direction_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&mesh_id_) -
    reinterpret_cast<char*>(&view_direction_)) + sizeof(mesh_id_));
height_ = 256u;
format_ = 1;
width_ = 256u;
}

Texture::~Texture() {
  // @@protoc_insertion_point(destructor:geo_globetrotter_proto_rocktree.Texture)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Texture::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void Texture::ArenaDtor(void* object) {
  Texture* _this = reinterpret_cast< Texture* >(object);
  (void)_this;
}
void Texture::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Texture::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Texture::Clear() {
// @@protoc_insertion_point(message_clear_start:geo_globetrotter_proto_rocktree.Texture)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  data_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    ::memset(&view_direction_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&mesh_id_) -
        reinterpret_cast<char*>(&view_direction_)) + sizeof(mesh_id_));
    height_ = 256u;
    format_ = 1;
    width_ = 256u;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Texture::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated bytes data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_data();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // optional .geo_globetrotter_proto_rocktree.Texture.Format format = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::geo_globetrotter_proto_rocktree::Texture_Format_IsValid(val))) {
            _internal_set_format(static_cast<::geo_globetrotter_proto_rocktree::Texture_Format>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional uint32 width = 3 [default = 256];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_width(&has_bits);
          width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 height = 4 [default = 256];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_height(&has_bits);
          height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .geo_globetrotter_proto_rocktree.Texture.ViewDirection view_direction = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::geo_globetrotter_proto_rocktree::Texture_ViewDirection_IsValid(val))) {
            _internal_set_view_direction(static_cast<::geo_globetrotter_proto_rocktree::Texture_ViewDirection>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional uint32 mesh_id = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_mesh_id(&has_bits);
          mesh_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Texture::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:geo_globetrotter_proto_rocktree.Texture)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated bytes data = 1;
  for (int i = 0, n = this->_internal_data_size(); i < n; i++) {
    const auto& s = this->_internal_data(i);
    target = stream->WriteBytes(1, s, target);
  }

  cached_has_bits = _has_bits_[0];
  // optional .geo_globetrotter_proto_rocktree.Texture.Format format = 2;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_format(), target);
  }

  // optional uint32 width = 3 [default = 256];
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_width(), target);
  }

  // optional uint32 height = 4 [default = 256];
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_height(), target);
  }

  // optional .geo_globetrotter_proto_rocktree.Texture.ViewDirection view_direction = 5;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      5, this->_internal_view_direction(), target);
  }

  // optional uint32 mesh_id = 6;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_mesh_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:geo_globetrotter_proto_rocktree.Texture)
  return target;
}

size_t Texture::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:geo_globetrotter_proto_rocktree.Texture)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated bytes data = 1;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(data_.size());
  for (int i = 0, n = data_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
      data_.Get(i));
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional .geo_globetrotter_proto_rocktree.Texture.ViewDirection view_direction = 5;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_view_direction());
    }

    // optional uint32 mesh_id = 6;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_mesh_id());
    }

    // optional uint32 height = 4 [default = 256];
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_height());
    }

    // optional .geo_globetrotter_proto_rocktree.Texture.Format format = 2;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_format());
    }

    // optional uint32 width = 3 [default = 256];
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_width());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Texture::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Texture::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Texture::GetClassData() const { return &_class_data_; }

void Texture::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<Texture *>(to)->MergeFrom(
      static_cast<const Texture &>(from));
}


void Texture::MergeFrom(const Texture& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:geo_globetrotter_proto_rocktree.Texture)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  data_.MergeFrom(from.data_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      view_direction_ = from.view_direction_;
    }
    if (cached_has_bits & 0x00000002u) {
      mesh_id_ = from.mesh_id_;
    }
    if (cached_has_bits & 0x00000004u) {
      height_ = from.height_;
    }
    if (cached_has_bits & 0x00000008u) {
      format_ = from.format_;
    }
    if (cached_has_bits & 0x00000010u) {
      width_ = from.width_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Texture::CopyFrom(const Texture& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:geo_globetrotter_proto_rocktree.Texture)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Texture::IsInitialized() const {
  return true;
}

void Texture::InternalSwap(Texture* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  data_.InternalSwap(&other->data_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Texture, mesh_id_)
      + sizeof(Texture::mesh_id_)
      - PROTOBUF_FIELD_OFFSET(Texture, view_direction_)>(
          reinterpret_cast<char*>(&view_direction_),
          reinterpret_cast<char*>(&other->view_direction_));
  swap(height_, other->height_);
  swap(format_, other->format_);
  swap(width_, other->width_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Texture::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_rocktree_2eproto_getter, &descriptor_table_rocktree_2eproto_once,
      file_level_metadata_rocktree_2eproto[9]);
}

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

class TextureData::_Internal {
 public:
  using HasBits = decltype(std::declval<TextureData>()._has_bits_);
  static const ::geo_globetrotter_proto_rocktree::NodeKey& node_key(const TextureData* msg);
  static void set_has_node_key(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::geo_globetrotter_proto_rocktree::NodeKey&
TextureData::_Internal::node_key(const TextureData* msg) {
  return *msg->node_key_;
}
TextureData::TextureData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  textures_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:geo_globetrotter_proto_rocktree.TextureData)
}
TextureData::TextureData(const TextureData& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      textures_(from.textures_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_node_key()) {
    node_key_ = new ::geo_globetrotter_proto_rocktree::NodeKey(*from.node_key_);
  } else {
    node_key_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:geo_globetrotter_proto_rocktree.TextureData)
}

inline void TextureData::SharedCtor() {
node_key_ = nullptr;
}

TextureData::~TextureData() {
  // @@protoc_insertion_point(destructor:geo_globetrotter_proto_rocktree.TextureData)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void TextureData::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete node_key_;
}

void TextureData::ArenaDtor(void* object) {
  TextureData* _this = reinterpret_cast< TextureData* >(object);
  (void)_this;
}
void TextureData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void TextureData::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void TextureData::Clear() {
// @@protoc_insertion_point(message_clear_start:geo_globetrotter_proto_rocktree.TextureData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  textures_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(node_key_ != nullptr);
    node_key_->Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* TextureData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_node_key(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .geo_globetrotter_proto_rocktree.Texture textures = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_textures(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* TextureData::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:geo_globetrotter_proto_rocktree.TextureData)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::node_key(this), target, stream);
  }

  // repeated .geo_globetrotter_proto_rocktree.Texture textures = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_textures_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, this->_internal_textures(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:geo_globetrotter_proto_rocktree.TextureData)
  return target;
}

size_t TextureData::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:geo_globetrotter_proto_rocktree.TextureData)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .geo_globetrotter_proto_rocktree.Texture textures = 2;
  total_size += 1UL * this->_internal_textures_size();
  for (const auto& msg : this->textures_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *node_key_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData TextureData::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    TextureData::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*TextureData::GetClassData() const { return &_class_data_; }

void TextureData::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<TextureData *>(to)->MergeFrom(
      static_cast<const TextureData &>(from));
}


void TextureData::MergeFrom(const TextureData& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:geo_globetrotter_proto_rocktree.TextureData)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  textures_.MergeFrom(from.textures_);
  if (from._internal_has_node_key()) {
    _internal_mutable_node_key()->::geo_globetrotter_proto_rocktree::NodeKey::MergeFrom(from._internal_node_key());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void TextureData::CopyFrom(const TextureData& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:geo_globetrotter_proto_rocktree.TextureData)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TextureData::IsInitialized() const {
  return true;
}

void TextureData::InternalSwap(TextureData* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  textures_.InternalSwap(&other->textures_);
  swap(node_key_, other->node_key_);
}

::PROTOBUF_NAMESPACE_ID::Metadata TextureData::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_rocktree_2eproto_getter, &descriptor_table_rocktree_2eproto_once,
      file_level_metadata_rocktree_2eproto[10]);
}

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

class Copyrights::_Internal {
 public:
};

Copyrights::Copyrights(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  copyrights_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:geo_globetrotter_proto_rocktree.Copyrights)
}
Copyrights::Copyrights(const Copyrights& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      copyrights_(from.copyrights_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:geo_globetrotter_proto_rocktree.Copyrights)
}

inline void Copyrights::SharedCtor() {
}

Copyrights::~Copyrights() {
  // @@protoc_insertion_point(destructor:geo_globetrotter_proto_rocktree.Copyrights)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Copyrights::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void Copyrights::ArenaDtor(void* object) {
  Copyrights* _this = reinterpret_cast< Copyrights* >(object);
  (void)_this;
}
void Copyrights::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Copyrights::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Copyrights::Clear() {
// @@protoc_insertion_point(message_clear_start:geo_globetrotter_proto_rocktree.Copyrights)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  copyrights_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Copyrights::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .geo_globetrotter_proto_rocktree.Copyright copyrights = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_copyrights(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Copyrights::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:geo_globetrotter_proto_rocktree.Copyrights)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .geo_globetrotter_proto_rocktree.Copyright copyrights = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_copyrights_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_copyrights(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:geo_globetrotter_proto_rocktree.Copyrights)
  return target;
}

size_t Copyrights::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:geo_globetrotter_proto_rocktree.Copyrights)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .geo_globetrotter_proto_rocktree.Copyright copyrights = 1;
  total_size += 1UL * this->_internal_copyrights_size();
  for (const auto& msg : this->copyrights_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Copyrights::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Copyrights::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Copyrights::GetClassData() const { return &_class_data_; }

void Copyrights::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<Copyrights *>(to)->MergeFrom(
      static_cast<const Copyrights &>(from));
}


void Copyrights::MergeFrom(const Copyrights& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:geo_globetrotter_proto_rocktree.Copyrights)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  copyrights_.MergeFrom(from.copyrights_);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Copyrights::CopyFrom(const Copyrights& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:geo_globetrotter_proto_rocktree.Copyrights)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Copyrights::IsInitialized() const {
  return true;
}

void Copyrights::InternalSwap(Copyrights* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  copyrights_.InternalSwap(&other->copyrights_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Copyrights::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_rocktree_2eproto_getter, &descriptor_table_rocktree_2eproto_once,
      file_level_metadata_rocktree_2eproto[11]);
}

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

class Copyright::_Internal {
 public:
  using HasBits = decltype(std::declval<Copyright>()._has_bits_);
  static void set_has_id(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_text(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_text_clean(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

Copyright::Copyright(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:geo_globetrotter_proto_rocktree.Copyright)
}
Copyright::Copyright(const Copyright& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  text_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_text()) {
    text_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_text(), 
      GetArenaForAllocation());
  }
  text_clean_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_text_clean()) {
    text_clean_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_text_clean(), 
      GetArenaForAllocation());
  }
  id_ = from.id_;
  // @@protoc_insertion_point(copy_constructor:geo_globetrotter_proto_rocktree.Copyright)
}

inline void Copyright::SharedCtor() {
text_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
text_clean_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
id_ = 0u;
}

Copyright::~Copyright() {
  // @@protoc_insertion_point(destructor:geo_globetrotter_proto_rocktree.Copyright)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void Copyright::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  text_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  text_clean_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void Copyright::ArenaDtor(void* object) {
  Copyright* _this = reinterpret_cast< Copyright* >(object);
  (void)_this;
}
void Copyright::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Copyright::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void Copyright::Clear() {
// @@protoc_insertion_point(message_clear_start:geo_globetrotter_proto_rocktree.Copyright)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      text_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      text_clean_.ClearNonDefaultToEmpty();
    }
  }
  id_ = 0u;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Copyright::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional uint32 id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_id(&has_bits);
          id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string text = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_text();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "geo_globetrotter_proto_rocktree.Copyright.text");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string text_clean = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          auto str = _internal_mutable_text_clean();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "geo_globetrotter_proto_rocktree.Copyright.text_clean");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Copyright::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:geo_globetrotter_proto_rocktree.Copyright)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 id = 1;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_id(), target);
  }

  // optional string text = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_text().data(), static_cast<int>(this->_internal_text().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "geo_globetrotter_proto_rocktree.Copyright.text");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_text(), target);
  }

  // optional string text_clean = 3;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_text_clean().data(), static_cast<int>(this->_internal_text_clean().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "geo_globetrotter_proto_rocktree.Copyright.text_clean");
    target = stream->WriteStringMaybeAliased(
        3, this->_internal_text_clean(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:geo_globetrotter_proto_rocktree.Copyright)
  return target;
}

size_t Copyright::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:geo_globetrotter_proto_rocktree.Copyright)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional string text = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_text());
    }

    // optional string text_clean = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_text_clean());
    }

    // optional uint32 id = 1;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->_internal_id());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Copyright::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    Copyright::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Copyright::GetClassData() const { return &_class_data_; }

void Copyright::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<Copyright *>(to)->MergeFrom(
      static_cast<const Copyright &>(from));
}


void Copyright::MergeFrom(const Copyright& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:geo_globetrotter_proto_rocktree.Copyright)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_text(from._internal_text());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_set_text_clean(from._internal_text_clean());
    }
    if (cached_has_bits & 0x00000004u) {
      id_ = from.id_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Copyright::CopyFrom(const Copyright& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:geo_globetrotter_proto_rocktree.Copyright)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Copyright::IsInitialized() const {
  return true;
}

void Copyright::InternalSwap(Copyright* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &text_, GetArenaForAllocation(),
      &other->text_, other->GetArenaForAllocation()
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &text_clean_, GetArenaForAllocation(),
      &other->text_clean_, other->GetArenaForAllocation()
  );
  swap(id_, other->id_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Copyright::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_rocktree_2eproto_getter, &descriptor_table_rocktree_2eproto_once,
      file_level_metadata_rocktree_2eproto[12]);
}

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

class PlanetoidMetadata::_Internal {
 public:
  using HasBits = decltype(std::declval<PlanetoidMetadata>()._has_bits_);
  static const ::geo_globetrotter_proto_rocktree::NodeMetadata& root_node_metadata(const PlanetoidMetadata* msg);
  static void set_has_root_node_metadata(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_radius(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_min_terrain_altitude(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_max_terrain_altitude(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

const ::geo_globetrotter_proto_rocktree::NodeMetadata&
PlanetoidMetadata::_Internal::root_node_metadata(const PlanetoidMetadata* msg) {
  return *msg->root_node_metadata_;
}
PlanetoidMetadata::PlanetoidMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:geo_globetrotter_proto_rocktree.PlanetoidMetadata)
}
PlanetoidMetadata::PlanetoidMetadata(const PlanetoidMetadata& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_root_node_metadata()) {
    root_node_metadata_ = new ::geo_globetrotter_proto_rocktree::NodeMetadata(*from.root_node_metadata_);
  } else {
    root_node_metadata_ = nullptr;
  }
  ::memcpy(&radius_, &from.radius_,
    static_cast<size_t>(reinterpret_cast<char*>(&max_terrain_altitude_) -
    reinterpret_cast<char*>(&radius_)) + sizeof(max_terrain_altitude_));
  // @@protoc_insertion_point(copy_constructor:geo_globetrotter_proto_rocktree.PlanetoidMetadata)
}

inline void PlanetoidMetadata::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&root_node_metadata_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&max_terrain_altitude_) -
    reinterpret_cast<char*>(&root_node_metadata_)) + sizeof(max_terrain_altitude_));
}

PlanetoidMetadata::~PlanetoidMetadata() {
  // @@protoc_insertion_point(destructor:geo_globetrotter_proto_rocktree.PlanetoidMetadata)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void PlanetoidMetadata::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete root_node_metadata_;
}

void PlanetoidMetadata::ArenaDtor(void* object) {
  PlanetoidMetadata* _this = reinterpret_cast< PlanetoidMetadata* >(object);
  (void)_this;
}
void PlanetoidMetadata::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void PlanetoidMetadata::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void PlanetoidMetadata::Clear() {
// @@protoc_insertion_point(message_clear_start:geo_globetrotter_proto_rocktree.PlanetoidMetadata)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(root_node_metadata_ != nullptr);
    root_node_metadata_->Clear();
  }
  if (cached_has_bits & 0x0000000eu) {
    ::memset(&radius_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&max_terrain_altitude_) -
        reinterpret_cast<char*>(&radius_)) + sizeof(max_terrain_altitude_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* PlanetoidMetadata::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .geo_globetrotter_proto_rocktree.NodeMetadata root_node_metadata = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_root_node_metadata(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional float radius = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          _Internal::set_has_radius(&has_bits);
          radius_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // optional float min_terrain_altitude = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
          _Internal::set_has_min_terrain_altitude(&has_bits);
          min_terrain_altitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // optional float max_terrain_altitude = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) {
          _Internal::set_has_max_terrain_altitude(&has_bits);
          max_terrain_altitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* PlanetoidMetadata::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:geo_globetrotter_proto_rocktree.PlanetoidMetadata)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .geo_globetrotter_proto_rocktree.NodeMetadata root_node_metadata = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::root_node_metadata(this), target, stream);
  }

  // optional float radius = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_radius(), target);
  }

  // optional float min_terrain_altitude = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_min_terrain_altitude(), target);
  }

  // optional float max_terrain_altitude = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_max_terrain_altitude(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:geo_globetrotter_proto_rocktree.PlanetoidMetadata)
  return target;
}

size_t PlanetoidMetadata::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:geo_globetrotter_proto_rocktree.PlanetoidMetadata)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional .geo_globetrotter_proto_rocktree.NodeMetadata root_node_metadata = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *root_node_metadata_);
    }

    // optional float radius = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 4;
    }

    // optional float min_terrain_altitude = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 4;
    }

    // optional float max_terrain_altitude = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 4;
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PlanetoidMetadata::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    PlanetoidMetadata::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PlanetoidMetadata::GetClassData() const { return &_class_data_; }

void PlanetoidMetadata::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<PlanetoidMetadata *>(to)->MergeFrom(
      static_cast<const PlanetoidMetadata &>(from));
}


void PlanetoidMetadata::MergeFrom(const PlanetoidMetadata& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:geo_globetrotter_proto_rocktree.PlanetoidMetadata)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_root_node_metadata()->::geo_globetrotter_proto_rocktree::NodeMetadata::MergeFrom(from._internal_root_node_metadata());
    }
    if (cached_has_bits & 0x00000002u) {
      radius_ = from.radius_;
    }
    if (cached_has_bits & 0x00000004u) {
      min_terrain_altitude_ = from.min_terrain_altitude_;
    }
    if (cached_has_bits & 0x00000008u) {
      max_terrain_altitude_ = from.max_terrain_altitude_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void PlanetoidMetadata::CopyFrom(const PlanetoidMetadata& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:geo_globetrotter_proto_rocktree.PlanetoidMetadata)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PlanetoidMetadata::IsInitialized() const {
  return true;
}

void PlanetoidMetadata::InternalSwap(PlanetoidMetadata* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(PlanetoidMetadata, max_terrain_altitude_)
      + sizeof(PlanetoidMetadata::max_terrain_altitude_)
      - PROTOBUF_FIELD_OFFSET(PlanetoidMetadata, root_node_metadata_)>(
          reinterpret_cast<char*>(&root_node_metadata_),
          reinterpret_cast<char*>(&other->root_node_metadata_));
}

::PROTOBUF_NAMESPACE_ID::Metadata PlanetoidMetadata::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_rocktree_2eproto_getter, &descriptor_table_rocktree_2eproto_once,
      file_level_metadata_rocktree_2eproto[13]);
}

// @@protoc_insertion_point(namespace_scope)
}  // namespace geo_globetrotter_proto_rocktree
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::geo_globetrotter_proto_rocktree::BulkMetadataRequest* Arena::CreateMaybeMessage< ::geo_globetrotter_proto_rocktree::BulkMetadataRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::geo_globetrotter_proto_rocktree::BulkMetadataRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::geo_globetrotter_proto_rocktree::NodeDataRequest* Arena::CreateMaybeMessage< ::geo_globetrotter_proto_rocktree::NodeDataRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::geo_globetrotter_proto_rocktree::NodeDataRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::geo_globetrotter_proto_rocktree::NodeKey* Arena::CreateMaybeMessage< ::geo_globetrotter_proto_rocktree::NodeKey >(Arena* arena) {
  return Arena::CreateMessageInternal< ::geo_globetrotter_proto_rocktree::NodeKey >(arena);
}
template<> PROTOBUF_NOINLINE ::geo_globetrotter_proto_rocktree::CopyrightRequest* Arena::CreateMaybeMessage< ::geo_globetrotter_proto_rocktree::CopyrightRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::geo_globetrotter_proto_rocktree::CopyrightRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::geo_globetrotter_proto_rocktree::TextureDataRequest* Arena::CreateMaybeMessage< ::geo_globetrotter_proto_rocktree::TextureDataRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::geo_globetrotter_proto_rocktree::TextureDataRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::geo_globetrotter_proto_rocktree::BulkMetadata* Arena::CreateMaybeMessage< ::geo_globetrotter_proto_rocktree::BulkMetadata >(Arena* arena) {
  return Arena::CreateMessageInternal< ::geo_globetrotter_proto_rocktree::BulkMetadata >(arena);
}
template<> PROTOBUF_NOINLINE ::geo_globetrotter_proto_rocktree::NodeMetadata* Arena::CreateMaybeMessage< ::geo_globetrotter_proto_rocktree::NodeMetadata >(Arena* arena) {
  return Arena::CreateMessageInternal< ::geo_globetrotter_proto_rocktree::NodeMetadata >(arena);
}
template<> PROTOBUF_NOINLINE ::geo_globetrotter_proto_rocktree::NodeData* Arena::CreateMaybeMessage< ::geo_globetrotter_proto_rocktree::NodeData >(Arena* arena) {
  return Arena::CreateMessageInternal< ::geo_globetrotter_proto_rocktree::NodeData >(arena);
}
template<> PROTOBUF_NOINLINE ::geo_globetrotter_proto_rocktree::Mesh* Arena::CreateMaybeMessage< ::geo_globetrotter_proto_rocktree::Mesh >(Arena* arena) {
  return Arena::CreateMessageInternal< ::geo_globetrotter_proto_rocktree::Mesh >(arena);
}
template<> PROTOBUF_NOINLINE ::geo_globetrotter_proto_rocktree::Texture* Arena::CreateMaybeMessage< ::geo_globetrotter_proto_rocktree::Texture >(Arena* arena) {
  return Arena::CreateMessageInternal< ::geo_globetrotter_proto_rocktree::Texture >(arena);
}
template<> PROTOBUF_NOINLINE ::geo_globetrotter_proto_rocktree::TextureData* Arena::CreateMaybeMessage< ::geo_globetrotter_proto_rocktree::TextureData >(Arena* arena) {
  return Arena::CreateMessageInternal< ::geo_globetrotter_proto_rocktree::TextureData >(arena);
}
template<> PROTOBUF_NOINLINE ::geo_globetrotter_proto_rocktree::Copyrights* Arena::CreateMaybeMessage< ::geo_globetrotter_proto_rocktree::Copyrights >(Arena* arena) {
  return Arena::CreateMessageInternal< ::geo_globetrotter_proto_rocktree::Copyrights >(arena);
}
template<> PROTOBUF_NOINLINE ::geo_globetrotter_proto_rocktree::Copyright* Arena::CreateMaybeMessage< ::geo_globetrotter_proto_rocktree::Copyright >(Arena* arena) {
  return Arena::CreateMessageInternal< ::geo_globetrotter_proto_rocktree::Copyright >(arena);
}
template<> PROTOBUF_NOINLINE ::geo_globetrotter_proto_rocktree::PlanetoidMetadata* Arena::CreateMaybeMessage< ::geo_globetrotter_proto_rocktree::PlanetoidMetadata >(Arena* arena) {
  return Arena::CreateMessageInternal< ::geo_globetrotter_proto_rocktree::PlanetoidMetadata >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
