// Copyright (C) 2007 Id Software, Inc.
//

#ifndef __RENDERWORLD_H__
#define __RENDERWORLD_H__

/*
===============================================================================

	Render World

===============================================================================
*/

#include "Material.h"
#include "../decllib/declDecal.h"

// shader parms
const int MAX_GLOBAL_SHADER_PARMS		= 4;	// Rarely used so lowered this from 12

const int SHADERPARM_RED				= 0;
const int SHADERPARM_GREEN				= 1;
const int SHADERPARM_BLUE				= 2;
const int SHADERPARM_ALPHA				= 3;
const int SHADERPARM_TIMESCALE			= 3;
const int SHADERPARM_TIMEOFFSET			= 4;
const int SHADERPARM_DIVERSITY			= 5;	// random between 0.0 and 1.0 for some effects (muzzle flashes, etc)
const int SHADERPARM_MODE				= 7;	// for selecting which shader passes to enable
const int SHADERPARM_TIME_OF_DEATH		= 7;	// for the monster skin-burn-away effect enable and time offset

// model parms
const int SHADERPARM_MD5_SKINSCALE		= 8;	// for scaling vertex offsets on md5 models (jack skellington effect)

const int SHADERPARM_MD3_FRAME			= 8;
const int SHADERPARM_MD3_LASTFRAME		= 9;
const int SHADERPARM_MD3_BACKLERP		= 10;

const int SHADERPARM_BEAM_END_X			= 8;	// for _beam models
const int SHADERPARM_BEAM_END_Y			= 9;
const int SHADERPARM_BEAM_END_Z			= 10;
const int SHADERPARM_BEAM_WIDTH			= 11;

const int SHADERPARM_SPRITE_WIDTH		= 8;	// for _sprite models
const int SHADERPARM_SPRITE_HEIGHT		= 9;
const int SHADERPARM_SPRITE_OFFSET		= 10;

const int SHADERPARM_FADE_ORIGIN_X		= 8;
const int SHADERPARM_FADE_ORIGIN_Y		= 9;
const int SHADERPARM_FADE_ORIGIN_Z		= 10;

const int SHADERPARM_PARTICLE_STOPTIME	= 8;	// don't spawn any more particles after this time

// guis
const int MAX_RENDERENTITY_GUI			= 3;

// RAVEN BEGIN
// jscott: for effect brightness
const int SHADERPARM_BRIGHTNESS			= 6;	// for the overall brightness of effects
// RAVEN END

struct srfTriangles_t;
struct renderEntity_t;
struct renderView_s;
class idRenderModel;
class sdDeclAmbientCubeMap;
class idDemoFile;
class sdUserInterface;

typedef bool( *deferredEntityCallback_t )( renderEntity_t*, const renderView_s*, int& lastModifiedGameTime );

const int MAX_SURFACE_BITS = 64;

const unsigned short MIRROR_VIEW_ID			= 0xFFFF;
const unsigned short FAST_MIRROR_VIEW_ID	= 0xFFFE;
const		   int	 WORLD_SPAWN_ID			= 0xFFFF0000;

enum sdUpdateBits {
	UDB_NONE				= 0,		// nothing to be updated
	UDB_PUSH				= BIT(0),	// PushPolytopeIntoTree needs to be called again, i.e. the areas this object touches could have changed
	UDB_INTERACTIONS		= BIT(1),	// Recalculate interactions for this object, i.e. the lights this object is affected by could have changed
	UDB_DECALS				= BIT(2),	// Decals on this surface could have changed and need to be recalculated
	UDB_CACHEDMODEL			= BIT(3),	// The model has changed and the old cached version is not useful anymore
	UDB_SURFACEMASK			= BIT(4),	// The surface mask is dirty
	UDB_IMPOSTERS			= BIT(5),	// The imposters changed
};

struct sdInstCommon {
	byte	color[4];
	idVec3	origin;
	idMat3	axis;
	union {
		float   dist; // overloaded
		float	maxVisDist;
	};
};


struct sdInstRT {
	sdInstCommon inst;
	float dist;
};

struct sdInstInfo {
	sdInstCommon inst;
	float	maxVisDist;
	float	minVisDist;
	idVec3	fadeOrigin;
};

struct renderEntity_t {
	idRenderModel*					hModel;				// this can only be null if callback is set

	int								spawnID;//entityNum;
	int								mapId;

	// Entities that are expensive to generate, like skeletal models, can be
	// deferred until their bounds are found to be in view, in the frustum
	// of a shadowing light that is in view, or contacted by a trace / overlay test.
	// This is also used to do visual cueing on items in the view
	// The renderView may be NULL if the callback is being issued for a non-view related
	// source.
	// The callback function should clear renderEntity->callback if it doesn't
	// want to be called again next time the entity is referenced (ie, if the
	// callback has now made the entity valid until the next updateEntity)
	idBounds						bounds;					// only needs to be set for deferred models and md5s
	deferredEntityCallback_t		callback;

	void *							callbackData;			// used for whatever the callback wants

	// player bodies and possibly player shadows should be suppressed in views from
	// that player's eyes, but will show up in mirrors and other subviews
	// security cameras could suppress their model in their subviews if we add a way
	// of specifying a view number for a remoteRenderMap view
	unsigned short					suppressSurfaceInViewID;
	unsigned short					suppressShadowInViewID;

	// world models for the player and weapons will not cast shadows from view weapon
	// muzzle flashes
	unsigned short					suppressShadowInLightID;

	// if non-zero, the surface and shadow (if it casts one)
	// will only show up in the specific view, ie: player weapons
	unsigned short					allowSurfaceInViewID;

	// if non-zero, the surface will act as a noSelfShadow in the specified view
	unsigned short					noSelfShadowInViewID;

	unsigned char					drawSpec;
	unsigned char					shadowSpec;

	// positioning
	// axis rotation vectors must be unit length for many
	// R_LocalToGlobal functions to work, so don't scale models!
	// axis vectors are [0] = forward, [1] = left, [2] = up
	idVec3							origin;
	idMat3							axis;

	// texturing
	const idMaterial*				customShader;			// if non-0, all surfaces will use this
	const idMaterial*				referenceShader;		// used so flares can reference the proper light shader
	const idDeclSkin*				customSkin;				// 0 for no remappings
	class idSoundEmitter*			referenceSound;			// for shader sound tables, allowing effects to vary with sounds
	float							shaderParms[ MAX_ENTITY_SHADER_PARMS ];	// can be used in any way by shader or model generation

	struct renderView_s*			remoteRenderView;		// any remote camera surfaces will use this

	int								numJoints;
	idJointMat *					joints;					// array of joints that will modify vertices.
															// NULL if non-deformable model.  NOT freed by renderer, unless jointsAllocated is set

	float							modelDepthHack;			// squash depth range so particle effects don't clip into walls
	bool							foliageDepthHack;

	float							sortOffset;				// Override material sort form render entity

	float							coverage;				// used when flag overridencoverage is specified

	short							minGpuSpec;
	short							numInsts;
	sdInstInfo *					insts;					//

	int								numVisDummies;
	idVec3							*dummies;

	int								numAreas;
	int	*							areas;

	struct renderEntityFlags_t {
		// options to override surface shader flags (replace with material parameters?)
		bool	noSelfShadow					: 1;	// cast shadows onto other objects,but not self
		bool	noShadow						: 1;	// no shadow at all

		bool	noDynamicInteractions			: 1;	// don't create any light / shadow interactions after
														// the level load is completed.  This is a performance hack
														// for the gigantic outdoor meshes in the monorail map, so
														// all the lights in the moving monorail don't touch the meshes

		bool	noHardwareSkinning				: 1;

		bool	weaponDepthHack					: 1;	// squash depth range so view weapons don't poke into walls
												// this automatically implies noShadow
		bool	forceUpdate						: 1;	// force an update (NOTE: not a bool to keep this struct a multiple of 4 bytes)
		bool	pushIntoConnectedOutsideAreas	: 1;	// forces the entityDef to be pushed in all connected outside areas
		bool	pushIntoOutsideAreas			: 1;	// forces the entityDef to be pushed in all connected outside areas

		bool	forceImposter					: 1;	// Never render the actual entity always the imposter
		bool	useFadeOrigin					: 1;	// Use an offset stored in the shaderparms for imposter fade calculations
		bool	pushByOrigin					: 1;	// Use origin in push
		bool	pushByCenter					: 1;	// Use center of bounds in push
		bool	pushByInstances					: 1;	// Use center of bounds in push

		bool	overridenBounds					: 1;

		bool	overridenCoverage				: 1;
		bool	occlusionTest					: 1;

		bool	foliageDepthHack				: 1;

		bool	dontCastFromAtmosLight			: 1;

		bool	usePointTestForAmbientCubeMaps	: 1;

		bool	disableLODs						: 1;

		bool	jointsAllocated					: 1;
	};
	float							weaponDepthHackFOV_x;
	float							weaponDepthHackFOV_y;
	renderEntityFlags_t				flags;

	float							shadowVisDistMult;		// max distance this entity will be drawn at
	int								maxVisDist;				// max distance this entity will be drawn at
	int								minVisDist;				// min distance this entity will be drawn at
	float							visDistFalloff;			// fraction of range spent fading in

	sdBitField< MAX_SURFACE_BITS - 1 >	hideSurfaceMask;		// mask to hide surfaces within a model

	const sdDeclImposter*			imposter;				// Imposter to use for entity (screen space based unless forceImposter is on)

	const sdDeclAmbientCubeMap*		ambientCubeMap;			// Override the ambient cubemap for this model (instead of the one specified by the area)

	int ApplyChanges( const renderEntity_t &other ); // Returns sdUpdateBits mask
};

const int MAX_LIGHT_AREAS = 8;
const int MAX_PRELIGHTS = 5;

struct renderLight_t {
	idMat3					axis;				// rotation vectors, must be unit length
	idVec3					origin;

	// if non-zero, the light will not show up in the specific view,
	// which may be used if we want to have slightly different muzzle
	// flash lights for the player and other views
	unsigned short			suppressLightInViewID;

	// if non-zero, the light will only show up in the specific view
	// which can allow player gun gui lights and such to not effect everyone
	unsigned short			allowLightInViewID;

	int						mapId;

	struct renderLightFlags_t {
		bool				noShadows		: 1;	// (should we replace this with material parameters on the shader?)
		bool				noSpecular		: 1;	// (should we replace this with material parameters on the shader?)

		bool				pointLight		: 1;	// otherwise a projection light (should probably invert the sense of this, because points are way more common)
		bool				parallel		: 1;	// lightCenter gives the direction to the light at infinity

		bool				atmosphereLight	: 1;	// special case atmosphere light, used for terrain lighting
		bool				insideLight		: 1;
	};
	renderLightFlags_t		flags;

	idVec3					lightRadius;		// xyz radius for point lights
	idVec3					lightCenter;		// offset the lighting direction for shading and
												// shadows, relative to origin

	// frustum definition for projected lights, all reletive to origin
	// FIXME: we should probably have real plane equations here, and offer
	// a helper function for conversion from this format
	idVec3					target;
	idVec3					right;
	idVec3					up;
	idVec3					start;
	idVec3					end;

	// Dmap will generate an optimized shadow volumes named _prelight_<lightName>
	// for the light against all the _area* models in the map.  The renderer will
	// ignore this value if the light has been moved after initial creation
	int						numPrelightModels;
	idRenderModel *			prelightModels[ MAX_PRELIGHTS ];

	// muzzle flash lights will not cast shadows from player and weapon world models
	int						lightId;

	int						maxVisDist;

	unsigned int			minSpecShadowColor;

	const idMaterial *		material;			// NULL = either lights/defaultPointLight or lights/defaultProjectedLight
	float					shaderParms[MAX_ENTITY_SHADER_PARMS];		// can be used in any way by shader
	idSoundEmitter *		referenceSound;		// for shader sound tables, allowing effects to vary with sounds

	int						manualPriority;		// if nonzero this light may be added to the manual lights list preferring higher priority ones
												// if there are too many lights ( which means it will affect particles etc...)

	int						drawSpec;
	int						shadowSpec;

	// light polytope doesn't get pushed down the tree, instead, only add to the specified areas
	int						numAreas;
	int						areas[ MAX_LIGHT_AREAS ];

	struct atmosLightProjection_t *atmosLightProjection;

	int						ApplyChanges( const renderLight_t &other ); // Returns sdUpdateBits mask
};

// RAVEN BEGIN
// jscott: for handling of effects
typedef struct renderEffect_s {

	const rvDeclEffect*		declEffect;

	unsigned short			suppressSurfaceInViewID;
	unsigned short			allowSurfaceInViewID;
	unsigned short			suppressLightsInViewID;
	int						groupID;

	idVec3					origin;
	idMat3					axis;

	idVec3					gravity;
	idVec3					endOrigin;
	idVec3					windVector;
	idVec3					materialColor;

	float					attenuation;
	bool					hasEndOrigin;
	bool					loop;						// effect is looping
	bool					useRenderBounds;
	bool					isStatic;
//	bool					ambient;					// effect is from an entity
	unsigned short			weaponDepthHackInViewID;	// squash depth range so view weapons don't poke into walls
	float					weaponDepthHackFOV_x;
	float					weaponDepthHackFOV_y;
	float					modelDepthHack;
	bool					foliageDepthHack;
	float					distanceOffset;

	float					maxVisDist;

	// THIS MUST BE THE LAST PARAMETER
	float					shaderParms[ MAX_ENTITY_SHADER_PARMS ];	// can be used in any way by shader or model generation

	int						ApplyChanges( const struct renderEffect_s &other ); // Returns sdUpdateBits mask
} renderEffect_t;
// RAVEN END

struct occlusionTest_t {
	idMat3		axis;
	idVec3		origin;
	idBounds	bb;
	int			view;
};

struct cheapDecalParameters_t {
	idVec3				origin;
	idVec3				normal;
	int					jointIdx;
	const sdDeclDecal*	decl;
};

typedef struct renderView_s {
	// player views will set this to a non-zero integer for model suppress / allow
	// subviews (mirrors, cameras, etc) will always clear it to zero
	unsigned short			viewID;

	// sized from 0 to SCREEN_WIDTH / SCREEN_HEIGHT (640/480), not actual resolution
	int						x, y, width, height;

	float					fov_x, fov_y;				// perspective
	float					size_x, size_y;				// orthographic

	idVec3					vieworg;
	idMat3					viewaxis;					// transformation matrix, view looks down the positive X axis
	idMat3					lastViewAxis;					// transformation matrix, view looks down the positive X axis
	idVec3					lastViewOrg;

	// time in milliseconds for shader effects and other time dependent rendering issues
	int						time;
	float					shaderParms[MAX_GLOBAL_SHADER_PARMS];	// can be used in any way by shader

	const idMaterial*		globalMaterial;							// used to override everything draw
	const idDeclSkin*		globalSkin;								// apply this skin to everything

	idVec4					clearColor;
	float					foliageDepthHack;

	float					nearPlane;
	float					farPlane;
	int						forceClear;

	struct renderViewFlags_t {
		bool				cramZNear			: 1;	// for cinematics, we want to set ZNear much lower
		bool				forceUpdate			: 1;	// for an update
		bool				forceViewIDOnly		: 1;	// only render entities with a matching viewID
		bool				forceDefsVisible	: 1;
	};
	renderViewFlags_t		flags;
} renderView_t;


// exitPortal_t is returned by idRenderWorld::GetPortal()
typedef struct {
	int						areas[2];			// areas connected by this portal
	const idWinding	*		w;					// winding points have counter clockwise ordering seen from areas[0]
	idPlane					plane;
	idVec3					center;
	int						blockingBits;		// PS_BLOCK_VIEW, PS_BLOCK_AIR, etc
	qhandle_t				portalHandle;
	int						portalFlags;
} exitPortal_t;

// modelTrace_t is for tracing vs. visual geometry
typedef struct modelTrace_s {
	float						fraction;			// fraction of trace completed
	idVec3						point;				// end point of trace in global space
	idVec3						normal;				// hit triangle normal vector in global space
	idVec2						st;					// texture coordinate
	const idMaterial *			material;			// material of hit surface
	const sdDeclSurfaceType *	surfaceType;
	const srfTriangles_t	*	geometry;
	idVec3						surfaceColor;
	const renderEntity_t *		entity;				// render entity that was hit
	const class idRenderEntity *		def;
	int							jointNumber;		// md5 joint nearest to the hit triangle

} modelTrace_t;

static const int NUM_PORTAL_ATTRIBUTES = 3;

typedef enum {
	PS_BLOCK_NONE		= 0,

	PS_BLOCK_VIEW		= 1,
	PS_BLOCK_LOCATION	= 2,	// game map location strings often stop in hallways
	PS_BLOCK_AIR		= 4,	// windows between pressurized and unpresurized areas

	PS_BLOCK_ALL = ( 1 << NUM_PORTAL_ATTRIBUTES ) - 1
} portalConnection_t;

// RAVEN BEGIN
// jscott: effect handling in the renderer
class rvRenderEffect {
public:
	virtual					~rvRenderEffect( void ) {}

	virtual void			FreeRenderEffect( void ) = 0;
	virtual void			UpdateRenderEffect( const renderEffect_t *def, bool forceUpdate = false ) = 0;
	virtual void			ForceUpdate( void ) = 0;
	virtual int				GetIndex( void ) = 0;
};
// RAVEN END

class sdOcclusionTest {
public:
	virtual					~sdOcclusionTest( void ) {}

	virtual void			FreeOcclusionTest( void ) = 0;
	virtual void			UpdateOcclusionTest( const occlusionTest_t *def ) = 0;
};

class idRenderWorld {
public:
	virtual					~idRenderWorld() {};

	// The same render world can be reinitialized as often as desired
	// a NULL or empty mapName will create an empty, single area world
	virtual bool			InitFromMap( const char *mapName ) = 0;
	virtual void			LinkCullSectorsToArea( int area ) = 0;

	//-------------- Entity and Light Defs -----------------

	// entityDefs and lightDefs are added to a given world to determine
	// what will be drawn for a rendered scene.  Most update work is defered
	// until it is determined that it is actually needed for a given view.
	virtual	qhandle_t		AddEntityDef( const renderEntity_t *re ) = 0;
	virtual	void			UpdateEntityDef( qhandle_t entityHandle, const renderEntity_t *re ) = 0;
	virtual	void			FreeEntityDef( qhandle_t entityHandle ) = 0;
	virtual const renderEntity_t *GetRenderEntity( qhandle_t entityHandle ) const = 0;
	virtual renderEntity_t *GetRenderEntity( qhandle_t entityHandle ) = 0;

	virtual	qhandle_t		AddLightDef( const renderLight_t *rlight ) = 0;
	virtual	void			UpdateLightDef( qhandle_t lightHandle, const renderLight_t *rlight ) = 0;
	virtual	void			FreeLightDef( qhandle_t lightHandle ) = 0;
	virtual const renderLight_t *GetRenderLight( qhandle_t lightHandle ) const = 0;

// RAVEN BEGIN
// jscott: handling of effects
	virtual qhandle_t		AddEffectDef( const renderEffect_t *reffect, int time ) = 0;
	virtual bool			UpdateEffectDef( qhandle_t effectHandle, const renderEffect_t *reffect, int time ) = 0;
	virtual void			StopEffectDef( qhandle_t effectHandle ) = 0;
	virtual void			RestartEffectDef( qhandle_t effectHandle ) = 0;
	virtual void			FreeEffectDef( qhandle_t effectHandle ) = 0;
	virtual void			FreeStoppedEffectDefs( void ) = 0;
// RAVEN END

// Game side occlusion tests
	virtual qhandle_t		AddOcclusionTestDef( const occlusionTest_t *occtest ) = 0;
	virtual void			UpdateOcclusionTestDef( qhandle_t occtestHandle, const occlusionTest_t *occtest ) = 0;
	virtual void			UpdateOcclusionTestDefViewID( qhandle_t occtestHandle, int viewID ) = 0;
	virtual bool			IsVisibleOcclusionTestDef( qhandle_t occtestHandle ) = 0;
	virtual	void			FreeOcclusionTestDef( qhandle_t occtestHandle ) = 0;
	virtual int				CountVisibleOcclusionTestDef( qhandle_t occtestHandle ) = 0;


	virtual bool			IsVisibleEntity( int viewID, int occid ) = 0;


	virtual void			UpdateOcclusionTests( void ) = 0;


	// Force the generation of all light / surface interactions at the start of a level
	// If this isn't called, they will all be dynamically generated
	virtual	void			GenerateAllInteractions() = 0;

	virtual idRenderModel*	GetEntityHandleDynamicModel( qhandle_t entityHandle ) = 0;

	//-------------- Decals and Overlays  -----------------

	virtual idRenderModel*	CreateDecalModel() = 0;
	virtual void 			AddToProjectedDecal( const idFixedWinding& winding, const idVec3 &projectionOrigin, const bool parallel, const idVec4& color, idRenderModel* model, int entityNum, const idMaterial** onlyMaterials = NULL, const int numOnlyMaterials = 1 ) = 0;
	virtual void			ResetDecalModel( idRenderModel* model ) = 0;
	virtual void			FinishDecal( idRenderModel* model ) = 0;

	// Creates decals on all world surfaces that the winding projects onto.
	// The projection origin should be infront of the winding plane.
	// The decals are projected onto world geometry between the winding plane and the projection origin.
	// The decals are depth faded from the winding plane to a certain distance infront of the
	// winding plane and the same distance from the projection origin towards the winding.
	// Arnout: FIXME as soon as there is a nicer way to get the current game time in the engine, stop passing in currentTime
	virtual void			ProjectDecalOntoWorld( const idFixedWinding &winding, const idVec3 &projectionOrigin, const bool parallel, const float fadeDepth, const idMaterial *material, const int startTime, const int currentTime ) = 0;

	// Creates decals on static models.
	virtual void			ProjectDecal( qhandle_t entityHandle, const idFixedWinding &winding, const idVec3 &projectionOrigin, const bool parallel, const float fadeDepth, const idMaterial *material, const int startTime, const int currentTime ) = 0;

	// Creates overlays on dynamic models.
	virtual void			ProjectOverlay( qhandle_t entityHandle, const idPlane localTextureAxis[2], const idMaterial *material ) = 0;

	// Removes all decals and overlays from the given entity def.
	virtual void			RemoveDecals( qhandle_t entityHandle ) = 0;
	virtual void			AddCheapDecal( qhandle_t entityHandle, const cheapDecalParameters_t &params, float time ) = 0;

	virtual void			ClearDecals( void ) = 0;

	//-------------- Env Bounds -----------------

	virtual void			AddEnvBounds( idVec3 const &origin, idVec3 const &scale, const char *cubemap ) = 0;

	//-------------- Scene Rendering -----------------

	// some calls to material functions use the current renderview time when servicing cinematics.  this function
	// ensures that any parms accessed (such as time) are properly set.
	virtual void			SetRenderView( const renderView_t *renderView ) = 0;

	// rendering a scene may actually render multiple subviews for mirrors and portals, and
	// may render composite textures for gui console screens and light projections
	// It would also be acceptable to render a scene multiple times, for "rear view mirrors", etc
	virtual void			RenderScene( const renderView_t *renderView ) = 0;
	virtual void			PerformRenderScene( const renderView_t *renderView ) = 0;

	//-------------- Portal Area Information -----------------

	// returns the number of portals
	virtual int				NumPortals( void ) const = 0;

	// returns 0 if no portal contacts the bounds
	// This is used by the game to identify portals that are contained
	// inside doors, so the connection between areas can be topologically
	// terminated when the door shuts.
	virtual	qhandle_t		FindPortal( const idBounds &b ) const = 0;

	// doors explicitly close off portals when shut
	// multiple bits can be set to block multiple things, ie: ( PS_VIEW | PS_LOCATION | PS_AIR )
	virtual	void			SetPortalState( qhandle_t portal, int blockingBits ) = 0;
	virtual int				GetPortalState( qhandle_t portal ) = 0;

	virtual void			UpdatePortalOccTestView( int viewID ) = 0;

	// returns true only if a chain of portals without the given connection bits set
	// exists between the two areas (a door doesn't separate them, etc)
	virtual	bool			AreasAreConnected( int areaNum1, int areaNum2, portalConnection_t connection ) = 0;
	virtual	bool			AreasAreConnected( int areaNum1, int areaNum2, portalFlags_t flag ) = 0;
	virtual	bool			AreasAreConnected( int areaNum1, int areaNum2 ) = 0;

	// returns the number of portal areas in a map, so game code can build information
	// tables for the different areas
	virtual	int				NumAreas( void ) const = 0;

	// Will return -1 if the point is not in an area, otherwise
	// it will return 0 <= value < NumAreas()
	virtual int				PointInArea( const idVec3 &point ) const = 0;

	// fills the *areas array with the numbers of the areas the bounds cover
	// returns the total number of areas the bounds cover
	virtual int				BoundsInAreas( const idBounds &bounds, int *areas, int maxAreas ) const = 0;

	// Used by the sound system to do area flowing
	virtual	int				NumPortalsInArea( int areaNum ) = 0;

	// returns one portal from an area
	virtual exitPortal_t	GetPortal( int areaNum, int portalNum ) = 0;

	// set portal flags on areas directly; primarely for editor reasons
	virtual void			SetAreaPortalFlags( int areaNum, int flags ) = 0;
	virtual int				GetAreaPortalFlags( int areaNum ) const = 0;

	// set the ambient lighting & atmosphere to use for this area
	virtual void			SetAreaAmbientCubeMap( int areaNum, const sdDeclAmbientCubeMap *cubeMapDecl ) = 0;

	virtual const sdDeclAmbientCubeMap *GetAreaAmbientCubeMap( int areaNum ) = 0;
	virtual void			SetCubemapSunProperties( const sdDeclAmbientCubeMap *cubeMapDecl, const idVec3 &sunDir, const idVec3 &sunColor ) = 0;

	//-------------- Tracing  -----------------

	// Traces vs the render model, possibly instantiating a dynamic version, and returns true if something was hit
	virtual bool			ModelTrace( modelTrace_t &trace, qhandle_t entityHandle, const idVec3 &start, const idVec3 &end, const float radius, int surfCollision = SURF_COLLISION ) const = 0;

	// Traces vs the whole rendered world. FIXME: we need some kind of material flags.
	virtual bool			Trace( modelTrace_t &trace, const idVec3 &start, const idVec3 &end, const float radius, bool skipDynamic = true ) const = 0;

	// Traces vs the world model bsp tree.
	virtual bool			FastWorldTrace( modelTrace_t &trace, const idVec3 &start, const idVec3 &end ) const = 0;

	//-------------- Demo Control  -----------------

	// Writes a loadmap command to the demo, and clears archive counters.
	virtual void			StartWritingDemo( idDemoFile *demo ) = 0;
	virtual void			StopWritingDemo() = 0;

	// Returns true when demoRenderView has been filled in.
	// adds/updates/frees entityDefs and lightDefs based on the current demo file
	// and returns the renderView to be used to render this frame.
	// a demo file may need to be advanced multiple times if the framerate
	// is less than 30hz
	// demoTimeOffset will be set if a new map load command was processed before
	// the next renderScene
	virtual bool			ProcessDemoCommand( idDemoFile *readDemo, renderView_t *demoRenderView, int *demoTimeOffset ) = 0;

	// this is used to regenerate all interactions ( which is currently only done during influences ), there may be a less
	// expensive way to do it
	virtual void			RegenerateWorld() = 0;

	//-------------- Debug Visualization  -----------------

	// Line drawing for debug visualization
	virtual void			DebugClearLines( int time ) = 0;		// a time of 0 will clear all lines and text
	virtual void			DebugLine( const idVec4 &color, const idVec3 &start, const idVec3 &end, const int lifetime = 0, const bool depthTest = false ) = 0;
	virtual void			DebugArrow( const idVec4 &color, const idVec3 &start, const idVec3 &end, int size, const int lifetime = 0, bool depthTest = false ) = 0;
	virtual void			DebugWinding( const idVec4 &color, const idWinding &w, const idVec3 &origin, const idMat3 &axis, const int lifetime = 0, const bool depthTest = false ) = 0;
	virtual void			DebugCircle( const idVec4 &color, const idVec3 &origin, const idVec3 &dir, const float radius, const int numSteps, const int lifetime = 0, const bool depthTest = false ) = 0;
	virtual void			DebugSphere( const idVec4 &color, const idSphere &sphere, const int lifetime = 0, const bool depthTest = false ) = 0;
	virtual void			DebugBounds( const idVec4 &color, const idBounds &bounds, const idVec3 &org = vec3_origin, const idMat3& axes = mat3_identity, const int lifetime = 0 ) = 0;
	virtual void			DebugBox( const idVec4 &color, const idBox &box, const int lifetime = 0 ) = 0;
	virtual void			DebugFrustum( const idVec4 &color, const idFrustum &frustum, const bool showFromOrigin = false, const int lifetime = 0 ) = 0;
	virtual void			DebugCone( const idVec4 &color, const idVec3 &apex, const idVec3 &dir, float radius1, float radius2, const int lifetime = 0 ) = 0;
	virtual void			DebugAxis( const idVec3 &origin, const idMat3 &axis, int lifetime = 0 ) = 0;

	// Polygon drawing for debug visualization.
	virtual void			DebugClearPolygons( int time ) = 0;		// a time of 0 will clear all polygons
	virtual void			DebugPolygon( const idVec4 &color, const idWinding &winding, const int lifeTime = 0, const bool depthTest = false, idImage* image = NULL ) = 0;

	// Text drawing for debug visualization.
	virtual void			DrawText( const char *text, const idVec3 &origin, float scale, const idVec4 &color, const idMat3 &viewAxis, const int align = 1, const int lifetime = 0) = 0;

	// Atmosphere / Ambient Systems.
	virtual void			SetAtmosphere( const sdDeclAtmosphere* atmosphere ) = 0;

	virtual const sdDeclAtmosphere*	GetAtmosphere() const = 0;

	virtual void			SetupMatrices( const renderView_t* renderView, float* projectionMatrix, float* modelViewMatrix, const bool allowJitter ) = 0;

	virtual void			SetMegaTextureSTGrid( const idBounds& bounds, const idVec2* grid, int width, int height ) = 0;

	virtual struct atmosLightProjection_t *FindAtmosLightProjection( int lightID ) = 0;
};


/*
============
sdUserInterface
============
*/
class sdUserInterface {
public:
	virtual					~sdUserInterface( void ) {}
	virtual void			Draw( void ) = 0;
	virtual void			Activate( void ) = 0;
	virtual void			OnInputInit( void ) = 0;
	virtual void			OnInputShutdown( void ) = 0;
};

#endif /* !__RENDERWORLD_H__ */