@fairyhunter13/opentui-core 0.1.90 → 0.1.92

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

@@ -1,201 +0,0 @@
-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

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

package/src/NativeSpanFeed.ts

@@ -1,300 +0,0 @@
-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()
-    }
-  }
-}