|
Subcategory: Landscapes and Terrain |
Topic |
Author |
Description |
|
Adding Realistic Rivers to Random Terrain [Added: 3/15/2004]
|
David Clyde
|
Discusses a method for adding rivers to randomly generated terrain that adds a realistic touch. |
|
Box Filtering Height Maps for Smooth Rolling Hills [Added: 10/23/2004]
|
Graham Wihlidal
|
Explains how to remove the sharp edges in height maps using a simple convolution filter. |
|
Continuous LOD Terrain Meshing Using Adaptive Quadtrees [Added: 2/29/2000]
|
Thatcher Ulrich
|
Presents an terrain algorithm that allows large landscapes with a high level of close-up detail. |
|
Fast Computation of Terrain Shadow Maps [Added: 5/7/2002]
|
Mircea Marghidanu
|
Covers the lighting and shadowing aspects of terrain rendering. |
|
How To Render Landscapes [Added: 8/25/1999]
|
James Sharman
|
|
|
Normal Computations for Heightfield Lighting [Added: 8/4/2005]
|
Jeromy Walsh
|
Explains the most common algorithms for computing vertex and surface normals in a heightfield. |
|
Procedural Planets Part 1 - Structure [Added: 3/21/2004]
|
Andrew True
|
Covers a triangle tessellation/data structure for procedural meshes that is different from the usual RTIN ROAMs and significantly different from Diamond LoDs |
|
Real-Time Dynamic Level of Detail Terrain Rendering with ROAM [Added: 4/11/2000]
|
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). |
|
Real-Time Heightmap Self-Shadowing Using the Strider Technique [Added: 7/22/2004]
|
Matthew Strahan
|
Describes a technique for creating terrain shadows. |
|
ROAMing Terrain: Real-time Optimally Adapting Meshes [Added: 6/7/2000]
|
Mark Duchaineau, et al.
|
Presents the ROAM (Real-time Optimally Adapting Meshes) method of terrain generation. |
|
'Slope Lighting' Terrain [Added: 7/8/2001]
|
Charlie Van Noland
|
Describes a fast terrain lighting technique. |
|
Spectral Synthesis Noise for Creating Terrain [Added: 1/11/2000]
|
druid
|
druid presents a flexible algorithm for producing very realistic and usable terrain, along with source code and executables |
|
Super Frustums [Added: 11/3/2003]
|
Borja Fdez. Gauna
|
Provides a high-level analysis of 3 methods of managing large terrains. |
|
Terrain Generation Using Fluid Simulation [Added: 9/30/2003]
|
Francis Woodhouse
|
Proposes a new method of terrain heightmap generation that uses an iterative process, treating the heightmap as a highly viscous and rubbery fluid. |
|
Terrain Geomorphing in the Vertex Shader [Added: 5/8/2003]
|
Daniel Wagner
|
This article, excerpted from the upcoming ShaderX2 - Shader Programming Tips and Tricks, discusses the implementation a fast terrain renderer which works optimally with current 3D hardware. |
|
Terrain Reasoning for 3D Action [Added: 10/3/2001]
|
William van der Sterren
|
Terrain reasoning gives the AI the
capability to take terrain into account terrain in planning, decision making,
action, and communication. |
|
Texturing Heightmaps [Added: 5/12/2005]
|
John Dexter
|
Gives a brief introduction to heightmaps before looking at some basic ways to color and texture a heightmapped terrain. |
|
The Second Life of Brute Force Terrain Mapping [Added: 6/20/2002]
|
Sander Maréchal
|
The article describes how advances in 3D hardware have benefitted terrain mapping algorithms. With the current state of technology, the brute force has become, in some situations, a realistic alternative to modern CLOD mapping. |
|
Uniform Terrain Decalcomania [Added: 6/29/2004]
|
Graham Towse
|
Provides an introduction about how to apply decals such as scorch marks to terrain. |
|
Using Bitmaps for Automatic Generation of Large-Scale Terrain Models [Added: 6/7/2000]
|
Kai Martin
|
Introduces a bit-map based technique that helps automatically generate terrain, while still giving artists and world builders control over the details. |
|
Subcategory: Collision Detection |
Topic |
Author |
Description |
|
Advanced Collision Detection Techniques [Added: 4/11/2000]
|
Nick Bobic
|
Assumes you already know some 3D collision detection basics and gets into advanced topics. |
|
Collision Detection [Added: 9/15/1999]
|
John Amato
|
Covers the bounding rectangles and pixel-perfect approaches to collision detection, including an argument for testing against a single pixel in some cases. |
|
Collision Detection Algorithm [Added: 9/17/1999]
|
TANSTAAFL
|
TANSTAAFL throws his hat into the ring with a straightforward method using bitmasks. |
|
Collision Response: Bouncy, Trouncy, Fun [Added: 7/10/2000]
|
Jeff Lander
|
Investigates how particle dynamics affects collision response. |
|
Crashing into the New Year: Collision Detection [Added: 7/10/2000]
|
Jeff Lander
|
Using techniques such as the dot product and cross product, Jeff Lander investigates some common collision detection problems that can be important to a variety of game applications. |
|
General Collision Detection for Games Using Ellipsoids [Added: 5/26/2000]
|
Paul Nettle
|
This document describes a collision technique that allows you to move an ellipsoid (a sphere with three different radii, one for each axis) through a world that not only properly detects collisions, but also reacts in a way that gamers would expect from the common first person shooter.
|
|
Getting the most out of your collision tests [Added: 9/15/1999]
|
Dave Roberts
|
An excellent article from Dr. Dobb's Journal, covering several approaches to collision detection. |
|
Opposing Face Geometry [Added: 2/19/2004]
|
Eli Kara
|
OFG presents a new method for collision detection optimizations by performing a simple pre-calculation on both input objects. |
|
Pool Hall Lessons: Fast, Accurate Collision Detection Between Circles or Spheres [Added: 1/28/2002]
|
Miles Jackson and Joe van den Heuvel
|
Explains how to detect collisions between two spheres and determine what they'll do after they collide. |
|
Practical Collision Detection [Added: 9/15/1999]
|
Jonathan Blow
|
Presents a sophisticated 3D collision detection method. |
|
Simple Bounding-Sphere Collision Detection [Added: 11/12/2000]
|
Oleg Dopertchouk
|
This article explains the simple process of using bounding sphere to detect collisions in 3D environments. |
|
Simple Intersection Tests For Games [Added: 6/14/2000]
|
Miguel Gomez
|
A key component to virtually any graphical game, 2D or 3D, is a collision detection system for game objects. This article explains some simple intersection tests for the most useful shapes: spheres and boxes. |
|
When Two Hearts Collide: Axis-Aligned Bounding Boxes [Added: 7/10/2000]
|
Jeff Lander
|
Demonstrates the use of axis-aligned bounding boxes for 3D collision detection. |
|
Subcategory: General |
Topic |
Author |
Description |
|
3DS Parser [Added: 6/2/2004]
|
|
Article and Java source code for parsing a .3ds file |
|
A Real-Time Procedural Universe, Part One: Generating Planetary Bodies [Added: 3/8/2001]
|
Sean O'Neil
|
Explains how to procedurally generate full-size planetary bodies at any level of detail. |
|
A Real-Time Procedural Universe, Part Three: Matters of Scale [Added: 4/20/2003]
|
Sean O'Neil
|
Concentrates on how to scale up to a star system or even an entire galaxy. |
|
A Real-Time Procedural Universe, Part Two: Rendering Planetary Bodies [Added: 8/28/2001]
|
Sean O'Neil
|
Describes a method of creating landscapes using spherical LOD algorithms. |
|
Achieving Frame Rate Independent Game Movement [Added: 12/20/2001]
|
Dan Ricart
|
The tutorial goes over some small equations to vary game movement based on frame rates and shows modifications made to NeHe's lesson 23 to demonstrate the effect. |
|
Alex Russell's Game Programming Tutorial using DirectX [Added: 3/21/2004]
|
Alex Russell
|
A series of game programming tutorials that assume you already know DirectX. |
|
Algorithms for an Infinite Universe [Added: 6/7/2000]
|
Guy W. Lecky-Thompson
|
How to create the illusion of an infinite world. |
|
Automating the Build Process [Added: 12/14/2000]
|
Francis Irving
|
Discusses using automated builds to reduce stress and improve efficiency. |
|
BackBuffer [Added: 7/17/2000]
|
Seumas McNally
|
BackBuffer is a basic 2D display technology, which provides an abstracted interface to a linear frame buffer in 8, 16, 24, or 32-bits, with seamless full-screen and windowed mode switching. |
|
Behind the Scenes of Messiah’s Character Animation System [Added: 3/28/2000]
|
Michael ‘Saxs’ Persson
|
Problems, solutions, and what was learned. |
|
Bringing Dr. Jones to the Infernal Machine [Added: 8/28/2001]
|
Florian Sauer
|
Explores how squeezing Indiana Jones and the Infernal Machine into the N64 can offer lessons for all development projects. |
|
Building Scalable 3D Games for the PC [Added: 7/10/2000]
|
Kim Pallister and Dean Macri
|
Discusses scalability in several areas of game development. |
|
ClanLibbing Part 1: Getting Started [Added: 11/2/2000]
|
Michael DePalatis
|
The first part in this series of ClanLib articles covers the basics, including exception handling in C++. |
|
Creating a PAK File Format [Added: 9/6/2003]
|
Raymond Wilson
|
Demonstrates one way of organising all your game related media files in to a single "PAK", or resource, file. |
|
Creating a Quake-like Console Using DirectDraw [Added: 5/17/2000]
|
Pranay Uppuluri
|
You know you want a Quake-like console in your game. This article will show you how. |
|
Creating a Scalable Console System with STL – Part 1 [Added: 12/6/2004]
|
Facundo Matias Carreiro
|
This article will explain how to create an abstract console interface. |
|
Creating a Useful Camera Class [Added: 10/13/2004]
|
Michael Schuld
|
An implementation of a camera that flies around in 3d space with math explanations as well as source code. |
|
Decoupling the mouse pointer update from the frame rate [Added: 10/22/1999]
|
Brian Gantt
|
Shows how to keep your mouse movement smooth regardless of the frame rate. |
|
Designing a Screen Shot System [Added: 3/12/2004]
|
James Dougherty (UltimaX)
|
Shows a way to design a high quality screen shot system. |
|
Enginuity, Part I [Added: 5/28/2003]
|
Richard Fine
|
Provides a roadmap for the series. |
|
Enginuity, Part II [Added: 6/11/2003]
|
Richard Fine
|
Covers the layout of the engine as a whole, and then moves to memory management and error logging. |
|
Enginuity, Part III [Added: 7/5/2003]
|
Richard "superpig" Fine
|
This installment adds a simple profiler to the engine, looks at working with game settings, and finally moves on to the heart of the engine - the kernel. |
|
Enginuity, Part IV [Added: 8/2/2003]
|
Richard "superpig" Fine
|
This article we'll take all the code we've produced so far - the Foundation Tier of the Enginuity engine - and actually make an executable program with it. Then we'll put together some of the 'system tasks' that any game will need. |
|
Enginuity, Part V [Added: 10/28/2003]
|
Richard "superpig" Fine
|
Adds serialization, triggers/interpolators, and the build stamp. |
|
Extended Graphical Templates for Sprite Management [Added: 7/12/2000]
|
TANSTAAFL
|
Explains how to store sprite information as part of the sprite. |
|
Game Programming 101 Part I [Added: 6/3/2000]
|
Bruno Sousa
|
This series takes the reader through the creation of a simple game. In part I, the design document is created and the basic setup is explained. |
|
Game Programming 101 Part II [Added: 6/29/2000]
|
Bruno Sousa
|
In part II, an error handling class and a basic Win32 skeleton are created. |
|
Game Programming Beginners Guide [Added: 1/18/2000]
|
Dave Astle
|
A must read for anyone just getting started in game programming. Answers many common questions. |
|
Game Programming Genesis Part I : Beginning Windows Programming [Added: 11/5/2000]
|
Joseph Farrell
|
This ongoing series will cover creating an RPG in Windows and DirectX. The first installment gets you started writing Win32 applications in Visual C++. |
|
Game Programming Genesis Part II : Using Resources in Win32 Programs [Added: 11/18/2000]
|
Joseph Farrell
|
Part 2 covers many resource types, including icons, cursors, bitmaps, menus, string tables, and custom types. |
|
Game Programming Genesis Part III : Tracking Your Window and Using GDI [Added: 12/7/2000]
|
Joseph Farrell
|
Part 3 in this series deals with some important Windows messages, and introduces the Graphical Device Interface. |
|
Game Programming Genesis Part IV : Introduction to DirectX [Added: 12/19/2000]
|
Joseph Farrell
|
Part 4 introduces the structure of DirectX, the Component Object Model (COM), and the fundamentals of DirectDraw. |
|
Game Programming Genesis Part IX : Adding Characters [Added: 3/7/2001]
|
Joseph Farrell
|
Shows how to take your existing tile engine and add a controllable player character, as well as some basic ideas for NPCs. |
|
Game Programming Genesis Part V : Palettes and Pixels in DirectDraw [Added: 1/3/2001]
|
Joseph Farrell
|
Explains how to create palette objects in DirectDraw, how to plot pixels in all color depths, and some basic special effects. |
|
Game Programming Genesis Part VI : Bitmapped Graphics in DirectDraw [Added: 1/12/2001]
|
Joseph Farrell
|
Covers loading bitmaps to surfaces, using the blitter for copying and color filling, using color keys, and clipping. |
|
Game Programming Genesis Part VII : Developing the Game Structure [Added: 1/29/2001]
|
Joseph Farrell
|
Presents an example of how to design a code layout for a Win32 game, covering modules, scripts, and effects. |
|
Game Programming Genesis Part VIII : Basic Tile Engines [Added: 2/12/2001]
|
Joseph Farrell
|
Walks through the development of a very basic tile engine with eight-way scrolling, flexible tile animations, and multi-layered maps. |
|
Game Programming Genesis Part X : Tips and Tricks [Added: 4/10/2001]
|
Joseph Farrell
|
Closes the series with a number of brief looks at useful game techniques, such as using log files and an overview of scripting. |
|
Graphics API Independence IV: TGA, BMP & RenderStates! [Added: 1/8/2004]
|
Erik "Wazoo" Yuzwa
|
Adds support for loading Targa files as well as adding render states. |
|
High Resolution Timing In Games [Added: 9/17/1999]
|
Dhonn Lushine
|
Dhonn explains how to use your built-in, high-resolution hardware clock in games. |
|
How to Load a Bitmap [Added: 7/23/2003]
|
Mark Bernard
|
Answers a commonly asked question. |
|
Image Compression with Vector Quantization [Added: 4/24/2001]
|
Ivan-Assen Ivanov
|
Provides an introduction to the field of VQ, presents two algorithms for performing VQ, and goes into the details of a successful real-world application for VQ texture compression. |
|
Instant Replay: Building a Game Engine with Reproducible Behavior [Added: 8/28/2001]
|
Patrick Dickinson
|
|
|
Item Management Systems [Added: 10/21/2004]
|
Victor Nicollet
|
Presents a simple and basic system for managing game objects. |
|
Keyboard I/O Considerations in Game Development [Added: 6/18/2004]
|
Rakesh Iyer
|
Presents a method for dealing with keyboard sampling rates changing over time as hardware advances. |
|
Loading and displaying .X files without DirectX [Added: 3/30/2005]
|
Paul Coppens
|
Detailed description of the .X file format, including how to load and animate it without DirectX. |
|
Machinima Cutscene Creation, Part One [Added: 10/9/2000]
|
Hugh Hancock
|
Examines some of the most common mistakes and omissions made in real-time cutscene creation, and points out a few pathways to truly cinematic cutscenes within game engines. |
|
Machinima Cutscene Creation, Part Two [Added: 10/12/2000]
|
Hugh Hancock
|
Looks at the meat of cutscene creation, production and post-production, before ultimately considering the specific strengths and weaknesses of real-time 3D as a cinematic medium. |
|
Making Galaxies [Added: 3/5/2001]
|
Patrick Down
|
Looks at a technique of using randomly generated data to create galaxies. |
|
Play by Play: Effective Memory Management [Added: 5/7/2003]
|
Brian Hixson, et al
|
This discussion is based on Tiburon's experiences in writing and rewriting the memory manager for Madden NFL 97 to Madden NFL 2002. |
|
Production Quality Game Code [Added: 9/17/1999]
|
Jered Wierzbicki
|
Jered discusses the level of code quality needed to create a commercial game. It may surprise you... |
|
Random maze-generator FAQ [Added: 1/15/2002]
|
|
Contains a few C implementations of random maze generation. |
|
Recognition of Handwritten Gestures [Added: 1/9/2004]
|
Oleg Dopertchouk
|
Explains how to use gesture recognition for input. |
|
Resource Files Explained [Added: 1/17/2000]
|
Jesse Towner
|
The time has come for you to venture into a new world of the game development universe - the elegant world of resource files. |
|
Screen Update API for Allegro [Added: 9/30/2004]
|
Chris "23yrold3yrold" Barry
|
Provides code and documentation for updating the screen in Allegro. |
|
Simultaneous Cross-Platform Game Development [Added: 7/10/2000]
|
Eric Lengyel
|
Demonstrates how major subsystems of a game engine can be written to function on both Windows and Macintosh operating systems. |
|
Static Libraries From a Game Programming Perspective [Added: 3/2/2001]
|
Stefan Hajnoczi
|
Explains what static libraries are and how to use them. |
|
Striving For Graphics API Independence [Added: 1/24/2002]
|
Erik Yuzwa
|
Walks through the steps involved in creating a rendering dynamic link library to allow you to switch between OpenGL and DirectGraphics transparently. |
|
Striving For Graphics API Independence II [Added: 6/25/2003]
|
Erik "Wazoo" Yuzwa
|
Covers the abstraction of primitive rendering APIs. |
|
Striving For Graphics API Independence III : Texture Mapping [Added: 8/15/2003]
|
Erik "wazoo" Yuzwa
|
This installment adds texture mapping to the mix. |
|
Synchronizing Walking Animations [Added: 4/5/2005]
|
Nicolás Vinacur
|
Presents a technique for spacing 2D animations. |
|
Text Input in an Allegro Game [Added: 8/14/2004]
|
Chris "23yrold3yrold" Barry
|
Describes how to process input using both C and C++. |
|
The Basic Game Loop [Added: 9/17/1999]
|
Geoff Howland
|
A simple description of the guts of every game. |
|
The Power of the Creator [Added: 10/7/2001]
|
Ben Dilts
|
This article covers a method for eliminating memory leaks in the context of a game engine. |
|
Timing Pitfalls and Solutions [Added: 4/16/2004]
|
Jan Wassenberg
|
Discusses some of the challenges involved with doing accurate timing on a PC. |
|
Using XML Technologies For Enhancing Log Files [Added: 6/12/2005]
|
Jack "jollyjeffers" Hoxley and Oli "evolutional" Wilkinson
|
Provides a practical demonstration of leveraging the power of XML in your own projects. |
|
Video Game Production Tutorials [Added: 12/6/2003]
|
Paul Zirkle
|
An highly informative anlaysis of game engine design, done as a research project. |
|
What Your Mother Never Told You about Game Programming [Added: 1/29/2001]
|
Peter Warden
|
Shares some of the ways in which you can keep your code usable in an imperfect environment. |
|
Working With AVI Files [Added: 11/8/1999]
|
Jonathan Nix
|
Covers working with AVI files using Microsoft's AVIFile API. |
|
Writing a Font Engine [Added: 5/17/2000]
|
Ben Hanson
|
Describes a simple, if inefficient, method to add font support to your game. |
|
Writing your own Load / Save routines [Added: 1/15/2001]
|
Bruno Sousa
|
Explains how to load games from and save games to a file. |
|
Subcategory: Code on the Cob |
Topic |
Author |
Description |
|
1: Introductions [Added: 10/29/1999]
|
Chris Hargrove
|
Discusses the purpose of the series, including promoting good code design. |
|
2: Let the Madness Begin [Added: 10/29/1999]
|
Chris Hargrove
|
Gets the project started with the system code |
|
3: Hey! Hey! Don't Touch Me! [Added: 10/29/1999]
|
Chris Hargrove
|
Covers the user input system |
|
4: Stack 'em, Pack 'em, and Rack 'em. [Added: 10/29/1999]
|
Chris Hargrove
|
Covers the creation of a file system |
|
5: From Top to Bottom [Added: 10/29/1999]
|
Chris Hargrove
|
Chris presents his Kiwidogma on the roles of top-down and bottom-up design in games |
|
6: The Butler [Added: 10/29/1999]
|
Chris Hargrove
|
Shows you how to build a resource management system |
|
7: A Sight for Sore Eyes [Added: 10/29/1999]
|
Chris Hargrove
|
Starts into the graphics system with DirectDraw |
|
8: Turkey Day Discussion [Added: 10/29/1999]
|
Chris Hargrove
|
Chris takes a break from the code to tell how he got into the industry |
|
9: Taking Command [Added: 10/29/1999]
|
Chris Hargrove
|
Goes over creating a Quake-style in-game console |
|
10: The Sounds of Madness [Added: 10/29/1999]
|
Chris Hargrove
|
Briefly introduces the DirectSound code |
|
11: The Next Stage [Added: 10/29/1999]
|
Chris Hargrove
|
Besides improving the video layer, this article covers the various stages programmers go through |
|
12: Bedtime Stories [Added: 10/29/1999]
|
Chris Hargrove
|
Chris' book recommendations |
|
13: Vector, Victor... Roger, Roger... [Added: 10/29/1999]
|
Chris Hargrove
|
Goes over some of the basics of 3D math, and why matrices aren't always good |
|
14: The Trials and Tribulations of Cocktail Parties [Added: 10/29/1999]
|
Chris Hargrove
|
Introduces multiplayer networking |
|
15: Perils of the Clock [Added: 10/29/1999]
|
Chris Hargrove
|
Explains why the series won't be completed for a while, if ever |
|
Subcategory: Optimization |
Topic |
Author |
Description |
|
Fifteen Ways to do Faster Blits [Added: 7/24/1999]
|
David Berube
|
Contains several tips for optimizing blits. Includes sample blitting code and an explanation of what was done to speed it up.
|
|
Implementing a 3D SIMD Geometry and Lighting Pipeline [Added: 3/1/2000]
|
Ronen Zohar and Haim Barad
|
Covers speeding up your engine using the new P3 instructions. |
|
Leveraging the Power of Cache Memory [Added: 3/1/2000]
|
Alexandre Macris and Pascal Urro
|
Shows a couple of ways of using data structures to take advantage of caching. |
|
Optimizations Corner: An Optimized Matrix Library in C++ [Added: 7/10/2000]
|
Haim Barad
|
Presents a set of optimized matrix routines that take advantage of SIMD architectural enhancements done to recent microprocessors. |
|
Optimizations Corner: Cleaning Memory and Partial Stalls in Your Code [Added: 7/10/2000]
|
Haim Barad
|
Explains the concept of partial stalls and how they affects performance on modern dynamic execution microarchitectures, relevant to Pentium Pro, Pentium II, and Pentium III processors. |
|
Optimizations Corner: Sorry, But Size Does Count! [Added: 7/10/2000]
|
Haim Barad
|
Presents some useful data optimization guidelines and shows that size really does count after all. |
|
Optimizations Corner: Tessellation of 4x4 Bezier Patches for the Intel Pentium III Processor [Added: 4/27/2000]
|
Haim Barad
|
Barad demonstrates 4x4 Bezier patches and how, by creating an optimized engine that incorporates tessellated surfaces, one can exploit features such as continuous LOD and non-rigid body deformation. |
|
Pentium III Prefetch Optimizations Using the VTune Performance Analyzer [Added: 4/27/2000]
|
Ornit Gross
|
Speed up your games by prefetching data using Streaming SIMD Extensions. |
|
Performance Programming Applied to C++ [Added: 7/29/2000]
|
Joris Timmermans
|
Fast code is a goal we all share. This article covers techniques you need to know to improve the performance of your programs, including some C++ specific suggestions. |
|
Profiling, Data AnalEnsysis, Scalability, and Magic Numbers, Part 2: Using Scalable Features and Conquering the Seven Deadly Performance Sins [Added: 8/24/2000]
|
Herb Marselas
|
Ensemble's Herb Marselas concludes his two-part series on game optimization. |
|
Profiling, Data Analysis, Scalability, and Magic Numbers [Added: 8/16/2000]
|
Herb Marselas
|
The first of a two-part series reveals the tips, tricks, tools, and pitfalls that went into raising the performance profile of Age of Empires II: The Age of Kings. so that it would run well on the minimum machine specification. |
|
Speeding up Memory Reads and Writes with VectorC [Added: 8/16/2000]
|
Andrew Richards
|
This article covers "prefetching" and "non-temporal stores" which can speed up performance considerably when used well. It also discusses using assembly language instead of VectorC to do the same job. |
|
Using VectorC to Take Advantage of MMX, 3DNow! and SSE [Added: 7/7/2000]
|
Andrew Richards
|
VectorC is a new compiler specifically designed to be used in game development. Here, VectorC's creator describes how to use it to optimize performance using Intel and AMD's multimedia instructions. |
|
Video Applications For the Pentium III Processor [Added: 7/10/2000]
|
Asi Elbaz
|
Describes how the Pentium III processor and Streaming SIMD Extensions can improve the performance of integer-based applications, using examples from the MPEG encoder application. |
|
Subcategory: Simple DirectMedia Layer |
Topic |
Author |
Description |
|
Direct3D 9.0 with SDL [Added: 5/17/2005]
|
Michael Conway
|
Illustrates how to use SDL instead of native Win32 to set up a Direct3D application. |
|
SDL & Fonts [Added: 6/9/2003]
|
Doug Manley
|
Describes how to easily use text with SDL. |
|
SDL & Fonts Part 2: PrintStrings [Added: 7/9/2003]
|
Doug Manley
|
Continues where the previous article left off, covering how to handle multiple lines of text. |
|
The Simple DirectMedia Layer from a Win32 Perspective, Part 1: Setting Up Your System for SDL [Added: 12/4/2001]
|
Ernest Pazera
|
This series kicks off by walking you through the steps needed to set up your development system to use SDL. |
|
The Simple DirectMedia Layer from a WIN32 Perspective, Part 2: SDL Video [Added: 12/17/2001]
|
Ernest Pazera
|
The second installment in this series provides extensive coverage of the video component of SDL. |
|
Subcategory: Links |
Name |
Rating |
Description |
|
Interactive Collision Detection for Virtual and Simulated Environments [Added: 5/17/2000 Clicks: 9401]
|
|
Don't you love academic sites? Their titles are so matter-of-fact. If you're going to be colliding objects in 3D, this contains some fast algorithms for doing it. |
|
morduun's big list of content generators [Added: 6/16/2002 Clicks: 6312]
|
|
A nice list of free or cheap tools for game development. |
|
YOV 408 [Added: 1/7/2004 Clicks: 2795]
|
|
Contains numerous articles and tutorials on game programming and other topics. |
|
Subcategory: Source Code |
Topic |
Author |
Description |
|
abermud [Added: 2/22/2002]
|
|
Source code to a MUD. (151K zip) |
|
Abuse [Added: 2/22/2002]
|
|
The very popular Abuse, by Crack-dot-com. (2482K zip) |
|
Descent I [Added: 2/22/2002]
|
|
Slightly limited source to Descent I.
(1475K self-extracting zip) |
|
DOOM [Added: 2/22/2002]
|
John Carmack
|
DOOM. 'Nuff said. (335K zip) |
|
Duke Nukem 3D [Added: 5/8/2003]
|
3D Realms
|
Full source to the 3D Realms legend. Release notes here |
|
Freespace 2 [Added: 4/29/2002]
|
Volition
|
The Freespace 2 source code from Volition (2.65 mb). |
|
Golgotha [Added: 2/22/2002]
|
|
The late Crack-dot-com's Golgotha engine. Warning, this is huge. (33,996K zip) |
|
Quake 1 [Added: 2/22/2002]
|
John Carmack
|
The original Quake. (3.06MB zip) |
|
Quake 2 [Added: 2/22/2002]
|
John Carmack
|
Yes, this is the actual source code. (1.41 MB zip) |
|
Wolfenstein 3D [Added: 2/22/2002]
|
John Carmack
|
The timeless 3D FPS, Wolfenstein 3D, from id. (564K zip) |
|
Zork [Added: 2/22/2002]
|
|
The text adventure game to end all text adventure games. (302K zip)
|
|