Struct LibreDR

pub struct LibreDR {
    connection: Connection,
}

Rust interface for LibreDR client

Fields

connection: Connection

Implementations

impl LibreDR

pub async fn new(connect: String, unix: bool, tls: bool) -> Result<Self>

Construct LibreDR by connecting to LibreDR server
Return Error if connection failed\

Examples

async {
  let client_tcp = LibreDR::new(String::from("127.0.0.1:9001"), false, false).await?;
  let client_unix = LibreDR::new(String::from("/var/run/libredr_client.sock"), true, false).await?;
}

async fn try_recv_msg_response_data( &mut self, data_cache: &DataCache, ) -> Result<Message>

Receive messages, response RequestData task, until receive a different task

pub async fn ray_tracing_forward( &mut self, geometry: &Geometry, geometry_data_cache: &DataCache, ray: ArrayD<f32>, texture: Array3<f32>, envmap: Array4<f32>, sample_per_pixel: (usize, usize), max_bounce: (usize, usize, usize, usize), switches: (u8, u8, u8, u8), clip_near: (f32, f32, f32), camera_space: bool, requires_grad: bool, srand: i32, low_discrepancy: u32, ) -> Result<ArrayD<f32>>

Create a RequestRayTracingForward task and wait for response

Arguments

• ray - ray parameters
  • if camera_space is false 18 * image_shape
    • including ray position 9 * image_shape
    • including ray direction 9 * image_shape
  • if camera_space is true, add another (1 + 14) channels
    • including ray depth 1 * image_shape (if depth <= 0, treat as hit miss)
    • including ray material 14 * image_shape
• texture - (3 + 3 + 3 + 1 + 3 + 1) * texture_resolution * texture_resolution (must be square image)
  • including normal + diffuse + specular + roughness + intensity + window
• envmap - 3 * 6 * envmap_resolution * envmap_resolution
  • (must be box unwrapped 6 square images)
• sample_per_pixel - sample_per_pixel_forward, sample_per_pixel_backward
• max_bounce - max_bounce_forward, max_bounce_backward, max_bounce_low_discrepancy, skip_bounce
• switches - tuple of 4 switches to determine hit miss and reflection behavior
  • render::MISS_* - determine how to deal with ray hit miss
    • common::render::MISS_NONE
    • common::render::MISS_ENVMAP
  • render::REFLECTION_NORMAL_* - determine how to get surface normal
    • common::render::REFLECTION_NORMAL_FACE
    • common::render::REFLECTION_NORMAL_VERTEX
    • common::render::REFLECTION_NORMAL_TEXTURE
  • render::REFLECTION_DIFFUSE_* - determine diffuse reflection model
    • common::render::REFLECTION_DIFFUSE_NONE
    • common::render::REFLECTION_DIFFUSE_LAMBERTIAN
  • render::REFLECTION_SPECULAR_* - determine specular reflection model
    • common::render::REFLECTION_SPECULAR_NONE
    • common::render::REFLECTION_SPECULAR_PHONG
    • common::render::REFLECTION_SPECULAR_BLINN_PHONG
    • common::render::REFLECTION_SPECULAR_TORRANCE_SPARROW_PHONG
    • common::render::REFLECTION_SPECULAR_TORRANCE_SPARROW_BLINN_PHONG
    • common::render::REFLECTION_SPECULAR_TORRANCE_SPARROW_BECKMANN
• clip_near - clip near distance for camera
  • clip_near can be a single float number (same for all bounces),
  • or tuple of 3 float numbers (first bounce, second bounce, and other bounces)
• camera_space - if true, the first bounce uses the depth and material given by the ray
• requires_grad - if true, worker will save intermediate data, the next task must be ray_tracing_backward
• srand - random seed
  • if srand >= 0, the same random seed is used for every pixel
  • if srand < 0, use different seed for each pixel
• low_discrepancy - (optional) start id of Halton low discrepancy sequence.
  • The default value is the same as sample_per_pixel_forward.
  • if combine multiple rendered images to reduce noise, this value can be set to:
    1 * sample_per_pixel_forward, 2 * sample_per_pixel_forward, 3 * sample_per_pixel_forward, …

Return

Return shape will be,

• if camera_space is true
  • render image 3 * image_shape
• if camera_space is false, add another
  • ray texture coordinate 2 * image_shape
  • ray depth (Euclidean distance) 1 * image_shape
  • ray normal 3 * image_shape

pub async fn ray_tracing_backward( &mut self, d_ray: ArrayD<f32>, ) -> Result<(Array3<f32>, Array4<f32>, Option<ArrayD<f32>>)>

Create a RequestRayTracingBackward task and wait for response.

Must be called consecutive to a RequestRayTracingForward task with requires_grad set to true.
To create multiple RequestRayTracingForward tasks and backward together, multiple client connections are required.

Arguments

• d_ray - gradient of image 3 * image_shape (must ensure same image_shape as RequestRayTracingForward)

Return

Return shape will be,

• if camera_space is false for RequestRayTracingForward task
  • 1st return value (3 + 3 + 3 + 1 + 3 + 1) * texture_resolution * texture_resolution
    • (same texture_resolution as RequestRayTracingForward)
    • including d_normal + d_diffuse + d_specular + d_roughness + d_intensity + d_window
  • 2nd return value 3 * 6 * envmap_resolution * envmap_resolution
    • (same envmap_resolution as RequestRayTracingForward)
    • including d_envmap
• if camera_space is true for RequestRayTracingForward task, add another
  • 3rd return value 14 * image_shape (same shape as RequestRayTracingForward)
    • including d_ray_texture

pub async fn close(&mut self) -> Result<()>

Send Message::Close to server to close cleanly

Trait Implementations

impl Debug for LibreDR

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.