8 namespace droid.Runtime.Messaging.FBS {
11 public static class FbsStateUtilities {
12 static VectorOffset _null_vector_offset =
new VectorOffset();
13 static Offset<FUnobservables> _null_unobservables_offset =
new Offset<FUnobservables>();
28 bool serialise_individual_observables =
false,
29 bool do_serialise_unobservables =
false,
30 bool do_serialise_aggregated_float_array =
false,
31 string api_version =
"N/A") {
32 var b =
new FlatBufferBuilder(1);
33 var state_offsets =
new Offset<FState>[states.Length];
35 foreach (var state
in states) {
36 state_offsets[i++] = serialise_state(b,
38 serialise_individual_observables,
39 do_serialise_unobservables,
40 do_serialise_aggregated_float_array);
43 var states_vector_offset = FStates.CreateStatesVector(b, state_offsets);
45 var api_version_offset = b.CreateString(api_version);
47 FStates.StartFStates(b);
48 FStates.AddStates(b, states_vector_offset);
49 FStates.AddApiVersion(b, api_version_offset);
50 FStates.AddSimulatorConfiguration(b, Serialise(b, simulator_configuration));
51 var states_offset = FStates.EndFStates(b);
53 FStates.FinishFStatesBuffer(b, states_offset);
55 return b.SizedByteArray();
60 #region PrivateMethods 67 static Offset<FSimulatorConfiguration>
69 return FSimulatorConfiguration.CreateFSimulatorConfiguration(b,
95 static Offset<FState> serialise_state(FlatBufferBuilder b,
97 bool serialise_individual_observables =
false,
98 bool do_serialise_unobservables =
false,
99 bool do_serialise_aggregated_float_array =
false) {
102 var observables_vector = _null_vector_offset;
103 if (do_serialise_aggregated_float_array) {
104 observables_vector = FState.CreateObservablesVector(b, state.
Observables);
107 var observers_vector = _null_vector_offset;
108 if (serialise_individual_observables) {
111 var observers =
new Offset<FOBS>[observations.Length];
113 foreach (var observer
in observations) {
114 observers[k++] = Serialise(b, observer);
117 observers_vector = FState.CreateObservationsVector(b, observers);
120 var unobservables = _null_unobservables_offset;
121 if (do_serialise_unobservables) {
123 var bodies = state_unobservables.
Bodies;
125 FUnobservables.StartBodiesVector(b, bodies.Length);
126 foreach (var rig
in bodies) {
128 var ang = rig.AngularVelocity;
129 FBody.CreateFBody(b, vel.x, vel.y, vel.z, ang.x, ang.y, ang.z);
132 var bodies_vector = b.EndVector();
134 var poses = state_unobservables.Poses;
136 FUnobservables.StartPosesVector(b, poses.Length);
137 foreach (var tra
in poses) {
138 var pos = tra.position;
139 var rot = tra.rotation;
140 FQuaternionTransform.CreateFQuaternionTransform(b, pos.x, pos.y, pos.z, rot.x, rot.y, rot.z, rot.w);
143 var poses_vector = b.EndVector();
145 FUnobservables.StartFUnobservables(b);
146 FUnobservables.AddPoses(b, poses_vector);
147 FUnobservables.AddBodies(b, bodies_vector);
148 unobservables = FUnobservables.EndFUnobservables(b);
151 var description_offset =
new Offset<FEnvironmentDescription>();
153 description_offset = Serialise(b, state);
156 var d =
new StringOffset();
163 FState.StartFState(b);
164 FState.AddEnvironmentName(b, n);
167 if (do_serialise_aggregated_float_array) {
168 FState.AddObservables(b, observables_vector);
171 if (do_serialise_unobservables) {
172 FState.AddUnobservables(b, unobservables);
176 FState.AddSignal(b, state.
Signal);
179 FState.AddTerminationReason(b, t);
181 if (serialise_individual_observables) {
182 FState.AddObservations(b, observers_vector);
186 FState.AddEnvironmentDescription(b, description_offset);
190 FState.AddSerialisedMessage(b, d);
193 return FState.EndFState(b);
196 static Offset<FActuator> Serialise(FlatBufferBuilder b,
IActuator actuator,
string identifier) {
197 var n = b.CreateString(identifier);
198 FActuator.StartFActuator(b);
199 FActuator.AddActuatorName(b, n);
200 FActuator.AddValidInput(b,
201 FRange.CreateFRange(b,
206 return FActuator.EndFActuator(b);
214 static Offset<FEulerTransform> Serialise(FlatBufferBuilder b,
IHasEulerTransform observer) {
216 return FEulerTransform.CreateFEulerTransform(b,
238 FQuaternionTransform.CreateFQuaternionTransform(b,
246 return FQT.EndFQT(b);
249 static Offset<FByteArray> Serialise(FlatBufferBuilder b,
IHasByteArray observer) {
283 static Offset<FArray> Serialise(FlatBufferBuilder b,
IHasFloatArray float_a) {
287 var ranges_vector =
new VectorOffset();
291 FRange.CreateFRange(b, tra._Decimal_Granularity, tra._Max_Value, tra._Min_Value);
294 ranges_vector = b.EndVector();
297 FArray.AddArray(b, v_offset);
299 FArray.AddRanges(b, ranges_vector);
301 return FArray.EndFArray(b);
310 static Offset<FRB> Serialise(FlatBufferBuilder b, Vector3 vel, Vector3 ang) {
312 FRB.AddBody(b, FBody.CreateFBody(b, vel.x, vel.y, vel.z, ang.x, ang.y, ang.z));
313 return FRB.EndFRB(b);
316 static Offset<FSingle> Serialise(FlatBufferBuilder b,
IHasSingle numeral) {
320 var range_offset = FRange.CreateFRange(b,
324 FSingle.AddRange(b, range_offset);
328 static Offset<FDouble> Serialise(FlatBufferBuilder b,
IHasDouble numeral) {
332 var granularity = numeral.
DoubleSpace.DecimalGranularity;
336 FDouble.AddXRange(b, FRange.CreateFRange(b, granularity, xs._Max_Value, xs._Min_Value));
337 FDouble.AddYRange(b, FRange.CreateFRange(b, granularity, ys._Max_Value, ys._Min_Value));
338 FDouble.AddVec2(b, FVector2.CreateFVector2(b, vec2.x, vec2.y));
343 static Offset<FTriple> Serialise(FlatBufferBuilder b,
IHasTriple numeral) {
347 FTriple.AddVec3(b, FVector3.CreateFVector3(b, vec3.x, vec3.y, vec3.z));
348 var granularity = numeral.
TripleSpace.DecimalGranularity;
352 FTriple.AddXRange(b, FRange.CreateFRange(b, granularity, xs._Max_Value, xs._Min_Value));
353 FTriple.AddYRange(b, FRange.CreateFRange(b, granularity, ys._Max_Value, ys._Min_Value));
354 FTriple.AddZRange(b, FRange.CreateFRange(b, granularity, zs._Max_Value, zs._Min_Value));
358 static Offset<FQuadruple> Serialise(FlatBufferBuilder b,
IHasQuadruple numeral) {
361 FQuadruple.AddQuat(b, FQuaternion.CreateFQuaternion(b, quad.x, quad.y, quad.z, quad.z));
362 var granularity = numeral.
QuadSpace.DecimalGranularity;
367 FQuadruple.AddXRange(b, FRange.CreateFRange(b, granularity, xs._Max_Value, xs._Min_Value));
368 FQuadruple.AddYRange(b, FRange.CreateFRange(b, granularity, ys._Max_Value, ys._Min_Value));
369 FQuadruple.AddZRange(b, FRange.CreateFRange(b, granularity, zs._Max_Value, zs._Min_Value));
370 FQuadruple.AddWRange(b, FRange.CreateFRange(b, granularity, ws._Max_Value, ws._Min_Value));
374 static Offset<FString> Serialise(FlatBufferBuilder b,
IHasString numeral) {
377 FString.AddStr(b, string_offset);
382 static Offset<FActor> Serialise(FlatBufferBuilder b,
383 Offset<FActuator>[] actuators,
386 var n = b.CreateString(identifier);
387 var actuator_vector = FActor.CreateActuatorsVector(b, actuators);
388 FActor.StartFActor(b);
390 FActor.AddAlive(b, ((KillableActor)actor).IsAlive);
392 FActor.AddAlive(b,
true);
395 FActor.AddActorName(b, n);
396 FActor.AddActuators(b, actuator_vector);
397 return FActor.EndFActor(b);
400 static Offset<FOBS> Serialise(FlatBufferBuilder b,
IObserver observer) {
403 int observation_offset;
407 observation_offset = Serialise(b, numeral).Value;
411 observation_offset = Serialise(b, a).Value;
415 observation_offset = Serialise(b, single).Value;
419 observation_offset = Serialise(b, has_double).Value;
423 observation_offset = Serialise(b, triple).Value;
427 observation_offset = Serialise(b, quadruple).Value;
431 observation_offset = Serialise(b, transform).Value;
435 observation_offset = Serialise(b, quaternion_transform).Value;
439 observation_offset = Serialise(b, rigidbody.Velocity, rigidbody.AngularVelocity).Value;
443 observation_offset = Serialise(b, array).Value;
447 return FOBS.CreateFOBS(b, n);
451 FOBS.AddObservationName(b, n);
452 FOBS.AddObservationType(b, observation_type);
453 FOBS.AddObservation(b, observation_offset);
454 return FOBS.EndFOBS(b);
457 static Offset<FEnvironmentDescription> Serialise(FlatBufferBuilder b,
EnvironmentState state) {
461 var actuators_offsets =
new Offset<FActuator>[actor.Value.Actuators.Values.Count];
463 foreach (var actuator
in actor.Value.Actuators) {
464 actuators_offsets[i++] = Serialise(b, actuator.Value, actuator.Key);
467 actors_offsets[j++] = Serialise(b, actuators_offsets, actor.Value, actor.Key);
470 var actors_vector_offset = FEnvironmentDescription.CreateActorsVector(b, actors_offsets);
475 configurables_offsets[k++] = Serialise(b, configurable.Value, configurable.Key);
478 var configurables_vector_offset =
479 FEnvironmentDescription.CreateConfigurablesVector(b, configurables_offsets);
481 var objective_offset = Serialise(b, state.
Description);
483 FEnvironmentDescription.StartFEnvironmentDescription(b);
484 FEnvironmentDescription.AddObjective(b, objective_offset);
486 FEnvironmentDescription.AddActors(b, actors_vector_offset);
487 FEnvironmentDescription.AddConfigurables(b, configurables_vector_offset);
489 return FEnvironmentDescription.EndFEnvironmentDescription(b);
493 var objective_name_offset = b.CreateString(
"Default objective");
494 FObjective.StartFObjective(b);
495 FObjective.AddMaxEpisodeLength(b, description.
MaxSteps);
497 FObjective.AddObjectiveName(b, objective_name_offset);
498 return FObjective.EndFObjective(b);
504 FTriple.AddVec3(b, FVector3.CreateFVector3(b, pos.x, pos.y, pos.z));
508 static Offset<FConfigurable> Serialise(
512 var n = b.CreateString(identifier);
514 int observation_offset;
518 observation_offset = Serialise(b, (IHasQuaternionTransform)configurable).Value;
521 observation_offset = Serialise(b, (PositionConfigurable)configurable).Value;
524 observation_offset = Serialise(b, (IHasSingle)configurable).Value;
529 observation_offset = Serialise(b, (IHasDouble)configurable).Value;
535 FConfigurable.StartFConfigurable(b);
536 FConfigurable.AddConfigurableName(b, n);
537 return FConfigurable.EndFConfigurable(b);
540 FConfigurable.StartFConfigurable(b);
541 FConfigurable.AddConfigurableName(b, n);
542 FConfigurable.AddObservation(b, observation_offset);
543 FConfigurable.AddObservationType(b, observation_type);
544 return FConfigurable.EndFConfigurable(b);
float TotalEnergySpentSinceReset
Dictionary< string, IActor > Actors
Quaternion ObservationValue
bool DoSerialiseIndividualSensors
Dictionary< string, IConfigurable > Configurables
EnvironmentDescription Description
Space1 [] ObservationSpace
Unobservables Unobservables
float [] ObservationArray
bool DoSerialiseUnobservables