@terraware/web-components 5.0.27 → 5.1.1-rc.0

package/components/VirtualWalkthrough/boundary-wall.js

@@ -1,109 +1,62 @@
-import { Script, Vec3, Color, ShaderMaterial, SEMANTIC_TEXCOORD0, SEMANTIC_POSITION, BLEND_NORMAL, CULLFACE_NONE, Mesh, MeshInstance, LAYERID_IMMEDIATE } from 'playcanvas';
-import { computeGroundPlane, yOnPlane } from './groundPlane.js';
-import { distanceToCircleEdge } from './xr-scene-bounds.js';
-
-/**
- * Flat-array geometry ready for `Mesh.setPositions` / `Mesh.setUvs` / `Mesh.setIndices`, plus the
- * grid cell counts the shader needs to know how far the UVs run.
- */
-
-/**
- * Triangle geometry for an upright cylinder standing on the boundary circle. Each segment is a quad
- * (two triangles) spanning from the ground up to `topY`; the base is sampled on the ground plane so
- * the wall meets the dashed BoundaryRing exactly, while the top is a flat ring at `topY` — the user
- * stands on the rig floor, not on the splat's ground plane, so the top is positioned relative to the
- * former and only the base follows the latter.
- *
- * UVs are emitted in **grid cell units** rather than metres — u runs 0..columns around the
- * circumference and v runs 0..rows up the wall — so the shader can draw a line at every whole number
- * and have the seam at u = columns line up perfectly with u = 0.
- */
-const boundaryWallMesh = ({
-  center,
-  radius,
-  groundPlane,
-  baseY,
-  topY,
-  gridSpacing,
-  segments = 96
-}) => {
-  if (radius <= 0 || segments <= 0 || gridSpacing <= 0) {
-    return {
-      positions: [],
-      uvs: [],
-      indices: [],
-      columns: 0,
-      rows: 0
+import { BLEND_NORMAL, CULLFACE_NONE, Color, LAYERID_IMMEDIATE, Mesh, MeshInstance, SEMANTIC_POSITION, SEMANTIC_TEXCOORD0, Script, ShaderMaterial, Vec3 } from "playcanvas";
+import { computeGroundPlane, yOnPlane } from "./groundPlane.js";
+import { distanceToCircleEdge } from "./xr-scene-bounds.js";
+const boundaryWallMesh = ({ center, radius, groundPlane, baseY, topY, gridSpacing, segments = 96 })=>{
+    if (radius <= 0 || segments <= 0 || gridSpacing <= 0) return {
+        positions: [],
+        uvs: [],
+        indices: [],
+        columns: 0,
+        rows: 0
     };
-  }
-  const plane = computeGroundPlane(groundPlane);
-  const step = Math.PI * 2 / segments;
-
-  // First pass: the bottom of every column, which the row count and the extent guard both need
-  // before any vertex can be emitted.
-  const bottoms = Array.from({
-    length: segments
-  }, (_, index) => {
-    const angle = index * step;
-    const x = center.x + radius * Math.cos(angle);
-    const z = center.z + radius * Math.sin(angle);
-    return {
-      x,
-      z,
-      y: plane ? yOnPlane(x, z, plane.normal, plane.point, baseY) : baseY
+    const plane = computeGroundPlane(groundPlane);
+    const step = 2 * Math.PI / segments;
+    const bottoms = Array.from({
+        length: segments
+    }, (_, index)=>{
+        const angle = index * step;
+        const x = center.x + radius * Math.cos(angle);
+        const z = center.z + radius * Math.sin(angle);
+        return {
+            x,
+            z,
+            y: plane ? yOnPlane(x, z, plane.normal, plane.point, baseY) : baseY
+        };
+    });
+    if (bottoms.some((bottom)=>bottom.y >= topY)) return {
+        positions: [],
+        uvs: [],
+        indices: [],
+        columns: 0,
+        rows: 0
     };
-  });
-  if (bottoms.some(bottom => bottom.y >= topY)) {
+    const averageBottomY = bottoms.reduce((total, bottom)=>total + bottom.y, 0) / bottoms.length;
+    const columns = Math.max(1, Math.round(2 * Math.PI * radius / gridSpacing));
+    const rows = Math.max(1, Math.round((topY - averageBottomY) / gridSpacing));
+    const positions = [];
+    const uvs = [];
+    const indices = [];
+    const pushColumn = (index)=>{
+        const { x, z, y } = bottoms[index % segments];
+        const u = index / segments * columns;
+        positions.push(x, y, z, x, topY, z);
+        uvs.push(u, 0, u, rows);
+    };
+    for(let i = 0; i < segments; i++){
+        const base = 4 * i;
+        pushColumn(i);
+        pushColumn(i + 1);
+        indices.push(base, base + 1, base + 3, base, base + 3, base + 2);
+    }
     return {
-      positions: [],
-      uvs: [],
-      indices: [],
-      columns: 0,
-      rows: 0
+        positions,
+        uvs,
+        indices,
+        columns,
+        rows
     };
-  }
-
-  // Every column has its own world height once the ground tilts, but v still runs 0..rows uniformly
-  // for all of them, so a single row count has to stand for the whole wall. Deriving it from the
-  // average bottom is exact for a flat ground plane (the common case) and keeps the cells square on
-  // average when the plane is tilted.
-  const averageBottomY = bottoms.reduce((total, bottom) => total + bottom.y, 0) / bottoms.length;
-  const columns = Math.max(1, Math.round(Math.PI * 2 * radius / gridSpacing));
-  const rows = Math.max(1, Math.round((topY - averageBottomY) / gridSpacing));
-  const positions = [];
-  const uvs = [];
-  const indices = [];
-  const pushColumn = index => {
-    // The closing column (index === segments) reuses column 0's position so the loop shuts exactly,
-    // while u keeps counting up to `columns` to place the seam.
-    const {
-      x,
-      z,
-      y
-    } = bottoms[index % segments];
-    const u = index / segments * columns;
-    positions.push(x, y, z, x, topY, z);
-    uvs.push(u, 0, u, rows);
-  };
-  for (let i = 0; i < segments; i++) {
-    const base = i * 4;
-    // Per segment: v0 bottom@a0, v1 top@a0, v2 bottom@a1, v3 top@a1.
-    pushColumn(i);
-    pushColumn(i + 1);
-    indices.push(base, base + 1, base + 3, base, base + 3, base + 2);
-  }
-  return {
-    positions,
-    uvs,
-    indices,
-    columns,
-    rows
-  };
 };
-
-// GLSL only: @playcanvas/react's Application defaults to deviceTypes [DEVICETYPE_WEBGL2], so the
-// WGSL variants the engine's own shaders carry would never be compiled here.
-const wallVertexGLSL = /* glsl */`
+const wallVertexGLSL = `
     attribute vec3 vertex_position;
     attribute vec2 aUv0;
 
@@ -120,7 +73,7 @@ const wallVertexGLSL = /* glsl */`
         gl_Position = matrix_viewProjection * world;
     }
 `;
-const wallFragmentGLSL = /* glsl */`
+const wallFragmentGLSL = `
     uniform vec3 uHeadPos;
     uniform float uFadeDistance;
     uniform float uBlockedFadeScale;
@@ -165,167 +118,131 @@ const wallFragmentGLSL = /* glsl */`
         gl_FragColor = vec4(mix(uCalmColor, uWarnColor, max(proximity, uBlocked)), alpha);
     }
 `;
-
-/**
- * Structural shape of TfXrNavigation this script depends on, kept local so it does not have to
- * import the navigation script. `enabled` is optional because a disabled script (e.g. while edit
- * mode is on) stops receiving postUpdate and would otherwise latch a stale clampDistance.
- */
-
-/**
- * Draws a Quest-guardian-style boundary wall: an upright cylinder on the bounds circle whose grid
- * fades in and shifts toward a warning colour as the head approaches, and goes to full intensity
- * while XR navigation is actively holding the user back.
- *
- * center / radius / groundPlane / baseY are set imperatively by the BoundaryWall component (see
- * BoundaryWall.tsx for why they are not reactive Script props), which calls `rebuild()` afterwards.
- */
 class BoundaryWallScript extends Script {
-  static scriptName = 'boundaryWall';
-  center = new Vec3();
-  radius = 0;
-  groundPlane = [];
-  /** Flat bottom height used when no usable ground plane is supplied. */
-  baseY = 0;
-  /**
-   * Absolute world Y of the wall's top edge. The default puts it 2.5 m above a rig floor at y = 0,
-   * which is where the user actually stands - the splat's ground plane can be well below that.
-   */
-  topY = 2.5;
-  segments = 96;
-  gridSpacing = 0.5;
-  /** Grid line thickness in world metres. */
-  lineWidth = 0.025;
-  /** Head distance, in world metres, at which the wall starts to appear. */
-  fadeDistance = 1.5;
-  /** Multiplier applied to fadeDistance while movement is being clamped. */
-  blockedFadeScale = 2.5;
-  calmColor = new Color(0.35, 0.7, 1);
-  warnColor = new Color(1, 0.45, 0.2);
-  _camera = null;
-  _navigation = null;
-  _headParam = new Float32Array(3);
-  initialize() {
-    this._material = new ShaderMaterial({
-      uniqueName: 'boundary-wall',
-      vertexGLSL: wallVertexGLSL,
-      fragmentGLSL: wallFragmentGLSL,
-      attributes: {
-        vertex_position: SEMANTIC_POSITION,
-        aUv0: SEMANTIC_TEXCOORD0
-      }
-    });
-    this._material.blendType = BLEND_NORMAL;
-    this._material.cull = CULLFACE_NONE;
-    this._material.depthWrite = false;
-    this._material.update();
-    this._resolveDependencies();
-    this.rebuild();
-    this.once('destroy', () => {
-      this._clearMesh();
-      this._material?.destroy();
-      this._material = undefined;
-      this._camera = null;
-      this._navigation = null;
-    });
-  }
-
-  /**
-   * The camera and the navigation script both live on entities this one does not own. They are
-   * resolved lazily rather than once, because script initialize order across sibling entities is not
-   * guaranteed and this entity mounts when an XR session starts.
-   */
-  _resolveDependencies() {
-    if (!this._camera) {
-      this._camera = this.app.root.findComponent('camera')?.entity ?? null;
+    static scriptName = 'boundaryWall';
+    center = new Vec3();
+    radius = 0;
+    groundPlane = [];
+    baseY = 0;
+    topY = 2.5;
+    segments = 96;
+    gridSpacing = 0.5;
+    lineWidth = 0.025;
+    fadeDistance = 1.5;
+    blockedFadeScale = 2.5;
+    calmColor = new Color(0.35, 0.7, 1);
+    warnColor = new Color(1, 0.45, 0.2);
+    _material;
+    _mesh;
+    _camera = null;
+    _navigation = null;
+    _headParam = new Float32Array(3);
+    initialize() {
+        this._material = new ShaderMaterial({
+            uniqueName: 'boundary-wall',
+            vertexGLSL: wallVertexGLSL,
+            fragmentGLSL: wallFragmentGLSL,
+            attributes: {
+                vertex_position: SEMANTIC_POSITION,
+                aUv0: SEMANTIC_TEXCOORD0
+            }
+        });
+        this._material.blendType = BLEND_NORMAL;
+        this._material.cull = CULLFACE_NONE;
+        this._material.depthWrite = false;
+        this._material.update();
+        this._resolveDependencies();
+        this.rebuild();
+        this.once('destroy', ()=>{
+            this._clearMesh();
+            this._material?.destroy();
+            this._material = void 0;
+            this._camera = null;
+            this._navigation = null;
+        });
     }
-    if (!this._navigation) {
-      const rig = this.app.root.findByName('camera-root');
-      // @ts-expect-error - scripts are added dynamically to the entity
-      this._navigation = rig?.script?.tfXrNavigation ?? null;
+    _resolveDependencies() {
+        if (!this._camera) this._camera = this.app.root.findComponent('camera')?.entity ?? null;
+        if (!this._navigation) {
+            const rig = this.app.root.findByName('camera-root');
+            this._navigation = rig?.script?.tfXrNavigation ?? null;
+        }
     }
-  }
-  rebuild() {
-    this._clearMesh();
-    const geometry = boundaryWallMesh({
-      center: this.center,
-      radius: this.radius,
-      groundPlane: this.groundPlane,
-      baseY: this.baseY,
-      topY: this.topY,
-      gridSpacing: this.gridSpacing,
-      segments: this.segments
-    });
-    if (geometry.positions.length === 0 || !this._material) {
-      return;
+    rebuild() {
+        this._clearMesh();
+        const geometry = boundaryWallMesh({
+            center: this.center,
+            radius: this.radius,
+            groundPlane: this.groundPlane,
+            baseY: this.baseY,
+            topY: this.topY,
+            gridSpacing: this.gridSpacing,
+            segments: this.segments
+        });
+        if (0 === geometry.positions.length || !this._material) return;
+        this._material.setParameter('uLineHalfWidth', this.lineWidth / this.gridSpacing * 0.5);
+        this._material.setParameter('uFadeDistance', this.fadeDistance);
+        this._material.setParameter('uBlockedFadeScale', this.blockedFadeScale);
+        this._material.setParameter('uRows', geometry.rows);
+        this._material.setParameter('uCalmColor', [
+            this.calmColor.r,
+            this.calmColor.g,
+            this.calmColor.b
+        ]);
+        this._material.setParameter('uWarnColor', [
+            this.warnColor.r,
+            this.warnColor.g,
+            this.warnColor.b
+        ]);
+        this._material.setParameter('uBlocked', 0);
+        this._material.setParameter('uHeadPos', [
+            0,
+            0,
+            0
+        ]);
+        const mesh = new Mesh(this.app.graphicsDevice);
+        mesh.setPositions(geometry.positions);
+        mesh.setUvs(0, geometry.uvs);
+        mesh.setIndices(geometry.indices);
+        mesh.update();
+        this._mesh = mesh;
+        const meshInstance = new MeshInstance(mesh, this._material);
+        if (this.entity.render) this.entity.render.meshInstances = [
+            meshInstance
+        ];
+        else this.entity.addComponent('render', {
+            meshInstances: [
+                meshInstance
+            ],
+            layers: [
+                LAYERID_IMMEDIATE
+            ]
+        });
     }
-
-    // The shader measures distance in grid cells, so convert. A cell is gridSpacing across only
-    // approximately - columns and rows are rounded to whole numbers - but that error is well under
-    // a line width, so it is not worth carrying the exact cell size through as a second uniform.
-    this._material.setParameter('uLineHalfWidth', this.lineWidth / this.gridSpacing * 0.5);
-    this._material.setParameter('uFadeDistance', this.fadeDistance);
-    this._material.setParameter('uBlockedFadeScale', this.blockedFadeScale);
-    this._material.setParameter('uRows', geometry.rows);
-    this._material.setParameter('uCalmColor', [this.calmColor.r, this.calmColor.g, this.calmColor.b]);
-    this._material.setParameter('uWarnColor', [this.warnColor.r, this.warnColor.g, this.warnColor.b]);
-    this._material.setParameter('uBlocked', 0);
-    this._material.setParameter('uHeadPos', [0, 0, 0]);
-    const mesh = new Mesh(this.app.graphicsDevice);
-    mesh.setPositions(geometry.positions);
-    mesh.setUvs(0, geometry.uvs);
-    mesh.setIndices(geometry.indices);
-    mesh.update();
-    this._mesh = mesh;
-    const meshInstance = new MeshInstance(mesh, this._material);
-    if (this.entity.render) {
-      this.entity.render.meshInstances = [meshInstance];
-    } else {
-      // Immediate layer, drawn after the World layer where the splats render, so the wall is not
-      // composited behind them - same reason BoundaryRingScript uses it.
-      this.entity.addComponent('render', {
-        meshInstances: [meshInstance],
-        layers: [LAYERID_IMMEDIATE]
-      });
+    update() {
+        this._resolveDependencies();
+        const material = this._material;
+        const camera = this._camera;
+        if (!material || !camera || !this.entity.render) return;
+        const navigation = this._navigation;
+        const blocked = navigation?.enabled !== false && (navigation?.clampDistance ?? 0) > 0 ? 1 : 0;
+        const reveal = this.fadeDistance * (blocked ? this.blockedFadeScale : 1);
+        const head = camera.getPosition();
+        const edgeDistance = distanceToCircleEdge(head.x, head.z, this.center.x, this.center.z, this.radius);
+        this.entity.render.enabled = this.radius > 0 && edgeDistance > -reveal;
+        if (!this.entity.render.enabled) return;
+        this._headParam[0] = head.x;
+        this._headParam[1] = head.y;
+        this._headParam[2] = head.z;
+        material.setParameter('uHeadPos', this._headParam);
+        material.setParameter('uBlocked', blocked);
     }
-  }
-  update() {
-    this._resolveDependencies();
-    const material = this._material;
-    const camera = this._camera;
-    if (!material || !camera || !this.entity.render) {
-      return;
+    _clearMesh() {
+        if (this.entity.render) this.entity.render.meshInstances = [];
+        if (this._mesh) {
+            this._mesh.destroy();
+            this._mesh = void 0;
+        }
     }
-    const navigation = this._navigation;
-    // A disabled navigation script (e.g. edit mode) stops receiving postUpdate, so its
-    // clampDistance would otherwise latch whatever value it last held.
-    const blocked = navigation?.enabled !== false && (navigation?.clampDistance ?? 0) > 0 ? 1 : 0;
-    const reveal = this.fadeDistance * (blocked ? this.blockedFadeScale : 1);
-    const head = camera.getPosition();
-
-    // Skip the transparent draw entirely while the head is deeper inside than the widest reveal
-    // radius - every fragment would discard anyway. Toggling render.enabled rather than
-    // entity.enabled keeps this update running so the wall can come back.
-    const edgeDistance = distanceToCircleEdge(head.x, head.z, this.center.x, this.center.z, this.radius);
-    this.entity.render.enabled = this.radius > 0 && edgeDistance > -reveal;
-    if (!this.entity.render.enabled) {
-      return;
-    }
-    this._headParam[0] = head.x;
-    this._headParam[1] = head.y;
-    this._headParam[2] = head.z;
-    material.setParameter('uHeadPos', this._headParam);
-    material.setParameter('uBlocked', blocked);
-  }
-  _clearMesh() {
-    if (this.entity.render) {
-      this.entity.render.meshInstances = [];
-    }
-    if (this._mesh) {
-      this._mesh.destroy();
-      this._mesh = undefined;
-    }
-  }
 }
-
 export { BoundaryWallScript, boundaryWallMesh };

package/components/VirtualWalkthrough/camera-adoption.js

@@ -1,66 +1,20 @@
-/**
- * The pose an adopted camera is put back to when the walkthrough releases it.
- */
-
-/**
- * A camera the walkthrough took over, and the call that hands it back.
- */
-
-/**
- * Hands the scene's existing camera to a walkthrough rig that hasn't been given one.
- *
- * A caller mounting the viewer into a scene it doesn't own passes `camera={null}`, because an XR
- * session is welded to the camera component it was started on — `XrManager.camera` is read-only and
- * `start` refuses while a session is running — so a walkthrough that brought a camera of its own
- * could only become the session's camera by ending it, which drops the user out of the headset.
- *
- * That leaves the rig with no camera under it, and everything that poses or solves against the head
- * resolves it with `findComponent('camera')` on the rig: `WalkthroughCamera`'s pointer and keyboard
- * walk, `XrStartPose`, `XrNavigation`'s thumbstick movement and turning, and the bounds clamp all go
- * inert, so the head is never placed at the walkthrough's start point and can never be moved from
- * wherever the host scene left it. Splat LOD is chosen from
- * the camera's distance to each octree node, so the far side of the model stays coarse for the whole
- * session no matter which way the headset turns.
- *
- * Reparenting carries the live camera component with it, so the session, its views, and the host's
- * own clear color and clip planes are all untouched — only which entity the camera hangs off
- * changes. The camera becomes a direct child of the rig, which is exactly where a camera the viewer
- * owns sits, so the rig means the same thing either way.
- *
- * @param root - The scene root to look for a camera in, expected to hold exactly one camera.
- * @param rig - The entity the walkthrough's XR scripts move, `camera-root`.
- * @param ownCamera - The entity the viewer mounts its own camera on. Nothing is adopted when it
- * already carries one.
- * @returns The adopted camera and the call that puts it back, or null when there was nothing to
- * adopt.
- */
-const adoptSceneCamera = (root, rig, ownCamera) => {
-  if (ownCamera.camera) {
-    return null;
-  }
-  const camera = root.findComponent('camera')?.entity;
-  // isDescendantOf covers a host that mounted the walkthrough inside its own camera, where
-  // reparenting would make a cycle.
-  if (!camera || camera === rig || !camera.parent || rig.isDescendantOf(camera)) {
-    return null;
-  }
-  const previous = {
-    parent: camera.parent,
-    position: camera.getLocalPosition().clone(),
-    rotation: camera.getLocalRotation().clone()
-  };
-
-  // addChild keeps the local transform, so the host's authored camera pose survives the move and
-  // only has to be restored because a session overwrites it with the head pose every frame.
-  rig.addChild(camera);
-  return {
-    camera,
-    release: () => {
-      previous.parent.addChild(camera);
-      camera.setLocalPosition(previous.position);
-      camera.setLocalRotation(previous.rotation);
-    }
-  };
+const adoptSceneCamera = (root, rig, ownCamera)=>{
+    if (ownCamera.camera) return null;
+    const camera = root.findComponent('camera')?.entity;
+    if (!camera || camera === rig || !camera.parent || rig.isDescendantOf(camera)) return null;
+    const previous = {
+        parent: camera.parent,
+        position: camera.getLocalPosition().clone(),
+        rotation: camera.getLocalRotation().clone()
+    };
+    rig.addChild(camera);
+    return {
+        camera,
+        release: ()=>{
+            previous.parent.addChild(camera);
+            camera.setLocalPosition(previous.position);
+            camera.setLocalRotation(previous.rotation);
+        }
+    };
 };
-
 export { adoptSceneCamera };

package/components/VirtualWalkthrough/groundPlane.js

@@ -1,50 +1,35 @@
-import { Vec3 } from 'playcanvas';
-
-/** Compute Y on the plane defined by `normal` passing through `point` at world XZ coords (x, z). */
-const yOnPlane = (x, z, normal, point, fallback) => {
-  if (Math.abs(normal.y) < 1e-6) {
-    return fallback;
-  }
-  return point.y - (normal.x * (x - point.x) + normal.z * (z - point.z)) / normal.y;
+import { Vec3 } from "playcanvas";
+const yOnPlane = (x, z, normal, point, fallback)=>{
+    if (Math.abs(normal.y) < 1e-6) return fallback;
+    return point.y - (normal.x * (x - point.x) + normal.z * (z - point.z)) / normal.y;
 };
-
-/**
- * Derive a ground plane from 3 world-space points.
- * Returns a normalized normal (flipped so normal.y >= 0) and a point on the plane,
- * or null when fewer than 3 points are supplied or they are degenerate/collinear.
- */
-const computeGroundPlane = points => {
-  if (points.length < 3) {
-    return null;
-  }
-  const p0 = points[0];
-  const p1 = points[1];
-  const p2 = points[2];
-  const v1x = p1.x - p0.x;
-  const v1y = p1.y - p0.y;
-  const v1z = p1.z - p0.z;
-  const v2x = p2.x - p0.x;
-  const v2y = p2.y - p0.y;
-  const v2z = p2.z - p0.z;
-  let nx = v1y * v2z - v1z * v2y;
-  let ny = v1z * v2x - v1x * v2z;
-  let nz = v1x * v2y - v1y * v2x;
-  const len = Math.sqrt(nx * nx + ny * ny + nz * nz);
-  if (len < 1e-10) {
-    return null;
-  }
-  nx /= len;
-  ny /= len;
-  nz /= len;
-  if (ny < 0) {
-    nx = -nx;
-    ny = -ny;
-    nz = -nz;
-  }
-  return {
-    normal: new Vec3(nx, ny, nz),
-    point: new Vec3(p0.x, p0.y, p0.z)
-  };
+const computeGroundPlane = (points)=>{
+    if (points.length < 3) return null;
+    const p0 = points[0];
+    const p1 = points[1];
+    const p2 = points[2];
+    const v1x = p1.x - p0.x;
+    const v1y = p1.y - p0.y;
+    const v1z = p1.z - p0.z;
+    const v2x = p2.x - p0.x;
+    const v2y = p2.y - p0.y;
+    const v2z = p2.z - p0.z;
+    let nx = v1y * v2z - v1z * v2y;
+    let ny = v1z * v2x - v1x * v2z;
+    let nz = v1x * v2y - v1y * v2x;
+    const len = Math.sqrt(nx * nx + ny * ny + nz * nz);
+    if (len < 1e-10) return null;
+    nx /= len;
+    ny /= len;
+    nz /= len;
+    if (ny < 0) {
+        nx = -nx;
+        ny = -ny;
+        nz = -nz;
+    }
+    return {
+        normal: new Vec3(nx, ny, nz),
+        point: new Vec3(p0.x, p0.y, p0.z)
+    };
 };
-
 export { computeGroundPlane, yOnPlane };