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

package/components/VirtualWalkthrough/boundary-wall.js

@@ -1,62 +1,109 @@
-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 = 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
+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
     };
-    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);
+  }
+  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
     };
-    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);
-    }
+  });
+  if (bottoms.some(bottom => bottom.y >= topY)) {
     return {
-        positions,
-        uvs,
-        indices,
-        columns,
-        rows
+      positions: [],
+      uvs: [],
+      indices: [],
+      columns: 0,
+      rows: 0
     };
+  }
+
+  // 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
+  };
 };
-const wallVertexGLSL = `
+
+// 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 */`
     attribute vec3 vertex_position;
     attribute vec2 aUv0;
 
@@ -73,7 +120,7 @@ const wallVertexGLSL = `
         gl_Position = matrix_viewProjection * world;
     }
 `;
-const wallFragmentGLSL = `
+const wallFragmentGLSL = /* glsl */`
     uniform vec3 uHeadPos;
     uniform float uFadeDistance;
     uniform float uBlockedFadeScale;
@@ -118,131 +165,167 @@ const wallFragmentGLSL = `
         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 = [];
-    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;
-        });
+  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;
     }
-    _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;
-        }
+    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;
     }
-    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
-            ]
-        });
+  }
+  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;
     }
-    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);
+
+    // 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]
+      });
     }
-    _clearMesh() {
-        if (this.entity.render) this.entity.render.meshInstances = [];
-        if (this._mesh) {
-            this._mesh.destroy();
-            this._mesh = void 0;
-        }
+  }
+  update() {
+    this._resolveDependencies();
+    const material = this._material;
+    const camera = this._camera;
+    if (!material || !camera || !this.entity.render) {
+      return;
     }
+    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,20 +1,66 @@
-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);
-        }
-    };
+/**
+ * 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);
+    }
+  };
 };
+
 export { adoptSceneCamera };

package/components/VirtualWalkthrough/groundPlane.js

@@ -1,35 +1,50 @@
-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;
+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;
 };
-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)
-    };
+
+/**
+ * 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)
+  };
 };
+
 export { computeGroundPlane, yOnPlane };