V1.6.0: Grid volume renderer update

Heterogeneous volumetric path tracing is currently supported in v1.6.0, new features:

• Support mono-chromatic and RGB grid volume. Current supported format: Mitsuba .vol
• Delta tracking distance sampler & ratio tracking transmittance estimator
• Channel-independent path throughput estimator for RGB volume (upgrade needed)
• Volume parser and configurating logic, improbed RR control.

Lit with backlights	Lit with top light and backlights

---

Features to be supported in v1.6.1 (may need several weeks, since this repo is not in its active development stage):

• Spectrum MIS for improved chromatic convergence
• Blackbody emission grid and RGB emission
• Envirment map based environment lighting

SSAO 1.5.1

Screen space ambient occlusion (SSAO) is implemented, use

python ./render.py --scene lambo --name lambo-back.xml --iter_num 8000 --arch cuda --type ao

to find out. The following images are rendered using RTX3060-laptop with a interactive preview, without it, the rendering speed is 81 fps and 161 fps, respectively. The scene consists of 300k primitives.

Lambo scene (67 fps)	Lambo-back scene (120 fps)

Note that the first image has some weird patches, which might be caused by erroneous normal vector and is not the problem of this renderer.

Temporary Farewell - version 1.5

Checkout AdaptiveGallery for the lastest renderings (sports car scene and Darth-Vader collections).

This will be the final active release for AdaPT 1.x (Taichi based). The future focus of mine will be shifted to real-time global dynamic illumination. Some other reasons include: Taichi lang is currently inefficient to support a large project & the things I have been implementing and the problems I have been solving are not innovative but require heavy engineering work.

This pull request has the following updates:

More BxDFs

We can now use:

• The full Trowbridge-Reitz(GGX)-distribution-based microfacet BRDF (microfacet). Note that microfacet introduces much new code therefore I observed a compile-time slow down due to Taichi's force inlining.
• Oren-Nayar diffuse BRDF (oren-nayar), which is a physically-based diffusive surface model, better than Lambertian.
• Thin coating BRDF for plastic-like material (thin-coat). The BRDF got its name due to it's kind of like it has a extremely thin layer with different index of refraction on the surface, therefore making the Fresnel' rules applicable.
• Lambertian transmission BSDF. Now we have three viable BSDF (in addition to null and det-refraction, we have lambertian).

Bug fix for direct renderer

Real-time interactive direct illumination renderer is fixed: upgraded from the previous implementation and can now be used when ray-intersection function return an Intersection struct.

Post-processing

Simple fire-fly removal script is provided to post process the output image. This functionality is not directly incorporated into the rendering pass due to the consideration for flexibility.

Other miscellaneous fixes and modification

• BDPT now utilizes ti.template() to avoid branching
• BRDFTag is added for clarity and readability in BRDF implementation
• I tried my best to use real_func of Taichi lang, but it seems that real_func might accidentally increase the GPU global memory usage and cause some unknown (and hard to debug) exception. This... shouldn't be the fault of mine.
• Fixed the issue mentioned in #22

Branch more

This branch is previously used to implement BxDF mixture model. The result is a success but it comes at a cost: the compile-time and run-time performances degrade unexpectedly. Yet, this branch should have been merged into the master branch if it worked it out well since there had been major refactoring work done for the PathTracer class and the whole logic was quite different. Therefore, I decided to keep this branch for, maybe, future uses.

For more information, take a look at the updated [README.md](https://github.com/Enigmatisms/AdaPT).

V1.4.1: bug fix for v1.4.0

Modified Phong BRDF problem is fixed. In the future we will use Darth-Vader helmet as our demo scene for material / medium. For the future releases and updates, please see the latest issue.

Lambertian	Frensel Blend	Glass Transmit
Blinn Phong Glossy	Modified Phong (incorrect)	Modified Phong (correct)

V1.4.0: Shading normal & Normal/Bump Map & Acceleration

Shading normal is finally supported, resulting in a much smoother shading. Besides this:

• Bump map / normal map can be applied to primitives to manipulate the surface appearance.
• Volumetric path tracer now supports MIS, the firefly effect in vpt is suppressed.
• Loading from wavefront obj file and BVH construction are accelerated GREATLY (over 1000x), the scene with more than 100k primitives can now be loaded into Taichi instantly.
• Rendering is accelerated (slightly, about 2x) for CUDA backend
• Support up to Taichi version 1.6 (from 1.4.0 to 1.6.0, all these versions are supported)

Newly rendered scene: venus can be found in the [AdaptiveGallery]. The three-bunnies scene is also re-rendered with vertex normal support (and miscellaneous stuff like proper total-reflection).

Two-sided BRDF and complex scene rendering

AdaPT now supports BRDF to be two-sided (but with the same attributes). With this we don't need to care about the normal direction given by modeling softwares (which might points inwards, causing primitive missing), so we can renderer highly complex scenes:

Kitchen scene (modeled by me via sketchup 2021 / blender)

Stuffs scene

All of the above scenes have their configuration file stored in scenes/cbox/, yet the obj model is not uploaded due to the line number and file sizes. These pictures are kept in gallery.md

Miscellaneous enhancements

Please check the updated version of README.md for the lastest rendered results.

AdaPT 1.3.0 update major features

• Texture packing / mapping is now supported. The vt field in .obj file will be loaded. Textures will be packed into a single texture image (without LoD mipmapping yet). Major refactoring works in ray intersection / BDPT logics.
• Console update: using rich lib to present better console outputs.
• Cached rendering: rendering now supports checkpointing the result.

Bug and fix

• scene_viz.py: fixed in #15
• np_rotation_between function: for more general orientation settings, original version will produce camera poses with roll angle.
• Remove k_a (absorption coefficient) in BSDF and BRDF

Remaining problems

• Exporting data structures from python Taichi now becomes one of the speed bottle-necks. For example, a scene with 90k+ meshes requires at least 5min to load.
• Taichi side rendering speed optimization should be done.

BVH tree accelerator

Marching towards v1.2.1, where we have our first BVH acceleration structure which is capable of accelerating ray intersection by reducing the amount of primitives to be taken into account. Tests showed that, for bunny scene which contains 14916 triangles, it only takes 30 ms to build BVH tree while achieving roughly 50x speed up compared to the brute force ray intersection which can only prune unnecessary computation via object bounding box. The implementation of BVH tree is done in C++ and I expose a python API via pybind/pybind11. All it takes is to build the bvh code and install locally with minimal effort. See the following figure with three Stanford Bunnies without mesh decimation (glass / conductor / Fresnel blend anisotropic) which is renderer within 15min.

For other modifications, please refer to PR #10

Transient renderer

Transient rendering based on temporal histogram is completed (PR and issue: #5 #6 #7) . The transient renderer supports camera unwarped (corresponding to transient_lit mode) and camera warped (corresponding to transient_cam mode) and steady state (corresponding to none) temporal decomposition mode, and by default, if the field in .xml scene file is not set, the decomposition mode will be none. For more information and demo, please refer to the README.md of AdaPT.

New light source collimated source is implemented. Different from the collimated source of mitsuba, our collimated source is not an cylinder ray with infinitesimal radius. We can specify the beam radius to simulate collimated laser.

Later the repo will be quantitatively tested against PBRT tracers (especially, pbrt-v3). There will be only two remaining major releases coded 1.3.0 (comparison & tests) and 1.4.0 (enhancement in emitter / BRDF / BSDF / medium) before I proceed to AdaPT v2.0.

Bidirectional Path Tracer

Bidirectional path tracer is now implemented in AdaPT, along with its MIS path connection methods to reduce variance and speed up convergence. BDPT has already been tested against pbrt-v3 qualitatively (volumetric cornell box), with some minor inconsistency. Enhancements:

• Migrated from taichi 1.3 to taichi 1.4 for faster JIT compilation. Follow-up API optimization should be carried out due to automatic function inlining of taichi, which makes JIT really slow (BDPT on the first run takes 1.5 - 2 min to compile).
• Volumetric path tracing with/without BDPT in unbounded scene. In the previous versions, VPT produces noisy (with infinite variance) and biased rendering results (due to untimely ray termination).
• AdaPT can converge to the same result with only 1%-5% required samples compared to VPT and UDPT. Previously, VPT will not converge even we sample 20000 rays per pixel in vpt/balls.xml scene.
• Fixed some implementation bugs.
  More rigorous tests should be done in future versions. In the future version, Metropolis Light Transport & transient rendering methods will be implemented.