Vec arg min max

.github/workflows/rust.yml

@@ -28,4 +28,4 @@ jobs:
       - name: Build workspace, std
         run: cargo build --workspace --verbose --all-targets --all-features
       - name: Run tests, std
-        run: cargo test --workspace --verbose --features "std" --exclude 'retrofire-demos*'
+        run: cargo test --workspace --verbose --features "std" --exclude 'retrofire-*demo*'

.gitignore

@@ -1,8 +1,8 @@
-/target
-/Cargo.lock
-/.idea
-/.vscode
-/tmp
+target/
+Cargo.lock
+.idea/
+.vscode/
+tmp/
 *.iml
 *.DS_Store
 

Cargo.toml

@@ -19,6 +19,7 @@ license.workspace = true
 keywords.workspace = true
 categories.workspace = true
 repository.workspace = true
+documentation.workspace = true
 
 [workspace]
 members = [
@@ -27,7 +28,7 @@ members = [
     "geom",
     "front",
     "demos",
-    "demos/wasm"
+    "demos/wasm",
 ]
 resolver = "2"
 
@@ -36,9 +37,10 @@ edition = "2024"
 version = "0.4.0"
 authors = ["Johannes 'Sharlin' Dahlström <johannes.dahlstrom@gmail.com>"]
 license = "MIT OR Apache-2.0"
-repository = "https://github.com/jdahlstrom/retrofire"
 keywords = ["graphics", "gamedev", "demoscene", "retrocomputing", "rendering"]
 categories = ["graphics", "game-development", "no-std"]
+repository = "https://github.com/jdahlstrom/retrofire"
+documentation = "https://crates.io/crates/retrofire"
 
 [workspace.lints]
 clippy.manual_range_contains = "allow"
@@ -53,17 +55,33 @@ retrofire-core = { version = "0.4.0", path = "core" }
 retrofire-front = { version = "0.4.0", path = "front" }
 retrofire-geom = { version = "0.4.0", path = "geom" }
 
+[dev-dependencies]
+divan = "0.1.21"
+
 [profile.release]
 opt-level = 2
-codegen-units = 1
+codegen-units = 4
 lto = "thin"
 debug = 1
 
 [profile.bench]
 opt-level = 3
 codegen-units = 1
-lto = "fat"
+lto = "thin"
 
 [profile.dev]
 opt-level = 1
 split-debuginfo = "unpacked"
+
+
+[[bench]]
+name = "fill"
+harness = false
+
+[[bench]]
+name = "clip"
+harness = false
+
+[[bench]]
+name = "isect"
+harness = false

README.md

@@ -54,13 +54,13 @@ for custom allocators is planned in order to make `alloc` optional as well.
 * Type-tagged affine and linear transforms and projections
 * Perspective-correct texture mapping
 * Triangle mesh data structure and a library of shapes
+* Cubic Bézier, Hermite, Catmull–Rom, and B-splines
+* Simple random number generation and distributions
 * Simple text rendering with bitmap fonts
 * Fully customizable rasterization stage
 * Collecting rendering performance data
 * Reading and writing pnm image files
 * Reading and writing Wavefront .obj files
-* Cubic Bezier curves and splines
-* Simple random number generation and distributions
 * Minifb, SDL2, and Wasm frontends
 * Forever emoji-free README and docs
 * Forever LLM-free code

benches/clip.rs

@@ -0,0 +1,91 @@
+//! Triangle clipping benchmarks.
+
+use core::{array, iter::repeat_with};
+
+use divan::{Bencher, counter::ItemsCount};
+
+use retrofire_core::{
+    geom::{Tri, vertex},
+    math::rand::{DEFAULT_RNG, DefaultRng, Distrib},
+    math::{orthographic, pt3},
+    render::clip::{ClipVert, view_frustum},
+};
+
+//#[global_allocator]
+//static ALLOC: AllocProfiler = AllocProfiler::system();
+
+#[divan::bench(args = [1, 10, 100, 1000, 10_000])]
+fn clip_mixed(b: Bencher, n: usize) {
+    let rng = &mut DefaultRng::default();
+    let pts = pt3(-10.0, -10.0, -10.0)..pt3(10.0, 10.0, 10.0);
+    let proj = orthographic(pt3(-1.0, -1.0, -1.0), pt3(1.0, 1.0, 1.0));
+
+    b.with_inputs(|| {
+        repeat_with(|| {
+            let vs = array::from_fn(|_| {
+                ClipVert::new(vertex(proj.apply(&pts.sample(rng)), ()))
+            });
+            Tri(vs)
+        })
+        .take(n)
+        .collect::<Vec<_>>()
+    })
+    .input_counter(|tris| ItemsCount::of_iter(tris))
+    .bench_local_values(|tris| {
+        let mut out = Vec::new();
+        view_frustum::clip(tris.as_slice(), &mut out);
+        out
+    })
+}
+
+#[divan::bench(args = [1, 10, 100, 1000, 10_000])]
+fn clip_all_inside(b: Bencher, n: usize) {
+    let rng = &mut DefaultRng::default();
+    let pts = pt3(-1.0, -1.0, -1.0)..pt3(1.0, 1.0, 1.0);
+    let proj = orthographic(pt3(-1.0, -1.0, -1.0), pt3(1.0, 1.0, 1.0));
+
+    b.with_inputs(|| {
+        repeat_with(|| {
+            let vs = array::from_fn(|_| {
+                ClipVert::new(vertex(proj.apply(&pts.sample(rng)), ()))
+            });
+            Tri(vs)
+        })
+        .take(n)
+        .collect::<Vec<_>>()
+    })
+    .input_counter(|tris| ItemsCount::of_iter(tris))
+    .bench_local_values(|tris| {
+        let mut out = Vec::new();
+        view_frustum::clip(tris.as_slice(), &mut out);
+        out
+    })
+}
+
+#[divan::bench(args = [1, 10, 100, 1000, 10_000])]
+fn clip_all_outside(b: Bencher, n: usize) {
+    let mut rng = DEFAULT_RNG;
+    let pts = pt3(2.0, -10.0, -10.0)..pt3(10.0, 10.0, 10.0);
+    let proj = orthographic(pt3(-1.0, -1.0, -1.0), pt3(1.0, 1.0, 1.0));
+
+    b.with_inputs(|| {
+        repeat_with(|| {
+            let vs = ([pts.start; 3]..[pts.end; 3])
+                .sample(&mut rng)
+                .map(|pt| ClipVert::new(vertex(proj.apply(&pt), ())));
+            Tri(vs)
+        })
+        .take(n)
+        .collect::<Vec<_>>()
+    })
+    .input_counter(|tris| ItemsCount::of_iter(tris))
+    .bench_local_values(|tris| {
+        let mut out = Vec::with_capacity(tris.len());
+        view_frustum::clip(tris.as_slice(), &mut out);
+        out
+    })
+}
+
+fn main() {
+    divan::main()
+}

benches/fill.rs

@@ -0,0 +1,101 @@
+//! Fillrate benchmarks.
+
+use core::iter::zip;
+
+use divan::{Bencher, counter::ItemsCount};
+
+use retrofire_core::{
+    geom::{Tri, vertex},
+    math::{Color3, Color3f, color::gray, pt3, rgb},
+    render::{
+        Texture, raster::ScreenPt, raster::tri_fill, tex::SamplerRepeatPot, uv,
+    },
+    util::{buf::Buf2, pnm::save_ppm},
+};
+
+const SIZES: [f32; 5] = [4.0, 16.0, 64.0, 256.0, 1024.0];
+
+const VERTS: [ScreenPt; 3] =
+    [pt3(0.1, 0.1, 0.0), pt3(0.9, 0.3, 0.5), pt3(0.4, 0.9, 1.0)];
+
+#[divan::bench(args = SIZES)]
+fn flat(b: Bencher, sz: f32) {
+    let mut buf: Buf2<Color3> = Buf2::new((1024, 1024));
+
+    b.with_inputs(|| VERTS.map(|p| vertex(p * sz, ())))
+        .input_counter(move |vs| ItemsCount::new(Tri(*vs).area() as usize))
+        .bench_local_values(|vs| {
+            tri_fill(vs, |sl| {
+                buf[sl.y][sl.xs].fill(gray(0xCC));
+            });
+        });
+
+    save_ppm("benches_fill_flat.ppm", buf).unwrap();
+}
+#[divan::bench(args = SIZES)]
+fn gouraud(b: Bencher, sz: f32) {
+    let mut buf: Buf2<Color3f> = Buf2::new((1024, 1024));
+
+    b.with_inputs(|| {
+        [
+            vertex(VERTS[0] * sz, rgb(0.9, 0.1, 0.0)),
+            vertex(VERTS[1] * sz, rgb(0.1, 0.8, 0.1)),
+            vertex(VERTS[2] * sz, rgb(0.2, 0.3, 1.0)),
+        ]
+    })
+    .input_counter(move |vs| ItemsCount::new(Tri(*vs).area() as usize))
+    .bench_local_values(|vs| {
+        tri_fill(vs, |sl| {
+            let y = sl.y;
+            let xs = sl.xs.clone();
+            let span = &mut buf[y][xs];
+
+            for ((_, col), pix) in zip(sl.vs, span) {
+                *pix = col;
+            }
+        });
+    });
+
+    let buf = Buf2::new_from(
+        (1024, 1024),
+        buf.data().into_iter().map(|c| c.to_color3()),
+    );
+    save_ppm("benches_fill_color.ppm", buf).unwrap();
+}
+
+#[divan::bench(args = SIZES)]
+fn texture(b: Bencher, sz: f32) {
+    let mut buf: Buf2<Color3> = Buf2::new((1024, 1024));
+
+    let tex = Texture::from(Buf2::<Color3>::new_from(
+        (2, 2),
+        [gray(0xFF), gray(0x33), gray(0x33), gray(0xFF)],
+    ));
+    let sampler = SamplerRepeatPot::new(&tex);
+
+    b.with_inputs(|| {
+        [
+            vertex(VERTS[0] * sz, uv(0.0, 0.0)),
+            vertex(VERTS[1] * sz, uv(4.0, 0.0)),
+            vertex(VERTS[2] * sz, uv(0.0, 4.0)),
+        ]
+    })
+    .input_counter(move |vs| ItemsCount::new(Tri(*vs).area() as usize))
+    .bench_local_values(|vs| {
+        tri_fill(vs, |sl| {
+            let y = sl.y;
+            let xs = sl.xs.clone();
+            let span = &mut buf[y][xs];
+
+            for ((_, uv), pix) in zip(sl.vs, span) {
+                *pix = sampler.sample(&tex, uv);
+            }
+        });
+    });
+
+    save_ppm("benches_fill_tex.ppm", buf).unwrap();
+}
+
+fn main() {
+    divan::main()
+}