#define RENDER_H
#include "svbsp.h"
+#include "r_stats.h"
typedef enum glsl_attrib_e
{
}
shaderlanguage_t;
-// this enum selects which of the glslshadermodeinfo entries should be used
+/// this enum selects which of the glslshadermodeinfo entries should be used
typedef enum shadermode_e
{
SHADERMODE_GENERIC, ///< (particles/HUD/etc) vertex color, optionally multiplied by one texture
}
shadermode_t;
-#define SHADERPERMUTATION_DIFFUSE (1<<0) ///< (lightsource) whether to use directional shading
-#define SHADERPERMUTATION_VERTEXTEXTUREBLEND (1<<1) ///< indicates this is a two-layer material blend based on vertex alpha (q3bsp)
-#define SHADERPERMUTATION_VIEWTINT (1<<2) ///< view tint (postprocessing only), use vertex colors (generic only)
-#define SHADERPERMUTATION_COLORMAPPING (1<<3) ///< indicates this is a colormapped skin
-#define SHADERPERMUTATION_SATURATION (1<<4) ///< saturation (postprocessing only)
-#define SHADERPERMUTATION_FOGINSIDE (1<<5) ///< tint the color by fog color or black if using additive blend mode
-#define SHADERPERMUTATION_FOGOUTSIDE (1<<6) ///< tint the color by fog color or black if using additive blend mode
-#define SHADERPERMUTATION_FOGHEIGHTTEXTURE (1<<7) ///< fog color and density determined by texture mapped on vertical axis
-#define SHADERPERMUTATION_FOGALPHAHACK (1<<8) ///< fog color and density determined by texture mapped on vertical axis
-#define SHADERPERMUTATION_GAMMARAMPS (1<<9) ///< gamma (postprocessing only)
-#define SHADERPERMUTATION_CUBEFILTER (1<<10) ///< (lightsource) use cubemap light filter
-#define SHADERPERMUTATION_GLOW (1<<11) ///< (lightmap) blend in an additive glow texture
-#define SHADERPERMUTATION_BLOOM (1<<12) ///< bloom (postprocessing only)
-#define SHADERPERMUTATION_SPECULAR (1<<13) ///< (lightsource or deluxemapping) render specular effects
-#define SHADERPERMUTATION_POSTPROCESSING (1<<14) ///< user defined postprocessing (postprocessing only)
-#define SHADERPERMUTATION_REFLECTION (1<<15) ///< normalmap-perturbed reflection of the scene infront of the surface, preformed as an overlay on the surface
-#define SHADERPERMUTATION_OFFSETMAPPING (1<<16) ///< adjust texcoords to roughly simulate a displacement mapped surface
-#define SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING (1<<17) ///< adjust texcoords to accurately simulate a displacement mapped surface (requires OFFSETMAPPING to also be set!)
-#define SHADERPERMUTATION_SHADOWMAP2D (1<<18) ///< (lightsource) use shadowmap texture as light filter
-#define SHADERPERMUTATION_SHADOWMAPVSDCT (1<<19) ///< (lightsource) use virtual shadow depth cube texture for shadowmap indexing
-#define SHADERPERMUTATION_SHADOWMAPORTHO (1<<20) ///< (lightsource) use orthographic shadowmap projection
-#define SHADERPERMUTATION_DEFERREDLIGHTMAP (1<<21) ///< (lightmap) read Texture_ScreenDiffuse/Specular textures and add them on top of lightmapping
-#define SHADERPERMUTATION_ALPHAKILL (1<<22) ///< (deferredgeometry) discard pixel if diffuse texture alpha below 0.5, (generic) apply global alpha
-#define SHADERPERMUTATION_REFLECTCUBE (1<<23) ///< fake reflections using global cubemap (not HDRI light probe)
-#define SHADERPERMUTATION_NORMALMAPSCROLLBLEND (1<<24) ///< (water) counter-direction normalmaps scrolling
-#define SHADERPERMUTATION_BOUNCEGRID (1<<25) ///< (lightmap) use Texture_BounceGrid as an additional source of ambient light
-#define SHADERPERMUTATION_BOUNCEGRIDDIRECTIONAL (1<<26) ///< (lightmap) use 16-component pixels in bouncegrid texture for directional lighting rather than standard 4-component
-#define SHADERPERMUTATION_TRIPPY (1<<27) ///< use trippy vertex shader effect
-#define SHADERPERMUTATION_DEPTHRGB (1<<28) ///< read/write depth values in RGB color coded format for older hardware without depth samplers
-#define SHADERPERMUTATION_ALPHAGEN_VERTEX (1<<29) ///< alphaGen vertex
-#define SHADERPERMUTATION_SKELETAL (1<<30) ///< (skeletal models) use skeletal matrices to deform vertices (gpu-skinning)
-#define SHADERPERMUTATION_OCCLUDE (1<<31) ///< use occlusion buffer for corona
-#define SHADERPERMUTATION_COUNT 32 ///< size of shaderpermutationinfo array
+#define SHADERPERMUTATION_DIFFUSE (1u<<0) ///< (lightsource) whether to use directional shading
+#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 SHADERPERMUTATION_COLORMAPPING (1u<<3) ///< indicates this is a colormapped skin
+#define SHADERPERMUTATION_SATURATION (1u<<4) ///< saturation (postprocessing only)
+#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_FOGHEIGHTTEXTURE (1u<<7) ///< fog color and density determined by texture mapped on vertical axis
+#define SHADERPERMUTATION_FOGALPHAHACK (1u<<8) ///< fog color and density determined by texture mapped on vertical axis
+#define SHADERPERMUTATION_GAMMARAMPS (1u<<9) ///< gamma (postprocessing only)
+#define SHADERPERMUTATION_CUBEFILTER (1u<<10) ///< (lightsource) use cubemap light filter
+#define SHADERPERMUTATION_GLOW (1u<<11) ///< (lightmap) blend in an additive glow texture
+#define SHADERPERMUTATION_BLOOM (1u<<12) ///< bloom (postprocessing only)
+#define SHADERPERMUTATION_SPECULAR (1u<<13) ///< (lightsource or deluxemapping) render specular effects
+#define SHADERPERMUTATION_POSTPROCESSING (1u<<14) ///< user defined postprocessing (postprocessing only)
+#define SHADERPERMUTATION_REFLECTION (1u<<15) ///< normalmap-perturbed reflection of the scene infront of the surface, preformed as an overlay on the surface
+#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_SHADOWMAP2D (1u<<18) ///< (lightsource) use shadowmap texture as light filter
+#define SHADERPERMUTATION_SHADOWMAPVSDCT (1u<<19) ///< (lightsource) use virtual shadow depth cube texture for shadowmap indexing
+#define SHADERPERMUTATION_SHADOWMAPORTHO (1u<<20) ///< (lightsource) use orthographic shadowmap projection
+#define SHADERPERMUTATION_DEFERREDLIGHTMAP (1u<<21) ///< (lightmap) read Texture_ScreenDiffuse/Specular textures and add them on top of lightmapping
+#define SHADERPERMUTATION_ALPHAKILL (1u<<22) ///< (deferredgeometry) discard pixel if diffuse texture alpha below 0.5, (generic) apply global alpha
+#define SHADERPERMUTATION_REFLECTCUBE (1u<<23) ///< fake reflections using global cubemap (not HDRI light probe)
+#define SHADERPERMUTATION_NORMALMAPSCROLLBLEND (1u<<24) ///< (water) counter-direction normalmaps scrolling
+#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_TRIPPY (1u<<27) ///< use trippy vertex shader effect
+#define SHADERPERMUTATION_DEPTHRGB (1u<<28) ///< read/write depth values in RGB color coded format for older hardware without depth samplers
+#define SHADERPERMUTATION_ALPHAGEN_VERTEX (1u<<29) ///< alphaGen vertex
+#define SHADERPERMUTATION_SKELETAL (1u<<30) ///< (skeletal models) use skeletal matrices to deform vertices (gpu-skinning)
+#define SHADERPERMUTATION_OCCLUDE (1u<<31) ///< use occlusion buffer for corona
+#define SHADERPERMUTATION_COUNT 32u ///< size of shaderpermutationinfo array
+// UBSan: unsigned literals because left shifting by 31 causes signed overflow, although it works as expected on x86.
// 1.0f / N table
extern float ixtable[4096];
extern cvar_t r_wateralpha;
extern cvar_t r_dynamic;
+extern cvar_t r_q1bsp_lightmap_updates_enabled;
+extern cvar_t r_q1bsp_lightmap_updates_combine;
+extern cvar_t r_q1bsp_lightmap_updates_combine_full_texture;
+extern cvar_t r_q1bsp_lightmap_updates_hidden_surfaces;
+
+void R_NewExplosion(const vec3_t org);
void R_UpdateVariables(void); // must call after setting up most of r_refdef, but before calling R_RenderView
void R_RenderView(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture, int x, int y, int width, int height); // must set r_refdef and call R_UpdateVariables and CL_UpdateEntityShading first
void R_RenderView_UpdateViewVectors(void); // just updates r_refdef.view.{forward,left,up,origin,right,inverse_matrix}
+float RSurf_FogPoint(const float *v);
+float RSurf_FogVertex(const float *v);
+
typedef enum r_refdef_scene_type_s {
RST_CLIENT,
RST_MENU,
RST_COUNT
} r_refdef_scene_type_t;
+typedef enum r_viewport_type_e
+{
+ R_VIEWPORTTYPE_ORTHO,
+ R_VIEWPORTTYPE_PERSPECTIVE,
+ R_VIEWPORTTYPE_PERSPECTIVE_INFINITEFARCLIP,
+ R_VIEWPORTTYPE_PERSPECTIVECUBESIDE,
+ R_VIEWPORTTYPE_TOTAL
+}
+r_viewport_type_t;
+
+typedef struct r_viewport_s
+{
+ matrix4x4_t cameramatrix; ///< from entity (transforms from camera entity to world)
+ matrix4x4_t viewmatrix; ///< actual matrix for rendering (transforms to viewspace)
+ matrix4x4_t projectmatrix; ///< actual projection matrix (transforms from viewspace to screen)
+ int x;
+ int y;
+ int z;
+ int width;
+ int height;
+ int depth;
+ r_viewport_type_t type;
+ float screentodepth[2]; ///< used by deferred renderer to calculate linear depth from device depth coordinates
+}
+r_viewport_t;
+
+typedef struct r_refdef_view_s
+{
+ // view information (changes multiple times per frame)
+ // if any of these variables change then r_refdef.viewcache must be regenerated
+ // by calling R_View_Update
+ // (which also updates viewport, scissor, colormask)
+
+ // it is safe and expected to copy this into a structure on the stack and
+ // call the renderer recursively, then restore from the stack afterward
+ // (as long as R_View_Update is called)
+
+ // eye position information
+ matrix4x4_t matrix, inverse_matrix;
+ vec3_t origin;
+ vec3_t forward;
+ vec3_t left;
+ vec3_t right;
+ vec3_t up;
+ int numfrustumplanes;
+ mplane_t frustum[6];
+ qbool useclipplane;
+ qbool usecustompvs; ///< uses r_refdef.viewcache.pvsbits as-is rather than computing it
+ mplane_t clipplane;
+ float frustum_x, frustum_y;
+ vec3_t frustumcorner[4];
+ /// if turned off it renders an ortho view
+ int useperspective;
+ /// allows visibility culling based on the view origin (e.g. pvs and R_CanSeeBox)
+ /// this is turned off by:
+ /// r_trippy
+ /// !r_refdef.view.useperspective
+ /// (sometimes) r_refdef.view.useclipplane
+ int usevieworiginculling;
+ float ortho_x, ortho_y;
+
+ // screen area to render in
+ int x;
+ int y;
+ int z;
+ int width;
+ int height;
+ int depth;
+ r_viewport_t viewport; ///< note: if r_viewscale is used, the viewport.width and viewport.height may be less than width and height
+
+ /// which color components to allow (for anaglyph glasses)
+ int colormask[4];
+
+ /// global RGB color multiplier for rendering
+ float colorscale;
+
+ /// whether to call R_ClearScreen before rendering stuff
+ qbool clear;
+ /// if true, don't clear or do any post process effects (bloom, etc)
+ qbool isoverlay;
+ /// if true, this is the MAIN view (which is, after CSQC, copied into the scene for use e.g. by r_speeds 1, showtex, prydon cursor)
+ qbool ismain;
+
+ // whether to draw r_showtris and such, this is only true for the main
+ // view render, all secondary renders (mirrors, portals, cameras,
+ // distortion effects, etc) omit such debugging information
+ qbool showdebug;
+
+ // these define which values to use in GL_CullFace calls to request frontface or backface culling
+ int cullface_front;
+ int cullface_back;
+
+ /// render quality (0 to 1) - affects r_drawparticles_drawdistance and others
+ float quality;
+}
+r_refdef_view_t;
+
+typedef struct r_refdef_viewcache_s
+{
+ // updated by gl_main_newmap()
+ int maxentities;
+ int world_numclusters;
+ int world_numclusterbytes;
+ int world_numleafs;
+ int world_numsurfaces;
+
+ // these properties are generated by R_View_Update()
+
+ /// which entities are currently visible for this viewpoint
+ /// (the used range is 0...r_refdef.scene.numentities)
+ unsigned char *entityvisible;
+
+ // flag arrays used for visibility checking on world model
+ // (all other entities have no per-surface/per-leaf visibility checks)
+ unsigned char *world_pvsbits;
+ unsigned char *world_leafvisible;
+ unsigned char *world_surfacevisible;
+ /// if true, the view is currently in a leaf without pvs data
+ qbool world_novis;
+}
+r_refdef_viewcache_t;
+
+// TODO: really think about which fields should go into scene and which one should stay in refdef [1/7/2008 Black]
+// maybe also refactor some of the functions to support different setting sources (ie. fogenabled, etc.) for different scenes
+typedef struct r_refdef_scene_s {
+ /// whether to call S_ExtraUpdate during render to reduce sound chop
+ qbool extraupdate;
+
+ /// (client gameworld) time for rendering time based effects
+ double time;
+
+ /// the world
+ entity_render_t *worldentity;
+
+ /// same as worldentity->model
+ model_t *worldmodel;
+
+ /// renderable entities (excluding world)
+ entity_render_t **entities;
+ int numentities;
+ int maxentities;
+
+ /// field of temporary entities that is reset each (client) frame
+ entity_render_t *tempentities;
+ int numtempentities;
+ int maxtempentities;
+ qbool expandtempentities;
+
+ // renderable dynamic lights
+ rtlight_t *lights[MAX_DLIGHTS];
+ rtlight_t templights[MAX_DLIGHTS];
+ int numlights;
+
+ // intensities for light styles right now, controls rtlights
+ float rtlightstylevalue[MAX_LIGHTSTYLES]; ///< float fraction of base light value
+ // 8.8bit fixed point intensities for light styles
+ // controls intensity lightmap layers
+ unsigned short lightstylevalue[MAX_LIGHTSTYLES]; ///< 8.8 fraction of base light value
+
+ // adds brightness to the whole scene, separate from lightmapintensity
+ // see CL_UpdateEntityShading
+ float ambientintensity;
+ // brightness of lightmap and modellight lighting on materials
+ // see CL_UpdateEntityShading
+ float lightmapintensity;
+
+ qbool rtworld;
+ qbool rtworldshadows;
+ qbool rtdlight;
+ qbool rtdlightshadows;
+} r_refdef_scene_t;
+
+typedef struct r_refdef_s
+{
+ // these fields define the basic rendering information for the world
+ // but not the view, which could change multiple times in one rendered
+ // frame (for example when rendering textures for certain effects)
+
+ // these are set for water warping before
+ // frustum_x/frustum_y are calculated
+ float frustumscale_x, frustumscale_y;
+
+ // current view settings (these get reset a few times during rendering because of water rendering, reflections, etc)
+ r_refdef_view_t view;
+ r_refdef_viewcache_t viewcache;
+
+ // minimum visible distance (pixels closer than this disappear)
+ double nearclip;
+ // maximum visible distance (pixels further than this disappear in 16bpp modes,
+ // in 32bpp an infinite-farclip matrix is used instead)
+ double farclip;
+
+ // fullscreen color blend
+ float viewblend[4];
+
+ r_refdef_scene_t scene;
+
+ float fogplane[4];
+ float fogplaneviewdist;
+ qbool fogplaneviewabove;
+ float fogheightfade;
+ float fogcolor[3];
+ float fogrange;
+ float fograngerecip;
+ float fogmasktabledistmultiplier;
+#define FOGMASKTABLEWIDTH 1024
+ float fogmasktable[FOGMASKTABLEWIDTH];
+ float fogmasktable_start, fogmasktable_alpha, fogmasktable_range, fogmasktable_density;
+ float fog_density;
+ float fog_red;
+ float fog_green;
+ float fog_blue;
+ float fog_alpha;
+ float fog_start;
+ float fog_end;
+ float fog_height;
+ float fog_fadedepth;
+ qbool fogenabled;
+ qbool oldgl_fogenable;
+
+ // new flexible texture height fog (overrides normal fog)
+ char fog_height_texturename[64]; // note: must be 64 for the sscanf code
+ unsigned char *fog_height_table1d;
+ unsigned char *fog_height_table2d;
+ int fog_height_tablesize; // enable
+ float fog_height_tablescale;
+ float fog_height_texcoordscale;
+ char fogheighttexturename[64]; // detects changes to active fog height texture
+
+ int draw2dstage; // 0 = no, 1 = yes, other value = needs setting up again
+
+ // true during envmap command capture
+ qbool envmap;
+
+ // whether to draw world lights realtime, dlights realtime, and their shadows
+ float polygonfactor;
+ float polygonoffset;
+
+ // how long R_RenderView took on the previous frame
+ double lastdrawscreentime;
+
+ // rendering stats for r_speeds display
+ // (these are incremented in many places)
+ int stats[r_stat_count];
+}
+r_refdef_t;
+
+extern r_refdef_t r_refdef;
+
void R_SelectScene( r_refdef_scene_type_t scenetype );
r_refdef_scene_t * R_GetScenePointer( r_refdef_scene_type_t scenetype );
#define gl_solid_format 3
#define gl_alpha_format 4
-int R_CullBox(const vec3_t mins, const vec3_t maxs);
-int R_CullBoxCustomPlanes(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);
+qbool R_CullBox(const vec3_t mins, const vec3_t maxs, int numplanes, const mplane_t *planes);
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);
#include "r_modules.h"
extern cvar_t r_renderview;
extern cvar_t r_waterwarp;
-extern cvar_t r_textureunits;
-
extern cvar_t r_glsl_offsetmapping;
extern cvar_t r_glsl_offsetmapping_reliefmapping;
extern cvar_t r_glsl_offsetmapping_scale;
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_CalcBeam_Vertex3f(float *vert, const float *org1, const float *org2, float width);
-void R_CalcSprite_Vertex3f(float *vertex3f, const float *origin, const float *left, const float *up, float scalex1, float scalex2, float scaley1, float scaley2);
+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);
extern mempool_t *r_main_mempool;
void RSurf_ActiveModelEntity(const entity_render_t *ent, qbool wantnormals, qbool wanttangents, qbool prepass);
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_SetupDepthAndCulling(void);
+void RSurf_SetupDepthAndCulling(bool ui);
extern int r_textureframe; ///< used only by R_GetCurrentTexture, incremented per view and per UI render
texture_t *R_GetCurrentTexture(texture_t *t);
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_DepthOrShadow(qbool notrippy, qbool depthrgb, qbool skeletal);
-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);
+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_SetupShader_DeferredLight(const rtlight_t *rtlight);
typedef struct r_rendertarget_s {
void R_DecalSystem_Reset(decalsystem_t *decalsystem);
void R_Shadow_UpdateBounceGridTexture(void);
void R_DrawPortals(void);
-void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
+void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface, int combine);
void R_Water_AddWaterPlane(msurface_t *surface, int entno);
int R_Shadow_GetRTLightInfo(unsigned int lightindex, float *origin, float *radius, float *color);
dp_font_t *FindFont(const char *title, qbool allocate_new);