markuno_lib 1.1.24 → 1.1.26

package/bin/markcad3d.js

@@ -1,186 +1,11 @@
-import * as THREE from 'three';
-import { PIF, clean, hash, getshape, raccordabezier } from '#cad/markcad.js';
-export { clamp } from '#cad/markcad.js';
-import earcut from 'earcut';
-
-const SIDE = THREE.FrontSide; // default sides THREE.DoubleSide/THREE.FrontSide;
-let materialline1 = new THREE.LineBasicMaterial({ color: 0x303030 });
-let materialline2 = new THREE.LineBasicMaterial({ color: 0x505050 });
-
-
-const mwhite$1 = new THREE.MeshStandardMaterial({ color: 0xffffff, roughness: 0.5, metalness: 0.4, side: SIDE });
-const mgray1 = new THREE.MeshStandardMaterial({ color: 0x808080, roughness: 0.5, metalness: 0.4, side: SIDE });
-const mgray2 = new THREE.MeshStandardMaterial({ color: 0xb0b0b0, roughness: 0.5, metalness: 0.4, side: SIDE });
-const mred = new THREE.MeshStandardMaterial({ color: 0xff0000, roughness: 0.5, metalness: 0.4, side: SIDE });
-const mblue = new THREE.MeshStandardMaterial({ color: 0x1e40af, roughness: 0.5, metalness: 0.4, side: SIDE });
-const mgreen = new THREE.MeshStandardMaterial({ color: 0x009000, roughness: 0.5, metalness: 0.4, side: SIDE });
-const mblack = new THREE.MeshStandardMaterial({ color: 0x000000, roughness: 0.5, metalness: 0.4, side: SIDE });
-const scaleunit = 1 / 1000;
-
-function groupfromgeometry(geometry, material, x, y, z, name, layer) {
-    let child = new THREE.Group();
-    child.position.set(x, y, z);
-    child.name = name;
-
-    // Crea la mesh principale
-    const mesh = new THREE.Mesh(geometry, material);
-    mesh.name = name;
-    mesh.castShadow = true;
-    mesh.receiveShadow = true;
-    mesh.layers.set(layer);
-
-    // Aggiunge i bordi
-    const edges = new THREE.EdgesGeometry(geometry);
-    const lineSegments = new THREE.LineSegments(edges, materialline1);
-    lineSegments.layers.set(30);
-
-    child.add(mesh);
-    child.add(lineSegments);
-    return child;
-}
-
-function posiziona(grp, pos = {}) {
-    let tm = new THREE.Group();
-    if (grp) {
-        let g2 = grp.clone();
-        let tm2 = g2;
-        let { sl = 0, sa = 0, sp = 0, ax = 0, ay = 0, az = 0, ul = 0, ua = 0, up = 0, scale = 1, scx = scale, scy = scale, scz = scale } = pos;
-        tm.position.set(sl, sa, sp);
-        tm.rotation.set(ax * PIF, ay * PIF, az * PIF);
-        if (ul || ua || up) {
-            tm2 = new THREE.Group();
-            tm2.add(g2);
-            tm2.position.set(ul, ua, up);
-        }
-        tm.scale.set(scx, scy, scz);
-        tm.add(tm2);
-    }
-    return tm;
-}
-
-function edgesfromgeometry(g1, layer = 30) {
-    const edges = new THREE.EdgesGeometry(g1, 20);
-    return getlinesgeom(edges, layer);
-}
-
-function getlinesgeom(edges, layer = 30) {
-    const lineSegments = new THREE.LineSegments(edges, materialline1);
-    lineSegments.layers.set(layer);
-    return lineSegments;
-}
-
-function getmesh(geom, material, layer = 1, clone = false) {
-    let m = new THREE.Mesh(geom, clone ? material.clone() : material);
-    m.castShadow = true;
-    m.receiveShadow = true;
-    m.layers.set(layer);
-    return m;
-}
-
-function get3dshape(punti, material, layer) {
-    if (!punti || punti.length < 3) {
-        return new THREE.BufferGeometry();
-    }
-    const vertices = [];
-    for (let i = 0; i < punti.length; i++) {
-        const p1 = punti[i];
-        const p2 = punti[(i + 1) % punti.length];
-        vertices.push(p1.x, 0, p1.y);
-        vertices.push(p2.x, 0, p2.y);
-    }
-    const geometry = new THREE.BufferGeometry();
-    geometry.setAttribute('position', new THREE.Float32BufferAttribute(vertices, 3));
-    let m = new THREE.LineSegments(geometry, material);
-    m.layers.set(layer);
-    return m;
-}
-
-function creategroup(name) {
-    let g = new THREE.Group();
-    g.name = name || '$$';
-    return g
-}
-
-function svuotanodo(n) {
-    function _dispose(node) {
-        // Gestisce ricorsivamente tutti i figli
-        if (node.children.length) {
-            const children = [...node.children];
-            children.forEach(child => {
-                _dispose(child);
-                node.remove(child);  // Usa node.remove invece di children.remove
-            });
-        }
-        // Dispone delle risorse del nodo corrente
-        if (node.geometry) {
-            node.geometry.dispose();
-        }
-        if (node.material) {
-            if (Array.isArray(node.material)) {
-                node.material.forEach(m => m.dispose());
-            } else {
-                node.material.dispose();
-            }
-        }
-    }
-    _dispose(n);
-}
-
-// cancella uno specifico nodo in una scena THREEJS 
-function deletegroup(grpbase, name) {
-    if (!grpbase?.children) return;
-    let gr = grpbase.children.find(e => e.name == name);
-    if (gr) {
-        // Rimuovi tutti i figli in modo ricorsivo
-        while (gr.children.length > 0) {
-            const child = gr.children[0];
-            /*
-            if (child.geometry) {
-                child.geometry.dispose();
-            }
-            if (child.material) {
-                if (Array.isArray(child.material)) {
-                    child.material.forEach(m => m.dispose());
-                } else {
-                    child.material.dispose();
-                }
-            }
-            */
-            gr.remove(child);
-        }
-        // Rimuovi il gruppo dal parent
-        if (gr.parent) {
-            gr.parent.remove(gr);
-        }
-        // Pulisci eventuali riferimenti
-        gr = null;
-    }
-}
-
-function randombasemat() {
-    const material = new THREE.LineBasicMaterial();
-    const color = new THREE.Color();
-    color.setHSL(Math.random(), 0.7, 0.4);
-    material.color = color;
-    return material;
-}
-
+import*as THREE from"three";import{PIF,clean,hash,getshape,raccordabezier}from"#markuno_cad";export{clamp}from"#markuno_cad";import earcut from"earcut";const SIDE=THREE.FrontSide;let materialline1=new THREE.LineBasicMaterial({color:3158064}),materialline2=new THREE.LineBasicMaterial({color:5263440});const mwhite$1=new THREE.MeshStandardMaterial({color:16777215,roughness:.5,metalness:.4,side:SIDE}),mgray1=new THREE.MeshStandardMaterial({color:8421504,roughness:.5,metalness:.4,side:SIDE}),mgray2=new THREE.MeshStandardMaterial({color:11579568,roughness:.5,metalness:.4,side:SIDE}),mred=new THREE.MeshStandardMaterial({color:16711680,roughness:.5,metalness:.4,side:SIDE}),mblue=new THREE.MeshStandardMaterial({color:1982639,roughness:.5,metalness:.4,side:SIDE}),mgreen=new THREE.MeshStandardMaterial({color:36864,roughness:.5,metalness:.4,side:SIDE}),mblack=new THREE.MeshStandardMaterial({color:0,roughness:.5,metalness:.4,side:SIDE}),scaleunit=.001;function groupfromgeometry(geometry,material,x,y,z,name,layer){let child=new THREE.Group;child.position.set(x,y,z),child.name=name;const mesh=new THREE.Mesh(geometry,material);mesh.name=name,mesh.castShadow=!0,mesh.receiveShadow=!0,mesh.layers.set(layer);const edges=new THREE.EdgesGeometry(geometry),lineSegments=new THREE.LineSegments(edges,materialline1);return lineSegments.layers.set(30),child.add(mesh),child.add(lineSegments),child}function posiziona(grp,pos={}){let tm=new THREE.Group;if(grp){let g2=grp.clone(),tm2=g2,{sl:sl=0,sa:sa=0,sp:sp=0,ax:ax=0,ay:ay=0,az:az=0,ul:ul=0,ua:ua=0,up:up=0,scale:scale=1,scx:scx=scale,scy:scy=scale,scz:scz=scale}=pos;tm.position.set(sl,sa,sp),tm.rotation.set(ax*PIF,ay*PIF,az*PIF),(ul||ua||up)&&(tm2=new THREE.Group,tm2.add(g2),tm2.position.set(ul,ua,up)),tm.scale.set(scx,scy,scz),tm.add(tm2)}return tm}function edgesfromgeometry(g1,layer=30){return getlinesgeom(new THREE.EdgesGeometry(g1,20),layer)}function getlinesgeom(edges,layer=30){const lineSegments=new THREE.LineSegments(edges,materialline1);return lineSegments.layers.set(layer),lineSegments}function getmesh(geom,material,layer=1,clone=!1){let m=new THREE.Mesh(geom,clone?material.clone():material);return m.castShadow=!0,m.receiveShadow=!0,m.layers.set(layer),m}function get3dshape(punti,material,layer){if(!punti||punti.length<3)return new THREE.BufferGeometry;const vertices=[];for(let i=0;i<punti.length;i++){const p1=punti[i],p2=punti[(i+1)%punti.length];vertices.push(p1.x,0,p1.y),vertices.push(p2.x,0,p2.y)}const geometry=new THREE.BufferGeometry;geometry.setAttribute("position",new THREE.Float32BufferAttribute(vertices,3));let m=new THREE.LineSegments(geometry,material);return m.layers.set(layer),m}function creategroup(name){let g=new THREE.Group;return g.name=name||"$$",g}function svuotanodo(n){!function _dispose(node){if(node.children.length){[...node.children].forEach((child=>{_dispose(child),node.remove(child)}))}node.geometry&&node.geometry.dispose(),node.material&&(Array.isArray(node.material)?node.material.forEach((m=>m.dispose())):node.material.dispose())}(n)}function deletegroup(grpbase,name){if(!grpbase?.children)return;let gr=grpbase.children.find((e=>e.name==name));if(gr){for(;gr.children.length>0;){const child=gr.children[0];gr.remove(child)}gr.parent&&gr.parent.remove(gr),gr=null}}function randombasemat(){const material=new THREE.LineBasicMaterial,color=new THREE.Color;return color.setHSL(Math.random(),.7,.4),material.color=color,material}
 /**
  * Crea una linea 3D
  * @param {Object} l - Oggetto contenente punti p1 e p2
  * @param {string} id - Identificatore
  * @param {THREE.Material} [mat=null] - Materiale da applicare
  * @returns {THREE.Line} Linea 3D
- */
-function getline(l, id, mat = null) {
-    const lineGeometry = new THREE.BufferGeometry().setFromPoints([
-        new THREE.Vector3(l.p1.x, 0, l.p1.y),
-        new THREE.Vector3(l.p2.x, 0, l.p2.y)
-    ]);
-    let tm = new THREE.Line(lineGeometry, mat || randombasemat());
-    return tm;
-}
-
+ */function getline(l,id,mat=null){const lineGeometry=(new THREE.BufferGeometry).setFromPoints([new THREE.Vector3(l.p1.x,0,l.p1.y),new THREE.Vector3(l.p2.x,0,l.p2.y)]);return new THREE.Line(lineGeometry,mat||randombasemat())}
 /**
  * Crea un punto 3D rappresentato da una sfera
  * @param {Object} p - Coordinate del punto
@@ -188,45 +13,7 @@ function getline(l, id, mat = null) {
  * @param {THREE.Material} [mat=null] - Materiale da applicare
  * @param {number} [size=5] - Dimensione della sfera
  * @returns {THREE.Mesh} Punto 3D
- */
-function getpoint(p, id, mat = null, size = 5) {
-    const pointgeom = new THREE.SphereGeometry(size, 8, 8);
-    let tm = new THREE.Mesh(pointgeom, mat || randombasemat());
-    tm.position.set(p.x, 0, p.y);
-    return tm;
-}
-
-
-function meshrotate(orientamento, mesh, x = 0, y = 0, z = 0) {
-    switch (orientamento.trim().toUpperCase()) {
-        case 'LPA':
-            mesh.rotation.y = Math.PI / 2;
-            mesh.rotation.x = Math.PI;
-            mesh.position.set(0, z, 0);
-            break;
-        case 'ALP':
-            mesh.rotation.x = Math.PI / 2;
-            mesh.position.set(0, x, 0);
-            break;
-        case 'APL':
-            mesh.rotation.x = -Math.PI / 2;
-            mesh.rotation.z = -Math.PI / 2;
-            break;
-        case 'PLA':
-            break;
-        case 'PAL':
-            mesh.rotation.z = Math.PI / 2;
-            mesh.position.set(z, 0, 0);
-            break;
-        case 'LAP':
-            mesh.rotation.y = Math.PI / 2;
-            mesh.rotation.z = Math.PI / 2;
-            break;
-    }
-    return mesh;
-}
-
-
+ */function getpoint(p,id,mat=null,size=5){const pointgeom=new THREE.SphereGeometry(size,8,8);let tm=new THREE.Mesh(pointgeom,mat||randombasemat());return tm.position.set(p.x,0,p.y),tm}
 /**
  * Aggiunge un pivot a un oggetto 3D esistente, mantenendone posizione e orientamento globale.
  * @param {THREE.Object3D} grp - Oggetto esistente già posizionato nella scena.
@@ -234,54 +21,7 @@ function meshrotate(orientamento, mesh, x = 0, y = 0, z = 0) {
  * @param {Object} movimento - Istanza della classe MovimentoBase o derivata.
  * @returns {THREE.Group} - Nuovo gruppo contenitore con pivot.
  */
-
-function addmovpivot(gcad, grp, movimento, op = {}, x = 0, y = 0, z = 0) {
-    movimento = clean(movimento, true);
-    if (!gcad.movs[movimento]) return grp;
-    gcad.movs[movimento];
-    const pivotLocal = new THREE.Vector3(x, y, z);
-    const isZeroPivot = pivotLocal.lengthSq() === 0;
-
-    const pivotGroup = new THREE.Group();        // gruppopivot
-    pivotGroup.name = `pivot_${movimento}`;
-
-    const movimentoGroup = new THREE.Group();    // gruppomovimento
-    movimentoGroup.name = `mov_${movimento}`;
-
-    // Gestione posizione
-    if (isZeroPivot) {
-        pivotGroup.position.copy(grp.position);
-        pivotGroup.quaternion.copy(grp.quaternion);
-        grp.position.set(0, 0, 0);
-        grp.rotation.set(0, 0, 0);
-    } else {
-        const pivotWorld = pivotLocal.clone().applyMatrix4(grp.matrixWorld);
-        pivotGroup.position.copy(pivotWorld);
-
-        const offset = pivotLocal.clone().negate();
-        grp.position.add(offset);
-
-        pivotGroup.quaternion.copy(grp.getWorldQuaternion(new THREE.Quaternion()));
-        grp.rotation.set(0, 0, 0);
-    }
-
-    // Costruisci gerarchia: pivot -> movimento -> oggetto
-    movimentoGroup.add(grp);
-    pivotGroup.add(movimentoGroup);
-
-    // Imposta userData del gruppo MOVIMENTO, non del pivot!
-    if (!op) op = {};
-    op.inmov = false;
-    op.key = movimento;
-    op.dt = 0;
-    op.dtstart = false;
-
-    movimentoGroup.userData.mov = { ...op };
-
-    return pivotGroup;
-}
-
-
+function addmovpivot(gcad,grp,movimento,op={},x=0,y=0,z=0){if(movimento=clean(movimento,!0),!gcad.movs[movimento])return grp;gcad.movs[movimento];const pivotLocal=new THREE.Vector3(x,y,z),isZeroPivot=0===pivotLocal.lengthSq(),pivotGroup=new THREE.Group;pivotGroup.name=`pivot_${movimento}`;const movimentoGroup=new THREE.Group;if(movimentoGroup.name=`mov_${movimento}`,isZeroPivot)pivotGroup.position.copy(grp.position),pivotGroup.quaternion.copy(grp.quaternion),grp.position.set(0,0,0),grp.rotation.set(0,0,0);else{const pivotWorld=pivotLocal.clone().applyMatrix4(grp.matrixWorld);pivotGroup.position.copy(pivotWorld);const offset=pivotLocal.clone().negate();grp.position.add(offset),pivotGroup.quaternion.copy(grp.getWorldQuaternion(new THREE.Quaternion)),grp.rotation.set(0,0,0)}return movimentoGroup.add(grp),pivotGroup.add(movimentoGroup),op||(op={}),op.inmov=!1,op.key=movimento,op.dt=0,op.dtstart=!1,movimentoGroup.userData.mov={...op},pivotGroup}
 /**
  * Crea un gestore di movimento per animare oggetti 3D.
  * @param {string} key - Chiave identificativa del movimento
@@ -305,148 +45,7 @@ function addmovpivot(gcad, grp, movimento, op = {}, x = 0, y = 0, z = 0) {
  *   @property {string} key - Chiave del movimento
  *   @property {function} step - Esegue un passo dell'animazione
  *   @property {function} reset - Resetta l'oggetto alla posizione iniziale
- */
-function getmovimento(key, gtimeline = []) {
-    let totale = 0;
-    let timeline = [];
-    const _calcolatotale = () => {
-        totale = timeline.reduce((t, e) => t + (e.time || 0), 0);
-    };
-
-    const _cleartimeline = () => {
-        timeline = [];
-        totale = 0;
-    };
-
-    const _add = (t, op = {}) => {
-        if (t) {
-            timeline.push({ ...op, time: t });
-        }
-        _calcolatotale();
-    };
-
-    _cleartimeline();
-    if (gtimeline && gtimeline.length) {
-        gtimeline.forEach(e => _add(e.time, e));
-    }
-
-    const _resetmov = (grp) => {
-        const { mov } = grp?.userData || {};
-        if (mov) {
-            mov.inmov = false;
-            grp.position.set(0, 0, 0);
-            grp.scale.set(1, 1, 1);
-            grp.rotation.set(0, 0, 0);
-        }
-    };
-
-    const _step = (grp, callback) => {
-        if (!grp || !grp.userData?.mov || !totale) return;
-        const { mov } = grp.userData;
-        if (!mov.inmov) return;
-        let dt = mov.dt - mov.dtstart;
-        if (mov.ripeti) {
-            dt = dt % totale;
-        } else if (dt > totale) {
-            _resetmov(grp);
-            return;
-        }
-
-        let x = 0, y = 0, z = 0;
-        let ax = 0, ay = 0, az = 0;
-        let sx = 1, sy = 1, sz = 1;
-        let t = null;
-
-        let accumTime = 0;
-
-        for (let step of timeline) {
-            accumTime += step.time;
-            if (dt < accumTime) {
-                const c = (step.time > 0) ? (dt - (accumTime - step.time)) / step.time : 1;
-                const _calc = (f, def = 0) => typeof f === 'function' ? f(mov) * c : (f || def) * c;
-
-                x += _calc(step.x);
-                y += _calc(step.y);
-                z += _calc(step.z);
-
-                sx *= 1 + _calc(step.sx ?? step.s, 0);
-                sy *= 1 + _calc(step.sy ?? step.s, 0);
-                sz *= 1 + _calc(step.sz ?? step.s, 0);
-
-                ax += _calc(step.ax) * PIF;
-                ay += _calc(step.ay) * PIF;
-                az += _calc(step.az) * PIF;
-
-                if (typeof step.t !== 'undefined') {
-                    t = typeof step.t === 'function' ? step.t(mov) * c : step.t * c;
-                }
-
-                break; // consider only the current step
-            } else {
-                // Accumula completamente il valore intero
-                const _calc = (f, def = 0) => typeof f === 'function' ? f(mov) : f || def;
-
-                x += _calc(step.x);
-                y += _calc(step.y);
-                z += _calc(step.z);
-
-                sx *= 1 + _calc(step.sx ?? step.s, 0);
-                sy *= 1 + _calc(step.sy ?? step.s, 0);
-                sz *= 1 + _calc(step.sz ?? step.s, 0);
-
-                ax += _calc(step.ax) * PIF;
-                ay += _calc(step.ay) * PIF;
-                az += _calc(step.az) * PIF;
-
-                if (typeof step.t !== 'undefined') {
-                    t = typeof step.t === 'function' ? step.t(mov) : step.t;
-                }
-            }
-        }
-
-        grp.position.set(x, y, z);
-        grp.scale.set(sx, sy, sz);
-        grp.rotation.set(ax, ay, az);
-
-        if (t !== null) {
-            // Applica la trasparenza se esistono materiali con `transparent: true`
-            grp.traverse(obj => {
-                if (obj.material) {
-                    const materials = Array.isArray(obj.material) ? obj.material : [obj.material];
-                    materials.forEach(mat => {
-                        if (mat.transparent) {
-                            mat.opacity = 1 - t;
-                        }
-                    });
-                }
-            });
-        }
-
-        if (callback) callback(grp, dt);
-    };
-
-    return {
-        get tline() { return totale },
-        clear: _cleartimeline,
-        add: _add,
-        key,
-        step: _step,
-        reset: _resetmov,
-    };
-}
-
-// Canvas globale per il rendering delle targhette
-let globalLabelCanvas = null;
-let globalLabelContext = null;
-function getGlobalCanvas() {
-    if (!globalLabelCanvas) {
-        globalLabelCanvas = document.createElement('canvas');
-        globalLabelContext = globalLabelCanvas.getContext('2d', { willReadFrequently: true });
-    }
-    return { canvas: globalLabelCanvas, context: globalLabelContext };
-}
-
-
+ */function getmovimento(key,gtimeline=[]){let totale=0,timeline=[];const _cleartimeline=()=>{timeline=[],totale=0},_add=(t,op={})=>{t&&timeline.push({...op,time:t}),totale=timeline.reduce(((t,e)=>t+(e.time||0)),0)};_cleartimeline(),gtimeline&&gtimeline.length&&gtimeline.forEach((e=>_add(e.time,e)));const _resetmov=grp=>{const{mov:mov}=grp?.userData||{};mov&&(mov.inmov=!1,grp.position.set(0,0,0),grp.scale.set(1,1,1),grp.rotation.set(0,0,0))};return{get tline(){return totale},clear:_cleartimeline,add:_add,key:key,step:(grp,callback)=>{if(!grp||!grp.userData?.mov||!totale)return;const{mov:mov}=grp.userData;if(!mov.inmov)return;let dt=mov.dt-mov.dtstart;if(mov.ripeti)dt%=totale;else if(dt>totale)return void _resetmov(grp);let x=0,y=0,z=0,ax=0,ay=0,az=0,sx=1,sy=1,sz=1,t=null,accumTime=0;for(let step of timeline){if(accumTime+=step.time,dt<accumTime){const c=step.time>0?(dt-(accumTime-step.time))/step.time:1,_calc=(f,def=0)=>"function"==typeof f?f(mov)*c:(f||def)*c;x+=_calc(step.x),y+=_calc(step.y),z+=_calc(step.z),sx*=1+_calc(step.sx??step.s,0),sy*=1+_calc(step.sy??step.s,0),sz*=1+_calc(step.sz??step.s,0),ax+=_calc(step.ax)*PIF,ay+=_calc(step.ay)*PIF,az+=_calc(step.az)*PIF,void 0!==step.t&&(t="function"==typeof step.t?step.t(mov)*c:step.t*c);break}{const _calc=(f,def=0)=>"function"==typeof f?f(mov):f||def;x+=_calc(step.x),y+=_calc(step.y),z+=_calc(step.z),sx*=1+_calc(step.sx??step.s,0),sy*=1+_calc(step.sy??step.s,0),sz*=1+_calc(step.sz??step.s,0),ax+=_calc(step.ax)*PIF,ay+=_calc(step.ay)*PIF,az+=_calc(step.az)*PIF,void 0!==step.t&&(t="function"==typeof step.t?step.t(mov):step.t)}}grp.position.set(x,y,z),grp.scale.set(sx,sy,sz),grp.rotation.set(ax,ay,az),null!==t&&grp.traverse((obj=>{if(obj.material){(Array.isArray(obj.material)?obj.material:[obj.material]).forEach((mat=>{mat.transparent&&(mat.opacity=1-t)}))}})),callback&&callback(grp,dt)},reset:_resetmov}}let globalLabelCanvas=null,globalLabelContext=null;
 /**
  * Crea un punto di riferimento invisibile nell'albero 3D
  * @param {number} x - Coordinata X
@@ -456,216 +55,14 @@ function getGlobalCanvas() {
  * @param {string} [id=null] - Identificatore opzionale
  * @returns {THREE.Object3D} Oggetto di riferimento invisibile
  */
-function getriferimento(dati, x = 0, y = 0, z = 0, id = 'rif') {
-    if (typeof dati == 'string') dati = { testo: dati };
-    let riferimento = new THREE.Object3D();
-    riferimento.position.set(x, y, z);
-
-    // Imposta il nome se fornito
-    if (id) riferimento.name = id;
-    riferimento.userData = { tipo: 'rif', ...dati };
-    return riferimento;
-}
-
-
+function getriferimento(dati,x=0,y=0,z=0,id="rif"){"string"==typeof dati&&(dati={testo:dati});let riferimento=new THREE.Object3D;return riferimento.position.set(x,y,z),id&&(riferimento.name=id),riferimento.userData={tipo:"rif",...dati},riferimento}
 /**
  * Crea una targhetta rettangolare con testo
  * @param {Array|string} testo - Array di oggetti {testo, size, colore} o stringa
  * @param {number} dim - Larghezza/altezza della targhetta
  * @param {Object} options - Opzioni aggiuntive
  * @returns {THREE.Mesh} Mesh con la targhetta
- */
-function gettarghetta(gcad, testo, dim = 100, options = {}) {
-    // Converti stringa in array di oggetti testo
-    const {
-        noSfondo = false,
-        forcey = false,
-        coloreSfondo = 'white',
-        coloreBordo = 'darkgray',
-        spessoreBordo = 3,
-        padding = 8,
-        layer = 21,
-        fontFamily = 'Arial',
-        raggioAngoli = 20,   // Raggio degli angoli arrotondati
-    } = options;
-    let tt = hash(`T:${coloreSfondo}|${coloreBordo}|${padding}|${spessoreBordo}|${raggioAngoli}|${noSfondo}|${testo}`);
-
-
-
-    testo = testo.split('\n').map(e => {
-        let size = 12, color = 'black';
-        e = e.trim();
-        let rr = /^\s*\#(\w)(\d*)\,(.*)$/.exec(e);
-        if (rr) {
-            size = parseInt(rr[2] || 12);
-            e = rr[3];
-            switch (rr[1].toLowerCase()) {
-                case 'r': color = 'red'; break;
-                case 'g': color = 'green'; break;
-                case 'b': color = 'blue'; break;
-                case 'c': color = 'cyan'; break;
-            }
-        }
-        return { testo: e, size, color }
-    }).filter(e => e.testo);
-
-
-
-    // Ottieni il canvas globale
-    const { canvas, context } = getGlobalCanvas();
-
-    // Calcola le dimensioni necessarie per il testo
-    let maxWidth = 0;
-    let totalHeight = padding * 2; // Inizia con il padding superiore e inferiore
-    const scale = 2;
-    testo.forEach((riga, i) => {
-        const { testo: testoRiga, size = 12 } = riga;
-        const fontSize = size * scale;
-        context.font = `${fontSize}px ${fontFamily}`;
-
-        const metrics = context.measureText(testoRiga);
-        const textWidth = metrics.width;
-        const textHeight = fontSize * (i == testo.length - 1 ? 1 : 1.2); // Approssimazione dell'altezza del testo
-        maxWidth = Math.max(maxWidth, textWidth);
-        totalHeight += textHeight;
-    });
-
-    // Aggiungi padding laterale alla larghezza
-    maxWidth += padding * 2;
-
-    // Calcola il rapporto di aspetto del testo
-    const aspectRatio = totalHeight / maxWidth || 1;
-
-    // Calcola dimx e dimy in base all'opzione forcey
-    let dimx, dimy;
-    if (forcey) {
-        dimy = dim;
-        dimx = Math.ceil(dimy / aspectRatio);
-    } else {
-        dimx = dim;
-        dimy = Math.ceil(dimx * aspectRatio);
-    }
-    if (!gcad.textures[tt]) {
-
-        // Ridimensiona il canvas per adattarlo alle dimensioni specificate
-        // Aggiungi spazio extra per il bordo
-        const canvasWidth = maxWidth + spessoreBordo * 2;
-        const canvasHeight = totalHeight + spessoreBordo * 2;
-
-        // Ridimensiona il canvas globale se necessario
-        if (canvas.width < canvasWidth || canvas.height < canvasHeight) {
-            canvas.width = Math.max(canvas.width, canvasWidth);
-            canvas.height = Math.max(canvas.height, canvasHeight);
-        }
-
-        // Pulisci l'area del canvas che useremo
-        context.clearRect(0, 0, canvasWidth, canvasHeight);
-
-        // Converti il colore di sfondo da esadecimale a RGB
-        const bgColor = new THREE.Color(coloreSfondo);
-        const bgColorStyle = `rgb(${Math.floor(bgColor.r * 255)}, ${Math.floor(bgColor.g * 255)}, ${Math.floor(bgColor.b * 255)})`;
-
-        // Converti il colore del bordo da esadecimale a RGB
-        const borderColor = new THREE.Color(coloreBordo);
-        const borderColorStyle = `rgb(${Math.floor(borderColor.r * 255)}, ${Math.floor(borderColor.g * 255)}, ${Math.floor(borderColor.b * 255)})`;
-
-        // Calcola il raggio degli angoli
-        const radius = raggioAngoli;
-
-        // Disegna prima il bordo (rettangolo più grande)
-        context.beginPath();
-        if (!noSfondo) {
-            drawRoundedRect(context, 0, 0, canvasWidth, canvasHeight, radius + spessoreBordo / 2);
-            context.fillStyle = borderColorStyle;
-            context.fill();
-
-            // Poi disegna lo sfondo (rettangolo più piccolo)
-            context.beginPath();
-            drawRoundedRect(context, spessoreBordo, spessoreBordo,
-                canvasWidth - spessoreBordo * 2,
-                canvasHeight - spessoreBordo * 2,
-                radius - spessoreBordo / 2);
-            context.fillStyle = bgColorStyle;
-            context.fill();
-        }
-        // Disegna ogni riga di testo
-        let yPosition = padding + spessoreBordo;
-
-        // Disegna ogni riga di testo
-        testo.forEach((riga) => {
-            const { testo: testoRiga, size = 12, color = 'black' } = riga;
-
-            // Imposta lo stile del testo
-            const fontSize = size * scale;
-            context.font = `${fontSize}px ${fontFamily}`;
-            context.fillStyle = color;
-            context.textAlign = 'center';
-            context.textBaseline = 'top';
-
-            // Disegna il testo
-            context.fillText(testoRiga, canvasWidth / 2, yPosition);
-            yPosition += fontSize * 1.2; // Spazio tra le righe
-        });
-
-        // Ottieni i dati dell'immagine direttamente dal canvas globale
-        const imageData = context.getImageData(0, 0, canvasWidth, canvasHeight);
-
-        // Crea una texture direttamente dai dati dell'immagine
-        const texture = new THREE.DataTexture(
-            imageData.data,
-            imageData.width,
-            imageData.height,
-            THREE.RGBAFormat
-        );
-
-        // Imposta le proprietà della texture
-        texture.needsUpdate = true;
-        texture.flipY = true;
-        texture.minFilter = THREE.LinearFilter;
-        texture.magFilter = THREE.LinearFilter;
-
-        // Imposta l'area del canvas da utilizzare come texture
-        // Memorizza la texture nella cache
-        gcad.textures[tt] = texture;
-    }
-
-
-
-    // Crea un materiale con la texture
-    const materialeTesto = new THREE.MeshBasicMaterial({
-        map: gcad.textures[tt],
-        transparent: true,
-        side: SIDE
-    });
-
-    // Crea un piano per il testo con le dimensioni specificate
-    const geometriaTesto = new THREE.PlaneGeometry(dimx, dimy);
-    const meshTesto = new THREE.Mesh(geometriaTesto, materialeTesto);
-    meshTesto.layers.set(layer);
-    meshTesto.userData = {
-        dimx, dimy
-    };
-
-    return meshTesto;
-}
-
-// Funzione helper per disegnare un rettangolo con angoli arrotondati
-function drawRoundedRect(ctx, x, y, width, height, radius) {
-    // Assicurati che il raggio non sia troppo grande
-    radius = Math.min(radius, Math.min(width / 2, height / 2));
-
-    ctx.moveTo(x + radius, y);
-    ctx.lineTo(x + width - radius, y);
-    ctx.quadraticCurveTo(x + width, y, x + width, y + radius);
-    ctx.lineTo(x + width, y + height - radius);
-    ctx.quadraticCurveTo(x + width, y + height, x + width - radius, y + height);
-    ctx.lineTo(x + radius, y + height);
-    ctx.quadraticCurveTo(x, y + height, x, y + height - radius);
-    ctx.lineTo(x, y + radius);
-    ctx.quadraticCurveTo(x, y, x + radius, y);
-    ctx.closePath();
-}
-
+ */function gettarghetta(gcad,testo,dim=100,options={}){const{noSfondo:noSfondo=!1,forcey:forcey=!1,coloreSfondo:coloreSfondo="white",coloreBordo:coloreBordo="darkgray",spessoreBordo:spessoreBordo=3,padding:padding=8,layer:layer=21,fontFamily:fontFamily="Arial",raggioAngoli:raggioAngoli=20}=options;let tt=hash(`T:${coloreSfondo}|${coloreBordo}|${padding}|${spessoreBordo}|${raggioAngoli}|${noSfondo}|${testo}`);testo=testo.split("\n").map((e=>{let size=12,color="black";e=e.trim();let rr=/^\s*\#(\w)(\d*)\,(.*)$/.exec(e);if(rr)switch(size=parseInt(rr[2]||12),e=rr[3],rr[1].toLowerCase()){case"r":color="red";break;case"g":color="green";break;case"b":color="blue";break;case"c":color="cyan"}return{testo:e,size:size,color:color}})).filter((e=>e.testo));const{canvas:canvas,context:context}=function getGlobalCanvas(){return globalLabelCanvas||(globalLabelCanvas=document.createElement("canvas"),globalLabelContext=globalLabelCanvas.getContext("2d",{willReadFrequently:!0})),{canvas:globalLabelCanvas,context:globalLabelContext}}();let maxWidth=0,totalHeight=2*padding;testo.forEach(((riga,i)=>{const{testo:testoRiga,size:size=12}=riga,fontSize=2*size;context.font=`${fontSize}px ${fontFamily}`;const textWidth=context.measureText(testoRiga).width,textHeight=fontSize*(i==testo.length-1?1:1.2);maxWidth=Math.max(maxWidth,textWidth),totalHeight+=textHeight})),maxWidth+=2*padding;const aspectRatio=totalHeight/maxWidth||1;let dimx,dimy;if(forcey?(dimy=dim,dimx=Math.ceil(dimy/aspectRatio)):(dimx=dim,dimy=Math.ceil(dimx*aspectRatio)),!gcad.textures[tt]){const canvasWidth=maxWidth+2*spessoreBordo,canvasHeight=totalHeight+2*spessoreBordo;(canvas.width<canvasWidth||canvas.height<canvasHeight)&&(canvas.width=Math.max(canvas.width,canvasWidth),canvas.height=Math.max(canvas.height,canvasHeight)),context.clearRect(0,0,canvasWidth,canvasHeight);const bgColor=new THREE.Color(coloreSfondo),bgColorStyle=`rgb(${Math.floor(255*bgColor.r)}, ${Math.floor(255*bgColor.g)}, ${Math.floor(255*bgColor.b)})`,borderColor=new THREE.Color(coloreBordo),borderColorStyle=`rgb(${Math.floor(255*borderColor.r)}, ${Math.floor(255*borderColor.g)}, ${Math.floor(255*borderColor.b)})`,radius=raggioAngoli;context.beginPath(),noSfondo||(drawRoundedRect(context,0,0,canvasWidth,canvasHeight,radius+spessoreBordo/2),context.fillStyle=borderColorStyle,context.fill(),context.beginPath(),drawRoundedRect(context,spessoreBordo,spessoreBordo,canvasWidth-2*spessoreBordo,canvasHeight-2*spessoreBordo,radius-spessoreBordo/2),context.fillStyle=bgColorStyle,context.fill());let yPosition=padding+spessoreBordo;testo.forEach((riga=>{const{testo:testoRiga,size:size=12,color:color="black"}=riga,fontSize=2*size;context.font=`${fontSize}px ${fontFamily}`,context.fillStyle=color,context.textAlign="center",context.textBaseline="top",context.fillText(testoRiga,canvasWidth/2,yPosition),yPosition+=1.2*fontSize}));const imageData=context.getImageData(0,0,canvasWidth,canvasHeight),texture=new THREE.DataTexture(imageData.data,imageData.width,imageData.height,THREE.RGBAFormat);texture.needsUpdate=!0,texture.flipY=!0,texture.minFilter=THREE.LinearFilter,texture.magFilter=THREE.LinearFilter,gcad.textures[tt]=texture}const materialeTesto=new THREE.MeshBasicMaterial({map:gcad.textures[tt],transparent:!0,side:SIDE}),geometriaTesto=new THREE.PlaneGeometry(dimx,dimy),meshTesto=new THREE.Mesh(geometriaTesto,materialeTesto);return meshTesto.layers.set(layer),meshTesto.userData={dimx:dimx,dimy:dimy},meshTesto}function drawRoundedRect(ctx,x,y,width,height,radius){radius=Math.min(radius,Math.min(width/2,height/2)),ctx.moveTo(x+radius,y),ctx.lineTo(x+width-radius,y),ctx.quadraticCurveTo(x+width,y,x+width,y+radius),ctx.lineTo(x+width,y+height-radius),ctx.quadraticCurveTo(x+width,y+height,x+width-radius,y+height),ctx.lineTo(x+radius,y+height),ctx.quadraticCurveTo(x,y+height,x,y+height-radius),ctx.lineTo(x,y+radius),ctx.quadraticCurveTo(x,y,x+radius,y),ctx.closePath()}
 /**
  * Crea una quota tra due punti in 3D sul piano XY
  * @param {string} testo - Testo da visualizzare nella quota
@@ -676,178 +73,7 @@ function drawRoundedRect(ctx, x, y, width, height, radius) {
  * @param {number} sizetesto - Dimensione del testo
  * @param {Object} options - Opzioni aggiuntive
  * @returns {THREE.Group} Gruppo contenente la quota
- */
-function getquota(gcad, testo, x1, y1, x2, y2, altezza = 30, offset = 0, options = {}) {
-    // Opzioni di default
-    const {
-        piano = 'xy',
-        layer = 22,
-        delta = 5,         // Margine per decidere se la targhetta è troppo grande
-        spessoreLinea = 3, // Spessore della linea (diametro del cilindro)
-    } = options;
-    // pp point on plane. usare questa funzione per convertire i punti 2D rispetto al piano scelto
-    const pp = (x, y) => {
-        if (piano === 'xz') return [x, 0, y];
-        if (piano === 'yz') return [0, x, y]; // Corretto: x diventa y, y diventa z
-        return [x, y, 0]; // Default: piano xy
-    };
-
-    // Creo un gruppo per contenere tutti gli elementi della quota
-    const quotaGroup = new THREE.Group();
-    quotaGroup.name = 'quota';
-
-    // Calcolo la distanza tra i due punti
-    const dx = x2 - x1;
-    const dy = y2 - y1;
-    const distanza = Math.sqrt(dx * dx + dy * dy);
-
-    // Calcolo l'angolo di rotazione
-    const angolo = Math.atan2(dy, dx);
-
-    // Calcolo l'offset perpendicolare alla linea
-    const offsetX = -Math.sin(angolo) * offset;
-    const offsetY = Math.cos(angolo) * offset;
-    // Creo il testo della quota
-    const targhetta = gettarghetta(gcad,
-        testo || `${distanza.toFixed(1)}`, altezza * 2,
-        {
-            noSfondo: true,
-            layer,
-            forcey: true
-        }
-    );
-    const { dimx, dimy } = targhetta.userData;
-
-    // Determino se la targhetta è più grande della distanza disponibile
-    const targhettaTroppoGrande = dimx > (distanza - delta);
-
-    // Funzione per creare un cilindro tra due punti
-    function getCilindro(puntoInizio, puntoFine, spessore) {
-        const direzione = new THREE.Vector3().subVectors(puntoFine, puntoInizio);
-        const lunghezza = direzione.length();
-
-        // Creo la geometria del cilindro senza top e bottom
-        let ky = hash(`c:${spessore}|${lunghezza}`);
-        let geometria;
-        if (!gcad.geo[ky]) {
-            geometria = new THREE.CylinderGeometry(
-                spessore / 2, // raggio superiore
-                spessore / 2, // raggio inferiore
-                lunghezza,    // altezza
-                3, // numero di segmenti
-                1,            // segmenti di altezza
-                true          // openEnded = true per rimuovere top e bottom
-            );
-            gcad.geo[ky] = geometria;
-        } else {
-            geometria = gcad.geo[ky];
-        }
-
-        // Creo la mesh
-        const cilindro = new THREE.Mesh(geometria, mblack);
-
-        // Posiziono il cilindro
-        cilindro.position.copy(puntoInizio).add(direzione.multiplyScalar(0.5));
-
-        // Calcolo la rotazione per allineare il cilindro con la direzione
-        const punto = new THREE.Vector3().copy(puntoFine);
-        cilindro.lookAt(punto);
-
-        // Ruoto di 90 gradi per allineare correttamente il cilindro
-        cilindro.rotateX(Math.PI / 2);
-
-        return cilindro;
-    }
-
-    // Gestisco il posizionamento della targhetta e delle linee
-    if (targhettaTroppoGrande) {
-        // Posiziono la targhetta sopra la linea
-        targhetta.position.set(distanza / 2, altezza, 0);
-
-        // Creo una singola linea orizzontale come cilindro
-        const puntoInizio = new THREE.Vector3(...pp(0, 0));
-        const puntoFine = new THREE.Vector3(...pp(distanza, 0));
-        const lineaOrizzontale = getCilindro(puntoInizio, puntoFine, spessoreLinea);
-        quotaGroup.add(lineaOrizzontale);
-    } else {
-        // Calcolo lo spazio necessario per la targhetta
-        const spazioTarghetta = dimx + delta;
-        const inizioTarghetta = (distanza - spazioTarghetta) / 2;
-        const fineTarghetta = inizioTarghetta + spazioTarghetta;
-
-        // Creo due linee orizzontali separate come cilindri
-        const puntoInizio1 = new THREE.Vector3(...pp(0, 0));
-        const puntoFine1 = new THREE.Vector3(...pp(inizioTarghetta, 0));
-        const lineaOrizzontale1 = getCilindro(puntoInizio1, puntoFine1, spessoreLinea);
-        quotaGroup.add(lineaOrizzontale1);
-
-        const puntoInizio2 = new THREE.Vector3(...pp(fineTarghetta, 0));
-        const puntoFine2 = new THREE.Vector3(...pp(distanza, 0));
-        const lineaOrizzontale2 = getCilindro(puntoInizio2, puntoFine2, spessoreLinea);
-        quotaGroup.add(lineaOrizzontale2);
-
-        // Posiziono la targhetta al centro
-        targhetta.position.set(...pp(distanza / 2, 0));
-    }
-
-    // Creo le linee verticali alle estremità come cilindri
-    // Calcolo l'altezza delle linee verticali in base all'offset
-    const h1 = offset > altezza / 2 ? -offset : -altezza / 2;
-    const h2 = -offset > altezza / 2 ? -offset : altezza / 2;
-
-    // Creo le linee verticali - semplificato per tutti i piani usando pp
-    const puntoInizioV1 = new THREE.Vector3(...pp(0, h1));
-    const puntoFineV1 = new THREE.Vector3(...pp(0, h2));
-    const puntoInizioV2 = new THREE.Vector3(...pp(distanza, h1));
-    const puntoFineV2 = new THREE.Vector3(...pp(distanza, h2));
-
-    const lineaVerticale1 = getCilindro(puntoInizioV1, puntoFineV1, spessoreLinea);
-    quotaGroup.add(lineaVerticale1);
-
-    const lineaVerticale2 = getCilindro(puntoInizioV2, puntoFineV2, spessoreLinea);
-    quotaGroup.add(lineaVerticale2);
-
-    // Creo una funzione di aggiornamento per far sì che la targhetta sia sempre rivolta verso la camera
-    targhetta.userData.updateOrientation = function (camera) {
-        if (camera) {
-            this.quaternion.copy(camera.quaternion);
-        }
-    };
-
-    // Aggiungo la targhetta al gruppo
-    quotaGroup.add(targhetta);
-
-    // Posiziono e ruoto il gruppo in base al piano scelto
-    if (piano === 'xy') {
-        quotaGroup.position.set(x1 + offsetX, y1 + offsetY, 0);
-        quotaGroup.rotation.z = angolo;
-    } else if (piano === 'xz') {
-        quotaGroup.position.set(x1 + offsetX, 0, y1 + offsetY);
-        quotaGroup.rotation.y = -angolo; // Rotazione attorno all'asse Y per il piano XZ
-    } else if (piano === 'yz') {
-        quotaGroup.position.set(0, x1 + offsetX, y1 + offsetY);
-        quotaGroup.rotation.x = angolo; // Rotazione attorno all'asse X per il piano YZ
-    }
-
-
-    quotaGroup.traverse(function (object) {
-        object.layers.set(layer);
-    });
-
-    return quotaGroup;
-}
-
-function cylgeometry(gcad, h, r, rtop, segments = 16) {
-    if (!r || !h) return null;
-    let ky = hash(`cy${h}|${r}|${rtop || r}|${segments}`);
-    if (!gcad.geo[ky]) {
-        const geometry = new THREE.CylinderGeometry(rtop || r, r, h, segments);
-        gcad.geo[ky] = geometry;
-    }
-    return gcad.geo[ky];
-}
-
-
+ */function getquota(gcad,testo,x1,y1,x2,y2,altezza=30,offset=0,options={}){const{piano:piano="xy",layer:layer=22,delta:delta=5,spessoreLinea:spessoreLinea=3}=options,pp=(x,y)=>"xz"===piano?[x,0,y]:"yz"===piano?[0,x,y]:[x,y,0],quotaGroup=new THREE.Group;quotaGroup.name="quota";const dx=x2-x1,dy=y2-y1,distanza=Math.sqrt(dx*dx+dy*dy),angolo=Math.atan2(dy,dx),offsetX=-Math.sin(angolo)*offset,offsetY=Math.cos(angolo)*offset,targhetta=gettarghetta(gcad,testo||`${distanza.toFixed(1)}`,2*altezza,{noSfondo:!0,layer:layer,forcey:!0}),{dimx:dimx,dimy:dimy}=targhetta.userData;function getCilindro(puntoInizio,puntoFine,spessore){const direzione=(new THREE.Vector3).subVectors(puntoFine,puntoInizio),lunghezza=direzione.length();let geometria,ky=hash(`c:${spessore}|${lunghezza}`);gcad.geo[ky]?geometria=gcad.geo[ky]:(geometria=new THREE.CylinderGeometry(spessore/2,spessore/2,lunghezza,3,1,!0),gcad.geo[ky]=geometria);const cilindro=new THREE.Mesh(geometria,mblack);cilindro.position.copy(puntoInizio).add(direzione.multiplyScalar(.5));const punto=(new THREE.Vector3).copy(puntoFine);return cilindro.lookAt(punto),cilindro.rotateX(Math.PI/2),cilindro}if(dimx>distanza-delta){targhetta.position.set(distanza/2,altezza,0);const lineaOrizzontale=getCilindro(new THREE.Vector3(...pp(0,0)),new THREE.Vector3(...pp(distanza,0)),spessoreLinea);quotaGroup.add(lineaOrizzontale)}else{const spazioTarghetta=dimx+delta,inizioTarghetta=(distanza-spazioTarghetta)/2,fineTarghetta=inizioTarghetta+spazioTarghetta,lineaOrizzontale1=getCilindro(new THREE.Vector3(...pp(0,0)),new THREE.Vector3(...pp(inizioTarghetta,0)),spessoreLinea);quotaGroup.add(lineaOrizzontale1);const lineaOrizzontale2=getCilindro(new THREE.Vector3(...pp(fineTarghetta,0)),new THREE.Vector3(...pp(distanza,0)),spessoreLinea);quotaGroup.add(lineaOrizzontale2),targhetta.position.set(...pp(distanza/2,0))}const h1=offset>altezza/2?-offset:-altezza/2,h2=-offset>altezza/2?-offset:altezza/2,puntoInizioV1=new THREE.Vector3(...pp(0,h1)),puntoFineV1=new THREE.Vector3(...pp(0,h2)),puntoInizioV2=new THREE.Vector3(...pp(distanza,h1)),puntoFineV2=new THREE.Vector3(...pp(distanza,h2)),lineaVerticale1=getCilindro(puntoInizioV1,puntoFineV1,spessoreLinea);quotaGroup.add(lineaVerticale1);const lineaVerticale2=getCilindro(puntoInizioV2,puntoFineV2,spessoreLinea);return quotaGroup.add(lineaVerticale2),targhetta.userData.updateOrientation=function(camera){camera&&this.quaternion.copy(camera.quaternion)},quotaGroup.add(targhetta),"xy"===piano?(quotaGroup.position.set(x1+offsetX,y1+offsetY,0),quotaGroup.rotation.z=angolo):"xz"===piano?(quotaGroup.position.set(x1+offsetX,0,y1+offsetY),quotaGroup.rotation.y=-angolo):"yz"===piano&&(quotaGroup.position.set(0,x1+offsetX,y1+offsetY),quotaGroup.rotation.x=angolo),quotaGroup.traverse((function(object){object.layers.set(layer)})),quotaGroup}
 /**
  * Crea un cilindro 3D con orientamento personalizzabile
  * @param {string} ori - Orientamento (X/L, Y/A, Z/P)
@@ -858,44 +84,7 @@ function cylgeometry(gcad, h, r, rtop, segments = 16) {
  * @param {Object} options - Opzioni di configurazione
  * @returns {Promise<THREE.Group>} Gruppo contenente il cilindro
  */
-async function getcilindro(gcad, ori, h, r1, r2, mats = mwhite$1, options) {
-    if (!options) options = {};
-    if (!Array.isArray(mats)) mats = [mats];
-
-    const cyl = cylgeometry(gcad, h, r1, r2, options.sides || 16);
-
-    let grp = new THREE.Group();
-
-    // Gestione orientamento
-    switch ((ori || '').trim().toUpperCase()) {
-        case 'X':
-        case 'L':
-            grp.position.set(h / 2, 0, 0);
-            grp.rotation.z = Math.PI / 2;
-            break;
-        case 'Z':
-        case 'P':
-            grp.position.set(0, 0, h / 2);
-            grp.rotation.x = Math.PI / 2;
-            break;
-        default:
-            grp.position.set(0, h / 2, 0);
-    }
-
-    if (cyl) {
-        if (!options.nolines) {
-            let segments = edgesfromgeometry(cyl);
-            grp.add(segments);
-        }
-
-        const matTop = mats[0] || mwhite$1;
-        const matBottom = mats[1] || matTop;
-        const matSides = mats[2] || matTop;
-        grp.add(getmesh(cyl, [matTop, matBottom, matSides]));
-    }
-    return grp;
-}
-
+async function getcilindro(gcad,ori,h,r1,r2,mats=mwhite$1,options){options||(options={}),Array.isArray(mats)||(mats=[mats]);const cyl=function cylgeometry(gcad,h,r,rtop,segments=16){if(!r||!h)return null;let ky=hash(`cy${h}|${r}|${rtop||r}|${segments}`);if(!gcad.geo[ky]){const geometry=new THREE.CylinderGeometry(rtop||r,r,h,segments);gcad.geo[ky]=geometry}return gcad.geo[ky]}(gcad,h,r1,r2,options.sides||16);let grp=new THREE.Group;switch((ori||"").trim().toUpperCase()){case"X":case"L":grp.position.set(h/2,0,0),grp.rotation.z=Math.PI/2;break;case"Z":case"P":grp.position.set(0,0,h/2),grp.rotation.x=Math.PI/2;break;default:grp.position.set(0,h/2,0)}if(cyl){if(!options.nolines){let segments=edgesfromgeometry(cyl);grp.add(segments)}const matTop=mats[0]||mwhite$1,matBottom=mats[1]||matTop,matSides=mats[2]||matTop;grp.add(getmesh(cyl,[matTop,matBottom,matSides]))}return grp}
 /**
  * Crea un box 3D con linee di bordo opzionali
  * @param {number} x - Larghezza
@@ -904,663 +93,12 @@ async function getcilindro(gcad, ori, h, r1, r2, mats = mwhite$1, options) {
  * @param {THREE.Material} mat - Materiale da applicare
  * @param {Object} options - Opzioni di configurazione
  * @returns {Promise<THREE.Group>} Gruppo contenente il box
- */
-
-
-function boxgeometry(gcad, x, y, z) {
-    let ky = hash(`b:${x}|${y}|${x}`);
-    if (!gcad.geo[ky]) {
-        const bx = new THREE.BoxGeometry(x, y, z);
-        gcad.geo[ky] = bx;
-    }
-    return gcad.geo[ky];
-}
-
-function getface(gcad, x, y, mat, scaled = false) {  // rimosso async
-    let ky = hash(`f:${x}|${y}|${scaled ? 1 : 0}`);
-    if (!gcad.geo[ky]) {
-        const geometry = new THREE.PlaneGeometry(x, y);
-        const uvs = geometry.attributes.uv;
-        const positions = geometry.attributes.position;
-        for (let i = 0; i < positions.count; i++) {
-            uvs.setXY(i,
-                scaled ? positions.getX(i) : positions.getX(i) / (x * scaleunit),
-                scaled ? positions.getY(i) : positions.getY(i) / (y * scaleunit)
-            );
-        }
-        gcad.geo[ky] = geometry;
-    }
-    const plane = new THREE.Mesh(gcad.geo[ky], mat);
-    plane.position.set(x / 2, y / 2, 0);
-    if (mat?.transparent) {
-        plane.layers.set(2);
-    }
-    return plane;
-}
-
-async function getbox(gcad, x, y, z, mat, options) {
-    if (!options) options = {};
-    let grp = new THREE.Group();
-    const box = boxgeometry(gcad, x, y, z);
-    grp.position.set(x / 2, y / 2, z / 2);
-    if (!options.nolines) {
-        let segments = edgesfromgeometry(box);
-        grp.add(segments);
-    }
-    grp.add(getmesh(box, mat || mwhite$1));
-    return grp;
-}
-
+ */function getface(gcad,x,y,mat,scaled=!1){let ky=hash(`f:${x}|${y}|${scaled?1:0}`);if(!gcad.geo[ky]){const geometry=new THREE.PlaneGeometry(x,y),uvs=geometry.attributes.uv,positions=geometry.attributes.position;for(let i=0;i<positions.count;i++)uvs.setXY(i,scaled?positions.getX(i):positions.getX(i)/(.001*x),scaled?positions.getY(i):positions.getY(i)/(.001*y));gcad.geo[ky]=geometry}const plane=new THREE.Mesh(gcad.geo[ky],mat);return plane.position.set(x/2,y/2,0),mat?.transparent&&plane.layers.set(2),plane}async function getbox(gcad,x,y,z,mat,options){options||(options={});let grp=new THREE.Group;const box=function boxgeometry(gcad,x,y,z){let ky=hash(`b:${x}|${y}|${x}`);if(!gcad.geo[ky]){const bx=new THREE.BoxGeometry(x,y,z);gcad.geo[ky]=bx}return gcad.geo[ky]}(gcad,x,y,z);if(grp.position.set(x/2,y/2,z/2),!options.nolines){let segments=edgesfromgeometry(box);grp.add(segments)}return grp.add(getmesh(box,mat||mwhite$1)),grp}
 /**
  * @param {BufferGeometry} geometry
  * @param {number} tolerance
  * @return {BufferGeometry}
- */
-function mergeVertices( geometry, tolerance = 1e-4 ) {
-
-	tolerance = Math.max( tolerance, Number.EPSILON );
-
-	// Generate an index buffer if the geometry doesn't have one, or optimize it
-	// if it's already available.
-	const hashToIndex = {};
-	const indices = geometry.getIndex();
-	const positions = geometry.getAttribute( 'position' );
-	const vertexCount = indices ? indices.count : positions.count;
-
-	// next value for triangle indices
-	let nextIndex = 0;
-
-	// attributes and new attribute arrays
-	const attributeNames = Object.keys( geometry.attributes );
-	const tmpAttributes = {};
-	const tmpMorphAttributes = {};
-	const newIndices = [];
-	const getters = [ 'getX', 'getY', 'getZ', 'getW' ];
-	const setters = [ 'setX', 'setY', 'setZ', 'setW' ];
-
-	// Initialize the arrays, allocating space conservatively. Extra
-	// space will be trimmed in the last step.
-	for ( let i = 0, l = attributeNames.length; i < l; i ++ ) {
-
-		const name = attributeNames[ i ];
-		const attr = geometry.attributes[ name ];
-
-		tmpAttributes[ name ] = new attr.constructor(
-			new attr.array.constructor( attr.count * attr.itemSize ),
-			attr.itemSize,
-			attr.normalized
-		);
-
-		const morphAttributes = geometry.morphAttributes[ name ];
-		if ( morphAttributes ) {
-
-			if ( ! tmpMorphAttributes[ name ] ) tmpMorphAttributes[ name ] = [];
-			morphAttributes.forEach( ( morphAttr, i ) => {
-
-				const array = new morphAttr.array.constructor( morphAttr.count * morphAttr.itemSize );
-				tmpMorphAttributes[ name ][ i ] = new morphAttr.constructor( array, morphAttr.itemSize, morphAttr.normalized );
-
-			} );
-
-		}
-
-	}
-
-	// convert the error tolerance to an amount of decimal places to truncate to
-	const halfTolerance = tolerance * 0.5;
-	const exponent = Math.log10( 1 / tolerance );
-	const hashMultiplier = Math.pow( 10, exponent );
-	const hashAdditive = halfTolerance * hashMultiplier;
-	for ( let i = 0; i < vertexCount; i ++ ) {
-
-		const index = indices ? indices.getX( i ) : i;
-
-		// Generate a hash for the vertex attributes at the current index 'i'
-		let hash = '';
-		for ( let j = 0, l = attributeNames.length; j < l; j ++ ) {
-
-			const name = attributeNames[ j ];
-			const attribute = geometry.getAttribute( name );
-			const itemSize = attribute.itemSize;
-
-			for ( let k = 0; k < itemSize; k ++ ) {
-
-				// double tilde truncates the decimal value
-				hash += `${ ~ ~ ( attribute[ getters[ k ] ]( index ) * hashMultiplier + hashAdditive ) },`;
-
-			}
-
-		}
-
-		// Add another reference to the vertex if it's already
-		// used by another index
-		if ( hash in hashToIndex ) {
-
-			newIndices.push( hashToIndex[ hash ] );
-
-		} else {
-
-			// copy data to the new index in the temporary attributes
-			for ( let j = 0, l = attributeNames.length; j < l; j ++ ) {
-
-				const name = attributeNames[ j ];
-				const attribute = geometry.getAttribute( name );
-				const morphAttributes = geometry.morphAttributes[ name ];
-				const itemSize = attribute.itemSize;
-				const newArray = tmpAttributes[ name ];
-				const newMorphArrays = tmpMorphAttributes[ name ];
-
-				for ( let k = 0; k < itemSize; k ++ ) {
-
-					const getterFunc = getters[ k ];
-					const setterFunc = setters[ k ];
-					newArray[ setterFunc ]( nextIndex, attribute[ getterFunc ]( index ) );
-
-					if ( morphAttributes ) {
-
-						for ( let m = 0, ml = morphAttributes.length; m < ml; m ++ ) {
-
-							newMorphArrays[ m ][ setterFunc ]( nextIndex, morphAttributes[ m ][ getterFunc ]( index ) );
-
-						}
-
-					}
-
-				}
-
-			}
-
-			hashToIndex[ hash ] = nextIndex;
-			newIndices.push( nextIndex );
-			nextIndex ++;
-
-		}
-
-	}
-
-	// generate result BufferGeometry
-	const result = geometry.clone();
-	for ( const name in geometry.attributes ) {
-
-		const tmpAttribute = tmpAttributes[ name ];
-
-		result.setAttribute( name, new tmpAttribute.constructor(
-			tmpAttribute.array.slice( 0, nextIndex * tmpAttribute.itemSize ),
-			tmpAttribute.itemSize,
-			tmpAttribute.normalized,
-		) );
-
-		if ( ! ( name in tmpMorphAttributes ) ) continue;
-
-		for ( let j = 0; j < tmpMorphAttributes[ name ].length; j ++ ) {
-
-			const tmpMorphAttribute = tmpMorphAttributes[ name ][ j ];
-
-			result.morphAttributes[ name ][ j ] = new tmpMorphAttribute.constructor(
-				tmpMorphAttribute.array.slice( 0, nextIndex * tmpMorphAttribute.itemSize ),
-				tmpMorphAttribute.itemSize,
-				tmpMorphAttribute.normalized,
-			);
-
-		}
-
-	}
-
-	// indices
-
-	result.setIndex( newIndices );
-
-	return result;
-
-}
-
-function pannellogeometry(gcad, l, a, p, r1 = 0, r2 = 0, r3 = 0, r4 = 0, b = 0, npt = 2) {
-    let ky = hash(`pg--${l}|${a}|${p}|${r1}|${r2}|${r3}|${r4}|${b}|${npt}`);
-    l -= 0.01;
-    a -= 0.01;
-    p -= 0.01;
-
-    if (!gcad.geo[ky]) {
-        l -= b * 2;
-        a -= b * 2;
-        p -= b * 2;
-        let tm = getshape();
-
-        const vv = [
-            { x: r4, y: 0 }, // 0
-            { x: a - r1, y: 0 }, //1
-            { x: a, y: r1 }, //2
-            { x: a, y: p - r2 }, //3
-            { x: a - r2, y: p }, //4
-            { x: r3, y: p }, //5
-            { x: 0, y: p - r3 }, //6
-            { x: 0, y: r4 }, //7
-        ];
-        tm.addpt(vv[0]);
-        tm.addpt(vv[1]);
-        if (r1) {
-            tm.addpt(raccordabezier(vv[0], vv[1], vv[2], vv[3], npt));
-        }
-        tm.addpt(vv[2]);
-        tm.addpt(vv[3]);
-        if (r2) {
-            tm.addpt(raccordabezier(vv[2], vv[3], vv[4], vv[5], npt));
-        }
-        tm.addpt(vv[4]);
-        tm.addpt(vv[5]);
-        if (r3) {
-            tm.addpt(raccordabezier(vv[4], vv[5], vv[6], vv[7], npt));
-        }
-        tm.addpt(vv[6]);
-        tm.addpt(vv[7]);
-        if (r2) {
-            tm.addpt(raccordabezier(vv[6], vv[7], vv[0], vv[1], npt));
-        }
-        tm.removeduplicate(0.01);
-        let pts = tm.pt;
-        //pts = tm.computenormals(0.01);
-        //const pts = tm.computenormals(0);
-        const shape = new THREE.Shape();
-        shape.moveTo(pts[0].x, pts[0].y);
-        for (let i = 1; i < pts.length; i++) {
-            shape.lineTo(pts[i].x, pts[i].y);
-        }
-        shape.lineTo(pts[0].x, pts[0].y);
-        const extrudeSettings = {
-            depth: l, // Estrusione lungo l'asse Z
-            bevelEnabled: b > 0, // Attiva il bevel se r è valido
-            bevelThickness: b,
-            bevelSize: b,
-            bevelSegments: 1,
-        };
-        let xgeo = new THREE.ExtrudeGeometry(shape, extrudeSettings);
-        xgeo = mergeVertices(xgeo);
-        xgeo.computeVertexNormals();
-        const uv = xgeo.attributes.uv;
-        let x1 = Math.random() * l;
-        let y1 = Math.random() * (a + p);
-        for (let i = 0; i < uv.count; i++) {
-            uv.setXY(i,
-                uv.getX(i) + x1,
-                uv.getY(i) + y1
-            );
-        }
-        uv.needsUpdate = true;
-        gcad.geo[ky] = xgeo;
-
-    }
-    return gcad.geo[ky];
-}
-
-
-
-async function getpannello(gcad, orientamento, x, y, z, mat1, mat2, options) {
-    if (!options) options = {};
-    let { r, r1, r2, r3, r4, b, npt } = options;
-
-    // Normalizza i raggi degli angoli
-    r1 = r1 || r || 0;
-    r2 = r2 || r || 0;
-    r3 = r3 || r || 0;
-    r4 = r4 || r || 0;
-    npt = npt || 2;
-    b = b || 0;
-    if (b >= x / 2 || b >= y / 2 || b >= z / 2) b = 0;
-
-
-    // Calcola dimensioni in base all'orientamento
-    let l, a, p;
-    orientamento = orientamento.trim().toUpperCase();
-    l = orientamento[0] == 'L' ? x : orientamento[0] == 'A' ? y : z;
-    a = orientamento[1] == 'L' ? x : orientamento[1] == 'A' ? y : z;
-    p = orientamento[2] == 'L' ? x : orientamento[2] == 'A' ? y : z;
-
-    let grp = new THREE.Group();
-
-    // Aggiunge linee di bordo se richiesto
-    if (!options.nolines) {
-        let segments = edgesfromgeometry(new THREE.BoxGeometry(x, y, z));
-        segments.position.set(x / 2, y / 2, z / 2);
-        grp.add(segments);
-    }
-    let geometry = pannellogeometry(gcad, l, a, p, r1, r2, r3, r4, b, npt);
-
-    let mesh = getmesh(geometry, [mat2 || mgreen, mat1 || mwhite$1]);
-    mesh.name = 'pannello';
-    mesh.layers.set(1);
-    let m2 = mesh;
-    if (b) {
-
-        mesh.position.set(b, b, b);
-        m2 = new THREE.Group();
-        m2.add(mesh);
-    }
-
-    mesh = meshrotate(orientamento, m2, l, a, p);
-    grp.add(mesh);
-    return grp;
-}
-
-function infoestrudi(shape, hshape, pts, options) {
-    if (!options) options = {};
-    if (!pts) pts = [];
-    // calcola le posizioni;
-    let p0 = options.p0 || 0;
-    let coeffbase1 = Math.tan(options.coeffbase1 * PIF || 0);
-    let coeffbase2 = Math.tan(options.coeffbase2 * PIF || 0);
-    let p1 = hshape || options.p1 || 20;
-    let coefftop1 = Math.tan(options.coefftop1 * PIF || 0);
-    let coefftop2 = Math.tan(options.coefftop2 * PIF || 0);
-    // calcola x,y minimo e massimo della shape
-    let { mi, ma } = shape.pt.reduce((t, e) => {
-        // e.x,e.y punto
-        t.mi.x = Math.min(t.mi.x, e.x);
-        t.mi.y = Math.min(t.mi.y, e.y);
-        t.ma.x = Math.max(t.ma.x, e.x);
-        t.ma.y = Math.max(t.ma.y, e.y);
-        return t;
-    }, { mi: { x: 1e9, y: 1e9 }, ma: { x: -1e9, y: -1e9 } });
-    // calcola lunghezza minima e massima, e calcola la z per ogni punto
-    let lmax = 0;
-    let lmin = 1e9;
-    function getpars(p) {
-        p.z1 = getzeta(p.x, p.y, p0, coeffbase1, coeffbase2);
-        p.z2 = getzeta(p.x, p.y, p1, coefftop1, coefftop2);
-        p.l = Math.abs(p.z2 - p.z1);
-    }
-    for (let p of pts) {
-        getpars(p);
-    }
-    getpars(mi);
-    getpars(ma);
-    let rect = [{ x: mi.x, y: mi.y },
-    { x: ma.x, y: mi.y },
-    { x: ma.x, y: ma.y },
-    { x: mi.x, y: ma.y }];
-    for (let r of rect) {
-        getpars(r);
-        if (r.l > lmax) lmax = r.l;
-        if (r.l < lmin) lmin = r.l;
-    }
-    return {
-        aini: options.coeffbase1 || 0,
-        aini2: options.coeffbase2 || 0,
-        afin: options.coefftop1 || 0,
-        afin2: options.coefftop2 || 0,
-
-        pts,
-        mi,
-        ma,
-        rect,
-        dimx: ma.x - mi.x,
-        dimy: ma.y - mi.y,
-        lnom: p1 - p0,
-        lmax,
-        lmin,
-        lmed: (lmax + lmin) / 2
-    }
-}
-
-
-function getzeta(x, y, zbase, cx, cy) {
-    return x * cx + y * cy + zbase;
-}
-
-function sidegeomfromshapes(gcad, ky, s1, s2, invert = false) {
-    // la chiave per questa funzione è complessa e va ricavata prima!
-
-    if (!s1 || !s2) return;
-    if (s1.length !== s2.length) throw new Error('shapes with different length');
-    if (s1.length < 2) throw new Error('I percorsi devono contenere almeno due punti ciascuno.');
-    if (!gcad.geo[ky]) {
-        const positions = [];
-        // const normals = [];
-        const uvs = [];
-        const indices = [];
-        const np = s1.length;
-        const addpts = (ss) => {
-            for (const s of ss) {
-                positions.push(s.x, s.y, s.z);
-                //       normals.push(s.nx, s.ny, s.nz);
-                uvs.push(s.u, s.v);
-            }
-        };
-
-        // Funzione per verificare se due punti sono uguali
-        const equalpos = (p1, p2) => p1.x === p2.x && p1.y === p2.y && p1.z === p2.z;
-
-        const addindexquad = (i1, i2, i3, i4) => {
-            if (invert) {
-                indices.push(i1, i3, i2, i3, i4, i2);
-
-            } else {
-                indices.push(i1, i2, i3, i3, i2, i4);
-            }
-        };
-
-        // Aggiungi tutti i punti di s1 e s2
-        addpts(s1);
-        addpts(s2);
-
-        // Creazione degli indici per i triangoli
-        for (let i = 0; i < np - 1; i++) {
-            const j = (i + 1); // raccorda sempre 'ultimo punto con il primo!
-
-            // Verifica se i punti consecutivi di s1 sono duplicati
-            if (equalpos(s1[i], s1[j])) {
-                continue;
-            }
-
-            // Aggiungi i triangoli del quadrilatero
-            addindexquad(i, j, i + np, j + np);
-        }
-
-        // Creazione della BufferGeometry
-        const geometry = new THREE.BufferGeometry();
-
-        // Impostazione degli attributi
-        geometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
-        // geometry.setAttribute('normal', new THREE.Float32BufferAttribute(normals, 3));
-        geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
-        geometry.setIndex(indices);
-
-        //Computazione delle normali (opzionale, se non già calcolate)
-        geometry.computeVertexNormals();
-        gcad.geo[ky] = geometry;
-    }
-    return gcad.geo[ky];
-
-}
-function bottomgeomfromshape(gcad, inverti, outer, holes, c = 0, a = 0, b = 0) {
-    // determina chiave
-    let ky = `bg:${c}|${a}${b}|${outer.key}|${inverti}`;
-    for (var h of holes) ky = `${ky}|${h.key}`;
-    ky = hash(ky);
-    if (!gcad.geo[ky]) {
-        let pos = [],
-            hl = [];
-        let triangles;
-        let cc = outer.pt.length;
-        pos = outer.vec;
-
-        if (Array.isArray(holes)) {
-            for (var h of holes) {
-                hl.push(cc);
-                cc += h.pt.length;
-                pos = [...pos, ...h.vec];
-            }
-            triangles = earcut(pos, hl);
-        } else {
-            triangles = earcut(pos);
-        }
-        const geometry = new THREE.BufferGeometry();
-        const vertices = [];
-        const uvs = [];
-        const indices = [];
-        // Aggiungi i vertici per ogni triangolo
-        for (let i = 0; i < triangles.length; i++) {
-            const index = triangles[i];
-            const x = pos[index * 2];
-            const y = -pos[index * 2 + 1];
-            const z = getzeta(x, y, c, a, b);// a * x + b * y + c; // Calcolo della coordinata z
-
-            // Aggiungi il vertice 3D
-            vertices.push(x, y, z);
-
-            // Imposta le coordinate UV (x, y)
-            uvs.push(y, x);
-        }
-        for (let i = 0; i < triangles.length; i += 3) {
-            if (inverti) {
-                indices.push(i, i + 2, i + 1);
-            } else {
-                indices.push(i, i + 1, i + 2);
-            }
-
-        }
-
-
-        // Calcola la normale una sola volta
-        //const v0 = new THREE.Vector3(pos[triangles[0] * 2], pos[triangles[0] * 2 + 1], a * pos[triangles[0] * 2] + b * pos[triangles[0] * 2 + 1] + c);
-        //const v1 = new THREE.Vector3(pos[triangles[1] * 2], pos[triangles[1] * 2 + 1], a * pos[triangles[1] * 2] + b * pos[triangles[1] * 2 + 1] + c);
-        //const v2 = new THREE.Vector3(pos[triangles[2] * 2], pos[triangles[2] * 2 + 1], a * pos[triangles[2] * 2] + b * pos[triangles[2] * 2 + 1] + c);
-
-        // Calcola i vettori del triangolo
-        //const edge1 = new THREE.Vector3().subVectors(v1, v0);
-        //const edge2 = new THREE.Vector3().subVectors(v2, v0);
-
-        // Calcola il prodotto vettoriale per ottenere la normale
-        //const normal = new THREE.Vector3().crossVectors(edge1, edge2).normalize();
-
-        // Aggiungi la normale per ogni vertice del triangolo
-        //const normals = [];
-        //for (let i = 0; i < triangles.length; i++) {
-        //    normals.push(normal.x, normal.y, normal.z);
-        //}
-
-        // Imposta i vertici nella geometria
-        geometry.setAttribute('position', new THREE.Float32BufferAttribute(vertices, 3));
-        geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
-        geometry.setIndex(indices);
-
-        //geometry.setAttribute('normal', new THREE.Float32BufferAttribute(normals, 3));
-        geometry.computeVertexNormals();
-        gcad.geo[ky] = geometry;
-    }
-    return gcad.geo[ky];
-}
-
-
-function sidegeomfrompat(gcad, pbase, pat, invert) {
-    let ky = `bsg:${pbase.key}|${pat.key}|${invert}`;
-    ky = hash(ky);
-    if (!gcad.geo[ky]) {
-        const positions = [];
-        const uvs = [];
-        const indices = [];
-        const np = pbase.length;
-        const lp = pat.pt.length;
-        // Funzione per verificare se due punti sono uguali
-        const equalpos = (p1, p2) => p1.x === p2.x && p1.y === p2.y && p1.z === p2.z;
-
-        let l0 = 0;
-        for (let ii = 0; ii < lp; ii++) {
-            const addpts = (ss, mat, deltav) => {
-                for (const s of ss) {
-                    let p = new THREE.Vector3(s.x, s.y, s.z);
-                    p.applyMatrix4(mat);
-                    positions.push(p.x, p.y, p.z);
-                    uvs.push(s.u, s.v + deltav);
-                }
-            };
-            let seg1 = pat.infosegmento(ii, true);
-            let obj = new THREE.Object3D();
-            obj.position.set(seg1.x, 0, seg1.y);
-            obj.rotation.set(0, (90 - seg1.ang) * PIF, 0);
-
-            //obj.position.set(seg1.y, -seg1.x, 0);
-
-            obj.updateMatrix();
-            addpts(pbase, obj.matrix, l0);
-            l0 += seg1.l;
-        }
-
-        // Creazione degli indici per i triangoli
-        for (let li = 0; li < lp - 1; li++) {
-
-            for (let i = 0; i < np - 1; i++) {
-                const addindexquad = (i1, i2, i3, i4) => {
-                    if (invert) {
-                        indices.push(i1, i3, i2, i3, i4, i2);
-                    } else {
-                        indices.push(i1, i2, i3, i3, i2, i4);
-                    }
-                };
-                const j = (i + 1); // raccorda sempre 'ultimo punto con il primo!
-                // Verifica se i punti consecutivi di s1 sono duplicati
-                if (equalpos(pbase[i], pbase[j])) {
-                    continue;
-                }
-                addindexquad(
-                    i + li * np,
-                    j + li * np,
-                    i + (li + 1) * np,
-                    j + (li + 1) * np
-                );
-            }
-        }
-        const geometry = new THREE.BufferGeometry();
-        geometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
-        // geometry.setAttribute('normal', new THREE.Float32BufferAttribute(normals, 3));
-        geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
-        geometry.setIndex(indices);
-        geometry.computeVertexNormals();
-        gcad[ky] = geometry;
-    }
-    return gcad[ky];
-}
-
-function estrusorotate(orientamento, mesh, z = 0) {
-    switch (orientamento.trim().toUpperCase().slice(0, 1)) {
-        case 'A':
-            mesh.rotation.x = -Math.PI / 2;
-            break;
-        case 'L':
-            mesh.rotation.y = Math.PI / 2;
-            mesh.rotation.z = Math.PI;
-            break;
-        //     mesh.position.set(0, z, 0);
-        //     break;
-        // case 'ALP':
-        //     mesh.rotation.x = Math.PI / 2;
-        //     mesh.rotation.y = Math.PI / 2;
-        //     break;
-        // case 'APL':
-        //     mesh.rotation.z = Math.PI / 2;
-        //     mesh.rotation.y = Math.PI;
-        //     mesh.position.set(0, 0, z);
-        //     break;
-        // case 'PLA':
-        //     //mesh.rotation.y = -Math.PI / 2;
-        //     mesh.rotation.x = -Math.PI / 2;
-        //     mesh.rotation.z = - Math.PI / 2;
-
-        //     break;
-        // case 'PAL':
-        //     mesh.rotation.y = -Math.PI / 2;
-        //     mesh.position.set(z, 0, 0);
-        //     break;
-        // case 'LAP':
-        //     break;
-        case 'P':
-            mesh.rotation.z = Math.PI / 2;
-
-            break;
-    }
-    return mesh;
-}
-
-
+ */function pannellogeometry(gcad,l,a,p,r1=0,r2=0,r3=0,r4=0,b=0,npt=2){let ky=hash(`pg--${l}|${a}|${p}|${r1}|${r2}|${r3}|${r4}|${b}|${npt}`);if(l-=.01,a-=.01,p-=.01,!gcad.geo[ky]){l-=2*b,a-=2*b,p-=2*b;let tm=getshape();const vv=[{x:r4,y:0},{x:a-r1,y:0},{x:a,y:r1},{x:a,y:p-r2},{x:a-r2,y:p},{x:r3,y:p},{x:0,y:p-r3},{x:0,y:r4}];tm.addpt(vv[0]),tm.addpt(vv[1]),r1&&tm.addpt(raccordabezier(vv[0],vv[1],vv[2],vv[3],npt)),tm.addpt(vv[2]),tm.addpt(vv[3]),r2&&tm.addpt(raccordabezier(vv[2],vv[3],vv[4],vv[5],npt)),tm.addpt(vv[4]),tm.addpt(vv[5]),r3&&tm.addpt(raccordabezier(vv[4],vv[5],vv[6],vv[7],npt)),tm.addpt(vv[6]),tm.addpt(vv[7]),r2&&tm.addpt(raccordabezier(vv[6],vv[7],vv[0],vv[1],npt)),tm.removeduplicate(.01);let pts=tm.pt;const shape=new THREE.Shape;shape.moveTo(pts[0].x,pts[0].y);for(let i=1;i<pts.length;i++)shape.lineTo(pts[i].x,pts[i].y);shape.lineTo(pts[0].x,pts[0].y);const extrudeSettings={depth:l,bevelEnabled:b>0,bevelThickness:b,bevelSize:b,bevelSegments:1};let xgeo=new THREE.ExtrudeGeometry(shape,extrudeSettings);xgeo=function mergeVertices(geometry,tolerance=1e-4){tolerance=Math.max(tolerance,Number.EPSILON);const hashToIndex={},indices=geometry.getIndex(),positions=geometry.getAttribute("position"),vertexCount=indices?indices.count:positions.count;let nextIndex=0;const attributeNames=Object.keys(geometry.attributes),tmpAttributes={},tmpMorphAttributes={},newIndices=[],getters=["getX","getY","getZ","getW"],setters=["setX","setY","setZ","setW"];for(let i=0,l=attributeNames.length;i<l;i++){const name=attributeNames[i],attr=geometry.attributes[name];tmpAttributes[name]=new attr.constructor(new attr.array.constructor(attr.count*attr.itemSize),attr.itemSize,attr.normalized);const morphAttributes=geometry.morphAttributes[name];morphAttributes&&(tmpMorphAttributes[name]||(tmpMorphAttributes[name]=[]),morphAttributes.forEach(((morphAttr,i)=>{const array=new morphAttr.array.constructor(morphAttr.count*morphAttr.itemSize);tmpMorphAttributes[name][i]=new morphAttr.constructor(array,morphAttr.itemSize,morphAttr.normalized)})))}const halfTolerance=.5*tolerance,exponent=Math.log10(1/tolerance),hashMultiplier=Math.pow(10,exponent),hashAdditive=halfTolerance*hashMultiplier;for(let i=0;i<vertexCount;i++){const index=indices?indices.getX(i):i;let hash="";for(let j=0,l=attributeNames.length;j<l;j++){const name=attributeNames[j],attribute=geometry.getAttribute(name),itemSize=attribute.itemSize;for(let k=0;k<itemSize;k++)hash+=~~(attribute[getters[k]](index)*hashMultiplier+hashAdditive)+","}if(hash in hashToIndex)newIndices.push(hashToIndex[hash]);else{for(let j=0,l=attributeNames.length;j<l;j++){const name=attributeNames[j],attribute=geometry.getAttribute(name),morphAttributes=geometry.morphAttributes[name],itemSize=attribute.itemSize,newArray=tmpAttributes[name],newMorphArrays=tmpMorphAttributes[name];for(let k=0;k<itemSize;k++){const getterFunc=getters[k],setterFunc=setters[k];if(newArray[setterFunc](nextIndex,attribute[getterFunc](index)),morphAttributes)for(let m=0,ml=morphAttributes.length;m<ml;m++)newMorphArrays[m][setterFunc](nextIndex,morphAttributes[m][getterFunc](index))}}hashToIndex[hash]=nextIndex,newIndices.push(nextIndex),nextIndex++}}const result=geometry.clone();for(const name in geometry.attributes){const tmpAttribute=tmpAttributes[name];if(result.setAttribute(name,new tmpAttribute.constructor(tmpAttribute.array.slice(0,nextIndex*tmpAttribute.itemSize),tmpAttribute.itemSize,tmpAttribute.normalized)),name in tmpMorphAttributes)for(let j=0;j<tmpMorphAttributes[name].length;j++){const tmpMorphAttribute=tmpMorphAttributes[name][j];result.morphAttributes[name][j]=new tmpMorphAttribute.constructor(tmpMorphAttribute.array.slice(0,nextIndex*tmpMorphAttribute.itemSize),tmpMorphAttribute.itemSize,tmpMorphAttribute.normalized)}}return result.setIndex(newIndices),result}(xgeo),xgeo.computeVertexNormals();const uv=xgeo.attributes.uv;let x1=Math.random()*l,y1=Math.random()*(a+p);for(let i=0;i<uv.count;i++)uv.setXY(i,uv.getX(i)+x1,uv.getY(i)+y1);uv.needsUpdate=!0,gcad.geo[ky]=xgeo}return gcad.geo[ky]}async function getpannello(gcad,orientamento,x,y,z,mat1,mat2,options){options||(options={});let l,a,p,{r:r,r1:r1,r2:r2,r3:r3,r4:r4,b:b,npt:npt}=options;r1=r1||r||0,r2=r2||r||0,r3=r3||r||0,r4=r4||r||0,npt=npt||2,b=b||0,(b>=x/2||b>=y/2||b>=z/2)&&(b=0),l="L"==(orientamento=orientamento.trim().toUpperCase())[0]?x:"A"==orientamento[0]?y:z,a="L"==orientamento[1]?x:"A"==orientamento[1]?y:z,p="L"==orientamento[2]?x:"A"==orientamento[2]?y:z;let grp=new THREE.Group;if(!options.nolines){let segments=edgesfromgeometry(new THREE.BoxGeometry(x,y,z));segments.position.set(x/2,y/2,z/2),grp.add(segments)}let mesh=getmesh(pannellogeometry(gcad,l,a,p,r1,r2,r3,r4,b,npt),[mat2||mgreen,mat1||mwhite$1]);mesh.name="pannello",mesh.layers.set(1);let m2=mesh;return b&&(mesh.position.set(b,b,b),m2=new THREE.Group,m2.add(mesh)),mesh=function meshrotate(orientamento,mesh,x=0,y=0,z=0){switch(orientamento.trim().toUpperCase()){case"LPA":mesh.rotation.y=Math.PI/2,mesh.rotation.x=Math.PI,mesh.position.set(0,z,0);break;case"ALP":mesh.rotation.x=Math.PI/2,mesh.position.set(0,x,0);break;case"APL":mesh.rotation.x=-Math.PI/2,mesh.rotation.z=-Math.PI/2;break;case"PLA":break;case"PAL":mesh.rotation.z=Math.PI/2,mesh.position.set(z,0,0);break;case"LAP":mesh.rotation.y=Math.PI/2,mesh.rotation.z=Math.PI/2}return mesh}(orientamento,m2,l,a,p),grp.add(mesh),grp}function infoestrudi(shape,hshape,pts,options){options||(options={}),pts||(pts=[]);let p0=options.p0||0,coeffbase1=Math.tan(options.coeffbase1*PIF||0),coeffbase2=Math.tan(options.coeffbase2*PIF||0),p1=hshape||options.p1||20,coefftop1=Math.tan(options.coefftop1*PIF||0),coefftop2=Math.tan(options.coefftop2*PIF||0),{mi:mi,ma:ma}=shape.pt.reduce(((t,e)=>(t.mi.x=Math.min(t.mi.x,e.x),t.mi.y=Math.min(t.mi.y,e.y),t.ma.x=Math.max(t.ma.x,e.x),t.ma.y=Math.max(t.ma.y,e.y),t)),{mi:{x:1e9,y:1e9},ma:{x:-1e9,y:-1e9}}),lmax=0,lmin=1e9;function getpars(p){p.z1=getzeta(p.x,p.y,p0,coeffbase1,coeffbase2),p.z2=getzeta(p.x,p.y,p1,coefftop1,coefftop2),p.l=Math.abs(p.z2-p.z1)}for(let p of pts)getpars(p);getpars(mi),getpars(ma);let rect=[{x:mi.x,y:mi.y},{x:ma.x,y:mi.y},{x:ma.x,y:ma.y},{x:mi.x,y:ma.y}];for(let r of rect)getpars(r),r.l>lmax&&(lmax=r.l),r.l<lmin&&(lmin=r.l);return{aini:options.coeffbase1||0,aini2:options.coeffbase2||0,afin:options.coefftop1||0,afin2:options.coefftop2||0,pts:pts,mi:mi,ma:ma,rect:rect,dimx:ma.x-mi.x,dimy:ma.y-mi.y,lnom:p1-p0,lmax:lmax,lmin:lmin,lmed:(lmax+lmin)/2}}function getzeta(x,y,zbase,cx,cy){return x*cx+y*cy+zbase}function sidegeomfromshapes(gcad,ky,s1,s2,invert=!1){if(s1&&s2){if(s1.length!==s2.length)throw new Error("shapes with different length");if(s1.length<2)throw new Error("I percorsi devono contenere almeno due punti ciascuno.");if(!gcad.geo[ky]){const positions=[],uvs=[],indices=[],np=s1.length,addpts=ss=>{for(const s of ss)positions.push(s.x,s.y,s.z),uvs.push(s.u,s.v)},equalpos=(p1,p2)=>p1.x===p2.x&&p1.y===p2.y&&p1.z===p2.z,addindexquad=(i1,i2,i3,i4)=>{invert?indices.push(i1,i3,i2,i3,i4,i2):indices.push(i1,i2,i3,i3,i2,i4)};addpts(s1),addpts(s2);for(let i=0;i<np-1;i++){const j=i+1;equalpos(s1[i],s1[j])||addindexquad(i,j,i+np,j+np)}const geometry=new THREE.BufferGeometry;geometry.setAttribute("position",new THREE.Float32BufferAttribute(positions,3)),geometry.setAttribute("uv",new THREE.Float32BufferAttribute(uvs,2)),geometry.setIndex(indices),geometry.computeVertexNormals(),gcad.geo[ky]=geometry}return gcad.geo[ky]}}function bottomgeomfromshape(gcad,inverti,outer,holes,c=0,a=0,b=0){let ky=`bg:${c}|${a}${b}|${outer.key}|${inverti}`;for(var h of holes)ky=`${ky}|${h.key}`;if(ky=hash(ky),!gcad.geo[ky]){let triangles,pos=[],hl=[],cc=outer.pt.length;if(pos=outer.vec,Array.isArray(holes)){for(var h of holes)hl.push(cc),cc+=h.pt.length,pos=[...pos,...h.vec];triangles=earcut(pos,hl)}else triangles=earcut(pos);const geometry=new THREE.BufferGeometry,vertices=[],uvs=[],indices=[];for(let i=0;i<triangles.length;i++){const index=triangles[i],x=pos[2*index],y=-pos[2*index+1],z=getzeta(x,y,c,a,b);vertices.push(x,y,z),uvs.push(y,x)}for(let i=0;i<triangles.length;i+=3)inverti?indices.push(i,i+2,i+1):indices.push(i,i+1,i+2);geometry.setAttribute("position",new THREE.Float32BufferAttribute(vertices,3)),geometry.setAttribute("uv",new THREE.Float32BufferAttribute(uvs,2)),geometry.setIndex(indices),geometry.computeVertexNormals(),gcad.geo[ky]=geometry}return gcad.geo[ky]}function estrusorotate(orientamento,mesh,z=0){switch(orientamento.trim().toUpperCase().slice(0,1)){case"A":mesh.rotation.x=-Math.PI/2;break;case"L":mesh.rotation.y=Math.PI/2,mesh.rotation.z=Math.PI;break;case"P":mesh.rotation.z=Math.PI/2}return mesh}
 /**
  * Crea una geometria estrusa con opzioni avanzate
  * @param {string} orient - Orientamento dell'estrusione
@@ -1570,102 +108,7 @@ function estrusorotate(orientamento, mesh, z = 0) {
  * @param {Array} mats - Array di materiali
  * @param {Object} options - Opzioni di configurazione
  * @returns {THREE.Group} Gruppo contenente la geometria estrusa
- */
-
-
-function estruso(gcad, orient, hshape, shape, holes, mats, options) {
-    if (!options) {
-        options = {};
-    }
-    if (!mats) mats = [];
-    // Estrae i parametri dalle opzioni
-    let p0 = options.p0 || 0;
-
-    let coeffbase1 = Math.tan(options.coeffbase1 * PIF || 0);
-    let coeffbase2 = Math.tan(options.coeffbase2 * PIF || 0);
-    let p1 = hshape || options.p1 || 20;
-    let coefftop1 = Math.tan(options.coefftop1 * PIF || 0);
-    let coefftop2 = Math.tan(options.coefftop2 * PIF || 0);
-    let open = options.open || false;
-    let grp = new THREE.Group();
-
-    // Crea le geometrie di base
-
-
-
-    // Aggiunge facce base e top se richiesto
-    if (!options.nobase) {
-        let g1 = bottomgeomfromshape(gcad, false, shape, open ? [] : holes, p0, coeffbase1, coeffbase2);
-        if (!options.nolines) grp.add(edgesfromgeometry(g1));
-        grp.add(getmesh(g1, mats[0] || mwhite$1));
-    }
-    if (!options.notop) {
-        let g3 = bottomgeomfromshape(gcad, true, shape, open ? [] : holes, p1, coefftop1, coefftop2);
-        grp.add(getmesh(g3, mats[1] || mats[0] || mwhite$1));
-        if (!options.nolines) grp.add(edgesfromgeometry(g3));
-    }
-
-    // Gestione dei lati e dei fori
-    if (!options.nosides) {
-        let pat1 = shape.to3d(0, p0, coeffbase1, coeffbase2, open);
-        let pat2 = shape.to3d(0, p1, coefftop1, coefftop2, open);
-        let ky = `${shape.key}|${p0}|${p1}|${coeffbase1}|${coeffbase2}|${coefftop1}|${coefftop2}|${open}`;
-        let geo1 = sidegeomfromshapes(gcad, ky, pat1, pat2, false);
-
-        if (!options.nolines && !options.nosidelines) {
-            grp.add(edgesfromgeometry(geo1));
-        }
-        grp.add(getmesh(geo1, mats[2] || mats[0] || mwhite$1));
-
-        // Gestione dei fori
-        if (holes && !open) {
-            for (var h of holes) {
-                pat1 = h.to3d(0, p0, coeffbase1, coeffbase2);
-                pat2 = h.to3d(0, p1, coefftop1, coefftop2);
-                ky = `${h.key}|${p0}|${p1}|${coeffbase1}|${coeffbase2}|${coefftop1}|${coefftop2}`;
-                let geo2 = sidegeomfromshapes(gcad, ky, pat1, pat2, true);
-                if (!options.nolines && !options.nosidelines) {
-                    grp.add(edgesfromgeometry(geo2));
-                }
-                grp.add(getmesh(geo2, mats[3] || mats[0] || mwhite$1));
-            }
-        }
-    }
-    return estrusorotate(orient, grp, hshape);
-}
-
-function revolve(gcad, shape, orient, mat, options) {
-    if (!options) {
-        options = {};
-    }
-    let segmenti = options.segmenti ?? 12;
-    let ky = hash(`rev|${shape.key}|${orient}|${segmenti}`);
-    let geometria = gcad.geo[ky];
-    let grp = new THREE.Group();
-    if (!geometria) {
-        const punti3D = shape.pt.map(p => new THREE.Vector3(p.x, p.y, 0));
-        // Creiamo la geometria di rivoluzione
-        geometria = new THREE.LatheGeometry(
-            punti3D,
-            segmenti,
-            0,
-            Math.PI * 2
-        );
-        gcad.geo[ky] = geometria;
-    }
-    const mesh = new THREE.Mesh(geometria, mat);
-    grp.add(mesh);
-    if (!options.nolines && !options.nosidelines) {
-        grp.add(edgesfromgeometry(geometria));
-    }
-    return grp;
-    // todo: orienta il gruppo
-    //return estrusorotate(orient, grp);
-
-}
-
-
-
+ */function estruso(gcad,orient,hshape,shape,holes,mats,options){options||(options={}),mats||(mats=[]);let p0=options.p0||0,coeffbase1=Math.tan(options.coeffbase1*PIF||0),coeffbase2=Math.tan(options.coeffbase2*PIF||0),p1=hshape||options.p1||20,coefftop1=Math.tan(options.coefftop1*PIF||0),coefftop2=Math.tan(options.coefftop2*PIF||0),open=options.open||!1,grp=new THREE.Group;if(!options.nobase){let g1=bottomgeomfromshape(gcad,!1,shape,open?[]:holes,p0,coeffbase1,coeffbase2);options.nolines||grp.add(edgesfromgeometry(g1)),grp.add(getmesh(g1,mats[0]||mwhite$1))}if(!options.notop){let g3=bottomgeomfromshape(gcad,!0,shape,open?[]:holes,p1,coefftop1,coefftop2);grp.add(getmesh(g3,mats[1]||mats[0]||mwhite$1)),options.nolines||grp.add(edgesfromgeometry(g3))}if(!options.nosides){let pat1=shape.to3d(0,p0,coeffbase1,coeffbase2,open),pat2=shape.to3d(0,p1,coefftop1,coefftop2,open),ky=`${shape.key}|${p0}|${p1}|${coeffbase1}|${coeffbase2}|${coefftop1}|${coefftop2}|${open}`,geo1=sidegeomfromshapes(gcad,ky,pat1,pat2,!1);if(options.nolines||options.nosidelines||grp.add(edgesfromgeometry(geo1)),grp.add(getmesh(geo1,mats[2]||mats[0]||mwhite$1)),holes&&!open)for(var h of holes){pat1=h.to3d(0,p0,coeffbase1,coeffbase2),pat2=h.to3d(0,p1,coefftop1,coefftop2),ky=`${h.key}|${p0}|${p1}|${coeffbase1}|${coeffbase2}|${coefftop1}|${coefftop2}`;let geo2=sidegeomfromshapes(gcad,ky,pat1,pat2,!0);options.nolines||options.nosidelines||grp.add(edgesfromgeometry(geo2)),grp.add(getmesh(geo2,mats[3]||mats[0]||mwhite$1))}}return estrusorotate(orient,grp,hshape)}function revolve(gcad,shape,orient,mat,options){options||(options={});let segmenti=options.segmenti??12,ky=hash(`rev|${shape.key}|${orient}|${segmenti}`),geometria=gcad.geo[ky],grp=new THREE.Group;if(!geometria){const punti3D=shape.pt.map((p=>new THREE.Vector3(p.x,p.y,0)));geometria=new THREE.LatheGeometry(punti3D,segmenti,0,2*Math.PI),gcad.geo[ky]=geometria}const mesh=new THREE.Mesh(geometria,mat);return grp.add(mesh),options.nolines||options.nosidelines||grp.add(edgesfromgeometry(geometria)),grp}
 /**
  * Crea una geometria estrusa con opzioni avanzate
  * @param {string} orient - Orientamento dell'estrusione
@@ -1675,157 +118,4 @@ function revolve(gcad, shape, orient, mat, options) {
  * @param {Array} mats - Array di materiali
  * @param {Object} options - Opzioni di configurazione
  * @returns {THREE.Group} Gruppo contenente la geometria estrusa
- */
-
-
-function estrusopat(gcad, orient, pat, shape, mats, options) {
-    if (!options) {
-        options = {};
-    }
-    let invert = options.invert;
-    //
-    if (!mats) mats = [];
-    let open = options.open;
-    // Estrae i parametri dalle opzioni
-    if (!pat.pt?.length) return;
-    let pbase = shape.to3d(0, 0, 0, 0, open);
-    let grp = new THREE.Group();
-
-    if (!options.nobase) {
-        let gb = new THREE.Group();
-        let g1 = bottomgeomfromshape(gcad, false, shape, [], 0, 0, 0);
-        gb.add(getmesh(g1, mats[0] || mwhite$1));
-        gb.add(edgesfromgeometry(g1));
-        let seg1 = pat.infosegmento(0, true);
-        grp.add(posiziona(gb, { sl: seg1.x, sp: seg1.y, sa: 0, ay: (90 - seg1.ang) }));
-    }
-
-    if (!options.notop) {
-        let gt = new THREE.Group();
-        let g2 = bottomgeomfromshape(gcad, true, shape, [], 0, 0, 0);
-        gt.add(getmesh(g2, mats[1] || mats[0] || mwhite$1));
-        gt.add(edgesfromgeometry(g2));
-        let seg1 = pat.infosegmento(pat.pt.length - 1, true);
-        grp.add(posiziona(gt, { sl: seg1.x, sp: seg1.y, sa: 0, ay: (90 - seg1.ang) }));
-    }
-
-
-
-    const geo1 = sidegeomfrompat(gcad, pbase, pat, invert);
-    if (!options.nolines && !options.nosidelines) {
-        grp.add(edgesfromgeometry(geo1));
-    }
-    grp.add(getmesh(geo1, mats[2] || mats[0] || mwhite$1));
-
-
-    // for (let ii = 1; ii < pat.pt.length - 1; ii++) {
-
-    //     let seg1 = pat.infosegmento(ii, true);
-
-    //     grp.add(posiziona(gb, { sp: seg1.y, sa: - seg1.x, ax: 90 - seg1.ang }));
-    // }
-
-
-    return estrusorotate(orient, grp, 0);
-}
-
-async function createCircleTexture(gcad, size = 64, color = 'rgba(255,0,0,1)') {
-    const ky = `ct|${size}|${color}`;
-    if (!gcad.textures[ky]) {
-        const canvas = document.createElement('canvas');
-        canvas.width = canvas.height = size;
-
-        const ctx = canvas.getContext('2d');
-        const radius = size / 2;
-
-        // Sfondo trasparente
-        ctx.clearRect(0, 0, size, size);
-
-        // Cerchio pieno al centro
-        ctx.fillStyle = color;
-        ctx.beginPath();
-        ctx.arc(radius, radius, radius, 0, Math.PI * 2);
-        ctx.fill();
-
-        const texture = new THREE.CanvasTexture(canvas);
-        texture.needsUpdate = true;
-        gcad.textures[ky] = texture;
-    }
-
-    return gcad.textures[ky];
-}
-
-
-async function spritemat(gcad, file) {
-    //  le varie opzioni per smat sono sx,sy,rot,rough,metal,env
-    try {
-        let tm = {
-            transparent: true,
-            depthTest: false,
-            depthWrite: false,
-            fog: false,
-            toneMapped: false, // ❗ importante con HDR
-        };
-        if (file.startsWith("#")) {
-            tm.color = file;
-        } else {
-            let tx = await gcad.tex(file, 1000, 1000);
-            if (tx) {
-                tm.map = tx;
-            } else {
-                tm.color = "black";
-            }
-        }
-        return new THREE.SpriteMaterial(tm);
-    } catch (error) {
-        return mwhite;
-    }
-}
-
-function getsprite0(ispunto, x, y, z, mat, options = {}) {
-    if (!options) options = {};
-    let { size = 50, pick = false, screen = false, sizex, sizey } = options;
-
-    const sprite = new THREE.Sprite(mat);
-    sprite.position.set(0, 0, 0);
-    sprite.userData.issprite = true;
-    sprite.userData.ispunto = ispunto;
-    sprite.userData.ispick = pick;
-    sprite.userData.isScreen = screen;
-    sprite.renderOrder = 999;
-    sprite.layers.set(29);
-    sprite.name = ispunto ? '_punto' : '_sprite';
-    let gr = new THREE.Group();
-    gr.position.set(x, y, z);
-    gr.scale.set(sizex || size, sizey || sizex || size, 1); // dimensione apparente (adatta al tuo uso)
-    gr.add(sprite);
-    gr.traverse(obj => {
-        if (obj.material) {
-            obj.material.depthTest = false;
-            obj.material.depthWrite = false;
-        }
-    });
-    gr.renderOrder = 999;
-    return gr;
-
-}
-
-async function getpunto(gcad, x, y, z, color = 'yellow', options) {
-    if (!options) options = { size: 20 };
-    options.screen = true;
-    const texture = await createCircleTexture(gcad, 64, color); // rosso sfumato
-    const mat = new THREE.SpriteMaterial({
-        map: texture,
-        transparent: true,
-
-        fog: false,
-        toneMapped: false, // ❗ importante con HDR
-    });
-    return getsprite0(true, x, y, z, mat, options)
-}
-
-async function getsprite(gcad, x, y, z, mat, options = {}) {
-    return getsprite0(false, x, y, z, mat, options);
-}
-
-export { SIDE, addmovpivot, creategroup, deletegroup, edgesfromgeometry, estruso, estrusopat, get3dshape, getbox, getcilindro, getface, getline, getlinesgeom, getmesh, getmovimento, getpannello, getpoint, getpunto, getquota, getriferimento, getsprite, gettarghetta, groupfromgeometry, infoestrudi, materialline1, materialline2, mblack, mblue, mgray1, mgray2, mgreen, mred, mwhite$1 as mwhite, posiziona, randombasemat, revolve, scaleunit, spritemat, svuotanodo };
+ */function estrusopat(gcad,orient,pat,shape,mats,options){options||(options={});let invert=options.invert;mats||(mats=[]);let open=options.open;if(!pat.pt?.length)return;let pbase=shape.to3d(0,0,0,0,open),grp=new THREE.Group;if(!options.nobase){let gb=new THREE.Group,g1=bottomgeomfromshape(gcad,!1,shape,[],0,0,0);gb.add(getmesh(g1,mats[0]||mwhite$1)),gb.add(edgesfromgeometry(g1));let seg1=pat.infosegmento(0,!0);grp.add(posiziona(gb,{sl:seg1.x,sp:seg1.y,sa:0,ay:90-seg1.ang}))}if(!options.notop){let gt=new THREE.Group,g2=bottomgeomfromshape(gcad,!0,shape,[],0,0,0);gt.add(getmesh(g2,mats[1]||mats[0]||mwhite$1)),gt.add(edgesfromgeometry(g2));let seg1=pat.infosegmento(pat.pt.length-1,!0);grp.add(posiziona(gt,{sl:seg1.x,sp:seg1.y,sa:0,ay:90-seg1.ang}))}const geo1=function sidegeomfrompat(gcad,pbase,pat,invert){let ky=`bsg:${pbase.key}|${pat.key}|${invert}`;if(ky=hash(ky),!gcad.geo[ky]){const positions=[],uvs=[],indices=[],np=pbase.length,lp=pat.pt.length,equalpos=(p1,p2)=>p1.x===p2.x&&p1.y===p2.y&&p1.z===p2.z;let l0=0;for(let ii=0;ii<lp;ii++){const addpts=(ss,mat,deltav)=>{for(const s of ss){let p=new THREE.Vector3(s.x,s.y,s.z);p.applyMatrix4(mat),positions.push(p.x,p.y,p.z),uvs.push(s.u,s.v+deltav)}};let seg1=pat.infosegmento(ii,!0),obj=new THREE.Object3D;obj.position.set(seg1.x,0,seg1.y),obj.rotation.set(0,(90-seg1.ang)*PIF,0),obj.updateMatrix(),addpts(pbase,obj.matrix,l0),l0+=seg1.l}for(let li=0;li<lp-1;li++)for(let i=0;i<np-1;i++){const addindexquad=(i1,i2,i3,i4)=>{invert?indices.push(i1,i3,i2,i3,i4,i2):indices.push(i1,i2,i3,i3,i2,i4)},j=i+1;equalpos(pbase[i],pbase[j])||addindexquad(i+li*np,j+li*np,i+(li+1)*np,j+(li+1)*np)}const geometry=new THREE.BufferGeometry;geometry.setAttribute("position",new THREE.Float32BufferAttribute(positions,3)),geometry.setAttribute("uv",new THREE.Float32BufferAttribute(uvs,2)),geometry.setIndex(indices),geometry.computeVertexNormals(),gcad[ky]=geometry}return gcad[ky]}(gcad,pbase,pat,invert);return options.nolines||options.nosidelines||grp.add(edgesfromgeometry(geo1)),grp.add(getmesh(geo1,mats[2]||mats[0]||mwhite$1)),estrusorotate(orient,grp,0)}async function spritemat(gcad,file){try{let tm={transparent:!0,depthTest:!1,depthWrite:!1,fog:!1,toneMapped:!1};if(file.startsWith("#"))tm.color=file;else{let tx=await gcad.tex(file,1e3,1e3);tx?tm.map=tx:tm.color="black"}return new THREE.SpriteMaterial(tm)}catch(error){return mwhite}}function getsprite0(ispunto,x,y,z,mat,options={}){options||(options={});let{size:size=50,pick:pick=!1,screen:screen=!1,sizex:sizex,sizey:sizey}=options;const sprite=new THREE.Sprite(mat);sprite.position.set(0,0,0),sprite.userData.issprite=!0,sprite.userData.ispunto=ispunto,sprite.userData.ispick=pick,sprite.userData.isScreen=screen,sprite.renderOrder=999,sprite.layers.set(29),sprite.name=ispunto?"_punto":"_sprite";let gr=new THREE.Group;return gr.position.set(x,y,z),gr.scale.set(sizex||size,sizey||sizex||size,1),gr.add(sprite),gr.traverse((obj=>{obj.material&&(obj.material.depthTest=!1,obj.material.depthWrite=!1)})),gr.renderOrder=999,gr}async function getpunto(gcad,x,y,z,color="yellow",options){options||(options={size:20}),options.screen=!0;const texture=await async function createCircleTexture(gcad,size=64,color="rgba(255,0,0,1)"){const ky=`ct|${size}|${color}`;if(!gcad.textures[ky]){const canvas=document.createElement("canvas");canvas.width=canvas.height=size;const ctx=canvas.getContext("2d"),radius=size/2;ctx.clearRect(0,0,size,size),ctx.fillStyle=color,ctx.beginPath(),ctx.arc(radius,radius,radius,0,2*Math.PI),ctx.fill();const texture=new THREE.CanvasTexture(canvas);texture.needsUpdate=!0,gcad.textures[ky]=texture}return gcad.textures[ky]}(gcad,64,color);return getsprite0(!0,x,y,z,new THREE.SpriteMaterial({map:texture,transparent:!0,fog:!1,toneMapped:!1}),options)}async function getsprite(gcad,x,y,z,mat,options={}){return getsprite0(!1,x,y,z,mat,options)}export{SIDE,addmovpivot,creategroup,deletegroup,edgesfromgeometry,estruso,estrusopat,get3dshape,getbox,getcilindro,getface,getline,getlinesgeom,getmesh,getmovimento,getpannello,getpoint,getpunto,getquota,getriferimento,getsprite,gettarghetta,groupfromgeometry,infoestrudi,materialline1,materialline2,mblack,mblue,mgray1,mgray2,mgreen,mred,mwhite$1 as mwhite,posiziona,randombasemat,revolve,scaleunit,spritemat,svuotanodo};