@holoscript/core 6.0.4 → 7.0.0

package/dist/chunk-G4VZTCIB.js

@@ -1,659 +0,0 @@
-import { init_DomainBlockCompilerMixin, compileDomainBlocks, compileMaterialBlock, materialToWebGPU } from './chunk-YQK5JNFK.js';
-import { init_CompilerBase, CompilerBase } from './chunk-6XSERL6L.js';
-import { __export, __esm } from './chunk-2CWOLHTE.js';
-import { ANSCapabilityPath } from '@holoscript/platform';
-
-// src/compiler/WebGPUCompiler.ts
-var WebGPUCompiler_exports = {};
-__export(WebGPUCompiler_exports, {
-  WebGPUCompiler: () => WebGPUCompiler
-});
-var WebGPUCompiler;
-var init_WebGPUCompiler = __esm({
-  "src/compiler/WebGPUCompiler.ts"() {
-    init_CompilerBase();
-    init_DomainBlockCompilerMixin();
-    WebGPUCompiler = class extends CompilerBase {
-      constructor(options = {}) {
-        super();
-        this.compilerName = "WebGPUCompiler";
-        this.lines = [];
-        this.indentLevel = 0;
-        this.objectIndex = 0;
-        this.options = {
-          entryPoint: options.entryPoint || "main",
-          enableCompute: options.enableCompute ?? true,
-          msaa: options.msaa || 4,
-          indent: options.indent || "  "
-        };
-      }
-      getRequiredCapability() {
-        return ANSCapabilityPath.WEBGPU;
-      }
-      compile(composition, agentToken, outputPath) {
-        this.validateCompilerAccess(agentToken, outputPath);
-        this.lines = [];
-        this.indentLevel = 0;
-        this.objectIndex = 0;
-        this.emit("// Auto-generated by HoloScript WebGPUCompiler");
-        this.emit(
-          `// Source: composition "${this.escapeStringValue(composition.name, "TypeScript")}"`
-        );
-        this.emit("// Do not edit manually \u2014 regenerate from .holo source");
-        this.emit("");
-        this.emitDeviceInit();
-        if (composition.environment) this.emitEnvironment(composition.environment);
-        if (composition.objects) {
-          for (const obj of composition.objects) this.emitObject(obj);
-        }
-        if (composition.spatialGroups) {
-          for (const group of composition.spatialGroups) this.emitGroup(group);
-        }
-        if (composition.lights) {
-          for (const light of composition.lights) this.emitLight(light);
-        }
-        if (composition.camera) this.emitCamera(composition.camera);
-        if (this.options.enableCompute) this.emitComputeShaders(composition);
-        this.emitWebGPUDomainBlocks(composition);
-        this.emitShaderSources();
-        this.emitRenderLoop(composition);
-        return this.lines.join("\n");
-      }
-      emitWebGPUDomainBlocks(composition) {
-        const domainBlocks = composition.domainBlocks ?? [];
-        if (domainBlocks.length === 0) return;
-        this.emit("");
-        this.emit("// === v4.2 Domain Blocks ===");
-        let blockIdx = 0;
-        const compiled = compileDomainBlocks(
-          domainBlocks,
-          {
-            material: (block) => {
-              const mat = compileMaterialBlock(block);
-              return materialToWebGPU(mat, `db${blockIdx++}`);
-            }
-          },
-          (block) => `// Domain block: ${block.domain}/${block.keyword} "${this.escapeStringValue(block.name, "TypeScript")}"`
-        );
-        for (const line of compiled) {
-          for (const l of line.split("\n")) {
-            this.emit(l);
-          }
-        }
-      }
-      // ─── Device Init ──────────────────────────────────────────────────────────
-      emitDeviceInit() {
-        this.emit("// === WebGPU Device Initialization ===");
-        this.emit('const canvas = document.querySelector("canvas") as HTMLCanvasElement;');
-        this.emit("const adapter = await navigator.gpu.requestAdapter();");
-        this.emit('if (!adapter) throw new Error("WebGPU not supported");');
-        this.emit("const device = await adapter.requestDevice();");
-        this.emit('const context = canvas.getContext("webgpu") as GPUCanvasContext;');
-        this.emit("const format = navigator.gpu.getPreferredCanvasFormat();");
-        this.emit('context.configure({ device, format, alphaMode: "premultiplied" });');
-        this.emit(`const MSAA_COUNT = ${this.options.msaa};`);
-        this.emit(
-          "const msaaTexture = device.createTexture({ size: [canvas.width, canvas.height], sampleCount: MSAA_COUNT, format, usage: GPUTextureUsage.RENDER_ATTACHMENT });"
-        );
-        this.emit(
-          'const depthTexture = device.createTexture({ size: [canvas.width, canvas.height], sampleCount: MSAA_COUNT, format: "depth24plus", usage: GPUTextureUsage.RENDER_ATTACHMENT });'
-        );
-        this.emit("");
-        this.emit(
-          "function createBuffer(device: GPUDevice, data: Float32Array, usage: number): GPUBuffer {"
-        );
-        this.indent();
-        this.emit(
-          "const buf = device.createBuffer({ size: data.byteLength, usage: usage | GPUBufferUsage.COPY_DST });"
-        );
-        this.emit("device.queue.writeBuffer(buf, 0, data); return buf;");
-        this.dedent();
-        this.emit("}");
-        this.emit("function createStorageBuffer(device: GPUDevice, size: number): GPUBuffer {");
-        this.indent();
-        this.emit(
-          "return device.createBuffer({ size, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST });"
-        );
-        this.dedent();
-        this.emit("}");
-        this.emit("");
-      }
-      // ─── Environment ──────────────────────────────────────────────────────────
-      emitEnvironment(env) {
-        this.emit("// === Environment ===");
-        const envData = {};
-        for (const prop of env.properties) envData[prop.key] = prop.value;
-        const bg = envData.background || envData.skybox || "#000000";
-        const bgColor = this.parseColor(bg);
-        this.emit(
-          `const clearColor: GPUColor = { r: ${bgColor[0]}, g: ${bgColor[1]}, b: ${bgColor[2]}, a: 1.0 };`
-        );
-        if (envData.fog && typeof envData.fog === "object") {
-          const fog = envData.fog;
-          const fc = this.parseColor(fog.color || "#cccccc");
-          this.emit(
-            `const fogUniforms = createBuffer(device, new Float32Array([${fc[0]}, ${fc[1]}, ${fc[2]}, 1.0, ${fog.near ?? 10}, ${fog.far ?? 100}, 0.0, 0.0]), GPUBufferUsage.UNIFORM);`
-          );
-        }
-        if (envData.ambient_light !== void 0) {
-          this.emit(
-            `const ambientIntensity = ${typeof envData.ambient_light === "number" ? envData.ambient_light : 0.5};`
-          );
-        }
-        this.emit("");
-      }
-      // ─── Object ───────────────────────────────────────────────────────────────
-      emitObject(obj) {
-        this.objectIndex++;
-        const v = this.sanitizeName(obj.name);
-        const meshType = this.findObjProp(obj, "geometry") || this.findObjProp(obj, "mesh") || this.findObjProp(obj, "type") || "cube";
-        const modelSrc = this.findObjProp(obj, "source") || this.findObjProp(obj, "src") || this.findObjProp(obj, "model");
-        const isModel = meshType === "model" || !!modelSrc;
-        const traits = obj.traits || [];
-        this.emit(`// Object: ${this.escapeStringValue(obj.name, "TypeScript")}`);
-        const isGaussianSplat = traits.some((t) => t.name === "gaussian_splat");
-        const isPointCloud = traits.some((t) => t.name === "point_cloud");
-        const isGpuParticle = traits.some((t) => t.name === "gpu_particle");
-        if (isModel && modelSrc) {
-          this.emit(`const ${v}Model = await assetLoader.load("${modelSrc}");`);
-          const pos = this.findObjProp(obj, "position");
-          const [px, py, pz] = Array.isArray(pos) ? pos : [0, 0, 0];
-          this.emit(
-            `const ${v}ModelMatrix = createBuffer(device, new Float32Array([1,0,0,0, 0,1,0,0, 0,0,1,0, ${px},${py},${pz},1]), GPUBufferUsage.UNIFORM);`
-          );
-        } else if (isModel) {
-          this.emit(`// WARNING: geometry "model" without source URL \u2014 placeholder cube`);
-          this.emitMeshObject(v, obj, "cube");
-        } else if (isGaussianSplat) {
-          this.emitGaussianSplatObject(v, obj);
-        } else if (isPointCloud) {
-          this.emitPointCloudObject(v, obj);
-        } else if (isGpuParticle) {
-          this.emitGpuParticleObject(v, obj);
-        } else {
-          this.emitMeshObject(v, obj, meshType);
-        }
-        if (traits.some((t) => t.name === "gpu_physics")) {
-          this.emit(`const ${v}PhysicsBuf = createStorageBuffer(device, 1024 * 16); // gpu_physics`);
-        }
-        if (traits.some((t) => t.name === "compute" || t.name === "gpu_buffer")) {
-          const ct = traits.find((t) => t.name === "compute" || t.name === "gpu_buffer");
-          this.emit(
-            `const ${v}ComputeBuf = createStorageBuffer(device, ${ct?.config?.buffer_size || 4096});`
-          );
-        }
-        this.emit("");
-        if (obj.children) {
-          for (const child of obj.children) this.emitObject(child);
-        }
-      }
-      emitMeshObject(v, obj, meshType) {
-        this.emit(`const ${v}Vertices = ${this.geometryVertexDataFn(meshType)};`);
-        this.emit(`const ${v}VBO = createBuffer(device, ${v}Vertices, GPUBufferUsage.VERTEX);`);
-        this.emit(`const ${v}VertexCount = ${v}Vertices.length / 6;`);
-        const pos = this.findObjProp(obj, "position");
-        const scale = this.findObjProp(obj, "scale") || this.findObjProp(obj, "size");
-        const [px, py, pz] = Array.isArray(pos) ? pos : [0, 0, 0];
-        const [sx, sy, sz] = Array.isArray(scale) ? scale : typeof scale === "number" ? [scale, scale, scale] : [1, 1, 1];
-        this.emit(
-          `const ${v}Model = createBuffer(device, new Float32Array([${sx},0,0,0, 0,${sy},0,0, 0,0,${sz},0, ${px},${py},${pz},1]), GPUBufferUsage.UNIFORM);`
-        );
-        const material = this.findObjProp(obj, "material");
-        const color = this.findObjProp(obj, "color");
-        const [cr, cg, cb] = this.extractMaterialColor(material, color);
-        const rough = this.extractMaterialProp(material, "roughness", 0.5);
-        const metal = this.extractMaterialProp(material, "metalness", 0);
-        this.emit(
-          `const ${v}Mat = createBuffer(device, new Float32Array([${cr},${cg},${cb},1.0, ${rough},${metal},0,0]), GPUBufferUsage.UNIFORM);`
-        );
-        this.emit(`const ${v}Pipeline = device.createRenderPipeline({`);
-        this.indent();
-        this.emit('layout: "auto",');
-        this.emit(
-          'vertex: { module: device.createShaderModule({ code: WGSL_VERTEX }), entryPoint: "vs_main",'
-        );
-        this.emit(
-          '  buffers: [{ arrayStride: 24, attributes: [{ shaderLocation: 0, offset: 0, format: "float32x3" }, { shaderLocation: 1, offset: 12, format: "float32x3" }] }] },'
-        );
-        this.emit(
-          'fragment: { module: device.createShaderModule({ code: WGSL_FRAGMENT }), entryPoint: "fs_main", targets: [{ format }] },'
-        );
-        this.emit('primitive: { topology: "triangle-list", cullMode: "back" },');
-        this.emit(
-          `depthStencil: { format: "depth24plus", depthWriteEnabled: true, depthCompare: "less" }, multisample: { count: MSAA_COUNT },`
-        );
-        this.dedent();
-        this.emit("});");
-        this.emit(
-          `const ${v}Bind = device.createBindGroup({ layout: ${v}Pipeline.getBindGroupLayout(0), entries: [`
-        );
-        this.emit(
-          `  { binding: 0, resource: { buffer: ${v}Model } }, { binding: 1, resource: { buffer: ${v}Mat } }] });`
-        );
-      }
-      emitGaussianSplatObject(v, obj) {
-        const trait = obj.traits?.find((t) => t.name === "gaussian_splat");
-        const src = trait?.config?.src || "scene.ply";
-        const max = trait?.config?.max_splats || 5e5;
-        const sorted = trait?.config?.sorted !== false;
-        this.emit(`// Gaussian Splat \u2014 source: ${src} (${sorted ? "radix-sorted" : "unsorted"})`);
-        if (sorted) {
-          this.emit(
-            `// === Wait-Free Radix Sort Pipeline (4x 8-bit Blelloch scan, no global atomics) ===`
-          );
-          this.emit(`import { GaussianSplatSorter } from '@holoscript/core/gpu/GaussianSplatSorter';`);
-          this.emit(`const ${v}Sorter = new GaussianSplatSorter(device, {`);
-          this.indent();
-          this.emit(`maxSplats: ${max},`);
-          this.emit(`canvasWidth: canvas.width,`);
-          this.emit(`canvasHeight: canvas.height,`);
-          this.dedent();
-          this.emit(`});`);
-          this.emit(`await ${v}Sorter.initialize();`);
-          this.emit(`const ${v}SplatCount = { value: 0 };`);
-        } else {
-          this.emit(`const ${v}SplatBuf = createStorageBuffer(device, ${max} * 32);`);
-          this.emit(`const ${v}SplatCount = { value: 0 };`);
-          this.emit(`const ${v}SplatPipeline = device.createRenderPipeline({`);
-          this.indent();
-          this.emit('layout: "auto",');
-          this.emit(
-            'vertex: { module: device.createShaderModule({ code: WGSL_SPLAT }), entryPoint: "vs_splat", buffers: [] },'
-          );
-          this.emit(
-            'fragment: { module: device.createShaderModule({ code: WGSL_SPLAT }), entryPoint: "fs_splat",'
-          );
-          this.emit(
-            '  targets: [{ format, blend: { color: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" }, alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" } } }] },'
-          );
-          this.emit('primitive: { topology: "triangle-strip" },');
-          this.emit(
-            'depthStencil: { format: "depth24plus", depthWriteEnabled: false, depthCompare: "less" },'
-          );
-          this.dedent();
-          this.emit("});");
-        }
-      }
-      emitPointCloudObject(v, obj) {
-        const trait = obj.traits?.find((t) => t.name === "point_cloud");
-        const max = trait?.config?.max_points || 1e5;
-        this.emit(`// Point Cloud (${max} max points)`);
-        this.emit(`const ${v}PointBuf = createStorageBuffer(device, ${max} * 16);`);
-        this.emit(`const ${v}PointCount = { value: 0 };`);
-        this.emit(`const ${v}PointPipeline = device.createRenderPipeline({`);
-        this.indent();
-        this.emit('layout: "auto",');
-        this.emit(
-          'vertex: { module: device.createShaderModule({ code: WGSL_POINT }), entryPoint: "vs_point",'
-        );
-        this.emit(
-          '  buffers: [{ arrayStride: 16, attributes: [{ shaderLocation: 0, offset: 0, format: "float32x3" }, { shaderLocation: 1, offset: 12, format: "unorm8x4" }] }] },'
-        );
-        this.emit(
-          'fragment: { module: device.createShaderModule({ code: WGSL_POINT }), entryPoint: "fs_point", targets: [{ format }] },'
-        );
-        this.emit(
-          `primitive: { topology: "point-list" }, depthStencil: { format: "depth24plus", depthWriteEnabled: true, depthCompare: "less" }, multisample: { count: MSAA_COUNT },`
-        );
-        this.dedent();
-        this.emit("});");
-      }
-      emitGpuParticleObject(v, obj) {
-        const trait = obj.traits?.find((t) => t.name === "gpu_particle");
-        const count = trait?.config?.count || 1e4;
-        this.emit(`// GPU Particles (${count})`);
-        this.emit(`const ${v}ParticleCount = ${count};`);
-        this.emit(`const ${v}ParticleBufA = createStorageBuffer(device, ${v}ParticleCount * 32);`);
-        this.emit(`const ${v}ParticleBufB = createStorageBuffer(device, ${v}ParticleCount * 32);`);
-        this.emit(`const ${v}ParticlePipeline = device.createRenderPipeline({`);
-        this.indent();
-        this.emit('layout: "auto",');
-        this.emit(
-          'vertex: { module: device.createShaderModule({ code: WGSL_PARTICLE_RENDER }), entryPoint: "vs_particle",'
-        );
-        this.emit(
-          '  buffers: [{ arrayStride: 32, attributes: [{ shaderLocation: 0, offset: 0, format: "float32x3" }, { shaderLocation: 1, offset: 12, format: "float32x3" }, { shaderLocation: 2, offset: 24, format: "float32" }] }] },'
-        );
-        this.emit(
-          'fragment: { module: device.createShaderModule({ code: WGSL_PARTICLE_RENDER }), entryPoint: "fs_particle",'
-        );
-        this.emit(
-          '  targets: [{ format, blend: { color: { srcFactor: "src-alpha", dstFactor: "one", operation: "add" }, alpha: { srcFactor: "zero", dstFactor: "one", operation: "add" } } }] },'
-        );
-        this.emit(
-          'primitive: { topology: "point-list" }, depthStencil: { format: "depth24plus", depthWriteEnabled: false, depthCompare: "less" },'
-        );
-        this.dedent();
-        this.emit("});");
-      }
-      // ─── Spatial Group ────────────────────────────────────────────────────────
-      emitGroup(group) {
-        const v = this.sanitizeName(group.name);
-        this.emit(`// Spatial Group: ${this.escapeStringValue(group.name, "TypeScript")}`);
-        const pos = group.properties.find((p) => p.key === "position")?.value;
-        const [px, py, pz] = Array.isArray(pos) ? pos : [0, 0, 0];
-        this.emit(
-          `const ${v}GroupXform = createBuffer(device, new Float32Array([1,0,0,0, 0,1,0,0, 0,0,1,0, ${px},${py},${pz},1]), GPUBufferUsage.UNIFORM);`
-        );
-        for (const obj of group.objects) this.emitObject(obj);
-        if (group.groups) {
-          for (const sub of group.groups) this.emitGroup(sub);
-        }
-        this.emit("");
-      }
-      // ─── Light ────────────────────────────────────────────────────────────────
-      emitLight(light) {
-        const v = this.sanitizeName(light.name);
-        let color = [1, 1, 1], intensity = 1, pos = [0, 10, 0], dir = [0, -1, 0];
-        for (const prop of light.properties) {
-          if (prop.key === "color") color = this.parseColor(prop.value);
-          else if (prop.key === "intensity") intensity = prop.value;
-          else if (prop.key === "position" && Array.isArray(prop.value)) pos = prop.value;
-          else if (prop.key === "direction" && Array.isArray(prop.value)) dir = prop.value;
-        }
-        const ti = { directional: 0, point: 1, spot: 2, hemisphere: 3, ambient: 4, area: 5 }[light.lightType] ?? 0;
-        this.emit(
-          `// Light: ${this.escapeStringValue(light.name, "TypeScript")} (${light.lightType})`
-        );
-        this.emit(
-          `const ${v}Light = createBuffer(device, new Float32Array([${color[0] * intensity},${color[1] * intensity},${color[2] * intensity},${ti}, ${pos[0]},${pos[1]},${pos[2]},0, ${dir[0]},${dir[1]},${dir[2]},0]), GPUBufferUsage.UNIFORM);`
-        );
-        this.emit("");
-      }
-      // ─── Camera ───────────────────────────────────────────────────────────────
-      emitCamera(cam) {
-        this.emit("// === Camera ===");
-        let fov = 60, near = 0.1, far = 1e3, pos = [0, 1, 5], lookAt = [0, 0, 0];
-        for (const prop of cam.properties) {
-          if (prop.key === "fov" || prop.key === "field_of_view") fov = prop.value;
-          else if (prop.key === "near") near = prop.value;
-          else if (prop.key === "far") far = prop.value;
-          else if (prop.key === "position" && Array.isArray(prop.value)) pos = prop.value;
-          else if ((prop.key === "look_at" || prop.key === "lookAt") && Array.isArray(prop.value))
-            lookAt = prop.value;
-        }
-        this.emit(`const cameraFov = ${fov} * Math.PI / 180;`);
-        this.emit(`const cameraNear = ${near}, cameraFar = ${far};`);
-        this.emit(`const cameraPos = new Float32Array([${pos.join(",")}]);`);
-        this.emit(`const cameraTarget = new Float32Array([${lookAt.join(",")}]);`);
-        this.emit("const aspect = canvas.width / canvas.height;");
-        this.emit("function buildViewProjection(): Float32Array {");
-        this.indent();
-        this.emit("const f = 1.0 / Math.tan(cameraFov / 2), ri = 1.0 / (cameraNear - cameraFar);");
-        this.emit(
-          "return new Float32Array([f/aspect,0,0,0, 0,f,0,0, 0,0,(cameraNear+cameraFar)*ri,-1, 0,0,cameraNear*cameraFar*ri*2,0]);"
-        );
-        this.dedent();
-        this.emit("}");
-        this.emit(
-          "const vpUniform = createBuffer(device, buildViewProjection(), GPUBufferUsage.UNIFORM);"
-        );
-        this.emit("");
-      }
-      // ─── Compute Pipelines ────────────────────────────────────────────────────
-      emitComputeShaders(composition) {
-        const gpuObjs = (composition.objects || []).filter(
-          (o) => o.traits?.some(
-            (t) => t.name === "gpu_particle" || t.name === "gpu_physics" || t.name === "compute"
-          )
-        );
-        if (gpuObjs.length === 0) return;
-        this.emit("// === Compute Pipelines ===");
-        for (const obj of gpuObjs) {
-          const v = this.sanitizeName(obj.name);
-          const traits = obj.traits || [];
-          if (traits.some((t) => t.name === "gpu_particle")) {
-            const count = traits.find((t) => t.name === "gpu_particle")?.config?.count || 1e4;
-            this.emit(
-              `const ${v}ParticleCompute = device.createComputePipeline({ layout: "auto", compute: { module: device.createShaderModule({ code: WGSL_PARTICLE_COMPUTE }), entryPoint: "cs_particle_update" } });`
-            );
-            this.emit(`const ${v}ComputeDispatches = ${Math.ceil(count / 64)};`);
-          }
-          if (traits.some((t) => t.name === "gpu_physics")) {
-            this.emit(
-              `const ${v}PhysicsCompute = device.createComputePipeline({ layout: "auto", compute: { module: device.createShaderModule({ code: WGSL_PHYSICS_COMPUTE }), entryPoint: "cs_physics_step" } });`
-            );
-          }
-          if (traits.some((t) => t.name === "compute")) {
-            const ct = traits.find((t) => t.name === "compute");
-            const entry = ct?.config?.shader || "custom_compute";
-            const wg = ct?.config?.workgroups || [64, 1, 1];
-            this.emit(
-              `const ${v}CustomCompute = device.createComputePipeline({ layout: "auto", compute: { module: device.createShaderModule({ code: WGSL_CUSTOM_${v.toUpperCase()} }), entryPoint: "${entry}" } });`
-            );
-            this.emit(`const ${v}Workgroups: [number, number, number] = [${wg}];`);
-          }
-        }
-        this.emit("");
-      }
-      // ─── WGSL Shader Sources ──────────────────────────────────────────────────
-      emitShaderSources() {
-        this.emit("// === WGSL Shader Sources ===");
-        this.emit("const WGSL_VERTEX = /* wgsl */`");
-        this.emit("struct Uniforms { model: mat4x4<f32> };");
-        this.emit("@group(0) @binding(0) var<uniform> u: Uniforms;");
-        this.emit("struct VIn { @location(0) pos: vec3<f32>, @location(1) norm: vec3<f32> };");
-        this.emit(
-          "struct VOut { @builtin(position) clip: vec4<f32>, @location(0) wNorm: vec3<f32>, @location(1) wPos: vec3<f32> };"
-        );
-        this.emit("@vertex fn vs_main(i: VIn) -> VOut {");
-        this.emit("  var o: VOut; let w = u.model * vec4<f32>(i.pos, 1.0);");
-        this.emit(
-          "  o.clip = w; o.wNorm = (u.model * vec4<f32>(i.norm, 0.0)).xyz; o.wPos = w.xyz; return o; }`;"
-        );
-        this.emit("");
-        this.emit("const WGSL_FRAGMENT = /* wgsl */`");
-        this.emit("struct Mat { color: vec4<f32>, rm: vec4<f32> };");
-        this.emit("@group(0) @binding(1) var<uniform> mat: Mat;");
-        this.emit("struct FIn { @location(0) wNorm: vec3<f32>, @location(1) wPos: vec3<f32> };");
-        this.emit("@fragment fn fs_main(i: FIn) -> @location(0) vec4<f32> {");
-        this.emit("  let N = normalize(i.wNorm); let L = normalize(vec3<f32>(1.0, 2.0, 1.5));");
-        this.emit("  let d = max(dot(N, L), 0.0) * (1.0 - mat.rm.x * 0.5);");
-        this.emit("  return vec4<f32>(mat.color.rgb * (0.15 + d), mat.color.a); }`;");
-        this.emit("");
-        this.emit("const WGSL_SPLAT = /* wgsl */`");
-        this.emit(
-          "struct Splat { center: vec3<f32>, opacity: f32, cov: array<f32,6>, sh: vec3<f32> };"
-        );
-        this.emit("@group(0) @binding(0) var<storage, read> splats: array<Splat>;");
-        this.emit(
-          "struct SO { @builtin(position) p: vec4<f32>, @location(0) c: vec4<f32>, @location(1) uv: vec2<f32> };"
-        );
-        this.emit(
-          "@vertex fn vs_splat(@builtin(vertex_index) vi: u32, @builtin(instance_index) ii: u32) -> SO {"
-        );
-        this.emit("  var q = array<vec2<f32>,4>(vec2(-1,-1),vec2(1,-1),vec2(-1,1),vec2(1,1));");
-        this.emit(
-          "  var o: SO; let s = splats[ii]; o.p = vec4<f32>(s.center.xy + q[vi]*0.01, s.center.z, 1.0);"
-        );
-        this.emit("  o.c = vec4<f32>(s.sh, s.opacity); o.uv = q[vi]; return o; }");
-        this.emit("@fragment fn fs_splat(i: SO) -> @location(0) vec4<f32> {");
-        this.emit("  let a = i.c.a * exp(-dot(i.uv, i.uv) * 4.0); if (a < 0.01) { discard; }");
-        this.emit("  return vec4<f32>(i.c.rgb * a, a); }`;");
-        this.emit("");
-        this.emit("const WGSL_POINT = /* wgsl */`");
-        this.emit("struct PO { @builtin(position) p: vec4<f32>, @location(0) c: vec4<f32> };");
-        this.emit(
-          "@vertex fn vs_point(@location(0) pos: vec3<f32>, @location(1) col: vec4<f32>) -> PO { var o: PO; o.p = vec4<f32>(pos, 1.0); o.c = col; return o; }"
-        );
-        this.emit("@fragment fn fs_point(i: PO) -> @location(0) vec4<f32> { return i.c; }`;");
-        this.emit("");
-        this.emit("const WGSL_PARTICLE_RENDER = /* wgsl */`");
-        this.emit("struct PVO { @builtin(position) p: vec4<f32>, @location(0) life: f32 };");
-        this.emit(
-          "@vertex fn vs_particle(@location(0) pos: vec3<f32>, @location(1) vel: vec3<f32>, @location(2) life: f32) -> PVO { var o: PVO; o.p = vec4<f32>(pos, 1.0); o.life = life; return o; }"
-        );
-        this.emit("@fragment fn fs_particle(i: PVO) -> @location(0) vec4<f32> {");
-        this.emit(
-          "  let t = clamp(i.life, 0.0, 1.0); return vec4<f32>(mix(vec3(1.0,0.2,0.0), vec3(1.0,1.0,0.5), t), t*0.8); }`;"
-        );
-        this.emit("");
-        this.emit("const WGSL_PARTICLE_COMPUTE = /* wgsl */`");
-        this.emit("struct P { pos: vec3<f32>, _p0: f32, vel: vec3<f32>, life: f32 };");
-        this.emit("@group(0) @binding(0) var<storage, read> pin: array<P>;");
-        this.emit("@group(0) @binding(1) var<storage, read_write> pout: array<P>;");
-        this.emit("@group(0) @binding(2) var<uniform> dt: f32;");
-        this.emit(
-          "@compute @workgroup_size(64) fn cs_particle_update(@builtin(global_invocation_id) gid: vec3<u32>) {"
-        );
-        this.emit("  let i = gid.x; if (i >= arrayLength(&pin)) { return; } var p = pin[i];");
-        this.emit("  p.vel.y -= 9.81 * dt; p.pos += p.vel * dt; p.life -= dt;");
-        this.emit(
-          "  if (p.life <= 0.0) { p.pos = vec3(0.0); p.vel = vec3(0.0, 5.0, 0.0); p.life = 2.0; }"
-        );
-        this.emit("  pout[i] = p; }`;");
-        this.emit("");
-        this.emit("const WGSL_PHYSICS_COMPUTE = /* wgsl */`");
-        this.emit("struct Body { pos: vec3<f32>, mass: f32, vel: vec3<f32>, _p: f32 };");
-        this.emit("@group(0) @binding(0) var<storage, read_write> bodies: array<Body>;");
-        this.emit("@group(0) @binding(1) var<uniform> dt: f32;");
-        this.emit(
-          "@compute @workgroup_size(64) fn cs_physics_step(@builtin(global_invocation_id) gid: vec3<u32>) {"
-        );
-        this.emit("  let i = gid.x; if (i >= arrayLength(&bodies)) { return; } var b = bodies[i];");
-        this.emit("  b.vel.y -= 9.81 * dt; b.pos += b.vel * dt;");
-        this.emit(
-          "  if (b.pos.y < 0.0) { b.pos.y = 0.0; b.vel.y = -b.vel.y * 0.6; } bodies[i] = b; }`;"
-        );
-        this.emit("");
-      }
-      // ─── Render Loop ──────────────────────────────────────────────────────────
-      emitRenderLoop(composition) {
-        this.emit("// === Render Loop ===");
-        this.emit("let frameCount = 0;");
-        this.emit("const t0 = performance.now();");
-        this.emit("function frame() {");
-        this.indent();
-        this.emit("frameCount++;");
-        this.emit("const time = (performance.now() - t0) / 1000.0;");
-        this.emit("const enc = device.createCommandEncoder();");
-        const gpuObjs = (composition.objects || []).filter(
-          (o) => o.traits?.some(
-            (t) => t.name === "gpu_particle" || t.name === "gpu_physics" || t.name === "compute"
-          )
-        );
-        if (gpuObjs.length > 0 && this.options.enableCompute) {
-          this.emit("const cp = enc.beginComputePass();");
-          for (const obj of gpuObjs) {
-            const v = this.sanitizeName(obj.name);
-            if (obj.traits?.some((t) => t.name === "gpu_particle")) {
-              this.emit(
-                `cp.setPipeline(${v}ParticleCompute); cp.dispatchWorkgroups(${v}ComputeDispatches);`
-              );
-            }
-            if (obj.traits?.some((t) => t.name === "gpu_physics")) {
-              this.emit(`cp.setPipeline(${v}PhysicsCompute); cp.dispatchWorkgroups(16);`);
-            }
-            if (obj.traits?.some((t) => t.name === "compute")) {
-              this.emit(`cp.setPipeline(${v}CustomCompute); cp.dispatchWorkgroups(...${v}Workgroups);`);
-            }
-          }
-          this.emit("cp.end();");
-        }
-        this.emit("const rp = enc.beginRenderPass({");
-        this.indent();
-        this.emit(
-          'colorAttachments: [{ view: msaaTexture.createView(), resolveTarget: context.getCurrentTexture().createView(), clearValue: clearColor, loadOp: "clear", storeOp: "store" }],'
-        );
-        this.emit(
-          'depthStencilAttachment: { view: depthTexture.createView(), depthClearValue: 1.0, depthLoadOp: "clear", depthStoreOp: "store" },'
-        );
-        this.dedent();
-        this.emit("});");
-        if (composition.objects) {
-          for (const obj of composition.objects) this.emitDrawCall(obj);
-        }
-        if (composition.spatialGroups) {
-          for (const group of composition.spatialGroups) {
-            for (const obj of group.objects) this.emitDrawCall(obj);
-          }
-        }
-        this.emit("rp.end();");
-        this.emit("device.queue.submit([enc.finish()]);");
-        this.emit("requestAnimationFrame(frame);");
-        this.dedent();
-        this.emit("}");
-        this.emit("requestAnimationFrame(frame);");
-      }
-      emitDrawCall(obj) {
-        const v = this.sanitizeName(obj.name);
-        const traits = obj.traits || [];
-        if (traits.some((t) => t.name === "gaussian_splat")) {
-          this.emit(`rp.setPipeline(${v}SplatPipeline); rp.draw(4, ${v}SplatCount.value);`);
-        } else if (traits.some((t) => t.name === "point_cloud")) {
-          this.emit(`rp.setPipeline(${v}PointPipeline); rp.draw(${v}PointCount.value);`);
-        } else if (traits.some((t) => t.name === "gpu_particle")) {
-          this.emit(
-            `rp.setPipeline(${v}ParticlePipeline); rp.setVertexBuffer(0, ${v}ParticleBufA); rp.draw(${v}ParticleCount);`
-          );
-        } else {
-          this.emit(
-            `rp.setPipeline(${v}Pipeline); rp.setBindGroup(0, ${v}Bind); rp.setVertexBuffer(0, ${v}VBO); rp.draw(${v}VertexCount);`
-          );
-        }
-        if (obj.children) {
-          for (const child of obj.children) this.emitDrawCall(child);
-        }
-      }
-      // ─── Helpers ──────────────────────────────────────────────────────────────
-      emit(line) {
-        this.lines.push(this.options.indent.repeat(this.indentLevel) + line);
-      }
-      indent() {
-        this.indentLevel++;
-      }
-      dedent() {
-        this.indentLevel = Math.max(0, this.indentLevel - 1);
-      }
-      sanitizeName(name) {
-        return name.replace(/[^a-zA-Z0-9_]/g, "_");
-      }
-      findObjProp(obj, key) {
-        return obj.properties?.find((p) => p.key === key)?.value;
-      }
-      parseColor(value) {
-        if (typeof value === "string" && value.startsWith("#")) {
-          const h = value.slice(1);
-          return [
-            parseFloat((parseInt(h.substring(0, 2), 16) / 255).toFixed(4)),
-            parseFloat((parseInt(h.substring(2, 4), 16) / 255).toFixed(4)),
-            parseFloat((parseInt(h.substring(4, 6), 16) / 255).toFixed(4))
-          ];
-        }
-        if (Array.isArray(value) && value.length >= 3) return [value[0], value[1], value[2]];
-        return [1, 1, 1];
-      }
-      extractMaterialColor(material, color) {
-        if (color) return this.parseColor(color);
-        if (material && typeof material === "object" && !Array.isArray(material)) {
-          const m = material;
-          if (m.color) return this.parseColor(m.color);
-        }
-        return [0.8, 0.8, 0.8];
-      }
-      extractMaterialProp(material, key, fallback) {
-        if (material && typeof material === "object" && !Array.isArray(material)) {
-          const m = material;
-          if (m[key] !== void 0) return m[key];
-        }
-        return fallback;
-      }
-      geometryVertexDataFn(meshType) {
-        const map = {
-          sphere: "generateSphereVertices(0.5, 16, 16)",
-          orb: "generateSphereVertices(0.5, 16, 16)",
-          plane: "generatePlaneVertices(1.0, 1.0)",
-          cylinder: "generateCylinderVertices(0.5, 1.0, 16)",
-          cone: "generateConeVertices(0.5, 1.0, 16)",
-          pyramid: "generateConeVertices(0.5, 1.0, 16)",
-          torus: "generateTorusVertices(0.5, 0.15, 16, 32)"
-        };
-        return map[meshType] || "generateCubeVertices(1.0)";
-      }
-    };
-  }
-});
-
-export { WebGPUCompiler, WebGPUCompiler_exports, init_WebGPUCompiler };
-//# sourceMappingURL=chunk-G4VZTCIB.js.map
-//# sourceMappingURL=chunk-G4VZTCIB.js.map