@woosh/meep-engine 3.11.2 → 3.12.0

package/editor/selection/screen_rect_frustum.js

@@ -1,119 +1,119 @@
-import { assert } from "../../src/core/assert.js";
-import Vector3 from "../../src/core/geom/Vector3.js";
-
-/**
- * Planes the volume is made of: four sides, a near and a far.
- *
- * @type {number}
- */
-export const SCREEN_RECT_FRUSTUM_PLANES = 6;
-
-/**
- * @type {Vector3}
- */
-const eye = new Vector3();
-
-/**
- * The four corner directions and the one through the middle.
- *
- * @type {Vector3[]}
- */
-const corners = [new Vector3(), new Vector3(), new Vector3(), new Vector3()];
-
-/**
- * @type {Vector3}
- */
-const centre = new Vector3();
-
-/**
- * @type {Vector3}
- */
-const normal = new Vector3();
-
-/**
- * The volume a rectangle drawn on the screen means.
- *
- * **Built from the facade's own projection rays rather than from a camera object**, which is what
- * makes it renderer-neutral: `viewportProjectionRay` is on both engines, answers in world space, and
- * takes its origin from the eye — so the four corners of the rectangle give four directions from one
- * point, and four side planes follow. The three version of this unprojected eight corners through a
- * `THREE.Camera` and could only ever run on one renderer.
- *
- * **Each side plane's orientation is decided against the rectangle's own middle**, not against a
- * winding convention. Which way a cross product points depends on the order the corners come in and
- * on the handedness of the projection, and neither is a thing this should have an opinion about; the
- * direction through the centre of the rectangle is inside the volume by construction, so it settles
- * every sign in one step.
- *
- * Planes are written `nx, ny, nz, w` with the interior **positive**, which is what
- * `aabb3_intersects_clipping_volume_array` tests for.
- *
- * @param {ArrayLike<number>|Float64Array} result at least `SCREEN_RECT_FRUSTUM_PLANES * 4` long
- * @param {GraphicsEngine|GraphicsEngine3} graphics
- * @param {AABB2} rect clip space, −1…1, +Y up
- * @param {number} near world units from the eye
- * @param {number} far world units from the eye
- */
-export function screen_rect_frustum(result, graphics, rect, near, far) {
-    assert.defined(result, 'result');
-    assert.defined(graphics, 'graphics');
-    assert.defined(rect, 'rect');
-    assert.isNumber(near, 'near');
-    assert.isNumber(far, 'far');
-
-    // around the rectangle rather than across it, so that consecutive pairs share an edge
-    const around = [
-        [rect.x0, rect.y1],
-        [rect.x1, rect.y1],
-        [rect.x1, rect.y0],
-        [rect.x0, rect.y0]
-    ];
-
-    for (let i = 0; i < 4; i++) {
-        graphics.viewportProjectionRay(around[i][0], around[i][1], eye, corners[i]);
-    }
-
-    graphics.viewportProjectionRay(
-        (rect.x0 + rect.x1) / 2,
-        (rect.y0 + rect.y1) / 2,
-        eye, centre
-    );
-
-    for (let i = 0; i < 4; i++) {
-        const a = corners[i];
-        const b = corners[(i + 1) % 4];
-
-        normal.copy(a);
-        normal.cross(b);
-        normal.normalize();
-
-        if (normal.dot(centre) < 0) {
-            normal.multiplyScalar(-1);
-        }
-
-        write_plane(result, i, normal, -normal.dot(eye));
-    }
-
-    // ahead of the eye by `near`, and no further than `far` — the range the camera draws, which is
-    // the range a marquee can be selecting from
-    write_plane(result, 4, centre, -centre.dot(eye) - near);
-
-    normal.copy(centre).multiplyScalar(-1);
-
-    write_plane(result, 5, normal, centre.dot(eye) + far);
-}
-
-/**
- * @param {ArrayLike<number>} result
- * @param {number} index
- * @param {Vector3} n
- * @param {number} w
- */
-function write_plane(result, index, n, w) {
-    const address = index * 4;
-
-    result[address] = n.x;
-    result[address + 1] = n.y;
-    result[address + 2] = n.z;
-    result[address + 3] = w;
-}
+import { assert } from "../../src/core/assert.js";
+import Vector3 from "../../src/core/geom/Vector3.js";
+
+/**
+ * Planes the volume is made of: four sides, a near and a far.
+ *
+ * @type {number}
+ */
+export const SCREEN_RECT_FRUSTUM_PLANES = 6;
+
+/**
+ * @type {Vector3}
+ */
+const eye = new Vector3();
+
+/**
+ * The four corner directions and the one through the middle.
+ *
+ * @type {Vector3[]}
+ */
+const corners = [new Vector3(), new Vector3(), new Vector3(), new Vector3()];
+
+/**
+ * @type {Vector3}
+ */
+const centre = new Vector3();
+
+/**
+ * @type {Vector3}
+ */
+const normal = new Vector3();
+
+/**
+ * The volume a rectangle drawn on the screen means.
+ *
+ * **Built from the facade's own projection rays rather than from a camera object**, which is what
+ * makes it renderer-neutral: `viewportProjectionRay` is on both engines, answers in world space, and
+ * takes its origin from the eye — so the four corners of the rectangle give four directions from one
+ * point, and four side planes follow. The three version of this unprojected eight corners through a
+ * `THREE.Camera` and could only ever run on one renderer.
+ *
+ * **Each side plane's orientation is decided against the rectangle's own middle**, not against a
+ * winding convention. Which way a cross product points depends on the order the corners come in and
+ * on the handedness of the projection, and neither is a thing this should have an opinion about; the
+ * direction through the centre of the rectangle is inside the volume by construction, so it settles
+ * every sign in one step.
+ *
+ * Planes are written `nx, ny, nz, w` with the interior **positive**, which is what
+ * `aabb3_intersects_clipping_volume_array` tests for.
+ *
+ * @param {ArrayLike<number>|Float64Array} result at least `SCREEN_RECT_FRUSTUM_PLANES * 4` long
+ * @param {GraphicsEngine|GraphicsEngine} graphics
+ * @param {AABB2} rect clip space, −1…1, +Y up
+ * @param {number} near world units from the eye
+ * @param {number} far world units from the eye
+ */
+export function screen_rect_frustum(result, graphics, rect, near, far) {
+    assert.defined(result, 'result');
+    assert.defined(graphics, 'graphics');
+    assert.defined(rect, 'rect');
+    assert.isNumber(near, 'near');
+    assert.isNumber(far, 'far');
+
+    // around the rectangle rather than across it, so that consecutive pairs share an edge
+    const around = [
+        [rect.x0, rect.y1],
+        [rect.x1, rect.y1],
+        [rect.x1, rect.y0],
+        [rect.x0, rect.y0]
+    ];
+
+    for (let i = 0; i < 4; i++) {
+        graphics.viewportProjectionRay(around[i][0], around[i][1], eye, corners[i]);
+    }
+
+    graphics.viewportProjectionRay(
+        (rect.x0 + rect.x1) / 2,
+        (rect.y0 + rect.y1) / 2,
+        eye, centre
+    );
+
+    for (let i = 0; i < 4; i++) {
+        const a = corners[i];
+        const b = corners[(i + 1) % 4];
+
+        normal.copy(a);
+        normal.cross(b);
+        normal.normalize();
+
+        if (normal.dot(centre) < 0) {
+            normal.multiplyScalar(-1);
+        }
+
+        write_plane(result, i, normal, -normal.dot(eye));
+    }
+
+    // ahead of the eye by `near`, and no further than `far` — the range the camera draws, which is
+    // the range a marquee can be selecting from
+    write_plane(result, 4, centre, -centre.dot(eye) - near);
+
+    normal.copy(centre).multiplyScalar(-1);
+
+    write_plane(result, 5, normal, centre.dot(eye) + far);
+}
+
+/**
+ * @param {ArrayLike<number>} result
+ * @param {number} index
+ * @param {Vector3} n
+ * @param {number} w
+ */
+function write_plane(result, index, n, w) {
+    const address = index * 4;
+
+    result[address] = n.x;
+    result[address + 1] = n.y;
+    result[address + 2] = n.z;
+    result[address + 3] = w;
+}