Re-enable path-tracer.

In Rust-GPU#313 I disabled all the code relying on OptiX. I subsequently learned
that the path-tracer's use of OptiX is optional. This commit re-enables
it, and makes the optionality (via features) more strict so it works on
systems without OptiX.

Note: If you were rewriting this from scratch you'd probably group
together the OptiX-dependent code pieces more nicely, but I just
scattered `#[cfg(feature = "optix")]` attributes around to keep the
modifications as small as possible.

Author: nnethercote

Cargo.lock

@@ -19,7 +19,8 @@ members = [
   "crates/rustc_codegen_nvvm_macros",
 
   # These crates that rely on OptiX are disabled because OptiX is less important than CUDA and the
-  # OptiX SDK is a pain to install.
+  # OptiX SDK is a pain to install. The `path-tracer` crates are an exception because their OptiX
+  # use is behind a feature, which is off by default.
   # "crates/optix",
   # "crates/optix_device",
   # "crates/optix_device_macros",
@@ -30,8 +31,8 @@ members = [
   # "crates/optix/examples/ex03_window",
   # "crates/optix/examples/ex04_mesh",
   # "crates/optix/examples/ex04_mesh/kernels",
-  # "crates/optix/examples/path_tracer",
-  # "crates/optix/examples/path_tracer/kernels",
+  "crates/optix/examples/path_tracer",
+  "crates/optix/examples/path_tracer/kernels",
 
   "examples/gemm",
   "examples/gemm/kernels",

Cargo.toml

@@ -10,7 +10,7 @@ cust = { version = "0.3", path = "../../../cust", features = ["impl_glam"] }
 image = "0.25.5"
 path-tracer-kernels = { path = "kernels" }
 gpu_rand = { version = "0.1", path = "../../../gpu_rand" }
-optix = { version = "0.1", path = "../../../optix" }
+optix = { version = "0.1", path = "../../../optix", optional = true }
 glium = "0.32.0"
 glutin = "0.28.0"
 imgui = "0.9.0"
@@ -22,3 +22,6 @@ anyhow = "1.0.53"
 
 [build-dependencies]
 cuda_builder = { workspace = true, default-features = false }
+
+[features]
+optix = ["dep:optix", "path-tracer-kernels/optix"]

crates/optix/examples/path_tracer/Cargo.toml

@@ -14,9 +14,12 @@ fn main() {
         .copy_to(out_path.join("kernels.ptx"))
         .build()
         .unwrap();
-    CudaBuilder::new(manifest_dir.join("kernels"))
-        .copy_to(out_path.join("kernels_optix.ptx"))
-        .build_args(&["--features", "optix"])
-        .build()
-        .unwrap();
+
+    // njn: temp
+    // #[cfg(feature = "optix")]
+    // CudaBuilder::new(manifest_dir.join("kernels"))
+    //     .copy_to(out_path.join("kernels_optix.ptx"))
+    //     .build_args(&["--features", "optix"])
+    //     .build()
+    //     .unwrap();
 }

crates/optix/examples/path_tracer/build.rs

@@ -9,11 +9,11 @@ glam = { version = "0.30", default-features = false, features = ["libm", "cuda"]
 enum_dispatch = "0.3.13"
 gpu_rand = { version = "0.1", path = "../../../../gpu_rand" }
 cust_core = { path = "../../../../cust_core", features = ["glam"] }
-optix_device = { path = "../../../../optix_device" }
+optix_device = { path = "../../../../optix_device", optional = true }
 approx = { version = "0.5" }
 
 [lib]
 crate-type = ["cdylib", "rlib"]
 
 [features]
-optix = []
+optix = ["dep:optix_device"]

crates/optix/examples/path_tracer/kernels/Cargo.toml

@@ -5,6 +5,7 @@ extern crate alloc;
 pub mod hittable;
 pub mod material;
 pub mod math;
+#[cfg(feature = "optix")]
 pub mod optix;
 pub mod render;
 pub mod render_kernels;
@@ -51,6 +52,7 @@ impl Ray {
         self.origin + t * self.dir
     }
 
+    #[cfg(feature = "optix")]
     pub fn from_optix() -> Self {
         use optix_device::intersection;
 

crates/optix/examples/path_tracer/kernels/src/lib.rs

@@ -5,7 +5,9 @@ use imgui::Ui;
 
 use std::time::Duration;
 
-use crate::{common::Camera, optix::OptixRenderer};
+use crate::common::Camera;
+#[cfg(feature = "optix")]
+use crate::optix::OptixRenderer;
 use anyhow::Result;
 use cust::{
     error::CudaResult,
@@ -15,6 +17,7 @@ use cust::{
     prelude::*,
 };
 use glam::{U8Vec3, USizeVec2};
+#[cfg(feature = "optix")]
 use optix::{
     context::DeviceContext,
     denoiser::{Denoiser, DenoiserModelKind, Image, ImageFormat},
@@ -33,44 +36,55 @@ pub(crate) static PTX: &str = include_str!(concat!(env!("OUT_DIR"), "/kernels.pt
 pub struct CudaRenderer {
     stream: Stream,
     module: Module,
+    #[cfg(feature = "optix")]
     denoiser: Denoiser,
+    #[cfg(feature = "optix")]
     _optix_context: DeviceContext,
     _context: Context,
 
     buffers: CudaRendererBuffers,
     cpu_image: Vec<U8Vec3>,
+    #[cfg(feature = "optix")]
     optix_renderer: OptixRenderer,
 }
 
 impl CudaRenderer {
     pub fn new(dimensions: USizeVec2, camera: &Camera, scene: &Scene) -> Result<Self> {
         let context = cust::quick_init()?;
+        #[cfg(feature = "optix")]
         optix::init().unwrap();
 
+        #[cfg(feature = "optix")]
         let mut optix_context = DeviceContext::new(&context, false).unwrap();
 
         let module = Module::from_ptx(PTX, &[]).unwrap();
         let stream = Stream::new(StreamFlags::NON_BLOCKING, None)?;
+
+        #[cfg(feature = "optix")]
         let mut denoiser =
             Denoiser::new(&optix_context, DenoiserModelKind::Ldr, Default::default()).unwrap();
-
+        #[cfg(feature = "optix")]
         denoiser
             .setup_state(&stream, dimensions.x as u32, dimensions.y as u32, false)
             .unwrap();
 
         let buffers = CudaRendererBuffers::new(dimensions, camera, scene)?;
         let cpu_image = vec![U8Vec3::ZERO; dimensions.element_product()];
 
+        #[cfg(feature = "optix")]
         let optix_renderer = OptixRenderer::new(&mut optix_context, &stream, scene)?;
 
         Ok(Self {
             _context: context,
+            #[cfg(feature = "optix")]
             _optix_context: optix_context,
+            #[cfg(feature = "optix")]
             denoiser,
             module,
             stream,
             buffers,
             cpu_image,
+            #[cfg(feature = "optix")]
             optix_renderer,
         })
     }
@@ -97,9 +111,11 @@ impl CudaRenderer {
         self.cpu_image
             .resize(new_size.element_product(), U8Vec3::ZERO);
 
+        #[cfg(feature = "optix")]
         self.denoiser
             .setup_state(&self.stream, new_size.x as u32, new_size.y as u32, false)
             .unwrap();
+
         Ok(())
     }
 
@@ -123,7 +139,9 @@ impl CudaRenderer {
         let stream = &self.stream;
 
         let (blocks, threads) = self.launch_dimensions();
+        #[cfg(feature = "optix")]
         let width = self.buffers.viewport.bounds.x as u32;
+        #[cfg(feature = "optix")]
         let height = self.buffers.viewport.bounds.y as u32;
 
         let start = Event::new(EventFlags::DEFAULT)?;
@@ -144,24 +162,30 @@ impl CudaRenderer {
         }
 
         let input_buf = if denoise {
-            let input_image = Image::new(
-                &self.buffers.scaled_buffer,
-                ImageFormat::Float3,
-                width,
-                height,
-            );
-
-            self.denoiser
-                .invoke(
-                    stream,
-                    Default::default(),
-                    input_image,
-                    Default::default(),
-                    &mut self.buffers.denoised_buffer,
-                )
-                .unwrap();
+            #[cfg(not(feature = "optix"))]
+            unreachable!();
+
+            #[cfg(feature = "optix")]
+            {
+                let input_image = Image::new(
+                    &self.buffers.scaled_buffer,
+                    ImageFormat::Float3,
+                    width,
+                    height,
+                );
+
+                self.denoiser
+                    .invoke(
+                        stream,
+                        Default::default(),
+                        input_image,
+                        Default::default(),
+                        &mut self.buffers.denoised_buffer,
+                    )
+                    .unwrap();
 
-            self.buffers.denoised_buffer.as_device_ptr()
+                self.buffers.denoised_buffer.as_device_ptr()
+            }
         } else {
             self.buffers.scaled_buffer.as_device_ptr()
         };
@@ -204,6 +228,10 @@ impl CudaRenderer {
         start.record(stream)?;
 
         if use_optix {
+            #[cfg(not(feature = "optix"))]
+            unreachable!();
+
+            #[cfg(feature = "optix")]
             self.optix_renderer.render(stream, &mut self.buffers)?;
         } else {
             unsafe {

crates/optix/examples/path_tracer/src/cuda/mod.rs

@@ -1,6 +1,7 @@
 pub mod common;
 pub mod cpu;
 pub mod cuda;
+#[cfg(feature = "optix")]
 pub mod optix;
 pub mod renderer;
 pub mod viewer;