Merge pull request #362 from xyz-tools/share-ring-trig

Share the precomputed sin/cos ring across ExtrusionGeometry instances

Author: remcoder

src/__tests__/extrusion-geometry.ts

@@ -127,6 +127,35 @@ test('ExtrusionGeometry produces the same ring for every point on the path', ()
   expect(secondRing).toEqual(firstRing);
 });
 
+test('ExtrusionGeometry produces identical rings across instances', () => {
+  // The trig table is cached at module level and shared between instances, so
+  // two geometries with the same radialSegments must produce identical rings.
+  const radialSegments = 4;
+  const ring = (radialSegments + 1) * 3;
+  const points = [new Vector3(0, 0, 0), new Vector3(1, 0, 0)];
+  const first = new ExtrusionGeometry(points, 0.6, 0.2, radialSegments);
+  const second = new ExtrusionGeometry(points, 0.6, 0.2, radialSegments);
+
+  const firstRing = Array.from(first.attributes.normal.array.slice(0, ring));
+  const secondRing = Array.from(second.attributes.normal.array.slice(0, ring));
+
+  expect(secondRing).toEqual(firstRing);
+});
+
+test('ExtrusionGeometry builds a distinct ring per radialSegments value', () => {
+  // A different radialSegments takes the cache-miss path and yields its own
+  // table rather than reusing another entry.
+  const points = [new Vector3(0, 0, 0), new Vector3(1, 0, 0)];
+  const coarse = new ExtrusionGeometry(points, 0.6, 0.2, 3);
+  const fine = new ExtrusionGeometry(points, 0.6, 0.2, 5);
+
+  expect(coarse.attributes.normal.count).toBe((points.length + 1) * 4);
+  expect(fine.attributes.normal.count).toBe((points.length + 1) * 6);
+  expect(Array.from(coarse.attributes.normal.array.slice(0, 12))).not.toEqual(
+    Array.from(fine.attributes.normal.array.slice(0, 12))
+  );
+});
+
 test('ExtrusionGeometry orients each corner independently', () => {
   // The corner vectors are scratch objects shared between points, so stale
   // state from one point leaking into the next would show up as a corner

src/extrusion-geometry.ts

@@ -1,5 +1,28 @@
 import { BufferAttribute, BufferGeometry, Vector2, Vector3 } from 'three';
 
+// The ring of sines and cosines depends only on radialSegments, and in
+// practice every geometry is built with the same value, so the tables are
+// cached at module level and shared across all ExtrusionGeometry instances.
+// The cached arrays are shared: they must only ever be read, never mutated.
+const ringCache = new Map<number, { sin: Float64Array; cos: Float64Array }>();
+
+function ringTrig(radialSegments: number): { sin: Float64Array; cos: Float64Array } {
+  let ring = ringCache.get(radialSegments);
+  if (ring) return ring;
+
+  const sin = new Float64Array(radialSegments + 1);
+  const cos = new Float64Array(radialSegments + 1);
+  for (let j = 0; j <= radialSegments; j++) {
+    const angle = (j / radialSegments) * Math.PI * 2;
+    sin[j] = Math.sin(angle);
+    cos[j] = -Math.cos(angle);
+  }
+
+  ring = { sin, cos };
+  ringCache.set(radialSegments, ring);
+  return ring;
+}
+
 /**
  * A geometry class for extruding 3D paths into volumetric shapes
  */
@@ -73,17 +96,8 @@ class ExtrusionGeometry extends BufferGeometry {
     const uvCount = points.length * ringSize;
     const indexCount = Math.max(0, points.length - 1) * radialSegments * 6;
 
-    // The ring of sines and cosines depends only on j, which runs from 0 to
-    // radialSegments, so it is the same for every point on the path. Computing
-    // it once keeps a large model from making a million trig calls to produce a
-    // handful of distinct values.
-    const ringSin = new Float64Array(radialSegments + 1);
-    const ringCos = new Float64Array(radialSegments + 1);
-    for (let j = 0; j <= radialSegments; j++) {
-      const angle = (j / radialSegments) * Math.PI * 2;
-      ringSin[j] = Math.sin(angle);
-      ringCos[j] = -Math.cos(angle);
-    }
+    // Shared, read-only trig tables (see ringCache above); do not mutate.
+    const { sin: ringSin, cos: ringCos } = ringTrig(radialSegments);
 
     const vertices = new Float32Array(vertexCount * 3);
     const normals = new Float32Array(vertexCount * 3);