/****************************************************************************************/
/*  Genesis.h                                                                           */
/*                                                                                      */
/*  Description: The master header for Genesis                                          */
/*                                                                                      */
/*  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.                                                                  */
/*                                                                                      */
/*  The Original Code is Genesis3D, released March 25, 1999.                            */
/*  Genesis3D Version 1.1 released November 15, 1999                                 */
/*  Copyright (C) 1999 WildTangent, Inc. All Rights Reserved           */
/*                                                                                      */
/****************************************************************************************/
#ifndef GENESIS_H
#define GENESIS_H

#include "BaseType.h"
#include "Vec3d.h"
#include "XForm3d.h"
#include "GETypes.h"
#include "ExtBox.h"
#include "vfile.h"
#include "Bitmap.h"

#ifdef __cplusplus
extern "C" {
#endif

//================================================================================
//	Constants / Defines / TypDefs
//================================================================================

typedef struct		geEngine			geEngine;

typedef struct		geDriver_System		geDriver_System;
typedef struct		geDriver			geDriver;
typedef struct		geDriver_Mode		geDriver_Mode;

typedef struct		geSound_System		geSound_System;
typedef struct		geSound_Cfg			geSound_Cfg;
typedef struct		geSound_Def			geSound_Def;
typedef struct		geSound				geSound;
										
typedef struct		geActor				geActor;
typedef struct		geActor_Def			geActor_Def;		// the definition of an actor's geometry/bone structure

typedef struct		geWorld				geWorld;

typedef struct		geWorld_Model		geWorld_Model;

typedef struct		geEntity			geEntity;
typedef struct		geEntity_EntitySet	geEntity_EntitySet;

typedef struct		geCamera			geCamera;

typedef struct		geCSNetMgr			geCSNetMgr;

typedef struct		gePoly				gePoly;

typedef struct		geLight				geLight;			

typedef struct		geFog				geFog;

typedef struct		geMesh_Def			geMesh_Def;			// Mesh def
typedef struct		geMesh				geMesh;				

#define GE_VERSION_MAJOR		(1UL)
#define GE_VERSION_MINOR		(3UL)
#define GE_VERSION_MINOR_MIN	(3UL)

#define GE_VERSION_MAJOR_SHIFT	(16)
#define GE_VERSION_MAJOR_MASK	((uint32)0xFFFF0000)

#define GE_VERSION				( (GE_VERSION_MAJOR << GE_VERSION_MAJOR_SHIFT) + GE_VERSION_MINOR )

// From here down, still needs to be fixed up for July4
typedef	struct		GE_ModelMotion		GE_ModelMotion;
typedef float		GE_TimeType;

// Polys
typedef enum
{
	GE_TEXTURED_POLY,
	GE_GOURAUD_POLY,
	GE_TEXTURED_POINT					
} gePoly_Type;

// Poly Fx flags
#define	GE_RENDER_DO_NOT_OCCLUDE_OTHERS	(1<<0)			// Poly will not occlude others
#define GE_RENDER_DO_NOT_OCCLUDE_SELF	(1<<1)			// Renders under any condition.  Useful for halos, etc...
#define	GE_RENDER_BACKFACED				(1<<2)			// Poly should be backfaced from the Camera's Pov
#define GE_RENDER_DEPTH_SORT_BF			(1<<3)			// Sorts relative to camera position, from back to front
#define GE_RENDER_CLAMP_UV				(1<<4)			// Clamp UV's in both directions
#define GE_RENDER_NO_FOG				(1<<5)
#define GE_RENDER_NO_CLIP				(1<<6)

// World Add flags
#define GE_WORLD_RENDER				(1<<0)
#define GE_WORLD_COLLIDE			(1<<1)



#ifndef GE_CONTENTS_TYPES
#define GE_CONTENTS_TYPES

//
// Content types in GE_Contents structure (multiple contents can be mixed...)
//
//*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=
//	IF THESE FLAGS CHANGE, THEY MUST CHANGE IN GBSPFILE.H in Genesis AND GBSPLIB, and Genesis.H!!!!!
//*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=
#define GE_CONTENTS_SOLID			(1<<0)		// Solid (Visible)
#define GE_CONTENTS_WINDOW			(1<<1)		// Window (Visible)
#define GE_CONTENTS_EMPTY			(1<<2)		// Empty but Visible (water, lava, etc...)

#define GE_CONTENTS_TRANSLUCENT		(1<<3)		// Vis will see through it
#define GE_CONTENTS_WAVY			(1<<4)		// Wavy (Visible)
#define GE_CONTENTS_DETAIL			(1<<5)		// Won't be included in vis oclusion

#define GE_CONTENTS_CLIP			(1<<6)		// Structural but not visible
#define GE_CONTENTS_HINT			(1<<7)		// Primary splitter (Non-Visible)
#define GE_CONTENTS_AREA			(1<<8)		// Area seperator leaf (Non-Visible)

#define GE_CONTENTS_FLOCKING		(1<<9)
#define GE_CONTENTS_SHEET			(1<<10)
#define GE_CONTENTS_AIR				(1<<11)		// No brush lives in this leaf
#define GE_RESERVED4				(1<<12)
#define GE_RESERVED5				(1<<13)
#define GE_RESERVED6				(1<<14)
#define GE_RESERVED7				(1<<15)

// 16-31 reserved for user contents
#define GE_CONTENTS_USER1			(1<<16)
#define GE_CONTENTS_USER2			(1<<17)
#define GE_CONTENTS_USER3			(1<<18)
#define GE_CONTENTS_USER4			(1<<19)
#define GE_CONTENTS_USER5			(1<<20)
#define GE_CONTENTS_USER6			(1<<21)
#define GE_CONTENTS_USER7			(1<<22)
#define GE_CONTENTS_USER8			(1<<23)
#define GE_CONTENTS_USER9			(1<<24)
#define GE_CONTENTS_USER10			(1<<25)
#define GE_CONTENTS_USER11			(1<<26)
#define GE_CONTENTS_USER12			(1<<27)
#define GE_CONTENTS_USER13			(1<<28)
#define GE_CONTENTS_USER14			(1<<29)
#define GE_CONTENTS_USER15			(1<<30)
#define GE_CONTENTS_USER16			(1<<31)
// 16-31 reserved for user contents


// These contents are all solid types
#define GE_CONTENTS_SOLID_CLIP		(GE_CONTENTS_SOLID | GE_CONTENTS_WINDOW | GE_CONTENTS_CLIP)
#define GE_CONTENTS_CANNOT_OCCUPY	GE_CONTENTS_SOLID_CLIP

// These contents are all visible types
#define GE_VISIBLE_CONTENTS			(	GE_CONTENTS_SOLID | \
										GE_CONTENTS_EMPTY | \
										GE_CONTENTS_WINDOW | \
										GE_CONTENTS_WAVY)

#endif
//*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=
//*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=

// NOTES - Fills in first Model/Mesh hit
// Exceptions:
//		Returns the last solid model hit...
typedef struct
{
	geMesh			*Mesh;
	geWorld_Model	*Model;
	geActor			*Actor;
	int32			Contents;
} GE_Contents;

typedef geBoolean GE_CollisionCB(geWorld_Model *Model, geActor *Actor, void *Context);

// Collision
typedef struct
{
	geVec3d	Normal;									// Orientation of plane
	geFloat	Dist;									// Distance from origin
} GE_Plane;

typedef struct
{
	geWorld_Model	*Model;							// Pointer to what model was hit (if any)
	geMesh			*Mesh;							// Pointer to what mesh was hit (if any)
	geActor			*Actor;							// Pointer to what actor was hit (if any)	
	geVec3d			Impact;							// Impact Point
	geFloat			Ratio;							// Percent from 0 to 1.0, how far along the line for the impact point
	GE_Plane		Plane;							// Impact Plane
} GE_Collision;

// If these render states change, they must change in DCommon.h too!!!
// These are still under construction, and are for debug purposes only.
// They are merely means of overriding ways the engine normally renders primitives, etc...
//
//	RenderState States
//
#define GE_RENDERSTATE_ZWRITE		0		// Z Writes
#define GE_RENDERSTATE_ZCMP			1		// Z Compares
#define GE_RENDERSTATE_BILINEAR		2		// Bilinear filtering
#define	GE_RENDERSTATE_ANTI_ALIAS	3		// Anti-Aliasing
#define GE_RENDERSTATE_POLYMODE		4		// Normal, Gouraud only, Lines only, etc

//
//	RenderState Flags
//
#define GE_RENDERFLAG_OFF		0
#define GE_RENDERFLAG_ON		1

//
//  PolyMode flags	(A method to override how polys are drawn for debugging purposes...)
//
#define GE_POLYMODE_NORMAL		1			// Draw as is
#define GE_POLYMODE_GOURAUD		2			// Gouraud only
#define GE_POLYMODE_LINES		3			// Outlines only

//================================================================================
//	Engine Management functions
//================================================================================


#ifdef _INC_WINDOWS	
	// Windows.h must be included before genesis.h for this api to be exposed.
	

GENESISAPI	geEngine	*geEngine_CreateWithVersion(HWND hWnd, const char *AppName, const char *DriverDirectory, uint32 Version);
							// use geEngine_Create, rather than calling this directly.

#define geEngine_Create( hWnd, AppName, DriverDirectory)   geEngine_CreateWithVersion(hWnd,AppName,DriverDirectory,GE_VERSION)

#endif

GENESISAPI void			geEngine_Free(geEngine *Engine);

GENESISAPI geBoolean	geEngine_AddWorld(geEngine *Engine, geWorld *World);
GENESISAPI geBoolean	geEngine_RemoveWorld(geEngine *Engine, geWorld *World);

GENESISAPI geBoolean	geEngine_AddBitmap(geEngine *Engine, geBitmap *Bitmap);
GENESISAPI geBoolean	geEngine_RemoveBitmap(geEngine *Engine, geBitmap *Bitmap);

GENESISAPI geDriver_System *geEngine_GetDriverSystem(geEngine *Engine);

GENESISAPI geBoolean	geEngine_SetDriverAndMode(	geEngine *Engine, 
													geDriver *Driver, 
													geDriver_Mode *DriverMode);

GENESISAPI geBoolean	geEngine_ShutdownDriver(geEngine *Engine);

GENESISAPI geBoolean	geEngine_BeginFrame(geEngine *Engine, geCamera *Camera, geBoolean ClearScreen);
GENESISAPI geBoolean	geEngine_EndFrame(geEngine *Engine);

GENESISAPI geBoolean	geEngine_RenderWorld(geEngine *Engine, geWorld *World, geCamera *Camera, geFloat Time);
GENESISAPI geBoolean	geEngine_Printf(geEngine *Engine, int32 x, int32 y, const char *String, ...);

GENESISAPI void			GENESISCC geEngine_RenderPoly(const geEngine *Engine, const GE_TLVertex *Points, int NumPoints, const geBitmap *Texture, uint32 Flags);
							//RenderPoly : if Texture is null, we Gouraud shade

GENESISAPI void			GENESISCC geEngine_RenderPolyArray(const geEngine *Engine, const GE_TLVertex ** pPoints, int * pNumPoints, int NumPolys, 
								const geBitmap *Texture, uint32 Flags);

GENESISAPI geBoolean GENESISCC geEngine_DrawAlphaBitmap(	
		geEngine * Engine,
		geBitmap * pBitmap,
		geVec3d * VertUVArray,
		geCamera * ClipCamera,	// if null, uses full screen
		GE_Rect * PixelRect,		// pixels in the "camera" view
		GE_Rect * PercentRect,	// percent of the "camera" view
		geFloat   Alpha,
		GE_RGBA * RGBA_Array
		);

GENESISAPI geBoolean	GENESISCC geEngine_DrawBitmap(const geEngine *Engine,const geBitmap *Bitmap,
								const geRect * Source, uint32 x, uint32 y);
							//DrawBitmap & RenderPoly : must Engine_AddBitmap first!


GENESISAPI void			geEngine_FillRect(geEngine *Engine, const GE_Rect *Rect, const GE_RGBA *Color);

GENESISAPI geBoolean	geEngine_SetGamma(geEngine *Engine, geFloat Gamma);
GENESISAPI geBoolean	geEngine_GetGamma(geEngine *Engine, geFloat *Gamma);

GENESISAPI geBoolean	geEngine_SetFogEnable(geEngine *Engine, geBoolean Enable, geFloat r, geFloat g, geFloat b, geFloat Start, geFloat End);
						// enables/disables distance fogging.  (based on Enable)
						//  r,g,b is the color of the fog
						//  Start is how far out from the camera is not fogged - this is where the fog begins
						//  End is how far out from the camera where the fog fully obscures things
				

GENESISAPI geBoolean	geEngine_ScreenShot(geEngine *Engine, const char *FileName);

GENESISAPI void			geEngine_EnableFrameRateCounter(geEngine *Engine, geBoolean Enabled);

GENESISAPI geBoolean	geEngine_Activate(geEngine *Engine, geBoolean bActive);

#ifdef _INC_WINDOWS
	// Windows.h must be included before genesis.h for this api to be exposed.
GENESISAPI geBoolean	geEngine_UpdateWindow(geEngine *Engine);
#endif

// geDriver
GENESISAPI geDriver		*geDriver_SystemGetNextDriver(geDriver_System *DriverSystem, geDriver *Start);
GENESISAPI geDriver_Mode *geDriver_GetNextMode(geDriver *Driver, geDriver_Mode *Start);
GENESISAPI geBoolean	geDriver_GetName(geDriver *Driver, const char **Name);
GENESISAPI geBoolean	geDriver_ModeGetName(geDriver_Mode *Mode, const char **Name);
GENESISAPI geBoolean	geDriver_ModeGetWidthHeight(geDriver_Mode *Mode, int32 *Width, int32 *Height);

//================================================================================
//	Sound Management functions
//================================================================================
#ifdef _INC_WINDOWS
	// Windows.h must be included before genesis.h for this api to be exposed.
GENESISAPI 	geSound_System *geSound_CreateSoundSystem(HWND hWnd);
#endif


GENESISAPI void			geSound_DestroySoundSystem(geSound_System *Sound);


GENESISAPI geSound_Def	   *geSound_LoadSoundDef(geSound_System *SoundS, geVFile *File);
GENESISAPI void				geSound_FreeSoundDef(geSound_System *SoundS, geSound_Def *SoundDef);

GENESISAPI geSound		   *geSound_PlaySoundDef(geSound_System *SoundS, 
									geSound_Def *SoundDef, 
									geFloat Volume, 
									geFloat Pan, 
									geFloat Frequency, 
									geBoolean Loop);
GENESISAPI geBoolean		geSound_StopSound(geSound_System *SoundS, geSound *Sound);
GENESISAPI geBoolean		geSound_ModifySound(geSound_System *SoundS, 
									geSound *Sound, 
									geFloat Volume, 
									geFloat Pan, 
									geFloat Frequency);
GENESISAPI geBoolean		geSound_SoundIsPlaying(geSound_System *SoundS, geSound *Sound);
GENESISAPI geBoolean		geSound_SetMasterVolume( geSound_System *SoundS, geFloat Volume );

GENESISAPI void geSound3D_GetConfig(
			const geWorld *World, 
			const geXForm3d *CameraTransform, 
			const geVec3d *SoundPos, 
			geFloat Min, 
			geFloat Ds,
			geFloat *Volume,
			geFloat *Pan,
			geFloat *Frequency);

GENESISAPI	void geSound3D_GetConfigIgnoreObstructions(
		const geWorld *World, 
		const geXForm3d *MXForm, 
		const geVec3d *SndPos, 
		geFloat Min, 
		geFloat Ds,
		geFloat *Volume,
		geFloat *Pan,
		geFloat *Frequency);

//	Added 11/08/1999 Ed Averill API call to return DSOUND object
GENESISAPI void *geSound_GetDSound(void);
//	End 11/08/1999 modification

//================================================================================
//  Path Support
//================================================================================
#include "Path.h"
//================================================================================
//  Motion Support
//================================================================================
#include "Motion.h"
//================================================================================
//  Actor Support
//================================================================================
#include "Actor.h"

//MRB BEGIN
//geSprite
//================================================================================
//  Sprite Support
//================================================================================
#include "Sprite.h"
//MRB END


//================================================================================
//	World Management functions
//================================================================================
GENESISAPI geWorld		*geWorld_Create(geVFile *File);
GENESISAPI void			geWorld_Free(geWorld *World);

// World Actors
GENESISAPI geBoolean	geWorld_RemoveActor    (geWorld *World, geActor *Actor);
GENESISAPI geBoolean    geWorld_AddActor       (geWorld *World, geActor *Actor, uint32 Flags, uint32 UserFlags);
GENESISAPI geBoolean	geWorld_SetActorFlags  (geWorld *World, geActor *Actor, uint32 Flags);

//MRB BEGIN
//geSprite
GENESISAPI geBoolean	geWorld_RemoveSprite    (geWorld *World, geSprite *Sprite);
GENESISAPI geBoolean	geWorld_AddSprite       (geWorld *World, geSprite *Sprite, uint32 Flags, uint32 UserFlags);
GENESISAPI geBoolean	geWorld_SetSpriteFlags  (geWorld *World, geSprite *Sprite, uint32 Flags);
//MRB END

// World Bitmaps
GENESISAPI geBoolean	geWorld_AddBitmap(		geWorld *World, geBitmap *Bitmap);
GENESISAPI geBoolean	geWorld_RemoveBitmap(	geWorld *World, geBitmap *Bitmap);
GENESISAPI geBoolean	geWorld_HasBitmap(const geWorld *World, const geBitmap *Bitmap);
GENESISAPI geBitmap		*geWorld_GetBitmapByName(geWorld *World, const char *BitmapName);
GENESISAPI geBoolean	geWorld_BitmapIsVisible(geWorld *World, const geBitmap *Bitmap);

// World BModels
GENESISAPI geWorld_Model	*geWorld_GetNextModel(geWorld *World, geWorld_Model *Start);
GENESISAPI geBoolean		geWorld_SetModelXForm(geWorld *World, geWorld_Model *Model, const geXForm3d *XForm);
GENESISAPI geBoolean		geWorld_GetModelXForm(const geWorld *World, const geWorld_Model *Model, geXForm3d *XForm);
GENESISAPI geBoolean		geWorld_OpenModel(geWorld *World, geWorld_Model *Model, geBoolean Open);
GENESISAPI geBoolean		geWorld_GetModelRotationalCenter(const geWorld *World, const geWorld_Model *Model, geVec3d *Center);
GENESISAPI geBoolean		geWorld_ModelGetBBox(const geWorld *World, const geWorld_Model *Model, geVec3d *Mins, geVec3d *Maxs);
GENESISAPI geMotion *		geWorld_ModelGetMotion(geWorld_Model *Model);
//	eaa3 07/28/2000

GENESISAPI void geWorld_ModelGetCenter(geWorld_Model *Model, geVec3d *Center);

GENESISAPI void			*geWorld_ModelGetUserData(const geWorld_Model *Model);
GENESISAPI void			geWorld_ModelSetUserData(geWorld_Model *Model, void *UserData);
GENESISAPI void			geWorld_ModelSetFlags(geWorld_Model *Model, uint32 ModelFlags);
GENESISAPI uint32		geWorld_ModelGetFlags(geWorld_Model *Model);

// World Lights
GENESISAPI geLight		*geWorld_AddLight(geWorld *World);
GENESISAPI void			geWorld_RemoveLight(geWorld *World, geLight *Light);
GENESISAPI geBoolean	geWorld_SetLightAttributes(	geWorld *World,
										geLight		*Light, 
										const		geVec3d *Pos, 
										const		GE_RGBA *RGBA, 
										geFloat		Radius,
										geBoolean	CastShadow);
GENESISAPI geBoolean	geWorld_SetLTypeTable(geWorld *World, int32 LType, const char *Table);

// World fog
GENESISAPI geFog		*geWorld_AddFog(geWorld *World);
GENESISAPI geBoolean	geWorld_RemoveFog(geWorld *World, geFog *Fog);

GENESISAPI geBoolean geFog_SetAttributes(	geFog			*Fog, 
											const geVec3d	*Pos, 
											GE_RGBA			*Color,
											geFloat			LightBrightness, 
											geFloat			VolumeBrightness, 
											geFloat			VolumeRadius);

// World Classes/Entities
GENESISAPI geEntity_EntitySet *geWorld_GetEntitySet(geWorld *World, const char *ClassName);
GENESISAPI geEntity		*geEntity_EntitySetGetNextEntity(geEntity_EntitySet *EntitySet, geEntity *Entity);
GENESISAPI void			*geEntity_GetUserData(geEntity *Entity);
GENESISAPI void			geEntity_GetName(const geEntity *Entity, char *Buff, int MaxLen);

// World collision
GENESISAPI geBoolean	geWorld_ModelCollision(	geWorld			*World, 
												geWorld_Model	*Model, 
												const geXForm3d	*DXForm, 
												GE_Collision	*Collision);
GENESISAPI geBoolean geWorld_TestModelMove(	geWorld			*World, 
											geWorld_Model	*Model, 
											const geXForm3d	*DXForm, 
											const geVec3d	*Mins, const geVec3d *Maxs,
											const geVec3d	*In, geVec3d *Out);

GENESISAPI geBoolean geWorld_Collision(	geWorld *World,				// World to collide with
										const geVec3d *Mins,		// Mins of object (in object-space).  This CAN be NULL
										const geVec3d *Maxs,		// Maxs of object (in object-space).  This CAN be NULL
										const geVec3d *Front,		// Front of line (in world-space)
										const geVec3d *Back,		// Back of line (in world-space)
										uint32 Contents,			// Contents to collide with (use GE_CONTENTS_SOLID_CLIP for default)
										uint32 CollideFlags,		// To mask out certain object types (GE_COLLIDE_ALL, etc...)
										uint32 UserFlags,			// To mask out actors (refer to geActor_SetUserFlags)
										GE_CollisionCB *CollisionCB, // A callback to allow user to reject collisions with certain objects)
										void *Context,				// User data passed through above callback
										GE_Collision *Col);			// Structure filled with info about what was collided with
	// NOTE - Mins/Maxs CAN be NULL.  If you are just testing a point, then use NULL (it's faster!!!).

GENESISAPI geBoolean geWorld_GetContents(geWorld *World, const geVec3d *Pos, const geVec3d *Mins, const geVec3d *Maxs, uint32 Flags, uint32 UserFlags, GE_CollisionCB *CollisionCB, void *Context, GE_Contents *Contents);
// changed texture name
GENESISAPI geBoolean geWorld_GetTextureName(geWorld *World, const geVec3d *Pos, const geVec3d *Mins, const geVec3d *Maxs, char *TexName);
// end change texture name

// World Polys
GENESISAPI	gePoly *geWorld_AddPolyOnce(geWorld *World, 
										GE_LVertex *Verts, 
										int32 NumVerts, 
										geBitmap *Bitmap,
										gePoly_Type Type, 
										uint32 RenderFlags,
										geFloat Scale);
GENESISAPI	gePoly *geWorld_AddPoly(geWorld *World, 
									GE_LVertex *Verts, 
									int32 NumVerts, 
									geBitmap *Bitmap,
									gePoly_Type Type,
									uint32 RenderFlags,
									geFloat Scale);

GENESISAPI	void geWorld_RemovePoly(geWorld *World, gePoly *Poly);
GENESISAPI	geBoolean gePoly_GetLVertex(gePoly *Poly, int32 Index, GE_LVertex *LVert);
GENESISAPI	geBoolean gePoly_SetLVertex(gePoly *Poly, int32 Index, const GE_LVertex *LVert);

// World visibility
GENESISAPI geBoolean	geWorld_GetLeaf(const geWorld *World, const geVec3d *Pos, int32 *Leaf);
GENESISAPI geBoolean	geWorld_MightSeeLeaf(const geWorld *World, int32 Leaf);

GENESISAPI geBoolean	geWorld_LeafMightSeeLeaf(const geWorld *World, int32 Leaf1, int32 Leaf2, uint32 VisFlags);
	// Checks to see if Leaf1 can see Leaf2
	// Currently VisFlags is not used yet.  It could be used for checking against areas, etc...
	// Eventually you could also pass in a VisObject, that is manipulated with a camera...

GENESISAPI geBoolean GENESISCC geWorld_IsActorPotentiallyVisible(const geWorld *World, const geActor *Actor, const geCamera *Camera);

//MRB BEGIN
//geSprite
GENESISAPI geBoolean GENESISCC geWorld_IsSpritePotentiallyVisible(const geWorld *World, const geSprite *Sprite, const geCamera *Camera);

//================================================================================
//	Camera Management functions
//================================================================================

GENESISAPI geCamera			*GENESISCC geCamera_Create(geFloat Fov, const geRect *Rect);
GENESISAPI void				GENESISCC geCamera_Destroy(geCamera **pCamera);
GENESISAPI void				GENESISCC geCamera_SetZScale(geCamera *Camera, geFloat ZScale);
GENESISAPI geFloat			GENESISCC geCamera_GetZScale(const geCamera *Camera);
GENESISAPI void				GENESISCC geCamera_SetFarClipPlane(geCamera *Camera, geBoolean Enable, geFloat ZFar);
							// sets a far clipping plane.  The world and objects aren't drawn if they lie beyond ZFar. 
							// Zfar is the distance out from the camera.
							// Polygons crossing the line are not nesessarily clipped exactly to the line.
GENESISAPI void				GENESISCC geCamera_GetFarClipPlane(const geCamera *Camera, geBoolean *Enable, geFloat *ZFar);
GENESISAPI void				GENESISCC geCamera_SetAttributes(geCamera *Camera,geFloat Fov, const geRect *Rect);
GENESISAPI void				GENESISCC geCamera_GetClippingRect(const geCamera *Camera, geRect *Rect);

GENESISAPI void				GENESISCC geCamera_ScreenPointToWorld(const geCamera	*Camera,
										int32			 ScreenX,
										int32			 ScreenY,
										geVec3d			*Vector	);
GENESISAPI void	GENESISCC geCamera_Project(const geCamera	*Camera, 
										const geVec3d	*PointInCameraSpace, 
										geVec3d			*ProjectedPoint);
GENESISAPI void GENESISCC geCamera_Transform(const geCamera *Camera, 
										const geVec3d *WorldSpacePoint, 
										  geVec3d *CameraSpacePoint);

GENESISAPI void GENESISCC geCamera_TransformArray(const geCamera *Camera, 
										const geVec3d *WorldSpacePointPtr, 
										      geVec3d *CameraSpacePointPtr,
											int count);

GENESISAPI void GENESISCC geCamera_TransformAndProject(const geCamera *Camera,
										const	geVec3d *Point, 
												geVec3d *ProjectedPoint);

GENESISAPI void GENESISCC geCamera_TransformAndProjectArray(const geCamera *Camera, 
										const geVec3d *WorldSpacePointPtr, 
										      geVec3d *ProjectedSpacePointPtr,
											int count);
	
GENESISAPI void GENESISCC geCamera_TransformAndProjectL(const geCamera *Camera,
										const GE_LVertex *Point, 
											GE_TLVertex *ProjectedPoint);
		
GENESISAPI void GENESISCC geCamera_TransformAndProjectLArray(const geCamera *Camera, 
										const GE_LVertex *WorldSpacePointPtr, 
										      GE_TLVertex *ProjectedSpacePointPtr,
											int count);


GENESISAPI geBoolean		GENESISCC geCamera_SetWorldSpaceXForm(geCamera *Camera, const geXForm3d *XForm);
GENESISAPI geBoolean		GENESISCC geCamera_SetWorldSpaceVisXForm(geCamera *Camera, const geXForm3d *XForm);
GENESISAPI const geXForm3d	*GENESISCC geCamera_GetWorldSpaceXForm( const geCamera *Camera);
GENESISAPI const geXForm3d * GENESISCC geCamera_GetCameraSpaceXForm( const geCamera *Camera);
GENESISAPI const geXForm3d * GENESISCC geCamera_GetWorldSpaceVisXForm( const geCamera *Camera);
GENESISAPI geBoolean GENESISCC geCamera_ConvertWorldSpaceToCameraSpace(const geXForm3d *WXForm, geXForm3d *CXForm);
GENESISAPI const geVec3d *GENESISCC geCamera_GetPov(const geCamera *Camera);



GENESISAPI void		GENESISCC geTClip_SetupEdges(geEngine *Engine,
						geFloat	LeftEdge, 
						geFloat RightEdge,
						geFloat TopEdge ,
						geFloat BottomEdge,
						geFloat BackEdge);

GENESISAPI geBoolean	GENESISCC geTClip_Push(void);
GENESISAPI geBoolean	GENESISCC geTClip_Pop(void);

GENESISAPI geBoolean	GENESISCC geTClip_SetTexture(const geBitmap * Bitmap);
GENESISAPI void		GENESISCC geTClip_Triangle(const GE_LVertex TriVertex[3]);

GENESISAPI void		GENESISCC geTClip_SetRenderFlags(uint32 newflags);	// LA
GENESISAPI void		GENESISCC geTClip_UnclippedTriangle(const GE_LVertex TriVertex[3]);	// LA


//================================================================================
// NetPlay Management functions
//================================================================================

typedef uint32				geCSNetMgr_NetID;
#define	MAX_CLIENT_NAME		256

// Types for messages received from GE_ReceiveSystemMessage
typedef enum 
{
	NET_MSG_NONE,					// No msg
	NET_MSG_USER,					// User message
	NET_MSG_CREATE_CLIENT,			// A new client has joined in
	NET_MSG_DESTROY_CLIENT,			// An existing client has left
	NET_MSG_HOST,					// We are the server now
	NET_MSG_SESSIONLOST,			// Connection was lost
	NET_MSG_SERVER_ID,				// Internal, for hand shaking process
} geCSNetMgr_NetMsgType;


typedef struct
{
	char				Name[MAX_CLIENT_NAME];
	geCSNetMgr_NetID	Id;
} geCSNetMgr_NetClient;

#ifdef _INC_WINDOWS
	// Windows.h must be included before genesis.h for this api to be exposed.
	typedef struct geCSNetMgr_NetSession
	{
		char		SessionName[200];					// Description of Service provider
		GUID		Guid;								// Service Provider GUID
	} geCSNetMgr_NetSession;
GENESISAPI 	geBoolean		GENESISCC geCSNetMgr_FindSession(geCSNetMgr *M, const char *IPAdress, geCSNetMgr_NetSession **SessionList, int32 *SessionNum );
GENESISAPI 	geBoolean		GENESISCC geCSNetMgr_JoinSession(geCSNetMgr *M, const char *Name, const geCSNetMgr_NetSession* Session);
#endif


GENESISAPI geCSNetMgr	*	GENESISCC geCSNetMgr_Create(void);
GENESISAPI void				GENESISCC geCSNetMgr_Destroy(geCSNetMgr **ppM);
GENESISAPI geBoolean		GENESISCC geCSNetMgr_ReceiveFromServer(geCSNetMgr *M, geCSNetMgr_NetMsgType *Type, int32 *Size, uint8 **Data);
GENESISAPI geBoolean		GENESISCC geCSNetMgr_ReceiveFromClient(geCSNetMgr *M, geCSNetMgr_NetMsgType *Type, geCSNetMgr_NetID *IdClient, int32 *Size, uint8 **Data);
GENESISAPI geBoolean		GENESISCC geCSNetMgr_ReceiveSystemMessage(geCSNetMgr *M, geCSNetMgr_NetID IdFor, geCSNetMgr_NetMsgType *Type, geCSNetMgr_NetClient *Client);
GENESISAPI geBoolean		GENESISCC geCSNetMgr_ReceiveAllMessages(geCSNetMgr *M, geCSNetMgr_NetID *IdFrom, geCSNetMgr_NetID *IdTo, geCSNetMgr_NetMsgType *Type, int32 *Size, uint8 **Data);
GENESISAPI geCSNetMgr_NetID	GENESISCC geCSNetMgr_GetServerID(geCSNetMgr *M);
GENESISAPI geCSNetMgr_NetID	GENESISCC geCSNetMgr_GetOurID(geCSNetMgr *M);
GENESISAPI geCSNetMgr_NetID	GENESISCC geCSNetMgr_GetAllPlayerID(geCSNetMgr *M);
GENESISAPI geBoolean		GENESISCC geCSNetMgr_WeAreTheServer(geCSNetMgr *M);
GENESISAPI geBoolean		GENESISCC geCSNetMgr_StartSession(geCSNetMgr *M, const char *SessionName, const char *PlayerName );
GENESISAPI geBoolean		GENESISCC geCSNetMgr_StopSession(geCSNetMgr *M);
GENESISAPI geBoolean		GENESISCC geCSNetMgr_SendToServer(geCSNetMgr *M, geBoolean Guaranteed, uint8 *Data, int32 DataSize);
GENESISAPI geBoolean		GENESISCC geCSNetMgr_SendToClient(geCSNetMgr *M, geCSNetMgr_NetID To, geBoolean Guaranteed, uint8 *Data, int32 DataSize);

#ifdef __cplusplus
}
#endif

#endif