@hla4ts/spacefom 0.1.0

package/src/spacefom-encoding.ts

@@ -0,0 +1,261 @@
+const FLOAT64_SIZE = 8;
+const INT16_SIZE = 2;
+const HLA_COUNT_SIZE = 4;
+
+function assertLength(data: Uint8Array, expected: number, label: string): void {
+  if (data.length !== expected) {
+    throw new Error(`${label}: expected ${expected} bytes, got ${data.length}`);
+  }
+}
+
+function assertFloat64ArrayLength(data: Uint8Array, expected: number, label: string): void {
+  if (data.length !== expected * FLOAT64_SIZE) {
+    throw new Error(
+      `${label}: expected ${expected * FLOAT64_SIZE} bytes (${expected} float64 values), got ${data.length}`
+    );
+  }
+}
+
+export function encodeFloat64LE(value: number): Uint8Array {
+  const buffer = new ArrayBuffer(FLOAT64_SIZE);
+  const view = new DataView(buffer);
+  view.setFloat64(0, value, true);
+  return new Uint8Array(buffer);
+}
+
+export function decodeFloat64LE(data: Uint8Array): number {
+  assertLength(data, FLOAT64_SIZE, "HLAfloat64LE");
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  return view.getFloat64(0, true);
+}
+
+export function encodeScalar(value: number): Uint8Array {
+  return encodeFloat64LE(value);
+}
+
+export function decodeScalar(data: Uint8Array): number {
+  return decodeFloat64LE(data);
+}
+
+export function encodeInt16LE(value: number): Uint8Array {
+  const buffer = new ArrayBuffer(INT16_SIZE);
+  const view = new DataView(buffer);
+  view.setInt16(0, value, true);
+  return new Uint8Array(buffer);
+}
+
+export function decodeInt16LE(data: Uint8Array): number {
+  assertLength(data, INT16_SIZE, "HLAinteger16LE");
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  return view.getInt16(0, true);
+}
+
+export function encodeHLAunicodeString(value: string): Uint8Array {
+  const length = value.length;
+  const buffer = new ArrayBuffer(HLA_COUNT_SIZE + length * 2);
+  const view = new DataView(buffer);
+  view.setUint32(0, length, false);
+  for (let i = 0; i < length; i += 1) {
+    view.setUint16(HLA_COUNT_SIZE + i * 2, value.charCodeAt(i), false);
+  }
+  return new Uint8Array(buffer);
+}
+
+export function decodeHLAunicodeString(data: Uint8Array): string {
+  if (data.length < HLA_COUNT_SIZE) {
+    throw new Error("HLAunicodeString: insufficient data");
+  }
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const length = view.getUint32(0, false);
+  const expected = HLA_COUNT_SIZE + length * 2;
+  if (data.length !== expected) {
+    throw new Error(`HLAunicodeString: expected ${expected} bytes, got ${data.length}`);
+  }
+  let result = "";
+  for (let i = 0; i < length; i += 1) {
+    result += String.fromCharCode(view.getUint16(HLA_COUNT_SIZE + i * 2, false));
+  }
+  return result;
+}
+
+
+function encodeFloat64Array(values: number[], expectedLength: number, label: string): Uint8Array {
+  if (values.length !== expectedLength) {
+    throw new Error(`${label}: expected ${expectedLength} values, got ${values.length}`);
+  }
+  const buffer = new ArrayBuffer(values.length * FLOAT64_SIZE);
+  const view = new DataView(buffer);
+  for (let i = 0; i < values.length; i += 1) {
+    view.setFloat64(i * FLOAT64_SIZE, values[i], true);
+  }
+  return new Uint8Array(buffer);
+}
+
+function decodeFloat64Array(data: Uint8Array, expectedLength: number, label: string): number[] {
+  assertFloat64ArrayLength(data, expectedLength, label);
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const values = new Array<number>(expectedLength);
+  for (let i = 0; i < expectedLength; i += 1) {
+    values[i] = view.getFloat64(i * FLOAT64_SIZE, true);
+  }
+  return values;
+}
+
+export type Vector3 = [number, number, number];
+export type Matrix3 = [number, number, number, number, number, number, number, number, number];
+
+export interface AttitudeQuaternion {
+  scalar: number;
+  vector: Vector3;
+}
+
+export interface ReferenceFrameTranslation {
+  position: Vector3;
+  velocity: Vector3;
+}
+
+export interface ReferenceFrameRotation {
+  attitude: AttitudeQuaternion;
+  angularVelocity: Vector3;
+}
+
+export interface SpaceTimeCoordinateState {
+  translation: ReferenceFrameTranslation;
+  rotation: ReferenceFrameRotation;
+  time: number;
+}
+
+export function encodeVector3(values: Vector3): Uint8Array {
+  return encodeFloat64Array(values, 3, "Vector3");
+}
+
+export function decodeVector3(data: Uint8Array): Vector3 {
+  const values = decodeFloat64Array(data, 3, "Vector3");
+  return [values[0], values[1], values[2]];
+}
+
+export function encodeMatrix3(values: Matrix3): Uint8Array {
+  return encodeFloat64Array(values, 9, "Matrix3");
+}
+
+export function decodeMatrix3(data: Uint8Array): Matrix3 {
+  const values = decodeFloat64Array(data, 9, "Matrix3");
+  return [
+    values[0],
+    values[1],
+    values[2],
+    values[3],
+    values[4],
+    values[5],
+    values[6],
+    values[7],
+    values[8],
+  ];
+}
+
+export function encodeAttitudeQuaternion(value: AttitudeQuaternion): Uint8Array {
+  return encodeFloat64Array(
+    [value.scalar, value.vector[0], value.vector[1], value.vector[2]],
+    4,
+    "AttitudeQuaternion"
+  );
+}
+
+export function decodeAttitudeQuaternion(data: Uint8Array): AttitudeQuaternion {
+  const values = decodeFloat64Array(data, 4, "AttitudeQuaternion");
+  return {
+    scalar: values[0],
+    vector: [values[1], values[2], values[3]],
+  };
+}
+
+export function encodeReferenceFrameTranslation(value: ReferenceFrameTranslation): Uint8Array {
+  return encodeFloat64Array(
+    [
+      value.position[0],
+      value.position[1],
+      value.position[2],
+      value.velocity[0],
+      value.velocity[1],
+      value.velocity[2],
+    ],
+    6,
+    "ReferenceFrameTranslation"
+  );
+}
+
+export function decodeReferenceFrameTranslation(data: Uint8Array): ReferenceFrameTranslation {
+  const values = decodeFloat64Array(data, 6, "ReferenceFrameTranslation");
+  return {
+    position: [values[0], values[1], values[2]],
+    velocity: [values[3], values[4], values[5]],
+  };
+}
+
+export function encodeReferenceFrameRotation(value: ReferenceFrameRotation): Uint8Array {
+  return encodeFloat64Array(
+    [
+      value.attitude.scalar,
+      value.attitude.vector[0],
+      value.attitude.vector[1],
+      value.attitude.vector[2],
+      value.angularVelocity[0],
+      value.angularVelocity[1],
+      value.angularVelocity[2],
+    ],
+    7,
+    "ReferenceFrameRotation"
+  );
+}
+
+export function decodeReferenceFrameRotation(data: Uint8Array): ReferenceFrameRotation {
+  const values = decodeFloat64Array(data, 7, "ReferenceFrameRotation");
+  return {
+    attitude: {
+      scalar: values[0],
+      vector: [values[1], values[2], values[3]],
+    },
+    angularVelocity: [values[4], values[5], values[6]],
+  };
+}
+
+export function encodeSpaceTimeCoordinateState(value: SpaceTimeCoordinateState): Uint8Array {
+  return encodeFloat64Array(
+    [
+      value.translation.position[0],
+      value.translation.position[1],
+      value.translation.position[2],
+      value.translation.velocity[0],
+      value.translation.velocity[1],
+      value.translation.velocity[2],
+      value.rotation.attitude.scalar,
+      value.rotation.attitude.vector[0],
+      value.rotation.attitude.vector[1],
+      value.rotation.attitude.vector[2],
+      value.rotation.angularVelocity[0],
+      value.rotation.angularVelocity[1],
+      value.rotation.angularVelocity[2],
+      value.time,
+    ],
+    14,
+    "SpaceTimeCoordinateState"
+  );
+}
+
+export function decodeSpaceTimeCoordinateState(data: Uint8Array): SpaceTimeCoordinateState {
+  const values = decodeFloat64Array(data, 14, "SpaceTimeCoordinateState");
+  return {
+    translation: {
+      position: [values[0], values[1], values[2]],
+      velocity: [values[3], values[4], values[5]],
+    },
+    rotation: {
+      attitude: {
+        scalar: values[6],
+        vector: [values[7], values[8], values[9]],
+      },
+      angularVelocity: [values[10], values[11], values[12]],
+    },
+    time: values[13],
+  };
+}

package/src/spacefom-presets.ts

@@ -0,0 +1,58 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import type { FomModuleSet } from "@hla4ts/hla-api";
+
+export const SpaceFomBaseModules = [
+  "datatypes",
+  "entity",
+  "environment",
+  "management",
+  "switches",
+] as const;
+
+export type SpaceFomBaseModuleName = (typeof SpaceFomBaseModules)[number];
+export type SpaceFomModuleFormat = "inline" | "file";
+
+const SPACEFOM_MODULE_FILES: Record<SpaceFomBaseModuleName, string> = {
+  datatypes: "SISO_SpaceFOM_datatypes.xml",
+  entity: "SISO_SpaceFOM_entity.xml",
+  environment: "SISO_SpaceFOM_environment.xml",
+  management: "SISO_SpaceFOM_management.xml",
+  switches: "SISO_SpaceFOM_switches.xml",
+};
+
+export interface SpaceFomModuleLoadOptions {
+  modules?: SpaceFomBaseModuleName[];
+  format?: SpaceFomModuleFormat;
+}
+
+function resolveSpaceFomModulePath(name: SpaceFomBaseModuleName): string {
+  const baseDir = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(baseDir, "..", "spacefom", SPACEFOM_MODULE_FILES[name]);
+}
+
+export async function loadSpaceFomModules(
+  options: SpaceFomModuleLoadOptions = {}
+): Promise<FomModuleSet> {
+  const modules = options.modules ?? [...SpaceFomBaseModules];
+  const format = options.format ?? "inline";
+  const result: FomModuleSet = [];
+
+  for (const moduleName of modules) {
+    const modulePath = resolveSpaceFomModulePath(moduleName);
+    if (format === "file") {
+      const content = await fs.readFile(modulePath);
+      result.push({
+        type: "file",
+        name: path.basename(modulePath),
+        content: new Uint8Array(content),
+      });
+    } else {
+      const content = await fs.readFile(modulePath, "utf8");
+      result.push({ type: "inline", content });
+    }
+  }
+
+  return result;
+}