@swf2es/context3d 0.1.19 → 0.1.20

package/src/webgl/textures.ts

@@ -1,4 +1,4 @@
-import type { Texture3D } from "../backend.js";
+import { compressedFormat, TEXEL_BYTES, type Texture3D, type TextureFormat } from "../backend.js";
 import { blockBytes, type DxtEncoder, decodeDxt, encodeDxt } from "../dxt.js";
 import { Context3DError } from "../errors.js";
 import { range } from "./state.js";
@@ -20,20 +20,169 @@ export interface TextureState {
   multisample: MultisampleTarget | null;
   samples: number;
   antiAlias: number;
+  /** The extra colour outputs its framebuffer has attached, a bit each from output 1. */
+  outputs: number;
   /** TEXTURE_BASE_LEVEL: a streaming texture's finest level whole to the smallest. */
   base: number;
 }
 
-/** The staging array, made base-sized at its first use: a texture given only blocks on S3TC has none. */
+/**
+ * GL's internal format for an uncompressed texture's storage. The packed formats are kept
+ * at 8 bits a channel, as AIR draws into them, their texels widened on upload as Direct3D
+ * samples them; 5:6:5 has no alpha to read but 1.
+ */
+export function storageFormat(gl: WebGL2RenderingContext, format: TextureFormat): number {
+  switch (format) {
+    case "bgrPacked565":
+      return gl.RGB8;
+    case "rgbaHalfFloat":
+      return gl.RGBA16F;
+    default:
+      return gl.RGBA8;
+  }
+}
+
+/** 8-bit channel values as half floats, for bitmaps uploaded to rgbaHalfFloat. */
+let halves: Uint16Array | null = null;
+
+function halfOf(byte: number): number {
+  if (!halves) {
+    halves = new Uint16Array(256);
+    const float = new Float32Array(1);
+    const bits = new Uint32Array(float.buffer);
+    for (let i = 1; i < 256; i++) {
+      float[0] = i / 255;
+      const word = bits[0];
+      const exponent = ((word >>> 23) & 255) - 127 + 15;
+      // Every value here is a normal half: round its 23-bit mantissa to 10 bits, to nearest even.
+      const mantissa = word & 0x7fffff;
+      let half = (exponent << 10) | (mantissa >>> 13);
+      const rest = mantissa & 0x1fff;
+      if (rest > 0x1000 || (rest === 0x1000 && half & 1)) {
+        half++;
+      }
+      halves[i] = half;
+    }
+  }
+
+  return halves[byte];
+}
+
+/** A channel cut to its high `bits` and widened back to 8 by repeating them, as Direct3D reads it. */
+function widen(value: number, bits: number): number {
+  const kept = value >> (8 - bits);
+  return (kept << (8 - bits)) | (kept >> (2 * bits - 8));
+}
+
+/**
+ * The staging array, made base-sized at its first use: a texture given only blocks on S3TC
+ * has none. It holds a level as RGBA bytes, or a byte upload's texels as they came, with
+ * room for half floats' eight bytes a texel.
+ */
 function staging(texture: Texture3D, state: TextureState): Uint8Array {
   if (state.bytes.length === 0) {
-    state.bytes = new Uint8Array(texture.width * texture.height * 4);
+    state.bytes = new Uint8Array(
+      texture.width * texture.height * Math.max(4, TEXEL_BYTES[texture.format] ?? 4),
+    );
   }
 
   return state.bytes;
 }
 
-/** The staged level uploaded: as it is, or a compressed texture's encoded to its blocks, as AIR compresses pixels. */
+/**
+ * The staged level turned, in place, into what the texture's storage takes: from RGBA
+ * bytes, or from its format's texels where `raw`, little-endian words. 5:6:5 and 4:4:4:4
+ * keep each channel's high bits, as AIR packs a bitmap; half floats take each byte over 255.
+ */
+function convertStaged(
+  format: TextureFormat,
+  bytes: Uint8Array,
+  count: number,
+  raw: boolean,
+): void {
+  const words = new Uint16Array(bytes.buffer, bytes.byteOffset, bytes.length >> 1);
+  switch (format) {
+    case "bgrPacked565":
+      if (raw) {
+        // Backwards: texel i's three bytes land at 3i, ahead of its word at 2i.
+        for (let i = count - 1; i >= 0; i--) {
+          const word = words[i];
+          const at = i * 3;
+          bytes[at] = ((word >> 11) << 3) | (word >> 13);
+          bytes[at + 1] = (((word >> 5) & 63) << 2) | ((word >> 9) & 3);
+          bytes[at + 2] = ((word & 31) << 3) | ((word >> 2) & 7);
+        }
+      } else {
+        // Forwards: texel i's three bytes land at 3i, behind its own four at 4i.
+        for (let i = 0; i < count; i++) {
+          const at = i * 4;
+          const to = i * 3;
+          const r = widen(bytes[at], 5);
+          const g = widen(bytes[at + 1], 6);
+          const b = widen(bytes[at + 2], 5);
+          bytes[to] = r;
+          bytes[to + 1] = g;
+          bytes[to + 2] = b;
+        }
+      }
+      break;
+    case "bgraPacked4444":
+      if (raw) {
+        // A word is alpha, red, green and blue from its high nibble down.
+        for (let i = count - 1; i >= 0; i--) {
+          const word = words[i];
+          const at = i * 4;
+          bytes[at] = ((word >> 8) & 15) * 17;
+          bytes[at + 1] = ((word >> 4) & 15) * 17;
+          bytes[at + 2] = (word & 15) * 17;
+          bytes[at + 3] = (word >> 12) * 17;
+        }
+      } else {
+        for (let i = 0; i < count * 4; i++) {
+          bytes[i] = (bytes[i] >> 4) * 17;
+        }
+      }
+      break;
+    case "rgbaHalfFloat":
+      if (!raw) {
+        // Backwards: texel i's four words land at 8i, ahead of its own bytes at 4i.
+        for (let i = count - 1; i >= 0; i--) {
+          const at = i * 4;
+          const r = halfOf(bytes[at]);
+          const g = halfOf(bytes[at + 1]);
+          const b = halfOf(bytes[at + 2]);
+          const a = halfOf(bytes[at + 3]);
+          words[i * 4] = r;
+          words[i * 4 + 1] = g;
+          words[i * 4 + 2] = b;
+          words[i * 4 + 3] = a;
+        }
+      }
+      break;
+  }
+}
+
+/** The staged level's texels, as WebGL takes them for the texture's storage. */
+function stagedPixels(
+  gl: WebGL2RenderingContext,
+  format: TextureFormat,
+  bytes: Uint8Array,
+  count: number,
+): [number, number, ArrayBufferView] {
+  switch (format) {
+    case "bgrPacked565":
+      return [gl.RGB, gl.UNSIGNED_BYTE, bytes];
+    case "rgbaHalfFloat":
+      return [gl.RGBA, gl.HALF_FLOAT, new Uint16Array(bytes.buffer, bytes.byteOffset, count * 4)];
+    default:
+      return [gl.RGBA, gl.UNSIGNED_BYTE, bytes];
+  }
+}
+
+/**
+ * The staged level uploaded: as it is, or a compressed texture's encoded to its blocks, as
+ * AIR compresses pixels; `raw` where it is staged in the texture's own format, not as RGBA.
+ */
 function uploadLevel(
   gl: WebGL2RenderingContext,
   texture: Texture3D,
@@ -43,8 +192,9 @@ function uploadLevel(
   w: number,
   h: number,
   encoder: DxtEncoder | null,
+  raw = false,
 ): void {
-  if (texture.format !== "bgra") {
+  if (compressedFormat(texture.format)) {
     const rgba = state.bytes.subarray(0, w * h * 4);
     const dxt5 = texture.format === "compressedAlpha";
     const blocks = encoder?.(rgba, dxt5, w, h) ?? encodeDxt(rgba, dxt5, w, h);
@@ -52,6 +202,18 @@ function uploadLevel(
     return;
   }
 
+  // BGRA's staging is RGBA bytes already: no conversion and no views.
+  const bgra = texture.format === "bgra";
+  if (!bgra) {
+    convertStaged(texture.format, state.bytes, w * h, raw);
+  }
+  const [layout, type, pixels] = bgra
+    ? [gl.RGBA, gl.UNSIGNED_BYTE, state.bytes]
+    : stagedPixels(gl, texture.format, state.bytes, w * h);
+  // 5:6:5's rows of three bytes need not be 4-byte aligned.
+  if (texture.format === "bgrPacked565") {
+    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
+  }
   const cube = texture.cube;
   const target = cube ? gl.TEXTURE_CUBE_MAP : gl.TEXTURE_2D;
   gl.activeTexture(gl.TEXTURE0);
@@ -63,10 +225,13 @@ function uploadLevel(
     0,
     w,
     h,
-    gl.RGBA,
-    gl.UNSIGNED_BYTE,
-    state.bytes,
+    layout,
+    type,
+    pixels,
   );
+  if (texture.format === "bgrPacked565") {
+    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 4);
+  }
   state.uploaded[face] |= 1 << level;
 }
 
@@ -149,10 +314,19 @@ export function uploadTextureBytes(
   range(face, 1, faces);
   const w = Math.max(1, width >> level);
   const h = Math.max(1, height >> level);
-  const length = w * h * 4;
+  const texel = TEXEL_BYTES[texture.format] ?? 4;
+  const length = w * h * texel;
   range(offset, length, data.length);
   staging(texture, state);
 
+  // BGRA, and the compressed formats' pixels, which are BGRA too, go up as RGBA; the
+  // others' texels as they are, little-endian words.
+  if (texel !== 4) {
+    state.bytes.set(data.subarray(offset, offset + length));
+    uploadLevel(gl, texture, state, level, face, w, h, encoder, true);
+    return;
+  }
+
   for (let i = 0; i < length; i += 4) {
     state.bytes[i] = data[offset + i + 2];
     state.bytes[i + 1] = data[offset + i + 1];