|
Practical Realtime Strategies for Accurate Indirect Occlusion
2016
Ambient occlusion is ubiquitous in games and other real-time
applications to approximate global illumination effects. However there
is no analytic solution to ambient occlusion integral for arbitrary
scenes, and using general numerical integration algorithms is too
slow, so approximations used in practice often are empirically made to
look pleasing even if they don’t accurately solve the AO integral. In
this work we introduce a new formulation of ambient occlusion, GTAO,
which is able to match a ground truth reference in half a millisecond
on current console hardware. This is done by using an alternative
formulation of the ambient occlusion equation, and an efficient
implementation which distributes computation using spatio-temporal
filtering. We then extend GTAO with a novel technique that takes into
account near-field global illumination, which is lost when using
ambient occlusion alone. Finally, we introduce a technique for
specular occlusion, GTSO, symmetric to ambient occlusion which allows
to compute realistic specular reflections from probe-based
illumination. Our techniques are efficient, give results close to the
ray-traced ground truth, and have been integrated in recent AAA
console titles.
|
|
Scalable Ambient Obscurance
2012
This paper presents a set of architecture-aware
performance and integration improvements for a recent screen-space
ambient obscurance algorithm. These improvements collectively produce
a 7× performance increase at 2560 × 1600, generalize the algorithm to
both forward and deferred renderers, and eliminate the radius- and
scene-dependence of the previous algorithm to provide a hard real-time
guarantee of fixed execution time. The optimizations build on three
strategies: pre-filter the depth buffer to maximize memory hierarchy
efficiency; reduce total bandwidth by carefully reconstructing
positions and normals at high precision from a depth buffer; and
exploit low-level intra- and inter-thread techniques for parallel,
floating-point architectures.
|
|
The Alchemy Screen-Space Ambient Obscurance Algorithm
2011
Ambient obscurance (AO) produces perceptually
important illumination effects such as darkened corners, cracks, and
wrinkles; prox- imity darkening; and contact shadows. We present the
AO algorithm from the Alchemy engine used at Vicarious Visions in com-
mercial games. It is based on a new derivation of screen-space
obscurance for robustness, and the insight that a falloff function can
cancel terms in a visibility integral to favor efficient operations.
Alchemy creates contact shadows that conform to surfaces, captures
obscurance from geometry of varying scale, and provides four intuitive
appearance parameters: world-space radius and bias, and aesthetic
intensity and contrast.
|
|
Volumetric Obscurance
2010
Obscurance and Ambient Occlusion (AO) are popular
techniques in both film and games that model how ambient light is
shadowed. While it is largely a solved problem for static scenes, for
dynamic scenes it is still difficult to compute at interactive
rates. Recent attempts to compute AO in screen space for dynamic
scenes either have poor performance or suffer from under-sampling
problems. We formulate the problem as a 3D volumetric integral, which
maps more naturally to graphics hardware. This integral can be solved
using line samples to improve the under-sampling problems that plague
other techniques. Following the idea of line integrals to its logical
conclusion, we show results using area samples that use a simple
statistical model of the depth buffer that allows us to use a single
sample. We also discuss strategies for generating point, line, and
area sample patterns along with ways to incorporate the surface normal
into the volume obscurance calculation.
|
|
A Simple and Practical Approach to SSAO
2010
Global illumination (GI) is a term used in computer
graphics to refer to all lighting phenomena caused by
interaction between surfaces (light rebounding off them,
refracting, or getting blocked), for example: color bleeding,
caustics, and shadows. Many times the term GI is used to refer
only to color bleeding and realistic ambient lighting. Direct
illumination – light that comes directly from a light source –
is easily computed in real-time with today´s hardware, but we
can´t say the same about GI because we need to gather
information about nearby surfaces for every surface in the scene
and the complexity of this quickly gets out of control. However,
there are some approximations to GI that are easier to
manage. When light travels through a scene, rebounding off
surfaces, there are some places that have a smaller chance of
getting hit with light: corners, tight gaps between objects,
creases, etc. This results in those areas being darker than
their surroundings.
|
|
Approximating Dynamic Global Illumination in Image Space
2009
Physically plausible illumination at real-time framerates is often
achieved using approximations. One popular example is ambient
occlusion (AO), for which very simple and efficient implementations
are used extensively in production. Recent methods approximate
AO between nearby geometry in screen space (SSAO). The key
observation described in this paper is, that screen-space occlusion
methods can be used to compute many more types of effects than just
occlusion, such as directional shadows and indirect color bleeding.
The proposed generalization has only a small overhead compared to
classic SSAO, approximates direct and one-bounce light transport
in screen space, can be combined with other methods that simulate
transport for macro structures and is visually equivalent to SSAO in
the worst case without introducing new artifacts. Since our method
works in screen space, it does not depend on the geometric complexity.
Plausible directional occlusion and indirect lighting effects can
be displayed for large and fully dynamic scenes at real-time frame
rates.
|
|
Screen Space Ambient Occlusion
2008
Ambient occlusion is a lighting model that
approximates the amount of light reaching a point on a diffuse
surface based on its directly visible occluders. It is commonly
used to add a global illumination look to rendered images. This
ambient occlusion algorithm operates on the depth buffer of the
scene being rendered and associated per-pixel normals. For
multiple directions defined in image space around the current
pixel, the algorithm samples the depth buffer, computes a
horizon angle for each sample, and integrates the ambient
occlusion for the current direction based on the tangent plane,
the horizon angle and a weighting function. This whitepaper
includes a brief introduction to the algorithm and its
parameters. For more details, please refer to [Bavoil and Sainz
08a] and [Bavoil and Sainz 08b].
|
|
Image-Space Horizon-Based Ambient Occlusion
2008
Siggraph 2008 presentation (47 slides)
|
|
Image-Space Horizon-Based Ambient Occlusion
2008
Ambient occlusion is a lighting model that
approximates the amount of light reaching a point on a diffuse surface
based on its directly visible occluders. It gives perceptual clues of
curvature and spatial proximity. Like [Mittring 2007] and [Shanmugam
and Arikan 2007], we propose a real-time ambient occlusion computation
as a postprocessing pass mainly based on a depth image from the eye’s
point of view. This approach requires no scene- dependent
precomputations and is applicable to dynamic scenes. Our proposed
method does not have the overocclusion issue from [Shanmugam and
Arikan 2007] and samples inside the radius of influence, unlike
[Mittring 2007].
|
|
Hardware Accelerated Ambient Occlusion Techniques on GPUs
2007
We introduce a visually pleasant ambient occlusion approximation
running on real-time graphics hardware. Our method is a
multi-pass algorithm that separates the ambient occlusion
problem into highfrequency, detailed ambient occlusion and
low-frequency, distant ambient occlusion domains, both capable
of running independently and in parallel. The high-frequency
detailed approach uses an image-space method to approximate the
ambient occlusion due to nearby occluders caused by high surface
detail. The low-frequency approach uses the intrinsic properties
of a modern GPU to greatly reduce the search area for large and
distant occluders with the help of a low-detail approximated
version of the occluder geometry. Our method utilizes the highly
parallel, stream processors (GPUs) to perform real-time visually
pleasant ambient occlusion. We show that our ambient occlusion
approximation works on a wide variety of applications such as
molecular data visualization, dynamic deformable animated
models, highly detailed geometry. Our algorithm demonstrates
scalability and is well-suited for the current and upcoming
graphics hardware.
|
|
A Practical Analytic Single Scattering Model for Real Time Rendering
2004
We consider real-time rendering of scenes in
participating media, capturing the effects of light scattering in fog,
mist and haze. While a number of sophisticated approaches based on
Monte Carlo and finite element simulation have been developed, those
methods do not work at interactive rates. The most common real-time
methods are essentially simple variants of the OpenGL fog model. While
easy to use and specify, that model excludes many important
qualitative effects like glows around light sources, the impact of
volumetric scat- tering on the appearance of surfaces such as the
diffusing of glossy highlights, and the appearance under complex
lighting such as environment maps. In this paper, we present an
alternative physically based approach that captures these effects
while maintaining real-time performance and the ease-of-use of the
OpenGL fog model. Our method is based on an explicit analytic
integration of the single scattering light transport equations for an
isotropic point light source in a homogeneous participating medium. We
can implement the model in modern programmable graphics hardware using
a few small numerical lookup tables stored as texture maps. Our model
can also be easily adapted to generate the appearances of materials
with arbitrary BRDFs, environment map lighting, and precomputed
radiance transfer methods, in the presence of participating media.
Hence, our techniques can be widely used in real-time rendering.
|
|
Practical Realtime Strategies for Accurate Indirect Occlusion
2000
Ambient occlusion is ubiquitous in games and other
real-time applications to approximate global illumination
effects. However there is no analytic solution to ambient
occlusion integral for arbitrary scenes, and using general
numerical integration algorithms is too slow, so approximations
used in practice often are empirically made to look pleasing even
if they don’t accurately solve the AO integral. In this work we
introduce a new formulation of ambient occlusion, GTAO, which is
able to match a ground truth reference in half a millisecond on
current console hardware. This is done by using an alternative
formulation of the ambient occlusion equation, and an efficient
implementation which distributes computation using
spatio-temporal filtering. We then extend GTAO with a novel
technique that takes into account near-field global illumination,
which is lost when using ambient occlusion alone. Finally, we
introduce a technique for specular occlusion, GTSO, symmetric to
ambient occlusion which allows to compute realistic specular
reflections from probe-based illumination. Our techniques are
efficient, give results close to the ray-traced ground truth, and
have been integrated in recent AAA console titles.
|
| |
SMAA: Enhanced Subpixel Morphological Antialiasing
2012
We present a new image-based, post-processing
antialiasing technique, which offers practical solutions to the
common, open problems of existing filter-based real-time antialiasing
algorithms. Some of the new features include local contrast analysis
for more reliable edge detection, and a simple and effective way to
handle sharp geometric features and diagonal lines. This, along with
our accelerated and accurate pattern classification allows for a
better reconstruction of silhouettes. Our method shows for the first
time how to combine morphological antialiasing (MLAA) with additional
multi/supersampling strategies (MSAA, SSAA) for accurate subpixel
features, and how to couple it with temporal reprojection; always
preserving the sharpness of the image. All these solutions combine
synergies making for a very robust technique, yielding results of
better overall quality than previous approaches while more closely
converging to MSAA/SSAA references but maintaining extremely fast
execution times. Additionally, we propose different presets to better
fit the available resources or particular needs of each scenario.
|
|
A Reconstruction Filter for Plausible Motion Blur
2012
This paper describes a novel filter for simulating motion blur
phenomena in real time by applying ideas from offline stochastic
reconstruction. The filter operates as a 2D post-process on a
conventional framebuffer augmented with a screen-space velocity
buffer. We demonstrate results on video game scenes rendered and
reconstructed in real-time on NVIDIA GeForce 480 and Xbox 360
platforms, and show that the same filter can be applied to cinematic
post-processing of offline-rendered images and real photographs. The
technique is fast and robust enough that we deployed it in a
production game engine used at Vicarious Visions.
|
|
FXAA
2009
This sample presents a high performance and high
quality screen-space software approximation to anti-aliasing called
FXAA
|
|
Rendering Anti-Aliased Line Segments
2005
Bridging the modeling and rendering gap between the existing
triangle and point primitives, we explore the use of line
segments as a new primitive to represent and render 3D
models. Our main contribution extends the anti-aliasing theory
in texture mapping to anti-aliased line segment rendering, and
presents an approximation algorithm to render high quality
anti-aliased opaque and transparent line segments in 3D
models. This anti- aliasing technique is empirically validated
by building a software pipeline to render models of any
combination of the three types of modeling primitives:
triangles, line segments and points. Our experiment shows that
models comprising line segments are generally more efficient and
effective for high quality rendering as compared to their
corresponding pure point models.
|
|
Advanced Visual Effects with Direct3D
2004
A 50 slide presentation.
|
|
Hardware Accelerated Motion Blur Generation
2003
Motion blur occurs in photography by the motion of objects
during the finite exposure time that the camera shutter remains
open for to record the image on film. The traditional method of
rendering a motion blur with a computer is to render the scene
at many discrete time instances in every frame. In this paper,
we present an efficient motion blur generation method that
leverages modern commodity graphics hardware. Our method
avoids rendering the entire complex scene many times per
frame. It first renders the scene into a texture, next renders
the optic flow, created based on object transformation, to a
vector field texture. The scene texture is finally efficiently
blurred according to the vector field using texturemapping
hardware to do a piecewise iterative line integral
convolution. Though our method uses vertex velocities to
calculate image pixel velocities, the line integral convolution
is performed on an image, making our method largely independent
of scene complexity.
|
|
Discontinuity Edge Overdraw
2001
Aliasing is an important problem when rendering triangle meshes.
Efficient antialiasing techniques such as mipmapping greatly
improve the filtering of textures defined over a mesh. A major
component of the remaining aliasing occurs along discontinuity
edges such as silhouettes, creases, and material boundaries.
Framebuffer supersampling is a simple remedy, but 2x2 super-
sampling leaves behind significant temporal artifacts, while
greater supersampling demands even more fill-rate and memory.
We present an alternative that focuses effort on discontinuity
edges by overdrawing such edges as antialiased lines. Although
the idea is simple, several subtleties arise. Visible silhouette
edges must be detected efficiently. Discontinuity edges need
consistent orientations. They must be blended as they approach
the silhouette to avoid popping. Unfortunately, edge blending
results in blurriness. Our technique balances these two
competing objectives of temporal smoothness and spatial
sharpness. Finally, the best results are obtained when
discontinuity edges are sorted by depth. Our approach proves
surprisingly effective at reducing temporal artifacts commonly
referred to as "crawling jaggies", with little added cost.
|
|
The Aliasing problem in Computer-Generated Shaded Images
1997
Certain defects, such as jagged edges and disappearing detail,
have long been an annoyance in digitally generated shaded
images. Although increasing the resolution or defocusing the
display can attenuate them, an understanding of these defects
leads to more effective methods. This paper explains the
observed defects in terms of the aliasing phenomenon inherent in
sampled signals and discusses prerdtering as a recognized
cure. A method for evaluating filters is presented, the
application of prefiltering to hidden-surface algorithms is
discussed, and an implementation of a filtering tiler is shown
accompanied by examples of its effectiveness.
|
|
An Efficient Antialiasing Technique
1991
An intuitive concept of antialiasing is developed into very
efficient antialiased line and circle generators that require
even less amount of integer arithmetic than Bresenham's line and
circle algorithms. Unlike its predecessors, the new
antialiasing technique is derived in spatial domain (raster
plane) under a subjectively meaningful error measure to preserve
the dynamics of curve and object boundaries. A formal analysis
of the new antialiasing technique in frequency domain is also
conducted. It is shown that our antialiasing technique computes
the same antialiased images as Fujimoto-Iwata's algorithm but at
a fraction of the latter's computational cost. The simplicities
of the new antialiased line and circle generators also mean they
are easy hardware implementations.
|
|
Stochastic Sampling in Computer Graphics
1986
Ray tracing, ray casting, and other forms of point sampling are
important techniques in computer graphics, but their usefulness
has been undermined by aliasing artifacts. In this paper it is
shown that these artifacts are not an inherent part of point
sampling, but a consequence of using regularly spaced
samples. If the samples occur at appropriate non-uniformly
spaced locations, frequencies above the Nyquist limit do not
alias, but instead appear as noise of the correct average
intensity. This noise is much less objectionable to our visual
system than aliasing. In ray tracing, the rays can be
sarcastically distributed to perform a Monte Carlo evaluation of
integrals in the rendering equation. This is called distributed
ray tracing and can be used to simulate motion blur, depth of
field, penumbrae, gloss, and translucency.
|
|
Digital Filtering Tutorial, Part II
1983
The Sampling Theorem assumes samples are taken at a niform
rate. We continue to assume a given input is sampled
uniformly -- at the pixels -- and that the output is sampled
uniformly -- also at the pixels. So we can still use the Sampling
Theorem, for example, to reconstruct the original input from its
samples. In case of magnification and minification scaling the
abscissa x by a constant factor), the spacing of the input
samples is changed by the scaling but the spacing remains
uniform. In this memo, however, a less restricted class of
mappings is considered which, in general, does not preserve
input sample spacing uniformity. A good illustration of such a
mapping is f(x) = (ax+b)/(cx+d) which occurs in perspective [2].
We shall show in this memo that the simplifications obtained for
magnification and minification do not go through for general
mappings, including, unfortunately, perspective. Then we shall
discuss some practical filters which are useful for the case
where the Sampling Theorem does hold: for scaling, translation,
and rotation. The filters include the Catmull-Rom and B-spline
cubic spline basis functions and the sine function made finite
with a variety of window functions: Bartlett, Hamming, Hanning,
Blackman, Lanczos, Kaiser, etc.
|
|
Digital Filtering Tutorial for Computer Graphics
1983
Digital sampling and filtering in both space and time are
intrinsic to computer graphics. The pixels of a framebuffer
representation of a picture are regularly placed samples in
2-dimensional screen space. Inappropriate application of
sampling theory (or no application at all) results in the
artifact called"jaggies". The frames of a film representation of
a movement are regularly placed samples in time. The artifact
here is called "strobing". Spatial filtering, called
"antialiasing", is used to soften the jaggies. Temporal
filtering, called "motion blur", removes strobing of edges and
backward spinning stagecoach wheels. The purpose of this memo is
to review the principles of digital sampling and filtering
theory in the context of computer graphics. In particular, it is
a rewording of the classical results in terms with which I am
comfortable. Hopefully other computer graphicists will also find
the restatement helpful.
|
|
Real Shading in Unreal Engine 4
2013
38 slides
|
|
Real Shading in Unreal Engine 4
2013 |
|
Physically Based Lighting at Pixar
2013
67 slides
|
|
Physically Based Lighting at Pixar
2013
For Monsters University and more recently for The Blue Umbrella, the lighting pipeline at Pixar was
completely rewritten and switched to a physically based and ray-traced system. Although ray-tracing
was already used in some cases—in the movie Cars for example—we were still using point lights,
shadow maps, ad hoc shading models, etc. Over the years, the original pipeline has gotten more and
more complex, with thousands of lights and shader tweaking in every shot. The idea was to let the
computer handle all this complexity, freeing the lighter to concentrate on the artistic side.
|
|
Open Shading Language in Disney's OZ The Great and Powerful
2013
31 slides
|
|
Getting more Physical in Call of Duty BLACK OPS
2013
We started pursuing Physically Based Lighting during the development of Call of Duty:
Black Ops. The details were presented at SIGGRAPH 2011 as part of the Advances in
Real-Time Rendering course [11]. Here we’ll give a brief recap of the important bits
relevant for this course and then describe the improvements we did during the
development of Call of Duty: Black Ops II.
|
|
Getting more Physical in Call of Duty BLACK OPS
2013
35 slides
|
|
Everything You Always Wanted to Know About mia_material
2013
As the original author of the popular mental ray shader mia_material, I will herein discuss its
background, development history, features, and even its failures.
|
|
Everything You Always Wanted to Know About mia_material
2013
46 slides
|
|
Crafting a Next-Gen Material Pipeline for The Order: 1886
2013
The Order: 1886 is an upcoming third-person action-adventure game for the PlayStation 4. When we
first started pre-production for the project, the word “filmic” was often used to describe the cinematic
feel that we wanted to achieve with the game’s visuals. Things like cinematic lighting, grungy streets,
and highly detailed characters were identified as key elements in creating a convincing portrayal of
19th-century London.
It was decided very early in the project that utilizing a physically based shading model would be a
key component of achieving the look we wanted for the game. A Cook-Torrance-like microfacet BRDF
was adopted as the default specular BRDF for our materials, and energy conservation was enforced
throughout the rendering pipeline. We also implemented several alternative BRDFs for skin, hair,
fabrics, and anisotropic materials.
|
|
Crafting a Next-Gen Material Pipeline for The Order: 1886
2013
74 slides
|
|
Crafting Physically Motivated Shading Models for Game Development
2013
66 slides
|
|
Background: Physics and Math of Shading
2013
78 slides
|
|
Background: Physics and Math of Shading
2013
In this section of the course notes, we will go over the fundamentals behind physically based shading
models, starting with a qualitative description of the underlying physics, followed by a quantitative
description of the relevant mathematical models, and finally discussing how these mathematical models
can be implemented for shading.
|
|
Physically-Based Shading at Disney
2012
Following our success with physically-based hair shading on Tangled [27], we began considering physically-
based shading models for a broader range of materials. With the physically-based hair model, we were
able to achieve a great degree of visual richness while maintaining artistic control. However, it proved
challenging to integrate the lighting of the hair with the rest of the scene which had still used tradi-
tional “ad-hoc” shading models and punctual lights. For subsequent films we wanted to increase the
richness of all of our materials while making lighting responses more consistent between materials and
environments and also wanted to improve artist productivity through the use of simplified controls.
|
|
Crafting Physically Motivated Shading Models for Game Development
2010
In this section of the course notes, we discuss the design of shading models that are both physically
based and appropriate for game development use.
|
|
Sampling the GGX Distribution of Visible Normals
2018
Importance sampling microfacet bidirectional
scattering distribution functions (BSDFs) using their
distribution of visible normals (VNDF) yields significant
variance reduction in Monte Carlo rendering. In this article, we
describe an efficient and exact sampling routine for the VNDF of
the GGX microfacet distribution. This routine leverages the
property that GGX is the distribution of normals of a truncated
ellipsoid, and sampling the GGX VNDF is equivalent to sampling
the 2D projection of this truncated ellipsoid. To do that, we
simplify the problem by using the linear transformation that maps
the truncated ellipsoid to a hemisphere. Since linear
transformations preserve the uniformity of projected areas,
sampling in the hemisphere configuration and transforming the
samples back to the ellipsoid configuration yields valid samples
from the GGX VNDF.
|
|
A Comprehensive Framework for Rendering Layered Materials
2014
We present a general and practical method for
computing BSDFs of layered materials. Its ingredients are
transport-theoretical models of isotropic or anisotropic scattering
layers and smooth or rough boundaries of conductors and
dielectrics. Following expansion into a directional basis that
supports arbitrary composition, we are able to efficiently and
accurately synthesize BSDFs for a great variety of layered structures.
Reflectance models created by our system correctly account for
multiple scattering within and between layers, and in the context of a
rendering system they are efficient to evaluate and support texturing
and exact importance sampling. Although our approach essentially
involves tabulating reflectance functions in a Fourier basis, the
generated models are compact to store due to the inherent sparsity of
our representation, and are accurate even for narrowly peaked
functions. While methods for rendering general layered surfaces have
been investigated in the past, ours is the first system that supports
arbitrary layer structures while remaining both efficient and
accurate.
|
|
Thinking in Layers - Modelling with Layered Surfaces
2011
This course serves as a guide on the considerable
potential of layered surface models that are available in many
commercial products.The key advantage of using such layered materials
over traditional, more general shading language constructs is that the
end result is automatically highly physically plausible because they
simulate real materials more precisely. However, this does not mean
that these models cannot be used for artistic purposes.
In particular, we demonstrate on simple layered surface models how a
surprisingly large number of interesting and important surface types
can be efficiently represented. We also show how handy such an
approach is for the eventual end user, whose main concern is the ease
with which one can describe object appearance based only on a few
intuitive parameters.
We first discuss layered surface models in general and the constraints
of modelling object appearance in a physically plausible fashion by
explaining basic material properties. We then demonstrate the
techniques that can be used to analyse such materials, both for high
quality offline rendering as well as in a real-time setting before we
give examples of the surface types that can be described in this way
and demonstrate how we create them in our company.
|
|
Crafting Physically Motivated Shading Models for Game Development
2010
Talk Outline
Motivation and Infrastructure
Making an Ad-hoc Game Shading Model Physically Plausible
Environmental And Ambient Light
Fine-Tuning and Future Directions
|
|
An Overview of BRDF Models
2008
This paper is focused on the Bidirectional
Reflectance Distribution Function (BRDF) in the context of algorithms
for computational production of realistic synthetic images. We provide
a review of most relevant analytical BRDF models proposed in the
literature which have been used for realistic rendering. We also show
different approaches used for obtaining efficient models from acquired
reflectance data, and the related function fitting techniques,
suitable for using that data in efficient rendering algorithms. We
consider the algorithms for computation of BRDF integrals, by using
Monte-Carlo based numerical integration. In this context, we review
known techniques to design efficient BRDF sampling schemes for both
analytical and measured BRDF models.
|
|
Microfacet Models for Refraction through Rough Surfaces
2007
Microfacet models have proven very successful for
modeling light reflection from rough surfaces. In this paper we review
microfacet theory and demonstrate how it can be extended to simulate
transmission through rough surfaces such as etched glass. We compare
the resulting transmission model to measured data from several real
surfaces and discuss appropriate choices for the microfacet
distribution and shadowing-masking functions. Since rendering
transmission through media requires tracking light that crosses at
least two interfaces, good importance sampling is a practical
necessity. Therefore, we also describe efficient schemes for sampling
the microfacet models and the corresponding probability density
functions.
|
|
Arbitrarily layered micro-facet surfaces
2007
In this paper we present a method to combine several
micro-facet based surface layers into a single unified, expressive
BRDF model that is easy to use. The restriction to micro-facet based
layers constitutes no loss of generality, since both perfectly
specular and perfectly diffuse surfaces can be seen as limit cases of
the micro-facet approach.
Such multi-layered surfaces can be used to
re-create the appearance of a wide range of different materials, and
yield good results without having to perform explicit sub–surface
scattering computations. This is achieved through suitable
approximations and simplifications of the scattering within the
simulated layered surface, while still taking absorption and total
internal reflection into account. We also discuss the corresponding
probability distribution function that is needed for sampling
purposes, and investigate how the flexibility of this new approach is
best put to use.
|
|
An Inexpensive BRDF Model for Physically-based Rendering
2003
A new BRDF model is presented which can be viewed as
an kind of intermediary model between empirism and theory. Main
results of physics are observed (energy conservation,
reciprocity rule, microfacet theory) and numerous phenomena
involved in light reflection are accounted for, in a physically
plausible way (incoherent and coherent reflection, spectrum
modifications, anisotropy, self-shadowing, multiple surface and
subsurface reflection, differences between homogeneous and
heterogeneous materials). The model has been especially
intended for computer graphics applications and therefore
includes two main features: simplicity (a small number of
intuitively understandable parameters controls the model) and
efficiency (the formulation provides adequation to Monte-Carlo
rendering techniques and/or hardware implementations).
|
|
BRDF models and their use in Global Illumination Algorithms
2000
42 slides
|
|
An Anisotropic Phong BRDF Model
2000
We present a BRDF model that combines several
advantages of the various empirical models currently
in use. In particular, it has intuitive parameters,
is anisotropic, conserves energy, is reciprocal, has
an appropriate non-Lambertian diffuse term, and is
well-suited for use in Monte Carlo renderers.
|
|
Compact Metallic Reflectance Models
1999
The paper presents simple, physically plausible, but
not physically based reflectance models for metals and other
specular materials. So far there has been no metallic BRDF model
that is easy to compute, suitable for fast importance sampling
and is physically plausible. This gap is filled by appropriate
modifications of the Phong, Blinn and the Ward models. The Phong
and the Blinn models are known not to have metallic
characteristics. On the other hand, this paper also shows that
the Cook-Torrance and the Ward models are not physically
plausible, because of their behavior at grazing angles. We also
compare the previous and the newly proposed models. Finally, the
generated images demonstrate how the metallic impression can be
provided by the new models.
|
|
Models of Light Reflection for Computer Synthesized Pictures
1997
In the production of computer generated pictures of three
dimensional objects, one stage of the calculation is the
determination of the intensity of a given object once its
visibility has been established. This is typically done by
modeling the surface as a perfect diffuser, sometimes with a
specular component added for the simulation of hilights. This
paper presents a more accurate function for the generation of
hilights which is based on some experimental measurements of how
light reflects from real surfaces. It differs from previous
models in that the intensity of the hilight changes with the
direction of the light source. Also the position and shape of
the hilights is somewhat different from that generated by
simpler models. Finally, the hilight function generates
different results when simulating metallic vs. nonmetallic
surfaces. Many of the effects so generated are somewhat subtle
and are apparent only during movie sequences. Some
representative still frames from such movies are included.
|
|
An Anisotropic Phong Light Reflection Model
1997
We present a new BRDF model that attempts to combine
the advantages of the various empirical models currently in use. In
particular, it has intuitive parameters, is anisotropic,
energy-conserving, reciprocal, has an appropriate non- Lambertian
diffuse term, and is easy to use in a Monte Carlo framework.
|
|
Using the Modified Phong Reflectance Model for Physically Based Rendering
1994
This text discusses a few aspects of reflectance models in physically based rendering:
The first section presents the definition of the bidirectional reflection distribution function (brdf) of a surface and its physical properties.
On a more practical level, the next section discusses models to represent brdfs and their desired properties in general for Monte Carlo algorithms.
The third section goes into details about a specific reflectance model, the modified Phong brdf, with its definition, its properties and its use. We show how this model can be correctly integrated in importance sampling schemes for physically based Monte Carlo rendering algorithms.
The fourth section is devoted to alternative parameter spaces in which reflectance models can be sampled, either deterministically or stochastically.
The last section discusses an important implementational issue, more specifically the problem of verifying the implementation of a reflectance model.
|
|
Generalization of Lambert's Reflectance Model
1994
Lambert's model for body reflection is widely used in
computer graphics. It is used extensively by rendering techniques such
as radiosity and ray tracing. For several real-world objects, however,
Lambert's model can prove to be a very inaccurate approximation to the
body reflectance. While the brightness of a Lambertian surface is
independent of viewing direction, that of a rough surface increases as
the viewing direction approaches the light source direction. In this
paper, a comprehensive model is developed that predicts body
reflectance from rough surfaces. The surface is modeled as a
collection of Lambertian facets. It is shown that such a surface is
inherently non-Lambertian due to the foreshortening of the surface
facets. Further, the model accounts for complex geometric and
radiometric phenomena such as masking, shadowing, and interreflections
between facets. Several experiments have been conducted on samples of
rough diffuse surfaces, such as, plaster, sand, clay, and cloth. All
these surfaces demonstrate significant deviation from Lambertian
behavior. The reflectance measurements obtained are in strong
agreement with the reflectance predicted by the model.
|
|
Measuring and Modeling Anisotropic Reflection
1992
A new device for measuring the spatial reflectance distributions
of surfaces is introduced, along with a new mathematical model
of anisotropic reflectance. The reflectance model presented is
both simple and accurate, permitting efficient reflectance data
reduction and reproduction. The validity of the model is
substantiated with comparisons to complete measurements of
surface reflectance functions gathered with the novel
reflectometry device. This new device uses imaging technology to
capture the entire hemisphere of reflected directions
simultaneously, which greatly accelerates the reflectance data
gathering process, making it possible to measure dozens of
surfaces in the time that it used to take to do one. Example
measurements and simulations are shown, and a table of fitted
parameters for several surfaces is presented.
|
|
Making Shaders More Physically Plausible
1992
There is a need to develop shaders that not only "look good",
but are more physically plausible. From physical and geometric
considerations, we review the derivation of a shading equation
expressing reflected radiance in terms of incident radiance and
the bidirectional reflectance distribution function (BRDF). We
then examine the connection between this equation and
conventional shaders used in computer graphics. Imposing the
additional physical constraints of energy conservation and
Helmholtz reciprocity allows us to create variations of the
conventional shaders that are more physically plausible.
|
|
A Reflectance Model for Computer Graphics
1982
A new reflectance model for rendering computer synthesized
images is presented. The model accounts for the relative
brightness of different materials and light sources in the same
scene. It describes the directional distribution of the
reflected light and a color shift that occurs as the reflectance
changes with incidence angle. A method for obtaining the
spectral energy distribution of the light reflected from an
object made of a specific real material is presented, and a
procedure for accurately reproducing the color associated with
the spectral energy distribution is discussed. The model is
applied to the simulation of a metal and a plastic.
|
|
Surface Reflection Models
One of the fundamental topics in lighting is how the light
interacts with the environment. The academic community has
researched several models over the last century, but for the
most part, we are still stuck with the most basic of models. The
reason for this is for the most part the lack of computational
power, making it difficult to use more truthful models in
real-time. The goal of this paper is to investigate the
viability of some of the more sophisticated surface reflection
models that have been created, giving developers a sense as to
how much computational power needs to be used to create better
looking surfaces.
Traditionally, the most used method of finding the color of a pixel has been through Gouraud interpolation of Lambert's Cosine Law at the vertices. This lighting model is extremely cheap to compute and is amenable to fixed function pipelines. With the advent of GPUs, Phong interpolation has become a viable option. This model has allowed for innovations like bump mapping giving more realism to modern virtual worlds. The underlying assumptions however are still the same; the surfaces are Lambertian. Unfortunately, this has the side effect of making most of the computer generated images look very much alike, and very different from the real world. The Lambertian surface assumption works great for some materials (like plastic), which means that different models must be used if other materials are to be represented faithfully. And this is what we will investigate over the next few pages. |
|
Reflection Models, and Physically-Based Illumination Models
A 17 slide presentation.
|
|
An Introduction to BRDF-Based Lighting
The introduction of modern GPUs such as the GeForce 256 and
GeForce2 GTS has opened the door for creating stunningly
photorealistc interactive 3D content. While the realization of
realtime computer-generated images indistinguishable from
photographs remains as yet unreached, one piece of machinery
that will play an important role in realizing interactive
photorealism is the notion of a Bi-directional Reflectance
Distribution Function (BRDF) and BRDF-based lighting techniques.
The purpose of this tutorial is to provide a working knowledge of the concepts and basic mathematics necessary to appreciate BRDFs and to provide some exposure to the terminology used when discussing BRDFs and BRDF-based lighting techniques. If you are already familiar with BRDFs, this paper will be a review; however, if you are new to BRDFs, this paper will provide a good starting point for understanding many reflectance-based lighting techniques. |
|
Forward+: Bringing Deferred Lighting to the Next Level
20012
This paper presents Forward+, a method of rendering
many lights by culling and storing only lights that contribute to the
pixel. Forward+ is an extension to traditional forward
rendering. Light culling, implemented using the compute capability of
the GPU, is added to the pipeline to create lists of lights; that list
is passed to the final rendering shader, which can access all
information about the lights. Although Forward+ increases workload to
the final shader, it theoretically requires less memory traffic
compared to compute-based deferred lighting. Furthermore, it removes
the major drawback of deferred techniques, which is a restriction of
materials and lighting models. Experiments are performed to compare
the performance of Forward+ and deferred lighting.
|
|
Deferred Attribute Interpolation for Memory-Efficient Deferred Shading
2015
In this work we present a novel approach to deferred shading suitable
for high resolution displays and high visibility sampling rates. We
reduce the memory costs of deferred shading by substituting the
geometry buffer with a visibility buffer that stores references into a
triangle buffer. The triangle buffer is populated dynamically with all
visible triangles which is compatible with the use of tessellation.
Stored triangles are represented by a sample point and screen-space
partial derivatives. This representation allows for efficient
attribute interpolation during shading and gives shaders knowledge
about the partial derivatives of all attributes. We show that the size
of the visibility buffer can be further decreased by storing a linked
list of visibility samples per pixel. For high-resolution displays we
propose an extension of our algorithm to perform shading at reduced
frequency, allowing us to reduce the sampling rate for computationally
expensive, but low-frequency signals such as indirect illumination.
|
|
Light Pre-Pass: Deferred Lighting: Latest Development
2009
An 18 slice set.
|
|
Inferred Lighting: Fast dynamic lighting and shadows for opaque and translucent objects
2009
This paper presents a three phase pipeline for real-time rendering
that provides fast dynamic light calculations while enabling greater
material flexibility than deferred shading. This method, called inferred
lighting, allows lighting calculations to occur at a significantly
lower resolution than the final output and is compatible
with hardware multisample antialiasing (MSAA). In addition, inferred
lighting introduces a novel method of computing lighting and
shadows for translucent objects (alpha polygons) that unifies the
pipeline for processing lit alpha polygons with that of opaque polygons.
The key to our method is a discontinuity sensitive filtering
algorithm that enables material shaders to "infer" their lighting values
from a light buffer sampled at a different resolution. This paper
also discusses specific implementation issues of inferred lighting
on DirectX 10, Xbox 360, and PlayStation 3 hardware.
|
|
Deferred Rendering in Killzone 2
2009
A 55 slide set.
|
|
Non-interleaved Deferred Shading of Interleaved Sample Patterns
2006
This paper presents a novel and fast technique to
combine interleaved sampling and deferred shading on a GPU. The core
idea of this paper is quite simple. Interleaved sample patterns are
computed in a non-interleaved deferred shading process. The geometric
buffer (G-buffer) which contains all of the pixel information is
actually split into several separate and distinct sub-buffers. To
achieve such a result in a fast way, a massive two-pass swizzling copy
is used to convert between these two buffer organizations. Once split,
the sub-buffers can then be accessed to perform any fragment operation
as it is done with a standard deferred shading rendering pipeline. By
combining interleaved sampling and deferred shading, real time
rendering of global illumination effects can be therefore easily
achieved. Instead of evaluating each light contribution on the whole
geometric buffer, each shading computation is coherently restricted to
a smaller subset a fragments using the sub-buffers. Therefore, each
screen pixel in a regular n m pattern will have its own small set of
light contributions. Doing so, the consumed fillrate is considerably
decreased and the provided rendering quality remains close to the
quality obtained with a non-interleaved approach. The implementation
of this rendering pipeline is finally straightforward and it can be
easily integrated in any existing real-time rendering package already
using deferred shading.
|
|
Deferred Shading Tutorial
2005
The authors of this article proposed a rendering technique that
produces 3D images that favor the recognition of shapes and
patterns, since shapes can be readily understood if certain
geometric properties are enhanced. In order to optimize the
enhancement process, geometric properties of the surfaces are
preserved as Geometric-Buffers G-buffers). So, by using
G-buffers as intermediate results, artificial enhancement
processes are separated from geometric processes (projection and
hidden surface removal) and physical processes (shading and
texture mapping), and performed as a post-processing pass
|
|
Illumination for Real-Time Rendering of Large Architectural
Environments
2005
A Master's Thesis. This thesis explores efficient techniques for
high quality real-time rendering of large architectural
environments using affordable graphics hardware, as applied to
illumination, including window reflections, shadows, and "bump
mapping". For each of these fields, the thesis investigates
existing methods and intends to provide adequate solutions. The
focus lies on the use of new features found in current graphics
hardware, making use of new OpenGL extensions and functionality
found in Shader Model 3.0 vertex and pixel shaders and the
OpenGL 2.0 core. The thesis strives to achieve maximum image
quality, while maintaining acceptable performance at an
affordable cost. The thesis shows the feasibility of using
deferred shading on current hardware and applies high dynamic
range rendering with the intent to increase
realism. Furthermore, the thesis explains how to use environment
mapping to simulate true planar reflections as well as
incorporates relevant image post-processing effects. Finally, a
shadow mapping solution is provided for the future integration
of dynamic geometry.
|
|
Deferred Shading
2004
A 32 slide presentation from a Game Developers conference. It
contains a nice, but brief outline of deferred shading with some nice
pictures but not much detail.
|
|
6800 Leagues Under the Sea: Deferred Shading
2004
A 44 slide presentation by Nvidia about deferred shading, and
its use with many other effects: lighting, shadows, AA, ...
|
|
The Triangle Processor and Normal Vector Shader: A VLSI System for High Performance Graphics
1988
Note: This, the origin of the deferred shading concept, is mostly
concerned with the hardware architecture needed render triangles
quickly. Buried within that, is the idea that
geometry should be rendered once, and the pixel shading should
be done on only visible pixels later.
Current affordable architectures for high-speed display of shaded 3D objects operate orders of magnitude too slowly. Recent advances in floating point chip technology have out-paced polygon fill time, making the memory access bottleneck between the drawing processor and the frame buffer the most significant factor to be accelerated. Massively parallel VLSI systems have the potential to by pass this bottleneck , but to date only at very high cost. We describe a new more affordable VLSI solution. A pipeline of triangle processors rasterizes the geometry, then a further pipeline of shading processors applies Phong shading with multiple light sources. The triangle processor pipeline performs 100 billion additions per second, and the shading pipeline performs two billion multiplies per second. This allows 3D graphics systems to be built capable of displaying more than one million triangles per second. We show the results of an anti-aliasing technique, and discuss extensions to texture mapping, shadows, and environment maps. |
|
A Survey of Efficient Representations for Independent Unit Vectors
2014
The bandwidth cost and memory footprint of vector buffers are limiting
factors for GPU rendering in many applications. This article surveys
time- and space-efficient representations for the important case of
non-register, in-core, statistically independent unit vectors, with
emphasis on GPU encoding and decoding. These representations are
appropriate for unit vectors in a geometry buffer or attribute
stream—where no correlation between adjacent vectors is easily
available—or for those in a normal map where quality higher than that
of DXN is required. We do not address out-of-core and register
storage vectors because they favor minimum-space and maximum-speed
alternatives, respectively.
We evaluate precision and its qualitative impact across these
techniques and give CPU reference implementations. For those methods
with good quality and reasonable performance, we provide optimized
GLSL GPU implementations of encoding and decoding.
|
|
The Tennis-ball Map: A Low-Distortion Sampling-Efficient Parameterization of the Sphere
2011
We introduce a parameterization of the sphere,
called the tennis-ball parameterization, which exhibits
properties highly desirable for computer graphics applications
which need to represent values over a sphere, for instance
spherical images for view-independent reflections maps and
omni-directional shadow maps. We are particularly interested in
using such maps in applications requiring high frame-rate
real-time rendering of dynamic scenes.
We use some carefully selected metrics to compare the tennisball parameterization to a number of other parameterizations found in traditional computer graphics, as well as several found in applied mathematics and sciences. Under the restrictions implied by view-independence and the high frame rate of real-time applications, we will show that the tennis-ball map exhibits some greatly improved characteristics compared to the other parameterizations. |
|
Practical Implementation of Dual Paraboloid Shadow Maps
2006
\ In this paper, we present refinements to dual
paraboloid shadow mapping algorithm from Brabec, et. al. This
work makes the algorithm practical for broader use in video
games. We give solutions for the tessellation constraints on
shadow casters and receivers present in the original work. We
also discuss heuristics for splitting plane placement and
pitfalls in filtering.
|
|
Dual Paraboloid Mapping In the Vertex Shader
2006
I had heard about "dual-paraboloid mapping" some
time ago and always wanted to look into how the algorithm
worked. The name itself begs to be investigated, and the
paraboloid mapping could be applied to environment maps as well
as shadow maps so it seemed like a good idea to look into
it.
When I recently found some spare time to read up on it I found several different academic papers on the topic explaining the theory behind the algorithm. However, after several rounds with Google I realized that there weren't many good resources on how to implement the mapping scheme. So I decided that I would investigate the topic and try to provide an easy to understand guide to the theory as well as a reference to the implementation of paraboloid mapping in the modern programmable rendering pipeline. The implementation is written in DirectX 9 HLSL. The effect files that are developed in this exercise are provided with the article and may be used in whatever manner you desire. |
|
Shadow Mapping for Hemispherical and Omnidirectional Light Sources
2002
\ In this paper we present a shadow mapping technique
for hemispherical and omnidirectional light sources using
dual-paraboloid mapping. In contrast to the traditional
perspective projection this parameterization has the benefit
that only a minimal number of rendering passes is needed during
generation of the shadow maps, making the method suitable for
dynamic environments and real time applications. By utilizing
programmable features available on state-of-the-art graphics
cards we show how the algorithm can be efficiently mapped to
hardware.
|
|
Parameterized Environment Maps
2001
Static environment maps fail to capture local
reflections including effects like selfreflections and parallax
in the reflected imagery. We instead propose parameterized
environment maps (PEMs), a set of per-view environment maps
which accurately reproduce local reflections at each viewpoint
as computed by an offline ray tracer. Even with a small set of
viewpoint samples, PEMs support plausible movement away from
and between the pre-rendered viewpoint samples while
maintaining local reflections. They also make use of
environment maps supported in graphics hardware to provide
real-time exploration of the pre-rendered space. In addition to
parameterization by viewpoint, our notion of PEMe xtends to
general, multidimensional parameterizations of the scene,
including relative motions of objects and lighting changes.
Our contributions include a technique for inferring environment maps providing a close match to ray-traced imagery. We also explicitly infer and encode all MIPMAP levels of the PEMs to achieve higher accuracy. We propose layered environment maps that separate local and distant reflected geometry. We explore several types of environment maps including finite spheres, ellipsoids, and boxes that better approximate the environmental geometry. We demonstrate results showing faithful local reflections in an interactive viewer. |
|
A Unified Approach to Prefiltered Environment Maps
2000
Different methods for prefiltered environment maps
have been proposed, each of which has different advantages and
disadvantages. We present a general notation for prefiltered
environment maps, which will be used to classify and compare
the existing methods. Based on that knowledge we develop three
new algorithms: 1. A fast hierarchical prefiltering method that
can be utilized for all previously proposed prefiltered
environment maps. 2. A technique for hardware-accelerated
prefiltering of environment maps that achieves interactive
rates even on low-end workstations. 3. Anisotropic environment
maps using the Banks model.
|
|
View-independent Environment Maps
1998
Environment maps are widely used for approximating
reflections in hardware-accelerated rendering applications.
Unfortunately, the parameterizations for environment maps used
in today's graphics hardware severely undersample certain
directions, and can thus not be used from multiple viewing
directions. Other parameterizations exist, but require
operations that would be too expensive for hardware imple-
mentations.
In this paper we introduce an inexpensive new parameterization for environment maps that allows us to reuse the environment map for any given viewing direction. We describe how, under certain restrictions, these maps can be used today in standard OpenGL implementations. Furthermore, we explore how OpenGL could be extended to support this kind of environment map more directly. |
|
Real-time Global Illumination by Precomputed Local Reconstruction from Sparse Radiance Probes
2017
We present a direct-to-indirect transport technique that enables
accurate realtime rendering of indirect illumination in mostly static
scenes of complexity on par with modern games while supporting fully
dynamic lights, cameras and diffuse surface materials. Our key
contribution is an algorithm for reconstructing the incident radiance
field from a sparse set of local samples — radiance probes — by
incorporating mutual visibility into the reconstruction filter. To
compute global illumination, we factorize the direct-to-indirect
transport operator into global and local parts, sample the global
transport with sparse radiance probes at real-time, and use the
sampled radiance field as input to our precomputed local
reconstruction operator to obtain indirect radiance. In contrast to
previous methods aiming to encode the global directto-indirect
transport operator, our precomputed data is local in the sense that it
needs no long-range interactions between probes and receivers, and
every receiver depends only on a small, constant number of nearby
radiance probes, aiding compression, storage, and iterative
workflows. While not as accurate, we demonstrate that our method can
also be used for rendering indirect illumination on glossy surfaces,
and approximating global illumination in scenes with large-scale
dynamic geometry.
|
|
Real-Time Global Illumination using Precomputed Light Field Probes
2017
We introduce a new data structure and algorithms that employ it to
compute real-time global illumination from static environments. Light
field probes encode a scene’s full light field and internal
visibility. They extend current radiance and irradiance probe
structures with per-texel visibility information similar to a G-buffer
and variance shadow map. We apply ideas from screen-space and voxel
cone tracing techniques to this data structure to efficiently sample
radiance on world space rays, with correct visibility information,
directly within pixel and compute shaders. From these primitives, we
then design two GPU algorithms to efficiently gather real-time,
viewer-dependent global illumination onto both static and dynamic
objects. These algorithms make different tradeoffs between performance
and accuracy. Supplemental GLSL source code is included.
|
|
Real-Time Diffuse Global Illumination Using Radiance Hints
2011
GPU-based interactive global illumination techniques are receiving an increasing interest from both the research and the industrial community as real-time graphics applications strive for visually rich and realistic dynamic three-dimensional environments. This paper presents a fast new diffuse global illumination method that generates a sparse set of low-cost radiance field evaluation points (radiance hints) and computes an arbitrary number of diffuse inter-reflections within a given volume. The proposed approximate technique combines ideas from exiting grid-based radiance caching techniques with reflective shadow maps as well as a stochastic scheme for visibility calculations, in order to achieve high frame rates for multiple light bounces.
|
|
Real-Time Bidirectional Path Tracing via Rasterization Supplemental Material
2011
Supplemental Material
|
|
Real-Time Bidirectional Path Tracing via Rasterization
2011
Global illumination drastically improves visual realism of interactive
applications. Although many interactive techniques are available,
they have some limitations or employ coarse approximations.
For example, general instant radiosity often has numerical error, because
the sampling strategy fails in some cases. This problem can
be reduced by a bidirectional sampling strategy that is often used in
off-line rendering. However, it has been complicated to implement
in real-time applications. This paper presents a simple real-time
global illumination system based on bidirectional path tracing. The
proposed system approximates bidirectional path tracing by using
rasterization on a commodity DirectX11 capable GPU. Moreover,
for glossy surfaces, a simple and efficient artifact suppression
technique is also introduced.
|
|
Interactive Indirect Illumination Using Voxel Cone Tracing
2011
Indirect illumination is an important element for
realistic image synthesis, but its computation is expensive and
highly dependent on the complexity of the scene and of the BRDF
of the involved surfaces. While off-line computation and
pre-baking can be acceptable for some cases, many applications
(games, simulators, etc.) require real-time or interactive
approaches to evaluate indirect illumination. We present a
novel algorithm to compute indirect lighting in real-time that
avoids costly precomputation steps and is not restricted to
low-frequency illumination. It is based on a hierarchical
voxel octree representation generated and updated on the fly
from a regular scene mesh coupled with an approximate voxel
cone tracing that allows for a fast estimation of the
visibility and incoming energy. Our approach can manage two
light bounces for both Lambertian and glossy materials at
interactive framerates (25-70FPS). It exhibits an almost
scene-independent performance and can handle complex scenes
with dynamic content thanks to an interactive
octree-voxelization scheme. In addition, we demonstrate that
our voxel cone tracing can be used to efficiently estimate
Ambient Occlusion,
|
|
Cascaded Light Propagation Volumes for Real-Time Indirect Illumination
2010
This paper introduces a new scalable technique for
approximating indirect illumination in fully dynamic scenes for
real-time applications, such as video games. We use lattices and
spherical harmonics to represent the spatial and angular distribution
of light in the scene. Our technique does not require any
precomputation and handles large scenes with nested lattices. It is
primarily targeted at rendering single-bounce indirect illumination
with occlusion, but can be extended to handle multiple bounces and
participating media. We demonstrate that our method produces plausible
results even when running on current game console hardware with a
budget of only a few milliseconds for performing all computation steps
for indirect lighting. We evaluate our technique and show it in
combination with a variety of popular real-time rendering
techniques.
|
|
Light Propagation Volumes in CryEngine 3
2009
This chapter introduces a new technique for approximating the first bounce of diffuse global illumination
in real-time. As diffuse global illumination is very computationally intensive, it is usually implemented
only as static precomputed solutions thus negatively affecting game production time. In this chapter we
present a completely dynamic solution using spherical harmonics (SH) radiance volumes for light field
finite-element approximation, point-based injective volumetric rendering and a new iterative radiance
propagation approach. Our implementation proves that it is possible to use this solution efficiently even
with current generation of console hardware (Microsoft Xbox 360, Sony PlayStation 3). Because this
technique does not require any preprocessing stages and fully supports dynamic lighting, objects,
materials and view points, it is possible to harmoniously integrate it into an engine as complex as the
cross-platform engine CryEngine 3 with a large set of graphics technologies without requiring additional
production time. Additional applications and combinations with existing techniques are dicussed in
details in this chapter.
|
|
Hardware-Accelerated Global Illumination by Image Space Photon Mapping
2009
We describe an extension to photon mapping that
recasts the most expensive steps of the algorithm - the initial and
final photon bounces - as image-space operations amenable to GPU
acceleration. This enables global illumination for real-time
applications as well as accelerating it for offline rendering.
Image Space Photon Mapping (ISPM) rasterizes a light-space bounce map
of emitted photons surviving initial-bounce Russian roulette sampling
on a GPU. It then traces photons conventionally on the
CPU. Traditional photon mapping estimates final radiance by gathering
photons from a k-d tree. ISPM instead scatters indirect illumination
by rasterizing an array of photon volumes. Each volume bounds a filter
kernel based on the a priori probability density of each photon
path. These two steps exploit the fact that initial path segments from
point lights and final ones into a pinhole camera each have a common
center of projection. An optional step uses joint bilateral upsampling
of irradiance to reduce the fill requirements of rasterizing photon
volumes. ISPM preserves the accurate and physically-based nature of
photon mapping, supports arbitrary BSDFs, and captures both high- and
low-frequency illumination effects such as caustics and diffuse color
interreflection. An implementation on a consumer GPU and 8-core CPU
renders highquality global illumination at up to 26 Hz at HD
(1920X1080) resolution, for complex scenes containing moving objects
and lights.
|
|
Instant Radiosity An Approach for Real-Time Global Illumination
2008
We give an overview of Instant Radiosity, an approach
for global illumination which has recently become suitable for
real-time rendering of complex scenes on PCs exploiting current 3D
hardware. We give an introduction to global illumination, present
other approaches for the solution of this problem and dig deeper into
Instant Radiosity including recent extensions and optimizations. We
also provide some of our own ideas for practical implementations.
|
|
Imperfect Shadow Maps for Efficient Computation of Indirect Illumination
2008
We present a method for interactive computation of
indirect illumination in large and fully dynamic
scenes based on approximate visibility queries. While
the high-frequency nature of direct lighting requires
accurate visibility, indirect illumination mostly
consists of smooth gradations, which tend to mask
errors due to incorrect visibility. We exploit this
by approximating visibility for indirect illumination
with imperfect shadow map-low-resolution shadow maps
rendered from a crude point-based representation of
the scene. These are used in conjunction with a
global illumination algorithm based on virtual point
lights enabling indirect illumination of dynamic
scenes at real-time frame rates. We demonstrate that
imperfect shadow maps are a valid approximation to
visibility, which makes the simulation of global
illumination an order of magnitude faster than using
accurate visibility.
|
|
Interactive Global Illumination Based on Coherent Surface Shadow Maps
2007
Interactive rendering of global illumination effects
is a challenging problem. While precomputed radiance transfer (PRT) is
able to render such effects in real time the geometry is generally
assumed static. This work proposes to replace the precomputed lighting
response used in PRT by precomputed depth. Precomputing depth has the
same cost as precomputing visibility, but allows visibility tests for
moving objects at runtime using simple shadow mapping. For this
purpose, a compression scheme for a high number of coherent surface
shadow maps (CSSMs) covering the entire scene surface is
developed. CSSMs allow visibility tests between all surface points
against all points in the scene. We demonstrate the effectiveness of
CSSM-based visibility using a novel combination of the lightcuts
algorithm and hierarchical radiosity, which can be efficiently
implemented on the GPU. We demonstrate interactive n-bounce diffuse
global illumination, with a final glossy bounce and many high
frequency effects: general BRDFs, texture and normal maps, and local
or distant lighting of arbitrary shape and distribution – all
evaluated per-pixel. Furthermore, all parameters can vary freely over
time – the only requirement is rigid geometry.
|
|
Splatting Indirect Illumination
2006
In this paper we present a novel method for plausible
real-time rendering of indirect illumination effects for diffuse
and non-diffuse surfaces. The scene geometry causing indirect
illumination is captured by an extended shadow map, as proposed
in previous work, and secondary light sources are distributed on
directly lit surfaces. One novelty is the rendering of these
secondary lights' contribution by splatting in a deferred shading
process, which decouples rendering time from scene complexity. An
importance sampling strategy, implemented entirely on the GPU,
allows efficient selection of secondary light sources. Adapting
the light's splat shape to surface glossiness also allows
efficient rendering of caustics. Unlike previous approaches the
approximated indirect lighting does barely exhibit coarse
artifacts - even under unfavorable viewing and lighting
conditions. We describe an implementation on contemporary
graphics hardware, show a comparison to previous approaches, and
present adaptation to and results in game-typical
applications.
|
|
Reflective Shadow Maps
2005
In this paper we present "reflective shadow maps", an algorithm for
interactive rendering of plausible indirect illumination. A reflective
shadow map is an extension to a standard shadow map, where every
pixel is considered as an indirect light source. The illumination due
to these indirect lights is evaluated on-the-fly using adaptive sampling
in a fragment shader. By using screen-space interpolation of
the indirect lighting, we achieve interactive rates, even for complex
scenes. Since we mainly work in screen space, the additional effort
is largely independent of scene complexity. The resulting indirect
light is approximate, but leads to plausible results and is suited for
dynamic scenes. We describe an implementation on current graphics
hardware and show results achieved with our approach.
|
|
Lightcuts: A Scalable Approach to Illumination
2005
Lightcuts is a scalable framework for computing realistic illumination.
It handles arbitrary geometry, non-diffuse materials, and illumination
from a wide variety of sources including point lights, area
lights, HDR environment maps, sun/sky models, and indirect illumination.
At its core is a new algorithm for accurately approximating
illumination from many point lights with a strongly sublinear
cost. We show how a group of lights can be cheaply approximated
while bounding the maximum approximation error. A binary light
tree and perceptual metric are then used to adaptively partition the
lights into groups to control the error vs. cost tradeoff.
We also introduce reconstruction cuts that exploit spatial coherence
to accelerate the generation of anti-aliased images with complex illumination.
Results are demonstrated for five complex scenes and
show that lightcuts can accurately approximate hundreds of thousands
of point lights using only a few hundred shadow rays. Reconstruction
cuts can reduce the number of shadow rays to tens.
|
|
Fast, Realistic Lighting for Video Games
2003
A novel, view-independent technology produces natural-looking
lighting effects faster than radiosity and ray tracing. The
approach is suited for 3D real-time interactive applications and
production rendering.
|
|
Efficient Illumination by High Dynamic Range Images
2003
We present an algorithm for determining quadrature rules for
computing the direct illumination of predominantly diffuse
objects by high dynamic range images. The new method precisely
reproduces fine shadow detail, is much more efficient as
compared to Monte Carlo integration, and does not require any
manual intervention
|
|
Hardware-Accelerated Global Illumination by Image Space Photon Mapping
2000
We describe an extension to photon mapping that recasts the most
expensive steps of the algorithm - the initial and final photon
bounces - as image-space operations amenable to GPU acceleration.
This enables global illumination for real-time applications as well as
accelerating it for offline rendering.
Image Space Photon Mapping (ISPM) rasterizes a light-space bounce map of emitted photons surviving initial-bounce Russian roulette sampling on a GPU. It then traces photons conventionally on the CPU. Traditional photon mapping estimates final radiance by gathering photons from k-d tree. ISPM instead scatters indirect illumination by rasterizing an array of photon volumes. Each volume bounds a filter kernel based on the a priori probability density of each photon path. These two steps exploit the fact that initial path segments from point lights and final ones into a pinhole camera each have a common center of projection. An optional step uses joint bilateral upsampling of irradiance to reduce the fill requirements of rasterizing photon volumes. ISPM preserves the accurate and physically-based nature of photon mapping, supports arbitrary BSDFs, and captures both high- and low-frequency illumination effects such as caustics and diffuse color interreflection. An implementation on a consumer GPU and 8-core CPU renders highquality global illumination at up to 26 Hz at HD (1920x1080) resolution, for complex scenes containing moving objects and lights. |
|
Instant Radiosity
1997
We present a fundamental procedure for instant rendering from the
radiance equation. Operating directly on the textured scene
description, the very efficient and simple algorithm produces
photorealistic images without any finite element kernel or solution
discretization of the underlying integral equation. Rendering rates of
a few seconds are obtained by exploiting graphics hardware, the
deterministic technique of the quasi-random walk for the solution of
the global illumination problem, and the new method of jittered low
discrepancy sampling.
|
|
Realtime HDR Rendering
2007
High dynamic range rendering in realtime graphics
has increased the visual quality of realtime scenes essentially.
There are several techniques of HDR-Rendering. This work summarizes
the theoretical background and results of previous works. A
ready-to-use HDR rendering library has been developed that integrates
seamlessly into the open source graphics engine Ogre3D. Further
a comparison that show the advantages and disadvantages of different
techniques in a realtime rendered scene has been made.
|
|
Real-Time HDR Image Based Lighting
2007
This report presents the work done on the final project for the
course of Image Based Rendering. A real-time application has
been implemented with the purpose of demonstrating the
capabilities of nowadays GPU's power within the scope of Image
Based Rendering and Lighting. The built application has a full
High Dynamic Range (HDR) pipeline and it deals with issues like
tone mapping, automatic scene exposure, vignette effect and
blooming (to increase the high dynamic effect). Furthermore,
some materials were used to demonstrate the potentiality of
Image Based Lighting.
|
|
High Dynamic Range Imaging: Theory and Practice
2006
A Siggraph 2006 Course presentation by multiple authors
consisting of 320 slides.
Current display devices have a limited range of contrast and colors that can be displayed, which is one of the main reasons that most image and video acquisition, processing and display techniques use no more than eight bits per color channel. This course outlines recent advances in high dynamic range imaging (HDRI) - from capture to display - that lift this restriction thereby enabling images to represent the color gamut and dynamic range of the original scene rather than the limited subspace imposed by current monitor technology. |
|
Perceptual Evaluation of Tone Mapping Operators with Real-World Scenes
2005
A number of successful tone mapping operators for contrast
compression have been proposed due to the need to visualize high
dynamic range (HDR) images on low dynamic range devices. They
were inspired by fields as diverse as image processing,
photographic practice, and modeling of the human visual systems
(HVS). The variety of approaches calls for a systematic
perceptual evaluation of their performance.
|
|
Perceptual Effects in Real-time Tone Mapping
2005
Tremendous progress in the development and accessibility of high
dynamic range (HDR) technology that has happened just recently
results in fast proliferation of HDR synthetic image sequences
and captured HDR video. When properly processed, such HDR data
can lead to very convincing and realistic results even when
presented on traditional low dynamic range LDR) display
devices. This requires real-time local contrast compression tone
mapping) with simultaneous modeling of important in HDR image
perception effects such as visual acuity, glare, day and night
vision. We propose a unified model to include all those effects
into a common computational framework, which enables an
efficient implementation on currently available graphics
hardware. We develop a post processing module which can be added
as the final stage of any real-time rendering system, game
engine, or digital video player, which enhances the realism and
believability of displayed image streams.
|
|
High Dynamic Range Imaging
2004
A Siggraph 2004 Course presentation by multiple authors
consisting of 276 slides.
Current display devices can display only a limited range of contrast and colors, which is one of the main reasons that most image acquisition, processing, and display techniques use no more than eight bits per color channel. This course outlines recent advances in high-dynamic-range imaging, from capture to display, that remove this restriction, thereby enabling images to represent the color gamut and dynamic range of the original scene rather than the limited subspace imposed by current monitor technology. |
|
High Dynamic Range Images
2003
This paper describes some of the principles in the computation
and displaying of High Dynamic Range images. Various methods
have been developed in computing High Dynamic Range images in
higher precision and virtually unlimited range, and displaying
the images on low-dynamic-range devices, such as CRT/LCD
monitors.
|
|
Tone Reproduction and Physically Based Spectral Rendering
2002
The ultimate aim of realistic graphics is the creation of images
that provoke the same responses that a viewer would have to a
real scene. This STAR addresses two related key problem areas in
this effort which are located at opposite ends of the rendering
pipeline, namely the data structures used to describe light
during the actual rendering process, and the issue of displaying
such radiant intensities in a meaningful way.
This STAR report will review the work to date on spectral rendering and tone reproduction techniques. It will include an investigation into the need for spectral imagery synthesis methods and accurate tone reproduction, and a discussion of major approaches to physically correct rendering and key tone mapping algorithms. |
|
RADEON(TM) 9700 Shading
2002
In this supplement to Chapter 3 in the bound course notes, we
will outline the shading capabilities of the new RADEON(TM) 9700
graphics processor and illustrate its power with a series of
examples.
|
|
Image-Based Lighting
2002
This tutorial shows how image-based lighting can illuminate
synthetic objects with measurements of real light, making
objects appear as if they're actually in a real-world scene.
|
|
A Tone Mapping Algorithm for High Contrast Images
2002
A new method is presented that takes as an input a high dynamic
range image and maps it into a limited range of luminance values
reproducible by a display device. There is significant evidence
that a similar operation is performed by early stages of human
visual system HVS). Our approach follows functionality of HVS
without attempting to construct its sophisticated model. The
operation is performed in three steps. First, we estimate local
adaptation luminance at each point in the image. Then, a simple
function is applied to these values to compress them into the
required display range. Since important image details can be
lost during this process, we then re-introduce details in the
final pass over the image.
|
|
Pixel Shading with DirectX 8.1 and the ATI RADEONTM 8500
2002
Programmable shaders are a powerful way to describe the
interaction of surfaces with light, as evidenced by the success
of programmable shading models like RenderMan and others. In
these notes, we will outline the structure of the programming
model and present some illustrative examples. In the companion
notes distributed at SIGGRAPH, we will show implementations of
the common example shaders used throughout this course (bumped
cubic environment mapping, McCool BRDF and parametrized
volumetric wood) as well as a new programming model which goes
beyond ps.1.4.
|
|
Real-Time High-Dynamic Range Texture Mapping
2001
This paper presents a technique for representing and displaying
high dynamic-range texture maps (HDRTMs) using current graphics
hardware. Dynamic range in real-world environments often far
exceeds the range representable in 8-bit per-channel texture
maps. The increased realism afforded by a high-dynamic range
representation provides improved fidelity and expressiveness for
interactive visualization of image-based models. Our technique
allows for real-time rendering of scenes with arbitrary dynamic
range, limited only by available texture memory.
|
|
Photographic Tone Reproduction for Digital Images
2001
A classic photographic task is the mapping of the
potentially high dynamic range of real world luminances to the low
dynamic range of the photographic print. This tone reproduction
problem is also faced by computer graphics practitioners who map
digital images to a low dynamic range print or screen. The work
presented in this paper leverages the time-tested techniques of
photographic practice to develop a new tone reproduction operator. In
particular, we use and extend the techniques developed by Ansel Adams
to deal with digital images. The resulting algorithm is simple and
produces good results for a wide variety of images
|
|
Interactive Tone Mapping
2000
Tone mapping and visual adaptation are crucial for the
generation of static, photorealistic images. A largely
unexplored problem is the simulation of adaptation and its
changes over time on the visual appearance of a scene. In
applications such as driving simulators, these changes must be
modeled in order to reproduce the visibility conditions of
real-world situations. In this paper, we address the practical
issues of interactive tone mapping and propose a simple model of
visual adaptation.
|
|
GPU-Based Importance Sampling
2006
We present a technique for image-based lighting of
glossy objects using a Monte Carlo quadrature that requires
minimal precomputation and operates within a single GPU shader,
thereby fitting easily into almost any production pipeline
requiring real-time dynamically changing materials or
lighting.
|
|
Fast Real-time Caustics from Height Fields
2009
Caustics are crucial in water rendering, yet they are
often neglected in real-time applications due to the
demanding computational requirements of the general purpose
caustics computation methods. In this paper we present a
two-pass algorithm for caustics computation that is extremely
fast and produces high quality results. Our algorithm is
targeted for commonly used height field representations of
water and a planar caustic-receiving surface. The underlying
theory of our approach is presented along with implementation
details and pseudo codes.
|
|
Hierarchical Caustic Maps
2008
Interactive applications typically rely on local
models for lighting, occasionally augmented by GPU-friendly
methods for approximating global illumination. Caustic mapping
ap- proximates the specular focusing of light using a
light-space image, akin to a shadow map, which is projected
onto the scene during final rendering. Unfortunately, existing
caus- tic map implementations must choose between quality and
speed. Quickly generated maps use few photons and look
extremely blurry, while sharper maps created from millions of
photons only render at a few frames per second. This paper
introduces a number of hierarchical enhancements to caustic
mapping that allow real-time rendering with high quality
caustic maps, even when using maps from multiple light
sources. These techniques utilize the geometry process- ing
stage of recent GPUs to avoid processing every photon and to
render a pyramidal caustic map that allows photon splats of
varying diameters without the increased costs in- herent in
rasterizing large splats.
|
|
Caustics Mapping: An Image-space Technique for Real-time Caustics
2007
In this paper, we present a simple and practical technique for
real-time rendering of caustics from reflective and refractive
objects. Our algorithm, conceptually similar to shadow mapping,
consists of two main parts: creation of a caustic map texture,
and utilization of the map to render caustics onto non-shiny
surfaces. Our approach avoids performing any expensive geometric
tests, such as ray-object intersection, and involves no
pre-computation; both of which are common features in previous
work. The algorithm is well suited for the standard rasterization
pipeline and runs entirely on the graphics hardware.
|
|
Screen-Space Perceptual Rendering of Human Skin
2009
We propose a novel skin shader which translates the simulation of subsurface scattering from texture space to a screen-space
diffusion approximation. It naturally scales well while maintaining a perceptually plausible result. This technique allows us to
ensure real-time performance even when several characters may appear on screen at the same time. The visual realism of the
resulting images is validated using a subjective psychophysical preference experiment. Our results show that, independent of
distance and light position, the images rendered using our novel shader have as high visual realism as a previously developed
physically-based shader.
|
|
Realistic Shading of Human Skin in Real time
2004
The demand for realistic human characters is driven by
interactive application developers worldwide. The look of 3D
models in real time graphics is efficiently improved by powerful
shader techniques. Today a common technique consists of a simple
lighting model combined with textures, which have precalculated
illumination included. In this paper we will give an overview of
the most recent techniques in skin shading. We present a
multifaceted implementation of shading techniques by efficiently
combining various approaches. Therefore we will explain physical
and anatomical backgrounds and refer to relevant papers. In our
opinion, this work is a valuable reference to assist shader
developers in their implementations and adaptions on recent and
future graphic hardware.
|
|
Mental Ray Fast Subsurface Scattering Tutorial
2004
Subsurface scattering skin shader tutorial for Mental Ray.
|
|
Skin in the "Dawn" Demo
2003
In particular, the chapter describes the skin shader used in
NVIDIA's "Dawn" real-time demo, which was featured at the SIGGRAPH 2003
Electronic Theater. While the intent of this particular chapter was to
describe how programmable hardware could be used to simulate human skin,
the flexibility offered by programmable hardware has many
ramifications.
|
|
A Rapid Hierarchical Rendering Technique for Translucent Materials
2002
This paper introduces an efficient two-pass rendering
technique for translucent materials. We decouple the computation of
irradiance at the surface from the evaluation of scattering inside the
material. This is done by splitting the evaluation into two passes,
where the first pass consists of computing the irradiance at selected
points on the surface. The second pass uses a rapid hierarchical
integration technique to evaluate a diffusion approximation based on
the irradiance samples. This approach is substantially faster than
previous methods for rendering translucent materials, and it has the
advantage that it integrates seamlessly with both scanline rendering
and global illumination methods. We show several images and animations
from our implementation that demonstrate that the approach is both
fast and robust, making it suitable for rendering translucent
materials in production.
|
|
Voxelized Shadow Volumes
2011
Efficient shadowing algorithms have been sought for
decades, but most shadow research focuses on quickly
identifying shadows on surfaces. This paper introduces a novel
algorithm to efficiently sample light visibility at points
inside a volume. These voxelized shadow volumes (VSVs) extend
shadow maps to allow efficient, si- multaneous queries of
visibility along view rays, or can alternately be seen as a
discretized shadow volume. We voxelize the scene into a binary,
epipolar-space grid where we apply a fast parallel scan to
identify shadowed voxels. Using a view-dependent grid, our GPU
implementation looks up 128 visibility samples along any eye
ray with a single texture fetch. We demonstrate our algorithm
in the context of interactive shadows in homogeneous,
single-scattering participating media.
|
|
Real Time Volumetric Shadows using Polygonal Light Volumes
2010
This paper presents a more efficient way of computing
single scattering effects in homogeneous participating media for
real-time purposes than the currently popular ray-marching based
algorithms. These effects include halos around light sources,
volumetric shadows and crepuscular rays. By displacing the
vertices of a base mesh with the depths from a standard shadow
map, we construct a polygonal mesh that encloses the volume of
space that is directly illuminated by a light source. Using this
volume we can calculate the airlight contribution for each pixel
by considering only points along the eye-ray where
shadow-transitions occur. Unlike previous ray-marching methods,
our method calculates the exact airlight contribution, with
respect to the shadow map resolution, at real time frame
rates.
|
|
Epipolar Sampling for Shadows and Crepuscular Rays in Participating Media with Single Scattering
2010
Scattering in participating media, such as fog or haze, generates
volumetric lighting effects known as crepuscular or god rays. Ren-
dering such effects greatly enhances the realism in virtual scenes,
but is inherently costly as scattering events occur at every point in
space and thus it requires costly integration of the light scattered
towards the observer. This is typically done using ray marching
which is too expensive for every pixel on the screen for interactive
applications. We propose a rendering technique for textured light
sources in single-scattering media, that draws from the concept of
epipolar geometry to place samples in image space: the inscattered
light varies orthogonally to crepuscular rays, but mostly smoothly
along these rays. These are epipolar lines of a plane of light rays
that projects onto one line on the image plane. Our method sam-
ples sparsely along epipolar lines and interpolates between sam-
ples where adequate, but preserves high frequency details that are
caused by shadowing of light rays. We show that our method is
very simple to implement on the GPU, yields high quality images,
and achieves high frame rates.
|
|
Volume Light
2008
Volume Light technique can be considered a simple approximation
of real world light scattering effect. Small particles, sprayed
in the air, interact with light beams and produce different
effects like rainbows or sun shafts. Volumetric effects, are
traditionally considered to be computational heavy, but can be
approximated in realtime. In most cases a convincing look can be
achieved by a good looking effect that integrates seamlessly into
the scene. Thus, volumetric light is going to be a visual effect,
rather than a physically correct simulation.
|
|
GPU Gems 3: Chapter 13. Volumetric Light Scattering as a Post-Process
2007
In this chapter, we present a simple post-process
method that produces the effect of volumetric light scattering
due to shadows in the atmosphere. We improve an existing
analytic model of daylight scattering to include the effect of
volumetric occlusion, and we present its implementation in a
pixel shader. The demo, which is included on the DVD
accompanying this book, shows the technique can be applied to
any animating image of arbitrary scene complexity.
|
|
A Practical Analytic Single Scattering Model for Real Time Rendering∗
2005
We consider real-time rendering of scenes in
participating media, capturing the effects of light scattering
in fog, mist and haze. While a number of sophisticated
approaches based on Monte Carlo and fi- nite element simulation
have been developed, those methods do not work at interactive
rates. The most common real-time methods are essentially simple
variants of the OpenGL fog model. While easy to use and
specify, that model excludes many important qualitative effects
like glows around light sources, the impact of volumetric
scattering on the appearance of surfaces such as the diffusing
of glossy highlights, and the appearance under complex lighting
such as environment maps. In this paper, we present an
alternative physically based approach that captures these
effects while maintaining realtime performance and the
ease-of-use of the OpenGL fog model. Our method is based on an
explicit analytic integration of the single scattering light
transport equations for an isotropic point light source in a
homogeneous participating medium. We can implement the model in
modern programmable graphics hardware using a few small
numerical lookup tables stored as texture maps. Our model can
also be easily adapted to generate the appearances of materials
with arbitrary BRDFs, environment map lighting, and precomputed
radiance transfer methods, in the presence of participating
media. Hence, our techniques can be widely used in real-time
rendering.
|
|
Light Shafts
2004
A 44 slide set.
|
|
Real-Time Rough Refraction
2011
We present an algorithm to render objects of
transparent materials with rough surfaces in real-time, under distant
illumination. Rough surfaces cause wide scattering as light enters
and exits objects, which significantly complicates the rendering of
such materials. We present two contributions to approximate the
successive scattering events at interfaces, due to rough refraction :
First, an approximation of the Bidirectional Transmittance
Distribution Function (BTDF), using spherical Gaussians, suitable for
real-time estimation of environment lighting using pre-convolution;
second, a combination of cone tracing and macro-geometry filtering to
effi- ciently integrate the scattered rays at the exiting interface of
the object. We demonstrate the quality of our approximation by
comparison against stochastic raytracing
|
|
Practical Post-Process Depth of Field
2006
In this chapter we describe a depth-of-field (DoF)
algorithm particularly suited for first-person games. At Infinity
Ward, we pride ourselves on immersing players in a rich cinematic
experience. Consistent with this goal, we developed a technique
for Call of Duty 4: Modern Warfare that provides depth of field's
key qualitative features in both the foreground and the
background with minimal impact on total system performance or
engine architecture. Our technique requires Shader Model 2.0
hardware.
|
|
Rendering Snowing Scene on GPU
2010
As the part of natural sceneries, snow scene is a
familiar natural phenomenon in the north of China. In this
paper, we present a new method to render snow scene on GPU
based particle system. We simulate the whirling snowflakes in
the sky and the snow deposition effect. Our method processes the
birth and death of snow particles via index on CPU and uses a
pair of Floating Point Textures on GPU to store the dynamic
attributes of snow particles. Our method also updates the
dynamic attributes of snow particles, and renders the system on
GPU. We also provide a method based height field and establish
some deposition rules to simulate the snow deposition. Finally,
our experiments prove that our method is feasible and high
performance. Our method can be used in computer animation,
games, special movie effects, etc.
|
|
Real-time Procedural Volumetric Fire
2007
We present a method for generating procedural volumetric fire
in real time. By combining curve-based volumetric free-form
deformation, hardware-accelerated volumetric rendering and
Improved Perlin Noise or M-Noise we are able to render a
vibrant and uniquely animated volumetric fire that supports
bi-directional environmental macro-level interactivity. Our
system is easily customizable by content artists. The fire is
animated both on the macro and micro levels. Macro changes are
controlled either by a prescripted sequence of movements, or by
a realistic particle simulation that takes into account
movement, wind, high-energy particle dispersion and thermal
buoyancy. Micro fire effects such as individual flame shape,
location, and flicker are generated in a pixel shader using
three- to four-dimensional Improved Perlin Noise or M-Noise
(depending on hardware limitations and performance
requirements). Our method supports efficient collision
detection, which, when combined with a sufficiently intelligent
particle simulation, enables real-time bi-directional
interaction between the fire and its environment. The result is
a three-dimensional procedural fire that is easily designed and
animated by content artists, supports dynamic interaction, and
can be rendered in real time.
|
|
Fur (using Shells and Fins)
2007
This sample illustrates the use of a new feature of DirectX 10, the Geometry Shader,
to create new geometry on the fly. The sample uses the shells and fins technique to
render fur on arbitrary triangle meshes. Fins are rendered by creating new geometry
per frame along the silhouette edges of a mesh. Before DirectX 10 this required
adding degenerate triangles to the mesh at every edge but now fins can be generated
efficiently using the Geometry Shader.
|
|
A Parametric Model for Oriented, Navigable Surfaces in Virtual Environments
2006
This paper introduces a parametric model of oriented, navigable
surfaces in virtual environments. An oriented, navigable surface
in 3D space is modeled as a ribbon which has a central axis and
can be twisted around the central axis. The axis is represented
with a cubic spline curve and is approximately arc-length
parameterized. The prole of the ribbon along the axis is
described by a slant function. With the representation of the
ribbon axis and the ribbon pro- le, a point on the ribbon
surface can be expressed as a function of two parameters: the
arc length along the axis and the offset from the axis. The
parametric model of a ribbon naturally forms a local ribbon
coordinate system which provides a frame of reference for
behavior code. In order to provide an uniform, continuous frame
of reference for an agent to navigate through connected ribbons,
we unite the ribbons to form a ribbon called a path.
|
|
Using Vertex Texture Displacement for Realistic Water Rendering
2005
Water surfaces are common in computer graphics, especially in
games. They are a critical element that can significantly
improve the level of realism in a scene. But depicting them
realistically is a hard problem, because of the high visual
complexity present in the motion of water surfaces, as well as
in the way light interacts with water. This chapter describes
techniques developed for rendering realistic depictions of the
ocean for the game Pacific Fighters.
Modern graphics hardware provides a number of useful features with DirectX Shader Model 3.0 that can be used to aid the rendering of water surfaces. This chapter will discuss how one of these features, vertex texturing, can be used to increase the realism of rendered water surfaces. Figure 18-1 shows some sample results. In addition, we also use branching in order to improve the performance of our vertex programs. |
|
Realistic real-time rain rendering
2005
Real-time rendering of virtual weather conditions has been
investigated in many papers. Inserting fog or snow in a scene
is rather straightforward. Rain is one of the most encountered
natural phenomena, but its rendering often lacks realism.
In this paper, we propose a realistic real-time rain rendering method using programmable graphics hardware. In order to simulate the refraction of the scene inside a raindrop, the scene is captured to a texture which is distorted according to optical properties of raindrops. This texture is mapped onto each raindrop. Our method also takes into account retinal persistence, and interaction with light sources. |
|
Curved PN Triangles
2001
To improve the visual quality of existing triangle-based art in
real-time entertainment, such as computer games, we propose replacing
flat triangles with curved patches and higher-order normal variation.
At the hardware level, based only on the three vertices and three
vertex normals of a given flat triangle, we substitute the geometry of
a three-sided cubic Bézier patch for the triangle’s flat geometry, and
a quadratically varying normal for Gouraud shading. These curved
point-normal triangles, or PN triangles, require minimal or no change
to existing authoring tools and hardware designs while providing a
smoother, though not necessarily everywhere tangent continuous,
silhouette and more organic shapes.
|
|
Non-Photorealistic Real-Time Edge Rendering using Non-Duplicate Parallel Detection and Capping
2010
Non-photorealistic rendering (NPR) provides
distinctly different information to the viewer when compared
with photorealistic rendering. Examples of NPR range from
visually pleasing toon and watercolor styles to the highly
precise and informative technical illustration styles. One of
the most important structures that can be found in many
different NPR styles is the humble edge. It can define
boundaries, amplify structure, highlight importance, and is an
essential component of several artistic styles. Their utility
has inspired research on realtime edge detection and rendering
techniques since the early days of computer graphics. There are
dozens of diverse methods to achieve real-time edge detection
and rendering.
In this thesis, a survey of major edge detection methods is presented. The methods in the survey are divided into four distinct categories. Next, Morgan McGuire and John F. Hugh's "Hardware-Determined Edge Features" method is described in detail. It forms the basis for the author's exploration of, and contributions to, edge detection. Then, the author details his attempts to correct the problems with McGuire and Hughes' method. A few alternative methods are explored that take advantage of OpenCL, a new GPU computation technology. Finally, the effectiveness of the contributions are analyzed and compared. |
|
Highlight Lines for Conveying Shape
2007
Recent work has shown that sparse lines defined on 3D shapes,
including occluding contours and suggestive contours, are
effective at conveying shape. We introduce two new families of
lines called suggestive highlights and principal highlights,
based on definitions related to suggestive contours and
geometric creases. We show that when these are drawn in white on
a gray background they are naturally interpreted as highlight
lines, and complement contours and suggestive contours. We
provide object-space definitions and algorithms for extracting
these lines, explore several stylization possibilities, and
compare the lines to ridges and valleys of intensity in
diffuse-shaded images.
|
|
Real-Time Rendering of Cartoon Smoke and Clouds
2006
We describe an algorithm for rendering animated smoke particle
systems in a cartoon style. This style includes outlines and
celshading. For efficient self-shadowing effects, we introduce
nailboard shadow volumes that create complex shadows from few
polygons. Including shadows, the renderer draws only three
polygons per particle and entirely avoids the latency of depth
buffer readback.
We combine the renderer with a fast simulator that generates the phenomenology of real smoke but has artistically controllable parameters. Together they produces real-time interactive smoke animations at over 30 fps. Thus our algorithm is well-suited to applications where interactive performance and expressive power are preferred to realism; for example, video games and rapid development of animation. |
|
Real-Time Pencil Rendering
2006
This paper presents a real-time technique for rendering 3D
meshes in the pencil drawing style. We analyze the
characteristics of pencil drawing and incorporate them into the
rendering process, which is fully implemented on a GPU. For
object contours, we propose a multiple contour drawing technique
that imitates trial-and-errors of human in contour drawing. For
interior shading, we present a simple approach for mapping
oriented textures onto an object surface. To improve the
quality of pencil rendering, we generate and map pencil textures
that reflect the properties of graphite pencils and paper. We
show several rendering examples that demonstrate the high
performance of the proposed technique in terms of speed and
quality.
|
|
Real-Time Pen-and-Ink Illustration of Landscapes
2006
Non-photorealistic rendering has been proven to be particularly
efficient in conveying and transmitting selected visual
information. Our paper presents a NPR rendering pipeline that
supports pen-andink illustration for, but not limited to,
complex landscape scenes in real time. This encompasses a
simplification framework using clustering which enables new
approaches to efficient and coherent rendering of stylized
silhouettes, hatching and abstract shading. Silhouette
stylization is performed in image-space. This avoids explicit
computation of connected lines. Further, coherent hatching of
the tree foliage is performed using an approximate
view-dependent parameterization computed on-the-fly within the
same simplification framework. All NPR algorithms are integrated
with photorealistic rendering, allowing seamless transition and
combination between a variety of photorealistic and
non-photorealistic drawing styles.
|
|
Illustrative Rendering in Team Fortress 2
2006
We present a set of artistic choices and novel real-time shading
techniques which support each other to enable the unique rendering
style of the game Team Fortress 2. Grounded in the conventions
of early 20th century commercial illustration, the look of Team
Fortress 2 is the result of tight collaboration between artists and engineers.
In this paper, we will discuss the way in which the art
direction and technology choices combine to support artistic goals
and gameplay constraints. In addition to achieving a compelling
style, the shading techniques are designed to quickly convey geometric
information using rim highlights as well as variation in luminance
and hue, so that game players are consistently able to visually
"read" the scene and identify other players in a variety of lighting
conditions.
|
|
Real-Time Halftoning: Fast and Simple Stylized Shading
2004
This gem introduces halftoning as a way for implementing
non-photorealistic rendering styles for computer games. The
technique uses only the conventional multi-texturing pipeline on
common hardware. We show how to create halftone screens for
images that resemble pen-and-ink drawing styles and how to
implement fast halftone rendering with modest pixel shading
hardware.
|
|
IMPaSTo: A Realistic, Interactive Model for Paint
2004
We present a paint model for use in interactive painting systems
that captures a wide range of styles similar to oils or
acrylics. The model includes both a numerical simulation to
recreate the physical flow of paint and an optical model to
mimic the paint appearance.
Our physical model for paint is based on a conservative advection scheme that simulates the basic dynamics of paint, augmented with heuristics that model the remaining key properties needed for painting. We allow one active wet layer, and an unlimited number of dry layers, with each layer being represented as a height-field. We represent paintings in terms of paint pigments rather than RGB colors, allowing us to relight paintings under any full-spectrum illuminant. We also incorporate an interactive implementation of the Kubelka-Munk diffuse reflectance model, and use a novel eightcomponent color space for greater color accuracy. We have integrated our paint model into a prototype painting system, with both our physical simulation and rendering algorithms running as fragment programs on the graphics hardware. The system demonstrates the model's effectiveness in rendering a variety of painting styles from semi-transparent glazes, to scumbling, to thick impasto. |
|
Estimating Curvatures and Their Derivatives on Triangle Meshes
2004
The computation of curvature and other differential
properties of surfaces is essential for many techniques in analysis
and rendering. We present a finite-differences approach for estimating
curvatures on irregular triangle meshes that may be thought of as an
extension of a common method for estimating per-vertex normals. The
technique is efficient in space and time, and results in significantly
fewer outlier estimates while more broadly offering accuracy
comparable to existing methods. It generalizes naturally to computing
derivatives of curvature and higher-order surface differentials.
|
|
Non-Photorealistic Rendering Techniques for Motion in Computer Games
2004
Still images can portray motion by using a stylized
technique. Most of these techniques are commonly used for
dynamic images as well (e.g., for cartoons). Typically, an
artist abstracts the motion of a specific scene or animation to
illustrate movement. Depicting motion in real-time environments
is no less essential, and therefore a similar approach is
desirable. Our approach is focused on three methods to stylize
motion: squash-and-stretch, multiple images, and motion lines. A
discussion of these methods for depicting motion in dynamic
images and an implementation are presented in this
paper. Finally, we discuss the results and conclude with the
outlook for further development.
|
|
Pen-and-ink textures for real-time rendering
2003
Simulation of a pen-and-ink illustration style in a realtime
rendering system is a challenging computer graphics
problem. Tonal art maps (TAMs) were recently suggested as a
solution to this problem. Unfortunately, only the hatching
aspect of pen-and-ink media was addressed thus far. We extend
the TAM approach and enable representation of arbitrary
textures. We generate TAM images by distributing stroke
primitives according to a probability density function. This
function is derived from the input image and varies depending on
the TAM's scale and tone levels. The resulting depiction of
textures approximates various styles of pen-and-ink
illustrations such as outlining, stippling, and hatching.
|
|
Hatching Stroke Styles & Pointillism
2003
Hatching is a common technique used in Non-Photorealistic
Rendering (NPR). For hatching, series of strokes are combined
into textures. These compositions of strokes can convey the
surface form through stroke orientation, the surface material
through stroke arrangement and style, and the effect of light on
the surface through stroke density. Up until now an important
issue of real-time hatching techniques has been how to employ
the limited programmability of the graphics hardware currently
available. Pixel programmability has now reached a state where
we can shift the focus to adding more flexibility to the
hatching scheme and combining hatching with other techniques for
creating new effects. We present a hatching scheme and some
extensions to it, namely interactively changing the stroke
style, and hatching with specular highlights. As an application,
we show how we integrate hand drawings into a scene taking into
account the effect of lighting. Finally, we show how to choose a
color for each stroke depending on the background color, which
can be used for a pointillistic style.
|
|
Non-Photorealistic Rendering
2002
Rendering in computer graphics means the process by
which a virtual scene is converted into an image. Pioneer work
in computer graphics was done to achieve photorealism. The goal
was to create synthetic images that can be mistaken by
photographs.
It is rather absurd that a field of study is named after what it is not. Stanislaw Ulam said once that "The study of non-linear physics is like the study of non-elephant biology". Non-photorealistic rendering is the means of generate imaging that does not aspire to realism. It is difficult to express what exactly it is, therefore it is easier to express what it is not. Photorealism has a lot of applications (special ef- Figure 1: Van Gogh, The Starry Night(June 1889) fects, design visualization and so on). But simulating reality is not as important as creating the illusion of reality in the mind of the observer. There are several motivations for generating images that does not pretend to simulate reality. |
|
Fine Tone Control in Hardware Hatching
2002
Recent advances in NPR have enabled real-time rendering of 3D
models shaded with hatching strokes for use in interactive
applications. The key challenges in real-time hatching are to
convey tone by dynamically adjusting stroke density, while
controlling stroke size and maintaining frame-to-frame
coherence. In this paper, we introduce two new real-time
hatching schemes that leverage recent advances in texture
mapping hardware. Both schemes provide enhanced control of tone,
thereby avoiding blending or aliasing artifacts present in
previous systems. The first scheme, which relies on volume
rendering hardware, admits the use of color. The second scheme,
which uses pixel shaders, allows per-pixel lighting operations
such as texture modulation. Both schemes run at interactive
rates on inexpensive PC graphics cards.
|
|
Real-Time Halftoning: A Primitive For Non-Photorealistic Shading
2002
We introduce halftoning as a general primitive for real-time
non-photorealistic shading. It is capable of producing a variety
of rendering styles, ranging from engraving with
lighting-dependent line width to pen-and-ink style drawings
using prioritized stroke textures. Since monitor resolution is
limited we employ a smooth threshold function that provides
stroke antialiasing.
By applying the halftone screen in texture space and evaluating the threshold function for each pixel we can influence the shading on a pixel-by-pixel basis. This enables many effects to be used, including indication mapping and individual stroke lighting. Our real-time halftoning method is a drop-in replacement for conventional multitexturing and runs on commodity hardware. Thus, it is easy to integrate in existing applications, as we demonstrate with an artistically rendered level in a game engine. |
|
Non-Photorealistic Rendering Techniques for Real-Time Character
Animation
2002
In this thesis, we present the results of an investigation into
the use of nonphotorealistic rendering techniques for real-time
character animation. So far, most non-photorealistic rendering
methods have only been applied to simple, static scenes. In the
context of real-time character animation, a number of special
technical issues arise that put much higher requirements on the
rendering algorithms. Based on established techniques, we
examine and extend a number of different non-photorealistic
rendering techniques and integrate them into a real-time
animation system. We analyse the results with respect to a
number of different criteria and develop ideas for extending and
refining the presented techniques. Furthermore, we motivate our
work by putting it into the context of computer depiction and
related fields such as fine arts and psychology.
|
|
Real-Time Hatching
2001
Drawing surfaces using hatching strokes simultaneously conveys
material, tone, and form. We present a system for real-time
rendering of hatching strokes over arbitrary surfaces, in a
variety of non-photorealistic styles. During an automatic
preprocess, we construct a sequence of mip-mapped hatch images
corresponding to different tones, collectively called a tonal
art map. Strokes within the hatch images are scaled to attain
appropriate stroke size and density at all resolutions, and are
organized to maintain coherence across scales and tones. At
runtime, hardware multitexturing blends the hatch images over
the rendered faces to locally vary tone while maintaining both
spatial and temporal coherence. In order to render strokes over
arbitrary surfaces, we build a lapped texture parametrization
where the overlapping patches align to a curvaturebased
direction field. By exploiting modern texture-mapping hardware,
our scheme convincingly renders hatching strokes in real-time on
a variety of complex surfaces.
|
|
Hardware-Determined Feature Edges
2000
Algorithms that detect silhouettes, creases, and other edge
based features often perform per-edge and per-face mesh
computations using global adjacency information. These are
unsuitable for hardware-pipeline implementation, where
programmability is at the vertex and pixel level and only local
information is available. Card and Mitchell and Gooch have
suggested that adjacency information could be packed into a
vertex data structure; we describe the details of converting
global/per-edge computations into local/per-vertex computations
on a related edge mesh. Using this trick, we describe a
feature-edge detection algorithm that runs entirely in hardware,
and show how to use it to create thick screen-space contours
with end-caps that join adjacent thick line segments. The
end-cap technique favors speed over quality and produces
artifacts for some meshes.
We present two parameterizations for mapping stroke textures onto these thick line's tessellation-independent screen space method that is better suited to still images, and an object space method better suited to animation. As additional applications, we show how to create fins for fur rendering and how to extrude contours in world-space to create the sides of a shadow volume directly on the GPU. The edge mesh is about nine times larger than the original mesh when stored at 16-bit precision and is constructed through a linear time pre-processing step. As long as topology remains fixed, the edge mesh can be animated as if it were a vertex mesh. |
|
Introduction to 3D Non-Photorealistic Rendering: Silhouettes and
Outlines
2000
In these notes, we survey some of the basic tools used for
non-photorealistic rendering of 3D scenes. We will primarily
focus on detecting outlines of object shape: silhouettes,
boundaries, and creases. (Hatching and shading, which are also
very important for communicating shape, are discussed elsewhere
in the course notes.) The algorithms in this section can be
divided into algorithms that operate in the image space (2D),
and algorithms that operate in world space (3D).
|
|
Art-Based Rendering of Fur, Grass, and Trees
1999
Artists and illustrators can evoke the complexity of fur or
vegetation with relatively few well-placed strokes. We present
an algorithm that uses strokes to render 3D computer graphics
scenes in a stylized manner suggesting the complexity of the
scene without representing it explicitly. The basic algorithm is
customizable to produce a range of effects including fur, grass
and trees, as we demonstrate in this paper and accompanying
video. The algorithm is implemented within a broader framework
that supports procedural stroke-based textures on polyhedral
models. It renders moderately complex scenes at multiple frames
per second on current graphics workstations, and provides some
interframe coherence.
|
|
Real-Time Nonphotorealistic Rendering
1997
Nonphotorealistic rendering (NPR) can help make comprehensible
but simple pictures of complicated objects by employing an
economy of line. But current nonphotorealistic rendering is
primarily a batch process. This paper presents a real-time
nonphotorealistic renderer that deliberately trades accuracy and
detail for speed. Our renderer uses a method for determining
visible lines and surfaces which is a modification of Appel's
hidden-line algorithm, with improvements which are based on the
topology of singular maps of a surface into the plane. The
method we describe for determining visibility has the potential
to be used in any NPR system that requires a description of
visible lines or surfaces in the scene. The major contribution
of this paper is thus to describe a tool which can significantly
improve the performance of these systems.We demonstrate the
systemwith several nonphotorealistic rendering styles, all of
which operate on complex models at interactive frame rates.
|
|
Simulating the structure and texture of solid wood
2016
Wood is an important decorative material prized for
its unique appearance. It is commonly rendered using artistically
authored 2D color and bump textures, which reproduces color
patterns on flat surfaces well. But the dramatic anisotropic
specular figure caused by wood fibers, common in curly maple and
other species, is harder to achieve. While suitable BRDF models
exist, the texture parameter maps for these wood BRDFs are
difficult to author—good results have been shown with elaborate
measurements for small flat samples, but these models are not
much used in practice. Furthermore, mapping 2D image textures
onto 3D objects leads to distortion and
inconsistencies. Procedural volumetric textures solve these
geometric problems, but existing methods produce much lower
quality than image textures. This paper aims to bring the best of
all these techniques together: we present a comprehensive
volumetric simulation of wood appearance, including growth rings,
color variation, pores, rays, and growth distortions. The fiber
directions required for anisotropic specular figure follow
naturally from the distortions. Our results rival the quality of
textures based on photographs, but with the consistency and
convenience of a volumetric model. Our model is modular, with
components that are intuitive to control, fast to compute, and
require minimal storage.
|
|
Procedural wood textures
2015
Existing bidirectional reflectance distribution
function (BRDF) models are capable of capturing the distinctive
highlights produced by the fibrous nature of wood. However,
capturing parameter textures for even a single specimen remains a
laborious process requiring specialized equipment. In this paper
we take a procedural approach to generating parameters for the
wood BSDF. We characterize the elements of trees that are
important for the appearance of wood, discuss techniques
appropriate for representing those features, and present a
complete procedural wood shader capable of reproducing the growth
patterns responsible for the distinctive appearance of highly
prized “figured” wood. Our procedural wood shader is
random-access, 3D, modular, and is fast enough to generate a
preview for design.
|
|
Measuring and Modeling the Appearance of Finished Wood
2005
Wood coated with transparent finish has a beautiful
and distinctive appearance that is familiar to everyone. Woods
with unusual grain patterns, such as tiger, burl, and birdseye
figures, have a strikingly unusual directional reflectance that
is prized for decorative applications. With new, high resolution
measurements of spatially varying BRDFs, we show that this
distinctive appearance is due to light scattering that does not
conform to the usual notion of anisotropic surface
reflection. The behavior can be explained by scattering from the
matrix of wood fibers below the surface, resulting in a
subsurface highlight that occurs on a cone with an out-of-plane
axis. We propose a new shading model component to handle
reflection from subsurface fibers, which is combined with the
standard diffuse and specular components to make a complete
shading model. Rendered results from fits of our model to the
measurement data demonstrate that this new model captures the
distinctive appearance of wood.
|
|
Generating Textures of New Zealand Native Wood
2002
This report explores algorithms for computer
generated textures simulating New Zealand native wood, we out
line procedural texturing algorithms like Perlin noise and
turbulence, techniques like texture generation, texture mapping
and Ray tracing. The main goal of this research is to study New
Zealand native wood in depth and to gather sufficient information
to be able to generate realistic and detailed 3D texture for New
Zealand native woods. In particular this work shows the
development of texture for Kauri out of New Zealand’s most famous
native trees, and with Rimu.
|
|
Variance-Aware Path Guiding
2020
Path guiding is a promising tool to improve the
performance of path tracing algorithms. However, not much
research has investigated what target densities a guiding method
should strive to learn for optimal performance. Instead, most
previous work pursues the zero-variance goal: The local decisions
are guided under the assumption that all other decisions along
the random walk will be sampled perfectly. In practice, however,
many decisions are poorly guided, or not guided at
all. Furthermore, learned distributions are often marginalized,
e.g., by neglecting the BSDF. We present a generic procedure to
derive theoretically optimal target densities for local path
guiding. These densities account for variance in nested
estimators, and marginalize provably well over, e.g., the
BSDF. We apply our theory in two state-of-the-art rendering
applications: a path guiding solution for unidirectional path
tracing [Müller et al. 2017] and a guiding method for light
source selection for the many lights problem [Vévoda et
al. 2018]. In both cases, we observe significant improvements,
especially on glossy surfaces. The implementations for both
applications consist of trivial modifications to the original
code base, without introducing any additional overhead.
|
|
Spatiotemporal reservoir resampling for real-time ray tracing with dynamic direct lighting -- Supplemental document
2020
Supplemental document.
|
|
Spatiotemporal reservoir resampling for real-time ray tracing with dynamic direct lighting
2020
Efficiently rendering direct lighting from millions
of dynamic light sources using Monte Carlo integration remains a
challenging problem, even for off-line rendering systems. We
introduce a new algorithm—ReSTIR—that renders such lighting
interactively, at high quality, and without needing to maintain
complex data structures. We repeatedly resample a set of
candidate light samples and apply further spatial and temporal
resampling to leverage information from relevant nearby
samples. We derive an unbiased Monte Carlo estimator for this
approach, and show that it achieves equal-error 6×-60× faster
than state-of-the-art methods. A biased estimator reduces noise
further and is 35×-65× faster, at the cost of some energy
loss. We implemented our approach on the GPU, rendering complex
scenes containing up to 3.4 million dynamic, emissive triangles
in under 50 ms per frame while tracing at most 8 rays per pixel.
|
|
Weakly Supervised Contrastive Learning in Path Manifold for Monte Carlo Image Reconstruction
2021
Image-space auxiliary features such as surface normal
have significantly contributed to the recent success of Monte Carlo
(MC) reconstruction networks. However, path-space features, another
essential piece of light propagation, have not yet been sufficiently
explored. Due to the curse of dimensionality, information flow between
a regression loss and high-dimensional path-space features is sparse,
leading to difficult training and inefficient usage of pathspace
features in a typical reconstruction framework. This paper introduces
a contrastive manifold learning framework to utilize path-space
features effectively. The proposed framework employs weakly-supervised
learning that converts reference pixel colors to dense pseudo labels
for light paths. A convolutional path-embedding network then induces
a low-dimensional manifold of paths by iteratively clustering
intra-class embeddings, while discriminating inter-class embeddings
using gradient descent. The proposed framework facilitates path-space
exploration of reconstruction networks by extracting low-dimensional
yet meaningful embeddings within the features. We apply our framework
to the recent image- and sample-space models and demonstrate
considerable improvements, especially on the sample space. The source
code is available at https://github.com/Mephisto405/WCMC.
|
|
Real-time Neural Radiance Caching for Path Tracing
2021
We present a real-time neural radiance caching method
for path-traced global illumination. Our system is designed to handle
fully dynamic scenes, and makes no assumptions about the lighting,
geometry, and materials. The data-driven nature of our approach
sidesteps many difficulties of caching algorithms, such as locating,
interpolating, and updating cache points. Since pretraining neural
networks to handle novel, dynamic scenes is a formidable
generalization challenge, we do away with pretraining and instead
achieve generalization via adaptation, i.e. we opt for training the
radiance cache while rendering. We employ self-training to provide
low-noise training targets and simulate infinite-bounce transport by
merely iterating few-bounce training updates. The updates and cache
queries incur a mild overhead—about 2.6ms on full HD resolution—thanks
to a streaming implementation of the neural network that fully
exploits modern hardware. We demonstrate significant noise reduction
at the cost of little induced bias, and report state-of-the-art,
real-time performance on a number of challenging scenarios
|
|
Interactive Monte Carlo Denoising Using Affinity of Neural Features
2021
High-quality denoising of Monte Carlo low-sample
renderings remains a critical challenge for practical interactive ray
tracing. We present a new learning-based denoiser that achieves
state-of-the-art quality and runs at interactive rates. Our model
processes individual path-traced samples with a lightweight neural
network to extract per-pixel feature vectors. The rest of our pipeline
operates in pixel space. We define a novel pairwise affinity over the
features in a pixel neighborhood, from which we assemble dilated
spatial kernels to filter the noisy radiance. Our denoiser is
temporally stable thanks to two mechanisms. First, we keep a running
average of the noisy radiance and intermediate features, using a
per-pixel recursive filter with learned weights. Second, we use a
small temporal kernel based on the pairwise affinity between features
of consecutive frames. Our experiments show our new affinities lead to
higher quality outputs than techniques with comparable computational
costs, and better high-frequency details than kernel-predicting
approaches. Our model matches or outperfoms state-ofthe-art offline
denoisers in the low-sample count regime (2–8 samples per pixel), and
runs at interactive frame rates at 1080p resolution.
|
|
Hierarchical Neural Reconstruction for Path Guiding Using Hybrid Path and Photon Samples
2021
Path guiding is a promising technique to reduce the
variance of path tracing. Although existing online path guiding
algorithms can eventually learn good sampling distributions given a
large amount of time and samples, the speed of learning becomes a
major bottleneck. In this paper, we accelerate the learning of
sampling distributions by training a light-weight neural network
offline to reconstruct from sparse samples. Uniquely, we design our
neural network to directly operate convolutions on a sparse quadtree,
which regresses a highquality hierarchical sampling distribution. Our
approach can reconstruct reasonably accurate sampling distributions
faster, allowing for efficient path guiding and rendering. In contrast
to the recent offline neural path guiding techniques that reconstruct
low-resolution 2D images for sampling, our novel hierarchical
framework enables more fine-grained directional sampling with less
memory usage, effectively advancing the practicality and efficiency of
neural path guiding. In addition, we take advantage of hybrid
bidirectional samples including both path samples and photons, as we
have found this more robust to different light transport scenarios
compared to using only one type of sample as in previous
work. Experiments on diverse testing scenes demonstrate that our
approach often improves rendering results with better visual quality
and lower errors. Our framework can also provide the proper balance of
speed, memory cost, and robustness.\
|
|
Spatiotemporal reservoir resampling for real-time ray tracing with dynamic direct lighting
2020
Efficiently rendering direct lighting from millions
of dynamic light sources using Monte Carlo integration remains a
challenging problem, even for off-line rendering systems. We introduce
a new algorithm—ReSTIR—that renders such lighting interactively, at
high quality, and without needing to maintain complex data
structures. We repeatedly resample a set of candidate light samples
and apply further spatial and temporal resampling to leverage
information from relevant nearby samples. We derive an unbiased Monte
Carlo estimator for this approach, and show that it achieves
equal-error 6×-60× faster than state-of-the-art methods. A biased
estimator reduces noise further and is 35×-65× faster, at the cost of
some energy loss. We implemented our approach on the GPU, rendering
complex scenes containing up to 3.4 million dynamic, emissive
triangles in under 50 ms per frame while tracing at most 8 rays per
pixel.
|
|
Neural Temporal Adaptive Sampling and Denoising
2020
Despite recent advances in Monte Carlo path tracing
at interactive rates, denoised image sequences generated with few
samples per-pixel often yield temporally unstable results and loss of
high-frequency details. We present a novel adaptive rendering method
that increases temporal stability and image fidelity of low sample
count path tracing by distributing samples via spatio-temporal joint
optimization of sampling and denoising. Adding temporal optimization
to the sample predictor enables it to learn spatio-temporal sampling
strategies such as placing more samples in disoccluded regions,
tracking specular highlights, etc; adding temporal feedback to the
denoiser boosts the effective input sample count and increases
temporal stability. The temporal approach also allows us to remove the
initial uniform sampling step typically present in adaptive sampling
algorithms. The sample predictor and denoiser are deep neural networks
that we co-train end-to-end over multiple consecutive frames. Our
approach is scalable, allowing trade-off between quality and
performance, and runs at near real-time rates while achieving
significantly better image quality and temporal stability than
previous methods.
|
|
Sample-based Monte Carlo Denoising using a Kernel-Splatting Network
2019
Denoising has proven to be useful to efficiently
generate high-quality Monte Carlo renderings. Traditional pixel-based
denoisers exploit summary statistics of a pixel’s sample
distributions, which discards much of the samples’ information and
limits their denoising power. On the other hand, samplebased
techniques tend to be slow and have difficulties handling general
transport scenarios. We present the first convolutional network that
can learn to denoise Monte Carlo renderings directly from the
samples. Learning the mapping between samples and images creates new
challenges for the network architecture design: the order of the
samples is arbitrary, and they should be treated in a permutation
invariant manner. To address these challenges, we develop a novel
kernel-predicting architecture that splats individual samples onto
nearby pixels. Splatting is a natural solution to situations such as
motion blur, depth-of-field and many light transport paths, where it
is easier to predict which pixels a sample contributes to, rather than
a gather approach that needs to figure out, for each pixel, which
samples (or nearby pixels) are relevant. Compared to previous
state-of-the-art methods, ours is robust to the severe noise of
low-sample count images (e.g. 8 samples per pixel) and yields
higher-quality results both visually and numerically. Our approach
retains the generality and efficiency of pixel-space methods while
enjoying the expressiveness and accuracy of the more complex
sample-based approaches.
|
|
Kernel-Predicting Convolutional Networks for Denoising Monte Carlo Renderings
2017
Regression-based algorithms have shown to be good at
denoising Monte Carlo (MC) renderings by leveraging its inexpensive
by-products (e.g., feature buffers). However, when using higher-order
models to handle complex cases, these techniques often overt to
noise in the input. For this reason, supervised learning methods have
been proposed that train on a large collection of reference examples,
but they use explicit filters that limit their denoising ability. To
address these problems, we propose a novel, supervised learning
approach that allows the filtering kernel to be more complex and
general by leveraging a deep convolutional neural network (CNN)
architecture. In one embodiment of our framework, the CNN directly
predicts the final denoised pixel value as a highly non-linear
combination of the input features. In a second approach, we introduce
a novel, kernel-prediction network which uses the CNN to estimate the
local weighting kernels used to compute each denoised pixel from its
neighbors. We train and evaluate our networks on production data and
observe improvements over state-of-theart MC denoisers, showing that
our methods generalize well to a variety of scenes. We conclude by
analyzing various components of our architecture and identify areas of
further research in deep learning for MC denoising.
|
|
Ray Tracing Gems II
2021
In 2018, real-time ray tracing arrived in consumer
GPU hardware and swiftly established itself as a key component of how
images would be generated moving forward. Now, three years later, the
second iteration of this hardware is available, mainstream game
consoles support ray tracing, and cross-platform API standards have
been established to drive even wider adoption. Developers and
researchers have been busy inventing (and reinventing) algorithms to
take advantage of the new possibilities created by these
advancements. The “gems” of knowledge discovered during this process
are what you will fnd in the pages that follow.
|
|
Ray Tracing Gems
2020
High-Quality and Real-Time Rendering
with DXR and Other APIs
|
|
Continuous Multiple Importance Sampling
2020
Multiple importance sampling (MIS) is a provably good
way to combine a finite set of sampling techniques to reduce
variance in Monte Carlo integral estimation. However, there exist
integration problems for which a continuum of sampling techniques
is available. To handle such cases we establish a continuous MIS
(CMIS) formulation as a generalization of MIS to uncountably
infinite sets of techniques. Our formulation is equipped with a
base estimator that is coupled with a provably optimal balance
heuristic and a practical stochastic MIS (SMIS) estimator that
makes CMIS accessible to a broad range of problems. To illustrate
the effectiveness and utility of our framework, we apply it to
three different light transport applications, showing improved
performance over the prior state-of-the-art techniques.
|
|
Understanding the Masking-Shadowing Function in Microfacet-Based BRDFs
2014
We provide a new presentation of the
masking-shadowing functions (or geometric attenuation factors) in
microfacet-based BRDFs and answer some common questions about
their applications. Our main motivation is to define a correct
(geometrically indicated), physically based masking function for
application in microfacet models, as well as the properties that
function should exhibit. Indeed, several different masking
functions are often presented in the literature and making the
right choice is not always obvious. We start by showing that
physically based masking functions are constrained by the
projected area of the visible microsurface onto the outgoing
direction. We use this property to derive the distribution of
visible normals from the microsurface, whose normalization factor
is the masking function. We then show how the common form of
microfacet-based BRDFs emerges from this distribution. As a
consequence, the masking function is related to the correct
normalization of microfacetbased BRDFs. However, while the
correct masking function satisfies these normalization
constraints, its explicit form is can only be determined for a
given microsurface profile. Our derivation emphasizes that under
the assumptions of their respective microsurface profiles, both
Smith’s function and the V-cavity masking function are
correct. However, we show that the V-cavity microsurface yields
results that miss the effect of occlusion, making it analogous to
the shading of a normal map instead of a displacement map. This
observation explains why the V-cavity model yields incorrect
glossy highlights at grazing view angles. We also review other
common masking functions, which are not associated with a
microsurface profile and thus are not physically based. The
insights gained from these observations motivate new research
directions in the field of microfacet theory. For instance, we
show that masking functions are stretch invariant and we show how
this property can be used to derive the masking function for
anisotropic microsurfaces in a straightforward way. We also
discuss future work such as the incorporation of multiple
scattering on the microsurface into BRDF models.
|
|
Importance Sampling Microfacet-Based BSDFs using the Distribution of Visible Normals -- supplemental material
2014
We present a new approach to microfacet-based BSDF
importance sampling. Previously proposed sampling schemes for
popular analytic BSDFs typically begin by choosing a microfacet
normal at random in a way that is independent of direction of
incident light. To sample the full BSDF using these normals
requires arbitrarily large sample weights leading to possible
fireflies. Additionally, at grazing angles nearly half of the
sampled normals face away from the incident ray and must be
rejected, making the sampling scheme inefficient. Instead, we
show how to use the distribution of visible normals directly to
generate samples, where normals are weighted by their projection
factor toward the incident direction. In this way, no backfacing
normals are sampled and the sample weights contain only the
shadowing factor of outgoing rays (and additionally a Fresnel
term for conductors). Arbitrarily large sample weights are
avoided and variance is reduced. Since the BSDF depends on the
microsurface model, we describe our sampling algorithm for two
models: the V-cavity and the Smith models. We demonstrate results
for both isotropic and anisotropic rough conductors and
dielectrics with Beckmann and GGX distributions.
|
|
Importance Sampling Microfacet-Based BSDFs using the Distribution of Visible Normals
2014
We present a new approach to microfacet-based BSDF
importance sampling. Previously proposed sampling schemes for
popular analytic BSDFs typically begin by choosing a microfacet
normal at random in a way that is independent of direction of
incident light. To sample the full BSDF using these normals
requires arbitrarily large sample weights leading to possible
fireflies. Additionally, at grazing angles nearly half of the
sampled normals face away from the incident ray and must be
rejected, making the sampling scheme inefficient. Instead, we
show how to use the distribution of visible normals directly to
generate samples, where normals are weighted by their projection
factor toward the incident direction. In this way, no backfacing
normals are sampled and the sample weights contain only the
shadowing factor of outgoing rays (and additionally a Fresnel
term for conductors). Arbitrarily large sample weights are
avoided and variance is reduced. Since the BSDF depends on the
microsurface model, we describe our sampling algorithm for two
models: the V-cavity and the Smith models. We demonstrate results
for both isotropic and anisotropic rough conductors and
dielectrics with Beckmann and GGX distributions.
|
|
GPU Ray Marching of Distance Fields
2012
Computer Graphics since its existence has been
striving to visualize its representations of surfaces and objects
to accurately match their real life counterparts. We investigate
the correctness of the ambient occlusion effect produced with the
use of a distance to the closest surface metric. This value is
obtained from a signed distance function/field. We evaluate the
robustness of the method as well as its ease of use. We also test
how this applies to a polygon mesh converted into a 3D texture of
distance values and included into our scenes. For rendering
images we use our GPU implementation of ray marching in the form
of sphere tracing and we compare the results to the ones produced
by a ray tracing framework.
|
|
Adaptive Rendering with Non-Local Means Filtering
2012
We propose a novel approach for image space adaptive sampling and
filtering in Monte Carlo rendering. We use an iterative scheme
composed of three steps. First, we adaptively distribute samples in
the image plane. Second, we denoise the image using a non-linear
filter. Third, we estimate the residual per-pixel error of the
filtered rendering, and the error estimate guides the sample
distribution in the next iteration. The effectiveness of our approach
hinges on the use of a state of the art image denoising technique,
which we extend to an adaptive rendering framework. A key idea is to
split the Monte Carlo samples into two buffers. This improves
denoising performance and facilitates variance and error
estimation. Our method relies only on the Monte Carlo samples,
allowing us to handle arbitrary light transport and lens effects. In
addition, it is robust to high noise levels and complex image
content. We compare our approach to a state of the art adaptive
rendering technique based on adaptive bandwidth selection and
demonstrate substantial improvements in terms of both numerical error
and visual quality. Our framework is easy to implement on top of
standard Monte Carlo renderers and it incurs little computational
overhead.
|
|
A Survey of Importance Sampling Applications in Unbiased Physically Based Rendering
2011
In this survey, we will discuss the application of importance sampling to the field of unbiased
physically based rendering. Unbiased rendering algorithms are based on the Monte Carlo
method. In this context, importance sampling techniques are used to reduce the variance of
the Monte Carlo estimate. Importance sampling has played an important role in the develop-
ment of the field of unbiased rendering and has let to three major rendering algorithms: Path
Tracing (PT), Bidirectional Path Tracing (BDPT) and Metropolis Light Transport (MLT).
In our discussion, we will focus on these algorithms, discussing them in detail. Furthermore,
we will more briefly discuss important extensions to these algorithms, based on importance
sampling.
|
|
Unbiased physically based rendering on the GPU
2010
Since the introduction of General-Purpose GPU
computing, there has been a significant increase in ray traversal
performance on the GPU. While CPU’s perform reasonably well on
coherent rays with similar origin and direction, on current hardware
the GPU vastly outperforms the CPU when it comes to incoherent rays,
required for unbiased rendering. A number of path tracers have been
implemented on the GPU, pulling unbiased physically based rendering to
the GPU. However, since the introduction of the path tracing
algorithm, the field of unbiased physically based rendering has made
significant advances. Notorious improvements are BiDirectional Path
Tracing and the Metropolis Light Transport algorithm. As of now little
effort has been made to implement these more advanced algorithms on
the GPU.
The goal of this thesis is to find efficient GPU implementations for unbiased physically based rendering methods. The CUDA framework is used for the GPU implementation. To justify the attempts for moving the sampling algorithm to the GPU, a hybrid architecture is investigated first, implementing the sampling algorithm on the CPU while using the GPU as a ray traversal and intersection co-processor. Results show that today’s CPU’s are not well suited for this architecture, making the CPU memory bandwidth a large bottleneck. We therefore propose three streaming GPU-only rendering algorithms: a Path Tracer (PT), a BiDirectional Path Tracer (BDPT) and an Energy Redistribution Path Tracer (ERPT). The streaming PT uses compaction to remove all terminated paths from the stream, leaving a continuous stream of active samples. New paths are regenerated in large batches at the end of the stream, thereby exploiting primary ray coherence during traversal. A streaming BDPT is obtained by using a recursive reformulation of the Multiple Importance Sampling computations. This requires only storage for a single light and eye vertex in memory at any time during sample evaluation, making the method’s memory-footprint independent of the maximum path length and allowing high SIMT efficiency. We propose an alternative mutation strategy for the ERPT method, further improving the convergence of the algorithm. Using this strategy, a GPU implementation of the ERPT method is presented. By sharing mutation chains between all threads within a GPU warp, efficiency and memory coherence is retained. Finally, the performance of these methods is evaluated and it is shown that the convergence characteristics of the original methods are preserved in our GPU implementations. |
|
Importance Sampling for Production Rendering
2010
\
Importance sampling provides a practical, production-proven method for
integrating diffuse and glossy surface reflections with arbitrary
image-based environment or area lighting constructs. Here, functions
are evaluated at random points across a domain to produce an estimate
of an integral. When using a large number of sample points, the method
produces a very accurate result of the integral and provides a strong
basis for simulating complex problems such as light transport.
Frequently, using the necessary number of samples to reach the exact result is too computationally expensive and fewer samples are evaluated at the cost of visual noise, or variance, within the image. Importance sampling offers a means to reduce the variance by skewing the samples toward regions of the illumination integral that provide the most energy. For instance, the direction of specular reflection or a bright light source within an environment more likely represent the final value of the integral than a random sample. The variance can be reduced more efficiently by combining multiple components of the illumination integral, such as the lighting and material function, to determine where to sample, which is the principle of Multiple Importance Sampling (MIS). As an alternative to the noise in importance sampling, Filtered Importance Sampling (FIS) can provide fast integration, where the lighting environment look-ups are prefiltered to give a smoother result with a significantly smaller number of samples. Importance sampling, MIS and FIS have various practical implications. In thi`s quarter-day course, we cover the necessary background for using Monte Carlo-based techniques for direct lighting and explain how various visual effects companies use these shading methods in their production pipelines. |
|
Incremental calculation of weighted mean and variance
2009
In these notes I explain how to derive formulae for
numerically stable calculation of the mean and standard deviation,
which are also suitable for incremental on-line calculation. I then
generalize these formulae to weighted means and standard deviations. I
unpick the difficulties that arise when generalizing further to
normalized weights. Finally I show that the exponentially weighted
moving average is a special case of the incremental normalized
weighted mean formula, and derive a formula for the exponentially
weighted moving standard deviation.
|
|
Bidirectional Path Tracing
2009
In this report we present the bidirectional path
tracing method. Bidirectional path tracing combines the ideas of
shooting and gathering light to create photorealistic images. We
discuss, how the well known path tracing algorithm and the light
tracing algortihm are subsets of the bidirectional path tracing
algorithm. Finally we will show tests that shows how
bidirectional path tracing can decrease the noise, in rendered
images, in curtain scenes.
|
|
Ray tracing implicit surfaces on the GPU
2008
In this paper we examine the methods of rendering
implicit surfaces with a per-pixel approach. Ray tracing
the implicit model directly has several benefits as
opposed to processing tessellated meshes, but also
invokes new kinds of problems. The main challenge is
efficiently finding the first ray-surface intersection point
where the surface is not given in an explicit form. Our
implementation uses the sphere tracing algorithm to
attack this problem and runs on the GPU to achieve high
frame rates. We also discuss secondary issues like
shading and texturing implicit models.
|
|
Two Stage Importance Sampling for Direct Lighting
2006
We describe an importance sampling method to generate
samples based on the product of a BRDF and an environment map or large
light source. The method works by creating a hierarchical partition
of the light source based on the BRDF function for each primary (eye)
ray in a ray tracer. This partition, along with a summed area table
of the light source, form an approximation to the product function
that is suitable for importance sampling. The partition is used to
guide a sample warping algorithm to transform a uniform distribution
of points so that they approximate the product distribution. The
technique is unbiased, requires little precomputation, and we
demonstrate that it works well for a variety of BRDF types. Further,
we present an adaptive method which allocates varying numbers of
samples to different image pixels to reduce shadow artifacts.
|
|
Energy Redistribution Path Tracing
2005
We present Energy Redistribution (ER) sampling as an
unbiased method to solve correlated integral problems. ER sampling is
a hybrid algorithm that uses Metropolis sampling-like mutation
strategies in a standard Monte Carlo integration setting, rather than
resorting to an intermediate probability distribution step. In the
context of global illumination, we present Energy Redistribution Path
Tracing (ERPT). Beginning with an inital set of light samples taken
from a path tracer, ERPT uses path mutations to redistribute the
energy of the samples over the image plane to reduce variance. The
result is a global illumination algorithm that is conceptually simpler
than Metropolis Light Transport (MLT) while retaining its most
powerful feature, path mutation. We compare images generated with the
new technique to standard path tracing and MLT.
|
|
A Simplified Path Tracing Architecture
2004
While the basic path tracing algorithm was developed
for simple surfaces and well-defined luminaires, modern scenes contain
complex luminaires, surfaces and participating media. This has
resulted in add-ons for the path tracing algorithm. We rethink the
path tracing architecture in the context of this complexity, and show
that an even simpler architecture than classical path tracing works
well. This consists of using simple directional sampling without
shadow rays, and treating participating media as probabilistic
surfaces.
|
|
Structured Importance Sampling of Environment Maps
2003
We introduce structured importance sampling, a new
technique for efficiently rendering scenes illuminated by distant
natural illumination given in an environment map. Our method handles
occlusion, high-frequency lighting, and is significantly faster than
alternative methods based on Monte Carlo sampling. We achieve this
speedup as a result of several ideas. First, we present a new metric
for stratifying and sampling an environment map taking into account
both the illumination intensity as well as the expected variance due
to occlusion within the scene. We then present a novel hierarchical
stratification algorithm that uses our metric to automatically
stratify the environment map into regular strata. This approach
enables a number of rendering optimizations, such as pre-integrating
the illumination within each stratum to eliminate noise at the cost of
adding bias, and sorting the strata to reduce the number of sample
rays. We have rendered several scenes illuminated by natural lighting,
and our results indicate that structured importance sampling is better
than the best previous Monte Carlo techniques, requiring one to two
orders of magnitude fewer samples for the same image quality.
|
|
Metropolis Light Transport
2000
We present a new Monte Carlo method for solving the
light transport problem, inspired by the Metropolis sampling method in
computational physics. To render an image, we generate a sequence of
light transport paths by randomly mutating a single current path
(e.g. adding a new vertex to the path). Each mutation is accepted or
rejected with a carefully chosen probability, to ensure that paths are
sampled according to the contribution they make to the ideal image.
We then estimate this image by sampling many paths, and recording
their locations on the image plane.
Our algorithm is unbiased, handles general geometric and scattering models, uses little storage, and can be orders of magnitude more efficient than previous unbiased approaches. It performs especially well on problems that are usually considered difficult, e.g. those involving bright indirect light, small geometric holes, or glossy surfaces. Furthermore, it is competitive with previous unbiased algorithms even for relatively simple scenes. The key advantage of the Metropolis approach is that the path space is explored locally, by favoring mutations that make small changes to the current path. This has several consequences. First, the average cost per sample is small (typically only one or two rays). Second, once an important path is found, the nearby paths are explored as well, thus amortizing the expense of finding such paths over many samples. Third, the mutation set is easily extended. By constructing mutations that preserve certain properties of the path (e.g. which light source is used) while changing others, we can exploit various kinds of coherence in the scene. It is often possible to handle difficult lighting problems efficiently by designing a specialized mutation in this way. |
|
Efficient Simulation of Light Transport in Scenes with Participating Media using Photon Maps
1998
This paper presents a new method for computing global
illumination in scenes with participating media. The method is
based on bidirectional Monte Carlo ray tracing and uses photon
maps to increase efficiency and reduce noise. We remove
previous restrictions limiting the photon map method to
surfaces by introducing a volume photon map containing photons
in participating media. We also derive a new radiance estimate
for photons in the volume photon map. The method is fast and
simple, but also general enough to handle nonhomogeneous media
and anisotropic scattering. It can efficiently simulate
effects such as multiple volume scattering, color bleeding
between volumes and surfaces, and volume caustics (light
reflected from or transmitted through specular surfaces and
then scattered by a medium). The photon map is decoupled from
the geometric representation of the scene, making the method
capable of simulat- ing global illumination in scenes
containing complex objects. These objects do not need to be
tessellated; they can be instanced, or even represented by an
implicit function. Since the method is based on a bidirectional
simulation, it automatically adapts to illumination and
view. Furthermore, because the use of photon maps reduces noise
and aliasing, the method is suitable for rendering of
animations.
|
|
Robust Monte Carlo Methods for Light Transport Simulation
1997
Light transport algorithms generate realistic images
by simulating the emission and scatter- ing of light in an
artificial environment. Applications include lighting design,
architecture, and computer animation, while related engineering
disciplines include neutron transport and radiative heat
transfer. The main challenge with these algorithms is the high
complexity of the geometric, scattering, and illumination
models that are typically used. In this disserta- tion, we
develop new Monte Carlo techniques that greatly extend the
range of input models for which light transport simulations are
practical. Our contributions include new theoreti- cal models,
statistical methods, and rendering algorithms.
We start by developing a rigorous theoretical basis for bidirectional light transport al- gorithms (those that combine direct and adjoint techniques). First, we propose a linear op- erator formulation that does not depend on any assumptions about the physical validity of the input scene. We show how to obtain mathematically correct results using a variety of bidirectional techniques. Next we derive a different formulation, such that for any physi- cally valid input scene, the transport operators are symmetric. This symmetry is important for both theory and implementations, and is based on a new reciprocity condition that we derive for transmissive materials. Finally, we show how light transport can be formulated as an integral over a space of paths. This framework allows new sampling and integration tech- niques to be applied, such as the Metropolis sampling algorithm. We also use this model to investigate the limitations of unbiased Monte Carlo methods, and to show that certain kinds of paths cannot be sampled. Our statistical contributions include a new technique called multiple importance sam- pling, which can greatly increase the robustness of Monte Carlo integration. It uses more than one sampling technique to evaluate an integral, and then combines these samples in a vii way that is provably close to optimal. This leads to estimators that have low variance for a broad class of integrands. We also describe a new variance reduction technique called efficiency-optimized Russian roulette. Finally, we link these ideas together to obtain new Monte Carlo light transport algo- rithms. Bidirectional path tracing uses a family of different path sampling techniques that generate some path vertices starting from a light source, and some starting from a sensor. We show that when these techniques are combined using multiple importance sampling, a large range of difficult lighting effects can be handled efficiently. The algorithm is unbiased, handles arbitrary geometry and materials, and is relatively simple to implement. The second algorithm we describe is Metropolis light transport, inspired by the Me- tropolis sampling method from computational physics. Paths are generated by following a random walk through path space, such that the probability density of visiting each path is proportional to the contribution it makes to the ideal image. The resulting algorithm is un- biased, uses little storage, handles arbitrary geometry and materials, and can be orders of magnitude more efficient than previous unbiased approaches. It performs especially well on problems that are usually considered difficult, e.g. those involving bright indirect light, small geometric holes, or glossy surfaces. To our knowledge, this is the first application of the Metropolis method to transport problems of any kind. |
|
Sphere tracing: a geometric method for the antialiased ray tracing of implicit surfaces
1996
\ Sphere tracing is a new technique for rendering
implicit surfaces that uses geometric distance. Sphere tracing marches
along the ray toward its first intersection in steps guaranteed not to
penetrate the implicit surface. It is particularly adept at rendering
pathological surfaces. Creased and rough implicit surfaces are defined
by functions with discontinuous or undefined derivatives. Sphere
tracing requires only a bound on the magnitude of the derivative,
robustly avoiding problems where the derivative jumps or vanishes. It
is an efficient direct visualization system for the design and
investigation of new implicit models. Sphere tracing efficiently
approximates cone tracing, supporting symbolic-prefiltered
antialiasing. Signed distance functions for a variety of primitives
and operations are derived.
|
|
Sphere tracing: a geometric method for the antialiased ray tracing of implicit surfaces
1996
Sphere tracing is a new technique for ren- dering
implicit surfaces that uses geomet- ric distance. Sphere tracing
marches along the ray toward its first intersection in steps
guaranteed not to penetrate the implicit surface. It is particularly
adept at render- ing pathological surfaces. Creased and rough implicit
surfaces are defined by functions with discontinuous or undefined
derivatives. Sphere tracing requires only a bound on the magnitude of
the deriva- tive, robustly avoiding problems where the derivative
jumps or vanishes. It is an efficient direct visualization system for
the design and investigation of new implicit models. Sphere tracing
efficiently approx- imates cone tracing, supporting symbolic-
prefiltered antialiasing. Signed distance functions for a variety of
primitives and operations are derived.
|
|
Sphere Tracing: A Geometric Method for the Antialiased Ray Tracing of Implicit Surfaces
1994
Sphere tracing is a new technique for rendering
implicit surfaces using geometric distance. Distance-based models
are common in computer-aided geometric design and in the modeling
of articulated figures. Given a function returning the distance
to an object, sphere tracing marches along the ray toward its
first intersection in steps guaranteed not to penetrate the
implicit surface.
Sphere tracing is particularly adept at rendering pathological surfaces. Creased and rough implicit surfaces are defined by functions with discontinuous or undefined derivatives. Current root finding techniques such as L-G surfaces and interval analysis require periodic evaluation of the derivative, and their behavior is dependent on the behavior of the derivative. Sphere tracing requires only a bound on the magnitude of the derivative, robustly avoiding problems where the derivative jumps or vanishes. This robustness and scope support sphere tracing as an efficient direct visualization system for the design and investigation of new implicit models. Furthermore, sphere tracing efficiently approximates cone tracing, supporting symbolicprefiltered antialiasing. Signed distance functions for a variety of primitives and operations are derived and appear independently as appendices, specifically the natural quadrics and torus, superquadrics, Bezier-based generalized cylinders and offset surfaces, constructive solid geometry, pseudonorm and Gaussian blends, taper, twist and hypertexture. |
|
Sphere Tracing: A Geometric Method for the Antialiased Ray Tracing of Implicit Surfaces
1994
\ Sphere tracing is a new technique for rendering
implicit surfaces using geometric distance. Distance-based models are
common in computer-aided geometric design and in the modeling of
articulated figures. Given a function returning the distance to an
object, sphere tracing marches along the ray toward its first
intersection in steps guaranteed not to penetrate the implicit
surface.
Sphere tracing is particularly adept at rendering pathological
surfaces. Creased and rough implicit surfaces are defined by functions
with discontinuous or undefined derivatives. Current root finding
techniques such as L-G surfaces and interval analysis require periodic
evaluation of the derivative, and their behavior is dependent on the
behavior of the derivative. Sphere tracing requires only a bound on
the magnitude of the derivative, robustly avoiding problems where the
derivative jumps or vanishes. This robustness and scope support sphere
tracing as an efficient direct visualization system for the design and
investigation of new implicit models.
Furthermore, sphere tracing efficiently approximates cone tracing,
supporting symbolic- prefiltered antialiasing. Signed distance
functions for a variety of primitives and operations are derived and
appear independently as appendices, specifically the natural quadrics
and torus, superquadrics, Bezier-based generalized cylinders and
offset surfaces, constructive solid geometry, pseudonorm and Gaussian
blends, taper, twist and hypertexture.
|
|
Bi-Directional Path Tracing
1993
In this paper we present a new Monte Carlo rendering
algorithm that seamlessly integrates the ideas of shooting and
gathering power to create photorealistic images. The algorithm
can be explained as a generalisation of the well-known path
tracing algorithm. Test results show that it performs
significantly better for typical indoor scenes where indirect
lighting is important.
|
|
Ray Tracing Deterministic 3-D Fractals
1989
As shown in 1982, Julia sets of quadratic functions
as well as many other deterministic fractals exist
in spaces of higher dimensionality than the complex
plane. Originally a boundary-tracking algorithm was
used to view these structures but required a large
amount of storage space to operate. By ray tracing
these objects, the storage facilities of a graphics work-
station frame buffer are sufficient. A short discussion
of a specific set of 3-D deterministic fractals precedes
a full description of a ray-tracing algorithm applied
to these objects. A comparison with the boundary-
tracking method and applications to other 3-D deter-
ministic fractals are also included.
|
|
The Rendering Equation
1986
We present an integral equation which generallzes a
variety of known rendering algorithms. In the course of discussing a
monte carlo solution we also present a new form of variance
reduction, called Hierarchical sampling and give a number of
elaborations shows that it may be an efficient new technique for a
wide variety of monte carlo procedures. The resulting renderlng
algorithm extends the range of optical phenomena which can be
effectively simulated.
|
|
Fast Summed-Area Table Generation and its Applications
2005
We introduce a technique to rapidly generate
summed-area tables using graphics hardware. Summed area tables,
originally introduced by Crow, provide a way to filter
arbitrarily large rectangular regions of an image in a constant
amount of time. Our algorithm for generating summed-area tables,
similar to a technique used in scientific computing called
recursive doubling, allows the generation of a summed-area table
in O(log n) time. We also describe a technique to mitigate the
precision requirements of summed-area tables. The ability to
calculate and use summed-area tables at interactive rates enables
numerous interesting rendering effects. We present several
possible applications. First, the use of summed-area tables
allows real-time rendering of interactive, glossy environmental
reflections. Second, we present glossy planar reflections with
varying blurriness dependent on a reflected object’s distance to
the reflector. Third, we show a technique that uses a summed-area
table to render glossy transparent objects. The final application
demonstrates an interactive depth-of-field effect using
summedarea tables.
|
|
Summed-Area Tables Area Tables And Their Application to Dynamic Glossy Environment Reflections
2004
Rendering dynamic reflections with per-pixel glossiness using dual-paraboloid maps and summed-area tables
|
|
Optimizing Parallel Reduction in CUDA
0
Slide set -- No abstract.
|
|
Beyond Hard Shadows: Moment Shadow Maps for Single Scattering, Soft Shadows and Translucent Occluders
2016
Building upon previous works, we transfer the
recently proposed moment shadow mapping to three new
applications. Like variance shadow maps and convolution shadow maps,
moment shadow maps can be filtered directly. Classically, this is used
to filter hard shadows but previous works explore other
applications. Prefiltered single scattering uses convolution shadow
maps to render single scattering in homogenous participating media,
variance soft shadow mapping uses variance shadow maps for approximate
soft shadows and Fourier opacity mapping uses convolution shadow maps
for translucent occluders. We combine these three techniques with
moment shadow mapping to arrive at better heuristics with less
computational overhead.
|
|
Moment Shadow Mapping
2015
We present moment shadow mapping, a novel technique
for fast, filtered hard shadows. Like variance shadow mapping it
allows for the application of all kinds of efficient texture filtering
and antialiasing to its moment shadow map. However it is designed to
provide a substantially higher quality. Moment shadow maps store four
moments of the depth within the filter kernel. Using this information,
our efficient algorithm computes the sharpest possible lower bound as
approximation to the shadow intensity. The choice to compute such a
bound using four moments is based upon an automated evaluation of
thousands of alternatives and thus known to be optimal. To reduce
memory and bandwidth requirements we present an optimized quantization
scheme to allow 16-bit quantization of moment shadow maps. Our
evaluation demonstrates that moment shadow mapping produces high
quality results with a single shadow map sample per fragment using 64
bits per shadow map texel.
|
|
Exponential Soft Shadow Mapping
2013
In this paper we present an image-based algorithm to
render visually plausible anti-aliased soft shadows in real time. Our
technique employs a new shadow pre-filtering method based on an
extended exponential shadow map- ping theory. The algorithm achieves
faithful contact shadows by adopting an optimal approximation to
exponential shadow reconstruction function. Benefiting from a novel
overflow free summed area table tile grid data structure, numerical
stability is guaranteed and error filtering response is avoided. By
integrating an adaptive anisotropic filtering method, the proposed
algorithm can produce high quality smooth shadows both in large
penumbra areas and in high frequency sharp transitions, meanwhile
guarantee cheap memory consumption and high performance.
|
|
Layered Variance Shadow Maps
2008
Shadow maps are commonly used in real-time rendering, but they
cannot be filtered linearly like standard color, resulting in severe
aliasing. Variance shadow maps resolve this problem by representing
the depth distribution using moments, which can be linearly filtered.
However, variance shadow maps suffer from "light bleeding""
artifacts and require high-precision texture filtering hardware.
We introduce layered variance shadow maps, which provide simultaneous solutions to both of these limitations. By partitioning the shadow map depth range into multiple layers, we eliminate all light bleeding between different layers. Using more layers increases the quality of the shadows at the expense of additional storage. Because each of these layers covers a reduced depth range, they can be stored in lower precision than would be required with typical variance shadow maps, enabling their use on a much wider range of graphics hardware. We also describe an iterative optimization algorithm to automatically position layers so as to maximize the utility of each. Our algorithm is easy to implement on current graphics hardware and provides an efficient, scalable solution to the problem of shadow map filtering. |
|
Exponential Shadow Maps
2008
Rendering high-quality shadows in real-time is a challenging
problem. Shadow mapping has proved to be an efficient solution,
as it scales well for complex scenes. However, it suffers from
aliasing problems. Filtering the shadow map alleviates aliasing,
but unfortunately, native hardware-accelerated filtering cannot
be applied, as the shadow test has to take place beforehand.
We introduce a simple approach to shadow map filtering, by approximating the shadow test using an exponential function. This enables us to pre-filter the shadow map, which in turn allows for high quality hardware-accelerated filtering. Compared to previous filtering techniques, our technique is faster, consumes less memory and produces less artifacts. |
|
Convolution Shadow Maps
2007
We present Convolution Shadow Maps, a novel shadow representation
that affords efficient arbitrary linear filtering of
shadows. Traditional shadow mapping is inherently non-linear
w.r.t. the stored depth values, due to the binary shadow test. We
linearize the problem by approximating shadow test as a weighted
summation of basis terms. We demonstrate the usefulness of this
representation, and show that hardware-accelerated anti-aliasing
techniques, such as tri-linear filtering, can be applied
naturally to Convolution Shadow Maps. Our approach can be
implemented very efficiently in current generation graphics
hardware, and offers real-time frame rates.
|
|
Variance Shadow Maps
2006
Shadow maps are a widely used shadowing technique in real time
graphics. One major drawback of their use is that they cannot be
filtered in the same way as color textures, typically leading to
severe aliasing. This paper introduces variance shadow maps, a
new real time shadowing algorithm. Instead of storing a single
depth value, we store the mean and mean squared of a
distribution of depths, from which we can efficiently compute
the variance over any filter region. Using the variance, we
derive an upper bound on the fraction of a shaded fragment that
is occluded. We show that this bound often provides a good
approximation to the true occlusion, and can be used as an
approximate value for rendering. Our algorithm is simple to
implement on current graphics processors and solves the problem
of shadow map aliasing with minimal additional storage and
computation.
|
|
Percentage-Closer Soft Shadows
2005
One of the fundamental problems in computer graphics is
generating accurate soft shadows from area light sources. Soft
shadows provide valuable cues about the relationships between
objects, becoming sharper as objects contact each other and more
blurry (softer) the further they are apart.
This sketch presents a new method, called Percentage-Closer Soft Shadows (PCSS), for generating perceptually accurate soft shadows. Based on shadow mapping Williams 1978 and percentage-closer filtering (PCF) Reeves et al. 1987, PCSS has these key characteristics:
This combination makes it uniquely suitable for a wide range of applications, from next-generation games to DCC/CAD applications. Because it uses just a single sample and requires no special processing steps, the technique easily replaces existing shadow mapping shader code in an application while producing much more compelling images. The only required change is to replace the typical shadow mapping pixel shader with a PCSS shader. |
|
Rendering Antialiased Shadows with Depth Maps (PCF)
2000
We present a solution to the aliasing problem for shadow
algorithms that use depth maps. The solution is based on a new
filtering technique called percentage closer filtering. In
addition to antialiasing, the improved algorithm provides soft
shadow boundaries that resemble penumbrae. We describe the new
algorithm in detail, demonstrate the effects of its parameters,
and analyze its performance.
|
|
Shadow Rendering Techniques for Real-Time Applications
2008
Shadows, subtle though they may be, provide a number of visual
cues as to the layout and orientation of a scene and its light
sources that would otherwise be difficult or impossible to
convey. Shadows, which play a vital role in computer graphics,
have been a highly active area of research from the publication
of the first seminal papers in the late 1970's all the way to
the current day.
This research provides an overview of the techniques that have been developed for rendering shadows in real-time applications. The two most widely used techniques for rendering hard-edged shadows are presented and discussed in detail. Additionally, several approaches to rendering soft-edged and physically based shadows are discussed, and an implementation of several of these techniques is presented in order to compare their performance and behavior in real-world applications |
|
Resolution-Matched Shadow Maps
2007
This article presents resolution-matched shadow maps (RMSM), a
modified adaptive shadow map (ASM) algorithm, that is practical
for interactive rendering of dynamic scenes. Adaptive shadow
maps, which build a quadtree of shadow samples to match the
projected resolution of each shadow texel in eye space, offer a
robust solution to projective and perspective aliasing in shadow
maps. However, their use for interactive dynamic scenes is
plagued by an expensive iterative edge-finding algorithm that
takes a highly variable amount of time per frame and is not
guaranteed to converge to a correct solution. This article
introduces a simplified algorithm that is up to ten times faster
than ASMs, has more predictable performance, and delivers more
accurate shadows. Our main contribution is the observation that
it is more efficient to forgo the iterative refinement analysis
in favor of generating all shadow texels requested by the pixels
in the eye-space image. The practicality of this approach is
based on the insight that, for surfaces continuously visible
from the eye, adjacent eye-space pixels map to adjacent shadow
texels in quadtree shadow space. This means that the number of
contiguous regions of shadow texels (which can be efficiently
generated with a rasterizer) is proportional to the number of
continuously visible surfaces in the scene. Moreover, these
regions can be coalesced to further reduce the number of render
passes required to shadow an image. The secondary contribution
of this paper is demonstrating the design and use of
data-parallel algorithms inseparably mixed with traditional
graphics programming to implement a novel interactive rendering
algorithm. For the scenes described in this paper, we achieve
60-80 frames per second on static scenes and 20-60 frames per
second on dynamic scenes for 512^2 and 1024^2 images with a
maximum effective shadow resolution of 32,768^2 texels.
|
|
Pixel-Correct Shadow Maps with Temporal Reprojection and Shadow Test Confidence
2007
Shadow mapping suffers from spatial aliasing (visible as blocky
shadows) as well as temporal aliasing (visible as flickering). Several
methods have already been proposed for reducing such artifacts, but so
far none is able to provide satisfying results in real time.
This paper extends shadow mapping by reusing information of previously rasterized images, stored efficiently in a so-called history buffer. This buffer is updated in every frame and then used for the shadow calculation. In combination with a special confidence-based method for the history buffer update (based on the current shadow map), temporal and spatial aliasing can be completely removed. The algorithm converges in about 10 to 60 frames and during convergence, shadow borders are sharpened over time. Consequently, in case of real-time frame rates, the temporal shadow adaption is practically imperceptible. The method is simple to implement and is as fast as uniform shadow mapping, incurring only the minor speed hit of the history buffer update. It works together with advanced filtering methods like percentage closer filtering and more advanced shadow mapping techniques like perspective or light space perspective shadow maps |
|
Cascaded Shadow Maps
2007
Shadow maps are a very popular technique to obtain
realistic shadows in game engines. When trying to use them for large
spaces, shadow maps get harder to tune and will be more prone to
exhibit surface acne and aliasing. Cascaded Shadow maps (CSM) is a
know approach that helps to fix the aliasing problem by providing
higher resolution of the depth texture near the viewer and lower
resolution far away. This is done by splitting the camera view frustum
and creating a separate depth-map for each partition in an attempt to
make the screen error constant.
|
|
Efficient Physically-Based Shadow Algorithms
2006
This research focuses on developing efficient algorithms for
computing shadows in computer-generated images. A distinctive
feature of the shadow algorithms presented in this thesis is
that they produce correct, physically based results, instead of
giving approximations whose quality is often hard to ensure or
evaluate.
|
|
Parallel-Split Shadow Maps for Large-scale Virtual Environments
2006
Shadowing effects dramatically enhance the realism of virtual
environments by providing useful visual cues. Shadow mapping is
an efficient algorithm for real-time shadow rendering, which is
extensively adopted in real-time applications by its generality
and efficiency. However, shadow mapping usually suffers from
the inherent aliasing errors due to the image-based nature. In
this paper, we present the Parallel-Split Shadow Maps (PSSMs)
scheme, which splits the view frustum into different parts by
using the planes parallel to the view plane and then generates
multiple smaller shadow maps for the split parts. A fast and
robust split strategy based on the analysis of shadow map
aliasing has been proposed, which produces a moderate aliasing
distribution over the whole depth range. By applying the
geometry approximation procedure to each of the split parts
instead of the whole scene, the tighter bounding shapes of
visible objects enhance the utilization of the shadow map
resolution. Hardware-acceleration is used to remove the extra
rendering passes when synthesizing the scene-shadows. Our
approach is intuitive to implement without using complex data
structures, with real-time performance for dynamic and
large-scale virtual environments.
|
|
Shadow in Games
2005
Shadows increase the visual realism, reduce the "floating
effect" by consolidating spatial relationships between objects,
reveal geometrical information (locations and angles) of the
light sources and therefore provide a better 3D cue. Shadows are
also important to game plays. For instance, a player object
should be able to hide in a dark area by changing its color and
the environmental light intensity.
Shadows are traditionally handled by using empirical add-on algorithms, including scanline-based, two-pass Weiler-Atherton, shadow volume, two-pass Z-buffer, ray tracing and radiosity. These approaches are able of creating realistic shadows, but often too slow to be practical for real-time applications. However, there are more and more reasons to speculate that, as hardware marches onwards with nowadays speed, those algorithms will be supported by graphic acceleration chips to produce higher and higher quality shadows. |
|
SDK White Paper: Soft Shadows
2004
This paper describes how Shader Model 3.0's conditional
branching accelerates the computation of soft shadows. Note that
you are not generating true soft-shadows, but rather
approximating soft shadows by softening the boundaries of
traditional hard shadows. The technique described in this paper
performs a small amount of computation to estimate if the
current pixel is in the approximated soft-shadow region. If the
pixel is completely in shadow, or completely out of shadow, the
shader exits early. Otherwise, additional work is performed to
produce a more accurate estimate of the shadow's intensity at
the current pixel. Using conditional branching to perform this
additional work only when needed gains considerable performance
over techniques that don't use branching.
|
|
Light Space Perspective Shadow Maps
2004
In this paper, we present a new shadow mapping
technique that improves upon the quality of perspective and uniform
shadow maps. Our technique uses a perspective transform specified in
light space which allows treating all lights as directional lights and
does not change the direction of the light sources. This gives all the
benefits of the perspective mapping but avoids the problems inherent
in perspective shadow mapping like singularities in post-perspective
space, missed shadow casters etc. Furthermore, we show that both
uniform and perspective shadow maps distribute the perspective
aliasing error that occurs in shadow mapping unequally over the
available depth range. We therefore propose a transform that equalizes
this error and gives equally pleasing results for near and far viewing
distances. Our method is simple to implement, requires no scene
analysis and is therefore as fast as uniform shadow mapping.
|
|
GPU Gems Chapter 14: Perspective Shadow Maps: Care and Feeding
2004
Shadow generation has always been a big problem in real-time 3D
graphics. Determining whether a point is in shadow is not a
trivial operation for modern GPUs, particularly because GPUs
work in terms of rasterizing polygons instead of ray tracing.
Today's shadows should be completely dynamic. Almost every object in the scene should cast and receive shadows, there should be self-shadowing, and every object should have soft shadows. Only two algorithms can satisfy these requirements: shadow volumes (or stencil shadows) and shadow mapping. The difference between the algorithms for shadow volumes and shadow mapping comes down to object space versus image space: |
|
Real-Time Soft Shadows Using a Single Light Sample
2003
We present a real-time rendering algorithm that generates soft
shadows of dynamic scenes using a single light sample. As a
depth-map algorithm it can handle arbitrary shadowed
surfaces. The shadow-casting surfaces, however, should satisfy a
few geometric properties to prevent artifacts. Our algorithm is
based on a bivariate attenuation function, whose result
modulates the intensity of a light causing shadows. The first
argument specifies the distance of the occluding point to the
shadowed point; the second argument measures how deep the
shadowed point is inside the shadow. The attenuation function
can be implemented using dependent texture accesses; the
complete implementation of the algorithm can be accelerated by
todays graphics hardware. We outline the implementation, and
discuss details of artifact prevention and filtering.
|
|
Perspective Shadow Maps
2002
Shadow maps are probably the most widely used means for the
generation of shadows, despite their well known aliasing
problems. In this paper we introduce perspective shadow maps,
which are generated in normalized device coordinate space, i.e.,
after perspective transformation. This results in important
reduction of shadow map aliasing with almost no overhead. We
correctly treat light source transformations and show how to
include all objects which cast shadows in the transformed
space. Perspective shadow maps can directly replace standard
shadow maps for interactive hardware accelerated rendering as
well as in high-quality, offline renderers.
|
|
Adaptive Shadow Maps
2001
ASMs are based on the observation that a high-quality shadow map
need not be of uniform high resolution; only regions that
contain shadow boundaries need to be sampled densely. In those
regions, the resolution of the shadow map should be at least as
high as the corresponding region in the eye view to avoid
aliasing artifacts.
An ASM hierarchically subdivides an ordinary shadow map, providing higher resolutions in visually important regions. Like a conventional shadow map, an ASM takes as input a set of transformed eye view points and allows shadow queries on this set, returning true if a particular point is lit and false otherwise. In software systems, ASMs can seamlessly replace conventional shadow maps. |
|
A Survey of Shadow Algorithms
1997
Shadows are essential to realistic and visually appealing
images, but they are difficult to compute in most display
environments. This survey will characterize the various types of
shadows, describe most existing shadow algorithms, and for each
one discuss their complexities, their advantages and their
shortcomings. The types of shadows examined are hard shadows,
soft shadows, shadows of transparent objects, and shadows for
complex modeling primitives. For each type, we examine shadow
algorithms within various rendering techniques.
The goal of the survey is to provide readers with enough background and insight on the various methods to allow them to choose the algorithm best suited to their needs. It is also hoped that our analysis will help identify the areas that need more research, and point to possible solutions. |
|
Stupid Spherical Harmonics (SH) Tricks
2008
This paper provides a brief overview of spherical
harmonics (SH) and discusses several ways they can be used in
interactive graphics and problems that might arise. In particular it
focuses on the following issues: How to evaluate lighting models
efficiently using SH, what “ringing” is and what you can do about it,
efficient evaluation of SH products and where they might be used.
|
|
Spherical Harmonic Lighting: The Gritty Details
2003
Spherical Harmonic lighting (SH lighting) is a technique for
calculating the lighting on 3D models from area light sources that
allows us to capture, relight and display global illumination style
images in real time. It was introduced in a paper at Siggraph 2002
by Sloan, Kautz and Snyder as a technique for ultra realistic
lighting of models. Looking a little closer at it's derivation we can
show that it is in fact a toolbox of interrelated techniques that the
games community can use to good effect.
|
|
An Efficient Representation for Irradiance Environment Maps
2000
We consider the rendering of diffuse objects under
distant illumination, as specified by an environment
map. Using an analytic expression for the irradiance in terms
of spherical harmonic coefficients of the lighting, we show that
one needs to compute and use only 9 coefficients, corresponding
to the lowest-frequency modes of the illumination, in order to
achieve average errors of only 1%. In other words, the
irradiance is insensitive to high frequencies in the lighting,
and is well approximated using only 9 parameters. In fact, we
show that the irradiance can be procedurally represented simply
as a quadratic polynomial in the cartesian components of the
surface normal, and give explicit formulae. These observations
lead to a simple and efficient procedural rendering algorithm
amenable to hardware implementation, a prefiltering method up to
three orders of magnitude faster than previous techniques, and
new representations for lighting design and image-based
rendering.
|
|
Linear Efficient Antialiased Displacement and Reflectance Mapping
2013
We present Linear Efficient Antialiased Displacement
and Reflectance (LEADR) mapping, a reflectance filtering technique
for displacement mapped surfaces. Similarly to LEAN mapping, it
employs two mipmapped texture maps, which store the first two moments
of the displacement gradients. During rendering, the projection of
this data over a pixel is used to compute a noncentered anisotropic
Beckmann distribution using only simple, linear filtering
operations. The distribution is then injected in a new, physically
based, rough surface microfacet BRDF model, that includes masking and
shadowing effects for both diffuse and specular reflection under
directional, point, and environment lighting. Furthermore, our method
is compatible with animation and deformation, making it extremely
general and flexible. Combined with an adaptive meshing scheme, LEADR
mapping provides the very first seamless and hardware-accelerated
multi-resolution representation for surfaces. In order to demonstrate
its effectiveness, we render highly detailed production models in real
time on a commodity GPU, with quality matching supersampled
ground-truth images.
|
|
Quadtree Displacement Mapping with Height Blending
2009
GDC09 Slide set: 119 slides
|
|
GPU Gems 3 - Chapter 18: Relaxed Cone Stepping for Relief Mapping
2009
The presence of geometric details on object surfaces
dramatically changes the way light interacts with these
surfaces. Although synthesizing realistic pictures requires
simulating this interaction as faithfully as possible,
explicitly modeling all the small details tends to be
impractical. To address these issues, an image-based technique
called relief mapping has recently been introduced for adding
per-fragment details onto arbitrary polygonal models (Policarpo
et al. 2005). The technique has been further extended to render
correct silhouettes (Oliveira and Policarpo 2005) and to handle
non-height-field surface details (Policarpo and Oliveira
2006). In all its variations, the ray-height-field intersection
is performed using a binary search, which refines the result
produced by some linear search procedure. While the binary
search converges very fast, the linear search (required to
avoid missing large structures) is prone to aliasing, by
possibly missing some thin structures, as is evident in Figure
18-1a. Several space-leaping techniques have since been
proposed to accelerate the ray-height-field intersection and to
minimize the occurrence of aliasing (Donnelly 2005, Dummer
2006, Baboud and Decoret 2006). Cone step mapping (CSM)
(Dummer 2006) provides a clever solution to accelerate the
intersection calculation for the average case and avoids
skipping height-field structures by using some precomputed data
(a cone map).
|
|
LEAN Mapping
2008
We introduce Linear Efficient Antialiased Normal
(LEAN) Map- ping, a method for real-time filtering of specular
highlights in bump and normal maps. The method evaluates bumps as part
of a shading computation in the tangent space of the polygonal surface
rather than in the tangent space of the individual bumps. By operat-
ing in a common tangent space, we are able to store information on the
distribution of bump normals in a linearly-filterable form compatible
with standard MIP and anisotropic filtering hardware. The necessary
textures can be computed in a preprocess or generated in real-time on
the GPU for time-varying normal maps. The method effectively captures
the bloom in highlight shape as bumps become too small to see, and
will even transform bump ridges into anisotropic shading. Unlike even
more expensive methods, several layers can be combined cheaply during
surface rendering, with perpixel blending. Though the method is based
on a modified Ward shading model, we show how to map between its
parameters and those of a standard Blinn-Phong model for compatibility
with existing art assets and pipelines, and demonstrate that both
models produce equivalent results at the largest MIP levels.
|
|
Pyramidal Displacement Mapping: A GPU based Artifacts-Free Ray Tracing through an Image Pyramid
2007
Displacement mapping enables us to details to polygonal meshes.
We present a real-time artifacts-free inverse displacement
mapping method using per-pixel ray tracing through an image
pyramid on the GPU. In each pixel, we make a ray and trace the
ray through a displacement map to find an intersection. To skip
empty-regions safely, we use the quad-tree image pyramid of a
displacement map in top-down order. For magnification we
estimate an intersection between a ray and a bi-linearly
interpolated displacement. For minification we perform a
mipmap-like prefiltering to improve quality of result images and
rendering performance. Results show that our method produces
correct images even at steep grazing angles. Rendering speed of
test scenes were over hundreds of frames per second and less
influence to the resolution of the map. Our method is simple
enough to add to existing virtual reality systems easily.
|
|
Accurate Per-Pixel Displacement Mapping using a Pyramid Structure
2007
We present a per-pixel displacement mapping method
that provides high accuracy as well as real-time
performance. This arises from the observation that we can safely
skip empty regions by moving a ray to the maximum height
value. We store this bounding information in the image pyramid of
a heighfield texture. In our method, a ray along view direction
advances hierarchically via this pyramid structure. This method,
called pyramidal displacement mapping, guarantees finding the
correct intersections on any heightfield and viewing
conditions. This article explains implementation details with
more accessible illustrations and descriptions for 3D application
developers. Additionally, we introduce a new LOD technique to
improve rendering performance and quality.
|
|
Practical Parallax Occlusion Mapping For Highly Detailed Surface Rendering
2006
A set of 70 slides from a Siggraph'2006 presentation.
|
|
Practical Parallax Occlusion Mapping For Highly Detailed Surface Rendering
2006
A 69 slide presentation about parallax maps.
|
|
Dynamic Parallax Occlusion Mapping with Approximate Soft Shadows
2006
This paper presents a per-pixel ray tracing algorithm with
dynamic lighting of surfaces in real-time on the GPU. First, we
propose a method for increased precision of the critical
rayheight field intersection and adaptive height field
sampling. We achieve higher quality results than the existing
inverse displacement mapping algorithms. Second, soft shadows
are computed by estimating light visibility for the displaced
surfaces. Third, we describe an adaptive level-of-detail system
which uses the information supplied by the graphics hardware
during rendering to automatically manage shader complexity. This
LOD scheme maintains smooth transitions between the full
displacement computation and a simplified representation at a
lower level of detail without visual artifacts. The algorithm
performs well for animated objects and supports dynamic
rendering of height fields for a variety of interesting
displacement effects. The presented method is scalable for a
range of consumer grade GPU products. It exhibits a low memory
footprint and can be easily integrated into existing art
pipelines for games and effects rendering.
|
|
Displacement Mapping on the GPU - State of the Art
2006
This paper reviews the latest developments of
displacement mapping algorithms implemented on the vertex,
geometry, and fragment shaders of graphics cards. Displacement
mapping algorithms are classified as per-vertex and per-pixel
methods. Per-pixel approaches are further categorized as safe
algorithms that aim at correct solutions in all cases, to
unsafe techniques that may fail in extreme cases but are
usually much faster than safe algorithms, and to combined
methods that exploit the robustness of safe and the speed of
unsafe techniques. We discuss the possible roles of vertex,
geometry, and fragment shaders to implement these
algorithms. Then the particular GPU based bump, parallax,
relief, sphere, horizon mapping, cone stepping, local ray
tracing, pyramidal and view-dependent displacement mapping
methods, as well as their numerous variations are reviewed
providing also implementation details of the shader
programs. We present these methods using uniform notations and
also point out when different authors called similar concepts
differently. In addition to basic displacement mapping,
self-shadowing and silhouette processing are also
reviewed. Based on our experiences gained having re-implemented
these methods, their performance and quality are compared, and
the advantages and disadvantages are fairly presented.
|
|
Cone Step Mapping: An Iterative Ray-Heightfield Intersection Algorithm
2006
This paper presents Cone Step Mapping (CSM), a new
approach to the Ray-Heightfield Intersection problem. CSM uses
preprocessed information about the heightfield to dynamically
adjust step sizes along the ray when finding the first
intersection. It is an iterative method that is unconditionally
stable, without the need to tune algorithm parameters. This
method is suitable for real-time rendering and has been
implemented using the OpenGL Shading Language (GLSL) on a
GeForce 6600.
|
|
Practical Parallax Occlusion Mapping with Approximate Soft
Shadows for Detailed Surface Rendering
2006
This chapter presents a per-pixel ray tracing algorithm with
dynamic lighting of surfaces in real-time on the GPU. First, we
will describe a method for increased precision of the critical
ray-height field intersection and adaptive height field
sampling. We achieve higher quality results than the existing
inverse displacement mapping algorithms. Second, soft shadows
are computed by estimating light visibility for the displaced
surfaces. Third, we describe an adaptive level-of-detail system
which uses the information supplied by the graphics hardware
during rendering to automatically manage shader complexity. This
LOD scheme maintains smooth transitions between the full
displacement computation and a simplified representation at a
lower level of detail without visual artifacts. Finally,
algorithm limitations will be discussed along with the practical
considerations for integration into game pipelines. Specific
attention will be given to the art asset authoring, providing
guidelines, tips and concerns. The algorithm performs well for
animated objects and supports dynamic rendering of height fields
for a variety of interesting displacement effects. The presented
method is scalable for a range of consumer grade GPU
products. It exhibits a low memory footprint and can be easily
integrated into existing art pipelines for games and effects
rendering.
|
|
Parallax Mapping with Offset Limiting: A Per-Pixel
Approximation of Uneven Surfaces
2004
This paper describes parallax mapping and an enhancement that
makes it more practical for general use. Parallax mapping is a
method for approximating the correct appearance of uneven
surfaces by modifying the texture coordinate for each pixel.
Parallax is exhibited when areas of a surface appear to move
relative to one another as the view position changes. This can
be observed on any surface that is not flat. Parallax can be
simulated well by constructing a complete geometric model of a
surface, but it can be computationally expensive to draw all the
necessary polygons. The method presented here requires no extra
polygons and approximates surface parallax using surface height
data.
|
|
View-Dependent Displacement Mapping
2003
Significant visual effects arise from surface mesostructure,
such as fine-scale shadowing, occlusion and silhouettes. To
efficiently render its detailed appearance, we introduce a
technique called view-dependent displacement mapping VDM) that
models surface displacements along the viewing direction. Unlike
traditional displacement mapping, VDM allows for efficient
rendering of self-shadows, occlusions and silhouettes without
increasing the complexity of the underlying surface mesh. VDM is
based on per-pixel processing, and with hardware acceleration it
can render mesostructure with rich visual appearance in real
time.
|
|
Synthetic Object Rendering
1998
We present a method that uses measured scene radiance and global
illumination in order to add new objects to light-based models
with correct lighting. The method uses a high dynamic range
imagebased model of the scene, rather than synthetic light
sources, to illuminate the newobjects. To compute the
illumination, the scene is considered as three components: the
distant scene, the local scene, and the synthetic objects. The
distant scene is assumed to be photometrically unaffected by the
objects, obviating the need for reflectance model
information. The local scene is endowed with estimated
reflectance model information so that it can catch shadows and
receive reflected light from the new objects. Renderings are
created with a standard global illumination method by simulating
the interaction of light amongst the three components. A
differential rendering technique allows for good results to be
obtained when only an estimate of the local scene reflectance
properties is known.
We apply the general method to the problem of rendering synthetic objects into real scenes. The light-based model is constructed from an approximate geometric model of the scene and by using a light probe to measure the incident illumination at the location of the synthetic objects. The global illumination solution is then composited into a photograph of the scene using the differential rendering technique. We conclude by discussing the relevance of the technique to recovering surface reflectance properties in uncontrolled lighting situations. Applications of the method include visual effects, interior design, and architectural visualization. |
|
Shade Trees
1984
Shading is an important part of computer imagery, but shaders
have been based on fixed models to which all surfaces must
conform. As computer imagery becomes more sophisticated,
surfaces have more complex shading characteristics and thus
require a less rigid shading model. This paper presents a
flexible tree-structured shading model that can represent a wide
range of shading characteristics. The model provides an easy
means for specifying complex shading characteristics. It is also
efficient because it can tailor the shading calculations to each
type of surface.
|