326 lines
13 KiB
TypeScript
326 lines
13 KiB
TypeScript
import { is, fromJS, Dataflow, Dataspace, Double, Embedded, Ref, Schemas, Turn } from "@syndicate-lang/core";
|
|
import * as html from "@syndicate-lang/html";
|
|
import * as timer from "@syndicate-lang/timer";
|
|
import * as wsRelay from "@syndicate-lang/ws-relay";
|
|
import * as wakeDetector from './wake-detector.js';
|
|
import * as Shapes from './gen/shapes.js';
|
|
import * as SceneProtocol from './gen/scene.js';
|
|
import * as Tracking from './gen/tracking.js';
|
|
import { md5 } from './md5.js';
|
|
import { setupLog, log } from './log.js';
|
|
import G = Schemas.gatekeeper;
|
|
import T = Schemas.transportAddress;
|
|
|
|
import {
|
|
AbstractMesh,
|
|
Mesh,
|
|
Vector3,
|
|
} from '@babylonjs/core/Legacy/legacy';
|
|
|
|
import { activeFloorMeshes, activeTouchableMeshes, Environment, ShapeTree, buildSound, builder as B, u2, u3, u3v } from './shapes.js';
|
|
import { RunningEngine } from './engine.js';
|
|
import { uuid } from './uuid.js';
|
|
|
|
assertion type SceneHandle(ds: Embedded<Ref>);
|
|
|
|
function interpretScene(myId: string, runningEngine: RunningEngine, rootMesh: Mesh, sceneDs: Ref) {
|
|
at sceneDs {
|
|
during SceneProtocol.Gravity($direction: Shapes.LiteralVector3) => {
|
|
Turn.active.sync(sceneDs).then(() => {
|
|
console.log('enabling gravity');
|
|
runningEngine.applyGravity = true;
|
|
});
|
|
on stop {
|
|
console.log('disabling gravity');
|
|
runningEngine.applyGravity = false;
|
|
}
|
|
runningEngine.gravity = new Vector3(direction.x, direction.y, direction.z);
|
|
}
|
|
|
|
during Shapes.Sprite({ "name": $name: string, "formals": $formals }) => spawn named `sprite:${name}` {
|
|
if (name === myId) {
|
|
console.log('ignoring sprite', name);
|
|
} else {
|
|
console.log('+shape', name);
|
|
on stop console.log('-shape', name);
|
|
const env = new Environment(name, formals as symbol[], sceneDs);
|
|
spriteMain(env, runningEngine, rootMesh);
|
|
}
|
|
}
|
|
|
|
during SceneProtocol.AmbientSound({
|
|
"name": $name: string,
|
|
"spec": $spec: Shapes.SoundSpec
|
|
}) => spawn named `sound:${name}` {
|
|
const sound = buildSound(name, runningEngine.scene, spec, false);
|
|
on stop sound.dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
function spriteMain(env: Environment, runningEngine: RunningEngine, rootMesh: Mesh) {
|
|
at env.sceneDs {
|
|
let currentShape = ShapeTree.empty(env.spriteName, runningEngine.scene);
|
|
currentShape.rootnode.parent = rootMesh;
|
|
on stop currentShape.remove();
|
|
during Shapes.Sprite({ "name": env.spriteName, "shape": $shape: Shapes.Shape }) => {
|
|
currentShape = currentShape.reconcile(env, env.spriteName, shape);
|
|
currentShape.rootnode.parent = rootMesh;
|
|
}
|
|
}
|
|
}
|
|
|
|
async function enterScene(
|
|
routeField: Dataflow.Field<G.Route<Ref>>,
|
|
id: string,
|
|
runningEngine: RunningEngine,
|
|
ds: Ref,
|
|
sceneDs: Ref,
|
|
initialPosition: Vector3,
|
|
email: Dataflow.Field<string>,
|
|
) {
|
|
const currentSceneFacet = Turn.activeFacet;
|
|
|
|
console.log('enterScene', sceneDs);
|
|
|
|
const rootMesh = new Mesh('--root-' + (+new Date()), runningEngine.scene);
|
|
|
|
runningEngine.applyGravity = false;
|
|
runningEngine.camera.position = initialPosition.clone();
|
|
|
|
interpretScene(id, runningEngine, rootMesh, sceneDs);
|
|
|
|
let lastTouchTime = 0;
|
|
let lastTouchSpriteName = "";
|
|
runningEngine.onCollide = (other: AbstractMesh) => {
|
|
if (other.metadata?.touchable) {
|
|
const now = +new Date();
|
|
const touched = other.metadata?.spriteName ?? "";
|
|
if ((now - lastTouchTime > 500) || (lastTouchSpriteName !== touched)) {
|
|
currentSceneFacet.turn(() => {
|
|
at sceneDs {
|
|
send message SceneProtocol.Touch({
|
|
subject: id,
|
|
object: touched,
|
|
});
|
|
}
|
|
});
|
|
lastTouchTime = now;
|
|
lastTouchSpriteName = touched;
|
|
}
|
|
}
|
|
};
|
|
|
|
const TAU = 2 * Math.PI;
|
|
|
|
const currentPosition = () => u3(runningEngine.position);
|
|
const currentRotation = () => u3(runningEngine.rotation, 1/TAU);
|
|
|
|
field position: Shapes.ImmediateVector3 = currentPosition();
|
|
field rotation: Shapes.ImmediateVector3 = currentRotation();
|
|
|
|
const refreshPeriod = Double(1 / 10);
|
|
at ds {
|
|
on message timer.PeriodicTick(refreshPeriod) => {
|
|
const newPosition = currentPosition();
|
|
const newRotation = currentRotation();
|
|
if (!is(Shapes.fromImmediateVector3(position.value), Shapes.fromImmediateVector3(newPosition))) {
|
|
position.value = newPosition;
|
|
}
|
|
if (!is(Shapes.fromImmediateVector3(rotation.value), Shapes.fromImmediateVector3(newRotation))) {
|
|
rotation.value = newRotation;
|
|
}
|
|
}
|
|
}
|
|
|
|
at sceneDs {
|
|
on message SceneProtocol.Touch({ "subject": id, "object": $o }) => {
|
|
react {
|
|
let needStop = true;
|
|
on asserted SceneProtocol.Portal({
|
|
"name": o,
|
|
"destination": $dest: SceneProtocol.PortalDestination,
|
|
"position": $targetPosition: Shapes.LiteralVector3,
|
|
}) => {
|
|
const newPos = new Vector3(targetPosition.x,
|
|
targetPosition.y,
|
|
targetPosition.z)
|
|
.add(runningEngine.options.initialPos);
|
|
needStop = false;
|
|
switch (dest._variant) {
|
|
case "local":
|
|
if (dest.value === sceneDs) {
|
|
runningEngine.camera.position = newPos;
|
|
} else {
|
|
runningEngine.scene.removeMesh(rootMesh, true);
|
|
Turn.active.stop(currentSceneFacet, () => {
|
|
react {
|
|
enterScene(routeField,
|
|
id,
|
|
runningEngine,
|
|
ds,
|
|
dest.value,
|
|
newPos,
|
|
email);
|
|
}
|
|
});
|
|
}
|
|
break;
|
|
default:
|
|
console.log('jumping to remote portal', dest);
|
|
routeField.value = dest.value;
|
|
break;
|
|
}
|
|
}
|
|
const checkFacet = Turn.activeFacet;
|
|
Turn.active.sync(sceneDs).then(() => checkFacet.turn(() => {
|
|
if (needStop) {
|
|
stop {}
|
|
}
|
|
}));
|
|
}
|
|
}
|
|
|
|
const _POS = Symbol.for('pos');
|
|
const _HEAD = Symbol.for('head');
|
|
const _BODY = Symbol.for('body');
|
|
|
|
assert Shapes.Variable({ spriteName: id, variable: _POS, value: Shapes.fromImmediateVector3(position.value) });
|
|
assert Shapes.Variable({ spriteName: id, variable: _HEAD, value: Shapes.fromImmediateVector3(rotation.value) });
|
|
assert Shapes.Variable({ spriteName: id, variable: _BODY, value: Shapes.fromImmediateVector3({
|
|
x: Shapes.DoubleValue.immediate(0),
|
|
y: rotation.value.y,
|
|
z: Shapes.DoubleValue.immediate(0),
|
|
}) });
|
|
|
|
assert Shapes.Sprite({
|
|
name: id,
|
|
formals: [_POS, _HEAD, _BODY],
|
|
shape: B.nonphysical(
|
|
B.move(Shapes.Vector3.reference(_POS), B.many([
|
|
B.move(u3v({x: 0, y: -0.9, z: 0}),
|
|
B.rotate(Shapes.Vector3.reference(_BODY),
|
|
B.scale(u3v({x: 0.4, y: 1.4, z: 0.1}), B.box()))),
|
|
B.rotate(Shapes.Vector3.reference(_HEAD),
|
|
B.scale(u3v({x: 0.15, y: 0.23, z: 0.18}), B.many([
|
|
B.box(),
|
|
B.move(u3v({x: 0, y: 0, z: 0.501}),
|
|
B.texture(
|
|
Shapes.TextureSpec.uvAlpha({
|
|
path: `https://www.gravatar.com/avatar/${md5(new TextEncoder().encode(email.value.trim()))}?s=256&d=wavatar`,
|
|
scale: Shapes.Vector2.immediate(u2({ x:1, y:1 })),
|
|
offset: Shapes.Vector2.immediate(u2({ x:0, y:0 })),
|
|
alpha: Shapes.DoubleValue.immediate(1),
|
|
}),
|
|
B.rotate(u3v({ x: 0, y: 0.5, z: 0 }),
|
|
B.plane()))),
|
|
]))),
|
|
]))),
|
|
});
|
|
}
|
|
}
|
|
|
|
function wsurl(): string {
|
|
const scheme = (document.location.protocol.toLowerCase() === 'https:') ? 'wss' : 'ws';
|
|
return `${scheme}://${document.location.host}/ws`;
|
|
}
|
|
|
|
function bootApp(ds: Ref, runningEngine: RunningEngine) {
|
|
spawn named 'app' {
|
|
at ds {
|
|
const id = uuid();
|
|
|
|
const url = wsurl();
|
|
const relayAddr = T.WebSocket(url);
|
|
|
|
field email: string = localStorage.getItem('userEmail') ?? id;
|
|
const outerFacet = Turn.activeFacet;
|
|
const emailInput = document.getElementById('emailInput') as HTMLInputElement;
|
|
emailInput.value = email.value;
|
|
emailInput.addEventListener('keyup', () => outerFacet.turn(() => {
|
|
email.value = emailInput.value;
|
|
localStorage.setItem('userEmail', emailInput.value);
|
|
}));
|
|
|
|
field route: G.Route<Ref> = G.Route<Ref>({
|
|
"transports": [fromJS(relayAddr)],
|
|
"pathSteps": [],
|
|
});
|
|
|
|
during G.ResolvePath({
|
|
"route": route.value,
|
|
"control": $control_e: Embedded,
|
|
"resolved": G.Resolved.accepted($remoteDs_e: Embedded),
|
|
}) => {
|
|
const control = control_e.embeddedValue;
|
|
const remoteDs = remoteDs_e.embeddedValue;
|
|
|
|
setupLog(remoteDs, id, Symbol.for('vr-demo'));
|
|
log('connected');
|
|
|
|
on message wakeDetector.WakeEvent() => {
|
|
at control {
|
|
send message G.ForceDisconnect();
|
|
}
|
|
}
|
|
|
|
react {
|
|
at remoteDs {
|
|
stop on asserted SceneHandle($sceneDs_e: Embedded) => {
|
|
react {
|
|
at remoteDs {
|
|
const ms: { [key: number]: true } = {};
|
|
on message $m0(Tracking.Marker({ "camera": "cam1", "id": _ })) => {
|
|
const m = Tracking.asMarker(m0);
|
|
if (!(m.id in ms)) {
|
|
console.log('Spawning marker', m.id);
|
|
ms[m.id] = true;
|
|
spawn linked named ['marker', m.id] {
|
|
field current: Tracking.Marker<Ref> = m;
|
|
on stop { delete ms[m.id]; }
|
|
on message $m1(Tracking.Marker({
|
|
"camera": m.camera,
|
|
"id": m.id,
|
|
"rotation": _,
|
|
})) => {
|
|
current.value = Tracking.asMarker(m1);
|
|
}
|
|
at sceneDs_e.embeddedValue {
|
|
assert fromJS(current.value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
enterScene(route,
|
|
id,
|
|
runningEngine,
|
|
ds,
|
|
sceneDs_e.embeddedValue,
|
|
runningEngine.options.initialPos,
|
|
email);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
window.addEventListener('load', async () => {
|
|
const runningEngine = await RunningEngine.start({
|
|
floorMeshes: () => activeFloorMeshes,
|
|
touchableMeshes: () => activeTouchableMeshes,
|
|
});
|
|
(window as any).E = runningEngine;
|
|
Dataspace.boot(ds => {
|
|
html.boot(ds);
|
|
timer.boot(ds);
|
|
wsRelay.boot(ds, false);
|
|
wakeDetector.boot(ds);
|
|
bootApp(ds, runningEngine);
|
|
});
|
|
});
|