@nice2dev/ui-3d 1.0.0 → 1.0.3

package/dist/cjs/uv/uvEditorUtils.js

@@ -0,0 +1,670 @@
+'use strict';
+
+var THREE = require('three');
+
+function _interopNamespaceDefault(e) {
+   var n = Object.create(null);
+   if (e) {
+      Object.keys(e).forEach(function (k) {
+         if (k !== 'default') {
+            var d = Object.getOwnPropertyDescriptor(e, k);
+            Object.defineProperty(n, k, d.get ? d : {
+               enumerable: true,
+               get: function () { return e[k]; }
+            });
+         }
+      });
+   }
+   n.default = e;
+   return Object.freeze(n);
+}
+
+var THREE__namespace = /*#__PURE__*/_interopNamespaceDefault(THREE);
+
+/**
+ * UV Editor Utilities
+ *
+ * Core algorithms and utilities for UV mapping operations.
+ * @module @nice2dev/ui-3d
+ */
+/* ═══════════════════════════════════════════
+   ID Generation
+   ═══════════════════════════════════════════ */
+let idCounter = 0;
+const generateId = (prefix) => `${prefix}_${Date.now()}_${++idCounter}`;
+/* ═══════════════════════════════════════════
+   UV Math Utilities
+   ═══════════════════════════════════════════ */
+const uvDistance = (a, b) => Math.sqrt((a.u - b.u) ** 2 + (a.v - b.v) ** 2);
+const uvLerp = (a, b, t) => ({
+    u: a.u + (b.u - a.u) * t,
+    v: a.v + (b.v - a.v) * t,
+});
+const uvAdd = (a, b) => ({
+    u: a.u + b.u,
+    v: a.v + b.v,
+});
+const uvSub = (a, b) => ({
+    u: a.u - b.u,
+    v: a.v - b.v,
+});
+const uvScale = (p, s) => ({
+    u: p.u * s,
+    v: p.v * s,
+});
+const uvRotate = (p, angle, center = { u: 0.5, v: 0.5 }) => {
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    const du = p.u - center.u;
+    const dv = p.v - center.v;
+    return {
+        u: center.u + du * cos - dv * sin,
+        v: center.v + du * sin + dv * cos,
+    };
+};
+const uvCross = (a, b) => a.u * b.v - a.v * b.u;
+/* ═══════════════════════════════════════════
+   Bounds Utilities
+   ═══════════════════════════════════════════ */
+const createEmptyBounds = () => ({
+    minU: Infinity,
+    maxU: -Infinity,
+    minV: Infinity,
+    maxV: -Infinity,
+});
+const expandBounds = (bounds, point) => ({
+    minU: Math.min(bounds.minU, point.u),
+    maxU: Math.max(bounds.maxU, point.u),
+    minV: Math.min(bounds.minV, point.v),
+    maxV: Math.max(bounds.maxV, point.v),
+});
+const mergeBounds = (a, b) => ({
+    minU: Math.min(a.minU, b.minU),
+    maxU: Math.max(a.maxU, b.maxU),
+    minV: Math.min(a.minV, b.minV),
+    maxV: Math.max(a.maxV, b.maxV),
+});
+const getBoundsCenter = (bounds) => ({
+    u: (bounds.minU + bounds.maxU) / 2,
+    v: (bounds.minV + bounds.maxV) / 2,
+});
+const getBoundsSize = (bounds) => ({
+    u: bounds.maxU - bounds.minU,
+    v: bounds.maxV - bounds.minV,
+});
+const getBoundsArea = (bounds) => (bounds.maxU - bounds.minU) * (bounds.maxV - bounds.minV);
+const boundsContains = (bounds, point) => point.u >= bounds.minU && point.u <= bounds.maxU &&
+    point.v >= bounds.minV && point.v <= bounds.maxV;
+const boundsOverlap = (a, b) => a.minU <= b.maxU && a.maxU >= b.minU &&
+    a.minV <= b.maxV && a.maxV >= b.minV;
+/* ═══════════════════════════════════════════
+   Geometry Extraction
+   ═══════════════════════════════════════════ */
+function extractUVMeshData(geometry, channel = 'uv') {
+    const uvAttr = geometry.getAttribute(channel);
+    const posAttr = geometry.getAttribute('position');
+    const indexAttr = geometry.getIndex();
+    if (!uvAttr || !posAttr)
+        return null;
+    const vertices = new Map();
+    const edges = new Map();
+    const faces = new Map();
+    // Extract vertices
+    for (let i = 0; i < uvAttr.count; i++) {
+        const id = generateId('v');
+        vertices.set(id, {
+            id,
+            position: { u: uvAttr.getX(i), v: uvAttr.getY(i) },
+            index: i,
+            pinned: false,
+            selected: false,
+            vertexIndex: i,
+        });
+    }
+    // Extract faces and edges
+    const vertexIds = Array.from(vertices.keys());
+    const edgeMap = new Map(); // "v1_v2" -> edgeId
+    const faceCount = indexAttr ? indexAttr.count / 3 : posAttr.count / 3;
+    for (let i = 0; i < faceCount; i++) {
+        const faceVertexIds = [];
+        const indices = [];
+        for (let j = 0; j < 3; j++) {
+            const idx = indexAttr ? indexAttr.getX(i * 3 + j) : i * 3 + j;
+            indices.push(idx);
+            faceVertexIds.push(vertexIds[idx]);
+        }
+        // Calculate face area in UV space
+        const v0 = vertices.get(faceVertexIds[0]).position;
+        const v1 = vertices.get(faceVertexIds[1]).position;
+        const v2 = vertices.get(faceVertexIds[2]).position;
+        const uvArea = Math.abs(uvCross(uvSub(v1, v0), uvSub(v2, v0))) / 2;
+        // Calculate face area in 3D space
+        const p0 = new THREE__namespace.Vector3().fromBufferAttribute(posAttr, indices[0]);
+        const p1 = new THREE__namespace.Vector3().fromBufferAttribute(posAttr, indices[1]);
+        const p2 = new THREE__namespace.Vector3().fromBufferAttribute(posAttr, indices[2]);
+        const e1 = p1.clone().sub(p0);
+        const e2 = p2.clone().sub(p0);
+        const area3D = e1.cross(e2).length() / 2;
+        const faceId = generateId('f');
+        faces.set(faceId, {
+            id: faceId,
+            vertices: faceVertexIds,
+            area: uvArea,
+            area3D,
+            distortion: area3D > 0 ? uvArea / area3D : 1,
+            selected: false,
+            faceIndex: i,
+        });
+        // Create edges
+        for (let j = 0; j < 3; j++) {
+            const v1Id = faceVertexIds[j];
+            const v2Id = faceVertexIds[(j + 1) % 3];
+            const edgeKey = [v1Id, v2Id].sort().join('_');
+            if (!edgeMap.has(edgeKey)) {
+                const edgeId = generateId('e');
+                const v1Pos = vertices.get(v1Id).position;
+                const v2Pos = vertices.get(v2Id).position;
+                edges.set(edgeId, {
+                    id: edgeId,
+                    startVertex: v1Id,
+                    endVertex: v2Id,
+                    seam: false,
+                    selected: false,
+                    length: uvDistance(v1Pos, v2Pos),
+                });
+                edgeMap.set(edgeKey, edgeId);
+            }
+        }
+    }
+    // Compute islands
+    const islands = computeIslands(vertices, edges, faces);
+    return {
+        vertices,
+        edges,
+        faces,
+        islands,
+        geometryId: geometry.uuid,
+        dirty: false,
+    };
+}
+/* ═══════════════════════════════════════════
+   Island Detection
+   ═══════════════════════════════════════════ */
+function computeIslands(vertices, edges, faces) {
+    const islands = new Map();
+    const visited = new Set();
+    const faceToIsland = new Map();
+    // Build adjacency graph (faces connected by non-seam edges)
+    const adjacency = new Map();
+    for (const face of faces.values()) {
+        adjacency.set(face.id, new Set());
+    }
+    // Find adjacent faces (sharing vertices)
+    const vertexToFaces = new Map();
+    for (const face of faces.values()) {
+        for (const vId of face.vertices) {
+            if (!vertexToFaces.has(vId))
+                vertexToFaces.set(vId, new Set());
+            vertexToFaces.get(vId).add(face.id);
+        }
+    }
+    for (const face of faces.values()) {
+        for (const vId of face.vertices) {
+            const connectedFaces = vertexToFaces.get(vId);
+            for (const otherFaceId of connectedFaces) {
+                if (otherFaceId !== face.id) {
+                    adjacency.get(face.id).add(otherFaceId);
+                }
+            }
+        }
+    }
+    // Flood fill to find islands
+    const floodFill = (startFaceId) => {
+        var _a;
+        const stack = [startFaceId];
+        const islandFaces = [];
+        while (stack.length > 0) {
+            const faceId = stack.pop();
+            if (visited.has(faceId))
+                continue;
+            visited.add(faceId);
+            islandFaces.push(faceId);
+            for (const neighborId of (_a = adjacency.get(faceId)) !== null && _a !== void 0 ? _a : []) {
+                if (!visited.has(neighborId)) {
+                    stack.push(neighborId);
+                }
+            }
+        }
+        return islandFaces;
+    };
+    for (const face of faces.values()) {
+        if (visited.has(face.id))
+            continue;
+        const islandFaces = floodFill(face.id);
+        const islandId = generateId('i');
+        // Gather island vertices and edges
+        const islandVertices = new Set();
+        const islandEdges = new Set();
+        for (const faceId of islandFaces) {
+            faceToIsland.set(faceId, islandId);
+            const f = faces.get(faceId);
+            for (const vId of f.vertices) {
+                islandVertices.add(vId);
+            }
+        }
+        for (const edge of edges.values()) {
+            if (islandVertices.has(edge.startVertex) && islandVertices.has(edge.endVertex)) {
+                islandEdges.add(edge.id);
+            }
+        }
+        // Calculate bounds
+        let bounds = createEmptyBounds();
+        let totalArea = 0;
+        let centerU = 0, centerV = 0;
+        for (const vId of islandVertices) {
+            const v = vertices.get(vId);
+            bounds = expandBounds(bounds, v.position);
+            centerU += v.position.u;
+            centerV += v.position.v;
+        }
+        for (const faceId of islandFaces) {
+            totalArea += faces.get(faceId).area;
+        }
+        const vertexCount = islandVertices.size;
+        islands.set(islandId, {
+            id: islandId,
+            faces: islandFaces,
+            vertices: Array.from(islandVertices),
+            edges: Array.from(islandEdges),
+            bounds,
+            area: totalArea,
+            selected: false,
+            center: { u: centerU / vertexCount, v: centerV / vertexCount },
+            rotation: 0,
+            scale: { u: 1, v: 1 },
+        });
+    }
+    return islands;
+}
+/* ═══════════════════════════════════════════
+   Projection Functions
+   ═══════════════════════════════════════════ */
+function applyProjection(geometry, settings, selectedFaces) {
+    const posAttr = geometry.getAttribute('position');
+    let uvAttr = geometry.getAttribute('uv');
+    if (!uvAttr) {
+        uvAttr = new THREE__namespace.BufferAttribute(new Float32Array(posAttr.count * 2), 2);
+        geometry.setAttribute('uv', uvAttr);
+    }
+    const indices = selectedFaces !== null && selectedFaces !== void 0 ? selectedFaces : Array.from({ length: posAttr.count }, (_, i) => i);
+    switch (settings.type) {
+        case 'planar':
+            applyPlanarProjection(geometry, settings, indices);
+            break;
+        case 'cylindrical':
+            applyCylindricalProjection(geometry, settings, indices);
+            break;
+        case 'spherical':
+            applySphericalProjection(geometry, settings, indices);
+            break;
+        case 'box':
+            applyBoxProjection(geometry, settings, indices);
+            break;
+        default:
+            applyPlanarProjection(geometry, { ...settings, axis: 'z'}, indices);
+    }
+    uvAttr.needsUpdate = true;
+}
+function applyPlanarProjection(geometry, settings, indices) {
+    const posAttr = geometry.getAttribute('position');
+    const uvAttr = geometry.getAttribute('uv');
+    const { scale, offset, axis } = settings;
+    for (const i of indices) {
+        const x = posAttr.getX(i);
+        const y = posAttr.getY(i);
+        const z = posAttr.getZ(i);
+        let u, v;
+        switch (axis) {
+            case 'x':
+                u = (z - offset.z) * scale.z;
+                v = (y - offset.y) * scale.y;
+                break;
+            case 'y':
+                u = (x - offset.x) * scale.x;
+                v = (z - offset.z) * scale.z;
+                break;
+            case 'z':
+            default:
+                u = (x - offset.x) * scale.x;
+                v = (y - offset.y) * scale.y;
+                break;
+        }
+        uvAttr.setXY(i, u, v);
+    }
+}
+function applyCylindricalProjection(geometry, settings, indices) {
+    const posAttr = geometry.getAttribute('position');
+    const uvAttr = geometry.getAttribute('uv');
+    const { scale, offset, axis } = settings;
+    for (const i of indices) {
+        const x = posAttr.getX(i) - offset.x;
+        const y = posAttr.getY(i) - offset.y;
+        const z = posAttr.getZ(i) - offset.z;
+        let u, v;
+        switch (axis) {
+            case 'x':
+                u = (Math.atan2(z, y) / (2 * Math.PI) + 0.5) * scale.x;
+                v = x * scale.y;
+                break;
+            case 'y':
+                u = (Math.atan2(x, z) / (2 * Math.PI) + 0.5) * scale.x;
+                v = y * scale.y;
+                break;
+            case 'z':
+            default:
+                u = (Math.atan2(y, x) / (2 * Math.PI) + 0.5) * scale.x;
+                v = z * scale.y;
+                break;
+        }
+        uvAttr.setXY(i, u, v);
+    }
+}
+function applySphericalProjection(geometry, settings, indices) {
+    const posAttr = geometry.getAttribute('position');
+    const uvAttr = geometry.getAttribute('uv');
+    const { scale, offset } = settings;
+    for (const i of indices) {
+        const x = posAttr.getX(i) - offset.x;
+        const y = posAttr.getY(i) - offset.y;
+        const z = posAttr.getZ(i) - offset.z;
+        const r = Math.sqrt(x * x + y * y + z * z);
+        const theta = Math.acos(y / r);
+        const phi = Math.atan2(z, x);
+        const u = (phi / (2 * Math.PI) + 0.5) * scale.x;
+        const v = (theta / Math.PI) * scale.y;
+        uvAttr.setXY(i, u, v);
+    }
+}
+function applyBoxProjection(geometry, settings, indices) {
+    var _a, _b, _c;
+    const posAttr = geometry.getAttribute('position');
+    const normalAttr = geometry.getAttribute('normal');
+    const uvAttr = geometry.getAttribute('uv');
+    if (!normalAttr) {
+        geometry.computeVertexNormals();
+    }
+    const { scale, offset } = settings;
+    for (const i of indices) {
+        const x = posAttr.getX(i) - offset.x;
+        const y = posAttr.getY(i) - offset.y;
+        const z = posAttr.getZ(i) - offset.z;
+        const nx = Math.abs((_a = normalAttr === null || normalAttr === void 0 ? void 0 : normalAttr.getX(i)) !== null && _a !== void 0 ? _a : 0);
+        const ny = Math.abs((_b = normalAttr === null || normalAttr === void 0 ? void 0 : normalAttr.getY(i)) !== null && _b !== void 0 ? _b : 1);
+        const nz = Math.abs((_c = normalAttr === null || normalAttr === void 0 ? void 0 : normalAttr.getZ(i)) !== null && _c !== void 0 ? _c : 0);
+        let u, v;
+        if (nx >= ny && nx >= nz) {
+            // Project on YZ plane
+            u = z * scale.z;
+            v = y * scale.y;
+        }
+        else if (ny >= nx && ny >= nz) {
+            // Project on XZ plane
+            u = x * scale.x;
+            v = z * scale.z;
+        }
+        else {
+            // Project on XY plane
+            u = x * scale.x;
+            v = y * scale.y;
+        }
+        uvAttr.setXY(i, u, v);
+    }
+}
+/* ═══════════════════════════════════════════
+   UV Packing
+   ═══════════════════════════════════════════ */
+function packIslands(meshData, options) {
+    const transforms = new Map();
+    const islands = Array.from(meshData.islands.values());
+    if (islands.length === 0) {
+        return { transforms, utilization: 0, success: true, iterations: 0 };
+    }
+    // Sort islands by area (largest first) for better packing
+    if (options.areaPriority) {
+        islands.sort((a, b) => b.area - a.area);
+    }
+    // Simple shelf-based packing algorithm
+    const padding = options.padding / options.resolution;
+    const margin = options.margin;
+    let currentX = margin;
+    let currentY = margin;
+    let rowHeight = 0;
+    let maxX = 0;
+    let maxY = 0;
+    for (const island of islands) {
+        const size = getBoundsSize(island.bounds);
+        const width = size.u + padding * 2;
+        const height = size.v + padding * 2;
+        // Check if fits in current row
+        if (currentX + width > 1 - margin) {
+            // Move to next row
+            currentX = margin;
+            currentY += rowHeight + padding;
+            rowHeight = 0;
+        }
+        // Calculate translation to move island to current position
+        const translation = {
+            u: currentX + padding - island.bounds.minU,
+            v: currentY + padding - island.bounds.minV,
+        };
+        transforms.set(island.id, {
+            translation,
+            rotation: 0,
+            scale: 1,
+        });
+        currentX += width;
+        rowHeight = Math.max(rowHeight, height);
+        maxX = Math.max(maxX, currentX);
+        maxY = Math.max(maxY, currentY + height);
+    }
+    // Calculate utilization
+    const totalIslandArea = islands.reduce((sum, i) => sum + i.area, 0);
+    const usedArea = maxX * maxY;
+    const utilization = usedArea > 0 ? totalIslandArea / usedArea : 0;
+    return {
+        transforms,
+        utilization,
+        success: maxX <= 1 && maxY <= 1,
+        iterations: 1,
+    };
+}
+function applyIslandTransforms(meshData, transforms) {
+    for (const [islandId, transform] of transforms) {
+        const island = meshData.islands.get(islandId);
+        if (!island)
+            continue;
+        const center = island.center;
+        for (const vertexId of island.vertices) {
+            const vertex = meshData.vertices.get(vertexId);
+            if (!vertex)
+                continue;
+            let pos = vertex.position;
+            // Apply rotation around center
+            if (transform.rotation !== 0) {
+                pos = uvRotate(pos, transform.rotation, center);
+            }
+            // Apply scale from center
+            if (transform.scale !== 1) {
+                pos = {
+                    u: center.u + (pos.u - center.u) * transform.scale,
+                    v: center.v + (pos.v - center.v) * transform.scale,
+                };
+            }
+            // Apply translation
+            pos = uvAdd(pos, transform.translation);
+            vertex.position = pos;
+        }
+        // Update island bounds
+        let bounds = createEmptyBounds();
+        for (const vertexId of island.vertices) {
+            bounds = expandBounds(bounds, meshData.vertices.get(vertexId).position);
+        }
+        island.bounds = bounds;
+        island.center = getBoundsCenter(bounds);
+    }
+    meshData.dirty = true;
+}
+/* ═══════════════════════════════════════════
+   UV Relaxation
+   ═══════════════════════════════════════════ */
+function relaxUVs(meshData, options, selectedVertices) {
+    const verticesToRelax = selectedVertices !== null && selectedVertices !== void 0 ? selectedVertices : new Set(meshData.vertices.keys());
+    const affectedVertices = [];
+    for (let iter = 0; iter < options.iterations; iter++) {
+        for (const vertexId of verticesToRelax) {
+            const vertex = meshData.vertices.get(vertexId);
+            if (!vertex || (options.preservePinned && vertex.pinned))
+                continue;
+            // Find connected vertices
+            const neighbors = [];
+            for (const edge of meshData.edges.values()) {
+                if (edge.startVertex === vertexId) {
+                    neighbors.push(meshData.vertices.get(edge.endVertex).position);
+                }
+                else if (edge.endVertex === vertexId) {
+                    neighbors.push(meshData.vertices.get(edge.startVertex).position);
+                }
+            }
+            if (neighbors.length === 0)
+                continue;
+            // Move towards average of neighbors (Laplacian smoothing)
+            const avg = {
+                u: neighbors.reduce((s, n) => s + n.u, 0) / neighbors.length,
+                v: neighbors.reduce((s, n) => s + n.v, 0) / neighbors.length,
+            };
+            const factor = 0.5; // Relaxation factor
+            vertex.position = uvLerp(vertex.position, avg, factor);
+            if (!affectedVertices.includes(vertexId)) {
+                affectedVertices.push(vertexId);
+            }
+        }
+    }
+    meshData.dirty = true;
+    return {
+        success: true,
+        affectedVertices,
+    };
+}
+/* ═══════════════════════════════════════════
+   Selection Utilities
+   ═══════════════════════════════════════════ */
+function selectVerticesInRect(meshData, rect, additive = false) {
+    const selected = [];
+    for (const [id, vertex] of meshData.vertices) {
+        if (boundsContains(rect, vertex.position)) {
+            vertex.selected = true;
+            selected.push(id);
+        }
+        else if (!additive) {
+            vertex.selected = false;
+        }
+    }
+    return selected;
+}
+function selectIsland(meshData, islandId, additive = false) {
+    if (!additive) {
+        for (const v of meshData.vertices.values())
+            v.selected = false;
+        for (const e of meshData.edges.values())
+            e.selected = false;
+        for (const f of meshData.faces.values())
+            f.selected = false;
+        for (const i of meshData.islands.values())
+            i.selected = false;
+    }
+    const island = meshData.islands.get(islandId);
+    if (!island)
+        return;
+    island.selected = true;
+    for (const vId of island.vertices) {
+        const v = meshData.vertices.get(vId);
+        if (v)
+            v.selected = true;
+    }
+    for (const eId of island.edges) {
+        const e = meshData.edges.get(eId);
+        if (e)
+            e.selected = true;
+    }
+    for (const fId of island.faces) {
+        const f = meshData.faces.get(fId);
+        if (f)
+            f.selected = true;
+    }
+}
+function getSelectedVertices(meshData) {
+    return Array.from(meshData.vertices.values()).filter(v => v.selected);
+}
+function getSelectedIslands(meshData) {
+    return Array.from(meshData.islands.values()).filter(i => i.selected);
+}
+/* ═══════════════════════════════════════════
+   Seam Operations
+   ═══════════════════════════════════════════ */
+function markSeam(meshData, edgeId, isSeam) {
+    const edge = meshData.edges.get(edgeId);
+    if (edge) {
+        edge.seam = isSeam;
+        meshData.dirty = true;
+    }
+}
+function clearAllSeams(meshData) {
+    for (const edge of meshData.edges.values()) {
+        edge.seam = false;
+    }
+    meshData.dirty = true;
+}
+/* ═══════════════════════════════════════════
+   Sync Back to Geometry
+   ═══════════════════════════════════════════ */
+function syncToGeometry(meshData, geometry, channel = 'uv') {
+    const uvAttr = geometry.getAttribute(channel);
+    if (!uvAttr)
+        return;
+    for (const vertex of meshData.vertices.values()) {
+        uvAttr.setXY(vertex.index, vertex.position.u, vertex.position.v);
+    }
+    uvAttr.needsUpdate = true;
+    meshData.dirty = false;
+}
+
+exports.applyIslandTransforms = applyIslandTransforms;
+exports.applyProjection = applyProjection;
+exports.boundsContains = boundsContains;
+exports.boundsOverlap = boundsOverlap;
+exports.clearAllSeams = clearAllSeams;
+exports.computeIslands = computeIslands;
+exports.createEmptyBounds = createEmptyBounds;
+exports.expandBounds = expandBounds;
+exports.extractUVMeshData = extractUVMeshData;
+exports.generateId = generateId;
+exports.getBoundsArea = getBoundsArea;
+exports.getBoundsCenter = getBoundsCenter;
+exports.getBoundsSize = getBoundsSize;
+exports.getSelectedIslands = getSelectedIslands;
+exports.getSelectedVertices = getSelectedVertices;
+exports.markSeam = markSeam;
+exports.mergeBounds = mergeBounds;
+exports.packIslands = packIslands;
+exports.relaxUVs = relaxUVs;
+exports.selectIsland = selectIsland;
+exports.selectVerticesInRect = selectVerticesInRect;
+exports.syncToGeometry = syncToGeometry;
+exports.uvAdd = uvAdd;
+exports.uvCross = uvCross;
+exports.uvDistance = uvDistance;
+exports.uvLerp = uvLerp;
+exports.uvRotate = uvRotate;
+exports.uvScale = uvScale;
+exports.uvSub = uvSub;
+//# sourceMappingURL=uvEditorUtils.js.map