@pascal-app/editor 1.0.4 → 1.0.5

package/src/components/tools/distribution/distribution-run-tool.test.ts

@@ -0,0 +1,241 @@
+import { describe, expect, test } from 'bun:test'
+import { OrthographicCamera, PerspectiveCamera, Raycaster, Vector2, Vector3 } from 'three'
+import {
+  createRunSurfaceFrame,
+  projectRunPointToSurface,
+  projectRunToAngleLock,
+  projectRunToCameraDirection,
+  projectRunToDirection,
+  projectRunToSurfaceAngleLock,
+  type RunCursorRay,
+  type RunPoint,
+  runDistanceSquared,
+  snapRunLength,
+  snapRunPointToSurface,
+  snapRunValue,
+  stepNominalRunSize,
+} from './distribution-run-tool'
+
+describe('distribution run drafting helpers', () => {
+  test('grid length preserves a diagonal from an off-grid socket', () => {
+    const start: RunPoint = [0.13, 0.27, 0.19]
+    const angled = projectRunToAngleLock(start, [1.4, 0.27, 1.3])
+    const point = snapRunLength(start, angled, 0.25)
+    expect(point[0] - start[0]).toBeCloseTo(point[2] - start[2])
+    expect(Math.sqrt(runDistanceSquared(start, point))).toBeCloseTo(1.75)
+    expect(point[1]).toBe(start[1])
+    expect(snapRunLength(start, angled, 0)).toEqual(angled)
+    expect(snapRunLength(start, start, 0.25)).toEqual(start)
+  })
+
+  test('grid length preserves wall-plane diagonals', () => {
+    const start: RunPoint = [0.13, 1.17, 4]
+    const wall = createRunSurfaceFrame(start, [0, 0, 1])
+    const angled = projectRunToSurfaceAngleLock(start, [1.4, 2.3, 4], wall)
+    const point = snapRunLength(start, angled, 0.25)
+    expect(point[0] - start[0]).toBeCloseTo(point[1] - start[1])
+    expect(point[2]).toBe(4)
+    expect(Math.sqrt(runDistanceSquared(start, point))).toBeCloseTo(1.75)
+  })
+
+  test('camera grid snapping steps along a vertical guide from an off-grid origin', () => {
+    const result = projectRunToCameraDirection(
+      [0.13, 0.17, 0.19],
+      { origin: [3.13, 2.3, 3.19], direction: [-Math.SQRT1_2, 0, -Math.SQRT1_2] },
+      [1, 0, 0],
+      0.05,
+      0.25,
+      [[0, 1, 0]],
+    )
+    expect(result?.point[0]).toBe(0.13)
+    expect(result?.point[1]).toBeCloseTo(2.42)
+    expect(result?.point[2]).toBe(0.19)
+  })
+  for (const camera of [
+    new OrthographicCamera(-8, 8, 6, -6, 0.1, 100),
+    new PerspectiveCamera(50, 4 / 3, 0.1, 100),
+  ]) {
+    test(`screen-space diagonal picking follows the ${camera.type} view`, () => {
+      camera.position.set(5, 8, 10)
+      camera.lookAt(0, 0, 0)
+      camera.updateMatrixWorld(true)
+      const target = new Vector3(2, 0, 2)
+      const ndc = target.clone().project(camera)
+      const ray = new Raycaster()
+      ray.setFromCamera(new Vector2(ndc.x, ndc.y), camera)
+      const project = (point: RunPoint): [number, number] => {
+        const p = new Vector3(...point).project(camera)
+        return [(p.x + 1) * 400, (1 - p.y) * 300]
+      }
+      const result = projectRunToCameraDirection(
+        [0, 0, 0],
+        {
+          origin: ray.ray.origin.toArray(),
+          direction: ray.ray.direction.toArray(),
+        },
+        [1, 0, 0],
+        0.05,
+        0,
+        [
+          [1, 0, 0],
+          [0, 0, 1],
+          [Math.SQRT1_2, 0, Math.SQRT1_2],
+        ],
+        undefined,
+        {
+          project,
+          pointer: project(target.toArray()),
+          previous: [1, 0, 0],
+        },
+      )
+      expect(result?.direction).toEqual([Math.SQRT1_2, 0, Math.SQRT1_2])
+      expect(result?.point[0]).toBeCloseTo(2)
+      expect(result?.point[2]).toBeCloseTo(2)
+    })
+  }
+  test('releases an airborne direction guide when the cursor returns to a wall', () => {
+    const start: RunPoint = [0, 1, 1]
+    const ray: RunCursorRay = {
+      origin: [3, 3, 5],
+      direction: [-1, -1, -2],
+    }
+    const directions: RunPoint[] = [[1, 0, 0]]
+    expect(
+      projectRunToCameraDirection(start, ray, [1, 0, 0], 0.05, 0, directions)?.point[0],
+    ).toBeCloseTo(1)
+
+    for (const clearance of [0.0254, 0.1016]) {
+      const wall = createRunSurfaceFrame([0, 0, 2 + clearance], [0, 0, 1])
+      expect(
+        projectRunToCameraDirection(start, ray, [1, 0, 0], 0.05, 0, directions, wall),
+      ).toBeNull()
+    }
+  })
+
+  test('keeps direction guides that lie on the active wall face', () => {
+    const wall = createRunSurfaceFrame([0, 0, 1], [0, 0, 1])
+    const result = projectRunToCameraDirection(
+      [0, 1, 1],
+      { origin: [3, 3, 5], direction: [-1, -1, -2] },
+      [1, 0, 0],
+      0.05,
+      0,
+      [[1, 0, 0]],
+      wall,
+    )
+    expect(result?.point[0]).toBeCloseTo(1)
+    expect(result?.point[2]).toBe(1)
+  })
+
+  test('camera hover resolves downward without a ground-plane height', () => {
+    const projected = projectRunToCameraDirection(
+      [0, 5, 0],
+      { origin: [3, 2, 3], direction: [-Math.SQRT1_2, 0, -Math.SQRT1_2] },
+      [1, 0, 0],
+      0.05,
+      0,
+    )
+    expect(projected?.direction).toEqual([0, -1, 0])
+    expect(projected?.point[1]).toBeCloseTo(2)
+  })
+
+  test('projects the cursor onto the direction selected by an arrow handle', () => {
+    const point = projectRunToDirection([1, 2, 3], [4, 9, 1], [Math.SQRT1_2, 0, Math.SQRT1_2])
+
+    expect(point[1]).toBe(2)
+    expect(point[0] - 1).toBeCloseTo(point[2] - 3)
+    expect(point[0]).toBeGreaterThan(1)
+  })
+
+  test('snaps values only when the step is active', () => {
+    expect(snapRunValue(1.13, 0.25)).toBe(1.25)
+    expect(snapRunValue(1.13, 0)).toBe(1.13)
+  })
+
+  test('projects a cursor onto the nearest 45 degree ray', () => {
+    const point = projectRunToAngleLock([2, 3, 4], [4, 9, 5.8])
+
+    expect(point[1]).toBe(3)
+    expect(point[0] - 2).toBeCloseTo(point[2] - 4)
+  })
+
+  test('projects a connected continuation onto directions relative to its source run', () => {
+    const source = [Math.SQRT1_2, 0, Math.SQRT1_2] as const
+    const projected = projectRunToAngleLock([0, 0, 0], [1, 0, -2], source)
+
+    expect(projected[0]).toBeCloseTo(1.5)
+    expect(projected[1]).toBe(0)
+    expect(projected[2]).toBeCloseTo(-1.5)
+  })
+
+  test('selects a true vertical direction from the camera cursor ray', () => {
+    const projected = projectRunToCameraDirection(
+      [0, 0, 0],
+      {
+        origin: [3, 3, 3],
+        direction: [-Math.SQRT1_2, 0, -Math.SQRT1_2],
+      },
+      [1, 0, 0],
+      0.05,
+      0,
+    )
+
+    expect(projected?.direction[0]).toBeCloseTo(0)
+    expect(projected?.direction[1]).toBeCloseTo(1)
+    expect(projected?.direction[2]).toBeCloseTo(0)
+    expect(projected?.point[1]).toBeCloseTo(3)
+  })
+
+  test('selects a rising 45 degree direction in the source plane', () => {
+    const target = [Math.SQRT1_2 * 4, Math.SQRT1_2 * 4, 0] as const
+    const projected = projectRunToCameraDirection(
+      [0, 0, 0],
+      {
+        origin: [target[0] + 3, target[1], 3],
+        direction: [-Math.SQRT1_2, 0, -Math.SQRT1_2],
+      },
+      [1, 0, 0],
+      0.05,
+      0,
+    )
+
+    expect(projected?.direction[0]).toBeCloseTo(Math.SQRT1_2)
+    expect(projected?.direction[1]).toBeCloseTo(Math.SQRT1_2)
+    expect(projected?.direction[2]).toBeCloseTo(0)
+  })
+
+  test('steps from off-catalogue sizes using the nearest nominal size', () => {
+    const sizes = [2, 3, 4, 6]
+
+    expect(stepNominalRunSize(sizes, 3.2, 1)).toBe(4)
+    expect(stepNominalRunSize(sizes, 3.2, -1)).toBe(2)
+    expect(stepNominalRunSize(sizes, 6, 1)).toBe(6)
+  })
+
+  test('computes squared 3D distance for fitting degeneracy checks', () => {
+    expect(runDistanceSquared([1, 2, 3], [4, 6, 3])).toBe(25)
+  })
+
+  test('projects and snaps a run in a vertical wall plane', () => {
+    const wall = createRunSurfaceFrame([4, 2, 6], [0, 0, 1])
+
+    expect(projectRunPointToSurface([7, 3, 9], wall)).toEqual([7, 3, 6])
+    expect(snapRunPointToSurface([7.12, 2.88, 6], wall, 0.25)).toEqual([7, 3, 6])
+  })
+
+  test('keeps angle snapping inside the active surface plane', () => {
+    const wall = createRunSurfaceFrame([0, 1, 4], [0, 0, 1])
+    const point = projectRunToSurfaceAngleLock([0, 1, 4], [1.2, 2.1, 4], wall)
+
+    expect(point[2]).toBeCloseTo(4)
+    expect(point[1] - 1).toBeCloseTo(point[0])
+  })
+
+  test('keeps a run on a rotated wall plane', () => {
+    const diagonalWall = createRunSurfaceFrame([2, 1, 2], [Math.SQRT1_2, 0, Math.SQRT1_2])
+    const projected = projectRunPointToSurface([4, 3, 0], diagonalWall)
+
+    expect(projected[0] + projected[2]).toBeCloseTo(4)
+    expect(projected[1]).toBeCloseTo(3)
+  })
+})

package/src/components/tools/distribution/distribution-run-tool.test.tsx

@@ -0,0 +1,125 @@
+import { expect, test } from 'bun:test'
+import { emitter, type GridEvent, useScene, WallNode } from '@pascal-app/core'
+import { useEditor, useInteractionScope } from '@pascal-app/editor'
+import { useThree } from '@react-three/fiber'
+import { act, create } from '@react-three/test-renderer'
+import { useDistributionRunTool } from './distribution-run-tool'
+
+test.each(['duct-segment', 'pipe-segment'] as const)(
+  '%s releases its wall plane after an outward commit and retains it along the wall',
+  async (toolName) => {
+    const previousScene = useScene.getState()
+    const previousEditor = useEditor.getState()
+    const previousScope = useInteractionScope.getState()
+    const previousWindow = Object.getOwnPropertyDescriptor(globalThis, 'window')
+    const previousActEnvironment = Object.getOwnPropertyDescriptor(
+      globalThis,
+      'IS_REACT_ACT_ENVIRONMENT',
+    )
+    Object.defineProperty(globalThis, 'IS_REACT_ACT_ENVIRONMENT', {
+      value: true,
+      configurable: true,
+      writable: true,
+    })
+    Object.defineProperty(globalThis, 'window', {
+      value: new EventTarget(),
+      configurable: true,
+      writable: true,
+    })
+    const wall = WallNode.parse({ parentId: 'level_test', start: [0, 0], end: [10, 0] })
+    let tool: ReturnType<typeof useDistributionRunTool> | undefined
+    const commits: Array<[number, number, number]> = []
+    let acceptCommit = true
+    function Host() {
+      const { gl } = useThree()
+      gl.domElement.getBoundingClientRect = () =>
+        ({ left: 0, top: 0, width: 100, height: 100 }) as DOMRect
+      tool = useDistributionRunTool({
+        active: true,
+        levelId: 'level_test',
+        toolName,
+        getPorts: () => [],
+        findBody: () => null,
+        surfaceClearance: () => 0.1,
+        commit: ({ end }) => {
+          if (!acceptCommit) return null
+          commits.push(end)
+          return { nextStart: end, nextConnection: { port: null, body: null } }
+        },
+      })
+      return null
+    }
+    let renderer: Awaited<ReturnType<typeof create>> | undefined
+    const wallEvent = (x: number): GridEvent => ({
+      position: [x, 1, 0],
+      localPosition: [x, 1, 0],
+      surfaceNormal: [0, 0, 1],
+      surfaceHit: {
+        kind: 'wall',
+        hostId: wall.id,
+        levelId: 'level_test',
+        face: 'side',
+        side: 'front',
+      },
+      nativeEvent: {} as GridEvent['nativeEvent'],
+    })
+    try {
+      useScene.setState({ nodes: { [wall.id]: wall } })
+      useEditor.setState({ snappingModeByContext: { wall: 'off', polygon: 'off', item: 'off' } })
+      renderer = await create(<Host />)
+      await act(async () => {
+        emitter.emit('grid:click', wallEvent(1))
+      })
+      await act(async () => {
+        emitter.emit('grid:click', wallEvent(2))
+      })
+      expect(commits).toEqual([[2, 1, 0.1]])
+      await act(async () => {
+        emitter.emit('grid:move', {
+          position: [3, 0, 4],
+          localPosition: [3, 0, 4],
+          localRay: { origin: [3, 2, 2.1], direction: [0, -0.5, -1] },
+          nativeEvent: {} as GridEvent['nativeEvent'],
+        })
+      })
+      expect(tool?.cursor?.[2]).toBeCloseTo(0.1)
+      await act(async () => {
+        tool?.onDirectionSelect([0, 0, 1])
+      })
+      const outward: GridEvent = {
+        position: [2, 0, 2.1],
+        localPosition: [2, 0, 2.1],
+        localRay: { origin: [2, 3, 2.1], direction: [0, -1, 0] },
+        nativeEvent: {} as GridEvent['nativeEvent'],
+      }
+      acceptCommit = false
+      await act(async () => {
+        emitter.emit('grid:click', outward)
+      })
+      expect(commits).toHaveLength(1)
+      acceptCommit = true
+      await act(async () => {
+        emitter.emit('grid:click', outward)
+      })
+      expect(commits[1]?.[2]).toBeCloseTo(2.1)
+      await act(async () => {
+        emitter.emit('grid:move', {
+          ...outward,
+          localRay: { origin: [4, 3, 2.1], direction: [0, -1, 0] },
+        })
+      })
+      expect(tool?.cursor).toEqual([4, 1, 2.1])
+      expect(tool?.surfaceTarget).toBeNull()
+    } finally {
+      await renderer?.unmount()
+      useScene.setState(previousScene, true)
+      useEditor.setState(previousEditor, true)
+      useInteractionScope.setState(previousScope, true)
+      if (previousWindow) Object.defineProperty(globalThis, 'window', previousWindow)
+      else Reflect.deleteProperty(globalThis, 'window')
+      if (previousActEnvironment)
+        Object.defineProperty(globalThis, 'IS_REACT_ACT_ENVIRONMENT', previousActEnvironment)
+      else Reflect.deleteProperty(globalThis, 'IS_REACT_ACT_ENVIRONMENT')
+    }
+  },
+)