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