代码拉取完成，页面将自动刷新
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.
6/14/2021: Bugfix - normal and albedo buffer values for denoiser were not correctly set
4/16/2021: Updated to also compile on OptiX 7.3
10/21/2020: Bugfix: all moduleCompileOptions and pipelineCompileOptions are now properly zero-initialized by default. Otherwise, variables not set in these struct might have invalid values.
8/3/2020: Updated to also compile on OptiX 7.1
1/3/2020: Several fixes and documentation adds to make project compile with CentOS 7 (ie, oder gcc)
1/1/2020: Changed all examples to enable full optimization level and most appropriate pipeline config for the specific example (single GAS)
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!
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).
/usr/local/cuda/bin into your PATH
OptiX_INSTALL_DIR to wherever you installed the SDK.
export OptiX_INSTALL_DIR=<wherever you installed OptiX 7 SDK>
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:
Install required packages
sudo apt install libglfw3-dev cmake-curses-gui
sudo yum install cmake3 glfw-devel freeglut-devel
Clone the code
git clone https://gitee.com/games-assignment/optix7course.git
cd optix7course
mkdir build
cd build
configure with cmake
cmake ..
cmake3 ..
and build
make
CMake GUI from your start menu
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:
And here, in Windows:
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
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.
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.
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.
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.
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.
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:
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.
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.
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!
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:
The same, with denoiser turned on:
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:
The same, with denoiser turned on:
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!
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。