|
Pixel Shading
Adjusting Real-Time Lighting for Shadow Volumes and Optimized Meshes
Abstract: Lighting an entire mesh is well understood and presents no real, unexpected artifacts. However, when more complex rendering systems optimize the number of polygons being rendered, like backface-culling from the light's point of view, lighting artifacts are introduced. When culling is done based on face normals and lighting is done based on vertex normals, some adjustments are required. The same applies to self-shadowing meshes that use stencil shadow volumes, since the shadow volumes are extruded based on face normals. Additionally, bump mapping needs even further adjustment, because the normal has nothing to do with the geometric shape of the mesh. This article explores these problems and presents a solution that is accomplished entirely in the pixel shader.
Real-Time Halftoning: Fast and Simple Stylized Shading |  |
Abstract: This article introduces halftoning as a way of implementing nonphotorealistic rendering styles for computer games. The technique uses only the conventional multitexturing 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.
Techniques to Apply Team Colors to 3D Models | |
Abstract: Applying visually appealing team color to 3D models is an important technique in any game with multiple players, whether AI or human controlled. This article explores several techniques for applying team color to arbitrary 3D models. The implementation of each technique is carefully explained, and the benefits and drawbacks of each method are discussed. The techniques include Unique Textures, Polygon Tinting, Texture Masks via Multitexturing, Texture Masks via Multipass, and Advanced Texture Masks via Pixel Shaders.
Fast Sepia Tone Conversion
Abstract: Sepia tone is a color space that is used to give images an aged or antique feel. Color conversion from RGB to sepia has usually been performed by mapping an RGB color into a lookup table. Although this technique is simple and effective, we have found a simpler and faster way to perform the same conversion with just a few pixel shader instructions and no table lookup.
Building a Million Particle System
Abstract: Current implementations of particle systems can handle up to 10,000 particles in real-time situations and are mostly limited by transfers of particle data from the main processor to the graphics hardware (GPU) for rendering. A full GPU implementation however does not have this bottleneck and can simulate and render one million particles in real-time on recent hardware. This allows a dramatic increase in the level of detail and also much smaller particles. Thus it goes back again towards the original idea of a particle being a minimal geometry element. The massively parallel simulation of particle physics on a GPU can be a flexible combination of a multitude of motion and position operations, such as gravity, local forces, and collision with primitive geometry shapes or texture-based height fields. This high level of realism allows particle systems to be used as gameplay element, such as for fog-like local invisibility. Additionally this technique can be combined with a parallel sorting algorithm, performing a distance- based sorting of the particles for correct alpha-blended rendering.
Inexpensive Underwater Caustics Using Cg
Abstract: This article explains an aesthetics-driven method for rendering the underwater lighting effects known as "caustics" in real-time. We believe the technique is fully original, and has very low computational cost. The results look remarkably realistic, and the method can easily be implemented in most graphics hardware. This simplified approach has proven very successful in many fractal-related disciplines, such as mountain and cloud rendering or tree modeling. This article should satisfy both those interested in water rendering algorithms, as well as those wanting an introduction to pixel shader programming in Cg.
Textures as Lookup Tables for Per-Pixel Lighting Computations
Abstract: In this article, we show ways to use texture maps as a means to solve functions through a lookup table, focusing on lighting computations. This technique saves precious pixel shader instructions, and in many cases, it is the only way to make certain per-pixel effects possible on the current generation of hardware.
Rendering with Handcrafted Shading Models
Abstract: This article proposes a simple technique called normal distribution function (NDF) shading. It allows an artist to handcraft shading models, with the shape and color of highlights simply stored in bitmaps. The technique uses per-pixel shading, and can also be used in conjunction with bump mapping. Anisotropic shading models can also be created.
Pixel Shader Optimizations for Terrain Rendering | |
Abstract:
Hemisphere Lighting With Radiosity Maps
Abstract: Hemisphere lighting is a simple way of emulating the indirect light contributions found in a typical outdoor scene. Any kind of complex radiosity lighting could be modeled by encoding the surrounding light sources into an HDR (high dynamic range) cubemap, but it is impractical to update such a cubemap in realtime as large numbers of objects move around the world. So we need to approximate, cutting down the complexities of the real world into a more efficient realtime model. The lighting model in this article was designed for fast moving objects in outdoor environments. Its goals were to tie the moving objects in with their surroundings, to convey a sensation of speed, and to be capable of rendering large numbers of meshes at a good framerate on first generation shader hardware.
Implementing Modular HLSL with RenderMonkey
Abstract: This article examines how to make shaders work using ATI's RenderMonkey API (which works on any hardware that supports shaders, not just ATI's hardware). HLSL stands for High Level Shader Language.
Implementing Lighting Models With HLSL
Abstract: This article examines using the High Level Shader Language (HLSL) which comes with DirectX 9. This is an overview article that serves as a good introduction to the topic.
Animation With Cg
Abstract: Cg targets the ability to programmatically control the shape, appearance, and motion of objects rendered using graphics hardware. Broadly, this type of language is called a shading language. However, Cg can do more than just shading. For example, Cg programs can perform physical simulation, compositing, and other nonshading tasks.
A Non-Integer Power Function on the Pixel Shader
Abstract: This feature, excerpted from Wolfgang Engel's ShaderX book from Wordware Publishing, presents a simple shader trick that performs a good per pixel approximation of a non-integer power function. The technique works for input values between 0 and 1 and supports large exponents. The presented shader does not require any texture look-up and is scalable, making it possible to spend more instructions in order to decrease the error or to reach greater exponents.
Volumetric Rendering in Realtime
Abstract: Most current implementations of fog in games use layered alpha images. This technique, however, does not bare significantly resemblance to how fog actually composites in real life, since density of the fog from the viewer is not modeled in any way. In order to create fog effects in a game, it is first necessary to create an analytical model that bears some resemblance to the mechanics of real fog. Includes a pixel shader supplement.
|
