teleportxr 1.0.92 → 1.0.93

package/client/client.js

@@ -228,6 +228,9 @@ class Client {
 		this.setupCommand.int64_startTimestamp_utc_unix_us = BigInt(core.getStartTimeUnixUs());
 		if(this.scene)
 		{
+			// Tell the client which axes standard the server authored the scene in. Node transforms
+			// are converted to the client's own standard at encode time (see SendNode).
+			this.setupCommand.AxesStandard_axesStandard=this.scene.serverAxesStandard;
 			if(this.scene.backgroundTexturePath&&this.scene.backgroundTexturePath!="")
 			{
 				this.setupCommand.BackgroundMode_backgroundMode=BackgroundMode.TEXTURE;
@@ -550,7 +553,9 @@ class Client {
 		var node=this.scene.GetNode(uid);
 		const MAX_NODE_SIZE=500;
 		const buffer = new ArrayBuffer(MAX_NODE_SIZE);
-		const nodeSize=node_encoder.encodeNode(node,buffer);
+		// Convert the node's transform from the server's axes standard to this client's, exactly as
+		// the C++ server does in GeometryEncoder::encodeNodes (ConvertTransform server->client).
+		const nodeSize=node_encoder.encodeNode(node,buffer,this.scene.serverAxesStandard,this.clientAxesStandard);
 		const view2 = new DataView(buffer, 0, nodeSize);
 		if(!this.webRtcConnection)
 		{

package/core/core.js

@@ -200,6 +200,111 @@ function AxesStandardToCubemapSuffix(axesStandard)
 	}
 }
 
+// ---- Axes-standard conversions for object transforms ----
+// Ported from the C++ server (libavstream common_maths.h ConvertPosition/Rotation/Scale), which
+// converts each node's transform from the server's axes standard to the client's during encoding.
+// The C++ table only covers Unreal/Unity <-> Gl/Engineering (its server is engine-driven), so the
+// Engineering <-> GlStyle cases below are added here (both right-handed: position/quat vector part
+// maps as (x, z, -y); its inverse as (x, -z, y); scale permutes y/z).
+function ConvertPosition(from, to, p)
+{
+	const A = AxesStandard;
+	if (from === to) return { x: p.x, y: p.y, z: p.z };
+	if (from === A.UnrealStyle)
+	{
+		if (to === A.GlStyle)          return { x: +p.y, y: +p.z, z: -p.x };
+		if (to === A.EngineeringStyle) return { x: p.y, y: p.x, z: p.z };
+	}
+	else if (from === A.UnityStyle)
+	{
+		if (to === A.GlStyle)          return { x: p.x, y: p.y, z: -p.z };
+		if (to === A.EngineeringStyle) return { x: p.x, y: p.z, z: p.y };
+	}
+	else if (from === A.EngineeringStyle)
+	{
+		if (to === A.UnrealStyle)      return { x: p.y, y: p.x, z: p.z };
+		if (to === A.UnityStyle)       return { x: p.x, y: p.z, z: p.y };
+		if (to === A.GlStyle)          return { x: p.x, y: p.z, z: -p.y };	// added
+	}
+	else if (from === A.GlStyle)
+	{
+		if (to === A.UnrealStyle)      return { x: -p.z, y: +p.x, z: +p.y };
+		if (to === A.UnityStyle)       return { x: p.x, y: p.y, z: -p.z };
+		if (to === A.EngineeringStyle) return { x: p.x, y: -p.z, z: p.y };	// added
+	}
+	console.warn("ConvertPosition: unsupported axes "+from+"->"+to+"; leaving unchanged");
+	return { x: p.x, y: p.y, z: p.z };
+}
+
+function ConvertRotation(from, to, q)
+{
+	const A = AxesStandard;
+	if (from === to) return { x: q.x, y: q.y, z: q.z, w: q.w };
+	if (from === A.UnrealStyle)
+	{
+		if (to === A.GlStyle)          return { x: -q.y, y: -q.z, z: +q.x, w: q.w };
+		if (to === A.EngineeringStyle) return { x: -q.y, y: -q.x, z: -q.z, w: q.w };
+	}
+	else if (from === A.EngineeringStyle)
+	{
+		if (to === A.UnrealStyle)      return { x: -q.y, y: -q.x, z: -q.z, w: q.w };
+		if (to === A.UnityStyle)       return { x: -q.x, y: -q.z, z: -q.y, w: q.w };
+		if (to === A.GlStyle)          return { x: q.x, y: q.z, z: -q.y, w: q.w };	// added
+	}
+	else if (from === A.GlStyle)
+	{
+		if (to === A.UnrealStyle)      return { x: +q.z, y: -q.x, z: -q.y, w: q.w };
+		if (to === A.UnityStyle)       return { x: -q.x, y: -q.y, z: q.z, w: q.w };
+		if (to === A.EngineeringStyle) return { x: q.x, y: -q.z, z: q.y, w: q.w };	// added
+	}
+	else if (from === A.UnityStyle)
+	{
+		if (to === A.GlStyle)          return { x: -q.x, y: -q.y, z: q.z, w: q.w };
+		if (to === A.EngineeringStyle) return { x: -q.x, y: -q.z, z: -q.y, w: q.w };
+	}
+	console.warn("ConvertRotation: unsupported axes "+from+"->"+to+"; leaving unchanged");
+	return { x: q.x, y: q.y, z: q.z, w: q.w };
+}
+
+function ConvertScale(from, to, s)
+{
+	const A = AxesStandard;
+	if (from === to) return { x: s.x, y: s.y, z: s.z };
+	if (from === A.UnrealStyle)
+	{
+		if (to === A.GlStyle)          return { x: +s.y, y: +s.z, z: s.x };
+		if (to === A.EngineeringStyle) return { x: s.y, y: s.x, z: s.z };
+	}
+	else if (from === A.UnityStyle)
+	{
+		if (to === A.GlStyle)          return { x: s.x, y: s.y, z: s.z };
+		if (to === A.EngineeringStyle) return { x: s.x, y: s.z, z: s.y };
+	}
+	else if (from === A.EngineeringStyle)
+	{
+		if (to === A.UnrealStyle)      return { x: s.y, y: s.x, z: s.z };
+		if (to === A.UnityStyle)       return { x: s.x, y: s.z, z: s.y };
+		if (to === A.GlStyle)          return { x: s.x, y: s.z, z: s.y };	// added (abs of position map)
+	}
+	else if (from === A.GlStyle)
+	{
+		if (to === A.UnrealStyle)      return { x: s.z, y: +s.x, z: +s.y };
+		if (to === A.UnityStyle)       return { x: s.x, y: s.y, z: s.z };
+		if (to === A.EngineeringStyle) return { x: s.x, y: s.z, z: s.y };	// added
+	}
+	return { x: s.x, y: s.y, z: s.z };
+}
+
+//! Convert a {position, orientation, scale} pose from one axes standard to another.
+function ConvertPose(from, to, pose)
+{
+	return {
+		position:    ConvertPosition(from, to, pose.position),
+		orientation: ConvertRotation(from, to, pose.orientation),
+		scale:       ConvertScale(from, to, pose.scale || { x: 1, y: 1, z: 1 }),
+	};
+}
+
 const GeometryPayloadType =
 {
 	Invalid: 0,
@@ -460,7 +565,9 @@ function put_string(dataView, byteOffset, name) {
 
 module.exports = {
 	UID_SIZE, endian, SizeOfType, encodeIntoDataView, decodeFromDataView
-	, vec4, BackgroundMode, AxesStandard, AxesStandardToCubemapSuffix, GeometryPayloadType, DisplayInfo, RenderingFeatures, LightingMode, VideoCodec
+	, vec4, BackgroundMode, AxesStandard, AxesStandardToCubemapSuffix
+	, ConvertPosition, ConvertRotation, ConvertScale, ConvertPose
+	, GeometryPayloadType, DisplayInfo, RenderingFeatures, LightingMode, VideoCodec
 	, VideoConfig, ClientDynamicLighting, encodeToUint8Array, decodeFromUint8Array
 	, generateUid, getStartTimeUnixUs, getTimestampUs,
 	unixTimeToUTCString, put_float32, put_uint16, put_int32, put_uint32

package/package.json

@@ -16,7 +16,7 @@
   },
   "name": "teleportxr",
   "description": "Teleport Spatial Server on node.js",
-  "version": "1.0.92",
+  "version": "1.0.93",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/simul/teleport-nodejs.git"

package/protocol/encoders/node_encoder.js

@@ -13,13 +13,15 @@ function putPlaceholderSize(dataView)
 }
 
 // return the size of the encoded node.
-function encodeNode(node,buffer)
+// fromAxes/toAxes, when supplied, convert the node's transform from the server's axes standard to
+// the client's during encoding (matches the C++ server). Omit them to encode the pose unchanged.
+function encodeNode(node,buffer,fromAxes,toAxes)
 {
 	var byteOffset=0;
-	const dataView = new DataView(buffer); 
+	const dataView = new DataView(buffer);
 	byteOffset=putPlaceholderSize(dataView);
 
-	var t=node.encodeIntoDataView(dataView,byteOffset);
+	var t=node.encodeIntoDataView(dataView,byteOffset,fromAxes,toAxes);
 	byteOffset=t;
 	// Actual size is now known: write the count of bytes that follow the
 	// size field, in little-endian (the protocol convention). Without the

package/scene/node.js

@@ -308,7 +308,7 @@ class Node {
 		);
 		this.components.push(tc);
 	}
-	encodeIntoDataView(dataView, byteOffset) {
+	encodeIntoDataView(dataView, byteOffset, fromAxes, toAxes) {
 		byteOffset = core.put_uint8(
 			dataView,
 			byteOffset,
@@ -317,8 +317,19 @@ class Node {
 
 		byteOffset = core.put_uint64(dataView, byteOffset, this.uid);
 		byteOffset = core.put_string(dataView, byteOffset, this.name);
+		// Convert the node's transform into the client's axes standard (server -> client). When no
+		// conversion is requested, or the standards match, the pose is encoded unchanged.
 		var clientsidePose = this.pose;
-		
+		if (fromAxes !== undefined && toAxes !== undefined && fromAxes !== toAxes &&
+			toAxes !== core.AxesStandard.NotInitialized)
+		{
+			const c = core.ConvertPose(fromAxes, toAxes, this.pose);
+			clientsidePose = new Pose();
+			clientsidePose.position = c.position;
+			clientsidePose.orientation = c.orientation;
+			clientsidePose.scale = c.scale;
+		}
+
 		byteOffset = clientsidePose.encodeIntoDataView(dataView, byteOffset);
 		
 		byteOffset = core.put_uint8(dataView, byteOffset, this.stationary);

package/scene/scene.js

@@ -15,6 +15,10 @@ class Scene {
 		this.specularCubemapPath="";
 		this.assetsPath="assets";
 		this.publicPath="http_resources";
+		// The axes standard the scene (node poses, cubemaps) is authored in. Node transforms are
+		// converted from this to each client's axes standard when streamed. Z-up Engineering by
+		// default, matching the C++ client's native frame and the *_eng cubemap source.
+		this.serverAxesStandard=core.AxesStandard.EngineeringStyle;
 	}
 	GetOrCreateNode(uid) {
 		if (!this.nodes.has(uid)) {