@frapx/core 0.3.0 → 0.5.0

package/dist/index.js

@@ -19,13 +19,150 @@ var UnsupportedError = class extends ShaderError {
 var TargetNotFoundError = class extends ShaderError {
 };
 var ShaderCompileError = class extends ShaderError {
+  constructor(message, details = {}) {
+    super(message);
+    this.stage = details.stage ?? null;
+    this.lines = details.lines ?? [];
+  }
 };
 var TextureLoadError = class extends ShaderError {
 };
 var DestroyedError = class extends ShaderError {
 };
 
+// src/internal/shaderLog.ts
+var ANGLE_STYLE = /^\s*ERROR:\s*\d+:(\d+):\s*(.*)$/;
+var NVIDIA_STYLE = /^\s*\d+\((\d+)\)\s*:\s*error\s*\w*\s*:\s*(.*)$/i;
+var NOISE = /compilation terminated|^\s*''\s*:\s*$/i;
+var CONTEXT_LINES = 2;
+var parseShaderLog = (log, source) => {
+  const sourceLines = source.split(/\r?\n/);
+  const lineAt = (line) => sourceLines[line - 1] ?? "";
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of log.split(/\r?\n/)) {
+    const match = ANGLE_STYLE.exec(entry) ?? NVIDIA_STYLE.exec(entry);
+    if (!match) continue;
+    const line = Number(match[1]);
+    const message = match[2].trim();
+    if (!message || NOISE.test(message)) continue;
+    const key = `${line}:${message}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const context = [];
+    const first = Math.max(1, line - CONTEXT_LINES);
+    const last = Math.min(sourceLines.length, line + CONTEXT_LINES);
+    for (let current = first; current <= last; current++) {
+      context.push({ line: current, source: lineAt(current) });
+    }
+    results.push({ line, message, source: lineAt(line), context });
+  }
+  return results;
+};
+
+// src/internal/webgl.ts
+var defaultVertexShader = `
+attribute vec2 a_position;
+varying vec2 v_uv;
+
+void main() {
+  v_uv = a_position * 0.5 + 0.5;
+  gl_Position = vec4(a_position, 0.0, 1.0);
+}
+`;
+var defaultVertexShader300 = `#version 300 es
+in vec2 a_position;
+out vec2 v_uv;
+
+void main() {
+  v_uv = a_position * 0.5 + 0.5;
+  gl_Position = vec4(a_position, 0.0, 1.0);
+}
+`;
+var isGLSL300 = (src) => /^\s*#version\s+300\s+es\b/.test(src);
+var isWebGL2Context = (gl) => typeof gl.createVertexArray === "function";
+var createProgram = (gl, vertexSource, fragmentSource) => {
+  const vertex = compileShader(gl, gl.VERTEX_SHADER, vertexSource);
+  let fragment;
+  try {
+    fragment = compileShader(gl, gl.FRAGMENT_SHADER, fragmentSource);
+  } catch (error) {
+    gl.deleteShader(vertex);
+    throw error;
+  }
+  const program = gl.createProgram();
+  if (!program) {
+    throw new ShaderCompileError("Failed to create WebGL program.");
+  }
+  gl.attachShader(program, vertex);
+  gl.attachShader(program, fragment);
+  gl.linkProgram(program);
+  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+    const log = gl.getProgramInfoLog(program) ?? "Unknown program link error.";
+    gl.deleteProgram(program);
+    gl.deleteShader(vertex);
+    gl.deleteShader(fragment);
+    throw new ShaderCompileError(log, { stage: "link" });
+  }
+  gl.deleteShader(vertex);
+  gl.deleteShader(fragment);
+  return program;
+};
+var createFullscreenBuffer = (gl, program) => {
+  const buffer = gl.createBuffer();
+  if (!buffer) {
+    throw new ShaderCompileError("Failed to create fullscreen buffer.");
+  }
+  const location = gl.getAttribLocation(program, "a_position");
+  gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+  gl.bufferData(
+    gl.ARRAY_BUFFER,
+    new Float32Array([-1, -1, 1, -1, -1, 1, -1, 1, 1, -1, 1, 1]),
+    gl.STATIC_DRAW
+  );
+  if (location >= 0) {
+    gl.enableVertexAttribArray(location);
+    gl.vertexAttribPointer(location, 2, gl.FLOAT, false, 0, 0);
+  }
+  return buffer;
+};
+var compileShader = (gl, type, source) => {
+  const shader = gl.createShader(type);
+  if (!shader) {
+    throw new ShaderCompileError("Failed to create WebGL shader.");
+  }
+  gl.shaderSource(shader, source);
+  gl.compileShader(shader);
+  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+    const log = gl.getShaderInfoLog(shader) ?? "Unknown shader compile error.";
+    gl.deleteShader(shader);
+    throw new ShaderCompileError(log, {
+      stage: type === gl.VERTEX_SHADER ? "vertex" : "fragment",
+      lines: parseShaderLog(log, source)
+    });
+  }
+  return shader;
+};
+
 // src/internal/capture.ts
+var waitForGpu = (gl) => {
+  if (!isWebGL2Context(gl)) return Promise.resolve();
+  const sync = gl.fenceSync(gl.SYNC_GPU_COMMANDS_COMPLETE, 0);
+  if (!sync) return Promise.resolve();
+  gl.flush();
+  return new Promise((resolve) => {
+    const poll = () => {
+      const status = gl.clientWaitSync(sync, 0, 0);
+      if (status === gl.TIMEOUT_EXPIRED) {
+        setTimeout(poll, 4);
+        return;
+      }
+      gl.deleteSync(sync);
+      resolve();
+    };
+    poll();
+  });
+};
 var readPixels = (gl, framebuffer, width, height, format) => {
   const length = width * height * 4;
   const data = format === "rgba16f" ? new Float32Array(length) : new Uint8Array(length);
@@ -166,6 +303,8 @@ var RuntimeHost = class {
     this.rafId = 0;
     this.running = false;
     this.inRender = false;
+    this.captureDrawing = false;
+    this.resizePending = false;
     this.destroyed = false;
     this.gates = /* @__PURE__ */ new Set();
     this.reducedMotionActive = false;
@@ -181,6 +320,7 @@ var RuntimeHost = class {
     this.removeListeners = [];
     this.currentStatus = "idle";
     this.contextRestoredShouldRun = false;
+    this.statusBeforeLoss = "idle";
     this.manualDelta = 0;
     this.lastManualTime = null;
     this.objectFitRestore = null;
@@ -285,30 +425,35 @@ var RuntimeHost = class {
     if (this.inRender) {
       throw new Error("captureFrame() cannot be called while a frame is drawing.");
     }
-    if (format === "rgba16f" && this.options.captureSource?.()?.format !== "rgba16f") {
+    const sourceFormat = this.options.captureSource?.()?.format;
+    if (format === "rgba16f" && sourceFormat !== "rgba16f" && sourceFormat !== "rgba32f") {
       throw new UnsupportedError(
         "rgba16f capture needs a float render target, such as feedback with format rgba16f."
       );
     }
-    this.renderInternal(this.elapsed, this.isManual ? this.manualDelta : 0);
-    const gl = this.context;
-    if (format === "png") {
-      return canvasToPng(this.dom.canvas);
+    options.signal?.throwIfAborted();
+    const delta = this.isManual ? this.manualDelta : 0;
+    const drawContext = this.context;
+    if (!this.options.onCaptureDraw) {
+      this.renderInternal(this.elapsed, delta);
+      return this.readCapture(format, drawContext);
     }
-    if (format === "rgba8") {
-      return readPixels(gl, null, this.width, this.height, "rgba8");
+    try {
+      await this.renderForCapture(this.options.onCaptureDraw, delta, options.signal);
+      return this.readCapture(format, drawContext);
+    } finally {
+      if (this.resizePending) {
+        this.resizePending = false;
+        this.resize();
+      }
     }
-    const source = this.options.captureSource();
-    return readPixels(
-      gl,
-      source.framebuffer,
-      source.width,
-      source.height,
-      "rgba16f"
-    );
   }
   resize() {
     if (this.destroyed || !this.dom) return;
+    if (this.captureDrawing) {
+      this.resizePending = true;
+      return;
+    }
     const prevWidth = this.width;
     const prevHeight = this.height;
     const prevViewportWidth = this.viewportWidth;
@@ -401,7 +546,7 @@ var RuntimeHost = class {
     this.renderInternal(this.elapsed, 0);
   }
   renderInternal(time, delta) {
-    if (!this.dom || !this.context) return;
+    if (!this.dom || !this.context || this.inRender) return;
     const gl = this.context;
     this.inRender = true;
     try {
@@ -412,6 +557,47 @@ var RuntimeHost = class {
       this.inRender = false;
     }
   }
+  // Holds the render lock across an asynchronous capture draw so no other
+  // frame interleaves with it.
+  async renderForCapture(draw, delta, signal) {
+    if (!this.dom || !this.context) return;
+    this.inRender = true;
+    this.captureDrawing = true;
+    try {
+      this.measureSize();
+      await draw(this.createFrameState(this.elapsed, delta, this.context), signal);
+      this.frame++;
+    } finally {
+      this.inRender = false;
+      this.captureDrawing = false;
+    }
+  }
+  // Reads the frame just drawn, in the task that drew it: the drawing buffer
+  // is not preserved. Fails if the context drawn into is gone, including when
+  // it was lost and restored while an asynchronous draw was pending.
+  readCapture(format, drawContext) {
+    if (this.destroyed) {
+      throw new DestroyedError("Runtime host was destroyed.");
+    }
+    const gl = this.context;
+    if (!gl || gl !== drawContext || !this.dom) {
+      throw new UnsupportedError("The WebGL context was lost while capturing.");
+    }
+    if (format === "png") {
+      return canvasToPng(this.dom.canvas);
+    }
+    if (format === "rgba8") {
+      return readPixels(gl, null, this.width, this.height, "rgba8");
+    }
+    const source = this.options.captureSource();
+    return readPixels(
+      gl,
+      source.framebuffer,
+      source.width,
+      source.height,
+      "rgba16f"
+    );
+  }
   createFrameState(time, delta, gl = this.context) {
     return {
       gl,
@@ -647,6 +833,7 @@ var RuntimeHost = class {
     const onLost = (event) => {
       event.preventDefault();
       this.contextRestoredShouldRun = this.running;
+      this.statusBeforeLoss = this.currentStatus;
       this.cancelFrame();
       this.context = null;
       this.currentStatus = "context-lost";
@@ -661,6 +848,7 @@ var RuntimeHost = class {
       const afterRestore = async () => {
         try {
           await this.options.onContextRestored?.(gl, this.width, this.height);
+          if (this.currentStatus === "context-lost") this.currentStatus = this.statusBeforeLoss;
           if (this.contextRestoredShouldRun) this.start();
           else if (!this.isManual) this.render();
         } catch (error) {
@@ -720,6 +908,211 @@ var assertWithinLimits = (gl, resolution) => {
 var toUniformName = (name) => name.startsWith("u_") ? name : `u_${name}`;
 var fromUniformName = (name) => name.startsWith("u_") ? name.slice(2) : name;
 
+// src/internal/uniforms.ts
+var normalizeUniform = (input) => {
+  if (typeof input === "number") {
+    return { type: "float", value: [input] };
+  }
+  if (input instanceof Float32Array) {
+    if (input.length === 9) return { type: "mat3", value: input };
+    if (input.length === 16) return { type: "mat4", value: input };
+    if (input.length === 2) return { type: "vec2", value: input };
+    if (input.length === 3) return { type: "vec3", value: input };
+    if (input.length === 4) return { type: "vec4", value: input };
+  }
+  if (isExplicitUniform(input)) {
+    return { type: input.type, value: input.value };
+  }
+  if (Array.isArray(input)) {
+    if (input.length === 2) return { type: "vec2", value: input };
+    if (input.length === 3) return { type: "vec3", value: input };
+    if (input.length === 4) return { type: "vec4", value: input };
+  }
+  return { type: "float", value: [0] };
+};
+var applyUniform = (gl, location, uniform) => {
+  const value = uniform.value;
+  switch (uniform.type) {
+    case "float":
+      gl.uniform1f(location, value[0] ?? 0);
+      break;
+    case "vec2":
+      gl.uniform2f(location, value[0] ?? 0, value[1] ?? 0);
+      break;
+    case "vec3":
+      gl.uniform3f(location, value[0] ?? 0, value[1] ?? 0, value[2] ?? 0);
+      break;
+    case "vec4":
+      gl.uniform4f(
+        location,
+        value[0] ?? 0,
+        value[1] ?? 0,
+        value[2] ?? 0,
+        value[3] ?? 0
+      );
+      break;
+    case "mat3":
+      gl.uniformMatrix3fv(location, false, value);
+      break;
+    case "mat4":
+      gl.uniformMatrix4fv(location, false, value);
+      break;
+  }
+};
+var applyProgramUniform = (gl, program, location, uniform) => {
+  gl.useProgram(program);
+  applyUniform(gl, location, uniform);
+};
+var applyUniforms = (gl, locations, cache, onMissing) => {
+  for (const [name, uniform] of cache) {
+    const location = locations.get(name);
+    if (!location) {
+      onMissing?.(name);
+      continue;
+    }
+    applyUniform(gl, location, uniform);
+  }
+};
+var collectUniformLocations = (gl, program) => {
+  const locations = /* @__PURE__ */ new Map();
+  const count = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS);
+  for (let index = 0; index < count; index += 1) {
+    const active = gl.getActiveUniform(program, index);
+    if (!active) continue;
+    const name = active.name.replace(/\[0\]$/, "");
+    const location = gl.getUniformLocation(program, name);
+    if (location) {
+      locations.set(name, location);
+    }
+  }
+  return locations;
+};
+var createUniformCache = (uniforms) => {
+  const cache = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(uniforms ?? {})) {
+    cache.set(toUniformName(name), normalizeUniform(value));
+  }
+  return cache;
+};
+var isExplicitUniform = (input) => {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return false;
+  return "type" in input && "value" in input;
+};
+
+// src/internal/bindings.ts
+var createUniformBindings = () => {
+  const sources = [];
+  const evaluate = (time) => {
+    const merged = /* @__PURE__ */ new Map();
+    for (const source of sources) {
+      for (const [name, value] of Object.entries(source.get(time))) {
+        merged.set(toUniformName(name), normalizeUniform(value));
+      }
+    }
+    return merged;
+  };
+  return {
+    add(source) {
+      sources.push(source);
+      let removed = false;
+      return () => {
+        if (removed) return;
+        removed = true;
+        const index = sources.indexOf(source);
+        if (index >= 0) sources.splice(index, 1);
+      };
+    },
+    get size() {
+      return sources.length;
+    },
+    evaluate,
+    signature(time) {
+      if (sources.length === 0) return "";
+      let text = "";
+      for (const [name, uniform] of evaluate(time)) {
+        text += `${name}:${uniform.type}:${Array.from(uniform.value).join(",")};`;
+      }
+      return text;
+    }
+  };
+};
+var EASES = {
+  linear: (t) => t,
+  smooth: (t) => t * t * (3 - 2 * t),
+  step: () => 0
+};
+var toEaseFunction = (ease) => {
+  if (typeof ease === "function") return ease;
+  const fn = EASES[ease];
+  if (!fn) throw new RangeError(`Unknown ease: ${String(ease)}`);
+  return fn;
+};
+var componentsOf = (value) => typeof value === "number" ? [value] : value;
+var isKeyList = (track) => Array.isArray(track);
+var compileTrack = (name, track, fallback) => {
+  const list = isKeyList(track);
+  const keys = list ? track : track.keys;
+  const ease = toEaseFunction((list ? void 0 : track.ease) ?? fallback);
+  if (keys.length === 0) throw new TypeError(`Keyframe track ${name} has no keys.`);
+  const sorted = [...keys].sort((a, b) => a[0] - b[0]);
+  const scalar = typeof sorted[0][1] === "number";
+  const size = componentsOf(sorted[0][1]).length;
+  for (const [time, value] of sorted) {
+    if (!Number.isFinite(time)) throw new TypeError(`Keyframe track ${name} has a non-finite time.`);
+    const components = componentsOf(value);
+    if (typeof value === "number" !== scalar || components.length !== size) {
+      throw new TypeError(`Keyframe track ${name} mixes values of different sizes.`);
+    }
+    if (!components.every(Number.isFinite)) {
+      throw new TypeError(`Keyframe track ${name} has a non-finite value.`);
+    }
+  }
+  return {
+    times: sorted.map(([time]) => time),
+    values: sorted.map(([, value]) => componentsOf(value)),
+    scalar,
+    ease
+  };
+};
+var sampleTrack = (track, time) => {
+  const { times, values } = track;
+  const last = times.length - 1;
+  let components;
+  if (time <= times[0]) {
+    components = values[0];
+  } else if (time >= times[last]) {
+    components = values[last];
+  } else {
+    let low = 0;
+    let high = last;
+    while (high - low > 1) {
+      const middle = low + high >> 1;
+      if (times[middle] <= time) low = middle;
+      else high = middle;
+    }
+    const span = times[high] - times[low];
+    const t = span > 0 ? track.ease((time - times[low]) / span) : 0;
+    const from = values[low];
+    const to = values[high];
+    components = from.map((value, index) => value + (to[index] - value) * t);
+  }
+  return track.scalar ? components[0] : Array.from(components);
+};
+var keyframes = (tracks, options = {}) => {
+  const fallback = options.ease ?? "linear";
+  toEaseFunction(fallback);
+  const compiled = Object.entries(tracks).map(
+    ([name, track]) => [name, compileTrack(name, track, fallback)]
+  );
+  return {
+    get(time) {
+      const values = {};
+      for (const [name, track] of compiled) values[name] = sampleTrack(track, time);
+      return values;
+    }
+  };
+};
+
 // src/internal/textures.ts
 var loadTexture = async (gl, name, input, unit) => {
   const options = normalizeTextureInput(input);
@@ -777,79 +1170,118 @@ var isTextureSource = (input) => typeof HTMLImageElement !== "undefined" && (inp
 var getSourceWidth = (source) => "naturalWidth" in source ? source.naturalWidth : source.width;
 var getSourceHeight = (source) => "naturalHeight" in source ? source.naturalHeight : source.height;
 
-// src/internal/webgl.ts
-var defaultVertexShader = `
-attribute vec2 a_position;
-varying vec2 v_uv;
-
-void main() {
-  v_uv = a_position * 0.5 + 0.5;
-  gl_Position = vec4(a_position, 0.0, 1.0);
-}
-`;
-var defaultVertexShader300 = `#version 300 es
-in vec2 a_position;
-out vec2 v_uv;
-
-void main() {
-  v_uv = a_position * 0.5 + 0.5;
-  gl_Position = vec4(a_position, 0.0, 1.0);
-}
-`;
-var isGLSL300 = (src) => /^\s*#version\s+300\s+es\b/.test(src);
-var isWebGL2Context = (gl) => typeof gl.createVertexArray === "function";
-var createProgram = (gl, vertexSource, fragmentSource) => {
-  const vertex = compileShader(gl, gl.VERTEX_SHADER, vertexSource);
-  const fragment = compileShader(gl, gl.FRAGMENT_SHADER, fragmentSource);
-  const program = gl.createProgram();
-  if (!program) {
-    throw new ShaderCompileError("Failed to create WebGL program.");
-  }
-  gl.attachShader(program, vertex);
-  gl.attachShader(program, fragment);
-  gl.linkProgram(program);
-  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-    const log = gl.getProgramInfoLog(program) ?? "Unknown program link error.";
-    gl.deleteProgram(program);
-    gl.deleteShader(vertex);
-    gl.deleteShader(fragment);
-    throw new ShaderCompileError(log);
-  }
-  gl.deleteShader(vertex);
-  gl.deleteShader(fragment);
-  return program;
-};
-var createFullscreenBuffer = (gl, program) => {
-  const buffer = gl.createBuffer();
-  if (!buffer) {
-    throw new ShaderCompileError("Failed to create fullscreen buffer.");
-  }
-  const location = gl.getAttribLocation(program, "a_position");
-  gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-  gl.bufferData(
-    gl.ARRAY_BUFFER,
-    new Float32Array([-1, -1, 1, -1, -1, 1, -1, 1, 1, -1, 1, 1]),
-    gl.STATIC_DRAW
-  );
-  if (location >= 0) {
-    gl.enableVertexAttribArray(location);
-    gl.vertexAttribPointer(location, 2, gl.FLOAT, false, 0, 0);
-  }
-  return buffer;
+// src/internal/textureSet.ts
+var createTextureSet = (inputs = {}) => {
+  const textureInputs = new Map(Object.entries(inputs));
+  let textures = /* @__PURE__ */ new Map();
+  const units = /* @__PURE__ */ new Map();
+  const versions = /* @__PURE__ */ new Map();
+  const reserveUnit = (gl, name) => {
+    const existing = units.get(name);
+    if (existing !== void 0) return existing;
+    const maxUnits = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS);
+    const used = new Set(units.values());
+    for (let unit = 0; unit < maxUnits; unit += 1) {
+      if (!used.has(unit)) {
+        units.set(name, unit);
+        return unit;
+      }
+    }
+    throw new TextureLoadError(
+      `Texture unit limit exceeded while loading texture: ${name}`
+    );
+  };
+  return {
+    get textures() {
+      return textures;
+    },
+    hasInput(name) {
+      return textureInputs.has(name);
+    },
+    reserveUnit,
+    async loadAll(gl, isCancelled) {
+      const loaded = /* @__PURE__ */ new Map();
+      for (const [name, input] of textureInputs) {
+        if (isCancelled()) break;
+        const unit = reserveUnit(gl, name);
+        loaded.set(name, await loadTexture(gl, name, input, unit));
+      }
+      for (const texture of textures.values()) {
+        gl.deleteTexture(texture.texture);
+      }
+      textures = loaded;
+    },
+    async set(gl, name, input, isCancelled) {
+      const version = (versions.get(name) ?? 0) + 1;
+      versions.set(name, version);
+      try {
+        const unit = reserveUnit(gl, name);
+        const loaded = await loadTexture(gl, name, input, unit);
+        if (isCancelled() || versions.get(name) !== version) {
+          gl.deleteTexture(loaded.texture);
+          return null;
+        }
+        const previous = textures.get(name);
+        textureInputs.set(name, input);
+        textures.set(name, loaded);
+        if (previous) gl.deleteTexture(previous.texture);
+        return loaded;
+      } catch (error) {
+        if (!textures.has(name) && !textureInputs.has(name)) {
+          units.delete(name);
+        }
+        throw error;
+      }
+    },
+    bind(gl, locations, onMissing) {
+      for (const texture of textures.values()) {
+        const unit = units.get(texture.name);
+        if (unit === void 0) continue;
+        const location = locations.get(texture.uniformName);
+        if (!location) {
+          onMissing?.(texture.uniformName);
+          continue;
+        }
+        gl.activeTexture(gl.TEXTURE0 + unit);
+        gl.bindTexture(gl.TEXTURE_2D, texture.texture);
+        gl.uniform1i(location, unit);
+      }
+    },
+    dispose(gl) {
+      for (const texture of textures.values()) {
+        gl.deleteTexture(texture.texture);
+      }
+    }
+  };
 };
-var compileShader = (gl, type, source) => {
-  const shader = gl.createShader(type);
-  if (!shader) {
-    throw new ShaderCompileError("Failed to create WebGL shader.");
-  }
-  gl.shaderSource(shader, source);
-  gl.compileShader(shader);
-  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-    const log = gl.getShaderInfoLog(shader) ?? "Unknown shader compile error.";
-    gl.deleteShader(shader);
-    throw new ShaderCompileError(log);
-  }
-  return shader;
+
+// src/internal/fullscreenProgram.ts
+var createFullscreenProgram = (gl, fragment, vertex) => {
+  const defaultVertex = isGLSL300(fragment) ? defaultVertexShader300 : defaultVertexShader;
+  const program = createProgram(gl, vertex ?? defaultVertex, fragment);
+  gl.useProgram(program);
+  const buffer = createFullscreenBuffer(gl, program);
+  const attribLocation = gl.getAttribLocation(program, "a_position");
+  const locations = collectUniformLocations(gl, program);
+  return {
+    program,
+    locations,
+    use() {
+      gl.useProgram(program);
+      gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+      if (attribLocation >= 0) {
+        gl.enableVertexAttribArray(attribLocation);
+        gl.vertexAttribPointer(attribLocation, 2, gl.FLOAT, false, 0, 0);
+      }
+    },
+    draw() {
+      gl.drawArrays(gl.TRIANGLES, 0, 6);
+    },
+    dispose() {
+      gl.deleteBuffer(buffer);
+      gl.deleteProgram(program);
+    }
+  };
 };
 
 // src/internal/blit.ts
@@ -1007,16 +1439,17 @@ var Target = class {
       throw new ShaderCompileError("Failed to create render target framebuffer.");
     }
     gl.bindTexture(gl.TEXTURE_2D, texture);
-    if (this.format === "rgba16f" && isWebGL2Context(gl)) {
+    if (this.format !== "rgba8" && isWebGL2Context(gl)) {
+      const half = this.format === "rgba16f";
       gl.texImage2D(
         gl.TEXTURE_2D,
         0,
-        gl.RGBA16F,
+        half ? gl.RGBA16F : gl.RGBA32F,
         this.width,
         this.height,
         0,
         gl.RGBA,
-        gl.HALF_FLOAT,
+        half ? gl.HALF_FLOAT : gl.FLOAT,
         null
       );
     } else {
@@ -1033,7 +1466,8 @@ var Target = class {
       );
     }
     const wrap = getWrap2(gl, this.options.wrap ?? "clamp");
-    const filter = this.options.filter === "nearest" ? gl.NEAREST : gl.LINEAR;
+    const linear = this.options.filter !== "nearest" && (this.format !== "rgba32f" || gl.getExtension("OES_texture_float_linear") !== null);
+    const filter = linear ? gl.LINEAR : gl.NEAREST;
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, wrap);
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, wrap);
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, filter);
@@ -1076,12 +1510,20 @@ export {
   TargetNotFoundError,
   TextureLoadError,
   UnsupportedError,
+  applyProgramUniform,
+  applyUniform,
+  applyUniforms,
+  collectUniformLocations,
   createBlitter,
   createFullscreenBuffer,
+  createFullscreenProgram,
   createPingPong,
   createProgram,
   createRenderTarget,
   createRuntimeHost,
+  createTextureSet,
+  createUniformBindings,
+  createUniformCache,
   defaultVertexShader,
   defaultVertexShader300,
   fromUniformName,
@@ -1091,13 +1533,17 @@ export {
   hexToRgba,
   isGLSL300,
   isWebGL2Context,
+  keyframes,
   loadTexture,
+  normalizeUniform,
+  parseShaderLog,
   resizeCanvasToTarget,
   resolveDpr,
   resolveElement,
   resolveRenderTargetFormat,
   setupCanvas,
   supportsRenderTargetFormat,
-  toUniformName
+  toUniformName,
+  waitForGpu
 };
 //# sourceMappingURL=index.js.map