@opentui/core 0.1.0

package/supersampling-jw3fem06.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/text-buffer.d.ts

@@ -0,0 +1,45 @@
+import type { StyledText } from "./lib/styled-text";
+import { RGBA } from "./types";
+import { type RenderLib } from "./zig";
+import { type Pointer } from "bun:ffi";
+export interface TextChunk {
+    __isChunk: true;
+    text: Uint8Array;
+    plainText: string;
+    fg?: RGBA;
+    bg?: RGBA;
+    attributes?: number;
+}
+export declare class TextBuffer {
+    private lib;
+    private bufferPtr;
+    private buffer;
+    private _length;
+    private _capacity;
+    private _lineInfo?;
+    constructor(lib: RenderLib, ptr: Pointer, buffer: {
+        char: Uint32Array;
+        fg: Float32Array;
+        bg: Float32Array;
+        attributes: Uint16Array;
+    }, capacity: number);
+    static create(capacity?: number): TextBuffer;
+    private syncBuffersAfterResize;
+    setStyledText(text: StyledText): void;
+    setDefaultFg(fg: RGBA | null): void;
+    setDefaultBg(bg: RGBA | null): void;
+    setDefaultAttributes(attributes: number | null): void;
+    resetDefaults(): void;
+    get length(): number;
+    get capacity(): number;
+    get ptr(): Pointer;
+    get lineInfo(): {
+        lineStarts: number[];
+        lineWidths: number[];
+    };
+    toString(): string;
+    concat(other: TextBuffer): TextBuffer;
+    setSelection(start: number, end: number, bgColor?: RGBA, fgColor?: RGBA): void;
+    resetSelection(): void;
+    destroy(): void;
+}

package/types.d.ts

@@ -0,0 +1,56 @@
+export declare class RGBA {
+    buffer: Float32Array;
+    constructor(buffer: Float32Array);
+    static fromArray(array: Float32Array): RGBA;
+    static fromValues(r: number, g: number, b: number, a?: number): RGBA;
+    static fromInts(r: number, g: number, b: number, a?: number): RGBA;
+    static fromHex(hex: string): RGBA;
+    toInts(): [number, number, number, number];
+    get r(): number;
+    set r(value: number);
+    get g(): number;
+    set g(value: number);
+    get b(): number;
+    set b(value: number);
+    get a(): number;
+    set a(value: number);
+    map<R>(fn: (value: number) => R): R[];
+    toString(): string;
+}
+export type ColorInput = string | RGBA;
+export declare const TextAttributes: {
+    NONE: number;
+    BOLD: number;
+    DIM: number;
+    ITALIC: number;
+    UNDERLINE: number;
+    BLINK: number;
+    INVERSE: number;
+    HIDDEN: number;
+    STRIKETHROUGH: number;
+};
+export type CursorStyle = "block" | "line" | "underline";
+export declare enum DebugOverlayCorner {
+    topLeft = 0,
+    topRight = 1,
+    bottomLeft = 2,
+    bottomRight = 3
+}
+export interface RenderContext {
+    addToHitGrid: (x: number, y: number, width: number, height: number, id: number) => void;
+    width: () => number;
+    height: () => number;
+    needsUpdate: () => void;
+}
+export interface SelectionState {
+    anchor: {
+        x: number;
+        y: number;
+    };
+    focus: {
+        x: number;
+        y: number;
+    };
+    isActive: boolean;
+    isSelecting: boolean;
+}

package/utils.d.ts

@@ -0,0 +1,19 @@
+import { type ColorInput, RGBA } from "./types";
+export declare function hexToRgb(hex: string): RGBA;
+export declare function rgbToHex(rgb: RGBA): string;
+export declare function hsvToRgb(h: number, s: number, v: number): RGBA;
+export declare function parseColor(color: ColorInput): RGBA;
+export declare function createTextAttributes({ bold, italic, underline, dim, blink, inverse, hidden, strikethrough, }?: {
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    dim?: boolean;
+    blink?: boolean;
+    inverse?: boolean;
+    hidden?: boolean;
+    strikethrough?: boolean;
+}): number;
+export declare function loadTemplate(filePath: string, params: Record<string, string>): Promise<string>;
+export declare function fixPaths<T extends {
+    [key: string]: string;
+}>(paths: T): T;

package/zig.d.ts

@@ -0,0 +1,95 @@
+import { type Pointer } from "bun:ffi";
+import type { CursorStyle, DebugOverlayCorner } from "./types";
+import { RGBA } from "./types";
+import { OptimizedBuffer } from "./buffer";
+import { TextBuffer } from "./text-buffer";
+export interface RenderLib {
+    createRenderer: (width: number, height: number) => Pointer | null;
+    destroyRenderer: (renderer: Pointer) => void;
+    setUseThread: (renderer: Pointer, useThread: boolean) => void;
+    setBackgroundColor: (renderer: Pointer, color: RGBA) => void;
+    setRenderOffset: (renderer: Pointer, offset: number) => void;
+    updateStats: (renderer: Pointer, time: number, fps: number, frameCallbackTime: number) => void;
+    updateMemoryStats: (renderer: Pointer, heapUsed: number, heapTotal: number, arrayBuffers: number) => void;
+    render: (renderer: Pointer, force: boolean) => void;
+    getNextBuffer: (renderer: Pointer) => OptimizedBuffer;
+    getCurrentBuffer: (renderer: Pointer) => OptimizedBuffer;
+    createOptimizedBuffer: (width: number, height: number, respectAlpha?: boolean) => OptimizedBuffer;
+    destroyOptimizedBuffer: (bufferPtr: Pointer) => void;
+    drawFrameBuffer: (targetBufferPtr: Pointer, destX: number, destY: number, bufferPtr: Pointer, sourceX?: number, sourceY?: number, sourceWidth?: number, sourceHeight?: number) => void;
+    getBufferWidth: (buffer: Pointer) => number;
+    getBufferHeight: (buffer: Pointer) => number;
+    bufferClear: (buffer: Pointer, color: RGBA) => void;
+    bufferGetCharPtr: (buffer: Pointer) => Pointer;
+    bufferGetFgPtr: (buffer: Pointer) => Pointer;
+    bufferGetBgPtr: (buffer: Pointer) => Pointer;
+    bufferGetAttributesPtr: (buffer: Pointer) => Pointer;
+    bufferGetRespectAlpha: (buffer: Pointer) => boolean;
+    bufferSetRespectAlpha: (buffer: Pointer, respectAlpha: boolean) => void;
+    bufferDrawText: (buffer: Pointer, text: string, x: number, y: number, color: RGBA, bgColor?: RGBA, attributes?: number) => void;
+    bufferSetCellWithAlphaBlending: (buffer: Pointer, x: number, y: number, char: string, color: RGBA, bgColor: RGBA, attributes?: number) => void;
+    bufferFillRect: (buffer: Pointer, x: number, y: number, width: number, height: number, color: RGBA) => void;
+    bufferDrawSuperSampleBuffer: (buffer: Pointer, x: number, y: number, pixelDataPtr: Pointer, pixelDataLength: number, format: "bgra8unorm" | "rgba8unorm", alignedBytesPerRow: number) => void;
+    bufferDrawPackedBuffer: (buffer: Pointer, dataPtr: Pointer, dataLen: number, posX: number, posY: number, terminalWidthCells: number, terminalHeightCells: number) => void;
+    bufferDrawBox: (buffer: Pointer, x: number, y: number, width: number, height: number, borderChars: Uint32Array, packedOptions: number, borderColor: RGBA, backgroundColor: RGBA, title: string | null) => void;
+    bufferResize: (buffer: Pointer, width: number, height: number) => {
+        char: Uint32Array;
+        fg: Float32Array;
+        bg: Float32Array;
+        attributes: Uint8Array;
+    };
+    resizeRenderer: (renderer: Pointer, width: number, height: number) => void;
+    setCursorPosition: (x: number, y: number, visible: boolean) => void;
+    setCursorStyle: (style: CursorStyle, blinking: boolean) => void;
+    setCursorColor: (color: RGBA) => void;
+    setDebugOverlay: (renderer: Pointer, enabled: boolean, corner: DebugOverlayCorner) => void;
+    clearTerminal: (renderer: Pointer) => void;
+    addToHitGrid: (renderer: Pointer, x: number, y: number, width: number, height: number, id: number) => void;
+    checkHit: (renderer: Pointer, x: number, y: number) => number;
+    dumpHitGrid: (renderer: Pointer) => void;
+    dumpBuffers: (renderer: Pointer, timestamp?: number) => void;
+    dumpStdoutBuffer: (renderer: Pointer, timestamp?: number) => void;
+    createTextBuffer: (capacity: number) => TextBuffer;
+    destroyTextBuffer: (buffer: Pointer) => void;
+    textBufferGetCharPtr: (buffer: Pointer) => Pointer;
+    textBufferGetFgPtr: (buffer: Pointer) => Pointer;
+    textBufferGetBgPtr: (buffer: Pointer) => Pointer;
+    textBufferGetAttributesPtr: (buffer: Pointer) => Pointer;
+    textBufferGetLength: (buffer: Pointer) => number;
+    textBufferSetCell: (buffer: Pointer, index: number, char: number, fg: Float32Array, bg: Float32Array, attr: number) => void;
+    textBufferConcat: (buffer1: Pointer, buffer2: Pointer) => TextBuffer;
+    textBufferResize: (buffer: Pointer, newLength: number) => {
+        char: Uint32Array;
+        fg: Float32Array;
+        bg: Float32Array;
+        attributes: Uint16Array;
+    };
+    textBufferReset: (buffer: Pointer) => void;
+    textBufferSetSelection: (buffer: Pointer, start: number, end: number, bgColor: RGBA | null, fgColor: RGBA | null) => void;
+    textBufferResetSelection: (buffer: Pointer) => void;
+    textBufferSetDefaultFg: (buffer: Pointer, fg: RGBA | null) => void;
+    textBufferSetDefaultBg: (buffer: Pointer, bg: RGBA | null) => void;
+    textBufferSetDefaultAttributes: (buffer: Pointer, attributes: number | null) => void;
+    textBufferResetDefaults: (buffer: Pointer) => void;
+    textBufferWriteChunk: (buffer: Pointer, textBytes: Uint8Array, fg: RGBA | null, bg: RGBA | null, attributes: number | null) => number;
+    textBufferGetCapacity: (buffer: Pointer) => number;
+    textBufferFinalizeLineInfo: (buffer: Pointer) => void;
+    textBufferGetLineInfo: (buffer: Pointer) => {
+        lineStarts: number[];
+        lineWidths: number[];
+    };
+    getTextBufferArrays: (buffer: Pointer, size: number) => {
+        char: Uint32Array;
+        fg: Float32Array;
+        bg: Float32Array;
+        attributes: Uint16Array;
+    };
+    bufferDrawTextBuffer: (buffer: Pointer, textBuffer: Pointer, x: number, y: number, clipRect?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }) => void;
+}
+export declare function setRenderLibPath(libPath: string): void;
+export declare function resolveRenderLib(): RenderLib;