brep-io-kernel 1.0.23 → 1.0.24

package/dist-kernel/brep-kernel.js

@@ -43327,7 +43327,34 @@ function Kx(i = {}) {
         }, B.parentSolid = this;
         try {
           const Q = (s?.materialKey || "OVERLAY").toUpperCase(), h = og?.EDGE || {}, u = h[Q] || (Q === "OVERLAY" ? h.OVERLAY : null) || h.BASE;
-          u && (B.material = u), u && ut.setBaseMaterial(B, u, { force: !1 }), B.material && Q !== "BASE" && (B.material.depthTest = !1, B.material.depthWrite = !1);
+          let l = u;
+          if (u && Q !== "BASE" && !(u.depthTest === !1 && u.depthWrite === !1)) {
+            const D = Object.values(h).includes(u);
+            let p = !1;
+            if (D && typeof u.clone == "function") {
+              try {
+                l = u.clone(), p = !!l && l !== u;
+              } catch {
+                l = u, p = !1;
+              }
+              if (p)
+                try {
+                  u.resolution && l.resolution && typeof l.resolution.copy == "function" && l.resolution.copy(u.resolution);
+                } catch {
+                }
+            }
+            if ((p || !D) && l) {
+              try {
+                l.depthTest = !1;
+              } catch {
+              }
+              try {
+                l.depthWrite = !1;
+              } catch {
+              }
+            }
+          }
+          l && (B.material = l), l && ut.setBaseMaterial(B, l, { force: !1 });
           try {
             B.computeLineDistances();
           } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brep-io-kernel",
-  "version": "1.0.23",
+  "version": "1.0.24",
   "scripts": {
     "dev": "pnpm generateLicenses && pnpm build:kernel && vite --host 0.0.0.0",
     "build": "pnpm generateLicenses && vite build",

package/src/BREP/SolidMethods/visualize.js

@@ -354,12 +354,34 @@ export function visualize(options = {}) {
                     const key = (aux?.materialKey || 'OVERLAY').toUpperCase();
                     const edgeMats = CADmaterials?.EDGE || {};
                     const mat = edgeMats[key] || (key === 'OVERLAY' ? edgeMats.OVERLAY : null) || edgeMats.BASE;
-                    if (mat) edgeObj.material = mat;
-                    if (mat) SelectionState.setBaseMaterial(edgeObj, mat, { force: false });
-                    if (edgeObj.material && (key !== 'BASE')) {
-                        edgeObj.material.depthTest = false;
-                        edgeObj.material.depthWrite = false;
+                    let appliedMat = mat;
+                    const wantsOverlay = key !== 'BASE';
+                    if (mat && wantsOverlay) {
+                        const alreadyOverlay = mat.depthTest === false && mat.depthWrite === false;
+                        if (!alreadyOverlay) {
+                            const shared = Object.values(edgeMats).includes(mat);
+                            let cloned = false;
+                            if (shared && typeof mat.clone === 'function') {
+                                try {
+                                    appliedMat = mat.clone();
+                                    cloned = !!appliedMat && appliedMat !== mat;
+                                } catch { appliedMat = mat; cloned = false; }
+                                if (cloned) {
+                                    try {
+                                        if (mat.resolution && appliedMat.resolution && typeof appliedMat.resolution.copy === 'function') {
+                                            appliedMat.resolution.copy(mat.resolution);
+                                        }
+                                    } catch { }
+                                }
+                            }
+                            if ((cloned || !shared) && appliedMat) {
+                                try { appliedMat.depthTest = false; } catch { }
+                                try { appliedMat.depthWrite = false; } catch { }
+                            }
+                        }
                     }
+                    if (appliedMat) edgeObj.material = appliedMat;
+                    if (appliedMat) SelectionState.setBaseMaterial(edgeObj, appliedMat, { force: false });
                     try { edgeObj.computeLineDistances(); } catch { }
                     edgeObj.renderOrder = 10020;
                 } catch { }