@pixagram/renderart 0.4.5 → 1.0.0

package/src/wasm/crt.rs

@@ -0,0 +1,181 @@
+//! CRT Effect Rendering Engine
+//!
+//! Simulates CRT display characteristics.
+
+/// CRT configuration
+#[derive(Clone, Copy)]
+pub struct CrtConfig {
+    pub warp_x: f32,
+    pub warp_y: f32,
+    pub scan_hardness: f32,
+    pub scan_opacity: f32,
+    pub mask_opacity: f32,
+    pub enable_warp: bool,
+    pub enable_scanlines: bool,
+    pub enable_mask: bool,
+}
+
+impl Default for CrtConfig {
+    fn default() -> Self {
+        Self {
+            warp_x: 0.015,
+            warp_y: 0.02,
+            scan_hardness: -4.0,
+            scan_opacity: 0.5,
+            mask_opacity: 0.3,
+            enable_warp: true,
+            enable_scanlines: true,
+            enable_mask: true,
+        }
+    }
+}
+
+/// Core CRT rendering function
+pub fn crt_upscale(
+    input: &[u8],
+    src_w: usize,
+    src_h: usize,
+    scale: usize,
+    config: &CrtConfig,
+) -> Vec<u8> {
+    let scale = scale.clamp(2, 32);
+    let out_w = src_w * scale;
+    let out_h = src_h * scale;
+    let mut output = vec![0u8; out_w * out_h * 4];
+
+    // Pre-calculate scanline LUT
+    let scan_lut: Vec<f32> = (0..=100)
+        .map(|i| {
+            if !config.enable_scanlines {
+                return 1.0;
+            }
+            let v = i as f32 / 100.0;
+            let d = (v - 0.5).abs();
+            let line = (d * d * config.scan_hardness).exp();
+            1.0 * (1.0 - config.scan_opacity) + line * config.scan_opacity
+        })
+        .collect();
+
+    // Pre-calculate mask LUT
+    let mask_lut: [[f32; 3]; 6] = if config.enable_mask {
+        [
+            [1.0, 0.0, 0.0],
+            [1.0, 0.0, 0.0],
+            [0.0, 1.0, 0.0],
+            [0.0, 1.0, 0.0],
+            [0.0, 0.0, 1.0],
+            [0.0, 0.0, 1.0],
+        ]
+        .map(|c| {
+            [
+                1.0 * (1.0 - config.mask_opacity) + c[0] * config.mask_opacity,
+                1.0 * (1.0 - config.mask_opacity) + c[1] * config.mask_opacity,
+                1.0 * (1.0 - config.mask_opacity) + c[2] * config.mask_opacity,
+            ]
+        })
+    } else {
+        [[1.0, 1.0, 1.0]; 6]
+    };
+
+    let src_w_f = src_w as f32;
+    let src_h_f = src_h as f32;
+    let out_w_f = out_w as f32;
+    let out_h_f = out_h as f32;
+
+    for y in 0..out_h {
+        let v_norm = y as f32 / out_h_f;
+
+        let dc_y = (v_norm - 0.5).abs();
+        let dc2_y = dc_y * dc_y;
+        let warp_x_factor = if config.enable_warp {
+            1.0 + (dc2_y * (0.3 * config.warp_x))
+        } else {
+            1.0
+        };
+
+        let src_y_pos = v_norm * src_h_f;
+        let scan_idx = ((src_y_pos.fract()) * 100.0) as usize;
+        let scan_val = scan_lut[scan_idx.min(100)];
+
+        for x in 0..out_w {
+            let u_norm = x as f32 / out_w_f;
+
+            let (warped_u, warped_v) = if config.enable_warp {
+                let dc_x = (u_norm - 0.5).abs();
+                let dc2_x = dc_x * dc_x;
+
+                let mut wu = u_norm - 0.5;
+                wu *= warp_x_factor;
+                wu += 0.5;
+
+                let mut wv = v_norm - 0.5;
+                wv *= 1.0 + (dc2_x * (0.4 * config.warp_y));
+                wv += 0.5;
+
+                (wu, wv)
+            } else {
+                (u_norm, v_norm)
+            };
+
+            if warped_u < 0.0 || warped_u >= 1.0 || warped_v < 0.0 || warped_v >= 1.0 {
+                continue;
+            }
+
+            let src_x = warped_u * src_w_f;
+            let src_y = warped_v * src_h_f;
+
+            let x0 = src_x.floor() as usize;
+            let y0 = src_y.floor() as usize;
+            let x1 = (x0 + 1).min(src_w - 1);
+            let y1 = (y0 + 1).min(src_h - 1);
+
+            let wx = src_x - x0 as f32;
+            let wy = src_y - y0 as f32;
+            let iwx = 1.0 - wx;
+            let iwy = 1.0 - wy;
+
+            let idx00 = (y0 * src_w + x0) * 4;
+            let idx10 = (y0 * src_w + x1) * 4;
+            let idx01 = (y1 * src_w + x0) * 4;
+            let idx11 = (y1 * src_w + x1) * 4;
+
+            let mut r = (input[idx00] as f32 * iwx + input[idx10] as f32 * wx) * iwy
+                + (input[idx01] as f32 * iwx + input[idx11] as f32 * wx) * wy;
+            let mut g = (input[idx00 + 1] as f32 * iwx + input[idx10 + 1] as f32 * wx) * iwy
+                + (input[idx01 + 1] as f32 * iwx + input[idx11 + 1] as f32 * wx) * wy;
+            let mut b = (input[idx00 + 2] as f32 * iwx + input[idx10 + 2] as f32 * wx) * iwy
+                + (input[idx01 + 2] as f32 * iwx + input[idx11 + 2] as f32 * wx) * wy;
+            let a = (input[idx00 + 3] as f32 * iwx + input[idx10 + 3] as f32 * wx) * iwy
+                + (input[idx01 + 3] as f32 * iwx + input[idx11 + 3] as f32 * wx) * wy;
+
+            if a < 1.0 {
+                continue;
+            }
+
+            r = (r / 255.0).powi(2);
+            g = (g / 255.0).powi(2);
+            b = (b / 255.0).powi(2);
+
+            let luma = r * 0.299 + g * 0.587 + b * 0.114;
+            let bloom = luma * 0.7;
+
+            let mask_val = mask_lut[x % 6];
+
+            r *= scan_val;
+            g *= scan_val;
+            b *= scan_val;
+
+            r *= mask_val[0] * (1.0 - bloom) + bloom;
+            g *= mask_val[1] * (1.0 - bloom) + bloom;
+            b *= mask_val[2] * (1.0 - bloom) + bloom;
+
+            let out_idx = (y * out_w + x) * 4;
+            output[out_idx] = (r.sqrt() * 255.0).min(255.0) as u8;
+            output[out_idx + 1] = (g.sqrt() * 255.0).min(255.0) as u8;
+            output[out_idx + 2] = (b.sqrt() * 255.0).min(255.0) as u8;
+            output[out_idx + 3] = a as u8;
+        }
+    }
+
+    output
+}

package/src/wasm/hex.rs

@@ -0,0 +1,324 @@
+//! Hexagonal Pixel Art Upscaling Engine
+
+/// Hexagon orientation
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum HexOrientation {
+    FlatTop = 0,
+    PointyTop = 1,
+}
+
+/// Offset coordinate system
+#[derive(Clone, Copy)]
+enum OffsetType {
+    Odd,
+}
+
+/// HEX configuration
+#[derive(Clone)]
+pub struct HexConfig {
+    pub orientation: HexOrientation,
+    pub draw_borders: bool,
+    pub border_color: u32,
+    pub border_thickness: usize,
+    pub background_color: u32,
+}
+
+impl Default for HexConfig {
+    fn default() -> Self {
+        Self {
+            orientation: HexOrientation::FlatTop,
+            draw_borders: false,
+            border_color: 0x282828FF,
+            border_thickness: 1,
+            background_color: 0x00000000,
+        }
+    }
+}
+
+// Fixed-point arithmetic
+#[derive(Clone, Copy, Default)]
+struct Fixed32(i32);
+
+impl Fixed32 {
+    const FRAC_BITS: i32 = 16;
+    const SCALE: i64 = 1 << 16;
+
+    #[inline(always)]
+    fn from_int(v: i32) -> Self {
+        Self(v << Self::FRAC_BITS)
+    }
+
+    #[inline(always)]
+    fn from_ratio(num: i32, denom: i32) -> Self {
+        Self((((num as i64) << Self::FRAC_BITS) / denom as i64) as i32)
+    }
+
+    #[inline(always)]
+    fn floor(self) -> i32 {
+        self.0 >> Self::FRAC_BITS
+    }
+
+    #[inline(always)]
+    fn abs(self) -> Self {
+        Self(self.0.abs())
+    }
+}
+
+/// Precomputed hexagon geometry
+struct HexGeometry {
+    orientation: HexOrientation,
+    offset_type: OffsetType,
+    h_spacing: Fixed32,
+    v_spacing: Fixed32,
+    cell_width: Fixed32,
+    cell_height: Fixed32,
+    row_offset: Fixed32,
+    col_offset: Fixed32,
+    edge_slope: Fixed32,
+    quarter_w: Fixed32,
+    half_h: Fixed32,
+}
+
+impl HexGeometry {
+    fn new(scale: u32, orientation: HexOrientation, offset_type: OffsetType) -> Self {
+        let scale = scale.max(2) as i32;
+
+        match orientation {
+            HexOrientation::FlatTop => {
+                let cell_width = Fixed32::from_int(scale * 2);
+                let cell_height = Fixed32::from_ratio(scale * 1732, 1000);
+                let h_spacing = Fixed32::from_ratio(scale * 3, 2);
+                let v_spacing = cell_height;
+                let row_offset = Fixed32(cell_height.0 / 2);
+
+                Self {
+                    orientation,
+                    offset_type,
+                    cell_width,
+                    cell_height,
+                    h_spacing,
+                    v_spacing,
+                    row_offset,
+                    col_offset: Fixed32::from_int(0),
+                    edge_slope: Fixed32::from_ratio(1732, 1000),
+                    quarter_w: Fixed32::from_ratio(scale, 2),
+                    half_h: Fixed32(cell_height.0 / 2),
+                }
+            }
+            HexOrientation::PointyTop => {
+                let cell_width = Fixed32::from_ratio(scale * 1732, 1000);
+                let cell_height = Fixed32::from_int(scale * 2);
+                let h_spacing = cell_width;
+                let v_spacing = Fixed32::from_ratio(scale * 3, 2);
+                let col_offset = Fixed32(cell_width.0 / 2);
+
+                Self {
+                    orientation,
+                    offset_type,
+                    cell_width,
+                    cell_height,
+                    h_spacing,
+                    v_spacing,
+                    row_offset: Fixed32::from_int(0),
+                    col_offset,
+                    edge_slope: Fixed32::from_ratio(1000, 1732),
+                    quarter_w: Fixed32(cell_width.0 / 4),
+                    half_h: Fixed32::from_ratio(scale, 2),
+                }
+            }
+        }
+    }
+
+    fn output_dimensions(&self, input_width: u32, input_height: u32) -> (u32, u32) {
+        let w = input_width as i64;
+        let h = input_height as i64;
+
+        let out_w = ((w * self.h_spacing.0 as i64) >> Fixed32::FRAC_BITS) + self.cell_width.floor() as i64;
+        let out_h = ((h * self.v_spacing.0 as i64) >> Fixed32::FRAC_BITS) + self.cell_height.floor() as i64;
+
+        (out_w.max(1) as u32, out_h.max(1) as u32)
+    }
+
+    #[inline(always)]
+    fn output_to_hex(&self, out_x: i32, out_y: i32) -> (i32, i32) {
+        match self.orientation {
+            HexOrientation::FlatTop => self.output_to_hex_flat(out_x, out_y),
+            HexOrientation::PointyTop => self.output_to_hex_pointy(out_x, out_y),
+        }
+    }
+
+    #[inline(always)]
+    fn output_to_hex_flat(&self, out_x: i32, out_y: i32) -> (i32, i32) {
+        let x = Fixed32::from_int(out_x);
+        let y = Fixed32::from_int(out_y);
+
+        let col = ((x.0 as i64 * Fixed32::SCALE) / self.h_spacing.0 as i64) as i32 >> Fixed32::FRAC_BITS;
+
+        let is_offset = match self.offset_type {
+            OffsetType::Odd => col & 1 == 1,
+        };
+
+        let y_adj = if is_offset {
+            Fixed32(y.0 - self.row_offset.0)
+        } else {
+            y
+        };
+
+        let mut row = ((y_adj.0 as i64 * Fixed32::SCALE) / self.v_spacing.0 as i64) as i32 >> Fixed32::FRAC_BITS;
+
+        let cell_x = Fixed32(x.0 - ((col as i64 * self.h_spacing.0 as i64) >> Fixed32::FRAC_BITS) as i32);
+        let cell_y = if is_offset {
+            Fixed32(y.0 - ((row as i64 * self.v_spacing.0 as i64) >> Fixed32::FRAC_BITS) as i32 - self.row_offset.0)
+        } else {
+            Fixed32(y.0 - ((row as i64 * self.v_spacing.0 as i64) >> Fixed32::FRAC_BITS) as i32)
+        };
+
+        if cell_x.0 < self.quarter_w.0 {
+            let half_h = self.half_h;
+            let dist_from_center = Fixed32(cell_y.0 - half_h.0).abs();
+            let edge_x = Fixed32(((dist_from_center.0 as i64 * Fixed32::SCALE) / self.edge_slope.0 as i64) as i32);
+
+            if cell_x.0 < self.quarter_w.0 - edge_x.0 {
+                if cell_y.0 < half_h.0 {
+                    row -= 1;
+                }
+                return (col - 1, row);
+            }
+        }
+
+        (col, row)
+    }
+
+    #[inline(always)]
+    fn output_to_hex_pointy(&self, out_x: i32, out_y: i32) -> (i32, i32) {
+        let x = Fixed32::from_int(out_x);
+        let y = Fixed32::from_int(out_y);
+
+        let row = ((y.0 as i64 * Fixed32::SCALE) / self.v_spacing.0 as i64) as i32 >> Fixed32::FRAC_BITS;
+
+        let is_offset = match self.offset_type {
+            OffsetType::Odd => row & 1 == 1,
+        };
+
+        let x_adj = if is_offset {
+            Fixed32(x.0 - self.col_offset.0)
+        } else {
+            x
+        };
+
+        let mut col = ((x_adj.0 as i64 * Fixed32::SCALE) / self.h_spacing.0 as i64) as i32 >> Fixed32::FRAC_BITS;
+
+        let cell_x = if is_offset {
+            Fixed32(x.0 - ((col as i64 * self.h_spacing.0 as i64) >> Fixed32::FRAC_BITS) as i32 - self.col_offset.0)
+        } else {
+            Fixed32(x.0 - ((col as i64 * self.h_spacing.0 as i64) >> Fixed32::FRAC_BITS) as i32)
+        };
+        let cell_y = Fixed32(y.0 - ((row as i64 * self.v_spacing.0 as i64) >> Fixed32::FRAC_BITS) as i32);
+
+        if cell_y.0 < self.half_h.0 {
+            let half_w = Fixed32(self.cell_width.0 / 2);
+            let dist_from_center = Fixed32(cell_x.0 - half_w.0).abs();
+            let edge_y = Fixed32(((dist_from_center.0 as i64 * self.edge_slope.0 as i64) / Fixed32::SCALE) as i32);
+
+            if cell_y.0 < edge_y.0 {
+                if cell_x.0 < half_w.0 && is_offset {
+                    col -= 1;
+                }
+                return (col, row - 1);
+            }
+        }
+
+        (col, row)
+    }
+}
+
+/// Get output dimensions for hexagonal rendering
+pub fn get_output_dimensions(
+    src_w: usize,
+    src_h: usize,
+    scale: usize,
+    orientation: &HexOrientation,
+) -> (usize, usize) {
+    let scale = scale.clamp(2, 32) as u32;
+    let geometry = HexGeometry::new(scale, *orientation, OffsetType::Odd);
+    let (out_w, out_h) = geometry.output_dimensions(src_w as u32, src_h as u32);
+    (out_w as usize, out_h as usize)
+}
+
+/// Core hexagonal rendering function
+pub fn hex_upscale(
+    input: &[u8],
+    src_w: usize,
+    src_h: usize,
+    scale: usize,
+    config: &HexConfig,
+) -> Vec<u8> {
+    let scale = scale.clamp(2, 32) as u32;
+    let geometry = HexGeometry::new(scale, config.orientation, OffsetType::Odd);
+    let (out_w, out_h) = geometry.output_dimensions(src_w as u32, src_h as u32);
+    let mut output = vec![0u8; (out_w * out_h * 4) as usize];
+
+    let bg_r = ((config.background_color >> 24) & 0xFF) as u8;
+    let bg_g = ((config.background_color >> 16) & 0xFF) as u8;
+    let bg_b = ((config.background_color >> 8) & 0xFF) as u8;
+    let bg_a = (config.background_color & 0xFF) as u8;
+
+    let border_r = ((config.border_color >> 24) & 0xFF) as u8;
+    let border_g = ((config.border_color >> 16) & 0xFF) as u8;
+    let border_b = ((config.border_color >> 8) & 0xFF) as u8;
+    let border_a = (config.border_color & 0xFF) as u8;
+
+    for y in 0..out_h as i32 {
+        for x in 0..out_w as i32 {
+            let (hex_col, hex_row) = geometry.output_to_hex(x, y);
+            let out_idx = ((y as u32 * out_w + x as u32) * 4) as usize;
+
+            if hex_col >= 0 && hex_row >= 0 && hex_col < src_w as i32 && hex_row < src_h as i32 {
+                if config.draw_borders && config.border_thickness > 0 {
+                    if is_border_pixel(x, y, &geometry, config.border_thickness) {
+                        output[out_idx] = border_r;
+                        output[out_idx + 1] = border_g;
+                        output[out_idx + 2] = border_b;
+                        output[out_idx + 3] = border_a;
+                        continue;
+                    }
+                }
+
+                let src_idx = (hex_row as usize * src_w + hex_col as usize) * 4;
+                output[out_idx] = input[src_idx];
+                output[out_idx + 1] = input[src_idx + 1];
+                output[out_idx + 2] = input[src_idx + 2];
+                output[out_idx + 3] = input[src_idx + 3];
+            } else {
+                output[out_idx] = bg_r;
+                output[out_idx + 1] = bg_g;
+                output[out_idx + 2] = bg_b;
+                output[out_idx + 3] = bg_a;
+            }
+        }
+    }
+
+    output
+}
+
+#[inline]
+fn is_border_pixel(x: i32, y: i32, geometry: &HexGeometry, thickness: usize) -> bool {
+    let t = thickness as i32;
+
+    for dy in -t..=t {
+        for dx in -t..=t {
+            if dx == 0 && dy == 0 {
+                continue;
+            }
+
+            let (h1_col, h1_row) = geometry.output_to_hex(x, y);
+            let (h2_col, h2_row) = geometry.output_to_hex(x + dx, y + dy);
+
+            if h1_col != h2_col || h1_row != h2_row {
+                return true;
+            }
+        }
+    }
+
+    false
+}