GameDev.net -- Programming

20 issues of porting C++ code on the 64-bit platform
[Added: 10/3/2007]

Andrey Karpov, Evgeniy Ryzhkov

The article observes some questions related to testing the 64-bit software. Some difficulties which a developer of resource-intensive 64- bit applications may face and the ways to overcome them are described

2D Car Physics
[Added: 12/15/2007]

Matt Kincaid

Tutorial on the math and implementation of car physics in a 2D environment

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.

A Hobbyist Game Engine Post Mortem
[Added: 10/8/2008]

Paul Coppens

Learn what went right and what went wrong along the path of developing the game engine ex-nihilo

A Postmortem of Game Programming with Digital Mars’ D Programming Language
[Added: 1/18/2008]

Jonathan Breuer

A detailed look at getting set up and started with D, as well as various highlights and pitfalls of the language

A Simple C++ Object Loader
[Added: 10/6/2009]

Francis Xavier

A guide to deserializing objects using Daabli. Demonstrates how easy it is to load objects, enumerations, pointers and STL containers using Daabli. Also discusses Daabli's flexible string conversion mechanism

A Simple Fast Resource Manager using C++ and STL
[Added: 4/24/2008]

Ashic Mahtab, Zinat Wali

This article describes an implementation of a resource manager in C++ using STL. It is simple yet efficient. Sample usage is shown to reflect the ease of use

A Verlet based approach for 2D game physics
[Added: 11/19/2009]

Benedikt Bitterli

Illustrates the power of Verlet integration for physics simulations and covers basic 2D rigid body dynamics with collision

Back to Basics: Stacks
[Added: 9/4/2007]

Steven Phung

A short and simple view of the stacks data structure for beginners looking to grasp the basic concepts

Cellular Textures, the light speed approach
[Added: 8/10/2009]

Carsten Przyluczky

Procedural texture generation is a very flexible and powerful technique, and the results are awesome looking textures that only require a few hundred bytes. Cellular textures is one such method. This article will describe how they are generated starting with a simple but slow algorithm. Then it will look over an advanced algorithm that takes linear time and provides some nice extra features

Clock Synchronization of Client Programs
[Added: 4/14/2008]

Pablo Marquez

Describes a straight-forward technique to synchronize client and server programs over the network in order to monitor latency and decrease the likelihood of player lag during gameplay

Common Misconceptions of Intel® Integrated Graphics
[Added: 12/17/2007]

Chuck DeSylva

Examines some of the common assumptions about integrated graphics (specifically the Intel X3000) and provides insights otherwise ignored by the trade press

Computation of Bounding Primitives on the GPU
[Added: 11/12/2008]

Philip Rideout

Nowadays it's becoming fashionable to use GPU's for purposes other than pure graphics. Learn a sneaky trick that leverages the GPU's horsepower to efficiently compute an axis-aligned bounding box. Includes sample code for DirectX 10, but this method can be used with other API's as well

Continuing GameMonkey Script: Advanced Use
[Added: 8/4/2009]

Oli Wilkinson

The long-awaited continuation of the Introduction to GameMonkey Script series, covering advanced aspects of the GM language, the virtual machine API, and threading

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.

Creating a GLSL Library
[Added: 10/29/2007]

Don Olmstead

covers creating a shader library and writing a texturing and a lighting shader as a next step after reading through the Orange Book

Cubic Shadow Mapping in Direct3D
[Added: 2/5/2008]

Ehsan Miandji

This tutorial will focus on implementing the cubic shadow mapping algorithm using Direct3D and HLSL and provides you with some optimization ideas.

Designing a Flexible Vertex Element System for XNA Using Attributes
[Added: 12/2/2008]

Michael Popoloski

This article outlines a safer and more flexible system for defining and creating vertex declarations in XNA, using several high-level C# features such as attributes and reflection to make the resulting solution elegant and concise.

Development of Resource-intensive Applications in Visual C++
[Added: 4/18/2008]

Andrey Karpov, Evgeniy Ryzhkov

The article will familiarize developers of application software with tasks set before them with the mass introduction of 64-bit multi-core processors. It will also touch upon the problems of effective use of hardware resources for solving everyday applied tasks within the limits of Windows x64 operating system.

Dynamic 3D Scene Graphs
[Added: 12/10/2008]

Andrew Top

Scene graphs used in most games today are actually scene trees, defined offline by artists. Interesting features can be achieved by instead defining offline a set of rules that explain how to generate a scene tree. By dynamically building the scene tree from a set of rules at run-time, we can support true scene graphs (scene graphs with cycles in them) as well as the ability to host environments with objects of drastically different scales (such as leaves, trees, solar systems and galaxies).

Excerpt from OpenGL® Programming Guide 6th Ed.
[Added: 4/4/2008]

Shreiner, Woo, Neider, and Davis

A complete chapter excerpt from the latest edition of the popular OpenGL Programming Guide

Excerpt from OpenGL® SuperBible: Comprehensive Tutorial and Reference, 4th Edition
[Added: 4/28/2008]

Wright, Lipchak and Haemel

Chapter 9: Texture Mapping: Beyond the Basics

Exploring Metaballs and Isosurfaces in 2D
[Added: 9/3/2008]

Stephen Whitmore

Ever wondered how the classic 'metaballs' effect worked? This article covers an overview and explanation of metaballs, as well as a simple implementation, some examples, suggestions for optimizations, and a meta-playground demo

Exporting C++ functions to Lua
[Added: 5/5/2009]

Magnus Österlind

This article shows a way to achieve type safe interaction between C++ and Lua. By utilizing the Boost::FunctionTypes library, we’re able to automatically detect the number and types of the parameters in the exported function, making the procedure for registering a C++ function as simple as a single function call with a name and a function pointer

High Dynamic Range Environment Mapping On Mainstream Graphics Hardware
[Added: 3/21/2008]

Lake, Northrop, Freeman

This white paper discusses the use of High Dynamic Range Imagery rendering utilizing Reinhard’s tone mapping calculation and floating point textures on the Intel® 965 Express Chipset and Mobile Intel® 965 Express Chipset family.

Hosting a C++ D3D engine in C# Winforms
[Added: 6/17/2008]

Ryan Villamil

Describes a sequence of techniques for hosting an unmanaged C++ graphics engine in a C# Winforms or WPF application.

Image Space Lighting
[Added: 6/11/2009]

David Maletz

An explanation of the theory behind and implementation of image space lighting, a technique that utilizes deferred lighting and rasterization to efficiently and accurately render hundreds of light sources in real time. This technique allows for complex lighting environments found in scenes with lampposts, lanterns, cities at night, light-emitting particle effects and other scenes with many light sources.

Integrating Your XNA Engine With XSI ModTool
[Added: 8/11/2008]

MJP

Learn how to use XSI|ModTool's XNA integration features to create a content authoring pipeline for your engine

Intro to the Flex SDK
[Added: 6/20/2007]

Andy Fischer

Covers how to download and install the Flex SDK, and walks through all the steps (including writing source code) to create a simple game

Introduction to Debugging
[Added: 6/19/2006]

Richard "superpig" Fine

An extensive introduction of the debugging process including the tools used.

Introduction to GameMonkey Script Part 2
[Added: 3/11/2006]

Oli Wilkinson

This part covers embedding GameMonkey in your game or other application.

Java Games: Active Rendering
[Added: 9/27/2007]

Tim Wright

Covers a rendering technique that allows you to focus on developing a game and spend less time worrying about which paint method to override

Java Games: Keyboard and Mouse
[Added: 11/30/2007]

Tim Wright

Covers building a polling interface for detecting input states

KJam - a new build tool for game development
[Added: 10/5/2006]

Rafael Baptista

Introduction to an extremely fast build tool designed to support very large software projects

Learn to Tango with D Excerpt: Chapter 2
[Added: 6/5/2008]

Bell, Igesund, Kelly, Parker

What is D to C? Come learn about D's declarations, basic data types, pointers, arrays, looping and decision structures, functions and error handling

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++

Linux Game Development Part 1
[Added: 6/28/2007]

Troy Hepfner

Introduction to Linux and a high-level overview of Linux game development so you can get started

Linux Game Development Part 2
[Added: 7/17/2007]

Troy Hepfner

Learn how to create a binary executable that will run on almost any Linux distribution.

Linux Game Development Part 3
[Added: 8/11/2007]

Troy Hepfner

Learn about the different install builders that are available for Linux, and how to create an easy-to-use installer that will run on any Linux distribution

Linux Game Development Part 4
[Added: 9/11/2007]

Troy Hepfner

Learn about testing your game on Linux, and some of the issues involved

Linux Game Development Part 5
[Added: 10/15/2007]

Troy Hepfner

Discover some tips for how to market your Linux game

Microsoft XNA Game Studio 3.0 Unleashed
[Added: 5/29/2009]

Chad Carter

Chapter 22: Creating a 3D Game

Moving Noise
[Added: 5/27/2009]

Dan Nielsen

This feature introduces a drop-in Perlin noise variant useful for quickly generating organic procedural functions that change over time. You can use it to create scenes, textures, animations, and sounds. If you modify it or do something interesting with it, the author would love to know

Nature in computer graphics
[Added: 9/7/2007]

Shaun Kichenbrand

A research paper outlining various graphical techniques and advancements in rendering natural objects

Nintendo Wii Flash Game Creator's Guide: Chapter 5
[Added: 6/26/2008]

Todd Perkins

Demonstrates using the Wii remote to make a game where you use a hammer to pound down a nail, with realistic motion

OpenGL Frame Buffer Object 101
[Added: 11/22/2006]

Rob 'phantom' Jones

An introduction to the Frame Buffer Object extension to OpenGL

OpenGL Frame Buffer Object 201
[Added: 12/14/2006]

Rob “phantom” Jones

Shows how you can use a single FBO to cycle through a number of textures to render to as well as using the OpenGL Shading Language to render to multiple textures at the same time via the Draw Buffers extension

Pathfinding With the C4 Game Engine
[Added: 10/10/2007]

Jon Watte

Discusses and includes code for a complete art path for authoring navigation meshes (networks) and doing A-star pathfinding throughout levels.

Programming Vertex, Geometry, and Pixel Shaders
[Added: 1/8/2009]

Wolfgang Engel, Jack Hoxley, Ralf Kornmann, Niko Suni, Jason Zink

This book, published for free to the GDWiki, covers DirectX 10 techniques and is intended for DX 8 & 9 users to upgrade their knowledge. The authors are open to comments and suggestions as the prep the DirectX 11 print-only version

Rendering Water as a Post-process Effect
[Added: 6/4/2009]

Wojciech Toman

This article presents a screen-space approach to water rendering. The technique makes water look realistic by focusing on aspects rarely taken into account like colour extinction. It is based on observation rather than on mathematical model.

Shaders and Metaprogramming
[Added: 7/3/2007]

Promit Roy

Discusses how to robustly expose shader constant parameters from a .NET 2.0 application using the reflection and metaprogramming abilities of managed code

Shadow Map Aliasing
[Added: 7/12/2007]

Dave Bookout

Discusses techniques to reduce the aliasing problem associated with using shadow maps

Shaving Ping
[Added: 5/11/2006]

Doug Helbling

Discusses optimization techniques for getting the most out of your game server.

The C++ Standard Library Part 1
[Added: 5/18/2006]

Howard "SiCrane" Jeng

The first installment in this series covers language features related to the standard library that may be unfamiliar to new programmers.

The C++ Standard Library Part 2
[Added: 9/13/2006]

Howard "SiCrane" Jeng

Introduces the basics of the std::vector class.

The Future of PC Gaming – The Possibilities of Direct3D 10
[Added: 4/28/2006]

Oluseyi

We sat down with ATI to discuss what Direct3D 10 and the next generation of hardware will offer for game developers.

The Visual C++ Exception Model
[Added: 3/27/2008]

Howard Jeng

A brief introduction to SEH, a high level overview of how MSVC implements C++ exceptions on top of SEH, some implications of this implementation and some ways to exploit the internals of the exception handling model.

Visual Studio Macros for the Game Programmer
[Added: 11/12/2007]

Mike Cline

A look into VS macros, with some examples of useful macros

Walls and Shadows in 2D
[Added: 11/10/2009]

Scott Mayo

This article presents a technique for determining visibility information suitable for arbitrary closed two-dimensional maps at interactive rates (each pass of the algorithm will usually take less than a second); as such it can be most useful in turn-based games, or games where extremely fast visibility recalculation is not required. The technique can also be used to handle illumination and shadow computations for point-based lights

Welzl's Minimum Sphere Algorithm Demystified
[Added: 3/19/2008]

Eli Kara

Explores a solution proposed by Emo Welzl regarding calculating the optimal sphere for use in bounding volumes

White Paper: Procedural Terrain Generation With Fractional Brownian Motion
[Added: 1/21/2008]

Jeffrey M. Freeman

This white paper investigates techniques for leveraging procedurally generated terrain with fractional Brownian Motion on the CPU and multi-texture blending on the GPU.