@babylonjs/lite-gl 0.1.0

package/render-target.d.ts

@@ -0,0 +1,290 @@
+/**
+ * Bind the render target's framebuffer as the draw target and set the viewport
+ * to cover it. `rt = null` binds the default (canvas) framebuffer and resets the
+ * viewport to the full canvas — the counterpart of Babylon's
+ * `restoreDefaultFramebuffer`. Subsequent `drawEffect` / `drawIndexed` /
+ * `clearEngine` calls write into the bound target.
+ *
+ * Cached. No-op on a lost/disposed context or a disposed `rt`. Mipmaps are NOT
+ * regenerated here — refresh a target's mip chain explicitly via
+ * {@link generateRenderTargetMipMaps} after rendering into it.
+ *
+ * @param engine - The engine.
+ * @param rt - The render target to draw into, or `null` for the canvas.
+ */
+export declare function bindRenderTarget(engine: GLEngineContext, rt: GLRenderTarget | null): void;
+
+/**
+ * Create an offscreen **float / half-float** render target — the HDR opt-in
+ * counterpart of {@link createRenderTarget}. This is the only render-target
+ * factory that references the `RGBA16F` / `RGBA32F` sized-format table, so RGBA8
+ * consumers ship none of it.
+ *
+ * Defaults to `gl.HALF_FLOAT`; pass `options.type = gl.FLOAT` for full 32-bit.
+ * The requested type is downgraded to the best renderable type the engine
+ * supports (mirroring Babylon's `getTextureType`).
+ *
+ * @param engine - The engine to allocate GL resources on.
+ * @param options - See {@link GLFloatRenderTargetOptions}.
+ * @returns The new {@link GLRenderTarget}.
+ * @throws As {@link createRenderTarget}.
+ */
+export declare function createFloatRenderTarget(engine: GLEngineContext, options: GLFloatRenderTargetOptions): GLRenderTarget;
+
+/**
+ * Create a {@link GLPingPong}: two same-sized {@link GLRenderTarget}s for
+ * self-feedback effects. `read` starts as the first target and `write` the
+ * second; {@link GLPingPong.swap} exchanges them allocation-free.
+ *
+ * @param engine - The engine to create GL resources on.
+ * @param options - Applied identically to both targets.
+ * @returns The new {@link GLPingPong}.
+ * @throws As {@link createRenderTarget}. If the second target fails to build the
+ *  first is disposed before rethrowing (no leak).
+ */
+export declare function createPingPong(engine: GLEngineContext, options: GLRenderTargetOptions): GLPingPong;
+
+/**
+ * Create an offscreen **RGBA8** render target.
+ *
+ * The color attachment is an owned {@link GLTexture} (rebuilt by this target's
+ * own restore hook), unless {@link GLRenderTargetOptions.colorTexture} supplies a
+ * caller-managed (BYO) one. Mirrors Babylon's `createRenderTargetTexture`.
+ *
+ * @param engine - The engine to allocate GL resources on.
+ * @param options - See {@link GLRenderTargetOptions} (`width`/`height` required).
+ * @returns The new {@link GLRenderTarget}.
+ * @throws If `width`/`height` are not positive integers, a GL handle could not
+ *  be allocated, or the resulting framebuffer is not complete. On failure every
+ *  partial GPU object (including an owned color texture) is released first.
+ */
+export declare function createRenderTarget(engine: GLEngineContext, options: GLRenderTargetOptions): GLRenderTarget;
+
+/**
+ * Release both targets of a {@link GLPingPong}. Idempotent, and a no-op for
+ * `null`/`undefined` (matching {@link disposeRenderTarget}).
+ *
+ * @param engine - The engine that owns `pp`.
+ * @param pp - The ping-pong pair to release, or `null`/`undefined` for a no-op.
+ */
+export declare function disposePingPong(engine: GLEngineContext, pp: GLPingPong | null | undefined): void;
+
+/**
+ * Release the render target's framebuffer, depth/stencil renderbuffer and (iff
+ * owned) color texture, and unregister it from the engine. Idempotent, and a
+ * no-op for `null`/`undefined` (so an optional target can be released
+ * unconditionally). Clears the bound-framebuffer cache if it pointed at this
+ * target, and any sampler slot that held the color texture handle.
+ *
+ * A BYO {@link GLRenderTargetOptions.colorTexture} is NOT disposed here — it is
+ * engine-managed and the caller owns its lifetime.
+ *
+ * @param engine - The engine.
+ * @param rt - The render target to dispose, or `null`/`undefined` for a no-op.
+ */
+export declare function disposeRenderTarget(engine: GLEngineContext, rt: GLRenderTarget | null | undefined): void;
+
+/** Regenerate a render target's color-attachment mip chain from its (freshly
+ *  rendered) level-0 — mipmaps for render targets are a pure manual opt-in
+ *  (call this after rendering into the target). No-op for a disposed target, a
+ *  handle-less color attachment, or a lost/disposed context. */
+export declare function generateRenderTargetMipMaps(engine: GLEngineContext, rt: GLRenderTarget): void;
+
+/** Read-only WebGL2 capability limits, queried once at context creation. */
+declare interface GLEngineCaps {
+    /** `gl.MAX_TEXTURE_SIZE` — largest supported texture dimension, in texels. */
+    readonly maxTextureSize: number;
+    /** `gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS` — number of sampler binding slots. */
+    readonly maxTextureUnits: number;
+    /** The `KHR_parallel_shader_compile` extension used for async link polling,
+     *  or null when unsupported — linking is then treated as synchronous. */
+    readonly parallelShaderCompile: {
+        COMPLETION_STATUS_KHR: number;
+    } | null;
+    /** True when 32-bit float color attachments are renderable
+     *  (`EXT_color_buffer_float`). Mirrors Babylon's `caps.textureFloatRender`. */
+    readonly textureFloatRender: boolean;
+    /** True when 32-bit float textures support linear filtering
+     *  (`OES_texture_float_linear`). Mirrors `caps.textureFloatLinearFiltering`. */
+    readonly textureFloatLinearFiltering: boolean;
+    /** True when 16-bit half-float color attachments are renderable
+     *  (`EXT_color_buffer_float` or `EXT_color_buffer_half_float`). Mirrors
+     *  `caps.textureHalfFloatRender`. */
+    readonly textureHalfFloatRender: boolean;
+    /** Half-float linear filtering — always `true` in WebGL2 (it is core).
+     *  Kept as a field to mirror Babylon's `caps.textureHalfFloatLinearFiltering`. */
+    readonly textureHalfFloatLinearFiltering: boolean;
+    /** Whether non-power-of-two textures need POT dimensions for mips / wrap.
+     *  Always `false` in WebGL2 (NPOT is core). Mirrors `engine.needPOTTextures`. */
+    readonly needPOTTextures: boolean;
+}
+
+/**
+ * Pure-state handle for a WebGL2 canvas + its cached GL state.
+ *
+ * INVARIANT: consumers MUST NOT mutate GL state directly through `engine.gl`.
+ * Doing so silently corrupts the cache in `_state`. The package owns every
+ * GL call. (`engine.gl` is exposed only so downstream code that already has the
+ * pattern of poking `engine._gl.getExtension(...)` can do that, but must NOT
+ * call `bindTexture`/`useProgram`/`bindBuffer`/`viewport`/etc.)
+ */
+declare interface GLEngineContext {
+    /** The canvas the WebGL2 context was acquired from. An `OffscreenCanvas` is
+     *  supported for worker render paths (e.g. the Lottie player); it has no CSS
+     *  box, so it must be sized explicitly via `setGLEngineSize` rather than the
+     *  CSS-derived `resizeGLEngine`. */
+    readonly canvas: HTMLCanvasElement | OffscreenCanvas;
+    /** The raw WebGL2 context. Do NOT mutate GL state through it — see the
+     *  type-level invariant above; the package owns every state-changing call. */
+    readonly gl: WebGL2RenderingContext;
+    /** Queried capability limits for this context. */
+    readonly caps: GLEngineCaps;
+
+/** Options for {@link createFloatRenderTarget} — {@link GLRenderTargetOptions}
+ *  plus the float color `type`. */
+export declare interface GLFloatRenderTargetOptions extends GLRenderTargetOptions {
+    /** Float color attachment type. Default `gl.HALF_FLOAT`. Pass `gl.FLOAT` for
+     *  full 32-bit. Downgraded to the best renderable type the engine supports
+     *  (`caps.textureFloatRender` / `caps.textureHalfFloatRender`), mirroring
+     *  Babylon's `getTextureType`. */
+    type?: GLenum;
+}
+
+/**
+ * A pair of {@link GLRenderTarget}s for self-feedback effects: SAMPLE the
+ * {@link GLPingPong.read | read} target (last frame's output) while RENDERING
+ * into the {@link GLPingPong.write | write} target, then {@link GLPingPong.swap}.
+ */
+export declare interface GLPingPong {
+    /** The target to SAMPLE this frame (the previous frame's output). */
+    readonly read: GLRenderTarget;
+    /** The target to RENDER into this frame. */
+    readonly write: GLRenderTarget;
+    /** Exchange `read` and `write`. Call after rendering the `write` target each
+     *  frame. Allocation-free — flips an internal index, no objects created. */
+    swap(): void;
+
+/**
+ * An offscreen render target — a `WebGLFramebuffer` wrapping a color
+ * {@link GLTexture} and an optional depth / stencil renderbuffer. The lite-gl
+ * counterpart of Babylon's `RenderTargetWrapper`.
+ */
+export declare interface GLRenderTarget {
+    /** The color attachment, sampleable like any other {@link GLTexture}
+     *  (`setEffectTexture` / `bindTexture`). For an owned attachment its handle
+     *  is swapped on `webglcontextrestored` while consumers keep this same
+     *  reference. */
+    texture: GLTexture;
+    /** Color attachment width in texels. */
+    width: number;
+    /** Color attachment height in texels. */
+    height: number;
+    /** True once the color attachment + framebuffer are allocated. */
+    isReady: boolean;
+
+/** Options for {@link createRenderTarget}. `width`/`height` are required; every
+ *  other field has a Babylon-matching default. The bare
+ *  `createRenderTarget(engine, { width, height })` makes an RGBA8 color-only
+ *  target with linear filtering and clamp wrapping. */
+export declare interface GLRenderTargetOptions {
+    /** Color attachment width in texels. Must be a positive integer. */
+    width: number;
+    /** Color attachment height in texels. Must be a positive integer. */
+    height: number;
+    /** Allocate a depth renderbuffer (`DEPTH_COMPONENT16`). Default `false`.
+     *  Stencil is NOT a create option — opt in (packed depth+stencil, or
+     *  stencil-only) via `generateRenderTargetStencil`
+     *  (`@babylonjs/lite-gl/depth-stencil`), which keeps the stencil/packed
+     *  renderbuffer code out of the render-target core bundle. */
+    generateDepthBuffer?: boolean;
+    /** Color texture minification filter. Default `gl.LINEAR`. */
+    minFilter?: GLenum;
+    /** Color texture magnification filter. Default `gl.LINEAR`. */
+    magFilter?: GLenum;
+    /** Color texture S wrap. Default `gl.CLAMP_TO_EDGE`. */
+    wrapS?: GLenum;
+    /** Color texture T wrap. Default `gl.CLAMP_TO_EDGE`. */
+    wrapT?: GLenum;
+    /** Attach a caller-supplied (BYO) color {@link GLTexture} instead of creating
+     *  one. When supplied the render target does NOT own or restore it — the
+     *  texture is engine-managed (restored by the standard texture-restore path
+     *  first) and the RT re-attaches its swapped handle afterwards. The caller is
+     *  responsible for sizing it to `width`×`height` and for disposing it. */
+    colorTexture?: GLTexture;
+}
+
+/**
+ * Pure-state texture handle. The `handle` field is MUTABLE so the same logical
+ * texture survives a `webglcontextrestored` event — every consumer keeps the
+ * same `GLTexture` reference; only the internal `WebGLTexture` is swapped.
+ *
+ * `loadTexture2D` also uses the same handle for the 1×1 placeholder upload AND
+ * the final image upload — so a `bindTexture(engine, unit, tex)` made before the
+ * image has decoded remains valid once the image arrives.
+ */
+declare interface GLTexture {
+    /** The live `WebGLTexture`. MUTABLE — swapped for a fresh handle on
+     *  `webglcontextrestored` while consumers keep the same `GLTexture` reference. */
+    handle: WebGLTexture;
+    /** GL texture target (always `gl.TEXTURE_2D` for this package). */
+    readonly target: GLenum;
+    /** Texture width in texels. Updated once an async upload resolves. */
+    width: number;
+    /** Texture height in texels. Updated once an async upload resolves. */
+    height: number;
+    /** True when the texture is safe to sample with final content (placeholders
+     *  read as not-ready until their image/upload completes). */
+    isReady: boolean;
+
+/**
+ * Synchronously read back a rectangle of the render target's color attachment
+ * via `gl.readPixels` — the lite-gl equivalent of Babylon's
+ * `_readTexturePixelsSync`. Binds the target's framebuffer (leaving it bound,
+ * matching Babylon).
+ *
+ * The returned array element type follows the color attachment type:
+ * `Uint8Array` for `UNSIGNED_BYTE`, `Float32Array` for `FLOAT`, `Uint16Array`
+ * for `HALF_FLOAT`. Origin is GL bottom-left.
+ *
+ * @param engine - The engine.
+ * @param rt - The render target to read from.
+ * @param x - Lower-left X of the read rectangle, in texels.
+ * @param y - Lower-left Y of the read rectangle, in texels.
+ * @param width - Read rectangle width in texels.
+ * @param height - Read rectangle height in texels.
+ * @param into - Optional preallocated buffer (`width*height*4` elements of the
+ *  matching type). Reused to avoid per-call allocation.
+ * @returns The pixel buffer (the provided `into`, or a freshly allocated one).
+ *  Empty buffer on a lost/disposed context.
+ */
+export declare function readRenderTargetPixels(engine: GLEngineContext, rt: GLRenderTarget, x: number, y: number, width: number, height: number, into?: ArrayBufferView): ArrayBufferView;
+
+/**
+ * Resize both targets of a {@link GLPingPong}. No-op when disposed.
+ *
+ * @param engine - The engine that owns `pp`.
+ * @param pp - The ping-pong pair to resize.
+ * @param width - New width in texels (positive integer).
+ * @param height - New height in texels (positive integer).
+ */
+export declare function resizePingPong(engine: GLEngineContext, pp: GLPingPong, width: number, height: number): void;
+
+/**
+ * Resize the render target's color attachment (and depth/stencil renderbuffer).
+ * Reallocates storage at the new size; the contents are discarded. The
+ * `GLRenderTarget` / `GLTexture` identity is preserved, so consumers and
+ * effect-sampler bindings holding the reference stay valid. If this target was
+ * the live draw target, it is rebound (with the new-size viewport) afterwards.
+ *
+ * No-op when the size is unchanged or `rt` is disposed. While the context is
+ * lost the new size is recorded but the GL reallocation is deferred to the
+ * restore hook.
+ *
+ * @param engine - The engine.
+ * @param rt - The render target to resize.
+ * @param width - New width in texels (≥ 1).
+ * @param height - New height in texels (≥ 1).
+ */
+export declare function resizeRenderTarget(engine: GLEngineContext, rt: GLRenderTarget, width: number, height: number): void;
+
+export { }

package/render-target.js

@@ -0,0 +1,355 @@
+import { p as pickSizedInternalFormat, i as bindTextureForUpload } from "./texture-DaMd1gGm.js";
+const UNSIGNED_BYTE = 5121;
+const HALF_FLOAT = 5131;
+const FLOAT = 5126;
+const RGBA = 6408;
+const RGBA8 = 32856;
+const LINEAR = 9729;
+const CLAMP_TO_EDGE = 33071;
+function createRenderTarget(engine, options) {
+  return buildRT(engine, options, RGBA8, RGBA, UNSIGNED_BYTE);
+}
+function createFloatRenderTarget(engine, options) {
+  const type = resolveColorType(engine, options.type ?? HALF_FLOAT);
+  const internalFormat = pickSizedInternalFormat(engine.gl, RGBA, type);
+  return buildRT(engine, options, internalFormat, RGBA, type);
+}
+function bindRenderTarget(engine, rt) {
+  if (engine._isLost || engine._disposed) {
+    return;
+  }
+  if (rt !== null && rt._disposed) {
+    return;
+  }
+  const gl = engine.gl;
+  const s = engine._state;
+  const fb = rt === null ? null : rt._framebuffer;
+  if (s.boundFramebuffer !== fb) {
+    gl.bindFramebuffer(gl.FRAMEBUFFER, fb);
+    s.boundFramebuffer = fb;
+  }
+  engine._currentRenderTarget = rt;
+  if (rt === null) {
+    setViewportCached(engine, 0, 0, engine.canvas.width, engine.canvas.height);
+  } else {
+    setViewportCached(engine, 0, 0, rt.width, rt.height);
+  }
+}
+function generateRenderTargetMipMaps(engine, rt) {
+  if (engine._isLost || engine._disposed || rt._disposed || rt.texture.handle === null) {
+    return;
+  }
+  bindTextureForUpload(engine, rt.texture.handle);
+  engine.gl.generateMipmap(engine.gl.TEXTURE_2D);
+}
+function resizeRenderTarget(engine, rt, width, height) {
+  var _a, _b;
+  if (rt._disposed) {
+    return;
+  }
+  validateSize(width, height);
+  if (rt.width === width && rt.height === height) {
+    return;
+  }
+  rt.width = width;
+  rt.height = height;
+  rt.texture.width = width;
+  rt.texture.height = height;
+  if (engine._isLost || engine._disposed) {
+    return;
+  }
+  const wasBound = engine._state.boundFramebuffer === rt._framebuffer && rt._framebuffer !== null;
+  if (!rt._config.ownsColorTexture) {
+    (_b = (_a = rt.texture)._updateRaw) == null ? void 0 : _b.call(_a, engine, null, width, height, 4);
+  }
+  rt._deleteGpu(engine.gl);
+  allocateRenderTargetGpu(engine, rt);
+  if (wasBound) {
+    bindRenderTarget(engine, rt);
+  }
+}
+function readRenderTargetPixels(engine, rt, x, y, width, height, into) {
+  const elements = width * height * 4;
+  if (engine._isLost || engine._disposed || rt._disposed) {
+    return into ?? new Uint8Array(0);
+  }
+  const gl = engine.gl;
+  const s = engine._state;
+  if (s.boundFramebuffer !== rt._framebuffer) {
+    gl.bindFramebuffer(gl.FRAMEBUFFER, rt._framebuffer);
+    s.boundFramebuffer = rt._framebuffer;
+  }
+  const type = rt._config.type;
+  let buffer = into;
+  if (buffer === void 0) {
+    buffer = type === gl.FLOAT ? new Float32Array(elements) : type === gl.HALF_FLOAT ? new Uint16Array(elements) : new Uint8Array(elements);
+  }
+  gl.readPixels(x, y, width, height, gl.RGBA, type, buffer);
+  return buffer;
+}
+function disposeRenderTarget(engine, rt) {
+  if (rt === null || rt === void 0 || rt._disposed) {
+    return;
+  }
+  rt._disposed = true;
+  if (rt._config.ownsColorTexture) {
+    rt.texture._disposed = true;
+  }
+  if (engine._currentRenderTarget === rt) {
+    engine._currentRenderTarget = null;
+  }
+  const i = engine._renderTargets.indexOf(rt);
+  if (i !== -1) {
+    engine._renderTargets.splice(i, 1);
+  }
+  const handle = rt.texture.handle;
+  if (!engine._isLost && !engine._disposed) {
+    rt._deleteGpu(engine.gl);
+  } else {
+    rt._framebuffer = null;
+    rt._depthStencil = null;
+  }
+  if (handle !== null) {
+    const bound = engine._state.boundTextures;
+    for (let u = 0; u < bound.length; u++) {
+      if (bound[u] === handle) {
+        bound[u] = null;
+      }
+    }
+  }
+}
+function createPingPong(engine, options) {
+  const a = createRenderTarget(engine, options);
+  let b;
+  try {
+    b = createRenderTarget(engine, options);
+  } catch (e) {
+    disposeRenderTarget(engine, a);
+    throw e;
+  }
+  const pp = {
+    _a: a,
+    _b: b,
+    _readIsA: true,
+    _disposed: false,
+    get read() {
+      return pp._readIsA ? pp._a : pp._b;
+    },
+    get write() {
+      return pp._readIsA ? pp._b : pp._a;
+    },
+    swap() {
+      pp._readIsA = !pp._readIsA;
+    }
+  };
+  return pp;
+}
+function resizePingPong(engine, pp, width, height) {
+  if (pp._disposed) {
+    return;
+  }
+  resizeRenderTarget(engine, pp._a, width, height);
+  resizeRenderTarget(engine, pp._b, width, height);
+}
+function disposePingPong(engine, pp) {
+  if (pp === null || pp === void 0 || pp._disposed) {
+    return;
+  }
+  pp._disposed = true;
+  disposeRenderTarget(engine, pp._a);
+  disposeRenderTarget(engine, pp._b);
+}
+function buildRT(engine, options, internalFormat, format, type) {
+  const width = options.width;
+  const height = options.height;
+  validateSize(width, height);
+  const gl = engine.gl;
+  const byo = options.colorTexture;
+  const config = {
+    internalFormat,
+    format,
+    type,
+    hasDepth: options.generateDepthBuffer ?? false,
+    minFilter: options.minFilter ?? LINEAR,
+    magFilter: options.magFilter ?? LINEAR,
+    wrapS: options.wrapS ?? CLAMP_TO_EDGE,
+    wrapT: options.wrapT ?? CLAMP_TO_EDGE,
+    ownsColorTexture: byo === void 0
+  };
+  const texture = byo ?? {
+    handle: null,
+    target: gl.TEXTURE_2D,
+    width,
+    height,
+    isReady: false,
+    _disposed: false,
+    _refCount: 1,
+    // Owned-by-RT: its storage is (re)allocated by allocateRenderTargetGpu,
+    // never via the engine `_textures` replay (it is NOT registered there).
+    _upload: () => {
+    },
+    _wasReady: false
+  };
+  const rt = {
+    texture,
+    width,
+    height,
+    isReady: false,
+    _framebuffer: null,
+    _depthStencil: null,
+    _rebuildDepthStencil: void 0,
+    _config: config,
+    _disposed: false,
+    _deleteGpu: () => {
+    },
+    _restore: () => {
+    }
+  };
+  rt._deleteGpu = (glc) => {
+    const s = engine._state;
+    if (rt._framebuffer !== null) {
+      if (s.boundFramebuffer === rt._framebuffer) {
+        s.boundFramebuffer = null;
+      }
+      glc.deleteFramebuffer(rt._framebuffer);
+      rt._framebuffer = null;
+    }
+    if (rt._depthStencil !== null) {
+      glc.deleteRenderbuffer(rt._depthStencil);
+      rt._depthStencil = null;
+    }
+    if (config.ownsColorTexture && rt.texture.handle !== null) {
+      glc.deleteTexture(rt.texture.handle);
+      rt.texture.handle = null;
+    }
+    rt.texture.isReady = false;
+    rt.isReady = false;
+  };
+  rt._restore = (target) => {
+    try {
+      allocateRenderTargetGpu(target, rt);
+    } catch (err) {
+      console.error("lite-gl: render target restore failed", err);
+    }
+  };
+  allocateRenderTargetGpu(engine, rt);
+  engine._renderTargets.push(rt);
+  return rt;
+}
+function resolveColorType(engine, type) {
+  const gl = engine.gl;
+  if (type === FLOAT && !engine.caps.textureFloatRender) {
+    return engine.caps.textureHalfFloatRender ? gl.HALF_FLOAT : gl.UNSIGNED_BYTE;
+  }
+  if (type === HALF_FLOAT && !engine.caps.textureHalfFloatRender) {
+    return gl.UNSIGNED_BYTE;
+  }
+  return type;
+}
+function validateSize(width, height) {
+  if (!Number.isInteger(width) || !Number.isInteger(height) || width < 1 || height < 1) {
+    throw new Error(`lite-gl: render target size must be positive integers, got ${width}x${height}`);
+  }
+}
+function allocateRenderTargetGpu(engine, rt) {
+  var _a;
+  if (engine._isLost || engine._disposed) {
+    return;
+  }
+  const gl = engine.gl;
+  const s = engine._state;
+  const c = rt._config;
+  const prevFb = s.boundFramebuffer;
+  let createdTexture = null;
+  let fb = null;
+  let rb = null;
+  try {
+    if (c.ownsColorTexture) {
+      const texHandle = gl.createTexture();
+      if (texHandle === null) {
+        throw new Error("lite-gl: gl.createTexture returned null (render target color)");
+      }
+      createdTexture = texHandle;
+      rt.texture.handle = texHandle;
+      bindTextureForUpload(engine, texHandle);
+      gl.texImage2D(gl.TEXTURE_2D, 0, c.internalFormat, rt.width, rt.height, 0, c.format, c.type, null);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, c.minFilter);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, c.magFilter);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, c.wrapS);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, c.wrapT);
+      rt.texture.isReady = true;
+      rt.texture._wasReady = true;
+    }
+    fb = gl.createFramebuffer();
+    if (fb === null) {
+      throw new Error("lite-gl: gl.createFramebuffer returned null");
+    }
+    rt._framebuffer = fb;
+    gl.bindFramebuffer(gl.FRAMEBUFFER, fb);
+    s.boundFramebuffer = fb;
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, rt.texture.handle, 0);
+    rt._depthStencil = null;
+    if (c.hasDepth) {
+      rb = gl.createRenderbuffer();
+      if (rb === null) {
+        throw new Error("lite-gl: gl.createRenderbuffer returned null");
+      }
+      gl.bindRenderbuffer(gl.RENDERBUFFER, rb);
+      gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, rt.width, rt.height);
+      gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, rb);
+      gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+      rt._depthStencil = rb;
+    }
+    (_a = rt._rebuildDepthStencil) == null ? void 0 : _a.call(rt, engine);
+    const status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
+    if (status !== gl.FRAMEBUFFER_COMPLETE) {
+      throw new Error(`lite-gl: render target framebuffer incomplete (status 0x${status.toString(16)})`);
+    }
+    rt.isReady = true;
+  } catch (e) {
+    if (rt._depthStencil !== null) {
+      gl.deleteRenderbuffer(rt._depthStencil);
+    }
+    rt._depthStencil = null;
+    if (fb !== null) {
+      gl.deleteFramebuffer(fb);
+    }
+    rt._framebuffer = null;
+    if (createdTexture !== null) {
+      gl.deleteTexture(createdTexture);
+      rt.texture.handle = null;
+      rt.texture.isReady = false;
+    }
+    rt.isReady = false;
+    throw e;
+  } finally {
+    if (s.boundFramebuffer !== prevFb) {
+      gl.bindFramebuffer(gl.FRAMEBUFFER, prevFb);
+      s.boundFramebuffer = prevFb;
+    }
+  }
+}
+function setViewportCached(engine, x, y, w, h) {
+  const s = engine._state;
+  if (s.viewportX === x && s.viewportY === y && s.viewportW === w && s.viewportH === h) {
+    return;
+  }
+  s.viewportX = x;
+  s.viewportY = y;
+  s.viewportW = w;
+  s.viewportH = h;
+  engine.gl.viewport(x, y, w, h);
+}
+export {
+  bindRenderTarget,
+  createFloatRenderTarget,
+  createPingPong,
+  createRenderTarget,
+  disposePingPong,
+  disposeRenderTarget,
+  generateRenderTargetMipMaps,
+  readRenderTargetPixels,
+  resizePingPong,
+  resizeRenderTarget
+};
+//# sourceMappingURL=render-target.js.map