@godot-scene-web/effects 0.1.0

package/dist/index-pM1LimTu.d.ts

@@ -0,0 +1,372 @@
+//#region src/particles/godot-renderer.d.ts
+/**
+ * Which Godot rendering backend a browser render should imitate.
+ *
+ * Named after the CAUSE rather than after the correction: the two RendererRD backends
+ * behave one way and Compatibility the other, and the option says which engine produced
+ * the pixels the browser is being asked to match.
+ *
+ * Defaults to `"forward_plus"` — Godot's own default `rendering/renderer/rendering_method`
+ * for a new project, and what a capture is overwhelmingly likely to have come from.
+ */
+type GodotRendererBackend = "forward_plus" | "mobile" | "gl_compatibility";
+/** The default backend: Godot's own default for a new project. */
+declare const DEFAULT_GODOT_RENDERER: GodotRendererBackend;
+/** Coerce an untrusted value (a hand-authored spec blob, a consumer option) to a backend. */
+declare function normalizeGodotRenderer(value: unknown): GodotRendererBackend;
+/**
+ * True when the backend runs `ParticleProcessMaterial.color` through
+ * `Color::srgb_to_linear()` at UBO-upload time. Both RendererRD backends do;
+ * Compatibility/GLES3 does not.
+ */
+declare function linearizesParticleColor(renderer: GodotRendererBackend): boolean;
+/**
+ * Godot's `Color::srgb_to_linear()`, one channel — `core/math/color.h:191-197`:
+ *
+ * ```cpp
+ * r < 0.04045f ? r * (1.0f / 12.92f)
+ *              : Math::pow(float((r + 0.055) * (1.0 / (1.0 + 0.055))), 2.4f)
+ * ```
+ *
+ * The piecewise IEC 61966-2-1 curve with exponent **2.4**, not a `pow(x, 2.2)`
+ * approximation, and the threshold comparison is strict `<`. Written here the way Godot
+ * writes it — reciprocal multiplies rather than divides — so the two read the same;
+ * Godot evaluates the inner expression in double and then narrows to float before
+ * `pow`, while JS stays in double throughout, a difference orders of magnitude below
+ * the 1/255 the comparison is made at.
+ *
+ * Note the fixed point at both ends: `srgbToLinear(0) === 0` and `srgbToLinear(1) === 1`.
+ * A fully saturated channel is where this curve is the identity, which is why it is the
+ * per-channel regression check on the parity fixture (see `docs/parity.md`).
+ */
+declare function srgbToLinear(value: number): number;
+/**
+ * A particle system's base colour as the given backend uploads it: RGB through
+ * {@link srgbToLinear} on the RendererRD backends, returned unchanged on
+ * Compatibility/GLES3.
+ *
+ * `fromProcessMaterial` is the scope gate. Only `ParticleProcessMaterial.color` — a
+ * `GPUParticles2D` with a process material — rides the UBO path that linearizes. When the
+ * base colour instead came from `CPUParticles2D.color` or the node's `modulate`, it reaches
+ * the canvas by a route Godot leaves in sRGB whatever the backend, and this returns it
+ * untouched.
+ *
+ * **ALPHA IS NEVER TOUCHED.** `Color::srgb_to_linear()` passes `a` straight through
+ * (`color.h:196`), so the coverage the blend algebra runs on is the authored value on
+ * every backend and every path.
+ *
+ * Always returns a fresh tuple, so callers never alias the raw colour they passed in.
+ */
+declare function linearizeParticleBaseColor(color: readonly [number, number, number, number], renderer: GodotRendererBackend, fromProcessMaterial: boolean): [number, number, number, number];
+//#endregion
+//#region src/particles/sampling.d.ts
+/** Renderer-neutral ramp and curve values used by particle state and texture bakers. */
+interface ParticleGradientStop {
+  offset: number;
+  color: [number, number, number, number];
+}
+interface ParticleCurvePoint {
+  x: number;
+  y: number;
+}
+/** Godot-style endpoint-clamped gradient sampling. */
+declare function sampleParticleGradient(stops: readonly ParticleGradientStop[], t: number, interpolationMode?: number): [number, number, number, number];
+/** Allocation-free gradient sampling for simulation hot paths. */
+declare function sampleParticleGradientInto(stops: readonly ParticleGradientStop[], t: number, out: [number, number, number, number], interpolationMode?: number): void;
+/** Godot-style endpoint-clamped linear curve sampling. */
+declare function sampleParticleCurve(points: readonly ParticleCurvePoint[], t: number): number;
+declare function normalizeParticleCurve(points: readonly ParticleCurvePoint[] | undefined): ParticleCurvePoint[] | undefined;
+//#endregion
+//#region src/particles/config.d.ts
+/** Renderer-neutral particle simulation contract. */
+interface ParticleConfig {
+  kind: "CPUParticles2D" | "GPUParticles2D";
+  /**
+   * Which Godot backend the browser render is imitating (`GodotHtmlRenderOptions.godotRenderer`,
+   * default `"forward_plus"`). Its ONLY effect is `baseColorRender` below — see
+   * `./godot-renderer.ts`.
+   */
+  godotRenderer: GodotRendererBackend;
+  amount: number;
+  amountRatio: number;
+  lifetime: number;
+  lifetimeRandomness: number;
+  oneShot: boolean;
+  emitting: boolean;
+  explosiveness: number;
+  randomness: number;
+  preprocess: number;
+  speedScale: number;
+  /** 0 => use 1/30 fixed step. */
+  fixedFps: number;
+  localCoords: boolean;
+  /** 0 = index, 1 = lifetime, 2 = reverse-lifetime (affects draw order only). */
+  drawOrder: number;
+  seed: number;
+  /** 0 point, 1 sphere(disk), 2 sphere-surface(ring), 3 box, 4 points, 6 ring. */
+  emissionShape: number;
+  emissionOffset: [number, number];
+  emissionScale: [number, number];
+  emissionSphereRadius: number;
+  emissionRingRadius: number;
+  emissionRingInnerRadius: number;
+  emissionRingHeight: number;
+  emissionBoxExtents: [number, number];
+  direction: [number, number];
+  /** Half-angle, degrees. */
+  spread: number;
+  initialVelocityMin: number;
+  initialVelocityMax: number;
+  /** Degrees. */
+  angleMin: number;
+  angleMax: number;
+  /** Degrees / second. */
+  angularVelocityMin: number;
+  angularVelocityMax: number;
+  gravity: [number, number];
+  linearAccelMin: number;
+  linearAccelMax: number;
+  radialAccelMin: number;
+  radialAccelMax: number;
+  tangentialAccelMin: number;
+  tangentialAccelMax: number;
+  dampingMin: number;
+  dampingMax: number;
+  dampingAsFriction: boolean;
+  /** Revolutions / second. */
+  orbitVelocityMin: number;
+  orbitVelocityMax: number;
+  scaleMin: number;
+  scaleMax: number;
+  hueVariationMin: number;
+  hueVariationMax: number;
+  alignY: boolean;
+  /** The system's base colour exactly as Godot serialized it — raw sRGB, never converted. */
+  baseColor: [number, number, number, number];
+  /**
+   * Whether `baseColor` came from `ParticleProcessMaterial.color` rather than from
+   * `CPUParticles2D.color` or the node's `modulate`. Gates the `godotRenderer` correction:
+   * only the process material rides the UBO path Godot linearizes. Defaults (when a
+   * hand-authored blob omits it) to `kind === "GPUParticles2D"`.
+   */
+  baseColorFromProcessMaterial: boolean;
+  /**
+   * `baseColor` as `godotRenderer` uploads it to the GPU: RGB through
+   * `Color::srgb_to_linear()` on `forward_plus`/`mobile` when
+   * `baseColorFromProcessMaterial`, IDENTICAL to `baseColor` otherwise. Alpha is never
+   * converted on any backend. This is the field the simulation multiplies (`simulate.ts`);
+   * `baseColor` is kept beside it as the authored value.
+   *
+   * DERIVED: `normalizeParticleConfig` always RECOMPUTES it from `baseColor`,
+   * `godotRenderer` and `baseColorFromProcessMaterial`, so the serialized value cannot go
+   * stale or lie. Deriving it rather
+   * than overwriting `baseColor` in place is what keeps normalization IDEMPOTENT —
+   * `normalizeParticleConfig(normalizeParticleConfig(x))` would otherwise apply the curve
+   * twice, and several call sites do re-normalize an already-normalized config.
+   */
+  baseColorRender: [number, number, number, number];
+  hframes: number;
+  vframes: number;
+  frameCount?: number;
+  animLoop: boolean;
+  animSpeedMin: number;
+  animSpeedMax: number;
+  animOffsetMin: number;
+  animOffsetMax: number;
+  colorRamp?: ParticleGradientStop[];
+  colorInitialRamp?: ParticleGradientStop[];
+  scaleCurve?: ParticleCurvePoint[];
+  scaleCurveX?: ParticleCurvePoint[];
+  scaleCurveY?: ParticleCurvePoint[];
+  alphaCurve?: ParticleCurvePoint[];
+  hueCurve?: ParticleCurvePoint[];
+}
+/** Renderer-facing particle fields that remain portable (no URLs or DOM placement). */
+interface ParticleRenderConfig extends ParticleConfig {
+  textureWidth: number;
+  textureHeight: number;
+  flipbookCropOnly?: boolean;
+  blendMode: number;
+  colorLut?: ParticleGradientStop[];
+  colorLutInterpolation?: number;
+  alphaFromRed?: boolean;
+  alphaErode?: {
+    threshold: number;
+    softness: number;
+  } | null;
+  uvPolar?: boolean;
+}
+//#endregion
+//#region src/particles/instance-buffer.d.ts
+/** Floats per particle render instance: center.xy, scale.xy, rotation, color.rgba, frame. */
+declare const INSTANCE_STRIDE = 10;
+/**
+ * CPU-owned packed particle instances. This class deliberately knows nothing about
+ * WebGL, WebGPU, a canvas, or a device lifecycle; render adapters own residency.
+ */
+declare class InstanceBuffer {
+  data: Float32Array;
+  /** Number of instances written since the last reset. */
+  count: number;
+  private capacity;
+  constructor(initialCapacity?: number);
+  reset(): void;
+  push(x: number, y: number, scaleX: number, scaleY: number, rotation: number, r: number, g: number, b: number, a: number, frame: number): void;
+  ensureCapacity(instances: number): void;
+}
+//#endregion
+//#region src/particles/state.d.ts
+interface Particle {
+  active: boolean;
+  /** Age in seconds. */
+  time: number;
+  /** This particle's randomized lifetime (seconds). */
+  lifetime: number;
+  /** Position in node-local pixels. */
+  x: number;
+  y: number;
+  /** Velocity in px/s. */
+  vx: number;
+  vy: number;
+  /** Rotation in radians. */
+  rotation: number;
+  /** Per-frame force RNG seed (stable per particle). */
+  seed: number;
+  angleRand: number;
+  scaleRand: number;
+  hueRand: number;
+  animOffsetRand: number;
+  /** color_initial_ramp sampled once at spawn (or white). */
+  startColor: [number, number, number, number];
+  scaleX: number;
+  scaleY: number;
+  r: number;
+  g: number;
+  b: number;
+  a: number;
+  /** Flipbook frame index. */
+  frame: number;
+}
+interface ParticleSystemState {
+  config: ParticleConfig;
+  particles: Particle[];
+  /** System time within the current cycle, wrapped to [0, lifetime). */
+  time: number;
+  /** Number of completed lifetime cycles (drives spawn timing + one-shot end). */
+  cycle: number;
+  /** Live emit flag — starts at `config.emitting`, cleared after a one-shot cycle. */
+  emitting: boolean;
+  /** Fixed-step remainder accumulator. */
+  remainder: number;
+  /** Effective particle count after the maxInstances clamp. */
+  count: number;
+}
+declare function createParticleState(config: ParticleConfig, maxInstances?: number): ParticleSystemState;
+/** Whether the system still needs simulating (live particles or still emitting). */
+declare function particlesAreLive(state: ParticleSystemState): boolean;
+declare function normalizeParticleConfig(raw: Partial<ParticleConfig> | null | undefined): ParticleConfig;
+/** Normalize portable renderer inputs without admitting HTML URL or placement fields. */
+declare function normalizeParticleRenderConfig(raw: Partial<ParticleRenderConfig> | null | undefined): ParticleRenderConfig;
+//#endregion
+//#region src/particles/pack-instances.d.ts
+interface ParticleInstanceTransform {
+  readonly xx: number;
+  readonly xy: number;
+  readonly yx: number;
+  readonly yy: number;
+  readonly originX: number;
+  readonly originY: number;
+  readonly scale?: number;
+  readonly rotation?: number;
+}
+interface ParticleInstancePackInput {
+  readonly state: ParticleSystemState;
+  readonly config: Pick<ParticleRenderConfig, "hframes" | "vframes" | "flipbookCropOnly">;
+  readonly instances: InstanceBuffer;
+  readonly textureWidth: number;
+  readonly textureHeight: number;
+  readonly origin?: readonly [number, number];
+  readonly transform?: ParticleInstanceTransform;
+  readonly modulate?: readonly [number, number, number, number];
+}
+/** The sprite-sheet grid used for a texture; untextured particles always have one frame. */
+declare function frameGridFor(textured: boolean, hframes: number, vframes: number): [number, number];
+/** Pack live particle state into a caller-owned, reusable GPU instance buffer. */
+declare function packParticleInstances(input: ParticleInstancePackInput): number;
+//#endregion
+//#region src/particles/simulate.d.ts
+/**
+ * Advance the system by `dt` seconds (real time), stepping the simulation in fixed
+ * `1/fixed_fps` (or 1/30) chunks so the look is frame-rate independent. Mutates
+ * `state` in place. `maxSteps` bounds the loop (warm-up / tab-switch spikes).
+ *
+ * Returns the number of fixed sub-steps it actually executed — the unit of work this function
+ * does, and the only honest denominator for its cost: one display frame can run zero steps (a
+ * fast display under a 30Hz `fixed_fps`, or `speed_scale: 0`) or many (a long dt, a warm-up), so
+ * a profiler that divided wall-clock by FRAMES would be measuring the display, not the sim (see
+ * `ParticleProfile.simSteps` in `./runtime`). Purely additive: every caller may ignore it, and
+ * this function stays pure of any clock.
+ */
+declare function simulateParticles(state: ParticleSystemState, dt: number, maxSteps?: number): number;
+/**
+ * Warm-start a freshly created system by its `preprocess` time (Godot pre-simulates
+ * that much before first draw, so a long-lived ambient — fog with preprocess=100 —
+ * appears mid-drift instead of empty/bursty). A REPEATING system reaches its steady
+ * state within two lifetime cycles (a particle's look depends on its age, not absolute
+ * time), so simulating `min(preprocess, 2 x lifetime)` is visually identical to the
+ * full preprocess at bounded cost; a one-shot's whole life fits in that window too.
+ * Steps are sized to cover the window (the default `maxSteps` caps at ~33s), and the
+ * sub-step remainder is dropped so the leftover doesn't fast-forward the first live
+ * frames at ~1000 steps per tick.
+ */
+declare function preprocessParticles(state: ParticleSystemState): void;
+/**
+ * Warm a system to a representative FROZEN state for the runtime's static/particles mode. Reuses the authored
+ * `preprocess` (an ambient emitter with preprocess>0 reaches its steady drift — identical to `preprocessParticles`),
+ * and for a system that would otherwise sit at spawn (preprocess<=0, e.g. a one-shot burst or an un-preprocessed
+ * emitter) advances a representative slice of a lifetime so the frozen frame is populated. Mutates `state`; the
+ * caller draws once and then stops simulating (see the particle runtime's static mode).
+ *
+ * This warm has no notion of the burst ENDING — it is a single representative frame, so a one-shot warmed here
+ * would otherwise be drawn as mid-flight forever. `staticOneShotExpired` is what retires it.
+ */
+declare function warmStaticParticles(state: ParticleSystemState): void;
+/**
+ * Godot's own ACTIVE WINDOW for one one-shot cycle, in seconds: `lifetime * (2 - explosiveness)`
+ * (particles.cpp `active_time`). At explosiveness 1 every particle is born at t=0, so the cycle is one
+ * lifetime; at 0 the births are spread over a full lifetime, so the last particle dies at 2x lifetime.
+ *
+ * This is the SAME law the game-side mod uses to schedule a frozen one-shot's synthesized end-of-burst
+ * (`CouchCoopHeadlessVisualSuspender.FinishNudgeDelaySeconds`), deliberately: the two sides have to agree on
+ * when a burst is over, or one of them keeps drawing/reporting it after the other has stopped. No clamp and no
+ * margin here — the mod's margin exists so its removal delta lands AFTER the client's tail, and this side IS
+ * that tail. `normalizeParticleConfig` already guarantees a finite `lifetime >= 0.01` and `explosiveness` in
+ * [0,1], so the result is finite and positive.
+ *
+ * `speedScale` is deliberately NOT folded in, for the same reason: the mod's law does not either, and a
+ * disagreement would be worse than the (rare, small) inaccuracy of a re-timed burst.
+ */
+declare function oneShotBurstSeconds(cfg: ParticleConfig): number;
+/**
+ * FROZEN-MODE expiry decision: has a one-shot burst the client has been drawing statically outlived its own
+ * active window, so the runtime should stop drawing it? Pure (no clock, no DOM) — the caller supplies the
+ * seconds elapsed since IT first saw this system emitting.
+ *
+ * WHY THIS EXISTS. In frozen/static mode a system is warmed to a representative mid-flight frame and that frame
+ * is parked forever — which is right for an ambient emitter (it really does emit forever) and wrong for a
+ * one-shot (it is a BURST; it ends). Nothing else can retire it: the frozen runtime never simulates, so the
+ * sim's own end-of-cycle never runs, and the only other input is the host's `emitting` flag — which a host can
+ * get stuck on (the live case: a game-side freeze left `Emitting` latched true on every energy-counter VFX, so
+ * the mirror drew a permanent "energy ring" over a counter the game was showing bare).
+ *
+ * WHY "since FIRST SIGHT". The client cannot know when the game started the burst — it sees only "this spec
+ * says emitting". One full active window from first sight is exactly what the burst itself would do, so a
+ * legitimate transient (a hit spark, a card-play flourish) still shows for its natural life; only a burst that
+ * outlives its own window — i.e. one nothing ever turned off — is dropped.
+ */
+declare function staticOneShotExpired(cfg: ParticleConfig, secondsSinceFirstEmitting: number): boolean;
+/** Live particle count (for tests / draw). */
+declare function activeParticleCount(state: ParticleSystemState): number;
+//#endregion
+export { linearizesParticleColor as A, normalizeParticleCurve as C, DEFAULT_GODOT_RENDERER as D, sampleParticleGradientInto as E, srgbToLinear as M, GodotRendererBackend as O, ParticleGradientStop as S, sampleParticleGradient as T, INSTANCE_STRIDE as _, staticOneShotExpired as a, ParticleRenderConfig as b, ParticleInstanceTransform as c, Particle as d, ParticleSystemState as f, particlesAreLive as g, normalizeParticleRenderConfig as h, simulateParticles as i, normalizeGodotRenderer as j, linearizeParticleBaseColor as k, frameGridFor as l, normalizeParticleConfig as m, oneShotBurstSeconds as n, warmStaticParticles as o, createParticleState as p, preprocessParticles as r, ParticleInstancePackInput as s, activeParticleCount as t, packParticleInstances as u, InstanceBuffer as v, sampleParticleCurve as w, ParticleCurvePoint as x, ParticleConfig as y };
+//# sourceMappingURL=index-pM1LimTu.d.ts.map

package/dist/index-pM1LimTu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-pM1LimTu.d.ts","names":[],"sources":["../src/particles/godot-renderer.ts","../src/particles/sampling.ts","../src/particles/config.ts","../src/particles/instance-buffer.ts","../src/particles/state.ts","../src/particles/pack-instances.ts","../src/particles/simulate.ts"],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { n as godotEaseSample, t as createEaseSampler } from "./index-CeKMJryT.js";
+import { A as linearizesParticleColor, C as normalizeParticleCurve, D as DEFAULT_GODOT_RENDERER, E as sampleParticleGradientInto, M as srgbToLinear, O as GodotRendererBackend, S as ParticleGradientStop, T as sampleParticleGradient, _ as INSTANCE_STRIDE, a as staticOneShotExpired, b as ParticleRenderConfig, c as ParticleInstanceTransform, d as Particle, f as ParticleSystemState, g as particlesAreLive, h as normalizeParticleRenderConfig, i as simulateParticles, j as normalizeGodotRenderer, k as linearizeParticleBaseColor, l as frameGridFor, m as normalizeParticleConfig, n as oneShotBurstSeconds, o as warmStaticParticles, p as createParticleState, r as preprocessParticles, s as ParticleInstancePackInput, t as activeParticleCount, u as packParticleInstances, v as InstanceBuffer, w as sampleParticleCurve, x as ParticleCurvePoint, y as ParticleConfig } from "./index-pM1LimTu.js";
+import { GodotBlendMode, ParsedShader, ShaderAnalysis, ShaderSampler, ShaderUniform, ShaderVarying, ShaderVaryingHoist, TranspiledShader, TranspiledWgslShader, UnsupportedShaderError, UnsupportedWgslShaderError, WgslBindings, WgslBuiltinOffsets, WgslStructField, WgslStructLayout, WgslStructMember, WgslUniformField, analyzeShader, expandGodotShaderIncludes, extractFunction, hasToken, matchBrace, parseShader, promoteIntLiterals, rejectUnsupported, replaceToken, sanitizeReservedIdentifiers, shaderLogic, stripComments, transpileGodotShader, transpileGodotShaderWgsl, unwrapShaderResource, wgslStructLayout } from "./shaders/index.js";
+export { DEFAULT_GODOT_RENDERER, GodotBlendMode, type GodotRendererBackend, INSTANCE_STRIDE, InstanceBuffer, ParsedShader, type Particle, type ParticleConfig, type ParticleCurvePoint, type ParticleGradientStop, type ParticleInstancePackInput, type ParticleInstanceTransform, type ParticleRenderConfig, type ParticleSystemState, ShaderAnalysis, ShaderSampler, ShaderUniform, ShaderVarying, ShaderVaryingHoist, TranspiledShader, TranspiledWgslShader, UnsupportedShaderError, UnsupportedWgslShaderError, WgslBindings, WgslBuiltinOffsets, WgslStructField, WgslStructLayout, WgslStructMember, WgslUniformField, activeParticleCount, analyzeShader, createEaseSampler, createParticleState, expandGodotShaderIncludes, extractFunction, frameGridFor, godotEaseSample, hasToken, linearizeParticleBaseColor, linearizesParticleColor, matchBrace, normalizeGodotRenderer, normalizeParticleConfig, normalizeParticleCurve, normalizeParticleRenderConfig, oneShotBurstSeconds, packParticleInstances, parseShader, particlesAreLive, preprocessParticles, promoteIntLiterals, rejectUnsupported, replaceToken, sampleParticleCurve, sampleParticleGradient, sampleParticleGradientInto, sanitizeReservedIdentifiers, shaderLogic, simulateParticles, srgbToLinear, staticOneShotExpired, stripComments, transpileGodotShader, transpileGodotShaderWgsl, unwrapShaderResource, warmStaticParticles, wgslStructLayout };

package/dist/index.js

@@ -0,0 +1,4 @@
+import { n as godotEaseSample, t as createEaseSampler } from "./easing-BH-VRsXl.js";
+import { C as srgbToLinear, S as normalizeGodotRenderer, _ as INSTANCE_STRIDE, a as activeParticleCount, b as linearizeParticleBaseColor, c as simulateParticles, d as normalizeParticleCurve, f as sampleParticleCurve, g as packParticleInstances, h as frameGridFor, i as particlesAreLive, l as staticOneShotExpired, m as sampleParticleGradientInto, n as normalizeParticleConfig, o as oneShotBurstSeconds, p as sampleParticleGradient, r as normalizeParticleRenderConfig, s as preprocessParticles, t as createParticleState, u as warmStaticParticles, v as InstanceBuffer, x as linearizesParticleColor, y as DEFAULT_GODOT_RENDERER } from "./particles-CQC9BFSI.js";
+import { UnsupportedShaderError, UnsupportedWgslShaderError, analyzeShader, expandGodotShaderIncludes, extractFunction, hasToken, matchBrace, parseShader, promoteIntLiterals, rejectUnsupported, replaceToken, sanitizeReservedIdentifiers, shaderLogic, stripComments, transpileGodotShader, transpileGodotShaderWgsl, unwrapShaderResource, wgslStructLayout } from "./shaders/index.js";
+export { DEFAULT_GODOT_RENDERER, INSTANCE_STRIDE, InstanceBuffer, UnsupportedShaderError, UnsupportedWgslShaderError, activeParticleCount, analyzeShader, createEaseSampler, createParticleState, expandGodotShaderIncludes, extractFunction, frameGridFor, godotEaseSample, hasToken, linearizeParticleBaseColor, linearizesParticleColor, matchBrace, normalizeGodotRenderer, normalizeParticleConfig, normalizeParticleCurve, normalizeParticleRenderConfig, oneShotBurstSeconds, packParticleInstances, parseShader, particlesAreLive, preprocessParticles, promoteIntLiterals, rejectUnsupported, replaceToken, sampleParticleCurve, sampleParticleGradient, sampleParticleGradientInto, sanitizeReservedIdentifiers, shaderLogic, simulateParticles, srgbToLinear, staticOneShotExpired, stripComments, transpileGodotShader, transpileGodotShaderWgsl, unwrapShaderResource, warmStaticParticles, wgslStructLayout };

package/dist/particles/index.d.ts

@@ -0,0 +1,2 @@
+import { A as linearizesParticleColor, C as normalizeParticleCurve, D as DEFAULT_GODOT_RENDERER, E as sampleParticleGradientInto, M as srgbToLinear, O as GodotRendererBackend, S as ParticleGradientStop, T as sampleParticleGradient, _ as INSTANCE_STRIDE, a as staticOneShotExpired, b as ParticleRenderConfig, c as ParticleInstanceTransform, d as Particle, f as ParticleSystemState, g as particlesAreLive, h as normalizeParticleRenderConfig, i as simulateParticles, j as normalizeGodotRenderer, k as linearizeParticleBaseColor, l as frameGridFor, m as normalizeParticleConfig, n as oneShotBurstSeconds, o as warmStaticParticles, p as createParticleState, r as preprocessParticles, s as ParticleInstancePackInput, t as activeParticleCount, u as packParticleInstances, v as InstanceBuffer, w as sampleParticleCurve, x as ParticleCurvePoint, y as ParticleConfig } from "../index-pM1LimTu.js";
+export { DEFAULT_GODOT_RENDERER, type GodotRendererBackend, INSTANCE_STRIDE, InstanceBuffer, type Particle, type ParticleConfig, type ParticleCurvePoint, type ParticleGradientStop, type ParticleInstancePackInput, type ParticleInstanceTransform, type ParticleRenderConfig, type ParticleSystemState, activeParticleCount, createParticleState, frameGridFor, linearizeParticleBaseColor, linearizesParticleColor, normalizeGodotRenderer, normalizeParticleConfig, normalizeParticleCurve, normalizeParticleRenderConfig, oneShotBurstSeconds, packParticleInstances, particlesAreLive, preprocessParticles, sampleParticleCurve, sampleParticleGradient, sampleParticleGradientInto, simulateParticles, srgbToLinear, staticOneShotExpired, warmStaticParticles };

package/dist/particles/index.js

@@ -0,0 +1,2 @@
+import { C as srgbToLinear, S as normalizeGodotRenderer, _ as INSTANCE_STRIDE, a as activeParticleCount, b as linearizeParticleBaseColor, c as simulateParticles, d as normalizeParticleCurve, f as sampleParticleCurve, g as packParticleInstances, h as frameGridFor, i as particlesAreLive, l as staticOneShotExpired, m as sampleParticleGradientInto, n as normalizeParticleConfig, o as oneShotBurstSeconds, p as sampleParticleGradient, r as normalizeParticleRenderConfig, s as preprocessParticles, t as createParticleState, u as warmStaticParticles, v as InstanceBuffer, x as linearizesParticleColor, y as DEFAULT_GODOT_RENDERER } from "../particles-CQC9BFSI.js";
+export { DEFAULT_GODOT_RENDERER, INSTANCE_STRIDE, InstanceBuffer, activeParticleCount, createParticleState, frameGridFor, linearizeParticleBaseColor, linearizesParticleColor, normalizeGodotRenderer, normalizeParticleConfig, normalizeParticleCurve, normalizeParticleRenderConfig, oneShotBurstSeconds, packParticleInstances, particlesAreLive, preprocessParticles, sampleParticleCurve, sampleParticleGradient, sampleParticleGradientInto, simulateParticles, srgbToLinear, staticOneShotExpired, warmStaticParticles };