aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/OpenSim/Client/Sirikata/Protocol/Sirikata.pbj.cs
diff options
context:
space:
mode:
authorMelanie2009-12-27 15:49:09 +0000
committerMelanie2009-12-27 15:49:09 +0000
commit769dad278373c0b945aa01a75365c0d658c98540 (patch)
tree601347095dd91b365a5fdcbec8a1f693048faa03 /OpenSim/Client/Sirikata/Protocol/Sirikata.pbj.cs
parentChange the signature of the forms requester data in preparation to getting (diff)
parentMerge branch 'master' of melanie@opensimulator.org:/var/git/opensim (diff)
downloadopensim-SC_OLD-769dad278373c0b945aa01a75365c0d658c98540.zip
opensim-SC_OLD-769dad278373c0b945aa01a75365c0d658c98540.tar.gz
opensim-SC_OLD-769dad278373c0b945aa01a75365c0d658c98540.tar.bz2
opensim-SC_OLD-769dad278373c0b945aa01a75365c0d658c98540.tar.xz
Merge branch 'master' into presence-refactor
Diffstat (limited to 'OpenSim/Client/Sirikata/Protocol/Sirikata.pbj.cs')
-rw-r--r--OpenSim/Client/Sirikata/Protocol/Sirikata.pbj.cs3907
1 files changed, 3907 insertions, 0 deletions
diff --git a/OpenSim/Client/Sirikata/Protocol/Sirikata.pbj.cs b/OpenSim/Client/Sirikata/Protocol/Sirikata.pbj.cs
new file mode 100644
index 0000000..9c0e3e7
--- /dev/null
+++ b/OpenSim/Client/Sirikata/Protocol/Sirikata.pbj.cs
@@ -0,0 +1,3907 @@
1using pbd = global::Google.ProtocolBuffers.Descriptors;
2using pb = global::Google.ProtocolBuffers;
3namespace Sirikata.Protocol {
4 public class MessageBody : PBJ.IMessage {
5 protected _PBJ_Internal.MessageBody super;
6 public _PBJ_Internal.MessageBody _PBJSuper{ get { return super;} }
7 public MessageBody() {
8 super=new _PBJ_Internal.MessageBody();
9 }
10 public MessageBody(_PBJ_Internal.MessageBody reference) {
11 super=reference;
12 }
13 public static MessageBody defaultInstance= new MessageBody (_PBJ_Internal.MessageBody.DefaultInstance);
14 public static MessageBody DefaultInstance{
15 get {return defaultInstance;}
16 }
17 public static pbd.MessageDescriptor Descriptor {
18 get { return _PBJ_Internal.MessageBody.Descriptor; } }
19 public static class Types {
20 }
21 public static bool WithinReservedFieldTagRange(int field_tag) {
22 return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
23 }
24 public static bool WithinExtensionFieldTagRange(int field_tag) {
25 return false;
26 }
27 public const int MessageNamesFieldTag=9;
28 public int MessageNamesCount { get { return super.MessageNamesCount;} }
29 public bool HasMessageNames(int index) {return PBJ._PBJ.ValidateString(super.GetMessageNames(index));}
30 public string MessageNames(int index) {
31 return (string)PBJ._PBJ.CastString(super.GetMessageNames(index));
32 }
33 public const int MessageArgumentsFieldTag=10;
34 public int MessageArgumentsCount { get { return super.MessageArgumentsCount;} }
35 public bool HasMessageArguments(int index) {return PBJ._PBJ.ValidateBytes(super.GetMessageArguments(index));}
36 public pb::ByteString MessageArguments(int index) {
37 return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetMessageArguments(index));
38 }
39 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
40 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
41 public static Builder CreateBuilder() { return new Builder(); }
42 public static Builder CreateBuilder(MessageBody prototype) {
43 return (Builder)new Builder().MergeFrom(prototype);
44 }
45 public static MessageBody ParseFrom(pb::ByteString data) {
46 return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data));
47 }
48 public static MessageBody ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
49 return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data,er));
50 }
51 public static MessageBody ParseFrom(byte[] data) {
52 return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data));
53 }
54 public static MessageBody ParseFrom(byte[] data, pb::ExtensionRegistry er) {
55 return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data,er));
56 }
57 public static MessageBody ParseFrom(global::System.IO.Stream data) {
58 return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data));
59 }
60 public static MessageBody ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
61 return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data,er));
62 }
63 public static MessageBody ParseFrom(pb::CodedInputStream data) {
64 return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data));
65 }
66 public static MessageBody ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
67 return new MessageBody(_PBJ_Internal.MessageBody.ParseFrom(data,er));
68 }
69 protected override bool _HasAllPBJFields{ get {
70 return true
71 ;
72 } }
73 public bool IsInitialized { get {
74 return super.IsInitialized&&_HasAllPBJFields;
75 } }
76 public class Builder : global::PBJ.IMessage.IBuilder{
77 protected override bool _HasAllPBJFields{ get {
78 return true
79 ;
80 } }
81 public bool IsInitialized { get {
82 return super.IsInitialized&&_HasAllPBJFields;
83 } }
84 protected _PBJ_Internal.MessageBody.Builder super;
85 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
86 public _PBJ_Internal.MessageBody.Builder _PBJSuper{ get { return super;} }
87 public Builder() {super = new _PBJ_Internal.MessageBody.Builder();}
88 public Builder(_PBJ_Internal.MessageBody.Builder other) {
89 super=other;
90 }
91 public Builder Clone() {return new Builder(super.Clone());}
92 public Builder MergeFrom(MessageBody prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
93 public Builder Clear() {super.Clear();return this;}
94 public MessageBody BuildPartial() {return new MessageBody(super.BuildPartial());}
95 public MessageBody Build() {if (_HasAllPBJFields) return new MessageBody(super.Build());return null;}
96 public pbd::MessageDescriptor DescriptorForType {
97 get { return MessageBody.Descriptor; } }
98 public Builder ClearMessageNames() { super.ClearMessageNames();return this;}
99 public Builder SetMessageNames(int index, string value) {
100 super.SetMessageNames(index,PBJ._PBJ.Construct(value));
101 return this;
102 }
103 public const int MessageNamesFieldTag=9;
104 public int MessageNamesCount { get { return super.MessageNamesCount;} }
105 public bool HasMessageNames(int index) {return PBJ._PBJ.ValidateString(super.GetMessageNames(index));}
106 public string MessageNames(int index) {
107 return (string)PBJ._PBJ.CastString(super.GetMessageNames(index));
108 }
109 public Builder AddMessageNames(string value) {
110 super.AddMessageNames(PBJ._PBJ.Construct(value));
111 return this;
112 }
113 public Builder ClearMessageArguments() { super.ClearMessageArguments();return this;}
114 public Builder SetMessageArguments(int index, pb::ByteString value) {
115 super.SetMessageArguments(index,PBJ._PBJ.Construct(value));
116 return this;
117 }
118 public const int MessageArgumentsFieldTag=10;
119 public int MessageArgumentsCount { get { return super.MessageArgumentsCount;} }
120 public bool HasMessageArguments(int index) {return PBJ._PBJ.ValidateBytes(super.GetMessageArguments(index));}
121 public pb::ByteString MessageArguments(int index) {
122 return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetMessageArguments(index));
123 }
124 public Builder AddMessageArguments(pb::ByteString value) {
125 super.AddMessageArguments(PBJ._PBJ.Construct(value));
126 return this;
127 }
128 }
129 }
130}
131namespace Sirikata.Protocol {
132 public class ReadOnlyMessage : PBJ.IMessage {
133 protected _PBJ_Internal.ReadOnlyMessage super;
134 public _PBJ_Internal.ReadOnlyMessage _PBJSuper{ get { return super;} }
135 public ReadOnlyMessage() {
136 super=new _PBJ_Internal.ReadOnlyMessage();
137 }
138 public ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage reference) {
139 super=reference;
140 }
141 public static ReadOnlyMessage defaultInstance= new ReadOnlyMessage (_PBJ_Internal.ReadOnlyMessage.DefaultInstance);
142 public static ReadOnlyMessage DefaultInstance{
143 get {return defaultInstance;}
144 }
145 public static pbd.MessageDescriptor Descriptor {
146 get { return _PBJ_Internal.ReadOnlyMessage.Descriptor; } }
147 public static class Types {
148 public enum ReturnStatus {
149 SUCCESS=_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.SUCCESS,
150 NETWORK_FAILURE=_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.NETWORK_FAILURE,
151 TIMEOUT_FAILURE=_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.TIMEOUT_FAILURE,
152 PROTOCOL_ERROR=_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.PROTOCOL_ERROR,
153 PORT_FAILURE=_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus.PORT_FAILURE
154 };
155 }
156 public static bool WithinReservedFieldTagRange(int field_tag) {
157 return false||(field_tag>=1&&field_tag<=8)||(field_tag>=1536&&field_tag<=2560)||(field_tag>=229376&&field_tag<=294912);
158 }
159 public static bool WithinExtensionFieldTagRange(int field_tag) {
160 return false;
161 }
162 public const int SourceObjectFieldTag=1;
163 public bool HasSourceObject{ get {return super.HasSourceObject&&PBJ._PBJ.ValidateUuid(super.SourceObject);} }
164 public PBJ.UUID SourceObject{ get {
165 if (HasSourceObject) {
166 return PBJ._PBJ.CastUuid(super.SourceObject);
167 } else {
168 return PBJ._PBJ.CastUuid();
169 }
170 }
171 }
172 public const int SourcePortFieldTag=3;
173 public bool HasSourcePort{ get {return super.HasSourcePort&&PBJ._PBJ.ValidateUint32(super.SourcePort);} }
174 public uint SourcePort{ get {
175 if (HasSourcePort) {
176 return PBJ._PBJ.CastUint32(super.SourcePort);
177 } else {
178 return PBJ._PBJ.CastUint32();
179 }
180 }
181 }
182 public const int SourceSpaceFieldTag=1536;
183 public bool HasSourceSpace{ get {return super.HasSourceSpace&&PBJ._PBJ.ValidateUuid(super.SourceSpace);} }
184 public PBJ.UUID SourceSpace{ get {
185 if (HasSourceSpace) {
186 return PBJ._PBJ.CastUuid(super.SourceSpace);
187 } else {
188 return PBJ._PBJ.CastUuid();
189 }
190 }
191 }
192 public const int DestinationObjectFieldTag=2;
193 public bool HasDestinationObject{ get {return super.HasDestinationObject&&PBJ._PBJ.ValidateUuid(super.DestinationObject);} }
194 public PBJ.UUID DestinationObject{ get {
195 if (HasDestinationObject) {
196 return PBJ._PBJ.CastUuid(super.DestinationObject);
197 } else {
198 return PBJ._PBJ.CastUuid();
199 }
200 }
201 }
202 public const int DestinationPortFieldTag=4;
203 public bool HasDestinationPort{ get {return super.HasDestinationPort&&PBJ._PBJ.ValidateUint32(super.DestinationPort);} }
204 public uint DestinationPort{ get {
205 if (HasDestinationPort) {
206 return PBJ._PBJ.CastUint32(super.DestinationPort);
207 } else {
208 return PBJ._PBJ.CastUint32();
209 }
210 }
211 }
212 public const int DestinationSpaceFieldTag=1537;
213 public bool HasDestinationSpace{ get {return super.HasDestinationSpace&&PBJ._PBJ.ValidateUuid(super.DestinationSpace);} }
214 public PBJ.UUID DestinationSpace{ get {
215 if (HasDestinationSpace) {
216 return PBJ._PBJ.CastUuid(super.DestinationSpace);
217 } else {
218 return PBJ._PBJ.CastUuid();
219 }
220 }
221 }
222 public const int IdFieldTag=7;
223 public bool HasId{ get {return super.HasId&&PBJ._PBJ.ValidateInt64(super.Id);} }
224 public long Id{ get {
225 if (HasId) {
226 return PBJ._PBJ.CastInt64(super.Id);
227 } else {
228 return PBJ._PBJ.CastInt64();
229 }
230 }
231 }
232 public const int ReplyIdFieldTag=8;
233 public bool HasReplyId{ get {return super.HasReplyId&&PBJ._PBJ.ValidateInt64(super.ReplyId);} }
234 public long ReplyId{ get {
235 if (HasReplyId) {
236 return PBJ._PBJ.CastInt64(super.ReplyId);
237 } else {
238 return PBJ._PBJ.CastInt64();
239 }
240 }
241 }
242 public const int ReturnStatusFieldTag=1792;
243 public bool HasReturnStatus{ get {return super.HasReturnStatus;} }
244 public Types.ReturnStatus ReturnStatus{ get {
245 if (HasReturnStatus) {
246 return (Types.ReturnStatus)super.ReturnStatus;
247 } else {
248 return new Types.ReturnStatus();
249 }
250 }
251 }
252 public const int MessageNamesFieldTag=9;
253 public int MessageNamesCount { get { return super.MessageNamesCount;} }
254 public bool HasMessageNames(int index) {return PBJ._PBJ.ValidateString(super.GetMessageNames(index));}
255 public string MessageNames(int index) {
256 return (string)PBJ._PBJ.CastString(super.GetMessageNames(index));
257 }
258 public const int MessageArgumentsFieldTag=10;
259 public int MessageArgumentsCount { get { return super.MessageArgumentsCount;} }
260 public bool HasMessageArguments(int index) {return PBJ._PBJ.ValidateBytes(super.GetMessageArguments(index));}
261 public pb::ByteString MessageArguments(int index) {
262 return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetMessageArguments(index));
263 }
264 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
265 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
266 public static Builder CreateBuilder() { return new Builder(); }
267 public static Builder CreateBuilder(ReadOnlyMessage prototype) {
268 return (Builder)new Builder().MergeFrom(prototype);
269 }
270 public static ReadOnlyMessage ParseFrom(pb::ByteString data) {
271 return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data));
272 }
273 public static ReadOnlyMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
274 return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data,er));
275 }
276 public static ReadOnlyMessage ParseFrom(byte[] data) {
277 return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data));
278 }
279 public static ReadOnlyMessage ParseFrom(byte[] data, pb::ExtensionRegistry er) {
280 return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data,er));
281 }
282 public static ReadOnlyMessage ParseFrom(global::System.IO.Stream data) {
283 return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data));
284 }
285 public static ReadOnlyMessage ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
286 return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data,er));
287 }
288 public static ReadOnlyMessage ParseFrom(pb::CodedInputStream data) {
289 return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data));
290 }
291 public static ReadOnlyMessage ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
292 return new ReadOnlyMessage(_PBJ_Internal.ReadOnlyMessage.ParseFrom(data,er));
293 }
294 protected override bool _HasAllPBJFields{ get {
295 return true
296 ;
297 } }
298 public bool IsInitialized { get {
299 return super.IsInitialized&&_HasAllPBJFields;
300 } }
301 public class Builder : global::PBJ.IMessage.IBuilder{
302 protected override bool _HasAllPBJFields{ get {
303 return true
304 ;
305 } }
306 public bool IsInitialized { get {
307 return super.IsInitialized&&_HasAllPBJFields;
308 } }
309 protected _PBJ_Internal.ReadOnlyMessage.Builder super;
310 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
311 public _PBJ_Internal.ReadOnlyMessage.Builder _PBJSuper{ get { return super;} }
312 public Builder() {super = new _PBJ_Internal.ReadOnlyMessage.Builder();}
313 public Builder(_PBJ_Internal.ReadOnlyMessage.Builder other) {
314 super=other;
315 }
316 public Builder Clone() {return new Builder(super.Clone());}
317 public Builder MergeFrom(ReadOnlyMessage prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
318 public Builder Clear() {super.Clear();return this;}
319 public ReadOnlyMessage BuildPartial() {return new ReadOnlyMessage(super.BuildPartial());}
320 public ReadOnlyMessage Build() {if (_HasAllPBJFields) return new ReadOnlyMessage(super.Build());return null;}
321 public pbd::MessageDescriptor DescriptorForType {
322 get { return ReadOnlyMessage.Descriptor; } }
323 public Builder ClearSourceObject() { super.ClearSourceObject();return this;}
324 public const int SourceObjectFieldTag=1;
325 public bool HasSourceObject{ get {return super.HasSourceObject&&PBJ._PBJ.ValidateUuid(super.SourceObject);} }
326 public PBJ.UUID SourceObject{ get {
327 if (HasSourceObject) {
328 return PBJ._PBJ.CastUuid(super.SourceObject);
329 } else {
330 return PBJ._PBJ.CastUuid();
331 }
332 }
333 set {
334 super.SourceObject=(PBJ._PBJ.Construct(value));
335 }
336 }
337 public Builder ClearSourcePort() { super.ClearSourcePort();return this;}
338 public const int SourcePortFieldTag=3;
339 public bool HasSourcePort{ get {return super.HasSourcePort&&PBJ._PBJ.ValidateUint32(super.SourcePort);} }
340 public uint SourcePort{ get {
341 if (HasSourcePort) {
342 return PBJ._PBJ.CastUint32(super.SourcePort);
343 } else {
344 return PBJ._PBJ.CastUint32();
345 }
346 }
347 set {
348 super.SourcePort=(PBJ._PBJ.Construct(value));
349 }
350 }
351 public Builder ClearSourceSpace() { super.ClearSourceSpace();return this;}
352 public const int SourceSpaceFieldTag=1536;
353 public bool HasSourceSpace{ get {return super.HasSourceSpace&&PBJ._PBJ.ValidateUuid(super.SourceSpace);} }
354 public PBJ.UUID SourceSpace{ get {
355 if (HasSourceSpace) {
356 return PBJ._PBJ.CastUuid(super.SourceSpace);
357 } else {
358 return PBJ._PBJ.CastUuid();
359 }
360 }
361 set {
362 super.SourceSpace=(PBJ._PBJ.Construct(value));
363 }
364 }
365 public Builder ClearDestinationObject() { super.ClearDestinationObject();return this;}
366 public const int DestinationObjectFieldTag=2;
367 public bool HasDestinationObject{ get {return super.HasDestinationObject&&PBJ._PBJ.ValidateUuid(super.DestinationObject);} }
368 public PBJ.UUID DestinationObject{ get {
369 if (HasDestinationObject) {
370 return PBJ._PBJ.CastUuid(super.DestinationObject);
371 } else {
372 return PBJ._PBJ.CastUuid();
373 }
374 }
375 set {
376 super.DestinationObject=(PBJ._PBJ.Construct(value));
377 }
378 }
379 public Builder ClearDestinationPort() { super.ClearDestinationPort();return this;}
380 public const int DestinationPortFieldTag=4;
381 public bool HasDestinationPort{ get {return super.HasDestinationPort&&PBJ._PBJ.ValidateUint32(super.DestinationPort);} }
382 public uint DestinationPort{ get {
383 if (HasDestinationPort) {
384 return PBJ._PBJ.CastUint32(super.DestinationPort);
385 } else {
386 return PBJ._PBJ.CastUint32();
387 }
388 }
389 set {
390 super.DestinationPort=(PBJ._PBJ.Construct(value));
391 }
392 }
393 public Builder ClearDestinationSpace() { super.ClearDestinationSpace();return this;}
394 public const int DestinationSpaceFieldTag=1537;
395 public bool HasDestinationSpace{ get {return super.HasDestinationSpace&&PBJ._PBJ.ValidateUuid(super.DestinationSpace);} }
396 public PBJ.UUID DestinationSpace{ get {
397 if (HasDestinationSpace) {
398 return PBJ._PBJ.CastUuid(super.DestinationSpace);
399 } else {
400 return PBJ._PBJ.CastUuid();
401 }
402 }
403 set {
404 super.DestinationSpace=(PBJ._PBJ.Construct(value));
405 }
406 }
407 public Builder ClearId() { super.ClearId();return this;}
408 public const int IdFieldTag=7;
409 public bool HasId{ get {return super.HasId&&PBJ._PBJ.ValidateInt64(super.Id);} }
410 public long Id{ get {
411 if (HasId) {
412 return PBJ._PBJ.CastInt64(super.Id);
413 } else {
414 return PBJ._PBJ.CastInt64();
415 }
416 }
417 set {
418 super.Id=(PBJ._PBJ.Construct(value));
419 }
420 }
421 public Builder ClearReplyId() { super.ClearReplyId();return this;}
422 public const int ReplyIdFieldTag=8;
423 public bool HasReplyId{ get {return super.HasReplyId&&PBJ._PBJ.ValidateInt64(super.ReplyId);} }
424 public long ReplyId{ get {
425 if (HasReplyId) {
426 return PBJ._PBJ.CastInt64(super.ReplyId);
427 } else {
428 return PBJ._PBJ.CastInt64();
429 }
430 }
431 set {
432 super.ReplyId=(PBJ._PBJ.Construct(value));
433 }
434 }
435 public Builder ClearReturnStatus() { super.ClearReturnStatus();return this;}
436 public const int ReturnStatusFieldTag=1792;
437 public bool HasReturnStatus{ get {return super.HasReturnStatus;} }
438 public Types.ReturnStatus ReturnStatus{ get {
439 if (HasReturnStatus) {
440 return (Types.ReturnStatus)super.ReturnStatus;
441 } else {
442 return new Types.ReturnStatus();
443 }
444 }
445 set {
446 super.ReturnStatus=((_PBJ_Internal.ReadOnlyMessage.Types.ReturnStatus)value);
447 }
448 }
449 public Builder ClearMessageNames() { super.ClearMessageNames();return this;}
450 public Builder SetMessageNames(int index, string value) {
451 super.SetMessageNames(index,PBJ._PBJ.Construct(value));
452 return this;
453 }
454 public const int MessageNamesFieldTag=9;
455 public int MessageNamesCount { get { return super.MessageNamesCount;} }
456 public bool HasMessageNames(int index) {return PBJ._PBJ.ValidateString(super.GetMessageNames(index));}
457 public string MessageNames(int index) {
458 return (string)PBJ._PBJ.CastString(super.GetMessageNames(index));
459 }
460 public Builder AddMessageNames(string value) {
461 super.AddMessageNames(PBJ._PBJ.Construct(value));
462 return this;
463 }
464 public Builder ClearMessageArguments() { super.ClearMessageArguments();return this;}
465 public Builder SetMessageArguments(int index, pb::ByteString value) {
466 super.SetMessageArguments(index,PBJ._PBJ.Construct(value));
467 return this;
468 }
469 public const int MessageArgumentsFieldTag=10;
470 public int MessageArgumentsCount { get { return super.MessageArgumentsCount;} }
471 public bool HasMessageArguments(int index) {return PBJ._PBJ.ValidateBytes(super.GetMessageArguments(index));}
472 public pb::ByteString MessageArguments(int index) {
473 return (pb::ByteString)PBJ._PBJ.CastBytes(super.GetMessageArguments(index));
474 }
475 public Builder AddMessageArguments(pb::ByteString value) {
476 super.AddMessageArguments(PBJ._PBJ.Construct(value));
477 return this;
478 }
479 }
480 }
481}
482namespace Sirikata.Protocol {
483 public class SpaceServices : PBJ.IMessage {
484 protected _PBJ_Internal.SpaceServices super;
485 public _PBJ_Internal.SpaceServices _PBJSuper{ get { return super;} }
486 public SpaceServices() {
487 super=new _PBJ_Internal.SpaceServices();
488 }
489 public SpaceServices(_PBJ_Internal.SpaceServices reference) {
490 super=reference;
491 }
492 public static SpaceServices defaultInstance= new SpaceServices (_PBJ_Internal.SpaceServices.DefaultInstance);
493 public static SpaceServices DefaultInstance{
494 get {return defaultInstance;}
495 }
496 public static pbd.MessageDescriptor Descriptor {
497 get { return _PBJ_Internal.SpaceServices.Descriptor; } }
498 public static class Types {
499 }
500 public static bool WithinReservedFieldTagRange(int field_tag) {
501 return false;
502 }
503 public static bool WithinExtensionFieldTagRange(int field_tag) {
504 return false;
505 }
506 public const int RegistrationPortFieldTag=33;
507 public bool HasRegistrationPort{ get {return super.HasRegistrationPort&&PBJ._PBJ.ValidateUint32(super.RegistrationPort);} }
508 public uint RegistrationPort{ get {
509 if (HasRegistrationPort) {
510 return PBJ._PBJ.CastUint32(super.RegistrationPort);
511 } else {
512 return PBJ._PBJ.CastUint32();
513 }
514 }
515 }
516 public const int LocPortFieldTag=34;
517 public bool HasLocPort{ get {return super.HasLocPort&&PBJ._PBJ.ValidateUint32(super.LocPort);} }
518 public uint LocPort{ get {
519 if (HasLocPort) {
520 return PBJ._PBJ.CastUint32(super.LocPort);
521 } else {
522 return PBJ._PBJ.CastUint32();
523 }
524 }
525 }
526 public const int GeomPortFieldTag=35;
527 public bool HasGeomPort{ get {return super.HasGeomPort&&PBJ._PBJ.ValidateUint32(super.GeomPort);} }
528 public uint GeomPort{ get {
529 if (HasGeomPort) {
530 return PBJ._PBJ.CastUint32(super.GeomPort);
531 } else {
532 return PBJ._PBJ.CastUint32();
533 }
534 }
535 }
536 public const int OsegPortFieldTag=36;
537 public bool HasOsegPort{ get {return super.HasOsegPort&&PBJ._PBJ.ValidateUint32(super.OsegPort);} }
538 public uint OsegPort{ get {
539 if (HasOsegPort) {
540 return PBJ._PBJ.CastUint32(super.OsegPort);
541 } else {
542 return PBJ._PBJ.CastUint32();
543 }
544 }
545 }
546 public const int CsegPortFieldTag=37;
547 public bool HasCsegPort{ get {return super.HasCsegPort&&PBJ._PBJ.ValidateUint32(super.CsegPort);} }
548 public uint CsegPort{ get {
549 if (HasCsegPort) {
550 return PBJ._PBJ.CastUint32(super.CsegPort);
551 } else {
552 return PBJ._PBJ.CastUint32();
553 }
554 }
555 }
556 public const int RouterPortFieldTag=38;
557 public bool HasRouterPort{ get {return super.HasRouterPort&&PBJ._PBJ.ValidateUint32(super.RouterPort);} }
558 public uint RouterPort{ get {
559 if (HasRouterPort) {
560 return PBJ._PBJ.CastUint32(super.RouterPort);
561 } else {
562 return PBJ._PBJ.CastUint32();
563 }
564 }
565 }
566 public const int PreConnectionBufferFieldTag=64;
567 public bool HasPreConnectionBuffer{ get {return super.HasPreConnectionBuffer&&PBJ._PBJ.ValidateUint64(super.PreConnectionBuffer);} }
568 public ulong PreConnectionBuffer{ get {
569 if (HasPreConnectionBuffer) {
570 return PBJ._PBJ.CastUint64(super.PreConnectionBuffer);
571 } else {
572 return PBJ._PBJ.CastUint64();
573 }
574 }
575 }
576 public const int MaxPreConnectionMessagesFieldTag=65;
577 public bool HasMaxPreConnectionMessages{ get {return super.HasMaxPreConnectionMessages&&PBJ._PBJ.ValidateUint64(super.MaxPreConnectionMessages);} }
578 public ulong MaxPreConnectionMessages{ get {
579 if (HasMaxPreConnectionMessages) {
580 return PBJ._PBJ.CastUint64(super.MaxPreConnectionMessages);
581 } else {
582 return PBJ._PBJ.CastUint64();
583 }
584 }
585 }
586 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
587 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
588 public static Builder CreateBuilder() { return new Builder(); }
589 public static Builder CreateBuilder(SpaceServices prototype) {
590 return (Builder)new Builder().MergeFrom(prototype);
591 }
592 public static SpaceServices ParseFrom(pb::ByteString data) {
593 return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data));
594 }
595 public static SpaceServices ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
596 return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data,er));
597 }
598 public static SpaceServices ParseFrom(byte[] data) {
599 return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data));
600 }
601 public static SpaceServices ParseFrom(byte[] data, pb::ExtensionRegistry er) {
602 return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data,er));
603 }
604 public static SpaceServices ParseFrom(global::System.IO.Stream data) {
605 return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data));
606 }
607 public static SpaceServices ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
608 return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data,er));
609 }
610 public static SpaceServices ParseFrom(pb::CodedInputStream data) {
611 return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data));
612 }
613 public static SpaceServices ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
614 return new SpaceServices(_PBJ_Internal.SpaceServices.ParseFrom(data,er));
615 }
616 protected override bool _HasAllPBJFields{ get {
617 return true
618 ;
619 } }
620 public bool IsInitialized { get {
621 return super.IsInitialized&&_HasAllPBJFields;
622 } }
623 public class Builder : global::PBJ.IMessage.IBuilder{
624 protected override bool _HasAllPBJFields{ get {
625 return true
626 ;
627 } }
628 public bool IsInitialized { get {
629 return super.IsInitialized&&_HasAllPBJFields;
630 } }
631 protected _PBJ_Internal.SpaceServices.Builder super;
632 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
633 public _PBJ_Internal.SpaceServices.Builder _PBJSuper{ get { return super;} }
634 public Builder() {super = new _PBJ_Internal.SpaceServices.Builder();}
635 public Builder(_PBJ_Internal.SpaceServices.Builder other) {
636 super=other;
637 }
638 public Builder Clone() {return new Builder(super.Clone());}
639 public Builder MergeFrom(SpaceServices prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
640 public Builder Clear() {super.Clear();return this;}
641 public SpaceServices BuildPartial() {return new SpaceServices(super.BuildPartial());}
642 public SpaceServices Build() {if (_HasAllPBJFields) return new SpaceServices(super.Build());return null;}
643 public pbd::MessageDescriptor DescriptorForType {
644 get { return SpaceServices.Descriptor; } }
645 public Builder ClearRegistrationPort() { super.ClearRegistrationPort();return this;}
646 public const int RegistrationPortFieldTag=33;
647 public bool HasRegistrationPort{ get {return super.HasRegistrationPort&&PBJ._PBJ.ValidateUint32(super.RegistrationPort);} }
648 public uint RegistrationPort{ get {
649 if (HasRegistrationPort) {
650 return PBJ._PBJ.CastUint32(super.RegistrationPort);
651 } else {
652 return PBJ._PBJ.CastUint32();
653 }
654 }
655 set {
656 super.RegistrationPort=(PBJ._PBJ.Construct(value));
657 }
658 }
659 public Builder ClearLocPort() { super.ClearLocPort();return this;}
660 public const int LocPortFieldTag=34;
661 public bool HasLocPort{ get {return super.HasLocPort&&PBJ._PBJ.ValidateUint32(super.LocPort);} }
662 public uint LocPort{ get {
663 if (HasLocPort) {
664 return PBJ._PBJ.CastUint32(super.LocPort);
665 } else {
666 return PBJ._PBJ.CastUint32();
667 }
668 }
669 set {
670 super.LocPort=(PBJ._PBJ.Construct(value));
671 }
672 }
673 public Builder ClearGeomPort() { super.ClearGeomPort();return this;}
674 public const int GeomPortFieldTag=35;
675 public bool HasGeomPort{ get {return super.HasGeomPort&&PBJ._PBJ.ValidateUint32(super.GeomPort);} }
676 public uint GeomPort{ get {
677 if (HasGeomPort) {
678 return PBJ._PBJ.CastUint32(super.GeomPort);
679 } else {
680 return PBJ._PBJ.CastUint32();
681 }
682 }
683 set {
684 super.GeomPort=(PBJ._PBJ.Construct(value));
685 }
686 }
687 public Builder ClearOsegPort() { super.ClearOsegPort();return this;}
688 public const int OsegPortFieldTag=36;
689 public bool HasOsegPort{ get {return super.HasOsegPort&&PBJ._PBJ.ValidateUint32(super.OsegPort);} }
690 public uint OsegPort{ get {
691 if (HasOsegPort) {
692 return PBJ._PBJ.CastUint32(super.OsegPort);
693 } else {
694 return PBJ._PBJ.CastUint32();
695 }
696 }
697 set {
698 super.OsegPort=(PBJ._PBJ.Construct(value));
699 }
700 }
701 public Builder ClearCsegPort() { super.ClearCsegPort();return this;}
702 public const int CsegPortFieldTag=37;
703 public bool HasCsegPort{ get {return super.HasCsegPort&&PBJ._PBJ.ValidateUint32(super.CsegPort);} }
704 public uint CsegPort{ get {
705 if (HasCsegPort) {
706 return PBJ._PBJ.CastUint32(super.CsegPort);
707 } else {
708 return PBJ._PBJ.CastUint32();
709 }
710 }
711 set {
712 super.CsegPort=(PBJ._PBJ.Construct(value));
713 }
714 }
715 public Builder ClearRouterPort() { super.ClearRouterPort();return this;}
716 public const int RouterPortFieldTag=38;
717 public bool HasRouterPort{ get {return super.HasRouterPort&&PBJ._PBJ.ValidateUint32(super.RouterPort);} }
718 public uint RouterPort{ get {
719 if (HasRouterPort) {
720 return PBJ._PBJ.CastUint32(super.RouterPort);
721 } else {
722 return PBJ._PBJ.CastUint32();
723 }
724 }
725 set {
726 super.RouterPort=(PBJ._PBJ.Construct(value));
727 }
728 }
729 public Builder ClearPreConnectionBuffer() { super.ClearPreConnectionBuffer();return this;}
730 public const int PreConnectionBufferFieldTag=64;
731 public bool HasPreConnectionBuffer{ get {return super.HasPreConnectionBuffer&&PBJ._PBJ.ValidateUint64(super.PreConnectionBuffer);} }
732 public ulong PreConnectionBuffer{ get {
733 if (HasPreConnectionBuffer) {
734 return PBJ._PBJ.CastUint64(super.PreConnectionBuffer);
735 } else {
736 return PBJ._PBJ.CastUint64();
737 }
738 }
739 set {
740 super.PreConnectionBuffer=(PBJ._PBJ.Construct(value));
741 }
742 }
743 public Builder ClearMaxPreConnectionMessages() { super.ClearMaxPreConnectionMessages();return this;}
744 public const int MaxPreConnectionMessagesFieldTag=65;
745 public bool HasMaxPreConnectionMessages{ get {return super.HasMaxPreConnectionMessages&&PBJ._PBJ.ValidateUint64(super.MaxPreConnectionMessages);} }
746 public ulong MaxPreConnectionMessages{ get {
747 if (HasMaxPreConnectionMessages) {
748 return PBJ._PBJ.CastUint64(super.MaxPreConnectionMessages);
749 } else {
750 return PBJ._PBJ.CastUint64();
751 }
752 }
753 set {
754 super.MaxPreConnectionMessages=(PBJ._PBJ.Construct(value));
755 }
756 }
757 }
758 }
759}
760namespace Sirikata.Protocol {
761 public class ObjLoc : PBJ.IMessage {
762 protected _PBJ_Internal.ObjLoc super;
763 public _PBJ_Internal.ObjLoc _PBJSuper{ get { return super;} }
764 public ObjLoc() {
765 super=new _PBJ_Internal.ObjLoc();
766 }
767 public ObjLoc(_PBJ_Internal.ObjLoc reference) {
768 super=reference;
769 }
770 public static ObjLoc defaultInstance= new ObjLoc (_PBJ_Internal.ObjLoc.DefaultInstance);
771 public static ObjLoc DefaultInstance{
772 get {return defaultInstance;}
773 }
774 public static pbd.MessageDescriptor Descriptor {
775 get { return _PBJ_Internal.ObjLoc.Descriptor; } }
776 public static class Types {
777 public enum UpdateFlags {
778 FORCE=_PBJ_Internal.ObjLoc.Types.UpdateFlags.FORCE
779 };
780 }
781 public static bool WithinReservedFieldTagRange(int field_tag) {
782 return false;
783 }
784 public static bool WithinExtensionFieldTagRange(int field_tag) {
785 return false;
786 }
787 public const int TimestampFieldTag=2;
788 public bool HasTimestamp{ get {return super.HasTimestamp&&PBJ._PBJ.ValidateTime(super.Timestamp);} }
789 public PBJ.Time Timestamp{ get {
790 if (HasTimestamp) {
791 return PBJ._PBJ.CastTime(super.Timestamp);
792 } else {
793 return PBJ._PBJ.CastTime();
794 }
795 }
796 }
797 public const int PositionFieldTag=3;
798 public bool HasPosition{ get {return super.PositionCount>=3;} }
799 public PBJ.Vector3d Position{ get {
800 int index=0;
801 if (HasPosition) {
802 return PBJ._PBJ.CastVector3d(super.GetPosition(index*3+0),super.GetPosition(index*3+1),super.GetPosition(index*3+2));
803 } else {
804 return PBJ._PBJ.CastVector3d();
805 }
806 }
807 }
808 public const int OrientationFieldTag=4;
809 public bool HasOrientation{ get {return super.OrientationCount>=3;} }
810 public PBJ.Quaternion Orientation{ get {
811 int index=0;
812 if (HasOrientation) {
813 return PBJ._PBJ.CastQuaternion(super.GetOrientation(index*3+0),super.GetOrientation(index*3+1),super.GetOrientation(index*3+2));
814 } else {
815 return PBJ._PBJ.CastQuaternion();
816 }
817 }
818 }
819 public const int VelocityFieldTag=5;
820 public bool HasVelocity{ get {return super.VelocityCount>=3;} }
821 public PBJ.Vector3f Velocity{ get {
822 int index=0;
823 if (HasVelocity) {
824 return PBJ._PBJ.CastVector3f(super.GetVelocity(index*3+0),super.GetVelocity(index*3+1),super.GetVelocity(index*3+2));
825 } else {
826 return PBJ._PBJ.CastVector3f();
827 }
828 }
829 }
830 public const int RotationalAxisFieldTag=7;
831 public bool HasRotationalAxis{ get {return super.RotationalAxisCount>=2;} }
832 public PBJ.Vector3f RotationalAxis{ get {
833 int index=0;
834 if (HasRotationalAxis) {
835 return PBJ._PBJ.CastNormal(super.GetRotationalAxis(index*2+0),super.GetRotationalAxis(index*2+1));
836 } else {
837 return PBJ._PBJ.CastNormal();
838 }
839 }
840 }
841 public const int AngularSpeedFieldTag=8;
842 public bool HasAngularSpeed{ get {return super.HasAngularSpeed&&PBJ._PBJ.ValidateFloat(super.AngularSpeed);} }
843 public float AngularSpeed{ get {
844 if (HasAngularSpeed) {
845 return PBJ._PBJ.CastFloat(super.AngularSpeed);
846 } else {
847 return PBJ._PBJ.CastFloat();
848 }
849 }
850 }
851 public const int UpdateFlagsFieldTag=6;
852 public bool HasUpdateFlags { get {
853 if (!super.HasUpdateFlags) return false;
854 return PBJ._PBJ.ValidateFlags(super.UpdateFlags,(ulong)Types.UpdateFlags.FORCE);
855 } }
856 public byte UpdateFlags{ get {
857 if (HasUpdateFlags) {
858 return (byte)PBJ._PBJ.CastFlags(super.UpdateFlags,(ulong)Types.UpdateFlags.FORCE);
859 } else {
860 return (byte)PBJ._PBJ.CastFlags((ulong)Types.UpdateFlags.FORCE);
861 }
862 }
863 }
864 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
865 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
866 public static Builder CreateBuilder() { return new Builder(); }
867 public static Builder CreateBuilder(ObjLoc prototype) {
868 return (Builder)new Builder().MergeFrom(prototype);
869 }
870 public static ObjLoc ParseFrom(pb::ByteString data) {
871 return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data));
872 }
873 public static ObjLoc ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
874 return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data,er));
875 }
876 public static ObjLoc ParseFrom(byte[] data) {
877 return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data));
878 }
879 public static ObjLoc ParseFrom(byte[] data, pb::ExtensionRegistry er) {
880 return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data,er));
881 }
882 public static ObjLoc ParseFrom(global::System.IO.Stream data) {
883 return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data));
884 }
885 public static ObjLoc ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
886 return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data,er));
887 }
888 public static ObjLoc ParseFrom(pb::CodedInputStream data) {
889 return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data));
890 }
891 public static ObjLoc ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
892 return new ObjLoc(_PBJ_Internal.ObjLoc.ParseFrom(data,er));
893 }
894 protected override bool _HasAllPBJFields{ get {
895 return true
896 ;
897 } }
898 public bool IsInitialized { get {
899 return super.IsInitialized&&_HasAllPBJFields;
900 } }
901 public class Builder : global::PBJ.IMessage.IBuilder{
902 protected override bool _HasAllPBJFields{ get {
903 return true
904 ;
905 } }
906 public bool IsInitialized { get {
907 return super.IsInitialized&&_HasAllPBJFields;
908 } }
909 protected _PBJ_Internal.ObjLoc.Builder super;
910 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
911 public _PBJ_Internal.ObjLoc.Builder _PBJSuper{ get { return super;} }
912 public Builder() {super = new _PBJ_Internal.ObjLoc.Builder();}
913 public Builder(_PBJ_Internal.ObjLoc.Builder other) {
914 super=other;
915 }
916 public Builder Clone() {return new Builder(super.Clone());}
917 public Builder MergeFrom(ObjLoc prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
918 public Builder Clear() {super.Clear();return this;}
919 public ObjLoc BuildPartial() {return new ObjLoc(super.BuildPartial());}
920 public ObjLoc Build() {if (_HasAllPBJFields) return new ObjLoc(super.Build());return null;}
921 public pbd::MessageDescriptor DescriptorForType {
922 get { return ObjLoc.Descriptor; } }
923 public Builder ClearTimestamp() { super.ClearTimestamp();return this;}
924 public const int TimestampFieldTag=2;
925 public bool HasTimestamp{ get {return super.HasTimestamp&&PBJ._PBJ.ValidateTime(super.Timestamp);} }
926 public PBJ.Time Timestamp{ get {
927 if (HasTimestamp) {
928 return PBJ._PBJ.CastTime(super.Timestamp);
929 } else {
930 return PBJ._PBJ.CastTime();
931 }
932 }
933 set {
934 super.Timestamp=(PBJ._PBJ.Construct(value));
935 }
936 }
937 public Builder ClearPosition() { super.ClearPosition();return this;}
938 public const int PositionFieldTag=3;
939 public bool HasPosition{ get {return super.PositionCount>=3;} }
940 public PBJ.Vector3d Position{ get {
941 int index=0;
942 if (HasPosition) {
943 return PBJ._PBJ.CastVector3d(super.GetPosition(index*3+0),super.GetPosition(index*3+1),super.GetPosition(index*3+2));
944 } else {
945 return PBJ._PBJ.CastVector3d();
946 }
947 }
948 set {
949 super.ClearPosition();
950 double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value);
951 super.AddPosition(_PBJtempArray[0]);
952 super.AddPosition(_PBJtempArray[1]);
953 super.AddPosition(_PBJtempArray[2]);
954 }
955 }
956 public Builder ClearOrientation() { super.ClearOrientation();return this;}
957 public const int OrientationFieldTag=4;
958 public bool HasOrientation{ get {return super.OrientationCount>=3;} }
959 public PBJ.Quaternion Orientation{ get {
960 int index=0;
961 if (HasOrientation) {
962 return PBJ._PBJ.CastQuaternion(super.GetOrientation(index*3+0),super.GetOrientation(index*3+1),super.GetOrientation(index*3+2));
963 } else {
964 return PBJ._PBJ.CastQuaternion();
965 }
966 }
967 set {
968 super.ClearOrientation();
969 float[] _PBJtempArray=PBJ._PBJ.ConstructQuaternion(value);
970 super.AddOrientation(_PBJtempArray[0]);
971 super.AddOrientation(_PBJtempArray[1]);
972 super.AddOrientation(_PBJtempArray[2]);
973 }
974 }
975 public Builder ClearVelocity() { super.ClearVelocity();return this;}
976 public const int VelocityFieldTag=5;
977 public bool HasVelocity{ get {return super.VelocityCount>=3;} }
978 public PBJ.Vector3f Velocity{ get {
979 int index=0;
980 if (HasVelocity) {
981 return PBJ._PBJ.CastVector3f(super.GetVelocity(index*3+0),super.GetVelocity(index*3+1),super.GetVelocity(index*3+2));
982 } else {
983 return PBJ._PBJ.CastVector3f();
984 }
985 }
986 set {
987 super.ClearVelocity();
988 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
989 super.AddVelocity(_PBJtempArray[0]);
990 super.AddVelocity(_PBJtempArray[1]);
991 super.AddVelocity(_PBJtempArray[2]);
992 }
993 }
994 public Builder ClearRotationalAxis() { super.ClearRotationalAxis();return this;}
995 public const int RotationalAxisFieldTag=7;
996 public bool HasRotationalAxis{ get {return super.RotationalAxisCount>=2;} }
997 public PBJ.Vector3f RotationalAxis{ get {
998 int index=0;
999 if (HasRotationalAxis) {
1000 return PBJ._PBJ.CastNormal(super.GetRotationalAxis(index*2+0),super.GetRotationalAxis(index*2+1));
1001 } else {
1002 return PBJ._PBJ.CastNormal();
1003 }
1004 }
1005 set {
1006 super.ClearRotationalAxis();
1007 float[] _PBJtempArray=PBJ._PBJ.ConstructNormal(value);
1008 super.AddRotationalAxis(_PBJtempArray[0]);
1009 super.AddRotationalAxis(_PBJtempArray[1]);
1010 }
1011 }
1012 public Builder ClearAngularSpeed() { super.ClearAngularSpeed();return this;}
1013 public const int AngularSpeedFieldTag=8;
1014 public bool HasAngularSpeed{ get {return super.HasAngularSpeed&&PBJ._PBJ.ValidateFloat(super.AngularSpeed);} }
1015 public float AngularSpeed{ get {
1016 if (HasAngularSpeed) {
1017 return PBJ._PBJ.CastFloat(super.AngularSpeed);
1018 } else {
1019 return PBJ._PBJ.CastFloat();
1020 }
1021 }
1022 set {
1023 super.AngularSpeed=(PBJ._PBJ.Construct(value));
1024 }
1025 }
1026 public Builder ClearUpdateFlags() { super.ClearUpdateFlags();return this;}
1027 public const int UpdateFlagsFieldTag=6;
1028 public bool HasUpdateFlags { get {
1029 if (!super.HasUpdateFlags) return false;
1030 return PBJ._PBJ.ValidateFlags(super.UpdateFlags,(ulong)Types.UpdateFlags.FORCE);
1031 } }
1032 public byte UpdateFlags{ get {
1033 if (HasUpdateFlags) {
1034 return (byte)PBJ._PBJ.CastFlags(super.UpdateFlags,(ulong)Types.UpdateFlags.FORCE);
1035 } else {
1036 return (byte)PBJ._PBJ.CastFlags((ulong)Types.UpdateFlags.FORCE);
1037 }
1038 }
1039 set {
1040 super.UpdateFlags=((value));
1041 }
1042 }
1043 }
1044 }
1045}
1046namespace Sirikata.Protocol {
1047 public class LocRequest : PBJ.IMessage {
1048 protected _PBJ_Internal.LocRequest super;
1049 public _PBJ_Internal.LocRequest _PBJSuper{ get { return super;} }
1050 public LocRequest() {
1051 super=new _PBJ_Internal.LocRequest();
1052 }
1053 public LocRequest(_PBJ_Internal.LocRequest reference) {
1054 super=reference;
1055 }
1056 public static LocRequest defaultInstance= new LocRequest (_PBJ_Internal.LocRequest.DefaultInstance);
1057 public static LocRequest DefaultInstance{
1058 get {return defaultInstance;}
1059 }
1060 public static pbd.MessageDescriptor Descriptor {
1061 get { return _PBJ_Internal.LocRequest.Descriptor; } }
1062 public static class Types {
1063 public enum Fields {
1064 POSITION=_PBJ_Internal.LocRequest.Types.Fields.POSITION,
1065 ORIENTATION=_PBJ_Internal.LocRequest.Types.Fields.ORIENTATION,
1066 VELOCITY=_PBJ_Internal.LocRequest.Types.Fields.VELOCITY,
1067 ROTATIONAL_AXIS=_PBJ_Internal.LocRequest.Types.Fields.ROTATIONAL_AXIS,
1068 ANGULAR_SPEED=_PBJ_Internal.LocRequest.Types.Fields.ANGULAR_SPEED
1069 };
1070 }
1071 public static bool WithinReservedFieldTagRange(int field_tag) {
1072 return false;
1073 }
1074 public static bool WithinExtensionFieldTagRange(int field_tag) {
1075 return false;
1076 }
1077 public const int RequestedFieldsFieldTag=2;
1078 public bool HasRequestedFields { get {
1079 if (!super.HasRequestedFields) return false;
1080 return PBJ._PBJ.ValidateFlags(super.RequestedFields,(ulong)Types.Fields.POSITION|(ulong)Types.Fields.ORIENTATION|(ulong)Types.Fields.VELOCITY|(ulong)Types.Fields.ROTATIONAL_AXIS|(ulong)Types.Fields.ANGULAR_SPEED);
1081 } }
1082 public uint RequestedFields{ get {
1083 if (HasRequestedFields) {
1084 return (uint)PBJ._PBJ.CastFlags(super.RequestedFields,(ulong)Types.Fields.POSITION|(ulong)Types.Fields.ORIENTATION|(ulong)Types.Fields.VELOCITY|(ulong)Types.Fields.ROTATIONAL_AXIS|(ulong)Types.Fields.ANGULAR_SPEED);
1085 } else {
1086 return (uint)PBJ._PBJ.CastFlags((ulong)Types.Fields.POSITION|(ulong)Types.Fields.ORIENTATION|(ulong)Types.Fields.VELOCITY|(ulong)Types.Fields.ROTATIONAL_AXIS|(ulong)Types.Fields.ANGULAR_SPEED);
1087 }
1088 }
1089 }
1090 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
1091 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
1092 public static Builder CreateBuilder() { return new Builder(); }
1093 public static Builder CreateBuilder(LocRequest prototype) {
1094 return (Builder)new Builder().MergeFrom(prototype);
1095 }
1096 public static LocRequest ParseFrom(pb::ByteString data) {
1097 return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data));
1098 }
1099 public static LocRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
1100 return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data,er));
1101 }
1102 public static LocRequest ParseFrom(byte[] data) {
1103 return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data));
1104 }
1105 public static LocRequest ParseFrom(byte[] data, pb::ExtensionRegistry er) {
1106 return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data,er));
1107 }
1108 public static LocRequest ParseFrom(global::System.IO.Stream data) {
1109 return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data));
1110 }
1111 public static LocRequest ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
1112 return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data,er));
1113 }
1114 public static LocRequest ParseFrom(pb::CodedInputStream data) {
1115 return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data));
1116 }
1117 public static LocRequest ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
1118 return new LocRequest(_PBJ_Internal.LocRequest.ParseFrom(data,er));
1119 }
1120 protected override bool _HasAllPBJFields{ get {
1121 return true
1122 ;
1123 } }
1124 public bool IsInitialized { get {
1125 return super.IsInitialized&&_HasAllPBJFields;
1126 } }
1127 public class Builder : global::PBJ.IMessage.IBuilder{
1128 protected override bool _HasAllPBJFields{ get {
1129 return true
1130 ;
1131 } }
1132 public bool IsInitialized { get {
1133 return super.IsInitialized&&_HasAllPBJFields;
1134 } }
1135 protected _PBJ_Internal.LocRequest.Builder super;
1136 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
1137 public _PBJ_Internal.LocRequest.Builder _PBJSuper{ get { return super;} }
1138 public Builder() {super = new _PBJ_Internal.LocRequest.Builder();}
1139 public Builder(_PBJ_Internal.LocRequest.Builder other) {
1140 super=other;
1141 }
1142 public Builder Clone() {return new Builder(super.Clone());}
1143 public Builder MergeFrom(LocRequest prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
1144 public Builder Clear() {super.Clear();return this;}
1145 public LocRequest BuildPartial() {return new LocRequest(super.BuildPartial());}
1146 public LocRequest Build() {if (_HasAllPBJFields) return new LocRequest(super.Build());return null;}
1147 public pbd::MessageDescriptor DescriptorForType {
1148 get { return LocRequest.Descriptor; } }
1149 public Builder ClearRequestedFields() { super.ClearRequestedFields();return this;}
1150 public const int RequestedFieldsFieldTag=2;
1151 public bool HasRequestedFields { get {
1152 if (!super.HasRequestedFields) return false;
1153 return PBJ._PBJ.ValidateFlags(super.RequestedFields,(ulong)Types.Fields.POSITION|(ulong)Types.Fields.ORIENTATION|(ulong)Types.Fields.VELOCITY|(ulong)Types.Fields.ROTATIONAL_AXIS|(ulong)Types.Fields.ANGULAR_SPEED);
1154 } }
1155 public uint RequestedFields{ get {
1156 if (HasRequestedFields) {
1157 return (uint)PBJ._PBJ.CastFlags(super.RequestedFields,(ulong)Types.Fields.POSITION|(ulong)Types.Fields.ORIENTATION|(ulong)Types.Fields.VELOCITY|(ulong)Types.Fields.ROTATIONAL_AXIS|(ulong)Types.Fields.ANGULAR_SPEED);
1158 } else {
1159 return (uint)PBJ._PBJ.CastFlags((ulong)Types.Fields.POSITION|(ulong)Types.Fields.ORIENTATION|(ulong)Types.Fields.VELOCITY|(ulong)Types.Fields.ROTATIONAL_AXIS|(ulong)Types.Fields.ANGULAR_SPEED);
1160 }
1161 }
1162 set {
1163 super.RequestedFields=((value));
1164 }
1165 }
1166 }
1167 }
1168}
1169namespace Sirikata.Protocol {
1170 public class NewObj : PBJ.IMessage {
1171 protected _PBJ_Internal.NewObj super;
1172 public _PBJ_Internal.NewObj _PBJSuper{ get { return super;} }
1173 public NewObj() {
1174 super=new _PBJ_Internal.NewObj();
1175 }
1176 public NewObj(_PBJ_Internal.NewObj reference) {
1177 super=reference;
1178 }
1179 public static NewObj defaultInstance= new NewObj (_PBJ_Internal.NewObj.DefaultInstance);
1180 public static NewObj DefaultInstance{
1181 get {return defaultInstance;}
1182 }
1183 public static pbd.MessageDescriptor Descriptor {
1184 get { return _PBJ_Internal.NewObj.Descriptor; } }
1185 public static class Types {
1186 }
1187 public static bool WithinReservedFieldTagRange(int field_tag) {
1188 return false;
1189 }
1190 public static bool WithinExtensionFieldTagRange(int field_tag) {
1191 return false;
1192 }
1193 public const int ObjectUuidEvidenceFieldTag=2;
1194 public bool HasObjectUuidEvidence{ get {return super.HasObjectUuidEvidence&&PBJ._PBJ.ValidateUuid(super.ObjectUuidEvidence);} }
1195 public PBJ.UUID ObjectUuidEvidence{ get {
1196 if (HasObjectUuidEvidence) {
1197 return PBJ._PBJ.CastUuid(super.ObjectUuidEvidence);
1198 } else {
1199 return PBJ._PBJ.CastUuid();
1200 }
1201 }
1202 }
1203 public const int RequestedObjectLocFieldTag=3;
1204 public bool HasRequestedObjectLoc{ get {return super.HasRequestedObjectLoc;} }
1205 public ObjLoc RequestedObjectLoc{ get {
1206 if (HasRequestedObjectLoc) {
1207 return new ObjLoc(super.RequestedObjectLoc);
1208 } else {
1209 return new ObjLoc();
1210 }
1211 }
1212 }
1213 public const int BoundingSphereFieldTag=4;
1214 public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} }
1215 public PBJ.BoundingSphere3f BoundingSphere{ get {
1216 int index=0;
1217 if (HasBoundingSphere) {
1218 return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3));
1219 } else {
1220 return PBJ._PBJ.CastBoundingsphere3f();
1221 }
1222 }
1223 }
1224 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
1225 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
1226 public static Builder CreateBuilder() { return new Builder(); }
1227 public static Builder CreateBuilder(NewObj prototype) {
1228 return (Builder)new Builder().MergeFrom(prototype);
1229 }
1230 public static NewObj ParseFrom(pb::ByteString data) {
1231 return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data));
1232 }
1233 public static NewObj ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
1234 return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data,er));
1235 }
1236 public static NewObj ParseFrom(byte[] data) {
1237 return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data));
1238 }
1239 public static NewObj ParseFrom(byte[] data, pb::ExtensionRegistry er) {
1240 return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data,er));
1241 }
1242 public static NewObj ParseFrom(global::System.IO.Stream data) {
1243 return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data));
1244 }
1245 public static NewObj ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
1246 return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data,er));
1247 }
1248 public static NewObj ParseFrom(pb::CodedInputStream data) {
1249 return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data));
1250 }
1251 public static NewObj ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
1252 return new NewObj(_PBJ_Internal.NewObj.ParseFrom(data,er));
1253 }
1254 protected override bool _HasAllPBJFields{ get {
1255 return true
1256 ;
1257 } }
1258 public bool IsInitialized { get {
1259 return super.IsInitialized&&_HasAllPBJFields;
1260 } }
1261 public class Builder : global::PBJ.IMessage.IBuilder{
1262 protected override bool _HasAllPBJFields{ get {
1263 return true
1264 ;
1265 } }
1266 public bool IsInitialized { get {
1267 return super.IsInitialized&&_HasAllPBJFields;
1268 } }
1269 protected _PBJ_Internal.NewObj.Builder super;
1270 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
1271 public _PBJ_Internal.NewObj.Builder _PBJSuper{ get { return super;} }
1272 public Builder() {super = new _PBJ_Internal.NewObj.Builder();}
1273 public Builder(_PBJ_Internal.NewObj.Builder other) {
1274 super=other;
1275 }
1276 public Builder Clone() {return new Builder(super.Clone());}
1277 public Builder MergeFrom(NewObj prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
1278 public Builder Clear() {super.Clear();return this;}
1279 public NewObj BuildPartial() {return new NewObj(super.BuildPartial());}
1280 public NewObj Build() {if (_HasAllPBJFields) return new NewObj(super.Build());return null;}
1281 public pbd::MessageDescriptor DescriptorForType {
1282 get { return NewObj.Descriptor; } }
1283 public Builder ClearObjectUuidEvidence() { super.ClearObjectUuidEvidence();return this;}
1284 public const int ObjectUuidEvidenceFieldTag=2;
1285 public bool HasObjectUuidEvidence{ get {return super.HasObjectUuidEvidence&&PBJ._PBJ.ValidateUuid(super.ObjectUuidEvidence);} }
1286 public PBJ.UUID ObjectUuidEvidence{ get {
1287 if (HasObjectUuidEvidence) {
1288 return PBJ._PBJ.CastUuid(super.ObjectUuidEvidence);
1289 } else {
1290 return PBJ._PBJ.CastUuid();
1291 }
1292 }
1293 set {
1294 super.ObjectUuidEvidence=(PBJ._PBJ.Construct(value));
1295 }
1296 }
1297 public Builder ClearRequestedObjectLoc() { super.ClearRequestedObjectLoc();return this;}
1298 public const int RequestedObjectLocFieldTag=3;
1299 public bool HasRequestedObjectLoc{ get {return super.HasRequestedObjectLoc;} }
1300 public ObjLoc RequestedObjectLoc{ get {
1301 if (HasRequestedObjectLoc) {
1302 return new ObjLoc(super.RequestedObjectLoc);
1303 } else {
1304 return new ObjLoc();
1305 }
1306 }
1307 set {
1308 super.RequestedObjectLoc=value._PBJSuper;
1309 }
1310 }
1311 public Builder ClearBoundingSphere() { super.ClearBoundingSphere();return this;}
1312 public const int BoundingSphereFieldTag=4;
1313 public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} }
1314 public PBJ.BoundingSphere3f BoundingSphere{ get {
1315 int index=0;
1316 if (HasBoundingSphere) {
1317 return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3));
1318 } else {
1319 return PBJ._PBJ.CastBoundingsphere3f();
1320 }
1321 }
1322 set {
1323 super.ClearBoundingSphere();
1324 float[] _PBJtempArray=PBJ._PBJ.ConstructBoundingsphere3f(value);
1325 super.AddBoundingSphere(_PBJtempArray[0]);
1326 super.AddBoundingSphere(_PBJtempArray[1]);
1327 super.AddBoundingSphere(_PBJtempArray[2]);
1328 super.AddBoundingSphere(_PBJtempArray[3]);
1329 }
1330 }
1331 }
1332 }
1333}
1334namespace Sirikata.Protocol {
1335 public class RetObj : PBJ.IMessage {
1336 protected _PBJ_Internal.RetObj super;
1337 public _PBJ_Internal.RetObj _PBJSuper{ get { return super;} }
1338 public RetObj() {
1339 super=new _PBJ_Internal.RetObj();
1340 }
1341 public RetObj(_PBJ_Internal.RetObj reference) {
1342 super=reference;
1343 }
1344 public static RetObj defaultInstance= new RetObj (_PBJ_Internal.RetObj.DefaultInstance);
1345 public static RetObj DefaultInstance{
1346 get {return defaultInstance;}
1347 }
1348 public static pbd.MessageDescriptor Descriptor {
1349 get { return _PBJ_Internal.RetObj.Descriptor; } }
1350 public static class Types {
1351 }
1352 public static bool WithinReservedFieldTagRange(int field_tag) {
1353 return false;
1354 }
1355 public static bool WithinExtensionFieldTagRange(int field_tag) {
1356 return false;
1357 }
1358 public const int ObjectReferenceFieldTag=2;
1359 public bool HasObjectReference{ get {return super.HasObjectReference&&PBJ._PBJ.ValidateUuid(super.ObjectReference);} }
1360 public PBJ.UUID ObjectReference{ get {
1361 if (HasObjectReference) {
1362 return PBJ._PBJ.CastUuid(super.ObjectReference);
1363 } else {
1364 return PBJ._PBJ.CastUuid();
1365 }
1366 }
1367 }
1368 public const int LocationFieldTag=3;
1369 public bool HasLocation{ get {return super.HasLocation;} }
1370 public ObjLoc Location{ get {
1371 if (HasLocation) {
1372 return new ObjLoc(super.Location);
1373 } else {
1374 return new ObjLoc();
1375 }
1376 }
1377 }
1378 public const int BoundingSphereFieldTag=4;
1379 public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} }
1380 public PBJ.BoundingSphere3f BoundingSphere{ get {
1381 int index=0;
1382 if (HasBoundingSphere) {
1383 return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3));
1384 } else {
1385 return PBJ._PBJ.CastBoundingsphere3f();
1386 }
1387 }
1388 }
1389 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
1390 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
1391 public static Builder CreateBuilder() { return new Builder(); }
1392 public static Builder CreateBuilder(RetObj prototype) {
1393 return (Builder)new Builder().MergeFrom(prototype);
1394 }
1395 public static RetObj ParseFrom(pb::ByteString data) {
1396 return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data));
1397 }
1398 public static RetObj ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
1399 return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data,er));
1400 }
1401 public static RetObj ParseFrom(byte[] data) {
1402 return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data));
1403 }
1404 public static RetObj ParseFrom(byte[] data, pb::ExtensionRegistry er) {
1405 return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data,er));
1406 }
1407 public static RetObj ParseFrom(global::System.IO.Stream data) {
1408 return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data));
1409 }
1410 public static RetObj ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
1411 return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data,er));
1412 }
1413 public static RetObj ParseFrom(pb::CodedInputStream data) {
1414 return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data));
1415 }
1416 public static RetObj ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
1417 return new RetObj(_PBJ_Internal.RetObj.ParseFrom(data,er));
1418 }
1419 protected override bool _HasAllPBJFields{ get {
1420 return true
1421 ;
1422 } }
1423 public bool IsInitialized { get {
1424 return super.IsInitialized&&_HasAllPBJFields;
1425 } }
1426 public class Builder : global::PBJ.IMessage.IBuilder{
1427 protected override bool _HasAllPBJFields{ get {
1428 return true
1429 ;
1430 } }
1431 public bool IsInitialized { get {
1432 return super.IsInitialized&&_HasAllPBJFields;
1433 } }
1434 protected _PBJ_Internal.RetObj.Builder super;
1435 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
1436 public _PBJ_Internal.RetObj.Builder _PBJSuper{ get { return super;} }
1437 public Builder() {super = new _PBJ_Internal.RetObj.Builder();}
1438 public Builder(_PBJ_Internal.RetObj.Builder other) {
1439 super=other;
1440 }
1441 public Builder Clone() {return new Builder(super.Clone());}
1442 public Builder MergeFrom(RetObj prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
1443 public Builder Clear() {super.Clear();return this;}
1444 public RetObj BuildPartial() {return new RetObj(super.BuildPartial());}
1445 public RetObj Build() {if (_HasAllPBJFields) return new RetObj(super.Build());return null;}
1446 public pbd::MessageDescriptor DescriptorForType {
1447 get { return RetObj.Descriptor; } }
1448 public Builder ClearObjectReference() { super.ClearObjectReference();return this;}
1449 public const int ObjectReferenceFieldTag=2;
1450 public bool HasObjectReference{ get {return super.HasObjectReference&&PBJ._PBJ.ValidateUuid(super.ObjectReference);} }
1451 public PBJ.UUID ObjectReference{ get {
1452 if (HasObjectReference) {
1453 return PBJ._PBJ.CastUuid(super.ObjectReference);
1454 } else {
1455 return PBJ._PBJ.CastUuid();
1456 }
1457 }
1458 set {
1459 super.ObjectReference=(PBJ._PBJ.Construct(value));
1460 }
1461 }
1462 public Builder ClearLocation() { super.ClearLocation();return this;}
1463 public const int LocationFieldTag=3;
1464 public bool HasLocation{ get {return super.HasLocation;} }
1465 public ObjLoc Location{ get {
1466 if (HasLocation) {
1467 return new ObjLoc(super.Location);
1468 } else {
1469 return new ObjLoc();
1470 }
1471 }
1472 set {
1473 super.Location=value._PBJSuper;
1474 }
1475 }
1476 public Builder ClearBoundingSphere() { super.ClearBoundingSphere();return this;}
1477 public const int BoundingSphereFieldTag=4;
1478 public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} }
1479 public PBJ.BoundingSphere3f BoundingSphere{ get {
1480 int index=0;
1481 if (HasBoundingSphere) {
1482 return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3));
1483 } else {
1484 return PBJ._PBJ.CastBoundingsphere3f();
1485 }
1486 }
1487 set {
1488 super.ClearBoundingSphere();
1489 float[] _PBJtempArray=PBJ._PBJ.ConstructBoundingsphere3f(value);
1490 super.AddBoundingSphere(_PBJtempArray[0]);
1491 super.AddBoundingSphere(_PBJtempArray[1]);
1492 super.AddBoundingSphere(_PBJtempArray[2]);
1493 super.AddBoundingSphere(_PBJtempArray[3]);
1494 }
1495 }
1496 }
1497 }
1498}
1499namespace Sirikata.Protocol {
1500 public class DelObj : PBJ.IMessage {
1501 protected _PBJ_Internal.DelObj super;
1502 public _PBJ_Internal.DelObj _PBJSuper{ get { return super;} }
1503 public DelObj() {
1504 super=new _PBJ_Internal.DelObj();
1505 }
1506 public DelObj(_PBJ_Internal.DelObj reference) {
1507 super=reference;
1508 }
1509 public static DelObj defaultInstance= new DelObj (_PBJ_Internal.DelObj.DefaultInstance);
1510 public static DelObj DefaultInstance{
1511 get {return defaultInstance;}
1512 }
1513 public static pbd.MessageDescriptor Descriptor {
1514 get { return _PBJ_Internal.DelObj.Descriptor; } }
1515 public static class Types {
1516 }
1517 public static bool WithinReservedFieldTagRange(int field_tag) {
1518 return false;
1519 }
1520 public static bool WithinExtensionFieldTagRange(int field_tag) {
1521 return false;
1522 }
1523 public const int ObjectReferenceFieldTag=2;
1524 public bool HasObjectReference{ get {return super.HasObjectReference&&PBJ._PBJ.ValidateUuid(super.ObjectReference);} }
1525 public PBJ.UUID ObjectReference{ get {
1526 if (HasObjectReference) {
1527 return PBJ._PBJ.CastUuid(super.ObjectReference);
1528 } else {
1529 return PBJ._PBJ.CastUuid();
1530 }
1531 }
1532 }
1533 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
1534 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
1535 public static Builder CreateBuilder() { return new Builder(); }
1536 public static Builder CreateBuilder(DelObj prototype) {
1537 return (Builder)new Builder().MergeFrom(prototype);
1538 }
1539 public static DelObj ParseFrom(pb::ByteString data) {
1540 return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data));
1541 }
1542 public static DelObj ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
1543 return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data,er));
1544 }
1545 public static DelObj ParseFrom(byte[] data) {
1546 return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data));
1547 }
1548 public static DelObj ParseFrom(byte[] data, pb::ExtensionRegistry er) {
1549 return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data,er));
1550 }
1551 public static DelObj ParseFrom(global::System.IO.Stream data) {
1552 return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data));
1553 }
1554 public static DelObj ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
1555 return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data,er));
1556 }
1557 public static DelObj ParseFrom(pb::CodedInputStream data) {
1558 return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data));
1559 }
1560 public static DelObj ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
1561 return new DelObj(_PBJ_Internal.DelObj.ParseFrom(data,er));
1562 }
1563 protected override bool _HasAllPBJFields{ get {
1564 return true
1565 ;
1566 } }
1567 public bool IsInitialized { get {
1568 return super.IsInitialized&&_HasAllPBJFields;
1569 } }
1570 public class Builder : global::PBJ.IMessage.IBuilder{
1571 protected override bool _HasAllPBJFields{ get {
1572 return true
1573 ;
1574 } }
1575 public bool IsInitialized { get {
1576 return super.IsInitialized&&_HasAllPBJFields;
1577 } }
1578 protected _PBJ_Internal.DelObj.Builder super;
1579 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
1580 public _PBJ_Internal.DelObj.Builder _PBJSuper{ get { return super;} }
1581 public Builder() {super = new _PBJ_Internal.DelObj.Builder();}
1582 public Builder(_PBJ_Internal.DelObj.Builder other) {
1583 super=other;
1584 }
1585 public Builder Clone() {return new Builder(super.Clone());}
1586 public Builder MergeFrom(DelObj prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
1587 public Builder Clear() {super.Clear();return this;}
1588 public DelObj BuildPartial() {return new DelObj(super.BuildPartial());}
1589 public DelObj Build() {if (_HasAllPBJFields) return new DelObj(super.Build());return null;}
1590 public pbd::MessageDescriptor DescriptorForType {
1591 get { return DelObj.Descriptor; } }
1592 public Builder ClearObjectReference() { super.ClearObjectReference();return this;}
1593 public const int ObjectReferenceFieldTag=2;
1594 public bool HasObjectReference{ get {return super.HasObjectReference&&PBJ._PBJ.ValidateUuid(super.ObjectReference);} }
1595 public PBJ.UUID ObjectReference{ get {
1596 if (HasObjectReference) {
1597 return PBJ._PBJ.CastUuid(super.ObjectReference);
1598 } else {
1599 return PBJ._PBJ.CastUuid();
1600 }
1601 }
1602 set {
1603 super.ObjectReference=(PBJ._PBJ.Construct(value));
1604 }
1605 }
1606 }
1607 }
1608}
1609namespace Sirikata.Protocol {
1610 public class NewProxQuery : PBJ.IMessage {
1611 protected _PBJ_Internal.NewProxQuery super;
1612 public _PBJ_Internal.NewProxQuery _PBJSuper{ get { return super;} }
1613 public NewProxQuery() {
1614 super=new _PBJ_Internal.NewProxQuery();
1615 }
1616 public NewProxQuery(_PBJ_Internal.NewProxQuery reference) {
1617 super=reference;
1618 }
1619 public static NewProxQuery defaultInstance= new NewProxQuery (_PBJ_Internal.NewProxQuery.DefaultInstance);
1620 public static NewProxQuery DefaultInstance{
1621 get {return defaultInstance;}
1622 }
1623 public static pbd.MessageDescriptor Descriptor {
1624 get { return _PBJ_Internal.NewProxQuery.Descriptor; } }
1625 public static class Types {
1626 }
1627 public static bool WithinReservedFieldTagRange(int field_tag) {
1628 return false;
1629 }
1630 public static bool WithinExtensionFieldTagRange(int field_tag) {
1631 return false;
1632 }
1633 public const int QueryIdFieldTag=2;
1634 public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} }
1635 public uint QueryId{ get {
1636 if (HasQueryId) {
1637 return PBJ._PBJ.CastUint32(super.QueryId);
1638 } else {
1639 return PBJ._PBJ.CastUint32();
1640 }
1641 }
1642 }
1643 public const int StatelessFieldTag=3;
1644 public bool HasStateless{ get {return super.HasStateless&&PBJ._PBJ.ValidateBool(super.Stateless);} }
1645 public bool Stateless{ get {
1646 if (HasStateless) {
1647 return PBJ._PBJ.CastBool(super.Stateless);
1648 } else {
1649 return PBJ._PBJ.CastBool();
1650 }
1651 }
1652 }
1653 public const int RelativeCenterFieldTag=4;
1654 public bool HasRelativeCenter{ get {return super.RelativeCenterCount>=3;} }
1655 public PBJ.Vector3f RelativeCenter{ get {
1656 int index=0;
1657 if (HasRelativeCenter) {
1658 return PBJ._PBJ.CastVector3f(super.GetRelativeCenter(index*3+0),super.GetRelativeCenter(index*3+1),super.GetRelativeCenter(index*3+2));
1659 } else {
1660 return PBJ._PBJ.CastVector3f();
1661 }
1662 }
1663 }
1664 public const int AbsoluteCenterFieldTag=5;
1665 public bool HasAbsoluteCenter{ get {return super.AbsoluteCenterCount>=3;} }
1666 public PBJ.Vector3d AbsoluteCenter{ get {
1667 int index=0;
1668 if (HasAbsoluteCenter) {
1669 return PBJ._PBJ.CastVector3d(super.GetAbsoluteCenter(index*3+0),super.GetAbsoluteCenter(index*3+1),super.GetAbsoluteCenter(index*3+2));
1670 } else {
1671 return PBJ._PBJ.CastVector3d();
1672 }
1673 }
1674 }
1675 public const int MaxRadiusFieldTag=6;
1676 public bool HasMaxRadius{ get {return super.HasMaxRadius&&PBJ._PBJ.ValidateFloat(super.MaxRadius);} }
1677 public float MaxRadius{ get {
1678 if (HasMaxRadius) {
1679 return PBJ._PBJ.CastFloat(super.MaxRadius);
1680 } else {
1681 return PBJ._PBJ.CastFloat();
1682 }
1683 }
1684 }
1685 public const int MinSolidAngleFieldTag=7;
1686 public bool HasMinSolidAngle{ get {return super.HasMinSolidAngle&&PBJ._PBJ.ValidateAngle(super.MinSolidAngle);} }
1687 public float MinSolidAngle{ get {
1688 if (HasMinSolidAngle) {
1689 return PBJ._PBJ.CastAngle(super.MinSolidAngle);
1690 } else {
1691 return PBJ._PBJ.CastAngle();
1692 }
1693 }
1694 }
1695 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
1696 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
1697 public static Builder CreateBuilder() { return new Builder(); }
1698 public static Builder CreateBuilder(NewProxQuery prototype) {
1699 return (Builder)new Builder().MergeFrom(prototype);
1700 }
1701 public static NewProxQuery ParseFrom(pb::ByteString data) {
1702 return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data));
1703 }
1704 public static NewProxQuery ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
1705 return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data,er));
1706 }
1707 public static NewProxQuery ParseFrom(byte[] data) {
1708 return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data));
1709 }
1710 public static NewProxQuery ParseFrom(byte[] data, pb::ExtensionRegistry er) {
1711 return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data,er));
1712 }
1713 public static NewProxQuery ParseFrom(global::System.IO.Stream data) {
1714 return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data));
1715 }
1716 public static NewProxQuery ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
1717 return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data,er));
1718 }
1719 public static NewProxQuery ParseFrom(pb::CodedInputStream data) {
1720 return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data));
1721 }
1722 public static NewProxQuery ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
1723 return new NewProxQuery(_PBJ_Internal.NewProxQuery.ParseFrom(data,er));
1724 }
1725 protected override bool _HasAllPBJFields{ get {
1726 return true
1727 ;
1728 } }
1729 public bool IsInitialized { get {
1730 return super.IsInitialized&&_HasAllPBJFields;
1731 } }
1732 public class Builder : global::PBJ.IMessage.IBuilder{
1733 protected override bool _HasAllPBJFields{ get {
1734 return true
1735 ;
1736 } }
1737 public bool IsInitialized { get {
1738 return super.IsInitialized&&_HasAllPBJFields;
1739 } }
1740 protected _PBJ_Internal.NewProxQuery.Builder super;
1741 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
1742 public _PBJ_Internal.NewProxQuery.Builder _PBJSuper{ get { return super;} }
1743 public Builder() {super = new _PBJ_Internal.NewProxQuery.Builder();}
1744 public Builder(_PBJ_Internal.NewProxQuery.Builder other) {
1745 super=other;
1746 }
1747 public Builder Clone() {return new Builder(super.Clone());}
1748 public Builder MergeFrom(NewProxQuery prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
1749 public Builder Clear() {super.Clear();return this;}
1750 public NewProxQuery BuildPartial() {return new NewProxQuery(super.BuildPartial());}
1751 public NewProxQuery Build() {if (_HasAllPBJFields) return new NewProxQuery(super.Build());return null;}
1752 public pbd::MessageDescriptor DescriptorForType {
1753 get { return NewProxQuery.Descriptor; } }
1754 public Builder ClearQueryId() { super.ClearQueryId();return this;}
1755 public const int QueryIdFieldTag=2;
1756 public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} }
1757 public uint QueryId{ get {
1758 if (HasQueryId) {
1759 return PBJ._PBJ.CastUint32(super.QueryId);
1760 } else {
1761 return PBJ._PBJ.CastUint32();
1762 }
1763 }
1764 set {
1765 super.QueryId=(PBJ._PBJ.Construct(value));
1766 }
1767 }
1768 public Builder ClearStateless() { super.ClearStateless();return this;}
1769 public const int StatelessFieldTag=3;
1770 public bool HasStateless{ get {return super.HasStateless&&PBJ._PBJ.ValidateBool(super.Stateless);} }
1771 public bool Stateless{ get {
1772 if (HasStateless) {
1773 return PBJ._PBJ.CastBool(super.Stateless);
1774 } else {
1775 return PBJ._PBJ.CastBool();
1776 }
1777 }
1778 set {
1779 super.Stateless=(PBJ._PBJ.Construct(value));
1780 }
1781 }
1782 public Builder ClearRelativeCenter() { super.ClearRelativeCenter();return this;}
1783 public const int RelativeCenterFieldTag=4;
1784 public bool HasRelativeCenter{ get {return super.RelativeCenterCount>=3;} }
1785 public PBJ.Vector3f RelativeCenter{ get {
1786 int index=0;
1787 if (HasRelativeCenter) {
1788 return PBJ._PBJ.CastVector3f(super.GetRelativeCenter(index*3+0),super.GetRelativeCenter(index*3+1),super.GetRelativeCenter(index*3+2));
1789 } else {
1790 return PBJ._PBJ.CastVector3f();
1791 }
1792 }
1793 set {
1794 super.ClearRelativeCenter();
1795 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
1796 super.AddRelativeCenter(_PBJtempArray[0]);
1797 super.AddRelativeCenter(_PBJtempArray[1]);
1798 super.AddRelativeCenter(_PBJtempArray[2]);
1799 }
1800 }
1801 public Builder ClearAbsoluteCenter() { super.ClearAbsoluteCenter();return this;}
1802 public const int AbsoluteCenterFieldTag=5;
1803 public bool HasAbsoluteCenter{ get {return super.AbsoluteCenterCount>=3;} }
1804 public PBJ.Vector3d AbsoluteCenter{ get {
1805 int index=0;
1806 if (HasAbsoluteCenter) {
1807 return PBJ._PBJ.CastVector3d(super.GetAbsoluteCenter(index*3+0),super.GetAbsoluteCenter(index*3+1),super.GetAbsoluteCenter(index*3+2));
1808 } else {
1809 return PBJ._PBJ.CastVector3d();
1810 }
1811 }
1812 set {
1813 super.ClearAbsoluteCenter();
1814 double[] _PBJtempArray=PBJ._PBJ.ConstructVector3d(value);
1815 super.AddAbsoluteCenter(_PBJtempArray[0]);
1816 super.AddAbsoluteCenter(_PBJtempArray[1]);
1817 super.AddAbsoluteCenter(_PBJtempArray[2]);
1818 }
1819 }
1820 public Builder ClearMaxRadius() { super.ClearMaxRadius();return this;}
1821 public const int MaxRadiusFieldTag=6;
1822 public bool HasMaxRadius{ get {return super.HasMaxRadius&&PBJ._PBJ.ValidateFloat(super.MaxRadius);} }
1823 public float MaxRadius{ get {
1824 if (HasMaxRadius) {
1825 return PBJ._PBJ.CastFloat(super.MaxRadius);
1826 } else {
1827 return PBJ._PBJ.CastFloat();
1828 }
1829 }
1830 set {
1831 super.MaxRadius=(PBJ._PBJ.Construct(value));
1832 }
1833 }
1834 public Builder ClearMinSolidAngle() { super.ClearMinSolidAngle();return this;}
1835 public const int MinSolidAngleFieldTag=7;
1836 public bool HasMinSolidAngle{ get {return super.HasMinSolidAngle&&PBJ._PBJ.ValidateAngle(super.MinSolidAngle);} }
1837 public float MinSolidAngle{ get {
1838 if (HasMinSolidAngle) {
1839 return PBJ._PBJ.CastAngle(super.MinSolidAngle);
1840 } else {
1841 return PBJ._PBJ.CastAngle();
1842 }
1843 }
1844 set {
1845 super.MinSolidAngle=(PBJ._PBJ.Construct(value));
1846 }
1847 }
1848 }
1849 }
1850}
1851namespace Sirikata.Protocol {
1852 public class ProxCall : PBJ.IMessage {
1853 protected _PBJ_Internal.ProxCall super;
1854 public _PBJ_Internal.ProxCall _PBJSuper{ get { return super;} }
1855 public ProxCall() {
1856 super=new _PBJ_Internal.ProxCall();
1857 }
1858 public ProxCall(_PBJ_Internal.ProxCall reference) {
1859 super=reference;
1860 }
1861 public static ProxCall defaultInstance= new ProxCall (_PBJ_Internal.ProxCall.DefaultInstance);
1862 public static ProxCall DefaultInstance{
1863 get {return defaultInstance;}
1864 }
1865 public static pbd.MessageDescriptor Descriptor {
1866 get { return _PBJ_Internal.ProxCall.Descriptor; } }
1867 public static class Types {
1868 public enum ProximityEvent {
1869 EXITED_PROXIMITY=_PBJ_Internal.ProxCall.Types.ProximityEvent.EXITED_PROXIMITY,
1870 ENTERED_PROXIMITY=_PBJ_Internal.ProxCall.Types.ProximityEvent.ENTERED_PROXIMITY,
1871 STATELESS_PROXIMITY=_PBJ_Internal.ProxCall.Types.ProximityEvent.STATELESS_PROXIMITY
1872 };
1873 }
1874 public static bool WithinReservedFieldTagRange(int field_tag) {
1875 return false;
1876 }
1877 public static bool WithinExtensionFieldTagRange(int field_tag) {
1878 return false;
1879 }
1880 public const int QueryIdFieldTag=2;
1881 public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} }
1882 public uint QueryId{ get {
1883 if (HasQueryId) {
1884 return PBJ._PBJ.CastUint32(super.QueryId);
1885 } else {
1886 return PBJ._PBJ.CastUint32();
1887 }
1888 }
1889 }
1890 public const int ProximateObjectFieldTag=3;
1891 public bool HasProximateObject{ get {return super.HasProximateObject&&PBJ._PBJ.ValidateUuid(super.ProximateObject);} }
1892 public PBJ.UUID ProximateObject{ get {
1893 if (HasProximateObject) {
1894 return PBJ._PBJ.CastUuid(super.ProximateObject);
1895 } else {
1896 return PBJ._PBJ.CastUuid();
1897 }
1898 }
1899 }
1900 public const int ProximityEventFieldTag=4;
1901 public bool HasProximityEvent{ get {return super.HasProximityEvent;} }
1902 public Types.ProximityEvent ProximityEvent{ get {
1903 if (HasProximityEvent) {
1904 return (Types.ProximityEvent)super.ProximityEvent;
1905 } else {
1906 return new Types.ProximityEvent();
1907 }
1908 }
1909 }
1910 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
1911 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
1912 public static Builder CreateBuilder() { return new Builder(); }
1913 public static Builder CreateBuilder(ProxCall prototype) {
1914 return (Builder)new Builder().MergeFrom(prototype);
1915 }
1916 public static ProxCall ParseFrom(pb::ByteString data) {
1917 return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data));
1918 }
1919 public static ProxCall ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
1920 return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data,er));
1921 }
1922 public static ProxCall ParseFrom(byte[] data) {
1923 return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data));
1924 }
1925 public static ProxCall ParseFrom(byte[] data, pb::ExtensionRegistry er) {
1926 return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data,er));
1927 }
1928 public static ProxCall ParseFrom(global::System.IO.Stream data) {
1929 return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data));
1930 }
1931 public static ProxCall ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
1932 return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data,er));
1933 }
1934 public static ProxCall ParseFrom(pb::CodedInputStream data) {
1935 return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data));
1936 }
1937 public static ProxCall ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
1938 return new ProxCall(_PBJ_Internal.ProxCall.ParseFrom(data,er));
1939 }
1940 protected override bool _HasAllPBJFields{ get {
1941 return true
1942 ;
1943 } }
1944 public bool IsInitialized { get {
1945 return super.IsInitialized&&_HasAllPBJFields;
1946 } }
1947 public class Builder : global::PBJ.IMessage.IBuilder{
1948 protected override bool _HasAllPBJFields{ get {
1949 return true
1950 ;
1951 } }
1952 public bool IsInitialized { get {
1953 return super.IsInitialized&&_HasAllPBJFields;
1954 } }
1955 protected _PBJ_Internal.ProxCall.Builder super;
1956 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
1957 public _PBJ_Internal.ProxCall.Builder _PBJSuper{ get { return super;} }
1958 public Builder() {super = new _PBJ_Internal.ProxCall.Builder();}
1959 public Builder(_PBJ_Internal.ProxCall.Builder other) {
1960 super=other;
1961 }
1962 public Builder Clone() {return new Builder(super.Clone());}
1963 public Builder MergeFrom(ProxCall prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
1964 public Builder Clear() {super.Clear();return this;}
1965 public ProxCall BuildPartial() {return new ProxCall(super.BuildPartial());}
1966 public ProxCall Build() {if (_HasAllPBJFields) return new ProxCall(super.Build());return null;}
1967 public pbd::MessageDescriptor DescriptorForType {
1968 get { return ProxCall.Descriptor; } }
1969 public Builder ClearQueryId() { super.ClearQueryId();return this;}
1970 public const int QueryIdFieldTag=2;
1971 public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} }
1972 public uint QueryId{ get {
1973 if (HasQueryId) {
1974 return PBJ._PBJ.CastUint32(super.QueryId);
1975 } else {
1976 return PBJ._PBJ.CastUint32();
1977 }
1978 }
1979 set {
1980 super.QueryId=(PBJ._PBJ.Construct(value));
1981 }
1982 }
1983 public Builder ClearProximateObject() { super.ClearProximateObject();return this;}
1984 public const int ProximateObjectFieldTag=3;
1985 public bool HasProximateObject{ get {return super.HasProximateObject&&PBJ._PBJ.ValidateUuid(super.ProximateObject);} }
1986 public PBJ.UUID ProximateObject{ get {
1987 if (HasProximateObject) {
1988 return PBJ._PBJ.CastUuid(super.ProximateObject);
1989 } else {
1990 return PBJ._PBJ.CastUuid();
1991 }
1992 }
1993 set {
1994 super.ProximateObject=(PBJ._PBJ.Construct(value));
1995 }
1996 }
1997 public Builder ClearProximityEvent() { super.ClearProximityEvent();return this;}
1998 public const int ProximityEventFieldTag=4;
1999 public bool HasProximityEvent{ get {return super.HasProximityEvent;} }
2000 public Types.ProximityEvent ProximityEvent{ get {
2001 if (HasProximityEvent) {
2002 return (Types.ProximityEvent)super.ProximityEvent;
2003 } else {
2004 return new Types.ProximityEvent();
2005 }
2006 }
2007 set {
2008 super.ProximityEvent=((_PBJ_Internal.ProxCall.Types.ProximityEvent)value);
2009 }
2010 }
2011 }
2012 }
2013}
2014namespace Sirikata.Protocol {
2015 public class DelProxQuery : PBJ.IMessage {
2016 protected _PBJ_Internal.DelProxQuery super;
2017 public _PBJ_Internal.DelProxQuery _PBJSuper{ get { return super;} }
2018 public DelProxQuery() {
2019 super=new _PBJ_Internal.DelProxQuery();
2020 }
2021 public DelProxQuery(_PBJ_Internal.DelProxQuery reference) {
2022 super=reference;
2023 }
2024 public static DelProxQuery defaultInstance= new DelProxQuery (_PBJ_Internal.DelProxQuery.DefaultInstance);
2025 public static DelProxQuery DefaultInstance{
2026 get {return defaultInstance;}
2027 }
2028 public static pbd.MessageDescriptor Descriptor {
2029 get { return _PBJ_Internal.DelProxQuery.Descriptor; } }
2030 public static class Types {
2031 }
2032 public static bool WithinReservedFieldTagRange(int field_tag) {
2033 return false;
2034 }
2035 public static bool WithinExtensionFieldTagRange(int field_tag) {
2036 return false;
2037 }
2038 public const int QueryIdFieldTag=2;
2039 public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} }
2040 public uint QueryId{ get {
2041 if (HasQueryId) {
2042 return PBJ._PBJ.CastUint32(super.QueryId);
2043 } else {
2044 return PBJ._PBJ.CastUint32();
2045 }
2046 }
2047 }
2048 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
2049 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
2050 public static Builder CreateBuilder() { return new Builder(); }
2051 public static Builder CreateBuilder(DelProxQuery prototype) {
2052 return (Builder)new Builder().MergeFrom(prototype);
2053 }
2054 public static DelProxQuery ParseFrom(pb::ByteString data) {
2055 return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data));
2056 }
2057 public static DelProxQuery ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
2058 return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data,er));
2059 }
2060 public static DelProxQuery ParseFrom(byte[] data) {
2061 return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data));
2062 }
2063 public static DelProxQuery ParseFrom(byte[] data, pb::ExtensionRegistry er) {
2064 return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data,er));
2065 }
2066 public static DelProxQuery ParseFrom(global::System.IO.Stream data) {
2067 return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data));
2068 }
2069 public static DelProxQuery ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
2070 return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data,er));
2071 }
2072 public static DelProxQuery ParseFrom(pb::CodedInputStream data) {
2073 return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data));
2074 }
2075 public static DelProxQuery ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
2076 return new DelProxQuery(_PBJ_Internal.DelProxQuery.ParseFrom(data,er));
2077 }
2078 protected override bool _HasAllPBJFields{ get {
2079 return true
2080 ;
2081 } }
2082 public bool IsInitialized { get {
2083 return super.IsInitialized&&_HasAllPBJFields;
2084 } }
2085 public class Builder : global::PBJ.IMessage.IBuilder{
2086 protected override bool _HasAllPBJFields{ get {
2087 return true
2088 ;
2089 } }
2090 public bool IsInitialized { get {
2091 return super.IsInitialized&&_HasAllPBJFields;
2092 } }
2093 protected _PBJ_Internal.DelProxQuery.Builder super;
2094 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
2095 public _PBJ_Internal.DelProxQuery.Builder _PBJSuper{ get { return super;} }
2096 public Builder() {super = new _PBJ_Internal.DelProxQuery.Builder();}
2097 public Builder(_PBJ_Internal.DelProxQuery.Builder other) {
2098 super=other;
2099 }
2100 public Builder Clone() {return new Builder(super.Clone());}
2101 public Builder MergeFrom(DelProxQuery prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
2102 public Builder Clear() {super.Clear();return this;}
2103 public DelProxQuery BuildPartial() {return new DelProxQuery(super.BuildPartial());}
2104 public DelProxQuery Build() {if (_HasAllPBJFields) return new DelProxQuery(super.Build());return null;}
2105 public pbd::MessageDescriptor DescriptorForType {
2106 get { return DelProxQuery.Descriptor; } }
2107 public Builder ClearQueryId() { super.ClearQueryId();return this;}
2108 public const int QueryIdFieldTag=2;
2109 public bool HasQueryId{ get {return super.HasQueryId&&PBJ._PBJ.ValidateUint32(super.QueryId);} }
2110 public uint QueryId{ get {
2111 if (HasQueryId) {
2112 return PBJ._PBJ.CastUint32(super.QueryId);
2113 } else {
2114 return PBJ._PBJ.CastUint32();
2115 }
2116 }
2117 set {
2118 super.QueryId=(PBJ._PBJ.Construct(value));
2119 }
2120 }
2121 }
2122 }
2123}
2124namespace Sirikata.Protocol {
2125 public class Vector3fProperty : PBJ.IMessage {
2126 protected _PBJ_Internal.Vector3fProperty super;
2127 public _PBJ_Internal.Vector3fProperty _PBJSuper{ get { return super;} }
2128 public Vector3fProperty() {
2129 super=new _PBJ_Internal.Vector3fProperty();
2130 }
2131 public Vector3fProperty(_PBJ_Internal.Vector3fProperty reference) {
2132 super=reference;
2133 }
2134 public static Vector3fProperty defaultInstance= new Vector3fProperty (_PBJ_Internal.Vector3fProperty.DefaultInstance);
2135 public static Vector3fProperty DefaultInstance{
2136 get {return defaultInstance;}
2137 }
2138 public static pbd.MessageDescriptor Descriptor {
2139 get { return _PBJ_Internal.Vector3fProperty.Descriptor; } }
2140 public static class Types {
2141 }
2142 public static bool WithinReservedFieldTagRange(int field_tag) {
2143 return false;
2144 }
2145 public static bool WithinExtensionFieldTagRange(int field_tag) {
2146 return false;
2147 }
2148 public const int ValueFieldTag=10;
2149 public bool HasValue{ get {return super.ValueCount>=3;} }
2150 public PBJ.Vector3f Value{ get {
2151 int index=0;
2152 if (HasValue) {
2153 return PBJ._PBJ.CastVector3f(super.GetValue(index*3+0),super.GetValue(index*3+1),super.GetValue(index*3+2));
2154 } else {
2155 return PBJ._PBJ.CastVector3f();
2156 }
2157 }
2158 }
2159 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
2160 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
2161 public static Builder CreateBuilder() { return new Builder(); }
2162 public static Builder CreateBuilder(Vector3fProperty prototype) {
2163 return (Builder)new Builder().MergeFrom(prototype);
2164 }
2165 public static Vector3fProperty ParseFrom(pb::ByteString data) {
2166 return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data));
2167 }
2168 public static Vector3fProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
2169 return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data,er));
2170 }
2171 public static Vector3fProperty ParseFrom(byte[] data) {
2172 return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data));
2173 }
2174 public static Vector3fProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) {
2175 return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data,er));
2176 }
2177 public static Vector3fProperty ParseFrom(global::System.IO.Stream data) {
2178 return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data));
2179 }
2180 public static Vector3fProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
2181 return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data,er));
2182 }
2183 public static Vector3fProperty ParseFrom(pb::CodedInputStream data) {
2184 return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data));
2185 }
2186 public static Vector3fProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
2187 return new Vector3fProperty(_PBJ_Internal.Vector3fProperty.ParseFrom(data,er));
2188 }
2189 protected override bool _HasAllPBJFields{ get {
2190 return true
2191 ;
2192 } }
2193 public bool IsInitialized { get {
2194 return super.IsInitialized&&_HasAllPBJFields;
2195 } }
2196 public class Builder : global::PBJ.IMessage.IBuilder{
2197 protected override bool _HasAllPBJFields{ get {
2198 return true
2199 ;
2200 } }
2201 public bool IsInitialized { get {
2202 return super.IsInitialized&&_HasAllPBJFields;
2203 } }
2204 protected _PBJ_Internal.Vector3fProperty.Builder super;
2205 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
2206 public _PBJ_Internal.Vector3fProperty.Builder _PBJSuper{ get { return super;} }
2207 public Builder() {super = new _PBJ_Internal.Vector3fProperty.Builder();}
2208 public Builder(_PBJ_Internal.Vector3fProperty.Builder other) {
2209 super=other;
2210 }
2211 public Builder Clone() {return new Builder(super.Clone());}
2212 public Builder MergeFrom(Vector3fProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
2213 public Builder Clear() {super.Clear();return this;}
2214 public Vector3fProperty BuildPartial() {return new Vector3fProperty(super.BuildPartial());}
2215 public Vector3fProperty Build() {if (_HasAllPBJFields) return new Vector3fProperty(super.Build());return null;}
2216 public pbd::MessageDescriptor DescriptorForType {
2217 get { return Vector3fProperty.Descriptor; } }
2218 public Builder ClearValue() { super.ClearValue();return this;}
2219 public const int ValueFieldTag=10;
2220 public bool HasValue{ get {return super.ValueCount>=3;} }
2221 public PBJ.Vector3f Value{ get {
2222 int index=0;
2223 if (HasValue) {
2224 return PBJ._PBJ.CastVector3f(super.GetValue(index*3+0),super.GetValue(index*3+1),super.GetValue(index*3+2));
2225 } else {
2226 return PBJ._PBJ.CastVector3f();
2227 }
2228 }
2229 set {
2230 super.ClearValue();
2231 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
2232 super.AddValue(_PBJtempArray[0]);
2233 super.AddValue(_PBJtempArray[1]);
2234 super.AddValue(_PBJtempArray[2]);
2235 }
2236 }
2237 }
2238 }
2239}
2240namespace Sirikata.Protocol {
2241 public class StringProperty : PBJ.IMessage {
2242 protected _PBJ_Internal.StringProperty super;
2243 public _PBJ_Internal.StringProperty _PBJSuper{ get { return super;} }
2244 public StringProperty() {
2245 super=new _PBJ_Internal.StringProperty();
2246 }
2247 public StringProperty(_PBJ_Internal.StringProperty reference) {
2248 super=reference;
2249 }
2250 public static StringProperty defaultInstance= new StringProperty (_PBJ_Internal.StringProperty.DefaultInstance);
2251 public static StringProperty DefaultInstance{
2252 get {return defaultInstance;}
2253 }
2254 public static pbd.MessageDescriptor Descriptor {
2255 get { return _PBJ_Internal.StringProperty.Descriptor; } }
2256 public static class Types {
2257 }
2258 public static bool WithinReservedFieldTagRange(int field_tag) {
2259 return false;
2260 }
2261 public static bool WithinExtensionFieldTagRange(int field_tag) {
2262 return false;
2263 }
2264 public const int ValueFieldTag=10;
2265 public bool HasValue{ get {return super.HasValue&&PBJ._PBJ.ValidateString(super.Value);} }
2266 public string Value{ get {
2267 if (HasValue) {
2268 return PBJ._PBJ.CastString(super.Value);
2269 } else {
2270 return PBJ._PBJ.CastString();
2271 }
2272 }
2273 }
2274 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
2275 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
2276 public static Builder CreateBuilder() { return new Builder(); }
2277 public static Builder CreateBuilder(StringProperty prototype) {
2278 return (Builder)new Builder().MergeFrom(prototype);
2279 }
2280 public static StringProperty ParseFrom(pb::ByteString data) {
2281 return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data));
2282 }
2283 public static StringProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
2284 return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data,er));
2285 }
2286 public static StringProperty ParseFrom(byte[] data) {
2287 return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data));
2288 }
2289 public static StringProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) {
2290 return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data,er));
2291 }
2292 public static StringProperty ParseFrom(global::System.IO.Stream data) {
2293 return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data));
2294 }
2295 public static StringProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
2296 return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data,er));
2297 }
2298 public static StringProperty ParseFrom(pb::CodedInputStream data) {
2299 return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data));
2300 }
2301 public static StringProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
2302 return new StringProperty(_PBJ_Internal.StringProperty.ParseFrom(data,er));
2303 }
2304 protected override bool _HasAllPBJFields{ get {
2305 return true
2306 ;
2307 } }
2308 public bool IsInitialized { get {
2309 return super.IsInitialized&&_HasAllPBJFields;
2310 } }
2311 public class Builder : global::PBJ.IMessage.IBuilder{
2312 protected override bool _HasAllPBJFields{ get {
2313 return true
2314 ;
2315 } }
2316 public bool IsInitialized { get {
2317 return super.IsInitialized&&_HasAllPBJFields;
2318 } }
2319 protected _PBJ_Internal.StringProperty.Builder super;
2320 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
2321 public _PBJ_Internal.StringProperty.Builder _PBJSuper{ get { return super;} }
2322 public Builder() {super = new _PBJ_Internal.StringProperty.Builder();}
2323 public Builder(_PBJ_Internal.StringProperty.Builder other) {
2324 super=other;
2325 }
2326 public Builder Clone() {return new Builder(super.Clone());}
2327 public Builder MergeFrom(StringProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
2328 public Builder Clear() {super.Clear();return this;}
2329 public StringProperty BuildPartial() {return new StringProperty(super.BuildPartial());}
2330 public StringProperty Build() {if (_HasAllPBJFields) return new StringProperty(super.Build());return null;}
2331 public pbd::MessageDescriptor DescriptorForType {
2332 get { return StringProperty.Descriptor; } }
2333 public Builder ClearValue() { super.ClearValue();return this;}
2334 public const int ValueFieldTag=10;
2335 public bool HasValue{ get {return super.HasValue&&PBJ._PBJ.ValidateString(super.Value);} }
2336 public string Value{ get {
2337 if (HasValue) {
2338 return PBJ._PBJ.CastString(super.Value);
2339 } else {
2340 return PBJ._PBJ.CastString();
2341 }
2342 }
2343 set {
2344 super.Value=(PBJ._PBJ.Construct(value));
2345 }
2346 }
2347 }
2348 }
2349}
2350namespace Sirikata.Protocol {
2351 public class StringMapProperty : PBJ.IMessage {
2352 protected _PBJ_Internal.StringMapProperty super;
2353 public _PBJ_Internal.StringMapProperty _PBJSuper{ get { return super;} }
2354 public StringMapProperty() {
2355 super=new _PBJ_Internal.StringMapProperty();
2356 }
2357 public StringMapProperty(_PBJ_Internal.StringMapProperty reference) {
2358 super=reference;
2359 }
2360 public static StringMapProperty defaultInstance= new StringMapProperty (_PBJ_Internal.StringMapProperty.DefaultInstance);
2361 public static StringMapProperty DefaultInstance{
2362 get {return defaultInstance;}
2363 }
2364 public static pbd.MessageDescriptor Descriptor {
2365 get { return _PBJ_Internal.StringMapProperty.Descriptor; } }
2366 public static class Types {
2367 }
2368 public static bool WithinReservedFieldTagRange(int field_tag) {
2369 return false;
2370 }
2371 public static bool WithinExtensionFieldTagRange(int field_tag) {
2372 return false;
2373 }
2374 public const int KeysFieldTag=2;
2375 public int KeysCount { get { return super.KeysCount;} }
2376 public bool HasKeys(int index) {return PBJ._PBJ.ValidateString(super.GetKeys(index));}
2377 public string Keys(int index) {
2378 return (string)PBJ._PBJ.CastString(super.GetKeys(index));
2379 }
2380 public const int ValuesFieldTag=3;
2381 public int ValuesCount { get { return super.ValuesCount;} }
2382 public bool HasValues(int index) {return PBJ._PBJ.ValidateString(super.GetValues(index));}
2383 public string Values(int index) {
2384 return (string)PBJ._PBJ.CastString(super.GetValues(index));
2385 }
2386 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
2387 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
2388 public static Builder CreateBuilder() { return new Builder(); }
2389 public static Builder CreateBuilder(StringMapProperty prototype) {
2390 return (Builder)new Builder().MergeFrom(prototype);
2391 }
2392 public static StringMapProperty ParseFrom(pb::ByteString data) {
2393 return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data));
2394 }
2395 public static StringMapProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
2396 return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data,er));
2397 }
2398 public static StringMapProperty ParseFrom(byte[] data) {
2399 return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data));
2400 }
2401 public static StringMapProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) {
2402 return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data,er));
2403 }
2404 public static StringMapProperty ParseFrom(global::System.IO.Stream data) {
2405 return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data));
2406 }
2407 public static StringMapProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
2408 return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data,er));
2409 }
2410 public static StringMapProperty ParseFrom(pb::CodedInputStream data) {
2411 return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data));
2412 }
2413 public static StringMapProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
2414 return new StringMapProperty(_PBJ_Internal.StringMapProperty.ParseFrom(data,er));
2415 }
2416 protected override bool _HasAllPBJFields{ get {
2417 return true
2418 ;
2419 } }
2420 public bool IsInitialized { get {
2421 return super.IsInitialized&&_HasAllPBJFields;
2422 } }
2423 public class Builder : global::PBJ.IMessage.IBuilder{
2424 protected override bool _HasAllPBJFields{ get {
2425 return true
2426 ;
2427 } }
2428 public bool IsInitialized { get {
2429 return super.IsInitialized&&_HasAllPBJFields;
2430 } }
2431 protected _PBJ_Internal.StringMapProperty.Builder super;
2432 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
2433 public _PBJ_Internal.StringMapProperty.Builder _PBJSuper{ get { return super;} }
2434 public Builder() {super = new _PBJ_Internal.StringMapProperty.Builder();}
2435 public Builder(_PBJ_Internal.StringMapProperty.Builder other) {
2436 super=other;
2437 }
2438 public Builder Clone() {return new Builder(super.Clone());}
2439 public Builder MergeFrom(StringMapProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
2440 public Builder Clear() {super.Clear();return this;}
2441 public StringMapProperty BuildPartial() {return new StringMapProperty(super.BuildPartial());}
2442 public StringMapProperty Build() {if (_HasAllPBJFields) return new StringMapProperty(super.Build());return null;}
2443 public pbd::MessageDescriptor DescriptorForType {
2444 get { return StringMapProperty.Descriptor; } }
2445 public Builder ClearKeys() { super.ClearKeys();return this;}
2446 public Builder SetKeys(int index, string value) {
2447 super.SetKeys(index,PBJ._PBJ.Construct(value));
2448 return this;
2449 }
2450 public const int KeysFieldTag=2;
2451 public int KeysCount { get { return super.KeysCount;} }
2452 public bool HasKeys(int index) {return PBJ._PBJ.ValidateString(super.GetKeys(index));}
2453 public string Keys(int index) {
2454 return (string)PBJ._PBJ.CastString(super.GetKeys(index));
2455 }
2456 public Builder AddKeys(string value) {
2457 super.AddKeys(PBJ._PBJ.Construct(value));
2458 return this;
2459 }
2460 public Builder ClearValues() { super.ClearValues();return this;}
2461 public Builder SetValues(int index, string value) {
2462 super.SetValues(index,PBJ._PBJ.Construct(value));
2463 return this;
2464 }
2465 public const int ValuesFieldTag=3;
2466 public int ValuesCount { get { return super.ValuesCount;} }
2467 public bool HasValues(int index) {return PBJ._PBJ.ValidateString(super.GetValues(index));}
2468 public string Values(int index) {
2469 return (string)PBJ._PBJ.CastString(super.GetValues(index));
2470 }
2471 public Builder AddValues(string value) {
2472 super.AddValues(PBJ._PBJ.Construct(value));
2473 return this;
2474 }
2475 }
2476 }
2477}
2478namespace Sirikata.Protocol {
2479 public class PhysicalParameters : PBJ.IMessage {
2480 protected _PBJ_Internal.PhysicalParameters super;
2481 public _PBJ_Internal.PhysicalParameters _PBJSuper{ get { return super;} }
2482 public PhysicalParameters() {
2483 super=new _PBJ_Internal.PhysicalParameters();
2484 }
2485 public PhysicalParameters(_PBJ_Internal.PhysicalParameters reference) {
2486 super=reference;
2487 }
2488 public static PhysicalParameters defaultInstance= new PhysicalParameters (_PBJ_Internal.PhysicalParameters.DefaultInstance);
2489 public static PhysicalParameters DefaultInstance{
2490 get {return defaultInstance;}
2491 }
2492 public static pbd.MessageDescriptor Descriptor {
2493 get { return _PBJ_Internal.PhysicalParameters.Descriptor; } }
2494 public static class Types {
2495 public enum Mode {
2496 NONPHYSICAL=_PBJ_Internal.PhysicalParameters.Types.Mode.NONPHYSICAL,
2497 STATIC=_PBJ_Internal.PhysicalParameters.Types.Mode.STATIC,
2498 DYNAMICBOX=_PBJ_Internal.PhysicalParameters.Types.Mode.DYNAMICBOX,
2499 DYNAMICSPHERE=_PBJ_Internal.PhysicalParameters.Types.Mode.DYNAMICSPHERE,
2500 DYNAMICCYLINDER=_PBJ_Internal.PhysicalParameters.Types.Mode.DYNAMICCYLINDER,
2501 CHARACTER=_PBJ_Internal.PhysicalParameters.Types.Mode.CHARACTER
2502 };
2503 }
2504 public static bool WithinReservedFieldTagRange(int field_tag) {
2505 return false;
2506 }
2507 public static bool WithinExtensionFieldTagRange(int field_tag) {
2508 return false;
2509 }
2510 public const int ModeFieldTag=2;
2511 public bool HasMode{ get {return super.HasMode;} }
2512 public Types.Mode Mode{ get {
2513 if (HasMode) {
2514 return (Types.Mode)super.Mode;
2515 } else {
2516 return new Types.Mode();
2517 }
2518 }
2519 }
2520 public const int DensityFieldTag=3;
2521 public bool HasDensity{ get {return super.HasDensity&&PBJ._PBJ.ValidateFloat(super.Density);} }
2522 public float Density{ get {
2523 if (HasDensity) {
2524 return PBJ._PBJ.CastFloat(super.Density);
2525 } else {
2526 return PBJ._PBJ.CastFloat();
2527 }
2528 }
2529 }
2530 public const int FrictionFieldTag=4;
2531 public bool HasFriction{ get {return super.HasFriction&&PBJ._PBJ.ValidateFloat(super.Friction);} }
2532 public float Friction{ get {
2533 if (HasFriction) {
2534 return PBJ._PBJ.CastFloat(super.Friction);
2535 } else {
2536 return PBJ._PBJ.CastFloat();
2537 }
2538 }
2539 }
2540 public const int BounceFieldTag=5;
2541 public bool HasBounce{ get {return super.HasBounce&&PBJ._PBJ.ValidateFloat(super.Bounce);} }
2542 public float Bounce{ get {
2543 if (HasBounce) {
2544 return PBJ._PBJ.CastFloat(super.Bounce);
2545 } else {
2546 return PBJ._PBJ.CastFloat();
2547 }
2548 }
2549 }
2550 public const int HullFieldTag=6;
2551 public bool HasHull{ get {return super.HullCount>=3;} }
2552 public PBJ.Vector3f Hull{ get {
2553 int index=0;
2554 if (HasHull) {
2555 return PBJ._PBJ.CastVector3f(super.GetHull(index*3+0),super.GetHull(index*3+1),super.GetHull(index*3+2));
2556 } else {
2557 return PBJ._PBJ.CastVector3f();
2558 }
2559 }
2560 }
2561 public const int CollideMsgFieldTag=16;
2562 public bool HasCollideMsg{ get {return super.HasCollideMsg&&PBJ._PBJ.ValidateUint32(super.CollideMsg);} }
2563 public uint CollideMsg{ get {
2564 if (HasCollideMsg) {
2565 return PBJ._PBJ.CastUint32(super.CollideMsg);
2566 } else {
2567 return PBJ._PBJ.CastUint32();
2568 }
2569 }
2570 }
2571 public const int CollideMaskFieldTag=17;
2572 public bool HasCollideMask{ get {return super.HasCollideMask&&PBJ._PBJ.ValidateUint32(super.CollideMask);} }
2573 public uint CollideMask{ get {
2574 if (HasCollideMask) {
2575 return PBJ._PBJ.CastUint32(super.CollideMask);
2576 } else {
2577 return PBJ._PBJ.CastUint32();
2578 }
2579 }
2580 }
2581 public const int GravityFieldTag=18;
2582 public bool HasGravity{ get {return super.HasGravity&&PBJ._PBJ.ValidateFloat(super.Gravity);} }
2583 public float Gravity{ get {
2584 if (HasGravity) {
2585 return PBJ._PBJ.CastFloat(super.Gravity);
2586 } else {
2587 return PBJ._PBJ.CastFloat();
2588 }
2589 }
2590 }
2591 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
2592 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
2593 public static Builder CreateBuilder() { return new Builder(); }
2594 public static Builder CreateBuilder(PhysicalParameters prototype) {
2595 return (Builder)new Builder().MergeFrom(prototype);
2596 }
2597 public static PhysicalParameters ParseFrom(pb::ByteString data) {
2598 return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data));
2599 }
2600 public static PhysicalParameters ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
2601 return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data,er));
2602 }
2603 public static PhysicalParameters ParseFrom(byte[] data) {
2604 return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data));
2605 }
2606 public static PhysicalParameters ParseFrom(byte[] data, pb::ExtensionRegistry er) {
2607 return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data,er));
2608 }
2609 public static PhysicalParameters ParseFrom(global::System.IO.Stream data) {
2610 return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data));
2611 }
2612 public static PhysicalParameters ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
2613 return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data,er));
2614 }
2615 public static PhysicalParameters ParseFrom(pb::CodedInputStream data) {
2616 return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data));
2617 }
2618 public static PhysicalParameters ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
2619 return new PhysicalParameters(_PBJ_Internal.PhysicalParameters.ParseFrom(data,er));
2620 }
2621 protected override bool _HasAllPBJFields{ get {
2622 return true
2623 ;
2624 } }
2625 public bool IsInitialized { get {
2626 return super.IsInitialized&&_HasAllPBJFields;
2627 } }
2628 public class Builder : global::PBJ.IMessage.IBuilder{
2629 protected override bool _HasAllPBJFields{ get {
2630 return true
2631 ;
2632 } }
2633 public bool IsInitialized { get {
2634 return super.IsInitialized&&_HasAllPBJFields;
2635 } }
2636 protected _PBJ_Internal.PhysicalParameters.Builder super;
2637 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
2638 public _PBJ_Internal.PhysicalParameters.Builder _PBJSuper{ get { return super;} }
2639 public Builder() {super = new _PBJ_Internal.PhysicalParameters.Builder();}
2640 public Builder(_PBJ_Internal.PhysicalParameters.Builder other) {
2641 super=other;
2642 }
2643 public Builder Clone() {return new Builder(super.Clone());}
2644 public Builder MergeFrom(PhysicalParameters prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
2645 public Builder Clear() {super.Clear();return this;}
2646 public PhysicalParameters BuildPartial() {return new PhysicalParameters(super.BuildPartial());}
2647 public PhysicalParameters Build() {if (_HasAllPBJFields) return new PhysicalParameters(super.Build());return null;}
2648 public pbd::MessageDescriptor DescriptorForType {
2649 get { return PhysicalParameters.Descriptor; } }
2650 public Builder ClearMode() { super.ClearMode();return this;}
2651 public const int ModeFieldTag=2;
2652 public bool HasMode{ get {return super.HasMode;} }
2653 public Types.Mode Mode{ get {
2654 if (HasMode) {
2655 return (Types.Mode)super.Mode;
2656 } else {
2657 return new Types.Mode();
2658 }
2659 }
2660 set {
2661 super.Mode=((_PBJ_Internal.PhysicalParameters.Types.Mode)value);
2662 }
2663 }
2664 public Builder ClearDensity() { super.ClearDensity();return this;}
2665 public const int DensityFieldTag=3;
2666 public bool HasDensity{ get {return super.HasDensity&&PBJ._PBJ.ValidateFloat(super.Density);} }
2667 public float Density{ get {
2668 if (HasDensity) {
2669 return PBJ._PBJ.CastFloat(super.Density);
2670 } else {
2671 return PBJ._PBJ.CastFloat();
2672 }
2673 }
2674 set {
2675 super.Density=(PBJ._PBJ.Construct(value));
2676 }
2677 }
2678 public Builder ClearFriction() { super.ClearFriction();return this;}
2679 public const int FrictionFieldTag=4;
2680 public bool HasFriction{ get {return super.HasFriction&&PBJ._PBJ.ValidateFloat(super.Friction);} }
2681 public float Friction{ get {
2682 if (HasFriction) {
2683 return PBJ._PBJ.CastFloat(super.Friction);
2684 } else {
2685 return PBJ._PBJ.CastFloat();
2686 }
2687 }
2688 set {
2689 super.Friction=(PBJ._PBJ.Construct(value));
2690 }
2691 }
2692 public Builder ClearBounce() { super.ClearBounce();return this;}
2693 public const int BounceFieldTag=5;
2694 public bool HasBounce{ get {return super.HasBounce&&PBJ._PBJ.ValidateFloat(super.Bounce);} }
2695 public float Bounce{ get {
2696 if (HasBounce) {
2697 return PBJ._PBJ.CastFloat(super.Bounce);
2698 } else {
2699 return PBJ._PBJ.CastFloat();
2700 }
2701 }
2702 set {
2703 super.Bounce=(PBJ._PBJ.Construct(value));
2704 }
2705 }
2706 public Builder ClearHull() { super.ClearHull();return this;}
2707 public const int HullFieldTag=6;
2708 public bool HasHull{ get {return super.HullCount>=3;} }
2709 public PBJ.Vector3f Hull{ get {
2710 int index=0;
2711 if (HasHull) {
2712 return PBJ._PBJ.CastVector3f(super.GetHull(index*3+0),super.GetHull(index*3+1),super.GetHull(index*3+2));
2713 } else {
2714 return PBJ._PBJ.CastVector3f();
2715 }
2716 }
2717 set {
2718 super.ClearHull();
2719 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
2720 super.AddHull(_PBJtempArray[0]);
2721 super.AddHull(_PBJtempArray[1]);
2722 super.AddHull(_PBJtempArray[2]);
2723 }
2724 }
2725 public Builder ClearCollideMsg() { super.ClearCollideMsg();return this;}
2726 public const int CollideMsgFieldTag=16;
2727 public bool HasCollideMsg{ get {return super.HasCollideMsg&&PBJ._PBJ.ValidateUint32(super.CollideMsg);} }
2728 public uint CollideMsg{ get {
2729 if (HasCollideMsg) {
2730 return PBJ._PBJ.CastUint32(super.CollideMsg);
2731 } else {
2732 return PBJ._PBJ.CastUint32();
2733 }
2734 }
2735 set {
2736 super.CollideMsg=(PBJ._PBJ.Construct(value));
2737 }
2738 }
2739 public Builder ClearCollideMask() { super.ClearCollideMask();return this;}
2740 public const int CollideMaskFieldTag=17;
2741 public bool HasCollideMask{ get {return super.HasCollideMask&&PBJ._PBJ.ValidateUint32(super.CollideMask);} }
2742 public uint CollideMask{ get {
2743 if (HasCollideMask) {
2744 return PBJ._PBJ.CastUint32(super.CollideMask);
2745 } else {
2746 return PBJ._PBJ.CastUint32();
2747 }
2748 }
2749 set {
2750 super.CollideMask=(PBJ._PBJ.Construct(value));
2751 }
2752 }
2753 public Builder ClearGravity() { super.ClearGravity();return this;}
2754 public const int GravityFieldTag=18;
2755 public bool HasGravity{ get {return super.HasGravity&&PBJ._PBJ.ValidateFloat(super.Gravity);} }
2756 public float Gravity{ get {
2757 if (HasGravity) {
2758 return PBJ._PBJ.CastFloat(super.Gravity);
2759 } else {
2760 return PBJ._PBJ.CastFloat();
2761 }
2762 }
2763 set {
2764 super.Gravity=(PBJ._PBJ.Construct(value));
2765 }
2766 }
2767 }
2768 }
2769}
2770namespace Sirikata.Protocol {
2771 public class LightInfoProperty : PBJ.IMessage {
2772 protected _PBJ_Internal.LightInfoProperty super;
2773 public _PBJ_Internal.LightInfoProperty _PBJSuper{ get { return super;} }
2774 public LightInfoProperty() {
2775 super=new _PBJ_Internal.LightInfoProperty();
2776 }
2777 public LightInfoProperty(_PBJ_Internal.LightInfoProperty reference) {
2778 super=reference;
2779 }
2780 public static LightInfoProperty defaultInstance= new LightInfoProperty (_PBJ_Internal.LightInfoProperty.DefaultInstance);
2781 public static LightInfoProperty DefaultInstance{
2782 get {return defaultInstance;}
2783 }
2784 public static pbd.MessageDescriptor Descriptor {
2785 get { return _PBJ_Internal.LightInfoProperty.Descriptor; } }
2786 public static class Types {
2787 public enum LightTypes {
2788 POINT=_PBJ_Internal.LightInfoProperty.Types.LightTypes.POINT,
2789 SPOTLIGHT=_PBJ_Internal.LightInfoProperty.Types.LightTypes.SPOTLIGHT,
2790 DIRECTIONAL=_PBJ_Internal.LightInfoProperty.Types.LightTypes.DIRECTIONAL
2791 };
2792 }
2793 public static bool WithinReservedFieldTagRange(int field_tag) {
2794 return false;
2795 }
2796 public static bool WithinExtensionFieldTagRange(int field_tag) {
2797 return false;
2798 }
2799 public const int DiffuseColorFieldTag=3;
2800 public bool HasDiffuseColor{ get {return super.DiffuseColorCount>=3;} }
2801 public PBJ.Vector3f DiffuseColor{ get {
2802 int index=0;
2803 if (HasDiffuseColor) {
2804 return PBJ._PBJ.CastVector3f(super.GetDiffuseColor(index*3+0),super.GetDiffuseColor(index*3+1),super.GetDiffuseColor(index*3+2));
2805 } else {
2806 return PBJ._PBJ.CastVector3f();
2807 }
2808 }
2809 }
2810 public const int SpecularColorFieldTag=4;
2811 public bool HasSpecularColor{ get {return super.SpecularColorCount>=3;} }
2812 public PBJ.Vector3f SpecularColor{ get {
2813 int index=0;
2814 if (HasSpecularColor) {
2815 return PBJ._PBJ.CastVector3f(super.GetSpecularColor(index*3+0),super.GetSpecularColor(index*3+1),super.GetSpecularColor(index*3+2));
2816 } else {
2817 return PBJ._PBJ.CastVector3f();
2818 }
2819 }
2820 }
2821 public const int PowerFieldTag=5;
2822 public bool HasPower{ get {return super.HasPower&&PBJ._PBJ.ValidateFloat(super.Power);} }
2823 public float Power{ get {
2824 if (HasPower) {
2825 return PBJ._PBJ.CastFloat(super.Power);
2826 } else {
2827 return PBJ._PBJ.CastFloat();
2828 }
2829 }
2830 }
2831 public const int AmbientColorFieldTag=6;
2832 public bool HasAmbientColor{ get {return super.AmbientColorCount>=3;} }
2833 public PBJ.Vector3f AmbientColor{ get {
2834 int index=0;
2835 if (HasAmbientColor) {
2836 return PBJ._PBJ.CastVector3f(super.GetAmbientColor(index*3+0),super.GetAmbientColor(index*3+1),super.GetAmbientColor(index*3+2));
2837 } else {
2838 return PBJ._PBJ.CastVector3f();
2839 }
2840 }
2841 }
2842 public const int ShadowColorFieldTag=7;
2843 public bool HasShadowColor{ get {return super.ShadowColorCount>=3;} }
2844 public PBJ.Vector3f ShadowColor{ get {
2845 int index=0;
2846 if (HasShadowColor) {
2847 return PBJ._PBJ.CastVector3f(super.GetShadowColor(index*3+0),super.GetShadowColor(index*3+1),super.GetShadowColor(index*3+2));
2848 } else {
2849 return PBJ._PBJ.CastVector3f();
2850 }
2851 }
2852 }
2853 public const int LightRangeFieldTag=8;
2854 public bool HasLightRange{ get {return super.HasLightRange&&PBJ._PBJ.ValidateDouble(super.LightRange);} }
2855 public double LightRange{ get {
2856 if (HasLightRange) {
2857 return PBJ._PBJ.CastDouble(super.LightRange);
2858 } else {
2859 return PBJ._PBJ.CastDouble();
2860 }
2861 }
2862 }
2863 public const int ConstantFalloffFieldTag=9;
2864 public bool HasConstantFalloff{ get {return super.HasConstantFalloff&&PBJ._PBJ.ValidateFloat(super.ConstantFalloff);} }
2865 public float ConstantFalloff{ get {
2866 if (HasConstantFalloff) {
2867 return PBJ._PBJ.CastFloat(super.ConstantFalloff);
2868 } else {
2869 return PBJ._PBJ.CastFloat();
2870 }
2871 }
2872 }
2873 public const int LinearFalloffFieldTag=10;
2874 public bool HasLinearFalloff{ get {return super.HasLinearFalloff&&PBJ._PBJ.ValidateFloat(super.LinearFalloff);} }
2875 public float LinearFalloff{ get {
2876 if (HasLinearFalloff) {
2877 return PBJ._PBJ.CastFloat(super.LinearFalloff);
2878 } else {
2879 return PBJ._PBJ.CastFloat();
2880 }
2881 }
2882 }
2883 public const int QuadraticFalloffFieldTag=11;
2884 public bool HasQuadraticFalloff{ get {return super.HasQuadraticFalloff&&PBJ._PBJ.ValidateFloat(super.QuadraticFalloff);} }
2885 public float QuadraticFalloff{ get {
2886 if (HasQuadraticFalloff) {
2887 return PBJ._PBJ.CastFloat(super.QuadraticFalloff);
2888 } else {
2889 return PBJ._PBJ.CastFloat();
2890 }
2891 }
2892 }
2893 public const int ConeInnerRadiansFieldTag=12;
2894 public bool HasConeInnerRadians{ get {return super.HasConeInnerRadians&&PBJ._PBJ.ValidateFloat(super.ConeInnerRadians);} }
2895 public float ConeInnerRadians{ get {
2896 if (HasConeInnerRadians) {
2897 return PBJ._PBJ.CastFloat(super.ConeInnerRadians);
2898 } else {
2899 return PBJ._PBJ.CastFloat();
2900 }
2901 }
2902 }
2903 public const int ConeOuterRadiansFieldTag=13;
2904 public bool HasConeOuterRadians{ get {return super.HasConeOuterRadians&&PBJ._PBJ.ValidateFloat(super.ConeOuterRadians);} }
2905 public float ConeOuterRadians{ get {
2906 if (HasConeOuterRadians) {
2907 return PBJ._PBJ.CastFloat(super.ConeOuterRadians);
2908 } else {
2909 return PBJ._PBJ.CastFloat();
2910 }
2911 }
2912 }
2913 public const int ConeFalloffFieldTag=14;
2914 public bool HasConeFalloff{ get {return super.HasConeFalloff&&PBJ._PBJ.ValidateFloat(super.ConeFalloff);} }
2915 public float ConeFalloff{ get {
2916 if (HasConeFalloff) {
2917 return PBJ._PBJ.CastFloat(super.ConeFalloff);
2918 } else {
2919 return PBJ._PBJ.CastFloat();
2920 }
2921 }
2922 }
2923 public const int TypeFieldTag=15;
2924 public bool HasType{ get {return super.HasType;} }
2925 public Types.LightTypes Type{ get {
2926 if (HasType) {
2927 return (Types.LightTypes)super.Type;
2928 } else {
2929 return new Types.LightTypes();
2930 }
2931 }
2932 }
2933 public const int CastsShadowFieldTag=16;
2934 public bool HasCastsShadow{ get {return super.HasCastsShadow&&PBJ._PBJ.ValidateBool(super.CastsShadow);} }
2935 public bool CastsShadow{ get {
2936 if (HasCastsShadow) {
2937 return PBJ._PBJ.CastBool(super.CastsShadow);
2938 } else {
2939 return PBJ._PBJ.CastBool();
2940 }
2941 }
2942 }
2943 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
2944 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
2945 public static Builder CreateBuilder() { return new Builder(); }
2946 public static Builder CreateBuilder(LightInfoProperty prototype) {
2947 return (Builder)new Builder().MergeFrom(prototype);
2948 }
2949 public static LightInfoProperty ParseFrom(pb::ByteString data) {
2950 return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data));
2951 }
2952 public static LightInfoProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
2953 return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data,er));
2954 }
2955 public static LightInfoProperty ParseFrom(byte[] data) {
2956 return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data));
2957 }
2958 public static LightInfoProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) {
2959 return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data,er));
2960 }
2961 public static LightInfoProperty ParseFrom(global::System.IO.Stream data) {
2962 return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data));
2963 }
2964 public static LightInfoProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
2965 return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data,er));
2966 }
2967 public static LightInfoProperty ParseFrom(pb::CodedInputStream data) {
2968 return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data));
2969 }
2970 public static LightInfoProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
2971 return new LightInfoProperty(_PBJ_Internal.LightInfoProperty.ParseFrom(data,er));
2972 }
2973 protected override bool _HasAllPBJFields{ get {
2974 return true
2975 ;
2976 } }
2977 public bool IsInitialized { get {
2978 return super.IsInitialized&&_HasAllPBJFields;
2979 } }
2980 public class Builder : global::PBJ.IMessage.IBuilder{
2981 protected override bool _HasAllPBJFields{ get {
2982 return true
2983 ;
2984 } }
2985 public bool IsInitialized { get {
2986 return super.IsInitialized&&_HasAllPBJFields;
2987 } }
2988 protected _PBJ_Internal.LightInfoProperty.Builder super;
2989 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
2990 public _PBJ_Internal.LightInfoProperty.Builder _PBJSuper{ get { return super;} }
2991 public Builder() {super = new _PBJ_Internal.LightInfoProperty.Builder();}
2992 public Builder(_PBJ_Internal.LightInfoProperty.Builder other) {
2993 super=other;
2994 }
2995 public Builder Clone() {return new Builder(super.Clone());}
2996 public Builder MergeFrom(LightInfoProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
2997 public Builder Clear() {super.Clear();return this;}
2998 public LightInfoProperty BuildPartial() {return new LightInfoProperty(super.BuildPartial());}
2999 public LightInfoProperty Build() {if (_HasAllPBJFields) return new LightInfoProperty(super.Build());return null;}
3000 public pbd::MessageDescriptor DescriptorForType {
3001 get { return LightInfoProperty.Descriptor; } }
3002 public Builder ClearDiffuseColor() { super.ClearDiffuseColor();return this;}
3003 public const int DiffuseColorFieldTag=3;
3004 public bool HasDiffuseColor{ get {return super.DiffuseColorCount>=3;} }
3005 public PBJ.Vector3f DiffuseColor{ get {
3006 int index=0;
3007 if (HasDiffuseColor) {
3008 return PBJ._PBJ.CastVector3f(super.GetDiffuseColor(index*3+0),super.GetDiffuseColor(index*3+1),super.GetDiffuseColor(index*3+2));
3009 } else {
3010 return PBJ._PBJ.CastVector3f();
3011 }
3012 }
3013 set {
3014 super.ClearDiffuseColor();
3015 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
3016 super.AddDiffuseColor(_PBJtempArray[0]);
3017 super.AddDiffuseColor(_PBJtempArray[1]);
3018 super.AddDiffuseColor(_PBJtempArray[2]);
3019 }
3020 }
3021 public Builder ClearSpecularColor() { super.ClearSpecularColor();return this;}
3022 public const int SpecularColorFieldTag=4;
3023 public bool HasSpecularColor{ get {return super.SpecularColorCount>=3;} }
3024 public PBJ.Vector3f SpecularColor{ get {
3025 int index=0;
3026 if (HasSpecularColor) {
3027 return PBJ._PBJ.CastVector3f(super.GetSpecularColor(index*3+0),super.GetSpecularColor(index*3+1),super.GetSpecularColor(index*3+2));
3028 } else {
3029 return PBJ._PBJ.CastVector3f();
3030 }
3031 }
3032 set {
3033 super.ClearSpecularColor();
3034 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
3035 super.AddSpecularColor(_PBJtempArray[0]);
3036 super.AddSpecularColor(_PBJtempArray[1]);
3037 super.AddSpecularColor(_PBJtempArray[2]);
3038 }
3039 }
3040 public Builder ClearPower() { super.ClearPower();return this;}
3041 public const int PowerFieldTag=5;
3042 public bool HasPower{ get {return super.HasPower&&PBJ._PBJ.ValidateFloat(super.Power);} }
3043 public float Power{ get {
3044 if (HasPower) {
3045 return PBJ._PBJ.CastFloat(super.Power);
3046 } else {
3047 return PBJ._PBJ.CastFloat();
3048 }
3049 }
3050 set {
3051 super.Power=(PBJ._PBJ.Construct(value));
3052 }
3053 }
3054 public Builder ClearAmbientColor() { super.ClearAmbientColor();return this;}
3055 public const int AmbientColorFieldTag=6;
3056 public bool HasAmbientColor{ get {return super.AmbientColorCount>=3;} }
3057 public PBJ.Vector3f AmbientColor{ get {
3058 int index=0;
3059 if (HasAmbientColor) {
3060 return PBJ._PBJ.CastVector3f(super.GetAmbientColor(index*3+0),super.GetAmbientColor(index*3+1),super.GetAmbientColor(index*3+2));
3061 } else {
3062 return PBJ._PBJ.CastVector3f();
3063 }
3064 }
3065 set {
3066 super.ClearAmbientColor();
3067 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
3068 super.AddAmbientColor(_PBJtempArray[0]);
3069 super.AddAmbientColor(_PBJtempArray[1]);
3070 super.AddAmbientColor(_PBJtempArray[2]);
3071 }
3072 }
3073 public Builder ClearShadowColor() { super.ClearShadowColor();return this;}
3074 public const int ShadowColorFieldTag=7;
3075 public bool HasShadowColor{ get {return super.ShadowColorCount>=3;} }
3076 public PBJ.Vector3f ShadowColor{ get {
3077 int index=0;
3078 if (HasShadowColor) {
3079 return PBJ._PBJ.CastVector3f(super.GetShadowColor(index*3+0),super.GetShadowColor(index*3+1),super.GetShadowColor(index*3+2));
3080 } else {
3081 return PBJ._PBJ.CastVector3f();
3082 }
3083 }
3084 set {
3085 super.ClearShadowColor();
3086 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
3087 super.AddShadowColor(_PBJtempArray[0]);
3088 super.AddShadowColor(_PBJtempArray[1]);
3089 super.AddShadowColor(_PBJtempArray[2]);
3090 }
3091 }
3092 public Builder ClearLightRange() { super.ClearLightRange();return this;}
3093 public const int LightRangeFieldTag=8;
3094 public bool HasLightRange{ get {return super.HasLightRange&&PBJ._PBJ.ValidateDouble(super.LightRange);} }
3095 public double LightRange{ get {
3096 if (HasLightRange) {
3097 return PBJ._PBJ.CastDouble(super.LightRange);
3098 } else {
3099 return PBJ._PBJ.CastDouble();
3100 }
3101 }
3102 set {
3103 super.LightRange=(PBJ._PBJ.Construct(value));
3104 }
3105 }
3106 public Builder ClearConstantFalloff() { super.ClearConstantFalloff();return this;}
3107 public const int ConstantFalloffFieldTag=9;
3108 public bool HasConstantFalloff{ get {return super.HasConstantFalloff&&PBJ._PBJ.ValidateFloat(super.ConstantFalloff);} }
3109 public float ConstantFalloff{ get {
3110 if (HasConstantFalloff) {
3111 return PBJ._PBJ.CastFloat(super.ConstantFalloff);
3112 } else {
3113 return PBJ._PBJ.CastFloat();
3114 }
3115 }
3116 set {
3117 super.ConstantFalloff=(PBJ._PBJ.Construct(value));
3118 }
3119 }
3120 public Builder ClearLinearFalloff() { super.ClearLinearFalloff();return this;}
3121 public const int LinearFalloffFieldTag=10;
3122 public bool HasLinearFalloff{ get {return super.HasLinearFalloff&&PBJ._PBJ.ValidateFloat(super.LinearFalloff);} }
3123 public float LinearFalloff{ get {
3124 if (HasLinearFalloff) {
3125 return PBJ._PBJ.CastFloat(super.LinearFalloff);
3126 } else {
3127 return PBJ._PBJ.CastFloat();
3128 }
3129 }
3130 set {
3131 super.LinearFalloff=(PBJ._PBJ.Construct(value));
3132 }
3133 }
3134 public Builder ClearQuadraticFalloff() { super.ClearQuadraticFalloff();return this;}
3135 public const int QuadraticFalloffFieldTag=11;
3136 public bool HasQuadraticFalloff{ get {return super.HasQuadraticFalloff&&PBJ._PBJ.ValidateFloat(super.QuadraticFalloff);} }
3137 public float QuadraticFalloff{ get {
3138 if (HasQuadraticFalloff) {
3139 return PBJ._PBJ.CastFloat(super.QuadraticFalloff);
3140 } else {
3141 return PBJ._PBJ.CastFloat();
3142 }
3143 }
3144 set {
3145 super.QuadraticFalloff=(PBJ._PBJ.Construct(value));
3146 }
3147 }
3148 public Builder ClearConeInnerRadians() { super.ClearConeInnerRadians();return this;}
3149 public const int ConeInnerRadiansFieldTag=12;
3150 public bool HasConeInnerRadians{ get {return super.HasConeInnerRadians&&PBJ._PBJ.ValidateFloat(super.ConeInnerRadians);} }
3151 public float ConeInnerRadians{ get {
3152 if (HasConeInnerRadians) {
3153 return PBJ._PBJ.CastFloat(super.ConeInnerRadians);
3154 } else {
3155 return PBJ._PBJ.CastFloat();
3156 }
3157 }
3158 set {
3159 super.ConeInnerRadians=(PBJ._PBJ.Construct(value));
3160 }
3161 }
3162 public Builder ClearConeOuterRadians() { super.ClearConeOuterRadians();return this;}
3163 public const int ConeOuterRadiansFieldTag=13;
3164 public bool HasConeOuterRadians{ get {return super.HasConeOuterRadians&&PBJ._PBJ.ValidateFloat(super.ConeOuterRadians);} }
3165 public float ConeOuterRadians{ get {
3166 if (HasConeOuterRadians) {
3167 return PBJ._PBJ.CastFloat(super.ConeOuterRadians);
3168 } else {
3169 return PBJ._PBJ.CastFloat();
3170 }
3171 }
3172 set {
3173 super.ConeOuterRadians=(PBJ._PBJ.Construct(value));
3174 }
3175 }
3176 public Builder ClearConeFalloff() { super.ClearConeFalloff();return this;}
3177 public const int ConeFalloffFieldTag=14;
3178 public bool HasConeFalloff{ get {return super.HasConeFalloff&&PBJ._PBJ.ValidateFloat(super.ConeFalloff);} }
3179 public float ConeFalloff{ get {
3180 if (HasConeFalloff) {
3181 return PBJ._PBJ.CastFloat(super.ConeFalloff);
3182 } else {
3183 return PBJ._PBJ.CastFloat();
3184 }
3185 }
3186 set {
3187 super.ConeFalloff=(PBJ._PBJ.Construct(value));
3188 }
3189 }
3190 public Builder ClearType() { super.ClearType();return this;}
3191 public const int TypeFieldTag=15;
3192 public bool HasType{ get {return super.HasType;} }
3193 public Types.LightTypes Type{ get {
3194 if (HasType) {
3195 return (Types.LightTypes)super.Type;
3196 } else {
3197 return new Types.LightTypes();
3198 }
3199 }
3200 set {
3201 super.Type=((_PBJ_Internal.LightInfoProperty.Types.LightTypes)value);
3202 }
3203 }
3204 public Builder ClearCastsShadow() { super.ClearCastsShadow();return this;}
3205 public const int CastsShadowFieldTag=16;
3206 public bool HasCastsShadow{ get {return super.HasCastsShadow&&PBJ._PBJ.ValidateBool(super.CastsShadow);} }
3207 public bool CastsShadow{ get {
3208 if (HasCastsShadow) {
3209 return PBJ._PBJ.CastBool(super.CastsShadow);
3210 } else {
3211 return PBJ._PBJ.CastBool();
3212 }
3213 }
3214 set {
3215 super.CastsShadow=(PBJ._PBJ.Construct(value));
3216 }
3217 }
3218 }
3219 }
3220}
3221namespace Sirikata.Protocol {
3222 public class ParentProperty : PBJ.IMessage {
3223 protected _PBJ_Internal.ParentProperty super;
3224 public _PBJ_Internal.ParentProperty _PBJSuper{ get { return super;} }
3225 public ParentProperty() {
3226 super=new _PBJ_Internal.ParentProperty();
3227 }
3228 public ParentProperty(_PBJ_Internal.ParentProperty reference) {
3229 super=reference;
3230 }
3231 public static ParentProperty defaultInstance= new ParentProperty (_PBJ_Internal.ParentProperty.DefaultInstance);
3232 public static ParentProperty DefaultInstance{
3233 get {return defaultInstance;}
3234 }
3235 public static pbd.MessageDescriptor Descriptor {
3236 get { return _PBJ_Internal.ParentProperty.Descriptor; } }
3237 public static class Types {
3238 }
3239 public static bool WithinReservedFieldTagRange(int field_tag) {
3240 return false;
3241 }
3242 public static bool WithinExtensionFieldTagRange(int field_tag) {
3243 return false;
3244 }
3245 public const int ValueFieldTag=10;
3246 public bool HasValue{ get {return super.HasValue&&PBJ._PBJ.ValidateUuid(super.Value);} }
3247 public PBJ.UUID Value{ get {
3248 if (HasValue) {
3249 return PBJ._PBJ.CastUuid(super.Value);
3250 } else {
3251 return PBJ._PBJ.CastUuid();
3252 }
3253 }
3254 }
3255 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
3256 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
3257 public static Builder CreateBuilder() { return new Builder(); }
3258 public static Builder CreateBuilder(ParentProperty prototype) {
3259 return (Builder)new Builder().MergeFrom(prototype);
3260 }
3261 public static ParentProperty ParseFrom(pb::ByteString data) {
3262 return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data));
3263 }
3264 public static ParentProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
3265 return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data,er));
3266 }
3267 public static ParentProperty ParseFrom(byte[] data) {
3268 return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data));
3269 }
3270 public static ParentProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) {
3271 return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data,er));
3272 }
3273 public static ParentProperty ParseFrom(global::System.IO.Stream data) {
3274 return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data));
3275 }
3276 public static ParentProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
3277 return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data,er));
3278 }
3279 public static ParentProperty ParseFrom(pb::CodedInputStream data) {
3280 return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data));
3281 }
3282 public static ParentProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
3283 return new ParentProperty(_PBJ_Internal.ParentProperty.ParseFrom(data,er));
3284 }
3285 protected override bool _HasAllPBJFields{ get {
3286 return true
3287 ;
3288 } }
3289 public bool IsInitialized { get {
3290 return super.IsInitialized&&_HasAllPBJFields;
3291 } }
3292 public class Builder : global::PBJ.IMessage.IBuilder{
3293 protected override bool _HasAllPBJFields{ get {
3294 return true
3295 ;
3296 } }
3297 public bool IsInitialized { get {
3298 return super.IsInitialized&&_HasAllPBJFields;
3299 } }
3300 protected _PBJ_Internal.ParentProperty.Builder super;
3301 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
3302 public _PBJ_Internal.ParentProperty.Builder _PBJSuper{ get { return super;} }
3303 public Builder() {super = new _PBJ_Internal.ParentProperty.Builder();}
3304 public Builder(_PBJ_Internal.ParentProperty.Builder other) {
3305 super=other;
3306 }
3307 public Builder Clone() {return new Builder(super.Clone());}
3308 public Builder MergeFrom(ParentProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
3309 public Builder Clear() {super.Clear();return this;}
3310 public ParentProperty BuildPartial() {return new ParentProperty(super.BuildPartial());}
3311 public ParentProperty Build() {if (_HasAllPBJFields) return new ParentProperty(super.Build());return null;}
3312 public pbd::MessageDescriptor DescriptorForType {
3313 get { return ParentProperty.Descriptor; } }
3314 public Builder ClearValue() { super.ClearValue();return this;}
3315 public const int ValueFieldTag=10;
3316 public bool HasValue{ get {return super.HasValue&&PBJ._PBJ.ValidateUuid(super.Value);} }
3317 public PBJ.UUID Value{ get {
3318 if (HasValue) {
3319 return PBJ._PBJ.CastUuid(super.Value);
3320 } else {
3321 return PBJ._PBJ.CastUuid();
3322 }
3323 }
3324 set {
3325 super.Value=(PBJ._PBJ.Construct(value));
3326 }
3327 }
3328 }
3329 }
3330}
3331namespace Sirikata.Protocol {
3332 public class UUIDListProperty : PBJ.IMessage {
3333 protected _PBJ_Internal.UUIDListProperty super;
3334 public _PBJ_Internal.UUIDListProperty _PBJSuper{ get { return super;} }
3335 public UUIDListProperty() {
3336 super=new _PBJ_Internal.UUIDListProperty();
3337 }
3338 public UUIDListProperty(_PBJ_Internal.UUIDListProperty reference) {
3339 super=reference;
3340 }
3341 public static UUIDListProperty defaultInstance= new UUIDListProperty (_PBJ_Internal.UUIDListProperty.DefaultInstance);
3342 public static UUIDListProperty DefaultInstance{
3343 get {return defaultInstance;}
3344 }
3345 public static pbd.MessageDescriptor Descriptor {
3346 get { return _PBJ_Internal.UUIDListProperty.Descriptor; } }
3347 public static class Types {
3348 }
3349 public static bool WithinReservedFieldTagRange(int field_tag) {
3350 return false;
3351 }
3352 public static bool WithinExtensionFieldTagRange(int field_tag) {
3353 return false;
3354 }
3355 public const int ValueFieldTag=10;
3356 public int ValueCount { get { return super.ValueCount;} }
3357 public bool HasValue(int index) {return PBJ._PBJ.ValidateUuid(super.GetValue(index));}
3358 public PBJ.UUID Value(int index) {
3359 return (PBJ.UUID)PBJ._PBJ.CastUuid(super.GetValue(index));
3360 }
3361 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
3362 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
3363 public static Builder CreateBuilder() { return new Builder(); }
3364 public static Builder CreateBuilder(UUIDListProperty prototype) {
3365 return (Builder)new Builder().MergeFrom(prototype);
3366 }
3367 public static UUIDListProperty ParseFrom(pb::ByteString data) {
3368 return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data));
3369 }
3370 public static UUIDListProperty ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
3371 return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data,er));
3372 }
3373 public static UUIDListProperty ParseFrom(byte[] data) {
3374 return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data));
3375 }
3376 public static UUIDListProperty ParseFrom(byte[] data, pb::ExtensionRegistry er) {
3377 return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data,er));
3378 }
3379 public static UUIDListProperty ParseFrom(global::System.IO.Stream data) {
3380 return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data));
3381 }
3382 public static UUIDListProperty ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
3383 return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data,er));
3384 }
3385 public static UUIDListProperty ParseFrom(pb::CodedInputStream data) {
3386 return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data));
3387 }
3388 public static UUIDListProperty ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
3389 return new UUIDListProperty(_PBJ_Internal.UUIDListProperty.ParseFrom(data,er));
3390 }
3391 protected override bool _HasAllPBJFields{ get {
3392 return true
3393 ;
3394 } }
3395 public bool IsInitialized { get {
3396 return super.IsInitialized&&_HasAllPBJFields;
3397 } }
3398 public class Builder : global::PBJ.IMessage.IBuilder{
3399 protected override bool _HasAllPBJFields{ get {
3400 return true
3401 ;
3402 } }
3403 public bool IsInitialized { get {
3404 return super.IsInitialized&&_HasAllPBJFields;
3405 } }
3406 protected _PBJ_Internal.UUIDListProperty.Builder super;
3407 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
3408 public _PBJ_Internal.UUIDListProperty.Builder _PBJSuper{ get { return super;} }
3409 public Builder() {super = new _PBJ_Internal.UUIDListProperty.Builder();}
3410 public Builder(_PBJ_Internal.UUIDListProperty.Builder other) {
3411 super=other;
3412 }
3413 public Builder Clone() {return new Builder(super.Clone());}
3414 public Builder MergeFrom(UUIDListProperty prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
3415 public Builder Clear() {super.Clear();return this;}
3416 public UUIDListProperty BuildPartial() {return new UUIDListProperty(super.BuildPartial());}
3417 public UUIDListProperty Build() {if (_HasAllPBJFields) return new UUIDListProperty(super.Build());return null;}
3418 public pbd::MessageDescriptor DescriptorForType {
3419 get { return UUIDListProperty.Descriptor; } }
3420 public Builder ClearValue() { super.ClearValue();return this;}
3421 public Builder SetValue(int index, PBJ.UUID value) {
3422 super.SetValue(index,PBJ._PBJ.Construct(value));
3423 return this;
3424 }
3425 public const int ValueFieldTag=10;
3426 public int ValueCount { get { return super.ValueCount;} }
3427 public bool HasValue(int index) {return PBJ._PBJ.ValidateUuid(super.GetValue(index));}
3428 public PBJ.UUID Value(int index) {
3429 return (PBJ.UUID)PBJ._PBJ.CastUuid(super.GetValue(index));
3430 }
3431 public Builder AddValue(PBJ.UUID value) {
3432 super.AddValue(PBJ._PBJ.Construct(value));
3433 return this;
3434 }
3435 }
3436 }
3437}
3438namespace Sirikata.Protocol {
3439 public class ConnectToSpace : PBJ.IMessage {
3440 protected _PBJ_Internal.ConnectToSpace super;
3441 public _PBJ_Internal.ConnectToSpace _PBJSuper{ get { return super;} }
3442 public ConnectToSpace() {
3443 super=new _PBJ_Internal.ConnectToSpace();
3444 }
3445 public ConnectToSpace(_PBJ_Internal.ConnectToSpace reference) {
3446 super=reference;
3447 }
3448 public static ConnectToSpace defaultInstance= new ConnectToSpace (_PBJ_Internal.ConnectToSpace.DefaultInstance);
3449 public static ConnectToSpace DefaultInstance{
3450 get {return defaultInstance;}
3451 }
3452 public static pbd.MessageDescriptor Descriptor {
3453 get { return _PBJ_Internal.ConnectToSpace.Descriptor; } }
3454 public static class Types {
3455 }
3456 public static bool WithinReservedFieldTagRange(int field_tag) {
3457 return false;
3458 }
3459 public static bool WithinExtensionFieldTagRange(int field_tag) {
3460 return false;
3461 }
3462 public const int SpaceIdFieldTag=1;
3463 public bool HasSpaceId{ get {return super.HasSpaceId&&PBJ._PBJ.ValidateUuid(super.SpaceId);} }
3464 public PBJ.UUID SpaceId{ get {
3465 if (HasSpaceId) {
3466 return PBJ._PBJ.CastUuid(super.SpaceId);
3467 } else {
3468 return PBJ._PBJ.CastUuid();
3469 }
3470 }
3471 }
3472 public const int ObjectUuidEvidenceFieldTag=2;
3473 public bool HasObjectUuidEvidence{ get {return super.HasObjectUuidEvidence&&PBJ._PBJ.ValidateUuid(super.ObjectUuidEvidence);} }
3474 public PBJ.UUID ObjectUuidEvidence{ get {
3475 if (HasObjectUuidEvidence) {
3476 return PBJ._PBJ.CastUuid(super.ObjectUuidEvidence);
3477 } else {
3478 return PBJ._PBJ.CastUuid();
3479 }
3480 }
3481 }
3482 public const int RequestedObjectLocFieldTag=3;
3483 public bool HasRequestedObjectLoc{ get {return super.HasRequestedObjectLoc;} }
3484 public ObjLoc RequestedObjectLoc{ get {
3485 if (HasRequestedObjectLoc) {
3486 return new ObjLoc(super.RequestedObjectLoc);
3487 } else {
3488 return new ObjLoc();
3489 }
3490 }
3491 }
3492 public const int BoundingSphereFieldTag=4;
3493 public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} }
3494 public PBJ.BoundingSphere3f BoundingSphere{ get {
3495 int index=0;
3496 if (HasBoundingSphere) {
3497 return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3));
3498 } else {
3499 return PBJ._PBJ.CastBoundingsphere3f();
3500 }
3501 }
3502 }
3503 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
3504 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
3505 public static Builder CreateBuilder() { return new Builder(); }
3506 public static Builder CreateBuilder(ConnectToSpace prototype) {
3507 return (Builder)new Builder().MergeFrom(prototype);
3508 }
3509 public static ConnectToSpace ParseFrom(pb::ByteString data) {
3510 return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data));
3511 }
3512 public static ConnectToSpace ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
3513 return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data,er));
3514 }
3515 public static ConnectToSpace ParseFrom(byte[] data) {
3516 return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data));
3517 }
3518 public static ConnectToSpace ParseFrom(byte[] data, pb::ExtensionRegistry er) {
3519 return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data,er));
3520 }
3521 public static ConnectToSpace ParseFrom(global::System.IO.Stream data) {
3522 return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data));
3523 }
3524 public static ConnectToSpace ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
3525 return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data,er));
3526 }
3527 public static ConnectToSpace ParseFrom(pb::CodedInputStream data) {
3528 return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data));
3529 }
3530 public static ConnectToSpace ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
3531 return new ConnectToSpace(_PBJ_Internal.ConnectToSpace.ParseFrom(data,er));
3532 }
3533 protected override bool _HasAllPBJFields{ get {
3534 return true
3535 ;
3536 } }
3537 public bool IsInitialized { get {
3538 return super.IsInitialized&&_HasAllPBJFields;
3539 } }
3540 public class Builder : global::PBJ.IMessage.IBuilder{
3541 protected override bool _HasAllPBJFields{ get {
3542 return true
3543 ;
3544 } }
3545 public bool IsInitialized { get {
3546 return super.IsInitialized&&_HasAllPBJFields;
3547 } }
3548 protected _PBJ_Internal.ConnectToSpace.Builder super;
3549 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
3550 public _PBJ_Internal.ConnectToSpace.Builder _PBJSuper{ get { return super;} }
3551 public Builder() {super = new _PBJ_Internal.ConnectToSpace.Builder();}
3552 public Builder(_PBJ_Internal.ConnectToSpace.Builder other) {
3553 super=other;
3554 }
3555 public Builder Clone() {return new Builder(super.Clone());}
3556 public Builder MergeFrom(ConnectToSpace prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
3557 public Builder Clear() {super.Clear();return this;}
3558 public ConnectToSpace BuildPartial() {return new ConnectToSpace(super.BuildPartial());}
3559 public ConnectToSpace Build() {if (_HasAllPBJFields) return new ConnectToSpace(super.Build());return null;}
3560 public pbd::MessageDescriptor DescriptorForType {
3561 get { return ConnectToSpace.Descriptor; } }
3562 public Builder ClearSpaceId() { super.ClearSpaceId();return this;}
3563 public const int SpaceIdFieldTag=1;
3564 public bool HasSpaceId{ get {return super.HasSpaceId&&PBJ._PBJ.ValidateUuid(super.SpaceId);} }
3565 public PBJ.UUID SpaceId{ get {
3566 if (HasSpaceId) {
3567 return PBJ._PBJ.CastUuid(super.SpaceId);
3568 } else {
3569 return PBJ._PBJ.CastUuid();
3570 }
3571 }
3572 set {
3573 super.SpaceId=(PBJ._PBJ.Construct(value));
3574 }
3575 }
3576 public Builder ClearObjectUuidEvidence() { super.ClearObjectUuidEvidence();return this;}
3577 public const int ObjectUuidEvidenceFieldTag=2;
3578 public bool HasObjectUuidEvidence{ get {return super.HasObjectUuidEvidence&&PBJ._PBJ.ValidateUuid(super.ObjectUuidEvidence);} }
3579 public PBJ.UUID ObjectUuidEvidence{ get {
3580 if (HasObjectUuidEvidence) {
3581 return PBJ._PBJ.CastUuid(super.ObjectUuidEvidence);
3582 } else {
3583 return PBJ._PBJ.CastUuid();
3584 }
3585 }
3586 set {
3587 super.ObjectUuidEvidence=(PBJ._PBJ.Construct(value));
3588 }
3589 }
3590 public Builder ClearRequestedObjectLoc() { super.ClearRequestedObjectLoc();return this;}
3591 public const int RequestedObjectLocFieldTag=3;
3592 public bool HasRequestedObjectLoc{ get {return super.HasRequestedObjectLoc;} }
3593 public ObjLoc RequestedObjectLoc{ get {
3594 if (HasRequestedObjectLoc) {
3595 return new ObjLoc(super.RequestedObjectLoc);
3596 } else {
3597 return new ObjLoc();
3598 }
3599 }
3600 set {
3601 super.RequestedObjectLoc=value._PBJSuper;
3602 }
3603 }
3604 public Builder ClearBoundingSphere() { super.ClearBoundingSphere();return this;}
3605 public const int BoundingSphereFieldTag=4;
3606 public bool HasBoundingSphere{ get {return super.BoundingSphereCount>=4;} }
3607 public PBJ.BoundingSphere3f BoundingSphere{ get {
3608 int index=0;
3609 if (HasBoundingSphere) {
3610 return PBJ._PBJ.CastBoundingsphere3f(super.GetBoundingSphere(index*4+0),super.GetBoundingSphere(index*4+1),super.GetBoundingSphere(index*4+2),super.GetBoundingSphere(index*4+3));
3611 } else {
3612 return PBJ._PBJ.CastBoundingsphere3f();
3613 }
3614 }
3615 set {
3616 super.ClearBoundingSphere();
3617 float[] _PBJtempArray=PBJ._PBJ.ConstructBoundingsphere3f(value);
3618 super.AddBoundingSphere(_PBJtempArray[0]);
3619 super.AddBoundingSphere(_PBJtempArray[1]);
3620 super.AddBoundingSphere(_PBJtempArray[2]);
3621 super.AddBoundingSphere(_PBJtempArray[3]);
3622 }
3623 }
3624 }
3625 }
3626}
3627namespace Sirikata.Protocol {
3628 public class CreateObject : PBJ.IMessage {
3629 protected _PBJ_Internal.CreateObject super;
3630 public _PBJ_Internal.CreateObject _PBJSuper{ get { return super;} }
3631 public CreateObject() {
3632 super=new _PBJ_Internal.CreateObject();
3633 }
3634 public CreateObject(_PBJ_Internal.CreateObject reference) {
3635 super=reference;
3636 }
3637 public static CreateObject defaultInstance= new CreateObject (_PBJ_Internal.CreateObject.DefaultInstance);
3638 public static CreateObject DefaultInstance{
3639 get {return defaultInstance;}
3640 }
3641 public static pbd.MessageDescriptor Descriptor {
3642 get { return _PBJ_Internal.CreateObject.Descriptor; } }
3643 public static class Types {
3644 }
3645 public static bool WithinReservedFieldTagRange(int field_tag) {
3646 return false;
3647 }
3648 public static bool WithinExtensionFieldTagRange(int field_tag) {
3649 return false;
3650 }
3651 public const int ObjectUuidFieldTag=1;
3652 public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} }
3653 public PBJ.UUID ObjectUuid{ get {
3654 if (HasObjectUuid) {
3655 return PBJ._PBJ.CastUuid(super.ObjectUuid);
3656 } else {
3657 return PBJ._PBJ.CastUuid();
3658 }
3659 }
3660 }
3661 public const int SpacePropertiesFieldTag=2;
3662 public int SpacePropertiesCount { get { return super.SpacePropertiesCount;} }
3663 public bool HasSpaceProperties(int index) {return true;}
3664 public ConnectToSpace SpaceProperties(int index) {
3665 return new ConnectToSpace(super.GetSpaceProperties(index));
3666 }
3667 public const int MeshFieldTag=3;
3668 public bool HasMesh{ get {return super.HasMesh&&PBJ._PBJ.ValidateString(super.Mesh);} }
3669 public string Mesh{ get {
3670 if (HasMesh) {
3671 return PBJ._PBJ.CastString(super.Mesh);
3672 } else {
3673 return PBJ._PBJ.CastString();
3674 }
3675 }
3676 }
3677 public const int ScaleFieldTag=4;
3678 public bool HasScale{ get {return super.ScaleCount>=3;} }
3679 public PBJ.Vector3f Scale{ get {
3680 int index=0;
3681 if (HasScale) {
3682 return PBJ._PBJ.CastVector3f(super.GetScale(index*3+0),super.GetScale(index*3+1),super.GetScale(index*3+2));
3683 } else {
3684 return PBJ._PBJ.CastVector3f();
3685 }
3686 }
3687 }
3688 public const int WeburlFieldTag=5;
3689 public bool HasWeburl{ get {return super.HasWeburl&&PBJ._PBJ.ValidateString(super.Weburl);} }
3690 public string Weburl{ get {
3691 if (HasWeburl) {
3692 return PBJ._PBJ.CastString(super.Weburl);
3693 } else {
3694 return PBJ._PBJ.CastString();
3695 }
3696 }
3697 }
3698 public const int LightInfoFieldTag=6;
3699 public bool HasLightInfo{ get {return super.HasLightInfo;} }
3700 public LightInfoProperty LightInfo{ get {
3701 if (HasLightInfo) {
3702 return new LightInfoProperty(super.LightInfo);
3703 } else {
3704 return new LightInfoProperty();
3705 }
3706 }
3707 }
3708 public const int CameraFieldTag=7;
3709 public bool HasCamera{ get {return super.HasCamera&&PBJ._PBJ.ValidateBool(super.Camera);} }
3710 public bool Camera{ get {
3711 if (HasCamera) {
3712 return PBJ._PBJ.CastBool(super.Camera);
3713 } else {
3714 return PBJ._PBJ.CastBool();
3715 }
3716 }
3717 }
3718 public const int PhysicalFieldTag=8;
3719 public bool HasPhysical{ get {return super.HasPhysical;} }
3720 public PhysicalParameters Physical{ get {
3721 if (HasPhysical) {
3722 return new PhysicalParameters(super.Physical);
3723 } else {
3724 return new PhysicalParameters();
3725 }
3726 }
3727 }
3728 public override Google.ProtocolBuffers.IMessage _PBJISuper { get { return super; } }
3729 public override PBJ.IMessage.IBuilder WeakCreateBuilderForType() { return new Builder(); }
3730 public static Builder CreateBuilder() { return new Builder(); }
3731 public static Builder CreateBuilder(CreateObject prototype) {
3732 return (Builder)new Builder().MergeFrom(prototype);
3733 }
3734 public static CreateObject ParseFrom(pb::ByteString data) {
3735 return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data));
3736 }
3737 public static CreateObject ParseFrom(pb::ByteString data, pb::ExtensionRegistry er) {
3738 return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data,er));
3739 }
3740 public static CreateObject ParseFrom(byte[] data) {
3741 return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data));
3742 }
3743 public static CreateObject ParseFrom(byte[] data, pb::ExtensionRegistry er) {
3744 return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data,er));
3745 }
3746 public static CreateObject ParseFrom(global::System.IO.Stream data) {
3747 return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data));
3748 }
3749 public static CreateObject ParseFrom(global::System.IO.Stream data, pb::ExtensionRegistry er) {
3750 return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data,er));
3751 }
3752 public static CreateObject ParseFrom(pb::CodedInputStream data) {
3753 return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data));
3754 }
3755 public static CreateObject ParseFrom(pb::CodedInputStream data, pb::ExtensionRegistry er) {
3756 return new CreateObject(_PBJ_Internal.CreateObject.ParseFrom(data,er));
3757 }
3758 protected override bool _HasAllPBJFields{ get {
3759 return true
3760 ;
3761 } }
3762 public bool IsInitialized { get {
3763 return super.IsInitialized&&_HasAllPBJFields;
3764 } }
3765 public class Builder : global::PBJ.IMessage.IBuilder{
3766 protected override bool _HasAllPBJFields{ get {
3767 return true
3768 ;
3769 } }
3770 public bool IsInitialized { get {
3771 return super.IsInitialized&&_HasAllPBJFields;
3772 } }
3773 protected _PBJ_Internal.CreateObject.Builder super;
3774 public override Google.ProtocolBuffers.IBuilder _PBJISuper { get { return super; } }
3775 public _PBJ_Internal.CreateObject.Builder _PBJSuper{ get { return super;} }
3776 public Builder() {super = new _PBJ_Internal.CreateObject.Builder();}
3777 public Builder(_PBJ_Internal.CreateObject.Builder other) {
3778 super=other;
3779 }
3780 public Builder Clone() {return new Builder(super.Clone());}
3781 public Builder MergeFrom(CreateObject prototype) { super.MergeFrom(prototype._PBJSuper);return this;}
3782 public Builder Clear() {super.Clear();return this;}
3783 public CreateObject BuildPartial() {return new CreateObject(super.BuildPartial());}
3784 public CreateObject Build() {if (_HasAllPBJFields) return new CreateObject(super.Build());return null;}
3785 public pbd::MessageDescriptor DescriptorForType {
3786 get { return CreateObject.Descriptor; } }
3787 public Builder ClearObjectUuid() { super.ClearObjectUuid();return this;}
3788 public const int ObjectUuidFieldTag=1;
3789 public bool HasObjectUuid{ get {return super.HasObjectUuid&&PBJ._PBJ.ValidateUuid(super.ObjectUuid);} }
3790 public PBJ.UUID ObjectUuid{ get {
3791 if (HasObjectUuid) {
3792 return PBJ._PBJ.CastUuid(super.ObjectUuid);
3793 } else {
3794 return PBJ._PBJ.CastUuid();
3795 }
3796 }
3797 set {
3798 super.ObjectUuid=(PBJ._PBJ.Construct(value));
3799 }
3800 }
3801 public Builder ClearSpaceProperties() { super.ClearSpaceProperties();return this;}
3802 public Builder SetSpaceProperties(int index,ConnectToSpace value) {
3803 super.SetSpaceProperties(index,value._PBJSuper);
3804 return this;
3805 }
3806 public const int SpacePropertiesFieldTag=2;
3807 public int SpacePropertiesCount { get { return super.SpacePropertiesCount;} }
3808 public bool HasSpaceProperties(int index) {return true;}
3809 public ConnectToSpace SpaceProperties(int index) {
3810 return new ConnectToSpace(super.GetSpaceProperties(index));
3811 }
3812 public Builder AddSpaceProperties(ConnectToSpace value ) {
3813 super.AddSpaceProperties(value._PBJSuper);
3814 return this;
3815 }
3816 public Builder ClearMesh() { super.ClearMesh();return this;}
3817 public const int MeshFieldTag=3;
3818 public bool HasMesh{ get {return super.HasMesh&&PBJ._PBJ.ValidateString(super.Mesh);} }
3819 public string Mesh{ get {
3820 if (HasMesh) {
3821 return PBJ._PBJ.CastString(super.Mesh);
3822 } else {
3823 return PBJ._PBJ.CastString();
3824 }
3825 }
3826 set {
3827 super.Mesh=(PBJ._PBJ.Construct(value));
3828 }
3829 }
3830 public Builder ClearScale() { super.ClearScale();return this;}
3831 public const int ScaleFieldTag=4;
3832 public bool HasScale{ get {return super.ScaleCount>=3;} }
3833 public PBJ.Vector3f Scale{ get {
3834 int index=0;
3835 if (HasScale) {
3836 return PBJ._PBJ.CastVector3f(super.GetScale(index*3+0),super.GetScale(index*3+1),super.GetScale(index*3+2));
3837 } else {
3838 return PBJ._PBJ.CastVector3f();
3839 }
3840 }
3841 set {
3842 super.ClearScale();
3843 float[] _PBJtempArray=PBJ._PBJ.ConstructVector3f(value);
3844 super.AddScale(_PBJtempArray[0]);
3845 super.AddScale(_PBJtempArray[1]);
3846 super.AddScale(_PBJtempArray[2]);
3847 }
3848 }
3849 public Builder ClearWeburl() { super.ClearWeburl();return this;}
3850 public const int WeburlFieldTag=5;
3851 public bool HasWeburl{ get {return super.HasWeburl&&PBJ._PBJ.ValidateString(super.Weburl);} }
3852 public string Weburl{ get {
3853 if (HasWeburl) {
3854 return PBJ._PBJ.CastString(super.Weburl);
3855 } else {
3856 return PBJ._PBJ.CastString();
3857 }
3858 }
3859 set {
3860 super.Weburl=(PBJ._PBJ.Construct(value));
3861 }
3862 }
3863 public Builder ClearLightInfo() { super.ClearLightInfo();return this;}
3864 public const int LightInfoFieldTag=6;
3865 public bool HasLightInfo{ get {return super.HasLightInfo;} }
3866 public LightInfoProperty LightInfo{ get {
3867 if (HasLightInfo) {
3868 return new LightInfoProperty(super.LightInfo);
3869 } else {
3870 return new LightInfoProperty();
3871 }
3872 }
3873 set {
3874 super.LightInfo=value._PBJSuper;
3875 }
3876 }
3877 public Builder ClearCamera() { super.ClearCamera();return this;}
3878 public const int CameraFieldTag=7;
3879 public bool HasCamera{ get {return super.HasCamera&&PBJ._PBJ.ValidateBool(super.Camera);} }
3880 public bool Camera{ get {
3881 if (HasCamera) {
3882 return PBJ._PBJ.CastBool(super.Camera);
3883 } else {
3884 return PBJ._PBJ.CastBool();
3885 }
3886 }
3887 set {
3888 super.Camera=(PBJ._PBJ.Construct(value));
3889 }
3890 }
3891 public Builder ClearPhysical() { super.ClearPhysical();return this;}
3892 public const int PhysicalFieldTag=8;
3893 public bool HasPhysical{ get {return super.HasPhysical;} }
3894 public PhysicalParameters Physical{ get {
3895 if (HasPhysical) {
3896 return new PhysicalParameters(super.Physical);
3897 } else {
3898 return new PhysicalParameters();
3899 }
3900 }
3901 set {
3902 super.Physical=value._PBJSuper;
3903 }
3904 }
3905 }
3906 }
3907}