2 Copyright (C) 1996-1997 Id Software, Inc.
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
13 See the GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23 #include "cl_dyntexture.h"
30 #include "dpsoftrast.h"
34 extern LPDIRECT3DDEVICE9 vid_d3d9dev;
37 mempool_t *r_main_mempool;
38 rtexturepool_t *r_main_texturepool;
40 static int r_textureframe = 0; ///< used only by R_GetCurrentTexture
42 static qboolean r_loadnormalmap;
43 static qboolean r_loadgloss;
45 static qboolean r_loaddds;
46 static qboolean r_savedds;
53 cvar_t r_motionblur = {CVAR_SAVE, "r_motionblur", "0", "screen motionblur - value represents intensity, somewhere around 0.5 recommended"};
54 cvar_t r_damageblur = {CVAR_SAVE, "r_damageblur", "0", "screen motionblur based on damage - value represents intensity, somewhere around 0.5 recommended"};
55 cvar_t r_motionblur_averaging = {CVAR_SAVE, "r_motionblur_averaging", "0.1", "sliding average reaction time for velocity (higher = slower adaption to change)"};
56 cvar_t r_motionblur_randomize = {CVAR_SAVE, "r_motionblur_randomize", "0.1", "randomizing coefficient to workaround ghosting"};
57 cvar_t r_motionblur_minblur = {CVAR_SAVE, "r_motionblur_minblur", "0.5", "factor of blur to apply at all times (always have this amount of blur no matter what the other factors are)"};
58 cvar_t r_motionblur_maxblur = {CVAR_SAVE, "r_motionblur_maxblur", "0.9", "maxmimum amount of blur"};
59 cvar_t r_motionblur_velocityfactor = {CVAR_SAVE, "r_motionblur_velocityfactor", "1", "factoring in of player velocity to the blur equation - the faster the player moves around the map, the more blur they get"};
60 cvar_t r_motionblur_velocityfactor_minspeed = {CVAR_SAVE, "r_motionblur_velocityfactor_minspeed", "400", "lower value of velocity when it starts to factor into blur equation"};
61 cvar_t r_motionblur_velocityfactor_maxspeed = {CVAR_SAVE, "r_motionblur_velocityfactor_maxspeed", "800", "upper value of velocity when it reaches the peak factor into blur equation"};
62 cvar_t r_motionblur_mousefactor = {CVAR_SAVE, "r_motionblur_mousefactor", "2", "factoring in of mouse acceleration to the blur equation - the faster the player turns their mouse, the more blur they get"};
63 cvar_t r_motionblur_mousefactor_minspeed = {CVAR_SAVE, "r_motionblur_mousefactor_minspeed", "0", "lower value of mouse acceleration when it starts to factor into blur equation"};
64 cvar_t r_motionblur_mousefactor_maxspeed = {CVAR_SAVE, "r_motionblur_mousefactor_maxspeed", "50", "upper value of mouse acceleration when it reaches the peak factor into blur equation"};
66 // TODO do we want a r_equalize_entities cvar that works on all ents, or would that be a cheat?
67 cvar_t r_equalize_entities_fullbright = {CVAR_SAVE, "r_equalize_entities_fullbright", "0", "render fullbright entities by equalizing their lightness, not by not rendering light"};
68 cvar_t r_equalize_entities_minambient = {CVAR_SAVE, "r_equalize_entities_minambient", "0.5", "light equalizing: ensure at least this ambient/diffuse ratio"};
69 cvar_t r_equalize_entities_by = {CVAR_SAVE, "r_equalize_entities_by", "0.7", "light equalizing: exponent of dynamics compression (0 = no compression, 1 = full compression)"};
70 cvar_t r_equalize_entities_to = {CVAR_SAVE, "r_equalize_entities_to", "0.8", "light equalizing: target light level"};
72 cvar_t r_depthfirst = {CVAR_SAVE, "r_depthfirst", "0", "renders a depth-only version of the scene before normal rendering begins to eliminate overdraw, values: 0 = off, 1 = world depth, 2 = world and model depth"};
73 cvar_t r_useinfinitefarclip = {CVAR_SAVE, "r_useinfinitefarclip", "1", "enables use of a special kind of projection matrix that has an extremely large farclip"};
74 cvar_t r_farclip_base = {0, "r_farclip_base", "65536", "farclip (furthest visible distance) for rendering when r_useinfinitefarclip is 0"};
75 cvar_t r_farclip_world = {0, "r_farclip_world", "2", "adds map size to farclip multiplied by this value"};
76 cvar_t r_nearclip = {0, "r_nearclip", "1", "distance from camera of nearclip plane" };
77 cvar_t r_deformvertexes = {0, "r_deformvertexes", "1", "allows use of deformvertexes in shader files (can be turned off to check performance impact)"};
78 cvar_t r_transparent = {0, "r_transparent", "1", "allows use of transparent surfaces (can be turned off to check performance impact)"};
79 cvar_t r_transparent_alphatocoverage = {0, "r_transparent_alphatocoverage", "1", "enables GL_ALPHA_TO_COVERAGE antialiasing technique on alphablend and alphatest surfaces when using vid_samples 2 or higher"};
80 cvar_t r_transparent_sortsurfacesbynearest = {0, "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"};
81 cvar_t r_transparent_useplanardistance = {0, "r_transparent_useplanardistance", "0", "sort transparent meshes by distance from view plane rather than spherical distance to the chosen point"};
82 cvar_t r_showoverdraw = {0, "r_showoverdraw", "0", "shows overlapping geometry"};
83 cvar_t r_showbboxes = {0, "r_showbboxes", "0", "shows bounding boxes of server entities, value controls opacity scaling (1 = 10%, 10 = 100%)"};
84 cvar_t r_showsurfaces = {0, "r_showsurfaces", "0", "1 shows surfaces as different colors, or a value of 2 shows triangle draw order (for analyzing whether meshes are optimized for vertex cache)"};
85 cvar_t r_showtris = {0, "r_showtris", "0", "shows triangle outlines, value controls brightness (can be above 1)"};
86 cvar_t r_shownormals = {0, "r_shownormals", "0", "shows per-vertex surface normals and tangent vectors for bumpmapped lighting"};
87 cvar_t r_showlighting = {0, "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"};
88 cvar_t r_showshadowvolumes = {0, "r_showshadowvolumes", "0", "shows areas shadowed by lights, useful for finding out why some areas of a map render slowly (bright blue = lots of passes = slow), a value of 2 disables depth testing which can be interesting but not very useful"};
89 cvar_t r_showcollisionbrushes = {0, "r_showcollisionbrushes", "0", "draws collision brushes in quake3 maps (mode 1), mode 2 disables rendering of world (trippy!)"};
90 cvar_t r_showcollisionbrushes_polygonfactor = {0, "r_showcollisionbrushes_polygonfactor", "-1", "expands outward the brush polygons a little bit, used to make collision brushes appear infront of walls"};
91 cvar_t r_showcollisionbrushes_polygonoffset = {0, "r_showcollisionbrushes_polygonoffset", "0", "nudges brush polygon depth in hardware depth units, used to make collision brushes appear infront of walls"};
92 cvar_t r_showdisabledepthtest = {0, "r_showdisabledepthtest", "0", "disables depth testing on r_show* cvars, allowing you to see what hidden geometry the graphics card is processing"};
93 cvar_t r_drawportals = {0, "r_drawportals", "0", "shows portals (separating polygons) in world interior in quake1 maps"};
94 cvar_t r_drawentities = {0, "r_drawentities","1", "draw entities (doors, players, projectiles, etc)"};
95 cvar_t r_draw2d = {0, "r_draw2d","1", "draw 2D stuff (dangerous to turn off)"};
96 cvar_t r_drawworld = {0, "r_drawworld","1", "draw world (most static stuff)"};
97 cvar_t r_drawviewmodel = {0, "r_drawviewmodel","1", "draw your weapon model"};
98 cvar_t r_drawexteriormodel = {0, "r_drawexteriormodel","1", "draw your player model (e.g. in chase cam, reflections)"};
99 cvar_t r_cullentities_trace = {0, "r_cullentities_trace", "1", "probabistically cull invisible entities"};
100 cvar_t r_cullentities_trace_samples = {0, "r_cullentities_trace_samples", "2", "number of samples to test for entity culling (in addition to center sample)"};
101 cvar_t r_cullentities_trace_tempentitysamples = {0, "r_cullentities_trace_tempentitysamples", "-1", "number of samples to test for entity culling of temp entities (including all CSQC entities), -1 disables trace culling on these entities to prevent flicker (pvs still applies)"};
102 cvar_t r_cullentities_trace_enlarge = {0, "r_cullentities_trace_enlarge", "0", "box enlargement for entity culling"};
103 cvar_t r_cullentities_trace_delay = {0, "r_cullentities_trace_delay", "1", "number of seconds until the entity gets actually culled"};
104 cvar_t r_sortentities = {0, "r_sortentities", "0", "sort entities before drawing (might be faster)"};
105 cvar_t r_speeds = {0, "r_speeds","0", "displays rendering statistics and per-subsystem timings"};
106 cvar_t r_fullbright = {0, "r_fullbright","0", "makes map very bright and renders faster"};
108 cvar_t r_fakelight = {0, "r_fakelight","0", "render 'fake' lighting instead of real lightmaps"};
109 cvar_t r_fakelight_intensity = {0, "r_fakelight_intensity","0.75", "fakelight intensity modifier"};
110 #define FAKELIGHT_ENABLED (r_fakelight.integer >= 2 || (r_fakelight.integer && r_refdef.scene.worldmodel && !r_refdef.scene.worldmodel->lit))
112 cvar_t r_wateralpha = {CVAR_SAVE, "r_wateralpha","1", "opacity of water polygons"};
113 cvar_t r_dynamic = {CVAR_SAVE, "r_dynamic","1", "enables dynamic lights (rocket glow and such)"};
114 cvar_t r_fullbrights = {CVAR_SAVE, "r_fullbrights", "1", "enables glowing pixels in quake textures (changes need r_restart to take effect)"};
115 cvar_t r_shadows = {CVAR_SAVE, "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."};
116 cvar_t r_shadows_darken = {CVAR_SAVE, "r_shadows_darken", "0.5", "how much shadowed areas will be darkened"};
117 cvar_t r_shadows_throwdistance = {CVAR_SAVE, "r_shadows_throwdistance", "500", "how far to cast shadows from models"};
118 cvar_t r_shadows_throwdirection = {CVAR_SAVE, "r_shadows_throwdirection", "0 0 -1", "override throwing direction for r_shadows 2"};
119 cvar_t r_shadows_drawafterrtlighting = {CVAR_SAVE, "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."};
120 cvar_t r_shadows_castfrombmodels = {CVAR_SAVE, "r_shadows_castfrombmodels", "0", "do cast shadows from bmodels"};
121 cvar_t r_shadows_focus = {CVAR_SAVE, "r_shadows_focus", "0 0 0", "offset the shadowed area focus"};
122 cvar_t r_shadows_shadowmapscale = {CVAR_SAVE, "r_shadows_shadowmapscale", "1", "increases shadowmap quality (multiply global shadowmap precision) for fake shadows. Needs shadowmapping ON."};
123 cvar_t r_q1bsp_skymasking = {0, "r_q1bsp_skymasking", "1", "allows sky polygons in quake1 maps to obscure other geometry"};
124 cvar_t r_polygonoffset_submodel_factor = {0, "r_polygonoffset_submodel_factor", "0", "biases depth values of world submodels such as doors, to prevent z-fighting artifacts in Quake maps"};
125 cvar_t r_polygonoffset_submodel_offset = {0, "r_polygonoffset_submodel_offset", "14", "biases depth values of world submodels such as doors, to prevent z-fighting artifacts in Quake maps"};
126 cvar_t r_polygonoffset_decals_factor = {0, "r_polygonoffset_decals_factor", "0", "biases depth values of decals to prevent z-fighting artifacts"};
127 cvar_t r_polygonoffset_decals_offset = {0, "r_polygonoffset_decals_offset", "-14", "biases depth values of decals to prevent z-fighting artifacts"};
128 cvar_t r_fog_exp2 = {0, "r_fog_exp2", "0", "uses GL_EXP2 fog (as in Nehahra) rather than realistic GL_EXP fog"};
129 cvar_t r_fog_clear = {0, "r_fog_clear", "1", "clears renderbuffer with fog color before render starts"};
130 cvar_t r_drawfog = {CVAR_SAVE, "r_drawfog", "1", "allows one to disable fog rendering"};
131 cvar_t r_transparentdepthmasking = {CVAR_SAVE, "r_transparentdepthmasking", "0", "enables depth writes on transparent meshes whose materially is normally opaque, this prevents seeing the inside of a transparent mesh"};
132 cvar_t r_transparent_sortmindist = {CVAR_SAVE, "r_transparent_sortmindist", "0", "lower distance limit for transparent sorting"};
133 cvar_t r_transparent_sortmaxdist = {CVAR_SAVE, "r_transparent_sortmaxdist", "32768", "upper distance limit for transparent sorting"};
134 cvar_t r_transparent_sortarraysize = {CVAR_SAVE, "r_transparent_sortarraysize", "4096", "number of distance-sorting layers"};
135 cvar_t r_celshading = {CVAR_SAVE, "r_celshading", "0", "cartoon-style light shading"};
136 cvar_t r_celoutlines = {CVAR_SAVE, "r_celoutlines", "0", "cartoon-style outlines (requires r_shadow_deferred)"};
138 cvar_t gl_fogenable = {0, "gl_fogenable", "0", "nehahra fog enable (for Nehahra compatibility only)"};
139 cvar_t gl_fogdensity = {0, "gl_fogdensity", "0.25", "nehahra fog density (recommend values below 0.1) (for Nehahra compatibility only)"};
140 cvar_t gl_fogred = {0, "gl_fogred","0.3", "nehahra fog color red value (for Nehahra compatibility only)"};
141 cvar_t gl_foggreen = {0, "gl_foggreen","0.3", "nehahra fog color green value (for Nehahra compatibility only)"};
142 cvar_t gl_fogblue = {0, "gl_fogblue","0.3", "nehahra fog color blue value (for Nehahra compatibility only)"};
143 cvar_t gl_fogstart = {0, "gl_fogstart", "0", "nehahra fog start distance (for Nehahra compatibility only)"};
144 cvar_t gl_fogend = {0, "gl_fogend","0", "nehahra fog end distance (for Nehahra compatibility only)"};
145 cvar_t gl_skyclip = {0, "gl_skyclip", "4608", "nehahra farclip distance - the real fog end (for Nehahra compatibility only)"};
147 cvar_t r_texture_dds_load = {CVAR_SAVE, "r_texture_dds_load", "0", "load compressed dds/filename.dds texture instead of filename.tga, if the file exists (requires driver support)"};
148 cvar_t r_texture_dds_save = {CVAR_SAVE, "r_texture_dds_save", "0", "save compressed dds/filename.dds texture when filename.tga is loaded, so that it can be loaded instead next time"};
150 cvar_t r_textureunits = {0, "r_textureunits", "32", "number of texture units to use in GL 1.1 and GL 1.3 rendering paths"};
151 static cvar_t gl_combine = {CVAR_READONLY, "gl_combine", "1", "indicates whether the OpenGL 1.3 rendering path is active"};
152 static cvar_t r_glsl = {CVAR_READONLY, "r_glsl", "1", "indicates whether the OpenGL 2.0 rendering path is active"};
154 cvar_t r_usedepthtextures = {CVAR_SAVE, "r_usedepthtextures", "1", "use depth texture instead of depth renderbuffer where possible, uses less video memory but may render slower (or faster) depending on hardware"};
155 cvar_t r_viewfbo = {CVAR_SAVE, "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"};
156 cvar_t r_viewscale = {CVAR_SAVE, "r_viewscale", "1", "scaling factor for resolution of the fbo rendering method, must be > 0, can be above 1 for a costly antialiasing behavior, typical values are 0.5 for 1/4th as many pixels rendered, or 1 for normal rendering"};
157 cvar_t r_viewscale_fpsscaling = {CVAR_SAVE, "r_viewscale_fpsscaling", "0", "change resolution based on framerate"};
158 cvar_t r_viewscale_fpsscaling_min = {CVAR_SAVE, "r_viewscale_fpsscaling_min", "0.0625", "worst acceptable quality"};
159 cvar_t r_viewscale_fpsscaling_multiply = {CVAR_SAVE, "r_viewscale_fpsscaling_multiply", "5", "adjust quality up or down by the frametime difference from 1.0/target, multiplied by this factor"};
160 cvar_t r_viewscale_fpsscaling_stepsize = {CVAR_SAVE, "r_viewscale_fpsscaling_stepsize", "0.01", "smallest adjustment to hit the target framerate (this value prevents minute oscillations)"};
161 cvar_t r_viewscale_fpsscaling_stepmax = {CVAR_SAVE, "r_viewscale_fpsscaling_stepmax", "1.00", "largest adjustment to hit the target framerate (this value prevents wild overshooting of the estimate)"};
162 cvar_t r_viewscale_fpsscaling_target = {CVAR_SAVE, "r_viewscale_fpsscaling_target", "70", "desired framerate"};
164 cvar_t r_glsl_deluxemapping = {CVAR_SAVE, "r_glsl_deluxemapping", "1", "use per pixel lighting on deluxemap-compiled q3bsp maps (or a value of 2 forces deluxemap shading even without deluxemaps)"};
165 cvar_t r_glsl_offsetmapping = {CVAR_SAVE, "r_glsl_offsetmapping", "0", "offset mapping effect (also known as parallax mapping or virtual displacement mapping)"};
166 cvar_t r_glsl_offsetmapping_steps = {CVAR_SAVE, "r_glsl_offsetmapping_steps", "2", "offset mapping steps (note: too high values may be not supported by your GPU)"};
167 cvar_t r_glsl_offsetmapping_reliefmapping = {CVAR_SAVE, "r_glsl_offsetmapping_reliefmapping", "0", "relief mapping effect (higher quality)"};
168 cvar_t r_glsl_offsetmapping_reliefmapping_steps = {CVAR_SAVE, "r_glsl_offsetmapping_reliefmapping_steps", "10", "relief mapping steps (note: too high values may be not supported by your GPU)"};
169 cvar_t r_glsl_offsetmapping_reliefmapping_refinesteps = {CVAR_SAVE, "r_glsl_offsetmapping_reliefmapping_refinesteps", "5", "relief mapping refine steps (these are a binary search executed as the last step as given by r_glsl_offsetmapping_reliefmapping_steps)"};
170 cvar_t r_glsl_offsetmapping_scale = {CVAR_SAVE, "r_glsl_offsetmapping_scale", "0.04", "how deep the offset mapping effect is"};
171 cvar_t r_glsl_offsetmapping_lod = {CVAR_SAVE, "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"};
172 cvar_t r_glsl_offsetmapping_lod_distance = {CVAR_SAVE, "r_glsl_offsetmapping_lod_distance", "32", "first LOD level distance, second level (-50% steps) is 2x of this, third (33%) - 3x etc."};
173 cvar_t r_glsl_postprocess = {CVAR_SAVE, "r_glsl_postprocess", "0", "use a GLSL postprocessing shader"};
174 cvar_t r_glsl_postprocess_uservec1 = {CVAR_SAVE, "r_glsl_postprocess_uservec1", "0 0 0 0", "a 4-component vector to pass as uservec1 to the postprocessing shader (only useful if default.glsl has been customized)"};
175 cvar_t r_glsl_postprocess_uservec2 = {CVAR_SAVE, "r_glsl_postprocess_uservec2", "0 0 0 0", "a 4-component vector to pass as uservec2 to the postprocessing shader (only useful if default.glsl has been customized)"};
176 cvar_t r_glsl_postprocess_uservec3 = {CVAR_SAVE, "r_glsl_postprocess_uservec3", "0 0 0 0", "a 4-component vector to pass as uservec3 to the postprocessing shader (only useful if default.glsl has been customized)"};
177 cvar_t r_glsl_postprocess_uservec4 = {CVAR_SAVE, "r_glsl_postprocess_uservec4", "0 0 0 0", "a 4-component vector to pass as uservec4 to the postprocessing shader (only useful if default.glsl has been customized)"};
178 cvar_t r_glsl_postprocess_uservec1_enable = {CVAR_SAVE, "r_glsl_postprocess_uservec1_enable", "1", "enables postprocessing uservec1 usage, creates USERVEC1 define (only useful if default.glsl has been customized)"};
179 cvar_t r_glsl_postprocess_uservec2_enable = {CVAR_SAVE, "r_glsl_postprocess_uservec2_enable", "1", "enables postprocessing uservec2 usage, creates USERVEC1 define (only useful if default.glsl has been customized)"};
180 cvar_t r_glsl_postprocess_uservec3_enable = {CVAR_SAVE, "r_glsl_postprocess_uservec3_enable", "1", "enables postprocessing uservec3 usage, creates USERVEC1 define (only useful if default.glsl has been customized)"};
181 cvar_t r_glsl_postprocess_uservec4_enable = {CVAR_SAVE, "r_glsl_postprocess_uservec4_enable", "1", "enables postprocessing uservec4 usage, creates USERVEC1 define (only useful if default.glsl has been customized)"};
183 cvar_t r_water = {CVAR_SAVE, "r_water", "0", "whether to use reflections and refraction on water surfaces (note: r_wateralpha must be set below 1)"};
184 cvar_t r_water_clippingplanebias = {CVAR_SAVE, "r_water_clippingplanebias", "1", "a rather technical setting which avoids black pixels around water edges"};
185 cvar_t r_water_resolutionmultiplier = {CVAR_SAVE, "r_water_resolutionmultiplier", "0.5", "multiplier for screen resolution when rendering refracted/reflected scenes, 1 is full quality, lower values are faster"};
186 cvar_t r_water_refractdistort = {CVAR_SAVE, "r_water_refractdistort", "0.01", "how much water refractions shimmer"};
187 cvar_t r_water_reflectdistort = {CVAR_SAVE, "r_water_reflectdistort", "0.01", "how much water reflections shimmer"};
188 cvar_t r_water_scissormode = {0, "r_water_scissormode", "3", "scissor (1) or cull (2) or both (3) water renders"};
189 cvar_t r_water_lowquality = {0, "r_water_lowquality", "0", "special option to accelerate water rendering, 1 disables shadows and particles, 2 disables all dynamic lights"};
190 cvar_t r_water_hideplayer = {CVAR_SAVE, "r_water_hideplayer", "0", "if set to 1 then player will be hidden in refraction views, if set to 2 then player will also be hidden in reflection views, player is always visible in camera views"};
191 cvar_t r_water_fbo = {CVAR_SAVE, "r_water_fbo", "1", "enables use of render to texture for water effects, otherwise copy to texture is used (slower)"};
193 cvar_t r_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "0", "enables animation smoothing on sprites"};
194 cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1", "enables animation smoothing on models"};
195 cvar_t r_lerplightstyles = {CVAR_SAVE, "r_lerplightstyles", "0", "enable animation smoothing on flickering lights"};
196 cvar_t r_waterscroll = {CVAR_SAVE, "r_waterscroll", "1", "makes water scroll around, value controls how much"};
198 cvar_t r_bloom = {CVAR_SAVE, "r_bloom", "0", "enables bloom effect (makes bright pixels affect neighboring pixels)"};
199 cvar_t r_bloom_colorscale = {CVAR_SAVE, "r_bloom_colorscale", "1", "how bright the glow is"};
201 cvar_t r_bloom_brighten = {CVAR_SAVE, "r_bloom_brighten", "2", "how bright the glow is, after subtract/power"};
202 cvar_t r_bloom_blur = {CVAR_SAVE, "r_bloom_blur", "4", "how large the glow is"};
203 cvar_t r_bloom_resolution = {CVAR_SAVE, "r_bloom_resolution", "320", "what resolution to perform the bloom effect at (independent of screen resolution)"};
204 cvar_t r_bloom_colorexponent = {CVAR_SAVE, "r_bloom_colorexponent", "1", "how exaggerated the glow is"};
205 cvar_t r_bloom_colorsubtract = {CVAR_SAVE, "r_bloom_colorsubtract", "0.125", "reduces bloom colors by a certain amount"};
207 cvar_t r_hdr_scenebrightness = {CVAR_SAVE, "r_hdr_scenebrightness", "1", "global rendering brightness"};
208 cvar_t r_hdr_glowintensity = {CVAR_SAVE, "r_hdr_glowintensity", "1", "how bright light emitting textures should appear"};
209 cvar_t r_hdr_irisadaptation = {CVAR_SAVE, "r_hdr_irisadaptation", "0", "adjust scene brightness according to light intensity at player location"};
210 cvar_t r_hdr_irisadaptation_multiplier = {CVAR_SAVE, "r_hdr_irisadaptation_multiplier", "2", "brightness at which value will be 1.0"};
211 cvar_t r_hdr_irisadaptation_minvalue = {CVAR_SAVE, "r_hdr_irisadaptation_minvalue", "0.5", "minimum value that can result from multiplier / brightness"};
212 cvar_t r_hdr_irisadaptation_maxvalue = {CVAR_SAVE, "r_hdr_irisadaptation_maxvalue", "4", "maximum value that can result from multiplier / brightness"};
213 cvar_t r_hdr_irisadaptation_value = {0, "r_hdr_irisadaptation_value", "1", "current value as scenebrightness multiplier, changes continuously when irisadaptation is active"};
214 cvar_t r_hdr_irisadaptation_fade_up = {CVAR_SAVE, "r_hdr_irisadaptation_fade_up", "0.1", "fade rate at which value adjusts to darkness"};
215 cvar_t r_hdr_irisadaptation_fade_down = {CVAR_SAVE, "r_hdr_irisadaptation_fade_down", "0.5", "fade rate at which value adjusts to brightness"};
216 cvar_t r_hdr_irisadaptation_radius = {CVAR_SAVE, "r_hdr_irisadaptation_radius", "15", "lighting within this many units of the eye is averaged"};
218 cvar_t r_smoothnormals_areaweighting = {0, "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"};
220 cvar_t developer_texturelogging = {0, "developer_texturelogging", "0", "produces a textures.log file containing names of skins and map textures the engine tried to load"};
222 cvar_t gl_lightmaps = {0, "gl_lightmaps", "0", "draws only lightmaps, no texture (for level designers)"};
224 cvar_t r_test = {0, "r_test", "0", "internal development use only, leave it alone (usually does nothing anyway)"};
226 cvar_t r_glsl_saturation = {CVAR_SAVE, "r_glsl_saturation", "1", "saturation multiplier (only working in glsl!)"};
227 cvar_t r_glsl_saturation_redcompensate = {CVAR_SAVE, "r_glsl_saturation_redcompensate", "0", "a 'vampire sight' addition to desaturation effect, does compensation for red color, r_glsl_restart is required"};
229 cvar_t r_glsl_vertextextureblend_usebothalphas = {CVAR_SAVE, "r_glsl_vertextextureblend_usebothalphas", "0", "use both alpha layers on vertex blended surfaces, each alpha layer sets amount of 'blend leak' on another layer."};
231 cvar_t r_framedatasize = {CVAR_SAVE, "r_framedatasize", "0.5", "size of renderer data cache used during one frame (for skeletal animation caching, light processing, etc)"};
233 extern cvar_t v_glslgamma;
234 extern cvar_t v_glslgamma_2d;
236 extern qboolean v_flipped_state;
238 r_framebufferstate_t r_fb;
240 /// shadow volume bsp struct with automatically growing nodes buffer
243 rtexture_t *r_texture_blanknormalmap;
244 rtexture_t *r_texture_white;
245 rtexture_t *r_texture_grey128;
246 rtexture_t *r_texture_black;
247 rtexture_t *r_texture_notexture;
248 rtexture_t *r_texture_whitecube;
249 rtexture_t *r_texture_normalizationcube;
250 rtexture_t *r_texture_fogattenuation;
251 rtexture_t *r_texture_fogheighttexture;
252 rtexture_t *r_texture_gammaramps;
253 unsigned int r_texture_gammaramps_serial;
254 //rtexture_t *r_texture_fogintensity;
255 rtexture_t *r_texture_reflectcube;
257 // TODO: hash lookups?
258 typedef struct cubemapinfo_s
265 int r_texture_numcubemaps;
266 cubemapinfo_t *r_texture_cubemaps[MAX_CUBEMAPS];
268 unsigned int r_queries[MAX_OCCLUSION_QUERIES];
269 unsigned int r_numqueries;
270 unsigned int r_maxqueries;
272 typedef struct r_qwskincache_s
274 char name[MAX_QPATH];
275 skinframe_t *skinframe;
279 static r_qwskincache_t *r_qwskincache;
280 static int r_qwskincache_size;
282 /// vertex coordinates for a quad that covers the screen exactly
283 extern const float r_screenvertex3f[12];
284 extern const float r_d3dscreenvertex3f[12];
285 const float r_screenvertex3f[12] =
292 const float r_d3dscreenvertex3f[12] =
300 void R_ModulateColors(float *in, float *out, int verts, float r, float g, float b)
303 for (i = 0;i < verts;i++)
314 void R_FillColors(float *out, int verts, float r, float g, float b, float a)
317 for (i = 0;i < verts;i++)
327 // FIXME: move this to client?
330 if (gamemode == GAME_NEHAHRA)
332 Cvar_Set("gl_fogenable", "0");
333 Cvar_Set("gl_fogdensity", "0.2");
334 Cvar_Set("gl_fogred", "0.3");
335 Cvar_Set("gl_foggreen", "0.3");
336 Cvar_Set("gl_fogblue", "0.3");
338 r_refdef.fog_density = 0;
339 r_refdef.fog_red = 0;
340 r_refdef.fog_green = 0;
341 r_refdef.fog_blue = 0;
342 r_refdef.fog_alpha = 1;
343 r_refdef.fog_start = 0;
344 r_refdef.fog_end = 16384;
345 r_refdef.fog_height = 1<<30;
346 r_refdef.fog_fadedepth = 128;
347 memset(r_refdef.fog_height_texturename, 0, sizeof(r_refdef.fog_height_texturename));
350 static void R_BuildBlankTextures(void)
352 unsigned char data[4];
353 data[2] = 128; // normal X
354 data[1] = 128; // normal Y
355 data[0] = 255; // normal Z
356 data[3] = 255; // height
357 r_texture_blanknormalmap = R_LoadTexture2D(r_main_texturepool, "blankbump", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, -1, NULL);
362 r_texture_white = R_LoadTexture2D(r_main_texturepool, "blankwhite", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, -1, NULL);
367 r_texture_grey128 = R_LoadTexture2D(r_main_texturepool, "blankgrey128", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, -1, NULL);
372 r_texture_black = R_LoadTexture2D(r_main_texturepool, "blankblack", 1, 1, data, TEXTYPE_BGRA, TEXF_PERSISTENT, -1, NULL);
375 static void R_BuildNoTexture(void)
378 unsigned char pix[16][16][4];
379 // this makes a light grey/dark grey checkerboard texture
380 for (y = 0;y < 16;y++)
382 for (x = 0;x < 16;x++)
384 if ((y < 8) ^ (x < 8))
400 r_texture_notexture = R_LoadTexture2D(r_main_texturepool, "notexture", 16, 16, &pix[0][0][0], TEXTYPE_BGRA, TEXF_MIPMAP | TEXF_PERSISTENT, -1, NULL);
403 static void R_BuildWhiteCube(void)
405 unsigned char data[6*1*1*4];
406 memset(data, 255, sizeof(data));
407 r_texture_whitecube = R_LoadTextureCubeMap(r_main_texturepool, "whitecube", 1, data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_PERSISTENT, -1, NULL);
410 static void R_BuildNormalizationCube(void)
414 vec_t s, t, intensity;
417 data = (unsigned char *)Mem_Alloc(tempmempool, 6*NORMSIZE*NORMSIZE*4);
418 for (side = 0;side < 6;side++)
420 for (y = 0;y < NORMSIZE;y++)
422 for (x = 0;x < NORMSIZE;x++)
424 s = (x + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
425 t = (y + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
460 intensity = 127.0f / sqrt(DotProduct(v, v));
461 data[((side*64+y)*64+x)*4+2] = (unsigned char)(128.0f + intensity * v[0]);
462 data[((side*64+y)*64+x)*4+1] = (unsigned char)(128.0f + intensity * v[1]);
463 data[((side*64+y)*64+x)*4+0] = (unsigned char)(128.0f + intensity * v[2]);
464 data[((side*64+y)*64+x)*4+3] = 255;
468 r_texture_normalizationcube = R_LoadTextureCubeMap(r_main_texturepool, "normalcube", NORMSIZE, data, TEXTYPE_BGRA, TEXF_CLAMP | TEXF_PERSISTENT, -1, NULL);
472 static void R_BuildFogTexture(void)
476 unsigned char data1[FOGWIDTH][4];
477 //unsigned char data2[FOGWIDTH][4];
480 r_refdef.fogmasktable_start = r_refdef.fog_start;
481 r_refdef.fogmasktable_alpha = r_refdef.fog_alpha;
482 r_refdef.fogmasktable_range = r_refdef.fogrange;
483 r_refdef.fogmasktable_density = r_refdef.fog_density;
485 r = r_refdef.fogmasktable_range / FOGMASKTABLEWIDTH;
486 for (x = 0;x < FOGMASKTABLEWIDTH;x++)
488 d = (x * r - r_refdef.fogmasktable_start);
489 if(developer_extra.integer)
490 Con_DPrintf("%f ", d);
492 if (r_fog_exp2.integer)
493 alpha = exp(-r_refdef.fogmasktable_density * r_refdef.fogmasktable_density * 0.0001 * d * d);
495 alpha = exp(-r_refdef.fogmasktable_density * 0.004 * d);
496 if(developer_extra.integer)
497 Con_DPrintf(" : %f ", alpha);
498 alpha = 1 - (1 - alpha) * r_refdef.fogmasktable_alpha;
499 if(developer_extra.integer)
500 Con_DPrintf(" = %f\n", alpha);
501 r_refdef.fogmasktable[x] = bound(0, alpha, 1);
504 for (x = 0;x < FOGWIDTH;x++)
506 b = (int)(r_refdef.fogmasktable[x * (FOGMASKTABLEWIDTH - 1) / (FOGWIDTH - 1)] * 255);
511 //data2[x][0] = 255 - b;
512 //data2[x][1] = 255 - b;
513 //data2[x][2] = 255 - b;
516 if (r_texture_fogattenuation)
518 R_UpdateTexture(r_texture_fogattenuation, &data1[0][0], 0, 0, 0, FOGWIDTH, 1, 1);
519 //R_UpdateTexture(r_texture_fogattenuation, &data2[0][0], 0, 0, 0, FOGWIDTH, 1, 1);
523 r_texture_fogattenuation = R_LoadTexture2D(r_main_texturepool, "fogattenuation", FOGWIDTH, 1, &data1[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT, -1, NULL);
524 //r_texture_fogintensity = R_LoadTexture2D(r_main_texturepool, "fogintensity", FOGWIDTH, 1, &data2[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP, NULL);
528 static void R_BuildFogHeightTexture(void)
530 unsigned char *inpixels;
538 strlcpy(r_refdef.fogheighttexturename, r_refdef.fog_height_texturename, sizeof(r_refdef.fogheighttexturename));
539 if (r_refdef.fogheighttexturename[0])
540 inpixels = loadimagepixelsbgra(r_refdef.fogheighttexturename, true, false, false, NULL);
543 r_refdef.fog_height_tablesize = 0;
544 if (r_texture_fogheighttexture)
545 R_FreeTexture(r_texture_fogheighttexture);
546 r_texture_fogheighttexture = NULL;
547 if (r_refdef.fog_height_table2d)
548 Mem_Free(r_refdef.fog_height_table2d);
549 r_refdef.fog_height_table2d = NULL;
550 if (r_refdef.fog_height_table1d)
551 Mem_Free(r_refdef.fog_height_table1d);
552 r_refdef.fog_height_table1d = NULL;
556 r_refdef.fog_height_tablesize = size;
557 r_refdef.fog_height_table1d = (unsigned char *)Mem_Alloc(r_main_mempool, size * 4);
558 r_refdef.fog_height_table2d = (unsigned char *)Mem_Alloc(r_main_mempool, size * size * 4);
559 memcpy(r_refdef.fog_height_table1d, inpixels, size * 4);
561 // LordHavoc: now the magic - what is that table2d for? it is a cooked
562 // average fog color table accounting for every fog layer between a point
563 // and the camera. (Note: attenuation is handled separately!)
564 for (y = 0;y < size;y++)
566 for (x = 0;x < size;x++)
572 for (j = x;j <= y;j++)
574 Vector4Add(c, r_refdef.fog_height_table1d + j*4, c);
580 for (j = x;j >= y;j--)
582 Vector4Add(c, r_refdef.fog_height_table1d + j*4, c);
587 r_refdef.fog_height_table2d[(y*size+x)*4+0] = (unsigned char)(c[0] * f);
588 r_refdef.fog_height_table2d[(y*size+x)*4+1] = (unsigned char)(c[1] * f);
589 r_refdef.fog_height_table2d[(y*size+x)*4+2] = (unsigned char)(c[2] * f);
590 r_refdef.fog_height_table2d[(y*size+x)*4+3] = (unsigned char)(c[3] * f);
593 r_texture_fogheighttexture = R_LoadTexture2D(r_main_texturepool, "fogheighttable", size, size, r_refdef.fog_height_table2d, TEXTYPE_BGRA, TEXF_ALPHA | TEXF_CLAMP, -1, NULL);
596 //=======================================================================================================================================================
598 static const char *builtinshaderstring =
599 #include "shader_glsl.h"
602 const char *builtinhlslshaderstring =
603 #include "shader_hlsl.h"
606 char *glslshaderstring = NULL;
607 char *hlslshaderstring = NULL;
609 //=======================================================================================================================================================
611 typedef struct shaderpermutationinfo_s
616 shaderpermutationinfo_t;
618 typedef struct shadermodeinfo_s
620 const char *vertexfilename;
621 const char *geometryfilename;
622 const char *fragmentfilename;
628 // NOTE: MUST MATCH ORDER OF SHADERPERMUTATION_* DEFINES!
629 shaderpermutationinfo_t shaderpermutationinfo[SHADERPERMUTATION_COUNT] =
631 {"#define USEDIFFUSE\n", " diffuse"},
632 {"#define USEVERTEXTEXTUREBLEND\n", " vertextextureblend"},
633 {"#define USEVIEWTINT\n", " viewtint"},
634 {"#define USECOLORMAPPING\n", " colormapping"},
635 {"#define USESATURATION\n", " saturation"},
636 {"#define USEFOGINSIDE\n", " foginside"},
637 {"#define USEFOGOUTSIDE\n", " fogoutside"},
638 {"#define USEFOGHEIGHTTEXTURE\n", " fogheighttexture"},
639 {"#define USEFOGALPHAHACK\n", " fogalphahack"},
640 {"#define USEGAMMARAMPS\n", " gammaramps"},
641 {"#define USECUBEFILTER\n", " cubefilter"},
642 {"#define USEGLOW\n", " glow"},
643 {"#define USEBLOOM\n", " bloom"},
644 {"#define USESPECULAR\n", " specular"},
645 {"#define USEPOSTPROCESSING\n", " postprocessing"},
646 {"#define USEREFLECTION\n", " reflection"},
647 {"#define USEOFFSETMAPPING\n", " offsetmapping"},
648 {"#define USEOFFSETMAPPING_RELIEFMAPPING\n", " reliefmapping"},
649 {"#define USESHADOWMAP2D\n", " shadowmap2d"},
650 {"#define USESHADOWMAPVSDCT\n", " shadowmapvsdct"}, // TODO make this a static parm
651 {"#define USESHADOWMAPORTHO\n", " shadowmaportho"},
652 {"#define USEDEFERREDLIGHTMAP\n", " deferredlightmap"},
653 {"#define USEALPHAKILL\n", " alphakill"},
654 {"#define USEREFLECTCUBE\n", " reflectcube"},
655 {"#define USENORMALMAPSCROLLBLEND\n", " normalmapscrollblend"},
656 {"#define USEBOUNCEGRID\n", " bouncegrid"},
657 {"#define USEBOUNCEGRIDDIRECTIONAL\n", " bouncegriddirectional"}, // TODO make this a static parm
658 {"#define USETRIPPY\n", " trippy"},
659 {"#define USEDEPTHRGB\n", " depthrgb"},
660 {"#define USEALPHAGENVERTEX\n", "alphagenvertex"}
663 // NOTE: MUST MATCH ORDER OF SHADERMODE_* ENUMS!
664 shadermodeinfo_t glslshadermodeinfo[SHADERMODE_COUNT] =
666 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_GENERIC\n", " generic"},
667 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_POSTPROCESS\n", " postprocess"},
668 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_DEPTH_OR_SHADOW\n", " depth/shadow"},
669 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_FLATCOLOR\n", " flatcolor"},
670 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_VERTEXCOLOR\n", " vertexcolor"},
671 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTMAP\n", " lightmap"},
672 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_FAKELIGHT\n", " fakelight"},
673 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
674 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
675 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTIONMAP_FORCED_LIGHTMAP\n", " lightdirectionmap_forced_lightmap"},
676 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTIONMAP_FORCED_VERTEXCOLOR\n", " lightdirectionmap_forced_vertexcolor"},
677 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTDIRECTION\n", " lightdirection"},
678 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_LIGHTSOURCE\n", " lightsource"},
679 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_REFRACTION\n", " refraction"},
680 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_WATER\n", " water"},
681 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_SHOWDEPTH\n", " showdepth"},
682 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_DEFERREDGEOMETRY\n", " deferredgeometry"},
683 {"glsl/default.glsl", NULL, "glsl/default.glsl", "#define MODE_DEFERREDLIGHTSOURCE\n", " deferredlightsource"},
686 shadermodeinfo_t hlslshadermodeinfo[SHADERMODE_COUNT] =
688 {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_GENERIC\n", " generic"},
689 {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_POSTPROCESS\n", " postprocess"},
690 {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_DEPTH_OR_SHADOW\n", " depth/shadow"},
691 {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_FLATCOLOR\n", " flatcolor"},
692 {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_VERTEXCOLOR\n", " vertexcolor"},
693 {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_LIGHTMAP\n", " lightmap"},
694 {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_FAKELIGHT\n", " fakelight"},
695 {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_LIGHTDIRECTIONMAP_MODELSPACE\n", " lightdirectionmap_modelspace"},
696 {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_LIGHTDIRECTIONMAP_TANGENTSPACE\n", " lightdirectionmap_tangentspace"},
697 {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_LIGHTDIRECTIONMAP_FORCED_LIGHTMAP\n", " lightdirectionmap_forced_lightmap"},
698 {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_LIGHTDIRECTIONMAP_FORCED_VERTEXCOLOR\n", " lightdirectionmap_forced_vertexcolor"},
699 {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_LIGHTDIRECTION\n", " lightdirection"},
700 {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_LIGHTSOURCE\n", " lightsource"},
701 {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_REFRACTION\n", " refraction"},
702 {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_WATER\n", " water"},
703 {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_SHOWDEPTH\n", " showdepth"},
704 {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_DEFERREDGEOMETRY\n", " deferredgeometry"},
705 {"hlsl/default.hlsl", NULL, "hlsl/default.hlsl", "#define MODE_DEFERREDLIGHTSOURCE\n", " deferredlightsource"},
708 struct r_glsl_permutation_s;
709 typedef struct r_glsl_permutation_s
712 struct r_glsl_permutation_s *hashnext;
714 unsigned int permutation;
716 /// indicates if we have tried compiling this permutation already
718 /// 0 if compilation failed
720 // texture units assigned to each detected uniform
721 int tex_Texture_First;
722 int tex_Texture_Second;
723 int tex_Texture_GammaRamps;
724 int tex_Texture_Normal;
725 int tex_Texture_Color;
726 int tex_Texture_Gloss;
727 int tex_Texture_Glow;
728 int tex_Texture_SecondaryNormal;
729 int tex_Texture_SecondaryColor;
730 int tex_Texture_SecondaryGloss;
731 int tex_Texture_SecondaryGlow;
732 int tex_Texture_Pants;
733 int tex_Texture_Shirt;
734 int tex_Texture_FogHeightTexture;
735 int tex_Texture_FogMask;
736 int tex_Texture_Lightmap;
737 int tex_Texture_Deluxemap;
738 int tex_Texture_Attenuation;
739 int tex_Texture_Cube;
740 int tex_Texture_Refraction;
741 int tex_Texture_Reflection;
742 int tex_Texture_ShadowMap2D;
743 int tex_Texture_CubeProjection;
744 int tex_Texture_ScreenNormalMap;
745 int tex_Texture_ScreenDiffuse;
746 int tex_Texture_ScreenSpecular;
747 int tex_Texture_ReflectMask;
748 int tex_Texture_ReflectCube;
749 int tex_Texture_BounceGrid;
750 /// locations of detected uniforms in program object, or -1 if not found
751 int loc_Texture_First;
752 int loc_Texture_Second;
753 int loc_Texture_GammaRamps;
754 int loc_Texture_Normal;
755 int loc_Texture_Color;
756 int loc_Texture_Gloss;
757 int loc_Texture_Glow;
758 int loc_Texture_SecondaryNormal;
759 int loc_Texture_SecondaryColor;
760 int loc_Texture_SecondaryGloss;
761 int loc_Texture_SecondaryGlow;
762 int loc_Texture_Pants;
763 int loc_Texture_Shirt;
764 int loc_Texture_FogHeightTexture;
765 int loc_Texture_FogMask;
766 int loc_Texture_Lightmap;
767 int loc_Texture_Deluxemap;
768 int loc_Texture_Attenuation;
769 int loc_Texture_Cube;
770 int loc_Texture_Refraction;
771 int loc_Texture_Reflection;
772 int loc_Texture_ShadowMap2D;
773 int loc_Texture_CubeProjection;
774 int loc_Texture_ScreenNormalMap;
775 int loc_Texture_ScreenDiffuse;
776 int loc_Texture_ScreenSpecular;
777 int loc_Texture_ReflectMask;
778 int loc_Texture_ReflectCube;
779 int loc_Texture_BounceGrid;
781 int loc_BloomBlur_Parameters;
783 int loc_Color_Ambient;
784 int loc_Color_Diffuse;
785 int loc_Color_Specular;
789 int loc_DeferredColor_Ambient;
790 int loc_DeferredColor_Diffuse;
791 int loc_DeferredColor_Specular;
792 int loc_DeferredMod_Diffuse;
793 int loc_DeferredMod_Specular;
794 int loc_DistortScaleRefractReflect;
797 int loc_FogHeightFade;
799 int loc_FogPlaneViewDist;
800 int loc_FogRangeRecip;
803 int loc_LightPosition;
804 int loc_OffsetMapping_ScaleSteps;
805 int loc_OffsetMapping_LodDistance;
806 int loc_OffsetMapping_Bias;
808 int loc_ReflectColor;
809 int loc_ReflectFactor;
810 int loc_ReflectOffset;
811 int loc_RefractColor;
813 int loc_ScreenCenterRefractReflect;
814 int loc_ScreenScaleRefractReflect;
815 int loc_ScreenToDepth;
816 int loc_ShadowMap_Parameters;
817 int loc_ShadowMap_TextureScale;
818 int loc_SpecularPower;
823 int loc_ViewTintColor;
825 int loc_ModelToLight;
827 int loc_BackgroundTexMatrix;
828 int loc_ModelViewProjectionMatrix;
829 int loc_ModelViewMatrix;
830 int loc_PixelToScreenTexCoord;
831 int loc_ModelToReflectCube;
832 int loc_ShadowMapMatrix;
833 int loc_BloomColorSubtract;
834 int loc_NormalmapScrollBlend;
835 int loc_BounceGridMatrix;
836 int loc_BounceGridIntensity;
838 r_glsl_permutation_t;
840 #define SHADERPERMUTATION_HASHSIZE 256
843 // non-degradable "lightweight" shader parameters to keep the permutations simpler
844 // these can NOT degrade! only use for simple stuff
847 SHADERSTATICPARM_SATURATION_REDCOMPENSATE = 0, ///< red compensation filter for saturation
848 SHADERSTATICPARM_EXACTSPECULARMATH = 1, ///< (lightsource or deluxemapping) use exact reflection map for specular effects, as opposed to the usual OpenGL approximation
849 SHADERSTATICPARM_POSTPROCESS_USERVEC1 = 2, ///< postprocess uservec1 is enabled
850 SHADERSTATICPARM_POSTPROCESS_USERVEC2 = 3, ///< postprocess uservec2 is enabled
851 SHADERSTATICPARM_POSTPROCESS_USERVEC3 = 4, ///< postprocess uservec3 is enabled
852 SHADERSTATICPARM_POSTPROCESS_USERVEC4 = 5, ///< postprocess uservec4 is enabled
853 SHADERSTATICPARM_VERTEXTEXTUREBLEND_USEBOTHALPHAS = 6, // use both alpha layers while blending materials, allows more advanced microblending
854 SHADERSTATICPARM_OFFSETMAPPING_USELOD = 7, ///< LOD for offsetmapping
855 SHADERSTATICPARM_SHADOWMAPPCF_1 = 8, ///< PCF 1
856 SHADERSTATICPARM_SHADOWMAPPCF_2 = 9, ///< PCF 2
857 SHADERSTATICPARM_SHADOWSAMPLER = 10, ///< sampler
858 SHADERSTATICPARM_CELSHADING = 11, ///< celshading (alternative diffuse and specular math)
859 SHADERSTATICPARM_CELOUTLINES = 12, ///< celoutline (depth buffer analysis to produce outlines)
861 #define SHADERSTATICPARMS_COUNT 13
863 static const char *shaderstaticparmstrings_list[SHADERSTATICPARMS_COUNT];
864 static int shaderstaticparms_count = 0;
866 static unsigned int r_compileshader_staticparms[(SHADERSTATICPARMS_COUNT + 0x1F) >> 5] = {0};
867 #define R_COMPILESHADER_STATICPARM_ENABLE(p) r_compileshader_staticparms[(p) >> 5] |= (1 << ((p) & 0x1F))
869 extern qboolean r_shadow_shadowmapsampler;
870 extern int r_shadow_shadowmappcf;
871 qboolean R_CompileShader_CheckStaticParms(void)
873 static int r_compileshader_staticparms_save[1];
874 memcpy(r_compileshader_staticparms_save, r_compileshader_staticparms, sizeof(r_compileshader_staticparms));
875 memset(r_compileshader_staticparms, 0, sizeof(r_compileshader_staticparms));
878 if (r_glsl_saturation_redcompensate.integer)
879 R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_SATURATION_REDCOMPENSATE);
880 if (r_glsl_vertextextureblend_usebothalphas.integer)
881 R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_VERTEXTEXTUREBLEND_USEBOTHALPHAS);
882 if (r_shadow_glossexact.integer)
883 R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_EXACTSPECULARMATH);
884 if (r_glsl_postprocess.integer)
886 if (r_glsl_postprocess_uservec1_enable.integer)
887 R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_POSTPROCESS_USERVEC1);
888 if (r_glsl_postprocess_uservec2_enable.integer)
889 R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_POSTPROCESS_USERVEC2);
890 if (r_glsl_postprocess_uservec3_enable.integer)
891 R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_POSTPROCESS_USERVEC3);
892 if (r_glsl_postprocess_uservec4_enable.integer)
893 R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_POSTPROCESS_USERVEC4);
895 if (r_glsl_offsetmapping_lod.integer && r_glsl_offsetmapping_lod_distance.integer > 0)
896 R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_OFFSETMAPPING_USELOD);
898 if (r_shadow_shadowmapsampler)
899 R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_SHADOWSAMPLER);
900 if (r_shadow_shadowmappcf > 1)
901 R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_SHADOWMAPPCF_2);
902 else if (r_shadow_shadowmappcf)
903 R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_SHADOWMAPPCF_1);
904 if (r_celshading.integer)
905 R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_CELSHADING);
906 if (r_celoutlines.integer)
907 R_COMPILESHADER_STATICPARM_ENABLE(SHADERSTATICPARM_CELOUTLINES);
909 return memcmp(r_compileshader_staticparms, r_compileshader_staticparms_save, sizeof(r_compileshader_staticparms)) != 0;
912 #define R_COMPILESHADER_STATICPARM_EMIT(p, n) \
913 if(r_compileshader_staticparms[(p) >> 5] & (1 << ((p) & 0x1F))) \
914 shaderstaticparmstrings_list[shaderstaticparms_count++] = "#define " n "\n"; \
916 shaderstaticparmstrings_list[shaderstaticparms_count++] = "\n"
917 static void R_CompileShader_AddStaticParms(unsigned int mode, unsigned int permutation)
919 shaderstaticparms_count = 0;
922 R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_SATURATION_REDCOMPENSATE, "SATURATION_REDCOMPENSATE");
923 R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_EXACTSPECULARMATH, "USEEXACTSPECULARMATH");
924 R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_POSTPROCESS_USERVEC1, "USERVEC1");
925 R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_POSTPROCESS_USERVEC2, "USERVEC2");
926 R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_POSTPROCESS_USERVEC3, "USERVEC3");
927 R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_POSTPROCESS_USERVEC4, "USERVEC4");
928 R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_VERTEXTEXTUREBLEND_USEBOTHALPHAS, "USEBOTHALPHAS");
929 R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_OFFSETMAPPING_USELOD, "USEOFFSETMAPPING_LOD");
930 R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_SHADOWMAPPCF_1, "USESHADOWMAPPCF 1");
931 R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_SHADOWMAPPCF_2, "USESHADOWMAPPCF 2");
932 R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_SHADOWSAMPLER, "USESHADOWSAMPLER");
933 R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_CELSHADING, "USECELSHADING");
934 R_COMPILESHADER_STATICPARM_EMIT(SHADERSTATICPARM_CELOUTLINES, "USECELOUTLINES");
937 /// information about each possible shader permutation
938 r_glsl_permutation_t *r_glsl_permutationhash[SHADERMODE_COUNT][SHADERPERMUTATION_HASHSIZE];
939 /// currently selected permutation
940 r_glsl_permutation_t *r_glsl_permutation;
941 /// storage for permutations linked in the hash table
942 memexpandablearray_t r_glsl_permutationarray;
944 static r_glsl_permutation_t *R_GLSL_FindPermutation(unsigned int mode, unsigned int permutation)
946 //unsigned int hashdepth = 0;
947 unsigned int hashindex = (permutation * 0x1021) & (SHADERPERMUTATION_HASHSIZE - 1);
948 r_glsl_permutation_t *p;
949 for (p = r_glsl_permutationhash[mode][hashindex];p;p = p->hashnext)
951 if (p->mode == mode && p->permutation == permutation)
953 //if (hashdepth > 10)
954 // Con_Printf("R_GLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
959 p = (r_glsl_permutation_t*)Mem_ExpandableArray_AllocRecord(&r_glsl_permutationarray);
961 p->permutation = permutation;
962 p->hashnext = r_glsl_permutationhash[mode][hashindex];
963 r_glsl_permutationhash[mode][hashindex] = p;
964 //if (hashdepth > 10)
965 // Con_Printf("R_GLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
969 static char *R_GLSL_GetText(const char *filename, qboolean printfromdisknotice)
972 if (!filename || !filename[0])
974 if (!strcmp(filename, "glsl/default.glsl"))
976 if (!glslshaderstring)
978 glslshaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
979 if (glslshaderstring)
980 Con_DPrintf("Loading shaders from file %s...\n", filename);
982 glslshaderstring = (char *)builtinshaderstring;
984 shaderstring = (char *) Mem_Alloc(r_main_mempool, strlen(glslshaderstring) + 1);
985 memcpy(shaderstring, glslshaderstring, strlen(glslshaderstring) + 1);
988 shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
991 if (printfromdisknotice)
992 Con_DPrintf("from disk %s... ", filename);
998 static void R_GLSL_CompilePermutation(r_glsl_permutation_t *p, unsigned int mode, unsigned int permutation)
1002 shadermodeinfo_t *modeinfo = glslshadermodeinfo + mode;
1003 char *vertexstring, *geometrystring, *fragmentstring;
1004 char permutationname[256];
1005 int vertstrings_count = 0;
1006 int geomstrings_count = 0;
1007 int fragstrings_count = 0;
1008 const char *vertstrings_list[32+5+SHADERSTATICPARMS_COUNT+1];
1009 const char *geomstrings_list[32+5+SHADERSTATICPARMS_COUNT+1];
1010 const char *fragstrings_list[32+5+SHADERSTATICPARMS_COUNT+1];
1017 permutationname[0] = 0;
1018 vertexstring = R_GLSL_GetText(modeinfo->vertexfilename, true);
1019 geometrystring = R_GLSL_GetText(modeinfo->geometryfilename, false);
1020 fragmentstring = R_GLSL_GetText(modeinfo->fragmentfilename, false);
1022 strlcat(permutationname, modeinfo->vertexfilename, sizeof(permutationname));
1024 // if we can do #version 130, we should (this improves quality of offset/reliefmapping thanks to textureGrad)
1025 if(vid.support.gl20shaders130)
1027 vertstrings_list[vertstrings_count++] = "#version 130\n";
1028 geomstrings_list[geomstrings_count++] = "#version 130\n";
1029 fragstrings_list[fragstrings_count++] = "#version 130\n";
1030 vertstrings_list[vertstrings_count++] = "#define GLSL130\n";
1031 geomstrings_list[geomstrings_count++] = "#define GLSL130\n";
1032 fragstrings_list[fragstrings_count++] = "#define GLSL130\n";
1035 // the first pretext is which type of shader to compile as
1036 // (later these will all be bound together as a program object)
1037 vertstrings_list[vertstrings_count++] = "#define VERTEX_SHADER\n";
1038 geomstrings_list[geomstrings_count++] = "#define GEOMETRY_SHADER\n";
1039 fragstrings_list[fragstrings_count++] = "#define FRAGMENT_SHADER\n";
1041 // the second pretext is the mode (for example a light source)
1042 vertstrings_list[vertstrings_count++] = modeinfo->pretext;
1043 geomstrings_list[geomstrings_count++] = modeinfo->pretext;
1044 fragstrings_list[fragstrings_count++] = modeinfo->pretext;
1045 strlcat(permutationname, modeinfo->name, sizeof(permutationname));
1047 // now add all the permutation pretexts
1048 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
1050 if (permutation & (1<<i))
1052 vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i].pretext;
1053 geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i].pretext;
1054 fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i].pretext;
1055 strlcat(permutationname, shaderpermutationinfo[i].name, sizeof(permutationname));
1059 // keep line numbers correct
1060 vertstrings_list[vertstrings_count++] = "\n";
1061 geomstrings_list[geomstrings_count++] = "\n";
1062 fragstrings_list[fragstrings_count++] = "\n";
1067 R_CompileShader_AddStaticParms(mode, permutation);
1068 memcpy((char *)(vertstrings_list + vertstrings_count), shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
1069 vertstrings_count += shaderstaticparms_count;
1070 memcpy((char *)(geomstrings_list + geomstrings_count), shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
1071 geomstrings_count += shaderstaticparms_count;
1072 memcpy((char *)(fragstrings_list + fragstrings_count), shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
1073 fragstrings_count += shaderstaticparms_count;
1075 // now append the shader text itself
1076 vertstrings_list[vertstrings_count++] = vertexstring;
1077 geomstrings_list[geomstrings_count++] = geometrystring;
1078 fragstrings_list[fragstrings_count++] = fragmentstring;
1080 // if any sources were NULL, clear the respective list
1082 vertstrings_count = 0;
1083 if (!geometrystring)
1084 geomstrings_count = 0;
1085 if (!fragmentstring)
1086 fragstrings_count = 0;
1088 // compile the shader program
1089 if (vertstrings_count + geomstrings_count + fragstrings_count)
1090 p->program = GL_Backend_CompileProgram(vertstrings_count, vertstrings_list, geomstrings_count, geomstrings_list, fragstrings_count, fragstrings_list);
1094 qglUseProgram(p->program);CHECKGLERROR
1095 // look up all the uniform variable names we care about, so we don't
1096 // have to look them up every time we set them
1098 p->loc_Texture_First = qglGetUniformLocation(p->program, "Texture_First");
1099 p->loc_Texture_Second = qglGetUniformLocation(p->program, "Texture_Second");
1100 p->loc_Texture_GammaRamps = qglGetUniformLocation(p->program, "Texture_GammaRamps");
1101 p->loc_Texture_Normal = qglGetUniformLocation(p->program, "Texture_Normal");
1102 p->loc_Texture_Color = qglGetUniformLocation(p->program, "Texture_Color");
1103 p->loc_Texture_Gloss = qglGetUniformLocation(p->program, "Texture_Gloss");
1104 p->loc_Texture_Glow = qglGetUniformLocation(p->program, "Texture_Glow");
1105 p->loc_Texture_SecondaryNormal = qglGetUniformLocation(p->program, "Texture_SecondaryNormal");
1106 p->loc_Texture_SecondaryColor = qglGetUniformLocation(p->program, "Texture_SecondaryColor");
1107 p->loc_Texture_SecondaryGloss = qglGetUniformLocation(p->program, "Texture_SecondaryGloss");
1108 p->loc_Texture_SecondaryGlow = qglGetUniformLocation(p->program, "Texture_SecondaryGlow");
1109 p->loc_Texture_Pants = qglGetUniformLocation(p->program, "Texture_Pants");
1110 p->loc_Texture_Shirt = qglGetUniformLocation(p->program, "Texture_Shirt");
1111 p->loc_Texture_FogHeightTexture = qglGetUniformLocation(p->program, "Texture_FogHeightTexture");
1112 p->loc_Texture_FogMask = qglGetUniformLocation(p->program, "Texture_FogMask");
1113 p->loc_Texture_Lightmap = qglGetUniformLocation(p->program, "Texture_Lightmap");
1114 p->loc_Texture_Deluxemap = qglGetUniformLocation(p->program, "Texture_Deluxemap");
1115 p->loc_Texture_Attenuation = qglGetUniformLocation(p->program, "Texture_Attenuation");
1116 p->loc_Texture_Cube = qglGetUniformLocation(p->program, "Texture_Cube");
1117 p->loc_Texture_Refraction = qglGetUniformLocation(p->program, "Texture_Refraction");
1118 p->loc_Texture_Reflection = qglGetUniformLocation(p->program, "Texture_Reflection");
1119 p->loc_Texture_ShadowMap2D = qglGetUniformLocation(p->program, "Texture_ShadowMap2D");
1120 p->loc_Texture_CubeProjection = qglGetUniformLocation(p->program, "Texture_CubeProjection");
1121 p->loc_Texture_ScreenNormalMap = qglGetUniformLocation(p->program, "Texture_ScreenNormalMap");
1122 p->loc_Texture_ScreenDiffuse = qglGetUniformLocation(p->program, "Texture_ScreenDiffuse");
1123 p->loc_Texture_ScreenSpecular = qglGetUniformLocation(p->program, "Texture_ScreenSpecular");
1124 p->loc_Texture_ReflectMask = qglGetUniformLocation(p->program, "Texture_ReflectMask");
1125 p->loc_Texture_ReflectCube = qglGetUniformLocation(p->program, "Texture_ReflectCube");
1126 p->loc_Texture_BounceGrid = qglGetUniformLocation(p->program, "Texture_BounceGrid");
1127 p->loc_Alpha = qglGetUniformLocation(p->program, "Alpha");
1128 p->loc_BloomBlur_Parameters = qglGetUniformLocation(p->program, "BloomBlur_Parameters");
1129 p->loc_ClientTime = qglGetUniformLocation(p->program, "ClientTime");
1130 p->loc_Color_Ambient = qglGetUniformLocation(p->program, "Color_Ambient");
1131 p->loc_Color_Diffuse = qglGetUniformLocation(p->program, "Color_Diffuse");
1132 p->loc_Color_Specular = qglGetUniformLocation(p->program, "Color_Specular");
1133 p->loc_Color_Glow = qglGetUniformLocation(p->program, "Color_Glow");
1134 p->loc_Color_Pants = qglGetUniformLocation(p->program, "Color_Pants");
1135 p->loc_Color_Shirt = qglGetUniformLocation(p->program, "Color_Shirt");
1136 p->loc_DeferredColor_Ambient = qglGetUniformLocation(p->program, "DeferredColor_Ambient");
1137 p->loc_DeferredColor_Diffuse = qglGetUniformLocation(p->program, "DeferredColor_Diffuse");
1138 p->loc_DeferredColor_Specular = qglGetUniformLocation(p->program, "DeferredColor_Specular");
1139 p->loc_DeferredMod_Diffuse = qglGetUniformLocation(p->program, "DeferredMod_Diffuse");
1140 p->loc_DeferredMod_Specular = qglGetUniformLocation(p->program, "DeferredMod_Specular");
1141 p->loc_DistortScaleRefractReflect = qglGetUniformLocation(p->program, "DistortScaleRefractReflect");
1142 p->loc_EyePosition = qglGetUniformLocation(p->program, "EyePosition");
1143 p->loc_FogColor = qglGetUniformLocation(p->program, "FogColor");
1144 p->loc_FogHeightFade = qglGetUniformLocation(p->program, "FogHeightFade");
1145 p->loc_FogPlane = qglGetUniformLocation(p->program, "FogPlane");
1146 p->loc_FogPlaneViewDist = qglGetUniformLocation(p->program, "FogPlaneViewDist");
1147 p->loc_FogRangeRecip = qglGetUniformLocation(p->program, "FogRangeRecip");
1148 p->loc_LightColor = qglGetUniformLocation(p->program, "LightColor");
1149 p->loc_LightDir = qglGetUniformLocation(p->program, "LightDir");
1150 p->loc_LightPosition = qglGetUniformLocation(p->program, "LightPosition");
1151 p->loc_OffsetMapping_ScaleSteps = qglGetUniformLocation(p->program, "OffsetMapping_ScaleSteps");
1152 p->loc_OffsetMapping_LodDistance = qglGetUniformLocation(p->program, "OffsetMapping_LodDistance");
1153 p->loc_OffsetMapping_Bias = qglGetUniformLocation(p->program, "OffsetMapping_Bias");
1154 p->loc_PixelSize = qglGetUniformLocation(p->program, "PixelSize");
1155 p->loc_ReflectColor = qglGetUniformLocation(p->program, "ReflectColor");
1156 p->loc_ReflectFactor = qglGetUniformLocation(p->program, "ReflectFactor");
1157 p->loc_ReflectOffset = qglGetUniformLocation(p->program, "ReflectOffset");
1158 p->loc_RefractColor = qglGetUniformLocation(p->program, "RefractColor");
1159 p->loc_Saturation = qglGetUniformLocation(p->program, "Saturation");
1160 p->loc_ScreenCenterRefractReflect = qglGetUniformLocation(p->program, "ScreenCenterRefractReflect");
1161 p->loc_ScreenScaleRefractReflect = qglGetUniformLocation(p->program, "ScreenScaleRefractReflect");
1162 p->loc_ScreenToDepth = qglGetUniformLocation(p->program, "ScreenToDepth");
1163 p->loc_ShadowMap_Parameters = qglGetUniformLocation(p->program, "ShadowMap_Parameters");
1164 p->loc_ShadowMap_TextureScale = qglGetUniformLocation(p->program, "ShadowMap_TextureScale");
1165 p->loc_SpecularPower = qglGetUniformLocation(p->program, "SpecularPower");
1166 p->loc_UserVec1 = qglGetUniformLocation(p->program, "UserVec1");
1167 p->loc_UserVec2 = qglGetUniformLocation(p->program, "UserVec2");
1168 p->loc_UserVec3 = qglGetUniformLocation(p->program, "UserVec3");
1169 p->loc_UserVec4 = qglGetUniformLocation(p->program, "UserVec4");
1170 p->loc_ViewTintColor = qglGetUniformLocation(p->program, "ViewTintColor");
1171 p->loc_ViewToLight = qglGetUniformLocation(p->program, "ViewToLight");
1172 p->loc_ModelToLight = qglGetUniformLocation(p->program, "ModelToLight");
1173 p->loc_TexMatrix = qglGetUniformLocation(p->program, "TexMatrix");
1174 p->loc_BackgroundTexMatrix = qglGetUniformLocation(p->program, "BackgroundTexMatrix");
1175 p->loc_ModelViewMatrix = qglGetUniformLocation(p->program, "ModelViewMatrix");
1176 p->loc_ModelViewProjectionMatrix = qglGetUniformLocation(p->program, "ModelViewProjectionMatrix");
1177 p->loc_PixelToScreenTexCoord = qglGetUniformLocation(p->program, "PixelToScreenTexCoord");
1178 p->loc_ModelToReflectCube = qglGetUniformLocation(p->program, "ModelToReflectCube");
1179 p->loc_ShadowMapMatrix = qglGetUniformLocation(p->program, "ShadowMapMatrix");
1180 p->loc_BloomColorSubtract = qglGetUniformLocation(p->program, "BloomColorSubtract");
1181 p->loc_NormalmapScrollBlend = qglGetUniformLocation(p->program, "NormalmapScrollBlend");
1182 p->loc_BounceGridMatrix = qglGetUniformLocation(p->program, "BounceGridMatrix");
1183 p->loc_BounceGridIntensity = qglGetUniformLocation(p->program, "BounceGridIntensity");
1184 // initialize the samplers to refer to the texture units we use
1185 p->tex_Texture_First = -1;
1186 p->tex_Texture_Second = -1;
1187 p->tex_Texture_GammaRamps = -1;
1188 p->tex_Texture_Normal = -1;
1189 p->tex_Texture_Color = -1;
1190 p->tex_Texture_Gloss = -1;
1191 p->tex_Texture_Glow = -1;
1192 p->tex_Texture_SecondaryNormal = -1;
1193 p->tex_Texture_SecondaryColor = -1;
1194 p->tex_Texture_SecondaryGloss = -1;
1195 p->tex_Texture_SecondaryGlow = -1;
1196 p->tex_Texture_Pants = -1;
1197 p->tex_Texture_Shirt = -1;
1198 p->tex_Texture_FogHeightTexture = -1;
1199 p->tex_Texture_FogMask = -1;
1200 p->tex_Texture_Lightmap = -1;
1201 p->tex_Texture_Deluxemap = -1;
1202 p->tex_Texture_Attenuation = -1;
1203 p->tex_Texture_Cube = -1;
1204 p->tex_Texture_Refraction = -1;
1205 p->tex_Texture_Reflection = -1;
1206 p->tex_Texture_ShadowMap2D = -1;
1207 p->tex_Texture_CubeProjection = -1;
1208 p->tex_Texture_ScreenNormalMap = -1;
1209 p->tex_Texture_ScreenDiffuse = -1;
1210 p->tex_Texture_ScreenSpecular = -1;
1211 p->tex_Texture_ReflectMask = -1;
1212 p->tex_Texture_ReflectCube = -1;
1213 p->tex_Texture_BounceGrid = -1;
1215 if (p->loc_Texture_First >= 0) {p->tex_Texture_First = sampler;qglUniform1i(p->loc_Texture_First , sampler);sampler++;}
1216 if (p->loc_Texture_Second >= 0) {p->tex_Texture_Second = sampler;qglUniform1i(p->loc_Texture_Second , sampler);sampler++;}
1217 if (p->loc_Texture_GammaRamps >= 0) {p->tex_Texture_GammaRamps = sampler;qglUniform1i(p->loc_Texture_GammaRamps , sampler);sampler++;}
1218 if (p->loc_Texture_Normal >= 0) {p->tex_Texture_Normal = sampler;qglUniform1i(p->loc_Texture_Normal , sampler);sampler++;}
1219 if (p->loc_Texture_Color >= 0) {p->tex_Texture_Color = sampler;qglUniform1i(p->loc_Texture_Color , sampler);sampler++;}
1220 if (p->loc_Texture_Gloss >= 0) {p->tex_Texture_Gloss = sampler;qglUniform1i(p->loc_Texture_Gloss , sampler);sampler++;}
1221 if (p->loc_Texture_Glow >= 0) {p->tex_Texture_Glow = sampler;qglUniform1i(p->loc_Texture_Glow , sampler);sampler++;}
1222 if (p->loc_Texture_SecondaryNormal >= 0) {p->tex_Texture_SecondaryNormal = sampler;qglUniform1i(p->loc_Texture_SecondaryNormal , sampler);sampler++;}
1223 if (p->loc_Texture_SecondaryColor >= 0) {p->tex_Texture_SecondaryColor = sampler;qglUniform1i(p->loc_Texture_SecondaryColor , sampler);sampler++;}
1224 if (p->loc_Texture_SecondaryGloss >= 0) {p->tex_Texture_SecondaryGloss = sampler;qglUniform1i(p->loc_Texture_SecondaryGloss , sampler);sampler++;}
1225 if (p->loc_Texture_SecondaryGlow >= 0) {p->tex_Texture_SecondaryGlow = sampler;qglUniform1i(p->loc_Texture_SecondaryGlow , sampler);sampler++;}
1226 if (p->loc_Texture_Pants >= 0) {p->tex_Texture_Pants = sampler;qglUniform1i(p->loc_Texture_Pants , sampler);sampler++;}
1227 if (p->loc_Texture_Shirt >= 0) {p->tex_Texture_Shirt = sampler;qglUniform1i(p->loc_Texture_Shirt , sampler);sampler++;}
1228 if (p->loc_Texture_FogHeightTexture>= 0) {p->tex_Texture_FogHeightTexture = sampler;qglUniform1i(p->loc_Texture_FogHeightTexture, sampler);sampler++;}
1229 if (p->loc_Texture_FogMask >= 0) {p->tex_Texture_FogMask = sampler;qglUniform1i(p->loc_Texture_FogMask , sampler);sampler++;}
1230 if (p->loc_Texture_Lightmap >= 0) {p->tex_Texture_Lightmap = sampler;qglUniform1i(p->loc_Texture_Lightmap , sampler);sampler++;}
1231 if (p->loc_Texture_Deluxemap >= 0) {p->tex_Texture_Deluxemap = sampler;qglUniform1i(p->loc_Texture_Deluxemap , sampler);sampler++;}
1232 if (p->loc_Texture_Attenuation >= 0) {p->tex_Texture_Attenuation = sampler;qglUniform1i(p->loc_Texture_Attenuation , sampler);sampler++;}
1233 if (p->loc_Texture_Cube >= 0) {p->tex_Texture_Cube = sampler;qglUniform1i(p->loc_Texture_Cube , sampler);sampler++;}
1234 if (p->loc_Texture_Refraction >= 0) {p->tex_Texture_Refraction = sampler;qglUniform1i(p->loc_Texture_Refraction , sampler);sampler++;}
1235 if (p->loc_Texture_Reflection >= 0) {p->tex_Texture_Reflection = sampler;qglUniform1i(p->loc_Texture_Reflection , sampler);sampler++;}
1236 if (p->loc_Texture_ShadowMap2D >= 0) {p->tex_Texture_ShadowMap2D = sampler;qglUniform1i(p->loc_Texture_ShadowMap2D , sampler);sampler++;}
1237 if (p->loc_Texture_CubeProjection >= 0) {p->tex_Texture_CubeProjection = sampler;qglUniform1i(p->loc_Texture_CubeProjection , sampler);sampler++;}
1238 if (p->loc_Texture_ScreenNormalMap >= 0) {p->tex_Texture_ScreenNormalMap = sampler;qglUniform1i(p->loc_Texture_ScreenNormalMap , sampler);sampler++;}
1239 if (p->loc_Texture_ScreenDiffuse >= 0) {p->tex_Texture_ScreenDiffuse = sampler;qglUniform1i(p->loc_Texture_ScreenDiffuse , sampler);sampler++;}
1240 if (p->loc_Texture_ScreenSpecular >= 0) {p->tex_Texture_ScreenSpecular = sampler;qglUniform1i(p->loc_Texture_ScreenSpecular , sampler);sampler++;}
1241 if (p->loc_Texture_ReflectMask >= 0) {p->tex_Texture_ReflectMask = sampler;qglUniform1i(p->loc_Texture_ReflectMask , sampler);sampler++;}
1242 if (p->loc_Texture_ReflectCube >= 0) {p->tex_Texture_ReflectCube = sampler;qglUniform1i(p->loc_Texture_ReflectCube , sampler);sampler++;}
1243 if (p->loc_Texture_BounceGrid >= 0) {p->tex_Texture_BounceGrid = sampler;qglUniform1i(p->loc_Texture_BounceGrid , sampler);sampler++;}
1245 Con_DPrintf("^5GLSL shader %s compiled (%i textures).\n", permutationname, sampler);
1248 Con_Printf("^1GLSL shader %s failed! some features may not work properly.\n", permutationname);
1252 Mem_Free(vertexstring);
1254 Mem_Free(geometrystring);
1256 Mem_Free(fragmentstring);
1259 static void R_SetupShader_SetPermutationGLSL(unsigned int mode, unsigned int permutation)
1261 r_glsl_permutation_t *perm = R_GLSL_FindPermutation(mode, permutation);
1262 if (r_glsl_permutation != perm)
1264 r_glsl_permutation = perm;
1265 if (!r_glsl_permutation->program)
1267 if (!r_glsl_permutation->compiled)
1268 R_GLSL_CompilePermutation(perm, mode, permutation);
1269 if (!r_glsl_permutation->program)
1271 // remove features until we find a valid permutation
1273 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
1275 // reduce i more quickly whenever it would not remove any bits
1276 int j = 1<<(SHADERPERMUTATION_COUNT-1-i);
1277 if (!(permutation & j))
1280 r_glsl_permutation = R_GLSL_FindPermutation(mode, permutation);
1281 if (!r_glsl_permutation->compiled)
1282 R_GLSL_CompilePermutation(perm, mode, permutation);
1283 if (r_glsl_permutation->program)
1286 if (i >= SHADERPERMUTATION_COUNT)
1288 //Con_Printf("Could not find a working OpenGL 2.0 shader for permutation %s %s\n", shadermodeinfo[mode].vertexfilename, shadermodeinfo[mode].pretext);
1289 r_glsl_permutation = R_GLSL_FindPermutation(mode, permutation);
1290 qglUseProgram(0);CHECKGLERROR
1291 return; // no bit left to clear, entire mode is broken
1296 qglUseProgram(r_glsl_permutation->program);CHECKGLERROR
1298 if (r_glsl_permutation->loc_ModelViewProjectionMatrix >= 0) qglUniformMatrix4fv(r_glsl_permutation->loc_ModelViewProjectionMatrix, 1, false, gl_modelviewprojection16f);
1299 if (r_glsl_permutation->loc_ModelViewMatrix >= 0) qglUniformMatrix4fv(r_glsl_permutation->loc_ModelViewMatrix, 1, false, gl_modelview16f);
1300 if (r_glsl_permutation->loc_ClientTime >= 0) qglUniform1f(r_glsl_permutation->loc_ClientTime, cl.time);
1307 extern LPDIRECT3DDEVICE9 vid_d3d9dev;
1308 extern D3DCAPS9 vid_d3d9caps;
1311 struct r_hlsl_permutation_s;
1312 typedef struct r_hlsl_permutation_s
1314 /// hash lookup data
1315 struct r_hlsl_permutation_s *hashnext;
1317 unsigned int permutation;
1319 /// indicates if we have tried compiling this permutation already
1321 /// NULL if compilation failed
1322 IDirect3DVertexShader9 *vertexshader;
1323 IDirect3DPixelShader9 *pixelshader;
1325 r_hlsl_permutation_t;
1327 typedef enum D3DVSREGISTER_e
1329 D3DVSREGISTER_TexMatrix = 0, // float4x4
1330 D3DVSREGISTER_BackgroundTexMatrix = 4, // float4x4
1331 D3DVSREGISTER_ModelViewProjectionMatrix = 8, // float4x4
1332 D3DVSREGISTER_ModelViewMatrix = 12, // float4x4
1333 D3DVSREGISTER_ShadowMapMatrix = 16, // float4x4
1334 D3DVSREGISTER_ModelToLight = 20, // float4x4
1335 D3DVSREGISTER_EyePosition = 24,
1336 D3DVSREGISTER_FogPlane = 25,
1337 D3DVSREGISTER_LightDir = 26,
1338 D3DVSREGISTER_LightPosition = 27,
1342 typedef enum D3DPSREGISTER_e
1344 D3DPSREGISTER_Alpha = 0,
1345 D3DPSREGISTER_BloomBlur_Parameters = 1,
1346 D3DPSREGISTER_ClientTime = 2,
1347 D3DPSREGISTER_Color_Ambient = 3,
1348 D3DPSREGISTER_Color_Diffuse = 4,
1349 D3DPSREGISTER_Color_Specular = 5,
1350 D3DPSREGISTER_Color_Glow = 6,
1351 D3DPSREGISTER_Color_Pants = 7,
1352 D3DPSREGISTER_Color_Shirt = 8,
1353 D3DPSREGISTER_DeferredColor_Ambient = 9,
1354 D3DPSREGISTER_DeferredColor_Diffuse = 10,
1355 D3DPSREGISTER_DeferredColor_Specular = 11,
1356 D3DPSREGISTER_DeferredMod_Diffuse = 12,
1357 D3DPSREGISTER_DeferredMod_Specular = 13,
1358 D3DPSREGISTER_DistortScaleRefractReflect = 14,
1359 D3DPSREGISTER_EyePosition = 15, // unused
1360 D3DPSREGISTER_FogColor = 16,
1361 D3DPSREGISTER_FogHeightFade = 17,
1362 D3DPSREGISTER_FogPlane = 18,
1363 D3DPSREGISTER_FogPlaneViewDist = 19,
1364 D3DPSREGISTER_FogRangeRecip = 20,
1365 D3DPSREGISTER_LightColor = 21,
1366 D3DPSREGISTER_LightDir = 22, // unused
1367 D3DPSREGISTER_LightPosition = 23,
1368 D3DPSREGISTER_OffsetMapping_ScaleSteps = 24,
1369 D3DPSREGISTER_PixelSize = 25,
1370 D3DPSREGISTER_ReflectColor = 26,
1371 D3DPSREGISTER_ReflectFactor = 27,
1372 D3DPSREGISTER_ReflectOffset = 28,
1373 D3DPSREGISTER_RefractColor = 29,
1374 D3DPSREGISTER_Saturation = 30,
1375 D3DPSREGISTER_ScreenCenterRefractReflect = 31,
1376 D3DPSREGISTER_ScreenScaleRefractReflect = 32,
1377 D3DPSREGISTER_ScreenToDepth = 33,
1378 D3DPSREGISTER_ShadowMap_Parameters = 34,
1379 D3DPSREGISTER_ShadowMap_TextureScale = 35,
1380 D3DPSREGISTER_SpecularPower = 36,
1381 D3DPSREGISTER_UserVec1 = 37,
1382 D3DPSREGISTER_UserVec2 = 38,
1383 D3DPSREGISTER_UserVec3 = 39,
1384 D3DPSREGISTER_UserVec4 = 40,
1385 D3DPSREGISTER_ViewTintColor = 41,
1386 D3DPSREGISTER_PixelToScreenTexCoord = 42,
1387 D3DPSREGISTER_BloomColorSubtract = 43,
1388 D3DPSREGISTER_ViewToLight = 44, // float4x4
1389 D3DPSREGISTER_ModelToReflectCube = 48, // float4x4
1390 D3DPSREGISTER_NormalmapScrollBlend = 52,
1391 D3DPSREGISTER_OffsetMapping_LodDistance = 53,
1392 D3DPSREGISTER_OffsetMapping_Bias = 54,
1397 /// information about each possible shader permutation
1398 r_hlsl_permutation_t *r_hlsl_permutationhash[SHADERMODE_COUNT][SHADERPERMUTATION_HASHSIZE];
1399 /// currently selected permutation
1400 r_hlsl_permutation_t *r_hlsl_permutation;
1401 /// storage for permutations linked in the hash table
1402 memexpandablearray_t r_hlsl_permutationarray;
1404 static r_hlsl_permutation_t *R_HLSL_FindPermutation(unsigned int mode, unsigned int permutation)
1406 //unsigned int hashdepth = 0;
1407 unsigned int hashindex = (permutation * 0x1021) & (SHADERPERMUTATION_HASHSIZE - 1);
1408 r_hlsl_permutation_t *p;
1409 for (p = r_hlsl_permutationhash[mode][hashindex];p;p = p->hashnext)
1411 if (p->mode == mode && p->permutation == permutation)
1413 //if (hashdepth > 10)
1414 // Con_Printf("R_HLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
1419 p = (r_hlsl_permutation_t*)Mem_ExpandableArray_AllocRecord(&r_hlsl_permutationarray);
1421 p->permutation = permutation;
1422 p->hashnext = r_hlsl_permutationhash[mode][hashindex];
1423 r_hlsl_permutationhash[mode][hashindex] = p;
1424 //if (hashdepth > 10)
1425 // Con_Printf("R_HLSL_FindPermutation: Warning: %i:%i has hashdepth %i\n", mode, permutation, hashdepth);
1429 static char *R_HLSL_GetText(const char *filename, qboolean printfromdisknotice)
1432 if (!filename || !filename[0])
1434 if (!strcmp(filename, "hlsl/default.hlsl"))
1436 if (!hlslshaderstring)
1438 hlslshaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
1439 if (hlslshaderstring)
1440 Con_DPrintf("Loading shaders from file %s...\n", filename);
1442 hlslshaderstring = (char *)builtinhlslshaderstring;
1444 shaderstring = (char *) Mem_Alloc(r_main_mempool, strlen(hlslshaderstring) + 1);
1445 memcpy(shaderstring, hlslshaderstring, strlen(hlslshaderstring) + 1);
1446 return shaderstring;
1448 shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL);
1451 if (printfromdisknotice)
1452 Con_DPrintf("from disk %s... ", filename);
1453 return shaderstring;
1455 return shaderstring;
1459 //#include <d3dx9shader.h>
1460 //#include <d3dx9mesh.h>
1462 static void R_HLSL_CacheShader(r_hlsl_permutation_t *p, const char *cachename, const char *vertstring, const char *fragstring)
1464 DWORD *vsbin = NULL;
1465 DWORD *psbin = NULL;
1466 fs_offset_t vsbinsize;
1467 fs_offset_t psbinsize;
1468 // IDirect3DVertexShader9 *vs = NULL;
1469 // IDirect3DPixelShader9 *ps = NULL;
1470 ID3DXBuffer *vslog = NULL;
1471 ID3DXBuffer *vsbuffer = NULL;
1472 ID3DXConstantTable *vsconstanttable = NULL;
1473 ID3DXBuffer *pslog = NULL;
1474 ID3DXBuffer *psbuffer = NULL;
1475 ID3DXConstantTable *psconstanttable = NULL;
1478 char temp[MAX_INPUTLINE];
1479 const char *vsversion = "vs_3_0", *psversion = "ps_3_0";
1481 qboolean debugshader = gl_paranoid.integer != 0;
1482 if (p->permutation & SHADERPERMUTATION_OFFSETMAPPING) {vsversion = "vs_3_0";psversion = "ps_3_0";}
1483 if (p->permutation & SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING) {vsversion = "vs_3_0";psversion = "ps_3_0";}
1486 vsbin = (DWORD *)FS_LoadFile(va(vabuf, sizeof(vabuf), "%s.vsbin", cachename), r_main_mempool, true, &vsbinsize);
1487 psbin = (DWORD *)FS_LoadFile(va(vabuf, sizeof(vabuf), "%s.psbin", cachename), r_main_mempool, true, &psbinsize);
1489 if ((!vsbin && vertstring) || (!psbin && fragstring))
1491 const char* dllnames_d3dx9 [] =
1515 dllhandle_t d3dx9_dll = NULL;
1516 HRESULT (WINAPI *qD3DXCompileShaderFromFileA)(LPCSTR pSrcFile, CONST D3DXMACRO* pDefines, LPD3DXINCLUDE pInclude, LPCSTR pFunctionName, LPCSTR pProfile, DWORD Flags, LPD3DXBUFFER* ppShader, LPD3DXBUFFER* ppErrorMsgs, LPD3DXCONSTANTTABLE* ppConstantTable);
1517 HRESULT (WINAPI *qD3DXPreprocessShader)(LPCSTR pSrcData, UINT SrcDataSize, CONST D3DXMACRO* pDefines, LPD3DXINCLUDE pInclude, LPD3DXBUFFER* ppShaderText, LPD3DXBUFFER* ppErrorMsgs);
1518 HRESULT (WINAPI *qD3DXCompileShader)(LPCSTR pSrcData, UINT SrcDataLen, CONST D3DXMACRO* pDefines, LPD3DXINCLUDE pInclude, LPCSTR pFunctionName, LPCSTR pProfile, DWORD Flags, LPD3DXBUFFER* ppShader, LPD3DXBUFFER* ppErrorMsgs, LPD3DXCONSTANTTABLE* ppConstantTable);
1519 dllfunction_t d3dx9_dllfuncs[] =
1521 {"D3DXCompileShaderFromFileA", (void **) &qD3DXCompileShaderFromFileA},
1522 {"D3DXPreprocessShader", (void **) &qD3DXPreprocessShader},
1523 {"D3DXCompileShader", (void **) &qD3DXCompileShader},
1526 if (Sys_LoadLibrary(dllnames_d3dx9, &d3dx9_dll, d3dx9_dllfuncs))
1528 DWORD shaderflags = 0;
1530 shaderflags = D3DXSHADER_DEBUG | D3DXSHADER_SKIPOPTIMIZATION;
1531 vsbin = (DWORD *)Mem_Realloc(tempmempool, vsbin, 0);
1532 psbin = (DWORD *)Mem_Realloc(tempmempool, psbin, 0);
1533 if (vertstring && vertstring[0])
1537 // vsresult = qD3DXPreprocessShader(vertstring, strlen(vertstring), NULL, NULL, &vsbuffer, &vslog);
1538 // FS_WriteFile(va(vabuf, sizeof(vabuf), "%s_vs.fx", cachename), vsbuffer->GetBufferPointer(), vsbuffer->GetBufferSize());
1539 FS_WriteFile(va(vabuf, sizeof(vabuf), "%s_vs.fx", cachename), vertstring, strlen(vertstring));
1540 vsresult = qD3DXCompileShaderFromFileA(va(vabuf, sizeof(vabuf), "%s/%s_vs.fx", fs_gamedir, cachename), NULL, NULL, "main", vsversion, shaderflags, &vsbuffer, &vslog, &vsconstanttable);
1543 vsresult = qD3DXCompileShader(vertstring, strlen(vertstring), NULL, NULL, "main", vsversion, shaderflags, &vsbuffer, &vslog, &vsconstanttable);
1546 vsbinsize = vsbuffer->GetBufferSize();
1547 vsbin = (DWORD *)Mem_Alloc(tempmempool, vsbinsize);
1548 memcpy(vsbin, vsbuffer->GetBufferPointer(), vsbinsize);
1549 vsbuffer->Release();
1553 strlcpy(temp, (const char *)vslog->GetBufferPointer(), min(sizeof(temp), vslog->GetBufferSize()));
1554 Con_DPrintf("HLSL vertex shader compile output for %s follows:\n%s\n", cachename, temp);
1558 if (fragstring && fragstring[0])
1562 // psresult = qD3DXPreprocessShader(fragstring, strlen(fragstring), NULL, NULL, &psbuffer, &pslog);
1563 // FS_WriteFile(va(vabuf, sizeof(vabuf), "%s_ps.fx", cachename), psbuffer->GetBufferPointer(), psbuffer->GetBufferSize());
1564 FS_WriteFile(va(vabuf, sizeof(vabuf), "%s_ps.fx", cachename), fragstring, strlen(fragstring));
1565 psresult = qD3DXCompileShaderFromFileA(va(vabuf, sizeof(vabuf), "%s/%s_ps.fx", fs_gamedir, cachename), NULL, NULL, "main", psversion, shaderflags, &psbuffer, &pslog, &psconstanttable);
1568 psresult = qD3DXCompileShader(fragstring, strlen(fragstring), NULL, NULL, "main", psversion, shaderflags, &psbuffer, &pslog, &psconstanttable);
1571 psbinsize = psbuffer->GetBufferSize();
1572 psbin = (DWORD *)Mem_Alloc(tempmempool, psbinsize);
1573 memcpy(psbin, psbuffer->GetBufferPointer(), psbinsize);
1574 psbuffer->Release();
1578 strlcpy(temp, (const char *)pslog->GetBufferPointer(), min(sizeof(temp), pslog->GetBufferSize()));
1579 Con_DPrintf("HLSL pixel shader compile output for %s follows:\n%s\n", cachename, temp);
1583 Sys_UnloadLibrary(&d3dx9_dll);
1586 Con_DPrintf("Unable to compile shader - D3DXCompileShader function not found\n");
1590 vsresult = IDirect3DDevice9_CreateVertexShader(vid_d3d9dev, vsbin, &p->vertexshader);
1591 if (FAILED(vsresult))
1592 Con_DPrintf("HLSL CreateVertexShader failed for %s (hresult = %8x)\n", cachename, vsresult);
1593 psresult = IDirect3DDevice9_CreatePixelShader(vid_d3d9dev, psbin, &p->pixelshader);
1594 if (FAILED(psresult))
1595 Con_DPrintf("HLSL CreatePixelShader failed for %s (hresult = %8x)\n", cachename, psresult);
1597 // free the shader data
1598 vsbin = (DWORD *)Mem_Realloc(tempmempool, vsbin, 0);
1599 psbin = (DWORD *)Mem_Realloc(tempmempool, psbin, 0);
1602 static void R_HLSL_CompilePermutation(r_hlsl_permutation_t *p, unsigned int mode, unsigned int permutation)
1605 shadermodeinfo_t *modeinfo = hlslshadermodeinfo + mode;
1606 int vertstring_length = 0;
1607 int geomstring_length = 0;
1608 int fragstring_length = 0;
1610 char *vertexstring, *geometrystring, *fragmentstring;
1611 char *vertstring, *geomstring, *fragstring;
1612 char permutationname[256];
1613 char cachename[256];
1614 int vertstrings_count = 0;
1615 int geomstrings_count = 0;
1616 int fragstrings_count = 0;
1617 const char *vertstrings_list[32+5+SHADERSTATICPARMS_COUNT+1];
1618 const char *geomstrings_list[32+5+SHADERSTATICPARMS_COUNT+1];
1619 const char *fragstrings_list[32+5+SHADERSTATICPARMS_COUNT+1];
1624 p->vertexshader = NULL;
1625 p->pixelshader = NULL;
1627 permutationname[0] = 0;
1629 vertexstring = R_HLSL_GetText(modeinfo->vertexfilename, true);
1630 geometrystring = R_HLSL_GetText(modeinfo->geometryfilename, false);
1631 fragmentstring = R_HLSL_GetText(modeinfo->fragmentfilename, false);
1633 strlcat(permutationname, modeinfo->vertexfilename, sizeof(permutationname));
1634 strlcat(cachename, "hlsl/", sizeof(cachename));
1636 // define HLSL so that the shader can tell apart the HLSL compiler and the Cg compiler
1637 vertstrings_count = 0;
1638 geomstrings_count = 0;
1639 fragstrings_count = 0;
1640 vertstrings_list[vertstrings_count++] = "#define HLSL\n";
1641 geomstrings_list[geomstrings_count++] = "#define HLSL\n";
1642 fragstrings_list[fragstrings_count++] = "#define HLSL\n";
1644 // the first pretext is which type of shader to compile as
1645 // (later these will all be bound together as a program object)
1646 vertstrings_list[vertstrings_count++] = "#define VERTEX_SHADER\n";
1647 geomstrings_list[geomstrings_count++] = "#define GEOMETRY_SHADER\n";
1648 fragstrings_list[fragstrings_count++] = "#define FRAGMENT_SHADER\n";
1650 // the second pretext is the mode (for example a light source)
1651 vertstrings_list[vertstrings_count++] = modeinfo->pretext;
1652 geomstrings_list[geomstrings_count++] = modeinfo->pretext;
1653 fragstrings_list[fragstrings_count++] = modeinfo->pretext;
1654 strlcat(permutationname, modeinfo->name, sizeof(permutationname));
1655 strlcat(cachename, modeinfo->name, sizeof(cachename));
1657 // now add all the permutation pretexts
1658 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
1660 if (permutation & (1<<i))
1662 vertstrings_list[vertstrings_count++] = shaderpermutationinfo[i].pretext;
1663 geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i].pretext;
1664 fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i].pretext;
1665 strlcat(permutationname, shaderpermutationinfo[i].name, sizeof(permutationname));
1666 strlcat(cachename, shaderpermutationinfo[i].name, sizeof(cachename));
1670 // keep line numbers correct
1671 vertstrings_list[vertstrings_count++] = "\n";
1672 geomstrings_list[geomstrings_count++] = "\n";
1673 fragstrings_list[fragstrings_count++] = "\n";
1678 R_CompileShader_AddStaticParms(mode, permutation);
1679 memcpy(vertstrings_list + vertstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
1680 vertstrings_count += shaderstaticparms_count;
1681 memcpy(geomstrings_list + geomstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
1682 geomstrings_count += shaderstaticparms_count;
1683 memcpy(fragstrings_list + fragstrings_count, shaderstaticparmstrings_list, sizeof(*vertstrings_list) * shaderstaticparms_count);
1684 fragstrings_count += shaderstaticparms_count;
1686 // replace spaces in the cachename with _ characters
1687 for (i = 0;cachename[i];i++)
1688 if (cachename[i] == ' ')
1691 // now append the shader text itself
1692 vertstrings_list[vertstrings_count++] = vertexstring;
1693 geomstrings_list[geomstrings_count++] = geometrystring;
1694 fragstrings_list[fragstrings_count++] = fragmentstring;
1696 // if any sources were NULL, clear the respective list
1698 vertstrings_count = 0;
1699 if (!geometrystring)
1700 geomstrings_count = 0;
1701 if (!fragmentstring)
1702 fragstrings_count = 0;
1704 vertstring_length = 0;
1705 for (i = 0;i < vertstrings_count;i++)
1706 vertstring_length += strlen(vertstrings_list[i]);
1707 vertstring = t = (char *)Mem_Alloc(tempmempool, vertstring_length + 1);
1708 for (i = 0;i < vertstrings_count;t += strlen(vertstrings_list[i]), i++)
1709 memcpy(t, vertstrings_list[i], strlen(vertstrings_list[i]));
1711 geomstring_length = 0;
1712 for (i = 0;i < geomstrings_count;i++)
1713 geomstring_length += strlen(geomstrings_list[i]);
1714 geomstring = t = (char *)Mem_Alloc(tempmempool, geomstring_length + 1);
1715 for (i = 0;i < geomstrings_count;t += strlen(geomstrings_list[i]), i++)
1716 memcpy(t, geomstrings_list[i], strlen(geomstrings_list[i]));
1718 fragstring_length = 0;
1719 for (i = 0;i < fragstrings_count;i++)
1720 fragstring_length += strlen(fragstrings_list[i]);
1721 fragstring = t = (char *)Mem_Alloc(tempmempool, fragstring_length + 1);
1722 for (i = 0;i < fragstrings_count;t += strlen(fragstrings_list[i]), i++)
1723 memcpy(t, fragstrings_list[i], strlen(fragstrings_list[i]));
1725 // try to load the cached shader, or generate one
1726 R_HLSL_CacheShader(p, cachename, vertstring, fragstring);
1728 if ((p->vertexshader || !vertstring[0]) && (p->pixelshader || !fragstring[0]))
1729 Con_DPrintf("^5HLSL shader %s compiled.\n", permutationname);
1731 Con_Printf("^1HLSL shader %s failed! some features may not work properly.\n", permutationname);
1735 Mem_Free(vertstring);
1737 Mem_Free(geomstring);
1739 Mem_Free(fragstring);
1741 Mem_Free(vertexstring);
1743 Mem_Free(geometrystring);
1745 Mem_Free(fragmentstring);
1748 static inline void hlslVSSetParameter16f(D3DVSREGISTER_t r, const float *a) {IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, a, 4);}
1749 static inline void hlslVSSetParameter4fv(D3DVSREGISTER_t r, const float *a) {IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, a, 1);}
1750 static inline void hlslVSSetParameter4f(D3DVSREGISTER_t r, float x, float y, float z, float w) {float temp[4];Vector4Set(temp, x, y, z, w);IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, temp, 1);}
1751 static inline void hlslVSSetParameter3f(D3DVSREGISTER_t r, float x, float y, float z) {float temp[4];Vector4Set(temp, x, y, z, 0);IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, temp, 1);}
1752 static inline void hlslVSSetParameter2f(D3DVSREGISTER_t r, float x, float y) {float temp[4];Vector4Set(temp, x, y, 0, 0);IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, temp, 1);}
1753 static inline void hlslVSSetParameter1f(D3DVSREGISTER_t r, float x) {float temp[4];Vector4Set(temp, x, 0, 0, 0);IDirect3DDevice9_SetVertexShaderConstantF(vid_d3d9dev, r, temp, 1);}
1755 static inline void hlslPSSetParameter16f(D3DPSREGISTER_t r, const float *a) {IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, a, 4);}
1756 static inline void hlslPSSetParameter4fv(D3DPSREGISTER_t r, const float *a) {IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, a, 1);}
1757 static inline void hlslPSSetParameter4f(D3DPSREGISTER_t r, float x, float y, float z, float w) {float temp[4];Vector4Set(temp, x, y, z, w);IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, temp, 1);}
1758 static inline void hlslPSSetParameter3f(D3DPSREGISTER_t r, float x, float y, float z) {float temp[4];Vector4Set(temp, x, y, z, 0);IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, temp, 1);}
1759 static inline void hlslPSSetParameter2f(D3DPSREGISTER_t r, float x, float y) {float temp[4];Vector4Set(temp, x, y, 0, 0);IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, temp, 1);}
1760 static inline void hlslPSSetParameter1f(D3DPSREGISTER_t r, float x) {float temp[4];Vector4Set(temp, x, 0, 0, 0);IDirect3DDevice9_SetPixelShaderConstantF(vid_d3d9dev, r, temp, 1);}
1762 void R_SetupShader_SetPermutationHLSL(unsigned int mode, unsigned int permutation)
1764 r_hlsl_permutation_t *perm = R_HLSL_FindPermutation(mode, permutation);
1765 if (r_hlsl_permutation != perm)
1767 r_hlsl_permutation = perm;
1768 if (!r_hlsl_permutation->vertexshader && !r_hlsl_permutation->pixelshader)
1770 if (!r_hlsl_permutation->compiled)
1771 R_HLSL_CompilePermutation(perm, mode, permutation);
1772 if (!r_hlsl_permutation->vertexshader && !r_hlsl_permutation->pixelshader)
1774 // remove features until we find a valid permutation
1776 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
1778 // reduce i more quickly whenever it would not remove any bits
1779 int j = 1<<(SHADERPERMUTATION_COUNT-1-i);
1780 if (!(permutation & j))
1783 r_hlsl_permutation = R_HLSL_FindPermutation(mode, permutation);
1784 if (!r_hlsl_permutation->compiled)
1785 R_HLSL_CompilePermutation(perm, mode, permutation);
1786 if (r_hlsl_permutation->vertexshader || r_hlsl_permutation->pixelshader)
1789 if (i >= SHADERPERMUTATION_COUNT)
1791 //Con_Printf("Could not find a working HLSL shader for permutation %s %s\n", shadermodeinfo[mode].vertexfilename, shadermodeinfo[mode].pretext);
1792 r_hlsl_permutation = R_HLSL_FindPermutation(mode, permutation);
1793 return; // no bit left to clear, entire mode is broken
1797 IDirect3DDevice9_SetVertexShader(vid_d3d9dev, r_hlsl_permutation->vertexshader);
1798 IDirect3DDevice9_SetPixelShader(vid_d3d9dev, r_hlsl_permutation->pixelshader);
1800 hlslVSSetParameter16f(D3DVSREGISTER_ModelViewProjectionMatrix, gl_modelviewprojection16f);
1801 hlslVSSetParameter16f(D3DVSREGISTER_ModelViewMatrix, gl_modelview16f);
1802 hlslPSSetParameter1f(D3DPSREGISTER_ClientTime, cl.time);
1806 static void R_SetupShader_SetPermutationSoft(unsigned int mode, unsigned int permutation)
1808 DPSOFTRAST_SetShader(mode, permutation, r_shadow_glossexact.integer);
1809 DPSOFTRAST_UniformMatrix4fv(DPSOFTRAST_UNIFORM_ModelViewProjectionMatrixM1, 1, false, gl_modelviewprojection16f);
1810 DPSOFTRAST_UniformMatrix4fv(DPSOFTRAST_UNIFORM_ModelViewMatrixM1, 1, false, gl_modelview16f);
1811 DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_ClientTime, cl.time);
1814 void R_GLSL_Restart_f(void)
1816 unsigned int i, limit;
1817 if (glslshaderstring && glslshaderstring != builtinshaderstring)
1818 Mem_Free(glslshaderstring);
1819 glslshaderstring = NULL;
1820 if (hlslshaderstring && hlslshaderstring != builtinhlslshaderstring)
1821 Mem_Free(hlslshaderstring);
1822 hlslshaderstring = NULL;
1823 switch(vid.renderpath)
1825 case RENDERPATH_D3D9:
1828 r_hlsl_permutation_t *p;
1829 r_hlsl_permutation = NULL;
1830 limit = Mem_ExpandableArray_IndexRange(&r_hlsl_permutationarray);
1831 for (i = 0;i < limit;i++)
1833 if ((p = (r_hlsl_permutation_t*)Mem_ExpandableArray_RecordAtIndex(&r_hlsl_permutationarray, i)))
1835 if (p->vertexshader)
1836 IDirect3DVertexShader9_Release(p->vertexshader);
1838 IDirect3DPixelShader9_Release(p->pixelshader);
1839 Mem_ExpandableArray_FreeRecord(&r_hlsl_permutationarray, (void*)p);
1842 memset(r_hlsl_permutationhash, 0, sizeof(r_hlsl_permutationhash));
1846 case RENDERPATH_D3D10:
1847 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1849 case RENDERPATH_D3D11:
1850 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1852 case RENDERPATH_GL20:
1853 case RENDERPATH_GLES2:
1855 r_glsl_permutation_t *p;
1856 r_glsl_permutation = NULL;
1857 limit = Mem_ExpandableArray_IndexRange(&r_glsl_permutationarray);
1858 for (i = 0;i < limit;i++)
1860 if ((p = (r_glsl_permutation_t*)Mem_ExpandableArray_RecordAtIndex(&r_glsl_permutationarray, i)))
1862 GL_Backend_FreeProgram(p->program);
1863 Mem_ExpandableArray_FreeRecord(&r_glsl_permutationarray, (void*)p);
1866 memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash));
1869 case RENDERPATH_GL11:
1870 case RENDERPATH_GL13:
1871 case RENDERPATH_GLES1:
1873 case RENDERPATH_SOFT:
1878 static void R_GLSL_DumpShader_f(void)
1883 file = FS_OpenRealFile("glsl/default.glsl", "w", false);
1886 FS_Print(file, "/* The engine may define the following macros:\n");
1887 FS_Print(file, "#define VERTEX_SHADER\n#define GEOMETRY_SHADER\n#define FRAGMENT_SHADER\n");
1888 for (i = 0;i < SHADERMODE_COUNT;i++)
1889 FS_Print(file, glslshadermodeinfo[i].pretext);
1890 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
1891 FS_Print(file, shaderpermutationinfo[i].pretext);
1892 FS_Print(file, "*/\n");
1893 FS_Print(file, builtinshaderstring);
1895 Con_Printf("glsl/default.glsl written\n");
1898 Con_Printf("failed to write to glsl/default.glsl\n");
1900 file = FS_OpenRealFile("hlsl/default.hlsl", "w", false);
1903 FS_Print(file, "/* The engine may define the following macros:\n");
1904 FS_Print(file, "#define VERTEX_SHADER\n#define GEOMETRY_SHADER\n#define FRAGMENT_SHADER\n");
1905 for (i = 0;i < SHADERMODE_COUNT;i++)
1906 FS_Print(file, hlslshadermodeinfo[i].pretext);
1907 for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
1908 FS_Print(file, shaderpermutationinfo[i].pretext);
1909 FS_Print(file, "*/\n");
1910 FS_Print(file, builtinhlslshaderstring);
1912 Con_Printf("hlsl/default.hlsl written\n");
1915 Con_Printf("failed to write to hlsl/default.hlsl\n");
1918 void R_SetupShader_Generic(rtexture_t *first, rtexture_t *second, int texturemode, int rgbscale, qboolean usegamma, qboolean notrippy, qboolean suppresstexalpha)
1920 unsigned int permutation = 0;
1921 if (r_trippy.integer && !notrippy)
1922 permutation |= SHADERPERMUTATION_TRIPPY;
1923 permutation |= SHADERPERMUTATION_VIEWTINT;
1925 permutation |= SHADERPERMUTATION_DIFFUSE;
1927 permutation |= SHADERPERMUTATION_SPECULAR;
1928 if (texturemode == GL_MODULATE)
1929 permutation |= SHADERPERMUTATION_COLORMAPPING;
1930 else if (texturemode == GL_ADD)
1931 permutation |= SHADERPERMUTATION_GLOW;
1932 else if (texturemode == GL_DECAL)
1933 permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
1934 if (usegamma && v_glslgamma.integer && v_glslgamma_2d.integer && !vid.sRGB2D && r_texture_gammaramps && !vid_gammatables_trivial)
1935 permutation |= SHADERPERMUTATION_GAMMARAMPS;
1936 if (suppresstexalpha)
1937 permutation |= SHADERPERMUTATION_REFLECTCUBE;
1939 texturemode = GL_MODULATE;
1940 if (vid.allowalphatocoverage)
1941 GL_AlphaToCoverage(false);
1942 switch (vid.renderpath)
1944 case RENDERPATH_D3D9:
1946 R_SetupShader_SetPermutationHLSL(SHADERMODE_GENERIC, permutation);
1947 R_Mesh_TexBind(GL20TU_FIRST , first );
1948 R_Mesh_TexBind(GL20TU_SECOND, second);
1949 if (permutation & SHADERPERMUTATION_GAMMARAMPS)
1950 R_Mesh_TexBind(r_glsl_permutation->tex_Texture_GammaRamps, r_texture_gammaramps);
1953 case RENDERPATH_D3D10:
1954 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1956 case RENDERPATH_D3D11:
1957 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
1959 case RENDERPATH_GL20:
1960 case RENDERPATH_GLES2:
1961 R_SetupShader_SetPermutationGLSL(SHADERMODE_GENERIC, permutation);
1962 R_Mesh_TexBind(r_glsl_permutation->tex_Texture_First , first );
1963 R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Second, second);
1964 if (r_glsl_permutation->tex_Texture_GammaRamps >= 0)
1965 R_Mesh_TexBind(r_glsl_permutation->tex_Texture_GammaRamps, r_texture_gammaramps);
1967 case RENDERPATH_GL13:
1968 case RENDERPATH_GLES1:
1969 R_Mesh_TexBind(0, first );
1970 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
1971 R_Mesh_TexBind(1, second);
1973 R_Mesh_TexCombine(1, texturemode, texturemode, rgbscale, 1);
1975 case RENDERPATH_GL11:
1976 R_Mesh_TexBind(0, first );
1978 case RENDERPATH_SOFT:
1979 R_SetupShader_SetPermutationSoft(SHADERMODE_GENERIC, permutation);
1980 R_Mesh_TexBind(GL20TU_FIRST , first );
1981 R_Mesh_TexBind(GL20TU_SECOND, second);
1986 void R_SetupShader_Generic_NoTexture(qboolean usegamma, qboolean notrippy)
1988 R_SetupShader_Generic(NULL, NULL, GL_MODULATE, 1, usegamma, notrippy, false);
1991 void R_SetupShader_DepthOrShadow(qboolean notrippy, qboolean depthrgb)
1993 unsigned int permutation = 0;
1994 if (r_trippy.integer && !notrippy)
1995 permutation |= SHADERPERMUTATION_TRIPPY;
1997 permutation |= SHADERPERMUTATION_DEPTHRGB;
1998 if (vid.allowalphatocoverage)
1999 GL_AlphaToCoverage(false);
2000 switch (vid.renderpath)
2002 case RENDERPATH_D3D9:
2004 R_SetupShader_SetPermutationHLSL(SHADERMODE_DEPTH_OR_SHADOW, permutation);
2007 case RENDERPATH_D3D10:
2008 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2010 case RENDERPATH_D3D11:
2011 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2013 case RENDERPATH_GL20:
2014 case RENDERPATH_GLES2:
2015 R_SetupShader_SetPermutationGLSL(SHADERMODE_DEPTH_OR_SHADOW, permutation);
2017 case RENDERPATH_GL13:
2018 case RENDERPATH_GLES1:
2019 R_Mesh_TexBind(0, 0);
2020 R_Mesh_TexBind(1, 0);
2022 case RENDERPATH_GL11:
2023 R_Mesh_TexBind(0, 0);
2025 case RENDERPATH_SOFT:
2026 R_SetupShader_SetPermutationSoft(SHADERMODE_DEPTH_OR_SHADOW, permutation);
2031 void R_SetupShader_ShowDepth(qboolean notrippy)
2033 int permutation = 0;
2034 if (r_trippy.integer && !notrippy)
2035 permutation |= SHADERPERMUTATION_TRIPPY;
2036 if (vid.allowalphatocoverage)
2037 GL_AlphaToCoverage(false);
2038 switch (vid.renderpath)
2040 case RENDERPATH_D3D9:
2042 R_SetupShader_SetPermutationHLSL(SHADERMODE_SHOWDEPTH, permutation);
2045 case RENDERPATH_D3D10:
2046 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2048 case RENDERPATH_D3D11:
2049 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2051 case RENDERPATH_GL20:
2052 case RENDERPATH_GLES2:
2053 R_SetupShader_SetPermutationGLSL(SHADERMODE_SHOWDEPTH, permutation);
2055 case RENDERPATH_GL13:
2056 case RENDERPATH_GLES1:
2058 case RENDERPATH_GL11:
2060 case RENDERPATH_SOFT:
2061 R_SetupShader_SetPermutationSoft(SHADERMODE_SHOWDEPTH, permutation);
2066 extern qboolean r_shadow_usingdeferredprepass;
2067 extern rtexture_t *r_shadow_attenuationgradienttexture;
2068 extern rtexture_t *r_shadow_attenuation2dtexture;
2069 extern rtexture_t *r_shadow_attenuation3dtexture;
2070 extern qboolean r_shadow_usingshadowmap2d;
2071 extern qboolean r_shadow_usingshadowmaportho;
2072 extern float r_shadow_shadowmap_texturescale[2];
2073 extern float r_shadow_shadowmap_parameters[4];
2074 extern qboolean r_shadow_shadowmapvsdct;
2075 extern rtexture_t *r_shadow_shadowmap2ddepthbuffer;
2076 extern rtexture_t *r_shadow_shadowmap2ddepthtexture;
2077 extern rtexture_t *r_shadow_shadowmapvsdcttexture;
2078 extern matrix4x4_t r_shadow_shadowmapmatrix;
2079 extern int r_shadow_shadowmaplod; // changes for each light based on distance
2080 extern int r_shadow_prepass_width;
2081 extern int r_shadow_prepass_height;
2082 extern rtexture_t *r_shadow_prepassgeometrydepthbuffer;
2083 extern rtexture_t *r_shadow_prepassgeometrynormalmaptexture;
2084 extern rtexture_t *r_shadow_prepasslightingdiffusetexture;
2085 extern rtexture_t *r_shadow_prepasslightingspeculartexture;
2087 #define BLENDFUNC_ALLOWS_COLORMOD 1
2088 #define BLENDFUNC_ALLOWS_FOG 2
2089 #define BLENDFUNC_ALLOWS_FOG_HACK0 4
2090 #define BLENDFUNC_ALLOWS_FOG_HACKALPHA 8
2091 #define BLENDFUNC_ALLOWS_ANYFOG (BLENDFUNC_ALLOWS_FOG | BLENDFUNC_ALLOWS_FOG_HACK0 | BLENDFUNC_ALLOWS_FOG_HACKALPHA)
2092 static int R_BlendFuncFlags(int src, int dst)
2096 // a blendfunc allows colormod if:
2097 // a) it can never keep the destination pixel invariant, or
2098 // b) it can keep the destination pixel invariant, and still can do so if colormodded
2099 // this is to prevent unintended side effects from colormod
2101 // a blendfunc allows fog if:
2102 // blend(fog(src), fog(dst)) == fog(blend(src, dst))
2103 // this is to prevent unintended side effects from fog
2105 // these checks are the output of fogeval.pl
2107 r |= BLENDFUNC_ALLOWS_COLORMOD;
2108 if(src == GL_DST_ALPHA && dst == GL_ONE) r |= BLENDFUNC_ALLOWS_FOG_HACK0;
2109 if(src == GL_DST_ALPHA && dst == GL_ONE_MINUS_DST_ALPHA) r |= BLENDFUNC_ALLOWS_FOG;
2110 if(src == GL_DST_COLOR && dst == GL_ONE_MINUS_SRC_ALPHA) r &= ~BLENDFUNC_ALLOWS_COLORMOD;
2111 if(src == GL_DST_COLOR && dst == GL_ONE_MINUS_SRC_COLOR) r |= BLENDFUNC_ALLOWS_FOG;
2112 if(src == GL_DST_COLOR && dst == GL_SRC_ALPHA) r &= ~BLENDFUNC_ALLOWS_COLORMOD;
2113 if(src == GL_DST_COLOR && dst == GL_SRC_COLOR) r &= ~BLENDFUNC_ALLOWS_COLORMOD;
2114 if(src == GL_DST_COLOR && dst == GL_ZERO) r &= ~BLENDFUNC_ALLOWS_COLORMOD;
2115 if(src == GL_ONE && dst == GL_ONE) r |= BLENDFUNC_ALLOWS_FOG_HACK0;
2116 if(src == GL_ONE && dst == GL_ONE_MINUS_SRC_ALPHA) r |= BLENDFUNC_ALLOWS_FOG_HACKALPHA;
2117 if(src == GL_ONE && dst == GL_ZERO) r |= BLENDFUNC_ALLOWS_FOG;
2118 if(src == GL_ONE_MINUS_DST_ALPHA && dst == GL_DST_ALPHA) r |= BLENDFUNC_ALLOWS_FOG;
2119 if(src == GL_ONE_MINUS_DST_ALPHA && dst == GL_ONE) r |= BLENDFUNC_ALLOWS_FOG_HACK0;
2120 if(src == GL_ONE_MINUS_DST_COLOR && dst == GL_SRC_COLOR) r |= BLENDFUNC_ALLOWS_FOG;
2121 if(src == GL_ONE_MINUS_SRC_ALPHA && dst == GL_ONE) r |= BLENDFUNC_ALLOWS_FOG_HACK0;
2122 if(src == GL_ONE_MINUS_SRC_ALPHA && dst == GL_SRC_ALPHA) r |= BLENDFUNC_ALLOWS_FOG;
2123 if(src == GL_ONE_MINUS_SRC_ALPHA && dst == GL_SRC_COLOR) r &= ~BLENDFUNC_ALLOWS_COLORMOD;
2124 if(src == GL_ONE_MINUS_SRC_COLOR && dst == GL_SRC_COLOR) r &= ~BLENDFUNC_ALLOWS_COLORMOD;
2125 if(src == GL_SRC_ALPHA && dst == GL_ONE) r |= BLENDFUNC_ALLOWS_FOG_HACK0;
2126 if(src == GL_SRC_ALPHA && dst == GL_ONE_MINUS_SRC_ALPHA) r |= BLENDFUNC_ALLOWS_FOG;
2127 if(src == GL_ZERO && dst == GL_ONE) r |= BLENDFUNC_ALLOWS_FOG;
2128 if(src == GL_ZERO && dst == GL_SRC_COLOR) r &= ~BLENDFUNC_ALLOWS_COLORMOD;
2133 void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, float ambientscale, float diffusescale, float specularscale, rsurfacepass_t rsurfacepass, int texturenumsurfaces, const msurface_t **texturesurfacelist, void *surfacewaterplane, qboolean notrippy)
2135 // select a permutation of the lighting shader appropriate to this
2136 // combination of texture, entity, light source, and fogging, only use the
2137 // minimum features necessary to avoid wasting rendering time in the
2138 // fragment shader on features that are not being used
2139 unsigned int permutation = 0;
2140 unsigned int mode = 0;
2142 static float dummy_colormod[3] = {1, 1, 1};
2143 float *colormod = rsurface.colormod;
2145 matrix4x4_t tempmatrix;
2146 r_waterstate_waterplane_t *waterplane = (r_waterstate_waterplane_t *)surfacewaterplane;
2147 if (r_trippy.integer && !notrippy)
2148 permutation |= SHADERPERMUTATION_TRIPPY;
2149 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
2150 permutation |= SHADERPERMUTATION_ALPHAKILL;
2151 if (rsurface.texture->r_water_waterscroll[0] && rsurface.texture->r_water_waterscroll[1])
2152 permutation |= SHADERPERMUTATION_NORMALMAPSCROLLBLEND; // todo: make generic
2153 if (rsurfacepass == RSURFPASS_BACKGROUND)
2155 // distorted background
2156 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERSHADER)
2158 mode = SHADERMODE_WATER;
2159 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHAGEN_VERTEX)
2160 permutation |= SHADERPERMUTATION_ALPHAGEN_VERTEX;
2161 if((r_wateralpha.value < 1) && (rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERALPHA))
2163 // this is the right thing to do for wateralpha
2164 GL_BlendFunc(GL_ONE, GL_ZERO);
2165 blendfuncflags = R_BlendFuncFlags(GL_ONE, GL_ZERO);
2169 // this is the right thing to do for entity alpha
2170 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2171 blendfuncflags = R_BlendFuncFlags(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2174 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFRACTION)
2176 mode = SHADERMODE_REFRACTION;
2177 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHAGEN_VERTEX)
2178 permutation |= SHADERPERMUTATION_ALPHAGEN_VERTEX;
2179 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2180 blendfuncflags = R_BlendFuncFlags(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2184 mode = SHADERMODE_GENERIC;
2185 permutation |= SHADERPERMUTATION_DIFFUSE;
2186 GL_BlendFunc(GL_ONE, GL_ZERO);
2187 blendfuncflags = R_BlendFuncFlags(GL_ONE, GL_ZERO);
2189 if (vid.allowalphatocoverage)
2190 GL_AlphaToCoverage(false);
2192 else if (rsurfacepass == RSURFPASS_DEFERREDGEOMETRY)
2194 if (r_glsl_offsetmapping.integer && ((R_TextureFlags(rsurface.texture->nmaptexture) & TEXF_ALPHA) || rsurface.texture->offsetbias != 0.0f))
2196 switch(rsurface.texture->offsetmapping)
2198 case OFFSETMAPPING_LINEAR: permutation |= SHADERPERMUTATION_OFFSETMAPPING;break;
2199 case OFFSETMAPPING_RELIEF: permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;break;
2200 case OFFSETMAPPING_DEFAULT: permutation |= SHADERPERMUTATION_OFFSETMAPPING;if (r_glsl_offsetmapping_reliefmapping.integer) permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;break;
2201 case OFFSETMAPPING_OFF: break;
2204 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
2205 permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
2206 // normalmap (deferred prepass), may use alpha test on diffuse
2207 mode = SHADERMODE_DEFERREDGEOMETRY;
2208 GL_BlendFunc(GL_ONE, GL_ZERO);
2209 blendfuncflags = R_BlendFuncFlags(GL_ONE, GL_ZERO);
2210 if (vid.allowalphatocoverage)
2211 GL_AlphaToCoverage(false);
2213 else if (rsurfacepass == RSURFPASS_RTLIGHT)
2215 if (r_glsl_offsetmapping.integer && ((R_TextureFlags(rsurface.texture->nmaptexture) & TEXF_ALPHA) || rsurface.texture->offsetbias != 0.0f))
2217 switch(rsurface.texture->offsetmapping)
2219 case OFFSETMAPPING_LINEAR: permutation |= SHADERPERMUTATION_OFFSETMAPPING;break;
2220 case OFFSETMAPPING_RELIEF: permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;break;
2221 case OFFSETMAPPING_DEFAULT: permutation |= SHADERPERMUTATION_OFFSETMAPPING;if (r_glsl_offsetmapping_reliefmapping.integer) permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;break;
2222 case OFFSETMAPPING_OFF: break;
2225 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
2226 permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
2227 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHAGEN_VERTEX)
2228 permutation |= SHADERPERMUTATION_ALPHAGEN_VERTEX;
2230 mode = SHADERMODE_LIGHTSOURCE;
2231 if (rsurface.rtlight->currentcubemap != r_texture_whitecube)
2232 permutation |= SHADERPERMUTATION_CUBEFILTER;
2233 if (diffusescale > 0)
2234 permutation |= SHADERPERMUTATION_DIFFUSE;
2235 if (specularscale > 0)
2236 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
2237 if (r_refdef.fogenabled)
2238 permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
2239 if (rsurface.texture->colormapping)
2240 permutation |= SHADERPERMUTATION_COLORMAPPING;
2241 if (r_shadow_usingshadowmap2d)
2243 permutation |= SHADERPERMUTATION_SHADOWMAP2D;
2244 if(r_shadow_shadowmapvsdct)
2245 permutation |= SHADERPERMUTATION_SHADOWMAPVSDCT;
2247 if (r_shadow_shadowmap2ddepthbuffer)
2248 permutation |= SHADERPERMUTATION_DEPTHRGB;
2250 if (rsurface.texture->reflectmasktexture)
2251 permutation |= SHADERPERMUTATION_REFLECTCUBE;
2252 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2253 blendfuncflags = R_BlendFuncFlags(GL_SRC_ALPHA, GL_ONE);
2254 if (vid.allowalphatocoverage)
2255 GL_AlphaToCoverage(false);
2257 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
2259 if (r_glsl_offsetmapping.integer && ((R_TextureFlags(rsurface.texture->nmaptexture) & TEXF_ALPHA) || rsurface.texture->offsetbias != 0.0f))
2261 switch(rsurface.texture->offsetmapping)
2263 case OFFSETMAPPING_LINEAR: permutation |= SHADERPERMUTATION_OFFSETMAPPING;break;
2264 case OFFSETMAPPING_RELIEF: permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;break;
2265 case OFFSETMAPPING_DEFAULT: permutation |= SHADERPERMUTATION_OFFSETMAPPING;if (r_glsl_offsetmapping_reliefmapping.integer) permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;break;
2266 case OFFSETMAPPING_OFF: break;
2269 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
2270 permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
2271 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHAGEN_VERTEX)
2272 permutation |= SHADERPERMUTATION_ALPHAGEN_VERTEX;
2273 // unshaded geometry (fullbright or ambient model lighting)
2274 mode = SHADERMODE_FLATCOLOR;
2275 ambientscale = diffusescale = specularscale = 0;
2276 if ((rsurface.texture->glowtexture || rsurface.texture->backgroundglowtexture) && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
2277 permutation |= SHADERPERMUTATION_GLOW;
2278 if (r_refdef.fogenabled)
2279 permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
2280 if (rsurface.texture->colormapping)
2281 permutation |= SHADERPERMUTATION_COLORMAPPING;
2282 if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
2284 permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
2285 permutation |= SHADERPERMUTATION_SHADOWMAP2D;
2287 if (r_shadow_shadowmap2ddepthbuffer)
2288 permutation |= SHADERPERMUTATION_DEPTHRGB;
2290 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
2291 permutation |= SHADERPERMUTATION_REFLECTION;
2292 if (rsurface.texture->reflectmasktexture)
2293 permutation |= SHADERPERMUTATION_REFLECTCUBE;
2294 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
2295 blendfuncflags = R_BlendFuncFlags(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
2296 // when using alphatocoverage, we don't need alphakill
2297 if (vid.allowalphatocoverage)
2299 if (r_transparent_alphatocoverage.integer)
2301 GL_AlphaToCoverage((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
2302 permutation &= ~SHADERPERMUTATION_ALPHAKILL;
2305 GL_AlphaToCoverage(false);
2308 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT_DIRECTIONAL)
2310 if (r_glsl_offsetmapping.integer && ((R_TextureFlags(rsurface.texture->nmaptexture) & TEXF_ALPHA) || rsurface.texture->offsetbias != 0.0f))
2312 switch(rsurface.texture->offsetmapping)
2314 case OFFSETMAPPING_LINEAR: permutation |= SHADERPERMUTATION_OFFSETMAPPING;break;
2315 case OFFSETMAPPING_RELIEF: permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;break;
2316 case OFFSETMAPPING_DEFAULT: permutation |= SHADERPERMUTATION_OFFSETMAPPING;if (r_glsl_offsetmapping_reliefmapping.integer) permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;break;
2317 case OFFSETMAPPING_OFF: break;
2320 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
2321 permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
2322 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHAGEN_VERTEX)
2323 permutation |= SHADERPERMUTATION_ALPHAGEN_VERTEX;
2324 // directional model lighting
2325 mode = SHADERMODE_LIGHTDIRECTION;
2326 if ((rsurface.texture->glowtexture || rsurface.texture->backgroundglowtexture) && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
2327 permutation |= SHADERPERMUTATION_GLOW;
2328 permutation |= SHADERPERMUTATION_DIFFUSE;
2329 if (specularscale > 0)
2330 permutation |= SHADERPERMUTATION_SPECULAR;
2331 if (r_refdef.fogenabled)
2332 permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
2333 if (rsurface.texture->colormapping)
2334 permutation |= SHADERPERMUTATION_COLORMAPPING;
2335 if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
2337 permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
2338 permutation |= SHADERPERMUTATION_SHADOWMAP2D;
2340 if (r_shadow_shadowmap2ddepthbuffer)
2341 permutation |= SHADERPERMUTATION_DEPTHRGB;
2343 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
2344 permutation |= SHADERPERMUTATION_REFLECTION;
2345 if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED))
2346 permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
2347 if (rsurface.texture->reflectmasktexture)
2348 permutation |= SHADERPERMUTATION_REFLECTCUBE;
2349 if (r_shadow_bouncegridtexture && cl.csqc_vidvars.drawworld)
2351 permutation |= SHADERPERMUTATION_BOUNCEGRID;
2352 if (r_shadow_bouncegriddirectional)
2353 permutation |= SHADERPERMUTATION_BOUNCEGRIDDIRECTIONAL;
2355 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
2356 blendfuncflags = R_BlendFuncFlags(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
2357 // when using alphatocoverage, we don't need alphakill
2358 if (vid.allowalphatocoverage)
2360 if (r_transparent_alphatocoverage.integer)
2362 GL_AlphaToCoverage((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
2363 permutation &= ~SHADERPERMUTATION_ALPHAKILL;
2366 GL_AlphaToCoverage(false);
2369 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
2371 if (r_glsl_offsetmapping.integer && ((R_TextureFlags(rsurface.texture->nmaptexture) & TEXF_ALPHA) || rsurface.texture->offsetbias != 0.0f))
2373 switch(rsurface.texture->offsetmapping)
2375 case OFFSETMAPPING_LINEAR: permutation |= SHADERPERMUTATION_OFFSETMAPPING;break;
2376 case OFFSETMAPPING_RELIEF: permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;break;
2377 case OFFSETMAPPING_DEFAULT: permutation |= SHADERPERMUTATION_OFFSETMAPPING;if (r_glsl_offsetmapping_reliefmapping.integer) permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;break;
2378 case OFFSETMAPPING_OFF: break;
2381 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
2382 permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
2383 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHAGEN_VERTEX)
2384 permutation |= SHADERPERMUTATION_ALPHAGEN_VERTEX;
2385 // ambient model lighting
2386 mode = SHADERMODE_LIGHTDIRECTION;
2387 if ((rsurface.texture->glowtexture || rsurface.texture->backgroundglowtexture) && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
2388 permutation |= SHADERPERMUTATION_GLOW;
2389 if (r_refdef.fogenabled)
2390 permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
2391 if (rsurface.texture->colormapping)
2392 permutation |= SHADERPERMUTATION_COLORMAPPING;
2393 if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
2395 permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
2396 permutation |= SHADERPERMUTATION_SHADOWMAP2D;
2398 if (r_shadow_shadowmap2ddepthbuffer)
2399 permutation |= SHADERPERMUTATION_DEPTHRGB;
2401 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
2402 permutation |= SHADERPERMUTATION_REFLECTION;
2403 if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED))
2404 permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
2405 if (rsurface.texture->reflectmasktexture)
2406 permutation |= SHADERPERMUTATION_REFLECTCUBE;
2407 if (r_shadow_bouncegridtexture && cl.csqc_vidvars.drawworld)
2409 permutation |= SHADERPERMUTATION_BOUNCEGRID;
2410 if (r_shadow_bouncegriddirectional)
2411 permutation |= SHADERPERMUTATION_BOUNCEGRIDDIRECTIONAL;
2413 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
2414 blendfuncflags = R_BlendFuncFlags(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
2415 // when using alphatocoverage, we don't need alphakill
2416 if (vid.allowalphatocoverage)
2418 if (r_transparent_alphatocoverage.integer)
2420 GL_AlphaToCoverage((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
2421 permutation &= ~SHADERPERMUTATION_ALPHAKILL;
2424 GL_AlphaToCoverage(false);
2429 if (r_glsl_offsetmapping.integer && ((R_TextureFlags(rsurface.texture->nmaptexture) & TEXF_ALPHA) || rsurface.texture->offsetbias != 0.0f))
2431 switch(rsurface.texture->offsetmapping)
2433 case OFFSETMAPPING_LINEAR: permutation |= SHADERPERMUTATION_OFFSETMAPPING;break;
2434 case OFFSETMAPPING_RELIEF: permutation |= SHADERPERMUTATION_OFFSETMAPPING | SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;break;
2435 case OFFSETMAPPING_DEFAULT: permutation |= SHADERPERMUTATION_OFFSETMAPPING;if (r_glsl_offsetmapping_reliefmapping.integer) permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING;break;
2436 case OFFSETMAPPING_OFF: break;
2439 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_VERTEXTEXTUREBLEND)
2440 permutation |= SHADERPERMUTATION_VERTEXTEXTUREBLEND;
2441 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHAGEN_VERTEX)
2442 permutation |= SHADERPERMUTATION_ALPHAGEN_VERTEX;
2444 if ((rsurface.texture->glowtexture || rsurface.texture->backgroundglowtexture) && r_hdr_glowintensity.value > 0 && !gl_lightmaps.integer)
2445 permutation |= SHADERPERMUTATION_GLOW;
2446 if (r_refdef.fogenabled)
2447 permutation |= r_texture_fogheighttexture ? SHADERPERMUTATION_FOGHEIGHTTEXTURE : (r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE);
2448 if (rsurface.texture->colormapping)
2449 permutation |= SHADERPERMUTATION_COLORMAPPING;
2450 if (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW))
2452 permutation |= SHADERPERMUTATION_SHADOWMAPORTHO;
2453 permutation |= SHADERPERMUTATION_SHADOWMAP2D;
2455 if (r_shadow_shadowmap2ddepthbuffer)
2456 permutation |= SHADERPERMUTATION_DEPTHRGB;
2458 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION)
2459 permutation |= SHADERPERMUTATION_REFLECTION;
2460 if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED))
2461 permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP;
2462 if (rsurface.texture->reflectmasktexture)
2463 permutation |= SHADERPERMUTATION_REFLECTCUBE;
2464 if (FAKELIGHT_ENABLED)
2466 // fake lightmapping (q1bsp, q3bsp, fullbright map)
2467 mode = SHADERMODE_FAKELIGHT;
2468 permutation |= SHADERPERMUTATION_DIFFUSE;
2469 if (specularscale > 0)
2470 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
2472 else if (r_glsl_deluxemapping.integer >= 1 && rsurface.uselightmaptexture && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brushq3.deluxemapping)
2474 // deluxemapping (light direction texture)
2475 if (rsurface.uselightmaptexture && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brushq3.deluxemapping && r_refdef.scene.worldmodel->brushq3.deluxemapping_modelspace)
2476 mode = SHADERMODE_LIGHTDIRECTIONMAP_MODELSPACE;
2478 mode = SHADERMODE_LIGHTDIRECTIONMAP_TANGENTSPACE;
2479 permutation |= SHADERPERMUTATION_DIFFUSE;
2480 if (specularscale > 0)
2481 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
2483 else if (r_glsl_deluxemapping.integer >= 2)
2485 // fake deluxemapping (uniform light direction in tangentspace)
2486 if (rsurface.uselightmaptexture)
2487 mode = SHADERMODE_LIGHTDIRECTIONMAP_FORCED_LIGHTMAP;
2489 mode = SHADERMODE_LIGHTDIRECTIONMAP_FORCED_VERTEXCOLOR;
2490 permutation |= SHADERPERMUTATION_DIFFUSE;
2491 if (specularscale > 0)
2492 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
2494 else if (rsurface.uselightmaptexture)
2496 // ordinary lightmapping (q1bsp, q3bsp)
2497 mode = SHADERMODE_LIGHTMAP;
2501 // ordinary vertex coloring (q3bsp)
2502 mode = SHADERMODE_VERTEXCOLOR;
2504 if (r_shadow_bouncegridtexture && cl.csqc_vidvars.drawworld)
2506 permutation |= SHADERPERMUTATION_BOUNCEGRID;
2507 if (r_shadow_bouncegriddirectional)
2508 permutation |= SHADERPERMUTATION_BOUNCEGRIDDIRECTIONAL;
2510 GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
2511 blendfuncflags = R_BlendFuncFlags(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2);
2512 // when using alphatocoverage, we don't need alphakill
2513 if (vid.allowalphatocoverage)
2515 if (r_transparent_alphatocoverage.integer)
2517 GL_AlphaToCoverage((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
2518 permutation &= ~SHADERPERMUTATION_ALPHAKILL;
2521 GL_AlphaToCoverage(false);
2524 if(!(blendfuncflags & BLENDFUNC_ALLOWS_COLORMOD))
2525 colormod = dummy_colormod;
2526 if(!(blendfuncflags & BLENDFUNC_ALLOWS_ANYFOG))
2527 permutation &= ~(SHADERPERMUTATION_FOGHEIGHTTEXTURE | SHADERPERMUTATION_FOGOUTSIDE | SHADERPERMUTATION_FOGINSIDE);
2528 if(blendfuncflags & BLENDFUNC_ALLOWS_FOG_HACKALPHA)
2529 permutation |= SHADERPERMUTATION_FOGALPHAHACK;
2530 switch(vid.renderpath)
2532 case RENDERPATH_D3D9:
2534 RSurf_PrepareVerticesForBatch(BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | (rsurface.modellightmapcolor4f ? BATCHNEED_VERTEXMESH_VERTEXCOLOR : 0) | BATCHNEED_VERTEXMESH_TEXCOORD | (rsurface.uselightmaptexture ? BATCHNEED_VERTEXMESH_LIGHTMAP : 0), texturenumsurfaces, texturesurfacelist);
2535 R_Mesh_PrepareVertices_Mesh(rsurface.batchnumvertices, rsurface.batchvertexmesh, rsurface.batchvertexmeshbuffer);
2536 R_SetupShader_SetPermutationHLSL(mode, permutation);
2537 Matrix4x4_ToArrayFloatGL(&rsurface.matrix, m16f);hlslPSSetParameter16f(D3DPSREGISTER_ModelToReflectCube, m16f);
2538 if (mode == SHADERMODE_LIGHTSOURCE)
2540 Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);hlslVSSetParameter16f(D3DVSREGISTER_ModelToLight, m16f);
2541 hlslVSSetParameter3f(D3DVSREGISTER_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
2545 if (mode == SHADERMODE_LIGHTDIRECTION)
2547 hlslVSSetParameter3f(D3DVSREGISTER_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);
2550 Matrix4x4_ToArrayFloatGL(&rsurface.texture->currenttexmatrix, m16f);hlslVSSetParameter16f(D3DVSREGISTER_TexMatrix, m16f);
2551 Matrix4x4_ToArrayFloatGL(&rsurface.texture->currentbackgroundtexmatrix, m16f);hlslVSSetParameter16f(D3DVSREGISTER_BackgroundTexMatrix, m16f);
2552 Matrix4x4_ToArrayFloatGL(&r_shadow_shadowmapmatrix, m16f);hlslVSSetParameter16f(D3DVSREGISTER_ShadowMapMatrix, m16f);
2553 hlslVSSetParameter3f(D3DVSREGISTER_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);
2554 hlslVSSetParameter4f(D3DVSREGISTER_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]);
2556 if (mode == SHADERMODE_LIGHTSOURCE)
2558 hlslPSSetParameter3f(D3DPSREGISTER_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
2559 hlslPSSetParameter3f(D3DPSREGISTER_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);
2560 hlslPSSetParameter3f(D3DPSREGISTER_Color_Ambient, colormod[0] * ambientscale, colormod[1] * ambientscale, colormod[2] * ambientscale);
2561 hlslPSSetParameter3f(D3DPSREGISTER_Color_Diffuse, colormod[0] * diffusescale, colormod[1] * diffusescale, colormod[2] * diffusescale);
2562 hlslPSSetParameter3f(D3DPSREGISTER_Color_Specular, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale);
2564 // additive passes are only darkened by fog, not tinted
2565 hlslPSSetParameter3f(D3DPSREGISTER_FogColor, 0, 0, 0);
2566 hlslPSSetParameter1f(D3DPSREGISTER_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f) - 1.0f);
2570 if (mode == SHADERMODE_FLATCOLOR)
2572 hlslPSSetParameter3f(D3DPSREGISTER_Color_Ambient, colormod[0], colormod[1], colormod[2]);
2574 else if (mode == SHADERMODE_LIGHTDIRECTION)
2576 hlslPSSetParameter3f(D3DPSREGISTER_Color_Ambient, (r_refdef.scene.ambient + rsurface.modellight_ambient[0] * r_refdef.lightmapintensity) * colormod[0], (r_refdef.scene.ambient + rsurface.modellight_ambient[1] * r_refdef.lightmapintensity) * colormod[1], (r_refdef.scene.ambient + rsurface.modellight_ambient[2] * r_refdef.lightmapintensity) * colormod[2]);
2577 hlslPSSetParameter3f(D3DPSREGISTER_Color_Diffuse, r_refdef.lightmapintensity * colormod[0], r_refdef.lightmapintensity * colormod[1], r_refdef.lightmapintensity * colormod[2]);
2578 hlslPSSetParameter3f(D3DPSREGISTER_Color_Specular, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale);
2579 hlslPSSetParameter3f(D3DPSREGISTER_DeferredMod_Diffuse, colormod[0], colormod[1], colormod[2]);
2580 hlslPSSetParameter3f(D3DPSREGISTER_DeferredMod_Specular, specularscale, specularscale, specularscale);
2581 hlslPSSetParameter3f(D3DPSREGISTER_LightColor, rsurface.modellight_diffuse[0], rsurface.modellight_diffuse[1], rsurface.modellight_diffuse[2]);
2582 hlslPSSetParameter3f(D3DPSREGISTER_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);
2586 hlslPSSetParameter3f(D3DPSREGISTER_Color_Ambient, r_refdef.scene.ambient * colormod[0], r_refdef.scene.ambient * colormod[1], r_refdef.scene.ambient * colormod[2]);
2587 hlslPSSetParameter3f(D3DPSREGISTER_Color_Diffuse, rsurface.texture->lightmapcolor[0], rsurface.texture->lightmapcolor[1], rsurface.texture->lightmapcolor[2]);
2588 hlslPSSetParameter3f(D3DPSREGISTER_Color_Specular, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale);
2589 hlslPSSetParameter3f(D3DPSREGISTER_DeferredMod_Diffuse, colormod[0] * diffusescale, colormod[1] * diffusescale, colormod[2] * diffusescale);
2590 hlslPSSetParameter3f(D3DPSREGISTER_DeferredMod_Specular, specularscale, specularscale, specularscale);
2592 // additive passes are only darkened by fog, not tinted
2593 if(blendfuncflags & BLENDFUNC_ALLOWS_FOG_HACK0)
2594 hlslPSSetParameter3f(D3DPSREGISTER_FogColor, 0, 0, 0);
2596 hlslPSSetParameter3f(D3DPSREGISTER_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
2597 hlslPSSetParameter4f(D3DPSREGISTER_DistortScaleRefractReflect, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor);
2598 hlslPSSetParameter4f(D3DPSREGISTER_ScreenScaleRefractReflect, r_fb.water.screenscale[0], r_fb.water.screenscale[1], r_fb.water.screenscale[0], r_fb.water.screenscale[1]);
2599 hlslPSSetParameter4f(D3DPSREGISTER_ScreenCenterRefractReflect, r_fb.water.screencenter[0], r_fb.water.screencenter[1], r_fb.water.screencenter[0], r_fb.water.screencenter[1]);
2600 hlslPSSetParameter4f(D3DPSREGISTER_RefractColor, rsurface.texture->refractcolor4f[0], rsurface.texture->refractcolor4f[1], rsurface.texture->refractcolor4f[2], rsurface.texture->refractcolor4f[3] * rsurface.texture->lightmapcolor[3]);
2601 hlslPSSetParameter4f(D3DPSREGISTER_ReflectColor, rsurface.texture->reflectcolor4f[0], rsurface.texture->reflectcolor4f[1], rsurface.texture->reflectcolor4f[2], rsurface.texture->reflectcolor4f[3] * rsurface.texture->lightmapcolor[3]);
2602 hlslPSSetParameter1f(D3DPSREGISTER_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);
2603 hlslPSSetParameter1f(D3DPSREGISTER_ReflectOffset, rsurface.texture->reflectmin);
2604 hlslPSSetParameter1f(D3DPSREGISTER_SpecularPower, (rsurface.texture->specularpower - 1.0f) * (r_shadow_glossexact.integer ? 0.25f : 1.0f));
2605 if (mode == SHADERMODE_WATER)
2606 hlslPSSetParameter2f(D3DPSREGISTER_NormalmapScrollBlend, rsurface.texture->r_water_waterscroll[0], rsurface.texture->r_water_waterscroll[1]);
2608 hlslPSSetParameter2f(D3DPSREGISTER_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);
2609 hlslPSSetParameter4f(D3DPSREGISTER_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);
2610 hlslPSSetParameter3f(D3DPSREGISTER_Color_Glow, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2]);
2611 hlslPSSetParameter1f(D3DPSREGISTER_Alpha, rsurface.texture->lightmapcolor[3] * ((rsurface.texture->basematerialflags & MATERIALFLAG_WATERSHADER && r_fb.water.enabled && !r_refdef.view.isoverlay) ? rsurface.texture->r_water_wateralpha : 1));
2612 hlslPSSetParameter3f(D3DPSREGISTER_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);
2613 if (rsurface.texture->pantstexture)
2614 hlslPSSetParameter3f(D3DPSREGISTER_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
2616 hlslPSSetParameter3f(D3DPSREGISTER_Color_Pants, 0, 0, 0);
2617 if (rsurface.texture->shirttexture)
2618 hlslPSSetParameter3f(D3DPSREGISTER_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
2620 hlslPSSetParameter3f(D3DPSREGISTER_Color_Shirt, 0, 0, 0);
2621 hlslPSSetParameter4f(D3DPSREGISTER_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]);
2622 hlslPSSetParameter1f(D3DPSREGISTER_FogPlaneViewDist, rsurface.fogplaneviewdist);
2623 hlslPSSetParameter1f(D3DPSREGISTER_FogRangeRecip, rsurface.fograngerecip);
2624 hlslPSSetParameter1f(D3DPSREGISTER_FogHeightFade, rsurface.fogheightfade);
2625 hlslPSSetParameter4f(D3DPSREGISTER_OffsetMapping_ScaleSteps,
2626 r_glsl_offsetmapping_scale.value*rsurface.texture->offsetscale,
2627 max(1, (permutation & SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING) ? r_glsl_offsetmapping_reliefmapping_steps.integer : r_glsl_offsetmapping_steps.integer),
2628 1.0 / max(1, (permutation & SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING) ? r_glsl_offsetmapping_reliefmapping_steps.integer : r_glsl_offsetmapping_steps.integer),
2629 max(1, r_glsl_offsetmapping_reliefmapping_refinesteps.integer)
2631 hlslPSSetParameter1f(D3DPSREGISTER_OffsetMapping_LodDistance, r_glsl_offsetmapping_lod_distance.integer * r_refdef.view.quality);
2632 hlslPSSetParameter1f(D3DPSREGISTER_OffsetMapping_Bias, rsurface.texture->offsetbias);
2633 hlslPSSetParameter2f(D3DPSREGISTER_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);
2634 hlslPSSetParameter2f(D3DPSREGISTER_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);
2636 R_Mesh_TexBind(GL20TU_NORMAL , rsurface.texture->nmaptexture );
2637 R_Mesh_TexBind(GL20TU_COLOR , rsurface.texture->basetexture );
2638 R_Mesh_TexBind(GL20TU_GLOSS , rsurface.texture->glosstexture );
2639 R_Mesh_TexBind(GL20TU_GLOW , rsurface.texture->glowtexture );
2640 if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_NORMAL , rsurface.texture->backgroundnmaptexture );
2641 if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_COLOR , rsurface.texture->backgroundbasetexture );
2642 if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_GLOSS , rsurface.texture->backgroundglosstexture );
2643 if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_GLOW , rsurface.texture->backgroundglowtexture );
2644 if (permutation & SHADERPERMUTATION_COLORMAPPING) R_Mesh_TexBind(GL20TU_PANTS , rsurface.texture->pantstexture );
2645 if (permutation & SHADERPERMUTATION_COLORMAPPING) R_Mesh_TexBind(GL20TU_SHIRT , rsurface.texture->shirttexture );
2646 if (permutation & SHADERPERMUTATION_REFLECTCUBE) R_Mesh_TexBind(GL20TU_REFLECTMASK , rsurface.texture->reflectmasktexture );
2647 if (permutation & SHADERPERMUTATION_REFLECTCUBE) R_Mesh_TexBind(GL20TU_REFLECTCUBE , rsurface.texture->reflectcubetexture ? rsurface.texture->reflectcubetexture : r_texture_whitecube);
2648 if (permutation & SHADERPERMUTATION_FOGHEIGHTTEXTURE) R_Mesh_TexBind(GL20TU_FOGHEIGHTTEXTURE , r_texture_fogheighttexture );
2649 if (permutation & (SHADERPERMUTATION_FOGINSIDE | SHADERPERMUTATION_FOGOUTSIDE)) R_Mesh_TexBind(GL20TU_FOGMASK , r_texture_fogattenuation );
2650 R_Mesh_TexBind(GL20TU_LIGHTMAP , rsurface.lightmaptexture ? rsurface.lightmaptexture : r_texture_white);
2651 R_Mesh_TexBind(GL20TU_DELUXEMAP , rsurface.deluxemaptexture ? rsurface.deluxemaptexture : r_texture_blanknormalmap);
2652 if (rsurface.rtlight ) R_Mesh_TexBind(GL20TU_ATTENUATION , r_shadow_attenuationgradienttexture );
2653 if (rsurfacepass == RSURFPASS_BACKGROUND)
2655 R_Mesh_TexBind(GL20TU_REFRACTION , waterplane->texture_refraction ? waterplane->texture_refraction : r_texture_black);
2656 if(mode == SHADERMODE_GENERIC) R_Mesh_TexBind(GL20TU_FIRST , waterplane->texture_camera ? waterplane->texture_camera : r_texture_black);
2657 R_Mesh_TexBind(GL20TU_REFLECTION , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);
2661 if (permutation & SHADERPERMUTATION_REFLECTION ) R_Mesh_TexBind(GL20TU_REFLECTION , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);
2663 // if (rsurfacepass == RSURFPASS_DEFERREDLIGHT ) R_Mesh_TexBind(GL20TU_SCREENNORMALMAP , r_shadow_prepassgeometrynormalmaptexture );
2664 if (permutation & SHADERPERMUTATION_DEFERREDLIGHTMAP ) R_Mesh_TexBind(GL20TU_SCREENDIFFUSE , r_shadow_prepasslightingdiffusetexture );
2665 if (permutation & SHADERPERMUTATION_DEFERREDLIGHTMAP ) R_Mesh_TexBind(GL20TU_SCREENSPECULAR , r_shadow_prepasslightingspeculartexture );
2666 if (rsurface.rtlight || (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW)))
2668 R_Mesh_TexBind(GL20TU_SHADOWMAP2D, r_shadow_shadowmap2ddepthtexture);
2669 if (rsurface.rtlight)
2671 if (permutation & SHADERPERMUTATION_CUBEFILTER ) R_Mesh_TexBind(GL20TU_CUBE , rsurface.rtlight->currentcubemap );
2672 if (permutation & SHADERPERMUTATION_SHADOWMAPVSDCT ) R_Mesh_TexBind(GL20TU_CUBEPROJECTION , r_shadow_shadowmapvsdcttexture );
2677 case RENDERPATH_D3D10:
2678 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2680 case RENDERPATH_D3D11:
2681 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
2683 case RENDERPATH_GL20:
2684 case RENDERPATH_GLES2:
2685 if (!vid.useinterleavedarrays)
2687 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), texturenumsurfaces, texturesurfacelist);
2688 R_Mesh_VertexPointer( 3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
2689 R_Mesh_ColorPointer( 4, GL_FLOAT, sizeof(float[4]), rsurface.batchlightmapcolor4f, rsurface.batchlightmapcolor4f_vertexbuffer, rsurface.batchlightmapcolor4f_bufferoffset);
2690 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
2691 R_Mesh_TexCoordPointer(1, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchsvector3f, rsurface.batchsvector3f_vertexbuffer, rsurface.batchsvector3f_bufferoffset);
2692 R_Mesh_TexCoordPointer(2, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchtvector3f, rsurface.batchtvector3f_vertexbuffer, rsurface.batchtvector3f_bufferoffset);
2693 R_Mesh_TexCoordPointer(3, 3, GL_FLOAT, sizeof(float[3]), rsurface.batchnormal3f, rsurface.batchnormal3f_vertexbuffer, rsurface.batchnormal3f_bufferoffset);
2694 R_Mesh_TexCoordPointer(4, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordlightmap2f, rsurface.batchtexcoordlightmap2f_vertexbuffer, rsurface.batchtexcoordlightmap2f_bufferoffset);
2698 RSurf_PrepareVerticesForBatch(BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | (rsurface.modellightmapcolor4f ? BATCHNEED_VERTEXMESH_VERTEXCOLOR : 0) | BATCHNEED_VERTEXMESH_TEXCOORD | (rsurface.uselightmaptexture ? BATCHNEED_VERTEXMESH_LIGHTMAP : 0), texturenumsurfaces, texturesurfacelist);
2699 R_Mesh_PrepareVertices_Mesh(rsurface.batchnumvertices, rsurface.batchvertexmesh, rsurface.batchvertexmeshbuffer);
2701 R_SetupShader_SetPermutationGLSL(mode, permutation);
2702 if (r_glsl_permutation->loc_ModelToReflectCube >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.matrix, m16f);qglUniformMatrix4fv(r_glsl_permutation->loc_ModelToReflectCube, 1, false, m16f);}
2703 if (mode == SHADERMODE_LIGHTSOURCE)
2705 if (r_glsl_permutation->loc_ModelToLight >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);qglUniformMatrix4fv(r_glsl_permutation->loc_ModelToLight, 1, false, m16f);}
2706 if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3f(r_glsl_permutation->loc_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
2707 if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3f(r_glsl_permutation->loc_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);
2708 if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Ambient, colormod[0] * ambientscale, colormod[1] * ambientscale, colormod[2] * ambientscale);
2709 if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Diffuse, colormod[0] * diffusescale, colormod[1] * diffusescale, colormod[2] * diffusescale);
2710 if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Specular, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale);
2712 // additive passes are only darkened by fog, not tinted
2713 if (r_glsl_permutation->loc_FogColor >= 0)
2714 qglUniform3f(r_glsl_permutation->loc_FogColor, 0, 0, 0);
2715 if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1f(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f) - 1.0f);
2719 if (mode == SHADERMODE_FLATCOLOR)
2721 if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Ambient, colormod[0], colormod[1], colormod[2]);
2723 else if (mode == SHADERMODE_LIGHTDIRECTION)
2725 if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Ambient, (r_refdef.scene.ambient + rsurface.modellight_ambient[0] * r_refdef.lightmapintensity * r_refdef.scene.rtlightstylevalue[0]) * colormod[0], (r_refdef.scene.ambient + rsurface.modellight_ambient[1] * r_refdef.lightmapintensity * r_refdef.scene.rtlightstylevalue[0]) * colormod[1], (r_refdef.scene.ambient + rsurface.modellight_ambient[2] * r_refdef.lightmapintensity * r_refdef.scene.rtlightstylevalue[0]) * colormod[2]);
2726 if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Diffuse, r_refdef.lightmapintensity * colormod[0], r_refdef.lightmapintensity * colormod[1], r_refdef.lightmapintensity * colormod[2]);
2727 if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Specular, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale);
2728 if (r_glsl_permutation->loc_DeferredMod_Diffuse >= 0) qglUniform3f(r_glsl_permutation->loc_DeferredMod_Diffuse, colormod[0], colormod[1], colormod[2]);
2729 if (r_glsl_permutation->loc_DeferredMod_Specular >= 0) qglUniform3f(r_glsl_permutation->loc_DeferredMod_Specular, specularscale, specularscale, specularscale);
2730 if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3f(r_glsl_permutation->loc_LightColor, rsurface.modellight_diffuse[0] * r_refdef.scene.rtlightstylevalue[0], rsurface.modellight_diffuse[1] * r_refdef.scene.rtlightstylevalue[0], rsurface.modellight_diffuse[2] * r_refdef.scene.rtlightstylevalue[0]);
2731 if (r_glsl_permutation->loc_LightDir >= 0) qglUniform3f(r_glsl_permutation->loc_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);
2735 if (r_glsl_permutation->loc_Color_Ambient >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Ambient, r_refdef.scene.ambient * colormod[0], r_refdef.scene.ambient * colormod[1], r_refdef.scene.ambient * colormod[2]);
2736 if (r_glsl_permutation->loc_Color_Diffuse >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Diffuse, rsurface.texture->lightmapcolor[0], rsurface.texture->lightmapcolor[1], rsurface.texture->lightmapcolor[2]);
2737 if (r_glsl_permutation->loc_Color_Specular >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Specular, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale);
2738 if (r_glsl_permutation->loc_DeferredMod_Diffuse >= 0) qglUniform3f(r_glsl_permutation->loc_DeferredMod_Diffuse, colormod[0] * diffusescale, colormod[1] * diffusescale, colormod[2] * diffusescale);
2739 if (r_glsl_permutation->loc_DeferredMod_Specular >= 0) qglUniform3f(r_glsl_permutation->loc_DeferredMod_Specular, specularscale, specularscale, specularscale);
2741 // additive passes are only darkened by fog, not tinted
2742 if (r_glsl_permutation->loc_FogColor >= 0)
2744 if(blendfuncflags & BLENDFUNC_ALLOWS_FOG_HACK0)
2745 qglUniform3f(r_glsl_permutation->loc_FogColor, 0, 0, 0);
2747 qglUniform3f(r_glsl_permutation->loc_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
2749 if (r_glsl_permutation->loc_DistortScaleRefractReflect >= 0) qglUniform4f(r_glsl_permutation->loc_DistortScaleRefractReflect, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor);
2750 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]);
2751 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]);
2752 if (r_glsl_permutation->loc_RefractColor >= 0) qglUniform4f(r_glsl_permutation->loc_RefractColor, rsurface.texture->refractcolor4f[0], rsurface.texture->refractcolor4f[1], rsurface.texture->refractcolor4f[2], rsurface.texture->refractcolor4f[3] * rsurface.texture->lightmapcolor[3]);
2753 if (r_glsl_permutation->loc_ReflectColor >= 0) qglUniform4f(r_glsl_permutation->loc_ReflectColor, rsurface.texture->reflectcolor4f[0], rsurface.texture->reflectcolor4f[1], rsurface.texture->reflectcolor4f[2], rsurface.texture->reflectcolor4f[3] * rsurface.texture->lightmapcolor[3]);
2754 if (r_glsl_permutation->loc_ReflectFactor >= 0) qglUniform1f(r_glsl_permutation->loc_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);
2755 if (r_glsl_permutation->loc_ReflectOffset >= 0) qglUniform1f(r_glsl_permutation->loc_ReflectOffset, rsurface.texture->reflectmin);
2756 if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1f(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f) - 1.0f);
2757 if (r_glsl_permutation->loc_NormalmapScrollBlend >= 0) qglUniform2f(r_glsl_permutation->loc_NormalmapScrollBlend, rsurface.texture->r_water_waterscroll[0], rsurface.texture->r_water_waterscroll[1]);
2759 if (r_glsl_permutation->loc_TexMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currenttexmatrix, m16f);qglUniformMatrix4fv(r_glsl_permutation->loc_TexMatrix, 1, false, m16f);}
2760 if (r_glsl_permutation->loc_BackgroundTexMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currentbackgroundtexmatrix, m16f);qglUniformMatrix4fv(r_glsl_permutation->loc_BackgroundTexMatrix, 1, false, m16f);}
2761 if (r_glsl_permutation->loc_ShadowMapMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&r_shadow_shadowmapmatrix, m16f);qglUniformMatrix4fv(r_glsl_permutation->loc_ShadowMapMatrix, 1, false, m16f);}
2762 if (r_glsl_permutation->loc_ShadowMap_TextureScale >= 0) qglUniform2f(r_glsl_permutation->loc_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);
2763 if (r_glsl_permutation->loc_ShadowMap_Parameters >= 0) qglUniform4f(r_glsl_permutation->loc_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);
2765 if (r_glsl_permutation->loc_Color_Glow >= 0) qglUniform3f(r_glsl_permutation->loc_Color_Glow, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2]);
2766 if (r_glsl_permutation->loc_Alpha >= 0) qglUniform1f(r_glsl_permutation->loc_Alpha, rsurface.texture->lightmapcolor[3] * ((rsurface.texture->basematerialflags & MATERIALFLAG_WATERSHADER && r_fb.water.enabled && !r_refdef.view.isoverlay) ? rsurface.texture->r_water_wateralpha : 1));
2767 if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3f(r_glsl_permutation->loc_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);
2768 if (r_glsl_permutation->loc_Color_Pants >= 0)
2770 if (rsurface.texture->pantstexture)
2771 qglUniform3f(r_glsl_permutation->loc_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
2773 qglUniform3f(r_glsl_permutation->loc_Color_Pants, 0, 0, 0);
2775 if (r_glsl_permutation->loc_Color_Shirt >= 0)
2777 if (rsurface.texture->shirttexture)
2778 qglUniform3f(r_glsl_permutation->loc_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
2780 qglUniform3f(r_glsl_permutation->loc_Color_Shirt, 0, 0, 0);
2782 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]);
2783 if (r_glsl_permutation->loc_FogPlaneViewDist >= 0) qglUniform1f(r_glsl_permutation->loc_FogPlaneViewDist, rsurface.fogplaneviewdist);
2784 if (r_glsl_permutation->loc_FogRangeRecip >= 0) qglUniform1f(r_glsl_permutation->loc_FogRangeRecip, rsurface.fograngerecip);
2785 if (r_glsl_permutation->loc_FogHeightFade >= 0) qglUniform1f(r_glsl_permutation->loc_FogHeightFade, rsurface.fogheightfade);
2786 if (r_glsl_permutation->loc_OffsetMapping_ScaleSteps >= 0) qglUniform4f(r_glsl_permutation->loc_OffsetMapping_ScaleSteps,
2787 r_glsl_offsetmapping_scale.value*rsurface.texture->offsetscale,
2788 max(1, (permutation & SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING) ? r_glsl_offsetmapping_reliefmapping_steps.integer : r_glsl_offsetmapping_steps.integer),
2789 1.0 / max(1, (permutation & SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING) ? r_glsl_offsetmapping_reliefmapping_steps.integer : r_glsl_offsetmapping_steps.integer),
2790 max(1, r_glsl_offsetmapping_reliefmapping_refinesteps.integer)
2792 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);
2793 if (r_glsl_permutation->loc_OffsetMapping_Bias >= 0) qglUniform1f(r_glsl_permutation->loc_OffsetMapping_Bias, rsurface.texture->offsetbias);
2794 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]);
2795 if (r_glsl_permutation->loc_PixelToScreenTexCoord >= 0) qglUniform2f(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
2796 if (r_glsl_permutation->loc_BounceGridMatrix >= 0) {Matrix4x4_Concat(&tempmatrix, &r_shadow_bouncegridmatrix, &rsurface.matrix);Matrix4x4_ToArrayFloatGL(&tempmatrix, m16f);qglUniformMatrix4fv(r_glsl_permutation->loc_BounceGridMatrix, 1, false, m16f);}
2797 if (r_glsl_permutation->loc_BounceGridIntensity >= 0) qglUniform1f(r_glsl_permutation->loc_BounceGridIntensity, r_shadow_bouncegridintensity*r_refdef.view.colorscale);
2799 if (r_glsl_permutation->tex_Texture_First >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_First , r_texture_white );
2800 if (r_glsl_permutation->tex_Texture_Second >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Second , r_texture_white );
2801 if (r_glsl_permutation->tex_Texture_GammaRamps >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_GammaRamps , r_texture_gammaramps );
2802 if (r_glsl_permutation->tex_Texture_Normal >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Normal , rsurface.texture->nmaptexture );
2803 if (r_glsl_permutation->tex_Texture_Color >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Color , rsurface.texture->basetexture );
2804 if (r_glsl_permutation->tex_Texture_Gloss >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Gloss , rsurface.texture->glosstexture );
2805 if (r_glsl_permutation->tex_Texture_Glow >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Glow , rsurface.texture->glowtexture );
2806 if (r_glsl_permutation->tex_Texture_SecondaryNormal >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_SecondaryNormal , rsurface.texture->backgroundnmaptexture );
2807 if (r_glsl_permutation->tex_Texture_SecondaryColor >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_SecondaryColor , rsurface.texture->backgroundbasetexture );
2808 if (r_glsl_permutation->tex_Texture_SecondaryGloss >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_SecondaryGloss , rsurface.texture->backgroundglosstexture );
2809 if (r_glsl_permutation->tex_Texture_SecondaryGlow >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_SecondaryGlow , rsurface.texture->backgroundglowtexture );
2810 if (r_glsl_permutation->tex_Texture_Pants >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Pants , rsurface.texture->pantstexture );
2811 if (r_glsl_permutation->tex_Texture_Shirt >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Shirt , rsurface.texture->shirttexture );
2812 if (r_glsl_permutation->tex_Texture_ReflectMask >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_ReflectMask , rsurface.texture->reflectmasktexture );
2813 if (r_glsl_permutation->tex_Texture_ReflectCube >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_ReflectCube , rsurface.texture->reflectcubetexture ? rsurface.texture->reflectcubetexture : r_texture_whitecube);
2814 if (r_glsl_permutation->tex_Texture_FogHeightTexture>= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_FogHeightTexture , r_texture_fogheighttexture );
2815 if (r_glsl_permutation->tex_Texture_FogMask >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_FogMask , r_texture_fogattenuation );
2816 if (r_glsl_permutation->tex_Texture_Lightmap >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Lightmap , rsurface.lightmaptexture ? rsurface.lightmaptexture : r_texture_white);
2817 if (r_glsl_permutation->tex_Texture_Deluxemap >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Deluxemap , rsurface.deluxemaptexture ? rsurface.deluxemaptexture : r_texture_blanknormalmap);
2818 if (r_glsl_permutation->tex_Texture_Attenuation >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Attenuation , r_shadow_attenuationgradienttexture );
2819 if (rsurfacepass == RSURFPASS_BACKGROUND)
2821 if (r_glsl_permutation->tex_Texture_Refraction >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Refraction , waterplane->texture_refraction ? waterplane->texture_refraction : r_texture_black);
2822 if (r_glsl_permutation->tex_Texture_First >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_First , waterplane->texture_camera ? waterplane->texture_camera : r_texture_black);
2823 if (r_glsl_permutation->tex_Texture_Reflection >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Reflection , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);
2827 if (r_glsl_permutation->tex_Texture_Reflection >= 0 && waterplane) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Reflection , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);
2829 if (r_glsl_permutation->tex_Texture_ScreenNormalMap >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_ScreenNormalMap , r_shadow_prepassgeometrynormalmaptexture );
2830 if (r_glsl_permutation->tex_Texture_ScreenDiffuse >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_ScreenDiffuse , r_shadow_prepasslightingdiffusetexture );
2831 if (r_glsl_permutation->tex_Texture_ScreenSpecular >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_ScreenSpecular , r_shadow_prepasslightingspeculartexture );
2832 if (rsurface.rtlight || (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW)))
2834 if (r_glsl_permutation->tex_Texture_ShadowMap2D >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_ShadowMap2D, r_shadow_shadowmap2ddepthtexture );
2835 if (rsurface.rtlight)
2837 if (r_glsl_permutation->tex_Texture_Cube >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Cube , rsurface.rtlight->currentcubemap );
2838 if (r_glsl_permutation->tex_Texture_CubeProjection >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_CubeProjection , r_shadow_shadowmapvsdcttexture );
2841 if (r_glsl_permutation->tex_Texture_BounceGrid >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_BounceGrid, r_shadow_bouncegridtexture);
2844 case RENDERPATH_GL11:
2845 case RENDERPATH_GL13:
2846 case RENDERPATH_GLES1:
2848 case RENDERPATH_SOFT:
2849 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), texturenumsurfaces, texturesurfacelist);
2850 R_Mesh_PrepareVertices_Mesh_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, rsurface.batchsvector3f, rsurface.batchtvector3f, rsurface.batchnormal3f, rsurface.batchlightmapcolor4f, rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordlightmap2f);
2851 R_SetupShader_SetPermutationSoft(mode, permutation);
2852 {Matrix4x4_ToArrayFloatGL(&rsurface.matrix, m16f);DPSOFTRAST_UniformMatrix4fv(DPSOFTRAST_UNIFORM_ModelToReflectCubeM1, 1, false, m16f);}
2853 if (mode == SHADERMODE_LIGHTSOURCE)
2855 {Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);DPSOFTRAST_UniformMatrix4fv(DPSOFTRAST_UNIFORM_ModelToLightM1, 1, false, m16f);}
2856 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]);
2857 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]);
2858 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Ambient, colormod[0] * ambientscale, colormod[1] * ambientscale, colormod[2] * ambientscale);
2859 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Diffuse, colormod[0] * diffusescale, colormod[1] * diffusescale, colormod[2] * diffusescale);
2860 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Specular, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale, r_refdef.view.colorscale * specularscale);
2862 // additive passes are only darkened by fog, not tinted
2863 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_FogColor, 0, 0, 0);
2864 DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f) - 1.0f);
2868 if (mode == SHADERMODE_FLATCOLOR)
2870 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Ambient, colormod[0], colormod[1], colormod[2]);
2872 else if (mode == SHADERMODE_LIGHTDIRECTION)
2874 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Ambient, (r_refdef.scene.ambient + rsurface.modellight_ambient[0] * r_refdef.lightmapintensity * r_refdef.scene.rtlightstylevalue[0]) * colormod[0], (r_refdef.scene.ambient + rsurface.modellight_ambient[1] * r_refdef.lightmapintensity * r_refdef.scene.rtlightstylevalue[0]) * colormod[1], (r_refdef.scene.ambient + rsurface.modellight_ambient[2] * r_refdef.lightmapintensity * r_refdef.scene.rtlightstylevalue[0]) * colormod[2]);
2875 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Diffuse, r_refdef.lightmapintensity * colormod[0], r_refdef.lightmapintensity * colormod[1], r_refdef.lightmapintensity * colormod[2]);
2876 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Specular, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale);
2877 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_DeferredMod_Diffuse, colormod[0], colormod[1], colormod[2]);
2878 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_DeferredMod_Specular, specularscale, specularscale, specularscale);
2879 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_LightColor, rsurface.modellight_diffuse[0] * r_refdef.scene.rtlightstylevalue[0], rsurface.modellight_diffuse[1] * r_refdef.scene.rtlightstylevalue[0], rsurface.modellight_diffuse[2] * r_refdef.scene.rtlightstylevalue[0]);
2880 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]);
2884 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Ambient, r_refdef.scene.ambient * colormod[0], r_refdef.scene.ambient * colormod[1], r_refdef.scene.ambient * colormod[2]);
2885 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Diffuse, rsurface.texture->lightmapcolor[0], rsurface.texture->lightmapcolor[1], rsurface.texture->lightmapcolor[2]);
2886 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Specular, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale, r_refdef.lightmapintensity * r_refdef.view.colorscale * specularscale);
2887 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_DeferredMod_Diffuse, colormod[0] * diffusescale, colormod[1] * diffusescale, colormod[2] * diffusescale);
2888 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_DeferredMod_Specular, specularscale, specularscale, specularscale);
2890 // additive passes are only darkened by fog, not tinted
2891 if(blendfuncflags & BLENDFUNC_ALLOWS_FOG_HACK0)
2892 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_FogColor, 0, 0, 0);
2894 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]);
2895 DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_DistortScaleRefractReflect, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_refractdistort.value * rsurface.texture->refractfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor, r_water_reflectdistort.value * rsurface.texture->reflectfactor);
2896 DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_ScreenScaleRefractReflect, r_fb.water.screenscale[0], r_fb.water.screenscale[1], r_fb.water.screenscale[0], r_fb.water.screenscale[1]);
2897 DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_ScreenCenterRefractReflect, r_fb.water.screencenter[0], r_fb.water.screencenter[1], r_fb.water.screencenter[0], r_fb.water.screencenter[1]);
2898 DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_RefractColor, rsurface.texture->refractcolor4f[0], rsurface.texture->refractcolor4f[1], rsurface.texture->refractcolor4f[2], rsurface.texture->refractcolor4f[3] * rsurface.texture->lightmapcolor[3]);
2899 DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_ReflectColor, rsurface.texture->reflectcolor4f[0], rsurface.texture->reflectcolor4f[1], rsurface.texture->reflectcolor4f[2], rsurface.texture->reflectcolor4f[3] * rsurface.texture->lightmapcolor[3]);
2900 DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_ReflectFactor, rsurface.texture->reflectmax - rsurface.texture->reflectmin);
2901 DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_ReflectOffset, rsurface.texture->reflectmin);
2902 DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_SpecularPower, rsurface.texture->specularpower * (r_shadow_glossexact.integer ? 0.25f : 1.0f) - 1.0f);
2903 DPSOFTRAST_Uniform2f(DPSOFTRAST_UNIFORM_NormalmapScrollBlend, rsurface.texture->r_water_waterscroll[0], rsurface.texture->r_water_waterscroll[1]);
2905 {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currenttexmatrix, m16f);DPSOFTRAST_UniformMatrix4fv(DPSOFTRAST_UNIFORM_TexMatrixM1, 1, false, m16f);}
2906 {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currentbackgroundtexmatrix, m16f);DPSOFTRAST_UniformMatrix4fv(DPSOFTRAST_UNIFORM_BackgroundTexMatrixM1, 1, false, m16f);}
2907 {Matrix4x4_ToArrayFloatGL(&r_shadow_shadowmapmatrix, m16f);DPSOFTRAST_UniformMatrix4fv(DPSOFTRAST_UNIFORM_ShadowMapMatrixM1, 1, false, m16f);}
2908 DPSOFTRAST_Uniform2f(DPSOFTRAST_UNIFORM_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);
2909 DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);
2911 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Glow, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2]);
2912 DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_Alpha, rsurface.texture->lightmapcolor[3] * ((rsurface.texture->basematerialflags & MATERIALFLAG_WATERSHADER && r_fb.water.enabled && !r_refdef.view.isoverlay) ? rsurface.texture->r_water_wateralpha : 1));
2913 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);
2914 if (DPSOFTRAST_UNIFORM_Color_Pants >= 0)
2916 if (rsurface.texture->pantstexture)
2917 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]);
2919 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Pants, 0, 0, 0);
2921 if (DPSOFTRAST_UNIFORM_Color_Shirt >= 0)
2923 if (rsurface.texture->shirttexture)
2924 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]);
2926 DPSOFTRAST_Uniform3f(DPSOFTRAST_UNIFORM_Color_Shirt, 0, 0, 0);
2928 DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]);
2929 DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_FogPlaneViewDist, rsurface.fogplaneviewdist);
2930 DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_FogRangeRecip, rsurface.fograngerecip);
2931 DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_FogHeightFade, rsurface.fogheightfade);
2932 DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_OffsetMapping_ScaleSteps,
2933 r_glsl_offsetmapping_scale.value*rsurface.texture->offsetscale,
2934 max(1, (permutation & SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING) ? r_glsl_offsetmapping_reliefmapping_steps.integer : r_glsl_offsetmapping_steps.integer),
2935 1.0 / max(1, (permutation & SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING) ? r_glsl_offsetmapping_reliefmapping_steps.integer : r_glsl_offsetmapping_steps.integer),
2936 max(1, r_glsl_offsetmapping_reliefmapping_refinesteps.integer)
2938 DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_OffsetMapping_LodDistance, r_glsl_offsetmapping_lod_distance.integer * r_refdef.view.quality);
2939 DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_OffsetMapping_Bias, rsurface.texture->offsetbias);
2940 DPSOFTRAST_Uniform2f(DPSOFTRAST_UNIFORM_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);
2941 DPSOFTRAST_Uniform2f(DPSOFTRAST_UNIFORM_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
2943 R_Mesh_TexBind(GL20TU_NORMAL , rsurface.texture->nmaptexture );
2944 R_Mesh_TexBind(GL20TU_COLOR , rsurface.texture->basetexture );
2945 R_Mesh_TexBind(GL20TU_GLOSS , rsurface.texture->glosstexture );
2946 R_Mesh_TexBind(GL20TU_GLOW , rsurface.texture->glowtexture );
2947 if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_NORMAL , rsurface.texture->backgroundnmaptexture );
2948 if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_COLOR , rsurface.texture->backgroundbasetexture );
2949 if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_GLOSS , rsurface.texture->backgroundglosstexture );
2950 if (permutation & SHADERPERMUTATION_VERTEXTEXTUREBLEND) R_Mesh_TexBind(GL20TU_SECONDARY_GLOW , rsurface.texture->backgroundglowtexture );
2951 if (permutation & SHADERPERMUTATION_COLORMAPPING) R_Mesh_TexBind(GL20TU_PANTS , rsurface.texture->pantstexture );
2952 if (permutation & SHADERPERMUTATION_COLORMAPPING) R_Mesh_TexBind(GL20TU_SHIRT , rsurface.texture->shirttexture );
2953 if (permutation & SHADERPERMUTATION_REFLECTCUBE) R_Mesh_TexBind(GL20TU_REFLECTMASK , rsurface.texture->reflectmasktexture );
2954 if (permutation & SHADERPERMUTATION_REFLECTCUBE) R_Mesh_TexBind(GL20TU_REFLECTCUBE , rsurface.texture->reflectcubetexture ? rsurface.texture->reflectcubetexture : r_texture_whitecube);
2955 if (permutation & SHADERPERMUTATION_FOGHEIGHTTEXTURE) R_Mesh_TexBind(GL20TU_FOGHEIGHTTEXTURE , r_texture_fogheighttexture );
2956 if (permutation & (SHADERPERMUTATION_FOGINSIDE | SHADERPERMUTATION_FOGOUTSIDE)) R_Mesh_TexBind(GL20TU_FOGMASK , r_texture_fogattenuation );
2957 R_Mesh_TexBind(GL20TU_LIGHTMAP , rsurface.lightmaptexture ? rsurface.lightmaptexture : r_texture_white);
2958 R_Mesh_TexBind(GL20TU_DELUXEMAP , rsurface.deluxemaptexture ? rsurface.deluxemaptexture : r_texture_blanknormalmap);
2959 if (rsurface.rtlight ) R_Mesh_TexBind(GL20TU_ATTENUATION , r_shadow_attenuationgradienttexture );
2960 if (rsurfacepass == RSURFPASS_BACKGROUND)
2962 R_Mesh_TexBind(GL20TU_REFRACTION , waterplane->texture_refraction ? waterplane->texture_refraction : r_texture_black);
2963 if(mode == SHADERMODE_GENERIC) R_Mesh_TexBind(GL20TU_FIRST , waterplane->texture_camera ? waterplane->texture_camera : r_texture_black);
2964 R_Mesh_TexBind(GL20TU_REFLECTION , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);
2968 if (permutation & SHADERPERMUTATION_REFLECTION ) R_Mesh_TexBind(GL20TU_REFLECTION , waterplane->texture_reflection ? waterplane->texture_reflection : r_texture_black);
2970 // if (rsurfacepass == RSURFPASS_DEFERREDLIGHT ) R_Mesh_TexBind(GL20TU_SCREENNORMALMAP , r_shadow_prepassgeometrynormalmaptexture );
2971 if (permutation & SHADERPERMUTATION_DEFERREDLIGHTMAP ) R_Mesh_TexBind(GL20TU_SCREENDIFFUSE , r_shadow_prepasslightingdiffusetexture );
2972 if (permutation & SHADERPERMUTATION_DEFERREDLIGHTMAP ) R_Mesh_TexBind(GL20TU_SCREENSPECULAR , r_shadow_prepasslightingspeculartexture );
2973 if (rsurface.rtlight || (r_shadow_usingshadowmaportho && !(rsurface.ent_flags & RENDER_NOSELFSHADOW)))
2975 R_Mesh_TexBind(GL20TU_SHADOWMAP2D, r_shadow_shadowmap2ddepthtexture);
2976 if (rsurface.rtlight)
2978 if (permutation & SHADERPERMUTATION_CUBEFILTER ) R_Mesh_TexBind(GL20TU_CUBE , rsurface.rtlight->currentcubemap );
2979 if (permutation & SHADERPERMUTATION_SHADOWMAPVSDCT ) R_Mesh_TexBind(GL20TU_CUBEPROJECTION , r_shadow_shadowmapvsdcttexture );
2986 void R_SetupShader_DeferredLight(const rtlight_t *rtlight)
2988 // select a permutation of the lighting shader appropriate to this
2989 // combination of texture, entity, light source, and fogging, only use the
2990 // minimum features necessary to avoid wasting rendering time in the
2991 // fragment shader on features that are not being used
2992 unsigned int permutation = 0;
2993 unsigned int mode = 0;
2994 const float *lightcolorbase = rtlight->currentcolor;
2995 float ambientscale = rtlight->ambientscale;
2996 float diffusescale = rtlight->diffusescale;
2997 float specularscale = rtlight->specularscale;
2998 // this is the location of the light in view space
2999 vec3_t viewlightorigin;
3000 // this transforms from view space (camera) to light space (cubemap)
3001 matrix4x4_t viewtolight;
3002 matrix4x4_t lighttoview;
3003 float viewtolight16f[16];
3005 mode = SHADERMODE_DEFERREDLIGHTSOURCE;
3006 if (rtlight->currentcubemap != r_texture_whitecube)
3007 permutation |= SHADERPERMUTATION_CUBEFILTER;
3008 if (diffusescale > 0)
3009 permutation |= SHADERPERMUTATION_DIFFUSE;
3010 if (specularscale > 0 && r_shadow_gloss.integer > 0)
3011 permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE;
3012 if (r_shadow_usingshadowmap2d)
3014 permutation |= SHADERPERMUTATION_SHADOWMAP2D;
3015 if (r_shadow_shadowmapvsdct)
3016 permutation |= SHADERPERMUTATION_SHADOWMAPVSDCT;
3018 if (r_shadow_shadowmap2ddepthbuffer)
3019 permutation |= SHADERPERMUTATION_DEPTHRGB;
3021 if (vid.allowalphatocoverage)
3022 GL_AlphaToCoverage(false);
3023 Matrix4x4_Transform(&r_refdef.view.viewport.viewmatrix, rtlight->shadoworigin, viewlightorigin);
3024 Matrix4x4_Concat(&lighttoview, &r_refdef.view.viewport.viewmatrix, &rtlight->matrix_lighttoworld);
3025 Matrix4x4_Invert_Simple(&viewtolight, &lighttoview);
3026 Matrix4x4_ToArrayFloatGL(&viewtolight, viewtolight16f);
3027 switch(vid.renderpath)
3029 case RENDERPATH_D3D9:
3031 R_SetupShader_SetPermutationHLSL(mode, permutation);
3032 hlslPSSetParameter3f(D3DPSREGISTER_LightPosition, viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]);
3033 hlslPSSetParameter16f(D3DPSREGISTER_ViewToLight, viewtolight16f);
3034 hlslPSSetParameter3f(D3DPSREGISTER_DeferredColor_Ambient , lightcolorbase[0] * ambientscale , lightcolorbase[1] * ambientscale , lightcolorbase[2] * ambientscale );
3035 hlslPSSetParameter3f(D3DPSREGISTER_DeferredColor_Diffuse , lightcolorbase[0] * diffusescale , lightcolorbase[1] * diffusescale , lightcolorbase[2] * diffusescale );
3036 hlslPSSetParameter3f(D3DPSREGISTER_DeferredColor_Specular, lightcolorbase[0] * specularscale, lightcolorbase[1] * specularscale, lightcolorbase[2] * specularscale);
3037 hlslPSSetParameter2f(D3DPSREGISTER_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);
3038 hlslPSSetParameter4f(D3DPSREGISTER_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);
3039 hlslPSSetParameter1f(D3DPSREGISTER_SpecularPower, (r_shadow_gloss.integer == 2 ? r_shadow_gloss2exponent.value : r_shadow_glossexponent.value) * (r_shadow_glossexact.integer ? 0.25f : 1.0f) - 1.0f);
3040 hlslPSSetParameter2f(D3DPSREGISTER_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);
3041 hlslPSSetParameter2f(D3DPSREGISTER_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);
3043 R_Mesh_TexBind(GL20TU_ATTENUATION , r_shadow_attenuationgradienttexture );
3044 R_Mesh_TexBind(GL20TU_SCREENNORMALMAP , r_shadow_prepassgeometrynormalmaptexture );
3045 R_Mesh_TexBind(GL20TU_CUBE , rsurface.rtlight->currentcubemap );
3046 R_Mesh_TexBind(GL20TU_SHADOWMAP2D , r_shadow_shadowmap2ddepthtexture );
3047 R_Mesh_TexBind(GL20TU_CUBEPROJECTION , r_shadow_shadowmapvsdcttexture );
3050 case RENDERPATH_D3D10:
3051 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3053 case RENDERPATH_D3D11:
3054 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
3056 case RENDERPATH_GL20:
3057 case RENDERPATH_GLES2:
3058 R_SetupShader_SetPermutationGLSL(mode, permutation);
3059 if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3f( r_glsl_permutation->loc_LightPosition , viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]);
3060 if (r_glsl_permutation->loc_ViewToLight >= 0) qglUniformMatrix4fv(r_glsl_permutation->loc_ViewToLight , 1, false, viewtolight16f);
3061 if (r_glsl_permutation->loc_DeferredColor_Ambient >= 0) qglUniform3f( r_glsl_permutation->loc_DeferredColor_Ambient , lightcolorbase[0] * ambientscale , lightcolorbase[1] * ambientscale , lightcolorbase[2] * ambientscale );
3062 if (r_glsl_permutation->loc_DeferredColor_Diffuse >= 0) qglUniform3f( r_glsl_permutation->loc_DeferredColor_Diffuse , lightcolorbase[0] * diffusescale , lightcolorbase[1] * diffusescale , lightcolorbase[2] * diffusescale );
3063 if (r_glsl_permutation->loc_DeferredColor_Specular >= 0) qglUniform3f( r_glsl_permutation->loc_DeferredColor_Specular , lightcolorbase[0] * specularscale, lightcolorbase[1] * specularscale, lightcolorbase[2] * specularscale);
3064 if (r_glsl_permutation->loc_ShadowMap_TextureScale >= 0) qglUniform2f( r_glsl_permutation->loc_ShadowMap_TextureScale , r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);
3065 if (r_glsl_permutation->loc_ShadowMap_Parameters >= 0) qglUniform4f( r_glsl_permutation->loc_ShadowMap_Parameters , r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);
3066 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);
3067 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]);
3068 if (r_glsl_permutation->loc_PixelToScreenTexCoord >= 0) qglUniform2f( r_glsl_permutation->loc_PixelToScreenTexCoord , 1.0f/vid.width, 1.0f/vid.height);
3070 if (r_glsl_permutation->tex_Texture_Attenuation >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Attenuation , r_shadow_attenuationgradienttexture );
3071 if (r_glsl_permutation->tex_Texture_ScreenNormalMap >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_ScreenNormalMap , r_shadow_prepassgeometrynormalmaptexture );
3072 if (r_glsl_permutation->tex_Texture_Cube >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Cube , rsurface.rtlight->currentcubemap );
3073 if (r_glsl_permutation->tex_Texture_ShadowMap2D >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_ShadowMap2D , r_shadow_shadowmap2ddepthtexture );
3074 if (r_glsl_permutation->tex_Texture_CubeProjection >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_CubeProjection , r_shadow_shadowmapvsdcttexture );
3076 case RENDERPATH_GL11:
3077 case RENDERPATH_GL13:
3078 case RENDERPATH_GLES1:
3080 case RENDERPATH_SOFT:
3081 R_SetupShader_SetPermutationGLSL(mode, permutation);
3082 DPSOFTRAST_Uniform3f( DPSOFTRAST_UNIFORM_LightPosition , viewlightorigin[0], viewlightorigin[1], viewlightorigin[2]);
3083 DPSOFTRAST_UniformMatrix4fv(DPSOFTRAST_UNIFORM_ViewToLightM1 , 1, false, viewtolight16f);
3084 DPSOFTRAST_Uniform3f( DPSOFTRAST_UNIFORM_DeferredColor_Ambient , lightcolorbase[0] * ambientscale , lightcolorbase[1] * ambientscale , lightcolorbase[2] * ambientscale );
3085 DPSOFTRAST_Uniform3f( DPSOFTRAST_UNIFORM_DeferredColor_Diffuse , lightcolorbase[0] * diffusescale , lightcolorbase[1] * diffusescale , lightcolorbase[2] * diffusescale );
3086 DPSOFTRAST_Uniform3f( DPSOFTRAST_UNIFORM_DeferredColor_Specular , lightcolorbase[0] * specularscale, lightcolorbase[1] * specularscale, lightcolorbase[2] * specularscale);
3087 DPSOFTRAST_Uniform2f( DPSOFTRAST_UNIFORM_ShadowMap_TextureScale , r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);
3088 DPSOFTRAST_Uniform4f( DPSOFTRAST_UNIFORM_ShadowMap_Parameters , r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);
3089 DPSOFTRAST_Uniform1f( DPSOFTRAST_UNIFORM_SpecularPower , (r_shadow_gloss.integer == 2 ? r_shadow_gloss2exponent.value : r_shadow_glossexponent.value) * (r_shadow_glossexact.integer ? 0.25f : 1.0f) - 1.0f);
3090 DPSOFTRAST_Uniform2f( DPSOFTRAST_UNIFORM_ScreenToDepth , r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);
3091 DPSOFTRAST_Uniform2f(DPSOFTRAST_UNIFORM_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
3093 R_Mesh_TexBind(GL20TU_ATTENUATION , r_shadow_attenuationgradienttexture );
3094 R_Mesh_TexBind(GL20TU_SCREENNORMALMAP , r_shadow_prepassgeometrynormalmaptexture );
3095 R_Mesh_TexBind(GL20TU_CUBE , rsurface.rtlight->currentcubemap );
3096 R_Mesh_TexBind(GL20TU_SHADOWMAP2D , r_shadow_shadowmap2ddepthtexture );
3097 R_Mesh_TexBind(GL20TU_CUBEPROJECTION , r_shadow_shadowmapvsdcttexture );
3102 #define SKINFRAME_HASH 1024
3106 int loadsequence; // incremented each level change
3107 memexpandablearray_t array;
3108 skinframe_t *hash[SKINFRAME_HASH];
3111 r_skinframe_t r_skinframe;
3113 void R_SkinFrame_PrepareForPurge(void)
3115 r_skinframe.loadsequence++;
3116 // wrap it without hitting zero
3117 if (r_skinframe.loadsequence >= 200)
3118 r_skinframe.loadsequence = 1;
3121 void R_SkinFrame_MarkUsed(skinframe_t *skinframe)
3125 // mark the skinframe as used for the purging code
3126 skinframe->loadsequence = r_skinframe.loadsequence;
3129 void R_SkinFrame_Purge(void)
3133 for (i = 0;i < SKINFRAME_HASH;i++)
3135 for (s = r_skinframe.hash[i];s;s = s->next)
3137 if (s->loadsequence && s->loadsequence != r_skinframe.loadsequence)
3139 if (s->merged == s->base)
3141 // FIXME: maybe pass a pointer to the pointer to R_PurgeTexture and reset it to NULL inside? [11/29/2007 Black]
3142 R_PurgeTexture(s->stain );s->stain = NULL;
3143 R_PurgeTexture(s->merged);s->merged = NULL;
3144 R_PurgeTexture(s->base );s->base = NULL;
3145 R_PurgeTexture(s->pants );s->pants = NULL;
3146 R_PurgeTexture(s->shirt );s->shirt = NULL;
3147 R_PurgeTexture(s->nmap );s->nmap = NULL;
3148 R_PurgeTexture(s->gloss );s->gloss = NULL;
3149 R_PurgeTexture(s->glow );s->glow = NULL;
3150 R_PurgeTexture(s->fog );s->fog = NULL;
3151 R_PurgeTexture(s->reflect);s->reflect = NULL;
3152 s->loadsequence = 0;
3158 skinframe_t *R_SkinFrame_FindNextByName( skinframe_t *last, const char *name ) {
3160 char basename[MAX_QPATH];
3162 Image_StripImageExtension(name, basename, sizeof(basename));
3164 if( last == NULL ) {
3166 hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
3167 item = r_skinframe.hash[hashindex];
3172 // linearly search through the hash bucket
3173 for( ; item ; item = item->next ) {
3174 if( !strcmp( item->basename, basename ) ) {
3181 skinframe_t *R_SkinFrame_Find(const char *name, int textureflags, int comparewidth, int compareheight, int comparecrc, qboolean add)
3185 char basename[MAX_QPATH];
3187 Image_StripImageExtension(name, basename, sizeof(basename));
3189 hashindex = CRC_Block((unsigned char *)basename, strlen(basename)) & (SKINFRAME_HASH - 1);
3190 for (item = r_skinframe.hash[hashindex];item;item = item->next)
3191 if (!strcmp(item->basename, basename) && (comparecrc < 0 || (item->textureflags == textureflags && item->comparewidth == comparewidth && item->compareheight == compareheight && item->comparecrc == comparecrc)))
3195 rtexture_t *dyntexture;
3196 // check whether its a dynamic texture
3197 dyntexture = CL_GetDynTexture( basename );
3198 if (!add && !dyntexture)
3200 item = (skinframe_t *)Mem_ExpandableArray_AllocRecord(&r_skinframe.array);
3201 memset(item, 0, sizeof(*item));
3202 strlcpy(item->basename, basename, sizeof(item->basename));
3203 item->base = dyntexture; // either NULL or dyntexture handle
3204 item->textureflags = textureflags & ~TEXF_FORCE_RELOAD;
3205 item->comparewidth = comparewidth;
3206 item->compareheight = compareheight;
3207 item->comparecrc = comparecrc;
3208 item->next = r_skinframe.hash[hashindex];
3209 r_skinframe.hash[hashindex] = item;
3211 else if (textureflags & TEXF_FORCE_RELOAD)
3213 rtexture_t *dyntexture;
3214 // check whether its a dynamic texture
3215 dyntexture = CL_GetDynTexture( basename );
3216 if (!add && !dyntexture)
3218 if (item->merged == item->base)
3219 item->merged = NULL;
3220 // FIXME: maybe pass a pointer to the pointer to R_PurgeTexture and reset it to NULL inside? [11/29/2007 Black]
3221 R_PurgeTexture(item->stain );item->stain = NULL;
3222 R_PurgeTexture(item->merged);item->merged = NULL;
3223 R_PurgeTexture(item->base );item->base = NULL;
3224 R_PurgeTexture(item->pants );item->pants = NULL;
3225 R_PurgeTexture(item->shirt );item->shirt = NULL;
3226 R_PurgeTexture(item->nmap );item->nmap = NULL;
3227 R_PurgeTexture(item->gloss );item->gloss = NULL;
3228 R_PurgeTexture(item->glow );item->glow = NULL;
3229 R_PurgeTexture(item->fog );item->fog = NULL;
3230 R_PurgeTexture(item->reflect);item->reflect = NULL;
3231 item->loadsequence = 0;
3233 else if( item->base == NULL )
3235 rtexture_t *dyntexture;
3236 // check whether its a dynamic texture
3237 // this only needs to be done because Purge doesnt delete skinframes - only sets the texture pointers to NULL and we need to restore it before returing.. [11/29/2007 Black]
3238 dyntexture = CL_GetDynTexture( basename );
3239 item->base = dyntexture; // either NULL or dyntexture handle
3242 R_SkinFrame_MarkUsed(item);
3246 #define R_SKINFRAME_LOAD_AVERAGE_COLORS(cnt, getpixel) \
3248 unsigned long long avgcolor[5], wsum; \
3256 for(pix = 0; pix < cnt; ++pix) \
3259 for(comp = 0; comp < 3; ++comp) \
3261 if(w) /* ignore perfectly black pixels because that is better for model skins */ \
3264 /* comp = 3; -- not needed, comp is always 3 when we get here */ \
3266 for(comp = 0; comp < 3; ++comp) \
3267 avgcolor[comp] += getpixel * w; \
3270 /* comp = 3; -- not needed, comp is always 3 when we get here */ \
3271 avgcolor[4] += getpixel; \
3273 if(avgcolor[3] == 0) /* no pixels seen? even worse */ \
3275 skinframe->avgcolor[0] = avgcolor[2] / (255.0 * avgcolor[3]); \
3276 skinframe->avgcolor[1] = avgcolor[1] / (255.0 * avgcolor[3]); \
3277 skinframe->avgcolor[2] = avgcolor[0] / (255.0 * avgcolor[3]); \
3278 skinframe->avgcolor[3] = avgcolor[4] / (255.0 * cnt); \
3281 extern cvar_t gl_picmip;
3282 skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboolean complain)
3285 unsigned char *pixels;
3286 unsigned char *bumppixels;
3287 unsigned char *basepixels = NULL;
3288 int basepixels_width = 0;
3289 int basepixels_height = 0;
3290 skinframe_t *skinframe;
3291 rtexture_t *ddsbase = NULL;
3292 qboolean ddshasalpha = false;
3293 float ddsavgcolor[4];
3294 char basename[MAX_QPATH];
3295 int miplevel = R_PicmipForFlags(textureflags);
3296 int savemiplevel = miplevel;
3300 if (cls.state == ca_dedicated)
3303 // return an existing skinframe if already loaded
3304 // if loading of the first image fails, don't make a new skinframe as it
3305 // would cause all future lookups of this to be missing
3306 skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
3307 if (skinframe && skinframe->base)
3310 Image_StripImageExtension(name, basename, sizeof(basename));
3312 // check for DDS texture file first
3313 if (!r_loaddds || !(ddsbase = R_LoadTextureDDSFile(r_main_texturepool, va(vabuf, sizeof(vabuf), "dds/%s.dds", basename), vid.sRGB3D, textureflags, &ddshasalpha, ddsavgcolor, miplevel, false)))
3315 basepixels = loadimagepixelsbgra(name, complain, true, false, &miplevel);
3316 if (basepixels == NULL)
3320 // FIXME handle miplevel
3322 if (developer_loading.integer)
3323 Con_Printf("loading skin \"%s\"\n", name);
3325 // we've got some pixels to store, so really allocate this new texture now
3327 skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, true);
3328 textureflags &= ~TEXF_FORCE_RELOAD;
3329 skinframe->stain = NULL;
3330 skinframe->merged = NULL;
3331 skinframe->base = NULL;
3332 skinframe->pants = NULL;
3333 skinframe->shirt = NULL;
3334 skinframe->nmap = NULL;
3335 skinframe->gloss = NULL;
3336 skinframe->glow = NULL;
3337 skinframe->fog = NULL;
3338 skinframe->reflect = NULL;
3339 skinframe->hasalpha = false;
3343 skinframe->base = ddsbase;
3344 skinframe->hasalpha = ddshasalpha;
3345 VectorCopy(ddsavgcolor, skinframe->avgcolor);
3346 if (r_loadfog && skinframe->hasalpha)
3347 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);
3348 //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]);
3352 basepixels_width = image_width;
3353 basepixels_height = image_height;
3354 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);
3355 if (textureflags & TEXF_ALPHA)
3357 for (j = 3;j < basepixels_width * basepixels_height * 4;j += 4)
3359 if (basepixels[j] < 255)
3361 skinframe->hasalpha = true;
3365 if (r_loadfog && skinframe->hasalpha)
3367 // has transparent pixels
3368 pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
3369 for (j = 0;j < image_width * image_height * 4;j += 4)
3374 pixels[j+3] = basepixels[j+3];
3376 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);
3380 R_SKINFRAME_LOAD_AVERAGE_COLORS(basepixels_width * basepixels_height, basepixels[4 * pix + comp]);
3382 //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]);
3383 if (r_savedds && qglGetCompressedTexImageARB && skinframe->base)
3384 R_SaveTextureDDSFile(skinframe->base, va(vabuf, sizeof(vabuf), "dds/%s.dds", skinframe->basename), r_texture_dds_save.integer < 2, skinframe->hasalpha);
3385 if (r_savedds && qglGetCompressedTexImageARB && skinframe->fog)
3386 R_SaveTextureDDSFile(skinframe->fog, va(vabuf, sizeof(vabuf), "dds/%s_mask.dds", skinframe->basename), r_texture_dds_save.integer < 2, true);
3392 mymiplevel = savemiplevel;
3393 if (r_loadnormalmap)
3394 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);
3395 skinframe->glow = R_LoadTextureDDSFile(r_main_texturepool, va(vabuf, sizeof(vabuf), "dds/%s_glow.dds", skinframe->basename), vid.sRGB3D, textureflags, NULL, NULL, mymiplevel, true);
3397 skinframe->gloss = R_LoadTextureDDSFile(r_main_texturepool, va(vabuf, sizeof(vabuf), "dds/%s_gloss.dds", skinframe->basename), vid.sRGB3D, textureflags, NULL, NULL, mymiplevel, true);
3398 skinframe->pants = R_LoadTextureDDSFile(r_main_texturepool, va(vabuf, sizeof(vabuf), "dds/%s_pants.dds", skinframe->basename), vid.sRGB3D, textureflags, NULL, NULL, mymiplevel, true);
3399 skinframe->shirt = R_LoadTextureDDSFile(r_main_texturepool, va(vabuf, sizeof(vabuf), "dds/%s_shirt.dds", skinframe->basename), vid.sRGB3D, textureflags, NULL, NULL, mymiplevel, true);
3400 skinframe->reflect = R_LoadTextureDDSFile(r_main_texturepool, va(vabuf, sizeof(vabuf), "dds/%s_reflect.dds", skinframe->basename), vid.sRGB3D, textureflags, NULL, NULL, mymiplevel, true);
3403 // _norm is the name used by tenebrae and has been adopted as standard
3404 if (r_loadnormalmap && skinframe->nmap == NULL)
3406 mymiplevel = savemiplevel;
3407 if ((pixels = loadimagepixelsbgra(va(vabuf, sizeof(vabuf), "%s_norm", skinframe->basename), false, false, false, &mymiplevel)) != NULL)
3409 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);
3413 else if (r_shadow_bumpscale_bumpmap.value > 0 && (bumppixels = loadimagepixelsbgra(va(vabuf, sizeof(vabuf), "%s_bump", skinframe->basename), false, false, false, &mymiplevel)) != NULL)
3415 pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
3416 Image_HeightmapToNormalmap_BGRA(bumppixels, pixels, image_width, image_height, false, r_shadow_bumpscale_bumpmap.value);
3417 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);
3419 Mem_Free(bumppixels);
3421 else if (r_shadow_bumpscale_basetexture.value > 0)
3423 pixels = (unsigned char *)Mem_Alloc(tempmempool, basepixels_width * basepixels_height * 4);
3424 Image_HeightmapToNormalmap_BGRA(basepixels, pixels, basepixels_width, basepixels_height, false, r_shadow_bumpscale_basetexture.value);
3425 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);
3429 if (r_savedds && qglGetCompressedTexImageARB && skinframe->nmap)
3430 R_SaveTextureDDSFile(skinframe->nmap, va(vabuf, sizeof(vabuf), "dds/%s_norm.dds", skinframe->basename), r_texture_dds_save.integer < 2, true);
3434 // _luma is supported only for tenebrae compatibility
3435 // _glow is the preferred name
3436 mymiplevel = savemiplevel;
3437 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_luma", skinframe->basename), false, false, false, &mymiplevel))))
3439 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);
3441 if (r_savedds && qglGetCompressedTexImageARB && skinframe->glow)
3442 R_SaveTextureDDSFile(skinframe->glow, va(vabuf, sizeof(vabuf), "dds/%s_glow.dds", skinframe->basename), r_texture_dds_save.integer < 2, true);
3444 Mem_Free(pixels);pixels = NULL;
3447 mymiplevel = savemiplevel;
3448 if (skinframe->gloss == NULL && r_loadgloss && (pixels = loadimagepixelsbgra(va(vabuf, sizeof(vabuf), "%s_gloss", skinframe->basename), false, false, false, &mymiplevel)))
3450 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);
3452 if (r_savedds && qglGetCompressedTexImageARB && skinframe->gloss)
3453 R_SaveTextureDDSFile(skinframe->gloss, va(vabuf, sizeof(vabuf), "dds/%s_gloss.dds", skinframe->basename), r_texture_dds_save.integer < 2, true);
3459 mymiplevel = savemiplevel;
3460 if (skinframe->pants == NULL && (pixels = loadimagepixelsbgra(va(vabuf, sizeof(vabuf), "%s_pants", skinframe->basename), false, false, false, &mymiplevel)))
3462 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);
3464 if (r_savedds && qglGetCompressedTexImageARB && skinframe->pants)
3465 R_SaveTextureDDSFile(skinframe->pants, va(vabuf, sizeof(vabuf), "dds/%s_pants.dds", skinframe->basename), r_texture_dds_save.integer < 2, false);
3471 mymiplevel = savemiplevel;
3472 if (skinframe->shirt == NULL && (pixels = loadimagepixelsbgra(va(vabuf, sizeof(vabuf), "%s_shirt", skinframe->basename), false, false, false, &mymiplevel)))
3474 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);
3476 if (r_savedds && qglGetCompressedTexImageARB && skinframe->shirt)
3477 R_SaveTextureDDSFile(skinframe->shirt, va(vabuf, sizeof(vabuf), "dds/%s_shirt.dds", skinframe->basename), r_texture_dds_save.integer < 2, false);
3483 mymiplevel = savemiplevel;
3484 if (skinframe->reflect == NULL && (pixels = loadimagepixelsbgra(va(vabuf, sizeof(vabuf), "%s_reflect", skinframe->basename), false, false, false, &mymiplevel)))
3486 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);
3488 if (r_savedds && qglGetCompressedTexImageARB && skinframe->reflect)
3489 R_SaveTextureDDSFile(skinframe->reflect, va(vabuf, sizeof(vabuf), "dds/%s_reflect.dds", skinframe->basename), r_texture_dds_save.integer < 2, true);
3496 Mem_Free(basepixels);
3501 // this is only used by .spr32 sprites, HL .spr files, HL .bsp files
3502 skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, const unsigned char *skindata, int width, int height, qboolean sRGB)
3505 unsigned char *temp1, *temp2;
3506 skinframe_t *skinframe;
3509 if (cls.state == ca_dedicated)
3512 // if already loaded just return it, otherwise make a new skinframe
3513 skinframe = R_SkinFrame_Find(name, textureflags, width, height, (textureflags & TEXF_FORCE_RELOAD) ? -1 : skindata ? CRC_Block(skindata, width*height*4) : 0, true);
3514 if (skinframe && skinframe->base)
3516 textureflags &= ~TEXF_FORCE_RELOAD;
3518 skinframe->stain = NULL;
3519 skinframe->merged = NULL;
3520 skinframe->base = NULL;
3521 skinframe->pants = NULL;
3522 skinframe->shirt = NULL;
3523 skinframe->nmap = NULL;
3524 skinframe->gloss = NULL;
3525 skinframe->glow = NULL;
3526 skinframe->fog = NULL;
3527 skinframe->reflect = NULL;
3528 skinframe->hasalpha = false;
3530 // if no data was provided, then clearly the caller wanted to get a blank skinframe
3534 if (developer_loading.integer)
3535 Con_Printf("loading 32bit skin \"%s\"\n", name);
3537 if (r_loadnormalmap && r_shadow_bumpscale_basetexture.value > 0)
3539 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
3540 temp2 = temp1 + width * height * 4;
3541 Image_HeightmapToNormalmap_BGRA(skindata, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
3542 skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, (textureflags | TEXF_ALPHA) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP), -1, NULL);
3545 skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, sRGB ? TEXTYPE_SRGB_BGRA : TEXTYPE_BGRA, textureflags, -1, NULL);
3546 if (textureflags & TEXF_ALPHA)
3548 for (i = 3;i < width * height * 4;i += 4)
3550 if (skindata[i] < 255)
3552 skinframe->hasalpha = true;
3556 if (r_loadfog && skinframe->hasalpha)
3558 unsigned char *fogpixels = (unsigned char *)Mem_Alloc(tempmempool, width * height * 4);
3559 memcpy(fogpixels, skindata, width * height * 4);
3560 for (i = 0;i < width * height * 4;i += 4)
3561 fogpixels[i] = fogpixels[i+1] = fogpixels[i+2] = 255;
3562 skinframe->fog = R_LoadTexture2D(r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_fog", skinframe->basename), width, height, fogpixels, TEXTYPE_BGRA, textureflags, -1, NULL);
3563 Mem_Free(fogpixels);
3567 R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, skindata[4 * pix + comp]);
3568 //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]);
3573 skinframe_t *R_SkinFrame_LoadInternalQuake(const char *name, int textureflags, int loadpantsandshirt, int loadglowtexture, const unsigned char *skindata, int width, int height)
3577 skinframe_t *skinframe;
3579 if (cls.state == ca_dedicated)
3582 // if already loaded just return it, otherwise make a new skinframe
3583 skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height) : 0, true);
3584 if (skinframe && skinframe->base)
3586 textureflags &= ~TEXF_FORCE_RELOAD;
3588 skinframe->stain = NULL;
3589 skinframe->merged = NULL;
3590 skinframe->base = NULL;
3591 skinframe->pants = NULL;
3592 skinframe->shirt = NULL;
3593 skinframe->nmap = NULL;
3594 skinframe->gloss = NULL;
3595 skinframe->glow = NULL;
3596 skinframe->fog = NULL;
3597 skinframe->reflect = NULL;
3598 skinframe->hasalpha = false;
3600 // if no data was provided, then clearly the caller wanted to get a blank skinframe
3604 if (developer_loading.integer)
3605 Con_Printf("loading quake skin \"%s\"\n", name);
3607 // 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)
3608 skinframe->qpixels = (unsigned char *)Mem_Alloc(r_main_mempool, width*height); // FIXME LEAK
3609 memcpy(skinframe->qpixels, skindata, width*height);
3610 skinframe->qwidth = width;
3611 skinframe->qheight = height;
3614 for (i = 0;i < width * height;i++)
3615 featuresmask |= palette_featureflags[skindata[i]];
3617 skinframe->hasalpha = false;
3618 skinframe->qhascolormapping = loadpantsandshirt && (featuresmask & (PALETTEFEATURE_PANTS | PALETTEFEATURE_SHIRT));
3619 skinframe->qgeneratenmap = r_shadow_bumpscale_basetexture.value > 0;
3620 skinframe->qgeneratemerged = true;
3621 skinframe->qgeneratebase = skinframe->qhascolormapping;
3622 skinframe->qgenerateglow = loadglowtexture && (featuresmask & PALETTEFEATURE_GLOW);
3624 R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, ((unsigned char *)palette_bgra_complete)[skindata[pix]*4 + comp]);
3625 //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]);
3630 static void R_SkinFrame_GenerateTexturesFromQPixels(skinframe_t *skinframe, qboolean colormapped)
3634 unsigned char *skindata;
3637 if (!skinframe->qpixels)
3640 if (!skinframe->qhascolormapping)
3641 colormapped = false;
3645 if (!skinframe->qgeneratebase)
3650 if (!skinframe->qgeneratemerged)
3654 width = skinframe->qwidth;
3655 height = skinframe->qheight;
3656 skindata = skinframe->qpixels;
3658 if (skinframe->qgeneratenmap)
3660 unsigned char *temp1, *temp2;
3661 skinframe->qgeneratenmap = false;
3662 temp1 = (unsigned char *)Mem_Alloc(tempmempool, width * height * 8);
3663 temp2 = temp1 + width * height * 4;
3664 // use either a custom palette or the quake palette
3665 Image_Copy8bitBGRA(skindata, temp1, width * height, palette_bgra_complete);
3666 Image_HeightmapToNormalmap_BGRA(temp1, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
3667 skinframe->nmap = R_LoadTexture2D(r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_nmap", skinframe->basename), width, height, temp2, TEXTYPE_BGRA, (skinframe->textureflags | TEXF_ALPHA) & (r_mipnormalmaps.integer ? ~0 : ~TEXF_MIPMAP), -1, NULL);
3671 if (skinframe->qgenerateglow)
3673 skinframe->qgenerateglow = false;
3674 skinframe->glow = R_LoadTexture2D(r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_glow", skinframe->basename), width, height, skindata, vid.sRGB3D ? TEXTYPE_SRGB_PALETTE : TEXTYPE_PALETTE, skinframe->textureflags, -1, palette_bgra_onlyfullbrights); // glow
3679 skinframe->qgeneratebase = false;
3680 skinframe->base = R_LoadTexture2D(r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_nospecial", skinframe->basename), width, height, skindata, vid.sRGB3D ? TEXTYPE_SRGB_PALETTE : TEXTYPE_PALETTE, skinframe->textureflags, -1, skinframe->glow ? palette_bgra_nocolormapnofullbrights : palette_bgra_nocolormap);
3681 skinframe->pants = R_LoadTexture2D(r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_pants", skinframe->basename), width, height, skindata, vid.sRGB3D ? TEXTYPE_SRGB_PALETTE : TEXTYPE_PALETTE, skinframe->textureflags, -1, palette_bgra_pantsaswhite);
3682 skinframe->shirt = R_LoadTexture2D(r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_shirt", skinframe->basename), width, height, skindata, vid.sRGB3D ? TEXTYPE_SRGB_PALETTE : TEXTYPE_PALETTE, skinframe->textureflags, -1, palette_bgra_shirtaswhite);
3686 skinframe->qgeneratemerged = false;
3687 skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, vid.sRGB3D ? TEXTYPE_SRGB_PALETTE : TEXTYPE_PALETTE, skinframe->textureflags, -1, skinframe->glow ? palette_bgra_nofullbrights : palette_bgra_complete);
3690 if (!skinframe->qgeneratemerged && !skinframe->qgeneratebase)
3692 Mem_Free(skinframe->qpixels);
3693 skinframe->qpixels = NULL;
3697 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)
3700 skinframe_t *skinframe;
3703 if (cls.state == ca_dedicated)
3706 // if already loaded just return it, otherwise make a new skinframe
3707 skinframe = R_SkinFrame_Find(name, textureflags, width, height, skindata ? CRC_Block(skindata, width*height) : 0, true);
3708 if (skinframe && skinframe->base)
3710 textureflags &= ~TEXF_FORCE_RELOAD;
3712 skinframe->stain = NULL;
3713 skinframe->merged = NULL;
3714 skinframe->base = NULL;
3715 skinframe->pants = NULL;
3716 skinframe->shirt = NULL;
3717 skinframe->nmap = NULL;
3718 skinframe->gloss = NULL;
3719 skinframe->glow = NULL;
3720 skinframe->fog = NULL;
3721 skinframe->reflect = NULL;
3722 skinframe->hasalpha = false;
3724 // if no data was provided, then clearly the caller wanted to get a blank skinframe
3728 if (developer_loading.integer)
3729 Con_Printf("loading embedded 8bit image \"%s\"\n", name);
3731 skinframe->base = skinframe->merged = R_LoadTexture2D(r_main_texturepool, skinframe->basename, width, height, skindata, TEXTYPE_PALETTE, textureflags, -1, palette);
3732 if (textureflags & TEXF_ALPHA)
3734 for (i = 0;i < width * height;i++)
3736 if (((unsigned char *)palette)[skindata[i]*4+3] < 255)
3738 skinframe->hasalpha = true;
3742 if (r_loadfog && skinframe->hasalpha)
3743 skinframe->fog = R_LoadTexture2D(r_main_texturepool, va(vabuf, sizeof(vabuf), "%s_fog", skinframe->basename), width, height, skindata, TEXTYPE_PALETTE, textureflags, -1, alphapalette);
3746 R_SKINFRAME_LOAD_AVERAGE_COLORS(width * height, ((unsigned char *)palette)[skindata[pix]*4 + comp]);
3747 //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]);
3752 skinframe_t *R_SkinFrame_LoadMissing(void)
3754 skinframe_t *skinframe;
3756 if (cls.state == ca_dedicated)
3759 skinframe = R_SkinFrame_Find("missing", TEXF_FORCENEAREST, 0, 0, 0, true);
3760 skinframe->stain = NULL;
3761 skinframe->merged = NULL;
3762 skinframe->base = NULL;
3763 skinframe->pants = NULL;
3764 skinframe->shirt = NULL;
3765 skinframe->nmap = NULL;
3766 skinframe->gloss = NULL;
3767 skinframe->glow = NULL;
3768 skinframe->fog = NULL;
3769 skinframe->reflect = NULL;
3770 skinframe->hasalpha = false;
3772 skinframe->avgcolor[0] = rand() / RAND_MAX;
3773 skinframe->avgcolor[1] = rand() / RAND_MAX;
3774 skinframe->avgcolor[2] = rand() / RAND_MAX;
3775 skinframe->avgcolor[3] = 1;
3780 //static char *suffix[6] = {"ft", "bk", "rt", "lf", "up", "dn"};
3781 typedef struct suffixinfo_s
3784 qboolean flipx, flipy, flipdiagonal;
3787 static suffixinfo_t suffix[3][6] =
3790 {"px", false, false, false},
3791 {"nx", false, false, false},
3792 {"py", false, false, false},
3793 {"ny", false, false, false},
3794 {"pz", false, false, false},
3795 {"nz", false, false, false}
3798 {"posx", false, false, false},
3799 {"negx", false, false, false},
3800 {"posy", false, false, false},
3801 {"negy", false, false, false},
3802 {"posz", false, false, false},
3803 {"negz", false, false, false}
3806 {"rt", true, false, true},
3807 {"lf", false, true, true},
3808 {"ft", true, true, false},
3809 {"bk", false, false, false},
3810 {"up", true, false, true},
3811 {"dn", true, false, true}
3815 static int componentorder[4] = {0, 1, 2, 3};
3817 static rtexture_t *R_LoadCubemap(const char *basename)
3819 int i, j, cubemapsize;
3820 unsigned char *cubemappixels, *image_buffer;
3821 rtexture_t *cubemaptexture;
3823 // must start 0 so the first loadimagepixels has no requested width/height
3825 cubemappixels = NULL;
3826 cubemaptexture = NULL;
3827 // keep trying different suffix groups (posx, px, rt) until one loads
3828 for (j = 0;j < 3 && !cubemappixels;j++)
3830 // load the 6 images in the suffix group
3831 for (i = 0;i < 6;i++)
3833 // generate an image name based on the base and and suffix
3834 dpsnprintf(name, sizeof(name), "%s%s", basename, suffix[j][i].suffix);
3836 if ((image_buffer = loadimagepixelsbgra(name, false, false, false, NULL)))
3838 // an image loaded, make sure width and height are equal
3839 if (image_width == image_height && (!cubemappixels || image_width == cubemapsize))
3841 // if this is the first image to load successfully, allocate the cubemap memory
3842 if (!cubemappixels && image_width >= 1)
3844 cubemapsize = image_width;
3845 // note this clears to black, so unavailable sides are black
3846 cubemappixels = (unsigned char *)Mem_Alloc(tempmempool, 6*cubemapsize*cubemapsize*4);
3848 // copy the image with any flipping needed by the suffix (px and posx types don't need flipping)
3850 Image_CopyMux(cubemappixels+i*cubemapsize*cubemapsize*4, image_buffer, cubemapsize, cubemapsize, suffix[j][i].flipx, suffix[j][i].flipy, suffix[j][i].flipdiagonal, 4, 4, componentorder);
3853 Con_Printf("Cubemap image \"%s\" (%ix%i) is not square, OpenGL requires square cubemaps.\n", name, image_width, image_height);
3855 Mem_Free(image_buffer);
3859 // if a cubemap loaded, upload it
3862 if (developer_loading.integer)
3863 Con_Printf("loading cubemap \"%s\"\n", basename);
3865 cubemaptexture = R_LoadTextureCubeMap(r_main_texturepool, basename, cubemapsize, cubemappixels, vid.sRGB3D ? TEXTYPE_SRGB_BGRA : TEXTYPE_BGRA, (gl_texturecompression_lightcubemaps.integer && gl_texturecompression.integer ? TEXF_COMPRESS : 0) | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
3866 Mem_Free(cubemappixels);
3870 Con_DPrintf("failed to load cubemap \"%s\"\n", basename);
3871 if (developer_loading.integer)
3873 Con_Printf("(tried tried images ");
3874 for (j = 0;j < 3;j++)
3875 for (i = 0;i < 6;i++)
3876 Con_Printf("%s\"%s%s.tga\"", j + i > 0 ? ", " : "", basename, suffix[j][i].suffix);
3877 Con_Print(" and was unable to find any of them).\n");
3880 return cubemaptexture;
3883 rtexture_t *R_GetCubemap(const char *basename)
3886 for (i = 0;i < r_texture_numcubemaps;i++)
3887 if (r_texture_cubemaps[i] != NULL)
3888 if (!strcasecmp(r_texture_cubemaps[i]->basename, basename))
3889 return r_texture_cubemaps[i]->texture ? r_texture_cubemaps[i]->texture : r_texture_whitecube;
3890 if (i >= MAX_CUBEMAPS || !r_main_mempool)
3891 return r_texture_whitecube;
3892 r_texture_numcubemaps++;
3893 r_texture_cubemaps[i] = (cubemapinfo_t *)Mem_Alloc(r_main_mempool, sizeof(cubemapinfo_t));
3894 strlcpy(r_texture_cubemaps[i]->basename, basename, sizeof(r_texture_cubemaps[i]->basename));
3895 r_texture_cubemaps[i]->texture = R_LoadCubemap(r_texture_cubemaps[i]->basename);
3896 return r_texture_cubemaps[i]->texture;
3899 static void R_Main_FreeViewCache(void)
3901 if (r_refdef.viewcache.entityvisible)
3902 Mem_Free(r_refdef.viewcache.entityvisible);
3903 if (r_refdef.viewcache.world_pvsbits)
3904 Mem_Free(r_refdef.viewcache.world_pvsbits);
3905 if (r_refdef.viewcache.world_leafvisible)
3906 Mem_Free(r_refdef.viewcache.world_leafvisible);
3907 if (r_refdef.viewcache.world_surfacevisible)
3908 Mem_Free(r_refdef.viewcache.world_surfacevisible);
3909 memset(&r_refdef.viewcache, 0, sizeof(r_refdef.viewcache));
3912 static void R_Main_ResizeViewCache(void)
3914 int numentities = r_refdef.scene.numentities;
3915 int numclusters = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_pvsclusters : 1;
3916 int numclusterbytes = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_pvsclusterbytes : 1;
3917 int numleafs = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->brush.num_leafs : 1;
3918 int numsurfaces = r_refdef.scene.worldmodel ? r_refdef.scene.worldmodel->num_surfaces : 1;
3919 if (r_refdef.viewcache.maxentities < numentities)
3921 r_refdef.viewcache.maxentities = numentities;
3922 if (r_refdef.viewcache.entityvisible)
3923 Mem_Free(r_refdef.viewcache.entityvisible);
3924 r_refdef.viewcache.entityvisible = (unsigned char *)Mem_Alloc(r_main_mempool, r_refdef.viewcache.maxentities);
3926 if (r_refdef.viewcache.world_numclusters != numclusters)
3928 r_refdef.viewcache.world_numclusters = numclusters;
3929 r_refdef.viewcache.world_numclusterbytes = numclusterbytes;
3930 if (r_refdef.viewcache.world_pvsbits)
3931 Mem_Free(r_refdef.viewcache.world_pvsbits);
3932 r_refdef.viewcache.world_pvsbits = (unsigned char *)Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numclusterbytes);
3934 if (r_refdef.viewcache.world_numleafs != numleafs)
3936 r_refdef.viewcache.world_numleafs = numleafs;
3937 if (r_refdef.viewcache.world_leafvisible)
3938 Mem_Free(r_refdef.viewcache.world_leafvisible);
3939 r_refdef.viewcache.world_leafvisible = (unsigned char *)Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numleafs);
3941 if (r_refdef.viewcache.world_numsurfaces != numsurfaces)
3943 r_refdef.viewcache.world_numsurfaces = numsurfaces;
3944 if (r_refdef.viewcache.world_surfacevisible)
3945 Mem_Free(r_refdef.viewcache.world_surfacevisible);
3946 r_refdef.viewcache.world_surfacevisible = (unsigned char *)Mem_Alloc(r_main_mempool, r_refdef.viewcache.world_numsurfaces);
3950 extern rtexture_t *loadingscreentexture;
3951 static void gl_main_start(void)
3953 loadingscreentexture = NULL;
3954 r_texture_blanknormalmap = NULL;
3955 r_texture_white = NULL;
3956 r_texture_grey128 = NULL;
3957 r_texture_black = NULL;
3958 r_texture_whitecube = NULL;
3959 r_texture_normalizationcube = NULL;
3960 r_texture_fogattenuation = NULL;
3961 r_texture_fogheighttexture = NULL;
3962 r_texture_gammaramps = NULL;
3963 r_texture_numcubemaps = 0;
3965 r_loaddds = r_texture_dds_load.integer != 0;
3966 r_savedds = vid.support.arb_texture_compression && vid.support.ext_texture_compression_s3tc && r_texture_dds_save.integer;
3968 switch(vid.renderpath)
3970 case RENDERPATH_GL20:
3971 case RENDERPATH_D3D9:
3972 case RENDERPATH_D3D10:
3973 case RENDERPATH_D3D11:
3974 case RENDERPATH_SOFT:
3975 case RENDERPATH_GLES2:
3976 Cvar_SetValueQuick(&r_textureunits, vid.texunits);
3977 Cvar_SetValueQuick(&gl_combine, 1);
3978 Cvar_SetValueQuick(&r_glsl, 1);
3979 r_loadnormalmap = true;
3983 case RENDERPATH_GL13:
3984 case RENDERPATH_GLES1:
3985 Cvar_SetValueQuick(&r_textureunits, vid.texunits);
3986 Cvar_SetValueQuick(&gl_combine, 1);
3987 Cvar_SetValueQuick(&r_glsl, 0);
3988 r_loadnormalmap = false;
3989 r_loadgloss = false;
3992 case RENDERPATH_GL11:
3993 Cvar_SetValueQuick(&r_textureunits, vid.texunits);
3994 Cvar_SetValueQuick(&gl_combine, 0);
3995 Cvar_SetValueQuick(&r_glsl, 0);
3996 r_loadnormalmap = false;
3997 r_loadgloss = false;
4003 R_FrameData_Reset();
4007 memset(r_queries, 0, sizeof(r_queries));
4009 r_qwskincache = NULL;
4010 r_qwskincache_size = 0;
4012 // due to caching of texture_t references, the collision cache must be reset
4013 Collision_Cache_Reset(true);
4015 // set up r_skinframe loading system for textures
4016 memset(&r_skinframe, 0, sizeof(r_skinframe));
4017 r_skinframe.loadsequence = 1;
4018 Mem_ExpandableArray_NewArray(&r_skinframe.array, r_main_mempool, sizeof(skinframe_t), 256);
4020 r_main_texturepool = R_AllocTexturePool();
4021 R_BuildBlankTextures();
4023 if (vid.support.arb_texture_cube_map)
4026 R_BuildNormalizationCube();
4028 r_texture_fogattenuation = NULL;
4029 r_texture_fogheighttexture = NULL;
4030 r_texture_gammaramps = NULL;
4031 //r_texture_fogintensity = NULL;
4032 memset(&r_fb, 0, sizeof(r_fb));
4033 r_glsl_permutation = NULL;
4034 memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash));
4035 Mem_ExpandableArray_NewArray(&r_glsl_permutationarray, r_main_mempool, sizeof(r_glsl_permutation_t), 256);
4036 glslshaderstring = NULL;
4038 r_hlsl_permutation = NULL;
4039 memset(r_hlsl_permutationhash, 0, sizeof(r_hlsl_permutationhash));
4040 Mem_ExpandableArray_NewArray(&r_hlsl_permutationarray, r_main_mempool, sizeof(r_hlsl_permutation_t), 256);
4042 hlslshaderstring = NULL;
4043 memset(&r_svbsp, 0, sizeof (r_svbsp));
4045 memset(r_texture_cubemaps, 0, sizeof(r_texture_cubemaps));
4046 r_texture_numcubemaps = 0;
4048 r_refdef.fogmasktable_density = 0;
4051 static void gl_main_shutdown(void)
4054 R_FrameData_Reset();
4056 R_Main_FreeViewCache();
4058 switch(vid.renderpath)
4060 case RENDERPATH_GL11:
4061 case RENDERPATH_GL13:
4062 case RENDERPATH_GL20:
4063 case RENDERPATH_GLES1:
4064 case RENDERPATH_GLES2:
4065 #ifdef GL_SAMPLES_PASSED_ARB
4067 qglDeleteQueriesARB(r_maxqueries, r_queries);
4070 case RENDERPATH_D3D9:
4071 //Con_DPrintf("FIXME D3D9 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4073 case RENDERPATH_D3D10:
4074 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4076 case RENDERPATH_D3D11:
4077 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
4079 case RENDERPATH_SOFT:
4085 memset(r_queries, 0, sizeof(r_queries));
4087 r_qwskincache = NULL;
4088 r_qwskincache_size = 0;
4090 // clear out the r_skinframe state
4091 Mem_ExpandableArray_FreeArray(&r_skinframe.array);
4092 memset(&r_skinframe, 0, sizeof(r_skinframe));
4095 Mem_Free(r_svbsp.nodes);
4096 memset(&r_svbsp, 0, sizeof (r_svbsp));
4097 R_FreeTexturePool(&r_main_texturepool);
4098 loadingscreentexture = NULL;
4099 r_texture_blanknormalmap = NULL;
4100 r_texture_white = NULL;
4101 r_texture_grey128 = NULL;
4102 r_texture_black = NULL;
4103 r_texture_whitecube = NULL;
4104 r_texture_normalizationcube = NULL;
4105 r_texture_fogattenuation = NULL;
4106 r_texture_fogheighttexture = NULL;
4107 r_texture_gammaramps = NULL;
4108 r_texture_numcubemaps = 0;
4109 //r_texture_fogintensity = NULL;
4110 memset(&r_fb, 0, sizeof(r_fb));
4113 r_glsl_permutation = NULL;
4114 memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash));
4115 Mem_ExpandableArray_FreeArray(&r_glsl_permutationarray);
4116 glslshaderstring = NULL;
4118 r_hlsl_permutation = NULL;
4119 memset(r_hlsl_permutationhash, 0, sizeof(r_hlsl_permutationhash));
4120 Mem_ExpandableArray_FreeArray(&r_hlsl_permutationarray);
4122 hlslshaderstring = NULL;
4125 static void gl_main_newmap(void)
4127 // FIXME: move this code to client
4128 char *entities, entname[MAX_QPATH];
4130 Mem_Free(r_qwskincache);
4131 r_qwskincache = NULL;
4132 r_qwskincache_size = 0;
4135 dpsnprintf(entname, sizeof(entname), "%s.ent", cl.worldnamenoextension);
4136 if ((entities = (char *)FS_LoadFile(entname, tempmempool, true, NULL)))
4138 CL_ParseEntityLump(entities);
4142 if (cl.worldmodel->brush.entities)
4143 CL_ParseEntityLump(cl.worldmodel->brush.entities);
4145 R_Main_FreeViewCache();
4147 R_FrameData_Reset();
4150 void GL_Main_Init(void)
4152 r_main_mempool = Mem_AllocPool("Renderer", 0, NULL);
4154 Cmd_AddCommand("r_glsl_restart", R_GLSL_Restart_f, "unloads GLSL shaders, they will then be reloaded as needed");
4155 Cmd_AddCommand("r_glsl_dumpshader", R_GLSL_DumpShader_f, "dumps the engine internal default.glsl shader into glsl/default.glsl");
4156 // FIXME: the client should set up r_refdef.fog stuff including the fogmasktable
4157 if (gamemode == GAME_NEHAHRA)
4159 Cvar_RegisterVariable (&gl_fogenable);
4160 Cvar_RegisterVariable (&gl_fogdensity);
4161 Cvar_RegisterVariable (&gl_fogred);
4162 Cvar_RegisterVariable (&gl_foggreen);
4163 Cvar_RegisterVariable (&gl_fogblue);
4164 Cvar_RegisterVariable (&gl_fogstart);
4165 Cvar_RegisterVariable (&gl_fogend);
4166 Cvar_RegisterVariable (&gl_skyclip);
4168 Cvar_RegisterVariable(&r_motionblur);
4169 Cvar_RegisterVariable(&r_damageblur);
4170 Cvar_RegisterVariable(&r_motionblur_averaging);
4171 Cvar_RegisterVariable(&r_motionblur_randomize);
4172 Cvar_RegisterVariable(&r_motionblur_minblur);
4173 Cvar_RegisterVariable(&r_motionblur_maxblur);
4174 Cvar_RegisterVariable(&r_motionblur_velocityfactor);
4175 Cvar_RegisterVariable(&r_motionblur_velocityfactor_minspeed);
4176 Cvar_RegisterVariable(&r_motionblur_velocityfactor_maxspeed);
4177 Cvar_RegisterVariable(&r_motionblur_mousefactor);
4178 Cvar_RegisterVariable(&r_motionblur_mousefactor_minspeed);
4179 Cvar_RegisterVariable(&r_motionblur_mousefactor_maxspeed);
4180 Cvar_RegisterVariable(&r_equalize_entities_fullbright);
4181 Cvar_RegisterVariable(&r_equalize_entities_minambient);
4182 Cvar_RegisterVariable(&r_equalize_entities_by);
4183 Cvar_RegisterVariable(&r_equalize_entities_to);
4184 Cvar_RegisterVariable(&r_depthfirst);
4185 Cvar_RegisterVariable(&r_useinfinitefarclip);
4186 Cvar_RegisterVariable(&r_farclip_base);
4187 Cvar_RegisterVariable(&r_farclip_world);
4188 Cvar_RegisterVariable(&r_nearclip);
4189 Cvar_RegisterVariable(&r_deformvertexes);
4190 Cvar_RegisterVariable(&r_transparent);
4191 Cvar_RegisterVariable(&r_transparent_alphatocoverage);
4192 Cvar_RegisterVariable(&r_transparent_sortsurfacesbynearest);
4193 Cvar_RegisterVariable(&r_transparent_useplanardistance);
4194 Cvar_RegisterVariable(&r_showoverdraw);
4195 Cvar_RegisterVariable(&r_showbboxes);
4196 Cvar_RegisterVariable(&r_showsurfaces);
4197 Cvar_RegisterVariable(&r_showtris);
4198 Cvar_RegisterVariable(&r_shownormals);
4199 Cvar_RegisterVariable(&r_showlighting);
4200 Cvar_RegisterVariable(&r_showshadowvolumes);
4201 Cvar_RegisterVariable(&r_showcollisionbrushes);
4202 Cvar_RegisterVariable(&r_showcollisionbrushes_polygonfactor);
4203 Cvar_RegisterVariable(&r_showcollisionbrushes_polygonoffset);
4204 Cvar_RegisterVariable(&r_showdisabledepthtest);
4205 Cvar_RegisterVariable(&r_drawportals);
4206 Cvar_RegisterVariable(&r_drawentities);
4207 Cvar_RegisterVariable(&r_draw2d);
4208 Cvar_RegisterVariable(&r_drawworld);
4209 Cvar_RegisterVariable(&r_cullentities_trace);
4210 Cvar_RegisterVariable(&r_cullentities_trace_samples);
4211 Cvar_RegisterVariable(&r_cullentities_trace_tempentitysamples);
4212 Cvar_RegisterVariable(&r_cullentities_trace_enlarge);
4213 Cvar_RegisterVariable(&r_cullentities_trace_delay);
4214 Cvar_RegisterVariable(&r_sortentities);
4215 Cvar_RegisterVariable(&r_drawviewmodel);
4216 Cvar_RegisterVariable(&r_drawexteriormodel);
4217 Cvar_RegisterVariable(&r_speeds);
4218 Cvar_RegisterVariable(&r_fullbrights);
4219 Cvar_RegisterVariable(&r_wateralpha);
4220 Cvar_RegisterVariable(&r_dynamic);
4221 Cvar_RegisterVariable(&r_fakelight);
4222 Cvar_RegisterVariable(&r_fakelight_intensity);
4223 Cvar_RegisterVariable(&r_fullbright);
4224 Cvar_RegisterVariable(&r_shadows);
4225 Cvar_RegisterVariable(&r_shadows_darken);
4226 Cvar_RegisterVariable(&r_shadows_drawafterrtlighting);
4227 Cvar_RegisterVariable(&r_shadows_castfrombmodels);
4228 Cvar_RegisterVariable(&r_shadows_throwdistance);
4229 Cvar_RegisterVariable(&r_shadows_throwdirection);
4230 Cvar_RegisterVariable(&r_shadows_focus);
4231 Cvar_RegisterVariable(&r_shadows_shadowmapscale);
4232 Cvar_RegisterVariable(&r_q1bsp_skymasking);
4233 Cvar_RegisterVariable(&r_polygonoffset_submodel_factor);
4234 Cvar_RegisterVariable(&r_polygonoffset_submodel_offset);
4235 Cvar_RegisterVariable(&r_polygonoffset_decals_factor);
4236 Cvar_RegisterVariable(&r_polygonoffset_decals_offset);
4237 Cvar_RegisterVariable(&r_fog_exp2);
4238 Cvar_RegisterVariable(&r_fog_clear);
4239 Cvar_RegisterVariable(&r_drawfog);
4240 Cvar_RegisterVariable(&r_transparentdepthmasking);
4241 Cvar_RegisterVariable(&r_transparent_sortmindist);
4242 Cvar_RegisterVariable(&r_transparent_sortmaxdist);
4243 Cvar_RegisterVariable(&r_transparent_sortarraysize);
4244 Cvar_RegisterVariable(&r_texture_dds_load);
4245 Cvar_RegisterVariable(&r_texture_dds_save);
4246 Cvar_RegisterVariable(&r_textureunits);
4247 Cvar_RegisterVariable(&gl_combine);
4248 Cvar_RegisterVariable(&r_usedepthtextures);
4249 Cvar_RegisterVariable(&r_viewfbo);
4250 Cvar_RegisterVariable(&r_viewscale);
4251 Cvar_RegisterVariable(&r_viewscale_fpsscaling);
4252 Cvar_RegisterVariable(&r_viewscale_fpsscaling_min);
4253 Cvar_RegisterVariable(&r_viewscale_fpsscaling_multiply);
4254 Cvar_RegisterVariable(&r_viewscale_fpsscaling_stepsize);
4255 Cvar_RegisterVariable(&r_viewscale_fpsscaling_stepmax);
4256 Cvar_RegisterVariable(&r_viewscale_fpsscaling_target);
4257 Cvar_RegisterVariable(&r_glsl);
4258 Cvar_RegisterVariable(&r_glsl_deluxemapping);
4259 Cvar_RegisterVariable(&r_glsl_offsetmapping);
4260 Cvar_RegisterVariable(&r_glsl_offsetmapping_steps);
4261 Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping);
4262 Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping_steps);
4263 Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping_refinesteps);
4264 Cvar_RegisterVariable(&r_glsl_offsetmapping_scale);
4265 Cvar_RegisterVariable(&r_glsl_offsetmapping_lod);
4266 Cvar_RegisterVariable(&r_glsl_offsetmapping_lod_distance);
4267 Cvar_RegisterVariable(&r_glsl_postprocess);
4268 Cvar_RegisterVariable(&r_glsl_postprocess_uservec1);
4269 Cvar_RegisterVariable(&r_glsl_postprocess_uservec2);
4270 Cvar_RegisterVariable(&r_glsl_postprocess_uservec3);
4271 Cvar_RegisterVariable(&r_glsl_postprocess_uservec4);
4272 Cvar_RegisterVariable(&r_glsl_postprocess_uservec1_enable);
4273 Cvar_RegisterVariable(&r_glsl_postprocess_uservec2_enable);
4274 Cvar_RegisterVariable(&r_glsl_postprocess_uservec3_enable);
4275 Cvar_RegisterVariable(&r_glsl_postprocess_uservec4_enable);
4276 Cvar_RegisterVariable(&r_celshading);
4277 Cvar_RegisterVariable(&r_celoutlines);
4279 Cvar_RegisterVariable(&r_water);
4280 Cvar_RegisterVariable(&r_water_resolutionmultiplier);
4281 Cvar_RegisterVariable(&r_water_clippingplanebias);
4282 Cvar_RegisterVariable(&r_water_refractdistort);
4283 Cvar_RegisterVariable(&r_water_reflectdistort);
4284 Cvar_RegisterVariable(&r_water_scissormode);
4285 Cvar_RegisterVariable(&r_water_lowquality);
4286 Cvar_RegisterVariable(&r_water_hideplayer);
4287 Cvar_RegisterVariable(&r_water_fbo);
4289 Cvar_RegisterVariable(&r_lerpsprites);
4290 Cvar_RegisterVariable(&r_lerpmodels);
4291 Cvar_RegisterVariable(&r_lerplightstyles);
4292 Cvar_RegisterVariable(&r_waterscroll);
4293 Cvar_RegisterVariable(&r_bloom);
4294 Cvar_RegisterVariable(&r_bloom_colorscale);
4295 Cvar_RegisterVariable(&r_bloom_brighten);
4296 Cvar_RegisterVariable(&r_bloom_blur);
4297 Cvar_RegisterVariable(&r_bloom_resolution);
4298 Cvar_RegisterVariable(&r_bloom_colorexponent);
4299 Cvar_RegisterVariable(&r_bloom_colorsubtract);
4300 Cvar_RegisterVariable(&r_hdr_scenebrightness);
4301 Cvar_RegisterVariable(&r_hdr_glowintensity);
4302 Cvar_RegisterVariable(&r_hdr_irisadaptation);
4303 Cvar_RegisterVariable(&r_hdr_irisadaptation_multiplier);
4304 Cvar_RegisterVariable(&r_hdr_irisadaptation_minvalue);
4305 Cvar_RegisterVariable(&r_hdr_irisadaptation_maxvalue);
4306 Cvar_RegisterVariable(&r_hdr_irisadaptation_value);
4307 Cvar_RegisterVariable(&r_hdr_irisadaptation_fade_up);
4308 Cvar_RegisterVariable(&r_hdr_irisadaptation_fade_down);
4309 Cvar_RegisterVariable(&r_hdr_irisadaptation_radius);
4310 Cvar_RegisterVariable(&r_smoothnormals_areaweighting);
4311 Cvar_RegisterVariable(&developer_texturelogging);
4312 Cvar_RegisterVariable(&gl_lightmaps);
4313 Cvar_RegisterVariable(&r_test);
4314 Cvar_RegisterVariable(&r_glsl_saturation);
4315 Cvar_RegisterVariable(&r_glsl_saturation_redcompensate);
4316 Cvar_RegisterVariable(&r_glsl_vertextextureblend_usebothalphas);
4317 Cvar_RegisterVariable(&r_framedatasize);
4318 if (gamemode == GAME_NEHAHRA || gamemode == GAME_TENEBRAE)
4319 Cvar_SetValue("r_fullbrights", 0);
4320 R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap, NULL, NULL);
4323 void Render_Init(void)
4336 R_LightningBeams_Init();
4346 extern char *ENGINE_EXTENSIONS;
4349 gl_renderer = (const char *)qglGetString(GL_RENDERER);
4350 gl_vendor = (const char *)qglGetString(GL_VENDOR);
4351 gl_version = (const char *)qglGetString(GL_VERSION);
4352 gl_extensions = (const char *)qglGetString(GL_EXTENSIONS);
4356 if (!gl_platformextensions)
4357 gl_platformextensions = "";
4359 Con_Printf("GL_VENDOR: %s\n", gl_vendor);
4360 Con_Printf("GL_RENDERER: %s\n", gl_renderer);
4361 Con_Printf("GL_VERSION: %s\n", gl_version);
4362 Con_DPrintf("GL_EXTENSIONS: %s\n", gl_extensions);
4363 Con_DPrintf("%s_EXTENSIONS: %s\n", gl_platform, gl_platformextensions);
4365 VID_CheckExtensions();
4367 // LordHavoc: report supported extensions
4368 Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
4370 // clear to black (loading plaque will be seen over this)
4371 GL_Clear(GL_COLOR_BUFFER_BIT, NULL, 1.0f, 128);
4375 int R_CullBox(const vec3_t mins, const vec3_t maxs)
4379 if (r_trippy.integer)
4381 for (i = 0;i < r_refdef.view.numfrustumplanes;i++)
4383 // skip nearclip plane, it often culls portals when you are very close, and is almost never useful
4386 p = r_refdef.view.frustum + i;
4391 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
4395 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
4399 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
4403 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
4407 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
4411 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
4415 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
4419 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
4427 int R_CullBoxCustomPlanes(const vec3_t mins, const vec3_t maxs, int numplanes, const mplane_t *planes)
4431 if (r_trippy.integer)
4433 for (i = 0;i < numplanes;i++)
4440 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
4444 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
4448 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
4452 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
4456 if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
4460 if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
4464 if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
4468 if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
4476 //==================================================================================
4478 // LordHavoc: this stores temporary data used within the same frame
4480 typedef struct r_framedata_mem_s
4482 struct r_framedata_mem_s *purge; // older mem block to free on next frame
4483 size_t size; // how much usable space
4484 size_t current; // how much space in use
4485 size_t mark; // last "mark" location, temporary memory can be freed by returning to this
4486 size_t wantedsize; // how much space was allocated
4487 unsigned char *data; // start of real data (16byte aligned)
4491 static r_framedata_mem_t *r_framedata_mem;
4493 void R_FrameData_Reset(void)
4495 while (r_framedata_mem)
4497 r_framedata_mem_t *next = r_framedata_mem->purge;
4498 Mem_Free(r_framedata_mem);
4499 r_framedata_mem = next;
4503 static void R_FrameData_Resize(void)
4506 wantedsize = (size_t)(r_framedatasize.value * 1024*1024);
4507 wantedsize = bound(65536, wantedsize, 1000*1024*1024);
4508 if (!r_framedata_mem || r_framedata_mem->wantedsize != wantedsize)
4510 r_framedata_mem_t *newmem = (r_framedata_mem_t *)Mem_Alloc(r_main_mempool, wantedsize);
4511 newmem->wantedsize = wantedsize;
4512 newmem->data = (unsigned char *)(((size_t)(newmem+1) + 15) & ~15);
4513 newmem->size = (unsigned char *)newmem + wantedsize - newmem->data;
4514 newmem->current = 0;
4516 newmem->purge = r_framedata_mem;
4517 r_framedata_mem = newmem;
4521 void R_FrameData_NewFrame(void)
4523 R_FrameData_Resize();
4524 if (!r_framedata_mem)
4526 // if we ran out of space on the last frame, free the old memory now
4527 while (r_framedata_mem->purge)
4529 // repeatedly remove the second item in the list, leaving only head
4530 r_framedata_mem_t *next = r_framedata_mem->purge->purge;
4531 Mem_Free(r_framedata_mem->purge);
4532 r_framedata_mem->purge = next;
4534 // reset the current mem pointer
4535 r_framedata_mem->current = 0;
4536 r_framedata_mem->mark = 0;
4539 void *R_FrameData_Alloc(size_t size)
4543 // align to 16 byte boundary - the data pointer is already aligned, so we
4544 // only need to ensure the size of every allocation is also aligned
4545 size = (size + 15) & ~15;
4547 while (!r_framedata_mem || r_framedata_mem->current + size > r_framedata_mem->size)
4549 // emergency - we ran out of space, allocate more memory
4550 Cvar_SetValueQuick(&r_framedatasize, bound(0.25f, r_framedatasize.value * 2.0f, 128.0f));
4551 R_FrameData_Resize();
4554 data = r_framedata_mem->data + r_framedata_mem->current;
4555 r_framedata_mem->current += size;
4557 // count the usage for stats
4558 r_refdef.stats.framedatacurrent = max(r_refdef.stats.framedatacurrent, (int)r_framedata_mem->current);
4559 r_refdef.stats.framedatasize = max(r_refdef.stats.framedatasize, (int)r_framedata_mem->size);
4561 return (void *)data;
4564 void *R_FrameData_Store(size_t size, void *data)
4566 void *d = R_FrameData_Alloc(size);
4568 memcpy(d, data, size);
4572 void R_FrameData_SetMark(void)
4574 if (!r_framedata_mem)
4576 r_framedata_mem->mark = r_framedata_mem->current;
4579 void R_FrameData_ReturnToMark(void)
4581 if (!r_framedata_mem)
4583 r_framedata_mem->current = r_framedata_mem->mark;
4586 //==================================================================================
4588 // LordHavoc: animcache originally written by Echon, rewritten since then
4591 * Animation cache prevents re-generating mesh data for an animated model
4592 * multiple times in one frame for lighting, shadowing, reflections, etc.
4595 void R_AnimCache_Free(void)
4599 void R_AnimCache_ClearCache(void)
4602 entity_render_t *ent;
4604 for (i = 0;i < r_refdef.scene.numentities;i++)
4606 ent = r_refdef.scene.entities[i];
4607 ent->animcache_vertex3f = NULL;
4608 ent->animcache_normal3f = NULL;
4609 ent->animcache_svector3f = NULL;
4610 ent->animcache_tvector3f = NULL;
4611 ent->animcache_vertexmesh = NULL;
4612 ent->animcache_vertex3fbuffer = NULL;
4613 ent->animcache_vertexmeshbuffer = NULL;
4617 static void R_AnimCache_UpdateEntityMeshBuffers(entity_render_t *ent, int numvertices)
4621 // check if we need the meshbuffers
4622 if (!vid.useinterleavedarrays)
4625 if (!ent->animcache_vertexmesh && ent->animcache_normal3f)
4626 ent->animcache_vertexmesh = (r_vertexmesh_t *)R_FrameData_Alloc(sizeof(r_vertexmesh_t)*numvertices);
4627 // TODO: upload vertex3f buffer?
4628 if (ent->animcache_vertexmesh)
4630 memcpy(ent->animcache_vertexmesh, ent->model->surfmesh.vertexmesh, sizeof(r_vertexmesh_t)*numvertices);
4631 for (i = 0;i < numvertices;i++)
4632 memcpy(ent->animcache_vertexmesh[i].vertex3f, ent->animcache_vertex3f + 3*i, sizeof(float[3]));
4633 if (ent->animcache_svector3f)
4634 for (i = 0;i < numvertices;i++)
4635 memcpy(ent->animcache_vertexmesh[i].svector3f, ent->animcache_svector3f + 3*i, sizeof(float[3]));
4636 if (ent->animcache_tvector3f)
4637 for (i = 0;i < numvertices;i++)
4638 memcpy(ent->animcache_vertexmesh[i].tvector3f, ent->animcache_tvector3f + 3*i, sizeof(float[3]));
4639 if (ent->animcache_normal3f)
4640 for (i = 0;i < numvertices;i++)
4641 memcpy(ent->animcache_vertexmesh[i].normal3f, ent->animcache_normal3f + 3*i, sizeof(float[3]));
4642 // TODO: upload vertexmeshbuffer?
4646 qboolean R_AnimCache_GetEntity(entity_render_t *ent, qboolean wantnormals, qboolean wanttangents)
4648 dp_model_t *model = ent->model;
4650 // see if it's already cached this frame
4651 if (ent->animcache_vertex3f)
4653 // add normals/tangents if needed (this only happens with multiple views, reflections, cameras, etc)
4654 if (wantnormals || wanttangents)
4656 if (ent->animcache_normal3f)
4657 wantnormals = false;
4658 if (ent->animcache_svector3f)
4659 wanttangents = false;
4660 if (wantnormals || wanttangents)
4662 numvertices = model->surfmesh.num_vertices;
4664 ent->animcache_normal3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
4667 ent->animcache_svector3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
4668 ent->animcache_tvector3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
4670 model->AnimateVertices(model, ent->frameblend, ent->skeleton, NULL, wantnormals ? ent->animcache_normal3f : NULL, wanttangents ? ent->animcache_svector3f : NULL, wanttangents ? ent->animcache_tvector3f : NULL);
4671 R_AnimCache_UpdateEntityMeshBuffers(ent, model->surfmesh.num_vertices);
4677 // see if this ent is worth caching
4678 if (!model || !model->Draw || !model->surfmesh.isanimated || !model->AnimateVertices)
4680 // get some memory for this entity and generate mesh data
4681 numvertices = model->surfmesh.num_vertices;
4682 ent->animcache_vertex3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
4684 ent->animcache_normal3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
4687 ent->animcache_svector3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
4688 ent->animcache_tvector3f = (float *)R_FrameData_Alloc(sizeof(float[3])*numvertices);
4690 model->AnimateVertices(model, ent->frameblend, ent->skeleton, ent->animcache_vertex3f, ent->animcache_normal3f, ent->animcache_svector3f, ent->animcache_tvector3f);
4691 R_AnimCache_UpdateEntityMeshBuffers(ent, model->surfmesh.num_vertices);
4696 void R_AnimCache_CacheVisibleEntities(void)
4699 qboolean wantnormals = true;
4700 qboolean wanttangents = !r_showsurfaces.integer;
4702 switch(vid.renderpath)
4704 case RENDERPATH_GL20:
4705 case RENDERPATH_D3D9:
4706 case RENDERPATH_D3D10:
4707 case RENDERPATH_D3D11:
4708 case RENDERPATH_GLES2:
4710 case RENDERPATH_GL11:
4711 case RENDERPATH_GL13:
4712 case RENDERPATH_GLES1:
4713 wanttangents = false;
4715 case RENDERPATH_SOFT:
4719 if (r_shownormals.integer)
4720 wanttangents = wantnormals = true;
4722 // TODO: thread this
4723 // NOTE: R_PrepareRTLights() also caches entities
4725 for (i = 0;i < r_refdef.scene.numentities;i++)
4726 if (r_refdef.viewcache.entityvisible[i])
4727 R_AnimCache_GetEntity(r_refdef.scene.entities[i], wantnormals, wanttangents);
4730 //==================================================================================
4732 extern cvar_t r_overheadsprites_pushback;
4734 static void R_View_UpdateEntityLighting (void)
4737 entity_render_t *ent;
4738 vec3_t tempdiffusenormal, avg;
4739 vec_t f, fa, fd, fdd;
4740 qboolean skipunseen = r_shadows.integer != 1; //|| R_Shadow_ShadowMappingEnabled();
4742 for (i = 0;i < r_refdef.scene.numentities;i++)
4744 ent = r_refdef.scene.entities[i];
4746 // skip unseen models
4747 if ((!r_refdef.viewcache.entityvisible[i] && skipunseen))
4751 if (ent->model && ent->model == cl.worldmodel)
4753 // TODO: use modellight for r_ambient settings on world?
4754 VectorSet(ent->modellight_ambient, 0, 0, 0);
4755 VectorSet(ent->modellight_diffuse, 0, 0, 0);
4756 VectorSet(ent->modellight_lightdir, 0, 0, 1);
4760 if (ent->flags & RENDER_CUSTOMIZEDMODELLIGHT)
4762 // aleady updated by CSQC
4763 // TODO: force modellight on BSP models in this case?
4764 VectorCopy(ent->modellight_lightdir, tempdiffusenormal);
4768 // fetch the lighting from the worldmodel data
4769 VectorClear(ent->modellight_ambient);
4770 VectorClear(ent->modellight_diffuse);
4771 VectorClear(tempdiffusenormal);
4772 if (ent->flags & RENDER_LIGHT)
4775 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
4777 // complete lightning for lit sprites
4778 // todo: make a EF_ field so small ents could be lit purely by modellight and skipping real rtlight pass (like EF_NORTLIGHT)?
4779 if (ent->model->type == mod_sprite && !(ent->model->data_textures[0].basematerialflags & MATERIALFLAG_FULLBRIGHT))
4781 if (ent->model->sprite.sprnum_type == SPR_OVERHEAD) // apply offset for overhead sprites
4782 org[2] = org[2] + r_overheadsprites_pushback.value;
4783 R_LightPoint(ent->modellight_ambient, org, LP_LIGHTMAP | LP_RTWORLD | LP_DYNLIGHT);
4786 R_CompleteLightPoint(ent->modellight_ambient, ent->modellight_diffuse, tempdiffusenormal, org, LP_LIGHTMAP);
4788 if(ent->flags & RENDER_EQUALIZE)
4790 // first fix up ambient lighting...
4791 if(r_equalize_entities_minambient.value > 0)
4793 fd = 0.299f * ent->modellight_diffuse[0] + 0.587f * ent->modellight_diffuse[1] + 0.114f * ent->modellight_diffuse[2];
4796 fa = (0.299f * ent->modellight_ambient[0] + 0.587f * ent->modellight_ambient[1] + 0.114f * ent->modellight_ambient[2]);
4797 if(fa < r_equalize_entities_minambient.value * fd)
4800 // fa'/fd' = minambient
4801 // fa'+0.25*fd' = fa+0.25*fd
4803 // fa' = fd' * minambient
4804 // fd'*(0.25+minambient) = fa+0.25*fd
4806 // fd' = (fa+0.25*fd) * 1 / (0.25+minambient)
4807 // fa' = (fa+0.25*fd) * minambient / (0.25+minambient)
4809 fdd = (fa + 0.25f * fd) / (0.25f + r_equalize_entities_minambient.value);
4810 f = fdd / fd; // f>0 because all this is additive; f<1 because fdd<fd because this follows from fa < r_equalize_entities_minambient.value * fd
4811 VectorMA(ent->modellight_ambient, (1-f)*0.25f, ent->modellight_diffuse, ent->modellight_ambient);
4812 VectorScale(ent->modellight_diffuse, f, ent->modellight_diffuse);
4817 if(r_equalize_entities_to.value > 0 && r_equalize_entities_by.value != 0)
4819 fa = 0.299f * ent->modellight_ambient[0] + 0.587f * ent->modellight_ambient[1] + 0.114f * ent->modellight_ambient[2];
4820 fd = 0.299f * ent->modellight_diffuse[0] + 0.587f * ent->modellight_diffuse[1] + 0.114f * ent->modellight_diffuse[2];
4824 // adjust brightness and saturation to target
4825 avg[0] = avg[1] = avg[2] = fa / f;
4826 VectorLerp(ent->modellight_ambient, r_equalize_entities_by.value, avg, ent->modellight_ambient);
4827 avg[0] = avg[1] = avg[2] = fd / f;
4828 VectorLerp(ent->modellight_diffuse, r_equalize_entities_by.value, avg, ent->modellight_diffuse);
4834 VectorSet(ent->modellight_ambient, 1, 1, 1);
4837 // move the light direction into modelspace coordinates for lighting code
4838 Matrix4x4_Transform3x3(&ent->inversematrix, tempdiffusenormal, ent->modellight_lightdir);
4839 if(VectorLength2(ent->modellight_lightdir) == 0)
4840 VectorSet(ent->modellight_lightdir, 0, 0, 1); // have to set SOME valid vector here
4841 VectorNormalize(ent->modellight_lightdir);
4845 #define MAX_LINEOFSIGHTTRACES 64
4847 static qboolean R_CanSeeBox(int numsamples, vec_t enlarge, vec3_t eye, vec3_t entboxmins, vec3_t entboxmaxs)
4850 vec3_t boxmins, boxmaxs;
4853 dp_model_t *model = r_refdef.scene.worldmodel;
4855 if (!model || !model->brush.TraceLineOfSight)
4858 // expand the box a little
4859 boxmins[0] = (enlarge+1) * entboxmins[0] - enlarge * entboxmaxs[0];
4860 boxmaxs[0] = (enlarge+1) * entboxmaxs[0] - enlarge * entboxmins[0];
4861 boxmins[1] = (enlarge+1) * entboxmins[1] - enlarge * entboxmaxs[1];
4862 boxmaxs[1] = (enlarge+1) * entboxmaxs[1] - enlarge * entboxmins[1];
4863 boxmins[2] = (enlarge+1) * entboxmins[2] - enlarge * entboxmaxs[2];
4864 boxmaxs[2] = (enlarge+1) * entboxmaxs[2] - enlarge * entboxmins[2];
4866 // return true if eye is inside enlarged box
4867 if (BoxesOverlap(boxmins, boxmaxs, eye, eye))
4871 VectorCopy(eye, start);
4872 VectorMAM(0.5f, boxmins, 0.5f, boxmaxs, end);
4873 if (model->brush.TraceLineOfSight(model, start, end))
4876 // try various random positions
4877 for (i = 0;i < numsamples;i++)
4879 VectorSet(end, lhrandom(boxmins[0], boxmaxs[0]), lhrandom(boxmins[1], boxmaxs[1]), lhrandom(boxmins[2], boxmaxs[2]));
4880 if (model->brush.TraceLineOfSight(model, start, end))
4888 static void R_View_UpdateEntityVisible (void)
4893 entity_render_t *ent;
4895 renderimask = r_refdef.envmap ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL)
4896 : r_fb.water.hideplayer ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL)
4897 : (chase_active.integer || r_fb.water.renderingscene) ? RENDER_VIEWMODEL
4898 : RENDER_EXTERIORMODEL;
4899 if (!r_drawviewmodel.integer)
4900 renderimask |= RENDER_VIEWMODEL;
4901 if (!r_drawexteriormodel.integer)
4902 renderimask |= RENDER_EXTERIORMODEL;
4903 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs)
4905 // worldmodel can check visibility
4906 memset(r_refdef.viewcache.entityvisible, 0, r_refdef.scene.numentities);
4907 for (i = 0;i < r_refdef.scene.numentities;i++)
4909 ent = r_refdef.scene.entities[i];
4910 if (!(ent->flags & renderimask))
4911 if (!R_CullBox(ent->mins, ent->maxs) || (ent->model && ent->model->type == mod_sprite && (ent->model->sprite.sprnum_type == SPR_LABEL || ent->model->sprite.sprnum_type == SPR_LABEL_SCALE)))
4912 if ((ent->flags & (RENDER_NODEPTHTEST | RENDER_WORLDOBJECT | RENDER_VIEWMODEL)) || r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs(r_refdef.scene.worldmodel, r_refdef.viewcache.world_leafvisible, ent->mins, ent->maxs))
4913 r_refdef.viewcache.entityvisible[i] = true;
4918 // no worldmodel or it can't check visibility
4919 for (i = 0;i < r_refdef.scene.numentities;i++)
4921 ent = r_refdef.scene.entities[i];
4922 r_refdef.viewcache.entityvisible[i] = !(ent->flags & renderimask) && ((ent->model && ent->model->type == mod_sprite && (ent->model->sprite.sprnum_type == SPR_LABEL || ent->model->sprite.sprnum_type == SPR_LABEL_SCALE)) || !R_CullBox(ent->mins, ent->maxs));
4925 if(r_cullentities_trace.integer && r_refdef.scene.worldmodel->brush.TraceLineOfSight && !r_refdef.view.useclipplane && !r_trippy.integer)
4926 // sorry, this check doesn't work for portal/reflection/refraction renders as the view origin is not useful for culling
4928 for (i = 0;i < r_refdef.scene.numentities;i++)
4930 if (!r_refdef.viewcache.entityvisible[i])
4932 ent = r_refdef.scene.entities[i];
4933 if(!(ent->flags & (RENDER_VIEWMODEL | RENDER_WORLDOBJECT | RENDER_NODEPTHTEST)) && !(ent->model && (ent->model->name[0] == '*')))
4935 samples = ent->entitynumber ? r_cullentities_trace_samples.integer : r_cullentities_trace_tempentitysamples.integer;
4937 continue; // temp entities do pvs only
4938 if(R_CanSeeBox(samples, r_cullentities_trace_enlarge.value, r_refdef.view.origin, ent->mins, ent->maxs))
4939 ent->last_trace_visibility = realtime;
4940 if(ent->last_trace_visibility < realtime - r_cullentities_trace_delay.value)
4941 r_refdef.viewcache.entityvisible[i] = 0;
4947 /// only used if skyrendermasked, and normally returns false
4948 static int R_DrawBrushModelsSky (void)
4951 entity_render_t *ent;
4954 for (i = 0;i < r_refdef.scene.numentities;i++)
4956 if (!r_refdef.viewcache.entityvisible[i])
4958 ent = r_refdef.scene.entities[i];
4959 if (!ent->model || !ent->model->DrawSky)
4961 ent->model->DrawSky(ent);
4967 static void R_DrawNoModel(entity_render_t *ent);
4968 static void R_DrawModels(void)
4971 entity_render_t *ent;
4973 for (i = 0;i < r_refdef.scene.numentities;i++)
4975 if (!r_refdef.viewcache.entityvisible[i])
4977 ent = r_refdef.scene.entities[i];
4978 r_refdef.stats.entities++;
4980 if (ent->model && !strncmp(ent->model->name, "models/proto_", 13))
4983 Matrix4x4_ToVectors(&ent->matrix, f, l, u, o);
4984 Con_Printf("R_DrawModels\n");
4985 Con_Printf("model %s O %f %f %f F %f %f %f L %f %f %f U %f %f %f\n", ent->model->name, o[0], o[1], o[2], f[0], f[1], f[2], l[0], l[1], l[2], u[0], u[1], u[2]);
4986 Con_Printf("group: %i %f %i %f %i %f %i %f\n", ent->framegroupblend[0].frame, ent->framegroupblend[0].lerp, ent->framegroupblend[1].frame, ent->framegroupblend[1].lerp, ent->framegroupblend[2].frame, ent->framegroupblend[2].lerp, ent->framegroupblend[3].frame, ent->framegroupblend[3].lerp);
4987 Con_Printf("blend: %i %f %i %f %i %f %i %f %i %f %i %f %i %f %i %f\n", ent->frameblend[0].subframe, ent->frameblend[0].lerp, ent->frameblend[1].subframe, ent->frameblend[1].lerp, ent->frameblend[2].subframe, ent->frameblend[2].lerp, ent->frameblend[3].subframe, ent->frameblend[3].lerp, ent->frameblend[4].subframe, ent->frameblend[4].lerp, ent->frameblend[5].subframe, ent->frameblend[5].lerp, ent->frameblend[6].subframe, ent->frameblend[6].lerp, ent->frameblend[7].subframe, ent->frameblend[7].lerp);
4990 if (ent->model && ent->model->Draw != NULL)
4991 ent->model->Draw(ent);
4997 static void R_DrawModelsDepth(void)
5000 entity_render_t *ent;
5002 for (i = 0;i < r_refdef.scene.numentities;i++)
5004 if (!r_refdef.viewcache.entityvisible[i])
5006 ent = r_refdef.scene.entities[i];
5007 if (ent->model && ent->model->DrawDepth != NULL)
5008 ent->model->DrawDepth(ent);
5012 static void R_DrawModelsDebug(void)
5015 entity_render_t *ent;
5017 for (i = 0;i < r_refdef.scene.numentities;i++)
5019 if (!r_refdef.viewcache.entityvisible[i])
5021 ent = r_refdef.scene.entities[i];
5022 if (ent->model && ent->model->DrawDebug != NULL)
5023 ent->model->DrawDebug(ent);
5027 static void R_DrawModelsAddWaterPlanes(void)
5030 entity_render_t *ent;
5032 for (i = 0;i < r_refdef.scene.numentities;i++)
5034 if (!r_refdef.viewcache.entityvisible[i])
5036 ent = r_refdef.scene.entities[i];
5037 if (ent->model && ent->model->DrawAddWaterPlanes != NULL)
5038 ent->model->DrawAddWaterPlanes(ent);
5042 static float irisvecs[7][3] = {{0, 0, 0}, {-1, 0, 0}, {1, 0, 0}, {0, -1, 0}, {0, 1, 0}, {0, 0, -1}, {0, 0, 1}};
5044 void R_HDR_UpdateIrisAdaptation(const vec3_t point)
5046 if (r_hdr_irisadaptation.integer)
5051 vec3_t diffusenormal;
5053 vec_t brightness = 0.0f;
5058 VectorCopy(r_refdef.view.forward, forward);
5059 for (c = 0;c < (int)(sizeof(irisvecs)/sizeof(irisvecs[0]));c++)
5061 p[0] = point[0] + irisvecs[c][0] * r_hdr_irisadaptation_radius.value;
5062 p[1] = point[1] + irisvecs[c][1] * r_hdr_irisadaptation_radius.value;
5063 p[2] = point[2] + irisvecs[c][2] * r_hdr_irisadaptation_radius.value;
5064 R_CompleteLightPoint(ambient, diffuse, diffusenormal, p, LP_LIGHTMAP | LP_RTWORLD | LP_DYNLIGHT);
5065 d = DotProduct(forward, diffusenormal);
5066 brightness += VectorLength(ambient);
5068 brightness += d * VectorLength(diffuse);
5070 brightness *= 1.0f / c;
5071 brightness += 0.00001f; // make sure it's never zero
5072 goal = r_hdr_irisadaptation_multiplier.value / brightness;
5073 goal = bound(r_hdr_irisadaptation_minvalue.value, goal, r_hdr_irisadaptation_maxvalue.value);
5074 current = r_hdr_irisadaptation_value.value;
5076 current = min(current + r_hdr_irisadaptation_fade_up.value * cl.realframetime, goal);
5077 else if (current > goal)
5078 current = max(current - r_hdr_irisadaptation_fade_down.value * cl.realframetime, goal);
5079 if (fabs(r_hdr_irisadaptation_value.value - current) > 0.0001f)
5080 Cvar_SetValueQuick(&r_hdr_irisadaptation_value, current);
5082 else if (r_hdr_irisadaptation_value.value != 1.0f)
5083 Cvar_SetValueQuick(&r_hdr_irisadaptation_value, 1.0f);
5086 static void R_View_SetFrustum(const int *scissor)
5089 double fpx = +1, fnx = -1, fpy = +1, fny = -1;
5090 vec3_t forward, left, up, origin, v;
5094 // flipped x coordinates (because x points left here)
5095 fpx = 1.0 - 2.0 * (scissor[0] - r_refdef.view.viewport.x) / (double) (r_refdef.view.viewport.width);
5096 fnx = 1.0 - 2.0 * (scissor[0] + scissor[2] - r_refdef.view.viewport.x) / (double) (r_refdef.view.viewport.width);
5098 // D3D Y coordinate is top to bottom, OpenGL is bottom to top, fix the D3D one
5099 switch(vid.renderpath)
5101 case RENDERPATH_D3D9:
5102 case RENDERPATH_D3D10:
5103 case RENDERPATH_D3D11:
5104 // non-flipped y coordinates
5105 fny = -1.0 + 2.0 * (vid.height - scissor[1] - scissor[3] - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height);
5106 fpy = -1.0 + 2.0 * (vid.height - scissor[1] - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height);
5108 case RENDERPATH_SOFT:
5109 case RENDERPATH_GL11:
5110 case RENDERPATH_GL13:
5111 case RENDERPATH_GL20:
5112 case RENDERPATH_GLES1:
5113 case RENDERPATH_GLES2:
5114 // non-flipped y coordinates
5115 fny = -1.0 + 2.0 * (scissor[1] - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height);
5116 fpy = -1.0 + 2.0 * (scissor[1] + scissor[3] - r_refdef.view.viewport.y) / (double) (r_refdef.view.viewport.height);
5121 // we can't trust r_refdef.view.forward and friends in reflected scenes
5122 Matrix4x4_ToVectors(&r_refdef.view.matrix, forward, left, up, origin);
5125 r_refdef.view.frustum[0].normal[0] = 0 - 1.0 / r_refdef.view.frustum_x;
5126 r_refdef.view.frustum[0].normal[1] = 0 - 0;
5127 r_refdef.view.frustum[0].normal[2] = -1 - 0;
5128 r_refdef.view.frustum[1].normal[0] = 0 + 1.0 / r_refdef.view.frustum_x;
5129 r_refdef.view.frustum[1].normal[1] = 0 + 0;
5130 r_refdef.view.frustum[1].normal[2] = -1 + 0;
5131 r_refdef.view.frustum[2].normal[0] = 0 - 0;
5132 r_refdef.view.frustum[2].normal[1] = 0 - 1.0 / r_refdef.view.frustum_y;
5133 r_refdef.view.frustum[2].normal[2] = -1 - 0;
5134 r_refdef.view.frustum[3].normal[0] = 0 + 0;
5135 r_refdef.view.frustum[3].normal[1] = 0 + 1.0 / r_refdef.view.frustum_y;
5136 r_refdef.view.frustum[3].normal[2] = -1 + 0;
5140 zNear = r_refdef.nearclip;
5141 nudge = 1.0 - 1.0 / (1<<23);
5142 r_refdef.view.frustum[4].normal[0] = 0 - 0;
5143 r_refdef.view.frustum[4].normal[1] = 0 - 0;
5144 r_refdef.view.frustum[4].normal[2] = -1 - -nudge;
5145 r_refdef.view.frustum[4].dist = 0 - -2 * zNear * nudge;
5146 r_refdef.view.frustum[5].normal[0] = 0 + 0;
5147 r_refdef.view.frustum[5].normal[1] = 0 + 0;
5148 r_refdef.view.frustum[5].normal[2] = -1 + -nudge;
5149 r_refdef.view.frustum[5].dist = 0 + -2 * zNear * nudge;
5155 r_refdef.view.frustum[0].normal[0] = m[3] - m[0];
5156 r_refdef.view.frustum[0].normal[1] = m[7] - m[4];
5157 r_refdef.view.frustum[0].normal[2] = m[11] - m[8];
5158 r_refdef.view.frustum[0].dist = m[15] - m[12];
5160 r_refdef.view.frustum[1].normal[0] = m[3] + m[0];
5161 r_refdef.view.frustum[1].normal[1] = m[7] + m[4];
5162 r_refdef.view.frustum[1].normal[2] = m[11] + m[8];
5163 r_refdef.view.frustum[1].dist = m[15] + m[12];
5165 r_refdef.view.frustum[2].normal[0] = m[3] - m[1];
5166 r_refdef.view.frustum[2].normal[1] = m[7] - m[5];
5167 r_refdef.view.frustum[2].normal[2] = m[11] - m[9];
5168 r_refdef.view.frustum[2].dist = m[15] - m[13];
5170 r_refdef.view.frustum[3].normal[0] = m[3] + m[1];
5171 r_refdef.view.frustum[3].normal[1] = m[7] + m[5];
5172 r_refdef.view.frustum[3].normal[2] = m[11] + m[9];
5173 r_refdef.view.frustum[3].dist = m[15] + m[13];
5175 r_refdef.view.frustum[4].normal[0] = m[3] - m[2];
5176 r_refdef.view.frustum[4].normal[1] = m[7] - m[6];
5177 r_refdef.view.frustum[4].normal[2] = m[11] - m[10];
5178 r_refdef.view.frustum[4].dist = m[15] - m[14];
5180 r_refdef.view.frustum[5].normal[0] = m[3] + m[2];
5181 r_refdef.view.frustum[5].normal[1] = m[7] + m[6];
5182 r_refdef.view.frustum[5].normal[2] = m[11] + m[10];
5183 r_refdef.view.frustum[5].dist = m[15] + m[14];
5186 if (r_refdef.view.useperspective)
5188 // calculate frustum corners, which are used to calculate deformed frustum planes for shadow caster culling
5189 VectorMAMAM(1024, forward, fnx * 1024.0 * r_refdef.view.frustum_x, left, fny * 1024.0 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[0]);
5190 VectorMAMAM(1024, forward, fpx * 1024.0 * r_refdef.view.frustum_x, left, fny * 1024.0 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[1]);
5191 VectorMAMAM(1024, forward, fnx * 1024.0 * r_refdef.view.frustum_x, left, fpy * 1024.0 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[2]);
5192 VectorMAMAM(1024, forward, fpx * 1024.0 * r_refdef.view.frustum_x, left, fpy * 1024.0 * r_refdef.view.frustum_y, up, r_refdef.view.frustumcorner[3]);
5194 // then the normals from the corners relative to origin
5195 CrossProduct(r_refdef.view.frustumcorner[2], r_refdef.view.frustumcorner[0], r_refdef.view.frustum[0].normal);
5196 CrossProduct(r_refdef.view.frustumcorner[1], r_refdef.view.frustumcorner[3], r_refdef.view.frustum[1].normal);
5197 CrossProduct(r_refdef.view.frustumcorner[0], r_refdef.view.frustumcorner[1], r_refdef.view.frustum[2].normal);
5198 CrossProduct(r_refdef.view.frustumcorner[3], r_refdef.view.frustumcorner[2], r_refdef.view.frustum[3].normal);
5200 // in a NORMAL view, forward cross left == up
5201 // in a REFLECTED view, forward cross left == down
5202 // so our cross products above need to be adjusted for a left handed coordinate system
5203 CrossProduct(forward, left, v);
5204 if(DotProduct(v, up) < 0)
5206 VectorNegate(r_refdef.view.frustum[0].normal, r_refdef.view.frustum[0].normal);
5207 VectorNegate(r_refdef.view.frustum[1].normal, r_refdef.view.frustum[1].normal);
5208 VectorNegate(r_refdef.view.frustum[2].normal, r_refdef.view.frustum[2].normal);
5209 VectorNegate(r_refdef.view.frustum[3].normal, r_refdef.view.frustum[3].normal);
5212 // Leaving those out was a mistake, those were in the old code, and they
5213 // fix a reproducable bug in this one: frustum culling got fucked up when viewmatrix was an identity matrix
5214 // I couldn't reproduce it after adding those normalizations. --blub
5215 VectorNormalize(r_refdef.view.frustum[0].normal);
5216 VectorNormalize(r_refdef.view.frustum[1].normal);
5217 VectorNormalize(r_refdef.view.frustum[2].normal);
5218 VectorNormalize(r_refdef.view.frustum[3].normal);
5220 // make the corners absolute
5221 VectorAdd(r_refdef.view.frustumcorner[0], r_refdef.view.origin, r_refdef.view.frustumcorner[0]);
5222 VectorAdd(r_refdef.view.frustumcorner[1], r_refdef.view.origin, r_refdef.view.frustumcorner[1]);
5223 VectorAdd(r_refdef.view.frustumcorner[2], r_refdef.view.origin, r_refdef.view.frustumcorner[2]);
5224 VectorAdd(r_refdef.view.frustumcorner[3], r_refdef.view.origin, r_refdef.view.frustumcorner[3]);
5227 VectorCopy(forward, r_refdef.view.frustum[4].normal);
5229 r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[0].normal);
5230 r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[1].normal);
5231 r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[2].normal);
5232 r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[3].normal);
5233 r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[4].normal) + r_refdef.nearclip;
5237 VectorScale(left, -r_refdef.view.ortho_x, r_refdef.view.frustum[0].normal);
5238 VectorScale(left, r_refdef.view.ortho_x, r_refdef.view.frustum[1].normal);
5239 VectorScale(up, -r_refdef.view.ortho_y, r_refdef.view.frustum[2].normal);
5240 VectorScale(up, r_refdef.view.ortho_y, r_refdef.view.frustum[3].normal);
5241 VectorCopy(forward, r_refdef.view.frustum[4].normal);
5242 r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[0].normal) + r_refdef.view.ortho_x;
5243 r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[1].normal) + r_refdef.view.ortho_x;
5244 r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[2].normal) + r_refdef.view.ortho_y;
5245 r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[3].normal) + r_refdef.view.ortho_y;
5246 r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, r_refdef.view.frustum[4].normal) + r_refdef.nearclip;
5248 r_refdef.view.numfrustumplanes = 5;
5250 if (r_refdef.view.useclipplane)
5252 r_refdef.view.numfrustumplanes = 6;
5253 r_refdef.view.frustum[5] = r_refdef.view.clipplane;
5256 for (i = 0;i < r_refdef.view.numfrustumplanes;i++)
5257 PlaneClassify(r_refdef.view.frustum + i);
5259 // LordHavoc: note to all quake engine coders, Quake had a special case
5260 // for 90 degrees which assumed a square view (wrong), so I removed it,
5261 // Quake2 has it disabled as well.
5263 // rotate R_VIEWFORWARD right by FOV_X/2 degrees
5264 //RotatePointAroundVector( r_refdef.view.frustum[0].normal, up, forward, -(90 - r_refdef.fov_x / 2));
5265 //r_refdef.view.frustum[0].dist = DotProduct (r_refdef.view.origin, frustum[0].normal);
5266 //PlaneClassify(&frustum[0]);
5268 // rotate R_VIEWFORWARD left by FOV_X/2 degrees
5269 //RotatePointAroundVector( r_refdef.view.frustum[1].normal, up, forward, (90 - r_refdef.fov_x / 2));
5270 //r_refdef.view.frustum[1].dist = DotProduct (r_refdef.view.origin, frustum[1].normal);
5271 //PlaneClassify(&frustum[1]);
5273 // rotate R_VIEWFORWARD up by FOV_X/2 degrees
5274 //RotatePointAroundVector( r_refdef.view.frustum[2].normal, left, forward, -(90 - r_refdef.fov_y / 2));
5275 //r_refdef.view.frustum[2].dist = DotProduct (r_refdef.view.origin, frustum[2].normal);
5276 //PlaneClassify(&frustum[2]);
5278 // rotate R_VIEWFORWARD down by FOV_X/2 degrees
5279 //RotatePointAroundVector( r_refdef.view.frustum[3].normal, left, forward, (90 - r_refdef.fov_y / 2));
5280 //r_refdef.view.frustum[3].dist = DotProduct (r_refdef.view.origin, frustum[3].normal);
5281 //PlaneClassify(&frustum[3]);
5284 //VectorCopy(forward, r_refdef.view.frustum[4].normal);
5285 //r_refdef.view.frustum[4].dist = DotProduct (r_refdef.view.origin, frustum[4].normal) + r_nearclip.value;
5286 //PlaneClassify(&frustum[4]);
5289 static void R_View_UpdateWithScissor(const int *myscissor)
5291 R_Main_ResizeViewCache();
5292 R_View_SetFrustum(myscissor);
5293 R_View_WorldVisibility(r_refdef.view.useclipplane);
5294 R_View_UpdateEntityVisible();
5295 R_View_UpdateEntityLighting();
5298 static void R_View_Update(void)
5300 R_Main_ResizeViewCache();
5301 R_View_SetFrustum(NULL);
5302 R_View_WorldVisibility(r_refdef.view.useclipplane);
5303 R_View_UpdateEntityVisible();
5304 R_View_UpdateEntityLighting();
5307 float viewscalefpsadjusted = 1.0f;
5309 static void R_GetScaledViewSize(int width, int height, int *outwidth, int *outheight)
5311 float scale = r_viewscale.value * sqrt(viewscalefpsadjusted);
5312 scale = bound(0.03125f, scale, 1.0f);
5313 *outwidth = (int)ceil(width * scale);
5314 *outheight = (int)ceil(height * scale);
5317 void R_SetupView(qboolean allowwaterclippingplane, int fbo, rtexture_t *depthtexture, rtexture_t *colortexture)
5319 const float *customclipplane = NULL;
5321 int /*rtwidth,*/ rtheight, scaledwidth, scaledheight;
5322 if (r_refdef.view.useclipplane && allowwaterclippingplane)
5324 // LordHavoc: couldn't figure out how to make this approach the
5325 vec_t dist = r_refdef.view.clipplane.dist - r_water_clippingplanebias.value;
5326 vec_t viewdist = DotProduct(r_refdef.view.origin, r_refdef.view.clipplane.normal);
5327 if (viewdist < r_refdef.view.clipplane.dist + r_water_clippingplanebias.value)
5328 dist = r_refdef.view.clipplane.dist;
5329 plane[0] = r_refdef.view.clipplane.normal[0];
5330 plane[1] = r_refdef.view.clipplane.normal[1];
5331 plane[2] = r_refdef.view.clipplane.normal[2];
5333 if(vid.renderpath != RENDERPATH_SOFT) customclipplane = plane;
5336 //rtwidth = fbo ? R_TextureWidth(depthtexture ? depthtexture : colortexture) : vid.width;
5337 rtheight = fbo ? R_TextureHeight(depthtexture ? depthtexture : colortexture) : vid.height;
5339 R_GetScaledViewSize(r_refdef.view.width, r_refdef.view.height, &scaledwidth, &scaledheight);
5340 if (!r_refdef.view.useperspective)
5341 R_Viewport_InitOrtho(&r_refdef.view.viewport, &r_refdef.view.matrix, r_refdef.view.x, rtheight - scaledheight - r_refdef.view.y, scaledwidth, scaledheight, -r_refdef.view.ortho_x, -r_refdef.view.ortho_y, r_refdef.view.ortho_x, r_refdef.view.ortho_y, -r_refdef.farclip, r_refdef.farclip, customclipplane);
5342 else if (vid.stencil && r_useinfinitefarclip.integer)
5343 R_Viewport_InitPerspectiveInfinite(&r_refdef.view.viewport, &r_refdef.view.matrix, r_refdef.view.x, rtheight - scaledheight - r_refdef.view.y, scaledwidth, scaledheight, r_refdef.view.frustum_x, r_refdef.view.frustum_y, r_refdef.nearclip, customclipplane);
5345 R_Viewport_InitPerspective(&r_refdef.view.viewport, &r_refdef.view.matrix, r_refdef.view.x, rtheight - scaledheight - r_refdef.view.y, scaledwidth, scaledheight, r_refdef.view.frustum_x, r_refdef.view.frustum_y, r_refdef.nearclip, r_refdef.farclip, customclipplane);
5346 R_Mesh_SetRenderTargets(fbo, depthtexture, colortexture, NULL, NULL, NULL);
5347 R_SetViewport(&r_refdef.view.viewport);
5348 if (r_refdef.view.useclipplane && allowwaterclippingplane && vid.renderpath == RENDERPATH_SOFT)
5350 matrix4x4_t mvpmatrix, invmvpmatrix, invtransmvpmatrix;
5351 float screenplane[4];
5352 Matrix4x4_Concat(&mvpmatrix, &r_refdef.view.viewport.projectmatrix, &r_refdef.view.viewport.viewmatrix);
5353 Matrix4x4_Invert_Full(&invmvpmatrix, &mvpmatrix);
5354 Matrix4x4_Transpose(&invtransmvpmatrix, &invmvpmatrix);
5355 Matrix4x4_Transform4(&invtransmvpmatrix, plane, screenplane);
5356 DPSOFTRAST_ClipPlane(screenplane[0], screenplane[1], screenplane[2], screenplane[3]);
5360 void R_EntityMatrix(const matrix4x4_t *matrix)
5362 if (gl_modelmatrixchanged || memcmp(matrix, &gl_modelmatrix, sizeof(matrix4x4_t)))
5364 gl_modelmatrixchanged = false;
5365 gl_modelmatrix = *matrix;
5366 Matrix4x4_Concat(&gl_modelviewmatrix, &gl_viewmatrix, &gl_modelmatrix);
5367 Matrix4x4_Concat(&gl_modelviewprojectionmatrix, &gl_projectionmatrix, &gl_modelviewmatrix);
5368 Matrix4x4_ToArrayFloatGL(&gl_modelviewmatrix, gl_modelview16f);
5369 Matrix4x4_ToArrayFloatGL(&gl_modelviewprojectionmatrix, gl_modelviewprojection16f);
5371 switch(vid.renderpath)
5373 case RENDERPATH_D3D9:
5375 hlslVSSetParameter16f(D3DVSREGISTER_ModelViewProjectionMatrix, gl_modelviewprojection16f);
5376 hlslVSSetParameter16f(D3DVSREGISTER_ModelViewMatrix, gl_modelview16f);
5379 case RENDERPATH_D3D10:
5380 Con_DPrintf("FIXME D3D10 shader %s:%i\n", __FILE__, __LINE__);
5382 case RENDERPATH_D3D11:
5383 Con_DPrintf("FIXME D3D11 shader %s:%i\n", __FILE__, __LINE__);
5385 case RENDERPATH_GL11:
5386 case RENDERPATH_GL13:
5387 case RENDERPATH_GLES1:
5388 qglLoadMatrixf(gl_modelview16f);CHECKGLERROR
5390 case RENDERPATH_SOFT:
5391 DPSOFTRAST_UniformMatrix4fv(DPSOFTRAST_UNIFORM_ModelViewProjectionMatrixM1, 1, false, gl_modelviewprojection16f);
5392 DPSOFTRAST_UniformMatrix4fv(DPSOFTRAST_UNIFORM_ModelViewMatrixM1, 1, false, gl_modelview16f);
5394 case RENDERPATH_GL20:
5395 case RENDERPATH_GLES2:
5396 if (r_glsl_permutation && r_glsl_permutation->loc_ModelViewProjectionMatrix >= 0) qglUniformMatrix4fv(r_glsl_permutation->loc_ModelViewProjectionMatrix, 1, false, gl_modelviewprojection16f);
5397 if (r_glsl_permutation && r_glsl_permutation->loc_ModelViewMatrix >= 0) qglUniformMatrix4fv(r_glsl_permutation->loc_ModelViewMatrix, 1, false, gl_modelview16f);
5403 void R_ResetViewRendering2D_Common(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture, float x2, float y2)
5405 r_viewport_t viewport;
5409 // GL is weird because it's bottom to top, r_refdef.view.y is top to bottom
5410 R_Viewport_InitOrtho(&viewport, &identitymatrix, r_refdef.view.x, vid.height - r_refdef.view.height - r_refdef.view.y, r_refdef.view.width, r_refdef.view.height, 0, 0, x2, y2, -10, 100, NULL);
5411 R_Mesh_SetRenderTargets(fbo, depthtexture, colortexture, NULL, NULL, NULL);
5412 R_SetViewport(&viewport);
5413 GL_Scissor(viewport.x, viewport.y, viewport.width, viewport.height);
5414 GL_Color(1, 1, 1, 1);
5415 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5416 GL_BlendFunc(GL_ONE, GL_ZERO);
5417 GL_ScissorTest(false);
5418 GL_DepthMask(false);
5419 GL_DepthRange(0, 1);
5420 GL_DepthTest(false);
5421 GL_DepthFunc(GL_LEQUAL);
5422 R_EntityMatrix(&identitymatrix);
5423 R_Mesh_ResetTextureState();
5424 GL_PolygonOffset(0, 0);
5425 R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255);
5426 switch(vid.renderpath)
5428 case RENDERPATH_GL11:
5429 case RENDERPATH_GL13:
5430 case RENDERPATH_GL20:
5431 case RENDERPATH_GLES1:
5432 case RENDERPATH_GLES2:
5433 qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
5435 case RENDERPATH_D3D9:
5436 case RENDERPATH_D3D10:
5437 case RENDERPATH_D3D11:
5438 case RENDERPATH_SOFT:
5441 GL_CullFace(GL_NONE);
5446 void R_ResetViewRendering2D(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture)
5450 R_ResetViewRendering2D_Common(fbo, depthtexture, colortexture, 1, 1);
5453 void R_ResetViewRendering3D(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture)
5457 R_SetupView(true, fbo, depthtexture, colortexture);
5458 GL_Scissor(r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
5459 GL_Color(1, 1, 1, 1);
5460 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
5461 GL_BlendFunc(GL_ONE, GL_ZERO);
5462 GL_ScissorTest(true);
5464 GL_DepthRange(0, 1);
5466 GL_DepthFunc(GL_LEQUAL);
5467 R_EntityMatrix(&identitymatrix);
5468 R_Mesh_ResetTextureState();
5469 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
5470 R_SetStencil(false, 255, GL_KEEP, GL_KEEP, GL_KEEP, GL_ALWAYS, 128, 255);
5471 switch(vid.renderpath)
5473 case RENDERPATH_GL11:
5474 case RENDERPATH_GL13:
5475 case RENDERPATH_GL20:
5476 case RENDERPATH_GLES1:
5477 case RENDERPATH_GLES2:
5478 qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
5480 case RENDERPATH_D3D9:
5481 case RENDERPATH_D3D10:
5482 case RENDERPATH_D3D11:
5483 case RENDERPATH_SOFT:
5486 GL_CullFace(r_refdef.view.cullface_back);
5491 R_RenderView_UpdateViewVectors
5494 void R_RenderView_UpdateViewVectors(void)
5496 // break apart the view matrix into vectors for various purposes
5497 // it is important that this occurs outside the RenderScene function because that can be called from reflection renders, where the vectors come out wrong
5498 // however the r_refdef.view.origin IS updated in RenderScene intentionally - otherwise the sky renders at the wrong origin, etc
5499 Matrix4x4_ToVectors(&r_refdef.view.matrix, r_refdef.view.forward, r_refdef.view.left, r_refdef.view.up, r_refdef.view.origin);
5500 VectorNegate(r_refdef.view.left, r_refdef.view.right);
5501 // make an inverted copy of the view matrix for tracking sprites
5502 Matrix4x4_Invert_Simple(&r_refdef.view.inverse_matrix, &r_refdef.view.matrix);
5505 void R_RenderScene(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture);
5506 void R_RenderWaterPlanes(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture);
5508 static void R_Water_StartFrame(void)
5511 int waterwidth, waterheight, texturewidth, textureheight, camerawidth, cameraheight;
5512 r_waterstate_waterplane_t *p;
5513 qboolean usewaterfbo = (r_viewfbo.integer >= 1 || r_water_fbo.integer >= 1) && vid.support.ext_framebuffer_object && vid.samples < 2;
5515 if (vid.width > (int)vid.maxtexturesize_2d || vid.height > (int)vid.maxtexturesize_2d)
5518 switch(vid.renderpath)
5520 case RENDERPATH_GL20:
5521 case RENDERPATH_D3D9:
5522 case RENDERPATH_D3D10:
5523 case RENDERPATH_D3D11:
5524 case RENDERPATH_SOFT:
5525 case RENDERPATH_GLES2:
5527 case RENDERPATH_GL11:
5528 case RENDERPATH_GL13:
5529 case RENDERPATH_GLES1:
5533 // set waterwidth and waterheight to the water resolution that will be
5534 // used (often less than the screen resolution for faster rendering)
5535 R_GetScaledViewSize(bound(1, vid.width * r_water_resolutionmultiplier.value, vid.width), bound(1, vid.height * r_water_resolutionmultiplier.value, vid.height), &waterwidth, &waterheight);
5537 // calculate desired texture sizes
5538 // can't use water if the card does not support the texture size
5539 if (!r_water.integer || r_showsurfaces.integer)
5540 texturewidth = textureheight = waterwidth = waterheight = camerawidth = cameraheight = 0;
5541 else if (vid.support.arb_texture_non_power_of_two)
5543 texturewidth = waterwidth;
5544 textureheight = waterheight;
5545 camerawidth = waterwidth;
5546 cameraheight = waterheight;
5550 for (texturewidth = 1;texturewidth < waterwidth ;texturewidth *= 2);
5551 for (textureheight = 1;textureheight < waterheight;textureheight *= 2);
5552 for (camerawidth = 1;camerawidth <= waterwidth; camerawidth *= 2); camerawidth /= 2;
5553 for (cameraheight = 1;cameraheight <= waterheight;cameraheight *= 2); cameraheight /= 2;
5556 // allocate textures as needed
5557 if (r_fb.water.texturewidth != texturewidth || r_fb.water.textureheight != textureheight || r_fb.water.camerawidth != camerawidth || r_fb.water.cameraheight != cameraheight || (r_fb.depthtexture && !usewaterfbo))
5559 r_fb.water.maxwaterplanes = MAX_WATERPLANES;
5560 for (i = 0, p = r_fb.water.waterplanes;i < r_fb.water.maxwaterplanes;i++, p++)
5562 if (p->texture_refraction)
5563 R_FreeTexture(p->texture_refraction);
5564 p->texture_refraction = NULL;
5565 if (p->fbo_refraction)
5566 R_Mesh_DestroyFramebufferObject(p->fbo_refraction);
5567 p->fbo_refraction = 0;
5568 if (p->texture_reflection)
5569 R_FreeTexture(p->texture_reflection);
5570 p->texture_reflection = NULL;
5571 if (p->fbo_reflection)
5572 R_Mesh_DestroyFramebufferObject(p->fbo_reflection);
5573 p->fbo_reflection = 0;
5574 if (p->texture_camera)
5575 R_FreeTexture(p->texture_camera);
5576 p->texture_camera = NULL;
5578 R_Mesh_DestroyFramebufferObject(p->fbo_camera);
5581 memset(&r_fb.water, 0, sizeof(r_fb.water));
5582 r_fb.water.texturewidth = texturewidth;
5583 r_fb.water.textureheight = textureheight;
5584 r_fb.water.camerawidth = camerawidth;
5585 r_fb.water.cameraheight = cameraheight;
5588 if (r_fb.water.texturewidth)
5590 int scaledwidth, scaledheight;
5592 r_fb.water.enabled = true;
5594 // water resolution is usually reduced
5595 r_fb.water.waterwidth = (int)bound(1, r_refdef.view.width * r_water_resolutionmultiplier.value, r_refdef.view.width);
5596 r_fb.water.waterheight = (int)bound(1, r_refdef.view.height * r_water_resolutionmultiplier.value, r_refdef.view.height);
5597 R_GetScaledViewSize(r_fb.water.waterwidth, r_fb.water.waterheight, &scaledwidth, &scaledheight);
5599 // set up variables that will be used in shader setup
5600 r_fb.water.screenscale[0] = 0.5f * (float)scaledwidth / (float)r_fb.water.texturewidth;
5601 r_fb.water.screenscale[1] = 0.5f * (float)scaledheight / (float)r_fb.water.textureheight;
5602 r_fb.water.screencenter[0] = 0.5f * (float)scaledwidth / (float)r_fb.water.texturewidth;
5603 r_fb.water.screencenter[1] = 0.5f * (float)scaledheight / (float)r_fb.water.textureheight;
5606 r_fb.water.maxwaterplanes = MAX_WATERPLANES;
5607 r_fb.water.numwaterplanes = 0;
5610 void R_Water_AddWaterPlane(msurface_t *surface, int entno)
5612 int planeindex, bestplaneindex, vertexindex;
5613 vec3_t mins, maxs, normal, center, v, n;
5614 vec_t planescore, bestplanescore;
5616 r_waterstate_waterplane_t *p;
5617 texture_t *t = R_GetCurrentTexture(surface->texture);
5619 rsurface.texture = t;
5620 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_NOGAPS, 1, ((const msurface_t **)&surface));
5621 // if the model has no normals, it's probably off-screen and they were not generated, so don't add it anyway
5622 if (!rsurface.batchnormal3f || rsurface.batchnumvertices < 1)
5624 // average the vertex normals, find the surface bounds (after deformvertexes)
5625 Matrix4x4_Transform(&rsurface.matrix, rsurface.batchvertex3f, v);
5626 Matrix4x4_Transform3x3(&rsurface.matrix, rsurface.batchnormal3f, n);
5627 VectorCopy(n, normal);
5628 VectorCopy(v, mins);
5629 VectorCopy(v, maxs);
5630 for (vertexindex = 1;vertexindex < rsurface.batchnumvertices;vertexindex++)
5632 Matrix4x4_Transform(&rsurface.matrix, rsurface.batchvertex3f + vertexindex*3, v);
5633 Matrix4x4_Transform3x3(&rsurface.matrix, rsurface.batchnormal3f + vertexindex*3, n);
5634 VectorAdd(normal, n, normal);
5635 mins[0] = min(mins[0], v[0]);
5636 mins[1] = min(mins[1], v[1]);
5637 mins[2] = min(mins[2], v[2]);
5638 maxs[0] = max(maxs[0], v[0]);
5639 maxs[1] = max(maxs[1], v[1]);
5640 maxs[2] = max(maxs[2], v[2]);
5642 VectorNormalize(normal);
5643 VectorMAM(0.5f, mins, 0.5f, maxs, center);
5645 VectorCopy(normal, plane.normal);
5646 VectorNormalize(plane.normal);
5647 plane.dist = DotProduct(center, plane.normal);
5648 PlaneClassify(&plane);
5649 if (PlaneDiff(r_refdef.view.origin, &plane) < 0)
5651 // skip backfaces (except if nocullface is set)
5652 // if (!(t->currentmaterialflags & MATERIALFLAG_NOCULLFACE))
5654 VectorNegate(plane.normal, plane.normal);
5656 PlaneClassify(&plane);
5660 // find a matching plane if there is one
5661 bestplaneindex = -1;
5662 bestplanescore = 1048576.0f;
5663 for (planeindex = 0, p = r_fb.water.waterplanes;planeindex < r_fb.water.numwaterplanes;planeindex++, p++)
5665 if(p->camera_entity == t->camera_entity)
5667 planescore = 1.0f - DotProduct(plane.normal, p->plane.normal) + fabs(plane.dist - p->plane.dist) * 0.001f;
5668 if (bestplaneindex < 0 || bestplanescore > planescore)
5670 bestplaneindex = planeindex;
5671 bestplanescore = planescore;
5675 planeindex = bestplaneindex;
5676 p = r_fb.water.waterplanes + planeindex;
5678 // if this surface does not fit any known plane rendered this frame, add one
5679 if ((planeindex < 0 || bestplanescore > 0.001f) && r_fb.water.numwaterplanes < r_fb.water.maxwaterplanes)
5681 // store the new plane
5682 planeindex = r_fb.water.numwaterplanes++;
5683 p = r_fb.water.waterplanes + planeindex;
5685 // clear materialflags and pvs
5686 p->materialflags = 0;
5687 p->pvsvalid = false;
5688 p->camera_entity = t->camera_entity;
5689 VectorCopy(mins, p->mins);
5690 VectorCopy(maxs, p->maxs);
5694 // merge mins/maxs when we're adding this surface to the plane
5695 p->mins[0] = min(p->mins[0], mins[0]);
5696 p->mins[1] = min(p->mins[1], mins[1]);
5697 p->mins[2] = min(p->mins[2], mins[2]);
5698 p->maxs[0] = max(p->maxs[0], maxs[0]);
5699 p->maxs[1] = max(p->maxs[1], maxs[1]);
5700 p->maxs[2] = max(p->maxs[2], maxs[2]);
5702 // merge this surface's materialflags into the waterplane
5703 p->materialflags |= t->currentmaterialflags;
5704 if(!(p->materialflags & MATERIALFLAG_CAMERA))
5706 // merge this surface's PVS into the waterplane
5707 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA) && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS
5708 && r_refdef.scene.worldmodel->brush.PointInLeaf && r_refdef.scene.worldmodel->brush.PointInLeaf(r_refdef.scene.worldmodel, center)->clusterindex >= 0)
5710 r_refdef.scene.worldmodel->brush.FatPVS(r_refdef.scene.worldmodel, center, 2, p->pvsbits, sizeof(p->pvsbits), p->pvsvalid);
5716 extern cvar_t r_drawparticles;
5717 extern cvar_t r_drawdecals;
5719 static void R_Water_ProcessPlanes(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture)
5722 r_refdef_view_t originalview;
5723 r_refdef_view_t myview;
5724 int planeindex, qualityreduction = 0, old_r_dynamic = 0, old_r_shadows = 0, old_r_worldrtlight = 0, old_r_dlight = 0, old_r_particles = 0, old_r_decals = 0;
5725 r_waterstate_waterplane_t *p;
5727 qboolean usewaterfbo = (r_viewfbo.integer >= 1 || r_water_fbo.integer >= 1) && vid.support.ext_framebuffer_object && vid.samples < 2;
5730 originalview = r_refdef.view;
5732 // lowquality hack, temporarily shut down some cvars and restore afterwards
5733 qualityreduction = r_water_lowquality.integer;
5734 if (qualityreduction > 0)
5736 if (qualityreduction >= 1)
5738 old_r_shadows = r_shadows.integer;
5739 old_r_worldrtlight = r_shadow_realtime_world.integer;
5740 old_r_dlight = r_shadow_realtime_dlight.integer;
5741 Cvar_SetValueQuick(&r_shadows, 0);
5742 Cvar_SetValueQuick(&r_shadow_realtime_world, 0);
5743 Cvar_SetValueQuick(&r_shadow_realtime_dlight, 0);
5745 if (qualityreduction >= 2)
5747 old_r_dynamic = r_dynamic.integer;
5748 old_r_particles = r_drawparticles.integer;
5749 old_r_decals = r_drawdecals.integer;
5750 Cvar_SetValueQuick(&r_dynamic, 0);
5751 Cvar_SetValueQuick(&r_drawparticles, 0);
5752 Cvar_SetValueQuick(&r_drawdecals, 0);
5756 // make sure enough textures are allocated
5757 for (planeindex = 0, p = r_fb.water.waterplanes;planeindex < r_fb.water.numwaterplanes;planeindex++, p++)
5759 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
5761 if (!p->texture_refraction)
5762 p->texture_refraction = R_LoadTexture2D(r_main_texturepool, va(vabuf, sizeof(vabuf), "waterplane%i_refraction", planeindex), r_fb.water.texturewidth, r_fb.water.textureheight, NULL, r_fb.textype, TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
5763 if (!p->texture_refraction)
5767 if (r_fb.water.depthtexture == NULL)
5768 r_fb.water.depthtexture = R_LoadTextureRenderBuffer(r_main_texturepool, "waterviewdepth", r_fb.water.texturewidth, r_fb.water.textureheight, TEXTYPE_DEPTHBUFFER24STENCIL8);
5769 if (p->fbo_refraction == 0)
5770 p->fbo_refraction = R_Mesh_CreateFramebufferObject(r_fb.water.depthtexture, p->texture_refraction, NULL, NULL, NULL);
5773 else if (p->materialflags & MATERIALFLAG_CAMERA)
5775 if (!p->texture_camera)
5776 p->texture_camera = R_LoadTexture2D(r_main_texturepool, va(vabuf, sizeof(vabuf), "waterplane%i_camera", planeindex), r_fb.water.camerawidth, r_fb.water.cameraheight, NULL, r_fb.textype, TEXF_RENDERTARGET | TEXF_FORCELINEAR, -1, NULL);
5777 if (!p->texture_camera)
5781 if (r_fb.water.depthtexture == NULL)
5782 r_fb.water.depthtexture = R_LoadTextureRenderBuffer(r_main_texturepool, "waterviewdepth", r_fb.water.texturewidth, r_fb.water.textureheight, TEXTYPE_DEPTHBUFFER24STENCIL8);
5783 if (p->fbo_camera == 0)
5784 p->fbo_camera = R_Mesh_CreateFramebufferObject(r_fb.water.depthtexture, p->texture_camera, NULL, NULL, NULL);
5788 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
5790 if (!p->texture_reflection)
5791 p->texture_reflection = R_LoadTexture2D(r_main_texturepool, va(vabuf, sizeof(vabuf), "waterplane%i_reflection", planeindex), r_fb.water.texturewidth, r_fb.water.textureheight, NULL, r_fb.textype, TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
5792 if (!p->texture_reflection)
5796 if (r_fb.water.depthtexture == NULL)
5797 r_fb.water.depthtexture = R_LoadTextureRenderBuffer(r_main_texturepool, "waterviewdepth", r_fb.water.texturewidth, r_fb.water.textureheight, TEXTYPE_DEPTHBUFFER24STENCIL8);
5798 if (p->fbo_reflection == 0)
5799 p->fbo_reflection = R_Mesh_CreateFramebufferObject(r_fb.water.depthtexture, p->texture_reflection, NULL, NULL, NULL);
5805 r_refdef.view = originalview;
5806 r_refdef.view.showdebug = false;
5807 r_refdef.view.width = r_fb.water.waterwidth;
5808 r_refdef.view.height = r_fb.water.waterheight;
5809 r_refdef.view.useclipplane = true;
5810 myview = r_refdef.view;
5811 r_fb.water.renderingscene = true;
5812 for (planeindex = 0, p = r_fb.water.waterplanes;planeindex < r_fb.water.numwaterplanes;planeindex++, p++)
5814 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
5816 r_refdef.view = myview;
5817 if(r_water_scissormode.integer)
5819 R_SetupView(true, p->fbo_reflection, r_fb.water.depthtexture, p->texture_reflection);
5820 if(R_ScissorForBBox(p->mins, p->maxs, myscissor))
5821 continue; // FIXME the plane then still may get rendered but with broken texture, but it sure won't be visible
5824 // render reflected scene and copy into texture
5825 Matrix4x4_Reflect(&r_refdef.view.matrix, p->plane.normal[0], p->plane.normal[1], p->plane.normal[2], p->plane.dist, -2);
5826 // update the r_refdef.view.origin because otherwise the sky renders at the wrong location (amongst other problems)
5827 Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, r_refdef.view.origin);
5828 r_refdef.view.clipplane = p->plane;
5829 // reverse the cullface settings for this render
5830 r_refdef.view.cullface_front = GL_FRONT;
5831 r_refdef.view.cullface_back = GL_BACK;
5832 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.num_pvsclusterbytes)
5834 r_refdef.view.usecustompvs = true;
5836 memcpy(r_refdef.viewcache.world_pvsbits, p->pvsbits, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
5838 memset(r_refdef.viewcache.world_pvsbits, 0xFF, r_refdef.scene.worldmodel->brush.num_pvsclusterbytes);
5841 r_fb.water.hideplayer = r_water_hideplayer.integer >= 2;
5842 R_ResetViewRendering3D(p->fbo_reflection, r_fb.water.depthtexture, p->texture_reflection);
5843 R_ClearScreen(r_refdef.fogenabled);
5844 if(r_water_scissormode.integer & 2)
5845 R_View_UpdateWithScissor(myscissor);
5848 R_AnimCache_CacheVisibleEntities();
5849 if(r_water_scissormode.integer & 1)
5850 GL_Scissor(myscissor[0], myscissor[1], myscissor[2], myscissor[3]);
5851 R_RenderScene(p->fbo_reflection, r_fb.water.depthtexture, p->texture_reflection);
5853 if (!p->fbo_reflection)
5854 R_Mesh_CopyToTexture(p->texture_reflection, 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
5855 r_fb.water.hideplayer = false;
5858 // render the normal view scene and copy into texture
5859 // (except that a clipping plane should be used to hide everything on one side of the water, and the viewer's weapon model should be omitted)
5860 if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
5862 r_refdef.view = myview;
5863 if(r_water_scissormode.integer)
5865 R_SetupView(true, p->fbo_refraction, r_fb.water.depthtexture, p->texture_refraction);
5866 if(R_ScissorForBBox(p->mins, p->maxs, myscissor))
5867 continue; // FIXME the plane then still may get rendered but with broken texture, but it sure won't be visible
5870 r_fb.water.hideplayer = r_water_hideplayer.integer >= 1;
5872 r_refdef.view.clipplane = p->plane;
5873 VectorNegate(r_refdef.view.clipplane.normal, r_refdef.view.clipplane.normal);
5874 r_refdef.view.clipplane.dist = -r_refdef.view.clipplane.dist;
5876 if((p->materialflags & MATERIALFLAG_CAMERA) && p->camera_entity)
5878 // we need to perform a matrix transform to render the view... so let's get the transformation matrix
5879 r_fb.water.hideplayer = false; // we don't want to hide the player model from these ones
5880 CL_VM_TransformView(p->camera_entity - MAX_EDICTS, &r_refdef.view.matrix, &r_refdef.view.clipplane, visorigin);
5881 R_RenderView_UpdateViewVectors();
5882 if(r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS)
5884 r_refdef.view.usecustompvs = true;
5885 r_refdef.scene.worldmodel->brush.FatPVS(r_refdef.scene.worldmodel, visorigin, 2, r_refdef.viewcache.world_pvsbits, (r_refdef.viewcache.world_numclusters+7)>>3, false);
5889 PlaneClassify(&r_refdef.view.clipplane);
5891 R_ResetViewRendering3D(p->fbo_refraction, r_fb.water.depthtexture, p->texture_refraction);
5892 R_ClearScreen(r_refdef.fogenabled);
5893 if(r_water_scissormode.integer & 2)
5894 R_View_UpdateWithScissor(myscissor);
5897 R_AnimCache_CacheVisibleEntities();
5898 if(r_water_scissormode.integer & 1)
5899 GL_Scissor(myscissor[0], myscissor[1], myscissor[2], myscissor[3]);
5900 R_RenderScene(p->fbo_refraction, r_fb.water.depthtexture, p->texture_refraction);
5902 if (!p->fbo_refraction)
5903 R_Mesh_CopyToTexture(p->texture_refraction, 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
5904 r_fb.water.hideplayer = false;
5906 else if (p->materialflags & MATERIALFLAG_CAMERA)
5908 r_refdef.view = myview;
5910 r_refdef.view.clipplane = p->plane;
5911 VectorNegate(r_refdef.view.clipplane.normal, r_refdef.view.clipplane.normal);
5912 r_refdef.view.clipplane.dist = -r_refdef.view.clipplane.dist;
5914 r_refdef.view.width = r_fb.water.camerawidth;
5915 r_refdef.view.height = r_fb.water.cameraheight;
5916 r_refdef.view.frustum_x = 1; // tan(45 * M_PI / 180.0);
5917 r_refdef.view.frustum_y = 1; // tan(45 * M_PI / 180.0);
5918 r_refdef.view.ortho_x = 90; // abused as angle by VM_CL_R_SetView
5919 r_refdef.view.ortho_y = 90; // abused as angle by VM_CL_R_SetView
5921 if(p->camera_entity)
5923 // we need to perform a matrix transform to render the view... so let's get the transformation matrix
5924 CL_VM_TransformView(p->camera_entity - MAX_EDICTS, &r_refdef.view.matrix, &r_refdef.view.clipplane, visorigin);
5927 // note: all of the view is used for displaying... so
5928 // there is no use in scissoring
5930 // reverse the cullface settings for this render
5931 r_refdef.view.cullface_front = GL_FRONT;
5932 r_refdef.view.cullface_back = GL_BACK;
5933 // also reverse the view matrix
5934 Matrix4x4_ConcatScale3(&r_refdef.view.matrix, 1, 1, -1); // this serves to invert texcoords in the result, as the copied texture is mapped the wrong way round
5935 R_RenderView_UpdateViewVectors();
5936 if(p->camera_entity && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.FatPVS)
5938 r_refdef.view.usecustompvs = true;
5939 r_refdef.scene.worldmodel->brush.FatPVS(r_refdef.scene.worldmodel, visorigin, 2, r_refdef.viewcache.world_pvsbits, (r_refdef.viewcache.world_numclusters+7)>>3, false);
5942 // camera needs no clipplane
5943 r_refdef.view.useclipplane = false;
5945 PlaneClassify(&r_refdef.view.clipplane);
5947 r_fb.water.hideplayer = false;
5949 R_ResetViewRendering3D(p->fbo_camera, r_fb.water.depthtexture, p->texture_camera);
5950 R_ClearScreen(r_refdef.fogenabled);
5952 R_AnimCache_CacheVisibleEntities();
5953 R_RenderScene(p->fbo_camera, r_fb.water.depthtexture, p->texture_camera);
5956 R_Mesh_CopyToTexture(p->texture_camera, 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
5957 r_fb.water.hideplayer = false;
5961 if(vid.renderpath==RENDERPATH_SOFT) DPSOFTRAST_ClipPlane(0, 0, 0, 1);
5962 r_fb.water.renderingscene = false;
5963 r_refdef.view = originalview;
5964 R_ResetViewRendering3D(fbo, depthtexture, colortexture);
5965 if (!r_fb.water.depthtexture)
5966 R_ClearScreen(r_refdef.fogenabled);
5968 R_AnimCache_CacheVisibleEntities();
5971 r_refdef.view = originalview;
5972 r_fb.water.renderingscene = false;
5973 Cvar_SetValueQuick(&r_water, 0);
5974 Con_Printf("R_Water_ProcessPlanes: Error: texture creation failed! Turned off r_water.\n");
5976 // lowquality hack, restore cvars
5977 if (qualityreduction > 0)
5979 if (qualityreduction >= 1)
5981 Cvar_SetValueQuick(&r_shadows, old_r_shadows);
5982 Cvar_SetValueQuick(&r_shadow_realtime_world, old_r_worldrtlight);
5983 Cvar_SetValueQuick(&r_shadow_realtime_dlight, old_r_dlight);
5985 if (qualityreduction >= 2)
5987 Cvar_SetValueQuick(&r_dynamic, old_r_dynamic);
5988 Cvar_SetValueQuick(&r_drawparticles, old_r_particles);
5989 Cvar_SetValueQuick(&r_drawdecals, old_r_decals);
5994 static void R_Bloom_StartFrame(void)
5997 int bloomtexturewidth, bloomtextureheight, screentexturewidth, screentextureheight;
5998 int viewwidth, viewheight;
5999 qboolean useviewfbo = r_viewfbo.integer >= 1 && vid.support.ext_framebuffer_object && vid.samples < 2;
6000 textype_t textype = TEXTYPE_COLORBUFFER;
6002 switch (vid.renderpath)
6004 case RENDERPATH_GL20:
6005 r_fb.usedepthtextures = r_usedepthtextures.integer != 0;
6006 if (vid.support.ext_framebuffer_object)
6008 if (r_viewfbo.integer == 2) textype = TEXTYPE_COLORBUFFER16F;
6009 if (r_viewfbo.integer == 3) textype = TEXTYPE_COLORBUFFER32F;
6012 case RENDERPATH_GL11:
6013 case RENDERPATH_GL13:
6014 case RENDERPATH_GLES1:
6015 case RENDERPATH_GLES2:
6016 case RENDERPATH_D3D9:
6017 case RENDERPATH_D3D10:
6018 case RENDERPATH_D3D11:
6019 r_fb.usedepthtextures = false;
6021 case RENDERPATH_SOFT:
6022 r_fb.usedepthtextures = true;
6026 if (r_viewscale_fpsscaling.integer)
6028 double actualframetime;
6029 double targetframetime;
6031 actualframetime = r_refdef.lastdrawscreentime;
6032 targetframetime = (1.0 / r_viewscale_fpsscaling_target.value);
6033 adjust = (targetframetime - actualframetime) * r_viewscale_fpsscaling_multiply.value;
6034 adjust = bound(-r_viewscale_fpsscaling_stepmax.value, adjust, r_viewscale_fpsscaling_stepmax.value);
6035 if (r_viewscale_fpsscaling_stepsize.value > 0)
6036 adjust = (int)(adjust / r_viewscale_fpsscaling_stepsize.value) * r_viewscale_fpsscaling_stepsize.value;
6037 viewscalefpsadjusted += adjust;
6038 viewscalefpsadjusted = bound(r_viewscale_fpsscaling_min.value, viewscalefpsadjusted, 1.0f);
6041 viewscalefpsadjusted = 1.0f;
6043 R_GetScaledViewSize(r_refdef.view.width, r_refdef.view.height, &viewwidth, &viewheight);
6045 switch(vid.renderpath)
6047 case RENDERPATH_GL20:
6048 case RENDERPATH_D3D9:
6049 case RENDERPATH_D3D10:
6050 case RENDERPATH_D3D11:
6051 case RENDERPATH_SOFT:
6052 case RENDERPATH_GLES2:
6054 case RENDERPATH_GL11:
6055 case RENDERPATH_GL13:
6056 case RENDERPATH_GLES1:
6060 // set bloomwidth and bloomheight to the bloom resolution that will be
6061 // used (often less than the screen resolution for faster rendering)
6062 r_fb.bloomwidth = bound(1, r_bloom_resolution.integer, vid.width);
6063 r_fb.bloomheight = r_fb.bloomwidth * vid.height / vid.width;
6064 r_fb.bloomheight = bound(1, r_fb.bloomheight, vid.height);
6065 r_fb.bloomwidth = bound(1, r_fb.bloomwidth, (int)vid.maxtexturesize_2d);
6066 r_fb.bloomheight = bound(1, r_fb.bloomheight, (int)vid.maxtexturesize_2d);
6068 // calculate desired texture sizes
6069 if (vid.support.arb_texture_non_power_of_two)
6071 screentexturewidth = vid.width;
6072 screentextureheight = vid.height;
6073 bloomtexturewidth = r_fb.bloomwidth;
6074 bloomtextureheight = r_fb.bloomheight;
6078 for (screentexturewidth = 1;screentexturewidth < vid.width ;screentexturewidth *= 2);
6079 for (screentextureheight = 1;screentextureheight < vid.height ;screentextureheight *= 2);
6080 for (bloomtexturewidth = 1;bloomtexturewidth < r_fb.bloomwidth ;bloomtexturewidth *= 2);
6081 for (bloomtextureheight = 1;bloomtextureheight < r_fb.bloomheight;bloomtextureheight *= 2);
6084 if ((r_bloom.integer || (!R_Stereo_Active() && (r_motionblur.value > 0 || r_damageblur.value > 0))) && ((r_bloom_resolution.integer < 4 || r_bloom_blur.value < 1 || r_bloom_blur.value >= 512) || r_refdef.view.width > (int)vid.maxtexturesize_2d || r_refdef.view.height > (int)vid.maxtexturesize_2d))
6086 Cvar_SetValueQuick(&r_bloom, 0);
6087 Cvar_SetValueQuick(&r_motionblur, 0);
6088 Cvar_SetValueQuick(&r_damageblur, 0);
6091 if (!(r_glsl_postprocess.integer || (!R_Stereo_ColorMasking() && r_glsl_saturation.value != 1) || (v_glslgamma.integer && !vid_gammatables_trivial))
6093 && (R_Stereo_Active() || (r_motionblur.value <= 0 && r_damageblur.value <= 0))
6095 && r_viewscale.value == 1.0f
6096 && !r_viewscale_fpsscaling.integer)
6097 screentexturewidth = screentextureheight = 0;
6098 if (!r_bloom.integer)
6099 bloomtexturewidth = bloomtextureheight = 0;
6101 // allocate textures as needed
6102 if (r_fb.screentexturewidth != screentexturewidth
6103 || r_fb.screentextureheight != screentextureheight
6104 || r_fb.bloomtexturewidth != bloomtexturewidth
6105 || r_fb.bloomtextureheight != bloomtextureheight
6106 || r_fb.textype != textype
6107 || useviewfbo != (r_fb.fbo != 0))
6109 for (i = 0;i < (int)(sizeof(r_fb.bloomtexture)/sizeof(r_fb.bloomtexture[i]));i++)
6111 if (r_fb.bloomtexture[i])
6112 R_FreeTexture(r_fb.bloomtexture[i]);
6113 r_fb.bloomtexture[i] = NULL;
6115 if (r_fb.bloomfbo[i])
6116 R_Mesh_DestroyFramebufferObject(r_fb.bloomfbo[i]);
6117 r_fb.bloomfbo[i] = 0;
6121 R_Mesh_DestroyFramebufferObject(r_fb.fbo);
6124 if (r_fb.colortexture)
6125 R_FreeTexture(r_fb.colortexture);
6126 r_fb.colortexture = NULL;
6128 if (r_fb.depthtexture)
6129 R_FreeTexture(r_fb.depthtexture);
6130 r_fb.depthtexture = NULL;
6132 if (r_fb.ghosttexture)
6133 R_FreeTexture(r_fb.ghosttexture);
6134 r_fb.ghosttexture = NULL;
6136 r_fb.screentexturewidth = screentexturewidth;
6137 r_fb.screentextureheight = screentextureheight;
6138 r_fb.bloomtexturewidth = bloomtexturewidth;
6139 r_fb.bloomtextureheight = bloomtextureheight;
6140 r_fb.textype = textype;
6142 if (r_fb.screentexturewidth && r_fb.screentextureheight)
6144 if (r_motionblur.value > 0 || r_damageblur.value > 0)
6145 r_fb.ghosttexture = R_LoadTexture2D(r_main_texturepool, "framebuffermotionblur", r_fb.screentexturewidth, r_fb.screentextureheight, NULL, r_fb.textype, TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
6146 r_fb.ghosttexture_valid = false;
6147 r_fb.colortexture = R_LoadTexture2D(r_main_texturepool, "framebuffercolor", r_fb.screentexturewidth, r_fb.screentextureheight, NULL, r_fb.textype, TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
6150 r_fb.depthtexture = R_LoadTextureRenderBuffer(r_main_texturepool, "framebufferdepth", r_fb.screentexturewidth, r_fb.screentextureheight, TEXTYPE_DEPTHBUFFER24STENCIL8);
6151 r_fb.fbo = R_Mesh_CreateFramebufferObject(r_fb.depthtexture, r_fb.colortexture, NULL, NULL, NULL);
6152 R_Mesh_SetRenderTargets(r_fb.fbo, r_fb.depthtexture, r_fb.colortexture, NULL, NULL, NULL);
6156 if (r_fb.bloomtexturewidth && r_fb.bloomtextureheight)
6158 for (i = 0;i < (int)(sizeof(r_fb.bloomtexture)/sizeof(r_fb.bloomtexture[i]));i++)
6160 r_fb.bloomtexture[i] = R_LoadTexture2D(r_main_texturepool, "framebufferbloom", r_fb.bloomtexturewidth, r_fb.bloomtextureheight, NULL, r_fb.textype, TEXF_RENDERTARGET | TEXF_FORCELINEAR | TEXF_CLAMP, -1, NULL);
6162 r_fb.bloomfbo[i] = R_Mesh_CreateFramebufferObject(NULL, r_fb.bloomtexture[i], NULL, NULL, NULL);
6167 // bloom texture is a different resolution
6168 r_fb.bloomwidth = bound(1, r_bloom_resolution.integer, r_refdef.view.width);
6169 r_fb.bloomheight = r_fb.bloomwidth * r_refdef.view.height / r_refdef.view.width;
6170 r_fb.bloomheight = bound(1, r_fb.bloomheight, r_refdef.view.height);
6171 r_fb.bloomwidth = bound(1, r_fb.bloomwidth, r_fb.bloomtexturewidth);
6172 r_fb.bloomheight = bound(1, r_fb.bloomheight, r_fb.bloomtextureheight);
6174 // set up a texcoord array for the full resolution screen image
6175 // (we have to keep this around to copy back during final render)
6176 r_fb.screentexcoord2f[0] = 0;
6177 r_fb.screentexcoord2f[1] = (float)viewheight / (float)r_fb.screentextureheight;
6178 r_fb.screentexcoord2f[2] = (float)viewwidth / (float)r_fb.screentexturewidth;
6179 r_fb.screentexcoord2f[3] = (float)viewheight / (float)r_fb.screentextureheight;
6180 r_fb.screentexcoord2f[4] = (float)viewwidth / (float)r_fb.screentexturewidth;
6181 r_fb.screentexcoord2f[5] = 0;
6182 r_fb.screentexcoord2f[6] = 0;
6183 r_fb.screentexcoord2f[7] = 0;
6187 for (i = 1;i < 8;i += 2)
6189 r_fb.screentexcoord2f[i] += 1 - (float)(viewheight + r_refdef.view.y) / (float)r_fb.screentextureheight;
6193 // set up a texcoord array for the reduced resolution bloom image
6194 // (which will be additive blended over the screen image)
6195 r_fb.bloomtexcoord2f[0] = 0;
6196 r_fb.bloomtexcoord2f[1] = (float)r_fb.bloomheight / (float)r_fb.bloomtextureheight;
6197 r_fb.bloomtexcoord2f[2] = (float)r_fb.bloomwidth / (float)r_fb.bloomtexturewidth;
6198 r_fb.bloomtexcoord2f[3] = (float)r_fb.bloomheight / (float)r_fb.bloomtextureheight;
6199 r_fb.bloomtexcoord2f[4] = (float)r_fb.bloomwidth / (float)r_fb.bloomtexturewidth;
6200 r_fb.bloomtexcoord2f[5] = 0;
6201 r_fb.bloomtexcoord2f[6] = 0;
6202 r_fb.bloomtexcoord2f[7] = 0;
6204 switch(vid.renderpath)
6206 case RENDERPATH_GL11:
6207 case RENDERPATH_GL13:
6208 case RENDERPATH_GL20:
6209 case RENDERPATH_SOFT:
6210 case RENDERPATH_GLES1:
6211 case RENDERPATH_GLES2:
6213 case RENDERPATH_D3D9:
6214 case RENDERPATH_D3D10:
6215 case RENDERPATH_D3D11:
6216 for (i = 0;i < 4;i++)
6218 r_fb.screentexcoord2f[i*2+0] += 0.5f / (float)r_fb.screentexturewidth;
6219 r_fb.screentexcoord2f[i*2+1] += 0.5f / (float)r_fb.screentextureheight;
6220 r_fb.bloomtexcoord2f[i*2+0] += 0.5f / (float)r_fb.bloomtexturewidth;
6221 r_fb.bloomtexcoord2f[i*2+1] += 0.5f / (float)r_fb.bloomtextureheight;
6226 R_Viewport_InitOrtho(&r_fb.bloomviewport, &identitymatrix, 0, 0, r_fb.bloomwidth, r_fb.bloomheight, 0, 0, 1, 1, -10, 100, NULL);
6229 r_refdef.view.clear = true;
6232 static void R_Bloom_MakeTexture(void)
6235 float xoffset, yoffset, r, brighten;
6237 float colorscale = r_bloom_colorscale.value;
6239 r_refdef.stats.bloom++;
6242 // this copy is unnecessary since it happens in R_BlendView already
6245 R_Mesh_CopyToTexture(r_fb.colortexture, 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
6246 r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
6250 // scale down screen texture to the bloom texture size
6252 r_fb.bloomindex = 0;
6253 R_Mesh_SetRenderTargets(r_fb.bloomfbo[r_fb.bloomindex], NULL, r_fb.bloomtexture[r_fb.bloomindex], NULL, NULL, NULL);
6254 R_SetViewport(&r_fb.bloomviewport);
6255 GL_DepthTest(false);
6256 GL_BlendFunc(GL_ONE, GL_ZERO);
6257 GL_Color(colorscale, colorscale, colorscale, 1);
6258 // D3D has upside down Y coords, the easiest way to flip this is to flip the screen vertices rather than the texcoords, so we just use a different array for that...
6259 switch(vid.renderpath)
6261 case RENDERPATH_GL11:
6262 case RENDERPATH_GL13:
6263 case RENDERPATH_GL20:
6264 case RENDERPATH_GLES1:
6265 case RENDERPATH_GLES2:
6266 case RENDERPATH_SOFT:
6267 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_fb.screentexcoord2f);
6269 case RENDERPATH_D3D9:
6270 case RENDERPATH_D3D10:
6271 case RENDERPATH_D3D11:
6272 R_Mesh_PrepareVertices_Generic_Arrays(4, r_d3dscreenvertex3f, NULL, r_fb.screentexcoord2f);
6275 // TODO: do boxfilter scale-down in shader?
6276 R_SetupShader_Generic(r_fb.colortexture, NULL, GL_MODULATE, 1, false, true, true);
6277 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
6278 r_refdef.stats.bloom_drawpixels += r_fb.bloomwidth * r_fb.bloomheight;
6280 // we now have a properly scaled bloom image
6281 if (!r_fb.bloomfbo[r_fb.bloomindex])
6283 // copy it into the bloom texture
6284 R_Mesh_CopyToTexture(r_fb.bloomtexture[r_fb.bloomindex], 0, 0, r_fb.bloomviewport.x, r_fb.bloomviewport.y, r_fb.bloomviewport.width, r_fb.bloomviewport.height);
6285 r_refdef.stats.bloom_copypixels += r_fb.bloomviewport.width * r_fb.bloomviewport.height;
6288 // multiply bloom image by itself as many times as desired
6289 for (x = 1;x < min(r_bloom_colorexponent.value, 32);)
6291 intex = r_fb.bloomtexture[r_fb.bloomindex];
6292 r_fb.bloomindex ^= 1;
6293 R_Mesh_SetRenderTargets(r_fb.bloomfbo[r_fb.bloomindex], NULL, r_fb.bloomtexture[r_fb.bloomindex], NULL, NULL, NULL);
6295 r = bound(0, r_bloom_colorexponent.value / x, 1); // always 0.5 to 1
6296 if (!r_fb.bloomfbo[r_fb.bloomindex])
6298 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR); // square it and multiply by two
6299 GL_Color(r,r,r,1); // apply fix factor
6304 GL_Clear(GL_COLOR_BUFFER_BIT, NULL, 1.0f, 128);
6305 GL_BlendFunc(GL_SRC_COLOR, GL_ZERO); // square it
6306 GL_Color(1,1,1,1); // no fix factor supported here
6308 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_fb.bloomtexcoord2f);
6309 R_SetupShader_Generic(intex, NULL, GL_MODULATE, 1, false, true, false);
6310 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
6311 r_refdef.stats.bloom_drawpixels += r_fb.bloomwidth * r_fb.bloomheight;
6313 if (!r_fb.bloomfbo[r_fb.bloomindex])
6315 // copy the darkened image to a texture
6316 R_Mesh_CopyToTexture(r_fb.bloomtexture[r_fb.bloomindex], 0, 0, r_fb.bloomviewport.x, r_fb.bloomviewport.y, r_fb.bloomviewport.width, r_fb.bloomviewport.height);
6317 r_refdef.stats.bloom_copypixels += r_fb.bloomviewport.width * r_fb.bloomviewport.height;
6321 range = r_bloom_blur.integer * r_fb.bloomwidth / 320;
6322 brighten = r_bloom_brighten.value;
6323 brighten = sqrt(brighten);
6325 brighten *= (3 * range) / (2 * range - 1); // compensate for the "dot particle"
6327 for (dir = 0;dir < 2;dir++)
6329 intex = r_fb.bloomtexture[r_fb.bloomindex];
6330 r_fb.bloomindex ^= 1;
6331 R_Mesh_SetRenderTargets(r_fb.bloomfbo[r_fb.bloomindex], NULL, r_fb.bloomtexture[r_fb.bloomindex], NULL, NULL, NULL);
6332 // blend on at multiple vertical offsets to achieve a vertical blur
6333 // TODO: do offset blends using GLSL
6334 // TODO instead of changing the texcoords, change the target positions to prevent artifacts at edges
6335 GL_BlendFunc(GL_ONE, GL_ZERO);
6336 R_SetupShader_Generic(intex, NULL, GL_MODULATE, 1, false, true, false);
6337 for (x = -range;x <= range;x++)
6339 if (!dir){xoffset = 0;yoffset = x;}
6340 else {xoffset = x;yoffset = 0;}
6341 xoffset /= (float)r_fb.bloomtexturewidth;
6342 yoffset /= (float)r_fb.bloomtextureheight;
6343 // compute a texcoord array with the specified x and y offset
6344 r_fb.offsettexcoord2f[0] = xoffset+r_fb.bloomtexcoord2f[0];
6345 r_fb.offsettexcoord2f[1] = yoffset+r_fb.bloomtexcoord2f[1];
6346 r_fb.offsettexcoord2f[2] = xoffset+r_fb.bloomtexcoord2f[2];
6347 r_fb.offsettexcoord2f[3] = yoffset+r_fb.bloomtexcoord2f[3];
6348 r_fb.offsettexcoord2f[4] = xoffset+r_fb.bloomtexcoord2f[4];
6349 r_fb.offsettexcoord2f[5] = yoffset+r_fb.bloomtexcoord2f[5];
6350 r_fb.offsettexcoord2f[6] = xoffset+r_fb.bloomtexcoord2f[6];
6351 r_fb.offsettexcoord2f[7] = yoffset+r_fb.bloomtexcoord2f[7];
6352 // this r value looks like a 'dot' particle, fading sharply to
6353 // black at the edges
6354 // (probably not realistic but looks good enough)
6355 //r = ((range*range+1)/((float)(x*x+1)))/(range*2+1);
6356 //r = brighten/(range*2+1);
6357 r = brighten / (range * 2 + 1);
6359 r *= (1 - x*x/(float)(range*range));
6360 GL_Color(r, r, r, 1);
6361 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_fb.offsettexcoord2f);
6362 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
6363 r_refdef.stats.bloom_drawpixels += r_fb.bloomwidth * r_fb.bloomheight;
6364 GL_BlendFunc(GL_ONE, GL_ONE);
6367 if (!r_fb.bloomfbo[r_fb.bloomindex])
6369 // copy the vertically or horizontally blurred bloom view to a texture
6370 R_Mesh_CopyToTexture(r_fb.bloomtexture[r_fb.bloomindex], 0, 0, r_fb.bloomviewport.x, r_fb.bloomviewport.y, r_fb.bloomviewport.width, r_fb.bloomviewport.height);
6371 r_refdef.stats.bloom_copypixels += r_fb.bloomviewport.width * r_fb.bloomviewport.height;
6376 static void R_BlendView(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture)
6378 unsigned int permutation;
6379 float uservecs[4][4];
6381 switch (vid.renderpath)
6383 case RENDERPATH_GL20:
6384 case RENDERPATH_D3D9:
6385 case RENDERPATH_D3D10:
6386 case RENDERPATH_D3D11:
6387 case RENDERPATH_SOFT:
6388 case RENDERPATH_GLES2:
6390 (r_fb.bloomtexture[r_fb.bloomindex] ? SHADERPERMUTATION_BLOOM : 0)
6391 | (r_refdef.viewblend[3] > 0 ? SHADERPERMUTATION_VIEWTINT : 0)
6392 | ((v_glslgamma.value && !vid_gammatables_trivial) ? SHADERPERMUTATION_GAMMARAMPS : 0)
6393 | (r_glsl_postprocess.integer ? SHADERPERMUTATION_POSTPROCESSING : 0)
6394 | ((!R_Stereo_ColorMasking() && r_glsl_saturation.value != 1) ? SHADERPERMUTATION_SATURATION : 0);
6396 if (r_fb.colortexture)
6400 R_Mesh_CopyToTexture(r_fb.colortexture, 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
6401 r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
6404 if(!R_Stereo_Active() && (r_motionblur.value > 0 || r_damageblur.value > 0) && r_fb.ghosttexture)
6406 // declare variables
6407 float blur_factor, blur_mouseaccel, blur_velocity;
6408 static float blur_average;
6409 static vec3_t blur_oldangles; // used to see how quickly the mouse is moving
6411 // set a goal for the factoring
6412 blur_velocity = bound(0, (VectorLength(cl.movement_velocity) - r_motionblur_velocityfactor_minspeed.value)
6413 / max(1, r_motionblur_velocityfactor_maxspeed.value - r_motionblur_velocityfactor_minspeed.value), 1);
6414 blur_mouseaccel = bound(0, ((fabs(VectorLength(cl.viewangles) - VectorLength(blur_oldangles)) * 10) - r_motionblur_mousefactor_minspeed.value)
6415 / max(1, r_motionblur_mousefactor_maxspeed.value - r_motionblur_mousefactor_minspeed.value), 1);
6416 blur_factor = ((blur_velocity * r_motionblur_velocityfactor.value)
6417 + (blur_mouseaccel * r_motionblur_mousefactor.value));
6419 // from the goal, pick an averaged value between goal and last value
6420 cl.motionbluralpha = bound(0, (cl.time - cl.oldtime) / max(0.001, r_motionblur_averaging.value), 1);
6421 blur_average = blur_average * (1 - cl.motionbluralpha) + blur_factor * cl.motionbluralpha;
6423 // enforce minimum amount of blur
6424 blur_factor = blur_average * (1 - r_motionblur_minblur.value) + r_motionblur_minblur.value;
6426 //Con_Printf("motionblur: direct factor: %f, averaged factor: %f, velocity: %f, mouse accel: %f \n", blur_factor, blur_average, blur_velocity, blur_mouseaccel);
6428 // calculate values into a standard alpha
6429 cl.motionbluralpha = 1 - exp(-
6431 (r_motionblur.value * blur_factor / 80)
6433 (r_damageblur.value * (cl.cshifts[CSHIFT_DAMAGE].percent / 1600))
6436 max(0.0001, cl.time - cl.oldtime) // fps independent
6439 // randomization for the blur value to combat persistent ghosting
6440 cl.motionbluralpha *= lhrandom(1 - r_motionblur_randomize.value, 1 + r_motionblur_randomize.value);
6441 cl.motionbluralpha = bound(0, cl.motionbluralpha, r_motionblur_maxblur.value);
6444 R_ResetViewRendering2D(fbo, depthtexture, colortexture);
6445 if (cl.motionbluralpha > 0 && !r_refdef.envmap && r_fb.ghosttexture_valid)
6447 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6448 GL_Color(1, 1, 1, cl.motionbluralpha);
6449 switch(vid.renderpath)
6451 case RENDERPATH_GL11:
6452 case RENDERPATH_GL13:
6453 case RENDERPATH_GL20:
6454 case RENDERPATH_GLES1:
6455 case RENDERPATH_GLES2:
6456 case RENDERPATH_SOFT:
6457 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, r_fb.screentexcoord2f);
6459 case RENDERPATH_D3D9:
6460 case RENDERPATH_D3D10:
6461 case RENDERPATH_D3D11:
6462 R_Mesh_PrepareVertices_Generic_Arrays(4, r_d3dscreenvertex3f, NULL, r_fb.screentexcoord2f);
6465 R_SetupShader_Generic(r_fb.ghosttexture, NULL, GL_MODULATE, 1, false, true, true);
6466 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
6467 r_refdef.stats.bloom_drawpixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
6470 // updates old view angles for next pass
6471 VectorCopy(cl.viewangles, blur_oldangles);
6473 // copy view into the ghost texture
6474 R_Mesh_CopyToTexture(r_fb.ghosttexture, 0, 0, r_refdef.view.viewport.x, r_refdef.view.viewport.y, r_refdef.view.viewport.width, r_refdef.view.viewport.height);
6475 r_refdef.stats.bloom_copypixels += r_refdef.view.viewport.width * r_refdef.view.viewport.height;
6476 r_fb.ghosttexture_valid = true;
6481 // no r_fb.colortexture means we're rendering to the real fb
6482 // we may still have to do view tint...
6483 if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
6485 // apply a color tint to the whole view
6486 R_ResetViewRendering2D(0, NULL, NULL);
6487 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
6488 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, NULL);
6489 R_SetupShader_Generic_NoTexture(false, true);
6490 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6491 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
6493 break; // no screen processing, no bloom, skip it
6496 if (r_fb.bloomtexture[0])
6498 // make the bloom texture
6499 R_Bloom_MakeTexture();
6502 #if _MSC_VER >= 1400
6503 #define sscanf sscanf_s
6505 memset(uservecs, 0, sizeof(uservecs));
6506 if (r_glsl_postprocess_uservec1_enable.integer)
6507 sscanf(r_glsl_postprocess_uservec1.string, "%f %f %f %f", &uservecs[0][0], &uservecs[0][1], &uservecs[0][2], &uservecs[0][3]);
6508 if (r_glsl_postprocess_uservec2_enable.integer)
6509 sscanf(r_glsl_postprocess_uservec2.string, "%f %f %f %f", &uservecs[1][0], &uservecs[1][1], &uservecs[1][2], &uservecs[1][3]);
6510 if (r_glsl_postprocess_uservec3_enable.integer)
6511 sscanf(r_glsl_postprocess_uservec3.string, "%f %f %f %f", &uservecs[2][0], &uservecs[2][1], &uservecs[2][2], &uservecs[2][3]);
6512 if (r_glsl_postprocess_uservec4_enable.integer)
6513 sscanf(r_glsl_postprocess_uservec4.string, "%f %f %f %f", &uservecs[3][0], &uservecs[3][1], &uservecs[3][2], &uservecs[3][3]);
6515 R_ResetViewRendering2D(0, NULL, NULL); // here we render to the real framebuffer!
6516 GL_Color(1, 1, 1, 1);
6517 GL_BlendFunc(GL_ONE, GL_ZERO);
6519 switch(vid.renderpath)
6521 case RENDERPATH_GL20:
6522 case RENDERPATH_GLES2:
6523 R_Mesh_PrepareVertices_Mesh_Arrays(4, r_screenvertex3f, NULL, NULL, NULL, NULL, r_fb.screentexcoord2f, r_fb.bloomtexcoord2f);
6524 R_SetupShader_SetPermutationGLSL(SHADERMODE_POSTPROCESS, permutation);
6525 if (r_glsl_permutation->tex_Texture_First >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_First , r_fb.colortexture);
6526 if (r_glsl_permutation->tex_Texture_Second >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_Second , r_fb.bloomtexture[r_fb.bloomindex]);
6527 if (r_glsl_permutation->tex_Texture_GammaRamps >= 0) R_Mesh_TexBind(r_glsl_permutation->tex_Texture_GammaRamps, r_texture_gammaramps );
6528 if (r_glsl_permutation->loc_ViewTintColor >= 0) qglUniform4f(r_glsl_permutation->loc_ViewTintColor , r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
6529 if (r_glsl_permutation->loc_PixelSize >= 0) qglUniform2f(r_glsl_permutation->loc_PixelSize , 1.0/r_fb.screentexturewidth, 1.0/r_fb.screentextureheight);
6530 if (r_glsl_permutation->loc_UserVec1 >= 0) qglUniform4f(r_glsl_permutation->loc_UserVec1 , uservecs[0][0], uservecs[0][1], uservecs[0][2], uservecs[0][3]);
6531 if (r_glsl_permutation->loc_UserVec2 >= 0) qglUniform4f(r_glsl_permutation->loc_UserVec2 , uservecs[1][0], uservecs[1][1], uservecs[1][2], uservecs[1][3]);
6532 if (r_glsl_permutation->loc_UserVec3 >= 0) qglUniform4f(r_glsl_permutation->loc_UserVec3 , uservecs[2][0], uservecs[2][1], uservecs[2][2], uservecs[2][3]);
6533 if (r_glsl_permutation->loc_UserVec4 >= 0) qglUniform4f(r_glsl_permutation->loc_UserVec4 , uservecs[3][0], uservecs[3][1], uservecs[3][2], uservecs[3][3]);
6534 if (r_glsl_permutation->loc_Saturation >= 0) qglUniform1f(r_glsl_permutation->loc_Saturation , r_glsl_saturation.value);
6535 if (r_glsl_permutation->loc_PixelToScreenTexCoord >= 0) qglUniform2f(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
6536 if (r_glsl_permutation->loc_BloomColorSubtract >= 0) qglUniform4f(r_glsl_permutation->loc_BloomColorSubtract , r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 0.0f);
6538 case RENDERPATH_D3D9:
6540 // D3D has upside down Y coords, the easiest way to flip this is to flip the screen vertices rather than the texcoords, so we just use a different array for that...
6541 R_Mesh_PrepareVertices_Mesh_Arrays(4, r_d3dscreenvertex3f, NULL, NULL, NULL, NULL, r_fb.screentexcoord2f, r_fb.bloomtexcoord2f);
6542 R_SetupShader_SetPermutationHLSL(SHADERMODE_POSTPROCESS, permutation);
6543 R_Mesh_TexBind(GL20TU_FIRST , r_fb.colortexture);
6544 R_Mesh_TexBind(GL20TU_SECOND , r_fb.bloomtexture[r_fb.bloomindex]);
6545 R_Mesh_TexBind(GL20TU_GAMMARAMPS, r_texture_gammaramps );
6546 hlslPSSetParameter4f(D3DPSREGISTER_ViewTintColor , r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
6547 hlslPSSetParameter2f(D3DPSREGISTER_PixelSize , 1.0/r_fb.screentexturewidth, 1.0/r_fb.screentextureheight);
6548 hlslPSSetParameter4f(D3DPSREGISTER_UserVec1 , uservecs[0][0], uservecs[0][1], uservecs[0][2], uservecs[0][3]);
6549 hlslPSSetParameter4f(D3DPSREGISTER_UserVec2 , uservecs[1][0], uservecs[1][1], uservecs[1][2], uservecs[1][3]);
6550 hlslPSSetParameter4f(D3DPSREGISTER_UserVec3 , uservecs[2][0], uservecs[2][1], uservecs[2][2], uservecs[2][3]);
6551 hlslPSSetParameter4f(D3DPSREGISTER_UserVec4 , uservecs[3][0], uservecs[3][1], uservecs[3][2], uservecs[3][3]);
6552 hlslPSSetParameter1f(D3DPSREGISTER_Saturation , r_glsl_saturation.value);
6553 hlslPSSetParameter2f(D3DPSREGISTER_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);
6554 hlslPSSetParameter4f(D3DPSREGISTER_BloomColorSubtract , r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 0.0f);
6557 case RENDERPATH_D3D10:
6558 Con_DPrintf("FIXME D3D10 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
6560 case RENDERPATH_D3D11:
6561 Con_DPrintf("FIXME D3D11 %s:%i %s\n", __FILE__, __LINE__, __FUNCTION__);
6563 case RENDERPATH_SOFT:
6564 R_Mesh_PrepareVertices_Mesh_Arrays(4, r_screenvertex3f, NULL, NULL, NULL, NULL, r_fb.screentexcoord2f, r_fb.bloomtexcoord2f);
6565 R_SetupShader_SetPermutationSoft(SHADERMODE_POSTPROCESS, permutation);
6566 R_Mesh_TexBind(GL20TU_FIRST , r_fb.colortexture);
6567 R_Mesh_TexBind(GL20TU_SECOND , r_fb.bloomtexture[r_fb.bloomindex]);
6568 R_Mesh_TexBind(GL20TU_GAMMARAMPS, r_texture_gammaramps );
6569 DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_ViewTintColor , r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
6570 DPSOFTRAST_Uniform2f(DPSOFTRAST_UNIFORM_PixelSize , 1.0/r_fb.screentexturewidth, 1.0/r_fb.screentextureheight);
6571 DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_UserVec1 , uservecs[0][0], uservecs[0][1], uservecs[0][2], uservecs[0][3]);
6572 DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_UserVec2 , uservecs[1][0], uservecs[1][1], uservecs[1][2], uservecs[1][3]);
6573 DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_UserVec3 , uservecs[2][0], uservecs[2][1], uservecs[2][2], uservecs[2][3]);
6574 DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_UserVec4 , uservecs[3][0], uservecs[3][1], uservecs[3][2], uservecs[3][3]);
6575 DPSOFTRAST_Uniform1f(DPSOFTRAST_UNIFORM_Saturation , r_glsl_saturation.value);
6576 DPSOFTRAST_Uniform2f(DPSOFTRAST_UNIFORM_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height);
6577 DPSOFTRAST_Uniform4f(DPSOFTRAST_UNIFORM_BloomColorSubtract , r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 0.0f);
6582 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
6583 r_refdef.stats.bloom_drawpixels += r_refdef.view.width * r_refdef.view.height;
6585 case RENDERPATH_GL11:
6586 case RENDERPATH_GL13:
6587 case RENDERPATH_GLES1:
6588 if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
6590 // apply a color tint to the whole view
6591 R_ResetViewRendering2D(0, NULL, NULL);
6592 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
6593 R_Mesh_PrepareVertices_Generic_Arrays(4, r_screenvertex3f, NULL, NULL);
6594 R_SetupShader_Generic_NoTexture(false, true);
6595 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
6596 R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
6602 matrix4x4_t r_waterscrollmatrix;
6604 void R_UpdateFog(void)
6607 if (gamemode == GAME_NEHAHRA)
6609 if (gl_fogenable.integer)
6611 r_refdef.oldgl_fogenable = true;
6612 r_refdef.fog_density = gl_fogdensity.value;
6613 r_refdef.fog_red = gl_fogred.value;
6614 r_refdef.fog_green = gl_foggreen.value;
6615 r_refdef.fog_blue = gl_fogblue.value;
6616 r_refdef.fog_alpha = 1;
6617 r_refdef.fog_start = 0;
6618 r_refdef.fog_end = gl_skyclip.value;
6619 r_refdef.fog_height = 1<<30;
6620 r_refdef.fog_fadedepth = 128;
6622 else if (r_refdef.oldgl_fogenable)
6624 r_refdef.oldgl_fogenable = false;
6625 r_refdef.fog_density = 0;
6626 r_refdef.fog_red = 0;
6627 r_refdef.fog_green = 0;
6628 r_refdef.fog_blue = 0;
6629 r_refdef.fog_alpha = 0;
6630 r_refdef.fog_start = 0;
6631 r_refdef.fog_end = 0;
6632 r_refdef.fog_height = 1<<30;
6633 r_refdef.fog_fadedepth = 128;
6638 r_refdef.fog_alpha = bound(0, r_refdef.fog_alpha, 1);
6639 r_refdef.fog_start = max(0, r_refdef.fog_start);
6640 r_refdef.fog_end = max(r_refdef.fog_start + 0.01, r_refdef.fog_end);
6642 if (r_refdef.fog_density && r_drawfog.integer)
6644 r_refdef.fogenabled = true;
6645 // this is the point where the fog reaches 0.9986 alpha, which we
6646 // consider a good enough cutoff point for the texture
6647 // (0.9986 * 256 == 255.6)
6648 if (r_fog_exp2.integer)
6649 r_refdef.fogrange = 32 / (r_refdef.fog_density * r_refdef.fog_density) + r_refdef.fog_start;
6651 r_refdef.fogrange = 2048 / r_refdef.fog_density + r_refdef.fog_start;
6652 r_refdef.fogrange = bound(r_refdef.fog_start, r_refdef.fogrange, r_refdef.fog_end);
6653 r_refdef.fograngerecip = 1.0f / r_refdef.fogrange;
6654 r_refdef.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * r_refdef.fograngerecip;
6655 if (strcmp(r_refdef.fogheighttexturename, r_refdef.fog_height_texturename))
6656 R_BuildFogHeightTexture();
6657 // fog color was already set
6658 // update the fog texture
6659 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)
6660 R_BuildFogTexture();
6661 r_refdef.fog_height_texcoordscale = 1.0f / max(0.125f, r_refdef.fog_fadedepth);
6662 r_refdef.fog_height_tablescale = r_refdef.fog_height_tablesize * r_refdef.fog_height_texcoordscale;
6665 r_refdef.fogenabled = false;
6668 if (r_refdef.fog_density)
6670 r_refdef.fogcolor[0] = r_refdef.fog_red;
6671 r_refdef.fogcolor[1] = r_refdef.fog_green;
6672 r_refdef.fogcolor[2] = r_refdef.fog_blue;
6674 Vector4Set(r_refdef.fogplane, 0, 0, 1, -r_refdef.fog_height);
6675 r_refdef.fogplaneviewdist = DotProduct(r_refdef.fogplane, r_refdef.view.origin) + r_refdef.fogplane[3];
6676 r_refdef.fogplaneviewabove = r_refdef.fogplaneviewdist >= 0;
6677 r_refdef.fogheightfade = -0.5f/max(0.125f, r_refdef.fog_fadedepth);
6681 VectorCopy(r_refdef.fogcolor, fogvec);
6682 // color.rgb *= ContrastBoost * SceneBrightness;
6683 VectorScale(fogvec, r_refdef.view.colorscale, fogvec);
6684 r_refdef.fogcolor[0] = bound(0.0f, fogvec[0], 1.0f);
6685 r_refdef.fogcolor[1] = bound(0.0f, fogvec[1], 1.0f);
6686 r_refdef.fogcolor[2] = bound(0.0f, fogvec[2], 1.0f);
6691 void R_UpdateVariables(void)
6695 r_refdef.scene.ambient = r_ambient.value * (1.0f / 64.0f);
6697 r_refdef.farclip = r_farclip_base.value;
6698 if (r_refdef.scene.worldmodel)
6699 r_refdef.farclip += r_refdef.scene.worldmodel->radius * r_farclip_world.value * 2;
6700 r_refdef.nearclip = bound (0.001f, r_nearclip.value, r_refdef.farclip - 1.0f);
6702 if (r_shadow_frontsidecasting.integer < 0 || r_shadow_frontsidecasting.integer > 1)
6703 Cvar_SetValueQuick(&r_shadow_frontsidecasting, 1);
6704 r_refdef.polygonfactor = 0;
6705 r_refdef.polygonoffset = 0;
6706 r_refdef.shadowpolygonfactor = r_refdef.polygonfactor + r_shadow_polygonfactor.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
6707 r_refdef.shadowpolygonoffset = r_refdef.polygonoffset + r_shadow_polygonoffset.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
6709 r_refdef.scene.rtworld = r_shadow_realtime_world.integer != 0;
6710 r_refdef.scene.rtworldshadows = r_shadow_realtime_world_shadows.integer && vid.stencil;
6711 r_refdef.scene.rtdlight = r_shadow_realtime_dlight.integer != 0 && !gl_flashblend.integer && r_dynamic.integer;
6712 r_refdef.scene.rtdlightshadows = r_refdef.scene.rtdlight && r_shadow_realtime_dlight_shadows.integer && vid.stencil;
6713 r_refdef.lightmapintensity = r_refdef.scene.rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
6714 if (FAKELIGHT_ENABLED)
6716 r_refdef.lightmapintensity *= r_fakelight_intensity.value;
6718 else if (r_refdef.scene.worldmodel)
6720 r_refdef.lightmapintensity *= r_refdef.scene.worldmodel->lightmapscale;
6722 if (r_showsurfaces.integer)
6724 r_refdef.scene.rtworld = false;
6725 r_refdef.scene.rtworldshadows = false;
6726 r_refdef.scene.rtdlight = false;
6727 r_refdef.scene.rtdlightshadows = false;
6728 r_refdef.lightmapintensity = 0;
6731 switch(vid.renderpath)
6733 case RENDERPATH_GL20:
6734 case RENDERPATH_D3D9:
6735 case RENDERPATH_D3D10:
6736 case RENDERPATH_D3D11:
6737 case RENDERPATH_SOFT:
6738 case RENDERPATH_GLES2:
6739 if(v_glslgamma.integer && !vid_gammatables_trivial)
6741 if(!r_texture_gammaramps || vid_gammatables_serial != r_texture_gammaramps_serial)
6743 // build GLSL gamma texture
6744 #define RAMPWIDTH 256
6745 unsigned short ramp[RAMPWIDTH * 3];
6746 unsigned char rampbgr[RAMPWIDTH][4];
6749 r_texture_gammaramps_serial = vid_gammatables_serial;
6751 VID_BuildGammaTables(&ramp[0], RAMPWIDTH);
6752 for(i = 0; i < RAMPWIDTH; ++i)
6754 rampbgr[i][0] = (unsigned char) (ramp[i + 2 * RAMPWIDTH] * 255.0 / 65535.0 + 0.5);
6755 rampbgr[i][1] = (unsigned char) (ramp[i + RAMPWIDTH] * 255.0 / 65535.0 + 0.5);
6756 rampbgr[i][2] = (unsigned char) (ramp[i] * 255.0 / 65535.0 + 0.5);
6759 if (r_texture_gammaramps)
6761 R_UpdateTexture(r_texture_gammaramps, &rampbgr[0][0], 0, 0, 0, RAMPWIDTH, 1, 1);
6765 r_texture_gammaramps = R_LoadTexture2D(r_main_texturepool, "gammaramps", RAMPWIDTH, 1, &rampbgr[0][0], TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_PERSISTENT, -1, NULL);
6771 // remove GLSL gamma texture
6774 case RENDERPATH_GL11:
6775 case RENDERPATH_GL13:
6776 case RENDERPATH_GLES1:
6781 static r_refdef_scene_type_t r_currentscenetype = RST_CLIENT;
6782 static r_refdef_scene_t r_scenes_store[ RST_COUNT ];
6788 void R_SelectScene( r_refdef_scene_type_t scenetype ) {
6789 if( scenetype != r_currentscenetype ) {
6790 // store the old scenetype
6791 r_scenes_store[ r_currentscenetype ] = r_refdef.scene;
6792 r_currentscenetype = scenetype;
6793 // move in the new scene
6794 r_refdef.scene = r_scenes_store[ r_currentscenetype ];
6803 r_refdef_scene_t * R_GetScenePointer( r_refdef_scene_type_t scenetype )
6805 // of course, we could also add a qboolean that provides a lock state and a ReleaseScenePointer function..
6806 if( scenetype == r_currentscenetype ) {
6807 return &r_refdef.scene;
6809 return &r_scenes_store[ scenetype ];
6813 static int R_SortEntities_Compare(const void *ap, const void *bp)
6815 const entity_render_t *a = *(const entity_render_t **)ap;
6816 const entity_render_t *b = *(const entity_render_t **)bp;
6819 if(a->model < b->model)
6821 if(a->model > b->model)
6825 // TODO possibly calculate the REAL skinnum here first using
6827 if(a->skinnum < b->skinnum)
6829 if(a->skinnum > b->skinnum)
6832 // everything we compared is equal
6835 static void R_SortEntities(void)
6837 // below or equal 2 ents, sorting never gains anything
6838 if(r_refdef.scene.numentities <= 2)
6841 qsort(r_refdef.scene.entities, r_refdef.scene.numentities, sizeof(*r_refdef.scene.entities), R_SortEntities_Compare);
6849 int dpsoftrast_test;
6850 extern cvar_t r_shadow_bouncegrid;
6851 void R_RenderView(void)
6853 matrix4x4_t originalmatrix = r_refdef.view.matrix, offsetmatrix;
6855 rtexture_t *depthtexture;
6856 rtexture_t *colortexture;
6858 dpsoftrast_test = r_test.integer;
6860 if (r_timereport_active)
6861 R_TimeReport("start");
6862 r_textureframe++; // used only by R_GetCurrentTexture
6863 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
6865 if(R_CompileShader_CheckStaticParms())
6868 if (!r_drawentities.integer)
6869 r_refdef.scene.numentities = 0;
6870 else if (r_sortentities.integer)
6873 R_AnimCache_ClearCache();
6874 R_FrameData_NewFrame();
6876 /* adjust for stereo display */
6877 if(R_Stereo_Active())
6879 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);
6880 Matrix4x4_Concat(&r_refdef.view.matrix, &originalmatrix, &offsetmatrix);
6883 if (r_refdef.view.isoverlay)
6885 // TODO: FIXME: move this into its own backend function maybe? [2/5/2008 Andreas]
6886 R_Mesh_SetRenderTargets(0, NULL, NULL, NULL, NULL, NULL);
6887 GL_Clear(GL_DEPTH_BUFFER_BIT, NULL, 1.0f, 0);
6888 R_TimeReport("depthclear");
6890 r_refdef.view.showdebug = false;
6892 r_fb.water.enabled = false;
6893 r_fb.water.numwaterplanes = 0;
6895 R_RenderScene(0, NULL, NULL);
6897 r_refdef.view.matrix = originalmatrix;
6903 if (!r_refdef.scene.entities || r_refdef.view.width * r_refdef.view.height == 0 || !r_renderview.integer || cl_videoplaying/* || !r_refdef.scene.worldmodel*/)
6905 r_refdef.view.matrix = originalmatrix;
6909 r_refdef.view.colorscale = r_hdr_scenebrightness.value * r_hdr_irisadaptation_value.value;
6911 if(vid_sRGB.integer && vid_sRGB_fallback.integer && !vid.sRGB3D)
6912 // in sRGB fallback, behave similar to true sRGB: convert this
6913 // value from linear to sRGB
6914 r_refdef.view.colorscale = Image_sRGBFloatFromLinearFloat(r_refdef.view.colorscale);
6916 R_RenderView_UpdateViewVectors();
6918 R_Shadow_UpdateWorldLightSelection();
6920 R_Bloom_StartFrame();
6921 R_Water_StartFrame();
6923 // now we probably have an fbo to render into
6925 depthtexture = r_fb.depthtexture;
6926 colortexture = r_fb.colortexture;
6929 if (r_timereport_active)
6930 R_TimeReport("viewsetup");
6932 R_ResetViewRendering3D(fbo, depthtexture, colortexture);
6934 if (r_refdef.view.clear || r_refdef.fogenabled || fbo)
6936 R_ClearScreen(r_refdef.fogenabled);
6937 if (r_timereport_active)
6938 R_TimeReport("viewclear");
6940 r_refdef.view.clear = true;
6942 r_refdef.view.showdebug = true;
6945 if (r_timereport_active)
6946 R_TimeReport("visibility");
6948 R_AnimCache_CacheVisibleEntities();
6949 if (r_timereport_active)
6950 R_TimeReport("animcache");
6952 R_Shadow_UpdateBounceGridTexture();
6953 if (r_timereport_active && r_shadow_bouncegrid.integer)
6954 R_TimeReport("bouncegrid");
6956 r_fb.water.numwaterplanes = 0;
6957 if (r_fb.water.enabled)
6958 R_RenderWaterPlanes(fbo, depthtexture, colortexture);
6960 R_RenderScene(fbo, depthtexture, colortexture);
6961 r_fb.water.numwaterplanes = 0;
6963 R_BlendView(fbo, depthtexture, colortexture);
6964 if (r_timereport_active)
6965 R_TimeReport("blendview");
6967 GL_Scissor(0, 0, vid.width, vid.height);
6968 GL_ScissorTest(false);
6970 r_refdef.view.matrix = originalmatrix;
6975 void R_RenderWaterPlanes(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture)
6977 if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawAddWaterPlanes)
6979 r_refdef.scene.worldmodel->DrawAddWaterPlanes(r_refdef.scene.worldentity);
6980 if (r_timereport_active)
6981 R_TimeReport("waterworld");
6984 // don't let sound skip if going slow
6985 if (r_refdef.scene.extraupdate)
6988 R_DrawModelsAddWaterPlanes();
6989 if (r_timereport_active)
6990 R_TimeReport("watermodels");
6992 if (r_fb.water.numwaterplanes)
6994 R_Water_ProcessPlanes(fbo, depthtexture, colortexture);
6995 if (r_timereport_active)
6996 R_TimeReport("waterscenes");
7000 extern cvar_t cl_locs_show;
7001 static void R_DrawLocs(void);
7002 static void R_DrawEntityBBoxes(void);
7003 static void R_DrawModelDecals(void);
7004 extern cvar_t cl_decals_newsystem;
7005 extern qboolean r_shadow_usingdeferredprepass;
7006 void R_RenderScene(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture)
7008 qboolean shadowmapping = false;
7010 if (r_timereport_active)
7011 R_TimeReport("beginscene");
7013 r_refdef.stats.renders++;
7017 // don't let sound skip if going slow
7018 if (r_refdef.scene.extraupdate)
7021 R_MeshQueue_BeginScene();
7025 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);
7027 if (r_timereport_active)
7028 R_TimeReport("skystartframe");
7030 if (cl.csqc_vidvars.drawworld)
7032 // don't let sound skip if going slow
7033 if (r_refdef.scene.extraupdate)
7036 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawSky)
7038 r_refdef.scene.worldmodel->DrawSky(r_refdef.scene.worldentity);
7039 if (r_timereport_active)
7040 R_TimeReport("worldsky");
7043 if (R_DrawBrushModelsSky() && r_timereport_active)
7044 R_TimeReport("bmodelsky");
7046 if (skyrendermasked && skyrenderlater)
7048 // we have to force off the water clipping plane while rendering sky
7049 R_SetupView(false, fbo, depthtexture, colortexture);
7051 R_SetupView(true, fbo, depthtexture, colortexture);
7052 if (r_timereport_active)
7053 R_TimeReport("sky");
7057 R_Shadow_PrepareLights(fbo, depthtexture, colortexture);
7058 if (r_shadows.integer > 0 && r_refdef.lightmapintensity > 0)
7059 R_Shadow_PrepareModelShadows();
7060 if (r_timereport_active)
7061 R_TimeReport("preparelights");
7063 if (R_Shadow_ShadowMappingEnabled())
7064 shadowmapping = true;
7066 if (r_shadow_usingdeferredprepass)
7067 R_Shadow_DrawPrepass();
7069 if (r_depthfirst.integer >= 1 && cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->DrawDepth)
7071 r_refdef.scene.worldmodel->DrawDepth(r_refdef.scene.worldentity);
7072 if (r_timereport_active)
7073 R_TimeReport("worlddepth");
7075 if (r_depthfirst.integer >= 2)
7077 R_DrawModelsDepth();
7078 if (r_timereport_active)
7079 R_TimeReport("modeldepth");
7082 if (r_shadows.integer >= 2 && shadowmapping && r_refdef.lightmapintensity > 0)
7084 R_ResetViewRendering3D(fbo, depthtexture, colortexture);
7085 R_DrawModelShadowMaps(fbo, depthtexture, colortexture);
7086 R_ResetViewRendering3D(fbo, depthtexture, colortexture);
7087 // don't let sound skip if going slow
7088 if (r_refdef.scene.extraupdate)
7092 if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->Draw)
7094 r_refdef.scene.worldmodel->Draw(r_refdef.scene.worldentity);
7095 if (r_timereport_active)
7096 R_TimeReport("world");
7099 // don't let sound skip if going slow
7100 if (r_refdef.scene.extraupdate)
7104 if (r_timereport_active)
7105 R_TimeReport("models");
7107 // don't let sound skip if going slow
7108 if (r_refdef.scene.extraupdate)
7111 if ((r_shadows.integer == 1 || (r_shadows.integer > 0 && !shadowmapping)) && !r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0)
7113 R_ResetViewRendering3D(fbo, depthtexture, colortexture);
7114 R_DrawModelShadows(fbo, depthtexture, colortexture);
7115 R_ResetViewRendering3D(fbo, depthtexture, colortexture);
7116 // don't let sound skip if going slow
7117 if (r_refdef.scene.extraupdate)
7121 if (!r_shadow_usingdeferredprepass)
7123 R_Shadow_DrawLights();
7124 if (r_timereport_active)
7125 R_TimeReport("rtlights");
7128 // don't let sound skip if going slow
7129 if (r_refdef.scene.extraupdate)
7132 if ((r_shadows.integer == 1 || (r_shadows.integer > 0 && !shadowmapping)) && r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0)
7134 R_ResetViewRendering3D(fbo, depthtexture, colortexture);
7135 R_DrawModelShadows(fbo, depthtexture, colortexture);
7136 R_ResetViewRendering3D(fbo, depthtexture, colortexture);
7137 // don't let sound skip if going slow
7138 if (r_refdef.scene.extraupdate)
7142 if (cl.csqc_vidvars.drawworld)
7144 if (cl_decals_newsystem.integer)
7146 R_DrawModelDecals();
7147 if (r_timereport_active)
7148 R_TimeReport("modeldecals");
7153 if (r_timereport_active)
7154 R_TimeReport("decals");
7158 if (r_timereport_active)
7159 R_TimeReport("particles");
7162 if (r_timereport_active)
7163 R_TimeReport("explosions");
7165 R_DrawLightningBeams();
7166 if (r_timereport_active)
7167 R_TimeReport("lightning");
7171 VM_CL_AddPolygonsToMeshQueue(CLVM_prog);
7173 if (r_refdef.view.showdebug)
7175 if (cl_locs_show.integer)
7178 if (r_timereport_active)
7179 R_TimeReport("showlocs");
7182 if (r_drawportals.integer)
7185 if (r_timereport_active)
7186 R_TimeReport("portals");
7189 if (r_showbboxes.value > 0)
7191 R_DrawEntityBBoxes();
7192 if (r_timereport_active)
7193 R_TimeReport("bboxes");
7197 if (r_transparent.integer)
7199 R_MeshQueue_RenderTransparent();
7200 if (r_timereport_active)
7201 R_TimeReport("drawtrans");
7204 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))
7206 r_refdef.scene.worldmodel->DrawDebug(r_refdef.scene.worldentity);
7207 if (r_timereport_active)
7208 R_TimeReport("worlddebug");
7209 R_DrawModelsDebug();
7210 if (r_timereport_active)
7211 R_TimeReport("modeldebug");
7214 if (cl.csqc_vidvars.drawworld)
7216 R_Shadow_DrawCoronas();
7217 if (r_timereport_active)
7218 R_TimeReport("coronas");
7223 GL_DepthTest(false);
7224 qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
7225 GL_Color(1, 1, 1, 1);
7226 qglBegin(GL_POLYGON);
7227 qglVertex3f(r_refdef.view.frustumcorner[0][0], r_refdef.view.frustumcorner[0][1], r_refdef.view.frustumcorner[0][2]);
7228 qglVertex3f(r_refdef.view.frustumcorner[1][0], r_refdef.view.frustumcorner[1][1], r_refdef.view.frustumcorner[1][2]);
7229 qglVertex3f(r_refdef.view.frustumcorner[3][0], r_refdef.view.frustumcorner[3][1], r_refdef.view.frustumcorner[3][2]);
7230 qglVertex3f(r_refdef.view.frustumcorner[2][0], r_refdef.view.frustumcorner[2][1], r_refdef.view.frustumcorner[2][2]);
7232 qglBegin(GL_POLYGON);
7233 qglVertex3f(r_refdef.view.frustumcorner[0][0] + 1000 * r_refdef.view.forward[0], r_refdef.view.frustumcorner[0][1] + 1000 * r_refdef.view.forward[1], r_refdef.view.frustumcorner[0][2] + 1000 * r_refdef.view.forward[2]);
7234 qglVertex3f(r_refdef.view.frustumcorner[1][0] + 1000 * r_refdef.view.forward[0], r_refdef.view.frustumcorner[1][1] + 1000 * r_refdef.view.forward[1], r_refdef.view.frustumcorner[1][2] + 1000 * r_refdef.view.forward[2]);
7235 qglVertex3f(r_refdef.view.frustumcorner[3][0] + 1000 * r_refdef.view.forward[0], r_refdef.view.frustumcorner[3][1] + 1000 * r_refdef.view.forward[1], r_refdef.view.frustumcorner[3][2] + 1000 * r_refdef.view.forward[2]);
7236 qglVertex3f(r_refdef.view.frustumcorner[2][0] + 1000 * r_refdef.view.forward[0], r_refdef.view.frustumcorner[2][1] + 1000 * r_refdef.view.forward[1], r_refdef.view.frustumcorner[2][2] + 1000 * r_refdef.view.forward[2]);
7238 qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
7242 // don't let sound skip if going slow
7243 if (r_refdef.scene.extraupdate)
7247 static const unsigned short bboxelements[36] =
7257 static void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, float ca)
7260 float *v, *c, f1, f2, vertex3f[8*3], color4f[8*4];
7262 RSurf_ActiveWorldEntity();
7264 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
7265 GL_DepthMask(false);
7266 GL_DepthRange(0, 1);
7267 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
7268 // R_Mesh_ResetTextureState();
7270 vertex3f[ 0] = mins[0];vertex3f[ 1] = mins[1];vertex3f[ 2] = mins[2]; //
7271 vertex3f[ 3] = maxs[0];vertex3f[ 4] = mins[1];vertex3f[ 5] = mins[2];
7272 vertex3f[ 6] = mins[0];vertex3f[ 7] = maxs[1];vertex3f[ 8] = mins[2];
7273 vertex3f[ 9] = maxs[0];vertex3f[10] = maxs[1];vertex3f[11] = mins[2];
7274 vertex3f[12] = mins[0];vertex3f[13] = mins[1];vertex3f[14] = maxs[2];
7275 vertex3f[15] = maxs[0];vertex3f[16] = mins[1];vertex3f[17] = maxs[2];
7276 vertex3f[18] = mins[0];vertex3f[19] = maxs[1];vertex3f[20] = maxs[2];
7277 vertex3f[21] = maxs[0];vertex3f[22] = maxs[1];vertex3f[23] = maxs[2];
7278 R_FillColors(color4f, 8, cr, cg, cb, ca);
7279 if (r_refdef.fogenabled)
7281 for (i = 0, v = vertex3f, c = color4f;i < 8;i++, v += 3, c += 4)
7283 f1 = RSurf_FogVertex(v);
7285 c[0] = c[0] * f1 + r_refdef.fogcolor[0] * f2;
7286 c[1] = c[1] * f1 + r_refdef.fogcolor[1] * f2;
7287 c[2] = c[2] * f1 + r_refdef.fogcolor[2] * f2;
7290 R_Mesh_PrepareVertices_Generic_Arrays(8, vertex3f, color4f, NULL);
7291 R_Mesh_ResetTextureState();
7292 R_SetupShader_Generic_NoTexture(false, false);
7293 R_Mesh_Draw(0, 8, 0, 12, NULL, NULL, 0, bboxelements, NULL, 0);
7296 static void R_DrawEntityBBoxes_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
7298 prvm_prog_t *prog = SVVM_prog;
7301 prvm_edict_t *edict;
7303 // this function draws bounding boxes of server entities
7307 GL_CullFace(GL_NONE);
7308 R_SetupShader_Generic_NoTexture(false, false);
7310 for (i = 0;i < numsurfaces;i++)
7312 edict = PRVM_EDICT_NUM(surfacelist[i]);
7313 switch ((int)PRVM_serveredictfloat(edict, solid))
7315 case SOLID_NOT: Vector4Set(color, 1, 1, 1, 0.05);break;
7316 case SOLID_TRIGGER: Vector4Set(color, 1, 0, 1, 0.10);break;
7317 case SOLID_BBOX: Vector4Set(color, 0, 1, 0, 0.10);break;
7318 case SOLID_SLIDEBOX: Vector4Set(color, 1, 0, 0, 0.10);break;
7319 case SOLID_BSP: Vector4Set(color, 0, 0, 1, 0.05);break;
7320 case SOLID_CORPSE: Vector4Set(color, 1, 0.5, 0, 0.05);break;
7321 default: Vector4Set(color, 0, 0, 0, 0.50);break;
7323 color[3] *= r_showbboxes.value;
7324 color[3] = bound(0, color[3], 1);
7325 GL_DepthTest(!r_showdisabledepthtest.integer);
7326 GL_CullFace(r_refdef.view.cullface_front);
7327 R_DrawBBoxMesh(edict->priv.server->areamins, edict->priv.server->areamaxs, color[0], color[1], color[2], color[3]);
7331 static void R_DrawEntityBBoxes(void)
7334 prvm_edict_t *edict;
7336 prvm_prog_t *prog = SVVM_prog;
7338 // this function draws bounding boxes of server entities
7342 for (i = 0;i < prog->num_edicts;i++)
7344 edict = PRVM_EDICT_NUM(i);
7345 if (edict->priv.server->free)
7347 // exclude the following for now, as they don't live in world coordinate space and can't be solid:
7348 if(PRVM_serveredictedict(edict, tag_entity) != 0)
7350 if(PRVM_serveredictedict(edict, viewmodelforclient) != 0)
7352 VectorLerp(edict->priv.server->areamins, 0.5f, edict->priv.server->areamaxs, center);
7353 R_MeshQueue_AddTransparent(MESHQUEUE_SORT_DISTANCE, center, R_DrawEntityBBoxes_Callback, (entity_render_t *)NULL, i, (rtlight_t *)NULL);
7357 static const int nomodelelement3i[24] =
7369 static const unsigned short nomodelelement3s[24] =
7381 static const float nomodelvertex3f[6*3] =
7391 static const float nomodelcolor4f[6*4] =
7393 0.0f, 0.0f, 0.5f, 1.0f,
7394 0.0f, 0.0f, 0.5f, 1.0f,
7395 0.0f, 0.5f, 0.0f, 1.0f,
7396 0.0f, 0.5f, 0.0f, 1.0f,
7397 0.5f, 0.0f, 0.0f, 1.0f,
7398 0.5f, 0.0f, 0.0f, 1.0f
7401 static void R_DrawNoModel_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
7407 RSurf_ActiveCustomEntity(&ent->matrix, &ent->inversematrix, ent->flags, ent->shadertime, ent->colormod[0], ent->colormod[1], ent->colormod[2], ent->alpha, 6, nomodelvertex3f, NULL, NULL, NULL, NULL, nomodelcolor4f, 8, nomodelelement3i, nomodelelement3s, false, false);
7409 // this is only called once per entity so numsurfaces is always 1, and
7410 // surfacelist is always {0}, so this code does not handle batches
7412 if (rsurface.ent_flags & RENDER_ADDITIVE)
7414 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
7415 GL_DepthMask(false);
7417 else if (rsurface.colormod[3] < 1)
7419 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
7420 GL_DepthMask(false);
7424 GL_BlendFunc(GL_ONE, GL_ZERO);
7427 GL_DepthRange(0, (rsurface.ent_flags & RENDER_VIEWMODEL) ? 0.0625 : 1);
7428 GL_PolygonOffset(rsurface.basepolygonfactor, rsurface.basepolygonoffset);
7429 GL_DepthTest(!(rsurface.ent_flags & RENDER_NODEPTHTEST));
7430 GL_CullFace((rsurface.ent_flags & RENDER_DOUBLESIDED) ? GL_NONE : r_refdef.view.cullface_back);
7431 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
7432 for (i = 0, c = color4f;i < 6;i++, c += 4)
7434 c[0] *= rsurface.colormod[0];
7435 c[1] *= rsurface.colormod[1];
7436 c[2] *= rsurface.colormod[2];
7437 c[3] *= rsurface.colormod[3];
7439 if (r_refdef.fogenabled)
7441 for (i = 0, c = color4f;i < 6;i++, c += 4)
7443 f1 = RSurf_FogVertex(nomodelvertex3f + 3*i);
7445 c[0] = (c[0] * f1 + r_refdef.fogcolor[0] * f2);
7446 c[1] = (c[1] * f1 + r_refdef.fogcolor[1] * f2);
7447 c[2] = (c[2] * f1 + r_refdef.fogcolor[2] * f2);
7450 // R_Mesh_ResetTextureState();
7451 R_SetupShader_Generic_NoTexture(false, false);
7452 R_Mesh_PrepareVertices_Generic_Arrays(6, nomodelvertex3f, color4f, NULL);
7453 R_Mesh_Draw(0, 6, 0, 8, nomodelelement3i, NULL, 0, nomodelelement3s, NULL, 0);
7456 void R_DrawNoModel(entity_render_t *ent)
7459 Matrix4x4_OriginFromMatrix(&ent->matrix, org);
7460 if ((ent->flags & RENDER_ADDITIVE) || (ent->alpha < 1))
7461 R_MeshQueue_AddTransparent((ent->flags & RENDER_NODEPTHTEST) ? MESHQUEUE_SORT_HUD : MESHQUEUE_SORT_DISTANCE, org, R_DrawNoModel_TransparentCallback, ent, 0, rsurface.rtlight);
7463 R_DrawNoModel_TransparentCallback(ent, rsurface.rtlight, 0, NULL);
7466 void R_CalcBeam_Vertex3f (float *vert, const vec3_t org1, const vec3_t org2, float width)
7468 vec3_t right1, right2, diff, normal;
7470 VectorSubtract (org2, org1, normal);
7472 // calculate 'right' vector for start
7473 VectorSubtract (r_refdef.view.origin, org1, diff);
7474 CrossProduct (normal, diff, right1);
7475 VectorNormalize (right1);
7477 // calculate 'right' vector for end
7478 VectorSubtract (r_refdef.view.origin, org2, diff);
7479 CrossProduct (normal, diff, right2);
7480 VectorNormalize (right2);
7482 vert[ 0] = org1[0] + width * right1[0];
7483 vert[ 1] = org1[1] + width * right1[1];
7484 vert[ 2] = org1[2] + width * right1[2];
7485 vert[ 3] = org1[0] - width * right1[0];
7486 vert[ 4] = org1[1] - width * right1[1];
7487 vert[ 5] = org1[2] - width * right1[2];
7488 vert[ 6] = org2[0] - width * right2[0];
7489 vert[ 7] = org2[1] - width * right2[1];
7490 vert[ 8] = org2[2] - width * right2[2];
7491 vert[ 9] = org2[0] + width * right2[0];
7492 vert[10] = org2[1] + width * right2[1];
7493 vert[11] = org2[2] + width * right2[2];
7496 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)
7498 vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
7499 vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
7500 vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
7501 vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
7502 vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
7503 vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
7504 vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
7505 vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
7506 vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
7507 vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
7508 vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
7509 vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
7512 static int R_Mesh_AddVertex(rmesh_t *mesh, float x, float y, float z)
7517 VectorSet(v, x, y, z);
7518 for (i = 0, vertex3f = mesh->vertex3f;i < mesh->numvertices;i++, vertex3f += 3)
7519 if (VectorDistance2(v, vertex3f) < mesh->epsilon2)
7521 if (i == mesh->numvertices)
7523 if (mesh->numvertices < mesh->maxvertices)
7525 VectorCopy(v, vertex3f);
7526 mesh->numvertices++;
7528 return mesh->numvertices;
7534 void R_Mesh_AddPolygon3f(rmesh_t *mesh, int numvertices, float *vertex3f)
7538 element[0] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
7539 element[1] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
7540 e = mesh->element3i + mesh->numtriangles * 3;
7541 for (i = 0;i < numvertices - 2;i++, vertex3f += 3)
7543 element[2] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);
7544 if (mesh->numtriangles < mesh->maxtriangles)
7549 mesh->numtriangles++;
7551 element[1] = element[2];
7555 static void R_Mesh_AddPolygon3d(rmesh_t *mesh, int numvertices, double *vertex3d)
7559 element[0] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
7560 element[1] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
7561 e = mesh->element3i + mesh->numtriangles * 3;
7562 for (i = 0;i < numvertices - 2;i++, vertex3d += 3)
7564 element[2] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);
7565 if (mesh->numtriangles < mesh->maxtriangles)
7570 mesh->numtriangles++;
7572 element[1] = element[2];
7576 #define R_MESH_PLANE_DIST_EPSILON (1.0 / 32.0)
7577 void R_Mesh_AddBrushMeshFromPlanes(rmesh_t *mesh, int numplanes, mplane_t *planes)
7579 int planenum, planenum2;
7582 mplane_t *plane, *plane2;
7584 double temppoints[2][256*3];
7585 // figure out how large a bounding box we need to properly compute this brush
7587 for (w = 0;w < numplanes;w++)
7588 maxdist = max(maxdist, fabs(planes[w].dist));
7589 // now make it large enough to enclose the entire brush, and round it off to a reasonable multiple of 1024
7590 maxdist = floor(maxdist * (4.0 / 1024.0) + 1) * 1024.0;
7591 for (planenum = 0, plane = planes;planenum < numplanes;planenum++, plane++)
7595 PolygonD_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, maxdist);
7596 for (planenum2 = 0, plane2 = planes;planenum2 < numplanes && tempnumpoints >= 3;planenum2++, plane2++)
7598 if (planenum2 == planenum)
7600 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);
7603 if (tempnumpoints < 3)
7605 // generate elements forming a triangle fan for this polygon
7606 R_Mesh_AddPolygon3d(mesh, tempnumpoints, temppoints[w]);
7610 static void R_Texture_AddLayer(texture_t *t, qboolean depthmask, int blendfunc1, int blendfunc2, texturelayertype_t type, rtexture_t *texture, const matrix4x4_t *matrix, float r, float g, float b, float a)
7612 texturelayer_t *layer;
7613 layer = t->currentlayers + t->currentnumlayers++;
7615 layer->depthmask = depthmask;
7616 layer->blendfunc1 = blendfunc1;
7617 layer->blendfunc2 = blendfunc2;
7618 layer->texture = texture;
7619 layer->texmatrix = *matrix;
7620 layer->color[0] = r;
7621 layer->color[1] = g;
7622 layer->color[2] = b;
7623 layer->color[3] = a;
7626 static qboolean R_TestQ3WaveFunc(q3wavefunc_t func, const float *parms)
7628 if(parms[0] == 0 && parms[1] == 0)
7630 if(func >> Q3WAVEFUNC_USER_SHIFT) // assumes rsurface to be set!
7631 if(rsurface.userwavefunc_param[bound(0, (func >> Q3WAVEFUNC_USER_SHIFT) - 1, Q3WAVEFUNC_USER_COUNT - 1)] == 0)
7636 static float R_EvaluateQ3WaveFunc(q3wavefunc_t func, const float *parms)
7639 index = parms[2] + rsurface.shadertime * parms[3];
7640 index -= floor(index);
7641 switch (func & ((1 << Q3WAVEFUNC_USER_SHIFT) - 1))
7644 case Q3WAVEFUNC_NONE:
7645 case Q3WAVEFUNC_NOISE:
7646 case Q3WAVEFUNC_COUNT:
7649 case Q3WAVEFUNC_SIN: f = sin(index * M_PI * 2);break;
7650 case Q3WAVEFUNC_SQUARE: f = index < 0.5 ? 1 : -1;break;
7651 case Q3WAVEFUNC_SAWTOOTH: f = index;break;
7652 case Q3WAVEFUNC_INVERSESAWTOOTH: f = 1 - index;break;
7653 case Q3WAVEFUNC_TRIANGLE:
7655 f = index - floor(index);
7668 f = parms[0] + parms[1] * f;
7669 if(func >> Q3WAVEFUNC_USER_SHIFT) // assumes rsurface to be set!
7670 f *= rsurface.userwavefunc_param[bound(0, (func >> Q3WAVEFUNC_USER_SHIFT) - 1, Q3WAVEFUNC_USER_COUNT - 1)];
7674 static void R_tcMod_ApplyToMatrix(matrix4x4_t *texmatrix, q3shaderinfo_layer_tcmod_t *tcmod, int currentmaterialflags)
7680 matrix4x4_t matrix, temp;
7681 switch(tcmod->tcmod)
7685 if (currentmaterialflags & MATERIALFLAG_WATERSCROLL)
7686 matrix = r_waterscrollmatrix;
7688 matrix = identitymatrix;
7690 case Q3TCMOD_ENTITYTRANSLATE:
7691 // this is used in Q3 to allow the gamecode to control texcoord
7692 // scrolling on the entity, which is not supported in darkplaces yet.
7693 Matrix4x4_CreateTranslate(&matrix, 0, 0, 0);
7695 case Q3TCMOD_ROTATE:
7696 f = tcmod->parms[0] * rsurface.shadertime;
7697 Matrix4x4_CreateTranslate(&matrix, 0.5, 0.5, 0);
7698 Matrix4x4_ConcatRotate(&matrix, (f / 360 - floor(f / 360)) * 360, 0, 0, 1);
7699 Matrix4x4_ConcatTranslate(&matrix, -0.5, -0.5, 0);
7702 Matrix4x4_CreateScale3(&matrix, tcmod->parms[0], tcmod->parms[1], 1);
7704 case Q3TCMOD_SCROLL:
7705 // extra care is needed because of precision breakdown with large values of time
7706 offsetd[0] = tcmod->parms[0] * rsurface.shadertime;
7707 offsetd[1] = tcmod->parms[1] * rsurface.shadertime;
7708 Matrix4x4_CreateTranslate(&matrix, offsetd[0] - floor(offsetd[0]), offsetd[1] - floor(offsetd[1]), 0);
7710 case Q3TCMOD_PAGE: // poor man's animmap (to store animations into a single file, useful for HTTP downloaded textures)
7711 w = (int) tcmod->parms[0];
7712 h = (int) tcmod->parms[1];
7713 f = rsurface.shadertime / (tcmod->parms[2] * w * h);
7715 idx = (int) floor(f * w * h);
7716 Matrix4x4_CreateTranslate(&matrix, (idx % w) / tcmod->parms[0], (idx / w) / tcmod->parms[1], 0);
7718 case Q3TCMOD_STRETCH:
7719 f = 1.0f / R_EvaluateQ3WaveFunc(tcmod->wavefunc, tcmod->waveparms);
7720 Matrix4x4_CreateFromQuakeEntity(&matrix, 0.5f * (1 - f), 0.5 * (1 - f), 0, 0, 0, 0, f);
7722 case Q3TCMOD_TRANSFORM:
7723 VectorSet(tcmat + 0, tcmod->parms[0], tcmod->parms[1], 0);
7724 VectorSet(tcmat + 3, tcmod->parms[2], tcmod->parms[3], 0);
7725 VectorSet(tcmat + 6, 0 , 0 , 1);
7726 VectorSet(tcmat + 9, tcmod->parms[4], tcmod->parms[5], 0);
7727 Matrix4x4_FromArray12FloatGL(&matrix, tcmat);
7729 case Q3TCMOD_TURBULENT:
7730 // this is handled in the RSurf_PrepareVertices function
7731 matrix = identitymatrix;
7735 Matrix4x4_Concat(texmatrix, &matrix, &temp);
7738 static void R_LoadQWSkin(r_qwskincache_t *cache, const char *skinname)
7740 int textureflags = (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_PICMIP;
7741 char name[MAX_QPATH];
7742 skinframe_t *skinframe;
7743 unsigned char pixels[296*194];
7744 strlcpy(cache->name, skinname, sizeof(cache->name));
7745 dpsnprintf(name, sizeof(name), "skins/%s.pcx", cache->name);
7746 if (developer_loading.integer)
7747 Con_Printf("loading %s\n", name);
7748 skinframe = R_SkinFrame_Find(name, textureflags, 0, 0, 0, false);
7749 if (!skinframe || !skinframe->base)
7752 fs_offset_t filesize;
7754 f = FS_LoadFile(name, tempmempool, true, &filesize);
7757 if (LoadPCX_QWSkin(f, (int)filesize, pixels, 296, 194))
7758 skinframe = R_SkinFrame_LoadInternalQuake(name, textureflags, true, r_fullbrights.integer, pixels, image_width, image_height);
7762 cache->skinframe = skinframe;
7765 texture_t *R_GetCurrentTexture(texture_t *t)
7768 const entity_render_t *ent = rsurface.entity;
7769 dp_model_t *model = ent->model;
7770 q3shaderinfo_layer_tcmod_t *tcmod;
7772 if (t->update_lastrenderframe == r_textureframe && t->update_lastrenderentity == (void *)ent && !rsurface.forcecurrenttextureupdate)
7773 return t->currentframe;
7774 t->update_lastrenderframe = r_textureframe;
7775 t->update_lastrenderentity = (void *)ent;
7777 if(ent && ent->entitynumber >= MAX_EDICTS && ent->entitynumber < 2 * MAX_EDICTS)
7778 t->camera_entity = ent->entitynumber;
7780 t->camera_entity = 0;
7782 // switch to an alternate material if this is a q1bsp animated material
7784 texture_t *texture = t;
7785 int s = rsurface.ent_skinnum;
7786 if ((unsigned int)s >= (unsigned int)model->numskins)
7788 if (model->skinscenes)
7790 if (model->skinscenes[s].framecount > 1)
7791 s = model->skinscenes[s].firstframe + (unsigned int) (rsurface.shadertime * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
7793 s = model->skinscenes[s].firstframe;
7796 t = t + s * model->num_surfaces;
7799 // use an alternate animation if the entity's frame is not 0,
7800 // and only if the texture has an alternate animation
7801 if (rsurface.ent_alttextures && t->anim_total[1])
7802 t = t->anim_frames[1][(t->anim_total[1] >= 2) ? ((int)(rsurface.shadertime * 5.0f) % t->anim_total[1]) : 0];
7804 t = t->anim_frames[0][(t->anim_total[0] >= 2) ? ((int)(rsurface.shadertime * 5.0f) % t->anim_total[0]) : 0];
7806 texture->currentframe = t;
7809 // update currentskinframe to be a qw skin or animation frame
7810 if (rsurface.ent_qwskin >= 0)
7812 i = rsurface.ent_qwskin;
7813 if (!r_qwskincache || r_qwskincache_size != cl.maxclients)
7815 r_qwskincache_size = cl.maxclients;
7817 Mem_Free(r_qwskincache);
7818 r_qwskincache = (r_qwskincache_t *)Mem_Alloc(r_main_mempool, sizeof(*r_qwskincache) * r_qwskincache_size);
7820 if (strcmp(r_qwskincache[i].name, cl.scores[i].qw_skin))
7821 R_LoadQWSkin(&r_qwskincache[i], cl.scores[i].qw_skin);
7822 t->currentskinframe = r_qwskincache[i].skinframe;
7823 if (t->currentskinframe == NULL)
7824 t->currentskinframe = t->skinframes[LoopingFrameNumberFromDouble(rsurface.shadertime * t->skinframerate, t->numskinframes)];
7826 else if (t->numskinframes >= 2)
7827 t->currentskinframe = t->skinframes[LoopingFrameNumberFromDouble(rsurface.shadertime * t->skinframerate, t->numskinframes)];
7828 if (t->backgroundnumskinframes >= 2)
7829 t->backgroundcurrentskinframe = t->backgroundskinframes[LoopingFrameNumberFromDouble(rsurface.shadertime * t->backgroundskinframerate, t->backgroundnumskinframes)];
7831 t->currentmaterialflags = t->basematerialflags;
7832 t->currentalpha = rsurface.colormod[3];
7833 if (t->basematerialflags & MATERIALFLAG_WATERALPHA && (model->brush.supportwateralpha || r_novis.integer || r_trippy.integer))
7834 t->currentalpha *= r_wateralpha.value;
7835 if(t->basematerialflags & MATERIALFLAG_WATERSHADER && r_fb.water.enabled && !r_refdef.view.isoverlay)
7836 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW; // we apply wateralpha later
7837 if(!r_fb.water.enabled || r_refdef.view.isoverlay)
7838 t->currentmaterialflags &= ~(MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA);
7839 if (!(rsurface.ent_flags & RENDER_LIGHT))
7840 t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
7841 else if (FAKELIGHT_ENABLED)
7843 // no modellight if using fakelight for the map
7845 else if ((rsurface.modeltexcoordlightmap2f == NULL || (rsurface.ent_flags & (RENDER_DYNAMICMODELLIGHT | RENDER_CUSTOMIZEDMODELLIGHT))) && !(t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
7847 // pick a model lighting mode
7848 if (VectorLength2(rsurface.modellight_diffuse) >= (1.0f / 256.0f))
7849 t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL;
7851 t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT;
7853 if (rsurface.ent_flags & RENDER_ADDITIVE)
7854 t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
7855 else if (t->currentalpha < 1)
7856 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
7857 // LordHavoc: prevent bugs where code checks add or alpha at higher priority than customblend by clearing these flags
7858 if (t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
7859 t->currentmaterialflags &= ~(MATERIALFLAG_ADD | MATERIALFLAG_ALPHA);
7860 if (rsurface.ent_flags & RENDER_DOUBLESIDED)
7861 t->currentmaterialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_NOCULLFACE;
7862 if (rsurface.ent_flags & (RENDER_NODEPTHTEST | RENDER_VIEWMODEL))
7863 t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
7864 if (t->backgroundnumskinframes)
7865 t->currentmaterialflags |= MATERIALFLAG_VERTEXTEXTUREBLEND;
7866 if (t->currentmaterialflags & MATERIALFLAG_BLENDED)
7868 if (t->currentmaterialflags & (MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER | MATERIALFLAG_CAMERA))
7869 t->currentmaterialflags &= ~MATERIALFLAG_BLENDED;
7872 t->currentmaterialflags &= ~(MATERIALFLAG_REFRACTION | MATERIALFLAG_WATERSHADER | MATERIALFLAG_CAMERA);
7873 if (vid.allowalphatocoverage && r_transparent_alphatocoverage.integer >= 2 && ((t->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHA | MATERIALFLAG_ADD | MATERIALFLAG_CUSTOMBLEND)) == (MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHA)))
7875 // promote alphablend to alphatocoverage (a type of alphatest) if antialiasing is on
7876 t->currentmaterialflags = (t->currentmaterialflags & ~(MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHA)) | MATERIALFLAG_ALPHATEST;
7878 if ((t->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST)) == MATERIALFLAG_BLENDED && r_transparentdepthmasking.integer && !(t->basematerialflags & MATERIALFLAG_BLENDED))
7879 t->currentmaterialflags |= MATERIALFLAG_TRANSDEPTH;
7881 // there is no tcmod
7882 if (t->currentmaterialflags & MATERIALFLAG_WATERSCROLL)
7884 t->currenttexmatrix = r_waterscrollmatrix;
7885 t->currentbackgroundtexmatrix = r_waterscrollmatrix;
7887 else if (!(t->currentmaterialflags & MATERIALFLAG_CUSTOMSURFACE))
7889 Matrix4x4_CreateIdentity(&t->currenttexmatrix);
7890 Matrix4x4_CreateIdentity(&t->currentbackgroundtexmatrix);
7893 for (i = 0, tcmod = t->tcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
7894 R_tcMod_ApplyToMatrix(&t->currenttexmatrix, tcmod, t->currentmaterialflags);
7895 for (i = 0, tcmod = t->backgroundtcmods;i < Q3MAXTCMODS && tcmod->tcmod;i++, tcmod++)
7896 R_tcMod_ApplyToMatrix(&t->currentbackgroundtexmatrix, tcmod, t->currentmaterialflags);
7898 t->colormapping = VectorLength2(rsurface.colormap_pantscolor) + VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f);
7899 if (t->currentskinframe->qpixels)
7900 R_SkinFrame_GenerateTexturesFromQPixels(t->currentskinframe, t->colormapping);
7901 t->basetexture = (!t->colormapping && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
7902 if (!t->basetexture)
7903 t->basetexture = r_texture_notexture;
7904 t->pantstexture = t->colormapping ? t->currentskinframe->pants : NULL;
7905 t->shirttexture = t->colormapping ? t->currentskinframe->shirt : NULL;
7906 t->nmaptexture = t->currentskinframe->nmap;
7907 if (!t->nmaptexture)
7908 t->nmaptexture = r_texture_blanknormalmap;
7909 t->glosstexture = r_texture_black;
7910 t->glowtexture = t->currentskinframe->glow;
7911 t->fogtexture = t->currentskinframe->fog;
7912 t->reflectmasktexture = t->currentskinframe->reflect;
7913 if (t->backgroundnumskinframes)
7915 t->backgroundbasetexture = (!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base;
7916 t->backgroundnmaptexture = t->backgroundcurrentskinframe->nmap;
7917 t->backgroundglosstexture = r_texture_black;
7918 t->backgroundglowtexture = t->backgroundcurrentskinframe->glow;
7919 if (!t->backgroundnmaptexture)
7920 t->backgroundnmaptexture = r_texture_blanknormalmap;
7921 // make sure that if glow is going to be used, both textures are not NULL
7922 if (!t->backgroundglowtexture && t->glowtexture)
7923 t->backgroundglowtexture = r_texture_black;
7924 if (!t->glowtexture && t->backgroundglowtexture)
7925 t->glowtexture = r_texture_black;
7929 t->backgroundbasetexture = r_texture_white;
7930 t->backgroundnmaptexture = r_texture_blanknormalmap;
7931 t->backgroundglosstexture = r_texture_black;
7932 t->backgroundglowtexture = NULL;
7934 t->specularpower = r_shadow_glossexponent.value;
7935 // TODO: store reference values for these in the texture?
7936 t->specularscale = 0;
7937 if (r_shadow_gloss.integer > 0)
7939 if (t->currentskinframe->gloss || (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss))
7941 if (r_shadow_glossintensity.value > 0)
7943 t->glosstexture = t->currentskinframe->gloss ? t->currentskinframe->gloss : r_texture_white;
7944 t->backgroundglosstexture = (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss) ? t->backgroundcurrentskinframe->gloss : r_texture_white;
7945 t->specularscale = r_shadow_glossintensity.value;
7948 else if (r_shadow_gloss.integer >= 2 && r_shadow_gloss2intensity.value > 0)
7950 t->glosstexture = r_texture_white;
7951 t->backgroundglosstexture = r_texture_white;
7952 t->specularscale = r_shadow_gloss2intensity.value;
7953 t->specularpower = r_shadow_gloss2exponent.value;
7956 t->specularscale *= t->specularscalemod;
7957 t->specularpower *= t->specularpowermod;
7958 t->rtlightambient = 0;
7960 // lightmaps mode looks bad with dlights using actual texturing, so turn
7961 // off the colormap and glossmap, but leave the normalmap on as it still
7962 // accurately represents the shading involved
7963 if (gl_lightmaps.integer)
7965 t->basetexture = r_texture_grey128;
7966 t->pantstexture = r_texture_black;
7967 t->shirttexture = r_texture_black;
7968 t->nmaptexture = r_texture_blanknormalmap;
7969 t->glosstexture = r_texture_black;
7970 t->glowtexture = NULL;
7971 t->fogtexture = NULL;
7972 t->reflectmasktexture = NULL;
7973 t->backgroundbasetexture = NULL;
7974 t->backgroundnmaptexture = r_texture_blanknormalmap;
7975 t->backgroundglosstexture = r_texture_black;
7976 t->backgroundglowtexture = NULL;
7977 t->specularscale = 0;
7978 t->currentmaterialflags = MATERIALFLAG_WALL | (t->currentmaterialflags & (MATERIALFLAG_NOCULLFACE | MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SHORTDEPTHRANGE));
7981 Vector4Set(t->lightmapcolor, rsurface.colormod[0], rsurface.colormod[1], rsurface.colormod[2], t->currentalpha);
7982 VectorClear(t->dlightcolor);
7983 t->currentnumlayers = 0;
7984 if (t->currentmaterialflags & MATERIALFLAG_WALL)
7986 int blendfunc1, blendfunc2;
7988 if (t->currentmaterialflags & MATERIALFLAG_ADD)
7990 blendfunc1 = GL_SRC_ALPHA;
7991 blendfunc2 = GL_ONE;
7993 else if (t->currentmaterialflags & MATERIALFLAG_ALPHA)
7995 blendfunc1 = GL_SRC_ALPHA;
7996 blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
7998 else if (t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
8000 blendfunc1 = t->customblendfunc[0];
8001 blendfunc2 = t->customblendfunc[1];
8005 blendfunc1 = GL_ONE;
8006 blendfunc2 = GL_ZERO;
8008 // don't colormod evilblend textures
8009 if(!(R_BlendFuncFlags(blendfunc1, blendfunc2) & BLENDFUNC_ALLOWS_COLORMOD))
8010 VectorSet(t->lightmapcolor, 1, 1, 1);
8011 depthmask = !(t->currentmaterialflags & MATERIALFLAG_BLENDED);
8012 if (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
8014 // fullbright is not affected by r_refdef.lightmapintensity
8015 R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_TEXTURE, t->basetexture, &t->currenttexmatrix, t->lightmapcolor[0], t->lightmapcolor[1], t->lightmapcolor[2], t->lightmapcolor[3]);
8016 if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
8017 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->pantstexture, &t->currenttexmatrix, rsurface.colormap_pantscolor[0] * t->lightmapcolor[0], rsurface.colormap_pantscolor[1] * t->lightmapcolor[1], rsurface.colormap_pantscolor[2] * t->lightmapcolor[2], t->lightmapcolor[3]);
8018 if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
8019 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->shirttexture, &t->currenttexmatrix, rsurface.colormap_shirtcolor[0] * t->lightmapcolor[0], rsurface.colormap_shirtcolor[1] * t->lightmapcolor[1], rsurface.colormap_shirtcolor[2] * t->lightmapcolor[2], t->lightmapcolor[3]);
8023 vec3_t ambientcolor;
8025 // set the color tint used for lights affecting this surface
8026 VectorSet(t->dlightcolor, t->lightmapcolor[0] * t->lightmapcolor[3], t->lightmapcolor[1] * t->lightmapcolor[3], t->lightmapcolor[2] * t->lightmapcolor[3]);
8028 // q3bsp has no lightmap updates, so the lightstylevalue that
8029 // would normally be baked into the lightmap must be
8030 // applied to the color
8031 // FIXME: r_glsl 1 rendering doesn't support overbright lightstyles with this (the default light style is not overbright)
8032 if (model->type == mod_brushq3)
8033 colorscale *= r_refdef.scene.rtlightstylevalue[0];
8034 colorscale *= r_refdef.lightmapintensity;
8035 VectorScale(t->lightmapcolor, r_refdef.scene.ambient, ambientcolor);
8036 VectorScale(t->lightmapcolor, colorscale, t->lightmapcolor);
8037 // basic lit geometry
8038 R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_LITTEXTURE, t->basetexture, &t->currenttexmatrix, t->lightmapcolor[0], t->lightmapcolor[1], t->lightmapcolor[2], t->lightmapcolor[3]);
8039 // add pants/shirt if needed
8040 if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
8041 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_LITTEXTURE, t->pantstexture, &t->currenttexmatrix, rsurface.colormap_pantscolor[0] * t->lightmapcolor[0], rsurface.colormap_pantscolor[1] * t->lightmapcolor[1], rsurface.colormap_pantscolor[2] * t->lightmapcolor[2], t->lightmapcolor[3]);
8042 if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
8043 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_LITTEXTURE, t->shirttexture, &t->currenttexmatrix, rsurface.colormap_shirtcolor[0] * t->lightmapcolor[0], rsurface.colormap_shirtcolor[1] * t->lightmapcolor[1], rsurface.colormap_shirtcolor[2] * t->lightmapcolor[2], t->lightmapcolor[3]);
8044 // now add ambient passes if needed
8045 if (VectorLength2(ambientcolor) >= (1.0f/1048576.0f))
8047 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->basetexture, &t->currenttexmatrix, ambientcolor[0], ambientcolor[1], ambientcolor[2], t->lightmapcolor[3]);
8048 if (VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f) && t->pantstexture)
8049 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->pantstexture, &t->currenttexmatrix, rsurface.colormap_pantscolor[0] * ambientcolor[0], rsurface.colormap_pantscolor[1] * ambientcolor[1], rsurface.colormap_pantscolor[2] * ambientcolor[2], t->lightmapcolor[3]);
8050 if (VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->shirttexture)
8051 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->shirttexture, &t->currenttexmatrix, rsurface.colormap_shirtcolor[0] * ambientcolor[0], rsurface.colormap_shirtcolor[1] * ambientcolor[1], rsurface.colormap_shirtcolor[2] * ambientcolor[2], t->lightmapcolor[3]);
8054 if (t->glowtexture != NULL && !gl_lightmaps.integer)
8055 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->glowtexture, &t->currenttexmatrix, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2], t->lightmapcolor[3]);
8056 if (r_refdef.fogenabled && !(t->currentmaterialflags & MATERIALFLAG_ADD))
8058 // if this is opaque use alpha blend which will darken the earlier
8061 // if this is an alpha blended material, all the earlier passes
8062 // were darkened by fog already, so we only need to add the fog
8063 // color ontop through the fog mask texture
8065 // if this is an additive blended material, all the earlier passes
8066 // were darkened by fog already, and we should not add fog color
8067 // (because the background was not darkened, there is no fog color
8068 // that was lost behind it).
8069 R_Texture_AddLayer(t, false, GL_SRC_ALPHA, (t->currentmaterialflags & MATERIALFLAG_BLENDED) ? GL_ONE : GL_ONE_MINUS_SRC_ALPHA, TEXTURELAYERTYPE_FOG, t->fogtexture, &t->currenttexmatrix, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2], t->lightmapcolor[3]);
8073 return t->currentframe;
8076 rsurfacestate_t rsurface;
8078 void RSurf_ActiveWorldEntity(void)
8080 dp_model_t *model = r_refdef.scene.worldmodel;
8081 //if (rsurface.entity == r_refdef.scene.worldentity)
8083 rsurface.entity = r_refdef.scene.worldentity;
8084 rsurface.skeleton = NULL;
8085 memset(rsurface.userwavefunc_param, 0, sizeof(rsurface.userwavefunc_param));
8086 rsurface.ent_skinnum = 0;
8087 rsurface.ent_qwskin = -1;
8088 rsurface.ent_flags = r_refdef.scene.worldentity->flags;
8089 rsurface.shadertime = r_refdef.scene.time;
8090 rsurface.matrix = identitymatrix;
8091 rsurface.inversematrix = identitymatrix;
8092 rsurface.matrixscale = 1;
8093 rsurface.inversematrixscale = 1;
8094 R_EntityMatrix(&identitymatrix);
8095 VectorCopy(r_refdef.view.origin, rsurface.localvieworigin);
8096 Vector4Copy(r_refdef.fogplane, rsurface.fogplane);
8097 rsurface.fograngerecip = r_refdef.fograngerecip;
8098 rsurface.fogheightfade = r_refdef.fogheightfade;
8099 rsurface.fogplaneviewdist = r_refdef.fogplaneviewdist;
8100 rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
8101 VectorSet(rsurface.modellight_ambient, 0, 0, 0);
8102 VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
8103 VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
8104 VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
8105 VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
8106 VectorSet(rsurface.colormod, r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale);
8107 rsurface.colormod[3] = 1;
8108 VectorSet(rsurface.glowmod, r_refdef.view.colorscale * r_hdr_glowintensity.value, r_refdef.view.colorscale * r_hdr_glowintensity.value, r_refdef.view.colorscale * r_hdr_glowintensity.value);
8109 memset(rsurface.frameblend, 0, sizeof(rsurface.frameblend));
8110 rsurface.frameblend[0].lerp = 1;
8111 rsurface.ent_alttextures = false;
8112 rsurface.basepolygonfactor = r_refdef.polygonfactor;
8113 rsurface.basepolygonoffset = r_refdef.polygonoffset;
8114 rsurface.modelvertex3f = model->surfmesh.data_vertex3f;
8115 rsurface.modelvertex3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
8116 rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
8117 rsurface.modelsvector3f = model->surfmesh.data_svector3f;
8118 rsurface.modelsvector3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
8119 rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
8120 rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
8121 rsurface.modeltvector3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
8122 rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
8123 rsurface.modelnormal3f = model->surfmesh.data_normal3f;
8124 rsurface.modelnormal3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
8125 rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
8126 rsurface.modellightmapcolor4f = model->surfmesh.data_lightmapcolor4f;
8127 rsurface.modellightmapcolor4f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
8128 rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
8129 rsurface.modeltexcoordtexture2f = model->surfmesh.data_texcoordtexture2f;
8130 rsurface.modeltexcoordtexture2f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
8131 rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
8132 rsurface.modeltexcoordlightmap2f = model->surfmesh.data_texcoordlightmap2f;
8133 rsurface.modeltexcoordlightmap2f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
8134 rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
8135 rsurface.modelelement3i = model->surfmesh.data_element3i;
8136 rsurface.modelelement3i_indexbuffer = model->surfmesh.data_element3i_indexbuffer;
8137 rsurface.modelelement3i_bufferoffset = model->surfmesh.data_element3i_bufferoffset;
8138 rsurface.modelelement3s = model->surfmesh.data_element3s;
8139 rsurface.modelelement3s_indexbuffer = model->surfmesh.data_element3s_indexbuffer;
8140 rsurface.modelelement3s_bufferoffset = model->surfmesh.data_element3s_bufferoffset;
8141 rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
8142 rsurface.modelnumvertices = model->surfmesh.num_vertices;
8143 rsurface.modelnumtriangles = model->surfmesh.num_triangles;
8144 rsurface.modelsurfaces = model->data_surfaces;
8145 rsurface.modelvertexmesh = model->surfmesh.vertexmesh;
8146 rsurface.modelvertexmeshbuffer = model->surfmesh.vertexmeshbuffer;
8147 rsurface.modelvertex3fbuffer = model->surfmesh.vertex3fbuffer;
8148 rsurface.modelgeneratedvertex = false;
8149 rsurface.batchgeneratedvertex = false;
8150 rsurface.batchfirstvertex = 0;
8151 rsurface.batchnumvertices = 0;
8152 rsurface.batchfirsttriangle = 0;
8153 rsurface.batchnumtriangles = 0;
8154 rsurface.batchvertex3f = NULL;
8155 rsurface.batchvertex3f_vertexbuffer = NULL;
8156 rsurface.batchvertex3f_bufferoffset = 0;
8157 rsurface.batchsvector3f = NULL;
8158 rsurface.batchsvector3f_vertexbuffer = NULL;
8159 rsurface.batchsvector3f_bufferoffset = 0;
8160 rsurface.batchtvector3f = NULL;
8161 rsurface.batchtvector3f_vertexbuffer = NULL;
8162 rsurface.batchtvector3f_bufferoffset = 0;
8163 rsurface.batchnormal3f = NULL;
8164 rsurface.batchnormal3f_vertexbuffer = NULL;
8165 rsurface.batchnormal3f_bufferoffset = 0;
8166 rsurface.batchlightmapcolor4f = NULL;
8167 rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
8168 rsurface.batchlightmapcolor4f_bufferoffset = 0;
8169 rsurface.batchtexcoordtexture2f = NULL;
8170 rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
8171 rsurface.batchtexcoordtexture2f_bufferoffset = 0;
8172 rsurface.batchtexcoordlightmap2f = NULL;
8173 rsurface.batchtexcoordlightmap2f_vertexbuffer = NULL;
8174 rsurface.batchtexcoordlightmap2f_bufferoffset = 0;
8175 rsurface.batchvertexmesh = NULL;
8176 rsurface.batchvertexmeshbuffer = NULL;
8177 rsurface.batchvertex3fbuffer = NULL;
8178 rsurface.batchelement3i = NULL;
8179 rsurface.batchelement3i_indexbuffer = NULL;
8180 rsurface.batchelement3i_bufferoffset = 0;
8181 rsurface.batchelement3s = NULL;
8182 rsurface.batchelement3s_indexbuffer = NULL;
8183 rsurface.batchelement3s_bufferoffset = 0;
8184 rsurface.passcolor4f = NULL;
8185 rsurface.passcolor4f_vertexbuffer = NULL;
8186 rsurface.passcolor4f_bufferoffset = 0;
8187 rsurface.forcecurrenttextureupdate = false;
8190 void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents, qboolean prepass)
8192 dp_model_t *model = ent->model;
8193 //if (rsurface.entity == ent && (!model->surfmesh.isanimated || (!wantnormals && !wanttangents)))
8195 rsurface.entity = (entity_render_t *)ent;
8196 rsurface.skeleton = ent->skeleton;
8197 memcpy(rsurface.userwavefunc_param, ent->userwavefunc_param, sizeof(rsurface.userwavefunc_param));
8198 rsurface.ent_skinnum = ent->skinnum;
8199 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;
8200 rsurface.ent_flags = ent->flags;
8201 rsurface.shadertime = r_refdef.scene.time - ent->shadertime;
8202 rsurface.matrix = ent->matrix;
8203 rsurface.inversematrix = ent->inversematrix;
8204 rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix);
8205 rsurface.inversematrixscale = 1.0f / rsurface.matrixscale;
8206 R_EntityMatrix(&rsurface.matrix);
8207 Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.localvieworigin);
8208 Matrix4x4_TransformStandardPlane(&rsurface.inversematrix, r_refdef.fogplane[0], r_refdef.fogplane[1], r_refdef.fogplane[2], r_refdef.fogplane[3], rsurface.fogplane);
8209 rsurface.fogplaneviewdist *= rsurface.inversematrixscale;
8210 rsurface.fograngerecip = r_refdef.fograngerecip * rsurface.matrixscale;
8211 rsurface.fogheightfade = r_refdef.fogheightfade * rsurface.matrixscale;
8212 rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
8213 VectorCopy(ent->modellight_ambient, rsurface.modellight_ambient);
8214 VectorCopy(ent->modellight_diffuse, rsurface.modellight_diffuse);
8215 VectorCopy(ent->modellight_lightdir, rsurface.modellight_lightdir);
8216 VectorCopy(ent->colormap_pantscolor, rsurface.colormap_pantscolor);
8217 VectorCopy(ent->colormap_shirtcolor, rsurface.colormap_shirtcolor);
8218 VectorScale(ent->colormod, r_refdef.view.colorscale, rsurface.colormod);
8219 rsurface.colormod[3] = ent->alpha;
8220 VectorScale(ent->glowmod, r_refdef.view.colorscale * r_hdr_glowintensity.value, rsurface.glowmod);
8221 memcpy(rsurface.frameblend, ent->frameblend, sizeof(ent->frameblend));
8222 rsurface.ent_alttextures = ent->framegroupblend[0].frame != 0;
8223 rsurface.basepolygonfactor = r_refdef.polygonfactor;
8224 rsurface.basepolygonoffset = r_refdef.polygonoffset;
8225 if (ent->model->brush.submodel && !prepass)
8227 rsurface.basepolygonfactor += r_polygonoffset_submodel_factor.value;
8228 rsurface.basepolygonoffset += r_polygonoffset_submodel_offset.value;
8230 if (model->surfmesh.isanimated && model->AnimateVertices)
8232 if (ent->animcache_vertex3f)
8234 rsurface.modelvertex3f = ent->animcache_vertex3f;
8235 rsurface.modelsvector3f = wanttangents ? ent->animcache_svector3f : NULL;
8236 rsurface.modeltvector3f = wanttangents ? ent->animcache_tvector3f : NULL;
8237 rsurface.modelnormal3f = wantnormals ? ent->animcache_normal3f : NULL;
8238 rsurface.modelvertexmesh = ent->animcache_vertexmesh;
8239 rsurface.modelvertexmeshbuffer = ent->animcache_vertexmeshbuffer;
8240 rsurface.modelvertex3fbuffer = ent->animcache_vertex3fbuffer;
8242 else if (wanttangents)
8244 rsurface.modelvertex3f = (float *)R_FrameData_Alloc(model->surfmesh.num_vertices * sizeof(float[3]));
8245 rsurface.modelsvector3f = (float *)R_FrameData_Alloc(model->surfmesh.num_vertices * sizeof(float[3]));
8246 rsurface.modeltvector3f = (float *)R_FrameData_Alloc(model->surfmesh.num_vertices * sizeof(float[3]));
8247 rsurface.modelnormal3f = (float *)R_FrameData_Alloc(model->surfmesh.num_vertices * sizeof(float[3]));
8248 model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.modelvertex3f, rsurface.modelnormal3f, rsurface.modelsvector3f, rsurface.modeltvector3f);
8249 rsurface.modelvertexmesh = NULL;
8250 rsurface.modelvertexmeshbuffer = NULL;
8251 rsurface.modelvertex3fbuffer = NULL;
8253 else if (wantnormals)
8255 rsurface.modelvertex3f = (float *)R_FrameData_Alloc(model->surfmesh.num_vertices * sizeof(float[3]));
8256 rsurface.modelsvector3f = NULL;
8257 rsurface.modeltvector3f = NULL;
8258 rsurface.modelnormal3f = (float *)R_FrameData_Alloc(model->surfmesh.num_vertices * sizeof(float[3]));
8259 model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.modelvertex3f, rsurface.modelnormal3f, NULL, NULL);
8260 rsurface.modelvertexmesh = NULL;
8261 rsurface.modelvertexmeshbuffer = NULL;
8262 rsurface.modelvertex3fbuffer = NULL;
8266 rsurface.modelvertex3f = (float *)R_FrameData_Alloc(model->surfmesh.num_vertices * sizeof(float[3]));
8267 rsurface.modelsvector3f = NULL;
8268 rsurface.modeltvector3f = NULL;
8269 rsurface.modelnormal3f = NULL;
8270 model->AnimateVertices(model, rsurface.frameblend, rsurface.skeleton, rsurface.modelvertex3f, NULL, NULL, NULL);
8271 rsurface.modelvertexmesh = NULL;
8272 rsurface.modelvertexmeshbuffer = NULL;
8273 rsurface.modelvertex3fbuffer = NULL;
8275 rsurface.modelvertex3f_vertexbuffer = 0;
8276 rsurface.modelvertex3f_bufferoffset = 0;
8277 rsurface.modelsvector3f_vertexbuffer = 0;
8278 rsurface.modelsvector3f_bufferoffset = 0;
8279 rsurface.modeltvector3f_vertexbuffer = 0;
8280 rsurface.modeltvector3f_bufferoffset = 0;
8281 rsurface.modelnormal3f_vertexbuffer = 0;
8282 rsurface.modelnormal3f_bufferoffset = 0;
8283 rsurface.modelgeneratedvertex = true;
8287 rsurface.modelvertex3f = model->surfmesh.data_vertex3f;
8288 rsurface.modelvertex3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
8289 rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
8290 rsurface.modelsvector3f = model->surfmesh.data_svector3f;
8291 rsurface.modelsvector3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
8292 rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
8293 rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
8294 rsurface.modeltvector3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
8295 rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
8296 rsurface.modelnormal3f = model->surfmesh.data_normal3f;
8297 rsurface.modelnormal3f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
8298 rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
8299 rsurface.modelvertexmesh = model->surfmesh.vertexmesh;
8300 rsurface.modelvertexmeshbuffer = model->surfmesh.vertexmeshbuffer;
8301 rsurface.modelvertex3fbuffer = model->surfmesh.vertex3fbuffer;
8302 rsurface.modelgeneratedvertex = false;
8304 rsurface.modellightmapcolor4f = model->surfmesh.data_lightmapcolor4f;
8305 rsurface.modellightmapcolor4f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
8306 rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
8307 rsurface.modeltexcoordtexture2f = model->surfmesh.data_texcoordtexture2f;
8308 rsurface.modeltexcoordtexture2f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
8309 rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
8310 rsurface.modeltexcoordlightmap2f = model->surfmesh.data_texcoordlightmap2f;
8311 rsurface.modeltexcoordlightmap2f_vertexbuffer = model->surfmesh.vbo_vertexbuffer;
8312 rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
8313 rsurface.modelelement3i = model->surfmesh.data_element3i;
8314 rsurface.modelelement3i_indexbuffer = model->surfmesh.data_element3i_indexbuffer;
8315 rsurface.modelelement3i_bufferoffset = model->surfmesh.data_element3i_bufferoffset;
8316 rsurface.modelelement3s = model->surfmesh.data_element3s;
8317 rsurface.modelelement3s_indexbuffer = model->surfmesh.data_element3s_indexbuffer;
8318 rsurface.modelelement3s_bufferoffset = model->surfmesh.data_element3s_bufferoffset;
8319 rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
8320 rsurface.modelnumvertices = model->surfmesh.num_vertices;
8321 rsurface.modelnumtriangles = model->surfmesh.num_triangles;
8322 rsurface.modelsurfaces = model->data_surfaces;
8323 rsurface.batchgeneratedvertex = false;
8324 rsurface.batchfirstvertex = 0;
8325 rsurface.batchnumvertices = 0;
8326 rsurface.batchfirsttriangle = 0;
8327 rsurface.batchnumtriangles = 0;
8328 rsurface.batchvertex3f = NULL;
8329 rsurface.batchvertex3f_vertexbuffer = NULL;
8330 rsurface.batchvertex3f_bufferoffset = 0;
8331 rsurface.batchsvector3f = NULL;
8332 rsurface.batchsvector3f_vertexbuffer = NULL;
8333 rsurface.batchsvector3f_bufferoffset = 0;
8334 rsurface.batchtvector3f = NULL;
8335 rsurface.batchtvector3f_vertexbuffer = NULL;
8336 rsurface.batchtvector3f_bufferoffset = 0;
8337 rsurface.batchnormal3f = NULL;
8338 rsurface.batchnormal3f_vertexbuffer = NULL;
8339 rsurface.batchnormal3f_bufferoffset = 0;
8340 rsurface.batchlightmapcolor4f = NULL;
8341 rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
8342 rsurface.batchlightmapcolor4f_bufferoffset = 0;
8343 rsurface.batchtexcoordtexture2f = NULL;
8344 rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
8345 rsurface.batchtexcoordtexture2f_bufferoffset = 0;
8346 rsurface.batchtexcoordlightmap2f = NULL;
8347 rsurface.batchtexcoordlightmap2f_vertexbuffer = NULL;
8348 rsurface.batchtexcoordlightmap2f_bufferoffset = 0;
8349 rsurface.batchvertexmesh = NULL;
8350 rsurface.batchvertexmeshbuffer = NULL;
8351 rsurface.batchvertex3fbuffer = NULL;
8352 rsurface.batchelement3i = NULL;
8353 rsurface.batchelement3i_indexbuffer = NULL;
8354 rsurface.batchelement3i_bufferoffset = 0;
8355 rsurface.batchelement3s = NULL;
8356 rsurface.batchelement3s_indexbuffer = NULL;
8357 rsurface.batchelement3s_bufferoffset = 0;
8358 rsurface.passcolor4f = NULL;
8359 rsurface.passcolor4f_vertexbuffer = NULL;
8360 rsurface.passcolor4f_bufferoffset = 0;
8361 rsurface.forcecurrenttextureupdate = false;
8364 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, qboolean wantnormals, qboolean wanttangents)
8366 rsurface.entity = r_refdef.scene.worldentity;
8367 rsurface.skeleton = NULL;
8368 rsurface.ent_skinnum = 0;
8369 rsurface.ent_qwskin = -1;
8370 rsurface.ent_flags = entflags;
8371 rsurface.shadertime = r_refdef.scene.time - shadertime;
8372 rsurface.modelnumvertices = numvertices;
8373 rsurface.modelnumtriangles = numtriangles;
8374 rsurface.matrix = *matrix;
8375 rsurface.inversematrix = *inversematrix;
8376 rsurface.matrixscale = Matrix4x4_ScaleFromMatrix(&rsurface.matrix);
8377 rsurface.inversematrixscale = 1.0f / rsurface.matrixscale;
8378 R_EntityMatrix(&rsurface.matrix);
8379 Matrix4x4_Transform(&rsurface.inversematrix, r_refdef.view.origin, rsurface.localvieworigin);
8380 Matrix4x4_TransformStandardPlane(&rsurface.inversematrix, r_refdef.fogplane[0], r_refdef.fogplane[1], r_refdef.fogplane[2], r_refdef.fogplane[3], rsurface.fogplane);
8381 rsurface.fogplaneviewdist *= rsurface.inversematrixscale;
8382 rsurface.fograngerecip = r_refdef.fograngerecip * rsurface.matrixscale;
8383 rsurface.fogheightfade = r_refdef.fogheightfade * rsurface.matrixscale;
8384 rsurface.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * rsurface.fograngerecip;
8385 VectorSet(rsurface.modellight_ambient, 0, 0, 0);
8386 VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
8387 VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
8388 VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
8389 VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
8390 Vector4Set(rsurface.colormod, r * r_refdef.view.colorscale, g * r_refdef.view.colorscale, b * r_refdef.view.colorscale, a);
8391 VectorSet(rsurface.glowmod, r_refdef.view.colorscale * r_hdr_glowintensity.value, r_refdef.view.colorscale * r_hdr_glowintensity.value, r_refdef.view.colorscale * r_hdr_glowintensity.value);
8392 memset(rsurface.frameblend, 0, sizeof(rsurface.frameblend));
8393 rsurface.frameblend[0].lerp = 1;
8394 rsurface.ent_alttextures = false;
8395 rsurface.basepolygonfactor = r_refdef.polygonfactor;
8396 rsurface.basepolygonoffset = r_refdef.polygonoffset;
8399 rsurface.modelvertex3f = (float *)vertex3f;
8400 rsurface.modelsvector3f = svector3f ? (float *)svector3f : (float *)R_FrameData_Alloc(rsurface.modelnumvertices * sizeof(float[3]));
8401 rsurface.modeltvector3f = tvector3f ? (float *)tvector3f : (float *)R_FrameData_Alloc(rsurface.modelnumvertices * sizeof(float[3]));
8402 rsurface.modelnormal3f = normal3f ? (float *)normal3f : (float *)R_FrameData_Alloc(rsurface.modelnumvertices * sizeof(float[3]));
8404 else if (wantnormals)
8406 rsurface.modelvertex3f = (float *)vertex3f;
8407 rsurface.modelsvector3f = NULL;
8408 rsurface.modeltvector3f = NULL;
8409 rsurface.modelnormal3f = normal3f ? (float *)normal3f : (float *)R_FrameData_Alloc(rsurface.modelnumvertices * sizeof(float[3]));
8413 rsurface.modelvertex3f = (float *)vertex3f;
8414 rsurface.modelsvector3f = NULL;
8415 rsurface.modeltvector3f = NULL;
8416 rsurface.modelnormal3f = NULL;
8418 rsurface.modelvertexmesh = NULL;
8419 rsurface.modelvertexmeshbuffer = NULL;
8420 rsurface.modelvertex3fbuffer = NULL;
8421 rsurface.modelvertex3f_vertexbuffer = 0;
8422 rsurface.modelvertex3f_bufferoffset = 0;
8423 rsurface.modelsvector3f_vertexbuffer = 0;
8424 rsurface.modelsvector3f_bufferoffset = 0;
8425 rsurface.modeltvector3f_vertexbuffer = 0;
8426 rsurface.modeltvector3f_bufferoffset = 0;
8427 rsurface.modelnormal3f_vertexbuffer = 0;
8428 rsurface.modelnormal3f_bufferoffset = 0;
8429 rsurface.modelgeneratedvertex = true;
8430 rsurface.modellightmapcolor4f = (float *)color4f;
8431 rsurface.modellightmapcolor4f_vertexbuffer = 0;
8432 rsurface.modellightmapcolor4f_bufferoffset = 0;
8433 rsurface.modeltexcoordtexture2f = (float *)texcoord2f;
8434 rsurface.modeltexcoordtexture2f_vertexbuffer = 0;
8435 rsurface.modeltexcoordtexture2f_bufferoffset = 0;
8436 rsurface.modeltexcoordlightmap2f = NULL;
8437 rsurface.modeltexcoordlightmap2f_vertexbuffer = 0;
8438 rsurface.modeltexcoordlightmap2f_bufferoffset = 0;
8439 rsurface.modelelement3i = (int *)element3i;
8440 rsurface.modelelement3i_indexbuffer = NULL;
8441 rsurface.modelelement3i_bufferoffset = 0;
8442 rsurface.modelelement3s = (unsigned short *)element3s;
8443 rsurface.modelelement3s_indexbuffer = NULL;
8444 rsurface.modelelement3s_bufferoffset = 0;
8445 rsurface.modellightmapoffsets = NULL;
8446 rsurface.modelsurfaces = NULL;
8447 rsurface.batchgeneratedvertex = false;
8448 rsurface.batchfirstvertex = 0;
8449 rsurface.batchnumvertices = 0;
8450 rsurface.batchfirsttriangle = 0;
8451 rsurface.batchnumtriangles = 0;
8452 rsurface.batchvertex3f = NULL;
8453 rsurface.batchvertex3f_vertexbuffer = NULL;
8454 rsurface.batchvertex3f_bufferoffset = 0;
8455 rsurface.batchsvector3f = NULL;
8456 rsurface.batchsvector3f_vertexbuffer = NULL;
8457 rsurface.batchsvector3f_bufferoffset = 0;
8458 rsurface.batchtvector3f = NULL;
8459 rsurface.batchtvector3f_vertexbuffer = NULL;
8460 rsurface.batchtvector3f_bufferoffset = 0;
8461 rsurface.batchnormal3f = NULL;
8462 rsurface.batchnormal3f_vertexbuffer = NULL;
8463 rsurface.batchnormal3f_bufferoffset = 0;
8464 rsurface.batchlightmapcolor4f = NULL;
8465 rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
8466 rsurface.batchlightmapcolor4f_bufferoffset = 0;
8467 rsurface.batchtexcoordtexture2f = NULL;
8468 rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
8469 rsurface.batchtexcoordtexture2f_bufferoffset = 0;
8470 rsurface.batchtexcoordlightmap2f = NULL;
8471 rsurface.batchtexcoordlightmap2f_vertexbuffer = NULL;
8472 rsurface.batchtexcoordlightmap2f_bufferoffset = 0;
8473 rsurface.batchvertexmesh = NULL;
8474 rsurface.batchvertexmeshbuffer = NULL;
8475 rsurface.batchvertex3fbuffer = NULL;
8476 rsurface.batchelement3i = NULL;
8477 rsurface.batchelement3i_indexbuffer = NULL;
8478 rsurface.batchelement3i_bufferoffset = 0;
8479 rsurface.batchelement3s = NULL;
8480 rsurface.batchelement3s_indexbuffer = NULL;
8481 rsurface.batchelement3s_bufferoffset = 0;
8482 rsurface.passcolor4f = NULL;
8483 rsurface.passcolor4f_vertexbuffer = NULL;
8484 rsurface.passcolor4f_bufferoffset = 0;
8485 rsurface.forcecurrenttextureupdate = true;
8487 if (rsurface.modelnumvertices && rsurface.modelelement3i)
8489 if ((wantnormals || wanttangents) && !normal3f)
8491 rsurface.modelnormal3f = (float *)R_FrameData_Alloc(rsurface.modelnumvertices * sizeof(float[3]));
8492 Mod_BuildNormals(0, rsurface.modelnumvertices, rsurface.modelnumtriangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.modelnormal3f, r_smoothnormals_areaweighting.integer != 0);
8494 if (wanttangents && !svector3f)
8496 rsurface.modelsvector3f = (float *)R_FrameData_Alloc(rsurface.modelnumvertices * sizeof(float[3]));
8497 rsurface.modeltvector3f = (float *)R_FrameData_Alloc(rsurface.modelnumvertices * sizeof(float[3]));
8498 Mod_BuildTextureVectorsFromNormals(0, rsurface.modelnumvertices, rsurface.modelnumtriangles, rsurface.modelvertex3f, rsurface.modeltexcoordtexture2f, rsurface.modelnormal3f, rsurface.modelelement3i, rsurface.modelsvector3f, rsurface.modeltvector3f, r_smoothnormals_areaweighting.integer != 0);
8503 float RSurf_FogPoint(const float *v)
8505 // this code is identical to the USEFOGINSIDE/USEFOGOUTSIDE code in the shader
8506 float FogPlaneViewDist = r_refdef.fogplaneviewdist;
8507 float FogPlaneVertexDist = DotProduct(r_refdef.fogplane, v) + r_refdef.fogplane[3];
8508 float FogHeightFade = r_refdef.fogheightfade;
8510 unsigned int fogmasktableindex;
8511 if (r_refdef.fogplaneviewabove)
8512 fogfrac = min(0.0f, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0f, min(0.0f, FogPlaneVertexDist) * FogHeightFade);
8514 fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0f, FogPlaneVertexDist)) * min(1.0f, (min(0.0f, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);
8515 fogmasktableindex = (unsigned int)(VectorDistance(r_refdef.view.origin, v) * fogfrac * r_refdef.fogmasktabledistmultiplier);
8516 return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
8519 float RSurf_FogVertex(const float *v)
8521 // this code is identical to the USEFOGINSIDE/USEFOGOUTSIDE code in the shader
8522 float FogPlaneViewDist = rsurface.fogplaneviewdist;
8523 float FogPlaneVertexDist = DotProduct(rsurface.fogplane, v) + rsurface.fogplane[3];
8524 float FogHeightFade = rsurface.fogheightfade;
8526 unsigned int fogmasktableindex;
8527 if (r_refdef.fogplaneviewabove)
8528 fogfrac = min(0.0f, FogPlaneVertexDist) / (FogPlaneVertexDist - FogPlaneViewDist) * min(1.0f, min(0.0f, FogPlaneVertexDist) * FogHeightFade);
8530 fogfrac = FogPlaneViewDist / (FogPlaneViewDist - max(0.0f, FogPlaneVertexDist)) * min(1.0f, (min(0.0f, FogPlaneVertexDist) + FogPlaneViewDist) * FogHeightFade);
8531 fogmasktableindex = (unsigned int)(VectorDistance(rsurface.localvieworigin, v) * fogfrac * rsurface.fogmasktabledistmultiplier);
8532 return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)];
8535 static void RSurf_RenumberElements(const int *inelement3i, int *outelement3i, int numelements, int adjust)
8538 for (i = 0;i < numelements;i++)
8539 outelement3i[i] = inelement3i[i] + adjust;
8542 static const int quadedges[6][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3}};
8543 extern cvar_t gl_vbo;
8544 void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const msurface_t **texturesurfacelist)
8552 int surfacefirsttriangle;
8553 int surfacenumtriangles;
8554 int surfacefirstvertex;
8555 int surfaceendvertex;
8556 int surfacenumvertices;
8557 int batchnumvertices;
8558 int batchnumtriangles;
8562 qboolean dynamicvertex;
8566 float center[3], forward[3], right[3], up[3], v[3], newforward[3], newright[3], newup[3];
8568 q3shaderinfo_deform_t *deform;
8569 const msurface_t *surface, *firstsurface;
8570 r_vertexmesh_t *vertexmesh;
8571 if (!texturenumsurfaces)
8573 // find vertex range of this surface batch
8575 firstsurface = texturesurfacelist[0];
8576 firsttriangle = firstsurface->num_firsttriangle;
8577 batchnumvertices = 0;
8578 batchnumtriangles = 0;
8579 firstvertex = endvertex = firstsurface->num_firstvertex;
8580 for (i = 0;i < texturenumsurfaces;i++)
8582 surface = texturesurfacelist[i];
8583 if (surface != firstsurface + i)
8585 surfacefirstvertex = surface->num_firstvertex;
8586 surfaceendvertex = surfacefirstvertex + surface->num_vertices;
8587 surfacenumvertices = surface->num_vertices;
8588 surfacenumtriangles = surface->num_triangles;
8589 if (firstvertex > surfacefirstvertex)
8590 firstvertex = surfacefirstvertex;
8591 if (endvertex < surfaceendvertex)
8592 endvertex = surfaceendvertex;
8593 batchnumvertices += surfacenumvertices;
8594 batchnumtriangles += surfacenumtriangles;
8597 // we now know the vertex range used, and if there are any gaps in it
8598 rsurface.batchfirstvertex = firstvertex;
8599 rsurface.batchnumvertices = endvertex - firstvertex;
8600 rsurface.batchfirsttriangle = firsttriangle;
8601 rsurface.batchnumtriangles = batchnumtriangles;
8603 // this variable holds flags for which properties have been updated that
8604 // may require regenerating vertexmesh array...
8607 // check if any dynamic vertex processing must occur
8608 dynamicvertex = false;
8610 // if there is a chance of animated vertex colors, it's a dynamic batch
8611 if ((batchneed & (BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_ARRAY_VERTEXCOLOR)) && texturesurfacelist[0]->lightmapinfo)
8613 dynamicvertex = true;
8614 batchneed |= BATCHNEED_NOGAPS;
8615 needsupdate |= BATCHNEED_VERTEXMESH_VERTEXCOLOR;
8618 for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform && r_deformvertexes.integer;deformindex++, deform++)
8620 switch (deform->deform)
8623 case Q3DEFORM_PROJECTIONSHADOW:
8624 case Q3DEFORM_TEXT0:
8625 case Q3DEFORM_TEXT1:
8626 case Q3DEFORM_TEXT2:
8627 case Q3DEFORM_TEXT3:
8628 case Q3DEFORM_TEXT4:
8629 case Q3DEFORM_TEXT5:
8630 case Q3DEFORM_TEXT6:
8631 case Q3DEFORM_TEXT7:
8634 case Q3DEFORM_AUTOSPRITE:
8635 dynamicvertex = true;
8636 batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS;
8637 needsupdate |= BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
8639 case Q3DEFORM_AUTOSPRITE2:
8640 dynamicvertex = true;
8641 batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS;
8642 needsupdate |= BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
8644 case Q3DEFORM_NORMAL:
8645 dynamicvertex = true;
8646 batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS;
8647 needsupdate |= BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
8650 if(!R_TestQ3WaveFunc(deform->wavefunc, deform->waveparms))
8651 break; // if wavefunc is a nop, ignore this transform
8652 dynamicvertex = true;
8653 batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS;
8654 needsupdate |= BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
8656 case Q3DEFORM_BULGE:
8657 dynamicvertex = true;
8658 batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS;
8659 needsupdate |= BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR;
8662 if(!R_TestQ3WaveFunc(deform->wavefunc, deform->waveparms))
8663 break; // if wavefunc is a nop, ignore this transform
8664 dynamicvertex = true;
8665 batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS;
8666 needsupdate |= BATCHNEED_VERTEXMESH_VERTEX;
8670 switch(rsurface.texture->tcgen.tcgen)
8673 case Q3TCGEN_TEXTURE:
8675 case Q3TCGEN_LIGHTMAP:
8676 dynamicvertex = true;
8677 batchneed |= BATCHNEED_ARRAY_LIGHTMAP | BATCHNEED_NOGAPS;
8678 needsupdate |= BATCHNEED_VERTEXMESH_LIGHTMAP;
8680 case Q3TCGEN_VECTOR:
8681 dynamicvertex = true;
8682 batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS;
8683 needsupdate |= BATCHNEED_VERTEXMESH_TEXCOORD;
8685 case Q3TCGEN_ENVIRONMENT:
8686 dynamicvertex = true;
8687 batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_NOGAPS;
8688 needsupdate |= BATCHNEED_VERTEXMESH_TEXCOORD;
8691 if (rsurface.texture->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
8693 dynamicvertex = true;
8694 batchneed |= BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_NOGAPS;
8695 needsupdate |= BATCHNEED_VERTEXMESH_TEXCOORD;
8698 if (!rsurface.modelvertexmesh && (batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP)))
8700 dynamicvertex = true;
8701 batchneed |= BATCHNEED_NOGAPS;
8702 needsupdate |= (batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP));
8705 if (dynamicvertex || gaps || rsurface.batchfirstvertex)
8707 // when copying, we need to consider the regeneration of vertexmesh, any dependencies it may have must be set...
8708 if (batchneed & BATCHNEED_VERTEXMESH_VERTEX) batchneed |= BATCHNEED_ARRAY_VERTEX;
8709 if (batchneed & BATCHNEED_VERTEXMESH_NORMAL) batchneed |= BATCHNEED_ARRAY_NORMAL;
8710 if (batchneed & BATCHNEED_VERTEXMESH_VECTOR) batchneed |= BATCHNEED_ARRAY_VECTOR;
8711 if (batchneed & BATCHNEED_VERTEXMESH_VERTEXCOLOR) batchneed |= BATCHNEED_ARRAY_VERTEXCOLOR;
8712 if (batchneed & BATCHNEED_VERTEXMESH_TEXCOORD) batchneed |= BATCHNEED_ARRAY_TEXCOORD;
8713 if (batchneed & BATCHNEED_VERTEXMESH_LIGHTMAP) batchneed |= BATCHNEED_ARRAY_LIGHTMAP;
8716 // when the model data has no vertex buffer (dynamic mesh), we need to
8718 if (vid.useinterleavedarrays ? !rsurface.modelvertexmeshbuffer : !rsurface.modelvertex3f_vertexbuffer)
8719 batchneed |= BATCHNEED_NOGAPS;
8721 // if needsupdate, we have to do a dynamic vertex batch for sure
8722 if (needsupdate & batchneed)
8723 dynamicvertex = true;
8725 // see if we need to build vertexmesh from arrays
8726 if (!rsurface.modelvertexmesh && (batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP)))
8727 dynamicvertex = true;
8729 // if gaps are unacceptable, and there are gaps, it's a dynamic batch...
8730 // also some drivers strongly dislike firstvertex
8731 if ((batchneed & BATCHNEED_NOGAPS) && (gaps || firstvertex))
8732 dynamicvertex = true;
8734 rsurface.batchvertex3f = rsurface.modelvertex3f;
8735 rsurface.batchvertex3f_vertexbuffer = rsurface.modelvertex3f_vertexbuffer;
8736 rsurface.batchvertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
8737 rsurface.batchsvector3f = rsurface.modelsvector3f;
8738 rsurface.batchsvector3f_vertexbuffer = rsurface.modelsvector3f_vertexbuffer;
8739 rsurface.batchsvector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
8740 rsurface.batchtvector3f = rsurface.modeltvector3f;
8741 rsurface.batchtvector3f_vertexbuffer = rsurface.modeltvector3f_vertexbuffer;
8742 rsurface.batchtvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
8743 rsurface.batchnormal3f = rsurface.modelnormal3f;
8744 rsurface.batchnormal3f_vertexbuffer = rsurface.modelnormal3f_vertexbuffer;
8745 rsurface.batchnormal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
8746 rsurface.batchlightmapcolor4f = rsurface.modellightmapcolor4f;
8747 rsurface.batchlightmapcolor4f_vertexbuffer = rsurface.modellightmapcolor4f_vertexbuffer;
8748 rsurface.batchlightmapcolor4f_bufferoffset = rsurface.modellightmapcolor4f_bufferoffset;
8749 rsurface.batchtexcoordtexture2f = rsurface.modeltexcoordtexture2f;
8750 rsurface.batchtexcoordtexture2f_vertexbuffer = rsurface.modeltexcoordtexture2f_vertexbuffer;
8751 rsurface.batchtexcoordtexture2f_bufferoffset = rsurface.modeltexcoordtexture2f_bufferoffset;
8752 rsurface.batchtexcoordlightmap2f = rsurface.modeltexcoordlightmap2f;
8753 rsurface.batchtexcoordlightmap2f_vertexbuffer = rsurface.modeltexcoordlightmap2f_vertexbuffer;
8754 rsurface.batchtexcoordlightmap2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
8755 rsurface.batchvertex3fbuffer = rsurface.modelvertex3fbuffer;
8756 rsurface.batchvertexmesh = rsurface.modelvertexmesh;
8757 rsurface.batchvertexmeshbuffer = rsurface.modelvertexmeshbuffer;
8758 rsurface.batchelement3i = rsurface.modelelement3i;
8759 rsurface.batchelement3i_indexbuffer = rsurface.modelelement3i_indexbuffer;
8760 rsurface.batchelement3i_bufferoffset = rsurface.modelelement3i_bufferoffset;
8761 rsurface.batchelement3s = rsurface.modelelement3s;
8762 rsurface.batchelement3s_indexbuffer = rsurface.modelelement3s_indexbuffer;
8763 rsurface.batchelement3s_bufferoffset = rsurface.modelelement3s_bufferoffset;
8765 // if any dynamic vertex processing has to occur in software, we copy the
8766 // entire surface list together before processing to rebase the vertices
8767 // to start at 0 (otherwise we waste a lot of room in a vertex buffer).
8769 // if any gaps exist and we do not have a static vertex buffer, we have to
8770 // copy the surface list together to avoid wasting upload bandwidth on the
8771 // vertices in the gaps.
8773 // if gaps exist and we have a static vertex buffer, we still have to
8774 // combine the index buffer ranges into one dynamic index buffer.
8776 // in all cases we end up with data that can be drawn in one call.
8780 // static vertex data, just set pointers...
8781 rsurface.batchgeneratedvertex = false;
8782 // if there are gaps, we want to build a combined index buffer,
8783 // otherwise use the original static buffer with an appropriate offset
8786 // build a new triangle elements array for this batch
8787 rsurface.batchelement3i = (int *)R_FrameData_Alloc(batchnumtriangles * sizeof(int[3]));
8788 rsurface.batchfirsttriangle = 0;
8790 for (i = 0;i < texturenumsurfaces;i++)
8792 surfacefirsttriangle = texturesurfacelist[i]->num_firsttriangle;
8793 surfacenumtriangles = texturesurfacelist[i]->num_triangles;
8794 memcpy(rsurface.batchelement3i + 3*numtriangles, rsurface.modelelement3i + 3*surfacefirsttriangle, surfacenumtriangles*sizeof(int[3]));
8795 numtriangles += surfacenumtriangles;
8797 rsurface.batchelement3i_indexbuffer = NULL;
8798 rsurface.batchelement3i_bufferoffset = 0;
8799 rsurface.batchelement3s = NULL;
8800 rsurface.batchelement3s_indexbuffer = NULL;
8801 rsurface.batchelement3s_bufferoffset = 0;
8802 if (endvertex <= 65536)
8804 // make a 16bit (unsigned short) index array if possible
8805 rsurface.batchelement3s = (unsigned short *)R_FrameData_Alloc(batchnumtriangles * sizeof(unsigned short[3]));
8806 for (i = 0;i < numtriangles*3;i++)
8807 rsurface.batchelement3s[i] = rsurface.batchelement3i[i];
8813 // something needs software processing, do it for real...
8814 // we only directly handle separate array data in this case and then
8815 // generate interleaved data if needed...
8816 rsurface.batchgeneratedvertex = true;
8818 // now copy the vertex data into a combined array and make an index array
8819 // (this is what Quake3 does all the time)
8820 //if (gaps || rsurface.batchfirstvertex)
8822 rsurface.batchvertex3fbuffer = NULL;
8823 rsurface.batchvertexmesh = NULL;
8824 rsurface.batchvertexmeshbuffer = NULL;
8825 rsurface.batchvertex3f = NULL;
8826 rsurface.batchvertex3f_vertexbuffer = NULL;
8827 rsurface.batchvertex3f_bufferoffset = 0;
8828 rsurface.batchsvector3f = NULL;
8829 rsurface.batchsvector3f_vertexbuffer = NULL;
8830 rsurface.batchsvector3f_bufferoffset = 0;
8831 rsurface.batchtvector3f = NULL;
8832 rsurface.batchtvector3f_vertexbuffer = NULL;
8833 rsurface.batchtvector3f_bufferoffset = 0;
8834 rsurface.batchnormal3f = NULL;
8835 rsurface.batchnormal3f_vertexbuffer = NULL;
8836 rsurface.batchnormal3f_bufferoffset = 0;
8837 rsurface.batchlightmapcolor4f = NULL;
8838 rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
8839 rsurface.batchlightmapcolor4f_bufferoffset = 0;
8840 rsurface.batchtexcoordtexture2f = NULL;
8841 rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
8842 rsurface.batchtexcoordtexture2f_bufferoffset = 0;
8843 rsurface.batchtexcoordlightmap2f = NULL;
8844 rsurface.batchtexcoordlightmap2f_vertexbuffer = NULL;
8845 rsurface.batchtexcoordlightmap2f_bufferoffset = 0;
8846 rsurface.batchelement3i = (int *)R_FrameData_Alloc(batchnumtriangles * sizeof(int[3]));
8847 rsurface.batchelement3i_indexbuffer = NULL;
8848 rsurface.batchelement3i_bufferoffset = 0;
8849 rsurface.batchelement3s = NULL;
8850 rsurface.batchelement3s_indexbuffer = NULL;
8851 rsurface.batchelement3s_bufferoffset = 0;
8852 // we'll only be setting up certain arrays as needed
8853 if (batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP))
8854 rsurface.batchvertexmesh = (r_vertexmesh_t *)R_FrameData_Alloc(batchnumvertices * sizeof(r_vertexmesh_t));
8855 if (batchneed & BATCHNEED_ARRAY_VERTEX)
8856 rsurface.batchvertex3f = (float *)R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
8857 if (batchneed & BATCHNEED_ARRAY_NORMAL)
8858 rsurface.batchnormal3f = (float *)R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
8859 if (batchneed & BATCHNEED_ARRAY_VECTOR)
8861 rsurface.batchsvector3f = (float *)R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
8862 rsurface.batchtvector3f = (float *)R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
8864 if (batchneed & BATCHNEED_ARRAY_VERTEXCOLOR)
8865 rsurface.batchlightmapcolor4f = (float *)R_FrameData_Alloc(batchnumvertices * sizeof(float[4]));
8866 if (batchneed & BATCHNEED_ARRAY_TEXCOORD)
8867 rsurface.batchtexcoordtexture2f = (float *)R_FrameData_Alloc(batchnumvertices * sizeof(float[2]));
8868 if (batchneed & BATCHNEED_ARRAY_LIGHTMAP)
8869 rsurface.batchtexcoordlightmap2f = (float *)R_FrameData_Alloc(batchnumvertices * sizeof(float[2]));
8872 for (i = 0;i < texturenumsurfaces;i++)
8874 surfacefirstvertex = texturesurfacelist[i]->num_firstvertex;
8875 surfacenumvertices = texturesurfacelist[i]->num_vertices;
8876 surfacefirsttriangle = texturesurfacelist[i]->num_firsttriangle;
8877 surfacenumtriangles = texturesurfacelist[i]->num_triangles;
8878 // copy only the data requested
8879 if ((batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP)) && rsurface.modelvertexmesh)
8880 memcpy(rsurface.batchvertexmesh + numvertices, rsurface.modelvertexmesh + surfacefirstvertex, surfacenumvertices * sizeof(rsurface.batchvertexmesh[0]));
8881 if (batchneed & (BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | BATCHNEED_ARRAY_VERTEXCOLOR | BATCHNEED_ARRAY_TEXCOORD | BATCHNEED_ARRAY_LIGHTMAP))
8883 if (batchneed & BATCHNEED_ARRAY_VERTEX)
8885 if (rsurface.batchvertex3f)
8886 memcpy(rsurface.batchvertex3f + 3*numvertices, rsurface.modelvertex3f + 3*surfacefirstvertex, surfacenumvertices * sizeof(float[3]));
8888 memset(rsurface.batchvertex3f + 3*numvertices, 0, surfacenumvertices * sizeof(float[3]));
8890 if (batchneed & BATCHNEED_ARRAY_NORMAL)
8892 if (rsurface.modelnormal3f)
8893 memcpy(rsurface.batchnormal3f + 3*numvertices, rsurface.modelnormal3f + 3*surfacefirstvertex, surfacenumvertices * sizeof(float[3]));
8895 memset(rsurface.batchnormal3f + 3*numvertices, 0, surfacenumvertices * sizeof(float[3]));
8897 if (batchneed & BATCHNEED_ARRAY_VECTOR)
8899 if (rsurface.modelsvector3f)
8901 memcpy(rsurface.batchsvector3f + 3*numvertices, rsurface.modelsvector3f + 3*surfacefirstvertex, surfacenumvertices * sizeof(float[3]));
8902 memcpy(rsurface.batchtvector3f + 3*numvertices, rsurface.modeltvector3f + 3*surfacefirstvertex, surfacenumvertices * sizeof(float[3]));
8906 memset(rsurface.batchsvector3f + 3*numvertices, 0, surfacenumvertices * sizeof(float[3]));
8907 memset(rsurface.batchtvector3f + 3*numvertices, 0, surfacenumvertices * sizeof(float[3]));
8910 if (batchneed & BATCHNEED_ARRAY_VERTEXCOLOR)
8912 if (rsurface.modellightmapcolor4f)
8913 memcpy(rsurface.batchlightmapcolor4f + 4*numvertices, rsurface.modellightmapcolor4f + 4*surfacefirstvertex, surfacenumvertices * sizeof(float[4]));
8915 memset(rsurface.batchlightmapcolor4f + 4*numvertices, 0, surfacenumvertices * sizeof(float[4]));
8917 if (batchneed & BATCHNEED_ARRAY_TEXCOORD)
8919 if (rsurface.modeltexcoordtexture2f)
8920 memcpy(rsurface.batchtexcoordtexture2f + 2*numvertices, rsurface.modeltexcoordtexture2f + 2*surfacefirstvertex, surfacenumvertices * sizeof(float[2]));
8922 memset(rsurface.batchtexcoordtexture2f + 2*numvertices, 0, surfacenumvertices * sizeof(float[2]));
8924 if (batchneed & BATCHNEED_ARRAY_LIGHTMAP)
8926 if (rsurface.modeltexcoordlightmap2f)
8927 memcpy(rsurface.batchtexcoordlightmap2f + 2*numvertices, rsurface.modeltexcoordlightmap2f + 2*surfacefirstvertex, surfacenumvertices * sizeof(float[2]));
8929 memset(rsurface.batchtexcoordlightmap2f + 2*numvertices, 0, surfacenumvertices * sizeof(float[2]));
8932 RSurf_RenumberElements(rsurface.modelelement3i + 3*surfacefirsttriangle, rsurface.batchelement3i + 3*numtriangles, 3*surfacenumtriangles, numvertices - surfacefirstvertex);
8933 numvertices += surfacenumvertices;
8934 numtriangles += surfacenumtriangles;
8937 // generate a 16bit index array as well if possible
8938 // (in general, dynamic batches fit)
8939 if (numvertices <= 65536)
8941 rsurface.batchelement3s = (unsigned short *)R_FrameData_Alloc(batchnumtriangles * sizeof(unsigned short[3]));
8942 for (i = 0;i < numtriangles*3;i++)
8943 rsurface.batchelement3s[i] = rsurface.batchelement3i[i];
8946 // since we've copied everything, the batch now starts at 0
8947 rsurface.batchfirstvertex = 0;
8948 rsurface.batchnumvertices = batchnumvertices;
8949 rsurface.batchfirsttriangle = 0;
8950 rsurface.batchnumtriangles = batchnumtriangles;
8953 // q1bsp surfaces rendered in vertex color mode have to have colors
8954 // calculated based on lightstyles
8955 if ((batchneed & (BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_ARRAY_VERTEXCOLOR)) && texturesurfacelist[0]->lightmapinfo)
8957 // generate color arrays for the surfaces in this list
8962 const unsigned char *lm;
8963 rsurface.batchlightmapcolor4f = (float *)R_FrameData_Alloc(batchnumvertices * sizeof(float[4]));
8964 rsurface.batchlightmapcolor4f_vertexbuffer = NULL;
8965 rsurface.batchlightmapcolor4f_bufferoffset = 0;
8967 for (i = 0;i < texturenumsurfaces;i++)
8969 surface = texturesurfacelist[i];
8970 offsets = rsurface.modellightmapoffsets + surface->num_firstvertex;
8971 surfacenumvertices = surface->num_vertices;
8972 if (surface->lightmapinfo->samples)
8974 for (j = 0;j < surfacenumvertices;j++)
8976 lm = surface->lightmapinfo->samples + offsets[j];
8977 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[0]];
8978 VectorScale(lm, scale, c);
8979 if (surface->lightmapinfo->styles[1] != 255)
8981 size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
8983 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[1]];
8984 VectorMA(c, scale, lm, c);
8985 if (surface->lightmapinfo->styles[2] != 255)
8988 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[2]];
8989 VectorMA(c, scale, lm, c);
8990 if (surface->lightmapinfo->styles[3] != 255)
8993 scale = r_refdef.scene.lightstylevalue[surface->lightmapinfo->styles[3]];
8994 VectorMA(c, scale, lm, c);
9001 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);
9007 for (j = 0;j < surfacenumvertices;j++)
9009 Vector4Set(rsurface.batchlightmapcolor4f + 4*numvertices, 0, 0, 0, 1);
9016 // if vertices are deformed (sprite flares and things in maps, possibly
9017 // water waves, bulges and other deformations), modify the copied vertices
9019 for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform && r_deformvertexes.integer;deformindex++, deform++)
9021 switch (deform->deform)
9024 case Q3DEFORM_PROJECTIONSHADOW:
9025 case Q3DEFORM_TEXT0:
9026 case Q3DEFORM_TEXT1:
9027 case Q3DEFORM_TEXT2:
9028 case Q3DEFORM_TEXT3:
9029 case Q3DEFORM_TEXT4:
9030 case Q3DEFORM_TEXT5:
9031 case Q3DEFORM_TEXT6:
9032 case Q3DEFORM_TEXT7:
9035 case Q3DEFORM_AUTOSPRITE:
9036 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
9037 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
9038 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
9039 VectorNormalize(newforward);
9040 VectorNormalize(newright);
9041 VectorNormalize(newup);
9042 // rsurface.batchvertex3f = R_FrameData_Store(batchnumvertices * sizeof(float[3]), rsurface.batchvertex3f);
9043 // rsurface.batchvertex3f_vertexbuffer = NULL;
9044 // rsurface.batchvertex3f_bufferoffset = 0;
9045 // rsurface.batchsvector3f = R_FrameData_Store(batchnumvertices * sizeof(float[3]), rsurface.batchsvector3f);
9046 // rsurface.batchsvector3f_vertexbuffer = NULL;
9047 // rsurface.batchsvector3f_bufferoffset = 0;
9048 // rsurface.batchtvector3f = R_FrameData_Store(batchnumvertices * sizeof(float[3]), rsurface.batchtvector3f);
9049 // rsurface.batchtvector3f_vertexbuffer = NULL;
9050 // rsurface.batchtvector3f_bufferoffset = 0;
9051 // rsurface.batchnormal3f = R_FrameData_Store(batchnumvertices * sizeof(float[3]), rsurface.batchnormal3f);
9052 // rsurface.batchnormal3f_vertexbuffer = NULL;
9053 // rsurface.batchnormal3f_bufferoffset = 0;
9054 // sometimes we're on a renderpath that does not use vectors (GL11/GL13/GLES1)
9055 if (!VectorLength2(rsurface.batchnormal3f + 3*rsurface.batchfirstvertex))
9056 Mod_BuildNormals(rsurface.batchfirstvertex, batchnumvertices, batchnumtriangles, rsurface.batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.batchnormal3f, r_smoothnormals_areaweighting.integer != 0);
9057 if (!VectorLength2(rsurface.batchsvector3f + 3*rsurface.batchfirstvertex))
9058 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);
9059 // a single autosprite surface can contain multiple sprites...
9060 for (j = 0;j < batchnumvertices - 3;j += 4)
9062 VectorClear(center);
9063 for (i = 0;i < 4;i++)
9064 VectorAdd(center, rsurface.batchvertex3f + 3*(j+i), center);
9065 VectorScale(center, 0.25f, center);
9066 VectorCopy(rsurface.batchnormal3f + 3*j, forward);
9067 VectorCopy(rsurface.batchsvector3f + 3*j, right);
9068 VectorCopy(rsurface.batchtvector3f + 3*j, up);
9069 for (i = 0;i < 4;i++)
9071 VectorSubtract(rsurface.batchvertex3f + 3*(j+i), center, v);
9072 VectorMAMAMAM(1, center, DotProduct(forward, v), newforward, DotProduct(right, v), newright, DotProduct(up, v), newup, rsurface.batchvertex3f + 3*(j+i));
9075 // if we get here, BATCHNEED_ARRAY_NORMAL and BATCHNEED_ARRAY_VECTOR are in batchneed, so no need to check
9076 Mod_BuildNormals(rsurface.batchfirstvertex, batchnumvertices, batchnumtriangles, rsurface.batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.batchnormal3f, r_smoothnormals_areaweighting.integer != 0);
9077 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);
9079 case Q3DEFORM_AUTOSPRITE2:
9080 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, newforward);
9081 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.right, newright);
9082 Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.up, newup);
9083 VectorNormalize(newforward);
9084 VectorNormalize(newright);
9085 VectorNormalize(newup);
9086 // rsurface.batchvertex3f = R_FrameData_Store(batchnumvertices * sizeof(float[3]), rsurface.batchvertex3f);
9087 // rsurface.batchvertex3f_vertexbuffer = NULL;
9088 // rsurface.batchvertex3f_bufferoffset = 0;
9090 const float *v1, *v2;
9100 memset(shortest, 0, sizeof(shortest));
9101 // a single autosprite surface can contain multiple sprites...
9102 for (j = 0;j < batchnumvertices - 3;j += 4)
9104 VectorClear(center);
9105 for (i = 0;i < 4;i++)
9106 VectorAdd(center, rsurface.batchvertex3f + 3*(j+i), center);
9107 VectorScale(center, 0.25f, center);
9108 // find the two shortest edges, then use them to define the
9109 // axis vectors for rotating around the central axis
9110 for (i = 0;i < 6;i++)
9112 v1 = rsurface.batchvertex3f + 3*(j+quadedges[i][0]);
9113 v2 = rsurface.batchvertex3f + 3*(j+quadedges[i][1]);
9114 l = VectorDistance2(v1, v2);
9115 // this length bias tries to make sense of square polygons, assuming they are meant to be upright
9117 l += (1.0f / 1024.0f);
9118 if (shortest[0].length2 > l || i == 0)
9120 shortest[1] = shortest[0];
9121 shortest[0].length2 = l;
9122 shortest[0].v1 = v1;
9123 shortest[0].v2 = v2;
9125 else if (shortest[1].length2 > l || i == 1)
9127 shortest[1].length2 = l;
9128 shortest[1].v1 = v1;
9129 shortest[1].v2 = v2;
9132 VectorLerp(shortest[0].v1, 0.5f, shortest[0].v2, start);
9133 VectorLerp(shortest[1].v1, 0.5f, shortest[1].v2, end);
9134 // this calculates the right vector from the shortest edge
9135 // and the up vector from the edge midpoints
9136 VectorSubtract(shortest[0].v1, shortest[0].v2, right);
9137 VectorNormalize(right);
9138 VectorSubtract(end, start, up);
9139 VectorNormalize(up);
9140 // calculate a forward vector to use instead of the original plane normal (this is how we get a new right vector)
9141 VectorSubtract(rsurface.localvieworigin, center, forward);
9142 //Matrix4x4_Transform3x3(&rsurface.inversematrix, r_refdef.view.forward, forward);
9143 VectorNegate(forward, forward);
9144 VectorReflect(forward, 0, up, forward);
9145 VectorNormalize(forward);
9146 CrossProduct(up, forward, newright);
9147 VectorNormalize(newright);
9148 // rotate the quad around the up axis vector, this is made
9149 // especially easy by the fact we know the quad is flat,
9150 // so we only have to subtract the center position and
9151 // measure distance along the right vector, and then
9152 // multiply that by the newright vector and add back the
9154 // we also need to subtract the old position to undo the
9155 // displacement from the center, which we do with a
9156 // DotProduct, the subtraction/addition of center is also
9157 // optimized into DotProducts here
9158 l = DotProduct(right, center);
9159 for (i = 0;i < 4;i++)
9161 v1 = rsurface.batchvertex3f + 3*(j+i);
9162 f = DotProduct(right, v1) - l;
9163 VectorMAMAM(1, v1, -f, right, f, newright, rsurface.batchvertex3f + 3*(j+i));
9167 if(batchneed & (BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR)) // otherwise these can stay NULL
9169 // rsurface.batchnormal3f = R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
9170 // rsurface.batchnormal3f_vertexbuffer = NULL;
9171 // rsurface.batchnormal3f_bufferoffset = 0;
9172 Mod_BuildNormals(rsurface.batchfirstvertex, batchnumvertices, batchnumtriangles, rsurface.batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.batchnormal3f, r_smoothnormals_areaweighting.integer != 0);
9174 if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL
9176 // rsurface.batchsvector3f = R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
9177 // rsurface.batchsvector3f_vertexbuffer = NULL;
9178 // rsurface.batchsvector3f_bufferoffset = 0;
9179 // rsurface.batchtvector3f = R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
9180 // rsurface.batchtvector3f_vertexbuffer = NULL;
9181 // rsurface.batchtvector3f_bufferoffset = 0;
9182 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);
9185 case Q3DEFORM_NORMAL:
9186 // deform the normals to make reflections wavey
9187 rsurface.batchnormal3f = (float *)R_FrameData_Store(batchnumvertices * sizeof(float[3]), rsurface.batchnormal3f);
9188 rsurface.batchnormal3f_vertexbuffer = NULL;
9189 rsurface.batchnormal3f_bufferoffset = 0;
9190 for (j = 0;j < batchnumvertices;j++)
9193 float *normal = rsurface.batchnormal3f + 3*j;
9194 VectorScale(rsurface.batchvertex3f + 3*j, 0.98f, vertex);
9195 normal[0] = rsurface.batchnormal3f[j*3+0] + deform->parms[0] * noise4f( vertex[0], vertex[1], vertex[2], rsurface.shadertime * deform->parms[1]);
9196 normal[1] = rsurface.batchnormal3f[j*3+1] + deform->parms[0] * noise4f( 98 + vertex[0], vertex[1], vertex[2], rsurface.shadertime * deform->parms[1]);
9197 normal[2] = rsurface.batchnormal3f[j*3+2] + deform->parms[0] * noise4f(196 + vertex[0], vertex[1], vertex[2], rsurface.shadertime * deform->parms[1]);
9198 VectorNormalize(normal);
9200 if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL
9202 // rsurface.batchsvector3f = R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
9203 // rsurface.batchsvector3f_vertexbuffer = NULL;
9204 // rsurface.batchsvector3f_bufferoffset = 0;
9205 // rsurface.batchtvector3f = R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
9206 // rsurface.batchtvector3f_vertexbuffer = NULL;
9207 // rsurface.batchtvector3f_bufferoffset = 0;
9208 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);
9212 // deform vertex array to make wavey water and flags and such
9213 waveparms[0] = deform->waveparms[0];
9214 waveparms[1] = deform->waveparms[1];
9215 waveparms[2] = deform->waveparms[2];
9216 waveparms[3] = deform->waveparms[3];
9217 if(!R_TestQ3WaveFunc(deform->wavefunc, waveparms))
9218 break; // if wavefunc is a nop, don't make a dynamic vertex array
9219 // this is how a divisor of vertex influence on deformation
9220 animpos = deform->parms[0] ? 1.0f / deform->parms[0] : 100.0f;
9221 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
9222 // rsurface.batchvertex3f = R_FrameData_Store(batchnumvertices * sizeof(float[3]), rsurface.batchvertex3f);
9223 // rsurface.batchvertex3f_vertexbuffer = NULL;
9224 // rsurface.batchvertex3f_bufferoffset = 0;
9225 // rsurface.batchnormal3f = R_FrameData_Store(batchnumvertices * sizeof(float[3]), rsurface.batchnormal3f);
9226 // rsurface.batchnormal3f_vertexbuffer = NULL;
9227 // rsurface.batchnormal3f_bufferoffset = 0;
9228 for (j = 0;j < batchnumvertices;j++)
9230 // if the wavefunc depends on time, evaluate it per-vertex
9233 waveparms[2] = deform->waveparms[2] + (rsurface.batchvertex3f[j*3+0] + rsurface.batchvertex3f[j*3+1] + rsurface.batchvertex3f[j*3+2]) * animpos;
9234 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
9236 VectorMA(rsurface.batchvertex3f + 3*j, scale, rsurface.batchnormal3f + 3*j, rsurface.batchvertex3f + 3*j);
9238 // if we get here, BATCHNEED_ARRAY_NORMAL is in batchneed, so no need to check
9239 Mod_BuildNormals(rsurface.batchfirstvertex, batchnumvertices, batchnumtriangles, rsurface.batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.batchnormal3f, r_smoothnormals_areaweighting.integer != 0);
9240 if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL
9242 // rsurface.batchsvector3f = R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
9243 // rsurface.batchsvector3f_vertexbuffer = NULL;
9244 // rsurface.batchsvector3f_bufferoffset = 0;
9245 // rsurface.batchtvector3f = R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
9246 // rsurface.batchtvector3f_vertexbuffer = NULL;
9247 // rsurface.batchtvector3f_bufferoffset = 0;
9248 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);
9251 case Q3DEFORM_BULGE:
9252 // deform vertex array to make the surface have moving bulges
9253 // rsurface.batchvertex3f = R_FrameData_Store(batchnumvertices * sizeof(float[3]), rsurface.batchvertex3f);
9254 // rsurface.batchvertex3f_vertexbuffer = NULL;
9255 // rsurface.batchvertex3f_bufferoffset = 0;
9256 // rsurface.batchnormal3f = R_FrameData_Store(batchnumvertices * sizeof(float[3]), rsurface.batchnormal3f);
9257 // rsurface.batchnormal3f_vertexbuffer = NULL;
9258 // rsurface.batchnormal3f_bufferoffset = 0;
9259 for (j = 0;j < batchnumvertices;j++)
9261 scale = sin(rsurface.batchtexcoordtexture2f[j*2+0] * deform->parms[0] + rsurface.shadertime * deform->parms[2]) * deform->parms[1];
9262 VectorMA(rsurface.batchvertex3f + 3*j, scale, rsurface.batchnormal3f + 3*j, rsurface.batchvertex3f + 3*j);
9264 // if we get here, BATCHNEED_ARRAY_NORMAL is in batchneed, so no need to check
9265 Mod_BuildNormals(rsurface.batchfirstvertex, batchnumvertices, batchnumtriangles, rsurface.batchvertex3f, rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle, rsurface.batchnormal3f, r_smoothnormals_areaweighting.integer != 0);
9266 if(batchneed & BATCHNEED_ARRAY_VECTOR) // otherwise these can stay NULL
9268 // rsurface.batchsvector3f = R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
9269 // rsurface.batchsvector3f_vertexbuffer = NULL;
9270 // rsurface.batchsvector3f_bufferoffset = 0;
9271 // rsurface.batchtvector3f = R_FrameData_Alloc(batchnumvertices * sizeof(float[3]));
9272 // rsurface.batchtvector3f_vertexbuffer = NULL;
9273 // rsurface.batchtvector3f_bufferoffset = 0;
9274 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);
9278 // deform vertex array
9279 if(!R_TestQ3WaveFunc(deform->wavefunc, deform->waveparms))
9280 break; // if wavefunc is a nop, don't make a dynamic vertex array
9281 scale = R_EvaluateQ3WaveFunc(deform->wavefunc, deform->waveparms);
9282 VectorScale(deform->parms, scale, waveparms);
9283 // rsurface.batchvertex3f = R_FrameData_Store(batchnumvertices * sizeof(float[3]), rsurface.batchvertex3f);
9284 // rsurface.batchvertex3f_vertexbuffer = NULL;
9285 // rsurface.batchvertex3f_bufferoffset = 0;
9286 for (j = 0;j < batchnumvertices;j++)
9287 VectorAdd(rsurface.batchvertex3f + 3*j, waveparms, rsurface.batchvertex3f + 3*j);
9292 // generate texcoords based on the chosen texcoord source
9293 switch(rsurface.texture->tcgen.tcgen)
9296 case Q3TCGEN_TEXTURE:
9298 case Q3TCGEN_LIGHTMAP:
9299 // rsurface.batchtexcoordtexture2f = R_FrameData_Alloc(batchnumvertices * sizeof(float[2]));
9300 // rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
9301 // rsurface.batchtexcoordtexture2f_bufferoffset = 0;
9302 if (rsurface.batchtexcoordlightmap2f)
9303 memcpy(rsurface.batchtexcoordlightmap2f, rsurface.batchtexcoordtexture2f, batchnumvertices * sizeof(float[2]));
9305 case Q3TCGEN_VECTOR:
9306 // rsurface.batchtexcoordtexture2f = R_FrameData_Alloc(batchnumvertices * sizeof(float[2]));
9307 // rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
9308 // rsurface.batchtexcoordtexture2f_bufferoffset = 0;
9309 for (j = 0;j < batchnumvertices;j++)
9311 rsurface.batchtexcoordtexture2f[j*2+0] = DotProduct(rsurface.batchvertex3f + 3*j, rsurface.texture->tcgen.parms);
9312 rsurface.batchtexcoordtexture2f[j*2+1] = DotProduct(rsurface.batchvertex3f + 3*j, rsurface.texture->tcgen.parms + 3);
9315 case Q3TCGEN_ENVIRONMENT:
9316 // make environment reflections using a spheremap
9317 rsurface.batchtexcoordtexture2f = (float *)R_FrameData_Alloc(batchnumvertices * sizeof(float[2]));
9318 rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
9319 rsurface.batchtexcoordtexture2f_bufferoffset = 0;
9320 for (j = 0;j < batchnumvertices;j++)
9322 // identical to Q3A's method, but executed in worldspace so
9323 // carried models can be shiny too
9325 float viewer[3], d, reflected[3], worldreflected[3];
9327 VectorSubtract(rsurface.localvieworigin, rsurface.batchvertex3f + 3*j, viewer);
9328 // VectorNormalize(viewer);
9330 d = DotProduct(rsurface.batchnormal3f + 3*j, viewer);
9332 reflected[0] = rsurface.batchnormal3f[j*3+0]*2*d - viewer[0];
9333 reflected[1] = rsurface.batchnormal3f[j*3+1]*2*d - viewer[1];
9334 reflected[2] = rsurface.batchnormal3f[j*3+2]*2*d - viewer[2];
9335 // note: this is proportinal to viewer, so we can normalize later
9337 Matrix4x4_Transform3x3(&rsurface.matrix, reflected, worldreflected);
9338 VectorNormalize(worldreflected);
9340 // note: this sphere map only uses world x and z!
9341 // so positive and negative y will LOOK THE SAME.
9342 rsurface.batchtexcoordtexture2f[j*2+0] = 0.5 + 0.5 * worldreflected[1];
9343 rsurface.batchtexcoordtexture2f[j*2+1] = 0.5 - 0.5 * worldreflected[2];
9347 // the only tcmod that needs software vertex processing is turbulent, so
9348 // check for it here and apply the changes if needed
9349 // and we only support that as the first one
9350 // (handling a mixture of turbulent and other tcmods would be problematic
9351 // without punting it entirely to a software path)
9352 if (rsurface.texture->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
9354 amplitude = rsurface.texture->tcmods[0].parms[1];
9355 animpos = rsurface.texture->tcmods[0].parms[2] + rsurface.shadertime * rsurface.texture->tcmods[0].parms[3];
9356 // rsurface.batchtexcoordtexture2f = R_FrameData_Alloc(batchnumvertices * sizeof(float[2]));
9357 // rsurface.batchtexcoordtexture2f_vertexbuffer = NULL;
9358 // rsurface.batchtexcoordtexture2f_bufferoffset = 0;
9359 for (j = 0;j < batchnumvertices;j++)
9361 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);
9362 rsurface.batchtexcoordtexture2f[j*2+1] += amplitude * sin(((rsurface.batchvertex3f[j*3+1] ) * 1.0 / 1024.0f + animpos) * M_PI * 2);
9366 if (needsupdate & batchneed & (BATCHNEED_VERTEXMESH_VERTEX | BATCHNEED_VERTEXMESH_NORMAL | BATCHNEED_VERTEXMESH_VECTOR | BATCHNEED_VERTEXMESH_VERTEXCOLOR | BATCHNEED_VERTEXMESH_TEXCOORD | BATCHNEED_VERTEXMESH_LIGHTMAP))
9368 // convert the modified arrays to vertex structs
9369 // rsurface.batchvertexmesh = R_FrameData_Alloc(batchnumvertices * sizeof(r_vertexmesh_t));
9370 // rsurface.batchvertexmeshbuffer = NULL;
9371 if (batchneed & BATCHNEED_VERTEXMESH_VERTEX)
9372 for (j = 0, vertexmesh = rsurface.batchvertexmesh;j < batchnumvertices;j++, vertexmesh++)
9373 VectorCopy(rsurface.batchvertex3f + 3*j, vertexmesh->vertex3f);
9374 if (batchneed & BATCHNEED_VERTEXMESH_NORMAL)
9375 for (j = 0, vertexmesh = rsurface.batchvertexmesh;j < batchnumvertices;j++, vertexmesh++)
9376 VectorCopy(rsurface.batchnormal3f + 3*j, vertexmesh->normal3f);
9377 if (batchneed & BATCHNEED_VERTEXMESH_VECTOR)
9379 for (j = 0, vertexmesh = rsurface.batchvertexmesh;j < batchnumvertices;j++, vertexmesh++)
9381 VectorCopy(rsurface.batchsvector3f + 3*j, vertexmesh->svector3f);
9382 VectorCopy(rsurface.batchtvector3f + 3*j, vertexmesh->tvector3f);
9385 if ((batchneed & BATCHNEED_VERTEXMESH_VERTEXCOLOR) && rsurface.batchlightmapcolor4f)
9386 for (j = 0, vertexmesh = rsurface.batchvertexmesh;j < batchnumvertices;j++, vertexmesh++)
9387 Vector4Copy(rsurface.batchlightmapcolor4f + 4*j, vertexmesh->color4f);
9388 if (batchneed & BATCHNEED_VERTEXMESH_TEXCOORD)
9389 for (j = 0, vertexmesh = rsurface.batchvertexmesh;j < batchnumvertices;j++, vertexmesh++)
9390 Vector2Copy(rsurface.batchtexcoordtexture2f + 2*j, vertexmesh->texcoordtexture2f);
9391 if ((batchneed & BATCHNEED_VERTEXMESH_LIGHTMAP) && rsurface.batchtexcoordlightmap2f)
9392 for (j = 0, vertexmesh = rsurface.batchvertexmesh;j < batchnumvertices;j++, vertexmesh++)
9393 Vector2Copy(rsurface.batchtexcoordlightmap2f + 2*j, vertexmesh->texcoordlightmap2f);
9397 void RSurf_DrawBatch(void)
9399 // sometimes a zero triangle surface (usually a degenerate patch) makes it
9400 // through the pipeline, killing it earlier in the pipeline would have
9401 // per-surface overhead rather than per-batch overhead, so it's best to
9402 // reject it here, before it hits glDraw.
9403 if (rsurface.batchnumtriangles == 0)
9406 // batch debugging code
9407 if (r_test.integer && rsurface.entity == r_refdef.scene.worldentity && rsurface.batchvertex3f == r_refdef.scene.worldentity->model->surfmesh.data_vertex3f)
9413 e = rsurface.batchelement3i + rsurface.batchfirsttriangle*3;
9414 for (i = 0;i < rsurface.batchnumtriangles*3;i++)
9417 for (j = 0;j < rsurface.entity->model->num_surfaces;j++)
9419 if (c >= rsurface.modelsurfaces[j].num_firstvertex && c < (rsurface.modelsurfaces[j].num_firstvertex + rsurface.modelsurfaces[j].num_vertices))
9421 if (rsurface.modelsurfaces[j].texture != rsurface.texture)
9422 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);
9429 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);
9432 static int RSurf_FindWaterPlaneForSurface(const msurface_t *surface)
9434 // pick the closest matching water plane
9435 int planeindex, vertexindex, bestplaneindex = -1;
9439 r_waterstate_waterplane_t *p;
9440 qboolean prepared = false;
9442 for (planeindex = 0, p = r_fb.water.waterplanes;planeindex < r_fb.water.numwaterplanes;planeindex++, p++)
9444 if(p->camera_entity != rsurface.texture->camera_entity)
9449 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, 1, &surface);
9451 if(rsurface.batchnumvertices == 0)
9454 for (vertexindex = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3;vertexindex < rsurface.batchnumvertices;vertexindex++, v += 3)
9456 Matrix4x4_Transform(&rsurface.matrix, v, vert);
9457 d += fabs(PlaneDiff(vert, &p->plane));
9459 if (bestd > d || bestplaneindex < 0)
9462 bestplaneindex = planeindex;
9465 return bestplaneindex;
9466 // NOTE: this MAY return a totally unrelated water plane; we can ignore
9467 // this situation though, as it might be better to render single larger
9468 // batches with useless stuff (backface culled for example) than to
9469 // render multiple smaller batches
9472 static void RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray(void)
9475 rsurface.passcolor4f = (float *)R_FrameData_Alloc(rsurface.batchnumvertices * sizeof(float[4]));
9476 rsurface.passcolor4f_vertexbuffer = 0;
9477 rsurface.passcolor4f_bufferoffset = 0;
9478 for (i = 0;i < rsurface.batchnumvertices;i++)
9479 Vector4Set(rsurface.passcolor4f + 4*i, 0.5f, 0.5f, 0.5f, 1.0f);
9482 static void RSurf_DrawBatch_GL11_ApplyFog(void)
9489 if (rsurface.passcolor4f)
9491 // generate color arrays
9492 c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;
9493 rsurface.passcolor4f = (float *)R_FrameData_Alloc(rsurface.batchnumvertices * sizeof(float[4]));
9494 rsurface.passcolor4f_vertexbuffer = 0;
9495 rsurface.passcolor4f_bufferoffset = 0;
9496 for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4, c2 = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, c += 4, c2 += 4)
9498 f = RSurf_FogVertex(v);
9507 rsurface.passcolor4f = (float *)R_FrameData_Alloc(rsurface.batchnumvertices * sizeof(float[4]));
9508 rsurface.passcolor4f_vertexbuffer = 0;
9509 rsurface.passcolor4f_bufferoffset = 0;
9510 for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, c2 = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, c2 += 4)
9512 f = RSurf_FogVertex(v);
9521 static void RSurf_DrawBatch_GL11_ApplyFogToFinishedVertexColors(void)
9528 if (!rsurface.passcolor4f)
9530 c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;
9531 rsurface.passcolor4f = (float *)R_FrameData_Alloc(rsurface.batchnumvertices * sizeof(float[4]));
9532 rsurface.passcolor4f_vertexbuffer = 0;
9533 rsurface.passcolor4f_bufferoffset = 0;
9534 for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, c2 = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, c += 4, c2 += 4)
9536 f = RSurf_FogVertex(v);
9537 c2[0] = c[0] * f + r_refdef.fogcolor[0] * (1 - f);
9538 c2[1] = c[1] * f + r_refdef.fogcolor[1] * (1 - f);
9539 c2[2] = c[2] * f + r_refdef.fogcolor[2] * (1 - f);
9544 static void RSurf_DrawBatch_GL11_ApplyColor(float r, float g, float b, float a)
9549 if (!rsurface.passcolor4f)
9551 c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;
9552 rsurface.passcolor4f = (float *)R_FrameData_Alloc(rsurface.batchnumvertices * sizeof(float[4]));
9553 rsurface.passcolor4f_vertexbuffer = 0;
9554 rsurface.passcolor4f_bufferoffset = 0;
9555 for (i = 0, c2 = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, c += 4, c2 += 4)
9564 static void RSurf_DrawBatch_GL11_ApplyAmbient(void)
9569 if (!rsurface.passcolor4f)
9571 c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;
9572 rsurface.passcolor4f = (float *)R_FrameData_Alloc(rsurface.batchnumvertices * sizeof(float[4]));
9573 rsurface.passcolor4f_vertexbuffer = 0;
9574 rsurface.passcolor4f_bufferoffset = 0;
9575 for (i = 0, c2 = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, c += 4, c2 += 4)
9577 c2[0] = c[0] + r_refdef.scene.ambient;
9578 c2[1] = c[1] + r_refdef.scene.ambient;
9579 c2[2] = c[2] + r_refdef.scene.ambient;
9584 static void RSurf_DrawBatch_GL11_Lightmap(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
9587 rsurface.passcolor4f = NULL;
9588 rsurface.passcolor4f_vertexbuffer = 0;
9589 rsurface.passcolor4f_bufferoffset = 0;
9590 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog();
9591 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
9592 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
9593 GL_Color(r, g, b, a);
9594 R_Mesh_TexBind(0, rsurface.lightmaptexture);
9598 static void RSurf_DrawBatch_GL11_Unlit(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
9600 // TODO: optimize applyfog && applycolor case
9601 // just apply fog if necessary, and tint the fog color array if necessary
9602 rsurface.passcolor4f = NULL;
9603 rsurface.passcolor4f_vertexbuffer = 0;
9604 rsurface.passcolor4f_bufferoffset = 0;
9605 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog();
9606 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
9607 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
9608 GL_Color(r, g, b, a);
9612 static void RSurf_DrawBatch_GL11_VertexColor(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
9615 rsurface.passcolor4f = rsurface.batchlightmapcolor4f;
9616 rsurface.passcolor4f_vertexbuffer = rsurface.batchlightmapcolor4f_vertexbuffer;
9617 rsurface.passcolor4f_bufferoffset = rsurface.batchlightmapcolor4f_bufferoffset;
9618 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog();
9619 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
9620 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
9621 GL_Color(r, g, b, a);
9625 static void RSurf_DrawBatch_GL11_ClampColor(void)
9630 if (!rsurface.passcolor4f)
9632 for (i = 0, c1 = rsurface.passcolor4f + 4*rsurface.batchfirstvertex, c2 = rsurface.passcolor4f + 4*rsurface.batchfirstvertex;i < rsurface.batchnumvertices;i++, c1 += 4, c2 += 4)
9634 c2[0] = bound(0.0f, c1[0], 1.0f);
9635 c2[1] = bound(0.0f, c1[1], 1.0f);
9636 c2[2] = bound(0.0f, c1[2], 1.0f);
9637 c2[3] = bound(0.0f, c1[3], 1.0f);
9641 static void RSurf_DrawBatch_GL11_ApplyFakeLight(void)
9651 rsurface.passcolor4f = (float *)R_FrameData_Alloc(rsurface.batchnumvertices * sizeof(float[4]));
9652 rsurface.passcolor4f_vertexbuffer = 0;
9653 rsurface.passcolor4f_bufferoffset = 0;
9654 for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, n = rsurface.batchnormal3f + rsurface.batchfirstvertex * 3, c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, n += 3, c += 4)
9656 f = -DotProduct(r_refdef.view.forward, n);
9658 f = f * 0.85 + 0.15; // work around so stuff won't get black
9659 f *= r_refdef.lightmapintensity;
9660 Vector4Set(c, f, f, f, 1);
9664 static void RSurf_DrawBatch_GL11_FakeLight(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
9666 RSurf_DrawBatch_GL11_ApplyFakeLight();
9667 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog();
9668 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
9669 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
9670 GL_Color(r, g, b, a);
9674 static void RSurf_DrawBatch_GL11_ApplyVertexShade(float *r, float *g, float *b, float *a, qboolean *applycolor)
9682 vec3_t ambientcolor;
9683 vec3_t diffusecolor;
9687 VectorCopy(rsurface.modellight_lightdir, lightdir);
9688 f = 0.5f * r_refdef.lightmapintensity;
9689 ambientcolor[0] = rsurface.modellight_ambient[0] * *r * f;
9690 ambientcolor[1] = rsurface.modellight_ambient[1] * *g * f;
9691 ambientcolor[2] = rsurface.modellight_ambient[2] * *b * f;
9692 diffusecolor[0] = rsurface.modellight_diffuse[0] * *r * f;
9693 diffusecolor[1] = rsurface.modellight_diffuse[1] * *g * f;
9694 diffusecolor[2] = rsurface.modellight_diffuse[2] * *b * f;
9696 if (VectorLength2(diffusecolor) > 0)
9698 // q3-style directional shading
9699 rsurface.passcolor4f = (float *)R_FrameData_Alloc(rsurface.batchnumvertices * sizeof(float[4]));
9700 rsurface.passcolor4f_vertexbuffer = 0;
9701 rsurface.passcolor4f_bufferoffset = 0;
9702 for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, n = rsurface.batchnormal3f + rsurface.batchfirstvertex * 3, c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, n += 3, c += 4)
9704 if ((f = DotProduct(n, lightdir)) > 0)
9705 VectorMA(ambientcolor, f, diffusecolor, c);
9707 VectorCopy(ambientcolor, c);
9714 *applycolor = false;
9718 *r = ambientcolor[0];
9719 *g = ambientcolor[1];
9720 *b = ambientcolor[2];
9721 rsurface.passcolor4f = NULL;
9722 rsurface.passcolor4f_vertexbuffer = 0;
9723 rsurface.passcolor4f_bufferoffset = 0;
9727 static void RSurf_DrawBatch_GL11_VertexShade(float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
9729 RSurf_DrawBatch_GL11_ApplyVertexShade(&r, &g, &b, &a, &applycolor);
9730 if (applyfog) RSurf_DrawBatch_GL11_ApplyFog();
9731 if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(r, g, b, a);
9732 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, rsurface.passcolor4f_vertexbuffer, rsurface.passcolor4f_bufferoffset);
9733 GL_Color(r, g, b, a);
9737 static void RSurf_DrawBatch_GL11_MakeFogColor(float r, float g, float b, float a)
9745 rsurface.passcolor4f = (float *)R_FrameData_Alloc(rsurface.batchnumvertices * sizeof(float[4]));
9746 rsurface.passcolor4f_vertexbuffer = 0;
9747 rsurface.passcolor4f_bufferoffset = 0;
9749 for (i = 0, v = rsurface.batchvertex3f + rsurface.batchfirstvertex * 3, c = rsurface.passcolor4f + rsurface.batchfirstvertex * 4;i < rsurface.batchnumvertices;i++, v += 3, c += 4)
9751 f = 1 - RSurf_FogVertex(v);
9759 void RSurf_SetupDepthAndCulling(void)
9761 // submodels are biased to avoid z-fighting with world surfaces that they
9762 // may be exactly overlapping (avoids z-fighting artifacts on certain
9763 // doors and things in Quake maps)
9764 GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
9765 GL_PolygonOffset(rsurface.basepolygonfactor + rsurface.texture->biaspolygonfactor, rsurface.basepolygonoffset + rsurface.texture->biaspolygonoffset);
9766 GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
9767 GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_refdef.view.cullface_back);
9770 static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, const msurface_t **texturesurfacelist)
9772 // transparent sky would be ridiculous
9773 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
9775 R_SetupShader_Generic_NoTexture(false, false);
9776 skyrenderlater = true;
9777 RSurf_SetupDepthAndCulling();
9779 // LordHavoc: HalfLife maps have freaky skypolys so don't use
9780 // skymasking on them, and Quake3 never did sky masking (unlike
9781 // software Quake and software Quake2), so disable the sky masking
9782 // in Quake3 maps as it causes problems with q3map2 sky tricks,
9783 // and skymasking also looks very bad when noclipping outside the
9784 // level, so don't use it then either.
9785 if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->type == mod_brushq1 && r_q1bsp_skymasking.integer && !r_refdef.viewcache.world_novis && !r_trippy.integer)
9787 R_Mesh_ResetTextureState();
9788 if (skyrendermasked)
9790 R_SetupShader_DepthOrShadow(false, false);
9791 // depth-only (masking)
9792 GL_ColorMask(0,0,0,0);
9793 // just to make sure that braindead drivers don't draw
9794 // anything despite that colormask...
9795 GL_BlendFunc(GL_ZERO, GL_ONE);
9796 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
9797 if (rsurface.batchvertex3fbuffer)
9798 R_Mesh_PrepareVertices_Vertex3f(rsurface.batchnumvertices, rsurface.batchvertex3f, rsurface.batchvertex3fbuffer);
9800 R_Mesh_PrepareVertices_Vertex3f(rsurface.batchnumvertices, rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer);
9804 R_SetupShader_Generic_NoTexture(false, false);
9806 GL_BlendFunc(GL_ONE, GL_ZERO);
9807 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
9808 GL_Color(r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2], 1);
9809 R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, NULL, NULL);
9812 if (skyrendermasked)
9813 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
9815 R_Mesh_ResetTextureState();
9816 GL_Color(1, 1, 1, 1);
9819 extern rtexture_t *r_shadow_prepasslightingdiffusetexture;
9820 extern rtexture_t *r_shadow_prepasslightingspeculartexture;
9821 static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
9823 if (r_fb.water.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA)))
9827 // render screenspace normalmap to texture
9829 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_DEFERREDGEOMETRY, texturenumsurfaces, texturesurfacelist, NULL, false);
9834 // bind lightmap texture
9836 // water/refraction/reflection/camera surfaces have to be handled specially
9837 if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_CAMERA | MATERIALFLAG_REFLECTION)))
9839 int start, end, startplaneindex;
9840 for (start = 0;start < texturenumsurfaces;start = end)
9842 startplaneindex = RSurf_FindWaterPlaneForSurface(texturesurfacelist[start]);
9843 if(startplaneindex < 0)
9845 // this happens if the plane e.g. got backface culled and thus didn't get a water plane. We can just ignore this.
9846 // Con_Printf("No matching water plane for surface with material flags 0x%08x - PLEASE DEBUG THIS\n", rsurface.texture->currentmaterialflags);
9850 for (end = start + 1;end < texturenumsurfaces && startplaneindex == RSurf_FindWaterPlaneForSurface(texturesurfacelist[end]);end++)
9852 // now that we have a batch using the same planeindex, render it
9853 if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_CAMERA)))
9855 // render water or distortion background
9857 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BACKGROUND, end-start, texturesurfacelist + start, (void *)(r_fb.water.waterplanes + startplaneindex), false);
9859 // blend surface on top
9860 GL_DepthMask(false);
9861 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE, end-start, texturesurfacelist + start, NULL, false);
9864 else if ((rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION))
9866 // render surface with reflection texture as input
9867 GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED));
9868 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE, end-start, texturesurfacelist + start, (void *)(r_fb.water.waterplanes + startplaneindex), false);
9875 // render surface batch normally
9876 GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED));
9877 R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE, texturenumsurfaces, texturesurfacelist, NULL, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY) != 0);
9881 static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
9883 // OpenGL 1.3 path - anything not completely ancient
9884 qboolean applycolor;
9887 const texturelayer_t *layer;
9888 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | ((!rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) ? BATCHNEED_ARRAY_VERTEXCOLOR : 0) | BATCHNEED_ARRAY_TEXCOORD | (rsurface.modeltexcoordlightmap2f ? BATCHNEED_ARRAY_LIGHTMAP : 0) | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
9889 R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
9891 for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
9894 int layertexrgbscale;
9895 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
9897 if (layerindex == 0)
9901 GL_AlphaTest(false);
9902 GL_DepthFunc(GL_EQUAL);
9905 GL_DepthMask(layer->depthmask && writedepth);
9906 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
9907 if (layer->color[0] > 2 || layer->color[1] > 2 || layer->color[2] > 2)
9909 layertexrgbscale = 4;
9910 VectorScale(layer->color, 0.25f, layercolor);
9912 else if (layer->color[0] > 1 || layer->color[1] > 1 || layer->color[2] > 1)
9914 layertexrgbscale = 2;
9915 VectorScale(layer->color, 0.5f, layercolor);
9919 layertexrgbscale = 1;
9920 VectorScale(layer->color, 1.0f, layercolor);
9922 layercolor[3] = layer->color[3];
9923 applycolor = layercolor[0] != 1 || layercolor[1] != 1 || layercolor[2] != 1 || layercolor[3] != 1;
9924 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, 0, 0);
9925 applyfog = r_refdef.fogenabled && (rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED);
9926 switch (layer->type)
9928 case TEXTURELAYERTYPE_LITTEXTURE:
9929 // single-pass lightmapped texture with 2x rgbscale
9930 R_Mesh_TexBind(0, r_texture_white);
9931 R_Mesh_TexMatrix(0, NULL);
9932 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
9933 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordlightmap2f, rsurface.batchtexcoordlightmap2f_vertexbuffer, rsurface.batchtexcoordlightmap2f_bufferoffset);
9934 R_Mesh_TexBind(1, layer->texture);
9935 R_Mesh_TexMatrix(1, &layer->texmatrix);
9936 R_Mesh_TexCombine(1, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
9937 R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
9938 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
9939 RSurf_DrawBatch_GL11_VertexShade(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
9940 else if (FAKELIGHT_ENABLED)
9941 RSurf_DrawBatch_GL11_FakeLight(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
9942 else if (rsurface.uselightmaptexture)
9943 RSurf_DrawBatch_GL11_Lightmap(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
9945 RSurf_DrawBatch_GL11_VertexColor(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
9947 case TEXTURELAYERTYPE_TEXTURE:
9948 // singletexture unlit texture with transparency support
9949 R_Mesh_TexBind(0, layer->texture);
9950 R_Mesh_TexMatrix(0, &layer->texmatrix);
9951 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
9952 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
9953 R_Mesh_TexBind(1, 0);
9954 R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, 0, 0);
9955 RSurf_DrawBatch_GL11_Unlit(layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
9957 case TEXTURELAYERTYPE_FOG:
9958 // singletexture fogging
9961 R_Mesh_TexBind(0, layer->texture);
9962 R_Mesh_TexMatrix(0, &layer->texmatrix);
9963 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, layertexrgbscale, 1);
9964 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
9968 R_Mesh_TexBind(0, 0);
9969 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, 0, 0);
9971 R_Mesh_TexBind(1, 0);
9972 R_Mesh_TexCoordPointer(1, 2, GL_FLOAT, sizeof(float[2]), NULL, 0, 0);
9973 // generate a color array for the fog pass
9974 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, 0, 0);
9975 RSurf_DrawBatch_GL11_MakeFogColor(layercolor[0], layercolor[1], layercolor[2], layercolor[3]);
9979 Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
9982 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
9984 GL_DepthFunc(GL_LEQUAL);
9985 GL_AlphaTest(false);
9989 static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
9991 // OpenGL 1.1 - crusty old voodoo path
9994 const texturelayer_t *layer;
9995 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | ((!rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) ? BATCHNEED_ARRAY_VERTEXCOLOR : 0) | BATCHNEED_ARRAY_TEXCOORD | (rsurface.modeltexcoordlightmap2f ? BATCHNEED_ARRAY_LIGHTMAP : 0) | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
9996 R_Mesh_VertexPointer(3, GL_FLOAT, sizeof(float[3]), rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer, rsurface.batchvertex3f_bufferoffset);
9998 for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++)
10000 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
10002 if (layerindex == 0)
10003 GL_AlphaTest(true);
10006 GL_AlphaTest(false);
10007 GL_DepthFunc(GL_EQUAL);
10010 GL_DepthMask(layer->depthmask && writedepth);
10011 GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
10012 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), NULL, 0, 0);
10013 applyfog = r_refdef.fogenabled && (rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED);
10014 switch (layer->type)
10016 case TEXTURELAYERTYPE_LITTEXTURE:
10017 if (layer->blendfunc1 == GL_ONE && layer->blendfunc2 == GL_ZERO)
10019 // two-pass lit texture with 2x rgbscale
10020 // first the lightmap pass
10021 R_Mesh_TexBind(0, r_texture_white);
10022 R_Mesh_TexMatrix(0, NULL);
10023 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
10024 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordlightmap2f, rsurface.batchtexcoordlightmap2f_vertexbuffer, rsurface.batchtexcoordlightmap2f_bufferoffset);
10025 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
10026 RSurf_DrawBatch_GL11_VertexShade(1, 1, 1, 1, false, false);
10027 else if (FAKELIGHT_ENABLED)
10028 RSurf_DrawBatch_GL11_FakeLight(1, 1, 1, 1, false, false);
10029 else if (rsurface.uselightmaptexture)
10030 RSurf_DrawBatch_GL11_Lightmap(1, 1, 1, 1, false, false);
10032 RSurf_DrawBatch_GL11_VertexColor(1, 1, 1, 1, false, false);
10033 // then apply the texture to it
10034 GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
10035 R_Mesh_TexBind(0, layer->texture);
10036 R_Mesh_TexMatrix(0, &layer->texmatrix);
10037 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
10038 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
10039 RSurf_DrawBatch_GL11_Unlit(layer->color[0] * 0.5f, layer->color[1] * 0.5f, layer->color[2] * 0.5f, layer->color[3], layer->color[0] != 2 || layer->color[1] != 2 || layer->color[2] != 2 || layer->color[3] != 1, false);
10043 // single pass vertex-lighting-only texture with 1x rgbscale and transparency support
10044 R_Mesh_TexBind(0, layer->texture);
10045 R_Mesh_TexMatrix(0, &layer->texmatrix);
10046 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
10047 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
10048 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
10049 RSurf_DrawBatch_GL11_VertexShade(layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog);
10051 RSurf_DrawBatch_GL11_VertexColor(layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog);
10054 case TEXTURELAYERTYPE_TEXTURE:
10055 // singletexture unlit texture with transparency support
10056 R_Mesh_TexBind(0, layer->texture);
10057 R_Mesh_TexMatrix(0, &layer->texmatrix);
10058 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
10059 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
10060 RSurf_DrawBatch_GL11_Unlit(layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog);
10062 case TEXTURELAYERTYPE_FOG:
10063 // singletexture fogging
10064 if (layer->texture)
10066 R_Mesh_TexBind(0, layer->texture);
10067 R_Mesh_TexMatrix(0, &layer->texmatrix);
10068 R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1);
10069 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), rsurface.batchtexcoordtexture2f, rsurface.batchtexcoordtexture2f_vertexbuffer, rsurface.batchtexcoordtexture2f_bufferoffset);
10073 R_Mesh_TexBind(0, 0);
10074 R_Mesh_TexCoordPointer(0, 2, GL_FLOAT, sizeof(float[2]), NULL, 0, 0);
10076 // generate a color array for the fog pass
10077 R_Mesh_ColorPointer(4, GL_FLOAT, sizeof(float[4]), rsurface.passcolor4f, 0, 0);
10078 RSurf_DrawBatch_GL11_MakeFogColor(layer->color[0], layer->color[1], layer->color[2], layer->color[3]);
10082 Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
10085 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
10087 GL_DepthFunc(GL_LEQUAL);
10088 GL_AlphaTest(false);
10092 static void R_DrawTextureSurfaceList_ShowSurfaces(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth)
10096 r_vertexgeneric_t *batchvertex;
10099 // R_Mesh_ResetTextureState();
10100 R_SetupShader_Generic_NoTexture(false, false);
10102 if(rsurface.texture && rsurface.texture->currentskinframe)
10104 memcpy(c, rsurface.texture->currentskinframe->avgcolor, sizeof(c));
10105 c[3] *= rsurface.texture->currentalpha;
10115 if (rsurface.texture->pantstexture || rsurface.texture->shirttexture)
10117 c[0] = 0.5 * (rsurface.colormap_pantscolor[0] * 0.3 + rsurface.colormap_shirtcolor[0] * 0.7);
10118 c[1] = 0.5 * (rsurface.colormap_pantscolor[1] * 0.3 + rsurface.colormap_shirtcolor[1] * 0.7);
10119 c[2] = 0.5 * (rsurface.colormap_pantscolor[2] * 0.3 + rsurface.colormap_shirtcolor[2] * 0.7);
10122 // brighten it up (as texture value 127 means "unlit")
10123 c[0] *= 2 * r_refdef.view.colorscale;
10124 c[1] *= 2 * r_refdef.view.colorscale;
10125 c[2] *= 2 * r_refdef.view.colorscale;
10127 if(rsurface.texture->currentmaterialflags & MATERIALFLAG_WATERALPHA)
10128 c[3] *= r_wateralpha.value;
10130 if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHA && c[3] != 1)
10132 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
10133 GL_DepthMask(false);
10135 else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)
10137 GL_BlendFunc(GL_ONE, GL_ONE);
10138 GL_DepthMask(false);
10140 else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
10142 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // can't do alpha test without texture, so let's blend instead
10143 GL_DepthMask(false);
10145 else if(rsurface.texture->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
10147 GL_BlendFunc(rsurface.texture->customblendfunc[0], rsurface.texture->customblendfunc[1]);
10148 GL_DepthMask(false);
10152 GL_BlendFunc(GL_ONE, GL_ZERO);
10153 GL_DepthMask(writedepth);
10156 if (r_showsurfaces.integer == 3)
10158 rsurface.passcolor4f = NULL;
10160 if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
10162 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
10164 rsurface.passcolor4f = NULL;
10165 rsurface.passcolor4f_vertexbuffer = 0;
10166 rsurface.passcolor4f_bufferoffset = 0;
10168 else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT)
10170 qboolean applycolor = true;
10173 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
10175 r_refdef.lightmapintensity = 1;
10176 RSurf_DrawBatch_GL11_ApplyVertexShade(&one, &one, &one, &one, &applycolor);
10177 r_refdef.lightmapintensity = 0; // we're in showsurfaces, after all
10179 else if (FAKELIGHT_ENABLED)
10181 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
10183 r_refdef.lightmapintensity = r_fakelight_intensity.value;
10184 RSurf_DrawBatch_GL11_ApplyFakeLight();
10185 r_refdef.lightmapintensity = 0; // we're in showsurfaces, after all
10189 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_VERTEXCOLOR | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
10191 rsurface.passcolor4f = rsurface.batchlightmapcolor4f;
10192 rsurface.passcolor4f_vertexbuffer = rsurface.batchlightmapcolor4f_vertexbuffer;
10193 rsurface.passcolor4f_bufferoffset = rsurface.batchlightmapcolor4f_bufferoffset;
10196 if(!rsurface.passcolor4f)
10197 RSurf_DrawBatch_GL11_MakeFullbrightLightmapColorArray();
10199 RSurf_DrawBatch_GL11_ApplyAmbient();
10200 RSurf_DrawBatch_GL11_ApplyColor(c[0], c[1], c[2], c[3]);
10201 if(r_refdef.fogenabled)
10202 RSurf_DrawBatch_GL11_ApplyFogToFinishedVertexColors();
10203 RSurf_DrawBatch_GL11_ClampColor();
10205 R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, rsurface.passcolor4f, NULL);
10206 R_SetupShader_Generic_NoTexture(false, false);
10209 else if (!r_refdef.view.showdebug)
10211 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
10212 batchvertex = R_Mesh_PrepareVertices_Generic_Lock(rsurface.batchnumvertices);
10213 for (j = 0, vi = rsurface.batchfirstvertex;j < rsurface.batchnumvertices;j++, vi++)
10215 VectorCopy(rsurface.batchvertex3f + 3*vi, batchvertex[vi].vertex3f);
10216 Vector4Set(batchvertex[vi].color4f, 0, 0, 0, 1);
10218 R_Mesh_PrepareVertices_Generic_Unlock();
10221 else if (r_showsurfaces.integer == 4)
10223 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
10224 batchvertex = R_Mesh_PrepareVertices_Generic_Lock(rsurface.batchnumvertices);
10225 for (j = 0, vi = rsurface.batchfirstvertex;j < rsurface.batchnumvertices;j++, vi++)
10227 unsigned char c = (vi << 3) * (1.0f / 256.0f);
10228 VectorCopy(rsurface.batchvertex3f + 3*vi, batchvertex[vi].vertex3f);
10229 Vector4Set(batchvertex[vi].color4f, c, c, c, 1);
10231 R_Mesh_PrepareVertices_Generic_Unlock();
10234 else if (r_showsurfaces.integer == 2)
10237 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
10238 batchvertex = R_Mesh_PrepareVertices_Generic_Lock(3*rsurface.batchnumtriangles);
10239 for (j = 0, e = rsurface.batchelement3i + 3 * rsurface.batchfirsttriangle;j < rsurface.batchnumtriangles;j++, e += 3)
10241 unsigned char c = ((j + rsurface.batchfirsttriangle) << 3) * (1.0f / 256.0f);
10242 VectorCopy(rsurface.batchvertex3f + 3*e[0], batchvertex[j*3+0].vertex3f);
10243 VectorCopy(rsurface.batchvertex3f + 3*e[1], batchvertex[j*3+1].vertex3f);
10244 VectorCopy(rsurface.batchvertex3f + 3*e[2], batchvertex[j*3+2].vertex3f);
10245 Vector4Set(batchvertex[j*3+0].color4f, c, c, c, 1);
10246 Vector4Set(batchvertex[j*3+1].color4f, c, c, c, 1);
10247 Vector4Set(batchvertex[j*3+2].color4f, c, c, c, 1);
10249 R_Mesh_PrepareVertices_Generic_Unlock();
10250 R_Mesh_Draw(0, rsurface.batchnumtriangles*3, 0, rsurface.batchnumtriangles, NULL, NULL, 0, NULL, NULL, 0);
10254 int texturesurfaceindex;
10256 const msurface_t *surface;
10257 float surfacecolor4f[4];
10258 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, texturenumsurfaces, texturesurfacelist);
10259 batchvertex = R_Mesh_PrepareVertices_Generic_Lock(rsurface.batchfirstvertex + rsurface.batchnumvertices);
10261 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
10263 surface = texturesurfacelist[texturesurfaceindex];
10264 k = (int)(((size_t)surface) / sizeof(msurface_t));
10265 Vector4Set(surfacecolor4f, (k & 0xF) * (1.0f / 16.0f), (k & 0xF0) * (1.0f / 256.0f), (k & 0xF00) * (1.0f / 4096.0f), 1);
10266 for (j = 0;j < surface->num_vertices;j++)
10268 VectorCopy(rsurface.batchvertex3f + 3*vi, batchvertex[vi].vertex3f);
10269 Vector4Copy(surfacecolor4f, batchvertex[vi].color4f);
10273 R_Mesh_PrepareVertices_Generic_Unlock();
10278 static void R_DrawWorldTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
10281 RSurf_SetupDepthAndCulling();
10282 if (r_showsurfaces.integer)
10284 R_DrawTextureSurfaceList_ShowSurfaces(texturenumsurfaces, texturesurfacelist, writedepth);
10287 switch (vid.renderpath)
10289 case RENDERPATH_GL20:
10290 case RENDERPATH_D3D9:
10291 case RENDERPATH_D3D10:
10292 case RENDERPATH_D3D11:
10293 case RENDERPATH_SOFT:
10294 case RENDERPATH_GLES2:
10295 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
10297 case RENDERPATH_GL13:
10298 case RENDERPATH_GLES1:
10299 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth);
10301 case RENDERPATH_GL11:
10302 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth);
10308 static void R_DrawModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass)
10311 RSurf_SetupDepthAndCulling();
10312 if (r_showsurfaces.integer)
10314 R_DrawTextureSurfaceList_ShowSurfaces(texturenumsurfaces, texturesurfacelist, writedepth);
10317 switch (vid.renderpath)
10319 case RENDERPATH_GL20:
10320 case RENDERPATH_D3D9:
10321 case RENDERPATH_D3D10:
10322 case RENDERPATH_D3D11:
10323 case RENDERPATH_SOFT:
10324 case RENDERPATH_GLES2:
10325 R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
10327 case RENDERPATH_GL13:
10328 case RENDERPATH_GLES1:
10329 R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist, writedepth);
10331 case RENDERPATH_GL11:
10332 R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist, writedepth);
10338 static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
10341 int texturenumsurfaces, endsurface;
10342 texture_t *texture;
10343 const msurface_t *surface;
10344 const msurface_t *texturesurfacelist[MESHQUEUE_TRANSPARENT_BATCHSIZE];
10346 // if the model is static it doesn't matter what value we give for
10347 // wantnormals and wanttangents, so this logic uses only rules applicable
10348 // to a model, knowing that they are meaningless otherwise
10349 if (ent == r_refdef.scene.worldentity)
10350 RSurf_ActiveWorldEntity();
10351 else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
10352 RSurf_ActiveModelEntity(ent, false, false, false);
10355 switch (vid.renderpath)
10357 case RENDERPATH_GL20:
10358 case RENDERPATH_D3D9:
10359 case RENDERPATH_D3D10:
10360 case RENDERPATH_D3D11:
10361 case RENDERPATH_SOFT:
10362 case RENDERPATH_GLES2:
10363 RSurf_ActiveModelEntity(ent, true, true, false);
10365 case RENDERPATH_GL11:
10366 case RENDERPATH_GL13:
10367 case RENDERPATH_GLES1:
10368 RSurf_ActiveModelEntity(ent, true, false, false);
10373 if (r_transparentdepthmasking.integer)
10375 qboolean setup = false;
10376 for (i = 0;i < numsurfaces;i = j)
10379 surface = rsurface.modelsurfaces + surfacelist[i];
10380 texture = surface->texture;
10381 rsurface.texture = R_GetCurrentTexture(texture);
10382 rsurface.lightmaptexture = NULL;
10383 rsurface.deluxemaptexture = NULL;
10384 rsurface.uselightmaptexture = false;
10385 // scan ahead until we find a different texture
10386 endsurface = min(i + 1024, numsurfaces);
10387 texturenumsurfaces = 0;
10388 texturesurfacelist[texturenumsurfaces++] = surface;
10389 for (;j < endsurface;j++)
10391 surface = rsurface.modelsurfaces + surfacelist[j];
10392 if (texture != surface->texture)
10394 texturesurfacelist[texturenumsurfaces++] = surface;
10396 if (!(rsurface.texture->currentmaterialflags & MATERIALFLAG_TRANSDEPTH))
10398 // render the range of surfaces as depth
10402 GL_ColorMask(0,0,0,0);
10404 GL_DepthTest(true);
10405 GL_BlendFunc(GL_ONE, GL_ZERO);
10406 GL_DepthMask(true);
10407 // R_Mesh_ResetTextureState();
10408 R_SetupShader_DepthOrShadow(false, false);
10410 RSurf_SetupDepthAndCulling();
10411 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX, texturenumsurfaces, texturesurfacelist);
10412 if (rsurface.batchvertex3fbuffer)
10413 R_Mesh_PrepareVertices_Vertex3f(rsurface.batchnumvertices, rsurface.batchvertex3f, rsurface.batchvertex3fbuffer);
10415 R_Mesh_PrepareVertices_Vertex3f(rsurface.batchnumvertices, rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer);
10419 GL_ColorMask(r_refdef.view.colormask[0], r_refdef.view.colormask[1], r_refdef.view.colormask[2], 1);
10422 for (i = 0;i < numsurfaces;i = j)
10425 surface = rsurface.modelsurfaces + surfacelist[i];
10426 texture = surface->texture;
10427 rsurface.texture = R_GetCurrentTexture(texture);
10428 // scan ahead until we find a different texture
10429 endsurface = min(i + MESHQUEUE_TRANSPARENT_BATCHSIZE, numsurfaces);
10430 texturenumsurfaces = 0;
10431 texturesurfacelist[texturenumsurfaces++] = surface;
10432 if(FAKELIGHT_ENABLED)
10434 rsurface.lightmaptexture = NULL;
10435 rsurface.deluxemaptexture = NULL;
10436 rsurface.uselightmaptexture = false;
10437 for (;j < endsurface;j++)
10439 surface = rsurface.modelsurfaces + surfacelist[j];
10440 if (texture != surface->texture)
10442 texturesurfacelist[texturenumsurfaces++] = surface;
10447 rsurface.lightmaptexture = surface->lightmaptexture;
10448 rsurface.deluxemaptexture = surface->deluxemaptexture;
10449 rsurface.uselightmaptexture = surface->lightmaptexture != NULL;
10450 for (;j < endsurface;j++)
10452 surface = rsurface.modelsurfaces + surfacelist[j];
10453 if (texture != surface->texture || rsurface.lightmaptexture != surface->lightmaptexture)
10455 texturesurfacelist[texturenumsurfaces++] = surface;
10458 // render the range of surfaces
10459 if (ent == r_refdef.scene.worldentity)
10460 R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, false, false);
10462 R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, false, false);
10464 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
10467 static void R_ProcessTransparentTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist)
10469 // transparent surfaces get pushed off into the transparent queue
10470 int surfacelistindex;
10471 const msurface_t *surface;
10472 vec3_t tempcenter, center;
10473 for (surfacelistindex = 0;surfacelistindex < texturenumsurfaces;surfacelistindex++)
10475 surface = texturesurfacelist[surfacelistindex];
10476 if (r_transparent_sortsurfacesbynearest.integer)
10478 tempcenter[0] = bound(surface->mins[0], rsurface.localvieworigin[0], surface->maxs[0]);
10479 tempcenter[1] = bound(surface->mins[1], rsurface.localvieworigin[1], surface->maxs[1]);
10480 tempcenter[2] = bound(surface->mins[2], rsurface.localvieworigin[2], surface->maxs[2]);
10484 tempcenter[0] = (surface->mins[0] + surface->maxs[0]) * 0.5f;
10485 tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f;
10486 tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f;
10488 Matrix4x4_Transform(&rsurface.matrix, tempcenter, center);
10489 if (rsurface.entity->transparent_offset) // transparent offset
10491 center[0] += r_refdef.view.forward[0]*rsurface.entity->transparent_offset;
10492 center[1] += r_refdef.view.forward[1]*rsurface.entity->transparent_offset;
10493 center[2] += r_refdef.view.forward[2]*rsurface.entity->transparent_offset;
10495 R_MeshQueue_AddTransparent((rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST) ? MESHQUEUE_SORT_HUD : ((rsurface.entity->flags & RENDER_WORLDOBJECT) ? MESHQUEUE_SORT_SKY : MESHQUEUE_SORT_DISTANCE), center, R_DrawSurface_TransparentCallback, rsurface.entity, surface - rsurface.modelsurfaces, rsurface.rtlight);
10499 static void R_DrawTextureSurfaceList_DepthOnly(int texturenumsurfaces, const msurface_t **texturesurfacelist)
10501 if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
10503 if (r_fb.water.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)))
10505 RSurf_SetupDepthAndCulling();
10506 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX, texturenumsurfaces, texturesurfacelist);
10507 if (rsurface.batchvertex3fbuffer)
10508 R_Mesh_PrepareVertices_Vertex3f(rsurface.batchnumvertices, rsurface.batchvertex3f, rsurface.batchvertex3fbuffer);
10510 R_Mesh_PrepareVertices_Vertex3f(rsurface.batchnumvertices, rsurface.batchvertex3f, rsurface.batchvertex3f_vertexbuffer);
10514 static void R_ProcessWorldTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, qboolean prepass)
10518 R_DrawTextureSurfaceList_DepthOnly(texturenumsurfaces, texturesurfacelist);
10521 if (!rsurface.texture->currentnumlayers)
10523 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
10524 R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist);
10526 R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
10528 else if ((rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY) && (!r_showsurfaces.integer || r_showsurfaces.integer == 3))
10529 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
10530 else if (!rsurface.texture->currentnumlayers)
10532 else if (((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) || (r_showsurfaces.integer == 3 && (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST))))
10534 // in the deferred case, transparent surfaces were queued during prepass
10535 if (!r_shadow_usingdeferredprepass)
10536 R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist);
10540 // the alphatest check is to make sure we write depth for anything we skipped on the depth-only pass earlier
10541 R_DrawWorldTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST), prepass);
10546 static void R_QueueWorldSurfaceList(int numsurfaces, const msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean prepass)
10549 texture_t *texture;
10550 R_FrameData_SetMark();
10551 // break the surface list down into batches by texture and use of lightmapping
10552 for (i = 0;i < numsurfaces;i = j)
10555 // texture is the base texture pointer, rsurface.texture is the
10556 // current frame/skin the texture is directing us to use (for example
10557 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
10558 // use skin 1 instead)
10559 texture = surfacelist[i]->texture;
10560 rsurface.texture = R_GetCurrentTexture(texture);
10561 if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW))
10563 // if this texture is not the kind we want, skip ahead to the next one
10564 for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
10568 if(FAKELIGHT_ENABLED || depthonly || prepass)
10570 rsurface.lightmaptexture = NULL;
10571 rsurface.deluxemaptexture = NULL;
10572 rsurface.uselightmaptexture = false;
10573 // simply scan ahead until we find a different texture or lightmap state
10574 for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
10579 rsurface.lightmaptexture = surfacelist[i]->lightmaptexture;
10580 rsurface.deluxemaptexture = surfacelist[i]->deluxemaptexture;
10581 rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL;
10582 // simply scan ahead until we find a different texture or lightmap state
10583 for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.lightmaptexture == surfacelist[j]->lightmaptexture;j++)
10586 // render the range of surfaces
10587 R_ProcessWorldTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, prepass);
10589 R_FrameData_ReturnToMark();
10592 static void R_ProcessModelTextureSurfaceList(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly, qboolean prepass)
10596 R_DrawTextureSurfaceList_DepthOnly(texturenumsurfaces, texturesurfacelist);
10599 if (!rsurface.texture->currentnumlayers)
10601 if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)
10602 R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist);
10604 R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth, prepass);
10606 else if ((rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY) && (!r_showsurfaces.integer || r_showsurfaces.integer == 3))
10607 R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
10608 else if (!rsurface.texture->currentnumlayers)
10610 else if (((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) || (r_showsurfaces.integer == 3 && (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST))))
10612 // in the deferred case, transparent surfaces were queued during prepass
10613 if (!r_shadow_usingdeferredprepass)
10614 R_ProcessTransparentTextureSurfaceList(texturenumsurfaces, texturesurfacelist);
10618 // the alphatest check is to make sure we write depth for anything we skipped on the depth-only pass earlier
10619 R_DrawModelTextureSurfaceList(texturenumsurfaces, texturesurfacelist, writedepth || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST), prepass);
10624 static void R_QueueModelSurfaceList(entity_render_t *ent, int numsurfaces, const msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly, qboolean prepass)
10627 texture_t *texture;
10628 R_FrameData_SetMark();
10629 // break the surface list down into batches by texture and use of lightmapping
10630 for (i = 0;i < numsurfaces;i = j)
10633 // texture is the base texture pointer, rsurface.texture is the
10634 // current frame/skin the texture is directing us to use (for example
10635 // if a model has 2 skins and it is on skin 1, then skin 0 tells us to
10636 // use skin 1 instead)
10637 texture = surfacelist[i]->texture;
10638 rsurface.texture = R_GetCurrentTexture(texture);
10639 if (!(rsurface.texture->currentmaterialflags & flagsmask) || (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW))
10641 // if this texture is not the kind we want, skip ahead to the next one
10642 for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
10646 if(FAKELIGHT_ENABLED || depthonly || prepass)
10648 rsurface.lightmaptexture = NULL;
10649 rsurface.deluxemaptexture = NULL;
10650 rsurface.uselightmaptexture = false;
10651 // simply scan ahead until we find a different texture or lightmap state
10652 for (;j < numsurfaces && texture == surfacelist[j]->texture;j++)
10657 rsurface.lightmaptexture = surfacelist[i]->lightmaptexture;
10658 rsurface.deluxemaptexture = surfacelist[i]->deluxemaptexture;
10659 rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL;
10660 // simply scan ahead until we find a different texture or lightmap state
10661 for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.lightmaptexture == surfacelist[j]->lightmaptexture;j++)
10664 // render the range of surfaces
10665 R_ProcessModelTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly, prepass);
10667 R_FrameData_ReturnToMark();
10670 float locboxvertex3f[6*4*3] =
10672 1,0,1, 1,0,0, 1,1,0, 1,1,1,
10673 0,1,1, 0,1,0, 0,0,0, 0,0,1,
10674 1,1,1, 1,1,0, 0,1,0, 0,1,1,
10675 0,0,1, 0,0,0, 1,0,0, 1,0,1,
10676 0,0,1, 1,0,1, 1,1,1, 0,1,1,
10677 1,0,0, 0,0,0, 0,1,0, 1,1,0
10680 unsigned short locboxelements[6*2*3] =
10685 12,13,14, 12,14,15,
10686 16,17,18, 16,18,19,
10690 static void R_DrawLoc_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
10693 cl_locnode_t *loc = (cl_locnode_t *)ent;
10695 float vertex3f[6*4*3];
10697 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
10698 GL_DepthMask(false);
10699 GL_DepthRange(0, 1);
10700 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
10701 GL_DepthTest(true);
10702 GL_CullFace(GL_NONE);
10703 R_EntityMatrix(&identitymatrix);
10705 // R_Mesh_ResetTextureState();
10707 i = surfacelist[0];
10708 GL_Color(((i & 0x0007) >> 0) * (1.0f / 7.0f) * r_refdef.view.colorscale,
10709 ((i & 0x0038) >> 3) * (1.0f / 7.0f) * r_refdef.view.colorscale,
10710 ((i & 0x01C0) >> 6) * (1.0f / 7.0f) * r_refdef.view.colorscale,
10711 surfacelist[0] < 0 ? 0.5f : 0.125f);
10713 if (VectorCompare(loc->mins, loc->maxs))
10715 VectorSet(size, 2, 2, 2);
10716 VectorMA(loc->mins, -0.5f, size, mins);
10720 VectorCopy(loc->mins, mins);
10721 VectorSubtract(loc->maxs, loc->mins, size);
10724 for (i = 0;i < 6*4*3;)
10725 for (j = 0;j < 3;j++, i++)
10726 vertex3f[i] = mins[j] + size[j] * locboxvertex3f[i];
10728 R_Mesh_PrepareVertices_Generic_Arrays(6*4, vertex3f, NULL, NULL);
10729 R_SetupShader_Generic_NoTexture(false, false);
10730 R_Mesh_Draw(0, 6*4, 0, 6*2, NULL, NULL, 0, locboxelements, NULL, 0);
10733 void R_DrawLocs(void)
10736 cl_locnode_t *loc, *nearestloc;
10738 nearestloc = CL_Locs_FindNearest(cl.movement_origin);
10739 for (loc = cl.locnodes, index = 0;loc;loc = loc->next, index++)
10741 VectorLerp(loc->mins, 0.5f, loc->maxs, center);
10742 R_MeshQueue_AddTransparent(MESHQUEUE_SORT_DISTANCE, center, R_DrawLoc_Callback, (entity_render_t *)loc, loc == nearestloc ? -1 : index, NULL);
10746 void R_DecalSystem_Reset(decalsystem_t *decalsystem)
10748 if (decalsystem->decals)
10749 Mem_Free(decalsystem->decals);
10750 memset(decalsystem, 0, sizeof(*decalsystem));
10753 static void R_DecalSystem_SpawnTriangle(decalsystem_t *decalsystem, const float *v0, const float *v1, const float *v2, const float *t0, const float *t1, const float *t2, const float *c0, const float *c1, const float *c2, int triangleindex, int surfaceindex, int decalsequence)
10756 tridecal_t *decals;
10759 // expand or initialize the system
10760 if (decalsystem->maxdecals <= decalsystem->numdecals)
10762 decalsystem_t old = *decalsystem;
10763 qboolean useshortelements;
10764 decalsystem->maxdecals = max(16, decalsystem->maxdecals * 2);
10765 useshortelements = decalsystem->maxdecals * 3 <= 65536;
10766 decalsystem->decals = (tridecal_t *)Mem_Alloc(cls.levelmempool, decalsystem->maxdecals * (sizeof(tridecal_t) + sizeof(float[3][3]) + sizeof(float[3][2]) + sizeof(float[3][4]) + sizeof(int[3]) + (useshortelements ? sizeof(unsigned short[3]) : 0)));
10767 decalsystem->color4f = (float *)(decalsystem->decals + decalsystem->maxdecals);
10768 decalsystem->texcoord2f = (float *)(decalsystem->color4f + decalsystem->maxdecals*12);
10769 decalsystem->vertex3f = (float *)(decalsystem->texcoord2f + decalsystem->maxdecals*6);
10770 decalsystem->element3i = (int *)(decalsystem->vertex3f + decalsystem->maxdecals*9);
10771 decalsystem->element3s = (useshortelements ? ((unsigned short *)(decalsystem->element3i + decalsystem->maxdecals*3)) : NULL);
10772 if (decalsystem->numdecals)
10773 memcpy(decalsystem->decals, old.decals, decalsystem->numdecals * sizeof(tridecal_t));
10775 Mem_Free(old.decals);
10776 for (i = 0;i < decalsystem->maxdecals*3;i++)
10777 decalsystem->element3i[i] = i;
10778 if (useshortelements)
10779 for (i = 0;i < decalsystem->maxdecals*3;i++)
10780 decalsystem->element3s[i] = i;
10783 // grab a decal and search for another free slot for the next one
10784 decals = decalsystem->decals;
10785 decal = decalsystem->decals + (i = decalsystem->freedecal++);
10786 for (i = decalsystem->freedecal;i < decalsystem->numdecals && decals[i].color4f[0][3];i++)
10788 decalsystem->freedecal = i;
10789 if (decalsystem->numdecals <= i)
10790 decalsystem->numdecals = i + 1;
10792 // initialize the decal
10794 decal->triangleindex = triangleindex;
10795 decal->surfaceindex = surfaceindex;
10796 decal->decalsequence = decalsequence;
10797 decal->color4f[0][0] = c0[0];
10798 decal->color4f[0][1] = c0[1];
10799 decal->color4f[0][2] = c0[2];
10800 decal->color4f[0][3] = 1;
10801 decal->color4f[1][0] = c1[0];
10802 decal->color4f[1][1] = c1[1];
10803 decal->color4f[1][2] = c1[2];
10804 decal->color4f[1][3] = 1;
10805 decal->color4f[2][0] = c2[0];
10806 decal->color4f[2][1] = c2[1];
10807 decal->color4f[2][2] = c2[2];
10808 decal->color4f[2][3] = 1;
10809 decal->vertex3f[0][0] = v0[0];
10810 decal->vertex3f[0][1] = v0[1];
10811 decal->vertex3f[0][2] = v0[2];
10812 decal->vertex3f[1][0] = v1[0];
10813 decal->vertex3f[1][1] = v1[1];
10814 decal->vertex3f[1][2] = v1[2];
10815 decal->vertex3f[2][0] = v2[0];
10816 decal->vertex3f[2][1] = v2[1];
10817 decal->vertex3f[2][2] = v2[2];
10818 decal->texcoord2f[0][0] = t0[0];
10819 decal->texcoord2f[0][1] = t0[1];
10820 decal->texcoord2f[1][0] = t1[0];
10821 decal->texcoord2f[1][1] = t1[1];
10822 decal->texcoord2f[2][0] = t2[0];
10823 decal->texcoord2f[2][1] = t2[1];
10824 TriangleNormal(v0, v1, v2, decal->plane);
10825 VectorNormalize(decal->plane);
10826 decal->plane[3] = DotProduct(v0, decal->plane);
10829 extern cvar_t cl_decals_bias;
10830 extern cvar_t cl_decals_models;
10831 extern cvar_t cl_decals_newsystem_intensitymultiplier;
10832 // baseparms, parms, temps
10833 static void R_DecalSystem_SplatTriangle(decalsystem_t *decalsystem, float r, float g, float b, float a, float s1, float t1, float s2, float t2, int decalsequence, qboolean dynamic, float (*planes)[4], matrix4x4_t *projection, int triangleindex, int surfaceindex)
10838 const float *vertex3f;
10839 const float *normal3f;
10841 float points[2][9][3];
10848 e = rsurface.modelelement3i + 3*triangleindex;
10850 vertex3f = rsurface.modelvertex3f;
10851 normal3f = rsurface.modelnormal3f;
10855 for (cornerindex = 0;cornerindex < 3;cornerindex++)
10857 index = 3*e[cornerindex];
10858 VectorMA(vertex3f + index, cl_decals_bias.value, normal3f + index, v[cornerindex]);
10863 for (cornerindex = 0;cornerindex < 3;cornerindex++)
10865 index = 3*e[cornerindex];
10866 VectorCopy(vertex3f + index, v[cornerindex]);
10871 //TriangleNormal(v[0], v[1], v[2], normal);
10872 //if (DotProduct(normal, localnormal) < 0.0f)
10874 // clip by each of the box planes formed from the projection matrix
10875 // if anything survives, we emit the decal
10876 numpoints = PolygonF_Clip(3 , v[0] , planes[0][0], planes[0][1], planes[0][2], planes[0][3], 1.0f/64.0f, sizeof(points[0])/sizeof(points[0][0]), points[1][0]);
10879 numpoints = PolygonF_Clip(numpoints, points[1][0], planes[1][0], planes[1][1], planes[1][2], planes[1][3], 1.0f/64.0f, sizeof(points[0])/sizeof(points[0][0]), points[0][0]);
10882 numpoints = PolygonF_Clip(numpoints, points[0][0], planes[2][0], planes[2][1], planes[2][2], planes[2][3], 1.0f/64.0f, sizeof(points[0])/sizeof(points[0][0]), points[1][0]);
10885 numpoints = PolygonF_Clip(numpoints, points[1][0], planes[3][0], planes[3][1], planes[3][2], planes[3][3], 1.0f/64.0f, sizeof(points[0])/sizeof(points[0][0]), points[0][0]);
10888 numpoints = PolygonF_Clip(numpoints, points[0][0], planes[4][0], planes[4][1], planes[4][2], planes[4][3], 1.0f/64.0f, sizeof(points[0])/sizeof(points[0][0]), points[1][0]);
10891 numpoints = PolygonF_Clip(numpoints, points[1][0], planes[5][0], planes[5][1], planes[5][2], planes[5][3], 1.0f/64.0f, sizeof(points[0])/sizeof(points[0][0]), v[0]);
10894 // some part of the triangle survived, so we have to accept it...
10897 // dynamic always uses the original triangle
10899 for (cornerindex = 0;cornerindex < 3;cornerindex++)
10901 index = 3*e[cornerindex];
10902 VectorCopy(vertex3f + index, v[cornerindex]);
10905 for (cornerindex = 0;cornerindex < numpoints;cornerindex++)
10907 // convert vertex positions to texcoords
10908 Matrix4x4_Transform(projection, v[cornerindex], temp);
10909 tc[cornerindex][0] = (temp[1]+1.0f)*0.5f * (s2-s1) + s1;
10910 tc[cornerindex][1] = (temp[2]+1.0f)*0.5f * (t2-t1) + t1;
10911 // calculate distance fade from the projection origin
10912 f = a * (1.0f-fabs(temp[0])) * cl_decals_newsystem_intensitymultiplier.value;
10913 f = bound(0.0f, f, 1.0f);
10914 c[cornerindex][0] = r * f;
10915 c[cornerindex][1] = g * f;
10916 c[cornerindex][2] = b * f;
10917 c[cornerindex][3] = 1.0f;
10918 //VectorMA(v[cornerindex], cl_decals_bias.value, localnormal, v[cornerindex]);
10921 R_DecalSystem_SpawnTriangle(decalsystem, v[0], v[1], v[2], tc[0], tc[1], tc[2], c[0], c[1], c[2], triangleindex, surfaceindex, decalsequence);
10923 for (cornerindex = 0;cornerindex < numpoints-2;cornerindex++)
10924 R_DecalSystem_SpawnTriangle(decalsystem, v[0], v[cornerindex+1], v[cornerindex+2], tc[0], tc[cornerindex+1], tc[cornerindex+2], c[0], c[cornerindex+1], c[cornerindex+2], -1, surfaceindex, decalsequence);
10926 static void R_DecalSystem_SplatEntity(entity_render_t *ent, const vec3_t worldorigin, const vec3_t worldnormal, float r, float g, float b, float a, float s1, float t1, float s2, float t2, float worldsize, int decalsequence)
10928 matrix4x4_t projection;
10929 decalsystem_t *decalsystem;
10932 const msurface_t *surface;
10933 const msurface_t *surfaces;
10934 const int *surfacelist;
10935 const texture_t *texture;
10937 int numsurfacelist;
10938 int surfacelistindex;
10941 float localorigin[3];
10942 float localnormal[3];
10943 float localmins[3];
10944 float localmaxs[3];
10947 float planes[6][4];
10950 int bih_triangles_count;
10951 int bih_triangles[256];
10952 int bih_surfaces[256];
10954 decalsystem = &ent->decalsystem;
10955 model = ent->model;
10956 if (!model || !ent->allowdecals || ent->alpha < 1 || (ent->flags & (RENDER_ADDITIVE | RENDER_NODEPTHTEST)))
10958 R_DecalSystem_Reset(&ent->decalsystem);
10962 if (!model->brush.data_leafs && !cl_decals_models.integer)
10964 if (decalsystem->model)
10965 R_DecalSystem_Reset(decalsystem);
10969 if (decalsystem->model != model)
10970 R_DecalSystem_Reset(decalsystem);
10971 decalsystem->model = model;
10973 RSurf_ActiveModelEntity(ent, true, false, false);
10975 Matrix4x4_Transform(&rsurface.inversematrix, worldorigin, localorigin);
10976 Matrix4x4_Transform3x3(&rsurface.inversematrix, worldnormal, localnormal);
10977 VectorNormalize(localnormal);
10978 localsize = worldsize*rsurface.inversematrixscale;
10979 localmins[0] = localorigin[0] - localsize;
10980 localmins[1] = localorigin[1] - localsize;
10981 localmins[2] = localorigin[2] - localsize;
10982 localmaxs[0] = localorigin[0] + localsize;
10983 localmaxs[1] = localorigin[1] + localsize;
10984 localmaxs[2] = localorigin[2] + localsize;
10986 //VectorCopy(localnormal, planes[4]);
10987 //VectorVectors(planes[4], planes[2], planes[0]);
10988 AnglesFromVectors(angles, localnormal, NULL, false);
10989 AngleVectors(angles, planes[0], planes[2], planes[4]);
10990 VectorNegate(planes[0], planes[1]);
10991 VectorNegate(planes[2], planes[3]);
10992 VectorNegate(planes[4], planes[5]);
10993 planes[0][3] = DotProduct(planes[0], localorigin) - localsize;
10994 planes[1][3] = DotProduct(planes[1], localorigin) - localsize;
10995 planes[2][3] = DotProduct(planes[2], localorigin) - localsize;
10996 planes[3][3] = DotProduct(planes[3], localorigin) - localsize;
10997 planes[4][3] = DotProduct(planes[4], localorigin) - localsize;
10998 planes[5][3] = DotProduct(planes[5], localorigin) - localsize;
11003 matrix4x4_t forwardprojection;
11004 Matrix4x4_CreateFromQuakeEntity(&forwardprojection, localorigin[0], localorigin[1], localorigin[2], angles[0], angles[1], angles[2], localsize);
11005 Matrix4x4_Invert_Simple(&projection, &forwardprojection);
11010 float projectionvector[4][3];
11011 VectorScale(planes[0], ilocalsize, projectionvector[0]);
11012 VectorScale(planes[2], ilocalsize, projectionvector[1]);
11013 VectorScale(planes[4], ilocalsize, projectionvector[2]);
11014 projectionvector[0][0] = planes[0][0] * ilocalsize;
11015 projectionvector[0][1] = planes[1][0] * ilocalsize;
11016 projectionvector[0][2] = planes[2][0] * ilocalsize;
11017 projectionvector[1][0] = planes[0][1] * ilocalsize;
11018 projectionvector[1][1] = planes[1][1] * ilocalsize;
11019 projectionvector[1][2] = planes[2][1] * ilocalsize;
11020 projectionvector[2][0] = planes[0][2] * ilocalsize;
11021 projectionvector[2][1] = planes[1][2] * ilocalsize;
11022 projectionvector[2][2] = planes[2][2] * ilocalsize;
11023 projectionvector[3][0] = -(localorigin[0]*projectionvector[0][0]+localorigin[1]*projectionvector[1][0]+localorigin[2]*projectionvector[2][0]);
11024 projectionvector[3][1] = -(localorigin[0]*projectionvector[0][1]+localorigin[1]*projectionvector[1][1]+localorigin[2]*projectionvector[2][1]);
11025 projectionvector[3][2] = -(localorigin[0]*projectionvector[0][2]+localorigin[1]*projectionvector[1][2]+localorigin[2]*projectionvector[2][2]);
11026 Matrix4x4_FromVectors(&projection, projectionvector[0], projectionvector[1], projectionvector[2], projectionvector[3]);
11030 dynamic = model->surfmesh.isanimated;
11031 numsurfacelist = model->nummodelsurfaces;
11032 surfacelist = model->sortedmodelsurfaces;
11033 surfaces = model->data_surfaces;
11036 bih_triangles_count = -1;
11039 if(model->render_bih.numleafs)
11040 bih = &model->render_bih;
11041 else if(model->collision_bih.numleafs)
11042 bih = &model->collision_bih;
11045 bih_triangles_count = BIH_GetTriangleListForBox(bih, sizeof(bih_triangles) / sizeof(*bih_triangles), bih_triangles, bih_surfaces, localmins, localmaxs);
11046 if(bih_triangles_count == 0)
11048 if(bih_triangles_count > (int) (sizeof(bih_triangles) / sizeof(*bih_triangles))) // hit too many, likely bad anyway
11050 if(bih_triangles_count > 0)
11052 for (triangleindex = 0; triangleindex < bih_triangles_count; ++triangleindex)
11054 surfaceindex = bih_surfaces[triangleindex];
11055 surface = surfaces + surfaceindex;
11056 texture = surface->texture;
11057 if (texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SKY | MATERIALFLAG_SHORTDEPTHRANGE | MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
11059 if (texture->surfaceflags & Q3SURFACEFLAG_NOMARKS)
11061 R_DecalSystem_SplatTriangle(decalsystem, r, g, b, a, s1, t1, s2, t2, decalsequence, dynamic, planes, &projection, bih_triangles[triangleindex], surfaceindex);
11066 for (surfacelistindex = 0;surfacelistindex < numsurfacelist;surfacelistindex++)
11068 surfaceindex = surfacelist[surfacelistindex];
11069 surface = surfaces + surfaceindex;
11070 // check cull box first because it rejects more than any other check
11071 if (!dynamic && !BoxesOverlap(surface->mins, surface->maxs, localmins, localmaxs))
11073 // skip transparent surfaces
11074 texture = surface->texture;
11075 if (texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SKY | MATERIALFLAG_SHORTDEPTHRANGE | MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
11077 if (texture->surfaceflags & Q3SURFACEFLAG_NOMARKS)
11079 numtriangles = surface->num_triangles;
11080 for (triangleindex = 0; triangleindex < numtriangles; triangleindex++)
11081 R_DecalSystem_SplatTriangle(decalsystem, r, g, b, a, s1, t1, s2, t2, decalsequence, dynamic, planes, &projection, triangleindex + surface->num_firsttriangle, surfaceindex);
11086 // do not call this outside of rendering code - use R_DecalSystem_SplatEntities instead
11087 static void R_DecalSystem_ApplySplatEntities(const vec3_t worldorigin, const vec3_t worldnormal, float r, float g, float b, float a, float s1, float t1, float s2, float t2, float worldsize, int decalsequence)
11089 int renderentityindex;
11090 float worldmins[3];
11091 float worldmaxs[3];
11092 entity_render_t *ent;
11094 if (!cl_decals_newsystem.integer)
11097 worldmins[0] = worldorigin[0] - worldsize;
11098 worldmins[1] = worldorigin[1] - worldsize;
11099 worldmins[2] = worldorigin[2] - worldsize;
11100 worldmaxs[0] = worldorigin[0] + worldsize;
11101 worldmaxs[1] = worldorigin[1] + worldsize;
11102 worldmaxs[2] = worldorigin[2] + worldsize;
11104 R_DecalSystem_SplatEntity(r_refdef.scene.worldentity, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize, decalsequence);
11106 for (renderentityindex = 0;renderentityindex < r_refdef.scene.numentities;renderentityindex++)
11108 ent = r_refdef.scene.entities[renderentityindex];
11109 if (!BoxesOverlap(ent->mins, ent->maxs, worldmins, worldmaxs))
11112 R_DecalSystem_SplatEntity(ent, worldorigin, worldnormal, r, g, b, a, s1, t1, s2, t2, worldsize, decalsequence);
11116 typedef struct r_decalsystem_splatqueue_s
11118 vec3_t worldorigin;
11119 vec3_t worldnormal;
11125 r_decalsystem_splatqueue_t;
11127 int r_decalsystem_numqueued = 0;
11128 r_decalsystem_splatqueue_t r_decalsystem_queue[MAX_DECALSYSTEM_QUEUE];
11130 void R_DecalSystem_SplatEntities(const vec3_t worldorigin, const vec3_t worldnormal, float r, float g, float b, float a, float s1, float t1, float s2, float t2, float worldsize)
11132 r_decalsystem_splatqueue_t *queue;
11134 if (!cl_decals_newsystem.integer || r_decalsystem_numqueued == MAX_DECALSYSTEM_QUEUE)
11137 queue = &r_decalsystem_queue[r_decalsystem_numqueued++];
11138 VectorCopy(worldorigin, queue->worldorigin);
11139 VectorCopy(worldnormal, queue->worldnormal);
11140 Vector4Set(queue->color, r, g, b, a);
11141 Vector4Set(queue->tcrange, s1, t1, s2, t2);
11142 queue->worldsize = worldsize;
11143 queue->decalsequence = cl.decalsequence++;
11146 static void R_DecalSystem_ApplySplatEntitiesQueue(void)
11149 r_decalsystem_splatqueue_t *queue;
11151 for (i = 0, queue = r_decalsystem_queue;i < r_decalsystem_numqueued;i++, queue++)
11152 R_DecalSystem_ApplySplatEntities(queue->worldorigin, queue->worldnormal, queue->color[0], queue->color[1], queue->color[2], queue->color[3], queue->tcrange[0], queue->tcrange[1], queue->tcrange[2], queue->tcrange[3], queue->worldsize, queue->decalsequence);
11153 r_decalsystem_numqueued = 0;
11156 extern cvar_t cl_decals_max;
11157 static void R_DrawModelDecals_FadeEntity(entity_render_t *ent)
11160 decalsystem_t *decalsystem = &ent->decalsystem;
11167 if (!decalsystem->numdecals)
11170 if (r_showsurfaces.integer)
11173 if (ent->model != decalsystem->model || ent->alpha < 1 || (ent->flags & RENDER_ADDITIVE))
11175 R_DecalSystem_Reset(decalsystem);
11179 killsequence = cl.decalsequence - max(1, cl_decals_max.integer);
11180 lifetime = cl_decals_time.value + cl_decals_fadetime.value;
11182 if (decalsystem->lastupdatetime)
11183 frametime = (r_refdef.scene.time - decalsystem->lastupdatetime);
11186 decalsystem->lastupdatetime = r_refdef.scene.time;
11187 decal = decalsystem->decals;
11188 numdecals = decalsystem->numdecals;
11190 for (i = 0, decal = decalsystem->decals;i < numdecals;i++, decal++)
11192 if (decal->color4f[0][3])
11194 decal->lived += frametime;
11195 if (killsequence - decal->decalsequence > 0 || decal->lived >= lifetime)
11197 memset(decal, 0, sizeof(*decal));
11198 if (decalsystem->freedecal > i)
11199 decalsystem->freedecal = i;
11203 decal = decalsystem->decals;
11204 while (numdecals > 0 && !decal[numdecals-1].color4f[0][3])
11207 // collapse the array by shuffling the tail decals into the gaps
11210 while (decalsystem->freedecal < numdecals && decal[decalsystem->freedecal].color4f[0][3])
11211 decalsystem->freedecal++;
11212 if (decalsystem->freedecal == numdecals)
11214 decal[decalsystem->freedecal] = decal[--numdecals];
11217 decalsystem->numdecals = numdecals;
11219 if (numdecals <= 0)
11221 // if there are no decals left, reset decalsystem
11222 R_DecalSystem_Reset(decalsystem);
11226 extern skinframe_t *decalskinframe;
11227 static void R_DrawModelDecals_Entity(entity_render_t *ent)
11230 decalsystem_t *decalsystem = &ent->decalsystem;
11239 const unsigned char *surfacevisible = ent == r_refdef.scene.worldentity ? r_refdef.viewcache.world_surfacevisible : NULL;
11242 numdecals = decalsystem->numdecals;
11246 if (r_showsurfaces.integer)
11249 if (ent->model != decalsystem->model || ent->alpha < 1 || (ent->flags & RENDER_ADDITIVE))
11251 R_DecalSystem_Reset(decalsystem);
11255 // if the model is static it doesn't matter what value we give for
11256 // wantnormals and wanttangents, so this logic uses only rules applicable
11257 // to a model, knowing that they are meaningless otherwise
11258 if (ent == r_refdef.scene.worldentity)
11259 RSurf_ActiveWorldEntity();
11261 RSurf_ActiveModelEntity(ent, false, false, false);
11263 decalsystem->lastupdatetime = r_refdef.scene.time;
11264 decal = decalsystem->decals;
11266 faderate = 1.0f / max(0.001f, cl_decals_fadetime.value);
11268 // update vertex positions for animated models
11269 v3f = decalsystem->vertex3f;
11270 c4f = decalsystem->color4f;
11271 t2f = decalsystem->texcoord2f;
11272 for (i = 0, decal = decalsystem->decals;i < numdecals;i++, decal++)
11274 if (!decal->color4f[0][3])
11277 if (surfacevisible && !surfacevisible[decal->surfaceindex])
11281 if (decal->triangleindex < 0 && DotProduct(r_refdef.view.origin, decal->plane) < decal->plane[3])
11284 // update color values for fading decals
11285 if (decal->lived >= cl_decals_time.value)
11286 alpha = 1 - faderate * (decal->lived - cl_decals_time.value);
11290 c4f[ 0] = decal->color4f[0][0] * alpha;
11291 c4f[ 1] = decal->color4f[0][1] * alpha;
11292 c4f[ 2] = decal->color4f[0][2] * alpha;
11294 c4f[ 4] = decal->color4f[1][0] * alpha;
11295 c4f[ 5] = decal->color4f[1][1] * alpha;
11296 c4f[ 6] = decal->color4f[1][2] * alpha;
11298 c4f[ 8] = decal->color4f[2][0] * alpha;
11299 c4f[ 9] = decal->color4f[2][1] * alpha;
11300 c4f[10] = decal->color4f[2][2] * alpha;
11303 t2f[0] = decal->texcoord2f[0][0];
11304 t2f[1] = decal->texcoord2f[0][1];
11305 t2f[2] = decal->texcoord2f[1][0];
11306 t2f[3] = decal->texcoord2f[1][1];
11307 t2f[4] = decal->texcoord2f[2][0];
11308 t2f[5] = decal->texcoord2f[2][1];
11310 // update vertex positions for animated models
11311 if (decal->triangleindex >= 0 && decal->triangleindex < rsurface.modelnumtriangles)
11313 e = rsurface.modelelement3i + 3*decal->triangleindex;
11314 VectorCopy(rsurface.modelvertex3f + 3*e[0], v3f);
11315 VectorCopy(rsurface.modelvertex3f + 3*e[1], v3f + 3);
11316 VectorCopy(rsurface.modelvertex3f + 3*e[2], v3f + 6);
11320 VectorCopy(decal->vertex3f[0], v3f);
11321 VectorCopy(decal->vertex3f[1], v3f + 3);
11322 VectorCopy(decal->vertex3f[2], v3f + 6);
11325 if (r_refdef.fogenabled)
11327 alpha = RSurf_FogVertex(v3f);
11328 VectorScale(c4f, alpha, c4f);
11329 alpha = RSurf_FogVertex(v3f + 3);
11330 VectorScale(c4f + 4, alpha, c4f + 4);
11331 alpha = RSurf_FogVertex(v3f + 6);
11332 VectorScale(c4f + 8, alpha, c4f + 8);
11343 r_refdef.stats.drawndecals += numtris;
11345 // now render the decals all at once
11346 // (this assumes they all use one particle font texture!)
11347 RSurf_ActiveCustomEntity(&rsurface.matrix, &rsurface.inversematrix, rsurface.ent_flags, ent->shadertime, 1, 1, 1, 1, numdecals*3, decalsystem->vertex3f, decalsystem->texcoord2f, NULL, NULL, NULL, decalsystem->color4f, numtris, decalsystem->element3i, decalsystem->element3s, false, false);
11348 // R_Mesh_ResetTextureState();
11349 R_Mesh_PrepareVertices_Generic_Arrays(numtris * 3, decalsystem->vertex3f, decalsystem->color4f, decalsystem->texcoord2f);
11350 GL_DepthMask(false);
11351 GL_DepthRange(0, 1);
11352 GL_PolygonOffset(rsurface.basepolygonfactor + r_polygonoffset_decals_factor.value, rsurface.basepolygonoffset + r_polygonoffset_decals_offset.value);
11353 GL_DepthTest(true);
11354 GL_CullFace(GL_NONE);
11355 GL_BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
11356 R_SetupShader_Generic(decalskinframe->base, NULL, GL_MODULATE, 1, false, false, false);
11357 R_Mesh_Draw(0, numtris * 3, 0, numtris, decalsystem->element3i, NULL, 0, decalsystem->element3s, NULL, 0);
11361 static void R_DrawModelDecals(void)
11365 // fade faster when there are too many decals
11366 numdecals = r_refdef.scene.worldentity->decalsystem.numdecals;
11367 for (i = 0;i < r_refdef.scene.numentities;i++)
11368 numdecals += r_refdef.scene.entities[i]->decalsystem.numdecals;
11370 R_DrawModelDecals_FadeEntity(r_refdef.scene.worldentity);
11371 for (i = 0;i < r_refdef.scene.numentities;i++)
11372 if (r_refdef.scene.entities[i]->decalsystem.numdecals)
11373 R_DrawModelDecals_FadeEntity(r_refdef.scene.entities[i]);
11375 R_DecalSystem_ApplySplatEntitiesQueue();
11377 numdecals = r_refdef.scene.worldentity->decalsystem.numdecals;
11378 for (i = 0;i < r_refdef.scene.numentities;i++)
11379 numdecals += r_refdef.scene.entities[i]->decalsystem.numdecals;
11381 r_refdef.stats.totaldecals += numdecals;
11383 if (r_showsurfaces.integer)
11386 R_DrawModelDecals_Entity(r_refdef.scene.worldentity);
11388 for (i = 0;i < r_refdef.scene.numentities;i++)
11390 if (!r_refdef.viewcache.entityvisible[i])
11392 if (r_refdef.scene.entities[i]->decalsystem.numdecals)
11393 R_DrawModelDecals_Entity(r_refdef.scene.entities[i]);
11397 extern cvar_t mod_collision_bih;
11398 static void R_DrawDebugModel(void)
11400 entity_render_t *ent = rsurface.entity;
11401 int i, j, k, l, flagsmask;
11402 const msurface_t *surface;
11403 dp_model_t *model = ent->model;
11406 if (!sv.active && !cls.demoplayback && ent != r_refdef.scene.worldentity)
11409 if (r_showoverdraw.value > 0)
11411 float c = r_refdef.view.colorscale * r_showoverdraw.value * 0.125f;
11412 flagsmask = MATERIALFLAG_SKY | MATERIALFLAG_WALL;
11413 R_SetupShader_Generic_NoTexture(false, false);
11414 GL_DepthTest(false);
11415 GL_DepthMask(false);
11416 GL_DepthRange(0, 1);
11417 GL_BlendFunc(GL_ONE, GL_ONE);
11418 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
11420 if (ent == r_refdef.scene.worldentity && !r_refdef.viewcache.world_surfacevisible[j])
11422 rsurface.texture = R_GetCurrentTexture(surface->texture);
11423 if ((rsurface.texture->currentmaterialflags & flagsmask) && surface->num_triangles)
11425 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_NOGAPS, 1, &surface);
11426 GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : r_refdef.view.cullface_back);
11427 if (!rsurface.texture->currentlayers->depthmask)
11428 GL_Color(c, 0, 0, 1.0f);
11429 else if (ent == r_refdef.scene.worldentity)
11430 GL_Color(c, c, c, 1.0f);
11432 GL_Color(0, c, 0, 1.0f);
11433 R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, NULL, NULL);
11437 rsurface.texture = NULL;
11440 flagsmask = MATERIALFLAG_SKY | MATERIALFLAG_WALL;
11442 // R_Mesh_ResetTextureState();
11443 R_SetupShader_Generic_NoTexture(false, false);
11444 GL_DepthRange(0, 1);
11445 GL_DepthTest(!r_showdisabledepthtest.integer);
11446 GL_DepthMask(false);
11447 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
11449 if (r_showcollisionbrushes.value > 0 && model->collision_bih.numleafs)
11453 qboolean cullbox = ent == r_refdef.scene.worldentity;
11454 const q3mbrush_t *brush;
11455 const bih_t *bih = &model->collision_bih;
11456 const bih_leaf_t *bihleaf;
11457 float vertex3f[3][3];
11458 GL_PolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value);
11460 for (bihleafindex = 0, bihleaf = bih->leafs;bihleafindex < bih->numleafs;bihleafindex++, bihleaf++)
11462 if (cullbox && R_CullBox(bihleaf->mins, bihleaf->maxs))
11464 switch (bihleaf->type)
11467 brush = model->brush.data_brushes + bihleaf->itemindex;
11468 if (brush->colbrushf && brush->colbrushf->numtriangles)
11470 GL_Color((bihleafindex & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, ((bihleafindex >> 5) & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, ((bihleafindex >> 10) & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, r_showcollisionbrushes.value);
11471 R_Mesh_PrepareVertices_Generic_Arrays(brush->colbrushf->numpoints, brush->colbrushf->points->v, NULL, NULL);
11472 R_Mesh_Draw(0, brush->colbrushf->numpoints, 0, brush->colbrushf->numtriangles, brush->colbrushf->elements, NULL, 0, NULL, NULL, 0);
11475 case BIH_COLLISIONTRIANGLE:
11476 triangleindex = bihleaf->itemindex;
11477 VectorCopy(model->brush.data_collisionvertex3f + 3*model->brush.data_collisionelement3i[triangleindex*3+0], vertex3f[0]);
11478 VectorCopy(model->brush.data_collisionvertex3f + 3*model->brush.data_collisionelement3i[triangleindex*3+1], vertex3f[1]);
11479 VectorCopy(model->brush.data_collisionvertex3f + 3*model->brush.data_collisionelement3i[triangleindex*3+2], vertex3f[2]);
11480 GL_Color((bihleafindex & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, ((bihleafindex >> 5) & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, ((bihleafindex >> 10) & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, r_showcollisionbrushes.value);
11481 R_Mesh_PrepareVertices_Generic_Arrays(3, vertex3f[0], NULL, NULL);
11482 R_Mesh_Draw(0, 3, 0, 1, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
11484 case BIH_RENDERTRIANGLE:
11485 triangleindex = bihleaf->itemindex;
11486 VectorCopy(model->surfmesh.data_vertex3f + 3*model->surfmesh.data_element3i[triangleindex*3+0], vertex3f[0]);
11487 VectorCopy(model->surfmesh.data_vertex3f + 3*model->surfmesh.data_element3i[triangleindex*3+1], vertex3f[1]);
11488 VectorCopy(model->surfmesh.data_vertex3f + 3*model->surfmesh.data_element3i[triangleindex*3+2], vertex3f[2]);
11489 GL_Color((bihleafindex & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, ((bihleafindex >> 5) & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, ((bihleafindex >> 10) & 31) * (1.0f / 32.0f) * r_refdef.view.colorscale, r_showcollisionbrushes.value);
11490 R_Mesh_PrepareVertices_Generic_Arrays(3, vertex3f[0], NULL, NULL);
11491 R_Mesh_Draw(0, 3, 0, 1, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
11497 GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
11500 if (r_showtris.integer && qglPolygonMode)
11502 if (r_showdisabledepthtest.integer)
11504 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
11505 GL_DepthMask(false);
11509 GL_BlendFunc(GL_ONE, GL_ZERO);
11510 GL_DepthMask(true);
11512 qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);CHECKGLERROR
11513 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
11515 if (ent == r_refdef.scene.worldentity && !r_refdef.viewcache.world_surfacevisible[j])
11517 rsurface.texture = R_GetCurrentTexture(surface->texture);
11518 if ((rsurface.texture->currentmaterialflags & flagsmask) && surface->num_triangles)
11520 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | BATCHNEED_NOGAPS, 1, &surface);
11521 if (!rsurface.texture->currentlayers->depthmask)
11522 GL_Color(r_refdef.view.colorscale, 0, 0, r_showtris.value);
11523 else if (ent == r_refdef.scene.worldentity)
11524 GL_Color(r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale, r_showtris.value);
11526 GL_Color(0, r_refdef.view.colorscale, 0, r_showtris.value);
11527 R_Mesh_PrepareVertices_Generic_Arrays(rsurface.batchnumvertices, rsurface.batchvertex3f, NULL, NULL);
11531 qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);CHECKGLERROR
11532 rsurface.texture = NULL;
11535 if (r_shownormals.value != 0 && qglBegin)
11537 if (r_showdisabledepthtest.integer)
11539 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
11540 GL_DepthMask(false);
11544 GL_BlendFunc(GL_ONE, GL_ZERO);
11545 GL_DepthMask(true);
11547 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
11549 if (ent == r_refdef.scene.worldentity && !r_refdef.viewcache.world_surfacevisible[j])
11551 rsurface.texture = R_GetCurrentTexture(surface->texture);
11552 if ((rsurface.texture->currentmaterialflags & flagsmask) && surface->num_triangles)
11554 RSurf_PrepareVerticesForBatch(BATCHNEED_ARRAY_VERTEX | BATCHNEED_ARRAY_NORMAL | BATCHNEED_ARRAY_VECTOR | BATCHNEED_NOGAPS, 1, &surface);
11555 qglBegin(GL_LINES);
11556 if (r_shownormals.value < 0 && rsurface.batchnormal3f)
11558 for (k = 0, l = rsurface.batchfirstvertex;k < rsurface.batchnumvertices;k++, l++)
11560 VectorCopy(rsurface.batchvertex3f + l * 3, v);
11561 GL_Color(0, 0, r_refdef.view.colorscale, 1);
11562 qglVertex3f(v[0], v[1], v[2]);
11563 VectorMA(v, -r_shownormals.value, rsurface.batchnormal3f + l * 3, v);
11564 GL_Color(r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale, 1);
11565 qglVertex3f(v[0], v[1], v[2]);
11568 if (r_shownormals.value > 0 && rsurface.batchsvector3f)
11570 for (k = 0, l = rsurface.batchfirstvertex;k < rsurface.batchnumvertices;k++, l++)
11572 VectorCopy(rsurface.batchvertex3f + l * 3, v);
11573 GL_Color(r_refdef.view.colorscale, 0, 0, 1);
11574 qglVertex3f(v[0], v[1], v[2]);
11575 VectorMA(v, r_shownormals.value, rsurface.batchsvector3f + l * 3, v);
11576 GL_Color(r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale, 1);
11577 qglVertex3f(v[0], v[1], v[2]);
11580 if (r_shownormals.value > 0 && rsurface.batchtvector3f)
11582 for (k = 0, l = rsurface.batchfirstvertex;k < rsurface.batchnumvertices;k++, l++)
11584 VectorCopy(rsurface.batchvertex3f + l * 3, v);
11585 GL_Color(0, r_refdef.view.colorscale, 0, 1);
11586 qglVertex3f(v[0], v[1], v[2]);
11587 VectorMA(v, r_shownormals.value, rsurface.batchtvector3f + l * 3, v);
11588 GL_Color(r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale, 1);
11589 qglVertex3f(v[0], v[1], v[2]);
11592 if (r_shownormals.value > 0 && rsurface.batchnormal3f)
11594 for (k = 0, l = rsurface.batchfirstvertex;k < rsurface.batchnumvertices;k++, l++)
11596 VectorCopy(rsurface.batchvertex3f + l * 3, v);
11597 GL_Color(0, 0, r_refdef.view.colorscale, 1);
11598 qglVertex3f(v[0], v[1], v[2]);
11599 VectorMA(v, r_shownormals.value, rsurface.batchnormal3f + l * 3, v);
11600 GL_Color(r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale, 1);
11601 qglVertex3f(v[0], v[1], v[2]);
11608 rsurface.texture = NULL;
11613 int r_maxsurfacelist = 0;
11614 const msurface_t **r_surfacelist = NULL;
11615 void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass)
11617 int i, j, endj, flagsmask;
11618 dp_model_t *model = r_refdef.scene.worldmodel;
11619 msurface_t *surfaces;
11620 unsigned char *update;
11621 int numsurfacelist = 0;
11625 if (r_maxsurfacelist < model->num_surfaces)
11627 r_maxsurfacelist = model->num_surfaces;
11629 Mem_Free((msurface_t**)r_surfacelist);
11630 r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist));
11633 RSurf_ActiveWorldEntity();
11635 surfaces = model->data_surfaces;
11636 update = model->brushq1.lightmapupdateflags;
11638 // update light styles on this submodel
11639 if (!skysurfaces && !depthonly && !prepass && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
11641 model_brush_lightstyleinfo_t *style;
11642 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
11644 if (style->value != r_refdef.scene.lightstylevalue[style->style])
11646 int *list = style->surfacelist;
11647 style->value = r_refdef.scene.lightstylevalue[style->style];
11648 for (j = 0;j < style->numsurfaces;j++)
11649 update[list[j]] = true;
11654 flagsmask = skysurfaces ? MATERIALFLAG_SKY : MATERIALFLAG_WALL;
11658 R_DrawDebugModel();
11659 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
11663 rsurface.lightmaptexture = NULL;
11664 rsurface.deluxemaptexture = NULL;
11665 rsurface.uselightmaptexture = false;
11666 rsurface.texture = NULL;
11667 rsurface.rtlight = NULL;
11668 numsurfacelist = 0;
11669 // add visible surfaces to draw list
11670 for (i = 0;i < model->nummodelsurfaces;i++)
11672 j = model->sortedmodelsurfaces[i];
11673 if (r_refdef.viewcache.world_surfacevisible[j])
11674 r_surfacelist[numsurfacelist++] = surfaces + j;
11676 // update lightmaps if needed
11677 if (model->brushq1.firstrender)
11679 model->brushq1.firstrender = false;
11680 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
11682 R_BuildLightMap(r_refdef.scene.worldentity, surfaces + j);
11686 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
11687 if (r_refdef.viewcache.world_surfacevisible[j])
11689 R_BuildLightMap(r_refdef.scene.worldentity, surfaces + j);
11691 // don't do anything if there were no surfaces
11692 if (!numsurfacelist)
11694 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
11697 R_QueueWorldSurfaceList(numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
11699 // add to stats if desired
11700 if (r_speeds.integer && !skysurfaces && !depthonly)
11702 r_refdef.stats.world_surfaces += numsurfacelist;
11703 for (j = 0;j < numsurfacelist;j++)
11704 r_refdef.stats.world_triangles += r_surfacelist[j]->num_triangles;
11707 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
11710 void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass)
11712 int i, j, endj, flagsmask;
11713 dp_model_t *model = ent->model;
11714 msurface_t *surfaces;
11715 unsigned char *update;
11716 int numsurfacelist = 0;
11720 if (r_maxsurfacelist < model->num_surfaces)
11722 r_maxsurfacelist = model->num_surfaces;
11724 Mem_Free((msurface_t **)r_surfacelist);
11725 r_surfacelist = (const msurface_t **) Mem_Alloc(r_main_mempool, r_maxsurfacelist * sizeof(*r_surfacelist));
11728 // if the model is static it doesn't matter what value we give for
11729 // wantnormals and wanttangents, so this logic uses only rules applicable
11730 // to a model, knowing that they are meaningless otherwise
11731 if (ent == r_refdef.scene.worldentity)
11732 RSurf_ActiveWorldEntity();
11733 else if (r_showsurfaces.integer && r_showsurfaces.integer != 3)
11734 RSurf_ActiveModelEntity(ent, false, false, false);
11736 RSurf_ActiveModelEntity(ent, true, true, true);
11737 else if (depthonly)
11739 switch (vid.renderpath)
11741 case RENDERPATH_GL20:
11742 case RENDERPATH_D3D9:
11743 case RENDERPATH_D3D10:
11744 case RENDERPATH_D3D11:
11745 case RENDERPATH_SOFT:
11746 case RENDERPATH_GLES2:
11747 RSurf_ActiveModelEntity(ent, model->wantnormals, model->wanttangents, false);
11749 case RENDERPATH_GL11:
11750 case RENDERPATH_GL13:
11751 case RENDERPATH_GLES1:
11752 RSurf_ActiveModelEntity(ent, model->wantnormals, false, false);
11758 switch (vid.renderpath)
11760 case RENDERPATH_GL20:
11761 case RENDERPATH_D3D9:
11762 case RENDERPATH_D3D10:
11763 case RENDERPATH_D3D11:
11764 case RENDERPATH_SOFT:
11765 case RENDERPATH_GLES2:
11766 RSurf_ActiveModelEntity(ent, true, true, false);
11768 case RENDERPATH_GL11:
11769 case RENDERPATH_GL13:
11770 case RENDERPATH_GLES1:
11771 RSurf_ActiveModelEntity(ent, true, false, false);
11776 surfaces = model->data_surfaces;
11777 update = model->brushq1.lightmapupdateflags;
11779 // update light styles
11780 if (!skysurfaces && !depthonly && !prepass && model->brushq1.num_lightstyles && r_refdef.lightmapintensity > 0)
11782 model_brush_lightstyleinfo_t *style;
11783 for (i = 0, style = model->brushq1.data_lightstyleinfo;i < model->brushq1.num_lightstyles;i++, style++)
11785 if (style->value != r_refdef.scene.lightstylevalue[style->style])
11787 int *list = style->surfacelist;
11788 style->value = r_refdef.scene.lightstylevalue[style->style];
11789 for (j = 0;j < style->numsurfaces;j++)
11790 update[list[j]] = true;
11795 flagsmask = skysurfaces ? MATERIALFLAG_SKY : MATERIALFLAG_WALL;
11799 R_DrawDebugModel();
11800 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
11804 rsurface.lightmaptexture = NULL;
11805 rsurface.deluxemaptexture = NULL;
11806 rsurface.uselightmaptexture = false;
11807 rsurface.texture = NULL;
11808 rsurface.rtlight = NULL;
11809 numsurfacelist = 0;
11810 // add visible surfaces to draw list
11811 for (i = 0;i < model->nummodelsurfaces;i++)
11812 r_surfacelist[numsurfacelist++] = surfaces + model->sortedmodelsurfaces[i];
11813 // don't do anything if there were no surfaces
11814 if (!numsurfacelist)
11816 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
11819 // update lightmaps if needed
11823 for (j = model->firstmodelsurface, endj = model->firstmodelsurface + model->nummodelsurfaces;j < endj;j++)
11828 R_BuildLightMap(ent, surfaces + j);
11833 R_QueueModelSurfaceList(ent, numsurfacelist, r_surfacelist, flagsmask, writedepth, depthonly, prepass);
11835 // add to stats if desired
11836 if (r_speeds.integer && !skysurfaces && !depthonly)
11838 r_refdef.stats.entities_surfaces += numsurfacelist;
11839 for (j = 0;j < numsurfacelist;j++)
11840 r_refdef.stats.entities_triangles += r_surfacelist[j]->num_triangles;
11843 rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity
11846 void R_DrawCustomSurface(skinframe_t *skinframe, const matrix4x4_t *texmatrix, int materialflags, int firstvertex, int numvertices, int firsttriangle, int numtriangles, qboolean writedepth, qboolean prepass)
11848 static texture_t texture;
11849 static msurface_t surface;
11850 const msurface_t *surfacelist = &surface;
11852 // fake enough texture and surface state to render this geometry
11854 texture.update_lastrenderframe = -1; // regenerate this texture
11855 texture.basematerialflags = materialflags | MATERIALFLAG_CUSTOMSURFACE | MATERIALFLAG_WALL;
11856 texture.currentskinframe = skinframe;
11857 texture.currenttexmatrix = *texmatrix; // requires MATERIALFLAG_CUSTOMSURFACE
11858 texture.offsetmapping = OFFSETMAPPING_OFF;
11859 texture.offsetscale = 1;
11860 texture.specularscalemod = 1;
11861 texture.specularpowermod = 1;
11863 surface.texture = &texture;
11864 surface.num_triangles = numtriangles;
11865 surface.num_firsttriangle = firsttriangle;
11866 surface.num_vertices = numvertices;
11867 surface.num_firstvertex = firstvertex;
11870 rsurface.texture = R_GetCurrentTexture(surface.texture);
11871 rsurface.lightmaptexture = NULL;
11872 rsurface.deluxemaptexture = NULL;
11873 rsurface.uselightmaptexture = false;
11874 R_DrawModelTextureSurfaceList(1, &surfacelist, writedepth, prepass);
11877 void R_DrawCustomSurface_Texture(texture_t *texture, const matrix4x4_t *texmatrix, int materialflags, int firstvertex, int numvertices, int firsttriangle, int numtriangles, qboolean writedepth, qboolean prepass)
11879 static msurface_t surface;
11880 const msurface_t *surfacelist = &surface;
11882 // fake enough texture and surface state to render this geometry
11883 surface.texture = texture;
11884 surface.num_triangles = numtriangles;
11885 surface.num_firsttriangle = firsttriangle;
11886 surface.num_vertices = numvertices;
11887 surface.num_firstvertex = firstvertex;
11890 rsurface.texture = R_GetCurrentTexture(surface.texture);
11891 rsurface.lightmaptexture = NULL;
11892 rsurface.deluxemaptexture = NULL;
11893 rsurface.uselightmaptexture = false;
11894 R_DrawModelTextureSurfaceList(1, &surfacelist, writedepth, prepass);