allow deriving lines and points from faces

Author: stewartoallen

src/void/api/solids.js

@@ -20,12 +20,6 @@ function createSolidsApi(getApi) {
         }
         const loop = view?.object?.userData?.sketchProfileLoop || view?.entity?.loop || null;
         if (Array.isArray(loop) && loop.length >= 3) return [loop];
-        if (Array.isArray(profileTarget?.loops) && profileTarget.loops.length) {
-            const cached = profileTarget.loops
-                .filter(item => Array.isArray(item) && item.length >= 3)
-                .map(item => item.map(p => ({ x: p?.x || 0, y: p?.y || 0 })));
-            if (cached.length) return cached;
-        }
         return null;
     }
 
@@ -296,13 +290,29 @@ function createSolidsApi(getApi) {
                 center,
                 normal,
                 xAxis,
-                planar
+                planar,
+                boundarySegmentsLocal: null
             });
             groupId++;
         }
         return { triToGroup, groups };
     }
 
+    function buildBoundarySegmentsFromGeometry(geometry) {
+        if (!geometry) return [];
+        const edgesGeom = new THREE.EdgesGeometry(geometry, 1);
+        const pos = edgesGeom.getAttribute?.('position');
+        if (!pos) return [];
+        const out = [];
+        for (let i = 0; i + 1 < pos.count; i += 2) {
+            const a = new THREE.Vector3().fromBufferAttribute(pos, i);
+            const b = new THREE.Vector3().fromBufferAttribute(pos, i + 1);
+            out.push({ a, b, mid: a.clone().add(b).multiplyScalar(0.5) });
+        }
+        edgesGeom.dispose?.();
+        return out;
+    }
+
     function makeFaceMaterials() {
         return {
             hover: new THREE.MeshBasicMaterial({
@@ -621,6 +631,16 @@ function createSolidsApi(getApi) {
             return out;
         },
 
+        getPickEdgeForSolid(solidId) {
+            const id = String(solidId || '');
+            if (!id) return null;
+            const view = this._meshViews.get(id);
+            if (!view || view?.group?.visible === false || view?.mesh?.visible === false || view?.edges?.visible === false) {
+                return null;
+            }
+            return view.edges || null;
+        },
+
         getEdgeSegmentWorld(object, segmentIndex) {
             if (!object?.geometry || segmentIndex < 0) return null;
             object.updateMatrixWorld?.(true);
@@ -677,43 +697,53 @@ function createSolidsApi(getApi) {
             const srcA = new THREE.Vector3(Number(sa.x || 0), Number(sa.y || 0), Number(sa.z || 0));
             const srcB = new THREE.Vector3(Number(sb.x || 0), Number(sb.y || 0), Number(sb.z || 0));
             const solids = this.list() || [];
-            const wanted = [];
+            const searchSets = [];
             if (targetSolidId) {
-                wanted.push(targetSolidId);
-            } else if (targetFeatureId) {
+                searchSets.push([targetSolidId]);
+            }
+            if (targetFeatureId) {
+                const byFeature = [];
                 for (const solid of solids) {
                     if (String(solid?.source?.feature_id || '') === targetFeatureId && solid?.id) {
-                        wanted.push(String(solid.id));
+                        byFeature.push(String(solid.id));
                     }
                 }
-            } else {
-                for (const solid of solids) {
-                    if (solid?.id) wanted.push(String(solid.id));
-                }
+                if (byFeature.length) searchSets.push(byFeature);
+            }
+            const all = [];
+            for (const solid of solids) {
+                if (solid?.id) all.push(String(solid.id));
             }
+            if (all.length) searchSets.push(all);
             let best = null;
             let bestScore = Infinity;
-            for (const solidId of wanted) {
-                const view = this._meshViews.get(solidId);
-                const edgesObj = view?.edges;
-                if (!edgesObj?.geometry) continue;
-                const pos = edgesObj.geometry.getAttribute?.('position');
-                const idx = edgesObj.geometry.getIndex?.();
-                if (!pos) continue;
-                const segCount = idx?.array?.length
-                    ? Math.floor(idx.array.length / 2)
-                    : Math.floor(pos.count / 2);
-                for (let i = 0; i < segCount; i++) {
-                    const seg = this.getEdgeSegmentWorld(edgesObj, i);
-                    if (!seg) continue;
-                    const d1 = seg.a.distanceTo(srcA) + seg.b.distanceTo(srcB);
-                    const d2 = seg.a.distanceTo(srcB) + seg.b.distanceTo(srcA);
-                    const score = Math.min(d1, d2);
-                    if (score < bestScore) {
-                        bestScore = score;
-                        best = { solidId, index: i, aWorld: seg.a, bWorld: seg.b };
+            const scanSet = (wanted = []) => {
+                for (const solidId of wanted) {
+                    const view = this._meshViews.get(solidId);
+                    const edgesObj = view?.edges;
+                    if (!edgesObj?.geometry) continue;
+                    const pos = edgesObj.geometry.getAttribute?.('position');
+                    const idx = edgesObj.geometry.getIndex?.();
+                    if (!pos) continue;
+                    const segCount = idx?.array?.length
+                        ? Math.floor(idx.array.length / 2)
+                        : Math.floor(pos.count / 2);
+                    for (let i = 0; i < segCount; i++) {
+                        const seg = this.getEdgeSegmentWorld(edgesObj, i);
+                        if (!seg) continue;
+                        const d1 = seg.a.distanceTo(srcA) + seg.b.distanceTo(srcB);
+                        const d2 = seg.a.distanceTo(srcB) + seg.b.distanceTo(srcA);
+                        const score = Math.min(d1, d2);
+                        if (score < bestScore) {
+                            bestScore = score;
+                            best = { solidId, index: i, aWorld: seg.a, bWorld: seg.b };
+                        }
                     }
                 }
+            };
+            for (const wanted of searchSets) {
+                if (best) break;
+                scanSet(wanted);
             }
             if (!best) return null;
             best.midWorld = best.aWorld.clone().add(best.bWorld).multiplyScalar(0.5);
@@ -752,6 +782,31 @@ function createSolidsApi(getApi) {
             return { key: `${solidId}:${faceId}`, solidId, faceId, view, meta };
         },
 
+        getFaceBoundarySegments(key) {
+            const face = this.getFaceByKey(key);
+            if (!face?.meta?.geometry) return [];
+            if (!Array.isArray(face.meta.boundarySegmentsLocal)) {
+                face.meta.boundarySegmentsLocal = buildBoundarySegmentsFromGeometry(face.meta.geometry);
+            }
+            const local = face.meta.boundarySegmentsLocal || [];
+            if (!local.length) return [];
+            const mesh = face?.view?.mesh || null;
+            if (!mesh?.matrixWorld) return [];
+            mesh.updateMatrixWorld?.(true);
+            const out = [];
+            for (const seg of local) {
+                if (!seg?.a || !seg?.b) continue;
+                const a = seg.a.clone().applyMatrix4(mesh.matrixWorld);
+                const b = seg.b.clone().applyMatrix4(mesh.matrixWorld);
+                out.push({
+                    a,
+                    b,
+                    mid: a.clone().add(b).multiplyScalar(0.5)
+                });
+            }
+            return out;
+        },
+
         setHoveredFace(key = null) {
             const next = key && this.getFaceByKey(key) ? key : null;
             if (next === this._hoveredFaceKey) return;
@@ -1106,6 +1161,7 @@ function createSolidsApi(getApi) {
                 let result = null;
                 let passReason = reason;
                 for (let pass = 0; pass < 2; pass++) {
+                    api.sketchRuntime?.sync?.();
                     const snapshot = buildRebuildSnapshot(api);
                     try {
                         const workerReply = await this.requestWorkerRebuild(snapshot, passReason);
@@ -1147,6 +1203,11 @@ function createSolidsApi(getApi) {
                         passReason = 'sketch.face.rebind';
                         continue;
                     }
+                    if (derivedChanged && pass === 0) {
+                        api.sketchRuntime?.sync?.();
+                        passReason = 'sketch.derived.refresh';
+                        continue;
+                    }
                     if (rebound || derivedChanged) {
                         api.sketchRuntime?.sync?.();
                     }

src/void/interact.js

@@ -46,8 +46,6 @@ const interact = {
     hoveredSketchProfileKey: null,
     hoveredSolidFaceKey: null,
     hoveredSketchConstraintId: null,
-    _debugDerivedHoverKey: null,
-    _debugDerivedRenderKey: null,
     sketchPointerDown: null,
     sketchDrag: null,
     sketchLineStart: null,

src/void/interact/planes.js

@@ -130,8 +130,11 @@ function updateHandleScreenScales() {
 }
 
 function handleHover(intersection, event, allIntersections) {
-    if (!(this.isSketchEditing && this.isSketchEditing()) || (this.isSketchRetargetMode && this.isSketchRetargetMode())) {
-        const primaryHit = this.getPrimarySurfaceHitFromIntersections(allIntersections || (intersection ? [intersection] : []));
+    const sketchEditing = !!(this.isSketchEditing && this.isSketchEditing());
+    const retargetMode = !!(this.isSketchRetargetMode && this.isSketchRetargetMode());
+    const primaryHit = this.getPrimarySurfaceHitFromIntersections(allIntersections || (intersection ? [intersection] : []));
+
+    if (!sketchEditing || retargetMode) {
         if (primaryHit?.type === 'profile') {
             const profileHit = primaryHit.hit;
             if (this.hoveredSolidFaceKey) {
@@ -172,6 +175,26 @@ function handleHover(intersection, event, allIntersections) {
             api.solids?.setHoveredFace?.(null);
             window.dispatchEvent(new CustomEvent('void-state-change'));
         }
+    } else if (primaryHit?.type === 'solid-face') {
+        const solidFaceHit = primaryHit.hit;
+        this.hoveredSolidFaceKey = solidFaceHit.key;
+        api.solids?.setHoveredFace?.(solidFaceHit.key);
+        this.hoverIntersection = solidFaceHit.intersection || intersection || null;
+        this.setHoveredPoint(null);
+        this.hoveredSketchProfileKey = null;
+        api.sketchRuntime?.setHoveredProfile?.(null);
+        if (this.hoveredPlane && !this.hoveredPlane.isSelected()) {
+            this.hoveredPlane.setHovered(false);
+            this.hoveredPlane = null;
+        }
+        this.updateSketchInteractionVisuals?.();
+        window.dispatchEvent(new CustomEvent('void-state-change'));
+        return;
+    } else if (this.hoveredSolidFaceKey) {
+        this.hoveredSolidFaceKey = null;
+        api.solids?.setHoveredFace?.(null);
+        this.updateSketchInteractionVisuals?.();
+        window.dispatchEvent(new CustomEvent('void-state-change'));
     }
 
     const pointHit = this.getPointHitFromEvent(event);