@fairyhunter13/opentui-core 0.1.89 → 0.1.90

package/src/3d/shaders/supersampling.wgsl

@@ -0,0 +1,201 @@
+struct CellResult {
+    bg: vec4<f32>,      // Background RGBA (16 bytes)
+    fg: vec4<f32>,      // Foreground RGBA (16 bytes)
+    char: u32,          // Unicode character code (4 bytes)
+    _padding1: u32,     // Padding (4 bytes)
+    _padding2: u32,     // Extra padding (4 bytes) 
+    _padding3: u32,     // Extra padding (4 bytes) - total now 48 bytes (16-byte aligned)
+};
+
+struct CellBuffer {
+    cells: array<CellResult>
+};
+
+struct SuperSamplingParams {
+    width: u32,              // Canvas width in pixels
+    height: u32,             // Canvas height in pixels  
+    sampleAlgo: u32,         // 0 = standard 2x2, 1 = pre-squeezed horizontal blend
+    _padding: u32,           // Padding for 16-byte alignment
+};
+
+@group(0) @binding(0) var inputTexture: texture_2d<f32>;
+@group(0) @binding(1) var<storage, read_write> output: CellBuffer;
+@group(0) @binding(2) var<uniform> params: SuperSamplingParams;
+
+// Quadrant character lookup table (same as Zig implementation)
+const quadrantChars = array<u32, 16>(
+    32u,      // ' '  - 0000
+    0x2597u,  // ▗   - 0001 BR
+    0x2596u,  // ▖   - 0010 BL  
+    0x2584u,  // ▄   - 0011 Lower Half Block
+    0x259Du,  // ▝   - 0100 TR
+    0x2590u,  // ▐   - 0101 Right Half Block
+    0x259Eu,  // ▞   - 0110 TR+BL
+    0x259Fu,  // ▟   - 0111 TR+BL+BR
+    0x2598u,  // ▘   - 1000 TL
+    0x259Au,  // ▚   - 1001 TL+BR
+    0x258Cu,  // ▌   - 1010 Left Half Block
+    0x2599u,  // ▙   - 1011 TL+BL+BR
+    0x2580u,  // ▀   - 1100 Upper Half Block
+    0x259Cu,  // ▜   - 1101 TL+TR+BR
+    0x259Bu,  // ▛   - 1110 TL+TR+BL
+    0x2588u   // █   - 1111 Full Block
+);
+
+const inv_255: f32 = 1.0 / 255.0;
+
+fn getPixelColor(pixelX: u32, pixelY: u32) -> vec4<f32> {
+    if (pixelX >= params.width || pixelY >= params.height) {
+        return vec4<f32>(0.0, 0.0, 0.0, 1.0); // Black for out-of-bounds
+    }
+    
+    // textureLoad automatically handles format conversion to RGBA
+    return textureLoad(inputTexture, vec2<i32>(i32(pixelX), i32(pixelY)), 0);
+}
+
+fn colorDistance(a: vec4<f32>, b: vec4<f32>) -> f32 {
+    let diff = a.rgb - b.rgb;
+    return dot(diff, diff);
+}
+
+fn luminance(color: vec4<f32>) -> f32 {
+    return 0.2126 * color.r + 0.7152 * color.g + 0.0722 * color.b;
+}
+
+fn closestColorIndex(pixel: vec4<f32>, candA: vec4<f32>, candB: vec4<f32>) -> u32 {
+    return select(1u, 0u, colorDistance(pixel, candA) <= colorDistance(pixel, candB));
+}
+
+fn averageColor(pixels: array<vec4<f32>, 4>) -> vec4<f32> {
+    return (pixels[0] + pixels[1] + pixels[2] + pixels[3]) * 0.25;
+}
+
+fn blendColors(color1: vec4<f32>, color2: vec4<f32>) -> vec4<f32> {
+    let a1 = color1.a;
+    let a2 = color2.a;
+    
+    if (a1 == 0.0 && a2 == 0.0) {
+        return vec4<f32>(0.0, 0.0, 0.0, 0.0);
+    }
+    
+    let outAlpha = a1 + a2 - a1 * a2;
+    if (outAlpha == 0.0) {
+        return vec4<f32>(0.0, 0.0, 0.0, 0.0);
+    }
+    
+    let rgb = (color1.rgb * a1 + color2.rgb * a2 * (1.0 - a1)) / outAlpha;
+    
+    return vec4<f32>(rgb, outAlpha);
+}
+
+fn averageColorsWithAlpha(pixels: array<vec4<f32>, 4>) -> vec4<f32> {
+    let blend1 = blendColors(pixels[0], pixels[1]);
+    let blend2 = blendColors(pixels[2], pixels[3]);
+    
+    return blendColors(blend1, blend2);
+}
+
+fn renderQuadrantBlock(pixels: array<vec4<f32>, 4>) -> CellResult {
+    var maxDist: f32 = colorDistance(pixels[0], pixels[1]);
+    var pIdxA: u32 = 0u;
+    var pIdxB: u32 = 1u;
+    
+    for (var i: u32 = 0u; i < 4u; i++) {
+        for (var j: u32 = i + 1u; j < 4u; j++) {
+            let dist = colorDistance(pixels[i], pixels[j]);
+            if (dist > maxDist) {
+                pIdxA = i;
+                pIdxB = j;
+                maxDist = dist;
+            }
+        }
+    }
+    
+    let pCandA = pixels[pIdxA];
+    let pCandB = pixels[pIdxB];
+    
+    var chosenDarkColor: vec4<f32>;
+    var chosenLightColor: vec4<f32>;
+    
+    if (luminance(pCandA) <= luminance(pCandB)) {
+        chosenDarkColor = pCandA;
+        chosenLightColor = pCandB;
+    } else {
+        chosenDarkColor = pCandB;
+        chosenLightColor = pCandA;
+    }
+    
+    var quadrantBits: u32 = 0u;
+    let bitValues = array<u32, 4>(8u, 4u, 2u, 1u); // TL, TR, BL, BR
+    
+    for (var i: u32 = 0u; i < 4u; i++) {
+        if (closestColorIndex(pixels[i], chosenDarkColor, chosenLightColor) == 0u) {
+            quadrantBits |= bitValues[i];
+        }
+    }
+    
+    // Construct result
+    var result: CellResult;
+    
+    if (quadrantBits == 0u) { // All light
+        result.char = 32u; // Space character
+        result.fg = chosenDarkColor;
+        result.bg = averageColorsWithAlpha(pixels);
+    } else if (quadrantBits == 15u) { // All dark  
+        result.char = quadrantChars[15]; // Full block
+        result.fg = averageColorsWithAlpha(pixels);
+        result.bg = chosenLightColor;
+    } else { // Mixed pattern
+        result.char = quadrantChars[quadrantBits];
+        result.fg = chosenDarkColor;
+        result.bg = chosenLightColor;
+    }
+    result._padding1 = 0u;
+    result._padding2 = 0u;
+    result._padding3 = 0u;
+    
+    return result;
+}
+
+@compute @workgroup_size(${WORKGROUP_SIZE}, ${WORKGROUP_SIZE}, 1)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    let cellX = id.x;
+    let cellY = id.y;
+    let bufferWidthCells = (params.width + 1u) / 2u;
+    let bufferHeightCells = (params.height + 1u) / 2u;
+    
+    if (cellX >= bufferWidthCells || cellY >= bufferHeightCells) {
+        return;
+    }
+    
+    let renderX = cellX * 2u;
+    let renderY = cellY * 2u;
+    
+    var pixelsRgba: array<vec4<f32>, 4>;
+    
+    if (params.sampleAlgo == 1u) {
+        let topColor = getPixelColor(renderX, renderY);
+        let topColor2 = getPixelColor(renderX + 1u, renderY);
+        
+        let blendedTop = blendColors(topColor, topColor2);
+        
+        let bottomColor = getPixelColor(renderX, renderY + 1u);
+        let bottomColor2 = getPixelColor(renderX + 1u, renderY + 1u);
+        let blendedBottom = blendColors(bottomColor, bottomColor2);
+        
+        pixelsRgba[0] = blendedTop;      // TL
+        pixelsRgba[1] = blendedTop;      // TR  
+        pixelsRgba[2] = blendedBottom;   // BL
+        pixelsRgba[3] = blendedBottom;   // BR
+    } else {
+        pixelsRgba[0] = getPixelColor(renderX, renderY);         // TL
+        pixelsRgba[1] = getPixelColor(renderX + 1u, renderY);   // TR  
+        pixelsRgba[2] = getPixelColor(renderX, renderY + 1u);   // BL
+        pixelsRgba[3] = getPixelColor(renderX + 1u, renderY + 1u); // BR
+    }
+    
+    let cellResult = renderQuadrantBlock(pixelsRgba);
+    
+    let outputIndex = cellY * bufferWidthCells + cellX;
+    output.cells[outputIndex] = cellResult;
+}

package/src/3d.ts

@@ -0,0 +1,3 @@
+// 3D module exports - requires optional dependencies
+export * from "./3d/index.js"
+export * as THREE from "three"

package/src/NativeSpanFeed.ts

@@ -0,0 +1,300 @@
+import { toArrayBuffer, type Pointer } from "bun:ffi"
+import { resolveRenderLib } from "./zig"
+import { SpanInfoStruct } from "./zig-structs"
+import type { GrowthPolicy, NativeSpanFeedOptions, NativeSpanFeedStats } from "./zig-structs"
+
+export type { GrowthPolicy, NativeSpanFeedOptions, NativeSpanFeedStats } from "./zig-structs"
+
+const enum EventId {
+  ChunkAdded = 2,
+  Closed = 5,
+  Error = 6,
+  DataAvailable = 7,
+  StateBuffer = 8,
+}
+
+function toPointer(value: number | bigint): Pointer {
+  if (typeof value === "bigint") {
+    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error("Pointer exceeds safe integer range")
+    }
+    return Number(value) as Pointer
+  }
+  return value as Pointer
+}
+
+function toNumber(value: number | bigint): number {
+  return typeof value === "bigint" ? Number(value) : value
+}
+
+type StreamEventHandler = (eventId: number, arg0: Pointer, arg1: number | bigint) => void
+
+export type DataHandler = (data: Uint8Array) => void | Promise<void>
+
+/**
+ * Zero-copy wrapper over Zig memory; not a full stream interface.
+ */
+export class NativeSpanFeed {
+  static create(options?: NativeSpanFeedOptions): NativeSpanFeed {
+    const lib = resolveRenderLib()
+    const streamPtr = lib.createNativeSpanFeed(options)
+    const stream = new NativeSpanFeed(streamPtr)
+
+    lib.registerNativeSpanFeedStream(streamPtr, stream.eventHandler)
+
+    const status = lib.attachNativeSpanFeed(streamPtr)
+    if (status !== 0) {
+      lib.unregisterNativeSpanFeedStream(streamPtr)
+      lib.destroyNativeSpanFeed(streamPtr)
+      throw new Error(`Failed to attach stream: ${status}`)
+    }
+
+    return stream
+  }
+
+  static attach(streamPtr: bigint | number, _options?: NativeSpanFeedOptions): NativeSpanFeed {
+    const lib = resolveRenderLib()
+    const ptr = toPointer(streamPtr)
+    const stream = new NativeSpanFeed(ptr)
+
+    lib.registerNativeSpanFeedStream(ptr, stream.eventHandler)
+
+    const status = lib.attachNativeSpanFeed(ptr)
+    if (status !== 0) {
+      lib.unregisterNativeSpanFeedStream(ptr)
+      throw new Error(`Failed to attach stream: ${status}`)
+    }
+
+    return stream
+  }
+
+  readonly streamPtr: Pointer
+  private readonly lib = resolveRenderLib()
+  private readonly eventHandler: StreamEventHandler
+  private chunkMap = new Map<Pointer, ArrayBuffer>()
+  private chunkSizes = new Map<Pointer, number>()
+  private dataHandlers = new Set<DataHandler>()
+  private errorHandlers = new Set<(code: number) => void>()
+  private drainBuffer: Uint8Array | null = null
+  private stateBuffer: Uint8Array | null = null
+  private closed = false
+  private destroyed = false
+  private draining = false
+  private pendingDataAvailable = false
+  private pendingClose = false
+  private closing = false
+  private pendingAsyncHandlers = 0
+  private inCallback = false
+  private closeQueued = false
+
+  private constructor(streamPtr: Pointer) {
+    this.streamPtr = streamPtr
+    this.eventHandler = (eventId, arg0, arg1) => {
+      this.handleEvent(eventId, arg0, arg1)
+    }
+    this.ensureDrainBuffer()
+  }
+
+  private ensureDrainBuffer(): void {
+    if (this.drainBuffer) return
+    const capacity = 256
+    this.drainBuffer = new Uint8Array(capacity * SpanInfoStruct.size)
+  }
+
+  onData(handler: DataHandler): () => void {
+    this.dataHandlers.add(handler)
+    if (this.pendingDataAvailable) {
+      this.pendingDataAvailable = false
+      this.drainAll()
+    }
+    return () => this.dataHandlers.delete(handler)
+  }
+
+  onError(handler: (code: number) => void): () => void {
+    this.errorHandlers.add(handler)
+    return () => this.errorHandlers.delete(handler)
+  }
+
+  close(): void {
+    if (this.destroyed) return
+    if (this.inCallback || this.draining || this.pendingAsyncHandlers > 0) {
+      this.pendingClose = true
+      if (!this.closeQueued) {
+        this.closeQueued = true
+        queueMicrotask(() => {
+          this.closeQueued = false
+          this.processPendingClose()
+        })
+      }
+      return
+    }
+    this.performClose()
+  }
+
+  private processPendingClose(): void {
+    if (!this.pendingClose || this.destroyed) return
+    if (this.inCallback || this.draining || this.pendingAsyncHandlers > 0) return
+    this.pendingClose = false
+    this.performClose()
+  }
+
+  private performClose(): void {
+    if (this.closing) return
+    this.closing = true
+    if (!this.closed) {
+      const status = this.lib.streamClose(this.streamPtr)
+      if (status !== 0) {
+        this.closing = false
+        return
+      }
+      this.closed = true
+    }
+    this.finalizeDestroy()
+  }
+
+  private finalizeDestroy(): void {
+    if (this.destroyed) return
+    this.lib.unregisterNativeSpanFeedStream(this.streamPtr)
+    this.lib.destroyNativeSpanFeed(this.streamPtr)
+    this.destroyed = true
+    this.chunkMap.clear()
+    this.chunkSizes.clear()
+    this.stateBuffer = null
+    this.drainBuffer = null
+    this.dataHandlers.clear()
+    this.errorHandlers.clear()
+    this.pendingDataAvailable = false
+  }
+
+  private handleEvent(eventId: number, arg0: Pointer, arg1: number | bigint): void {
+    this.inCallback = true
+    try {
+      switch (eventId) {
+        case EventId.StateBuffer: {
+          const len = toNumber(arg1)
+          if (len > 0 && arg0) {
+            // toArrayBuffer must alias Zig memory so refcount writes are visible.
+            const buffer = toArrayBuffer(arg0, 0, len)
+            this.stateBuffer = new Uint8Array(buffer)
+          }
+          break
+        }
+        case EventId.DataAvailable: {
+          if (this.closing) break
+          if (this.dataHandlers.size === 0) {
+            this.pendingDataAvailable = true
+            break
+          }
+          this.drainAll()
+          break
+        }
+        case EventId.ChunkAdded: {
+          const chunkLen = toNumber(arg1)
+          if (chunkLen > 0 && arg0) {
+            if (!this.chunkMap.has(arg0)) {
+              const buffer = toArrayBuffer(arg0, 0, chunkLen)
+              this.chunkMap.set(arg0, buffer)
+            }
+            this.chunkSizes.set(arg0, chunkLen)
+          }
+          break
+        }
+        case EventId.Error: {
+          const code = arg0
+          for (const handler of this.errorHandlers) handler(code)
+          break
+        }
+        case EventId.Closed: {
+          this.closed = true
+          break
+        }
+        default:
+          break
+      }
+    } finally {
+      this.inCallback = false
+    }
+  }
+
+  private decrementRefcount(chunkIndex: number): void {
+    if (this.stateBuffer && chunkIndex < this.stateBuffer.length) {
+      const prev = this.stateBuffer[chunkIndex]
+      this.stateBuffer[chunkIndex] = prev > 0 ? prev - 1 : 0
+    }
+  }
+
+  private drainOnce(): number {
+    if (!this.drainBuffer || this.draining || this.pendingClose) return 0
+    const capacity = Math.floor(this.drainBuffer.byteLength / SpanInfoStruct.size)
+    if (capacity === 0) return 0
+
+    const count = this.lib.streamDrainSpans(this.streamPtr, this.drainBuffer, capacity)
+    if (count === 0) return 0
+
+    this.draining = true
+    const spans = SpanInfoStruct.unpackList(this.drainBuffer.buffer, count)
+    let firstError: unknown = null
+
+    try {
+      for (const span of spans) {
+        if (span.len === 0) continue
+
+        let buffer = this.chunkMap.get(span.chunkPtr)
+        if (!buffer) {
+          const size = this.chunkSizes.get(span.chunkPtr)
+          if (!size) continue
+          buffer = toArrayBuffer(span.chunkPtr, 0, size)
+          this.chunkMap.set(span.chunkPtr, buffer)
+        }
+
+        if (span.offset + span.len > buffer.byteLength) continue
+
+        const slice = new Uint8Array(buffer, span.offset, span.len)
+        let asyncResults: Promise<void>[] | null = null
+
+        for (const handler of this.dataHandlers) {
+          try {
+            const result = handler(slice)
+            // Async handlers keep the chunk pinned until they settle.
+            if (result && typeof result.then === "function") {
+              asyncResults ??= []
+              asyncResults.push(result)
+            }
+          } catch (e) {
+            firstError ??= e
+          }
+        }
+
+        const shouldStopAfterThisSpan = this.pendingClose
+
+        if (asyncResults) {
+          // Use allSettled so rejections still release refcounts.
+          const chunkIndex = span.chunkIndex
+          this.pendingAsyncHandlers += 1
+          Promise.allSettled(asyncResults).then(() => {
+            this.decrementRefcount(chunkIndex)
+            this.pendingAsyncHandlers -= 1
+            this.processPendingClose()
+          })
+        } else {
+          this.decrementRefcount(span.chunkIndex)
+        }
+
+        if (shouldStopAfterThisSpan) break
+      }
+    } finally {
+      this.draining = false
+    }
+
+    if (firstError) throw firstError
+
+    return count
+  }
+
+  drainAll(): void {
+    let count = this.drainOnce()
+    while (count > 0) {
+      count = this.drainOnce()
+    }
+  }
+}