text: // Generated by the protocol buffer compiler.  DO NOT EDIT!
  // source: meshgeom.proto
  
  #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
  #include "meshgeom.pb.h"
  
  #include <algorithm>
  
  #include <google/protobuf/stubs/common.h>
  #include <google/protobuf/stubs/once.h>
  #include <google/protobuf/io/coded_stream.h>
  #include <google/protobuf/wire_format_lite_inl.h>
  #include <google/protobuf/descriptor.h>
  #include <google/protobuf/generated_message_reflection.h>
  #include <google/protobuf/reflection_ops.h>
  #include <google/protobuf/wire_format.h>
  // @@protoc_insertion_point(includes)
  
  namespace Indriya {
  namespace Core {
  namespace Msgs {
  
  namespace {
  
  const ::google::protobuf::Descriptor* MeshGeom_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    MeshGeom_reflection_ = NULL;
  
  }  // namespace
  
  
  void protobuf_AssignDesc_meshgeom_2eproto() {
    protobuf_AddDesc_meshgeom_2eproto();
    const ::google::protobuf::FileDescriptor* file =
      ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
        "meshgeom.proto");
    GOOGLE_CHECK(file != NULL);
    MeshGeom_descriptor_ = file->message_type(0);
    static const int MeshGeom_offsets_[4] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MeshGeom, filename_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MeshGeom, scale_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MeshGeom, submesh_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MeshGeom, center_submesh_),
    };
    MeshGeom_reflection_ =
      ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
        MeshGeom_descriptor_,
        MeshGeom::default_instance_,
        MeshGeom_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MeshGeom, _has_bits_[0]),
        -1,
        -1,
        sizeof(MeshGeom),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MeshGeom, _internal_metadata_),
        -1);
  }
  
  namespace {
  
  GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
  inline void protobuf_AssignDescriptorsOnce() {
    ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
                   &protobuf_AssignDesc_meshgeom_2eproto);
  }
  
  void protobuf_RegisterTypes(const ::std::string&) {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
        MeshGeom_descriptor_, &MeshGeom::default_instance());
  }
  
  }  // namespace
  
  void protobuf_ShutdownFile_meshgeom_2eproto() {
    delete MeshGeom::default_instance_;
    delete MeshGeom_reflection_;
  }
  
  void protobuf_AddDesc_meshgeom_2eproto() {
    static bool already_here = false;
    if (already_here) return;
    already_here = true;
    GOOGLE_PROTOBUF_VERIFY_VERSION;
  
    ::Indriya::Core::Msgs::protobuf_AddDesc_vector3d_2eproto();
    ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
      "\n\016meshgeom.proto\022\021Indriya.Core.Msgs\032\016vec"
      "tor3d.proto\"q\n\010MeshGeom\022\020\n\010filename\030\001 \002("
      "\t\022*\n\005scale\030\002 \001(\0132\033.Indriya.Core.Msgs.Vec"
      "tor3d\022\017\n\007submesh\030\003 \001(\t\022\026\n\016center_submesh"
      "\030\004 \001(\010", 166);
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
      "meshgeom.proto", &protobuf_RegisterTypes);
    MeshGeom::default_instance_ = new MeshGeom();
    MeshGeom::default_instance_->InitAsDefaultInstance();
    ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_meshgeom_2eproto);
  }
  
  // Force AddDescriptors() to be called at static initialization time.
  struct StaticDescriptorInitializer_meshgeom_2eproto {
    StaticDescriptorInitializer_meshgeom_2eproto() {
      protobuf_AddDesc_meshgeom_2eproto();
    }
  } static_descriptor_initializer_meshgeom_2eproto_;
  
  namespace {
  
  static void MergeFromFail(int line) GOOGLE_ATTRIBUTE_COLD;
  static void MergeFromFail(int line) {
    GOOGLE_CHECK(false) << __FILE__ << ":" << line;
  }
  
  }  // namespace
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int MeshGeom::kFilenameFieldNumber;
  const int MeshGeom::kScaleFieldNumber;
  const int MeshGeom::kSubmeshFieldNumber;
  const int MeshGeom::kCenterSubmeshFieldNumber;
  #endif  // !_MSC_VER
  
  MeshGeom::MeshGeom()
    : ::google::protobuf::Message() , _internal_metadata_(NULL)  {
    SharedCtor();
    // @@protoc_insertion_point(constructor:Indriya.Core.Msgs.MeshGeom)
  }
  
  void MeshGeom::InitAsDefaultInstance() {
    scale_ = const_cast< ::Indriya::Core::Msgs::Vector3d*>(&::Indriya::Core::Msgs::Vector3d::default_instance());
  }
  
  MeshGeom::MeshGeom(const MeshGeom& from)
    : ::google::protobuf::Message(),
      _internal_metadata_(NULL) {
    SharedCtor();
    MergeFrom(from);
    // @@protoc_insertion_point(copy_constructor:Indriya.Core.Msgs.MeshGeom)
  }
  
  void MeshGeom::SharedCtor() {
    ::google::protobuf::internal::GetEmptyString();
    _cached_size_ = 0;
    filename_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    scale_ = NULL;
    submesh_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    center_submesh_ = false;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  MeshGeom::~MeshGeom() {
    // @@protoc_insertion_point(destructor:Indriya.Core.Msgs.MeshGeom)
    SharedDtor();
  }
  
  void MeshGeom::SharedDtor() {
    filename_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    submesh_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    if (this != default_instance_) {
      delete scale_;
    }
  }
  
  void MeshGeom::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* MeshGeom::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return MeshGeom_descriptor_;
  }
  
  const MeshGeom& MeshGeom::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_meshgeom_2eproto();
    return *default_instance_;
  }
  
  MeshGeom* MeshGeom::default_instance_ = NULL;
  
  MeshGeom* MeshGeom::New(::google::protobuf::Arena* arena) const {
    MeshGeom* n = new MeshGeom;
    if (arena != NULL) {
      arena->Own(n);
    }
    return n;
  }
  
  void MeshGeom::Clear() {
    if (_has_bits_[0 / 32] & 15) {
      if (has_filename()) {
        filename_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
      }
      if (has_scale()) {
        if (scale_ != NULL) scale_->::Indriya::Core::Msgs::Vector3d::Clear();
      }
      if (has_submesh()) {
        submesh_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
      }
      center_submesh_ = false;
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    if (_internal_metadata_.have_unknown_fields()) {
      mutable_unknown_fields()->Clear();
    }
  }
  
  bool MeshGeom::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
    ::google::protobuf::uint32 tag;
    // @@protoc_insertion_point(parse_start:Indriya.Core.Msgs.MeshGeom)
    for (;;) {
      ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
      tag = p.first;
      if (!p.second) goto handle_unusual;
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // required string filename = 1;
        case 1: {
          if (tag == 10) {
            DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                  input, this->mutable_filename()));
            ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
              this->filename().data(), this->filename().length(),
              ::google::protobuf::internal::WireFormat::PARSE,
              "Indriya.Core.Msgs.MeshGeom.filename");
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(18)) goto parse_scale;
          break;
        }
  
        // optional .Indriya.Core.Msgs.Vector3d scale = 2;
        case 2: {
          if (tag == 18) {
           parse_scale:
            DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                 input, mutable_scale()));
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(26)) goto parse_submesh;
          break;
        }
  
        // optional string submesh = 3;
        case 3: {
          if (tag == 26) {
           parse_submesh:
            DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                  input, this->mutable_submesh()));
            ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
              this->submesh().data(), this->submesh().length(),
              ::google::protobuf::internal::WireFormat::PARSE,
              "Indriya.Core.Msgs.MeshGeom.submesh");
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(32)) goto parse_center_submesh;
          break;
        }
  
        // optional bool center_submesh = 4;
        case 4: {
          if (tag == 32) {
           parse_center_submesh:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                   input, &center_submesh_)));
            set_has_center_submesh();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectAtEnd()) goto success;
          break;
        }
  
        default: {
        handle_unusual:
          if (tag == 0 ||
              ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            goto success;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
  success:
    // @@protoc_insertion_point(parse_success:Indriya.Core.Msgs.MeshGeom)
    return true;
  failure:
    // @@protoc_insertion_point(parse_failure:Indriya.Core.Msgs.MeshGeom)
    return false;
  #undef DO_
  }
  
  void MeshGeom::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // @@protoc_insertion_point(serialize_start:Indriya.Core.Msgs.MeshGeom)
    // required string filename = 1;
    if (has_filename()) {
      ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
        this->filename().data(), this->filename().length(),
        ::google::protobuf::internal::WireFormat::SERIALIZE,
        "Indriya.Core.Msgs.MeshGeom.filename");
      ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
        1, this->filename(), output);
    }
  
    // optional .Indriya.Core.Msgs.Vector3d scale = 2;
    if (has_scale()) {
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        2, *this->scale_, output);
    }
  
    // optional string submesh = 3;
    if (has_submesh()) {
      ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
        this->submesh().data(), this->submesh().length(),
        ::google::protobuf::internal::WireFormat::SERIALIZE,
        "Indriya.Core.Msgs.MeshGeom.submesh");
      ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
        3, this->submesh(), output);
    }
  
    // optional bool center_submesh = 4;
    if (has_center_submesh()) {
      ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->center_submesh(), output);
    }
  
    if (_internal_metadata_.have_unknown_fields()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
    // @@protoc_insertion_point(serialize_end:Indriya.Core.Msgs.MeshGeom)
  }
  
  ::google::protobuf::uint8* MeshGeom::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // @@protoc_insertion_point(serialize_to_array_start:Indriya.Core.Msgs.MeshGeom)
    // required string filename = 1;
    if (has_filename()) {
      ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
        this->filename().data(), this->filename().length(),
        ::google::protobuf::internal::WireFormat::SERIALIZE,
        "Indriya.Core.Msgs.MeshGeom.filename");
      target =
        ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
          1, this->filename(), target);
    }
  
    // optional .Indriya.Core.Msgs.Vector3d scale = 2;
    if (has_scale()) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteMessageNoVirtualToArray(
          2, *this->scale_, target);
    }
  
    // optional string submesh = 3;
    if (has_submesh()) {
      ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
        this->submesh().data(), this->submesh().length(),
        ::google::protobuf::internal::WireFormat::SERIALIZE,
        "Indriya.Core.Msgs.MeshGeom.submesh");
      target =
        ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
          3, this->submesh(), target);
    }
  
    // optional bool center_submesh = 4;
    if (has_center_submesh()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->center_submesh(), target);
    }
  
    if (_internal_metadata_.have_unknown_fields()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    // @@protoc_insertion_point(serialize_to_array_end:Indriya.Core.Msgs.MeshGeom)
    return target;
  }
  
  int MeshGeom::ByteSize() const {
    int total_size = 0;
  
    // required string filename = 1;
    if (has_filename()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->filename());
    }
    if (_has_bits_[1 / 32] & 14) {
      // optional .Indriya.Core.Msgs.Vector3d scale = 2;
      if (has_scale()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
            *this->scale_);
      }
  
      // optional string submesh = 3;
      if (has_submesh()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::StringSize(
            this->submesh());
      }
  
      // optional bool center_submesh = 4;
      if (has_center_submesh()) {
        total_size += 1 + 1;
      }
  
    }
    if (_internal_metadata_.have_unknown_fields()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void MeshGeom::MergeFrom(const ::google::protobuf::Message& from) {
    if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
    const MeshGeom* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const MeshGeom*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void MeshGeom::MergeFrom(const MeshGeom& from) {
    if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from.has_filename()) {
        set_has_filename();
        filename_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.filename_);
      }
      if (from.has_scale()) {
        mutable_scale()->::Indriya::Core::Msgs::Vector3d::MergeFrom(from.scale());
      }
      if (from.has_submesh()) {
        set_has_submesh();
        submesh_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.submesh_);
      }
      if (from.has_center_submesh()) {
        set_center_submesh(from.center_submesh());
      }
    }
    if (from._internal_metadata_.have_unknown_fields()) {
      mutable_unknown_fields()->MergeFrom(from.unknown_fields());
    }
  }
  
  void MeshGeom::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void MeshGeom::CopyFrom(const MeshGeom& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool MeshGeom::IsInitialized() const {
    if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  
    if (has_scale()) {
      if (!this->scale_->IsInitialized()) return false;
    }
    return true;
  }
  
  void MeshGeom::Swap(MeshGeom* other) {
    if (other == this) return;
    InternalSwap(other);
  }
  void MeshGeom::InternalSwap(MeshGeom* other) {
    filename_.Swap(&other->filename_);
    std::swap(scale_, other->scale_);
    submesh_.Swap(&other->submesh_);
    std::swap(center_submesh_, other->center_submesh_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _internal_metadata_.Swap(&other->_internal_metadata_);
    std::swap(_cached_size_, other->_cached_size_);
  }
  
  ::google::protobuf::Metadata MeshGeom::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = MeshGeom_descriptor_;
    metadata.reflection = MeshGeom_reflection_;
    return metadata;
  }
  
  #if PROTOBUF_INLINE_NOT_IN_HEADERS
  // MeshGeom
  
  // required string filename = 1;
   bool MeshGeom::has_filename() const {
    return (_has_bits_[0] & 0x00000001u) != 0;
  }
   void MeshGeom::set_has_filename() {
    _has_bits_[0] |= 0x00000001u;
  }
   void MeshGeom::clear_has_filename() {
    _has_bits_[0] &= ~0x00000001u;
  }
   void MeshGeom::clear_filename() {
    filename_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_filename();
  }
   const ::std::string& MeshGeom::filename() const {
    // @@protoc_insertion_point(field_get:Indriya.Core.Msgs.MeshGeom.filename)
    return filename_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
   void MeshGeom::set_filename(const ::std::string& value) {
    set_has_filename();
    filename_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
    // @@protoc_insertion_point(field_set:Indriya.Core.Msgs.MeshGeom.filename)
  }
   void MeshGeom::set_filename(const char* value) {
    set_has_filename();
    filename_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
    // @@protoc_insertion_point(field_set_char:Indriya.Core.Msgs.MeshGeom.filename)
  }
   void MeshGeom::set_filename(const char* value, size_t size) {
    set_has_filename();
    filename_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        ::std::string(reinterpret_cast<const char*>(value), size));
    // @@protoc_insertion_point(field_set_pointer:Indriya.Core.Msgs.MeshGeom.filename)
  }
   ::std::string* MeshGeom::mutable_filename() {
    set_has_filename();
    // @@protoc_insertion_point(field_mutable:Indriya.Core.Msgs.MeshGeom.filename)
    return filename_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
   ::std::string* MeshGeom::release_filename() {
    clear_has_filename();
    return filename_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
   void MeshGeom::set_allocated_filename(::std::string* filename) {
    if (filename != NULL) {
      set_has_filename();
    } else {
      clear_has_filename();
    }
    filename_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), filename);
    // @@protoc_insertion_point(field_set_allocated:Indriya.Core.Msgs.MeshGeom.filename)
  }
  
  // optional .Indriya.Core.Msgs.Vector3d scale = 2;
   bool MeshGeom::has_scale() const {
    return (_has_bits_[0] & 0x00000002u) != 0;
  }
   void MeshGeom::set_has_scale() {
    _has_bits_[0] |= 0x00000002u;
  }
   void MeshGeom::clear_has_scale() {
    _has_bits_[0] &= ~0x00000002u;
  }
   void MeshGeom::clear_scale() {
    if (scale_ != NULL) scale_->::Indriya::Core::Msgs::Vector3d::Clear();
    clear_has_scale();
  }
   const ::Indriya::Core::Msgs::Vector3d& MeshGeom::scale() const {
    // @@protoc_insertion_point(field_get:Indriya.Core.Msgs.MeshGeom.scale)
    return scale_ != NULL ? *scale_ : *default_instance_->scale_;
  }
   ::Indriya::Core::Msgs::Vector3d* MeshGeom::mutable_scale() {
    set_has_scale();
    if (scale_ == NULL) {
      scale_ = new ::Indriya::Core::Msgs::Vector3d;
    }
    // @@protoc_insertion_point(field_mutable:Indriya.Core.Msgs.MeshGeom.scale)
    return scale_;
  }
   ::Indriya::Core::Msgs::Vector3d* MeshGeom::release_scale() {
    clear_has_scale();
    ::Indriya::Core::Msgs::Vector3d* temp = scale_;
    scale_ = NULL;
    return temp;
  }
   void MeshGeom::set_allocated_scale(::Indriya::Core::Msgs::Vector3d* scale) {
    delete scale_;
    scale_ = scale;
    if (scale) {
      set_has_scale();
    } else {
      clear_has_scale();
    }
    // @@protoc_insertion_point(field_set_allocated:Indriya.Core.Msgs.MeshGeom.scale)
  }
  
  // optional string submesh = 3;
   bool MeshGeom::has_submesh() const {
    return (_has_bits_[0] & 0x00000004u) != 0;
  }
   void MeshGeom::set_has_submesh() {
    _has_bits_[0] |= 0x00000004u;
  }
   void MeshGeom::clear_has_submesh() {
    _has_bits_[0] &= ~0x00000004u;
  }
   void MeshGeom::clear_submesh() {
    submesh_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_submesh();
  }
   const ::std::string& MeshGeom::submesh() const {
    // @@protoc_insertion_point(field_get:Indriya.Core.Msgs.MeshGeom.submesh)
    return submesh_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
   void MeshGeom::set_submesh(const ::std::string& value) {
    set_has_submesh();
    submesh_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
    // @@protoc_insertion_point(field_set:Indriya.Core.Msgs.MeshGeom.submesh)
  }
   void MeshGeom::set_submesh(const char* value) {
    set_has_submesh();
    submesh_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
    // @@protoc_insertion_point(field_set_char:Indriya.Core.Msgs.MeshGeom.submesh)
  }
   void MeshGeom::set_submesh(const char* value, size_t size) {
    set_has_submesh();
    submesh_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        ::std::string(reinterpret_cast<const char*>(value), size));
    // @@protoc_insertion_point(field_set_pointer:Indriya.Core.Msgs.MeshGeom.submesh)
  }
   ::std::string* MeshGeom::mutable_submesh() {
    set_has_submesh();
    // @@protoc_insertion_point(field_mutable:Indriya.Core.Msgs.MeshGeom.submesh)
    return submesh_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
   ::std::string* MeshGeom::release_submesh() {
    clear_has_submesh();
    return submesh_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
   void MeshGeom::set_allocated_submesh(::std::string* submesh) {
    if (submesh != NULL) {
      set_has_submesh();
    } else {
      clear_has_submesh();
    }
    submesh_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), submesh);
    // @@protoc_insertion_point(field_set_allocated:Indriya.Core.Msgs.MeshGeom.submesh)
  }
  
  // optional bool center_submesh = 4;
   bool MeshGeom::has_center_submesh() const {
    return (_has_bits_[0] & 0x00000008u) != 0;
  }
   void MeshGeom::set_has_center_submesh() {
    _has_bits_[0] |= 0x00000008u;
  }
   void MeshGeom::clear_has_center_submesh() {
    _has_bits_[0] &= ~0x00000008u;
  }
   void MeshGeom::clear_center_submesh() {
    center_submesh_ = false;
    clear_has_center_submesh();
  }
   bool MeshGeom::center_submesh() const {
    // @@protoc_insertion_point(field_get:Indriya.Core.Msgs.MeshGeom.center_submesh)
    return center_submesh_;
  }
   void MeshGeom::set_center_submesh(bool value) {
    set_has_center_submesh();
    center_submesh_ = value;
    // @@protoc_insertion_point(field_set:Indriya.Core.Msgs.MeshGeom.center_submesh)
  }
  
  #endif  // PROTOBUF_INLINE_NOT_IN_HEADERS
  
  // @@protoc_insertion_point(namespace_scope)
  
  }  // namespace Msgs
  }  // namespace Core
  }  // namespace Indriya
  
  EX_REGISTER_STATIC_MSG("Indriya.Core.Msgs.MeshGeom", MeshGeom)
  // @@protoc_insertion_point(global_scope)
  