|
|
|
Game Programming Gems 2
Edited by Mark DeLoura, published 2001.
|
Comparison of VIPM Methods
Abstract: View-Independent Progressive Meshing (VIPM) has moved from the status of an interesting research project, to promising new technology, to sensible addition to all the best engines, and now into the Direct3D graphics API itself. However, in an effort to push the performance of VIPM, and in particular to drive the hardware as efficiently as possible, several new forms have been developed, each with their own tradeoffs and characteristics. This article is intended as a guide to some of the more promising versions, and should help people decide which of the many variants to sue in particular situations.
Simplified Terrain Using Interlocking Tiles |  |
Abstract: This article proposes a simple method for interlocking tiles that requires a minimal amount of coding. The technique offers the benefits of dynamically adapting detail levels and animation flexibility. It does this while maintaining a data system that is perfectly suited for hardware transform and lighting.
Sphere Trees for Fast Visibility Culling, Ray Tracing, and Range Searching | |
Abstract: The article presents an algorithm and demonstration application that manages thousands of objects in motion that are continuously maintained as a collection of hierarchical bounding spheres in a SphereTree. The design goal for this algorithm has been to make the 99-percentile case spend almost no CPU time updating an object in motion within the tree structure. Queries against the SphereTree perform more tests than other data structures, but this is mitigated by the fact that the tree can be maintained using very little CPU time. This data structure is ideally suited for gross culling of massive numbers of moving objects in a large world space. It doesn't matter if the objects are moving at widely disparate speeds, or even if many of them are not in motion at all. It also has a very low cost when objects are inserted and removed from the tree with great frequency.
Compressed Axis-Aligned Bounding Box Trees
Abstract: The axis-aligned bounding box (AABB) tree structure has proven to be very useful for accelerating intersection queries on sets of geometry. The data structure is easy to implement, the built structure is numerically well conditioned, and like all binary trees, they have O(log n) search time. This article explains several techniques that can be used to lower the overall memory footprint of an AABB tree to 11 bytes per triangle.
Direct Access Quadtree Lookup
Abstract: This article presents a general-purpose optimization for quadtree access that improves performance in three ways over the traditional implementations: 1) by eliminating node traversal and the unnecessary cache-misses it causes, 2) by requiring fewer instructions and CPU cycles overall vs. a best case traditional approach, and 3) by doing so in a compact amount of time and with minimal memory accesses regardless of what depth in the tree the target node resides in.
Approximating Fish Tank Refractions
Abstract: This article briefly explains a method for approximating the refraction effect seen when looking through the side of a fish tank. The majority of this article explains how to construct the transformation matrix that will be applied to the geometry inside the tank to simulate the refraction effect.
Rendering Print Resolution Screenshots
Abstract: This article proposes a solution of breaking the task into rendering several smaller subimages. These subimages can then be pasted together to form a screen shot of arbitrary resolution. This article focuses on the projection matrix tricks required to do this seamlessly.
Applying Decals to Arbitrary Surfaces | |
Abstract: This article presents a general method for applying a decal to an arbitrarily shaped surface and concurrently clipping the decal to the surface's boundary.
Rendering Distant Scenery with Skyboxes | |
Abstract: Rending distant scenery in 3D can be accomplished with skyboxes. This article explains the principle of skyboxing and describes alternative means for rendering a skyboxed scene.
Self-Shadowing Characters
Abstract: This article presents a projective texture approach, which enables self-shadowing of convex subsections of characters in real time. After breaking the character into convex subsections, the subsections are rendered into a texture with varying alpha values from teh point of view of the light source. When the character is rendered from the viewer's point-of-view, this texture is projected back onto the convex subsegments of the character, simulating the occlusion of each subsegment with respect to the light source. Being map based rather than stencil-volume based, this technique requires no additional work to be compatible with higher-order surface tessellation techniques.
Classic Super Mario 64 Third-Person Control and Animation
Abstract: This article will deal with the basic issues of controlling and animating a character from a third-person perspective. While it seems straightforward enough (just copy Super Mario 64), it's not as trivial as it first appears. There are many small nuggets of wisdom that can often take weeks of trial and error to discover.
Cartoon Rendering: Real-time Silhouette Edge Detection and Rendering
Abstract: Silhouette detection and rendering is a key component for adding a stylized look to 3D cartoon rendering. The basic concept of silhouette edge detection is to find the important edges that depict the outline of a model. Many cartoon animators illustrate these silhouettes by tracing a black outline around the borders of a model. This cartoon rendering article describes several silhouette edge detection techniques: an edge-based detection method, a programmable vertex shader technique, and an advanced texturing technique. The advantages and disadvantages of each technique are highlighted.
Cartoon Rendering Using Texture Mapping and Programmable Vertex Shaders
Abstract: The techniques described in this article take advantage of modern real-time graphics capabilities, including texture mapping and programmable vertex shading. The basic idea is to simulate a limited color palette using textures. To do this, we modify the standard diffuse shading equation to create a highlight and shadow color, and use these colors to create a small texture map for each material to be used as a lookup table at runtime. Additionaly, these techniques require no additional markup information from the artist - this article describes the creation of the texture maps and texture coordinates for each material.
Dynamic Per-Pixel Lighting Techniques
Abstract: This article presents several techniques that can be used to perform dynamic lighting effects on a per-pixel basis. These methods have the advantage that they don't require highly tessellated geometry, and can often be performed at little performance cost on multitexturing graphics hardware.
Generating Procedural Clouds Using 3D Hardware
Abstract: In this article, we'll set out to procedurally generate cloud textures that possess some of the properties that real clouds exhibit. In additon, because textures typically reside in graphics subsystem memory, we'll aim to generate the procedural clouds almost entirely using the graphics hardware. Finally, we'll address some ways to scale the technique's quality and performance requirements in order to accommodate a range of target machines.
Texture Masking for Faster Lens Flare | |
Abstract: This article introduces a novel way in which to generate texture information from pixels already rendered to the frame buffer. The technique can be used in several different ways, but is presented here as a solution to the common problem of occluded lens flare. Many games attempt to read back pixels generated in the frame buffer in order to determine exactly what was visible in the final scene. We will present a technique that works without CPU assistance, and does not require reading data from the graphics card. We will also outline the reasons why reading back information from the graphics card can be a costly operation and should be avoided if possible.
Practical Priority Buffer Shadows
Abstract: This article presents a set of techniques to improve the utility of "priority buffers". Along the way, we will explore other shadow techniques, and close by discussing how to create useful hybrid techniques.
Impostors: Adding Clutter
Abstract: Impostering is about using sprites in a 3D scene, but instead of an artist drawing or rendering the sprites beforehand, they are updated on the fly. Instead of rendering a high-triangle object every frame, the high-triangle object is occasionally rendered to a texture-usually on the order of once every 5 to 50 frames. This article presents Impostors and describes how to render them, create update heuristics, and use prediction to determine how to orient the impostor each time it is rendered.
Operations for Hardware-Accelerated Procedural Texture Animation
Abstract: This article covers a few fundamental operations for generating procedural animations, and puts these to use in specific examples that simulate fire, smoke, water, or perform image processing. With today's consumer hardware, we can even run complex cellular automata programs entirely within the rendering of a 3D accelerator and put the resulting animations to use in various effects.
 |
|
|
|
