[Paper Review] Implementing a Photorealistic Rendering System using GLSL

Toshiya Hachisuka|arXiv (Cornell University)|May 22, 2015

Computer Graphics and Visualization Techniques15 references3 citations

TL;DR

This paper presents a platform-independent, GPU-accelerated photorealistic rendering system implemented entirely in GLSL 1.20 using OpenGL 3.0, supporting bounding volume hierarchy (BVH) traversal and stochastic progressive photon mapping. It introduces a multiple-threaded BVH for stackless traversal and a floating-point-only pseudorandom number generator, achieving 2–3× performance improvement over the original threaded BVH while ensuring compatibility with WebGL and diverse platforms.

ABSTRACT

Ray tracing on GPUs is becoming quite common these days. There are many publicly available documents on how to implement basic ray tracing on GPUs for spheres and implicit surfaces. We even have some general frameworks for ray tracing on GPUs. We however hardly find details on how to implement more complex ray tracing algorithms themselves that are commonly used for photorealistic rendering. This paper explains an implementation of a stand-alone rendering system on GPUs which supports the bounding volume hierarchy and stochastic progressive photon mapping. The key characteristic of the system is that it uses only GLSL shaders without relying on any platform dependent feature. The system can thus run on many platforms that support OpenGL, making photorealistic rendering on GPUs widely accessible. This paper also sketches practical ideas for stackless traversal and pseudorandom number generation which both fit well with the limited system configuration.

Motivation & Objective

• To implement a fully portable photorealistic rendering system using only standard GLSL and OpenGL 3.0 features.
• To enable efficient ray tracing on GPUs without vendor-specific extensions or compute APIs.
• To support complex rendering algorithms like stochastic progressive photon mapping in a portable, shader-only environment.
• To address performance bottlenecks in BVH traversal and random number generation under constrained GLSL environments.
• To ensure compatibility with WebGL and multi-platform deployment, including web-based rendering.

Proposed method

• Uses a modified multiple-threaded BVH (MTBVH) that pre-sorts nodes along ray principal directions to enable fast, stackless traversal with reduced performance degradation.
• Employs a floating-point-only pseudorandom number generator based on multiplicative linear congruential generators to avoid reliance on bitwise operations.
• Implements stochastic progressive photon mapping with independent path tracing per pixel thread, enabling load balancing across varying path lengths.
• Applies stochastic spatial hashing with randomized depth values and z-buffering to resolve concurrent write conflicts in photon data storage.
• Uses a hybrid rendering pipeline with separate shaders for photon tracing, eye path tracing, and density estimation via range queries.
• Relies solely on GLSL 1.20 and OpenGL 3.0 features, avoiding compute shaders or vendor-specific extensions.

Experimental results

Research questions

• RQ1 How can a high-performance, photorealistic rendering system be implemented using only standard GLSL and OpenGL 3.0?
• RQ2 What optimizations can improve BVH traversal performance in GLSL without stack usage or advanced threading?
• RQ3 How can high-quality random number generation be achieved in GLSL without bitwise operations?
• RQ4 How can stochastic progressive photon mapping be efficiently parallelized across GPU threads with variable path lengths?
• RQ5 To what extent can such a system be deployed on WebGL and other portable platforms?

Key findings

• The multiple-threaded BVH (MTBVH) improves traversal performance by 2–3 times compared to the original threaded BVH by reducing traversal order dependency.
• The floating-point-only pseudorandom number generator produces sufficient randomness quality for rendering while being computationally efficient and compatible with GLSL 1.20.
• The system achieves end-to-end rendering of complex scenes (e.g., Cornell box) in under one minute on a GeForce GTX 680 using only GPU shaders.
• The implementation runs on multiple platforms and is compatible with WebGL, especially with floating-point texture extensions.
• The system supports efficient load balancing in path tracing by allowing independent path lengths per pixel thread, improving GPU utilization.
• The approach enables out-of-the-box multi-GPU support via OpenGL’s native driver-level parallelization, without custom code.