forgecad 0.9.4 → 0.9.5

package/dist/assets/cli/{render-Kw5hLEcL.js → render-BrVVdj_T.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, bH as initSolverWasm, bG as initKernel, S as Scene, bI as BoxGeometry, bd as MeshStandardMaterial, a4 as BackSide, b0 as PointLight, M as Mesh, aa as MeshBasicMaterial, bJ as localAabbPlaneRelation, h as Vector2, bK as ShapeUtils, g as Vector3, e as Color, aC as resolveForgeRenderStyle, b9 as getRenderStylePreset, ax as setParamOverrides, b6 as runScript, a0 as MathUtils, G as Box3, bL as Group, b3 as shapeToGeometry, b7 as MeshPhysicalMaterial, ba as AdditiveBlending, aH as LineBasicMaterial, b8 as LineSegments, aG as BufferGeometry, P as PerspectiveCamera, k as ShaderMaterial, bM as intersectWithPlane, W as WebGLRenderer, A as ACESFilmicToneMapping, c as SRGBColorSpace, bN as parseCameraCliSpec, bO as PMREMGenerator, aV as CanvasTexture, aW as Object3D, aX as FogExp2, aY as Fog, aZ as AmbientLight, b1 as DirectionalLight, a_ as HemisphereLight, bz as findJointAnimationClip, p as Plane, Y as Vector4, $ as Matrix4, bg as SDF_RAYMARCH_PROXY_VERTEX_SHADER, bf as buildSdfRaymarchFragmentShader, O as OrthographicCamera, bA as resolveJointAnimation, bB as resolveJointViewValues, R as Raycaster, aU as BufferAttribute, bP as worldAuthorPlaneToLocal, a$ as SpotLight } from "../sectionPlaneMath-C8N0w8o3.js";
-import { m as mergeViewportRenderSceneStates, p as parseRenderSceneCliSpec } from "../renderSceneState-tvtNKNRi.js";
+import { D as DoubleSide, bH as initSolverWasm, bG as initKernel, S as Scene, bI as BoxGeometry, bd as MeshStandardMaterial, a4 as BackSide, b0 as PointLight, M as Mesh, aa as MeshBasicMaterial, bJ as localAabbPlaneRelation, h as Vector2, bK as ShapeUtils, a0 as MathUtils, g as Vector3, G as Box3, aU as BufferAttribute, e as Color, aC as resolveForgeRenderStyle, b9 as getRenderStylePreset, ax as setParamOverrides, b6 as runScript, bL as Group, b3 as shapeToGeometry, b7 as MeshPhysicalMaterial, ba as AdditiveBlending, aH as LineBasicMaterial, b8 as LineSegments, aG as BufferGeometry, P as PerspectiveCamera, k as ShaderMaterial, bM as intersectWithPlane, W as WebGLRenderer, A as ACESFilmicToneMapping, c as SRGBColorSpace, bN as parseCameraCliSpec, bO as PMREMGenerator, aV as CanvasTexture, aW as Object3D, aX as FogExp2, aY as Fog, aZ as AmbientLight, b1 as DirectionalLight, a_ as HemisphereLight, bz as findJointAnimationClip, p as Plane, Y as Vector4, $ as Matrix4, bg as SDF_RAYMARCH_PROXY_VERTEX_SHADER, bf as buildSdfRaymarchFragmentShader, O as OrthographicCamera, bA as resolveJointAnimation, bB as resolveJointViewValues, R as Raycaster, bP as worldAuthorPlaneToLocal, a$ as SpotLight } from "../sectionPlaneMath-CykEnkvQ.js";
+import { m as mergeViewportRenderSceneStates, p as parseRenderSceneCliSpec } from "../renderSceneState-3DfsSASX.js";
 const CAD_MATERIAL_PROPS = {
   color: 6003669,
   metalness: 0.05,
@@ -269,17 +269,17 @@ function stitchLoops(points, edges) {
   const warnings = [];
   const adjacency = /* @__PURE__ */ new Map();
   const unusedEdges = /* @__PURE__ */ new Set();
-  const edgeKey = (a, b) => a < b ? `${a}:${b}` : `${b}:${a}`;
+  const edgeKey2 = (a, b) => a < b ? `${a}:${b}` : `${b}:${a}`;
   for (const [a, b] of edges) {
     if (!adjacency.has(a)) adjacency.set(a, []);
     if (!adjacency.has(b)) adjacency.set(b, []);
     (_a = adjacency.get(a)) == null ? void 0 : _a.push(b);
     (_b = adjacency.get(b)) == null ? void 0 : _b.push(a);
-    unusedEdges.add(edgeKey(a, b));
+    unusedEdges.add(edgeKey2(a, b));
   }
   const loops = [];
   for (const [edgeA, edgeB] of edges) {
-    const firstKey = edgeKey(edgeA, edgeB);
+    const firstKey = edgeKey2(edgeA, edgeB);
     if (!unusedEdges.has(firstKey)) continue;
     const loop = [edgeA, edgeB];
     unusedEdges.delete(firstKey);
@@ -288,12 +288,12 @@ function stitchLoops(points, edges) {
     let closed = false;
     for (let guard = 0; guard < points.length + edges.length + 8; guard += 1) {
       const neighbors = adjacency.get(current) ?? [];
-      const next = neighbors.find((candidate) => candidate !== previous && unusedEdges.has(edgeKey(current, candidate)));
+      const next = neighbors.find((candidate) => candidate !== previous && unusedEdges.has(edgeKey2(current, candidate)));
       if (next === void 0) {
         if (current === edgeA) closed = true;
         break;
       }
-      unusedEdges.delete(edgeKey(current, next));
+      unusedEdges.delete(edgeKey2(current, next));
       if (next === edgeA) {
         closed = true;
         break;
@@ -1069,6 +1069,38 @@ function analyzeDistanceInspection(entries, rawOptions = {}) {
     warnings: [...connectivity.warnings]
   };
 }
+const CAMERA_TOKEN_DIRECTIONS = {
+  front: [0, -1, 0.2],
+  back: [0, 1, 0.2],
+  side: [1, 0, 0.2],
+  right: [1, 0, 0.2],
+  top: [0, -0.01, 1],
+  iso: [0.6, -0.6, 0.4]
+};
+function normalizeCameraDirection(dir) {
+  const len = Math.sqrt(dir[0] ** 2 + dir[1] ** 2 + dir[2] ** 2) || 1;
+  return [dir[0] / len, dir[1] / len, dir[2] / len];
+}
+function sphericalToCameraDirection(azimuthDeg, elevationDeg) {
+  const az = azimuthDeg * Math.PI / 180;
+  const el = elevationDeg * Math.PI / 180;
+  const cosEl = Math.cos(el);
+  return [cosEl * Math.sin(az), -cosEl * Math.cos(az), Math.sin(el)];
+}
+function parseCameraToken(token) {
+  const normalized = token.trim();
+  const preset = CAMERA_TOKEN_DIRECTIONS[normalized];
+  if (preset) return { label: normalized, dir: preset };
+  const parts = normalized.split(":").map((s) => Number.parseFloat(s));
+  if (parts.length >= 2 && parts.length <= 3 && parts.every((n) => Number.isFinite(n))) {
+    const dir = sphericalToCameraDirection(parts[0], parts[1]);
+    const label = `az${parts[0]}_el${parts[1]}`;
+    return { label, dir, distance: parts[2] };
+  }
+  throw new Error(
+    `Unknown camera "${token}". Use a preset (front, back, side, right, top, iso) or azimuth:elevation in degrees (e.g. 45:30).`
+  );
+}
 function formatAvailableViews(views) {
   const names = Object.keys(views ?? {}).sort();
   if (names.length === 0) {
@@ -1302,6 +1334,244 @@ function summarizeThicknessSamples(samples, options) {
     unresolvedAreaPercent: percent(unresolvedArea, totalArea)
   };
 }
+const DEFAULT_ROUGHNESS_INSPECTION_OPTIONS = {
+  smoothAngleDeg: 5,
+  sharpAngleDeg: 30,
+  harshAngleDeg: 90
+};
+const ROUGHNESS_COLORS = {
+  smooth: [62, 72, 84],
+  moderate: [255, 214, 0],
+  sharp: [255, 124, 34],
+  harsh: [255, 42, 96]
+};
+function resolveRoughnessInspectionOptions(raw = {}) {
+  const options = {
+    smoothAngleDeg: raw.smoothAngleDeg ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.smoothAngleDeg,
+    sharpAngleDeg: raw.sharpAngleDeg ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.sharpAngleDeg,
+    harshAngleDeg: raw.harshAngleDeg ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.harshAngleDeg
+  };
+  if (!Number.isFinite(options.smoothAngleDeg) || options.smoothAngleDeg < 0) {
+    throw new Error(`smoothAngleDeg must be a finite non-negative angle (got ${options.smoothAngleDeg}).`);
+  }
+  if (!Number.isFinite(options.sharpAngleDeg) || options.sharpAngleDeg <= options.smoothAngleDeg) {
+    throw new Error(`sharpAngleDeg must be greater than smoothAngleDeg (got ${options.sharpAngleDeg}).`);
+  }
+  if (!Number.isFinite(options.harshAngleDeg) || options.harshAngleDeg <= options.sharpAngleDeg || options.harshAngleDeg > 180) {
+    throw new Error(`harshAngleDeg must be greater than sharpAngleDeg and <= 180 (got ${options.harshAngleDeg}).`);
+  }
+  return options;
+}
+function roughnessClassForAngle(angleDeg, options) {
+  if (angleDeg >= options.harshAngleDeg) return "harsh";
+  if (angleDeg >= options.sharpAngleDeg) return "sharp";
+  if (angleDeg >= options.smoothAngleDeg) return "moderate";
+  return "smooth";
+}
+function roughnessScoreForAngle(angleDeg, options) {
+  if (angleDeg < options.sharpAngleDeg) return 0;
+  if (angleDeg < options.harshAngleDeg) {
+    return MathUtils.lerp(0.48, 0.82, (angleDeg - options.sharpAngleDeg) / (options.harshAngleDeg - options.sharpAngleDeg));
+  }
+  return 1;
+}
+function roughnessColorForAngle(angleDeg, options) {
+  const cls = roughnessClassForAngle(angleDeg, options);
+  if (cls === "smooth" || cls === "harsh") return ROUGHNESS_COLORS[cls];
+  if (cls === "moderate") {
+    return lerpRgb(
+      ROUGHNESS_COLORS.moderate,
+      ROUGHNESS_COLORS.sharp,
+      (angleDeg - options.smoothAngleDeg) / (options.sharpAngleDeg - options.smoothAngleDeg)
+    );
+  }
+  return lerpRgb(
+    ROUGHNESS_COLORS.sharp,
+    ROUGHNESS_COLORS.harsh,
+    (angleDeg - options.sharpAngleDeg) / (options.harshAngleDeg - options.sharpAngleDeg)
+  );
+}
+function lerpRgb(a, b, t) {
+  const clamped = MathUtils.clamp(t, 0, 1);
+  return [
+    Math.round(MathUtils.lerp(a[0], b[0], clamped)),
+    Math.round(MathUtils.lerp(a[1], b[1], clamped)),
+    Math.round(MathUtils.lerp(a[2], b[2], clamped))
+  ];
+}
+function emptyRoughnessSummary() {
+  return {
+    triangleCount: 0,
+    edgeCount: 0,
+    boundaryEdgeCount: 0,
+    nonManifoldEdgeCount: 0,
+    smoothAreaPercent: 0,
+    moderateAreaPercent: 0,
+    sharpAreaPercent: 0,
+    harshAreaPercent: 0,
+    roughAreaPercent: 0,
+    meanAngleDeg: null,
+    p50AngleDeg: null,
+    p90AngleDeg: null,
+    p95AngleDeg: null,
+    p99AngleDeg: null,
+    maxAngleDeg: null,
+    qualityScore: 0
+  };
+}
+function summarizeRoughnessTriangles(triangles, edgeAngles, edgeCount, boundaryEdgeCount, nonManifoldEdgeCount, options) {
+  const areaByClass = {
+    smooth: 0,
+    moderate: 0,
+    sharp: 0,
+    harsh: 0
+  };
+  let totalArea = 0;
+  for (const tri of triangles) {
+    const area = Number.isFinite(tri.area) ? tri.area : 0;
+    totalArea += area;
+    areaByClass[roughnessClassForAngle(tri.maxAngleDeg, options)] += area;
+  }
+  const sortedAngles = [...edgeAngles].sort((lhs, rhs) => lhs - rhs);
+  const meanAngleDeg = sortedAngles.length > 0 ? Number((sortedAngles.reduce((sum, angle) => sum + angle, 0) / sortedAngles.length).toFixed(2)) : null;
+  const qualityScore = totalArea > 0 ? Math.round(
+    MathUtils.clamp(
+      100 * (areaByClass.smooth + areaByClass.moderate * 0.9) / totalArea - 50 * areaByClass.harsh / totalArea,
+      0,
+      100
+    )
+  ) : 0;
+  const safePercent = (value) => totalArea > 0 ? Number((value / totalArea * 100).toFixed(2)) : 0;
+  return {
+    triangleCount: triangles.length,
+    edgeCount,
+    boundaryEdgeCount,
+    nonManifoldEdgeCount,
+    smoothAreaPercent: safePercent(areaByClass.smooth),
+    moderateAreaPercent: safePercent(areaByClass.moderate),
+    sharpAreaPercent: safePercent(areaByClass.sharp),
+    harshAreaPercent: safePercent(areaByClass.harsh),
+    roughAreaPercent: safePercent(areaByClass.sharp + areaByClass.harsh),
+    meanAngleDeg,
+    p50AngleDeg: percentile(sortedAngles, 0.5),
+    p90AngleDeg: percentile(sortedAngles, 0.9),
+    p95AngleDeg: percentile(sortedAngles, 0.95),
+    p99AngleDeg: percentile(sortedAngles, 0.99),
+    maxAngleDeg: sortedAngles.length > 0 ? Number(sortedAngles[sortedAngles.length - 1].toFixed(2)) : null,
+    qualityScore
+  };
+}
+function percentile(sorted, q) {
+  if (sorted.length === 0) return null;
+  const index = MathUtils.clamp(Math.floor(sorted.length * q), 0, sorted.length - 1);
+  return Number(sorted[index].toFixed(2));
+}
+const DEG_PER_RAD = 180 / Math.PI;
+function analyzeRoughnessGeometry(sourceGeometry, rawOptions = {}) {
+  const options = resolveRoughnessInspectionOptions(rawOptions);
+  const geometry = sourceGeometry.index ? sourceGeometry.toNonIndexed() : sourceGeometry.clone();
+  const position = geometry.getAttribute("position");
+  const warnings = [];
+  if (!position || position.count < 3) {
+    return { geometry, summary: emptyRoughnessSummary(), warnings: ["No triangle geometry."] };
+  }
+  const triangleCount = Math.floor(position.count / 3);
+  const normals = new Array(triangleCount);
+  const triangles = new Array(triangleCount);
+  const edges = /* @__PURE__ */ new Map();
+  const colors = new Float32Array(position.count * 3);
+  const scores = new Float32Array(position.count);
+  const a = new Vector3();
+  const b = new Vector3();
+  const c = new Vector3();
+  const ac = new Vector3();
+  const normal = new Vector3();
+  const bbox = new Box3().setFromBufferAttribute(position);
+  const snap = Math.max(1e-6, bbox.getSize(new Vector3()).length() * 1e-8);
+  for (let tri = 0; tri < triangleCount; tri += 1) {
+    const offset = tri * 3;
+    readVertex(position, offset, a);
+    readVertex(position, offset + 1, b);
+    readVertex(position, offset + 2, c);
+    normal.subVectors(b, a).cross(ac.subVectors(c, a));
+    const areaTwice = normal.length();
+    triangles[tri] = { area: areaTwice * 0.5, maxAngleDeg: 0 };
+    normals[tri] = areaTwice > 1e-12 ? normal.multiplyScalar(1 / areaTwice).clone() : new Vector3(0, 0, 1);
+    const keys = [vertexKey(a, snap), vertexKey(b, snap), vertexKey(c, snap)];
+    for (let edge = 0; edge < 3; edge += 1) {
+      const key = edgeKey(keys[edge], keys[(edge + 1) % 3]);
+      let record = edges.get(key);
+      if (!record) {
+        record = { triangles: [] };
+        edges.set(key, record);
+      }
+      record.triangles.push(tri);
+    }
+  }
+  const { boundaryEdgeCount, nonManifoldEdgeCount, edgeAngles } = markTriangleRoughness(edges, triangles, normals);
+  if (boundaryEdgeCount > 0) warnings.push(`${boundaryEdgeCount} boundary edge(s) were treated as harsh roughness.`);
+  if (nonManifoldEdgeCount > 0) warnings.push(`${nonManifoldEdgeCount} non-manifold edge(s) were treated as harsh roughness.`);
+  for (let tri = 0; tri < triangleCount; tri += 1) {
+    const { maxAngleDeg } = triangles[tri];
+    const color = roughnessColorForAngle(maxAngleDeg, options);
+    const score = roughnessScoreForAngle(maxAngleDeg, options);
+    const offset = tri * 3;
+    for (let vertex = 0; vertex < 3; vertex += 1) {
+      const colorOffset = (offset + vertex) * 3;
+      colors[colorOffset] = color[0] / 255;
+      colors[colorOffset + 1] = color[1] / 255;
+      colors[colorOffset + 2] = color[2] / 255;
+      scores[offset + vertex] = score;
+    }
+  }
+  geometry.setAttribute("color", new BufferAttribute(colors, 3));
+  geometry.setAttribute("roughnessScore", new BufferAttribute(scores, 1));
+  geometry.computeBoundingBox();
+  return {
+    geometry,
+    summary: summarizeRoughnessTriangles(triangles, edgeAngles, edges.size, boundaryEdgeCount, nonManifoldEdgeCount, options),
+    warnings
+  };
+}
+function markTriangleRoughness(edges, triangles, normals) {
+  const edgeAngles = [];
+  let boundaryEdgeCount = 0;
+  let nonManifoldEdgeCount = 0;
+  for (const edge of edges.values()) {
+    if (edge.triangles.length === 1) {
+      boundaryEdgeCount += 1;
+      markTriangles(edge.triangles, triangles, 180);
+      edgeAngles.push(180);
+      continue;
+    }
+    if (edge.triangles.length > 2) {
+      nonManifoldEdgeCount += 1;
+      markTriangles(edge.triangles, triangles, 180);
+      edgeAngles.push(180);
+      continue;
+    }
+    const [first, second] = edge.triangles;
+    const dot = MathUtils.clamp(normals[first].dot(normals[second]), -1, 1);
+    const angleDeg = Math.acos(dot) * DEG_PER_RAD;
+    markTriangles(edge.triangles, triangles, angleDeg);
+    edgeAngles.push(angleDeg);
+  }
+  return { boundaryEdgeCount, nonManifoldEdgeCount, edgeAngles };
+}
+function readVertex(position, index, target) {
+  target.set(position.getX(index), position.getY(index), position.getZ(index));
+}
+function vertexKey(point, snap) {
+  return `${Math.round(point.x / snap)},${Math.round(point.y / snap)},${Math.round(point.z / snap)}`;
+}
+function edgeKey(a, b) {
+  return a < b ? `${a}|${b}` : `${b}|${a}`;
+}
+function markTriangles(indices, triangles, angleDeg) {
+  for (const index of indices) {
+    triangles[index].maxAngleDeg = Math.max(triangles[index].maxAngleDeg, angleDeg);
+  }
+}
 const canvas = document.getElementById("canvas");
 const exportCanvas = document.createElement("canvas");
 const exportCtx = exportCanvas.getContext("2d");
@@ -1569,39 +1839,8 @@ function updateSdfRaymarchUniforms(session) {
     sdf.material.uniforms.uIsOrthographic.value = isOrthographic;
   }
 }
-const ANGLE_DIRS = {
-  front: [0, -1, 0.2],
-  back: [0, 1, 0.2],
-  side: [1, 0, 0.2],
-  right: [1, 0, 0.2],
-  top: [0, -0.01, 1],
-  iso: [0.6, -0.6, 0.4]
-};
-function normalizeVector(dir) {
-  const len = Math.sqrt(dir[0] ** 2 + dir[1] ** 2 + dir[2] ** 2) || 1;
-  return [dir[0] / len, dir[1] / len, dir[2] / len];
-}
-function sphericalToDir(azimuthDeg, elevationDeg) {
-  const az = azimuthDeg * Math.PI / 180;
-  const el = elevationDeg * Math.PI / 180;
-  const cosEl = Math.cos(el);
-  return [cosEl * Math.sin(az), -cosEl * Math.cos(az), Math.sin(el)];
-}
-function parseCameraToken(token) {
-  const preset = ANGLE_DIRS[token];
-  if (preset) return { label: token, dir: preset };
-  const parts = token.split(":").map((s) => Number.parseFloat(s));
-  if (parts.length >= 2 && parts.length <= 3 && parts.every((n) => Number.isFinite(n))) {
-    const dir = sphericalToDir(parts[0], parts[1]);
-    const label = `az${parts[0]}_el${parts[1]}`;
-    return { label, dir, distance: parts[2] };
-  }
-  throw new Error(
-    `Unknown camera "${token}". Use a preset (front, back, side, right, top, iso) or azimuth:elevation in degrees (e.g. 45:30).`
-  );
-}
 function applyDirectionCamera(session, dir, distanceOverride) {
-  const d = normalizeVector(dir);
+  const d = normalizeCameraDirection(dir);
   const dist = distanceOverride ?? session.distance;
   session.camera.position.set(session.center.x + d[0] * dist, session.center.y + d[1] * dist, session.center.z + d[2] * dist);
   session.camera.up.set(0, 0, 1);
@@ -2274,6 +2513,130 @@ function renderCurrentThickness(session, rawOptions) {
     material.dispose();
   }
 }
+const ROUGHNESS_SMOOTH_OPACITY = 0.16;
+const ROUGHNESS_HARSH_OPACITY = 1;
+function createRoughnessMaterial(clippingPlanes) {
+  const material = new ShaderMaterial({
+    transparent: true,
+    depthTest: true,
+    depthWrite: true,
+    clippingPlanes: clippingPlanes ?? void 0,
+    uniforms: {
+      smoothOpacity: { value: ROUGHNESS_SMOOTH_OPACITY },
+      harshOpacity: { value: ROUGHNESS_HARSH_OPACITY }
+    },
+    vertexShader: `
+      attribute vec3 color;
+      attribute float roughnessScore;
+      varying vec3 vColor;
+      varying float vRoughnessScore;
+      varying vec3 vViewNormal;
+
+      void main() {
+        vColor = color;
+        vRoughnessScore = roughnessScore;
+        vViewNormal = normalize(normalMatrix * normal);
+        gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+      }
+    `,
+    fragmentShader: `
+      precision highp float;
+      uniform float smoothOpacity;
+      uniform float harshOpacity;
+      varying vec3 vColor;
+      varying float vRoughnessScore;
+      varying vec3 vViewNormal;
+
+      void main() {
+        vec3 shadowLight = normalize(vec3(0.32, 0.42, 0.84));
+        float shade = 0.34 + 0.48 * max(dot(normalize(vViewNormal), shadowLight), 0.0);
+        vec3 smoothShadow = vec3(0.26, 0.30, 0.35) * shade;
+        float colorMix = smoothstep(0.04, 0.35, vRoughnessScore);
+        vec3 finalColor = mix(smoothShadow, vColor, colorMix);
+        float alpha = mix(smoothOpacity, harshOpacity, smoothstep(0.02, 0.55, vRoughnessScore));
+        gl_FragColor = vec4(finalColor, alpha);
+      }
+    `
+  });
+  material.toneMapped = false;
+  return material;
+}
+function renderCurrentRoughness(session, rawOptions) {
+  const r = getRenderer(session.size, session.pixelRatio);
+  const options = resolveRoughnessInspectionOptions(rawOptions);
+  const byId = new Map(session.objects.map((obj) => [obj.id, obj]));
+  const warnings = [];
+  const objects = [];
+  const replacements = session.renderables.map((renderable, index) => {
+    const previousMaterial = renderable.solid.material;
+    const previousGeometry = renderable.solid.geometry;
+    if (renderable.sdfRaymarch) {
+      const material2 = new MeshBasicMaterial({ transparent: true, opacity: 0, depthWrite: false });
+      material2.toneMapped = false;
+      renderable.solid.material = material2;
+      warnings.push(`${renderable.name}: SDF raymarch objects are not included in mesh roughness inspection.`);
+      return { renderable, previousMaterial, previousGeometry, material: material2, geometry: null };
+    }
+    const analysis = analyzeRoughnessGeometry(previousGeometry, options);
+    const bbox = analysis.geometry.boundingBox;
+    const sourceObject = byId.get(renderable.id);
+    if (analysis.warnings.length > 0) {
+      analysis.warnings.forEach((warning) => warnings.push(`${renderable.name}: ${warning}`));
+    }
+    objects.push({
+      index: index + 1,
+      id: renderable.id,
+      name: renderable.name,
+      groupName: renderable.groupName,
+      treePath: sourceObject == null ? void 0 : sourceObject.treePath,
+      mock: (sourceObject == null ? void 0 : sourceObject.mock) === true,
+      bbox: {
+        min: bbox ? [bbox.min.x, bbox.min.y, bbox.min.z] : [0, 0, 0],
+        max: bbox ? [bbox.max.x, bbox.max.y, bbox.max.z] : [0, 0, 0]
+      },
+      ...analysis.summary
+    });
+    const material = createRoughnessMaterial(renderable.solidMaterial.clippingPlanes);
+    renderable.solid.geometry = analysis.geometry;
+    renderable.solid.material = material;
+    return { renderable, previousMaterial, previousGeometry, material, geometry: analysis.geometry };
+  });
+  try {
+    const png = withSolidOnlyVisibility(
+      session,
+      () => withTemporarySceneBackground(session, new Color(0), () => {
+        updateSdfRaymarchUniforms(session);
+        r.render(session.scene, session.camera);
+        return captureRenderedPng(session.size);
+      })
+    );
+    return {
+      png,
+      report: {
+        method: "mesh-dihedral-angle",
+        options,
+        objectCount: objects.length,
+        objects,
+        warnings,
+        style: {
+          smoothColor: ROUGHNESS_COLORS.smooth,
+          moderateColor: ROUGHNESS_COLORS.moderate,
+          sharpColor: ROUGHNESS_COLORS.sharp,
+          harshColor: ROUGHNESS_COLORS.harsh,
+          smoothOpacity: ROUGHNESS_SMOOTH_OPACITY,
+          harshOpacity: ROUGHNESS_HARSH_OPACITY
+        }
+      }
+    };
+  } finally {
+    replacements.forEach(({ renderable, previousMaterial, previousGeometry, material, geometry }) => {
+      renderable.solid.geometry = previousGeometry;
+      renderable.solid.material = previousMaterial;
+      geometry == null ? void 0 : geometry.dispose();
+      material.dispose();
+    });
+  }
+}
 function emptySectionSvg() {
   return {
     svg: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="-1 -1 2 2" width="400" height="400"><rect x="-1" y="-1" width="2" height="2" fill="#2a2a2a"/></svg>',
@@ -2756,7 +3119,7 @@ function applyOrbitPose(session, turn, pitchDeg) {
   const pitch = MathUtils.degToRad(clampedPitch);
   const cosPitch = Math.cos(pitch);
   const dir = [Math.sin(yaw) * cosPitch, -Math.cos(yaw) * cosPitch, Math.sin(pitch)];
-  const d = normalizeVector(dir);
+  const d = normalizeCameraDirection(dir);
   session.camera.position.set(
     session.orbitTarget.x + d[0] * session.orbitRadius,
     session.orbitTarget.y + d[1] * session.orbitRadius,
@@ -3190,6 +3553,12 @@ function createSession(code, opts) {
   const scene = new Scene();
   const sceneConfig = result.sceneConfig ?? null;
   try {
+    if ((opts == null ? void 0 : opts.viewName) && (opts == null ? void 0 : opts.cameraToken)) {
+      return {
+        ok: false,
+        error: "Cannot use --view with --camera. Choose either a model-declared view or an explicit camera."
+      };
+    }
     if (opts == null ? void 0 : opts.viewName) {
       if (requestedSceneState == null ? void 0 : requestedSceneState.camera) {
         return {
@@ -3227,6 +3596,34 @@ function createSession(code, opts) {
   const fov = 45;
   const distance = maxDim / (2 * Math.tan(fov * Math.PI / 360)) * 1.6;
   const cameraFov = ((_c = requestedSceneState == null ? void 0 : requestedSceneState.camera) == null ? void 0 : _c.fov) ?? ((_d = sceneConfig == null ? void 0 : sceneConfig.camera) == null ? void 0 : _d.fov) ?? fov;
+  try {
+    if (opts == null ? void 0 : opts.cameraToken) {
+      if (requestedSceneState == null ? void 0 : requestedSceneState.camera) {
+        return {
+          ok: false,
+          error: "Cannot use camera presets/angles with an explicit render camera. Remove --camera-json or the camera field from --scene."
+        };
+      }
+      const parsed = parseCameraToken(opts.cameraToken);
+      const dir = normalizeCameraDirection(parsed.dir);
+      const tokenDistance = parsed.distance ?? distance;
+      requestedSceneState = mergeViewportRenderSceneStates(requestedSceneState, {
+        camera: {
+          projectionMode: "perspective",
+          position: [
+            center.x + dir[0] * tokenDistance,
+            center.y + dir[1] * tokenDistance,
+            center.z + dir[2] * tokenDistance
+          ],
+          target: [center.x, center.y, center.z],
+          up: [0, 0, 1],
+          fov: cameraFov
+        }
+      });
+    }
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
   const joints = ((_e = result.jointsView) == null ? void 0 : _e.enabled) === false ? [] : ((_f = result.jointsView) == null ? void 0 : _f.joints) ?? [];
   const jointCouplings = ((_g = result.jointsView) == null ? void 0 : _g.enabled) === false ? [] : ((_h = result.jointsView) == null ? void 0 : _h.couplings) ?? [];
   const animationClips = ((_i = result.jointsView) == null ? void 0 : _i.enabled) === false ? [] : ((_j = result.jointsView) == null ? void 0 : _j.animations) ?? [];
@@ -3525,7 +3922,7 @@ window.__forgeRender = async (code, opts) => {
   const session = built.session;
   await emitInspectProgress(opts, { type: "session-done", objectCount: session.objects.length });
   const renderMode = (opts == null ? void 0 : opts.renderMode) === "wireframe" ? "wireframe" : "solid";
-  const edgePreset = (opts == null ? void 0 : opts.edges) ?? "thin";
+  const edgePreset = (opts == null ? void 0 : opts.edges) ?? "off";
   setSessionMode(session, renderMode);
   if (renderMode === "solid") {
     session.renderables.forEach((r) => {
@@ -3547,11 +3944,13 @@ window.__forgeRender = async (code, opts) => {
   const distanceRenders = {};
   const collisionRenders = {};
   const thicknessRenders = {};
+  const roughnessRenders = {};
   let maskObjects = [];
   let connectivityReport = null;
   let distanceReport = null;
   let collisionReport = null;
   let thicknessReport = null;
+  let roughnessReport = null;
   let sectionAtlas = null;
   const channelViewCounts = /* @__PURE__ */ new Map();
   const markChannelViewStart = async (channel, view) => {
@@ -3592,6 +3991,13 @@ window.__forgeRender = async (code, opts) => {
         normalRenders[label] = renderCurrentNormals(session);
         await markChannelViewDone("normals", label);
       }
+      if (requestedChannels.has("roughness")) {
+        await markChannelViewStart("roughness", label);
+        const roughness = renderCurrentRoughness(session, opts == null ? void 0 : opts.roughness);
+        roughnessRenders[label] = roughness.png;
+        roughnessReport = roughness.report;
+        await markChannelViewDone("roughness", label);
+      }
       if (requestedChannels.has("mask")) {
         await markChannelViewStart("mask", label);
         const mask = renderCurrentMask(session);
@@ -3652,6 +4058,12 @@ window.__forgeRender = async (code, opts) => {
     renders,
     depth: depthRenders,
     normals: normalRenders,
+    roughness: roughnessReport ? {
+      ...roughnessReport,
+      views: roughnessRenders
+    } : {
+      views: roughnessRenders
+    },
     mask: {
       views: maskRenders,
       objects: maskObjects