teleportxr 1.0.0

package/protocol/message.js

@@ -0,0 +1,145 @@
+'use strict';
+const core= require("../core/core.js");
+const command= require("./command");
+
+function decodeFromDataView(obj,dataView,byteOffset){
+    for (let key of Object.keys(obj)) {
+        let first_underscore=key.search('_');
+        var name=key.substring(first_underscore+1,key.end);
+        var type=key.substring(0,first_underscore);
+        var [sz,tp]=SizeOfType(type);
+        if(tp=="uint8")
+        {
+            var value=dataView.getUint8(byteOffset);
+            Object.entries[key]=value;
+        }
+        else if(tp=="int8")
+        {
+            var value=dataView.getInt8(byteOffset);
+            Object.entries[key]=value;
+        }
+        else if(tp=="uint32")
+        {
+            var value=dataView.getUint32(byteOffset);
+            Object.entries[key]=value;
+        }
+        else if(tp=="int32")
+        {
+            var value=dataView.getInt32(byteOffset);
+            Object.entries[key]=value;
+        }
+        else if(tp=="float32")
+        {
+            var value=dataView.getFloat32(byteOffset);
+            Object.entries[key]=value;
+        }
+        else if(tp=="int64")
+        {
+            var value=dataView.getBigInt64(byteOffset);
+            Object.entries[key]=value;
+        }
+        else if(tp=="uint64")
+        {
+            var value=dataView.get4BigUint6(byteOffset);
+            Object.entries[key]=value;
+        }
+        else if(tp=="struct")
+        {
+            sz=decodeFromDataView(value,dataView,byteOffset)-byteOffset;
+        }
+        byteOffset+=sz;
+        console.log(byteOffset+": "+sz+" bytes\t\t"+tp+" "+name+" "+value.toString());
+    }
+    return byteOffset;
+}
+//! The payload type, or how to interpret the server's message.
+const MessagePayloadType =
+{									
+	Invalid:0,
+    Handshake:1,
+    NodeStatus:2,
+    ReceivedResources:3,
+    ControllerPoses:4,
+    ResourceLost:5,		//! Inform the server that client "lost" a previously confirmed resource, e.g. due to some bug or error. Should *rarely* be used.
+    InputStates:6,
+    InputEvents:7,
+    DisplayInfo:8,
+    KeyframeRequest:9,
+    PongForLatency:10,
+    OrthogonalAcknowledgement:11,
+    Acknowledgement:12	
+};
+
+/// A message sent from client to server: may be sent on a reliable or unreliable channel, including via the signaling protocol.
+class Message{
+	constructor(){
+        this.MessagePayloadType_messagePayloadType=MessagePayloadType.Invalid;
+        this.int64_timestamp=BigInt(0);
+    }
+}
+
+class HandshakeMessage extends Message
+{
+    constructor(){
+        super();
+        //   type=1 byte
+        this.MessagePayloadType_messagePayloadType=MessagePayloadType.Handshake;
+        this.int64_timestamp=BigInt(0);
+        this.DisplayInfo_startDisplayInfo = new core.DisplayInfo();
+        this.float32_MetresPerUnit = 1.0;
+        this.float32_FOV = 90.0;
+        this.uint32_udpBufferSize = 0;			// In kilobytes.
+        this.uint32_maxBandwidthKpS = 0;		// In kilobytes per second
+        this.AxesStandard_axesStandard = core.AxesStandard.NotInitialized;
+        this.uint8_framerate = 0;				// In hertz
+        this.bool_isVR = true;
+        this.uint64_resourceCount = 0;			//Count of resources the client has, which are appended to the handshake.
+        this.uint32_maxLightsSupported = 0;
+        this.int32_minimumPriority = 0;		// The lowest priority object this client will render, meshes with lower priority need not be sent.
+        this.RenderingFeatures_renderingFeatures=new core.RenderingFeatures();
+    }
+    static sizeof(){
+        return 58;
+    }
+    size(){
+        return HandshakeMessage.sizeof();
+    }
+};
+
+class ReceivedResourcesMessage extends Message
+{
+    constructor(){
+        super();
+        //   type=1 byte
+        this.MessagePayloadType_messagePayloadType=MessagePayloadType.ReceivedResources;
+		// timestamp 8 bytes.
+		// count 8 bytes
+        this.uint64_receivedResourcesCount=BigInt(0);
+		// = 17 + 8 * num resources.
+    }
+    static sizeof(){
+        return 17;
+    }
+    size(){
+        return ReceivedResourcesMessage.sizeof();
+    }
+};
+class AcknowledgementMessage extends Message
+{
+    constructor(){
+        super();
+        //   type=1 byte
+        this.MessagePayloadType_messagePayloadType=MessagePayloadType.Acknowledgement;
+		// timestamp 8 bytes.
+		// count 8 bytes
+        this.uint64_ackId=BigInt(0);
+		// = 17 bytes
+    }
+    static sizeof(){
+        return 17;
+    }
+    size() {
+        return AcknowledgementMessage.sizeof();
+    }
+};
+module.exports= {Message,MessagePayloadType,HandshakeMessage,ReceivedResourcesMessage,AcknowledgementMessage};

package/scene/material.js

@@ -0,0 +1,105 @@
+'use strict';
+const core= require('../core/core.js');
+const resources= require('./resources.js');
+
+const MaterialMode =
+{
+	UNKNOWNMODE:0,
+	OPAQUE_MATERIAL:1,
+	TRANSPARENT_MATERIAL:2
+};
+
+class MaterialTexture
+{
+	constructor(uid=0,texCoord=0,tile_x=1.0,tile_y=1.0)
+	{
+		this.textureUid = uid;
+		this.texCoord = texCoord;
+		this.tiling = {x:tile_x, y:tile_y};
+	}
+	encodeIntoDataView(dataView,byteOffset) {
+		byteOffset=core.put_uint64(dataView,byteOffset,this.textureUid);
+		byteOffset=core.put_uint8(dataView,byteOffset,this.texCoord);
+		byteOffset=core.put_float32(dataView,byteOffset,this.tiling.x);
+		byteOffset=core.put_float32(dataView,byteOffset,this.tiling.y);
+		return byteOffset;
+	}
+};
+
+class Material
+{
+	constructor(uid,name="")
+	{
+		this.uid=uid;
+		this.name=name;
+
+		this.materialMode = MaterialMode.OPAQUE_MATERIAL;
+		this.baseColorTexture=new MaterialTexture();
+		this.baseColorFactor = {x:1.0, y:1.0, z: 1.0, w: 1.0};
+		this.metallicRoughnessTexture=new MaterialTexture();
+		this.metallicFactor = 0.0;
+		this.roughnessMultiplier = 1.0;
+		this.roughnessOffset = 0.0;
+
+		this.normalTexture=new MaterialTexture();
+		this.normalTexture.scale = NextFloat;
+
+		this.occlusionTexture=new MaterialTexture();
+
+		this.emissiveTexture=new MaterialTexture();
+		this.emissiveFactor={x: 0.0, y: 0.0, z:0.0};
+
+		this.doubleSided = false;
+		this.lightmapTexCoordIndex = 0;
+
+		this.extensions = [];
+	}
+	encodeIntoDataView(dataView,byteOffset) {
+		
+		byteOffset=core.put_uint8(dataView,byteOffset,core.GeometryPayloadType.Material);
+		byteOffset=core.put_uint64(dataView,byteOffset,this.uid);
+		byteOffset=core.put_string(dataView,byteOffset,this.name);
+
+		byteOffset=core.put_uint8(dataView,byteOffset,this.materialMode);
+
+		byteOffset=this.baseColorTexture.encodeIntoDataView(dataView,byteOffset);
+		byteOffset=core.put_vec4(dataView,byteOffset,this.baseColorFactor);
+
+		byteOffset=this.metallicRoughnessTexture.encodeIntoDataView(dataView,byteOffset);
+
+		byteOffset=core.put_float32(dataView,byteOffset,this.metallicFactor);
+		byteOffset=core.put_float32(dataView,byteOffset,this.roughnessMultiplier);
+		byteOffset=core.put_float32(dataView,byteOffset,this.roughnessOffset);
+		
+		byteOffset=this.normalTexture.encodeIntoDataView(dataView,byteOffset);
+		// TODO make this depend on (renderingFeatures.normals)
+	
+		byteOffset=core.put_float32(dataView,byteOffset,1.0);
+
+
+		byteOffset=this.occlusionTexture.encodeIntoDataView(dataView,byteOffset);
+
+		byteOffset=core.put_float32(dataView,byteOffset,1.0);
+
+		byteOffset=this.emissiveTexture.encodeIntoDataView(dataView,byteOffset);
+
+		byteOffset=core.put_vec3(dataView,byteOffset,this.emissiveFactor);
+
+		byteOffset=core.put_uint8(dataView,byteOffset,this.doubleSided);
+		byteOffset=core.put_uint8(dataView,byteOffset,this.lightmapTexCoordIndex);
+
+		byteOffset=core.put_uint64(dataView,byteOffset,BigInt(0));
+	}
+	encodeToUint8Array(){
+		var array=new Uint8Array(this.size());
+		var dataView=new DataView(array.buffer);
+		this.encodeIntoDataView(dataView);
+		return array;
+	}
+	/*static sizeof() {
+		return 8+24+Pose.size+8;
+	}
+	size() {
+		return Node.sizeof();
+	}*/
+};

package/scene/node.js

@@ -0,0 +1,255 @@
+'use strict';
+const core= require('../core/core.js');
+const resources= require('./resources.js');
+//! The payload type, or how to interpret the server's message.
+const NodeDataType =
+{									
+	Invalid:0,		
+	None:1,
+	Mesh:2,
+	Light:3,
+	TextCanvas:4,
+	SubScene:5,
+	Skeleton:6,
+	Link:7,
+	Script:8
+};
+
+class Pose
+{
+    constructor()
+    {
+		this.orientation = { x:0.0, y:0.0, z:0.0, w:1.0 };
+		this.position = { x:0.0, y:0.0, z:0.0 };
+		this.scale = { x:1.0, y:1.0, z:1.0 };
+	}
+    static sizeof(){
+        return 4*4+(3*4)+(3*4);
+    }
+    size(){
+        return Pose.sizeof();
+    }
+	encodeIntoDataView(dataView,byteOffset) {
+		dataView.setFloat32(byteOffset+0,this.position.x,core.endian);
+		dataView.setFloat32(byteOffset+4,this.position.y,core.endian);
+		dataView.setFloat32(byteOffset+8,this.position.z,core.endian);
+		dataView.setFloat32(byteOffset+12,this.orientation.x,core.endian);
+		dataView.setFloat32(byteOffset+16,this.orientation.y,core.endian);
+		dataView.setFloat32(byteOffset+20,this.orientation.z,core.endian);
+		dataView.setFloat32(byteOffset+24,this.orientation.w,core.endian);
+		dataView.setFloat32(byteOffset+28,this.scale.x,core.endian);
+		dataView.setFloat32(byteOffset+32,this.scale.y,core.endian);
+		dataView.setFloat32(byteOffset+36,this.scale.z,core.endian);
+		return byteOffset+40;
+	}
+	encodeToUint8Array(){
+		var array=new Uint8Array(this.size());
+		var dataView=new DataView(array.buffer);
+		this.encodeIntoDataView(dataView);
+		return array;
+	}
+};
+class PoseDynamic
+{
+	constructor(){
+		this.pose=new Pose();
+		this.velocity={x:0.0, y:0.0, z:0.0 };
+		this.angularVelocity={x:0.0, y:0.0, z:0.0 };
+	}
+    static sizeof(){
+        return Pose.sizeof()+(3*4)+(3*4);
+    }
+    size(){
+        return PoseDynamic.sizeof();
+    }
+	encodeIntoDataView(dataView,byteOffset) {
+		dataView.setFloat32(byteOffset+0,this.position.x,core.endian);
+		dataView.setFloat32(byteOffset+4,this.position.y,core.endian);
+		dataView.setFloat32(byteOffset+8,this.position.z,core.endian);
+		dataView.setFloat32(byteOffset+12,this.orientation.x,core.endian);
+		dataView.setFloat32(byteOffset+16,this.orientation.y,core.endian);
+		dataView.setFloat32(byteOffset+20,this.orientation.z,core.endian);
+		dataView.setFloat32(byteOffset+24,this.orientation.w,core.endian);
+		dataView.setFloat32(byteOffset+28,this.scale.x,core.endian);
+		dataView.setFloat32(byteOffset+32,this.scale.y,core.endian);
+		dataView.setFloat32(byteOffset+36,this.scale.z,core.endian);
+
+		dataView.setFloat32(byteOffset+40,this.velocity.x,core.endian);
+		dataView.setFloat32(byteOffset+44,this.velocity.y,core.endian);
+		dataView.setFloat32(byteOffset+48,this.velocity.z,core.endian);
+		dataView.setFloat32(byteOffset+52,this.angularVelocity.x,core.endian);
+		dataView.setFloat32(byteOffset+56,this.angularVelocity.y,core.endian);
+		dataView.setFloat32(byteOffset+60,this.angularVelocity.z,core.endian);
+		return byteOffset+64;
+	}
+};
+
+
+class RenderState
+{
+    constructor(){
+        this.lightmapScaleOffset= { x:1.0, y:1.0, z:0.0, w:0.0 };
+		this.globalIlluminationUid=0;
+    }
+}
+
+class Component {
+    constructor()
+	{
+		this.uid=0;
+		this.data_uid=0;
+	}
+	getType(){
+		return NodeDataType.Invalid;
+	}
+}
+
+class MeshComponent extends Component
+{
+    constructor()
+    {
+		super();
+		this.skeletonNodeID=0;
+		this.renderState = new RenderState();
+		this.meshUrl="";
+    }
+	getType() {
+		return NodeDataType.Mesh;
+	}
+	encodeIntoDataView(dataView,byteOffset) {
+		byteOffset=core.put_uint8(dataView,byteOffset,NodeDataType.Mesh);
+
+		var resuid=resources.GetResourceUidFromUrl(core.GeometryPayloadType.MeshPointer,this.meshUrl);
+		byteOffset=core.put_uint64(dataView,byteOffset,resuid);
+
+		byteOffset=core.put_uint64(dataView,byteOffset,this.skeletonNodeID);
+
+		var num_joint_indices=0;
+		byteOffset=core.put_uint16(dataView,byteOffset,num_joint_indices);
+		for (var i =0;i<num_joint_indices;i++)
+		{
+			var index=this.joint_indices[i];
+			byteOffset=put_int16(dataView,byteOffset,index);
+		}
+
+		var num_animations=0;
+		byteOffset=core.put_uint16(dataView,byteOffset,num_animations);
+		for (var i =0;i<num_animations;i++)
+		{
+			byteOffset=core.put_uint64(dataView,byteOffset,this.animations[i]);
+		}
+		// If the node's priority is less than the *client's* minimum, we don't want
+		// to send its mesh.
+		
+		var num_materials=0;
+		byteOffset=core.put_uint16(dataView,byteOffset,num_materials);
+		for (var i =0;i<num_materials;i++)
+		{
+			byteOffset=core.put_uint64(dataView,byteOffset,this.materials[i]);
+		}
+		byteOffset=core.put_vec4(dataView,byteOffset,this.renderState.lightmapScaleOffset);
+		byteOffset=core.put_uint64(dataView,byteOffset,this.renderState.globalIlluminationUid);
+		
+		return byteOffset;
+	}
+};
+
+class SkeletonComponent extends Component
+{
+    constructor()
+    {
+		super();
+    }
+	getType(){
+		return NodeDataType.Skeleton;
+	}
+};
+
+class Node
+{
+    constructor(uid,name="")
+    {
+		this.uid=uid;
+		this.name=name;
+		this.pose=new Pose();
+		this.parent_uid=0;
+
+		this.holder_client_id=0;
+		this.stationary=true;
+
+		this.priority=0;
+
+		this.components = [];
+    }
+    static sizeof() {
+        return 8+24+Pose.size+8;
+    }
+    size() {
+        return Node.sizeof();
+    }
+	setMeshComponent(mesh_url) {
+		this.components.forEach(component => {
+			if(component.getType()==NodeDataType.Mesh) {
+				component.meshUrl=mesh_url;
+				component.data_uid=resources.GetResourceUidFromUrl(core.GeometryPayloadType.MeshPointer,mesh_url);
+				return;
+			}
+		});
+		var m=new MeshComponent();
+		m.meshUrl=mesh_url;
+		m.data_uid=resources.GetResourceUidFromUrl(core.GeometryPayloadType.MeshPointer,mesh_url);
+		this.components.push(m);
+	}
+	encodeIntoDataView(dataView,byteOffset) {
+		byteOffset=core.put_uint8(dataView,byteOffset,core.GeometryPayloadType.Node);
+
+		byteOffset=core.put_uint64(dataView,byteOffset,this.uid);
+		byteOffset=core.put_string(dataView,byteOffset,this.name);
+		var clientsidePose=this.pose;
+		//avs::ConvertTransform(serverSettings.serverAxesStandard, geometryStreamingService.getClientAxesStandard(), localTransform);
+		byteOffset=clientsidePose.encodeIntoDataView(dataView,byteOffset);
+		//put(node.localTransform);
+		byteOffset=core.put_uint8(dataView,byteOffset,this.stationary);
+		byteOffset=core.put_uint64(dataView,byteOffset,this.holder_client_id);
+		byteOffset=core.put_int32(dataView,byteOffset,this.priority);
+		byteOffset=core.put_uint64(dataView,byteOffset,this.parent_uid);
+
+		// Data components. Let's say 8 bits for number of components.
+		byteOffset=core.put_uint8(dataView,byteOffset,this.components.length);
+		for(var i=0;i<this.components.length;i++) {
+			byteOffset=this.components[i].encodeIntoDataView(dataView,byteOffset);
+		}
+		
+		return byteOffset;
+	/*
+		if (this.data_type ==NodeDataType.Light)
+		{
+			put(this.lightColour);
+			put(this.lightRadius);
+			put(this.lightRange);
+			vec3 lightDirection = this.lightDirection;
+			avs::ConvertPosition(serverSettings.serverAxesStandard, geometryStreamingService.getClientAxesStandard(), lightDirection);
+			put(lightDirection);
+			put(this.lightType);
+		}
+		if (this.data_type == avs::NodeDataType::TextCanvas)
+		{
+			// nothing this-specific to add at present.
+		}
+		if (this.data_type == avs::NodeDataType::Skeleton)
+		{
+		}
+		if (this.data_type == avs::NodeDataType::Link)
+		{
+			size_t urlLength = this.url.length();
+			put(urlLength);
+			put((uint8_t *)this.url.data(), urlLength);
+			size_t queryLength = this.query_url.length();
+			put(queryLength);
+			put((uint8_t *)this.query_url.data(), queryLength);
+
+		}*/
+	}
+};
+
+module.exports = {NodeDataType,Pose,PoseDynamic,Node };

package/scene/resources.js

@@ -0,0 +1,62 @@
+'use strict';
+const core= require('../core/core.js');
+
+/// Each resource has a url. If it's a local URL, the resource
+/// is stored here on the server. If not, it's a remotely stored resource,
+/// accessed by https.
+class Resource
+{
+	//! One trackedResources shared acrosss all clients.
+	static resourcesByUid=new Map();
+	static pathToUid=new Map();
+    constructor(type,uid,url)
+    {
+		this.uid=uid;
+		this.url=url;
+		this.type=type;
+	}
+	encodeIntoDataView(dataView,byteOffset) {
+		byteOffset=core.put_uint8(dataView,byteOffset,this.type);
+		byteOffset=core.put_uint64(dataView,byteOffset,this.uid);
+		byteOffset=core.put_string(dataView,byteOffset,this.url);
+		return byteOffset;
+	}
+}
+
+function GetResourceUidFromUrl(type,url)
+{
+	if(Resource.pathToUid.has(url))
+	{
+		var uid=Resource.pathToUid.get(url);
+		return uid;
+	}
+	var uid=core.generateUid();
+	Resource.resourcesByUid.set(uid,new Resource(type,uid,url));
+	Resource.pathToUid.set(url,uid);
+	return uid;
+}
+
+function GetResourceFromUrl(url)
+{
+	if(!Resource.pathToUid.has(url))
+		return null;
+	var uid=Resource.pathToUid.get(url);
+	if(uid==0)
+		return null;
+	var res=Resource.resourcesByUid.get(uid);
+	return res;
+}
+
+function GetResourceFromUid(uid)
+{
+	var res=Resource.resourcesByUid.get(uid);
+	return res;
+}
+
+//! Add the texture url as a resource.
+function AddTexture(url)
+{
+	GetResourceUidFromUrl(core.GeometryPayloadType.TexturePointer,url);
+}
+
+module.exports = {Resource,GetResourceFromUrl,GetResourceUidFromUrl,GetResourceFromUid,AddTexture};

package/scene/scene.js

@@ -0,0 +1,83 @@
+'use strict';
+const fs = require('fs');
+const nd = require('./node.js');
+const core = require('../core/core.js');
+const resources = require('./resources.js');
+const { error } = require('console');
+
+class Scene {
+	constructor() {
+		this.nodes = new Map();
+		this.backgroundTexturePath="";
+	}
+	GetOrCreateNode(uid) {
+		if (!this.nodes.has(uid)) {
+			this.nodes.set(uid, new nd.Node(uid));
+		}
+		var c = this.nodes.get(uid);
+		return c;
+	}
+	GetNode(uid) {
+		if (!this.nodes.has(uid)) {
+			return null;
+		}
+		var c = this.nodes.get(uid);
+		return c;
+	}
+	CreateNode(name) {
+		var uid = core.generateUid();
+		if (this.nodes.has(uid)) {
+			error("Uid " + uid + " already present.");
+		}
+		this.nodes.set(uid, new nd.Node(uid, name));
+		return uid;
+	}
+	GetAllNodeUids() {
+		let node_uids = Array.from(this.nodes.keys());
+		return node_uids;
+	}
+	//! Load an initial scene state from a json file.
+	Load(filename) {
+		const data = fs.readFileSync(filename, "utf8");
+		const j = JSON.parse(data);
+		console.log(j);
+		if(j.environment)
+		{
+			if(j.environment.background_texture)
+			{
+				this.backgroundTexturePath=j.environment.background_texture;
+				resources.AddTexture(this.backgroundTexturePath);
+			}
+		}
+		if(j.nodes)
+		{
+			const j_nodes=j.nodes;
+			for (let [key, sub_obj] of Object.entries(j_nodes)) {
+				var uid = this.CreateNode();
+				var n = this.GetNode(uid);
+				n.name = key;
+				const pose = sub_obj["pose"];
+				if (pose) {
+					n.pose.position = { x: pose.position[0], y: pose.position[1], z: pose.position[2] };
+					n.pose.orientation = { x: pose.orientation[0], y: pose.orientation[1], z: pose.orientation[2], w: pose.orientation[3] };
+				}
+				const components = sub_obj["components"];
+				if (components) {
+					for (let c of components) {
+						if (c["type"] == "mesh")
+							n.setMeshComponent(c["url"]);
+					}
+				}
+			}
+		}
+	}
+	writeState() {
+		var content="";
+		this.nodes.forEach(node => {
+			content=content+"Node "+node.uid+" " + node.name + "<br>";
+		});
+		return content;
+	}
+}
+
+module.exports = { Scene };

package/server.js

@@ -0,0 +1,35 @@
+'use strict';
+ 
+const WebRtcConnectionManager = require('./connections/webrtcconnectionmanager');
+const cm = require('./client/client_manager.js');
+
+const signaling=require("./signaling.js");
+const scene=require("./scene/scene.js");
+
+var sc=new scene.Scene();
+
+const fs = require('fs');
+const path = require('path');
+
+const assetsPath = path.join(__dirname,'assets');
+
+sc.Load(path.join(assetsPath,'scene.json'));
+
+// This is our app's callback for when a new client is to be created.
+// It must return the origin uid for the client.
+function createNewClient(clientID) {
+	var origin_uid=sc.CreateNode();
+	return origin_uid;
+}
+
+// This will be called AFTER a client has been created, so we can access it from the clientManager.
+function onClientPostCreate(clientID) {
+	var client=cm.getInstance().GetClient(clientID);
+	client.SetScene(sc);
+}
+
+const webRtcConnectionManager = WebRtcConnectionManager.getInstance();
+webRtcConnectionManager.SetSendConfigMessage(signaling.sendConfigMessage);
+cm.getInstance().SetNewClientCallback(createNewClient);
+cm.getInstance().SetClientPostCreationCallback(onClientPostCreate);
+signaling.init(webRtcConnectionManager,cm.getInstance().newClient.bind(cm.getInstance()));