@buley/hexgrid-3d 1.1.1 → 3.0.0

package/src/webgpu/shaders/fluid_sim.wgsl

@@ -0,0 +1,140 @@
+// fluid_sim.wgsl
+// 3D Fluid Simulation Compute Shaders
+
+struct FluidUniforms {
+  dt: f32,
+  width: f32,
+  height: f32,
+  depth: f32,
+  decay: f32,
+};
+
+@group(0) @binding(0) var<uniform> uniforms: FluidUniforms;
+
+// Bindings for Double-Buffering (Read -> Write)
+// Group 1: Velocity / Density
+@group(1) @binding(0) var field_in: texture_3d<f32>;
+@group(1) @binding(1) var field_out: texture_storage_3d<rgba16float, write>;
+
+// Sampler for linear interpolation
+@group(1) @binding(2) var field_sampler: sampler;
+
+// ----------------------------------------------------------------------------
+// ADVECTION
+// Moves quantities along the velocity field
+// ----------------------------------------------------------------------------
+@group(2) @binding(0) var velocity_field: texture_3d<f32>;
+
+@compute @workgroup_size(8, 8, 8)
+fn advect(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  let dims = vec3<f32>(uniforms.width, uniforms.height, uniforms.depth);
+  let coords = vec3<f32>(global_id);
+
+  if (any(coords >= dims)) { return; }
+
+  // 1. Sample velocity at current position
+  // Note: textureSampleLevel requires normalized coordinates [0, 1]
+  let uvw = (coords + 0.5) / dims;
+  let vel = textureSampleLevel(velocity_field, field_sampler, uvw, 0.0).xyz;
+
+  // 2. Trace back in time
+  let dt = uniforms.dt;
+  // Scale velocity back to grid units?
+  // Uniforms velocity tends to be in grid-units per second.
+  // Backtrace coordinate:
+  let back_pos = coords - vel * dt;
+
+  // 3. Sample field at previous position
+  let back_uvw = (back_pos + 0.5) / dims;
+  let new_val = textureSampleLevel(field_in, field_sampler, back_uvw, 0.0);
+
+  // 4. Apply decay
+  let decayed = new_val * uniforms.decay;
+
+  textureStore(field_out, global_id, decayed);
+}
+
+// ----------------------------------------------------------------------------
+// DIFFUSION (Jacobi Iteration)
+// ----------------------------------------------------------------------------
+// x_new = (x_old + alpha * neighbor_sum) * inverse_beta
+struct JacobiUniforms {
+  alpha: f32,
+  rBeta: f32,
+};
+@group(3) @binding(0) var<uniform> jacobi: JacobiUniforms;
+@group(3) @binding(1) var b_field: texture_3d<f32>; // The 'b' vector in Ax=b (usually previous state or inputs)
+@group(3) @binding(2) var x_field: texture_3d<f32>; // The 'x' vector (current guess)
+
+@compute @workgroup_size(8, 8, 8)
+fn diffuse(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  let dims = vec3<i32>(uniforms.width, uniforms.height, uniforms.depth);
+  let pos = vec3<i32>(global_id);
+  
+  if (any(pos >= dims)) { return; }
+
+  // Neighbors
+  let left   = textureLoad(x_field, pos + vec3<i32>(-1, 0, 0), 0);
+  let right  = textureLoad(x_field, pos + vec3<i32>(1, 0, 0), 0);
+  let down   = textureLoad(x_field, pos + vec3<i32>(0, -1, 0), 0);
+  let up     = textureLoad(x_field, pos + vec3<i32>(0, 1, 0), 0);
+  let back   = textureLoad(x_field, pos + vec3<i32>(0, 0, -1), 0);
+  let front  = textureLoad(x_field, pos + vec3<i32>(0, 0, 1), 0);
+
+  let bC = textureLoad(b_field, pos, 0);
+
+  // Jacobi step
+  let result = (left + right + down + up + back + front) * jacobi.alpha + bC;
+  let next_val = result * jacobi.rBeta;
+
+  textureStore(field_out, global_id, next_val);
+}
+
+// ----------------------------------------------------------------------------
+// DIVERGENCE
+// ----------------------------------------------------------------------------
+@compute @workgroup_size(8, 8, 8)
+fn divergence(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  let dims = vec3<i32>(uniforms.width, uniforms.height, uniforms.depth);
+  let pos = vec3<i32>(global_id);
+
+  if (any(pos >= dims)) { return; }
+
+  let left   = textureLoad(field_in, pos + vec3<i32>(-1, 0, 0), 0).x;
+  let right  = textureLoad(field_in, pos + vec3<i32>(1, 0, 0), 0).x;
+  let down   = textureLoad(field_in, pos + vec3<i32>(0, -1, 0), 0).y;
+  let up     = textureLoad(field_in, pos + vec3<i32>(0, 1, 0), 0).y;
+  let back   = textureLoad(field_in, pos + vec3<i32>(0, 0, -1), 0).z;
+  let front  = textureLoad(field_in, pos + vec3<i32>(0, 0, 1), 0).z;
+
+  let div = 0.5 * ((right - left) + (up - down) + (front - back));
+
+  textureStore(field_out, global_id, vec4<f32>(div, 0.0, 0.0, 1.0));
+}
+
+// ----------------------------------------------------------------------------
+// GRADIENT SUBTRACTION
+// u_new = u_old - gradient(p)
+// ----------------------------------------------------------------------------
+@group(4) @binding(0) var pressure_field: texture_3d<f32>;
+
+@compute @workgroup_size(8, 8, 8)
+fn subtract_gradient(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  let dims = vec3<i32>(uniforms.width, uniforms.height, uniforms.depth);
+  let pos = vec3<i32>(global_id);
+
+  if (any(pos >= dims)) { return; }
+
+  let pLeft   = textureLoad(pressure_field, pos + vec3<i32>(-1, 0, 0), 0).x;
+  let pRight  = textureLoad(pressure_field, pos + vec3<i32>(1, 0, 0), 0).x;
+  let pDown   = textureLoad(pressure_field, pos + vec3<i32>(0, -1, 0), 0).x;
+  let pUp     = textureLoad(pressure_field, pos + vec3<i32>(0, 1, 0), 0).x;
+  let pBack   = textureLoad(pressure_field, pos + vec3<i32>(0, 0, -1), 0).x;
+  let pFront  = textureLoad(pressure_field, pos + vec3<i32>(0, 0, 1), 0).x;
+
+  let old_vel = textureLoad(field_in, pos, 0).xyz;
+  let grad = vec3<f32>(pRight - pLeft, pUp - pDown, pFront - pBack) * 0.5;
+  let new_vel = old_vel - grad;
+
+  textureStore(field_out, global_id, vec4<f32>(new_vel, 1.0));
+}

package/src/webnn/WebNNContext.ts

@@ -0,0 +1,99 @@
+/**
+ * WebNN Context Manager
+ * Handles the creation and management of the WebNN MLContext.
+ * Prioritizes NPU -> GPU -> CPU.
+ */
+
+export type WebNNDeviceType = 'cpu' | 'gpu' | 'npu';
+
+export class WebNNContext {
+  private static instance: WebNNContext;
+  private context: MLContext | null = null;
+  private deviceType: WebNNDeviceType = 'cpu';
+  private isSupported: boolean = false;
+
+  private constructor() {}
+
+  static getInstance(): WebNNContext {
+    if (!WebNNContext.instance) {
+      WebNNContext.instance = new WebNNContext();
+    }
+    return WebNNContext.instance;
+  }
+
+  /**
+   * Initialize WebNN context with preferred device type.
+   */
+  async initialize(preference: WebNNDeviceType = 'npu'): Promise<boolean> {
+    if (typeof navigator === 'undefined' || !navigator.ml) {
+      console.warn('WebNN is not supported in this environment.');
+      this.isSupported = false;
+      return false;
+    }
+
+    try {
+      // Try preferred device first
+      this.context = await navigator.ml.createContext({ deviceType: preference });
+      this.deviceType = preference;
+      this.isSupported = true;
+      console.log(`WebNN initialized successfully on ${preference}`);
+      return true;
+    } catch (e) {
+      console.warn(`Failed to initialize WebNN on ${preference}, trying fallback chain...`, e);
+      
+      // Fallback chain: NPU -> GPU -> CPU
+      const chain: WebNNDeviceType[] = ['npu', 'gpu', 'cpu'];
+      const startIndex = chain.indexOf(preference) + 1;
+
+      for (let i = startIndex; i < chain.length; i++) {
+        const fallback = chain[i];
+        try {
+          this.context = await navigator.ml.createContext({ deviceType: fallback });
+          this.deviceType = fallback;
+          this.isSupported = true;
+          console.log(`WebNN initialized successfully on fallback ${fallback}`);
+          return true;
+        } catch (err) {
+            console.warn(`Failed to initialize WebNN on fallback ${fallback}`, err);
+        }
+      }
+    }
+
+    this.isSupported = false;
+    return false;
+  }
+
+  getContext(): MLContext | null {
+    return this.context;
+  }
+
+  getDeviceType(): WebNNDeviceType {
+    return this.deviceType;
+  }
+
+  isAvailable(): boolean {
+    return this.isSupported && this.context !== null;
+  }
+}
+
+// Type definitions for WebNN (since it might not be in standard lib yet)
+declare global {
+  interface Navigator {
+    ml: {
+      createContext(options?: { deviceType?: string }): Promise<MLContext>;
+    };
+  }
+
+  interface MLContext {
+    // Placeholder for MLContext methods
+    compute(graph: MLGraph, inputs: Record<string, ArrayBufferView>, outputs: Record<string, ArrayBufferView>): Promise<MLComputeResult>;
+  }
+
+  interface MLGraph {
+      // Opaque
+  }
+
+  interface MLComputeResult {
+      // Opaque
+  }
+}

package/tsconfig.json

@@ -18,8 +18,9 @@
     "baseUrl": ".",
     "paths": {
       "@/*": ["src/*"]
-    }
+    },
+    "types": ["@webgpu/types"]
   },
-  "include": ["src"],
+  "include": ["src", "src/**/*.wgsl"],
   "exclude": ["node_modules", "dist", "tests"]
 }