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

#ifndef GOOGLE_PROTOBUF_INCLUDED_rocktree_2eproto_2epb_2eh
#define GOOGLE_PROTOBUF_INCLUDED_rocktree_2eproto_2epb_2eh

#include <limits>
#include <string>
#include <type_traits>

#include "google/protobuf/port_def.inc"
#if PROTOBUF_VERSION < 3021000
#error "This file was generated by a newer version of protoc which is"
#error "incompatible with your Protocol Buffer headers. Please update"
#error "your headers."
#endif  // PROTOBUF_VERSION

#if 3021010 < PROTOBUF_MIN_PROTOC_VERSION
#error "This file was generated by an older version of protoc which is"
#error "incompatible with your Protocol Buffer headers. Please"
#error "regenerate this file with a newer version of protoc."
#endif  // PROTOBUF_MIN_PROTOC_VERSION
#include "google/protobuf/port_undef.inc"
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/metadata_lite.h"
#include "google/protobuf/generated_message_reflection.h"
#include "google/protobuf/message.h"
#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
#include "google/protobuf/extension_set.h"  // IWYU pragma: export
#include "google/protobuf/generated_enum_reflection.h"
#include "google/protobuf/unknown_field_set.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_rocktree_2eproto

PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_rocktree_2eproto {
  static const ::uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable
    descriptor_table_rocktree_2eproto;
namespace geo_globetrotter_proto_rocktree {
class BulkMetadata;
struct BulkMetadataDefaultTypeInternal;
extern BulkMetadataDefaultTypeInternal _BulkMetadata_default_instance_;
class BulkMetadataRequest;
struct BulkMetadataRequestDefaultTypeInternal;
extern BulkMetadataRequestDefaultTypeInternal _BulkMetadataRequest_default_instance_;
class Copyright;
struct CopyrightDefaultTypeInternal;
extern CopyrightDefaultTypeInternal _Copyright_default_instance_;
class CopyrightRequest;
struct CopyrightRequestDefaultTypeInternal;
extern CopyrightRequestDefaultTypeInternal _CopyrightRequest_default_instance_;
class Copyrights;
struct CopyrightsDefaultTypeInternal;
extern CopyrightsDefaultTypeInternal _Copyrights_default_instance_;
class Mesh;
struct MeshDefaultTypeInternal;
extern MeshDefaultTypeInternal _Mesh_default_instance_;
class NodeData;
struct NodeDataDefaultTypeInternal;
extern NodeDataDefaultTypeInternal _NodeData_default_instance_;
class NodeDataRequest;
struct NodeDataRequestDefaultTypeInternal;
extern NodeDataRequestDefaultTypeInternal _NodeDataRequest_default_instance_;
class NodeKey;
struct NodeKeyDefaultTypeInternal;
extern NodeKeyDefaultTypeInternal _NodeKey_default_instance_;
class NodeMetadata;
struct NodeMetadataDefaultTypeInternal;
extern NodeMetadataDefaultTypeInternal _NodeMetadata_default_instance_;
class PlanetoidMetadata;
struct PlanetoidMetadataDefaultTypeInternal;
extern PlanetoidMetadataDefaultTypeInternal _PlanetoidMetadata_default_instance_;
class Texture;
struct TextureDefaultTypeInternal;
extern TextureDefaultTypeInternal _Texture_default_instance_;
class TextureData;
struct TextureDataDefaultTypeInternal;
extern TextureDataDefaultTypeInternal _TextureData_default_instance_;
class TextureDataRequest;
struct TextureDataRequestDefaultTypeInternal;
extern TextureDataRequestDefaultTypeInternal _TextureDataRequest_default_instance_;
}  // namespace geo_globetrotter_proto_rocktree
PROTOBUF_NAMESPACE_OPEN
template <>
::geo_globetrotter_proto_rocktree::BulkMetadata* Arena::CreateMaybeMessage<::geo_globetrotter_proto_rocktree::BulkMetadata>(Arena*);
template <>
::geo_globetrotter_proto_rocktree::BulkMetadataRequest* Arena::CreateMaybeMessage<::geo_globetrotter_proto_rocktree::BulkMetadataRequest>(Arena*);
template <>
::geo_globetrotter_proto_rocktree::Copyright* Arena::CreateMaybeMessage<::geo_globetrotter_proto_rocktree::Copyright>(Arena*);
template <>
::geo_globetrotter_proto_rocktree::CopyrightRequest* Arena::CreateMaybeMessage<::geo_globetrotter_proto_rocktree::CopyrightRequest>(Arena*);
template <>
::geo_globetrotter_proto_rocktree::Copyrights* Arena::CreateMaybeMessage<::geo_globetrotter_proto_rocktree::Copyrights>(Arena*);
template <>
::geo_globetrotter_proto_rocktree::Mesh* Arena::CreateMaybeMessage<::geo_globetrotter_proto_rocktree::Mesh>(Arena*);
template <>
::geo_globetrotter_proto_rocktree::NodeData* Arena::CreateMaybeMessage<::geo_globetrotter_proto_rocktree::NodeData>(Arena*);
template <>
::geo_globetrotter_proto_rocktree::NodeDataRequest* Arena::CreateMaybeMessage<::geo_globetrotter_proto_rocktree::NodeDataRequest>(Arena*);
template <>
::geo_globetrotter_proto_rocktree::NodeKey* Arena::CreateMaybeMessage<::geo_globetrotter_proto_rocktree::NodeKey>(Arena*);
template <>
::geo_globetrotter_proto_rocktree::NodeMetadata* Arena::CreateMaybeMessage<::geo_globetrotter_proto_rocktree::NodeMetadata>(Arena*);
template <>
::geo_globetrotter_proto_rocktree::PlanetoidMetadata* Arena::CreateMaybeMessage<::geo_globetrotter_proto_rocktree::PlanetoidMetadata>(Arena*);
template <>
::geo_globetrotter_proto_rocktree::Texture* Arena::CreateMaybeMessage<::geo_globetrotter_proto_rocktree::Texture>(Arena*);
template <>
::geo_globetrotter_proto_rocktree::TextureData* Arena::CreateMaybeMessage<::geo_globetrotter_proto_rocktree::TextureData>(Arena*);
template <>
::geo_globetrotter_proto_rocktree::TextureDataRequest* Arena::CreateMaybeMessage<::geo_globetrotter_proto_rocktree::TextureDataRequest>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

namespace geo_globetrotter_proto_rocktree {
enum NodeMetadata_Flags : int {
  NodeMetadata_Flags_RICH3D_LEAF = 1,
  NodeMetadata_Flags_RICH3D_NODATA = 2,
  NodeMetadata_Flags_LEAF = 4,
  NodeMetadata_Flags_NODATA = 8,
  NodeMetadata_Flags_USE_IMAGERY_EPOCH = 16,
};

bool NodeMetadata_Flags_IsValid(int value);
constexpr NodeMetadata_Flags NodeMetadata_Flags_Flags_MIN = static_cast<NodeMetadata_Flags>(1);
constexpr NodeMetadata_Flags NodeMetadata_Flags_Flags_MAX = static_cast<NodeMetadata_Flags>(16);
constexpr int NodeMetadata_Flags_Flags_ARRAYSIZE = 16 + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
NodeMetadata_Flags_descriptor();
template <typename T>
const std::string& NodeMetadata_Flags_Name(T value) {
  static_assert(std::is_same<T, NodeMetadata_Flags>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to Flags_Name().");
  return NodeMetadata_Flags_Name(static_cast<NodeMetadata_Flags>(value));
}
template <>
inline const std::string& NodeMetadata_Flags_Name(NodeMetadata_Flags value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum<NodeMetadata_Flags_descriptor,
                                                 1, 16>(
      static_cast<int>(value));
}
inline bool NodeMetadata_Flags_Parse(absl::string_view name, NodeMetadata_Flags* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<NodeMetadata_Flags>(
      NodeMetadata_Flags_descriptor(), name, value);
}
enum Mesh_Layer : int {
  Mesh_Layer_OVERGROUND = 0,
  Mesh_Layer_TERRAIN_BELOW_WATER = 1,
  Mesh_Layer_TERRAIN_ABOVE_WATER = 2,
  Mesh_Layer_TERRAIN_HIDDEN = 3,
  Mesh_Layer_WATER = 4,
  Mesh_Layer_WATER_SKIRTS = 5,
  Mesh_Layer_WATER_SKIRTS_INVERTED = 6,
  Mesh_Layer_OVERLAY_SURFACE = 7,
  Mesh_Layer_OVERLAY_SURFACE_SKIRTS = 8,
  Mesh_Layer_NUM_LAYERS = 9,
};

bool Mesh_Layer_IsValid(int value);
constexpr Mesh_Layer Mesh_Layer_Layer_MIN = static_cast<Mesh_Layer>(0);
constexpr Mesh_Layer Mesh_Layer_Layer_MAX = static_cast<Mesh_Layer>(9);
constexpr int Mesh_Layer_Layer_ARRAYSIZE = 9 + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
Mesh_Layer_descriptor();
template <typename T>
const std::string& Mesh_Layer_Name(T value) {
  static_assert(std::is_same<T, Mesh_Layer>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to Layer_Name().");
  return Mesh_Layer_Name(static_cast<Mesh_Layer>(value));
}
template <>
inline const std::string& Mesh_Layer_Name(Mesh_Layer value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum<Mesh_Layer_descriptor,
                                                 0, 9>(
      static_cast<int>(value));
}
inline bool Mesh_Layer_Parse(absl::string_view name, Mesh_Layer* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Mesh_Layer>(
      Mesh_Layer_descriptor(), name, value);
}
enum Mesh_LayerMask : int {
  Mesh_LayerMask_TERRAIN_WITH_OVERGROUND = 7,
  Mesh_LayerMask_TERRAIN_WITH_WATER = 28,
  Mesh_LayerMask_TERRAIN_WITHOUT_WATER = 14,
};

bool Mesh_LayerMask_IsValid(int value);
constexpr Mesh_LayerMask Mesh_LayerMask_LayerMask_MIN = static_cast<Mesh_LayerMask>(7);
constexpr Mesh_LayerMask Mesh_LayerMask_LayerMask_MAX = static_cast<Mesh_LayerMask>(28);
constexpr int Mesh_LayerMask_LayerMask_ARRAYSIZE = 28 + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
Mesh_LayerMask_descriptor();
template <typename T>
const std::string& Mesh_LayerMask_Name(T value) {
  static_assert(std::is_same<T, Mesh_LayerMask>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to LayerMask_Name().");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(Mesh_LayerMask_descriptor(), value);
}
inline bool Mesh_LayerMask_Parse(absl::string_view name, Mesh_LayerMask* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Mesh_LayerMask>(
      Mesh_LayerMask_descriptor(), name, value);
}
enum Texture_Format : int {
  Texture_Format_JPG = 1,
  Texture_Format_DXT1 = 2,
  Texture_Format_ETC1 = 3,
  Texture_Format_PVRTC2 = 4,
  Texture_Format_PVRTC4 = 5,
  Texture_Format_CRN_DXT1 = 6,
};

bool Texture_Format_IsValid(int value);
constexpr Texture_Format Texture_Format_Format_MIN = static_cast<Texture_Format>(1);
constexpr Texture_Format Texture_Format_Format_MAX = static_cast<Texture_Format>(6);
constexpr int Texture_Format_Format_ARRAYSIZE = 6 + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
Texture_Format_descriptor();
template <typename T>
const std::string& Texture_Format_Name(T value) {
  static_assert(std::is_same<T, Texture_Format>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to Format_Name().");
  return Texture_Format_Name(static_cast<Texture_Format>(value));
}
template <>
inline const std::string& Texture_Format_Name(Texture_Format value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum<Texture_Format_descriptor,
                                                 1, 6>(
      static_cast<int>(value));
}
inline bool Texture_Format_Parse(absl::string_view name, Texture_Format* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Texture_Format>(
      Texture_Format_descriptor(), name, value);
}
enum Texture_ViewDirection : int {
  Texture_ViewDirection_NADIR = 0,
  Texture_ViewDirection_NORTH_45 = 1,
  Texture_ViewDirection_EAST_45 = 2,
  Texture_ViewDirection_SOUTH_45 = 3,
  Texture_ViewDirection_WEST_45 = 4,
};

bool Texture_ViewDirection_IsValid(int value);
constexpr Texture_ViewDirection Texture_ViewDirection_ViewDirection_MIN = static_cast<Texture_ViewDirection>(0);
constexpr Texture_ViewDirection Texture_ViewDirection_ViewDirection_MAX = static_cast<Texture_ViewDirection>(4);
constexpr int Texture_ViewDirection_ViewDirection_ARRAYSIZE = 4 + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
Texture_ViewDirection_descriptor();
template <typename T>
const std::string& Texture_ViewDirection_Name(T value) {
  static_assert(std::is_same<T, Texture_ViewDirection>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to ViewDirection_Name().");
  return Texture_ViewDirection_Name(static_cast<Texture_ViewDirection>(value));
}
template <>
inline const std::string& Texture_ViewDirection_Name(Texture_ViewDirection value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum<Texture_ViewDirection_descriptor,
                                                 0, 4>(
      static_cast<int>(value));
}
inline bool Texture_ViewDirection_Parse(absl::string_view name, Texture_ViewDirection* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Texture_ViewDirection>(
      Texture_ViewDirection_descriptor(), name, value);
}

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


// -------------------------------------------------------------------

class BulkMetadataRequest final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:geo_globetrotter_proto_rocktree.BulkMetadataRequest) */ {
 public:
  inline BulkMetadataRequest() : BulkMetadataRequest(nullptr) {}
  ~BulkMetadataRequest() override;
  explicit PROTOBUF_CONSTEXPR BulkMetadataRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  BulkMetadataRequest(const BulkMetadataRequest& from);
  BulkMetadataRequest(BulkMetadataRequest&& from) noexcept
    : BulkMetadataRequest() {
    *this = ::std::move(from);
  }

  inline BulkMetadataRequest& operator=(const BulkMetadataRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline BulkMetadataRequest& operator=(BulkMetadataRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const BulkMetadataRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const BulkMetadataRequest* internal_default_instance() {
    return reinterpret_cast<const BulkMetadataRequest*>(
               &_BulkMetadataRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(BulkMetadataRequest& a, BulkMetadataRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(BulkMetadataRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BulkMetadataRequest* other) {
    if (other == this) return;
    GOOGLE_ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  BulkMetadataRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BulkMetadataRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BulkMetadataRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BulkMetadataRequest& from) {
    BulkMetadataRequest::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BulkMetadataRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "geo_globetrotter_proto_rocktree.BulkMetadataRequest";
  }
  protected:
  explicit BulkMetadataRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNodeKeyFieldNumber = 1,
  };
  // optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 1;
  bool has_node_key() const;
  void clear_node_key() ;
  const ::geo_globetrotter_proto_rocktree::NodeKey& node_key() const;
  PROTOBUF_NODISCARD ::geo_globetrotter_proto_rocktree::NodeKey* release_node_key();
  ::geo_globetrotter_proto_rocktree::NodeKey* mutable_node_key();
  void set_allocated_node_key(::geo_globetrotter_proto_rocktree::NodeKey* node_key);
  private:
  const ::geo_globetrotter_proto_rocktree::NodeKey& _internal_node_key() const;
  ::geo_globetrotter_proto_rocktree::NodeKey* _internal_mutable_node_key();
  public:
  void unsafe_arena_set_allocated_node_key(
      ::geo_globetrotter_proto_rocktree::NodeKey* node_key);
  ::geo_globetrotter_proto_rocktree::NodeKey* unsafe_arena_release_node_key();
  // @@protoc_insertion_point(class_scope:geo_globetrotter_proto_rocktree.BulkMetadataRequest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::geo_globetrotter_proto_rocktree::NodeKey* node_key_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_rocktree_2eproto;
};// -------------------------------------------------------------------

class NodeDataRequest final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:geo_globetrotter_proto_rocktree.NodeDataRequest) */ {
 public:
  inline NodeDataRequest() : NodeDataRequest(nullptr) {}
  ~NodeDataRequest() override;
  explicit PROTOBUF_CONSTEXPR NodeDataRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  NodeDataRequest(const NodeDataRequest& from);
  NodeDataRequest(NodeDataRequest&& from) noexcept
    : NodeDataRequest() {
    *this = ::std::move(from);
  }

  inline NodeDataRequest& operator=(const NodeDataRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline NodeDataRequest& operator=(NodeDataRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const NodeDataRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const NodeDataRequest* internal_default_instance() {
    return reinterpret_cast<const NodeDataRequest*>(
               &_NodeDataRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(NodeDataRequest& a, NodeDataRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(NodeDataRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NodeDataRequest* other) {
    if (other == this) return;
    GOOGLE_ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  NodeDataRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NodeDataRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NodeDataRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const NodeDataRequest& from) {
    NodeDataRequest::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NodeDataRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "geo_globetrotter_proto_rocktree.NodeDataRequest";
  }
  protected:
  explicit NodeDataRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNodeKeyFieldNumber = 1,
    kImageryEpochFieldNumber = 3,
    kTextureFormatFieldNumber = 2,
  };
  // optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 1;
  bool has_node_key() const;
  void clear_node_key() ;
  const ::geo_globetrotter_proto_rocktree::NodeKey& node_key() const;
  PROTOBUF_NODISCARD ::geo_globetrotter_proto_rocktree::NodeKey* release_node_key();
  ::geo_globetrotter_proto_rocktree::NodeKey* mutable_node_key();
  void set_allocated_node_key(::geo_globetrotter_proto_rocktree::NodeKey* node_key);
  private:
  const ::geo_globetrotter_proto_rocktree::NodeKey& _internal_node_key() const;
  ::geo_globetrotter_proto_rocktree::NodeKey* _internal_mutable_node_key();
  public:
  void unsafe_arena_set_allocated_node_key(
      ::geo_globetrotter_proto_rocktree::NodeKey* node_key);
  ::geo_globetrotter_proto_rocktree::NodeKey* unsafe_arena_release_node_key();
  // optional uint32 imagery_epoch = 3;
  bool has_imagery_epoch() const;
  void clear_imagery_epoch() ;
  ::uint32_t imagery_epoch() const;
  void set_imagery_epoch(::uint32_t value);
  private:
  ::uint32_t _internal_imagery_epoch() const;
  void _internal_set_imagery_epoch(::uint32_t value);
  public:
  // optional .geo_globetrotter_proto_rocktree.Texture.Format texture_format = 2;
  bool has_texture_format() const;
  void clear_texture_format() ;
  ::geo_globetrotter_proto_rocktree::Texture_Format texture_format() const;
  void set_texture_format(::geo_globetrotter_proto_rocktree::Texture_Format value);
  private:
  ::geo_globetrotter_proto_rocktree::Texture_Format _internal_texture_format() const;
  void _internal_set_texture_format(::geo_globetrotter_proto_rocktree::Texture_Format value);
  public:
  // @@protoc_insertion_point(class_scope:geo_globetrotter_proto_rocktree.NodeDataRequest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::geo_globetrotter_proto_rocktree::NodeKey* node_key_;
    ::uint32_t imagery_epoch_;
    int texture_format_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_rocktree_2eproto;
};// -------------------------------------------------------------------

class NodeKey final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:geo_globetrotter_proto_rocktree.NodeKey) */ {
 public:
  inline NodeKey() : NodeKey(nullptr) {}
  ~NodeKey() override;
  explicit PROTOBUF_CONSTEXPR NodeKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  NodeKey(const NodeKey& from);
  NodeKey(NodeKey&& from) noexcept
    : NodeKey() {
    *this = ::std::move(from);
  }

  inline NodeKey& operator=(const NodeKey& from) {
    CopyFrom(from);
    return *this;
  }
  inline NodeKey& operator=(NodeKey&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const NodeKey& default_instance() {
    return *internal_default_instance();
  }
  static inline const NodeKey* internal_default_instance() {
    return reinterpret_cast<const NodeKey*>(
               &_NodeKey_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(NodeKey& a, NodeKey& b) {
    a.Swap(&b);
  }
  inline void Swap(NodeKey* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NodeKey* other) {
    if (other == this) return;
    GOOGLE_ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  NodeKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NodeKey>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NodeKey& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const NodeKey& from) {
    NodeKey::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NodeKey* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "geo_globetrotter_proto_rocktree.NodeKey";
  }
  protected:
  explicit NodeKey(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPathFieldNumber = 1,
    kEpochFieldNumber = 2,
  };
  // optional string path = 1;
  bool has_path() const;
  void clear_path() ;
  const std::string& path() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_path(ArgT0&& arg0, ArgT... args);
  std::string* mutable_path();
  PROTOBUF_NODISCARD std::string* release_path();
  void set_allocated_path(std::string* path);
  private:
  const std::string& _internal_path() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_path(const std::string& value);
  std::string* _internal_mutable_path();
  public:
  // optional uint32 epoch = 2;
  bool has_epoch() const;
  void clear_epoch() ;
  ::uint32_t epoch() const;
  void set_epoch(::uint32_t value);
  private:
  ::uint32_t _internal_epoch() const;
  void _internal_set_epoch(::uint32_t value);
  public:
  // @@protoc_insertion_point(class_scope:geo_globetrotter_proto_rocktree.NodeKey)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr path_;
    ::uint32_t epoch_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_rocktree_2eproto;
};// -------------------------------------------------------------------

class CopyrightRequest final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:geo_globetrotter_proto_rocktree.CopyrightRequest) */ {
 public:
  inline CopyrightRequest() : CopyrightRequest(nullptr) {}
  ~CopyrightRequest() override;
  explicit PROTOBUF_CONSTEXPR CopyrightRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CopyrightRequest(const CopyrightRequest& from);
  CopyrightRequest(CopyrightRequest&& from) noexcept
    : CopyrightRequest() {
    *this = ::std::move(from);
  }

  inline CopyrightRequest& operator=(const CopyrightRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline CopyrightRequest& operator=(CopyrightRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CopyrightRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const CopyrightRequest* internal_default_instance() {
    return reinterpret_cast<const CopyrightRequest*>(
               &_CopyrightRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(CopyrightRequest& a, CopyrightRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(CopyrightRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CopyrightRequest* other) {
    if (other == this) return;
    GOOGLE_ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CopyrightRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CopyrightRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CopyrightRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CopyrightRequest& from) {
    CopyrightRequest::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CopyrightRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "geo_globetrotter_proto_rocktree.CopyrightRequest";
  }
  protected:
  explicit CopyrightRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kEpochFieldNumber = 1,
  };
  // optional uint32 epoch = 1;
  bool has_epoch() const;
  void clear_epoch() ;
  ::uint32_t epoch() const;
  void set_epoch(::uint32_t value);
  private:
  ::uint32_t _internal_epoch() const;
  void _internal_set_epoch(::uint32_t value);
  public:
  // @@protoc_insertion_point(class_scope:geo_globetrotter_proto_rocktree.CopyrightRequest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t epoch_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_rocktree_2eproto;
};// -------------------------------------------------------------------

class TextureDataRequest final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:geo_globetrotter_proto_rocktree.TextureDataRequest) */ {
 public:
  inline TextureDataRequest() : TextureDataRequest(nullptr) {}
  ~TextureDataRequest() override;
  explicit PROTOBUF_CONSTEXPR TextureDataRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  TextureDataRequest(const TextureDataRequest& from);
  TextureDataRequest(TextureDataRequest&& from) noexcept
    : TextureDataRequest() {
    *this = ::std::move(from);
  }

  inline TextureDataRequest& operator=(const TextureDataRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline TextureDataRequest& operator=(TextureDataRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TextureDataRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const TextureDataRequest* internal_default_instance() {
    return reinterpret_cast<const TextureDataRequest*>(
               &_TextureDataRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(TextureDataRequest& a, TextureDataRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(TextureDataRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TextureDataRequest* other) {
    if (other == this) return;
    GOOGLE_ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  TextureDataRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TextureDataRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TextureDataRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TextureDataRequest& from) {
    TextureDataRequest::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TextureDataRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "geo_globetrotter_proto_rocktree.TextureDataRequest";
  }
  protected:
  explicit TextureDataRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNodeKeyFieldNumber = 1,
    kViewDirectionFieldNumber = 3,
    kTextureFormatFieldNumber = 2,
  };
  // optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 1;
  bool has_node_key() const;
  void clear_node_key() ;
  const ::geo_globetrotter_proto_rocktree::NodeKey& node_key() const;
  PROTOBUF_NODISCARD ::geo_globetrotter_proto_rocktree::NodeKey* release_node_key();
  ::geo_globetrotter_proto_rocktree::NodeKey* mutable_node_key();
  void set_allocated_node_key(::geo_globetrotter_proto_rocktree::NodeKey* node_key);
  private:
  const ::geo_globetrotter_proto_rocktree::NodeKey& _internal_node_key() const;
  ::geo_globetrotter_proto_rocktree::NodeKey* _internal_mutable_node_key();
  public:
  void unsafe_arena_set_allocated_node_key(
      ::geo_globetrotter_proto_rocktree::NodeKey* node_key);
  ::geo_globetrotter_proto_rocktree::NodeKey* unsafe_arena_release_node_key();
  // optional .geo_globetrotter_proto_rocktree.Texture.ViewDirection view_direction = 3;
  bool has_view_direction() const;
  void clear_view_direction() ;
  ::geo_globetrotter_proto_rocktree::Texture_ViewDirection view_direction() const;
  void set_view_direction(::geo_globetrotter_proto_rocktree::Texture_ViewDirection value);
  private:
  ::geo_globetrotter_proto_rocktree::Texture_ViewDirection _internal_view_direction() const;
  void _internal_set_view_direction(::geo_globetrotter_proto_rocktree::Texture_ViewDirection value);
  public:
  // optional .geo_globetrotter_proto_rocktree.Texture.Format texture_format = 2;
  bool has_texture_format() const;
  void clear_texture_format() ;
  ::geo_globetrotter_proto_rocktree::Texture_Format texture_format() const;
  void set_texture_format(::geo_globetrotter_proto_rocktree::Texture_Format value);
  private:
  ::geo_globetrotter_proto_rocktree::Texture_Format _internal_texture_format() const;
  void _internal_set_texture_format(::geo_globetrotter_proto_rocktree::Texture_Format value);
  public:
  // @@protoc_insertion_point(class_scope:geo_globetrotter_proto_rocktree.TextureDataRequest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::geo_globetrotter_proto_rocktree::NodeKey* node_key_;
    int view_direction_;
    int texture_format_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_rocktree_2eproto;
};// -------------------------------------------------------------------

class BulkMetadata final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:geo_globetrotter_proto_rocktree.BulkMetadata) */ {
 public:
  inline BulkMetadata() : BulkMetadata(nullptr) {}
  ~BulkMetadata() override;
  explicit PROTOBUF_CONSTEXPR BulkMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  BulkMetadata(const BulkMetadata& from);
  BulkMetadata(BulkMetadata&& from) noexcept
    : BulkMetadata() {
    *this = ::std::move(from);
  }

  inline BulkMetadata& operator=(const BulkMetadata& from) {
    CopyFrom(from);
    return *this;
  }
  inline BulkMetadata& operator=(BulkMetadata&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const BulkMetadata& default_instance() {
    return *internal_default_instance();
  }
  static inline const BulkMetadata* internal_default_instance() {
    return reinterpret_cast<const BulkMetadata*>(
               &_BulkMetadata_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(BulkMetadata& a, BulkMetadata& b) {
    a.Swap(&b);
  }
  inline void Swap(BulkMetadata* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BulkMetadata* other) {
    if (other == this) return;
    GOOGLE_ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  BulkMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BulkMetadata>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BulkMetadata& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BulkMetadata& from) {
    BulkMetadata::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BulkMetadata* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "geo_globetrotter_proto_rocktree.BulkMetadata";
  }
  protected:
  explicit BulkMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNodeMetadataFieldNumber = 1,
    kHeadNodeCenterFieldNumber = 3,
    kMetersPerTexelFieldNumber = 4,
    kHeadNodeKeyFieldNumber = 2,
    kDefaultImageryEpochFieldNumber = 5,
    kDefaultAvailableTextureFormatsFieldNumber = 6,
    kDefaultAvailableViewDependentTexturesFieldNumber = 7,
    kDefaultAvailableViewDependentTextureFormatsFieldNumber = 8,
  };
  // repeated .geo_globetrotter_proto_rocktree.NodeMetadata node_metadata = 1;
  int node_metadata_size() const;
  private:
  int _internal_node_metadata_size() const;

  public:
  void clear_node_metadata() ;
  ::geo_globetrotter_proto_rocktree::NodeMetadata* mutable_node_metadata(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::NodeMetadata >*
      mutable_node_metadata();
  private:
  const ::geo_globetrotter_proto_rocktree::NodeMetadata& _internal_node_metadata(int index) const;
  ::geo_globetrotter_proto_rocktree::NodeMetadata* _internal_add_node_metadata();
  public:
  const ::geo_globetrotter_proto_rocktree::NodeMetadata& node_metadata(int index) const;
  ::geo_globetrotter_proto_rocktree::NodeMetadata* add_node_metadata();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::NodeMetadata >&
      node_metadata() const;
  // repeated double head_node_center = 3 [packed = true];
  int head_node_center_size() const;
  private:
  int _internal_head_node_center_size() const;

  public:
  void clear_head_node_center() ;
  private:
  double _internal_head_node_center(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_head_node_center() const;
  void _internal_add_head_node_center(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_head_node_center();
  public:
  double head_node_center(int index) const;
  void set_head_node_center(int index, double value);
  void add_head_node_center(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      head_node_center() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_head_node_center();
  // repeated float meters_per_texel = 4 [packed = true];
  int meters_per_texel_size() const;
  private:
  int _internal_meters_per_texel_size() const;

  public:
  void clear_meters_per_texel() ;
  private:
  float _internal_meters_per_texel(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_meters_per_texel() const;
  void _internal_add_meters_per_texel(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_meters_per_texel();
  public:
  float meters_per_texel(int index) const;
  void set_meters_per_texel(int index, float value);
  void add_meters_per_texel(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      meters_per_texel() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_meters_per_texel();
  // optional .geo_globetrotter_proto_rocktree.NodeKey head_node_key = 2;
  bool has_head_node_key() const;
  void clear_head_node_key() ;
  const ::geo_globetrotter_proto_rocktree::NodeKey& head_node_key() const;
  PROTOBUF_NODISCARD ::geo_globetrotter_proto_rocktree::NodeKey* release_head_node_key();
  ::geo_globetrotter_proto_rocktree::NodeKey* mutable_head_node_key();
  void set_allocated_head_node_key(::geo_globetrotter_proto_rocktree::NodeKey* head_node_key);
  private:
  const ::geo_globetrotter_proto_rocktree::NodeKey& _internal_head_node_key() const;
  ::geo_globetrotter_proto_rocktree::NodeKey* _internal_mutable_head_node_key();
  public:
  void unsafe_arena_set_allocated_head_node_key(
      ::geo_globetrotter_proto_rocktree::NodeKey* head_node_key);
  ::geo_globetrotter_proto_rocktree::NodeKey* unsafe_arena_release_head_node_key();
  // optional uint32 default_imagery_epoch = 5;
  bool has_default_imagery_epoch() const;
  void clear_default_imagery_epoch() ;
  ::uint32_t default_imagery_epoch() const;
  void set_default_imagery_epoch(::uint32_t value);
  private:
  ::uint32_t _internal_default_imagery_epoch() const;
  void _internal_set_default_imagery_epoch(::uint32_t value);
  public:
  // optional uint32 default_available_texture_formats = 6;
  bool has_default_available_texture_formats() const;
  void clear_default_available_texture_formats() ;
  ::uint32_t default_available_texture_formats() const;
  void set_default_available_texture_formats(::uint32_t value);
  private:
  ::uint32_t _internal_default_available_texture_formats() const;
  void _internal_set_default_available_texture_formats(::uint32_t value);
  public:
  // optional uint32 default_available_view_dependent_textures = 7;
  bool has_default_available_view_dependent_textures() const;
  void clear_default_available_view_dependent_textures() ;
  ::uint32_t default_available_view_dependent_textures() const;
  void set_default_available_view_dependent_textures(::uint32_t value);
  private:
  ::uint32_t _internal_default_available_view_dependent_textures() const;
  void _internal_set_default_available_view_dependent_textures(::uint32_t value);
  public:
  // optional uint32 default_available_view_dependent_texture_formats = 8;
  bool has_default_available_view_dependent_texture_formats() const;
  void clear_default_available_view_dependent_texture_formats() ;
  ::uint32_t default_available_view_dependent_texture_formats() const;
  void set_default_available_view_dependent_texture_formats(::uint32_t value);
  private:
  ::uint32_t _internal_default_available_view_dependent_texture_formats() const;
  void _internal_set_default_available_view_dependent_texture_formats(::uint32_t value);
  public:
  // @@protoc_insertion_point(class_scope:geo_globetrotter_proto_rocktree.BulkMetadata)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::NodeMetadata > node_metadata_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > head_node_center_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > meters_per_texel_;
    ::geo_globetrotter_proto_rocktree::NodeKey* head_node_key_;
    ::uint32_t default_imagery_epoch_;
    ::uint32_t default_available_texture_formats_;
    ::uint32_t default_available_view_dependent_textures_;
    ::uint32_t default_available_view_dependent_texture_formats_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_rocktree_2eproto;
};// -------------------------------------------------------------------

class NodeMetadata final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:geo_globetrotter_proto_rocktree.NodeMetadata) */ {
 public:
  inline NodeMetadata() : NodeMetadata(nullptr) {}
  ~NodeMetadata() override;
  explicit PROTOBUF_CONSTEXPR NodeMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  NodeMetadata(const NodeMetadata& from);
  NodeMetadata(NodeMetadata&& from) noexcept
    : NodeMetadata() {
    *this = ::std::move(from);
  }

  inline NodeMetadata& operator=(const NodeMetadata& from) {
    CopyFrom(from);
    return *this;
  }
  inline NodeMetadata& operator=(NodeMetadata&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const NodeMetadata& default_instance() {
    return *internal_default_instance();
  }
  static inline const NodeMetadata* internal_default_instance() {
    return reinterpret_cast<const NodeMetadata*>(
               &_NodeMetadata_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(NodeMetadata& a, NodeMetadata& b) {
    a.Swap(&b);
  }
  inline void Swap(NodeMetadata* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NodeMetadata* other) {
    if (other == this) return;
    GOOGLE_ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  NodeMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NodeMetadata>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NodeMetadata& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const NodeMetadata& from) {
    NodeMetadata::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NodeMetadata* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "geo_globetrotter_proto_rocktree.NodeMetadata";
  }
  protected:
  explicit NodeMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  using Flags = NodeMetadata_Flags;
  static constexpr Flags RICH3D_LEAF = NodeMetadata_Flags_RICH3D_LEAF;
  static constexpr Flags RICH3D_NODATA = NodeMetadata_Flags_RICH3D_NODATA;
  static constexpr Flags LEAF = NodeMetadata_Flags_LEAF;
  static constexpr Flags NODATA = NodeMetadata_Flags_NODATA;
  static constexpr Flags USE_IMAGERY_EPOCH = NodeMetadata_Flags_USE_IMAGERY_EPOCH;
  static inline bool Flags_IsValid(int value) {
    return NodeMetadata_Flags_IsValid(value);
  }
  static constexpr Flags Flags_MIN = NodeMetadata_Flags_Flags_MIN;
  static constexpr Flags Flags_MAX = NodeMetadata_Flags_Flags_MAX;
  static constexpr int Flags_ARRAYSIZE = NodeMetadata_Flags_Flags_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Flags_descriptor() {
    return NodeMetadata_Flags_descriptor();
  }
  template <typename T>
  static inline const std::string& Flags_Name(T value) {
    return NodeMetadata_Flags_Name(value);
  }
  static inline bool Flags_Parse(absl::string_view name, Flags* value) {
    return NodeMetadata_Flags_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kProcessingOrientedBoundingBoxFieldNumber = 6,
    kOrientedBoundingBoxFieldNumber = 3,
    kPathAndFlagsFieldNumber = 1,
    kEpochFieldNumber = 2,
    kMetersPerTexelFieldNumber = 4,
    kBulkMetadataEpochFieldNumber = 5,
    kImageryEpochFieldNumber = 7,
    kAvailableTextureFormatsFieldNumber = 8,
    kAvailableViewDependentTexturesFieldNumber = 9,
    kAvailableViewDependentTextureFormatsFieldNumber = 10,
  };
  // repeated double processing_oriented_bounding_box = 6 [packed = true];
  int processing_oriented_bounding_box_size() const;
  private:
  int _internal_processing_oriented_bounding_box_size() const;

  public:
  void clear_processing_oriented_bounding_box() ;
  private:
  double _internal_processing_oriented_bounding_box(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_processing_oriented_bounding_box() const;
  void _internal_add_processing_oriented_bounding_box(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_processing_oriented_bounding_box();
  public:
  double processing_oriented_bounding_box(int index) const;
  void set_processing_oriented_bounding_box(int index, double value);
  void add_processing_oriented_bounding_box(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      processing_oriented_bounding_box() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_processing_oriented_bounding_box();
  // optional bytes oriented_bounding_box = 3;
  bool has_oriented_bounding_box() const;
  void clear_oriented_bounding_box() ;
  const std::string& oriented_bounding_box() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_oriented_bounding_box(ArgT0&& arg0, ArgT... args);
  std::string* mutable_oriented_bounding_box();
  PROTOBUF_NODISCARD std::string* release_oriented_bounding_box();
  void set_allocated_oriented_bounding_box(std::string* oriented_bounding_box);
  private:
  const std::string& _internal_oriented_bounding_box() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_oriented_bounding_box(const std::string& value);
  std::string* _internal_mutable_oriented_bounding_box();
  public:
  // optional uint32 path_and_flags = 1;
  bool has_path_and_flags() const;
  void clear_path_and_flags() ;
  ::uint32_t path_and_flags() const;
  void set_path_and_flags(::uint32_t value);
  private:
  ::uint32_t _internal_path_and_flags() const;
  void _internal_set_path_and_flags(::uint32_t value);
  public:
  // optional uint32 epoch = 2;
  bool has_epoch() const;
  void clear_epoch() ;
  ::uint32_t epoch() const;
  void set_epoch(::uint32_t value);
  private:
  ::uint32_t _internal_epoch() const;
  void _internal_set_epoch(::uint32_t value);
  public:
  // optional float meters_per_texel = 4;
  bool has_meters_per_texel() const;
  void clear_meters_per_texel() ;
  float meters_per_texel() const;
  void set_meters_per_texel(float value);
  private:
  float _internal_meters_per_texel() const;
  void _internal_set_meters_per_texel(float value);
  public:
  // optional uint32 bulk_metadata_epoch = 5;
  bool has_bulk_metadata_epoch() const;
  void clear_bulk_metadata_epoch() ;
  ::uint32_t bulk_metadata_epoch() const;
  void set_bulk_metadata_epoch(::uint32_t value);
  private:
  ::uint32_t _internal_bulk_metadata_epoch() const;
  void _internal_set_bulk_metadata_epoch(::uint32_t value);
  public:
  // optional uint32 imagery_epoch = 7;
  bool has_imagery_epoch() const;
  void clear_imagery_epoch() ;
  ::uint32_t imagery_epoch() const;
  void set_imagery_epoch(::uint32_t value);
  private:
  ::uint32_t _internal_imagery_epoch() const;
  void _internal_set_imagery_epoch(::uint32_t value);
  public:
  // optional uint32 available_texture_formats = 8;
  bool has_available_texture_formats() const;
  void clear_available_texture_formats() ;
  ::uint32_t available_texture_formats() const;
  void set_available_texture_formats(::uint32_t value);
  private:
  ::uint32_t _internal_available_texture_formats() const;
  void _internal_set_available_texture_formats(::uint32_t value);
  public:
  // optional uint32 available_view_dependent_textures = 9;
  bool has_available_view_dependent_textures() const;
  void clear_available_view_dependent_textures() ;
  ::uint32_t available_view_dependent_textures() const;
  void set_available_view_dependent_textures(::uint32_t value);
  private:
  ::uint32_t _internal_available_view_dependent_textures() const;
  void _internal_set_available_view_dependent_textures(::uint32_t value);
  public:
  // optional uint32 available_view_dependent_texture_formats = 10;
  bool has_available_view_dependent_texture_formats() const;
  void clear_available_view_dependent_texture_formats() ;
  ::uint32_t available_view_dependent_texture_formats() const;
  void set_available_view_dependent_texture_formats(::uint32_t value);
  private:
  ::uint32_t _internal_available_view_dependent_texture_formats() const;
  void _internal_set_available_view_dependent_texture_formats(::uint32_t value);
  public:
  // @@protoc_insertion_point(class_scope:geo_globetrotter_proto_rocktree.NodeMetadata)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > processing_oriented_bounding_box_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oriented_bounding_box_;
    ::uint32_t path_and_flags_;
    ::uint32_t epoch_;
    float meters_per_texel_;
    ::uint32_t bulk_metadata_epoch_;
    ::uint32_t imagery_epoch_;
    ::uint32_t available_texture_formats_;
    ::uint32_t available_view_dependent_textures_;
    ::uint32_t available_view_dependent_texture_formats_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_rocktree_2eproto;
};// -------------------------------------------------------------------

class NodeData final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:geo_globetrotter_proto_rocktree.NodeData) */ {
 public:
  inline NodeData() : NodeData(nullptr) {}
  ~NodeData() override;
  explicit PROTOBUF_CONSTEXPR NodeData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  NodeData(const NodeData& from);
  NodeData(NodeData&& from) noexcept
    : NodeData() {
    *this = ::std::move(from);
  }

  inline NodeData& operator=(const NodeData& from) {
    CopyFrom(from);
    return *this;
  }
  inline NodeData& operator=(NodeData&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const NodeData& default_instance() {
    return *internal_default_instance();
  }
  static inline const NodeData* internal_default_instance() {
    return reinterpret_cast<const NodeData*>(
               &_NodeData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(NodeData& a, NodeData& b) {
    a.Swap(&b);
  }
  inline void Swap(NodeData* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NodeData* other) {
    if (other == this) return;
    GOOGLE_ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  NodeData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NodeData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NodeData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const NodeData& from) {
    NodeData::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NodeData* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "geo_globetrotter_proto_rocktree.NodeData";
  }
  protected:
  explicit NodeData(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMatrixGlobeFromMeshFieldNumber = 1,
    kMeshesFieldNumber = 2,
    kCopyrightIdsFieldNumber = 3,
    kKmlBoundingBoxFieldNumber = 5,
    kOverlaySurfaceMeshesFieldNumber = 7,
    kForNormalsFieldNumber = 8,
    kNodeKeyFieldNumber = 4,
    kWaterMeshFieldNumber = 6,
  };
  // repeated double matrix_globe_from_mesh = 1 [packed = true];
  int matrix_globe_from_mesh_size() const;
  private:
  int _internal_matrix_globe_from_mesh_size() const;

  public:
  void clear_matrix_globe_from_mesh() ;
  private:
  double _internal_matrix_globe_from_mesh(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_matrix_globe_from_mesh() const;
  void _internal_add_matrix_globe_from_mesh(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_matrix_globe_from_mesh();
  public:
  double matrix_globe_from_mesh(int index) const;
  void set_matrix_globe_from_mesh(int index, double value);
  void add_matrix_globe_from_mesh(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      matrix_globe_from_mesh() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_matrix_globe_from_mesh();
  // repeated .geo_globetrotter_proto_rocktree.Mesh meshes = 2;
  int meshes_size() const;
  private:
  int _internal_meshes_size() const;

  public:
  void clear_meshes() ;
  ::geo_globetrotter_proto_rocktree::Mesh* mutable_meshes(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Mesh >*
      mutable_meshes();
  private:
  const ::geo_globetrotter_proto_rocktree::Mesh& _internal_meshes(int index) const;
  ::geo_globetrotter_proto_rocktree::Mesh* _internal_add_meshes();
  public:
  const ::geo_globetrotter_proto_rocktree::Mesh& meshes(int index) const;
  ::geo_globetrotter_proto_rocktree::Mesh* add_meshes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Mesh >&
      meshes() const;
  // repeated uint32 copyright_ids = 3;
  int copyright_ids_size() const;
  private:
  int _internal_copyright_ids_size() const;

  public:
  void clear_copyright_ids() ;
  private:
  ::uint32_t _internal_copyright_ids(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >&
      _internal_copyright_ids() const;
  void _internal_add_copyright_ids(::uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >*
      _internal_mutable_copyright_ids();
  public:
  ::uint32_t copyright_ids(int index) const;
  void set_copyright_ids(int index, ::uint32_t value);
  void add_copyright_ids(::uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >&
      copyright_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >*
      mutable_copyright_ids();
  // repeated double kml_bounding_box = 5 [packed = true];
  int kml_bounding_box_size() const;
  private:
  int _internal_kml_bounding_box_size() const;

  public:
  void clear_kml_bounding_box() ;
  private:
  double _internal_kml_bounding_box(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_kml_bounding_box() const;
  void _internal_add_kml_bounding_box(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_kml_bounding_box();
  public:
  double kml_bounding_box(int index) const;
  void set_kml_bounding_box(int index, double value);
  void add_kml_bounding_box(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      kml_bounding_box() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_kml_bounding_box();
  // repeated .geo_globetrotter_proto_rocktree.Mesh overlay_surface_meshes = 7;
  int overlay_surface_meshes_size() const;
  private:
  int _internal_overlay_surface_meshes_size() const;

  public:
  void clear_overlay_surface_meshes() ;
  ::geo_globetrotter_proto_rocktree::Mesh* mutable_overlay_surface_meshes(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Mesh >*
      mutable_overlay_surface_meshes();
  private:
  const ::geo_globetrotter_proto_rocktree::Mesh& _internal_overlay_surface_meshes(int index) const;
  ::geo_globetrotter_proto_rocktree::Mesh* _internal_add_overlay_surface_meshes();
  public:
  const ::geo_globetrotter_proto_rocktree::Mesh& overlay_surface_meshes(int index) const;
  ::geo_globetrotter_proto_rocktree::Mesh* add_overlay_surface_meshes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Mesh >&
      overlay_surface_meshes() const;
  // optional bytes for_normals = 8;
  bool has_for_normals() const;
  void clear_for_normals() ;
  const std::string& for_normals() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_for_normals(ArgT0&& arg0, ArgT... args);
  std::string* mutable_for_normals();
  PROTOBUF_NODISCARD std::string* release_for_normals();
  void set_allocated_for_normals(std::string* for_normals);
  private:
  const std::string& _internal_for_normals() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_for_normals(const std::string& value);
  std::string* _internal_mutable_for_normals();
  public:
  // optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 4;
  bool has_node_key() const;
  void clear_node_key() ;
  const ::geo_globetrotter_proto_rocktree::NodeKey& node_key() const;
  PROTOBUF_NODISCARD ::geo_globetrotter_proto_rocktree::NodeKey* release_node_key();
  ::geo_globetrotter_proto_rocktree::NodeKey* mutable_node_key();
  void set_allocated_node_key(::geo_globetrotter_proto_rocktree::NodeKey* node_key);
  private:
  const ::geo_globetrotter_proto_rocktree::NodeKey& _internal_node_key() const;
  ::geo_globetrotter_proto_rocktree::NodeKey* _internal_mutable_node_key();
  public:
  void unsafe_arena_set_allocated_node_key(
      ::geo_globetrotter_proto_rocktree::NodeKey* node_key);
  ::geo_globetrotter_proto_rocktree::NodeKey* unsafe_arena_release_node_key();
  // optional .geo_globetrotter_proto_rocktree.Mesh water_mesh = 6;
  bool has_water_mesh() const;
  void clear_water_mesh() ;
  const ::geo_globetrotter_proto_rocktree::Mesh& water_mesh() const;
  PROTOBUF_NODISCARD ::geo_globetrotter_proto_rocktree::Mesh* release_water_mesh();
  ::geo_globetrotter_proto_rocktree::Mesh* mutable_water_mesh();
  void set_allocated_water_mesh(::geo_globetrotter_proto_rocktree::Mesh* water_mesh);
  private:
  const ::geo_globetrotter_proto_rocktree::Mesh& _internal_water_mesh() const;
  ::geo_globetrotter_proto_rocktree::Mesh* _internal_mutable_water_mesh();
  public:
  void unsafe_arena_set_allocated_water_mesh(
      ::geo_globetrotter_proto_rocktree::Mesh* water_mesh);
  ::geo_globetrotter_proto_rocktree::Mesh* unsafe_arena_release_water_mesh();
  // @@protoc_insertion_point(class_scope:geo_globetrotter_proto_rocktree.NodeData)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > matrix_globe_from_mesh_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Mesh > meshes_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t > copyright_ids_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > kml_bounding_box_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Mesh > overlay_surface_meshes_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr for_normals_;
    ::geo_globetrotter_proto_rocktree::NodeKey* node_key_;
    ::geo_globetrotter_proto_rocktree::Mesh* water_mesh_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_rocktree_2eproto;
};// -------------------------------------------------------------------

class Mesh final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:geo_globetrotter_proto_rocktree.Mesh) */ {
 public:
  inline Mesh() : Mesh(nullptr) {}
  ~Mesh() override;
  explicit PROTOBUF_CONSTEXPR Mesh(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Mesh(const Mesh& from);
  Mesh(Mesh&& from) noexcept
    : Mesh() {
    *this = ::std::move(from);
  }

  inline Mesh& operator=(const Mesh& from) {
    CopyFrom(from);
    return *this;
  }
  inline Mesh& operator=(Mesh&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Mesh& default_instance() {
    return *internal_default_instance();
  }
  static inline const Mesh* internal_default_instance() {
    return reinterpret_cast<const Mesh*>(
               &_Mesh_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(Mesh& a, Mesh& b) {
    a.Swap(&b);
  }
  inline void Swap(Mesh* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Mesh* other) {
    if (other == this) return;
    GOOGLE_ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Mesh* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Mesh>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Mesh& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Mesh& from) {
    Mesh::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Mesh* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "geo_globetrotter_proto_rocktree.Mesh";
  }
  protected:
  explicit Mesh(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  using Layer = Mesh_Layer;
  static constexpr Layer OVERGROUND = Mesh_Layer_OVERGROUND;
  static constexpr Layer TERRAIN_BELOW_WATER = Mesh_Layer_TERRAIN_BELOW_WATER;
  static constexpr Layer TERRAIN_ABOVE_WATER = Mesh_Layer_TERRAIN_ABOVE_WATER;
  static constexpr Layer TERRAIN_HIDDEN = Mesh_Layer_TERRAIN_HIDDEN;
  static constexpr Layer WATER = Mesh_Layer_WATER;
  static constexpr Layer WATER_SKIRTS = Mesh_Layer_WATER_SKIRTS;
  static constexpr Layer WATER_SKIRTS_INVERTED = Mesh_Layer_WATER_SKIRTS_INVERTED;
  static constexpr Layer OVERLAY_SURFACE = Mesh_Layer_OVERLAY_SURFACE;
  static constexpr Layer OVERLAY_SURFACE_SKIRTS = Mesh_Layer_OVERLAY_SURFACE_SKIRTS;
  static constexpr Layer NUM_LAYERS = Mesh_Layer_NUM_LAYERS;
  static inline bool Layer_IsValid(int value) {
    return Mesh_Layer_IsValid(value);
  }
  static constexpr Layer Layer_MIN = Mesh_Layer_Layer_MIN;
  static constexpr Layer Layer_MAX = Mesh_Layer_Layer_MAX;
  static constexpr int Layer_ARRAYSIZE = Mesh_Layer_Layer_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Layer_descriptor() {
    return Mesh_Layer_descriptor();
  }
  template <typename T>
  static inline const std::string& Layer_Name(T value) {
    return Mesh_Layer_Name(value);
  }
  static inline bool Layer_Parse(absl::string_view name, Layer* value) {
    return Mesh_Layer_Parse(name, value);
  }

  using LayerMask = Mesh_LayerMask;
  static constexpr LayerMask TERRAIN_WITH_OVERGROUND = Mesh_LayerMask_TERRAIN_WITH_OVERGROUND;
  static constexpr LayerMask TERRAIN_WITH_WATER = Mesh_LayerMask_TERRAIN_WITH_WATER;
  static constexpr LayerMask TERRAIN_WITHOUT_WATER = Mesh_LayerMask_TERRAIN_WITHOUT_WATER;
  static inline bool LayerMask_IsValid(int value) {
    return Mesh_LayerMask_IsValid(value);
  }
  static constexpr LayerMask LayerMask_MIN = Mesh_LayerMask_LayerMask_MIN;
  static constexpr LayerMask LayerMask_MAX = Mesh_LayerMask_LayerMask_MAX;
  static constexpr int LayerMask_ARRAYSIZE = Mesh_LayerMask_LayerMask_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LayerMask_descriptor() {
    return Mesh_LayerMask_descriptor();
  }
  template <typename T>
  static inline const std::string& LayerMask_Name(T value) {
    return Mesh_LayerMask_Name(value);
  }
  static inline bool LayerMask_Parse(absl::string_view name, LayerMask* value) {
    return Mesh_LayerMask_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kTextureFieldNumber = 6,
    kUvOffsetAndScaleFieldNumber = 10,
    kVerticesFieldNumber = 1,
    kTextureCoordsFieldNumber = 2,
    kIndicesFieldNumber = 3,
    kOctantRangesFieldNumber = 4,
    kLayerCountsFieldNumber = 5,
    kTextureCoordinatesFieldNumber = 7,
    kLayerAndOctantCountsFieldNumber = 8,
    kVertexAlphasFieldNumber = 9,
    kNormalsFieldNumber = 11,
    kSkirtFlagsFieldNumber = 13,
    kNormalsDevFieldNumber = 16,
    kMeshIdFieldNumber = 12,
  };
  // repeated .geo_globetrotter_proto_rocktree.Texture texture = 6;
  int texture_size() const;
  private:
  int _internal_texture_size() const;

  public:
  void clear_texture() ;
  ::geo_globetrotter_proto_rocktree::Texture* mutable_texture(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Texture >*
      mutable_texture();
  private:
  const ::geo_globetrotter_proto_rocktree::Texture& _internal_texture(int index) const;
  ::geo_globetrotter_proto_rocktree::Texture* _internal_add_texture();
  public:
  const ::geo_globetrotter_proto_rocktree::Texture& texture(int index) const;
  ::geo_globetrotter_proto_rocktree::Texture* add_texture();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Texture >&
      texture() const;
  // repeated float uv_offset_and_scale = 10 [packed = true];
  int uv_offset_and_scale_size() const;
  private:
  int _internal_uv_offset_and_scale_size() const;

  public:
  void clear_uv_offset_and_scale() ;
  private:
  float _internal_uv_offset_and_scale(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_uv_offset_and_scale() const;
  void _internal_add_uv_offset_and_scale(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_uv_offset_and_scale();
  public:
  float uv_offset_and_scale(int index) const;
  void set_uv_offset_and_scale(int index, float value);
  void add_uv_offset_and_scale(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      uv_offset_and_scale() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_uv_offset_and_scale();
  // optional bytes vertices = 1;
  bool has_vertices() const;
  void clear_vertices() ;
  const std::string& vertices() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_vertices(ArgT0&& arg0, ArgT... args);
  std::string* mutable_vertices();
  PROTOBUF_NODISCARD std::string* release_vertices();
  void set_allocated_vertices(std::string* vertices);
  private:
  const std::string& _internal_vertices() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_vertices(const std::string& value);
  std::string* _internal_mutable_vertices();
  public:
  // optional bytes texture_coords = 2;
  bool has_texture_coords() const;
  void clear_texture_coords() ;
  const std::string& texture_coords() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_texture_coords(ArgT0&& arg0, ArgT... args);
  std::string* mutable_texture_coords();
  PROTOBUF_NODISCARD std::string* release_texture_coords();
  void set_allocated_texture_coords(std::string* texture_coords);
  private:
  const std::string& _internal_texture_coords() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_texture_coords(const std::string& value);
  std::string* _internal_mutable_texture_coords();
  public:
  // optional bytes indices = 3;
  bool has_indices() const;
  void clear_indices() ;
  const std::string& indices() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_indices(ArgT0&& arg0, ArgT... args);
  std::string* mutable_indices();
  PROTOBUF_NODISCARD std::string* release_indices();
  void set_allocated_indices(std::string* indices);
  private:
  const std::string& _internal_indices() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_indices(const std::string& value);
  std::string* _internal_mutable_indices();
  public:
  // optional bytes octant_ranges = 4;
  bool has_octant_ranges() const;
  void clear_octant_ranges() ;
  const std::string& octant_ranges() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_octant_ranges(ArgT0&& arg0, ArgT... args);
  std::string* mutable_octant_ranges();
  PROTOBUF_NODISCARD std::string* release_octant_ranges();
  void set_allocated_octant_ranges(std::string* octant_ranges);
  private:
  const std::string& _internal_octant_ranges() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_octant_ranges(const std::string& value);
  std::string* _internal_mutable_octant_ranges();
  public:
  // optional bytes layer_counts = 5;
  bool has_layer_counts() const;
  void clear_layer_counts() ;
  const std::string& layer_counts() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_layer_counts(ArgT0&& arg0, ArgT... args);
  std::string* mutable_layer_counts();
  PROTOBUF_NODISCARD std::string* release_layer_counts();
  void set_allocated_layer_counts(std::string* layer_counts);
  private:
  const std::string& _internal_layer_counts() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_layer_counts(const std::string& value);
  std::string* _internal_mutable_layer_counts();
  public:
  // optional bytes texture_coordinates = 7;
  bool has_texture_coordinates() const;
  void clear_texture_coordinates() ;
  const std::string& texture_coordinates() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_texture_coordinates(ArgT0&& arg0, ArgT... args);
  std::string* mutable_texture_coordinates();
  PROTOBUF_NODISCARD std::string* release_texture_coordinates();
  void set_allocated_texture_coordinates(std::string* texture_coordinates);
  private:
  const std::string& _internal_texture_coordinates() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_texture_coordinates(const std::string& value);
  std::string* _internal_mutable_texture_coordinates();
  public:
  // optional bytes layer_and_octant_counts = 8;
  bool has_layer_and_octant_counts() const;
  void clear_layer_and_octant_counts() ;
  const std::string& layer_and_octant_counts() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_layer_and_octant_counts(ArgT0&& arg0, ArgT... args);
  std::string* mutable_layer_and_octant_counts();
  PROTOBUF_NODISCARD std::string* release_layer_and_octant_counts();
  void set_allocated_layer_and_octant_counts(std::string* layer_and_octant_counts);
  private:
  const std::string& _internal_layer_and_octant_counts() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_layer_and_octant_counts(const std::string& value);
  std::string* _internal_mutable_layer_and_octant_counts();
  public:
  // optional bytes vertex_alphas = 9;
  bool has_vertex_alphas() const;
  void clear_vertex_alphas() ;
  const std::string& vertex_alphas() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_vertex_alphas(ArgT0&& arg0, ArgT... args);
  std::string* mutable_vertex_alphas();
  PROTOBUF_NODISCARD std::string* release_vertex_alphas();
  void set_allocated_vertex_alphas(std::string* vertex_alphas);
  private:
  const std::string& _internal_vertex_alphas() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_vertex_alphas(const std::string& value);
  std::string* _internal_mutable_vertex_alphas();
  public:
  // optional bytes normals = 11;
  bool has_normals() const;
  void clear_normals() ;
  const std::string& normals() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_normals(ArgT0&& arg0, ArgT... args);
  std::string* mutable_normals();
  PROTOBUF_NODISCARD std::string* release_normals();
  void set_allocated_normals(std::string* normals);
  private:
  const std::string& _internal_normals() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_normals(const std::string& value);
  std::string* _internal_mutable_normals();
  public:
  // optional bytes skirt_flags = 13;
  bool has_skirt_flags() const;
  void clear_skirt_flags() ;
  const std::string& skirt_flags() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_skirt_flags(ArgT0&& arg0, ArgT... args);
  std::string* mutable_skirt_flags();
  PROTOBUF_NODISCARD std::string* release_skirt_flags();
  void set_allocated_skirt_flags(std::string* skirt_flags);
  private:
  const std::string& _internal_skirt_flags() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_skirt_flags(const std::string& value);
  std::string* _internal_mutable_skirt_flags();
  public:
  // optional bytes normals_dev = 16;
  bool has_normals_dev() const;
  void clear_normals_dev() ;
  const std::string& normals_dev() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_normals_dev(ArgT0&& arg0, ArgT... args);
  std::string* mutable_normals_dev();
  PROTOBUF_NODISCARD std::string* release_normals_dev();
  void set_allocated_normals_dev(std::string* normals_dev);
  private:
  const std::string& _internal_normals_dev() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_normals_dev(const std::string& value);
  std::string* _internal_mutable_normals_dev();
  public:
  // optional uint32 mesh_id = 12;
  bool has_mesh_id() const;
  void clear_mesh_id() ;
  ::uint32_t mesh_id() const;
  void set_mesh_id(::uint32_t value);
  private:
  ::uint32_t _internal_mesh_id() const;
  void _internal_set_mesh_id(::uint32_t value);
  public:
  // @@protoc_insertion_point(class_scope:geo_globetrotter_proto_rocktree.Mesh)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Texture > texture_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > uv_offset_and_scale_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr vertices_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr texture_coords_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr indices_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr octant_ranges_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr layer_counts_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr texture_coordinates_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr layer_and_octant_counts_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr vertex_alphas_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr normals_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr skirt_flags_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr normals_dev_;
    ::uint32_t mesh_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_rocktree_2eproto;
};// -------------------------------------------------------------------

class Texture final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:geo_globetrotter_proto_rocktree.Texture) */ {
 public:
  inline Texture() : Texture(nullptr) {}
  ~Texture() override;
  explicit PROTOBUF_CONSTEXPR Texture(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Texture(const Texture& from);
  Texture(Texture&& from) noexcept
    : Texture() {
    *this = ::std::move(from);
  }

  inline Texture& operator=(const Texture& from) {
    CopyFrom(from);
    return *this;
  }
  inline Texture& operator=(Texture&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Texture& default_instance() {
    return *internal_default_instance();
  }
  static inline const Texture* internal_default_instance() {
    return reinterpret_cast<const Texture*>(
               &_Texture_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(Texture& a, Texture& b) {
    a.Swap(&b);
  }
  inline void Swap(Texture* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Texture* other) {
    if (other == this) return;
    GOOGLE_ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Texture* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Texture>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Texture& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Texture& from) {
    Texture::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Texture* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "geo_globetrotter_proto_rocktree.Texture";
  }
  protected:
  explicit Texture(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  using Format = Texture_Format;
  static constexpr Format JPG = Texture_Format_JPG;
  static constexpr Format DXT1 = Texture_Format_DXT1;
  static constexpr Format ETC1 = Texture_Format_ETC1;
  static constexpr Format PVRTC2 = Texture_Format_PVRTC2;
  static constexpr Format PVRTC4 = Texture_Format_PVRTC4;
  static constexpr Format CRN_DXT1 = Texture_Format_CRN_DXT1;
  static inline bool Format_IsValid(int value) {
    return Texture_Format_IsValid(value);
  }
  static constexpr Format Format_MIN = Texture_Format_Format_MIN;
  static constexpr Format Format_MAX = Texture_Format_Format_MAX;
  static constexpr int Format_ARRAYSIZE = Texture_Format_Format_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Format_descriptor() {
    return Texture_Format_descriptor();
  }
  template <typename T>
  static inline const std::string& Format_Name(T value) {
    return Texture_Format_Name(value);
  }
  static inline bool Format_Parse(absl::string_view name, Format* value) {
    return Texture_Format_Parse(name, value);
  }

  using ViewDirection = Texture_ViewDirection;
  static constexpr ViewDirection NADIR = Texture_ViewDirection_NADIR;
  static constexpr ViewDirection NORTH_45 = Texture_ViewDirection_NORTH_45;
  static constexpr ViewDirection EAST_45 = Texture_ViewDirection_EAST_45;
  static constexpr ViewDirection SOUTH_45 = Texture_ViewDirection_SOUTH_45;
  static constexpr ViewDirection WEST_45 = Texture_ViewDirection_WEST_45;
  static inline bool ViewDirection_IsValid(int value) {
    return Texture_ViewDirection_IsValid(value);
  }
  static constexpr ViewDirection ViewDirection_MIN = Texture_ViewDirection_ViewDirection_MIN;
  static constexpr ViewDirection ViewDirection_MAX = Texture_ViewDirection_ViewDirection_MAX;
  static constexpr int ViewDirection_ARRAYSIZE = Texture_ViewDirection_ViewDirection_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ViewDirection_descriptor() {
    return Texture_ViewDirection_descriptor();
  }
  template <typename T>
  static inline const std::string& ViewDirection_Name(T value) {
    return Texture_ViewDirection_Name(value);
  }
  static inline bool ViewDirection_Parse(absl::string_view name, ViewDirection* value) {
    return Texture_ViewDirection_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 1,
    kViewDirectionFieldNumber = 5,
    kMeshIdFieldNumber = 6,
    kHeightFieldNumber = 4,
    kFormatFieldNumber = 2,
    kWidthFieldNumber = 3,
  };
  // repeated bytes data = 1;
  int data_size() const;
  private:
  int _internal_data_size() const;

  public:
  void clear_data() ;
  const std::string& data(int index) const;
  std::string* mutable_data(int index);
  void set_data(int index, const std::string& value);
  void set_data(int index, std::string&& value);
  void set_data(int index, const char* value);
  void set_data(int index, const void* value, ::size_t size);
  std::string* add_data();
  void add_data(const std::string& value);
  void add_data(std::string&& value);
  void add_data(const char* value);
  void add_data(const void* value, ::size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_data();
  private:
  const std::string& _internal_data(int index) const;
  std::string* _internal_add_data();
  public:
  // optional .geo_globetrotter_proto_rocktree.Texture.ViewDirection view_direction = 5;
  bool has_view_direction() const;
  void clear_view_direction() ;
  ::geo_globetrotter_proto_rocktree::Texture_ViewDirection view_direction() const;
  void set_view_direction(::geo_globetrotter_proto_rocktree::Texture_ViewDirection value);
  private:
  ::geo_globetrotter_proto_rocktree::Texture_ViewDirection _internal_view_direction() const;
  void _internal_set_view_direction(::geo_globetrotter_proto_rocktree::Texture_ViewDirection value);
  public:
  // optional uint32 mesh_id = 6;
  bool has_mesh_id() const;
  void clear_mesh_id() ;
  ::uint32_t mesh_id() const;
  void set_mesh_id(::uint32_t value);
  private:
  ::uint32_t _internal_mesh_id() const;
  void _internal_set_mesh_id(::uint32_t value);
  public:
  // optional uint32 height = 4 [default = 256];
  bool has_height() const;
  void clear_height() ;
  ::uint32_t height() const;
  void set_height(::uint32_t value);
  private:
  ::uint32_t _internal_height() const;
  void _internal_set_height(::uint32_t value);
  public:
  // optional .geo_globetrotter_proto_rocktree.Texture.Format format = 2;
  bool has_format() const;
  void clear_format() ;
  ::geo_globetrotter_proto_rocktree::Texture_Format format() const;
  void set_format(::geo_globetrotter_proto_rocktree::Texture_Format value);
  private:
  ::geo_globetrotter_proto_rocktree::Texture_Format _internal_format() const;
  void _internal_set_format(::geo_globetrotter_proto_rocktree::Texture_Format value);
  public:
  // optional uint32 width = 3 [default = 256];
  bool has_width() const;
  void clear_width() ;
  ::uint32_t width() const;
  void set_width(::uint32_t value);
  private:
  ::uint32_t _internal_width() const;
  void _internal_set_width(::uint32_t value);
  public:
  // @@protoc_insertion_point(class_scope:geo_globetrotter_proto_rocktree.Texture)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> data_;
    int view_direction_;
    ::uint32_t mesh_id_;
    ::uint32_t height_;
    int format_;
    ::uint32_t width_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_rocktree_2eproto;
};// -------------------------------------------------------------------

class TextureData final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:geo_globetrotter_proto_rocktree.TextureData) */ {
 public:
  inline TextureData() : TextureData(nullptr) {}
  ~TextureData() override;
  explicit PROTOBUF_CONSTEXPR TextureData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  TextureData(const TextureData& from);
  TextureData(TextureData&& from) noexcept
    : TextureData() {
    *this = ::std::move(from);
  }

  inline TextureData& operator=(const TextureData& from) {
    CopyFrom(from);
    return *this;
  }
  inline TextureData& operator=(TextureData&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TextureData& default_instance() {
    return *internal_default_instance();
  }
  static inline const TextureData* internal_default_instance() {
    return reinterpret_cast<const TextureData*>(
               &_TextureData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(TextureData& a, TextureData& b) {
    a.Swap(&b);
  }
  inline void Swap(TextureData* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TextureData* other) {
    if (other == this) return;
    GOOGLE_ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  TextureData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TextureData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TextureData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TextureData& from) {
    TextureData::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TextureData* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "geo_globetrotter_proto_rocktree.TextureData";
  }
  protected:
  explicit TextureData(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTexturesFieldNumber = 2,
    kNodeKeyFieldNumber = 1,
  };
  // repeated .geo_globetrotter_proto_rocktree.Texture textures = 2;
  int textures_size() const;
  private:
  int _internal_textures_size() const;

  public:
  void clear_textures() ;
  ::geo_globetrotter_proto_rocktree::Texture* mutable_textures(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Texture >*
      mutable_textures();
  private:
  const ::geo_globetrotter_proto_rocktree::Texture& _internal_textures(int index) const;
  ::geo_globetrotter_proto_rocktree::Texture* _internal_add_textures();
  public:
  const ::geo_globetrotter_proto_rocktree::Texture& textures(int index) const;
  ::geo_globetrotter_proto_rocktree::Texture* add_textures();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Texture >&
      textures() const;
  // optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 1;
  bool has_node_key() const;
  void clear_node_key() ;
  const ::geo_globetrotter_proto_rocktree::NodeKey& node_key() const;
  PROTOBUF_NODISCARD ::geo_globetrotter_proto_rocktree::NodeKey* release_node_key();
  ::geo_globetrotter_proto_rocktree::NodeKey* mutable_node_key();
  void set_allocated_node_key(::geo_globetrotter_proto_rocktree::NodeKey* node_key);
  private:
  const ::geo_globetrotter_proto_rocktree::NodeKey& _internal_node_key() const;
  ::geo_globetrotter_proto_rocktree::NodeKey* _internal_mutable_node_key();
  public:
  void unsafe_arena_set_allocated_node_key(
      ::geo_globetrotter_proto_rocktree::NodeKey* node_key);
  ::geo_globetrotter_proto_rocktree::NodeKey* unsafe_arena_release_node_key();
  // @@protoc_insertion_point(class_scope:geo_globetrotter_proto_rocktree.TextureData)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Texture > textures_;
    ::geo_globetrotter_proto_rocktree::NodeKey* node_key_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_rocktree_2eproto;
};// -------------------------------------------------------------------

class Copyrights final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:geo_globetrotter_proto_rocktree.Copyrights) */ {
 public:
  inline Copyrights() : Copyrights(nullptr) {}
  ~Copyrights() override;
  explicit PROTOBUF_CONSTEXPR Copyrights(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Copyrights(const Copyrights& from);
  Copyrights(Copyrights&& from) noexcept
    : Copyrights() {
    *this = ::std::move(from);
  }

  inline Copyrights& operator=(const Copyrights& from) {
    CopyFrom(from);
    return *this;
  }
  inline Copyrights& operator=(Copyrights&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Copyrights& default_instance() {
    return *internal_default_instance();
  }
  static inline const Copyrights* internal_default_instance() {
    return reinterpret_cast<const Copyrights*>(
               &_Copyrights_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(Copyrights& a, Copyrights& b) {
    a.Swap(&b);
  }
  inline void Swap(Copyrights* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Copyrights* other) {
    if (other == this) return;
    GOOGLE_ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Copyrights* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Copyrights>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Copyrights& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Copyrights& from) {
    Copyrights::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Copyrights* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "geo_globetrotter_proto_rocktree.Copyrights";
  }
  protected:
  explicit Copyrights(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCopyrightsFieldNumber = 1,
  };
  // repeated .geo_globetrotter_proto_rocktree.Copyright copyrights = 1;
  int copyrights_size() const;
  private:
  int _internal_copyrights_size() const;

  public:
  void clear_copyrights() ;
  ::geo_globetrotter_proto_rocktree::Copyright* mutable_copyrights(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Copyright >*
      mutable_copyrights();
  private:
  const ::geo_globetrotter_proto_rocktree::Copyright& _internal_copyrights(int index) const;
  ::geo_globetrotter_proto_rocktree::Copyright* _internal_add_copyrights();
  public:
  const ::geo_globetrotter_proto_rocktree::Copyright& copyrights(int index) const;
  ::geo_globetrotter_proto_rocktree::Copyright* add_copyrights();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Copyright >&
      copyrights() const;
  // @@protoc_insertion_point(class_scope:geo_globetrotter_proto_rocktree.Copyrights)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Copyright > copyrights_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_rocktree_2eproto;
};// -------------------------------------------------------------------

class Copyright final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:geo_globetrotter_proto_rocktree.Copyright) */ {
 public:
  inline Copyright() : Copyright(nullptr) {}
  ~Copyright() override;
  explicit PROTOBUF_CONSTEXPR Copyright(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Copyright(const Copyright& from);
  Copyright(Copyright&& from) noexcept
    : Copyright() {
    *this = ::std::move(from);
  }

  inline Copyright& operator=(const Copyright& from) {
    CopyFrom(from);
    return *this;
  }
  inline Copyright& operator=(Copyright&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Copyright& default_instance() {
    return *internal_default_instance();
  }
  static inline const Copyright* internal_default_instance() {
    return reinterpret_cast<const Copyright*>(
               &_Copyright_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(Copyright& a, Copyright& b) {
    a.Swap(&b);
  }
  inline void Swap(Copyright* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Copyright* other) {
    if (other == this) return;
    GOOGLE_ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Copyright* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Copyright>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Copyright& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Copyright& from) {
    Copyright::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Copyright* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "geo_globetrotter_proto_rocktree.Copyright";
  }
  protected:
  explicit Copyright(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTextFieldNumber = 2,
    kTextCleanFieldNumber = 3,
    kIdFieldNumber = 1,
  };
  // optional string text = 2;
  bool has_text() const;
  void clear_text() ;
  const std::string& text() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_text(ArgT0&& arg0, ArgT... args);
  std::string* mutable_text();
  PROTOBUF_NODISCARD std::string* release_text();
  void set_allocated_text(std::string* text);
  private:
  const std::string& _internal_text() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value);
  std::string* _internal_mutable_text();
  public:
  // optional string text_clean = 3;
  bool has_text_clean() const;
  void clear_text_clean() ;
  const std::string& text_clean() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_text_clean(ArgT0&& arg0, ArgT... args);
  std::string* mutable_text_clean();
  PROTOBUF_NODISCARD std::string* release_text_clean();
  void set_allocated_text_clean(std::string* text_clean);
  private:
  const std::string& _internal_text_clean() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_text_clean(const std::string& value);
  std::string* _internal_mutable_text_clean();
  public:
  // optional uint32 id = 1;
  bool has_id() const;
  void clear_id() ;
  ::uint32_t id() const;
  void set_id(::uint32_t value);
  private:
  ::uint32_t _internal_id() const;
  void _internal_set_id(::uint32_t value);
  public:
  // @@protoc_insertion_point(class_scope:geo_globetrotter_proto_rocktree.Copyright)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_clean_;
    ::uint32_t id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_rocktree_2eproto;
};// -------------------------------------------------------------------

class PlanetoidMetadata final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:geo_globetrotter_proto_rocktree.PlanetoidMetadata) */ {
 public:
  inline PlanetoidMetadata() : PlanetoidMetadata(nullptr) {}
  ~PlanetoidMetadata() override;
  explicit PROTOBUF_CONSTEXPR PlanetoidMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PlanetoidMetadata(const PlanetoidMetadata& from);
  PlanetoidMetadata(PlanetoidMetadata&& from) noexcept
    : PlanetoidMetadata() {
    *this = ::std::move(from);
  }

  inline PlanetoidMetadata& operator=(const PlanetoidMetadata& from) {
    CopyFrom(from);
    return *this;
  }
  inline PlanetoidMetadata& operator=(PlanetoidMetadata&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PlanetoidMetadata& default_instance() {
    return *internal_default_instance();
  }
  static inline const PlanetoidMetadata* internal_default_instance() {
    return reinterpret_cast<const PlanetoidMetadata*>(
               &_PlanetoidMetadata_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(PlanetoidMetadata& a, PlanetoidMetadata& b) {
    a.Swap(&b);
  }
  inline void Swap(PlanetoidMetadata* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PlanetoidMetadata* other) {
    if (other == this) return;
    GOOGLE_ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PlanetoidMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PlanetoidMetadata>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PlanetoidMetadata& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PlanetoidMetadata& from) {
    PlanetoidMetadata::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PlanetoidMetadata* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "geo_globetrotter_proto_rocktree.PlanetoidMetadata";
  }
  protected:
  explicit PlanetoidMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRootNodeMetadataFieldNumber = 1,
    kRadiusFieldNumber = 2,
    kMinTerrainAltitudeFieldNumber = 3,
    kMaxTerrainAltitudeFieldNumber = 4,
  };
  // optional .geo_globetrotter_proto_rocktree.NodeMetadata root_node_metadata = 1;
  bool has_root_node_metadata() const;
  void clear_root_node_metadata() ;
  const ::geo_globetrotter_proto_rocktree::NodeMetadata& root_node_metadata() const;
  PROTOBUF_NODISCARD ::geo_globetrotter_proto_rocktree::NodeMetadata* release_root_node_metadata();
  ::geo_globetrotter_proto_rocktree::NodeMetadata* mutable_root_node_metadata();
  void set_allocated_root_node_metadata(::geo_globetrotter_proto_rocktree::NodeMetadata* root_node_metadata);
  private:
  const ::geo_globetrotter_proto_rocktree::NodeMetadata& _internal_root_node_metadata() const;
  ::geo_globetrotter_proto_rocktree::NodeMetadata* _internal_mutable_root_node_metadata();
  public:
  void unsafe_arena_set_allocated_root_node_metadata(
      ::geo_globetrotter_proto_rocktree::NodeMetadata* root_node_metadata);
  ::geo_globetrotter_proto_rocktree::NodeMetadata* unsafe_arena_release_root_node_metadata();
  // optional float radius = 2;
  bool has_radius() const;
  void clear_radius() ;
  float radius() const;
  void set_radius(float value);
  private:
  float _internal_radius() const;
  void _internal_set_radius(float value);
  public:
  // optional float min_terrain_altitude = 3;
  bool has_min_terrain_altitude() const;
  void clear_min_terrain_altitude() ;
  float min_terrain_altitude() const;
  void set_min_terrain_altitude(float value);
  private:
  float _internal_min_terrain_altitude() const;
  void _internal_set_min_terrain_altitude(float value);
  public:
  // optional float max_terrain_altitude = 4;
  bool has_max_terrain_altitude() const;
  void clear_max_terrain_altitude() ;
  float max_terrain_altitude() const;
  void set_max_terrain_altitude(float value);
  private:
  float _internal_max_terrain_altitude() const;
  void _internal_set_max_terrain_altitude(float value);
  public:
  // @@protoc_insertion_point(class_scope:geo_globetrotter_proto_rocktree.PlanetoidMetadata)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::geo_globetrotter_proto_rocktree::NodeMetadata* root_node_metadata_;
    float radius_;
    float min_terrain_altitude_;
    float max_terrain_altitude_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_rocktree_2eproto;
};

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




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


#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// -------------------------------------------------------------------

// BulkMetadataRequest

// optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 1;
inline bool BulkMetadataRequest::has_node_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.node_key_ != nullptr);
  return value;
}
inline void BulkMetadataRequest::clear_node_key() {
  if (_impl_.node_key_ != nullptr) _impl_.node_key_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::geo_globetrotter_proto_rocktree::NodeKey& BulkMetadataRequest::_internal_node_key() const {
  const ::geo_globetrotter_proto_rocktree::NodeKey* p = _impl_.node_key_;
  return p != nullptr ? *p : reinterpret_cast<const ::geo_globetrotter_proto_rocktree::NodeKey&>(
      ::geo_globetrotter_proto_rocktree::_NodeKey_default_instance_);
}
inline const ::geo_globetrotter_proto_rocktree::NodeKey& BulkMetadataRequest::node_key() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.BulkMetadataRequest.node_key)
  return _internal_node_key();
}
inline void BulkMetadataRequest::unsafe_arena_set_allocated_node_key(
    ::geo_globetrotter_proto_rocktree::NodeKey* node_key) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.node_key_);
  }
  _impl_.node_key_ = node_key;
  if (node_key) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:geo_globetrotter_proto_rocktree.BulkMetadataRequest.node_key)
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* BulkMetadataRequest::release_node_key() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::geo_globetrotter_proto_rocktree::NodeKey* temp = _impl_.node_key_;
  _impl_.node_key_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* BulkMetadataRequest::unsafe_arena_release_node_key() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.BulkMetadataRequest.node_key)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::geo_globetrotter_proto_rocktree::NodeKey* temp = _impl_.node_key_;
  _impl_.node_key_ = nullptr;
  return temp;
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* BulkMetadataRequest::_internal_mutable_node_key() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.node_key_ == nullptr) {
    auto* p = CreateMaybeMessage<::geo_globetrotter_proto_rocktree::NodeKey>(GetArenaForAllocation());
    _impl_.node_key_ = p;
  }
  return _impl_.node_key_;
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* BulkMetadataRequest::mutable_node_key() {
  ::geo_globetrotter_proto_rocktree::NodeKey* _msg = _internal_mutable_node_key();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.BulkMetadataRequest.node_key)
  return _msg;
}
inline void BulkMetadataRequest::set_allocated_node_key(::geo_globetrotter_proto_rocktree::NodeKey* node_key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.node_key_;
  }
  if (node_key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(node_key);
    if (message_arena != submessage_arena) {
      node_key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, node_key, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.node_key_ = node_key;
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.BulkMetadataRequest.node_key)
}

// -------------------------------------------------------------------

// NodeDataRequest

// optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 1;
inline bool NodeDataRequest::has_node_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.node_key_ != nullptr);
  return value;
}
inline void NodeDataRequest::clear_node_key() {
  if (_impl_.node_key_ != nullptr) _impl_.node_key_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::geo_globetrotter_proto_rocktree::NodeKey& NodeDataRequest::_internal_node_key() const {
  const ::geo_globetrotter_proto_rocktree::NodeKey* p = _impl_.node_key_;
  return p != nullptr ? *p : reinterpret_cast<const ::geo_globetrotter_proto_rocktree::NodeKey&>(
      ::geo_globetrotter_proto_rocktree::_NodeKey_default_instance_);
}
inline const ::geo_globetrotter_proto_rocktree::NodeKey& NodeDataRequest::node_key() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeDataRequest.node_key)
  return _internal_node_key();
}
inline void NodeDataRequest::unsafe_arena_set_allocated_node_key(
    ::geo_globetrotter_proto_rocktree::NodeKey* node_key) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.node_key_);
  }
  _impl_.node_key_ = node_key;
  if (node_key) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:geo_globetrotter_proto_rocktree.NodeDataRequest.node_key)
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* NodeDataRequest::release_node_key() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::geo_globetrotter_proto_rocktree::NodeKey* temp = _impl_.node_key_;
  _impl_.node_key_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* NodeDataRequest::unsafe_arena_release_node_key() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.NodeDataRequest.node_key)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::geo_globetrotter_proto_rocktree::NodeKey* temp = _impl_.node_key_;
  _impl_.node_key_ = nullptr;
  return temp;
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* NodeDataRequest::_internal_mutable_node_key() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.node_key_ == nullptr) {
    auto* p = CreateMaybeMessage<::geo_globetrotter_proto_rocktree::NodeKey>(GetArenaForAllocation());
    _impl_.node_key_ = p;
  }
  return _impl_.node_key_;
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* NodeDataRequest::mutable_node_key() {
  ::geo_globetrotter_proto_rocktree::NodeKey* _msg = _internal_mutable_node_key();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.NodeDataRequest.node_key)
  return _msg;
}
inline void NodeDataRequest::set_allocated_node_key(::geo_globetrotter_proto_rocktree::NodeKey* node_key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.node_key_;
  }
  if (node_key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(node_key);
    if (message_arena != submessage_arena) {
      node_key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, node_key, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.node_key_ = node_key;
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.NodeDataRequest.node_key)
}

// optional .geo_globetrotter_proto_rocktree.Texture.Format texture_format = 2;
inline bool NodeDataRequest::has_texture_format() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline void NodeDataRequest::clear_texture_format() {
  _impl_.texture_format_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::geo_globetrotter_proto_rocktree::Texture_Format NodeDataRequest::_internal_texture_format() const {
  return static_cast< ::geo_globetrotter_proto_rocktree::Texture_Format >(_impl_.texture_format_);
}
inline ::geo_globetrotter_proto_rocktree::Texture_Format NodeDataRequest::texture_format() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeDataRequest.texture_format)
  return _internal_texture_format();
}
inline void NodeDataRequest::_internal_set_texture_format(::geo_globetrotter_proto_rocktree::Texture_Format value) {
  assert(::geo_globetrotter_proto_rocktree::Texture_Format_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.texture_format_ = value;
}
inline void NodeDataRequest::set_texture_format(::geo_globetrotter_proto_rocktree::Texture_Format value) {
  _internal_set_texture_format(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.NodeDataRequest.texture_format)
}

// optional uint32 imagery_epoch = 3;
inline bool NodeDataRequest::has_imagery_epoch() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline void NodeDataRequest::clear_imagery_epoch() {
  _impl_.imagery_epoch_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::uint32_t NodeDataRequest::_internal_imagery_epoch() const {
  return _impl_.imagery_epoch_;
}
inline ::uint32_t NodeDataRequest::imagery_epoch() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeDataRequest.imagery_epoch)
  return _internal_imagery_epoch();
}
inline void NodeDataRequest::_internal_set_imagery_epoch(::uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.imagery_epoch_ = value;
}
inline void NodeDataRequest::set_imagery_epoch(::uint32_t value) {
  _internal_set_imagery_epoch(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.NodeDataRequest.imagery_epoch)
}

// -------------------------------------------------------------------

// NodeKey

// optional string path = 1;
inline bool NodeKey::has_path() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline void NodeKey::clear_path() {
  _impl_.path_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& NodeKey::path() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeKey.path)
  return _internal_path();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NodeKey::set_path(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.path_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.NodeKey.path)
}
inline std::string* NodeKey::mutable_path() {
  std::string* _s = _internal_mutable_path();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.NodeKey.path)
  return _s;
}
inline const std::string& NodeKey::_internal_path() const {
  return _impl_.path_.Get();
}
inline void NodeKey::_internal_set_path(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.path_.Set(value, GetArenaForAllocation());
}
inline std::string* NodeKey::_internal_mutable_path() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.path_.Mutable(GetArenaForAllocation());
}
inline std::string* NodeKey::release_path() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.NodeKey.path)
  if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.path_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.path_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void NodeKey::set_allocated_path(std::string* path) {
  if (path != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.path_.SetAllocated(path, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.path_.IsDefault()) {
    _impl_.path_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.NodeKey.path)
}

// optional uint32 epoch = 2;
inline bool NodeKey::has_epoch() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline void NodeKey::clear_epoch() {
  _impl_.epoch_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::uint32_t NodeKey::_internal_epoch() const {
  return _impl_.epoch_;
}
inline ::uint32_t NodeKey::epoch() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeKey.epoch)
  return _internal_epoch();
}
inline void NodeKey::_internal_set_epoch(::uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.epoch_ = value;
}
inline void NodeKey::set_epoch(::uint32_t value) {
  _internal_set_epoch(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.NodeKey.epoch)
}

// -------------------------------------------------------------------

// CopyrightRequest

// optional uint32 epoch = 1;
inline bool CopyrightRequest::has_epoch() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline void CopyrightRequest::clear_epoch() {
  _impl_.epoch_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::uint32_t CopyrightRequest::_internal_epoch() const {
  return _impl_.epoch_;
}
inline ::uint32_t CopyrightRequest::epoch() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.CopyrightRequest.epoch)
  return _internal_epoch();
}
inline void CopyrightRequest::_internal_set_epoch(::uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.epoch_ = value;
}
inline void CopyrightRequest::set_epoch(::uint32_t value) {
  _internal_set_epoch(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.CopyrightRequest.epoch)
}

// -------------------------------------------------------------------

// TextureDataRequest

// optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 1;
inline bool TextureDataRequest::has_node_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.node_key_ != nullptr);
  return value;
}
inline void TextureDataRequest::clear_node_key() {
  if (_impl_.node_key_ != nullptr) _impl_.node_key_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::geo_globetrotter_proto_rocktree::NodeKey& TextureDataRequest::_internal_node_key() const {
  const ::geo_globetrotter_proto_rocktree::NodeKey* p = _impl_.node_key_;
  return p != nullptr ? *p : reinterpret_cast<const ::geo_globetrotter_proto_rocktree::NodeKey&>(
      ::geo_globetrotter_proto_rocktree::_NodeKey_default_instance_);
}
inline const ::geo_globetrotter_proto_rocktree::NodeKey& TextureDataRequest::node_key() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.TextureDataRequest.node_key)
  return _internal_node_key();
}
inline void TextureDataRequest::unsafe_arena_set_allocated_node_key(
    ::geo_globetrotter_proto_rocktree::NodeKey* node_key) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.node_key_);
  }
  _impl_.node_key_ = node_key;
  if (node_key) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:geo_globetrotter_proto_rocktree.TextureDataRequest.node_key)
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* TextureDataRequest::release_node_key() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::geo_globetrotter_proto_rocktree::NodeKey* temp = _impl_.node_key_;
  _impl_.node_key_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* TextureDataRequest::unsafe_arena_release_node_key() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.TextureDataRequest.node_key)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::geo_globetrotter_proto_rocktree::NodeKey* temp = _impl_.node_key_;
  _impl_.node_key_ = nullptr;
  return temp;
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* TextureDataRequest::_internal_mutable_node_key() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.node_key_ == nullptr) {
    auto* p = CreateMaybeMessage<::geo_globetrotter_proto_rocktree::NodeKey>(GetArenaForAllocation());
    _impl_.node_key_ = p;
  }
  return _impl_.node_key_;
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* TextureDataRequest::mutable_node_key() {
  ::geo_globetrotter_proto_rocktree::NodeKey* _msg = _internal_mutable_node_key();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.TextureDataRequest.node_key)
  return _msg;
}
inline void TextureDataRequest::set_allocated_node_key(::geo_globetrotter_proto_rocktree::NodeKey* node_key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.node_key_;
  }
  if (node_key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(node_key);
    if (message_arena != submessage_arena) {
      node_key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, node_key, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.node_key_ = node_key;
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.TextureDataRequest.node_key)
}

// optional .geo_globetrotter_proto_rocktree.Texture.Format texture_format = 2;
inline bool TextureDataRequest::has_texture_format() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline void TextureDataRequest::clear_texture_format() {
  _impl_.texture_format_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::geo_globetrotter_proto_rocktree::Texture_Format TextureDataRequest::_internal_texture_format() const {
  return static_cast< ::geo_globetrotter_proto_rocktree::Texture_Format >(_impl_.texture_format_);
}
inline ::geo_globetrotter_proto_rocktree::Texture_Format TextureDataRequest::texture_format() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.TextureDataRequest.texture_format)
  return _internal_texture_format();
}
inline void TextureDataRequest::_internal_set_texture_format(::geo_globetrotter_proto_rocktree::Texture_Format value) {
  assert(::geo_globetrotter_proto_rocktree::Texture_Format_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.texture_format_ = value;
}
inline void TextureDataRequest::set_texture_format(::geo_globetrotter_proto_rocktree::Texture_Format value) {
  _internal_set_texture_format(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.TextureDataRequest.texture_format)
}

// optional .geo_globetrotter_proto_rocktree.Texture.ViewDirection view_direction = 3;
inline bool TextureDataRequest::has_view_direction() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline void TextureDataRequest::clear_view_direction() {
  _impl_.view_direction_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::geo_globetrotter_proto_rocktree::Texture_ViewDirection TextureDataRequest::_internal_view_direction() const {
  return static_cast< ::geo_globetrotter_proto_rocktree::Texture_ViewDirection >(_impl_.view_direction_);
}
inline ::geo_globetrotter_proto_rocktree::Texture_ViewDirection TextureDataRequest::view_direction() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.TextureDataRequest.view_direction)
  return _internal_view_direction();
}
inline void TextureDataRequest::_internal_set_view_direction(::geo_globetrotter_proto_rocktree::Texture_ViewDirection value) {
  assert(::geo_globetrotter_proto_rocktree::Texture_ViewDirection_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.view_direction_ = value;
}
inline void TextureDataRequest::set_view_direction(::geo_globetrotter_proto_rocktree::Texture_ViewDirection value) {
  _internal_set_view_direction(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.TextureDataRequest.view_direction)
}

// -------------------------------------------------------------------

// BulkMetadata

// repeated .geo_globetrotter_proto_rocktree.NodeMetadata node_metadata = 1;
inline int BulkMetadata::_internal_node_metadata_size() const {
  return _impl_.node_metadata_.size();
}
inline int BulkMetadata::node_metadata_size() const {
  return _internal_node_metadata_size();
}
inline void BulkMetadata::clear_node_metadata() {
  _impl_.node_metadata_.Clear();
}
inline ::geo_globetrotter_proto_rocktree::NodeMetadata* BulkMetadata::mutable_node_metadata(int index) {
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.BulkMetadata.node_metadata)
  return _impl_.node_metadata_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::NodeMetadata >*
BulkMetadata::mutable_node_metadata() {
  // @@protoc_insertion_point(field_mutable_list:geo_globetrotter_proto_rocktree.BulkMetadata.node_metadata)
  return &_impl_.node_metadata_;
}
inline const ::geo_globetrotter_proto_rocktree::NodeMetadata& BulkMetadata::_internal_node_metadata(int index) const {
  return _impl_.node_metadata_.Get(index);
}
inline const ::geo_globetrotter_proto_rocktree::NodeMetadata& BulkMetadata::node_metadata(int index) const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.BulkMetadata.node_metadata)
  return _internal_node_metadata(index);
}
inline ::geo_globetrotter_proto_rocktree::NodeMetadata* BulkMetadata::_internal_add_node_metadata() {
  return _impl_.node_metadata_.Add();
}
inline ::geo_globetrotter_proto_rocktree::NodeMetadata* BulkMetadata::add_node_metadata() {
  ::geo_globetrotter_proto_rocktree::NodeMetadata* _add = _internal_add_node_metadata();
  // @@protoc_insertion_point(field_add:geo_globetrotter_proto_rocktree.BulkMetadata.node_metadata)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::NodeMetadata >&
BulkMetadata::node_metadata() const {
  // @@protoc_insertion_point(field_list:geo_globetrotter_proto_rocktree.BulkMetadata.node_metadata)
  return _impl_.node_metadata_;
}

// optional .geo_globetrotter_proto_rocktree.NodeKey head_node_key = 2;
inline bool BulkMetadata::has_head_node_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.head_node_key_ != nullptr);
  return value;
}
inline void BulkMetadata::clear_head_node_key() {
  if (_impl_.head_node_key_ != nullptr) _impl_.head_node_key_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::geo_globetrotter_proto_rocktree::NodeKey& BulkMetadata::_internal_head_node_key() const {
  const ::geo_globetrotter_proto_rocktree::NodeKey* p = _impl_.head_node_key_;
  return p != nullptr ? *p : reinterpret_cast<const ::geo_globetrotter_proto_rocktree::NodeKey&>(
      ::geo_globetrotter_proto_rocktree::_NodeKey_default_instance_);
}
inline const ::geo_globetrotter_proto_rocktree::NodeKey& BulkMetadata::head_node_key() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.BulkMetadata.head_node_key)
  return _internal_head_node_key();
}
inline void BulkMetadata::unsafe_arena_set_allocated_head_node_key(
    ::geo_globetrotter_proto_rocktree::NodeKey* head_node_key) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.head_node_key_);
  }
  _impl_.head_node_key_ = head_node_key;
  if (head_node_key) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:geo_globetrotter_proto_rocktree.BulkMetadata.head_node_key)
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* BulkMetadata::release_head_node_key() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::geo_globetrotter_proto_rocktree::NodeKey* temp = _impl_.head_node_key_;
  _impl_.head_node_key_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* BulkMetadata::unsafe_arena_release_head_node_key() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.BulkMetadata.head_node_key)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::geo_globetrotter_proto_rocktree::NodeKey* temp = _impl_.head_node_key_;
  _impl_.head_node_key_ = nullptr;
  return temp;
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* BulkMetadata::_internal_mutable_head_node_key() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.head_node_key_ == nullptr) {
    auto* p = CreateMaybeMessage<::geo_globetrotter_proto_rocktree::NodeKey>(GetArenaForAllocation());
    _impl_.head_node_key_ = p;
  }
  return _impl_.head_node_key_;
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* BulkMetadata::mutable_head_node_key() {
  ::geo_globetrotter_proto_rocktree::NodeKey* _msg = _internal_mutable_head_node_key();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.BulkMetadata.head_node_key)
  return _msg;
}
inline void BulkMetadata::set_allocated_head_node_key(::geo_globetrotter_proto_rocktree::NodeKey* head_node_key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.head_node_key_;
  }
  if (head_node_key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(head_node_key);
    if (message_arena != submessage_arena) {
      head_node_key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, head_node_key, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.head_node_key_ = head_node_key;
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.BulkMetadata.head_node_key)
}

// repeated double head_node_center = 3 [packed = true];
inline int BulkMetadata::_internal_head_node_center_size() const {
  return _impl_.head_node_center_.size();
}
inline int BulkMetadata::head_node_center_size() const {
  return _internal_head_node_center_size();
}
inline void BulkMetadata::clear_head_node_center() {
  _impl_.head_node_center_.Clear();
}
inline double BulkMetadata::_internal_head_node_center(int index) const {
  return _impl_.head_node_center_.Get(index);
}
inline double BulkMetadata::head_node_center(int index) const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.BulkMetadata.head_node_center)
  return _internal_head_node_center(index);
}
inline void BulkMetadata::set_head_node_center(int index, double value) {
  _impl_.head_node_center_.Set(index, value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.BulkMetadata.head_node_center)
}
inline void BulkMetadata::_internal_add_head_node_center(double value) {
  _impl_.head_node_center_.Add(value);
}
inline void BulkMetadata::add_head_node_center(double value) {
  _internal_add_head_node_center(value);
  // @@protoc_insertion_point(field_add:geo_globetrotter_proto_rocktree.BulkMetadata.head_node_center)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
BulkMetadata::_internal_head_node_center() const {
  return _impl_.head_node_center_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
BulkMetadata::head_node_center() const {
  // @@protoc_insertion_point(field_list:geo_globetrotter_proto_rocktree.BulkMetadata.head_node_center)
  return _internal_head_node_center();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
BulkMetadata::_internal_mutable_head_node_center() {
  return &_impl_.head_node_center_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
BulkMetadata::mutable_head_node_center() {
  // @@protoc_insertion_point(field_mutable_list:geo_globetrotter_proto_rocktree.BulkMetadata.head_node_center)
  return _internal_mutable_head_node_center();
}

// repeated float meters_per_texel = 4 [packed = true];
inline int BulkMetadata::_internal_meters_per_texel_size() const {
  return _impl_.meters_per_texel_.size();
}
inline int BulkMetadata::meters_per_texel_size() const {
  return _internal_meters_per_texel_size();
}
inline void BulkMetadata::clear_meters_per_texel() {
  _impl_.meters_per_texel_.Clear();
}
inline float BulkMetadata::_internal_meters_per_texel(int index) const {
  return _impl_.meters_per_texel_.Get(index);
}
inline float BulkMetadata::meters_per_texel(int index) const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.BulkMetadata.meters_per_texel)
  return _internal_meters_per_texel(index);
}
inline void BulkMetadata::set_meters_per_texel(int index, float value) {
  _impl_.meters_per_texel_.Set(index, value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.BulkMetadata.meters_per_texel)
}
inline void BulkMetadata::_internal_add_meters_per_texel(float value) {
  _impl_.meters_per_texel_.Add(value);
}
inline void BulkMetadata::add_meters_per_texel(float value) {
  _internal_add_meters_per_texel(value);
  // @@protoc_insertion_point(field_add:geo_globetrotter_proto_rocktree.BulkMetadata.meters_per_texel)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
BulkMetadata::_internal_meters_per_texel() const {
  return _impl_.meters_per_texel_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
BulkMetadata::meters_per_texel() const {
  // @@protoc_insertion_point(field_list:geo_globetrotter_proto_rocktree.BulkMetadata.meters_per_texel)
  return _internal_meters_per_texel();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
BulkMetadata::_internal_mutable_meters_per_texel() {
  return &_impl_.meters_per_texel_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
BulkMetadata::mutable_meters_per_texel() {
  // @@protoc_insertion_point(field_mutable_list:geo_globetrotter_proto_rocktree.BulkMetadata.meters_per_texel)
  return _internal_mutable_meters_per_texel();
}

// optional uint32 default_imagery_epoch = 5;
inline bool BulkMetadata::has_default_imagery_epoch() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline void BulkMetadata::clear_default_imagery_epoch() {
  _impl_.default_imagery_epoch_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::uint32_t BulkMetadata::_internal_default_imagery_epoch() const {
  return _impl_.default_imagery_epoch_;
}
inline ::uint32_t BulkMetadata::default_imagery_epoch() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.BulkMetadata.default_imagery_epoch)
  return _internal_default_imagery_epoch();
}
inline void BulkMetadata::_internal_set_default_imagery_epoch(::uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.default_imagery_epoch_ = value;
}
inline void BulkMetadata::set_default_imagery_epoch(::uint32_t value) {
  _internal_set_default_imagery_epoch(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.BulkMetadata.default_imagery_epoch)
}

// optional uint32 default_available_texture_formats = 6;
inline bool BulkMetadata::has_default_available_texture_formats() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline void BulkMetadata::clear_default_available_texture_formats() {
  _impl_.default_available_texture_formats_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::uint32_t BulkMetadata::_internal_default_available_texture_formats() const {
  return _impl_.default_available_texture_formats_;
}
inline ::uint32_t BulkMetadata::default_available_texture_formats() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.BulkMetadata.default_available_texture_formats)
  return _internal_default_available_texture_formats();
}
inline void BulkMetadata::_internal_set_default_available_texture_formats(::uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.default_available_texture_formats_ = value;
}
inline void BulkMetadata::set_default_available_texture_formats(::uint32_t value) {
  _internal_set_default_available_texture_formats(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.BulkMetadata.default_available_texture_formats)
}

// optional uint32 default_available_view_dependent_textures = 7;
inline bool BulkMetadata::has_default_available_view_dependent_textures() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline void BulkMetadata::clear_default_available_view_dependent_textures() {
  _impl_.default_available_view_dependent_textures_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline ::uint32_t BulkMetadata::_internal_default_available_view_dependent_textures() const {
  return _impl_.default_available_view_dependent_textures_;
}
inline ::uint32_t BulkMetadata::default_available_view_dependent_textures() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.BulkMetadata.default_available_view_dependent_textures)
  return _internal_default_available_view_dependent_textures();
}
inline void BulkMetadata::_internal_set_default_available_view_dependent_textures(::uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.default_available_view_dependent_textures_ = value;
}
inline void BulkMetadata::set_default_available_view_dependent_textures(::uint32_t value) {
  _internal_set_default_available_view_dependent_textures(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.BulkMetadata.default_available_view_dependent_textures)
}

// optional uint32 default_available_view_dependent_texture_formats = 8;
inline bool BulkMetadata::has_default_available_view_dependent_texture_formats() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline void BulkMetadata::clear_default_available_view_dependent_texture_formats() {
  _impl_.default_available_view_dependent_texture_formats_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline ::uint32_t BulkMetadata::_internal_default_available_view_dependent_texture_formats() const {
  return _impl_.default_available_view_dependent_texture_formats_;
}
inline ::uint32_t BulkMetadata::default_available_view_dependent_texture_formats() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.BulkMetadata.default_available_view_dependent_texture_formats)
  return _internal_default_available_view_dependent_texture_formats();
}
inline void BulkMetadata::_internal_set_default_available_view_dependent_texture_formats(::uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.default_available_view_dependent_texture_formats_ = value;
}
inline void BulkMetadata::set_default_available_view_dependent_texture_formats(::uint32_t value) {
  _internal_set_default_available_view_dependent_texture_formats(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.BulkMetadata.default_available_view_dependent_texture_formats)
}

// -------------------------------------------------------------------

// NodeMetadata

// optional uint32 path_and_flags = 1;
inline bool NodeMetadata::has_path_and_flags() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline void NodeMetadata::clear_path_and_flags() {
  _impl_.path_and_flags_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::uint32_t NodeMetadata::_internal_path_and_flags() const {
  return _impl_.path_and_flags_;
}
inline ::uint32_t NodeMetadata::path_and_flags() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeMetadata.path_and_flags)
  return _internal_path_and_flags();
}
inline void NodeMetadata::_internal_set_path_and_flags(::uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.path_and_flags_ = value;
}
inline void NodeMetadata::set_path_and_flags(::uint32_t value) {
  _internal_set_path_and_flags(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.NodeMetadata.path_and_flags)
}

// optional uint32 epoch = 2;
inline bool NodeMetadata::has_epoch() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline void NodeMetadata::clear_epoch() {
  _impl_.epoch_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::uint32_t NodeMetadata::_internal_epoch() const {
  return _impl_.epoch_;
}
inline ::uint32_t NodeMetadata::epoch() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeMetadata.epoch)
  return _internal_epoch();
}
inline void NodeMetadata::_internal_set_epoch(::uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.epoch_ = value;
}
inline void NodeMetadata::set_epoch(::uint32_t value) {
  _internal_set_epoch(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.NodeMetadata.epoch)
}

// optional uint32 bulk_metadata_epoch = 5;
inline bool NodeMetadata::has_bulk_metadata_epoch() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline void NodeMetadata::clear_bulk_metadata_epoch() {
  _impl_.bulk_metadata_epoch_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline ::uint32_t NodeMetadata::_internal_bulk_metadata_epoch() const {
  return _impl_.bulk_metadata_epoch_;
}
inline ::uint32_t NodeMetadata::bulk_metadata_epoch() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeMetadata.bulk_metadata_epoch)
  return _internal_bulk_metadata_epoch();
}
inline void NodeMetadata::_internal_set_bulk_metadata_epoch(::uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.bulk_metadata_epoch_ = value;
}
inline void NodeMetadata::set_bulk_metadata_epoch(::uint32_t value) {
  _internal_set_bulk_metadata_epoch(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.NodeMetadata.bulk_metadata_epoch)
}

// optional bytes oriented_bounding_box = 3;
inline bool NodeMetadata::has_oriented_bounding_box() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline void NodeMetadata::clear_oriented_bounding_box() {
  _impl_.oriented_bounding_box_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& NodeMetadata::oriented_bounding_box() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeMetadata.oriented_bounding_box)
  return _internal_oriented_bounding_box();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NodeMetadata::set_oriented_bounding_box(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.oriented_bounding_box_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.NodeMetadata.oriented_bounding_box)
}
inline std::string* NodeMetadata::mutable_oriented_bounding_box() {
  std::string* _s = _internal_mutable_oriented_bounding_box();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.NodeMetadata.oriented_bounding_box)
  return _s;
}
inline const std::string& NodeMetadata::_internal_oriented_bounding_box() const {
  return _impl_.oriented_bounding_box_.Get();
}
inline void NodeMetadata::_internal_set_oriented_bounding_box(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.oriented_bounding_box_.Set(value, GetArenaForAllocation());
}
inline std::string* NodeMetadata::_internal_mutable_oriented_bounding_box() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.oriented_bounding_box_.Mutable(GetArenaForAllocation());
}
inline std::string* NodeMetadata::release_oriented_bounding_box() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.NodeMetadata.oriented_bounding_box)
  if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.oriented_bounding_box_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.oriented_bounding_box_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void NodeMetadata::set_allocated_oriented_bounding_box(std::string* oriented_bounding_box) {
  if (oriented_bounding_box != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.oriented_bounding_box_.SetAllocated(oriented_bounding_box, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.oriented_bounding_box_.IsDefault()) {
    _impl_.oriented_bounding_box_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.NodeMetadata.oriented_bounding_box)
}

// optional float meters_per_texel = 4;
inline bool NodeMetadata::has_meters_per_texel() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline void NodeMetadata::clear_meters_per_texel() {
  _impl_.meters_per_texel_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float NodeMetadata::_internal_meters_per_texel() const {
  return _impl_.meters_per_texel_;
}
inline float NodeMetadata::meters_per_texel() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeMetadata.meters_per_texel)
  return _internal_meters_per_texel();
}
inline void NodeMetadata::_internal_set_meters_per_texel(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.meters_per_texel_ = value;
}
inline void NodeMetadata::set_meters_per_texel(float value) {
  _internal_set_meters_per_texel(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.NodeMetadata.meters_per_texel)
}

// repeated double processing_oriented_bounding_box = 6 [packed = true];
inline int NodeMetadata::_internal_processing_oriented_bounding_box_size() const {
  return _impl_.processing_oriented_bounding_box_.size();
}
inline int NodeMetadata::processing_oriented_bounding_box_size() const {
  return _internal_processing_oriented_bounding_box_size();
}
inline void NodeMetadata::clear_processing_oriented_bounding_box() {
  _impl_.processing_oriented_bounding_box_.Clear();
}
inline double NodeMetadata::_internal_processing_oriented_bounding_box(int index) const {
  return _impl_.processing_oriented_bounding_box_.Get(index);
}
inline double NodeMetadata::processing_oriented_bounding_box(int index) const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeMetadata.processing_oriented_bounding_box)
  return _internal_processing_oriented_bounding_box(index);
}
inline void NodeMetadata::set_processing_oriented_bounding_box(int index, double value) {
  _impl_.processing_oriented_bounding_box_.Set(index, value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.NodeMetadata.processing_oriented_bounding_box)
}
inline void NodeMetadata::_internal_add_processing_oriented_bounding_box(double value) {
  _impl_.processing_oriented_bounding_box_.Add(value);
}
inline void NodeMetadata::add_processing_oriented_bounding_box(double value) {
  _internal_add_processing_oriented_bounding_box(value);
  // @@protoc_insertion_point(field_add:geo_globetrotter_proto_rocktree.NodeMetadata.processing_oriented_bounding_box)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
NodeMetadata::_internal_processing_oriented_bounding_box() const {
  return _impl_.processing_oriented_bounding_box_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
NodeMetadata::processing_oriented_bounding_box() const {
  // @@protoc_insertion_point(field_list:geo_globetrotter_proto_rocktree.NodeMetadata.processing_oriented_bounding_box)
  return _internal_processing_oriented_bounding_box();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
NodeMetadata::_internal_mutable_processing_oriented_bounding_box() {
  return &_impl_.processing_oriented_bounding_box_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
NodeMetadata::mutable_processing_oriented_bounding_box() {
  // @@protoc_insertion_point(field_mutable_list:geo_globetrotter_proto_rocktree.NodeMetadata.processing_oriented_bounding_box)
  return _internal_mutable_processing_oriented_bounding_box();
}

// optional uint32 imagery_epoch = 7;
inline bool NodeMetadata::has_imagery_epoch() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline void NodeMetadata::clear_imagery_epoch() {
  _impl_.imagery_epoch_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline ::uint32_t NodeMetadata::_internal_imagery_epoch() const {
  return _impl_.imagery_epoch_;
}
inline ::uint32_t NodeMetadata::imagery_epoch() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeMetadata.imagery_epoch)
  return _internal_imagery_epoch();
}
inline void NodeMetadata::_internal_set_imagery_epoch(::uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.imagery_epoch_ = value;
}
inline void NodeMetadata::set_imagery_epoch(::uint32_t value) {
  _internal_set_imagery_epoch(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.NodeMetadata.imagery_epoch)
}

// optional uint32 available_texture_formats = 8;
inline bool NodeMetadata::has_available_texture_formats() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline void NodeMetadata::clear_available_texture_formats() {
  _impl_.available_texture_formats_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline ::uint32_t NodeMetadata::_internal_available_texture_formats() const {
  return _impl_.available_texture_formats_;
}
inline ::uint32_t NodeMetadata::available_texture_formats() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeMetadata.available_texture_formats)
  return _internal_available_texture_formats();
}
inline void NodeMetadata::_internal_set_available_texture_formats(::uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.available_texture_formats_ = value;
}
inline void NodeMetadata::set_available_texture_formats(::uint32_t value) {
  _internal_set_available_texture_formats(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.NodeMetadata.available_texture_formats)
}

// optional uint32 available_view_dependent_textures = 9;
inline bool NodeMetadata::has_available_view_dependent_textures() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline void NodeMetadata::clear_available_view_dependent_textures() {
  _impl_.available_view_dependent_textures_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline ::uint32_t NodeMetadata::_internal_available_view_dependent_textures() const {
  return _impl_.available_view_dependent_textures_;
}
inline ::uint32_t NodeMetadata::available_view_dependent_textures() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeMetadata.available_view_dependent_textures)
  return _internal_available_view_dependent_textures();
}
inline void NodeMetadata::_internal_set_available_view_dependent_textures(::uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.available_view_dependent_textures_ = value;
}
inline void NodeMetadata::set_available_view_dependent_textures(::uint32_t value) {
  _internal_set_available_view_dependent_textures(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.NodeMetadata.available_view_dependent_textures)
}

// optional uint32 available_view_dependent_texture_formats = 10;
inline bool NodeMetadata::has_available_view_dependent_texture_formats() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline void NodeMetadata::clear_available_view_dependent_texture_formats() {
  _impl_.available_view_dependent_texture_formats_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline ::uint32_t NodeMetadata::_internal_available_view_dependent_texture_formats() const {
  return _impl_.available_view_dependent_texture_formats_;
}
inline ::uint32_t NodeMetadata::available_view_dependent_texture_formats() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeMetadata.available_view_dependent_texture_formats)
  return _internal_available_view_dependent_texture_formats();
}
inline void NodeMetadata::_internal_set_available_view_dependent_texture_formats(::uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.available_view_dependent_texture_formats_ = value;
}
inline void NodeMetadata::set_available_view_dependent_texture_formats(::uint32_t value) {
  _internal_set_available_view_dependent_texture_formats(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.NodeMetadata.available_view_dependent_texture_formats)
}

// -------------------------------------------------------------------

// NodeData

// repeated double matrix_globe_from_mesh = 1 [packed = true];
inline int NodeData::_internal_matrix_globe_from_mesh_size() const {
  return _impl_.matrix_globe_from_mesh_.size();
}
inline int NodeData::matrix_globe_from_mesh_size() const {
  return _internal_matrix_globe_from_mesh_size();
}
inline void NodeData::clear_matrix_globe_from_mesh() {
  _impl_.matrix_globe_from_mesh_.Clear();
}
inline double NodeData::_internal_matrix_globe_from_mesh(int index) const {
  return _impl_.matrix_globe_from_mesh_.Get(index);
}
inline double NodeData::matrix_globe_from_mesh(int index) const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeData.matrix_globe_from_mesh)
  return _internal_matrix_globe_from_mesh(index);
}
inline void NodeData::set_matrix_globe_from_mesh(int index, double value) {
  _impl_.matrix_globe_from_mesh_.Set(index, value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.NodeData.matrix_globe_from_mesh)
}
inline void NodeData::_internal_add_matrix_globe_from_mesh(double value) {
  _impl_.matrix_globe_from_mesh_.Add(value);
}
inline void NodeData::add_matrix_globe_from_mesh(double value) {
  _internal_add_matrix_globe_from_mesh(value);
  // @@protoc_insertion_point(field_add:geo_globetrotter_proto_rocktree.NodeData.matrix_globe_from_mesh)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
NodeData::_internal_matrix_globe_from_mesh() const {
  return _impl_.matrix_globe_from_mesh_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
NodeData::matrix_globe_from_mesh() const {
  // @@protoc_insertion_point(field_list:geo_globetrotter_proto_rocktree.NodeData.matrix_globe_from_mesh)
  return _internal_matrix_globe_from_mesh();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
NodeData::_internal_mutable_matrix_globe_from_mesh() {
  return &_impl_.matrix_globe_from_mesh_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
NodeData::mutable_matrix_globe_from_mesh() {
  // @@protoc_insertion_point(field_mutable_list:geo_globetrotter_proto_rocktree.NodeData.matrix_globe_from_mesh)
  return _internal_mutable_matrix_globe_from_mesh();
}

// repeated .geo_globetrotter_proto_rocktree.Mesh meshes = 2;
inline int NodeData::_internal_meshes_size() const {
  return _impl_.meshes_.size();
}
inline int NodeData::meshes_size() const {
  return _internal_meshes_size();
}
inline void NodeData::clear_meshes() {
  _impl_.meshes_.Clear();
}
inline ::geo_globetrotter_proto_rocktree::Mesh* NodeData::mutable_meshes(int index) {
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.NodeData.meshes)
  return _impl_.meshes_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Mesh >*
NodeData::mutable_meshes() {
  // @@protoc_insertion_point(field_mutable_list:geo_globetrotter_proto_rocktree.NodeData.meshes)
  return &_impl_.meshes_;
}
inline const ::geo_globetrotter_proto_rocktree::Mesh& NodeData::_internal_meshes(int index) const {
  return _impl_.meshes_.Get(index);
}
inline const ::geo_globetrotter_proto_rocktree::Mesh& NodeData::meshes(int index) const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeData.meshes)
  return _internal_meshes(index);
}
inline ::geo_globetrotter_proto_rocktree::Mesh* NodeData::_internal_add_meshes() {
  return _impl_.meshes_.Add();
}
inline ::geo_globetrotter_proto_rocktree::Mesh* NodeData::add_meshes() {
  ::geo_globetrotter_proto_rocktree::Mesh* _add = _internal_add_meshes();
  // @@protoc_insertion_point(field_add:geo_globetrotter_proto_rocktree.NodeData.meshes)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Mesh >&
NodeData::meshes() const {
  // @@protoc_insertion_point(field_list:geo_globetrotter_proto_rocktree.NodeData.meshes)
  return _impl_.meshes_;
}

// repeated uint32 copyright_ids = 3;
inline int NodeData::_internal_copyright_ids_size() const {
  return _impl_.copyright_ids_.size();
}
inline int NodeData::copyright_ids_size() const {
  return _internal_copyright_ids_size();
}
inline void NodeData::clear_copyright_ids() {
  _impl_.copyright_ids_.Clear();
}
inline ::uint32_t NodeData::_internal_copyright_ids(int index) const {
  return _impl_.copyright_ids_.Get(index);
}
inline ::uint32_t NodeData::copyright_ids(int index) const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeData.copyright_ids)
  return _internal_copyright_ids(index);
}
inline void NodeData::set_copyright_ids(int index, ::uint32_t value) {
  _impl_.copyright_ids_.Set(index, value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.NodeData.copyright_ids)
}
inline void NodeData::_internal_add_copyright_ids(::uint32_t value) {
  _impl_.copyright_ids_.Add(value);
}
inline void NodeData::add_copyright_ids(::uint32_t value) {
  _internal_add_copyright_ids(value);
  // @@protoc_insertion_point(field_add:geo_globetrotter_proto_rocktree.NodeData.copyright_ids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >&
NodeData::_internal_copyright_ids() const {
  return _impl_.copyright_ids_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >&
NodeData::copyright_ids() const {
  // @@protoc_insertion_point(field_list:geo_globetrotter_proto_rocktree.NodeData.copyright_ids)
  return _internal_copyright_ids();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >*
NodeData::_internal_mutable_copyright_ids() {
  return &_impl_.copyright_ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >*
NodeData::mutable_copyright_ids() {
  // @@protoc_insertion_point(field_mutable_list:geo_globetrotter_proto_rocktree.NodeData.copyright_ids)
  return _internal_mutable_copyright_ids();
}

// optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 4;
inline bool NodeData::has_node_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.node_key_ != nullptr);
  return value;
}
inline void NodeData::clear_node_key() {
  if (_impl_.node_key_ != nullptr) _impl_.node_key_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::geo_globetrotter_proto_rocktree::NodeKey& NodeData::_internal_node_key() const {
  const ::geo_globetrotter_proto_rocktree::NodeKey* p = _impl_.node_key_;
  return p != nullptr ? *p : reinterpret_cast<const ::geo_globetrotter_proto_rocktree::NodeKey&>(
      ::geo_globetrotter_proto_rocktree::_NodeKey_default_instance_);
}
inline const ::geo_globetrotter_proto_rocktree::NodeKey& NodeData::node_key() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeData.node_key)
  return _internal_node_key();
}
inline void NodeData::unsafe_arena_set_allocated_node_key(
    ::geo_globetrotter_proto_rocktree::NodeKey* node_key) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.node_key_);
  }
  _impl_.node_key_ = node_key;
  if (node_key) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:geo_globetrotter_proto_rocktree.NodeData.node_key)
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* NodeData::release_node_key() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::geo_globetrotter_proto_rocktree::NodeKey* temp = _impl_.node_key_;
  _impl_.node_key_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* NodeData::unsafe_arena_release_node_key() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.NodeData.node_key)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::geo_globetrotter_proto_rocktree::NodeKey* temp = _impl_.node_key_;
  _impl_.node_key_ = nullptr;
  return temp;
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* NodeData::_internal_mutable_node_key() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.node_key_ == nullptr) {
    auto* p = CreateMaybeMessage<::geo_globetrotter_proto_rocktree::NodeKey>(GetArenaForAllocation());
    _impl_.node_key_ = p;
  }
  return _impl_.node_key_;
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* NodeData::mutable_node_key() {
  ::geo_globetrotter_proto_rocktree::NodeKey* _msg = _internal_mutable_node_key();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.NodeData.node_key)
  return _msg;
}
inline void NodeData::set_allocated_node_key(::geo_globetrotter_proto_rocktree::NodeKey* node_key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.node_key_;
  }
  if (node_key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(node_key);
    if (message_arena != submessage_arena) {
      node_key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, node_key, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.node_key_ = node_key;
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.NodeData.node_key)
}

// repeated double kml_bounding_box = 5 [packed = true];
inline int NodeData::_internal_kml_bounding_box_size() const {
  return _impl_.kml_bounding_box_.size();
}
inline int NodeData::kml_bounding_box_size() const {
  return _internal_kml_bounding_box_size();
}
inline void NodeData::clear_kml_bounding_box() {
  _impl_.kml_bounding_box_.Clear();
}
inline double NodeData::_internal_kml_bounding_box(int index) const {
  return _impl_.kml_bounding_box_.Get(index);
}
inline double NodeData::kml_bounding_box(int index) const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeData.kml_bounding_box)
  return _internal_kml_bounding_box(index);
}
inline void NodeData::set_kml_bounding_box(int index, double value) {
  _impl_.kml_bounding_box_.Set(index, value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.NodeData.kml_bounding_box)
}
inline void NodeData::_internal_add_kml_bounding_box(double value) {
  _impl_.kml_bounding_box_.Add(value);
}
inline void NodeData::add_kml_bounding_box(double value) {
  _internal_add_kml_bounding_box(value);
  // @@protoc_insertion_point(field_add:geo_globetrotter_proto_rocktree.NodeData.kml_bounding_box)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
NodeData::_internal_kml_bounding_box() const {
  return _impl_.kml_bounding_box_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
NodeData::kml_bounding_box() const {
  // @@protoc_insertion_point(field_list:geo_globetrotter_proto_rocktree.NodeData.kml_bounding_box)
  return _internal_kml_bounding_box();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
NodeData::_internal_mutable_kml_bounding_box() {
  return &_impl_.kml_bounding_box_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
NodeData::mutable_kml_bounding_box() {
  // @@protoc_insertion_point(field_mutable_list:geo_globetrotter_proto_rocktree.NodeData.kml_bounding_box)
  return _internal_mutable_kml_bounding_box();
}

// optional .geo_globetrotter_proto_rocktree.Mesh water_mesh = 6;
inline bool NodeData::has_water_mesh() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.water_mesh_ != nullptr);
  return value;
}
inline void NodeData::clear_water_mesh() {
  if (_impl_.water_mesh_ != nullptr) _impl_.water_mesh_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::geo_globetrotter_proto_rocktree::Mesh& NodeData::_internal_water_mesh() const {
  const ::geo_globetrotter_proto_rocktree::Mesh* p = _impl_.water_mesh_;
  return p != nullptr ? *p : reinterpret_cast<const ::geo_globetrotter_proto_rocktree::Mesh&>(
      ::geo_globetrotter_proto_rocktree::_Mesh_default_instance_);
}
inline const ::geo_globetrotter_proto_rocktree::Mesh& NodeData::water_mesh() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeData.water_mesh)
  return _internal_water_mesh();
}
inline void NodeData::unsafe_arena_set_allocated_water_mesh(
    ::geo_globetrotter_proto_rocktree::Mesh* water_mesh) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.water_mesh_);
  }
  _impl_.water_mesh_ = water_mesh;
  if (water_mesh) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:geo_globetrotter_proto_rocktree.NodeData.water_mesh)
}
inline ::geo_globetrotter_proto_rocktree::Mesh* NodeData::release_water_mesh() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::geo_globetrotter_proto_rocktree::Mesh* temp = _impl_.water_mesh_;
  _impl_.water_mesh_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::geo_globetrotter_proto_rocktree::Mesh* NodeData::unsafe_arena_release_water_mesh() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.NodeData.water_mesh)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::geo_globetrotter_proto_rocktree::Mesh* temp = _impl_.water_mesh_;
  _impl_.water_mesh_ = nullptr;
  return temp;
}
inline ::geo_globetrotter_proto_rocktree::Mesh* NodeData::_internal_mutable_water_mesh() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.water_mesh_ == nullptr) {
    auto* p = CreateMaybeMessage<::geo_globetrotter_proto_rocktree::Mesh>(GetArenaForAllocation());
    _impl_.water_mesh_ = p;
  }
  return _impl_.water_mesh_;
}
inline ::geo_globetrotter_proto_rocktree::Mesh* NodeData::mutable_water_mesh() {
  ::geo_globetrotter_proto_rocktree::Mesh* _msg = _internal_mutable_water_mesh();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.NodeData.water_mesh)
  return _msg;
}
inline void NodeData::set_allocated_water_mesh(::geo_globetrotter_proto_rocktree::Mesh* water_mesh) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.water_mesh_;
  }
  if (water_mesh) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(water_mesh);
    if (message_arena != submessage_arena) {
      water_mesh = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, water_mesh, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.water_mesh_ = water_mesh;
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.NodeData.water_mesh)
}

// repeated .geo_globetrotter_proto_rocktree.Mesh overlay_surface_meshes = 7;
inline int NodeData::_internal_overlay_surface_meshes_size() const {
  return _impl_.overlay_surface_meshes_.size();
}
inline int NodeData::overlay_surface_meshes_size() const {
  return _internal_overlay_surface_meshes_size();
}
inline void NodeData::clear_overlay_surface_meshes() {
  _impl_.overlay_surface_meshes_.Clear();
}
inline ::geo_globetrotter_proto_rocktree::Mesh* NodeData::mutable_overlay_surface_meshes(int index) {
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.NodeData.overlay_surface_meshes)
  return _impl_.overlay_surface_meshes_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Mesh >*
NodeData::mutable_overlay_surface_meshes() {
  // @@protoc_insertion_point(field_mutable_list:geo_globetrotter_proto_rocktree.NodeData.overlay_surface_meshes)
  return &_impl_.overlay_surface_meshes_;
}
inline const ::geo_globetrotter_proto_rocktree::Mesh& NodeData::_internal_overlay_surface_meshes(int index) const {
  return _impl_.overlay_surface_meshes_.Get(index);
}
inline const ::geo_globetrotter_proto_rocktree::Mesh& NodeData::overlay_surface_meshes(int index) const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeData.overlay_surface_meshes)
  return _internal_overlay_surface_meshes(index);
}
inline ::geo_globetrotter_proto_rocktree::Mesh* NodeData::_internal_add_overlay_surface_meshes() {
  return _impl_.overlay_surface_meshes_.Add();
}
inline ::geo_globetrotter_proto_rocktree::Mesh* NodeData::add_overlay_surface_meshes() {
  ::geo_globetrotter_proto_rocktree::Mesh* _add = _internal_add_overlay_surface_meshes();
  // @@protoc_insertion_point(field_add:geo_globetrotter_proto_rocktree.NodeData.overlay_surface_meshes)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Mesh >&
NodeData::overlay_surface_meshes() const {
  // @@protoc_insertion_point(field_list:geo_globetrotter_proto_rocktree.NodeData.overlay_surface_meshes)
  return _impl_.overlay_surface_meshes_;
}

// optional bytes for_normals = 8;
inline bool NodeData::has_for_normals() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline void NodeData::clear_for_normals() {
  _impl_.for_normals_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& NodeData::for_normals() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.NodeData.for_normals)
  return _internal_for_normals();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NodeData::set_for_normals(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.for_normals_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.NodeData.for_normals)
}
inline std::string* NodeData::mutable_for_normals() {
  std::string* _s = _internal_mutable_for_normals();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.NodeData.for_normals)
  return _s;
}
inline const std::string& NodeData::_internal_for_normals() const {
  return _impl_.for_normals_.Get();
}
inline void NodeData::_internal_set_for_normals(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.for_normals_.Set(value, GetArenaForAllocation());
}
inline std::string* NodeData::_internal_mutable_for_normals() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.for_normals_.Mutable(GetArenaForAllocation());
}
inline std::string* NodeData::release_for_normals() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.NodeData.for_normals)
  if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.for_normals_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.for_normals_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void NodeData::set_allocated_for_normals(std::string* for_normals) {
  if (for_normals != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.for_normals_.SetAllocated(for_normals, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.for_normals_.IsDefault()) {
    _impl_.for_normals_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.NodeData.for_normals)
}

// -------------------------------------------------------------------

// Mesh

// optional bytes vertices = 1;
inline bool Mesh::has_vertices() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline void Mesh::clear_vertices() {
  _impl_.vertices_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Mesh::vertices() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Mesh.vertices)
  return _internal_vertices();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Mesh::set_vertices(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.vertices_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Mesh.vertices)
}
inline std::string* Mesh::mutable_vertices() {
  std::string* _s = _internal_mutable_vertices();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.Mesh.vertices)
  return _s;
}
inline const std::string& Mesh::_internal_vertices() const {
  return _impl_.vertices_.Get();
}
inline void Mesh::_internal_set_vertices(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.vertices_.Set(value, GetArenaForAllocation());
}
inline std::string* Mesh::_internal_mutable_vertices() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.vertices_.Mutable(GetArenaForAllocation());
}
inline std::string* Mesh::release_vertices() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.Mesh.vertices)
  if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.vertices_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.vertices_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Mesh::set_allocated_vertices(std::string* vertices) {
  if (vertices != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.vertices_.SetAllocated(vertices, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.vertices_.IsDefault()) {
    _impl_.vertices_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.Mesh.vertices)
}

// optional bytes vertex_alphas = 9;
inline bool Mesh::has_vertex_alphas() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline void Mesh::clear_vertex_alphas() {
  _impl_.vertex_alphas_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const std::string& Mesh::vertex_alphas() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Mesh.vertex_alphas)
  return _internal_vertex_alphas();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Mesh::set_vertex_alphas(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000080u;
 _impl_.vertex_alphas_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Mesh.vertex_alphas)
}
inline std::string* Mesh::mutable_vertex_alphas() {
  std::string* _s = _internal_mutable_vertex_alphas();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.Mesh.vertex_alphas)
  return _s;
}
inline const std::string& Mesh::_internal_vertex_alphas() const {
  return _impl_.vertex_alphas_.Get();
}
inline void Mesh::_internal_set_vertex_alphas(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.vertex_alphas_.Set(value, GetArenaForAllocation());
}
inline std::string* Mesh::_internal_mutable_vertex_alphas() {
  _impl_._has_bits_[0] |= 0x00000080u;
  return _impl_.vertex_alphas_.Mutable(GetArenaForAllocation());
}
inline std::string* Mesh::release_vertex_alphas() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.Mesh.vertex_alphas)
  if ((_impl_._has_bits_[0] & 0x00000080u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000080u;
  auto* p = _impl_.vertex_alphas_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.vertex_alphas_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Mesh::set_allocated_vertex_alphas(std::string* vertex_alphas) {
  if (vertex_alphas != nullptr) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.vertex_alphas_.SetAllocated(vertex_alphas, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.vertex_alphas_.IsDefault()) {
    _impl_.vertex_alphas_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.Mesh.vertex_alphas)
}

// optional bytes texture_coords = 2;
inline bool Mesh::has_texture_coords() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline void Mesh::clear_texture_coords() {
  _impl_.texture_coords_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Mesh::texture_coords() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Mesh.texture_coords)
  return _internal_texture_coords();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Mesh::set_texture_coords(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.texture_coords_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Mesh.texture_coords)
}
inline std::string* Mesh::mutable_texture_coords() {
  std::string* _s = _internal_mutable_texture_coords();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.Mesh.texture_coords)
  return _s;
}
inline const std::string& Mesh::_internal_texture_coords() const {
  return _impl_.texture_coords_.Get();
}
inline void Mesh::_internal_set_texture_coords(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.texture_coords_.Set(value, GetArenaForAllocation());
}
inline std::string* Mesh::_internal_mutable_texture_coords() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.texture_coords_.Mutable(GetArenaForAllocation());
}
inline std::string* Mesh::release_texture_coords() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.Mesh.texture_coords)
  if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.texture_coords_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.texture_coords_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Mesh::set_allocated_texture_coords(std::string* texture_coords) {
  if (texture_coords != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.texture_coords_.SetAllocated(texture_coords, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.texture_coords_.IsDefault()) {
    _impl_.texture_coords_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.Mesh.texture_coords)
}

// optional bytes indices = 3;
inline bool Mesh::has_indices() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline void Mesh::clear_indices() {
  _impl_.indices_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Mesh::indices() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Mesh.indices)
  return _internal_indices();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Mesh::set_indices(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.indices_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Mesh.indices)
}
inline std::string* Mesh::mutable_indices() {
  std::string* _s = _internal_mutable_indices();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.Mesh.indices)
  return _s;
}
inline const std::string& Mesh::_internal_indices() const {
  return _impl_.indices_.Get();
}
inline void Mesh::_internal_set_indices(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.indices_.Set(value, GetArenaForAllocation());
}
inline std::string* Mesh::_internal_mutable_indices() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.indices_.Mutable(GetArenaForAllocation());
}
inline std::string* Mesh::release_indices() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.Mesh.indices)
  if ((_impl_._has_bits_[0] & 0x00000004u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.indices_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.indices_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Mesh::set_allocated_indices(std::string* indices) {
  if (indices != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.indices_.SetAllocated(indices, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.indices_.IsDefault()) {
    _impl_.indices_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.Mesh.indices)
}

// optional bytes octant_ranges = 4;
inline bool Mesh::has_octant_ranges() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline void Mesh::clear_octant_ranges() {
  _impl_.octant_ranges_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& Mesh::octant_ranges() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Mesh.octant_ranges)
  return _internal_octant_ranges();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Mesh::set_octant_ranges(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.octant_ranges_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Mesh.octant_ranges)
}
inline std::string* Mesh::mutable_octant_ranges() {
  std::string* _s = _internal_mutable_octant_ranges();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.Mesh.octant_ranges)
  return _s;
}
inline const std::string& Mesh::_internal_octant_ranges() const {
  return _impl_.octant_ranges_.Get();
}
inline void Mesh::_internal_set_octant_ranges(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.octant_ranges_.Set(value, GetArenaForAllocation());
}
inline std::string* Mesh::_internal_mutable_octant_ranges() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.octant_ranges_.Mutable(GetArenaForAllocation());
}
inline std::string* Mesh::release_octant_ranges() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.Mesh.octant_ranges)
  if ((_impl_._has_bits_[0] & 0x00000008u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.octant_ranges_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.octant_ranges_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Mesh::set_allocated_octant_ranges(std::string* octant_ranges) {
  if (octant_ranges != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.octant_ranges_.SetAllocated(octant_ranges, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.octant_ranges_.IsDefault()) {
    _impl_.octant_ranges_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.Mesh.octant_ranges)
}

// optional bytes layer_counts = 5;
inline bool Mesh::has_layer_counts() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline void Mesh::clear_layer_counts() {
  _impl_.layer_counts_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& Mesh::layer_counts() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Mesh.layer_counts)
  return _internal_layer_counts();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Mesh::set_layer_counts(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.layer_counts_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Mesh.layer_counts)
}
inline std::string* Mesh::mutable_layer_counts() {
  std::string* _s = _internal_mutable_layer_counts();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.Mesh.layer_counts)
  return _s;
}
inline const std::string& Mesh::_internal_layer_counts() const {
  return _impl_.layer_counts_.Get();
}
inline void Mesh::_internal_set_layer_counts(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.layer_counts_.Set(value, GetArenaForAllocation());
}
inline std::string* Mesh::_internal_mutable_layer_counts() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.layer_counts_.Mutable(GetArenaForAllocation());
}
inline std::string* Mesh::release_layer_counts() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.Mesh.layer_counts)
  if ((_impl_._has_bits_[0] & 0x00000010u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.layer_counts_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.layer_counts_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Mesh::set_allocated_layer_counts(std::string* layer_counts) {
  if (layer_counts != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.layer_counts_.SetAllocated(layer_counts, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.layer_counts_.IsDefault()) {
    _impl_.layer_counts_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.Mesh.layer_counts)
}

// repeated .geo_globetrotter_proto_rocktree.Texture texture = 6;
inline int Mesh::_internal_texture_size() const {
  return _impl_.texture_.size();
}
inline int Mesh::texture_size() const {
  return _internal_texture_size();
}
inline void Mesh::clear_texture() {
  _impl_.texture_.Clear();
}
inline ::geo_globetrotter_proto_rocktree::Texture* Mesh::mutable_texture(int index) {
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.Mesh.texture)
  return _impl_.texture_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Texture >*
Mesh::mutable_texture() {
  // @@protoc_insertion_point(field_mutable_list:geo_globetrotter_proto_rocktree.Mesh.texture)
  return &_impl_.texture_;
}
inline const ::geo_globetrotter_proto_rocktree::Texture& Mesh::_internal_texture(int index) const {
  return _impl_.texture_.Get(index);
}
inline const ::geo_globetrotter_proto_rocktree::Texture& Mesh::texture(int index) const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Mesh.texture)
  return _internal_texture(index);
}
inline ::geo_globetrotter_proto_rocktree::Texture* Mesh::_internal_add_texture() {
  return _impl_.texture_.Add();
}
inline ::geo_globetrotter_proto_rocktree::Texture* Mesh::add_texture() {
  ::geo_globetrotter_proto_rocktree::Texture* _add = _internal_add_texture();
  // @@protoc_insertion_point(field_add:geo_globetrotter_proto_rocktree.Mesh.texture)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Texture >&
Mesh::texture() const {
  // @@protoc_insertion_point(field_list:geo_globetrotter_proto_rocktree.Mesh.texture)
  return _impl_.texture_;
}

// optional bytes texture_coordinates = 7;
inline bool Mesh::has_texture_coordinates() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline void Mesh::clear_texture_coordinates() {
  _impl_.texture_coordinates_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& Mesh::texture_coordinates() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Mesh.texture_coordinates)
  return _internal_texture_coordinates();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Mesh::set_texture_coordinates(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.texture_coordinates_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Mesh.texture_coordinates)
}
inline std::string* Mesh::mutable_texture_coordinates() {
  std::string* _s = _internal_mutable_texture_coordinates();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.Mesh.texture_coordinates)
  return _s;
}
inline const std::string& Mesh::_internal_texture_coordinates() const {
  return _impl_.texture_coordinates_.Get();
}
inline void Mesh::_internal_set_texture_coordinates(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.texture_coordinates_.Set(value, GetArenaForAllocation());
}
inline std::string* Mesh::_internal_mutable_texture_coordinates() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.texture_coordinates_.Mutable(GetArenaForAllocation());
}
inline std::string* Mesh::release_texture_coordinates() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.Mesh.texture_coordinates)
  if ((_impl_._has_bits_[0] & 0x00000020u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.texture_coordinates_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.texture_coordinates_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Mesh::set_allocated_texture_coordinates(std::string* texture_coordinates) {
  if (texture_coordinates != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.texture_coordinates_.SetAllocated(texture_coordinates, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.texture_coordinates_.IsDefault()) {
    _impl_.texture_coordinates_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.Mesh.texture_coordinates)
}

// repeated float uv_offset_and_scale = 10 [packed = true];
inline int Mesh::_internal_uv_offset_and_scale_size() const {
  return _impl_.uv_offset_and_scale_.size();
}
inline int Mesh::uv_offset_and_scale_size() const {
  return _internal_uv_offset_and_scale_size();
}
inline void Mesh::clear_uv_offset_and_scale() {
  _impl_.uv_offset_and_scale_.Clear();
}
inline float Mesh::_internal_uv_offset_and_scale(int index) const {
  return _impl_.uv_offset_and_scale_.Get(index);
}
inline float Mesh::uv_offset_and_scale(int index) const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Mesh.uv_offset_and_scale)
  return _internal_uv_offset_and_scale(index);
}
inline void Mesh::set_uv_offset_and_scale(int index, float value) {
  _impl_.uv_offset_and_scale_.Set(index, value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Mesh.uv_offset_and_scale)
}
inline void Mesh::_internal_add_uv_offset_and_scale(float value) {
  _impl_.uv_offset_and_scale_.Add(value);
}
inline void Mesh::add_uv_offset_and_scale(float value) {
  _internal_add_uv_offset_and_scale(value);
  // @@protoc_insertion_point(field_add:geo_globetrotter_proto_rocktree.Mesh.uv_offset_and_scale)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
Mesh::_internal_uv_offset_and_scale() const {
  return _impl_.uv_offset_and_scale_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
Mesh::uv_offset_and_scale() const {
  // @@protoc_insertion_point(field_list:geo_globetrotter_proto_rocktree.Mesh.uv_offset_and_scale)
  return _internal_uv_offset_and_scale();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
Mesh::_internal_mutable_uv_offset_and_scale() {
  return &_impl_.uv_offset_and_scale_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
Mesh::mutable_uv_offset_and_scale() {
  // @@protoc_insertion_point(field_mutable_list:geo_globetrotter_proto_rocktree.Mesh.uv_offset_and_scale)
  return _internal_mutable_uv_offset_and_scale();
}

// optional bytes layer_and_octant_counts = 8;
inline bool Mesh::has_layer_and_octant_counts() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline void Mesh::clear_layer_and_octant_counts() {
  _impl_.layer_and_octant_counts_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& Mesh::layer_and_octant_counts() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Mesh.layer_and_octant_counts)
  return _internal_layer_and_octant_counts();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Mesh::set_layer_and_octant_counts(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.layer_and_octant_counts_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Mesh.layer_and_octant_counts)
}
inline std::string* Mesh::mutable_layer_and_octant_counts() {
  std::string* _s = _internal_mutable_layer_and_octant_counts();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.Mesh.layer_and_octant_counts)
  return _s;
}
inline const std::string& Mesh::_internal_layer_and_octant_counts() const {
  return _impl_.layer_and_octant_counts_.Get();
}
inline void Mesh::_internal_set_layer_and_octant_counts(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.layer_and_octant_counts_.Set(value, GetArenaForAllocation());
}
inline std::string* Mesh::_internal_mutable_layer_and_octant_counts() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.layer_and_octant_counts_.Mutable(GetArenaForAllocation());
}
inline std::string* Mesh::release_layer_and_octant_counts() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.Mesh.layer_and_octant_counts)
  if ((_impl_._has_bits_[0] & 0x00000040u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.layer_and_octant_counts_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.layer_and_octant_counts_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Mesh::set_allocated_layer_and_octant_counts(std::string* layer_and_octant_counts) {
  if (layer_and_octant_counts != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.layer_and_octant_counts_.SetAllocated(layer_and_octant_counts, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.layer_and_octant_counts_.IsDefault()) {
    _impl_.layer_and_octant_counts_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.Mesh.layer_and_octant_counts)
}

// optional bytes normals = 11;
inline bool Mesh::has_normals() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline void Mesh::clear_normals() {
  _impl_.normals_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const std::string& Mesh::normals() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Mesh.normals)
  return _internal_normals();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Mesh::set_normals(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000100u;
 _impl_.normals_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Mesh.normals)
}
inline std::string* Mesh::mutable_normals() {
  std::string* _s = _internal_mutable_normals();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.Mesh.normals)
  return _s;
}
inline const std::string& Mesh::_internal_normals() const {
  return _impl_.normals_.Get();
}
inline void Mesh::_internal_set_normals(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.normals_.Set(value, GetArenaForAllocation());
}
inline std::string* Mesh::_internal_mutable_normals() {
  _impl_._has_bits_[0] |= 0x00000100u;
  return _impl_.normals_.Mutable(GetArenaForAllocation());
}
inline std::string* Mesh::release_normals() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.Mesh.normals)
  if ((_impl_._has_bits_[0] & 0x00000100u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000100u;
  auto* p = _impl_.normals_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.normals_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Mesh::set_allocated_normals(std::string* normals) {
  if (normals != nullptr) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.normals_.SetAllocated(normals, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.normals_.IsDefault()) {
    _impl_.normals_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.Mesh.normals)
}

// optional bytes normals_dev = 16;
inline bool Mesh::has_normals_dev() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline void Mesh::clear_normals_dev() {
  _impl_.normals_dev_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline const std::string& Mesh::normals_dev() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Mesh.normals_dev)
  return _internal_normals_dev();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Mesh::set_normals_dev(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000400u;
 _impl_.normals_dev_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Mesh.normals_dev)
}
inline std::string* Mesh::mutable_normals_dev() {
  std::string* _s = _internal_mutable_normals_dev();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.Mesh.normals_dev)
  return _s;
}
inline const std::string& Mesh::_internal_normals_dev() const {
  return _impl_.normals_dev_.Get();
}
inline void Mesh::_internal_set_normals_dev(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.normals_dev_.Set(value, GetArenaForAllocation());
}
inline std::string* Mesh::_internal_mutable_normals_dev() {
  _impl_._has_bits_[0] |= 0x00000400u;
  return _impl_.normals_dev_.Mutable(GetArenaForAllocation());
}
inline std::string* Mesh::release_normals_dev() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.Mesh.normals_dev)
  if ((_impl_._has_bits_[0] & 0x00000400u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000400u;
  auto* p = _impl_.normals_dev_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.normals_dev_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Mesh::set_allocated_normals_dev(std::string* normals_dev) {
  if (normals_dev != nullptr) {
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  _impl_.normals_dev_.SetAllocated(normals_dev, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.normals_dev_.IsDefault()) {
    _impl_.normals_dev_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.Mesh.normals_dev)
}

// optional uint32 mesh_id = 12;
inline bool Mesh::has_mesh_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline void Mesh::clear_mesh_id() {
  _impl_.mesh_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline ::uint32_t Mesh::_internal_mesh_id() const {
  return _impl_.mesh_id_;
}
inline ::uint32_t Mesh::mesh_id() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Mesh.mesh_id)
  return _internal_mesh_id();
}
inline void Mesh::_internal_set_mesh_id(::uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.mesh_id_ = value;
}
inline void Mesh::set_mesh_id(::uint32_t value) {
  _internal_set_mesh_id(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Mesh.mesh_id)
}

// optional bytes skirt_flags = 13;
inline bool Mesh::has_skirt_flags() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline void Mesh::clear_skirt_flags() {
  _impl_.skirt_flags_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const std::string& Mesh::skirt_flags() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Mesh.skirt_flags)
  return _internal_skirt_flags();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Mesh::set_skirt_flags(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000200u;
 _impl_.skirt_flags_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Mesh.skirt_flags)
}
inline std::string* Mesh::mutable_skirt_flags() {
  std::string* _s = _internal_mutable_skirt_flags();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.Mesh.skirt_flags)
  return _s;
}
inline const std::string& Mesh::_internal_skirt_flags() const {
  return _impl_.skirt_flags_.Get();
}
inline void Mesh::_internal_set_skirt_flags(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.skirt_flags_.Set(value, GetArenaForAllocation());
}
inline std::string* Mesh::_internal_mutable_skirt_flags() {
  _impl_._has_bits_[0] |= 0x00000200u;
  return _impl_.skirt_flags_.Mutable(GetArenaForAllocation());
}
inline std::string* Mesh::release_skirt_flags() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.Mesh.skirt_flags)
  if ((_impl_._has_bits_[0] & 0x00000200u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000200u;
  auto* p = _impl_.skirt_flags_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.skirt_flags_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Mesh::set_allocated_skirt_flags(std::string* skirt_flags) {
  if (skirt_flags != nullptr) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.skirt_flags_.SetAllocated(skirt_flags, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.skirt_flags_.IsDefault()) {
    _impl_.skirt_flags_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.Mesh.skirt_flags)
}

// -------------------------------------------------------------------

// Texture

// repeated bytes data = 1;
inline int Texture::_internal_data_size() const {
  return _impl_.data_.size();
}
inline int Texture::data_size() const {
  return _internal_data_size();
}
inline void Texture::clear_data() {
  _impl_.data_.Clear();
}
inline std::string* Texture::add_data() {
  std::string* _s = _internal_add_data();
  // @@protoc_insertion_point(field_add_mutable:geo_globetrotter_proto_rocktree.Texture.data)
  return _s;
}
inline const std::string& Texture::_internal_data(int index) const {
  return _impl_.data_.Get(index);
}
inline const std::string& Texture::data(int index) const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Texture.data)
  return _internal_data(index);
}
inline std::string* Texture::mutable_data(int index) {
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.Texture.data)
  return _impl_.data_.Mutable(index);
}
inline void Texture::set_data(int index, const std::string& value) {
  _impl_.data_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Texture.data)
}
inline void Texture::set_data(int index, std::string&& value) {
  _impl_.data_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Texture.data)
}
inline void Texture::set_data(int index, const char* value) {
  GOOGLE_ABSL_DCHECK(value != nullptr);  _impl_.data_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:geo_globetrotter_proto_rocktree.Texture.data)
}
inline void Texture::set_data(int index, const void* value, ::size_t size) {
  _impl_.data_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:geo_globetrotter_proto_rocktree.Texture.data)
}
inline std::string* Texture::_internal_add_data() {
  return _impl_.data_.Add();
}
inline void Texture::add_data(const std::string& value) {
  _impl_.data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:geo_globetrotter_proto_rocktree.Texture.data)
}
inline void Texture::add_data(std::string&& value) {
  _impl_.data_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:geo_globetrotter_proto_rocktree.Texture.data)
}
inline void Texture::add_data(const char* value) {
  GOOGLE_ABSL_DCHECK(value != nullptr);  _impl_.data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:geo_globetrotter_proto_rocktree.Texture.data)
}
inline void Texture::add_data(const void* value, ::size_t size) {
  _impl_.data_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:geo_globetrotter_proto_rocktree.Texture.data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Texture::data() const {
  // @@protoc_insertion_point(field_list:geo_globetrotter_proto_rocktree.Texture.data)
  return _impl_.data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Texture::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:geo_globetrotter_proto_rocktree.Texture.data)
  return &_impl_.data_;
}

// optional .geo_globetrotter_proto_rocktree.Texture.Format format = 2;
inline bool Texture::has_format() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline void Texture::clear_format() {
  _impl_.format_ = 1;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline ::geo_globetrotter_proto_rocktree::Texture_Format Texture::_internal_format() const {
  return static_cast< ::geo_globetrotter_proto_rocktree::Texture_Format >(_impl_.format_);
}
inline ::geo_globetrotter_proto_rocktree::Texture_Format Texture::format() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Texture.format)
  return _internal_format();
}
inline void Texture::_internal_set_format(::geo_globetrotter_proto_rocktree::Texture_Format value) {
  assert(::geo_globetrotter_proto_rocktree::Texture_Format_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.format_ = value;
}
inline void Texture::set_format(::geo_globetrotter_proto_rocktree::Texture_Format value) {
  _internal_set_format(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Texture.format)
}

// optional uint32 width = 3 [default = 256];
inline bool Texture::has_width() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline void Texture::clear_width() {
  _impl_.width_ = 256u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline ::uint32_t Texture::_internal_width() const {
  return _impl_.width_;
}
inline ::uint32_t Texture::width() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Texture.width)
  return _internal_width();
}
inline void Texture::_internal_set_width(::uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.width_ = value;
}
inline void Texture::set_width(::uint32_t value) {
  _internal_set_width(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Texture.width)
}

// optional uint32 height = 4 [default = 256];
inline bool Texture::has_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline void Texture::clear_height() {
  _impl_.height_ = 256u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::uint32_t Texture::_internal_height() const {
  return _impl_.height_;
}
inline ::uint32_t Texture::height() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Texture.height)
  return _internal_height();
}
inline void Texture::_internal_set_height(::uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.height_ = value;
}
inline void Texture::set_height(::uint32_t value) {
  _internal_set_height(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Texture.height)
}

// optional .geo_globetrotter_proto_rocktree.Texture.ViewDirection view_direction = 5;
inline bool Texture::has_view_direction() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline void Texture::clear_view_direction() {
  _impl_.view_direction_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::geo_globetrotter_proto_rocktree::Texture_ViewDirection Texture::_internal_view_direction() const {
  return static_cast< ::geo_globetrotter_proto_rocktree::Texture_ViewDirection >(_impl_.view_direction_);
}
inline ::geo_globetrotter_proto_rocktree::Texture_ViewDirection Texture::view_direction() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Texture.view_direction)
  return _internal_view_direction();
}
inline void Texture::_internal_set_view_direction(::geo_globetrotter_proto_rocktree::Texture_ViewDirection value) {
  assert(::geo_globetrotter_proto_rocktree::Texture_ViewDirection_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.view_direction_ = value;
}
inline void Texture::set_view_direction(::geo_globetrotter_proto_rocktree::Texture_ViewDirection value) {
  _internal_set_view_direction(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Texture.view_direction)
}

// optional uint32 mesh_id = 6;
inline bool Texture::has_mesh_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline void Texture::clear_mesh_id() {
  _impl_.mesh_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::uint32_t Texture::_internal_mesh_id() const {
  return _impl_.mesh_id_;
}
inline ::uint32_t Texture::mesh_id() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Texture.mesh_id)
  return _internal_mesh_id();
}
inline void Texture::_internal_set_mesh_id(::uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.mesh_id_ = value;
}
inline void Texture::set_mesh_id(::uint32_t value) {
  _internal_set_mesh_id(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Texture.mesh_id)
}

// -------------------------------------------------------------------

// TextureData

// optional .geo_globetrotter_proto_rocktree.NodeKey node_key = 1;
inline bool TextureData::has_node_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.node_key_ != nullptr);
  return value;
}
inline void TextureData::clear_node_key() {
  if (_impl_.node_key_ != nullptr) _impl_.node_key_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::geo_globetrotter_proto_rocktree::NodeKey& TextureData::_internal_node_key() const {
  const ::geo_globetrotter_proto_rocktree::NodeKey* p = _impl_.node_key_;
  return p != nullptr ? *p : reinterpret_cast<const ::geo_globetrotter_proto_rocktree::NodeKey&>(
      ::geo_globetrotter_proto_rocktree::_NodeKey_default_instance_);
}
inline const ::geo_globetrotter_proto_rocktree::NodeKey& TextureData::node_key() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.TextureData.node_key)
  return _internal_node_key();
}
inline void TextureData::unsafe_arena_set_allocated_node_key(
    ::geo_globetrotter_proto_rocktree::NodeKey* node_key) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.node_key_);
  }
  _impl_.node_key_ = node_key;
  if (node_key) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:geo_globetrotter_proto_rocktree.TextureData.node_key)
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* TextureData::release_node_key() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::geo_globetrotter_proto_rocktree::NodeKey* temp = _impl_.node_key_;
  _impl_.node_key_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* TextureData::unsafe_arena_release_node_key() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.TextureData.node_key)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::geo_globetrotter_proto_rocktree::NodeKey* temp = _impl_.node_key_;
  _impl_.node_key_ = nullptr;
  return temp;
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* TextureData::_internal_mutable_node_key() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.node_key_ == nullptr) {
    auto* p = CreateMaybeMessage<::geo_globetrotter_proto_rocktree::NodeKey>(GetArenaForAllocation());
    _impl_.node_key_ = p;
  }
  return _impl_.node_key_;
}
inline ::geo_globetrotter_proto_rocktree::NodeKey* TextureData::mutable_node_key() {
  ::geo_globetrotter_proto_rocktree::NodeKey* _msg = _internal_mutable_node_key();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.TextureData.node_key)
  return _msg;
}
inline void TextureData::set_allocated_node_key(::geo_globetrotter_proto_rocktree::NodeKey* node_key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.node_key_;
  }
  if (node_key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(node_key);
    if (message_arena != submessage_arena) {
      node_key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, node_key, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.node_key_ = node_key;
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.TextureData.node_key)
}

// repeated .geo_globetrotter_proto_rocktree.Texture textures = 2;
inline int TextureData::_internal_textures_size() const {
  return _impl_.textures_.size();
}
inline int TextureData::textures_size() const {
  return _internal_textures_size();
}
inline void TextureData::clear_textures() {
  _impl_.textures_.Clear();
}
inline ::geo_globetrotter_proto_rocktree::Texture* TextureData::mutable_textures(int index) {
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.TextureData.textures)
  return _impl_.textures_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Texture >*
TextureData::mutable_textures() {
  // @@protoc_insertion_point(field_mutable_list:geo_globetrotter_proto_rocktree.TextureData.textures)
  return &_impl_.textures_;
}
inline const ::geo_globetrotter_proto_rocktree::Texture& TextureData::_internal_textures(int index) const {
  return _impl_.textures_.Get(index);
}
inline const ::geo_globetrotter_proto_rocktree::Texture& TextureData::textures(int index) const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.TextureData.textures)
  return _internal_textures(index);
}
inline ::geo_globetrotter_proto_rocktree::Texture* TextureData::_internal_add_textures() {
  return _impl_.textures_.Add();
}
inline ::geo_globetrotter_proto_rocktree::Texture* TextureData::add_textures() {
  ::geo_globetrotter_proto_rocktree::Texture* _add = _internal_add_textures();
  // @@protoc_insertion_point(field_add:geo_globetrotter_proto_rocktree.TextureData.textures)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Texture >&
TextureData::textures() const {
  // @@protoc_insertion_point(field_list:geo_globetrotter_proto_rocktree.TextureData.textures)
  return _impl_.textures_;
}

// -------------------------------------------------------------------

// Copyrights

// repeated .geo_globetrotter_proto_rocktree.Copyright copyrights = 1;
inline int Copyrights::_internal_copyrights_size() const {
  return _impl_.copyrights_.size();
}
inline int Copyrights::copyrights_size() const {
  return _internal_copyrights_size();
}
inline void Copyrights::clear_copyrights() {
  _impl_.copyrights_.Clear();
}
inline ::geo_globetrotter_proto_rocktree::Copyright* Copyrights::mutable_copyrights(int index) {
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.Copyrights.copyrights)
  return _impl_.copyrights_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Copyright >*
Copyrights::mutable_copyrights() {
  // @@protoc_insertion_point(field_mutable_list:geo_globetrotter_proto_rocktree.Copyrights.copyrights)
  return &_impl_.copyrights_;
}
inline const ::geo_globetrotter_proto_rocktree::Copyright& Copyrights::_internal_copyrights(int index) const {
  return _impl_.copyrights_.Get(index);
}
inline const ::geo_globetrotter_proto_rocktree::Copyright& Copyrights::copyrights(int index) const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Copyrights.copyrights)
  return _internal_copyrights(index);
}
inline ::geo_globetrotter_proto_rocktree::Copyright* Copyrights::_internal_add_copyrights() {
  return _impl_.copyrights_.Add();
}
inline ::geo_globetrotter_proto_rocktree::Copyright* Copyrights::add_copyrights() {
  ::geo_globetrotter_proto_rocktree::Copyright* _add = _internal_add_copyrights();
  // @@protoc_insertion_point(field_add:geo_globetrotter_proto_rocktree.Copyrights.copyrights)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::geo_globetrotter_proto_rocktree::Copyright >&
Copyrights::copyrights() const {
  // @@protoc_insertion_point(field_list:geo_globetrotter_proto_rocktree.Copyrights.copyrights)
  return _impl_.copyrights_;
}

// -------------------------------------------------------------------

// Copyright

// optional uint32 id = 1;
inline bool Copyright::has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline void Copyright::clear_id() {
  _impl_.id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::uint32_t Copyright::_internal_id() const {
  return _impl_.id_;
}
inline ::uint32_t Copyright::id() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Copyright.id)
  return _internal_id();
}
inline void Copyright::_internal_set_id(::uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.id_ = value;
}
inline void Copyright::set_id(::uint32_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Copyright.id)
}

// optional string text = 2;
inline bool Copyright::has_text() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline void Copyright::clear_text() {
  _impl_.text_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Copyright::text() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Copyright.text)
  return _internal_text();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Copyright::set_text(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Copyright.text)
}
inline std::string* Copyright::mutable_text() {
  std::string* _s = _internal_mutable_text();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.Copyright.text)
  return _s;
}
inline const std::string& Copyright::_internal_text() const {
  return _impl_.text_.Get();
}
inline void Copyright::_internal_set_text(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.text_.Set(value, GetArenaForAllocation());
}
inline std::string* Copyright::_internal_mutable_text() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.text_.Mutable(GetArenaForAllocation());
}
inline std::string* Copyright::release_text() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.Copyright.text)
  if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.text_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.text_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Copyright::set_allocated_text(std::string* text) {
  if (text != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.text_.SetAllocated(text, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.text_.IsDefault()) {
    _impl_.text_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.Copyright.text)
}

// optional string text_clean = 3;
inline bool Copyright::has_text_clean() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline void Copyright::clear_text_clean() {
  _impl_.text_clean_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Copyright::text_clean() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.Copyright.text_clean)
  return _internal_text_clean();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Copyright::set_text_clean(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.text_clean_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.Copyright.text_clean)
}
inline std::string* Copyright::mutable_text_clean() {
  std::string* _s = _internal_mutable_text_clean();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.Copyright.text_clean)
  return _s;
}
inline const std::string& Copyright::_internal_text_clean() const {
  return _impl_.text_clean_.Get();
}
inline void Copyright::_internal_set_text_clean(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.text_clean_.Set(value, GetArenaForAllocation());
}
inline std::string* Copyright::_internal_mutable_text_clean() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.text_clean_.Mutable(GetArenaForAllocation());
}
inline std::string* Copyright::release_text_clean() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.Copyright.text_clean)
  if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.text_clean_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.text_clean_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Copyright::set_allocated_text_clean(std::string* text_clean) {
  if (text_clean != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.text_clean_.SetAllocated(text_clean, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.text_clean_.IsDefault()) {
    _impl_.text_clean_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.Copyright.text_clean)
}

// -------------------------------------------------------------------

// PlanetoidMetadata

// optional .geo_globetrotter_proto_rocktree.NodeMetadata root_node_metadata = 1;
inline bool PlanetoidMetadata::has_root_node_metadata() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.root_node_metadata_ != nullptr);
  return value;
}
inline void PlanetoidMetadata::clear_root_node_metadata() {
  if (_impl_.root_node_metadata_ != nullptr) _impl_.root_node_metadata_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::geo_globetrotter_proto_rocktree::NodeMetadata& PlanetoidMetadata::_internal_root_node_metadata() const {
  const ::geo_globetrotter_proto_rocktree::NodeMetadata* p = _impl_.root_node_metadata_;
  return p != nullptr ? *p : reinterpret_cast<const ::geo_globetrotter_proto_rocktree::NodeMetadata&>(
      ::geo_globetrotter_proto_rocktree::_NodeMetadata_default_instance_);
}
inline const ::geo_globetrotter_proto_rocktree::NodeMetadata& PlanetoidMetadata::root_node_metadata() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.PlanetoidMetadata.root_node_metadata)
  return _internal_root_node_metadata();
}
inline void PlanetoidMetadata::unsafe_arena_set_allocated_root_node_metadata(
    ::geo_globetrotter_proto_rocktree::NodeMetadata* root_node_metadata) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.root_node_metadata_);
  }
  _impl_.root_node_metadata_ = root_node_metadata;
  if (root_node_metadata) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:geo_globetrotter_proto_rocktree.PlanetoidMetadata.root_node_metadata)
}
inline ::geo_globetrotter_proto_rocktree::NodeMetadata* PlanetoidMetadata::release_root_node_metadata() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::geo_globetrotter_proto_rocktree::NodeMetadata* temp = _impl_.root_node_metadata_;
  _impl_.root_node_metadata_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::geo_globetrotter_proto_rocktree::NodeMetadata* PlanetoidMetadata::unsafe_arena_release_root_node_metadata() {
  // @@protoc_insertion_point(field_release:geo_globetrotter_proto_rocktree.PlanetoidMetadata.root_node_metadata)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::geo_globetrotter_proto_rocktree::NodeMetadata* temp = _impl_.root_node_metadata_;
  _impl_.root_node_metadata_ = nullptr;
  return temp;
}
inline ::geo_globetrotter_proto_rocktree::NodeMetadata* PlanetoidMetadata::_internal_mutable_root_node_metadata() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.root_node_metadata_ == nullptr) {
    auto* p = CreateMaybeMessage<::geo_globetrotter_proto_rocktree::NodeMetadata>(GetArenaForAllocation());
    _impl_.root_node_metadata_ = p;
  }
  return _impl_.root_node_metadata_;
}
inline ::geo_globetrotter_proto_rocktree::NodeMetadata* PlanetoidMetadata::mutable_root_node_metadata() {
  ::geo_globetrotter_proto_rocktree::NodeMetadata* _msg = _internal_mutable_root_node_metadata();
  // @@protoc_insertion_point(field_mutable:geo_globetrotter_proto_rocktree.PlanetoidMetadata.root_node_metadata)
  return _msg;
}
inline void PlanetoidMetadata::set_allocated_root_node_metadata(::geo_globetrotter_proto_rocktree::NodeMetadata* root_node_metadata) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.root_node_metadata_;
  }
  if (root_node_metadata) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(root_node_metadata);
    if (message_arena != submessage_arena) {
      root_node_metadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, root_node_metadata, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.root_node_metadata_ = root_node_metadata;
  // @@protoc_insertion_point(field_set_allocated:geo_globetrotter_proto_rocktree.PlanetoidMetadata.root_node_metadata)
}

// optional float radius = 2;
inline bool PlanetoidMetadata::has_radius() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline void PlanetoidMetadata::clear_radius() {
  _impl_.radius_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float PlanetoidMetadata::_internal_radius() const {
  return _impl_.radius_;
}
inline float PlanetoidMetadata::radius() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.PlanetoidMetadata.radius)
  return _internal_radius();
}
inline void PlanetoidMetadata::_internal_set_radius(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.radius_ = value;
}
inline void PlanetoidMetadata::set_radius(float value) {
  _internal_set_radius(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.PlanetoidMetadata.radius)
}

// optional float min_terrain_altitude = 3;
inline bool PlanetoidMetadata::has_min_terrain_altitude() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline void PlanetoidMetadata::clear_min_terrain_altitude() {
  _impl_.min_terrain_altitude_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float PlanetoidMetadata::_internal_min_terrain_altitude() const {
  return _impl_.min_terrain_altitude_;
}
inline float PlanetoidMetadata::min_terrain_altitude() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.PlanetoidMetadata.min_terrain_altitude)
  return _internal_min_terrain_altitude();
}
inline void PlanetoidMetadata::_internal_set_min_terrain_altitude(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.min_terrain_altitude_ = value;
}
inline void PlanetoidMetadata::set_min_terrain_altitude(float value) {
  _internal_set_min_terrain_altitude(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.PlanetoidMetadata.min_terrain_altitude)
}

// optional float max_terrain_altitude = 4;
inline bool PlanetoidMetadata::has_max_terrain_altitude() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline void PlanetoidMetadata::clear_max_terrain_altitude() {
  _impl_.max_terrain_altitude_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float PlanetoidMetadata::_internal_max_terrain_altitude() const {
  return _impl_.max_terrain_altitude_;
}
inline float PlanetoidMetadata::max_terrain_altitude() const {
  // @@protoc_insertion_point(field_get:geo_globetrotter_proto_rocktree.PlanetoidMetadata.max_terrain_altitude)
  return _internal_max_terrain_altitude();
}
inline void PlanetoidMetadata::_internal_set_max_terrain_altitude(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.max_terrain_altitude_ = value;
}
inline void PlanetoidMetadata::set_max_terrain_altitude(float value) {
  _internal_set_max_terrain_altitude(value);
  // @@protoc_insertion_point(field_set:geo_globetrotter_proto_rocktree.PlanetoidMetadata.max_terrain_altitude)
}

#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif  // __GNUC__

// @@protoc_insertion_point(namespace_scope)
}  // namespace geo_globetrotter_proto_rocktree


PROTOBUF_NAMESPACE_OPEN

template <>
struct is_proto_enum<::geo_globetrotter_proto_rocktree::NodeMetadata_Flags> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::geo_globetrotter_proto_rocktree::NodeMetadata_Flags>() {
  return ::geo_globetrotter_proto_rocktree::NodeMetadata_Flags_descriptor();
}
template <>
struct is_proto_enum<::geo_globetrotter_proto_rocktree::Mesh_Layer> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::geo_globetrotter_proto_rocktree::Mesh_Layer>() {
  return ::geo_globetrotter_proto_rocktree::Mesh_Layer_descriptor();
}
template <>
struct is_proto_enum<::geo_globetrotter_proto_rocktree::Mesh_LayerMask> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::geo_globetrotter_proto_rocktree::Mesh_LayerMask>() {
  return ::geo_globetrotter_proto_rocktree::Mesh_LayerMask_descriptor();
}
template <>
struct is_proto_enum<::geo_globetrotter_proto_rocktree::Texture_Format> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::geo_globetrotter_proto_rocktree::Texture_Format>() {
  return ::geo_globetrotter_proto_rocktree::Texture_Format_descriptor();
}
template <>
struct is_proto_enum<::geo_globetrotter_proto_rocktree::Texture_ViewDirection> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::geo_globetrotter_proto_rocktree::Texture_ViewDirection>() {
  return ::geo_globetrotter_proto_rocktree::Texture_ViewDirection_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"

#endif  // GOOGLE_PROTOBUF_INCLUDED_rocktree_2eproto_2epb_2eh
