Mondschein Engine  0.3.0
mbd.pb.h
1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: mbd.proto
3 
4 #ifndef PROTOBUF_mbd_2eproto__INCLUDED
5 #define PROTOBUF_mbd_2eproto__INCLUDED
6 
7 #include <string>
8 
9 #include <google/protobuf/stubs/common.h>
10 
11 #if GOOGLE_PROTOBUF_VERSION < 2005000
12 #error This file was generated by a newer version of protoc which is
13 #error incompatible with your Protocol Buffer headers. Please update
14 #error your headers.
15 #endif
16 #if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
17 #error This file was generated by an older version of protoc which is
18 #error incompatible with your Protocol Buffer headers. Please
19 #error regenerate this file with a newer version of protoc.
20 #endif
21 
22 #include <google/protobuf/generated_message_util.h>
23 #include <google/protobuf/message.h>
24 #include <google/protobuf/repeated_field.h>
25 #include <google/protobuf/extension_set.h>
26 #include <google/protobuf/generated_enum_reflection.h>
27 #include <google/protobuf/unknown_field_set.h>
28 // @@protoc_insertion_point(includes)
29 
30 namespace mondschein
31 {
32  namespace io
33  {
34  namespace mbd
35  {
36 
37  // Internal implementation detail -- do not call these.
38  void protobuf_AddDesc_mbd_2eproto();
39  void protobuf_AssignDesc_mbd_2eproto();
40  void protobuf_ShutdownFile_mbd_2eproto();
41 
42  class data;
43  class data_vector;
44  class data_camera;
45  class data_light;
46  class data_material;
47  class data_mesh;
48  class data_pose;
49  class data_texture;
50  class data_scenegraph;
51  class data_scenegraph_attribs_tuple;
52  class data_beziercurve;
53  class data_bezierpatch;
54  class data_nurbscurve;
55  class data_nurbspatch;
56 
57  enum normal_e
58  {
59  FLAT = 0,
60  FLAT_INV = 1,
61  INTERMEDIATE = 2,
62  INTERMEDIATE_INV = 3
63  };
64  bool normal_e_IsValid(int value);
65  const normal_e normal_e_MIN = FLAT;
66  const normal_e normal_e_MAX = INTERMEDIATE_INV;
67  const int normal_e_ARRAYSIZE = normal_e_MAX + 1;
68 
69  const ::google::protobuf::EnumDescriptor *normal_e_descriptor();
70  inline const ::std::string &normal_e_Name(normal_e value)
71  {
72  return ::google::protobuf::internal::NameOfEnum(
73  normal_e_descriptor(), value);
74  }
75  inline bool normal_e_Parse(
76  const ::std::string &name, normal_e *value)
77  {
78  return ::google::protobuf::internal::ParseNamedEnum<normal_e>(
79  normal_e_descriptor(), name, value);
80  }
82  {
83  ONN = 0,
84  ONL = 1,
85  OLN = 2,
86  OLL = 3,
87  NNN = 4,
88  NNL = 5,
89  NLN = 6,
90  NLL = 7,
91  LNN = 8,
92  LNL = 9,
93  LLN = 10,
94  LLL = 11
95  };
96  bool texture_filtering_e_IsValid(int value);
97  const texture_filtering_e texture_filtering_e_MIN = ONN;
98  const texture_filtering_e texture_filtering_e_MAX = LLL;
99  const int texture_filtering_e_ARRAYSIZE = texture_filtering_e_MAX + 1;
100 
101  const ::google::protobuf::EnumDescriptor *texture_filtering_e_descriptor();
102  inline const ::std::string &texture_filtering_e_Name(texture_filtering_e value)
103  {
104  return ::google::protobuf::internal::NameOfEnum(
105  texture_filtering_e_descriptor(), value);
106  }
107  inline bool texture_filtering_e_Parse(
108  const ::std::string &name, texture_filtering_e *value)
109  {
110  return ::google::protobuf::internal::ParseNamedEnum<texture_filtering_e>(
111  texture_filtering_e_descriptor(), name, value);
112  }
113  // ===================================================================
114 
115  class data_vector : public ::google::protobuf::Message
116  {
117  public:
118  data_vector();
119  virtual ~data_vector();
120 
121  data_vector(const data_vector &from);
122 
123  inline data_vector &operator=(const data_vector &from)
124  {
125  CopyFrom(from);
126  return *this;
127  }
128 
129  inline const ::google::protobuf::UnknownFieldSet &unknown_fields() const
130  {
131  return _unknown_fields_;
132  }
133 
134  inline ::google::protobuf::UnknownFieldSet *mutable_unknown_fields()
135  {
136  return &_unknown_fields_;
137  }
138 
139  static const ::google::protobuf::Descriptor *descriptor();
140  static const data_vector &default_instance();
141 
142  void Swap(data_vector *other);
143 
144  // implements Message ----------------------------------------------
145 
146  data_vector *New() const;
147  void CopyFrom(const ::google::protobuf::Message &from);
148  void MergeFrom(const ::google::protobuf::Message &from);
149  void CopyFrom(const data_vector &from);
150  void MergeFrom(const data_vector &from);
151  void Clear();
152  bool IsInitialized() const;
153 
154  int ByteSize() const;
155  bool MergePartialFromCodedStream(
156  ::google::protobuf::io::CodedInputStream *input);
157  void SerializeWithCachedSizes(
158  ::google::protobuf::io::CodedOutputStream *output) const;
159  ::google::protobuf::uint8 *SerializeWithCachedSizesToArray(::google::protobuf::uint8 *output) const;
160  int GetCachedSize() const { return _cached_size_; }
161  private:
162  void SharedCtor();
163  void SharedDtor();
164  void SetCachedSize(int size) const;
165  public:
166 
167  ::google::protobuf::Metadata GetMetadata() const;
168 
169  // nested types ----------------------------------------------------
170 
171  // accessors -------------------------------------------------------
172 
173  // required double x = 1 [default = 0];
174  inline bool has_x() const;
175  inline void clear_x();
176  static const int kXFieldNumber = 1;
177  inline double x() const;
178  inline void set_x(double value);
179 
180  // required double y = 2 [default = 0];
181  inline bool has_y() const;
182  inline void clear_y();
183  static const int kYFieldNumber = 2;
184  inline double y() const;
185  inline void set_y(double value);
186 
187  // optional double z = 3 [default = 0];
188  inline bool has_z() const;
189  inline void clear_z();
190  static const int kZFieldNumber = 3;
191  inline double z() const;
192  inline void set_z(double value);
193 
194  // optional double w = 4 [default = 1];
195  inline bool has_w() const;
196  inline void clear_w();
197  static const int kWFieldNumber = 4;
198  inline double w() const;
199  inline void set_w(double value);
200 
201  // @@protoc_insertion_point(class_scope:mondschein.io.mbd.data.vector)
202  private:
203  inline void set_has_x();
204  inline void clear_has_x();
205  inline void set_has_y();
206  inline void clear_has_y();
207  inline void set_has_z();
208  inline void clear_has_z();
209  inline void set_has_w();
210  inline void clear_has_w();
211 
212  ::google::protobuf::UnknownFieldSet _unknown_fields_;
213 
214  double x_;
215  double y_;
216  double z_;
217  double w_;
218 
219  mutable int _cached_size_;
220  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
221 
222  friend void protobuf_AddDesc_mbd_2eproto();
223  friend void protobuf_AssignDesc_mbd_2eproto();
224  friend void protobuf_ShutdownFile_mbd_2eproto();
225 
226  void InitAsDefaultInstance();
227  static data_vector *default_instance_;
228  };
229  // -------------------------------------------------------------------
230 
231  class data_camera : public ::google::protobuf::Message
232  {
233  public:
234  data_camera();
235  virtual ~data_camera();
236 
237  data_camera(const data_camera &from);
238 
239  inline data_camera &operator=(const data_camera &from)
240  {
241  CopyFrom(from);
242  return *this;
243  }
244 
245  inline const ::google::protobuf::UnknownFieldSet &unknown_fields() const
246  {
247  return _unknown_fields_;
248  }
249 
250  inline ::google::protobuf::UnknownFieldSet *mutable_unknown_fields()
251  {
252  return &_unknown_fields_;
253  }
254 
255  static const ::google::protobuf::Descriptor *descriptor();
256  static const data_camera &default_instance();
257 
258  void Swap(data_camera *other);
259 
260  // implements Message ----------------------------------------------
261 
262  data_camera *New() const;
263  void CopyFrom(const ::google::protobuf::Message &from);
264  void MergeFrom(const ::google::protobuf::Message &from);
265  void CopyFrom(const data_camera &from);
266  void MergeFrom(const data_camera &from);
267  void Clear();
268  bool IsInitialized() const;
269 
270  int ByteSize() const;
271  bool MergePartialFromCodedStream(
272  ::google::protobuf::io::CodedInputStream *input);
273  void SerializeWithCachedSizes(
274  ::google::protobuf::io::CodedOutputStream *output) const;
275  ::google::protobuf::uint8 *SerializeWithCachedSizesToArray(::google::protobuf::uint8 *output) const;
276  int GetCachedSize() const { return _cached_size_; }
277  private:
278  void SharedCtor();
279  void SharedDtor();
280  void SetCachedSize(int size) const;
281  public:
282 
283  ::google::protobuf::Metadata GetMetadata() const;
284 
285  // nested types ----------------------------------------------------
286 
287  // accessors -------------------------------------------------------
288 
289  // required string name = 1;
290  inline bool has_name() const;
291  inline void clear_name();
292  static const int kNameFieldNumber = 1;
293  inline const ::std::string &name() const;
294  inline void set_name(const ::std::string &value);
295  inline void set_name(const char *value);
296  inline void set_name(const char *value, size_t size);
297  inline ::std::string *mutable_name();
298  inline ::std::string *release_name();
299  inline void set_allocated_name(::std::string *name);
300 
301  // required double fovy = 2 [default = 1.0472];
302  inline bool has_fovy() const;
303  inline void clear_fovy();
304  static const int kFovyFieldNumber = 2;
305  inline double fovy() const;
306  inline void set_fovy(double value);
307 
308  // required double aspect = 3 [default = 0];
309  inline bool has_aspect() const;
310  inline void clear_aspect();
311  static const int kAspectFieldNumber = 3;
312  inline double aspect() const;
313  inline void set_aspect(double value);
314 
315  // required double near = 4 [default = 1];
316  inline bool has_near() const;
317  inline void clear_near();
318  static const int kNearFieldNumber = 4;
319  inline double near() const;
320  inline void set_near(double value);
321 
322  // required double far = 5 [default = 100];
323  inline bool has_far() const;
324  inline void clear_far();
325  static const int kFarFieldNumber = 5;
326  inline double far() const;
327  inline void set_far(double value);
328 
329  // required uint32 x = 6 [default = 0];
330  inline bool has_x() const;
331  inline void clear_x();
332  static const int kXFieldNumber = 6;
334  inline void set_x(::google::protobuf::uint32 value);
335 
336  // required uint32 y = 7 [default = 0];
337  inline bool has_y() const;
338  inline void clear_y();
339  static const int kYFieldNumber = 7;
341  inline void set_y(::google::protobuf::uint32 value);
342 
343  // required uint32 w = 8 [default = 0];
344  inline bool has_w() const;
345  inline void clear_w();
346  static const int kWFieldNumber = 8;
348  inline void set_w(::google::protobuf::uint32 value);
349 
350  // required uint32 h = 9 [default = 0];
351  inline bool has_h() const;
352  inline void clear_h();
353  static const int kHFieldNumber = 9;
355  inline void set_h(::google::protobuf::uint32 value);
356 
357  // @@protoc_insertion_point(class_scope:mondschein.io.mbd.data.camera)
358  private:
359  inline void set_has_name();
360  inline void clear_has_name();
361  inline void set_has_fovy();
362  inline void clear_has_fovy();
363  inline void set_has_aspect();
364  inline void clear_has_aspect();
365  inline void set_has_near();
366  inline void clear_has_near();
367  inline void set_has_far();
368  inline void clear_has_far();
369  inline void set_has_x();
370  inline void clear_has_x();
371  inline void set_has_y();
372  inline void clear_has_y();
373  inline void set_has_w();
374  inline void clear_has_w();
375  inline void set_has_h();
376  inline void clear_has_h();
377 
378  ::google::protobuf::UnknownFieldSet _unknown_fields_;
379 
380  ::std::string *name_;
381  double fovy_;
382  double aspect_;
383  double near_;
384  double far_;
389 
390  mutable int _cached_size_;
391  ::google::protobuf::uint32 _has_bits_[(9 + 31) / 32];
392 
393  friend void protobuf_AddDesc_mbd_2eproto();
394  friend void protobuf_AssignDesc_mbd_2eproto();
395  friend void protobuf_ShutdownFile_mbd_2eproto();
396 
397  void InitAsDefaultInstance();
398  static data_camera *default_instance_;
399  };
400  // -------------------------------------------------------------------
401 
402  class data_light : public ::google::protobuf::Message
403  {
404  public:
405  data_light();
406  virtual ~data_light();
407 
408  data_light(const data_light &from);
409 
410  inline data_light &operator=(const data_light &from)
411  {
412  CopyFrom(from);
413  return *this;
414  }
415 
416  inline const ::google::protobuf::UnknownFieldSet &unknown_fields() const
417  {
418  return _unknown_fields_;
419  }
420 
421  inline ::google::protobuf::UnknownFieldSet *mutable_unknown_fields()
422  {
423  return &_unknown_fields_;
424  }
425 
426  static const ::google::protobuf::Descriptor *descriptor();
427  static const data_light &default_instance();
428 
429  void Swap(data_light *other);
430 
431  // implements Message ----------------------------------------------
432 
433  data_light *New() const;
434  void CopyFrom(const ::google::protobuf::Message &from);
435  void MergeFrom(const ::google::protobuf::Message &from);
436  void CopyFrom(const data_light &from);
437  void MergeFrom(const data_light &from);
438  void Clear();
439  bool IsInitialized() const;
440 
441  int ByteSize() const;
442  bool MergePartialFromCodedStream(
443  ::google::protobuf::io::CodedInputStream *input);
444  void SerializeWithCachedSizes(
445  ::google::protobuf::io::CodedOutputStream *output) const;
446  ::google::protobuf::uint8 *SerializeWithCachedSizesToArray(::google::protobuf::uint8 *output) const;
447  int GetCachedSize() const { return _cached_size_; }
448  private:
449  void SharedCtor();
450  void SharedDtor();
451  void SetCachedSize(int size) const;
452  public:
453 
454  ::google::protobuf::Metadata GetMetadata() const;
455 
456  // nested types ----------------------------------------------------
457 
458  // accessors -------------------------------------------------------
459 
460  // required string name = 1;
461  inline bool has_name() const;
462  inline void clear_name();
463  static const int kNameFieldNumber = 1;
464  inline const ::std::string &name() const;
465  inline void set_name(const ::std::string &value);
466  inline void set_name(const char *value);
467  inline void set_name(const char *value, size_t size);
468  inline ::std::string *mutable_name();
469  inline ::std::string *release_name();
470  inline void set_allocated_name(::std::string *name);
471 
472  // required .mondschein.io.mbd.data.vector ambient = 2;
473  inline bool has_ambient() const;
474  inline void clear_ambient();
475  static const int kAmbientFieldNumber = 2;
476  inline const ::mondschein::io::mbd::data_vector &ambient() const;
477  inline ::mondschein::io::mbd::data_vector *mutable_ambient();
478  inline ::mondschein::io::mbd::data_vector *release_ambient();
479  inline void set_allocated_ambient(::mondschein::io::mbd::data_vector *ambient);
480 
481  // required .mondschein.io.mbd.data.vector diffuse = 3;
482  inline bool has_diffuse() const;
483  inline void clear_diffuse();
484  static const int kDiffuseFieldNumber = 3;
485  inline const ::mondschein::io::mbd::data_vector &diffuse() const;
486  inline ::mondschein::io::mbd::data_vector *mutable_diffuse();
487  inline ::mondschein::io::mbd::data_vector *release_diffuse();
488  inline void set_allocated_diffuse(::mondschein::io::mbd::data_vector *diffuse);
489 
490  // required .mondschein.io.mbd.data.vector specular = 4;
491  inline bool has_specular() const;
492  inline void clear_specular();
493  static const int kSpecularFieldNumber = 4;
494  inline const ::mondschein::io::mbd::data_vector &specular() const;
495  inline ::mondschein::io::mbd::data_vector *mutable_specular();
496  inline ::mondschein::io::mbd::data_vector *release_specular();
497  inline void set_allocated_specular(::mondschein::io::mbd::data_vector *specular);
498 
499  // required .mondschein.io.mbd.data.vector position = 5;
500  inline bool has_position() const;
501  inline void clear_position();
502  static const int kPositionFieldNumber = 5;
503  inline const ::mondschein::io::mbd::data_vector &position() const;
504  inline ::mondschein::io::mbd::data_vector *mutable_position();
505  inline ::mondschein::io::mbd::data_vector *release_position();
506  inline void set_allocated_position(::mondschein::io::mbd::data_vector *position);
507 
508  // required .mondschein.io.mbd.data.vector direction = 6;
509  inline bool has_direction() const;
510  inline void clear_direction();
511  static const int kDirectionFieldNumber = 6;
512  inline const ::mondschein::io::mbd::data_vector &direction() const;
513  inline ::mondschein::io::mbd::data_vector *mutable_direction();
514  inline ::mondschein::io::mbd::data_vector *release_direction();
515  inline void set_allocated_direction(::mondschein::io::mbd::data_vector *direction);
516 
517  // required double exponent = 7;
518  inline bool has_exponent() const;
519  inline void clear_exponent();
520  static const int kExponentFieldNumber = 7;
521  inline double exponent() const;
522  inline void set_exponent(double value);
523 
524  // required double cutoff = 8;
525  inline bool has_cutoff() const;
526  inline void clear_cutoff();
527  static const int kCutoffFieldNumber = 8;
528  inline double cutoff() const;
529  inline void set_cutoff(double value);
530 
531  // required double const_att = 9;
532  inline bool has_const_att() const;
533  inline void clear_const_att();
534  static const int kConstAttFieldNumber = 9;
535  inline double const_att() const;
536  inline void set_const_att(double value);
537 
538  // required double lin_att = 10;
539  inline bool has_lin_att() const;
540  inline void clear_lin_att();
541  static const int kLinAttFieldNumber = 10;
542  inline double lin_att() const;
543  inline void set_lin_att(double value);
544 
545  // required double quad_att = 11;
546  inline bool has_quad_att() const;
547  inline void clear_quad_att();
548  static const int kQuadAttFieldNumber = 11;
549  inline double quad_att() const;
550  inline void set_quad_att(double value);
551 
552  // required uint32 light_nr = 12;
553  inline bool has_light_nr() const;
554  inline void clear_light_nr();
555  static const int kLightNrFieldNumber = 12;
556  inline ::google::protobuf::uint32 light_nr() const;
557  inline void set_light_nr(::google::protobuf::uint32 value);
558 
559  // @@protoc_insertion_point(class_scope:mondschein.io.mbd.data.light)
560  private:
561  inline void set_has_name();
562  inline void clear_has_name();
563  inline void set_has_ambient();
564  inline void clear_has_ambient();
565  inline void set_has_diffuse();
566  inline void clear_has_diffuse();
567  inline void set_has_specular();
568  inline void clear_has_specular();
569  inline void set_has_position();
570  inline void clear_has_position();
571  inline void set_has_direction();
572  inline void clear_has_direction();
573  inline void set_has_exponent();
574  inline void clear_has_exponent();
575  inline void set_has_cutoff();
576  inline void clear_has_cutoff();
577  inline void set_has_const_att();
578  inline void clear_has_const_att();
579  inline void set_has_lin_att();
580  inline void clear_has_lin_att();
581  inline void set_has_quad_att();
582  inline void clear_has_quad_att();
583  inline void set_has_light_nr();
584  inline void clear_has_light_nr();
585 
586  ::google::protobuf::UnknownFieldSet _unknown_fields_;
587 
588  ::std::string *name_;
589  ::mondschein::io::mbd::data_vector *ambient_;
590  ::mondschein::io::mbd::data_vector *diffuse_;
591  ::mondschein::io::mbd::data_vector *specular_;
592  ::mondschein::io::mbd::data_vector *position_;
593  ::mondschein::io::mbd::data_vector *direction_;
594  double exponent_;
595  double cutoff_;
596  double const_att_;
597  double lin_att_;
598  double quad_att_;
599  ::google::protobuf::uint32 light_nr_;
600 
601  mutable int _cached_size_;
602  ::google::protobuf::uint32 _has_bits_[(12 + 31) / 32];
603 
604  friend void protobuf_AddDesc_mbd_2eproto();
605  friend void protobuf_AssignDesc_mbd_2eproto();
606  friend void protobuf_ShutdownFile_mbd_2eproto();
607 
608  void InitAsDefaultInstance();
609  static data_light *default_instance_;
610  };
611  // -------------------------------------------------------------------
612 
613  class data_material : public ::google::protobuf::Message
614  {
615  public:
616  data_material();
617  virtual ~data_material();
618 
619  data_material(const data_material &from);
620 
621  inline data_material &operator=(const data_material &from)
622  {
623  CopyFrom(from);
624  return *this;
625  }
626 
627  inline const ::google::protobuf::UnknownFieldSet &unknown_fields() const
628  {
629  return _unknown_fields_;
630  }
631 
632  inline ::google::protobuf::UnknownFieldSet *mutable_unknown_fields()
633  {
634  return &_unknown_fields_;
635  }
636 
637  static const ::google::protobuf::Descriptor *descriptor();
638  static const data_material &default_instance();
639 
640  void Swap(data_material *other);
641 
642  // implements Message ----------------------------------------------
643 
644  data_material *New() const;
645  void CopyFrom(const ::google::protobuf::Message &from);
646  void MergeFrom(const ::google::protobuf::Message &from);
647  void CopyFrom(const data_material &from);
648  void MergeFrom(const data_material &from);
649  void Clear();
650  bool IsInitialized() const;
651 
652  int ByteSize() const;
653  bool MergePartialFromCodedStream(
654  ::google::protobuf::io::CodedInputStream *input);
655  void SerializeWithCachedSizes(
656  ::google::protobuf::io::CodedOutputStream *output) const;
657  ::google::protobuf::uint8 *SerializeWithCachedSizesToArray(::google::protobuf::uint8 *output) const;
658  int GetCachedSize() const { return _cached_size_; }
659  private:
660  void SharedCtor();
661  void SharedDtor();
662  void SetCachedSize(int size) const;
663  public:
664 
665  ::google::protobuf::Metadata GetMetadata() const;
666 
667  // nested types ----------------------------------------------------
668 
669  // accessors -------------------------------------------------------
670 
671  // required string name = 1;
672  inline bool has_name() const;
673  inline void clear_name();
674  static const int kNameFieldNumber = 1;
675  inline const ::std::string &name() const;
676  inline void set_name(const ::std::string &value);
677  inline void set_name(const char *value);
678  inline void set_name(const char *value, size_t size);
679  inline ::std::string *mutable_name();
680  inline ::std::string *release_name();
681  inline void set_allocated_name(::std::string *name);
682 
683  // required .mondschein.io.mbd.data.vector ambient = 2;
684  inline bool has_ambient() const;
685  inline void clear_ambient();
686  static const int kAmbientFieldNumber = 2;
687  inline const ::mondschein::io::mbd::data_vector &ambient() const;
688  inline ::mondschein::io::mbd::data_vector *mutable_ambient();
689  inline ::mondschein::io::mbd::data_vector *release_ambient();
690  inline void set_allocated_ambient(::mondschein::io::mbd::data_vector *ambient);
691 
692  // required .mondschein.io.mbd.data.vector diffuse = 3;
693  inline bool has_diffuse() const;
694  inline void clear_diffuse();
695  static const int kDiffuseFieldNumber = 3;
696  inline const ::mondschein::io::mbd::data_vector &diffuse() const;
697  inline ::mondschein::io::mbd::data_vector *mutable_diffuse();
698  inline ::mondschein::io::mbd::data_vector *release_diffuse();
699  inline void set_allocated_diffuse(::mondschein::io::mbd::data_vector *diffuse);
700 
701  // required .mondschein.io.mbd.data.vector specular = 4;
702  inline bool has_specular() const;
703  inline void clear_specular();
704  static const int kSpecularFieldNumber = 4;
705  inline const ::mondschein::io::mbd::data_vector &specular() const;
706  inline ::mondschein::io::mbd::data_vector *mutable_specular();
707  inline ::mondschein::io::mbd::data_vector *release_specular();
708  inline void set_allocated_specular(::mondschein::io::mbd::data_vector *specular);
709 
710  // required .mondschein.io.mbd.data.vector emission = 5;
711  inline bool has_emission() const;
712  inline void clear_emission();
713  static const int kEmissionFieldNumber = 5;
714  inline const ::mondschein::io::mbd::data_vector &emission() const;
715  inline ::mondschein::io::mbd::data_vector *mutable_emission();
716  inline ::mondschein::io::mbd::data_vector *release_emission();
717  inline void set_allocated_emission(::mondschein::io::mbd::data_vector *emission);
718 
719  // required double shininess = 6;
720  inline bool has_shininess() const;
721  inline void clear_shininess();
722  static const int kShininessFieldNumber = 6;
723  inline double shininess() const;
724  inline void set_shininess(double value);
725 
726  // @@protoc_insertion_point(class_scope:mondschein.io.mbd.data.material)
727  private:
728  inline void set_has_name();
729  inline void clear_has_name();
730  inline void set_has_ambient();
731  inline void clear_has_ambient();
732  inline void set_has_diffuse();
733  inline void clear_has_diffuse();
734  inline void set_has_specular();
735  inline void clear_has_specular();
736  inline void set_has_emission();
737  inline void clear_has_emission();
738  inline void set_has_shininess();
739  inline void clear_has_shininess();
740 
741  ::google::protobuf::UnknownFieldSet _unknown_fields_;
742 
743  ::std::string *name_;
744  ::mondschein::io::mbd::data_vector *ambient_;
745  ::mondschein::io::mbd::data_vector *diffuse_;
746  ::mondschein::io::mbd::data_vector *specular_;
747  ::mondschein::io::mbd::data_vector *emission_;
748  double shininess_;
749 
750  mutable int _cached_size_;
751  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
752 
753  friend void protobuf_AddDesc_mbd_2eproto();
754  friend void protobuf_AssignDesc_mbd_2eproto();
755  friend void protobuf_ShutdownFile_mbd_2eproto();
756 
757  void InitAsDefaultInstance();
758  static data_material *default_instance_;
759  };
760  // -------------------------------------------------------------------
761 
762  class data_mesh : public ::google::protobuf::Message
763  {
764  public:
765  data_mesh();
766  virtual ~data_mesh();
767 
768  data_mesh(const data_mesh &from);
769 
770  inline data_mesh &operator=(const data_mesh &from)
771  {
772  CopyFrom(from);
773  return *this;
774  }
775 
776  inline const ::google::protobuf::UnknownFieldSet &unknown_fields() const
777  {
778  return _unknown_fields_;
779  }
780 
781  inline ::google::protobuf::UnknownFieldSet *mutable_unknown_fields()
782  {
783  return &_unknown_fields_;
784  }
785 
786  static const ::google::protobuf::Descriptor *descriptor();
787  static const data_mesh &default_instance();
788 
789  void Swap(data_mesh *other);
790 
791  // implements Message ----------------------------------------------
792 
793  data_mesh *New() const;
794  void CopyFrom(const ::google::protobuf::Message &from);
795  void MergeFrom(const ::google::protobuf::Message &from);
796  void CopyFrom(const data_mesh &from);
797  void MergeFrom(const data_mesh &from);
798  void Clear();
799  bool IsInitialized() const;
800 
801  int ByteSize() const;
802  bool MergePartialFromCodedStream(
803  ::google::protobuf::io::CodedInputStream *input);
804  void SerializeWithCachedSizes(
805  ::google::protobuf::io::CodedOutputStream *output) const;
806  ::google::protobuf::uint8 *SerializeWithCachedSizesToArray(::google::protobuf::uint8 *output) const;
807  int GetCachedSize() const { return _cached_size_; }
808  private:
809  void SharedCtor();
810  void SharedDtor();
811  void SetCachedSize(int size) const;
812  public:
813 
814  ::google::protobuf::Metadata GetMetadata() const;
815 
816  // nested types ----------------------------------------------------
817 
818  // accessors -------------------------------------------------------
819 
820  // required string name = 1;
821  inline bool has_name() const;
822  inline void clear_name();
823  static const int kNameFieldNumber = 1;
824  inline const ::std::string &name() const;
825  inline void set_name(const ::std::string &value);
826  inline void set_name(const char *value);
827  inline void set_name(const char *value, size_t size);
828  inline ::std::string *mutable_name();
829  inline ::std::string *release_name();
830  inline void set_allocated_name(::std::string *name);
831 
832  // repeated .mondschein.io.mbd.data.vector v = 2;
833  inline int v_size() const;
834  inline void clear_v();
835  static const int kVFieldNumber = 2;
836  inline const ::mondschein::io::mbd::data_vector &v(int index) const;
837  inline ::mondschein::io::mbd::data_vector *mutable_v(int index);
838  inline ::mondschein::io::mbd::data_vector *add_v();
839  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > &
840  v() const;
841  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > *
842  mutable_v();
843 
844  // repeated .mondschein.io.mbd.data.vector vn = 3;
845  inline int vn_size() const;
846  inline void clear_vn();
847  static const int kVnFieldNumber = 3;
848  inline const ::mondschein::io::mbd::data_vector &vn(int index) const;
849  inline ::mondschein::io::mbd::data_vector *mutable_vn(int index);
850  inline ::mondschein::io::mbd::data_vector *add_vn();
851  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > &
852  vn() const;
853  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > *
854  mutable_vn();
855 
856  // repeated .mondschein.io.mbd.data.vector vt = 4;
857  inline int vt_size() const;
858  inline void clear_vt();
859  static const int kVtFieldNumber = 4;
860  inline const ::mondschein::io::mbd::data_vector &vt(int index) const;
861  inline ::mondschein::io::mbd::data_vector *mutable_vt(int index);
862  inline ::mondschein::io::mbd::data_vector *add_vt();
863  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > &
864  vt() const;
865  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > *
866  mutable_vt();
867 
868  // repeated .mondschein.io.mbd.data.vector vc = 5;
869  inline int vc_size() const;
870  inline void clear_vc();
871  static const int kVcFieldNumber = 5;
872  inline const ::mondschein::io::mbd::data_vector &vc(int index) const;
873  inline ::mondschein::io::mbd::data_vector *mutable_vc(int index);
874  inline ::mondschein::io::mbd::data_vector *add_vc();
875  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > &
876  vc() const;
877  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > *
878  mutable_vc();
879 
880  // @@protoc_insertion_point(class_scope:mondschein.io.mbd.data.mesh)
881  private:
882  inline void set_has_name();
883  inline void clear_has_name();
884 
885  ::google::protobuf::UnknownFieldSet _unknown_fields_;
886 
887  ::std::string *name_;
888  ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > v_;
889  ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > vn_;
890  ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > vt_;
891  ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > vc_;
892 
893  mutable int _cached_size_;
894  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
895 
896  friend void protobuf_AddDesc_mbd_2eproto();
897  friend void protobuf_AssignDesc_mbd_2eproto();
898  friend void protobuf_ShutdownFile_mbd_2eproto();
899 
900  void InitAsDefaultInstance();
901  static data_mesh *default_instance_;
902  };
903  // -------------------------------------------------------------------
904 
905  class data_pose : public ::google::protobuf::Message
906  {
907  public:
908  data_pose();
909  virtual ~data_pose();
910 
911  data_pose(const data_pose &from);
912 
913  inline data_pose &operator=(const data_pose &from)
914  {
915  CopyFrom(from);
916  return *this;
917  }
918 
919  inline const ::google::protobuf::UnknownFieldSet &unknown_fields() const
920  {
921  return _unknown_fields_;
922  }
923 
924  inline ::google::protobuf::UnknownFieldSet *mutable_unknown_fields()
925  {
926  return &_unknown_fields_;
927  }
928 
929  static const ::google::protobuf::Descriptor *descriptor();
930  static const data_pose &default_instance();
931 
932  void Swap(data_pose *other);
933 
934  // implements Message ----------------------------------------------
935 
936  data_pose *New() const;
937  void CopyFrom(const ::google::protobuf::Message &from);
938  void MergeFrom(const ::google::protobuf::Message &from);
939  void CopyFrom(const data_pose &from);
940  void MergeFrom(const data_pose &from);
941  void Clear();
942  bool IsInitialized() const;
943 
944  int ByteSize() const;
945  bool MergePartialFromCodedStream(
946  ::google::protobuf::io::CodedInputStream *input);
947  void SerializeWithCachedSizes(
948  ::google::protobuf::io::CodedOutputStream *output) const;
949  ::google::protobuf::uint8 *SerializeWithCachedSizesToArray(::google::protobuf::uint8 *output) const;
950  int GetCachedSize() const { return _cached_size_; }
951  private:
952  void SharedCtor();
953  void SharedDtor();
954  void SetCachedSize(int size) const;
955  public:
956 
957  ::google::protobuf::Metadata GetMetadata() const;
958 
959  // nested types ----------------------------------------------------
960 
961  // accessors -------------------------------------------------------
962 
963  // required string name = 1;
964  inline bool has_name() const;
965  inline void clear_name();
966  static const int kNameFieldNumber = 1;
967  inline const ::std::string &name() const;
968  inline void set_name(const ::std::string &value);
969  inline void set_name(const char *value);
970  inline void set_name(const char *value, size_t size);
971  inline ::std::string *mutable_name();
972  inline ::std::string *release_name();
973  inline void set_allocated_name(::std::string *name);
974 
975  // required .mondschein.io.mbd.data.vector c1 = 2;
976  inline bool has_c1() const;
977  inline void clear_c1();
978  static const int kC1FieldNumber = 2;
979  inline const ::mondschein::io::mbd::data_vector &c1() const;
980  inline ::mondschein::io::mbd::data_vector *mutable_c1();
981  inline ::mondschein::io::mbd::data_vector *release_c1();
982  inline void set_allocated_c1(::mondschein::io::mbd::data_vector *c1);
983 
984  // required .mondschein.io.mbd.data.vector c2 = 3;
985  inline bool has_c2() const;
986  inline void clear_c2();
987  static const int kC2FieldNumber = 3;
988  inline const ::mondschein::io::mbd::data_vector &c2() const;
989  inline ::mondschein::io::mbd::data_vector *mutable_c2();
990  inline ::mondschein::io::mbd::data_vector *release_c2();
991  inline void set_allocated_c2(::mondschein::io::mbd::data_vector *c2);
992 
993  // required .mondschein.io.mbd.data.vector c3 = 4;
994  inline bool has_c3() const;
995  inline void clear_c3();
996  static const int kC3FieldNumber = 4;
997  inline const ::mondschein::io::mbd::data_vector &c3() const;
998  inline ::mondschein::io::mbd::data_vector *mutable_c3();
999  inline ::mondschein::io::mbd::data_vector *release_c3();
1000  inline void set_allocated_c3(::mondschein::io::mbd::data_vector *c3);
1001 
1002  // required .mondschein.io.mbd.data.vector c4 = 5;
1003  inline bool has_c4() const;
1004  inline void clear_c4();
1005  static const int kC4FieldNumber = 5;
1006  inline const ::mondschein::io::mbd::data_vector &c4() const;
1007  inline ::mondschein::io::mbd::data_vector *mutable_c4();
1008  inline ::mondschein::io::mbd::data_vector *release_c4();
1009  inline void set_allocated_c4(::mondschein::io::mbd::data_vector *c4);
1010 
1011  // @@protoc_insertion_point(class_scope:mondschein.io.mbd.data.pose)
1012  private:
1013  inline void set_has_name();
1014  inline void clear_has_name();
1015  inline void set_has_c1();
1016  inline void clear_has_c1();
1017  inline void set_has_c2();
1018  inline void clear_has_c2();
1019  inline void set_has_c3();
1020  inline void clear_has_c3();
1021  inline void set_has_c4();
1022  inline void clear_has_c4();
1023 
1024  ::google::protobuf::UnknownFieldSet _unknown_fields_;
1025 
1026  ::std::string *name_;
1027  ::mondschein::io::mbd::data_vector *c1_;
1028  ::mondschein::io::mbd::data_vector *c2_;
1029  ::mondschein::io::mbd::data_vector *c3_;
1030  ::mondschein::io::mbd::data_vector *c4_;
1031 
1032  mutable int _cached_size_;
1033  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
1034 
1035  friend void protobuf_AddDesc_mbd_2eproto();
1036  friend void protobuf_AssignDesc_mbd_2eproto();
1037  friend void protobuf_ShutdownFile_mbd_2eproto();
1038 
1039  void InitAsDefaultInstance();
1040  static data_pose *default_instance_;
1041  };
1042  // -------------------------------------------------------------------
1043 
1044  class data_texture : public ::google::protobuf::Message
1045  {
1046  public:
1047  data_texture();
1048  virtual ~data_texture();
1049 
1050  data_texture(const data_texture &from);
1051 
1052  inline data_texture &operator=(const data_texture &from)
1053  {
1054  CopyFrom(from);
1055  return *this;
1056  }
1057 
1058  inline const ::google::protobuf::UnknownFieldSet &unknown_fields() const
1059  {
1060  return _unknown_fields_;
1061  }
1062 
1063  inline ::google::protobuf::UnknownFieldSet *mutable_unknown_fields()
1064  {
1065  return &_unknown_fields_;
1066  }
1067 
1068  static const ::google::protobuf::Descriptor *descriptor();
1069  static const data_texture &default_instance();
1070 
1071  void Swap(data_texture *other);
1072 
1073  // implements Message ----------------------------------------------
1074 
1075  data_texture *New() const;
1076  void CopyFrom(const ::google::protobuf::Message &from);
1077  void MergeFrom(const ::google::protobuf::Message &from);
1078  void CopyFrom(const data_texture &from);
1079  void MergeFrom(const data_texture &from);
1080  void Clear();
1081  bool IsInitialized() const;
1082 
1083  int ByteSize() const;
1084  bool MergePartialFromCodedStream(
1085  ::google::protobuf::io::CodedInputStream *input);
1086  void SerializeWithCachedSizes(
1087  ::google::protobuf::io::CodedOutputStream *output) const;
1088  ::google::protobuf::uint8 *SerializeWithCachedSizesToArray(::google::protobuf::uint8 *output) const;
1089  int GetCachedSize() const { return _cached_size_; }
1090  private:
1091  void SharedCtor();
1092  void SharedDtor();
1093  void SetCachedSize(int size) const;
1094  public:
1095 
1096  ::google::protobuf::Metadata GetMetadata() const;
1097 
1098  // nested types ----------------------------------------------------
1099 
1100  // accessors -------------------------------------------------------
1101 
1102  // required string name = 1;
1103  inline bool has_name() const;
1104  inline void clear_name();
1105  static const int kNameFieldNumber = 1;
1106  inline const ::std::string &name() const;
1107  inline void set_name(const ::std::string &value);
1108  inline void set_name(const char *value);
1109  inline void set_name(const char *value, size_t size);
1110  inline ::std::string *mutable_name();
1111  inline ::std::string *release_name();
1112  inline void set_allocated_name(::std::string *name);
1113 
1114  // required uint32 unit = 2;
1115  inline bool has_unit() const;
1116  inline void clear_unit();
1117  static const int kUnitFieldNumber = 2;
1118  inline ::google::protobuf::uint32 unit() const;
1119  inline void set_unit(::google::protobuf::uint32 value);
1120 
1121  // required .mondschein.io.mbd.texture_filtering_e texture_filter = 3;
1122  inline bool has_texture_filter() const;
1123  inline void clear_texture_filter();
1124  static const int kTextureFilterFieldNumber = 3;
1126  inline void set_texture_attribs_filter(::mondschein::io::mbd::texture_filtering_e value);
1127 
1128  // required uint32 anisotropic_filter = 4;
1129  inline bool has_anisotropic_filter() const;
1130  inline void clear_anisotropic_filter();
1131  static const int kAnisotropicFilterFieldNumber = 4;
1132  inline ::google::protobuf::uint32 anisotropic_filter() const;
1133  inline void set_anisotropic_filter(::google::protobuf::uint32 value);
1134 
1135  // required string image = 5;
1136  inline bool has_image() const;
1137  inline void clear_image();
1138  static const int kImageFieldNumber = 5;
1139  inline const ::std::string &image() const;
1140  inline void set_image(const ::std::string &value);
1141  inline void set_image(const char *value);
1142  inline void set_image(const char *value, size_t size);
1143  inline ::std::string *mutable_image();
1144  inline ::std::string *release_image();
1145  inline void set_allocated_image(::std::string *image);
1146 
1147  // optional string format = 6;
1148  inline bool has_format() const;
1149  inline void clear_format();
1150  static const int kFormatFieldNumber = 6;
1151  inline const ::std::string &format() const;
1152  inline void set_format(const ::std::string &value);
1153  inline void set_format(const char *value);
1154  inline void set_format(const char *value, size_t size);
1155  inline ::std::string *mutable_format();
1156  inline ::std::string *release_format();
1157  inline void set_allocated_format(::std::string *format);
1158 
1159  // @@protoc_insertion_point(class_scope:mondschein.io.mbd.data.texture)
1160  private:
1161  inline void set_has_name();
1162  inline void clear_has_name();
1163  inline void set_has_unit();
1164  inline void clear_has_unit();
1165  inline void set_has_texture_filter();
1166  inline void clear_has_texture_filter();
1167  inline void set_has_anisotropic_filter();
1168  inline void clear_has_anisotropic_filter();
1169  inline void set_has_image();
1170  inline void clear_has_image();
1171  inline void set_has_format();
1172  inline void clear_has_format();
1173 
1174  ::google::protobuf::UnknownFieldSet _unknown_fields_;
1175 
1176  ::std::string *name_;
1178  int texture_filter_;
1179  ::std::string *image_;
1180  ::std::string *format_;
1181  ::google::protobuf::uint32 anisotropic_filter_;
1182 
1183  mutable int _cached_size_;
1184  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
1185 
1186  friend void protobuf_AddDesc_mbd_2eproto();
1187  friend void protobuf_AssignDesc_mbd_2eproto();
1188  friend void protobuf_ShutdownFile_mbd_2eproto();
1189 
1190  void InitAsDefaultInstance();
1191  static data_texture *default_instance_;
1192  };
1193  // -------------------------------------------------------------------
1194 
1195  class data_scenegraph_attribs_tuple : public ::google::protobuf::Message
1196  {
1197  public:
1198  data_scenegraph_attribs_tuple();
1199  virtual ~data_scenegraph_attribs_tuple();
1200 
1201  data_scenegraph_attribs_tuple(const data_scenegraph_attribs_tuple &from);
1202 
1203  inline data_scenegraph_attribs_tuple &operator=(const data_scenegraph_attribs_tuple &from)
1204  {
1205  CopyFrom(from);
1206  return *this;
1207  }
1208 
1209  inline const ::google::protobuf::UnknownFieldSet &unknown_fields() const
1210  {
1211  return _unknown_fields_;
1212  }
1213 
1214  inline ::google::protobuf::UnknownFieldSet *mutable_unknown_fields()
1215  {
1216  return &_unknown_fields_;
1217  }
1218 
1219  static const ::google::protobuf::Descriptor *descriptor();
1220  static const data_scenegraph_attribs_tuple &default_instance();
1221 
1222  void Swap(data_scenegraph_attribs_tuple *other);
1223 
1224  // implements Message ----------------------------------------------
1225 
1226  data_scenegraph_attribs_tuple *New() const;
1227  void CopyFrom(const ::google::protobuf::Message &from);
1228  void MergeFrom(const ::google::protobuf::Message &from);
1229  void CopyFrom(const data_scenegraph_attribs_tuple &from);
1230  void MergeFrom(const data_scenegraph_attribs_tuple &from);
1231  void Clear();
1232  bool IsInitialized() const;
1233 
1234  int ByteSize() const;
1235  bool MergePartialFromCodedStream(
1236  ::google::protobuf::io::CodedInputStream *input);
1237  void SerializeWithCachedSizes(
1238  ::google::protobuf::io::CodedOutputStream *output) const;
1239  ::google::protobuf::uint8 *SerializeWithCachedSizesToArray(::google::protobuf::uint8 *output) const;
1240  int GetCachedSize() const { return _cached_size_; }
1241  private:
1242  void SharedCtor();
1243  void SharedDtor();
1244  void SetCachedSize(int size) const;
1245  public:
1246 
1247  ::google::protobuf::Metadata GetMetadata() const;
1248 
1249  // nested types ----------------------------------------------------
1250 
1251  // accessors -------------------------------------------------------
1252 
1253  // required uint32 src = 1;
1254  inline bool has_src() const;
1255  inline void clear_src();
1256  static const int kSrcFieldNumber = 1;
1258  inline void set_src(::google::protobuf::uint32 value);
1259 
1260  // required uint32 dst = 2;
1261  inline bool has_dst() const;
1262  inline void clear_dst();
1263  static const int kDstFieldNumber = 2;
1265  inline void set_dst(::google::protobuf::uint32 value);
1266 
1267  // @@protoc_insertion_point(class_scope:mondschein.io.mbd.data.scenegraph.tuple)
1268  private:
1269  inline void set_has_src();
1270  inline void clear_has_src();
1271  inline void set_has_dst();
1272  inline void clear_has_dst();
1273 
1274  ::google::protobuf::UnknownFieldSet _unknown_fields_;
1275 
1278 
1279  mutable int _cached_size_;
1280  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
1281 
1282  friend void protobuf_AddDesc_mbd_2eproto();
1283  friend void protobuf_AssignDesc_mbd_2eproto();
1284  friend void protobuf_ShutdownFile_mbd_2eproto();
1285 
1286  void InitAsDefaultInstance();
1287  static data_scenegraph_attribs_tuple *default_instance_;
1288  };
1289  // -------------------------------------------------------------------
1290 
1291  class data_scenegraph : public ::google::protobuf::Message
1292  {
1293  public:
1294  data_scenegraph();
1295  virtual ~data_scenegraph();
1296 
1297  data_scenegraph(const data_scenegraph &from);
1298 
1299  inline data_scenegraph &operator=(const data_scenegraph &from)
1300  {
1301  CopyFrom(from);
1302  return *this;
1303  }
1304 
1305  inline const ::google::protobuf::UnknownFieldSet &unknown_fields() const
1306  {
1307  return _unknown_fields_;
1308  }
1309 
1310  inline ::google::protobuf::UnknownFieldSet *mutable_unknown_fields()
1311  {
1312  return &_unknown_fields_;
1313  }
1314 
1315  static const ::google::protobuf::Descriptor *descriptor();
1316  static const data_scenegraph &default_instance();
1317 
1318  void Swap(data_scenegraph *other);
1319 
1320  // implements Message ----------------------------------------------
1321 
1322  data_scenegraph *New() const;
1323  void CopyFrom(const ::google::protobuf::Message &from);
1324  void MergeFrom(const ::google::protobuf::Message &from);
1325  void CopyFrom(const data_scenegraph &from);
1326  void MergeFrom(const data_scenegraph &from);
1327  void Clear();
1328  bool IsInitialized() const;
1329 
1330  int ByteSize() const;
1331  bool MergePartialFromCodedStream(
1332  ::google::protobuf::io::CodedInputStream *input);
1333  void SerializeWithCachedSizes(
1334  ::google::protobuf::io::CodedOutputStream *output) const;
1335  ::google::protobuf::uint8 *SerializeWithCachedSizesToArray(::google::protobuf::uint8 *output) const;
1336  int GetCachedSize() const { return _cached_size_; }
1337  private:
1338  void SharedCtor();
1339  void SharedDtor();
1340  void SetCachedSize(int size) const;
1341  public:
1342 
1343  ::google::protobuf::Metadata GetMetadata() const;
1344 
1345  // nested types ----------------------------------------------------
1346 
1347  typedef data_scenegraph_attribs_tuple tuple;
1348 
1349  // accessors -------------------------------------------------------
1350 
1351  // required string name = 1;
1352  inline bool has_name() const;
1353  inline void clear_name();
1354  static const int kNameFieldNumber = 1;
1355  inline const ::std::string &name() const;
1356  inline void set_name(const ::std::string &value);
1357  inline void set_name(const char *value);
1358  inline void set_name(const char *value, size_t size);
1359  inline ::std::string *mutable_name();
1360  inline ::std::string *release_name();
1361  inline void set_allocated_name(::std::string *name);
1362 
1363  // repeated string nodes = 2;
1364  inline int nodes_size() const;
1365  inline void clear_nodes();
1366  static const int kNodesFieldNumber = 2;
1367  inline const ::std::string &nodes(int index) const;
1368  inline ::std::string *mutable_nodes(int index);
1369  inline void set_nodes(int index, const ::std::string &value);
1370  inline void set_nodes(int index, const char *value);
1371  inline void set_nodes(int index, const char *value, size_t size);
1372  inline ::std::string *add_nodes();
1373  inline void add_nodes(const ::std::string &value);
1374  inline void add_nodes(const char *value);
1375  inline void add_nodes(const char *value, size_t size);
1376  inline const ::google::protobuf::RepeatedPtrField< ::std::string> &nodes() const;
1377  inline ::google::protobuf::RepeatedPtrField< ::std::string> *mutable_nodes();
1378 
1379  // repeated .mondschein.io.mbd.data.scenegraph.tuple edges = 3;
1380  inline int edges_size() const;
1381  inline void clear_edges();
1382  static const int kEdgesFieldNumber = 3;
1383  inline const ::mondschein::io::mbd::data_scenegraph_attribs_tuple &edges(int index) const;
1384  inline ::mondschein::io::mbd::data_scenegraph_attribs_tuple *mutable_edges(int index);
1385  inline ::mondschein::io::mbd::data_scenegraph_attribs_tuple *add_edges();
1386  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_scenegraph_attribs_tuple > &
1387  edges() const;
1388  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_scenegraph_attribs_tuple > *
1389  mutable_edges();
1390 
1391  // @@protoc_insertion_point(class_scope:mondschein.io.mbd.data.scenegraph)
1392  private:
1393  inline void set_has_name();
1394  inline void clear_has_name();
1395 
1396  ::google::protobuf::UnknownFieldSet _unknown_fields_;
1397 
1398  ::std::string *name_;
1399  ::google::protobuf::RepeatedPtrField< ::std::string> nodes_;
1400  ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_scenegraph_attribs_tuple > edges_;
1401 
1402  mutable int _cached_size_;
1403  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
1404 
1405  friend void protobuf_AddDesc_mbd_2eproto();
1406  friend void protobuf_AssignDesc_mbd_2eproto();
1407  friend void protobuf_ShutdownFile_mbd_2eproto();
1408 
1409  void InitAsDefaultInstance();
1410  static data_scenegraph *default_instance_;
1411  };
1412  // -------------------------------------------------------------------
1413 
1414  class data_beziercurve : public ::google::protobuf::Message
1415  {
1416  public:
1417  data_beziercurve();
1418  virtual ~data_beziercurve();
1419 
1420  data_beziercurve(const data_beziercurve &from);
1421 
1422  inline data_beziercurve &operator=(const data_beziercurve &from)
1423  {
1424  CopyFrom(from);
1425  return *this;
1426  }
1427 
1428  inline const ::google::protobuf::UnknownFieldSet &unknown_fields() const
1429  {
1430  return _unknown_fields_;
1431  }
1432 
1433  inline ::google::protobuf::UnknownFieldSet *mutable_unknown_fields()
1434  {
1435  return &_unknown_fields_;
1436  }
1437 
1438  static const ::google::protobuf::Descriptor *descriptor();
1439  static const data_beziercurve &default_instance();
1440 
1441  void Swap(data_beziercurve *other);
1442 
1443  // implements Message ----------------------------------------------
1444 
1445  data_beziercurve *New() const;
1446  void CopyFrom(const ::google::protobuf::Message &from);
1447  void MergeFrom(const ::google::protobuf::Message &from);
1448  void CopyFrom(const data_beziercurve &from);
1449  void MergeFrom(const data_beziercurve &from);
1450  void Clear();
1451  bool IsInitialized() const;
1452 
1453  int ByteSize() const;
1454  bool MergePartialFromCodedStream(
1455  ::google::protobuf::io::CodedInputStream *input);
1456  void SerializeWithCachedSizes(
1457  ::google::protobuf::io::CodedOutputStream *output) const;
1458  ::google::protobuf::uint8 *SerializeWithCachedSizesToArray(::google::protobuf::uint8 *output) const;
1459  int GetCachedSize() const { return _cached_size_; }
1460  private:
1461  void SharedCtor();
1462  void SharedDtor();
1463  void SetCachedSize(int size) const;
1464  public:
1465 
1466  ::google::protobuf::Metadata GetMetadata() const;
1467 
1468  // nested types ----------------------------------------------------
1469 
1470  // accessors -------------------------------------------------------
1471 
1472  // required string name = 1;
1473  inline bool has_name() const;
1474  inline void clear_name();
1475  static const int kNameFieldNumber = 1;
1476  inline const ::std::string &name() const;
1477  inline void set_name(const ::std::string &value);
1478  inline void set_name(const char *value);
1479  inline void set_name(const char *value, size_t size);
1480  inline ::std::string *mutable_name();
1481  inline ::std::string *release_name();
1482  inline void set_allocated_name(::std::string *name);
1483 
1484  // repeated .mondschein.io.mbd.data.vector points = 2;
1485  inline int points_size() const;
1486  inline void clear_points();
1487  static const int kPointsFieldNumber = 2;
1488  inline const ::mondschein::io::mbd::data_vector &points(int index) const;
1489  inline ::mondschein::io::mbd::data_vector *mutable_points(int index);
1490  inline ::mondschein::io::mbd::data_vector *add_points();
1491  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > &
1492  points() const;
1493  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > *
1494  mutable_points();
1495 
1496  // optional .mondschein.io.mbd.normal_e normals = 3;
1497  inline bool has_normals() const;
1498  inline void clear_normals();
1499  static const int kNormalsFieldNumber = 3;
1500  inline ::mondschein::io::mbd::normal_e normals() const;
1501  inline void set_normals(::mondschein::io::mbd::normal_e value);
1502 
1503  // @@protoc_insertion_point(class_scope:mondschein.io.mbd.data.beziercurve)
1504  private:
1505  inline void set_has_name();
1506  inline void clear_has_name();
1507  inline void set_has_normals();
1508  inline void clear_has_normals();
1509 
1510  ::google::protobuf::UnknownFieldSet _unknown_fields_;
1511 
1512  ::std::string *name_;
1513  ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > points_;
1514  int normals_;
1515 
1516  mutable int _cached_size_;
1517  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
1518 
1519  friend void protobuf_AddDesc_mbd_2eproto();
1520  friend void protobuf_AssignDesc_mbd_2eproto();
1521  friend void protobuf_ShutdownFile_mbd_2eproto();
1522 
1523  void InitAsDefaultInstance();
1524  static data_beziercurve *default_instance_;
1525  };
1526  // -------------------------------------------------------------------
1527 
1528  class data_bezierpatch : public ::google::protobuf::Message
1529  {
1530  public:
1531  data_bezierpatch();
1532  virtual ~data_bezierpatch();
1533 
1534  data_bezierpatch(const data_bezierpatch &from);
1535 
1536  inline data_bezierpatch &operator=(const data_bezierpatch &from)
1537  {
1538  CopyFrom(from);
1539  return *this;
1540  }
1541 
1542  inline const ::google::protobuf::UnknownFieldSet &unknown_fields() const
1543  {
1544  return _unknown_fields_;
1545  }
1546 
1547  inline ::google::protobuf::UnknownFieldSet *mutable_unknown_fields()
1548  {
1549  return &_unknown_fields_;
1550  }
1551 
1552  static const ::google::protobuf::Descriptor *descriptor();
1553  static const data_bezierpatch &default_instance();
1554 
1555  void Swap(data_bezierpatch *other);
1556 
1557  // implements Message ----------------------------------------------
1558 
1559  data_bezierpatch *New() const;
1560  void CopyFrom(const ::google::protobuf::Message &from);
1561  void MergeFrom(const ::google::protobuf::Message &from);
1562  void CopyFrom(const data_bezierpatch &from);
1563  void MergeFrom(const data_bezierpatch &from);
1564  void Clear();
1565  bool IsInitialized() const;
1566 
1567  int ByteSize() const;
1568  bool MergePartialFromCodedStream(
1569  ::google::protobuf::io::CodedInputStream *input);
1570  void SerializeWithCachedSizes(
1571  ::google::protobuf::io::CodedOutputStream *output) const;
1572  ::google::protobuf::uint8 *SerializeWithCachedSizesToArray(::google::protobuf::uint8 *output) const;
1573  int GetCachedSize() const { return _cached_size_; }
1574  private:
1575  void SharedCtor();
1576  void SharedDtor();
1577  void SetCachedSize(int size) const;
1578  public:
1579 
1580  ::google::protobuf::Metadata GetMetadata() const;
1581 
1582  // nested types ----------------------------------------------------
1583 
1584  // accessors -------------------------------------------------------
1585 
1586  // required string name = 1;
1587  inline bool has_name() const;
1588  inline void clear_name();
1589  static const int kNameFieldNumber = 1;
1590  inline const ::std::string &name() const;
1591  inline void set_name(const ::std::string &value);
1592  inline void set_name(const char *value);
1593  inline void set_name(const char *value, size_t size);
1594  inline ::std::string *mutable_name();
1595  inline ::std::string *release_name();
1596  inline void set_allocated_name(::std::string *name);
1597 
1598  // repeated .mondschein.io.mbd.data.beziercurve curves = 2;
1599  inline int curves_size() const;
1600  inline void clear_curves();
1601  static const int kCurvesFieldNumber = 2;
1602  inline const ::mondschein::io::mbd::data_beziercurve &curves(int index) const;
1603  inline ::mondschein::io::mbd::data_beziercurve *mutable_curves(int index);
1604  inline ::mondschein::io::mbd::data_beziercurve *add_curves();
1605  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_beziercurve > &
1606  curves() const;
1607  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_beziercurve > *
1608  mutable_curves();
1609 
1610  // optional .mondschein.io.mbd.normal_e normals = 3;
1611  inline bool has_normals() const;
1612  inline void clear_normals();
1613  static const int kNormalsFieldNumber = 3;
1614  inline ::mondschein::io::mbd::normal_e normals() const;
1615  inline void set_normals(::mondschein::io::mbd::normal_e value);
1616 
1617  // @@protoc_insertion_point(class_scope:mondschein.io.mbd.data.bezierpatch)
1618  private:
1619  inline void set_has_name();
1620  inline void clear_has_name();
1621  inline void set_has_normals();
1622  inline void clear_has_normals();
1623 
1624  ::google::protobuf::UnknownFieldSet _unknown_fields_;
1625 
1626  ::std::string *name_;
1627  ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_beziercurve > curves_;
1628  int normals_;
1629 
1630  mutable int _cached_size_;
1631  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
1632 
1633  friend void protobuf_AddDesc_mbd_2eproto();
1634  friend void protobuf_AssignDesc_mbd_2eproto();
1635  friend void protobuf_ShutdownFile_mbd_2eproto();
1636 
1637  void InitAsDefaultInstance();
1638  static data_bezierpatch *default_instance_;
1639  };
1640  // -------------------------------------------------------------------
1641 
1642  class data_nurbscurve : public ::google::protobuf::Message
1643  {
1644  public:
1645  data_nurbscurve();
1646  virtual ~data_nurbscurve();
1647 
1648  data_nurbscurve(const data_nurbscurve &from);
1649 
1650  inline data_nurbscurve &operator=(const data_nurbscurve &from)
1651  {
1652  CopyFrom(from);
1653  return *this;
1654  }
1655 
1656  inline const ::google::protobuf::UnknownFieldSet &unknown_fields() const
1657  {
1658  return _unknown_fields_;
1659  }
1660 
1661  inline ::google::protobuf::UnknownFieldSet *mutable_unknown_fields()
1662  {
1663  return &_unknown_fields_;
1664  }
1665 
1666  static const ::google::protobuf::Descriptor *descriptor();
1667  static const data_nurbscurve &default_instance();
1668 
1669  void Swap(data_nurbscurve *other);
1670 
1671  // implements Message ----------------------------------------------
1672 
1673  data_nurbscurve *New() const;
1674  void CopyFrom(const ::google::protobuf::Message &from);
1675  void MergeFrom(const ::google::protobuf::Message &from);
1676  void CopyFrom(const data_nurbscurve &from);
1677  void MergeFrom(const data_nurbscurve &from);
1678  void Clear();
1679  bool IsInitialized() const;
1680 
1681  int ByteSize() const;
1682  bool MergePartialFromCodedStream(
1683  ::google::protobuf::io::CodedInputStream *input);
1684  void SerializeWithCachedSizes(
1685  ::google::protobuf::io::CodedOutputStream *output) const;
1686  ::google::protobuf::uint8 *SerializeWithCachedSizesToArray(::google::protobuf::uint8 *output) const;
1687  int GetCachedSize() const { return _cached_size_; }
1688  private:
1689  void SharedCtor();
1690  void SharedDtor();
1691  void SetCachedSize(int size) const;
1692  public:
1693 
1694  ::google::protobuf::Metadata GetMetadata() const;
1695 
1696  // nested types ----------------------------------------------------
1697 
1698  // accessors -------------------------------------------------------
1699 
1700  // required string name = 1;
1701  inline bool has_name() const;
1702  inline void clear_name();
1703  static const int kNameFieldNumber = 1;
1704  inline const ::std::string &name() const;
1705  inline void set_name(const ::std::string &value);
1706  inline void set_name(const char *value);
1707  inline void set_name(const char *value, size_t size);
1708  inline ::std::string *mutable_name();
1709  inline ::std::string *release_name();
1710  inline void set_allocated_name(::std::string *name);
1711 
1712  // required uint32 dimension = 2;
1713  inline bool has_dimension() const;
1714  inline void clear_dimension();
1715  static const int kDimensionFieldNumber = 2;
1716  inline ::google::protobuf::uint32 dimension() const;
1717  inline void set_dimension(::google::protobuf::uint32 value);
1718 
1719  // repeated .mondschein.io.mbd.data.vector points = 3;
1720  inline int points_size() const;
1721  inline void clear_points();
1722  static const int kPointsFieldNumber = 3;
1723  inline const ::mondschein::io::mbd::data_vector &points(int index) const;
1724  inline ::mondschein::io::mbd::data_vector *mutable_points(int index);
1725  inline ::mondschein::io::mbd::data_vector *add_points();
1726  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > &
1727  points() const;
1728  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > *
1729  mutable_points();
1730 
1731  // optional .mondschein.io.mbd.normal_e normals = 4;
1732  inline bool has_normals() const;
1733  inline void clear_normals();
1734  static const int kNormalsFieldNumber = 4;
1735  inline ::mondschein::io::mbd::normal_e normals() const;
1736  inline void set_normals(::mondschein::io::mbd::normal_e value);
1737 
1738  // @@protoc_insertion_point(class_scope:mondschein.io.mbd.data.nurbscurve)
1739  private:
1740  inline void set_has_name();
1741  inline void clear_has_name();
1742  inline void set_has_dimension();
1743  inline void clear_has_dimension();
1744  inline void set_has_normals();
1745  inline void clear_has_normals();
1746 
1747  ::google::protobuf::UnknownFieldSet _unknown_fields_;
1748 
1749  ::std::string *name_;
1750  ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > points_;
1751  ::google::protobuf::uint32 dimension_;
1752  int normals_;
1753 
1754  mutable int _cached_size_;
1755  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
1756 
1757  friend void protobuf_AddDesc_mbd_2eproto();
1758  friend void protobuf_AssignDesc_mbd_2eproto();
1759  friend void protobuf_ShutdownFile_mbd_2eproto();
1760 
1761  void InitAsDefaultInstance();
1762  static data_nurbscurve *default_instance_;
1763  };
1764  // -------------------------------------------------------------------
1765 
1766  class data_nurbspatch : public ::google::protobuf::Message
1767  {
1768  public:
1769  data_nurbspatch();
1770  virtual ~data_nurbspatch();
1771 
1772  data_nurbspatch(const data_nurbspatch &from);
1773 
1774  inline data_nurbspatch &operator=(const data_nurbspatch &from)
1775  {
1776  CopyFrom(from);
1777  return *this;
1778  }
1779 
1780  inline const ::google::protobuf::UnknownFieldSet &unknown_fields() const
1781  {
1782  return _unknown_fields_;
1783  }
1784 
1785  inline ::google::protobuf::UnknownFieldSet *mutable_unknown_fields()
1786  {
1787  return &_unknown_fields_;
1788  }
1789 
1790  static const ::google::protobuf::Descriptor *descriptor();
1791  static const data_nurbspatch &default_instance();
1792 
1793  void Swap(data_nurbspatch *other);
1794 
1795  // implements Message ----------------------------------------------
1796 
1797  data_nurbspatch *New() const;
1798  void CopyFrom(const ::google::protobuf::Message &from);
1799  void MergeFrom(const ::google::protobuf::Message &from);
1800  void CopyFrom(const data_nurbspatch &from);
1801  void MergeFrom(const data_nurbspatch &from);
1802  void Clear();
1803  bool IsInitialized() const;
1804 
1805  int ByteSize() const;
1806  bool MergePartialFromCodedStream(
1807  ::google::protobuf::io::CodedInputStream *input);
1808  void SerializeWithCachedSizes(
1809  ::google::protobuf::io::CodedOutputStream *output) const;
1810  ::google::protobuf::uint8 *SerializeWithCachedSizesToArray(::google::protobuf::uint8 *output) const;
1811  int GetCachedSize() const { return _cached_size_; }
1812  private:
1813  void SharedCtor();
1814  void SharedDtor();
1815  void SetCachedSize(int size) const;
1816  public:
1817 
1818  ::google::protobuf::Metadata GetMetadata() const;
1819 
1820  // nested types ----------------------------------------------------
1821 
1822  // accessors -------------------------------------------------------
1823 
1824  // required string name = 1;
1825  inline bool has_name() const;
1826  inline void clear_name();
1827  static const int kNameFieldNumber = 1;
1828  inline const ::std::string &name() const;
1829  inline void set_name(const ::std::string &value);
1830  inline void set_name(const char *value);
1831  inline void set_name(const char *value, size_t size);
1832  inline ::std::string *mutable_name();
1833  inline ::std::string *release_name();
1834  inline void set_allocated_name(::std::string *name);
1835 
1836  // required uint32 dimension = 2;
1837  inline bool has_dimension() const;
1838  inline void clear_dimension();
1839  static const int kDimensionFieldNumber = 2;
1840  inline ::google::protobuf::uint32 dimension() const;
1841  inline void set_dimension(::google::protobuf::uint32 value);
1842 
1843  // repeated .mondschein.io.mbd.data.nurbscurve curves = 3;
1844  inline int curves_size() const;
1845  inline void clear_curves();
1846  static const int kCurvesFieldNumber = 3;
1847  inline const ::mondschein::io::mbd::data_nurbscurve &curves(int index) const;
1848  inline ::mondschein::io::mbd::data_nurbscurve *mutable_curves(int index);
1849  inline ::mondschein::io::mbd::data_nurbscurve *add_curves();
1850  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_nurbscurve > &
1851  curves() const;
1852  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_nurbscurve > *
1853  mutable_curves();
1854 
1855  // optional .mondschein.io.mbd.normal_e normals = 4;
1856  inline bool has_normals() const;
1857  inline void clear_normals();
1858  static const int kNormalsFieldNumber = 4;
1859  inline ::mondschein::io::mbd::normal_e normals() const;
1860  inline void set_normals(::mondschein::io::mbd::normal_e value);
1861 
1862  // @@protoc_insertion_point(class_scope:mondschein.io.mbd.data.nurbspatch)
1863  private:
1864  inline void set_has_name();
1865  inline void clear_has_name();
1866  inline void set_has_dimension();
1867  inline void clear_has_dimension();
1868  inline void set_has_normals();
1869  inline void clear_has_normals();
1870 
1871  ::google::protobuf::UnknownFieldSet _unknown_fields_;
1872 
1873  ::std::string *name_;
1874  ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_nurbscurve > curves_;
1875  ::google::protobuf::uint32 dimension_;
1876  int normals_;
1877 
1878  mutable int _cached_size_;
1879  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
1880 
1881  friend void protobuf_AddDesc_mbd_2eproto();
1882  friend void protobuf_AssignDesc_mbd_2eproto();
1883  friend void protobuf_ShutdownFile_mbd_2eproto();
1884 
1885  void InitAsDefaultInstance();
1886  static data_nurbspatch *default_instance_;
1887  };
1888  // -------------------------------------------------------------------
1889 
1890  class data : public ::google::protobuf::Message
1891  {
1892  public:
1893  data();
1894  virtual ~data();
1895 
1896  data(const data &from);
1897 
1898  inline data &operator=(const data &from)
1899  {
1900  CopyFrom(from);
1901  return *this;
1902  }
1903 
1904  inline const ::google::protobuf::UnknownFieldSet &unknown_fields() const
1905  {
1906  return _unknown_fields_;
1907  }
1908 
1909  inline ::google::protobuf::UnknownFieldSet *mutable_unknown_fields()
1910  {
1911  return &_unknown_fields_;
1912  }
1913 
1914  static const ::google::protobuf::Descriptor *descriptor();
1915  static const data &default_instance();
1916 
1917  void Swap(data *other);
1918 
1919  // implements Message ----------------------------------------------
1920 
1921  data *New() const;
1922  void CopyFrom(const ::google::protobuf::Message &from);
1923  void MergeFrom(const ::google::protobuf::Message &from);
1924  void CopyFrom(const data &from);
1925  void MergeFrom(const data &from);
1926  void Clear();
1927  bool IsInitialized() const;
1928 
1929  int ByteSize() const;
1930  bool MergePartialFromCodedStream(
1931  ::google::protobuf::io::CodedInputStream *input);
1932  void SerializeWithCachedSizes(
1933  ::google::protobuf::io::CodedOutputStream *output) const;
1934  ::google::protobuf::uint8 *SerializeWithCachedSizesToArray(::google::protobuf::uint8 *output) const;
1935  int GetCachedSize() const { return _cached_size_; }
1936  private:
1937  void SharedCtor();
1938  void SharedDtor();
1939  void SetCachedSize(int size) const;
1940  public:
1941 
1942  ::google::protobuf::Metadata GetMetadata() const;
1943 
1944  // nested types ----------------------------------------------------
1945 
1946  typedef data_vector vector;
1947  typedef data_camera camera;
1948  typedef data_light light;
1949  typedef data_material material;
1950  typedef data_mesh mesh;
1951  typedef data_pose pose;
1952  typedef data_texture texture;
1953  typedef data_scenegraph scenegraph;
1954  typedef data_beziercurve beziercurve;
1955  typedef data_bezierpatch bezierpatch;
1956  typedef data_nurbscurve nurbscurve;
1957  typedef data_nurbspatch nurbspatch;
1958 
1959  // accessors -------------------------------------------------------
1960 
1961  // required string name = 1;
1962  inline bool has_name() const;
1963  inline void clear_name();
1964  static const int kNameFieldNumber = 1;
1965  inline const ::std::string &name() const;
1966  inline void set_name(const ::std::string &value);
1967  inline void set_name(const char *value);
1968  inline void set_name(const char *value, size_t size);
1969  inline ::std::string *mutable_name();
1970  inline ::std::string *release_name();
1971  inline void set_allocated_name(::std::string *name);
1972 
1973  // repeated .mondschein.io.mbd.data.camera cameras = 2;
1974  inline int cameras_size() const;
1975  inline void clear_cameras();
1976  static const int kCamerasFieldNumber = 2;
1977  inline const ::mondschein::io::mbd::data_camera &cameras(int index) const;
1978  inline ::mondschein::io::mbd::data_camera *mutable_cameras(int index);
1979  inline ::mondschein::io::mbd::data_camera *add_cameras();
1980  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_camera > &
1981  cameras() const;
1982  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_camera > *
1983  mutable_cameras();
1984 
1985  // repeated .mondschein.io.mbd.data.light lights = 3;
1986  inline int lights_size() const;
1987  inline void clear_lights();
1988  static const int kLightsFieldNumber = 3;
1989  inline const ::mondschein::io::mbd::data_light &lights(int index) const;
1990  inline ::mondschein::io::mbd::data_light *mutable_lights(int index);
1991  inline ::mondschein::io::mbd::data_light *add_lights();
1992  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_light > &
1993  lights() const;
1994  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_light > *
1995  mutable_lights();
1996 
1997  // repeated .mondschein.io.mbd.data.material materials = 4;
1998  inline int materials_size() const;
1999  inline void clear_materials();
2000  static const int kMaterialsFieldNumber = 4;
2001  inline const ::mondschein::io::mbd::data_material &materials(int index) const;
2002  inline ::mondschein::io::mbd::data_material *mutable_materials(int index);
2003  inline ::mondschein::io::mbd::data_material *add_materials();
2004  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_material > &
2005  materials() const;
2006  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_material > *
2007  mutable_materials();
2008 
2009  // repeated .mondschein.io.mbd.data.mesh meshes = 5;
2010  inline int meshes_size() const;
2011  inline void clear_meshes();
2012  static const int kMeshesFieldNumber = 5;
2013  inline const ::mondschein::io::mbd::data_mesh &meshes(int index) const;
2014  inline ::mondschein::io::mbd::data_mesh *mutable_meshes(int index);
2015  inline ::mondschein::io::mbd::data_mesh *add_meshes();
2016  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_mesh > &
2017  meshes() const;
2018  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_mesh > *
2019  mutable_meshes();
2020 
2021  // repeated .mondschein.io.mbd.data.pose poses = 6;
2022  inline int poses_size() const;
2023  inline void clear_poses();
2024  static const int kPosesFieldNumber = 6;
2025  inline const ::mondschein::io::mbd::data_pose &poses(int index) const;
2026  inline ::mondschein::io::mbd::data_pose *mutable_poses(int index);
2027  inline ::mondschein::io::mbd::data_pose *add_poses();
2028  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_pose > &
2029  poses() const;
2030  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_pose > *
2031  mutable_poses();
2032 
2033  // repeated .mondschein.io.mbd.data.texture textures = 7;
2034  inline int textures_size() const;
2035  inline void clear_textures();
2036  static const int kTexturesFieldNumber = 7;
2037  inline const ::mondschein::io::mbd::data_texture &textures(int index) const;
2038  inline ::mondschein::io::mbd::data_texture *mutable_textures(int index);
2039  inline ::mondschein::io::mbd::data_texture *add_textures();
2040  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_texture > &
2041  textures() const;
2042  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_texture > *
2043  mutable_textures();
2044 
2045  // repeated .mondschein.io.mbd.data.beziercurve beziercurves = 8;
2046  inline int beziercurves_size() const;
2047  inline void clear_beziercurves();
2048  static const int kBeziercurvesFieldNumber = 8;
2049  inline const ::mondschein::io::mbd::data_beziercurve &beziercurves(int index) const;
2050  inline ::mondschein::io::mbd::data_beziercurve *mutable_beziercurves(int index);
2051  inline ::mondschein::io::mbd::data_beziercurve *add_beziercurves();
2052  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_beziercurve > &
2053  beziercurves() const;
2054  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_beziercurve > *
2055  mutable_beziercurves();
2056 
2057  // repeated .mondschein.io.mbd.data.nurbscurve nurbscurves = 9;
2058  inline int nurbscurves_size() const;
2059  inline void clear_nurbscurves();
2060  static const int kNurbscurvesFieldNumber = 9;
2061  inline const ::mondschein::io::mbd::data_nurbscurve &nurbscurves(int index) const;
2062  inline ::mondschein::io::mbd::data_nurbscurve *mutable_nurbscurves(int index);
2063  inline ::mondschein::io::mbd::data_nurbscurve *add_nurbscurves();
2064  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_nurbscurve > &
2065  nurbscurves() const;
2066  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_nurbscurve > *
2067  mutable_nurbscurves();
2068 
2069  // repeated .mondschein.io.mbd.data.bezierpatch bezierpatches = 10;
2070  inline int bezierpatches_size() const;
2071  inline void clear_bezierpatches();
2072  static const int kBezierpatchesFieldNumber = 10;
2073  inline const ::mondschein::io::mbd::data_bezierpatch &bezierpatches(int index) const;
2074  inline ::mondschein::io::mbd::data_bezierpatch *mutable_bezierpatches(int index);
2075  inline ::mondschein::io::mbd::data_bezierpatch *add_bezierpatches();
2076  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_bezierpatch > &
2077  bezierpatches() const;
2078  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_bezierpatch > *
2079  mutable_bezierpatches();
2080 
2081  // repeated .mondschein.io.mbd.data.nurbspatch nurbspatches = 11;
2082  inline int nurbspatches_size() const;
2083  inline void clear_nurbspatches();
2084  static const int kNurbspatchesFieldNumber = 11;
2085  inline const ::mondschein::io::mbd::data_nurbspatch &nurbspatches(int index) const;
2086  inline ::mondschein::io::mbd::data_nurbspatch *mutable_nurbspatches(int index);
2087  inline ::mondschein::io::mbd::data_nurbspatch *add_nurbspatches();
2088  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_nurbspatch > &
2089  nurbspatches() const;
2090  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_nurbspatch > *
2091  mutable_nurbspatches();
2092 
2093  // repeated .mondschein.io.mbd.data.scenegraph scenegraphs = 12;
2094  inline int scenegraphs_size() const;
2095  inline void clear_scenegraphs();
2096  static const int kScenegraphsFieldNumber = 12;
2097  inline const ::mondschein::io::mbd::data_scenegraph &scenegraphs(int index) const;
2098  inline ::mondschein::io::mbd::data_scenegraph *mutable_scenegraphs(int index);
2099  inline ::mondschein::io::mbd::data_scenegraph *add_scenegraphs();
2100  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_scenegraph > &
2101  scenegraphs() const;
2102  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_scenegraph > *
2103  mutable_scenegraphs();
2104 
2105  // @@protoc_insertion_point(class_scope:mondschein.io.mbd.data)
2106  private:
2107  inline void set_has_name();
2108  inline void clear_has_name();
2109 
2110  ::google::protobuf::UnknownFieldSet _unknown_fields_;
2111 
2112  ::std::string *name_;
2113  ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_camera > cameras_;
2114  ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_light > lights_;
2115  ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_material > materials_;
2116  ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_mesh > meshes_;
2117  ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_pose > poses_;
2118  ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_texture > textures_;
2119  ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_beziercurve > beziercurves_;
2120  ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_nurbscurve > nurbscurves_;
2121  ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_bezierpatch > bezierpatches_;
2122  ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_nurbspatch > nurbspatches_;
2123  ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_scenegraph > scenegraphs_;
2124 
2125  mutable int _cached_size_;
2126  ::google::protobuf::uint32 _has_bits_[(12 + 31) / 32];
2127 
2128  friend void protobuf_AddDesc_mbd_2eproto();
2129  friend void protobuf_AssignDesc_mbd_2eproto();
2130  friend void protobuf_ShutdownFile_mbd_2eproto();
2131 
2132  void InitAsDefaultInstance();
2133  static data *default_instance_;
2134  };
2135  // ===================================================================
2136 
2137 
2138  // ===================================================================
2139 
2140  // data_vector
2141 
2142  // required double x = 1 [default = 0];
2143  inline bool data_vector::has_x() const
2144  {
2145  return (_has_bits_[0] & 0x00000001u) != 0;
2146  }
2147  inline void data_vector::set_has_x()
2148  {
2149  _has_bits_[0] |= 0x00000001u;
2150  }
2151  inline void data_vector::clear_has_x()
2152  {
2153  _has_bits_[0] &= ~0x00000001u;
2154  }
2155  inline void data_vector::clear_x()
2156  {
2157  x_ = 0;
2158  clear_has_x();
2159  }
2160  inline double data_vector::x() const
2161  {
2162  return x_;
2163  }
2164  inline void data_vector::set_x(double value)
2165  {
2166  set_has_x();
2167  x_ = value;
2168  }
2169 
2170  // required double y = 2 [default = 0];
2171  inline bool data_vector::has_y() const
2172  {
2173  return (_has_bits_[0] & 0x00000002u) != 0;
2174  }
2175  inline void data_vector::set_has_y()
2176  {
2177  _has_bits_[0] |= 0x00000002u;
2178  }
2179  inline void data_vector::clear_has_y()
2180  {
2181  _has_bits_[0] &= ~0x00000002u;
2182  }
2183  inline void data_vector::clear_y()
2184  {
2185  y_ = 0;
2186  clear_has_y();
2187  }
2188  inline double data_vector::y() const
2189  {
2190  return y_;
2191  }
2192  inline void data_vector::set_y(double value)
2193  {
2194  set_has_y();
2195  y_ = value;
2196  }
2197 
2198  // optional double z = 3 [default = 0];
2199  inline bool data_vector::has_z() const
2200  {
2201  return (_has_bits_[0] & 0x00000004u) != 0;
2202  }
2203  inline void data_vector::set_has_z()
2204  {
2205  _has_bits_[0] |= 0x00000004u;
2206  }
2207  inline void data_vector::clear_has_z()
2208  {
2209  _has_bits_[0] &= ~0x00000004u;
2210  }
2211  inline void data_vector::clear_z()
2212  {
2213  z_ = 0;
2214  clear_has_z();
2215  }
2216  inline double data_vector::z() const
2217  {
2218  return z_;
2219  }
2220  inline void data_vector::set_z(double value)
2221  {
2222  set_has_z();
2223  z_ = value;
2224  }
2225 
2226  // optional double w = 4 [default = 1];
2227  inline bool data_vector::has_w() const
2228  {
2229  return (_has_bits_[0] & 0x00000008u) != 0;
2230  }
2231  inline void data_vector::set_has_w()
2232  {
2233  _has_bits_[0] |= 0x00000008u;
2234  }
2235  inline void data_vector::clear_has_w()
2236  {
2237  _has_bits_[0] &= ~0x00000008u;
2238  }
2239  inline void data_vector::clear_w()
2240  {
2241  w_ = 1;
2242  clear_has_w();
2243  }
2244  inline double data_vector::w() const
2245  {
2246  return w_;
2247  }
2248  inline void data_vector::set_w(double value)
2249  {
2250  set_has_w();
2251  w_ = value;
2252  }
2253 
2254  // -------------------------------------------------------------------
2255 
2256  // data_camera
2257 
2258  // required string name = 1;
2259  inline bool data_camera::has_name() const
2260  {
2261  return (_has_bits_[0] & 0x00000001u) != 0;
2262  }
2263  inline void data_camera::set_has_name()
2264  {
2265  _has_bits_[0] |= 0x00000001u;
2266  }
2267  inline void data_camera::clear_has_name()
2268  {
2269  _has_bits_[0] &= ~0x00000001u;
2270  }
2271  inline void data_camera::clear_name()
2272  {
2273  if (name_ != &::google::protobuf::internal::kEmptyString)
2274  {
2275  name_->clear();
2276  }
2277  clear_has_name();
2278  }
2279  inline const ::std::string &data_camera::name() const
2280  {
2281  return *name_;
2282  }
2283  inline void data_camera::set_name(const ::std::string &value)
2284  {
2285  set_has_name();
2286  if (name_ == &::google::protobuf::internal::kEmptyString)
2287  {
2288  name_ = new ::std::string;
2289  }
2290  name_->assign(value);
2291  }
2292  inline void data_camera::set_name(const char *value)
2293  {
2294  set_has_name();
2295  if (name_ == &::google::protobuf::internal::kEmptyString)
2296  {
2297  name_ = new ::std::string;
2298  }
2299  name_->assign(value);
2300  }
2301  inline void data_camera::set_name(const char *value, size_t size)
2302  {
2303  set_has_name();
2304  if (name_ == &::google::protobuf::internal::kEmptyString)
2305  {
2306  name_ = new ::std::string;
2307  }
2308  name_->assign(reinterpret_cast<const char *>(value), size);
2309  }
2310  inline ::std::string *data_camera::mutable_name()
2311  {
2312  set_has_name();
2313  if (name_ == &::google::protobuf::internal::kEmptyString)
2314  {
2315  name_ = new ::std::string;
2316  }
2317  return name_;
2318  }
2319  inline ::std::string *data_camera::release_name()
2320  {
2321  clear_has_name();
2322  if (name_ == &::google::protobuf::internal::kEmptyString)
2323  {
2324  return NULL;
2325  }
2326  else
2327  {
2328  ::std::string *temp = name_;
2329  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
2330  return temp;
2331  }
2332  }
2333  inline void data_camera::set_allocated_name(::std::string *name)
2334  {
2335  if (name_ != &::google::protobuf::internal::kEmptyString)
2336  {
2337  delete name_;
2338  }
2339  if (name)
2340  {
2341  set_has_name();
2342  name_ = name;
2343  }
2344  else
2345  {
2346  clear_has_name();
2347  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
2348  }
2349  }
2350 
2351  // required double fovy = 2 [default = 1.0472];
2352  inline bool data_camera::has_fovy() const
2353  {
2354  return (_has_bits_[0] & 0x00000002u) != 0;
2355  }
2356  inline void data_camera::set_has_fovy()
2357  {
2358  _has_bits_[0] |= 0x00000002u;
2359  }
2360  inline void data_camera::clear_has_fovy()
2361  {
2362  _has_bits_[0] &= ~0x00000002u;
2363  }
2364  inline void data_camera::clear_fovy()
2365  {
2366  fovy_ = 1.0472;
2367  clear_has_fovy();
2368  }
2369  inline double data_camera::fovy() const
2370  {
2371  return fovy_;
2372  }
2373  inline void data_camera::set_fovy(double value)
2374  {
2375  set_has_fovy();
2376  fovy_ = value;
2377  }
2378 
2379  // required double aspect = 3 [default = 0];
2380  inline bool data_camera::has_aspect() const
2381  {
2382  return (_has_bits_[0] & 0x00000004u) != 0;
2383  }
2384  inline void data_camera::set_has_aspect()
2385  {
2386  _has_bits_[0] |= 0x00000004u;
2387  }
2388  inline void data_camera::clear_has_aspect()
2389  {
2390  _has_bits_[0] &= ~0x00000004u;
2391  }
2392  inline void data_camera::clear_aspect()
2393  {
2394  aspect_ = 0;
2395  clear_has_aspect();
2396  }
2397  inline double data_camera::aspect() const
2398  {
2399  return aspect_;
2400  }
2401  inline void data_camera::set_aspect(double value)
2402  {
2403  set_has_aspect();
2404  aspect_ = value;
2405  }
2406 
2407  // required double near = 4 [default = 1];
2408  inline bool data_camera::has_near() const
2409  {
2410  return (_has_bits_[0] & 0x00000008u) != 0;
2411  }
2412  inline void data_camera::set_has_near()
2413  {
2414  _has_bits_[0] |= 0x00000008u;
2415  }
2416  inline void data_camera::clear_has_near()
2417  {
2418  _has_bits_[0] &= ~0x00000008u;
2419  }
2420  inline void data_camera::clear_near()
2421  {
2422  near_ = 1;
2423  clear_has_near();
2424  }
2425  inline double data_camera::near() const
2426  {
2427  return near_;
2428  }
2429  inline void data_camera::set_near(double value)
2430  {
2431  set_has_near();
2432  near_ = value;
2433  }
2434 
2435  // required double far = 5 [default = 100];
2436  inline bool data_camera::has_far() const
2437  {
2438  return (_has_bits_[0] & 0x00000010u) != 0;
2439  }
2440  inline void data_camera::set_has_far()
2441  {
2442  _has_bits_[0] |= 0x00000010u;
2443  }
2444  inline void data_camera::clear_has_far()
2445  {
2446  _has_bits_[0] &= ~0x00000010u;
2447  }
2448  inline void data_camera::clear_far()
2449  {
2450  far_ = 100;
2451  clear_has_far();
2452  }
2453  inline double data_camera::far() const
2454  {
2455  return far_;
2456  }
2457  inline void data_camera::set_far(double value)
2458  {
2459  set_has_far();
2460  far_ = value;
2461  }
2462 
2463  // required uint32 x = 6 [default = 0];
2464  inline bool data_camera::has_x() const
2465  {
2466  return (_has_bits_[0] & 0x00000020u) != 0;
2467  }
2468  inline void data_camera::set_has_x()
2469  {
2470  _has_bits_[0] |= 0x00000020u;
2471  }
2472  inline void data_camera::clear_has_x()
2473  {
2474  _has_bits_[0] &= ~0x00000020u;
2475  }
2476  inline void data_camera::clear_x()
2477  {
2478  x_ = 0u;
2479  clear_has_x();
2480  }
2481  inline ::google::protobuf::uint32 data_camera::x() const
2482  {
2483  return x_;
2484  }
2485  inline void data_camera::set_x(::google::protobuf::uint32 value)
2486  {
2487  set_has_x();
2488  x_ = value;
2489  }
2490 
2491  // required uint32 y = 7 [default = 0];
2492  inline bool data_camera::has_y() const
2493  {
2494  return (_has_bits_[0] & 0x00000040u) != 0;
2495  }
2496  inline void data_camera::set_has_y()
2497  {
2498  _has_bits_[0] |= 0x00000040u;
2499  }
2500  inline void data_camera::clear_has_y()
2501  {
2502  _has_bits_[0] &= ~0x00000040u;
2503  }
2504  inline void data_camera::clear_y()
2505  {
2506  y_ = 0u;
2507  clear_has_y();
2508  }
2509  inline ::google::protobuf::uint32 data_camera::y() const
2510  {
2511  return y_;
2512  }
2513  inline void data_camera::set_y(::google::protobuf::uint32 value)
2514  {
2515  set_has_y();
2516  y_ = value;
2517  }
2518 
2519  // required uint32 w = 8 [default = 0];
2520  inline bool data_camera::has_w() const
2521  {
2522  return (_has_bits_[0] & 0x00000080u) != 0;
2523  }
2524  inline void data_camera::set_has_w()
2525  {
2526  _has_bits_[0] |= 0x00000080u;
2527  }
2528  inline void data_camera::clear_has_w()
2529  {
2530  _has_bits_[0] &= ~0x00000080u;
2531  }
2532  inline void data_camera::clear_w()
2533  {
2534  w_ = 0u;
2535  clear_has_w();
2536  }
2537  inline ::google::protobuf::uint32 data_camera::w() const
2538  {
2539  return w_;
2540  }
2541  inline void data_camera::set_w(::google::protobuf::uint32 value)
2542  {
2543  set_has_w();
2544  w_ = value;
2545  }
2546 
2547  // required uint32 h = 9 [default = 0];
2548  inline bool data_camera::has_h() const
2549  {
2550  return (_has_bits_[0] & 0x00000100u) != 0;
2551  }
2552  inline void data_camera::set_has_h()
2553  {
2554  _has_bits_[0] |= 0x00000100u;
2555  }
2556  inline void data_camera::clear_has_h()
2557  {
2558  _has_bits_[0] &= ~0x00000100u;
2559  }
2560  inline void data_camera::clear_h()
2561  {
2562  h_ = 0u;
2563  clear_has_h();
2564  }
2565  inline ::google::protobuf::uint32 data_camera::h() const
2566  {
2567  return h_;
2568  }
2569  inline void data_camera::set_h(::google::protobuf::uint32 value)
2570  {
2571  set_has_h();
2572  h_ = value;
2573  }
2574 
2575  // -------------------------------------------------------------------
2576 
2577  // data_light
2578 
2579  // required string name = 1;
2580  inline bool data_light::has_name() const
2581  {
2582  return (_has_bits_[0] & 0x00000001u) != 0;
2583  }
2584  inline void data_light::set_has_name()
2585  {
2586  _has_bits_[0] |= 0x00000001u;
2587  }
2588  inline void data_light::clear_has_name()
2589  {
2590  _has_bits_[0] &= ~0x00000001u;
2591  }
2592  inline void data_light::clear_name()
2593  {
2594  if (name_ != &::google::protobuf::internal::kEmptyString)
2595  {
2596  name_->clear();
2597  }
2598  clear_has_name();
2599  }
2600  inline const ::std::string &data_light::name() const
2601  {
2602  return *name_;
2603  }
2604  inline void data_light::set_name(const ::std::string &value)
2605  {
2606  set_has_name();
2607  if (name_ == &::google::protobuf::internal::kEmptyString)
2608  {
2609  name_ = new ::std::string;
2610  }
2611  name_->assign(value);
2612  }
2613  inline void data_light::set_name(const char *value)
2614  {
2615  set_has_name();
2616  if (name_ == &::google::protobuf::internal::kEmptyString)
2617  {
2618  name_ = new ::std::string;
2619  }
2620  name_->assign(value);
2621  }
2622  inline void data_light::set_name(const char *value, size_t size)
2623  {
2624  set_has_name();
2625  if (name_ == &::google::protobuf::internal::kEmptyString)
2626  {
2627  name_ = new ::std::string;
2628  }
2629  name_->assign(reinterpret_cast<const char *>(value), size);
2630  }
2631  inline ::std::string *data_light::mutable_name()
2632  {
2633  set_has_name();
2634  if (name_ == &::google::protobuf::internal::kEmptyString)
2635  {
2636  name_ = new ::std::string;
2637  }
2638  return name_;
2639  }
2640  inline ::std::string *data_light::release_name()
2641  {
2642  clear_has_name();
2643  if (name_ == &::google::protobuf::internal::kEmptyString)
2644  {
2645  return NULL;
2646  }
2647  else
2648  {
2649  ::std::string *temp = name_;
2650  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
2651  return temp;
2652  }
2653  }
2654  inline void data_light::set_allocated_name(::std::string *name)
2655  {
2656  if (name_ != &::google::protobuf::internal::kEmptyString)
2657  {
2658  delete name_;
2659  }
2660  if (name)
2661  {
2662  set_has_name();
2663  name_ = name;
2664  }
2665  else
2666  {
2667  clear_has_name();
2668  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
2669  }
2670  }
2671 
2672  // required .mondschein.io.mbd.data.vector ambient = 2;
2673  inline bool data_light::has_ambient() const
2674  {
2675  return (_has_bits_[0] & 0x00000002u) != 0;
2676  }
2677  inline void data_light::set_has_ambient()
2678  {
2679  _has_bits_[0] |= 0x00000002u;
2680  }
2681  inline void data_light::clear_has_ambient()
2682  {
2683  _has_bits_[0] &= ~0x00000002u;
2684  }
2685  inline void data_light::clear_ambient()
2686  {
2687  if (ambient_ != NULL) ambient_->::mondschein::io::mbd::data_vector::Clear();
2688  clear_has_ambient();
2689  }
2690  inline const ::mondschein::io::mbd::data_vector &data_light::ambient() const
2691  {
2692  return ambient_ != NULL ? *ambient_ : *default_instance_->ambient_;
2693  }
2694  inline ::mondschein::io::mbd::data_vector *data_light::mutable_ambient()
2695  {
2696  set_has_ambient();
2697  if (ambient_ == NULL) ambient_ = new ::mondschein::io::mbd::data_vector;
2698  return ambient_;
2699  }
2700  inline ::mondschein::io::mbd::data_vector *data_light::release_ambient()
2701  {
2702  clear_has_ambient();
2703  ::mondschein::io::mbd::data_vector *temp = ambient_;
2704  ambient_ = NULL;
2705  return temp;
2706  }
2707  inline void data_light::set_allocated_ambient(::mondschein::io::mbd::data_vector *ambient)
2708  {
2709  delete ambient_;
2710  ambient_ = ambient;
2711  if (ambient)
2712  {
2713  set_has_ambient();
2714  }
2715  else
2716  {
2717  clear_has_ambient();
2718  }
2719  }
2720 
2721  // required .mondschein.io.mbd.data.vector diffuse = 3;
2722  inline bool data_light::has_diffuse() const
2723  {
2724  return (_has_bits_[0] & 0x00000004u) != 0;
2725  }
2726  inline void data_light::set_has_diffuse()
2727  {
2728  _has_bits_[0] |= 0x00000004u;
2729  }
2730  inline void data_light::clear_has_diffuse()
2731  {
2732  _has_bits_[0] &= ~0x00000004u;
2733  }
2734  inline void data_light::clear_diffuse()
2735  {
2736  if (diffuse_ != NULL) diffuse_->::mondschein::io::mbd::data_vector::Clear();
2737  clear_has_diffuse();
2738  }
2739  inline const ::mondschein::io::mbd::data_vector &data_light::diffuse() const
2740  {
2741  return diffuse_ != NULL ? *diffuse_ : *default_instance_->diffuse_;
2742  }
2743  inline ::mondschein::io::mbd::data_vector *data_light::mutable_diffuse()
2744  {
2745  set_has_diffuse();
2746  if (diffuse_ == NULL) diffuse_ = new ::mondschein::io::mbd::data_vector;
2747  return diffuse_;
2748  }
2749  inline ::mondschein::io::mbd::data_vector *data_light::release_diffuse()
2750  {
2751  clear_has_diffuse();
2752  ::mondschein::io::mbd::data_vector *temp = diffuse_;
2753  diffuse_ = NULL;
2754  return temp;
2755  }
2756  inline void data_light::set_allocated_diffuse(::mondschein::io::mbd::data_vector *diffuse)
2757  {
2758  delete diffuse_;
2759  diffuse_ = diffuse;
2760  if (diffuse)
2761  {
2762  set_has_diffuse();
2763  }
2764  else
2765  {
2766  clear_has_diffuse();
2767  }
2768  }
2769 
2770  // required .mondschein.io.mbd.data.vector specular = 4;
2771  inline bool data_light::has_specular() const
2772  {
2773  return (_has_bits_[0] & 0x00000008u) != 0;
2774  }
2775  inline void data_light::set_has_specular()
2776  {
2777  _has_bits_[0] |= 0x00000008u;
2778  }
2779  inline void data_light::clear_has_specular()
2780  {
2781  _has_bits_[0] &= ~0x00000008u;
2782  }
2783  inline void data_light::clear_specular()
2784  {
2785  if (specular_ != NULL) specular_->::mondschein::io::mbd::data_vector::Clear();
2786  clear_has_specular();
2787  }
2788  inline const ::mondschein::io::mbd::data_vector &data_light::specular() const
2789  {
2790  return specular_ != NULL ? *specular_ : *default_instance_->specular_;
2791  }
2792  inline ::mondschein::io::mbd::data_vector *data_light::mutable_specular()
2793  {
2794  set_has_specular();
2795  if (specular_ == NULL) specular_ = new ::mondschein::io::mbd::data_vector;
2796  return specular_;
2797  }
2798  inline ::mondschein::io::mbd::data_vector *data_light::release_specular()
2799  {
2800  clear_has_specular();
2801  ::mondschein::io::mbd::data_vector *temp = specular_;
2802  specular_ = NULL;
2803  return temp;
2804  }
2805  inline void data_light::set_allocated_specular(::mondschein::io::mbd::data_vector *specular)
2806  {
2807  delete specular_;
2808  specular_ = specular;
2809  if (specular)
2810  {
2811  set_has_specular();
2812  }
2813  else
2814  {
2815  clear_has_specular();
2816  }
2817  }
2818 
2819  // required .mondschein.io.mbd.data.vector position = 5;
2820  inline bool data_light::has_position() const
2821  {
2822  return (_has_bits_[0] & 0x00000010u) != 0;
2823  }
2824  inline void data_light::set_has_position()
2825  {
2826  _has_bits_[0] |= 0x00000010u;
2827  }
2828  inline void data_light::clear_has_position()
2829  {
2830  _has_bits_[0] &= ~0x00000010u;
2831  }
2832  inline void data_light::clear_position()
2833  {
2834  if (position_ != NULL) position_->::mondschein::io::mbd::data_vector::Clear();
2835  clear_has_position();
2836  }
2837  inline const ::mondschein::io::mbd::data_vector &data_light::position() const
2838  {
2839  return position_ != NULL ? *position_ : *default_instance_->position_;
2840  }
2841  inline ::mondschein::io::mbd::data_vector *data_light::mutable_position()
2842  {
2843  set_has_position();
2844  if (position_ == NULL) position_ = new ::mondschein::io::mbd::data_vector;
2845  return position_;
2846  }
2847  inline ::mondschein::io::mbd::data_vector *data_light::release_position()
2848  {
2849  clear_has_position();
2850  ::mondschein::io::mbd::data_vector *temp = position_;
2851  position_ = NULL;
2852  return temp;
2853  }
2854  inline void data_light::set_allocated_position(::mondschein::io::mbd::data_vector *position)
2855  {
2856  delete position_;
2857  position_ = position;
2858  if (position)
2859  {
2860  set_has_position();
2861  }
2862  else
2863  {
2864  clear_has_position();
2865  }
2866  }
2867 
2868  // required .mondschein.io.mbd.data.vector direction = 6;
2869  inline bool data_light::has_direction() const
2870  {
2871  return (_has_bits_[0] & 0x00000020u) != 0;
2872  }
2873  inline void data_light::set_has_direction()
2874  {
2875  _has_bits_[0] |= 0x00000020u;
2876  }
2877  inline void data_light::clear_has_direction()
2878  {
2879  _has_bits_[0] &= ~0x00000020u;
2880  }
2881  inline void data_light::clear_direction()
2882  {
2883  if (direction_ != NULL) direction_->::mondschein::io::mbd::data_vector::Clear();
2884  clear_has_direction();
2885  }
2886  inline const ::mondschein::io::mbd::data_vector &data_light::direction() const
2887  {
2888  return direction_ != NULL ? *direction_ : *default_instance_->direction_;
2889  }
2890  inline ::mondschein::io::mbd::data_vector *data_light::mutable_direction()
2891  {
2892  set_has_direction();
2893  if (direction_ == NULL) direction_ = new ::mondschein::io::mbd::data_vector;
2894  return direction_;
2895  }
2896  inline ::mondschein::io::mbd::data_vector *data_light::release_direction()
2897  {
2898  clear_has_direction();
2899  ::mondschein::io::mbd::data_vector *temp = direction_;
2900  direction_ = NULL;
2901  return temp;
2902  }
2903  inline void data_light::set_allocated_direction(::mondschein::io::mbd::data_vector *direction)
2904  {
2905  delete direction_;
2906  direction_ = direction;
2907  if (direction)
2908  {
2909  set_has_direction();
2910  }
2911  else
2912  {
2913  clear_has_direction();
2914  }
2915  }
2916 
2917  // required double exponent = 7;
2918  inline bool data_light::has_exponent() const
2919  {
2920  return (_has_bits_[0] & 0x00000040u) != 0;
2921  }
2922  inline void data_light::set_has_exponent()
2923  {
2924  _has_bits_[0] |= 0x00000040u;
2925  }
2926  inline void data_light::clear_has_exponent()
2927  {
2928  _has_bits_[0] &= ~0x00000040u;
2929  }
2930  inline void data_light::clear_exponent()
2931  {
2932  exponent_ = 0;
2933  clear_has_exponent();
2934  }
2935  inline double data_light::exponent() const
2936  {
2937  return exponent_;
2938  }
2939  inline void data_light::set_exponent(double value)
2940  {
2941  set_has_exponent();
2942  exponent_ = value;
2943  }
2944 
2945  // required double cutoff = 8;
2946  inline bool data_light::has_cutoff() const
2947  {
2948  return (_has_bits_[0] & 0x00000080u) != 0;
2949  }
2950  inline void data_light::set_has_cutoff()
2951  {
2952  _has_bits_[0] |= 0x00000080u;
2953  }
2954  inline void data_light::clear_has_cutoff()
2955  {
2956  _has_bits_[0] &= ~0x00000080u;
2957  }
2958  inline void data_light::clear_cutoff()
2959  {
2960  cutoff_ = 0;
2961  clear_has_cutoff();
2962  }
2963  inline double data_light::cutoff() const
2964  {
2965  return cutoff_;
2966  }
2967  inline void data_light::set_cutoff(double value)
2968  {
2969  set_has_cutoff();
2970  cutoff_ = value;
2971  }
2972 
2973  // required double const_att = 9;
2974  inline bool data_light::has_const_att() const
2975  {
2976  return (_has_bits_[0] & 0x00000100u) != 0;
2977  }
2978  inline void data_light::set_has_const_att()
2979  {
2980  _has_bits_[0] |= 0x00000100u;
2981  }
2982  inline void data_light::clear_has_const_att()
2983  {
2984  _has_bits_[0] &= ~0x00000100u;
2985  }
2986  inline void data_light::clear_const_att()
2987  {
2988  const_att_ = 0;
2989  clear_has_const_att();
2990  }
2991  inline double data_light::const_att() const
2992  {
2993  return const_att_;
2994  }
2995  inline void data_light::set_const_att(double value)
2996  {
2997  set_has_const_att();
2998  const_att_ = value;
2999  }
3000 
3001  // required double lin_att = 10;
3002  inline bool data_light::has_lin_att() const
3003  {
3004  return (_has_bits_[0] & 0x00000200u) != 0;
3005  }
3006  inline void data_light::set_has_lin_att()
3007  {
3008  _has_bits_[0] |= 0x00000200u;
3009  }
3010  inline void data_light::clear_has_lin_att()
3011  {
3012  _has_bits_[0] &= ~0x00000200u;
3013  }
3014  inline void data_light::clear_lin_att()
3015  {
3016  lin_att_ = 0;
3017  clear_has_lin_att();
3018  }
3019  inline double data_light::lin_att() const
3020  {
3021  return lin_att_;
3022  }
3023  inline void data_light::set_lin_att(double value)
3024  {
3025  set_has_lin_att();
3026  lin_att_ = value;
3027  }
3028 
3029  // required double quad_att = 11;
3030  inline bool data_light::has_quad_att() const
3031  {
3032  return (_has_bits_[0] & 0x00000400u) != 0;
3033  }
3034  inline void data_light::set_has_quad_att()
3035  {
3036  _has_bits_[0] |= 0x00000400u;
3037  }
3038  inline void data_light::clear_has_quad_att()
3039  {
3040  _has_bits_[0] &= ~0x00000400u;
3041  }
3042  inline void data_light::clear_quad_att()
3043  {
3044  quad_att_ = 0;
3045  clear_has_quad_att();
3046  }
3047  inline double data_light::quad_att() const
3048  {
3049  return quad_att_;
3050  }
3051  inline void data_light::set_quad_att(double value)
3052  {
3053  set_has_quad_att();
3054  quad_att_ = value;
3055  }
3056 
3057  // required uint32 light_nr = 12;
3058  inline bool data_light::has_light_nr() const
3059  {
3060  return (_has_bits_[0] & 0x00000800u) != 0;
3061  }
3062  inline void data_light::set_has_light_nr()
3063  {
3064  _has_bits_[0] |= 0x00000800u;
3065  }
3066  inline void data_light::clear_has_light_nr()
3067  {
3068  _has_bits_[0] &= ~0x00000800u;
3069  }
3070  inline void data_light::clear_light_nr()
3071  {
3072  light_nr_ = 0u;
3073  clear_has_light_nr();
3074  }
3075  inline ::google::protobuf::uint32 data_light::light_nr() const
3076  {
3077  return light_nr_;
3078  }
3079  inline void data_light::set_light_nr(::google::protobuf::uint32 value)
3080  {
3081  set_has_light_nr();
3082  light_nr_ = value;
3083  }
3084 
3085  // -------------------------------------------------------------------
3086 
3087  // data_material
3088 
3089  // required string name = 1;
3090  inline bool data_material::has_name() const
3091  {
3092  return (_has_bits_[0] & 0x00000001u) != 0;
3093  }
3094  inline void data_material::set_has_name()
3095  {
3096  _has_bits_[0] |= 0x00000001u;
3097  }
3098  inline void data_material::clear_has_name()
3099  {
3100  _has_bits_[0] &= ~0x00000001u;
3101  }
3102  inline void data_material::clear_name()
3103  {
3104  if (name_ != &::google::protobuf::internal::kEmptyString)
3105  {
3106  name_->clear();
3107  }
3108  clear_has_name();
3109  }
3110  inline const ::std::string &data_material::name() const
3111  {
3112  return *name_;
3113  }
3114  inline void data_material::set_name(const ::std::string &value)
3115  {
3116  set_has_name();
3117  if (name_ == &::google::protobuf::internal::kEmptyString)
3118  {
3119  name_ = new ::std::string;
3120  }
3121  name_->assign(value);
3122  }
3123  inline void data_material::set_name(const char *value)
3124  {
3125  set_has_name();
3126  if (name_ == &::google::protobuf::internal::kEmptyString)
3127  {
3128  name_ = new ::std::string;
3129  }
3130  name_->assign(value);
3131  }
3132  inline void data_material::set_name(const char *value, size_t size)
3133  {
3134  set_has_name();
3135  if (name_ == &::google::protobuf::internal::kEmptyString)
3136  {
3137  name_ = new ::std::string;
3138  }
3139  name_->assign(reinterpret_cast<const char *>(value), size);
3140  }
3141  inline ::std::string *data_material::mutable_name()
3142  {
3143  set_has_name();
3144  if (name_ == &::google::protobuf::internal::kEmptyString)
3145  {
3146  name_ = new ::std::string;
3147  }
3148  return name_;
3149  }
3150  inline ::std::string *data_material::release_name()
3151  {
3152  clear_has_name();
3153  if (name_ == &::google::protobuf::internal::kEmptyString)
3154  {
3155  return NULL;
3156  }
3157  else
3158  {
3159  ::std::string *temp = name_;
3160  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
3161  return temp;
3162  }
3163  }
3164  inline void data_material::set_allocated_name(::std::string *name)
3165  {
3166  if (name_ != &::google::protobuf::internal::kEmptyString)
3167  {
3168  delete name_;
3169  }
3170  if (name)
3171  {
3172  set_has_name();
3173  name_ = name;
3174  }
3175  else
3176  {
3177  clear_has_name();
3178  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
3179  }
3180  }
3181 
3182  // required .mondschein.io.mbd.data.vector ambient = 2;
3183  inline bool data_material::has_ambient() const
3184  {
3185  return (_has_bits_[0] & 0x00000002u) != 0;
3186  }
3187  inline void data_material::set_has_ambient()
3188  {
3189  _has_bits_[0] |= 0x00000002u;
3190  }
3191  inline void data_material::clear_has_ambient()
3192  {
3193  _has_bits_[0] &= ~0x00000002u;
3194  }
3195  inline void data_material::clear_ambient()
3196  {
3197  if (ambient_ != NULL) ambient_->::mondschein::io::mbd::data_vector::Clear();
3198  clear_has_ambient();
3199  }
3200  inline const ::mondschein::io::mbd::data_vector &data_material::ambient() const
3201  {
3202  return ambient_ != NULL ? *ambient_ : *default_instance_->ambient_;
3203  }
3204  inline ::mondschein::io::mbd::data_vector *data_material::mutable_ambient()
3205  {
3206  set_has_ambient();
3207  if (ambient_ == NULL) ambient_ = new ::mondschein::io::mbd::data_vector;
3208  return ambient_;
3209  }
3210  inline ::mondschein::io::mbd::data_vector *data_material::release_ambient()
3211  {
3212  clear_has_ambient();
3213  ::mondschein::io::mbd::data_vector *temp = ambient_;
3214  ambient_ = NULL;
3215  return temp;
3216  }
3217  inline void data_material::set_allocated_ambient(::mondschein::io::mbd::data_vector *ambient)
3218  {
3219  delete ambient_;
3220  ambient_ = ambient;
3221  if (ambient)
3222  {
3223  set_has_ambient();
3224  }
3225  else
3226  {
3227  clear_has_ambient();
3228  }
3229  }
3230 
3231  // required .mondschein.io.mbd.data.vector diffuse = 3;
3232  inline bool data_material::has_diffuse() const
3233  {
3234  return (_has_bits_[0] & 0x00000004u) != 0;
3235  }
3236  inline void data_material::set_has_diffuse()
3237  {
3238  _has_bits_[0] |= 0x00000004u;
3239  }
3240  inline void data_material::clear_has_diffuse()
3241  {
3242  _has_bits_[0] &= ~0x00000004u;
3243  }
3244  inline void data_material::clear_diffuse()
3245  {
3246  if (diffuse_ != NULL) diffuse_->::mondschein::io::mbd::data_vector::Clear();
3247  clear_has_diffuse();
3248  }
3249  inline const ::mondschein::io::mbd::data_vector &data_material::diffuse() const
3250  {
3251  return diffuse_ != NULL ? *diffuse_ : *default_instance_->diffuse_;
3252  }
3253  inline ::mondschein::io::mbd::data_vector *data_material::mutable_diffuse()
3254  {
3255  set_has_diffuse();
3256  if (diffuse_ == NULL) diffuse_ = new ::mondschein::io::mbd::data_vector;
3257  return diffuse_;
3258  }
3259  inline ::mondschein::io::mbd::data_vector *data_material::release_diffuse()
3260  {
3261  clear_has_diffuse();
3262  ::mondschein::io::mbd::data_vector *temp = diffuse_;
3263  diffuse_ = NULL;
3264  return temp;
3265  }
3266  inline void data_material::set_allocated_diffuse(::mondschein::io::mbd::data_vector *diffuse)
3267  {
3268  delete diffuse_;
3269  diffuse_ = diffuse;
3270  if (diffuse)
3271  {
3272  set_has_diffuse();
3273  }
3274  else
3275  {
3276  clear_has_diffuse();
3277  }
3278  }
3279 
3280  // required .mondschein.io.mbd.data.vector specular = 4;
3281  inline bool data_material::has_specular() const
3282  {
3283  return (_has_bits_[0] & 0x00000008u) != 0;
3284  }
3285  inline void data_material::set_has_specular()
3286  {
3287  _has_bits_[0] |= 0x00000008u;
3288  }
3289  inline void data_material::clear_has_specular()
3290  {
3291  _has_bits_[0] &= ~0x00000008u;
3292  }
3293  inline void data_material::clear_specular()
3294  {
3295  if (specular_ != NULL) specular_->::mondschein::io::mbd::data_vector::Clear();
3296  clear_has_specular();
3297  }
3298  inline const ::mondschein::io::mbd::data_vector &data_material::specular() const
3299  {
3300  return specular_ != NULL ? *specular_ : *default_instance_->specular_;
3301  }
3302  inline ::mondschein::io::mbd::data_vector *data_material::mutable_specular()
3303  {
3304  set_has_specular();
3305  if (specular_ == NULL) specular_ = new ::mondschein::io::mbd::data_vector;
3306  return specular_;
3307  }
3308  inline ::mondschein::io::mbd::data_vector *data_material::release_specular()
3309  {
3310  clear_has_specular();
3311  ::mondschein::io::mbd::data_vector *temp = specular_;
3312  specular_ = NULL;
3313  return temp;
3314  }
3315  inline void data_material::set_allocated_specular(::mondschein::io::mbd::data_vector *specular)
3316  {
3317  delete specular_;
3318  specular_ = specular;
3319  if (specular)
3320  {
3321  set_has_specular();
3322  }
3323  else
3324  {
3325  clear_has_specular();
3326  }
3327  }
3328 
3329  // required .mondschein.io.mbd.data.vector emission = 5;
3330  inline bool data_material::has_emission() const
3331  {
3332  return (_has_bits_[0] & 0x00000010u) != 0;
3333  }
3334  inline void data_material::set_has_emission()
3335  {
3336  _has_bits_[0] |= 0x00000010u;
3337  }
3338  inline void data_material::clear_has_emission()
3339  {
3340  _has_bits_[0] &= ~0x00000010u;
3341  }
3342  inline void data_material::clear_emission()
3343  {
3344  if (emission_ != NULL) emission_->::mondschein::io::mbd::data_vector::Clear();
3345  clear_has_emission();
3346  }
3347  inline const ::mondschein::io::mbd::data_vector &data_material::emission() const
3348  {
3349  return emission_ != NULL ? *emission_ : *default_instance_->emission_;
3350  }
3351  inline ::mondschein::io::mbd::data_vector *data_material::mutable_emission()
3352  {
3353  set_has_emission();
3354  if (emission_ == NULL) emission_ = new ::mondschein::io::mbd::data_vector;
3355  return emission_;
3356  }
3357  inline ::mondschein::io::mbd::data_vector *data_material::release_emission()
3358  {
3359  clear_has_emission();
3360  ::mondschein::io::mbd::data_vector *temp = emission_;
3361  emission_ = NULL;
3362  return temp;
3363  }
3364  inline void data_material::set_allocated_emission(::mondschein::io::mbd::data_vector *emission)
3365  {
3366  delete emission_;
3367  emission_ = emission;
3368  if (emission)
3369  {
3370  set_has_emission();
3371  }
3372  else
3373  {
3374  clear_has_emission();
3375  }
3376  }
3377 
3378  // required double shininess = 6;
3379  inline bool data_material::has_shininess() const
3380  {
3381  return (_has_bits_[0] & 0x00000020u) != 0;
3382  }
3383  inline void data_material::set_has_shininess()
3384  {
3385  _has_bits_[0] |= 0x00000020u;
3386  }
3387  inline void data_material::clear_has_shininess()
3388  {
3389  _has_bits_[0] &= ~0x00000020u;
3390  }
3391  inline void data_material::clear_shininess()
3392  {
3393  shininess_ = 0;
3394  clear_has_shininess();
3395  }
3396  inline double data_material::shininess() const
3397  {
3398  return shininess_;
3399  }
3400  inline void data_material::set_shininess(double value)
3401  {
3402  set_has_shininess();
3403  shininess_ = value;
3404  }
3405 
3406  // -------------------------------------------------------------------
3407 
3408  // data_mesh
3409 
3410  // required string name = 1;
3411  inline bool data_mesh::has_name() const
3412  {
3413  return (_has_bits_[0] & 0x00000001u) != 0;
3414  }
3415  inline void data_mesh::set_has_name()
3416  {
3417  _has_bits_[0] |= 0x00000001u;
3418  }
3419  inline void data_mesh::clear_has_name()
3420  {
3421  _has_bits_[0] &= ~0x00000001u;
3422  }
3423  inline void data_mesh::clear_name()
3424  {
3425  if (name_ != &::google::protobuf::internal::kEmptyString)
3426  {
3427  name_->clear();
3428  }
3429  clear_has_name();
3430  }
3431  inline const ::std::string &data_mesh::name() const
3432  {
3433  return *name_;
3434  }
3435  inline void data_mesh::set_name(const ::std::string &value)
3436  {
3437  set_has_name();
3438  if (name_ == &::google::protobuf::internal::kEmptyString)
3439  {
3440  name_ = new ::std::string;
3441  }
3442  name_->assign(value);
3443  }
3444  inline void data_mesh::set_name(const char *value)
3445  {
3446  set_has_name();
3447  if (name_ == &::google::protobuf::internal::kEmptyString)
3448  {
3449  name_ = new ::std::string;
3450  }
3451  name_->assign(value);
3452  }
3453  inline void data_mesh::set_name(const char *value, size_t size)
3454  {
3455  set_has_name();
3456  if (name_ == &::google::protobuf::internal::kEmptyString)
3457  {
3458  name_ = new ::std::string;
3459  }
3460  name_->assign(reinterpret_cast<const char *>(value), size);
3461  }
3462  inline ::std::string *data_mesh::mutable_name()
3463  {
3464  set_has_name();
3465  if (name_ == &::google::protobuf::internal::kEmptyString)
3466  {
3467  name_ = new ::std::string;
3468  }
3469  return name_;
3470  }
3471  inline ::std::string *data_mesh::release_name()
3472  {
3473  clear_has_name();
3474  if (name_ == &::google::protobuf::internal::kEmptyString)
3475  {
3476  return NULL;
3477  }
3478  else
3479  {
3480  ::std::string *temp = name_;
3481  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
3482  return temp;
3483  }
3484  }
3485  inline void data_mesh::set_allocated_name(::std::string *name)
3486  {
3487  if (name_ != &::google::protobuf::internal::kEmptyString)
3488  {
3489  delete name_;
3490  }
3491  if (name)
3492  {
3493  set_has_name();
3494  name_ = name;
3495  }
3496  else
3497  {
3498  clear_has_name();
3499  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
3500  }
3501  }
3502 
3503  // repeated .mondschein.io.mbd.data.vector v = 2;
3504  inline int data_mesh::v_size() const
3505  {
3506  return v_.size();
3507  }
3508  inline void data_mesh::clear_v()
3509  {
3510  v_.Clear();
3511  }
3512  inline const ::mondschein::io::mbd::data_vector &data_mesh::v(int index) const
3513  {
3514  return v_.Get(index);
3515  }
3516  inline ::mondschein::io::mbd::data_vector *data_mesh::mutable_v(int index)
3517  {
3518  return v_.Mutable(index);
3519  }
3520  inline ::mondschein::io::mbd::data_vector *data_mesh::add_v()
3521  {
3522  return v_.Add();
3523  }
3524  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > &
3525  data_mesh::v() const
3526  {
3527  return v_;
3528  }
3529  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > *
3530  data_mesh::mutable_v()
3531  {
3532  return &v_;
3533  }
3534 
3535  // repeated .mondschein.io.mbd.data.vector vn = 3;
3536  inline int data_mesh::vn_size() const
3537  {
3538  return vn_.size();
3539  }
3540  inline void data_mesh::clear_vn()
3541  {
3542  vn_.Clear();
3543  }
3544  inline const ::mondschein::io::mbd::data_vector &data_mesh::vn(int index) const
3545  {
3546  return vn_.Get(index);
3547  }
3548  inline ::mondschein::io::mbd::data_vector *data_mesh::mutable_vn(int index)
3549  {
3550  return vn_.Mutable(index);
3551  }
3552  inline ::mondschein::io::mbd::data_vector *data_mesh::add_vn()
3553  {
3554  return vn_.Add();
3555  }
3556  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > &
3557  data_mesh::vn() const
3558  {
3559  return vn_;
3560  }
3561  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > *
3562  data_mesh::mutable_vn()
3563  {
3564  return &vn_;
3565  }
3566 
3567  // repeated .mondschein.io.mbd.data.vector vt = 4;
3568  inline int data_mesh::vt_size() const
3569  {
3570  return vt_.size();
3571  }
3572  inline void data_mesh::clear_vt()
3573  {
3574  vt_.Clear();
3575  }
3576  inline const ::mondschein::io::mbd::data_vector &data_mesh::vt(int index) const
3577  {
3578  return vt_.Get(index);
3579  }
3580  inline ::mondschein::io::mbd::data_vector *data_mesh::mutable_vt(int index)
3581  {
3582  return vt_.Mutable(index);
3583  }
3584  inline ::mondschein::io::mbd::data_vector *data_mesh::add_vt()
3585  {
3586  return vt_.Add();
3587  }
3588  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > &
3589  data_mesh::vt() const
3590  {
3591  return vt_;
3592  }
3593  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > *
3594  data_mesh::mutable_vt()
3595  {
3596  return &vt_;
3597  }
3598 
3599  // repeated .mondschein.io.mbd.data.vector vc = 5;
3600  inline int data_mesh::vc_size() const
3601  {
3602  return vc_.size();
3603  }
3604  inline void data_mesh::clear_vc()
3605  {
3606  vc_.Clear();
3607  }
3608  inline const ::mondschein::io::mbd::data_vector &data_mesh::vc(int index) const
3609  {
3610  return vc_.Get(index);
3611  }
3612  inline ::mondschein::io::mbd::data_vector *data_mesh::mutable_vc(int index)
3613  {
3614  return vc_.Mutable(index);
3615  }
3616  inline ::mondschein::io::mbd::data_vector *data_mesh::add_vc()
3617  {
3618  return vc_.Add();
3619  }
3620  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > &
3621  data_mesh::vc() const
3622  {
3623  return vc_;
3624  }
3625  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > *
3626  data_mesh::mutable_vc()
3627  {
3628  return &vc_;
3629  }
3630 
3631  // -------------------------------------------------------------------
3632 
3633  // data_pose
3634 
3635  // required string name = 1;
3636  inline bool data_pose::has_name() const
3637  {
3638  return (_has_bits_[0] & 0x00000001u) != 0;
3639  }
3640  inline void data_pose::set_has_name()
3641  {
3642  _has_bits_[0] |= 0x00000001u;
3643  }
3644  inline void data_pose::clear_has_name()
3645  {
3646  _has_bits_[0] &= ~0x00000001u;
3647  }
3648  inline void data_pose::clear_name()
3649  {
3650  if (name_ != &::google::protobuf::internal::kEmptyString)
3651  {
3652  name_->clear();
3653  }
3654  clear_has_name();
3655  }
3656  inline const ::std::string &data_pose::name() const
3657  {
3658  return *name_;
3659  }
3660  inline void data_pose::set_name(const ::std::string &value)
3661  {
3662  set_has_name();
3663  if (name_ == &::google::protobuf::internal::kEmptyString)
3664  {
3665  name_ = new ::std::string;
3666  }
3667  name_->assign(value);
3668  }
3669  inline void data_pose::set_name(const char *value)
3670  {
3671  set_has_name();
3672  if (name_ == &::google::protobuf::internal::kEmptyString)
3673  {
3674  name_ = new ::std::string;
3675  }
3676  name_->assign(value);
3677  }
3678  inline void data_pose::set_name(const char *value, size_t size)
3679  {
3680  set_has_name();
3681  if (name_ == &::google::protobuf::internal::kEmptyString)
3682  {
3683  name_ = new ::std::string;
3684  }
3685  name_->assign(reinterpret_cast<const char *>(value), size);
3686  }
3687  inline ::std::string *data_pose::mutable_name()
3688  {
3689  set_has_name();
3690  if (name_ == &::google::protobuf::internal::kEmptyString)
3691  {
3692  name_ = new ::std::string;
3693  }
3694  return name_;
3695  }
3696  inline ::std::string *data_pose::release_name()
3697  {
3698  clear_has_name();
3699  if (name_ == &::google::protobuf::internal::kEmptyString)
3700  {
3701  return NULL;
3702  }
3703  else
3704  {
3705  ::std::string *temp = name_;
3706  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
3707  return temp;
3708  }
3709  }
3710  inline void data_pose::set_allocated_name(::std::string *name)
3711  {
3712  if (name_ != &::google::protobuf::internal::kEmptyString)
3713  {
3714  delete name_;
3715  }
3716  if (name)
3717  {
3718  set_has_name();
3719  name_ = name;
3720  }
3721  else
3722  {
3723  clear_has_name();
3724  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
3725  }
3726  }
3727 
3728  // required .mondschein.io.mbd.data.vector c1 = 2;
3729  inline bool data_pose::has_c1() const
3730  {
3731  return (_has_bits_[0] & 0x00000002u) != 0;
3732  }
3733  inline void data_pose::set_has_c1()
3734  {
3735  _has_bits_[0] |= 0x00000002u;
3736  }
3737  inline void data_pose::clear_has_c1()
3738  {
3739  _has_bits_[0] &= ~0x00000002u;
3740  }
3741  inline void data_pose::clear_c1()
3742  {
3743  if (c1_ != NULL) c1_->::mondschein::io::mbd::data_vector::Clear();
3744  clear_has_c1();
3745  }
3746  inline const ::mondschein::io::mbd::data_vector &data_pose::c1() const
3747  {
3748  return c1_ != NULL ? *c1_ : *default_instance_->c1_;
3749  }
3750  inline ::mondschein::io::mbd::data_vector *data_pose::mutable_c1()
3751  {
3752  set_has_c1();
3753  if (c1_ == NULL) c1_ = new ::mondschein::io::mbd::data_vector;
3754  return c1_;
3755  }
3756  inline ::mondschein::io::mbd::data_vector *data_pose::release_c1()
3757  {
3758  clear_has_c1();
3759  ::mondschein::io::mbd::data_vector *temp = c1_;
3760  c1_ = NULL;
3761  return temp;
3762  }
3763  inline void data_pose::set_allocated_c1(::mondschein::io::mbd::data_vector *c1)
3764  {
3765  delete c1_;
3766  c1_ = c1;
3767  if (c1)
3768  {
3769  set_has_c1();
3770  }
3771  else
3772  {
3773  clear_has_c1();
3774  }
3775  }
3776 
3777  // required .mondschein.io.mbd.data.vector c2 = 3;
3778  inline bool data_pose::has_c2() const
3779  {
3780  return (_has_bits_[0] & 0x00000004u) != 0;
3781  }
3782  inline void data_pose::set_has_c2()
3783  {
3784  _has_bits_[0] |= 0x00000004u;
3785  }
3786  inline void data_pose::clear_has_c2()
3787  {
3788  _has_bits_[0] &= ~0x00000004u;
3789  }
3790  inline void data_pose::clear_c2()
3791  {
3792  if (c2_ != NULL) c2_->::mondschein::io::mbd::data_vector::Clear();
3793  clear_has_c2();
3794  }
3795  inline const ::mondschein::io::mbd::data_vector &data_pose::c2() const
3796  {
3797  return c2_ != NULL ? *c2_ : *default_instance_->c2_;
3798  }
3799  inline ::mondschein::io::mbd::data_vector *data_pose::mutable_c2()
3800  {
3801  set_has_c2();
3802  if (c2_ == NULL) c2_ = new ::mondschein::io::mbd::data_vector;
3803  return c2_;
3804  }
3805  inline ::mondschein::io::mbd::data_vector *data_pose::release_c2()
3806  {
3807  clear_has_c2();
3808  ::mondschein::io::mbd::data_vector *temp = c2_;
3809  c2_ = NULL;
3810  return temp;
3811  }
3812  inline void data_pose::set_allocated_c2(::mondschein::io::mbd::data_vector *c2)
3813  {
3814  delete c2_;
3815  c2_ = c2;
3816  if (c2)
3817  {
3818  set_has_c2();
3819  }
3820  else
3821  {
3822  clear_has_c2();
3823  }
3824  }
3825 
3826  // required .mondschein.io.mbd.data.vector c3 = 4;
3827  inline bool data_pose::has_c3() const
3828  {
3829  return (_has_bits_[0] & 0x00000008u) != 0;
3830  }
3831  inline void data_pose::set_has_c3()
3832  {
3833  _has_bits_[0] |= 0x00000008u;
3834  }
3835  inline void data_pose::clear_has_c3()
3836  {
3837  _has_bits_[0] &= ~0x00000008u;
3838  }
3839  inline void data_pose::clear_c3()
3840  {
3841  if (c3_ != NULL) c3_->::mondschein::io::mbd::data_vector::Clear();
3842  clear_has_c3();
3843  }
3844  inline const ::mondschein::io::mbd::data_vector &data_pose::c3() const
3845  {
3846  return c3_ != NULL ? *c3_ : *default_instance_->c3_;
3847  }
3848  inline ::mondschein::io::mbd::data_vector *data_pose::mutable_c3()
3849  {
3850  set_has_c3();
3851  if (c3_ == NULL) c3_ = new ::mondschein::io::mbd::data_vector;
3852  return c3_;
3853  }
3854  inline ::mondschein::io::mbd::data_vector *data_pose::release_c3()
3855  {
3856  clear_has_c3();
3857  ::mondschein::io::mbd::data_vector *temp = c3_;
3858  c3_ = NULL;
3859  return temp;
3860  }
3861  inline void data_pose::set_allocated_c3(::mondschein::io::mbd::data_vector *c3)
3862  {
3863  delete c3_;
3864  c3_ = c3;
3865  if (c3)
3866  {
3867  set_has_c3();
3868  }
3869  else
3870  {
3871  clear_has_c3();
3872  }
3873  }
3874 
3875  // required .mondschein.io.mbd.data.vector c4 = 5;
3876  inline bool data_pose::has_c4() const
3877  {
3878  return (_has_bits_[0] & 0x00000010u) != 0;
3879  }
3880  inline void data_pose::set_has_c4()
3881  {
3882  _has_bits_[0] |= 0x00000010u;
3883  }
3884  inline void data_pose::clear_has_c4()
3885  {
3886  _has_bits_[0] &= ~0x00000010u;
3887  }
3888  inline void data_pose::clear_c4()
3889  {
3890  if (c4_ != NULL) c4_->::mondschein::io::mbd::data_vector::Clear();
3891  clear_has_c4();
3892  }
3893  inline const ::mondschein::io::mbd::data_vector &data_pose::c4() const
3894  {
3895  return c4_ != NULL ? *c4_ : *default_instance_->c4_;
3896  }
3897  inline ::mondschein::io::mbd::data_vector *data_pose::mutable_c4()
3898  {
3899  set_has_c4();
3900  if (c4_ == NULL) c4_ = new ::mondschein::io::mbd::data_vector;
3901  return c4_;
3902  }
3903  inline ::mondschein::io::mbd::data_vector *data_pose::release_c4()
3904  {
3905  clear_has_c4();
3906  ::mondschein::io::mbd::data_vector *temp = c4_;
3907  c4_ = NULL;
3908  return temp;
3909  }
3910  inline void data_pose::set_allocated_c4(::mondschein::io::mbd::data_vector *c4)
3911  {
3912  delete c4_;
3913  c4_ = c4;
3914  if (c4)
3915  {
3916  set_has_c4();
3917  }
3918  else
3919  {
3920  clear_has_c4();
3921  }
3922  }
3923 
3924  // -------------------------------------------------------------------
3925 
3926  // data_texture
3927 
3928  // required string name = 1;
3929  inline bool data_texture::has_name() const
3930  {
3931  return (_has_bits_[0] & 0x00000001u) != 0;
3932  }
3933  inline void data_texture::set_has_name()
3934  {
3935  _has_bits_[0] |= 0x00000001u;
3936  }
3937  inline void data_texture::clear_has_name()
3938  {
3939  _has_bits_[0] &= ~0x00000001u;
3940  }
3941  inline void data_texture::clear_name()
3942  {
3943  if (name_ != &::google::protobuf::internal::kEmptyString)
3944  {
3945  name_->clear();
3946  }
3947  clear_has_name();
3948  }
3949  inline const ::std::string &data_texture::name() const
3950  {
3951  return *name_;
3952  }
3953  inline void data_texture::set_name(const ::std::string &value)
3954  {
3955  set_has_name();
3956  if (name_ == &::google::protobuf::internal::kEmptyString)
3957  {
3958  name_ = new ::std::string;
3959  }
3960  name_->assign(value);
3961  }
3962  inline void data_texture::set_name(const char *value)
3963  {
3964  set_has_name();
3965  if (name_ == &::google::protobuf::internal::kEmptyString)
3966  {
3967  name_ = new ::std::string;
3968  }
3969  name_->assign(value);
3970  }
3971  inline void data_texture::set_name(const char *value, size_t size)
3972  {
3973  set_has_name();
3974  if (name_ == &::google::protobuf::internal::kEmptyString)
3975  {
3976  name_ = new ::std::string;
3977  }
3978  name_->assign(reinterpret_cast<const char *>(value), size);
3979  }
3980  inline ::std::string *data_texture::mutable_name()
3981  {
3982  set_has_name();
3983  if (name_ == &::google::protobuf::internal::kEmptyString)
3984  {
3985  name_ = new ::std::string;
3986  }
3987  return name_;
3988  }
3989  inline ::std::string *data_texture::release_name()
3990  {
3991  clear_has_name();
3992  if (name_ == &::google::protobuf::internal::kEmptyString)
3993  {
3994  return NULL;
3995  }
3996  else
3997  {
3998  ::std::string *temp = name_;
3999  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
4000  return temp;
4001  }
4002  }
4003  inline void data_texture::set_allocated_name(::std::string *name)
4004  {
4005  if (name_ != &::google::protobuf::internal::kEmptyString)
4006  {
4007  delete name_;
4008  }
4009  if (name)
4010  {
4011  set_has_name();
4012  name_ = name;
4013  }
4014  else
4015  {
4016  clear_has_name();
4017  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
4018  }
4019  }
4020 
4021  // required uint32 unit = 2;
4022  inline bool data_texture::has_unit() const
4023  {
4024  return (_has_bits_[0] & 0x00000002u) != 0;
4025  }
4026  inline void data_texture::set_has_unit()
4027  {
4028  _has_bits_[0] |= 0x00000002u;
4029  }
4030  inline void data_texture::clear_has_unit()
4031  {
4032  _has_bits_[0] &= ~0x00000002u;
4033  }
4034  inline void data_texture::clear_unit()
4035  {
4036  unit_ = 0u;
4037  clear_has_unit();
4038  }
4039  inline ::google::protobuf::uint32 data_texture::unit() const
4040  {
4041  return unit_;
4042  }
4043  inline void data_texture::set_unit(::google::protobuf::uint32 value)
4044  {
4045  set_has_unit();
4046  unit_ = value;
4047  }
4048 
4049  // required .mondschein.io.mbd.texture_filtering_e texture_filter = 3;
4050  inline bool data_texture::has_texture_filter() const
4051  {
4052  return (_has_bits_[0] & 0x00000004u) != 0;
4053  }
4054  inline void data_texture::set_has_texture_filter()
4055  {
4056  _has_bits_[0] |= 0x00000004u;
4057  }
4058  inline void data_texture::clear_has_texture_filter()
4059  {
4060  _has_bits_[0] &= ~0x00000004u;
4061  }
4062  inline void data_texture::clear_texture_filter()
4063  {
4064  texture_filter_ = 0;
4065  clear_has_texture_filter();
4066  }
4067  inline ::mondschein::io::mbd::texture_filtering_e data_texture::texture_filter() const
4068  {
4069  return static_cast< ::mondschein::io::mbd::texture_filtering_e >(texture_filter_);
4070  }
4071  inline void data_texture::set_texture_attribs_filter(::mondschein::io::mbd::texture_filtering_e value)
4072  {
4073  assert(::mondschein::io::mbd::texture_filtering_e_IsValid(value));
4074  set_has_texture_filter();
4075  texture_filter_ = value;
4076  }
4077 
4078  // required uint32 anisotropic_filter = 4;
4079  inline bool data_texture::has_anisotropic_filter() const
4080  {
4081  return (_has_bits_[0] & 0x00000008u) != 0;
4082  }
4083  inline void data_texture::set_has_anisotropic_filter()
4084  {
4085  _has_bits_[0] |= 0x00000008u;
4086  }
4087  inline void data_texture::clear_has_anisotropic_filter()
4088  {
4089  _has_bits_[0] &= ~0x00000008u;
4090  }
4091  inline void data_texture::clear_anisotropic_filter()
4092  {
4093  anisotropic_filter_ = 0u;
4094  clear_has_anisotropic_filter();
4095  }
4096  inline ::google::protobuf::uint32 data_texture::anisotropic_filter() const
4097  {
4098  return anisotropic_filter_;
4099  }
4100  inline void data_texture::set_anisotropic_filter(::google::protobuf::uint32 value)
4101  {
4102  set_has_anisotropic_filter();
4103  anisotropic_filter_ = value;
4104  }
4105 
4106  // required string image = 5;
4107  inline bool data_texture::has_image() const
4108  {
4109  return (_has_bits_[0] & 0x00000010u) != 0;
4110  }
4111  inline void data_texture::set_has_image()
4112  {
4113  _has_bits_[0] |= 0x00000010u;
4114  }
4115  inline void data_texture::clear_has_image()
4116  {
4117  _has_bits_[0] &= ~0x00000010u;
4118  }
4119  inline void data_texture::clear_image()
4120  {
4121  if (image_ != &::google::protobuf::internal::kEmptyString)
4122  {
4123  image_->clear();
4124  }
4125  clear_has_image();
4126  }
4127  inline const ::std::string &data_texture::image() const
4128  {
4129  return *image_;
4130  }
4131  inline void data_texture::set_image(const ::std::string &value)
4132  {
4133  set_has_image();
4134  if (image_ == &::google::protobuf::internal::kEmptyString)
4135  {
4136  image_ = new ::std::string;
4137  }
4138  image_->assign(value);
4139  }
4140  inline void data_texture::set_image(const char *value)
4141  {
4142  set_has_image();
4143  if (image_ == &::google::protobuf::internal::kEmptyString)
4144  {
4145  image_ = new ::std::string;
4146  }
4147  image_->assign(value);
4148  }
4149  inline void data_texture::set_image(const char *value, size_t size)
4150  {
4151  set_has_image();
4152  if (image_ == &::google::protobuf::internal::kEmptyString)
4153  {
4154  image_ = new ::std::string;
4155  }
4156  image_->assign(reinterpret_cast<const char *>(value), size);
4157  }
4158  inline ::std::string *data_texture::mutable_image()
4159  {
4160  set_has_image();
4161  if (image_ == &::google::protobuf::internal::kEmptyString)
4162  {
4163  image_ = new ::std::string;
4164  }
4165  return image_;
4166  }
4167  inline ::std::string *data_texture::release_image()
4168  {
4169  clear_has_image();
4170  if (image_ == &::google::protobuf::internal::kEmptyString)
4171  {
4172  return NULL;
4173  }
4174  else
4175  {
4176  ::std::string *temp = image_;
4177  image_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
4178  return temp;
4179  }
4180  }
4181  inline void data_texture::set_allocated_image(::std::string *image)
4182  {
4183  if (image_ != &::google::protobuf::internal::kEmptyString)
4184  {
4185  delete image_;
4186  }
4187  if (image)
4188  {
4189  set_has_image();
4190  image_ = image;
4191  }
4192  else
4193  {
4194  clear_has_image();
4195  image_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
4196  }
4197  }
4198 
4199  // optional string format = 6;
4200  inline bool data_texture::has_format() const
4201  {
4202  return (_has_bits_[0] & 0x00000020u) != 0;
4203  }
4204  inline void data_texture::set_has_format()
4205  {
4206  _has_bits_[0] |= 0x00000020u;
4207  }
4208  inline void data_texture::clear_has_format()
4209  {
4210  _has_bits_[0] &= ~0x00000020u;
4211  }
4212  inline void data_texture::clear_format()
4213  {
4214  if (format_ != &::google::protobuf::internal::kEmptyString)
4215  {
4216  format_->clear();
4217  }
4218  clear_has_format();
4219  }
4220  inline const ::std::string &data_texture::format() const
4221  {
4222  return *format_;
4223  }
4224  inline void data_texture::set_format(const ::std::string &value)
4225  {
4226  set_has_format();
4227  if (format_ == &::google::protobuf::internal::kEmptyString)
4228  {
4229  format_ = new ::std::string;
4230  }
4231  format_->assign(value);
4232  }
4233  inline void data_texture::set_format(const char *value)
4234  {
4235  set_has_format();
4236  if (format_ == &::google::protobuf::internal::kEmptyString)
4237  {
4238  format_ = new ::std::string;
4239  }
4240  format_->assign(value);
4241  }
4242  inline void data_texture::set_format(const char *value, size_t size)
4243  {
4244  set_has_format();
4245  if (format_ == &::google::protobuf::internal::kEmptyString)
4246  {
4247  format_ = new ::std::string;
4248  }
4249  format_->assign(reinterpret_cast<const char *>(value), size);
4250  }
4251  inline ::std::string *data_texture::mutable_format()
4252  {
4253  set_has_format();
4254  if (format_ == &::google::protobuf::internal::kEmptyString)
4255  {
4256  format_ = new ::std::string;
4257  }
4258  return format_;
4259  }
4260  inline ::std::string *data_texture::release_format()
4261  {
4262  clear_has_format();
4263  if (format_ == &::google::protobuf::internal::kEmptyString)
4264  {
4265  return NULL;
4266  }
4267  else
4268  {
4269  ::std::string *temp = format_;
4270  format_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
4271  return temp;
4272  }
4273  }
4274  inline void data_texture::set_allocated_format(::std::string *format)
4275  {
4276  if (format_ != &::google::protobuf::internal::kEmptyString)
4277  {
4278  delete format_;
4279  }
4280  if (format)
4281  {
4282  set_has_format();
4283  format_ = format;
4284  }
4285  else
4286  {
4287  clear_has_format();
4288  format_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
4289  }
4290  }
4291 
4292  // -------------------------------------------------------------------
4293 
4294  // data_scenegraph_attribs_tuple
4295 
4296  // required uint32 src = 1;
4297  inline bool data_scenegraph_attribs_tuple::has_src() const
4298  {
4299  return (_has_bits_[0] & 0x00000001u) != 0;
4300  }
4301  inline void data_scenegraph_attribs_tuple::set_has_src()
4302  {
4303  _has_bits_[0] |= 0x00000001u;
4304  }
4305  inline void data_scenegraph_attribs_tuple::clear_has_src()
4306  {
4307  _has_bits_[0] &= ~0x00000001u;
4308  }
4309  inline void data_scenegraph_attribs_tuple::clear_src()
4310  {
4311  src_ = 0u;
4312  clear_has_src();
4313  }
4314  inline ::google::protobuf::uint32 data_scenegraph_attribs_tuple::src() const
4315  {
4316  return src_;
4317  }
4318  inline void data_scenegraph_attribs_tuple::set_src(::google::protobuf::uint32 value)
4319  {
4320  set_has_src();
4321  src_ = value;
4322  }
4323 
4324  // required uint32 dst = 2;
4325  inline bool data_scenegraph_attribs_tuple::has_dst() const
4326  {
4327  return (_has_bits_[0] & 0x00000002u) != 0;
4328  }
4329  inline void data_scenegraph_attribs_tuple::set_has_dst()
4330  {
4331  _has_bits_[0] |= 0x00000002u;
4332  }
4333  inline void data_scenegraph_attribs_tuple::clear_has_dst()
4334  {
4335  _has_bits_[0] &= ~0x00000002u;
4336  }
4337  inline void data_scenegraph_attribs_tuple::clear_dst()
4338  {
4339  dst_ = 0u;
4340  clear_has_dst();
4341  }
4342  inline ::google::protobuf::uint32 data_scenegraph_attribs_tuple::dst() const
4343  {
4344  return dst_;
4345  }
4346  inline void data_scenegraph_attribs_tuple::set_dst(::google::protobuf::uint32 value)
4347  {
4348  set_has_dst();
4349  dst_ = value;
4350  }
4351 
4352  // -------------------------------------------------------------------
4353 
4354  // data_scenegraph
4355 
4356  // required string name = 1;
4357  inline bool data_scenegraph::has_name() const
4358  {
4359  return (_has_bits_[0] & 0x00000001u) != 0;
4360  }
4361  inline void data_scenegraph::set_has_name()
4362  {
4363  _has_bits_[0] |= 0x00000001u;
4364  }
4365  inline void data_scenegraph::clear_has_name()
4366  {
4367  _has_bits_[0] &= ~0x00000001u;
4368  }
4369  inline void data_scenegraph::clear_name()
4370  {
4371  if (name_ != &::google::protobuf::internal::kEmptyString)
4372  {
4373  name_->clear();
4374  }
4375  clear_has_name();
4376  }
4377  inline const ::std::string &data_scenegraph::name() const
4378  {
4379  return *name_;
4380  }
4381  inline void data_scenegraph::set_name(const ::std::string &value)
4382  {
4383  set_has_name();
4384  if (name_ == &::google::protobuf::internal::kEmptyString)
4385  {
4386  name_ = new ::std::string;
4387  }
4388  name_->assign(value);
4389  }
4390  inline void data_scenegraph::set_name(const char *value)
4391  {
4392  set_has_name();
4393  if (name_ == &::google::protobuf::internal::kEmptyString)
4394  {
4395  name_ = new ::std::string;
4396  }
4397  name_->assign(value);
4398  }
4399  inline void data_scenegraph::set_name(const char *value, size_t size)
4400  {
4401  set_has_name();
4402  if (name_ == &::google::protobuf::internal::kEmptyString)
4403  {
4404  name_ = new ::std::string;
4405  }
4406  name_->assign(reinterpret_cast<const char *>(value), size);
4407  }
4408  inline ::std::string *data_scenegraph::mutable_name()
4409  {
4410  set_has_name();
4411  if (name_ == &::google::protobuf::internal::kEmptyString)
4412  {
4413  name_ = new ::std::string;
4414  }
4415  return name_;
4416  }
4417  inline ::std::string *data_scenegraph::release_name()
4418  {
4419  clear_has_name();
4420  if (name_ == &::google::protobuf::internal::kEmptyString)
4421  {
4422  return NULL;
4423  }
4424  else
4425  {
4426  ::std::string *temp = name_;
4427  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
4428  return temp;
4429  }
4430  }
4431  inline void data_scenegraph::set_allocated_name(::std::string *name)
4432  {
4433  if (name_ != &::google::protobuf::internal::kEmptyString)
4434  {
4435  delete name_;
4436  }
4437  if (name)
4438  {
4439  set_has_name();
4440  name_ = name;
4441  }
4442  else
4443  {
4444  clear_has_name();
4445  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
4446  }
4447  }
4448 
4449  // repeated string nodes = 2;
4450  inline int data_scenegraph::nodes_size() const
4451  {
4452  return nodes_.size();
4453  }
4454  inline void data_scenegraph::clear_nodes()
4455  {
4456  nodes_.Clear();
4457  }
4458  inline const ::std::string &data_scenegraph::nodes(int index) const
4459  {
4460  return nodes_.Get(index);
4461  }
4462  inline ::std::string *data_scenegraph::mutable_nodes(int index)
4463  {
4464  return nodes_.Mutable(index);
4465  }
4466  inline void data_scenegraph::set_nodes(int index, const ::std::string &value)
4467  {
4468  nodes_.Mutable(index)->assign(value);
4469  }
4470  inline void data_scenegraph::set_nodes(int index, const char *value)
4471  {
4472  nodes_.Mutable(index)->assign(value);
4473  }
4474  inline void data_scenegraph::set_nodes(int index, const char *value, size_t size)
4475  {
4476  nodes_.Mutable(index)->assign(
4477  reinterpret_cast<const char *>(value), size);
4478  }
4479  inline ::std::string *data_scenegraph::add_nodes()
4480  {
4481  return nodes_.Add();
4482  }
4483  inline void data_scenegraph::add_nodes(const ::std::string &value)
4484  {
4485  nodes_.Add()->assign(value);
4486  }
4487  inline void data_scenegraph::add_nodes(const char *value)
4488  {
4489  nodes_.Add()->assign(value);
4490  }
4491  inline void data_scenegraph::add_nodes(const char *value, size_t size)
4492  {
4493  nodes_.Add()->assign(reinterpret_cast<const char *>(value), size);
4494  }
4495  inline const ::google::protobuf::RepeatedPtrField< ::std::string> &
4496  data_scenegraph::nodes() const
4497  {
4498  return nodes_;
4499  }
4500  inline ::google::protobuf::RepeatedPtrField< ::std::string> *
4501  data_scenegraph::mutable_nodes()
4502  {
4503  return &nodes_;
4504  }
4505 
4506  // repeated .mondschein.io.mbd.data.scenegraph.tuple edges = 3;
4507  inline int data_scenegraph::edges_size() const
4508  {
4509  return edges_.size();
4510  }
4511  inline void data_scenegraph::clear_edges()
4512  {
4513  edges_.Clear();
4514  }
4515  inline const ::mondschein::io::mbd::data_scenegraph_attribs_tuple &data_scenegraph::edges(int index) const
4516  {
4517  return edges_.Get(index);
4518  }
4519  inline ::mondschein::io::mbd::data_scenegraph_attribs_tuple *data_scenegraph::mutable_edges(int index)
4520  {
4521  return edges_.Mutable(index);
4522  }
4523  inline ::mondschein::io::mbd::data_scenegraph_attribs_tuple *data_scenegraph::add_edges()
4524  {
4525  return edges_.Add();
4526  }
4527  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_scenegraph_attribs_tuple > &
4528  data_scenegraph::edges() const
4529  {
4530  return edges_;
4531  }
4532  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_scenegraph_attribs_tuple > *
4533  data_scenegraph::mutable_edges()
4534  {
4535  return &edges_;
4536  }
4537 
4538  // -------------------------------------------------------------------
4539 
4540  // data_beziercurve
4541 
4542  // required string name = 1;
4543  inline bool data_beziercurve::has_name() const
4544  {
4545  return (_has_bits_[0] & 0x00000001u) != 0;
4546  }
4547  inline void data_beziercurve::set_has_name()
4548  {
4549  _has_bits_[0] |= 0x00000001u;
4550  }
4551  inline void data_beziercurve::clear_has_name()
4552  {
4553  _has_bits_[0] &= ~0x00000001u;
4554  }
4555  inline void data_beziercurve::clear_name()
4556  {
4557  if (name_ != &::google::protobuf::internal::kEmptyString)
4558  {
4559  name_->clear();
4560  }
4561  clear_has_name();
4562  }
4563  inline const ::std::string &data_beziercurve::name() const
4564  {
4565  return *name_;
4566  }
4567  inline void data_beziercurve::set_name(const ::std::string &value)
4568  {
4569  set_has_name();
4570  if (name_ == &::google::protobuf::internal::kEmptyString)
4571  {
4572  name_ = new ::std::string;
4573  }
4574  name_->assign(value);
4575  }
4576  inline void data_beziercurve::set_name(const char *value)
4577  {
4578  set_has_name();
4579  if (name_ == &::google::protobuf::internal::kEmptyString)
4580  {
4581  name_ = new ::std::string;
4582  }
4583  name_->assign(value);
4584  }
4585  inline void data_beziercurve::set_name(const char *value, size_t size)
4586  {
4587  set_has_name();
4588  if (name_ == &::google::protobuf::internal::kEmptyString)
4589  {
4590  name_ = new ::std::string;
4591  }
4592  name_->assign(reinterpret_cast<const char *>(value), size);
4593  }
4594  inline ::std::string *data_beziercurve::mutable_name()
4595  {
4596  set_has_name();
4597  if (name_ == &::google::protobuf::internal::kEmptyString)
4598  {
4599  name_ = new ::std::string;
4600  }
4601  return name_;
4602  }
4603  inline ::std::string *data_beziercurve::release_name()
4604  {
4605  clear_has_name();
4606  if (name_ == &::google::protobuf::internal::kEmptyString)
4607  {
4608  return NULL;
4609  }
4610  else
4611  {
4612  ::std::string *temp = name_;
4613  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
4614  return temp;
4615  }
4616  }
4617  inline void data_beziercurve::set_allocated_name(::std::string *name)
4618  {
4619  if (name_ != &::google::protobuf::internal::kEmptyString)
4620  {
4621  delete name_;
4622  }
4623  if (name)
4624  {
4625  set_has_name();
4626  name_ = name;
4627  }
4628  else
4629  {
4630  clear_has_name();
4631  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
4632  }
4633  }
4634 
4635  // repeated .mondschein.io.mbd.data.vector points = 2;
4636  inline int data_beziercurve::points_size() const
4637  {
4638  return points_.size();
4639  }
4640  inline void data_beziercurve::clear_points()
4641  {
4642  points_.Clear();
4643  }
4644  inline const ::mondschein::io::mbd::data_vector &data_beziercurve::points(int index) const
4645  {
4646  return points_.Get(index);
4647  }
4648  inline ::mondschein::io::mbd::data_vector *data_beziercurve::mutable_points(int index)
4649  {
4650  return points_.Mutable(index);
4651  }
4652  inline ::mondschein::io::mbd::data_vector *data_beziercurve::add_points()
4653  {
4654  return points_.Add();
4655  }
4656  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > &
4657  data_beziercurve::points() const
4658  {
4659  return points_;
4660  }
4661  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > *
4662  data_beziercurve::mutable_points()
4663  {
4664  return &points_;
4665  }
4666 
4667  // optional .mondschein.io.mbd.normal_e normals = 3;
4668  inline bool data_beziercurve::has_normals() const
4669  {
4670  return (_has_bits_[0] & 0x00000004u) != 0;
4671  }
4672  inline void data_beziercurve::set_has_normals()
4673  {
4674  _has_bits_[0] |= 0x00000004u;
4675  }
4676  inline void data_beziercurve::clear_has_normals()
4677  {
4678  _has_bits_[0] &= ~0x00000004u;
4679  }
4680  inline void data_beziercurve::clear_normals()
4681  {
4682  normals_ = 0;
4683  clear_has_normals();
4684  }
4685  inline ::mondschein::io::mbd::normal_e data_beziercurve::normals() const
4686  {
4687  return static_cast< ::mondschein::io::mbd::normal_e >(normals_);
4688  }
4689  inline void data_beziercurve::set_normals(::mondschein::io::mbd::normal_e value)
4690  {
4691  assert(::mondschein::io::mbd::normal_e_IsValid(value));
4692  set_has_normals();
4693  normals_ = value;
4694  }
4695 
4696  // -------------------------------------------------------------------
4697 
4698  // data_bezierpatch
4699 
4700  // required string name = 1;
4701  inline bool data_bezierpatch::has_name() const
4702  {
4703  return (_has_bits_[0] & 0x00000001u) != 0;
4704  }
4705  inline void data_bezierpatch::set_has_name()
4706  {
4707  _has_bits_[0] |= 0x00000001u;
4708  }
4709  inline void data_bezierpatch::clear_has_name()
4710  {
4711  _has_bits_[0] &= ~0x00000001u;
4712  }
4713  inline void data_bezierpatch::clear_name()
4714  {
4715  if (name_ != &::google::protobuf::internal::kEmptyString)
4716  {
4717  name_->clear();
4718  }
4719  clear_has_name();
4720  }
4721  inline const ::std::string &data_bezierpatch::name() const
4722  {
4723  return *name_;
4724  }
4725  inline void data_bezierpatch::set_name(const ::std::string &value)
4726  {
4727  set_has_name();
4728  if (name_ == &::google::protobuf::internal::kEmptyString)
4729  {
4730  name_ = new ::std::string;
4731  }
4732  name_->assign(value);
4733  }
4734  inline void data_bezierpatch::set_name(const char *value)
4735  {
4736  set_has_name();
4737  if (name_ == &::google::protobuf::internal::kEmptyString)
4738  {
4739  name_ = new ::std::string;
4740  }
4741  name_->assign(value);
4742  }
4743  inline void data_bezierpatch::set_name(const char *value, size_t size)
4744  {
4745  set_has_name();
4746  if (name_ == &::google::protobuf::internal::kEmptyString)
4747  {
4748  name_ = new ::std::string;
4749  }
4750  name_->assign(reinterpret_cast<const char *>(value), size);
4751  }
4752  inline ::std::string *data_bezierpatch::mutable_name()
4753  {
4754  set_has_name();
4755  if (name_ == &::google::protobuf::internal::kEmptyString)
4756  {
4757  name_ = new ::std::string;
4758  }
4759  return name_;
4760  }
4761  inline ::std::string *data_bezierpatch::release_name()
4762  {
4763  clear_has_name();
4764  if (name_ == &::google::protobuf::internal::kEmptyString)
4765  {
4766  return NULL;
4767  }
4768  else
4769  {
4770  ::std::string *temp = name_;
4771  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
4772  return temp;
4773  }
4774  }
4775  inline void data_bezierpatch::set_allocated_name(::std::string *name)
4776  {
4777  if (name_ != &::google::protobuf::internal::kEmptyString)
4778  {
4779  delete name_;
4780  }
4781  if (name)
4782  {
4783  set_has_name();
4784  name_ = name;
4785  }
4786  else
4787  {
4788  clear_has_name();
4789  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
4790  }
4791  }
4792 
4793  // repeated .mondschein.io.mbd.data.beziercurve curves = 2;
4794  inline int data_bezierpatch::curves_size() const
4795  {
4796  return curves_.size();
4797  }
4798  inline void data_bezierpatch::clear_curves()
4799  {
4800  curves_.Clear();
4801  }
4802  inline const ::mondschein::io::mbd::data_beziercurve &data_bezierpatch::curves(int index) const
4803  {
4804  return curves_.Get(index);
4805  }
4806  inline ::mondschein::io::mbd::data_beziercurve *data_bezierpatch::mutable_curves(int index)
4807  {
4808  return curves_.Mutable(index);
4809  }
4810  inline ::mondschein::io::mbd::data_beziercurve *data_bezierpatch::add_curves()
4811  {
4812  return curves_.Add();
4813  }
4814  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_beziercurve > &
4815  data_bezierpatch::curves() const
4816  {
4817  return curves_;
4818  }
4819  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_beziercurve > *
4820  data_bezierpatch::mutable_curves()
4821  {
4822  return &curves_;
4823  }
4824 
4825  // optional .mondschein.io.mbd.normal_e normals = 3;
4826  inline bool data_bezierpatch::has_normals() const
4827  {
4828  return (_has_bits_[0] & 0x00000004u) != 0;
4829  }
4830  inline void data_bezierpatch::set_has_normals()
4831  {
4832  _has_bits_[0] |= 0x00000004u;
4833  }
4834  inline void data_bezierpatch::clear_has_normals()
4835  {
4836  _has_bits_[0] &= ~0x00000004u;
4837  }
4838  inline void data_bezierpatch::clear_normals()
4839  {
4840  normals_ = 0;
4841  clear_has_normals();
4842  }
4843  inline ::mondschein::io::mbd::normal_e data_bezierpatch::normals() const
4844  {
4845  return static_cast< ::mondschein::io::mbd::normal_e >(normals_);
4846  }
4847  inline void data_bezierpatch::set_normals(::mondschein::io::mbd::normal_e value)
4848  {
4849  assert(::mondschein::io::mbd::normal_e_IsValid(value));
4850  set_has_normals();
4851  normals_ = value;
4852  }
4853 
4854  // -------------------------------------------------------------------
4855 
4856  // data_nurbscurve
4857 
4858  // required string name = 1;
4859  inline bool data_nurbscurve::has_name() const
4860  {
4861  return (_has_bits_[0] & 0x00000001u) != 0;
4862  }
4863  inline void data_nurbscurve::set_has_name()
4864  {
4865  _has_bits_[0] |= 0x00000001u;
4866  }
4867  inline void data_nurbscurve::clear_has_name()
4868  {
4869  _has_bits_[0] &= ~0x00000001u;
4870  }
4871  inline void data_nurbscurve::clear_name()
4872  {
4873  if (name_ != &::google::protobuf::internal::kEmptyString)
4874  {
4875  name_->clear();
4876  }
4877  clear_has_name();
4878  }
4879  inline const ::std::string &data_nurbscurve::name() const
4880  {
4881  return *name_;
4882  }
4883  inline void data_nurbscurve::set_name(const ::std::string &value)
4884  {
4885  set_has_name();
4886  if (name_ == &::google::protobuf::internal::kEmptyString)
4887  {
4888  name_ = new ::std::string;
4889  }
4890  name_->assign(value);
4891  }
4892  inline void data_nurbscurve::set_name(const char *value)
4893  {
4894  set_has_name();
4895  if (name_ == &::google::protobuf::internal::kEmptyString)
4896  {
4897  name_ = new ::std::string;
4898  }
4899  name_->assign(value);
4900  }
4901  inline void data_nurbscurve::set_name(const char *value, size_t size)
4902  {
4903  set_has_name();
4904  if (name_ == &::google::protobuf::internal::kEmptyString)
4905  {
4906  name_ = new ::std::string;
4907  }
4908  name_->assign(reinterpret_cast<const char *>(value), size);
4909  }
4910  inline ::std::string *data_nurbscurve::mutable_name()
4911  {
4912  set_has_name();
4913  if (name_ == &::google::protobuf::internal::kEmptyString)
4914  {
4915  name_ = new ::std::string;
4916  }
4917  return name_;
4918  }
4919  inline ::std::string *data_nurbscurve::release_name()
4920  {
4921  clear_has_name();
4922  if (name_ == &::google::protobuf::internal::kEmptyString)
4923  {
4924  return NULL;
4925  }
4926  else
4927  {
4928  ::std::string *temp = name_;
4929  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
4930  return temp;
4931  }
4932  }
4933  inline void data_nurbscurve::set_allocated_name(::std::string *name)
4934  {
4935  if (name_ != &::google::protobuf::internal::kEmptyString)
4936  {
4937  delete name_;
4938  }
4939  if (name)
4940  {
4941  set_has_name();
4942  name_ = name;
4943  }
4944  else
4945  {
4946  clear_has_name();
4947  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
4948  }
4949  }
4950 
4951  // required uint32 dimension = 2;
4952  inline bool data_nurbscurve::has_dimension() const
4953  {
4954  return (_has_bits_[0] & 0x00000002u) != 0;
4955  }
4956  inline void data_nurbscurve::set_has_dimension()
4957  {
4958  _has_bits_[0] |= 0x00000002u;
4959  }
4960  inline void data_nurbscurve::clear_has_dimension()
4961  {
4962  _has_bits_[0] &= ~0x00000002u;
4963  }
4964  inline void data_nurbscurve::clear_dimension()
4965  {
4966  dimension_ = 0u;
4967  clear_has_dimension();
4968  }
4969  inline ::google::protobuf::uint32 data_nurbscurve::dimension() const
4970  {
4971  return dimension_;
4972  }
4973  inline void data_nurbscurve::set_dimension(::google::protobuf::uint32 value)
4974  {
4975  set_has_dimension();
4976  dimension_ = value;
4977  }
4978 
4979  // repeated .mondschein.io.mbd.data.vector points = 3;
4980  inline int data_nurbscurve::points_size() const
4981  {
4982  return points_.size();
4983  }
4984  inline void data_nurbscurve::clear_points()
4985  {
4986  points_.Clear();
4987  }
4988  inline const ::mondschein::io::mbd::data_vector &data_nurbscurve::points(int index) const
4989  {
4990  return points_.Get(index);
4991  }
4992  inline ::mondschein::io::mbd::data_vector *data_nurbscurve::mutable_points(int index)
4993  {
4994  return points_.Mutable(index);
4995  }
4996  inline ::mondschein::io::mbd::data_vector *data_nurbscurve::add_points()
4997  {
4998  return points_.Add();
4999  }
5000  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > &
5001  data_nurbscurve::points() const
5002  {
5003  return points_;
5004  }
5005  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_vector > *
5006  data_nurbscurve::mutable_points()
5007  {
5008  return &points_;
5009  }
5010 
5011  // optional .mondschein.io.mbd.normal_e normals = 4;
5012  inline bool data_nurbscurve::has_normals() const
5013  {
5014  return (_has_bits_[0] & 0x00000008u) != 0;
5015  }
5016  inline void data_nurbscurve::set_has_normals()
5017  {
5018  _has_bits_[0] |= 0x00000008u;
5019  }
5020  inline void data_nurbscurve::clear_has_normals()
5021  {
5022  _has_bits_[0] &= ~0x00000008u;
5023  }
5024  inline void data_nurbscurve::clear_normals()
5025  {
5026  normals_ = 0;
5027  clear_has_normals();
5028  }
5029  inline ::mondschein::io::mbd::normal_e data_nurbscurve::normals() const
5030  {
5031  return static_cast< ::mondschein::io::mbd::normal_e >(normals_);
5032  }
5033  inline void data_nurbscurve::set_normals(::mondschein::io::mbd::normal_e value)
5034  {
5035  assert(::mondschein::io::mbd::normal_e_IsValid(value));
5036  set_has_normals();
5037  normals_ = value;
5038  }
5039 
5040  // -------------------------------------------------------------------
5041 
5042  // data_nurbspatch
5043 
5044  // required string name = 1;
5045  inline bool data_nurbspatch::has_name() const
5046  {
5047  return (_has_bits_[0] & 0x00000001u) != 0;
5048  }
5049  inline void data_nurbspatch::set_has_name()
5050  {
5051  _has_bits_[0] |= 0x00000001u;
5052  }
5053  inline void data_nurbspatch::clear_has_name()
5054  {
5055  _has_bits_[0] &= ~0x00000001u;
5056  }
5057  inline void data_nurbspatch::clear_name()
5058  {
5059  if (name_ != &::google::protobuf::internal::kEmptyString)
5060  {
5061  name_->clear();
5062  }
5063  clear_has_name();
5064  }
5065  inline const ::std::string &data_nurbspatch::name() const
5066  {
5067  return *name_;
5068  }
5069  inline void data_nurbspatch::set_name(const ::std::string &value)
5070  {
5071  set_has_name();
5072  if (name_ == &::google::protobuf::internal::kEmptyString)
5073  {
5074  name_ = new ::std::string;
5075  }
5076  name_->assign(value);
5077  }
5078  inline void data_nurbspatch::set_name(const char *value)
5079  {
5080  set_has_name();
5081  if (name_ == &::google::protobuf::internal::kEmptyString)
5082  {
5083  name_ = new ::std::string;
5084  }
5085  name_->assign(value);
5086  }
5087  inline void data_nurbspatch::set_name(const char *value, size_t size)
5088  {
5089  set_has_name();
5090  if (name_ == &::google::protobuf::internal::kEmptyString)
5091  {
5092  name_ = new ::std::string;
5093  }
5094  name_->assign(reinterpret_cast<const char *>(value), size);
5095  }
5096  inline ::std::string *data_nurbspatch::mutable_name()
5097  {
5098  set_has_name();
5099  if (name_ == &::google::protobuf::internal::kEmptyString)
5100  {
5101  name_ = new ::std::string;
5102  }
5103  return name_;
5104  }
5105  inline ::std::string *data_nurbspatch::release_name()
5106  {
5107  clear_has_name();
5108  if (name_ == &::google::protobuf::internal::kEmptyString)
5109  {
5110  return NULL;
5111  }
5112  else
5113  {
5114  ::std::string *temp = name_;
5115  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
5116  return temp;
5117  }
5118  }
5119  inline void data_nurbspatch::set_allocated_name(::std::string *name)
5120  {
5121  if (name_ != &::google::protobuf::internal::kEmptyString)
5122  {
5123  delete name_;
5124  }
5125  if (name)
5126  {
5127  set_has_name();
5128  name_ = name;
5129  }
5130  else
5131  {
5132  clear_has_name();
5133  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
5134  }
5135  }
5136 
5137  // required uint32 dimension = 2;
5138  inline bool data_nurbspatch::has_dimension() const
5139  {
5140  return (_has_bits_[0] & 0x00000002u) != 0;
5141  }
5142  inline void data_nurbspatch::set_has_dimension()
5143  {
5144  _has_bits_[0] |= 0x00000002u;
5145  }
5146  inline void data_nurbspatch::clear_has_dimension()
5147  {
5148  _has_bits_[0] &= ~0x00000002u;
5149  }
5150  inline void data_nurbspatch::clear_dimension()
5151  {
5152  dimension_ = 0u;
5153  clear_has_dimension();
5154  }
5155  inline ::google::protobuf::uint32 data_nurbspatch::dimension() const
5156  {
5157  return dimension_;
5158  }
5159  inline void data_nurbspatch::set_dimension(::google::protobuf::uint32 value)
5160  {
5161  set_has_dimension();
5162  dimension_ = value;
5163  }
5164 
5165  // repeated .mondschein.io.mbd.data.nurbscurve curves = 3;
5166  inline int data_nurbspatch::curves_size() const
5167  {
5168  return curves_.size();
5169  }
5170  inline void data_nurbspatch::clear_curves()
5171  {
5172  curves_.Clear();
5173  }
5174  inline const ::mondschein::io::mbd::data_nurbscurve &data_nurbspatch::curves(int index) const
5175  {
5176  return curves_.Get(index);
5177  }
5178  inline ::mondschein::io::mbd::data_nurbscurve *data_nurbspatch::mutable_curves(int index)
5179  {
5180  return curves_.Mutable(index);
5181  }
5182  inline ::mondschein::io::mbd::data_nurbscurve *data_nurbspatch::add_curves()
5183  {
5184  return curves_.Add();
5185  }
5186  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_nurbscurve > &
5187  data_nurbspatch::curves() const
5188  {
5189  return curves_;
5190  }
5191  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_nurbscurve > *
5192  data_nurbspatch::mutable_curves()
5193  {
5194  return &curves_;
5195  }
5196 
5197  // optional .mondschein.io.mbd.normal_e normals = 4;
5198  inline bool data_nurbspatch::has_normals() const
5199  {
5200  return (_has_bits_[0] & 0x00000008u) != 0;
5201  }
5202  inline void data_nurbspatch::set_has_normals()
5203  {
5204  _has_bits_[0] |= 0x00000008u;
5205  }
5206  inline void data_nurbspatch::clear_has_normals()
5207  {
5208  _has_bits_[0] &= ~0x00000008u;
5209  }
5210  inline void data_nurbspatch::clear_normals()
5211  {
5212  normals_ = 0;
5213  clear_has_normals();
5214  }
5215  inline ::mondschein::io::mbd::normal_e data_nurbspatch::normals() const
5216  {
5217  return static_cast< ::mondschein::io::mbd::normal_e >(normals_);
5218  }
5219  inline void data_nurbspatch::set_normals(::mondschein::io::mbd::normal_e value)
5220  {
5221  assert(::mondschein::io::mbd::normal_e_IsValid(value));
5222  set_has_normals();
5223  normals_ = value;
5224  }
5225 
5226  // -------------------------------------------------------------------
5227 
5228  // data
5229 
5230  // required string name = 1;
5231  inline bool data::has_name() const
5232  {
5233  return (_has_bits_[0] & 0x00000001u) != 0;
5234  }
5235  inline void data::set_has_name()
5236  {
5237  _has_bits_[0] |= 0x00000001u;
5238  }
5239  inline void data::clear_has_name()
5240  {
5241  _has_bits_[0] &= ~0x00000001u;
5242  }
5243  inline void data::clear_name()
5244  {
5245  if (name_ != &::google::protobuf::internal::kEmptyString)
5246  {
5247  name_->clear();
5248  }
5249  clear_has_name();
5250  }
5251  inline const ::std::string &data::name() const
5252  {
5253  return *name_;
5254  }
5255  inline void data::set_name(const ::std::string &value)
5256  {
5257  set_has_name();
5258  if (name_ == &::google::protobuf::internal::kEmptyString)
5259  {
5260  name_ = new ::std::string;
5261  }
5262  name_->assign(value);
5263  }
5264  inline void data::set_name(const char *value)
5265  {
5266  set_has_name();
5267  if (name_ == &::google::protobuf::internal::kEmptyString)
5268  {
5269  name_ = new ::std::string;
5270  }
5271  name_->assign(value);
5272  }
5273  inline void data::set_name(const char *value, size_t size)
5274  {
5275  set_has_name();
5276  if (name_ == &::google::protobuf::internal::kEmptyString)
5277  {
5278  name_ = new ::std::string;
5279  }
5280  name_->assign(reinterpret_cast<const char *>(value), size);
5281  }
5282  inline ::std::string *data::mutable_name()
5283  {
5284  set_has_name();
5285  if (name_ == &::google::protobuf::internal::kEmptyString)
5286  {
5287  name_ = new ::std::string;
5288  }
5289  return name_;
5290  }
5291  inline ::std::string *data::release_name()
5292  {
5293  clear_has_name();
5294  if (name_ == &::google::protobuf::internal::kEmptyString)
5295  {
5296  return NULL;
5297  }
5298  else
5299  {
5300  ::std::string *temp = name_;
5301  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
5302  return temp;
5303  }
5304  }
5305  inline void data::set_allocated_name(::std::string *name)
5306  {
5307  if (name_ != &::google::protobuf::internal::kEmptyString)
5308  {
5309  delete name_;
5310  }
5311  if (name)
5312  {
5313  set_has_name();
5314  name_ = name;
5315  }
5316  else
5317  {
5318  clear_has_name();
5319  name_ = const_cast< ::std::string *>(&::google::protobuf::internal::kEmptyString);
5320  }
5321  }
5322 
5323  // repeated .mondschein.io.mbd.data.camera cameras = 2;
5324  inline int data::cameras_size() const
5325  {
5326  return cameras_.size();
5327  }
5328  inline void data::clear_cameras()
5329  {
5330  cameras_.Clear();
5331  }
5332  inline const ::mondschein::io::mbd::data_camera &data::cameras(int index) const
5333  {
5334  return cameras_.Get(index);
5335  }
5336  inline ::mondschein::io::mbd::data_camera *data::mutable_cameras(int index)
5337  {
5338  return cameras_.Mutable(index);
5339  }
5340  inline ::mondschein::io::mbd::data_camera *data::add_cameras()
5341  {
5342  return cameras_.Add();
5343  }
5344  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_camera > &
5345  data::cameras() const
5346  {
5347  return cameras_;
5348  }
5349  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_camera > *
5350  data::mutable_cameras()
5351  {
5352  return &cameras_;
5353  }
5354 
5355  // repeated .mondschein.io.mbd.data.light lights = 3;
5356  inline int data::lights_size() const
5357  {
5358  return lights_.size();
5359  }
5360  inline void data::clear_lights()
5361  {
5362  lights_.Clear();
5363  }
5364  inline const ::mondschein::io::mbd::data_light &data::lights(int index) const
5365  {
5366  return lights_.Get(index);
5367  }
5368  inline ::mondschein::io::mbd::data_light *data::mutable_lights(int index)
5369  {
5370  return lights_.Mutable(index);
5371  }
5372  inline ::mondschein::io::mbd::data_light *data::add_lights()
5373  {
5374  return lights_.Add();
5375  }
5376  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_light > &
5377  data::lights() const
5378  {
5379  return lights_;
5380  }
5381  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_light > *
5382  data::mutable_lights()
5383  {
5384  return &lights_;
5385  }
5386 
5387  // repeated .mondschein.io.mbd.data.material materials = 4;
5388  inline int data::materials_size() const
5389  {
5390  return materials_.size();
5391  }
5392  inline void data::clear_materials()
5393  {
5394  materials_.Clear();
5395  }
5396  inline const ::mondschein::io::mbd::data_material &data::materials(int index) const
5397  {
5398  return materials_.Get(index);
5399  }
5400  inline ::mondschein::io::mbd::data_material *data::mutable_materials(int index)
5401  {
5402  return materials_.Mutable(index);
5403  }
5404  inline ::mondschein::io::mbd::data_material *data::add_materials()
5405  {
5406  return materials_.Add();
5407  }
5408  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_material > &
5409  data::materials() const
5410  {
5411  return materials_;
5412  }
5413  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_material > *
5414  data::mutable_materials()
5415  {
5416  return &materials_;
5417  }
5418 
5419  // repeated .mondschein.io.mbd.data.mesh meshes = 5;
5420  inline int data::meshes_size() const
5421  {
5422  return meshes_.size();
5423  }
5424  inline void data::clear_meshes()
5425  {
5426  meshes_.Clear();
5427  }
5428  inline const ::mondschein::io::mbd::data_mesh &data::meshes(int index) const
5429  {
5430  return meshes_.Get(index);
5431  }
5432  inline ::mondschein::io::mbd::data_mesh *data::mutable_meshes(int index)
5433  {
5434  return meshes_.Mutable(index);
5435  }
5436  inline ::mondschein::io::mbd::data_mesh *data::add_meshes()
5437  {
5438  return meshes_.Add();
5439  }
5440  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_mesh > &
5441  data::meshes() const
5442  {
5443  return meshes_;
5444  }
5445  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_mesh > *
5446  data::mutable_meshes()
5447  {
5448  return &meshes_;
5449  }
5450 
5451  // repeated .mondschein.io.mbd.data.pose poses = 6;
5452  inline int data::poses_size() const
5453  {
5454  return poses_.size();
5455  }
5456  inline void data::clear_poses()
5457  {
5458  poses_.Clear();
5459  }
5460  inline const ::mondschein::io::mbd::data_pose &data::poses(int index) const
5461  {
5462  return poses_.Get(index);
5463  }
5464  inline ::mondschein::io::mbd::data_pose *data::mutable_poses(int index)
5465  {
5466  return poses_.Mutable(index);
5467  }
5468  inline ::mondschein::io::mbd::data_pose *data::add_poses()
5469  {
5470  return poses_.Add();
5471  }
5472  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_pose > &
5473  data::poses() const
5474  {
5475  return poses_;
5476  }
5477  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_pose > *
5478  data::mutable_poses()
5479  {
5480  return &poses_;
5481  }
5482 
5483  // repeated .mondschein.io.mbd.data.texture textures = 7;
5484  inline int data::textures_size() const
5485  {
5486  return textures_.size();
5487  }
5488  inline void data::clear_textures()
5489  {
5490  textures_.Clear();
5491  }
5492  inline const ::mondschein::io::mbd::data_texture &data::textures(int index) const
5493  {
5494  return textures_.Get(index);
5495  }
5496  inline ::mondschein::io::mbd::data_texture *data::mutable_textures(int index)
5497  {
5498  return textures_.Mutable(index);
5499  }
5500  inline ::mondschein::io::mbd::data_texture *data::add_textures()
5501  {
5502  return textures_.Add();
5503  }
5504  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_texture > &
5505  data::textures() const
5506  {
5507  return textures_;
5508  }
5509  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_texture > *
5510  data::mutable_textures()
5511  {
5512  return &textures_;
5513  }
5514 
5515  // repeated .mondschein.io.mbd.data.beziercurve beziercurves = 8;
5516  inline int data::beziercurves_size() const
5517  {
5518  return beziercurves_.size();
5519  }
5520  inline void data::clear_beziercurves()
5521  {
5522  beziercurves_.Clear();
5523  }
5524  inline const ::mondschein::io::mbd::data_beziercurve &data::beziercurves(int index) const
5525  {
5526  return beziercurves_.Get(index);
5527  }
5528  inline ::mondschein::io::mbd::data_beziercurve *data::mutable_beziercurves(int index)
5529  {
5530  return beziercurves_.Mutable(index);
5531  }
5532  inline ::mondschein::io::mbd::data_beziercurve *data::add_beziercurves()
5533  {
5534  return beziercurves_.Add();
5535  }
5536  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_beziercurve > &
5537  data::beziercurves() const
5538  {
5539  return beziercurves_;
5540  }
5541  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_beziercurve > *
5542  data::mutable_beziercurves()
5543  {
5544  return &beziercurves_;
5545  }
5546 
5547  // repeated .mondschein.io.mbd.data.nurbscurve nurbscurves = 9;
5548  inline int data::nurbscurves_size() const
5549  {
5550  return nurbscurves_.size();
5551  }
5552  inline void data::clear_nurbscurves()
5553  {
5554  nurbscurves_.Clear();
5555  }
5556  inline const ::mondschein::io::mbd::data_nurbscurve &data::nurbscurves(int index) const
5557  {
5558  return nurbscurves_.Get(index);
5559  }
5560  inline ::mondschein::io::mbd::data_nurbscurve *data::mutable_nurbscurves(int index)
5561  {
5562  return nurbscurves_.Mutable(index);
5563  }
5564  inline ::mondschein::io::mbd::data_nurbscurve *data::add_nurbscurves()
5565  {
5566  return nurbscurves_.Add();
5567  }
5568  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_nurbscurve > &
5569  data::nurbscurves() const
5570  {
5571  return nurbscurves_;
5572  }
5573  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_nurbscurve > *
5574  data::mutable_nurbscurves()
5575  {
5576  return &nurbscurves_;
5577  }
5578 
5579  // repeated .mondschein.io.mbd.data.bezierpatch bezierpatches = 10;
5580  inline int data::bezierpatches_size() const
5581  {
5582  return bezierpatches_.size();
5583  }
5584  inline void data::clear_bezierpatches()
5585  {
5586  bezierpatches_.Clear();
5587  }
5588  inline const ::mondschein::io::mbd::data_bezierpatch &data::bezierpatches(int index) const
5589  {
5590  return bezierpatches_.Get(index);
5591  }
5592  inline ::mondschein::io::mbd::data_bezierpatch *data::mutable_bezierpatches(int index)
5593  {
5594  return bezierpatches_.Mutable(index);
5595  }
5596  inline ::mondschein::io::mbd::data_bezierpatch *data::add_bezierpatches()
5597  {
5598  return bezierpatches_.Add();
5599  }
5600  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_bezierpatch > &
5601  data::bezierpatches() const
5602  {
5603  return bezierpatches_;
5604  }
5605  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_bezierpatch > *
5606  data::mutable_bezierpatches()
5607  {
5608  return &bezierpatches_;
5609  }
5610 
5611  // repeated .mondschein.io.mbd.data.nurbspatch nurbspatches = 11;
5612  inline int data::nurbspatches_size() const
5613  {
5614  return nurbspatches_.size();
5615  }
5616  inline void data::clear_nurbspatches()
5617  {
5618  nurbspatches_.Clear();
5619  }
5620  inline const ::mondschein::io::mbd::data_nurbspatch &data::nurbspatches(int index) const
5621  {
5622  return nurbspatches_.Get(index);
5623  }
5624  inline ::mondschein::io::mbd::data_nurbspatch *data::mutable_nurbspatches(int index)
5625  {
5626  return nurbspatches_.Mutable(index);
5627  }
5628  inline ::mondschein::io::mbd::data_nurbspatch *data::add_nurbspatches()
5629  {
5630  return nurbspatches_.Add();
5631  }
5632  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_nurbspatch > &
5633  data::nurbspatches() const
5634  {
5635  return nurbspatches_;
5636  }
5637  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_nurbspatch > *
5638  data::mutable_nurbspatches()
5639  {
5640  return &nurbspatches_;
5641  }
5642 
5643  // repeated .mondschein.io.mbd.data.scenegraph scenegraphs = 12;
5644  inline int data::scenegraphs_size() const
5645  {
5646  return scenegraphs_.size();
5647  }
5648  inline void data::clear_scenegraphs()
5649  {
5650  scenegraphs_.Clear();
5651  }
5652  inline const ::mondschein::io::mbd::data_scenegraph &data::scenegraphs(int index) const
5653  {
5654  return scenegraphs_.Get(index);
5655  }
5656  inline ::mondschein::io::mbd::data_scenegraph *data::mutable_scenegraphs(int index)
5657  {
5658  return scenegraphs_.Mutable(index);
5659  }
5660  inline ::mondschein::io::mbd::data_scenegraph *data::add_scenegraphs()
5661  {
5662  return scenegraphs_.Add();
5663  }
5664  inline const ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_scenegraph > &
5665  data::scenegraphs() const
5666  {
5667  return scenegraphs_;
5668  }
5669  inline ::google::protobuf::RepeatedPtrField< ::mondschein::io::mbd::data_scenegraph > *
5670  data::mutable_scenegraphs()
5671  {
5672  return &scenegraphs_;
5673  }
5674 
5675 
5676  // @@protoc_insertion_point(namespace_scope)
5677 
5678  } // namespace mbd
5679  } // namespace io
5680 } // namespace mondschein
5681 
5682 #ifndef SWIG
5683 namespace google
5684 {
5685  namespace protobuf
5686  {
5687 
5688  template <>
5689  inline const EnumDescriptor *GetEnumDescriptor< ::mondschein::io::mbd::normal_e>()
5690  {
5691  return ::mondschein::io::mbd::normal_e_descriptor();
5692  }
5693  template <>
5694  inline const EnumDescriptor *GetEnumDescriptor< ::mondschein::io::mbd::texture_filtering_e>()
5695  {
5696  return ::mondschein::io::mbd::texture_filtering_e_descriptor();
5697  }
5698 
5699  } // namespace google
5700 } // namespace protobuf
5701 #endif // SWIG
5702 
5703 // @@protoc_insertion_point(global_scope)
5704 
5705 #endif // PROTOBUF_mbd_2eproto__INCLUDED