d:/Cpp/RoboidControl-cpp/Thing.h

#pragma once
 
#if !defined(NO_STD)
#include <iostream>
#include <list>
#endif
#include "LinearAlgebra/Spherical.h"
#include "LinearAlgebra/SwingTwist.h"
 
namespace RoboidControl {
 
class Participant;
class ParticipantUDP;
 
#define THING_STORE_SIZE 256
// IMPORTANT: values higher than 256 will need to change the Thing::id type
// to 16-bit or higher, breaking the networking protocol!
 
class Thing {
 public:
  enum Type : unsigned char {
    Undetermined,
    // Sensor,
    Switch,
    DistanceSensor,
    DirectionalSensor,
    TemperatureSensor,
    TouchSensor,
    // Motor,
    ControlledMotor,
    UncontrolledMotor,
    Servo,
    // Other
    Roboid,
    Humanoid,
    ExternalSensor,
    DifferentialDrive
  };
 
#pragma region Init
 
  Thing(unsigned char thingType = Type::Undetermined);
 
  Thing(Participant* owner,
        unsigned char thingType = Type::Undetermined,
        unsigned char thingId = 0);
 
  Thing(Thing* parent, unsigned char thingType = 0, unsigned char thingId = 0);
 
#pragma endregion Init
 
 public:
  bool terminate = false;
 
#pragma region Properties
 
  Participant* owner = nullptr;
  unsigned char id = 0;
 
  unsigned char type = Type::Undetermined;
 
  const char* name = nullptr;
 
 public:
  void SetName(const char* name);
  const char* GetName() const;
  bool nameChanged = false;
 
  void SetModel(const char* url);
 
  const char* modelUrl = nullptr;
  float modelScale = 1;
 
#pragma endregion Properties
 
#pragma region Hierarchy
 
  virtual void SetParent(Thing* parent);
  Thing* GetParent();
 
  unsigned char childCount = 0;
  Thing* GetChildByIndex(unsigned char ix);
 
  virtual void AddChild(Thing* child);
  Thing* RemoveChild(Thing* child);
 
  Thing* GetChild(unsigned char id, bool recurse = false);
 
  Thing* FindChild(const char* name, bool recurse = true);
 
  bool hierarchyChanged = true;
 
 private:
  Thing* parent = nullptr;
  Thing** children = nullptr;
 
#pragma endregion Hierarchy
 
#pragma region Pose
 
 public:
  void SetPosition(Spherical position);
  Spherical GetPosition();
  bool positionUpdated = false;
 
  void SetOrientation(SwingTwist orientation);
  SwingTwist GetOrientation();
  bool orientationUpdated = false;
 
  void SetLinearVelocity(Spherical linearVelocity);
  virtual Spherical GetLinearVelocity();
  bool linearVelocityUpdated = false;
 
  virtual void SetAngularVelocity(Spherical angularVelocity);
  virtual Spherical GetAngularVelocity();
  bool angularVelocityUpdated = false;
 
 private:
  Spherical position;
  SwingTwist orientation;
 
  Spherical linearVelocity;
  Spherical angularVelocity;
 
#pragma endregion Pose
 
#pragma region Update
 
 public:
  static unsigned long GetTimeMs();
 
  void Update(bool recursive = false);
 
  virtual void Update(unsigned long currentTimeMs, bool recurse = false);
 
  static void UpdateThings(unsigned long currentTimeMs);
 
#pragma endregion Update
 
 public:
  virtual int GenerateBinary(char* buffer, unsigned char* ix);
  virtual void ProcessBinary(char* bytes);
};
 
}  // namespace RoboidControl