Home

Awesome

Siggraph 2019/2020 OptiX 7/7.3 Course Tutorial Code

Note on OWL Version

May 10, 2021: This repo was originally created as sample code for the OptiX 7 course at Siggraph 2019/2020. The goal of this was to teach OptiX 7 step by step, from first principles, and with mininal external dependencies. This makes this particular codebase great for learning the basics; however, it is not necessarily the greatest resource to eventually use to build your own advanced projects with. If you do want to follow up and build your owl OptiX projects, I would suggest to also have a look at my other OptiX 7 resource, the OWL project (at http://owl-project.github.io or https://gitee.com/games-assignment/owl), which in particular aims at making it easier to write OptiX programs by wrapping all or most of the techniques you have learned in this course in some much easier to use "convenience layer" API on top of OptiX 7. OWL does, in fact, now also contain a sample that reproduces exactly this course's final sample within the OWL framework.

Latest Updates:

About this Tutorial/Repository

This tutorial was created to accompany the 2019 Siggraph course on "RTX Accelerated Ray Tracing with OptiX" (slides available on https://drive.google.com/open?id=1_IYHwAZ4EoMcDmS0TknP-TZd7Cwmab_I), 百度云提取码：kadz.

The aim of this repo is to serve as a "tutorial" in how to set up a full Scene - i.e., OptiX Context, Module, Programs, Pipeline, Shader Binding Table (SBT), Accel Struct (AS), Build Inputs, Texture Samplers, etc., in the newly introduced OptiX 7.

To do this, this repo intentionally does not provide one example that has the final code, but instead is split into 12 smaller examples, each of which modifies and extends the previous one, hopefully in a way that it is relatively easy to spot the differences (i.e., to spot what exactly had to be added to go from "A" to "B").

Note this tutorial does (intentionally) not end in a overwhelming-wow-factor full-featured renderer - its aim is to only help you get started with OptiX 7, exactly up to the point where "Textbook Ray Tracing 101" would usually kick in.

With that - enjoy!

PS: I tried my best to make sure that code is correct, and will work out of the box in both Linux and Windows. However, I assume it's safe to expect that some one or other bug has crept in somewhere that I haven't found yet. If you do find one, please feel free to let me know via email or bug report, or send a push request, so others will be spared from finding it again. Any other feedback is welcome, too!

Building the Code

This code was intentionally written with minimal dependencies, requiring only CMake (as a build system), your favorite compiler (tested with Visual Studio 2017 and 2019 under Windows, and GCC under Linux), and the OptiX 7 SDK (including CUDA 10.1 and NVIDIA driver recent enough to support OptiX).

Dependencies

The only external library we use is GLFW for windowing, and even this one we build on the fly under Windows, so installing it is required only under Linux.

Detailed steps below:

Building under Linux

    git clone https://gitee.com/games-assignment/optix7course.git
    cd optix7course

    mkdir build
    cd build

    make

Building under Windows

Examples Overview

Example 1: Hello World

This is simplest example, that only initializes the OptiX Library, prints "hello world", and exits. It's pretty much testing only whether your SDK, driver, and PATH/LD_LIBRARY_PATH are properly set up to build, link, and run this tutorial.

This is how this should look like in Linux: Example 1 Linux output

And here, in Windows: Example 1 Linux output

Note: if you do not see this output file, you may have a driver that does not work properly with OptiX 7 or some other cause. Normally the console window will disappear before you can see the error. To run and see the console window's messages, use the Visual Studio option "Start Without Debugging" (or hit Ctrl+F5), which will keep the console window visible after exit. The other option (or for Linux) is to run the program in a console window, e.g., run build\Debug\ex01_helloOptix.exe

Example 2: First Pipeline Setup and Raygen Program

This is the first "real" OptiX example, and maybe somewhat surprisingly, the biggest "step" in all the examples.

The actual raygen program that this example launches is actually very (!) small, and pretty much trivial; and there are no other programs, not even geometry, nor a single ray being traced ... but to launch this simple raygen program we nevertheless have to go through the entire process of creating Modules, Programs, and, in particular, a valid "Shader Binding Table" (SBT), before we can launch our little raygen sample.

On the upside: Once this initial setup is done, everything will get much simpler in the following examples.

PNG file generated by Example 2

Example 3: Rendering in a GLFW Window

Rendering to files is nice and well, but probably you want to eventually do some online rendering; so this example moves the previous raygen example into a 3D viewer window (created and run using GLFW). For now this viewer just displays the rendered images, with no user interaction.

Same Raygen example, in GLFL Window (Linux) Same Raygen example, in GLFL Window (Windows)

Example 4: Creating a first Triangle Mesh and Accel Struct

Though the previous setup steps were important to get right, eventually you want to use a ray tracer to trace some real rays against some real geometry.

This example introduces how to create some Triangle Mesh Geometry (in this example, two simple, hardcoded, cubes), how to build an Acceleration Structure over this "BuildInput", and how to trace rays against it. To do this we also need to introduce a simple camera model.

First Triangle Mesh and Accel Struct

Example 5: First Shader Binding Table (SBT) Data

The earlier examples created an SBT (they had to, else they couldn't have executed any OptiX launch), but didn't actually put any data into the SBT. This example introduces how to do that, by putting just some simple constant per-object color into the mesh's SBT entry, then shading it based on the surface normal's angle to the view ray.

First SBT Data

Example 6: Multiple Triangle Meshes

This example introduces the concept of having multiple different meshes (each with their own programs and SBT data) into the same accel structure. Whereas the previous example used two (same color) cubes in one triangle mesh, this example split this test scene into two meshes with one cube (and one color) each.

Multiple Triangle Meshes

Example 7: First Real Model

This example takes the previous "multiple meshes" code unmodified, but introduces a simple OBJ file format parser (using Syoyo Fuyita's tinyobj, and hooks the resulting triangle meshes up to the previous example's render code.

For this example, you must download the Crytek Sponza model and unzip it to the (non-existent, until you create it) subdirectory optix7course/models.

And la-voila, with exactly the same render code from Sample 6, it suddenly starts to take shape:

First Real Model: Sponza

Example 8: Adding Textures via CUDA Texture Objects

This example shows how to create and set up CUDA texture objects on the host, with the host passing those to the device via the SBT, and how to use those texture objects on the device. This one will take a bit of time to load in Debug - it's worth the wait! Or simply build and run in Release.

Adding Textures

Example 9: Adding a second ray type: Shadows

This is the last example that focuses on host-side setup, in this case adding a second ray type (for shadow rays), which also requires changing the way the SBT is being built.

This sample also shows how to shoot secondary rays (the shadow rays) in device programs, how to use an any-hit program for the shadow rays, how to call optixTerminateRay from within an any-hit program, and how to use the optixTrace call's SBT index/offset values to specify the ray type.

Adding Shadow Rays

Example 10: Soft Shadows

Whereas the first 9 examples focused on how to perform all the required host-side setup for various incremental features, this example can now start to focus more on the "ray tracing 101" style additions that focus what rays to trace to add certain rendering effects.

This simple example intentionally only adds soft shadows from area lights, but extending this to add reflections, refraction, diffuse bounces, better material models/BRDFs, etc., should from now on be straightforward.

Please feel free to play with adding these examples ... and share what you did!

Soft Shadows

Example 11: Simple Denoising (LDR, color only)

This example takes the code from the previous example and simply runs the optix denoiser on the final frame (ie, color) buffer computed by this optix launch. It does not store any albedo or normal buffers, not compute HDR intensity, etc.

To fully see the impact of denoising without progressive resampling, feel free to turn denoising and/or progressive refinemnt on and off via the 'd' (denoising) and 'a' (accumulate) keys.

Example 11, single sample per pixel, no denoising: Ex11, 1spp, noisy

The same, with denoiser turned on: Ex11, 1spp, denoised

Example 12: Denoising with HDR and separate Normal Channel

This example improves on the simple denoising by computing a separate normal buffer (which improves the denoiser quality), and by doing denoising in HDR, with an added gamma pass after denoising.

As with example 11, to fully see the impact of denoising without progressive resampling, feel free to turn denoising and/or progressive refinemnt on and off via the 'd' (denoising) and 'a' (accumulate) keys.

Example 12, single sample per pixel, no denoising: Ex12, 1spp, noisy

The same, with denoiser turned on: Ex12, 1spp, denoised

Example 13: It's up to you ...

From here on, there are multiple different avenues of how to add to this simple viewer, in terms of visual features, performance, kind and complexity of geometry, etc. In no particular order, and just to serve as inspiration:

Whichever of these - or other - features you might want to play around with: Let me know how it works out ... and have fun doing it!