Implement a basic Sierpinski Gasket IFS

Cargo.toml

@@ -22,7 +22,9 @@ spirv-std = { git = "https://github.com/Rust-GPU/rust-gpu.git", rev = "67f1ff2"
 anyhow = "1.0.102"
 bytemuck = { version = "1.25.0", features = ["derive"] }
 glam = { version = "0.33.1", default-features = false, features = ["bytemuck", "scalar-math"] }
+image = { version = "0.25.10", default-features = false, features = ["default-formats"]}
 libm = "0.2.16"
 rand = { version = "0.10.1", default-features = false }
 rspirv = "0.13.0"
-
+rand_xoshiro = "0.8.1"
+tempfile = "3.27.0"

enkou-shaders/Cargo.toml

@@ -15,3 +15,9 @@ glam.workspace = true
 libm.workspace = true
 rand.workspace = true
 spirv-std.workspace = true
+
+[dev-dependencies]
+anyhow.workspace = true
+image.workspace = true
+rand_xoshiro.workspace = true
+tempfile.workspace = true

enkou-shaders/examples/gasket.rs

@@ -0,0 +1,75 @@
+use anyhow::{Context, Result};
+use enkou_shaders::Coefficients2;
+use enkou_shaders::camera::Camera;
+use enkou_shaders::chaos_game::ChaosGame;
+use enkou_shaders::transform::Transform;
+use glam::{Affine2, Vec2, uvec2, UVec2};
+use image::{GrayImage, Luma};
+use rand::SeedableRng;
+use rand_xoshiro::Xoshiro256StarStar;
+use std::mem;
+use std::process::Command;
+use tempfile::{NamedTempFile};
+
+const ITERATIONS: u32 = 50_000;
+const ITERATIONS_DISCARD: u32 = 20;
+const IMAGE_DIMENSION: UVec2 = uvec2(600, 600);
+
+pub fn main() -> Result<()> {
+    let seed: u64 = 4; // chosen by fair dice roll
+    let mut rng = Xoshiro256StarStar::seed_from_u64(seed);
+
+    let transforms = [
+        // F_0: (x / 2, y / 2)
+        Transform::new(Affine2::from_coefficients(0.5, 0.0, 0.0, 0.0, 0.5, 0.0)),
+        // F_1: ((x + 1) / 2, y / 2)
+        Transform::new(Affine2::from_coefficients(0.5, 0.0, 0.5, 0.0, 0.5, 0.0)),
+        // F_2: (x / 2, (y + 1) / 2)
+        Transform::new(Affine2::from_coefficients(0.5, 0.0, 0.0, 0.0, 0.5, 0.5)),
+    ];
+
+    let weights = [1.0 / 3.0, 1.0 / 3.0, 1.0 / 3.0];
+
+    let mut image = GrayImage::new(IMAGE_DIMENSION.x, IMAGE_DIMENSION.y);
+
+    // The gasket is defined on the range [0, 1] for both X and Y
+    let camera = Camera::new(
+        IMAGE_DIMENSION,
+        Vec2::ONE * 0.5,
+        0.0,
+        Vec2::ZERO,
+        IMAGE_DIMENSION.as_vec2(),
+    );
+
+    let mut chaos_game = ChaosGame::new(&mut rng, &transforms, &weights);
+    for i in 0..ITERATIONS {
+        let next_point = chaos_game.next().unwrap();
+
+        if i < ITERATIONS_DISCARD {
+            continue;
+        }
+
+        if let Some(next_point) = camera.transform_point_to_image(next_point) {
+            image.put_pixel(next_point.x, next_point.y, Luma([255u8]))
+        }
+    }
+
+    let temp = NamedTempFile::with_suffix(".png").context("Unable to create file for image")?;
+    image.save(temp.path()).context("Unable to save image")?;
+
+    let open_program = cfg_select! {
+        unix => "xdg-open",
+        _ => panic!("Unknown system"),
+    };
+
+    Command::new(open_program)
+        .arg(temp.path())
+        .spawn()?
+        .wait()?;
+
+    // In case the image viewer forks and gives control back prior to reading the file,
+    // drop it and don't run the constructor
+    mem::forget(temp);
+
+    Ok(())
+}

enkou-shaders/src/camera.rs

@@ -5,6 +5,7 @@ use libm::powf;
 #[derive(Copy, Clone, Pod, Zeroable)]
 #[repr(C)]
 pub struct Camera {
+    dimensions: UVec2,
     transform: Affine2,
 }
 
@@ -39,7 +40,10 @@ impl Camera {
             * zoom_transform
             * ifs_center_transform;
 
-        Camera { transform }
+        Camera {
+            dimensions,
+            transform,
+        }
     }
 
     /// Map a point from IFS coordinates to pixel coordinates.
@@ -62,6 +66,21 @@ impl Camera {
     pub fn transform_point(&self, point: Vec2) -> IVec2 {
         self.transform.transform_point2(point).as_ivec2()
     }
+
+    /// Map a point from IFS coordinates to pixel coordinates (like [`transform_point`]),
+    /// and check that the result is within the provided image dimensions.
+    pub fn transform_point_to_image(&self, point: Vec2) -> Option<UVec2> {
+        let pixel_coordinates = self.transform_point(point);
+        if pixel_coordinates.x < 0
+            || pixel_coordinates.y < 0
+            || (pixel_coordinates.x as u32) >= self.dimensions.x
+            || (pixel_coordinates.y as u32) >= self.dimensions.y
+        {
+            None
+        } else {
+            Some(pixel_coordinates.as_uvec2())
+        }
+    }
 }
 
 #[cfg(test)]

enkou-shaders/src/chaos_game.rs

@@ -0,0 +1,68 @@
+use glam::{vec2, Vec2};
+use rand::distr::{Distribution, StandardUniform};
+use rand::{Rng, RngExt};
+use crate::transform::Transform;
+
+struct BiUnit;
+impl Distribution<f32> for BiUnit {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f32 {
+        rng.sample::<f32, _>(StandardUniform) * 2.0 - 1.0
+    }
+}
+
+/// Iterate one step in the chaos game; choose the next transform, apply it,
+/// and return the resulting point. Also returns the transform index so that
+/// path-dependent weights (the "Xaos" table in Apophysis) can be chosen
+/// for the next iteration step.
+///
+/// # Arguments
+///
+/// * `weights` - Weights are assumed to be normalized; adding all elements together should return the value 1
+pub fn step_chaos_game<R: Rng>(
+    point: Vec2,
+    rng: &mut R,
+    transforms: &[Transform],
+    weights: &[f32],
+) -> (Vec2, u32) {
+    let mut choice_weight = rng.sample::<f32, _>(StandardUniform);
+    let mut transform_index: u32 = 0;
+
+    for weight in weights {
+        choice_weight -= weight;
+        if choice_weight <= 0.0 {
+            break;
+        }
+
+        transform_index += 1;
+    }
+
+    (
+        transforms[transform_index as usize].transform_point(point),
+        transform_index,
+    )
+}
+
+pub struct ChaosGame<'a, R: Rng> {
+    current_point: Vec2,
+    rng: &'a mut R,
+    transforms: &'a [Transform],
+    weights: &'a [f32],
+}
+
+impl<'a, R: Rng> ChaosGame<'a, R> {
+    pub fn new(rng: &'a mut R, transforms: &'a [Transform], weights: &'a [f32]) -> Self {
+        let current_point = vec2(rng.sample(BiUnit), rng.sample(BiUnit));
+        ChaosGame { current_point, rng, transforms, weights }
+    }
+}
+
+impl<'a, R: Rng> Iterator for ChaosGame<'a, R> {
+    type Item = Vec2;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let (next_point, _) = step_chaos_game(self.current_point, self.rng, self.transforms, self.weights);
+        self.current_point = next_point;
+
+        Some(next_point)
+    }
+}

enkou-shaders/src/lib.rs

@@ -3,12 +3,12 @@
 #![warn(missing_docs)]
 
 pub mod camera;
+pub mod chaos_game;
+pub mod transform;
 
 use bytemuck::{Pod, Zeroable};
 use core::f32::consts::PI;
-use glam::{Affine2, Vec2, Vec3, Vec4, vec2, vec3};
-use rand::distr::StandardUniform;
-use rand::{Rng, RngExt};
+use glam::{Affine2, Vec3, Vec4, vec2, vec3};
 #[cfg(target_arch = "spirv")]
 use spirv_std::num_traits::Float;
 use spirv_std::spirv;
@@ -75,54 +75,6 @@ impl Coefficients2 for Affine2 {
     }
 }
 
-#[derive(Copy, Clone, Pod, Zeroable)]
-#[repr(C)]
-pub struct Transform {
-    pub coefficients: Affine2,
-}
-
-impl Transform {
-    pub fn new(coefficients: Affine2) -> Self {
-        Transform { coefficients }
-    }
-
-    pub fn transform_point(&self, point: Vec2) -> Vec2 {
-        self.coefficients.transform_point2(point)
-    }
-}
-
-/// Iterate one step in the chaos game; choose the next transform, apply it,
-/// and return the resulting point. Also returns the transform index so that
-/// path-dependent weights (the "Xaos" table in Apophysis) can be chosen
-/// for the next iteration step.
-///
-/// # Arguments
-///
-/// * `weights` - Weights are assumed to be normalized; adding all elements together should return the value 1
-pub fn step_chaos_game<R: Rng>(
-    rng: &mut R,
-    point: Vec2,
-    weights: &[f32],
-    transforms: &[Transform],
-) -> (Vec2, u32) {
-    let mut choice_weight = rng.sample::<f32, _>(StandardUniform);
-    let mut transform_index: u32 = 0;
-
-    for weight in weights {
-        choice_weight -= weight;
-        if choice_weight <= 0.0 {
-            break;
-        }
-
-        transform_index += 1;
-    }
-
-    (
-        transforms[transform_index as usize].transform_point(point),
-        transform_index,
-    )
-}
-
 #[derive(Copy, Clone, Pod, Zeroable)]
 #[repr(C)]
 pub struct ShaderConstants {

enkou-shaders/src/transform.rs

@@ -0,0 +1,18 @@
+use bytemuck::{Pod, Zeroable};
+use glam::{Affine2, Vec2};
+
+#[derive(Copy, Clone, Pod, Zeroable)]
+#[repr(C)]
+pub struct Transform {
+    pub coefficients: Affine2,
+}
+
+impl Transform {
+    pub fn new(coefficients: Affine2) -> Self {
+        Transform { coefficients }
+    }
+
+    pub fn transform_point(&self, point: Vec2) -> Vec2 {
+        self.coefficients.transform_point2(point)
+    }
+}