forgecad 0.9.7 → 0.9.8

package/dist/assets/{sectionPlaneMath-BdTjyVfs.js → scalar-sampling-budget-iBAeF8RM.js}

@@ -10605,7 +10605,7 @@ async function initManifoldWasm() {
   if (_wasm$1) return _wasm$1;
   performance.mark("manifold:start");
   const Module = (await __vitePreload(async () => {
-    const { default: __vite_default__ } = await import("./manifold-DjYsd7A_.js");
+    const { default: __vite_default__ } = await import("./manifold-C6-sZYQN.js");
     return { default: __vite_default__ };
   }, true ? [] : void 0)).default;
   performance.mark("manifold:imported");
@@ -94501,6 +94501,19 @@ const Viewport = {
     collectRenderLabel(text, at, options);
   }
 };
+const NO_SURFACE_FIELD = {
+  enabled: false,
+  kind: "precision",
+  baseColor: "#000000",
+  darkColor: "#000000",
+  lineColor: "#000000",
+  nodeColor: "#000000",
+  accentColor: "#000000",
+  spacing: 1,
+  lineWidth: 0.01,
+  glow: 0,
+  objectColorMix: 0
+};
 const DEFAULT_RENDER_STYLE = "classic";
 const RENDER_STYLE_OPTIONS = [
   {
@@ -94522,6 +94535,16 @@ const RENDER_STYLE_OPTIONS = [
     id: "glass",
     label: "Glass",
     description: "Showcase lighting for authored transparent materials."
+  },
+  {
+    id: "precision",
+    label: "Precision",
+    description: "Dense, thin surface-field contours for technical inspection."
+  },
+  {
+    id: "hybrid",
+    label: "Hybrid",
+    description: "Topo-led surface contours with a quiet orthogonal field."
   }
 ];
 const RENDER_STYLE_IDS = new Set(RENDER_STYLE_OPTIONS.map((option) => option.id));
@@ -94577,7 +94600,8 @@ const PRESETS = {
       color: "#ffffff",
       opacity: 0,
       scale: 1
-    }
+    },
+    surfaceField: NO_SURFACE_FIELD
   },
   studio: {
     id: "studio",
@@ -94630,7 +94654,8 @@ const PRESETS = {
       color: "#f7fffb",
       opacity: 0.055,
       scale: 1.006
-    }
+    },
+    surfaceField: NO_SURFACE_FIELD
   },
   fast: {
     id: "fast",
@@ -94683,7 +94708,8 @@ const PRESETS = {
       color: "#fff6df",
       opacity: 0,
       scale: 1
-    }
+    },
+    surfaceField: NO_SURFACE_FIELD
   },
   glass: {
     id: "glass",
@@ -94736,6 +94762,139 @@ const PRESETS = {
       color: "#e8fff8",
       opacity: 0.13,
       scale: 1.012
+    },
+    surfaceField: NO_SURFACE_FIELD
+  },
+  precision: {
+    id: "precision",
+    label: "Precision",
+    background: "#0c1011",
+    toneMappingExposure: 1.06,
+    environmentIntensity: 0.35,
+    canvasDpr: { live: 1, idleMax: 1.45 },
+    lights: {
+      ambientIntensity: 0.36,
+      keyIntensity: 1.25,
+      keyColor: "#f2fff9",
+      keyPosition: [95, -120, 145],
+      fillIntensity: 0.32,
+      fillColor: "#cbeee8",
+      fillPosition: [-80, 70, 80],
+      rimIntensity: 0.28,
+      rimColor: "#d1fff7",
+      rimPosition: [-105, -75, 120],
+      hemisphereSky: "#d1fff7",
+      hemisphereGround: "#111616",
+      hemisphereIntensity: 0.3
+    },
+    material: {
+      metalness: 0,
+      roughness: 0.68,
+      clearcoat: 0,
+      clearcoatRoughness: 0.6,
+      reflectivity: 0.18,
+      specularIntensity: 0.62,
+      opacity: 1,
+      transmission: 0,
+      thickness: 0,
+      authoredTransparent: {
+        roughness: 0.42,
+        clearcoat: 0.08,
+        clearcoatRoughness: 0.46,
+        reflectivity: 0.24,
+        specularIntensity: 0.72,
+        transmission: 0,
+        thickness: 0.2
+      }
+    },
+    edge: {
+      color: "#d1fff7",
+      opacity: 0.26
+    },
+    glassShell: {
+      enabled: false,
+      color: "#d1fff7",
+      opacity: 0,
+      scale: 1
+    },
+    surfaceField: {
+      enabled: true,
+      kind: "precision",
+      baseColor: "#3d5659",
+      darkColor: "#070b0c",
+      lineColor: "#d1fff7",
+      nodeColor: "#fff4bc",
+      accentColor: "#ffb66f",
+      spacing: 0.22,
+      lineWidth: 36e-4,
+      glow: 0.2,
+      objectColorMix: 0.35
+    }
+  },
+  hybrid: {
+    id: "hybrid",
+    label: "Hybrid",
+    background: "#0b1312",
+    toneMappingExposure: 1.08,
+    environmentIntensity: 0.42,
+    canvasDpr: { live: 1, idleMax: 1.45 },
+    lights: {
+      ambientIntensity: 0.38,
+      keyIntensity: 1.32,
+      keyColor: "#f2fff9",
+      keyPosition: [100, -125, 145],
+      fillIntensity: 0.34,
+      fillColor: "#c9fff2",
+      fillPosition: [-80, 78, 85],
+      rimIntensity: 0.34,
+      rimColor: "#d7ff86",
+      rimPosition: [-105, -80, 125],
+      hemisphereSky: "#bfffee",
+      hemisphereGround: "#101810",
+      hemisphereIntensity: 0.32
+    },
+    material: {
+      metalness: 0,
+      roughness: 0.66,
+      clearcoat: 0,
+      clearcoatRoughness: 0.6,
+      reflectivity: 0.2,
+      specularIntensity: 0.66,
+      opacity: 1,
+      transmission: 0,
+      thickness: 0,
+      authoredTransparent: {
+        roughness: 0.4,
+        clearcoat: 0.08,
+        clearcoatRoughness: 0.46,
+        reflectivity: 0.24,
+        specularIntensity: 0.74,
+        transmission: 0,
+        thickness: 0.2
+      }
+    },
+    edge: {
+      color: "#defdf7",
+      opacity: 0.28
+    },
+    glassShell: {
+      enabled: false,
+      color: "#defdf7",
+      opacity: 0,
+      scale: 1
+    },
+    surfaceField: {
+      enabled: true,
+      kind: "hybrid",
+      baseColor: "#32645e",
+      darkColor: "#07100f",
+      lineColor: "#95fff0",
+      nodeColor: "#ffe098",
+      accentColor: "#d7ff86",
+      spacing: 0.3,
+      lineWidth: 5e-3,
+      glow: 0.4,
+      objectColorMix: 0.28
     }
   }
 };
@@ -339496,6 +339655,14 @@ function createForgeRuntimeModule(bindings) {
   runtime.default = runtime;
   return runtime;
 }
+function finalizeForgeJsImport(moduleExports, importedDims) {
+  if (moduleExports instanceof Assembly) {
+    return new ImportedAssembly(moduleExports, moduleExports.getReferences());
+  }
+  if (!(moduleExports instanceof Shape$1)) return moduleExports;
+  if (importedDims.length === 0) return moduleExports;
+  return setShapeDimensions(moduleExports, [...getShapeDimensions(moduleExports), ...importedDims]);
+}
 const DEFAULT_RAYMARCH_STEPS = 360;
 const MIN_RAYMARCH_STEP = 0.012;
 function classifySdfPreviewNode(node) {
@@ -340417,7 +340584,7 @@ function isRenderableEntryResult(value) {
   return containsRenderableLeaf(value, /* @__PURE__ */ new WeakSet());
 }
 function containsRenderableLeaf(value, seen2) {
-  if (value instanceof Shape$1 || value instanceof Sketch || value instanceof SdfShape || value instanceof ShapeGroup || value instanceof GCodeBuilder || value instanceof Assembly || value instanceof SolvedAssembly) {
+  if (value instanceof Shape$1 || value instanceof Sketch || value instanceof SdfShape || value instanceof ShapeGroup || value instanceof GCodeBuilder || value instanceof Assembly || value instanceof ImportedAssembly || value instanceof SolvedAssembly) {
     return true;
   }
   if (!value || typeof value !== "object") return false;
@@ -340439,11 +340606,6 @@ function hasExplicitModuleExports(exportsValue, initialExportsRef) {
   const keys = Object.keys(exportsValue);
   return keys.some((key) => key !== "__esModule");
 }
-function finalizeForgeJsImport(moduleExports, importedDims) {
-  if (!(moduleExports instanceof Shape$1)) return moduleExports;
-  if (importedDims.length === 0) return moduleExports;
-  return setShapeDimensions(moduleExports, [...getShapeDimensions(moduleExports), ...importedDims]);
-}
 function mapScriptResultToScene(args) {
   var _a3;
   const objects = [];
@@ -340571,6 +340733,19 @@ function mapScriptResultToScene(args) {
       value.solve().toSceneObjects().forEach((item, index2) => processNamedItem(item, `${name}.${index2 + 1}`, `${index2 + 1}`, name, treePath, inheritedTags));
       return;
     }
+    if (value instanceof ImportedAssembly) {
+      const group2 = value.toGroup();
+      group2.children.forEach((child, index2) => {
+        flattenGroupChild(
+          child,
+          groupChildLabel(group2, name, index2),
+          name,
+          [...treePath, shapeGroupChildSegment(group2, index2)],
+          mergeSceneTags(inheritedTags, group2.tagsForChild(index2))
+        );
+      });
+      return;
+    }
     if (value instanceof SolvedAssembly) {
       value.toSceneObjects().forEach((item, index2) => processNamedItem(item, `${name}.${index2 + 1}`, `${index2 + 1}`, name, treePath, inheritedTags));
       return;
@@ -340726,6 +340901,12 @@ function mapScriptResultToScene(args) {
       const label = `Object ${index2 + 1}`;
       processNamedItem(item, label, label);
     });
+  } else if (result instanceof ImportedAssembly) {
+    const group2 = result.toGroup();
+    group2.children.forEach((child, index2) => {
+      const label = rootGroupChildLabel(group2, index2);
+      flattenGroupChild(child, label, void 0, [label], group2.tagsForChild(index2));
+    });
   } else if (result instanceof ShapeGroup) {
     result.children.forEach((child, i) => {
       const label = rootGroupChildLabel(result, i);
@@ -340764,7 +340945,7 @@ function mapScriptResultToScene(args) {
       }
       processRenderableTree(item, label, label);
     });
-  } else if (result !== null && typeof result === "object" && !Array.isArray(result) && !(result instanceof Shape$1) && !(result instanceof Sketch) && !(result instanceof SdfShape) && !(result instanceof ShapeGroup) && !(result instanceof GCodeBuilder) && !(result instanceof Assembly) && !(result instanceof SolvedAssembly)) {
+  } else if (result !== null && typeof result === "object" && !Array.isArray(result) && !(result instanceof Shape$1) && !(result instanceof Sketch) && !(result instanceof SdfShape) && !(result instanceof ShapeGroup) && !(result instanceof GCodeBuilder) && !(result instanceof Assembly) && !(result instanceof ImportedAssembly) && !(result instanceof SolvedAssembly)) {
     const obj = result;
     const defaultValue = obj.default;
     if (defaultValue && isRenderableEntryResult(defaultValue)) {
@@ -340852,7 +341033,7 @@ Fix one:
     sketch: objects.length === 1 ? objects[0].sketch : null,
     objects,
     extraDimensions: shapeDimensions,
-    error: objects.length > 0 || args.allowEmptyResult ? null : "No renderable objects found. Return a Shape, Sketch, SdfShape, array, or object tree containing renderable values."
+    error: objects.length > 0 || args.allowEmptyResult ? null : "No renderable objects found. Return a Shape, Sketch, SdfShape, Assembly, ImportedAssembly, array, or object tree containing renderable values."
   };
 }
 const FORGE_RUNTIME_MODULE_SPECIFIERS = /* @__PURE__ */ new Set(["forgecad", "@forge/runtime", "@forgecad/runtime"]);
@@ -341149,6 +341330,7 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
       composeChain,
       assembly,
       Assembly,
+      ImportedAssembly,
       port: () => {
         throw new Error("port() has been renamed to connector(). Update your script.");
       },
@@ -341795,10 +341977,16 @@ function analyzeCollisionIntersections(entries, rawOptions = {}) {
   const collisions = [];
   const preparedEntries = entries.map((entry) => prepareEntry(entry));
   const { pairs: candidatePairs, bboxPairChecks } = collectCandidatePairs(preparedEntries, options);
-  const limitedCandidatePairs = options.maxCandidatePairs === null ? candidatePairs : candidatePairs.slice(0, options.maxCandidatePairs);
-  const pairLimitSkippedPairCount = candidatePairs.length - limitedCandidatePairs.length;
+  const exactCandidatePairs = candidatePairs.filter((pair) => pair.bboxOverlapVolume > options.minOverlapVolume);
+  const bboxVolumePrunedPairCount = candidatePairs.length - exactCandidatePairs.length;
+  const limitedCandidatePairs = options.maxCandidatePairs === null ? exactCandidatePairs : exactCandidatePairs.slice(0, options.maxCandidatePairs);
+  const pairLimitSkippedPairCount = exactCandidatePairs.length - limitedCandidatePairs.length;
   let testedPairCount = 0;
   let timeBudgetStopped = false;
+  const exactCheckedKeys = /* @__PURE__ */ new Set();
+  const pairKey = (pair) => `${pair.sourceIndex}:${pair.targetIndex}`;
+  const exactCandidateKeys = new Set(exactCandidatePairs.map(pairKey));
+  const limitedCandidateKeys = new Set(limitedCandidatePairs.map(pairKey));
   const exactStarted = performance.now();
   for (const pair of limitedCandidatePairs) {
     if (options.maxElapsedMs !== null && (options.maxElapsedMs <= 0 || performance.now() - exactStarted >= options.maxElapsedMs)) {
@@ -341806,6 +341994,7 @@ function analyzeCollisionIntersections(entries, rawOptions = {}) {
       break;
     }
     testedPairCount += 1;
+    exactCheckedKeys.add(pairKey(pair));
     const a2 = preparedEntries[pair.sourceIndex];
     const b = preparedEntries[pair.targetIndex];
     try {
@@ -341836,10 +342025,11 @@ function analyzeCollisionIntersections(entries, rawOptions = {}) {
   const bboxCandidates = options.includeBBoxCandidates ? candidatePairs.map((pair, index2) => {
     const source = preparedEntries[pair.sourceIndex];
     const target = preparedEntries[pair.targetIndex];
-    const exactChecked = index2 < testedPairCount;
+    const exactChecked = exactCheckedKeys.has(pairKey(pair));
     let skippedBy;
     if (!exactChecked) {
-      skippedBy = index2 >= limitedCandidatePairs.length ? "pair-limit" : "time-budget";
+      const key = pairKey(pair);
+      skippedBy = !exactCandidateKeys.has(key) ? "bbox-volume-threshold" : limitedCandidateKeys.has(key) ? "time-budget" : "pair-limit";
     }
     return {
       index: index2 + 1,
@@ -341883,10 +342073,12 @@ function analyzeCollisionIntersections(entries, rawOptions = {}) {
       method: "aabb-bvh",
       allPairCount: preparedEntries.length * (preparedEntries.length - 1) / 2,
       bboxPairChecks,
+      bboxVolumePrunedPairCount,
       booleanPairChecks: testedPairCount
     },
     objectCount: objects.length,
     candidatePairCount: candidatePairs.length,
+    bboxVolumePrunedPairCount,
     testedPairCount,
     skippedPairCount,
     pairLimitSkippedPairCount,
@@ -341899,6 +342091,192 @@ function analyzeCollisionIntersections(entries, rawOptions = {}) {
     warnings
   };
 }
+const SURFACE_FIELD_VERTEX_SHADER = `
+  varying vec3 vWorldPos;
+  varying vec3 vNormalW;
+
+  void main() {
+    vec4 world = modelMatrix * vec4(position, 1.0);
+    vWorldPos = world.xyz;
+    vNormalW = normalize(mat3(modelMatrix) * normal);
+    gl_Position = projectionMatrix * viewMatrix * world;
+  }
+`;
+const SURFACE_FIELD_FRAGMENT_SHADER = `
+  uniform float uGlow;
+  uniform float uLineWidth;
+  uniform float uObjectColorMix;
+  uniform float uFieldScale;
+  uniform float uSpacing;
+  uniform int uFieldKind;
+  uniform vec3 uAccentColor;
+  uniform vec3 uBaseColor;
+  uniform vec3 uDarkColor;
+  uniform vec3 uLineColor;
+  uniform vec3 uNodeColor;
+  uniform vec3 uObjectColor;
+
+  varying vec3 vNormalW;
+  varying vec3 vWorldPos;
+
+  float gridLine(float coord, float spacing, float width) {
+    float distanceToLine = abs(fract(coord / spacing + 0.5) - 0.5) * spacing;
+    return 1.0 - smoothstep(width, width * 2.7, distanceToLine);
+  }
+
+  float intersectionFade(float axisNormal) {
+    return 1.0 - smoothstep(0.72, 0.98, abs(axisNormal));
+  }
+
+  void main() {
+    vec3 normalW = normalize(vNormalW);
+    vec3 viewDir = normalize(cameraPosition - vWorldPos);
+    vec3 lightDir = normalize(vec3(-0.38, 0.72, 0.58));
+    float lit = max(dot(normalW, lightDir), 0.0);
+    float rim = pow(1.0 - max(dot(normalW, viewDir), 0.0), 2.35);
+    vec3 fieldPos = vWorldPos / uFieldScale;
+
+    float xFade = intersectionFade(normalW.x);
+    float yFade = intersectionFade(normalW.y);
+    float zFade = intersectionFade(normalW.z);
+
+    float lx = gridLine(fieldPos.x, uSpacing, uLineWidth) * xFade;
+    float ly = gridLine(fieldPos.y, uSpacing, uLineWidth) * yFade;
+    float lz = gridLine(fieldPos.z, uSpacing, uLineWidth) * zFade;
+    float mx = gridLine(fieldPos.x, uSpacing * 0.5, uLineWidth * 0.52) * xFade * 0.34;
+    float my = gridLine(fieldPos.y, uSpacing * 0.5, uLineWidth * 0.52) * yFade * 0.34;
+    float mz = gridLine(fieldPos.z, uSpacing * 0.5, uLineWidth * 0.52) * zFade * 0.34;
+    float majorX = gridLine(fieldPos.x, uSpacing * 4.0, uLineWidth * 1.25) * xFade;
+    float majorY = gridLine(fieldPos.y, uSpacing * 4.0, uLineWidth * 1.25) * yFade;
+    float majorZ = gridLine(fieldPos.z, uSpacing * 4.0, uLineWidth * 1.25) * zFade;
+
+    float contour = max(max(lx, ly), lz);
+    float minorContour = max(max(mx, my), mz);
+    float majorContour = max(max(majorX, majorY), majorZ);
+    float pairNode = max(max(min(lx, ly), min(lx, lz)), min(ly, lz));
+    float topoScale = max(max(lz, mz), majorZ);
+    float lineMask = max(max(contour * 0.74, minorContour), majorContour * 0.54);
+    float nodeMask = pairNode * 0.035;
+
+    if (uFieldKind == 1) {
+      lineMask = max(topoScale, max(mx, my) * 0.42);
+      nodeMask = pairNode * 0.06;
+    }
+
+    vec3 body = mix(uBaseColor, uObjectColor, uObjectColorMix);
+    vec3 base = mix(uDarkColor, body, 0.34 + lit * 0.66) + rim * uAccentColor * 0.14;
+    vec3 color = mix(base, uLineColor, clamp(lineMask * 0.58, 0.0, 1.0));
+    color += uLineColor * lineMask * uGlow * 0.22;
+    color += uNodeColor * nodeMask * uGlow * 0.28;
+    color += sin(gl_FragCoord.y * 3.14159) * 0.008;
+
+    gl_FragColor = vec4(color, 1.0);
+  }
+`;
+const ZEBRA_STRIPE_SCALE = 18;
+const ZEBRA_STRIPE_SOFTNESS = 0.16;
+const ZEBRA_DARK_COLOR = "#05070a";
+const ZEBRA_LIGHT_COLOR = "#f2f4ec";
+const ZEBRA_ACCENT_COLOR = "#3bd6ff";
+const ZEBRA_STRIPE_VERTEX_SHADER = `
+  varying vec3 vViewNormal;
+  varying vec3 vViewPosition;
+
+  void main() {
+    vec4 viewPosition = modelViewMatrix * vec4(position, 1.0);
+    vViewPosition = viewPosition.xyz;
+    vViewNormal = normalize(normalMatrix * normal);
+    gl_Position = projectionMatrix * viewPosition;
+  }
+`;
+const ZEBRA_STRIPE_FRAGMENT_SHADER = `
+  precision highp float;
+
+  uniform vec3 uAccentColor;
+  uniform vec3 uDarkColor;
+  uniform vec3 uLightColor;
+  uniform float uStripeScale;
+  uniform float uStripeSoftness;
+
+  varying vec3 vViewNormal;
+  varying vec3 vViewPosition;
+
+  void main() {
+    vec3 normal = normalize(vViewNormal);
+    if (!gl_FrontFacing) {
+      normal = -normal;
+    }
+
+    vec3 eyeDirection = normalize(-vViewPosition);
+    vec3 reflection = normalize(reflect(-eyeDirection, normal));
+    float stripePhase = reflection.x * 0.92 + reflection.y * 0.28 + reflection.z * 0.18;
+    float stripeWave = sin(stripePhase * uStripeScale);
+    float stripeMask = smoothstep(-uStripeSoftness, uStripeSoftness, stripeWave);
+
+    float grazing = pow(1.0 - clamp(dot(normal, eyeDirection), 0.0, 1.0), 1.8);
+    float secondaryWave = sin((reflection.y - reflection.z * 0.45) * uStripeScale * 0.45);
+    float secondary = smoothstep(0.72, 1.0, secondaryWave) * 0.12;
+
+    vec3 bands = mix(uDarkColor, uLightColor, stripeMask);
+    vec3 color = mix(bands, uAccentColor, grazing * 0.18);
+    color += uLightColor * secondary * (0.35 + grazing * 0.4);
+
+    gl_FragColor = vec4(color, 1.0);
+  }
+`;
+function isVisibleColor(colors, vertexIndex) {
+  const offset2 = vertexIndex * 3;
+  return colors[offset2] > 1e-6 || colors[offset2 + 1] > 1e-6 || colors[offset2 + 2] > 1e-6;
+}
+function copyAttribute(attribute, vertexIndexes) {
+  const itemSize = attribute.itemSize;
+  const source = attribute.array;
+  const out = new Float32Array(vertexIndexes.length * itemSize);
+  vertexIndexes.forEach((vertexIndex, outIndex) => {
+    const sourceOffset = vertexIndex * itemSize;
+    const outOffset = outIndex * itemSize;
+    for (let component = 0; component < itemSize; component += 1) {
+      out[outOffset + component] = source[sourceOffset + component];
+    }
+  });
+  return new BufferAttribute(out, itemSize, attribute.normalized);
+}
+function selectedTriangleVertexIndexes(geometry, colors) {
+  const position = geometry.getAttribute("position");
+  if (!position || colors.length !== position.count * 3) return [];
+  const selected = [];
+  const index2 = geometry.getIndex();
+  if (index2) {
+    const values = index2.array;
+    for (let triangle = 0; triangle + 2 < index2.count; triangle += 3) {
+      const a2 = values[triangle];
+      const b = values[triangle + 1];
+      const c2 = values[triangle + 2];
+      if (isVisibleColor(colors, a2) || isVisibleColor(colors, b) || isVisibleColor(colors, c2)) {
+        selected.push(a2, b, c2);
+      }
+    }
+    return selected;
+  }
+  for (let vertex2 = 0; vertex2 + 2 < position.count; vertex2 += 3) {
+    if (isVisibleColor(colors, vertex2) || isVisibleColor(colors, vertex2 + 1) || isVisibleColor(colors, vertex2 + 2)) {
+      selected.push(vertex2, vertex2 + 1, vertex2 + 2);
+    }
+  }
+  return selected;
+}
+function geometryWithVisibleVertexColors(geometry, colors) {
+  const vertexIndexes = selectedTriangleVertexIndexes(geometry, colors);
+  if (vertexIndexes.length === 0) return null;
+  const out = new BufferGeometry();
+  for (const name of ["position", "normal"]) {
+    const attribute = geometry.getAttribute(name);
+    if (attribute) out.setAttribute(name, copyAttribute(attribute, vertexIndexes));
+  }
+  const colorAttribute = copyAttribute(new BufferAttribute(colors, 3), vertexIndexes);
+  out.setAttribute("color", colorAttribute);
+  return out;
+}
 const VECTOR_KEYS = /* @__PURE__ */ new Set(["pos", "position", "target", "lookat", "aim", "up"]);
 const roundNumber = (value, digits) => {
   const scale2 = 10 ** digits;
@@ -342070,6 +342448,28 @@ function localAabbPlaneRelation(min2, max2, plane, eps = 1e-7) {
   if (minDistance > -eps) return "positive";
   return "crossing";
 }
+const DEFAULT_SCALAR_SCENE_BUDGET_OBJECTS = 15;
+const DEFAULT_SCALAR_SCENE_MIN_SAMPLES_PER_OBJECT = 100;
+function resolveScalarSceneSampleBudget(args) {
+  const objectCount = Math.max(0, Math.floor(args.objectCount));
+  const requestedMaxSamplesPerObject = Math.max(1, Math.floor(args.maxSamplesPerObject));
+  const sceneBudgetObjectCount = Math.max(1, Math.floor(args.sceneBudgetObjectCount ?? DEFAULT_SCALAR_SCENE_BUDGET_OBJECTS));
+  const minSamplesPerObject = Math.max(1, Math.floor(args.minSamplesPerObject ?? DEFAULT_SCALAR_SCENE_MIN_SAMPLES_PER_OBJECT));
+  const explicitMaxSamplesPerObject = args.explicitMaxSamplesPerObject === true;
+  const sceneMaxSamples = requestedMaxSamplesPerObject * sceneBudgetObjectCount;
+  const budgeted = objectCount <= 0 || objectCount <= sceneBudgetObjectCount || explicitMaxSamplesPerObject ? requestedMaxSamplesPerObject : Math.max(minSamplesPerObject, Math.floor(sceneMaxSamples / objectCount));
+  const effectiveMaxSamplesPerObject = Math.min(requestedMaxSamplesPerObject, budgeted);
+  return {
+    objectCount,
+    requestedMaxSamplesPerObject,
+    effectiveMaxSamplesPerObject,
+    sceneBudgetObjectCount,
+    sceneMaxSamples,
+    minSamplesPerObject,
+    explicitMaxSamplesPerObject,
+    capped: effectiveMaxSamplesPerObject < requestedMaxSamplesPerObject
+  };
+}
 export {
   Matrix4 as $,
   ACESFilmicToneMapping as A,
@@ -342165,7 +342565,7 @@ export {
   DEFAULT_ACTIVE_BACKEND as ay,
   isConstraintSketch as az,
   PCFShadowMap as b,
-  initKernelManifoldOnly as b$,
+  Group as b$,
   PointLight as b0,
   DirectionalLight as b1,
   analyzeCollisionIntersections as b2,
@@ -342176,61 +342576,73 @@ export {
   runScript as b7,
   MeshPhysicalMaterial as b8,
   LineSegments as b9,
-  findJointAnimationClip as bA,
-  resolveJointAnimation as bB,
-  resolveJointViewValues as bC,
-  getShapePorts as bD,
-  getShapeUsedPorts as bE,
-  DEFAULT_VIEW_CONFIG as bF,
-  getKernelFaceNameForTriangle as bG,
-  initKernel as bH,
-  initSolverWasm as bI,
-  BoxGeometry as bJ,
-  localAabbPlaneRelation as bK,
-  ShapeUtils as bL,
-  aabbInteriorOverlaps as bM,
-  aabbOverlapVolume as bN,
-  AabbSpatialIndex as bO,
-  aabbGaps as bP,
-  Group as bQ,
-  intersectWithPlane as bR,
-  parseCameraCliSpec as bS,
-  PMREMGenerator as bT,
-  PointsMaterial as bU,
-  Points$1 as bV,
-  serializeCollisionFinding as bW,
-  worldAuthorPlaneToLocal as bX,
-  generateCuttingLayoutPdf as bY,
-  getCameraForwardVector as bZ,
-  RENDER_STYLE_OPTIONS as b_,
-  getRenderStylePreset as ba,
-  AdditiveBlending as bb,
-  CatmullRomCurve3 as bc,
-  TubeGeometry as bd,
-  MeshStandardMaterial as be,
-  compileSdfNode3 as bf,
-  buildSdfRaymarchFragmentShader as bg,
-  SDF_RAYMARCH_PROXY_VERTEX_SHADER as bh,
-  Shape2 as bi,
-  ShapeGeometry as bj,
-  ShaderLib as bk,
-  CylinderGeometry as bl,
-  parseViewportCameraState as bm,
-  createResolvedExplodeConfig as bn,
-  explodeBoundsCenter as bo,
-  explodeMergeBounds as bp,
-  resolveExplodeDirective as bq,
-  computeExplodeMotion as br,
-  getSketchWorldMatrix as bs,
-  explodeAdd as bt,
-  hasExplodeOverride as bu,
-  resolveExplodeLocalFanDirection as bv,
-  explodeMul as bw,
-  explodeLeafFanStage as bx,
-  normalizeCutPlane as by,
-  toClippingPlane as bz,
+  resolveExplodeDirective as bA,
+  computeExplodeMotion as bB,
+  getSketchWorldMatrix as bC,
+  explodeAdd as bD,
+  hasExplodeOverride as bE,
+  resolveExplodeLocalFanDirection as bF,
+  explodeMul as bG,
+  explodeLeafFanStage as bH,
+  normalizeCutPlane as bI,
+  toClippingPlane as bJ,
+  findJointAnimationClip as bK,
+  resolveJointAnimation as bL,
+  resolveJointViewValues as bM,
+  getShapePorts as bN,
+  getShapeUsedPorts as bO,
+  DEFAULT_VIEW_CONFIG as bP,
+  getKernelFaceNameForTriangle as bQ,
+  resolveScalarSceneSampleBudget as bR,
+  initKernel as bS,
+  initSolverWasm as bT,
+  BoxGeometry as bU,
+  localAabbPlaneRelation as bV,
+  ShapeUtils as bW,
+  aabbGaps as bX,
+  aabbInteriorOverlaps as bY,
+  aabbOverlapVolume as bZ,
+  AabbSpatialIndex as b_,
+  geometryWithVisibleVertexColors as ba,
+  getRenderStylePreset as bb,
+  AdditiveBlending as bc,
+  ZEBRA_STRIPE_SOFTNESS as bd,
+  ZEBRA_STRIPE_SCALE as be,
+  ZEBRA_LIGHT_COLOR as bf,
+  ZEBRA_DARK_COLOR as bg,
+  ZEBRA_ACCENT_COLOR as bh,
+  ZEBRA_STRIPE_FRAGMENT_SHADER as bi,
+  ZEBRA_STRIPE_VERTEX_SHADER as bj,
+  SURFACE_FIELD_FRAGMENT_SHADER as bk,
+  SURFACE_FIELD_VERTEX_SHADER as bl,
+  CatmullRomCurve3 as bm,
+  TubeGeometry as bn,
+  MeshStandardMaterial as bo,
+  compileSdfNode3 as bp,
+  buildSdfRaymarchFragmentShader as bq,
+  SDF_RAYMARCH_PROXY_VERTEX_SHADER as br,
+  Shape2 as bs,
+  ShapeGeometry as bt,
+  ShaderLib as bu,
+  CylinderGeometry as bv,
+  parseViewportCameraState as bw,
+  createResolvedExplodeConfig as bx,
+  explodeBoundsCenter as by,
+  explodeMergeBounds as bz,
   SRGBColorSpace as c,
-  __viteBrowserExternal$1 as c0,
+  intersectWithPlane as c0,
+  setActiveBackend as c1,
+  parseCameraCliSpec as c2,
+  PMREMGenerator as c3,
+  PointsMaterial as c4,
+  Points$1 as c5,
+  serializeCollisionFinding as c6,
+  worldAuthorPlaneToLocal as c7,
+  generateCuttingLayoutPdf as c8,
+  getCameraForwardVector as c9,
+  RENDER_STYLE_OPTIONS as ca,
+  initKernelManifoldOnly as cb,
+  __viteBrowserExternal$1 as cc,
   Layers as d,
   Color as e,
   RGBAFormat as f,