Randy Bennett's Portfolio


// FUNCTION HandleCollision() : Handles collisions between spheres
void HandleCollision(POINT_MASS pt_Masses[], Vector3D_d &separationDistance, double &changeInTime, int i, int j)
{
	// Create a unit length vector representing the angle of collision:
	Vector3D_d unitNormal = separationDistance;
	unitNormal.normalize();

	// Find the new velocities of both objects based off of their velocities prior to collision:
	double velocity_1 = pt_Masses[i].getLinearVelocity().dotProduct(unitNormal);
	double velocity_2 = pt_Masses[j].getLinearVelocity().dotProduct(unitNormal);

	// Calculate the average elasticity between the two spheres:
	double average_E = ( pt_Masses[i].getElasticity() + pt_Masses[j].getElasticity() ) / 2;

	// Use the equations for elastic collision response to calculate the final velocities:
	double finalVelocity_1 = ( ( ( pt_Masses[i].getMass() -
								( average_E * pt_Masses[j].getMass() ) ) * velocity_1 ) +
								( (1 + average_E) * pt_Masses[j].getMass() * velocity_2 ) ) /
								( pt_Masses[i].getMass() + pt_Masses[j].getMass() );
	double finalVelocity_2 = ( ( ( pt_Masses[j].getMass() -
								( average_E * pt_Masses[i].getMass() ) ) * velocity_2 ) +
								( (1 + average_E) * pt_Masses[i].getMass() * velocity_1 ) ) /
								( pt_Masses[i].getMass() + pt_Masses[j].getMass() );

	pt_Masses[i].setLinearVelocity( (finalVelocity_1 - velocity_1) * unitNormal + pt_Masses[i].getLinearVelocity() );
	pt_Masses[j].setLinearVelocity( (finalVelocity_2 - velocity_2) * unitNormal + pt_Masses[j].getLinearVelocity() );

	// If point masses are overlapping, back them up so that they are barely touching:
	double minDistance = pt_Masses[i].getBoundingSphereRadius() + pt_Masses[j].getBoundingSphereRadius();
	double overlapDistance = minDistance - separationDistance.getNorm();

	pt_Masses[i].setLocation( pt_Masses[i].getLocation() + ( 0.5 * unitNormal * overlapDistance) );
	pt_Masses[j].setLocation( pt_Masses[j].getLocation() + (-0.5 * unitNormal * overlapDistance) );
}

Exchange Simulator Tool

admin — Sun, 23 Aug 2009 17:54:59 +0000

Exchange Simulator is a tool I created to assist in the design process of a game I am working on. It was developed in C# using Windows Forms. Please open the links below to learn more.

Summary

Vertex Displacement and Normal Calculation in the Vertex Shader

admin — Mon, 04 May 2009 22:10:21 +0000

This Shader Demo performs run-time vertex displacement and normal calculation on a surface. The effect is programmed in HLSL, and the API code is in C# using the XNA Game Library. Please open the links below to learn more.

Summary

Vertex Displacement and Normal Calculation in the Vertex Shader
image-magnifier-demo-30.zip

View Code

// This is the HLSL effect which creates the displacement and calculates the new normals, tangents, and binormals.
// It then renders the scene using a directional light, specular highlights, a normal map, and a texture.

float4×4 World;
float4×4 View;
float4×4 Projection;

float Ambient;
float3 LightDirection;
float3 CameraPosition;
float SpecularPower;
float3 LightStrength;

float BulgeWidth; // width of the “bulge” displacement
float BulgeHeight; // height of the “bulge” displacement

Texture Image;
sampler ImageSampler = sampler_state { texture = < Image >;
magfilter = LINEAR; minfilter = LINEAR; mipfilter = LINEAR;
AddressU = wrap; AddressV = wrap; };

Texture NormalMap;
sampler NormalMapSampler = sampler_state { texture = < NormalMap >;
magfilter = LINEAR; minfilter = LINEAR; mipfilter = LINEAR;
AddressU = wrap; AddressV = wrap; };

struct VertexShaderInput
{
float4 Position : POSITION0;
float3 Normal : NORMAL0;
float2 TexCoord : TEXCOORD0;
};

struct VertexShaderOutput
{
float4 Position : POSITION0;
float2 TexCoord : TEXCOORD0;
float3 LightDirT : TEXCOORD1;
float3 EyeDirection : TEXCOORD2;
};

void calcSurfaceHeightNormTanBinorm(float x, float z, out float y, out float3 normal, out float3 tangent, out float3 biNormal)
{
// Use the “Witch of Agnesi” function [ y = (8a^3) / (x^2 + 4a^2) ] to determine the surface displacement
// However, use the distance from the vertex (x,z) to the origin (0,0) as the independent variable, instead of just using x.

float dist = sqrt(x*x + z*z) / BulgeWidth; // dist = distance from vertex to origin. Multiplying by BulgeWidth serves to widen the “bulge”
float bW_sqrd = pow(BulgeWidth, 2);
float h = BulgeHeight;

// Determine height by using the “Witch of Agnesi” function, but using dist as the independent variable
y = 8*(h*h*h) / (dist*dist + 4*h*h);

// Use partial derivatives of “Witch of Agnesi” Curve to caluculate normal
normal.x = (-16 * h*h*h * x/bW_sqrd) / pow(((x*x + z*z)/bW_sqrd + 4*h*h), 2);
normal.z = (-16 * h*h*h * z/bW_sqrd) / pow(((x*x + z*z)/bW_sqrd + 4*h*h), 2);
normal.y = 1.0f;
normal = normalize(normal);

// Use partial derivative dy/dx, holding z constant, to calculate tangent
tangent.x = 1.0f;
tangent.z = 0.0f;
tangent.y = (-16 * h*h*h * bW_sqrd*x) / pow( (bW_sqrd*(x*x + z*z) + 4*h*h), 2);
tangent = normalize(tangent);

// Use cross product of normal and tangent to calculate biNormal
biNormal = cross(normal, tangent);
}

VertexShaderOutput VertexShaderFunction(VertexShaderInput input)
{
VertexShaderOutput output = (VertexShaderOutput)0;

// Calculate the displaced height for this vertex as well as it’s new normal, tangent, and binormal
float3 normal, tangent, biNormal;
calcSurfaceHeightNormTanBinorm(input.Position.x, input.Position.z, input.Position.y, normal, tangent, biNormal); // (y, normal, tangent, and biNormal are out parameters)

float4 worldPosition = mul(input.Position, World);
float4 viewPosition = mul(worldPosition, View);
output.Position = mul(viewPosition, Projection);

// Use normal, tangent, and biNormal to create a tangentToObject matrix
float3×3 tangentToObject;
tangentToObject[0] = normalize(biNormal);
tangentToObject[1] = normalize(tangent);
tangentToObject[2] = normalize(normal);

float3×3 tangentToWorld = mul(tangentToObject, World); // Create a tangentToWorld matrix to be used for tangent-space lighting

output.LightDirT = mul(tangentToWorld, LightDirection); // Take LightDirection from world to tangent space

float3 worldEyeDirection = normalize(worldPosition – CameraPosition);
output.EyeDirection = mul(tangentToWorld, worldEyeDirection); // Take worldEyeDirection from world to tangent space

output.TexCoord = input.TexCoord;

return output;
}

float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0
{
// Original Color:
float4 texColor = tex2D(ImageSampler, input.TexCoord);

// Shading Contribution:
float3 normalFromNormalMap = tex2D(NormalMapSampler, input.TexCoord);
float3 normalT = (normalFromNormalMap – 0.5f) * 2.0f;
float shading = max(dot(-normalize(normalT), normalize(input.LightDirT)), 0);
shading *= LightStrength;

// Specular Contribution:
float specular = 0.0f;
float3 reflection = -reflect(normalize(input.LightDirT), normalT);
specular = max(dot(normalize(reflection), normalize(input.EyeDirection)), 0);
specular = pow(specular, SpecularPower);
specular *= LightStrength;

// Final Output Color:
float4 outColor = float4(0,0,0,1);
outColor.xyz = texColor * (Ambient + shading) + specular;
return outColor;
}

technique Technique1
{
pass Pass1
{
VertexShader = compile vs_2_0 VertexShaderFunction();
PixelShader = compile ps_2_0 PixelShaderFunction();
}
}

Normal Map

admin — Sat, 31 Jan 2009 05:39:46 +0000

This Shading Demo is an assignment I completed for a course called DirectX Programming. The effect is programmed in High Level Shader Language (HLSL). The main program is coded in C++ using DirectX 9.0. Please open the links below to learn more.

Summary

// This is the HLSL effect file which creates the normal map effect

uniform extern float4×4 WorldViewProj : WOLRDVIEWPROJECTION;
uniform extern float4×4 World : WORLD;
uniform extern float3 gLightDir;

texture2D gDiffuseTexture;
texture2D NormalMap;

sampler2D SAMPLER0 = sampler_state {
texture = (gDiffuseTexture);
MinFilter = Linear;
MagFilter = Linear;
MipFilter = Linear;
AddressU = Wrap;
AddressV = Wrap;
mipmaplodbias = 0.0;
};

sampler2D SAMPLER1 = sampler_state {
texture = (NormalMap);
MinFilter = Linear;
MagFilter = Linear;
MipFilter = Linear;
AddressU = Wrap;
AddressV = Wrap;
mipmaplodbias = 0.0;
};

struct VS_OUTPUT
{
float4 position : POSITION;
float3 normal : TEXCOORD0;
float3 lightDirection : TEXCOORD1;
float2 uv : TEXCOORD2;
};

VS_OUTPUT VSMain
(
float4 inPosition : POSITION,
float3 inNormal : NORMAL,
float3 inBitangent : BINORMAL,
float2 inUv : TEXCOORD1
)
{
VS_OUTPUT Out = (VS_OUTPUT)0;

float3 bitangent = mul(inBitangent, World);
float3 normal = mul(inNormal, World);
float3 tangent = cross(bitangent, normal);
float3×3 rotation = float3×3(tangent, bitangent, normal);

Out.position = mul(inPosition, WorldViewProj);
Out.normal = normalize(mul(inNormal, World));
Out.uv = inUv;
Out.lightDirection = mul(rotation, gLightDir);

return Out;
}

float4 PSMain( VS_OUTPUT In ) : COLOR
{
// Sample the normal from the tangent-space normal map
float3 normal = tex2D(SAMPLER1, In.uv).xyz;

// Unbias = convert from range [0,1] to range [-1,1]
normal = normal * 2.0 – 1.0;

float nDotL = -1*dot(normal, In.lightDirection);
return float4(nDotL.xxx * tex2D(SAMPLER0, In.uv), 1);
}

technique TransformTechnique
{
pass P0
{
vertexShader = compile vs_2_0 VSMain();
pixelShader = compile ps_2_0 PSMain();
}
}

Specular Shading and Environment Reflection Map

admin — Sat, 31 Jan 2009 04:10:37 +0000

This Shading Demo is an assignment I completed for a course called DirectX Programming. The effects are programmed in High Level Shader Language (HLSL). The main program is coded in C++ using DirectX 9.0. Please open the links below to learn more.

Summary

// This is the HLSL effect file which creates the Specular Lighting effect

uniform extern float4×4 WorldViewProj : WOLRDVIEWPROJECTION;
uniform extern float4×4 World : WORLD;
uniform extern float3 gEyePosition;
uniform extern float3 gLightDir;

texture2D gNormalMap;

sampler2D normalMap = sampler_state{
texture = (gNormalMap);
};

struct VS_OUTPUT
{
float4 position : POSITION;
float3 normal : TEXCOORD0;
float2 uv : TEXCOORD1;
float3 lightDirection : TEXCOORD2;
float3 eyeDirection : TEXCOORD3;
};

VS_OUTPUT VSMain
(
float4 inPosition : POSITION,
float3 inNormal : NORMAL,
float3 inTangent : TANGENT,
float2 inUv : TEXCOORD0
)
{
VS_OUTPUT Out = (VS_OUTPUT)0;

float3 tangent = mul(inTangent, World);
float3 normal = mul(inNormal, World);
float3 bitangent = cross(tangent, normal);

float3×3 worldToTangent = float3×3(tangent, bitangent, normal);

Out.position = mul(inPosition, WorldViewProj);
Out.normal = normalize(mul(inNormal, World));
Out.uv = inUv;
Out.lightDirection = mul(gLightDir, worldToTangent);

float3 objectSpaceEyeDir = ( inPosition – gEyePosition).xyz;
float3 worldSpaceEyeDir = mul( objectSpaceEyeDir, (float3×3)World );
Out.eyeDirection = mul(worldSpaceEyeDir, worldToTangent);

return Out;
}

float4 PSMain( VS_OUTPUT In ) : COLOR
{
//sample the normal from the tangent-space normal map
float3 normal = tex2D(normalMap, In.uv);

//Unbias = convert from range 0.0 to 1.0
//to range -1.0 to 1.0
normal = normal * 2.0 – 1.0;

float3 eyeDirection = normalize(In.eyeDirection);
float3 reflection = reflect(eyeDirection, normal);
float rDotL = saturate(dot(reflection, In.lightDirection ));
float specularity = 8.0;
float specular = pow(rDotL, specularity );

return float4(specular.xxx, 1);
}

technique TransformTechnique
{
pass P0
{
vertexShader = compile vs_2_0 VSMain();
pixelShader = compile ps_2_0 PSMain();
}
}

Eat Your Words

admin — Sat, 31 Jan 2009 03:41:55 +0000

Eat Your Words is a game I made in a Computer Science 2 course at Front Range Community College. It is a Console-Based Game programmed in C++. Please open the links below to learn more.

Gameplay Summary

COMING SOON

Screenshots

Different options for gameplay

Two words in one

Safety Last

admin — Sat, 31 Jan 2009 03:29:57 +0000

Safety Last is a game I worked on with a team of UAT students. It was developed in Adobe Flash using ActionScript 2.0. Please open the links below to learn more.

Gameplay Summary

COMING SOON

Screenshots

Buckle the belt before time runs out!

Get that mask on!

Choose a mini-game

Ricochet

admin — Sat, 31 Jan 2009 02:55:19 +0000

Ricochet is a game I developed for a course at UAT called Game Programming in C++. It was developed in C++ using the Allegro Game Library. Please open the links below to learn more.

Gameplay Summary

RicochetRandomMapCode.zip

Random Tile Map Generation Using Recursion

The following code creates a random tile map using recursion. createRandomMap() is called from main() or some other function. It first defaults the tile map to all wall tiles, and then calls the recursive function, createRandomHall(). createRandomHall() creates a straght hall of open tiles, one tile at a time. After creating each tile, there is a chance that createRandomHall() will call itself, giving the current tile as the new start tile, and using a new random direction. When the parent hall is returned to it will continue growing until a given max length is reached, another open tile is reached, or the edge of the map is reached. Thus, the map grows like a tree, with each hall being a branch, until a given number of open tiles have been created.

Additionally, there are three key parameters which may be customized when generating a random map: The maximum length of a hall, the number of open tiles, and the map density which controls how often a new hall will branch off.


const int MAX_HALL_LENGTH 6	// Maximum length a given hall may grow to during random map creation
const int NUM_OPEN_TILES 100	// Number of non-wall tiles in a given random map
const int MAP_DENSITY 16	// Determines chance of a new hall branching off during random map creation.
const bool ADD_OUTER_RING_TO_MAP true	// Whether or not an outer ring of open tiles should be added to a map

/* . . . */

// FUNCTION clearLevel() :  clears every tile in mapArray[][] to a wall tile.
void clearLevel()
{
	// clear level to blanks
	int x, y;
	for (x = 0; x < NUM_COLS; x++)
		for (y = 0; y < NUM_ROWS; y++)
			mapArray[x][y] = 'W';
}

// FUNCTION createRandomMap() : Creates a random tile map.
void createRandomMap()
{
	// mapNumber serves as an ID for the map being generated.
	mapNumber++;

	do
	{
		// tileCounter will hold the number of open tiles which have been created
		tileCounter = 0;	

		// make every tile a wall tile to start.
		clearLevel();		

		// generate a random tile and direction to begin "branching out" from
		int startX = 1 + rand()%(NUM_COLS - 1);
		int startY = 1 + rand()%(NUM_ROWS - 1);
		int startDir = rand()%4;

		// initial call to recursive function:
		createRandomHall(startX, startY, startDir); 

	// if NUM_OPEN_TILES of open tiles were not created, then try again
	}while(tileCounter != NUM_OPEN_TILES);

	// Add an outer ring of open tiles for better map design
	if(ADD_OUTER_RING_TO_MAP) { addOuterRingToMap(); }
}

// FUNCTION createRandomHall() : Recursively creates the random halls that make up a map.
// PARAMS : startX and startY are where a given hall will begin, startDir is the direction it will "move" in
void createRandomHall(int startX, int startY, int startDir)
{
	int randNum = 0;
	int randTileType = 0;	// used to choose a random collectible upgrade to place on certain tiles.
	int curX = startX;
	int curY = startY;
	int curDir = startDir;
	int hallLength = 0;

	while( tileCounter < NUM_OPEN_TILES )
	{
		// if the hall hasn't extended too far, and the current tile is a wall tile and is not on the outer edge of the map...
		if( (hallLength < MAX_HALL_LENGTH) && (mapArray[curX][curY] == 'W') &&
			!( curX <= 0 || curX >= NUM_COLS-1 || curY <= 0 || curY >= NUM_ROWS-1 ) )
		{
			if(tileCounter == 0) { mapArray[curX][curY] = '+'; }	// assign Player 1 start position
			else if(tileCounter == NUM_OPEN_TILES-1) { mapArray[curX][curY] = '-'; }// assign Player 2 start position
			else
			{
				if(tileCounter%20 == 5)	// 1 in 20 chance of placing a collectible upgrade at current tile
				{
					randTileType = 1 + rand()%5;	// choose random upgrade
					mapArray[curX][curY] = char(int('0') + randTileType);	// assign upgrade to this tile
				}
				else
					mapArray[curX][curY] = ' ';	// otherwise tile is open without a collectible upgrade
			}
			tileCounter++; hallLength++;

			randNum = rand()%MAP_DENSITY;	// make random integer between 0 and MAP_DENSITY
			// if randNum is between 1 and 4, then branch off
			switch(randNum) {
						// branch NORTH
				case 1:	if(curDir != NORTH) { createRandomHall(curX, curY-1, NORTH); }		break;						// branch EAST
				case 2:	if(curDir != EAST)  { createRandomHall(curX+1, curY, EAST);	 }		break;						// branch SOUTH
				case 3:	if(curDir != SOUTH) { createRandomHall(curX, curY+1, SOUTH); }		break;						// branch WEST
				case 4:	if(curDir != WEST)  { createRandomHall(curX-1, curY, WEST);	 }		break;
				default: break;
			}

			// if randNum was 5 or higher, or we have returned from a recursive call, we now continue down 				this hall in the same direction.
			switch(curDir) {
				case NORTH: curY--;	break;
				case EAST:  curX++;	break;
				case SOUTH: curY++;	break;
				case WEST:  curX--;	break;
			}
		}
		else { break; }
	}

	return;
}

// FUNCTION addOuterRingToMap() : Adds an outer ring of open tiles for better map design
void addOuterRingToMap()
{
	int x = 0, y = 0;
	for(x = 1; x < NUM_COLS-1; x++)
	{
		if(mapArray[x][1] == 'W')	// if tile is a wall (and not a start position or collectible upgrade)...
			mapArray[x][1] = ' ';	// make it an open tile
		if(mapArray[x][NUM_ROWS-2] == 'W')
			mapArray[x][NUM_ROWS-2] = ' ';
	}
	for(y = 1; y < NUM_ROWS-1; y++)
	{
		if(mapArray[1][y] == 'W')
			mapArray[1][y] = ' ';
		if(mapArray[NUM_COLS-2][y] == 'W')
			mapArray[NUM_COLS-2][y] = ' ';
	}
}

Flocking 3D

admin — Sat, 31 Jan 2009 02:19:26 +0000

Flocking 3D is a simulation I developed for a course at UAT called Artificial Life Programming. It was developed in C++ using DirectX 9.0. Please open the links below to learn more.

Simulation Summary

Flocking3DboidCollectionCode.zip

3D Space Partitioning for Efficiency

The following code is a function which is called once per frame. It takes as arguments an array of Boids (where Boid is a class representing one of the birds) and a 2D array of doubly-linked lists of Boid pointers called boidCollection. Here is a brief description of the function’s purpose: It organizes the array of Boids based on their current position in order to provide for extremely efficient comparisons between nearby Boids later on.

The boidCollection, being a 2D array, “maps” to the space in which the Boids are flying around. The Boid’s position determines what index it will belong to within boidCollection. This way, when it comes time to check for collisions or other comparative operations, a Boid only needs to be compared to the Boids in it’s own partition of space or to those directly surrounding it, and those relevant Boids may be found by moving through the linked lists contained in the Boid’s corresponding boidCollection index and the Lists in the “surrounding” indexes. The reason this function must be called once per frame is because a Boid is always moving and therefore its corresponding index in boidCollection will need to change whenever it crosses over to another partition of space.


// FUNCTION updateBoidCollection(): Called once every frame.  Reorganizes the
// boidCollection structure based on new positions of Boids.
void updateBoidCollection( Boid boidArray[],
                                       Array2D< DLinkedList< Boid* > > &boidCollection )
{
	int oldXTile = 0;	// the X tile that the Boid was on in the previous frame
	int oldZTile = 0;	// the Z tile that the Boid was on in the previous frame
	int newXTile = 0;  // the X tile that the Boid will move to
	int newZTile = 0;  // the Z tile that the Boid will move to

	DListIterator< Boid* > crntBoid;	// an iterator that's used to move through every Boid in a given tile

	for( int i = 0; i < NUM_BOIDS; i++ )	// for all Boids:
	{
		// assign old tile and new tile
		oldXTile = boidArray[i].getXTile();
		oldZTile = boidArray[i].getZTile();
		newXTile = floor( ( boidArray[i].getXPos() + (0.5 * ROOM_LENGTH) ) / TILE_SIZE);
		newZTile = floor( ( boidArray[i].getZPos() + (0.5 * ROOM_WIDTH) ) / TILE_SIZE);

		// if old tile and new tile are not the same then boidCollection needs to reflect this change
		if( (newXTile != oldXTile) || (newZTile != oldZTile) )
		{
                        // assign iterator to the DLinkedList at new tile
			crntBoid = boidCollection.Get( oldXTile, oldZTile ).GetIterator();	

			// iterate through the list until you find the Boid
			while( crntBoid.Item()->getID() != boidArray[i].getID() && crntBoid.Valid() )
			{
				crntBoid.Forth();
			}
			if( crntBoid.Valid() )
                       // if you found the Boid (which you should unless an error has occurred)...
			{
				// remove its node from the list
				boidCollection.Get( oldXTile, oldZTile ).RemoveWithoutDeleting(crntBoid);
			}
			else
			{
				cout << "Error in reading a DLinkedList.\n";
			}
			// append the Boid to the list at the new tile's location
			boidCollection.Get( newXTile, newZTile ).Append( &boidArray[i] );
			boidArray[i].setXTile( newXTile );		// give Boid its new tile position
			boidArray[i].setZTile( newZTile );
		}
	}
}

Charged Particles (original)

admin — Sat, 31 Jan 2009 01:24:37 +0000

Charged Particles is a simulation I developed for a course at UAT called Advanced Game Physics Programming. It was developed in C++ using DirectX 9.0. Please open the links below to learn more.

Simulation Summary

ChargedParticlesCollisionCode.zip

Sphere-Sphere Collision Response

Nothing is returned, however the two spheres receive new velocities based on their initial velocities, relative positions, masses, and coefficients of restitution (elasticity).

Also note that, if the spheres are overlapping, they are each moved apart by half of the distance between them so that they are barely touching.


// FUNCTION HandleCollision() : Handles collisions between spheres
void HandleCollision(POINT_MASS pt_Masses[], Vector3D_d &separationDistance, double &changeInTime, int i, int j)
{
	// Create a unit length vector representing the angle of collision:
	Vector3D_d unitNormal = separationDistance;
	unitNormal.normalize();

	// Find the new velocities of both objects based off of their velocities prior to collision:
	double velocity_1 = pt_Masses[i].getLinearVelocity().dotProduct(unitNormal);
	double velocity_2 = pt_Masses[j].getLinearVelocity().dotProduct(unitNormal);

	// Calculate the average elasticity between the two spheres:
	double average_E = ( pt_Masses[i].getElasticity() + pt_Masses[j].getElasticity() ) / 2;

	// Use the equations for elastic collision response to calculate the final velocities:
	double finalVelocity_1 = ( ( ( pt_Masses[i].getMass() -
								( average_E * pt_Masses[j].getMass() ) ) * velocity_1 ) +
								( (1 + average_E) * pt_Masses[j].getMass() * velocity_2 ) ) /
								( pt_Masses[i].getMass() + pt_Masses[j].getMass() );
	double finalVelocity_2 = ( ( ( pt_Masses[j].getMass() -
								( average_E * pt_Masses[i].getMass() ) ) * velocity_2 ) +
								( (1 + average_E) * pt_Masses[i].getMass() * velocity_1 ) ) /
								( pt_Masses[i].getMass() + pt_Masses[j].getMass() );

	pt_Masses[i].setLinearVelocity( (finalVelocity_1 - velocity_1) * unitNormal + pt_Masses[i].getLinearVelocity() );
	pt_Masses[j].setLinearVelocity( (finalVelocity_2 - velocity_2) * unitNormal + pt_Masses[j].getLinearVelocity() );

	// If point masses are overlapping, back them up so that they are barely touching:
	double minDistance = pt_Masses[i].getBoundingSphereRadius() + pt_Masses[j].getBoundingSphereRadius();
	double overlapDistance = minDistance - separationDistance.getNorm();

	pt_Masses[i].setLocation( pt_Masses[i].getLocation() + ( 0.5 * unitNormal * overlapDistance) );
	pt_Masses[j].setLocation( pt_Masses[j].getLocation() + (-0.5 * unitNormal * overlapDistance) );
}