Upcoming Events
Unite 2010
11/10 - 11/12 @ Montréal, Canada

GDC China
12/5 - 12/7 @ Shanghai, China

Asia Game Show 2010
12/24 - 12/27  

GDC 2011
2/28 - 3/4 @ San Francisco, CA

More events...
Quick Stats
142 people currently visiting GDNet.
2406 articles in the reference section.

Help us fight cancer!
Join SETI Team GDNet!
Link to us Events 4 Gamers
Home » Articles & Resources » Programming » Game Programming
Intel sponsors gamedev.net search:
Game Programming

Here you will find game programming tutorials not specifically covered in other areas.

For more information about Game Programming, check out:

Resources Listed: 171
Landscapes and TerrainOptimization
Collision DetectionSimple DirectMedia Layer
Code on the CobSource Code
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
2D Rotated Rectangle Collision
[Added: 2/3/2009]
Eric Meythaler  An explanation of the Separating Axis Theorem and how it can be used to perform 2D collision detection between rotated rectangles. 
Advanced Collision Detection Techniques
[Added: 4/11/2000]
Nick Bobic  Assumes you already know some 3D collision detection basics and gets into advanced topics. 
Basic Collision Detection and Response
[Added: 9/17/2007]
Metanet Software  A detailed explanation of the maths and techniques behind collision detection in games 
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. 
Continuous Collision Detection for translating Ellipsoid
[Added: 10/25/2007]
Chandan Pawaskar  We know sphere sweep test can provide accurate collision detection for fast moving objects. However a sphere is a loose fit in most practical cases. This article provides information for sweep testing Ellipsoids. 
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. 
Grid-Based Collision Detection and Raycasting
[Added: 9/17/2007]
Metanet Software  Describes "broad-phase" collision detection, using a grid of cells to narrow the area of detection for an object 
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. 
[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. 
Direct3D 9.0 with Allegro
[Added: 1/25/2006]
Homer Cuevas  Tutorial and demo code for using Direct3D and Allegro together. 
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. 
Leveraging Inheritance and Template Classes for Asset Tracking
[Added: 11/5/2007]
Christopher Harvey  Presents a method for tracking assets that should only be loaded once during the lifetime of an application using templates and abstraction in C++ 
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 Game Loop
[Added: 5/1/2008]
Koen Witters  Discusses various game loop implementations. 
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. 
The Simplest Game Possible
[Added: 7/26/2007]
Ben Skubi  A short and concise look at creating a Guess the Number game in C++ for anyone wondering how to architect a simple game 
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
DevHub - Side Tutorial - SDL Image
[Added: 3/17/2008]
Tim Jones  This side tutorial demonstrates how to stop using bitmap files within SDL. We'll see how to load and link SDL_image and integrate that into our existing surface class. 
DevHub - Side Tutorial - SDL SoundBank
[Added: 4/16/2008]
Tim Jones  This side tutorial demonstrates how to create a soundbank of sounds to play in your games. It will help you manage your sound resources with IDs for easy use. 
DevHub - Tutorial 1 - SDL Tutorial Basics
[Added: 3/17/2008]
Tim Jones  Provides a basic game framework for initialization of SDL as well as common routines. These routines are split into separate files, defining the main functions of a game, Initialization, Events, Loops (Data handling, Rendering, and Cleanup. It provides a bare bones framework to help newcomers understand code re-usability, as well as practicality with integrating with SDL. 
DevHub - Tutorial 2 - SDL Coordinates and Blitting
[Added: 3/17/2008]
Tim Jones  This tutorial builds upon the previous one, demonstrating the basics of bliting (drawing) graphics to screen and loading files. You'll learn how to draw surfaces to screen while managing surface resources correctly. 
DevHub - Tutorial 3 - SDL Events
[Added: 3/17/2008]
Tim Jones  This tutorial helps the user design a reusable event class structure wrapper around SDL. The class is easily integrated into various classes via inheritance, allowing events to be checked easily by overloading a function.  
DevHub - Tutorial 4 - SDL Tutorial Tic-Tac-Toe
[Added: 3/17/2008]
Tim Jones  Using the first three tutorials, we combine them all together in a practical framework. Using this framework, we learn some key concepts of combining events, and surfaces into making a basic Tic-Tac-Toe game. We'll take the concepts learned earlier and bring them all together. 
DevHub - Tutorial 5 - SDL Animation
[Added: 3/17/2008]
Tim Jones  Building upon the previous framework we will add a basic animation class. We'll see how to do frame animation that is timed based, as well as oscillating an animation. This class is then used along with a surface to provide on screen animation. 
DevHub - Tutorial 6 - SDL Entities
[Added: 3/17/2008]
Tim Jones  This tutorial demonstrates the basics of creating and managing entities (sprites). We'll manage all the entities in a practical manner using lists. This tutorial will build upon the animation tutorial, bringing the two together. 
DevHub - Tutorial 7 - SDL Maps
[Added: 3/17/2008]
Tim Jones  This tutorial shows how to load and render maps using external files. Maps are built from tiles, and these maps are put into areas. These areas will be clipped according to a camera view, allowing for faster performance.  
DevHub - Tutorial 8 - SDL Collision
[Added: 11/5/2008]
Tim Jones  This tutorial demonstrates how to check for collisions using entities against other entities, and a collisions against a map. It also shows you how to effectively move entities with time-based movements. 
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. 
SDL Collision Events
[Added: 9/3/2009]
Tim Jones  Using the previous tutorial as a basis, we'll look out how to respond appropriately to collisions and how to trigger events when collisions take place. 
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: 13618]
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: 9891]
A nice list of free or cheap tools for game development. 
YOV 408
[Added: 1/7/2004 Clicks: 5810]
Contains numerous articles and tutorials on game programming and other topics. 
Subcategory: Source Code
Topic Author Description
[Added: 2/22/2002]
  Source code to a MUD. (151K zip) 
[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) 
[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). 
[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) 
[Added: 2/22/2002]
  The text adventure game to end all text adventure games. (302K zip)  
 Key: = HTML article hosted here  , = HTML article hosted elsewhere  = link to another web site  = Adobe Acrobat document  = Zip files  = Word or text document