react-native-webrtc-kaleidoscope 2.0.0 → 2.1.0

package/ios/KaleidoscopeModule/gpu/Orientation.swift

@@ -35,49 +35,49 @@ import Foundation
 import simd
 
 enum Orientation {
-  /// The four geometric reorientation ops, keyed by their registered effect
-  /// name. Screen-space semantics are documented on each case.
-  enum Op: String {
-    /// Screen-horizontal mirror (left<->right, head stays up).
-    case flipX = "flip-x"
-    /// Screen-vertical flip (upside down, left/right unchanged).
-    case flipY = "flip-y"
-    /// Whole frame rotated 90 degrees clockwise (output dims swap to h x w).
-    case rotateCW = "rotate-cw"
-    /// Whole frame rotated 90 degrees counter-clockwise (output dims swap).
-    case rotateCCW = "rotate-ccw"
+    /// The four geometric reorientation ops, keyed by their registered effect
+    /// name. Screen-space semantics are documented on each case.
+    enum Op: String {
+        /// Screen-horizontal mirror (left<->right, head stays up).
+        case flipX = "flip-x"
+        /// Screen-vertical flip (upside down, left/right unchanged).
+        case flipY = "flip-y"
+        /// Whole frame rotated 90 degrees clockwise (output dims swap to h x w).
+        case rotateCW = "rotate-cw"
+        /// Whole frame rotated 90 degrees counter-clockwise (output dims swap).
+        case rotateCCW = "rotate-ccw"
 
-    /// Whether this op swaps the output dimensions (w x h -> h x w). True for the
-    /// 90-degree rotations, false for the flips.
-    var swapsDimensions: Bool {
-      switch self {
-      case .flipX, .flipY: return false
-      case .rotateCW, .rotateCCW: return true
-      }
+        /// Whether this op swaps the output dimensions (w x h -> h x w). True for the
+        /// 90-degree rotations, false for the flips.
+        var swapsDimensions: Bool {
+            switch self {
+            case .flipX, .flipY: false
+            case .rotateCW, .rotateCCW: true
+            }
+        }
     }
-  }
 
-  /// The uUvTransform to bind at buffer(0) of transform.metalsrc for `op`. The
-  /// input frame is already display-upright (see Ingest), so this is pure screen
-  /// space and rotation-independent.
-  ///
-  /// flip-x:   negate U                       -> columns (-1, 0), ( 0,  1)
-  /// flip-y:   negate V                       -> columns ( 1, 0), ( 0, -1)
-  /// rotate-cw / rotate-ccw: screen 90-degree rotations. Shared with Android's
-  ///   mat2For. On the clean sampled space (both flips correct, so no transpose
-  ///   or residual reflection) columns (0,-1),(1,0) rendered COUNTER-clockwise,
-  ///   so clockwise is its inverse, columns (0,1),(-1,0). (Requires the ingest to
-  ///   deliver a display-upright, non-mirrored original; see Ingest.swift.)
-  static func uvTransform(op: Op) -> simd_float2x2 {
-    switch op {
-    case .flipX:
-      return simd_float2x2(columns: (SIMD2<Float>(-1, 0), SIMD2<Float>(0, 1)))
-    case .flipY:
-      return simd_float2x2(columns: (SIMD2<Float>(1, 0), SIMD2<Float>(0, -1)))
-    case .rotateCW:
-      return simd_float2x2(columns: (SIMD2<Float>(0, 1), SIMD2<Float>(-1, 0)))
-    case .rotateCCW:
-      return simd_float2x2(columns: (SIMD2<Float>(0, -1), SIMD2<Float>(1, 0)))
+    /// The uUvTransform to bind at buffer(0) of transform.metalsrc for `op`. The
+    /// input frame is already display-upright (see Ingest), so this is pure screen
+    /// space and rotation-independent.
+    ///
+    /// flip-x:   negate U                       -> columns (-1, 0), ( 0,  1)
+    /// flip-y:   negate V                       -> columns ( 1, 0), ( 0, -1)
+    /// rotate-cw / rotate-ccw: screen 90-degree rotations. Shared with Android's
+    ///   mat2For. On the clean sampled space (both flips correct, so no transpose
+    ///   or residual reflection) columns (0,-1),(1,0) rendered COUNTER-clockwise,
+    ///   so clockwise is its inverse, columns (0,1),(-1,0). (Requires the ingest to
+    ///   deliver a display-upright, non-mirrored original; see Ingest.swift.)
+    static func uvTransform(op: Op) -> simd_float2x2 {
+        switch op {
+        case .flipX:
+            simd_float2x2(columns: (SIMD2<Float>(-1, 0), SIMD2<Float>(0, 1)))
+        case .flipY:
+            simd_float2x2(columns: (SIMD2<Float>(1, 0), SIMD2<Float>(0, -1)))
+        case .rotateCW:
+            simd_float2x2(columns: (SIMD2<Float>(0, 1), SIMD2<Float>(-1, 0)))
+        case .rotateCCW:
+            simd_float2x2(columns: (SIMD2<Float>(0, -1), SIMD2<Float>(1, 0)))
+        }
     }
-  }
 }

package/ios/KaleidoscopeModule/gpu/ShaderLibrary.swift

@@ -20,7 +20,7 @@
 // trigger Xcode's MetalCompile build phase for the bundle target, which would
 // compile all three into a single `default.metallib` inside the bundle and
 // collide on the three `main0` entry points (air-lld duplicate-symbol errors
-// at link time) — exactly the collision the source_files exclusion already
+// at link time); exactly the collision the source_files exclusion already
 // avoids for the main target. The podspec's resource_bundles glob copies
 // KaleidoscopeModule/shaders/*.metalsrc into the bundle as plain text, and we
 // read that SOURCE TEXT here via String(contentsOf:), then hand it to
@@ -32,69 +32,115 @@ import Metal
 import os.log
 
 struct ShaderLibrary {
-  private let library: MTLLibrary
+    private let library: MTLLibrary
 
-  /// Compiles `<fileName>.metalsrc` (read from the Kaleidoscope bundle) into a
-  /// standalone MTLLibrary.
-  init(device: MTLDevice, bundle: Bundle, fileName: String) throws {
-    guard let url = ShaderLibrary.locate(fileName: fileName, bundle: bundle) else {
-      throw RendererError.libraryCompileFailed("\(fileName).metalsrc not found in bundle")
-    }
+    /// The raw MSL source text this library was compiled from. Retained so the
+    /// generic generative-shader path can parse the spirv-cross `[[buffer(n)]]`
+    /// decorations out of it (see uniformBufferIndices); the only tractable way
+    /// to bind arbitrary-named uniforms by index without per-shader Swift. The
+    /// fixed-binding shaders (passthrough/blur/composite/transform) ignore it.
     let source: String
-    do {
-      source = try String(contentsOf: url, encoding: .utf8)
-    } catch {
-      throw RendererError.libraryCompileFailed(
-        "read \(fileName).metalsrc failed: \(error.localizedDescription)"
-      )
+
+    /// Compiles `<fileName>.metalsrc` (read from the Kaleidoscope bundle) into a
+    /// standalone MTLLibrary.
+    init(device: MTLDevice, bundle: Bundle, fileName: String) throws {
+        guard let url = ShaderLibrary.locate(fileName: fileName, bundle: bundle) else {
+            throw RendererError.libraryCompileFailed("\(fileName).metalsrc not found in bundle")
+        }
+        let source: String
+        do {
+            source = try String(contentsOf: url, encoding: .utf8)
+        } catch {
+            throw RendererError.libraryCompileFailed(
+                "read \(fileName).metalsrc failed: \(error.localizedDescription)"
+            )
+        }
+        self.source = source
+        do {
+            library = try device.makeLibrary(source: source, options: nil)
+        } catch {
+            throw RendererError.libraryCompileFailed(
+                "compile \(fileName).metalsrc failed: \(error.localizedDescription)"
+            )
+        }
     }
-    do {
-      self.library = try device.makeLibrary(source: source, options: nil)
-    } catch {
-      throw RendererError.libraryCompileFailed(
-        "compile \(fileName).metalsrc failed: \(error.localizedDescription)"
-      )
+
+    /// Returns the `main0` function for this library's stage.
+    func function() throws -> MTLFunction {
+        guard let fn = library.makeFunction(name: "main0") else {
+            throw RendererError.missingFunction("main0")
+        }
+        return fn
     }
-  }
 
-  /// Returns the `main0` function for this library's stage.
-  func function() throws -> MTLFunction {
-    guard let fn = library.makeFunction(name: "main0") else {
-      throw RendererError.missingFunction("main0")
+    /// Parse the fragment-stage uniform name -> Metal buffer index map from the
+    /// spirv-cross MSL source. This is the keystone of the GENERIC uniform binding
+    /// (no per-shader Swift): spirv-cross emits each scalar/vector uniform as a
+    /// `constant T& uName [[buffer(n)]]` argument on `main0`, and CRUCIALLY it does
+    /// NOT preserve GLSL declaration order; plasma.metalsrc binds
+    /// uResolution=0, uTime=1, uSpeed=2, uScale=3, uColorA=4, uColorB=5, which is
+    /// neither GLSL order nor alphabetical. So a host-side name->index map MUST be
+    /// derived from the actual decorations, not assumed. We match every
+    /// `& <name> [[buffer(<n>)]]` token (the `&` distinguishes a `constant T&`
+    /// uniform reference from a texture/sampler argument, which use `[[texture(n)]]`
+    /// / `[[sampler(n)]]`). The leading `&` may be glued to the type (`float&`) or
+    /// spaced; the regex tolerates optional whitespace. Texture and sampler
+    /// arguments are intentionally NOT matched (different decoration), so a
+    /// generative shader that also sampled a texture would not collide here.
+    ///
+    /// Returns e.g. ["uResolution": 0, "uTime": 1, "uSpeed": 2, ...] for plasma.
+    /// The host binds uTime/uResolution itself and looks up every JS-set uniform
+    /// by name in this map to find its buffer index. A uniform the shader does not
+    /// declare is simply absent from the map and skipped at bind time.
+    func uniformBufferIndices() -> [String: Int] {
+        var indices = [String: Int]()
+        // `& uName [[buffer(7)]]` with optional whitespace around the `&` and inside
+        // the attribute. \w covers the u-prefixed identifier; the index is decimal.
+        let pattern = #"&\s*([A-Za-z_][A-Za-z0-9_]*)\s*\[\[\s*buffer\s*\(\s*(\d+)\s*\)\s*\]\]"#
+        guard let regex = try? NSRegularExpression(pattern: pattern) else { return indices }
+        let ns = source as NSString
+        let matches = regex.matches(in: source, range: NSRange(location: 0, length: ns.length))
+        for match in matches where match.numberOfRanges == 3 {
+            let name = ns.substring(with: match.range(at: 1))
+            let idxStr = ns.substring(with: match.range(at: 2))
+            if let idx = Int(idxStr) {
+                indices[name] = idx
+            }
+        }
+        return indices
     }
-    return fn
-  }
 
-  /// Resolve `<fileName>.metalsrc`. Tries the nested Kaleidoscope resource bundle
-  /// first (the normal install layout for an autolinked pod), then the given
-  /// bundle directly, then `shaders/` subpaths under each. The breadth covers
-  /// both the resource_bundles install layout and a flattened test layout.
-  private static func locate(fileName: String, bundle: Bundle) -> URL? {
-    let candidateBundles = [Bundle.kaleidoscopeResources(relativeTo: bundle), bundle].compactMap { $0 }
-    for candidate in candidateBundles {
-      if let url = candidate.url(forResource: fileName, withExtension: "metalsrc") {
-        return url
-      }
-      if let url = candidate.url(forResource: fileName, withExtension: "metalsrc", subdirectory: "shaders") {
-        return url
-      }
+    /// Resolve `<fileName>.metalsrc`. Tries the nested Kaleidoscope resource bundle
+    /// first (the normal install layout for an autolinked pod), then the given
+    /// bundle directly, then `shaders/` subpaths under each. The breadth covers
+    /// both the resource_bundles install layout and a flattened test layout.
+    private static func locate(fileName: String, bundle: Bundle) -> URL? {
+        let candidateBundles = [Bundle.kaleidoscopeResources(relativeTo: bundle), bundle].compactMap { $0 }
+        for candidate in candidateBundles {
+            if let url = candidate.url(forResource: fileName, withExtension: "metalsrc") {
+                return url
+            }
+            if let url = candidate.url(forResource: fileName, withExtension: "metalsrc", subdirectory: "shaders") {
+                return url
+            }
+        }
+        return nil
     }
-    return nil
-  }
 }
 
 extension Bundle {
-  /// Resolves the `Kaleidoscope.bundle` that the podspec's `resource_bundles`
-  /// produces. For an autolinked pod the resource bundle is nested inside the
-  /// framework/app bundle that contains the Swift code; `relativeTo` is that
-  /// containing bundle. Falls back to `Bundle(for:)` of a renderer type so a
-  /// statically linked layout (resources merged into the host app) still
-  /// resolves.
-  static func kaleidoscopeResources(relativeTo containing: Bundle) -> Bundle? {
-    if let url = containing.url(forResource: "Kaleidoscope", withExtension: "bundle"),
-       let nested = Bundle(url: url) {
-      return nested
+    /// Resolves the `Kaleidoscope.bundle` that the podspec's `resource_bundles`
+    /// produces. For an autolinked pod the resource bundle is nested inside the
+    /// framework/app bundle that contains the Swift code; `relativeTo` is that
+    /// containing bundle. Falls back to `Bundle(for:)` of a renderer type so a
+    /// statically linked layout (resources merged into the host app) still
+    /// resolves.
+    static func kaleidoscopeResources(relativeTo containing: Bundle) -> Bundle? {
+        if let url = containing.url(forResource: "Kaleidoscope", withExtension: "bundle"),
+           let nested = Bundle(url: url)
+        {
+            return nested
+        }
+        return nil
     }
-    return nil
-  }
 }