#include "svbsp.h"
#include "r_stats.h"
#include "r_modules.h"
#include "meshqueue.h"
#include "gl_backend.h"

Include dependency graph for render.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	r_framebufferstate_t
struct	r_refdef_scene_t
struct	r_refdef_t
struct	r_refdef_view_t
struct	r_refdef_viewcache_t
struct	r_rendertarget_t
struct	r_viewport_t
struct	r_waterstate_t
struct	r_waterstate_waterplane_t
struct	rmesh_t
struct	rsurfacestate_t

Macros
#define	BATCHNEED_ALLOWMULTIDRAW (1<<10)
#define	BATCHNEED_ALWAYSCOPY (1<< 9)
#define	BATCHNEED_ARRAY_LIGHTMAP (1<< 6)
#define	BATCHNEED_ARRAY_NORMAL (1<< 1)
#define	BATCHNEED_ARRAY_SKELETAL (1<< 7)
#define	BATCHNEED_ARRAY_TEXCOORD (1<< 5)
#define	BATCHNEED_ARRAY_VECTOR (1<< 2)
#define	BATCHNEED_ARRAY_VERTEX (1<< 0)
#define	BATCHNEED_ARRAY_VERTEXCOLOR (1<< 4)
#define	BATCHNEED_ARRAY_VERTEXTINTCOLOR (1<< 3)
#define	BATCHNEED_NOGAPS (1<< 8)
#define	BOTTOM_RANGE 96
#define	FOGMASKTABLEWIDTH 1024
#define	gl_alpha_format 4
#define	gl_solid_format 3
#define	SHADERPERMUTATION_ALPHAGEN_VERTEX (1u<<29)
	alphaGen vertex
#define	SHADERPERMUTATION_ALPHAKILL (1u<<22)
	(deferredgeometry) discard pixel if diffuse texture alpha below 0.5, (generic) apply global alpha
#define	SHADERPERMUTATION_BLOOM (1u<<12)
	bloom (postprocessing only)
#define	SHADERPERMUTATION_BOUNCEGRID (1u<<25)
	(lightmap) use Texture_BounceGrid as an additional source of ambient light
#define	SHADERPERMUTATION_BOUNCEGRIDDIRECTIONAL (1u<<26)
	(lightmap) use 16-component pixels in bouncegrid texture for directional lighting rather than standard 4-component
#define	SHADERPERMUTATION_COLORMAPPING (1u<<3)
	indicates this is a colormapped skin
#define	SHADERPERMUTATION_COUNT 32u
	size of shaderpermutationinfo array
#define	SHADERPERMUTATION_CUBEFILTER (1u<<10)
	(lightsource) use cubemap light filter
#define	SHADERPERMUTATION_DEFERREDLIGHTMAP (1u<<21)
	(lightmap) read Texture_ScreenDiffuse/Specular textures and add them on top of lightmapping
#define	SHADERPERMUTATION_DEPTHRGB (1u<<28)
	read/write depth values in RGB color coded format for older hardware without depth samplers
#define	SHADERPERMUTATION_DIFFUSE (1u<<0)
	(lightsource) whether to use directional shading
#define	SHADERPERMUTATION_FOGALPHAHACK (1u<<8)
	fog color and density determined by texture mapped on vertical axis
#define	SHADERPERMUTATION_FOGHEIGHTTEXTURE (1u<<7)
	fog color and density determined by texture mapped on vertical axis
#define	SHADERPERMUTATION_FOGINSIDE (1u<<5)
	tint the color by fog color or black if using additive blend mode
#define	SHADERPERMUTATION_FOGOUTSIDE (1u<<6)
	tint the color by fog color or black if using additive blend mode
#define	SHADERPERMUTATION_GAMMARAMPS (1u<<9)
	gamma (postprocessing only)
#define	SHADERPERMUTATION_GLOW (1u<<11)
	(lightmap) blend in an additive glow texture
#define	SHADERPERMUTATION_NORMALMAPSCROLLBLEND (1u<<24)
	(water) counter-direction normalmaps scrolling
#define	SHADERPERMUTATION_OCCLUDE (1u<<31)
	use occlusion buffer for corona
#define	SHADERPERMUTATION_OFFSETMAPPING (1u<<16)
	adjust texcoords to roughly simulate a displacement mapped surface
#define	SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING (1u<<17)
	adjust texcoords to accurately simulate a displacement mapped surface (requires OFFSETMAPPING to also be set!)
#define	SHADERPERMUTATION_POSTPROCESSING (1u<<14)
	user defined postprocessing (postprocessing only)
#define	SHADERPERMUTATION_REFLECTCUBE (1u<<23)
	fake reflections using global cubemap (not HDRI light probe)
#define	SHADERPERMUTATION_REFLECTION (1u<<15)
	normalmap-perturbed reflection of the scene infront of the surface, preformed as an overlay on the surface
#define	SHADERPERMUTATION_SATURATION (1u<<4)
	saturation (postprocessing only)
#define	SHADERPERMUTATION_SHADOWMAP2D (1u<<18)
	(lightsource) use shadowmap texture as light filter
#define	SHADERPERMUTATION_SHADOWMAPORTHO (1u<<20)
	(lightsource) use orthographic shadowmap projection
#define	SHADERPERMUTATION_SHADOWMAPVSDCT (1u<<19)
	(lightsource) use virtual shadow depth cube texture for shadowmap indexing
#define	SHADERPERMUTATION_SKELETAL (1u<<30)
	(skeletal models) use skeletal matrices to deform vertices (gpu-skinning)
#define	SHADERPERMUTATION_SPECULAR (1u<<13)
	(lightsource or deluxemapping) render specular effects
#define	SHADERPERMUTATION_TRIPPY (1u<<27)
	use trippy vertex shader effect
#define	SHADERPERMUTATION_VERTEXTEXTUREBLEND (1u<<1)
	indicates this is a two-layer material blend based on vertex alpha (q3bsp)
#define	SHADERPERMUTATION_VIEWTINT (1u<<2)
	view tint (postprocessing only), use vertex colors (generic only)
#define	TOP_RANGE 16

Enumerations
enum	glsl_attrib { GLSLATTRIB_POSITION = 0 , GLSLATTRIB_COLOR = 1 , GLSLATTRIB_TEXCOORD0 = 2 , GLSLATTRIB_TEXCOORD1 = 3 , GLSLATTRIB_TEXCOORD2 = 4 , GLSLATTRIB_TEXCOORD3 = 5 , GLSLATTRIB_TEXCOORD4 = 6 , GLSLATTRIB_TEXCOORD5 = 7 , GLSLATTRIB_TEXCOORD6 = 8 , GLSLATTRIB_TEXCOORD7 = 9 }
enum	r_bufferdata_type_t { R_BUFFERDATA_VERTEX , R_BUFFERDATA_INDEX16 , R_BUFFERDATA_INDEX32 , R_BUFFERDATA_UNIFORM , R_BUFFERDATA_COUNT }
	enum of the various types of hardware buffer object used in rendering note that the r_buffermegs[] array must be maintained to match this More...
enum	r_refdef_scene_type_t { RST_CLIENT , RST_MENU , RST_COUNT }
enum	r_viewport_type_t { R_VIEWPORTTYPE_ORTHO , R_VIEWPORTTYPE_PERSPECTIVE , R_VIEWPORTTYPE_PERSPECTIVE_INFINITEFARCLIP , R_VIEWPORTTYPE_PERSPECTIVECUBESIDE , R_VIEWPORTTYPE_TOTAL }
enum	rsurfacepass_t { RSURFPASS_BASE , RSURFPASS_BACKGROUND , RSURFPASS_RTLIGHT , RSURFPASS_DEFERREDGEOMETRY }
enum	shaderlanguage_t { SHADERLANGUAGE_GLSL , SHADERLANGUAGE_COUNT }
enum	shadermode_t { SHADERMODE_GENERIC , SHADERMODE_POSTPROCESS , SHADERMODE_DEPTH_OR_SHADOW , SHADERMODE_FLATCOLOR , SHADERMODE_VERTEXCOLOR , SHADERMODE_LIGHTMAP , SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE , SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE , SHADERMODE_LIGHTDIRECTIONMAP_FORCED_LIGHTMAP , SHADERMODE_LIGHTDIRECTIONMAP_FORCED_VERTEXCOLOR , SHADERMODE_LIGHTGRID , SHADERMODE_LIGHTDIRECTION , SHADERMODE_LIGHTSOURCE , SHADERMODE_REFRACTION , SHADERMODE_WATER , SHADERMODE_DEFERREDGEOMETRY , SHADERMODE_DEFERREDLIGHTSOURCE , SHADERMODE_COUNT }
	this enum selects which of the glslshadermodeinfo entries should be used More...

Functions
void	CL_VM_DrawHud (double frametime)
qbool	CL_VM_UpdateView (double frametime)
dp_font_t *	FindFont (const char *title, qbool allocate_new)
void	FOG_clear (void)
void	Font_Init (void)
void	gl_backend_init (void)
void	GL_Draw_Init (void)
void	GL_Main_Init (void)
void	GL_Surf_Init (void)
void	LoadFont (qbool override, const char name, dp_font_t fnt, float scale, float voffset)
void	Mod_RenderInit (void)
void	R_AnimCache_CacheVisibleEntities (void)
	generate animcache data for all entities marked visible
void	R_AnimCache_ClearCache (void)
	clear the animcache pointers on all known render entities
void	R_AnimCache_Free (void)
	free all R_AnimCache memory
qbool	R_AnimCache_GetEntity (entity_render_t *ent, qbool wantnormals, qbool wanttangents)
	get the skeletal data or cached animated mesh data for an entity (optionally with normals and tangents)
void	R_BufferData_NewFrame (void)
	begin a new frame (recycle old buffers)
void	R_BufferData_Reset (void)
	free all dynamic vertex/index/uniform buffers
r_meshbuffer_t *	R_BufferData_Store (size_t size, const void data, r_bufferdata_type_t type, int returnbufferoffset)
	request space in a vertex/index/uniform buffer for the chosen data, returns the buffer pointer and offset, always successful
void	R_BuildLightMap (const entity_render_t ent, msurface_t surface, int combine)
void	R_CalcBeam_Vertex3f (float vert, const float org1, const float *org2, float width)
void	R_CalcSprite_Vertex3f (float *vertex3f, const vec3_t origin, const vec3_t left, const vec3_t up, float scalex1, float scalex2, float scaley1, float scaley2)
qbool	R_CanSeeBox (int numsamples, vec_t eyejitter, vec_t entboxenlarge, vec_t entboxexpand, vec_t pad, vec3_t eye, vec3_t entboxmins, vec3_t entboxmaxs)
qbool	R_CompileShader_CheckStaticParms (void)
qbool	R_CullBox (const vec3_t mins, const vec3_t maxs, int numplanes, const mplane_t *planes)
qbool	R_CullFrustum (const vec3_t mins, const vec3_t maxs)
void	R_DebugLine (vec3_t start, vec3_t end)
void	R_DecalSystem_Reset (decalsystem_t *decalsystem)
void	R_DecalSystem_SplatEntities (const vec3_t org, const vec3_t normal, float r, float g, float b, float a, float s1, float t1, float s2, float t2, float size)
void	R_DrawCustomSurface (skinframe_t skinframe, const matrix4x4_t texmatrix, int materialflags, int firstvertex, int numvertices, int firsttriangle, int numtriangles, qbool writedepth, qbool prepass, qbool ui)
void	R_DrawCustomSurface_Texture (texture_t texture, const matrix4x4_t texmatrix, int materialflags, int firstvertex, int numvertices, int firsttriangle, int numtriangles, qbool writedepth, qbool prepass, qbool ui)
void	R_DrawExplosions (void)
void	R_DrawModelSurfaces (entity_render_t *ent, qbool skysurfaces, qbool writedepth, qbool depthonly, qbool debug, qbool prepass, qbool ui)
void	R_DrawParticles (void)
void	R_DrawPortals (void)
void	R_Explosion_Init (void)
void	R_FillColors (float *out, int verts, float r, float g, float b, float a)
void *	R_FrameData_Alloc (size_t size)
	allocate some temporary memory for your purposes
void	R_FrameData_NewFrame (void)
	prepare for a new frame, recycles old buffers if a resize occurred previously
void	R_FrameData_Reset (void)
	free all R_FrameData memory
void	R_FrameData_ReturnToMark (void)
	discard recent memory allocations (rewind to marker)
void	R_FrameData_SetMark (void)
	set a marker that allows you to discard the following temporary memory allocations
void *	R_FrameData_Store (size_t size, void *data)
	allocate some temporary memory and copy this data into it
rtexture_t *	R_GetCubemap (const char *basename)
texture_t *	R_GetCurrentTexture (texture_t *t)
r_refdef_scene_t *	R_GetScenePointer (r_refdef_scene_type_t scenetype)
void	R_GLSL_Restart_f (cmd_state_t *cmd)
void	R_HDR_UpdateIrisAdaptation (const vec3_t point)
void	R_LightningBeams_Init (void)
void	R_Mesh_AddBrushMeshFromPlanes (rmesh_t mesh, int numplanes, mplane_t planes)
void	R_Mesh_AddPolygon3f (rmesh_t mesh, int numvertices, float vertex3f)
void	R_Model_Sprite_Draw (entity_render_t *ent)
void	R_ModulateColors (float in, float out, int verts, float r, float g, float b)
void	R_NewExplosion (const vec3_t org)
void	R_Particles_Init (void)
void	R_RenderScene (int viewfbo, rtexture_t viewdepthtexture, rtexture_t viewcolortexture, int viewx, int viewy, int viewwidth, int viewheight)
void	R_RenderTarget_FreeUnused (qbool force)
r_rendertarget_t *	R_RenderTarget_Get (int texturewidth, int textureheight, textype_t depthtextype, qbool depthisrenderbuffer, textype_t colortextype0, textype_t colortextype1, textype_t colortextype2, textype_t colortextype3)
void	R_RenderView (int fbo, rtexture_t depthtexture, rtexture_t colortexture, int x, int y, int width, int height)
void	R_RenderView_UpdateViewVectors (void)
void	R_RenderWaterPlanes (int viewfbo, rtexture_t viewdepthtexture, rtexture_t viewcolortexture, int viewx, int viewy, int viewwidth, int viewheight)
void	R_ResetSkyBox (void)
void	R_ResetViewRendering2D (int viewfbo, rtexture_t viewdepthtexture, rtexture_t viewcolortexture, int viewx, int viewy, int viewwidth, int viewheight)
void	R_ResetViewRendering2D_Common (int viewfbo, rtexture_t viewdepthtexture, rtexture_t viewcolortexture, int viewx, int viewy, int viewwidth, int viewheight, float x2, float y2)
void	R_ResetViewRendering3D (int viewfbo, rtexture_t viewdepthtexture, rtexture_t viewcolortexture, int viewx, int viewy, int viewwidth, int viewheight)
void	R_SelectScene (r_refdef_scene_type_t scenetype)
int	R_SetSkyBox (const char *sky)
void	R_SetupShader_DeferredLight (const rtlight_t *rtlight)
void	R_SetupShader_DepthOrShadow (qbool notrippy, qbool depthrgb, qbool skeletal)
void	R_SetupShader_Generic (rtexture_t *t, qbool usegamma, qbool notrippy, qbool suppresstexalpha)
void	R_SetupShader_Generic_NoTexture (qbool usegamma, qbool notrippy)
void	R_SetupShader_Surface (const float ambientcolor[3], const float diffusecolor[3], const float specularcolor[3], rsurfacepass_t rsurfacepass, int texturenumsurfaces, const msurface_t *texturesurfacelist, void waterplane, qbool notrippy, qbool ui)
void	R_SetupView (qbool allowwaterclippingplane, int viewfbo, rtexture_t viewdepthtexture, rtexture_t viewcolortexture, int viewx, int viewy, int viewwidth, int viewheight)
void	R_Shadow_EditLights_DrawSelectedLightProperties (void)
int	R_Shadow_GetRTLightInfo (unsigned int lightindex, float origin, float radius, float *color)
void	R_Shadow_Init (void)
void	R_Shadow_UpdateBounceGridTexture (void)
skinframe_t *	R_SkinFrame_Find (const char *name, int textureflags, int comparewidth, int compareheight, int comparecrc, qbool add)
skinframe_t *	R_SkinFrame_FindNextByName (skinframe_t last, const char name)
skinframe_t *	R_SkinFrame_LoadExternal (const char *name, int textureflags, qbool complain, qbool fallbacknotexture)
skinframe_t *	R_SkinFrame_LoadExternal_SkinFrame (skinframe_t skinframe, const char name, int textureflags, qbool complain, qbool fallbacknotexture)
skinframe_t *	R_SkinFrame_LoadInternal8bit (const char name, int textureflags, const unsigned char skindata, int width, int height, const unsigned int palette, const unsigned int alphapalette)
skinframe_t *	R_SkinFrame_LoadInternalBGRA (const char name, int textureflags, const unsigned char skindata, int width, int height, int comparewidth, int compareheight, int comparecrc, qbool sRGB)
skinframe_t *	R_SkinFrame_LoadInternalQuake (const char name, int textureflags, int loadpantsandshirt, int loadglowtexture, const unsigned char skindata, int width, int height)
skinframe_t *	R_SkinFrame_LoadInternalUsingTexture (const char name, int textureflags, rtexture_t tex, int width, int height, qbool sRGB)
skinframe_t *	R_SkinFrame_LoadMissing (void)
skinframe_t *	R_SkinFrame_LoadNoTexture (void)
void	R_SkinFrame_MarkUsed (skinframe_t *skinframe)
void	R_SkinFrame_PrepareForPurge (void)
void	R_SkinFrame_Purge (void)
void	R_SkinFrame_PurgeSkinFrame (skinframe_t *skinframe)
void	R_Sky (void)
void	R_Sky_Init (void)
void	R_SkyStartFrame (void)
void	R_Stain (const vec3_t origin, float radius, int cr1, int cg1, int cb1, int ca1, int cr2, int cg2, int cb2, int ca2)
void	R_Textures_Init (void)
void	R_TimeReport (const char *name)
void	R_UpdateFog (void)
void	R_UpdateVariables (void)
void	R_View_WorldVisibility (qbool forcenovis)
void	R_Water_AddWaterPlane (msurface_t *surface, int entno)
void	Render_Init (void)
void	RSurf_ActiveCustomEntity (const matrix4x4_t matrix, const matrix4x4_t inversematrix, int entflags, double shadertime, float r, float g, float b, float a, int numvertices, const float vertex3f, const float texcoord2f, const float normal3f, const float svector3f, const float tvector3f, const float color4f, int numtriangles, const int element3i, const unsigned short element3s, qbool wantnormals, qbool wanttangents)
void	RSurf_ActiveModelEntity (const entity_render_t *ent, qbool wantnormals, qbool wanttangents, qbool prepass)
void	RSurf_DrawBatch (void)
float	RSurf_FogPoint (const float *v)
float	RSurf_FogVertex (const float *v)
void	RSurf_PrepareVerticesForBatch (int batchneed, int texturenumsurfaces, const msurface_t **texturesurfacelist)
void	RSurf_SetupDepthAndCulling (bool ui)
void	RSurf_UploadBuffersForBatch (void)
void	Sbar_Init (void)
void	SCR_DrawConsole (void)
void	SHOWLMP_decodehide (void)
void	SHOWLMP_decodeshow (void)
void	SHOWLMP_drawall (void)

Variables
cvar_t	cl_deathfade
cvar_t	developer_texturelogging
cvar_t	gl_flashblend
cvar_t	gl_polyblend
float	ixtable [4096]
cvar_t	r_ambient
cvar_t	r_draw2d
qbool	r_draw2d_force
cvar_t	r_drawentities
cvar_t	r_drawviewmodel
cvar_t	r_drawworld
cvar_t	r_dynamic
r_framebufferstate_t	r_fb
cvar_t	r_fullbright
cvar_t	r_fxaa
cvar_t	r_glsl_deluxemapping
cvar_t	r_glsl_offsetmapping
cvar_t	r_glsl_offsetmapping_lod
cvar_t	r_glsl_offsetmapping_lod_distance
cvar_t	r_glsl_offsetmapping_reliefmapping
cvar_t	r_glsl_offsetmapping_scale
cvar_t	r_lerplightstyles
cvar_t	r_lerpmodels
cvar_t	r_lerpsprites
mempool_t *	r_main_mempool
unsigned int	r_maxqueries
cvar_t	r_nearclip
cvar_t	r_novis
unsigned int	r_numqueries
cvar_t	r_q1bsp_lightmap_updates_combine
cvar_t	r_q1bsp_lightmap_updates_combine_full_texture
cvar_t	r_q1bsp_lightmap_updates_enabled
cvar_t	r_q1bsp_lightmap_updates_hidden_surfaces
cvar_t	r_q3bsp_renderskydepth
unsigned int	r_queries [MAX_OCCLUSION_QUERIES]
r_refdef_t	r_refdef
cvar_t	r_render
cvar_t	r_renderview
const float	r_screenvertex3f [12]
	vertex coordinates for a quad that covers the screen exactly
rtexture_t *	r_shadow_attenuation2dtexture
rtexture_t *	r_shadow_attenuation3dtexture
rtexture_t *	r_shadow_attenuationgradienttexture
float	r_shadow_lightshadowmap_parameters [4]
float	r_shadow_lightshadowmap_texturescale [4]
float	r_shadow_modelshadowmap_parameters [4]
float	r_shadow_modelshadowmap_texturescale [4]
int	r_shadow_prepass_height
int	r_shadow_prepass_width
rtexture_t *	r_shadow_prepassgeometrydepthbuffer
rtexture_t *	r_shadow_prepassgeometrynormalmaptexture
rtexture_t *	r_shadow_prepasslightingdiffusetexture
rtexture_t *	r_shadow_prepasslightingspeculartexture
rtexture_t *	r_shadow_shadowmap2ddepthbuffer
rtexture_t *	r_shadow_shadowmap2ddepthtexture
matrix4x4_t	r_shadow_shadowmapmatrix
qbool	r_shadow_shadowmapvsdct
rtexture_t *	r_shadow_shadowmapvsdcttexture
qbool	r_shadow_usingdeferredprepass
qbool	r_shadow_usingshadowmap2d
qbool	r_shadow_usingshadowmaportho
rtexture_t *	r_shadow_viewcolortexture
rtexture_t *	r_shadow_viewdepthtexture
int	r_shadow_viewfbo
int	r_shadow_viewheight
int	r_shadow_viewwidth
int	r_shadow_viewx
int	r_shadow_viewy
cvar_t	r_shadows
cvar_t	r_shadows_castfrombmodels
cvar_t	r_shadows_darken
cvar_t	r_shadows_drawafterrtlighting
cvar_t	r_shadows_focus
cvar_t	r_shadows_shadowmapbias
cvar_t	r_shadows_shadowmapscale
cvar_t	r_shadows_throwdirection
cvar_t	r_shadows_throwdistance
cvar_t	r_showcollisionbrushes
cvar_t	r_showcollisionbrushes_polygonfactor
cvar_t	r_showcollisionbrushes_polygonoffset
cvar_t	r_showdisabledepthtest
cvar_t	r_showlighting
cvar_t	r_shownormals
cvar_t	r_showoverdraw
cvar_t	r_showparticleedges
cvar_t	r_showspriteedges
cvar_t	r_showtris
cvar_t	r_sky
cvar_t	r_sky_scissor
cvar_t	r_skyscroll1
cvar_t	r_skyscroll2
cvar_t	r_smoothnormals_areaweighting
cvar_t	r_speeds
svbsp_t	r_svbsp
	shadow volume bsp struct with automatically growing nodes buffer
cvar_t	r_test
rtexture_t *	r_texture_black
rtexture_t *	r_texture_blanknormalmap
rtexture_t *	r_texture_fogattenuation
rtexture_t *	r_texture_fogheighttexture
rtexture_t *	r_texture_grey128
rtexture_t *	r_texture_normalizationcube
rtexture_t *	r_texture_notexture
rtexture_t *	r_texture_white
rtexture_t *	r_texture_whitecube
int	r_textureframe
	used only by R_GetCurrentTexture, incremented per view and per UI render
int	r_timereport_active
cvar_t	r_transparent_alphatocoverage
cvar_t	r_transparent_sortarraysize
cvar_t	r_transparent_sortmaxdist
cvar_t	r_transparent_sortmindist
cvar_t	r_transparent_sortsurfacesbynearest
cvar_t	r_transparent_useplanardistance
cvar_t	r_trippy
cvar_t	r_viewfbo
cvar_t	r_wateralpha
cvar_t	r_waterscroll
cvar_t	r_waterwarp
rsurfacestate_t	rsurface
int	skyrenderlater
int	skyrendermasked
int	skyscissor [4]

Macro Definition Documentation

◆ BATCHNEED_ALLOWMULTIDRAW

#define BATCHNEED_ALLOWMULTIDRAW (1<<10)

Definition at line 795 of file render.h.

Referenced by R_DrawSurface_TransparentCallback(), R_DrawTextureSurfaceList_DepthOnly(), R_DrawTextureSurfaceList_Sky(), R_Mod_DrawShadowMap(), R_SetupShader_Surface(), and RSurf_PrepareVerticesForBatch().

◆ BATCHNEED_ALWAYSCOPY

#define BATCHNEED_ALWAYSCOPY (1<< 9)

Definition at line 794 of file render.h.

Referenced by R_DrawTextureSurfaceList_ShowSurfaces(), and RSurf_PrepareVerticesForBatch().

◆ BATCHNEED_ARRAY_LIGHTMAP

#define BATCHNEED_ARRAY_LIGHTMAP (1<< 6)

Definition at line 791 of file render.h.

Referenced by R_SetupShader_Surface(), and RSurf_PrepareVerticesForBatch().

◆ BATCHNEED_ARRAY_NORMAL

#define BATCHNEED_ARRAY_NORMAL (1<< 1)

Definition at line 786 of file render.h.

Referenced by R_DrawDebugModel(), R_SetupShader_Surface(), R_Water_AddWaterPlane(), and RSurf_PrepareVerticesForBatch().

◆ BATCHNEED_ARRAY_SKELETAL

#define BATCHNEED_ARRAY_SKELETAL (1<< 7)

Definition at line 792 of file render.h.

Referenced by RSurf_PrepareVerticesForBatch().

◆ BATCHNEED_ARRAY_TEXCOORD

#define BATCHNEED_ARRAY_TEXCOORD (1<< 5)

Definition at line 790 of file render.h.

Referenced by R_SetupShader_Surface(), and RSurf_PrepareVerticesForBatch().

◆ BATCHNEED_ARRAY_VECTOR

#define BATCHNEED_ARRAY_VECTOR (1<< 2)

Definition at line 787 of file render.h.

Referenced by R_DrawDebugModel(), R_SetupShader_Surface(), and RSurf_PrepareVerticesForBatch().

◆ BATCHNEED_ARRAY_VERTEX

#define BATCHNEED_ARRAY_VERTEX (1<< 0)

Definition at line 785 of file render.h.

Referenced by R_DrawDebugModel(), R_DrawSurface_TransparentCallback(), R_DrawTextureSurfaceList_DepthOnly(), R_DrawTextureSurfaceList_ShowSurfaces(), R_DrawTextureSurfaceList_Sky(), R_Mod_DrawShadowMap(), R_SetupShader_Surface(), R_Shadow_RenderLighting_VisibleLighting(), R_Water_AddWaterPlane(), RSurf_FindWaterPlaneForSurface(), and RSurf_PrepareVerticesForBatch().

◆ BATCHNEED_ARRAY_VERTEXCOLOR

#define BATCHNEED_ARRAY_VERTEXCOLOR (1<< 4)

Definition at line 789 of file render.h.

Referenced by R_DrawTextureSurfaceList_ShowSurfaces(), R_SetupShader_Surface(), and RSurf_PrepareVerticesForBatch().

◆ BATCHNEED_ARRAY_VERTEXTINTCOLOR

#define BATCHNEED_ARRAY_VERTEXTINTCOLOR (1<< 3)

Definition at line 788 of file render.h.

◆ BATCHNEED_NOGAPS

#define BATCHNEED_NOGAPS (1<< 8)

Definition at line 793 of file render.h.

Referenced by R_DrawDebugModel(), R_DrawTextureSurfaceList_Sky(), R_Shadow_RenderLighting_VisibleLighting(), R_Water_AddWaterPlane(), and RSurf_PrepareVerticesForBatch().

◆ BOTTOM_RANGE

#define BOTTOM_RANGE 96

Definition at line 183 of file render.h.

Referenced by M_Setup_Draw().

◆ FOGMASKTABLEWIDTH

#define FOGMASKTABLEWIDTH 1024

Definition at line 428 of file render.h.

Referenced by R_BuildFogTexture(), R_UpdateFog(), RSurf_ActiveCustomEntity(), RSurf_ActiveModelEntity(), RSurf_FogPoint(), and RSurf_FogVertex().

◆ gl_alpha_format

#define gl_alpha_format 4

Definition at line 498 of file render.h.

◆ gl_solid_format

#define gl_solid_format 3

Definition at line 497 of file render.h.

◆ SHADERPERMUTATION_ALPHAGEN_VERTEX

#define SHADERPERMUTATION_ALPHAGEN_VERTEX (1u<<29)

alphaGen vertex

Definition at line 102 of file render.h.

Referenced by R_SetupShader_Surface().

◆ SHADERPERMUTATION_ALPHAKILL

#define SHADERPERMUTATION_ALPHAKILL (1u<<22)

(deferredgeometry) discard pixel if diffuse texture alpha below 0.5, (generic) apply global alpha

Definition at line 95 of file render.h.

Referenced by R_SetupShader_Surface().

◆ SHADERPERMUTATION_BLOOM

#define SHADERPERMUTATION_BLOOM (1u<<12)

bloom (postprocessing only)

Definition at line 85 of file render.h.

Referenced by R_BlendView().

◆ SHADERPERMUTATION_BOUNCEGRID

#define SHADERPERMUTATION_BOUNCEGRID (1u<<25)

(lightmap) use Texture_BounceGrid as an additional source of ambient light

Definition at line 98 of file render.h.

Referenced by R_SetupShader_Surface().

◆ SHADERPERMUTATION_BOUNCEGRIDDIRECTIONAL

#define SHADERPERMUTATION_BOUNCEGRIDDIRECTIONAL (1u<<26)

(lightmap) use 16-component pixels in bouncegrid texture for directional lighting rather than standard 4-component

Definition at line 99 of file render.h.

Referenced by R_SetupShader_Surface().

◆ SHADERPERMUTATION_COLORMAPPING

#define SHADERPERMUTATION_COLORMAPPING (1u<<3)

indicates this is a colormapped skin

Definition at line 76 of file render.h.

Referenced by R_SetupShader_Surface().

◆ SHADERPERMUTATION_COUNT

#define SHADERPERMUTATION_COUNT 32u

size of shaderpermutationinfo array

Definition at line 105 of file render.h.

Referenced by R_GLSL_CompilePermutation(), R_GLSL_DumpShader_f(), and R_SetupShader_SetPermutationGLSL().

◆ SHADERPERMUTATION_CUBEFILTER

#define SHADERPERMUTATION_CUBEFILTER (1u<<10)

(lightsource) use cubemap light filter

Definition at line 83 of file render.h.

Referenced by R_SetupShader_DeferredLight(), and R_SetupShader_Surface().

◆ SHADERPERMUTATION_DEFERREDLIGHTMAP

#define SHADERPERMUTATION_DEFERREDLIGHTMAP (1u<<21)

(lightmap) read Texture_ScreenDiffuse/Specular textures and add them on top of lightmapping

Definition at line 94 of file render.h.

Referenced by R_SetupShader_Surface().

◆ SHADERPERMUTATION_DEPTHRGB

#define SHADERPERMUTATION_DEPTHRGB (1u<<28)

read/write depth values in RGB color coded format for older hardware without depth samplers

Definition at line 101 of file render.h.

Referenced by R_SetupShader_DeferredLight(), R_SetupShader_DepthOrShadow(), and R_SetupShader_Surface().

◆ SHADERPERMUTATION_DIFFUSE

#define SHADERPERMUTATION_DIFFUSE (1u<<0)

(lightsource) whether to use directional shading

Definition at line 73 of file render.h.

Referenced by R_SetupShader_DeferredLight(), R_SetupShader_Generic(), and R_SetupShader_Surface().

◆ SHADERPERMUTATION_FOGALPHAHACK

#define SHADERPERMUTATION_FOGALPHAHACK (1u<<8)

fog color and density determined by texture mapped on vertical axis

Definition at line 81 of file render.h.

Referenced by R_SetupShader_Surface().

◆ SHADERPERMUTATION_FOGHEIGHTTEXTURE

#define SHADERPERMUTATION_FOGHEIGHTTEXTURE (1u<<7)

fog color and density determined by texture mapped on vertical axis

Definition at line 80 of file render.h.

Referenced by R_SetupShader_Surface().

◆ SHADERPERMUTATION_FOGINSIDE

#define SHADERPERMUTATION_FOGINSIDE (1u<<5)

tint the color by fog color or black if using additive blend mode

Definition at line 78 of file render.h.

Referenced by R_SetupShader_Surface().

◆ SHADERPERMUTATION_FOGOUTSIDE

#define SHADERPERMUTATION_FOGOUTSIDE (1u<<6)

tint the color by fog color or black if using additive blend mode

Definition at line 79 of file render.h.

Referenced by R_SetupShader_Surface().

◆ SHADERPERMUTATION_GAMMARAMPS

#define SHADERPERMUTATION_GAMMARAMPS (1u<<9)

gamma (postprocessing only)

Definition at line 82 of file render.h.

Referenced by R_BlendView(), and R_SetupShader_Generic().

◆ SHADERPERMUTATION_GLOW

#define SHADERPERMUTATION_GLOW (1u<<11)

(lightmap) blend in an additive glow texture

Definition at line 84 of file render.h.

Referenced by R_SetupShader_Surface().

◆ SHADERPERMUTATION_NORMALMAPSCROLLBLEND

#define SHADERPERMUTATION_NORMALMAPSCROLLBLEND (1u<<24)

(water) counter-direction normalmaps scrolling

Definition at line 97 of file render.h.

Referenced by R_SetupShader_Surface().

◆ SHADERPERMUTATION_OCCLUDE

#define SHADERPERMUTATION_OCCLUDE (1u<<31)

use occlusion buffer for corona

Definition at line 104 of file render.h.

Referenced by R_SetupShader_Surface().

◆ SHADERPERMUTATION_OFFSETMAPPING

#define SHADERPERMUTATION_OFFSETMAPPING (1u<<16)

adjust texcoords to roughly simulate a displacement mapped surface

Definition at line 89 of file render.h.

Referenced by R_SetupShader_Surface().

◆ SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING

#define SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING (1u<<17)

adjust texcoords to accurately simulate a displacement mapped surface (requires OFFSETMAPPING to also be set!)

Definition at line 90 of file render.h.

Referenced by R_SetupShader_Surface().

◆ SHADERPERMUTATION_POSTPROCESSING

#define SHADERPERMUTATION_POSTPROCESSING (1u<<14)

user defined postprocessing (postprocessing only)

Definition at line 87 of file render.h.

Referenced by R_BlendView().

◆ SHADERPERMUTATION_REFLECTCUBE

#define SHADERPERMUTATION_REFLECTCUBE (1u<<23)

fake reflections using global cubemap (not HDRI light probe)

Definition at line 96 of file render.h.

Referenced by R_SetupShader_Generic(), and R_SetupShader_Surface().

◆ SHADERPERMUTATION_REFLECTION

#define SHADERPERMUTATION_REFLECTION (1u<<15)

normalmap-perturbed reflection of the scene infront of the surface, preformed as an overlay on the surface

Definition at line 88 of file render.h.

Referenced by R_SetupShader_Surface().

◆ SHADERPERMUTATION_SATURATION

#define SHADERPERMUTATION_SATURATION (1u<<4)

saturation (postprocessing only)

Definition at line 77 of file render.h.

Referenced by R_BlendView().

◆ SHADERPERMUTATION_SHADOWMAP2D

#define SHADERPERMUTATION_SHADOWMAP2D (1u<<18)

(lightsource) use shadowmap texture as light filter

Definition at line 91 of file render.h.

Referenced by R_SetupShader_DeferredLight(), and R_SetupShader_Surface().

◆ SHADERPERMUTATION_SHADOWMAPORTHO

#define SHADERPERMUTATION_SHADOWMAPORTHO (1u<<20)

(lightsource) use orthographic shadowmap projection

Definition at line 93 of file render.h.

Referenced by R_SetupShader_Surface().

◆ SHADERPERMUTATION_SHADOWMAPVSDCT

#define SHADERPERMUTATION_SHADOWMAPVSDCT (1u<<19)

(lightsource) use virtual shadow depth cube texture for shadowmap indexing

Definition at line 92 of file render.h.

Referenced by R_SetupShader_DeferredLight(), and R_SetupShader_Surface().

◆ SHADERPERMUTATION_SKELETAL

#define SHADERPERMUTATION_SKELETAL (1u<<30)

(skeletal models) use skeletal matrices to deform vertices (gpu-skinning)

Definition at line 103 of file render.h.

Referenced by R_SetupShader_DepthOrShadow(), and R_SetupShader_Surface().

◆ SHADERPERMUTATION_SPECULAR

#define SHADERPERMUTATION_SPECULAR (1u<<13)

(lightsource or deluxemapping) render specular effects

Definition at line 86 of file render.h.

Referenced by R_SetupShader_DeferredLight(), and R_SetupShader_Surface().

◆ SHADERPERMUTATION_TRIPPY

#define SHADERPERMUTATION_TRIPPY (1u<<27)

use trippy vertex shader effect

Definition at line 100 of file render.h.

Referenced by R_SetupShader_DepthOrShadow(), R_SetupShader_Generic(), and R_SetupShader_Surface().

◆ SHADERPERMUTATION_VERTEXTEXTUREBLEND

#define SHADERPERMUTATION_VERTEXTEXTUREBLEND (1u<<1)

indicates this is a two-layer material blend based on vertex alpha (q3bsp)

Definition at line 74 of file render.h.

Referenced by R_SetupShader_Surface().

◆ SHADERPERMUTATION_VIEWTINT

#define SHADERPERMUTATION_VIEWTINT (1u<<2)

view tint (postprocessing only), use vertex colors (generic only)

Definition at line 75 of file render.h.

Referenced by R_BlendView(), and R_SetupShader_Generic().

◆ TOP_RANGE

#define TOP_RANGE 16

Definition at line 182 of file render.h.

Referenced by M_Setup_Draw().

Enumeration Type Documentation

◆ glsl_attrib

enum glsl_attrib

Enumerator
GLSLATTRIB_POSITION
GLSLATTRIB_COLOR
GLSLATTRIB_TEXCOORD0
GLSLATTRIB_TEXCOORD1
GLSLATTRIB_TEXCOORD2
GLSLATTRIB_TEXCOORD3
GLSLATTRIB_TEXCOORD4
GLSLATTRIB_TEXCOORD5
GLSLATTRIB_TEXCOORD6
GLSLATTRIB_TEXCOORD7

Definition at line 27 of file render.h.

{
    GLSLATTRIB_POSITION = 0,
    GLSLATTRIB_COLOR = 1,
    GLSLATTRIB_TEXCOORD0 = 2,
    GLSLATTRIB_TEXCOORD1 = 3,
    GLSLATTRIB_TEXCOORD2 = 4,
    GLSLATTRIB_TEXCOORD3 = 5,
    GLSLATTRIB_TEXCOORD4 = 6,
    GLSLATTRIB_TEXCOORD5 = 7,
    GLSLATTRIB_TEXCOORD6 = 8,
    GLSLATTRIB_TEXCOORD7 = 9,
}

◆ r_bufferdata_type_t

enum r_bufferdata_type_t

enum of the various types of hardware buffer object used in rendering note that the r_buffermegs[] array must be maintained to match this

Enumerator
R_BUFFERDATA_VERTEX
R_BUFFERDATA_INDEX16	vertex buffer
R_BUFFERDATA_INDEX32	index buffer - 16bit (because D3D cares)
R_BUFFERDATA_UNIFORM	index buffer - 32bit (because D3D cares)
R_BUFFERDATA_COUNT	uniform buffer how many kinds of buffer we have

Definition at line 523 of file render.h.

{
    R_BUFFERDATA_VERTEX, 
    R_BUFFERDATA_INDEX16, 
    R_BUFFERDATA_INDEX32, 
    R_BUFFERDATA_UNIFORM, 
    R_BUFFERDATA_COUNT 
}

◆ r_refdef_scene_type_t

enum r_refdef_scene_type_t

Enumerator
RST_CLIENT
RST_MENU
RST_COUNT

Definition at line 222 of file render.h.

                                   {
    RST_CLIENT,
    RST_MENU,
    RST_COUNT
} r_refdef_scene_type_t;

◆ r_viewport_type_t

enum r_viewport_type_t

Enumerator
R_VIEWPORTTYPE_ORTHO
R_VIEWPORTTYPE_PERSPECTIVE
R_VIEWPORTTYPE_PERSPECTIVE_INFINITEFARCLIP
R_VIEWPORTTYPE_PERSPECTIVECUBESIDE
R_VIEWPORTTYPE_TOTAL

Definition at line 228 of file render.h.

{
    R_VIEWPORTTYPE_ORTHO,
    R_VIEWPORTTYPE_PERSPECTIVE,
    R_VIEWPORTTYPE_PERSPECTIVE_INFINITEFARCLIP,
    R_VIEWPORTTYPE_PERSPECTIVECUBESIDE,
    R_VIEWPORTTYPE_TOTAL
}

◆ rsurfacepass_t

enum rsurfacepass_t

Enumerator
RSURFPASS_BASE
RSURFPASS_BACKGROUND
RSURFPASS_RTLIGHT
RSURFPASS_DEFERREDGEOMETRY

Definition at line 802 of file render.h.

{
    RSURFPASS_BASE,
    RSURFPASS_BACKGROUND,
    RSURFPASS_RTLIGHT,
    RSURFPASS_DEFERREDGEOMETRY
}

◆ shaderlanguage_t

enum shaderlanguage_t

Enumerator
SHADERLANGUAGE_GLSL
SHADERLANGUAGE_COUNT

Definition at line 42 of file render.h.

{
    SHADERLANGUAGE_GLSL,
    SHADERLANGUAGE_COUNT
}

◆ shadermode_t

enum shadermode_t

this enum selects which of the glslshadermodeinfo entries should be used

Enumerator
SHADERMODE_GENERIC	(particles/HUD/etc) vertex color, optionally multiplied by one texture
SHADERMODE_POSTPROCESS	postprocessing shader (r_glsl_postprocess)
SHADERMODE_DEPTH_OR_SHADOW	(depthfirst/shadows) vertex shader only
SHADERMODE_FLATCOLOR	(lightmap) modulate texture by uniform color (q1bsp, q3bsp)
SHADERMODE_VERTEXCOLOR	(lightmap) modulate texture by vertex colors (q3bsp)
SHADERMODE_LIGHTMAP	(lightmap) modulate texture by lightmap texture (q1bsp, q3bsp)
SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE	(lightmap) use directional pixel shading from texture containing modelspace light directions (q3bsp deluxemap)
SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE	(lightmap) use directional pixel shading from texture containing tangentspace light directions (q1bsp deluxemap)
SHADERMODE_LIGHTDIRECTIONMAP_FORCED_LIGHTMAP
SHADERMODE_LIGHTDIRECTIONMAP_FORCED_VERTEXCOLOR
SHADERMODE_LIGHTGRID	(lightmap) use directional pixel shading from lightgrid data (q3bsp)
SHADERMODE_LIGHTDIRECTION	(lightmap) use directional pixel shading from fixed light direction (q3bsp)
SHADERMODE_LIGHTSOURCE	(lightsource) use directional pixel shading from light source (rtlight)
SHADERMODE_REFRACTION	refract background (the material is rendered normally after this pass)
SHADERMODE_WATER	refract background and reflection (the material is rendered normally after this pass)
SHADERMODE_DEFERREDGEOMETRY	(deferred) render material properties to screenspace geometry buffers
SHADERMODE_DEFERREDLIGHTSOURCE	(deferred) use directional pixel shading from light source (rtlight) on screenspace geometry buffers
SHADERMODE_COUNT

Definition at line 50 of file render.h.

{
    SHADERMODE_GENERIC, 
    SHADERMODE_POSTPROCESS, 
    SHADERMODE_DEPTH_OR_SHADOW, 
    SHADERMODE_FLATCOLOR, 
    SHADERMODE_VERTEXCOLOR, 
    SHADERMODE_LIGHTMAP, 
    SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE, 
    SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE, 
    SHADERMODE_LIGHTDIRECTIONMAP_FORCED_LIGHTMAP, // forced deluxemapping for lightmapped surfaces
    SHADERMODE_LIGHTDIRECTIONMAP_FORCED_VERTEXCOLOR, // forced deluxemapping for vertexlit surfaces
    SHADERMODE_LIGHTGRID, 
    SHADERMODE_LIGHTDIRECTION, 
    SHADERMODE_LIGHTSOURCE, 
    SHADERMODE_REFRACTION, 
    SHADERMODE_WATER, 
    SHADERMODE_DEFERREDGEOMETRY, 
    SHADERMODE_DEFERREDLIGHTSOURCE, 
    SHADERMODE_COUNT
}

Function Documentation

◆ CL_VM_DrawHud()

void CL_VM_DrawHud ( double frametime )

Definition at line 541 of file csprogs.c.

{
    prvm_prog_t *prog = CLVM_prog;
 
    R_TimeReport("pre-DrawHud");
 
    PRVM_clientglobalfloat(time) = cl.time;
    PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
    CSQC_SetGlobals(frametime);
 
    PRVM_GarbageCollection(prog);
 
    // width and height parameters are virtual in CSQC_SIMPLE engines
    VectorSet(PRVM_G_VECTOR(OFS_PARM0), vid_conwidth.integer, vid_conheight.integer, 0);
    PRVM_G_FLOAT(OFS_PARM1) = sb_showscores;
    prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_DrawHud), "QC function CSQC_DrawHud is missing");
 
    if (PRVM_clientfunction(CSQC_DrawScores))
    {
        VectorSet(PRVM_G_VECTOR(OFS_PARM0), vid_conwidth.integer, vid_conheight.integer, 0);
        PRVM_G_FLOAT(OFS_PARM1) = sb_showscores;
        if (key_dest != key_menu)
            prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_DrawScores), "QC function CSQC_DrawScores is missing");
    }
    else if (sb_showscores || (cl.stats[STAT_HEALTH] <= 0 && cl_deathscoreboard.integer))
        if (!cl.islocalgame) // LadyHavoc: changed to draw the deathmatch overlays in any multiplayer mode
            Sbar_DeathmatchOverlay ();
 
    R_TimeReport("DrawHud");
}

References cl, cl_deathscoreboard, CLVM_prog, CSQC_SetGlobals(), prvm_prog_t::ExecuteProgram, frametime, key_dest, key_menu, OFS_PARM0, OFS_PARM1, PRVM_clientfunction, PRVM_clientglobaledict, PRVM_clientglobalfloat, PRVM_G_FLOAT, PRVM_G_VECTOR, PRVM_GarbageCollection(), R_TimeReport(), sb_showscores, Sbar_DeathmatchOverlay(), self, STAT_HEALTH, time, VectorSet, vid_conheight, and vid_conwidth.

Referenced by SCR_DrawScreen().

◆ CL_VM_UpdateView()

qbool CL_VM_UpdateView ( double frametime )

Definition at line 484 of file csprogs.c.

{
    prvm_prog_t *prog = CLVM_prog;
    vec3_t emptyvector;
    emptyvector[0] = 0;
    emptyvector[1] = 0;
    emptyvector[2] = 0;
//  vec3_t oldangles;
 
    if(!prog->loaded)
        return false;
 
    R_TimeReport("pre-UpdateView");
 
    csqc_original_r_refdef_view = r_refdef.view;
    csqc_main_r_refdef_view = r_refdef.view;
    //VectorCopy(cl.viewangles, oldangles);
    PRVM_clientglobalfloat(time) = cl.time;
    PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
    CSQC_SetGlobals(frametime);
    // clear renderable entity and light lists to prevent crashes if the
    // CSQC_UpdateView function does not call R_ClearScene as it should
    r_refdef.scene.numentities = 0;
    r_refdef.scene.numlights = 0;
    // polygonbegin without draw2d arg has to guess
    prog->polygonbegin_guess2d = false;
    // free memory for resources that are no longer referenced
    PRVM_GarbageCollection(prog);
    // pass in width and height and menu/focus state as parameters (EXT_CSQC_1)
    if (csqc_lowres.integer)
    {
        PRVM_G_FLOAT(OFS_PARM0) = vid_conwidth.value;
        PRVM_G_FLOAT(OFS_PARM1) = vid_conheight.value;
    }
    else
    {
        PRVM_G_FLOAT(OFS_PARM0) = vid.mode.width;
        PRVM_G_FLOAT(OFS_PARM1) = vid.mode.height;
    }
    /*
     * This should be fine for now but FTEQW uses flags for keydest
     * and checks that an array called "eyeoffset" is 0
     *
     * Just a note in case there's compatibility problems later
     */
    PRVM_G_FLOAT(OFS_PARM2) = key_dest == key_game;
    prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_UpdateView), "QC function CSQC_UpdateView is missing");
    //VectorCopy(oldangles, cl.viewangles);
    // Dresk : Reset Dmg Globals Here
    CL_VM_UpdateDmgGlobals(0, 0, emptyvector);
    r_refdef.view = csqc_main_r_refdef_view;
    R_RenderView_UpdateViewVectors(); // we have to do this, as we undid the scene render doing this for us
 
    R_TimeReport("UpdateView");
    return true;
}

References cl, CL_VM_UpdateDmgGlobals(), CLVM_prog, csqc_lowres, csqc_main_r_refdef_view, csqc_original_r_refdef_view, CSQC_SetGlobals(), CSQC_UpdateView(), prvm_prog_t::ExecuteProgram, frametime, key_dest, key_game, prvm_prog_t::loaded, OFS_PARM0, OFS_PARM1, OFS_PARM2, prvm_prog_t::polygonbegin_guess2d, PRVM_clientfunction, PRVM_clientglobaledict, PRVM_clientglobalfloat, PRVM_G_FLOAT, PRVM_GarbageCollection(), r_refdef, R_RenderView_UpdateViewVectors(), R_TimeReport(), self, time, vid, vid_conheight, and vid_conwidth.

Referenced by SCR_DrawScreen().

◆ FindFont()

dp_font_t * FindFont	(	const char *	title,
		qbool	allocate_new )

Definition at line 481 of file gl_draw.c.

{
    int i, oldsize;
 
    // find font
    for(i = 0; i < dp_fonts.maxsize; ++i)
        if(!strcmp(dp_fonts.f[i].title, title))
            return &dp_fonts.f[i];
    // if not found - try allocate
    if (allocate_new)
    {
        // find any font with empty title
        for(i = 0; i < dp_fonts.maxsize; ++i)
        {
            if(!strcmp(dp_fonts.f[i].title, ""))
            {
                dp_strlcpy(dp_fonts.f[i].title, title, sizeof(dp_fonts.f[i].title));
                return &dp_fonts.f[i];
            }
        }
        // if no any 'free' fonts - expand buffer
        oldsize = dp_fonts.maxsize;
        dp_fonts.maxsize = dp_fonts.maxsize + FONTS_EXPAND;
        if (developer_font.integer)
            Con_Printf("FindFont: enlarging fonts buffer (%i -> %i)\n", oldsize, dp_fonts.maxsize);
        dp_fonts.f = (dp_font_t *)Mem_Realloc(fonts_mempool, dp_fonts.f, sizeof(dp_font_t) * dp_fonts.maxsize);
        // relink ft2 structures
        for(i = 0; i < oldsize; ++i)
            if (dp_fonts.f[i].ft2)
                dp_fonts.f[i].ft2->settings = &dp_fonts.f[i].settings;
        // register a font in first expanded slot
        dp_strlcpy(dp_fonts.f[oldsize].title, title, sizeof(dp_fonts.f[oldsize].title));
        return &dp_fonts.f[oldsize];
    }
    return NULL;
}

References Con_Printf(), developer_font, dp_fonts, dp_strlcpy, FONTS_EXPAND, fonts_mempool, Mem_Realloc, and NULL.

Referenced by LoadFont_f(), and VM_loadfont().

◆ FOG_clear()

void FOG_clear ( void )

Definition at line 349 of file gl_rmain.c.

{
    if (gamemode == GAME_NEHAHRA)
    {
        Cvar_SetQuick(&gl_fogenable, "0");
        Cvar_SetQuick(&gl_fogdensity, "0.2");
        Cvar_SetQuick(&gl_fogred, "0.3");
        Cvar_SetQuick(&gl_foggreen, "0.3");
        Cvar_SetQuick(&gl_fogblue, "0.3");
    }
    r_refdef.fog_density = 0;
    r_refdef.fog_red = 0;
    r_refdef.fog_green = 0;
    r_refdef.fog_blue = 0;
    r_refdef.fog_alpha = 1;
    r_refdef.fog_start = 0;
    r_refdef.fog_end = 16384;
    r_refdef.fog_height = 1<<30;
    r_refdef.fog_fadedepth = 128;
    memset(r_refdef.fog_height_texturename, 0, sizeof(r_refdef.fog_height_texturename));
}

References Cvar_SetQuick(), GAME_NEHAHRA, gamemode, gl_fogblue, gl_fogdensity, gl_fogenable, gl_foggreen, gl_fogred, and r_refdef.

Referenced by CL_Fog_f(), CL_Fog_HeightTexture_f(), and CL_ParseEntityLump().

◆ Font_Init()

void Font_Init ( void )

Definition at line 443 of file ft2.c.

{
    Cvar_RegisterVariable(&r_font_nonpoweroftwo);
    Cvar_RegisterVariable(&r_font_disable_freetype);
    Cvar_RegisterVariable(&r_font_size_snapping);
    Cvar_RegisterVariable(&r_font_kerning);
    Cvar_RegisterVariable(&r_font_diskcache);
    Cvar_RegisterVariable(&r_font_compress);
    Cvar_RegisterVariable(&developer_font);
 
    Cvar_RegisterVariable(&r_font_disable_incmaps);
 
    // let's open it at startup already
    Font_OpenLibrary();
}

References Cvar_RegisterVariable(), developer_font, Font_OpenLibrary(), r_font_compress, r_font_disable_freetype, r_font_disable_incmaps, r_font_diskcache, r_font_kerning, r_font_nonpoweroftwo, and r_font_size_snapping.

Referenced by Render_Init().

◆ gl_backend_init()

void gl_backend_init ( void )

Definition at line 339 of file gl_backend.c.

{
    int i;
 
    for (i = 0;i < POLYGONELEMENTS_MAXPOINTS - 2;i++)
    {
        polygonelement3s[i * 3 + 0] = 0;
        polygonelement3s[i * 3 + 1] = i + 1;
        polygonelement3s[i * 3 + 2] = i + 2;
    }
    // elements for rendering a series of quads as triangles
    for (i = 0;i < QUADELEMENTS_MAXQUADS;i++)
    {
        quadelement3s[i * 6 + 0] = i * 4;
        quadelement3s[i * 6 + 1] = i * 4 + 1;
        quadelement3s[i * 6 + 2] = i * 4 + 2;
        quadelement3s[i * 6 + 3] = i * 4;
        quadelement3s[i * 6 + 4] = i * 4 + 2;
        quadelement3s[i * 6 + 5] = i * 4 + 3;
    }
 
    for (i = 0;i < (POLYGONELEMENTS_MAXPOINTS - 2)*3;i++)
        polygonelement3i[i] = polygonelement3s[i];
    for (i = 0;i < QUADELEMENTS_MAXQUADS*6;i++)
        quadelement3i[i] = quadelement3s[i];
 
    Cvar_RegisterVariable(&r_render);
    Cvar_RegisterVariable(&r_renderview);
    Cvar_RegisterVariable(&r_waterwarp);
    Cvar_RegisterVariable(&gl_polyblend);
    Cvar_RegisterVariable(&v_flipped);
    Cvar_RegisterVariable(&gl_debug);
    Cvar_RegisterVariable(&gl_paranoid);
#ifdef DEBUGGL // gl_printcheckerror does nothing in normal builds
    Cvar_RegisterVariable(&gl_printcheckerror);
#endif
 
    Cmd_AddCommand(CF_CLIENT, "gl_vbostats", GL_VBOStats_f, "prints a list of all buffer objects (vertex data and triangle elements) and total video memory used by them");
 
    R_RegisterModule("GL_Backend", gl_backend_start, gl_backend_shutdown, gl_backend_newmap, gl_backend_devicelost, gl_backend_devicerestored);
}

References CF_CLIENT, Cmd_AddCommand(), Cvar_RegisterVariable(), gl_backend_devicelost(), gl_backend_devicerestored(), gl_backend_newmap(), gl_backend_shutdown(), gl_backend_start(), gl_debug, gl_paranoid, gl_polyblend, gl_printcheckerror, GL_VBOStats_f(), polygonelement3i, polygonelement3s, POLYGONELEMENTS_MAXPOINTS, quadelement3i, quadelement3s, QUADELEMENTS_MAXQUADS, R_RegisterModule(), r_render, r_renderview, r_waterwarp, and v_flipped.

Referenced by Render_Init().

◆ GL_Draw_Init()

void GL_Draw_Init ( void )

Definition at line 747 of file gl_draw.c.

{
    int i, j;
 
    Cvar_RegisterVariable(&r_font_postprocess_blur);
    Cvar_RegisterVariable(&r_font_postprocess_outline);
    Cvar_RegisterVariable(&r_font_postprocess_shadow_x);
    Cvar_RegisterVariable(&r_font_postprocess_shadow_y);
    Cvar_RegisterVariable(&r_font_postprocess_shadow_z);
    Cvar_RegisterVariable(&r_font_hinting);
    Cvar_RegisterVariable(&r_font_antialias);
    Cvar_RegisterVariable(&r_font_always_reload);
    Cvar_RegisterVariable(&r_textshadow);
    Cvar_RegisterVariable(&r_textbrightness);
    Cvar_RegisterVariable(&r_textcontrast);
    Cvar_RegisterVariable(&r_nearest_2d);
    Cvar_RegisterVariable(&r_nearest_conchars);
 
    // allocate fonts storage
    fonts_mempool = Mem_AllocPool("FONTS", 0, NULL);
    dp_fonts.maxsize = MAX_FONTS;
    dp_fonts.f = (dp_font_t *)Mem_Alloc(fonts_mempool, sizeof(dp_font_t) * dp_fonts.maxsize);
    memset(dp_fonts.f, 0, sizeof(dp_font_t) * dp_fonts.maxsize);
 
    // assign starting font names
    dp_strlcpy(FONT_DEFAULT->title, "default", sizeof(FONT_DEFAULT->title));
    dp_strlcpy(FONT_DEFAULT->texpath, "gfx/conchars", sizeof(FONT_DEFAULT->texpath));
    dp_strlcpy(FONT_CONSOLE->title, "console", sizeof(FONT_CONSOLE->title));
    dp_strlcpy(FONT_SBAR->title, "sbar", sizeof(FONT_SBAR->title));
    dp_strlcpy(FONT_NOTIFY->title, "notify", sizeof(FONT_NOTIFY->title));
    dp_strlcpy(FONT_CHAT->title, "chat", sizeof(FONT_CHAT->title));
    dp_strlcpy(FONT_CENTERPRINT->title, "centerprint", sizeof(FONT_CENTERPRINT->title));
    dp_strlcpy(FONT_INFOBAR->title, "infobar", sizeof(FONT_INFOBAR->title));
    dp_strlcpy(FONT_MENU->title, "menu", sizeof(FONT_MENU->title));
    for(i = 0, j = 0; i < MAX_USERFONTS; ++i)
        if(!FONT_USER(i)->title[0])
            dpsnprintf(FONT_USER(i)->title, sizeof(FONT_USER(i)->title), "user%d", j++);
 
    Cmd_AddCommand(CF_CLIENT, "loadfont", LoadFont_f, "loadfont function tganame loads a font; example: loadfont console gfx/veramono; loadfont without arguments lists the available functions");
    R_RegisterModule("GL_Draw", gl_draw_start, gl_draw_shutdown, gl_draw_newmap, NULL, NULL);
}

References CF_CLIENT, Cmd_AddCommand(), Cvar_RegisterVariable(), dp_fonts, dp_strlcpy, dpsnprintf(), FONT_CENTERPRINT, FONT_CHAT, FONT_CONSOLE, FONT_DEFAULT, FONT_INFOBAR, FONT_MENU, FONT_NOTIFY, FONT_SBAR, FONT_USER, fonts_mempool, gl_draw_newmap(), gl_draw_shutdown(), gl_draw_start(), LoadFont_f(), MAX_FONTS, MAX_USERFONTS, Mem_Alloc, Mem_AllocPool, NULL, r_font_always_reload, r_font_antialias, r_font_hinting, r_font_postprocess_blur, r_font_postprocess_outline, r_font_postprocess_shadow_x, r_font_postprocess_shadow_y, r_font_postprocess_shadow_z, r_nearest_2d, r_nearest_conchars, R_RegisterModule(), r_textbrightness, r_textcontrast, and r_textshadow.

Referenced by Render_Init().

◆ GL_Main_Init()

void GL_Main_Init ( void )

Definition at line 3220 of file gl_rmain.c.

{
    int i;
    r_main_mempool = Mem_AllocPool("Renderer", 0, NULL);
    R_InitShaderModeInfo();
 
    Cmd_AddCommand(CF_CLIENT, "r_glsl_restart", R_GLSL_Restart_f, "unloads GLSL shaders, they will then be reloaded as needed");
    Cmd_AddCommand(CF_CLIENT, "r_glsl_dumpshader", R_GLSL_DumpShader_f, "dumps the engine internal default.glsl shader into glsl/default.glsl");
    // FIXME: the client should set up r_refdef.fog stuff including the fogmasktable
    if (gamemode == GAME_NEHAHRA)
    {
        Cvar_RegisterVariable (&gl_fogenable);
        Cvar_RegisterVariable (&gl_fogdensity);
        Cvar_RegisterVariable (&gl_fogred);
        Cvar_RegisterVariable (&gl_foggreen);
        Cvar_RegisterVariable (&gl_fogblue);
        Cvar_RegisterVariable (&gl_fogstart);
        Cvar_RegisterVariable (&gl_fogend);
        Cvar_RegisterVariable (&gl_skyclip);
    }
    Cvar_RegisterVariable(&r_motionblur);
    Cvar_RegisterVariable(&r_damageblur);
    Cvar_RegisterVariable(&r_motionblur_averaging);
    Cvar_RegisterVariable(&r_motionblur_randomize);
    Cvar_RegisterVariable(&r_motionblur_minblur);
    Cvar_RegisterVariable(&r_motionblur_maxblur);
    Cvar_RegisterVariable(&r_motionblur_velocityfactor);
    Cvar_RegisterVariable(&r_motionblur_velocityfactor_minspeed);
    Cvar_RegisterVariable(&r_motionblur_velocityfactor_maxspeed);
    Cvar_RegisterVariable(&r_motionblur_mousefactor);
    Cvar_RegisterVariable(&r_motionblur_mousefactor_minspeed);
    Cvar_RegisterVariable(&r_motionblur_mousefactor_maxspeed);
    Cvar_RegisterVariable(&r_depthfirst);
    Cvar_RegisterVariable(&r_useinfinitefarclip);
    Cvar_RegisterVariable(&r_farclip_base);
    Cvar_RegisterVariable(&r_farclip_world);
    Cvar_RegisterVariable(&r_nearclip);
    Cvar_RegisterVariable(&r_deformvertexes);
    Cvar_RegisterVariable(&r_transparent);
    Cvar_RegisterVariable(&r_transparent_alphatocoverage);
    Cvar_RegisterVariable(&r_transparent_sortsurfacesbynearest);
    Cvar_RegisterVariable(&r_transparent_useplanardistance);
    Cvar_RegisterVariable(&r_showoverdraw);
    Cvar_RegisterVariable(&r_showbboxes);
    Cvar_RegisterVariable(&r_showbboxes_client);
    Cvar_RegisterVariable(&r_showsurfaces);
    Cvar_RegisterVariable(&r_showtris);
    Cvar_RegisterVariable(&r_shownormals);
    Cvar_RegisterVariable(&r_showlighting);
    Cvar_RegisterVariable(&r_showcollisionbrushes);
    Cvar_RegisterVariable(&r_showcollisionbrushes_polygonfactor);
    Cvar_RegisterVariable(&r_showcollisionbrushes_polygonoffset);
    Cvar_RegisterVariable(&r_showdisabledepthtest);
    Cvar_RegisterVariable(&r_showspriteedges);
    Cvar_RegisterVariable(&r_showparticleedges);
    Cvar_RegisterVariable(&r_drawportals);
    Cvar_RegisterVariable(&r_drawentities);
    Cvar_RegisterVariable(&r_draw2d);
    Cvar_RegisterVariable(&r_drawworld);
    Cvar_RegisterVariable(&r_cullentities_trace);
    Cvar_RegisterVariable(&r_cullentities_trace_entityocclusion);
    Cvar_RegisterVariable(&r_cullentities_trace_samples);
    Cvar_RegisterVariable(&r_cullentities_trace_tempentitysamples);
    Cvar_RegisterVariable(&r_cullentities_trace_enlarge);
    Cvar_RegisterVariable(&r_cullentities_trace_expand);
    Cvar_RegisterVariable(&r_cullentities_trace_pad);
    Cvar_RegisterVariable(&r_cullentities_trace_delay);
    Cvar_RegisterVariable(&r_cullentities_trace_eyejitter);
    Cvar_RegisterVariable(&r_sortentities);
    Cvar_RegisterVariable(&r_drawviewmodel);
    Cvar_RegisterVariable(&r_drawexteriormodel);
    Cvar_RegisterVariable(&r_speeds);
    Cvar_RegisterVariable(&r_fullbrights);
    Cvar_RegisterVariable(&r_wateralpha);
    Cvar_RegisterVariable(&r_dynamic);
    Cvar_RegisterVariable(&r_fullbright_directed);
    Cvar_RegisterVariable(&r_fullbright_directed_ambient);
    Cvar_RegisterVariable(&r_fullbright_directed_diffuse);
    Cvar_RegisterVariable(&r_fullbright_directed_pitch);
    Cvar_RegisterVariable(&r_fullbright_directed_pitch_relative);
    Cvar_RegisterVariable(&r_fullbright);
    Cvar_RegisterVariable(&r_shadows);
    Cvar_RegisterVariable(&r_shadows_darken);
    Cvar_RegisterVariable(&r_shadows_drawafterrtlighting);
    Cvar_RegisterVariable(&r_shadows_castfrombmodels);
    Cvar_RegisterVariable(&r_shadows_throwdistance);
    Cvar_RegisterVariable(&r_shadows_throwdirection);
    Cvar_RegisterVariable(&r_shadows_focus);
    Cvar_RegisterVariable(&r_shadows_shadowmapscale);
    Cvar_RegisterVariable(&r_shadows_shadowmapbias);
    Cvar_RegisterVariable(&r_q1bsp_skymasking);
    Cvar_RegisterVariable(&r_polygonoffset_submodel_factor);
    Cvar_RegisterVariable(&r_polygonoffset_submodel_offset);
    Cvar_RegisterVariable(&r_polygonoffset_decals_factor);
    Cvar_RegisterVariable(&r_polygonoffset_decals_offset);
    Cvar_RegisterVariable(&r_fog_exp2);
    Cvar_RegisterVariable(&r_fog_clear);
    Cvar_RegisterVariable(&r_drawfog);
    Cvar_RegisterVariable(&r_transparentdepthmasking);
    Cvar_RegisterVariable(&r_transparent_sortmindist);
    Cvar_RegisterVariable(&r_transparent_sortmaxdist);
    Cvar_RegisterVariable(&r_transparent_sortarraysize);
    Cvar_RegisterVariable(&r_texture_dds_load);
    Cvar_RegisterVariable(&r_texture_dds_save);
    Cvar_RegisterVariable(&r_usedepthtextures);
    Cvar_RegisterVariable(&r_viewfbo);
    Cvar_RegisterVariable(&r_rendertarget_debug);
    Cvar_RegisterVariable(&r_viewscale);
    Cvar_RegisterVariable(&r_viewscale_fpsscaling);
    Cvar_RegisterVariable(&r_viewscale_fpsscaling_min);
    Cvar_RegisterVariable(&r_viewscale_fpsscaling_multiply);
    Cvar_RegisterVariable(&r_viewscale_fpsscaling_stepsize);
    Cvar_RegisterVariable(&r_viewscale_fpsscaling_stepmax);
    Cvar_RegisterVariable(&r_viewscale_fpsscaling_target);
    Cvar_RegisterVariable(&r_glsl_deluxemapping);
    Cvar_RegisterVariable(&r_glsl_offsetmapping);
    Cvar_RegisterVariable(&r_glsl_offsetmapping_steps);
    Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping);
    Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping_steps);
    Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping_refinesteps);
    Cvar_RegisterVariable(&r_glsl_offsetmapping_scale);
    Cvar_RegisterVariable(&r_glsl_offsetmapping_lod);
    Cvar_RegisterVariable(&r_glsl_offsetmapping_lod_distance);
    Cvar_RegisterVariable(&r_glsl_postprocess);
    Cvar_RegisterVariable(&r_glsl_postprocess_uservec1);
    Cvar_RegisterVariable(&r_glsl_postprocess_uservec2);
    Cvar_RegisterVariable(&r_glsl_postprocess_uservec3);
    Cvar_RegisterVariable(&r_glsl_postprocess_uservec4);
    Cvar_RegisterVariable(&r_glsl_postprocess_uservec1_enable);
    Cvar_RegisterVariable(&r_glsl_postprocess_uservec2_enable);
    Cvar_RegisterVariable(&r_glsl_postprocess_uservec3_enable);
    Cvar_RegisterVariable(&r_glsl_postprocess_uservec4_enable);
    Cvar_RegisterVariable(&r_celshading);
    Cvar_RegisterVariable(&r_celoutlines);
    Cvar_RegisterVariable(&r_fxaa);
 
    Cvar_RegisterVariable(&r_water);
    Cvar_RegisterVariable(&r_water_cameraentitiesonly);
    Cvar_RegisterVariable(&r_water_resolutionmultiplier);
    Cvar_RegisterVariable(&r_water_clippingplanebias);
    Cvar_RegisterVariable(&r_water_refractdistort);
    Cvar_RegisterVariable(&r_water_reflectdistort);
    Cvar_RegisterVariable(&r_water_scissormode);
    Cvar_RegisterVariable(&r_water_lowquality);
    Cvar_RegisterVariable(&r_water_hideplayer);
 
    Cvar_RegisterVariable(&r_lerpsprites);
    Cvar_RegisterVariable(&r_lerpmodels);
    Cvar_RegisterVariable(&r_nolerp_list);
    Cvar_RegisterVariable(&r_lerplightstyles);
    Cvar_RegisterVariable(&r_waterscroll);
    Cvar_RegisterVariable(&r_bloom);
    Cvar_RegisterVariable(&r_colorfringe);
    Cvar_RegisterVariable(&r_bloom_colorscale);
    Cvar_RegisterVariable(&r_bloom_brighten);
    Cvar_RegisterVariable(&r_bloom_blur);
    Cvar_RegisterVariable(&r_bloom_resolution);
    Cvar_RegisterVariable(&r_bloom_colorexponent);
    Cvar_RegisterVariable(&r_bloom_colorsubtract);
    Cvar_RegisterVariable(&r_bloom_scenebrightness);
    Cvar_RegisterVariable(&r_hdr_scenebrightness);
    Cvar_RegisterVariable(&r_hdr_glowintensity);
    Cvar_RegisterVariable(&r_hdr_irisadaptation);
    Cvar_RegisterVariable(&r_hdr_irisadaptation_multiplier);
    Cvar_RegisterVariable(&r_hdr_irisadaptation_minvalue);
    Cvar_RegisterVariable(&r_hdr_irisadaptation_maxvalue);
    Cvar_RegisterVariable(&r_hdr_irisadaptation_value);
    Cvar_RegisterVariable(&r_hdr_irisadaptation_fade_up);
    Cvar_RegisterVariable(&r_hdr_irisadaptation_fade_down);
    Cvar_RegisterVariable(&r_hdr_irisadaptation_radius);
    Cvar_RegisterVariable(&r_smoothnormals_areaweighting);
    Cvar_RegisterVariable(&developer_texturelogging);
    Cvar_RegisterVariable(&gl_lightmaps);
    Cvar_RegisterVariable(&r_test);
    Cvar_RegisterVariable(&r_batch_multidraw);
    Cvar_RegisterVariable(&r_batch_multidraw_mintriangles);
    Cvar_RegisterVariable(&r_batch_debugdynamicvertexpath);
    Cvar_RegisterVariable(&r_glsl_skeletal);
    Cvar_RegisterVariable(&r_glsl_saturation);
    Cvar_RegisterVariable(&r_glsl_saturation_redcompensate);
    Cvar_RegisterVariable(&r_glsl_vertextextureblend_usebothalphas);
    Cvar_RegisterVariable(&r_framedatasize);
    for (i = 0;i < R_BUFFERDATA_COUNT;i++)
        Cvar_RegisterVariable(&r_buffermegs[i]);
    Cvar_RegisterVariable(&r_batch_dynamicbuffer);
    Cvar_RegisterVariable(&r_q1bsp_lightmap_updates_enabled);
    Cvar_RegisterVariable(&r_q1bsp_lightmap_updates_combine);
    Cvar_RegisterVariable(&r_q1bsp_lightmap_updates_hidden_surfaces);
    if (gamemode == GAME_NEHAHRA || gamemode == GAME_TENEBRAE)
        Cvar_SetQuick(&r_fullbrights, "0");
#ifdef DP_MOBILETOUCH
    // GLES devices have terrible depth precision in general, so...
    Cvar_SetValueQuick(&r_nearclip, 4);
    Cvar_SetValueQuick(&r_farclip_base, 4096);
    Cvar_SetValueQuick(&r_farclip_world, 0);
    Cvar_SetValueQuick(&r_useinfinitefarclip, 0);
#endif
    R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap, NULL, NULL);
}

Referenced by Render_Init().

◆ GL_Surf_Init()

void GL_Surf_Init ( void )

Definition at line 1564 of file gl_rsurf.c.

{
 
    Cvar_RegisterVariable(&r_ambient);
    Cvar_RegisterVariable(&r_lockpvs);
    Cvar_RegisterVariable(&r_lockvisibility);
    Cvar_RegisterVariable(&r_useportalculling);
    Cvar_RegisterVariable(&r_usesurfaceculling);
    Cvar_RegisterVariable(&r_vis_trace);
    Cvar_RegisterVariable(&r_vis_trace_samples);
    Cvar_RegisterVariable(&r_vis_trace_delay);
    Cvar_RegisterVariable(&r_vis_trace_eyejitter);
    Cvar_RegisterVariable(&r_vis_trace_enlarge);
    Cvar_RegisterVariable(&r_vis_trace_expand);
    Cvar_RegisterVariable(&r_vis_trace_pad);
    Cvar_RegisterVariable(&r_vis_trace_surfaces);
    Cvar_RegisterVariable(&r_q3bsp_renderskydepth);
 
    Cmd_AddCommand(CF_CLIENT, "r_replacemaptexture", R_ReplaceWorldTexture_f, "override a map texture for testing purposes");
    Cmd_AddCommand(CF_CLIENT, "r_listmaptextures", R_ListWorldTextures_f, "list all textures used by the current map");
 
    //R_RegisterModule("GL_Surf", gl_surf_start, gl_surf_shutdown, gl_surf_newmap);
}

References CF_CLIENT, Cmd_AddCommand(), Cvar_RegisterVariable(), r_ambient, R_ListWorldTextures_f(), r_lockpvs, r_lockvisibility, r_q3bsp_renderskydepth, R_ReplaceWorldTexture_f(), r_useportalculling, r_usesurfaceculling, r_vis_trace, r_vis_trace_delay, r_vis_trace_enlarge, r_vis_trace_expand, r_vis_trace_eyejitter, r_vis_trace_pad, r_vis_trace_samples, and r_vis_trace_surfaces.

Referenced by Render_Init().

◆ LoadFont()

void LoadFont	(	qbool	override,
		const char *	name,
		dp_font_t *	fnt,
		float	scale,
		float	voffset )

Definition at line 330 of file gl_draw.c.

{
    int i, ch;
    float maxwidth;
    char widthfile[MAX_QPATH];
    char *widthbuf;
    fs_offset_t widthbufsize;
 
    if(override || !fnt->texpath[0])
    {
        dp_strlcpy(fnt->texpath, name, sizeof(fnt->texpath));
        // load the cvars when the font is FIRST loader
        fnt->settings.scale = scale;
        fnt->settings.voffset = voffset;
        fnt->settings.antialias = r_font_antialias.integer;
        fnt->settings.hinting = r_font_hinting.integer;
        fnt->settings.outline = r_font_postprocess_outline.value;
        fnt->settings.blur = r_font_postprocess_blur.value;
        fnt->settings.shadowx = r_font_postprocess_shadow_x.value;
        fnt->settings.shadowy = r_font_postprocess_shadow_y.value;
        fnt->settings.shadowz = r_font_postprocess_shadow_z.value;
    }
 
    // fix bad scale
    if (fnt->settings.scale <= 0)
        fnt->settings.scale = 1;
 
    if(drawtexturepool == NULL)
        return; // before gl_draw_start, so will be loaded later
 
    if(fnt->ft2)
    {
        // we are going to reload. clear old ft2 data
        Font_UnloadFont(fnt->ft2);
        Mem_Free(fnt->ft2);
        fnt->ft2 = NULL;
    }
 
    if(fnt->req_face != -1)
    {
        if(!Font_LoadFont(fnt->texpath, fnt))
            Con_DPrintf("Failed to load font-file for '%s', it will not support as many characters.\n", fnt->texpath);
    }
 
    fnt->pic = Draw_CachePic_Flags(fnt->texpath, CACHEPICFLAG_QUIET | CACHEPICFLAG_NOCOMPRESSION | (r_nearest_conchars.integer ? CACHEPICFLAG_NEAREST : 0) | CACHEPICFLAG_FAILONMISSING);
    if(!Draw_IsPicLoaded(fnt->pic))
    {
        for (i = 0; i < MAX_FONT_FALLBACKS; ++i)
        {
            if (!fnt->fallbacks[i][0])
                break;
            fnt->pic = Draw_CachePic_Flags(fnt->fallbacks[i], CACHEPICFLAG_QUIET | CACHEPICFLAG_NOCOMPRESSION | (r_nearest_conchars.integer ? CACHEPICFLAG_NEAREST : 0) | CACHEPICFLAG_FAILONMISSING);
            if(Draw_IsPicLoaded(fnt->pic))
                break;
        }
        if(!Draw_IsPicLoaded(fnt->pic))
        {
            fnt->pic = Draw_CachePic_Flags("gfx/conchars", CACHEPICFLAG_NOCOMPRESSION | (r_nearest_conchars.integer ? CACHEPICFLAG_NEAREST : 0));
            dp_strlcpy(widthfile, "gfx/conchars.width", sizeof(widthfile));
        }
        else
            dpsnprintf(widthfile, sizeof(widthfile), "%s.width", fnt->fallbacks[i]);
    }
    else
        dpsnprintf(widthfile, sizeof(widthfile), "%s.width", fnt->texpath);
 
    // unspecified width == 1 (base width)
    for(ch = 0; ch < 256; ++ch)
        fnt->width_of[ch] = 1;
 
    // FIXME load "name.width", if it fails, fill all with 1
    if((widthbuf = (char *) FS_LoadFile(widthfile, tempmempool, true, &widthbufsize)))
    {
        float extraspacing = 0;
        const char *p = widthbuf;
 
        ch = 0;
        while(ch < 256)
        {
            if(!COM_ParseToken_Simple(&p, false, false, true))
                return;
 
            switch(*com_token)
            {
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                case '+':
                case '-':
                case '.':
                    fnt->width_of[ch] = atof(com_token) + extraspacing;
                    ch++;
                    break;
                default:
                    if(!strcmp(com_token, "extraspacing"))
                    {
                        if(!COM_ParseToken_Simple(&p, false, false, true))
                            return;
                        extraspacing = atof(com_token);
                    }
                    else if(!strcmp(com_token, "scale"))
                    {
                        if(!COM_ParseToken_Simple(&p, false, false, true))
                            return;
                        fnt->settings.scale = atof(com_token);
                    }
                    else
                    {
                        Con_DPrintf("Warning: skipped unknown font property %s\n", com_token);
                        if(!COM_ParseToken_Simple(&p, false, false, true))
                            return;
                    }
                    break;
            }
        }
 
        Mem_Free(widthbuf);
    }
 
    if(fnt->ft2)
    {
        for (i = 0; i < MAX_FONT_SIZES; ++i)
        {
            ft2_font_map_t *map = Font_MapForIndex(fnt->ft2, i);
            if (!map)
                break;
            for(ch = 0; ch < 256; ++ch)
                fnt->width_of_ft2[i][ch] = Font_SnapTo(fnt->width_of[ch], 1/map->size);
        }
    }
 
    maxwidth = fnt->width_of[0];
    for(i = 1; i < 256; ++i)
        maxwidth = max(maxwidth, fnt->width_of[i]);
    fnt->maxwidth = maxwidth;
 
    // fix up maxwidth for overlap
    fnt->maxwidth *= fnt->settings.scale;
 
    if(fnt == FONT_CONSOLE)
        con_linewidth = -1; // rewrap console in next frame
}

References ft2_settings_t::antialias, ft2_settings_t::blur, CACHEPICFLAG_FAILONMISSING, CACHEPICFLAG_NEAREST, CACHEPICFLAG_NOCOMPRESSION, CACHEPICFLAG_QUIET, COM_ParseToken_Simple(), com_token, Con_DPrintf(), con_linewidth, dp_strlcpy, dpsnprintf(), Draw_CachePic_Flags(), Draw_IsPicLoaded(), drawtexturepool, dp_font_t::fallbacks, FONT_CONSOLE, Font_LoadFont(), Font_MapForIndex(), Font_SnapTo(), Font_UnloadFont(), FS_LoadFile(), dp_font_t::ft2, ft2_settings_t::hinting, max, MAX_FONT_FALLBACKS, MAX_FONT_SIZES, MAX_QPATH, dp_font_t::maxwidth, Mem_Free, name, NULL, ft2_settings_t::outline, dp_font_t::pic, r_font_antialias, r_font_hinting, r_font_postprocess_blur, r_font_postprocess_outline, r_font_postprocess_shadow_x, r_font_postprocess_shadow_y, r_font_postprocess_shadow_z, r_nearest_conchars, dp_font_t::req_face, ft2_settings_t::scale, scale, dp_font_t::settings, ft2_settings_t::shadowx, ft2_settings_t::shadowy, ft2_settings_t::shadowz, tempmempool, dp_font_t::texpath, ft2_settings_t::voffset, dp_font_t::width_of, and dp_font_t::width_of_ft2.

Referenced by gl_draw_start(), LoadFont_f(), and VM_loadfont().

◆ Mod_RenderInit()

void Mod_RenderInit ( void )

Definition at line 206 of file model_shared.c.

{
    R_RegisterModule("Models", mod_start, mod_shutdown, mod_newmap, NULL, NULL);
}

References mod_newmap(), mod_shutdown(), mod_start(), NULL, and R_RegisterModule().

Referenced by Render_Init().

◆ R_AnimCache_CacheVisibleEntities()

void R_AnimCache_CacheVisibleEntities ( void )

generate animcache data for all entities marked visible

Definition at line 3874 of file gl_rmain.c.

{
    int i;
 
    // TODO: thread this
    // NOTE: R_PrepareRTLights() also caches entities
 
    for (i = 0;i < r_refdef.scene.numentities;i++)
        if (r_refdef.viewcache.entityvisible[i])
            R_AnimCache_GetEntity(r_refdef.scene.entities[i], true, true);
}

References R_AnimCache_GetEntity(), and r_refdef.

Referenced by R_RenderView(), and R_Water_ProcessPlanes().

◆ R_AnimCache_ClearCache()

void R_AnimCache_ClearCache ( void )

clear the animcache pointers on all known render entities

Definition at line 3762 of file gl_rmain.c.

{
    int i;
    entity_render_t *ent;
 
    for (i = 0;i < r_refdef.scene.numentities;i++)
    {
        ent = r_refdef.scene.entities[i];
        ent->animcache_vertex3f = NULL;
        ent->animcache_vertex3f_vertexbuffer = NULL;
        ent->animcache_vertex3f_bufferoffset = 0;
        ent->animcache_normal3f = NULL;
        ent->animcache_normal3f_vertexbuffer = NULL;
        ent->animcache_normal3f_bufferoffset = 0;
        ent->animcache_svector3f = NULL;
        ent->animcache_svector3f_vertexbuffer = NULL;
        ent->animcache_svector3f_bufferoffset = 0;
        ent->animcache_tvector3f = NULL;
        ent->animcache_tvector3f_vertexbuffer = NULL;
        ent->animcache_tvector3f_bufferoffset = 0;
        ent->animcache_skeletaltransform3x4 = NULL;
        ent->animcache_skeletaltransform3x4buffer = NULL;
        ent->animcache_skeletaltransform3x4offset = 0;
        ent->animcache_skeletaltransform3x4size = 0;
    }
}

Referenced by R_RenderView().

◆ R_AnimCache_Free()

void R_AnimCache_Free ( void )

free all R_AnimCache memory

Definition at line 3758 of file gl_rmain.c.

3759{

3760}

Referenced by gl_main_shutdown(), and gl_main_start().

◆ R_AnimCache_GetEntity()

qbool R_AnimCache_GetEntity	(	entity_render_t *	ent,
		qbool	wantnormals,
		qbool	wanttangents )

get the skeletal data or cached animated mesh data for an entity (optionally with normals and tangents)

Definition at line 3789 of file gl_rmain.c.

{
    model_t *model = ent->model;
    int numvertices;
 
    // see if this ent is worth caching
    if (!model || !model->Draw || !model->AnimateVertices)
        return false;
    // nothing to cache if it contains no animations and has no skeleton
    if (!model->surfmesh.isanimated && !(model->num_bones && ent->skeleton && ent->skeleton->relativetransforms))
        return false;
    // see if it is already cached for gpuskeletal
    if (ent->animcache_skeletaltransform3x4)
        return false;
    // see if it is already cached as a mesh
    if (ent->animcache_vertex3f)
    {
        // check if we need to add normals or tangents
        if (ent->animcache_normal3f)
            wantnormals = false;
        if (ent->animcache_svector3f)
            wanttangents = false;
        if (!wantnormals && !wanttangents)
            return false;
    }
 
    // check which kind of cache we need to generate
    if (r_gpuskeletal && model->num_bones > 0 && model->surfmesh.data_skeletalindex4ub)
    {
        // cache the skeleton so the vertex shader can use it
        r_refdef.stats[r_stat_animcache_skeletal_count] += 1;
        r_refdef.stats[r_stat_animcache_skeletal_bones] += model->num_bones;
        r_refdef.stats[r_stat_animcache_skeletal_maxbones] = max(r_refdef.stats[r_stat_animcache_skeletal_maxbones], model->num_bones);
        ent->animcache_skeletaltransform3x4 = (float *)R_FrameData_Alloc(sizeof(float[3][4]) * model->num_bones);
        Mod_Skeletal_BuildTransforms(model, ent->frameblend, ent->skeleton, NULL, ent->animcache_skeletaltransform3x4);
        // note: this can fail if the buffer is at the grow limit
        ent->animcache_skeletaltransform3x4size = sizeof(float[3][4]) * model->num_bones;
        ent->animcache_skeletaltransform3x4buffer = R_BufferData_Store(ent->animcache_skeletaltransform3x4size, ent->animcache_skeletaltransform3x4, R_BUFFERDATA_UNIFORM, &ent->animcache_skeletaltransform3x4offset);
    }
    else if (ent->animcache_vertex3f)
    {
        // mesh was already cached but we may need to add normals/tangents
        // (this only happens with multiple views, reflections, cameras, etc)
        if (wantnormals || wanttangents)
        {
            numvertices = model->surfmesh.num_vertices;
            if (wantnormals)
                ent->animcache_normal3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
            if (wanttangents)
            {
                ent->animcache_svector3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
                ent->animcache_tvector3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
            }
            model->AnimateVertices(model, ent->frameblend, ent->skeleton, NULL, wantnormals ? ent->animcache_normal3f : NULL, wanttangents ? ent->animcache_svector3f : NULL, wanttangents ? ent->animcache_tvector3f : NULL);
            r_refdef.stats[r_stat_animcache_shade_count] += 1;
            r_refdef.stats[r_stat_animcache_shade_vertices] += numvertices;
            r_refdef.stats[r_stat_animcache_shade_maxvertices] = max(r_refdef.stats[r_stat_animcache_shade_maxvertices], numvertices);
        }
    }
    else
    {
        // generate mesh cache
        numvertices = model->surfmesh.num_vertices;
        ent->animcache_vertex3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
        if (wantnormals)
            ent->animcache_normal3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
        if (wanttangents)
        {
            ent->animcache_svector3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
            ent->animcache_tvector3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
        }
        model->AnimateVertices(model, ent->frameblend, ent->skeleton, ent->animcache_vertex3f, ent->animcache_normal3f, ent->animcache_svector3f, ent->animcache_tvector3f);
        if (wantnormals || wanttangents)
        {
            r_refdef.stats[r_stat_animcache_shade_count] += 1;
            r_refdef.stats[r_stat_animcache_shade_vertices] += numvertices;
            r_refdef.stats[r_stat_animcache_shade_maxvertices] = max(r_refdef.stats[r_stat_animcache_shade_maxvertices], numvertices);
        }
        r_refdef.stats[r_stat_animcache_shape_count] += 1;
        r_refdef.stats[r_stat_animcache_shape_vertices] += numvertices;
        r_refdef.stats[r_stat_animcache_shape_maxvertices] = max(r_refdef.stats[r_stat_animcache_shape_maxvertices], numvertices);
    }
    return true;
}

References entity_render_t::animcache_normal3f, entity_render_t::animcache_skeletaltransform3x4, entity_render_t::animcache_skeletaltransform3x4buffer, entity_render_t::animcache_skeletaltransform3x4offset, entity_render_t::animcache_skeletaltransform3x4size, entity_render_t::animcache_svector3f, entity_render_t::animcache_tvector3f, entity_render_t::animcache_vertex3f, entity_render_t::frameblend, max, Mod_Skeletal_BuildTransforms(), entity_render_t::model, model, NULL, R_BufferData_Store(), R_BUFFERDATA_UNIFORM, R_FrameData_Alloc(), r_gpuskeletal, r_refdef, r_stat_animcache_shade_count, r_stat_animcache_shade_maxvertices, r_stat_animcache_shade_vertices, r_stat_animcache_shape_count, r_stat_animcache_shape_maxvertices, r_stat_animcache_shape_vertices, r_stat_animcache_skeletal_bones, r_stat_animcache_skeletal_count, r_stat_animcache_skeletal_maxbones, skeleton_t::relativetransforms, and entity_render_t::skeleton.

Referenced by R_AnimCache_CacheVisibleEntities(), R_Shadow_PrepareLight(), and R_Shadow_PrepareModelShadows().

◆ R_BufferData_NewFrame()

void R_BufferData_NewFrame ( void )

begin a new frame (recycle old buffers)

Definition at line 3678 of file gl_rmain.c.

{
    int type;
    r_bufferdata_buffer_t **p, *mem;
    // cycle to the next frame's buffers
    r_bufferdata_cycle = (r_bufferdata_cycle + 1) % R_BUFFERDATA_CYCLE;
    // if we ran out of space on the last time we used these buffers, free the old memory now
    for (type = 0;type < R_BUFFERDATA_COUNT;type++)
    {
        if (r_bufferdata_buffer[r_bufferdata_cycle][type])
        {
            R_BufferData_Resize((r_bufferdata_type_t)type, false, 131072);
            // free all but the head buffer, this is how we recycle obsolete
            // buffers after they are no longer in use
            p = &r_bufferdata_buffer[r_bufferdata_cycle][type]->purge;
            while (*p)
            {
                mem = *p;
                *p = (*p)->purge;
                if (mem->buffer)
                    R_Mesh_DestroyMeshBuffer(mem->buffer);
                Mem_Free(mem);
            }
            // reset the current offset
            r_bufferdata_buffer[r_bufferdata_cycle][type]->current = 0;
        }
    }
}

References r_bufferdata_buffer_t::buffer, Mem_Free, r_bufferdata_buffer_t::purge, r_bufferdata_buffer, R_BUFFERDATA_COUNT, R_BUFFERDATA_CYCLE, r_bufferdata_cycle, R_BufferData_Resize(), R_Mesh_DestroyMeshBuffer(), and type.

Referenced by CL_UpdateScreen().

◆ R_BufferData_Reset()

void R_BufferData_Reset ( void )

free all dynamic vertex/index/uniform buffers

Definition at line 3613 of file gl_rmain.c.

{
    int cycle, type;
    r_bufferdata_buffer_t **p, *mem;
    for (cycle = 0;cycle < R_BUFFERDATA_CYCLE;cycle++)
    {
        for (type = 0;type < R_BUFFERDATA_COUNT;type++)
        {
            // free all buffers
            p = &r_bufferdata_buffer[cycle][type];
            while (*p)
            {
                mem = *p;
                *p = (*p)->purge;
                if (mem->buffer)
                    R_Mesh_DestroyMeshBuffer(mem->buffer);
                Mem_Free(mem);
            }
        }
    }
}

References r_bufferdata_buffer_t::buffer, Mem_Free, r_bufferdata_buffer_t::purge, r_bufferdata_buffer, R_BUFFERDATA_COUNT, R_BUFFERDATA_CYCLE, R_Mesh_DestroyMeshBuffer(), and type.

Referenced by gl_main_newmap(), gl_main_shutdown(), and gl_main_start().

◆ R_BufferData_Store()

r_meshbuffer_t * R_BufferData_Store	(	size_t	size,
		const void *	data,
		r_bufferdata_type_t	type,
		int *	returnbufferoffset )

request space in a vertex/index/uniform buffer for the chosen data, returns the buffer pointer and offset, always successful

Definition at line 3707 of file gl_rmain.c.

{
    r_bufferdata_buffer_t *mem;
    int offset = 0;
    int padsize;
 
    *returnbufferoffset = 0;
 
    // align size to a byte boundary appropriate for the buffer type, this
    // makes all allocations have aligned start offsets
    if (type == R_BUFFERDATA_UNIFORM)
        padsize = (datasize + r_uniformbufferalignment - 1) & ~(r_uniformbufferalignment - 1);
    else
        padsize = (datasize + 15) & ~15;
 
    // if we ran out of space in this buffer we must allocate a new one
    if (!r_bufferdata_buffer[r_bufferdata_cycle][type] || r_bufferdata_buffer[r_bufferdata_cycle][type]->current + padsize > r_bufferdata_buffer[r_bufferdata_cycle][type]->size)
        R_BufferData_Resize(type, true, padsize);
 
    // if the resize did not give us enough memory, fail
    if (!r_bufferdata_buffer[r_bufferdata_cycle][type] || r_bufferdata_buffer[r_bufferdata_cycle][type]->current + padsize > r_bufferdata_buffer[r_bufferdata_cycle][type]->size)
        Sys_Error("R_BufferData_Store: failed to create a new buffer of sufficient size\n");
 
    mem = r_bufferdata_buffer[r_bufferdata_cycle][type];
    offset = (int)mem->current;
    mem->current += padsize;
 
    // upload the data to the buffer at the chosen offset
    if (offset == 0)
        R_Mesh_UpdateMeshBuffer(mem->buffer, NULL, mem->size, false, 0);
    R_Mesh_UpdateMeshBuffer(mem->buffer, data, datasize, true, offset);
 
    // count the usage for stats
    r_refdef.stats[r_stat_bufferdatacurrent_vertex + type] = max(r_refdef.stats[r_stat_bufferdatacurrent_vertex + type], (int)mem->current);
    r_refdef.stats[r_stat_bufferdatasize_vertex + type] = max(r_refdef.stats[r_stat_bufferdatasize_vertex + type], (int)mem->size);
 
    // return the buffer offset
    *returnbufferoffset = offset;
 
    return mem->buffer;
}

References r_bufferdata_buffer_t::buffer, r_bufferdata_buffer_t::current, data, int(), max, NULL, offset, r_bufferdata_buffer, r_bufferdata_cycle, R_BufferData_Resize(), R_BUFFERDATA_UNIFORM, R_Mesh_UpdateMeshBuffer(), r_refdef, r_stat_bufferdatacurrent_vertex, r_stat_bufferdatasize_vertex, r_uniformbufferalignment, r_bufferdata_buffer_t::size, size, Sys_Error(), and type.

Referenced by Mod_Mesh_UploadDynamicBuffers(), R_AnimCache_GetEntity(), R_Mesh_Draw(), R_Mesh_PrepareVertices_Generic_Arrays(), R_Mesh_PrepareVertices_Mesh_Arrays(), R_Mesh_PrepareVertices_Vertex3f(), and RSurf_UploadBuffersForBatch().

◆ R_BuildLightMap()

void R_BuildLightMap	(	const entity_render_t *	ent,
		msurface_t *	surface,
		int	combine )

Definition at line 50 of file gl_rsurf.c.

{
    int smax, tmax, i, size, size3, maps, l;
    int *bl, scale;
    unsigned char *lightmap, *out, *stain;
    model_t *model = ent->model;
    int *intblocklights;
    unsigned char *templight;
 
    smax = (surface->lightmapinfo->extents[0]>>4)+1;
    tmax = (surface->lightmapinfo->extents[1]>>4)+1;
    size = smax*tmax;
    size3 = size*3;
 
    r_refdef.stats[r_stat_lightmapupdatepixels] += size;
    r_refdef.stats[r_stat_lightmapupdates]++;
 
    if (cl.buildlightmapmemorysize < size*sizeof(int[3]))
    {
        cl.buildlightmapmemorysize = size*sizeof(int[3]);
        if (cl.buildlightmapmemory)
            Mem_Free(cl.buildlightmapmemory);
        cl.buildlightmapmemory = (unsigned char *) Mem_Alloc(cls.levelmempool, cl.buildlightmapmemorysize);
    }
 
    // these both point at the same buffer, templight is only used for final
    // processing and can replace the intblocklights data as it goes
    intblocklights = (int *)cl.buildlightmapmemory;
    templight = (unsigned char *)cl.buildlightmapmemory;
 
    // update cached lighting info
    model->brushq1.lightmapupdateflags[surface - model->data_surfaces] = false;
 
    lightmap = surface->lightmapinfo->samples;
 
// set to full bright if no light data
    bl = intblocklights;
    if (!model->brushq1.lightdata)
    {
        for (i = 0;i < size3;i++)
            bl[i] = 128*256;
    }
    else
    {
// clear to no light
        memset(bl, 0, size3*sizeof(*bl));
 
// add all the lightmaps
        if (lightmap)
            for (maps = 0;maps < MAXLIGHTMAPS && surface->lightmapinfo->styles[maps] != 255;maps++, lightmap += size3)
                for (scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[maps]], i = 0;i < size3;i++)
                    bl[i] += lightmap[i] * scale;
    }
 
    stain = surface->lightmapinfo->stainsamples;
    bl = intblocklights;
    out = templight;
    // the >> 16 shift adjusts down 8 bits to account for the stainmap
    // scaling, and remaps the 0-65536 (2x overbright) to 0-256, it will
    // be doubled during rendering to achieve 2x overbright
    // (0 = 0.0, 128 = 1.0, 256 = 2.0)
    if (stain)
    {
        for (i = 0;i < size;i++, bl += 3, stain += 3, out += 4)
        {
            l = (bl[0] * stain[0]) >> 16;out[2] = min(l, 255);
            l = (bl[1] * stain[1]) >> 16;out[1] = min(l, 255);
            l = (bl[2] * stain[2]) >> 16;out[0] = min(l, 255);
            out[3] = 255;
        }
    }
    else
    {
        for (i = 0;i < size;i++, bl += 3, out += 4)
        {
            l = bl[0] >> 8;out[2] = min(l, 255);
            l = bl[1] >> 8;out[1] = min(l, 255);
            l = bl[2] >> 8;out[0] = min(l, 255);
            out[3] = 255;
        }
    }
 
    if(vid_sRGB.integer && vid_sRGB_fallback.integer && !vid.sRGB3D)
        Image_MakesRGBColorsFromLinear_Lightmap(templight, templight, size);
    R_UpdateTexture(surface->lightmaptexture, templight, surface->lightmapinfo->lightmaporigin[0], surface->lightmapinfo->lightmaporigin[1], 0, smax, tmax, 1, combine);
 
    // update the surface's deluxemap if it has one
    if (surface->deluxemaptexture != r_texture_blanknormalmap)
    {
        vec3_t n;
        unsigned char *normalmap = surface->lightmapinfo->nmapsamples;
        lightmap = surface->lightmapinfo->samples;
        // clear to no normalmap
        bl = intblocklights;
        memset(bl, 0, size3*sizeof(*bl));
        // add all the normalmaps
        if (lightmap && normalmap)
        {
            for (maps = 0;maps < MAXLIGHTMAPS && surface->lightmapinfo->styles[maps] != 255;maps++, lightmap += size3, normalmap += size3)
            {
                for (scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[maps]], i = 0;i < size;i++)
                {
                    // add the normalmap with weighting proportional to the style's lightmap intensity
                    l = (int)(VectorLength(lightmap + i*3) * scale);
                    bl[i*3+0] += ((int)normalmap[i*3+0] - 128) * l;
                    bl[i*3+1] += ((int)normalmap[i*3+1] - 128) * l;
                    bl[i*3+2] += ((int)normalmap[i*3+2] - 128) * l;
                }
            }
        }
        bl = intblocklights;
        out = templight;
        // we simply renormalize the weighted normals to get a valid deluxemap
        for (i = 0;i < size;i++, bl += 3, out += 4)
        {
            VectorCopy(bl, n);
            VectorNormalize(n);
            l = (int)(n[0] * 128 + 128);out[2] = bound(0, l, 255);
            l = (int)(n[1] * 128 + 128);out[1] = bound(0, l, 255);
            l = (int)(n[2] * 128 + 128);out[0] = bound(0, l, 255);
            out[3] = 255;
        }
        R_UpdateTexture(surface->deluxemaptexture, templight, surface->lightmapinfo->lightmaporigin[0], surface->lightmapinfo->lightmaporigin[1], 0, smax, tmax, 1, r_q1bsp_lightmap_updates_combine.integer);
    }
}

References bound, cl, cls, msurface_t::deluxemaptexture, msurface_lightmapinfo_t::extents, Image_MakesRGBColorsFromLinear_Lightmap(), int(), msurface_t::lightmapinfo, msurface_lightmapinfo_t::lightmaporigin, msurface_t::lightmaptexture, MAXLIGHTMAPS, Mem_Alloc, Mem_Free, min, entity_render_t::model, model, n, msurface_lightmapinfo_t::nmapsamples, r_q1bsp_lightmap_updates_combine, r_refdef, r_stat_lightmapupdatepixels, r_stat_lightmapupdates, r_texture_blanknormalmap, R_UpdateTexture(), msurface_lightmapinfo_t::samples, scale, size, msurface_lightmapinfo_t::stainsamples, msurface_lightmapinfo_t::styles, VectorCopy, VectorLength, VectorNormalize, vid, vid_sRGB, and vid_sRGB_fallback.

Referenced by R_DrawModelSurfaces().

◆ R_CalcBeam_Vertex3f()

void R_CalcBeam_Vertex3f	(	float *	vert,
		const float *	org1,
		const float *	org2,
		float	width )

Definition at line 6253 of file gl_rmain.c.

{
    vec3_t right1, right2, diff, normal;
 
    VectorSubtract (org2, org1, normal);
 
    // calculate 'right' vector for start
    VectorSubtract (r_refdef.view.origin, org1, diff);
    CrossProduct (normal, diff, right1);
    VectorNormalize (right1);
 
    // calculate 'right' vector for end
    VectorSubtract (r_refdef.view.origin, org2, diff);
    CrossProduct (normal, diff, right2);
    VectorNormalize (right2);
 
    vert[ 0] = org1[0] + width * right1[0];
    vert[ 1] = org1[1] + width * right1[1];
    vert[ 2] = org1[2] + width * right1[2];
    vert[ 3] = org1[0] - width * right1[0];
    vert[ 4] = org1[1] - width * right1[1];
    vert[ 5] = org1[2] - width * right1[2];
    vert[ 6] = org2[0] - width * right2[0];
    vert[ 7] = org2[1] - width * right2[1];
    vert[ 8] = org2[2] - width * right2[2];
    vert[ 9] = org2[0] + width * right2[0];
    vert[10] = org2[1] + width * right2[1];
    vert[11] = org2[2] + width * right2[2];
}

References CrossProduct, normal, r_refdef, VectorNormalize, VectorSubtract, and width.

Referenced by R_DrawParticle_TransparentCallback().

◆ R_CalcSprite_Vertex3f()

void R_CalcSprite_Vertex3f	(	float *	vertex3f,
		const vec3_t	origin,
		const vec3_t	left,
		const vec3_t	up,
		float	scalex1,
		float	scalex2,
		float	scaley1,
		float	scaley2 )

Definition at line 6283 of file gl_rmain.c.

{
    vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
    vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
    vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
    vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
    vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
    vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
    vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
    vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
    vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
    vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
    vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
    vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
}

References origin, and up.

Referenced by R_BeginCoronaQuery(), R_DrawCorona(), R_Model_Sprite_Draw_TransparentCallback(), R_Shadow_DrawCursor_TransparentCallback(), and R_Shadow_DrawLightSprite_TransparentCallback().

◆ R_CanSeeBox()

qbool R_CanSeeBox	(	int	numsamples,
		vec_t	eyejitter,
		vec_t	entboxenlarge,
		vec_t	entboxexpand,
		vec_t	pad,
		vec3_t	eye,
		vec3_t	entboxmins,
		vec3_t	entboxmaxs )

Definition at line 3888 of file gl_rmain.c.

{
    long unsigned int i;
    int j;
    vec3_t eyemins, eyemaxs;
    vec3_t boxmins, boxmaxs;
    vec3_t padmins, padmaxs;
    vec3_t start;
    vec3_t end;
    model_t *model = r_refdef.scene.worldmodel;
    static vec3_t positions[] = {
        { 0.5f, 0.5f, 0.5f },
        { 0.0f, 0.0f, 0.0f },
        { 0.0f, 0.0f, 1.0f },
        { 0.0f, 1.0f, 0.0f },
        { 0.0f, 1.0f, 1.0f },
        { 1.0f, 0.0f, 0.0f },
        { 1.0f, 0.0f, 1.0f },
        { 1.0f, 1.0f, 0.0f },
        { 1.0f, 1.0f, 1.0f },
    };
 
    // sample count can be set to -1 to skip this logic, for flicker-prone objects
    if (numsamples < 0)
        return true;
 
    // view origin is not used for culling in portal/reflection/refraction renders or isometric views
    if (!r_refdef.view.usevieworiginculling)
        return true;
 
    if (!r_cullentities_trace_entityocclusion.integer && (!model || !model->brush.TraceLineOfSight))
        return true;
 
    // expand the eye box a little
    eyemins[0] = eye[0] - eyejitter;
    eyemaxs[0] = eye[0] + eyejitter;
    eyemins[1] = eye[1] - eyejitter;
    eyemaxs[1] = eye[1] + eyejitter;
    eyemins[2] = eye[2] - eyejitter;
    eyemaxs[2] = eye[2] + eyejitter;
    // expand the box a little
    boxmins[0] = (entboxenlarge + 1) * entboxmins[0] - entboxenlarge * entboxmaxs[0] - entboxexpand;
    boxmaxs[0] = (entboxenlarge + 1) * entboxmaxs[0] - entboxenlarge * entboxmins[0] + entboxexpand;
    boxmins[1] = (entboxenlarge + 1) * entboxmins[1] - entboxenlarge * entboxmaxs[1] - entboxexpand;
    boxmaxs[1] = (entboxenlarge + 1) * entboxmaxs[1] - entboxenlarge * entboxmins[1] + entboxexpand;
    boxmins[2] = (entboxenlarge + 1) * entboxmins[2] - entboxenlarge * entboxmaxs[2] - entboxexpand;
    boxmaxs[2] = (entboxenlarge + 1) * entboxmaxs[2] - entboxenlarge * entboxmins[2] + entboxexpand;
    // make an even larger box for the acceptable area
    padmins[0] = boxmins[0] - pad;
    padmaxs[0] = boxmaxs[0] + pad;
    padmins[1] = boxmins[1] - pad;
    padmaxs[1] = boxmaxs[1] + pad;
    padmins[2] = boxmins[2] - pad;
    padmaxs[2] = boxmaxs[2] + pad;
 
    // return true if eye overlaps enlarged box
    if (BoxesOverlap(boxmins, boxmaxs, eyemins, eyemaxs))
        return true;
 
    VectorCopy(eye, start);
    // try specific positions in the box first - note that these can be cached
    if (r_cullentities_trace_entityocclusion.integer)
    {
        for (i = 0; i < sizeof(positions) / sizeof(positions[0]); i++)
        {
            trace_t trace;
            end[0] = boxmins[0] + (boxmaxs[0] - boxmins[0]) * positions[i][0];
            end[1] = boxmins[1] + (boxmaxs[1] - boxmins[1]) * positions[i][1];
            end[2] = boxmins[2] + (boxmaxs[2] - boxmins[2]) * positions[i][2];
            //trace_t trace = CL_TraceLine(start, end, MOVE_NORMAL, NULL, SUPERCONTENTS_SOLID, SUPERCONTENTS_SKY, MATERIALFLAGMASK_TRANSLUCENT, 0.0f, true, false, NULL, true, true);
            trace = CL_Cache_TraceLineSurfaces(start, end, MOVE_NORMAL, SUPERCONTENTS_SOLID, 0, MATERIALFLAGMASK_TRANSLUCENT);
            // not picky - if the trace ended anywhere in the box we're good
            if (BoxesOverlap(trace.endpos, trace.endpos, padmins, padmaxs))
                return true;
        }
    }
    else
    {
        // try center
        VectorMAM(0.5f, boxmins, 0.5f, boxmaxs, end);
        if (model->brush.TraceLineOfSight(model, start, end, padmins, padmaxs))
            return true;
    }
 
    // try various random positions
    for (j = 0; j < numsamples; j++)
    {
        VectorSet(start, lhrandom(eyemins[0], eyemaxs[0]), lhrandom(eyemins[1], eyemaxs[1]), lhrandom(eyemins[2], eyemaxs[2]));
        VectorSet(end, lhrandom(boxmins[0], boxmaxs[0]), lhrandom(boxmins[1], boxmaxs[1]), lhrandom(boxmins[2], boxmaxs[2]));
        if (r_cullentities_trace_entityocclusion.integer)
        {
            trace_t trace = CL_TraceLine(start, end, MOVE_NORMAL, NULL, SUPERCONTENTS_SOLID, SUPERCONTENTS_SKY, MATERIALFLAGMASK_TRANSLUCENT, 0.0f, true, false, NULL, true, true);
            // not picky - if the trace ended anywhere in the box we're good
            if (BoxesOverlap(trace.endpos, trace.endpos, padmins, padmaxs))
                return true;
        }
        else if (model->brush.TraceLineOfSight(model, start, end, padmins, padmaxs))
            return true;
    }
 
    return false;
}

References BoxesOverlap, CL_Cache_TraceLineSurfaces(), CL_TraceLine(), trace_t::endpos, lhrandom, MATERIALFLAGMASK_TRANSLUCENT, model, MOVE_NORMAL, NULL, r_cullentities_trace_entityocclusion, r_refdef, SUPERCONTENTS_SKY, SUPERCONTENTS_SOLID, VectorCopy, VectorMAM, and VectorSet.

Referenced by R_Shadow_BounceGrid_AssignPhotons_Task(), R_Shadow_PrepareLight(), R_View_UpdateEntityVisible(), R_View_WorldVisibility(), and R_View_WorldVisibility_CullSurfaces().

◆ R_CompileShader_CheckStaticParms()

qbool R_CompileShader_CheckStaticParms ( void )

Definition at line 861 of file gl_rmain.c.

{
    static int r_compileshader_staticparms_save[(SHADERSTATICPARMS_COUNT + 0x1F) >> 5];
    memcpy(r_compileshader_staticparms_save, r_compileshader_staticparms, sizeof(r_compileshader_staticparms));
    memset(r_compileshader_staticparms, 0, sizeof(r_compileshader_staticparms));
 
    // detect all
    if (r_glsl_saturation_redcompensate.integer)
        R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_SATURATION_REDCOMPENSATE);
    if (r_glsl_vertextextureblend_usebothalphas.integer)
        R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_VERTEXTEXTUREBLEND_USEBOTHALPHAS);
    if (r_shadow_glossexact.integer)
        R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_EXACTSPECULARMATH);
    if (r_glsl_postprocess.integer)
    {
        if (r_glsl_postprocess_uservec1_enable.integer)
            R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_POSTPROCESS_USERVEC1);
        if (r_glsl_postprocess_uservec2_enable.integer)
            R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_POSTPROCESS_USERVEC2);
        if (r_glsl_postprocess_uservec3_enable.integer)
            R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_POSTPROCESS_USERVEC3);
        if (r_glsl_postprocess_uservec4_enable.integer)
            R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_POSTPROCESS_USERVEC4);
    }
    if (r_fxaa.integer)
        R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_FXAA);
    if (r_glsl_offsetmapping_lod.integer && r_glsl_offsetmapping_lod_distance.integer > 0)
        R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_OFFSETMAPPING_USELOD);
 
    if (r_shadow_shadowmapsampler)
        R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_SHADOWSAMPLER);
    if (r_shadow_shadowmappcf > 1)
        R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_SHADOWMAPPCF_2);
    else if (r_shadow_shadowmappcf)
        R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_SHADOWMAPPCF_1);
    if (r_celshading.integer)
        R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_CELSHADING);
    if (r_celoutlines.integer)
        R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_CELOUTLINES);
    if (r_colorfringe.value)
        R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_COLORFRINGE);
 
    return memcmp(r_compileshader_staticparms, r_compileshader_staticparms_save, sizeof(r_compileshader_staticparms)) != 0;
}

References r_celoutlines, r_celshading, r_colorfringe, R_COMPILESHADER_STATICPARM_ENABLE, r_compileshader_staticparms, r_fxaa, r_glsl_offsetmapping_lod, r_glsl_offsetmapping_lod_distance, r_glsl_postprocess, r_glsl_postprocess_uservec1_enable, r_glsl_postprocess_uservec2_enable, r_glsl_postprocess_uservec3_enable, r_glsl_postprocess_uservec4_enable, r_glsl_saturation_redcompensate, r_glsl_vertextextureblend_usebothalphas, r_shadow_glossexact, r_shadow_shadowmappcf, r_shadow_shadowmapsampler, SHADERSTATICPARM_CELOUTLINES, SHADERSTATICPARM_CELSHADING, SHADERSTATICPARM_COLORFRINGE, SHADERSTATICPARM_EXACTSPECULARMATH, SHADERSTATICPARM_FXAA, SHADERSTATICPARM_OFFSETMAPPING_USELOD, SHADERSTATICPARM_POSTPROCESS_USERVEC1, SHADERSTATICPARM_POSTPROCESS_USERVEC2, SHADERSTATICPARM_POSTPROCESS_USERVEC3, SHADERSTATICPARM_POSTPROCESS_USERVEC4, SHADERSTATICPARM_SATURATION_REDCOMPENSATE, SHADERSTATICPARM_SHADOWMAPPCF_1, SHADERSTATICPARM_SHADOWMAPPCF_2, SHADERSTATICPARM_SHADOWSAMPLER, SHADERSTATICPARM_VERTEXTEXTUREBLEND_USEBOTHALPHAS, and SHADERSTATICPARMS_COUNT.

Referenced by R_RenderView(), and R_Shadow_SetShadowMode().

◆ R_CullBox()

qbool R_CullBox	(	const vec3_t	mins,
		const vec3_t	maxs,
		int	numplanes,
		const mplane_t *	planes )

Definition at line 3470 of file gl_rmain.c.

{
    // nothing to ignore
    return _R_CullBox(mins, maxs, numplanes, planes, -1);
}

References _R_CullBox(), maxs, and mins.

Referenced by R_Q1BSP_RecursiveGetLightInfo_BIH(), R_Q1BSP_RecursiveGetLightInfo_BSP(), and R_Shadow_PrepareLight().

◆ R_CullFrustum()

qbool R_CullFrustum	(	const vec3_t	mins,
		const vec3_t	maxs )

Definition at line 3464 of file gl_rmain.c.

{
    // skip nearclip plane, it often culls portals when you are very close, and is almost never useful
    return _R_CullBox(mins, maxs, r_refdef.view.numfrustumplanes, r_refdef.view.frustum, 4);
}

References _R_CullBox(), maxs, mins, and r_refdef.

Referenced by R_DrawDebugModel(), R_DrawPortals(), R_Shadow_BounceGrid_AssignPhotons_Task(), R_Shadow_BounceGrid_TracePhotons_Shot(), R_Shadow_PrepareLight(), R_View_UpdateEntityVisible(), R_View_WorldVisibility(), and R_View_WorldVisibility_CullSurfaces().

◆ R_DebugLine()

void R_DebugLine	(	vec3_t	start,
		vec3_t	end )

Definition at line 10107 of file gl_rmain.c.

{
    model_t *mod = CL_Mesh_UI();
    msurface_t *surf;
    int e0, e1, e2, e3;
    float offsetx, offsety, x1, y1, x2, y2, width = 1.0f;
    float r1 = 1.0f, g1 = 0.0f, b1 = 0.0f, alpha1 = 0.25f;
    float r2 = 1.0f, g2 = 1.0f, b2 = 0.0f, alpha2 = 0.25f;
    vec4_t w[2], s[2];
 
    // transform to screen coords first
    Vector4Set(w[0], start[0], start[1], start[2], 1);
    Vector4Set(w[1], end[0], end[1], end[2], 1);
    R_Viewport_TransformToScreen(&r_refdef.view.viewport, w[0], s[0]);
    R_Viewport_TransformToScreen(&r_refdef.view.viewport, w[1], s[1]);
    x1 = s[0][0] * vid_conwidth.value / vid.mode.width;
    y1 = (vid.mode.height - s[0][1]) * vid_conheight.value / vid.mode.height;
    x2 = s[1][0] * vid_conwidth.value / vid.mode.width;
    y2 = (vid.mode.height - s[1][1]) * vid_conheight.value / vid.mode.height;
    //Con_DPrintf("R_DebugLine: %.0f,%.0f to %.0f,%.0f\n", x1, y1, x2, y2);
 
    // add the line to the UI mesh for drawing later
 
    // width is measured in real pixels
    if (fabs(x2 - x1) > fabs(y2 - y1))
    {
        offsetx = 0;
        offsety = 0.5f * width * vid_conheight.value / vid.mode.height;
    }
    else
    {
        offsetx = 0.5f * width * vid_conwidth.value / vid.mode.width;
        offsety = 0;
    }
    surf = Mod_Mesh_AddSurface(mod, Mod_Mesh_GetTexture(mod, "white", 0, 0, MATERIALFLAG_WALL | MATERIALFLAG_VERTEXCOLOR | MATERIALFLAG_ALPHAGEN_VERTEX | MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW), true);
    e0 = Mod_Mesh_IndexForVertex(mod, surf, x1 - offsetx, y1 - offsety, 10, 0, 0, -1, 0, 0, 0, 0, r1, g1, b1, alpha1);
    e1 = Mod_Mesh_IndexForVertex(mod, surf, x2 - offsetx, y2 - offsety, 10, 0, 0, -1, 0, 0, 0, 0, r2, g2, b2, alpha2);
    e2 = Mod_Mesh_IndexForVertex(mod, surf, x2 + offsetx, y2 + offsety, 10, 0, 0, -1, 0, 0, 0, 0, r2, g2, b2, alpha2);
    e3 = Mod_Mesh_IndexForVertex(mod, surf, x1 + offsetx, y1 + offsety, 10, 0, 0, -1, 0, 0, 0, 0, r1, g1, b1, alpha1);
    Mod_Mesh_AddTriangle(mod, surf, e0, e1, e2);
    Mod_Mesh_AddTriangle(mod, surf, e0, e2, e3);
 
}

References CL_Mesh_UI, fabs(), MATERIALFLAG_ALPHA, MATERIALFLAG_ALPHAGEN_VERTEX, MATERIALFLAG_BLENDED, MATERIALFLAG_NOSHADOW, MATERIALFLAG_VERTEXCOLOR, MATERIALFLAG_WALL, mod(), Mod_Mesh_AddSurface(), Mod_Mesh_AddTriangle(), Mod_Mesh_GetTexture(), Mod_Mesh_IndexForVertex(), r_refdef, R_Viewport_TransformToScreen(), Vector4Set, vid, vid_conheight, vid_conwidth, w, width, x1, x2, and y2.

Referenced by R_DrawParticle_TransparentCallback(), and R_Model_Sprite_Draw_TransparentCallback().

◆ R_DecalSystem_Reset()

void R_DecalSystem_Reset ( decalsystem_t * decalsystem )

Definition at line 9134 of file gl_rmain.c.

{
    if (decalsystem->decals)
        Mem_Free(decalsystem->decals);
    memset(decalsystem, 0, sizeof(*decalsystem));
}

References decalsystem_t::decals, and Mem_Free.

Referenced by CL_UpdateNetworkEntities(), CLVM_free_edict(), R_DecalSystem_SplatEntity(), R_DrawModelDecals_Entity(), and R_DrawModelDecals_FadeEntity().

◆ R_DecalSystem_SplatEntities()

void R_DecalSystem_SplatEntities	(	const vec3_t	org,
		const vec3_t	normal,
		float	r,
		float	g,
		float	b,
		float	a,
		float	s1,
		float	t1,
		float	s2,
		float	t2,
		float	size )

Definition at line 9506 of file gl_rmain.c.

{
    r_decalsystem_splatqueue_t *queue;
 
    if (r_decalsystem_numqueued == MAX_DECALSYSTEM_QUEUE)
        return;
 
    queue = &r_decalsystem_queue[r_decalsystem_numqueued++];
    VectorCopy(worldorigin, queue->worldorigin);
    VectorCopy(worldnormal, queue->worldnormal);
    Vector4Set(queue->color, r, g, b, a);
    Vector4Set(queue->tcrange, s1, t1, s2, t2);
    queue->worldsize = worldsize;
    queue->decalsequence = cl.decalsequence++;
}

References a, b, cl, r_decalsystem_splatqueue_t::color, r_decalsystem_splatqueue_t::decalsequence, g, MAX_DECALSYSTEM_QUEUE, r, r_decalsystem_numqueued, r_decalsystem_queue, r_decalsystem_splatqueue_t::tcrange, Vector4Set, VectorCopy, r_decalsystem_splatqueue_t::worldnormal, r_decalsystem_splatqueue_t::worldorigin, and r_decalsystem_splatqueue_t::worldsize.

Referenced by CL_ImmediateBloodStain(), and CL_SpawnDecalParticleForSurface().

◆ R_DrawCustomSurface()

void R_DrawCustomSurface	(	skinframe_t *	skinframe,
		const matrix4x4_t *	texmatrix,
		int	materialflags,
		int	firstvertex,
		int	numvertices,
		int	firsttriangle,
		int	numtriangles,
		qbool	writedepth,
		qbool	prepass,
		qbool	ui )

Definition at line 10152 of file gl_rmain.c.

{
    static texture_t texture;
 
    // fake enough texture and surface state to render this geometry
 
    texture.update_lastrenderframe = -1; // regenerate this texture
    texture.basematerialflags = materialflags | MATERIALFLAG_CUSTOMSURFACE | MATERIALFLAG_WALL;
    texture.basealpha = 1.0f;
    texture.currentskinframe = skinframe;
    texture.currenttexmatrix = *texmatrix; // requires MATERIALFLAG_CUSTOMSURFACE
    texture.offsetmapping = OFFSETMAPPING_OFF;
    texture.offsetscale = 1;
    texture.specularscalemod = 1;
    texture.specularpowermod = 1;
    texture.transparentsort = TRANSPARENTSORT_DISTANCE;
 
    R_DrawCustomSurface_Texture(&texture, texmatrix, materialflags, firstvertex, numvertices, firsttriangle, numtriangles, writedepth, prepass, ui);
}

References MATERIALFLAG_CUSTOMSURFACE, MATERIALFLAG_WALL, OFFSETMAPPING_OFF, R_DrawCustomSurface_Texture(), texture, and TRANSPARENTSORT_DISTANCE.

Referenced by R_DrawCorona(), R_Shadow_DrawCursor_TransparentCallback(), R_Shadow_DrawLightSprite_TransparentCallback(), R_SkyBox(), and R_SkySphere().

◆ R_DrawCustomSurface_Texture()

void R_DrawCustomSurface_Texture	(	texture_t *	texture,
		const matrix4x4_t *	texmatrix,
		int	materialflags,
		int	firstvertex,
		int	numvertices,
		int	firsttriangle,
		int	numtriangles,
		qbool	writedepth,
		qbool	prepass,
		qbool	ui )

Definition at line 10172 of file gl_rmain.c.

{
    static msurface_t surface;
    const msurface_t *surfacelist = &surface;
 
    // fake enough texture and surface state to render this geometry
    surface.texture = texture;
    surface.num_triangles = numtriangles;
    surface.num_firsttriangle = firsttriangle;
    surface.num_vertices = numvertices;
    surface.num_firstvertex = firstvertex;
 
    // now render it
    rsurface.texture = R_GetCurrentTexture(surface.texture);
    rsurface.lightmaptexture = NULL;
    rsurface.deluxemaptexture = NULL;
    rsurface.uselightmaptexture = false;
    R_DrawModelTextureSurfaceList(1, &surfacelist, writedepth, prepass, ui);
}

References NULL, msurface_t::num_firsttriangle, msurface_t::num_firstvertex, msurface_t::num_triangles, msurface_t::num_vertices, R_DrawModelTextureSurfaceList(), R_GetCurrentTexture(), rsurface, msurface_t::texture, and texture.

Referenced by R_DrawCustomSurface(), and R_Model_Sprite_Draw_TransparentCallback().

◆ R_DrawExplosions()

void R_DrawExplosions ( void )

Definition at line 264 of file r_explosion.c.

{
#ifdef MAX_EXPLOSIONS
    int i;
 
    if (!r_drawexplosions.integer)
        return;
 
    for (i = 0;i < numexplosions;i++)
    {
        if (explosion[i].alpha)
        {
            R_MoveExplosion(&explosion[i]);
            if (explosion[i].alpha)
                R_MeshQueue_AddTransparent(TRANSPARENTSORT_DISTANCE, explosion[i].origin, R_DrawExplosion_TransparentCallback, NULL, i, NULL);
        }
    }
    while (numexplosions > 0 && explosion[i-1].alpha <= 0)
        numexplosions--;
#endif
}

References alpha, explosion, NULL, numexplosions, origin, R_DrawExplosion_TransparentCallback(), r_drawexplosions, R_MeshQueue_AddTransparent(), R_MoveExplosion(), and TRANSPARENTSORT_DISTANCE.

Referenced by R_RenderScene().

◆ R_DrawModelSurfaces()

void R_DrawModelSurfaces	(	entity_render_t *	ent,
		qbool	skysurfaces,
		qbool	writedepth,
		qbool	depthonly,
		qbool	debug,
		qbool	prepass,
		qbool	ui )

Definition at line 9970 of file gl_rmain.c.

{
    int i, j, flagsmask;
    model_t *model = ent->model;
    msurface_t *surfaces;
    unsigned char *update;
    int numsurfacelist = 0;
    if (model == NULL)
        return;
 
    if (r_maxsurfacelist < model->num_surfaces)
    {
        r_maxsurfacelist = model->num_surfaces;
        if (r_surfacelist)
            Mem_Free((msurface_t **)r_surfacelist);
        r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist));
    }
 
    if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
        RSurf_ActiveModelEntity(ent, false, false, false);
    else if (prepass)
        RSurf_ActiveModelEntity(ent, true, true, true);
    else if (depthonly)
        RSurf_ActiveModelEntity(ent, model->wantnormals, model->wanttangents, false);
    else
        RSurf_ActiveModelEntity(ent, true, true, false);
 
    surfaces = model->data_surfaces;
    update = model->brushq1.lightmapupdateflags;
 
    flagsmask = skysurfaces ? MATERIALFLAG_SKY : MATERIALFLAG_WALL;
 
    if (debug)
    {
        R_DrawDebugModel();
        rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveModelEntity
        return;
    }
 
    // check if this is an empty model
    if (model->submodelsurfaces_start >= model->submodelsurfaces_end)
        return;
 
    rsurface.lightmaptexture = NULL;
    rsurface.deluxemaptexture = NULL;
    rsurface.uselightmaptexture = false;
    rsurface.texture = NULL;
    rsurface.rtlight = NULL;
    numsurfacelist = 0;
 
    // add visible surfaces to draw list
    if (ent == r_refdef.scene.worldentity)
    {
        // for the world entity, check surfacevisible
        for (i = model->submodelsurfaces_start;i < model->submodelsurfaces_end;i++)
        {
            j = model->modelsurfaces_sorted[i];
            if (r_refdef.viewcache.world_surfacevisible[j])
                r_surfacelist[numsurfacelist++] = surfaces + j;
        }
 
        // don't do anything if there were no surfaces added (none of the world entity is visible)
        if (!numsurfacelist)
        {
            rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveModelEntity
            return;
        }
    }
    else if (ui)
    {
        // for ui we have to preserve the order of surfaces (not using modelsurfaces_sorted)
        for (i = model->submodelsurfaces_start; i < model->submodelsurfaces_end; i++)
            r_surfacelist[numsurfacelist++] = surfaces + i;
    }
    else
    {
        // add all surfaces
        for (i = model->submodelsurfaces_start; i < model->submodelsurfaces_end; i++)
            r_surfacelist[numsurfacelist++] = surfaces + model->modelsurfaces_sorted[i];
    }
 
    /*
     * Mark lightmaps as dirty if their lightstyle's value changed. We do this by
     * using style chains because most styles do not change on most frames, and most
     * surfaces do not have styles on them. Mods like Arcane Dimensions (e.g. ad_necrokeep)
     * break this rule and animate most surfaces.
     */
    if (update && !skysurfaces && !depthonly && !prepass && model->brushq1.num_lightstyles && r_refdef.scene.lightmapintensity > 0 && r_q1bsp_lightmap_updates_enabled.integer)
    {
        model_brush_lightstyleinfo_t *style;
 
        // For each lightstyle, check if its value changed and mark the lightmaps as dirty if so
        for (i = 0, style = model->brushq1.data_lightstyleinfo; i < model->brushq1.num_lightstyles; i++, style++)
        {
            if (style->value != r_refdef.scene.lightstylevalue[style->style])
            {
                int* list = style->surfacelist;
                style->value = r_refdef.scene.lightstylevalue[style->style];
                // Value changed - mark the surfaces belonging to this style chain as dirty
                for (j = 0; j < style->numsurfaces; j++)
                    update[list[j]] = true;
            }
        }
        // Now check if update flags are set on any surfaces that are visible
        if (r_q1bsp_lightmap_updates_hidden_surfaces.integer)
        {
            /*
             * We can do less frequent texture uploads (approximately 10hz for animated
             * lightstyles) by rebuilding lightmaps on surfaces that are not currently visible.
             * For optimal efficiency, this includes the submodels of the worldmodel, so we
             * use model->num_surfaces, not nummodelsurfaces.
             */
            for (i = 0; i < model->num_surfaces;i++)
                if (update[i])
                    R_BuildLightMap(ent, surfaces + i, r_q1bsp_lightmap_updates_combine.integer);
        }
        else
        {
            for (i = 0; i < numsurfacelist; i++)
                if (update[r_surfacelist[i] - surfaces])
                    R_BuildLightMap(ent, (msurface_t *)r_surfacelist[i], r_q1bsp_lightmap_updates_combine.integer);
        }
    }
 
    R_QueueModelSurfaceList(ent, numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass, ui);
 
    // add to stats if desired
    if (r_speeds.integer && !skysurfaces && !depthonly)
    {
        r_refdef.stats[r_stat_entities_surfaces] += numsurfacelist;
        for (j = 0;j < numsurfacelist;j++)
            r_refdef.stats[r_stat_entities_triangles] += r_surfacelist[j]->num_triangles;
    }
 
    rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveModelEntity
}

References MATERIALFLAG_SKY, MATERIALFLAG_WALL, Mem_Alloc, Mem_Free, entity_render_t::model, model, NULL, R_BuildLightMap(), R_DrawDebugModel(), r_main_mempool, r_maxsurfacelist, r_q1bsp_lightmap_updates_combine, r_q1bsp_lightmap_updates_enabled, r_q1bsp_lightmap_updates_hidden_surfaces, R_QueueModelSurfaceList(), r_refdef, r_showsurfaces, r_speeds, r_stat_entities_surfaces, r_stat_entities_triangles, r_surfacelist, RSurf_ActiveModelEntity(), rsurface, and style.

Referenced by DrawQ_FlushUI(), R_Mod_Draw(), R_Mod_DrawDebug(), R_Mod_DrawDepth(), R_Mod_DrawPrepass(), and R_Mod_DrawSky().

◆ R_DrawParticles()

void R_DrawParticles ( void )

Definition at line 2907 of file cl_particles.c.

{
    int i, a;
    int drawparticles = r_drawparticles.integer;
    float minparticledist_start;
    particle_t *p;
    float gravity, frametime, f, dist, oldorg[3], decaldir[3];
    float drawdist2;
    int hitent;
    trace_t trace;
    qbool update;
    float pt_explode_frame_interval, pt_explode2_frame_interval;
    int color;
 
    frametime = bound(0, cl.time - cl.particles_updatetime, 1);
    cl.particles_updatetime = bound(cl.time - 1, cl.particles_updatetime + frametime, cl.time + 1);
 
    // LadyHavoc: early out conditions
    if (!cl.num_particles)
        return;
 
    // Handling of the colour ramp for pt_explode and pt_explode2
    pt_explode_frame_interval = frametime * 10;
    pt_explode2_frame_interval = frametime * 15;
 
    minparticledist_start = DotProduct(r_refdef.view.origin, r_refdef.view.forward) + r_drawparticles_nearclip_min.value;
    gravity = frametime * cl.movevars_gravity;
    update = frametime > 0;
    drawdist2 = r_drawparticles_drawdistance.value * r_refdef.view.quality;
    drawdist2 = drawdist2*drawdist2;
 
    for (i = 0, p = cl.particles;i < cl.num_particles;i++, p++)
    {
        if (!p->typeindex)
        {
            if (cl.free_particle > i)
                cl.free_particle = i;
            continue;
        }
 
        if (update)
        {
            if (p->delayedspawn > cl.time)
                continue;
 
            p->size += p->sizeincrease * frametime;
            p->alpha -= p->alphafade * frametime;
 
            if (p->alpha <= 0 || p->die <= cl.time)
                goto killparticle;
 
            if (p->orientation != PARTICLE_VBEAM && p->orientation != PARTICLE_HBEAM && frametime > 0)
            {
                if (p->liquidfriction && cl_particles_collisions.integer && (CL_PointSuperContents(p->org) & SUPERCONTENTS_LIQUIDSMASK))
                {
                    if (p->typeindex == pt_blood)
                        p->size += frametime * 8;
                    else
                        p->vel[2] -= p->gravity * gravity;
                    f = 1.0f - min(p->liquidfriction * frametime, 1);
                    VectorScale(p->vel, f, p->vel);
                }
                else
                {
                    p->vel[2] -= p->gravity * gravity;
                    if (p->airfriction)
                    {
                        f = 1.0f - min(p->airfriction * frametime, 1);
                        VectorScale(p->vel, f, p->vel);
                    }
                }
 
                VectorCopy(p->org, oldorg);
                VectorMA(p->org, frametime, p->vel, p->org);
//              if (p->bounce && cl.time >= p->delayedcollisions)
                if (p->bounce && cl_particles_collisions.integer && VectorLength(p->vel))
                {
                    trace = CL_TraceLine(oldorg, p->org, MOVE_NORMAL, NULL, SUPERCONTENTS_SOLID | ((p->typeindex == pt_rain || p->typeindex == pt_snow) ? SUPERCONTENTS_LIQUIDSMASK : 0), 0, 0, collision_extendmovelength.value, true, false, &hitent, false, false);
                    // if the trace started in or hit something of SUPERCONTENTS_NODROP
                    // or if the trace hit something flagged as NOIMPACT
                    // then remove the particle
                    if (trace.hitq3surfaceflags & Q3SURFACEFLAG_NOIMPACT || ((trace.startsupercontents | trace.hitsupercontents) & SUPERCONTENTS_NODROP) || (trace.startsupercontents & SUPERCONTENTS_SOLID))
                        goto killparticle;
                    VectorCopy(trace.endpos, p->org);
                    // react if the particle hit something
                    if (trace.fraction < 1)
                    {
                        VectorCopy(trace.endpos, p->org);
 
                        if (p->staintexnum >= 0)
                        {
                            // blood - splash on solid
                            if (!(trace.hitq3surfaceflags & Q3SURFACEFLAG_NOMARKS))
                            {
                                R_Stain(p->org, 16,
                                    p->staincolor[0], p->staincolor[1], p->staincolor[2], (int)(p->stainalpha * p->stainsize * (1.0f / 160.0f)),
                                    p->staincolor[0], p->staincolor[1], p->staincolor[2], (int)(p->stainalpha * p->stainsize * (1.0f / 160.0f)));
                                if (cl_decals.integer)
                                {
                                    // create a decal for the blood splat
                                    a = 0xFFFFFF ^ (p->staincolor[0]*65536+p->staincolor[1]*256+p->staincolor[2]);
                                    if (cl_decals_newsystem_bloodsmears.integer)
                                    {
                                        VectorCopy(p->vel, decaldir);
                                        VectorNormalize(decaldir);
                                    }
                                    else
                                        VectorCopy(trace.plane.normal, decaldir);
                                    CL_SpawnDecalParticleForSurface(hitent, p->org, decaldir, a, a, p->staintexnum, p->stainsize, p->stainalpha); // staincolor needs to be inverted for decals!
                                }
                            }
                        }
 
                        if (p->typeindex == pt_blood)
                        {
                            // blood - splash on solid
                            if (trace.hitq3surfaceflags & Q3SURFACEFLAG_NOMARKS)
                                goto killparticle;
                            if(p->staintexnum == -1) // staintex < -1 means no stains at all
                            {
                                R_Stain(p->org, 16, 64, 16, 16, (int)(p->alpha * p->size * (1.0f / 80.0f)), 64, 32, 32, (int)(p->alpha * p->size * (1.0f / 80.0f)));
                                if (cl_decals.integer)
                                {
                                    // create a decal for the blood splat
                                    if (cl_decals_newsystem_bloodsmears.integer)
                                    {
                                        VectorCopy(p->vel, decaldir);
                                        VectorNormalize(decaldir);
                                    }
                                    else
                                        VectorCopy(trace.plane.normal, decaldir);
                                    CL_SpawnDecalParticleForSurface(hitent, p->org, decaldir, p->color[0] * 65536 + p->color[1] * 256 + p->color[2], p->color[0] * 65536 + p->color[1] * 256 + p->color[2], tex_blooddecal[rand()&7], p->size * lhrandom(cl_particles_blood_decal_scalemin.value, cl_particles_blood_decal_scalemax.value), cl_particles_blood_decal_alpha.value * 768);
                                }
                            }
                            goto killparticle;
                        }
                        else if (p->bounce < 0)
                        {
                            // bounce -1 means remove on impact
                            goto killparticle;
                        }
                        else
                        {
                            // anything else - bounce off solid
                            dist = DotProduct(p->vel, trace.plane.normal) * -p->bounce;
                            VectorMA(p->vel, dist, trace.plane.normal, p->vel);
                        }
                    }
                }
 
                if (VectorLength2(p->vel) < 0.03)
                {
                    if(p->orientation == PARTICLE_SPARK) // sparks are virtually invisible if very slow, so rather let them go off
                        goto killparticle;
                    VectorClear(p->vel);
                }
            }
 
            if (p->typeindex != pt_static)
            {
                switch (p->typeindex)
                {
                case pt_entityparticle:
                    // particle that removes itself after one rendered frame
                    if (p->time2)
                        goto killparticle;
                    else
                        p->time2 = 1;
                    break;
                case pt_blood:
                    a = CL_PointSuperContents(p->org);
                    if (a & (SUPERCONTENTS_SOLID | SUPERCONTENTS_LAVA | SUPERCONTENTS_NODROP))
                        goto killparticle;
                    break;
                case pt_bubble:
                    a = CL_PointSuperContents(p->org);
                    if (!(a & (SUPERCONTENTS_WATER | SUPERCONTENTS_SLIME)))
                        goto killparticle;
                    break;
                case pt_rain:
                    a = CL_PointSuperContents(p->org);
                    if (a & (SUPERCONTENTS_SOLID | SUPERCONTENTS_LIQUIDSMASK))
                        goto killparticle;
                    break;
                case pt_snow:
                    if (cl.time > p->time2)
                    {
                        // snow flutter
                        p->time2 = cl.time + (rand() & 3) * 0.1;
                        p->vel[0] = p->vel[0] * 0.9f + lhrandom(-32, 32);
                        p->vel[1] = p->vel[0] * 0.9f + lhrandom(-32, 32);
                    }
                    a = CL_PointSuperContents(p->org);
                    if (a & (SUPERCONTENTS_SOLID | SUPERCONTENTS_LIQUIDSMASK))
                        goto killparticle;
                    break;
                case pt_explode:
                    // Progress the particle colour up the ramp
                    p->time2 += pt_explode_frame_interval;
                    if (p->time2 >= 8)
                        p->die = -1;
                    else
                    {
                        color = particlepalette[ramp1[(int)p->time2]];
                        p->color[0] = color >> 16;
                        p->color[1] = color >>  8;
                        p->color[2] = color >>  0;
                    }
                    break;
                case pt_explode2:
                    // Progress the particle colour up the ramp
                    p->time2 += pt_explode2_frame_interval;
                    if (p->time2 >= 8)
                        p->die = -1;
                    else
                    {
                        color = particlepalette[ramp2[(int)p->time2]];
                        p->color[0] = color >> 16;
                        p->color[1] = color >>  8;
                        p->color[2] = color >>  0;
                    }
                    break;
                default:
                    break;
                }
            }
        }
        else if (p->delayedspawn > cl.time)
            continue;
        if (!drawparticles)
            continue;
        // don't render particles too close to the view (they chew fillrate)
        // also don't render particles behind the view (useless)
        // further checks to cull to the frustum would be too slow here
        switch(p->typeindex)
        {
        case pt_beam:
            // beams have no culling
            R_MeshQueue_AddTransparent(TRANSPARENTSORT_DISTANCE, p->sortorigin, R_DrawParticle_TransparentCallback, NULL, i, NULL);
            break;
        default:
            if(cl_particles_visculling.integer)
                if (!r_refdef.viewcache.world_novis)
                    if(r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.PointInLeaf)
                    {
                        mleaf_t *leaf = r_refdef.scene.worldmodel->brush.PointInLeaf(r_refdef.scene.worldmodel, p->org);
                        if(leaf)
                            if(!CHECKPVSBIT(r_refdef.viewcache.world_pvsbits, leaf->clusterindex))
                                continue;
                    }
            // anything else just has to be in front of the viewer and visible at this distance
            if (!r_refdef.view.useperspective || (DotProduct(p->org, r_refdef.view.forward) >= minparticledist_start && VectorDistance2(p->org, r_refdef.view.origin) < drawdist2 * (p->size * p->size)))
                R_MeshQueue_AddTransparent(TRANSPARENTSORT_DISTANCE, p->sortorigin, R_DrawParticle_TransparentCallback, NULL, i, NULL);
            break;
        }
 
        continue;
killparticle:
        p->typeindex = 0;
        if (cl.free_particle > i)
            cl.free_particle = i;
    }
 
    // reduce cl.num_particles if possible
    while (cl.num_particles > 0 && cl.particles[cl.num_particles - 1].typeindex == 0)
        cl.num_particles--;
 
    if (cl.num_particles == cl.max_particles && cl.max_particles < MAX_PARTICLES)
    {
        particle_t *oldparticles = cl.particles;
        cl.max_particles = min(cl.max_particles * 2, MAX_PARTICLES);
        cl.particles = (particle_t *) Mem_Alloc(cls.levelmempool, cl.max_particles * sizeof(particle_t));
        memcpy(cl.particles, oldparticles, cl.num_particles * sizeof(particle_t));
        Mem_Free(oldparticles);
    }
}

References a, particle_t::airfriction, particle_t::alpha, particle_t::alphafade, particle_t::bounce, bound, CHECKPVSBIT, cl, cl_decals, cl_decals_newsystem_bloodsmears, cl_particles_blood_decal_alpha, cl_particles_blood_decal_scalemax, cl_particles_blood_decal_scalemin, cl_particles_collisions, cl_particles_visculling, CL_PointSuperContents, CL_SpawnDecalParticleForSurface(), CL_TraceLine(), cls, mleaf_t::clusterindex, collision_extendmovelength, color, particle_t::color, particle_t::delayedspawn, particle_t::die, DotProduct, trace_t::endpos, f, trace_t::fraction, frametime, particle_t::gravity, trace_t::hitq3surfaceflags, trace_t::hitsupercontents, int(), lhrandom, particle_t::liquidfriction, MAX_PARTICLES, Mem_Alloc, Mem_Free, min, MOVE_NORMAL, plane_t::normal, NULL, particle_t::org, particle_t::orientation, PARTICLE_HBEAM, PARTICLE_SPARK, PARTICLE_VBEAM, particlepalette, trace_t::plane, pt_beam, pt_blood, pt_bubble, pt_entityparticle, pt_explode, pt_explode2, pt_rain, pt_snow, pt_static, Q3SURFACEFLAG_NOIMPACT, Q3SURFACEFLAG_NOMARKS, R_DrawParticle_TransparentCallback(), r_drawparticles, r_drawparticles_drawdistance, r_drawparticles_nearclip_min, R_MeshQueue_AddTransparent(), r_refdef, R_Stain(), ramp1, ramp2, particle_t::size, particle_t::sizeincrease, particle_t::sortorigin, particle_t::stainalpha, particle_t::staincolor, particle_t::stainsize, particle_t::staintexnum, trace_t::startsupercontents, SUPERCONTENTS_LAVA, SUPERCONTENTS_LIQUIDSMASK, SUPERCONTENTS_NODROP, SUPERCONTENTS_SLIME, SUPERCONTENTS_SOLID, SUPERCONTENTS_WATER, tex_blooddecal, particle_t::time2, TRANSPARENTSORT_DISTANCE, particle_t::typeindex, VectorClear, VectorCopy, VectorDistance2, VectorLength, VectorLength2, VectorMA, VectorNormalize, VectorScale, and particle_t::vel.

Referenced by R_RenderScene().

◆ R_DrawPortals()

void R_DrawPortals ( void )

Definition at line 381 of file gl_rsurf.c.

{
    int i, leafnum;
    mportal_t *portal;
    float center[3], f;
    model_t *model = r_refdef.scene.worldmodel;
    if (model == NULL)
        return;
    for (leafnum = 0;leafnum < model->brush.num_leafs;leafnum++)
    {
        if (r_refdef.viewcache.world_leafvisible[leafnum])
        {
            //for (portalnum = 0, portal = model->brush.data_portals;portalnum < model->brush.num_portals;portalnum++, portal++)
            for (portal = model->brush.data_leafs[leafnum].portals;portal;portal = portal->next)
            {
                if (portal->numpoints <= POLYGONELEMENTS_MAXPOINTS)
                if (!R_CullFrustum(portal->mins, portal->maxs))
                {
                    VectorClear(center);
                    for (i = 0;i < portal->numpoints;i++)
                        VectorAdd(center, portal->points[i].position, center);
                    f = ixtable[portal->numpoints];
                    VectorScale(center, f, center);
                    R_MeshQueue_AddTransparent(TRANSPARENTSORT_DISTANCE, center, R_DrawPortal_Callback, (entity_render_t *)portal, leafnum, rsurface.rtlight);
                }
            }
        }
    }
}

References f, ixtable, mportal_t::maxs, mportal_t::mins, model, mportal_t::next, NULL, mportal_t::numpoints, mportal_t::points, POLYGONELEMENTS_MAXPOINTS, mvertex_t::position, R_CullFrustum(), R_DrawPortal_Callback(), R_MeshQueue_AddTransparent(), r_refdef, rsurface, TRANSPARENTSORT_DISTANCE, VectorAdd, VectorClear, and VectorScale.

Referenced by R_RenderScene().

◆ R_Explosion_Init()

void R_Explosion_Init ( void )

Definition at line 131 of file r_explosion.c.

{
#ifdef MAX_EXPLOSIONS
    int i, x, y;
    i = 0;
    for (y = 0;y < EXPLOSIONGRID;y++)
    {
        for (x = 0;x < EXPLOSIONGRID;x++)
        {
            explosiontris[i][0] = R_ExplosionVert(x    , y    );
            explosiontris[i][1] = R_ExplosionVert(x + 1, y    );
            explosiontris[i][2] = R_ExplosionVert(x    , y + 1);
            i++;
            explosiontris[i][0] = R_ExplosionVert(x + 1, y    );
            explosiontris[i][1] = R_ExplosionVert(x + 1, y + 1);
            explosiontris[i][2] = R_ExplosionVert(x    , y + 1);
            i++;
        }
    }
 
#endif
    Cvar_RegisterVariable(&r_explosionclip);
#ifdef MAX_EXPLOSIONS
    Cvar_RegisterVariable(&r_drawexplosions);
 
    R_RegisterModule("R_Explosions", r_explosion_start, r_explosion_shutdown, r_explosion_newmap, NULL, NULL);
#endif
}

References Cvar_RegisterVariable(), EXPLOSIONGRID, explosiontris, NULL, r_drawexplosions, r_explosion_newmap(), r_explosion_shutdown(), r_explosion_start(), r_explosionclip, R_ExplosionVert(), R_RegisterModule(), x, and y.

Referenced by Render_Init().

◆ R_FillColors()

void R_FillColors	(	float *	out,
		int	verts,
		float	r,
		float	g,
		float	b,
		float	a )

Definition at line 335 of file gl_rmain.c.

{
    int i;
    for (i = 0;i < verts;i++)
    {
        out[0] = r;
        out[1] = g;
        out[2] = b;
        out[3] = a;
        out += 4;
    }
}

References a, b, g, and r.

Referenced by R_DrawBBoxMesh().

◆ R_FrameData_Alloc()

void * R_FrameData_Alloc ( size_t size )

allocate some temporary memory for your purposes

Definition at line 3539 of file gl_rmain.c.

{
    void *data;
    float newvalue;
 
    // align to 16 byte boundary - the data pointer is already aligned, so we
    // only need to ensure the size of every allocation is also aligned
    size = (size + 15) & ~15;
 
    while (!r_framedata_mem || r_framedata_mem->current + size > r_framedata_mem->size)
    {
        // emergency - we ran out of space, allocate more memory
        // note: this has no upper-bound, we'll fail to allocate memory eventually and just die
        newvalue = r_framedatasize.value * 2.0f;
        // upper bound based on architecture - if we try to allocate more than this we could overflow, better to loop until we error out on allocation failure
        if (sizeof(size_t) >= 8)
            newvalue = bound(0.25f, newvalue, (float)(1ll << 42));
        else
            newvalue = bound(0.25f, newvalue, (float)(1 << 10));
        // this might not be a growing it, but we'll allocate another buffer every time
        Cvar_SetValueQuick(&r_framedatasize, newvalue);
        R_FrameData_Resize(true);
    }
 
    data = r_framedata_mem->data + r_framedata_mem->current;
    r_framedata_mem->current += size;
 
    // count the usage for stats
    r_refdef.stats[r_stat_framedatacurrent] = max(r_refdef.stats[r_stat_framedatacurrent], (int)r_framedata_mem->current);
    r_refdef.stats[r_stat_framedatasize] = max(r_refdef.stats[r_stat_framedatasize], (int)r_framedata_mem->size);
 
    return (void *)data;
}

References bound, Cvar_SetValueQuick(), data, max, r_framedata_mem, R_FrameData_Resize(), r_framedatasize, r_refdef, r_stat_framedatacurrent, r_stat_framedatasize, and size.

Referenced by R_AnimCache_GetEntity(), R_FrameData_Store(), R_Q1BSP_CallRecursiveGetLightInfo(), RSurf_ActiveCustomEntity(), RSurf_ActiveModelEntity(), and RSurf_PrepareVerticesForBatch().

◆ R_FrameData_NewFrame()

void R_FrameData_NewFrame ( void )

prepare for a new frame, recycles old buffers if a resize occurred previously

Definition at line 3521 of file gl_rmain.c.

{
    R_FrameData_Resize(false);
    if (!r_framedata_mem)
        return;
    // if we ran out of space on the last frame, free the old memory now
    while (r_framedata_mem->purge)
    {
        // repeatedly remove the second item in the list, leaving only head
        r_framedata_mem_t *next = r_framedata_mem->purge->purge;
        Mem_Free(r_framedata_mem->purge);
        r_framedata_mem->purge = next;
    }
    // reset the current mem pointer
    r_framedata_mem->current = 0;
    r_framedata_mem->mark = 0;
}

References Mem_Free, r_framedata_mem, and R_FrameData_Resize().

Referenced by CL_UpdateScreen().

◆ R_FrameData_Reset()

void R_FrameData_Reset ( void )

free all R_FrameData memory

Definition at line 3493 of file gl_rmain.c.

{
    while (r_framedata_mem)
    {
        r_framedata_mem_t *next = r_framedata_mem->purge;
        Mem_Free(r_framedata_mem);
        r_framedata_mem = next;
    }
}

References Mem_Free, and r_framedata_mem.

Referenced by gl_main_newmap(), gl_main_shutdown(), and gl_main_start().

◆ R_FrameData_ReturnToMark()

void R_FrameData_ReturnToMark ( void )

discard recent memory allocations (rewind to marker)

Definition at line 3588 of file gl_rmain.c.

{
    if (!r_framedata_mem)
        return;
    r_framedata_mem->current = r_framedata_mem->mark;
}

References r_framedata_mem.

Referenced by R_Mod_DrawLight(), R_Mod_DrawShadowMap(), R_Q1BSP_DrawLight_TransparentCallback(), R_QueueModelSurfaceList(), and R_RTLight_Compile().

◆ R_FrameData_SetMark()

void R_FrameData_SetMark ( void )

set a marker that allows you to discard the following temporary memory allocations

Definition at line 3581 of file gl_rmain.c.

{
    if (!r_framedata_mem)
        return;
    r_framedata_mem->mark = r_framedata_mem->current;
}

References r_framedata_mem.

Referenced by R_Mod_DrawLight(), R_Mod_DrawShadowMap(), R_Q1BSP_DrawLight_TransparentCallback(), R_QueueModelSurfaceList(), and R_RTLight_Compile().

◆ R_FrameData_Store()

void * R_FrameData_Store	(	size_t	size,
		void *	data )

allocate some temporary memory and copy this data into it

Definition at line 3573 of file gl_rmain.c.

{
    void *d = R_FrameData_Alloc(size);
    if (d && data)
        memcpy(d, data, size);
    return d;
}

References data, R_FrameData_Alloc(), and size.

Referenced by R_Shadow_PrepareLight(), and RSurf_PrepareVerticesForBatch().

◆ R_GetCubemap()

rtexture_t * R_GetCubemap ( const char * basename )

Definition at line 2982 of file gl_rmain.c.

{
    int i;
    for (i = 0;i < r_texture_numcubemaps;i++)
        if (r_texture_cubemaps[i] != NULL)
            if (!strcasecmp(r_texture_cubemaps[i]->basename, basename))
                return r_texture_cubemaps[i]->texture ? r_texture_cubemaps[i]->texture : r_texture_whitecube;
    if (i >= MAX_CUBEMAPS || !r_main_mempool)
        return r_texture_whitecube;
    r_texture_numcubemaps++;
    r_texture_cubemaps[i] = (cubemapinfo_t *)Mem_Alloc(r_main_mempool, sizeof(cubemapinfo_t));
    dp_strlcpy(r_texture_cubemaps[i]->basename, basename, sizeof(r_texture_cubemaps[i]->basename));
    r_texture_cubemaps[i]->texture = R_LoadCubemap(r_texture_cubemaps[i]->basename);
    return r_texture_cubemaps[i]->texture;
}

References dp_strlcpy, MAX_CUBEMAPS, Mem_Alloc, NULL, R_LoadCubemap(), r_main_mempool, r_texture_cubemaps, r_texture_numcubemaps, and r_texture_whitecube.

Referenced by Mod_LoadTextureFromQ3Shader(), R_Shadow_PrepareLight(), and VM_CL_loadcubemap().

◆ R_GetCurrentTexture()

texture_t * R_GetCurrentTexture ( texture_t * t )

Definition at line 6549 of file gl_rmain.c.

{
    int i, q;
    const entity_render_t *ent = rsurface.entity;
    model_t *model = ent->model; // when calling this, ent must not be NULL
    q3shaderinfo_layer_tcmod_t *tcmod;
    float specularscale = 0.0f;
 
    if (t->update_lastrenderframe == r_textureframe && t->update_lastrenderentity == (void *)ent && !rsurface.forcecurrenttextureupdate)
        return t->currentframe;
    t->update_lastrenderframe = r_textureframe;
    t->update_lastrenderentity = (void *)ent;
 
    if(ent->entitynumber >= MAX_EDICTS && ent->entitynumber < 2 * MAX_EDICTS)
        t->camera_entity = ent->entitynumber;
    else
        t->camera_entity = 0;
 
    // switch to an alternate material if this is a q1bsp animated material
    {
        texture_t *texture = t;
        int s = rsurface.ent_skinnum;
        if ((unsigned int)s >= (unsigned int)model->numskins)
            s = 0;
        if (model->skinscenes)
        {
            if (model->skinscenes[s].framecount > 1)
                s = model->skinscenes[s].firstframe + (unsigned int) (rsurface.shadertime * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
            else
                s = model->skinscenes[s].firstframe;
        }
        if (s > 0)
            t = t + s * model->num_surfaces;
        if (t->animated)
        {
            // use an alternate animation if the entity's frame is not 0,
            // and only if the texture has an alternate animation
            if (t->animated == 2) // q2bsp
                t = t->anim_frames[0][ent->framegroupblend[0].frame % t->anim_total[0]];
            else if (rsurface.ent_alttextures && t->anim_total[1])
                t = t->anim_frames[1][(t->anim_total[1] >= 2) ? ((int)(rsurface.shadertime * 5.0f) % t->anim_total[1]) : 0];
            else
                t = t->anim_frames[0][(t->anim_total[0] >= 2) ? ((int)(rsurface.shadertime * 5.0f) % t->anim_total[0]) : 0];
        }
        texture->currentframe = t;
    }
 
    // update currentskinframe to be a qw skin or animation frame
    if (rsurface.ent_qwskin >= 0)
    {
        i = rsurface.ent_qwskin;
        if (!r_qwskincache || r_qwskincache_size != cl.maxclients)
        {
            r_qwskincache_size = cl.maxclients;
            if (r_qwskincache)
                Mem_Free(r_qwskincache);
            r_qwskincache = (r_qwskincache_t *)Mem_Alloc(r_main_mempool, sizeof(*r_qwskincache) * r_qwskincache_size);
        }
        if (strcmp(r_qwskincache[i].name, cl.scores[i].qw_skin))
            R_LoadQWSkin(&r_qwskincache[i], cl.scores[i].qw_skin);
        t->currentskinframe = r_qwskincache[i].skinframe;
        if (t->materialshaderpass && t->currentskinframe == NULL)
            t->currentskinframe = t->materialshaderpass->skinframes[LoopingFrameNumberFromDouble(rsurface.shadertime * t->materialshaderpass->framerate, t->materialshaderpass->numframes)];
    }
    else if (t->materialshaderpass && t->materialshaderpass->numframes >= 2)
        t->currentskinframe = t->materialshaderpass->skinframes[LoopingFrameNumberFromDouble(rsurface.shadertime * t->materialshaderpass->framerate, t->materialshaderpass->numframes)];
    if (t->backgroundshaderpass && t->backgroundshaderpass->numframes >= 2)
        t->backgroundcurrentskinframe = t->backgroundshaderpass->skinframes[LoopingFrameNumberFromDouble(rsurface.shadertime * t->backgroundshaderpass->framerate, t->backgroundshaderpass->numframes)];
 
    t->currentmaterialflags = t->basematerialflags;
    t->currentalpha = rsurface.entity->alpha * t->basealpha;
    if (t->basematerialflags & MATERIALFLAG_WATERALPHA && (model->brush.supportwateralpha || r_water.integer || r_novis.integer || r_trippy.integer))
        t->currentalpha *= r_wateralpha.value;
    if(t->basematerialflags & MATERIALFLAG_WATERSHADER && r_fb.water.enabled && !r_refdef.view.isoverlay)
        t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW; // we apply wateralpha later
    if(!r_fb.water.enabled || r_refdef.view.isoverlay)
        t->currentmaterialflags &= ~(MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA);
 
    // decide on which type of lighting to use for this surface
    if (rsurface.entity->render_modellight_forced)
        t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT;
    if (rsurface.entity->render_rtlight_disabled)
        t->currentmaterialflags |= MATERIALFLAG_NORTLIGHT;
    if (rsurface.entity->render_lightgrid)
        t->currentmaterialflags |= MATERIALFLAG_LIGHTGRID;
    if (t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND && !(R_BlendFuncFlags(t->customblendfunc[0], t->customblendfunc[1]) & BLENDFUNC_ALLOWS_COLORMOD))
    {
        // some CUSTOMBLEND blendfuncs are too weird, we have to ignore colormod and view colorscale
        t->currentmaterialflags = (t->currentmaterialflags | MATERIALFLAG_MODELLIGHT | MATERIALFLAG_NORTLIGHT) & ~MATERIALFLAG_LIGHTGRID;
        for (q = 0; q < 3; q++)
        {
            t->render_glowmod[q] = rsurface.entity->glowmod[q];
            t->render_modellight_lightdir_world[q] = q == 2;
            t->render_modellight_lightdir_local[q] = q == 2;
            t->render_modellight_ambient[q] = 1;
            t->render_modellight_diffuse[q] = 0;
            t->render_modellight_specular[q] = 0;
            t->render_lightmap_ambient[q] = 0;
            t->render_lightmap_diffuse[q] = 0;
            t->render_lightmap_specular[q] = 0;
            t->render_rtlight_diffuse[q] = 0;
            t->render_rtlight_specular[q] = 0;
        }
    }
    else if ((t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT) || !(rsurface.ent_flags & RENDER_LIGHT))
    {
        // fullbright is basically MATERIALFLAG_MODELLIGHT but with ambient locked to 1,1,1 and no shading
        t->currentmaterialflags = (t->currentmaterialflags | MATERIALFLAG_NORTLIGHT | MATERIALFLAG_MODELLIGHT) & ~MATERIALFLAG_LIGHTGRID;
        for (q = 0; q < 3; q++)
        {
            t->render_glowmod[q] = rsurface.entity->render_glowmod[q] * r_refdef.view.colorscale;
            t->render_modellight_ambient[q] = rsurface.entity->render_fullbright[q] * r_refdef.view.colorscale;
            t->render_modellight_lightdir_world[q] = q == 2;
            t->render_modellight_lightdir_local[q] = q == 2;
            t->render_modellight_diffuse[q] = 0;
            t->render_modellight_specular[q] = 0;
            t->render_lightmap_ambient[q] = 0;
            t->render_lightmap_diffuse[q] = 0;
            t->render_lightmap_specular[q] = 0;
            t->render_rtlight_diffuse[q] = 0;
            t->render_rtlight_specular[q] = 0;
        }
    }
    else if (t->currentmaterialflags & MATERIALFLAG_LIGHTGRID)
    {
        t->currentmaterialflags &= ~MATERIALFLAG_MODELLIGHT;
        for (q = 0; q < 3; q++)
        {
            t->render_glowmod[q] = rsurface.entity->render_glowmod[q] * r_refdef.view.colorscale;
            t->render_modellight_lightdir_world[q] = q == 2;
            t->render_modellight_lightdir_local[q] = q == 2;
            t->render_modellight_ambient[q] = 0;
            t->render_modellight_diffuse[q] = 0;
            t->render_modellight_specular[q] = 0;
            t->render_lightmap_ambient[q] = rsurface.entity->render_lightmap_ambient[q] * r_refdef.view.colorscale;
            t->render_lightmap_diffuse[q] = rsurface.entity->render_lightmap_diffuse[q] * 2 * r_refdef.view.colorscale;
            t->render_lightmap_specular[q] = rsurface.entity->render_lightmap_specular[q] * 2 * r_refdef.view.colorscale;
            t->render_rtlight_diffuse[q] = rsurface.entity->render_rtlight_diffuse[q] * r_refdef.view.colorscale;
            t->render_rtlight_specular[q] = rsurface.entity->render_rtlight_specular[q] * r_refdef.view.colorscale;
        }
    }
    else if ((rsurface.ent_flags & (RENDER_DYNAMICMODELLIGHT | RENDER_CUSTOMIZEDMODELLIGHT)) || rsurface.modeltexcoordlightmap2f == NULL)
    {
        // ambient + single direction light (modellight)
        t->currentmaterialflags = (t->currentmaterialflags | MATERIALFLAG_MODELLIGHT) & ~MATERIALFLAG_LIGHTGRID;
        for (q = 0; q < 3; q++)
        {
            t->render_glowmod[q] = rsurface.entity->render_glowmod[q] * r_refdef.view.colorscale;
            t->render_modellight_lightdir_world[q] = rsurface.entity->render_modellight_lightdir_world[q];
            t->render_modellight_lightdir_local[q] = rsurface.entity->render_modellight_lightdir_local[q];
            t->render_modellight_ambient[q] = rsurface.entity->render_modellight_ambient[q] * r_refdef.view.colorscale;
            t->render_modellight_diffuse[q] = rsurface.entity->render_modellight_diffuse[q] * r_refdef.view.colorscale;
            t->render_modellight_specular[q] = rsurface.entity->render_modellight_specular[q] * r_refdef.view.colorscale;
            t->render_lightmap_ambient[q] = 0;
            t->render_lightmap_diffuse[q] = 0;
            t->render_lightmap_specular[q] = 0;
            t->render_rtlight_diffuse[q] = rsurface.entity->render_rtlight_diffuse[q] * r_refdef.view.colorscale;
            t->render_rtlight_specular[q] = rsurface.entity->render_rtlight_specular[q] * r_refdef.view.colorscale;
        }
    }
    else
    {
        // lightmap - 2x diffuse and specular brightness because bsp files have 0-2 colors as 0-1
        for (q = 0; q < 3; q++)
        {
            t->render_glowmod[q] = rsurface.entity->render_glowmod[q] * r_refdef.view.colorscale;
            t->render_modellight_lightdir_world[q] = q == 2;
            t->render_modellight_lightdir_local[q] = q == 2;
            t->render_modellight_ambient[q] = 0;
            t->render_modellight_diffuse[q] = 0;
            t->render_modellight_specular[q] = 0;
            t->render_lightmap_ambient[q] = rsurface.entity->render_lightmap_ambient[q] * r_refdef.view.colorscale;
            t->render_lightmap_diffuse[q] = rsurface.entity->render_lightmap_diffuse[q] * 2 * r_refdef.view.colorscale;
            t->render_lightmap_specular[q] = rsurface.entity->render_lightmap_specular[q] * 2 * r_refdef.view.colorscale;
            t->render_rtlight_diffuse[q] = rsurface.entity->render_rtlight_diffuse[q] * r_refdef.view.colorscale;
            t->render_rtlight_specular[q] = rsurface.entity->render_rtlight_specular[q] * r_refdef.view.colorscale;
        }
    }
 
    if (t->currentmaterialflags & MATERIALFLAG_VERTEXCOLOR)
    {
        // since MATERIALFLAG_VERTEXCOLOR uses the lightmapcolor4f vertex
        // attribute, we punt it to the lightmap path and hope for the best,
        // but lighting doesn't work.
        //
        // FIXME: this is fine for effects but CSQC polygons should be subject
        // to lighting.
        t->currentmaterialflags &= ~(MATERIALFLAG_MODELLIGHT | MATERIALFLAG_LIGHTGRID);
        for (q = 0; q < 3; q++)
        {
            t->render_glowmod[q] = rsurface.entity->render_glowmod[q] * r_refdef.view.colorscale;
            t->render_modellight_lightdir_world[q] = q == 2;
            t->render_modellight_lightdir_local[q] = q == 2;
            t->render_modellight_ambient[q] = 0;
            t->render_modellight_diffuse[q] = 0;
            t->render_modellight_specular[q] = 0;
            t->render_lightmap_ambient[q] = 0;
            t->render_lightmap_diffuse[q] = rsurface.entity->render_fullbright[q] * r_refdef.view.colorscale;
            t->render_lightmap_specular[q] = 0;
            t->render_rtlight_diffuse[q] = 0;
            t->render_rtlight_specular[q] = 0;
        }
    }
 
    for (q = 0; q < 3; q++)
    {
        t->render_colormap_pants[q] = rsurface.entity->colormap_pantscolor[q];
        t->render_colormap_shirt[q] = rsurface.entity->colormap_shirtcolor[q];
    }
 
    if (rsurface.ent_flags & RENDER_ADDITIVE)
        t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
    else if (t->currentalpha < 1)
        t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
    // LadyHavoc: prevent bugs where code checks add or alpha at higher priority than customblend by clearing these flags
    if (t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
        t->currentmaterialflags &= ~(MATERIALFLAG_ADD | MATERIALFLAG_ALPHA);
    if (rsurface.ent_flags & RENDER_DOUBLESIDED)
        t->currentmaterialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_NOCULLFACE;
    if (rsurface.ent_flags & (RENDER_NODEPTHTEST | RENDER_VIEWMODEL))
        t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
    if (t->backgroundshaderpass)
        t->currentmaterialflags |= MATERIALFLAG_VERTEXTEXTUREBLEND;
    if (t->currentmaterialflags & MATERIALFLAG_BLENDED)
    {
        if (t->currentmaterialflags & (MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER | MATERIALFLAG_CAMERA))
            t->currentmaterialflags &= ~MATERIALFLAG_BLENDED;
    }
    else
        t->currentmaterialflags &= ~(MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER | MATERIALFLAG_CAMERA);
    if (vid.allowalphatocoverage && r_transparent_alphatocoverage.integer >= 2 && ((t->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHA | MATERIALFLAG_ADD | MATERIALFLAG_CUSTOMBLEND)) == (MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHA)))
    {
        // promote alphablend to alphatocoverage (a type of alphatest) if antialiasing is on
        t->currentmaterialflags = (t->currentmaterialflags & ~(MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHA)) | MATERIALFLAG_ALPHATEST;
    }
    if ((t->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST)) == MATERIALFLAG_BLENDED && r_transparentdepthmasking.integer && !(t->basematerialflags & MATERIALFLAG_BLENDED))
        t->currentmaterialflags |= MATERIALFLAG_TRANSDEPTH;
 
    // there is no tcmod
    if (t->currentmaterialflags & MATERIALFLAG_WATERSCROLL)
    {
        t->currenttexmatrix = r_waterscrollmatrix;
        t->currentbackgroundtexmatrix = r_waterscrollmatrix;
    }
    else if (!(t->currentmaterialflags & MATERIALFLAG_CUSTOMSURFACE))
    {
        Matrix4x4_CreateIdentity(&t->currenttexmatrix);
        Matrix4x4_CreateIdentity(&t->currentbackgroundtexmatrix);
    }
 
    if (t->materialshaderpass)
        for (i = 0, tcmod = t->materialshaderpass->tcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
            R_tcMod_ApplyToMatrix(&t->currenttexmatrix, tcmod, t->currentmaterialflags);
 
    t->colormapping = VectorLength2(t->render_colormap_pants) + VectorLength2(t->render_colormap_shirt) >= (1.0f / 1048576.0f);
    if (t->currentskinframe->qpixels)
        R_SkinFrame_GenerateTexturesFromQPixels(t->currentskinframe, t->colormapping);
    t->basetexture = (!t->colormapping && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
    if (!t->basetexture)
        t->basetexture = r_texture_notexture;
    t->pantstexture = t->colormapping ? t->currentskinframe->pants : NULL;
    t->shirttexture = t->colormapping ? t->currentskinframe->shirt : NULL;
    t->nmaptexture = t->currentskinframe->nmap;
    if (!t->nmaptexture)
        t->nmaptexture = r_texture_blanknormalmap;
    t->glosstexture = r_texture_black;
    t->glowtexture = t->currentskinframe->glow;
    t->fogtexture = t->currentskinframe->fog;
    t->reflectmasktexture = t->currentskinframe->reflect;
    if (t->backgroundshaderpass)
    {
        for (i = 0, tcmod = t->backgroundshaderpass->tcmods; i < Q3MAXTCMODS && tcmod->tcmod; i++, tcmod++)
            R_tcMod_ApplyToMatrix(&t->currentbackgroundtexmatrix, tcmod, t->currentmaterialflags);
        t->backgroundbasetexture = (!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base;
        t->backgroundnmaptexture = t->backgroundcurrentskinframe->nmap;
        t->backgroundglosstexture = r_texture_black;
        t->backgroundglowtexture = t->backgroundcurrentskinframe->glow;
        if (!t->backgroundnmaptexture)
            t->backgroundnmaptexture = r_texture_blanknormalmap;
        // make sure that if glow is going to be used, both textures are not NULL
        if (!t->backgroundglowtexture && t->glowtexture)
            t->backgroundglowtexture = r_texture_black;
        if (!t->glowtexture && t->backgroundglowtexture)
            t->glowtexture = r_texture_black;
    }
    else
    {
        t->backgroundbasetexture = r_texture_white;
        t->backgroundnmaptexture = r_texture_blanknormalmap;
        t->backgroundglosstexture = r_texture_black;
        t->backgroundglowtexture = NULL;
    }
    t->specularpower = r_shadow_glossexponent.value;
    // TODO: store reference values for these in the texture?
    if (r_shadow_gloss.integer > 0)
    {
        if (t->currentskinframe->gloss || (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss))
        {
            if (r_shadow_glossintensity.value > 0)
            {
                t->glosstexture = t->currentskinframe->gloss ? t->currentskinframe->gloss : r_texture_white;
                t->backgroundglosstexture = (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss) ? t->backgroundcurrentskinframe->gloss : r_texture_white;
                specularscale = r_shadow_glossintensity.value;
            }
        }
        else if (r_shadow_gloss.integer >= 2 && r_shadow_gloss2intensity.value > 0)
        {
            t->glosstexture = r_texture_white;
            t->backgroundglosstexture = r_texture_white;
            specularscale = r_shadow_gloss2intensity.value;
            t->specularpower = r_shadow_gloss2exponent.value;
        }
    }
    specularscale *= t->specularscalemod;
    t->specularpower *= t->specularpowermod;
 
    // lightmaps mode looks bad with dlights using actual texturing, so turn
    // off the colormap and glossmap, but leave the normalmap on as it still
    // accurately represents the shading involved
    if (gl_lightmaps.integer && ent != &cl_meshentities[MESH_UI].render)
    {
        t->basetexture = r_texture_grey128;
        t->pantstexture = r_texture_black;
        t->shirttexture = r_texture_black;
        if (gl_lightmaps.integer < 2)
            t->nmaptexture = r_texture_blanknormalmap;
        t->glosstexture = r_texture_black;
        t->glowtexture = NULL;
        t->fogtexture = NULL;
        t->reflectmasktexture = NULL;
        t->backgroundbasetexture = NULL;
        if (gl_lightmaps.integer < 2)
            t->backgroundnmaptexture = r_texture_blanknormalmap;
        t->backgroundglosstexture = r_texture_black;
        t->backgroundglowtexture = NULL;
        specularscale = 0;
        t->currentmaterialflags = MATERIALFLAG_WALL | (t->currentmaterialflags & (MATERIALFLAG_NOCULLFACE | MATERIALFLAG_MODELLIGHT | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SHORTDEPTHRANGE));
    }
 
    if (specularscale != 1.0f)
    {
        for (q = 0; q < 3; q++)
        {
            t->render_modellight_specular[q] *= specularscale;
            t->render_lightmap_specular[q] *= specularscale;
            t->render_rtlight_specular[q] *= specularscale;
        }
    }
 
    t->currentblendfunc[0] = GL_ONE;
    t->currentblendfunc[1] = GL_ZERO;
    if (t->currentmaterialflags & MATERIALFLAG_ADD)
    {
        t->currentblendfunc[0] = GL_SRC_ALPHA;
        t->currentblendfunc[1] = GL_ONE;
    }
    else if (t->currentmaterialflags & MATERIALFLAG_ALPHA)
    {
        t->currentblendfunc[0] = GL_SRC_ALPHA;
        t->currentblendfunc[1] = GL_ONE_MINUS_SRC_ALPHA;
    }
    else if (t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
    {
        t->currentblendfunc[0] = t->customblendfunc[0];
        t->currentblendfunc[1] = t->customblendfunc[1];
    }
 
    return t;
}

Referenced by R_DrawCustomSurface_Texture(), R_DrawDebugModel(), R_DrawSurface_TransparentCallback(), R_Mod_DrawLight(), R_Mod_DrawShadowMap(), R_Model_Sprite_Draw_TransparentCallback(), R_Q1BSP_DrawLight_TransparentCallback(), R_Q1BSP_RecursiveGetLightInfo_BIH(), R_Q1BSP_RecursiveGetLightInfo_BSP(), R_QueueModelSurfaceList(), and R_Water_AddWaterPlane().

◆ R_GetScenePointer()

r_refdef_scene_t * R_GetScenePointer ( r_refdef_scene_type_t scenetype )

Definition at line 5588 of file gl_rmain.c.

{
    // of course, we could also add a qbool that provides a lock state and a ReleaseScenePointer function..
    if( scenetype == r_currentscenetype ) {
        return &r_refdef.scene;
    } else {
        return &r_scenes_store[ scenetype ];
    }
}

References r_currentscenetype, r_refdef, and r_scenes_store.

Referenced by MVM_init_cmd().

◆ R_GLSL_Restart_f()

void R_GLSL_Restart_f ( cmd_state_t * cmd )

Definition at line 1394 of file gl_rmain.c.

{
    unsigned int i, limit;
    switch(vid.renderpath)
    {
    case RENDERPATH_GL32:
    case RENDERPATH_GLES2:
        {
            r_glsl_permutation_t *p;
            r_glsl_permutation = NULL;
            limit = (unsigned int)Mem_ExpandableArray_IndexRange(&r_glsl_permutationarray);
            for (i = 0;i < limit;i++)
            {
                if ((p = (r_glsl_permutation_t*)Mem_ExpandableArray_RecordAtIndex(&r_glsl_permutationarray, i)))
                {
                    GL_Backend_FreeProgram(p->program);
                    Mem_ExpandableArray_FreeRecord(&r_glsl_permutationarray, (void*)p);
                }
            }
            memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash));
        }
        break;
    }
}

References cmd(), GL_Backend_FreeProgram(), int(), Mem_ExpandableArray_FreeRecord(), Mem_ExpandableArray_IndexRange(), Mem_ExpandableArray_RecordAtIndex(), NULL, r_glsl_permutation_t::program, r_glsl_permutation, r_glsl_permutationarray, r_glsl_permutationhash, RENDERPATH_GL32, RENDERPATH_GLES2, and vid.

Referenced by GL_Main_Init(), gl_main_shutdown(), R_RenderView(), and R_Shadow_SetShadowMode().

◆ R_HDR_UpdateIrisAdaptation()

void R_HDR_UpdateIrisAdaptation ( const vec3_t point )

Definition at line 4144 of file gl_rmain.c.

{
    if (r_hdr_irisadaptation.integer)
    {
        vec3_t p;
        vec3_t ambient;
        vec3_t diffuse;
        vec3_t diffusenormal;
        vec3_t forward;
        vec_t brightness = 0.0f;
        vec_t goal;
        vec_t current;
        vec_t d;
        int c;
        VectorCopy(r_refdef.view.forward, forward);
        for (c = 0;c < (int)(sizeof(irisvecs)/sizeof(irisvecs[0]));c++)
        {
            p[0] = point[0] + irisvecs[c][0] * r_hdr_irisadaptation_radius.value;
            p[1] = point[1] + irisvecs[c][1] * r_hdr_irisadaptation_radius.value;
            p[2] = point[2] + irisvecs[c][2] * r_hdr_irisadaptation_radius.value;
            R_CompleteLightPoint(ambient, diffuse, diffusenormal, p, LP_LIGHTMAP | LP_RTWORLD | LP_DYNLIGHT, r_refdef.scene.lightmapintensity, r_refdef.scene.ambientintensity);
            d = DotProduct(forward, diffusenormal);
            brightness += VectorLength(ambient);
            if (d > 0)
                brightness += d * VectorLength(diffuse);
        }
        brightness *= 1.0f / c;
        brightness += 0.00001f; // make sure it's never zero
        goal = r_hdr_irisadaptation_multiplier.value / brightness;
        goal = bound(r_hdr_irisadaptation_minvalue.value, goal, r_hdr_irisadaptation_maxvalue.value);
        current = r_hdr_irisadaptation_value.value;
        if (current < goal)
            current = min(current + r_hdr_irisadaptation_fade_up.value * cl.realframetime, goal);
        else if (current > goal)
            current = max(current - r_hdr_irisadaptation_fade_down.value * cl.realframetime, goal);
        if (fabs(r_hdr_irisadaptation_value.value - current) > 0.0001f)
            Cvar_SetValueQuick(&r_hdr_irisadaptation_value, current);
    }
    else if (r_hdr_irisadaptation_value.value != 1.0f)
        Cvar_SetValueQuick(&r_hdr_irisadaptation_value, 1.0f);
}

References bound, cl, Cvar_SetValueQuick(), DotProduct, fabs(), forward, int(), irisvecs, LP_DYNLIGHT, LP_LIGHTMAP, LP_RTWORLD, max, min, R_CompleteLightPoint(), r_hdr_irisadaptation, r_hdr_irisadaptation_fade_down, r_hdr_irisadaptation_fade_up, r_hdr_irisadaptation_maxvalue, r_hdr_irisadaptation_minvalue, r_hdr_irisadaptation_multiplier, r_hdr_irisadaptation_radius, r_hdr_irisadaptation_value, r_refdef, VectorCopy, and VectorLength.

Referenced by CL_UpdateScreen().

◆ R_LightningBeams_Init()

void R_LightningBeams_Init ( void )

Definition at line 96 of file r_lightning.c.

{
    Cvar_RegisterVariable(&r_lightningbeam_thickness);
    Cvar_RegisterVariable(&r_lightningbeam_scroll);
    Cvar_RegisterVariable(&r_lightningbeam_repeatdistance);
    Cvar_RegisterVariable(&r_lightningbeam_color_red);
    Cvar_RegisterVariable(&r_lightningbeam_color_green);
    Cvar_RegisterVariable(&r_lightningbeam_color_blue);
    Cvar_RegisterVariable(&r_lightningbeam_qmbtexture);
    R_RegisterModule("R_LightningBeams", r_lightningbeams_start, r_lightningbeams_shutdown, r_lightningbeams_newmap, NULL, NULL);
}

References Cvar_RegisterVariable(), NULL, r_lightningbeam_color_blue, r_lightningbeam_color_green, r_lightningbeam_color_red, r_lightningbeam_qmbtexture, r_lightningbeam_repeatdistance, r_lightningbeam_scroll, r_lightningbeam_thickness, r_lightningbeams_newmap(), r_lightningbeams_shutdown(), r_lightningbeams_start(), and R_RegisterModule().

Referenced by Render_Init().

◆ R_Mesh_AddBrushMeshFromPlanes()

void R_Mesh_AddBrushMeshFromPlanes	(	rmesh_t *	mesh,
		int	numplanes,
		mplane_t *	planes )

Definition at line 6364 of file gl_rmain.c.

{
    int planenum, planenum2;
    int w;
    int tempnumpoints;
    mplane_t *plane, *plane2;
    double maxdist;
    double temppoints[2][256*3];
    // figure out how large a bounding box we need to properly compute this brush
    maxdist = 0;
    for (w = 0;w < numplanes;w++)
        maxdist = max(maxdist, fabs(planes[w].dist));
    // now make it large enough to enclose the entire brush, and round it off to a reasonable multiple of 1024
    maxdist = floor(maxdist * (4.0 / 1024.0) + 1) * 1024.0;
    for (planenum = 0, plane = planes;planenum < numplanes;planenum++, plane++)
    {
        w = 0;
        tempnumpoints = 4;
        PolygonD_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, maxdist);
        for (planenum2 = 0, plane2 = planes;planenum2 < numplanes && tempnumpoints >= 3;planenum2++, plane2++)
        {
            if (planenum2 == planenum)
                continue;
            PolygonD_Divide(tempnumpoints, temppoints[w], plane2->normal[0], plane2->normal[1], plane2->normal[2], plane2->dist, R_MESH_PLANE_DIST_EPSILON, 0, NULL, NULL, 256, temppoints[!w], &tempnumpoints, NULL);
            w = !w;
        }
        if (tempnumpoints < 3)
            continue;
        // generate elements forming a triangle fan for this polygon
        R_Mesh_AddPolygon3d(mesh, tempnumpoints, temppoints[w]);
    }
}

References mplane_t::dist, fabs(), floor(), max, mplane_t::normal, NULL, PolygonD_Divide(), PolygonD_QuadForPlane(), R_Mesh_AddPolygon3d(), R_MESH_PLANE_DIST_EPSILON, and w.

◆ R_Mesh_AddPolygon3f()

void R_Mesh_AddPolygon3f	(	rmesh_t *	mesh,
		int	numvertices,
		float *	vertex3f )

Definition at line 6321 of file gl_rmain.c.

{
    int i;
    int *e, element[3];
    element[0] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
    element[1] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
    e = mesh->element3i + mesh->numtriangles * 3;
    for (i = 0;i < numvertices - 2;i++, vertex3f += 3)
    {
        element[2] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);
        if (mesh->numtriangles < mesh->maxtriangles)
        {
            *e++ = element[0];
            *e++ = element[1];
            *e++ = element[2];
            mesh->numtriangles++;
        }
        element[1] = element[2];
    }
}

References rmesh_t::element3i, rmesh_t::maxtriangles, rmesh_t::numtriangles, and R_Mesh_AddVertex().

◆ R_Model_Sprite_Draw()

void R_Model_Sprite_Draw ( entity_render_t * ent )

Definition at line 430 of file r_sprites.c.

{
    vec3_t org;
    if (ent->frameblend[0].subframe < 0)
        return;
 
    Matrix4x4_OriginFromMatrix(&ent->matrix, org);
    R_MeshQueue_AddTransparent((ent->flags & RENDER_WORLDOBJECT) ? TRANSPARENTSORT_SKY : (ent->flags & RENDER_NODEPTHTEST) ? TRANSPARENTSORT_HUD : TRANSPARENTSORT_DISTANCE, org, R_Model_Sprite_Draw_TransparentCallback, ent, 0, rsurface.rtlight);
}

References entity_render_t::flags, entity_render_t::frameblend, entity_render_t::matrix, Matrix4x4_OriginFromMatrix(), R_MeshQueue_AddTransparent(), R_Model_Sprite_Draw_TransparentCallback(), RENDER_NODEPTHTEST, RENDER_WORLDOBJECT, rsurface, frameblend_t::subframe, TRANSPARENTSORT_DISTANCE, TRANSPARENTSORT_HUD, and TRANSPARENTSORT_SKY.

Referenced by Mod_IDS2_Load(), and Mod_IDSP_Load().

◆ R_ModulateColors()

void R_ModulateColors	(	float *	in,
		float *	out,
		int	verts,
		float	r,
		float	g,
		float	b )

Definition at line 321 of file gl_rmain.c.

{
    int i;
    for (i = 0;i < verts;i++)
    {
        out[0] = in[0] * r;
        out[1] = in[1] * g;
        out[2] = in[2] * b;
        out[3] = in[3];
        in += 4;
        out += 4;
    }
}

References b, g, and r.

◆ R_NewExplosion()

void R_NewExplosion ( const vec3_t org )

Definition at line 160 of file r_explosion.c.

{
#ifdef MAX_EXPLOSIONS
    int i, j;
    float dist, n;
    explosion_t *e;
    trace_t trace;
    unsigned char noise[EXPLOSIONGRID*EXPLOSIONGRID];
    fractalnoisequick(noise, EXPLOSIONGRID, 4); // adjust noise grid size according to explosion
    for (i = 0, e = explosion;i < MAX_EXPLOSIONS;i++, e++)
    {
        if (!e->alpha)
        {
            numexplosions = max(numexplosions, i + 1);
            e->starttime = cl.time;
            e->endtime = cl.time + cl_explosions_lifetime.value;
            e->time = e->starttime;
            e->alpha = cl_explosions_alpha_start.value;
            e->fade = (cl_explosions_alpha_start.value - cl_explosions_alpha_end.value) / cl_explosions_lifetime.value;
            e->clipping = r_explosionclip.integer != 0;
            VectorCopy(org, e->origin);
            for (j = 0;j < EXPLOSIONVERTS;j++)
            {
                // calculate start origin and velocity
                n = noise[explosionnoiseindex[j]] * (1.0f / 255.0f) + 0.5;
                dist = n * cl_explosions_size_start.value;
                VectorMA(e->origin, dist, explosionpoint[j], e->vert[j]);
                dist = n * (cl_explosions_size_end.value - cl_explosions_size_start.value) / cl_explosions_lifetime.value;
                VectorScale(explosionpoint[j], dist, e->vertvel[j]);
                // clip start origin
                if (e->clipping)
                {
                    trace = CL_TraceLine(e->origin, e->vert[j], MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, 0, 0, collision_extendmovelength.value, true, false, NULL, false, false);
                    VectorCopy(trace.endpos, e->vert[i]);
                }
            }
            break;
        }
    }
#endif
}

References explosion_t::alpha, cl, cl_explosions_alpha_end, cl_explosions_alpha_start, cl_explosions_lifetime, cl_explosions_size_end, cl_explosions_size_start, CL_TraceLine(), explosion_t::clipping, collision_extendmovelength, trace_t::endpos, explosion_t::endtime, explosion, EXPLOSIONGRID, explosionnoiseindex, explosionpoint, EXPLOSIONVERTS, explosion_t::fade, fractalnoisequick(), max, MAX_EXPLOSIONS, MOVE_NOMONSTERS, n, noise, NULL, numexplosions, explosion_t::origin, r_explosionclip, explosion_t::starttime, SUPERCONTENTS_SOLID, explosion_t::time, VectorCopy, VectorMA, VectorScale, explosion_t::vert, and explosion_t::vertvel.

Referenced by CL_ParticleExplosion().

◆ R_Particles_Init()

void R_Particles_Init ( void )

Definition at line 2602 of file cl_particles.c.

{
    int i;
    for (i = 0;i < MESHQUEUE_TRANSPARENT_BATCHSIZE;i++)
    {
        particle_elements[i*6+0] = i*4+0;
        particle_elements[i*6+1] = i*4+1;
        particle_elements[i*6+2] = i*4+2;
        particle_elements[i*6+3] = i*4+0;
        particle_elements[i*6+4] = i*4+2;
        particle_elements[i*6+5] = i*4+3;
    }
 
    Cvar_RegisterVariable(&r_drawparticles);
    Cvar_RegisterVariable(&r_drawparticles_drawdistance);
    Cvar_RegisterVariable(&r_drawparticles_nearclip_min);
    Cvar_RegisterVariable(&r_drawparticles_nearclip_max);
    Cvar_RegisterVariable(&r_drawdecals);
    Cvar_RegisterVariable(&r_drawdecals_drawdistance);
    R_RegisterModule("R_Particles", r_part_start, r_part_shutdown, r_part_newmap, NULL, NULL);
}

References Cvar_RegisterVariable(), MESHQUEUE_TRANSPARENT_BATCHSIZE, NULL, particle_elements, r_drawdecals, r_drawdecals_drawdistance, r_drawparticles, r_drawparticles_drawdistance, r_drawparticles_nearclip_max, r_drawparticles_nearclip_min, r_part_newmap(), r_part_shutdown(), r_part_start(), and R_RegisterModule().

Referenced by Render_Init().

◆ R_RenderScene()

void R_RenderScene	(	int	viewfbo,
		rtexture_t *	viewdepthtexture,
		rtexture_t *	viewcolortexture,
		int	viewx,
		int	viewy,
		int	viewwidth,
		int	viewheight )

Definition at line 5830 of file gl_rmain.c.

{
    qbool shadowmapping = false;
 
    if (r_timereport_active)
        R_TimeReport("beginscene");
 
    r_refdef.stats[r_stat_renders]++;
 
    R_UpdateFog();
 
    R_MeshQueue_BeginScene();
 
    R_SkyStartFrame();
 
    Matrix4x4_CreateTranslate(&r_waterscrollmatrix, sin(r_refdef.scene.time) * 0.025 * r_waterscroll.value, sin(r_refdef.scene.time * 0.8f) * 0.025 * r_waterscroll.value, 0);
 
    if (r_timereport_active)
        R_TimeReport("skystartframe");
 
    if (cl.csqc_vidvars.drawworld)
    {
        if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawSky)
        {
            r_refdef.scene.worldmodel->DrawSky(r_refdef.scene.worldentity);
            if (r_timereport_active)
                R_TimeReport("worldsky");
        }
 
        if (R_DrawBrushModelsSky() && r_timereport_active)
            R_TimeReport("bmodelsky");
 
        if (skyrendermasked && skyrenderlater)
        {
            // we have to force off the water clipping plane while rendering sky
            R_SetupView(false, viewfbo, viewdepthtexture, viewcolortexture, viewx, viewy, viewwidth, viewheight);
            R_Sky();
            R_SetupView(true, viewfbo, viewdepthtexture, viewcolortexture, viewx, viewy, viewwidth, viewheight);
            if (r_timereport_active)
                R_TimeReport("sky");
        }
    }
 
    // save the framebuffer info for R_Shadow_RenderMode_Reset during this view render
    r_shadow_viewfbo = viewfbo;
    r_shadow_viewdepthtexture = viewdepthtexture;
    r_shadow_viewcolortexture = viewcolortexture;
    r_shadow_viewx = viewx;
    r_shadow_viewy = viewy;
    r_shadow_viewwidth = viewwidth;
    r_shadow_viewheight = viewheight;
 
    R_Shadow_PrepareModelShadows();
    R_Shadow_PrepareLights();
    if (r_timereport_active)
        R_TimeReport("preparelights");
 
    // render all the shadowmaps that will be used for this view
    shadowmapping = R_Shadow_ShadowMappingEnabled();
    if (shadowmapping || r_shadow_shadowmapatlas_modelshadows_size)
    {
        R_Shadow_DrawShadowMaps();
        if (r_timereport_active)
            R_TimeReport("shadowmaps");
    }
 
    // render prepass deferred lighting if r_shadow_deferred is on, this produces light buffers that will be sampled in forward pass
    if (r_shadow_usingdeferredprepass)
        R_Shadow_DrawPrepass();
 
    // now we begin the forward pass of the view render
    if (r_depthfirst.integer >= 1 && cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawDepth)
    {
        r_refdef.scene.worldmodel->DrawDepth(r_refdef.scene.worldentity);
        if (r_timereport_active)
            R_TimeReport("worlddepth");
    }
    if (r_depthfirst.integer >= 2)
    {
        R_DrawModelsDepth();
        if (r_timereport_active)
            R_TimeReport("modeldepth");
    }
 
    if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->Draw)
    {
        r_refdef.scene.worldmodel->Draw(r_refdef.scene.worldentity);
        if (r_timereport_active)
            R_TimeReport("world");
    }
 
    R_DrawModels();
    if (r_timereport_active)
        R_TimeReport("models");
 
    if (!r_shadow_usingdeferredprepass)
    {
        R_Shadow_DrawLights();
        if (r_timereport_active)
            R_TimeReport("rtlights");
    }
 
    if (cl.csqc_vidvars.drawworld)
    {
        R_DrawModelDecals();
        if (r_timereport_active)
            R_TimeReport("modeldecals");
 
        R_DrawParticles();
        if (r_timereport_active)
            R_TimeReport("particles");
 
        R_DrawExplosions();
        if (r_timereport_active)
            R_TimeReport("explosions");
    }
 
    if (r_refdef.view.showdebug)
    {
        if (cl_locs_show.integer)
        {
            R_DrawLocs();
            if (r_timereport_active)
                R_TimeReport("showlocs");
        }
 
        if (r_drawportals.integer)
        {
            R_DrawPortals();
            if (r_timereport_active)
                R_TimeReport("portals");
        }
 
        if (r_showbboxes_client.value > 0)
        {
            R_DrawEntityBBoxes(CLVM_prog);
            if (r_timereport_active)
                R_TimeReport("clbboxes");
        }
        if (r_showbboxes.value > 0)
        {
            R_DrawEntityBBoxes(SVVM_prog);
            if (r_timereport_active)
                R_TimeReport("svbboxes");
        }
    }
 
    if (r_transparent.integer)
    {
        R_MeshQueue_RenderTransparent();
        if (r_timereport_active)
            R_TimeReport("drawtrans");
    }
 
    if (r_refdef.view.showdebug && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawDebug && (r_showtris.value > 0 || r_shownormals.value != 0 || r_showcollisionbrushes.value > 0 || r_showoverdraw.value > 0))
    {
        r_refdef.scene.worldmodel->DrawDebug(r_refdef.scene.worldentity);
        if (r_timereport_active)
            R_TimeReport("worlddebug");
        R_DrawModelsDebug();
        if (r_timereport_active)
            R_TimeReport("modeldebug");
    }
 
    if (cl.csqc_vidvars.drawworld)
    {
        R_Shadow_DrawCoronas();
        if (r_timereport_active)
            R_TimeReport("coronas");
    }
}

References cl, cl_locs_show, CLVM_prog, Matrix4x4_CreateTranslate(), r_depthfirst, R_DrawBrushModelsSky(), R_DrawEntityBBoxes(), R_DrawExplosions(), R_DrawLocs(), R_DrawModelDecals(), R_DrawModels(), R_DrawModelsDebug(), R_DrawModelsDepth(), R_DrawParticles(), R_DrawPortals(), r_drawportals, R_MeshQueue_BeginScene(), R_MeshQueue_RenderTransparent(), r_refdef, R_SetupView(), R_Shadow_DrawCoronas(), R_Shadow_DrawLights(), R_Shadow_DrawPrepass(), R_Shadow_DrawShadowMaps(), R_Shadow_PrepareLights(), R_Shadow_PrepareModelShadows(), r_shadow_shadowmapatlas_modelshadows_size, R_Shadow_ShadowMappingEnabled(), r_shadow_usingdeferredprepass, r_shadow_viewcolortexture, r_shadow_viewdepthtexture, r_shadow_viewfbo, r_shadow_viewheight, r_shadow_viewwidth, r_shadow_viewx, r_shadow_viewy, r_showbboxes, r_showbboxes_client, r_showcollisionbrushes, r_shownormals, r_showoverdraw, r_showtris, R_Sky(), R_SkyStartFrame(), r_stat_renders, R_TimeReport(), r_timereport_active, r_transparent, R_UpdateFog(), r_waterscroll, r_waterscrollmatrix, sin(), skyrenderlater, skyrendermasked, and SVVM_prog.

Referenced by R_RenderView(), and R_Water_ProcessPlanes().

◆ R_RenderTarget_FreeUnused()

void R_RenderTarget_FreeUnused ( qbool force )

Definition at line 4523 of file gl_rmain.c.

{
    unsigned int i, j, end;
    end = (unsigned int)Mem_ExpandableArray_IndexRange(&r_fb.rendertargets); // checked
    for (i = 0; i < end; i++)
    {
        r_rendertarget_t *r = (r_rendertarget_t *)Mem_ExpandableArray_RecordAtIndex(&r_fb.rendertargets, i);
        // free resources for rendertargets that have not been used for a while
        // (note: this check is run after the frame render, so any targets used
        // this frame will not be affected even at low framerates)
        if (r && (host.realtime - r->lastusetime > 0.2 || force))
        {
            if (r->fbo)
                R_Mesh_DestroyFramebufferObject(r->fbo);
            for (j = 0; j < sizeof(r->colortexture) / sizeof(r->colortexture[0]); j++)
                if (r->colortexture[j])
                    R_FreeTexture(r->colortexture[j]);
            if (r->depthtexture)
                R_FreeTexture(r->depthtexture);
            Mem_ExpandableArray_FreeRecord(&r_fb.rendertargets, r);
        }
    }
}

References host, int(), Mem_ExpandableArray_FreeRecord(), Mem_ExpandableArray_IndexRange(), Mem_ExpandableArray_RecordAtIndex(), r, r_fb, R_FreeTexture(), and R_Mesh_DestroyFramebufferObject().

Referenced by gl_main_shutdown(), and SCR_DrawScreen().

◆ R_RenderTarget_Get()

r_rendertarget_t * R_RenderTarget_Get	(	int	texturewidth,
		int	textureheight,
		textype_t	depthtextype,
		qbool	depthisrenderbuffer,
		textype_t	colortextype0,
		textype_t	colortextype1,
		textype_t	colortextype2,
		textype_t	colortextype3 )

Definition at line 4564 of file gl_rmain.c.

{
    unsigned int i, j, end;
    r_rendertarget_t *r = NULL;
    char vabuf[256];
    // first try to reuse an existing slot if possible
    end = (unsigned int)Mem_ExpandableArray_IndexRange(&r_fb.rendertargets); // checked
    for (i = 0; i < end; i++)
    {
        r = (r_rendertarget_t *)Mem_ExpandableArray_RecordAtIndex(&r_fb.rendertargets, i);
        if (r && r->lastusetime != host.realtime && r->texturewidth == texturewidth && r->textureheight == textureheight && r->depthtextype == depthtextype && r->colortextype[0] == colortextype0 && r->colortextype[1] == colortextype1 && r->colortextype[2] == colortextype2 && r->colortextype[3] == colortextype3)
            break;
    }
    if (i == end)
    {
        // no unused exact match found, so we have to make one in the first unused slot
        r = (r_rendertarget_t *)Mem_ExpandableArray_AllocRecord(&r_fb.rendertargets);
        r->texturewidth = texturewidth;
        r->textureheight = textureheight;
        r->colortextype[0] = colortextype0;
        r->colortextype[1] = colortextype1;
        r->colortextype[2] = colortextype2;
        r->colortextype[3] = colortextype3;
        r->depthtextype = depthtextype;
        r->depthisrenderbuffer = depthisrenderbuffer;
        for (j = 0; j < 4; j++)
            if (r->colortextype[j])
                r->colortexture[j] = R_LoadTexture2D(r_main_texturepool, va(vabuf, sizeof(vabuf), "rendertarget%i_%i_type%i", i, j, (int)r->colortextype[j]), r->texturewidth, r->textureheight, NULL, r->colortextype[j], TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
        if (r->depthtextype)
        {
            if (r->depthisrenderbuffer)
                r->depthtexture = R_LoadTextureRenderBuffer(r_main_texturepool, va(vabuf, sizeof(vabuf), "renderbuffer%i_depth_type%i", i, (int)r->depthtextype), r->texturewidth, r->textureheight, r->depthtextype);
            else
                r->depthtexture = R_LoadTexture2D(r_main_texturepool, va(vabuf, sizeof(vabuf), "rendertarget%i_depth_type%i", i, (int)r->depthtextype), r->texturewidth, r->textureheight, NULL, r->depthtextype, TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
        }
        r->fbo = R_Mesh_CreateFramebufferObject(r->depthtexture, r->colortexture[0], r->colortexture[1], r->colortexture[2], r->colortexture[3]);
    }
    r_refdef.stats[r_stat_rendertargets_used]++;
    r_refdef.stats[r_stat_rendertargets_pixels] += r->texturewidth * r->textureheight;
    r->lastusetime = host.realtime;
    R_CalcTexCoordsForView(0, 0, r->texturewidth, r->textureheight, r->texturewidth, r->textureheight, r->texcoord2f);
    return r;
}

References host, int(), Mem_ExpandableArray_AllocRecord(), Mem_ExpandableArray_IndexRange(), Mem_ExpandableArray_RecordAtIndex(), NULL, r, R_CalcTexCoordsForView(), r_fb, R_LoadTexture2D(), R_LoadTextureRenderBuffer(), r_main_texturepool, R_Mesh_CreateFramebufferObject(), r_refdef, r_stat_rendertargets_pixels, r_stat_rendertargets_used, TEXF_CLAMP, TEXF_FORCELINEAR, TEXF_RENDERTARGET, and va().

Referenced by R_Bloom_MakeTexture(), R_Bloom_StartFrame(), R_Envmap_f(), and R_Water_ProcessPlanes().

◆ R_RenderView()

void R_RenderView	(	int	fbo,
		rtexture_t *	depthtexture,
		rtexture_t *	colortexture,
		int	x,
		int	y,
		int	width,
		int	height )

Definition at line 5637 of file gl_rmain.c.

{
    matrix4x4_t originalmatrix = r_refdef.view.matrix, offsetmatrix;
    int viewfbo = 0;
    rtexture_t *viewdepthtexture = NULL;
    rtexture_t *viewcolortexture = NULL;
    int viewx = r_refdef.view.x, viewy = r_refdef.view.y, viewwidth = r_refdef.view.width, viewheight = r_refdef.view.height;
    qbool skipblend;
 
    // finish any 2D rendering that was queued
    DrawQ_Finish();
 
    if (r_timereport_active)
        R_TimeReport("start");
    r_textureframe++; // used only by R_GetCurrentTexture
    rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveModelEntity
 
    if(R_CompileShader_CheckStaticParms())
        R_GLSL_Restart_f(cmd_local);
 
    if (!r_drawentities.integer)
        r_refdef.scene.numentities = 0;
    else if (r_sortentities.integer)
        R_SortEntities();
 
    R_AnimCache_ClearCache();
 
    /* adjust for stereo display */
    if(R_Stereo_Active())
    {
        Matrix4x4_CreateFromQuakeEntity(&offsetmatrix, 0, r_stereo_separation.value * (0.5f - r_stereo_side), 0, 0, r_stereo_angle.value * (0.5f - r_stereo_side), 0, 1);
        Matrix4x4_Concat(&r_refdef.view.matrix, &originalmatrix, &offsetmatrix);
    }
 
    if (r_refdef.view.isoverlay)
    {
        // TODO: FIXME: move this into its own backend function maybe? [2/5/2008 Andreas]
        R_Mesh_SetRenderTargets(0);
        GL_Clear(GL_DEPTH_BUFFER_BIT, NULL, 1.0f, 0);
        R_TimeReport("depthclear");
 
        r_refdef.view.showdebug = false;
 
        r_fb.water.enabled = false;
        r_fb.water.numwaterplanes = 0;
 
        R_RenderScene(0, NULL, NULL, r_refdef.view.x, r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
 
        r_refdef.view.matrix = originalmatrix;
 
        CHECKGLERROR
        return;
    }
 
    if (!r_refdef.scene.entities || r_refdef.view.width * r_refdef.view.height == 0 || !r_renderview.integer || cl_videoplaying/* || !r_refdef.scene.worldmodel*/)
    {
        r_refdef.view.matrix = originalmatrix;
        return;
    }
 
    r_refdef.view.usevieworiginculling = !r_trippy.value && r_refdef.view.useperspective;
    if (v_isometric.integer && r_refdef.view.ismain)
        V_MakeViewIsometric();
 
    r_refdef.view.colorscale = r_hdr_scenebrightness.value * r_hdr_irisadaptation_value.value;
 
    if(vid_sRGB.integer && vid_sRGB_fallback.integer && !vid.sRGB3D)
        // in sRGB fallback, behave similar to true sRGB: convert this
        // value from linear to sRGB
        r_refdef.view.colorscale = Image_sRGBFloatFromLinearFloat(r_refdef.view.colorscale);
 
    R_RenderView_UpdateViewVectors();
 
    R_Shadow_UpdateWorldLightSelection();
 
    // this will set up r_fb.rt_screen
    R_Bloom_StartFrame();
 
    // apply bloom brightness offset
    if(r_fb.rt_bloom)
        r_refdef.view.colorscale *= r_bloom_scenebrightness.value;
 
    skipblend = R_BlendView_IsTrivial(r_fb.rt_screen->texturewidth, r_fb.rt_screen->textureheight, width, height);
    if (skipblend)
    {
        // Render to the screen right away.
        viewfbo = fbo;
        viewdepthtexture = depthtexture;
        viewcolortexture = colortexture;
        viewx = x;
        viewy = y;
        viewwidth = width;
        viewheight = height;
    }
    else if (r_fb.rt_screen)
    {
        // R_Bloom_StartFrame probably set up an fbo for us to render into, it will be rendered to the window later in R_BlendView
        viewfbo = r_fb.rt_screen->fbo;
        viewdepthtexture = r_fb.rt_screen->depthtexture;
        viewcolortexture = r_fb.rt_screen->colortexture[0];
        viewx = 0;
        viewy = 0;
        viewwidth = r_fb.rt_screen->texturewidth;
        viewheight = r_fb.rt_screen->textureheight;
    }
 
    R_Water_StartFrame(viewwidth, viewheight);
 
    CHECKGLERROR
    if (r_timereport_active)
        R_TimeReport("viewsetup");
 
    R_ResetViewRendering3D(viewfbo, viewdepthtexture, viewcolortexture, viewx, viewy, viewwidth, viewheight);
 
    // clear the whole fbo every frame - otherwise the driver will consider
    // it to be an inter-frame texture and stall in multi-gpu configurations
    if (r_fb.rt_screen)
        GL_ScissorTest(false);
    R_ClearScreen(r_refdef.fogenabled);
    if (r_timereport_active)
        R_TimeReport("viewclear");
 
    r_refdef.view.clear = true;
 
    r_refdef.view.showdebug = true;
 
    R_View_Update(NULL);
    if (r_timereport_active)
        R_TimeReport("visibility");
 
    R_AnimCache_CacheVisibleEntities();
    if (r_timereport_active)
        R_TimeReport("animcache");
 
    R_Shadow_UpdateBounceGridTexture();
    // R_Shadow_UpdateBounceGridTexture called R_TimeReport a few times internally, so we don't need to do that here.
 
    r_fb.water.numwaterplanes = 0;
    if (r_fb.water.enabled)
        R_RenderWaterPlanes(viewfbo, viewdepthtexture, viewcolortexture, viewx, viewy, viewwidth, viewheight);
 
    // for the actual view render we use scissoring a fair amount, so scissor
    // test needs to be on
    if (r_fb.rt_screen)
        GL_ScissorTest(true);
    GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
    R_RenderScene(viewfbo, viewdepthtexture, viewcolortexture, viewx, viewy, viewwidth, viewheight);
    r_fb.water.numwaterplanes = 0;
 
    // postprocess uses textures that are not aligned with the viewport we're rendering, so no scissoring
    GL_ScissorTest(false);
 
    R_MotionBlurView(viewfbo, viewdepthtexture, viewcolortexture, viewx, viewy, viewwidth, viewheight);
    if (!skipblend)
        R_BlendView(viewcolortexture, fbo, depthtexture, colortexture, x, y, width, height);
    if (r_timereport_active)
        R_TimeReport("blendview");
 
    r_refdef.view.matrix = originalmatrix;
 
    CHECKGLERROR
 
    // go back to 2d rendering
    DrawQ_Start();
}

References CHECKGLERROR, cl_videoplaying, cmd_local, DrawQ_Finish(), DrawQ_Start(), GL_Clear(), GL_DEPTH_BUFFER_BIT, GL_Scissor(), GL_ScissorTest(), height, Image_sRGBFloatFromLinearFloat, Matrix4x4_Concat(), Matrix4x4_CreateFromQuakeEntity(), NULL, R_AnimCache_CacheVisibleEntities(), R_AnimCache_ClearCache(), R_BlendView(), R_BlendView_IsTrivial(), r_bloom_scenebrightness, R_Bloom_StartFrame(), R_ClearScreen(), R_CompileShader_CheckStaticParms(), r_drawentities, r_fb, R_GLSL_Restart_f(), r_hdr_irisadaptation_value, r_hdr_scenebrightness, R_Mesh_SetRenderTargets(), R_MotionBlurView(), r_refdef, R_RenderScene(), r_renderview, R_RenderView_UpdateViewVectors(), R_RenderWaterPlanes(), R_ResetViewRendering3D(), R_Shadow_UpdateBounceGridTexture(), R_Shadow_UpdateWorldLightSelection(), R_SortEntities(), r_sortentities, R_Stereo_Active(), r_stereo_angle, r_stereo_separation, r_stereo_side, r_textureframe, R_TimeReport(), r_timereport_active, r_trippy, R_View_Update(), R_Water_StartFrame(), rsurface, v_isometric, V_MakeViewIsometric(), vid, vid_sRGB, vid_sRGB_fallback, width, x, and y.

Referenced by R_Envmap_f(), SCR_DrawScreen(), and VM_CL_R_RenderScene().

◆ R_RenderView_UpdateViewVectors()

void R_RenderView_UpdateViewVectors ( void )

Definition at line 4512 of file gl_rmain.c.

{
    // break apart the view matrix into vectors for various purposes
    // it is important that this occurs outside the RenderScene function because that can be called from reflection renders, where the vectors come out wrong
    // however the r_refdef.view.origin IS updated in RenderScene intentionally - otherwise the sky renders at the wrong origin, etc
    Matrix4x4_ToVectors(&r_refdef.view.matrix, r_refdef.view.forward, r_refdef.view.left, r_refdef.view.up, r_refdef.view.origin);
    VectorNegate(r_refdef.view.left, r_refdef.view.right);
    // make an inverted copy of the view matrix for tracking sprites
    Matrix4x4_Invert_Full(&r_refdef.view.inverse_matrix, &r_refdef.view.matrix);
}

References Matrix4x4_Invert_Full(), Matrix4x4_ToVectors(), r_refdef, and VectorNegate.

Referenced by CL_VM_UpdateView(), R_RenderView(), and R_Water_ProcessPlanes().

◆ R_RenderWaterPlanes()

void R_RenderWaterPlanes	(	int	viewfbo,
		rtexture_t *	viewdepthtexture,
		rtexture_t *	viewcolortexture,
		int	viewx,
		int	viewy,
		int	viewwidth,
		int	viewheight )

Definition at line 5803 of file gl_rmain.c.

{
    if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawAddWaterPlanes)
    {
        r_refdef.scene.worldmodel->DrawAddWaterPlanes(r_refdef.scene.worldentity);
        if (r_timereport_active)
            R_TimeReport("waterworld");
    }
 
    R_DrawModelsAddWaterPlanes();
    if (r_timereport_active)
        R_TimeReport("watermodels");
 
    if (r_fb.water.numwaterplanes)
    {
        R_Water_ProcessPlanes(viewfbo, viewdepthtexture, viewcolortexture, viewx, viewy, viewwidth, viewheight);
        if (r_timereport_active)
            R_TimeReport("waterscenes");
    }
}

References cl, R_DrawModelsAddWaterPlanes(), r_fb, r_refdef, R_TimeReport(), r_timereport_active, and R_Water_ProcessPlanes().

Referenced by R_RenderView().

◆ R_ResetSkyBox()

void R_ResetSkyBox ( void )

Definition at line 440 of file r_sky.c.

{
    R_UnloadSkyBox();
    memset(skyname,0,MAX_QPATH);
    R_LoadSkyBox();
}

References MAX_QPATH, R_LoadSkyBox(), R_UnloadSkyBox(), and skyname.

Referenced by CL_ClearState().

◆ R_ResetViewRendering2D()

void R_ResetViewRendering2D	(	int	viewfbo,
		rtexture_t *	viewdepthtexture,
		rtexture_t *	viewcolortexture,
		int	viewx,
		int	viewy,
		int	viewwidth,
		int	viewheight )

Definition at line 4477 of file gl_rmain.c.

{
    R_ResetViewRendering2D_Common(viewfbo, viewdepthtexture, viewcolortexture, viewx, viewy, viewwidth, viewheight, 1.0f, 1.0f);
}

References R_ResetViewRendering2D_Common().

Referenced by R_BlendView(), and R_MotionBlurView().

◆ R_ResetViewRendering2D_Common()

void R_ResetViewRendering2D_Common	(	int	viewfbo,
		rtexture_t *	viewdepthtexture,
		rtexture_t *	viewcolortexture,
		int	viewx,
		int	viewy,
		int	viewwidth,
		int	viewheight,
		float	x2,
		float	y2 )

Definition at line 4439 of file gl_rmain.c.

{
    r_viewport_t viewport;
    int viewy_adjusted;
 
    CHECKGLERROR
 
    // GL is weird because it's bottom to top, r_refdef.view.y is top to bottom.
    // Unless the render target is a FBO...
    viewy_adjusted = viewfbo ? viewy : vid.mode.height - viewheight - viewy;
 
    R_Viewport_InitOrtho(&viewport, &identitymatrix, viewx, viewy_adjusted, viewwidth, viewheight, 0, 0, x2, y2, -10, 100, NULL);
    R_Mesh_SetRenderTargets(viewfbo);
    R_SetViewport(&viewport);
    GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
    GL_Color(1, 1, 1, 1);
    GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
    GL_BlendFunc(GL_ONE, GL_ZERO);
    GL_ScissorTest(false);
    GL_DepthMask(false);
    GL_DepthRange(0, 1);
    GL_DepthTest(false);
    GL_DepthFunc(GL_LEQUAL);
    R_EntityMatrix(&identitymatrix);
    R_Mesh_ResetTextureState();
    GL_PolygonOffset(0, 0);
    switch(vid.renderpath)
    {
    case RENDERPATH_GL32:
    case RENDERPATH_GLES2:
        qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
        break;
    }
    GL_CullFace(GL_NONE);
 
    CHECKGLERROR
}

References CHECKGLERROR, GL_BlendFunc(), GL_Color(), GL_ColorMask(), GL_CullFace(), GL_DepthFunc(), GL_DepthMask(), GL_DepthRange(), GL_DepthTest(), GL_LEQUAL, GL_NONE, GL_ONE, GL_POLYGON_OFFSET_FILL, GL_PolygonOffset(), GL_Scissor(), GL_ScissorTest(), GL_ZERO, r_viewport_t::height, identitymatrix, NULL, R_EntityMatrix(), R_Mesh_ResetTextureState(), R_Mesh_SetRenderTargets(), r_refdef, R_SetViewport(), R_Viewport_InitOrtho(), RENDERPATH_GL32, RENDERPATH_GLES2, vid, r_viewport_t::width, r_viewport_t::x, x2, r_viewport_t::y, and y2.

Referenced by DrawQ_Start(), and R_ResetViewRendering2D().

◆ R_ResetViewRendering3D()

void R_ResetViewRendering3D	(	int	viewfbo,
		rtexture_t *	viewdepthtexture,
		rtexture_t *	viewcolortexture,
		int	viewx,
		int	viewy,
		int	viewwidth,
		int	viewheight )

Definition at line 4482 of file gl_rmain.c.

{
    R_SetupView(true, viewfbo, viewdepthtexture, viewcolortexture, viewx, viewy, viewwidth, viewheight);
    GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
    GL_Color(1, 1, 1, 1);
    GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
    GL_BlendFunc(GL_ONE, GL_ZERO);
    GL_ScissorTest(true);
    GL_DepthMask(true);
    GL_DepthRange(0, 1);
    GL_DepthTest(true);
    GL_DepthFunc(GL_LEQUAL);
    R_EntityMatrix(&identitymatrix);
    R_Mesh_ResetTextureState();
    GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
    switch(vid.renderpath)
    {
    case RENDERPATH_GL32:
    case RENDERPATH_GLES2:
        qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
        break;
    }
    GL_CullFace(r_refdef.view.cullface_back);
}

References CHECKGLERROR, GL_BlendFunc(), GL_Color(), GL_ColorMask(), GL_CullFace(), GL_DepthFunc(), GL_DepthMask(), GL_DepthRange(), GL_DepthTest(), GL_LEQUAL, GL_ONE, GL_POLYGON_OFFSET_FILL, GL_PolygonOffset(), GL_Scissor(), GL_ScissorTest(), GL_ZERO, identitymatrix, R_EntityMatrix(), R_Mesh_ResetTextureState(), r_refdef, R_SetupView(), RENDERPATH_GL32, RENDERPATH_GLES2, and vid.

Referenced by R_RenderView(), and R_Water_ProcessPlanes().

◆ R_SelectScene()

void R_SelectScene ( r_refdef_scene_type_t scenetype )

Definition at line 5573 of file gl_rmain.c.

                                                      {
    if( scenetype != r_currentscenetype ) {
        // store the old scenetype
        r_scenes_store[ r_currentscenetype ] = r_refdef.scene;
        r_currentscenetype = scenetype;
        // move in the new scene
        r_refdef.scene = r_scenes_store[ r_currentscenetype ];
    }
}

References r_currentscenetype, r_refdef, and r_scenes_store.

Referenced by MP_Draw(), and MVM_error_cmd().

◆ R_SetSkyBox()

int R_SetSkyBox ( const char * sky )

Definition at line 149 of file r_sky.c.

{
    if (strcmp(sky, skyname) == 0) // no change
        return true;
 
    if (strlen(sky) > 1000)
    {
        Con_Printf("sky name too long (%i, max is 1000)\n", (int)strlen(sky));
        return false;
    }
 
    dp_strlcpy(skyname, sky, sizeof(skyname));
 
    return R_LoadSkyBox();
}

References Con_Printf(), dp_strlcpy, R_LoadSkyBox(), skyname, and strlen().

Referenced by CL_ParseEntityLump(), CL_ParseServerMessage(), and LoadSky_f().

◆ R_SetupShader_DeferredLight()

void R_SetupShader_DeferredLight ( const rtlight_t * rtlight )

Definition at line 2091 of file gl_rmain.c.

{
    // select a permutation of the lighting shader appropriate to this
    // combination of texture, entity, light source, and fogging, only use the
    // minimum features necessary to avoid wasting rendering time in the
    // fragment shader on features that are not being used
    uint64_t permutation = 0;
    unsigned int mode = 0;
    const float *lightcolorbase = rtlight->currentcolor;
    float ambientscale = rtlight->ambientscale;
    float diffusescale = rtlight->diffusescale;
    float specularscale = rtlight->specularscale;
    // this is the location of the light in view space
    vec3_t viewlightorigin;
    // this transforms from view space (camera) to light space (cubemap)
    matrix4x4_t viewtolight;
    matrix4x4_t lighttoview;
    float viewtolight16f[16];
    // light source
    mode = SHADERMODE_DEFERREDLIGHTSOURCE;
    if (rtlight->currentcubemap != r_texture_whitecube)
        permutation |= SHADERPERMUTATION_CUBEFILTER;
    if (diffusescale > 0)
        permutation |= SHADERPERMUTATION_DIFFUSE;
    if (specularscale > 0 && r_shadow_gloss.integer > 0)
        permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
    if (r_shadow_usingshadowmap2d)
    {
        permutation |= SHADERPERMUTATION_SHADOWMAP2D;
        if (r_shadow_shadowmapvsdct)
            permutation |= SHADERPERMUTATION_SHADOWMAPVSDCT;
 
        if (r_shadow_shadowmap2ddepthbuffer)
            permutation |= SHADERPERMUTATION_DEPTHRGB;
    }
    if (vid.allowalphatocoverage)
        GL_AlphaToCoverage(false);
    Matrix4x4_Transform(&r_refdef.view.viewport.viewmatrix, rtlight->shadoworigin, viewlightorigin);
    Matrix4x4_Concat(&lighttoview, &r_refdef.view.viewport.viewmatrix, &rtlight->matrix_lighttoworld);
    Matrix4x4_Invert_Full(&viewtolight, &lighttoview);
    Matrix4x4_ToArrayFloatGL(&viewtolight, viewtolight16f);
    switch(vid.renderpath)
    {
    case RENDERPATH_GL32:
    case RENDERPATH_GLES2:
        R_SetupShader_SetPermutationGLSL(mode, permutation);
        if (r_glsl_permutation->loc_LightPosition             >= 0) qglUniform3f(       r_glsl_permutation->loc_LightPosition            , viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]);
        if (r_glsl_permutation->loc_ViewToLight               >= 0) qglUniformMatrix4fv(r_glsl_permutation->loc_ViewToLight              , 1, false, viewtolight16f);
        if (r_glsl_permutation->loc_DeferredColor_Ambient     >= 0) qglUniform3f(       r_glsl_permutation->loc_DeferredColor_Ambient    , lightcolorbase[0] * ambientscale , lightcolorbase[1] * ambientscale , lightcolorbase[2] * ambientscale );
        if (r_glsl_permutation->loc_DeferredColor_Diffuse     >= 0) qglUniform3f(       r_glsl_permutation->loc_DeferredColor_Diffuse    , lightcolorbase[0] * diffusescale , lightcolorbase[1] * diffusescale , lightcolorbase[2] * diffusescale );
        if (r_glsl_permutation->loc_DeferredColor_Specular    >= 0) qglUniform3f(       r_glsl_permutation->loc_DeferredColor_Specular   , lightcolorbase[0] * specularscale, lightcolorbase[1] * specularscale, lightcolorbase[2] * specularscale);
        if (r_glsl_permutation->loc_ShadowMap_TextureScale    >= 0) qglUniform4f(       r_glsl_permutation->loc_ShadowMap_TextureScale   , r_shadow_lightshadowmap_texturescale[0], r_shadow_lightshadowmap_texturescale[1], r_shadow_lightshadowmap_texturescale[2], r_shadow_lightshadowmap_texturescale[3]);
        if (r_glsl_permutation->loc_ShadowMap_Parameters      >= 0) qglUniform4f(       r_glsl_permutation->loc_ShadowMap_Parameters     , r_shadow_lightshadowmap_parameters[0], r_shadow_lightshadowmap_parameters[1], r_shadow_lightshadowmap_parameters[2], r_shadow_lightshadowmap_parameters[3]);
        if (r_glsl_permutation->loc_SpecularPower             >= 0) qglUniform1f(       r_glsl_permutation->loc_SpecularPower            , (r_shadow_gloss.integer == 2 ? r_shadow_gloss2exponent.value : r_shadow_glossexponent.value) * (r_shadow_glossexact.integer ? 0.25f : 1.0f) - 1.0f);
        if (r_glsl_permutation->loc_ScreenToDepth             >= 0) qglUniform2f(       r_glsl_permutation->loc_ScreenToDepth            , r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);
        if (r_glsl_permutation->loc_PixelToScreenTexCoord     >= 0) qglUniform2f(       r_glsl_permutation->loc_PixelToScreenTexCoord    , 1.0f/r_fb.screentexturewidth, 1.0f/r_fb.screentextureheight);
 
        if (r_glsl_permutation->tex_Texture_Attenuation       >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Attenuation        , r_shadow_attenuationgradienttexture                 );
        if (r_glsl_permutation->tex_Texture_ScreenNormalMap   >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_ScreenNormalMap    , r_shadow_prepassgeometrynormalmaptexture            );
        if (r_glsl_permutation->tex_Texture_Cube              >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Cube               , rsurface.rtlight->currentcubemap                    );
        if (r_glsl_permutation->tex_Texture_ShadowMap2D       >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_ShadowMap2D        , r_shadow_shadowmap2ddepthtexture                    );
        if (r_glsl_permutation->tex_Texture_CubeProjection    >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_CubeProjection     , r_shadow_shadowmapvsdcttexture                      );
        break;
    }
}

References rtlight_t::ambientscale, rtlight_t::currentcolor, rtlight_t::currentcubemap, rtlight_t::diffusescale, GL_AlphaToCoverage(), Matrix4x4_Concat(), Matrix4x4_Invert_Full(), Matrix4x4_ToArrayFloatGL(), Matrix4x4_Transform(), rtlight_t::matrix_lighttoworld, mode, r_fb, r_glsl_permutation, R_Mesh_TexBind(), r_refdef, R_SetupShader_SetPermutationGLSL(), r_shadow_attenuationgradienttexture, r_shadow_gloss, r_shadow_gloss2exponent, r_shadow_glossexact, r_shadow_glossexponent, r_shadow_lightshadowmap_parameters, r_shadow_lightshadowmap_texturescale, r_shadow_prepassgeometrynormalmaptexture, r_shadow_shadowmap2ddepthbuffer, r_shadow_shadowmap2ddepthtexture, r_shadow_shadowmapvsdct, r_shadow_shadowmapvsdcttexture, r_shadow_usingshadowmap2d, r_texture_whitecube, RENDERPATH_GL32, RENDERPATH_GLES2, rsurface, SHADERMODE_DEFERREDLIGHTSOURCE, SHADERPERMUTATION_CUBEFILTER, SHADERPERMUTATION_DEPTHRGB, SHADERPERMUTATION_DIFFUSE, SHADERPERMUTATION_SHADOWMAP2D, SHADERPERMUTATION_SHADOWMAPVSDCT, SHADERPERMUTATION_SPECULAR, rtlight_t::shadoworigin, rtlight_t::specularscale, and vid.

Referenced by R_Shadow_RenderMode_DrawDeferredLight().

◆ R_SetupShader_DepthOrShadow()

void R_SetupShader_DepthOrShadow	(	qbool	notrippy,
		qbool	depthrgb,
		qbool	skeletal )

Definition at line 1493 of file gl_rmain.c.

{
    uint64_t permutation = 0;
    if (r_trippy.integer && !notrippy)
        permutation |= SHADERPERMUTATION_TRIPPY;
    if (depthrgb)
        permutation |= SHADERPERMUTATION_DEPTHRGB;
    if (skeletal)
        permutation |= SHADERPERMUTATION_SKELETAL;
 
    if (vid.allowalphatocoverage)
        GL_AlphaToCoverage(false);
    switch (vid.renderpath)
    {
    case RENDERPATH_GL32:
    case RENDERPATH_GLES2:
        R_SetupShader_SetPermutationGLSL(SHADERMODE_DEPTH_OR_SHADOW, permutation);
#ifndef USE_GLES2 /* FIXME: GLES3 only */
        if (r_glsl_permutation->ubiloc_Skeletal_Transform12_UniformBlock >= 0 && rsurface.batchskeletaltransform3x4buffer) qglBindBufferRange(GL_UNIFORM_BUFFER, r_glsl_permutation->ubibind_Skeletal_Transform12_UniformBlock, rsurface.batchskeletaltransform3x4buffer->bufferobject, rsurface.batchskeletaltransform3x4offset, rsurface.batchskeletaltransform3x4size);
#endif
        break;
    }
}

References GL_AlphaToCoverage(), GL_UNIFORM_BUFFER, r_glsl_permutation, R_SetupShader_SetPermutationGLSL(), r_trippy, RENDERPATH_GL32, RENDERPATH_GLES2, rsurface, SHADERMODE_DEPTH_OR_SHADOW, SHADERPERMUTATION_DEPTHRGB, SHADERPERMUTATION_SKELETAL, SHADERPERMUTATION_TRIPPY, and vid.

Referenced by R_DrawSurface_TransparentCallback(), R_DrawTextureSurfaceList_DepthOnly(), R_DrawTextureSurfaceList_Sky(), R_Shadow_ClearShadowMapTexture(), and R_Shadow_RenderMode_ShadowMap().

◆ R_SetupShader_Generic()

void R_SetupShader_Generic	(	rtexture_t *	t,
		qbool	usegamma,
		qbool	notrippy,
		qbool	suppresstexalpha )

Definition at line 1461 of file gl_rmain.c.

{
    uint64_t permutation = 0;
    if (r_trippy.integer && !notrippy)
        permutation |= SHADERPERMUTATION_TRIPPY;
    permutation |= SHADERPERMUTATION_VIEWTINT;
    if (t)
        permutation |= SHADERPERMUTATION_DIFFUSE;
    if (usegamma && v_glslgamma_2d.integer && !vid.sRGB2D && r_texture_gammaramps && !vid_gammatables_trivial)
        permutation |= SHADERPERMUTATION_GAMMARAMPS;
    if (suppresstexalpha)
        permutation |= SHADERPERMUTATION_REFLECTCUBE;
    if (vid.allowalphatocoverage)
        GL_AlphaToCoverage(false);
    switch (vid.renderpath)
    {
    case RENDERPATH_GL32:
    case RENDERPATH_GLES2:
        R_SetupShader_SetPermutationGLSL(SHADERMODE_GENERIC, permutation);
        if (r_glsl_permutation->tex_Texture_First >= 0)
            R_Mesh_TexBind(r_glsl_permutation->tex_Texture_First, t);
        if (r_glsl_permutation->tex_Texture_GammaRamps >= 0)
            R_Mesh_TexBind(r_glsl_permutation->tex_Texture_GammaRamps, r_texture_gammaramps);
        break;
    }
}

References GL_AlphaToCoverage(), r_glsl_permutation, R_Mesh_TexBind(), R_SetupShader_SetPermutationGLSL(), r_texture_gammaramps, r_trippy, RENDERPATH_GL32, RENDERPATH_GLES2, SHADERMODE_GENERIC, SHADERPERMUTATION_DIFFUSE, SHADERPERMUTATION_GAMMARAMPS, SHADERPERMUTATION_REFLECTCUBE, SHADERPERMUTATION_TRIPPY, SHADERPERMUTATION_VIEWTINT, v_glslgamma_2d, vid, and vid_gammatables_trivial.

Referenced by R_Bloom_MakeTexture(), R_DrawExplosion_TransparentCallback(), R_DrawModelDecals_Entity(), R_DrawParticle_TransparentCallback(), R_MotionBlurView(), R_SetupShader_Generic_NoTexture(), and SCR_DrawLoadingScreen().

◆ R_SetupShader_Generic_NoTexture()

void R_SetupShader_Generic_NoTexture	(	qbool	usegamma,
		qbool	notrippy )

Definition at line 1488 of file gl_rmain.c.

{
    R_SetupShader_Generic(NULL, usegamma, notrippy, false);
}

References NULL, and R_SetupShader_Generic().

Referenced by R_DrawBBoxMesh(), R_DrawDebugModel(), R_DrawEntityBBoxes_Callback(), R_DrawLoc_Callback(), R_DrawNoModel_TransparentCallback(), R_DrawPortal_Callback(), R_DrawTextureSurfaceList_ShowSurfaces(), R_DrawTextureSurfaceList_Sky(), R_Shadow_DrawCoronas(), R_Shadow_RenderMode_Reset(), and SCR_DrawLoadingStack().

◆ R_SetupShader_Surface()

void R_SetupShader_Surface	(	const float	ambientcolor[3],
		const float	diffusecolor[3],
		const float	specularcolor[3],
		rsurfacepass_t	rsurfacepass,
		int	texturenumsurfaces,
		const msurface_t **	texturesurfacelist,
		void *	waterplane,
		qbool	notrippy,
		qbool	ui )

Definition at line 1563 of file gl_rmain.c.

{
    // select a permutation of the lighting shader appropriate to this
    // combination of texture, entity, light source, and fogging, only use the
    // minimum features necessary to avoid wasting rendering time in the
    // fragment shader on features that are not being used
    uint64_t permutation = 0;
    unsigned int mode = 0;
    int blendfuncflags;
    texture_t *t = rsurface.texture;
    float m16f[16];
    matrix4x4_t tempmatrix;
    r_waterstate_waterplane_t *waterplane = (r_waterstate_waterplane_t *)surfacewaterplane;
    if (r_trippy.integer && !notrippy)
        permutation |= SHADERPERMUTATION_TRIPPY;
    if (t->currentmaterialflags & MATERIALFLAG_ALPHATEST)
        permutation |= SHADERPERMUTATION_ALPHAKILL;
    if (t->currentmaterialflags & MATERIALFLAG_OCCLUDE)
        permutation |= SHADERPERMUTATION_OCCLUDE;
    if (t->r_water_waterscroll[0] && t->r_water_waterscroll[1])
        permutation |= SHADERPERMUTATION_NORMALMAPSCROLLBLEND; // todo: make generic
    if (rsurfacepass == RSURFPASS_BACKGROUND)
    {
        // distorted background
        if (t->currentmaterialflags & MATERIALFLAG_WATERSHADER)
        {
            mode = SHADERMODE_WATER;
            if (t->currentmaterialflags & MATERIALFLAG_ALPHAGEN_VERTEX)
                permutation |= SHADERPERMUTATION_ALPHAGEN_VERTEX;
            if((r_wateralpha.value < 1) && (t->currentmaterialflags & MATERIALFLAG_WATERALPHA))
            {
                // this is the right thing to do for wateralpha
                GL_BlendFunc(GL_ONE, GL_ZERO);
                blendfuncflags = R_BlendFuncFlags(GL_ONE, GL_ZERO);
            }
            else
            {
                // this is the right thing to do for entity alpha
                GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                blendfuncflags = R_BlendFuncFlags(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
            }
        }
        else if (t->currentmaterialflags & MATERIALFLAG_REFRACTION)
        {
            mode = SHADERMODE_REFRACTION;
            if (t->currentmaterialflags & MATERIALFLAG_ALPHAGEN_VERTEX)
                permutation |= SHADERPERMUTATION_ALPHAGEN_VERTEX;
            GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
            blendfuncflags = R_BlendFuncFlags(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        }
        else
        {
            mode = SHADERMODE_GENERIC;
            permutation |= SHADERPERMUTATION_DIFFUSE | SHADERPERMUTATION_ALPHAKILL;
            GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
            blendfuncflags = R_BlendFuncFlags(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        }
        if (vid.allowalphatocoverage)
            GL_AlphaToCoverage(false);
    }
    else if (rsurfacepass == RSURFPASS_DEFERREDGEOMETRY)
    {
        if (r_glsl_offsetmapping.integer && ((R_TextureFlags(t->nmaptexture) & TEXF_ALPHA) || t->offsetbias != 0.0f))
        {
            switch(t->offsetmapping)
            {
            case OFFSETMAPPING_LINEAR: permutation |= SHADERPERMUTATION_OFFSETMAPPING;break;
            case OFFSETMAPPING_RELIEF: permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;break;
            case OFFSETMAPPING_DEFAULT: permutation |= SHADERPERMUTATION_OFFSETMAPPING;if (r_glsl_offsetmapping_reliefmapping.integer) permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;break;
            case OFFSETMAPPING_OFF: break;
            }
        }
        if (t->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
            permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
        // normalmap (deferred prepass), may use alpha test on diffuse
        mode = SHADERMODE_DEFERREDGEOMETRY;
        GL_BlendFunc(GL_ONE, GL_ZERO);
        blendfuncflags = R_BlendFuncFlags(GL_ONE, GL_ZERO);
        if (vid.allowalphatocoverage)
            GL_AlphaToCoverage(false);
    }
    else if (rsurfacepass == RSURFPASS_RTLIGHT)
    {
        if (r_glsl_offsetmapping.integer && ((R_TextureFlags(t->nmaptexture) & TEXF_ALPHA) || t->offsetbias != 0.0f))
        {
            switch(t->offsetmapping)
            {
            case OFFSETMAPPING_LINEAR: permutation |= SHADERPERMUTATION_OFFSETMAPPING;break;
            case OFFSETMAPPING_RELIEF: permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;break;
            case OFFSETMAPPING_DEFAULT: permutation |= SHADERPERMUTATION_OFFSETMAPPING;if (r_glsl_offsetmapping_reliefmapping.integer) permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;break;
            case OFFSETMAPPING_OFF: break;
            }
        }
        if (t->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
            permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
        if (t->currentmaterialflags & MATERIALFLAG_ALPHAGEN_VERTEX)
            permutation |= SHADERPERMUTATION_ALPHAGEN_VERTEX;
        // light source
        mode = SHADERMODE_LIGHTSOURCE;
        if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
            permutation |= SHADERPERMUTATION_CUBEFILTER;
        if (VectorLength2(rtlightdiffuse) > 0)
            permutation |= SHADERPERMUTATION_DIFFUSE;
        if (VectorLength2(rtlightspecular) > 0)
            permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
        if (r_refdef.fogenabled)
            permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
        if (t->colormapping)
            permutation |= SHADERPERMUTATION_COLORMAPPING;
        if (r_shadow_usingshadowmap2d)
        {
            permutation |= SHADERPERMUTATION_SHADOWMAP2D;
            if(r_shadow_shadowmapvsdct)
                permutation |= SHADERPERMUTATION_SHADOWMAPVSDCT;
 
            if (r_shadow_shadowmap2ddepthbuffer)
                permutation |= SHADERPERMUTATION_DEPTHRGB;
        }
        if (t->reflectmasktexture)
            permutation |= SHADERPERMUTATION_REFLECTCUBE;
        GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
        blendfuncflags = R_BlendFuncFlags(GL_SRC_ALPHA, GL_ONE);
        if (vid.allowalphatocoverage)
            GL_AlphaToCoverage(false);
    }
    else if (t->currentmaterialflags & MATERIALFLAG_LIGHTGRID)
    {
        if (r_glsl_offsetmapping.integer && ((R_TextureFlags(t->nmaptexture) & TEXF_ALPHA) || t->offsetbias != 0.0f))
        {
            switch(t->offsetmapping)
            {
            case OFFSETMAPPING_LINEAR: permutation |= SHADERPERMUTATION_OFFSETMAPPING;break;
            case OFFSETMAPPING_RELIEF: permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;break;
            case OFFSETMAPPING_DEFAULT: permutation |= SHADERPERMUTATION_OFFSETMAPPING;if (r_glsl_offsetmapping_reliefmapping.integer) permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;break;
            case OFFSETMAPPING_OFF: break;
            }
        }
        if (t->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
            permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
        if (t->currentmaterialflags & MATERIALFLAG_ALPHAGEN_VERTEX)
            permutation |= SHADERPERMUTATION_ALPHAGEN_VERTEX;
        // directional model lighting
        mode = SHADERMODE_LIGHTGRID;
        if ((t->glowtexture || t->backgroundglowtexture) && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
            permutation |= SHADERPERMUTATION_GLOW;
        permutation |= SHADERPERMUTATION_DIFFUSE;
        if (t->glosstexture || t->backgroundglosstexture)
            permutation |= SHADERPERMUTATION_SPECULAR;
        if (r_refdef.fogenabled)
            permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
        if (t->colormapping)
            permutation |= SHADERPERMUTATION_COLORMAPPING;
        if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
        {
            permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
            permutation |= SHADERPERMUTATION_SHADOWMAP2D;
 
            if (r_shadow_shadowmap2ddepthbuffer)
                permutation |= SHADERPERMUTATION_DEPTHRGB;
        }
        if (t->currentmaterialflags & MATERIALFLAG_REFLECTION)
            permutation |= SHADERPERMUTATION_REFLECTION;
        if (r_shadow_usingdeferredprepass && !(t->currentmaterialflags & MATERIALFLAG_BLENDED))
            permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
        if (t->reflectmasktexture)
            permutation |= SHADERPERMUTATION_REFLECTCUBE;
        if (r_shadow_bouncegrid_state.texture && cl.csqc_vidvars.drawworld && !notrippy)
        {
            permutation |= SHADERPERMUTATION_BOUNCEGRID;
            if (r_shadow_bouncegrid_state.directional)
                permutation |= SHADERPERMUTATION_BOUNCEGRIDDIRECTIONAL;
        }
        GL_BlendFunc(t->currentblendfunc[0], t->currentblendfunc[1]);
        blendfuncflags = R_BlendFuncFlags(t->currentblendfunc[0], t->currentblendfunc[1]);
        // when using alphatocoverage, we don't need alphakill
        if (vid.allowalphatocoverage)
        {
            if (r_transparent_alphatocoverage.integer)
            {
                GL_AlphaToCoverage((t->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
                permutation &= ~SHADERPERMUTATION_ALPHAKILL;
            }
            else
                GL_AlphaToCoverage(false);
        }
    }
    else if (t->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
    {
        if (r_glsl_offsetmapping.integer && ((R_TextureFlags(t->nmaptexture) & TEXF_ALPHA) || t->offsetbias != 0.0f))
        {
            switch(t->offsetmapping)
            {
            case OFFSETMAPPING_LINEAR: permutation |= SHADERPERMUTATION_OFFSETMAPPING;break;
            case OFFSETMAPPING_RELIEF: permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;break;
            case OFFSETMAPPING_DEFAULT: permutation |= SHADERPERMUTATION_OFFSETMAPPING;if (r_glsl_offsetmapping_reliefmapping.integer) permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;break;
            case OFFSETMAPPING_OFF: break;
            }
        }
        if (t->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
            permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
        if (t->currentmaterialflags & MATERIALFLAG_ALPHAGEN_VERTEX)
            permutation |= SHADERPERMUTATION_ALPHAGEN_VERTEX;
        // directional model lighting
        mode = SHADERMODE_LIGHTDIRECTION;
        if ((t->glowtexture || t->backgroundglowtexture) && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
            permutation |= SHADERPERMUTATION_GLOW;
        if (VectorLength2(t->render_modellight_diffuse))
            permutation |= SHADERPERMUTATION_DIFFUSE;
        if (VectorLength2(t->render_modellight_specular) > 0)
            permutation |= SHADERPERMUTATION_SPECULAR;
        if (r_refdef.fogenabled)
            permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
        if (t->colormapping)
            permutation |= SHADERPERMUTATION_COLORMAPPING;
        if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
        {
            permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
            permutation |= SHADERPERMUTATION_SHADOWMAP2D;
 
            if (r_shadow_shadowmap2ddepthbuffer)
                permutation |= SHADERPERMUTATION_DEPTHRGB;
        }
        if (t->currentmaterialflags & MATERIALFLAG_REFLECTION)
            permutation |= SHADERPERMUTATION_REFLECTION;
        if (r_shadow_usingdeferredprepass && !(t->currentmaterialflags & MATERIALFLAG_BLENDED))
            permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
        if (t->reflectmasktexture)
            permutation |= SHADERPERMUTATION_REFLECTCUBE;
        if (r_shadow_bouncegrid_state.texture && cl.csqc_vidvars.drawworld && !notrippy)
        {
            permutation |= SHADERPERMUTATION_BOUNCEGRID;
            if (r_shadow_bouncegrid_state.directional)
                permutation |= SHADERPERMUTATION_BOUNCEGRIDDIRECTIONAL;
        }
        GL_BlendFunc(t->currentblendfunc[0], t->currentblendfunc[1]);
        blendfuncflags = R_BlendFuncFlags(t->currentblendfunc[0], t->currentblendfunc[1]);
        // when using alphatocoverage, we don't need alphakill
        if (vid.allowalphatocoverage)
        {
            if (r_transparent_alphatocoverage.integer)
            {
                GL_AlphaToCoverage((t->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
                permutation &= ~SHADERPERMUTATION_ALPHAKILL;
            }
            else
                GL_AlphaToCoverage(false);
        }
    }
    else
    {
        if (r_glsl_offsetmapping.integer && ((R_TextureFlags(t->nmaptexture) & TEXF_ALPHA) || t->offsetbias != 0.0f))
        {
            switch(t->offsetmapping)
            {
            case OFFSETMAPPING_LINEAR: permutation |= SHADERPERMUTATION_OFFSETMAPPING;break;
            case OFFSETMAPPING_RELIEF: permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;break;
            case OFFSETMAPPING_DEFAULT: permutation |= SHADERPERMUTATION_OFFSETMAPPING;if (r_glsl_offsetmapping_reliefmapping.integer) permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;break;
            case OFFSETMAPPING_OFF: break;
            }
        }
        if (t->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
            permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
        if (t->currentmaterialflags & MATERIALFLAG_ALPHAGEN_VERTEX)
            permutation |= SHADERPERMUTATION_ALPHAGEN_VERTEX;
        // lightmapped wall
        if ((t->glowtexture || t->backgroundglowtexture) && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
            permutation |= SHADERPERMUTATION_GLOW;
        if (r_refdef.fogenabled && !ui)
            permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
        if (t->colormapping)
            permutation |= SHADERPERMUTATION_COLORMAPPING;
        if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
        {
            permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
            permutation |= SHADERPERMUTATION_SHADOWMAP2D;
 
            if (r_shadow_shadowmap2ddepthbuffer)
                permutation |= SHADERPERMUTATION_DEPTHRGB;
        }
        if (t->currentmaterialflags & MATERIALFLAG_REFLECTION)
            permutation |= SHADERPERMUTATION_REFLECTION;
        if (r_shadow_usingdeferredprepass && !(t->currentmaterialflags & MATERIALFLAG_BLENDED))
            permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
        if (t->reflectmasktexture)
            permutation |= SHADERPERMUTATION_REFLECTCUBE;
        if (r_glsl_deluxemapping.integer >= 1 && rsurface.uselightmaptexture && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brushq3.deluxemapping)
        {
            // deluxemapping (light direction texture)
            if (rsurface.uselightmaptexture && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brushq3.deluxemapping && r_refdef.scene.worldmodel->brushq3.deluxemapping_modelspace)
                mode = SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE;
            else
                mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
            permutation |= SHADERPERMUTATION_DIFFUSE;
            if (VectorLength2(t->render_lightmap_specular) > 0)
                permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
        }
        else if (r_glsl_deluxemapping.integer >= 2)
        {
            // fake deluxemapping (uniform light direction in tangentspace)
            if (rsurface.uselightmaptexture)
                mode = SHADERMODE_LIGHTDIRECTIONMAP_FORCED_LIGHTMAP;
            else
                mode = SHADERMODE_LIGHTDIRECTIONMAP_FORCED_VERTEXCOLOR;
            permutation |= SHADERPERMUTATION_DIFFUSE;
            if (VectorLength2(t->render_lightmap_specular) > 0)
                permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
        }
        else if (rsurface.uselightmaptexture)
        {
            // ordinary lightmapping (q1bsp, q3bsp)
            mode = SHADERMODE_LIGHTMAP;
        }
        else
        {
            // ordinary vertex coloring (q3bsp)
            mode = SHADERMODE_VERTEXCOLOR;
        }
        if (r_shadow_bouncegrid_state.texture && cl.csqc_vidvars.drawworld && !notrippy)
        {
            permutation |= SHADERPERMUTATION_BOUNCEGRID;
            if (r_shadow_bouncegrid_state.directional)
                permutation |= SHADERPERMUTATION_BOUNCEGRIDDIRECTIONAL;
        }
        GL_BlendFunc(t->currentblendfunc[0], t->currentblendfunc[1]);
        blendfuncflags = R_BlendFuncFlags(t->currentblendfunc[0], t->currentblendfunc[1]);
        // when using alphatocoverage, we don't need alphakill
        if (vid.allowalphatocoverage)
        {
            if (r_transparent_alphatocoverage.integer)
            {
                GL_AlphaToCoverage((t->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
                permutation &= ~SHADERPERMUTATION_ALPHAKILL;
            }
            else
                GL_AlphaToCoverage(false);
        }
    }
    if(!(blendfuncflags & BLENDFUNC_ALLOWS_ANYFOG))
        permutation &= ~(SHADERPERMUTATION_FOGHEIGHTTEXTURE | SHADERPERMUTATION_FOGOUTSIDE | SHADERPERMUTATION_FOGINSIDE);
    if(blendfuncflags & BLENDFUNC_ALLOWS_FOG_HACKALPHA && !ui)
        permutation |= SHADERPERMUTATION_FOGALPHAHACK;
    switch(vid.renderpath)
    {
    case RENDERPATH_GL32:
    case RENDERPATH_GLES2:
        RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | (rsurface.modellightmapcolor4f ? BATCHNEED_ARRAY_VERTEXCOLOR : 0) | BATCHNEED_ARRAY_TEXCOORD | (rsurface.uselightmaptexture ? BATCHNEED_ARRAY_LIGHTMAP : 0) | BATCHNEED_ALLOWMULTIDRAW, texturenumsurfaces, texturesurfacelist);
        RSurf_UploadBuffersForBatch();
        // this has to be after RSurf_PrepareVerticesForBatch
        if (rsurface.batchskeletaltransform3x4buffer)
            permutation |= SHADERPERMUTATION_SKELETAL;
        R_SetupShader_SetPermutationGLSL(mode, permutation);
#ifndef USE_GLES2 /* FIXME: GLES3 only */
        if (r_glsl_permutation->ubiloc_Skeletal_Transform12_UniformBlock >= 0 && rsurface.batchskeletaltransform3x4buffer) qglBindBufferRange(GL_UNIFORM_BUFFER, r_glsl_permutation->ubibind_Skeletal_Transform12_UniformBlock, rsurface.batchskeletaltransform3x4buffer->bufferobject, rsurface.batchskeletaltransform3x4offset, rsurface.batchskeletaltransform3x4size);
#endif
        if (r_glsl_permutation->loc_ModelToReflectCube >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.matrix, m16f);qglUniformMatrix4fv(r_glsl_permutation->loc_ModelToReflectCube, 1, false, m16f);}
        if (mode == SHADERMODE_LIGHTSOURCE)
        {
            if (r_glsl_permutation->loc_ModelToLight >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);qglUniformMatrix4fv(r_glsl_permutation->loc_ModelToLight, 1, false, m16f);}
            if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3f(r_glsl_permutation->loc_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
            if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3f(r_glsl_permutation->loc_LightColor, 1, 1, 1); // DEPRECATED
            if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Ambient, rtlightambient[0], rtlightambient[1], rtlightambient[2]);
            if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Diffuse, rtlightdiffuse[0], rtlightdiffuse[1], rtlightdiffuse[2]);
            if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Specular, rtlightspecular[0], rtlightspecular[1], rtlightspecular[2]);
 
            // additive passes are only darkened by fog, not tinted
            if (r_glsl_permutation->loc_FogColor >= 0)
                qglUniform3f(r_glsl_permutation->loc_FogColor, 0, 0, 0);
            if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1f(r_glsl_permutation->loc_SpecularPower, t->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f) - 1.0f);
        }
        else
        {
            if (mode == SHADERMODE_FLATCOLOR)
            {
                if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Ambient, t->render_modellight_ambient[0], t->render_modellight_ambient[1], t->render_modellight_ambient[2]);
            }
            else if (mode == SHADERMODE_LIGHTGRID)
            {
                if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Ambient, t->render_lightmap_ambient[0], t->render_lightmap_ambient[1], t->render_lightmap_ambient[2]);
                if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Diffuse, t->render_lightmap_diffuse[0], t->render_lightmap_diffuse[1], t->render_lightmap_diffuse[2]);
                if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Specular, t->render_lightmap_specular[0], t->render_lightmap_specular[1], t->render_lightmap_specular[2]);
                // other LightGrid uniforms handled below
            }
            else if (mode == SHADERMODE_LIGHTDIRECTION)
            {
                if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Ambient, t->render_modellight_ambient[0], t->render_modellight_ambient[1], t->render_modellight_ambient[2]);
                if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Diffuse, t->render_modellight_diffuse[0], t->render_modellight_diffuse[1], t->render_modellight_diffuse[2]);
                if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Specular, t->render_modellight_specular[0], t->render_modellight_specular[1], t->render_modellight_specular[2]);
                if (r_glsl_permutation->loc_DeferredMod_Diffuse >= 0) qglUniform3f(r_glsl_permutation->loc_DeferredMod_Diffuse, t->render_rtlight_diffuse[0], t->render_rtlight_diffuse[1], t->render_rtlight_diffuse[2]);
                if (r_glsl_permutation->loc_DeferredMod_Specular >= 0) qglUniform3f(r_glsl_permutation->loc_DeferredMod_Specular, t->render_rtlight_specular[0], t->render_rtlight_specular[1], t->render_rtlight_specular[2]);
                if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3f(r_glsl_permutation->loc_LightColor, 1, 1, 1); // DEPRECATED
                if (r_glsl_permutation->loc_LightDir >= 0) qglUniform3f(r_glsl_permutation->loc_LightDir, t->render_modellight_lightdir_local[0], t->render_modellight_lightdir_local[1], t->render_modellight_lightdir_local[2]);
            }
            else
            {
                if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Ambient, t->render_lightmap_ambient[0], t->render_lightmap_ambient[1], t->render_lightmap_ambient[2]);
                if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Diffuse, t->render_lightmap_diffuse[0], t->render_lightmap_diffuse[1], t->render_lightmap_diffuse[2]);
                if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Specular, t->render_lightmap_specular[0], t->render_lightmap_specular[1], t->render_lightmap_specular[2]);
                if (r_glsl_permutation->loc_DeferredMod_Diffuse >= 0) qglUniform3f(r_glsl_permutation->loc_DeferredMod_Diffuse, t->render_rtlight_diffuse[0], t->render_rtlight_diffuse[1], t->render_rtlight_diffuse[2]);
                if (r_glsl_permutation->loc_DeferredMod_Specular >= 0) qglUniform3f(r_glsl_permutation->loc_DeferredMod_Specular, t->render_rtlight_specular[0], t->render_rtlight_specular[1], t->render_rtlight_specular[2]);
            }
            // additive passes are only darkened by fog, not tinted
            if (r_glsl_permutation->loc_FogColor >= 0 && !ui)
            {
                if(blendfuncflags & BLENDFUNC_ALLOWS_FOG_HACK0)
                    qglUniform3f(r_glsl_permutation->loc_FogColor, 0, 0, 0);
                else
                    qglUniform3f(r_glsl_permutation->loc_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
            }
            if (r_glsl_permutation->loc_DistortScaleRefractReflect >= 0) qglUniform4f(r_glsl_permutation->loc_DistortScaleRefractReflect, r_water_refractdistort.value * t->refractfactor, r_water_refractdistort.value * t->refractfactor, r_water_reflectdistort.value * t->reflectfactor, r_water_reflectdistort.value * t->reflectfactor);
            if (r_glsl_permutation->loc_ScreenScaleRefractReflect >= 0) qglUniform4f(r_glsl_permutation->loc_ScreenScaleRefractReflect, r_fb.water.screenscale[0], r_fb.water.screenscale[1], r_fb.water.screenscale[0], r_fb.water.screenscale[1]);
            if (r_glsl_permutation->loc_ScreenCenterRefractReflect >= 0) qglUniform4f(r_glsl_permutation->loc_ScreenCenterRefractReflect, r_fb.water.screencenter[0], r_fb.water.screencenter[1], r_fb.water.screencenter[0], r_fb.water.screencenter[1]);
            if (r_glsl_permutation->loc_RefractColor >= 0) qglUniform4f(r_glsl_permutation->loc_RefractColor, t->refractcolor4f[0], t->refractcolor4f[1], t->refractcolor4f[2], t->refractcolor4f[3] * t->currentalpha);
            if (r_glsl_permutation->loc_ReflectColor >= 0) qglUniform4f(r_glsl_permutation->loc_ReflectColor, t->reflectcolor4f[0], t->reflectcolor4f[1], t->reflectcolor4f[2], t->reflectcolor4f[3] * t->currentalpha);
            if (r_glsl_permutation->loc_ReflectFactor >= 0) qglUniform1f(r_glsl_permutation->loc_ReflectFactor, t->reflectmax - t->reflectmin);
            if (r_glsl_permutation->loc_ReflectOffset >= 0) qglUniform1f(r_glsl_permutation->loc_ReflectOffset, t->reflectmin);
            if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1f(r_glsl_permutation->loc_SpecularPower, t->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f) - 1.0f);
            if (r_glsl_permutation->loc_NormalmapScrollBlend >= 0) qglUniform2f(r_glsl_permutation->loc_NormalmapScrollBlend, t->r_water_waterscroll[0], t->r_water_waterscroll[1]);
        }
        if (r_glsl_permutation->loc_TexMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&t->currenttexmatrix, m16f);qglUniformMatrix4fv(r_glsl_permutation->loc_TexMatrix, 1, false, m16f);}
        if (r_glsl_permutation->loc_BackgroundTexMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&t->currentbackgroundtexmatrix, m16f);qglUniformMatrix4fv(r_glsl_permutation->loc_BackgroundTexMatrix, 1, false, m16f);}
        if (r_glsl_permutation->loc_ShadowMapMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&r_shadow_shadowmapmatrix, m16f);qglUniformMatrix4fv(r_glsl_permutation->loc_ShadowMapMatrix, 1, false, m16f);}
        if (permutation & SHADERPERMUTATION_SHADOWMAPORTHO)
        {
            if (r_glsl_permutation->loc_ShadowMap_TextureScale >= 0) qglUniform4f(r_glsl_permutation->loc_ShadowMap_TextureScale, r_shadow_modelshadowmap_texturescale[0], r_shadow_modelshadowmap_texturescale[1], r_shadow_modelshadowmap_texturescale[2], r_shadow_modelshadowmap_texturescale[3]);
            if (r_glsl_permutation->loc_ShadowMap_Parameters >= 0) qglUniform4f(r_glsl_permutation->loc_ShadowMap_Parameters, r_shadow_modelshadowmap_parameters[0], r_shadow_modelshadowmap_parameters[1], r_shadow_modelshadowmap_parameters[2], r_shadow_modelshadowmap_parameters[3]);
        }
        else
        {
            if (r_glsl_permutation->loc_ShadowMap_TextureScale >= 0) qglUniform4f(r_glsl_permutation->loc_ShadowMap_TextureScale, r_shadow_lightshadowmap_texturescale[0], r_shadow_lightshadowmap_texturescale[1], r_shadow_lightshadowmap_texturescale[2], r_shadow_lightshadowmap_texturescale[3]);
            if (r_glsl_permutation->loc_ShadowMap_Parameters >= 0) qglUniform4f(r_glsl_permutation->loc_ShadowMap_Parameters, r_shadow_lightshadowmap_parameters[0], r_shadow_lightshadowmap_parameters[1], r_shadow_lightshadowmap_parameters[2], r_shadow_lightshadowmap_parameters[3]);
        }
 
        if (r_glsl_permutation->loc_Color_Glow >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Glow, t->render_glowmod[0], t->render_glowmod[1], t->render_glowmod[2]);
        if (r_glsl_permutation->loc_Alpha >= 0) qglUniform1f(r_glsl_permutation->loc_Alpha, t->currentalpha * ((t->basematerialflags & MATERIALFLAG_WATERSHADER && r_fb.water.enabled && !r_refdef.view.isoverlay) ? t->r_water_wateralpha : 1));
        if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3f(r_glsl_permutation->loc_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);
        if (r_glsl_permutation->loc_Color_Pants >= 0)
        {
            if (t->pantstexture)
                qglUniform3f(r_glsl_permutation->loc_Color_Pants, t->render_colormap_pants[0], t->render_colormap_pants[1], t->render_colormap_pants[2]);
            else
                qglUniform3f(r_glsl_permutation->loc_Color_Pants, 0, 0, 0);
        }
        if (r_glsl_permutation->loc_Color_Shirt >= 0)
        {
            if (t->shirttexture)
                qglUniform3f(r_glsl_permutation->loc_Color_Shirt, t->render_colormap_shirt[0], t->render_colormap_shirt[1], t->render_colormap_shirt[2]);
            else
                qglUniform3f(r_glsl_permutation->loc_Color_Shirt, 0, 0, 0);
        }
        if (r_glsl_permutation->loc_FogPlane >= 0) qglUniform4f(r_glsl_permutation->loc_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]);
        if (r_glsl_permutation->loc_FogPlaneViewDist >= 0) qglUniform1f(r_glsl_permutation->loc_FogPlaneViewDist, rsurface.fogplaneviewdist);
        if (r_glsl_permutation->loc_FogRangeRecip >= 0) qglUniform1f(r_glsl_permutation->loc_FogRangeRecip, rsurface.fograngerecip);
        if (r_glsl_permutation->loc_FogHeightFade >= 0) qglUniform1f(r_glsl_permutation->loc_FogHeightFade, rsurface.fogheightfade);
        if (r_glsl_permutation->loc_OffsetMapping_ScaleSteps >= 0) qglUniform4f(r_glsl_permutation->loc_OffsetMapping_ScaleSteps,
                r_glsl_offsetmapping_scale.value*t->offsetscale,
                max(1, (permutation & SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING) ? r_glsl_offsetmapping_reliefmapping_steps.integer : r_glsl_offsetmapping_steps.integer),
                1.0 / max(1, (permutation & SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING) ? r_glsl_offsetmapping_reliefmapping_steps.integer : r_glsl_offsetmapping_steps.integer),
                max(1, r_glsl_offsetmapping_reliefmapping_refinesteps.integer)
            );
        if (r_glsl_permutation->loc_OffsetMapping_LodDistance >= 0) qglUniform1f(r_glsl_permutation->loc_OffsetMapping_LodDistance, r_glsl_offsetmapping_lod_distance.integer * r_refdef.view.quality);
        if (r_glsl_permutation->loc_OffsetMapping_Bias >= 0) qglUniform1f(r_glsl_permutation->loc_OffsetMapping_Bias, t->offsetbias);
        if (r_glsl_permutation->loc_ScreenToDepth >= 0) qglUniform2f(r_glsl_permutation->loc_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);
        if (r_glsl_permutation->loc_PixelToScreenTexCoord >= 0) qglUniform2f(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/r_fb.screentexturewidth, 1.0f/r_fb.screentextureheight);
        if (r_glsl_permutation->loc_BounceGridMatrix >= 0) {Matrix4x4_Concat(&tempmatrix, &r_shadow_bouncegrid_state.matrix, &rsurface.matrix);Matrix4x4_ToArrayFloatGL(&tempmatrix, m16f);qglUniformMatrix4fv(r_glsl_permutation->loc_BounceGridMatrix, 1, false, m16f);}
        if (r_glsl_permutation->loc_BounceGridIntensity >= 0) qglUniform1f(r_glsl_permutation->loc_BounceGridIntensity, r_shadow_bouncegrid_state.intensity*r_refdef.view.colorscale);
        if (r_glsl_permutation->loc_LightGridMatrix >= 0 && r_refdef.scene.worldmodel)
        {
            float m9f[9];
            Matrix4x4_Concat(&tempmatrix, &r_refdef.scene.worldmodel->brushq3.lightgridworldtotexturematrix, &rsurface.matrix);
            Matrix4x4_ToArrayFloatGL(&tempmatrix, m16f);
            qglUniformMatrix4fv(r_glsl_permutation->loc_LightGridMatrix, 1, false, m16f);
            Matrix4x4_Normalize3(&tempmatrix, &rsurface.matrix);
            Matrix4x4_ToArrayFloatGL(&tempmatrix, m16f);
            m9f[0] = m16f[0];m9f[1] = m16f[1];m9f[2] = m16f[2];
            m9f[3] = m16f[4];m9f[4] = m16f[5];m9f[5] = m16f[6];
            m9f[6] = m16f[8];m9f[7] = m16f[9];m9f[8] = m16f[10];
            qglUniformMatrix3fv(r_glsl_permutation->loc_LightGridNormalMatrix, 1, false, m9f);
        }
 
        if (r_glsl_permutation->tex_Texture_First           >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_First            , r_texture_white                                     );
        if (r_glsl_permutation->tex_Texture_Second          >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Second           , r_texture_white                                     );
        if (r_glsl_permutation->tex_Texture_GammaRamps      >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_GammaRamps       , r_texture_gammaramps                                );
        if (r_glsl_permutation->tex_Texture_Normal          >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Normal           , t->nmaptexture                       );
        if (r_glsl_permutation->tex_Texture_Color           >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Color            , t->basetexture                       );
        if (r_glsl_permutation->tex_Texture_Gloss           >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Gloss            , t->glosstexture                      );
        if (r_glsl_permutation->tex_Texture_Glow            >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Glow             , t->glowtexture                       );
        if (r_glsl_permutation->tex_Texture_SecondaryNormal >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_SecondaryNormal  , t->backgroundnmaptexture             );
        if (r_glsl_permutation->tex_Texture_SecondaryColor  >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_SecondaryColor   , t->backgroundbasetexture             );
        if (r_glsl_permutation->tex_Texture_SecondaryGloss  >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_SecondaryGloss   , t->backgroundglosstexture            );
        if (r_glsl_permutation->tex_Texture_SecondaryGlow   >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_SecondaryGlow    , t->backgroundglowtexture             );
        if (r_glsl_permutation->tex_Texture_Pants           >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Pants            , t->pantstexture                      );
        if (r_glsl_permutation->tex_Texture_Shirt           >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Shirt            , t->shirttexture                      );
        if (r_glsl_permutation->tex_Texture_ReflectMask     >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_ReflectMask      , t->reflectmasktexture                );
        if (r_glsl_permutation->tex_Texture_ReflectCube     >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_ReflectCube      , t->reflectcubetexture ? t->reflectcubetexture : r_texture_whitecube);
        if (r_glsl_permutation->tex_Texture_FogHeightTexture>= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_FogHeightTexture , r_texture_fogheighttexture                          );
        if (r_glsl_permutation->tex_Texture_FogMask         >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_FogMask          , r_texture_fogattenuation                            );
        if (r_glsl_permutation->tex_Texture_Lightmap        >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Lightmap         , rsurface.lightmaptexture ? rsurface.lightmaptexture : r_texture_white);
        if (r_glsl_permutation->tex_Texture_Deluxemap       >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Deluxemap        , rsurface.deluxemaptexture ? rsurface.deluxemaptexture : r_texture_blanknormalmap);
        if (r_glsl_permutation->tex_Texture_Attenuation     >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Attenuation      , r_shadow_attenuationgradienttexture                 );
        if (rsurfacepass == RSURFPASS_BACKGROUND)
        {
            if (r_glsl_permutation->tex_Texture_Refraction  >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Refraction        , waterplane->rt_refraction ? waterplane->rt_refraction->colortexture[0] : r_texture_black);
            if (r_glsl_permutation->tex_Texture_First       >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_First             , waterplane->rt_camera ? waterplane->rt_camera->colortexture[0] : r_texture_black);
            if (r_glsl_permutation->tex_Texture_Reflection  >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Reflection        , waterplane->rt_reflection ? waterplane->rt_reflection->colortexture[0] : r_texture_black);
        }
        else
        {
            if (r_glsl_permutation->tex_Texture_Reflection >= 0 && waterplane) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Reflection        , waterplane->rt_reflection ? waterplane->rt_reflection->colortexture[0] : r_texture_black);
        }
        if (r_glsl_permutation->tex_Texture_ScreenNormalMap >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_ScreenNormalMap   , r_shadow_prepassgeometrynormalmaptexture            );
        if (r_glsl_permutation->tex_Texture_ScreenDiffuse   >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_ScreenDiffuse     , r_shadow_prepasslightingdiffusetexture              );
        if (r_glsl_permutation->tex_Texture_ScreenSpecular  >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_ScreenSpecular    , r_shadow_prepasslightingspeculartexture             );
        if (rsurface.rtlight || (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW)))
        {
            if (r_glsl_permutation->tex_Texture_ShadowMap2D     >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_ShadowMap2D, r_shadow_shadowmap2ddepthtexture                           );
            if (rsurface.rtlight)
            {
                if (r_glsl_permutation->tex_Texture_Cube            >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Cube              , rsurface.rtlight->currentcubemap                    );
                if (r_glsl_permutation->tex_Texture_CubeProjection  >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_CubeProjection    , r_shadow_shadowmapvsdcttexture                      );
            }
        }
        if (r_glsl_permutation->tex_Texture_BounceGrid  >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_BounceGrid, r_shadow_bouncegrid_state.texture);
        if (r_glsl_permutation->tex_Texture_LightGrid   >= 0 && r_refdef.scene.worldmodel) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_LightGrid, r_refdef.scene.worldmodel->brushq3.lightgridtexture);
        CHECKGLERROR
        break;
    }
}

Referenced by R_DrawTextureSurfaceList_GL20(), and R_Shadow_RenderLighting_Light_GLSL().

◆ R_SetupView()

void R_SetupView	(	qbool	allowwaterclippingplane,
		int	viewfbo,
		rtexture_t *	viewdepthtexture,
		rtexture_t *	viewcolortexture,
		int	viewx,
		int	viewy,
		int	viewwidth,
		int	viewheight )

Definition at line 4384 of file gl_rmain.c.

{
    const float *customclipplane = NULL;
    float plane[4];
    int viewy_adjusted;
    if (r_refdef.view.useclipplane && allowwaterclippingplane)
    {
        // LadyHavoc: couldn't figure out how to make this approach work the same in DPSOFTRAST
        vec_t dist = r_refdef.view.clipplane.dist - r_water_clippingplanebias.value;
        vec_t viewdist = DotProduct(r_refdef.view.origin, r_refdef.view.clipplane.normal);
        if (viewdist < r_refdef.view.clipplane.dist + r_water_clippingplanebias.value)
            dist = r_refdef.view.clipplane.dist;
        plane[0] = r_refdef.view.clipplane.normal[0];
        plane[1] = r_refdef.view.clipplane.normal[1];
        plane[2] = r_refdef.view.clipplane.normal[2];
        plane[3] = -dist;
        customclipplane = plane;
    }
 
    // GL is weird because it's bottom to top, r_refdef.view.y is top to bottom.
    // Unless the render target is a FBO...
    viewy_adjusted = viewfbo ? viewy : vid.mode.height - viewheight - viewy;
 
    if (!r_refdef.view.useperspective)
        R_Viewport_InitOrtho3D(&r_refdef.view.viewport, &r_refdef.view.matrix, viewx, viewy_adjusted, viewwidth, viewheight, r_refdef.view.ortho_x, r_refdef.view.ortho_y, -r_refdef.farclip, r_refdef.farclip, customclipplane);
    else if (vid.stencil && r_useinfinitefarclip.integer)
        R_Viewport_InitPerspectiveInfinite(&r_refdef.view.viewport, &r_refdef.view.matrix, viewx, viewy_adjusted, viewwidth, viewheight, r_refdef.view.frustum_x, r_refdef.view.frustum_y, r_refdef.nearclip, customclipplane);
    else
        R_Viewport_InitPerspective(&r_refdef.view.viewport, &r_refdef.view.matrix, viewx, viewy_adjusted, viewwidth, viewheight, r_refdef.view.frustum_x, r_refdef.view.frustum_y, r_refdef.nearclip, r_refdef.farclip, customclipplane);
    R_Mesh_SetRenderTargets(viewfbo);
    R_SetViewport(&r_refdef.view.viewport);
}

References DotProduct, NULL, R_Mesh_SetRenderTargets(), r_refdef, R_SetViewport(), r_useinfinitefarclip, R_Viewport_InitOrtho3D(), R_Viewport_InitPerspective(), R_Viewport_InitPerspectiveInfinite(), r_water_clippingplanebias, and vid.

Referenced by R_RenderScene(), R_ResetViewRendering3D(), and R_Water_ProcessPlanes().

◆ R_Shadow_EditLights_DrawSelectedLightProperties()

void R_Shadow_EditLights_DrawSelectedLightProperties ( void )

Definition at line 5713 of file r_shadow.c.

{
    int lightnumber, lightcount;
    size_t lightindex, range;
    dlight_t *light;
    char temp[256];
    float x, y;
 
    if (!r_editlights.integer)
        return;
 
    // update cvars so QC can query them
    if (r_shadow_selectedlight)
    {
        dpsnprintf(temp, sizeof(temp), "%f %f %f", r_shadow_selectedlight->origin[0], r_shadow_selectedlight->origin[1], r_shadow_selectedlight->origin[2]);
        Cvar_SetQuick(&r_editlights_current_origin, temp);
        dpsnprintf(temp, sizeof(temp), "%f %f %f", r_shadow_selectedlight->angles[0], r_shadow_selectedlight->angles[1], r_shadow_selectedlight->angles[2]);
        Cvar_SetQuick(&r_editlights_current_angles, temp);
        dpsnprintf(temp, sizeof(temp), "%f %f %f", r_shadow_selectedlight->color[0], r_shadow_selectedlight->color[1], r_shadow_selectedlight->color[2]);
        Cvar_SetQuick(&r_editlights_current_color, temp);
        Cvar_SetValueQuick(&r_editlights_current_radius, r_shadow_selectedlight->radius);
        Cvar_SetValueQuick(&r_editlights_current_corona, r_shadow_selectedlight->corona);
        Cvar_SetValueQuick(&r_editlights_current_coronasize, r_shadow_selectedlight->coronasizescale);
        Cvar_SetValueQuick(&r_editlights_current_style, r_shadow_selectedlight->style);
        Cvar_SetValueQuick(&r_editlights_current_shadows, r_shadow_selectedlight->shadow);
        Cvar_SetQuick(&r_editlights_current_cubemap, r_shadow_selectedlight->cubemapname);
        Cvar_SetValueQuick(&r_editlights_current_ambient, r_shadow_selectedlight->ambientscale);
        Cvar_SetValueQuick(&r_editlights_current_diffuse, r_shadow_selectedlight->diffusescale);
        Cvar_SetValueQuick(&r_editlights_current_specular, r_shadow_selectedlight->specularscale);
        Cvar_SetValueQuick(&r_editlights_current_normalmode, (r_shadow_selectedlight->flags & LIGHTFLAG_NORMALMODE) ? 1 : 0);
        Cvar_SetValueQuick(&r_editlights_current_realtimemode, (r_shadow_selectedlight->flags & LIGHTFLAG_REALTIMEMODE) ? 1 : 0);
    }
 
    // draw properties on screen
    if (!r_editlights_drawproperties.integer)
        return;
    x = vid_conwidth.value - 320;
    y = 5;
    DrawQ_Pic(x-5, y-5, NULL, 250, 243, 0, 0, 0, 0.75, 0);
    lightnumber = -1;
    lightcount = 0;
    range = Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray); // checked
    for (lightindex = 0;lightindex < range;lightindex++)
    {
        light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
        if (!light)
            continue;
        if (light == r_shadow_selectedlight)
            lightnumber = (int)lightindex;
        lightcount++;
    }
    dpsnprintf(temp, sizeof(temp), "Cursor origin: %.0f %.0f %.0f", r_editlights_cursorlocation[0], r_editlights_cursorlocation[1], r_editlights_cursorlocation[2]); DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, false, FONT_DEFAULT);y += 8;
    dpsnprintf(temp, sizeof(temp), "Total lights : %i active (%i total)", lightcount, (int)Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray)); DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, false, FONT_DEFAULT);y += 8;
    y += 8;
    if (r_shadow_selectedlight == NULL)
        return;
    dpsnprintf(temp, sizeof(temp), "Light #%i properties:", lightnumber);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
    dpsnprintf(temp, sizeof(temp), "Origin       : %.0f %.0f %.0f\n", r_shadow_selectedlight->origin[0], r_shadow_selectedlight->origin[1], r_shadow_selectedlight->origin[2]);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
    dpsnprintf(temp, sizeof(temp), "Angles       : %.0f %.0f %.0f\n", r_shadow_selectedlight->angles[0], r_shadow_selectedlight->angles[1], r_shadow_selectedlight->angles[2]);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
    dpsnprintf(temp, sizeof(temp), "Color        : %.2f %.2f %.2f\n", r_shadow_selectedlight->color[0], r_shadow_selectedlight->color[1], r_shadow_selectedlight->color[2]);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
    dpsnprintf(temp, sizeof(temp), "Radius       : %.0f\n", r_shadow_selectedlight->radius);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
    dpsnprintf(temp, sizeof(temp), "Corona       : %.0f\n", r_shadow_selectedlight->corona);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
    dpsnprintf(temp, sizeof(temp), "Style        : %i\n", r_shadow_selectedlight->style);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
    dpsnprintf(temp, sizeof(temp), "Shadows      : %s\n", r_shadow_selectedlight->shadow ? "yes" : "no");DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
    dpsnprintf(temp, sizeof(temp), "Cubemap      : %s\n", r_shadow_selectedlight->cubemapname);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
    dpsnprintf(temp, sizeof(temp), "CoronaSize   : %.2f\n", r_shadow_selectedlight->coronasizescale);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
    dpsnprintf(temp, sizeof(temp), "Ambient      : %.2f\n", r_shadow_selectedlight->ambientscale);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
    dpsnprintf(temp, sizeof(temp), "Diffuse      : %.2f\n", r_shadow_selectedlight->diffusescale);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
    dpsnprintf(temp, sizeof(temp), "Specular     : %.2f\n", r_shadow_selectedlight->specularscale);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
    dpsnprintf(temp, sizeof(temp), "NormalMode   : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_NORMALMODE) ? "yes" : "no");DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
    dpsnprintf(temp, sizeof(temp), "RealTimeMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_REALTIMEMODE) ? "yes" : "no");DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT);y += 8;
    y += 8;
    dpsnprintf(temp, sizeof(temp), "Render stats\n"); DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT); y += 8;
    dpsnprintf(temp, sizeof(temp), "Current color: %.3f %.3f %.3f\n", r_shadow_selectedlight->rtlight.currentcolor[0], r_shadow_selectedlight->rtlight.currentcolor[1], r_shadow_selectedlight->rtlight.currentcolor[2]); DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT); y += 8;
    dpsnprintf(temp, sizeof(temp), "Shadow size  : %ix%ix6\n", r_shadow_selectedlight->rtlight.shadowmapatlassidesize, r_shadow_selectedlight->rtlight.shadowmapatlassidesize); DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT); y += 8;
    dpsnprintf(temp, sizeof(temp), "World surfs  : %i\n", r_shadow_selectedlight->rtlight.cached_numsurfaces); DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT); y += 8;
    dpsnprintf(temp, sizeof(temp), "Shadow ents  : %i + %i noself\n", r_shadow_selectedlight->rtlight.cached_numshadowentities, r_shadow_selectedlight->rtlight.cached_numshadowentities_noselfshadow); DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT); y += 8;
    dpsnprintf(temp, sizeof(temp), "Lit ents     : %i + %i noself\n", r_shadow_selectedlight->rtlight.cached_numlightentities, r_shadow_selectedlight->rtlight.cached_numlightentities_noselfshadow); DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT); y += 8;
    dpsnprintf(temp, sizeof(temp), "BG photons   : %.3f\n", r_shadow_selectedlight->rtlight.bouncegrid_photons); DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT); y += 8;
    dpsnprintf(temp, sizeof(temp), "BG radius    : %.0f\n", r_shadow_selectedlight->rtlight.bouncegrid_effectiveradius); DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT); y += 8;
    dpsnprintf(temp, sizeof(temp), "BG color     : %.3f %.3f %.3f\n", r_shadow_selectedlight->rtlight.bouncegrid_photoncolor[0], r_shadow_selectedlight->rtlight.bouncegrid_photoncolor[1], r_shadow_selectedlight->rtlight.bouncegrid_photoncolor[2]); DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT); y += 8;
    dpsnprintf(temp, sizeof(temp), "BG stats     : %i traces %i hits\n", r_shadow_selectedlight->rtlight.bouncegrid_traces, r_shadow_selectedlight->rtlight.bouncegrid_hits); DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_DEFAULT); y += 8;
}

Referenced by SCR_DrawScreen().

◆ R_Shadow_GetRTLightInfo()

int R_Shadow_GetRTLightInfo	(	unsigned int	lightindex,
		float *	origin,
		float *	radius,
		float *	color )

Definition at line 4777 of file r_shadow.c.

{
    unsigned int range;
    dlight_t *light;
    rtlight_t *rtlight;
    range = (unsigned int)Mem_ExpandableArray_IndexRange(&r_shadow_worldlightsarray);
    if (lightindex >= range)
        return -1;
    light = (dlight_t *) Mem_ExpandableArray_RecordAtIndex(&r_shadow_worldlightsarray, lightindex);
    if (!light)
        return 0;
    rtlight = &light->rtlight;
    //if (!(rtlight->flags & flag))
    //  return 0;
    VectorCopy(rtlight->shadoworigin, origin);
    *radius = rtlight->radius;
    VectorCopy(rtlight->color, color);
    return 1;
}

References color, rtlight_t::color, int(), Mem_ExpandableArray_IndexRange(), Mem_ExpandableArray_RecordAtIndex(), origin, r_shadow_worldlightsarray, rtlight_t::radius, dlight_t::rtlight, rtlight_t::shadoworigin, and VectorCopy.

Referenced by Mod_GenerateLightmaps_CreateLights(), and Mod_GenerateLightmaps_LightPoint().

◆ R_Shadow_Init()

void R_Shadow_Init ( void )

Definition at line 601 of file r_shadow.c.

{
    Cvar_RegisterVariable(&r_shadow_bumpscale_basetexture);
    Cvar_RegisterVariable(&r_shadow_bumpscale_bumpmap);
    Cvar_RegisterVariable(&r_shadow_usebihculling);
    Cvar_RegisterVariable(&r_shadow_usenormalmap);
    Cvar_RegisterVariable(&r_shadow_debuglight);
    Cvar_RegisterVariable(&r_shadow_deferred);
    Cvar_RegisterVariable(&r_shadow_gloss);
    Cvar_RegisterVariable(&r_shadow_gloss2intensity);
    Cvar_RegisterVariable(&r_shadow_glossintensity);
    Cvar_RegisterVariable(&r_shadow_glossexponent);
    Cvar_RegisterVariable(&r_shadow_gloss2exponent);
    Cvar_RegisterVariable(&r_shadow_glossexact);
    Cvar_RegisterVariable(&r_shadow_lightattenuationdividebias);
    Cvar_RegisterVariable(&r_shadow_lightattenuationlinearscale);
    Cvar_RegisterVariable(&r_shadow_lightintensityscale);
    Cvar_RegisterVariable(&r_shadow_lightradiusscale);
    Cvar_RegisterVariable(&r_shadow_projectdistance);
    Cvar_RegisterVariable(&r_shadow_frontsidecasting);
    Cvar_RegisterVariable(&r_shadow_realtime_world_importlightentitiesfrommap);
    Cvar_RegisterVariable(&r_shadow_realtime_dlight);
    Cvar_RegisterVariable(&r_shadow_realtime_dlight_shadows);
    Cvar_RegisterVariable(&r_shadow_realtime_dlight_svbspculling);
    Cvar_RegisterVariable(&r_shadow_realtime_dlight_portalculling);
    Cvar_RegisterVariable(&r_shadow_realtime_world);
    Cvar_RegisterVariable(&r_shadow_realtime_world_lightmaps);
    Cvar_RegisterVariable(&r_shadow_realtime_world_shadows);
    Cvar_RegisterVariable(&r_shadow_realtime_world_compile);
    Cvar_RegisterVariable(&r_shadow_realtime_world_compileshadow);
    Cvar_RegisterVariable(&r_shadow_realtime_world_compilesvbsp);
    Cvar_RegisterVariable(&r_shadow_realtime_world_compileportalculling);
    Cvar_RegisterVariable(&r_shadow_scissor);
    Cvar_RegisterVariable(&r_shadow_shadowmapping);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_vsdct);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_filterquality);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_useshadowsampler);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_depthbits);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_precision);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_maxsize);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_minsize);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_texturesize);
//  Cvar_RegisterVariable(&r_shadow_shadowmapping_lod_bias);
//  Cvar_RegisterVariable(&r_shadow_shadowmapping_lod_scale);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_bordersize);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_nearclip);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_bias);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonfactor);
    Cvar_RegisterVariable(&r_shadow_shadowmapping_polygonoffset);
    Cvar_RegisterVariable(&r_shadow_sortsurfaces);
    Cvar_RegisterVariable(&r_shadow_culllights_pvs);
    Cvar_RegisterVariable(&r_shadow_culllights_trace);
    Cvar_RegisterVariable(&r_shadow_culllights_trace_eyejitter);
    Cvar_RegisterVariable(&r_shadow_culllights_trace_enlarge);
    Cvar_RegisterVariable(&r_shadow_culllights_trace_expand);
    Cvar_RegisterVariable(&r_shadow_culllights_trace_pad);
    Cvar_RegisterVariable(&r_shadow_culllights_trace_samples);
    Cvar_RegisterVariable(&r_shadow_culllights_trace_tempsamples);
    Cvar_RegisterVariable(&r_shadow_culllights_trace_delay);
    Cvar_RegisterVariable(&r_shadow_bouncegrid);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_blur);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_bounceminimumintensity);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_culllightpaths);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_directionalshading);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_dlightparticlemultiplier);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_hitmodels);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_lightradiusscale);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_maxbounce);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_maxphotons);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_quality);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_spacing);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_updateinterval);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_x);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_y);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_dynamic_z);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_floatcolors);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_includedirectlighting);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_intensity);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_lightpathsize);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_normalizevectors);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_particlebounceintensity);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_particleintensity);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_rng_seed);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_rng_type);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_static);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_static_bounceminimumintensity);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_static_directionalshading);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_static_lightradiusscale);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_static_maxbounce);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_static_maxphotons);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_static_quality);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_static_spacing);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_subsamples);
    Cvar_RegisterVariable(&r_shadow_bouncegrid_threaded);
    Cvar_RegisterVariable(&r_coronas);
    Cvar_RegisterVariable(&r_coronas_occlusionsizescale);
    Cvar_RegisterVariable(&r_coronas_occlusionquery);
    Cvar_RegisterVariable(&gl_flashblend);
    R_Shadow_EditLights_Init();
    Mem_ExpandableArray_NewArray(&r_shadow_worldlightsarray, r_main_mempool, sizeof(dlight_t), 128);
    r_shadow_scenemaxlights = 0;
    r_shadow_scenenumlights = 0;
    r_shadow_scenelightlist = NULL;
    maxshadowtriangles = 0;
    shadowelements = NULL;
    maxshadowvertices = 0;
    shadowvertex3f = NULL;
    maxvertexupdate = 0;
    vertexupdate = NULL;
    vertexremap = NULL;
    vertexupdatenum = 0;
    maxshadowmark = 0;
    numshadowmark = 0;
    shadowmark = NULL;
    shadowmarklist = NULL;
    shadowmarkcount = 0;
    maxshadowsides = 0;
    numshadowsides = 0;
    shadowsides = NULL;
    shadowsideslist = NULL;
    r_shadow_buffer_numleafpvsbytes = 0;
    r_shadow_buffer_visitingleafpvs = NULL;
    r_shadow_buffer_leafpvs = NULL;
    r_shadow_buffer_leaflist = NULL;
    r_shadow_buffer_numsurfacepvsbytes = 0;
    r_shadow_buffer_surfacepvs = NULL;
    r_shadow_buffer_surfacelist = NULL;
    r_shadow_buffer_surfacesides = NULL;
    r_shadow_buffer_shadowtrispvs = NULL;
    r_shadow_buffer_lighttrispvs = NULL;
    R_RegisterModule("R_Shadow", r_shadow_start, r_shadow_shutdown, r_shadow_newmap, NULL, NULL);
}

Referenced by Render_Init().

◆ R_Shadow_UpdateBounceGridTexture()

void R_Shadow_UpdateBounceGridTexture ( void )

Definition at line 2755 of file r_shadow.c.

{
    int flag = r_refdef.scene.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE;
    r_shadow_bouncegrid_settings_t settings;
    qbool enable = false;
    qbool settingschanged;
 
    enable = R_Shadow_BounceGrid_CheckEnable(flag);
    
    R_Shadow_BounceGrid_GenerateSettings(&settings);
    
    // changing intensity does not require an update
    r_shadow_bouncegrid_state.intensity = r_shadow_bouncegrid_intensity.value;
 
    settingschanged = memcmp(&r_shadow_bouncegrid_state.settings, &settings, sizeof(settings)) != 0;
 
    // when settings change, we free everything as it is just simpler that way.
    if (settingschanged || !enable)
    {
        // not enabled, make sure we free anything we don't need anymore.
        if (r_shadow_bouncegrid_state.texture)
        {
            R_FreeTexture(r_shadow_bouncegrid_state.texture);
            r_shadow_bouncegrid_state.texture = NULL;
        }
        R_Shadow_BounceGrid_FreeHighPixels();
        r_shadow_bouncegrid_state.numpixels = 0;
        r_shadow_bouncegrid_state.numphotons = 0;
        r_shadow_bouncegrid_state.directional = false;
 
        if (!enable)
            return;
    }
 
    // if all the settings seem identical to the previous update, return
    if (r_shadow_bouncegrid_state.texture && (settings.staticmode || host.realtime < r_shadow_bouncegrid_state.lastupdatetime + r_shadow_bouncegrid_dynamic_updateinterval.value) && !settingschanged)
        return;
 
    // store the new settings
    r_shadow_bouncegrid_state.settings = settings;
 
    R_Shadow_BounceGrid_UpdateSpacing();
 
    // allocate the highpixels array we'll be accumulating light into
    if (r_shadow_bouncegrid_state.blurpixels[0] == NULL)
        r_shadow_bouncegrid_state.blurpixels[0] = (float *)Mem_Alloc(r_main_mempool, r_shadow_bouncegrid_state.numpixels * sizeof(float[4]));
    if (r_shadow_bouncegrid_state.settings.blur && r_shadow_bouncegrid_state.blurpixels[1] == NULL)
        r_shadow_bouncegrid_state.blurpixels[1] = (float *)Mem_Alloc(r_main_mempool, r_shadow_bouncegrid_state.numpixels * sizeof(float[4]));
    r_shadow_bouncegrid_state.highpixels_index = 0;
    r_shadow_bouncegrid_state.highpixels = r_shadow_bouncegrid_state.blurpixels[r_shadow_bouncegrid_state.highpixels_index];
 
    // set up the tracking of photon data
    if (r_shadow_bouncegrid_state.photons == NULL)
        r_shadow_bouncegrid_state.photons = (r_shadow_bouncegrid_photon_t *)Mem_Alloc(r_main_mempool, r_shadow_bouncegrid_state.settings.maxphotons * sizeof(r_shadow_bouncegrid_photon_t));
    if (r_shadow_bouncegrid_state.photons_tasks == NULL)
        r_shadow_bouncegrid_state.photons_tasks = (taskqueue_task_t *)Mem_Alloc(r_main_mempool, r_shadow_bouncegrid_state.settings.maxphotons * sizeof(taskqueue_task_t));
    r_shadow_bouncegrid_state.numphotons = 0;
 
    // set up the tracking of slice tasks
    if (r_shadow_bouncegrid_state.slices_tasks == NULL)
        r_shadow_bouncegrid_state.slices_tasks = (taskqueue_task_t *)Mem_Alloc(r_main_mempool, r_shadow_bouncegrid_state.resolution[2] * sizeof(taskqueue_task_t));
 
    memset(&r_shadow_bouncegrid_state.cleartex_task, 0, sizeof(taskqueue_task_t));
    memset(&r_shadow_bouncegrid_state.assignphotons_task, 0, sizeof(taskqueue_task_t));
    memset(&r_shadow_bouncegrid_state.enqueuephotons_task, 0, sizeof(taskqueue_task_t));
    memset(r_shadow_bouncegrid_state.photons_tasks, 0, r_shadow_bouncegrid_state.settings.maxphotons * sizeof(taskqueue_task_t));
    memset(&r_shadow_bouncegrid_state.photons_done_task, 0, sizeof(taskqueue_task_t));
    memset(&r_shadow_bouncegrid_state.enqueue_slices_task, 0, sizeof(taskqueue_task_t));
    memset(r_shadow_bouncegrid_state.slices_tasks, 0, r_shadow_bouncegrid_state.resolution[2] * sizeof(taskqueue_task_t));
    memset(&r_shadow_bouncegrid_state.slices_done_task, 0, sizeof(taskqueue_task_t));
    memset(&r_shadow_bouncegrid_state.blurpixels_task, 0, sizeof(taskqueue_task_t));
 
    // clear the texture
    TaskQueue_Setup(&r_shadow_bouncegrid_state.cleartex_task, NULL, R_Shadow_BounceGrid_ClearTex_Task, 0, 0, NULL, NULL);
    TaskQueue_Enqueue(1, &r_shadow_bouncegrid_state.cleartex_task);
 
    // calculate weighting factors for distributing photons among the lights
    TaskQueue_Setup(&r_shadow_bouncegrid_state.assignphotons_task, NULL, R_Shadow_BounceGrid_AssignPhotons_Task, 0, 0, NULL, NULL);
    TaskQueue_Enqueue(1, &r_shadow_bouncegrid_state.assignphotons_task);
 
    // enqueue tasks to trace the photons from lights
    TaskQueue_Setup(&r_shadow_bouncegrid_state.enqueuephotons_task, &r_shadow_bouncegrid_state.assignphotons_task, R_Shadow_BounceGrid_EnqueuePhotons_Task, 0, 0, NULL, NULL);
    TaskQueue_Enqueue(1, &r_shadow_bouncegrid_state.enqueuephotons_task);
 
    // accumulate the light paths into texture
    TaskQueue_Setup(&r_shadow_bouncegrid_state.enqueue_slices_task, &r_shadow_bouncegrid_state.photons_done_task, R_Shadow_BounceGrid_EnqueueSlices_Task, 0, 0, NULL, NULL);
    TaskQueue_Enqueue(1, &r_shadow_bouncegrid_state.enqueue_slices_task);
 
    // apply a mild blur filter to the texture
    TaskQueue_Setup(&r_shadow_bouncegrid_state.blurpixels_task, &r_shadow_bouncegrid_state.slices_done_task, R_Shadow_BounceGrid_BlurPixels_Task, 0, 0, NULL, NULL);
    TaskQueue_Enqueue(1, &r_shadow_bouncegrid_state.blurpixels_task);
 
    TaskQueue_WaitForTaskDone(&r_shadow_bouncegrid_state.blurpixels_task);
    R_TimeReport("bouncegrid_gen");
 
    // convert the pixels to lower precision and upload the texture
    // this unfortunately has to run on the main thread for OpenGL calls, so we have to block on the previous task...
    R_Shadow_BounceGrid_ConvertPixelsAndUpload();
    R_TimeReport("bouncegrid_tex");
 
    // after we compute the static lighting we don't need to keep the highpixels array around
    if (settings.staticmode)
        R_Shadow_BounceGrid_FreeHighPixels();
}

References host, LIGHTFLAG_NORMALMODE, LIGHTFLAG_REALTIMEMODE, Mem_Alloc, NULL, R_FreeTexture(), r_main_mempool, r_refdef, R_Shadow_BounceGrid_AssignPhotons_Task(), R_Shadow_BounceGrid_BlurPixels_Task(), R_Shadow_BounceGrid_CheckEnable(), R_Shadow_BounceGrid_ClearTex_Task(), R_Shadow_BounceGrid_ConvertPixelsAndUpload(), r_shadow_bouncegrid_dynamic_updateinterval, R_Shadow_BounceGrid_EnqueuePhotons_Task(), R_Shadow_BounceGrid_EnqueueSlices_Task(), R_Shadow_BounceGrid_FreeHighPixels(), R_Shadow_BounceGrid_GenerateSettings(), r_shadow_bouncegrid_intensity, r_shadow_bouncegrid_state, R_Shadow_BounceGrid_UpdateSpacing(), R_TimeReport(), r_shadow_bouncegrid_settings_t::staticmode, TaskQueue_Enqueue(), TaskQueue_Setup(), and TaskQueue_WaitForTaskDone().

Referenced by R_RenderView().

◆ R_SkinFrame_Find()

skinframe_t * R_SkinFrame_Find	(	const char *	name,
		int	textureflags,
		int	comparewidth,
		int	compareheight,
		int	comparecrc,
		qbool	add )

Definition at line 2240 of file gl_rmain.c.

{
    skinframe_t *item;
    int compareflags = textureflags & TEXF_IMPORTANTBITS;
    int hashindex;
    char basename[MAX_QPATH];
 
    Image_StripImageExtension(name, basename, sizeof(basename));
 
    hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
    for (item = r_skinframe.hash[hashindex];item;item = item->next)
        if (!strcmp(item->basename, basename) &&
            item->textureflags == compareflags &&
            item->comparewidth == comparewidth &&
            item->compareheight == compareheight &&
            item->comparecrc == comparecrc)
            break;
 
    if (!item)
    {
        if (!add)
            return NULL;
        item = (skinframe_t *)Mem_ExpandableArray_AllocRecord(&r_skinframe.array);
        memset(item, 0, sizeof(*item));
        dp_strlcpy(item->basename, basename, sizeof(item->basename));
        item->textureflags = compareflags;
        item->comparewidth = comparewidth;
        item->compareheight = compareheight;
        item->comparecrc = comparecrc;
        item->next = r_skinframe.hash[hashindex];
        r_skinframe.hash[hashindex] = item;
    }
    else if (textureflags & TEXF_FORCE_RELOAD)
        R_SkinFrame_PurgeSkinFrame(item);
 
    R_SkinFrame_MarkUsed(item);
    return item;
}

References skinframe_t::basename, skinframe_t::comparecrc, skinframe_t::compareheight, skinframe_t::comparewidth, CRC_Block(), dp_strlcpy, Image_StripImageExtension(), MAX_QPATH, Mem_ExpandableArray_AllocRecord(), name, skinframe_t::next, NULL, r_skinframe, R_SkinFrame_MarkUsed(), R_SkinFrame_PurgeSkinFrame(), SKINFRAME_HASH, strlen(), TEXF_FORCE_RELOAD, TEXF_IMPORTANTBITS, and skinframe_t::textureflags.

Referenced by R_LoadQWSkin(), R_SkinFrame_LoadExternal(), R_SkinFrame_LoadExternal_SkinFrame(), R_SkinFrame_LoadInternal8bit(), R_SkinFrame_LoadInternalBGRA(), R_SkinFrame_LoadInternalQuake(), R_SkinFrame_LoadInternalUsingTexture(), and R_SkinFrame_LoadMissing().

◆ R_SkinFrame_FindNextByName()

skinframe_t * R_SkinFrame_FindNextByName	(	skinframe_t *	last,
		const char *	name )

Definition at line 2217 of file gl_rmain.c.

                                                                               {
    skinframe_t *item;
    char basename[MAX_QPATH];
 
    Image_StripImageExtension(name, basename, sizeof(basename));
 
    if( last == NULL ) {
        int hashindex;
        hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
        item = r_skinframe.hash[hashindex];
    } else {
        item = last->next;
    }
 
    // linearly search through the hash bucket
    for( ; item ; item = item->next ) {
        if( !strcmp( item->basename, basename ) ) {
            return item;
        }
    }
    return NULL;
}

References skinframe_t::basename, CRC_Block(), Image_StripImageExtension(), MAX_QPATH, name, skinframe_t::next, NULL, r_skinframe, SKINFRAME_HASH, and strlen().

◆ R_SkinFrame_LoadExternal()

skinframe_t * R_SkinFrame_LoadExternal	(	const char *	name,
		int	textureflags,
		qbool	complain,
		qbool	fallbacknotexture )

Definition at line 2314 of file gl_rmain.c.

{
    skinframe_t *skinframe;
 
    if (cls.state == ca_dedicated)
        return NULL;
 
    // return an existing skinframe if already loaded
    skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
    if (skinframe && skinframe->base)
        return skinframe;
 
    // if the skinframe doesn't exist this will create it
    return R_SkinFrame_LoadExternal_SkinFrame(skinframe, name, textureflags, complain, fallbacknotexture);
}

References skinframe_t::base, ca_dedicated, cls, name, NULL, R_SkinFrame_Find(), and R_SkinFrame_LoadExternal_SkinFrame().

Referenced by Draw_CachePic_Flags(), Draw_GetPicTexture(), Draw_IsPicLoaded(), Mod_CreateShaderPassFromQ3ShaderLayer(), Mod_IDP0_Load(), Mod_IDS2_Load(), Mod_LoadTextureFromQ3Shader(), Mod_Q1BSP_LoadTextures(), Mod_Sprite_SharedSetup(), R_InitParticleTexture(), and R_ReplaceWorldTexture_f().

◆ R_SkinFrame_LoadExternal_SkinFrame()

skinframe_t * R_SkinFrame_LoadExternal_SkinFrame	(	skinframe_t *	skinframe,
		const char *	name,
		int	textureflags,
		qbool	complain,
		qbool	fallbacknotexture )

Definition at line 2331 of file gl_rmain.c.

{
    int j;
    unsigned char *pixels;
    unsigned char *bumppixels;
    unsigned char *basepixels = NULL;
    int basepixels_width = 0;
    int basepixels_height = 0;
    rtexture_t *ddsbase = NULL;
    qbool ddshasalpha = false;
    float ddsavgcolor[4];
    char basename[MAX_QPATH];
    int miplevel = R_PicmipForFlags(textureflags);
    int savemiplevel = miplevel;
    int mymiplevel;
    char vabuf[1024];
 
    if (cls.state == ca_dedicated)
        return NULL;
 
    Image_StripImageExtension(name, basename, sizeof(basename));
 
    // check for DDS texture file first
    if (!r_loaddds || !(ddsbase = R_LoadTextureDDSFile(r_main_texturepool, va(vabuf, sizeof(vabuf), "dds/%s.dds", basename), vid.sRGB3D, textureflags, &ddshasalpha, ddsavgcolor, miplevel, false)))
    {
        basepixels = loadimagepixelsbgra(name, complain, true, false, &miplevel);
        if (basepixels == NULL && fallbacknotexture)
            basepixels = Image_GenerateNoTexture();
        if (basepixels == NULL)
            return NULL;
    }
 
    // FIXME handle miplevel
 
    if (developer_loading.integer)
        Con_Printf("loading skin \"%s\"\n", name);
 
    // we've got some pixels to store, so really allocate this new texture now
    if (!skinframe)
        skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, true);
    textureflags &= ~TEXF_FORCE_RELOAD;
    skinframe->stain = NULL;
    skinframe->merged = NULL;
    skinframe->base = NULL;
    skinframe->pants = NULL;
    skinframe->shirt = NULL;
    skinframe->nmap = NULL;
    skinframe->gloss = NULL;
    skinframe->glow = NULL;
    skinframe->fog = NULL;
    skinframe->reflect = NULL;
    skinframe->hasalpha = false;
    // we could store the q2animname here too
 
    if (ddsbase)
    {
        skinframe->base = ddsbase;
        skinframe->hasalpha = ddshasalpha;
        VectorCopy(ddsavgcolor, skinframe->avgcolor);
        if (r_loadfog && skinframe->hasalpha)
            skinframe->fog = R_LoadTextureDDSFile(r_main_texturepool, va(vabuf, sizeof(vabuf), "dds/%s_mask.dds", skinframe->basename), false, textureflags | TEXF_ALPHA, NULL, NULL, miplevel, true);
        //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]);
    }
    else
    {
        basepixels_width = image_width;
        basepixels_height = image_height;
        skinframe->base = R_LoadTexture2D (r_main_texturepool, skinframe->basename, basepixels_width, basepixels_height, basepixels, vid.sRGB3D ? TEXTYPE_SRGB_BGRA : TEXTYPE_BGRA, textureflags & (gl_texturecompression_color.integer && gl_texturecompression.integer ? ~0 : ~TEXF_COMPRESS), miplevel, NULL);
        if (textureflags & TEXF_ALPHA)
        {
            for (j = 3;j < basepixels_width * basepixels_height * 4;j += 4)
            {
                if (basepixels[j] < 255)
                {
                    skinframe->hasalpha = true;
                    break;
                }
            }
            if (r_loadfog && skinframe->hasalpha)
            {
                // has transparent pixels
                pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
                for (j = 0;j < image_width * image_height * 4;j += 4)
                {
                    pixels[j+0] = 255;
                    pixels[j+1] = 255;
                    pixels[j+2] = 255;
                    pixels[j+3] = basepixels[j+3];
                }
                skinframe->fog = R_LoadTexture2D (r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_mask", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, textureflags & (gl_texturecompression_color.integer && gl_texturecompression.integer ? ~0 : ~TEXF_COMPRESS), miplevel, NULL);
                Mem_Free(pixels);
            }
        }
        R_SKINFRAME_LOAD_AVERAGE_COLORS(basepixels_width * basepixels_height, basepixels[4 * pix + comp]);
#ifndef USE_GLES2
        //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]);
        if (r_savedds && skinframe->base)
            R_SaveTextureDDSFile(skinframe->base, va(vabuf, sizeof(vabuf), "dds/%s.dds", skinframe->basename), r_texture_dds_save.integer < 2, skinframe->hasalpha);
        if (r_savedds && skinframe->fog)
            R_SaveTextureDDSFile(skinframe->fog, va(vabuf, sizeof(vabuf), "dds/%s_mask.dds", skinframe->basename), r_texture_dds_save.integer < 2, true);
#endif
    }
 
    if (r_loaddds)
    {
        mymiplevel = savemiplevel;
        if (r_loadnormalmap)
            skinframe->nmap = R_LoadTextureDDSFile(r_main_texturepool, va(vabuf, sizeof(vabuf), "dds/%s_norm.dds", skinframe->basename), false, (TEXF_ALPHA | textureflags) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP), NULL, NULL, mymiplevel, true);
        skinframe->glow = R_LoadTextureDDSFile(r_main_texturepool, va(vabuf, sizeof(vabuf), "dds/%s_glow.dds", skinframe->basename), vid.sRGB3D, textureflags, NULL, NULL, mymiplevel, true);
        if (r_loadgloss)
            skinframe->gloss = R_LoadTextureDDSFile(r_main_texturepool, va(vabuf, sizeof(vabuf), "dds/%s_gloss.dds", skinframe->basename), vid.sRGB3D, textureflags, NULL, NULL, mymiplevel, true);
        skinframe->pants = R_LoadTextureDDSFile(r_main_texturepool, va(vabuf, sizeof(vabuf), "dds/%s_pants.dds", skinframe->basename), vid.sRGB3D, textureflags, NULL, NULL, mymiplevel, true);
        skinframe->shirt = R_LoadTextureDDSFile(r_main_texturepool, va(vabuf, sizeof(vabuf), "dds/%s_shirt.dds", skinframe->basename), vid.sRGB3D, textureflags, NULL, NULL, mymiplevel, true);
        skinframe->reflect = R_LoadTextureDDSFile(r_main_texturepool, va(vabuf, sizeof(vabuf), "dds/%s_reflect.dds", skinframe->basename), vid.sRGB3D, textureflags, NULL, NULL, mymiplevel, true);
    }
 
    // _norm is the name used by tenebrae and has been adopted as standard
    if (r_loadnormalmap && skinframe->nmap == NULL)
    {
        mymiplevel = savemiplevel;
        if ((pixels = loadimagepixelsbgra(va(vabuf, sizeof(vabuf), "%s_norm", skinframe->basename), false, false, false, &mymiplevel)) != NULL)
        {
            skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, (TEXF_ALPHA | textureflags) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP) & (gl_texturecompression_normal.integer && gl_texturecompression.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
            Mem_Free(pixels);
            pixels = NULL;
        }
        else if (r_shadow_bumpscale_bumpmap.value > 0 && (bumppixels = loadimagepixelsbgra(va(vabuf, sizeof(vabuf), "%s_bump", skinframe->basename), false, false, false, &mymiplevel)) != NULL)
        {
            pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
            Image_HeightmapToNormalmap_BGRA(bumppixels, pixels, image_width, image_height, false, r_shadow_bumpscale_bumpmap.value);
            skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, (TEXF_ALPHA | textureflags) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP) & (gl_texturecompression_normal.integer && gl_texturecompression.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
            Mem_Free(pixels);
            Mem_Free(bumppixels);
        }
        else if (r_shadow_bumpscale_basetexture.value > 0)
        {
            pixels = (unsigned char *)Mem_Alloc(tempmempool, basepixels_width * basepixels_height * 4);
            Image_HeightmapToNormalmap_BGRA(basepixels, pixels, basepixels_width, basepixels_height, false, r_shadow_bumpscale_basetexture.value);
            skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_nmap", skinframe->basename), basepixels_width, basepixels_height, pixels, TEXTYPE_BGRA, (TEXF_ALPHA | textureflags) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP) & (gl_texturecompression_normal.integer && gl_texturecompression.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
            Mem_Free(pixels);
        }
#ifndef USE_GLES2
        if (r_savedds && skinframe->nmap)
            R_SaveTextureDDSFile(skinframe->nmap, va(vabuf, sizeof(vabuf), "dds/%s_norm.dds", skinframe->basename), r_texture_dds_save.integer < 2, true);
#endif
    }
 
    // _luma is supported only for tenebrae compatibility
    // _blend and .blend are supported only for Q3 & QL compatibility, this hack can be removed if better Q3 shader support is implemented
    // _glow is the preferred name
    mymiplevel = savemiplevel;
    if (skinframe->glow == NULL && ((pixels = loadimagepixelsbgra(va(vabuf, sizeof(vabuf), "%s_glow", skinframe->basename), false, false, false, &mymiplevel)) || (pixels = loadimagepixelsbgra(va(vabuf, sizeof(vabuf), "%s.blend", skinframe->basename), false, false, false, &mymiplevel)) || (pixels = loadimagepixelsbgra(va(vabuf, sizeof(vabuf), "%s_blend", skinframe->basename), false, false, false, &mymiplevel)) || (pixels = loadimagepixelsbgra(va(vabuf, sizeof(vabuf), "%s_luma", skinframe->basename), false, false, false, &mymiplevel))))
    {
        skinframe->glow = R_LoadTexture2D (r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_glow", skinframe->basename), image_width, image_height, pixels, vid.sRGB3D ? TEXTYPE_SRGB_BGRA : TEXTYPE_BGRA, textureflags & (gl_texturecompression_glow.integer && gl_texturecompression.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
#ifndef USE_GLES2
        if (r_savedds && skinframe->glow)
            R_SaveTextureDDSFile(skinframe->glow, va(vabuf, sizeof(vabuf), "dds/%s_glow.dds", skinframe->basename), r_texture_dds_save.integer < 2, true);
#endif
        Mem_Free(pixels);pixels = NULL;
    }
 
    mymiplevel = savemiplevel;
    if (skinframe->gloss == NULL && r_loadgloss && (pixels = loadimagepixelsbgra(va(vabuf, sizeof(vabuf), "%s_gloss", skinframe->basename), false, false, false, &mymiplevel)))
    {
        skinframe->gloss = R_LoadTexture2D (r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_gloss", skinframe->basename), image_width, image_height, pixels, vid.sRGB3D ? TEXTYPE_SRGB_BGRA : TEXTYPE_BGRA, (TEXF_ALPHA | textureflags) & (gl_texturecompression_gloss.integer && gl_texturecompression.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
#ifndef USE_GLES2
        if (r_savedds && skinframe->gloss)
            R_SaveTextureDDSFile(skinframe->gloss, va(vabuf, sizeof(vabuf), "dds/%s_gloss.dds", skinframe->basename), r_texture_dds_save.integer < 2, true);
#endif
        Mem_Free(pixels);
        pixels = NULL;
    }
 
    mymiplevel = savemiplevel;
    if (skinframe->pants == NULL && (pixels = loadimagepixelsbgra(va(vabuf, sizeof(vabuf), "%s_pants", skinframe->basename), false, false, false, &mymiplevel)))
    {
        skinframe->pants = R_LoadTexture2D (r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_pants", skinframe->basename), image_width, image_height, pixels, vid.sRGB3D ? TEXTYPE_SRGB_BGRA : TEXTYPE_BGRA, textureflags & (gl_texturecompression_color.integer && gl_texturecompression.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
#ifndef USE_GLES2
        if (r_savedds && skinframe->pants)
            R_SaveTextureDDSFile(skinframe->pants, va(vabuf, sizeof(vabuf), "dds/%s_pants.dds", skinframe->basename), r_texture_dds_save.integer < 2, false);
#endif
        Mem_Free(pixels);
        pixels = NULL;
    }
 
    mymiplevel = savemiplevel;
    if (skinframe->shirt == NULL && (pixels = loadimagepixelsbgra(va(vabuf, sizeof(vabuf), "%s_shirt", skinframe->basename), false, false, false, &mymiplevel)))
    {
        skinframe->shirt = R_LoadTexture2D (r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_shirt", skinframe->basename), image_width, image_height, pixels, vid.sRGB3D ? TEXTYPE_SRGB_BGRA : TEXTYPE_BGRA, textureflags & (gl_texturecompression_color.integer && gl_texturecompression.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
#ifndef USE_GLES2
        if (r_savedds && skinframe->shirt)
            R_SaveTextureDDSFile(skinframe->shirt, va(vabuf, sizeof(vabuf), "dds/%s_shirt.dds", skinframe->basename), r_texture_dds_save.integer < 2, false);
#endif
        Mem_Free(pixels);
        pixels = NULL;
    }
 
    mymiplevel = savemiplevel;
    if (skinframe->reflect == NULL && (pixels = loadimagepixelsbgra(va(vabuf, sizeof(vabuf), "%s_reflect", skinframe->basename), false, false, false, &mymiplevel)))
    {
        skinframe->reflect = R_LoadTexture2D (r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_reflect", skinframe->basename), image_width, image_height, pixels, vid.sRGB3D ? TEXTYPE_SRGB_BGRA : TEXTYPE_BGRA, textureflags & (gl_texturecompression_reflectmask.integer && gl_texturecompression.integer ? ~0 : ~TEXF_COMPRESS), mymiplevel, NULL);
#ifndef USE_GLES2
        if (r_savedds && skinframe->reflect)
            R_SaveTextureDDSFile(skinframe->reflect, va(vabuf, sizeof(vabuf), "dds/%s_reflect.dds", skinframe->basename), r_texture_dds_save.integer < 2, true);
#endif
        Mem_Free(pixels);
        pixels = NULL;
    }
 
    if (basepixels)
        Mem_Free(basepixels);
 
    return skinframe;
}

References skinframe_t::avgcolor, skinframe_t::base, skinframe_t::basename, ca_dedicated, cls, Con_Printf(), developer_loading, skinframe_t::fog, gl_texturecompression, gl_texturecompression_color, gl_texturecompression_gloss, gl_texturecompression_glow, gl_texturecompression_normal, gl_texturecompression_reflectmask, skinframe_t::gloss, skinframe_t::glow, skinframe_t::hasalpha, Image_GenerateNoTexture(), image_height, Image_HeightmapToNormalmap_BGRA(), Image_StripImageExtension(), image_width, loadimagepixelsbgra(), MAX_QPATH, Mem_Alloc, Mem_Free, skinframe_t::merged, name, skinframe_t::nmap, NULL, skinframe_t::pants, pixels, r_loaddds, r_loadfog, r_loadgloss, r_loadnormalmap, R_LoadTexture2D(), R_LoadTextureDDSFile(), r_main_texturepool, r_mipnormalmaps, R_PicmipForFlags(), r_savedds, R_SaveTextureDDSFile(), r_shadow_bumpscale_basetexture, r_shadow_bumpscale_bumpmap, R_SkinFrame_Find(), R_SKINFRAME_LOAD_AVERAGE_COLORS, r_texture_dds_save, skinframe_t::reflect, skinframe_t::shirt, skinframe_t::stain, tempmempool, TEXF_ALPHA, TEXF_COMPRESS, TEXF_FORCE_RELOAD, TEXF_MIPMAP, TEXTYPE_BGRA, TEXTYPE_SRGB_BGRA, va(), VectorCopy, and vid.

Referenced by Draw_CachePic_Flags(), and R_SkinFrame_LoadExternal().

◆ R_SkinFrame_LoadInternal8bit()

skinframe_t * R_SkinFrame_LoadInternal8bit	(	const char *	name,
		int	textureflags,
		const unsigned char *	skindata,
		int	width,
		int	height,
		const unsigned int *	palette,
		const unsigned int *	alphapalette )

Definition at line 2749 of file gl_rmain.c.

{
    int i;
    skinframe_t *skinframe;
    char vabuf[1024];
 
    if (cls.state == ca_dedicated)
        return NULL;
 
    // if already loaded just return it, otherwise make a new skinframe
    skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height) : 0, true);
    if (skinframe->base)
        return skinframe;
    textureflags &= ~TEXF_FORCE_RELOAD;
 
    skinframe->stain = NULL;
    skinframe->merged = NULL;
    skinframe->base = NULL;
    skinframe->pants = NULL;
    skinframe->shirt = NULL;
    skinframe->nmap = NULL;
    skinframe->gloss = NULL;
    skinframe->glow = NULL;
    skinframe->fog = NULL;
    skinframe->reflect = NULL;
    skinframe->hasalpha = false;
 
    // if no data was provided, then clearly the caller wanted to get a blank skinframe
    if (!skindata)
        return NULL;
 
    if (developer_loading.integer)
        Con_Printf("loading embedded 8bit image \"%s\"\n", name);
 
    skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_PALETTE, textureflags, -1, palette);
    if ((textureflags & TEXF_ALPHA) && alphapalette)
    {
        for (i = 0;i < width * height;i++)
        {
            if (((unsigned char *)palette)[skindata[i]*4+3] < 255)
            {
                skinframe->hasalpha = true;
                break;
            }
        }
        if (r_loadfog && skinframe->hasalpha)
            skinframe->fog = R_LoadTexture2D(r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_fog", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, textureflags, -1, alphapalette);
    }
 
    R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, ((unsigned char *)palette)[skindata[pix]*4 + comp]);
    //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]);
 
    return skinframe;
}

References skinframe_t::base, skinframe_t::basename, ca_dedicated, cls, Con_Printf(), CRC_Block(), developer_loading, skinframe_t::fog, skinframe_t::gloss, skinframe_t::glow, skinframe_t::hasalpha, height, skinframe_t::merged, name, skinframe_t::nmap, NULL, skinframe_t::pants, r_loadfog, R_LoadTexture2D(), r_main_texturepool, R_SkinFrame_Find(), R_SKINFRAME_LOAD_AVERAGE_COLORS, skinframe_t::reflect, skinframe_t::shirt, skinframe_t::stain, TEXF_ALPHA, TEXF_FORCE_RELOAD, TEXTYPE_PALETTE, va(), and width.

Referenced by R_Shadow_MakeTextures().

◆ R_SkinFrame_LoadInternalBGRA()

skinframe_t * R_SkinFrame_LoadInternalBGRA	(	const char *	name,
		int	textureflags,
		const unsigned char *	skindata,
		int	width,
		int	height,
		int	comparewidth,
		int	compareheight,
		int	comparecrc,
		qbool	sRGB )

Definition at line 2546 of file gl_rmain.c.

{
    int i;
    skinframe_t *skinframe;
    char vabuf[1024];
 
    if (cls.state == ca_dedicated)
        return NULL;
 
    // if already loaded just return it, otherwise make a new skinframe
    skinframe = R_SkinFrame_Find(name, textureflags, comparewidth, compareheight, comparecrc, true);
    if (skinframe->base)
        return skinframe;
    textureflags &= ~TEXF_FORCE_RELOAD;
 
    skinframe->stain = NULL;
    skinframe->merged = NULL;
    skinframe->base = NULL;
    skinframe->pants = NULL;
    skinframe->shirt = NULL;
    skinframe->nmap = NULL;
    skinframe->gloss = NULL;
    skinframe->glow = NULL;
    skinframe->fog = NULL;
    skinframe->reflect = NULL;
    skinframe->hasalpha = false;
 
    // if no data was provided, then clearly the caller wanted to get a blank skinframe
    if (!skindata)
        return NULL;
 
    if (developer_loading.integer)
        Con_Printf("loading 32bit skin \"%s\"\n", name);
 
    if (r_loadnormalmap && r_shadow_bumpscale_basetexture.value > 0)
    {
        unsigned char *a = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
        unsigned char *b = a + width * height * 4;
        Image_HeightmapToNormalmap_BGRA(skindata, b, width, height, false, r_shadow_bumpscale_basetexture.value);
        skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_nmap", skinframe->basename), width, height, b, TEXTYPE_BGRA, (textureflags | TEXF_ALPHA) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP), -1, NULL);
        Mem_Free(a);
    }
    skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, sRGB ? TEXTYPE_SRGB_BGRA : TEXTYPE_BGRA, textureflags, -1, NULL);
    if (textureflags & TEXF_ALPHA)
    {
        for (i = 3;i < width * height * 4;i += 4)
        {
            if (skindata[i] < 255)
            {
                skinframe->hasalpha = true;
                break;
            }
        }
        if (r_loadfog && skinframe->hasalpha)
        {
            unsigned char *fogpixels = (unsigned char *)Mem_Alloc(tempmempool, width * height * 4);
            memcpy(fogpixels, skindata, width * height * 4);
            for (i = 0;i < width * height * 4;i += 4)
                fogpixels[i] = fogpixels[i+1] = fogpixels[i+2] = 255;
            skinframe->fog = R_LoadTexture2D(r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_fog", skinframe->basename), width, height, fogpixels, TEXTYPE_BGRA, textureflags, -1, NULL);
            Mem_Free(fogpixels);
        }
    }
 
    R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, skindata[4 * pix + comp]);
    //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]);
 
    return skinframe;
}

References a, b, skinframe_t::base, skinframe_t::basename, ca_dedicated, cls, Con_Printf(), developer_loading, skinframe_t::fog, skinframe_t::gloss, skinframe_t::glow, skinframe_t::hasalpha, height, Image_HeightmapToNormalmap_BGRA(), Mem_Alloc, Mem_Free, skinframe_t::merged, name, skinframe_t::nmap, NULL, skinframe_t::pants, r_loadfog, r_loadnormalmap, R_LoadTexture2D(), r_main_texturepool, r_mipnormalmaps, r_shadow_bumpscale_basetexture, R_SkinFrame_Find(), R_SKINFRAME_LOAD_AVERAGE_COLORS, skinframe_t::reflect, skinframe_t::shirt, skinframe_t::stain, tempmempool, TEXF_ALPHA, TEXF_FORCE_RELOAD, TEXF_MIPMAP, TEXTYPE_BGRA, TEXTYPE_SRGB_BGRA, va(), and width.

Referenced by CL_Beams_SetupBuiltinTexture(), Curl_EndDownload(), Draw_NewPic(), Mod_Q1BSP_LoadSplitSky(), Mod_Q1BSP_LoadTextures(), Mod_Sprite_SharedSetup(), R_InitParticleTexture(), R_LoadSkyBox(), R_Shadow_MakeTextures_MakeCorona(), and R_SkinFrame_LoadNoTexture().

◆ R_SkinFrame_LoadInternalQuake()

skinframe_t * R_SkinFrame_LoadInternalQuake	(	const char *	name,
		int	textureflags,
		int	loadpantsandshirt,
		int	loadglowtexture,
		const unsigned char *	skindata,
		int	width,
		int	height )

Definition at line 2616 of file gl_rmain.c.

{
    int i;
    int featuresmask;
    skinframe_t *skinframe;
 
    if (cls.state == ca_dedicated)
        return NULL;
 
    // if already loaded just return it, otherwise make a new skinframe
    skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height) : 0, true);
    if (skinframe->base)
        return skinframe;
    //textureflags &= ~TEXF_FORCE_RELOAD;
 
    skinframe->stain = NULL;
    skinframe->merged = NULL;
    skinframe->base = NULL;
    skinframe->pants = NULL;
    skinframe->shirt = NULL;
    skinframe->nmap = NULL;
    skinframe->gloss = NULL;
    skinframe->glow = NULL;
    skinframe->fog = NULL;
    skinframe->reflect = NULL;
    skinframe->hasalpha = false;
 
    // if no data was provided, then clearly the caller wanted to get a blank skinframe
    if (!skindata)
        return NULL;
 
    if (developer_loading.integer)
        Con_Printf("loading quake skin \"%s\"\n", name);
 
    // we actually don't upload anything until the first use, because mdl skins frequently go unused, and are almost never used in both modes (colormapped and non-colormapped)
    skinframe->qpixels = (unsigned char *)Mem_Alloc(r_main_mempool, width*height); // FIXME LEAK
    memcpy(skinframe->qpixels, skindata, width*height);
    skinframe->qwidth = width;
    skinframe->qheight = height;
 
    featuresmask = 0;
    for (i = 0;i < width * height;i++)
        featuresmask |= palette_featureflags[skindata[i]];
 
    skinframe->hasalpha = false;
    // fence textures
    if (name[0] == '{')
        skinframe->hasalpha = true;
    skinframe->qhascolormapping = loadpantsandshirt && (featuresmask & (PALETTEFEATURE_PANTS | PALETTEFEATURE_SHIRT));
    skinframe->qgeneratenmap = r_shadow_bumpscale_basetexture.value > 0;
    skinframe->qgeneratemerged = true;
    skinframe->qgeneratebase = skinframe->qhascolormapping;
    skinframe->qgenerateglow = loadglowtexture && (featuresmask & PALETTEFEATURE_GLOW);
 
    R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, ((unsigned char *)palette_bgra_complete)[skindata[pix]*4 + comp]);
    //Con_Printf("Texture %s has average colors %f %f %f alpha %f\n", name, skinframe->avgcolor[0], skinframe->avgcolor[1], skinframe->avgcolor[2], skinframe->avgcolor[3]);
 
    return skinframe;
}

References skinframe_t::base, ca_dedicated, cls, Con_Printf(), CRC_Block(), developer_loading, skinframe_t::fog, skinframe_t::gloss, skinframe_t::glow, skinframe_t::hasalpha, height, Mem_Alloc, skinframe_t::merged, name, skinframe_t::nmap, NULL, palette_bgra_complete, palette_featureflags, PALETTEFEATURE_GLOW, PALETTEFEATURE_PANTS, PALETTEFEATURE_SHIRT, skinframe_t::pants, skinframe_t::qgeneratebase, skinframe_t::qgenerateglow, skinframe_t::qgeneratemerged, skinframe_t::qgeneratenmap, skinframe_t::qhascolormapping, skinframe_t::qheight, skinframe_t::qpixels, skinframe_t::qwidth, r_main_mempool, r_shadow_bumpscale_basetexture, R_SkinFrame_Find(), R_SKINFRAME_LOAD_AVERAGE_COLORS, skinframe_t::reflect, skinframe_t::shirt, skinframe_t::stain, and width.

Referenced by Mod_IDP0_Load(), Mod_Q1BSP_LoadTextures(), and R_LoadQWSkin().

◆ R_SkinFrame_LoadInternalUsingTexture()

skinframe_t * R_SkinFrame_LoadInternalUsingTexture	(	const char *	name,
		int	textureflags,
		rtexture_t *	tex,
		int	width,
		int	height,
		qbool	sRGB )

Definition at line 2840 of file gl_rmain.c.

{
    skinframe_t *skinframe;
    if (cls.state == ca_dedicated)
        return NULL;
    // if already loaded just return it, otherwise make a new skinframe
    skinframe = R_SkinFrame_Find(name, textureflags, width, height, 0, true);
    if (skinframe->base)
        return skinframe;
    textureflags &= ~TEXF_FORCE_RELOAD;
    skinframe->stain = NULL;
    skinframe->merged = NULL;
    skinframe->base = NULL;
    skinframe->pants = NULL;
    skinframe->shirt = NULL;
    skinframe->nmap = NULL;
    skinframe->gloss = NULL;
    skinframe->glow = NULL;
    skinframe->fog = NULL;
    skinframe->reflect = NULL;
    skinframe->hasalpha = (textureflags & TEXF_ALPHA) != 0;
    // if no data was provided, then clearly the caller wanted to get a blank skinframe
    if (!tex)
        return NULL;
    if (developer_loading.integer)
        Con_Printf("loading 32bit skin \"%s\"\n", name);
    skinframe->base = skinframe->merged = tex;
    Vector4Set(skinframe->avgcolor, 1, 1, 1, 1); // bogus placeholder
    return skinframe;
}

References skinframe_t::avgcolor, skinframe_t::base, ca_dedicated, cls, Con_Printf(), developer_loading, skinframe_t::fog, skinframe_t::gloss, skinframe_t::glow, skinframe_t::hasalpha, height, skinframe_t::merged, name, skinframe_t::nmap, NULL, skinframe_t::pants, R_SkinFrame_Find(), skinframe_t::reflect, skinframe_t::shirt, skinframe_t::stain, TEXF_ALPHA, TEXF_FORCE_RELOAD, Vector4Set, and width.

◆ R_SkinFrame_LoadMissing()

skinframe_t * R_SkinFrame_LoadMissing ( void )

Definition at line 2804 of file gl_rmain.c.

{
    skinframe_t *skinframe;
 
    if (cls.state == ca_dedicated)
        return NULL;
 
    skinframe = R_SkinFrame_Find("missing", TEXF_FORCENEAREST, 0, 0, 0, true);
    skinframe->stain = NULL;
    skinframe->merged = NULL;
    skinframe->base = NULL;
    skinframe->pants = NULL;
    skinframe->shirt = NULL;
    skinframe->nmap = NULL;
    skinframe->gloss = NULL;
    skinframe->glow = NULL;
    skinframe->fog = NULL;
    skinframe->reflect = NULL;
    skinframe->hasalpha = false;
 
    skinframe->avgcolor[0] = rand() / RAND_MAX;
    skinframe->avgcolor[1] = rand() / RAND_MAX;
    skinframe->avgcolor[2] = rand() / RAND_MAX;
    skinframe->avgcolor[3] = 1;
 
    return skinframe;
}

References skinframe_t::avgcolor, skinframe_t::base, ca_dedicated, cls, skinframe_t::fog, skinframe_t::gloss, skinframe_t::glow, skinframe_t::hasalpha, skinframe_t::merged, skinframe_t::nmap, NULL, skinframe_t::pants, R_SkinFrame_Find(), skinframe_t::reflect, skinframe_t::shirt, skinframe_t::stain, and TEXF_FORCENEAREST.

Referenced by Mod_BuildAliasSkinsFromSkinFiles(), Mod_IDP2_Load(), Mod_IDS2_Load(), Mod_LoadTextureFromQ3Shader(), Mod_Q1BSP_LoadTextures(), Mod_Sprite_SharedSetup(), and Mod_SpriteSetupTexture().

◆ R_SkinFrame_LoadNoTexture()

skinframe_t * R_SkinFrame_LoadNoTexture ( void )

Definition at line 2832 of file gl_rmain.c.

{
    if (cls.state == ca_dedicated)
        return NULL;
 
    return R_SkinFrame_LoadInternalBGRA("notexture", TEXF_FORCENEAREST, Image_GenerateNoTexture(), 16, 16, 0, 0, 0, false);
}

References ca_dedicated, cls, Image_GenerateNoTexture(), NULL, R_SkinFrame_LoadInternalBGRA(), and TEXF_FORCENEAREST.

◆ R_SkinFrame_MarkUsed()

void R_SkinFrame_MarkUsed ( skinframe_t * skinframe )

Definition at line 2176 of file gl_rmain.c.

{
    if (!skinframe)
        return;
    // mark the skinframe as used for the purging code
    skinframe->loadsequence = r_skinframe.loadsequence;
}

References skinframe_t::loadsequence, and r_skinframe.

Referenced by Draw_CachePic_Flags(), Draw_NewPic(), gl_draw_newmap(), mod_newmap(), r_lightningbeams_newmap(), r_part_newmap(), r_shadow_newmap(), and R_SkinFrame_Find().

◆ R_SkinFrame_PrepareForPurge()

void R_SkinFrame_PrepareForPurge ( void )

Definition at line 2168 of file gl_rmain.c.

{
    r_skinframe.loadsequence++;
    // wrap it without hitting zero
    if (r_skinframe.loadsequence >= 200)
        r_skinframe.loadsequence = 1;
}

References r_skinframe.

Referenced by R_Modules_NewMap().

◆ R_SkinFrame_Purge()

void R_SkinFrame_Purge ( void )

Definition at line 2203 of file gl_rmain.c.

{
    int i;
    skinframe_t *s;
    for (i = 0;i < SKINFRAME_HASH;i++)
    {
        for (s = r_skinframe.hash[i];s;s = s->next)
        {
            if (s->loadsequence && s->loadsequence != r_skinframe.loadsequence)
                R_SkinFrame_PurgeSkinFrame(s);
        }
    }
}

References skinframe_t::loadsequence, skinframe_t::next, r_skinframe, R_SkinFrame_PurgeSkinFrame(), and SKINFRAME_HASH.

Referenced by R_Modules_NewMap().

◆ R_SkinFrame_PurgeSkinFrame()

void R_SkinFrame_PurgeSkinFrame ( skinframe_t * skinframe )

Definition at line 2184 of file gl_rmain.c.

{
    if (s == NULL)
        return;
    if (s->merged == s->base)
        s->merged = NULL;
    R_PurgeTexture(s->stain); s->stain = NULL;
    R_PurgeTexture(s->merged); s->merged = NULL;
    R_PurgeTexture(s->base); s->base = NULL;
    R_PurgeTexture(s->pants); s->pants = NULL;
    R_PurgeTexture(s->shirt); s->shirt = NULL;
    R_PurgeTexture(s->nmap); s->nmap = NULL;
    R_PurgeTexture(s->gloss); s->gloss = NULL;
    R_PurgeTexture(s->glow); s->glow = NULL;
    R_PurgeTexture(s->fog); s->fog = NULL;
    R_PurgeTexture(s->reflect); s->reflect = NULL;
    s->loadsequence = 0;
}

References skinframe_t::base, skinframe_t::fog, skinframe_t::gloss, skinframe_t::glow, skinframe_t::loadsequence, skinframe_t::merged, skinframe_t::nmap, NULL, skinframe_t::pants, R_PurgeTexture(), skinframe_t::reflect, skinframe_t::shirt, and skinframe_t::stain.

Referenced by Draw_CachePic_Flags(), Draw_Frame(), Draw_FreePic(), Draw_NewPic(), Mod_UnloadCustomMaterial(), R_SkinFrame_Find(), R_SkinFrame_Purge(), and R_UnloadSkyBox().

◆ R_Sky()

void R_Sky ( void )

Definition at line 403 of file r_sky.c.

{
    Matrix4x4_CreateFromQuakeEntity(&skymatrix, r_refdef.view.origin[0], r_refdef.view.origin[1], r_refdef.view.origin[2], 0, 0, 0, r_refdef.farclip * (0.5f / 16.0f));
    Matrix4x4_Invert_Simple(&skyinversematrix, &skymatrix);
 
    if (r_sky_scissor.integer)
    {
        // if the scissor is empty just return
        if (skyscissor[2] == 0 || skyscissor[3] == 0)
            return;
        GL_Scissor(skyscissor[0], skyscissor[1], skyscissor[2], skyscissor[3]);
        GL_ScissorTest(true);
    }
    if (skyrendersphere)
    {
        // this does not modify depth buffer
        R_SkySphere();
    }
    else if (skyrenderbox)
    {
        // this does not modify depth buffer
        R_SkyBox();
    }
    /* this will be skyroom someday
    else
    {
        // this modifies the depth buffer so we have to clear it afterward
        //R_SkyRoom();
        // clear the depthbuffer that was used while rendering the skyroom
        //GL_Clear(GL_DEPTH_BUFFER_BIT);
    }
    */
    GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
}

References GL_Scissor(), GL_ScissorTest(), Matrix4x4_CreateFromQuakeEntity(), Matrix4x4_Invert_Simple(), r_refdef, r_sky_scissor, R_SkyBox(), R_SkySphere(), skyinversematrix, skymatrix, skyrenderbox, skyrendersphere, and skyscissor.

Referenced by R_RenderScene().

◆ R_Sky_Init()

void R_Sky_Init ( void )

Definition at line 464 of file r_sky.c.

{
    Cmd_AddCommand(CF_CLIENT, "loadsky", &LoadSky_f, "load a skybox by basename (for example loadsky mtnsun_ loads mtnsun_ft.tga and so on)");
    Cvar_RegisterVariable (&r_sky);
    Cvar_RegisterVariable (&r_skyscroll1);
    Cvar_RegisterVariable (&r_skyscroll2);
    Cvar_RegisterVariable (&r_sky_scissor);
    memset(&skyboxskinframe, 0, sizeof(skyboxskinframe));
    skyname[0] = 0;
    R_RegisterModule("R_Sky", r_sky_start, r_sky_shutdown, r_sky_newmap, NULL, NULL);
}

References CF_CLIENT, Cmd_AddCommand(), Cvar_RegisterVariable(), LoadSky_f(), NULL, R_RegisterModule(), r_sky, r_sky_newmap(), r_sky_scissor, r_sky_shutdown(), r_sky_start(), r_skyscroll1, r_skyscroll2, skyboxskinframe, and skyname.

Referenced by Render_Init().

◆ R_SkyStartFrame()

void R_SkyStartFrame ( void )

Definition at line 57 of file r_sky.c.

{
    skyrendersphere = false;
    skyrenderbox = false;
    skyrendermasked = false;
    // for depth-masked sky, we need to know whether any sky was rendered
    skyrenderlater = false;
    // we can scissor the sky to just the relevant area
    Vector4Clear(skyscissor);
    if (r_sky.integer)
    {
        if (skyboxskinframe[0] || skyboxskinframe[1] || skyboxskinframe[2] || skyboxskinframe[3] || skyboxskinframe[4] || skyboxskinframe[5])
            skyrenderbox = true;
        else if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.solidskyskinframe)
            skyrendersphere = true;
        skyrendermasked = true;
    }
}

References r_refdef, r_sky, skyboxskinframe, skyrenderbox, skyrenderlater, skyrendermasked, skyrendersphere, skyscissor, and Vector4Clear.

Referenced by R_RenderScene().

◆ R_Stain()

void R_Stain	(	const vec3_t	origin,
		float	radius,
		int	cr1,
		int	cg1,
		int	cb1,
		int	ca1,
		int	cr2,
		int	cg2,
		int	cb2,
		int	ca2 )

Definition at line 298 of file gl_rsurf.c.

{
    int n;
    float fcolor[8];
    entity_render_t *ent;
    model_t *model;
    vec3_t org;
    if (r_refdef.scene.worldmodel == NULL || !r_refdef.scene.worldmodel->brush.data_nodes || !r_refdef.scene.worldmodel->brushq1.lightdata)
        return;
    fcolor[0] = cr1;
    fcolor[1] = cg1;
    fcolor[2] = cb1;
    fcolor[3] = ca1 * (1.0f / 64.0f);
    fcolor[4] = cr2 - cr1;
    fcolor[5] = cg2 - cg1;
    fcolor[6] = cb2 - cb1;
    fcolor[7] = (ca2 - ca1) * (1.0f / 64.0f);
 
    R_StainNode(r_refdef.scene.worldmodel->brush.data_nodes + r_refdef.scene.worldmodel->brushq1.hulls[0].firstclipnode, r_refdef.scene.worldmodel, origin, radius, fcolor);
 
    // look for embedded bmodels
    for (n = 0;n < cl.num_brushmodel_entities;n++)
    {
        ent = &cl.entities[cl.brushmodel_entities[n]].render;
        model = ent->model;
        if (model && model->name[0] == '*')
        {
            if (model->brush.data_nodes)
            {
                Matrix4x4_Transform(&ent->inversematrix, origin, org);
                R_StainNode(model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode, model, org, radius, fcolor);
            }
        }
    }
}

References cl, entity_render_t::inversematrix, Matrix4x4_Transform(), entity_render_t::model, model, n, NULL, origin, r_refdef, and R_StainNode().

Referenced by CL_ParticleEffect_Fallback(), CL_ParticleExplosion(), and R_DrawParticles().

◆ R_Textures_Init()

void R_Textures_Init ( void )

Definition at line 720 of file gl_textures.c.

{
    Cmd_AddCommand(CF_CLIENT, "gl_texturemode", &GL_TextureMode_f, "set texture filtering mode (GL_NEAREST, GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, etc); an additional argument 'force' forces the texture mode even in cases where it may not be appropriate");
    Cmd_AddCommand(CF_CLIENT, "r_texturestats", R_TextureStats_f, "print information about all loaded textures and some statistics");
    Cvar_RegisterVariable (&gl_max_size);
    Cvar_RegisterVariable (&gl_picmip);
    Cvar_RegisterVariable (&gl_picmip_world);
    Cvar_RegisterVariable (&r_picmipworld);
    Cvar_RegisterVariable (&gl_picmip_sprites);
    Cvar_RegisterVariable (&r_picmipsprites);
    Cvar_RegisterVariable (&gl_picmip_other);
    Cvar_RegisterVariable (&gl_max_lightmapsize);
    Cvar_RegisterVariable (&r_lerpimages);
    Cvar_RegisterVariable (&gl_texture_anisotropy);
    Cvar_RegisterVariable (&gl_texturecompression);
    Cvar_RegisterVariable (&gl_texturecompression_color);
    Cvar_RegisterVariable (&gl_texturecompression_normal);
    Cvar_RegisterVariable (&gl_texturecompression_gloss);
    Cvar_RegisterVariable (&gl_texturecompression_glow);
    Cvar_RegisterVariable (&gl_texturecompression_2d);
    Cvar_RegisterVariable (&gl_texturecompression_q3bsplightmaps);
    Cvar_RegisterVariable (&gl_texturecompression_q3bspdeluxemaps);
    Cvar_RegisterVariable (&gl_texturecompression_sky);
    Cvar_RegisterVariable (&gl_texturecompression_lightcubemaps);
    Cvar_RegisterVariable (&gl_texturecompression_reflectmask);
    Cvar_RegisterVariable (&gl_texturecompression_sprites);
    Cvar_RegisterVariable (&r_texture_dds_load_alphamode);
    Cvar_RegisterVariable (&r_texture_dds_load_logfailure);
    Cvar_RegisterVariable (&r_texture_dds_swdecode);
 
    R_RegisterModule("R_Textures", r_textures_start, r_textures_shutdown, r_textures_newmap, r_textures_devicelost, r_textures_devicerestored);
}

Referenced by Render_Init().

◆ R_TimeReport()

void R_TimeReport ( const char * name )

Definition at line 193 of file r_stats.c.

{
    char tempbuf[256];
    int length;
    int t;
 
    if (r_speeds.integer < 2 || !r_timereport_active)
        return;
 
    CHECKGLERROR
    if (r_speeds.integer == 2)
        GL_Finish();
    CHECKGLERROR
    r_timereport_temp = r_timereport_current;
    r_timereport_current = Sys_DirtyTime();
    t = (int) ((r_timereport_current - r_timereport_temp) * 1000000.0 + 0.5);
 
    length = dpsnprintf(tempbuf, sizeof(tempbuf), "%8i %s", t, desc);
    if (length < 0)
        length = (int)sizeof(tempbuf) - 1;
    if (r_speeds_longestitem < length)
        r_speeds_longestitem = length;
    for (;length < r_speeds_longestitem;length++)
        tempbuf[length] = ' ';
    tempbuf[length] = 0;
 
    if (speedstringcount + length > (vid_conwidth.integer / 8))
    {
        dp_strlcat(r_speeds_timestring, "\n", sizeof(r_speeds_timestring));
        speedstringcount = 0;
    }
    dp_strlcat(r_speeds_timestring, tempbuf, sizeof(r_speeds_timestring));
    speedstringcount += length;
}

References CHECKGLERROR, dp_strlcat, dpsnprintf(), GL_Finish(), int(), length, r_speeds, r_speeds_longestitem, r_speeds_timestring, r_timereport_active, r_timereport_current, r_timereport_temp, speedstringcount, Sys_DirtyTime(), and vid_conwidth.

Referenced by CL_Frame(), CL_VM_DrawHud(), CL_VM_UpdateView(), Host_Frame(), R_RenderScene(), R_RenderView(), R_RenderWaterPlanes(), R_Shadow_DrawPrepass(), R_Shadow_UpdateBounceGridTexture(), S_PaintAndSubmit(), S_Update(), SCR_DrawScreen(), and SV_Frame().

◆ R_UpdateFog()

void R_UpdateFog ( void )

Definition at line 5396 of file gl_rmain.c.

{
    // Nehahra fog
    if (gamemode == GAME_NEHAHRA)
    {
        if (gl_fogenable.integer)
        {
            r_refdef.oldgl_fogenable = true;
            r_refdef.fog_density = gl_fogdensity.value;
            r_refdef.fog_red = gl_fogred.value;
            r_refdef.fog_green = gl_foggreen.value;
            r_refdef.fog_blue = gl_fogblue.value;
            r_refdef.fog_alpha = 1;
            r_refdef.fog_start = 0;
            r_refdef.fog_end = gl_skyclip.value;
            r_refdef.fog_height = 1<<30;
            r_refdef.fog_fadedepth = 128;
        }
        else if (r_refdef.oldgl_fogenable)
        {
            r_refdef.oldgl_fogenable = false;
            r_refdef.fog_density = 0;
            r_refdef.fog_red = 0;
            r_refdef.fog_green = 0;
            r_refdef.fog_blue = 0;
            r_refdef.fog_alpha = 0;
            r_refdef.fog_start = 0;
            r_refdef.fog_end = 0;
            r_refdef.fog_height = 1<<30;
            r_refdef.fog_fadedepth = 128;
        }
    }
 
    // fog parms
    r_refdef.fog_alpha = bound(0, r_refdef.fog_alpha, 1);
    r_refdef.fog_start = max(0, r_refdef.fog_start);
    r_refdef.fog_end = max(r_refdef.fog_start + 0.01, r_refdef.fog_end);
 
    if (r_refdef.fog_density && r_drawfog.integer)
    {
        r_refdef.fogenabled = true;
        // this is the point where the fog reaches 0.9986 alpha, which we
        // consider a good enough cutoff point for the texture
        // (0.9986 * 256 == 255.6)
        if (r_fog_exp2.integer)
            r_refdef.fogrange = 32 / (r_refdef.fog_density * r_refdef.fog_density) + r_refdef.fog_start;
        else
            r_refdef.fogrange = 2048 / r_refdef.fog_density + r_refdef.fog_start;
        r_refdef.fogrange = bound(r_refdef.fog_start, r_refdef.fogrange, r_refdef.fog_end);
        r_refdef.fograngerecip = 1.0f / r_refdef.fogrange;
        r_refdef.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * r_refdef.fograngerecip;
        if (strcmp(r_refdef.fogheighttexturename, r_refdef.fog_height_texturename))
            R_BuildFogHeightTexture();
        // fog color was already set
        // update the fog texture
        if (r_refdef.fogmasktable_start != r_refdef.fog_start || r_refdef.fogmasktable_alpha != r_refdef.fog_alpha || r_refdef.fogmasktable_density != r_refdef.fog_density || r_refdef.fogmasktable_range != r_refdef.fogrange)
            R_BuildFogTexture();
        r_refdef.fog_height_texcoordscale = 1.0f / max(0.125f, r_refdef.fog_fadedepth);
        r_refdef.fog_height_tablescale = r_refdef.fog_height_tablesize * r_refdef.fog_height_texcoordscale;
    }
    else
        r_refdef.fogenabled = false;
 
    // fog color
    if (r_refdef.fog_density)
    {
        r_refdef.fogcolor[0] = r_refdef.fog_red;
        r_refdef.fogcolor[1] = r_refdef.fog_green;
        r_refdef.fogcolor[2] = r_refdef.fog_blue;
 
        Vector4Set(r_refdef.fogplane, 0, 0, 1, -r_refdef.fog_height);
        r_refdef.fogplaneviewdist = DotProduct(r_refdef.fogplane, r_refdef.view.origin) + r_refdef.fogplane[3];
        r_refdef.fogplaneviewabove = r_refdef.fogplaneviewdist >= 0;
        r_refdef.fogheightfade = -0.5f/max(0.125f, r_refdef.fog_fadedepth);
 
        {
            vec3_t fogvec;
            VectorCopy(r_refdef.fogcolor, fogvec);
            //   color.rgb *= ContrastBoost * SceneBrightness;
            VectorScale(fogvec, r_refdef.view.colorscale, fogvec);
            r_refdef.fogcolor[0] = bound(0.0f, fogvec[0], 1.0f);
            r_refdef.fogcolor[1] = bound(0.0f, fogvec[1], 1.0f);
            r_refdef.fogcolor[2] = bound(0.0f, fogvec[2], 1.0f);
        }
    }
}

References bound, DotProduct, FOGMASKTABLEWIDTH, GAME_NEHAHRA, gamemode, gl_fogblue, gl_fogdensity, gl_fogenable, gl_foggreen, gl_fogred, gl_skyclip, max, R_BuildFogHeightTexture(), R_BuildFogTexture(), r_drawfog, r_fog_exp2, r_refdef, Vector4Set, VectorCopy, and VectorScale.

Referenced by R_ClearScreen(), and R_RenderScene().

◆ R_UpdateVariables()

void R_UpdateVariables ( void )

Definition at line 5483 of file gl_rmain.c.

{
    R_Textures_Frame();
 
    r_refdef.scene.ambientintensity = r_ambient.value * (1.0f / 64.0f);
 
    r_refdef.farclip = r_farclip_base.value;
    if (r_refdef.scene.worldmodel)
        r_refdef.farclip += r_refdef.scene.worldmodel->radius * r_farclip_world.value * 2;
    r_refdef.nearclip = bound (0.001f, r_nearclip.value, r_refdef.farclip - 1.0f);
 
    if (r_shadow_frontsidecasting.integer < 0 || r_shadow_frontsidecasting.integer > 1)
        Cvar_SetValueQuick(&r_shadow_frontsidecasting, 1);
    r_refdef.polygonfactor = 0;
    r_refdef.polygonoffset = 0;
 
    r_refdef.scene.rtworld = r_shadow_realtime_world.integer != 0;
    r_refdef.scene.rtworldshadows = r_shadow_realtime_world_shadows.integer && vid.stencil;
    r_refdef.scene.rtdlight = r_shadow_realtime_dlight.integer != 0 && !gl_flashblend.integer && r_dynamic.integer;
    r_refdef.scene.rtdlightshadows = r_refdef.scene.rtdlight && r_shadow_realtime_dlight_shadows.integer && vid.stencil;
    r_refdef.scene.lightmapintensity = r_refdef.scene.rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
    if (r_refdef.scene.worldmodel)
    {
        r_refdef.scene.lightmapintensity *= r_refdef.scene.worldmodel->lightmapscale;
 
        // Apply the default lightstyle to the lightmap even on q3bsp
        if (cl.worldmodel && cl.worldmodel->type == mod_brushq3) {
            r_refdef.scene.lightmapintensity *= r_refdef.scene.rtlightstylevalue[0];
        }
    }
    if (r_showsurfaces.integer)
    {
        r_refdef.scene.rtworld = false;
        r_refdef.scene.rtworldshadows = false;
        r_refdef.scene.rtdlight = false;
        r_refdef.scene.rtdlightshadows = false;
        r_refdef.scene.lightmapintensity = 0;
    }
 
    r_gpuskeletal = false;
    switch(vid.renderpath)
    {
    case RENDERPATH_GL32:
        r_gpuskeletal = r_glsl_skeletal.integer && !r_showsurfaces.integer;
    case RENDERPATH_GLES2:
        if(!vid_gammatables_trivial)
        {
            if(!r_texture_gammaramps || vid_gammatables_serial != r_texture_gammaramps_serial)
            {
                // build GLSL gamma texture
#define RAMPWIDTH 256
                unsigned short ramp[RAMPWIDTH * 3];
                unsigned char rampbgr[RAMPWIDTH][4];
                int i;
 
                r_texture_gammaramps_serial = vid_gammatables_serial;
 
                VID_BuildGammaTables(&ramp[0], RAMPWIDTH);
                for(i = 0; i < RAMPWIDTH; ++i)
                {
                    rampbgr[i][0] = (unsigned char) (ramp[i + 2 * RAMPWIDTH] * 255.0 / 65535.0 + 0.5);
                    rampbgr[i][1] = (unsigned char) (ramp[i + RAMPWIDTH] * 255.0 / 65535.0 + 0.5);
                    rampbgr[i][2] = (unsigned char) (ramp[i] * 255.0 / 65535.0 + 0.5);
                    rampbgr[i][3] = 0;
                }
                if (r_texture_gammaramps)
                {
                    R_UpdateTexture(r_texture_gammaramps, &rampbgr[0][0], 0, 0, 0, RAMPWIDTH, 1, 1, 0);
                }
                else
                {
                    r_texture_gammaramps = R_LoadTexture2D(r_main_texturepool, "gammaramps", RAMPWIDTH, 1, &rampbgr[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT, -1, NULL);
                }
            }
        }
        else
        {
            // remove GLSL gamma texture
        }
        break;
    }
}

References bound, cl, Cvar_SetValueQuick(), gl_flashblend, mod_brushq3, NULL, r_ambient, r_dynamic, r_farclip_base, r_farclip_world, r_glsl_skeletal, r_gpuskeletal, R_LoadTexture2D(), r_main_texturepool, r_nearclip, r_refdef, r_shadow_frontsidecasting, r_shadow_realtime_dlight, r_shadow_realtime_dlight_shadows, r_shadow_realtime_world, r_shadow_realtime_world_lightmaps, r_shadow_realtime_world_shadows, r_showsurfaces, r_texture_gammaramps, r_texture_gammaramps_serial, R_Textures_Frame(), R_UpdateTexture(), RAMPWIDTH, RENDERPATH_GL32, RENDERPATH_GLES2, TEXF_CLAMP, TEXF_FORCELINEAR, TEXF_PERSISTENT, TEXTYPE_BGRA, vid, VID_BuildGammaTables(), vid_gammatables_serial, and vid_gammatables_trivial.

Referenced by R_Envmap_f(), and SCR_DrawScreen().

◆ R_View_WorldVisibility()

void R_View_WorldVisibility ( qbool forcenovis )

Definition at line 436 of file gl_rsurf.c.

{
    int i, j, *mark;
    mleaf_t *leaf;
    mleaf_t *viewleaf;
    model_t *model = r_refdef.scene.worldmodel;
 
    if (!model)
        return;
 
    if (r_lockvisibility.integer)
        return;
 
    // clear the visible surface and leaf flags arrays
    memset(r_refdef.viewcache.world_surfacevisible, 0, model->num_surfaces);
    if(!r_lockpvs.integer)
        memset(r_refdef.viewcache.world_leafvisible, 0, model->brush.num_leafs);
 
    r_refdef.viewcache.world_novis = false;
 
    if (r_refdef.view.usecustompvs)
    {
        // simply cull each marked leaf to the frustum (view pyramid)
        for (j = 0, leaf = model->brush.data_leafs;j < model->brush.num_leafs;j++, leaf++)
        {
            // if leaf is in current pvs and on the screen, mark its surfaces
            if (CHECKPVSBIT(r_refdef.viewcache.world_pvsbits, leaf->clusterindex) && !R_CullFrustum(leaf->mins, leaf->maxs))
            {
                r_refdef.stats[r_stat_world_leafs]++;
                r_refdef.viewcache.world_leafvisible[j] = true;
                if (leaf->numleafsurfaces)
                    for (i = 0, mark = leaf->firstleafsurface;i < leaf->numleafsurfaces;i++, mark++)
                        r_refdef.viewcache.world_surfacevisible[*mark] = true;
            }
        }
    }
    else
    {
        // if possible find the leaf the view origin is in
        viewleaf = model->brush.PointInLeaf ? model->brush.PointInLeaf(model, r_refdef.view.origin) : NULL;
        // if possible fetch the visible cluster bits
        if (!r_lockpvs.integer && model->brush.FatPVS)
            model->brush.FatPVS(model, r_refdef.view.origin, 2, &r_refdef.viewcache.world_pvsbits, r_main_mempool, false);
 
        // if floating around in the void (no pvs data available, and no
        // portals available), simply use all on-screen leafs.
        if (!viewleaf || viewleaf->clusterindex < 0 || forcenovis || !r_refdef.view.usevieworiginculling)
        {
            // no visibility method: (used when floating around in the void)
            // simply cull each leaf to the frustum (view pyramid)
            // similar to quake's RecursiveWorldNode but without cache misses
            r_refdef.viewcache.world_novis = true;
            for (j = 0, leaf = model->brush.data_leafs;j < model->brush.num_leafs;j++, leaf++)
            {
                if (leaf->clusterindex < 0)
                    continue;
                // if leaf is in current pvs and on the screen, mark its surfaces
                if (!R_CullFrustum(leaf->mins, leaf->maxs))
                {
                    r_refdef.stats[r_stat_world_leafs]++;
                    r_refdef.viewcache.world_leafvisible[j] = true;
                    if (leaf->numleafsurfaces)
                        for (i = 0, mark = leaf->firstleafsurface;i < leaf->numleafsurfaces;i++, mark++)
                            r_refdef.viewcache.world_surfacevisible[*mark] = true;
                }
            }
        }
        // just check if each leaf in the PVS is on screen
        // (unless portal culling is enabled)
        else if (!model->brush.data_portals || r_useportalculling.integer < 1 || (r_useportalculling.integer < 2 && !r_novis.integer))
        {
            // pvs method:
            // simply check if each leaf is in the Potentially Visible Set,
            // and cull to frustum (view pyramid)
            // similar to quake's RecursiveWorldNode but without cache misses
            for (j = 0, leaf = model->brush.data_leafs;j < model->brush.num_leafs;j++, leaf++)
            {
                if (leaf->clusterindex < 0)
                    continue;
                // if leaf is in current pvs and on the screen, mark its surfaces
                if (CHECKPVSBIT(r_refdef.viewcache.world_pvsbits, leaf->clusterindex) && !R_CullFrustum(leaf->mins, leaf->maxs))
                {
                    r_refdef.stats[r_stat_world_leafs]++;
                    r_refdef.viewcache.world_leafvisible[j] = true;
                    if (leaf->numleafsurfaces)
                        for (i = 0, mark = leaf->firstleafsurface;i < leaf->numleafsurfaces;i++, mark++)
                            r_refdef.viewcache.world_surfacevisible[*mark] = true;
                }
            }
        }
        // if desired use a recursive portal flow, culling each portal to
        // frustum and checking if the leaf the portal leads to is in the pvs
        else
        {
            int leafstackpos;
            mportal_t *p;
            mleaf_t *leafstack[8192];
            vec3_t cullmins, cullmaxs;
            float cullbias = r_nearclip.value * 2.0f; // the nearclip plane can easily end up culling portals in certain perfectly-aligned views, causing view blackouts
            // simple-frustum portal method:
            // follows portals leading outward from viewleaf, does not venture
            // offscreen or into leafs that are not visible, faster than
            // Quake's RecursiveWorldNode and vastly better in unvised maps,
            // often culls some surfaces that pvs alone would miss
            // (such as a room in pvs that is hidden behind a wall, but the
            //  passage leading to the room is off-screen)
            leafstack[0] = viewleaf;
            leafstackpos = 1;
            while (leafstackpos)
            {
                leaf = leafstack[--leafstackpos];
                if (r_refdef.viewcache.world_leafvisible[leaf - model->brush.data_leafs])
                    continue;
                if (leaf->clusterindex < 0)
                    continue;
                r_refdef.stats[r_stat_world_leafs]++;
                r_refdef.viewcache.world_leafvisible[leaf - model->brush.data_leafs] = true;
                // mark any surfaces bounding this leaf
                if (leaf->numleafsurfaces)
                    for (i = 0, mark = leaf->firstleafsurface;i < leaf->numleafsurfaces;i++, mark++)
                        r_refdef.viewcache.world_surfacevisible[*mark] = true;
                // follow portals into other leafs
                // the checks are:
                // the leaf has not been visited yet
                // and the leaf is visible in the pvs
                // the portal polygon's bounding box is on the screen
                for (p = leaf->portals;p;p = p->next)
                {
                    r_refdef.stats[r_stat_world_portals]++;
                    if (r_refdef.viewcache.world_leafvisible[p->past - model->brush.data_leafs])
                        continue;
                    if (!CHECKPVSBIT(r_refdef.viewcache.world_pvsbits, p->past->clusterindex))
                        continue;
                    cullmins[0] = p->mins[0] - cullbias;
                    cullmins[1] = p->mins[1] - cullbias;
                    cullmins[2] = p->mins[2] - cullbias;
                    cullmaxs[0] = p->maxs[0] + cullbias;
                    cullmaxs[1] = p->maxs[1] + cullbias;
                    cullmaxs[2] = p->maxs[2] + cullbias;
                    if (R_CullFrustum(cullmins, cullmaxs))
                        continue;
                    if (r_vis_trace.integer)
                    {
                        if (p->tracetime != host.realtime && R_CanSeeBox(r_vis_trace_samples.value, r_vis_trace_eyejitter.value, r_vis_trace_enlarge.value, r_vis_trace_expand.value, r_vis_trace_pad.value, r_refdef.view.origin, cullmins, cullmaxs))
                            p->tracetime = host.realtime;
                        if (host.realtime - p->tracetime > r_vis_trace_delay.value)
                            continue;
                    }
                    if (leafstackpos >= (int)(sizeof(leafstack) / sizeof(leafstack[0])))
                        break;
                    leafstack[leafstackpos++] = p->past;
                }
            }
        }
    }
 
    // Cull the rest
    R_View_WorldVisibility_CullSurfaces();
}

References CHECKPVSBIT, mleaf_t::clusterindex, mleaf_t::firstleafsurface, host, mleaf_t::maxs, mportal_t::maxs, mleaf_t::mins, mportal_t::mins, model, mportal_t::next, NULL, mleaf_t::numleafsurfaces, mportal_t::past, mleaf_t::portals, R_CanSeeBox(), R_CullFrustum(), r_lockpvs, r_lockvisibility, r_main_mempool, r_nearclip, r_novis, r_refdef, r_stat_world_leafs, r_stat_world_portals, r_useportalculling, R_View_WorldVisibility_CullSurfaces(), r_vis_trace, r_vis_trace_delay, r_vis_trace_enlarge, r_vis_trace_expand, r_vis_trace_eyejitter, r_vis_trace_pad, r_vis_trace_samples, and mportal_t::tracetime.

Referenced by R_View_Update().

◆ R_Water_AddWaterPlane()

void R_Water_AddWaterPlane	(	msurface_t *	surface,
		int	entno )

Definition at line 4640 of file gl_rmain.c.

{
    int planeindex, bestplaneindex, vertexindex;
    vec3_t mins, maxs, normal, center, v, n;
    vec_t planescore, bestplanescore;
    mplane_t plane;
    r_waterstate_waterplane_t *p;
    texture_t *t = R_GetCurrentTexture(surface->texture);
 
    rsurface.texture = t;
    RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_NOGAPS, 1, ((const msurface_t **)&surface));
    // if the model has no normals, it's probably off-screen and they were not generated, so don't add it anyway
    if (!rsurface.batchnormal3f || rsurface.batchnumvertices < 1)
        return;
    // average the vertex normals, find the surface bounds (after deformvertexes)
    Matrix4x4_Transform(&rsurface.matrix, rsurface.batchvertex3f, v);
    Matrix4x4_Transform3x3(&rsurface.matrix, rsurface.batchnormal3f, n);
    VectorCopy(n, normal);
    VectorCopy(v, mins);
    VectorCopy(v, maxs);
    for (vertexindex = 1;vertexindex < rsurface.batchnumvertices;vertexindex++)
    {
        Matrix4x4_Transform(&rsurface.matrix, rsurface.batchvertex3f + vertexindex*3, v);
        Matrix4x4_Transform3x3(&rsurface.matrix, rsurface.batchnormal3f + vertexindex*3, n);
        VectorAdd(normal, n, normal);
        mins[0] = min(mins[0], v[0]);
        mins[1] = min(mins[1], v[1]);
        mins[2] = min(mins[2], v[2]);
        maxs[0] = max(maxs[0], v[0]);
        maxs[1] = max(maxs[1], v[1]);
        maxs[2] = max(maxs[2], v[2]);
    }
    VectorNormalize(normal);
    VectorMAM(0.5f, mins, 0.5f, maxs, center);
 
    VectorCopy(normal, plane.normal);
    VectorNormalize(plane.normal);
    plane.dist = DotProduct(center, plane.normal);
    PlaneClassify(&plane);
    if (PlaneDiff(r_refdef.view.origin, &plane) < 0)
    {
        // skip backfaces (except if nocullface is set)
//      if (!(t->currentmaterialflags & MATERIALFLAG_NOCULLFACE))
//          return;
        VectorNegate(plane.normal, plane.normal);
        plane.dist *= -1;
        PlaneClassify(&plane);
    }
 
 
    // find a matching plane if there is one
    bestplaneindex = -1;
    bestplanescore = 1048576.0f;
    for (planeindex = 0, p = r_fb.water.waterplanes;planeindex < r_fb.water.numwaterplanes;planeindex++, p++)
    {
        if(p->camera_entity == t->camera_entity)
        {
            planescore = 1.0f - DotProduct(plane.normal, p->plane.normal) + fabs(plane.dist - p->plane.dist) * 0.001f;
            if (bestplaneindex < 0 || bestplanescore > planescore)
            {
                bestplaneindex = planeindex;
                bestplanescore = planescore;
            }
        }
    }
    planeindex = bestplaneindex;
 
    // if this surface does not fit any known plane rendered this frame, add one
    if (planeindex < 0 || bestplanescore > 0.001f)
    {
        if (r_fb.water.numwaterplanes < r_fb.water.maxwaterplanes)
        {
            // store the new plane
            planeindex = r_fb.water.numwaterplanes++;
            p = r_fb.water.waterplanes + planeindex;
            p->plane = plane;
            // clear materialflags and pvs
            p->materialflags = 0;
            p->pvsvalid = false;
            p->camera_entity = t->camera_entity;
            VectorCopy(mins, p->mins);
            VectorCopy(maxs, p->maxs);
        }
        else
        {
            // We're totally screwed.
            return;
        }
    }
    else
    {
        // merge mins/maxs when we're adding this surface to the plane
        p = r_fb.water.waterplanes + planeindex;
        p->mins[0] = min(p->mins[0], mins[0]);
        p->mins[1] = min(p->mins[1], mins[1]);
        p->mins[2] = min(p->mins[2], mins[2]);
        p->maxs[0] = max(p->maxs[0], maxs[0]);
        p->maxs[1] = max(p->maxs[1], maxs[1]);
        p->maxs[2] = max(p->maxs[2], maxs[2]);
    }
    // merge this surface's materialflags into the waterplane
    p->materialflags |= t->currentmaterialflags;
    if(!(p->materialflags & MATERIALFLAG_CAMERA))
    {
        // merge this surface's PVS into the waterplane
        if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS
         && r_refdef.scene.worldmodel->brush.PointInLeaf && r_refdef.scene.worldmodel->brush.PointInLeaf(r_refdef.scene.worldmodel, center)->clusterindex >= 0)
        {
            r_refdef.scene.worldmodel->brush.FatPVS(r_refdef.scene.worldmodel, center, 2, &p->pvsbits, r_main_mempool, p->pvsvalid);
            p->pvsvalid = true;
        }
    }
}

References BATCHNEED_ARRAY_NORMAL, BATCHNEED_ARRAY_VERTEX, BATCHNEED_NOGAPS, r_waterstate_waterplane_t::camera_entity, texture_t::camera_entity, texture_t::currentmaterialflags, mplane_t::dist, DotProduct, fabs(), MATERIALFLAG_CAMERA, MATERIALFLAG_REFLECTION, MATERIALFLAG_REFRACTION, MATERIALFLAG_WATERSHADER, r_waterstate_waterplane_t::materialflags, Matrix4x4_Transform(), Matrix4x4_Transform3x3(), max, maxs, r_waterstate_waterplane_t::maxs, min, mins, r_waterstate_waterplane_t::mins, n, mplane_t::normal, normal, r_waterstate_waterplane_t::plane, PlaneClassify(), PlaneDiff, r_waterstate_waterplane_t::pvsbits, r_waterstate_waterplane_t::pvsvalid, r_fb, R_GetCurrentTexture(), r_main_mempool, r_refdef, RSurf_PrepareVerticesForBatch(), rsurface, msurface_t::texture, v, VectorAdd, VectorCopy, VectorMAM, VectorNegate, and VectorNormalize.

Referenced by R_Mod_DrawAddWaterPlanes().

◆ Render_Init()

void Render_Init ( void )

Definition at line 3420 of file gl_rmain.c.

{
    gl_backend_init();
    R_Textures_Init();
    GL_Main_Init();
    Font_Init();
    GL_Draw_Init();
    R_Shadow_Init();
    R_Sky_Init();
    GL_Surf_Init();
    Sbar_Init();
    R_Particles_Init();
    R_Explosion_Init();
    R_LightningBeams_Init();
    CL_MeshEntities_Init();
    Mod_RenderInit();
}

References CL_MeshEntities_Init(), Font_Init(), gl_backend_init(), GL_Draw_Init(), GL_Main_Init(), GL_Surf_Init(), Mod_RenderInit(), R_Explosion_Init(), R_LightningBeams_Init(), R_Particles_Init(), R_Shadow_Init(), R_Sky_Init(), R_Textures_Init(), and Sbar_Init().

Referenced by CL_Init().

◆ RSurf_ActiveCustomEntity()

void RSurf_ActiveCustomEntity	(	const matrix4x4_t *	matrix,
		const matrix4x4_t *	inversematrix,
		int	entflags,
		double	shadertime,
		float	r,
		float	g,
		float	b,
		float	a,
		int	numvertices,
		const float *	vertex3f,
		const float *	texcoord2f,
		const float *	normal3f,
		const float *	svector3f,
		const float *	tvector3f,
		const float *	color4f,
		int	numtriangles,
		const int *	element3i,
		const unsigned short *	element3s,
		qbool	wantnormals,
		qbool	wanttangents )

Definition at line 7146 of file gl_rmain.c.

{
    rsurface.entity = r_refdef.scene.worldentity;
    if (r != 1.0f || g != 1.0f || b != 1.0f || a != 1.0f) {
        // HACK to provide a valid entity with modded colors to R_GetCurrentTexture.
        // A better approach could be making this copy only once per frame.
        static entity_render_t custom_entity;
        int q;
        custom_entity = *rsurface.entity;
        for (q = 0; q < 3; ++q) {
            float colormod = q == 0 ? r : q == 1 ? g : b;
            custom_entity.render_fullbright[q] *= colormod;
            custom_entity.render_modellight_ambient[q] *= colormod;
            custom_entity.render_modellight_diffuse[q] *= colormod;
            custom_entity.render_lightmap_ambient[q] *= colormod;
            custom_entity.render_lightmap_diffuse[q] *= colormod;
            custom_entity.render_rtlight_diffuse[q] *= colormod;
        }
        custom_entity.alpha *= a;
        rsurface.entity = &custom_entity;
    }
    rsurface.skeleton = NULL;
    rsurface.ent_skinnum = 0;
    rsurface.ent_qwskin = -1;
    rsurface.ent_flags = entflags;
    rsurface.shadertime = r_refdef.scene.time - shadertime;
    rsurface.modelnumvertices = numvertices;
    rsurface.modelnumtriangles = numtriangles;
    rsurface.matrix = *matrix;
    rsurface.inversematrix = *inversematrix;
    rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix);
    rsurface.inversematrixscale = 1.0f / rsurface.matrixscale;
    R_EntityMatrix(&rsurface.matrix);
    Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.localvieworigin);
    Matrix4x4_TransformStandardPlane(&rsurface.inversematrix, r_refdef.fogplane[0], r_refdef.fogplane[1], r_refdef.fogplane[2], r_refdef.fogplane[3], rsurface.fogplane);
    rsurface.fogplaneviewdist *= rsurface.inversematrixscale;
    rsurface.fograngerecip = r_refdef.fograngerecip * rsurface.matrixscale;
    rsurface.fogheightfade = r_refdef.fogheightfade * rsurface.matrixscale;
    rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
    memset(rsurface.frameblend, 0, sizeof(rsurface.frameblend));
    rsurface.frameblend[0].lerp = 1;
    rsurface.ent_alttextures = false;
    rsurface.basepolygonfactor = r_refdef.polygonfactor;
    rsurface.basepolygonoffset = r_refdef.polygonoffset;
    rsurface.entityskeletaltransform3x4 = NULL;
    rsurface.entityskeletaltransform3x4buffer = NULL;
    rsurface.entityskeletaltransform3x4offset = 0;
    rsurface.entityskeletaltransform3x4size = 0;
    rsurface.entityskeletalnumtransforms = 0;
    r_refdef.stats[r_stat_batch_entitycustom_count]++;
    r_refdef.stats[r_stat_batch_entitycustom_surfaces] += 1;
    r_refdef.stats[r_stat_batch_entitycustom_vertices] += rsurface.modelnumvertices;
    r_refdef.stats[r_stat_batch_entitycustom_triangles] += rsurface.modelnumtriangles;
    if (wanttangents)
    {
        rsurface.modelvertex3f = (float *)vertex3f;
        rsurface.modelsvector3f = svector3f ? (float *)svector3f : (float *)R_FrameData_Alloc(rsurface.modelnumvertices * sizeof(float[3]));
        rsurface.modeltvector3f = tvector3f ? (float *)tvector3f : (float *)R_FrameData_Alloc(rsurface.modelnumvertices * sizeof(float[3]));
        rsurface.modelnormal3f = normal3f ? (float *)normal3f : (float *)R_FrameData_Alloc(rsurface.modelnumvertices * sizeof(float[3]));
    }
    else if (wantnormals)
    {
        rsurface.modelvertex3f = (float *)vertex3f;
        rsurface.modelsvector3f = NULL;
        rsurface.modeltvector3f = NULL;
        rsurface.modelnormal3f = normal3f ? (float *)normal3f : (float *)R_FrameData_Alloc(rsurface.modelnumvertices * sizeof(float[3]));
    }
    else
    {
        rsurface.modelvertex3f = (float *)vertex3f;
        rsurface.modelsvector3f = NULL;
        rsurface.modeltvector3f = NULL;
        rsurface.modelnormal3f = NULL;
    }
    rsurface.modelvertex3f_vertexbuffer = 0;
    rsurface.modelvertex3f_bufferoffset = 0;
    rsurface.modelsvector3f_vertexbuffer = 0;
    rsurface.modelsvector3f_bufferoffset = 0;
    rsurface.modeltvector3f_vertexbuffer = 0;
    rsurface.modeltvector3f_bufferoffset = 0;
    rsurface.modelnormal3f_vertexbuffer = 0;
    rsurface.modelnormal3f_bufferoffset = 0;
    rsurface.modelgeneratedvertex = true;
    rsurface.modellightmapcolor4f  = (float *)color4f;
    rsurface.modellightmapcolor4f_vertexbuffer = 0;
    rsurface.modellightmapcolor4f_bufferoffset = 0;
    rsurface.modeltexcoordtexture2f  = (float *)texcoord2f;
    rsurface.modeltexcoordtexture2f_vertexbuffer = 0;
    rsurface.modeltexcoordtexture2f_bufferoffset = 0;
    rsurface.modeltexcoordlightmap2f  = NULL;
    rsurface.modeltexcoordlightmap2f_vertexbuffer = 0;
    rsurface.modeltexcoordlightmap2f_bufferoffset = 0;
    rsurface.modelskeletalindex4ub = NULL;
    rsurface.modelskeletalindex4ub_vertexbuffer = NULL;
    rsurface.modelskeletalindex4ub_bufferoffset = 0;
    rsurface.modelskeletalweight4ub = NULL;
    rsurface.modelskeletalweight4ub_vertexbuffer = NULL;
    rsurface.modelskeletalweight4ub_bufferoffset = 0;
    rsurface.modelelement3i = (int *)element3i;
    rsurface.modelelement3i_indexbuffer = NULL;
    rsurface.modelelement3i_bufferoffset = 0;
    rsurface.modelelement3s = (unsigned short *)element3s;
    rsurface.modelelement3s_indexbuffer = NULL;
    rsurface.modelelement3s_bufferoffset = 0;
    rsurface.modellightmapoffsets = NULL;
    rsurface.modelsurfaces = NULL;
    rsurface.batchgeneratedvertex = false;
    rsurface.batchfirstvertex = 0;
    rsurface.batchnumvertices = 0;
    rsurface.batchfirsttriangle = 0;
    rsurface.batchnumtriangles = 0;
    rsurface.batchvertex3f  = NULL;
    rsurface.batchvertex3f_vertexbuffer = NULL;
    rsurface.batchvertex3f_bufferoffset = 0;
    rsurface.batchsvector3f = NULL;
    rsurface.batchsvector3f_vertexbuffer = NULL;
    rsurface.batchsvector3f_bufferoffset = 0;
    rsurface.batchtvector3f = NULL;
    rsurface.batchtvector3f_vertexbuffer = NULL;
    rsurface.batchtvector3f_bufferoffset = 0;
    rsurface.batchnormal3f  = NULL;
    rsurface.batchnormal3f_vertexbuffer = NULL;
    rsurface.batchnormal3f_bufferoffset = 0;
    rsurface.batchlightmapcolor4f = NULL;
    rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
    rsurface.batchlightmapcolor4f_bufferoffset = 0;
    rsurface.batchtexcoordtexture2f = NULL;
    rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
    rsurface.batchtexcoordtexture2f_bufferoffset = 0;
    rsurface.batchtexcoordlightmap2f = NULL;
    rsurface.batchtexcoordlightmap2f_vertexbuffer = NULL;
    rsurface.batchtexcoordlightmap2f_bufferoffset = 0;
    rsurface.batchskeletalindex4ub = NULL;
    rsurface.batchskeletalindex4ub_vertexbuffer = NULL;
    rsurface.batchskeletalindex4ub_bufferoffset = 0;
    rsurface.batchskeletalweight4ub = NULL;
    rsurface.batchskeletalweight4ub_vertexbuffer = NULL;
    rsurface.batchskeletalweight4ub_bufferoffset = 0;
    rsurface.batchelement3i = NULL;
    rsurface.batchelement3i_indexbuffer = NULL;
    rsurface.batchelement3i_bufferoffset = 0;
    rsurface.batchelement3s = NULL;
    rsurface.batchelement3s_indexbuffer = NULL;
    rsurface.batchelement3s_bufferoffset = 0;
    rsurface.forcecurrenttextureupdate = true;
 
    if (rsurface.modelnumvertices && rsurface.modelelement3i)
    {
        if ((wantnormals || wanttangents) && !normal3f)
        {
            rsurface.modelnormal3f = (float *)R_FrameData_Alloc(rsurface.modelnumvertices * sizeof(float[3]));
            Mod_BuildNormals(0, rsurface.modelnumvertices, rsurface.modelnumtriangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.modelnormal3f, r_smoothnormals_areaweighting.integer != 0);
        }
        if (wanttangents && !svector3f)
        {
            rsurface.modelsvector3f = (float *)R_FrameData_Alloc(rsurface.modelnumvertices * sizeof(float[3]));
            rsurface.modeltvector3f = (float *)R_FrameData_Alloc(rsurface.modelnumvertices * sizeof(float[3]));
            Mod_BuildTextureVectorsFromNormals(0, rsurface.modelnumvertices, rsurface.modelnumtriangles, rsurface.modelvertex3f, rsurface.modeltexcoordtexture2f, rsurface.modelnormal3f, rsurface.modelelement3i, rsurface.modelsvector3f, rsurface.modeltvector3f, r_smoothnormals_areaweighting.integer != 0);
        }
    }
}

References a, entity_render_t::alpha, b, colormod, FOGMASKTABLEWIDTH, g, Matrix4x4_ScaleFromMatrix(), Matrix4x4_Transform(), Matrix4x4_TransformStandardPlane(), Mod_BuildNormals(), Mod_BuildTextureVectorsFromNormals(), NULL, r, R_EntityMatrix(), R_FrameData_Alloc(), r_refdef, r_smoothnormals_areaweighting, r_stat_batch_entitycustom_count, r_stat_batch_entitycustom_surfaces, r_stat_batch_entitycustom_triangles, r_stat_batch_entitycustom_vertices, entity_render_t::render_fullbright, entity_render_t::render_lightmap_ambient, entity_render_t::render_lightmap_diffuse, entity_render_t::render_modellight_ambient, entity_render_t::render_modellight_diffuse, entity_render_t::render_rtlight_diffuse, and rsurface.

Referenced by R_DrawCorona(), R_DrawModelDecals_Entity(), R_DrawNoModel_TransparentCallback(), R_Model_Sprite_Draw_TransparentCallback(), R_Shadow_DrawCursor_TransparentCallback(), R_Shadow_DrawLightSprite_TransparentCallback(), R_SkyBox(), and R_SkySphere().

◆ RSurf_ActiveModelEntity()

void RSurf_ActiveModelEntity	(	const entity_render_t *	ent,
		qbool	wantnormals,
		qbool	wanttangents,
		qbool	prepass )

Definition at line 6921 of file gl_rmain.c.

{
    model_t *model = ent->model;
    //if (rsurface.entity == ent && (!model->surfmesh.isanimated || (!wantnormals && !wanttangents)))
    //  return;
    rsurface.entity = (entity_render_t *)ent;
    rsurface.skeleton = ent->skeleton;
    memcpy(rsurface.userwavefunc_param, ent->userwavefunc_param, sizeof(rsurface.userwavefunc_param));
    rsurface.ent_skinnum = ent->skinnum;
    rsurface.ent_qwskin = (ent->entitynumber <= cl.maxclients && ent->entitynumber >= 1 && cls.protocol == PROTOCOL_QUAKEWORLD && cl.scores[ent->entitynumber - 1].qw_skin[0] && !strcmp(ent->model->name, "progs/player.mdl")) ? (ent->entitynumber - 1) : -1;
    rsurface.ent_flags = ent->flags;
    if (r_fullbright_directed.integer && (r_fullbright.integer || !model->lit))
        rsurface.ent_flags |= RENDER_LIGHT | RENDER_DYNAMICMODELLIGHT;
    rsurface.shadertime = r_refdef.scene.time - ent->shadertime;
    rsurface.matrix = ent->matrix;
    rsurface.inversematrix = ent->inversematrix;
    rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix);
    rsurface.inversematrixscale = 1.0f / rsurface.matrixscale;
    R_EntityMatrix(&rsurface.matrix);
    Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.localvieworigin);
    Matrix4x4_TransformStandardPlane(&rsurface.inversematrix, r_refdef.fogplane[0], r_refdef.fogplane[1], r_refdef.fogplane[2], r_refdef.fogplane[3], rsurface.fogplane);
    rsurface.fogplaneviewdist = r_refdef.fogplaneviewdist * rsurface.inversematrixscale;
    rsurface.fograngerecip = r_refdef.fograngerecip * rsurface.matrixscale;
    rsurface.fogheightfade = r_refdef.fogheightfade * rsurface.matrixscale;
    rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
    memcpy(rsurface.frameblend, ent->frameblend, sizeof(ent->frameblend));
    rsurface.ent_alttextures = ent->framegroupblend[0].frame != 0;
    rsurface.basepolygonfactor = r_refdef.polygonfactor;
    rsurface.basepolygonoffset = r_refdef.polygonoffset;
    if (ent->model->brush.submodel && !prepass)
    {
        rsurface.basepolygonfactor += r_polygonoffset_submodel_factor.value;
        rsurface.basepolygonoffset += r_polygonoffset_submodel_offset.value;
    }
    // if the animcache code decided it should use the shader path, skip the deform step
    rsurface.entityskeletaltransform3x4 = ent->animcache_skeletaltransform3x4;
    rsurface.entityskeletaltransform3x4buffer = ent->animcache_skeletaltransform3x4buffer;
    rsurface.entityskeletaltransform3x4offset = ent->animcache_skeletaltransform3x4offset;
    rsurface.entityskeletaltransform3x4size = ent->animcache_skeletaltransform3x4size;
    rsurface.entityskeletalnumtransforms = rsurface.entityskeletaltransform3x4 ? model->num_bones : 0;
    if (model->surfmesh.isanimated && model->AnimateVertices && !rsurface.entityskeletaltransform3x4)
    {
        if (ent->animcache_vertex3f)
        {
            r_refdef.stats[r_stat_batch_entitycache_count]++;
            r_refdef.stats[r_stat_batch_entitycache_surfaces] += model->num_surfaces;
            r_refdef.stats[r_stat_batch_entitycache_vertices] += model->surfmesh.num_vertices;
            r_refdef.stats[r_stat_batch_entitycache_triangles] += model->surfmesh.num_triangles;
            rsurface.modelvertex3f = ent->animcache_vertex3f;
            rsurface.modelvertex3f_vertexbuffer = ent->animcache_vertex3f_vertexbuffer;
            rsurface.modelvertex3f_bufferoffset = ent->animcache_vertex3f_bufferoffset;
            rsurface.modelsvector3f = wanttangents ? ent->animcache_svector3f : NULL;
            rsurface.modelsvector3f_vertexbuffer = wanttangents ? ent->animcache_svector3f_vertexbuffer : NULL;
            rsurface.modelsvector3f_bufferoffset = wanttangents ? ent->animcache_svector3f_bufferoffset : 0;
            rsurface.modeltvector3f = wanttangents ? ent->animcache_tvector3f : NULL;
            rsurface.modeltvector3f_vertexbuffer = wanttangents ? ent->animcache_tvector3f_vertexbuffer : NULL;
            rsurface.modeltvector3f_bufferoffset = wanttangents ? ent->animcache_tvector3f_bufferoffset : 0;
            rsurface.modelnormal3f = wantnormals ? ent->animcache_normal3f : NULL;
            rsurface.modelnormal3f_vertexbuffer = wantnormals ? ent->animcache_normal3f_vertexbuffer : NULL;
            rsurface.modelnormal3f_bufferoffset = wantnormals ? ent->animcache_normal3f_bufferoffset : 0;
        }
        else if (wanttangents)
        {
            r_refdef.stats[r_stat_batch_entityanimate_count]++;
            r_refdef.stats[r_stat_batch_entityanimate_surfaces] += model->num_surfaces;
            r_refdef.stats[r_stat_batch_entityanimate_vertices] += model->surfmesh.num_vertices;
            r_refdef.stats[r_stat_batch_entityanimate_triangles] += model->surfmesh.num_triangles;
            rsurface.modelvertex3f = (float *)R_FrameData_Alloc(model->surfmesh.num_vertices * sizeof(float[3]));
            rsurface.modelsvector3f = (float *)R_FrameData_Alloc(model->surfmesh.num_vertices * sizeof(float[3]));
            rsurface.modeltvector3f = (float *)R_FrameData_Alloc(model->surfmesh.num_vertices * sizeof(float[3]));
            rsurface.modelnormal3f = (float *)R_FrameData_Alloc(model->surfmesh.num_vertices * sizeof(float[3]));
            model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.modelvertex3f, rsurface.modelnormal3f, rsurface.modelsvector3f, rsurface.modeltvector3f);
            rsurface.modelvertex3f_vertexbuffer = NULL;
            rsurface.modelvertex3f_bufferoffset = 0;
            rsurface.modelvertex3f_vertexbuffer = 0;
            rsurface.modelvertex3f_bufferoffset = 0;
            rsurface.modelsvector3f_vertexbuffer = 0;
            rsurface.modelsvector3f_bufferoffset = 0;
            rsurface.modeltvector3f_vertexbuffer = 0;
            rsurface.modeltvector3f_bufferoffset = 0;
            rsurface.modelnormal3f_vertexbuffer = 0;
            rsurface.modelnormal3f_bufferoffset = 0;
        }
        else if (wantnormals)
        {
            r_refdef.stats[r_stat_batch_entityanimate_count]++;
            r_refdef.stats[r_stat_batch_entityanimate_surfaces] += model->num_surfaces;
            r_refdef.stats[r_stat_batch_entityanimate_vertices] += model->surfmesh.num_vertices;
            r_refdef.stats[r_stat_batch_entityanimate_triangles] += model->surfmesh.num_triangles;
            rsurface.modelvertex3f = (float *)R_FrameData_Alloc(model->surfmesh.num_vertices * sizeof(float[3]));
            rsurface.modelsvector3f = NULL;
            rsurface.modeltvector3f = NULL;
            rsurface.modelnormal3f = (float *)R_FrameData_Alloc(model->surfmesh.num_vertices * sizeof(float[3]));
            model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.modelvertex3f, rsurface.modelnormal3f, NULL, NULL);
            rsurface.modelvertex3f_vertexbuffer = NULL;
            rsurface.modelvertex3f_bufferoffset = 0;
            rsurface.modelvertex3f_vertexbuffer = 0;
            rsurface.modelvertex3f_bufferoffset = 0;
            rsurface.modelsvector3f_vertexbuffer = 0;
            rsurface.modelsvector3f_bufferoffset = 0;
            rsurface.modeltvector3f_vertexbuffer = 0;
            rsurface.modeltvector3f_bufferoffset = 0;
            rsurface.modelnormal3f_vertexbuffer = 0;
            rsurface.modelnormal3f_bufferoffset = 0;
        }
        else
        {
            r_refdef.stats[r_stat_batch_entityanimate_count]++;
            r_refdef.stats[r_stat_batch_entityanimate_surfaces] += model->num_surfaces;
            r_refdef.stats[r_stat_batch_entityanimate_vertices] += model->surfmesh.num_vertices;
            r_refdef.stats[r_stat_batch_entityanimate_triangles] += model->surfmesh.num_triangles;
            rsurface.modelvertex3f = (float *)R_FrameData_Alloc(model->surfmesh.num_vertices * sizeof(float[3]));
            rsurface.modelsvector3f = NULL;
            rsurface.modeltvector3f = NULL;
            rsurface.modelnormal3f = NULL;
            model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.modelvertex3f, NULL, NULL, NULL);
            rsurface.modelvertex3f_vertexbuffer = NULL;
            rsurface.modelvertex3f_bufferoffset = 0;
            rsurface.modelvertex3f_vertexbuffer = 0;
            rsurface.modelvertex3f_bufferoffset = 0;
            rsurface.modelsvector3f_vertexbuffer = 0;
            rsurface.modelsvector3f_bufferoffset = 0;
            rsurface.modeltvector3f_vertexbuffer = 0;
            rsurface.modeltvector3f_bufferoffset = 0;
            rsurface.modelnormal3f_vertexbuffer = 0;
            rsurface.modelnormal3f_bufferoffset = 0;
        }
        rsurface.modelgeneratedvertex = true;
    }
    else
    {
        if (rsurface.entityskeletaltransform3x4)
        {
            r_refdef.stats[r_stat_batch_entityskeletal_count]++;
            r_refdef.stats[r_stat_batch_entityskeletal_surfaces] += model->num_surfaces;
            r_refdef.stats[r_stat_batch_entityskeletal_vertices] += model->surfmesh.num_vertices;
            r_refdef.stats[r_stat_batch_entityskeletal_triangles] += model->surfmesh.num_triangles;
        }
        else
        {
            r_refdef.stats[r_stat_batch_entitystatic_count]++;
            r_refdef.stats[r_stat_batch_entitystatic_surfaces] += model->num_surfaces;
            r_refdef.stats[r_stat_batch_entitystatic_vertices] += model->surfmesh.num_vertices;
            r_refdef.stats[r_stat_batch_entitystatic_triangles] += model->surfmesh.num_triangles;
        }
        rsurface.modelvertex3f  = model->surfmesh.data_vertex3f;
        rsurface.modelvertex3f_vertexbuffer = model->surfmesh.data_vertex3f_vertexbuffer;
        rsurface.modelvertex3f_bufferoffset = model->surfmesh.data_vertex3f_bufferoffset;
        rsurface.modelsvector3f = model->surfmesh.data_svector3f;
        rsurface.modelsvector3f_vertexbuffer = model->surfmesh.data_svector3f_vertexbuffer;
        rsurface.modelsvector3f_bufferoffset = model->surfmesh.data_svector3f_bufferoffset;
        rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
        rsurface.modeltvector3f_vertexbuffer = model->surfmesh.data_tvector3f_vertexbuffer;
        rsurface.modeltvector3f_bufferoffset = model->surfmesh.data_tvector3f_bufferoffset;
        rsurface.modelnormal3f  = model->surfmesh.data_normal3f;
        rsurface.modelnormal3f_vertexbuffer = model->surfmesh.data_normal3f_vertexbuffer;
        rsurface.modelnormal3f_bufferoffset = model->surfmesh.data_normal3f_bufferoffset;
        rsurface.modelgeneratedvertex = false;
    }
    rsurface.modellightmapcolor4f  = model->surfmesh.data_lightmapcolor4f;
    rsurface.modellightmapcolor4f_vertexbuffer = model->surfmesh.data_lightmapcolor4f_vertexbuffer;
    rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.data_lightmapcolor4f_bufferoffset;
    rsurface.modeltexcoordtexture2f  = model->surfmesh.data_texcoordtexture2f;
    rsurface.modeltexcoordtexture2f_vertexbuffer = model->surfmesh.data_texcoordtexture2f_vertexbuffer;
    rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.data_texcoordtexture2f_bufferoffset;
    rsurface.modeltexcoordlightmap2f  = model->surfmesh.data_texcoordlightmap2f;
    rsurface.modeltexcoordlightmap2f_vertexbuffer = model->surfmesh.data_texcoordlightmap2f_vertexbuffer;
    rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.data_texcoordlightmap2f_bufferoffset;
    rsurface.modelskeletalindex4ub = model->surfmesh.data_skeletalindex4ub;
    rsurface.modelskeletalindex4ub_vertexbuffer = model->surfmesh.data_skeletalindex4ub_vertexbuffer;
    rsurface.modelskeletalindex4ub_bufferoffset = model->surfmesh.data_skeletalindex4ub_bufferoffset;
    rsurface.modelskeletalweight4ub = model->surfmesh.data_skeletalweight4ub;
    rsurface.modelskeletalweight4ub_vertexbuffer = model->surfmesh.data_skeletalweight4ub_vertexbuffer;
    rsurface.modelskeletalweight4ub_bufferoffset = model->surfmesh.data_skeletalweight4ub_bufferoffset;
    rsurface.modelelement3i = model->surfmesh.data_element3i;
    rsurface.modelelement3i_indexbuffer = model->surfmesh.data_element3i_indexbuffer;
    rsurface.modelelement3i_bufferoffset = model->surfmesh.data_element3i_bufferoffset;
    rsurface.modelelement3s = model->surfmesh.data_element3s;
    rsurface.modelelement3s_indexbuffer = model->surfmesh.data_element3s_indexbuffer;
    rsurface.modelelement3s_bufferoffset = model->surfmesh.data_element3s_bufferoffset;
    rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
    rsurface.modelnumvertices = model->surfmesh.num_vertices;
    rsurface.modelnumtriangles = model->surfmesh.num_triangles;
    rsurface.modelsurfaces = model->data_surfaces;
    rsurface.batchgeneratedvertex = false;
    rsurface.batchfirstvertex = 0;
    rsurface.batchnumvertices = 0;
    rsurface.batchfirsttriangle = 0;
    rsurface.batchnumtriangles = 0;
    rsurface.batchvertex3f  = NULL;
    rsurface.batchvertex3f_vertexbuffer = NULL;
    rsurface.batchvertex3f_bufferoffset = 0;
    rsurface.batchsvector3f = NULL;
    rsurface.batchsvector3f_vertexbuffer = NULL;
    rsurface.batchsvector3f_bufferoffset = 0;
    rsurface.batchtvector3f = NULL;
    rsurface.batchtvector3f_vertexbuffer = NULL;
    rsurface.batchtvector3f_bufferoffset = 0;
    rsurface.batchnormal3f  = NULL;
    rsurface.batchnormal3f_vertexbuffer = NULL;
    rsurface.batchnormal3f_bufferoffset = 0;
    rsurface.batchlightmapcolor4f = NULL;
    rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
    rsurface.batchlightmapcolor4f_bufferoffset = 0;
    rsurface.batchtexcoordtexture2f = NULL;
    rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
    rsurface.batchtexcoordtexture2f_bufferoffset = 0;
    rsurface.batchtexcoordlightmap2f = NULL;
    rsurface.batchtexcoordlightmap2f_vertexbuffer = NULL;
    rsurface.batchtexcoordlightmap2f_bufferoffset = 0;
    rsurface.batchskeletalindex4ub = NULL;
    rsurface.batchskeletalindex4ub_vertexbuffer = NULL;
    rsurface.batchskeletalindex4ub_bufferoffset = 0;
    rsurface.batchskeletalweight4ub = NULL;
    rsurface.batchskeletalweight4ub_vertexbuffer = NULL;
    rsurface.batchskeletalweight4ub_bufferoffset = 0;
    rsurface.batchelement3i = NULL;
    rsurface.batchelement3i_indexbuffer = NULL;
    rsurface.batchelement3i_bufferoffset = 0;
    rsurface.batchelement3s = NULL;
    rsurface.batchelement3s_indexbuffer = NULL;
    rsurface.batchelement3s_bufferoffset = 0;
    rsurface.forcecurrenttextureupdate = false;
}

Referenced by R_DecalSystem_SplatEntity(), R_DrawBBoxMesh(), R_DrawModelDecals_Entity(), R_DrawModelSurfaces(), R_DrawParticle_TransparentCallback(), R_DrawSurface_TransparentCallback(), R_Mod_DrawAddWaterPlanes(), R_Mod_GetLightInfo(), R_Shadow_DrawCoronas(), R_Shadow_DrawEntityShadow(), R_Shadow_DrawModelShadowMaps(), R_Shadow_DrawWorldLight(), R_Shadow_DrawWorldShadow_ShadowMap(), and R_Shadow_SetupEntityLight().

◆ RSurf_DrawBatch()

void RSurf_DrawBatch ( void )

Definition at line 8477 of file gl_rmain.c.

{
    // sometimes a zero triangle surface (usually a degenerate patch) makes it
    // through the pipeline, killing it earlier in the pipeline would have
    // per-surface overhead rather than per-batch overhead, so it's best to
    // reject it here, before it hits glDraw.
    if (rsurface.batchnumtriangles == 0)
        return;
#if 0
    // batch debugging code
    if (r_test.integer && rsurface.entity == r_refdef.scene.worldentity && rsurface.batchvertex3f == r_refdef.scene.worldentity->model->surfmesh.data_vertex3f)
    {
        int i;
        int j;
        int c;
        const int *e;
        e = rsurface.batchelement3i + rsurface.batchfirsttriangle*3;
        for (i = 0;i < rsurface.batchnumtriangles*3;i++)
        {
            c = e[i];
            for (j = 0;j < rsurface.entity->model->num_surfaces;j++)
            {
                if (c >= rsurface.modelsurfaces[j].num_firstvertex && c < (rsurface.modelsurfaces[j].num_firstvertex + rsurface.modelsurfaces[j].num_vertices))
                {
                    if (rsurface.modelsurfaces[j].texture != rsurface.texture)
                        Sys_Error("RSurf_DrawBatch: index %i uses different texture (%s) than surface %i which it belongs to (which uses %s)\n", c, rsurface.texture->name, j, rsurface.modelsurfaces[j].texture->name);
                    break;
                }
            }
        }
    }
#endif
    if (rsurface.batchmultidraw)
    {
        // issue multiple draws rather than copying index data
        int numsurfaces = rsurface.batchmultidrawnumsurfaces;
        const msurface_t **surfacelist = rsurface.batchmultidrawsurfacelist;
        int i, j, k, firstvertex, endvertex, firsttriangle, endtriangle;
        for (i = 0;i < numsurfaces;)
        {
            // combine consecutive surfaces as one draw
            for (k = i, j = i + 1;j < numsurfaces;k = j, j++)
                if (surfacelist[j] != surfacelist[k] + 1)
                    break;
            firstvertex = surfacelist[i]->num_firstvertex;
            endvertex = surfacelist[k]->num_firstvertex + surfacelist[k]->num_vertices;
            firsttriangle = surfacelist[i]->num_firsttriangle;
            endtriangle = surfacelist[k]->num_firsttriangle + surfacelist[k]->num_triangles;
            R_Mesh_Draw(firstvertex, endvertex - firstvertex, firsttriangle, endtriangle - firsttriangle, rsurface.batchelement3i, rsurface.batchelement3i_indexbuffer, rsurface.batchelement3i_bufferoffset, rsurface.batchelement3s, rsurface.batchelement3s_indexbuffer, rsurface.batchelement3s_bufferoffset);
            i = j;
        }
    }
    else
    {
        // there is only one consecutive run of index data (may have been combined)
        R_Mesh_Draw(rsurface.batchfirstvertex, rsurface.batchnumvertices, rsurface.batchfirsttriangle, rsurface.batchnumtriangles, rsurface.batchelement3i, rsurface.batchelement3i_indexbuffer, rsurface.batchelement3i_bufferoffset, rsurface.batchelement3s, rsurface.batchelement3s_indexbuffer, rsurface.batchelement3s_bufferoffset);
    }
}

References msurface_t::num_firsttriangle, msurface_t::num_firstvertex, msurface_t::num_triangles, msurface_t::num_vertices, R_Mesh_Draw(), r_refdef, r_test, rsurface, and Sys_Error().

Referenced by R_DrawDebugModel(), R_DrawSurface_TransparentCallback(), R_DrawTextureSurfaceList_DepthOnly(), R_DrawTextureSurfaceList_GL20(), R_DrawTextureSurfaceList_ShowSurfaces(), R_DrawTextureSurfaceList_Sky(), R_Mod_DrawShadowMap(), R_Shadow_RenderLighting_Light_GLSL(), and R_Shadow_RenderLighting_VisibleLighting().

◆ RSurf_FogPoint()

float RSurf_FogPoint ( const float * v )

Definition at line 7308 of file gl_rmain.c.

{
    // this code is identical to the USEFOGINSIDE/USEFOGOUTSIDE code in the shader
    float FogPlaneViewDist = r_refdef.fogplaneviewdist;
    float FogPlaneVertexDist = DotProduct(r_refdef.fogplane, v) + r_refdef.fogplane[3];
    float FogHeightFade = r_refdef.fogheightfade;
    float fogfrac;
    unsigned int fogmasktableindex;
    if (r_refdef.fogplaneviewabove)
        fogfrac = min(0.0f, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0f, min(0.0f, FogPlaneVertexDist) * FogHeightFade);
    else
        fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0f, FogPlaneVertexDist)) * min(1.0f, (min(0.0f, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);
    fogmasktableindex = (unsigned int)(VectorDistance(r_refdef.view.origin, v) * fogfrac * r_refdef.fogmasktabledistmultiplier);
    return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
}

References DotProduct, fogfrac, FogHeightFade, FOGMASKTABLEWIDTH, FogPlaneVertexDist, FogPlaneViewDist, int(), max, min, r_refdef, v, and VectorDistance.

◆ RSurf_FogVertex()

float RSurf_FogVertex ( const float * v )

Definition at line 7324 of file gl_rmain.c.

{
    // this code is identical to the USEFOGINSIDE/USEFOGOUTSIDE code in the shader
    float FogPlaneViewDist = rsurface.fogplaneviewdist;
    float FogPlaneVertexDist = DotProduct(rsurface.fogplane, v) + rsurface.fogplane[3];
    float FogHeightFade = rsurface.fogheightfade;
    float fogfrac;
    unsigned int fogmasktableindex;
    if (r_refdef.fogplaneviewabove)
        fogfrac = min(0.0f, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0f, min(0.0f, FogPlaneVertexDist) * FogHeightFade);
    else
        fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0f, FogPlaneVertexDist)) * min(1.0f, (min(0.0f, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);
    fogmasktableindex = (unsigned int)(VectorDistance(rsurface.localvieworigin, v) * fogfrac * rsurface.fogmasktabledistmultiplier);
    return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
}

References DotProduct, fogfrac, FogHeightFade, FOGMASKTABLEWIDTH, FogPlaneVertexDist, FogPlaneViewDist, int(), max, min, r_refdef, rsurface, v, and VectorDistance.

Referenced by R_DrawBBoxMesh(), R_DrawModelDecals_Entity(), R_DrawNoModel_TransparentCallback(), and R_DrawParticle_TransparentCallback().

◆ RSurf_PrepareVerticesForBatch()

void RSurf_PrepareVerticesForBatch	(	int	batchneed,
		int	texturenumsurfaces,
		const msurface_t **	texturesurfacelist )

Definition at line 7388 of file gl_rmain.c.

{
    int deformindex;
    int firsttriangle;
    int numtriangles;
    int firstvertex;
    int endvertex;
    int numvertices;
    int surfacefirsttriangle;
    int surfacenumtriangles;
    int surfacefirstvertex;
    int surfaceendvertex;
    int surfacenumvertices;
    int batchnumsurfaces = texturenumsurfaces;
    int batchnumvertices;
    int batchnumtriangles;
    int i, j;
    qbool gaps;
    qbool dynamicvertex;
    float amplitude;
    float animpos;
    float center[3], forward[3], right[3], up[3], v[3], newforward[3], newright[3], newup[3];
    float waveparms[4];
    unsigned char *ub;
    q3shaderinfo_deform_t *deform;
    const msurface_t *surface, *firstsurface;
    if (!texturenumsurfaces)
        return;
    // find vertex range of this surface batch
    gaps = false;
    firstsurface = texturesurfacelist[0];
    firsttriangle = firstsurface->num_firsttriangle;
    batchnumvertices = 0;
    batchnumtriangles = 0;
    firstvertex = endvertex = firstsurface->num_firstvertex;
    for (i = 0;i < texturenumsurfaces;i++)
    {
        surface = texturesurfacelist[i];
        if (surface != firstsurface + i)
            gaps = true;
        surfacefirstvertex = surface->num_firstvertex;
        surfaceendvertex = surfacefirstvertex + surface->num_vertices;
        surfacenumvertices = surface->num_vertices;
        surfacenumtriangles = surface->num_triangles;
        if (firstvertex > surfacefirstvertex)
            firstvertex = surfacefirstvertex;
        if (endvertex < surfaceendvertex)
            endvertex = surfaceendvertex;
        batchnumvertices += surfacenumvertices;
        batchnumtriangles += surfacenumtriangles;
    }
 
    r_refdef.stats[r_stat_batch_batches]++;
    if (gaps)
        r_refdef.stats[r_stat_batch_withgaps]++;
    r_refdef.stats[r_stat_batch_surfaces] += batchnumsurfaces;
    r_refdef.stats[r_stat_batch_vertices] += batchnumvertices;
    r_refdef.stats[r_stat_batch_triangles] += batchnumtriangles;
 
    // we now know the vertex range used, and if there are any gaps in it
    rsurface.batchfirstvertex = firstvertex;
    rsurface.batchnumvertices = endvertex - firstvertex;
    rsurface.batchfirsttriangle = firsttriangle;
    rsurface.batchnumtriangles = batchnumtriangles;
 
    // check if any dynamic vertex processing must occur
    dynamicvertex = false;
 
    // we must use vertexbuffers for rendering, we can upload vertex buffers
    // easily enough but if the basevertex is non-zero it becomes more
    // difficult, so force dynamicvertex path in that case - it's suboptimal
    // but the most optimal case is to have the geometry sources provide their
    // own anyway.
    if (!rsurface.modelvertex3f_vertexbuffer && firstvertex != 0)
        dynamicvertex = true;
 
    // a cvar to force the dynamic vertex path to be taken, for debugging
    if (r_batch_debugdynamicvertexpath.integer)
    {
        if (!dynamicvertex)
        {
            r_refdef.stats[r_stat_batch_dynamic_batches_because_cvar] += 1;
            r_refdef.stats[r_stat_batch_dynamic_surfaces_because_cvar] += batchnumsurfaces;
            r_refdef.stats[r_stat_batch_dynamic_vertices_because_cvar] += batchnumvertices;
            r_refdef.stats[r_stat_batch_dynamic_triangles_because_cvar] += batchnumtriangles;
        }
        dynamicvertex = true;
    }
 
    // if there is a chance of animated vertex colors, it's a dynamic batch
    if ((batchneed & BATCHNEED_ARRAY_VERTEXCOLOR) && texturesurfacelist[0]->lightmapinfo)
    {
        if (!dynamicvertex)
        {
            r_refdef.stats[r_stat_batch_dynamic_batches_because_lightmapvertex] += 1;
            r_refdef.stats[r_stat_batch_dynamic_surfaces_because_lightmapvertex] += batchnumsurfaces;
            r_refdef.stats[r_stat_batch_dynamic_vertices_because_lightmapvertex] += batchnumvertices;
            r_refdef.stats[r_stat_batch_dynamic_triangles_because_lightmapvertex] += batchnumtriangles;
        }
        dynamicvertex = true;
    }
 
    for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform && r_deformvertexes.integer;deformindex++, deform++)
    {
        switch (deform->deform)
        {
        default:
        case Q3DEFORM_PROJECTIONSHADOW:
        case Q3DEFORM_TEXT0:
        case Q3DEFORM_TEXT1:
        case Q3DEFORM_TEXT2:
        case Q3DEFORM_TEXT3:
        case Q3DEFORM_TEXT4:
        case Q3DEFORM_TEXT5:
        case Q3DEFORM_TEXT6:
        case Q3DEFORM_TEXT7:
        case Q3DEFORM_NONE:
            break;
        case Q3DEFORM_AUTOSPRITE:
            if (!dynamicvertex)
            {
                r_refdef.stats[r_stat_batch_dynamic_batches_because_deformvertexes_autosprite] += 1;
                r_refdef.stats[r_stat_batch_dynamic_surfaces_because_deformvertexes_autosprite] += batchnumsurfaces;
                r_refdef.stats[r_stat_batch_dynamic_vertices_because_deformvertexes_autosprite] += batchnumvertices;
                r_refdef.stats[r_stat_batch_dynamic_triangles_because_deformvertexes_autosprite] += batchnumtriangles;
            }
            dynamicvertex = true;
            batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | BATCHNEED_ARRAY_TEXCOORD;
            break;
        case Q3DEFORM_AUTOSPRITE2:
            if (!dynamicvertex)
            {
                r_refdef.stats[r_stat_batch_dynamic_batches_because_deformvertexes_autosprite2] += 1;
                r_refdef.stats[r_stat_batch_dynamic_surfaces_because_deformvertexes_autosprite2] += batchnumsurfaces;
                r_refdef.stats[r_stat_batch_dynamic_vertices_because_deformvertexes_autosprite2] += batchnumvertices;
                r_refdef.stats[r_stat_batch_dynamic_triangles_because_deformvertexes_autosprite2] += batchnumtriangles;
            }
            dynamicvertex = true;
            batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_TEXCOORD;
            break;
        case Q3DEFORM_NORMAL:
            if (!dynamicvertex)
            {
                r_refdef.stats[r_stat_batch_dynamic_batches_because_deformvertexes_normal] += 1;
                r_refdef.stats[r_stat_batch_dynamic_surfaces_because_deformvertexes_normal] += batchnumsurfaces;
                r_refdef.stats[r_stat_batch_dynamic_vertices_because_deformvertexes_normal] += batchnumvertices;
                r_refdef.stats[r_stat_batch_dynamic_triangles_because_deformvertexes_normal] += batchnumtriangles;
            }
            dynamicvertex = true;
            batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_TEXCOORD;
            break;
        case Q3DEFORM_WAVE:
            if(!R_TestQ3WaveFunc(deform->wavefunc, deform->waveparms))
                break; // if wavefunc is a nop, ignore this transform
            if (!dynamicvertex)
            {
                r_refdef.stats[r_stat_batch_dynamic_batches_because_deformvertexes_wave] += 1;
                r_refdef.stats[r_stat_batch_dynamic_surfaces_because_deformvertexes_wave] += batchnumsurfaces;
                r_refdef.stats[r_stat_batch_dynamic_vertices_because_deformvertexes_wave] += batchnumvertices;
                r_refdef.stats[r_stat_batch_dynamic_triangles_because_deformvertexes_wave] += batchnumtriangles;
            }
            dynamicvertex = true;
            batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_TEXCOORD;
            break;
        case Q3DEFORM_BULGE:
            if (!dynamicvertex)
            {
                r_refdef.stats[r_stat_batch_dynamic_batches_because_deformvertexes_bulge] += 1;
                r_refdef.stats[r_stat_batch_dynamic_surfaces_because_deformvertexes_bulge] += batchnumsurfaces;
                r_refdef.stats[r_stat_batch_dynamic_vertices_because_deformvertexes_bulge] += batchnumvertices;
                r_refdef.stats[r_stat_batch_dynamic_triangles_because_deformvertexes_bulge] += batchnumtriangles;
            }
            dynamicvertex = true;
            batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_TEXCOORD;
            break;
        case Q3DEFORM_MOVE:
            if(!R_TestQ3WaveFunc(deform->wavefunc, deform->waveparms))
                break; // if wavefunc is a nop, ignore this transform
            if (!dynamicvertex)
            {
                r_refdef.stats[r_stat_batch_dynamic_batches_because_deformvertexes_move] += 1;
                r_refdef.stats[r_stat_batch_dynamic_surfaces_because_deformvertexes_move] += batchnumsurfaces;
                r_refdef.stats[r_stat_batch_dynamic_vertices_because_deformvertexes_move] += batchnumvertices;
                r_refdef.stats[r_stat_batch_dynamic_triangles_because_deformvertexes_move] += batchnumtriangles;
            }
            dynamicvertex = true;
            batchneed |= BATCHNEED_ARRAY_VERTEX;
            break;
        }
    }
    if (rsurface.texture->materialshaderpass)
    {
        switch (rsurface.texture->materialshaderpass->tcgen.tcgen)
        {
        default:
        case Q3TCGEN_TEXTURE:
            break;
        case Q3TCGEN_LIGHTMAP:
            if (!dynamicvertex)
            {
                r_refdef.stats[r_stat_batch_dynamic_batches_because_tcgen_lightmap] += 1;
                r_refdef.stats[r_stat_batch_dynamic_surfaces_because_tcgen_lightmap] += batchnumsurfaces;
                r_refdef.stats[r_stat_batch_dynamic_vertices_because_tcgen_lightmap] += batchnumvertices;
                r_refdef.stats[r_stat_batch_dynamic_triangles_because_tcgen_lightmap] += batchnumtriangles;
            }
            dynamicvertex = true;
            batchneed |= BATCHNEED_ARRAY_LIGHTMAP;
            break;
        case Q3TCGEN_VECTOR:
            if (!dynamicvertex)
            {
                r_refdef.stats[r_stat_batch_dynamic_batches_because_tcgen_vector] += 1;
                r_refdef.stats[r_stat_batch_dynamic_surfaces_because_tcgen_vector] += batchnumsurfaces;
                r_refdef.stats[r_stat_batch_dynamic_vertices_because_tcgen_vector] += batchnumvertices;
                r_refdef.stats[r_stat_batch_dynamic_triangles_because_tcgen_vector] += batchnumtriangles;
            }
            dynamicvertex = true;
            batchneed |= BATCHNEED_ARRAY_VERTEX;
            break;
        case Q3TCGEN_ENVIRONMENT:
            if (!dynamicvertex)
            {
                r_refdef.stats[r_stat_batch_dynamic_batches_because_tcgen_environment] += 1;
                r_refdef.stats[r_stat_batch_dynamic_surfaces_because_tcgen_environment] += batchnumsurfaces;
                r_refdef.stats[r_stat_batch_dynamic_vertices_because_tcgen_environment] += batchnumvertices;
                r_refdef.stats[r_stat_batch_dynamic_triangles_because_tcgen_environment] += batchnumtriangles;
            }
            dynamicvertex = true;
            batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL;
            break;
        }
        if (rsurface.texture->materialshaderpass->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
        {
            if (!dynamicvertex)
            {
                r_refdef.stats[r_stat_batch_dynamic_batches_because_tcmod_turbulent] += 1;
                r_refdef.stats[r_stat_batch_dynamic_surfaces_because_tcmod_turbulent] += batchnumsurfaces;
                r_refdef.stats[r_stat_batch_dynamic_vertices_because_tcmod_turbulent] += batchnumvertices;
                r_refdef.stats[r_stat_batch_dynamic_triangles_because_tcmod_turbulent] += batchnumtriangles;
            }
            dynamicvertex = true;
            batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_TEXCOORD;
        }
    }
 
    // the caller can specify BATCHNEED_NOGAPS to force a batch with
    // firstvertex = 0 and endvertex = numvertices (no gaps, no firstvertex),
    // we ensure this by treating the vertex batch as dynamic...
    if ((batchneed & BATCHNEED_ALWAYSCOPY) || ((batchneed & BATCHNEED_NOGAPS) && (gaps || firstvertex > 0)))
    {
        if (!dynamicvertex)
        {
            r_refdef.stats[r_stat_batch_dynamic_batches_because_nogaps] += 1;
            r_refdef.stats[r_stat_batch_dynamic_surfaces_because_nogaps] += batchnumsurfaces;
            r_refdef.stats[r_stat_batch_dynamic_vertices_because_nogaps] += batchnumvertices;
            r_refdef.stats[r_stat_batch_dynamic_triangles_because_nogaps] += batchnumtriangles;
        }
        dynamicvertex = true;
    }
 
    // if we're going to have to apply the skeletal transform manually, we need to batch the skeletal data
    if (dynamicvertex && rsurface.entityskeletaltransform3x4)
        batchneed |= BATCHNEED_ARRAY_SKELETAL;
 
    rsurface.batchvertex3f = rsurface.modelvertex3f;
    rsurface.batchvertex3f_vertexbuffer = rsurface.modelvertex3f_vertexbuffer;
    rsurface.batchvertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
    rsurface.batchsvector3f = rsurface.modelsvector3f;
    rsurface.batchsvector3f_vertexbuffer = rsurface.modelsvector3f_vertexbuffer;
    rsurface.batchsvector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
    rsurface.batchtvector3f = rsurface.modeltvector3f;
    rsurface.batchtvector3f_vertexbuffer = rsurface.modeltvector3f_vertexbuffer;
    rsurface.batchtvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
    rsurface.batchnormal3f = rsurface.modelnormal3f;
    rsurface.batchnormal3f_vertexbuffer = rsurface.modelnormal3f_vertexbuffer;
    rsurface.batchnormal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
    rsurface.batchlightmapcolor4f = rsurface.modellightmapcolor4f;
    rsurface.batchlightmapcolor4f_vertexbuffer  = rsurface.modellightmapcolor4f_vertexbuffer;
    rsurface.batchlightmapcolor4f_bufferoffset  = rsurface.modellightmapcolor4f_bufferoffset;
    rsurface.batchtexcoordtexture2f = rsurface.modeltexcoordtexture2f;
    rsurface.batchtexcoordtexture2f_vertexbuffer  = rsurface.modeltexcoordtexture2f_vertexbuffer;
    rsurface.batchtexcoordtexture2f_bufferoffset  = rsurface.modeltexcoordtexture2f_bufferoffset;
    rsurface.batchtexcoordlightmap2f = rsurface.modeltexcoordlightmap2f;
    rsurface.batchtexcoordlightmap2f_vertexbuffer = rsurface.modeltexcoordlightmap2f_vertexbuffer;
    rsurface.batchtexcoordlightmap2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
    rsurface.batchskeletalindex4ub = rsurface.modelskeletalindex4ub;
    rsurface.batchskeletalindex4ub_vertexbuffer = rsurface.modelskeletalindex4ub_vertexbuffer;
    rsurface.batchskeletalindex4ub_bufferoffset = rsurface.modelskeletalindex4ub_bufferoffset;
    rsurface.batchskeletalweight4ub = rsurface.modelskeletalweight4ub;
    rsurface.batchskeletalweight4ub_vertexbuffer = rsurface.modelskeletalweight4ub_vertexbuffer;
    rsurface.batchskeletalweight4ub_bufferoffset = rsurface.modelskeletalweight4ub_bufferoffset;
    rsurface.batchelement3i = rsurface.modelelement3i;
    rsurface.batchelement3i_indexbuffer = rsurface.modelelement3i_indexbuffer;
    rsurface.batchelement3i_bufferoffset = rsurface.modelelement3i_bufferoffset;
    rsurface.batchelement3s = rsurface.modelelement3s;
    rsurface.batchelement3s_indexbuffer = rsurface.modelelement3s_indexbuffer;
    rsurface.batchelement3s_bufferoffset = rsurface.modelelement3s_bufferoffset;
    rsurface.batchskeletaltransform3x4 = rsurface.entityskeletaltransform3x4;
    rsurface.batchskeletaltransform3x4buffer = rsurface.entityskeletaltransform3x4buffer;
    rsurface.batchskeletaltransform3x4offset = rsurface.entityskeletaltransform3x4offset;
    rsurface.batchskeletaltransform3x4size = rsurface.entityskeletaltransform3x4size;
    rsurface.batchskeletalnumtransforms = rsurface.entityskeletalnumtransforms;
 
    // if any dynamic vertex processing has to occur in software, we copy the
    // entire surface list together before processing to rebase the vertices
    // to start at 0 (otherwise we waste a lot of room in a vertex buffer).
    //
    // if any gaps exist and we do not have a static vertex buffer, we have to
    // copy the surface list together to avoid wasting upload bandwidth on the
    // vertices in the gaps.
    //
    // if gaps exist and we have a static vertex buffer, we can choose whether
    // to combine the index buffer ranges into one dynamic index buffer or
    // simply issue multiple glDrawElements calls (BATCHNEED_ALLOWMULTIDRAW).
    //
    // in many cases the batch is reduced to one draw call.
 
    rsurface.batchmultidraw = false;
    rsurface.batchmultidrawnumsurfaces = 0;
    rsurface.batchmultidrawsurfacelist = NULL;
 
    if (!dynamicvertex)
    {
        // static vertex data, just set pointers...
        rsurface.batchgeneratedvertex = false;
        // if there are gaps, we want to build a combined index buffer,
        // otherwise use the original static buffer with an appropriate offset
        if (gaps)
        {
            r_refdef.stats[r_stat_batch_copytriangles_batches] += 1;
            r_refdef.stats[r_stat_batch_copytriangles_surfaces] += batchnumsurfaces;
            r_refdef.stats[r_stat_batch_copytriangles_vertices] += batchnumvertices;
            r_refdef.stats[r_stat_batch_copytriangles_triangles] += batchnumtriangles;
            if ((batchneed & BATCHNEED_ALLOWMULTIDRAW) && r_batch_multidraw.integer && batchnumtriangles >= r_batch_multidraw_mintriangles.integer)
            {
                rsurface.batchmultidraw = true;
                rsurface.batchmultidrawnumsurfaces = texturenumsurfaces;
                rsurface.batchmultidrawsurfacelist = texturesurfacelist;
                return;
            }
            // build a new triangle elements array for this batch
            rsurface.batchelement3i = (int *)R_FrameData_Alloc(batchnumtriangles * sizeof(int[3]));
            rsurface.batchfirsttriangle = 0;
            numtriangles = 0;
            for (i = 0;i < texturenumsurfaces;i++)
            {
                surfacefirsttriangle = texturesurfacelist[i]->num_firsttriangle;
                surfacenumtriangles = texturesurfacelist[i]->num_triangles;
                memcpy(rsurface.batchelement3i + 3*numtriangles, rsurface.modelelement3i + 3*surfacefirsttriangle, surfacenumtriangles*sizeof(int[3]));
                numtriangles += surfacenumtriangles;
            }
            rsurface.batchelement3i_indexbuffer = NULL;
            rsurface.batchelement3i_bufferoffset = 0;
            rsurface.batchelement3s = NULL;
            rsurface.batchelement3s_indexbuffer = NULL;
            rsurface.batchelement3s_bufferoffset = 0;
            if (endvertex <= 65536)
            {
                // make a 16bit (unsigned short) index array if possible
                rsurface.batchelement3s = (unsigned short *)R_FrameData_Alloc(batchnumtriangles * sizeof(unsigned short[3]));
                for (i = 0;i < numtriangles*3;i++)
                    rsurface.batchelement3s[i] = rsurface.batchelement3i[i];
            }
        }
        else
        {
            r_refdef.stats[r_stat_batch_fast_batches] += 1;
            r_refdef.stats[r_stat_batch_fast_surfaces] += batchnumsurfaces;
            r_refdef.stats[r_stat_batch_fast_vertices] += batchnumvertices;
            r_refdef.stats[r_stat_batch_fast_triangles] += batchnumtriangles;
        }
        return;
    }
 
    // something needs software processing, do it for real...
    // we only directly handle separate array data in this case and then
    // generate interleaved data if needed...
    rsurface.batchgeneratedvertex = true;
    r_refdef.stats[r_stat_batch_dynamic_batches] += 1;
    r_refdef.stats[r_stat_batch_dynamic_surfaces] += batchnumsurfaces;
    r_refdef.stats[r_stat_batch_dynamic_vertices] += batchnumvertices;
    r_refdef.stats[r_stat_batch_dynamic_triangles] += batchnumtriangles;
 
    // now copy the vertex data into a combined array and make an index array
    // (this is what Quake3 does all the time)
    // we also apply any skeletal animation here that would have been done in
    // the vertex shader, because most of the dynamic vertex animation cases
    // need actual vertex positions and normals
    //if (dynamicvertex)
    {
        rsurface.batchvertex3f = NULL;
        rsurface.batchvertex3f_vertexbuffer = NULL;
        rsurface.batchvertex3f_bufferoffset = 0;
        rsurface.batchsvector3f = NULL;
        rsurface.batchsvector3f_vertexbuffer = NULL;
        rsurface.batchsvector3f_bufferoffset = 0;
        rsurface.batchtvector3f = NULL;
        rsurface.batchtvector3f_vertexbuffer = NULL;
        rsurface.batchtvector3f_bufferoffset = 0;
        rsurface.batchnormal3f = NULL;
        rsurface.batchnormal3f_vertexbuffer = NULL;
        rsurface.batchnormal3f_bufferoffset = 0;
        rsurface.batchlightmapcolor4f = NULL;
        rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
        rsurface.batchlightmapcolor4f_bufferoffset = 0;
        rsurface.batchtexcoordtexture2f = NULL;
        rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
        rsurface.batchtexcoordtexture2f_bufferoffset = 0;
        rsurface.batchtexcoordlightmap2f = NULL;
        rsurface.batchtexcoordlightmap2f_vertexbuffer = NULL;
        rsurface.batchtexcoordlightmap2f_bufferoffset = 0;
        rsurface.batchskeletalindex4ub = NULL;
        rsurface.batchskeletalindex4ub_vertexbuffer = NULL;
        rsurface.batchskeletalindex4ub_bufferoffset = 0;
        rsurface.batchskeletalweight4ub = NULL;
        rsurface.batchskeletalweight4ub_vertexbuffer = NULL;
        rsurface.batchskeletalweight4ub_bufferoffset = 0;
        rsurface.batchelement3i = (int *)R_FrameData_Alloc(batchnumtriangles * sizeof(int[3]));
        rsurface.batchelement3i_indexbuffer = NULL;
        rsurface.batchelement3i_bufferoffset = 0;
        rsurface.batchelement3s = NULL;
        rsurface.batchelement3s_indexbuffer = NULL;
        rsurface.batchelement3s_bufferoffset = 0;
        rsurface.batchskeletaltransform3x4buffer = NULL;
        rsurface.batchskeletaltransform3x4offset = 0;
        rsurface.batchskeletaltransform3x4size = 0;
        // we'll only be setting up certain arrays as needed
        if (batchneed & BATCHNEED_ARRAY_VERTEX)
            rsurface.batchvertex3f = (float *)R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
        if (batchneed & BATCHNEED_ARRAY_NORMAL)
            rsurface.batchnormal3f = (float *)R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
        if (batchneed & BATCHNEED_ARRAY_VECTOR)
        {
            rsurface.batchsvector3f = (float *)R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
            rsurface.batchtvector3f = (float *)R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
        }
        if (batchneed & BATCHNEED_ARRAY_VERTEXCOLOR)
            rsurface.batchlightmapcolor4f = (float *)R_FrameData_Alloc(batchnumvertices * sizeof(float[4]));
        if (batchneed & BATCHNEED_ARRAY_TEXCOORD)
            rsurface.batchtexcoordtexture2f = (float *)R_FrameData_Alloc(batchnumvertices * sizeof(float[2]));
        if (batchneed & BATCHNEED_ARRAY_LIGHTMAP)
            rsurface.batchtexcoordlightmap2f = (float *)R_FrameData_Alloc(batchnumvertices * sizeof(float[2]));
        if (batchneed & BATCHNEED_ARRAY_SKELETAL)
        {
            rsurface.batchskeletalindex4ub = (unsigned char *)R_FrameData_Alloc(batchnumvertices * sizeof(unsigned char[4]));
            rsurface.batchskeletalweight4ub = (unsigned char *)R_FrameData_Alloc(batchnumvertices * sizeof(unsigned char[4]));
        }
        numvertices = 0;
        numtriangles = 0;
        for (i = 0;i < texturenumsurfaces;i++)
        {
            surfacefirstvertex = texturesurfacelist[i]->num_firstvertex;
            surfacenumvertices = texturesurfacelist[i]->num_vertices;
            surfacefirsttriangle = texturesurfacelist[i]->num_firsttriangle;
            surfacenumtriangles = texturesurfacelist[i]->num_triangles;
            // copy only the data requested
            if (batchneed & (BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | BATCHNEED_ARRAY_VERTEXCOLOR | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_ARRAY_LIGHTMAP))
            {
                if (batchneed & BATCHNEED_ARRAY_VERTEX)
                {
                    if (rsurface.batchvertex3f)
                        memcpy(rsurface.batchvertex3f + 3*numvertices, rsurface.modelvertex3f + 3*surfacefirstvertex, surfacenumvertices * sizeof(float[3]));
                    else
                        memset(rsurface.batchvertex3f + 3*numvertices, 0, surfacenumvertices * sizeof(float[3]));
                }
                if (batchneed & BATCHNEED_ARRAY_NORMAL)
                {
                    if (rsurface.modelnormal3f)
                        memcpy(rsurface.batchnormal3f + 3*numvertices, rsurface.modelnormal3f + 3*surfacefirstvertex, surfacenumvertices * sizeof(float[3]));
                    else
                        memset(rsurface.batchnormal3f + 3*numvertices, 0, surfacenumvertices * sizeof(float[3]));
                }
                if (batchneed & BATCHNEED_ARRAY_VECTOR)
                {
                    if (rsurface.modelsvector3f)
                    {
                        memcpy(rsurface.batchsvector3f + 3*numvertices, rsurface.modelsvector3f + 3*surfacefirstvertex, surfacenumvertices * sizeof(float[3]));
                        memcpy(rsurface.batchtvector3f + 3*numvertices, rsurface.modeltvector3f + 3*surfacefirstvertex, surfacenumvertices * sizeof(float[3]));
                    }
                    else
                    {
                        memset(rsurface.batchsvector3f + 3*numvertices, 0, surfacenumvertices * sizeof(float[3]));
                        memset(rsurface.batchtvector3f + 3*numvertices, 0, surfacenumvertices * sizeof(float[3]));
                    }
                }
                if (batchneed & BATCHNEED_ARRAY_VERTEXCOLOR)
                {
                    if (rsurface.modellightmapcolor4f)
                        memcpy(rsurface.batchlightmapcolor4f + 4*numvertices, rsurface.modellightmapcolor4f + 4*surfacefirstvertex, surfacenumvertices * sizeof(float[4]));
                    else
                        memset(rsurface.batchlightmapcolor4f + 4*numvertices, 0, surfacenumvertices * sizeof(float[4]));
                }
                if (batchneed & BATCHNEED_ARRAY_TEXCOORD)
                {
                    if (rsurface.modeltexcoordtexture2f)
                        memcpy(rsurface.batchtexcoordtexture2f + 2*numvertices, rsurface.modeltexcoordtexture2f + 2*surfacefirstvertex, surfacenumvertices * sizeof(float[2]));
                    else
                        memset(rsurface.batchtexcoordtexture2f + 2*numvertices, 0, surfacenumvertices * sizeof(float[2]));
                }
                if (batchneed & BATCHNEED_ARRAY_LIGHTMAP)
                {
                    if (rsurface.modeltexcoordlightmap2f)
                        memcpy(rsurface.batchtexcoordlightmap2f + 2*numvertices, rsurface.modeltexcoordlightmap2f + 2*surfacefirstvertex, surfacenumvertices * sizeof(float[2]));
                    else
                        memset(rsurface.batchtexcoordlightmap2f + 2*numvertices, 0, surfacenumvertices * sizeof(float[2]));
                }
                if (batchneed & BATCHNEED_ARRAY_SKELETAL)
                {
                    if (rsurface.modelskeletalindex4ub)
                    {
                        memcpy(rsurface.batchskeletalindex4ub + 4*numvertices, rsurface.modelskeletalindex4ub + 4*surfacefirstvertex, surfacenumvertices * sizeof(unsigned char[4]));
                        memcpy(rsurface.batchskeletalweight4ub + 4*numvertices, rsurface.modelskeletalweight4ub + 4*surfacefirstvertex, surfacenumvertices * sizeof(unsigned char[4]));
                    }
                    else
                    {
                        memset(rsurface.batchskeletalindex4ub + 4*numvertices, 0, surfacenumvertices * sizeof(unsigned char[4]));
                        memset(rsurface.batchskeletalweight4ub + 4*numvertices, 0, surfacenumvertices * sizeof(unsigned char[4]));
                        ub = rsurface.batchskeletalweight4ub + 4*numvertices;
                        for (j = 0;j < surfacenumvertices;j++)
                            ub[j*4] = 255;
                    }
                }
            }
            RSurf_RenumberElements(rsurface.modelelement3i + 3*surfacefirsttriangle, rsurface.batchelement3i + 3*numtriangles, 3*surfacenumtriangles, numvertices - surfacefirstvertex);
            numvertices += surfacenumvertices;
            numtriangles += surfacenumtriangles;
        }
 
        // generate a 16bit index array as well if possible
        // (in general, dynamic batches fit)
        if (numvertices <= 65536)
        {
            rsurface.batchelement3s = (unsigned short *)R_FrameData_Alloc(batchnumtriangles * sizeof(unsigned short[3]));
            for (i = 0;i < numtriangles*3;i++)
                rsurface.batchelement3s[i] = rsurface.batchelement3i[i];
        }
 
        // since we've copied everything, the batch now starts at 0
        rsurface.batchfirstvertex = 0;
        rsurface.batchnumvertices = batchnumvertices;
        rsurface.batchfirsttriangle = 0;
        rsurface.batchnumtriangles = batchnumtriangles;
    }
 
    // apply skeletal animation that would have been done in the vertex shader
    if (rsurface.batchskeletaltransform3x4)
    {
        const unsigned char *si;
        const unsigned char *sw;
        const float *t[4];
        const float *b = rsurface.batchskeletaltransform3x4;
        float *vp, *vs, *vt, *vn;
        float w[4];
        float m[3][4], n[3][4];
        float tp[3], ts[3], tt[3], tn[3];
        r_refdef.stats[r_stat_batch_dynamicskeletal_batches] += 1;
        r_refdef.stats[r_stat_batch_dynamicskeletal_surfaces] += batchnumsurfaces;
        r_refdef.stats[r_stat_batch_dynamicskeletal_vertices] += batchnumvertices;
        r_refdef.stats[r_stat_batch_dynamicskeletal_triangles] += batchnumtriangles;
        si = rsurface.batchskeletalindex4ub;
        sw = rsurface.batchskeletalweight4ub;
        vp = rsurface.batchvertex3f;
        vs = rsurface.batchsvector3f;
        vt = rsurface.batchtvector3f;
        vn = rsurface.batchnormal3f;
        memset(m[0], 0, sizeof(m));
        memset(n[0], 0, sizeof(n));
        for (i = 0;i < batchnumvertices;i++)
        {
            t[0] = b + si[0]*12;
            if (sw[0] == 255)
            {
                // common case - only one matrix
                m[0][0] = t[0][ 0];
                m[0][1] = t[0][ 1];
                m[0][2] = t[0][ 2];
                m[0][3] = t[0][ 3];
                m[1][0] = t[0][ 4];
                m[1][1] = t[0][ 5];
                m[1][2] = t[0][ 6];
                m[1][3] = t[0][ 7];
                m[2][0] = t[0][ 8];
                m[2][1] = t[0][ 9];
                m[2][2] = t[0][10];
                m[2][3] = t[0][11];
            }
            else if (sw[2] + sw[3])
            {
                // blend 4 matrices
                t[1] = b + si[1]*12;
                t[2] = b + si[2]*12;
                t[3] = b + si[3]*12;
                w[0] = sw[0] * (1.0f / 255.0f);
                w[1] = sw[1] * (1.0f / 255.0f);
                w[2] = sw[2] * (1.0f / 255.0f);
                w[3] = sw[3] * (1.0f / 255.0f);
                // blend the matrices
                m[0][0] = t[0][ 0] * w[0] + t[1][ 0] * w[1] + t[2][ 0] * w[2] + t[3][ 0] * w[3];
                m[0][1] = t[0][ 1] * w[0] + t[1][ 1] * w[1] + t[2][ 1] * w[2] + t[3][ 1] * w[3];
                m[0][2] = t[0][ 2] * w[0] + t[1][ 2] * w[1] + t[2][ 2] * w[2] + t[3][ 2] * w[3];
                m[0][3] = t[0][ 3] * w[0] + t[1][ 3] * w[1] + t[2][ 3] * w[2] + t[3][ 3] * w[3];
                m[1][0] = t[0][ 4] * w[0] + t[1][ 4] * w[1] + t[2][ 4] * w[2] + t[3][ 4] * w[3];
                m[1][1] = t[0][ 5] * w[0] + t[1][ 5] * w[1] + t[2][ 5] * w[2] + t[3][ 5] * w[3];
                m[1][2] = t[0][ 6] * w[0] + t[1][ 6] * w[1] + t[2][ 6] * w[2] + t[3][ 6] * w[3];
                m[1][3] = t[0][ 7] * w[0] + t[1][ 7] * w[1] + t[2][ 7] * w[2] + t[3][ 7] * w[3];
                m[2][0] = t[0][ 8] * w[0] + t[1][ 8] * w[1] + t[2][ 8] * w[2] + t[3][ 8] * w[3];
                m[2][1] = t[0][ 9] * w[0] + t[1][ 9] * w[1] + t[2][ 9] * w[2] + t[3][ 9] * w[3];
                m[2][2] = t[0][10] * w[0] + t[1][10] * w[1] + t[2][10] * w[2] + t[3][10] * w[3];
                m[2][3] = t[0][11] * w[0] + t[1][11] * w[1] + t[2][11] * w[2] + t[3][11] * w[3];
            }
            else
            {
                // blend 2 matrices
                t[1] = b + si[1]*12;
                w[0] = sw[0] * (1.0f / 255.0f);
                w[1] = sw[1] * (1.0f / 255.0f);
                // blend the matrices
                m[0][0] = t[0][ 0] * w[0] + t[1][ 0] * w[1];
                m[0][1] = t[0][ 1] * w[0] + t[1][ 1] * w[1];
                m[0][2] = t[0][ 2] * w[0] + t[1][ 2] * w[1];
                m[0][3] = t[0][ 3] * w[0] + t[1][ 3] * w[1];
                m[1][0] = t[0][ 4] * w[0] + t[1][ 4] * w[1];
                m[1][1] = t[0][ 5] * w[0] + t[1][ 5] * w[1];
                m[1][2] = t[0][ 6] * w[0] + t[1][ 6] * w[1];
                m[1][3] = t[0][ 7] * w[0] + t[1][ 7] * w[1];
                m[2][0] = t[0][ 8] * w[0] + t[1][ 8] * w[1];
                m[2][1] = t[0][ 9] * w[0] + t[1][ 9] * w[1];
                m[2][2] = t[0][10] * w[0] + t[1][10] * w[1];
                m[2][3] = t[0][11] * w[0] + t[1][11] * w[1];
            }
            si += 4;
            sw += 4;
            // modify the vertex
            VectorCopy(vp, tp);
            vp[0] = tp[0] * m[0][0] + tp[1] * m[0][1] + tp[2] * m[0][2] + m[0][3];
            vp[1] = tp[0] * m[1][0] + tp[1] * m[1][1] + tp[2] * m[1][2] + m[1][3];
            vp[2] = tp[0] * m[2][0] + tp[1] * m[2][1] + tp[2] * m[2][2] + m[2][3];
            vp += 3;
            if (vn)
            {
                // the normal transformation matrix is a set of cross products...
                CrossProduct(m[1], m[2], n[0]);
                CrossProduct(m[2], m[0], n[1]);
                CrossProduct(m[0], m[1], n[2]); // is actually transpose(inverse(m)) * det(m)
                VectorCopy(vn, tn);
                vn[0] = tn[0] * n[0][0] + tn[1] * n[0][1] + tn[2] * n[0][2];
                vn[1] = tn[0] * n[1][0] + tn[1] * n[1][1] + tn[2] * n[1][2];
                vn[2] = tn[0] * n[2][0] + tn[1] * n[2][1] + tn[2] * n[2][2];
                VectorNormalize(vn);
                vn += 3;
                if (vs)
                {
                    VectorCopy(vs, ts);
                    vs[0] = ts[0] * n[0][0] + ts[1] * n[0][1] + ts[2] * n[0][2];
                    vs[1] = ts[0] * n[1][0] + ts[1] * n[1][1] + ts[2] * n[1][2];
                    vs[2] = ts[0] * n[2][0] + ts[1] * n[2][1] + ts[2] * n[2][2];
                    VectorNormalize(vs);
                    vs += 3;
                    VectorCopy(vt, tt);
                    vt[0] = tt[0] * n[0][0] + tt[1] * n[0][1] + tt[2] * n[0][2];
                    vt[1] = tt[0] * n[1][0] + tt[1] * n[1][1] + tt[2] * n[1][2];
                    vt[2] = tt[0] * n[2][0] + tt[1] * n[2][1] + tt[2] * n[2][2];
                    VectorNormalize(vt);
                    vt += 3;
                }
            }
        }
        rsurface.batchskeletaltransform3x4 = NULL;
        rsurface.batchskeletalnumtransforms = 0;
    }
 
    // q1bsp surfaces rendered in vertex color mode have to have colors
    // calculated based on lightstyles
    if ((batchneed & BATCHNEED_ARRAY_VERTEXCOLOR) && texturesurfacelist[0]->lightmapinfo)
    {
        // generate color arrays for the surfaces in this list
        int c[4];
        int scale;
        int size3;
        const int *offsets;
        const unsigned char *lm;
        rsurface.batchlightmapcolor4f = (float *)R_FrameData_Alloc(batchnumvertices * sizeof(float[4]));
        rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
        rsurface.batchlightmapcolor4f_bufferoffset = 0;
        numvertices = 0;
        for (i = 0;i < texturenumsurfaces;i++)
        {
            surface = texturesurfacelist[i];
            offsets = rsurface.modellightmapoffsets + surface->num_firstvertex;
            surfacenumvertices = surface->num_vertices;
            if (surface->lightmapinfo->samples)
            {
                for (j = 0;j < surfacenumvertices;j++)
                {
                    lm = surface->lightmapinfo->samples + offsets[j];
                    scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[0]];
                    VectorScale(lm, scale, c);
                    if (surface->lightmapinfo->styles[1] != 255)
                    {
                        size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
                        lm += size3;
                        scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[1]];
                        VectorMA(c, scale, lm, c);
                        if (surface->lightmapinfo->styles[2] != 255)
                        {
                            lm += size3;
                            scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[2]];
                            VectorMA(c, scale, lm, c);
                            if (surface->lightmapinfo->styles[3] != 255)
                            {
                                lm += size3;
                                scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[3]];
                                VectorMA(c, scale, lm, c);
                            }
                        }
                    }
                    c[0] >>= 7;
                    c[1] >>= 7;
                    c[2] >>= 7;
                    Vector4Set(rsurface.batchlightmapcolor4f + 4*numvertices, min(c[0], 255) * (1.0f / 255.0f), min(c[1], 255) * (1.0f / 255.0f), min(c[2], 255) * (1.0f / 255.0f), 1);
                    numvertices++;
                }
            }
            else
            {
                for (j = 0;j < surfacenumvertices;j++)
                {
                    Vector4Set(rsurface.batchlightmapcolor4f + 4*numvertices, 0, 0, 0, 1);
                    numvertices++;
                }
            }
        }
    }
 
    // if vertices are deformed (sprite flares and things in maps, possibly
    // water waves, bulges and other deformations), modify the copied vertices
    // in place
    for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform && r_deformvertexes.integer;deformindex++, deform++)
    {
        float scale;
        switch (deform->deform)
        {
        default:
        case Q3DEFORM_PROJECTIONSHADOW:
        case Q3DEFORM_TEXT0:
        case Q3DEFORM_TEXT1:
        case Q3DEFORM_TEXT2:
        case Q3DEFORM_TEXT3:
        case Q3DEFORM_TEXT4:
        case Q3DEFORM_TEXT5:
        case Q3DEFORM_TEXT6:
        case Q3DEFORM_TEXT7:
        case Q3DEFORM_NONE:
            break;
        case Q3DEFORM_AUTOSPRITE:
            Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
            Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
            Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
            VectorNormalize(newforward);
            VectorNormalize(newright);
            VectorNormalize(newup);
//          rsurface.batchvertex3f = R_FrameData_Store(batchnumvertices * sizeof(float[3]), rsurface.batchvertex3f);
//          rsurface.batchvertex3f_vertexbuffer = NULL;
//          rsurface.batchvertex3f_bufferoffset = 0;
//          rsurface.batchsvector3f = R_FrameData_Store(batchnumvertices * sizeof(float[3]), rsurface.batchsvector3f);
//          rsurface.batchsvector3f_vertexbuffer = NULL;
//          rsurface.batchsvector3f_bufferoffset = 0;
//          rsurface.batchtvector3f = R_FrameData_Store(batchnumvertices * sizeof(float[3]), rsurface.batchtvector3f);
//          rsurface.batchtvector3f_vertexbuffer = NULL;
//          rsurface.batchtvector3f_bufferoffset = 0;
//          rsurface.batchnormal3f = R_FrameData_Store(batchnumvertices * sizeof(float[3]), rsurface.batchnormal3f);
//          rsurface.batchnormal3f_vertexbuffer = NULL;
//          rsurface.batchnormal3f_bufferoffset = 0;
            // sometimes we're on a renderpath that does not use vectors (GL11/GL13/GLES1)
            if (!VectorLength2(rsurface.batchnormal3f + 3*rsurface.batchfirstvertex))
                Mod_BuildNormals(rsurface.batchfirstvertex, batchnumvertices, batchnumtriangles, rsurface.batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.batchnormal3f, r_smoothnormals_areaweighting.integer != 0);
            if (!VectorLength2(rsurface.batchsvector3f + 3*rsurface.batchfirstvertex))
                Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, batchnumvertices, batchnumtriangles, rsurface.batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.batchsvector3f, rsurface.batchtvector3f, r_smoothnormals_areaweighting.integer != 0);
            // a single autosprite surface can contain multiple sprites...
            for (j = 0;j < batchnumvertices - 3;j += 4)
            {
                VectorClear(center);
                for (i = 0;i < 4;i++)
                    VectorAdd(center, rsurface.batchvertex3f + 3*(j+i), center);
                VectorScale(center, 0.25f, center);
                VectorCopy(rsurface.batchnormal3f + 3*j, forward);
                VectorCopy(rsurface.batchsvector3f + 3*j, right);
                VectorCopy(rsurface.batchtvector3f + 3*j, up);
                for (i = 0;i < 4;i++)
                {
                    VectorSubtract(rsurface.batchvertex3f + 3*(j+i), center, v);
                    VectorMAMAMAM(1, center, DotProduct(forward, v), newforward, DotProduct(right, v), newright, DotProduct(up, v), newup, rsurface.batchvertex3f + 3*(j+i));
                }
            }
            // if we get here, BATCHNEED_ARRAY_NORMAL and BATCHNEED_ARRAY_VECTOR are in batchneed, so no need to check
            Mod_BuildNormals(rsurface.batchfirstvertex, batchnumvertices, batchnumtriangles, rsurface.batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.batchnormal3f, r_smoothnormals_areaweighting.integer != 0);
            Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, batchnumvertices, batchnumtriangles, rsurface.batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.batchsvector3f, rsurface.batchtvector3f, r_smoothnormals_areaweighting.integer != 0);
            break;
        case Q3DEFORM_AUTOSPRITE2:
            Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
            Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
            Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
            VectorNormalize(newforward);
            VectorNormalize(newright);
            VectorNormalize(newup);
//          rsurface.batchvertex3f = R_FrameData_Store(batchnumvertices * sizeof(float[3]), rsurface.batchvertex3f);
//          rsurface.batchvertex3f_vertexbuffer = NULL;
//          rsurface.batchvertex3f_bufferoffset = 0;
            {
                const float *v1, *v2;
                vec3_t start, end;
                float f, l;
                struct
                {
                    float length2;
                    const float *v1;
                    const float *v2;
                }
                shortest[2];
                memset(shortest, 0, sizeof(shortest));
                // a single autosprite surface can contain multiple sprites...
                for (j = 0;j < batchnumvertices - 3;j += 4)
                {
                    VectorClear(center);
                    for (i = 0;i < 4;i++)
                        VectorAdd(center, rsurface.batchvertex3f + 3*(j+i), center);
                    VectorScale(center, 0.25f, center);
                    // find the two shortest edges, then use them to define the
                    // axis vectors for rotating around the central axis
                    for (i = 0;i < 6;i++)
                    {
                        v1 = rsurface.batchvertex3f + 3*(j+quadedges[i][0]);
                        v2 = rsurface.batchvertex3f + 3*(j+quadedges[i][1]);
                        l = VectorDistance2(v1, v2);
                        // this length bias tries to make sense of square polygons, assuming they are meant to be upright
                        if (v1[2] != v2[2])
                            l += (1.0f / 1024.0f);
                        if (shortest[0].length2 > l || i == 0)
                        {
                            shortest[1] = shortest[0];
                            shortest[0].length2 = l;
                            shortest[0].v1 = v1;
                            shortest[0].v2 = v2;
                        }
                        else if (shortest[1].length2 > l || i == 1)
                        {
                            shortest[1].length2 = l;
                            shortest[1].v1 = v1;
                            shortest[1].v2 = v2;
                        }
                    }
                    VectorLerp(shortest[0].v1, 0.5f, shortest[0].v2, start);
                    VectorLerp(shortest[1].v1, 0.5f, shortest[1].v2, end);
                    // this calculates the right vector from the shortest edge
                    // and the up vector from the edge midpoints
                    VectorSubtract(shortest[0].v1, shortest[0].v2, right);
                    VectorNormalize(right);
                    VectorSubtract(end, start, up);
                    VectorNormalize(up);
                    // calculate a forward vector to use instead of the original plane normal (this is how we get a new right vector)
                    VectorSubtract(rsurface.localvieworigin, center, forward);
                    //Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, forward);
                    VectorNegate(forward, forward);
                    VectorReflect(forward, 0, up, forward);
                    VectorNormalize(forward);
                    CrossProduct(up, forward, newright);
                    VectorNormalize(newright);
                    // rotate the quad around the up axis vector, this is made
                    // especially easy by the fact we know the quad is flat,
                    // so we only have to subtract the center position and
                    // measure distance along the right vector, and then
                    // multiply that by the newright vector and add back the
                    // center position
                    // we also need to subtract the old position to undo the
                    // displacement from the center, which we do with a
                    // DotProduct, the subtraction/addition of center is also
                    // optimized into DotProducts here
                    l = DotProduct(right, center);
                    for (i = 0;i < 4;i++)
                    {
                        v1 = rsurface.batchvertex3f + 3*(j+i);
                        f = DotProduct(right, v1) - l;
                        VectorMAMAM(1, v1, -f, right, f, newright, rsurface.batchvertex3f + 3*(j+i));
                    }
                }
            }
            if(batchneed & (BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR)) // otherwise these can stay NULL
            {
//              rsurface.batchnormal3f = R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
//              rsurface.batchnormal3f_vertexbuffer = NULL;
//              rsurface.batchnormal3f_bufferoffset = 0;
                Mod_BuildNormals(rsurface.batchfirstvertex, batchnumvertices, batchnumtriangles, rsurface.batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.batchnormal3f, r_smoothnormals_areaweighting.integer != 0);
            }
            if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL
            {
//              rsurface.batchsvector3f = R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
//              rsurface.batchsvector3f_vertexbuffer = NULL;
//              rsurface.batchsvector3f_bufferoffset = 0;
//              rsurface.batchtvector3f = R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
//              rsurface.batchtvector3f_vertexbuffer = NULL;
//              rsurface.batchtvector3f_bufferoffset = 0;
                Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, batchnumvertices, batchnumtriangles, rsurface.batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.batchsvector3f, rsurface.batchtvector3f, r_smoothnormals_areaweighting.integer != 0);
            }
            break;
        case Q3DEFORM_NORMAL:
            // deform the normals to make reflections wavey
            rsurface.batchnormal3f = (float *)R_FrameData_Store(batchnumvertices * sizeof(float[3]), rsurface.batchnormal3f);
            rsurface.batchnormal3f_vertexbuffer = NULL;
            rsurface.batchnormal3f_bufferoffset = 0;
            for (j = 0;j < batchnumvertices;j++)
            {
                float vertex[3];
                float *normal = rsurface.batchnormal3f + 3*j;
                VectorScale(rsurface.batchvertex3f + 3*j, 0.98f, vertex);
                normal[0] = rsurface.batchnormal3f[j*3+0] + deform->parms[0] * noise4f(      vertex[0], vertex[1], vertex[2], rsurface.shadertime * deform->parms[1]);
                normal[1] = rsurface.batchnormal3f[j*3+1] + deform->parms[0] * noise4f( 98 + vertex[0], vertex[1], vertex[2], rsurface.shadertime * deform->parms[1]);
                normal[2] = rsurface.batchnormal3f[j*3+2] + deform->parms[0] * noise4f(196 + vertex[0], vertex[1], vertex[2], rsurface.shadertime * deform->parms[1]);
                VectorNormalize(normal);
            }
            if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL
            {
//              rsurface.batchsvector3f = R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
//              rsurface.batchsvector3f_vertexbuffer = NULL;
//              rsurface.batchsvector3f_bufferoffset = 0;
//              rsurface.batchtvector3f = R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
//              rsurface.batchtvector3f_vertexbuffer = NULL;
//              rsurface.batchtvector3f_bufferoffset = 0;
                Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, batchnumvertices, batchnumtriangles, rsurface.batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.batchsvector3f, rsurface.batchtvector3f, r_smoothnormals_areaweighting.integer != 0);
            }
            break;
        case Q3DEFORM_WAVE:
            // deform vertex array to make wavey water and flags and such
            waveparms[0] = deform->waveparms[0];
            waveparms[1] = deform->waveparms[1];
            waveparms[2] = deform->waveparms[2];
            waveparms[3] = deform->waveparms[3];
            if(!R_TestQ3WaveFunc(deform->wavefunc, waveparms))
                break; // if wavefunc is a nop, don't make a dynamic vertex array
            // this is how a divisor of vertex influence on deformation
            animpos = deform->parms[0] ? 1.0f / deform->parms[0] : 100.0f;
            scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
//          rsurface.batchvertex3f = R_FrameData_Store(batchnumvertices * sizeof(float[3]), rsurface.batchvertex3f);
//          rsurface.batchvertex3f_vertexbuffer = NULL;
//          rsurface.batchvertex3f_bufferoffset = 0;
//          rsurface.batchnormal3f = R_FrameData_Store(batchnumvertices * sizeof(float[3]), rsurface.batchnormal3f);
//          rsurface.batchnormal3f_vertexbuffer = NULL;
//          rsurface.batchnormal3f_bufferoffset = 0;
            for (j = 0;j < batchnumvertices;j++)
            {
                // if the wavefunc depends on time, evaluate it per-vertex
                if (waveparms[3])
                {
                    waveparms[2] = deform->waveparms[2] + (rsurface.batchvertex3f[j*3+0] + rsurface.batchvertex3f[j*3+1] + rsurface.batchvertex3f[j*3+2]) * animpos;
                    scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
                }
                VectorMA(rsurface.batchvertex3f + 3*j, scale, rsurface.batchnormal3f + 3*j, rsurface.batchvertex3f + 3*j);
            }
            // if we get here, BATCHNEED_ARRAY_NORMAL is in batchneed, so no need to check
            Mod_BuildNormals(rsurface.batchfirstvertex, batchnumvertices, batchnumtriangles, rsurface.batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.batchnormal3f, r_smoothnormals_areaweighting.integer != 0);
            if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL
            {
//              rsurface.batchsvector3f = R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
//              rsurface.batchsvector3f_vertexbuffer = NULL;
//              rsurface.batchsvector3f_bufferoffset = 0;
//              rsurface.batchtvector3f = R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
//              rsurface.batchtvector3f_vertexbuffer = NULL;
//              rsurface.batchtvector3f_bufferoffset = 0;
                Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, batchnumvertices, batchnumtriangles, rsurface.batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.batchsvector3f, rsurface.batchtvector3f, r_smoothnormals_areaweighting.integer != 0);
            }
            break;
        case Q3DEFORM_BULGE:
            // deform vertex array to make the surface have moving bulges
//          rsurface.batchvertex3f = R_FrameData_Store(batchnumvertices * sizeof(float[3]), rsurface.batchvertex3f);
//          rsurface.batchvertex3f_vertexbuffer = NULL;
//          rsurface.batchvertex3f_bufferoffset = 0;
//          rsurface.batchnormal3f = R_FrameData_Store(batchnumvertices * sizeof(float[3]), rsurface.batchnormal3f);
//          rsurface.batchnormal3f_vertexbuffer = NULL;
//          rsurface.batchnormal3f_bufferoffset = 0;
            for (j = 0;j < batchnumvertices;j++)
            {
                scale = sin(rsurface.batchtexcoordtexture2f[j*2+0] * deform->parms[0] + rsurface.shadertime * deform->parms[2]) * deform->parms[1];
                VectorMA(rsurface.batchvertex3f + 3*j, scale, rsurface.batchnormal3f + 3*j, rsurface.batchvertex3f + 3*j);
            }
            // if we get here, BATCHNEED_ARRAY_NORMAL is in batchneed, so no need to check
            Mod_BuildNormals(rsurface.batchfirstvertex, batchnumvertices, batchnumtriangles, rsurface.batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.batchnormal3f, r_smoothnormals_areaweighting.integer != 0);
            if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL
            {
//              rsurface.batchsvector3f = R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
//              rsurface.batchsvector3f_vertexbuffer = NULL;
//              rsurface.batchsvector3f_bufferoffset = 0;
//              rsurface.batchtvector3f = R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
//              rsurface.batchtvector3f_vertexbuffer = NULL;
//              rsurface.batchtvector3f_bufferoffset = 0;
                Mod_BuildTextureVectorsFromNormals(rsurface.batchfirstvertex, batchnumvertices, batchnumtriangles, rsurface.batchvertex3f, rsurface.batchtexcoordtexture2f, rsurface.batchnormal3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.batchsvector3f, rsurface.batchtvector3f, r_smoothnormals_areaweighting.integer != 0);
            }
            break;
        case Q3DEFORM_MOVE:
            // deform vertex array
            if(!R_TestQ3WaveFunc(deform->wavefunc, deform->waveparms))
                break; // if wavefunc is a nop, don't make a dynamic vertex array
            scale = R_EvaluateQ3WaveFunc(deform->wavefunc, deform->waveparms);
            VectorScale(deform->parms, scale, waveparms);
//          rsurface.batchvertex3f = R_FrameData_Store(batchnumvertices * sizeof(float[3]), rsurface.batchvertex3f);
//          rsurface.batchvertex3f_vertexbuffer = NULL;
//          rsurface.batchvertex3f_bufferoffset = 0;
            for (j = 0;j < batchnumvertices;j++)
                VectorAdd(rsurface.batchvertex3f + 3*j, waveparms, rsurface.batchvertex3f + 3*j);
            break;
        }
    }
 
    if (rsurface.batchtexcoordtexture2f && rsurface.texture->materialshaderpass)
    {
    // generate texcoords based on the chosen texcoord source
        switch(rsurface.texture->materialshaderpass->tcgen.tcgen)
        {
        default:
        case Q3TCGEN_TEXTURE:
            break;
        case Q3TCGEN_LIGHTMAP:
    //      rsurface.batchtexcoordtexture2f = R_FrameData_Alloc(batchnumvertices * sizeof(float[2]));
    //      rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
    //      rsurface.batchtexcoordtexture2f_bufferoffset = 0;
            if (rsurface.batchtexcoordlightmap2f)
                memcpy(rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordlightmap2f, batchnumvertices * sizeof(float[2]));
            break;
        case Q3TCGEN_VECTOR:
    //      rsurface.batchtexcoordtexture2f = R_FrameData_Alloc(batchnumvertices * sizeof(float[2]));
    //      rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
    //      rsurface.batchtexcoordtexture2f_bufferoffset = 0;
            for (j = 0;j < batchnumvertices;j++)
            {
                rsurface.batchtexcoordtexture2f[j*2+0] = DotProduct(rsurface.batchvertex3f + 3*j, rsurface.texture->materialshaderpass->tcgen.parms);
                rsurface.batchtexcoordtexture2f[j*2+1] = DotProduct(rsurface.batchvertex3f + 3*j, rsurface.texture->materialshaderpass->tcgen.parms + 3);
            }
            break;
        case Q3TCGEN_ENVIRONMENT:
            // make environment reflections using a spheremap
            rsurface.batchtexcoordtexture2f = (float *)R_FrameData_Alloc(batchnumvertices * sizeof(float[2]));
            rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
            rsurface.batchtexcoordtexture2f_bufferoffset = 0;
            for (j = 0;j < batchnumvertices;j++)
            {
                // identical to Q3A's method, but executed in worldspace so
                // carried models can be shiny too
 
                float viewer[3], d, reflected[3], worldreflected[3];
 
                VectorSubtract(rsurface.localvieworigin, rsurface.batchvertex3f + 3*j, viewer);
                // VectorNormalize(viewer);
 
                d = DotProduct(rsurface.batchnormal3f + 3*j, viewer);
 
                reflected[0] = rsurface.batchnormal3f[j*3+0]*2*d - viewer[0];
                reflected[1] = rsurface.batchnormal3f[j*3+1]*2*d - viewer[1];
                reflected[2] = rsurface.batchnormal3f[j*3+2]*2*d - viewer[2];
                // note: this is proportinal to viewer, so we can normalize later
 
                Matrix4x4_Transform3x3(&rsurface.matrix, reflected, worldreflected);
                VectorNormalize(worldreflected);
 
                // note: this sphere map only uses world x and z!
                // so positive and negative y will LOOK THE SAME.
                rsurface.batchtexcoordtexture2f[j*2+0] = 0.5 + 0.5 * worldreflected[1];
                rsurface.batchtexcoordtexture2f[j*2+1] = 0.5 - 0.5 * worldreflected[2];
            }
            break;
        }
        // the only tcmod that needs software vertex processing is turbulent, so
        // check for it here and apply the changes if needed
        // and we only support that as the first one
        // (handling a mixture of turbulent and other tcmods would be problematic
        //  without punting it entirely to a software path)
        if (rsurface.texture->materialshaderpass->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
        {
            amplitude = rsurface.texture->materialshaderpass->tcmods[0].parms[1];
            animpos = rsurface.texture->materialshaderpass->tcmods[0].parms[2] + rsurface.shadertime * rsurface.texture->materialshaderpass->tcmods[0].parms[3];
    //      rsurface.batchtexcoordtexture2f = R_FrameData_Alloc(batchnumvertices * sizeof(float[2]));
    //      rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
    //      rsurface.batchtexcoordtexture2f_bufferoffset = 0;
            for (j = 0;j < batchnumvertices;j++)
            {
                rsurface.batchtexcoordtexture2f[j*2+0] += amplitude * sin(((rsurface.batchvertex3f[j*3+0] + rsurface.batchvertex3f[j*3+2]) * 1.0 / 1024.0f + animpos) * M_PI * 2);
                rsurface.batchtexcoordtexture2f[j*2+1] += amplitude * sin(((rsurface.batchvertex3f[j*3+1]                                ) * 1.0 / 1024.0f + animpos) * M_PI * 2);
            }
        }
    }
}

Referenced by R_DrawDebugModel(), R_DrawSurface_TransparentCallback(), R_DrawTextureSurfaceList_DepthOnly(), R_DrawTextureSurfaceList_ShowSurfaces(), R_DrawTextureSurfaceList_Sky(), R_Mod_DrawShadowMap(), R_SetupShader_Surface(), R_Shadow_RenderLighting_VisibleLighting(), R_Water_AddWaterPlane(), and RSurf_FindWaterPlaneForSurface().

◆ RSurf_SetupDepthAndCulling()

void RSurf_SetupDepthAndCulling ( bool ui )

Definition at line 8576 of file gl_rmain.c.

{
    // submodels are biased to avoid z-fighting with world surfaces that they
    // may be exactly overlapping (avoids z-fighting artifacts on certain
    // doors and things in Quake maps)
    GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
    GL_PolygonOffset(rsurface.basepolygonfactor + rsurface.texture->biaspolygonfactor, rsurface.basepolygonoffset + rsurface.texture->biaspolygonoffset);
    GL_DepthTest(!ui && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
    GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_refdef.view.cullface_back);
}

References GL_CullFace(), GL_DepthRange(), GL_DepthTest(), GL_NONE, GL_PolygonOffset(), MATERIALFLAG_NOCULLFACE, MATERIALFLAG_NODEPTHTEST, MATERIALFLAG_SHORTDEPTHRANGE, r_refdef, and rsurface.

Referenced by R_DrawModelTextureSurfaceList(), R_DrawSurface_TransparentCallback(), R_DrawTextureSurfaceList_DepthOnly(), R_DrawTextureSurfaceList_Sky(), and R_Shadow_RenderLighting().

◆ RSurf_UploadBuffersForBatch()

void RSurf_UploadBuffersForBatch ( void )

Definition at line 7340 of file gl_rmain.c.

{
    // upload buffer data for generated vertex data (dynamicvertex case) or index data (copytriangles case) and models that lack it to begin with (e.g. DrawQ_FlushUI)
    // note that if rsurface.batchvertex3f_vertexbuffer is NULL, dynamicvertex is forced as we don't account for the proper base vertex here.
    if (rsurface.batchvertex3f && !rsurface.batchvertex3f_vertexbuffer)
        rsurface.batchvertex3f_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(float[3]), rsurface.batchvertex3f, R_BUFFERDATA_VERTEX, &rsurface.batchvertex3f_bufferoffset);
    if (rsurface.batchsvector3f && !rsurface.batchsvector3f_vertexbuffer)
        rsurface.batchsvector3f_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(float[3]), rsurface.batchsvector3f, R_BUFFERDATA_VERTEX, &rsurface.batchsvector3f_bufferoffset);
    if (rsurface.batchtvector3f && !rsurface.batchtvector3f_vertexbuffer)
        rsurface.batchtvector3f_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(float[3]), rsurface.batchtvector3f, R_BUFFERDATA_VERTEX, &rsurface.batchtvector3f_bufferoffset);
    if (rsurface.batchnormal3f && !rsurface.batchnormal3f_vertexbuffer)
        rsurface.batchnormal3f_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(float[3]), rsurface.batchnormal3f, R_BUFFERDATA_VERTEX, &rsurface.batchnormal3f_bufferoffset);
    if (rsurface.batchlightmapcolor4f && !rsurface.batchlightmapcolor4f_vertexbuffer)
        rsurface.batchlightmapcolor4f_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(float[4]), rsurface.batchlightmapcolor4f, R_BUFFERDATA_VERTEX, &rsurface.batchlightmapcolor4f_bufferoffset);
    if (rsurface.batchtexcoordtexture2f && !rsurface.batchtexcoordtexture2f_vertexbuffer)
        rsurface.batchtexcoordtexture2f_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(float[2]), rsurface.batchtexcoordtexture2f, R_BUFFERDATA_VERTEX, &rsurface.batchtexcoordtexture2f_bufferoffset);
    if (rsurface.batchtexcoordlightmap2f && !rsurface.batchtexcoordlightmap2f_vertexbuffer)
        rsurface.batchtexcoordlightmap2f_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(float[2]), rsurface.batchtexcoordlightmap2f, R_BUFFERDATA_VERTEX, &rsurface.batchtexcoordlightmap2f_bufferoffset);
    if (rsurface.batchskeletalindex4ub && !rsurface.batchskeletalindex4ub_vertexbuffer)
        rsurface.batchskeletalindex4ub_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(unsigned char[4]), rsurface.batchskeletalindex4ub, R_BUFFERDATA_VERTEX, &rsurface.batchskeletalindex4ub_bufferoffset);
    if (rsurface.batchskeletalweight4ub && !rsurface.batchskeletalweight4ub_vertexbuffer)
        rsurface.batchskeletalweight4ub_vertexbuffer = R_BufferData_Store(rsurface.batchnumvertices * sizeof(unsigned char[4]), rsurface.batchskeletalweight4ub, R_BUFFERDATA_VERTEX, &rsurface.batchskeletalweight4ub_bufferoffset);
 
    if (rsurface.batchelement3s && !rsurface.batchelement3s_indexbuffer)
        rsurface.batchelement3s_indexbuffer = R_BufferData_Store(rsurface.batchnumtriangles * sizeof(short[3]), rsurface.batchelement3s, R_BUFFERDATA_INDEX16, &rsurface.batchelement3s_bufferoffset);
    else if (rsurface.batchelement3i && !rsurface.batchelement3i_indexbuffer)
        rsurface.batchelement3i_indexbuffer = R_BufferData_Store(rsurface.batchnumtriangles * sizeof(int[3]), rsurface.batchelement3i, R_BUFFERDATA_INDEX32, &rsurface.batchelement3i_bufferoffset);
 
    R_Mesh_VertexPointer(     3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
    R_Mesh_ColorPointer(      4, GL_FLOAT, sizeof(float[4]), rsurface.batchlightmapcolor4f, rsurface.batchlightmapcolor4f_vertexbuffer, rsurface.batchlightmapcolor4f_bufferoffset);
    R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
    R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchsvector3f, rsurface.batchsvector3f_vertexbuffer, rsurface.batchsvector3f_bufferoffset);
    R_Mesh_TexCoordPointer(2, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchtvector3f, rsurface.batchtvector3f_vertexbuffer, rsurface.batchtvector3f_bufferoffset);
    R_Mesh_TexCoordPointer(3, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchnormal3f, rsurface.batchnormal3f_vertexbuffer, rsurface.batchnormal3f_bufferoffset);
    R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordlightmap2f, rsurface.batchtexcoordlightmap2f_vertexbuffer, rsurface.batchtexcoordlightmap2f_bufferoffset);
    R_Mesh_TexCoordPointer(5, 2, GL_FLOAT, sizeof(float[2]), NULL, NULL, 0);
    R_Mesh_TexCoordPointer(6, 4, GL_UNSIGNED_BYTE | 0x80000000, sizeof(unsigned char[4]), rsurface.batchskeletalindex4ub, rsurface.batchskeletalindex4ub_vertexbuffer, rsurface.batchskeletalindex4ub_bufferoffset);
    R_Mesh_TexCoordPointer(7, 4, GL_UNSIGNED_BYTE, sizeof(unsigned char[4]), rsurface.batchskeletalweight4ub, rsurface.batchskeletalweight4ub_vertexbuffer, rsurface.batchskeletalweight4ub_bufferoffset);
}

References GL_FLOAT, GL_UNSIGNED_BYTE, NULL, R_BUFFERDATA_INDEX16, R_BUFFERDATA_INDEX32, R_BufferData_Store(), R_BUFFERDATA_VERTEX, R_Mesh_ColorPointer(), R_Mesh_TexCoordPointer(), R_Mesh_VertexPointer(), and rsurface.

Referenced by R_SetupShader_Surface().

◆ Sbar_Init()

void Sbar_Init ( void )

Definition at line 359 of file sbar.c.

{
    Cmd_AddCommand(CF_CLIENT, "+showscores", Sbar_ShowScores_f, "show scoreboard");
    Cmd_AddCommand(CF_CLIENT, "-showscores", Sbar_DontShowScores_f, "hide scoreboard");
    Cvar_RegisterVariable(&cl_showfps);
    Cvar_RegisterVariable(&cl_showsound);
    Cvar_RegisterVariable(&cl_showblur);
    Cvar_RegisterVariable(&cl_showspeed);
    Cvar_RegisterVariable(&cl_showspeed_factor);
    Cvar_RegisterVariable(&cl_showtopspeed);
    Cvar_RegisterVariable(&cl_showtime);
    Cvar_RegisterVariable(&cl_showtime_format);
    Cvar_RegisterVariable(&cl_showdate);
    Cvar_RegisterVariable(&cl_showdate_format);
    Cvar_RegisterVariable(&cl_showtex);
    
    Cvar_RegisterVirtual(&cl_showfps, "showfps");
    Cvar_RegisterVirtual(&cl_showsound, "showsound");
    Cvar_RegisterVirtual(&cl_showblur, "showblur");
    Cvar_RegisterVirtual(&cl_showspeed, "showspeed");
    Cvar_RegisterVirtual(&cl_showtopspeed, "showtopspeed");
    Cvar_RegisterVirtual(&cl_showtime, "showtime");
    Cvar_RegisterVirtual(&cl_showtime_format, "showtime_format");
    Cvar_RegisterVirtual(&cl_showdate, "showdate");
    Cvar_RegisterVirtual(&cl_showdate_format, "showdate_format");
    Cvar_RegisterVirtual(&cl_showtex, "showtex");
    
    Cvar_RegisterVariable(&sbar_alpha_bg);
    Cvar_RegisterVariable(&sbar_alpha_fg);
    Cvar_RegisterVariable(&sbar_hudselector);
    Cvar_RegisterVariable(&sbar_scorerank);
    Cvar_RegisterVariable(&sbar_gametime);
    Cvar_RegisterVariable(&sbar_miniscoreboard_size);
    Cvar_RegisterVariable(&sbar_info_pos);
    Cvar_RegisterVariable(&cl_deathscoreboard);
    // This cvar is found in Fitzquake-derived engines and FTEQW and is read by the Alkaline 1.2 and Arcane Dimensions 1.80 CSQC
    Cvar_RegisterVirtual(&sbar_alpha_bg, "scr_sbaralpha");
 
    Cvar_RegisterVariable(&crosshair_color_red);
    Cvar_RegisterVariable(&crosshair_color_green);
    Cvar_RegisterVariable(&crosshair_color_blue);
    Cvar_RegisterVariable(&crosshair_color_alpha);
    Cvar_RegisterVariable(&crosshair_size);
 
    Cvar_RegisterVariable(&sbar_flagstatus_right); // (GAME_NEXUZI ONLY)
    Cvar_RegisterVariable(&sbar_flagstatus_pos); // (GAME_NEXUIZ ONLY)
 
    R_RegisterModule("sbar", sbar_start, sbar_shutdown, sbar_newmap, NULL, NULL);
}

References CF_CLIENT, cl_deathscoreboard, cl_showblur, cl_showdate, cl_showdate_format, cl_showfps, cl_showsound, cl_showspeed, cl_showspeed_factor, cl_showtex, cl_showtime, cl_showtime_format, cl_showtopspeed, Cmd_AddCommand(), crosshair_color_alpha, crosshair_color_blue, crosshair_color_green, crosshair_color_red, crosshair_size, Cvar_RegisterVariable(), Cvar_RegisterVirtual(), NULL, R_RegisterModule(), sbar_alpha_bg, sbar_alpha_fg, Sbar_DontShowScores_f(), sbar_flagstatus_pos, sbar_flagstatus_right, sbar_gametime, sbar_hudselector, sbar_info_pos, sbar_miniscoreboard_size, sbar_newmap(), sbar_scorerank, Sbar_ShowScores_f(), sbar_shutdown(), and sbar_start().

Referenced by Render_Init().

◆ SCR_DrawConsole()

void SCR_DrawConsole ( void )

Definition at line 750 of file cl_screen.c.

{
    // infobar and loading progress are not drawn simultaneously
    scr_con_margin_bottom = SCR_InfobarHeight();
    if (!scr_con_margin_bottom && scr_loading)
        scr_con_margin_bottom = scr_loadingscreen_barheight.integer;
    if (key_consoleactive & KEY_CONSOLEACTIVE_FORCED)
    {
        // full screen
        Con_DrawConsole (vid_conheight.integer - scr_con_margin_bottom, true);
    }
    else if (scr_con_current)
        Con_DrawConsole (min(scr_con_current, vid_conheight.integer - scr_con_margin_bottom), false);
    else
        con_vislines = 0;
}

References Con_DrawConsole(), con_vislines, key_consoleactive, KEY_CONSOLEACTIVE_FORCED, min, scr_con_current, scr_con_margin_bottom, SCR_InfobarHeight(), scr_loading, scr_loadingscreen_barheight, and vid_conheight.

Referenced by SCR_DrawScreen().

◆ SHOWLMP_decodehide()

void SHOWLMP_decodehide ( void )

Definition at line 1368 of file cl_screen.c.

{
    int i;
    char *lmplabel;
    lmplabel = MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
    for (i = 0;i < cl.num_showlmps;i++)
        if (cl.showlmps[i].isactive && strcmp(cl.showlmps[i].label, lmplabel) == 0)
        {
            cl.showlmps[i].isactive = false;
            return;
        }
}

References cl, cl_message, cl_readstring, and MSG_ReadString().

Referenced by CL_ParseServerMessage().

◆ SHOWLMP_decodeshow()

void SHOWLMP_decodeshow ( void )

Definition at line 1381 of file cl_screen.c.

{
    int k;
    char lmplabel[256], picname[256];
    float x, y;
    dp_strlcpy (lmplabel,MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof (lmplabel));
    dp_strlcpy (picname, MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof (picname));
    if (gamemode == GAME_NEHAHRA) // LadyHavoc: nasty old legacy junk
    {
        x = MSG_ReadByte(&cl_message);
        y = MSG_ReadByte(&cl_message);
    }
    else
    {
        x = MSG_ReadShort(&cl_message);
        y = MSG_ReadShort(&cl_message);
    }
    if (!cl.showlmps || cl.num_showlmps >= cl.max_showlmps)
    {
        showlmp_t *oldshowlmps = cl.showlmps;
        cl.max_showlmps += 16;
        cl.showlmps = (showlmp_t *) Mem_Alloc(cls.levelmempool, cl.max_showlmps * sizeof(showlmp_t));
        if (oldshowlmps)
        {
            if (cl.num_showlmps)
                memcpy(cl.showlmps, oldshowlmps, cl.num_showlmps * sizeof(showlmp_t));
            Mem_Free(oldshowlmps);
        }
    }
    for (k = 0;k < cl.max_showlmps;k++)
        if (cl.showlmps[k].isactive && !strcmp(cl.showlmps[k].label, lmplabel))
            break;
    if (k == cl.max_showlmps)
        for (k = 0;k < cl.max_showlmps;k++)
            if (!cl.showlmps[k].isactive)
                break;
    cl.showlmps[k].isactive = true;
    dp_strlcpy (cl.showlmps[k].label, lmplabel, sizeof (cl.showlmps[k].label));
    dp_strlcpy (cl.showlmps[k].pic, picname, sizeof (cl.showlmps[k].pic));
    cl.showlmps[k].x = x;
    cl.showlmps[k].y = y;
    cl.num_showlmps = max(cl.num_showlmps, k + 1);
}

References cl, cl_message, cl_readstring, cls, dp_strlcpy, GAME_NEHAHRA, gamemode, max, Mem_Alloc, Mem_Free, MSG_ReadByte, MSG_ReadShort, MSG_ReadString(), x, and y.

Referenced by CL_ParseServerMessage().

◆ SHOWLMP_drawall()

void SHOWLMP_drawall ( void )

Definition at line 1425 of file cl_screen.c.

{
    int i;
    for (i = 0;i < cl.num_showlmps;i++)
        if (cl.showlmps[i].isactive)
            DrawQ_Pic(cl.showlmps[i].x, cl.showlmps[i].y, Draw_CachePic_Flags (cl.showlmps[i].pic, CACHEPICFLAG_NOTPERSISTENT), 0, 0, 1, 1, 1, 1, 0);
}

References CACHEPICFLAG_NOTPERSISTENT, cl, Draw_CachePic_Flags(), and DrawQ_Pic().

Referenced by SCR_DrawScreen().

Variable Documentation

◆ cl_deathfade

cvar_t cl_deathfade

extern

Definition at line 83 of file cl_main.c.

83{CF_CLIENT | CF_ARCHIVE, "cl_deathfade", "0", "fade screen to dark red when dead, value represents how fast the fade is (higher is faster)"};

CF_ARCHIVE

#define CF_ARCHIVE

cvar should have its set value saved to config.cfg and persist across sessions

Definition cmd.h:53

Referenced by CL_Init(), and V_CalcViewBlend().

◆ developer_texturelogging

cvar_t developer_texturelogging

extern

Definition at line 231 of file gl_rmain.c.

231{CF_CLIENT, "developer_texturelogging", "0", "produces a textures.log file containing names of skins and map textures the engine tried to load"};

Referenced by GL_Main_Init(), and loadimagepixelsbgra().

◆ gl_flashblend

cvar_t gl_flashblend

extern

Definition at line 236 of file r_shadow.c.

236{CF_CLIENT | CF_ARCHIVE, "gl_flashblend", "0", "render bright coronas for dynamic lights instead of actual lighting, fast but ugly"};

◆ gl_polyblend

cvar_t gl_polyblend

extern

Definition at line 17 of file gl_backend.c.

17{CF_CLIENT | CF_ARCHIVE, "gl_polyblend", "1", "tints view while underwater, hurt, etc"};

Referenced by gl_backend_init(), M_Menu_Options_Effects_AdjustSliders(), M_Options_Effects_Draw(), and V_CalcViewBlend().

◆ ixtable

float ixtable[4096]

extern

Definition at line 27 of file mathlib.c.

Referenced by Mathlib_Init(), Portal_CheckPolygon(), Portal_RecursiveFlow(), Portal_RecursiveFlowSearch(), and R_DrawPortals().

◆ r_ambient

cvar_t r_ambient

extern

Definition at line 28 of file gl_rsurf.c.

28{CF_CLIENT, "r_ambient", "0", "brightens map, value is 0-128"};

Referenced by GL_Surf_Init(), and R_UpdateVariables().

◆ r_draw2d

cvar_t r_draw2d

extern

Definition at line 97 of file gl_rmain.c.

97{CF_CLIENT, "r_draw2d","1", "draw 2D stuff (dangerous to turn off)"};

Referenced by DrawQ_FlushUI(), DrawQ_String_Scale(), and GL_Main_Init().

◆ r_draw2d_force

qbool r_draw2d_force

extern

Definition at line 795 of file gl_draw.c.

Referenced by Con_DrawConsole(), DrawQ_FlushUI(), DrawQ_String_Scale(), R_TimeReport_EndFrame(), and Sbar_ShowFPS().

◆ r_drawentities

cvar_t r_drawentities

extern

Definition at line 96 of file gl_rmain.c.

96{CF_CLIENT, "r_drawentities","1", "draw entities (doors, players, projectiles, etc)"};

Referenced by GL_Main_Init(), and R_RenderView().

◆ r_drawviewmodel

cvar_t r_drawviewmodel

extern

Definition at line 99 of file gl_rmain.c.

99{CF_CLIENT, "r_drawviewmodel","1", "draw your weapon model"};

Referenced by GL_Main_Init(), and R_View_UpdateEntityVisible().

◆ r_drawworld

cvar_t r_drawworld

extern

Definition at line 98 of file gl_rmain.c.

98{CF_CLIENT, "r_drawworld","1", "draw world (most static stuff)"};

Referenced by CL_ClearState(), GL_Main_Init(), VM_CL_R_ClearScene(), and VM_CL_R_SetView().

◆ r_dynamic

cvar_t r_dynamic

extern

Definition at line 121 of file gl_rmain.c.

121{CF_CLIENT | CF_ARCHIVE, "r_dynamic","1", "enables dynamic lights (rocket glow and such)"};

Referenced by CL_RelinkLightFlashes(), GL_Main_Init(), R_UpdateVariables(), and R_Water_ProcessPlanes().

◆ r_fb

r_framebufferstate_t r_fb

extern

◆ r_fullbright

cvar_t r_fullbright

extern

Definition at line 112 of file gl_rmain.c.

112{CF_CLIENT, "r_fullbright","0", "makes map very bright and renders faster"};

Referenced by CL_RelinkStaticEntities(), CL_RelinkWorld(), CL_UpdateEntityShading_Entity(), CL_UpdateNetworkEntity(), CSQC_AddRenderEdict(), GL_Main_Init(), RSurf_ActiveModelEntity(), and VM_CL_makestatic().

◆ r_fxaa

cvar_t r_fxaa

extern

Definition at line 190 of file gl_rmain.c.

190{CF_CLIENT | CF_ARCHIVE, "r_fxaa", "0", "fast approximate anti aliasing"};

Referenced by GL_Main_Init(), R_BlendView_IsTrivial(), and R_CompileShader_CheckStaticParms().

◆ r_glsl_deluxemapping

cvar_t r_glsl_deluxemapping

extern

Definition at line 171 of file gl_rmain.c.

171{CF_CLIENT | CF_ARCHIVE, "r_glsl_deluxemapping", "1", "use per pixel lighting on deluxemap-compiled q3bsp maps (or a value of 2 forces deluxemap shading even without deluxemaps)"};

Referenced by GL_Main_Init(), and R_SetupShader_Surface().

◆ r_glsl_offsetmapping

cvar_t r_glsl_offsetmapping

extern

Definition at line 172 of file gl_rmain.c.

172{CF_CLIENT | CF_ARCHIVE, "r_glsl_offsetmapping", "0", "offset mapping effect (also known as parallax mapping or virtual displacement mapping)"};

Referenced by GL_Main_Init(), and R_SetupShader_Surface().

◆ r_glsl_offsetmapping_lod

cvar_t r_glsl_offsetmapping_lod

extern

Definition at line 178 of file gl_rmain.c.

178{CF_CLIENT | CF_ARCHIVE, "r_glsl_offsetmapping_lod", "0", "apply distance-based level-of-detail correction to number of offsetmappig steps, effectively making it render faster on large open-area maps"};

Referenced by GL_Main_Init(), and R_CompileShader_CheckStaticParms().

◆ r_glsl_offsetmapping_lod_distance

cvar_t r_glsl_offsetmapping_lod_distance

extern

Definition at line 179 of file gl_rmain.c.

179{CF_CLIENT | CF_ARCHIVE, "r_glsl_offsetmapping_lod_distance", "32", "first LOD level distance, second level (-50% steps) is 2x of this, third (33%) - 3x etc."};

Referenced by GL_Main_Init(), R_CompileShader_CheckStaticParms(), and R_SetupShader_Surface().

◆ r_glsl_offsetmapping_reliefmapping

cvar_t r_glsl_offsetmapping_reliefmapping

extern

Definition at line 174 of file gl_rmain.c.

174{CF_CLIENT | CF_ARCHIVE, "r_glsl_offsetmapping_reliefmapping", "0", "relief mapping effect (higher quality)"};

Referenced by GL_Main_Init(), and R_SetupShader_Surface().

◆ r_glsl_offsetmapping_scale

cvar_t r_glsl_offsetmapping_scale

extern

Definition at line 177 of file gl_rmain.c.

177{CF_CLIENT | CF_ARCHIVE, "r_glsl_offsetmapping_scale", "0.04", "how deep the offset mapping effect is"};

Referenced by GL_Main_Init(), and R_SetupShader_Surface().

◆ r_lerplightstyles

cvar_t r_lerplightstyles

extern

Definition at line 205 of file gl_rmain.c.

205{CF_CLIENT | CF_ARCHIVE, "r_lerplightstyles", "0", "enable animation smoothing on flickering lights"};

Referenced by CL_RelinkLightFlashes(), GL_Main_Init(), M_Menu_Options_Effects_AdjustSliders(), and M_Options_Effects_Draw().

◆ r_lerpmodels

cvar_t r_lerpmodels

extern

Definition at line 203 of file gl_rmain.c.

203{CF_CLIENT | CF_ARCHIVE, "r_lerpmodels", "1", "enables animation smoothing on models"};

Referenced by GL_Main_Init(), M_Menu_Options_Effects_AdjustSliders(), M_Options_Effects_Draw(), and VM_FrameBlendFromFrameGroupBlend().

◆ r_lerpsprites

cvar_t r_lerpsprites

extern

Definition at line 202 of file gl_rmain.c.

202{CF_CLIENT | CF_ARCHIVE, "r_lerpsprites", "0", "enables animation smoothing on sprites"};

Referenced by GL_Main_Init(), M_Menu_Options_Effects_AdjustSliders(), M_Options_Effects_Draw(), and VM_FrameBlendFromFrameGroupBlend().

◆ r_main_mempool

mempool_t* r_main_mempool

extern

Definition at line 42 of file gl_rmain.c.

Referenced by CL_Beams_SetupBuiltinTexture(), CL_Beams_SetupExternalTexture(), gl_backend_start(), GL_Main_Init(), gl_main_start(), R_BufferData_Resize(), R_BuildFogHeightTexture(), R_DrawModelSurfaces(), R_FrameData_Resize(), R_GetCubemap(), R_GetCurrentTexture(), R_InitShaderModeInfo(), R_Main_ResizeViewCache(), R_Mod_CompileShadowMap(), R_RTLight_Compile(), R_ShaderStrCat(), R_Shadow_BounceGrid_ConvertPixelsAndUpload(), R_Shadow_EnlargeLeafSurfaceTrisBuffer(), R_Shadow_Init(), R_Shadow_PrepareLights_AddSceneLight(), R_Shadow_PrepareShadowMark(), R_Shadow_PrepareShadowSides(), R_Shadow_ResizeShadowArrays(), R_Shadow_SetShadowMode(), R_Shadow_UpdateBounceGridTexture(), R_SkinFrame_LoadInternalQuake(), R_View_WorldVisibility(), R_Water_AddWaterPlane(), R_Water_ProcessPlanes(), and ShaderModeInfo_GetShaderText().

◆ r_maxqueries

unsigned int r_maxqueries

extern

Definition at line 299 of file gl_rmain.c.

Referenced by gl_main_shutdown(), gl_main_start(), R_BeginCoronaQuery(), and R_Shadow_DrawCoronas().

◆ r_nearclip

cvar_t r_nearclip

extern

Definition at line 76 of file gl_rmain.c.

76{CF_CLIENT, "r_nearclip", "1", "distance from camera of nearclip plane" };

Referenced by GL_Main_Init(), R_UpdateVariables(), and R_View_WorldVisibility().

◆ r_novis

cvar_t r_novis

extern

Definition at line 31 of file model_brush.c.

31{CF_CLIENT, "r_novis", "0", "draws whole level, see also sv_cullentities_pvs 0"};

Referenced by Mod_BrushInit(), Mod_BSP_FatPVS(), R_GetCurrentTexture(), R_View_UpdateEntityVisible(), R_View_WorldVisibility(), and SV_MarkWriteEntityStateToClient().

◆ r_numqueries

unsigned int r_numqueries

extern

Definition at line 298 of file gl_rmain.c.

Referenced by gl_main_shutdown(), gl_main_start(), R_BeginCoronaQuery(), and R_Shadow_DrawCoronas().

◆ r_q1bsp_lightmap_updates_combine

cvar_t r_q1bsp_lightmap_updates_combine

extern

Definition at line 258 of file gl_rmain.c.

258{CF_CLIENT | CF_ARCHIVE, "r_q1bsp_lightmap_updates_combine", "2", "combine lightmap texture updates to make fewer glTexSubImage2D calls, modes: 0 = immediately upload lightmaps (may be thousands of small 3x3 updates), 1 = combine to one call, 2 = combine to one full texture update (glTexImage2D) which tells the driver it does not need to lock the resource (faster on most drivers)"};

Referenced by GL_Main_Init(), R_BuildLightMap(), and R_DrawModelSurfaces().

◆ r_q1bsp_lightmap_updates_combine_full_texture

cvar_t r_q1bsp_lightmap_updates_combine_full_texture

extern

◆ r_q1bsp_lightmap_updates_enabled

cvar_t r_q1bsp_lightmap_updates_enabled

extern

Definition at line 257 of file gl_rmain.c.

257{CF_CLIENT, "r_q1bsp_lightmap_updates_enabled", "1", "allow lightmaps to be updated on Q1BSP maps (don't turn this off except for debugging)"};

Referenced by GL_Main_Init(), and R_DrawModelSurfaces().

◆ r_q1bsp_lightmap_updates_hidden_surfaces

cvar_t r_q1bsp_lightmap_updates_hidden_surfaces

extern

Definition at line 259 of file gl_rmain.c.

259{CF_CLIENT | CF_ARCHIVE, "r_q1bsp_lightmap_updates_hidden_surfaces", "0", "update lightmaps on surfaces that are not visible, so that updates only occur on frames where lightstyles changed value (animation or light switches), only makes sense with combine = 2"};

Referenced by GL_Main_Init(), and R_DrawModelSurfaces().

◆ r_q3bsp_renderskydepth

cvar_t r_q3bsp_renderskydepth

extern

Definition at line 41 of file gl_rsurf.c.

41{CF_CLIENT, "r_q3bsp_renderskydepth", "0", "draws sky depth masking in q3 maps (as in q1 maps), this means for example that sky polygons can hide other things"};

Referenced by GL_Surf_Init(), and R_DrawTextureSurfaceList_Sky().

◆ r_queries

unsigned int r_queries[MAX_OCCLUSION_QUERIES]

extern

Definition at line 297 of file gl_rmain.c.

Referenced by gl_main_shutdown(), gl_main_start(), R_BeginCoronaQuery(), and R_Shadow_DrawCoronas().

◆ r_refdef

r_refdef_t r_refdef

extern

Definition at line 57 of file gl_rmain.c.

Referenced by CL_Beam_AddPolygons(), CL_Beam_CalculatePositions(), CL_ClearTempEntities(), CL_ExpandCSQCRenderEntities(), CL_Fog_f(), CL_Fog_HeightTexture_f(), CL_Frame(), CL_GetEntityMatrix(), CL_GetTagMatrix(), CL_Init(), CL_LinkNetworkEntity(), CL_Locs_RemoveNearest_f(), CL_MeshEntities_Scene_AddRenderEntity(), CL_NewParticlesFromEffectinfo(), CL_NewTempEntity(), CL_ParseEntityLump(), CL_ParticleEffect_Fallback(), CL_RelinkBeams(), CL_RelinkLightFlashes(), CL_RelinkStaticEntities(), CL_RelinkWorld(), CL_TimeRefresh_f(), CL_UpdateEntityShading(), CL_UpdateEntityShading_Entity(), CL_UpdatePrydonCursor(), CL_UpdateScreen(), CL_UpdateWorld(), CL_VM_UpdateView(), Collision_Cache_Lookup(), CSQC_AddRenderEdict(), CSQC_R_RecalcView(), DrawQ_Finish(), DrawQ_FlushUI(), DrawQ_RecalcView(), DrawQ_SetClipArea(), DrawQ_Start(), FOG_clear(), gl_main_start(), Mod_BSP_LightPoint_RecursiveBSPNode(), Mod_Mesh_Finalize(), MP_Draw(), R_AnimCache_CacheVisibleEntities(), R_AnimCache_ClearCache(), R_AnimCache_GetEntity(), R_BeginCoronaQuery(), R_BlendView(), R_BlendView_IsTrivial(), R_Bloom_MakeTexture(), R_Bloom_StartFrame(), R_BufferData_Store(), R_BuildFogHeightTexture(), R_BuildFogTexture(), R_BuildLightMap(), R_CalcBeam_Vertex3f(), R_CanSeeBox(), R_ClearScreen(), R_CompleteLightPoint(), R_CullFrustum(), R_DebugLine(), R_DecalSystem_ApplySplatEntities(), R_DrawBBoxMesh(), R_DrawBrushModelsSky(), R_DrawCorona(), R_DrawDebugModel(), R_DrawExplosion_TransparentCallback(), R_DrawLoc_Callback(), R_DrawModelDecals(), R_DrawModelDecals_Entity(), R_DrawModelDecals_FadeEntity(), R_DrawModels(), R_DrawModelsAddWaterPlanes(), R_DrawModelsDebug(), R_DrawModelsDepth(), R_DrawModelSurfaces(), R_DrawModelTextureSurfaceList(), R_DrawNoModel_TransparentCallback(), R_DrawParticle_TransparentCallback(), R_DrawParticles(), R_DrawPortal_Callback(), R_DrawPortals(), R_DrawSurface_TransparentCallback(), R_DrawTextureSurfaceList_ShowSurfaces(), R_DrawTextureSurfaceList_Sky(), R_Envmap_f(), R_FrameData_Alloc(), R_GetCurrentTexture(), R_GetScenePointer(), R_HDR_UpdateIrisAdaptation(), R_ListWorldTextures_f(), R_Main_FreeViewCache(), R_Main_ResizeViewCache(), R_Mesh_Draw(), R_Mesh_UpdateMeshBuffer(), R_MeshQueue_AddTransparent(), R_MeshQueue_BeginScene(), R_Mod_DrawAddWaterPlanes(), R_Mod_DrawDepth(), R_Mod_DrawLight(), R_Mod_DrawShadowMap(), R_Mod_GetLightInfo(), R_Model_Sprite_Draw_TransparentCallback(), R_MotionBlurView(), R_ProcessTransparentTextureSurfaceList(), R_RenderScene(), R_RenderTarget_Get(), R_RenderView(), R_RenderView_UpdateViewVectors(), R_RenderWaterPlanes(), R_ReplaceWorldTexture_f(), R_ResetViewRendering2D_Common(), R_ResetViewRendering3D(), R_RTLight_Compile(), R_ScissorForBBox(), R_SelectScene(), R_SetupShader_DeferredLight(), R_SetupShader_Surface(), R_SetupView(), R_Shadow_BounceGrid_AssignPhotons_Task(), R_Shadow_BounceGrid_CheckEnable(), R_Shadow_BounceGrid_UpdateSpacing(), R_Shadow_ClearShadowMapTexture(), R_Shadow_ClearStencil(), R_Shadow_ComputeShadowCasterCullingPlanes(), R_Shadow_CullFrustumSides(), R_Shadow_DrawCoronas(), R_Shadow_DrawCursor_TransparentCallback(), R_Shadow_DrawLight(), R_Shadow_DrawLightShadowMaps(), R_Shadow_DrawLightSprite_TransparentCallback(), R_Shadow_DrawModelShadowMaps(), R_Shadow_DrawPrepass(), R_Shadow_DrawWorldLight(), R_Shadow_DrawWorldShadow_ShadowMap(), R_Shadow_PrepareLight(), R_Shadow_PrepareLights(), R_Shadow_PrepareModelShadows(), R_Shadow_RenderMode_Begin(), R_Shadow_RenderMode_DrawDeferredLight(), R_Shadow_RenderMode_End(), R_Shadow_RenderMode_Lighting(), R_Shadow_RenderMode_Reset(), R_Shadow_RenderMode_ShadowMap(), R_Shadow_RenderMode_VisibleLighting(), R_Shadow_ScissorForBBox(), R_Shadow_SelectLightInView(), R_Shadow_SetCursorLocationForView(), R_Shadow_UpdateBounceGridTexture(), R_Sky(), R_SkySphere(), R_SkyStartFrame(), R_SortEntities(), R_Stain(), R_TimeReport_BeginFrame(), R_TimeReport_EndFrame(), R_TrackSprite(), R_UpdateFog(), R_UpdateVariables(), R_View_SetFrustum(), R_View_Update(), R_View_UpdateEntityVisible(), R_View_WorldVisibility(), R_View_WorldVisibility_CullSurfaces(), R_Water_AddWaterPlane(), R_Water_ProcessPlanes(), RSurf_ActiveCustomEntity(), RSurf_ActiveModelEntity(), RSurf_DrawBatch(), RSurf_FogPoint(), RSurf_FogVertex(), RSurf_PrepareVerticesForBatch(), RSurf_SetupDepthAndCulling(), Sbar_ShowFPS(), SCR_DrawScreen(), V_CalcIntermissionRefdef(), V_CalcRefdef(), V_CalcRefdefUsing(), V_CalcViewBlend(), V_MakeViewIsometric(), VM_CL_getlight(), VM_CL_project(), VM_CL_R_AddDynamicLight(), VM_CL_R_ClearScene(), VM_CL_R_RenderScene(), VM_CL_R_SetView(), and VM_CL_unproject().

◆ r_render

cvar_t r_render

extern

Definition at line 11 of file gl_backend.c.

11{CF_CLIENT, "r_render", "1", "enables rendering 3D views (you want this on!)"};

Referenced by gl_backend_init(), and R_Mesh_Draw().

◆ r_renderview

cvar_t r_renderview

extern

Definition at line 12 of file gl_backend.c.

12{CF_CLIENT, "r_renderview", "1", "enables rendering 3D views (you want this on!)"};

Referenced by gl_backend_init(), and R_RenderView().

◆ r_screenvertex3f

const float r_screenvertex3f[12]

extern

vertex coordinates for a quad that covers the screen exactly

Definition at line 313 of file gl_rmain.c.

{
    0, 0, 0,
    1, 0, 0,
    1, 1, 0,
    0, 1, 0
};

Referenced by R_BlendView(), R_Bloom_MakeTexture(), and R_MotionBlurView().

◆ r_shadow_attenuation2dtexture

rtexture_t* r_shadow_attenuation2dtexture

extern

◆ r_shadow_attenuation3dtexture

rtexture_t* r_shadow_attenuation3dtexture

extern

◆ r_shadow_attenuationgradienttexture

rtexture_t* r_shadow_attenuationgradienttexture

extern

Definition at line 108 of file r_shadow.c.

Referenced by R_SetupShader_DeferredLight(), R_SetupShader_Surface(), R_Shadow_MakeTextures(), r_shadow_shutdown(), and r_shadow_start().

◆ r_shadow_lightshadowmap_parameters

float r_shadow_lightshadowmap_parameters[4]

extern

Definition at line 41 of file r_shadow.c.

Referenced by R_SetupShader_DeferredLight(), R_SetupShader_Surface(), and R_Shadow_SetShadowmapParametersForLight().

◆ r_shadow_lightshadowmap_texturescale

float r_shadow_lightshadowmap_texturescale[4]

extern

Definition at line 40 of file r_shadow.c.

Referenced by R_SetupShader_DeferredLight(), R_SetupShader_Surface(), and R_Shadow_SetShadowmapParametersForLight().

◆ r_shadow_modelshadowmap_parameters

float r_shadow_modelshadowmap_parameters[4]

extern

Definition at line 43 of file r_shadow.c.

Referenced by R_SetupShader_Surface(), and R_Shadow_DrawModelShadowMaps().

◆ r_shadow_modelshadowmap_texturescale

float r_shadow_modelshadowmap_texturescale[4]

extern

Definition at line 42 of file r_shadow.c.

Referenced by R_SetupShader_Surface(), and R_Shadow_DrawModelShadowMaps().

◆ r_shadow_prepass_height

int r_shadow_prepass_height

extern

Definition at line 118 of file r_shadow.c.

Referenced by R_Shadow_PrepareLights(), r_shadow_shutdown(), and r_shadow_start().

◆ r_shadow_prepass_width

int r_shadow_prepass_width

extern

Definition at line 117 of file r_shadow.c.

Referenced by R_Shadow_PrepareLights(), r_shadow_shutdown(), and r_shadow_start().

◆ r_shadow_prepassgeometrydepthbuffer

rtexture_t* r_shadow_prepassgeometrydepthbuffer

extern

Definition at line 119 of file r_shadow.c.

Referenced by R_Shadow_FreeDeferred(), and R_Shadow_PrepareLights().

◆ r_shadow_prepassgeometrynormalmaptexture

rtexture_t* r_shadow_prepassgeometrynormalmaptexture

extern

Definition at line 120 of file r_shadow.c.

Referenced by R_SetupShader_DeferredLight(), R_SetupShader_Surface(), R_Shadow_FreeDeferred(), and R_Shadow_PrepareLights().

◆ r_shadow_prepasslightingdiffusetexture

rtexture_t* r_shadow_prepasslightingdiffusetexture

extern

Definition at line 121 of file r_shadow.c.

◆ r_shadow_prepasslightingspeculartexture

rtexture_t* r_shadow_prepasslightingspeculartexture

extern

Definition at line 122 of file r_shadow.c.

◆ r_shadow_shadowmap2ddepthbuffer

rtexture_t* r_shadow_shadowmap2ddepthbuffer

extern

Definition at line 110 of file r_shadow.c.

Referenced by R_SetupShader_DeferredLight(), R_SetupShader_Surface(), R_Shadow_ClearShadowMapTexture(), R_Shadow_FreeShadowMaps(), R_Shadow_MakeShadowMap(), R_Shadow_RenderMode_ShadowMap(), R_Shadow_SetShadowmapParametersForLight(), and r_shadow_start().

◆ r_shadow_shadowmap2ddepthtexture

rtexture_t* r_shadow_shadowmap2ddepthtexture

extern

Definition at line 111 of file r_shadow.c.

Referenced by R_SetupShader_DeferredLight(), R_SetupShader_Surface(), R_Shadow_ClearShadowMapTexture(), R_Shadow_FreeShadowMaps(), R_Shadow_MakeShadowMap(), R_Shadow_SetShadowmapParametersForLight(), and r_shadow_start().

◆ r_shadow_shadowmapmatrix

matrix4x4_t r_shadow_shadowmapmatrix

extern

Definition at line 62 of file r_shadow.c.

Referenced by R_SetupShader_Surface(), and R_Shadow_DrawModelShadowMaps().

◆ r_shadow_shadowmapvsdct

qbool r_shadow_shadowmapvsdct

extern

Definition at line 57 of file r_shadow.c.

Referenced by R_SetupShader_DeferredLight(), R_SetupShader_Surface(), R_Shadow_ClearShadowMapTexture(), R_Shadow_PrepareLights(), R_Shadow_SetShadowmapParametersForLight(), R_Shadow_SetShadowMode(), and r_shadow_start().

◆ r_shadow_shadowmapvsdcttexture

rtexture_t* r_shadow_shadowmapvsdcttexture

extern

Definition at line 112 of file r_shadow.c.

Referenced by R_SetupShader_DeferredLight(), R_SetupShader_Surface(), R_Shadow_ClearShadowMapTexture(), R_Shadow_FreeShadowMaps(), R_Shadow_MakeVSDCT(), and r_shadow_start().

◆ r_shadow_usingdeferredprepass

qbool r_shadow_usingdeferredprepass

extern

Definition at line 64 of file r_shadow.c.

◆ r_shadow_usingshadowmap2d

qbool r_shadow_usingshadowmap2d

extern

Definition at line 37 of file r_shadow.c.

Referenced by R_SetupShader_DeferredLight(), R_SetupShader_Surface(), R_Shadow_RenderMode_DrawDeferredLight(), R_Shadow_RenderMode_Lighting(), and R_Shadow_RenderMode_Reset().

◆ r_shadow_usingshadowmaportho

qbool r_shadow_usingshadowmaportho

extern

Definition at line 38 of file r_shadow.c.

Referenced by R_SetupShader_Surface(), R_Shadow_DrawModelShadowMaps(), and R_Shadow_PrepareLights().

◆ r_shadow_viewcolortexture

rtexture_t* r_shadow_viewcolortexture

extern

Definition at line 126 of file r_shadow.c.

Referenced by R_RenderScene().

◆ r_shadow_viewdepthtexture

rtexture_t* r_shadow_viewdepthtexture

extern

Definition at line 125 of file r_shadow.c.

Referenced by R_RenderScene().

◆ r_shadow_viewfbo

int r_shadow_viewfbo

extern

Definition at line 124 of file r_shadow.c.

Referenced by R_RenderScene(), and R_Shadow_RenderMode_Reset().

◆ r_shadow_viewheight

int r_shadow_viewheight

extern

Definition at line 130 of file r_shadow.c.

Referenced by R_RenderScene().

◆ r_shadow_viewwidth

int r_shadow_viewwidth

extern

Definition at line 129 of file r_shadow.c.

Referenced by R_RenderScene().

◆ r_shadow_viewx

int r_shadow_viewx

extern

Definition at line 127 of file r_shadow.c.

Referenced by R_RenderScene().

◆ r_shadow_viewy

int r_shadow_viewy

extern

Definition at line 128 of file r_shadow.c.

Referenced by R_RenderScene().

◆ r_shadows

cvar_t r_shadows

extern

Definition at line 123 of file gl_rmain.c.

123{CF_CLIENT | CF_ARCHIVE, "r_shadows", "0", "casts fake stencil shadows from models onto the world (rtlights are unaffected by this); when set to 2, always cast the shadows in the direction set by r_shadows_throwdirection, otherwise use the model lighting."};

Referenced by GL_Main_Init(), R_Shadow_PrepareModelShadows(), and R_Water_ProcessPlanes().

◆ r_shadows_castfrombmodels

cvar_t r_shadows_castfrombmodels

extern

Definition at line 128 of file gl_rmain.c.

128{CF_CLIENT | CF_ARCHIVE, "r_shadows_castfrombmodels", "0", "do cast shadows from bmodels"};

Referenced by GL_Main_Init(), and R_Shadow_PrepareModelShadows().

◆ r_shadows_darken

cvar_t r_shadows_darken

extern

Definition at line 124 of file gl_rmain.c.

124{CF_CLIENT | CF_ARCHIVE, "r_shadows_darken", "0.5", "how much shadowed areas will be darkened"};

Referenced by GL_Main_Init(), and R_Shadow_DrawModelShadowMaps().

◆ r_shadows_drawafterrtlighting

cvar_t r_shadows_drawafterrtlighting

extern

Definition at line 127 of file gl_rmain.c.

127{CF_CLIENT | CF_ARCHIVE, "r_shadows_drawafterrtlighting", "0", "draw fake shadows AFTER realtime lightning is drawn. May be useful for simulating fast sunlight on large outdoor maps with only one noshadow rtlight. The price is less realistic appearance of dynamic light shadows."};

Referenced by GL_Main_Init().

◆ r_shadows_focus

cvar_t r_shadows_focus

extern

Definition at line 129 of file gl_rmain.c.

129{CF_CLIENT | CF_ARCHIVE, "r_shadows_focus", "0 0 0", "offset the shadowed area focus"};

Referenced by GL_Main_Init(), R_Shadow_DrawModelShadowMaps(), and R_Shadow_PrepareModelShadows().

◆ r_shadows_shadowmapbias

cvar_t r_shadows_shadowmapbias

extern

Definition at line 131 of file gl_rmain.c.

131{CF_CLIENT | CF_ARCHIVE, "r_shadows_shadowmapbias", "-1", "sets shadowmap bias for fake shadows. -1 sets the value of r_shadow_shadowmapping_bias. Needs shadowmapping ON."};

Referenced by GL_Main_Init(), and R_Shadow_DrawModelShadowMaps().

◆ r_shadows_shadowmapscale

cvar_t r_shadows_shadowmapscale

extern

Definition at line 130 of file gl_rmain.c.

130{CF_CLIENT | CF_ARCHIVE, "r_shadows_shadowmapscale", "0.25", "higher values increase shadowmap quality at a cost of area covered (multiply global shadowmap precision) for fake shadows. Needs shadowmapping ON."};

Referenced by GL_Main_Init(), R_Shadow_DrawModelShadowMaps(), and R_Shadow_PrepareModelShadows().

◆ r_shadows_throwdirection

cvar_t r_shadows_throwdirection

extern

Definition at line 126 of file gl_rmain.c.

126{CF_CLIENT | CF_ARCHIVE, "r_shadows_throwdirection", "0 0 -1", "override throwing direction for r_shadows 2"};

Referenced by GL_Main_Init(), R_Shadow_DrawModelShadowMaps(), and R_Shadow_PrepareModelShadows().

◆ r_shadows_throwdistance

cvar_t r_shadows_throwdistance

extern

Definition at line 125 of file gl_rmain.c.

125{CF_CLIENT | CF_ARCHIVE, "r_shadows_throwdistance", "500", "how far to cast shadows from models"};

Referenced by GL_Main_Init(), R_Shadow_DrawModelShadowMaps(), and R_Shadow_PrepareModelShadows().

◆ r_showcollisionbrushes

cvar_t r_showcollisionbrushes

extern

Definition at line 89 of file gl_rmain.c.

89{CF_CLIENT, "r_showcollisionbrushes", "0", "draws collision brushes in quake3 maps (mode 1), mode 2 disables rendering of world (trippy!)"};

Referenced by GL_Main_Init(), R_DrawDebugModel(), and R_RenderScene().

◆ r_showcollisionbrushes_polygonfactor

cvar_t r_showcollisionbrushes_polygonfactor

extern

Definition at line 90 of file gl_rmain.c.

90{CF_CLIENT, "r_showcollisionbrushes_polygonfactor", "-1", "expands outward the brush polygons a little bit, used to make collision brushes appear infront of walls"};

Referenced by GL_Main_Init(), and R_DrawDebugModel().

◆ r_showcollisionbrushes_polygonoffset

cvar_t r_showcollisionbrushes_polygonoffset

extern

Definition at line 91 of file gl_rmain.c.

91{CF_CLIENT, "r_showcollisionbrushes_polygonoffset", "0", "nudges brush polygon depth in hardware depth units, used to make collision brushes appear infront of walls"};

Referenced by GL_Main_Init(), and R_DrawDebugModel().

◆ r_showdisabledepthtest

cvar_t r_showdisabledepthtest

extern

Definition at line 92 of file gl_rmain.c.

92{CF_CLIENT, "r_showdisabledepthtest", "0", "disables depth testing on r_show* cvars, allowing you to see what hidden geometry the graphics card is processing"};

Referenced by GL_Main_Init(), R_DrawDebugModel(), R_DrawEntityBBoxes_Callback(), and R_Shadow_RenderLighting().

◆ r_showlighting

cvar_t r_showlighting

extern

Definition at line 88 of file gl_rmain.c.

88{CF_CLIENT, "r_showlighting", "0", "shows areas lit by lights, useful for finding out why some areas of a map render slowly (bright orange = lots of passes = slow), a value of 2 disables depth testing which can be interesting but not very useful"};

Referenced by GL_Main_Init(), R_Shadow_DrawLight(), and R_Shadow_RenderMode_VisibleLighting().

◆ r_shownormals

cvar_t r_shownormals

extern

Definition at line 87 of file gl_rmain.c.

87{CF_CLIENT, "r_shownormals", "0", "shows per-vertex surface normals and tangent vectors for bumpmapped lighting"};

Referenced by GL_Main_Init(), R_DrawDebugModel(), and R_RenderScene().

◆ r_showoverdraw

cvar_t r_showoverdraw

extern

Definition at line 82 of file gl_rmain.c.

82{CF_CLIENT, "r_showoverdraw", "0", "shows overlapping geometry"};

Referenced by GL_Main_Init(), R_DrawDebugModel(), and R_RenderScene().

◆ r_showparticleedges

cvar_t r_showparticleedges

extern

Definition at line 94 of file gl_rmain.c.

94{CF_CLIENT, "r_showparticleedges", "0", "renders a debug outline to show the polygon shape of each particle, for debugging rendering bugs with specific view types"};

Referenced by GL_Main_Init(), and R_DrawParticle_TransparentCallback().

◆ r_showspriteedges

cvar_t r_showspriteedges

extern

Definition at line 93 of file gl_rmain.c.

93{CF_CLIENT, "r_showspriteedges", "0", "renders a debug outline to show the polygon shape of each sprite frame rendered (may be 2 or more in case of interpolated animations), for debugging rendering bugs with specific view types"};

Referenced by GL_Main_Init(), and R_Model_Sprite_Draw_TransparentCallback().

◆ r_showtris

cvar_t r_showtris

extern

Definition at line 86 of file gl_rmain.c.

86{CF_CLIENT, "r_showtris", "0", "shows triangle outlines, value controls brightness (can be above 1)"};

Referenced by GL_Main_Init(), R_DrawDebugModel(), and R_RenderScene().

◆ r_sky

cvar_t r_sky

extern

Definition at line 6 of file r_sky.c.

6{CF_CLIENT | CF_ARCHIVE, "r_sky", "1", "enables sky rendering (black otherwise)"};

Referenced by R_Sky_Init(), and R_SkyStartFrame().

◆ r_sky_scissor

cvar_t r_sky_scissor

extern

Definition at line 9 of file r_sky.c.

9{CF_CLIENT, "r_sky_scissor", "1", "limit rendering of sky to approximately the area of the sky surfaces"};

Referenced by R_DrawTextureSurfaceList_Sky(), R_Sky(), and R_Sky_Init().

◆ r_skyscroll1

cvar_t r_skyscroll1

extern

Definition at line 7 of file r_sky.c.

7{CF_CLIENT | CF_ARCHIVE, "r_skyscroll1", "1", "speed at which upper clouds layer scrolls in quake sky"};

Referenced by M_Menu_Options_Effects_AdjustSliders(), M_Options_Effects_Draw(), R_Sky_Init(), and R_SkySphere().

◆ r_skyscroll2

cvar_t r_skyscroll2

extern

Definition at line 8 of file r_sky.c.

8{CF_CLIENT | CF_ARCHIVE, "r_skyscroll2", "2", "speed at which lower clouds layer scrolls in quake sky"};

Referenced by M_Menu_Options_Effects_AdjustSliders(), M_Options_Effects_Draw(), R_Sky_Init(), and R_SkySphere().

◆ r_smoothnormals_areaweighting

cvar_t r_smoothnormals_areaweighting

extern

Definition at line 229 of file gl_rmain.c.

229{CF_CLIENT, "r_smoothnormals_areaweighting", "1", "uses significantly faster (and supposedly higher quality) area-weighted vertex normals and tangent vectors rather than summing normalized triangle normals and tangents"};

Referenced by GL_Main_Init(), Mod_Alias_MorphMesh_CompileFrames(), Mod_DARKPLACESMODEL_Load(), Mod_INTERQUAKEMODEL_Load(), Mod_OBJ_Load(), Mod_PSKMODEL_Load(), Mod_Q1BSP_LoadFaces(), Mod_Q3BSP_LoadFaces(), Mod_VBSP_LoadFaces(), Mod_ZYMOTICMODEL_Load(), RSurf_ActiveCustomEntity(), and RSurf_PrepareVerticesForBatch().

◆ r_speeds

cvar_t r_speeds

extern

Definition at line 111 of file gl_rmain.c.

111{CF_CLIENT, "r_speeds","0", "displays rendering statistics and per-subsystem timings"};

Referenced by GL_Main_Init(), R_DrawModelSurfaces(), R_TimeReport(), R_TimeReport_BeginFrame(), R_TimeReport_EndFrame(), and VID_Finish().

◆ r_svbsp

svbsp_t r_svbsp

extern

shadow volume bsp struct with automatically growing nodes buffer

Definition at line 268 of file gl_rmain.c.

Referenced by gl_main_shutdown(), gl_main_start(), R_Q1BSP_CallRecursiveGetLightInfo(), R_Q1BSP_RecursiveGetLightInfo_BIH(), and R_Q1BSP_RecursiveGetLightInfo_BSP().

◆ r_test

cvar_t r_test

extern

Definition at line 235 of file gl_rmain.c.

235{CF_CLIENT, "r_test", "0", "internal development use only, leave it alone (usually does nothing anyway)"};

Referenced by GL_Main_Init(), R_Shadow_DrawModelShadowMaps(), and RSurf_DrawBatch().

◆ r_texture_black

rtexture_t* r_texture_black

extern

Definition at line 275 of file gl_rmain.c.

Referenced by gl_main_shutdown(), gl_main_start(), R_BuildBlankTextures(), R_GetCurrentTexture(), and R_SetupShader_Surface().

◆ r_texture_blanknormalmap

rtexture_t* r_texture_blanknormalmap

extern

Definition at line 272 of file gl_rmain.c.

Referenced by gl_main_shutdown(), gl_main_start(), Mod_Q1BSP_LoadFaces(), Mod_Q3BSP_LoadFaces(), Mod_VBSP_LoadFaces(), R_BuildBlankTextures(), R_BuildLightMap(), R_GetCurrentTexture(), and R_SetupShader_Surface().

◆ r_texture_fogattenuation

rtexture_t* r_texture_fogattenuation

extern

Definition at line 279 of file gl_rmain.c.

Referenced by gl_main_shutdown(), gl_main_start(), R_BuildFogTexture(), and R_SetupShader_Surface().

◆ r_texture_fogheighttexture

rtexture_t* r_texture_fogheighttexture

extern

Definition at line 280 of file gl_rmain.c.

Referenced by gl_main_shutdown(), gl_main_start(), R_BuildFogHeightTexture(), and R_SetupShader_Surface().

◆ r_texture_grey128

rtexture_t* r_texture_grey128

extern

Definition at line 274 of file gl_rmain.c.

Referenced by gl_main_shutdown(), gl_main_start(), R_BuildBlankTextures(), and R_GetCurrentTexture().

◆ r_texture_normalizationcube

rtexture_t* r_texture_normalizationcube

extern

Definition at line 278 of file gl_rmain.c.

Referenced by gl_main_shutdown(), gl_main_start(), and R_BuildNormalizationCube().

◆ r_texture_notexture

rtexture_t* r_texture_notexture

extern

Definition at line 276 of file gl_rmain.c.

Referenced by R_BuildNoTexture(), and R_GetCurrentTexture().

◆ r_texture_white

rtexture_t* r_texture_white

extern

Definition at line 273 of file gl_rmain.c.

Referenced by gl_main_shutdown(), gl_main_start(), R_BuildBlankTextures(), R_GetCurrentTexture(), R_RealGetTexture(), and R_SetupShader_Surface().

◆ r_texture_whitecube

rtexture_t* r_texture_whitecube

extern

Definition at line 277 of file gl_rmain.c.

Referenced by gl_main_shutdown(), gl_main_start(), R_BuildWhiteCube(), R_GetCubemap(), R_SetupShader_DeferredLight(), R_SetupShader_Surface(), and R_Shadow_PrepareLight().

◆ r_textureframe

int r_textureframe

extern

used only by R_GetCurrentTexture, incremented per view and per UI render

Definition at line 45 of file gl_rmain.c.

Referenced by DrawQ_FlushUI(), R_GetCurrentTexture(), and R_RenderView().

◆ r_timereport_active

int r_timereport_active

extern

Definition at line 189 of file r_stats.c.

Referenced by R_RenderScene(), R_RenderView(), R_RenderWaterPlanes(), R_Shadow_DrawPrepass(), R_TimeReport(), R_TimeReport_BeginFrame(), R_TimeReport_EndFrame(), and SCR_DrawScreen().

◆ r_transparent_alphatocoverage

cvar_t r_transparent_alphatocoverage

extern

Definition at line 79 of file gl_rmain.c.

79{CF_CLIENT, "r_transparent_alphatocoverage", "1", "enables GL_ALPHA_TO_COVERAGE antialiasing technique on alphablend and alphatest surfaces when using vid_samples 2 or higher"};

Referenced by GL_Main_Init(), R_GetCurrentTexture(), and R_SetupShader_Surface().

◆ r_transparent_sortarraysize

cvar_t r_transparent_sortarraysize

extern

Definition at line 143 of file gl_rmain.c.

143{CF_CLIENT | CF_ARCHIVE, "r_transparent_sortarraysize", "4096", "number of distance-sorting layers"};

Referenced by GL_Main_Init(), and R_MeshQueue_RenderTransparent().

◆ r_transparent_sortmaxdist

cvar_t r_transparent_sortmaxdist

extern

Definition at line 142 of file gl_rmain.c.

142{CF_CLIENT | CF_ARCHIVE, "r_transparent_sortmaxdist", "32768", "upper distance limit for transparent sorting"};

Referenced by GL_Main_Init(), and R_MeshQueue_RenderTransparent().

◆ r_transparent_sortmindist

cvar_t r_transparent_sortmindist

extern

Definition at line 141 of file gl_rmain.c.

141{CF_CLIENT | CF_ARCHIVE, "r_transparent_sortmindist", "0", "lower distance limit for transparent sorting"};

Referenced by GL_Main_Init(), and R_MeshQueue_RenderTransparent().

◆ r_transparent_sortsurfacesbynearest

cvar_t r_transparent_sortsurfacesbynearest

extern

Definition at line 80 of file gl_rmain.c.

80{CF_CLIENT, "r_transparent_sortsurfacesbynearest", "1", "sort entity and world surfaces by nearest point on bounding box instead of using the center of the bounding box, usually reduces sorting artifacts"};

Referenced by GL_Main_Init(), R_Mod_DrawLight(), and R_ProcessTransparentTextureSurfaceList().

◆ r_transparent_useplanardistance

cvar_t r_transparent_useplanardistance

extern

Definition at line 81 of file gl_rmain.c.

81{CF_CLIENT, "r_transparent_useplanardistance", "0", "sort transparent meshes by distance from view plane rather than spherical distance to the chosen point"};

Referenced by GL_Main_Init(), and R_MeshQueue_AddTransparent().

◆ r_trippy

cvar_t r_trippy

extern

Definition at line 29 of file model_brush.c.

29{CF_CLIENT, "r_trippy", "0", "easter egg"};

Referenced by _R_CullBox(), Mod_BrushInit(), Mod_BSP_FatPVS(), R_DrawTextureSurfaceList_Sky(), R_GetCurrentTexture(), R_RenderView(), R_SetupShader_DepthOrShadow(), R_SetupShader_Generic(), R_SetupShader_Surface(), R_Shadow_ComputeShadowCasterCullingPlanes(), R_Shadow_ScissorForBBox(), R_View_WorldVisibility_CullSurfaces(), SV_MarkWriteEntityStateToClient(), and V_MakeViewIsometric().

◆ r_viewfbo

cvar_t r_viewfbo

extern

Definition at line 160 of file gl_rmain.c.

160{CF_CLIENT | CF_ARCHIVE, "r_viewfbo", "0", "enables use of an 8bit (1) or 16bit (2) or 32bit (3) per component float framebuffer render, which may be at a different resolution than the video mode; the default setting of 0 uses a framebuffer render when required, and renders directly to the screen otherwise"};

Referenced by GL_Main_Init(), R_BlendView_IsTrivial(), R_Bloom_StartFrame(), and VID_Mode().

◆ r_wateralpha

cvar_t r_wateralpha

extern

Definition at line 120 of file gl_rmain.c.

120{CF_CLIENT | CF_ARCHIVE, "r_wateralpha","1", "opacity of water polygons"};

Referenced by GL_Main_Init(), M_Menu_Options_Effects_AdjustSliders(), M_Options_Effects_Draw(), R_DrawTextureSurfaceList_ShowSurfaces(), R_GetCurrentTexture(), and R_SetupShader_Surface().

◆ r_waterscroll

cvar_t r_waterscroll

extern

Definition at line 206 of file gl_rmain.c.

206{CF_CLIENT | CF_ARCHIVE, "r_waterscroll", "1", "makes water scroll around, value controls how much"};

Referenced by GL_Main_Init(), M_Menu_Options_Effects_AdjustSliders(), M_Options_Effects_Draw(), and R_RenderScene().

◆ r_waterwarp

cvar_t r_waterwarp

extern

Definition at line 13 of file gl_backend.c.

13{CF_CLIENT | CF_ARCHIVE, "r_waterwarp", "1", "warp view while underwater"};

Referenced by gl_backend_init(), M_Menu_Options_Effects_AdjustSliders(), M_Options_Effects_Draw(), and V_CalcViewBlend().

◆ rsurface

rsurfacestate_t rsurface

extern

Definition at line 6919 of file gl_rmain.c.

Referenced by R_DecalSystem_SplatEntity(), R_DecalSystem_SplatTriangle(), R_DrawCustomSurface_Texture(), R_DrawDebugModel(), R_DrawModelDecals_Entity(), R_DrawModelSurfaces(), R_DrawNoModel(), R_DrawNoModel_TransparentCallback(), R_DrawPortals(), R_DrawSurface_TransparentCallback(), R_DrawTextureSurfaceList_DepthOnly(), R_DrawTextureSurfaceList_GL20(), R_DrawTextureSurfaceList_ShowSurfaces(), R_DrawTextureSurfaceList_Sky(), R_EvaluateQ3WaveFunc(), R_GetCurrentTexture(), R_Mod_DrawAddWaterPlanes(), R_Mod_DrawLight(), R_Mod_DrawShadowMap(), R_Mod_GetLightInfo(), R_Model_Sprite_Draw(), R_Model_Sprite_Draw_TransparentCallback(), R_ProcessModelTextureSurfaceList(), R_ProcessTransparentTextureSurfaceList(), R_Q1BSP_DrawLight_TransparentCallback(), R_QueueModelSurfaceList(), R_RenderView(), R_SetupShader_DeferredLight(), R_SetupShader_DepthOrShadow(), R_SetupShader_Surface(), R_Shadow_DrawEntityLight(), R_Shadow_DrawEntityShadow(), R_Shadow_DrawModelShadowMaps(), R_Shadow_DrawWorldLight(), R_Shadow_DrawWorldShadow_ShadowMap(), R_Shadow_RenderLighting(), R_Shadow_RenderLighting_VisibleLighting(), R_Shadow_RenderMode_ActiveLight(), R_Shadow_RenderMode_DrawDeferredLight(), R_Shadow_RenderMode_ShadowMap(), R_Shadow_SetShadowmapParametersForLight(), R_Shadow_SetupEntityLight(), R_tcMod_ApplyToMatrix(), R_TestQ3WaveFunc(), R_Water_AddWaterPlane(), RSurf_ActiveCustomEntity(), RSurf_ActiveModelEntity(), RSurf_DrawBatch(), RSurf_FindWaterPlaneForSurface(), RSurf_FogVertex(), RSurf_PrepareVerticesForBatch(), RSurf_SetupDepthAndCulling(), and RSurf_UploadBuffersForBatch().

◆ skyrenderlater

int skyrenderlater

extern

Definition at line 10 of file r_sky.c.

Referenced by R_DrawTextureSurfaceList_Sky(), R_RenderScene(), and R_SkyStartFrame().

◆ skyrendermasked

int skyrendermasked

Definition at line 120 of file render.h.

◆ skyscissor

int skyscissor[4]

extern

Definition at line 12 of file r_sky.c.

Referenced by R_DrawTextureSurfaceList_Sky(), R_Sky(), and R_SkyStartFrame().

Data Structures

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ BATCHNEED_ALLOWMULTIDRAW

◆ BATCHNEED_ALWAYSCOPY

◆ BATCHNEED_ARRAY_LIGHTMAP

◆ BATCHNEED_ARRAY_NORMAL

◆ BATCHNEED_ARRAY_SKELETAL

◆ BATCHNEED_ARRAY_TEXCOORD

◆ BATCHNEED_ARRAY_VECTOR

◆ BATCHNEED_ARRAY_VERTEX

◆ BATCHNEED_ARRAY_VERTEXCOLOR

◆ BATCHNEED_ARRAY_VERTEXTINTCOLOR

◆ BATCHNEED_NOGAPS

◆ BOTTOM_RANGE

◆ FOGMASKTABLEWIDTH

◆ gl_alpha_format

◆ gl_solid_format

◆ SHADERPERMUTATION_ALPHAGEN_VERTEX

◆ SHADERPERMUTATION_ALPHAKILL

◆ SHADERPERMUTATION_BLOOM

◆ SHADERPERMUTATION_BOUNCEGRID

◆ SHADERPERMUTATION_BOUNCEGRIDDIRECTIONAL

◆ SHADERPERMUTATION_COLORMAPPING

◆ SHADERPERMUTATION_COUNT

◆ SHADERPERMUTATION_CUBEFILTER

◆ SHADERPERMUTATION_DEFERREDLIGHTMAP

◆ SHADERPERMUTATION_DEPTHRGB

◆ SHADERPERMUTATION_DIFFUSE

◆ SHADERPERMUTATION_FOGALPHAHACK

◆ SHADERPERMUTATION_FOGHEIGHTTEXTURE

◆ SHADERPERMUTATION_FOGINSIDE

◆ SHADERPERMUTATION_FOGOUTSIDE

◆ SHADERPERMUTATION_GAMMARAMPS

◆ SHADERPERMUTATION_GLOW

◆ SHADERPERMUTATION_NORMALMAPSCROLLBLEND

◆ SHADERPERMUTATION_OCCLUDE

◆ SHADERPERMUTATION_OFFSETMAPPING

◆ SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING

◆ SHADERPERMUTATION_POSTPROCESSING

◆ SHADERPERMUTATION_REFLECTCUBE

◆ SHADERPERMUTATION_REFLECTION

◆ SHADERPERMUTATION_SATURATION

◆ SHADERPERMUTATION_SHADOWMAP2D

◆ SHADERPERMUTATION_SHADOWMAPORTHO

◆ SHADERPERMUTATION_SHADOWMAPVSDCT

◆ SHADERPERMUTATION_SKELETAL

◆ SHADERPERMUTATION_SPECULAR

◆ SHADERPERMUTATION_TRIPPY

◆ SHADERPERMUTATION_VERTEXTEXTUREBLEND

◆ SHADERPERMUTATION_VIEWTINT

◆ TOP_RANGE

Enumeration Type Documentation

◆ glsl_attrib

◆ r_bufferdata_type_t

◆ r_refdef_scene_type_t

◆ r_viewport_type_t

◆ rsurfacepass_t

◆ shaderlanguage_t

◆ shadermode_t

Function Documentation

◆ CL_VM_DrawHud()

◆ CL_VM_UpdateView()

◆ FindFont()

◆ FOG_clear()

◆ Font_Init()

◆ gl_backend_init()

◆ GL_Draw_Init()

◆ GL_Main_Init()

◆ GL_Surf_Init()

◆ LoadFont()

◆ Mod_RenderInit()

◆ R_AnimCache_CacheVisibleEntities()

◆ R_AnimCache_ClearCache()

◆ R_AnimCache_Free()

◆ R_AnimCache_GetEntity()

◆ R_BufferData_NewFrame()