voidcore 0.0.0

package/dist/index.js

@@ -0,0 +1,1162 @@
+// src/engine/wasm.ts
+async function loadWasm() {
+  const response = await fetch("/voidcore.wasm");
+  const memory = new WebAssembly.Memory({ initial: 512 });
+  const { instance } = await WebAssembly.instantiateStreaming(response, {
+    env: { memory }
+  });
+  const exports = instance.exports;
+  const buffer = memory.buffer;
+  const f32 = new Float32Array(buffer);
+  const u32 = new Uint32Array(buffer);
+  const u8 = new Uint8Array(buffer);
+  const scratchOffset = exports.vc_init(512);
+  return {
+    exports,
+    memory,
+    f32,
+    u32,
+    u8,
+    scratchOffset,
+    positionsPtr: exports.vc_get_positions_ptr(),
+    eulerRotationsPtr: exports.vc_get_euler_rotations_ptr(),
+    scalesPtr: exports.vc_get_scales_ptr(),
+    worldMatricesPtr: exports.vc_get_world_matrices_ptr(),
+    colorsPtr: exports.vc_get_colors_ptr(),
+    flagsPtr: exports.vc_get_flags_ptr(),
+    bspheresPtr: exports.vc_get_bspheres_ptr(),
+    geometryIdsPtr: exports.vc_get_geometry_ids_ptr(),
+    sortKeysPtr: exports.vc_get_sort_keys_ptr(),
+    visibleIndicesPtr: exports.vc_get_visible_indices_ptr()
+  };
+}
+
+// src/engine/webgl-shaders.ts
+var vertexShaderGLSL = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+
+layout(std140) uniform CameraUniforms {
+  mat4 view;
+  mat4 projection;
+} camera;
+
+layout(std140) uniform ModelUniforms {
+  mat4 world;
+  vec4 color;
+  vec4 flags; // x = unlit
+} model;
+
+layout(location = 0) in vec3 a_position;
+layout(location = 1) in vec3 a_normal;
+
+out vec3 v_worldNormal;
+out vec4 v_color;
+out float v_unlit;
+
+void main() {
+  vec4 worldPos = model.world * vec4(a_position, 1.0);
+  gl_Position = camera.projection * camera.view * worldPos;
+
+  mat3 normalMat = mat3(model.world);
+  v_worldNormal = normalize(normalMat * a_normal);
+  v_color = model.color;
+  v_unlit = model.flags.x;
+}
+`
+);
+var fragmentShaderGLSL = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+
+layout(std140) uniform LightUniforms {
+  vec4 direction;
+  vec4 color;
+  vec4 ambient;
+} light;
+
+in vec3 v_worldNormal;
+in vec4 v_color;
+in float v_unlit;
+
+out vec4 fragColor;
+
+void main() {
+  vec3 normal = normalize(v_worldNormal);
+  vec3 lightDir = normalize(-light.direction.xyz);
+
+  float NdotL = max(dot(normal, lightDir), 0.0);
+  vec3 diffuse = light.color.rgb * NdotL;
+  vec3 ambient = light.ambient.rgb;
+
+  vec3 finalColor;
+  if (v_unlit > 0.5) {
+    finalColor = v_color.rgb;
+  } else {
+    finalColor = v_color.rgb * (diffuse + ambient);
+  }
+
+  fragColor = vec4(finalColor, v_color.a);
+}
+`
+);
+
+// src/engine/webgl-renderer.ts
+function compileShader(gl, type, source) {
+  const shader = gl.createShader(type);
+  gl.shaderSource(shader, source);
+  gl.compileShader(shader);
+  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+    const info = gl.getShaderInfoLog(shader);
+    gl.deleteShader(shader);
+    throw new Error(`Shader compile error: ${info}`);
+  }
+  return shader;
+}
+function createProgram(gl, vsSource, fsSource) {
+  const vs = compileShader(gl, gl.VERTEX_SHADER, vsSource);
+  const fs = compileShader(gl, gl.FRAGMENT_SHADER, fsSource);
+  const program = gl.createProgram();
+  gl.attachShader(program, vs);
+  gl.attachShader(program, fs);
+  gl.linkProgram(program);
+  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+    const info = gl.getProgramInfoLog(program);
+    throw new Error(`Program link error: ${info}`);
+  }
+  gl.deleteShader(vs);
+  gl.deleteShader(fs);
+  return program;
+}
+function createWebGLRenderer(canvas) {
+  const gl = canvas.getContext("webgl2", { antialias: true });
+  if (!gl) throw new Error("WebGL2 not supported");
+  gl.enable(gl.DEPTH_TEST);
+  gl.depthFunc(gl.LESS);
+  gl.enable(gl.CULL_FACE);
+  gl.cullFace(gl.BACK);
+  gl.clearColor(0.1, 0.1, 0.1, 1);
+  const program = createProgram(gl, vertexShaderGLSL, fragmentShaderGLSL);
+  const cameraBlockIdx = gl.getUniformBlockIndex(program, "CameraUniforms");
+  const modelBlockIdx = gl.getUniformBlockIndex(program, "ModelUniforms");
+  const lightBlockIdx = gl.getUniformBlockIndex(program, "LightUniforms");
+  gl.uniformBlockBinding(program, cameraBlockIdx, 0);
+  gl.uniformBlockBinding(program, modelBlockIdx, 1);
+  gl.uniformBlockBinding(program, lightBlockIdx, 2);
+  const cameraUBO = gl.createBuffer();
+  gl.bindBuffer(gl.UNIFORM_BUFFER, cameraUBO);
+  gl.bufferData(gl.UNIFORM_BUFFER, 128, gl.DYNAMIC_DRAW);
+  const MODEL_UBO_SIZE = 96;
+  const modelUBO = gl.createBuffer();
+  gl.bindBuffer(gl.UNIFORM_BUFFER, modelUBO);
+  gl.bufferData(gl.UNIFORM_BUFFER, MODEL_UBO_SIZE, gl.DYNAMIC_DRAW);
+  const lightUBO = gl.createBuffer();
+  gl.bindBuffer(gl.UNIFORM_BUFFER, lightUBO);
+  gl.bufferData(gl.UNIFORM_BUFFER, 48, gl.DYNAMIC_DRAW);
+  const geometries = /* @__PURE__ */ new Map();
+  const modelData = new Float32Array(24);
+  const renderer = {
+    backend: "webgl",
+    registerGeometry(id, vertices, indices) {
+      const vao = gl.createVertexArray();
+      gl.bindVertexArray(vao);
+      const vbo = gl.createBuffer();
+      gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
+      gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW);
+      gl.enableVertexAttribArray(0);
+      gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 24, 0);
+      gl.enableVertexAttribArray(1);
+      gl.vertexAttribPointer(1, 3, gl.FLOAT, false, 24, 12);
+      const ebo = gl.createBuffer();
+      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ebo);
+      gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices, gl.STATIC_DRAW);
+      gl.bindVertexArray(null);
+      geometries.set(id, { vao, indexCount: indices.length });
+    },
+    updateCamera(view, projection) {
+      const data = new Float32Array(32);
+      data.set(view, 0);
+      data.set(projection, 16);
+      gl.bindBuffer(gl.UNIFORM_BUFFER, cameraUBO);
+      gl.bufferSubData(gl.UNIFORM_BUFFER, 0, data);
+    },
+    updateLighting(dir, dirColor, ambient) {
+      const data = new Float32Array(12);
+      data.set(dir.subarray(0, 3), 0);
+      data.set(dirColor.subarray(0, 3), 4);
+      data.set(ambient.subarray(0, 3), 8);
+      gl.bindBuffer(gl.UNIFORM_BUFFER, lightUBO);
+      gl.bufferSubData(gl.UNIFORM_BUFFER, 0, data);
+    },
+    draw(entities, count) {
+      gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+      gl.useProgram(program);
+      gl.bindBufferBase(gl.UNIFORM_BUFFER, 0, cameraUBO);
+      gl.bindBufferBase(gl.UNIFORM_BUFFER, 2, lightUBO);
+      for (let i = 0; i < count; i++) {
+        const entity = entities[i];
+        const geo = geometries.get(entity.geometryId);
+        if (!geo) continue;
+        modelData.set(entity.worldMatrix, 0);
+        modelData.set(entity.color, 16);
+        modelData[20] = entity.unlit ? 1 : 0;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, modelUBO);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 0, modelData);
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, 1, modelUBO);
+        gl.bindVertexArray(geo.vao);
+        gl.drawElements(gl.TRIANGLES, geo.indexCount, gl.UNSIGNED_SHORT, 0);
+      }
+      gl.bindVertexArray(null);
+    },
+    resize(width, height) {
+      if (width === 0 || height === 0) return;
+      gl.viewport(0, 0, width, height);
+    },
+    destroy() {
+      gl.deleteBuffer(cameraUBO);
+      gl.deleteBuffer(modelUBO);
+      gl.deleteBuffer(lightUBO);
+      gl.deleteProgram(program);
+      for (const geo of geometries.values()) {
+        gl.deleteVertexArray(geo.vao);
+      }
+    }
+  };
+  return renderer;
+}
+
+// src/engine/shaders.ts
+var shaderSource = (
+  /* wgsl */
+  `
+struct CameraUniforms {
+  view: mat4x4f,
+  projection: mat4x4f,
+}
+
+struct ModelUniforms {
+  world: mat4x4f,
+  color: vec4f,
+  flags: vec4f, // x = unlit
+}
+
+struct LightUniforms {
+  direction: vec4f,
+  color: vec4f,
+  ambient: vec4f,
+}
+
+@group(0) @binding(0) var<uniform> camera: CameraUniforms;
+@group(1) @binding(0) var<uniform> model: ModelUniforms;
+@group(2) @binding(0) var<uniform> light: LightUniforms;
+
+struct VertexInput {
+  @location(0) position: vec3f,
+  @location(1) normal: vec3f,
+}
+
+struct VertexOutput {
+  @builtin(position) position: vec4f,
+  @location(0) worldNormal: vec3f,
+  @location(1) color: vec4f,
+  @location(2) unlit: f32,
+}
+
+@vertex
+fn vs_main(input: VertexInput) -> VertexOutput {
+  var output: VertexOutput;
+
+  let worldPos = model.world * vec4f(input.position, 1.0);
+  output.position = camera.projection * camera.view * worldPos;
+
+  // Transform normal by upper 3x3 of world matrix
+  let normalMat = mat3x3f(
+    model.world[0].xyz,
+    model.world[1].xyz,
+    model.world[2].xyz,
+  );
+  output.worldNormal = normalize(normalMat * input.normal);
+  output.color = model.color;
+  output.unlit = model.flags.x;
+
+  return output;
+}
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4f {
+  let normal = normalize(input.worldNormal);
+  let lightDir = normalize(-light.direction.xyz);
+
+  // Lambert diffuse
+  let NdotL = max(dot(normal, lightDir), 0.0);
+  let diffuse = light.color.rgb * NdotL;
+  let ambient = light.ambient.rgb;
+
+  var finalColor: vec3f;
+  if (input.unlit > 0.5) {
+    finalColor = input.color.rgb;
+  } else {
+    finalColor = input.color.rgb * (diffuse + ambient);
+  }
+
+  return vec4f(finalColor, input.color.a);
+}
+`
+);
+
+// src/engine/renderer.ts
+var MODEL_UNIFORM_SIZE = 256;
+var MAX_ENTITIES = 4096;
+async function createWebGPURenderer(canvas) {
+  const adapter = await navigator.gpu.requestAdapter();
+  if (!adapter) throw new Error("No WebGPU adapter");
+  const device = await adapter.requestDevice();
+  const context = canvas.getContext("webgpu");
+  const format = navigator.gpu.getPreferredCanvasFormat();
+  context.configure({ device, format, alphaMode: "premultiplied" });
+  const shaderModule = device.createShaderModule({
+    code: shaderSource
+  });
+  const cameraBindGroupLayout = device.createBindGroupLayout({
+    entries: [
+      {
+        binding: 0,
+        visibility: GPUShaderStage.VERTEX,
+        buffer: { type: "uniform" }
+      }
+    ]
+  });
+  const modelBindGroupLayout = device.createBindGroupLayout({
+    entries: [
+      {
+        binding: 0,
+        visibility: GPUShaderStage.VERTEX,
+        buffer: { type: "uniform", hasDynamicOffset: true }
+      }
+    ]
+  });
+  const lightBindGroupLayout = device.createBindGroupLayout({
+    entries: [
+      {
+        binding: 0,
+        visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
+        buffer: { type: "uniform" }
+      }
+    ]
+  });
+  const pipelineLayout = device.createPipelineLayout({
+    bindGroupLayouts: [
+      cameraBindGroupLayout,
+      modelBindGroupLayout,
+      lightBindGroupLayout
+    ]
+  });
+  let depthTexture = device.createTexture({
+    size: [canvas.width || 1, canvas.height || 1],
+    format: "depth24plus",
+    usage: GPUTextureUsage.RENDER_ATTACHMENT,
+    sampleCount: 4
+  });
+  let msaaTexture = device.createTexture({
+    size: [canvas.width || 1, canvas.height || 1],
+    format,
+    usage: GPUTextureUsage.RENDER_ATTACHMENT,
+    sampleCount: 4
+  });
+  const pipeline = device.createRenderPipeline({
+    layout: pipelineLayout,
+    vertex: {
+      module: shaderModule,
+      entryPoint: "vs_main",
+      buffers: [
+        {
+          arrayStride: 24,
+          // 6 floats × 4 bytes
+          attributes: [
+            { shaderLocation: 0, offset: 0, format: "float32x3" },
+            // position
+            { shaderLocation: 1, offset: 12, format: "float32x3" }
+            // normal
+          ]
+        }
+      ]
+    },
+    fragment: {
+      module: shaderModule,
+      entryPoint: "fs_main",
+      targets: [{ format }]
+    },
+    primitive: {
+      topology: "triangle-list",
+      cullMode: "back"
+    },
+    depthStencil: {
+      depthWriteEnabled: true,
+      depthCompare: "less",
+      format: "depth24plus"
+    },
+    multisample: { count: 4 }
+  });
+  const cameraBuffer = device.createBuffer({
+    size: 128,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  const cameraBindGroup = device.createBindGroup({
+    layout: cameraBindGroupLayout,
+    entries: [{ binding: 0, resource: { buffer: cameraBuffer } }]
+  });
+  const modelBuffer = device.createBuffer({
+    size: MODEL_UNIFORM_SIZE * MAX_ENTITIES,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  const modelBindGroup = device.createBindGroup({
+    layout: modelBindGroupLayout,
+    entries: [
+      {
+        binding: 0,
+        resource: { buffer: modelBuffer, size: MODEL_UNIFORM_SIZE }
+      }
+    ]
+  });
+  const lightBuffer = device.createBuffer({
+    size: 48,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  const lightBindGroup = device.createBindGroup({
+    layout: lightBindGroupLayout,
+    entries: [{ binding: 0, resource: { buffer: lightBuffer } }]
+  });
+  const modelData = new Float32Array(
+    MODEL_UNIFORM_SIZE / 4 * MAX_ENTITIES
+  );
+  const geometries = /* @__PURE__ */ new Map();
+  const renderer = {
+    backend: "webgpu",
+    registerGeometry(id, vertices, indices) {
+      const vertexBuffer = device.createBuffer({
+        size: vertices.byteLength,
+        usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST
+      });
+      device.queue.writeBuffer(vertexBuffer, 0, new Float32Array(vertices));
+      const indexBuffer = device.createBuffer({
+        size: indices.byteLength,
+        usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
+      });
+      device.queue.writeBuffer(
+        indexBuffer,
+        0,
+        indices instanceof Uint16Array ? new Uint16Array(indices) : new Uint32Array(indices)
+      );
+      geometries.set(id, {
+        vertexBuffer,
+        indexBuffer,
+        indexCount: indices.length
+      });
+    },
+    updateCamera(view, projection) {
+      device.queue.writeBuffer(cameraBuffer, 0, new Float32Array(view));
+      device.queue.writeBuffer(cameraBuffer, 64, new Float32Array(projection));
+    },
+    updateLighting(dir, dirColor, ambient) {
+      const data = new Float32Array(12);
+      data.set(dir.subarray(0, 3), 0);
+      data.set(dirColor.subarray(0, 3), 4);
+      data.set(ambient.subarray(0, 3), 8);
+      device.queue.writeBuffer(lightBuffer, 0, data);
+    },
+    draw(entities, count) {
+      const commandEncoder = device.createCommandEncoder();
+      const colorView = msaaTexture.createView();
+      const resolveTarget = context.getCurrentTexture().createView();
+      const renderPass = commandEncoder.beginRenderPass({
+        colorAttachments: [
+          {
+            view: colorView,
+            resolveTarget,
+            clearValue: { r: 0.1, g: 0.1, b: 0.1, a: 1 },
+            loadOp: "clear",
+            storeOp: "discard"
+          }
+        ],
+        depthStencilAttachment: {
+          view: depthTexture.createView(),
+          depthClearValue: 1,
+          depthLoadOp: "clear",
+          depthStoreOp: "discard"
+        }
+      });
+      renderPass.setPipeline(pipeline);
+      renderPass.setBindGroup(0, cameraBindGroup);
+      renderPass.setBindGroup(2, lightBindGroup);
+      for (let i = 0; i < count; i++) {
+        const entity = entities[i];
+        const base = MODEL_UNIFORM_SIZE / 4 * i;
+        modelData.set(entity.worldMatrix, base);
+        modelData.set(entity.color, base + 16);
+        modelData[base + 20] = entity.unlit ? 1 : 0;
+      }
+      device.queue.writeBuffer(
+        modelBuffer,
+        0,
+        modelData.buffer,
+        0,
+        MODEL_UNIFORM_SIZE * count
+      );
+      for (let i = 0; i < count; i++) {
+        const entity = entities[i];
+        const geo = geometries.get(entity.geometryId);
+        if (!geo) continue;
+        renderPass.setBindGroup(1, modelBindGroup, [MODEL_UNIFORM_SIZE * i]);
+        renderPass.setVertexBuffer(0, geo.vertexBuffer);
+        renderPass.setIndexBuffer(geo.indexBuffer, "uint16");
+        renderPass.drawIndexed(geo.indexCount);
+      }
+      renderPass.end();
+      device.queue.submit([commandEncoder.finish()]);
+    },
+    resize(width, height) {
+      if (width === 0 || height === 0) return;
+      depthTexture.destroy();
+      msaaTexture.destroy();
+      depthTexture = device.createTexture({
+        size: [width, height],
+        format: "depth24plus",
+        usage: GPUTextureUsage.RENDER_ATTACHMENT,
+        sampleCount: 4
+      });
+      msaaTexture = device.createTexture({
+        size: [width, height],
+        format,
+        usage: GPUTextureUsage.RENDER_ATTACHMENT,
+        sampleCount: 4
+      });
+    },
+    destroy() {
+      cameraBuffer.destroy();
+      modelBuffer.destroy();
+      lightBuffer.destroy();
+      depthTexture.destroy();
+      msaaTexture.destroy();
+      for (const geo of geometries.values()) {
+        geo.vertexBuffer.destroy();
+        geo.indexBuffer.destroy();
+      }
+      device.destroy();
+    }
+  };
+  return renderer;
+}
+
+// src/engine/gpu.ts
+async function createRenderer(canvas, backend) {
+  if (backend === "webgl") {
+    return createWebGLRenderer(canvas);
+  }
+  if (backend === "webgpu" || navigator.gpu) {
+    try {
+      return await createWebGPURenderer(canvas);
+    } catch {
+    }
+  }
+  return createWebGLRenderer(canvas);
+}
+
+// src/engine/camera.ts
+var Camera = class {
+  eye = new Float32Array([0, -10, 5]);
+  target = new Float32Array([0, 0, 0]);
+  up = new Float32Array([0, 0, 1]);
+  fov = Math.PI / 4;
+  // 45 degrees
+  near = 0.1;
+  far = 1e3;
+  // Output matrices
+  view = new Float32Array(16);
+  projection = new Float32Array(16);
+  vp = new Float32Array(16);
+  // Byte offsets in WASM scratch area
+  viewOffset;
+  projOffset;
+  vpOffset;
+  constructor(scratchOffset) {
+    this.viewOffset = scratchOffset;
+    this.projOffset = scratchOffset + 64;
+    this.vpOffset = scratchOffset + 128;
+  }
+  update(wasm, aspect) {
+    const { exports, f32 } = wasm;
+    exports.vc_look_at(
+      this.viewOffset,
+      this.eye[0],
+      this.eye[1],
+      this.eye[2],
+      this.target[0],
+      this.target[1],
+      this.target[2],
+      this.up[0],
+      this.up[1],
+      this.up[2]
+    );
+    exports.vc_perspective(this.projOffset, this.fov, aspect, this.near, this.far);
+    exports.vc_m4_multiply(this.vpOffset, this.projOffset, this.viewOffset);
+    const vi = this.viewOffset / 4;
+    const pi = this.projOffset / 4;
+    const vpi = this.vpOffset / 4;
+    this.view.set(f32.subarray(vi, vi + 16));
+    this.projection.set(f32.subarray(pi, pi + 16));
+    this.vp.set(f32.subarray(vpi, vpi + 16));
+  }
+};
+
+// src/engine/mesh.ts
+var FLAG_DIRTY = 1;
+var FLAG_VISIBLE = 2;
+var FLAG_UNLIT = 4;
+var Mesh = class {
+  entityId = -1;
+  // Sub-views into WASM SoA arrays (set when added to scene)
+  position;
+  rotation;
+  scale;
+  color;
+  worldMatrix;
+  wasm;
+  flags;
+  geometryId;
+  initOptions;
+  // Bounding sphere (center offset from entity origin, radius)
+  bsphereRadius = 0.5;
+  bsphereCenterOffset = new Float32Array(3);
+  constructor(options) {
+    this.geometryId = options.geometryId;
+    this.initOptions = options;
+  }
+  /** Called by Scene when entity is assigned */
+  _bind(wasm, entityId) {
+    this.entityId = entityId;
+    this.wasm = wasm;
+    const { f32, u32 } = wasm;
+    const posBase = wasm.positionsPtr / 4 + entityId * 3;
+    const rotBase = wasm.eulerRotationsPtr / 4 + entityId * 3;
+    const scBase = wasm.scalesPtr / 4 + entityId * 3;
+    const colBase = wasm.colorsPtr / 4 + entityId * 4;
+    const wmBase = wasm.worldMatricesPtr / 4 + entityId * 16;
+    this.position = f32.subarray(posBase, posBase + 3);
+    this.rotation = f32.subarray(rotBase, rotBase + 3);
+    this.scale = f32.subarray(scBase, scBase + 3);
+    this.color = f32.subarray(colBase, colBase + 4);
+    this.worldMatrix = f32.subarray(wmBase, wmBase + 16);
+    this.flags = u32.subarray(
+      wasm.flagsPtr / 4 + entityId,
+      wasm.flagsPtr / 4 + entityId + 1
+    );
+    const opts = this.initOptions;
+    if (opts.position) {
+      this.position[0] = opts.position[0];
+      this.position[1] = opts.position[1];
+      this.position[2] = opts.position[2];
+    }
+    if (opts.rotation) {
+      this.rotation[0] = opts.rotation[0];
+      this.rotation[1] = opts.rotation[1];
+      this.rotation[2] = opts.rotation[2];
+    }
+    if (opts.scale) {
+      this.scale[0] = opts.scale[0];
+      this.scale[1] = opts.scale[1];
+      this.scale[2] = opts.scale[2];
+    }
+    if (opts.color) {
+      this.color[0] = opts.color[0];
+      this.color[1] = opts.color[1];
+      this.color[2] = opts.color[2];
+      this.color[3] = opts.color[3];
+    }
+    let fl = FLAG_DIRTY | FLAG_VISIBLE;
+    if (opts.visible === false) fl &= ~FLAG_VISIBLE;
+    if (opts.unlit) fl |= FLAG_UNLIT;
+    this.flags[0] = fl;
+    u32[wasm.geometryIdsPtr / 4 + entityId] = this.geometryId;
+  }
+  setDirty() {
+    if (this.flags) {
+      this.flags[0] |= FLAG_DIRTY;
+    }
+  }
+  get visible() {
+    return (this.flags[0] & FLAG_VISIBLE) !== 0;
+  }
+  set visible(v) {
+    if (v) this.flags[0] |= FLAG_VISIBLE;
+    else this.flags[0] &= ~FLAG_VISIBLE;
+  }
+  get unlit() {
+    return (this.flags[0] & FLAG_UNLIT) !== 0;
+  }
+  set unlit(v) {
+    if (v) this.flags[0] |= FLAG_UNLIT;
+    else this.flags[0] &= ~FLAG_UNLIT;
+  }
+  /** Update bounding sphere in WASM memory */
+  updateBsphere() {
+    const f32 = this.wasm.f32;
+    const base = this.wasm.bspheresPtr / 4 + this.entityId * 4;
+    f32[base] = this.position[0] + this.bsphereCenterOffset[0];
+    f32[base + 1] = this.position[1] + this.bsphereCenterOffset[1];
+    f32[base + 2] = this.position[2] + this.bsphereCenterOffset[2];
+    const maxScale = Math.max(this.scale[0], this.scale[1], this.scale[2]);
+    f32[base + 3] = this.bsphereRadius * maxScale;
+  }
+};
+
+// src/engine/scene.ts
+var FLAG_VISIBLE2 = 2;
+var FLAG_UNLIT2 = 4;
+var Scene = class _Scene {
+  wasm;
+  renderer;
+  camera;
+  canvas;
+  meshes = [];
+  activeCount = 0;
+  geometryRegistry = /* @__PURE__ */ new Map();
+  nextGeometryId = 0;
+  config;
+  // Lighting
+  lightDir = new Float32Array([0.5, -1, 0.3]);
+  lightColor = new Float32Array([1, 1, 1]);
+  ambientColor = new Float32Array([0.15, 0.15, 0.15]);
+  // Stats
+  visibleCount = 0;
+  drawCalls = 0;
+  // Scratch offsets for frustum planes (6 planes × 4 floats = 96 bytes)
+  planesOffset = 0;
+  constructor(canvas, config) {
+    this.canvas = canvas;
+    this.config = config;
+  }
+  static async create(canvas, config = {}) {
+    const scene = new _Scene(canvas, config);
+    scene.wasm = await loadWasm();
+    scene.renderer = await createRenderer(canvas, config.backend);
+    scene.camera = new Camera(scene.wasm.scratchOffset);
+    scene.planesOffset = scene.wasm.scratchOffset + 192;
+    return scene;
+  }
+  registerGeometry(geometry) {
+    const id = this.nextGeometryId++;
+    this.geometryRegistry.set(id, geometry);
+    this.renderer.registerGeometry(id, geometry.vertices, geometry.indices);
+    return id;
+  }
+  add(mesh) {
+    const entityId = this.activeCount++;
+    mesh._bind(this.wasm, entityId);
+    this.meshes[entityId] = mesh;
+    const geo = this.geometryRegistry.get(mesh.geometryId);
+    if (geo) {
+      const { center, radius } = computeBoundingSphere(geo.vertices);
+      mesh.bsphereRadius = radius;
+      mesh.bsphereCenterOffset.set(center);
+      mesh.updateBsphere();
+    }
+    return mesh;
+  }
+  remove(mesh) {
+    if (mesh.entityId < 0) return;
+    const lastIdx = this.activeCount - 1;
+    if (mesh.entityId !== lastIdx && lastIdx >= 0) {
+      const lastMesh = this.meshes[lastIdx];
+      if (lastMesh) {
+        copyEntityData(this.wasm, lastIdx, mesh.entityId);
+        lastMesh._bind(this.wasm, mesh.entityId);
+        this.meshes[mesh.entityId] = lastMesh;
+      }
+    }
+    this.meshes[lastIdx] = null;
+    mesh.entityId = -1;
+    this.activeCount--;
+  }
+  setDirectionalLight(direction, color) {
+    this.lightDir.set(direction);
+    this.lightColor.set(color);
+  }
+  setAmbientLight(color) {
+    this.ambientColor.set(color);
+  }
+  render() {
+    const { wasm, renderer, camera, activeCount } = this;
+    const aspect = this.canvas.width / this.canvas.height;
+    wasm.exports.vc_compute_world_matrices(activeCount);
+    camera.update(wasm, aspect);
+    for (let i = 0; i < activeCount; i++) {
+      this.meshes[i]?.updateBsphere();
+    }
+    let visibleIndices;
+    let visibleCount;
+    if (wasm.exports.vc_extract_frustum_planes && wasm.exports.vc_frustum_cull) {
+      const vpOffset = wasm.scratchOffset + 128;
+      wasm.exports.vc_extract_frustum_planes(vpOffset, this.planesOffset);
+      visibleCount = wasm.exports.vc_frustum_cull(
+        activeCount,
+        this.planesOffset,
+        wasm.bspheresPtr,
+        wasm.flagsPtr,
+        wasm.visibleIndicesPtr
+      );
+      if (wasm.exports.vc_build_sort_keys && wasm.exports.vc_sort_draw_calls) {
+        wasm.exports.vc_build_sort_keys(
+          visibleCount,
+          wasm.visibleIndicesPtr,
+          wasm.geometryIdsPtr,
+          wasm.sortKeysPtr
+        );
+        wasm.exports.vc_sort_draw_calls(
+          visibleCount,
+          wasm.sortKeysPtr,
+          wasm.visibleIndicesPtr
+        );
+      }
+      visibleIndices = [];
+      const u32 = wasm.u32;
+      const base = wasm.visibleIndicesPtr / 4;
+      for (let i = 0; i < visibleCount; i++) {
+        visibleIndices.push(u32[base + i]);
+      }
+    } else {
+      visibleIndices = [];
+      for (let i = 0; i < activeCount; i++) {
+        const flags = wasm.u32[wasm.flagsPtr / 4 + i];
+        if (flags & FLAG_VISIBLE2) {
+          visibleIndices.push(i);
+        }
+      }
+      visibleCount = visibleIndices.length;
+    }
+    this.visibleCount = visibleCount;
+    const drawEntities = [];
+    for (const idx of visibleIndices) {
+      const mesh = this.meshes[idx];
+      if (!mesh) continue;
+      drawEntities.push({
+        worldMatrix: mesh.worldMatrix,
+        color: mesh.color,
+        geometryId: mesh.geometryId,
+        unlit: (wasm.u32[wasm.flagsPtr / 4 + idx] & FLAG_UNLIT2) !== 0
+      });
+    }
+    renderer.updateCamera(camera.view, camera.projection);
+    renderer.updateLighting(this.lightDir, this.lightColor, this.ambientColor);
+    renderer.draw(drawEntities, drawEntities.length);
+    this.drawCalls = drawEntities.length;
+    wasm.exports.vc_frame_reset();
+  }
+  resize(width, height) {
+    this.canvas.width = width;
+    this.canvas.height = height;
+    this.renderer.resize(width, height);
+  }
+  async switchBackend(canvas, backend) {
+    this.renderer.destroy();
+    this.canvas = canvas;
+    this.renderer = await createRenderer(canvas, backend);
+    for (const [id, geo] of this.geometryRegistry) {
+      this.renderer.registerGeometry(id, geo.vertices, geo.indices);
+    }
+  }
+  destroy() {
+    this.renderer.destroy();
+  }
+};
+function copyEntityData(wasm, from, to) {
+  const { f32, u32 } = wasm;
+  const pFrom = wasm.positionsPtr / 4 + from * 3;
+  const pTo = wasm.positionsPtr / 4 + to * 3;
+  f32.copyWithin(pTo, pFrom, pFrom + 3);
+  const rFrom = wasm.eulerRotationsPtr / 4 + from * 3;
+  const rTo = wasm.eulerRotationsPtr / 4 + to * 3;
+  f32.copyWithin(rTo, rFrom, rFrom + 3);
+  const sFrom = wasm.scalesPtr / 4 + from * 3;
+  const sTo = wasm.scalesPtr / 4 + to * 3;
+  f32.copyWithin(sTo, sFrom, sFrom + 3);
+  const wmFrom = wasm.worldMatricesPtr / 4 + from * 16;
+  const wmTo = wasm.worldMatricesPtr / 4 + to * 16;
+  f32.copyWithin(wmTo, wmFrom, wmFrom + 16);
+  const cFrom = wasm.colorsPtr / 4 + from * 4;
+  const cTo = wasm.colorsPtr / 4 + to * 4;
+  f32.copyWithin(cTo, cFrom, cFrom + 4);
+  u32[wasm.flagsPtr / 4 + to] = u32[wasm.flagsPtr / 4 + from];
+  const bFrom = wasm.bspheresPtr / 4 + from * 4;
+  const bTo = wasm.bspheresPtr / 4 + to * 4;
+  f32.copyWithin(bTo, bFrom, bFrom + 4);
+  u32[wasm.geometryIdsPtr / 4 + to] = u32[wasm.geometryIdsPtr / 4 + from];
+}
+function computeBoundingSphere(vertices) {
+  const stride = 6;
+  const count = vertices.length / stride;
+  let cx = 0, cy = 0, cz = 0;
+  for (let i = 0; i < count; i++) {
+    cx += vertices[i * stride];
+    cy += vertices[i * stride + 1];
+    cz += vertices[i * stride + 2];
+  }
+  cx /= count;
+  cy /= count;
+  cz /= count;
+  let maxR2 = 0;
+  for (let i = 0; i < count; i++) {
+    const dx = vertices[i * stride] - cx;
+    const dy = vertices[i * stride + 1] - cy;
+    const dz = vertices[i * stride + 2] - cz;
+    maxR2 = Math.max(maxR2, dx * dx + dy * dy + dz * dz);
+  }
+  return {
+    center: new Float32Array([cx, cy, cz]),
+    radius: Math.sqrt(maxR2)
+  };
+}
+
+// src/engine/geometry.ts
+function createBoxGeometry(w = 1, h = 1, d = 1) {
+  const hw = w / 2, hh = h / 2, hd = d / 2;
+  const vertices = new Float32Array([
+    // +X face
+    hw,
+    -hh,
+    -hd,
+    1,
+    0,
+    0,
+    hw,
+    hh,
+    -hd,
+    1,
+    0,
+    0,
+    hw,
+    hh,
+    hd,
+    1,
+    0,
+    0,
+    hw,
+    -hh,
+    hd,
+    1,
+    0,
+    0,
+    // -X face
+    -hw,
+    -hh,
+    hd,
+    -1,
+    0,
+    0,
+    -hw,
+    hh,
+    hd,
+    -1,
+    0,
+    0,
+    -hw,
+    hh,
+    -hd,
+    -1,
+    0,
+    0,
+    -hw,
+    -hh,
+    -hd,
+    -1,
+    0,
+    0,
+    // +Y face
+    -hw,
+    hh,
+    -hd,
+    0,
+    1,
+    0,
+    hw,
+    hh,
+    -hd,
+    0,
+    1,
+    0,
+    hw,
+    hh,
+    hd,
+    0,
+    1,
+    0,
+    // intentional: not -hw
+    -hw,
+    hh,
+    hd,
+    0,
+    1,
+    0,
+    // -Y face
+    -hw,
+    -hh,
+    hd,
+    0,
+    -1,
+    0,
+    hw,
+    -hh,
+    hd,
+    0,
+    -1,
+    0,
+    hw,
+    -hh,
+    -hd,
+    0,
+    -1,
+    0,
+    -hw,
+    -hh,
+    -hd,
+    0,
+    -1,
+    0,
+    // +Z face
+    -hw,
+    -hh,
+    hd,
+    0,
+    0,
+    1,
+    hw,
+    -hh,
+    hd,
+    0,
+    0,
+    1,
+    hw,
+    hh,
+    hd,
+    0,
+    0,
+    1,
+    -hw,
+    hh,
+    hd,
+    0,
+    0,
+    1,
+    // -Z face
+    hw,
+    -hh,
+    -hd,
+    0,
+    0,
+    -1,
+    -hw,
+    -hh,
+    -hd,
+    0,
+    0,
+    -1,
+    -hw,
+    hh,
+    -hd,
+    0,
+    0,
+    -1,
+    hw,
+    hh,
+    -hd,
+    0,
+    0,
+    -1
+  ]);
+  const indices = new Uint16Array([
+    0,
+    1,
+    2,
+    0,
+    2,
+    3,
+    // +X
+    4,
+    5,
+    6,
+    4,
+    6,
+    7,
+    // -X
+    8,
+    10,
+    9,
+    8,
+    11,
+    10,
+    // +Y
+    12,
+    14,
+    13,
+    12,
+    15,
+    14,
+    // -Y
+    16,
+    17,
+    18,
+    16,
+    18,
+    19,
+    // +Z
+    20,
+    21,
+    22,
+    20,
+    22,
+    23
+    // -Z
+  ]);
+  return { vertices, indices };
+}
+function createSphereGeometry(radius = 0.5, wSegs = 16, hSegs = 12) {
+  const verts = [];
+  const idxs = [];
+  for (let y = 0; y <= hSegs; y++) {
+    const v = y / hSegs;
+    const phi = v * Math.PI;
+    for (let x = 0; x <= wSegs; x++) {
+      const u = x / wSegs;
+      const theta = u * Math.PI * 2;
+      const nx = Math.sin(phi) * Math.cos(theta);
+      const ny = Math.cos(phi);
+      const nz = Math.sin(phi) * Math.sin(theta);
+      verts.push(nx * radius, ny * radius, nz * radius, nx, ny, nz);
+    }
+  }
+  for (let y = 0; y < hSegs; y++) {
+    for (let x = 0; x < wSegs; x++) {
+      const a = y * (wSegs + 1) + x;
+      const b = a + wSegs + 1;
+      idxs.push(a, b, a + 1);
+      idxs.push(b, b + 1, a + 1);
+    }
+  }
+  return {
+    vertices: new Float32Array(verts),
+    indices: new Uint16Array(idxs)
+  };
+}
+export {
+  Camera,
+  Mesh,
+  Scene,
+  createBoxGeometry,
+  createRenderer,
+  createSphereGeometry,
+  fragmentShaderGLSL,
+  loadWasm,
+  shaderSource,
+  vertexShaderGLSL
+};