37 files changed, 712 insertions, 383 deletions
diff --git a/source/benoit/benoit.rs b/source/benoit/benoit.rs
index 2812e52..e4a7a8f 100644
--- a/source/benoit/benoit.rs
+++ b/source/benoit/benoit.rs
@@ -12,8 +12,8 @@
 
 Benoit is distributed in the hope that it will
 be useful, but WITHOUT ANY WARRANTY; without
- even the implied warranty of MERCHANTABILITY or
- FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ even the implied warranty of MERCHANTABIL ITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See theGNU
 Affero General Public License for more details.
 
 You should have received a copy of the GNU
@@ -21,13 +21,36 @@
 If not, see <https://www.gnu.org/licenses/>.
 */
 
-pub mod application;
+extern crate rug;
+
+use rug::Float;
+
+pub mod app;
 pub mod configuration;
 pub mod fractal;
 pub mod iteration;
-pub mod render_data;
+pub mod task;
 pub mod video;
 
-pub const VERSION: u32 = 0x23;
+pub struct Version<T> {
+ major: T,
+ minor: T,
+ patch: T,
+}
+
+pub const VERSION: Version::<u32> = Version::<u32> {
+ major: 0x1,
+ minor: 0x0,
+ patch: 0x0,
+};
 
 pub const PRECISION: u32 = 0x80;
+
+pub struct FeedbackInfo<'a> {
+ prev_centre_real: &'a Float,
+ prev_centre_imag: &'a Float,
+ prev_zoom: &'a Float,
+ next_centre_real: &'a Float,
+ next_centre_imag: &'a Float,
+ next_zoom: &'a Float,
+}
diff --git a/source/benoit/benoit/application.rs b/source/benoit/benoit/app.rs
index b05ede2..f7ebb47 100644
--- a/source/benoit/benoit/application.rs
+++ b/source/benoit/benoit/app.rs
@@ -23,7 +23,7 @@
 
 use crate::benoit::fractal::Fractal;
 use crate::benoit::iteration::IteratorFunction;
-use crate::benoit::render_data::RenderData;
+use crate::benoit::task::render_data::RenderData;
 use crate::benoit::video::Video;
 
 extern crate rug;
@@ -33,7 +33,8 @@ use std::sync::Arc;
 
 pub mod animate;
 pub mod colour;
-pub mod draw;
+pub mod colour_row;
+pub mod drop;
 pub mod dump;
 pub mod get_iterator_function;
 pub mod get_row_renderer;
@@ -48,13 +49,7 @@ pub mod run;
 
 pub type RowRenderer = fn(Arc<RenderData>, u32, IteratorFunction);
 
-pub struct PreviousPosition {
- centre_real: Float,
- centre_imag: Float,
- zoom: Float,
-}
-
-pub struct Application {
+pub struct App {
 thread_count: u32,
 
 fractal: Fractal,
@@ -69,6 +64,8 @@ pub struct Application {
 zoom: Float,
 max_iter_count: u32,
 
+ colour_range: f32,
+
 dump_path: String,
 
 video: Option<Video>,
diff --git a/source/benoit/benoit/app/animate.rs b/source/benoit/benoit/app/animate.rs
new file mode 100644
index 0000000..f732e61
--- /dev/null
+++ b/source/benoit/benoit/app/animate.rs
@@ -0,0 +1,120 @@
+/*
+ Copyright 2021, 2023 Gabriel Bjørnager Jensen.
+
+ This file is part of Benoit.
+
+ Benoit is free software: you can redistribute it
+ and/or modify it under the terms of the GNU
+ Affero General Public License as published by
+ the Free Software Foundation, either version 3
+ of the License, or (at your option) any later
+ version.
+
+ Benoit is distributed in the hope that it will
+ be useful, but WITHOUT ANY WARRANTY; without
+ even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Affero General Public License for more details.
+
+ You should have received a copy of the GNU
+ Affero General Public License along with Benoit.
+ If not, see <https://www.gnu.org/licenses/>.
+*/
+
+use crate::benoit::PRECISION;
+use crate::benoit::app::App;
+
+extern crate rug;
+extern crate sdl2;
+
+use rug::Float;
+use rug::ops::PowAssign;
+use std::time::Instant;
+
+impl App {
+ pub fn animate(&self) -> i32 {
+ let canvas_size = self.canvas_width as usize * self.canvas_width as usize;
+
+ let mut iter_count_buffer: Vec::<u32> = vec![0x0; canvas_size];
+ let mut square_dist_buffer: Vec::<f32> = vec![0.0; canvas_size];
+
+ let mut image: Vec::<u8> = vec![0x0; canvas_size * 0x3];
+
+ if self.frame_count == 0x1 {
+ // If only a single frame is to be rendered, we
+ // aren't going to animate it.
+
+ eprint!("rendering at {}{:+}i ({}x)...", self.centre_real.to_f32(), self.centre_imag.to_f32(), self.zoom.to_f32());
+
+ let time_start = Instant::now();
+
+ self.render(&mut iter_count_buffer[..], &mut square_dist_buffer[..], &self.centre_real, &self.centre_imag, &self.zoom, self.max_iter_count);
+ let render_time = time_start.elapsed();
+
+ self.colour(&mut image[..], self.max_iter_count, &mut iter_count_buffer[..], &mut square_dist_buffer[..]);
+ let colour_time = time_start.elapsed() - render_time;
+
+ self.dump(format!("{}/render.webp", self.dump_path), &image, self.canvas_width);
+
+ eprintln!(" rend. {:.3}ms, col. {:.3}ms", render_time.as_micros() as f32 / 1000.0, colour_time.as_micros() as f32 / 1000.0);
+
+ return 0x0;
+ }
+
+ // zoom_start:
+ let mut zoom = Float::with_val(PRECISION, 1.0 / 4.0);
+
+ let zoom_stop = Float::with_val(PRECISION, &self.zoom);
+
+ let zoom_factor = {
+ // To get the zoom factor, we first want the 'a'
+ // value of the growth function from (0) to
+ // (frame_count) on the x-dimension and from
+ // (zoom_start) to (zoom_stop) on the y-dimension:
+ //
+ // a = nroot(x1-x0,y1/y0),
+ //
+ // but this may be simplified for use with Rug
+ // because
+ //
+ // nroot(a,b) = b^(1/a),
+ //
+ // making the final equation
+ //
+ // (y1/y0)^(1/(x1-x0)) = (zoom_stop/zoom_start)^(1/(frame_count-1)).
+ //
+ // N.b. that we subtract one from frame_count as we
+ // want the final render to have exactly the
+ // specified zoom.
+
+ let exponent = Float::with_val(PRECISION, 1.0 / (self.frame_count as f32 - 1.0));
+
+ let mut factor = Float::with_val(PRECISION, &zoom_stop / &zoom);
+ factor.pow_assign(exponent);
+
+ factor
+ };
+
+ eprintln!("animating {} frames at {}{:+}i to {:.3} (fac. {:.3})", self.frame_count, self.centre_real.to_f64(), self.centre_imag.to_f64(), zoom_stop.to_f64(), zoom_factor.to_f64());
+
+ for frame in 0x0..self.frame_count {
+ eprint!("{frame:010} ({:.3}x)...", zoom.to_f32());
+
+ let time_start = Instant::now();
+
+ self.render(&mut iter_count_buffer[..], &mut square_dist_buffer[..], &self.centre_real, &self.centre_imag, &zoom, self.max_iter_count);
+ let render_time = time_start.elapsed();
+
+ self.colour(&mut image[..], self.max_iter_count, &mut iter_count_buffer[..], &mut square_dist_buffer[..]);
+ let colour_time = time_start.elapsed() - render_time;
+
+ self.dump(format!("{}/frame{frame:010}.webp", self.dump_path), &image, self.canvas_width);
+
+ eprintln!(" rend. {:.3}ms, col. {:.3}ms", render_time.as_micros() as f32 / 1000.0, colour_time.as_micros() as f32 / 1000.0);
+
+ zoom *= &zoom_factor;
+ }
+
+ return 0x0;
+ }
+}
diff --git a/source/benoit/benoit/app/colour.rs b/source/benoit/benoit/app/colour.rs
new file mode 100644
index 0000000..3325b55
--- /dev/null
+++ b/source/benoit/benoit/app/colour.rs
@@ -0,0 +1,40 @@
+/*
+ Copyright 2021, 2023 Gabriel Bjørnager Jensen.
+
+ This file is part of Benoit.
+
+ Benoit is free software: you can redistribute it
+ and/or modify it under the terms of the GNU
+ Affero General Public License as published by
+ the Free Software Foundation, either version 3
+ of the License, or (at your option) any later
+ version.
+
+ Benoit is distributed in the hope that it will
+ be useful, but WITHOUT ANY WARRANTY; without
+ even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Affero General Public License for more details.
+
+ You should have received a copy of the GNU
+ Affero General Public License along with Benoit.
+ If not, see <https://www.gnu.org/licenses/>.
+*/
+
+use crate::benoit::app::App;
+use crate::benoit::task::colour_data::ColourData;
+
+extern crate rayon;
+
+use rayon::prelude::*;
+use std::sync::Arc;
+
+impl App {
+ pub fn colour(&self, buffer: &mut [u8], max_iter_count: u32, iter_count_buffer: &[u32], square_dist_buffer: &[f32]) {
+ let data = Arc::new(ColourData::new(buffer, self.canvas_width, max_iter_count, self.colour_range, iter_count_buffer, square_dist_buffer));
+
+ (0x0..self.canvas_width).into_par_iter().for_each(|row| {
+ App::colour_row(data.clone(), row as u32);
+ });
+ }
+}
diff --git a/source/benoit/benoit/application/colour.rs b/source/benoit/benoit/app/colour_row.rs
index a4587c6..81896cc 100644
--- a/source/benoit/benoit/application/colour.rs
+++ b/source/benoit/benoit/app/colour_row.rs
@@ -21,7 +21,42 @@
 If not, see <https://www.gnu.org/licenses/>.
 */
 
-use crate::benoit::application::Application;
+use crate::benoit::app::App;
+use crate::benoit::task::colour_data::ColourData;
+
+use std::hint::unreachable_unchecked;
+use std::sync::Arc;
+
+impl App {
+ pub fn colour_row(data: Arc<ColourData>, y: u32) {
+ let (iter_count_buffer, square_dist_buffer, image) = unsafe { data.slice(y) };
+
+ for x in 0x0..data.canvas_width {
+ let x = x as usize;
+
+ let iter_count = iter_count_buffer[ x];
+ let distance = square_dist_buffer[x].sqrt();
+
+ let factor = (iter_count as f32 + 1.0 - distance.log2().log2()) / data.colour_range % 1.0;
+
+ let (red, green, blue) = if iter_count != data.max_iter_count {
+ hsv_to_rgb(factor, 7.0 / 8.0, 7.0 / 8.0)
+ } else {
+ (0.0, 0.0, 0.0)
+ };
+
+ let red = (red * 255.0).round() as u8;
+ let green = (green * 255.0).round() as u8;
+ let blue = (blue * 255.0).round() as u8;
+
+ unsafe {
+ *image.get_unchecked_mut(x * 0x3) = red;
+ *image.get_unchecked_mut(x * 0x3 + 0x1) = green;
+ *image.get_unchecked_mut(x * 0x3 + 0x2) = blue;
+ }
+ }
+ }
+}
 
 fn hsv_to_rgb(hue: f32, saturation: f32, value: f32) -> (f32, f32, f32) {
 return if saturation <= 0.0 {
@@ -39,42 +74,13 @@ fn hsv_to_rgb(hue: f32, saturation: f32, value: f32) -> (f32, f32, f32) {
 let t = v * (1.0 - s * (1.0 - f));
 
 match h.trunc() as u8 {
- 0x0 => (v, t, p),
- 0x1 => (q, v, p),
- 0x2 => (p, v, t),
- 0x3 => (p, q, v),
- 0x4 => (t, p, v),
- 0x5 => (v, p, q),
- value => unreachable!(),
+ 0x0 => (v, t, p),
+ 0x1 => (q, v, p),
+ 0x2 => (p, v, t),
+ 0x3 => (p, q, v),
+ 0x4 => (t, p, v),
+ 0x5 => (v, p, q),
+ _ => unsafe { unreachable_unchecked() },
 }
 };
 }
-
-impl Application {
- pub fn colour(&self, buffer: &mut [u8], iter_count_buffer: &[u32], square_dist_buffer: &[f32]) {
- let canvas_size = self.canvas_width * self.canvas_width;
-
- for pixel in 0x0..canvas_size {
- let iter_count = iter_count_buffer[pixel as usize];
-
- let distance = square_dist_buffer[pixel as usize].sqrt();
-
- let factor_range = 16.0_f32.min(self.max_iter_count as f32);
- let factor = (iter_count as f32 + 1.0 - distance.log2().log2()) / factor_range % 1.0;
-
- let (red, green, blue) = if iter_count != self.max_iter_count {
- hsv_to_rgb(factor, 7.0 / 8.0, 7.0 / 8.0)
- } else {
- (0.0, 0.0, 0.0)
- };
-
- let red = (red * 255.0).round() as u8;
- let green = (green * 255.0).round() as u8;
- let blue = (blue * 255.0).round() as u8;
-
- buffer[pixel as usize * 0x3] = red;
- buffer[pixel as usize * 0x3 + 0x1] = green;
- buffer[pixel as usize * 0x3 + 0x2] = blue;
- }
- }
-}
diff --git a/source/benoit/benoit/render_data/send.rs b/source/benoit/benoit/app/drop.rs
index b351cdd..dfa6de1 100644
--- a/source/benoit/benoit/render_data/send.rs
+++ b/source/benoit/benoit/app/drop.rs
@@ -21,6 +21,11 @@
 If not, see <https://www.gnu.org/licenses/>.
 */
 
-use crate::benoit::render_data::RenderData;
+use crate::benoit::app::App;
 
-unsafe impl Send for RenderData {}
+impl Drop for App {
+ fn drop(&mut self) {
+ eprintln!();
+ eprintln!("Goodbye!");
+ }
+}
diff --git a/source/benoit/benoit/application/dump.rs b/source/benoit/benoit/app/dump.rs
index 4a19a52..6001e31 100644
--- a/source/benoit/benoit/application/dump.rs
+++ b/source/benoit/benoit/app/dump.rs
@@ -21,14 +21,14 @@
 If not, see <https://www.gnu.org/licenses/>.
 */
 
-use crate::benoit::application::Application;
+use crate::benoit::app::App;
 
 extern crate webp;
 
 use std::fs::write;
 use webp::Encoder;
 
-impl Application {
+impl App {
 pub fn dump(&self, path: String, image: &[u8], canvas_width: u32) {
 let encoder = Encoder::from_rgb(&image[..], canvas_width, canvas_width);
 
diff --git a/source/benoit/benoit/application/get_iterator_function.rs b/source/benoit/benoit/app/get_iterator_function.rs
index 1ca2cb7..1454785 100644
--- a/source/benoit/benoit/application/get_iterator_function.rs
+++ b/source/benoit/benoit/app/get_iterator_function.rs
@@ -22,10 +22,10 @@
 */
 
 use crate::benoit::fractal::Fractal;
-use crate::benoit::application::Application;
+use crate::benoit::app::App;
 use crate::benoit::iteration::*;
 
-impl Application {
+impl App {
 pub fn get_iterator_function(fractal: Fractal) -> IteratorFunction {
 return match fractal {
 Fractal::BurningShip => iterate_burning_ship,
diff --git a/source/benoit/benoit/application/get_row_renderer.rs b/source/benoit/benoit/app/get_row_renderer.rs
index d8c349a..050d14f 100644
--- a/source/benoit/benoit/application/get_row_renderer.rs
+++ b/source/benoit/benoit/app/get_row_renderer.rs
@@ -21,14 +21,14 @@
 If not, see <https://www.gnu.org/licenses/>.
 */
 
-use crate::benoit::application::Application;
-use crate::benoit::application::RowRenderer;
+use crate::benoit::app::App;
+use crate::benoit::app::RowRenderer;
 
-impl Application {
+impl App {
 pub fn get_row_renderer(julia: bool) -> RowRenderer {
 return match julia {
- false => Application::render_row_normal,
- true => Application::render_row_julia,
+ false => App::render_row_normal,
+ true => App::render_row_julia,
 };
 }
 }
diff --git a/source/benoit/benoit/application/handle_keys.rs b/source/benoit/benoit/app/handle_keys.rs
index 1991c36..2b2cff5 100644
--- a/source/benoit/benoit/application/handle_keys.rs
+++ b/source/benoit/benoit/app/handle_keys.rs
@@ -22,7 +22,7 @@
 */
 
 use crate::benoit::PRECISION;
-use crate::benoit::application::{Application, RowRenderer};
+use crate::benoit::app::{App, RowRenderer};
 use crate::benoit::fractal::Fractal;
 use crate::benoit::iteration::IteratorFunction;
 
@@ -32,34 +32,7 @@ extern crate sdl2;
 use rug::Float;
 use sdl2::keyboard::Scancode;
 
-fn cycle_fractal(fractal: Fractal) -> (Fractal, IteratorFunction) {
- let fractal = match fractal {
- Fractal::BurningShip => Fractal::Mandelbrot,
- Fractal::Mandelbrot => Fractal::Tricorn,
- Fractal::Tricorn => Fractal::BurningShip,
- };
-
- let iterator_function = Application::get_iterator_function(fractal);
-
- eprintln!("rendering the {}", fractal.get_name());
-
- return (fractal, iterator_function);
-}
-
-fn toggle_julia(julia: bool) -> (bool, RowRenderer) {
- let julia = !julia;
-
- let row_renderer = Application::get_row_renderer(julia);
-
- match julia {
- false => eprintln!("disabled the julia set"),
- true => eprintln!("enabled the julia set"),
- };
-
- return (julia, row_renderer);
-}
-
-impl Application {
+impl App {
 pub fn handle_keys(&mut self, scan_code: Scancode) -> bool {
 match scan_code {
 Scancode::LAlt => (self.fractal, self.iterator_function) = cycle_fractal(self.fractal),
@@ -103,6 +76,41 @@ impl Application {
 _ => self.max_iter_count,
 };
 
+ const COLOUR_RANGE_FACTOR: f32 = 1.0 + 1.0 / 16.0;
+
+ self.colour_range = match scan_code {
+ Scancode::Up => self.colour_range * COLOUR_RANGE_FACTOR,
+ Scancode::Down => self.colour_range / COLOUR_RANGE_FACTOR,
+ _ => self.colour_range,
+ };
+
 return false;
 }
 }
+
+fn cycle_fractal(fractal: Fractal) -> (Fractal, IteratorFunction) {
+ let fractal = match fractal {
+ Fractal::BurningShip => Fractal::Mandelbrot,
+ Fractal::Mandelbrot => Fractal::Tricorn,
+ Fractal::Tricorn => Fractal::BurningShip,
+ };
+
+ let iterator_function = App::get_iterator_function(fractal);
+
+ eprintln!("rendering the {}", fractal.get_name());
+
+ return (fractal, iterator_function);
+}
+
+fn toggle_julia(julia: bool) -> (bool, RowRenderer) {
+ let julia = !julia;
+
+ let row_renderer = App::get_row_renderer(julia);
+
+ match julia {
+ false => eprintln!("disabled the julia set"),
+ true => eprintln!("enabled the julia set"),
+ };
+
+ return (julia, row_renderer);
+}
diff --git a/source/benoit/benoit/application/initialise.rs b/source/benoit/benoit/app/initialise.rs
index f019f02..15d98ac 100644
--- a/source/benoit/benoit/application/initialise.rs
+++ b/source/benoit/benoit/app/initialise.rs
@@ -21,7 +21,7 @@
 If not, see <https://www.gnu.org/licenses/>.
 */
 
-use crate::benoit::application::Application;
+use crate::benoit::app::App;
 use crate::benoit::configuration::Configuration;
 use crate::benoit::video::Video;
 
@@ -31,8 +31,8 @@ use rayon::ThreadPoolBuilder;
 use std::env::args;
 use std::thread::available_parallelism;
 
-impl Application {
- pub fn initialise() -> Application {
+impl App {
+ pub fn initialise() -> App {
 let mut arguments = args();
 
 let configuration = match arguments.nth(0x1) {
@@ -58,7 +58,9 @@ impl Application {
 
 ThreadPoolBuilder::new().num_threads(configuration.thread_count as usize).build_global().unwrap();
 
- return Application {
+ eprintln!("rendering the {}", configuration.fractal.get_name());
+
+ return App {
 thread_count: thread_count,
 
 fractal: configuration.fractal,
@@ -73,6 +75,8 @@ impl Application {
 zoom: configuration.zoom,
 max_iter_count: configuration.max_iter_count,
 
+ colour_range: configuration.colour_range,
+
 dump_path: configuration.dump_path,
 
 video: video,
@@ -81,8 +85,8 @@ impl Application {
 do_render: true,
 do_dump: false,
 
- row_renderer: Application::get_row_renderer( configuration.julia),
- iterator_function: Application::get_iterator_function(configuration.fractal),
+ row_renderer: App::get_row_renderer( configuration.julia),
+ iterator_function: App::get_iterator_function(configuration.fractal),
 };
 }
 }
diff --git a/source/benoit/benoit/app/loop.rs b/source/benoit/benoit/app/loop.rs
new file mode 100644
index 0000000..b40b509
--- /dev/null
+++ b/source/benoit/benoit/app/loop.rs
@@ -0,0 +1,126 @@
+/*
+ Copyright 2021, 2023 Gabriel Bjørnager Jensen.
+
+ This file is part of Benoit.
+
+ Benoit is free software: you can redistribute it
+ and/or modify it under the terms of the GNU
+ Affero General Public License as published by
+ the Free Software Foundation, either version 3
+ of the License, or (at your option) any later
+ version.
+
+ Benoit is distributed in the hope that it will
+ be useful, but WITHOUT ANY WARRANTY; without
+ even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Affero General Public License for more details.
+
+ You should have received a copy of the GNU
+ Affero General Public License along with Benoit.
+ If not, see <https://www.gnu.org/licenses/>.
+*/
+
+use crate::benoit::FeedbackInfo;
+use crate::benoit::app::App;
+
+extern crate rug;
+
+use rug::Assign;
+use std::time::Instant;
+
+impl App {
+ pub fn r#loop(&mut self) -> i32 {
+ assert_eq!(self.video.is_some(), true);
+
+ eprintln!();
+ eprintln!("Controls:");
+ eprintln!("- W Translate up");
+ eprintln!("- A Translate left");
+ eprintln!("- S Translate down");
+ eprintln!("- D Translate right");
+ eprintln!();
+ eprintln!("- Q Zoom out");
+ eprintln!("- E Zoom in");
+ eprintln!();
+ eprintln!("- R Decrease max. iteration count");
+ eprintln!("- F Increase max. iteration count");
+ eprintln!();
+ eprintln!("- Tab Toggle Julia");
+ eprintln!("- Alt Cycle between fractals");
+ eprintln!();
+ eprintln!("- Up Increase colour range");
+ eprintln!("- Down Decrease colour range");
+ eprintln!();
+ eprintln!("- Z Print centre value (c)");
+ eprintln!("- X Dump frame");
+ eprintln!("- C Render frame");
+ eprintln!();
+
+ let mut event_pump = unsafe { self.video.as_mut().unwrap_unchecked().sdl.event_pump().expect("unable to get event pump") };
+
+ let canvas_size = self.canvas_width as usize * self.canvas_width as usize;
+
+ let mut iter_count_buffer: Vec::<u32> = vec![0x0; canvas_size];
+ let mut square_dist_buffer: Vec::<f32> = vec![0.0; canvas_size];
+
+ let mut image: Vec::<u8> = vec![0x0; canvas_size * 0x3];
+
+ let mut prev_centre_real = self.centre_real.clone();
+ let mut prev_centre_imag = self.centre_imag.clone();
+ let mut prev_zoom = self.zoom.clone();
+ let mut prev_max_iter_count = self.max_iter_count;
+
+ loop {
+ let frame_start = Instant::now();
+
+ if self.poll_events(&mut event_pump) { break }
+
+ if self.do_render {
+ eprint!("rendering...");
+
+ let time_start = Instant::now();
+
+ self.render(&mut iter_count_buffer[..], &mut square_dist_buffer[..], &self.centre_real, &self.centre_imag, &self.zoom, self.max_iter_count);
+ let render_time = time_start.elapsed();
+
+ eprintln!(" rend. {:.3}ms", render_time.as_micros() as f32 / 1000.0);
+
+ prev_centre_real.assign(&self.centre_real);
+ prev_centre_imag.assign(&self.centre_imag);
+ prev_zoom.assign(&self.zoom);
+ prev_max_iter_count = self.max_iter_count;
+
+ self.do_render = false;
+ }
+
+ self.colour(&mut image[..], prev_max_iter_count, &mut iter_count_buffer[..], &mut square_dist_buffer[..]);
+
+ {
+ let feedback_info = FeedbackInfo {
+ prev_centre_real: &prev_centre_real,
+ prev_centre_imag: &prev_centre_imag,
+ prev_zoom: &prev_zoom,
+ next_centre_real: &self.centre_real,
+ next_centre_imag: &self.centre_imag,
+ next_zoom: &self.zoom,
+ };
+
+ unsafe { self.video.as_mut().unwrap_unchecked().draw(&image[..], self.canvas_width, self.scale, Some(&feedback_info)) };
+ }
+
+ if self.do_dump {
+ let path = format!("{}/image.webp", self.dump_path);
+
+ eprintln!("dumping image at \"{path}\"");
+ self.dump(path, &image, self.canvas_width);
+
+ self.do_dump = false;
+ }
+
+ unsafe { self.video.as_ref().unwrap_unchecked().sync(&frame_start) };
+ }
+
+ return 0x0;
+ }
+}
+\ No newline at end of file
diff --git a/source/benoit/benoit/application/poll_events.rs b/source/benoit/benoit/app/poll_events.rs
index ed26b05..2df0c96 100644
--- a/source/benoit/benoit/application/poll_events.rs
+++ b/source/benoit/benoit/app/poll_events.rs
@@ -21,14 +21,14 @@
 If not, see <https://www.gnu.org/licenses/>.
 */
 
-use crate::benoit::application::Application;
+use crate::benoit::app::App;
 
 extern crate sdl2;
 
 use sdl2::EventPump;
 use sdl2::event::Event;
 
-impl Application {
+impl App {
 pub fn poll_events(&mut self, event_pump: &mut EventPump) -> bool {
 for event in event_pump.poll_iter() {
 let quit = match event {
diff --git a/source/benoit/benoit/application/render.rs b/source/benoit/benoit/app/render.rs
index eae4438..aa5ff9b 100644
--- a/source/benoit/benoit/application/render.rs
+++ b/source/benoit/benoit/app/render.rs
@@ -21,8 +21,8 @@
 If not, see <https://www.gnu.org/licenses/>.
 */
 
-use crate::benoit::application::Application;
-use crate::benoit::render_data::RenderData;
+use crate::benoit::app::App;
+use crate::benoit::task::render_data::RenderData;
 
 extern crate rayon;
 extern crate rug;
@@ -30,25 +30,16 @@ extern crate rug;
 use rayon::prelude::*;
 use rug::Float;
 use std::sync::Arc;
-use std::time::Instant;
 
-impl Application {
+impl App {
 pub fn render(&self, iter_count_buffer: &mut [u32], square_dist_buffer: &mut [f32], centre_real: &Float, centre_imag: &Float, zoom: &Float, max_iter_count: u32) {
- eprint!("rendering...");
-
- let time_start = Instant::now();
-
 let row_renderer = self.row_renderer;
 let iterator = self.iterator_function;
 
 let data = Arc::new(RenderData::new(iter_count_buffer, square_dist_buffer, self.canvas_width, centre_real.clone(), centre_imag.clone(), zoom.clone(), max_iter_count));
 
 (0x0..self.canvas_width).into_par_iter().for_each(|row| {
- row_renderer(data.clone(), row, iterator);
+ row_renderer(data.clone(), row as u32, iterator);
 });
-
- let duration = time_start.elapsed();
-
- eprintln!(" done ({}ms)", duration.as_millis());
 }
 }
diff --git a/source/benoit/benoit/application/render_row_julia.rs b/source/benoit/benoit/app/render_row_julia.rs
index 3f4bb0c..5c3cae8 100644
--- a/source/benoit/benoit/application/render_row_julia.rs
+++ b/source/benoit/benoit/app/render_row_julia.rs
@@ -22,17 +22,18 @@
 */
 
 use crate::benoit::PRECISION;
-use crate::benoit::application::Application;
+use crate::benoit::app::App;
 use crate::benoit::iteration::IteratorFunction;
-use crate::benoit::render_data::RenderData;
+use crate::benoit::task::render_data::RenderData;
 
 extern crate rug;
 
 use rug::{Assign, Float};
 use rug::float::Special;
+use rug::ops::NegAssign;
 use std::sync::Arc;
 
-impl Application {
+impl App {
 pub fn render_row_julia(data: Arc<RenderData>, y: u32, iterator: IteratorFunction) {
 let (iter_count_buffer, square_dist_buffer) = unsafe { data.slice(y) };
 
@@ -53,9 +54,9 @@ impl Application {
 // position-determined value that (c) would've had.
 
 let mut za = {
- let tmp0 = Float::with_val(PRECISION, &canvas_width / 2.0);
-
- let mut za = Float::with_val(PRECISION, &x_float - &tmp0);
+ let mut za = Float::with_val(PRECISION, &canvas_width / 2.0);
+ za.neg_assign();
+ za += &x_float;
 za *= 4.0;
 za /= &canvas_width;
 
@@ -63,9 +64,9 @@ impl Application {
 };
 
 let mut zb = {
- let tmp0 = Float::with_val(PRECISION, &canvas_width / 2.0);
-
- let mut zb = Float::with_val(PRECISION, &y_float - &tmp0);
+ let mut zb = Float::with_val(PRECISION, &canvas_width / 2.0);
+ zb.neg_assign();
+ zb += &y_float;
 zb *= 4.0;
 zb /= &canvas_width;
 
diff --git a/source/benoit/benoit/application/render_row_normal.rs b/source/benoit/benoit/app/render_row_normal.rs
index 157c767..381b8bc 100644
--- a/source/benoit/benoit/application/render_row_normal.rs
+++ b/source/benoit/benoit/app/render_row_normal.rs
@@ -22,17 +22,18 @@
 */
 
 use crate::benoit::PRECISION;
-use crate::benoit::application::Application;
+use crate::benoit::app::App;
 use crate::benoit::iteration::IteratorFunction;
-use crate::benoit::render_data::RenderData;
+use crate::benoit::task::render_data::RenderData;
 
 extern crate rug;
 
 use rug::{Assign, Float};
 use rug::float::Special;
+use rug::ops::NegAssign;
 use std::sync::Arc;
 
-impl Application {
+impl App {
 pub fn render_row_normal(data: Arc<RenderData>, y: u32, iterator: IteratorFunction) {
 let (iter_count_buffer, square_dist_buffer) = unsafe { data.slice(y) };
 
@@ -43,9 +44,9 @@ impl Application {
 let y_float = Float::with_val(PRECISION, y);
 
 let ca = {
- let tmp0 = Float::with_val(PRECISION, &canvas_width / 2.0);
-
- let mut ca = Float::with_val(PRECISION, &x_float - &tmp0);
+ let mut ca = Float::with_val(PRECISION, &canvas_width / 2.0);
+ ca.neg_assign();
+ ca += &x_float;
 ca *= 4.0;
 ca /= &canvas_width;
 ca /= &data.zoom;
@@ -55,9 +56,9 @@ impl Application {
 };
 
 let cb = {
- let tmp0 = Float::with_val(PRECISION, &canvas_width / 2.0);
-
- let mut cb = Float::with_val(PRECISION, &y_float - &tmp0);
+ let mut cb = Float::with_val(PRECISION, &canvas_width / 2.0);
+ cb.neg_assign();
+ cb += &y_float;
 cb *= 4.0;
 cb /= &canvas_width;
 cb /= &data.zoom;
@@ -72,7 +73,7 @@ impl Application {
 let mut za_prev = Float::with_val(PRECISION, Special::Nan);
 let mut zb_prev = Float::with_val(PRECISION, Special::Nan);
 
- let mut iter_count: u32 = 0x0;
+ let mut iter_count: u32 = 0x1;
 let mut square_dist;
 while {
 square_dist = Float::with_val(PRECISION, &za * &za + &zb * &zb).to_f32();
diff --git a/source/benoit/benoit/application/run.rs b/source/benoit/benoit/app/run.rs
index b9aa50b..3524cad 100644
--- a/source/benoit/benoit/application/run.rs
+++ b/source/benoit/benoit/app/run.rs
@@ -22,19 +22,17 @@
 */
 
 use crate::benoit::VERSION;
-use crate::benoit::application::Application;
+use crate::benoit::app::App;
 
 extern crate sdl2;
 
-impl Application {
+impl App {
 pub fn run(&mut self) -> i32 {
 println!();
- println!("Benoit {VERSION:X}");
+ println!("Benoit {:X}.{:X}.{:X}", VERSION.major, VERSION.minor, VERSION.patch);
 println!("Copyright 2021, 2023 Gabriel Bjørnager Jensen.");
 println!();
 
- eprintln!("rendering the {}", self.fractal.get_name());
-
 return match self.interactive {
 true => self.r#loop(),
 false => self.animate(),
diff --git a/source/benoit/benoit/application/animate.rs b/source/benoit/benoit/application/animate.rs
deleted file mode 100644
index 117f430..0000000
--- a/source/benoit/benoit/application/animate.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- Copyright 2021, 2023 Gabriel Bjørnager Jensen.
-
- This file is part of Benoit.
-
- Benoit is free software: you can redistribute it
- and/or modify it under the terms of the GNU
- Affero General Public License as published by
- the Free Software Foundation, either version 3
- of the License, or (at your option) any later
- version.
-
- Benoit is distributed in the hope that it will
- be useful, but WITHOUT ANY WARRANTY; without
- even the implied warranty of MERCHANTABILITY or
- FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Affero General Public License for more details.
-
- You should have received a copy of the GNU
- Affero General Public License along with Benoit.
- If not, see <https://www.gnu.org/licenses/>.
-*/
-
-use crate::benoit::PRECISION;
-use crate::benoit::application::Application;
-
-extern crate rug;
-extern crate sdl2;
-
-use rug::Float;
-use rug::ops::PowAssign;
-use std::ops::MulAssign;
-
-impl Application {
- pub fn animate(&self) -> i32 {
- // zoom_start:
- let mut zoom = Float::with_val(PRECISION, 1.0 / 4.0);
-
- let zoom_stop = Float::with_val(PRECISION, &self.zoom);
-
- let zoom_factor = {
- // To get the zoom factor, we first want the 'a'
- // value of the growth function from (0) and to
- // (frame_count) on the x-dimension and from (1) to
- // (zoom) on the y-dimension:
- //
- // a = nroot(x1-x0,y1/y0)
- //
- // but this may be simplified for use with Rug
- // because
- //
- // nroot(a,b) = b^(1/a)
- //
- // making the final equation
- //
- // (x1-x0)^(1/(y1*y0)) = (zoom_stop/zoom_start)^(1/frame_count)
-
- let x_difference = Float::with_val(PRECISION, self.frame_count);
-
- let exponent = Float::with_val(PRECISION, 1.0 / &x_difference);
-
- let mut factor = Float::with_val(PRECISION, &zoom_stop);
- factor /= &zoom;
- factor.pow_assign(exponent);
-
- factor
- };
-
- eprintln!("animating {} frames at {}{:+}i to {:.3} (fac.: {:.3})", self.frame_count, self.centre_real.to_f64(), self.centre_imag.to_f64(), zoom_stop.to_f64(), zoom_factor.to_f64());
-
- let canvas_size = self.canvas_width as usize * self.canvas_width as usize;
-
- let mut iter_count_buffer: Vec::<u32> = vec![0x0; canvas_size];
- let mut square_dist_buffer: Vec::<f32> = vec![0.0; canvas_size];
-
- let mut image: Vec::<u8> = vec![0x0; canvas_size * 0x3];
-
- for frame in 0x0..self.frame_count {
- eprint!("{frame:010}: ");
- self.render(&mut iter_count_buffer[..], &mut square_dist_buffer[..], &self.centre_real, &self.centre_imag, &zoom, self.max_iter_count);
- self.colour(&mut image[..], &mut iter_count_buffer[..], &mut square_dist_buffer[..]);
-
- self.dump(format!("{}/frame{frame:010}.webp", self.dump_path), &image, self.canvas_width);
-
- zoom.mul_assign(&zoom_factor);
- }
-
- return 0x0;
- }
-}
diff --git a/source/benoit/benoit/application/loop.rs b/source/benoit/benoit/application/loop.rs
deleted file mode 100644
index 9c5fc55..0000000
--- a/source/benoit/benoit/application/loop.rs
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- Copyright 2021, 2023 Gabriel Bjørnager Jensen.
-
- This file is part of Benoit.
-
- Benoit is free software: you can redistribute it
- and/or modify it under the terms of the GNU
- Affero General Public License as published by
- the Free Software Foundation, either version 3
- of the License, or (at your option) any later
- version.
-
- Benoit is distributed in the hope that it will
- be useful, but WITHOUT ANY WARRANTY; without
- even the implied warranty of MERCHANTABILITY or
- FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Affero General Public License for more details.
-
- You should have received a copy of the GNU
- Affero General Public License along with Benoit.
- If not, see <https://www.gnu.org/licenses/>.
-*/
-
-use crate::benoit::application::{Application, PreviousPosition};
-
-extern crate sdl2;
-
-impl Application {
- pub fn r#loop(&mut self) -> i32 {
- eprintln!();
- eprintln!("Controls:");
- eprintln!("- W Translate up");
- eprintln!("- A Translate left");
- eprintln!("- S Translate down");
- eprintln!("- D Translate right");
- eprintln!();
- eprintln!("- Q Zoom out");
- eprintln!("- E Zoom in");
- eprintln!();
- eprintln!("- R Decrease max. iteration count");
- eprintln!("- F Increase max. iteration count");
- eprintln!();
- eprintln!("- Tab Toggle Julia");
- eprintln!("- Alt Cycle between fractals");
- eprintln!();
- eprintln!("- Z Print centre value (c)");
- eprintln!("- X Dump frame");
- eprintln!("- C Render frame");
- eprintln!();
-
- let mut event_pump = self.video.as_mut().unwrap().sdl.event_pump().expect("unable to get event pump");
-
- let canvas_size = self.canvas_width as usize * self.canvas_width as usize;
-
- let mut iter_count_buffer: Vec::<u32> = vec![0x0; canvas_size];
- let mut square_dist_buffer: Vec::<f32> = vec![0.0; canvas_size];
-
- let mut image: Vec::<u8> = vec![0x0; canvas_size * 0x3];
-
- let mut previous_position = PreviousPosition {
- centre_real: self.centre_real.clone(),
- centre_imag: self.centre_imag.clone(),
- zoom: self.zoom.clone(),
- };
-
- loop {
- if self.poll_events(&mut event_pump) { break }
-
- if self.do_render {
- self.render(&mut iter_count_buffer[..], &mut square_dist_buffer[..], &self.centre_real, &self.centre_imag, &self.zoom, self.max_iter_count);
- self.colour(&mut image[..], &iter_count_buffer[..], &square_dist_buffer[..]);
-
- previous_position = PreviousPosition {
- centre_real: self.centre_real.clone(),
- centre_imag: self.centre_imag.clone(),
- zoom: self.zoom.clone(),
- };
-
- self.do_render = false;
- }
-
- self.draw(&image[..], &previous_position);
-
- if self.do_dump {
- let path = format!("{}/image.webp", self.dump_path);
-
- eprintln!("dumping image at \"{path}\"");
- self.dump(path, &image, self.canvas_width);
-
- self.do_dump = false;
- }
- }
-
- return 0x0;
- }
-}
-\ No newline at end of file
diff --git a/source/benoit/benoit/configuration.rs b/source/benoit/benoit/configuration.rs
index ca36400..f472f62 100644
--- a/source/benoit/benoit/configuration.rs
+++ b/source/benoit/benoit/configuration.rs
@@ -45,6 +45,8 @@ pub struct Configuration {
 pub zoom: Float,
 pub max_iter_count: u32,
 
+ pub colour_range: f32,
+
 pub dump_path: String,
 
 pub interactive: bool,
diff --git a/source/benoit/benoit/configuration/default.rs b/source/benoit/benoit/configuration/default.rs
index 1d59786..46373cd 100644
--- a/source/benoit/benoit/configuration/default.rs
+++ b/source/benoit/benoit/configuration/default.rs
@@ -46,6 +46,8 @@ impl Configuration {
 zoom: Float::with_val(PRECISION, 1.0),
 max_iter_count: 0x100,
 
+ colour_range: 16.0,
+
 dump_path: "./render/".to_string(),
 
 interactive: true,
diff --git a/source/benoit/benoit/configuration/load.rs b/source/benoit/benoit/configuration/load.rs
index b06cd71..711c890 100644
--- a/source/benoit/benoit/configuration/load.rs
+++ b/source/benoit/benoit/configuration/load.rs
@@ -43,14 +43,20 @@ impl Configuration {
 
 let configuration_text = match read(path) {
 Ok(content) => String::from_utf8_lossy(&content).to_string(),
- Err(..) => {
- eprintln!("unable to read configuration file");
- return configuration;
- },
+ Err(..) => panic!("unable to read configuration file"),
 };
 
 let configuration_table = Table::from_str(configuration_text.as_str()).expect("unable to parse configuration");
 
+ let get_boolean = |buffer: &mut bool, table: &Table, name: &str| {
+ if !table.contains_key(name) { return }
+
+ match &configuration_table[name] {
+ Value::Boolean(value) => *buffer = *value,
+ _ => panic!("mismatched type of {name}"),
+ };
+ };
+
 let get_integer = |buffer: &mut u32, table: &Table, name: &str| {
 if !table.contains_key(name) { return }
 
@@ -96,6 +102,8 @@ impl Configuration {
 configuration.fractal
 };
 
+ get_boolean(&mut configuration.julia, &configuration_table, "julia");
+
 get_integer(&mut configuration.canvas_width, &configuration_table, "canvas_width");
 get_integer(&mut configuration.scale, &configuration_table, "scale");
 get_integer(&mut configuration.frame_count, &configuration_table, "frame_count");
@@ -105,6 +113,18 @@ impl Configuration {
 get_float( &mut configuration.zoom, &configuration_table, "zoom");
 get_integer(&mut configuration.max_iter_count, &configuration_table, "maximum_iteration_count");
 
+ // We allow thread counts of zero as those signal
+ // automatic thread count detection.
+ if configuration.canvas_width == 0x0 {
+ panic!("only non-zero values for canvas_width are allowed");
+ } else if configuration.scale == 0x0 {
+ panic!("only non-zero values for scale are allowed");
+ } else if configuration.frame_count == 0x0 {
+ panic!("only non-zero values for frame_count are allowed");
+ } else if configuration.max_iter_count == 0x0 {
+ panic!("only non-zero values for maximum_iteration_count are allowed");
+ }
+
 return configuration;
 }
 }
diff --git a/source/benoit/benoit/iteration/iterate_burning_ship.rs b/source/benoit/benoit/iteration/iterate_burning_ship.rs
index 89d2ec1..038367f 100644
--- a/source/benoit/benoit/iteration/iterate_burning_ship.rs
+++ b/source/benoit/benoit/iteration/iterate_burning_ship.rs
@@ -30,7 +30,7 @@ pub fn iterate_burning_ship(za: &mut Float, zb: &mut Float, ca: &Float, cb: &Flo
 // iteration - the real and imaginary parts of (z)
 // are made absolute:
 //
- // z(n+1) = (abs(Re(z(n)))+i*abs(Im(z(n))))^2+c
+ // z(n+1) = (abs(Re(z(n)))+i*abs(Im(z(n))))^2+c.
 
 za.abs_mut();
 zb.abs_mut();
diff --git a/source/benoit/benoit/iteration/iterate_mandelbrot.rs b/source/benoit/benoit/iteration/iterate_mandelbrot.rs
index 6be612c..9037326 100644
--- a/source/benoit/benoit/iteration/iterate_mandelbrot.rs
+++ b/source/benoit/benoit/iteration/iterate_mandelbrot.rs
@@ -34,14 +34,14 @@ pub fn iterate_mandelbrot(za: &mut Float, zb: &mut Float, ca: &Float, cb: &Float
 //
 // stays bounded: I.e. the absolute value of (z) stays bounded:
 //
- // abs(z) = sqrt(Re(z)^2+Im(z)^2) <= 2^2 = 4
+ // abs(z) = sqrt(Re(z)^2+Im(z)^2) <= 2^2 = 4.
 
 let za_temporary = za.clone();
 
 // We can calculate the square of a complex number
 // as:
 //
- // (a+bi)^2 = (a+bi)(a+bi) = a^2+abi+abi-b^2 = a^2-b^2+2abi
+ // (a+bi)^2 = (a+bi)(a+bi) = a^2+abi+abi-b^2 = a^2-b^2+2abi.
 
 za.square_mut();
 *za -= &*zb * &*zb;
diff --git a/source/benoit/benoit/iteration/iterate_tricorn.rs b/source/benoit/benoit/iteration/iterate_tricorn.rs
index 2edea53..3d1bfb9 100644
--- a/source/benoit/benoit/iteration/iterate_tricorn.rs
+++ b/source/benoit/benoit/iteration/iterate_tricorn.rs
@@ -30,7 +30,7 @@ pub fn iterate_tricorn(za: &mut Float, zb: &mut Float, ca: &Float, cb: &Float) {
 // Mandelbrot Set in that the conjugate of (z) is
 // used instead of just (z):
 //
- // z(n+1) = (Re(z(n))-Im(z(n)))^2+c
+ // z(n+1) = (Re(z(n))-Im(z(n)))^2+c.
 
 let za_temporary = za.clone();
 
@@ -42,7 +42,7 @@ pub fn iterate_tricorn(za: &mut Float, zb: &mut Float, ca: &Float, cb: &Float) {
 // We can negate the value by multiplying with
 // (-1). A multiplication can be saved, as
 //
- // a*2*(-1) = a*(-2)
+ // a*2*(-1) = a*(-2).
 //
 // Thus, we may combine these two multiplications.
 *zb *= -2.0;
diff --git a/source/benoit/benoit/render_data/sync.rs b/source/benoit/benoit/task.rs
index 454ebb1..ee53b52 100644
--- a/source/benoit/benoit/render_data/sync.rs
+++ b/source/benoit/benoit/task.rs
@@ -21,6 +21,5 @@
 If not, see <https://www.gnu.org/licenses/>.
 */
 
-use crate::benoit::render_data::RenderData;
-
-unsafe impl Sync for RenderData {}
+pub mod colour_data;
+pub mod render_data;
diff --git a/source/benoit/benoit/task/colour_data.rs b/source/benoit/benoit/task/colour_data.rs
new file mode 100644
index 0000000..77d561d
--- /dev/null
+++ b/source/benoit/benoit/task/colour_data.rs
@@ -0,0 +1,40 @@
+/*
+ Copyright 2021, 2023 Gabriel Bjørnager Jensen.
+
+ This file is part of Benoit.
+
+ Benoit is free software: you can redistribute it
+ and/or modify it under the terms of the GNU
+ Affero General Public License as published by
+ the Free Software Foundation, either version 3
+ of the License, or (at your option) any later
+ version.
+
+ Benoit is distributed in the hope that it will
+ be useful, but WITHOUT ANY WARRANTY; without
+ even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Affero General Public License for more details.
+
+ You should have received a copy of the GNU
+ Affero General Public License along with Benoit.
+ If not, see <https://www.gnu.org/licenses/>.
+*/
+
+pub mod new;
+pub mod slice;
+
+pub struct ColourData {
+ pub canvas_width: u32,
+
+ pub max_iter_count: u32,
+ pub colour_range: f32,
+
+ iter_count_buffer: *const u32,
+ square_dist_buffer: *const f32,
+
+ image: *mut u8,
+}
+
+unsafe impl Send for ColourData {}
+unsafe impl Sync for ColourData {}
diff --git a/source/benoit/benoit/task/colour_data/new.rs b/source/benoit/benoit/task/colour_data/new.rs
new file mode 100644
index 0000000..2707018
--- /dev/null
+++ b/source/benoit/benoit/task/colour_data/new.rs
@@ -0,0 +1,40 @@
+/*
+ Copyright 2021, 2023 Gabriel Bjørnager Jensen.
+
+ This file is part of Benoit.
+
+ Benoit is free software: you can redistribute it
+ and/or modify it under the terms of the GNU
+ Affero General Public License as published by
+ the Free Software Foundation, either version 3
+ of the License, or (at your option) any later
+ version.
+
+ Benoit is distributed in the hope that it will
+ be useful, but WITHOUT ANY WARRANTY; without
+ even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Affero General Public License for more details.
+
+ You should have received a copy of the GNU
+ Affero General Public License along with Benoit.
+ If not, see <https://www.gnu.org/licenses/>.
+*/
+
+use crate::benoit::task::colour_data::ColourData;
+
+impl ColourData {
+ pub fn new(image: &mut [u8], canvas_width: u32, max_iter_count: u32, colour_range: f32, iter_count_buffer: &[u32], square_dist_buffer: &[f32]) -> ColourData {
+ return ColourData {
+ canvas_width: canvas_width,
+
+ max_iter_count: max_iter_count,
+ colour_range: colour_range,
+
+ iter_count_buffer: iter_count_buffer.as_ptr(),
+ square_dist_buffer: square_dist_buffer.as_ptr(),
+
+ image: image.as_mut_ptr(),
+ };
+ }
+}
diff --git a/source/benoit/benoit/task/colour_data/slice.rs b/source/benoit/benoit/task/colour_data/slice.rs
new file mode 100644
index 0000000..975eda2
--- /dev/null
+++ b/source/benoit/benoit/task/colour_data/slice.rs
@@ -0,0 +1,41 @@
+/*
+ Copyright 2021, 2023 Gabriel Bjørnager Jensen.
+
+ This file is part of Benoit.
+
+ Benoit is free software: you can redistribute it
+ and/or modify it under the terms of the GNU
+ Affero General Public License as published by
+ the Free Software Foundation, either version 3
+ of the License, or (at your option) any later
+ version.
+
+ Benoit is distributed in the hope that it will
+ be useful, but WITHOUT ANY WARRANTY; without
+ even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Affero General Public License for more details.
+
+ You should have received a copy of the GNU
+ Affero General Public License along with Benoit.
+ If not, see <https://www.gnu.org/licenses/>.
+*/
+
+use crate::benoit::task::colour_data::ColourData;
+
+use std::slice::{from_raw_parts, from_raw_parts_mut};
+
+impl ColourData {
+ pub unsafe fn slice(&self, row: u32) -> (&[u32], &[f32], &mut [u8]) {
+ let offset = row as isize * self.canvas_width as isize;
+
+ let iter_count = from_raw_parts(self.iter_count_buffer.offset(offset), self.canvas_width as usize);
+ let dist = from_raw_parts(self.square_dist_buffer.offset(offset), self.canvas_width as usize);
+
+ let offset = offset * 0x3;
+
+ let image = from_raw_parts_mut(self.image.offset(offset), self.canvas_width as usize * 0x3);
+
+ return (iter_count, dist, image);
+ }
+}
diff --git a/source/benoit/benoit/render_data.rs b/source/benoit/benoit/task/render_data.rs
index 5546e16..e73b514 100644
--- a/source/benoit/benoit/render_data.rs
+++ b/source/benoit/benoit/task/render_data.rs
@@ -26,9 +26,7 @@ extern crate rug;
 use rug::Float;
 
 pub mod new;
-pub mod send;
 pub mod slice;
-pub mod sync;
 
 pub struct RenderData {
 pub canvas_width: u32,
@@ -42,3 +40,6 @@ pub struct RenderData {
 iter_count_buffer: *mut u32,
 square_dist_buffer: *mut f32,
 }
+
+unsafe impl Send for RenderData {}
+unsafe impl Sync for RenderData {}
diff --git a/source/benoit/benoit/render_data/new.rs b/source/benoit/benoit/task/render_data/new.rs
index 4e3f28d..d9509b5 100644
--- a/source/benoit/benoit/render_data/new.rs
+++ b/source/benoit/benoit/task/render_data/new.rs
@@ -21,7 +21,7 @@
 If not, see <https://www.gnu.org/licenses/>.
 */
 
-use crate::benoit::render_data::RenderData;
+use crate::benoit::task::render_data::RenderData;
 
 extern crate rug;
 
@@ -29,9 +29,6 @@ use rug::Float;
 
 impl RenderData {
 pub fn new(iter_count_buffer: &mut [u32], square_dist_buffer: &mut [f32], canvas_width: u32, centre_real: Float, centre_imag: Float, zoom: Float, max_iter_count: u32) -> RenderData {
- let iter_count_buffer_pointer = iter_count_buffer.as_mut_ptr();
- let square_dist_buffer_pointer = square_dist_buffer.as_mut_ptr();
-
 return RenderData {
 canvas_width: canvas_width,
 
@@ -41,8 +38,8 @@ impl RenderData {
 
 max_iter_count: max_iter_count,
 
- iter_count_buffer: iter_count_buffer_pointer,
- square_dist_buffer: square_dist_buffer_pointer,
+ iter_count_buffer: iter_count_buffer.as_mut_ptr(),
+ square_dist_buffer: square_dist_buffer.as_mut_ptr(),
 };
 }
 }
diff --git a/source/benoit/benoit/render_data/slice.rs b/source/benoit/benoit/task/render_data/slice.rs
index ab12d4f..d2660ee 100644
--- a/source/benoit/benoit/render_data/slice.rs
+++ b/source/benoit/benoit/task/render_data/slice.rs
@@ -21,16 +21,17 @@
 If not, see <https://www.gnu.org/licenses/>.
 */
 
-use crate::benoit::render_data::RenderData;
+use crate::benoit::task::render_data::RenderData;
 
 use std::slice::from_raw_parts_mut;
 
 impl RenderData {
 pub unsafe fn slice(&self, row: u32) -> (&mut [u32], &mut [f32]) {
 let offset = row as isize * self.canvas_width as isize;
+
 let iter_count = from_raw_parts_mut(self.iter_count_buffer.offset(offset), self.canvas_width as usize);
- let distance = from_raw_parts_mut(self.square_dist_buffer.offset(offset), self.canvas_width as usize);
+ let dist = from_raw_parts_mut(self.square_dist_buffer.offset(offset), self.canvas_width as usize);
 
- return (iter_count, distance);
+ return (iter_count, dist);
 }
 }
diff --git a/source/benoit/benoit/video.rs b/source/benoit/benoit/video.rs
index 2147b27..af060fe 100644
--- a/source/benoit/benoit/video.rs
+++ b/source/benoit/benoit/video.rs
@@ -23,12 +23,15 @@
 
 extern crate sdl2;
 
-use sdl2::Sdl;
+use sdl2::{Sdl, VideoSubsystem};
 use sdl2::render::WindowCanvas;
 
+pub mod draw;
 pub mod initialise;
+pub mod sync;
 
 pub struct Video {
- pub sdl: Sdl,
- pub canvas: WindowCanvas,
+ pub sdl: Sdl,
+ pub sdl_video: VideoSubsystem,
+ pub canvas: WindowCanvas,
 }
diff --git a/source/benoit/benoit/application/draw.rs b/source/benoit/benoit/video/draw.rs
index 31ba470..bd5a837 100644
--- a/source/benoit/benoit/application/draw.rs
+++ b/source/benoit/benoit/video/draw.rs
@@ -21,8 +21,8 @@
 If not, see <https://www.gnu.org/licenses/>.
 */
 
-use crate::benoit::PRECISION;
-use crate::benoit::application::{Application, PreviousPosition};
+use crate::benoit::{FeedbackInfo, PRECISION};
+use crate::benoit::video::Video;
 
 extern crate rug;
 extern crate sdl2;
@@ -31,13 +31,13 @@ use rug::Float;
 use sdl2::pixels::Color;
 use sdl2::rect::Rect;
 
-impl Application {
- pub fn draw(&mut self, image: &[u8], previous_position: &PreviousPosition) {
- let canvas_size = self.canvas_width * self.canvas_width;
+impl Video {
+ pub fn draw(&mut self, image: &[u8], canvas_width: u32, scale: u32, feedback_info: Option<&FeedbackInfo>) {
+ let canvas_size = canvas_width * canvas_width;
 
 for pixel in 0x0..canvas_size {
- let y = pixel as u32 / self.canvas_width;
- let x = pixel as u32 - y * self.canvas_width;
+ let y = pixel as u32 / canvas_width;
+ let x = pixel as u32 - y * canvas_width;
 
 let colour = {
 let red = image[pixel as usize * 0x3];
@@ -48,27 +48,29 @@ impl Application {
 };
 
 let rectangle = Rect::new(
- (x * self.scale) as i32,
- (y * self.scale) as i32,
- self.scale,
- self.scale
+ (x * scale) as i32,
+ (y * scale) as i32,
+ scale,
+ scale
 );
 
- self.video.as_mut().unwrap().canvas.set_draw_color(colour);
- self.video.as_mut().unwrap().canvas.fill_rects(&[rectangle]).unwrap();
+ self.canvas.set_draw_color(colour);
+ self.canvas.fill_rects(&[rectangle]).unwrap();
 }
 
- if !self.julia {
+ if feedback_info.is_some() {
+ let feedback_info = unsafe { feedback_info.unwrap_unchecked() };
+
 let canvas_width = {
- let mut canvas_width = Float::with_val(PRECISION, self.canvas_width);
- canvas_width *= self.scale;
+ let mut canvas_width = Float::with_val(PRECISION, canvas_width);
+ canvas_width *= scale;
 
 canvas_width
 };
 
 let viewport = {
 let ((offset_x, offset_y), width) = {
- let zoom_ratio = Float::with_val(PRECISION, &self.zoom / &previous_position.zoom);
+ let zoom_ratio = Float::with_val(PRECISION, feedback_info.next_zoom / feedback_info.prev_zoom);
 
 let mut width = Float::with_val(PRECISION, 1.0 / &zoom_ratio);
 
@@ -76,17 +78,17 @@ impl Application {
 // inverted vertical axis compared to those of
 // SDL's coordinate system.
 
- let mut offset_x = self.centre_real.clone();
- let mut offset_y = Float::with_val(PRECISION, -&self.centre_imag);
+ let mut offset_x = feedback_info.next_centre_real.clone();
+ let mut offset_y = Float::with_val(PRECISION, -feedback_info.next_centre_imag);
 
- offset_x -= &previous_position.centre_real;
- offset_y += &previous_position.centre_imag;
+ offset_x -= feedback_info.prev_centre_real;
+ offset_y += feedback_info.prev_centre_imag;
 
 offset_x /= 4.0;
 offset_y /= 4.0;
 
- offset_x *= &previous_position.zoom;
- offset_y *= &previous_position.zoom;
+ offset_x *= feedback_info.prev_zoom;
+ offset_y *= feedback_info.prev_zoom;
 
 let mut zoom_offset = Float::with_val(PRECISION, 1.0 - &width);
 zoom_offset /= 2.0;
@@ -109,13 +111,13 @@ impl Application {
 )
 };
 
- self.video.as_mut().unwrap().canvas.set_draw_color(Color::RGBA(0x0, 0x0, 0x0, 0x3F));
- self.video.as_mut().unwrap().canvas.fill_rects(&[viewport]).unwrap();
+ self.canvas.set_draw_color(Color::RGBA(0x0, 0x0, 0x0, 0x3F));
+ self.canvas.fill_rects(&[viewport]).unwrap();
 
- self.video.as_mut().unwrap().canvas.set_draw_color(Color::RGB(0xFF, 0xFF, 0xFF));
- self.video.as_mut().unwrap().canvas.draw_rects(&[viewport]).unwrap();
+ self.canvas.set_draw_color(Color::RGB(0xFF, 0xFF, 0xFF));
+ self.canvas.draw_rects(&[viewport]).unwrap();
 }
 
- self.video.as_mut().unwrap().canvas.present();
+ self.canvas.present();
 }
 }
diff --git a/source/benoit/benoit/video/initialise.rs b/source/benoit/benoit/video/initialise.rs
index 40bc68d..f97ae8b 100644
--- a/source/benoit/benoit/video/initialise.rs
+++ b/source/benoit/benoit/video/initialise.rs
@@ -33,15 +33,16 @@ impl Video {
 let sdl = sdl2::init().expect("unable to initialise sdl2");
 let sdl_video = sdl.video().expect("unable to initialise video");
 
- let window = sdl_video.window(format!("Benoit {VERSION:X}").as_str(), canvas_width * scale, canvas_width * scale).position_centered().build().expect("unable to open window");
+ let window = sdl_video.window(format!("Benoit {:X}.{:X}.{:X}", VERSION.major, VERSION.minor, VERSION.patch).as_str(), canvas_width * scale, canvas_width * scale).position_centered().build().expect("unable to open window");
 
 let mut canvas = window.into_canvas().build().expect("unable to create canvas");
 
 canvas.set_blend_mode(BlendMode::Blend);
 
 return Video {
- sdl: sdl,
- canvas: canvas,
+ sdl: sdl,
+ sdl_video: sdl_video,
+ canvas: canvas,
 };
 }
 }
diff --git a/source/benoit/benoit/video/sync.rs b/source/benoit/benoit/video/sync.rs
new file mode 100644
index 0000000..c8c016a
--- /dev/null
+++ b/source/benoit/benoit/video/sync.rs
@@ -0,0 +1,46 @@
+/*
+ Copyright 2021, 2023 Gabriel Bjørnager Jensen.
+
+ This file is part of Benoit.
+
+ Benoit is free software: you can redistribute it
+ and/or modify it under the terms of the GNU
+ Affero General Public License as published by
+ the Free Software Foundation, either version 3
+ of the License, or (at your option) any later
+ version.
+
+ Benoit is distributed in the hope that it will
+ be useful, but WITHOUT ANY WARRANTY; without
+ even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Affero General Public License for more details.
+
+ You should have received a copy of the GNU
+ Affero General Public License along with Benoit.
+ If not, see <https://www.gnu.org/licenses/>.
+*/
+
+use crate::benoit::video::Video;
+
+use std::thread::sleep;
+use std::time::{Duration, Instant};
+
+impl Video {
+ pub fn sync(&self, frame_start: &Instant) {
+ let frame_duration = {
+ let index = self.canvas.window().display_index().expect("unable to get display index");
+
+ let mode = self.sdl_video.current_display_mode(index).expect("unable to get display mode");
+
+ Duration::from_secs(0x1) / mode.refresh_rate as u32
+ };
+
+ let remaining = match frame_duration.checked_sub(frame_start.elapsed()) {
+ Some(value) => value,
+ None => Duration::from_secs(0x0),
+ };
+
+ sleep(remaining);
+ }
+}
+\ No newline at end of file
diff --git a/source/benoit/main.rs b/source/benoit/main.rs
index ec24cbb..3716309 100644
--- a/source/benoit/main.rs
+++ b/source/benoit/main.rs
@@ -23,15 +23,15 @@
 
 mod benoit;
 
-use benoit::application::Application;
+use benoit::app::App;
 
 use std::mem::drop;
 use std::process::exit;
 
 fn main() {
- let mut application = Application::initialise();
- let code = application.run();
+ let mut app = App::initialise();
+ let code = app.run();
 
- drop(application);
+ drop(app);
 exit(code);
 }