use image::{DynamicImage, GenericImageView};
pub struct DrawBuffer {
width: u32,
height: u32,
data: Vec<u32>,
scale: f32,
}
impl DrawBuffer {
pub fn new(w: u32, h: u32) -> DrawBuffer {
DrawBuffer {
width: w,
height: h,
data: vec![0; (w * h) as usize],
scale: 1.0,
}
}
pub fn get_scale(&self) -> f32 {
self.scale
}
pub fn set_scale(&mut self, scale: f32) {
self.scale = scale;
}
pub fn copy_from_draw_buffer(&mut self, other: &DrawBuffer) {
self.data.copy_from_slice(other.get_data());
}
pub fn fill_with_grid(&mut self, size: u32, col_a: u32, col_b: u32) {
let h = self.height; let w = self.width; let mut pos = 0;
for y in 0..h {
for x in 0..w {
if (x / size + y / size) % 2 == 0 {
self.data[pos] = col_a;
} else {
self.data[pos] = col_b;
}
pos += 1;
}
}
}
pub fn blit_image(&mut self, image: &DynamicImage) {
let mut pos = 0;
let h = self.height;
let w = self.width;
for y in 0..h {
for x in 0..w {
let sx = (x as f32 * self.scale).trunc() as u32;
let sy = (y as f32 * self.scale).trunc() as u32;
let pixel = image.get_pixel(sx, sy);
let r = pixel[0] as u32;
let g = pixel[1] as u32;
let b = pixel[2] as u32;
let a = pixel[3] as u32;
let bg = self.data[pos];
let fg: u32 = (r << 16) | (g << 8) | (b << 0);
let rgb = DrawBuffer::mix_rgba(fg, bg, (a as f32) / 255.0);
self.data[pos] = rgb;
pos += 1;
}
}
}
pub fn draw_hline(&mut self, sx: u32, ex: u32, y: u32, col: u32) {
let w = self.width as usize;
let h = self.height as usize;
let mut y = (y as f32 / self.scale) as usize;
let mut sx = (sx as f32 / self.scale) as usize;
let mut ex = (ex as f32 / self.scale) as usize;
if y >= h {
y = h - 1;
}
if sx >= w {
sx = w - 1;
}
if ex >= w {
ex = w - 1;
}
let col = col >> 8; for x in sx..=ex {
let p = w * y + x;
self.data[p] = col;
}
}
#[allow(dead_code)]
fn draw_vline(&mut self, x: u32, sy: u32, ey: u32, col: u32) {
let w = self.width as usize;
let h = self.height as usize;
let mut x = (x as f32 / self.scale) as usize;
let mut sy = (sy as f32 / self.scale) as usize;
let mut ey = (ey as f32 / self.scale) as usize;
if x >= w {
x = w - 1;
}
if sy >= h {
sy = h - 1;
}
if ey >= h {
ey = h - 1;
}
let col = col >> 8; for y in sy..=ey {
let p = w * y + x;
self.data[p] = col;
}
}
fn clamp_i32(v: i32, min: i32, max: i32) -> i32 {
if v < min {
min
} else if v > max {
max
} else {
v
}
}
pub fn draw_filled_rectangle(&mut self, sx: i32, sy: i32, ex: i32, ey: i32, col: u32) {
let s = self.scale;
let sx = ((sx as f32) / s).trunc() as i32;
let sy = ((sy as f32) / s).trunc() as i32;
let ex = ((ex as f32) / s).trunc() as i32;
let ey = ((ey as f32) / s).trunc() as i32;
let sx = DrawBuffer::clamp_i32(sx, 0, self.width as i32) as u32;
let sy = DrawBuffer::clamp_i32(sy, 0, self.height as i32) as u32;
let ex = DrawBuffer::clamp_i32(ex, 0, self.width as i32) as u32;
let ey = DrawBuffer::clamp_i32(ey, 0, self.height as i32) as u32;
for y in sy..ey {
for x in sx..ex {
let offset = (self.width * y + x) as usize;
self.data[offset] = col;
}
}
}
pub fn draw_frame(&mut self, x: i32, y: i32, fw: u32, fh: u32, col: u32, line_width: u32) {
let hw = ((line_width as f32) * 0.5).trunc() as i32;
let fw = fw as i32;
let fh = fh as i32;
self.draw_filled_rectangle(x - hw, y - hw, x + fw + hw, y + hw, col);
self.draw_filled_rectangle(x - hw, y + fh - hw, x + fw + hw, y + fh + hw, col);
self.draw_filled_rectangle(x - hw, y + hw, x + hw, y + fh - hw, col);
self.draw_filled_rectangle(x + fw - hw, y + hw, x + fw + hw, y + fh - hw, col);
}
pub fn get_width(&self) -> u32 {
self.width
}
pub fn get_height(&self) -> u32 {
self.height
}
pub fn get_data(&self) -> &Vec<u32> {
&self.data
}
pub fn mix_rgba(a: u32, b: u32, f: f32) -> u32 {
let ra = ((a >> 24) & 0x000000ff) as u8;
let ga = ((a >> 16) & 0x000000ff) as u8;
let ba = ((a >> 8) & 0x000000ff) as u8;
let aa = ((a >> 0) & 0x000000ff) as u8;
let rb = ((b >> 24) & 0x000000ff) as u8;
let gb = ((b >> 16) & 0x000000ff) as u8;
let bb = ((b >> 8) & 0x000000ff) as u8;
let ab = ((b >> 0) & 0x000000ff) as u8;
let r = ((ra as f32) * f + (rb as f32) * (1.0 - f)) as u32;
let g = ((ga as f32) * f + (gb as f32) * (1.0 - f)) as u32;
let b = ((ba as f32) * f + (bb as f32) * (1.0 - f)) as u32;
let a = ((aa as f32) * f + (ab as f32) * (1.0 - f)) as u32;
let rgba = (r << 24) | (g << 16) | (b << 8) | a;
rgba
}
#[allow(dead_code)]
fn mix_byte(a: u8, b: u8, f: u8) -> u8 {
let f = (f as f32) / 255.0;
let fa = a as f32 * f;
let fb = b as f32 * (1.0 - f);
(fa + fb) as u8
}
}