Merge pull request #10 from jwetzell/feat/lighting-encode

add support for encoding RTTrPL packets

src/encoders/index.ts

@@ -1,3 +1,8 @@
+import ChannelBlock from './lighting/channel-block';
+import LightingOutput from './lighting/lighting-output';
+import RTTrPL from './lighting/rttrpl';
+import Spot from './lighting/spot';
+import Universe from './lighting/universe';
 import CentroidAccelVelocity from './motion/centroid-accel-velocity';
 import CentroidPosition from './motion/centroid-position';
 import OrientationEuler from './motion/orientation-euler';
@@ -13,6 +18,7 @@ import RTTrPHeader from './rttrp-header';
 export const Encoders = {
   RTTrPHeader,
   RTTrPM,
+  RTTrPL,
   Trackable,
   CentroidPosition,
   OrientationQuaternion,
@@ -22,4 +28,8 @@ export const Encoders = {
   TrackedPointAccelVelocity,
   ZoneCollisionDetection,
   ZoneObject,
+  LightingOutput,
+  Universe,
+  Spot,
+  ChannelBlock,
 };

src/encoders/lighting/channel-block.ts

@@ -0,0 +1,13 @@
+export default (offset: number, fade: number, value: number, isLittleEndian: boolean = false): Uint8Array => {
+  const bytes = new Uint8Array(5);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+
+  let dataOffset = 0;
+  view.setUint16(dataOffset, offset, isLittleEndian);
+  dataOffset += 2;
+  view.setUint16(dataOffset, fade, isLittleEndian);
+  dataOffset += 2;
+  view.setUint8(dataOffset, value);
+
+  return bytes;
+};

src/encoders/lighting/lighting-output.ts

@@ -0,0 +1,36 @@
+export default (
+  sequence: number,
+  action: number,
+  holdTime: number,
+  universeModules: Uint8Array[],
+  isLittleEndian: boolean = false
+): Uint8Array => {
+  let totalLightingOutputModuleSize = 1 + 2 + 4 + 1 + 4 + 2;
+
+  universeModules.forEach((universeModule) => {
+    totalLightingOutputModuleSize += universeModule.byteLength;
+  });
+
+  const bytes = new Uint8Array(totalLightingOutputModuleSize);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+
+  let dataOffset = 0;
+  view.setUint8(dataOffset, 0x07);
+  dataOffset += 1;
+  view.setUint16(dataOffset, bytes.byteLength, isLittleEndian);
+  dataOffset += 2;
+  view.setUint32(dataOffset, sequence, isLittleEndian);
+  dataOffset += 4;
+  view.setUint8(dataOffset, action);
+  dataOffset += 1;
+  view.setUint32(dataOffset, holdTime, isLittleEndian);
+  dataOffset += 4;
+  view.setUint16(dataOffset, universeModules.length, isLittleEndian);
+  dataOffset += 2;
+
+  universeModules.forEach((universeModule) => {
+    bytes.set(universeModule, dataOffset);
+    dataOffset += universeModule.length;
+  });
+  return bytes;
+};

src/encoders/lighting/rttrpl.ts

@@ -0,0 +1,27 @@
+import RTTrPHeader from '../rttrp-header';
+
+export default (
+  packetId: number,
+  context: number,
+  lightingOutputs: Uint8Array[],
+  isLittleEndian: boolean = false
+): Uint8Array => {
+  let totalPacketSize = 18; //header size
+
+  lightingOutputs.forEach((lightingOutput) => {
+    totalPacketSize += lightingOutput.length;
+  });
+  const bytes = new Uint8Array(totalPacketSize);
+
+  let dataOffset = 0;
+
+  const headerBytes = RTTrPHeader(0x4434, 0x02, packetId, 0x00, context, lightingOutputs, isLittleEndian);
+
+  bytes.set(headerBytes, dataOffset);
+  dataOffset += headerBytes.length;
+  lightingOutputs.forEach((lightingOutput) => {
+    bytes.set(lightingOutput, dataOffset);
+    dataOffset += lightingOutput.length;
+  });
+  return bytes;
+};

src/encoders/lighting/spot.ts

@@ -0,0 +1,32 @@
+export default (
+  id: number,
+  offset: number,
+  channelBlockModules: Uint8Array[],
+  isLittleEndian: boolean = false
+): Uint8Array => {
+  let totalSpotModuleSize = 1 + 2 + 2 + 2 + 2;
+
+  channelBlockModules.forEach((channelBlockModule) => {
+    totalSpotModuleSize += channelBlockModule.byteLength;
+  });
+
+  const bytes = new Uint8Array(totalSpotModuleSize);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+
+  let dataOffset = 0;
+  view.setUint8(dataOffset, 0x0a);
+  dataOffset += 1;
+  view.setUint16(dataOffset, bytes.byteLength, isLittleEndian);
+  dataOffset += 2;
+  view.setUint16(dataOffset, id, isLittleEndian);
+  dataOffset += 2;
+  view.setUint16(dataOffset, offset, isLittleEndian);
+  dataOffset += 2;
+  view.setUint16(dataOffset, channelBlockModules.length, isLittleEndian);
+  dataOffset += 2;
+  channelBlockModules.forEach((channelBlockModule) => {
+    bytes.set(channelBlockModule, dataOffset);
+    dataOffset += channelBlockModule.length;
+  });
+  return bytes;
+};

src/encoders/lighting/universe.ts

@@ -0,0 +1,25 @@
+export default (id: number, spotModules: Uint8Array[], isLittleEndian: boolean = false): Uint8Array => {
+  let totalSpotModuleSize = 1 + 2 + 2 + 2;
+
+  spotModules.forEach((spotModule) => {
+    totalSpotModuleSize += spotModule.byteLength;
+  });
+
+  const bytes = new Uint8Array(totalSpotModuleSize);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+
+  let dataOffset = 0;
+  view.setUint8(dataOffset, 0x09);
+  dataOffset += 1;
+  view.setUint16(dataOffset, bytes.byteLength, isLittleEndian);
+  dataOffset += 2;
+  view.setUint16(dataOffset, id, isLittleEndian);
+  dataOffset += 2;
+  view.setUint16(dataOffset, spotModules.length, isLittleEndian);
+  dataOffset += 2;
+  spotModules.forEach((spotModule) => {
+    bytes.set(spotModule, dataOffset);
+    dataOffset += spotModule.length;
+  });
+  return bytes;
+};

tests/lighting-encode.test.js

@@ -0,0 +1,78 @@
+const { deepEqual, throws } = require('assert');
+const { describe, it } = require('node:test');
+const { Encoders } = require('../');
+
+const goodTests = [
+  {
+    description: 'RTTrPL + Lighting Output + Universe + Spot + Single Channel Block',
+    expected: new Uint8Array([
+      65, 84, 0x44, 0x34, 0, 2, 0, 0, 0, 1, 0, 0, 53, 18, 52, 86, 120, 1, 0x07, 0x00, 0x23, 0x00, 0x00, 0x00, 0x01,
+      0x01, 0x00, 0x00, 0x00, 0x64, 0x00, 0x01, 0x09, 0x00, 0x15, 0x12, 0x34, 0x00, 0x01, 0x0a, 0x00, 0x0e, 0x12, 0x34,
+      0x00, 0x01, 0x00, 0x01, 0x00, 0x08, 0x00, 0x06, 0x40,
+    ]),
+    bytes: () => {
+      return Encoders.RTTrPL(1, 0x12345678, [
+        Encoders.LightingOutput(1, 1, 100, [
+          Encoders.Universe(0x1234, [Encoders.Spot(0x1234, 1, [Encoders.ChannelBlock(8, 6, 64)])]),
+        ]),
+      ]);
+    },
+  },
+  {
+    description: 'Lighting Output + Universe + Spot + Single Channel Block',
+    expected: new Uint8Array([
+      0x07, 0x00, 0x23, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x64, 0x00, 0x01, 0x09, 0x00, 0x15, 0x12, 0x34,
+      0x00, 0x01, 0x0a, 0x00, 0x0e, 0x12, 0x34, 0x00, 0x01, 0x00, 0x01, 0x00, 0x08, 0x00, 0x06, 0x40,
+    ]),
+    bytes: () => {
+      return Encoders.LightingOutput(1, 1, 100, [
+        Encoders.Universe(0x1234, [Encoders.Spot(0x1234, 1, [Encoders.ChannelBlock(8, 6, 64)])]),
+      ]);
+    },
+  },
+  {
+    description: 'Universe + Spot + Single Channel Block',
+    expected: new Uint8Array([
+      0x09, 0x00, 0x15, 0x12, 0x34, 0x00, 0x01, 0x0a, 0x00, 0x0e, 0x12, 0x34, 0x00, 0x01, 0x00, 0x01, 0x00, 0x08, 0x00,
+      0x06, 0x40,
+    ]),
+    bytes: () => {
+      return Encoders.Universe(0x1234, [Encoders.Spot(0x1234, 1, [Encoders.ChannelBlock(8, 6, 64)])]);
+    },
+  },
+  {
+    description: 'Spot + Single Channel Block',
+    expected: new Uint8Array([0x0a, 0x00, 0x0e, 0x12, 0x34, 0x00, 0x01, 0x00, 0x01, 0x00, 0x08, 0x00, 0x06, 0x40]),
+    bytes: () => {
+      return Encoders.Spot(0x1234, 1, [Encoders.ChannelBlock(8, 6, 64)]);
+    },
+  },
+  {
+    description: 'Channel Block',
+    expected: new Uint8Array([0x00, 0x08, 0x00, 0x06, 0x40]),
+    bytes: () => {
+      return Encoders.ChannelBlock(8, 6, 64);
+    },
+  },
+];
+
+describe('RTTrPL Message Encoding', () => {
+  goodTests.forEach((messageTest) => {
+    it(messageTest.description, () => {
+      const actual = messageTest.bytes();
+      deepEqual(actual, messageTest.expected);
+    });
+  });
+});
+
+//TODO(jwetzell): add tests that handle errors
+const badTests = [];
+
+describe('RTTrPL Message Encoding Throws', () => {
+  badTests.forEach((messageTest) => {
+    it(messageTest.description, () => {
+      messageTest.bytes();
+      throws(() => {}, messageTest.throwsMessage);
+    });
+  });
+});