@godot-scene-web/canvas-effects 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tomás Fox
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/webgl.d.mts

@@ -0,0 +1,409 @@
+import { InstanceBuffer, ParticleRenderConfig, ParticleSystemState } from "@godot-scene-web/effects/particles";
+import { GodotBlendMode, ShaderUniform } from "@godot-scene-web/effects/shaders";
+
+//#region src/particle-webgl.d.ts
+/** A borrowed GL context and quad. Core never creates or owns either resource. */
+interface ParticleGl {
+  gl: WebGL2RenderingContext;
+  quad: WebGLBuffer;
+}
+/** Release one portable buffer's WebGL allocation on its owning borrowed context. */
+declare function disposeParticleInstanceBuffer(gl: WebGL2RenderingContext, instances: InstanceBuffer): void;
+/** Context-loss path: forget driver names without issuing GL commands. */
+declare function invalidateParticleInstanceBuffer(gl: WebGL2RenderingContext, instances: InstanceBuffer): void;
+interface AccumTarget {
+  fbo: WebGLFramebuffer;
+  texture: WebGLTexture;
+  width: number;
+  height: number;
+}
+interface ParticleProgram {
+  program: WebGLProgram;
+  cornerBuffer: WebGLBuffer;
+  uViewport: WebGLUniformLocation | null;
+  uHframes: WebGLUniformLocation | null;
+  uVframes: WebGLUniformLocation | null;
+  uTexture: WebGLUniformLocation | null;
+  uLutTex: WebGLUniformLocation | null;
+  uMaskTex: WebGLUniformLocation | null;
+  uTextured: WebGLUniformLocation | null;
+  uLut: WebGLUniformLocation | null;
+  uAdditive: WebGLUniformLocation | null;
+  uAlphaFromRed: WebGLUniformLocation | null;
+  uErode: WebGLUniformLocation | null;
+  uErodeFactors: WebGLUniformLocation | null;
+  uMask: WebGLUniformLocation | null;
+  uUvPolar: WebGLUniformLocation | null;
+  /** Additive resolve pass (normalize summed light -> straight color + coverage). */
+  resolveProgram: WebGLProgram;
+  uAccum: WebGLUniformLocation | null;
+  accum: AccumTarget | null;
+}
+declare function getParticleProgram(gl: WebGL2RenderingContext): ParticleProgram | null;
+interface DrawParticlesOptions {
+  texture: WebGLTexture | null;
+  textured: boolean;
+  /**
+   * Baked per-texel color LUT (1px-tall RGBA ramp) bound on texture unit 1, or null.
+   * Present => the fragment shader replaces each texel's RGB with `lut(texel.r)`, keeping
+   * the source alpha. See `ParticleSpecConfig.colorLut`.
+   */
+  lutTexture?: WebGLTexture | null;
+  /**
+   * Quad-shaped coverage mask bound on texture unit 2, or null. Present => the fragment multiplies coverage by
+   * its RED channel (`ParticleSpecConfig.maskUrl`). A still-loading texture is the shared 1x1 TRANSPARENT
+   * placeholder, so the system stays invisible until it decodes — the same "no mask, no particle" the game shows.
+   */
+  maskTexture?: WebGLTexture | null;
+  hframes: number;
+  vframes: number;
+  blendMode: number;
+  viewportW: number;
+  viewportH: number;
+  /** The rect the pixels actually LAND in (≤ viewportW/H): the caller's clamped `gl.viewport`
+   *  when the shared drawing buffer couldn't hold the full viewportW×H (see
+   *  `ensureSharedDrawSize`). `viewportW/H` stay the px coordinate DOMAIN (the vertex NDC
+   *  mapping divides by them), so a smaller target scales the draw down; the caller's blit
+   *  scales it back up. Defaults to viewportW/H — a healthy buffer changes nothing. */
+  targetW?: number;
+  targetH?: number;
+  /** Non-default destination for a borrowed-stage additive resolve. */
+  targetFramebuffer?: WebGLFramebuffer | null;
+  /**
+   * Add the resolved light into an already-painted destination rather than
+   * overwriting a freshly cleared particle surface. This is required when an
+   * additive system is an ordered pass in a shared canvas framebuffer.
+   */
+  additiveResolveIntoExisting?: boolean;
+  /** `ParticleSpecConfig.alphaFromRed`: coverage from the source RED channel, pre-LUT. */
+  alphaFromRed?: boolean;
+  /** `ParticleSpecConfig.alphaErode`: constant-erosion smoothstep applied to coverage. */
+  erode?: {
+    threshold: number;
+    softness: number;
+  } | null;
+  /** `ParticleSpecConfig.uvPolar`: sample the sheet through Godot's polar_coordinates remap. */
+  uvPolar?: boolean;
+}
+/** Allocate additive accumulation storage before a caller mutates simulation state. */
+declare function prepareParticleDraw(gl: WebGL2RenderingContext, program: ParticleProgram, opts: DrawParticlesOptions): boolean;
+declare function blendFactorsFor(blendMode: number): [string, string, string, string];
+declare function drawParticles(sharedGl: ParticleGl, program: ParticleProgram, buffer: InstanceBuffer, opts: DrawParticlesOptions): boolean;
+//#endregion
+//#region src/shader-webgl.d.ts
+/** Allocate the shared clip-space quad used by full-surface shader draws. */
+declare function createWebglFullscreenQuad(gl: WebGL2RenderingContext): WebGLBuffer | null;
+declare function createWebglTexture(gl: WebGL2RenderingContext): WebGLTexture | null;
+/** Upload bytes, an image, or a canvas with Godot's top-left UV convention. */
+declare function uploadWebglTexture(gl: WebGL2RenderingContext, texture: WebGLTexture, source: TexImageSource | Uint8Array, width?: number, height?: number, opts?: {
+  repeat?: boolean;
+  nearest?: boolean;
+}): void;
+declare function createWebglPlaceholderTexture(gl: WebGL2RenderingContext, repeat: boolean): WebGLTexture | null;
+interface PendingProgram {
+  ready(): boolean;
+  finish(): WebGLProgram | null;
+}
+/** Kick compilation and linking without synchronously asking the driver for status. */
+declare function startProgram(gl: WebGL2RenderingContext, vertexSrc: string, fragmentSrc: string, beforeLink?: (program: WebGLProgram) => void): PendingProgram;
+/** Compile and link synchronously for callers that cannot yield. */
+declare function compileProgram(gl: WebGL2RenderingContext, vertexSrc: string, fragmentSrc: string, beforeLink?: (program: WebGLProgram) => void): WebGLProgram | null;
+/** Finish when the parallel-compile extension says its status query will not block. */
+declare function compileProgramAsync(gl: WebGL2RenderingContext, vertexSrc: string, fragmentSrc: string, beforeLink?: (program: WebGLProgram) => void): Promise<WebGLProgram | null>;
+/** Fully precomputed GPU frame. HTML adapters calculate DOM geometry/captures first. */
+interface WebglGodotShaderFrame {
+  readonly program: WebGLProgram;
+  readonly locations: ReadonlyMap<string, WebGLUniformLocation | null>;
+  readonly uniforms: readonly ShaderUniform[];
+  readonly quad: WebGLBuffer;
+  readonly width: number;
+  readonly height: number;
+  readonly texture: WebGLTexture | null;
+  readonly time?: number;
+  readonly texturePixelSize?: readonly [number, number];
+  readonly modulate: readonly [number, number, number, number];
+  readonly uvFit: readonly [number, number];
+  readonly uvWindow: readonly [number, number, number, number];
+  readonly screenOrigin?: readonly [number, number];
+  readonly screenSize?: readonly [number, number];
+  readonly screenTexture?: WebGLTexture;
+  readonly screenTextureUnit?: number;
+  readonly screenPixelSize?: readonly [number, number];
+  readonly samplers: readonly {
+    name: string;
+    unit: number;
+    texture: WebGLTexture | null;
+  }[];
+  readonly params: Readonly<Record<string, number | readonly number[]>>;
+  readonly paramKinds: Readonly<Record<string, string>>;
+}
+/** Execute one Godot shader frame in a borrowed context; no DOM, scheduling, or capture work. */
+declare function drawGodotWebglShaderFrame(gl: WebGL2RenderingContext, frame: WebglGodotShaderFrame): void;
+/** Exact Godot scalar/vector/array upload rules. Callers retain their own binding model. */
+declare function uploadGodotShaderUniform(gl: WebGL2RenderingContext, location: WebGLUniformLocation | null, uniform: ShaderUniform, raw: number | readonly number[] | undefined, paramKind?: string): void;
+/** Clear a supplied framebuffer's draw region; callers control its lifetime and binding. */
+declare function clearWebglSurface(gl: WebGL2RenderingContext, width: number, height: number, scissorToViewport?: boolean): void;
+/** Release an owned texture. Borrowed texture handles must not be passed here. */
+declare function deleteWebglTexture(gl: WebGL2RenderingContext, texture: WebGLTexture | null): void;
+//#endregion
+//#region src/webgl.d.ts
+type HeadlessEffectDiagnosticCode = "CONTEXT_LOST" | "DISPOSED" | "INVALID_DIMENSIONS" | "INVALID_RENDER_INPUT" | "RESOURCE_ALLOCATION_FAILED" | "FRAMEBUFFER_INCOMPLETE" | "SHADER_COMPILE_FAILED" | "UNSUPPORTED_SHADER_FEATURE" | "UNSUPPORTED_PARTICLE_FEATURE" | "SCREEN_TEXTURE_REQUIRED" | "FOREIGN_TARGET";
+interface HeadlessEffectDiagnostic {
+  readonly code: HeadlessEffectDiagnosticCode;
+  readonly message: string;
+  /** The exact requested capability where a typed producer declines it. */
+  readonly feature?: string;
+}
+type HeadlessEffectResult<T> = {
+  readonly ok: true;
+  readonly value: T;
+} | {
+  readonly ok: false;
+  readonly diagnostic: HeadlessEffectDiagnostic;
+};
+/** An RGBA8 texture/FBO pair owned by one {@link HeadlessEffectsStage}. */
+interface HeadlessEffectTarget {
+  readonly texture: WebGLTexture | null;
+  readonly framebuffer: WebGLFramebuffer | null;
+  readonly width: number;
+  readonly height: number;
+}
+/** A same-context read-only source. Borrowed cache textures are never deleted by this stage. */
+/** A live texture from this WebGL context. Resource decoding stays with the host. */
+interface WebglTextureInput {
+  readonly texture: WebGLTexture;
+  readonly width: number;
+  readonly height: number;
+}
+type HeadlessTextureInput = HeadlessEffectTarget | WebglTextureInput;
+/**
+ * The framebuffer supplied by a host at a precise painter position. This is a
+ * GPU contract, deliberately free of DrawList and HTML binding objects.
+ */
+interface WebglEffectTargetContext {
+  readonly framebuffer: WebGLFramebuffer | null;
+  readonly width: number;
+  readonly height: number;
+  readonly damage?: unknown;
+  readonly scissor: Readonly<{
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  }>;
+}
+type HeadlessShaderFeature = "screen-texture" | "time" | "delta" | "seed" | "external-textures" | "multiple-render-targets" | "transform-feedback" | "godot-source";
+type HeadlessUniformValue = number | readonly [number, number] | readonly [number, number, number] | readonly [number, number, number, number];
+/**
+ * A complete GLSL ES 3 fragment pass.  It receives `v_uv`; optional uniforms
+ * are `u_time`, `u_delta`, `u_seed`, `u_resolution`, and (when declared in
+ * `features`) `u_screenTexture`.  Application uniforms are numeric scalars or
+ * vec2/3/4 values.  Other textures and Godot shader-language translation are
+ * intentionally refused rather than guessed.
+ */
+interface HeadlessShaderPass {
+  /** Fragment output MUST be premultiplied RGBA, matching the canvas stage contract. */
+  readonly fragmentSource: string;
+  readonly features?: readonly HeadlessShaderFeature[];
+  readonly uniforms?: Readonly<Record<string, HeadlessUniformValue>>;
+}
+interface HeadlessShaderRenderInput {
+  readonly time: number;
+  readonly delta: number;
+  readonly seed?: number;
+  /** Snapshot of the accumulated painter target at this exact caller-selected position. */
+  readonly screenTexture?: HeadlessEffectTarget;
+}
+interface HeadlessShaderProducer {
+  readonly target: HeadlessEffectTarget;
+  /** Compile and cache the GPU pass before the caller’s frame-critical path. */
+  warmUp(): HeadlessEffectResult<void>;
+  resize(width: number, height: number): HeadlessEffectResult<void>;
+  render(input: HeadlessShaderRenderInput): HeadlessEffectResult<HeadlessEffectTarget>;
+  /** Execute by snapshotting an executor's current framebuffer, then replace it. */
+  renderScreen(input: HeadlessShaderRenderInput, context: WebglEffectTargetContext): HeadlessEffectResult<void>;
+  /** Delete ordinary live-context resources; the producer remains reusable. */
+  invalidate(): void;
+  /** Context-loss only: discard names without issuing GL calls. */
+  invalidateContextLoss(): void;
+  dispose(): void;
+}
+/** Numeric values accepted by the existing Godot shader compiler. */
+type HeadlessGodotShaderValue = number | readonly number[];
+/**
+ * DOM-free inputs for the same canvas_item compiler used by the HTML runtime.
+ * Textures deliberately name stage targets, never URLs: loading/decoding is an
+ * HTML concern and an unresolved source is a typed refusal instead of a blank
+ * approximation.
+ */
+interface HeadlessGodotShaderPass {
+  readonly source: string;
+  readonly texture?: HeadlessTextureInput;
+  readonly samplers?: Readonly<Record<string, HeadlessTextureInput>>;
+  readonly uniforms?: Readonly<Record<string, HeadlessGodotShaderValue>>;
+  readonly modulate?: readonly [number, number, number, number];
+  readonly uvFit?: readonly [number, number];
+  readonly uvWindow?: readonly [number, number, number, number];
+}
+interface HeadlessGodotShaderRenderInput extends HeadlessShaderRenderInput {
+  /** Node rect in normalized stage coordinates, for SCREEN_UV. */
+  readonly screenRect?: readonly [number, number, number, number];
+}
+interface HeadlessGodotShaderProducer {
+  readonly target: HeadlessEffectTarget;
+  /** The source render_mode blend, for the caller's surrounding canvas draw. */
+  readonly blend: GodotBlendMode;
+  warmUp(): HeadlessEffectResult<void>;
+  resize(width: number, height: number): HeadlessEffectResult<void>;
+  render(input: HeadlessGodotShaderRenderInput): HeadlessEffectResult<HeadlessEffectTarget>;
+  renderScreen(input: HeadlessGodotShaderRenderInput, context: WebglEffectTargetContext): HeadlessEffectResult<void>;
+  invalidate(): void;
+  invalidateContextLoss(): void;
+  dispose(): void;
+}
+interface HeadlessParticleFeatures {
+  /** Only a point emitter is implemented in this first reusable GPU path. */
+  readonly emissionShape?: "point" | "box" | "circle";
+  readonly collision?: boolean;
+  readonly attractors?: boolean;
+  readonly textureAtlas?: boolean;
+}
+/** Deterministic, stateless procedural point-particle subset. */
+interface HeadlessParticleParameters {
+  readonly maxParticles: number;
+  readonly emissionRate: number;
+  readonly lifetimeSeconds: number;
+  readonly position: readonly [number, number];
+  readonly directionRadians: number;
+  readonly spreadRadians: number;
+  readonly speedMin: number;
+  readonly speedMax: number;
+  readonly gravity: readonly [number, number];
+  /** Straight RGBA 0..1; the GPU pass premultiplies before writing to its target. */
+  readonly startColor: readonly [number, number, number, number];
+  /** Straight RGBA 0..1; the GPU pass premultiplies before writing to its target. */
+  readonly endColor: readonly [number, number, number, number];
+  readonly startSizePx: number;
+  readonly endSizePx: number;
+  readonly features?: HeadlessParticleFeatures;
+}
+interface HeadlessParticleRenderInput {
+  readonly time: number;
+  readonly delta: number;
+  readonly seed: number;
+}
+interface HeadlessParticleProducer {
+  readonly target: HeadlessEffectTarget;
+  /** Compile and cache the GPU pass before the caller’s frame-critical path. */
+  warmUp(): HeadlessEffectResult<void>;
+  resize(width: number, height: number): HeadlessEffectResult<void>;
+  /** Re-evaluates from explicit inputs; it owns neither stateful simulation nor a timer. */
+  render(input: HeadlessParticleRenderInput): HeadlessEffectResult<HeadlessEffectTarget>;
+  invalidate(): void;
+  invalidateContextLoss(): void;
+  dispose(): void;
+}
+/** Caller-owned semantic storage. Supplying this keeps particle state and bytes reusable across producers. */
+interface GodotParticleScratch {
+  /** Render-only fields intentionally live beside the portable simulation state. */
+  readonly config: ParticleRenderConfig;
+  readonly state: ParticleSystemState;
+  readonly instances: InstanceBuffer;
+}
+/** Allocate reusable, DOM-free simulation and instance storage for a normalized Godot particle spec. */
+declare function createGodotParticleScratch(config: ParticleRenderConfig | Partial<ParticleRenderConfig>, maxInstances?: number): GodotParticleScratch;
+/** Explicit live stage textures; no URL decoding, loading, or foreign GL texture ownership is accepted. */
+interface HeadlessGodotParticlePass {
+  /** Omit when scratch is supplied: then scratch owns the normalized config. */
+  readonly config?: ParticleRenderConfig | Partial<ParticleRenderConfig>;
+  readonly spriteTexture?: HeadlessTextureInput;
+  readonly lutTexture?: HeadlessTextureInput;
+  readonly maskTexture?: HeadlessTextureInput;
+  /** Declared material capabilities are refused rather than silently approximated. */
+  readonly features?: Readonly<{
+    collision?: boolean;
+    attractors?: boolean;
+    trails?: boolean;
+    customMaterial?: boolean;
+  }>;
+  readonly scratch?: GodotParticleScratch;
+}
+interface HeadlessGodotParticleRenderInput {
+  /** Renderer-selected local emitter placement; never part of simulation state. */
+  readonly origin?: readonly [number, number];
+  readonly time: number;
+  readonly delta: number;
+  readonly emitting: boolean;
+  /** Reset state at this exact caller-selected frame; no producer clock is consulted. */
+  readonly restart?: boolean;
+}
+/**
+ * Per-draw local-to-framebuffer similarity transform in Godot Transform2D
+ * order `[xx, xy, yx, yy, originX, originY]`. Omit for identity. A direct
+ * particle pass refuses skew and non-uniform scale rather than deforming a
+ * sprite whose renderer only has scalar rotation and independent local size.
+ */
+interface HeadlessGodotParticleDirectRenderInput extends HeadlessGodotParticleRenderInput {
+  readonly transform?: readonly [number, number, number, number, number, number];
+  /**
+   * Straight inherited CanvasItem RGBA. Each component multiplies the matching
+   * particle instance component before the shared renderer premultiplies it.
+   */
+  readonly modulate?: readonly [number, number, number, number];
+}
+interface HeadlessGodotParticleProducer {
+  readonly target: HeadlessEffectTarget;
+  readonly scratch: GodotParticleScratch;
+  warmUp(): HeadlessEffectResult<void>;
+  resize(width: number, height: number): HeadlessEffectResult<void>;
+  render(input: HeadlessGodotParticleRenderInput): HeadlessEffectResult<HeadlessEffectTarget>;
+  invalidate(): void;
+  invalidateContextLoss(): void;
+  dispose(): void;
+}
+/**
+ * A Godot-particle producer that paints into the canvas executor's live target.
+ * It allocates no per-system target texture or compositor FBO.
+ */
+interface HeadlessGodotParticleDirectPass {
+  readonly scratch: GodotParticleScratch;
+  warmUp(): HeadlessEffectResult<void>;
+  draw(input: HeadlessGodotParticleDirectRenderInput, context: WebglEffectTargetContext): HeadlessEffectResult<void>;
+  invalidate(): void;
+  invalidateContextLoss(): void;
+  dispose(): void;
+}
+/** Explicit painter-position copy of an accumulated target. */
+interface HeadlessScreenSampleCommand {
+  readonly source: HeadlessEffectTarget;
+  readonly destination: HeadlessEffectTarget;
+  readonly filter?: "nearest" | "linear";
+}
+interface HeadlessEffectsStage {
+  readonly gl: WebGL2RenderingContext;
+  createShaderProducer(pass: HeadlessShaderPass, width: number, height: number): HeadlessEffectResult<HeadlessShaderProducer>;
+  /** Compile the shared Godot canvas_item semantic engine without DOM ownership. */
+  createGodotShaderProducer(pass: HeadlessGodotShaderPass, width: number, height: number): HeadlessEffectResult<HeadlessGodotShaderProducer>;
+  createParticleProducer(parameters: HeadlessParticleParameters, width: number, height: number): HeadlessEffectResult<HeadlessParticleProducer>;
+  createGodotParticleProducer(pass: HeadlessGodotParticlePass, width: number, height: number): HeadlessEffectResult<HeadlessGodotParticleProducer>;
+  /** Create a direct painter pass; it never creates a system target or copy surface. */
+  createGodotParticleDirectPass(pass: HeadlessGodotParticlePass): HeadlessEffectResult<HeadlessGodotParticleDirectPass>;
+  /**
+   * Execute a copy at the call site’s draw-list position.  A same-target copy is
+   * routed through a stage-owned snapshot, never a read/write feedback loop.
+   */
+  executeScreenSample(command: HeadlessScreenSampleCommand): HeadlessEffectResult<void>;
+  /** Delete ordinary live-context resources; producers remain reusable. */
+  invalidate(): void;
+  /** Drop dead GL handles after context loss without issuing delete calls. */
+  invalidateContextLoss(): void;
+  /** Delete every stage-owned GL handle while the context is live. */
+  dispose(): void;
+}
+/** Safe ceiling for the stateless point-particle subset. Larger systems are refused. */
+declare const MAX_HEADLESS_PARTICLES = 16384;
+/** Create a DOM-free owner for effect FBOs and their ordered GPU passes. */
+declare function createHeadlessEffectsStage(gl: WebGL2RenderingContext): HeadlessEffectsStage;
+//#endregion
+export { GodotParticleScratch, HeadlessEffectDiagnostic, HeadlessEffectDiagnosticCode, HeadlessEffectResult, HeadlessEffectTarget, HeadlessEffectsStage, HeadlessGodotParticleDirectPass, HeadlessGodotParticleDirectRenderInput, HeadlessGodotParticlePass, HeadlessGodotParticleProducer, HeadlessGodotParticleRenderInput, HeadlessGodotShaderPass, HeadlessGodotShaderProducer, HeadlessGodotShaderRenderInput, HeadlessGodotShaderValue, HeadlessParticleFeatures, HeadlessParticleParameters, HeadlessParticleProducer, HeadlessParticleRenderInput, HeadlessScreenSampleCommand, HeadlessShaderFeature, HeadlessShaderPass, HeadlessShaderProducer, HeadlessShaderRenderInput, HeadlessTextureInput, HeadlessUniformValue, MAX_HEADLESS_PARTICLES, type PendingProgram, WebglEffectTargetContext, type WebglGodotShaderFrame, WebglTextureInput, blendFactorsFor, clearWebglSurface, compileProgram, compileProgramAsync, createGodotParticleScratch, createHeadlessEffectsStage, createWebglFullscreenQuad, createWebglPlaceholderTexture, createWebglTexture, deleteWebglTexture, disposeParticleInstanceBuffer, drawGodotWebglShaderFrame, drawParticles, getParticleProgram, invalidateParticleInstanceBuffer, prepareParticleDraw, startProgram, uploadGodotShaderUniform, uploadWebglTexture };
+//# sourceMappingURL=webgl.d.mts.map

package/dist/webgl.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl.d.mts","names":[],"sources":["../src/particle-webgl.ts","../src/shader-webgl.ts","../src/webgl.ts"],"mappings":"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"}