Merge remote-tracking branch 'origin/master'

libretrogd/benches/bitmap.rs

@@ -1,7 +1,6 @@
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 
-use libretrogd::Bitmap;
-use libretrogd::Palette;
+use libretrogd::graphics::*;
 use libretrogd::{SCREEN_HEIGHT, SCREEN_WIDTH};
 
 pub fn criterion_benchmark(c: &mut Criterion) {

libretrogd/benches/blit.rs

@@ -2,7 +2,8 @@ use std::path::Path;
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 
-use libretrogd::{Bitmap, BlitMethod, Rect};
+use libretrogd::graphics::*;
+use libretrogd::math::*;
 
 pub fn criterion_benchmark(c: &mut Criterion) {
     let mut framebuffer = Bitmap::new(320, 240).unwrap();
@@ -13,6 +14,8 @@ pub fn criterion_benchmark(c: &mut Criterion) {
     let mut trans_bmp = Bitmap::new(16, 16).unwrap();
     trans_bmp.blit_region(BlitMethod::Solid, &bmp, &Rect::new(160, 0, 16, 16), 0, 0);
 
+    //////
+
     c.bench_function("blit_single_checked_solid", |b| {
         b.iter(|| {
             framebuffer.blit(
@@ -35,6 +38,8 @@ pub fn criterion_benchmark(c: &mut Criterion) {
         })
     });
 
+    //////
+
     c.bench_function("blit_single_checked_transparent", |b| {
         b.iter(|| {
             framebuffer.blit(
@@ -56,6 +61,438 @@ pub fn criterion_benchmark(c: &mut Criterion) {
             )
         })
     });
+
+    //////
+
+    c.bench_function("blit_solid_flipped_not_flipped", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::SolidFlipped {
+                    horizontal_flip: false,
+                    vertical_flip: false
+                }),
+                black_box(&solid_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    c.bench_function("blit_solid_flipped_horizontally", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::SolidFlipped {
+                    horizontal_flip: true,
+                    vertical_flip: false
+                }),
+                black_box(&solid_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    c.bench_function("blit_solid_flipped_vertically", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::SolidFlipped {
+                    horizontal_flip: false,
+                    vertical_flip: true
+                }),
+                black_box(&solid_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    c.bench_function("blit_solid_flipped_horizontally_and_vertically", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::SolidFlipped {
+                    horizontal_flip: true,
+                    vertical_flip: true
+                }),
+                black_box(&solid_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    //////
+
+    c.bench_function("blit_transparent_flipped_not_flipped", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::TransparentFlipped {
+                    transparent_color: 0,
+                    horizontal_flip: false,
+                    vertical_flip: false
+                }),
+                black_box(&trans_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    c.bench_function("blit_transparent_flipped_horizontally", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::TransparentFlipped {
+                    transparent_color: 0,
+                    horizontal_flip: true,
+                    vertical_flip: false
+                }),
+                black_box(&trans_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    c.bench_function("blit_transparent_flipped_vertically", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::TransparentFlipped {
+                    transparent_color: 0,
+                    horizontal_flip: false,
+                    vertical_flip: true
+                }),
+                black_box(&trans_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    c.bench_function("blit_transparent_flipped_horizontally_and_vertically", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::TransparentFlipped {
+                    transparent_color: 0,
+                    horizontal_flip: true,
+                    vertical_flip: true
+                }),
+                black_box(&trans_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    //////
+
+    c.bench_function("blit_transparent_single_flipped_not_flipped", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::TransparentFlippedSingle {
+                    transparent_color: 0,
+                    horizontal_flip: false,
+                    vertical_flip: false,
+                    draw_color: 17,
+                }),
+                black_box(&trans_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    c.bench_function("blit_transparent_single_flipped_horizontally", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::TransparentFlippedSingle {
+                    transparent_color: 0,
+                    horizontal_flip: true,
+                    vertical_flip: false,
+                    draw_color: 17,
+                }),
+                black_box(&trans_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    c.bench_function("blit_transparent_single_flipped_vertically", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::TransparentFlippedSingle {
+                    transparent_color: 0,
+                    horizontal_flip: false,
+                    vertical_flip: true,
+                    draw_color: 17,
+                }),
+                black_box(&trans_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    c.bench_function("blit_transparent_single_flipped_horizontally_and_vertically", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::TransparentFlippedSingle {
+                    transparent_color: 0,
+                    horizontal_flip: true,
+                    vertical_flip: true,
+                    draw_color: 17,
+                }),
+                black_box(&trans_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    //////
+
+    c.bench_function("blit_transparent_single", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::TransparentSingle {
+                    transparent_color: 0,
+                    draw_color: 17,
+                }),
+                black_box(&trans_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    //////
+
+    c.bench_function("blit_transparent_offset", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::TransparentOffset {
+                    transparent_color: 0,
+                    offset: 42,
+                }),
+                black_box(&trans_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    //////
+
+    c.bench_function("blit_transparent_offset_flipped_not_flipped", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::TransparentFlippedOffset {
+                    transparent_color: 0,
+                    horizontal_flip: false,
+                    vertical_flip: false,
+                    offset: 42,
+                }),
+                black_box(&trans_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    c.bench_function("blit_transparent_offset_flipped_horizontally", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::TransparentFlippedOffset {
+                    transparent_color: 0,
+                    horizontal_flip: true,
+                    vertical_flip: false,
+                    offset: 42,
+                }),
+                black_box(&trans_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    c.bench_function("blit_transparent_offset_flipped_vertically", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::TransparentFlippedOffset {
+                    transparent_color: 0,
+                    horizontal_flip: false,
+                    vertical_flip: true,
+                    offset: 42,
+                }),
+                black_box(&trans_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    c.bench_function("blit_transparent_offset_flipped_horizontally_and_vertically", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::TransparentFlippedOffset {
+                    transparent_color: 0,
+                    horizontal_flip: true,
+                    vertical_flip: true,
+                    offset: 42,
+                }),
+                black_box(&trans_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    //////
+
+    c.bench_function("blit_solid_offset", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::SolidOffset(42)),
+                black_box(&solid_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    //////
+
+    c.bench_function("blit_solid_offset_flipped_not_flipped", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::SolidFlippedOffset {
+                    horizontal_flip: false,
+                    vertical_flip: false,
+                    offset: 42,
+                }),
+                black_box(&solid_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    c.bench_function("blit_solid_offset_flipped_horizontally", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::SolidFlippedOffset {
+                    horizontal_flip: true,
+                    vertical_flip: false,
+                    offset: 42,
+                }),
+                black_box(&solid_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    c.bench_function("blit_solid_offset_flipped_vertically", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::SolidFlippedOffset {
+                    horizontal_flip: false,
+                    vertical_flip: true,
+                    offset: 42,
+                }),
+                black_box(&solid_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    c.bench_function("blit_solid_offset_flipped_horizontally_and_vertically", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::SolidFlippedOffset {
+                    horizontal_flip: true,
+                    vertical_flip: true,
+                    offset: 42,
+                }),
+                black_box(&solid_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    //////
+
+    c.bench_function("blit_rotozoom", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::RotoZoom {
+                    angle: 73.0f32.to_radians(),
+                    scale_x: 1.2,
+                    scale_y: 0.8,
+                }),
+                black_box(&solid_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    //////
+
+    c.bench_function("blit_rotozoom_offset", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::RotoZoomOffset {
+                    angle: 73.0f32.to_radians(),
+                    scale_x: 1.2,
+                    scale_y: 0.8,
+                    offset: 42,
+                }),
+                black_box(&solid_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    //////
+
+    c.bench_function("blit_rotozoom_transparent", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::RotoZoomTransparent {
+                    angle: 73.0f32.to_radians(),
+                    scale_x: 1.2,
+                    scale_y: 0.8,
+                    transparent_color: 0,
+                }),
+                black_box(&trans_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
+    //////
+
+    c.bench_function("blit_rotozoom_offset_transparent", |b| {
+        b.iter(|| {
+            framebuffer.blit(
+                black_box(BlitMethod::RotoZoomTransparentOffset {
+                    angle: 73.0f32.to_radians(),
+                    scale_x: 1.2,
+                    scale_y: 0.8,
+                    transparent_color: 0,
+                    offset: 42,
+                }),
+                black_box(&trans_bmp),
+                black_box(100),
+                black_box(100),
+            )
+        })
+    });
+
 }
 
 criterion_group!(benches, criterion_benchmark);

libretrogd/src/audio/buffer/mod.rs

@@ -11,7 +11,7 @@ pub enum AudioBufferError {
 }
 
 /// Holds audio sample data that can be played via [`AudioDevice`].
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub struct AudioBuffer {
     spec: AudioSpec,
     pub data: Vec<u8>,

libretrogd/src/graphics/bitmap/blit.rs

@@ -651,7 +651,9 @@ impl Bitmap {
             // rotozoom blits internally clip per-pixel right now ... and regardless, the normal
             // clip_blit() function wouldn't handle a rotozoom blit destination region anyway ...
             RotoZoom { .. } => {}
+            RotoZoomOffset { .. } => {}
             RotoZoomTransparent { .. } => {}
+            RotoZoomTransparentOffset { .. } => {}
 
             // set axis flip arguments
             SolidFlipped { horizontal_flip, vertical_flip, ..  } |

libretrogd/src/graphics/bitmap/mod.rs

@@ -40,7 +40,7 @@ pub enum BitmapError {
 /// one row to the next is always exactly equal to the bitmap width. Rendering operations provided
 /// here are done with respect to the bitmaps clipping region, where rendering outside of the
 /// clipping region is simply not performed / stops at the clipping boundary.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub struct Bitmap {
     width: u32,
     height: u32,

libretrogd/src/graphics/bitmapatlas.rs

@@ -11,7 +11,7 @@ pub enum BitmapAtlasError {
     OutOfBounds,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub struct BitmapAtlas {
     bitmap: Bitmap,
     bounds: Rect,

libretrogd/src/graphics/font.rs

@@ -43,7 +43,7 @@ pub trait Font {
     fn measure(&self, text: &str, opts: FontRenderOpts) -> (u32, u32);
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub struct BitmaskCharacter {
     bytes: [u8; CHAR_HEIGHT],
     bounds: Rect,
@@ -83,7 +83,7 @@ impl Character for BitmaskCharacter {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub struct BitmaskFont {
     characters: Box<[BitmaskCharacter]>,
     line_height: u8,

libretrogd/src/graphics/palette.rs

@@ -224,7 +224,7 @@ pub enum PaletteFormat {
 
 /// Contains a 256 color palette, and provides methods useful for working with palettes. The
 /// colors are all stored individually as 32-bit packed values in the format 0xAARRGGBB.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub struct Palette {
     colors: [u32; NUM_COLORS],
 }
@@ -530,13 +530,6 @@ impl IndexMut<u8> for Palette {
     }
 }
 
-impl PartialEq for Palette {
-    #[inline]
-    fn eq(&self, other: &Self) -> bool {
-        self.colors == other.colors
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use tempfile::TempDir;

libretrogd/src/math/matrix3x3.rs

@@ -3,7 +3,7 @@ use std::ops::{Mul, MulAssign};
 use crate::math::*;
 
 /// Represents a 3x3 column-major matrix and provides common methods for matrix math.
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, PartialEq)]
 pub struct Matrix3x3 {
     pub m: [f32; 9],
 }