@pixagram/renderart 0.2.0 → 0.2.1

package/dist/index.mjs

@@ -618,38 +618,85 @@ var HEX_PRESETS = {
 };
 
 // src/wasm-loader.ts
-var wasmModule = null;
+var wasm = null;
 var wasmMemory = null;
 var initPromise = null;
-async function initWasm(wasmInit, wasm) {
-  if (wasmModule) return;
+var wasmUrl = "";
+var cachedUint8Memory = null;
+var WASM_VECTOR_LEN = 0;
+function getUint8Memory() {
+  if (cachedUint8Memory === null || cachedUint8Memory.byteLength === 0) {
+    cachedUint8Memory = new Uint8Array(wasmMemory.buffer);
+  }
+  return cachedUint8Memory;
+}
+function passArray8ToWasm(arg) {
+  const ptr = wasm.__wbindgen_malloc(arg.length);
+  getUint8Memory().set(arg, ptr);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+function setWasmUrl(url) {
+  wasmUrl = url;
+}
+function getDefaultWasmUrl() {
+  if (wasmUrl) return wasmUrl;
+  const paths = [
+    "/renderart_wasm_bg.wasm",
+    "/wasm/renderart_wasm_bg.wasm",
+    "/static/wasm/renderart_wasm_bg.wasm",
+    "/assets/wasm/renderart_wasm_bg.wasm"
+  ];
+  return paths[0];
+}
+async function initWasm(customUrl) {
+  if (wasm) return;
   if (initPromise) return initPromise;
+  const url = customUrl || getDefaultWasmUrl();
   initPromise = (async () => {
     try {
-      await wasmInit();
-      wasmModule = wasm;
-      if (wasmModule.get_memory) {
-        wasmMemory = wasmModule.get_memory();
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch WASM: ${response.status} ${response.statusText}`);
+      }
+      const bytes = await response.arrayBuffer();
+      const imports = {
+        __wbindgen_placeholder__: {
+          __wbindgen_throw: (ptr, len) => {
+            const msg = new TextDecoder().decode(getUint8Memory().subarray(ptr, ptr + len));
+            throw new Error(msg);
+          }
+        },
+        wbg: {
+          __wbindgen_throw: (ptr, len) => {
+            const msg = new TextDecoder().decode(getUint8Memory().subarray(ptr, ptr + len));
+            throw new Error(msg);
+          }
+        }
+      };
+      const { instance } = await WebAssembly.instantiate(bytes, imports);
+      wasm = instance.exports;
+      wasmMemory = wasm.memory;
+      if (wasm.__wbindgen_start) {
+        wasm.__wbindgen_start();
       }
     } catch (e) {
       initPromise = null;
-      throw new Error(`Failed to initialize WASM module: ${e}`);
+      throw new Error(`Failed to initialize WASM: ${e}. Make sure the .wasm file is served at: ${url}`);
     }
   })();
   return initPromise;
 }
 function isWasmLoaded() {
-  return wasmModule !== null;
+  return wasm !== null;
 }
-function getWasmModule() {
-  if (!wasmModule) {
-    throw new Error("WASM not initialized. Call initWasm() first.");
+async function ensureWasm() {
+  if (!wasm) {
+    await initWasm();
   }
-  return wasmModule;
 }
-function getOutputData(result) {
-  if (!wasmMemory) throw new Error("WASM memory not available");
-  const buffer = new Uint8Array(wasmMemory.buffer, result.ptr, result.len);
+function getOutputData(ptr, len) {
+  const buffer = getUint8Memory().subarray(ptr, ptr + len);
   return new Uint8ClampedArray(buffer.slice());
 }
 function toUint8Array(input) {
@@ -675,45 +722,49 @@ var CrtCpuRenderer = class _CrtCpuRenderer {
   constructor() {
     this.ready = false;
   }
-  /** Create renderer (WASM must be initialized first via initWasm) */
-  static create() {
-    if (!isWasmLoaded()) {
-      throw new Error("WASM not initialized. Call initWasm() first.");
-    }
+  /** Create and initialize renderer (auto-loads WASM) */
+  static async create() {
+    await ensureWasm();
     const renderer = new _CrtCpuRenderer();
     renderer.ready = true;
     return renderer;
   }
-  /** Check if renderer is ready */
   isReady() {
     return this.ready && isWasmLoaded();
   }
-  /** Render CRT effect */
   render(input, options = {}) {
-    if (!this.ready || !wasmModule) {
+    if (!this.ready || !wasm) {
       throw new Error("Renderer not initialized");
     }
     const data = toUint8Array(input);
     const width = input.width;
     const height = input.height;
     const scale = Math.min(32, Math.max(2, options.scale ?? 3));
-    const config = new wasmModule.CrtConfig();
-    config.warp_x = options.warpX ?? 0.015;
-    config.warp_y = options.warpY ?? 0.02;
-    config.scan_hardness = options.scanHardness ?? -4;
-    config.scan_opacity = options.scanOpacity ?? 0.5;
-    config.mask_opacity = options.maskOpacity ?? 0.3;
-    config.enable_warp = options.enableWarp !== false;
-    config.enable_scanlines = options.enableScanlines !== false;
-    config.enable_mask = options.enableMask !== false;
-    const result = wasmModule.crt_upscale_config(data, width, height, scale, config);
+    const ptr = passArray8ToWasm(data);
+    const resultPtr = wasm.crt_upscale_raw(
+      ptr,
+      WASM_VECTOR_LEN,
+      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 ? 1 : 0,
+      options.enableScanlines !== false ? 1 : 0,
+      options.enableMask !== false ? 1 : 0
+    );
+    const outWidth = width * scale;
+    const outHeight = height * scale;
+    const outLen = outWidth * outHeight * 4;
     return {
-      data: getOutputData(result),
-      width: result.width,
-      height: result.height
+      data: getOutputData(resultPtr, outLen),
+      width: outWidth,
+      height: outHeight
     };
   }
-  /** Dispose resources */
   dispose() {
     this.ready = false;
   }
@@ -722,50 +773,68 @@ var HexCpuRenderer = class _HexCpuRenderer {
   constructor() {
     this.ready = false;
   }
-  /** Create renderer (WASM must be initialized first via initWasm) */
-  static create() {
-    if (!isWasmLoaded()) {
-      throw new Error("WASM not initialized. Call initWasm() first.");
-    }
+  static async create() {
+    await ensureWasm();
     const renderer = new _HexCpuRenderer();
     renderer.ready = true;
     return renderer;
   }
-  /** Check if renderer is ready */
   isReady() {
     return this.ready && isWasmLoaded();
   }
-  /** Render hexagonal effect */
   render(input, options = {}) {
-    if (!this.ready || !wasmModule) {
+    if (!this.ready || !wasm) {
       throw new Error("Renderer not initialized");
     }
     const data = toUint8Array(input);
     const width = input.width;
     const height = input.height;
     const scale = Math.min(32, Math.max(2, options.scale ?? 16));
-    const config = new wasmModule.HexConfig();
-    config.orientation = options.orientation === "pointy-top" ? 1 : 0;
-    config.draw_borders = options.drawBorders ?? false;
-    config.border_color = parseColorToU32(options.borderColor, 673720575);
-    config.border_thickness = options.borderThickness ?? 1;
-    config.background_color = parseColorToU32(options.backgroundColor, 0);
-    const result = wasmModule.hex_upscale_config(data, width, height, scale, config);
+    const orientation = options.orientation === "pointy-top" ? 1 : 0;
+    const ptr = passArray8ToWasm(data);
+    const resultPtr = wasm.hex_upscale_raw(
+      ptr,
+      WASM_VECTOR_LEN,
+      width,
+      height,
+      scale,
+      orientation,
+      options.drawBorders ? 1 : 0,
+      parseColorToU32(options.borderColor, 673720575),
+      options.borderThickness ?? 1,
+      parseColorToU32(options.backgroundColor, 0)
+    );
+    const dims = this.getDimensions(width, height, scale, options.orientation);
+    const outLen = dims.width * dims.height * 4;
     return {
-      data: getOutputData(result),
-      width: result.width,
-      height: result.height
+      data: getOutputData(resultPtr, outLen),
+      width: dims.width,
+      height: dims.height
     };
   }
-  /** Get output dimensions */
   getDimensions(srcWidth, srcHeight, scale, orientation = "flat-top") {
-    if (!this.ready || !wasmModule) {
-      throw new Error("Renderer not initialized");
+    const SQRT3 = 1.732050808;
+    scale = Math.min(32, Math.max(2, scale));
+    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)
+      };
     }
-    const dims = wasmModule.hex_get_dimensions(srcWidth, srcHeight, scale, orientation === "pointy-top" ? 1 : 0);
-    return { width: dims[0], height: dims[1] };
   }
-  /** Dispose resources */
   dispose() {
     this.ready = false;
   }
@@ -774,41 +843,44 @@ var XbrzCpuRenderer = class _XbrzCpuRenderer {
   constructor() {
     this.ready = false;
   }
-  /** Create renderer (WASM must be initialized first via initWasm) */
-  static create() {
-    if (!isWasmLoaded()) {
-      throw new Error("WASM not initialized. Call initWasm() first.");
-    }
+  static async create() {
+    await ensureWasm();
     const renderer = new _XbrzCpuRenderer();
     renderer.ready = true;
     return renderer;
   }
-  /** Check if renderer is ready */
   isReady() {
     return this.ready && isWasmLoaded();
   }
-  /** Render xBRZ scaling */
   render(input, options = {}) {
-    if (!this.ready || !wasmModule) {
+    if (!this.ready || !wasm) {
       throw new Error("Renderer not initialized");
     }
     const data = toUint8Array(input);
     const width = input.width;
     const height = input.height;
     const scale = Math.min(6, Math.max(2, options.scale ?? 2));
-    const config = new wasmModule.XbrzConfig();
-    config.luminance_weight = options.luminanceWeight ?? 1;
-    config.equal_color_tolerance = options.equalColorTolerance ?? 30;
-    config.dominant_direction_threshold = options.dominantDirectionThreshold ?? 4.4;
-    config.steep_direction_threshold = options.steepDirectionThreshold ?? 2.2;
-    const result = wasmModule.xbrz_upscale_config(data, width, height, scale, config);
+    const ptr = passArray8ToWasm(data);
+    const resultPtr = wasm.xbrz_upscale_raw(
+      ptr,
+      WASM_VECTOR_LEN,
+      width,
+      height,
+      scale,
+      options.luminanceWeight ?? 1,
+      options.equalColorTolerance ?? 30,
+      options.dominantDirectionThreshold ?? 4.4,
+      options.steepDirectionThreshold ?? 2.2
+    );
+    const outWidth = width * scale;
+    const outHeight = height * scale;
+    const outLen = outWidth * outHeight * 4;
     return {
-      data: getOutputData(result),
-      width: result.width,
-      height: result.height
+      data: getOutputData(resultPtr, outLen),
+      width: outWidth,
+      height: outHeight
     };
   }
-  /** Dispose resources */
   dispose() {
     this.ready = false;
   }
@@ -850,13 +922,11 @@ function getMaxTextureSize() {
   }
 }
 var CrtEngine = class {
-  constructor(gpuAvailable, cpuAvailable) {
+  constructor(gpuAvailable) {
     this.gpuRenderer = null;
     this.cpuRenderer = null;
     this.gpuAvailable = gpuAvailable;
-    this.cpuAvailable = cpuAvailable;
   }
-  /** Initialize GPU renderer */
   ensureGpu() {
     if (!this.gpuRenderer && this.gpuAvailable) {
       this.gpuRenderer = CrtGpuRenderer.create();
@@ -864,15 +934,13 @@ var CrtEngine = class {
     if (!this.gpuRenderer) throw new Error("GPU renderer not available");
     return this.gpuRenderer;
   }
-  /** Initialize CPU renderer */
-  ensureCpu() {
-    if (!this.cpuRenderer && this.cpuAvailable && isWasmLoaded()) {
-      this.cpuRenderer = CrtCpuRenderer.create();
+  async ensureCpu() {
+    if (!this.cpuRenderer) {
+      this.cpuRenderer = await CrtCpuRenderer.create();
     }
-    if (!this.cpuRenderer) throw new Error("CPU renderer not available. Initialize WASM first.");
     return this.cpuRenderer;
   }
-  render(input, optionsOrPreset, overrides) {
+  async render(input, optionsOrPreset, overrides) {
     let options = {};
     if (typeof optionsOrPreset === "string") {
       options = { ...CRT_PRESETS[optionsOrPreset], ...overrides };
@@ -887,13 +955,13 @@ var CrtEngine = class {
         if (backend === "gpu") throw e;
       }
     }
-    return this.ensureCpu().render(input, options);
+    const cpu = await this.ensureCpu();
+    return cpu.render(input, options);
   }
   /** Render synchronously (GPU only) */
   renderSync(input, options) {
     return this.ensureGpu().render(input, options ?? {});
   }
-  /** Dispose resources */
   dispose() {
     this.gpuRenderer?.dispose();
     this.cpuRenderer?.dispose();
@@ -902,11 +970,10 @@ var CrtEngine = class {
   }
 };
 var HexEngine = class {
-  constructor(gpuAvailable, cpuAvailable) {
+  constructor(gpuAvailable) {
     this.gpuRenderer = null;
     this.cpuRenderer = null;
     this.gpuAvailable = gpuAvailable;
-    this.cpuAvailable = cpuAvailable;
   }
   ensureGpu() {
     if (!this.gpuRenderer && this.gpuAvailable) {
@@ -915,14 +982,13 @@ var HexEngine = class {
     if (!this.gpuRenderer) throw new Error("GPU renderer not available");
     return this.gpuRenderer;
   }
-  ensureCpu() {
-    if (!this.cpuRenderer && this.cpuAvailable && isWasmLoaded()) {
-      this.cpuRenderer = HexCpuRenderer.create();
+  async ensureCpu() {
+    if (!this.cpuRenderer) {
+      this.cpuRenderer = await HexCpuRenderer.create();
     }
-    if (!this.cpuRenderer) throw new Error("CPU renderer not available. Initialize WASM first.");
     return this.cpuRenderer;
   }
-  render(input, optionsOrPreset, overrides) {
+  async render(input, optionsOrPreset, overrides) {
     let options = {};
     if (typeof optionsOrPreset === "string") {
       options = { ...HEX_PRESETS[optionsOrPreset], ...overrides };
@@ -937,13 +1003,12 @@ var HexEngine = class {
         if (backend === "gpu") throw e;
       }
     }
-    return this.ensureCpu().render(input, options);
+    const cpu = await this.ensureCpu();
+    return cpu.render(input, options);
   }
-  /** Render synchronously (GPU only) */
   renderSync(input, options) {
     return this.ensureGpu().render(input, options ?? {});
   }
-  /** Get output dimensions */
   getDimensions(srcWidth, srcHeight, options) {
     const scale = options?.scale ?? 16;
     const orientation = options?.orientation ?? "flat-top";
@@ -957,27 +1022,25 @@ var HexEngine = class {
   }
 };
 var XbrzEngine = class {
-  constructor(cpuAvailable) {
+  constructor() {
     this.cpuRenderer = null;
-    this.cpuAvailable = cpuAvailable;
   }
-  ensureCpu() {
-    if (!this.cpuRenderer && this.cpuAvailable && isWasmLoaded()) {
-      this.cpuRenderer = XbrzCpuRenderer.create();
+  async ensureCpu() {
+    if (!this.cpuRenderer) {
+      this.cpuRenderer = await XbrzCpuRenderer.create();
     }
-    if (!this.cpuRenderer) throw new Error("CPU renderer not available. Initialize WASM first.");
     return this.cpuRenderer;
   }
-  render(input, optionsOrPreset, overrides) {
+  async render(input, optionsOrPreset, overrides) {
     let options = {};
     if (typeof optionsOrPreset === "string") {
       options = { ...XBRZ_PRESETS[optionsOrPreset], ...overrides };
     } else if (optionsOrPreset) {
       options = optionsOrPreset;
     }
-    return this.ensureCpu().render(input, options);
+    const cpu = await this.ensureCpu();
+    return cpu.render(input, options);
   }
-  /** Get output dimensions */
   getDimensions(srcWidth, srcHeight, scale = 2) {
     const s = Math.min(6, Math.max(2, scale));
     return { width: srcWidth * s, height: srcHeight * s };
@@ -988,47 +1051,38 @@ var XbrzEngine = class {
   }
 };
 var RenderArt = class _RenderArt {
-  constructor(gpuAvailable, cpuAvailable) {
-    this.crt = new CrtEngine(gpuAvailable, cpuAvailable);
-    this.hex = new HexEngine(gpuAvailable, cpuAvailable);
-    this.xbrz = new XbrzEngine(cpuAvailable);
+  constructor(gpuAvailable) {
+    this.crt = new CrtEngine(gpuAvailable);
+    this.hex = new HexEngine(gpuAvailable);
+    this.xbrz = new XbrzEngine();
     const maxTextureSize = gpuAvailable ? getMaxTextureSize() : 0;
     this._capabilities = {
       gpu: gpuAvailable,
-      cpu: cpuAvailable,
+      cpu: true,
+      // Always potentially available via async init
       maxTextureSize,
-      recommendedBackend: gpuAvailable ? "gpu" : cpuAvailable ? "cpu" : "auto"
+      recommendedBackend: gpuAvailable ? "gpu" : "cpu"
     };
   }
-  /** 
-   * Create RenderArt instance
-   * GPU renderers always available if WebGL2 supported.
-   * CPU renderers require WASM to be initialized via initWasm() first.
-   */
+  /** Create RenderArt instance */
   static create() {
     const gpuAvailable = checkWebGL2();
-    const cpuAvailable = isWasmLoaded();
-    if (!gpuAvailable && !cpuAvailable) {
-      throw new Error("No rendering backend available. WebGL2 not supported and WASM not initialized.");
-    }
-    return new _RenderArt(gpuAvailable, cpuAvailable);
+    return new _RenderArt(gpuAvailable);
   }
-  /**
-   * Create GPU-only RenderArt instance (no WASM required)
-   * CPU fallback will not be available.
-   */
+  /** Create GPU-only instance */
   static createGpuOnly() {
-    const gpuAvailable = checkWebGL2();
-    if (!gpuAvailable) {
+    if (!checkWebGL2()) {
       throw new Error("WebGL2 not supported");
     }
-    return new _RenderArt(true, false);
+    return new _RenderArt(true);
+  }
+  /** Pre-initialize WASM for faster first CPU render */
+  async preloadWasm(wasmUrl2) {
+    await initWasm(wasmUrl2);
   }
-  /** Get renderer capabilities */
   get capabilities() {
     return { ...this._capabilities };
   }
-  /** Dispose all resources */
   dispose() {
     this.crt.dispose();
     this.hex.dispose();
@@ -1036,6 +1090,6 @@ var RenderArt = class _RenderArt {
   }
 };
 
-export { CRT_PRESETS, CrtCpuRenderer, CrtEngine, CrtGpuRenderer, HEX_PRESETS, HexCpuRenderer, HexEngine, HexGpuRenderer, RenderArt, XBRZ_PRESETS, XbrzCpuRenderer, XbrzEngine, getWasmModule, hexGetDimensions, initWasm, isWasmLoaded };
+export { CRT_PRESETS, CrtCpuRenderer, CrtEngine, CrtGpuRenderer, HEX_PRESETS, HexCpuRenderer, HexEngine, HexGpuRenderer, RenderArt, XBRZ_PRESETS, XbrzCpuRenderer, XbrzEngine, hexGetDimensions, initWasm, isWasmLoaded, setWasmUrl };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map