react-native-webrtc-kaleidoscope 2.0.0 → 2.1.0

package/android/src/main/java/com/simiancraft/kaleidoscope/gpu/GlProgram.kt

@@ -6,74 +6,93 @@ package com.simiancraft.kaleidoscope.gpu
 import android.opengl.GLES30
 import android.util.Log
 
-internal class GlProgram(vertexSource: String, fragmentSource: String) {
-  val id: Int
+internal class GlProgram(
+    vertexSource: String,
+    fragmentSource: String,
+) {
+    val id: Int
 
-  init {
-    val vs = compileShader(GLES30.GL_VERTEX_SHADER, vertexSource)
-    val fs = compileShader(GLES30.GL_FRAGMENT_SHADER, fragmentSource)
-    id = GLES30.glCreateProgram()
-    GLES30.glAttachShader(id, vs)
-    GLES30.glAttachShader(id, fs)
-    GLES30.glLinkProgram(id)
-    GLES30.glDetachShader(id, vs)
-    GLES30.glDetachShader(id, fs)
-    GLES30.glDeleteShader(vs)
-    GLES30.glDeleteShader(fs)
+    init {
+        val vs = compileShader(GLES30.GL_VERTEX_SHADER, vertexSource)
+        val fs = compileShader(GLES30.GL_FRAGMENT_SHADER, fragmentSource)
+        id = GLES30.glCreateProgram()
+        GLES30.glAttachShader(id, vs)
+        GLES30.glAttachShader(id, fs)
+        GLES30.glLinkProgram(id)
+        GLES30.glDetachShader(id, vs)
+        GLES30.glDetachShader(id, fs)
+        GLES30.glDeleteShader(vs)
+        GLES30.glDeleteShader(fs)
 
-    val status = IntArray(1)
-    GLES30.glGetProgramiv(id, GLES30.GL_LINK_STATUS, status, 0)
-    if (status[0] != GLES30.GL_TRUE) {
-      val log = GLES30.glGetProgramInfoLog(id)
-      GLES30.glDeleteProgram(id)
-      error("Kaleidoscope: shader link failed: $log")
+        val status = IntArray(1)
+        GLES30.glGetProgramiv(id, GLES30.GL_LINK_STATUS, status, 0)
+        if (status[0] != GLES30.GL_TRUE) {
+            val log = GLES30.glGetProgramInfoLog(id)
+            GLES30.glDeleteProgram(id)
+            error("Kaleidoscope: shader link failed: $log")
+        }
     }
-  }
 
-  fun use() {
-    GLES30.glUseProgram(id)
-  }
+    fun use() {
+        GLES30.glUseProgram(id)
+    }
 
-  fun uniformLocation(name: String): Int = GLES30.glGetUniformLocation(id, name)
+    fun uniformLocation(name: String): Int = GLES30.glGetUniformLocation(id, name)
 
-  fun setInt(name: String, value: Int) {
-    GLES30.glUniform1i(uniformLocation(name), value)
-  }
+    fun setInt(
+        name: String,
+        value: Int,
+    ) {
+        GLES30.glUniform1i(uniformLocation(name), value)
+    }
 
-  fun setFloat(name: String, value: Float) {
-    GLES30.glUniform1f(uniformLocation(name), value)
-  }
+    fun setFloat(
+        name: String,
+        value: Float,
+    ) {
+        GLES30.glUniform1f(uniformLocation(name), value)
+    }
 
-  fun setVec2(name: String, x: Float, y: Float) {
-    GLES30.glUniform2f(uniformLocation(name), x, y)
-  }
+    fun setVec2(
+        name: String,
+        x: Float,
+        y: Float,
+    ) {
+        GLES30.glUniform2f(uniformLocation(name), x, y)
+    }
 
-  /** Upload a column-major 2x2 (4 floats) to a mat2 uniform. */
-  fun setMat2(name: String, columnMajor: FloatArray) {
-    GLES30.glUniformMatrix2fv(uniformLocation(name), 1, false, columnMajor, 0)
-  }
+    /** Upload a column-major 2x2 (4 floats) to a mat2 uniform. */
+    fun setMat2(
+        name: String,
+        columnMajor: FloatArray,
+    ) {
+        GLES30.glUniformMatrix2fv(uniformLocation(name), 1, false, columnMajor, 0)
+    }
 
-  fun delete() {
-    GLES30.glDeleteProgram(id)
-  }
+    fun delete() {
+        GLES30.glDeleteProgram(id)
+    }
 
-  companion object {
-    private const val TAG = "Kaleidoscope.GlProgram"
+    companion object {
+        private const val TAG = "Kaleidoscope.GlProgram"
 
-    private fun compileShader(type: Int, source: String): Int {
-      val handle = GLES30.glCreateShader(type)
-      GLES30.glShaderSource(handle, source)
-      GLES30.glCompileShader(handle)
-      val status = IntArray(1)
-      GLES30.glGetShaderiv(handle, GLES30.GL_COMPILE_STATUS, status, 0)
-      if (status[0] != GLES30.GL_TRUE) {
-        val log = GLES30.glGetShaderInfoLog(handle)
-        GLES30.glDeleteShader(handle)
-        // Surface the source so adb logcat shows which shader failed.
-        Log.e(TAG, "shader source:\n$source")
-        error("Kaleidoscope: shader compile failed: $log")
-      }
-      return handle
+        private fun compileShader(
+            type: Int,
+            source: String,
+        ): Int {
+            val handle = GLES30.glCreateShader(type)
+            GLES30.glShaderSource(handle, source)
+            GLES30.glCompileShader(handle)
+            val status = IntArray(1)
+            GLES30.glGetShaderiv(handle, GLES30.GL_COMPILE_STATUS, status, 0)
+            if (status[0] != GLES30.GL_TRUE) {
+                val log = GLES30.glGetShaderInfoLog(handle)
+                GLES30.glDeleteShader(handle)
+                // Surface the source so adb logcat shows which shader failed.
+                Log.e(TAG, "shader source:\n$source")
+                error("Kaleidoscope: shader compile failed: $log")
+            }
+            return handle
+        }
     }
-  }
 }

package/android/src/main/java/com/simiancraft/kaleidoscope/gpu/Ingest.kt

@@ -11,7 +11,7 @@
 // composited pre-rotated). That per-effect cascade is what this module removes.
 //
 // `composedTexMatrix` folds the display rotation INTO the texture matrix, so the
-// single OES->2D pass that BlurFactory, BackgroundImageFactory, and
+// single OES->2D pass that the composite factory and
 // TransformFactory each run now lands a DISPLAY-UPRIGHT frame in the FBO. The
 // FBO is sized with `displayWidth` / `displayHeight` (buffer dims swapped on a
 // 90/270 frame), so the upright image fills it without clamping.
@@ -41,83 +41,104 @@
 package com.simiancraft.kaleidoscope.gpu
 
 internal object Ingest {
-  // The ONE orientation calibration knob. +1f applies the display rotation as
-  // -frame.rotation about center (the geometric inverse, which is what maps a
-  // display-upright destination UV back into the camera's pre-rotation UV
-  // space); -1f applies +frame.rotation. Flip this sign if a portrait-device
-  // screenshot shows the whole frame rotated the wrong way. This is the only
-  // place orientation direction is decided.
-  private const val ROTATION_DIRECTION = 1f
+    // The ONE orientation calibration knob. +1f applies the display rotation as
+    // -frame.rotation about center (the geometric inverse, which is what maps a
+    // display-upright destination UV back into the camera's pre-rotation UV
+    // space); -1f applies +frame.rotation. Flip this sign if a portrait-device
+    // screenshot shows the whole frame rotated the wrong way. This is the only
+    // place orientation direction is decided.
+    private const val ROTATION_DIRECTION = 1f
 
-  /** Display width for a buffer of [bufferWidth] x [bufferHeight] at [frameRotation]. */
-  fun displayWidth(bufferWidth: Int, bufferHeight: Int, frameRotation: Int): Int =
-    if (swaps(frameRotation)) bufferHeight else bufferWidth
+    /** Display width for a buffer of [bufferWidth] x [bufferHeight] at [frameRotation]. */
+    fun displayWidth(
+        bufferWidth: Int,
+        bufferHeight: Int,
+        frameRotation: Int,
+    ): Int = if (swaps(frameRotation)) bufferHeight else bufferWidth
 
-  /** Display height for a buffer of [bufferWidth] x [bufferHeight] at [frameRotation]. */
-  fun displayHeight(bufferWidth: Int, bufferHeight: Int, frameRotation: Int): Int =
-    if (swaps(frameRotation)) bufferWidth else bufferHeight
+    /** Display height for a buffer of [bufferWidth] x [bufferHeight] at [frameRotation]. */
+    fun displayHeight(
+        bufferWidth: Int,
+        bufferHeight: Int,
+        frameRotation: Int,
+    ): Int = if (swaps(frameRotation)) bufferWidth else bufferHeight
 
-  /** Does this frame rotation swap buffer dims into display dims? */
-  private fun swaps(frameRotation: Int): Boolean {
-    val r = normalize(frameRotation)
-    return r == 90 || r == 270
-  }
+    /** Does this frame rotation swap buffer dims into display dims? */
+    private fun swaps(frameRotation: Int): Boolean {
+        val r = normalize(frameRotation)
+        return r == 90 || r == 270
+    }
 
-  /**
-   * Column-major 4x4 for the OES->2D pass's `uTexMatrix`, composing the camera
-   * [transformMatrix] with the display rotation derived from [frameRotation].
-   * Feed the result straight to glUniformMatrix4fv (already flat, length 16).
-   *
-   * M' = transformMatrix4 * Rot(theta about 0.5), where
-   * theta = ROTATION_DIRECTION * frameRotation degrees.
-   */
-  fun composedTexMatrix(
-    transformMatrix: android.graphics.Matrix,
-    frameRotation: Int,
-  ): FloatArray {
-    val base = Egl.matrixToGl(transformMatrix)
-    val rot = rotationAboutCenter(ROTATION_DIRECTION * normalize(frameRotation).toFloat())
-    return multiplyColumnMajor4(base, rot)
-  }
+    /**
+     * Column-major 4x4 for the OES->2D pass's `uTexMatrix`, composing the camera
+     * [transformMatrix] with the display rotation derived from [frameRotation].
+     * Feed the result straight to glUniformMatrix4fv (already flat, length 16).
+     *
+     * M' = transformMatrix4 * Rot(theta about 0.5), where
+     * theta = ROTATION_DIRECTION * frameRotation degrees.
+     */
+    fun composedTexMatrix(
+        transformMatrix: android.graphics.Matrix,
+        frameRotation: Int,
+    ): FloatArray {
+        val base = Egl.matrixToGl(transformMatrix)
+        val rot = rotationAboutCenter(ROTATION_DIRECTION * normalize(frameRotation).toFloat())
+        return multiplyColumnMajor4(base, rot)
+    }
 
-  /**
-   * Column-major 4x4 that rotates the xy UV plane by [degrees] about (0.5, 0.5),
-   * leaving z and w untouched. Translate-to-center, rotate, translate-back.
-   */
-  private fun rotationAboutCenter(degrees: Float): FloatArray {
-    val rad = Math.toRadians(degrees.toDouble())
-    val c = Math.cos(rad).toFloat()
-    val s = Math.sin(rad).toFloat()
-    // 2D rotation about 0.5 in (x, y):
-    //   x' = c*(x-0.5) - s*(y-0.5) + 0.5
-    //   y' = s*(x-0.5) + c*(y-0.5) + 0.5
-    // As an affine 4x4 (column-major): linear block in the upper-left 2x2,
-    // translation in the last column.
-    val tx = 0.5f - 0.5f * c + 0.5f * s
-    val ty = 0.5f - 0.5f * s - 0.5f * c
-    return floatArrayOf(
-      c, s, 0f, 0f,
-      -s, c, 0f, 0f,
-      0f, 0f, 1f, 0f,
-      tx, ty, 0f, 1f,
-    )
-  }
+    /**
+     * Column-major 4x4 that rotates the xy UV plane by [degrees] about (0.5, 0.5),
+     * leaving z and w untouched. Translate-to-center, rotate, translate-back.
+     */
+    private fun rotationAboutCenter(degrees: Float): FloatArray {
+        val rad = Math.toRadians(degrees.toDouble())
+        val c = Math.cos(rad).toFloat()
+        val s = Math.sin(rad).toFloat()
+        // 2D rotation about 0.5 in (x, y):
+        //   x' = c*(x-0.5) - s*(y-0.5) + 0.5
+        //   y' = s*(x-0.5) + c*(y-0.5) + 0.5
+        // As an affine 4x4 (column-major): linear block in the upper-left 2x2,
+        // translation in the last column.
+        val tx = 0.5f - 0.5f * c + 0.5f * s
+        val ty = 0.5f - 0.5f * s - 0.5f * c
+        return floatArrayOf(
+            c,
+            s,
+            0f,
+            0f,
+            -s,
+            c,
+            0f,
+            0f,
+            0f,
+            0f,
+            1f,
+            0f,
+            tx,
+            ty,
+            0f,
+            1f,
+        )
+    }
 
-  /** a * b, both column-major 4x4 flat arrays (length 16). Returns a*b. */
-  private fun multiplyColumnMajor4(a: FloatArray, b: FloatArray): FloatArray {
-    val out = FloatArray(16)
-    for (col in 0 until 4) {
-      for (row in 0 until 4) {
-        var sum = 0f
-        for (k in 0 until 4) {
-          // column-major index: element(row, k) = a[k*4 + row]
-          sum += a[k * 4 + row] * b[col * 4 + k]
+    /** a * b, both column-major 4x4 flat arrays (length 16). Returns a*b. */
+    private fun multiplyColumnMajor4(
+        a: FloatArray,
+        b: FloatArray,
+    ): FloatArray {
+        val out = FloatArray(16)
+        for (col in 0 until 4) {
+            for (row in 0 until 4) {
+                var sum = 0f
+                for (k in 0 until 4) {
+                    // column-major index: element(row, k) = a[k*4 + row]
+                    sum += a[k * 4 + row] * b[col * 4 + k]
+                }
+                out[col * 4 + row] = sum
+            }
         }
-        out[col * 4 + row] = sum
-      }
+        return out
     }
-    return out
-  }
 
-  private fun normalize(deg: Int): Int = ((deg % 360) + 360) % 360
+    private fun normalize(deg: Int): Int = ((deg % 360) + 360) % 360
 }

package/android/src/main/java/com/simiancraft/kaleidoscope/gpu/Orientation.kt

@@ -15,7 +15,7 @@
 //   rotate-cw / rotate-ccw                            -> swap axes (+ a sign)
 //
 // There is no per-effect rotation/flip compensation anywhere; if a screenshot
-// shows the WHOLE frame rotated wrong, that is an ingest problem — flip
+// shows the WHOLE frame rotated wrong, that is an ingest problem; flip
 // Ingest.ROTATION_DIRECTION, do not add a correction here.
 //
 // mat2 column-major convention: floatArrayOf(a, b, c, d) builds the GLSL mat2
@@ -29,30 +29,30 @@ package com.simiancraft.kaleidoscope.gpu
 // and takes an Op in its constructor; an internal Op would leak through a public
 // signature.
 object Orientation {
-  /** Screen-space reorientation operations the transform effect exposes. */
-  enum class Op { FLIP_X, FLIP_Y, ROTATE_CW, ROTATE_CCW }
+    /** Screen-space reorientation operations the transform effect exposes. */
+    enum class Op { FLIP_X, FLIP_Y, ROTATE_CW, ROTATE_CCW }
 
-  /** Does the op swap output dimensions (w x h -> h x w)? True for rotations. */
-  fun swapsDimensions(op: Op): Boolean = op == Op.ROTATE_CW || op == Op.ROTATE_CCW
+    /** Does the op swap output dimensions (w x h -> h x w)? True for rotations. */
+    fun swapsDimensions(op: Op): Boolean = op == Op.ROTATE_CW || op == Op.ROTATE_CCW
 
-  /**
-   * Column-major 2x2 for glUniformMatrix2fv. The input frame is already
-   * display-upright (see Ingest), so this is rotation-independent.
-   *
-   * flip-x: negate U -> column 0 = (-1, 0), column 1 = (0, 1).
-   * flip-y: negate V -> column 0 = ( 1, 0), column 1 = (0, -1).
-   * rotate-cw / rotate-ccw: screen 90-degree rotations. Device-confirmed on the
-   *   clean sampled space (both flips correct on both platforms, so the matrix->
-   *   screen map is axis-aligned and orientation-preserving): columns (0,-1),(1,0)
-   *   rendered COUNTER-clockwise, so clockwise is the inverse, columns (0,1),(-1,0).
-   */
-  fun mat2For(op: Op): FloatArray =
-    when (op) {
-      Op.FLIP_X -> floatArrayOf(-1f, 0f, 0f, 1f)
-      Op.FLIP_Y -> floatArrayOf(1f, 0f, 0f, -1f)
-      // Device-confirmed: columns (0,-1),(1,0) rendered CCW on the clean space,
-      // so clockwise is its inverse, columns (0,1),(-1,0).
-      Op.ROTATE_CW -> floatArrayOf(0f, 1f, -1f, 0f)
-      Op.ROTATE_CCW -> floatArrayOf(0f, -1f, 1f, 0f)
-    }
+    /**
+     * Column-major 2x2 for glUniformMatrix2fv. The input frame is already
+     * display-upright (see Ingest), so this is rotation-independent.
+     *
+     * flip-x: negate U -> column 0 = (-1, 0), column 1 = (0, 1).
+     * flip-y: negate V -> column 0 = ( 1, 0), column 1 = (0, -1).
+     * rotate-cw / rotate-ccw: screen 90-degree rotations. Device-confirmed on the
+     *   clean sampled space (both flips correct on both platforms, so the matrix->
+     *   screen map is axis-aligned and orientation-preserving): columns (0,-1),(1,0)
+     *   rendered COUNTER-clockwise, so clockwise is the inverse, columns (0,1),(-1,0).
+     */
+    fun mat2For(op: Op): FloatArray =
+        when (op) {
+            Op.FLIP_X -> floatArrayOf(-1f, 0f, 0f, 1f)
+            Op.FLIP_Y -> floatArrayOf(1f, 0f, 0f, -1f)
+            // Device-confirmed: columns (0,-1),(1,0) rendered CCW on the clean space,
+            // so clockwise is its inverse, columns (0,1),(-1,0).
+            Op.ROTATE_CW -> floatArrayOf(0f, 1f, -1f, 0f)
+            Op.ROTATE_CCW -> floatArrayOf(0f, -1f, 1f, 0f)
+        }
 }

package/android/src/main/java/com/simiancraft/kaleidoscope/gpu/Shaders.kt

@@ -3,32 +3,32 @@
 // assets/shaders/*.frag if the count grows past ~6 or if external tooling
 // (SPIRV-Cross, ShaderToy round-tripping) starts to matter.
 //
-// Shapes mirror the web GLSL in src/web/effects/*.ts. Keep in sync manually.
+// Shapes mirror the web GLSL in web-driver/effects/*.ts. Keep in sync manually.
 
 package com.simiancraft.kaleidoscope.gpu
 
 internal object Shaders {
-  // Procedural full-screen quad via gl_VertexID; no VAO or VBO required.
-  // Caller does: glDrawArrays(GL_TRIANGLE_STRIP, 0, 4).
-  // gl_VertexID -> (p in 0..2 space) -> (clip in -1..1, uv in 0..1)
-  //   0 -> (0,0) -> (-1,-1), uv (0,0)
-  //   1 -> (2,0) -> ( 1,-1), uv (1,0)
-  //   2 -> (0,2) -> (-1, 1), uv (0,1)
-  //   3 -> (2,2) -> ( 1, 1), uv (1,1)
-  // Canonical source: shaders/passthrough.vert. Generated into
-  // ShadersGenerated by `bun run build:shaders`; delegated here so call sites
-  // keep using Shaders.PASSTHROUGH_VERT.
-  val PASSTHROUGH_VERT = ShadersGenerated.PASSTHROUGH_VERT
+    // Procedural full-screen quad via gl_VertexID; no VAO or VBO required.
+    // Caller does: glDrawArrays(GL_TRIANGLE_STRIP, 0, 4).
+    // gl_VertexID -> (p in 0..2 space) -> (clip in -1..1, uv in 0..1)
+    //   0 -> (0,0) -> (-1,-1), uv (0,0)
+    //   1 -> (2,0) -> ( 1,-1), uv (1,0)
+    //   2 -> (0,2) -> (-1, 1), uv (0,1)
+    //   3 -> (2,2) -> ( 1, 1), uv (1,1)
+    // Canonical source: shaders/passthrough.vert. Generated into
+    // ShadersGenerated by `bun run build:shaders`; delegated here so call sites
+    // keep using Shaders.PASSTHROUGH_VERT.
+    val PASSTHROUGH_VERT = ShadersGenerated.PASSTHROUGH_VERT
 
-  // Sample the OES external camera texture and emit as 2D RGBA. The first
-  // pass of every effect runs this so subsequent passes can use sampler2D.
-  //
-  // The camera's TextureBuffer carries a transform matrix that encodes the
-  // selfie mirror (front cameras), sensor orientation correction, and any
-  // crop. The renderer applies it when displaying the raw OES; we have to
-  // apply it ourselves before sampling, otherwise our 2D output is the raw
-  // sensor view instead of the screen-aligned view.
-  const val OES_PASSTHROUGH_FRAG = """#version 300 es
+    // Sample the OES external camera texture and emit as 2D RGBA. The first
+    // pass of every effect runs this so subsequent passes can use sampler2D.
+    //
+    // The camera's TextureBuffer carries a transform matrix that encodes the
+    // selfie mirror (front cameras), sensor orientation correction, and any
+    // crop. The renderer applies it when displaying the raw OES; we have to
+    // apply it ourselves before sampling, otherwise our 2D output is the raw
+    // sensor view instead of the screen-aligned view.
+    const val OES_PASSTHROUGH_FRAG = """#version 300 es
 #extension GL_OES_EGL_image_external_essl3 : require
 precision mediump float;
 uniform samplerExternalOES uTex;
@@ -41,61 +41,42 @@ void main() {
 }
 """
 
-  // Separable 1D Gaussian using pre-computed weights + offsets uniform arrays.
-  // 17 texture lookups per pixel (1 center + 8 symmetric pairs) and zero
-  // exp() calls; the kernel is computed once on the CPU and uploaded once
-  // per program use. Inspired by software-mansion/react-native-executorch's
-  // GlBlurRenderer pattern; ~2x faster than evaluating the Gaussian
-  // per-pixel in the fragment shader.
-  //
-  // uAxis is (1/width, 0) for the horizontal pass and (0, 1/height) for the
-  // vertical pass. uOffsets[0] is the center tap (zero); offsets are in
-  // pixel units, so the shader multiplies by uAxis to convert to UV space.
-  // Canonical source: shaders/blur.frag. Generated into ShadersGenerated by
-  // `bun run build:shaders`; delegated here. BlurFactory computes the 9 weights
-  // and offsets from sigma on the CPU and uploads the arrays each program use.
-  val BLUR_FRAG = ShadersGenerated.BLUR_FRAG
+    // Plain 2D-sampler passthrough. The RGB-input branch of an effect (i.e. when
+    // it is chained AFTER another effect that already emitted a GL_TEXTURE_2D
+    // TextureBuffer) runs this in place of OES_PASSTHROUGH_FRAG to land the
+    // upstream 2D source in the cached "original 2D" FBO. No texture matrix: the
+    // upstream effect already normalized orientation (display-upright, rotation
+    // 0), so this is an identity copy. Platform-local (no OES, no cross-runtime
+    // variant), so it stays hand-written here rather than in ShadersGenerated.
+    const val TWO_D_PASSTHROUGH_FRAG = """#version 300 es
+precision mediump float;
+uniform sampler2D uTex;
+in highp vec2 vUv;
+out vec4 oColor;
+void main() {
+  oColor = texture(uTex, vUv);
+}
+"""
+
+    // Composite compositor BLUR layer: camera-sampling separable gaussian, 13-tap
+    // with sigma-coupled spread. Canonical source shaders/blur/composite-blur.frag,
+    // generated into ShadersGenerated; delegated here. Migrated off the hand-written
+    // LayerShaders.BLUR_FRAG (and the old CPU-kernel linear blur.frag, now deleted).
+    val COMPOSITE_BLUR_FRAG = ShadersGenerated.COMPOSITE_BLUR_FRAG
 
-  // Composite: mix(background, original, mask). One shader, byte-identical
-  // to src/web/shaders.ts's COMPOSITE_FRAG_SRC.
-  //
-  // uOriginal and uBackground are expected to land with semantic "top of
-  // source image" at GL v=1; the shader samples both at vUv directly. On
-  // Android the OES->2D pass with transformMatrix lands the original at
-  // v=1, and the bg PNG is pre-flipped via Bitmap matrix before
-  // GLUtils.texImage2D since Android OpenGL ES has no flipY flag.
-  //
-  // uMask is sampled at vUv * uMaskUvScale + uMaskUvOffset. On Android,
-  // those are identity (1,1) and (0,0) because the readback round-trip
-  // (glReadPixels bottom-up plus Bitmap top-down plus GLUtils.texImage2D
-  // row-preserving) leaves the mask aligned with origFbo. On web they are
-  // (1,-1) and (0,1) to encode a V-flip on the mask sampling, because
-  // canvas-staging the mask there would mangle the soft confidence values
-  // in alpha (premultiplied-alpha math).
-  //
-  // uMaskLo / uMaskHi parameterize the smoothstep transition over the raw
-  // confidence map. The processor computes them from a maskHardness factor
-  // (0 = soft halo, 1 = hard edge) so callers do not have to think in lo/hi
-  // pairs.
-  //
-  // uBgUvScale and uBgUvOffset control how the background texture is mapped
-  // onto the output. For blur, they are (1,1) and (0,0); sample the full
-  // blurred copy. For background-image, the caller computes them to perform
-  // a cover-fit center crop so an arbitrarily-shaped image fills the output
-  // without distortion.
-  // Canonical source: shaders/composite.frag. Generated into ShadersGenerated
-  // by `bun run build:shaders`; delegated here. The per-platform mask/bg
-  // orientation differences live in the uniforms the host sets (see above),
-  // not in the shader, so the same generated body serves every runtime.
-  val COMPOSITE_FRAG = ShadersGenerated.COMPOSITE_FRAG
+    // Composite compositor CAMERA layer (direct/background): raw display-upright
+    // camera, opaque. Canonical source shaders/_shared/composite-camera.frag,
+    // generated into ShadersGenerated; delegated here. Migrated off the hand-written
+    // LayerShaders.CAMERA_FRAG.
+    val COMPOSITE_CAMERA_FRAG = ShadersGenerated.COMPOSITE_CAMERA_FRAG
 
-  // Transform: a single-pass geometric reorientation (axis flip or 90-degree
-  // rotation) driven by the uUvTransform mat2 the host computes from a pure
-  // screen-space op via Orientation.mat2For. One shader serves all four ops
-  // (flip-x, flip-y, rotate-cw, rotate-ccw); the input is already
-  // display-upright (camera orientation is normalized once in Ingest), so no
-  // rotation correction happens here.
-  // Canonical source: shaders/transform.frag. Generated into ShadersGenerated
-  // by `bun run build:shaders`; delegated here.
-  val TRANSFORM_FRAG = ShadersGenerated.TRANSFORM_FRAG
+    // Transform: a single-pass geometric reorientation (axis flip or 90-degree
+    // rotation) driven by the uUvTransform mat2 the host computes from a pure
+    // screen-space op via Orientation.mat2For. One shader serves all four ops
+    // (flip-x, flip-y, rotate-cw, rotate-ccw); the input is already
+    // display-upright (camera orientation is normalized once in Ingest), so no
+    // rotation correction happens here.
+    // Canonical source: shaders/transform.frag. Generated into ShadersGenerated
+    // by `bun run build:shaders`; delegated here.
+    val TRANSFORM_FRAG = ShadersGenerated.TRANSFORM_FRAG
 }