Image rework for soundness and usability

examples/life.rs

@@ -14,7 +14,7 @@ async fn main() {
     let mut cells = vec![CellState::Dead; w * h];
     let mut buffer = vec![CellState::Dead; w * h];
 
-    let mut image = Image::gen_image_color(w as u16, h as u16, WHITE);
+    let mut image = Image::filled_with_color(w as u16, h as u16, WHITE);
 
     for cell in cells.iter_mut() {
         if rand::gen_range(0, 5) == 0 {
@@ -26,8 +26,8 @@ async fn main() {
     loop {
         clear_background(WHITE);
 
-        let w = image.width();
-        let h = image.height();
+        let w = image.width() as usize;
+        let h = image.height() as usize;
 
         for y in 0..h as i32 {
             for x in 0..w as i32 {
@@ -77,7 +77,7 @@ async fn main() {
             image.set_pixel(
                 (i % w) as u32,
                 (i / w) as u32,
-                match buffer[i as usize] {
+                match buffer[i] {
                     CellState::Alive => BLACK,
                     CellState::Dead => WHITE,
                 },

examples/shadertoy.rs

@@ -28,7 +28,7 @@ impl Uniform {
 fn color_picker_texture(w: usize, h: usize) -> (Texture2D, Image) {
     let ratio = 1.0 / h as f32;
 
-    let mut image = Image::gen_image_color(w as u16, h as u16, WHITE);
+    let mut image = Image::filled_with_color(w as u16, h as u16, WHITE);
     let image_data = image.get_image_data_mut();
 
     for j in 0..h {

src/color.rs

@@ -44,31 +44,31 @@ fn color_from_bytes() {
     );
 }
 
-impl Into<[u8; 4]> for Color {
-    fn into(self) -> [u8; 4] {
-        [
-            (self.r * 255.) as u8,
-            (self.g * 255.) as u8,
-            (self.b * 255.) as u8,
-            (self.a * 255.) as u8,
-        ]
+impl From<[u8; 4]> for Color {
+    fn from(value: [u8; 4]) -> Color {
+        Color::new(
+            value[0] as f32 / 255.,
+            value[1] as f32 / 255.,
+            value[2] as f32 / 255.,
+            value[3] as f32 / 255.,
+        )
     }
 }
 
-impl Into<Color> for [u8; 4] {
-    fn into(self) -> Color {
-        Color::new(
-            self[0] as f32 / 255.,
-            self[1] as f32 / 255.,
-            self[2] as f32 / 255.,
-            self[3] as f32 / 255.,
-        )
+impl From<Color> for [u8; 4] {
+    fn from(value: Color) -> Self {
+        [
+            (value.r * 255.) as u8,
+            (value.g * 255.) as u8,
+            (value.b * 255.) as u8,
+            (value.a * 255.) as u8,
+        ]
     }
 }
 
-impl Into<[f32; 4]> for Color {
-    fn into(self) -> [f32; 4] {
-        [self.r, self.g, self.b, self.a]
+impl From<Color> for [f32; 4] {
+    fn from(value: Color) -> [f32; 4] {
+        [value.r, value.g, value.b, value.a]
     }
 }
 

src/text.rs

@@ -111,14 +111,14 @@ impl Font {
         let sprite = self.atlas.lock().unwrap().new_unique_id();
         self.atlas.lock().unwrap().cache_sprite(
             sprite,
-            Image {
-                bytes: bitmap
+            Image::from_raw_parts(
+                width,
+                height,
+                bitmap
                     .iter()
                     .flat_map(|coverage| vec![255, 255, 255, *coverage])
                     .collect(),
-                width,
-                height,
-            },
+            ),
         );
         let advance = metrics.advance_width;
 

src/text/atlas.rs

@@ -41,8 +41,9 @@ impl Atlas {
     const UNIQUENESS_OFFSET: u64 = 100000;
 
     pub fn new(ctx: &mut dyn miniquad::RenderingBackend, filter: miniquad::FilterMode) -> Atlas {
-        let image = Image::gen_image_color(512, 512, Color::new(0.0, 0.0, 0.0, 0.0));
-        let texture = ctx.new_texture_from_rgba8(image.width, image.height, &image.bytes);
+        let image = Image::filled_with_color(512, 512, Color::new(0.0, 0.0, 0.0, 0.0));
+        let texture =
+            ctx.new_texture_from_rgba8(image.width() as u16, image.height() as u16, &image.bytes());
         ctx.texture_set_filter(
             texture,
             miniquad::FilterMode::Nearest,
@@ -79,30 +80,32 @@ impl Atlas {
     }
 
     pub const fn width(&self) -> u16 {
-        self.image.width
+        self.image.width() as u16
     }
 
     pub const fn height(&self) -> u16 {
-        self.image.height
+        self.image.height() as u16
     }
 
     pub fn texture(&mut self) -> miniquad::TextureId {
         let ctx = get_quad_context();
         if self.dirty {
             self.dirty = false;
             let (texture_width, texture_height) = ctx.texture_size(self.texture);
-            if texture_width != self.image.width as _ || texture_height != self.image.height as _ {
+            if texture_width != self.image.width() as _
+                || texture_height != self.image.height() as _
+            {
                 ctx.delete_texture(self.texture);
 
                 self.texture = ctx.new_texture_from_rgba8(
-                    self.image.width,
-                    self.image.height,
-                    &self.image.bytes[..],
+                    self.image.width() as u16,
+                    self.image.height() as u16,
+                    &self.image.bytes()[..],
                 );
                 ctx.texture_set_filter(self.texture, self.filter, miniquad::MipmapFilterMode::None);
             }
 
-            ctx.texture_update(self.texture, &self.image.bytes);
+            ctx.texture_update(self.texture, self.image.bytes());
         }
 
         self.texture
@@ -123,9 +126,9 @@ impl Atlas {
     }
 
     pub fn cache_sprite(&mut self, key: SpriteKey, sprite: Image) {
-        let (width, height) = (sprite.width as usize, sprite.height as usize);
+        let (width, height) = (sprite.width() as usize, sprite.height() as usize);
 
-        let x = if self.cursor_x + (width as u16) < self.image.width {
+        let x = if self.cursor_x + (width as u16) < self.image.width() as u16 {
             if height as u16 > self.max_line_height {
                 self.max_line_height = height as u16;
             }
@@ -141,7 +144,9 @@ impl Atlas {
         let y = self.cursor_y;
 
         // texture bounds exceeded
-        if y + sprite.height > self.image.height || x + sprite.width > self.image.width {
+        if y + sprite.height() as u16 > self.image.height() as u16
+            || x + sprite.width() as u16 > self.image.width() as u16
+        {
             // reset glyph cache state
             let sprites = self.sprites.drain().collect::<Vec<_>>();
             self.cursor_x = 0;
@@ -154,11 +159,14 @@ impl Atlas {
             // note: if we tried to fit gigantic texture into a small atlas,
             // new_width will still be not enough. But its fine, it will
             // be regenerated on the recursion call.
-            let new_width = self.image.width * 2;
-            let new_height = self.image.height * 2;
+            let new_width = self.image.width() * 2;
+            let new_height = self.image.height() * 2;
 
-            self.image =
-                Image::gen_image_color(new_width, new_height, Color::new(0.0, 0.0, 0.0, 0.0));
+            self.image = Image::filled_with_color(
+                new_width as u16,
+                new_height as u16,
+                Color::new(0.0, 0.0, 0.0, 0.0),
+            );
 
             // recache all previously cached symbols
             for (key, sprite) in sprites {