@pixagram/renderart 0.4.5 → 1.0.0

package/dist/index.js

@@ -1,964 +1,37 @@
-'use strict';
-
-// src/crt-gpu.ts
-var VERTEX_SHADER = `#version 300 es
-layout(location = 0) in vec2 position;
-out vec2 vUv;
-
-void main() {
-    vUv = position * 0.5 + 0.5;
-    gl_Position = vec4(position, 0.0, 1.0);
-}`;
-var FRAGMENT_SHADER = `#version 300 es
-precision highp float;
-
-uniform sampler2D uTex;
-uniform vec2 uRes;
-uniform vec2 uWarp;
-uniform float uScanHardness;
-uniform float uScanOpacity;
-uniform float uMaskOpacity;
-uniform int uEnableWarp;
-uniform int uEnableScanlines;
-uniform int uEnableMask;
-
-in vec2 vUv;
-out vec4 outColor;
-
-// Gamma 2.0 approximation
-vec3 toLinear(vec3 c) { return c * c; }
-vec3 toSrgb(vec3 c) { return sqrt(c); }
-
-vec2 warp(vec2 uv) {
-    if (uEnableWarp == 0) return uv;
-    vec2 dc = abs(0.5 - uv);
-    vec2 dc2 = dc * dc;
-    uv.x -= 0.5; uv.x *= 1.0 + (dc2.y * (0.3 * uWarp.x)); uv.x += 0.5;
-    uv.y -= 0.5; uv.y *= 1.0 + (dc2.x * (0.4 * uWarp.y)); uv.y += 0.5;
-    return uv;
-}
-
-float scanline(float y, float sourceHeight) {
-    if (uEnableScanlines == 0) return 1.0;
-    float v = fract(y * sourceHeight);
-    float d = abs(v - 0.5);
-    float line = exp(d * d * uScanHardness);
-    return mix(1.0, line, uScanOpacity);
-}
-
-vec3 mask(vec2 pos) {
-    if (uEnableMask == 0) return vec3(1.0);
-    float x = fract(pos.x / 6.0);
-    vec3 m = vec3(1.0);
-    float step1 = 0.333;
-    float step2 = 0.666;
-    
-    m.r = step(0.0, x) - step(step1, x);
-    m.g = step(step1, x) - step(step2, x);
-    m.b = step(step2, x) - step(1.0, x);
-    
-    return mix(vec3(1.0), m, uMaskOpacity);
-}
-
-void main() {
-    // 1. Geometry
-    vec2 uv = warp(vUv);
-    
-    // 2. Bounds Check
-    if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) {
-        outColor = vec4(0.0); 
-        return;
-    }
-
-    // 3. Texture Sample
-    vec4 texSample = texture(uTex, uv);
-    
-    if (texSample.a == 0.0) {
-        outColor = vec4(0.0);
-        return;
-    }
-
-    vec3 linearColor = toLinear(texSample.rgb);
-    
-    // 4. CRT Effects
-    ivec2 texSize = textureSize(uTex, 0);
-    
-    // Smart Bloom
-    float luma = dot(linearColor, vec3(0.299, 0.587, 0.114));
-    float bloom = luma * 0.7;
-
-    // Calculate patterns
-    float scan = scanline(uv.y, float(texSize.y));
-    vec3 m = mask(gl_FragCoord.xy);
-    
-    // Apply effects
-    vec3 effects = m * scan;
-    vec3 finalRGB = linearColor * mix(effects, vec3(1.0), bloom);
-
-    // 5. Output
-    outColor = vec4(toSrgb(finalRGB), texSample.a);
-}`;
-var CrtGpuRenderer = class _CrtGpuRenderer {
-  constructor() {
-    this.gl = null;
-    this.canvas = null;
-    this.program = null;
-    this.texture = null;
-    this.uniforms = {};
-    this.initialized = false;
-    this.currentCanvasSize = { width: 0, height: 0 };
-    this.currentTexSize = { width: 0, height: 0 };
-  }
-  /** Create a new CRT GPU renderer */
-  static create() {
-    const renderer = new _CrtGpuRenderer();
-    renderer.init();
-    return renderer;
-  }
-  init() {
-    if (typeof OffscreenCanvas === "undefined") {
-      throw new Error("OffscreenCanvas not supported");
-    }
-    this.canvas = new OffscreenCanvas(1, 1);
-    this.gl = this.canvas.getContext("webgl2", {
-      alpha: true,
-      premultipliedAlpha: false,
-      desynchronized: true,
-      powerPreference: "high-performance",
-      antialias: false
-    });
-    if (!this.gl) {
-      throw new Error("WebGL2 not supported");
-    }
-    const gl = this.gl;
-    const vs = this.createShader(gl.VERTEX_SHADER, VERTEX_SHADER);
-    const fs = this.createShader(gl.FRAGMENT_SHADER, FRAGMENT_SHADER);
-    this.program = gl.createProgram();
-    gl.attachShader(this.program, vs);
-    gl.attachShader(this.program, fs);
-    gl.linkProgram(this.program);
-    if (!gl.getProgramParameter(this.program, gl.LINK_STATUS)) {
-      throw new Error("Shader program link failed: " + gl.getProgramInfoLog(this.program));
-    }
-    gl.useProgram(this.program);
-    this.uniforms = {
-      uTex: gl.getUniformLocation(this.program, "uTex"),
-      uRes: gl.getUniformLocation(this.program, "uRes"),
-      uWarp: gl.getUniformLocation(this.program, "uWarp"),
-      uScanHardness: gl.getUniformLocation(this.program, "uScanHardness"),
-      uScanOpacity: gl.getUniformLocation(this.program, "uScanOpacity"),
-      uMaskOpacity: gl.getUniformLocation(this.program, "uMaskOpacity"),
-      uEnableWarp: gl.getUniformLocation(this.program, "uEnableWarp"),
-      uEnableScanlines: gl.getUniformLocation(this.program, "uEnableScanlines"),
-      uEnableMask: gl.getUniformLocation(this.program, "uEnableMask")
-    };
-    gl.uniform1i(this.uniforms.uTex, 0);
-    const buf = gl.createBuffer();
-    gl.bindBuffer(gl.ARRAY_BUFFER, buf);
-    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, -1, 3, -1, -1, 3]), gl.STATIC_DRAW);
-    gl.enableVertexAttribArray(0);
-    gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
-    this.texture = gl.createTexture();
-    gl.bindTexture(gl.TEXTURE_2D, this.texture);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-    gl.clearColor(0, 0, 0, 0);
-    this.initialized = true;
-  }
-  createShader(type, source) {
-    const gl = this.gl;
-    const shader = gl.createShader(type);
-    gl.shaderSource(shader, source);
-    gl.compileShader(shader);
-    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-      const info = gl.getShaderInfoLog(shader);
-      gl.deleteShader(shader);
-      throw new Error("Shader compile failed: " + info);
-    }
-    return shader;
-  }
-  /** Check if renderer is ready */
-  isReady() {
-    return this.initialized;
-  }
-  /** Render CRT effect */
-  render(input, options = {}) {
-    if (!this.initialized || !this.gl || !this.canvas) {
-      throw new Error("Renderer not initialized");
-    }
-    const gl = this.gl;
-    const data = input instanceof ImageData ? input.data : input.data;
-    const width = input.width;
-    const height = input.height;
-    const scale = Math.min(32, Math.max(2, options.scale ?? 3));
-    const outWidth = width * scale;
-    const outHeight = height * scale;
-    if (this.currentCanvasSize.width !== outWidth || this.currentCanvasSize.height !== outHeight) {
-      this.canvas.width = outWidth;
-      this.canvas.height = outHeight;
-      this.currentCanvasSize = { width: outWidth, height: outHeight };
-      gl.viewport(0, 0, outWidth, outHeight);
-    }
-    gl.uniform2f(this.uniforms.uRes, outWidth, outHeight);
-    gl.uniform2f(this.uniforms.uWarp, options.warpX ?? 0.015, options.warpY ?? 0.02);
-    gl.uniform1f(this.uniforms.uScanHardness, options.scanHardness ?? -4);
-    gl.uniform1f(this.uniforms.uScanOpacity, options.scanOpacity ?? 0.5);
-    gl.uniform1f(this.uniforms.uMaskOpacity, options.maskOpacity ?? 0.3);
-    gl.uniform1i(this.uniforms.uEnableWarp, options.enableWarp !== false ? 1 : 0);
-    gl.uniform1i(this.uniforms.uEnableScanlines, options.enableScanlines !== false ? 1 : 0);
-    gl.uniform1i(this.uniforms.uEnableMask, options.enableMask !== false ? 1 : 0);
-    gl.bindTexture(gl.TEXTURE_2D, this.texture);
-    if (this.currentTexSize.width !== width || this.currentTexSize.height !== height) {
-      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, data);
-      this.currentTexSize = { width, height };
-    } else {
-      gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, data);
-    }
-    gl.clear(gl.COLOR_BUFFER_BIT);
-    gl.drawArrays(gl.TRIANGLES, 0, 3);
-    const pixels = new Uint8ClampedArray(outWidth * outHeight * 4);
-    gl.readPixels(0, 0, outWidth, outHeight, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
-    return {
-      data: pixels,
-      width: outWidth,
-      height: outHeight
-    };
-  }
-  /** Dispose resources */
-  dispose() {
-    if (this.gl) {
-      if (this.texture) this.gl.deleteTexture(this.texture);
-      if (this.program) this.gl.deleteProgram(this.program);
-      this.gl = null;
-    }
-    this.canvas = null;
-    this.initialized = false;
-  }
-};
-var CRT_PRESETS = {
-  default: {},
-  authentic: {
-    warpX: 0.02,
-    warpY: 0.025,
-    scanHardness: -6,
-    scanOpacity: 0.6,
-    maskOpacity: 0.4
-  },
-  subtle: {
-    warpX: 8e-3,
-    warpY: 0.01,
-    scanHardness: -3,
-    scanOpacity: 0.3,
-    maskOpacity: 0.15
-  },
-  flat: {
-    warpX: 0,
-    warpY: 0,
-    enableWarp: false,
-    scanHardness: -4,
-    scanOpacity: 0.5,
-    maskOpacity: 0.3
-  }
-};
-
-// src/hex-gpu.ts
-var VERTEX_SHADER2 = `#version 300 es
-layout(location = 0) in vec2 position;
-out vec2 vUv;
-
-void main() {
-    vUv = position * 0.5 + 0.5;
-    gl_Position = vec4(position, 0.0, 1.0);
-}`;
-var FRAGMENT_SHADER2 = `#version 300 es
-precision highp float;
-
-uniform sampler2D uTex;
-uniform vec2 uOutputRes;
-uniform vec2 uInputRes;
-uniform float uScale;
-uniform int uOrientation; // 0 = flat-top, 1 = pointy-top
-uniform int uDrawBorders;
-uniform vec4 uBorderColor;
-uniform float uBorderThickness;
-uniform vec4 uBackgroundColor;
-
-in vec2 vUv;
-out vec4 outColor;
-
-const float SQRT3 = 1.732050808;
-const float INV_SQRT3 = 0.577350269;
-
-// Convert output pixel to hex coordinate (flat-top)
-vec2 pixelToHexFlat(vec2 pos, float scale) {
-    float hSpacing = scale * 1.5;
-    float vSpacing = scale * SQRT3;
-    
-    float col = pos.x / hSpacing;
-    int colInt = int(floor(col));
-    
-    // Check if odd column (offset)
-    bool isOffset = (colInt & 1) == 1;
-    float yOffset = isOffset ? vSpacing * 0.5 : 0.0;
-    
-    float row = (pos.y - yOffset) / vSpacing;
-    int rowInt = int(floor(row));
-    
-    // Refine with corner detection
-    float cellX = pos.x - float(colInt) * hSpacing;
-    float cellY = pos.y - float(rowInt) * vSpacing - yOffset;
-    
-    float quarterW = scale * 0.5;
-    float halfH = vSpacing * 0.5;
-    
-    if (cellX < quarterW) {
-        float distFromCenter = abs(cellY - halfH);
-        float edgeX = distFromCenter * INV_SQRT3;
-        
-        if (cellX < quarterW - edgeX) {
-            if (cellY < halfH) {
-                rowInt -= 1;
-            }
-            colInt -= 1;
-        }
-    }
-    
-    return vec2(float(colInt), float(rowInt));
-}
-
-// Convert output pixel to hex coordinate (pointy-top)
-vec2 pixelToHexPointy(vec2 pos, float scale) {
-    float hSpacing = scale * SQRT3;
-    float vSpacing = scale * 1.5;
-    
-    float row = pos.y / vSpacing;
-    int rowInt = int(floor(row));
-    
-    // Check if odd row (offset)
-    bool isOffset = (rowInt & 1) == 1;
-    float xOffset = isOffset ? hSpacing * 0.5 : 0.0;
-    
-    float col = (pos.x - xOffset) / hSpacing;
-    int colInt = int(floor(col));
-    
-    // Refine with corner detection
-    float cellX = pos.x - float(colInt) * hSpacing - xOffset;
-    float cellY = pos.y - float(rowInt) * vSpacing;
-    
-    float halfW = hSpacing * 0.5;
-    float quarterH = scale * 0.5;
-    
-    if (cellY < quarterH) {
-        float distFromCenter = abs(cellX - halfW);
-        float edgeY = distFromCenter * SQRT3;
-        
-        if (cellY < edgeY) {
-            if (cellX < halfW && isOffset) {
-                colInt -= 1;
-            }
-            rowInt -= 1;
-        }
-    }
-    
-    return vec2(float(colInt), float(rowInt));
-}
-
-// Check if pixel is on hex border
-bool isBorderPixel(vec2 pos, float scale, int orientation, float thickness) {
-    for (float dy = -thickness; dy <= thickness; dy += 1.0) {
-        for (float dx = -thickness; dx <= thickness; dx += 1.0) {
-            if (dx == 0.0 && dy == 0.0) continue;
-            
-            vec2 h1 = orientation == 0 
-                ? pixelToHexFlat(pos, scale) 
-                : pixelToHexPointy(pos, scale);
-            vec2 h2 = orientation == 0 
-                ? pixelToHexFlat(pos + vec2(dx, dy), scale) 
-                : pixelToHexPointy(pos + vec2(dx, dy), scale);
-            
-            if (h1 != h2) return true;
-        }
-    }
-    return false;
-}
-
-void main() {
-    vec2 pixelPos = vUv * uOutputRes;
-    
-    // Get hex coordinate
-    vec2 hexCoord = uOrientation == 0 
-        ? pixelToHexFlat(pixelPos, uScale) 
-        : pixelToHexPointy(pixelPos, uScale);
-    
-    // Check bounds
-    if (hexCoord.x < 0.0 || hexCoord.y < 0.0 || 
-        hexCoord.x >= uInputRes.x || hexCoord.y >= uInputRes.y) {
-        outColor = uBackgroundColor;
-        return;
-    }
-    
-    // Check for border
-    if (uDrawBorders == 1 && uBorderThickness > 0.0) {
-        if (isBorderPixel(pixelPos, uScale, uOrientation, uBorderThickness)) {
-            outColor = uBorderColor;
-            return;
-        }
-    }
-    
-    // Sample source pixel (add 0.5 for pixel center)
-    vec2 texCoord = (hexCoord + 0.5) / uInputRes;
-    outColor = texture(uTex, texCoord);
-}`;
-function parseColor(color, defaultColor) {
-  if (color === void 0) return defaultColor;
-  if (typeof color === "number") {
-    return [
-      (color >> 24 & 255) / 255,
-      (color >> 16 & 255) / 255,
-      (color >> 8 & 255) / 255,
-      (color & 255) / 255
-    ];
-  }
-  if (color === "transparent") return [0, 0, 0, 0];
-  if (color.startsWith("#")) {
-    const hex = color.slice(1);
-    if (hex.length === 6) {
-      return [
-        parseInt(hex.slice(0, 2), 16) / 255,
-        parseInt(hex.slice(2, 4), 16) / 255,
-        parseInt(hex.slice(4, 6), 16) / 255,
-        1
-      ];
-    }
-    if (hex.length === 8) {
-      return [
-        parseInt(hex.slice(0, 2), 16) / 255,
-        parseInt(hex.slice(2, 4), 16) / 255,
-        parseInt(hex.slice(4, 6), 16) / 255,
-        parseInt(hex.slice(6, 8), 16) / 255
-      ];
-    }
-  }
-  return defaultColor;
-}
-function hexGetDimensions(srcWidth, srcHeight, scale, orientation = "flat-top") {
-  const SQRT3 = 1.732050808;
-  if (orientation === "flat-top") {
-    const hSpacing = scale * 1.5;
-    const vSpacing = scale * SQRT3;
-    const cellWidth = scale * 2;
-    const cellHeight = scale * SQRT3;
-    return {
-      width: Math.ceil(srcWidth * hSpacing + cellWidth),
-      height: Math.ceil(srcHeight * vSpacing + cellHeight)
-    };
-  } else {
-    const hSpacing = scale * SQRT3;
-    const vSpacing = scale * 1.5;
-    const cellWidth = scale * SQRT3;
-    const cellHeight = scale * 2;
-    return {
-      width: Math.ceil(srcWidth * hSpacing + cellWidth),
-      height: Math.ceil(srcHeight * vSpacing + cellHeight)
-    };
-  }
-}
-var HexGpuRenderer = class _HexGpuRenderer {
-  constructor() {
-    this.gl = null;
-    this.canvas = null;
-    this.program = null;
-    this.texture = null;
-    this.uniforms = {};
-    this.initialized = false;
-    this.currentCanvasSize = { width: 0, height: 0 };
-    this.currentTexSize = { width: 0, height: 0 };
-  }
-  /** Create a new HEX GPU renderer */
-  static create() {
-    const renderer = new _HexGpuRenderer();
-    renderer.init();
-    return renderer;
-  }
-  init() {
-    if (typeof OffscreenCanvas === "undefined") {
-      throw new Error("OffscreenCanvas not supported");
-    }
-    this.canvas = new OffscreenCanvas(1, 1);
-    this.gl = this.canvas.getContext("webgl2", {
-      alpha: true,
-      premultipliedAlpha: false,
-      desynchronized: true,
-      powerPreference: "high-performance",
-      antialias: false
-    });
-    if (!this.gl) {
-      throw new Error("WebGL2 not supported");
-    }
-    const gl = this.gl;
-    const vs = this.createShader(gl.VERTEX_SHADER, VERTEX_SHADER2);
-    const fs = this.createShader(gl.FRAGMENT_SHADER, FRAGMENT_SHADER2);
-    this.program = gl.createProgram();
-    gl.attachShader(this.program, vs);
-    gl.attachShader(this.program, fs);
-    gl.linkProgram(this.program);
-    if (!gl.getProgramParameter(this.program, gl.LINK_STATUS)) {
-      throw new Error("Shader program link failed: " + gl.getProgramInfoLog(this.program));
-    }
-    gl.useProgram(this.program);
-    this.uniforms = {
-      uTex: gl.getUniformLocation(this.program, "uTex"),
-      uOutputRes: gl.getUniformLocation(this.program, "uOutputRes"),
-      uInputRes: gl.getUniformLocation(this.program, "uInputRes"),
-      uScale: gl.getUniformLocation(this.program, "uScale"),
-      uOrientation: gl.getUniformLocation(this.program, "uOrientation"),
-      uDrawBorders: gl.getUniformLocation(this.program, "uDrawBorders"),
-      uBorderColor: gl.getUniformLocation(this.program, "uBorderColor"),
-      uBorderThickness: gl.getUniformLocation(this.program, "uBorderThickness"),
-      uBackgroundColor: gl.getUniformLocation(this.program, "uBackgroundColor")
-    };
-    gl.uniform1i(this.uniforms.uTex, 0);
-    const buf = gl.createBuffer();
-    gl.bindBuffer(gl.ARRAY_BUFFER, buf);
-    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, -1, 3, -1, -1, 3]), gl.STATIC_DRAW);
-    gl.enableVertexAttribArray(0);
-    gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
-    this.texture = gl.createTexture();
-    gl.bindTexture(gl.TEXTURE_2D, this.texture);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-    gl.clearColor(0, 0, 0, 0);
-    this.initialized = true;
-  }
-  createShader(type, source) {
-    const gl = this.gl;
-    const shader = gl.createShader(type);
-    gl.shaderSource(shader, source);
-    gl.compileShader(shader);
-    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-      const info = gl.getShaderInfoLog(shader);
-      gl.deleteShader(shader);
-      throw new Error("Shader compile failed: " + info);
-    }
-    return shader;
-  }
-  /** Check if renderer is ready */
-  isReady() {
-    return this.initialized;
-  }
-  /** Render hexagonal effect */
-  render(input, options = {}) {
-    if (!this.initialized || !this.gl || !this.canvas) {
-      throw new Error("Renderer not initialized");
-    }
-    const gl = this.gl;
-    const data = input instanceof ImageData ? input.data : input.data;
-    const width = input.width;
-    const height = input.height;
-    const scale = Math.min(32, Math.max(2, options.scale ?? 16));
-    const orientation = options.orientation ?? "flat-top";
-    const { width: outWidth, height: outHeight } = hexGetDimensions(width, height, scale, orientation);
-    if (this.currentCanvasSize.width !== outWidth || this.currentCanvasSize.height !== outHeight) {
-      this.canvas.width = outWidth;
-      this.canvas.height = outHeight;
-      this.currentCanvasSize = { width: outWidth, height: outHeight };
-      gl.viewport(0, 0, outWidth, outHeight);
-    }
-    gl.uniform2f(this.uniforms.uOutputRes, outWidth, outHeight);
-    gl.uniform2f(this.uniforms.uInputRes, width, height);
-    gl.uniform1f(this.uniforms.uScale, scale);
-    gl.uniform1i(this.uniforms.uOrientation, orientation === "flat-top" ? 0 : 1);
-    gl.uniform1i(this.uniforms.uDrawBorders, options.drawBorders ? 1 : 0);
-    gl.uniform1f(this.uniforms.uBorderThickness, options.borderThickness ?? 1);
-    const borderColor = parseColor(options.borderColor, [0.16, 0.16, 0.16, 1]);
-    gl.uniform4f(this.uniforms.uBorderColor, ...borderColor);
-    const bgColor = parseColor(options.backgroundColor, [0, 0, 0, 0]);
-    gl.uniform4f(this.uniforms.uBackgroundColor, ...bgColor);
-    gl.bindTexture(gl.TEXTURE_2D, this.texture);
-    if (this.currentTexSize.width !== width || this.currentTexSize.height !== height) {
-      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, data);
-      this.currentTexSize = { width, height };
-    } else {
-      gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, data);
-    }
-    gl.clear(gl.COLOR_BUFFER_BIT);
-    gl.drawArrays(gl.TRIANGLES, 0, 3);
-    const pixels = new Uint8ClampedArray(outWidth * outHeight * 4);
-    gl.readPixels(0, 0, outWidth, outHeight, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
-    return {
-      data: pixels,
-      width: outWidth,
-      height: outHeight
-    };
-  }
-  /** Dispose resources */
-  dispose() {
-    if (this.gl) {
-      if (this.texture) this.gl.deleteTexture(this.texture);
-      if (this.program) this.gl.deleteProgram(this.program);
-      this.gl = null;
-    }
-    this.canvas = null;
-    this.initialized = false;
-  }
-};
-var HEX_PRESETS = {
-  default: {},
-  bordered: {
-    drawBorders: true,
-    borderColor: "#282828",
-    borderThickness: 1
-  },
-  pointy: {
-    orientation: "pointy-top",
-    drawBorders: false
-  }
-};
-
-// src/wasm-loader.ts
-var wasm = null;
-var wasmReady = false;
-function initWasm(wasmModule) {
-  wasm = wasmModule;
-  wasmReady = true;
-}
-function isWasmLoaded() {
-  return wasmReady;
-}
-function getOutputData(result) {
-  const memory = wasm.get_memory();
-  const buffer = new Uint8Array(memory.buffer, result.ptr, result.len);
-  return new Uint8ClampedArray(buffer.slice());
-}
-function toUint8Array(input) {
-  const data = input instanceof ImageData ? input.data : input.data;
-  return data instanceof Uint8Array ? data : new Uint8Array(data);
-}
-function ensureWasm() {
-  if (!wasmReady || !wasm) {
-    throw new Error("WASM not initialized. Call initWasm() first.");
-  }
-}
-var CrtCpuRenderer = class _CrtCpuRenderer {
-  /** Create renderer (WASM must be initialized first) */
-  static create() {
-    ensureWasm();
-    return new _CrtCpuRenderer();
-  }
-  /** Check if renderer is ready */
-  isReady() {
-    return wasmReady;
-  }
-  /** Render CRT effect */
-  render(input, options = {}) {
-    ensureWasm();
-    const data = toUint8Array(input);
-    const width = input.width;
-    const height = input.height;
-    const scale = Math.min(32, Math.max(2, options.scale ?? 3));
-    const result = wasm.crt_upscale_config(
-      data,
-      width,
-      height,
-      scale,
-      options.warpX ?? 0.015,
-      options.warpY ?? 0.02,
-      options.scanHardness ?? -4,
-      options.scanOpacity ?? 0.5,
-      options.maskOpacity ?? 0.3,
-      options.enableWarp !== false,
-      options.enableScanlines !== false,
-      options.enableMask !== false
-    );
-    return {
-      data: getOutputData(result),
-      width: result.width,
-      height: result.height
-    };
-  }
-  dispose() {
-  }
-};
-function parseColorToU32(color, defaultVal) {
-  if (color === void 0) return defaultVal;
-  if (typeof color === "number") return color;
-  if (color === "transparent") return 0;
-  if (color.startsWith("#")) {
-    const hex = color.slice(1);
-    if (hex.length === 6) return parseInt(hex, 16) << 8 | 255;
-    if (hex.length === 8) return parseInt(hex, 16);
-  }
-  return defaultVal;
-}
-var HexCpuRenderer = class _HexCpuRenderer {
-  static create() {
-    ensureWasm();
-    return new _HexCpuRenderer();
-  }
-  isReady() {
-    return wasmReady;
-  }
-  render(input, options = {}) {
-    ensureWasm();
-    const data = toUint8Array(input);
-    const width = input.width;
-    const height = input.height;
-    const scale = Math.min(32, Math.max(2, options.scale ?? 16));
-    const result = wasm.hex_upscale_config(
-      data,
-      width,
-      height,
-      scale,
-      options.orientation === "pointy-top" ? 1 : 0,
-      options.drawBorders ?? false,
-      parseColorToU32(options.borderColor, 673720575),
-      options.borderThickness ?? 1,
-      parseColorToU32(options.backgroundColor, 0)
-    );
-    return {
-      data: getOutputData(result),
-      width: result.width,
-      height: result.height
-    };
-  }
-  getDimensions(srcWidth, srcHeight, scale, orientation = "flat-top") {
-    ensureWasm();
-    const dims = wasm.hex_get_dimensions(srcWidth, srcHeight, scale, orientation === "pointy-top" ? 1 : 0);
-    return { width: dims[0], height: dims[1] };
-  }
-  dispose() {
-  }
-};
-var XbrzCpuRenderer = class _XbrzCpuRenderer {
-  static create() {
-    ensureWasm();
-    return new _XbrzCpuRenderer();
-  }
-  isReady() {
-    return wasmReady;
-  }
-  render(input, options = {}) {
-    ensureWasm();
-    const data = toUint8Array(input);
-    const width = input.width;
-    const height = input.height;
-    const scale = Math.min(6, Math.max(2, options.scale ?? 2));
-    const result = wasm.xbrz_upscale_config(
-      data,
-      width,
-      height,
-      scale,
-      options.luminanceWeight ?? 1,
-      options.equalColorTolerance ?? 30,
-      options.dominantDirectionThreshold ?? 4.4,
-      options.steepDirectionThreshold ?? 2.2
-    );
-    return {
-      data: getOutputData(result),
-      width: result.width,
-      height: result.height
-    };
-  }
-  dispose() {
-  }
-};
-var XBRZ_PRESETS = {
-  default: {},
-  sharp: {
-    luminanceWeight: 1,
-    equalColorTolerance: 20,
-    dominantDirectionThreshold: 4.4,
-    steepDirectionThreshold: 2.2
-  },
-  smooth: {
-    luminanceWeight: 0.8,
-    equalColorTolerance: 35,
-    dominantDirectionThreshold: 5,
-    steepDirectionThreshold: 2.5
-  }
-};
-
-// src/renderart.ts
-function checkWebGL2() {
-  if (typeof OffscreenCanvas === "undefined") return false;
-  try {
-    const canvas = new OffscreenCanvas(1, 1);
-    return !!canvas.getContext("webgl2");
-  } catch {
-    return false;
-  }
-}
-function getMaxTextureSize() {
-  if (!checkWebGL2()) return 0;
-  try {
-    const canvas = new OffscreenCanvas(1, 1);
-    const gl = canvas.getContext("webgl2");
-    return gl?.getParameter(gl.MAX_TEXTURE_SIZE) ?? 0;
-  } catch {
-    return 0;
-  }
-}
-var CrtEngine = class {
-  constructor(gpuAvailable) {
-    this.gpuRenderer = null;
-    this.cpuRenderer = null;
-    this.gpuAvailable = gpuAvailable;
-  }
-  ensureGpu() {
-    if (!this.gpuRenderer && this.gpuAvailable) {
-      this.gpuRenderer = CrtGpuRenderer.create();
-    }
-    if (!this.gpuRenderer) throw new Error("GPU renderer not available");
-    return this.gpuRenderer;
-  }
-  ensureCpu() {
-    if (!this.cpuRenderer) {
-      this.cpuRenderer = CrtCpuRenderer.create();
-    }
-    return this.cpuRenderer;
-  }
-  /** Render with options or preset */
-  render(input, optionsOrPreset = {}) {
-    const options = typeof optionsOrPreset === "string" ? { ...CRT_PRESETS[optionsOrPreset] } : optionsOrPreset;
-    const backend = options.backend ?? "auto";
-    if (backend === "gpu" || backend === "auto" && this.gpuAvailable) {
-      return this.ensureGpu().render(input, options);
-    }
-    return this.ensureCpu().render(input, options);
-  }
-  /** Synchronous GPU-only render */
-  renderSync(input, options = {}) {
-    return this.ensureGpu().render(input, options);
-  }
-  dispose() {
-    this.gpuRenderer?.dispose();
-    this.cpuRenderer?.dispose();
-    this.gpuRenderer = null;
-    this.cpuRenderer = null;
-  }
-};
-var HexEngine = class {
-  constructor(gpuAvailable) {
-    this.gpuRenderer = null;
-    this.cpuRenderer = null;
-    this.gpuAvailable = gpuAvailable;
-  }
-  ensureGpu() {
-    if (!this.gpuRenderer && this.gpuAvailable) {
-      this.gpuRenderer = HexGpuRenderer.create();
-    }
-    if (!this.gpuRenderer) throw new Error("GPU renderer not available");
-    return this.gpuRenderer;
-  }
-  ensureCpu() {
-    if (!this.cpuRenderer) {
-      this.cpuRenderer = HexCpuRenderer.create();
-    }
-    return this.cpuRenderer;
-  }
-  render(input, optionsOrPreset = {}) {
-    const options = typeof optionsOrPreset === "string" ? { ...HEX_PRESETS[optionsOrPreset] } : optionsOrPreset;
-    const backend = options.backend ?? "auto";
-    if (backend === "gpu" || backend === "auto" && this.gpuAvailable) {
-      return this.ensureGpu().render(input, options);
-    }
-    return this.ensureCpu().render(input, options);
-  }
-  renderSync(input, options = {}) {
-    return this.ensureGpu().render(input, options);
-  }
-  getDimensions(srcWidth, srcHeight, options = {}) {
-    const scale = options.scale ?? 16;
-    const orientation = options.orientation ?? "flat-top";
-    return hexGetDimensions(srcWidth, srcHeight, scale, orientation);
-  }
-  dispose() {
-    this.gpuRenderer?.dispose();
-    this.cpuRenderer?.dispose();
-    this.gpuRenderer = null;
-    this.cpuRenderer = null;
-  }
-};
-var XbrzEngine = class {
-  constructor() {
-    this.cpuRenderer = null;
-  }
-  ensureCpu() {
-    if (!this.cpuRenderer) {
-      this.cpuRenderer = XbrzCpuRenderer.create();
-    }
-    return this.cpuRenderer;
-  }
-  render(input, optionsOrPreset = {}) {
-    const options = typeof optionsOrPreset === "string" ? { ...XBRZ_PRESETS[optionsOrPreset] } : optionsOrPreset;
-    return this.ensureCpu().render(input, options);
-  }
-  dispose() {
-    this.cpuRenderer?.dispose();
-    this.cpuRenderer = null;
-  }
-};
-var RenderArt = class _RenderArt {
-  constructor(capabilities) {
-    this.capabilities = capabilities;
-    this.crt = new CrtEngine(capabilities.gpu);
-    this.hex = new HexEngine(capabilities.gpu);
-    this.xbrz = new XbrzEngine();
-  }
-  /**
-   * Create RenderArt instance.
-   * For CPU/WASM support, call initWasm() first.
-   */
-  static create() {
-    const gpuAvailable = checkWebGL2();
-    const cpuAvailable = isWasmLoaded();
-    return new _RenderArt({
-      gpu: gpuAvailable,
-      cpu: cpuAvailable,
-      maxTextureSize: gpuAvailable ? getMaxTextureSize() : 0,
-      recommendedBackend: gpuAvailable ? "gpu" : cpuAvailable ? "cpu" : "gpu"
-    });
-  }
-  /**
-   * Create GPU-only RenderArt instance (no WASM needed).
-   */
-  static createGpuOnly() {
-    const gpuAvailable = checkWebGL2();
-    if (!gpuAvailable) {
-      throw new Error("WebGL2 not available");
-    }
-    return new _RenderArt({
-      gpu: true,
-      cpu: false,
-      maxTextureSize: getMaxTextureSize(),
-      recommendedBackend: "gpu"
-    });
-  }
-  dispose() {
-    this.crt.dispose();
-    this.hex.dispose();
-    this.xbrz.dispose();
-  }
-};
-
-exports.CRT_PRESETS = CRT_PRESETS;
-exports.CrtCpuRenderer = CrtCpuRenderer;
-exports.CrtEngine = CrtEngine;
-exports.CrtGpuRenderer = CrtGpuRenderer;
-exports.HEX_PRESETS = HEX_PRESETS;
-exports.HexCpuRenderer = HexCpuRenderer;
-exports.HexEngine = HexEngine;
-exports.HexGpuRenderer = HexGpuRenderer;
-exports.RenderArt = RenderArt;
-exports.XBRZ_PRESETS = XBRZ_PRESETS;
-exports.XbrzCpuRenderer = XbrzCpuRenderer;
-exports.XbrzEngine = XbrzEngine;
-exports.hexGetDimensions = hexGetDimensions;
-exports.initWasm = initWasm;
-exports.isWasmLoaded = isWasmLoaded;
-//# sourceMappingURL=index.js.map
+/**
+ * RenderArt - High-Performance Pixel Art Rendering
+ *
+ * A collection of GPU-accelerated (WebGL2) and WASM-powered
+ * pixel art upscaling and transformation engines.
+ *
+ * @packageDocumentation
+ */
+// CRT Renderer
+export { CrtGpuRenderer, CRT_PRESETS } from './crt-gpu';
+// Hexagonal Renderer
+export { HexGpuRenderer, HEX_PRESETS, hexGetDimensions } from './hex-gpu';
+// xBRZ Renderer
+export { XbrzGpuRenderer, XBRZ_PRESETS } from './xbrz-gpu';
+/** Convenience factory for creating renderers */
+export const createRenderer = {
+    /** Create a CRT effect renderer */
+    crt: () => {
+        const { CrtGpuRenderer } = require('./crt-gpu');
+        return CrtGpuRenderer.create();
+    },
+    /** Create a hexagonal grid renderer */
+    hex: () => {
+        const { HexGpuRenderer } = require('./hex-gpu');
+        return HexGpuRenderer.create();
+    },
+    /** Create an xBRZ upscaling renderer */
+    xbrz: () => {
+        const { XbrzGpuRenderer } = require('./xbrz-gpu');
+        return XbrzGpuRenderer.create();
+    },
+};
+/** All available presets */
+export { CRT_PRESETS as crtPresets } from './crt-gpu';
+export { HEX_PRESETS as hexPresets } from './hex-gpu';
+export { XBRZ_PRESETS as xbrzPresets } from './xbrz-gpu';
 //# sourceMappingURL=index.js.map