text: // Generated by the protocol buffer compiler.  DO NOT EDIT!
  // source: physics.proto
  
  #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
  #include "physics.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* Physics_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    Physics_reflection_ = NULL;
  const ::google::protobuf::EnumDescriptor* Physics_Type_descriptor_ = NULL;
  
  }  // namespace
  
  
  void protobuf_AssignDesc_physics_2eproto() {
    protobuf_AddDesc_physics_2eproto();
    const ::google::protobuf::FileDescriptor* file =
      ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
        "physics.proto");
    GOOGLE_CHECK(file != NULL);
    Physics_descriptor_ = file->message_type(0);
    static const int Physics_offsets_[15] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Physics, type_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Physics, solver_type_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Physics, min_step_size_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Physics, precon_iters_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Physics, iters_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Physics, sor_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Physics, cfm_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Physics, erp_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Physics, contact_max_correcting_vel_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Physics, contact_surface_layer_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Physics, gravity_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Physics, enable_physics_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Physics, real_time_factor_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Physics, real_time_update_rate_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Physics, max_step_size_),
    };
    Physics_reflection_ =
      ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
        Physics_descriptor_,
        Physics::default_instance_,
        Physics_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Physics, _has_bits_[0]),
        -1,
        -1,
        sizeof(Physics),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Physics, _internal_metadata_),
        -1);
    Physics_Type_descriptor_ = Physics_descriptor_->enum_type(0);
  }
  
  namespace {
  
  GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
  inline void protobuf_AssignDescriptorsOnce() {
    ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
                   &protobuf_AssignDesc_physics_2eproto);
  }
  
  void protobuf_RegisterTypes(const ::std::string&) {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
        Physics_descriptor_, &Physics::default_instance());
  }
  
  }  // namespace
  
  void protobuf_ShutdownFile_physics_2eproto() {
    delete Physics::default_instance_;
    delete Physics_reflection_;
  }
  
  void protobuf_AddDesc_physics_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\rphysics.proto\022\021Indriya.Core.Msgs\032\016vect"
      "or3d.proto\"\302\003\n\007Physics\0222\n\004type\030\001 \001(\0162\037.I"
      "ndriya.Core.Msgs.Physics.Type:\003ODE\022\023\n\013so"
      "lver_type\030\002 \001(\t\022\025\n\rmin_step_size\030\003 \001(\001\022\024"
      "\n\014precon_iters\030\004 \001(\005\022\r\n\005iters\030\005 \001(\005\022\013\n\003s"
      "or\030\006 \001(\001\022\013\n\003cfm\030\007 \001(\001\022\013\n\003erp\030\010 \001(\001\022\"\n\032co"
      "ntact_max_correcting_vel\030\t \001(\001\022\035\n\025contac"
      "t_surface_layer\030\n \001(\001\022,\n\007gravity\030\013 \001(\0132\033"
      ".Indriya.Core.Msgs.Vector3d\022\026\n\016enable_ph"
      "ysics\030\014 \001(\010\022\030\n\020real_time_factor\030\r \001(\001\022\035\n"
      "\025real_time_update_rate\030\016 \001(\001\022\025\n\rmax_step"
      "_size\030\017 \001(\001\"2\n\004Type\022\007\n\003ODE\020\001\022\n\n\006BULLET\020\002"
      "\022\013\n\007SIMBODY\020\003\022\010\n\004DART\020\004", 503);
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
      "physics.proto", &protobuf_RegisterTypes);
    Physics::default_instance_ = new Physics();
    Physics::default_instance_->InitAsDefaultInstance();
    ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_physics_2eproto);
  }
  
  // Force AddDescriptors() to be called at static initialization time.
  struct StaticDescriptorInitializer_physics_2eproto {
    StaticDescriptorInitializer_physics_2eproto() {
      protobuf_AddDesc_physics_2eproto();
    }
  } static_descriptor_initializer_physics_2eproto_;
  
  namespace {
  
  static void MergeFromFail(int line) GOOGLE_ATTRIBUTE_COLD;
  static void MergeFromFail(int line) {
    GOOGLE_CHECK(false) << __FILE__ << ":" << line;
  }
  
  }  // namespace
  
  
  // ===================================================================
  
  const ::google::protobuf::EnumDescriptor* Physics_Type_descriptor() {
    protobuf_AssignDescriptorsOnce();
    return Physics_Type_descriptor_;
  }
  bool Physics_Type_IsValid(int value) {
    switch(value) {
      case 1:
      case 2:
      case 3:
      case 4:
        return true;
      default:
        return false;
    }
  }
  
  #ifndef _MSC_VER
  const Physics_Type Physics::ODE;
  const Physics_Type Physics::BULLET;
  const Physics_Type Physics::SIMBODY;
  const Physics_Type Physics::DART;
  const Physics_Type Physics::Type_MIN;
  const Physics_Type Physics::Type_MAX;
  const int Physics::Type_ARRAYSIZE;
  #endif  // _MSC_VER
  #ifndef _MSC_VER
  const int Physics::kTypeFieldNumber;
  const int Physics::kSolverTypeFieldNumber;
  const int Physics::kMinStepSizeFieldNumber;
  const int Physics::kPreconItersFieldNumber;
  const int Physics::kItersFieldNumber;
  const int Physics::kSorFieldNumber;
  const int Physics::kCfmFieldNumber;
  const int Physics::kErpFieldNumber;
  const int Physics::kContactMaxCorrectingVelFieldNumber;
  const int Physics::kContactSurfaceLayerFieldNumber;
  const int Physics::kGravityFieldNumber;
  const int Physics::kEnablePhysicsFieldNumber;
  const int Physics::kRealTimeFactorFieldNumber;
  const int Physics::kRealTimeUpdateRateFieldNumber;
  const int Physics::kMaxStepSizeFieldNumber;
  #endif  // !_MSC_VER
  
  Physics::Physics()
    : ::google::protobuf::Message() , _internal_metadata_(NULL)  {
    SharedCtor();
    // @@protoc_insertion_point(constructor:Indriya.Core.Msgs.Physics)
  }
  
  void Physics::InitAsDefaultInstance() {
    gravity_ = const_cast< ::Indriya::Core::Msgs::Vector3d*>(&::Indriya::Core::Msgs::Vector3d::default_instance());
  }
  
  Physics::Physics(const Physics& from)
    : ::google::protobuf::Message(),
      _internal_metadata_(NULL) {
    SharedCtor();
    MergeFrom(from);
    // @@protoc_insertion_point(copy_constructor:Indriya.Core.Msgs.Physics)
  }
  
  void Physics::SharedCtor() {
    ::google::protobuf::internal::GetEmptyString();
    _cached_size_ = 0;
    type_ = 1;
    solver_type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    min_step_size_ = 0;
    precon_iters_ = 0;
    iters_ = 0;
    sor_ = 0;
    cfm_ = 0;
    erp_ = 0;
    contact_max_correcting_vel_ = 0;
    contact_surface_layer_ = 0;
    gravity_ = NULL;
    enable_physics_ = false;
    real_time_factor_ = 0;
    real_time_update_rate_ = 0;
    max_step_size_ = 0;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  Physics::~Physics() {
    // @@protoc_insertion_point(destructor:Indriya.Core.Msgs.Physics)
    SharedDtor();
  }
  
  void Physics::SharedDtor() {
    solver_type_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    if (this != default_instance_) {
      delete gravity_;
    }
  }
  
  void Physics::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* Physics::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return Physics_descriptor_;
  }
  
  const Physics& Physics::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_physics_2eproto();
    return *default_instance_;
  }
  
  Physics* Physics::default_instance_ = NULL;
  
  Physics* Physics::New(::google::protobuf::Arena* arena) const {
    Physics* n = new Physics;
    if (arena != NULL) {
      arena->Own(n);
    }
    return n;
  }
  
  void Physics::Clear() {
  #define ZR_HELPER_(f) reinterpret_cast<char*>(\
    &reinterpret_cast<Physics*>(16)->f)
  
  #define ZR_(first, last) do {\
    ::memset(&first, 0,\
             ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\
  } while (0)
  
    if (_has_bits_[0 / 32] & 255) {
      ZR_(precon_iters_, iters_);
      type_ = 1;
      if (has_solver_type()) {
        solver_type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
      }
    }
    if (_has_bits_[8 / 32] & 32512) {
      ZR_(enable_physics_, contact_surface_layer_);
      ZR_(real_time_factor_, max_step_size_);
      if (has_gravity()) {
        if (gravity_ != NULL) gravity_->::Indriya::Core::Msgs::Vector3d::Clear();
      }
    }
  
  #undef ZR_HELPER_
  #undef ZR_
  
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    if (_internal_metadata_.have_unknown_fields()) {
      mutable_unknown_fields()->Clear();
    }
  }
  
  bool Physics::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.Physics)
    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)) {
        // optional .Indriya.Core.Msgs.Physics.Type type = 1 [default = ODE];
        case 1: {
          if (tag == 8) {
            int value;
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                   input, &value)));
            if (::Indriya::Core::Msgs::Physics_Type_IsValid(value)) {
              set_type(static_cast< ::Indriya::Core::Msgs::Physics_Type >(value));
            } else {
              mutable_unknown_fields()->AddVarint(1, value);
            }
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(18)) goto parse_solver_type;
          break;
        }
  
        // optional string solver_type = 2;
        case 2: {
          if (tag == 18) {
           parse_solver_type:
            DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                  input, this->mutable_solver_type()));
            ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
              this->solver_type().data(), this->solver_type().length(),
              ::google::protobuf::internal::WireFormat::PARSE,
              "Indriya.Core.Msgs.Physics.solver_type");
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(25)) goto parse_min_step_size;
          break;
        }
  
        // optional double min_step_size = 3;
        case 3: {
          if (tag == 25) {
           parse_min_step_size:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                   input, &min_step_size_)));
            set_has_min_step_size();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(32)) goto parse_precon_iters;
          break;
        }
  
        // optional int32 precon_iters = 4;
        case 4: {
          if (tag == 32) {
           parse_precon_iters:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                   input, &precon_iters_)));
            set_has_precon_iters();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(40)) goto parse_iters;
          break;
        }
  
        // optional int32 iters = 5;
        case 5: {
          if (tag == 40) {
           parse_iters:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                   input, &iters_)));
            set_has_iters();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(49)) goto parse_sor;
          break;
        }
  
        // optional double sor = 6;
        case 6: {
          if (tag == 49) {
           parse_sor:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                   input, &sor_)));
            set_has_sor();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(57)) goto parse_cfm;
          break;
        }
  
        // optional double cfm = 7;
        case 7: {
          if (tag == 57) {
           parse_cfm:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                   input, &cfm_)));
            set_has_cfm();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(65)) goto parse_erp;
          break;
        }
  
        // optional double erp = 8;
        case 8: {
          if (tag == 65) {
           parse_erp:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                   input, &erp_)));
            set_has_erp();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(73)) goto parse_contact_max_correcting_vel;
          break;
        }
  
        // optional double contact_max_correcting_vel = 9;
        case 9: {
          if (tag == 73) {
           parse_contact_max_correcting_vel:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                   input, &contact_max_correcting_vel_)));
            set_has_contact_max_correcting_vel();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(81)) goto parse_contact_surface_layer;
          break;
        }
  
        // optional double contact_surface_layer = 10;
        case 10: {
          if (tag == 81) {
           parse_contact_surface_layer:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                   input, &contact_surface_layer_)));
            set_has_contact_surface_layer();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(90)) goto parse_gravity;
          break;
        }
  
        // optional .Indriya.Core.Msgs.Vector3d gravity = 11;
        case 11: {
          if (tag == 90) {
           parse_gravity:
            DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                 input, mutable_gravity()));
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(96)) goto parse_enable_physics;
          break;
        }
  
        // optional bool enable_physics = 12;
        case 12: {
          if (tag == 96) {
           parse_enable_physics:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                   input, &enable_physics_)));
            set_has_enable_physics();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(105)) goto parse_real_time_factor;
          break;
        }
  
        // optional double real_time_factor = 13;
        case 13: {
          if (tag == 105) {
           parse_real_time_factor:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                   input, &real_time_factor_)));
            set_has_real_time_factor();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(113)) goto parse_real_time_update_rate;
          break;
        }
  
        // optional double real_time_update_rate = 14;
        case 14: {
          if (tag == 113) {
           parse_real_time_update_rate:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                   input, &real_time_update_rate_)));
            set_has_real_time_update_rate();
          } else {
            goto handle_unusual;
          }
          if (input->ExpectTag(121)) goto parse_max_step_size;
          break;
        }
  
        // optional double max_step_size = 15;
        case 15: {
          if (tag == 121) {
           parse_max_step_size:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                   input, &max_step_size_)));
            set_has_max_step_size();
          } 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.Physics)
    return true;
  failure:
    // @@protoc_insertion_point(parse_failure:Indriya.Core.Msgs.Physics)
    return false;
  #undef DO_
  }
  
  void Physics::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // @@protoc_insertion_point(serialize_start:Indriya.Core.Msgs.Physics)
    // optional .Indriya.Core.Msgs.Physics.Type type = 1 [default = ODE];
    if (has_type()) {
      ::google::protobuf::internal::WireFormatLite::WriteEnum(
        1, this->type(), output);
    }
  
    // optional string solver_type = 2;
    if (has_solver_type()) {
      ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
        this->solver_type().data(), this->solver_type().length(),
        ::google::protobuf::internal::WireFormat::SERIALIZE,
        "Indriya.Core.Msgs.Physics.solver_type");
      ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
        2, this->solver_type(), output);
    }
  
    // optional double min_step_size = 3;
    if (has_min_step_size()) {
      ::google::protobuf::internal::WireFormatLite::WriteDouble(3, this->min_step_size(), output);
    }
  
    // optional int32 precon_iters = 4;
    if (has_precon_iters()) {
      ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->precon_iters(), output);
    }
  
    // optional int32 iters = 5;
    if (has_iters()) {
      ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->iters(), output);
    }
  
    // optional double sor = 6;
    if (has_sor()) {
      ::google::protobuf::internal::WireFormatLite::WriteDouble(6, this->sor(), output);
    }
  
    // optional double cfm = 7;
    if (has_cfm()) {
      ::google::protobuf::internal::WireFormatLite::WriteDouble(7, this->cfm(), output);
    }
  
    // optional double erp = 8;
    if (has_erp()) {
      ::google::protobuf::internal::WireFormatLite::WriteDouble(8, this->erp(), output);
    }
  
    // optional double contact_max_correcting_vel = 9;
    if (has_contact_max_correcting_vel()) {
      ::google::protobuf::internal::WireFormatLite::WriteDouble(9, this->contact_max_correcting_vel(), output);
    }
  
    // optional double contact_surface_layer = 10;
    if (has_contact_surface_layer()) {
      ::google::protobuf::internal::WireFormatLite::WriteDouble(10, this->contact_surface_layer(), output);
    }
  
    // optional .Indriya.Core.Msgs.Vector3d gravity = 11;
    if (has_gravity()) {
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        11, *this->gravity_, output);
    }
  
    // optional bool enable_physics = 12;
    if (has_enable_physics()) {
      ::google::protobuf::internal::WireFormatLite::WriteBool(12, this->enable_physics(), output);
    }
  
    // optional double real_time_factor = 13;
    if (has_real_time_factor()) {
      ::google::protobuf::internal::WireFormatLite::WriteDouble(13, this->real_time_factor(), output);
    }
  
    // optional double real_time_update_rate = 14;
    if (has_real_time_update_rate()) {
      ::google::protobuf::internal::WireFormatLite::WriteDouble(14, this->real_time_update_rate(), output);
    }
  
    // optional double max_step_size = 15;
    if (has_max_step_size()) {
      ::google::protobuf::internal::WireFormatLite::WriteDouble(15, this->max_step_size(), output);
    }
  
    if (_internal_metadata_.have_unknown_fields()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
    // @@protoc_insertion_point(serialize_end:Indriya.Core.Msgs.Physics)
  }
  
  ::google::protobuf::uint8* Physics::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // @@protoc_insertion_point(serialize_to_array_start:Indriya.Core.Msgs.Physics)
    // optional .Indriya.Core.Msgs.Physics.Type type = 1 [default = ODE];
    if (has_type()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
        1, this->type(), target);
    }
  
    // optional string solver_type = 2;
    if (has_solver_type()) {
      ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
        this->solver_type().data(), this->solver_type().length(),
        ::google::protobuf::internal::WireFormat::SERIALIZE,
        "Indriya.Core.Msgs.Physics.solver_type");
      target =
        ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
          2, this->solver_type(), target);
    }
  
    // optional double min_step_size = 3;
    if (has_min_step_size()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(3, this->min_step_size(), target);
    }
  
    // optional int32 precon_iters = 4;
    if (has_precon_iters()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->precon_iters(), target);
    }
  
    // optional int32 iters = 5;
    if (has_iters()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->iters(), target);
    }
  
    // optional double sor = 6;
    if (has_sor()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(6, this->sor(), target);
    }
  
    // optional double cfm = 7;
    if (has_cfm()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(7, this->cfm(), target);
    }
  
    // optional double erp = 8;
    if (has_erp()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(8, this->erp(), target);
    }
  
    // optional double contact_max_correcting_vel = 9;
    if (has_contact_max_correcting_vel()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(9, this->contact_max_correcting_vel(), target);
    }
  
    // optional double contact_surface_layer = 10;
    if (has_contact_surface_layer()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(10, this->contact_surface_layer(), target);
    }
  
    // optional .Indriya.Core.Msgs.Vector3d gravity = 11;
    if (has_gravity()) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteMessageNoVirtualToArray(
          11, *this->gravity_, target);
    }
  
    // optional bool enable_physics = 12;
    if (has_enable_physics()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(12, this->enable_physics(), target);
    }
  
    // optional double real_time_factor = 13;
    if (has_real_time_factor()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(13, this->real_time_factor(), target);
    }
  
    // optional double real_time_update_rate = 14;
    if (has_real_time_update_rate()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(14, this->real_time_update_rate(), target);
    }
  
    // optional double max_step_size = 15;
    if (has_max_step_size()) {
      target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(15, this->max_step_size(), 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.Physics)
    return target;
  }
  
  int Physics::ByteSize() const {
    int total_size = 0;
  
    if (_has_bits_[0 / 32] & 255) {
      // optional .Indriya.Core.Msgs.Physics.Type type = 1 [default = ODE];
      if (has_type()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
      }
  
      // optional string solver_type = 2;
      if (has_solver_type()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::StringSize(
            this->solver_type());
      }
  
      // optional double min_step_size = 3;
      if (has_min_step_size()) {
        total_size += 1 + 8;
      }
  
      // optional int32 precon_iters = 4;
      if (has_precon_iters()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::Int32Size(
            this->precon_iters());
      }
  
      // optional int32 iters = 5;
      if (has_iters()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::Int32Size(
            this->iters());
      }
  
      // optional double sor = 6;
      if (has_sor()) {
        total_size += 1 + 8;
      }
  
      // optional double cfm = 7;
      if (has_cfm()) {
        total_size += 1 + 8;
      }
  
      // optional double erp = 8;
      if (has_erp()) {
        total_size += 1 + 8;
      }
  
    }
    if (_has_bits_[8 / 32] & 32512) {
      // optional double contact_max_correcting_vel = 9;
      if (has_contact_max_correcting_vel()) {
        total_size += 1 + 8;
      }
  
      // optional double contact_surface_layer = 10;
      if (has_contact_surface_layer()) {
        total_size += 1 + 8;
      }
  
      // optional .Indriya.Core.Msgs.Vector3d gravity = 11;
      if (has_gravity()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
            *this->gravity_);
      }
  
      // optional bool enable_physics = 12;
      if (has_enable_physics()) {
        total_size += 1 + 1;
      }
  
      // optional double real_time_factor = 13;
      if (has_real_time_factor()) {
        total_size += 1 + 8;
      }
  
      // optional double real_time_update_rate = 14;
      if (has_real_time_update_rate()) {
        total_size += 1 + 8;
      }
  
      // optional double max_step_size = 15;
      if (has_max_step_size()) {
        total_size += 1 + 8;
      }
  
    }
    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 Physics::MergeFrom(const ::google::protobuf::Message& from) {
    if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
    const Physics* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const Physics*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void Physics::MergeFrom(const Physics& from) {
    if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from.has_type()) {
        set_type(from.type());
      }
      if (from.has_solver_type()) {
        set_has_solver_type();
        solver_type_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.solver_type_);
      }
      if (from.has_min_step_size()) {
        set_min_step_size(from.min_step_size());
      }
      if (from.has_precon_iters()) {
        set_precon_iters(from.precon_iters());
      }
      if (from.has_iters()) {
        set_iters(from.iters());
      }
      if (from.has_sor()) {
        set_sor(from.sor());
      }
      if (from.has_cfm()) {
        set_cfm(from.cfm());
      }
      if (from.has_erp()) {
        set_erp(from.erp());
      }
    }
    if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
      if (from.has_contact_max_correcting_vel()) {
        set_contact_max_correcting_vel(from.contact_max_correcting_vel());
      }
      if (from.has_contact_surface_layer()) {
        set_contact_surface_layer(from.contact_surface_layer());
      }
      if (from.has_gravity()) {
        mutable_gravity()->::Indriya::Core::Msgs::Vector3d::MergeFrom(from.gravity());
      }
      if (from.has_enable_physics()) {
        set_enable_physics(from.enable_physics());
      }
      if (from.has_real_time_factor()) {
        set_real_time_factor(from.real_time_factor());
      }
      if (from.has_real_time_update_rate()) {
        set_real_time_update_rate(from.real_time_update_rate());
      }
      if (from.has_max_step_size()) {
        set_max_step_size(from.max_step_size());
      }
    }
    if (from._internal_metadata_.have_unknown_fields()) {
      mutable_unknown_fields()->MergeFrom(from.unknown_fields());
    }
  }
  
  void Physics::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void Physics::CopyFrom(const Physics& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool Physics::IsInitialized() const {
  
    if (has_gravity()) {
      if (!this->gravity_->IsInitialized()) return false;
    }
    return true;
  }
  
  void Physics::Swap(Physics* other) {
    if (other == this) return;
    InternalSwap(other);
  }
  void Physics::InternalSwap(Physics* other) {
    std::swap(type_, other->type_);
    solver_type_.Swap(&other->solver_type_);
    std::swap(min_step_size_, other->min_step_size_);
    std::swap(precon_iters_, other->precon_iters_);
    std::swap(iters_, other->iters_);
    std::swap(sor_, other->sor_);
    std::swap(cfm_, other->cfm_);
    std::swap(erp_, other->erp_);
    std::swap(contact_max_correcting_vel_, other->contact_max_correcting_vel_);
    std::swap(contact_surface_layer_, other->contact_surface_layer_);
    std::swap(gravity_, other->gravity_);
    std::swap(enable_physics_, other->enable_physics_);
    std::swap(real_time_factor_, other->real_time_factor_);
    std::swap(real_time_update_rate_, other->real_time_update_rate_);
    std::swap(max_step_size_, other->max_step_size_);
    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 Physics::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = Physics_descriptor_;
    metadata.reflection = Physics_reflection_;
    return metadata;
  }
  
  #if PROTOBUF_INLINE_NOT_IN_HEADERS
  // Physics
  
  // optional .Indriya.Core.Msgs.Physics.Type type = 1 [default = ODE];
   bool Physics::has_type() const {
    return (_has_bits_[0] & 0x00000001u) != 0;
  }
   void Physics::set_has_type() {
    _has_bits_[0] |= 0x00000001u;
  }
   void Physics::clear_has_type() {
    _has_bits_[0] &= ~0x00000001u;
  }
   void Physics::clear_type() {
    type_ = 1;
    clear_has_type();
  }
   ::Indriya::Core::Msgs::Physics_Type Physics::type() const {
    // @@protoc_insertion_point(field_get:Indriya.Core.Msgs.Physics.type)
    return static_cast< ::Indriya::Core::Msgs::Physics_Type >(type_);
  }
   void Physics::set_type(::Indriya::Core::Msgs::Physics_Type value) {
    assert(::Indriya::Core::Msgs::Physics_Type_IsValid(value));
    set_has_type();
    type_ = value;
    // @@protoc_insertion_point(field_set:Indriya.Core.Msgs.Physics.type)
  }
  
  // optional string solver_type = 2;
   bool Physics::has_solver_type() const {
    return (_has_bits_[0] & 0x00000002u) != 0;
  }
   void Physics::set_has_solver_type() {
    _has_bits_[0] |= 0x00000002u;
  }
   void Physics::clear_has_solver_type() {
    _has_bits_[0] &= ~0x00000002u;
  }
   void Physics::clear_solver_type() {
    solver_type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_solver_type();
  }
   const ::std::string& Physics::solver_type() const {
    // @@protoc_insertion_point(field_get:Indriya.Core.Msgs.Physics.solver_type)
    return solver_type_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
   void Physics::set_solver_type(const ::std::string& value) {
    set_has_solver_type();
    solver_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
    // @@protoc_insertion_point(field_set:Indriya.Core.Msgs.Physics.solver_type)
  }
   void Physics::set_solver_type(const char* value) {
    set_has_solver_type();
    solver_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
    // @@protoc_insertion_point(field_set_char:Indriya.Core.Msgs.Physics.solver_type)
  }
   void Physics::set_solver_type(const char* value, size_t size) {
    set_has_solver_type();
    solver_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        ::std::string(reinterpret_cast<const char*>(value), size));
    // @@protoc_insertion_point(field_set_pointer:Indriya.Core.Msgs.Physics.solver_type)
  }
   ::std::string* Physics::mutable_solver_type() {
    set_has_solver_type();
    // @@protoc_insertion_point(field_mutable:Indriya.Core.Msgs.Physics.solver_type)
    return solver_type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
   ::std::string* Physics::release_solver_type() {
    clear_has_solver_type();
    return solver_type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
   void Physics::set_allocated_solver_type(::std::string* solver_type) {
    if (solver_type != NULL) {
      set_has_solver_type();
    } else {
      clear_has_solver_type();
    }
    solver_type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), solver_type);
    // @@protoc_insertion_point(field_set_allocated:Indriya.Core.Msgs.Physics.solver_type)
  }
  
  // optional double min_step_size = 3;
   bool Physics::has_min_step_size() const {
    return (_has_bits_[0] & 0x00000004u) != 0;
  }
   void Physics::set_has_min_step_size() {
    _has_bits_[0] |= 0x00000004u;
  }
   void Physics::clear_has_min_step_size() {
    _has_bits_[0] &= ~0x00000004u;
  }
   void Physics::clear_min_step_size() {
    min_step_size_ = 0;
    clear_has_min_step_size();
  }
   double Physics::min_step_size() const {
    // @@protoc_insertion_point(field_get:Indriya.Core.Msgs.Physics.min_step_size)
    return min_step_size_;
  }
   void Physics::set_min_step_size(double value) {
    set_has_min_step_size();
    min_step_size_ = value;
    // @@protoc_insertion_point(field_set:Indriya.Core.Msgs.Physics.min_step_size)
  }
  
  // optional int32 precon_iters = 4;
   bool Physics::has_precon_iters() const {
    return (_has_bits_[0] & 0x00000008u) != 0;
  }
   void Physics::set_has_precon_iters() {
    _has_bits_[0] |= 0x00000008u;
  }
   void Physics::clear_has_precon_iters() {
    _has_bits_[0] &= ~0x00000008u;
  }
   void Physics::clear_precon_iters() {
    precon_iters_ = 0;
    clear_has_precon_iters();
  }
   ::google::protobuf::int32 Physics::precon_iters() const {
    // @@protoc_insertion_point(field_get:Indriya.Core.Msgs.Physics.precon_iters)
    return precon_iters_;
  }
   void Physics::set_precon_iters(::google::protobuf::int32 value) {
    set_has_precon_iters();
    precon_iters_ = value;
    // @@protoc_insertion_point(field_set:Indriya.Core.Msgs.Physics.precon_iters)
  }
  
  // optional int32 iters = 5;
   bool Physics::has_iters() const {
    return (_has_bits_[0] & 0x00000010u) != 0;
  }
   void Physics::set_has_iters() {
    _has_bits_[0] |= 0x00000010u;
  }
   void Physics::clear_has_iters() {
    _has_bits_[0] &= ~0x00000010u;
  }
   void Physics::clear_iters() {
    iters_ = 0;
    clear_has_iters();
  }
   ::google::protobuf::int32 Physics::iters() const {
    // @@protoc_insertion_point(field_get:Indriya.Core.Msgs.Physics.iters)
    return iters_;
  }
   void Physics::set_iters(::google::protobuf::int32 value) {
    set_has_iters();
    iters_ = value;
    // @@protoc_insertion_point(field_set:Indriya.Core.Msgs.Physics.iters)
  }
  
  // optional double sor = 6;
   bool Physics::has_sor() const {
    return (_has_bits_[0] & 0x00000020u) != 0;
  }
   void Physics::set_has_sor() {
    _has_bits_[0] |= 0x00000020u;
  }
   void Physics::clear_has_sor() {
    _has_bits_[0] &= ~0x00000020u;
  }
   void Physics::clear_sor() {
    sor_ = 0;
    clear_has_sor();
  }
   double Physics::sor() const {
    // @@protoc_insertion_point(field_get:Indriya.Core.Msgs.Physics.sor)
    return sor_;
  }
   void Physics::set_sor(double value) {
    set_has_sor();
    sor_ = value;
    // @@protoc_insertion_point(field_set:Indriya.Core.Msgs.Physics.sor)
  }
  
  // optional double cfm = 7;
   bool Physics::has_cfm() const {
    return (_has_bits_[0] & 0x00000040u) != 0;
  }
   void Physics::set_has_cfm() {
    _has_bits_[0] |= 0x00000040u;
  }
   void Physics::clear_has_cfm() {
    _has_bits_[0] &= ~0x00000040u;
  }
   void Physics::clear_cfm() {
    cfm_ = 0;
    clear_has_cfm();
  }
   double Physics::cfm() const {
    // @@protoc_insertion_point(field_get:Indriya.Core.Msgs.Physics.cfm)
    return cfm_;
  }
   void Physics::set_cfm(double value) {
    set_has_cfm();
    cfm_ = value;
    // @@protoc_insertion_point(field_set:Indriya.Core.Msgs.Physics.cfm)
  }
  
  // optional double erp = 8;
   bool Physics::has_erp() const {
    return (_has_bits_[0] & 0x00000080u) != 0;
  }
   void Physics::set_has_erp() {
    _has_bits_[0] |= 0x00000080u;
  }
   void Physics::clear_has_erp() {
    _has_bits_[0] &= ~0x00000080u;
  }
   void Physics::clear_erp() {
    erp_ = 0;
    clear_has_erp();
  }
   double Physics::erp() const {
    // @@protoc_insertion_point(field_get:Indriya.Core.Msgs.Physics.erp)
    return erp_;
  }
   void Physics::set_erp(double value) {
    set_has_erp();
    erp_ = value;
    // @@protoc_insertion_point(field_set:Indriya.Core.Msgs.Physics.erp)
  }
  
  // optional double contact_max_correcting_vel = 9;
   bool Physics::has_contact_max_correcting_vel() const {
    return (_has_bits_[0] & 0x00000100u) != 0;
  }
   void Physics::set_has_contact_max_correcting_vel() {
    _has_bits_[0] |= 0x00000100u;
  }
   void Physics::clear_has_contact_max_correcting_vel() {
    _has_bits_[0] &= ~0x00000100u;
  }
   void Physics::clear_contact_max_correcting_vel() {
    contact_max_correcting_vel_ = 0;
    clear_has_contact_max_correcting_vel();
  }
   double Physics::contact_max_correcting_vel() const {
    // @@protoc_insertion_point(field_get:Indriya.Core.Msgs.Physics.contact_max_correcting_vel)
    return contact_max_correcting_vel_;
  }
   void Physics::set_contact_max_correcting_vel(double value) {
    set_has_contact_max_correcting_vel();
    contact_max_correcting_vel_ = value;
    // @@protoc_insertion_point(field_set:Indriya.Core.Msgs.Physics.contact_max_correcting_vel)
  }
  
  // optional double contact_surface_layer = 10;
   bool Physics::has_contact_surface_layer() const {
    return (_has_bits_[0] & 0x00000200u) != 0;
  }
   void Physics::set_has_contact_surface_layer() {
    _has_bits_[0] |= 0x00000200u;
  }
   void Physics::clear_has_contact_surface_layer() {
    _has_bits_[0] &= ~0x00000200u;
  }
   void Physics::clear_contact_surface_layer() {
    contact_surface_layer_ = 0;
    clear_has_contact_surface_layer();
  }
   double Physics::contact_surface_layer() const {
    // @@protoc_insertion_point(field_get:Indriya.Core.Msgs.Physics.contact_surface_layer)
    return contact_surface_layer_;
  }
   void Physics::set_contact_surface_layer(double value) {
    set_has_contact_surface_layer();
    contact_surface_layer_ = value;
    // @@protoc_insertion_point(field_set:Indriya.Core.Msgs.Physics.contact_surface_layer)
  }
  
  // optional .Indriya.Core.Msgs.Vector3d gravity = 11;
   bool Physics::has_gravity() const {
    return (_has_bits_[0] & 0x00000400u) != 0;
  }
   void Physics::set_has_gravity() {
    _has_bits_[0] |= 0x00000400u;
  }
   void Physics::clear_has_gravity() {
    _has_bits_[0] &= ~0x00000400u;
  }
   void Physics::clear_gravity() {
    if (gravity_ != NULL) gravity_->::Indriya::Core::Msgs::Vector3d::Clear();
    clear_has_gravity();
  }
   const ::Indriya::Core::Msgs::Vector3d& Physics::gravity() const {
    // @@protoc_insertion_point(field_get:Indriya.Core.Msgs.Physics.gravity)
    return gravity_ != NULL ? *gravity_ : *default_instance_->gravity_;
  }
   ::Indriya::Core::Msgs::Vector3d* Physics::mutable_gravity() {
    set_has_gravity();
    if (gravity_ == NULL) {
      gravity_ = new ::Indriya::Core::Msgs::Vector3d;
    }
    // @@protoc_insertion_point(field_mutable:Indriya.Core.Msgs.Physics.gravity)
    return gravity_;
  }
   ::Indriya::Core::Msgs::Vector3d* Physics::release_gravity() {
    clear_has_gravity();
    ::Indriya::Core::Msgs::Vector3d* temp = gravity_;
    gravity_ = NULL;
    return temp;
  }
   void Physics::set_allocated_gravity(::Indriya::Core::Msgs::Vector3d* gravity) {
    delete gravity_;
    gravity_ = gravity;
    if (gravity) {
      set_has_gravity();
    } else {
      clear_has_gravity();
    }
    // @@protoc_insertion_point(field_set_allocated:Indriya.Core.Msgs.Physics.gravity)
  }
  
  // optional bool enable_physics = 12;
   bool Physics::has_enable_physics() const {
    return (_has_bits_[0] & 0x00000800u) != 0;
  }
   void Physics::set_has_enable_physics() {
    _has_bits_[0] |= 0x00000800u;
  }
   void Physics::clear_has_enable_physics() {
    _has_bits_[0] &= ~0x00000800u;
  }
   void Physics::clear_enable_physics() {
    enable_physics_ = false;
    clear_has_enable_physics();
  }
   bool Physics::enable_physics() const {
    // @@protoc_insertion_point(field_get:Indriya.Core.Msgs.Physics.enable_physics)
    return enable_physics_;
  }
   void Physics::set_enable_physics(bool value) {
    set_has_enable_physics();
    enable_physics_ = value;
    // @@protoc_insertion_point(field_set:Indriya.Core.Msgs.Physics.enable_physics)
  }
  
  // optional double real_time_factor = 13;
   bool Physics::has_real_time_factor() const {
    return (_has_bits_[0] & 0x00001000u) != 0;
  }
   void Physics::set_has_real_time_factor() {
    _has_bits_[0] |= 0x00001000u;
  }
   void Physics::clear_has_real_time_factor() {
    _has_bits_[0] &= ~0x00001000u;
  }
   void Physics::clear_real_time_factor() {
    real_time_factor_ = 0;
    clear_has_real_time_factor();
  }
   double Physics::real_time_factor() const {
    // @@protoc_insertion_point(field_get:Indriya.Core.Msgs.Physics.real_time_factor)
    return real_time_factor_;
  }
   void Physics::set_real_time_factor(double value) {
    set_has_real_time_factor();
    real_time_factor_ = value;
    // @@protoc_insertion_point(field_set:Indriya.Core.Msgs.Physics.real_time_factor)
  }
  
  // optional double real_time_update_rate = 14;
   bool Physics::has_real_time_update_rate() const {
    return (_has_bits_[0] & 0x00002000u) != 0;
  }
   void Physics::set_has_real_time_update_rate() {
    _has_bits_[0] |= 0x00002000u;
  }
   void Physics::clear_has_real_time_update_rate() {
    _has_bits_[0] &= ~0x00002000u;
  }
   void Physics::clear_real_time_update_rate() {
    real_time_update_rate_ = 0;
    clear_has_real_time_update_rate();
  }
   double Physics::real_time_update_rate() const {
    // @@protoc_insertion_point(field_get:Indriya.Core.Msgs.Physics.real_time_update_rate)
    return real_time_update_rate_;
  }
   void Physics::set_real_time_update_rate(double value) {
    set_has_real_time_update_rate();
    real_time_update_rate_ = value;
    // @@protoc_insertion_point(field_set:Indriya.Core.Msgs.Physics.real_time_update_rate)
  }
  
  // optional double max_step_size = 15;
   bool Physics::has_max_step_size() const {
    return (_has_bits_[0] & 0x00004000u) != 0;
  }
   void Physics::set_has_max_step_size() {
    _has_bits_[0] |= 0x00004000u;
  }
   void Physics::clear_has_max_step_size() {
    _has_bits_[0] &= ~0x00004000u;
  }
   void Physics::clear_max_step_size() {
    max_step_size_ = 0;
    clear_has_max_step_size();
  }
   double Physics::max_step_size() const {
    // @@protoc_insertion_point(field_get:Indriya.Core.Msgs.Physics.max_step_size)
    return max_step_size_;
  }
   void Physics::set_max_step_size(double value) {
    set_has_max_step_size();
    max_step_size_ = value;
    // @@protoc_insertion_point(field_set:Indriya.Core.Msgs.Physics.max_step_size)
  }
  
  #endif  // PROTOBUF_INLINE_NOT_IN_HEADERS
  
  // @@protoc_insertion_point(namespace_scope)
  
  }  // namespace Msgs
  }  // namespace Core
  }  // namespace Indriya
  
  EX_REGISTER_STATIC_MSG("Indriya.Core.Msgs.Physics", Physics)
  // @@protoc_insertion_point(global_scope)
  