@pixagram/renderart 0.4.5 → 1.0.0

package/src/wasm/lib.rs

@@ -0,0 +1,285 @@
+//! RenderArt WASM Module
+//! 
+//! High-performance pixel art rendering engines for WebAssembly.
+
+use wasm_bindgen::prelude::*;
+
+mod crt;
+mod hex;
+mod xbrz;
+
+// Static output buffers to avoid deallocation issues
+static mut CRT_BUFFER: Vec<u8> = Vec::new();
+static mut HEX_BUFFER: Vec<u8> = Vec::new();
+static mut XBRZ_BUFFER: Vec<u8> = Vec::new();
+
+/// Result of an upscale operation
+#[wasm_bindgen]
+pub struct UpscaleResult {
+    pub ptr: u32,
+    pub len: u32,
+    pub width: u32,
+    pub height: u32,
+}
+
+/// Get WASM memory for reading output buffers
+#[wasm_bindgen]
+pub fn get_memory() -> JsValue {
+    wasm_bindgen::memory()
+}
+
+// ============================================================================
+// CRT Functions
+// ============================================================================
+
+/// CRT upscale with default config
+#[wasm_bindgen]
+pub fn crt_upscale(data: &[u8], width: u32, height: u32, scale: u32) -> UpscaleResult {
+    crt_upscale_config(
+        data, width, height, scale,
+        0.015, 0.02,      // warp_x, warp_y
+        -4.0, 0.5, 0.3,   // scan_hardness, scan_opacity, mask_opacity
+        true, true, true  // enable_warp, enable_scanlines, enable_mask
+    )
+}
+
+/// CRT upscale with full config
+#[wasm_bindgen]
+pub fn crt_upscale_config(
+    data: &[u8],
+    width: u32,
+    height: u32,
+    scale: u32,
+    warp_x: f32,
+    warp_y: f32,
+    scan_hardness: f32,
+    scan_opacity: f32,
+    mask_opacity: f32,
+    enable_warp: bool,
+    enable_scanlines: bool,
+    enable_mask: bool,
+) -> UpscaleResult {
+    let config = crt::CrtConfig {
+        warp_x,
+        warp_y,
+        scan_hardness,
+        scan_opacity,
+        mask_opacity,
+        enable_warp,
+        enable_scanlines,
+        enable_mask,
+    };
+    
+    let output = crt::crt_upscale(data, width as usize, height as usize, scale as usize, &config);
+    let out_width = width * scale;
+    let out_height = height * scale;
+    
+    unsafe {
+        CRT_BUFFER = output;
+        UpscaleResult {
+            ptr: CRT_BUFFER.as_ptr() as u32,
+            len: CRT_BUFFER.len() as u32,
+            width: out_width,
+            height: out_height,
+        }
+    }
+}
+
+// ============================================================================
+// HEX Functions  
+// ============================================================================
+
+/// HEX upscale with default config
+#[wasm_bindgen]
+pub fn hex_upscale(data: &[u8], width: u32, height: u32, scale: u32) -> UpscaleResult {
+    hex_upscale_config(
+        data, width, height, scale,
+        0,           // orientation (flat-top)
+        false,       // draw_borders
+        0x282828FF,  // border_color
+        1,           // border_thickness
+        0x00000000   // background_color
+    )
+}
+
+/// HEX upscale with full config
+#[wasm_bindgen]
+pub fn hex_upscale_config(
+    data: &[u8],
+    width: u32,
+    height: u32,
+    scale: u32,
+    orientation: u32,
+    draw_borders: bool,
+    border_color: u32,
+    border_thickness: u32,
+    background_color: u32,
+) -> UpscaleResult {
+    let config = hex::HexConfig {
+        orientation: if orientation == 0 {
+            hex::HexOrientation::FlatTop
+        } else {
+            hex::HexOrientation::PointyTop
+        },
+        draw_borders,
+        border_color,
+        border_thickness: border_thickness as usize,
+        background_color,
+    };
+    
+    let (out_width, out_height) = hex::get_output_dimensions(
+        width as usize,
+        height as usize,
+        scale as usize,
+        &config.orientation
+    );
+    
+    let output = hex::hex_upscale(data, width as usize, height as usize, scale as usize, &config);
+    
+    unsafe {
+        HEX_BUFFER = output;
+        UpscaleResult {
+            ptr: HEX_BUFFER.as_ptr() as u32,
+            len: HEX_BUFFER.len() as u32,
+            width: out_width as u32,
+            height: out_height as u32,
+        }
+    }
+}
+
+/// Get HEX output dimensions
+#[wasm_bindgen]
+pub fn hex_get_dimensions(width: u32, height: u32, scale: u32, orientation: u32) -> Vec<u32> {
+    let orient = if orientation == 0 {
+        hex::HexOrientation::FlatTop
+    } else {
+        hex::HexOrientation::PointyTop
+    };
+    
+    let (out_w, out_h) = hex::get_output_dimensions(
+        width as usize,
+        height as usize,
+        scale as usize,
+        &orient
+    );
+    
+    vec![out_w as u32, out_h as u32]
+}
+
+// ============================================================================
+// XBRZ Functions
+// ============================================================================
+
+/// XBRZ upscale with default config
+#[wasm_bindgen]
+pub fn xbrz_upscale(data: &[u8], width: u32, height: u32, scale: u32) -> UpscaleResult {
+    xbrz_upscale_config(
+        data, width, height, scale,
+        1.0,   // luminance_weight
+        30,    // equal_color_tolerance
+        4.4,   // dominant_direction_threshold
+        2.2    // steep_direction_threshold
+    )
+}
+
+/// XBRZ upscale with full config
+#[wasm_bindgen]
+pub fn xbrz_upscale_config(
+    data: &[u8],
+    width: u32,
+    height: u32,
+    scale: u32,
+    luminance_weight: f32,
+    equal_color_tolerance: u32,
+    dominant_direction_threshold: f32,
+    steep_direction_threshold: f32,
+) -> UpscaleResult {
+    let config = xbrz::XbrzConfig {
+        luminance_weight,
+        equal_color_tolerance,
+        dominant_direction_threshold,
+        steep_direction_threshold,
+    };
+    
+    let clamped_scale = scale.clamp(2, 6) as usize;
+    let output = xbrz::xbrz_upscale(data, width as usize, height as usize, clamped_scale, &config);
+    
+    let out_width = width * clamped_scale as u32;
+    let out_height = height * clamped_scale as u32;
+    
+    unsafe {
+        XBRZ_BUFFER = output;
+        UpscaleResult {
+            ptr: XBRZ_BUFFER.as_ptr() as u32,
+            len: XBRZ_BUFFER.len() as u32,
+            width: out_width,
+            height: out_height,
+        }
+    }
+}
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    
+    fn create_test_image(w: usize, h: usize) -> Vec<u8> {
+        let mut data = vec![0u8; w * h * 4];
+        for y in 0..h {
+            for x in 0..w {
+                let i = (y * w + x) * 4;
+                data[i] = (x * 255 / w) as u8;     // R
+                data[i + 1] = (y * 255 / h) as u8; // G
+                data[i + 2] = 128;                  // B
+                data[i + 3] = 255;                  // A
+            }
+        }
+        data
+    }
+    
+    #[test]
+    fn test_crt_basic() {
+        let img = create_test_image(4, 4);
+        let result = crt_upscale(&img, 4, 4, 2);
+        assert_eq!(result.width, 8);
+        assert_eq!(result.height, 8);
+        assert_eq!(result.len, 8 * 8 * 4);
+    }
+    
+    #[test]
+    fn test_hex_dimensions() {
+        let dims = hex_get_dimensions(4, 4, 16, 0);
+        assert!(dims[0] > 0);
+        assert!(dims[1] > 0);
+    }
+    
+    #[test]
+    fn test_hex_render() {
+        let img = create_test_image(4, 4);
+        let result = hex_upscale(&img, 4, 4, 8);
+        assert!(result.width > 0);
+        assert!(result.height > 0);
+    }
+    
+    #[test]
+    fn test_xbrz_basic() {
+        let img = create_test_image(4, 4);
+        let result = xbrz_upscale(&img, 4, 4, 2);
+        assert_eq!(result.width, 8);
+        assert_eq!(result.height, 8);
+    }
+    
+    #[test]
+    fn test_xbrz_scale_factors() {
+        let img = create_test_image(4, 4);
+        
+        for scale in 2..=6 {
+            let result = xbrz_upscale(&img, 4, 4, scale);
+            assert_eq!(result.width, 4 * scale);
+            assert_eq!(result.height, 4 * scale);
+        }
+    }
+}

package/src/wasm/xbrz.rs

@@ -0,0 +1,262 @@
+//! xBRZ Pixel Art Scaling Engine
+
+/// XBRZ configuration
+#[derive(Clone, Copy)]
+pub struct XbrzConfig {
+    pub luminance_weight: f32,
+    pub equal_color_tolerance: u32,
+    pub dominant_direction_threshold: f32,
+    pub steep_direction_threshold: f32,
+}
+
+impl Default for XbrzConfig {
+    fn default() -> Self {
+        Self {
+            luminance_weight: 1.0,
+            equal_color_tolerance: 30,
+            dominant_direction_threshold: 4.4,
+            steep_direction_threshold: 2.2,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Default)]
+struct Color {
+    r: u8,
+    g: u8,
+    b: u8,
+    a: u8,
+}
+
+impl Color {
+    #[inline(always)]
+    fn from_rgba(data: &[u8], idx: usize) -> Self {
+        Self {
+            r: data[idx],
+            g: data[idx + 1],
+            b: data[idx + 2],
+            a: data[idx + 3],
+        }
+    }
+
+    #[inline(always)]
+    fn write_to(&self, data: &mut [u8], idx: usize) {
+        data[idx] = self.r;
+        data[idx + 1] = self.g;
+        data[idx + 2] = self.b;
+        data[idx + 3] = self.a;
+    }
+
+    #[inline(always)]
+    fn luminance(&self) -> u32 {
+        (self.r as u32 * 299 + self.g as u32 * 587 + self.b as u32 * 114) / 1000
+    }
+
+    #[inline(always)]
+    fn blend(c1: Color, c2: Color, ratio: u32) -> Color {
+        let inv_ratio = 256 - ratio;
+        Color {
+            r: ((c1.r as u32 * inv_ratio + c2.r as u32 * ratio) >> 8) as u8,
+            g: ((c1.g as u32 * inv_ratio + c2.g as u32 * ratio) >> 8) as u8,
+            b: ((c1.b as u32 * inv_ratio + c2.b as u32 * ratio) >> 8) as u8,
+            a: ((c1.a as u32 * inv_ratio + c2.a as u32 * ratio) >> 8) as u8,
+        }
+    }
+}
+
+#[inline(always)]
+fn color_distance(c1: Color, c2: Color, lum_weight: f32) -> f32 {
+    let dr = (c1.r as i32 - c2.r as i32).abs() as f32;
+    let dg = (c1.g as i32 - c2.g as i32).abs() as f32;
+    let db = (c1.b as i32 - c2.b as i32).abs() as f32;
+    let da = (c1.a as i32 - c2.a as i32).abs() as f32;
+
+    let lum1 = c1.luminance() as f32;
+    let lum2 = c2.luminance() as f32;
+    let dl = (lum1 - lum2).abs();
+
+    (dr * 0.299 + dg * 0.587 + db * 0.114) * (1.0 - lum_weight) + dl * lum_weight + da * 0.5
+}
+
+#[inline(always)]
+fn colors_equal(c1: Color, c2: Color, tolerance: u32) -> bool {
+    let dr = (c1.r as i32 - c2.r as i32).abs() as u32;
+    let dg = (c1.g as i32 - c2.g as i32).abs() as u32;
+    let db = (c1.b as i32 - c2.b as i32).abs() as u32;
+    let da = (c1.a as i32 - c2.a as i32).abs() as u32;
+
+    dr + dg + db + da <= tolerance * 4
+}
+
+/// Core xBRZ rendering function
+pub fn xbrz_upscale(
+    input: &[u8],
+    src_w: usize,
+    src_h: usize,
+    scale: usize,
+    config: &XbrzConfig,
+) -> Vec<u8> {
+    let scale = scale.clamp(2, 6);
+    let out_w = src_w * scale;
+    let out_h = src_h * scale;
+    let mut output = vec![0u8; out_w * out_h * 4];
+
+    for sy in 0..src_h {
+        for sx in 0..src_w {
+            let kernel = get_kernel(input, src_w, src_h, sx as i32, sy as i32);
+            let scaled = scale_pixel(&kernel, scale, config);
+
+            for by in 0..scale {
+                for bx in 0..scale {
+                    let ox = sx * scale + bx;
+                    let oy = sy * scale + by;
+                    let out_idx = (oy * out_w + ox) * 4;
+                    scaled[by * scale + bx].write_to(&mut output, out_idx);
+                }
+            }
+        }
+    }
+
+    output
+}
+
+fn get_kernel(input: &[u8], w: usize, h: usize, x: i32, y: i32) -> [Color; 9] {
+    let mut kernel = [Color::default(); 9];
+
+    for dy in -1..=1i32 {
+        for dx in -1..=1i32 {
+            let sx = (x + dx).clamp(0, w as i32 - 1) as usize;
+            let sy = (y + dy).clamp(0, h as i32 - 1) as usize;
+            let idx = (sy * w + sx) * 4;
+            let ki = ((dy + 1) * 3 + (dx + 1)) as usize;
+            kernel[ki] = Color::from_rgba(input, idx);
+        }
+    }
+
+    kernel
+}
+
+fn scale_pixel(kernel: &[Color; 9], scale: usize, config: &XbrzConfig) -> Vec<Color> {
+    let center = kernel[4];
+    let mut result = vec![center; scale * scale];
+
+    process_corner(
+        &mut result, scale, 0, 0,
+        kernel[0], kernel[1], kernel[3], center,
+        config,
+    );
+
+    process_corner(
+        &mut result, scale, scale as i32 - 1, 0,
+        kernel[2], kernel[1], kernel[5], center,
+        config,
+    );
+
+    process_corner(
+        &mut result, scale, 0, scale as i32 - 1,
+        kernel[6], kernel[7], kernel[3], center,
+        config,
+    );
+
+    process_corner(
+        &mut result, scale, scale as i32 - 1, scale as i32 - 1,
+        kernel[8], kernel[7], kernel[5], center,
+        config,
+    );
+
+    result
+}
+
+#[allow(clippy::too_many_arguments)]
+fn process_corner(
+    result: &mut [Color],
+    scale: usize,
+    cx: i32, cy: i32,
+    corner: Color,
+    edge1: Color,
+    edge2: Color,
+    center: Color,
+    config: &XbrzConfig,
+) {
+    let lum_w = config.luminance_weight;
+    let eq_tol = config.equal_color_tolerance;
+
+    let e1_eq_c = colors_equal(edge1, center, eq_tol);
+    let e2_eq_c = colors_equal(edge2, center, eq_tol);
+    let corner_eq_e1 = colors_equal(corner, edge1, eq_tol);
+    let corner_eq_e2 = colors_equal(corner, edge2, eq_tol);
+
+    let dist_e1_e2 = color_distance(edge1, edge2, lum_w);
+    let dist_e1_c = color_distance(edge1, center, lum_w);
+    let dist_e2_c = color_distance(edge2, center, lum_w);
+
+    if !e1_eq_c && !e2_eq_c {
+        let weight = determine_blend_weight(
+            dist_e1_c, dist_e2_c, dist_e1_e2,
+            corner_eq_e1, corner_eq_e2,
+            config,
+        );
+
+        if weight > 0.0 {
+            let blend_color = if dist_e1_c < dist_e2_c { edge1 } else { edge2 };
+            let ratio = (weight * 256.0) as u32;
+
+            let idx = (cy * scale as i32 + cx) as usize;
+            result[idx] = Color::blend(center, blend_color, ratio.min(192));
+
+            if scale >= 3 {
+                blend_adjacent(result, scale, cx, cy, blend_color, weight * 0.5);
+            }
+        }
+    }
+}
+
+fn determine_blend_weight(
+    dist1: f32,
+    dist2: f32,
+    dist_between: f32,
+    _eq1: bool,
+    _eq2: bool,
+    config: &XbrzConfig,
+) -> f32 {
+    let ratio = if dist1 < 0.001 || dist2 < 0.001 {
+        0.0
+    } else if dist1 < dist2 {
+        dist2 / dist1
+    } else {
+        dist1 / dist2
+    };
+
+    if ratio > config.dominant_direction_threshold {
+        0.75
+    } else if ratio > config.steep_direction_threshold {
+        0.5
+    } else if dist_between > (dist1 + dist2) * 0.5 {
+        0.25
+    } else {
+        0.0
+    }
+}
+
+fn blend_adjacent(
+    result: &mut [Color],
+    scale: usize,
+    cx: i32, cy: i32,
+    blend: Color,
+    weight: f32,
+) {
+    let s = scale as i32;
+    let ratio = (weight * 128.0) as u32;
+
+    let hx = if cx == 0 { 1 } else { cx - 1 };
+    if hx >= 0 && hx < s {
+        let idx = (cy * s + hx) as usize;
+        result[idx] = Color::blend(result[idx], blend, ratio);
+    }
+
+    let vy = if cy == 0 { 1 } else { cy - 1 };
+    if vy >= 0 && vy < s {
+        let idx = (vy * s + cx) as usize;
+        result[idx] = Color::blend(result[idx], blend, ratio);
+    }
+}