From 90f886f97114a5dff2c814e29be2d82ce98436dd Mon Sep 17 00:00:00 2001 From: Bradlee Speice Date: Sat, 20 Jun 2026 15:10:25 -0400 Subject: [PATCH] Implement the IFS camera --- Cargo.lock | 1 + Cargo.toml | 1 + enkou-shaders/Cargo.toml | 1 + enkou-shaders/src/camera.rs | 156 ++++++++++++++++++++++++++++++++++++ enkou-shaders/src/lib.rs | 18 ++++- 5 files changed, 173 insertions(+), 4 deletions(-) create mode 100644 enkou-shaders/src/camera.rs diff --git a/Cargo.lock b/Cargo.lock index 4684777..3fb615e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -155,6 +155,7 @@ version = "0.1.0" dependencies = [ "bytemuck", "glam", + "libm", "rand", "spirv-std", ] diff --git a/Cargo.toml b/Cargo.toml index cdedf41..75f972f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -22,6 +22,7 @@ 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"] } +libm = "0.2.16" rand = { version = "0.10.1", default-features = false } rspirv = "0.13.0" diff --git a/enkou-shaders/Cargo.toml b/enkou-shaders/Cargo.toml index ecbf4a0..4e89b76 100644 --- a/enkou-shaders/Cargo.toml +++ b/enkou-shaders/Cargo.toml @@ -12,5 +12,6 @@ workspace = true [dependencies] bytemuck.workspace = true glam.workspace = true +libm.workspace = true rand.workspace = true spirv-std.workspace = true diff --git a/enkou-shaders/src/camera.rs b/enkou-shaders/src/camera.rs new file mode 100644 index 0000000..532378b --- /dev/null +++ b/enkou-shaders/src/camera.rs @@ -0,0 +1,156 @@ +use bytemuck::{Pod, Zeroable}; +use glam::{Affine2, IVec2, UVec2, Vec2, vec2}; +use libm::powf; + +#[derive(Copy, Clone, Pod, Zeroable)] +#[repr(C)] +pub struct Camera { + transform: Affine2, +} + +impl Camera { + /// Construct a new camera that maps IFS coordinates to pixel coordinates. + /// + /// The camera object is itself an affine transformation, but it's helpful to express + /// the parameters in individual steps, and compose them internally. + /// + /// # Arguments + /// + /// * `dimensions` - Width and height of the output image (in pixels). + /// * `center` - Location of the origin in IFS coordinates. Positive `x` shifts the image + /// left, and positive `y` position shifts the image up. + /// * `rotate` - Rotation angle (in radians) of IFS coordinates. Rotation is applied after the + /// `center` translation, so it is about the new origin. + /// * `zoom` - Zoom factor applied to IFS coordinates. IFS coordinates are scaled by + /// `pow(2, zoom)`, so a zoom factor of 0 is the identity. + /// * `scale` - Pixels per unit of IFS coordinates. By default, this parameter is chosen such + /// that the largest dimension will cover the range `[-2, 2]`, but values higher or lower + /// can be used as a secondary zoom. + pub fn new(dimensions: UVec2, center: Vec2, rotate: f32, zoom: Vec2, scale: Vec2) -> Camera { + let ifs_center_transform = Affine2::from_translation(-center); + let zoom_transform = Affine2::from_scale(vec2(powf(2.0, zoom.x), powf(2.0, zoom.y))); + let scale_transform = Affine2::from_scale(scale); + let rotate_transform = Affine2::from_angle(rotate); + let image_center_transform = Affine2::from_translation((dimensions / 2).as_vec2()); + + let transform = image_center_transform + * rotate_transform + * scale_transform + * zoom_transform + * ifs_center_transform; + + Camera { transform } + } + + /// Map a point from IFS coordinates to pixel coordinates. + /// + /// ``` + /// # use glam::{vec2, ivec2, uvec2, Vec2}; + /// # use crate::enkou_shaders::camera::Camera; + /// // Output image is 600x600 pixels, centered at the origin, no rotation, no zoom, + /// // and scaled such that it covers the range [-2, 2]. + /// // Use the origin as the IFS coordinate, so the pixel coordinate is the center of the image + /// let camera = Camera::new( + /// uvec2(600, 600), + /// Vec2::ZERO, + /// 0.0, + /// Vec2::ZERO, + /// vec2(150.0, 150.0) + /// ); + /// assert_eq!(camera.transform_point(vec2(0.0, 0.0)), ivec2(300, 300)); + /// ``` + pub fn transform_point(&self, point: Vec2) -> IVec2 { + self.transform.transform_point2(point).as_ivec2() + } +} + +#[cfg(test)] +mod test { + use crate::camera::Camera; + use glam::{Affine2, Vec2, ivec2, uvec2, vec2}; + use libm::powf; + + #[test] + pub fn manual_camera() { + let starting_point = vec2(1.0, 1.0); + + // Move the origin; points move right and up by one unit, giving us (2.0, 2.0) + let center = vec2(-1.0, -1.0); + let point = starting_point - center; + + // Rotate about the new origin; points move counter-clockwise, giving us (-2.0, 2.0) + let rotate = 90.0f32.to_radians(); + let point = Affine2::from_angle(rotate).transform_point2(point); + + // Zoom in by a factor of 1; points will be twice as far from the origin, + // giving us (-4.0, 4.0) + let zoom = vec2(1.0, 1.0); + let point = point * vec2(powf(2.0, zoom.x), powf(2.0, zoom.y)); + + // Apply scaling; scale 100 in a 1000 x 1000 image is an effective range + // of [-5, 5] in IFS coordinates. + // After scaling, the point is (-400.0, 400.0) + let scale = vec2(100.0, 100.0); + let point = point * scale; + + // Move the origin from (0, 0) to image center, + // giving us (100.0, 900.0) + let dimensions = uvec2(1000, 1000); + let point = point.as_ivec2() + dimensions.as_ivec2() / 2; + + // Check that the camera implementation ends up at the same point + let camera = Camera::new(dimensions, center, rotate, zoom, scale); + + // The camera is implemented by composing affine transforms, + // which ends up with a slightly different result because of rounding. + let error = camera.transform_point(starting_point) - point; + assert!(error.x.abs() <= 1); + assert!(error.y.abs() <= 1); + } + + #[test] + pub fn point_outside_camera() { + // Scale 250 for an image 1000 x 1000 gives an effective range of [-2, 2] + let camera = Camera::new( + uvec2(1000, 1000), + Vec2::ZERO, + 0.0, + Vec2::ZERO, + vec2(250.0, 250.0), + ); + + // Converting a point outside the effective range is legal, but outside the image bounds + assert_eq!(camera.transform_point(vec2(3.0, 3.0)), ivec2(1250, 1250)); + } + + #[test] + pub fn point_outside_camera_negative() { + // Scale 250 for an image 1000 x 1000 gives an effective range of [-2, 2] + let camera = Camera::new( + uvec2(1000, 1000), + Vec2::ZERO, + 0.0, + Vec2::ZERO, + vec2(250.0, 250.0), + ); + + // Converting a point outside the effective range is legal, but outside the image bounds + assert_eq!(camera.transform_point(vec2(-3.0, -3.0)), ivec2(-250, -250)); + } + + #[test] + pub fn aspect_ratio() { + // Scale 100 for an image 1600 x 900 gives an effective X range of [-8, 8], + // and effective Y range of [-4.5, 4.5] + let camera = Camera::new( + uvec2(1600, 900), + Vec2::ZERO, + 0.0, + Vec2::ZERO, + vec2(100.0, 100.0), + ); + + // This point is inside the image width, but outside its height + assert_eq!(camera.transform_point(vec2(6.0, 6.0)), ivec2(1400, 1050)); + } +} diff --git a/enkou-shaders/src/lib.rs b/enkou-shaders/src/lib.rs index ce89c67..170d1b7 100644 --- a/enkou-shaders/src/lib.rs +++ b/enkou-shaders/src/lib.rs @@ -2,11 +2,13 @@ #![no_std] #![warn(missing_docs)] +pub mod camera; + use bytemuck::{Pod, Zeroable}; use core::f32::consts::PI; -use glam::{Affine2, Vec3, Vec4, vec2, vec3, Vec2}; -use rand::{Rng, RngExt}; +use glam::{Affine2, Vec2, Vec3, Vec4, vec2, vec3}; use rand::distr::StandardUniform; +use rand::{Rng, RngExt}; #[cfg(target_arch = "spirv")] use spirv_std::num_traits::Float; use spirv_std::spirv; @@ -97,7 +99,12 @@ impl Transform { /// # Arguments /// /// * `weights` - Weights are assumed to be normalized; adding all elements together should return the value 1 -pub fn step_chaos_game(rng: &mut R, point: Vec2, weights: &[f32], transforms: &[Transform]) -> (Vec2, u32) { +pub fn step_chaos_game( + rng: &mut R, + point: Vec2, + weights: &[f32], + transforms: &[Transform], +) -> (Vec2, u32) { let mut choice_weight = rng.sample::(StandardUniform); let mut transform_index: u32 = 0; @@ -110,7 +117,10 @@ pub fn step_chaos_game(rng: &mut R, point: Vec2, weights: &[f32], transf transform_index += 1; } - (transforms[transform_index as usize].transform_point(point), transform_index) + ( + transforms[transform_index as usize].transform_point(point), + transform_index, + ) } #[derive(Copy, Clone, Pod, Zeroable)]