Rustic Zen:

Photon Garden Raytracer Impementation. Rust Impementation of Zenphoton

This project is hosted on Gitlab with a mirror to Github. Main Repo: https://gitlab.com/IGBC/rustic-zen/

Rustic Zen renders artworks from a scene definition by simulating individual photons and tracing their path as they bounce through a 2D. space.

Photons are generated by Lights and interact with Objects. Each interaction results in either the photon being absorbed, or being allowed to continue with a new direction, based on the rules defined by the Object's Material.

What this library Provides:

This library holds only the rendering framework and models for defining a scene. Functionality for defining a scene, i.e. generative and animation algorithms are not provided here. The focus of Rustic-Zen is providing the raytrace algorithms for rendering a static scene.

Rustic-Zen provides a single basic shader, for backwards compatiblity with prior art. It is expected that dedicated library users will use the exposed Material trait to create your own shaders.

Example usage:

extern crate rustic_zen;
extern crate png;

use rustic_zen::prelude::*;
use rustic_zen::material::hqz_legacy;
// To use encoder.set()
use png::HasParameters;

fn main() {
    // Set up constants.
    let width: f64 = 1920.0;
    let height: f64 = 1080.0;
    
    // Build a basic Material
    let m = hqz_legacy(0.3, 0.3, 0.3);
    
    // Build a basic Object
    let o = Object::line_from_points((0.0,(height * 0.75)), (width, (height * 0.75)), m);

    // Build a basic Light
    let l = Light{
        power: 1.0.into(),
        x: (width / 2.0).into(),
        y: (height / 2.0).into(),
        polar_angle: 0.0.into(),
        polar_distance: 0.0.into(),
        ray_angle: (360.0, 0.0).into(), // creates a linear range
        wavelength: Sampler::new_blackbody(4500.0),
    };
    // Construct a renderer object and add the light and object to it.
    let s = Scene::new(width as usize, height as usize).with_object(o).with_light(l);
    // Render Image
    println!("Tracing Rays");
    let (rays, image) = s.render(RenderConstraint::TimeMS(1000), 1);
    // this call should probably be more like 5000 - 15000 ms and use your number of threads,
    // but this example is run by various CI tools, and tests can't take too long.
    // Output the Image as a Vec<u8>
    println!("Serializing!");
    let data = image.to_rgb8(rays, 0.7, 1.2);
    
    let mut encoder = png::Encoder::new(w, width as u32, height as u32);
    encoder.set(png::ColorType::RGB).set(png::BitDepth::Eight);
    let mut writer = encoder.write_header().unwrap();
    writer.write_image_data(&data).unwrap();
}

Example Output:

example output

Versioning:

In alpha version numbers are 0.0.* every change will be breaking In beta version numbers will be 0.*.* every minor release will be breaking Post 1.0.0 semantic versioning will be used

Licence

This project and all artworks created by the examples are copyright Lauren Brown (SEGFAULT), and are licenced under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Public License