/*
gl_local.h - renderer local definitions
this code written for Paranoia 2: Savior modification
Copyright (C) 2013 Uncle Mike

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
*/

#ifndef GL_LOCAL_H
#define GL_LOCAL_H

#include "gl_export.h"
#include "ref_params.h"
#include "com_model.h"
#include "r_studioint.h"
#include "gl_framebuffer.h"
#include "gl_frustum.h"
#include "gl_primitive.h"
#include "cl_dlight.h"
#include "features.h"
#include <utlarray.h>
#include <matrix.h>

#define ACTUAL_GL_VERSION	30.0f

// limits
#define MAX_REF_STACK	8			// pass depth
#define MAX_VISIBLE_ENTS	4096			// total pack of frame ents
#define MAX_SORTED_FACES	32768			// bmodels only
#define MAX_SUBVIEW_FACES	1024			// mirrors, portals, monitors, water, puddles. NOTE: multipass faces can merge view passes
#define MAX_OCCLUDED_FACES	1024			// mirrors + water
#define MAX_SORTED_MESHES	2048			// studio only
#define MAX_MOVIES		16			// max various movies per level
#define MAX_MOVIE_TEXTURES	64			// max # of unique video textures per level
#define MAX_LIGHTSTYLES	64			// a byte limit, don't modify
#define MAX_LIGHTMAPS	256			// Xash3D supports up to 256 lightmaps
#define MAX_DLIGHTS 	64			// per one frame. unsigned int limit
#define MAX_ENGINE_DLIGHTS 	32
#define MAX_LIGHTCACHE	2048			// unique models with instanced vertex lighting
#define MAX_SHADOWS		MAX_DLIGHTS
#define MAX_SUBVIEW_TEXTURES	64			// total depth
#define MAX_FRAMEBUFFERS	MAX_SUBVIEW_TEXTURES
#define MAX_FBO_ATTACHMENTS	8			// color attachments per FBO
#define DEFAULT_CUBEMAP_SIZE	32			// same as in Source
#define AMBIENT_EPSILON	0.001f			// to avoid division by zero
#define STAIR_INTERP_TIME	100.0f
#define LIGHT_PROBES	10			// eight OBB corners, center and one reserved slot (NOTE: not all the probes will be used)
#define LIGHT_SAMPLES	8			// GPU limitation for local arrays (very slowly if more than eight elements)
#define MOD_FRAMES		20

#define WATER_TEXTURES	29
#define WATER_ANIMTIME	20.0f

#define INVALID_HANDLE	0xFFFF	// studio cache

#define FLASHLIGHT_KEY	-666
#define SUNLIGHT_KEY	-777
#define SKYBOX_ENTITY	70

#define LM_SAMPLE_SIZE	16
#define LM_SAMPLE_EXTRASIZE	8

#define BLOCK_SIZE		glConfig.block_size		// lightmap blocksize
#define BLOCK_SIZE_DEFAULT	128			// for keep backward compatibility
#define BLOCK_SIZE_MAX	2048			// must match with engine const!!!
#define SHADOW_SIZE		4096			// atlas size

#define WORLD_MATRIX	0			// must be 0 always
#define REFPVS_RADIUS	2.0f			// PVS radius for rendering
#define Z_NEAR		4.0f
#define Z_NEAR_LIGHT	0.1f
#define BACKFACE_EPSILON	0.01f

#define CVAR_TO_BOOL( x )	((x) && ((x)->value != 0.0f) ? true : false )

// VBO offsets
#define OFFSET( type, var )	((const void *)&(((type *)NULL)->var))
#define R_OpaqueEntity( e )	(( (e)->curstate.rendermode == kRenderNormal ) || ( (e)->curstate.rendermode == kRenderTransAlpha ))
#define R_ModelOpaque( rm )	(( rm == kRenderNormal ) || ( rm == kRenderTransAlpha ))
#define R_StaticEntity( e )	( (e)->origin == g_vecZero && (e)->angles == g_vecZero && (e)->curstate.renderfx != SKYBOX_ENTITY )
#define R_FullBright()	( CVAR_TO_BOOL( r_fullbright ) || !worldmodel->lightdata )
#define RP_OUTSIDE( leaf )	(((( leaf ) - worldmodel->leafs ) - 1 ) == -1 )
#define R_WaterEntity( m )	( FBitSet( m->flags, BIT( 2 )))

#define ScreenCopyRequired( x )	((x) && FBitSet( (x)->status, SHADER_USE_SCREENCOPY ))
#define IsReflectShader( x )		((x) && FBitSet( (x)->status, SHADER_USE_CUBEMAPS ))

// refparams
#define RP_NONE		0
#define RP_THIRDPERSON	BIT( 0 )
#define RP_DRAW_WORLD	BIT( 1 )	// otherwise it's player customization window
#define RP_DRAW_OVERVIEW	BIT( 2 )	// dev_overview is active
#define RP_CLIPPLANE	BIT( 3 )	// mirrors used
#define RP_MERGE_PVS	BIT( 4 )	// merge PVS with previous pass
#define RP_MIRRORVIEW	BIT( 5 )	// lock pvs at vieworg
#define RP_ENVVIEW		BIT( 6 )	// used for cubemapshot
#define RP_SHADOWVIEW	BIT( 7 )	// view through light
#define RP_NOSHADOWS	BIT( 8 )	// disable shadows for this pass
#define RP_SKYVIEW		BIT( 9 )	// render skyonly
#define RP_WATERPASS	BIT( 10 )	// it's mirorring plane for water surface
#define RP_NOGRASS		BIT( 11 )	// don't draw grass
#define RP_DEFERREDSCENE	BIT( 12 )	// render scene into geometry buffer
#define RP_DEFERREDLIGHT	BIT( 13 )	// render scene into low-res lightmap

// RI->view.changed
#define RC_ORIGIN_CHANGED	BIT( 0 )	// origin is changed from the previous frame
#define RC_ANGLES_CHANGED	BIT( 1 )	// angles is changed from the previous frame
#define RC_VIEWLEAF_CHANGED	BIT( 2 )	// viewleaf is changed
#define RC_FOV_CHANGED	BIT( 3 )	// FOV is changed
#define RC_PVS_CHANGED	BIT( 4 )	// now our PVS was potentially changed :-)
#define RC_FRUSTUM_CHANGED	BIT( 5 )	// now our frustum was potentially changed :-)
#define RC_FORCE_UPDATE	BIT( 6 )	// some cvar manipulations invoke updates of visible list

// RI->view.flags
#define RF_SKYVISIBLE	BIT( 0 )	// sky is visible for this frame
#define RF_HASDYNLIGHTS	BIT( 1 )	// pass have dynlights

#define RP_NONVIEWERREF	(RP_MIRRORVIEW|RP_ENVVIEW|RP_SHADOWVIEW|RP_SKYVIEW)
#define RP_LOCALCLIENT( e )	(gEngfuncs.GetLocalPlayer() && ((e)->index == gEngfuncs.GetLocalPlayer()->index && e->curstate.entityType == ET_PLAYER ))
#define RP_NORMALPASS()	( FBitSet( RI->params, RP_NONVIEWERREF ) == 0 )
#define RP_CUBEPASS()	( FBitSet( RI->params, RP_SKYVIEW|RP_ENVVIEW ))

#define TF_LIGHTMAP		(TF_NOMIPMAP|TF_CLAMP|TF_ATLAS_PAGE|TF_HAS_ALPHA)
#define TF_DELUXMAP		(TF_CLAMP|TF_NOMIPMAP|TF_NORMALMAP|TF_ATLAS_PAGE)
#define TF_IMAGE		(TF_NOMIPMAP|TF_CLAMP)
#define TF_SCREEN		(TF_NOMIPMAP|TF_CLAMP)
#define TF_SPOTLIGHT	(TF_NOMIPMAP|TF_BORDER)
#define TF_SHADOW		(TF_NOMIPMAP|TF_CLAMP|TF_DEPTHMAP|TF_LUMINANCE)
#define TF_SHADOW_CUBEMAP	(TF_NOMIPMAP|TF_CLAMP|TF_CUBEMAP|TF_DEPTHMAP|TF_LUMINANCE)
#define TF_RECTANGLE_SCREEN	(TF_RECTANGLE|TF_NOMIPMAP|TF_CLAMP)
#define TF_DEPTH		(TF_NOMIPMAP|TF_CLAMP|TF_NEAREST|TF_DEPTHMAP|TF_LUMINANCE|TF_NOCOMPARE)
#define TF_GRASS		(TF_CLAMP)
#define TF_DEPTHBUFF	(TF_DEPTHMAP|TF_LUMINANCE|TF_NOCOMPARE)
#define TF_STORAGE		(TF_NEAREST|TF_RECTANGLE|TF_ARB_FLOAT|TF_HAS_ALPHA|TF_CLAMP|TF_NOMIPMAP)

#define TF_DEPTHBUFFER	(TF_SCREEN|TF_DEPTHMAP|TF_NEAREST|TF_NOCOMPARE)
#define TF_COLORBUFFER	(TF_SCREEN|TF_NEAREST)

#define CULL_VISIBLE	0	// not culled
#define CULL_BACKSIDE	1	// backside of transparent wall
#define CULL_FRUSTUM	2	// culled by frustum
#define CULL_OTHER		3	// culled by other reason

#define TF_RT_COLOR		(TF_NEAREST|TF_CLAMP|TF_NOMIPMAP)
#define TF_RT_NORMAL	(TF_NEAREST|TF_CLAMP|TF_NOMIPMAP|TF_NORMALMAP)
#define TF_RT_DEPTH		(TF_NEAREST|TF_CLAMP|TF_NOMIPMAP|TF_DEPTHMAP|TF_NOCOMPARE)

#define MAT_ALL_EFFECTS	(BRUSH_HAS_BUMP|BRUSH_HAS_SPECULAR|BRUSH_REFLECT|BRUSH_FULLBRIGHT)

#define FBO_MAIN		0

// light types
#define LIGHT_SPOT		0	// standard projection light
#define LIGHT_OMNI		1	// omnidirectional light
#define LIGHT_DIRECTIONAL	2	// parallel light (sun light)

// helpers
#define GetVForward()	Vector( RI->view.matrix[0] )
#define GetVRight()		Vector( RI->view.matrix[1] )
#define GetVLeft()		-Vector(RI->view.matrix[1] )
#define GetVUp()		Vector( RI->view.matrix[2] )
#define GetVieworg()	RI->view.origin

typedef enum
{
	DRAWLIST_ALL = 0,	// special case for decals
	DRAWLIST_SOLID,
	DRAWLIST_TRANS,
	DRAWLIST_LIGHT,
	DRAWLIST_SUBVIEW,
	DRAWLIST_SHADOW,
} drawlist_t;

enum
{
	BUMP_BASELIGHT_STYLE	= 61,
	BUMP_ADDLIGHT_STYLE		= 62,
	BUMP_LIGHTVECS_STYLE	= 63,
};

class DecalGroupEntry;
typedef int (*cmpfunc)( const void *a, const void *b );
typedef void (*pfnShaderCallback)( struct glsl_prog_s *shader );

// multiple output draw buffers
typedef struct
{
	char		name[32];
	int		width;
	int		height;
	int		depth;
	int		colortarget[MAX_FBO_ATTACHMENTS];
	int		depthtarget;
	uint		id;
} gl_drawbuffer_t;

typedef struct gl_fbo_s
{
	GLboolean		init;
	GLuint		framebuffer;
	GLuint		renderbuffer;
	int		texture;
} gl_fbo_t;

typedef struct gl_movie_s
{
	char		name[32];
	void		*state;
	float		length;		// total cinematic length
	long		xres, yres;	// size of cinematic
} gl_movie_t;

typedef struct gl_texbuffer_s
{
	int		framebuffer;
	int		texturenum;
	int		texframe;		// this frame texture was used
	matrix4x4		matrix;		// texture matrix
} gl_texbuffer_t;

class gl_state_t
{
public:
	GLfloat		modelMatrix[16];	// matrix4x4( origin, angles, scale )
	matrix4x4		transform;	// entity transformation matrix 
	bool		m_bSkyEntity;
	const Vector GetModelOrigin( void );
};

typedef enum
{
	LM_FREE = 0,	// lightmap is clear
	LM_USED,		// partially used, has free space
	LM_DONE,		// completely full
} lmstate_t;

typedef struct
{
	lmstate_t		state;
	unsigned short	allocated[BLOCK_SIZE_MAX];
	int		lightmap;
	int		deluxmap;	
} gl_lightmap_t;

typedef struct
{
	unsigned short	allocated[SHADOW_SIZE];
	CFrameBuffer	shadowmap;
} gl_shadowmap_t;

typedef struct
{
	Vector		diffuse;		// direct light color
	Vector		normal;		// direct light normal
	int		ambientlight;	// clip at 128
	int		shadelight;	// clip at 192 - ambientlight
	Vector		ambient[6];	// cubemap 1x1 (single pixel per side)
	bool		nointerp;		// flickering light force nointerp
} mstudiolight_t;

// NOTE: if this is changed it must be changed in studio.h and com_model.h too!!!
typedef struct
{
	float		smoothness;		// smoothness factor
	float		detailScale[2];		// detail texture scales x, y
	float		reflectScale;		// reflection scale for translucent water
	float		refractScale;		// refraction scale for mirrors, windows, water
	float		aberrationScale;		// chromatic abberation
	float		reliefScale;		// relief-mapping
	struct matdef_s	*effects;			// hit, impact, particle effects etc

	char		name[64];
	unsigned short	dt_texturenum;		// detail texture load directly from material specific

	char		diffusemap[64];
	char		normalmap[64];
	char		glossmap[64];
} matdesc_t;

typedef struct
{
	char		name[64];
	char		diffuse[64];
	unsigned short	gl_diffuse_id;	// diffuse texture
	unsigned short	gl_heightmap_id;
	unsigned short	width, height;
	byte		maxHeight;
	byte		numLayers;	// layers that specified on heightmap
	byte		*pixels;		// pixels are immediately goes here
} indexMap_t;

typedef struct
{
	char		pathes[MAX_LANDSCAPE_LAYERS][64];	// path to texture (may include extension etc)
	char		names[MAX_LANDSCAPE_LAYERS][64];	// basenames
	matdesc_t		*material[MAX_LANDSCAPE_LAYERS];	// layer settings
	float		smoothness[MAX_LANDSCAPE_LAYERS];	// shader params
	unsigned short	gl_diffuse_id;			// diffuse texture array
	unsigned short	gl_detail_id;			// detail texture
	unsigned short	gl_normalmap_id;			// normalmap array
	unsigned short	gl_specular_id;			// specular array
} layerMap_t;

typedef struct terrain_s
{
	char		name[16];
	indexMap_t	indexmap;
	layerMap_t	layermap;
	int		numLayers;	// count of array textures
	int		tessSize;
	float		texScale;		// global texture scale
	bool		valid;		// if heightmap was actual
} terrain_t;

typedef struct
{
	int		changed;				// whats changed from last frame
	int		flags;				// some info about current frame (sets by renderer)

	int		entity;				// playernum or camera edict
	Vector		origin;
	Vector		angles;
	Vector		pvspoint;
	ref_overview_t	over;				// cached overview

	int		client_frame;			// cached client frame
	bool		novis_cached;			// last value of r_novis variable
	bool		lockpvs_cached;			// last value of r_lockpvs variable

	float		fov_x;				// actual fov_x
	float		fov_y;				// actual fov_y
	float		farClip;
	float		planedist;			// for sort translucent surfaces
	float		lodScale;

	int		port[4];				// cached view.port

	CFrustum		frustum;				// view frustum
	CFrustum		splitFrustum[MAX_SHADOWMAPS];
	float		parallelSplitDistances[MAX_SHADOWMAPS];	// distances in camera space

	matrix4x4		matrix;				// untransformed viewmatrix
	matrix4x4		worldMatrix;			// modelview for world
	matrix4x4		projectionMatrix;			// gl frustum
	matrix4x4		worldProjectionMatrix;		// worldviewMatrix * projectionMatrix

	mleaf_t		*leaf;				// leaf where are vieworg located

	vec3_t		visMins;				// visMins used for compute precision farclip
	vec3_t		visMaxs;

	float		skyMins[2][6];			// sky texcoords
	float		skyMaxs[2][6];			// sky texcoords

	byte		pvsarray[(MAX_MAP_LEAFS+7)/8];	// actual PVS for current frame
	byte		visfaces[(MAX_MAP_FACES+7)/8];	// actual visible faces for current frame (world only)
	byte		vislight[(MAX_MAP_WORLDLIGHTS+7)/8];	// visible lights per current frame
} ref_viewcache_t;

typedef struct
{
	// forward rendering lists
	CUtlArray<CSolidEntry>	solid_faces;
	CUtlArray<CSolidEntry>	solid_meshes;
	CUtlArray<CTransEntry>	trans_list;
	CUtlArray<struct grass_s*>	grass_list;
	CUtlArray<Vector>		primverts;		// primitive vertexes

	// forward lighting lists
	CUtlArray<CSolidEntry>	light_faces;
	CUtlArray<CSolidEntry>	light_meshes;
	CUtlArray<struct grass_s*>	light_grass;

	msurface_t		*subview_faces[MAX_SUBVIEW_FACES];	// 6 kb
	int			num_subview_faces;
} ref_drawlist_t;

// contain gl-friendly data that may keep from previous frame
// to avoid to recompute it again
typedef struct
{
	int		viewport[4];		// in OpenGL space

	GLfloat		modelviewMatrix[16];	// worldviewMatrix
	GLfloat		projectionMatrix[16];	// projection matrix
	GLfloat		modelviewProjectionMatrix[16];// send to engine
} ref_glstate_t;

typedef struct
{
	int		params;		// rendering parameters

	// NEW STATE
	ref_viewcache_t	view;		// cached view
	ref_glstate_t	glstate;		// cached glstate
	ref_drawlist_t	frame;		// frame lists

	// GLOBAL STATE
	mplane_t		clipPlane;
	cl_entity_t	*currententity;
	model_t		*currentmodel;
	CDynLight		*currentlight;
	struct glsl_prog_s	*currentshader;
	msurface_t	*reject_face;	// avoid recursion to himself
} ref_instance_t;

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

 GL STATE MACHINE

=======================================================================
*/
enum
{
	R_OPENGL_110 = 0,		// base
	R_WGL_PROCADDRESS,
	R_ARB_VERTEX_BUFFER_OBJECT_EXT,
	R_ARB_VERTEX_ARRAY_OBJECT_EXT,
	R_TEXTURE_ARRAY_EXT,	// shaders only
	R_EXT_GPU_SHADER4,		// shaders only
	R_DRAW_BUFFERS_EXT,
	R_ARB_MULTITEXTURE,
	R_TEXTURECUBEMAP_EXT,
	R_SHADER_GLSL100_EXT,
	R_DRAW_RANGEELEMENTS_EXT,
	R_TEXTURE_3D_EXT,
	R_SHADER_OBJECTS_EXT,
	R_VERTEX_SHADER_EXT,	// glsl vertex program
	R_FRAGMENT_SHADER_EXT,	// glsl fragment program	
	R_ARB_TEXTURE_NPOT_EXT,
	R_TEXTURE_2D_RECT_EXT,
	R_DEPTH_TEXTURE,
	R_SHADOW_EXT,
	R_FRAMEBUFFER_OBJECT,
	R_SEPARATE_BLENDFUNC_EXT,
	R_OCCLUSION_QUERIES_EXT,
	R_SEAMLESS_CUBEMAP,
	R_BINARY_SHADER_EXT,
	R_PARANOIA_EXT,		// custom OpenGL32.dll with hacked function glDepthRange
	R_DEBUG_OUTPUT,
	R_EXTCOUNT,		// must be last
};

enum
{
	GL_KEEP_UNIT = -1,		// alternative way - change the unit by GL_SelectTexture
	GL_TEXTURE0 = 0,
	GL_TEXTURE1,
	GL_TEXTURE2,
	GL_TEXTURE3,
	GL_TEXTURE4,
	GL_TEXTURE5,
	GL_TEXTURE6,
	GL_TEXTURE7,
	GL_TEXTURE8,
	GL_TEXTURE9,
	GL_TEXTURE10,
	GL_TEXTURE11,
	MAX_TEXTURE_UNITS
};

typedef struct
{
	bool		fCustomRendering;
	bool		fClearScreen;			// force clear if world shaders failed to build
	int		fGamePaused;

	double		time;				// cl.time
	double		oldtime;				// cl.oldtime
	double		frametime;			// special frametime for multipass rendering (will set to 0 on a nextview)
	double		saved_frametime;			// push\pop

	cl_entity_t	*draw_entities[MAX_VISIBLE_ENTS];	// list of all pending entities for current frame
	int		num_draw_entities;			// count for actual rendering frame

	int		defaultTexture;   	// use for bad textures
	int		skyboxTextures[6];	// skybox sides
	int		normalmapTexture;	// default normalmap
	int		deluxemapTexture;	// default deluxemap
	int		vsdctCubeTexture;	// Virtual Shadow Depth Cubemap Texture
	int		whiteCubeTexture;	// stub
	int		depthTexture;	// stub
	int		depthCubemap;	// stub
	int		normalsFitting;	// best fit normals

	int		defaultProjTexture;	// fallback for missed textures
	int		flashlightTexture;	// flashlight projection texture
	int		spotlightTexture[8];// reserve for eight textures
	int		cinTextures[MAX_MOVIE_TEXTURES];
	gl_texbuffer_t	subviewTextures[MAX_SUBVIEW_TEXTURES];
	int		shadowTextures[MAX_SHADOWS];
	int		shadowCubemaps[MAX_SHADOWS];
	int		waterTextures[WATER_TEXTURES];
	int		num_2D_shadows_used;	// used shadow textures per full frame
	int		num_CM_shadows_used;	// used shadow textures per full frame
	int		num_subview_used;		// used mirror textures per full frame
	int		num_cin_used;		// used movie textures per full frame

	int		screen_color;
	int		screen_depth;

	int		grayTexture;
	int		whiteTexture;
	int		blackTexture;
	int		screenTexture;

	CUtlArray<gl_state_t>	cached_state;

	gl_lightmap_t	lightmaps[MAX_LIGHTMAPS];
	byte		current_lightmap_texture;
	int		packed_lights_texture;
	int		packed_planes_texture;
	int		packed_nodes_texture;
	int		packed_models_texture;

	gl_shadowmap_t	shadowmap;	// single atlas

	// framebuffers
	CFrameBuffer	fbo_shadow2D;	// used for projection shadowmapping
	CFrameBuffer	fbo_shadowCM;	// used for omnidirectional shadowmapping
	CFrameBuffer	sunShadowFBO[MAX_SHADOWMAPS];	// extra-large shadowmap for sun rendering
	CFrameBuffer	fbo_light;	// store lightmap
	CFrameBuffer	fbo_filter;	// store filtered lightmap
	CFrameBuffer	fbo_shadow;	// store shadowflags

	gl_drawbuffer_t	*defscene_fbo;
	gl_drawbuffer_t	*deflight_fbo;
	word		defSceneShader[2];	// geometry pass
	word		defLightShader;	// light pass
	word		defDynLightShader[2];// dynamic light pass
	word		bilateralShader;	// upscale filter

	// skybox shaders
	word		skyboxEnv[2];	// skybox & sun
	word		defSceneSky;	// skybox & sun
	word		defLightSky;	// skybox & sun

	// framebuffers
	gl_fbo_t		frame_buffers[MAX_FRAMEBUFFERS];
	int		num_framebuffers;

	int		realframecount;	// not including passes
	int		grassunloadframe;	// unload too far grass to save video memory

	Vector		ambientLight;	// at vieworg
	int		waterlevel;	// player waterlevel
	cl_entity_t	*waterentity;	// player inside

	// fog params
	bool		fogEnabled;
	Vector		fogColor;
	float		fogDensity;
	float		fogSkyDensity;

	// sky params
	Vector		sky_origin;
	Vector		sky_world_origin;
	float		sky_speed;

	Vector		sky_normal;	// sky vector
	Vector		sky_ambient;	// sky ambient color

	// global ambient\direct factors
	float		ambientFactor;
	float		diffuseFactor;

	float		sun_refract;
	float		sun_ambient;
	Vector		sun_diffuse;

	CDynLight		*sunlight;		// sun is active if not a NULL

	Vector		screen_normals[4];		// helper to transform world->screen space

	float		farclip;			// max viewable distance
	float		gravity;			// particles used

	float		lightstyle[MAX_LIGHTSTYLES];	// value 0 - 65536
	gl_movie_t	cinematics[MAX_MOVIES];	// precached cinematics

	struct movevars_s	*movevars;

	// generic light that used to cache shaders
	CDynLight		defaultlightSpot;
	CDynLight		defaultlightOmni;
	CDynLight		defaultlightProj;

	matdesc_t		*materials;
	unsigned int	matcount;


	bool		params_changed;		// some cvars are toggled, shaders needs to recompile and resort
	bool		local_client_added;		// indicate what a local client already been added into renderlist
	bool		sun_light_enabled;		// map have a light_environment with valid direction
	bool		lighting_changed;		// r_lighting_modulate was changed
	bool		shadows_notsupport;		// no shadow textures
	bool		show_uniforms_peak;		// print the maxcount of used uniforms
	int		glsl_valid_sequence;	// reloas shaders while some render cvars was changed
	int		total_vbo_memory;		// statistics
	Vector4D		gamma_table[64];

	CDynLight		dlights[MAX_DLIGHTS];

	vec3_t		ambient_color;
	float		direct_scale;
	float		light_gamma;
	float		light_threshold;
	float		smoothing_threshold;

	// original player vieworg and angles
	Vector		cached_vieworigin;
	Vector		cached_viewangles;

	struct mvbocache_s	*vertex_light_cache[MAX_LIGHTCACHE];	// FIXME: make growable
	struct mvbocache_s	*surface_light_cache[MAX_LIGHTCACHE];

	// cull info
	Vector		modelorg;		// relative to viewpoint
} ref_globals_t;

typedef struct
{
	unsigned int	c_world_leafs;
	unsigned int	c_world_nodes;	// walking by BSP tree

	unsigned int	c_culled_entities;
	unsigned int	c_total_tris;	// triangle count

	unsigned int	c_subview_passes;
	unsigned int	c_shadow_passes;

	unsigned int	c_worldlights;
	unsigned int	c_occlusion_culled;	// culled by occlusion query

	unsigned int	c_screen_copy;	// how many times screen was copied

	unsigned int	num_shader_binds;
	unsigned int	num_flushes;

	msurface_t	*debug_surface;
} ref_stats_t;

typedef struct
{
	double		compile_shader;
	double		create_light_cache;
	double		create_buffer_object;
	double		total_buildtime;
} ref_buildstats_t;

typedef enum
{
	GLHW_GENERIC,		// where everthing works the way it should
	GLHW_RADEON,		// where you don't have proper GLSL support
	GLHW_NVIDIA		// Geforce 8/9 class DX10 hardware
} glHWType_t;

typedef struct
{
	int		width, height;
	int		defWidth, defHeight;
	qboolean		fullScreen;
	qboolean		wideScreen;

	int		faceCull;
	int		frontFace;
	int		frameBuffer;

	GLfloat		depthmin;
	GLfloat		depthmax;
	GLint		depthmask;
	GLfloat		identityMatrix[16];

	ref_instance_t	stack[MAX_REF_STACK];
	GLuint		stack_position;
} glState_t;

typedef struct
{
	const char	*renderer_string;		// ptrs to OpenGL32.dll, use with caution
	const char	*version_string;
	const char	*vendor_string;

	glHWType_t	hardware_type;
	float		version;

	// list of supported extensions
	const char	*extensions_string;
	bool		extension[R_EXTCOUNT];

	int		block_size;		// lightmap blocksize
	
	int		max_texture_units;
	GLint		max_2d_texture_size;
	GLint		max_3d_texture_size;
	GLint		max_2d_texture_layers;
	GLint		max_cubemap_size;
	GLint		binary_formats;
	GLint		num_formats;

	int		max_vertex_uniforms;
	int		max_vertex_attribs;
	int		max_varying_floats;
	int		max_skinning_bones;		// total bones that can be transformed with GLSL
	int		peak_used_uniforms;
} glConfig_t;

extern glState_t		glState;
extern glConfig_t		glConfig;
extern engine_studio_api_t	IEngineStudio;
extern float		gldepthmin, gldepthmax;
extern int		sunSize[MAX_SHADOWMAPS];
extern char		r_speeds_msg[2048];
extern char		r_depth_msg[2048];
extern model_t		*worldmodel;
extern int		g_iGunMode;
extern ref_stats_t		r_stats;
extern ref_buildstats_t	r_buildstats;
extern ref_instance_t	*RI;
extern ref_globals_t	tr;

//
// gl_backend.cpp
//
void R_InitRefState( void );
void R_PushRefState( void );
void R_PopRefState( void );
void R_ResetRefState( void );
ref_instance_t *R_GetPrevInstance( void );
void CompressNormalizedVector( char outVec[3], const Vector &inVec );
bool GL_BackendStartFrame( ref_viewpass_t *rvp, int params );
void GL_BackendEndFrame( ref_viewpass_t *rvp, int params );
int R_GetSpriteTexture( const model_t *m_pSpriteModel, int frame );
void GL_BindDrawbuffer( gl_drawbuffer_t *framebuffer );
void GL_DepthRange( GLfloat depthmin, GLfloat depthmax );
void R_RenderQuadPrimitive( CSolidEntry *entry );
void GL_LoadMatrix( const matrix4x4 &source );
void GL_LoadTexMatrix( const matrix4x4 &source );
void GL_BindFrameBuffer( int buffer, int texture );
void R_Speeds_Printf( const char *msg, ... );
int R_AllocFrameBuffer( int viewport[4] );
void GL_CheckVertexArrayBinding( void );
void R_FreeFrameBuffer( int buffer );
void GL_CleanupAllTextureUnits( void );
void GL_ComputeScreenRays( void );
void GL_DisableAllTexGens( void );
void GL_DepthMask( GLint enable );
void GL_FrontFace( GLenum front );
void GL_ClipPlane( bool enable );
void GL_BindFBO( GLuint buffer );
void GL_AlphaTest( GLint enable );
void GL_DepthTest( GLint enable );
void GL_CleanupDrawState( void );
void GL_SetDefaultState( void );
void GL_Blend( GLint enable );
void GL_Cull( GLenum cull );
void GL_Setup2D( void );
void GL_Setup3D( void );

//
// gl_cubemaps.cpp
//
void CL_FindNearestCubeMap( const Vector &pos, mcubemap_t **result );
void CL_FindTwoNearestCubeMap( const Vector &pos, mcubemap_t **result1, mcubemap_t **result2 );
void CL_FindNearestCubeMapForSurface( const Vector &pos, const msurface_t *surf, mcubemap_t **result );
void CL_FindTwoNearestCubeMapForSurface( const Vector &pos, const msurface_t *surf, mcubemap_t **result1, mcubemap_t **result2 );
void CL_BuildCubemaps_f( void );

//
// gl_cull.cpp
//
bool R_CullModel( cl_entity_t *e, const Vector &mins, const Vector &maxs );
int R_CullSurface( msurface_t *surf, const Vector &vieworg, CFrustum *frustum, int clipFlags = 0 );
bool R_CullBrushModel( cl_entity_t *e );
bool R_CullNodeTopView( mnode_t *node );

#define R_CullBox( mins, maxs )		( RI->view.frustum.CullBox( mins, maxs ))
#define R_CullSphere( centre, radius )		( RI->view.frustum.CullSphere( centre, radius ))
#define R_CullFrustum( otherFrustum )		( RI->view.frustum.CullFrustum( otherFrustum ))

//
// gl_debug.cpp
//
void DBG_PrintVertexVBOSizes( void );
void DBG_DrawLightFrustum( void );
void DBG_DrawGlassScissors( void );
void DrawLightProbes( void );
void R_ShowLightMaps( void );
void R_RenderLightProbeInternal( const Vector &origin, const Vector lightCube[] );
void DBG_DrawBBox( const Vector &mins, const Vector &maxs );
void DrawWirePoly( msurface_t *surf );
void DrawTangentSpaces( void );
void DrawWireFrame( void );
void DrawViewLeaf( void );
void DrawCubeMaps( void );

//
// gl_deferred.cpp
//
void GL_SetupGBuffer( void );
void GL_ResetGBuffer( void );
void GL_DrawDeferredPass( void );

//
// gl_framebuffer.c
//
gl_drawbuffer_t *GL_AllocDrawbuffer( const char *name, int width, int height, int depth = 1 );
void GL_ResizeDrawbuffer( gl_drawbuffer_t *fbo, int width, int height, int depth = 1 );
void GL_AttachColorTextureToFBO( gl_drawbuffer_t *fbo, int textrue, int colorIndex, int side = 0 );
void GL_AttachDepthTextureToFBO( gl_drawbuffer_t *fbo, int texture, int side = 0 );
void GL_CheckFBOStatus( gl_drawbuffer_t *fbo );
void GL_VidInitDrawBuffers( void );
void GL_FreeDrawbuffers( void );

//
// gl_lightmap.cpp
//
void R_UpdateSurfaceParams( msurface_t *surf );
void R_UpdateSurfaceParams( struct mstudiosurface_s *surf );
void GL_BeginBuildingLightmaps( void );
void GL_AllocLightmapForFace( msurface_t *surf );
bool GL_AllocLightmapForFace( struct mstudiosurface_s *surf );
void GL_EndBuildingLightmaps( bool lightmap, bool deluxmap );
void R_TextureCoords( msurface_t *surf, const Vector &vec, float *out );
void R_GlobalCoords( msurface_t *surf, const Vector &point, float *out );
void R_GlobalCoords( msurface_t *surf, const Vector &point, const Vector &absmin, const Vector &absmax, float scale, float *out );
void R_LightmapCoords( msurface_t *surf, const Vector &vec, float *coords, int style );
void R_LightmapCoords( struct mstudiosurface_s *surf, const Vector &vec, const Vector lmvecs[2], float *coords, int style );

//
// gl_rlight.cpp
//
CDynLight *CL_AllocDlight( int key );
void R_GetLightVectors( cl_entity_t *pEnt, Vector &origin, Vector &angles );
void R_SetupLightParams( CDynLight *pl, const Vector &origin, const Vector &angles, float radius, float fov, int type, int flags = 0 );
void R_FindWorldLights( const Vector &origin, const Vector &mins, const Vector &maxs, byte lights[MAXDYNLIGHTS], bool skipZ = false );
void R_LightForStudio( const Vector &point, mstudiolight_t *light, bool ambient );
void R_PointAmbientFromLeaf( const Vector &point, mstudiolight_t *light );
void R_LightForSky( const Vector &point, mstudiolight_t *light );
void R_LightVec( const Vector &point, mstudiolight_t *light, bool ambient );
Vector R_LightsForPoint( const Vector &point, float radius );
void R_SetupLightTexture( CDynLight *pl, int texture );
void R_SetupDynamicLights( void );
void CL_ClearDlights( void );
void R_AnimateLight( void );
int HasDynamicLights( void );
int HasStaticLights( void );
void CL_DecayLights( void );

//
// gl_rmain.cpp
//
void R_ClearScene( void );
int R_ComputeFxBlend( cl_entity_t *e );
void R_RenderScene( const ref_viewpass_t *rvp, int params );
qboolean R_AddEntity( struct cl_entity_s *clent, int entityType );
bool R_WorldToScreen( const Vector &point, Vector &screen );
void R_ScreenToWorld( const Vector &screen, Vector &point );
void R_SetupProjectionMatrix( float fov_x, float fov_y, matrix4x4 &m );
unsigned short GL_CacheState( const Vector &origin, const Vector &angles, bool skyentity = false );
void R_MarkWorldVisibleFaces( model_t *model );
gl_state_t *GL_GetCache( word hCachedMatrix );
void R_DrawParticles( qboolean trans );
void R_SetupGLstate( void );
void R_RenderTransList( void );
void R_SetupFrustum( void );
void R_Clear( int bitMask );

//
// gl_rmisc.cpp
//
void R_NewMap( void );
void R_VidInit( void );
void CL_InitMaterials( void );
matdesc_t *CL_FindMaterial( const char *name );
void R_LoadLandscapes( const char *filename );
terrain_t *R_FindTerrain( const char *texname );
void R_InitDynLightShaders( void );
void R_InitShadowTextures( void );
void R_FreeLandscapes( void );

//
// gl_rsurf.cpp
//
texture_t *R_TextureAnimation( msurface_t *s );
void GL_InitRandomTable( void );

//
// gl_shader.cpp
//
const char *GL_PretifyListOptions( const char *options, bool newlines = false );
word GL_FindUberShader( const char *glname, const char *options = "" );
word GL_FindShader( const char *glname, const char *vpname, const char *fpname, const char *options = "" );
void GL_SetShaderDirective( char *options, const char *directive );
void GL_AddShaderDirective( char *options, const char *directive );
void GL_AddShaderFeature( word shaderNum, int feature );
void GL_CheckTextureAlpha( char *options, int texturenum );
void GL_EncodeNormal( char *options, int texturenum );
void GL_BindShader( struct glsl_prog_s *shader );
void GL_FreeUberShaders( void );
void GL_InitGPUShaders( void );
void GL_FreeGPUShaders( void );

//
// gl_shadows.cpp
//
void R_RenderShadowmaps( void );
void R_RenderDeferredShadows( void );

//
// gl_movie.cpp
//
void R_InitCinematics( void );
void R_FreeCinematics( void );
int R_PrecacheCinematic( const char *cinname );
int R_AllocateCinematicTexture( unsigned int txFlags );
void R_UpdateCinematic( const msurface_t *surf );
void R_UpdateCinSound( cl_entity_t *e );

//
// gl_mirror.cpp
//
void R_RenderSubview( void );

//
// gl_scene.cpp
//
void R_CheckChanges( void );
void R_InitDefaultLights( void );

//
// gl_sky.cpp
//
void R_AddSkyBoxSurface( msurface_t *fa );
void R_DrawSkyBox( void );

//
// gl_postprocess.cpp
//
void InitPostTextures( void );
void InitPostEffects( void );
void RenderDOF( void );
void RenderUnderwaterBlur( void );
void RenderNerveGasBlur( void );
void RenderMonochrome( void );
void RenderSunShafts( void );
void RenderFSQ( int wide, int tall );

//
// gl_world_new.cpp
//
void Mod_ThrowModelInstances( void );
void Mod_PrepareModelInstances( void );
void GL_LoadAndRebuildCubemaps( int refParams );
void Mod_SetOrthoBounds( const float *mins, const float *maxs );
bool Mod_CheckLayerNameForSurf( msurface_t *surf, const char *checkName );
bool Mod_CheckLayerNameForPixel( mfaceinfo_t *land, const Vector &point, const char *checkName );
int Mod_FatPVS( model_t *model, const vec3_t org, float radius, byte *visbuffer, int visbytes, bool merge, bool fullvis );
void Mod_FindStaticLights( byte *vislight, byte lights[MAXDYNLIGHTS], const Vector &origin );
void R_ProcessWorldData( model_t *mod, qboolean create, const byte *buffer );
bool R_AddSurfaceToDrawList( msurface_t *surf, drawlist_t type );
void R_MarkVisibleLights( byte lights[MAXDYNLIGHTS] );
gl_texbuffer_t *Surf_GetSubview( mextrasurf_t *es );
void R_RenderTransSurface( CTransEntry *entry );
int Mod_SampleSizeForFace( msurface_t *surf );
bool Surf_CheckSubview( mextrasurf_t *es, bool puddle = false );
void R_RenderDynLightList( bool solid );
void R_MarkSubmodelVisibleFaces( void );
void Mod_InitBSPModelsTexture( void );
void R_UpdateSubmodelParams( void );
void Mod_ResortFaces( void );

//
// gl_world.cpp
//
void R_RenderDeferredBrushList( void );
void R_RenderSolidBrushList( void );
void R_RenderShadowBrushList( void );
void R_RenderSurfOcclusionList( void );

//
// rain.cpp
//
void R_DrawWeather( void );
void ParseRain( void );
void ResetRain( void );
void InitRain( void );

#endif//GL_LOCAL_H