Abstract Control variates are a variance‐reduction technique for Monte Carlo integration. The principle involves approximating the integrand by a function that can be analytically integrated, and integrating using the Monte Carlo method only the residual difference between the integrand and the approximation, to obtain an unbiased estimate. Neural networks are universal approx‐imators that could potentially be used as a control variate. However, the challenge lies in the analytic integration, which is not possible in general. In this manuscript, we study one of the simplest neural network models, the multilayered perceptron (MLP) with continuous piecewise linear activation functions, and its possible analytic integration. We propose an integration method based on integration domain subdivision, employing techniques from computational geometry to solve this problem in 2D. We demonstrate that an MLP can be used as a control variate in combination with our integration method, showing applications in the light transport simulation.

While bidirectional path tracing is a well-established light transport algorithm, many samples are required to obtain high-quality results for specular-diffuse-glossy or glossy-diffuse-glossy reflections especially when they are highly glossy. To improve the efficiency for such light path configurations, we propose a hierarchical Russian roulette technique for vertex connections. Our technique accelerates a huge number of Russian roulette operations according to an approximate scattering lobe at an eye-subpath vertex for many cached light-subpath vertices. Our method dramatically reduces the number of random number generations needed for Russian roulette by introducing a hierarchical rejection algorithm which assigns random numbers in a top-down fashion. To efficiently reject light vertices in each hierarchy, we also introduce an efficient approximation of anisotropic scattering lobes used for the probability of Russian roulette. Our technique is easy to integrate into some existing bidirectional path tracing-based algorithms which cache light-subpath vertices (e.g., probabilistic connections, and vertex connection and merging). In addition, unlike existing many-light methods, our method does not restrict multiple importance sampling strategies thanks to the simplicity of Russian roulette. Although the proposed technique does not support perfectly specular surfaces, it significantly improves the efficiency for caustics reflected on extremely glossy surfaces in an unbiased fashion.

Abstract This paper introduces a real‐time rendering method for single‐bounce glossy caustics created by GGX microsurfaces. Our method is based on stochastic light culling of virtual point lights (VPLs), which is an unbiased culling method that randomly determines the range of influence of light for each VPL. While the original stochastic light culling method uses a bounding sphere defined by that light range for coarse culling (e.g., tiled culling), we have further extended the method by calculating a tighter bounding ellipsoid for glossy VPLs. Such bounding ellipsoids can be calculated analytically under the classic Phong reflection model which cannot be applied to physically plausible materials used in modern computer graphics productions. In order to use stochastic light culling for such modern materials, this paper derives a simple analytical solution to generate a tighter bounding ellipsoid for VPLs on GGX microsurfaces. This paper also presents an efficient implementation for culling bounding ellipsoids in the context of tiled culling. When stochastic light culling is combined with interleaved sampling for a scene with tens of thousands of VPLs, this tiled culling is faster than conservative rasterization‐based clustered shading which is a state‐of‐the‐art culling technique that supports bounding ellipsoids. Using these techniques, VPLs are culled efficiently for completely dynamic single‐bounce glossy caustics reflected from GGX microsurfaces.

Porting an existing application to the GPU requires a lot of engineering effort. However, as the GPU memory of today is smaller compared to the host memory, some application which requires to access to a large data set needs to implement an out-of-core logic on top of the GPU implementation which is additional engineering work [Garanzha et al. 2011]. We present a framework to make it easy to transform an in-core GPU implementation to an out-of-core GPU implementation. In this work, we assume that the out-of-core memory access is read only. The proposed method is implemented using OpenCL thus we use the terminology of OpenCL in this document.

The appearance of hair plays a critical role in synthesizing realistic looking human characters. However, due to the high complexity in hair geometry and the scattering nature of hair fibers, rendering hair with photorealistic quality and at interactive speeds remains as an open problem in computer graphics. Previous approaches attempt to simplify the scattering model to only tackle a specific aspect of the scattering effects. In this paper, we present a new approach to simultaneously render complex scattering effects including volumetric shadows, transparency, and antialiasing under a unified framework. Our solution uses a shadow-ray path to produce volumetric self-shadows and an additional view-ray path to produce transparency. To compute and accumulate the contribution of individual hair fibers along each (shadow or view) path, we develop a new GPU-based k-buffer technique that can efficiently locate the K nearest scattering locations and combine them in the correct order. Compared with existing multi-layer based approaches[Kim and Neumann 2001; Yuksel and Keyser 2008; Sintorn and Assarsson 2009], we show that our k-buffer solution can more accurately reproduce the shadowing and transparency effects. Further, we present an anti-aliasing scheme that directly builds upon the k-buffer. We implement all three effects (volumetric shadows, transparency, and anti-aliasing) under a unified rendering pipeline. Experiments on complex hair models demonstrate that our new solution produces near photorealistic hair rendering at very interactive speed.

Particle-based simulations have been used to simulate granular materials, fluids, and rigid bodies. To achieve realistic behavior, a large number of particles have to be simulated. Particle-based simulations are suited for GPUs because the computation of each particle is almost the same, (i.e., the granularity of the computation is uniform over the particles). This is preferable for GPUs with a wide SIMD architecture. However, particle-based simulation on the GPU has been mostly restricted to simulating particles of identical size [Harada et al. 2007]. This is because the work granularity is non-uniform if there are particles with different radii, which leads to inefficient use of the GPU. Heterogeneous CPU/GPU architectures, such as AMD Fusion® APUs, can solve this simulation efficiently by using the CPU and the GPU at the same time. On a PC with a CPU and a discrete GPU, whenever a computation is dispatched to the GPU, the data has to be sent via PCI Express®bus, which introduces a latency. However, heterogeneous architectures have a CPU and a GPU on the same die with a tightly coupled shared memory, so the same memory space can be accessed from the GPU and the CPU without any copying, which can facilitate a tight collaboration between the two processors. In this paper, we describe a particle-based simulation with particles of various sizes running on a heterogeneous architecture by dispatching and simultaneously processing work on the GPU and CPU depending on the granularity.

Rigid body simulations are used often in games. Because of the computational cost, a large scale simulation is not feasible in real time. However, with the increased performance of GPUs, achieving a larger-scale simulation in real time becomes more realistic. A rigid body simulation is too complicated to implement on the GPU in a straightforward manner. One of the challenges is implementing an efficient constraint solver. A projected Gauss-Seidel method is often used to solve constraints [Catto 2005]. The input and output of the solver are the velocity of rigid bodies. However, constraints sharing a body cannot be solved in parallel because of this data dependency. This is a challenge when a GPU is used for a rigid body simulation. A solution to solve constraints in parallel is to split them into groups of constraints called batches. In a batch, no body is shared among constraints, so they can be solved in parallel. An introduction of batch solves the problem of constraint solving, but batch creation itself is a serial process. To complete a rigid body simulation pipeline on the GPU, batch creation on the GPU is also necessary.

No abstract available.

This course is intended for instructing students and practitioners on recent developments related to collision and proximity computations for interactive games and simulations.

We cull collisions between very large numbers of moving bodies using graphics processing units (GPUs). To perform massively parallel sweep-and-prune (SaP), we mitigate the great density of intervals along the axis of sweep by using principal component analysis to choose the best sweep direction, together with spatial subdivisions to further reduce the number of false positive overlaps. Our algorithm implemented entirely on GPUs using the CUDA framework can handle a million moving objects at interactive rates. As application of our algorithm, we demonstrate the real-time simulation of very large numbers of particles and rigid-body dynamics.