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 Collection of Examples of 64-bit Errors in Real Programs
[Added: 8/4/2010]

Andrey Karpov

This article is the most complete collection of examples of 64-bit errors in the C and C++ languages. The article is intended for Windows-application developers who use Visual C++, however, it will be useful for other programmers as well

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 and Practical Approach to SSAO
[Added: 5/25/2010]

José María Méndez

This article presents a simple but accurate screen space ambient occlusion implementation, including HLSL code

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 Super Simple Method for Creating Infinite Scenery
[Added: 9/15/2010]

Gabriel T. Delarosa

Outlines a method of creating simple infinite scenery in both the vertical and horizontal dimensions require no static geometry

A Type-safe Generic Pointer
[Added: 8/17/2010]

Francis Xavier

A safer alternative to void*, any_ptr can point to any type of object and provide type-safe, const-correct access to it

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

Cube Map Rendering Techniques for Direct3D10
[Added: 2/1/2010]

Vincent Prat

Unlike DirectX 9 which allows you to only render cube maps in 6 passes, DirectX 10 offers different ways to do it more efficiently: geometry shaders & improvements in the geometry instancing API offer single pass alternatives to cube map rendering. This article presents 3 algorithms as well as their drawbacks and advantages

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.

Deferred Rendering Demystified
[Added: 3/1/2010]

Noam Gat

Deferred Rendering is an alternative rendering approach that has many advantages. The theory behind it has been discussed to great detail, but implementing a deferred renderer is still a puzzling task. This article discusses the technique from a design standpoint, suggesting how a graphics engine can be structured to easily integrate a deferred rendering approach, and is accompanied by an open source implementation of one using the Ogre 3d engine.

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.

Developing iPhone Games for Longer Battery Life
[Added: 7/20/2010]

Ed Welch

The team for the iPhone turn-based strategy game Armageddon Wars explores a frame throttling technique to decrease hardware usage during gameplay and noticeably increase battery life

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

Learning iOS Game Programming
[Added: 10/20/2010]

Michael Daley

Excerpt from the book centered on the main game loop in an iOS game

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

Real-Time Dynamic Fur on the GPU
[Added: 10/14/2010]

Dzmitry Malyshau

Leveraging the GPU and particles to create real time dynamic fur

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.

Terrain System for Circuits
[Added: 1/12/2010]

Diego B.S.

This article presents a solution for games - mostly car racing titles - in which the characters - cars - move along a racetrack. The proposed terrain system manages the physical information of the track, building an internal data structure and applying an spline algorithm to get an smoothed continuous surface

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 Essential Guide to Flash Games: Chapter 2
[Added: 5/17/2010]

Jeff Fulton, Steve Fulton

This chapter takes you through the creation of an AS3 game framework and a simple test case

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 Game Maker's Companion
[Added: 12/10/2010]

Jacob Habgood, Nana Nielsen, Kevin Crossley, Martin Rijks

This book excerpt contains the first chapter of the book that introduces beginning game developers to the Game Maker program

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.

Using Abstraction to Optimize Runtime Polymorphism
[Added: 7/9/2010]

Gabriel T. Delarosa

We take a look at the cost of C++'s virtual function mechanism and how to improve the performance of runtime polymorphism without giving up it's many benefits

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.

Why AppUp? A Quick Review of the AppUp Model
[Added: 12/21/2010]

Intel

Intel introduces their solution for apps that extend beyond the realm of smart phones in this sponsored article