lecodes-gl-lite 2.0.0

package/src/webgl/ibl.ts

@@ -0,0 +1,137 @@
+// KTX1 environment loader for the lite engine. Reads the SAME asset the Filament build ships
+// (assets/neutral_ibl128.ktx, produced by cmgen): a prefiltered R11F_G11F_B10F cubemap whose mip
+// chain encodes roughness levels, plus 9 spherical-harmonics irradiance coefficients in the "sh"
+// key-value metadata. So the lite engine's ambient term is fed by the exact data Filament uses.
+
+import { Texture, type OGLRenderingContext } from 'ogl'
+
+const KTX_MAGIC = 0xab4b5458 // ¬KTX (big-endian read of the first 4 bytes)
+
+export type IblData = {
+  /** 9 × [r,g,b] irradiance SH coefficients (pre-convolved by cmgen — direct basis eval). */
+  sh: Float32Array // 27 floats
+  cubemap: Texture
+  maxLod: number
+}
+
+type Ktx1 = {
+  glType: number
+  glFormat: number
+  glInternalFormat: number
+  width: number
+  height: number
+  faces: number
+  mipLevels: number
+  keyValues: Map<string, string>
+  /** mips[level][face] — raw pixel payloads */
+  mips: Uint8Array[][]
+}
+
+const parseKtx1 = (buf: ArrayBuffer): Ktx1 => {
+  const dv = new DataView(buf)
+  if (dv.getUint32(0, false) !== KTX_MAGIC) throw new Error('Not a KTX1 file')
+  const little = dv.getUint32(12, true) === 0x04030201
+  const u32 = (off: number): number => dv.getUint32(off, little)
+
+  const glType = u32(16)
+  const glFormat = u32(24)
+  const glInternalFormat = u32(28)
+  const width = u32(36)
+  const height = u32(40)
+  const faces = u32(52)
+  const mipLevels = Math.max(1, u32(56))
+  const bytesOfKeyValueData = u32(60)
+
+  const keyValues = new Map<string, string>()
+  const decoder = new TextDecoder('utf-8')
+  let p = 64
+  const kvEnd = 64 + bytesOfKeyValueData
+  while (p < kvEnd) {
+    const byteSize = u32(p)
+    p += 4
+    const bytes = new Uint8Array(buf, p, byteSize)
+    const nul = bytes.indexOf(0)
+    const key = decoder.decode(bytes.subarray(0, nul))
+    const value = decoder.decode(bytes.subarray(nul + 1)).replace(/\0+$/, '')
+    keyValues.set(key, value)
+    p += byteSize + ((3 - ((byteSize + 3) % 4)))
+  }
+
+  const mips: Uint8Array[][] = []
+  p = kvEnd
+  for (let level = 0; level < mipLevels; level++) {
+    const imageSize = u32(p) // per-face size for cubemaps (non-array)
+    p += 4
+    const faceList: Uint8Array[] = []
+    for (let f = 0; f < faces; f++) {
+      faceList.push(new Uint8Array(buf, p, imageSize))
+      p += imageSize + ((3 - ((imageSize + 3) % 4)))
+    }
+    mips.push(faceList)
+  }
+
+  return { glType, glFormat, glInternalFormat, width, height, faces, mipLevels, keyValues, mips }
+}
+
+/** Parse cmgen's "sh" metadata: 9 lines of "r g b". */
+const parseSh = (text: string | undefined): Float32Array => {
+  const sh = new Float32Array(27)
+  if (!text) return sh
+  const nums = text.trim().split(/[\s\n]+/).map(Number)
+  for (let i = 0; i < Math.min(27, nums.length); i++) sh[i] = nums[i]
+  return sh
+}
+
+const GL_R11F_G11F_B10F = 0x8c3a
+const GL_UNSIGNED_INT_10F_11F_11F_REV = 0x8c3b
+const GL_RGB = 0x1907
+
+export const loadIbl = (gl: OGLRenderingContext & WebGL2RenderingContext, buf: ArrayBuffer): IblData => {
+  const ktx = parseKtx1(buf)
+  const sh = parseSh(ktx.keyValues.get('sh'))
+
+  // Upload the cubemap manually (OGL's Texture doesn't handle per-mip cubemap payloads).
+  const texture = new Texture(gl, {
+    target: gl.TEXTURE_CUBE_MAP,
+    generateMipmaps: false,
+    minFilter: gl.LINEAR_MIPMAP_LINEAR,
+    magFilter: gl.LINEAR,
+    flipY: false,
+    width: ktx.width,
+    height: ktx.height,
+  })
+
+  const packed = ktx.glInternalFormat === GL_R11F_G11F_B10F
+  gl.bindTexture(gl.TEXTURE_CUBE_MAP, texture.texture)
+  gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false)
+  gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1)
+  for (let level = 0; level < ktx.mipLevels; level++) {
+    const size = Math.max(1, ktx.width >> level)
+    for (let face = 0; face < ktx.faces; face++) {
+      const data = ktx.mips[level][face]
+      if (packed) {
+        gl.texImage2D(
+          gl.TEXTURE_CUBE_MAP_POSITIVE_X + face, level, GL_R11F_G11F_B10F, size, size, 0,
+          GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV,
+          new Uint32Array(data.buffer, data.byteOffset, data.byteLength / 4),
+        )
+      } else {
+        // Fallback: assume RGB(A)8
+        const channels = ktx.glFormat === GL_RGB ? 3 : 4
+        gl.texImage2D(
+          gl.TEXTURE_CUBE_MAP_POSITIVE_X + face, level, channels === 3 ? gl.RGB8 : gl.RGBA8, size, size, 0,
+          channels === 3 ? gl.RGB : gl.RGBA, gl.UNSIGNED_BYTE, data,
+        )
+      }
+    }
+  }
+  gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAX_LEVEL, ktx.mipLevels - 1)
+  gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR)
+  gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
+
+  // Tell OGL's texture state tracking the image is already uploaded.
+  ;(texture as any).store.image = (texture as any).image = ktx
+  ;(texture as any).needsUpdate = false
+
+  return { sh, cubemap: texture, maxLod: ktx.mipLevels - 1 }
+}