@woosh/meep-engine 3.0.1 → 3.1.0

package/src/shade/renderer/geometry/primitives/make_torus_geometry.js

@@ -0,0 +1,107 @@
+import { Attribute } from "../Attribute.js";
+import { Geometry } from "../Geometry.js";
+import { StandardAttributes } from "../StandardAttributes.js";
+
+/**
+ * The ring lies in the XY plane and the hole runs along Z.
+ *
+ * @param {number} [radius] distance from the centre of the hole to the centre of the tube
+ * @param {number} [tube] radius of the tube itself
+ * @param {number} [radialSegments] segments around the tube
+ * @param {number} [tubularSegments] segments around the ring
+ * @param {number} [arc] how much of the ring to build, in radians; a full turn closes the surface
+ * @returns {Geometry}
+ */
+export function make_torus_geometry(radius = 1, tube = 0.4, radialSegments = 8, tubularSegments = 6, arc = Math.PI * 2) {
+
+    /*
+     A port of three's `TorusGeometry` onto `Geometry`: the same parameterisation and the same
+     winding, writing meep attributes instead of three ones.
+
+     Derived from three.js (https://github.com/mrdoob/three.js), Copyright (c) 2010-2024 three.js authors, MIT licence.
+    */
+
+    const geo = new Geometry();
+
+    geo.name = "Torus";
+
+    // segments
+
+    radialSegments = Math.floor(radialSegments);
+    tubularSegments = Math.floor(tubularSegments);
+
+    // buffers
+
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+
+    // generate vertices, normals and uvs
+
+    for (let j = 0; j <= radialSegments; j++) {
+
+        for (let i = 0; i <= tubularSegments; i++) {
+
+            const u = i / tubularSegments * arc;
+            const v = j / radialSegments * Math.PI * 2;
+
+            // vertex
+
+            const vertex_x = (radius + tube * Math.cos(v)) * Math.cos(u);
+            const vertex_y = (radius + tube * Math.cos(v)) * Math.sin(u);
+            const vertex_z = tube * Math.sin(v);
+
+            vertices.push(vertex_x, vertex_y, vertex_z);
+
+            // normal, taken from the centre of the tube's cross-section out to the vertex
+
+            const center_x = radius * Math.cos(u);
+            const center_y = radius * Math.sin(u);
+
+            const normal_x = vertex_x - center_x;
+            const normal_y = vertex_y - center_y;
+            const normal_z = vertex_z;
+
+            const normal_length = Math.sqrt(normal_x * normal_x + normal_y * normal_y + normal_z * normal_z);
+
+            normals.push(normal_x / normal_length, normal_y / normal_length, normal_z / normal_length);
+
+            // uv
+
+            uvs.push(i / tubularSegments);
+            uvs.push(j / radialSegments);
+
+        }
+
+    }
+
+    // generate indices
+
+    for (let j = 1; j <= radialSegments; j++) {
+
+        for (let i = 1; i <= tubularSegments; i++) {
+
+            const a = (tubularSegments + 1) * j + i - 1;
+            const b = (tubularSegments + 1) * (j - 1) + i - 1;
+            const c = (tubularSegments + 1) * (j - 1) + i;
+            const d = (tubularSegments + 1) * j + i;
+
+            // faces
+
+            indices.push(a, b, d);
+            indices.push(b, c, d);
+
+        }
+
+    }
+
+    // build geometry
+
+    geo.index = Attribute.from(new Uint32Array(indices), 1, 'index');
+    geo.addAttribute(Attribute.from(new Float32Array(vertices), 3, StandardAttributes.Position));
+    geo.addAttribute(Attribute.from(new Float32Array(normals), 3, StandardAttributes.Normal));
+    geo.addAttribute(Attribute.from(new Float32Array(uvs), 2, StandardAttributes.TextureCoordinates0));
+
+    return geo;
+}

package/src/shade/renderer/geometry/primitives/make_torus_knot_geometry.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A (p, q) torus knot: a tube swept along a curve that winds `p` times around the axis of a torus
+ * and `q` times around its tube. `p` and `q` coprime give a knot; sharing a factor gives a link.
+ *
+ * @param {number} [radius] radius of the torus the curve winds around
+ * @param {number} [tube] radius of the swept tube
+ * @param {number} [tubularSegments] segments along the curve
+ * @param {number} [radialSegments] segments around the tube
+ * @param {number} [p] turns around the torus axis
+ * @param {number} [q] turns around the torus tube
+ * @returns {Geometry}
+ */
+export function make_torus_knot_geometry(radius?: number, tube?: number, tubularSegments?: number, radialSegments?: number, p?: number, q?: number): Geometry;
+import { Geometry } from "../Geometry.js";
+//# sourceMappingURL=make_torus_knot_geometry.d.ts.map

package/src/shade/renderer/geometry/primitives/make_torus_knot_geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make_torus_knot_geometry.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/primitives/make_torus_knot_geometry.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;GAWG;AACH,kDARW,MAAM,SACN,MAAM,oBACN,MAAM,mBACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,QAAQ,CAsHpB;yBA1IwB,gBAAgB"}

package/src/shade/renderer/geometry/primitives/make_torus_knot_geometry.js

@@ -0,0 +1,165 @@
+import { Vector3 } from "../../../../core/geom/Vector3.js";
+import { Attribute } from "../Attribute.js";
+import { Geometry } from "../Geometry.js";
+import { StandardAttributes } from "../StandardAttributes.js";
+
+const P1 = new Vector3();
+const P2 = new Vector3();
+
+const B = new Vector3();
+const T = new Vector3();
+const N = new Vector3();
+
+/**
+ * A (p, q) torus knot: a tube swept along a curve that winds `p` times around the axis of a torus
+ * and `q` times around its tube. `p` and `q` coprime give a knot; sharing a factor gives a link.
+ *
+ * @param {number} [radius] radius of the torus the curve winds around
+ * @param {number} [tube] radius of the swept tube
+ * @param {number} [tubularSegments] segments along the curve
+ * @param {number} [radialSegments] segments around the tube
+ * @param {number} [p] turns around the torus axis
+ * @param {number} [q] turns around the torus tube
+ * @returns {Geometry}
+ */
+export function make_torus_knot_geometry(radius = 1, tube = 0.4, tubularSegments = 64, radialSegments = 8, p = 2, q = 3) {
+
+    /*
+     A port of three's `TorusKnotGeometry` onto `Geometry`: the same curve, the same extrusion frame
+     and the same winding, writing meep attributes instead of three ones.
+
+     Derived from three.js (https://github.com/mrdoob/three.js), Copyright (c) 2010-2024 three.js authors, MIT licence.
+    */
+
+    const geo = new Geometry();
+
+    geo.name = "TorusKnot";
+
+    // segments
+
+    tubularSegments = Math.floor(tubularSegments);
+    radialSegments = Math.floor(radialSegments);
+
+    // buffers
+
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+
+    // generate vertices, normals and uvs
+
+    for (let i = 0; i <= tubularSegments; ++i) {
+
+        // the radian "u" is used to calculate the position on the torus curve of the current tubular segment
+
+        const u = i / tubularSegments * p * Math.PI * 2;
+
+        // now we calculate two points. P1 is our current position on the curve, P2 is a little farther ahead.
+        // these points are used to create a special "coordinate space", which is necessary to calculate the correct vertex positions
+
+        calculatePositionOnCurve(u, p, q, radius, P1);
+        calculatePositionOnCurve(u + 0.01, p, q, radius, P2);
+
+        // calculate orthonormal basis
+
+        T.subVectors(P2, P1);
+        N.addVectors(P2, P1);
+        B.crossVectors(T, N);
+        N.crossVectors(B, T);
+
+        // normalize B, N. T can be ignored, we don't use it
+
+        B.normalize();
+        N.normalize();
+
+        for (let j = 0; j <= radialSegments; ++j) {
+
+            // now calculate the vertices. they are nothing more than an extrusion of the torus curve.
+            // because we extrude a shape in the xy-plane, there is no need to calculate a z-value.
+
+            const v = j / radialSegments * Math.PI * 2;
+            const cx = -tube * Math.cos(v);
+            const cy = tube * Math.sin(v);
+
+            // now calculate the final vertex position.
+            // first we orient the extrusion with our basis vectors, then we add it to the current position on the curve
+
+            const vertex_x = P1.x + (cx * N.x + cy * B.x);
+            const vertex_y = P1.y + (cx * N.y + cy * B.y);
+            const vertex_z = P1.z + (cx * N.z + cy * B.z);
+
+            vertices.push(vertex_x, vertex_y, vertex_z);
+
+            // normal (P1 is always the center/origin of the extrusion, thus we can use it to calculate the normal)
+
+            const normal_x = vertex_x - P1.x;
+            const normal_y = vertex_y - P1.y;
+            const normal_z = vertex_z - P1.z;
+
+            const normal_length = Math.sqrt(normal_x * normal_x + normal_y * normal_y + normal_z * normal_z);
+
+            normals.push(normal_x / normal_length, normal_y / normal_length, normal_z / normal_length);
+
+            // uv
+
+            uvs.push(i / tubularSegments);
+            uvs.push(j / radialSegments);
+
+        }
+
+    }
+
+    // generate indices
+
+    for (let j = 1; j <= tubularSegments; j++) {
+
+        for (let i = 1; i <= radialSegments; i++) {
+
+            const a = (radialSegments + 1) * (j - 1) + (i - 1);
+            const b = (radialSegments + 1) * j + (i - 1);
+            const c = (radialSegments + 1) * j + i;
+            const d = (radialSegments + 1) * (j - 1) + i;
+
+            // faces
+
+            indices.push(a, b, d);
+            indices.push(b, c, d);
+
+        }
+
+    }
+
+    // build geometry
+
+    geo.index = Attribute.from(new Uint32Array(indices), 1, 'index');
+    geo.addAttribute(Attribute.from(new Float32Array(vertices), 3, StandardAttributes.Position));
+    geo.addAttribute(Attribute.from(new Float32Array(normals), 3, StandardAttributes.Normal));
+    geo.addAttribute(Attribute.from(new Float32Array(uvs), 2, StandardAttributes.TextureCoordinates0));
+
+    return geo;
+}
+
+/**
+ * The point on the knot's curve at parameter `u`.
+ *
+ * @param {number} u
+ * @param {number} p
+ * @param {number} q
+ * @param {number} radius
+ * @param {Vector3} position
+ */
+function calculatePositionOnCurve(u, p, q, radius, position) {
+
+    const cu = Math.cos(u);
+    const su = Math.sin(u);
+    const quOverP = q / p * u;
+    const cs = Math.cos(quOverP);
+
+    position.set(
+        radius * (2 + cs) * 0.5 * cu,
+        radius * (2 + cs) * su * 0.5,
+        radius * Math.sin(quOverP) * 0.5
+    );
+
+}

package/src/shade/renderer/postprocess/gtao/generate_magic_square_noise.d.ts

@@ -1,5 +1,9 @@
 /**
- * Taken from THREE.js GTAO implementation, not very good for what it's intended for
+ * Taken from three's GTAO implementation (`examples/jsm/shaders/GTAOShader.js`), not very good
+ * for what it is intended for.
+ *
+ * Derived from three.js (https://github.com/mrdoob/three.js), Copyright (c) 2010-2024 three.js authors, MIT licence.
+ *
  * @param {number} size
  * @returns {ShadeTexture}
  */

package/src/shade/renderer/postprocess/gtao/generate_magic_square_noise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate_magic_square_noise.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/generate_magic_square_noise.js"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,gDAHW,MAAM,GACJ,YAAY,CAmCxB;6BA3C4B,+BAA+B"}
+{"version":3,"file":"generate_magic_square_noise.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/generate_magic_square_noise.js"],"names":[],"mappings":"AAOA;;;;;;;;GAQG;AACH,gDAHW,MAAM,GACJ,YAAY,CAmCxB;6BA/C4B,+BAA+B"}

package/src/shade/renderer/postprocess/gtao/generate_magic_square_noise.js

@@ -1,47 +1,51 @@
-import Vector3 from "../../../../core/geom/Vector3.js";
-import { Sampler2D } from "../../../../engine/graphics/texture/sampler/Sampler2D.js";
-import { ShadeTexture } from "../../texture/ShadeTexture.js";
-import { ShadeImage } from "../../texture/source/ShadeImage.js";
-import { TextureWrapType } from "../../texture/TextureWrapType.js";
-import { generateMagicSquare } from "./generate_magic_square.js";
-
-/**
- * Taken from THREE.js GTAO implementation, not very good for what it's intended for
- * @param {number} size
- * @returns {ShadeTexture}
- */
-export function generateMagicSquareNoise(size = 5) {
-
-    const noiseSize = Math.floor(size) % 2 === 0 ? Math.floor(size) + 1 : Math.floor(size);
-    const magicSquare = generateMagicSquare(noiseSize);
-    const noiseSquareSize = magicSquare.length;
-    const data = new Uint8Array(noiseSquareSize * 4);
-
-    for (let inx = 0; inx < noiseSquareSize; ++inx) {
-
-        const iAng = magicSquare[inx];
-        const angle = (2 * Math.PI * iAng) / noiseSquareSize;
-        const randomVec = new Vector3(
-            Math.cos(angle),
-            Math.sin(angle),
-            0
-        );
-
-        randomVec.normalize();
-
-        data[inx * 4] = (randomVec.x * 0.5 + 0.5) * 255;
-        data[inx * 4 + 1] = (randomVec.y * 0.5 + 0.5) * 255;
-        data[inx * 4 + 2] = 127;
-        data[inx * 4 + 3] = 255;
-
-    }
-
-    const texture = ShadeTexture.from(ShadeImage.fromSampler2D(new Sampler2D(data, 4, noiseSize, noiseSize)));
-
-    texture.wrapS = TextureWrapType.Repeat;
-    texture.wrapT = TextureWrapType.Repeat;
-
-    return texture;
-
-}
-
+import Vector3 from "../../../../core/geom/Vector3.js";
+import { Sampler2D } from "../../../../engine/graphics/texture/sampler/Sampler2D.js";
+import { ShadeTexture } from "../../texture/ShadeTexture.js";
+import { ShadeImage } from "../../texture/source/ShadeImage.js";
+import { TextureWrapType } from "../../texture/TextureWrapType.js";
+import { generateMagicSquare } from "./generate_magic_square.js";
+
+/**
+ * Taken from three's GTAO implementation (`examples/jsm/shaders/GTAOShader.js`), not very good
+ * for what it is intended for.
+ *
+ * Derived from three.js (https://github.com/mrdoob/three.js), Copyright (c) 2010-2024 three.js authors, MIT licence.
+ *
+ * @param {number} size
+ * @returns {ShadeTexture}
+ */
+export function generateMagicSquareNoise(size = 5) {
+
+    const noiseSize = Math.floor(size) % 2 === 0 ? Math.floor(size) + 1 : Math.floor(size);
+    const magicSquare = generateMagicSquare(noiseSize);
+    const noiseSquareSize = magicSquare.length;
+    const data = new Uint8Array(noiseSquareSize * 4);
+
+    for (let inx = 0; inx < noiseSquareSize; ++inx) {
+
+        const iAng = magicSquare[inx];
+        const angle = (2 * Math.PI * iAng) / noiseSquareSize;
+        const randomVec = new Vector3(
+            Math.cos(angle),
+            Math.sin(angle),
+            0
+        );
+
+        randomVec.normalize();
+
+        data[inx * 4] = (randomVec.x * 0.5 + 0.5) * 255;
+        data[inx * 4 + 1] = (randomVec.y * 0.5 + 0.5) * 255;
+        data[inx * 4 + 2] = 127;
+        data[inx * 4 + 3] = 255;
+
+    }
+
+    const texture = ShadeTexture.from(ShadeImage.fromSampler2D(new Sampler2D(data, 4, noiseSize, noiseSize)));
+
+    texture.wrapS = TextureWrapType.Repeat;
+    texture.wrapT = TextureWrapType.Repeat;
+
+    return texture;
+
+}
+

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -49,7 +49,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#124@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#126@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/shader/chunk/texture/chunk_texture_filter_fxaa_lite.d.ts

@@ -5,6 +5,8 @@
  * `chunk_texture_filter_fxaa_quality`.
  *
  * Adapted from an early three.js port (mrdoob/three.js@d7d25d3 examples/jsm/shaders/FXAAShader.js).
+ *
+ * Derived from three.js (https://github.com/mrdoob/three.js), Copyright (c) 2010-2024 three.js authors, MIT licence.
  * @type {CodeChunk}
  */
 export const chunk_texture_filter_fxaa_lite: CodeChunk;

package/src/shade/renderer/shader/chunk/texture/chunk_texture_filter_fxaa_lite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_texture_filter_fxaa_lite.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/texture/chunk_texture_filter_fxaa_lite.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,6CAFU,SAAS,CAqNjB;0BA/NwB,6BAA6B"}
+{"version":3,"file":"chunk_texture_filter_fxaa_lite.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/texture/chunk_texture_filter_fxaa_lite.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,6CAFU,SAAS,CAqNjB;0BAjOwB,6BAA6B"}