@aethervtt/shard-gpu-webgl2 0.0.0-stage → 0.1.0

package/dist/readback.js

@@ -0,0 +1,104 @@
+import { GL } from "./gl.js";
+const READ_BYTES = { format: GL.RGBA, type: GL.UNSIGNED_BYTE, bytes: 4, direct: false };
+const READ_BYTES_DIRECT = { ...READ_BYTES, direct: true };
+const READ_FLOAT = { format: GL.RGBA, type: GL.FLOAT, bytes: 16, direct: false };
+const READ_FLOAT_DIRECT = { ...READ_FLOAT, direct: true };
+const READ_UINT = {
+  format: GL.RGBA_INTEGER,
+  type: GL.UNSIGNED_INT,
+  bytes: 16,
+  direct: false
+};
+const READ_UINT_DIRECT = { ...READ_UINT, direct: true };
+const READ_SINT = { format: GL.RGBA_INTEGER, type: GL.INT, bytes: 16, direct: false };
+function readFormatOf(info) {
+  if (info.kind === "uint") return info.internal === GL.RGBA32UI ? READ_UINT_DIRECT : READ_UINT;
+  if (info.kind === "sint") return READ_SINT;
+  if (info.kind === "depth") return READ_FLOAT;
+  if (info.type === GL.UNSIGNED_BYTE || info.type === GL.UNSIGNED_INT_2_10_10_10_REV) {
+    return info.internal === GL.RGBA8 || info.internal === GL.SRGB8_ALPHA8 ? READ_BYTES_DIRECT : READ_BYTES;
+  }
+  return info.internal === GL.RGBA32F ? READ_FLOAT_DIRECT : READ_FLOAT;
+}
+const scratch = new DataView(new ArrayBuffer(4));
+function floatToHalf(value) {
+  scratch.setFloat32(0, value, true);
+  const x = scratch.getUint32(0, true);
+  const sign = x >>> 16 & 32768;
+  const exp = x >>> 23 & 255;
+  let mant = x & 8388607;
+  if (exp === 255) return sign | 31744 | (mant !== 0 ? 512 : 0);
+  let e = exp - 112;
+  if (e >= 31) return sign | 31744;
+  if (e <= 0) {
+    if (e < -10) return sign;
+    mant = (mant | 8388608) >>> 1 - e;
+    return sign | mant + 4096 >>> 13;
+  }
+  mant += 4096;
+  if (mant & 8388608) {
+    mant = 0;
+    e++;
+    if (e >= 31) return sign | 31744;
+  }
+  return sign | e << 10 | mant >>> 13;
+}
+function toUfloat(value, bits) {
+  if (!(value > 0)) return 0;
+  scratch.setFloat32(0, value, true);
+  const x = scratch.getUint32(0, true);
+  const e = (x >>> 23 & 255) - 112;
+  const mant = x & 8388607;
+  if (e >= 31) return 31 << bits;
+  if (e <= 0) return (mant | 8388608) >>> 1 - e >>> 23 - bits;
+  return e << bits | mant >>> 23 - bits;
+}
+function repack(src, read, info, width, rows, out, outOffset, bytesPerRow) {
+  const input = new DataView(src.buffer, src.byteOffset, src.byteLength);
+  const output = new DataView(out.buffer, out.byteOffset, out.byteLength);
+  const components = info.components;
+  const size = info.bytes / components;
+  for (let y = 0; y < rows; y++) {
+    for (let x = 0; x < width; x++) {
+      const i = (y * width + x) * read.bytes;
+      const o = outOffset + y * bytesPerRow + x * info.bytes;
+      if (info.internal === GL.RGB10_A2) {
+        const r = Math.round(src[i] * 1023 / 255);
+        const g = Math.round(src[i + 1] * 1023 / 255);
+        const b = Math.round(src[i + 2] * 1023 / 255);
+        const a = Math.round(src[i + 3] * 3 / 255);
+        output.setUint32(o, (r | g << 10 | b << 20 | a << 30) >>> 0, true);
+        continue;
+      }
+      if (info.internal === GL.R11F_G11F_B10F) {
+        const r = toUfloat(input.getFloat32(i, true), 6);
+        const g = toUfloat(input.getFloat32(i + 4, true), 6);
+        const b = toUfloat(input.getFloat32(i + 8, true), 5);
+        output.setUint32(o, (r | g << 11 | b << 22) >>> 0, true);
+        continue;
+      }
+      for (let c = 0; c < components; c++) {
+        const p = o + c * size;
+        if (read.type === GL.UNSIGNED_BYTE) {
+          out[p] = src[i + c];
+        } else if (read.type === GL.FLOAT) {
+          const v = input.getFloat32(i + c * 4, true);
+          if (size === 4) output.setFloat32(p, v, true);
+          else if (info.depth)
+            output.setUint16(p, Math.round(Math.min(1, Math.max(0, v)) * 65535), true);
+          else output.setUint16(p, floatToHalf(v), true);
+        } else {
+          const v = input.getUint32(i + c * 4, true);
+          if (size === 4) output.setUint32(p, v, true);
+          else if (size === 2) output.setUint16(p, v & 65535, true);
+          else out[p] = v & 255;
+        }
+      }
+    }
+  }
+}
+export {
+  floatToHalf,
+  readFormatOf,
+  repack
+};

package/dist/replay.d.ts

@@ -0,0 +1,76 @@
+import { type CommandStream } from './commands.js';
+import type { Webgl2Device } from './device.js';
+import { Webgl2Texture } from './resources.js';
+export declare class Replayer {
+    private readonly device;
+    private readonly gl;
+    private readonly vao;
+    private readonly attachments;
+    private readonly single;
+    private stream;
+    private i;
+    private r;
+    private passFbo;
+    private passWidth;
+    private passHeight;
+    private colorCount;
+    private readonly colors;
+    private readonly resolves;
+    private readonly colorLayers;
+    private readonly colorDiscard;
+    private depthView;
+    private depthDiscard;
+    private stencilDiscard;
+    private depthReadOnly;
+    private depthCopied;
+    private readonly scratchDepth;
+    private readonly discards;
+    private readonly clearFloat;
+    private readonly clearUint;
+    private readonly clearInt;
+    private pipeline;
+    private readonly groups;
+    private readonly offsets;
+    private bindingsDirty;
+    private readonly vertexBuffers;
+    private readonly vertexOffsets;
+    private attributesDirty;
+    private attributePipeline;
+    private baseVertex;
+    private firstInstance;
+    private indexBuffer;
+    private indexBytes;
+    private indexOffset;
+    private stencilReference;
+    private readonly attribBuffer;
+    private readonly attribOffset;
+    private readonly attribStride;
+    private readonly attribFormat;
+    private readonly attribDivisor;
+    private readonly attribEnabled;
+    private readonly attribStamp;
+    private stamp;
+    private element;
+    constructor(device: Webgl2Device);
+    /** Forgets cached bindings: after a context loss, or when GL state was changed elsewhere. */
+    reset(): void;
+    /** Drops the depth copies made for `texture`. */
+    forget(texture: Webgl2Texture): void;
+    run(stream: CommandStream): void;
+    private num;
+    private ref;
+    private clearBindings;
+    private beginPass;
+    private readonly pending;
+    private endPass;
+    private draw;
+    private drawIndexed;
+    /** Binds what the draw needs. Undefined when there's nothing valid to draw with. */
+    private prepare;
+    /** Uniform blocks and textures from the bound groups. False if a group the pipeline reads is missing. */
+    private bind;
+    /** A copy of the read-only depth attachment for sampling, refreshed once per pass. */
+    private depthCopy;
+    /** Points each attribute of `p` at its buffer, moved by the base vertex or first instance. */
+    private attributes;
+}