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:
  struct Type {
    static const unsigned char Undetermined = 0x00;
    // Sensor
    static const unsigned char Switch = 0x01;
    static const unsigned char DistanceSensor = 0x02;
    static const unsigned char DirectionalSensor = 0x03;
    static const unsigned char TemperatureSensor = 0x04;
    static const unsigned char TouchSensor = 0x05;
    // Motor
    static const unsigned char ControlledMotor = 0x06;
    static const unsigned char UncontrolledMotor = 0x07;
    static const unsigned char Servo = 0x08;
    static const unsigned char RelativeEncoder = 0x19;
    // Other
    static const unsigned char Root = 0x10;
    static const unsigned char Roboid = 0x09;
    static const unsigned char Humanoid = 0x0A;
    static const unsigned char ExternalSensor = 0x08;
    static const unsigned char Animator = 0x0C;
    static const unsigned char DifferentialDrive = 0x0D;
  };
 
#pragma region Init
 
 private:
 public:
  Thing(Thing* parent = LocalRoot());
 
 private:
  Thing(Participant* owener);
 
 public:
  ~Thing();
 
  static void CreateRoot(Participant* owner);
 
  static Thing* LocalRoot();
 
#pragma endregion Init
 
 public:
  bool terminate = false;
 
#pragma region Properties
 
 public:
  unsigned char id = 0;
 
  unsigned char type = Type::Undetermined;
 
  Participant* owner = nullptr;
 
  const char* name = nullptr;
 
  void SetName(const char* name);
  const char* GetName() const;
  bool nameChanged = false;
 
  void SetModel(const char* url);
 
  const char* modelUrl = nullptr;
 
#pragma endregion Properties
 
#pragma region Hierarchy
 
  void SetParent(Thing* parent);
  Thing* GetParent();
 
  bool IsRoot() const;
 
  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:
  virtual void PrepareForUpdate();
 
  virtual void Update(bool recurse = false);
 
  static unsigned long GetTimeMs();
 
#pragma endregion Update
 
 public:
  virtual int GenerateBinary(char* buffer, unsigned char* ix);
  virtual void ProcessBinary(char* bytes);
};
 
}  // namespace RoboidControl