markuno_lib 1.1.21 → 1.1.22

package/bin/markcad3d.js

@@ -0,0 +1,1831 @@
+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;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Crea un punto 3D rappresentato da una sfera
+ * @param {Object} p - Coordinate del punto
+ * @param {string} id - Identificatore
+ * @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;
+}
+
+
+/**
+ * Aggiunge un pivot a un oggetto 3D esistente, mantenendone posizione e orientamento globale.
+ * @param {THREE.Object3D} grp - Oggetto esistente già posizionato nella scena.
+ * @param {THREE.Vector3} pivotLocal - Punto (locale) attorno a cui ruotare (es: -x/2, -y/2, 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;
+}
+
+
+/**
+ * Crea un gestore di movimento per animare oggetti 3D.
+ * @param {string} key - Chiave identificativa del movimento
+ * @param {Array<Object>} gtimeline - Timeline di passi di animazione. Ogni passo può contenere:
+ *   @param {number} time - Durata del passo in millisecondi
+ *   @param {(number|function)} [x] - Traslazione X (unità o funzione che restituisce unità)
+ *   @param {(number|function)} [y] - Traslazione Y
+ *   @param {(number|function)} [z] - Traslazione Z
+ *   @param {(number|function)} [s] - Scala uniforme (moltiplicatore)
+ *   @param {(number|function)} [sx] - Scala X
+ *   @param {(number|function)} [sy] - Scala Y
+ *   @param {(number|function)} [sz] - Scala Z
+ *   @param {(number|function)} [ax] - Rotazione X (in giri)
+ *   @param {(number|function)} [ay] - Rotazione Y
+ *   @param {(number|function)} [az] - Rotazione Z
+ *   @param {(number|function)} [t] - Trasparenza (0-1)
+ * @returns {Object} Oggetto gestore del movimento con metodi:
+ *   @property {number} tline - Durata totale della timeline
+ *   @property {function} clear - Pulisce la timeline
+ *   @property {function} add - Aggiunge un passo alla timeline
+ *   @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 };
+}
+
+
+/**
+ * Crea un punto di riferimento invisibile nell'albero 3D
+ * @param {number} x - Coordinata X
+ * @param {number} y - Coordinata Y
+ * @param {number} z - Coordinata Z
+ * @param {Object} dati - Dati da archiviare nell'oggetto
+ * @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;
+}
+
+
+/**
+ * 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();
+}
+
+/**
+ * Crea una quota tra due punti in 3D sul piano XY
+ * @param {string} testo - Testo da visualizzare nella quota
+ * @param {number} x1 - Coordinata X del primo punto
+ * @param {number} y1 - Coordinata Y del primo punto
+ * @param {number} x2 - Coordinata X del secondo punto
+ * @param {number} y2 - Coordinata Y del secondo punto
+ * @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];
+}
+
+
+/**
+ * Crea un cilindro 3D con orientamento personalizzabile
+ * @param {string} ori - Orientamento (X/L, Y/A, Z/P)
+ * @param {number} h - Altezza
+ * @param {number} r1 - Raggio base
+ * @param {number} r2 - Raggio top
+ * @param {THREE.Material|Array} mats - Materiale/i da applicare
+ * @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;
+}
+
+/**
+ * Crea un box 3D con linee di bordo opzionali
+ * @param {number} x - Larghezza
+ * @param {number} y - Altezza
+ * @param {number} z - Profondità
+ * @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;
+}
+
+/**
+ * @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;
+}
+
+
+/**
+ * Crea una geometria estrusa con opzioni avanzate
+ * @param {string} orient - Orientamento dell'estrusione
+ * @param {number} hshape - Altezza dell'estrusione
+ * @param {Object} shape - Forma base
+ * @param {Array} holes - Array di fori
+ * @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);
+
+}
+
+
+
+/**
+ * Crea una geometria estrusa con opzioni avanzate
+ * @param {string} orient - Orientamento dell'estrusione
+ * @param {number} hshape - Altezza dell'estrusione
+ * @param {Object} shape - Forma base
+ * @param {Array} holes - Array di fori
+ * @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 };