@holoscript/engine 6.0.3 → 6.0.4

package/dist/chunk-CXZPLD4S.js

@@ -0,0 +1,223 @@
+// src/gpu/GPUBuffers.ts
+var GPUBufferManager = class {
+  context;
+  device;
+  particleCount;
+  buffers = null;
+  // Buffer sizes (in bytes)
+  positionBufferSize;
+  velocityBufferSize;
+  stateBufferSize;
+  uniformBufferSize;
+  constructor(context, particleCount) {
+    this.context = context;
+    this.device = context.getDevice();
+    this.particleCount = particleCount;
+    this.positionBufferSize = particleCount * 4 * Float32Array.BYTES_PER_ELEMENT;
+    this.velocityBufferSize = particleCount * 4 * Float32Array.BYTES_PER_ELEMENT;
+    this.stateBufferSize = particleCount * 4 * Float32Array.BYTES_PER_ELEMENT;
+    this.uniformBufferSize = 32;
+  }
+  /**
+   * Initialize GPU buffers
+   */
+  async initialize() {
+    const positionsRead = this.createStorageBuffer(this.positionBufferSize, "positions-read");
+    const positionsWrite = this.createStorageBuffer(this.positionBufferSize, "positions-write");
+    const velocitiesRead = this.createStorageBuffer(this.velocityBufferSize, "velocities-read");
+    const velocitiesWrite = this.createStorageBuffer(this.velocityBufferSize, "velocities-write");
+    const statesRead = this.createStorageBuffer(this.stateBufferSize, "states-read");
+    const statesWrite = this.createStorageBuffer(this.stateBufferSize, "states-write");
+    const uniforms = this.device.createBuffer({
+      label: "uniforms",
+      size: this.uniformBufferSize,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+    });
+    this.buffers = {
+      positionsRead,
+      positionsWrite,
+      velocitiesRead,
+      velocitiesWrite,
+      statesRead,
+      statesWrite,
+      uniforms
+    };
+  }
+  /**
+   * Create a storage buffer
+   */
+  createStorageBuffer(size, label) {
+    return this.device.createBuffer({
+      label,
+      size,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
+    });
+  }
+  /**
+   * Upload particle data to GPU
+   */
+  uploadParticleData(data) {
+    if (!this.buffers) {
+      throw new Error("Buffers not initialized. Call initialize() first.");
+    }
+    this.device.queue.writeBuffer(this.buffers.positionsRead, 0, data.positions.buffer);
+    this.device.queue.writeBuffer(this.buffers.velocitiesRead, 0, data.velocities.buffer);
+    this.device.queue.writeBuffer(this.buffers.statesRead, 0, data.states.buffer);
+  }
+  /**
+   * Upload uniform data (simulation parameters)
+   */
+  uploadUniformData(uniforms) {
+    if (!this.buffers) {
+      throw new Error("Buffers not initialized");
+    }
+    const data = new Float32Array([
+      uniforms.dt,
+      uniforms.gravity,
+      uniforms.groundY,
+      uniforms.restitution,
+      uniforms.friction,
+      uniforms.particleCount,
+      uniforms._pad1 ?? 0,
+      uniforms._pad2 ?? 0
+    ]);
+    this.device.queue.writeBuffer(this.buffers.uniforms, 0, data.buffer);
+  }
+  /**
+   * Download particle data from GPU (for rendering or analysis)
+   *
+   * Note: This is an async operation that stalls the pipeline.
+   * Use sparingly (e.g., once per frame for rendering).
+   */
+  async downloadParticleData() {
+    if (!this.buffers) {
+      throw new Error("Buffers not initialized");
+    }
+    const positionsStaging = this.createStagingBuffer(this.positionBufferSize);
+    const velocitiesStaging = this.createStagingBuffer(this.velocityBufferSize);
+    const statesStaging = this.createStagingBuffer(this.stateBufferSize);
+    const commandEncoder = this.device.createCommandEncoder({ label: "readback-encoder" });
+    commandEncoder.copyBufferToBuffer(
+      this.buffers.positionsRead,
+      0,
+      positionsStaging,
+      0,
+      this.positionBufferSize
+    );
+    commandEncoder.copyBufferToBuffer(
+      this.buffers.velocitiesRead,
+      0,
+      velocitiesStaging,
+      0,
+      this.velocityBufferSize
+    );
+    commandEncoder.copyBufferToBuffer(
+      this.buffers.statesRead,
+      0,
+      statesStaging,
+      0,
+      this.stateBufferSize
+    );
+    this.device.queue.submit([commandEncoder.finish()]);
+    await Promise.all([
+      positionsStaging.mapAsync(GPUMapMode.READ),
+      velocitiesStaging.mapAsync(GPUMapMode.READ),
+      statesStaging.mapAsync(GPUMapMode.READ)
+    ]);
+    const positions = new Float32Array(positionsStaging.getMappedRange()).slice();
+    const velocities = new Float32Array(velocitiesStaging.getMappedRange()).slice();
+    const states = new Float32Array(statesStaging.getMappedRange()).slice();
+    positionsStaging.unmap();
+    velocitiesStaging.unmap();
+    statesStaging.unmap();
+    positionsStaging.destroy();
+    velocitiesStaging.destroy();
+    statesStaging.destroy();
+    return { positions, velocities, states };
+  }
+  /**
+   * Create a staging buffer for GPU→CPU readback
+   */
+  createStagingBuffer(size) {
+    return this.device.createBuffer({
+      size,
+      usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+    });
+  }
+  /**
+   * Swap read/write buffers (ping-pong)
+   *
+   * After a compute pass, the "write" buffers contain the new state.
+   * This function swaps read ↔ write so the next pass can read the latest data.
+   */
+  swap() {
+    if (!this.buffers) {
+      throw new Error("Buffers not initialized");
+    }
+    const tempPos = this.buffers.positionsRead;
+    this.buffers.positionsRead = this.buffers.positionsWrite;
+    this.buffers.positionsWrite = tempPos;
+    const tempVel = this.buffers.velocitiesRead;
+    this.buffers.velocitiesRead = this.buffers.velocitiesWrite;
+    this.buffers.velocitiesWrite = tempVel;
+    const tempState = this.buffers.statesRead;
+    this.buffers.statesRead = this.buffers.statesWrite;
+    this.buffers.statesWrite = tempState;
+  }
+  /**
+   * Get buffer set for binding to compute pipeline
+   */
+  getBuffers() {
+    if (!this.buffers) {
+      throw new Error("Buffers not initialized");
+    }
+    return this.buffers;
+  }
+  /**
+   * Get particle count
+   */
+  getParticleCount() {
+    return this.particleCount;
+  }
+  /**
+   * Destroy buffers and free GPU memory
+   */
+  destroy() {
+    if (!this.buffers) return;
+    this.buffers.positionsRead.destroy();
+    this.buffers.positionsWrite.destroy();
+    this.buffers.velocitiesRead.destroy();
+    this.buffers.velocitiesWrite.destroy();
+    this.buffers.statesRead.destroy();
+    this.buffers.statesWrite.destroy();
+    this.buffers.uniforms.destroy();
+    this.buffers = null;
+  }
+};
+function createInitialParticleData(count, options = {}) {
+  const { positionRange = { min: -5, max: 5 }, radius = 0.05, mass = 1 } = options;
+  const positions = new Float32Array(count * 4);
+  const velocities = new Float32Array(count * 4);
+  const states = new Float32Array(count * 4);
+  for (let i = 0; i < count; i++) {
+    const idx = i * 4;
+    positions[idx + 0] = Math.random() * (positionRange.max - positionRange.min) + positionRange.min;
+    positions[idx + 1] = Math.random() * (positionRange.max - positionRange.min) + positionRange.min;
+    positions[idx + 2] = Math.random() * (positionRange.max - positionRange.min) + positionRange.min;
+    positions[idx + 3] = radius;
+    velocities[idx + 0] = 0;
+    velocities[idx + 1] = 0;
+    velocities[idx + 2] = 0;
+    velocities[idx + 3] = mass;
+    states[idx + 0] = 1;
+    states[idx + 1] = 0;
+    states[idx + 2] = 1;
+    states[idx + 3] = 0;
+  }
+  return { positions, velocities, states };
+}
+
+export {
+  GPUBufferManager,
+  createInitialParticleData
+};