3esmessages.h

//
// author: Kazys Stepanas
//
#ifndef _3ESMESSAGES_H_
#define _3ESMESSAGES_H_

#include "3es-core.h"

#include "3espacketreader.h"
#include "3espacketwriter.h"

#include <cinttypes>
#include <cstring>

namespace tes
{
  enum MessageTypeIDs
  {
    MtNull,
    MtServerInfo,
    MtControl,
    MtCollatedPacket,

    // TODO: Move MtMesh and MtMaterial into a resources set.
    MtMesh,
    MtCamera,
    MtCategory,
    MtMaterial,

    ShapeHandlersIDStart = 64,
    UserIDStart = 2048
  };

  enum ShapeHandlerIDs
  {
    SIdSphere = ShapeHandlersIDStart,
    SIdBox,
    SIdCone,
    SIdCylinder,
    SIdCapsule,
    SIdPlane,
    SIdStar,
    SIdArrow,
    SIdMeshShape,
    SIdMeshSet,
    SIdPointCloud,
    SIdText3D,
    SIdText2D,

    SIdBuiltInLast = SIdText2D
  };

  enum ControlId
  {
    CIdNull,
    CIdFrame,           
    CIdCoordinateFrame, 
    CIdFrameCount,      
    CIdForceFrameFlush, 
    CIdReset,           
    CIdSnapshot,        
  };

  enum CategoryMessageId
  {
    CMIdName, 
  };

  enum ObjectMessageId
  {
    OIdNull,
    OIdCreate,
    OIdUpdate,
    OIdDestroy,
    OIdData
  };

  enum
  {
    OFNone = 0, 
    OFWire = (1 << 0), 
    OFTransparent = (1 << 1), 
    OFTwoSided = (1 << 2),  

    OFUpdateMode = (1 << 3),  
    OFPosition = (1 << 4),    
    OFRotation = (1 << 5),    
    OFScale = (1 << 6),       
    OFColour = (1 << 7),      
    OFColor = OFColour,       

    OFUser = (1 << 12)        
  };

  enum PointsAttributeFlag
  {
    PAFNone = 0,  
    PAFNormals = (1 << 0), 
    PAFColours = (1 << 1) 
  };

  enum Text2DFlag
  {
    Text2DFWorldSpace = OFUser  
  };

  enum Text3DFlag
  {
    Text3DFScreenFacing = OFUser  
  };

  enum MeshShapeFlag
  {
    MeshShapeCalculateNormals = OFUser  
  };

  enum UpdateFlag
  {
    UFNone = 0, 
    UFInterpolate = (1 << 0)
  };

  enum CollatedPacketFlag
  {
    CPFCompress = (1<<0),
  };

  enum ControlFlag
  {
    CFFramePersist = (1 << 0),
  };

  struct _3es_coreAPI ServerInfoMessage
  {
    uint64_t timeUnit;
    uint32_t defaultFrameTime;
    uint8_t coordinateFrame;
    uint8_t reserved[35];

    inline bool read(PacketReader &reader)
    {
      bool ok = true;
      ok = reader.readElement(timeUnit) == sizeof(timeUnit) && ok;
      ok = reader.readElement(coordinateFrame) == sizeof(coordinateFrame) && ok;
      ok = reader.readArray(reserved, sizeof(reserved) / sizeof(reserved[0])) == sizeof(reserved) / sizeof(reserved[0]) && ok;
      return ok;
    }

    inline bool write(PacketWriter &writer) const
    {
      bool ok = true;
      ok = writer.writeElement(timeUnit) == sizeof(timeUnit) && ok;
      ok = writer.writeElement(defaultFrameTime) == sizeof(defaultFrameTime) && ok;
      ok = writer.writeElement(coordinateFrame) == sizeof(coordinateFrame) && ok;
      ok = writer.writeArray(reserved, sizeof(reserved) / sizeof(reserved[0])) == sizeof(reserved) / sizeof(reserved[0]) && ok;
      return ok;
    }
  };

  void _3es_coreAPI initDefaultServerInfo(ServerInfoMessage *info);

  struct _3es_coreAPI ControlMessage
  {
    uint32_t controlFlags;
    uint32_t value32;
    uint64_t value64;

    inline bool read(PacketReader &reader)
    {
      bool ok = true;
      ok = reader.readElement(controlFlags) == sizeof(controlFlags) && ok;
      ok = reader.readElement(value32) == sizeof(value32) && ok;
      ok = reader.readElement(value64) == sizeof(value64) && ok;
      return ok;
    }

    inline bool write(PacketWriter &writer) const
    {
      bool ok = true;
      ok = writer.writeElement(controlFlags) == sizeof(controlFlags) && ok;
      ok = writer.writeElement(value32) == sizeof(value32) && ok;
      ok = writer.writeElement(value64) == sizeof(value64) && ok;
      return ok;
    }
  };

  struct _3es_coreAPI CategoryNameMessage
  {
    enum { MessageId = CMIdName };
    uint16_t categoryId;
    uint16_t parentId;
    uint16_t defaultActive;
    uint16_t nameLength;
    const char *name;

    inline bool read(PacketReader &reader, char *nameBuffer, size_t nameBufferSize)
    {
      bool ok = true;
      ok = reader.readElement(categoryId) == sizeof(categoryId) && ok;
      ok = reader.readElement(parentId) == sizeof(parentId) && ok;
      ok = reader.readElement(defaultActive) == sizeof(defaultActive) && ok;
      ok = reader.readElement(nameLength) == sizeof(nameLength) && ok;
      name = nameBuffer;

      if (!nameBuffer && nameLength || nameLength + 1 > nameBufferSize)
      {
        return false;
      }

      reader.readRaw((uint8_t *)nameBuffer, nameLength);
      nameBuffer[nameLength] = '\0';

      return ok;
    }

    inline bool write(PacketWriter &writer) const
    {
      bool ok = true;
      uint16_t nameLength = (uint16_t)((name) ? strlen(name) : 0);
      ok = writer.writeElement(categoryId) == sizeof(categoryId) && ok;
      ok = writer.writeElement(parentId) == sizeof(parentId) && ok;
      ok = writer.writeElement(defaultActive) == sizeof(defaultActive) && ok;
      ok = writer.writeElement(nameLength) == sizeof(nameLength) && ok;
      if (nameLength > 0)
      {
        if (name)
        {
          ok = writer.writeRaw((const uint8_t *)name, nameLength) == nameLength && ok;
        }
        else
        {
          ok = false;
        }
      }
      return ok;
    }
  };

  struct _3es_coreAPI CollatedPacketMessage
  {
    uint16_t flags;
    uint16_t reserved;
    uint32_t uncompressedBytes;

    inline bool read(PacketReader &reader)
    {
      bool ok = true;
      ok = reader.readElement(flags) == sizeof(flags) && ok;
      ok = reader.readElement(reserved) == sizeof(reserved) && ok;
      ok = reader.readElement(uncompressedBytes) == sizeof(uncompressedBytes) && ok;
      return ok;
    }

    inline bool write(PacketWriter &writer) const
    {
      bool ok = true;
      ok = writer.writeElement(flags) == sizeof(flags) && ok;
      ok = writer.writeElement(reserved) == sizeof(reserved) && ok;
      ok = writer.writeElement(uncompressedBytes) == sizeof(uncompressedBytes) && ok;
      return ok;
    }
  };

  struct _3es_coreAPI ObjectAttributes
  {
    uint32_t colour;    
    float position[3];  
    float rotation[4];  
    float scale[3];     

    inline void identity()
    {
      colour = 0xffffffffu;
      position[0] = position[1] = position[2] =
        rotation[0] = rotation[1] = rotation[2] = 0.0f;
      rotation[3] = 1.0f;
      scale[0] = scale[1] = scale[2] = 1.0f;
    }

    inline bool read(PacketReader &reader)
    {
      bool ok = true;
      ok = reader.readElement(colour) == sizeof(colour) && ok;
      ok = reader.readArray(&position[0], 3) == 3 && ok;
      ok = reader.readArray(&rotation[0], 4) == 4 && ok;
      ok = reader.readArray(&scale[0], 3) == 3 && ok;
      return ok;
    }

    inline bool write(PacketWriter &writer) const
    {
      bool ok = true;
      ok = writer.writeElement(colour) == sizeof(colour) && ok;
      ok = writer.writeArray(&position[0], 3) == 3 && ok;
      ok = writer.writeArray(&rotation[0], 4) == 4 && ok;
      ok = writer.writeArray(&scale[0], 3) == 3 && ok;
      return ok;
    }
  };

  struct _3es_coreAPI CreateMessage
  {
    enum { MessageId = OIdCreate };

    uint32_t id;        
    uint16_t category;  
    uint16_t flags;     
    uint16_t reserved;  
    ObjectAttributes attributes;  

    inline bool read(PacketReader &reader)
    {
      bool ok = true;
      ok = reader.readElement(id) == sizeof(id) && ok;
      ok = reader.readElement(category) == sizeof(category) && ok;
      ok = reader.readElement(flags) == sizeof(flags) && ok;
      ok = reader.readElement(reserved) == sizeof(reserved) && ok;
      ok = attributes.read(reader) && ok;
      return ok;
    }

    inline bool write(PacketWriter &writer) const
    {
      bool ok = true;
      ok = writer.writeElement(id) == sizeof(id) && ok;
      ok = writer.writeElement(category) == sizeof(category) && ok;
      ok = writer.writeElement(flags) == sizeof(flags) && ok;
      ok = writer.writeElement(reserved) == sizeof(reserved) && ok;
      ok = attributes.write(writer) && ok;
      return ok;
    }
  };

  struct _3es_coreAPI DataMessage
  {
    enum { MessageId = OIdData };

    uint32_t id;        

    inline bool read(PacketReader &reader)
    {
      bool ok = true;
      ok = reader.readElement(id) == sizeof(id) && ok;
      return ok;
    }

    inline bool write(PacketWriter &writer) const
    {
      bool ok = true;
      ok = writer.writeElement(id) == sizeof(id) && ok;
      return ok;
    }
  };

  struct _3es_coreAPI UpdateMessage
  {
    enum { MessageId = OIdUpdate };

    uint32_t id;        
    uint16_t flags;     
    ObjectAttributes attributes;  

    inline bool read(PacketReader &reader)
    {
      bool ok = true;
      ok = reader.readElement(id) == sizeof(id) && ok;
      ok = reader.readElement(flags) == sizeof(flags) && ok;
      ok = attributes.read(reader) && ok;
      return ok;
    }

    inline bool write(PacketWriter &writer) const
    {
      bool ok = true;
      ok = writer.writeElement(id) == sizeof(id) && ok;
      ok = writer.writeElement(flags) == sizeof(flags) && ok;
      ok = attributes.write(writer) && ok;
      return ok;
    }
  };

  struct _3es_coreAPI DestroyMessage
  {
    enum { MessageId = OIdDestroy };

    uint32_t id;        

    inline bool read(PacketReader &reader)
    {
      bool ok = true;
      ok = reader.readElement(id) == sizeof(id) && ok;
      return ok;
    }

    inline bool write(PacketWriter &writer) const
    {
      bool ok = true;
      ok = writer.writeElement(id) == sizeof(id) && ok;
      return ok;
    }
  };
}

#endif // _3ESMESSAGES_H_