forgecad 0.9.14 → 0.9.15

package/dist/assets/cli/{render-Cho2uKG_.js → render-DSY3mMQa.js}

@@ -1,8 +1,8 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { D as DoubleSide, cB as initSolverWasm, cA as initKernel, S as Scene, cC as BoxGeometry, bR as MeshStandardMaterial, a4 as BackSide, b3 as PointLight, M as Mesh, aa as MeshBasicMaterial, cD as localAabbPlaneRelation, h as Vector2, cE as ShapeUtils, cF as analyzePhysicalConnectivity, g as Vector3, $ as Matrix4, cG as Frustum, G as Box3, a0 as MathUtils, cH as meshContactDataFor, cI as AabbSpatialIndex, cJ as detectPhysicalContact, cK as resolveThicknessInspectionOptions, R as Raycaster, cL as thicknessColor, cM as thicknessClass, aX as BufferAttribute, cN as roughnessClassForAngle, cO as resolveRoughnessInspectionOptions, cP as roughnessColorForAngle, cQ as roughnessScoreForAngle, cR as activateBackend, e as Color, b6 as COMPARISON_COLORS, aF as resolveForgeRenderStyle, bt as getRenderStylePreset, ax as setParamOverrides, bh as runScript, cl as scanProxyGridForBounds, cS as Group, ba as shapeToGeometry, bi as MeshPhysicalMaterial, bw as NormalBlending, cT as createScanProxyGeometry, bv as AdditiveBlending, aK as LineBasicMaterial, bj as LineSegments, aJ as BufferGeometry, P as PerspectiveCamera, bo as worldAuthorPlaneToLocal, cU as resolveSectionHatchMetrics, ct as buildGeometryComparisonPointCloud, cr as triangleSoupFromMeshes, O as OrthographicCamera, k as ShaderMaterial, bC as ZEBRA_STRIPE_FRAGMENT_SHADER, bD as ZEBRA_STRIPE_VERTEX_SHADER, bx as ZEBRA_STRIPE_SOFTNESS, by as ZEBRA_STRIPE_SCALE, bz as ZEBRA_LIGHT_COLOR, bA as ZEBRA_DARK_COLOR, bB as ZEBRA_ACCENT_COLOR, bs as geometryWithVisibleVertexColors, cV as intersectWithPlane, cW as setActiveBackend, W as WebGLRenderer, A as ACESFilmicToneMapping, c as SRGBColorSpace, cX as parseCameraCliSpec, cY as PMREMGenerator, aY as CanvasTexture, aZ as Object3D, a_ as FogExp2, a$ as Fog, b0 as AmbientLight, b4 as DirectionalLight, b1 as HemisphereLight, cd as findJointAnimationClip, p as Plane, bF as SURFACE_FIELD_FRAGMENT_SHADER, bG as SURFACE_FIELD_VERTEX_SHADER, bE as SCAN_PROXY_LAYER_STYLES, Y as Vector4, bU as SDF_RAYMARCH_PROXY_VERTEX_SHADER, bT as buildSdfRaymarchFragmentShader, ce as resolveJointAnimation, cf as resolveJointViewValues, bL as ROUGHNESS_COLORS, cZ as PointsMaterial, c_ as Points, b5 as heatPointsForSide, c$ as analyzeCollisionIntersections, d0 as serializeCollisionFinding, d1 as summarizeThicknessSamples, bN as THICKNESS_COLORS, b2 as SpotLight, cx as resolveScalarSceneSampleBudget, bb as buildComparisonHeatPatchGeometry, bc as EdgesGeometry, b7 as comparisonHeatDepthTest, b8 as comparisonHeatEdgeOpacity, b9 as comparisonHeatPatchOpacity, cz as comparisonCandidateContextOpacity, d2 as DEFAULT_COMPARISON_CANDIDATE_OPACITY } from "../scalar-sampling-budget-CfDiFvh7.js";
-import { m as mergeViewportRenderSceneStates, p as parseRenderSceneCliSpec, g as getSceneObjectTreePath } from "../targets-D6PWsv6X.js";
+import { D as DoubleSide, cC as initSolverWasm, cB as initKernel, S as Scene, cD as BoxGeometry, bV as MeshStandardMaterial, a4 as BackSide, b7 as PointLight, M as Mesh, aa as MeshBasicMaterial, cE as localAabbPlaneRelation, h as Vector2, cF as ShapeUtils, cG as analyzePhysicalConnectivity, g as Vector3, $ as Matrix4, cH as Frustum, G as Box3, a0 as MathUtils, cI as meshContactDataFor, cJ as AabbSpatialIndex, cK as detectPhysicalContact, cL as resolveThicknessInspectionOptions, R as Raycaster, cM as thicknessColor, cN as thicknessClass, a$ as BufferAttribute, cO as roughnessClassForAngle, cP as resolveRoughnessInspectionOptions, cQ as roughnessColorForAngle, cR as roughnessScoreForAngle, cS as activateBackend, e as Color, ba as COMPARISON_COLORS, ay as resolveForgeRenderStyle, by as getRenderStylePreset, ax as setParamOverrides, bl as runScript, cm as scanProxyGridForBounds, cT as Group, be as shapeToGeometry, bm as MeshPhysicalMaterial, bA as NormalBlending, cU as createScanProxyGeometry, bw as AdditiveBlending, aO as LineBasicMaterial, bn as LineSegments, aN as BufferGeometry, P as PerspectiveCamera, cj as DEFAULT_VIEW_CONFIG, bs as worldAuthorPlaneToLocal, cV as resolveSectionHatchMetrics, cu as buildGeometryComparisonPointCloud, cs as triangleSoupFromMeshes, O as OrthographicCamera, k as ShaderMaterial, bG as ZEBRA_STRIPE_FRAGMENT_SHADER, bH as ZEBRA_STRIPE_VERTEX_SHADER, bB as ZEBRA_STRIPE_SOFTNESS, bC as ZEBRA_STRIPE_SCALE, bD as ZEBRA_LIGHT_COLOR, bE as ZEBRA_DARK_COLOR, bF as ZEBRA_ACCENT_COLOR, bx as geometryWithVisibleVertexColors, cW as intersectWithPlane, cX as setActiveBackend, W as WebGLRenderer, A as ACESFilmicToneMapping, c as SRGBColorSpace, cY as parseCameraCliSpec, cZ as PMREMGenerator, b0 as CanvasTexture, b1 as Object3D, b2 as FogExp2, b3 as Fog, b4 as AmbientLight, b8 as DirectionalLight, b5 as HemisphereLight, aI as findJointAnimationClip, p as Plane, bJ as SURFACE_FIELD_FRAGMENT_SHADER, bK as SURFACE_FIELD_VERTEX_SHADER, bI as SCAN_PROXY_LAYER_STYLES, Y as Vector4, bY as SDF_RAYMARCH_PROXY_VERTEX_SHADER, bX as buildSdfRaymarchFragmentShader, aJ as resolveJointAnimation, aK as resolveJointViewValues, bP as ROUGHNESS_COLORS, c_ as PointsMaterial, c$ as Points, b9 as heatPointsForSide, d0 as analyzeCollisionIntersections, d1 as serializeCollisionFinding, d2 as summarizeThicknessSamples, bR as THICKNESS_COLORS, b6 as SpotLight, c0 as CylinderGeometry, d3 as TorusGeometry, bM as CatmullRomCurve3, bN as TubeGeometry, cy as resolveScalarSceneSampleBudget, bf as buildComparisonHeatPatchGeometry, bg as EdgesGeometry, d4 as SphereGeometry, d5 as ConeGeometry, bb as comparisonHeatDepthTest, bc as comparisonHeatEdgeOpacity, bd as comparisonHeatPatchOpacity, cA as comparisonCandidateContextOpacity, d6 as DEFAULT_COMPARISON_CANDIDATE_OPACITY } from "../scalar-sampling-budget-wJF98aY9.js";
+import { m as mergeViewportRenderSceneStates, p as parseRenderSceneCliSpec, g as getSceneObjectTreePath } from "../targets-B9sGB5nB.js";
 const CAD_MATERIAL_PROPS = {
   color: 6003669,
   metalness: 0.05,
@@ -1767,6 +1767,10 @@ const exportCtx = exportCanvas.getContext("2d");
 const DEFAULT_BACKGROUND = 2434342;
 const DEFAULT_PITCH_DEG = 18;
 const DEFAULT_FIXED_DIR = new Vector3(0, -1, 0.32).normalize();
+const RIG_SHADOW_COLOR = [6, 10, 18];
+const RIG_LINK_COLOR = [20, 220, 255];
+const RIG_PART_LINK_COLOR = [174, 255, 92];
+const RIG_HIDDEN_LINK_COLOR = [116, 136, 148];
 const ORTHO_BASE_SIZE = 960;
 const CAPTURE_RUNTIME_CAPABILITIES = {
   version: 3,
@@ -2790,6 +2794,314 @@ function renderCurrentMask(session) {
     });
   }
 }
+function tupleFromVector(value) {
+  return [Number(value.x.toFixed(6)), Number(value.y.toFixed(6)), Number(value.z.toFixed(6))];
+}
+function isFiniteVector(value) {
+  return Number.isFinite(value.x) && Number.isFinite(value.y) && Number.isFinite(value.z);
+}
+function clampRadius(value, min, max) {
+  return MathUtils.clamp(value, min, max);
+}
+function rigObjectMatchesChild(renderable, child) {
+  return renderable.name === child || renderable.groupName === child;
+}
+function rigChildCenter(session, child) {
+  const bounds = new Box3();
+  let hasBounds = false;
+  for (const renderable of session.renderables) {
+    if (!rigObjectMatchesChild(renderable, child)) continue;
+    renderable.root.updateMatrixWorld(true);
+    const objectBounds = new Box3().setFromObject(renderable.root);
+    if (!objectBounds.isEmpty()) {
+      bounds.union(objectBounds);
+      hasBounds = true;
+    }
+  }
+  if (!hasBounds) return null;
+  const center = bounds.getCenter(new Vector3());
+  return isFiniteVector(center) ? center : null;
+}
+function resolveRigArcReferenceDirection(axisWorld) {
+  const candidates = [new Vector3(0, 0, 1), new Vector3(0, 1, 0), new Vector3(1, 0, 0)];
+  for (const candidate of candidates) {
+    const projected = candidate.clone().addScaledVector(axisWorld, -candidate.dot(axisWorld));
+    if (projected.lengthSq() > 1e-8) return projected.normalize();
+  }
+  return new Vector3(1, 0, 0);
+}
+function resolveRigVisualArcAngleDeg(valueDeg, visualLimitDeg) {
+  if (!Number.isFinite(valueDeg)) return 0;
+  const limit = MathUtils.clamp(visualLimitDeg, 0, 360);
+  if (limit <= 1e-8) return 0;
+  if (Math.abs(valueDeg) <= 360) return MathUtils.clamp(valueDeg, -limit, limit);
+  return MathUtils.clamp(valueDeg % 360, -limit, limit);
+}
+function addRigCylinder(group, start, end, radius, color, opacity, renderOrder) {
+  const direction = end.clone().sub(start);
+  const length = direction.length();
+  if (length <= 1e-6) return null;
+  direction.multiplyScalar(1 / length);
+  const geometry = new CylinderGeometry(radius, radius, length, 18);
+  const material = new MeshBasicMaterial({
+    color: Array.isArray(color) ? colorHex(color) : color,
+    transparent: opacity < 1,
+    opacity,
+    depthTest: false,
+    depthWrite: false,
+    blending: AdditiveBlending,
+    toneMapped: false
+  });
+  const mesh = new Mesh(geometry, material);
+  mesh.position.copy(start).add(end).multiplyScalar(0.5);
+  mesh.quaternion.setFromUnitVectors(new Vector3(0, 1, 0), direction);
+  mesh.renderOrder = renderOrder;
+  group.add(mesh);
+  return mesh;
+}
+function addRigSphere(group, position, radius, color, renderOrder) {
+  const mesh = new Mesh(
+    new SphereGeometry(radius, 18, 18),
+    new MeshBasicMaterial({ color, depthTest: false, toneMapped: false })
+  );
+  mesh.position.copy(position);
+  mesh.renderOrder = renderOrder;
+  group.add(mesh);
+}
+function addRigCone(group, position, direction, radius, length, color) {
+  if (direction.lengthSq() <= 1e-8) return;
+  const mesh = new Mesh(
+    new ConeGeometry(radius, length, 18),
+    new MeshBasicMaterial({ color, depthTest: false, toneMapped: false })
+  );
+  mesh.position.copy(position);
+  mesh.quaternion.setFromUnitVectors(new Vector3(0, 1, 0), direction.clone().normalize());
+  mesh.renderOrder = 96;
+  group.add(mesh);
+}
+function addRigJointVisual(group, entry, config, axisLength, hidden) {
+  const pivot = new Vector3(...entry.pivot);
+  const axis = new Vector3(...entry.axis).normalize();
+  const axisColor = hidden ? colorHex(RIG_HIDDEN_LINK_COLOR) : config.axisColor;
+  const arcColor = hidden ? colorHex(RIG_HIDDEN_LINK_COLOR) : config.arcColor;
+  const coreColor = hidden ? "#d7e7ee" : config.axisCoreColor;
+  const zeroColor = hidden ? "#aebbc4" : config.zeroColor;
+  const length = axisLength * (hidden ? 0.78 : 1);
+  const axisRadius = clampRadius(length * config.axisLineRadiusScale, config.axisLineRadiusMin, config.axisLineRadiusMax);
+  const spokeRadius = clampRadius(length * config.spokeLineRadiusScale, config.spokeLineRadiusMin, config.spokeLineRadiusMax);
+  const arcLineRadius = clampRadius(length * config.arcLineRadiusScale, config.arcLineRadiusMin, config.arcLineRadiusMax);
+  const dotRadius = Math.max(config.axisDotRadiusMin, length * config.axisDotRadiusScale);
+  const arrowRadius = Math.max(config.axisArrowRadiusMin, length * config.axisArrowRadiusScale);
+  const arrowLength = Math.max(config.axisArrowLengthMin, length * config.axisArrowLengthScale);
+  const axisStart = pivot.clone().addScaledVector(axis, -length * 0.5);
+  const axisEnd = pivot.clone().addScaledVector(axis, length * 0.5);
+  addRigCylinder(group, axisStart, axisEnd, axisRadius, axisColor, hidden ? 0.55 : 0.98, 95);
+  addRigSphere(group, pivot, dotRadius, coreColor, 96);
+  addRigCone(
+    group,
+    axisEnd.clone().addScaledVector(axis, arrowLength * config.axisArrowOffsetFactor),
+    axis,
+    arrowRadius,
+    arrowLength,
+    axisColor
+  );
+  const ringRadius = Math.max(config.arcRadiusMin, length * config.arcRadiusScale);
+  const ring = new Mesh(
+    new TorusGeometry(ringRadius, arcLineRadius * 0.78, 10, 72),
+    new MeshBasicMaterial({
+      color: hidden ? colorHex(RIG_HIDDEN_LINK_COLOR) : config.axisColor,
+      transparent: true,
+      opacity: hidden ? 0.34 : 0.58,
+      depthTest: false,
+      depthWrite: false,
+      blending: AdditiveBlending,
+      toneMapped: false
+    })
+  );
+  ring.position.copy(pivot);
+  ring.quaternion.setFromUnitVectors(new Vector3(0, 0, 1), axis);
+  ring.renderOrder = 92;
+  group.add(ring);
+  if (entry.type !== "revolute") return;
+  const arcStartDirection = resolveRigArcReferenceDirection(axis);
+  const arcAngleRad = MathUtils.degToRad(resolveRigVisualArcAngleDeg(entry.value, config.arcVisualLimitDeg));
+  const arcStartPoint = pivot.clone().addScaledVector(arcStartDirection, ringRadius);
+  const arcEndDirection = arcStartDirection.clone().applyAxisAngle(axis, arcAngleRad);
+  const arcEndPoint = pivot.clone().addScaledVector(arcEndDirection, ringRadius);
+  addRigCylinder(group, pivot, arcStartPoint, spokeRadius, zeroColor, hidden ? 0.45 : 0.9, 97);
+  addRigCylinder(group, pivot, arcEndPoint, spokeRadius, arcColor, hidden ? 0.5 : 0.96, 97);
+  addRigSphere(group, arcStartPoint, Math.max(config.arcDotRadiusMin, length * config.arcDotRadiusScale), zeroColor, 98);
+  addRigSphere(group, arcEndPoint, Math.max(config.arcDotRadiusMin, length * config.arcDotRadiusScale), arcColor, 98);
+  if (Math.abs(arcAngleRad) > 1e-4) {
+    const visualDeg = MathUtils.radToDeg(Math.abs(arcAngleRad));
+    const steps = Math.max(config.arcMinSteps, Math.ceil(visualDeg / config.arcStepDeg));
+    const points = [];
+    for (let i = 0; i <= steps; i += 1) {
+      const direction = arcStartDirection.clone().applyAxisAngle(axis, arcAngleRad * (i / steps));
+      points.push(pivot.clone().addScaledVector(direction, ringRadius));
+    }
+    const curve = new CatmullRomCurve3(points, false, "centripetal");
+    const tubeSegments = Math.max(config.arcTubeSegmentsMin, Math.ceil(points.length * config.arcTubeSegmentsFactor));
+    const tube = new Mesh(
+      new TubeGeometry(curve, tubeSegments, arcLineRadius, config.arcTubeRadialSegments, false),
+      new MeshBasicMaterial({
+        color: arcColor,
+        transparent: true,
+        opacity: hidden ? 0.5 : 0.98,
+        depthTest: false,
+        depthWrite: false,
+        blending: AdditiveBlending,
+        toneMapped: false
+      })
+    );
+    tube.renderOrder = 98;
+    group.add(tube);
+  }
+}
+function buildRigSceneGroup(session) {
+  var _a;
+  const group = new Group();
+  const config = session.jointOverlayConfig;
+  const bbox = new Box3(new Vector3(...session.bbox.min), new Vector3(...session.bbox.max));
+  const diagonal = Math.max(1, bbox.getSize(new Vector3()).length());
+  const axisLength = Math.max(config.axisLengthMin, diagonal * config.axisLengthScale);
+  const animatedValues = resolveJointAnimation(session.selectedAnimation, 0, session.baseJointValues);
+  const effectiveJointValues = resolveJointViewValues(session.joints, session.jointCouplings, animatedValues);
+  const jointMatrices = computeJointNodeMatrices(session.joints, effectiveJointValues);
+  const joints = [];
+  const links = [];
+  const jointByChild = /* @__PURE__ */ new Map();
+  for (let index = 0; index < session.joints.length; index += 1) {
+    const joint = session.joints[index];
+    const parentMatrix = joint.parent ? ((_a = jointMatrices.get(joint.parent)) == null ? void 0 : _a.clone()) ?? new Matrix4() : new Matrix4();
+    const axisLocal = new Vector3(joint.axis[0], joint.axis[1], joint.axis[2]).normalize();
+    const axisWorld = axisLocal.clone().transformDirection(parentMatrix);
+    if (axisWorld.lengthSq() <= 1e-8) axisWorld.copy(axisLocal);
+    axisWorld.normalize();
+    if (axisWorld.lengthSq() <= 1e-8 || !isFiniteVector(axisWorld)) continue;
+    const pivotWorld = new Vector3(joint.pivot[0], joint.pivot[1], joint.pivot[2]).applyMatrix4(parentMatrix);
+    if (!isFiniteVector(pivotWorld)) continue;
+    const rawValue = effectiveJointValues[joint.name] ?? joint.defaultValue;
+    const entry = {
+      index,
+      name: joint.name,
+      type: joint.type,
+      child: joint.child,
+      ...joint.parent ? { parent: joint.parent } : {},
+      hidden: joint.hidden === true,
+      value: Number.isFinite(rawValue) ? rawValue : joint.defaultValue,
+      pivot: tupleFromVector(pivotWorld),
+      axis: tupleFromVector(axisWorld)
+    };
+    joints.push(entry);
+    jointByChild.set(joint.child, entry);
+  }
+  const pushLink = (entry, kind, start, end) => {
+    if (!start || !end || !isFiniteVector(start) || !isFiniteVector(end)) return;
+    if (start.distanceToSquared(end) <= 1e-6) return;
+    const id = `${entry.name}:${kind}`;
+    links.push({
+      id,
+      kind,
+      joint: entry.name,
+      hidden: entry.hidden,
+      start: tupleFromVector(start),
+      end: tupleFromVector(end)
+    });
+  };
+  for (const entry of joints) {
+    const pivot = new Vector3(...entry.pivot);
+    const parent = entry.parent ? jointByChild.get(entry.parent) : null;
+    pushLink(entry, "hierarchy", parent ? new Vector3(...parent.pivot) : null, pivot);
+    pushLink(entry, "part", pivot, rigChildCenter(session, entry.child));
+  }
+  const hierarchyRadius = clampRadius(axisLength * 0.013, 0.55, 2.4);
+  const partRadius = clampRadius(axisLength * 8e-3, 0.34, 1.45);
+  for (const link of links) {
+    addRigCylinder(
+      group,
+      new Vector3(...link.start),
+      new Vector3(...link.end),
+      link.kind === "hierarchy" ? hierarchyRadius : partRadius,
+      link.hidden ? RIG_HIDDEN_LINK_COLOR : link.kind === "hierarchy" ? RIG_LINK_COLOR : RIG_PART_LINK_COLOR,
+      link.hidden ? 0.36 : link.kind === "hierarchy" ? 0.82 : 0.58,
+      88
+    );
+  }
+  if (config.enabled) {
+    for (const joint of joints) {
+      addRigJointVisual(group, joint, config, axisLength, joint.hidden);
+    }
+  }
+  return {
+    group,
+    report: {
+      method: "rig-skeleton-shadow-v1",
+      objectCount: session.renderables.length,
+      jointCount: joints.length,
+      linkCount: links.length,
+      hiddenJointCount: joints.filter((joint) => joint.hidden).length,
+      joints,
+      links,
+      palette: {
+        shadow: RIG_SHADOW_COLOR,
+        hierarchyLink: RIG_LINK_COLOR,
+        partLink: RIG_PART_LINK_COLOR,
+        hiddenLink: RIG_HIDDEN_LINK_COLOR
+      }
+    }
+  };
+}
+function renderCurrentRig(session) {
+  const r = getRenderer(session.size, session.pixelRatio);
+  const { group, report } = buildRigSceneGroup(session);
+  const replacements = session.renderables.map((renderable) => {
+    var _a, _b;
+    const material = new MeshBasicMaterial({
+      color: colorHex(RIG_SHADOW_COLOR),
+      transparent: true,
+      opacity: 0.16,
+      side: DoubleSide,
+      depthWrite: false,
+      toneMapped: false,
+      clippingPlanes: renderable.solidMaterial.clippingPlanes
+    });
+    const previous = {
+      solidVisible: renderable.solid.visible,
+      wireVisible: renderable.wire.visible,
+      shellVisible: (_a = renderable.shell) == null ? void 0 : _a.visible,
+      scanProxyVisible: (_b = renderable.scanProxy) == null ? void 0 : _b.visible,
+      material: renderable.solid.material,
+      replacement: material
+    };
+    renderable.solid.material = material;
+    renderable.solid.visible = true;
+    renderable.wire.visible = false;
+    if (renderable.shell) renderable.shell.visible = false;
+    if (renderable.scanProxy) renderable.scanProxy.visible = false;
+    return { renderable, previous };
+  });
+  session.scene.add(group);
+  try {
+    const png = withTemporarySceneBackground(session, new Color(132105), () => {
+      updateSdfRaymarchUniforms(session);
+      r.render(session.scene, session.camera);
+      return captureRenderedPng(session.size);
+    });
+    return { png, report };
+  } finally {
+    session.scene.remove(group);
+    disposeObjectTree(group);
+    replacements.forEach(({ renderable, previous }) => {
+      renderable.solid.material = previous.material;
+      renderable.solid.visible = previous.solidVisible;
+      renderable.wire.visible = previous.wireVisible;
+      if (renderable.shell && previous.shellVisible !== void 0) renderable.shell.visible = previous.shellVisible;
+      if (renderable.scanProxy && previous.scanProxyVisible !== void 0) renderable.scanProxy.visible = previous.scanProxyVisible;
+      previous.replacement.dispose();
+    });
+  }
+}
 function analyzeSessionConnectivity(session) {
   if (!session.physicalConnectivity) {
     session.physicalConnectivity = analyzePhysicalConnectivity(session.connectivityEntries);
@@ -3792,9 +4104,6 @@ function addRenderStyleLights(scene, style) {
     new HemisphereLight(new Color(lights.hemisphereSky), new Color(lights.hemisphereGround), lights.hemisphereIntensity)
   );
 }
-function fieldKindUniform(kind) {
-  return kind === "hybrid" ? 1 : 0;
-}
 function createSurfaceFieldMaterial({
   field,
   objectColor,
@@ -3808,7 +4117,6 @@ function createSurfaceFieldMaterial({
       uAccentColor: { value: new Color(field.accentColor) },
       uBaseColor: { value: new Color(field.baseColor) },
       uDarkColor: { value: new Color(field.darkColor) },
-      uFieldKind: { value: fieldKindUniform(field.kind) },
       uFieldScale: { value: fieldScale },
       uGlow: { value: field.glow },
       uLineColor: { value: new Color(field.lineColor) },
@@ -4693,7 +5001,7 @@ Available renderable objects: ${available}`;
   return "No visible renderable objects found.";
 }
 function createSession(code, opts) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
   const size = (opts == null ? void 0 : opts.size) ?? 1024;
   const pixelRatio = (opts == null ? void 0 : opts.pixelRatio) ?? 1;
   const debug = createCaptureDebugLogger(opts == null ? void 0 : opts.debug);
@@ -4706,6 +5014,12 @@ function createSession(code, opts) {
   });
   const r = getRenderer(size, pixelRatio);
   const renderStyle = resolveForgeRenderStyle(opts == null ? void 0 : opts.renderStyle);
+  if (renderStyle === "matrix") {
+    return {
+      ok: false,
+      error: "Matrix render style is only supported in the interactive viewport; CLI rendering does not support the glyph volume yet."
+    };
+  }
   const renderStylePreset = getRenderStylePreset(renderStyle);
   let requestedSceneState = null;
   try {
@@ -5190,6 +5504,7 @@ function createSession(code, opts) {
     roughnessInspection: null,
     joints,
     jointCouplings,
+    jointOverlayConfig: ((_p = result.viewConfig) == null ? void 0 : _p.jointOverlay) ?? DEFAULT_VIEW_CONFIG.jointOverlay,
     animationClips,
     defaultAnimation,
     selectedAnimation,
@@ -5336,6 +5651,7 @@ window.__forgeRender = async (code, opts) => {
   const depthRenders = {};
   const normalRenders = {};
   const zebraRenders = {};
+  const rigRenders = {};
   const maskRenders = {};
   const connectivityRenders = {};
   const floatingRenders = {};
@@ -5348,6 +5664,7 @@ window.__forgeRender = async (code, opts) => {
   let connectivityReport = null;
   let floatingReport = null;
   let distanceReport = null;
+  let rigReport = null;
   const comparisonViewStats = {};
   let comparisonPointCloud = null;
   let collisionReport = null;
@@ -5423,6 +5740,13 @@ window.__forgeRender = async (code, opts) => {
         zebraRenders[label] = renderCurrentZebra(session);
         await markChannelViewDone("zebra", label);
       }
+      if (requestedChannels.has("rig")) {
+        await markChannelViewStart("rig", label);
+        const rig = renderCurrentRig(session);
+        rigRenders[label] = rig.png;
+        rigReport = rig.report;
+        await markChannelViewDone("rig", label);
+      }
       if (requestedChannels.has("roughness")) {
         await markChannelViewStart("roughness", label);
         const roughness = renderCurrentRoughness(session, opts == null ? void 0 : opts.roughness);
@@ -5518,6 +5842,12 @@ window.__forgeRender = async (code, opts) => {
     depth: depthRenders,
     normals: normalRenders,
     zebra: zebraRenders,
+    rig: rigReport ? {
+      ...rigReport,
+      views: rigRenders
+    } : {
+      views: rigRenders
+    },
     roughness: roughnessReport ? {
       ...roughnessReport,
       pointCloud: roughnessPointCloud,