wuic-framework-lib 1.3.0 → 1.5.0

package/fesm2022/wuic-framework-lib-scene3d-light-baker-gpu-0LjqhSNn.mjs

@@ -0,0 +1,303 @@
+import * as THREE from 'three';
+import { i as isBakeableMesh, W as WUIC_BAKED_FLAG } from './wuic-framework-lib-scene3d-designer.component-BQzFxSXP.mjs';
+
+/**
+ * Lightmap baking su COMPUTE SHADER (WebGPU) — stessa semantica del baker CPU
+ * (`bakeVertexLighting`): lambert diffuso per ambient/directional/point/spot
+ * con attenuazione morbida e ombre opzionali, scritto nei vertex colors e
+ * materiale sostituito con MeshBasicMaterial unlit.
+ *
+ * La differenza e' DOVE gira il lavoro: un kernel TSL (un thread per vertice)
+ * calcola luce e occlusione; le ombre usano Moller-Trumbore brute-force sul
+ * triangle soup world-space di tutte le mesh bakabili. Il raycaster CPU e'
+ * O(V x L x T) sul main thread e blocca l'UI per secondi/minuti su scene
+ * dense; lo stesso lavoro in compute e' massicciamente parallelo.
+ *
+ * Richiede il renderer WebGPU attivo (`renderer.computeAsync`): il chiamante
+ * fa fallback sul baker CPU per WebGL o in caso d'errore.
+ */
+/** Oltre questo budget (vertici x luci x triangoli) il bake GPU rifiuta e si va di CPU. */
+const MAX_GPU_BAKE_WORK = 4e10;
+async function bakeVertexLightingGpu(renderer, content, lights, options) {
+    if (typeof renderer?.computeAsync !== 'function') {
+        throw new Error('bakeVertexLightingGpu: renderer senza computeAsync (serve WebGPURenderer)');
+    }
+    const webgpu = await import('three/webgpu');
+    const TSL = webgpu.TSL;
+    const { Fn, If, Loop, Break, instanceIndex, storage, float, vec3, vec4, uint } = TSL;
+    const meshes = [];
+    content.traverse((obj) => {
+        if (isBakeableMesh(obj)) {
+            meshes.push(obj);
+        }
+    });
+    if (meshes.length === 0) {
+        return { bakedMeshes: 0, totalVertices: 0 };
+    }
+    content.updateMatrixWorld(true);
+    // --- Vertici (world) di TUTTE le mesh in un unico buffer: un dispatch solo.
+    const ranges = [];
+    let vertexCount = 0;
+    for (const mesh of meshes) {
+        const geometry = mesh.geometry;
+        if (!geometry.getAttribute('normal')) {
+            geometry.computeVertexNormals();
+        }
+        const count = geometry.getAttribute('position').count;
+        ranges.push({ mesh, offset: vertexCount, count });
+        vertexCount += count;
+    }
+    const posArray = new Float32Array(vertexCount * 4);
+    const nrmArray = new Float32Array(vertexCount * 4);
+    const v = new THREE.Vector3();
+    const n = new THREE.Vector3();
+    const normalMatrix = new THREE.Matrix3();
+    for (const { mesh, offset } of ranges) {
+        const geometry = mesh.geometry;
+        const position = geometry.getAttribute('position');
+        const normal = geometry.getAttribute('normal');
+        normalMatrix.getNormalMatrix(mesh.matrixWorld);
+        for (let i = 0; i < position.count; i++) {
+            v.fromBufferAttribute(position, i).applyMatrix4(mesh.matrixWorld);
+            n.fromBufferAttribute(normal, i).applyMatrix3(normalMatrix).normalize();
+            const o = (offset + i) * 4;
+            posArray[o] = v.x;
+            posArray[o + 1] = v.y;
+            posArray[o + 2] = v.z;
+            posArray[o + 3] = 1;
+            nrmArray[o] = n.x;
+            nrmArray[o + 1] = n.y;
+            nrmArray[o + 2] = n.z;
+            nrmArray[o + 3] = 0;
+        }
+    }
+    // --- Triangle soup world-space per l'occlusione (solo con ombre attive).
+    let triCount = 0;
+    let triArray = new Float32Array(0);
+    if (options.shadows) {
+        const triPositions = [];
+        const a = new THREE.Vector3();
+        const b = new THREE.Vector3();
+        const c = new THREE.Vector3();
+        for (const { mesh } of ranges) {
+            const geometry = mesh.geometry;
+            const position = geometry.getAttribute('position');
+            const index = geometry.getIndex();
+            const faces = index ? index.count / 3 : position.count / 3;
+            for (let f = 0; f < faces; f++) {
+                const i0 = index ? index.getX(f * 3) : f * 3;
+                const i1 = index ? index.getX(f * 3 + 1) : f * 3 + 1;
+                const i2 = index ? index.getX(f * 3 + 2) : f * 3 + 2;
+                a.fromBufferAttribute(position, i0).applyMatrix4(mesh.matrixWorld);
+                b.fromBufferAttribute(position, i1).applyMatrix4(mesh.matrixWorld);
+                c.fromBufferAttribute(position, i2).applyMatrix4(mesh.matrixWorld);
+                triPositions.push(a.x, a.y, a.z, 0, b.x, b.y, b.z, 0, c.x, c.y, c.z, 0);
+            }
+        }
+        triArray = new Float32Array(triPositions);
+        triCount = triArray.length / 12;
+    }
+    // --- Luci: pre-risolte su CPU con la STESSA semantica di gatherLight.
+    // A=[type, effIntensity, cosOuter, spotDenom] B=[rgb,0]
+    // C=dir: versore VERSO la luce | point/spot: posizione world  D=direzione cono spot.
+    const packedA = [];
+    const packedB = [];
+    const packedC = [];
+    const packedD = [];
+    const lightPos = new THREE.Vector3();
+    const targetPos = new THREE.Vector3();
+    const dir = new THREE.Vector3();
+    let lightCount = 0;
+    for (const light of lights) {
+        if (!light.visible) {
+            continue;
+        }
+        if (light.isAmbientLight) {
+            packedA.push(0, light.intensity, 0, 0);
+            packedB.push(light.color.r, light.color.g, light.color.b, 0);
+            packedC.push(0, 0, 0, 0);
+            packedD.push(0, 0, 0, 0);
+        }
+        else if (light.isDirectionalLight) {
+            const dl = light;
+            dl.getWorldPosition(lightPos);
+            dl.target.getWorldPosition(targetPos);
+            dir.subVectors(lightPos, targetPos).normalize();
+            packedA.push(1, light.intensity, 0, 0);
+            packedB.push(light.color.r, light.color.g, light.color.b, 0);
+            packedC.push(dir.x, dir.y, dir.z, 0);
+            packedD.push(0, 0, 0, 0);
+        }
+        else if (light.isPointLight || light.isSpotLight) {
+            light.getWorldPosition(lightPos);
+            const isSpot = !!light.isSpotLight;
+            let cosOuter = -2;
+            let spotDenom = 1;
+            let effIntensity = light.intensity;
+            if (isSpot) {
+                const spot = light;
+                spot.target.getWorldPosition(targetPos);
+                dir.subVectors(targetPos, lightPos).normalize();
+                cosOuter = Math.cos(spot.angle);
+                const cosInner = Math.cos(spot.angle * (1 - spot.penumbra));
+                spotDenom = Math.max(cosInner - cosOuter, 1e-6);
+                // Fattore 0.12 (unita' candela leggibili) ripiegato nell'intensita'.
+                effIntensity *= 0.12;
+                packedD.push(dir.x, dir.y, dir.z, 0);
+            }
+            else {
+                packedD.push(0, 0, 0, 0);
+            }
+            packedA.push(isSpot ? 3 : 2, effIntensity, cosOuter, spotDenom);
+            packedB.push(light.color.r, light.color.g, light.color.b, 0);
+            packedC.push(lightPos.x, lightPos.y, lightPos.z, 0);
+        }
+        else {
+            continue; // tipi non supportati dal bake
+        }
+        lightCount++;
+    }
+    if (lightCount === 0) {
+        // Nessuna luce supportata: colori a zero, la CPU farebbe lo stesso.
+        return applyBakeResults(ranges, new Float32Array(vertexCount * 4));
+    }
+    const shadowWork = options.shadows ? vertexCount * lightCount * Math.max(triCount, 1) : vertexCount * lightCount;
+    if (shadowWork > MAX_GPU_BAKE_WORK) {
+        throw new Error(`bakeVertexLightingGpu: scena oltre il budget GPU (${shadowWork.toExponential(1)})`);
+    }
+    // --- Storage buffer + kernel TSL.
+    const positionsAttr = new webgpu.StorageBufferAttribute(posArray, 4);
+    const normalsAttr = new webgpu.StorageBufferAttribute(nrmArray, 4);
+    const trianglesAttr = new webgpu.StorageBufferAttribute(triCount > 0 ? triArray : new Float32Array(4), 4);
+    const lightsAAttr = new webgpu.StorageBufferAttribute(new Float32Array(packedA), 4);
+    const lightsBAttr = new webgpu.StorageBufferAttribute(new Float32Array(packedB), 4);
+    const lightsCAttr = new webgpu.StorageBufferAttribute(new Float32Array(packedC), 4);
+    const lightsDAttr = new webgpu.StorageBufferAttribute(new Float32Array(packedD), 4);
+    const colorsAttr = new webgpu.StorageBufferAttribute(new Float32Array(vertexCount * 4), 4);
+    const positions = storage(positionsAttr, 'vec4', vertexCount).toReadOnly();
+    const normals = storage(normalsAttr, 'vec4', vertexCount).toReadOnly();
+    const triangles = storage(trianglesAttr, 'vec4', Math.max(triCount * 3, 1)).toReadOnly();
+    const lightsA = storage(lightsAAttr, 'vec4', lightCount).toReadOnly();
+    const lightsB = storage(lightsBAttr, 'vec4', lightCount).toReadOnly();
+    const lightsC = storage(lightsCAttr, 'vec4', lightCount).toReadOnly();
+    const lightsD = storage(lightsDAttr, 'vec4', lightCount).toReadOnly();
+    const colors = storage(colorsAttr, 'vec4', vertexCount);
+    const withShadows = options.shadows && triCount > 0;
+    const kernel = Fn(() => {
+        If(instanceIndex.lessThan(uint(vertexCount)), () => {
+            const P = positions.element(instanceIndex).xyz.toVar();
+            const N = normals.element(instanceIndex).xyz.toVar();
+            const acc = vec3(0).toVar();
+            Loop(lightCount, ({ i: li }) => {
+                const A = lightsA.element(li).toVar();
+                const B = lightsB.element(li).xyz.toVar();
+                const lightType = A.x;
+                const intensity = A.y;
+                If(lightType.lessThan(0.5), () => {
+                    // Ambient: contributo piatto.
+                    acc.addAssign(B.mul(intensity));
+                }).Else(() => {
+                    const lambert = float(0).toVar();
+                    const atten = float(1).toVar();
+                    const toLight = vec3(0, 1, 0).toVar();
+                    const shadowDist = float(1e9).toVar();
+                    const skip = float(0).toVar();
+                    If(lightType.lessThan(1.5), () => {
+                        // Directional: C = versore verso la luce.
+                        toLight.assign(lightsC.element(li).xyz);
+                        lambert.assign(N.dot(toLight).max(0));
+                    }).Else(() => {
+                        // Point/Spot: C = posizione world della luce.
+                        const dvec = lightsC.element(li).xyz.sub(P).toVar();
+                        const dist = dvec.length().toVar();
+                        If(dist.lessThanEqual(1e-6), () => {
+                            skip.assign(1);
+                        }).Else(() => {
+                            toLight.assign(dvec.div(dist));
+                            lambert.assign(N.dot(toLight).max(0));
+                            // Attenuazione morbida (non fisica), come il baker CPU.
+                            atten.assign(float(1).div(dist.mul(dist).mul(0.08).add(1)));
+                            shadowDist.assign(dist);
+                            If(lightType.greaterThan(2.5), () => {
+                                // Spot: A.z = cosOuter, A.w = denom (cosInner - cosOuter).
+                                const coneDir = lightsD.element(li).xyz;
+                                const cosAngle = toLight.negate().dot(coneDir).toVar();
+                                If(cosAngle.lessThanEqual(A.z), () => {
+                                    skip.assign(1); // fuori dal cono
+                                }).Else(() => {
+                                    const spotFactor = cosAngle.sub(A.z).div(A.w).clamp(0, 1);
+                                    atten.mulAssign(spotFactor);
+                                });
+                            });
+                        });
+                    });
+                    If(skip.lessThan(0.5).and(lambert.greaterThan(0)).and(atten.greaterThan(0)), () => {
+                        const lit = float(1).toVar();
+                        if (withShadows) {
+                            // Raggio d'ombra Moller-Trumbore brute-force sul triangle soup.
+                            const origin = P.add(N.mul(0.02)).toVar();
+                            const maxT = shadowDist.sub(0.04).min(1000).toVar();
+                            Loop(triCount, ({ i: ti }) => {
+                                const base = ti.mul(3);
+                                const v0 = triangles.element(base).xyz;
+                                const e1 = triangles.element(base.add(1)).xyz.sub(v0).toVar();
+                                const e2 = triangles.element(base.add(2)).xyz.sub(v0).toVar();
+                                const h = toLight.cross(e2).toVar();
+                                const det = e1.dot(h).toVar();
+                                If(det.abs().greaterThan(1e-7), () => {
+                                    const f = float(1).div(det);
+                                    const s = origin.sub(v0).toVar();
+                                    const u = f.mul(s.dot(h)).toVar();
+                                    If(u.greaterThanEqual(0).and(u.lessThanEqual(1)), () => {
+                                        const q = s.cross(e1).toVar();
+                                        const w = f.mul(toLight.dot(q)).toVar();
+                                        If(w.greaterThanEqual(0).and(u.add(w).lessThanEqual(1)), () => {
+                                            const t = f.mul(e2.dot(q));
+                                            If(t.greaterThan(0.001).and(t.lessThan(maxT)), () => {
+                                                lit.assign(0);
+                                                Break();
+                                            });
+                                        });
+                                    });
+                                });
+                            });
+                        }
+                        acc.addAssign(B.mul(intensity.mul(lambert).mul(atten).mul(lit)));
+                    });
+                });
+            });
+            // Clamp morbido per non bruciare (tone-map naive, come CPU).
+            colors.element(instanceIndex).assign(vec4(acc.min(1), 1));
+        });
+    });
+    await renderer.computeAsync(kernel().compute(vertexCount));
+    const resultBuffer = await renderer.getArrayBufferAsync(colorsAttr);
+    return applyBakeResults(ranges, new Float32Array(resultBuffer));
+}
+/** Scrive i colori calcolati nei vertex colors e applica il materiale unlit (mirror del baker CPU). */
+function applyBakeResults(ranges, packedColors) {
+    let totalVertices = 0;
+    for (const { mesh, offset, count } of ranges) {
+        const geometry = mesh.geometry;
+        const colors = new Float32Array(count * 3);
+        for (let i = 0; i < count; i++) {
+            const src = (offset + i) * 4;
+            colors[i * 3] = packedColors[src];
+            colors[i * 3 + 1] = packedColors[src + 1];
+            colors[i * 3 + 2] = packedColors[src + 2];
+        }
+        geometry.setAttribute('color', new THREE.BufferAttribute(colors, 3));
+        const orig = Array.isArray(mesh.material) ? mesh.material[0] : mesh.material;
+        mesh.material = new THREE.MeshBasicMaterial({
+            color: orig?.color instanceof THREE.Color ? orig.color.clone() : new THREE.Color(0xffffff),
+            map: orig?.map || null,
+            vertexColors: true
+        });
+        mesh.userData[WUIC_BAKED_FLAG] = true;
+        totalVertices += count;
+    }
+    return { bakedMeshes: ranges.length, totalVertices };
+}
+
+export { bakeVertexLightingGpu };
+//# sourceMappingURL=wuic-framework-lib-scene3d-light-baker-gpu-0LjqhSNn.mjs.map