three-cad-viewer 5.0.5 → 5.0.7

package/dist/three-cad-viewer.js

@@ -84005,7 +84005,10 @@ void main() {
 	 * `Uint32BufferAttribute` under this name; the pick pass reads it as an **integer**
 	 * attribute (`gpuType = THREE.IntType`, GLSL3 `in uint`) so ids stay exact past
 	 * 2^24. The geometry side must set `gpuType = THREE.IntType` on the attribute for
-	 * the pick shader to read it.
+	 * the pick shader to read it. Between the stages the id travels as two float
+	 * varyings (16-bit halves), deliberately NOT as a `flat uint` — see the note in
+	 * highlight.ts: a `flat` varying costs ~25x the scene's buffer bytes in graphics
+	 * memory under WebKit's ANGLE-on-Metal backend.
 	 */
 	const COMPONENT_ID_ATTRIBUTE = "componentId";
 	/**
@@ -84303,8 +84306,9 @@ void main() {
 	 */
 	const PICK_POINT_SIZE = 3;
 	/**
-	 * Shared GLSL3 MRT fragment shader for all pick materials (face/vertex/edge): packs
-	 * the flat `vId` into attachment 0 (byte order MUST match `packId()`: low byte in R)
+	 * Shared GLSL3 MRT fragment shader for all pick materials (face/vertex/edge):
+	 * reassembles the id from its two interpolated halves and packs it into attachment 0
+	 * (byte order MUST match `packId()`: low byte in R)
 	 * and writes the interpolated world position into attachment 1 (RGBA32F; `w=1` marks
 	 * "has position"). The fragment clip chunk only `discard`s (non-ALPHA_TO_COVERAGE),
 	 * so no `diffuseColor` symbol is required.
@@ -84312,13 +84316,15 @@ void main() {
 	const PICK_FRAGMENT_SHADER = /* glsl */ `
   #include <clipping_planes_pars_fragment>
 
-  flat in uint vId;
+  in float vIdLo;
+  in float vIdHi;
   in vec3 vWorldPos;
   layout(location = 0) out vec4 fragId;
   layout(location = 1) out vec4 fragPos;
 
   void main() {
     #include <clipping_planes_fragment>
+    uint vId = ( uint( vIdHi + 0.5 ) << 16 ) | uint( vIdLo + 0.5 );
     fragId = vec4(
       float( vId & 0xFFu ) / 255.0,
       float( ( vId >> 8 ) & 0xFFu ) / 255.0,
@@ -84336,19 +84342,24 @@ void main() {
 	function createFacePickMaterial(options = {}) {
 	    // GLSL3 (WebGL2). For a (non-Raw) ShaderMaterial three.js auto-injects
 	    // `in vec3 position;`, `uniform mat4 modelMatrix/modelViewMatrix/projectionMatrix`,
-	    // so we declare ONLY the custom integer attribute + flat varying. Integer
-	    // varyings MUST be `flat`. Clip chunks use legacy `varying`/`attribute` keywords
+	    // so we declare ONLY the custom integer attribute + the two id-half varyings
+	    // (float, interpolated — an integer varying would have to be `flat`, which is
+	    // the ANGLE-on-Metal memory trap described in highlight.ts; all vertices of a
+	    // primitive carry the same id, so interpolation + rounding is exact). Clip
+	    // chunks use legacy `varying`/`attribute` keywords
 	    // which three remaps via `#define` under GLSL3; the vertex chunk reads a local
 	    // `vec4 mvPosition`, which we compute before the include.
 	    const vertexShader = /* glsl */ `
     #include <clipping_planes_pars_vertex>
 
     in uint componentId;
-    flat out uint vId;
+    out float vIdLo;
+    out float vIdHi;
     out vec3 vWorldPos;
 
     void main() {
-      vId = componentId;
+      vIdLo = float( componentId & 0xFFFFu );
+      vIdHi = float( componentId >> 16 );
       vec4 worldPos = modelMatrix * vec4( position, 1.0 );
       vWorldPos = worldPos.xyz;
       vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
@@ -84387,13 +84398,15 @@ void main() {
     #include <clipping_planes_pars_vertex>
 
     in uint componentId;
-    flat out uint vId;
+    out float vIdLo;
+    out float vIdHi;
     out vec3 vWorldPos;
     uniform float uPickSize;
     uniform float uDepthBias;
 
     void main() {
-      vId = componentId;
+      vIdLo = float( componentId & 0xFFFFu );
+      vIdHi = float( componentId >> 16 );
       vec4 worldPos = modelMatrix * vec4( position, 1.0 );
       vWorldPos = worldPos.xyz;
       vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
@@ -84453,7 +84466,8 @@ void main() {
     in vec3 instanceEnd;
     in uint componentId;
 
-    flat out uint vId;
+    out float vIdLo;
+    out float vIdHi;
     out vec3 vWorldPos;
 
     void trimSegment( const in vec4 start, inout vec4 end ) {
@@ -84465,7 +84479,8 @@ void main() {
     }
 
     void main() {
-      vId = componentId;
+      vIdLo = float( componentId & 0xFFFFu );
+      vIdHi = float( componentId >> 16 );
 
       // World-space segment endpoints → approximate hit point along the edge.
       vWorldPos = ( position.y < 0.5 )
@@ -85003,20 +85018,41 @@ void main() {
 	//
 	// three upgrades stock materials to GLSL ES 3.00 on WebGL2 via `#define attribute
 	// in` / `#define varying out|in` macros (WebGLProgram.js), so writing `attribute` /
-	// `flat varying` here is converted automatically; `usampler2D` / `texelFetch` /
+	// `varying` here is converted automatically; `usampler2D` / `texelFetch` /
 	// integer attributes are then available.
+	//
+	// The component id crosses to the fragment stage as TWO ordinary (interpolated)
+	// float varyings holding its 16-bit halves — NOT as a `flat uint`. A `flat`
+	// varying is what an integer varying would require, and it is exactly what must
+	// be avoided here: under WebKit's ANGLE-on-Metal backend, every draw whose
+	// program has a `flat` varying makes ANGLE allocate a converted copy of the
+	// draw's index data (>= 64 KB each, pooled, never returned to the GL on
+	// deleteBuffer). With this varying on every visible material that was ~25x the
+	// scene's vertex/index bytes in graphics memory (26 MB of buffers -> 812 MB;
+	// 100 MB -> 2.3 GB) and it is charged to the page's WebContent process in the
+	// system WebKit, which killed build123d Studio at 16 GB after a few large
+	// shows. Without `flat` the same scene takes 63 MB / 160 MB. Measured 2026-09-17
+	// (working-docs/leak-harness.html + probe2.html, Playwright WebKit and Safari).
+	//
+	// Interpolating floats is exact for the id's purpose: every vertex of a face,
+	// every vertex of an instanced segment and a point carry the SAME id, so the
+	// interpolated value equals it up to rounding, and `uint(x + 0.5)` recovers it.
+	// Two 16-bit halves (both < 65536, exactly representable in float32) keep the
+	// full 32-bit id range that `applyComponentIds` promises.
 	// ---------------------------------------------------------------------------
 	/**
 	 * Shared state-fetch GLSL, injected into BOTH stages: the vertex stage needs it for
 	 * widening / point size, the fragment for color. Declares the sampler + texWidth +
-	 * the flat varying and a helper returning the component's {@link HighlightFlag} bits
-	 * (0 for background / nothing).
+	 * the two id-half varyings and a helper returning the component's
+	 * {@link HighlightFlag} bits (0 for background / nothing).
 	 */
 	const HL_STATE_GLSL = `
-flat varying uint vHighlightId;
+varying float vHighlightIdLo;
+varying float vHighlightIdHi;
 uniform highp usampler2D ${U_HIGHLIGHT_STATE};
 uniform int ${U_HIGHLIGHT_TEX_WIDTH};
 uint highlightState() {
+  uint vHighlightId = (uint(vHighlightIdHi + 0.5) << 16) | uint(vHighlightIdLo + 0.5);
   if (vHighlightId == 0u) return 0u;
   ivec2 hlUv = ivec2(
     int(vHighlightId) % ${U_HIGHLIGHT_TEX_WIDTH},
@@ -85031,8 +85067,8 @@ uint highlightState() {
 	const HL_VERTEX_HEADER = `
 attribute uint ${COMPONENT_ID_ATTRIBUTE};
 ${HL_STATE_GLSL}`;
-	/** Vertex main: forward the id. Injected right after `void main() {`. */
-	const HL_VERTEX_ASSIGN = `vHighlightId = ${COMPONENT_ID_ATTRIBUTE};`;
+	/** Vertex main: forward the id as two 16-bit halves. Injected right after `void main() {`. */
+	const HL_VERTEX_ASSIGN = `vHighlightIdLo = float(${COMPONENT_ID_ATTRIBUTE} & 0xFFFFu); vHighlightIdHi = float(${COMPONENT_ID_ATTRIBUTE} >> 16);`;
 	/** Fragment header: the shared state fetch + the two highlight colors. */
 	const HL_FRAGMENT_HEADER = `
 ${HL_STATE_GLSL}
@@ -85282,7 +85318,7 @@ uniform vec3 ${U_HIGHLIGHT_HOVER_COLOR};`;
 	                this.uniforms.uHighlightSelectedColor;
 	            shader.uniforms[U_HIGHLIGHT_HOVER_COLOR] =
 	                this.uniforms.uHighlightHoverColor;
-	            // Common: forward the component id as a flat varying.
+	            // Common: forward the component id (as two interpolated float halves).
 	            shader.vertexShader =
 	                HL_VERTEX_HEADER +
 	                    "\n" +
@@ -88814,7 +88850,14 @@ float metalnessFactor = metalness;
 	            group.name = `GridHelper-${i}`;
 	            group.add(new GridHelper(this.size, 2 * this.ticks, this.colors[this.theme][i === 0 ? 1 : i === 1 ? 0 : 2], this.colors[this.theme][i === 0 ? 0 : i === 1 ? 2 : 1], this.theme == "dark" ? 0x7777777 : 0xbbbbbb));
 	            let label;
-	            for (let x = -this.size / 2; x <= this.size / 2; x += this.delta / 2) {
+	            // A grid of no size has no labels, and asking for them hangs the tab:
+	            // `niceBounds` answers [0, 0, 0] for a bounding box whose largest extent
+	            // is zero - which is what an empty model gives it - so `delta` is zero
+	            // and the loop below steps by zero, never advancing and never throwing.
+	            // Guarded here rather than in `niceBounds`, whose answer is right: there
+	            // is nothing to place ticks on.
+	            const step = this.delta / 2;
+	            for (let x = -this.size / 2; step > 0 && x <= this.size / 2; x += step) {
 	                if (Math.abs(x) < 1e-6) {
 	                    continue;
 	                } // skip center label
@@ -97356,7 +97399,7 @@ float metalnessFactor = metalness;
 	    }
 	}
 
-	const version = "5.0.5";
+	const version = "5.0.7";
 
 	/**
 	 * `PickedComponent` over a GPU id-pick result. Drives the shader
@@ -110826,6 +110869,11 @@ void mainImage(const in vec4 inputColor, const in vec2 uv, const in float depth,
 	            deepDispose(this._rendered.camera);
 	            deepDispose(this._rendered.controls);
 	            deepDispose(this._rendered.treeview);
+	            // The orientation marker owns its own THREE.Scene (cones, labels, sphere,
+	            // axes), not part of the main scene above, so it needs its own dispose —
+	            // without it every clear()/render() cycle left 8 geometries and 3 programs
+	            // behind on the GL (measured 2026-09-17, working-docs/leak-harness.html).
+	            this._rendered.orientationMarker.dispose();
 	            // clear tree view
 	            this.display.clearCadTree();
 	            // clear info
@@ -112532,12 +112580,21 @@ void mainImage(const in vec4 inputColor, const in vec2 uv, const in float depth,
 	        this.renderer.setSize(cadWidth, height);
 	        // Resize the id pick target to match the canvas
 	        this.idPicker?.setSize(cadWidth, height);
-	        // Adapt display dimensions
+	        // Adapt display dimensions. `glass` and `tools` are part of the sizes:
+	        // setSizes widens the toolbar and the body by the tree only when the tree
+	        // sits beside the canvas (`tools && !glass`), and updates the tree and
+	        // info heights only outside glass mode. Leaving them out meant neither
+	        // branch could ever be taken from a resize, so a non-glass viewer got a
+	        // toolbar and a body of `cadWidth + 2` with a `treeWidth + cadWidth` row
+	        // inside them - measured as a 550px toolbar over 802px of content - and a
+	        // tree that kept its old height. `glassMode` passes both and was right.
 	        this.display.setSizes({
 	            treeWidth: treeWidth,
 	            treeHeight: this.state.get("treeHeight"),
 	            cadWidth: cadWidth,
 	            height: height,
+	            glass: glass,
+	            tools: this.state.get("tools"),
 	        });
 	        // Set glass state - subscription will update UI
 	        this.state.set("glass", glass);