GameDev1001

Certification - I have started seeing some Value In It.

2011-07-05T19:16:00.000-07:00

As most professionals reach mid life career crisis , they resort to a new hobby. They collect certifications like ITIL,PMP,TOGAF,CISA etc. to name a few.

Most people use it to get their way into higher position.

These certifications are catalog of best practices in a domain. They cannot be understood fully , unless you have become a practitioner in all aspects of a domain. In the era of specialization , It hard for a single professional to master the nuances of best practices in a objective manner.

People go for certification to motivate themselves to study these "dogmas" and examination fee acts as a deterrent from choking away from the pursuit.

At the end of the day , the Individual will emerge home with some Ideas for sure. For me , that is the key take away.

To learn procedural skills , one needs to be lucky or go for certification. ( This is akin to teaching management at a B-school.)

GPU Programming

2011-07-05T10:57:00.000-07:00

The importance of writing small gpu programs has its highest need these days.
The following is the result of my battle with shader designer for my pet project Rubiks cube with minimum data in to the gpu.

//vertex program
//mapping of colors on to object based on the vertex normals

varying vec3 color;

void main()
{
if( abs(gl_Normal.x) > 0.5 )
{

if(sign(gl_Normal.x) == 1)
{
color.rgb = vec3(1.0, 0.55, 0.0); //orange;
}
else
{
color.rgb = vec3(0.0,0.9, 0.0); //green
}
}
else if( abs(gl_Normal.y) > 0.5 )
{
if(sign(gl_Normal.y) == 1)
{
color.rgb = vec3(1, 0, 0); //red
}
else
{
color.rgb = vec3(0, 0, 0.8);//blue;
}
}
else if( abs(gl_Normal.z) > 0.5 )
{
if(sign(gl_Normal.z) == 1)
{
color.rgb = vec3(1, 1, 1);//white
}
else
{
color.rgb = vec3(1, 1, 0);//yellow
}
}
gl_Position = ftransform();
}

//Fragment program
varying vec3 vcolor;

void main()
{
gl_FragColor = vec4( vcolor, 1);
}

//[todo:more text in this post]

Meshes

2011-06-23T13:40:00.000-07:00

3D Models are made up of vertices that can form drawing primitives.
Thus conceptually a mesh can be defined by a set of vertices and a set of indices.
Vertices have information for position, color, lighting etc.
And indices group those vertices into drawing primitives.

//A simple vertex
Vertex
{
position,
normal,
texture

};
VertexArray[] = {...} //What are the vertices that form the model
IndexArray[] = {...} //What is the order of the vertices that form the drawing primitive

Where
drawing primitive = {point, line, triangle, ... }

Now we can.

Strem the mesh data between graphics card memory and system memory.
Define local axes,angles, axial and object bounding volumes.
Connect the mesh with a scene graph system.
Connect the mesh with a phsics system.
Apply transforms on meshes to make simple animations;
Register a bone hierarchy suitable to the mesh with transforms and weights.
Chain a list of morph targets.
Chain a list of meshes with decreasing level of detail.
Add a list of vertex/fragment shaders.
Change the state of rendering/animation with game/graphics events.

and so on.

All of this start from how to render the vertices with less space and in minimum time.

Ref:
OpenGL : begin .. end paradigm, vertex arrays, VBO

For commercial file formats refer
3D File formats: Obj, 3DS, PVR, X

Camera

2009-05-24T00:40:00.000-07:00

The following is a common camera definition in games which helps to make view transform and projection transform.

Camera
{
//tripod and aim
ViewerPosition,
ViewerTarget,
ViewerTilt,
LocalAxesIJK,
RotationAnglesAroundLocalAxesPitchYawRoll,

//lens
aspectRatio,
nearPlane,
farPlane;
}

Animation

2009-05-24T00:38:00.000-07:00

Definition
Animation is realistically affecting any visual change in a scene with respect to time. The variables may include position, size, orientation, color, transparency or surface texture of the graphics object. "It is all about timing and positioning"
Frame Animation
Normally 30 to 60 frames of a 3D scene is to be rendered per second for a convincing animation. Although game engines usually expose a setFrameRate() interface for controlling frame rate, the efffective framerate depends on the scene complexity.
Character Animation
It deals with creating the moving pictures of the actors in the scene. In game development, it is done using two techniques: - Morph animation and Skelton animation.
In skeletal animation, a character is represented in two parts: a surface representation (skin) used to draw the character and a hierarchical set of bones used for animation only. By using skeletal animation one can control of every joint, bone, and muscle of the character's body to alter the shape of its skin.
Morphing is the transformation of one shape to another using some kind of interpolation. It is the kind of animation used for modeling character's expressions and lip synchronization.
Every type of animation requires key frames. Pre calculated key frames add the realism of character animation. 3D artists work with models using packages such as Maya or use motion capture for this purpose. Simulation of rigid body is not enough for certain situations. Descriptions of object behavior under the influence of force are generally referred to as physics based modeling. Some examples for these objects are cloths, ropes, soft bodies etc.

Collision Handling

2009-05-24T00:23:00.000-07:00

Collision handling is the next important thing after rendering.
Steps:
1. Detect whether two objects collide
This is achieved through standard and AABB or OBB intersection test using computational geometry algorithms.
Space subdivision methods coupled with occlusion culling reduce the amount of checking.

2.Determine where the collision point.
Once the the collision is detected, the relative location of the collision point with respect the center of mass from each objects need to be taken into account.

3.Implementing the expected the result of the collision
Rigid bodies collide and respond to collisions obeying the laws of Newton.

Curves and Surfaces

2009-05-24T00:20:00.001-07:00

Curves and curved surfaces describe most commonly the non-planar geometry with mathematical expressions rather than a mesh. These expressions can be converted to mesh representation on the fly. Thus, it saves some amount vertex memory. In addition, curved geometry provides scalable, smoother and continuous primitives than straight lines and planar polygons.

Reflection

2009-05-24T00:19:00.001-07:00

Planar reflection follows the law of reflection and works reasonably fast.
Ray tracing is the solution for high quality reflection mapping but it may not work at real time. Environment mapping is a fast technique that simulates highly reflective surfaces.

Transparency

2009-05-24T00:17:00.000-07:00

A transparent surfaces in general produce both reflected and refracted light.
It is assumed that for simple transmittance, the incoming light comes from directly beyond the transmitter. This is a reasonable assumption when the front and back surfaces of the transmitter are parallel and the thickness is not great, e.g., for a pane of glass. A transparent surface can be treated as a blend color. When blending, the transmitter's color is mixed with the incoming color from the objects seen through the transmitter. For other transparent media, the refractive index by Snell's law plays a role.

Shadows

2009-05-24T00:14:00.000-07:00

The keywords in shadowing process are light sources, shadow casters and shadow receivers. The light source can be a point source or area source. Calculating the shadow for point sources is easier compared that for area sources.
Point light sources generate only fully shadowed regions, while area light sources produce a fully shadowed region (umbra), and a partially shadowed region (penumbra).
Fully shadowed regions are called hard shadows and partially shadowed region are called soft shadows.
A basic technique for shadowing is projected planar shadows.

It is a simple technique. First, a three points are chosen so that the triangle formed by them defines the projection plane. The four plane coefficients are calculated from the three points that define the projection plane. Light position vector and these coefficients are used to pack a matrix called shadow matrix. This matrix squishes the 3D object on to the plane. To render the shadow, this matrix is applied to the objects that should cast shadow and the objects are rendered in dark color with no lighting. In this scheme, the three-dimensional object is rendered in two passes to create a shadow. In the first pass, the scene is rendered normally with lighting and depth test switched on. Then in the second pass, the depth test is disabled to deal with the z fighting between the shadow and the projection plane. While depth testing is disabled, the things that render last lie on top. The shadow receiver is already drawn in the pass. To cast the shadow, the shadow matrix is applied as described early.

Some other techniques are:
Projected Shadows
Shadow Mapping
Vertex Projection
Shadow Volumes

Textures

2009-05-24T00:13:00.001-07:00

Generally, textures are 1D, 2D or 3D arrays of pixels applied to a 3D object’s surface.
Texture coordinates are in texture space. When a texture is applied to a polygon, its texel addresses must be mapped into object space. They must then be translated into the screen space. 3D Renderer performs this as an inverse mapping. That is, for each pixel in screen space, the corresponding texel position in texture space is calculated. The texture color at or around that point is sampled. The applications should specify texture coordinates for each vertex. These values are called (u,v) and must be in the range of 0.0 to 1.0.
For every pixel in the primitive's on-screen image, it must obtain a color value from the texture. This is called texture filtering. When a texture filter operation is performed, the texture being used is typically also being magnified or minified. In other words, the texture is being mapped into a primitive image that is larger or smaller than it is. Think of filtering as a type of interpolation. Five schemes are listed below.
Nearest-Point Sampling
Linear Filtering
Bilinear Filtering
Anisotropic Filtering
MipMapping
Textures are used mainly for mapping patterns, for adding roughness to a surface and for simulating shadows and lighting.

Colors

2009-05-24T00:10:00.000-07:00

A large percentage of the visible spectrum can be represented by mixing red, green, and blue colored light in various proportions and intensities. RGB Color model is used in OpenGL and DirectX. A color value is an (Red, Green, Blue) triplet. The values can range from 0.0 (none) to 1.0 (full intensity). An intuitive color model is HSB. Hue is the color reflected from or transmitted through an object. Saturation is the strength or purity of the color. Saturation represents the amount of gray in proportion to the hue, measured as a percentage from 0% (gray) to 100% (fully saturated). Brightness is the relative lightness or darkness of the color, usually measured as a percentage from 0% (black) to 100% (white).

Shading

2009-05-24T00:08:00.000-07:00

Shading is the process of applying a shading model to obtain pixel intensities or colors that we see for all rendered vertices and surfaces in a scene. It takes input from lights, materials and vertex positions.

A shading model describes how to calculate the intensity of light that we should see at a given point on the surface of an object.

Shading models are of two types: - Accurate models such as radiosity methods and empirical models based on simple photometric calculations.

A basic shading model

The illumination is calculated as a sum of the ambient, diffuse, specular and emissive light per vertex.

Illumination = Ambient Light + Diffuse Light + Specular Light + Emissive Light

Major shading models :
Flat shading
Goraud shading
FastPhong shading

GPUs allow the programmers to customize the rendering portion of the pipeline using shader programmers or scripts.

More on shaders from knol:

http://knol.google.com/k/koen-samyn/hlsl-shaders/2lijysgth48w1/2#

Materials

2009-05-24T00:05:00.000-07:00

A surface can interact with light in many ways; it absorbs, reflects, transmits, refracts or emits light. Dull objects absorb more of the incident light and shiny objects reflect more of the incident light. The scattering of the reflected light by rough surfaces is called diffuse reflection. In addition to diffuse reflection, shiny objects create bright spots when illuminated. This type of reflection is called specular reflection. The polygon surfaces in a 3D model should be associated with materials for calculating how the surfaces and lights interact. The ratio between incoming light intensity and outgoing light intensity is measured as surface reflectance; it is different for different colors, so it is represented as an RGB vector or color, commonly called the surface color. A material (In DirectX or OpenGL) is surface’s reflectance properties for ambient, diffuse and specular lights. In addition, material contains the emissive lighting information of the surface and power of the specular highlight.

Lights

2009-05-24T00:01:00.000-07:00

The beauty of the game is greatly influenced by how the lights are used.

Basic Light Properties
Position, Range, Attenuation, Direction
Position of the light is represented as a position vector in the world space. Range is the maximum distance from the position at which the light’s intensity is non-zero. Attenuation controls how a light's intensity decreases toward the range. It is given as a set of three constants. The direction property represents the direction in which light rays travel. It is represented using a vector.

Light Color Components
The light emitted by a light source consists of Ambient, Diffuse and Specular components.
1. Ambient light
It provides constant lighting for a scene. It lights all object vertices the same because it is not dependent on any other lighting factors such as vertex normals, light direction, light position, range, or attenuation.
2. Diffuse Light
Diffuse light comes from one direction, so it is brighter if it comes squarely down on a surface than if it barely glances off the surface. Once it hits a surface, however, it is scattered equally in all directions, so it appears equally bright, no matter where the eye is located.
3. Specular Light
Specular light tends to reflect off the surface in a preferred direction causing a bright shine that can only be seen from some angles. A shiny metal or plastic has a high specular component, and chalk or carpet has almost none.
Emissive Light
Emissive Lighting is light that is emitted by an object, not by the light source. Emissive light lights all object vertices with the color defined in the material emissive property. It is not dependent on the vertex normal or the light direction.

Types of Sources
A light source may be of type point, directional or a spotlight.
1. Point Source
Point lights have color and position within a scene. They emit light equally in all directions. A light bulb is a good example of a point light. Point lights are affected by attenuation and range. Since point sources have no single direction, for calculating lighting at vertex, the light vector is calculated by subtracting the position vector of the vertex from the point source’s position vector.
2. Directional Source
Directional lights have only color and direction, not position. They emit parallel light. This means that all light generated by directional lights travels through a scene in the same direction. Imagine a directional light as a light source at near infinite distance, such as the sun. Directional lights are not affected by attenuation or range, so the direction and color are the only factors considered when the lighting calculation is done. Because of the small number of illumination factors, these are the least computationally intensive lights to use.
3. Spotlight
Spotlights emit a cone of light, which has two parts; a bright inner cone and an outer cone. Light is brightest in the inner cone and is not present outside the outer cone, with light intensity attenuating between the two areas. This type of attenuation is known as fall off. Spotlights are affected by falloff, attenuation, and range. These factors, as well as the distance light travels to each vertex, are figured in when computing lighting effects for objects in a scene.

Hidden Surface Removal /Occlusion Culling

2009-05-23T23:58:00.000-07:00

By displaying only visible surfaces or lines, geometry and fragments flow to video card can be reduced. Algorithms for HSR work in either image space or object space. Object space methods deal with comparing objects and parts of objects each other within the scene. Image space methods deal with deciding the visibility point by point, at each pixel position on the projection plane. Most HSR methods use coherence and depth sorting. Coherence methods are used to take advantage of the regularities in the scene. Z-Buffering method is built into the GPU or the software renderer. Some people refer to both object space HSR methods and occlusion culling as the same. The difference is that the former eliminate only a single polygon at a time where as the latter eliminate a bunch of objects hidden by groups of other objects. View frustum culling eliminates groups of polygons outside the view frustum. Back-Face culling eliminates polygons facing away from the camera. Depth buffering (e.g. Z-buffer) schemes store the depth value for each location in the frame buffer. When a new frame is rendered the old depth values are compared against the new one. This comparison succeeds if the new depth is lesser than the previous depth. Only those pixels that pass the depth test are copied to the frame buffer, the depth values are also updated.
Some object space HSR methods are:
Back-Face Culling
View-Frustum Culling
Occlusion Culling
Octree Method
BSP tree Method
Portals
Some image space HSR methods are:
Z-Buffer
A-Buffer
Scan line method
Area Subdivision Method

Transformations

2009-05-23T23:48:00.000-07:00

Modeling Transforms
Transformations are ways of moving points or vectors mathematically in space. The five types of modeling transformations in common use are translation, rotation, scaling, shearing and reflection.
Note: In Opengl when a series of transformation matrices are specified they are multiplied using the post matrix multiplication convention. ie. the transforms are concatenated in the order they are specified.

Viewing Transforms
Viewing transform is a translation and rotation matrix which helps in building views from cameras.

Projection Transforms
For games and related tools, our interest is limited to perspective projections and orthographic projections only. Perspective projection gives the illusion that objects and lengths appear smaller as their distance from the center of projection increases. Orthographic projection does not alter the shape or size of the objects. An artist uses multiple orthographic views to study his model. Orthographic projection matrix is an affine transformation matrix while that of Perspective projection is not.

Visual Realism in 3D Games

2009-02-23T07:19:00.000-08:00

Developers have been relying heavily on the following techniques for creating realistic static and moving images.

Transformations
Hidden Surface Removal
Lights
Materials
Shading
Colors
Textures
Shadows
Transparency
Reflection
Curves and Surfaces
Collision Detection
Animation
Realistic camera models
Advanced meshes
Image based rendering

A Typical Rendering Pipeline

2009-02-17T09:25:00.000-08:00

Three conceptual stages of the rendering pipeline are application, geometry and rasterization.

The Application Stage

The input at this stage is a scene description which is a set of meshes, materials, textures, lights etc. The lesser the number of polygons the lesser the burden on geometry stage. Occlusion culling, View Frustum Culling, Hidden Surface Removal, and LOD selection are the main techniques that helps the geometry stage from overloading. Culling means to select a portion of the geometry from the current scene for rendering. If an object is outside the viewing volume, the object is culled. Occlusion culling methods eliminate a bunch of objects hidden by groups of other objects. Tessellation, game objects movement, camera movement, AI and physics calculations are some other tasks done at this stage.

Geometry stage and rasterization stage is hardwired in modern GPUs;

The Geometry Stage

The triangles will contain vertices with information such as position, color, normals and texture coordinates. In addition to this a 3D scene may contain other information such as light sources and materials. The Geometry stage takes this input. At first note that in our game there will be a coordinate system. It is called world coordinate system. The 3D models that are to be used inside the game use another coordinate system chosen by the modeler or level designer. It is called modeling coordinate system or local coordinate system. Transformations like scaling, rotation, translation and skewing of the objects are easy to do at the model space. This is the first step at the geometry stage. The next task is to convert modeling coordinates into world coordinates. This is called the world transformation. Next the world space coordinates are to be translated and rotated around the camera's view. This is called the view transformation. The viewing coordinate axes can be calculated easily from three vectors: -eye, center and up. Orthographic or perspective transformation is applied next. For orthographic projections the viewing volume is a parallelepiped and for perspective projections the viewing volume is a frustum of a pyramid. The perspective projection gives the illusion of distant objects to look small and near objects to look big. Now a test is done on each triangle to determine if their vertices are completely outside the view volume. This test is trivial for most of the triangles in the scene but can result in re-tessellation of some of the triangles. Lighting calculation is to be done next. For that first step is back face culling for reducing the load. After that per vertex lighting calculation is done using the current shading model. Perspective division and clipping is performed next. This clipping can also result in re-tessellation of some of the triangles. The result is a 2D image residing on the projection window. Now it is to be mapped to the pc monitor as per the users’ requirements. This is the final transform called viewport transform. This result contains more than (x, y) values and send to the rasterization stage.

The Rasterization Stage

Once a model's vertices have been clipped and transformed into window space, the renderer must determine what pixels in the view-port are covered by each graphics primitive. The process of filling in the horizontal spans of pixels belonging to a primitive is called scan-conversion. The renderer calculates the depth, interpolated vertex colors and interpolated texture coordinates for each pixel. This information combined with the location of the pixel itself is called a fragment. A graphics application specifies how the fragment data is used to determine the final color and depth of each pixel during rasterization. This process is called pixel shading. After this the renderer performs a set of operations per fragment. This is called fragment operations. The main fragment operations are: - Pixel ownership test, Scissor test, Alpha test, Stencil test, Depth test Fog calculation, Antialiasing and Blending. The final output is a sent to the frame buffer for display.
Final Note: - We can replace some parts of the fixed pipeline discussed so far with custom programs. These programs execute on the GPU are called shaders. We can achieve huge amount of flexibility in the graphical effects by writing shaders.
Vertex shader and Geometry shader can replace the T&L portion, Pixel shader (fragment shader) can replace shading portion in the rasterization part of the pipeline. The geometry shader allows the GPU to create and destroy geometric primitives on the fly.

A Typical Rendering Pipeline by Manoj MJ is licensed under a Creative Commons Attribution-Share Alike 2.5 India License.
Based on a work at gamedev1001.blogspot.com.

CG and AG for undergraduate level (in India)

2009-02-17T09:02:00.003-08:00

Computer Graphics
-----------------------
Computer Graphics concerns the pictorial synthesis of real or imaginary objects from their computer based models. A typical course syllabus for an introductory level course in computer graphics is shown below. Needless to say for a game programmer this course is a must.

Introductory Computer Graphics Course
Graphics hardware:- Organization of a interactive graphics system, Random scan and Raster scan systems, Display processors, Display files, Graphical input and output devices.
2D Graphics: - Line drawing algorithms, Circle drawing algorithms, Bresenham's algorithms, 2D transformations, Line clipping, Polygon clipping, Window, View port.
3D Graphics: - 3D Transformations, Viewing and projection, Hidden surface removal, Realism in 3D graphics, Illumination and Shading, Shadows, Ray tracing, Rasterization, Clipping, Visibility, Curves and surfaces, Fractals, Animation techniques
Colors and Textures: - Color theory, Ant aliasing, Texture mapping and Procedural textures.
Graphics software: - Elements of graphics design - Picture representation and data structures, GUI, Graphics Packages- GKS, PHIGS, OpenGL
Books:-
Computer Graphics – Hearn and Baker
Computer Graphics – Harrington
Principles of Interactive Computer Graphics- Newman and Sproull
Procedural Elements of Computer Graphics - David Rogers
Computer Graphics, Principles and Practice - Foley, Van Dam, Feiner, Hughes
Computer Graphics Using Open GL - FS Hill

Computational Geometry
--------------------------------
Computational geometry a.k.a Algorithmic Geometry is the study of algorithms for geometrical problems. Many of these problems can be solved instantly by a person looking at a picture. (Example: is a point inside a polygon?) However, the computational solution of such problems is often non-trivial: it relies on the choice of appropriate data structures and on skillful implementation of linear algebra concepts. Acquiring good skills in algorithmic geometry will be a huge advantage to graphics and physics engine developers. A typical course syllabus for an introductory level course in computer graphics is shown below.
Computational Geometry
---------------------
Geometrical Preliminaries:- Double connected edge list, geometric duality, geometric searching, planar straight line graph(PSLG), point location problem, location of a point in a planar subdivision, plane sweep algorithm, slab method, chain method, regularization of PSLG, range searching problems.
Convex hulls: - convex hull algorithms in the plane, Graham's scan algorithm, Jarvi's march, divide and conquer algorithm, dynamic convex hull algorithm.

Triangularization: - Triangularization of a point set, triangularization algorithms, polygon Triangularization, Convexity Heyll's theorem, Delauny triangularization.
Voronoi Diagrams: - applications in the plane, post office problem.
Arrangement of Lines: - zone theorem, many faces in arrangements, construction of arrangements, forbidden graph theorem, bipartie graph for many face problems
Linear programming:- linear programming in two dimensions, Prune- eliminate redundant half planes, introduction to visibility problems, definition of direct visibility, point visibility and edge visibility, algorithm for computing point in side a polygon, visible region inside a polygon.
Books:-
Computational Geometry- An Introduction - Franco P. Preparata, Michael Lan Shamos
Algorithms in Combinatorial Geometry - Herbert Edelsbrunner
Art Gallery Theorem - Joseph O' Rourke
Computational Geometry in C - Rourke
Computational Geometry and Computer Graphics in C++ - Michael J. Lazio

Geometry Transforms in OpenGL

2008-06-05T04:33:00.000-07:00

//Geometry pipeline Pseudo code
Mat4x4 ModelViewXForm, ProjectionXForm;
Plane ViewVolume[6];
Vector4 vertex,projectedVertex,clipVertex ;

for_each vertex
{

screenSpaceVertex =
viewportXForm *
perpectiveDivide(
clip(
(ModelViewXForm * ProjectionXForm * vertex),
ViewVolume)
)
);
}

Note: For more information look at gluProject(...) and Vertex Shader programs

Reflection math

2007-04-07T23:34:00.000-07:00

Reflection
If we are given the direction vector of the incident ray and normal vector of the surface wherethe ray hits, how can we obtain the direction of the reflected ray.In this system the angle of incidence is equal to the angle of reflection.Let the incident ray vector be 'a' and reflected ray vector be 'r'.a is resolved into m and e horizontally and vertically. because of symmetry r is also resolved intothe same components.
From the figure e=a-m ; r = e- m; or r = a-2m
but m is the projection of a on n; ie, m = (a.n / n)*(unit vector n)
or m = [a.(unit vector n)]*unit vector n
putting this value of m in equation r = a-2m we will get the result.

Finding normal

2007-04-07T23:30:00.000-07:00

Finding the normal vector of a plane
A plane is defined by three points. Let P0, P1, and P2 be that three points.Calculate vectors, A = P1-P0 and B = P2-P0. Then A and B defines the plane.The cross product of A and B will be the normal vector of the plane.Thus N = A X B.

Projecting a vector

2007-04-07T23:26:00.000-07:00

Projection of a vector on to another vector
Suppose we want to project b on a. This is an another vector with the same direction as a. So we will just calculate the component of b along a and multiply it with unit vector of a to get the projection of b on a. The component of b along a is b cos(theta) where theta is the angle between a and b. we know that a.b = a.b.cos(theta).Then proj of b on a = (a.b/a)*(unit vector a)

Back face culling

2007-04-07T23:12:00.000-07:00

Back face culling
We know that dot product between two vertices is : zero when they are perpendicular to each other, greater than zero when angle between them is acute, and less than zero when angle between them is obtuse. This property is used for making a decision to whether render a triangle in a scene with respect to a camera. Only the triangles which are facing the camera needs to be drawn. Camera has a camera direction unit vector(look at vector ) and each triangle has a normal vector. If the dot product of these two vectors is less than zero, it means the camera is facing the triangle and the triangle passes the test.

The Inevitable Pipeline

2007-01-15T08:40:00.000-08:00

Here you will see the geometry pipeline of a game engine. With the help of data structures like BSP tree a part of the game geometry is selected to render and the selected part is passed to the geometry pipeline. The pipeline takes vertices as input. At first note that in our game there will be a coordinate system. It is called world coordinate system. The 3D models that are to be used inside the game use another coordinate system chosen by the modeler or level designer. It is called modeling coordinate system. The first task of the geometry pipeline is to convert modeling coordinates into world coordinates. This is the world transformation.
In this world coordinate system there is an additional coordinate system (sometimes more than one). This additional coordinate system belongs to the camera. The world space coordinates are relocated and rotated around the camera's view. This is the view transformation.
Now the next transformation gives us the illusion of distant objects appearing small and near objects look big. It is called projection transformation.
Now we need to remove any vertices that will not be visible. This process is called clipping. After clipping, the remaining vertices are scaled according to the viewport parameters and converted into screen coordinates. The screen coordinates are sent to the next stage of the pipeline for tasks such as shading and scan convertion.
Similar pipeline is implemented in graphics APIs such as OpenGL and Direct3D.

ICAT syllabus for PG Programme in game dev

2006-10-04T06:01:00.000-07:00

I got some really good stuff about game programmers should learn from www.icat.ac.in
HERE IS IT
=====================================================================
DIGITAL MEDIA TECHNOLOGIES
Introduction
=============
* Elements of Digital Media
* Principles of Digital Media
* Introduction to software used in the Digital Media industry
Design Concept
==========
* Principles of Design
* Introduction to colour theory
Digital Design
==============
* Introduction to Graphic Designing
* Colour systems (RGB, grey scale, CMYK) and file formats
* Creating and manipulating bitmap and vector images
* Creating Backgrounds/ Matte painting
* Scanning, storing and transporting images
* Enlargement and reduction, resolution, colour depth, image size and file size
* Palette, mode and image attributes
* Transformation of objects, reshaping and applying effects and filters
* Paths & Type
* Masking
* Layer Concept
* Understanding Colour & Colour Correction
* Filters & Texture
UI Design
=========
* Menu Design
* Colour Psychology
* Ergonomics
SCIENCE FOR GAMING
==================
Operating Systems
=================
* Introduction to O/S
* O/S Concepts and Structure
* Processes
* Memory Management
* File System
* Input/Output System
* Deadlocks
Data Structures
=================
* Abstract Data Types, Classes and Objects
* Analysis of Algorithm
* Foundational Data Structures
* Lists
* Stack
* Queues
* Tables
* Trees
* Graphs
Object Oriented Analysis & Design
==================================
* Introduction to OOAD
* Introduction to UML
* Case modelling and Case study
* OO Analysis
* Class design
* Behavioural modelling
* Software architecture design and modelling
* OO Design patterns
Software Engineering
====================
* Introduction to Software Engineering
* Variables
* Statements
* Code Improvements
* System Considerations
* Software Craftsmanship
* CVS
Mathematics
===========
* Set Theory and Functions, Polynomials
* Trigonometry, Vector Math
* Quaternion Algebra, Linear Transformation
* Analytical Geometry,
Physics
=======
* Newtonian Physics, Gravity and Friction , Acceleration and Velocity, Trajectories
* Kinematics and Motion control
* Collision Detection and Response

Programming
===========
* Pointers and Pointer Arithmetic
* Data Types and OOPS Principles
* Dynamic Memory
*STL and Name Spaces
* Classes and Class Design
* Templates
* WIN32 API
Graphics Fundamentals
=====================
* Concepts of Dimension
* 3D Pipeline
* Audio, Video and Picture Formats
* 3D File Formats
* Lighting and Materials
* Transformation and Lighting Pipeline
* Rendering Pipeline
* Hidden Surface removal, BSP trees, culling.
* Camera Management Systems
* Terrain And Height Maps
* Sorting Algorithms
Graphics API (Direct X)
========================
* Introduction and Pre-requisites for DirectX
* Vertex and Indexed Buffers
* Single and Multitexture Effects
* Compressed Textures
* Colour Blending
* Effect Framework
* Alpha Blending
* Billboards and particle Systems
* Decals
* Skeletal Animation
* Keyframe Animation
* Indexed / Non Indexed vertex Blending
* Shaders and HLSL
* Light Maps
* Bump, Environment Mapping
* Stencil Buffers
* Level of Detail (LOD)
Effects
=======
* Weapon Effects
* Dynamic Lighting,
* Shadow and Lens flare
* Rain, Snow, Fog, Smoke, Fire, Particles and Plasma
* Lighting and Thunder,
* 3D Sound
GAME DEVELOPMENT WITH ENGINE
===============================
Introduction
============
* Intro to Game Engines and Game Engine Architecture
* Game Engine Level Editor
* Scripting in the Engine
Level Designing
===============
* Tools and concepts used to create levels for games
* Level design and architecture theory
* Concepts of the “critical path” and “flow”
* Game balancing
* Play testing

GAME PROGRAMMING
=================
Artificial Intelligence
===============
* Basic Deterministic Rule
*Random Motion
* Tracking and Evasion Algorithm
*behavioural State Systems
*Basic Search Tree Systems
* Shortest Path Algorithm
* Basic Path Finding
Network Programming
===================
* Winsock
* TCP/IP, UDP
* Direct Play
* CRC, Dead Reckoning
* Multiplayer and Distributed Gaming
I/O Programming
===============
* Keyboard, Mouse, Joystick Interfacing
* Force Feedback
* Hardware Abstraction
Mobile Game Development
=======================
* Introduction to Mobile Gaming
J2ME Overview
* Creating MIDlet
*Configuring J2ME
* Limitations & Optimisation
* Intergraded Developer Environment
* High Level User Interface
* Low Level User Interface
* Audio
* Record Store
* 3D API
* Emulators
* Porting & Deployment
====================================================================

3D Maths Part III:Vector Algebra

2005-11-14T07:17:00.000-08:00

Vectors are of fundamental importance in any 3D game engine. They are used to represent points and directions in space. They are used to represent spatial directions such as direction of light, orientation of camera, normal of a triangular mesh. Understanding how to manipulate vectors is an essential skill for a successful 3D programmer.

Affine Space

=========

Imagine our universe. Has it got any origin or axes? NO. But we can define Origin as the sun and define axes. Or we can take the Origin as center of the earth. In mathematics, an affine space is an abstract structure that generalises the affine-geometric properties of Euclidean space. In an affine space, one can subtract points to get vectors, or add a vector to a point to get another point, but one cannot add points, since there is no origin.Math gurus please visit wikipedia for more info.

Vector Algebra

===========

A vector is represented as a list of its components (V1, V2, V3,…, Vn) where n is the dimension of the vector. You can get more information about vectors from wikipedia.

Types of Vectors

Zero (Null) Vector: A vector whose magnitude is zero; magnitude is calculated as

root of(V1² + V2² V3² +…+V1²)

Unit Vector: A vector whose magnitude is unity.

Like Vectors: Vectors whose directions are the same

Unlike Vectors: Vectors whose directions are opposite

Negative of a vector: Vector which is opposite in direction but same in magnitude

Collinear Vectors: Vectors which are parallel and in the same line of action

Co-Initial Vector: A vector which is not altered by shifting it about parallel in space

Free Vector: If it is our liberty to choose origin for a vector then it is a free vector

Localized Vector: If we cannot choose the vector’s origin then it is a localized vector

Addition of two vectors

=================

(a,b) + (c,d) = (a+c,b+d)

Properties

=======

Commutative,

Associative,

Existence of additive identity

Existence of additive inverse

Substraction of two vectors

====================

(a,b) – (c,d)

take negative of (c,d) then add

(a,b)+(-(c,d))

(a,b)+(-c,-d) = (a-c, b-d)

Properties same as additive properties

Multiplication by scalar

=================

5*(a,b) = (5a,5b)

Properties

=======

Associative

Distributive

Existence of Identity

Dot Product

=========

(a,b) . (c,d) = (ac,bd)

AB.CD = mag(AB)*mag(CD)*cos(theta)

Where AB,CD are two vectors and theta the angle between them

Cross Product

==========

(a,b,c) X (d,e,f) = determinant( i,j,k,a,b,c,d,e,f)

where i,j,k are the unit vectors

AB.CD = mag(AB)*mag(CD)*sin(theta)*n

Where AB,CD are two vectors and theta the angle between them and n the normal vector perpendicular to both AB and CD

3D Maths Part II:Geometry: Some Basic Definitions

2005-10-16T10:24:00.002-07:00

Quote: "A journey of 1000 miles begins with a single step"

Point
====
A location in a plane or in space, having zero dimensions.

Lines
====
A line is made up of an infinite number of points. Points in the same line are called colinear. Between each point is another point. This continues on forever. Thus a line is a one-dimensional figure. That is, a line has length, but no width or height.
A line can be defined by two points A and B. its in infinite length, passing through the points and extending forever in both directions. A line segment between two points A and B, the line that contains them is the set of points consisting of the distinct points A and B, all of the points between them.But the line segment AB extends from to A to B only. A ray is semi infinite. It is specified by a point and direction through its end points. A ray that contains two points A and B is the set of points consisting of the distinct points A and B,all of the points between them, and all points for which B is between them and A.

Every line is either horizontal, vertical or oblique. Horizontal lines have a slope of zero. Vertical lines are said to have infinite slope. In space, vertical lines never meet, but it is possible for horizontal lines to meet. There are four different relationships that two lines can have.
Lines can be identical, intersecting, parallel, perpendicular, or skew. Identical lines are lines that coincide. Therefore, they are the same line. The second one is the most obvious. Intersecting lines are lines that share a point. Parallel lines are coplanar lines that never intersect. They always have a certain distance between them and always have the same direction. Perpendicular lines are lines that intersect in one point and form a 90 degree angle. Skew lines only happen in space. They are noncoplanar lines that never intersect. Unlike parallel lines, however, they don't always have a set distance between them, nor do they always have the same direction.

Planes
=====
Planes are two-dimensional. A plane has length and width, but no height, and extends infinitely on all sides.Planes are thought of as flat surfaces. A plane is made up of an infinite amount of lines. Some properties of planes:-
1)Any line joining two points on a plane lies wholly in that plane.
2)One and only one plane can be drawn through three non-collinear points
3)One and only one plane can be drawn to contain two concurrent lines.
4)One and only one plane can be drawn perpendicular to a given direction and at a given distance from the origin
5)One and only one plane can be drawn through a given point and perpendicular to a given direction.

Two-dimensional figures are called plane figures. e.g. rectangle, circle, pentagons etc.A closed plane figure made up of several line segments that are joined together is called a polygon.

Space
====
Space is the set of all points. It is made up of an infinite number of planes.
Figures in space are called solids or surfaces. eg. cube, sphere etc.
A three-dimensional solid that is bounded by plane polygons is called a polyhedron.

Locus
======
Locus of a moving point is the path traced by the point satisfying some geometrical
conditions.

Change of axes
=============
Translation: To alter the origin of coordinates without altering the direction of axes.
Rotation : To change the direction of axes of coordinates without changing the origin.

Conic Sections
=============
The curves obtained by slicing a cone with a plane that does not pass through the vertex are called conic sections

Parametric Representation
=======================
Suppose we have a point moving around in the (x, y) plane. At each time t the particle will be at some point whose coordinates we can write as (x(t), y(t)). i.e. the x and y coordinates of the point are given as functions of the parameter t. Many curves can be most conveniently expressed in the form x = x(t) y = y(t) where t is some parameter. t need not be time, though it often helps to think about it in that way. This is called a parametric representation of the curve. e.g. Parametric eqn of a circle x² +y² = r² is x = r cos(t), y = r sin( t)

3D Maths Part I: Vectors and Points

2005-09-25T00:38:00.000-07:00

"Real game programmers are not afraid of maths"

Introduction

All physical quantities are classified into two types viz,scalars and vectors. Scalars are the quantities having magnitude only and not related to any fixed direction. Vectors are the quanties having magnitude and direction.e.g. mass, volume, distance, temperature,time speed and density are scalarswhere as displacement,velocity, force, acceleration and momentum are vectors.In a graphics system vectors and points are used to express geometrical ideas
algebraically. Vector algebra is the main tool for problem solving in CG.

3D Cartesian coordinate system

All points and vectors work relative to some coordinate system. 3D cartesian coordinate system is the most used one. Let O(Origin) be any point in space and X'OX , Y'OY and Z'OZ be any three mutually perpendicular lines.These lines are called axes. Distances are marked along each axes. Let OX,OY and OZ be marked from zero to (+)ve infinity, and OX',OY' and OZ' be marked from zero to (-)ve infinity.This system can take the form a right handed or left handed system.To form a right handed system take the plane formed by axes X'OX and Y'OY.Then grasp your right hand around the Z-axis(Z'OZ )by sweeping from positive X-axis(OX) around to the positive y-axis(OY). Note the direction to which your thumb points. This is the direction of your positive Z-axis(OZ). To form a left handed system do the same thing with your left hand and your direction of your thumb will give you the direction of your positive Z-axis.Note that OpenGL uses right handed system, where as DirectX uses left handed system.

Points Vs Vectors

Points specify a location in space (or in the plane). A point is a position specified with coordinate values in some reference frame, so thatdistance from the origin depends on the choice of the reference frame.In the 3D cartesian coordinate system a point is represented in the form (x,y,z); where x is the distance of the point along X axis from origin, y is the distance of the point along Y axis from origin,z is the distance of the point along Z axis from origin.

With respect to CG think of a vector as a displacement from one point to another.A vector is often geometrically represented as a directed line segment. Because vector is a displacement it has a size and direction but no inherent location.If v is the vector from point A to point B then we can say that point B is formed by displacing point A to B. ie, A+v=B or v=B-A. Thus the difference between two points is a vector.

The following are the operations with points and vectors

point - point = vector

point + vector = point

point - vector = point

vector +vector = vector

vector - vector = vector

point + point: NOT DEFINED!

NB:The fundamental difference between a point and a vector is that points have location but no direction whereas vectors have direction but no location.

Advice to young programmers

2005-08-12T08:56:00.000-07:00

This is the summary of speech Given by Alex Stepenov (The man behind STL ; Principal Scientist, Adobe Systems) at Adobe India on 30 Nov 2004. It's really a great speech. I think every programmer should read it.

1. Study , Study and Study

- Never ever think that you have acquired all or most of the knowledge which exists in the world. Almost everybody in US at age of 14 and everybody in India at age of 24 starts thinking that he has acquired all the wisdom and knowledge that he needs. This should be strictly avoided.
- You should be habituated to studies...exactly in the same way as you are habituated to brushing teeth and taking bath every morning. The habit of study must become a ‘part of your blood’. And the study should be from both the areas: CS, since it is your profession, and something from non-CS...Something which doesnot relate to your work. This would expand your knowledge in other field too. A regular study, everyday, is extremely essential. It doesnot matter whether you study of 20 minutes of 2 hours, but consistency is a must.
- You should always study basics and fundamentals. There is no point in going for advanced topics. When I was at the age of 24, I wanted to do PhD in program verification, though I was not able to understand anything from that. The basic reason was that my fundamental concepts were not clear. Studying ‘Algebraic Geometry’ is useless if you donot understand basics in Algebra and Geometry. Also, you should always go back and re-read and re-iterate over the fundamental concepts. What is the exact definition of ‘fundamental’? The stuff which is around for a while and which forms basic part of the concepts can be regarded as more fundamental. Of course, everybody understands what a fundamental means.
- Here are few books which I would strongly recommend that every CS professional should read and understand.
i. “Structure and Interpretation of Computer Programs” by Albenson and Sussman I personally donot like the material present in this book and I do have some objections about it but this is the best book I have ever seen which explains all the concepts in programming in a clear and excellent way. This book is available online at http://mitpress.mit.edu/sicp/
ii. Introduction to Computer Architecture: by Hennessy and Patterson. How many of you have shipped the programs by writing them in assembly? A very good understanding of basics of how a computer operates is what every CS professional must have. H&P Wrote two books on CA. I am talking about their first book, the introductory text for understanding basic aspects of how a computer works. Even if you feel that you know whatever is written in that book, donot stop reading. It’s good to revise basics again and again. iii. “Fundamentals of Programming” by Donald Knuth. The core of CS is algorithms and Data structures. Every CS professional must have the 3 volumes of Knuth’s Book on programming. It really doesnot matter if you take 30 years of your life to understand what Knuth has written, what is more important is that you read atleast some part of that book everyday without fail. iv. Introduction to Algorithms by Cormen, Leiserson and Rivest This book should be read daily to keep your concepts fresh. This is the best book for fundamental concepts in algorithms.

2. Learn Professional Ethics

- As a CS Professional, you are morally obliged to do a good job. What this means is that you are supposed to do your job not for your manager but for yourself. This is already told in Bhagwatgeeta : Doing duties of your life.
- The direct implication of this is: never ever write a bad code. You don’t need to be fastest and run after shipping dates; rather you need to write quality code. Never write junk code. Rewrite it till it is good. Thoroughly test every piece of code that you write. Donot write codes which are “sort of allright”. You might not achieve perfection, but atleast your code should be of good quality.
- Let me quote my own example in this context. You might have heard about STL, The Standard Template Library that ships in with C++ compilers. I wrote it 10 years ago, in 1994. While implementing one of the routines in the STL, namely the “search routine”, I was a bit lazy and instead of writing a good linear order implementation of KMP which was
difficult to code, I wrote a best quadratic implementation. I knew that I could make the search faster by writing a linear-order implementation, but I was lazy and I did not do that. And, after 10 years of my writing STL, exactly the same implementation is still used inside STL and STL ships with an inefficient quadratic implementation of search routine even today!! You might ask me: why can’t you rewrite that? Well...I cannot, because that code is no more my property!! Further, nobody today will be interested in a standalone efficient STL ...people would prefer one which automatically ships out with the compiler itself.
- Moral is, you should have aesthetic beauty built inside you. You should “feel” uneasy on writing bad code and should be eager to rewrite the code till it becomes upto the quality. And to the judge the quality, you need to develop sense regarding which algorithms to use under what circumstances.

3. Figure out your Goals

- Always aspire doing bigger things in life
- “Viewing promotion path as your career” is a completely wrong goal. If you are really interested in studying and learning new things, never ever aspire for being a manager. Managers cannot learn and study...they have no time. “Company ladder aspiration” is not what should be important for you.
- You might feel that you want to do certain things which you cannot do till you become a manager. When you become a manager, you will soon realize that now you just cannot do anything!
- You will have a great experience as programmers. But if you care for people and love people, you will never enjoy being a manager...most good managers are reluctant managers. If you see people as people, you cannot survive at management level.
- Always aspire for professional greatness. Our profession is very beautiful because we create abstract models and implement them in reality. There is a big fun in doing that. We have a profession which allows us to do creative things and even gives nice salary for that.
- The three biggest mistakes that people usually make are aiming for money, aiming for promotion and aiming for fame. The moment you get some of these, you aspire for some more...and then there is no end. I donot mean that you shouldnot earn money, but you should understand how much
money would satisfy your needs. Bill Clinton might be the richest person in the world; he is certainly not the happiest. Our lives are far better than his.
- Find your goal, and do best in the job that you have. Understand that what is in your pocket doesnot matter...what is in your brain finally matters. Money and fame donot matter. Knowledge matters.

4. Follow your culture

I have seen the tradition that whatever junk is created in
US, it rapidly spreads up in the rest of the world, and India is not an exception for this. This cultural change creates a very strong impact on everybody’s life. Habits of watching spicy Bollywood or Hollywood movies and listening to pop songs and all such stupid stuff gets very easily cultivated in people of your age...but believe me, there is nothing great in that. This all just makes you run away from your culture. And there is no wisdom in running away from your culture. Indian culture, which has great Vedas and stories like Mahabharata and Bhagwatgeeta is really great and even Donald Knuth enjoys reading that. You should understand that fundamental things in Indian culture teach you a lot and you should never forget them. Finally, I would like to conclude by saying that it’s your life...donot waste it on stupid things...develop your tests, and start the fight.

To: My dear noobie game programmer Part II

2005-07-31T08:29:00.000-07:00

Getting your hands dirty with 2D
In the near future, I will be writing on how to make PC games that work on windows platforms. I use VC++ and windows programming for this purpose.
The following was the roadmap for my journey to 2D game development.
Hope it would suit you too.

Study VC++, Platform SDK (Windows Programming)
Make games using GDI(Graphics library with in the Platform SDK)
Study DirectX( 2D,input and audio portion)
Make games using DirectX

If you are an avid fan of 3D games and want to go for 3D first, take care that you don’t get messed up with 3D fundas. I had to sit three weeks in front of my PC to get my first frame of my 3D app! By doing different types of 2D games you can master the concepts of manipulating and displaying animated and non-animated sprites, implementing game logic, physics, player input, music sound etc. That will definitely help you when you do 3D games. Therefore I suggest you to go for 2D first. The three 2D APIs that have high demand are DirectX, Flash and J2ME (for mobile platforms).

I would recommend to any budding game programmer to do the clones of following games before entering the world of 3D game programming or starting commercial development of 2D games. The list may be incomplete.
1. Space Invaders
2. Pong
3. Pac-Man
4. Battle City / Tank
5. Snake
6. Jigsaw puzzle
7. Tic-Tac-Toe
8. Reversi
9. Car Race
10. Super Mario
Before start making these games organise all reusable functions in a class library as your engine wrapper. Also get a level editing tool like Mappy or Tile Studio.

BOOKS
PLs:-
The C Programming Language - B.Kernighan & D.Ritchie
The C++ Programming Language - Bjarne Stroustrup
Java, The Complete Reference - Herbert SchildtJ2ME,
Visual C++, The complete Reference – Pappas and Murray
Programming Windows – Charles Petzold
Programming Windows with MFC - Jeff Prosise

Essential Theory, Graphics and Maths:-
Computer Graphics, Principles and Practice - Foley, vanDam, Feiner, Hughes
A Trip Down the Graphics Pipeline- Jim Blinn
Principles of Interactive Computer Graphics- Newman & Sproull
Computer Graphics – Hearn and Baker
3D Computer Graphics - Alan Watt
Computer Graphics Using Open GL - Francis S. Hill, Jr.
Geometric Tools for Computer Graphics - Philip J.Schneider & David H.Eberly
Mathematics for 3D Game Programming and Computer Graphics -Eric Lengyel

More Essential Theory:-
Mechanics-
Programming Languages Design and Implementaion- Pratt & Zelkowitz
Modern Operating Systems - A.S.Tanenbaum
Datastructures-
Algorithms Analysis and Design-
Compilers Theory,Practice and Tools - Aho, Ulman, Sethi
Computer Organization and Architecture-
Artificial Intelligence -
Computer Networks – A.S.Tanenbaum

Rendering APIs:-
OpenGL Superbible - Richard S Wright & Michael Sweet
OpenGL Red Book - OpenGL ARB
DirectX7 in 24 hours -Robert Dunlop, et alBeginning DirectX9 - Wendy Jones

Engine Design and Programming:
3D Game Engine Programming- Stefan Zerbst & Oliver Duvel

Game Programming:
J2ME Game Programming - Martin J Wells
Teach yourself game programming in 24 hours – Michael Morrison
Windows Game Programming for Dummies – Andre Lamothe
Game Progamming All in One -Bruno Miguel Teixeira de Sousa
Game Coding Complete - Mike McShaffry

Beyond Graphics:
Physics for Game Developers - David M.Bourg
AI for Game Developers - David M. Bourg, Glenn Seeman
Programming Multiplayer Games - Andrew Mulholland & Teijo Hakala
URLS
http://www.gamedev.net/
http://www.gpwiki.org/
http://www.gameprogrammer.com/
http://www.gametutorials.com/
http://www.gamedeveloper.net/
http://www.gamespp.com/
http://www.gamasutra.com/
http://www.gdmag.com/
http://www.gdse.com/
http://www.flipcode.com/
http://www.msdn.com/
http://www.gameai.com/
http://www.aiguru.com/
http://www.ai-depot.com/
http://www.generation5.org/
http://www.aihorizon.com/
www.aaai.org
IRC
#gamedev@AfterNET.org

To: My dear noobie game programmer Part I

2005-06-30T21:07:00.000-07:00

Programming games is not as easy like playing them. You have to make a plan and stick to it for accomplishing that, or you might lose your interest soon because of the steep learning curve and constant failures. What I am going to discuss here today is what are the steps that can lead you to the hall of good game programmers.
First things first. You must have skills in mathematics and programming. The three main programming languages used for programming PC and console games are C, C++ and Java. It will be helpful to know the working of a PC or Console from chip level to application level.
Quote: "You can see that knowing how something works may not be necessary for operating a mechanism but is useful for operating it efficiently. And as you may know, game programming is all about using things efficiently and taking them to the limit.”

Here are some of the prerequisites for a typical company’s game programmer post.
Is it too heavy? Don't even think about that word, coz you are a game programmer :)

BASICS
C, C++, Java, Assembly Language
VC++, STL, MFC, GDI, Platform SDK,
Data structures and Computer Algorithms
Compilers architecture
Operating systems architecture
Computer networks architecture
Graphics-API (DirectX, OpenGL)

MATHS
Algebra
Geometry
Coordinate Systems
Trigonometry
Number Systems
Complex Numbers
Vectors
Matrices and Quaternion
Numerical Methods and Interpolation

PHYSICS
Every bit of Newtonian physics.

GRAPHICS
Hardware Knowledge (Devices, VGA, GPU etc)
Basic graphics concepts of 2D and 3D
Color Models, image-formats, image-processing routines
Object representations
Transformations, clipping, viewing
Illumination
Hidden surface Elimination
Animations
Game engine Architecture
Standard graphics algorithms

ARTIFICIAL INTELLIGENCE
Bot movement AI (Deterministic and Non Deterministic)
Path finding
Scripting
Finite state machines
Fuzzy Logic, Neural Networks and Genetic Algorithms
Rule Based AI
Probability, Bayesian Techniques
Dynamic Programming, Game Search Trees

NETWORKS
Thorough knowledge and skills in tcp/ip and udp
Knowledge of protocols and working of computer networks
Knowledge of authentic hacking
Knowledge and experience in client-server applications development.
Knowledge of website development and scripting languages

You might have started swearing I guess! You can reach these goals, if you move according to a plan. I just put it to show the steps that you have to reach.

Intro

2005-05-11T23:10:00.000-07:00

If you consider gamedev as a passion or as a profession, then this blog is for you. I would like to share my experience with this black art.