|
|
|
Gamasutra.com
|
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.
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.
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.
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.
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.
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.
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.
 |
|
|
|
