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