@plasius/gpu-particles 0.1.0

package/dist/effects/rain/prelude.wgsl

@@ -0,0 +1,35 @@
+// Rain effect shared WGSL definitions.
+
+struct Particle {
+  pos: vec4<f32>,
+  vel: vec4<f32>,
+};
+
+struct EffectParams {
+  time: f32,
+  dt: f32,
+  intensity: f32,
+  spawn_radius: f32,
+  bounds_min: vec2<f32>,
+  bounds_max: vec2<f32>,
+  origin: vec2<f32>,
+  drift: vec2<f32>,
+};
+
+@group(1) @binding(0) var<storage, read_write> particles: array<Particle>;
+@group(1) @binding(1) var<uniform> effect_params: EffectParams;
+
+fn hash_u32(x: u32) -> u32 {
+  var v = x;
+  v = v ^ (v >> 16u);
+  v = v * 0x7feb352du;
+  v = v ^ (v >> 15u);
+  v = v * 0x846ca68bu;
+  v = v ^ (v >> 16u);
+  return v;
+}
+
+fn rand01(seed: u32) -> f32 {
+  let v = hash_u32(seed) & 0x00ffffffu;
+  return f32(v) / 16777216.0;
+}

package/dist/effects/rain/render.job.wgsl

@@ -0,0 +1,8 @@
+// Rain render job placeholder.
+
+fn process_job(job_index: u32, job_type: u32, payload_words: u32) {
+  let _ignore = job_index + job_type + payload_words;
+  if (_ignore == 0u) {
+    return;
+  }
+}

package/dist/effects/rain/update.job.wgsl

@@ -0,0 +1,51 @@
+// Rain update job.
+
+fn rand_signed(seed: u32) -> f32 {
+  return rand01(seed) * 2.0 - 1.0;
+}
+
+fn respawn_rain(seed: u32) -> Particle {
+  let x = effect_params.origin.x + rand_signed(seed) * effect_params.spawn_radius;
+  let y = effect_params.origin.y + rand01(seed ^ 0x9e3779b9u) * 0.1;
+  let speed = 0.7 + rand01(seed ^ 0x85ebca6bu) * 1.2;
+  let vel = vec2<f32>(effect_params.drift.x * 0.2, -speed);
+  return Particle(vec4<f32>(vec2<f32>(x, y), 1.0, f32(seed)), vec4<f32>(vel, 0.0, 0.0));
+}
+
+fn process_job(job_index: u32, job_type: u32, payload_words: u32) {
+  if (payload_words == 0u) {
+    return;
+  }
+  let particle_index = payload_word(job_index, 0u);
+  if (particle_index >= arrayLength(&particles)) {
+    return;
+  }
+
+  var particle = particles[particle_index];
+  var life = particle.pos.z;
+  let seed = u32(particle.pos.w) ^ (particle_index * 97u);
+
+  if (life <= 0.0) {
+    particle = respawn_rain(seed + u32(effect_params.time * 400.0));
+    particles[particle_index] = particle;
+    return;
+  }
+
+  var pos = particle.pos.xy;
+  var vel = particle.vel.xy;
+  vel.x = vel.x + effect_params.drift.x * effect_params.dt * 0.3;
+  pos = pos + vel * effect_params.dt;
+
+  if (pos.y < effect_params.bounds_min.y - 0.1) {
+    life = -1.0;
+  }
+
+  particle.pos = vec4<f32>(pos, life, f32(seed));
+  particle.vel = vec4<f32>(vel, particle.vel.z, particle.vel.w);
+
+  if (life <= 0.0) {
+    particle = respawn_rain(seed + 13u + u32(effect_params.time * 700.0));
+  }
+
+  particles[particle_index] = particle;
+}

package/dist/effects/snow/prelude.wgsl

@@ -0,0 +1,35 @@
+// Snow effect shared WGSL definitions.
+
+struct Particle {
+  pos: vec4<f32>,
+  vel: vec4<f32>,
+};
+
+struct EffectParams {
+  time: f32,
+  dt: f32,
+  intensity: f32,
+  spawn_radius: f32,
+  bounds_min: vec2<f32>,
+  bounds_max: vec2<f32>,
+  origin: vec2<f32>,
+  drift: vec2<f32>,
+};
+
+@group(1) @binding(0) var<storage, read_write> particles: array<Particle>;
+@group(1) @binding(1) var<uniform> effect_params: EffectParams;
+
+fn hash_u32(x: u32) -> u32 {
+  var v = x;
+  v = v ^ (v >> 16u);
+  v = v * 0x7feb352du;
+  v = v ^ (v >> 15u);
+  v = v * 0x846ca68bu;
+  v = v ^ (v >> 16u);
+  return v;
+}
+
+fn rand01(seed: u32) -> f32 {
+  let v = hash_u32(seed) & 0x00ffffffu;
+  return f32(v) / 16777216.0;
+}

package/dist/effects/snow/render.job.wgsl

@@ -0,0 +1,8 @@
+// Snow render job placeholder.
+
+fn process_job(job_index: u32, job_type: u32, payload_words: u32) {
+  let _ignore = job_index + job_type + payload_words;
+  if (_ignore == 0u) {
+    return;
+  }
+}

package/dist/effects/snow/update.job.wgsl

@@ -0,0 +1,53 @@
+// Snow update job.
+
+fn rand_signed(seed: u32) -> f32 {
+  return rand01(seed) * 2.0 - 1.0;
+}
+
+fn respawn_snow(seed: u32) -> Particle {
+  let x = effect_params.origin.x + rand_signed(seed) * effect_params.spawn_radius;
+  let y = effect_params.origin.y + rand01(seed ^ 0x9e3779b9u) * 0.1;
+  let speed = 0.12 + rand01(seed ^ 0x85ebca6bu) * 0.2;
+  let drift = rand_signed(seed ^ 0x27d4eb2du) * 0.05;
+  let vel = vec2<f32>(drift + effect_params.drift.x * 0.2, -speed);
+  return Particle(vec4<f32>(vec2<f32>(x, y), 1.0, f32(seed)), vec4<f32>(vel, 0.0, 0.0));
+}
+
+fn process_job(job_index: u32, job_type: u32, payload_words: u32) {
+  if (payload_words == 0u) {
+    return;
+  }
+  let particle_index = payload_word(job_index, 0u);
+  if (particle_index >= arrayLength(&particles)) {
+    return;
+  }
+
+  var particle = particles[particle_index];
+  var life = particle.pos.z;
+  let seed = u32(particle.pos.w) ^ (particle_index * 67u);
+
+  if (life <= 0.0) {
+    particle = respawn_snow(seed + u32(effect_params.time * 200.0));
+    particles[particle_index] = particle;
+    return;
+  }
+
+  var pos = particle.pos.xy;
+  var vel = particle.vel.xy;
+  let sway = sin(effect_params.time * 0.8 + f32(seed) * 0.01) * 0.02;
+  vel.x = vel.x + sway + effect_params.drift.x * effect_params.dt * 0.4;
+  pos = pos + vel * effect_params.dt;
+
+  if (pos.y < effect_params.bounds_min.y - 0.1) {
+    life = -1.0;
+  }
+
+  particle.pos = vec4<f32>(pos, life, f32(seed));
+  particle.vel = vec4<f32>(vel, particle.vel.z, particle.vel.w);
+
+  if (life <= 0.0) {
+    particle = respawn_snow(seed + 29u + u32(effect_params.time * 300.0));
+  }
+
+  particles[particle_index] = particle;
+}

package/dist/effects/sparks/prelude.wgsl

@@ -0,0 +1,41 @@
+// Sparks effect shared WGSL definitions.
+
+struct Particle {
+  pos: vec4<f32>,
+  vel: vec4<f32>,
+};
+
+struct EffectParams {
+  time: f32,
+  dt: f32,
+  intensity: f32,
+  spawn_radius: f32,
+  bounds_min: vec2<f32>,
+  bounds_max: vec2<f32>,
+  origin: vec2<f32>,
+  drift: vec2<f32>,
+};
+
+@group(1) @binding(0) var<storage, read_write> particles: array<Particle>;
+@group(1) @binding(1) var<uniform> effect_params: EffectParams;
+
+const TWO_PI: f32 = 6.2831853;
+
+fn hash_u32(x: u32) -> u32 {
+  var v = x;
+  v = v ^ (v >> 16u);
+  v = v * 0x7feb352du;
+  v = v ^ (v >> 15u);
+  v = v * 0x846ca68bu;
+  v = v ^ (v >> 16u);
+  return v;
+}
+
+fn rand01(seed: u32) -> f32 {
+  let v = hash_u32(seed) & 0x00ffffffu;
+  return f32(v) / 16777216.0;
+}
+
+fn rand_signed(seed: u32) -> f32 {
+  return rand01(seed) * 2.0 - 1.0;
+}

package/dist/effects/sparks/render.job.wgsl

@@ -0,0 +1,8 @@
+// Sparks render job placeholder.
+
+fn process_job(job_index: u32, job_type: u32, payload_words: u32) {
+  let _ignore = job_index + job_type + payload_words;
+  if (_ignore == 0u) {
+    return;
+  }
+}

package/dist/effects/sparks/update.job.wgsl

@@ -0,0 +1,53 @@
+// Sparks update job.
+
+fn respawn_spark(seed: u32) -> Particle {
+  let angle = rand01(seed) * TWO_PI;
+  let speed = 0.5 + rand01(seed ^ 0x9e3779b9u) * 1.6;
+  let radius = effect_params.spawn_radius * rand01(seed ^ 0x85ebca6bu);
+  let offset = vec2<f32>(cos(angle), sin(angle)) * radius;
+  let pos = effect_params.origin + offset;
+  let vel = vec2<f32>(cos(angle), sin(angle)) * speed;
+  let life = 0.3 + rand01(seed ^ 0x27d4eb2du) * 0.7;
+  return Particle(vec4<f32>(pos, life, f32(seed)), vec4<f32>(vel, 1.0, 0.0));
+}
+
+fn process_job(job_index: u32, job_type: u32, payload_words: u32) {
+  if (payload_words == 0u) {
+    return;
+  }
+  let particle_index = payload_word(job_index, 0u);
+  if (particle_index >= arrayLength(&particles)) {
+    return;
+  }
+
+  var particle = particles[particle_index];
+  var life = particle.pos.z;
+  let seed = u32(particle.pos.w) ^ (particle_index * 131u);
+
+  if (life <= 0.0) {
+    particle = respawn_spark(seed + u32(effect_params.time * 500.0));
+    particles[particle_index] = particle;
+    return;
+  }
+
+  var vel = particle.vel.xy;
+  var pos = particle.pos.xy;
+  vel.y = vel.y - 1.4 * effect_params.dt + effect_params.drift.y * effect_params.dt;
+  vel.x = vel.x + effect_params.drift.x * effect_params.dt;
+  vel = vel * 0.985;
+  pos = pos + vel * effect_params.dt;
+  life = life - effect_params.dt * 1.5;
+
+  if (pos.y < effect_params.bounds_min.y - 0.2 || pos.y > effect_params.bounds_max.y + 0.2) {
+    life = -1.0;
+  }
+
+  particle.pos = vec4<f32>(pos, life, f32(seed));
+  particle.vel = vec4<f32>(vel, particle.vel.z, particle.vel.w);
+
+  if (life <= 0.0) {
+    particle = respawn_spark(seed + 19u + u32(effect_params.time * 700.0));
+  }
+
+  particles[particle_index] = particle;
+}

package/dist/effects/text/layout.job.wgsl

@@ -0,0 +1,57 @@
+// Text layout job.
+
+fn respawn_text(seed: u32) -> Particle {
+  let x = effect_params.origin.x + rand_signed(seed) * effect_params.spawn_radius;
+  let y = effect_params.origin.y + rand01(seed ^ 0x9e3779b9u) * 0.05;
+  let value = f32(hash_u32(seed) % 10000u);
+  let lateral = rand_signed(seed ^ 0x85ebca6bu) * 0.12;
+  let upward = 0.55 + rand01(seed ^ 0x27d4eb2du) * 0.45;
+  let vel = vec2<f32>(lateral, upward);
+  let life = 2.2 + rand01(seed ^ 0x51a3c1u) * 1.2;
+  return Particle(vec4<f32>(vec2<f32>(x, y), life, f32(seed)), vec4<f32>(vel, 0.0, value));
+}
+
+fn process_job(job_index: u32, job_type: u32, payload_words: u32) {
+  if (payload_words == 0u) {
+    return;
+  }
+  let particle_index = payload_word(job_index, 0u);
+  if (particle_index >= arrayLength(&particles)) {
+    return;
+  }
+
+  var particle = particles[particle_index];
+  var life = particle.pos.z;
+  let seed = u32(particle.pos.w) ^ (particle_index * 113u);
+
+  if (life <= 0.0) {
+    let burst = rand01(seed ^ u32(effect_params.time * 120.0));
+    if (burst > 0.985) {
+      particle = respawn_text(seed + u32(effect_params.time * 600.0));
+      particles[particle_index] = particle;
+    }
+    return;
+  }
+
+  var pos = particle.pos.xy;
+  var vel = particle.vel.xy;
+  let dir = select(-1.0, 1.0, pos.x >= effect_params.origin.x);
+  vel.x = vel.x + dir * 0.18 * effect_params.dt;
+  vel.x = vel.x + effect_params.drift.x * effect_params.dt * 0.05;
+  vel.y = vel.y - 0.95 * effect_params.dt;
+  vel = vel * 0.995;
+  pos = pos + vel * effect_params.dt;
+
+  if (pos.y < effect_params.bounds_min.y - 0.1 || pos.x < effect_params.bounds_min.x - 0.1 || pos.x > effect_params.bounds_max.x + 0.1) {
+    life = -1.0;
+  }
+
+  particle.pos = vec4<f32>(pos, life, f32(seed));
+  particle.vel = vec4<f32>(vel, particle.vel.z, particle.vel.w);
+
+  if (life <= 0.0) {
+    particle = respawn_text(seed + 37u + u32(effect_params.time * 500.0));
+  }
+
+  particles[particle_index] = particle;
+}

package/dist/effects/text/prelude.wgsl

@@ -0,0 +1,39 @@
+// Text overlay effect shared WGSL definitions.
+
+struct Particle {
+  pos: vec4<f32>,
+  vel: vec4<f32>,
+};
+
+struct EffectParams {
+  time: f32,
+  dt: f32,
+  intensity: f32,
+  spawn_radius: f32,
+  bounds_min: vec2<f32>,
+  bounds_max: vec2<f32>,
+  origin: vec2<f32>,
+  drift: vec2<f32>,
+};
+
+@group(1) @binding(0) var<storage, read_write> particles: array<Particle>;
+@group(1) @binding(1) var<uniform> effect_params: EffectParams;
+
+fn hash_u32(x: u32) -> u32 {
+  var v = x;
+  v = v ^ (v >> 16u);
+  v = v * 0x7feb352du;
+  v = v ^ (v >> 15u);
+  v = v * 0x846ca68bu;
+  v = v ^ (v >> 16u);
+  return v;
+}
+
+fn rand01(seed: u32) -> f32 {
+  let v = hash_u32(seed) & 0x00ffffffu;
+  return f32(v) / 16777216.0;
+}
+
+fn rand_signed(seed: u32) -> f32 {
+  return rand01(seed) * 2.0 - 1.0;
+}

package/dist/effects/text/render.job.wgsl

@@ -0,0 +1,8 @@
+// Text render job placeholder.
+
+fn process_job(job_index: u32, job_type: u32, payload_words: u32) {
+  let _ignore = job_index + job_type + payload_words;
+  if (_ignore == 0u) {
+    return;
+  }
+}

package/dist/index.cjs

@@ -0,0 +1,286 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.js
+var index_exports = {};
+__export(index_exports, {
+  defaultParticleEffect: () => defaultParticleEffect,
+  getParticleEffect: () => getParticleEffect,
+  loadParticleEffectJobWgsl: () => loadParticleEffectJobWgsl,
+  loadParticleEffectJobs: () => loadParticleEffectJobs,
+  loadParticleEffectPreludeWgsl: () => loadParticleEffectPreludeWgsl,
+  loadParticleJobs: () => loadParticleJobs,
+  loadParticlePhysicsJobWgsl: () => loadParticlePhysicsJobWgsl,
+  loadParticlePreludeWgsl: () => loadParticlePreludeWgsl,
+  loadParticleRenderJobWgsl: () => loadParticleRenderJobWgsl,
+  particleEffectNames: () => particleEffectNames,
+  particleEffects: () => particleEffects,
+  particleJobLabels: () => particleJobLabels,
+  particleJobs: () => particleJobs,
+  particlePhysicsJobWgslUrl: () => particlePhysicsJobWgslUrl,
+  particlePreludeWgslUrl: () => particlePreludeWgslUrl,
+  particleRenderJobWgslUrl: () => particleRenderJobWgslUrl
+});
+module.exports = __toCommonJS(index_exports);
+var baseUrl = (() => {
+  if (false) {
+    return new URL("./index.js", void 0);
+  }
+  if (typeof __filename !== "undefined" && typeof require !== "undefined") {
+    const { pathToFileURL } = require("url");
+    return pathToFileURL(__filename);
+  }
+  const base = typeof process !== "undefined" && process.cwd ? `file://${process.cwd()}/` : "file:///";
+  return new URL("./index.js", base);
+})();
+var effectSpecs = {
+  fire: {
+    prelude: "prelude.wgsl",
+    jobs: {
+      physics: "physics.job.wgsl",
+      render: "render.job.wgsl"
+    }
+  },
+  sparks: {
+    prelude: "prelude.wgsl",
+    jobs: {
+      update: "update.job.wgsl",
+      render: "render.job.wgsl"
+    }
+  },
+  text: {
+    prelude: "prelude.wgsl",
+    jobs: {
+      layout: "layout.job.wgsl",
+      render: "render.job.wgsl"
+    }
+  },
+  rain: {
+    prelude: "prelude.wgsl",
+    jobs: {
+      update: "update.job.wgsl",
+      render: "render.job.wgsl"
+    }
+  },
+  snow: {
+    prelude: "prelude.wgsl",
+    jobs: {
+      update: "update.job.wgsl",
+      render: "render.job.wgsl"
+    }
+  },
+  firework: {
+    prelude: "prelude.wgsl",
+    jobs: {
+      update: "update.job.wgsl",
+      render: "render.job.wgsl"
+    }
+  }
+};
+function buildEffect(name, spec) {
+  const preludeUrl = new URL(`./effects/${name}/${spec.prelude}`, baseUrl);
+  const jobs = Object.entries(spec.jobs).map(([key, file]) => {
+    const label = `particles.${name}.${key}`;
+    return {
+      key,
+      label,
+      url: new URL(`./effects/${name}/${file}`, baseUrl),
+      sourceName: label
+    };
+  });
+  return {
+    name,
+    preludeUrl,
+    jobs
+  };
+}
+var particleEffects = Object.freeze(
+  Object.fromEntries(
+    Object.entries(effectSpecs).map(([name, spec]) => [
+      name,
+      buildEffect(name, spec)
+    ])
+  )
+);
+var particleEffectNames = Object.freeze(
+  Object.keys(particleEffects)
+);
+var defaultParticleEffect = "fire";
+function getEffectJob(effect, key) {
+  const job = effect.jobs.find((entry) => entry.key === key);
+  if (!job) {
+    const available = effect.jobs.map((entry) => entry.key).join(", ");
+    throw new Error(
+      `Unknown job "${key}" for effect "${effect.name}". Available: ${available}.`
+    );
+  }
+  return job;
+}
+function getParticleEffect(name = defaultParticleEffect) {
+  const effect = particleEffects[name];
+  if (!effect) {
+    const available = particleEffectNames.join(", ");
+    throw new Error(`Unknown particle effect "${name}". Available: ${available}.`);
+  }
+  return effect;
+}
+var defaultEffect = getParticleEffect(defaultParticleEffect);
+var defaultPhysicsJob = getEffectJob(defaultEffect, "physics");
+var defaultRenderJob = getEffectJob(defaultEffect, "render");
+var particlePreludeWgslUrl = defaultEffect.preludeUrl;
+var particlePhysicsJobWgslUrl = defaultPhysicsJob.url;
+var particleRenderJobWgslUrl = defaultRenderJob.url;
+var particleJobLabels = {
+  physics: defaultPhysicsJob.label,
+  render: defaultRenderJob.label
+};
+var particleJobs = [
+  {
+    label: defaultPhysicsJob.label,
+    url: defaultPhysicsJob.url,
+    sourceName: defaultPhysicsJob.sourceName
+  },
+  {
+    label: defaultRenderJob.label,
+    url: defaultRenderJob.url,
+    sourceName: defaultRenderJob.sourceName
+  }
+];
+function assertNotHtmlWgsl(source, context) {
+  const sample = source.slice(0, 200).toLowerCase();
+  if (sample.includes("<!doctype") || sample.includes("<html") || sample.includes("<meta")) {
+    const label = context ? ` for ${context}` : "";
+    throw new Error(
+      `Expected WGSL${label} but received HTML. Check the URL or server root.`
+    );
+  }
+}
+async function loadWgslSource(options = {}) {
+  const { wgsl, url, fetcher = globalThis.fetch, base } = options ?? {};
+  if (typeof wgsl === "string") {
+    assertNotHtmlWgsl(wgsl, "inline WGSL");
+    return wgsl;
+  }
+  if (!url) {
+    return null;
+  }
+  const resolved = url instanceof URL ? url : new URL(url, base ?? baseUrl);
+  if (!fetcher || resolved.protocol === "file:") {
+    const { readFile } = await import("fs/promises");
+    const { fileURLToPath } = await import("url");
+    const source2 = await readFile(fileURLToPath(resolved), "utf8");
+    assertNotHtmlWgsl(source2, resolved.href);
+    return source2;
+  }
+  const response = await fetcher(resolved);
+  if (!response.ok) {
+    const status = "status" in response ? response.status : "unknown";
+    const statusText = "statusText" in response ? response.statusText : "";
+    const detail = statusText ? `${status} ${statusText}` : `${status}`;
+    throw new Error(`Failed to load WGSL (${detail})`);
+  }
+  const source = await response.text();
+  assertNotHtmlWgsl(source, resolved.href);
+  return source;
+}
+async function loadEffectPrelude(effect, fetcher) {
+  const source = await loadWgslSource({ url: effect.preludeUrl, fetcher });
+  if (typeof source !== "string") {
+    throw new Error(`Failed to load ${effect.name} prelude WGSL source.`);
+  }
+  return source;
+}
+async function loadEffectJob(effect, job, fetcher) {
+  const source = await loadWgslSource({ url: job.url, fetcher });
+  if (typeof source !== "string") {
+    throw new Error(
+      `Failed to load ${effect.name} job "${job.key}" WGSL source.`
+    );
+  }
+  return source;
+}
+async function loadParticleEffectPreludeWgsl(effectName, options = {}) {
+  const { fetcher } = options ?? {};
+  const effect = getParticleEffect(effectName);
+  return loadEffectPrelude(effect, fetcher);
+}
+async function loadParticleEffectJobWgsl(effectName, jobKey, options = {}) {
+  const { fetcher } = options ?? {};
+  const effect = getParticleEffect(effectName);
+  const job = getEffectJob(effect, jobKey);
+  return loadEffectJob(effect, job, fetcher);
+}
+async function loadParticleEffectJobs(effectName, options = {}) {
+  const { fetcher } = options ?? {};
+  const effect = getParticleEffect(effectName);
+  const preludeWgsl = await loadEffectPrelude(effect, fetcher);
+  const jobSources = await Promise.all(
+    effect.jobs.map((job) => loadEffectJob(effect, job, fetcher))
+  );
+  const jobs = effect.jobs.map((job, index) => ({
+    wgsl: jobSources[index],
+    label: job.label,
+    sourceName: job.sourceName
+  }));
+  return { preludeWgsl, jobs };
+}
+async function loadParticlePreludeWgsl(options = {}) {
+  const { fetcher } = options ?? {};
+  return loadEffectPrelude(defaultEffect, fetcher);
+}
+async function loadParticlePhysicsJobWgsl(options = {}) {
+  const { fetcher } = options ?? {};
+  return loadEffectJob(defaultEffect, defaultPhysicsJob, fetcher);
+}
+async function loadParticleRenderJobWgsl(options = {}) {
+  const { fetcher } = options ?? {};
+  return loadEffectJob(defaultEffect, defaultRenderJob, fetcher);
+}
+async function loadParticleJobs(options = {}) {
+  return loadParticleEffectJobs(defaultParticleEffect, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultParticleEffect,
+  getParticleEffect,
+  loadParticleEffectJobWgsl,
+  loadParticleEffectJobs,
+  loadParticleEffectPreludeWgsl,
+  loadParticleJobs,
+  loadParticlePhysicsJobWgsl,
+  loadParticlePreludeWgsl,
+  loadParticleRenderJobWgsl,
+  particleEffectNames,
+  particleEffects,
+  particleJobLabels,
+  particleJobs,
+  particlePhysicsJobWgslUrl,
+  particlePreludeWgslUrl,
+  particleRenderJobWgslUrl
+});
+//# sourceMappingURL=index.cjs.map