/****************************************************************************************/
/*  SPRITE.C                                                                            */
/*                                                                                      */
/*  Author: Michael R. Brumm	                                                          */
/*  Description: Sprite implementation                                                  */
/*                                                                                      */
/*  The contents of this file are subject to the Genesis3D Public License               */
/*  Version 1.01 (the "License"); you may not use this file except in                   */
/*  compliance with the License. You may obtain a copy of the License at                */
/*  http://www.genesis3d.com                                                            */
/*                                                                                      */
/*  Software distributed under the License is distributed on an "AS IS"                 */
/*  basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See                */
/*  the License for the specific language governing rights and limitations              */
/*  under the License.                                                                  */
/*                                                                                      */
/****************************************************************************************/

#include <assert.h>
#include <math.h>

#include "world.h"
#include "trace.h"

#include "sprite.h"

#include "ErrorLog.h"


#define BIG_DISTANCE 30000.0f

extern geBoolean geBitmap_IsValid(const geBitmap *Bmp);

// sprites are rectangular
#define SPRITE_NUM_CORNERS 4

// unit corners used to create scaled corners
#define UNIT_CORNERS	{ {0.5f, -0.5f}, {-0.5f, -0.5f}, {-0.5f, 0.5f}, {0.5f, 0.5f} }
const geCoordinate	UnitCorners[SPRITE_NUM_CORNERS] = UNIT_CORNERS;


// dynamic light information is reused between sprites
// saving resources and allocation time
typedef struct geSprite_DynamicLight
{
	geVec3d		Normal;
	geColor		Color;
	geFloat		Distance;
	geFloat		Radius;
} geSprite_DynamicLight;

static geSprite_DynamicLight geSpriteDynamicLights[MAX_DYNAMIC_LIGHTS];


// frustum clipping arrays are reused between sprites
// saving resources and allocation time
#define MAX_TEMP_VERTS	30

static Surf_TexVert		UnclippedUVRGBA[MAX_TEMP_VERTS];

static geVec3d				FrustumClippedVertexes1[MAX_TEMP_VERTS];
static Surf_TexVert		FrustumClippedUVRGBA1[MAX_TEMP_VERTS];
static geVec3d				FrustumClippedVertexes2[MAX_TEMP_VERTS];
static Surf_TexVert		FrustumClippedUVRGBA2[MAX_TEMP_VERTS];

static int32					FrustumNumClippedTexturedLitVertices;

static Surf_TLVertex	FrustumClippedTexturedLitVertexes[MAX_TEMP_VERTS];


typedef struct geSprite
{
	// number of owners
	int32				RefCount;				

	// bitmaps used to texture the sprite
	geBitmap *	Bitmap;
	geBitmap *	BackfaceBitmap;

	// backface properties
	geBoolean		BackfaceEnabled;
	geBoolean		BackfaceMirrorImage;

	// makes the sprite always face the camera
	geBoolean		AlwaysFaceCamera;

	// transform affects position and orientation of the sprite
	geXForm3d		Transform;

	// internal transform also affects position and orientation of the sprite
	// allows the sprite to be offset from its center of rotation
	geBoolean		InternalTransformUsed;
	geXForm3d		InternalTransform;

	// actual center of sprite (both external and internal transforms added)
	geVec3d			Position;

	// scale of the sprite
	// allows sprite to be sized without changing
	geFloat			ScaleX;
	geFloat			ScaleY;

	// cached corners and vertexes
	// corners are used to build the vertexes
	// vertexes are used to build final screen polys
	geCoordinate	Corners[SPRITE_NUM_CORNERS];
	geVec3d				Vertexes[SPRITE_NUM_CORNERS];

	// texture parameters
	geFloat			TextureOffsetX;
	geFloat			TextureOffsetY;
	geFloat			TextureScaleX;
	geFloat			TextureScaleY;

	// cached texture mapping information
	geUV				UVs[SPRITE_NUM_CORNERS];
	geUV				BackfaceUVs[SPRITE_NUM_CORNERS];

	// lighting parameters
	// used to build cached lighting information
	geColor			AmbientLight;
	geBoolean		UseFillLight;
	geColor			FillLight;
	geVec3d			FillLightNormal;
	geBoolean		UseLightFromFloor;
	int32				MaximumDynamicLightsToUse;

	// cached lighting information
	GE_RGBA			RGBA;
	GE_RGBA			BackfaceRGBA;

	// surface normal of the sprite's face
	geVec3d			SurfaceNormal;
	geBoolean		LightingUsesSurfaceNormal;

	// bounding box which other objects collide against
	geVec3d			BoundingBoxMinCorner;
	geVec3d			BoundingBoxMaxCorner;

	// user data
	void *			UserData;

	// tracks changes made and whether cached data needs
	// to be updated
	geBoolean		TransformChanged;
	geBoolean		LightingChanged;

} geSprite;


	// these are useful globals to monitor resources
int32 geSprite_Count       = 0;
int32 geSprite_RefCount    = 0;


__inline static void geSprite_UpdatePosition(geSprite *S)
{
	if (S->AlwaysFaceCamera)
		S->Position = S->Transform.Translation;
	else
		geVec3d_Add( &(S->Transform.Translation), &(S->InternalTransform.Translation), &(S->Position) );
}


__inline static void geSprite_UpdateCorners(geSprite *S)
{
	int i;

	for (i = 0; i < SPRITE_NUM_CORNERS; i++)
	{
		S->Corners[i].X = UnitCorners[i].X * S->ScaleX;
		S->Corners[i].Y = UnitCorners[i].Y * S->ScaleY;
	}
}


__inline static void geSprite_UpdateVertexes(geSprite *S)
{
	int i;

	// create a rectangle of the correct size around the origin
	for (i = 0; i < SPRITE_NUM_CORNERS; i++)
	{
		S->Vertexes[i].X = S->Corners[i].X;
		S->Vertexes[i].Y = S->Corners[i].Y;
		S->Vertexes[i].Z = 0.0f;
	}

	// apply the internal and external transform if an internal transform is used
	if (S->InternalTransformUsed)
		geXForm3d_TransformArray(&(S->InternalTransform), S->Vertexes, S->Vertexes, SPRITE_NUM_CORNERS);

	// apply the sprites external transform
	geXForm3d_TransformArray(&(S->Transform), S->Vertexes, S->Vertexes, SPRITE_NUM_CORNERS);
}


__inline static void geSprite_UpdateVertexesToFaceCamera(geSprite *S, geCamera *Camera)
{
	int i;
	const geXForm3d *CameraXForm;
	geVec3d Left;
	geVec3d Up;
	geVec3d In;
	geFloat Dot;

	// optimized out:
	//
	//		geXForm3d FaceCameraXForm;

	// get the camera's transform
	CameraXForm = geCamera_GetWorldSpaceXForm(Camera);

	// get the vector opposite to the direction the camera is looking
	//
	// optimized from:
	//
	//		geXForm3d_GetIn(CameraXForm, &In);
	//		In.X = -In.X;
	//		In.Y = -In.Y;
	//		In.Z = -In.Z;
	//
	In.X = CameraXForm->AZ;
	In.Y = CameraXForm->BZ;
	In.Z = CameraXForm->CZ;

	// get the up direction of the camera
	geXForm3d_GetUp(CameraXForm, &Up);

	Dot = geVec3d_DotProduct(&Up, &In);

	Up.X = Up.X - (Dot * In.X);
	Up.Y = Up.Y - (Dot * In.Y);
	Up.Z = Up.Z - (Dot * In.Z);

	geVec3d_Normalize(&Up);

	// get the left vector direction for the sprite based on the 'in' and 'up'
	//
	// optimized from:
	//
	//		geVec3d_CrossProduct(&Up, &In, &Left);
	//
	Left.X = (Up.Z * In.Y) - (Up.Y * In.Z);
  Left.Y = (Up.X * In.Z) - (Up.Z * In.X);
  Left.Z = (Up.Y * In.X) - (Up.X * In.Y);

	// build the transform based on the left, up, in, and position of the sprite
	//
	// optimized out:
	//
	//		geXForm3d_SetFromLeftUpIn(&RotationXForm, &Left, &Up, &In);
	//		FaceCameraXForm.Translation = S->Transform.Translation;

	// modify all the vertexes
	for (i = 0; i < SPRITE_NUM_CORNERS; i++)
	{
		// optimized from:
		//
		//		S->Vertexes[i].X = S->Corners[i].X;
		//		S->Vertexes[i].Y = S->Corners[i].Y;
		//		S->Vertexes[i].Z = 0.0f;
		//
		//		geXForm3d_Transform(&FaceCameraXForm, &(S->Vertexes[i]), &(S->Vertexes[i]));
		//
		S->Vertexes[i].X = (S->Corners[i].X * Left.X) + (S->Corners[i].Y * Up.X) + S->Transform.Translation.X;
		S->Vertexes[i].Y = (S->Corners[i].X * Left.Y) + (S->Corners[i].Y * Up.Y) + S->Transform.Translation.Y;
		S->Vertexes[i].Z = (S->Corners[i].X * Left.Z) + (S->Corners[i].Y * Up.Z) + S->Transform.Translation.Z;
	}
}


__inline static void geSprite_UpdateSurfaceNormal(geSprite *S)
{
	if (S->InternalTransformUsed)
	{
		// rotate the surface normal by the internal transform
		//
		// optimized from:
		//
		//		S->SurfaceNormal.X = 0.0f;
		//		S->SurfaceNormal.Y = 0.0f;
		//		S->SurfaceNormal.Z = -1.0f;
		// 
		//		geXForm3d_Rotate(&(S->InternalTransform), &(S->SurfaceNormal), &(S->SurfaceNormal));
		//
		S->SurfaceNormal.X = -S->InternalTransform.AZ;
		S->SurfaceNormal.Y = -S->InternalTransform.BZ;
		S->SurfaceNormal.Z = -S->InternalTransform.CZ;

		// rotate the surface normal by the external transform
		geXForm3d_Rotate(&(S->Transform), &(S->SurfaceNormal), &(S->SurfaceNormal));

	}

	else
	{
		// rotate the surface normal by the external transform
		//
		// optimized from:
		//
		//		S->SurfaceNormal.X = 0.0f;
		//		S->SurfaceNormal.Y = 0.0f;
		//		S->SurfaceNormal.Z = -1.0f;
		// 
		//		geXForm3d_Rotate(&(S->Transform), &(S->SurfaceNormal), &(S->SurfaceNormal));
		//
		S->SurfaceNormal.X = -S->Transform.AZ;
		S->SurfaceNormal.Y = -S->Transform.BZ;
		S->SurfaceNormal.Z = -S->Transform.CZ;
	}
}


__inline static void geSprite_UpdateSurfaceNormalToFaceCamera(geSprite *S, geCamera *Camera)
{
	// get the camera's transform
	const geXForm3d *CameraXForm;
	CameraXForm = geCamera_GetWorldSpaceXForm(Camera);

	// get the vector opposite to the direction the camera is looking
	//
	// optimized from:
	//
	//		geXForm3d_GetIn(CameraXForm, &(S->SurfaceNormal));
	//		S->SurfaceNormal.X = -S->SurfaceNormal.X;
	//		S->SurfaceNormal.Y = -S->SurfaceNormal.Y;
	//		S->SurfaceNormal.Z = -S->SurfaceNormal.Z;
	//
	S->SurfaceNormal.X = CameraXForm->AZ;
	S->SurfaceNormal.Y = CameraXForm->BZ;
	S->SurfaceNormal.Z = CameraXForm->CZ;
}


__inline static void geSprite_CreateFrustumClippedScreenPoly(geSprite *S, geCamera *Camera, Frustum_Info *FInfo, geBoolean *Render, geBoolean *RenderBackface)
{
	int i;

	const geXForm3d *CameraXForm;

	GFX_Plane *FPlanes;

	geVec3d *pVerts1;
	geVec3d *pVerts2;
	Surf_TexVert *pTexs1;
	Surf_TexVert *pTexs2;
	int32 Length;

	geVec3d CameraNormal;

	// if the face is always facing the camera, the backface will not
	// be rendered
	if (S->AlwaysFaceCamera)
	{
		*RenderBackface = GE_FALSE;
	}

	// if the sprite is not always facing the camera, figure out which
	// face is facing the camera
	else
	{
		// get the camera's transform
		CameraXForm = geCamera_GetWorldSpaceXForm(Camera);

		// get the direction vector from the camera to the sprite
		geVec3d_Subtract(&(S->Position), &(CameraXForm->Translation), &CameraNormal);
		geVec3d_Normalize(&CameraNormal);

		// check to see how similar the sprite's surface normal is to the direction
		// between the camera and the sprite, and determine if the backface is being
		// shown to the camera
		*RenderBackface = (geVec3d_DotProduct(&CameraNormal, &(S->SurfaceNormal)) > 0);

		// if the backface is facing the camera, and it is disabled, then
		// don't render it
		if ( (*RenderBackface) && (!S->BackfaceEnabled) )
		{
			*Render = GE_FALSE;
			return;
		}
	}

	// no sense in rendering a completely transparent face
	if ( ((!(*RenderBackface)) && (S->RGBA.a == 0.0f)) || 
			 ((*RenderBackface) && (S->BackfaceRGBA.a == 0.0f)) )
	{
		*Render = GE_FALSE;
		return;
	}

	// copy the correct texture mappings
	if (*RenderBackface)
	{
		for (i = 0; i < SPRITE_NUM_CORNERS; i++)
		{
			UnclippedUVRGBA[i].u = S->BackfaceUVs[i].u;
			UnclippedUVRGBA[i].v = S->BackfaceUVs[i].v;
		}
	}
	else
	{
		for (i = 0; i < SPRITE_NUM_CORNERS; i++)
		{
			UnclippedUVRGBA[i].u = S->UVs[i].u;
			UnclippedUVRGBA[i].v = S->UVs[i].v;
		}
	}

	// initialize pointers for frustum clipping
	FPlanes = FInfo->Planes;
	pVerts1 = S->Vertexes;
	pTexs1 = UnclippedUVRGBA;
	pVerts2 = FrustumClippedVertexes1;
	pTexs2 = FrustumClippedUVRGBA1;
	Length = SPRITE_NUM_CORNERS;

	// clip the vertexes (including their texture and lighting) to the frustum
	for (i = 0; i < FInfo->NumPlanes; i++, FPlanes++)
	{
		
		if (!Frustum_ClipToPlaneUV(FPlanes, pVerts1, pVerts2, pTexs1, pTexs2, Length, &FrustumNumClippedTexturedLitVertices))
			break;

		assert(FrustumNumClippedTexturedLitVertices < MAX_TEMP_VERTS);
		
		// this is hard to read, but essentially what is happening is that
		// source data is swapping with destination data every frustum clip.
		// in this way, vertexes are further clipped each time
		if (pVerts2 == FrustumClippedVertexes1)
		{
			pVerts1 = FrustumClippedVertexes1;
			pVerts2 = FrustumClippedVertexes2;
			pTexs1 = FrustumClippedUVRGBA1;
			pTexs2 = FrustumClippedUVRGBA2;
		}
		else
		{
			pVerts1 = FrustumClippedVertexes2;
			pVerts2 = FrustumClippedVertexes1;
			pTexs1 = FrustumClippedUVRGBA2;
			pTexs2 = FrustumClippedUVRGBA1;
		}

		Length = FrustumNumClippedTexturedLitVertices;
	}
			
	assert(FrustumNumClippedTexturedLitVertices < MAX_TEMP_VERTS);

	// Not visible or not enough vertexes
	if ( (i != FInfo->NumPlanes) || (FrustumNumClippedTexturedLitVertices < 3) )
	{
		*Render = GE_FALSE;
		return;
	}

	// Transform the face to camera space
	geCamera_TransformArray(Camera, pVerts1, pVerts1, FrustumNumClippedTexturedLitVertices);

	// Project the face, and combine vertex and texture and lighting data into one structure
	Frustum_ProjectRGBA(pVerts1, pTexs1, (DRV_TLVertex*)&FrustumClippedTexturedLitVertexes, FrustumNumClippedTexturedLitVertices, Camera);

	*Render = GE_TRUE;
}


__inline static void geSprite_UpdateBackfaceTextureMap(geSprite *S)
{
	if (S->BackfaceMirrorImage)
	{
		S->BackfaceUVs[0].u = S->UVs[0].u;
		S->BackfaceUVs[0].v = S->UVs[0].v;
		S->BackfaceUVs[1].u = S->UVs[1].u;
		S->BackfaceUVs[1].v = S->UVs[1].v;
		S->BackfaceUVs[2].u = S->UVs[2].u;
		S->BackfaceUVs[2].v = S->UVs[2].v;
		S->BackfaceUVs[3].u = S->UVs[3].u;
		S->BackfaceUVs[3].v = S->UVs[3].v;
	}
	else
	{
		S->BackfaceUVs[0].u = S->UVs[1].u;
		S->BackfaceUVs[0].v = S->UVs[1].v;
		S->BackfaceUVs[1].u = S->UVs[0].u;
		S->BackfaceUVs[1].v = S->UVs[0].v;
		S->BackfaceUVs[2].u = S->UVs[3].u;
		S->BackfaceUVs[2].v = S->UVs[3].v;
		S->BackfaceUVs[3].u = S->UVs[2].u;
		S->BackfaceUVs[3].v = S->UVs[2].v;
	}
}


__inline static void geSprite_UpdateTextureMap(geSprite *S)
{
/*
	S->UVs[0].u = TextureOffsetX;
	S->UVs[0].v = 1 - TextureOffsetY;

	S->UVs[1].u = TextureOffsetX + TextureScaleX;
	S->UVs[1].v = 1 - TextureOffsetY;

	S->UVs[2].u = TextureOffsetX + TextureScaleX;
	S->UVs[2].v = 1 - TextureOffsetY - TextureScaleY;

	S->UVs[3].u = TextureOffsetX;
	S->UVs[3].v = 1 - TextureOffsetY - TextureScaleY;
*/
	// optimized (compiler probably would figure it out, but why take the chance)
	S->UVs[3].u = S->UVs[0].u = S->TextureOffsetX;
	S->UVs[1].v = S->UVs[0].v = 1 - S->TextureOffsetY;

	S->UVs[2].u = S->UVs[1].u = S->TextureOffsetX + S->TextureScaleX;
	S->UVs[1].v = 1 - S->TextureOffsetY;

	S->UVs[3].v = S->UVs[2].v = 1 - S->TextureOffsetY - S->TextureScaleY;

	geSprite_UpdateBackfaceTextureMap(S);
}


#pragma warning(disable : 4700 )
__inline static void geSprite_UpdateLighting(geSprite *S, geWorld *World)
{
	int32 i, j;

	geFloat Intensity;

	geBoolean DoBackface;

	geSprite_DynamicLight TempSwap;

	geFloat Scale;

	geVec3d PositionBelowFloor;

	geBoolean	InsideWorldModel;
	geBoolean	FloorBeneath;

	geVec3d Impact;
	int32		Node;
	int32		Plane;

	GFX_Node			*GFXNodes;
	Surf_SurfInfo	*Surf;
	GE_RGBA				FaceLightmapColor;


	// first apply the ambient light
	S->RGBA.r = S->AmbientLight.r;
	S->RGBA.g = S->AmbientLight.g;
	S->RGBA.b = S->AmbientLight.b;

	// apply the ambient to the backface, if there is one
	DoBackface = ( (S->BackfaceEnabled) && !(S->AlwaysFaceCamera) );
	if (DoBackface)
	{
		S->BackfaceRGBA.r = S->AmbientLight.r;
		S->BackfaceRGBA.g = S->AmbientLight.g;
		S->BackfaceRGBA.b = S->AmbientLight.b;
	}

	// calculate the fill light, if it applies
	if (S->UseFillLight)
	{
		Intensity = geVec3d_DotProduct( &(S->FillLightNormal), &(S->SurfaceNormal) );

		if (Intensity < 0.0f)
		{
			S->RGBA.r -= (Intensity * S->FillLight.r);
			S->RGBA.g -= (Intensity * S->FillLight.g);
			S->RGBA.b -= (Intensity * S->FillLight.b);
		}
		else
		{
			// apply the fill light to the backface, if there is one
			if (DoBackface)
			{
				S->BackfaceRGBA.r += (Intensity * S->FillLight.r);
				S->BackfaceRGBA.g += (Intensity * S->FillLight.g);
				S->BackfaceRGBA.b += (Intensity * S->FillLight.b);
			}
		}
	}

	if (S->MaximumDynamicLightsToUse > 0)
	{
		// a pointer to make things easier
		Light_DLight *DynamicLights = World->LightInfo->DynamicLights;
		
		// start out with no dynamic lights available for lighting
		int32 DLCount = 0;

		// get all the dynamic lights that are active
		for (i = 0; i < MAX_DYNAMIC_LIGHTS; i++)
		{
			if (DynamicLights[i].Active)
			{
				// the normal is a vector distance
				geVec3d Normal;
				geVec3d_Subtract(&(S->Position), &(DynamicLights[i].Pos), &Normal);

				// which is why it can be used to calculate distance (squared)
				geSpriteDynamicLights[DLCount].Distance = (Normal.X * Normal.X) + 
																									(Normal.Y * Normal.Y) + 
																									(Normal.Z * Normal.Z);

				// if the sprite is inside the active dynamic light's radius, then add it to the array
				if (geSpriteDynamicLights[DLCount].Distance < (DynamicLights[i].Radius * DynamicLights[i].Radius))
				{
					geSpriteDynamicLights[DLCount].Color.r = DynamicLights[i].Color.r;
					geSpriteDynamicLights[DLCount].Color.g = DynamicLights[i].Color.g;
					geSpriteDynamicLights[DLCount].Color.b = DynamicLights[i].Color.b;
					geSpriteDynamicLights[DLCount].Radius = DynamicLights[i].Radius;
					// this normal will be normalized later
					geSpriteDynamicLights[DLCount].Normal = Normal;
					DLCount++;
				}
			}
		}

		// try to eliminate some easy out possibilities
		if (DLCount > 1)
		{
			// if there is only one light needed, just make sure the closest
			// is in the first location
			if ( (S->MaximumDynamicLightsToUse == 1) )
			{
				for (i = 1; i < DLCount; i++)
				{
					if (geSpriteDynamicLights[i].Distance < geSpriteDynamicLights[0].Distance)
						geSpriteDynamicLights[0] = geSpriteDynamicLights[i];
				}
			}
			// if there is not just one light to get out of the array, then
			// sort the active dynamic lights by distance (squared)
			else
			{
				for (i = 0; i < DLCount; i++)
				{
					for (j = 0; j < (DLCount - 1); j++)
					{
						if (geSpriteDynamicLights[j].Distance > geSpriteDynamicLights[j+1].Distance)
						{
							TempSwap = geSpriteDynamicLights[j];
							geSpriteDynamicLights[j] = geSpriteDynamicLights[j+1];
							geSpriteDynamicLights[j+1] = TempSwap;
						}
					}
				}
			}
		}

		// use whatever dynamic lights are available, under the maximum number
		if (DLCount > S->MaximumDynamicLightsToUse)
			DLCount = S->MaximumDynamicLightsToUse;

		// calculate the effect the closest lights have on the face
		for (i = 0; i < DLCount; i++)
		{
			// makes the code more readable
			geVec3d *LightNormal = &(geSpriteDynamicLights[i].Normal);

			// get the real distance (not the distance squared)
			geFloat Distance = (geFloat)sqrt(geSpriteDynamicLights[i].Distance);

			// see, I told you it would get normalized (although not perfectly)
			if (Distance > 1.0f)
				geVec3d_Scale(LightNormal, (1.0f / Distance), LightNormal);
			else
				Distance = 1.0f;

			Scale = 1.0f - (Distance / geSpriteDynamicLights[i].Radius);

			Intensity	=	geVec3d_DotProduct( LightNormal, &(S->SurfaceNormal) );

			if (Intensity < 0.0f)
			{
				S->RGBA.r -= (Intensity * geSpriteDynamicLights[i].Color.r * Scale);
				S->RGBA.g -= (Intensity * geSpriteDynamicLights[i].Color.g * Scale);
				S->RGBA.b -= (Intensity * geSpriteDynamicLights[i].Color.b * Scale);
			}
			else
			{
				if (DoBackface)
				{
					S->BackfaceRGBA.r += (Intensity * geSpriteDynamicLights[i].Color.r * Scale);
					S->BackfaceRGBA.g += (Intensity * geSpriteDynamicLights[i].Color.g * Scale);
					S->BackfaceRGBA.b += (Intensity * geSpriteDynamicLights[i].Color.b * Scale);
				}
			}
		}
	}

	if (S->UseLightFromFloor)
	{
		PositionBelowFloor.X = S->Position.X;
		PositionBelowFloor.Y = S->Position.Y - BIG_DISTANCE;
		PositionBelowFloor.Z = S->Position.Z;

		// Get shadow hit plane impact point
		InsideWorldModel = Trace_WorldCollisionExact2(World, &(S->Position), &(S->Position), &Impact, &Node, &Plane, NULL);
		FloorBeneath = Trace_WorldCollisionExact2(World, &(S->Position), &PositionBelowFloor, &Impact, &Node, &Plane, NULL);

		// Now find the color of the mesh by getting the lightmap point he is standing on...
		if ( (!InsideWorldModel) && FloorBeneath)
		{
			// make things a bit more readable
			GFXNodes = World->CurrentBSP->BSPData.GFXNodes;

			// get the surface infomation for the node below the sprite
			Surf = &(World->CurrentBSP->SurfInfo[GFXNodes[Node].FirstFace]);

			// if there are lightmap faces, then find the light mapped face below the sprite
			if (Surf->LInfo.Face >= 0)
			{
				// go through each face looking for one below the sprite
				for (i = 0; i < GFXNodes[Node].NumFaces; i++)
				{
					// if the surface is located at the point below the sprite,
					// get the lightmap
					if (Surf_InSurfBoundingBox(Surf, &Impact, 20.0f))
					{
						// setup the lightmap for the surface
						Light_SetupLightmap(&Surf->LInfo, NULL);

						// get the lightmap color at the point and add it to the
						// light of the sprite, and stop looking for any more light
						if (Light_GetLightmapRGB(Surf, &Impact, &FaceLightmapColor))
						{
							S->RGBA.r += FaceLightmapColor.r;
							S->RGBA.g += FaceLightmapColor.g;
							S->RGBA.b += FaceLightmapColor.b;

							if (DoBackface)
							{
								S->BackfaceRGBA.r += FaceLightmapColor.r;
								S->BackfaceRGBA.g += FaceLightmapColor.g;
								S->BackfaceRGBA.b += FaceLightmapColor.b;
							}

							break;
						}
					}
					
					// go to the next surface
					Surf++;
				}
			}
		}
	}

	// fix up any over or under flow
	if (S->RGBA.r > 255.0f)
		S->RGBA.r = 255.0f;
	else if (S->RGBA.r < 0.0f)
		S->RGBA.r = 0.0f;

	if (S->RGBA.g > 255.0f)
		S->RGBA.g = 255.0f;
	else if (S->RGBA.g < 0.0f)
		S->RGBA.g = 0.0f;

	if (S->RGBA.b > 255.0f)
		S->RGBA.b = 255.0f;
	else if (S->RGBA.b < 0.0f)
		S->RGBA.b = 0.0f;

	if (DoBackface)
	{
		// fix up any over or under flow
		if (S->BackfaceRGBA.r > 255.0f)
			S->BackfaceRGBA.r = 255.0f;
		else if (S->BackfaceRGBA.r < 0.0f)
			S->BackfaceRGBA.r = 0.0f;

		if (S->BackfaceRGBA.g > 255.0f)
			S->BackfaceRGBA.g = 255.0f;
		else if (S->BackfaceRGBA.g < 0.0f)
			S->BackfaceRGBA.g = 0.0f;

		if (S->BackfaceRGBA.b > 255.0f)
			S->BackfaceRGBA.b = 255.0f;
		else if (S->BackfaceRGBA.b < 0.0f)
			S->BackfaceRGBA.b = 0.0f;
	}
}
#pragma warning(default : 4700 )


GENESISAPI int32 GENESISCC geSprite_GetCount()
{
	return geSprite_Count;
}


GENESISAPI geSprite *GENESISCC geSprite_Create(geBitmap *SpriteBitmap, geBitmap *SpriteBackfaceBitmap)
{
	geSprite *S;

	if (SpriteBitmap)
	{
		if ( geBitmap_IsValid(SpriteBitmap) == GE_FALSE )
		{
			geErrorLog_Add( ERR_SPRITE_INVALIDBITMAP , NULL);
			return NULL;
		}
	}

	if ( (SpriteBackfaceBitmap) && (SpriteBackfaceBitmap != SpriteBitmap) )
	{
		if ( geBitmap_IsValid(SpriteBackfaceBitmap) == GE_FALSE )
		{
			geErrorLog_Add( ERR_SPRITE_INVALIDBITMAP , NULL);
			return NULL;
		}
	}


	S = GE_RAM_ALLOCATE_STRUCT( geSprite );
	if ( S == NULL )
	{
		geErrorLog_Add( ERR_SPRITE_ENOMEM , NULL);
		return NULL;
	}
	
	S->RefCount = 0;

	S->Bitmap = SpriteBitmap;
	if (SpriteBitmap)
		geBitmap_CreateRef(SpriteBitmap);

	S->BackfaceBitmap = SpriteBackfaceBitmap;
	if ( (SpriteBackfaceBitmap) && (SpriteBitmap != SpriteBackfaceBitmap) )
		geBitmap_CreateRef(SpriteBackfaceBitmap);

	S->BackfaceEnabled = GE_TRUE;
	S->BackfaceMirrorImage = GE_TRUE;

	S->AlwaysFaceCamera = GE_FALSE;
	
	geXForm3d_SetIdentity(&(S->Transform));

	S->InternalTransformUsed = GE_FALSE;
	geXForm3d_SetIdentity(&(S->InternalTransform));

	geSprite_UpdatePosition(S);

	S->ScaleX = 1.0f;
	S->ScaleY = 1.0f;
	geSprite_UpdateCorners(S);

	S->TextureOffsetX = 0.0f;
	S->TextureOffsetY = 0.0f;
	S->TextureScaleX = 1.0f;
	S->TextureScaleY = 1.0f;
	geSprite_UpdateTextureMap(S);

	geVec3d_Clear(&(S->BoundingBoxMinCorner));
	geVec3d_Clear(&(S->BoundingBoxMaxCorner));

	S->AmbientLight.r = 0.1f;		
	S->AmbientLight.g = 0.1f;			
	S->AmbientLight.b = 0.1f;
	S->UseFillLight = GE_FALSE;
	S->UseLightFromFloor = GE_FALSE;
	S->MaximumDynamicLightsToUse = 0;

	S->LightingUsesSurfaceNormal = GE_FALSE;

	S->RGBA.a = 255.0f;
	S->BackfaceRGBA.a = 255.0f;

	S->UserData = NULL;

	S->TransformChanged = GE_TRUE;
	S->LightingChanged = GE_TRUE;

	assert( geSprite_IsValid(S) );

	geSprite_Count++;

	return S;
}	


GENESISAPI void GENESISCC geSprite_CreateRef(geSprite *S)
{
	assert( geSprite_IsValid(S) );

	S->RefCount++;
	geSprite_RefCount++;
}


GENESISAPI void GENESISCC geSprite_Destroy(geSprite **pS)
{
	geSprite *S;
	assert(  pS != NULL );
	assert( *pS != NULL );
	assert( geSprite_IsValid(*pS) );
	
	S = *pS;
	if (S->RefCount > 0)
	{
		S->RefCount --;
		geSprite_RefCount--;
		return;
	}

	if (S->Bitmap)
	{
		geBitmap_Destroy(&(S->Bitmap));
	}

	if ( (S->BackfaceBitmap) && (S->BackfaceBitmap != S->Bitmap) )
	{
		geBitmap_Destroy(&(S->BackfaceBitmap));
	}

	geRam_Free(*pS);
	geSprite_Count--;
	*pS = NULL;
}


GENESISAPI geBoolean GENESISCC geSprite_IsValid(const geSprite *S)
{
	if (S == NULL)
		return GE_FALSE;

	return GE_TRUE;
}


GENESISAPI geBitmap *GENESISCC geSprite_GetBitmap(const geSprite *S)
{
	assert ( (S->Bitmap == NULL) || (geBitmap_IsValid(S->Bitmap)) );

	return S->Bitmap;
}


GENESISAPI geBitmap *GENESISCC geSprite_GetBackfaceBitmap(const geSprite *S)
{
	assert ( (S->BackfaceBitmap == NULL) || (geBitmap_IsValid(S->BackfaceBitmap)) );

	return S->BackfaceBitmap;
}


GENESISAPI void GENESISCC geSprite_GetBackface(const geSprite *S, geBoolean *Enabled, geBoolean *MirrorImage)
{
	assert ( Enabled );
	assert ( MirrorImage );

	*Enabled = S->BackfaceEnabled;
	*MirrorImage = S->BackfaceMirrorImage;
}


GENESISAPI void GENESISCC geSprite_SetBackface(geSprite *S, const geBoolean Enabled, const geBoolean MirrorImage)
{
	assert( geSprite_IsValid(S) );

	// because lighting the backface requires a lot of extra calculations, the
	// backface doesn't have correct lighting if it has been turned off. so, if it
	// is turned on, lighting needs to be updated
	S->LightingChanged = (S->LightingChanged || ((Enabled) && (!S->BackfaceEnabled)) );

	// if the mirror imaging is changed, then update the texture map for the backface
	if (S->BackfaceMirrorImage != MirrorImage)
	{
		S->BackfaceMirrorImage = MirrorImage;
		geSprite_UpdateBackfaceTextureMap(S);
	}

	S->BackfaceEnabled = Enabled;
}


GENESISAPI void GENESISCC geSprite_GetFaceCamera(const geSprite *S, geBoolean *Enabled)
{
	assert( geSprite_IsValid(S) );
	assert( Enabled != NULL );

	*Enabled = S->AlwaysFaceCamera;
}


GENESISAPI void GENESISCC geSprite_SetFaceCamera(geSprite *S, geBoolean Enabled)
{
	assert( geSprite_IsValid(S) );

	// if facing the camera is being disabled, then force an
	// update on everything the transform affects
	if ( (S->AlwaysFaceCamera) && (!Enabled) )
	{
		S->TransformChanged = GE_TRUE;
	}

	S->AlwaysFaceCamera = Enabled;

	geSprite_UpdatePosition(S);
}


GENESISAPI void GENESISCC geSprite_GetPosition(const geSprite *S, geVec3d *Pos)
{
	assert( geSprite_IsValid(S) );
	assert( Pos != NULL );
	assert( geXForm3d_IsOrthonormal(&(S->Transform)) );

	*Pos = S->Transform.Translation;
}


GENESISAPI void GENESISCC geSprite_SetPosition(geSprite *S, const geVec3d *Pos)
{
	assert( geSprite_IsValid(S) );
	assert( Pos != NULL );
	assert( geXForm3d_IsOrthonormal(&(S->Transform)) );

	S->Transform.Translation = *Pos;

	geSprite_UpdatePosition(S);

	S->TransformChanged = GE_TRUE;
}


GENESISAPI void GENESISCC geSprite_GetTransform(const geSprite *S, geXForm3d *Transform)
{
	assert( geSprite_IsValid(S) );
	assert( Transform!= NULL );

	*Transform = S->Transform;
}


GENESISAPI void GENESISCC geSprite_SetTransform(geSprite *S, const geXForm3d *Transform)
{
	assert( geSprite_IsValid(S) );
	assert( Transform );

	S->Transform = *Transform;
	
	geSprite_UpdatePosition(S);

	S->TransformChanged = GE_TRUE;
}


GENESISAPI void GENESISCC geSprite_GetInternalTransform(const geSprite *S, geXForm3d *Transform)
{
	assert( geSprite_IsValid(S) );
	assert( Transform );

	*Transform = S->InternalTransform;
}


GENESISAPI void GENESISCC geSprite_SetInternalTransform(geSprite *S, const geXForm3d *Transform)
{
	assert( geSprite_IsValid(S) );
	assert( Transform );

	S->InternalTransform = *Transform;
	S->InternalTransformUsed = !( geXForm3d_IsIdentity(Transform) );

	geSprite_UpdatePosition(S);

	S->TransformChanged = GE_TRUE;
}


GENESISAPI void GENESISCC geSprite_GetScale(const geSprite *S, geFloat *ScaleX, geFloat *ScaleY)
{
	assert( geSprite_IsValid(S)!=GE_FALSE );

	*ScaleX = S->ScaleX;
	*ScaleY = S->ScaleY;
}


GENESISAPI void GENESISCC geSprite_SetScale(geSprite *S, geFloat ScaleX, geFloat ScaleY)
{
	assert( geSprite_IsValid(S)!=GE_FALSE );

	if ( (S->ScaleX != ScaleX) || (S->ScaleY != ScaleY) )
	{
		S->ScaleX = ScaleX;
		S->ScaleY = ScaleY;

		geSprite_UpdateCorners(S);

		S->TransformChanged = GE_TRUE;
	}
}


GENESISAPI void GENESISCC geSprite_GetExtBox(const geSprite *S, geExtBox *ExtBox)
{
	assert( geSprite_IsValid(S) );
	assert( ExtBox != NULL );
	assert( geXForm3d_IsOrthonormal(&(S->Transform)) );

	geVec3d_Add( &(S->Transform.Translation), &(S->BoundingBoxMinCorner), &(ExtBox->Min));
	geVec3d_Add( &(S->Transform.Translation), &(S->BoundingBoxMaxCorner), &(ExtBox->Max));
}


GENESISAPI void GENESISCC geSprite_GetNonWorldExtBox(const geSprite *S, geExtBox *ExtBox)
{
	assert( geSprite_IsValid(S) );
	assert( ExtBox != NULL );
	
	ExtBox->Min = S->BoundingBoxMinCorner;
	ExtBox->Max = S->BoundingBoxMaxCorner;
}


GENESISAPI void GENESISCC geSprite_SetExtBox(geSprite *S, const geExtBox *ExtBox)
{
	assert( geSprite_IsValid(S) );
	assert( geExtBox_IsValid(ExtBox) );

	S->BoundingBoxMinCorner = ExtBox->Min;
	S->BoundingBoxMaxCorner = ExtBox->Max;
}


GENESISAPI void GENESISCC geSprite_GetTextureParameters(const geSprite *S,
	geFloat *OffsetX,
	geFloat *OffsetY,
	geFloat *ScaleX,
	geFloat *ScaleY)
{
	assert( geSprite_IsValid(S) );
	assert( OffsetX != NULL );
	assert( OffsetY != NULL );
	assert( ScaleX != NULL );
	assert( ScaleY != NULL );

	*OffsetX = S->TextureOffsetX;
	*OffsetY = S->TextureOffsetY;
	*ScaleX = S->TextureScaleX;
	*ScaleY = S->TextureScaleY;
}


GENESISAPI void GENESISCC geSprite_SetTextureParameters(geSprite *S,
	geFloat OffsetX,
	geFloat OffsetY,
	geFloat ScaleX,
	geFloat ScaleY)
{
	assert( geSprite_IsValid(S) );

	S->TextureOffsetX = OffsetX;
	S->TextureOffsetY = OffsetY;
	S->TextureScaleX = ScaleX;
	S->TextureScaleY = ScaleY;

	geSprite_UpdateTextureMap(S);
}


GENESISAPI void GENESISCC geSprite_GetLightingOptions(const geSprite *S,
	geFloat *AmbientLightRed,			
	geFloat *AmbientLightGreen,			
	geFloat *AmbientLightBlue,			
	geBoolean *UseFillLight,
	geVec3d *FillLightNormal,
	geFloat *FillLightRed,				
	geFloat *FillLightGreen,				
	geFloat *FillLightBlue,				
	geBoolean *UseLightFromFloor,
	int32 *MaximumDynamicLightsToUse)
{
	assert( geSprite_IsValid(S) );

	assert( AmbientLightRed != NULL );
	assert( AmbientLightGreen != NULL );			
	assert( AmbientLightBlue != NULL );			
	assert( UseFillLight != NULL );
	assert( FillLightNormal != NULL );
	assert( FillLightRed != NULL );	
	assert( FillLightGreen != NULL );	
	assert( FillLightBlue != NULL );	
	assert( UseLightFromFloor != NULL );
	assert( MaximumDynamicLightsToUse != NULL );

	*AmbientLightRed = S->AmbientLight.r;
	*AmbientLightGreen = S->AmbientLight.g;
	*AmbientLightBlue = S->AmbientLight.b;
	*UseFillLight = S->UseFillLight;
	*FillLightNormal = S->FillLightNormal;
	*FillLightRed = S->FillLight.r;
	*FillLightGreen = S->FillLight.g;
	*FillLightBlue = S->FillLight.b;
	*UseLightFromFloor = S->UseLightFromFloor;
	*MaximumDynamicLightsToUse = S->MaximumDynamicLightsToUse;
}


GENESISAPI void GENESISCC geSprite_SetLightingOptions(geSprite *S,
	geFloat AmbientLightRed,			// 0 .. 255
	geFloat AmbientLightGreen,		// 0 .. 255
	geFloat AmbientLightBlue,			// 0 .. 255
	geBoolean UseFillLight,
	const geVec3d *FillLightNormal,
	geFloat FillLightRed,					// 0 .. 255
	geFloat FillLightGreen,				// 0 .. 255
	geFloat FillLightBlue,				// 0 .. 255
	geBoolean UseLightFromFloor,
	int32 MaximumDynamicLightsToUse	// 0 for none
)
{
	assert( geSprite_IsValid(S) );
	assert( geVec3d_IsValid(FillLightNormal) );

	S->AmbientLight.r = AmbientLightRed;
	S->AmbientLight.g = AmbientLightGreen;
	S->AmbientLight.b = AmbientLightBlue;
	S->UseFillLight = UseFillLight;
	S->FillLightNormal = *FillLightNormal;
	S->FillLight.r = FillLightRed;
	S->FillLight.g = FillLightGreen;
	S->FillLight.b = FillLightBlue;
	S->UseLightFromFloor = UseLightFromFloor;
	S->MaximumDynamicLightsToUse = MaximumDynamicLightsToUse;

	// if fill light or dynamic lights are now used, and they weren't before,
	// then the surface normal will be needed.
	//
	// if the transform has changed, then it will be updated next render, so
	// don't do it now
	//
	// if the camera always faces the camera, then this will be updated every
	// render (and using a different normal), so don't do it now.
	if ( (!S->TransformChanged) && 
			 (!S->AlwaysFaceCamera) &&
			 (!S->LightingUsesSurfaceNormal) && ((UseFillLight) || (MaximumDynamicLightsToUse > 0)) )
		geSprite_UpdateSurfaceNormal(S);

	// store whether vertexes are required for lighting (only for fill lights and dynamic lights)
	S->LightingUsesSurfaceNormal = (S->UseFillLight) || (S->MaximumDynamicLightsToUse > 0);
}


GENESISAPI void GENESISCC geSprite_GetAlpha(const geSprite *S, geFloat *Alpha, geFloat *BackfaceAlpha)
{
	assert( geSprite_IsValid(S) );
	assert( Alpha );
	assert( BackfaceAlpha );

	*Alpha = S->RGBA.a;
	*BackfaceAlpha = S->BackfaceRGBA.a;
}


GENESISAPI void GENESISCC geSprite_SetAlpha(geSprite *S, geFloat Alpha, geFloat BackfaceAlpha)
{
	assert( geSprite_IsValid(S) );

	S->RGBA.a = Alpha;
	S->BackfaceRGBA.a = BackfaceAlpha;

	// alphas cannot be less than 0 or greater than 255
	if (S->RGBA.a < 0)
		S->RGBA.a = 0.0f;
	else if (S->RGBA.a > 255.0f)
		S->RGBA.a = 255.0f;
	if (S->BackfaceRGBA.a < 0)
		S->BackfaceRGBA.a = 0.0f;
	else if (S->BackfaceRGBA.a > 255.0f)
		S->BackfaceRGBA.a = 255.0f;
}


GENESISAPI void *GENESISCC geSprite_GetUserData(const geSprite *S)
{
	assert( geSprite_IsValid(S) );

	return S->UserData;
}


GENESISAPI void GENESISCC geSprite_SetUserData(geSprite *S, void *UserData)
{
	assert( geSprite_IsValid(S) );

	S->UserData = UserData;
}


geBoolean GENESISCC geSprite_RenderPrep(geSprite *S, geWorld *World)
{
	assert( geSprite_IsValid(S) );

	// if the sprite uses a front face bitmap, add the bitmap to the world
	if (S->Bitmap)
	{
		if ( geWorld_AddBitmap(World, S->Bitmap) == GE_FALSE )
		{
			geErrorLog_AddString(-1, "Sprite_RenderPrep : World_AddBitmap", NULL);
			return GE_FALSE;
		}
	}

	// if the sprite uses a backface bitmap (and it is not the same as the front),
	// add the bitmap to the world
	if ( (S->BackfaceBitmap) && (S->BackfaceBitmap != S->Bitmap) )
	{
		if ( geWorld_AddBitmap(World, S->Bitmap) == GE_FALSE )
		{
			geErrorLog_AddString(-1, "Sprite_RenderPrep : World_AddBitmap", NULL);
			return GE_FALSE;
		}
	}
	
	return GE_TRUE;
}


geBoolean GENESISCC geSprite_RenderThroughFrustum(geSprite *S, geEngine *Engine, geWorld *World, geCamera *Camera, Frustum_Info *FInfo)
{
	int i;
	geBoolean Render;
	geBoolean RenderBackface;

	assert( geSprite_IsValid(S) );

	// if the sprite always faces the camera, the surface normal and lighting
	// may need to be updated
	if (S->AlwaysFaceCamera)
	{
		// vertexes are needed both to build the final screen poly which is rendered,
		// but also for lighting
		geSprite_UpdateVertexesToFaceCamera(S, Camera);

		// only modify the surface normal if lighting needs it
		if (S->LightingUsesSurfaceNormal)
		{
			geSprite_UpdateSurfaceNormalToFaceCamera(S, Camera);
			S->LightingChanged = GE_TRUE;
		}

		// if the sprite uses ambient light from the floor and its transform has
		// changed (transform includes location), then update the lighting
		else if ( (S->TransformChanged) && (S->UseLightFromFloor) )
		{
			S->LightingChanged = GE_TRUE;
		}
	}

	// otherwise only update the vertexes if the transform has changed
	else if (S->TransformChanged)
	{
		// vertexes are needed both to build the final screen poly which is rendered,
		// but also for lighting
		geSprite_UpdateVertexes(S);

		// update the surface normal
		// this is needed to determine lighting and which face is being viewed
		geSprite_UpdateSurfaceNormal(S);

		// if the sprite uses the surface normal to light its faces, then
		// update the surface normal and update the lighting
		//
		// if the sprite uses ambient light from the floor and its transform has
		// changed (transform includes location), then update the lighting
		if ( (S->LightingUsesSurfaceNormal) || (S->UseLightFromFloor) )
		{
			S->LightingChanged = GE_TRUE;
		}

		S->TransformChanged = GE_FALSE;
	}

	// generate the frustum clipped screen poly based on the vertexes for the camera
	geSprite_CreateFrustumClippedScreenPoly(S, Camera, FInfo, &Render, &RenderBackface);

	// only render if there is something to render
	if (Render)
	{
		// moved inside here because there is no sense in dynamically
		// lighting the vertexes if they won't be drawn.
		// update the lighting only if lighting has changed or
		// lighting uses dynamic lights (which may change)
		if ( (S->LightingChanged) || (S->MaximumDynamicLightsToUse > 0) )
		{
			geSprite_UpdateLighting(S, World);
			S->LightingChanged = GE_FALSE;
		}

		// render the poly using the front or backface data
		if (RenderBackface)
		{
			// add the lighting data to the poly
			for (i = 0; i < FrustumNumClippedTexturedLitVertices; i++)
			{
				FrustumClippedTexturedLitVertexes[i].r = S->BackfaceRGBA.r;
				FrustumClippedTexturedLitVertexes[i].g = S->BackfaceRGBA.g;
				FrustumClippedTexturedLitVertexes[i].b = S->BackfaceRGBA.b;
				FrustumClippedTexturedLitVertexes[i].a = S->BackfaceRGBA.a;
			}

			// render the poly using the backface bitmap
			geEngine_RenderPoly(Engine, (GE_TLVertex*)FrustumClippedTexturedLitVertexes, FrustumNumClippedTexturedLitVertices, S->BackfaceBitmap, 0);
		}
		else
		{
			// add the lighting data to the poly
			for (i = 0; i < FrustumNumClippedTexturedLitVertices; i++)
			{
				FrustumClippedTexturedLitVertexes[i].r = S->RGBA.r;
				FrustumClippedTexturedLitVertexes[i].g = S->RGBA.g;
				FrustumClippedTexturedLitVertexes[i].b = S->RGBA.b;
				FrustumClippedTexturedLitVertexes[i].a = S->RGBA.a;
			}

			// render the poly using the front bitmap
			geEngine_RenderPoly(Engine, (GE_TLVertex*)FrustumClippedTexturedLitVertexes, FrustumNumClippedTexturedLitVertices, S->Bitmap, 0);
		}
	}
	
	return GE_TRUE;
}