@iwsdk/core 0.1.0

package/dist/locomotion/materials/line.js

@@ -0,0 +1,307 @@
+import '../../runtime/three.js';
+import { Vector3, Color, UniformsLib, UniformsUtils, ShaderLib, ShaderMaterial } from 'three';
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+// @ts-ignore
+UniformsLib.linee = {
+    linewidth: { value: 1 },
+    color: { value: new Color(0xffffff) },
+    startPoint: { value: new Vector3() },
+    endPoint: { value: new Vector3() },
+};
+ShaderLib['linee'] = {
+    uniforms: UniformsUtils.merge([
+        UniformsLib.common,
+        UniformsLib.fog,
+        // @ts-ignore
+        UniformsLib.linee,
+    ]),
+    vertexShader: /* glsl */ `
+		#include <common>
+		#include <color_pars_vertex>
+		#include <fog_pars_vertex>
+		#include <logdepthbuf_pars_vertex>
+		#include <clipping_planes_pars_vertex>
+
+		uniform float linewidth;
+		uniform vec3 startPoint;
+		uniform vec3 endPoint;
+		varying float vDistanceAlpha;
+
+		attribute vec3 instanceStart;
+		attribute vec3 instanceEnd;
+
+		attribute vec3 instanceColorStart;
+		attribute vec3 instanceColorEnd;
+
+		varying vec4 worldPos;
+		varying vec3 worldStart;
+		varying vec3 worldEnd;
+
+		void trimSegment( const in vec4 start, inout vec4 end ) {
+
+			// trim end segment so it terminates between the camera plane and the near plane
+
+			// conservative estimate of the near plane
+			float a = projectionMatrix[ 2 ][ 2 ]; // 3nd entry in 3th column
+			float b = projectionMatrix[ 3 ][ 2 ]; // 3nd entry in 4th column
+			float nearEstimate = - 0.5 * b / a;
+
+			float alpha = ( nearEstimate - start.z ) / ( end.z - start.z );
+
+			end.xyz = mix( start.xyz, end.xyz, alpha );
+
+		}
+
+		void main() {
+
+			#ifdef USE_COLOR
+
+				vColor.xyz = ( position.y < 0.5 ) ? instanceColorStart : instanceColorEnd;
+
+			#endif
+
+			// camera space
+			vec4 start = modelViewMatrix * vec4( instanceStart, 1.0 );
+			vec4 end = modelViewMatrix * vec4( instanceEnd, 1.0 );
+
+
+			worldStart = start.xyz;
+			worldEnd = end.xyz;
+
+			vec3 currentPosition = (position.y < 0.5) ? instanceStart : instanceEnd;
+    	float distanceToStart = length(currentPosition - startPoint);
+			float startAlpha = smoothstep(0.0, 0.8, distanceToStart);
+    	float distanceToEnd = length(currentPosition - endPoint);
+			float endAlpha = smoothstep(0.5, 2.0, distanceToEnd);
+    	// Compute vDistanceAlpha using smoothstep
+    	vDistanceAlpha = min(startAlpha, endAlpha);
+			
+
+			// special case for perspective projection, and segments that terminate either in, or behind, the camera plane
+			// clearly the gpu firmware has a way of addressing this issue when projecting into ndc space
+			// but we need to perform ndc-space calculations in the shader, so we must address this issue directly
+			// perhaps there is a more elegant solution -- WestLangley
+
+			bool perspective = ( projectionMatrix[ 2 ][ 3 ] == - 1.0 ); // 4th entry in the 3rd column
+
+			if ( perspective ) {
+
+				if ( start.z < 0.0 && end.z >= 0.0 ) {
+
+					trimSegment( start, end );
+
+				} else if ( end.z < 0.0 && start.z >= 0.0 ) {
+
+					trimSegment( end, start );
+
+				}
+
+			}
+
+			// clip space
+			vec4 clipStart = projectionMatrix * start;
+			vec4 clipEnd = projectionMatrix * end;
+
+			// ndc space
+			vec3 ndcStart = clipStart.xyz / clipStart.w;
+			vec3 ndcEnd = clipEnd.xyz / clipEnd.w;
+
+			// direction
+			vec2 dir = ndcEnd.xy - ndcStart.xy;
+			dir = normalize( dir );
+
+			vec3 worldDir = normalize( end.xyz - start.xyz );
+			vec3 tmpFwd = normalize( mix( start.xyz, end.xyz, 0.5 ) );
+			vec3 worldUp = normalize( cross( worldDir, tmpFwd ) );
+			vec3 worldFwd = cross( worldDir, worldUp );
+			worldPos = position.y < 0.5 ? start: end;
+
+			// height offset
+			float hw = linewidth * 0.5;
+			worldPos.xyz += position.x < 0.0 ? hw * worldUp : - hw * worldUp;
+
+			// don't extend the line if we're rendering dashes because we
+			// won't be rendering the endcaps
+
+			// cap extension
+			worldPos.xyz += position.y < 0.5 ? - hw * worldDir : hw * worldDir;
+
+			// add width to the box
+			worldPos.xyz += worldFwd * hw;
+
+			// endcaps
+			if ( position.y > 1.0 || position.y < 0.0 ) {
+
+				worldPos.xyz -= worldFwd * 2.0 * hw;
+
+			}
+
+
+			// project the worldpos
+			vec4 clip = projectionMatrix * worldPos;
+
+			// shift the depth of the projected points so the line
+			// segments overlap neatly
+			vec3 clipPose = ( position.y < 0.5 ) ? ndcStart : ndcEnd;
+			clip.z = clipPose.z * clip.w;
+
+			gl_Position = clip;
+
+			vec4 mvPosition = ( position.y < 0.5 ) ? start : end; // this is an approximation
+
+			#include <logdepthbuf_vertex>
+			#include <clipping_planes_vertex>
+			#include <fog_vertex>
+
+		}
+		`,
+    fragmentShader: /* glsl */ `
+		uniform float linewidth;
+
+		varying vec4 worldPos;
+		varying vec3 worldStart;
+		varying vec3 worldEnd;
+		varying float vDistanceAlpha;
+
+		#include <common>
+		#include <color_pars_fragment>
+		#include <fog_pars_fragment>
+		#include <logdepthbuf_pars_fragment>
+		#include <clipping_planes_pars_fragment>
+
+		vec2 closestLineToLine(vec3 p1, vec3 p2, vec3 p3, vec3 p4) {
+
+			float mua;
+			float mub;
+
+			vec3 p13 = p1 - p3;
+			vec3 p43 = p4 - p3;
+
+			vec3 p21 = p2 - p1;
+
+			float d1343 = dot( p13, p43 );
+			float d4321 = dot( p43, p21 );
+			float d1321 = dot( p13, p21 );
+			float d4343 = dot( p43, p43 );
+			float d2121 = dot( p21, p21 );
+
+			float denom = d2121 * d4343 - d4321 * d4321;
+
+			float numer = d1343 * d4321 - d1321 * d4343;
+
+			mua = numer / denom;
+			mua = clamp( mua, 0.0, 1.0 );
+			mub = ( d1343 + d4321 * ( mua ) ) / d4343;
+			mub = clamp( mub, 0.0, 1.0 );
+
+			return vec2( mua, mub );
+
+		}
+
+		void main() {
+
+			#include <clipping_planes_fragment>
+
+			// Find the closest points on the view ray and the line segment
+			vec3 rayEnd = normalize( worldPos.xyz ) * 1e5;
+			vec3 lineDir = worldEnd - worldStart;
+			vec2 params = closestLineToLine( worldStart, worldEnd, vec3( 0.0, 0.0, 0.0 ), rayEnd );
+
+			vec3 p1 = worldStart + lineDir * params.x;
+			vec3 p2 = rayEnd * params.y;
+			vec3 delta = p1 - p2;
+			float len = length( delta );
+			float norm = len / linewidth;
+
+			if ( norm > 0.5 ) {
+				discard;
+			}
+
+			#include <logdepthbuf_fragment>
+
+			gl_FragColor = vec4( 1.0, 1.0, 1.0, vDistanceAlpha );
+
+			#include <tonemapping_fragment>
+			#include <colorspace_fragment>
+			#include <fog_fragment>
+			#include <premultiplied_alpha_fragment>
+
+		}
+		`,
+};
+class LineMaterial extends ShaderMaterial {
+    constructor(parameters) {
+        super({
+            // @ts-ignore
+            type: 'LineMaterial',
+            uniforms: UniformsUtils.clone(ShaderLib['linee'].uniforms),
+            vertexShader: ShaderLib['linee'].vertexShader,
+            fragmentShader: ShaderLib['linee'].fragmentShader,
+            clipping: true, // required for clipping support
+        });
+        this.isLineMaterial = true;
+        // Compatibility flags with three/examples LineMaterial API
+        // worldUnits is effectively always true in this shader, but we accept the flag to avoid warnings
+        this._worldUnits = true;
+        this.setValues(parameters);
+    }
+    get color() {
+        return this.uniforms.diffuse.value;
+    }
+    set color(value) {
+        this.uniforms.diffuse.value = value;
+    }
+    // @ts-ignore
+    get linewidth() {
+        return this.uniforms.linewidth.value;
+    }
+    // @ts-ignore
+    set linewidth(value) {
+        if (!this.uniforms.linewidth) {
+            return;
+        }
+        this.uniforms.linewidth.value = value;
+    }
+    get dashed() {
+        return 'USE_DASH' in this.defines;
+    }
+    set dashed(value) {
+        if ((value === true) !== this.dashed) {
+            this.needsUpdate = true;
+        }
+        if (value === true) {
+            this.defines.USE_DASH = '';
+        }
+        else {
+            delete this.defines.USE_DASH;
+        }
+    }
+    // @ts-ignore
+    get opacity() {
+        return this.uniforms.opacity.value;
+    }
+    set opacity(value) {
+        if (!this.uniforms) {
+            return;
+        }
+        this.uniforms.opacity.value = value;
+    }
+    // --- Compatibility API ---
+    // Accept and expose `worldUnits` so Material.setValues doesn't warn.
+    // Our implementation measures linewidth in world space, so this is a no-op.
+    get worldUnits() {
+        return this._worldUnits;
+    }
+    set worldUnits(v) {
+        this._worldUnits = !!v;
+    }
+}
+
+export { LineMaterial };
+//# sourceMappingURL=line.js.map

package/dist/locomotion/materials/line.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"line.js","sources":["../../../src/locomotion/materials/line.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/dist/locomotion/slide.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { InputComponent } from '@iwsdk/xr-input';
+import { Types } from '../ecs/index.js';
+declare const SlideSystem_base: import("elics").SystemConstructor<{
+    /** Locomotor engine shared across locomotion systems. */
+    locomotor: {
+        type: Types.Object;
+        default: undefined;
+    };
+    /** Maximum linear speed in meters/second. */
+    maxSpeed: {
+        type: Types.Float32;
+        default: number;
+    };
+    /** Comfort vignette strength [0..1]; 0 disables vignetting. */
+    comfortAssist: {
+        type: Types.Float32;
+        default: number;
+    };
+    /** Button used to trigger jump. */
+    jumpButton: {
+        type: Types.String;
+        default: InputComponent;
+    };
+}, {}, import("../ecs/world.js").World, import("../ecs/system.js").System<{
+    /** Locomotor engine shared across locomotion systems. */
+    locomotor: {
+        type: Types.Object;
+        default: undefined;
+    };
+    /** Maximum linear speed in meters/second. */
+    maxSpeed: {
+        type: Types.Float32;
+        default: number;
+    };
+    /** Comfort vignette strength [0..1]; 0 disables vignetting. */
+    comfortAssist: {
+        type: Types.Float32;
+        default: number;
+    };
+    /** Button used to trigger jump. */
+    jumpButton: {
+        type: Types.String;
+        default: InputComponent;
+    };
+}, {}>>;
+/**
+ * Analog stick sliding locomotion with optional comfort vignette and jump.
+ *
+ * @remarks
+ * - Reads left controller thumbstick for planar movement relative to head yaw.
+ * - Applies a dynamic peripheral vignette based on input magnitude scaled by
+ *   `comfortAssist` to reduce motion sickness.
+ * - Triggers jump when `jumpButton` is pressed.
+ *
+ * @category Locomotion
+ */
+export declare class SlideSystem extends SlideSystem_base {
+    private movementVector;
+    private movementDirection;
+    private input2D;
+    private isMoving;
+    private vignette;
+    private vignetteAlphaTarget;
+    private locomotor;
+    init(): void;
+    destroy(): void;
+    update(delta: number): void;
+}
+export {};
+//# sourceMappingURL=slide.d.ts.map

package/dist/locomotion/slide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slide.d.ts","sourceRoot":"","sources":["../../src/locomotion/slide.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEjD,OAAO,EAAE,KAAK,EAAgB,MAAM,iBAAiB,CAAC;;IAuElD,yDAAyD;;;;;IAEzD,6CAA6C;;;;;IAE7C,+DAA+D;;;;;IAE/D,mCAAmC;;;;;;IANnC,yDAAyD;;;;;IAEzD,6CAA6C;;;;;IAE7C,+DAA+D;;;;;IAE/D,mCAAmC;;;;;;AApBvC;;;;;;;;;;GAUG;AACH,qBAAa,WAAY,SAAQ,gBAYhC;IACC,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,mBAAmB,CAAK;IAChC,OAAO,CAAC,SAAS,CAAa;IAE9B,IAAI;IAKJ,OAAO,IAAI,IAAI;IAIf,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CA+C5B"}

package/dist/locomotion/slide.js

@@ -0,0 +1,131 @@
+import { InputComponent } from '@iwsdk/xr-input';
+import { lerp } from '../node_modules/.pnpm/super-three@0.177.0/node_modules/super-three/src/math/MathUtils.js';
+import { createSystem } from '../ecs/system.js';
+import '../ecs/world.js';
+import { Types } from 'elics';
+import '../ecs/component-registry.js';
+import '../runtime/three.js';
+import { Vector3, Quaternion, Vector2, Mesh, CylinderGeometry, ShaderMaterial, BackSide, Color } from 'three';
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const vertexShader = `
+	varying vec2 vUv;
+
+	void main() {
+		vUv = uv;
+		vec4 modelPosition = modelMatrix * vec4(position, 1.0);
+		vec4 viewPosition = viewMatrix * modelPosition;
+		vec4 projectedPosition = projectionMatrix * viewPosition;
+
+		gl_Position = projectedPosition;
+	}
+`;
+const fragmentShader = `
+	uniform vec3 uColor;
+	uniform float uAlpha;
+	varying vec2 vUv;
+
+	void main() {
+		gl_FragColor = vec4(uColor, uAlpha * vUv.y);
+	}
+`;
+const createVignette = (radius, colorRep = 0x000000) => {
+    const vignette = new Mesh(new CylinderGeometry(radius, radius * 0.5, 0.3, 16, 1, true), new ShaderMaterial({
+        vertexShader: vertexShader,
+        fragmentShader: fragmentShader,
+        uniforms: {
+            uColor: { value: new Color(colorRep) },
+            uAlpha: { value: 0 },
+        },
+        depthTest: false,
+        side: BackSide,
+        transparent: true,
+    }));
+    vignette.frustumCulled = false;
+    vignette.renderOrder = 999;
+    vignette.rotateX(Math.PI / 2);
+    vignette.position.z = -0.15;
+    return vignette;
+};
+/**
+ * Analog stick sliding locomotion with optional comfort vignette and jump.
+ *
+ * @remarks
+ * - Reads left controller thumbstick for planar movement relative to head yaw.
+ * - Applies a dynamic peripheral vignette based on input magnitude scaled by
+ *   `comfortAssist` to reduce motion sickness.
+ * - Triggers jump when `jumpButton` is pressed.
+ *
+ * @category Locomotion
+ */
+class SlideSystem extends createSystem({}, {
+    /** Locomotor engine shared across locomotion systems. */
+    locomotor: { type: Types.Object, default: undefined },
+    /** Maximum linear speed in meters/second. */
+    maxSpeed: { type: Types.Float32, default: 5 },
+    /** Comfort vignette strength [0..1]; 0 disables vignetting. */
+    comfortAssist: { type: Types.Float32, default: 0.5 },
+    /** Button used to trigger jump. */
+    jumpButton: { type: Types.String, default: InputComponent.A_Button },
+}) {
+    constructor() {
+        super(...arguments);
+        this.movementVector = new Vector3();
+        this.movementDirection = new Quaternion();
+        this.input2D = new Vector2();
+        this.isMoving = false;
+        this.vignette = createVignette(0.3);
+        this.vignetteAlphaTarget = 0;
+    }
+    init() {
+        this.locomotor = this.config.locomotor.value;
+        this.player.head.add(this.vignette);
+    }
+    destroy() {
+        this.vignette.removeFromParent();
+    }
+    update(delta) {
+        var _a, _b;
+        this.vignetteAlphaTarget = 0;
+        // Handle jump input
+        if ((_a = this.input.gamepads.right) === null || _a === void 0 ? void 0 : _a.getButtonDown(this.config.jumpButton.value)) {
+            this.locomotor.jump();
+        }
+        if (this.input.isPrimary('controller', 'left')) {
+            this.input2D.copy(((_b = this.input.gamepads.left) === null || _b === void 0 ? void 0 : _b.getAxesValues(InputComponent.Thumbstick)) || {
+                x: 0,
+                y: 0,
+            });
+            this.movementVector.set(this.input2D.x, 0, this.input2D.y);
+            const inputValue = this.input2D.length();
+            if (inputValue > 0) {
+                this.player.head.getWorldQuaternion(this.movementDirection);
+                this.movementVector.applyQuaternion(this.movementDirection);
+                this.movementVector.y = 0;
+                this.movementVector
+                    .normalize()
+                    .multiplyScalar(inputValue * this.config.maxSpeed.value);
+                this.locomotor.slide(this.movementVector);
+                this.vignetteAlphaTarget =
+                    inputValue * this.config.comfortAssist.value;
+            }
+            else {
+                if (this.isMoving) {
+                    // Stop movement by sending zero vector
+                    this.movementVector.set(0, 0, 0);
+                    this.locomotor.slide(this.movementVector);
+                }
+            }
+            this.isMoving = inputValue > 0;
+            this.vignette.material.uniforms.uAlpha.value = lerp(this.vignette.material.uniforms.uAlpha.value, this.vignetteAlphaTarget, delta * 10);
+        }
+    }
+}
+
+export { SlideSystem };
+//# sourceMappingURL=slide.js.map

package/dist/locomotion/slide.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slide.js","sources":["../../src/locomotion/slide.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/dist/locomotion/teleport.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { Types } from '../ecs/index.js';
+declare const TeleportSystem_base: import("elics").SystemConstructor<{
+    /** Downward acceleration for the parabolic guide (negative). */
+    rayGravity: {
+        type: Types.Float32;
+        default: number;
+    };
+    /** Locomotor engine used for hit testing and teleport execution. */
+    locomotor: {
+        type: Types.Object;
+        default: undefined;
+    };
+    /** Enable hand‑tracking micro‑gesture flow for activation/confirm. */
+    microGestureControlsEnabled: {
+        type: Types.Boolean;
+        default: false;
+    };
+}, {}, import("../ecs/world.js").World, import("../ecs/system.js").System<{
+    /** Downward acceleration for the parabolic guide (negative). */
+    rayGravity: {
+        type: Types.Float32;
+        default: number;
+    };
+    /** Locomotor engine used for hit testing and teleport execution. */
+    locomotor: {
+        type: Types.Object;
+        default: undefined;
+    };
+    /** Enable hand‑tracking micro‑gesture flow for activation/confirm. */
+    microGestureControlsEnabled: {
+        type: Types.Boolean;
+        default: false;
+    };
+}, {}>>;
+/**
+ * Arc‑based teleportation with surface validation and hand/controller input.
+ *
+ * @remarks
+ * - Uses locomotor ray hit tests and only allows targets with upward normals.
+ * - In hand‑tracking mode, optional micro‑gestures can control activation
+ *   (e.g., thumb tap to confirm).
+ * - Draws a curved parabolic guide and landing marker with visual feedback.
+ *
+ * @category Locomotion
+ */
+export declare class TeleportSystem extends TeleportSystem_base {
+    private rayOrigin;
+    private rayDirection;
+    private markers;
+    private targetValid;
+    private teleportMarker;
+    private markerMat;
+    private line;
+    private teleportWasActive;
+    private activeInput;
+    private locomotor;
+    init(): void;
+    destroy(): void;
+    update(): void;
+}
+export {};
+//# sourceMappingURL=teleport.d.ts.map

package/dist/locomotion/teleport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"teleport.d.ts","sourceRoot":"","sources":["../../src/locomotion/teleport.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,EAAE,KAAK,EAAgB,MAAM,iBAAiB,CAAC;;IAkClD,gEAAgE;;;;;IAEhE,oEAAoE;;;;;IAEpE,sEAAsE;;;;;;IAJtE,gEAAgE;;;;;IAEhE,oEAAoE;;;;;IAEpE,sEAAsE;;;;;;AAlB1E;;;;;;;;;;GAUG;AACH,qBAAa,cAAe,SAAQ,mBAUnC;IACC,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,YAAY,CAAiB;IACrC,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,cAAc,CAAQ;IAC9B,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,WAAW,CAA8B;IACjD,OAAO,CAAC,SAAS,CAAa;IAE9B,IAAI;IA8BJ,OAAO,IAAI,IAAI;IAMf,MAAM,IAAI,IAAI;CAyFf"}