Struct RenderConfig 

pub struct RenderConfig<'a> {
    pub image_size: RenderSize,
    pub world_to_model: Matrix4<f32>,
    pub tile_sizes: Option<TileSizes>,
    pub threads: Option<&'a ThreadPool>,
    pub cancel: CancelToken,
}

Settings for 3D rendering

Fields

image_size: RenderSize

Render size

The resulting image will have the given width and height; depth sets the number of voxels to evaluate within each pixel of the image (stacked into a column going into the screen).

world_to_model: Matrix4<f32>

World-to-model transform

tile_sizes: Option<TileSizes>

Tile sizes to use during evaluation.

If this is None, then evaluation will use RenderHints::tile_sizes_3d to select based on evaluator type.

threads: Option<&'a ThreadPool>

Thread pool to use for rendering

If this is None, then rendering is done in a single thread; otherwise, the provided pool is used.

cancel: CancelToken

Token to cancel rendering

Implementations

impl RenderConfig<'_>

pub fn from_size(image_size: RenderSize) -> Self

Constructs a RenderConfig with reasonable defaults

This config uses the global thread pool for rendering, has an identity transform matrix, and uses the render hints to choose tile sizes.

To build a somewhat-customized RenderConfig, it’s typical to use this as the base object, then replace individual fields:

let cfg = RenderConfig {
    threads: None, // override field
    ..RenderConfig::from_size(1024.into()) // base
};

pub fn run<F: Function + RenderHints>( &self, shape: BoundShape<'_, F, f32>, ) -> Option<Image>

Render a shape in 3D using this configuration

In the resulting image, saturated pixels (i.e. pixels in the image which are fully occupied up to the camera) are represented with depth = self.image_size.depth() and a normal of [0, 0, 1].

pub fn mat(&self) -> Matrix4<f32>

Returns the combined screen-to-model transform matrix

Trait Implementations

impl RenderSize for RenderConfig<'_>

fn width(&self) -> u32

Width of the render, in voxels or pixels

fn height(&self) -> u32

Height of the render, in voxels or pixels