|
All Articles Sorted by Date
Versatile Walk Engine
Abstract: We propose an efficient walk component for the reative animation of biped characters of any size and proportions. The movement can be controlled by changing independently its style, desired speed, and desired target position. Compared to traditional approaches, our gait style parameterization provides an efficient way to generate a multitude of varied walking animations, as needed, for example, by crowd simulations.
Poster Quality Screenshots
Abstract: In the promotion of any game, there will come a time when you need screenshots for advertisements, box covers, previews, strategy guides, magazine covers, and full-size posters. Unfortunately, raw screenshots are often inferior for many of these purposes. This article details a method by which screenshots can be improved in two main ways: by increasing the resolution and by increasing the pixel quality (anti-aliasing). This technique has been successfully used to generate shots as large as 19,200 x 14,400 at 100 samples per pixel on Nintendo GameCube hardware. However the technique is extremely general and applicable to any platform.
GPU Shadow Volume Construction for Nonclosed Meshes |  |
Abstract: This article presents a method of rendering shadow volumes without requiring a two-manifold, closed mesh.
Perspective Shadow Maps | |
Abstract: Perspective shadow maps are very similar to standard shadow maps, but are distorted such that regions close to the camera have higher resolution than distant regions. This article describes the details of perspective shadow maps, demonstrates how they are generated, and discusses how typical pitfalls can be avoided.
Combined Depth and ID-Based Shadow Buffers | |
Abstract: This article describes a hybrid approach that combines the techniques of both depth and ID-based shadow buffers, exploiting the advantages of both methods. This approach allows for self-shadowing and supports up to 42,875 unique IDs.
Carving Static Shadows into Geometry
Abstract: This article describes a method of carving hard shadows directly into static geometry to create crisp, hard scene shadows that are consistent with the look of the stencil shadows typically used for characters. After the carving process, each resulting polygon is marked as either "in light" or "in shadow" for later rendering. This saves the overhead of rendering full shadow volumes for every detail in a scene, resulting in significant fill-rate savings. Additionally, we will briefly discuss how to dynamically cast shadows on moving objects using low-resolution proxy shadow volumes.
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.
Dynamic Gamma Using Sampled Scene Luminance | |
Abstract: The human eye constantly samples the brightness of available light and dialates the pupil in response. This variable sensitivity allows it to operate under a much wider range of lighting conditions from dark to bright. By sampling the frame buffer and adjusting the output gamma based on analysis of the data, the technique outlined in this article is able to simulate this type of variable sensitivity and make much better use of video's limited dynamic range. The same technique also allows the simulation of a number of visual phenomena that occur as the eye responds to changing, high dynamic range lighting.
Heat and Haze Post-Processing Effects
Abstract: This article focuses on reproducing the visual phenomenon of gaseous convection by approximating an image such that it looks visually convincing. This post-processing effect can be easily included at the end of just about any rendering pipeline, and can significantly enhance the final output by creating stunning visual effects with relatively little effort on the part of the programmer.
Hardware Skinning with Quaternions
Abstract: This article describes a technique for spherical joint blending with quaternions. This fast, accurate, and compact skinning solution keeps joints from collapsing, which is a common artifact with skinning techniques such as vertex blending.
Motion Capture Data Compression
Abstract: This article demonstrates a lossy compression system that was developed to improve memory usage for motion capture data. While the system has some features that take advantage of bone hierarchies, a more general solution can be used on any keyframed animation, such as prerecorded camera movements and hand-animated physics objects.
Fast Collision Detection for 3D Bones-Based Articulated Characters
Abstract: This article aims to give a practical, efficient implementation for collision detection with a bones-based character. Our implementation offers several advantages over techniques common in today's engines and leverages current infrastructure that is already needed for character animation.
Terrain Occlusion Culling with Horizons | |
Abstract: This article describes an occlusion culling technique for outdoor scenes based on heightfield terrain geometry. Unlike other terrain occlusion culling techniques, it does not require expensive offline preprocessing, so it is able to adapt on the fly to dynamically changing terrain.
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.
High Dynamic Range Lighting
Abstract: This session shows how to create more realistic environments and lighting through high dynamic imagery and image-based lighting. The course presents how high dynamic range imagery (HDRI) covering the full range of light in the real world can as texture maps in real-time virtual environments and as realistic sources of illumination for CG objects and characters. The course explains the relationship between HDRI, Image-Based Lighting, and Global Illumination, and how the three can be used together to create renderings and composites with extremely high realism. Examples are given using renderings from LightWave 3D, Maya, RADIANCE, and the Arnold rendering system. HDRI file formats, manipulation software, special blur and glare effects, and issues surrounding gamma correction are presented.
Light Scattering: Oh, that Looks Cool! Can we Have it in the Game, Real Quick?
Abstract: Lately a lot of exciting new and old techniques to enhance lighting used in games have become technically feasible on current generation graphics hardware. Surprisingly, or perhaps not so surprisingly – a large number of these techniques have so far not made it into real game applications in any larger way shape or form, sometimes not at all. This talk illustrates the problems encountered and solutions found when trying to go from technology demonstration to real game application using Factor 5’s latest game ‘Star Wars: Rebel Strike’ and the light scattering technique used in it as an example. Related technology used in the game are covered.
Adding Spherical Harmonic Lighting to the Sushi Engine
Abstract: Spherical Harmonic (SH) based lighting solution have entered the mainstream of real-time graphics. This relatively new lighting technique offers many advantages to engine programmers in both performance and advanced lighting realism. The internal engine and shader library that ATI’s demo team uses for their cutting edge technology demos are the case study on how to add support for SH lighting to a real-time graphics environment. This session discusses artist usability, the preprocess tool chain, and runtime issues and solutions they have encountered while adding SH lighting support to their tools, shader library, and engine.
Advanced Real-Time Reflectance
Abstract: Recent advances in graphics hardware and APIs are enabling game developers to use increasingly general reflectance models in their games. However, physics and computer graphics research has generated a large body of knowledge about material reflectance which has not yet been leveraged by game developers. This talk starts with the basic physics of reflectance, and continues to explain the deficiencies of the most commonly-used model (Blinn-Phong). The presentation covers various reflectance models used in the computer graphics literature (such as Cook- Torrance, Ashikhmin-Shirley, Ward, LaFortune and others). Practical implementation methods for these reflectance models on modern programmable hardware are used to realistically render several real-world materials. The presentation concludes by discussing the integratation of these models into the game development pipeline.
Deferred Shading on DX9 Class Hardware and the Xbox
Abstract: Deferred Shading is a rendering technique where all lighting/shading computations are delayed until after the scene is rendered. This technique is used in the non-realtime and raytracing world but only recently has become practical for realtime gaming on the PC and console. For the game developer this means a complete decoupling of geometry rendering from lighting, and removing the problem of determining which geometry interacts with which lights. This also eliminates traditional hardware limitations on the number and types of lights used. A deferred shading engine is capable of taking advantage of the latest hardware and delivering all the cutting edge shading effects you want: 100% per-pixel lighting, extensive material property functions (NDFs, BRDFs), true High Dynamic Range lighting, Volumetric and true 3D shaped lights. The presenters, who have developed and shipped titles using deferred shading, will take the attendees from the high level concepts to the nuts and bolts of developing a deferred shading renderer.
Destruction on a Diet
Abstract: This presentation follows the evolution of techniques for environmental interactivity successfully used in Twisted Metal: Black, War of the Monsters, and Downhill Domination. The lecture covers efficient methods for destruction and secondary AI, with a description of the entire process from asset creation, through the tool chain, and into the implantation of the run-time behaviors. Also discussed are the implications of a changing topology with dynamic elements on AI and network play.
Fast Yet Realistic Deformation and Fracture
Abstract: This talk discusses the details of a simple to implement finite element method for modeling deformable solids. Although the mathematical underpinnings of continuum mechanics cannot be ignored, the main concern of the talk focuses on how one goes about implementing and using the techniques to generate interesting behaviors. In addition to basic elastic deformation, more advance techniques for plastic deformation and fracture are also covered.
Motion Capture-driven Simulation for Characters
Abstract: Simulation game engines (e.g. Havoc and Karma) are becoming increasingly popular, but the question of controlling characters in their frameworks is still mostly unanswered. Subtlies in the motion of animated, humanlike characters affect the believability, aesthetic and impact of animated agents in video games. While motion capture produces characters with stylistic detail in their movements, the data is difficult to edit and control, especially in a changing environment like those seen in the rich virtual worlds of current games. Dynamic simulation allows physical laws to dictate interactions under such circumstances, but controllers for simulated agents are difficult to construct because we do not know how to specify the details of human motion procedurally. In this lecture, we describe a technique for dynamic simulation driven by motion capture data as a means of controlling dynamic characters beyond the simple motion blending techniqes used thus far. Through combining simulation and motion capture, we work to retain the interactivity, reactivity, and non-precscribed effects of dynamics with the styliezed details of motion capture data.
Motion Synthesis
Abstract: Realistic character animation is a crucial component of a successful game. Because the players interact with the synthetic characters, their motions must react to a variety of situations. Capturing or key-framing all possible motions that a game character may need to perform is impractical. The presenter shows two motion synthesis algorithms that can generate motions on the fly for a variety of user or game engine constraints by re-arranging frames from a collection of previously captured or animated motions.
Practical Implementation of High Dynamic Range Rendering
Abstract: For game real-time graphics, the visual expression attractiveness is more important than rendering accuracy. It is difficult to create attractive images just from more precise calculation. It is important to understand the differences between HDR and LDR and which is appropriate according to the type of expressions. This lecture should help clarify some of the problems when equipping HDR, introduce some techniques of HDR expressions that are possible to use on present hardware, DX8 and DX9, and indicate the expressions that can be advanced from HDR.
Practical Shadows: Out of the Demo and Into the Engine
Abstract: There are many shadowing algorithms available, such as blob shadows, shadow maps of various types, projective shadow maps, and stencil volume shadows. But they all have limitations, some of them work on some platforms and not others, each is appropriate for different situations. This lecture introduces each method and briefly discusses their major features and limitations. It then explores how to mix and match the various methods in a practical large-world engine on real console hardware. The lecture is mainly about the tricks and tips, where corners can be cut, when to use each technique, and the efficiency and scalability of each. The emphasis is using these methods in a practical game with large, complex and unconstrained scenes, rather than simply writing a technology demo.
Procedural Shaders: A Feature Animation Perspective
Abstract: Procedural shaders are textures generated from a small number of parameters. This talk compares the procedural shaders used in feature animation such as the Perlin Noise function, brick and fur shaders, and their real-time counterparts, explaining the tradeoffs required to bring them to real time.
Real-Time Global Illumination
Abstract: The session explores how real-time global illumination game engines can be create on current hardware. A brief history on various global illumination techniques is given and then the presenter explores how they can be adopted in to real-time 3D engines. He also discusses brand new approaches targeted directly at the real-time field.
Reusing Shading for Interactive Global Illumination
Abstract: This session presents recent techniques that reuse shading information to bridge the gap between slow shading and fast interactive image update. The common approach in all these systems is that shading is sparsely sampled and reconstructed for interactive rendering. This session covers several recent techniques including image-based techniques, mesh-based approaches, and four-dimensional approaches. This session also reviews key concepts in global illumination, and describe the state of the art in fast ray tracing. The techniques that are discussed include frameless rendering, image warping, the render cache and edge- and-point rendering, shading cache and corrective texturing, and four dimensional approaches such as 4D radiance interpolants and holodeck. Fast ray tracers such as GPU-based and CPU-accelerated approaches are also discussed.
The Full Spectrum Warrior Camera System
Abstract: This lecture focuses on the details of the camera system technology used in the game Full Spectrum Warrior (FSW). The lecture covers the camera motion system, which is based on a modified version of the proportional controller often used in game camera systems. The lecture also covers the unique "autolook" feature that gives players a better view of the battlefield in situations where the view would normally be largely obstructed. Collision avoidance and high-level architecture considerations are also discussed, as well as techniques for providing feedback to programmers and designers, who need to "tune" the system for optimal performance. The lecture concludes with a discussion of the limitations of the FSW camera system, a summary of recommended practices, and ideas for future investigation.
Let There be Clouds! Fast, Realistic Cloud-Rendering in Microsoft Flight Simulator 2004: A Century of Flight
Abstract: This article describes how clouds (altocumulus, stratus, and cumulonimbus, and cloud coverages ranging from a few sparse clouds to a dense, overcast sky) were rendered in Microsoft Flight Simulator 2004. Each cloud was modeled as five to 400 alpha-blended textured sprites. The sprites face the camera during rendering and together comprise a three-dimensional volume. With the help of a custom plug-in for 3DS Max, artists were able to highly customize clouds. The article describes the plug-in and provides details on in-game rendering.
Opposing Face Geometry: A Collision Detection Optimization Scheme
Abstract: OFG presents a new method for collision detection optimizations by performing a simple pre-calculation on both input objects. It is possible to reduce the number of faces necessary to check for intersection dramatically, from an order of O(mn) intersection tests to an order of O(k^2), or rather to a maximum of k^2 + 3k test operations, where k is a predetermined constant. The pre-calculation phase is of the order of O(m + n). Therefore, for increasingly complex convex objects, the OFG method saves more and more processing time. The method's downside is that increasingly complex objects might need a very high constant and small faces are less suited for this type of optimization. The method is much better for relatively low detail 3D objects.
2003
T-Junction Elimination and Retriangulation | |
Abstract: This article describes how to detect possible sources of these seams in complex 3D scenes and how to modify static geometry so that visible artifacts are avoided. Since T-junction elimination adds verticies to existing polygons (that are not necessarily convex), we also discuss a method for triangulating arbitrary concave polygons.
Fast Heightfield Calculation | |
Abstract: Heightfields are two-dimensional arrays of height values, commonly used to store terrain or water surface data, and are also commonly used for calculating bump maps. This article will describe how we can take advantage of the special characteristics of heightfield meshes to significantly optimize vertex normal calculation.
Fast Patch Normals
Abstract: Surface patches are a memory-efficient way of creating smooth surfaces that can be rendered at many levels of detail. However, having a smooth surface is not as useful if you cannot light it properly. For that, you need the normal vector at each vertex. This article describes how to treat the normal at each control point as a second control mesh, thus quickly approximating the correct surface normal. Although the results are not strictly correct, they can produce superior results by eliminating shading errors due to curve discontinuity introduced during skinning.
Fast and Simple Occlusion Culling | |
Abstract: This article describes two occlusion culling algorithms that are practical, effective, and require little preprocessing. The first one is the prioritized-layered projection (PLP) algorithm, which is an approximate algorithm that determines, for a given budget, a set of primitives that is likely to be visible. The second algorithm, cPLP, is a conservative version of PLP that guarantees finding all visible primitives.
Triangle Strip Creation, Optimizations, and Rendering | |
Abstract: This article focuses on how to generate triangle strips from arbitrary 3D polygonal models. We will describe and provide source code for developing long triangle strips. After describing the triangle strip algorithm, we will explain the benefits of triangle strips, the possible pitfalls encountered when creating them, and how to submit them to the graphics API. In addition, several other triangle strip creation algorithms will be reviewed and critiqued.
Computing Optimized Shadow Volumes for Complex Data Sets
Abstract: In this article, we describe a method for computing the exact front cap geometry visible from a given static light source. This is the exact geometry that is visible from the light's point of view, and it is useful for calculating shadow volumes. Previous work has been done on this topic; however, most methods suffer from either infinte recursion (with complex polygonal models) or fail to solve for cyclically overlapping polygons. The method presented here also works for scenes that have intersecting polygons.
Subdivision Surfaces for Character Animation | |
Abstract: This article introduces subdivision surfaces as a means of improving the appearance of game characters. First, we will present the different schemes available, focusing on two implementations of subdivision surfaces. Then, we will explore a number of optimization methods based on culling and preprocessing.
Improved Deformation of Bones | |
Abstract: This article describes how to avoid joint pinching from typical skinning methods by introducing additional bones at troublesome joints, such as the elbow and knees. By carefully reworking the weighting data to account for these 'links,' we can use the same simple core deformation algorithm and only incur the small additional burden of a few extra bones.
A Framework for Realistic Character Locomotion
Abstract: This article presents a solution to the foot sliding problem based on adjusting the position of the feet only when they are already in motion. A framework is described for applying this idea to the problem of realistic character animation by using independent modifiers for different parts of a skeleton.
A Programmable Vertex Shader Compiler | |
Abstract: This article discusses the implementation of a compiler for programmable vertex shaders. Provided with the article is a full implementation of a simple vertex shader compiler. It also contains documentation on how to create a workspace for building compilers and an example that compiles the OpenGL lighting equation into a DirectX vertex shader. To give a practical foundation for this article, we are focusing on the vertex shader implementation in DirectX8. Future implementations might vary, but the framework and infrastructure we provide should still be applicable.
Billboard Beams | |
Abstract: This article shows how to create the illusion of a 3D beam by using two triangles for the endpoints and two triangles for the beam. The details of positioning and texture mapping of the triangles are analyzed in the article.
3D Tricks for Isometric Engines | |
Abstract: Isometric engines are one of the last bastions of two-dimensional graphics left in the game industry. While this article proposes some 3D methods to enhance what is essentially a sprite-based display system, it tries to preserve the essence of sprite-based graphics. While you could simply represent a majority of the game objects with 3D models to get the same visual effect, the ideas presented here maintain the use of sprites by adding a few tricks to make them appear as flexible as 3D models. The concepts may also be useful in other 3D engines as a replacement for flat billboard sprites or as a means to represent distant objects at a lower level of detail.
Curvature Simulation Using Normal Maps | |
Abstract: This article explains how to perturb the normals on a surface to simulate the curvature of a denser model by using bump mapping. We will enhance the visual quality without losing speed or having to abandon more traditional ways of adding detail.
Methods for Dynamic, Photorealistic Terrain Lighting | |
Abstract: This article will present several methods for producing high-quality, physically based lighting solutions for terrain under dynamic lighting conditions. Topics include: Sunlight (Horizon Angles, Shadow Ellipses, and PTMs), Skylight (Radiosity Approximations and Patches), Animated Cloud Shadows, Video-Based Solutions, and Nonterrain Objects.
Cube Map Lighting Techniques | |
Abstract: This article will describe some ways to encode different lighting conditions as well as other properties within cube maps. It will give a brief overview of the properties of cube maps and how to index into them. Topics include: Physical Properties of Cube Maps, Getting data to/from a Cube Map, Rendering with the Cube Map, Encoding Cloud Cover, Encoding Lights in a Cube Map, Encoding Diffuse Lighting in a Cube Map, and Encoding a Day/Night Cycle into a Cube Map.
Procedural Texturing | |
Abstract: The goal of this article is to introduce basic concepts for using procedures to manipulate and synthesize images for games and to give simple guidelines for implementation.
Unique Textures | |
Abstract: This article explores how to use a relatively small number of artist-generated source textures and combine them at runtime using a variety of blends, fractal methods, and random numbers to create the textures required for the scene.
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.
Simulating and Rendering Particle Systems | |
Abstract:
Real-Time Animation of Trees | |
Abstract:
Real-Time Multiresolution Dynamics of Deeply Hierarchical Bodies | |
Abstract:
Scripted Bodies and Spline-Driven Animation | |
Abstract:
Collision Detection of Deformable Volumetric Meshes
Abstract:
Building an Advanced Facial Expression System | |
Abstract:
Inverse Dynamic Displacement Constraints in Real-Time Cloth and Soft-Body Models | |
Abstract:
Resolution of the Inverse Kinematic of an Articulated Structure Using the Jacobian Pseudo-Inverse | |
Abstract:
Automatic Parameterizations on the Cube | |
Abstract:
Filling Texture Holes Using the Euclidean Distance Map | |
Abstract:
A Fast All-Interger Ellipse Discretization Algorithm | |
 |  |
Tony Barrera (Barrera Kristiansen AB), Anders Hast (Creative Media Lab, University of Gävle), and Ewert Bengtsson (Center for Image Analysis, Uppsala University)
Graphics Programming Methods, 2003. |
Abstract:
A Fast and Simple All-Interger Parametric Line | |
| |
Tony Barrera (Barrera Kristiansen AB), Anders Hast (Creative Media Lab, University of Gävle), and Ewert Bengtsson (Center for Image Analysis, Uppsala University)
Graphics Programming Methods, 2003. |
Abstract:
An Easy-to-Code Smoothing Algorithm for 3D Reconstructed Surfaces | |
Abstract:
Higher-Order Surfaces Using Curved Point-Normal (PN) Triangles | |
Abstract:
Building a Flexible Terrain Engine for the Future | |
Abstract:
Visible Terrain Grid Determination Using the Frustum | |
Abstract:
Real-Time Generation and Rendering of 3D Planets | |
Abstract:
k-D Tree Face Portals with Solid Geometry | |
Abstract:
A Framework for Rapid 3D Level Design Using MAXScript Code Generation | |
Abstract:
A Modified Phong-Blinn Light Model for Shadowed Areas | |
Tony Barrera (Barrera Kristiansen AB), Anders Hast (Creative Media Lab, University of Gävle), and Ewert Bengtsson (Center for Image Analysis, Uppsala University)
Graphics Programming Methods, 2003. |
Abstract:
Stochastic Iteration for Nondiffuse Global Illumination | |
Abstract:
Metropolis Sampling in Random Walk Global Illumination Algorithms | |
Abstract:
Metropolis Density Estimation | |
Abstract:
Rendering with Adaptive Integration | |
Abstract:
Illumination-Based Occlusion Culling | |
Abstract:
Antialiasing for Bump Maps and a Fast Normalization Trick | |
Tony Barrera (Barrera Kristiansen AB), Anders Hast (Creative Media Lab, University of Gävle), and Ewert Bengtsson (Center for Image Analysis, Uppsala University)
Graphics Programming Methods, 2003. |
Abstract:
Fast Setup for Bilinear and Biquadratic Interpolation over Triangles | |
Tony Barrera (Barrera Kristiansen AB), Anders Hast (Creative Media Lab, University of Gävle), and Ewert Bengtsson (Center for Image Analysis, Uppsala University)
Graphics Programming Methods, 2003. |
Abstract:
An Effective Implementation of the k-D Trees | |
Abstract:
Pixel Shader Optimizations for Terrain Rendering | |
Abstract:
Real-Time Light-Atmosphere Interactions for Outdoor Scenes | |
Abstract:
True Volumetric Shadows | |
Abstract:
Quantization of True-Color Images with Opacity Information | |
Abstract:
Real-Time Relighting of Compressed Panoramas | |
Abstract:
An Optimal Dynamic Surface Caching Algorithm | |
Abstract:
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.
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.
2002
The Mechanics of Robust Stencil Shadows
Abstract: This article presents the intricacies of the entire stencil shadow algorithm and covers every mathematical detail of its efficient implementation.
Shader Integration: Merging Shading Technologies on the Nintendo Gamecube
Abstract: A general approach to shading is quite valuable and helps in making the right decisions. The general approach of Star Wars: Rogue Leader on the Nintendo Gamecube is described and the decisions made based on it, are outlined. This includes sketching down most of the shading algorithms, their specific implementations, and noting some technical details; as well as various clever bits and pieces. The second part of this features introduces the application of the principles introduced to the area of landscape shading/texturing.
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.
Rendering the Great Outdoors: Fast Occlusion Culling for Outdoor Environments
Abstract: This article presents one technique for hidden surface removal usable in 3D engines using tilizing object occlusion.
Bézier Triangles and N-Patches
Abstract: Graphics accelerators are beginning to include support for curved surfaces as basic primitives, including N-patches. In this excerpt from the upcoming second edition of Real-Time Rendering, see how N-patches can replace triangles to make low-polygon models more convincing and realistic.
Complex Matrix Transformations
Abstract: Matrix transforms are a ubiquitous aspect of 3D game programming, but game programmers do not often use a rigorous method for creating them or a common way of discussing them. Practitioners in the field of Robotics have mastered them long ago, but these methods haven't made their way into daily practice among game programmers. Some of the many symptoms include models that import the wrong way and characters that rotate left when they are told to rotate right. After a review of matrix conventions and notation, this feature introduces a useful naming scheme, a shorthand notation for transforms and tips for debugging them that will allow you to create concatenated matrix transforms correctly in much shorter time.
Incredibly Dense Meshes
Abstract: This article presents a technique for dealing with "incredibly dense meshes" where one might imagine it to be nearly impossible to move the data around in real time. The technique borrows from many well-known disciplines, including wavelets, subdivision surfaces, and height fields. The result is a method for authoring, storing, and rendering dense meshes that may have one million triangles or more, assuming very fast transformation hardware and comparatively small RAM and slow DMA.
Dynamic Level of Detail Terrain Rendering with Bézier Patches
Abstract: This article discusses the terrain system used in EA's SSX title. An algorithm for the tessellation of polynomial surfaces is presented, which features adaptive tessellation with continuous level-of-detail while avoiding the introduction of cracks and seams between adjacent surfaces with different geometric resolution.
Broken Sword: Palletized JPEG for Game Boy Advance
Abstract: Broken Sword is a graphical adventure game re-implemented from scratch to work on the Game Boy Advance. Uncompressed, the backgrounds would occupy close to 7MB. This article discusses the technique we used for storing lots of high detail unique backgrounds for use with character (tiled) BG modes.
Pool Hall Lessons: Fast, Accurate Collision Detection between Circles or Spheres
Abstract: This article explains how to detect collisions between two spheres and determine what they'll do after they collide. This is useful not only for games like pool where accurate collision of spheres is key, but also in games where characters and other mobile objects are bounded by spheres, these can be used to quickly determine if they have bumped into each other.
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.
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.
Deep-Water Animation and Rendering
Abstract: This article introduces a new realtime level-of-detail deep-water animation scheme, which uses many different proven water models. In addition we show how to utilities today’s latest graphic hardware for realistic rendering of oceans. Topics include FFT, surface dynamics, navier-stokes, caustics, godrays, water optics, foam and spray.
Four Tricks for Fast Blurring in Software and Hardware
Abstract: Computer games and real-time graphics are acquiring a a sharp-edged, polygonal look, imposed largely by technical limitations and occasionally unimaginative programming. One option that is often overlooked is blurring elements of the scene. Depth-of-field and focusing effects can bring certain elements of an image into the foreground, hide unnecessary clutter, and reduce the need to resort to over-used fogging tricks. This article presents a few tricks which can help make real-time blurring possible, and hopefully will provide enough material to inspire you to invent your own hybrid techniques.
2000
Optimizing Vertex Submission for OpenGL | |
Abstract: There are a number of functions available for submitting and rendering vertices in OpenGL, which range from the simple immediate mode functions to more complicated multiple vertex functions and vendor-specific extensions. However, teh performance can vary greatly depending on the functionality used. This article provides insight into the tradeoffs of various techniques.
Tweaking a Vertex's Projected Depth Value
Abstract: The goal is to find a way to offset a polygon's depth in a scene without changing its projected screen coordinates or altering its texture mapping perspective. Most 3D graphcs libraries contain some kind of polygon offset function to help achieve this goal. However, these solutions generally lack fine control and usually incur a per-vertex performance cost. This article presents an alternative method that modifies the projection matrix to achieve the depth offset effect.
The Vector Camera | |
Abstract: The vector camera is a generalized form of the matrix-based camera found in many traditional graphics engines. Matrices are often difficult to read due to the fact that they typically hold several operations concatenated together. The vector camera uses only simple vectors to describe its orientation to the overall graphics pipeline. This article describes the how to construct a vector camera and how to manipulate it.
Camera Control Techniques | |
Abstract: This article outlines a few basic techniques that can be used to develop the proper camera model for your game. In addition to basics, a scripted camera traveling on various curves (B-Spline, Catmull-Rom spline) is also discussed along with issues such as zooming, dampening, and the use of quaternions.
A Fast Cylinder-Frustrum Intersection Test | |
Abstract: This article presents a quick algorithm for determining whether an arbitrary cylinder potentially intersects the view frustum (and thus whether the object is visible).
3D Collision Detection | |
Abstract: This article will help lay the groundwork for building an accurate physics simulation by starting with one of the most crucial parts of a real-time physics engine: 3D collision detection. The two basic algorithms this article covers are: Bounding Sphere Collision Detection and Triangle-to-Triangle Collision Detection.
Multi-Resolution Maps for Interaction Detection (Collision Detection) | |
Abstract: This article describes a method for reducing the number of proximity tests that must be performed for games with large numbers of game objects of varying sizes.
Computing the Distance into a Sector | |
Abstract: This article describes a simple and fast algorithm for determining where a point is between the edges of a 2D quad (or sector). The result is a unit floating point number, where 0 indicates that the point lies on the leading edge, and where 1 indicates that the point lies on the opposite edge. The sector may be any four-sided, 2D convex shape.
Object Occlusion Culling | |
Abstract: This article introduces both frustum culling and occlusion culling, along with example code for a simple occlusion culling algorithm.
Never Let 'Em See You Pop - Issues in Geometric Level of Detail Selection
Abstract:
Octree Construction | |
Abstract:
Loose Octrees | |
Abstract:
View-Independent Progressive Meshing | |
Abstract:
Interpolated 3D Keyframe Animation | |
Abstract:
A Fast and Simple Skinning Technique | |
Abstract:
Filling in the Gaps-Advanced Animation Using Stitching and Skinning | |
Abstract:
Real-Time Realistic Terrain Generation | |
Abstract:
Fractal Terrain Generation - Fault Formation | |
Abstract:
Fractal Terrain Generation - Midpoint Displacement | |
Abstract:
Fractal Terrain Generation - Particle Deposition | |
Abstract:
2D Lens Flare | |
Abstract: This article shows how to implement an attractive lens flare effect using only a small amount of code and artwork, without needing to know anything about physical optics.
Using 3D Hardware for 2D Sprite Effects | |
Abstract: This article sheds some light on how to use 3D hardware to achieve 2D effects. Specifically, we take a look at how to do alpha blending, sprite scaling, and sprite rotation.
Motif-Based Static Lighting | |
Abstract:
Simulated Real-Time Lighting Using Vertex Color Interpolation | |
Abstract:
Attenuation Maps
Abstract:
Advanced Texturing Using Texture Coordinate Generation
Abstract:
Hardware Bump Mapping
Abstract:
Ground-Plane Shadows | |
Abstract:
Real-Time Shadows on Complex Objects | |
Abstract:
Improving Environment-Mapped Reflection Using Glossy Prefiltering and the Fresnel Term
Abstract:
Convincing-Looking Glass for Games | |
Abstract:
Refraction Mapping for Liquids in Containers | |
Abstract:
Refractive Texture Mapping, Part One
Abstract: Gustavo Oliveira presents, in two parts, a detailed implementation of refractive texture mapping for a simple water wave simulation using directional sine waves applied to a flat polygonal mesh. In this installment, Gustavo investigates the use of sphere mapping to simulate curved-surface reflections.
Refractive Texture Mapping, Part Two
Abstract: The second part of Gustavo Oliveira's detailed implementation of refractive texture mapping for a simple water wave simulation using directional sine waves applied to a flat polygonal mesh looks at how refractive texture mapping can be implemented to simulate refractions.
3D Engines for Games: A Broader Perspective
Abstract: You've developed an object viewer, a Quake level viewer, a radiosity renderer and a patch tessellator. You know 3D math, OpenGL and the 3DS file format by heart. Now you want to go further -- you want to use this knowledge to develop an entire engine. Does this seem like a large task for you? Well let me tell you, it is. I will not try to tell you how to make a good, playable game. Nor will I tell you how to program any specific parts of an engine. In fact there won't even be a single line of code in this article. The main goal is to enable you to quickly and (relatively) painlessly develop an engine and a game that uses it.
Building Your Own Subdivision Surfaces
Abstract: This article examines how to convert triangular meshes (which is one of the most popular data representations) into subdivision surfaces.
Hardware Accelerated Spherical Environment Mapping Using Texture Matrices
Abstract: Using sphere maps, you can create very high performance and cheap static reflections which in most cases are good enough for game reflections, another very useful example is creating realistic specular highlights from an infinite light source. This article will show a hardware T&L accelerated method of using sphere maps.
Inside Direct3D: Stencil Buffers
Abstract: Many 3D games and simulations on the market use cinema-quality special effects to add to their dramatic impact. Stencil buffers can create effects such as composites, decals, dissolves, fades, outlines, silhouettes, swipes, and shadows. Stencil buffers determine whether the pixels in an image are drawn. This means your software can "mask" portions of the rendered image so that they aren't displayed.
Siggraph 2000 From a Game Development Perspective
Abstract: Hardware, software, papers, general wackiness... If you missed the party last week in New Orleans, be sure to check out this wrapup of what Siggraph 2000 had to offer game developers. If you were there, check out some of the stuff you might have missed.
Building an Advanced Particle System
Abstract: Smoke, sparks, and blood are routinely created in today's games using particle systems. To realize these effects, you need to build a particle system, and not just a simple one. You need an advanced particle system, one that's fast, flexible, and extensible.
Implementing Curved Surface Geometry
Abstract: Back when Quake was first released, consumer-level 3D acceleration was nearly unheard of, and id's software renderer scaled in speed with the clock speed of your Pentium processor. During the few years since then, though, the game market has reached a point of extreme processor stratification. As game developers, it's important to support high-end consumers, and yet we'd prefer not to abandon the low-end players. And from this desire was a new industry trend born: scalable geometry.
The Blobs Go Marching Two by Two
Abstract: The challenge of accurately modelling organic shapes and the they way they slop, splash, waddle and plop has caused many game artists to crumple under the pressure of recreating such phenomena. Jeff Lander shows how to use meta-goop to create and manipulate organic objects.
Using Bitmaps for Automatic Generation of Large-Scale Terrain Models
Abstract: As game worlds (especially online, persistent ones) get larger, game development teams need efficient ways of creating large expanses of terrain without having to build it manually. Kai Martin introduces a bit-map based technique that helps automatically generates terrain, while still giving artists and world builders control over the details.
Subdivision Surface Theory
Abstract: A relatively new, up-and-coming technique for implementing scalable geometry, subdivision surfaces have emerged as a compelling contender among scalability solutions. Brian Sharp explains different surface schemes and how they can be applied to real-time 3D development.
Implementing Subdivision Surface Theory
Abstract: Sharp expands his introduction to subdivision surfaces with techniques for implementing the modified butterfly scheme in real-time development, complete with a demo.
Read My Lips: Facial Animation Techniques
Abstract: Until recently most facial animation used in games has been limited to cut-scene movies, but now more and more games have begun to include facial animation in real-time 3D. In the first of a two part series, Jeff Lander examines the basic concepts of facial movement.
Flex Your Facial Animation Muscles
Abstract: Given a nice, short list of the 13 visemes needed to represent speech realisitically, how would you adapt them to a character mesh to enable continuous lip-synching? In the second of two part series, Jeff Lander continues his examination of facial animation techniques by investigating how to construct and manipulate meshes.
Real-Time Dynamic Level of Detail Terrain Rendering with ROAM
Abstract: Once the sole domain of flight simultations, outdoor landscaping is now finding its way into 3D action gaming. In this article Bryan Turner examines the state of the art in hardware accelerated landscape engines and the algorithms which power them, with particular emphasis on Real-time Optimally Adapting Meshes (ROAM).
Advanced Collision Detection Techniques
Abstract: This article will take a top-down approach to collision detection by first looking at the whole picture and then quickly inspecting the core routines. I’ll discuss collision detection for two types of graphics engines: portal-based and BSP-based engines. Because the geometry in each engine is organized very differently from the other, the techniques for world-object collision detection are very different. The object-object collision detection, for the most part, will be the same for both types of engines, depending upon your current implementation. After we cover polygonal collision detection, we’ll examine how to extend what we’ve learned to curved objects.
Devil in the Blue Faceted Dress: Real Time Cloth Animation
Abstract: Cloth animation is tricky, and even in the world of high-end computer graphics, it’s difficult to get right. Jeff Lander wanted to create realistic cloth in his environments and on his characters, so with his hardware accelerated graphics rasterization freeing enough processor power necessary to make it possible, he set set about creating a real-time cloth simulation.
Continuous LOD Terrain Meshing Using Adaptive Quadtrees
Abstract: As part of the R&D for Soul Ride, the game I'm currently working on, I experimented with the published algorithms, and eventually came up with an extension that eliminates the tradeoff between terrain size and close-up detail. This article presents my algorithm, along with its similarities and differences from the above-mentioned algorithms.
2D Surface Deformation
Abstract: Increases in the performance of graphics accelerators free additional CPU cycles that can be used for real-time physical world modeling. Modifying the geometry of an object is more effective than mapping a new or animated texture, because correctly deformed objects will look right from any angle and in any lighting conditions. Max I. Fomitchev discusses the implementation of deformable surfaces for real-time 3D games that simulate realistic environments.
Crashing into the New Year: Collision Detection
Abstract: Collision detection is a huge issue and an active area of research in graphics simulation. Using techniques such as the dot product and cross product, Jeff Lander investigates some common problems that can be important to a variety of game applications.
When Two Hearts Collide: Axis-Aligned Bounding Boxes
Abstract: Most discussions of collision detection for real-time game applications begin with bounding spheres and bounding boxes. While fast, bounding spheres don't generally give the best approximation of an object's extent. Jeff Lander demonstrates the use of axis-aligned bounding boxes for 3D collision detection.
Using NURBS Surfaces in Real-time Applications
Abstract: The quest goes on to find suitable alternatives to polygonal models, and one of the most promising candidates seems to be NURBS surfaces. In this article, Dean Macri covers everything from concepts and terminology associated with parametric curves and surfaces, to difficulties encountered when using NURBS surfaces in place of polygonal models, to the types of 3D content that can be created by using parametrics.
Real-Time Shadow Casting Using Shadow Volumes
Abstract: Despite the rich colors, intricate textures, and dazzling effects in today's games, the human brain still notices that something is missing, and that something might just be shadows. Running with this idea, Jason Bestimt and Bryant Freitag discuss real-time dynamic shadowing using shadow volumes, presenting techniques and code listings for creating accurate shadows in 3D environments.
Occlusion Culling Algorithms
Abstract: Developers are always going to want better performance in real-time rendering, and so speed-up techniques and acceleration schemes will always be needed. In this excerpt from Chapter 7, "Speed-Up Techniques," of Real-Time Rendering, the authors discuss the class of acceleration schemes known as the occlusion culling techniques.
An In-Depth Look at Bicubic Bezier Surfaces
Abstract: In the November 1999 issue of Game Developer, Mark A. DeLoura discussed bicubic Bézier surfaces and their implementation for the Nintendo 64. Here he expands on the mathematics behind those ideas, analyzing three different tessellation algorithms and presenting the mathematical argument in favor of tessellation by central differencing.
Real-time Soft-object Animation using Free-form Deformation
Abstract: With increasing processor speeds, soft-object animation is finally affordable. You've heard of Bezier curves and surfaces - now use Bezier volumes to morph the heck out of your geometry. Add personality and exaggeration to a character's movements, or calculate the "intuitively correct" way to smash up a car.
SIGGRAPH '99 From a Game Development Perspective
Abstract: What did Daniel do this summer? He explored SIGGRAPH. Now he's bringing you the low-down on SGI, the state of Fahrenheit, Nvidia's NV-10, the latest animation tools, looming trends, and how they did that cool thing in the Matrix.
A Compact Method for Backface Culling
Abstract: Detecting and eliminating polygons in scene that face away from the viewer reduces the amount of computation and memory traffic. This article describes a new culling technique that performs accurate backface culling in object space, will speed up your 3D games on the PC.
Understanding and Using OpenGL Texture Objects
Abstract: What is a texture object, anyway? Apparently, they can improve your textured rendering performance by more than 10 times while using the same hardware. If this sounds like a good deal to you, read on. Wright will tell you all about how to make use of them.
2D Collision Detection
Abstract: Collision detection in 2D graphics is fairly straight-forward. You are normally trying to see whether two rectangular areas are in any way touching or overlapping each other. The rectangles to test for overlapping are the vertical and horizontal extents of the two bitmap images you want to perform collision detection on.
Architecting a 3D Animation Engine
Abstract: The interface to a 3D animation system can be very simple or very complex. If you've written one, you know what I mean. If you haven't written one, you probably will someday soon. Here is a set of C/C++ interface guidelines for an animation engine.
Rotating Objects Using Quaternions
Abstract: Implementing a floating camera that tracks and rotates about a real-time 3D character is just one of the many reasons you should understand the importance and implementation of quaternions.
Octree Partitioning Techniques
Abstract: Using Octree Space Partioning correctly can make all the difference between just another game and a beatiful work of art. Mike Kelleghan shows how it's done.
|
