X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=r_shadow.c;h=aa67549c6ddcd8f1a333f22ac9a255f4dca5d131;hp=dcfdef54285da3fd9d994f99d546c073de4858e0;hb=50099d9c0934fe93646fa2792fa7a9657422333b;hpb=41f1138b4a171ebb11be1418ed5579a8935b5516 diff --git a/r_shadow.c b/r_shadow.c index dcfdef54..aa67549c 100644 --- a/r_shadow.c +++ b/r_shadow.c @@ -146,6 +146,7 @@ typedef enum r_shadow_rendermode_e { R_SHADOW_RENDERMODE_NONE, R_SHADOW_RENDERMODE_STENCIL, + R_SHADOW_RENDERMODE_SEPARATESTENCIL, R_SHADOW_RENDERMODE_STENCILTWOSIDE, R_SHADOW_RENDERMODE_LIGHT_VERTEX, R_SHADOW_RENDERMODE_LIGHT_DOT3, @@ -184,7 +185,13 @@ int r_shadow_buffer_numsurfacepvsbytes; unsigned char *r_shadow_buffer_surfacepvs; int *r_shadow_buffer_surfacelist; +int r_shadow_buffer_numshadowtrispvsbytes; +unsigned char *r_shadow_buffer_shadowtrispvs; +int r_shadow_buffer_numlighttrispvsbytes; +unsigned char *r_shadow_buffer_lighttrispvs; + rtexturepool_t *r_shadow_texturepool; +rtexture_t *r_shadow_attenuationgradienttexture; rtexture_t *r_shadow_attenuation2dtexture; rtexture_t *r_shadow_attenuation3dtexture; @@ -197,27 +204,35 @@ rtexturepool_t *r_shadow_filters_texturepool; cvar_t r_shadow_bumpscale_basetexture = {0, "r_shadow_bumpscale_basetexture", "0", "generate fake bumpmaps from diffuse textures at this bumpyness, try 4 to match tenebrae, higher values increase depth, requires r_restart to take effect"}; cvar_t r_shadow_bumpscale_bumpmap = {0, "r_shadow_bumpscale_bumpmap", "4", "what magnitude to interpret _bump.tga textures as, higher values increase depth, requires r_restart to take effect"}; cvar_t r_shadow_debuglight = {0, "r_shadow_debuglight", "-1", "renders only one light, for level design purposes or debugging"}; +cvar_t r_shadow_usenormalmap = {CVAR_SAVE, "r_shadow_usenormalmap", "1", "enables use of directional shading on lights"}; cvar_t r_shadow_gloss = {CVAR_SAVE, "r_shadow_gloss", "1", "0 disables gloss (specularity) rendering, 1 uses gloss if textures are found, 2 forces a flat metallic specular effect on everything without textures (similar to tenebrae)"}; -cvar_t r_shadow_gloss2intensity = {0, "r_shadow_gloss2intensity", "0.25", "how bright the forced flat gloss should look if r_shadow_gloss is 2"}; +cvar_t r_shadow_gloss2intensity = {0, "r_shadow_gloss2intensity", "0.125", "how bright the forced flat gloss should look if r_shadow_gloss is 2"}; cvar_t r_shadow_glossintensity = {0, "r_shadow_glossintensity", "1", "how bright textured glossmaps should look if r_shadow_gloss is 1 or 2"}; -cvar_t r_shadow_lightattenuationpower = {0, "r_shadow_lightattenuationpower", "0.5", "changes attenuation texture generation (does not affect r_glsl lighting)"}; -cvar_t r_shadow_lightattenuationscale = {0, "r_shadow_lightattenuationscale", "1", "changes attenuation texture generation (does not affect r_glsl lighting)"}; +cvar_t r_shadow_glossexponent = {0, "r_shadow_glossexponent", "32", "how 'sharp' the gloss should appear (specular power)"}; +cvar_t r_shadow_lightattenuationdividebias = {0, "r_shadow_lightattenuationdividebias", "1", "changes attenuation texture generation"}; +cvar_t r_shadow_lightattenuationlinearscale = {0, "r_shadow_lightattenuationlinearscale", "2", "changes attenuation texture generation"}; cvar_t r_shadow_lightintensityscale = {0, "r_shadow_lightintensityscale", "1", "renders all world lights brighter or darker"}; +cvar_t r_shadow_lightradiusscale = {0, "r_shadow_lightradiusscale", "1", "renders all world lights larger or smaller"}; cvar_t r_shadow_portallight = {0, "r_shadow_portallight", "1", "use portal culling to exactly determine lit triangles when compiling world lights"}; cvar_t r_shadow_projectdistance = {0, "r_shadow_projectdistance", "1000000", "how far to cast shadows"}; +cvar_t r_shadow_frontsidecasting = {0, "r_shadow_frontsidecasting", "1", "whether to cast shadows from illuminated triangles (front side of model) or unlit triangles (back side of model)"}; cvar_t r_shadow_realtime_dlight = {CVAR_SAVE, "r_shadow_realtime_dlight", "1", "enables rendering of dynamic lights such as explosions and rocket light"}; cvar_t r_shadow_realtime_dlight_shadows = {CVAR_SAVE, "r_shadow_realtime_dlight_shadows", "1", "enables rendering of shadows from dynamic lights"}; -cvar_t r_shadow_realtime_dlight_portalculling = {0, "r_shadow_realtime_dlight_portalculling", "0", "enables portal culling optimizations on dynamic lights (slow! you probably don't want this!)"}; +cvar_t r_shadow_realtime_dlight_svbspculling = {0, "r_shadow_realtime_dlight_svbspculling", "0", "enables svbsp optimization on dynamic lights (very slow!)"}; +cvar_t r_shadow_realtime_dlight_portalculling = {0, "r_shadow_realtime_dlight_portalculling", "0", "enables portal optimization on dynamic lights (slow!)"}; cvar_t r_shadow_realtime_world = {CVAR_SAVE, "r_shadow_realtime_world", "0", "enables rendering of full world lighting (whether loaded from the map, or a .rtlights file, or a .ent file, or a .lights file produced by hlight)"}; -cvar_t r_shadow_realtime_world_dlightshadows = {CVAR_SAVE, "r_shadow_realtime_world_dlightshadows", "1", "enables shadows from dynamic lights when using full world lighting"}; cvar_t r_shadow_realtime_world_lightmaps = {CVAR_SAVE, "r_shadow_realtime_world_lightmaps", "0", "brightness to render lightmaps when using full world lighting, try 0.5 for a tenebrae-like appearance"}; cvar_t r_shadow_realtime_world_shadows = {CVAR_SAVE, "r_shadow_realtime_world_shadows", "1", "enables rendering of shadows from world lights"}; cvar_t r_shadow_realtime_world_compile = {0, "r_shadow_realtime_world_compile", "1", "enables compilation of world lights for higher performance rendering"}; cvar_t r_shadow_realtime_world_compileshadow = {0, "r_shadow_realtime_world_compileshadow", "1", "enables compilation of shadows from world lights for higher performance rendering"}; +cvar_t r_shadow_realtime_world_compilesvbsp = {0, "r_shadow_realtime_world_compilesvbsp", "1", "enables svbsp optimization during compilation"}; +cvar_t r_shadow_realtime_world_compileportalculling = {0, "r_shadow_realtime_world_compileportalculling", "1", "enables portal-based culling optimization during compilation"}; cvar_t r_shadow_scissor = {0, "r_shadow_scissor", "1", "use scissor optimization of light rendering (restricts rendering to the portion of the screen affected by the light)"}; -cvar_t r_shadow_shadow_polygonfactor = {0, "r_shadow_shadow_polygonfactor", "0", "how much to enlarge shadow volume polygons when rendering (should be 0!)"}; -cvar_t r_shadow_shadow_polygonoffset = {0, "r_shadow_shadow_polygonoffset", "1", "how much to push shadow volumes into the distance when rendering, to reduce chances of zfighting artifacts (should not be less than 0)"}; +cvar_t r_shadow_culltriangles = {0, "r_shadow_culltriangles", "1", "performs more expensive tests to remove unnecessary triangles of lit surfaces"}; +cvar_t r_shadow_polygonfactor = {0, "r_shadow_polygonfactor", "0", "how much to enlarge shadow volume polygons when rendering (should be 0!)"}; +cvar_t r_shadow_polygonoffset = {0, "r_shadow_polygonoffset", "1", "how much to push shadow volumes into the distance when rendering, to reduce chances of zfighting artifacts (should not be less than 0)"}; cvar_t r_shadow_texture3d = {0, "r_shadow_texture3d", "1", "use 3D voxel textures for spherical attenuation rather than cylindrical (does not affect r_glsl lighting)"}; +cvar_t gl_ext_separatestencil = {0, "gl_ext_separatestencil", "1", "make use of OpenGL 2.0 glStencilOpSeparate or GL_ATI_separate_stencil extension"}; cvar_t gl_ext_stenciltwoside = {0, "gl_ext_stenciltwoside", "1", "make use of GL_EXT_stenciltwoside extension (NVIDIA only)"}; cvar_t r_editlights = {0, "r_editlights", "0", "enables .rtlights file editing mode"}; cvar_t r_editlights_cursordistance = {0, "r_editlights_cursordistance", "1024", "maximum distance of cursor from eye"}; @@ -226,7 +241,16 @@ cvar_t r_editlights_cursorpushoff = {0, "r_editlights_cursorpushoff", "4", "how cvar_t r_editlights_cursorgrid = {0, "r_editlights_cursorgrid", "4", "snaps cursor to this grid size"}; cvar_t r_editlights_quakelightsizescale = {CVAR_SAVE, "r_editlights_quakelightsizescale", "1", "changes size of light entities loaded from a map"}; -float r_shadow_attenpower, r_shadow_attenscale; +// note the table actually includes one more value, just to avoid the need to clamp the distance index due to minor math error +#define ATTENTABLESIZE 256 +// 1D gradient, 2D circle and 3D sphere attenuation textures +#define ATTEN1DSIZE 32 +#define ATTEN2DSIZE 64 +#define ATTEN3DSIZE 32 + +static float r_shadow_attendividebias; // r_shadow_lightattenuationdividebias +static float r_shadow_attenlinearscale; // r_shadow_lightattenuationlinearscale +static float r_shadow_attentable[ATTENTABLESIZE+1]; rtlight_t *r_shadow_compilingrtlight; dlight_t *r_shadow_worldlightchain; @@ -256,12 +280,12 @@ void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void); void R_Shadow_EditLights_Reload_f(void); void R_Shadow_ValidateCvars(void); static void R_Shadow_MakeTextures(void); -void R_Shadow_DrawWorldLightShadowVolume(matrix4x4_t *matrix, dlight_t *light); void r_shadow_start(void) { // allocate vertex processing arrays numcubemaps = 0; + r_shadow_attenuationgradienttexture = NULL; r_shadow_attenuation2dtexture = NULL; r_shadow_attenuation3dtexture = NULL; r_shadow_texturepool = NULL; @@ -287,12 +311,17 @@ void r_shadow_start(void) r_shadow_buffer_numsurfacepvsbytes = 0; r_shadow_buffer_surfacepvs = NULL; r_shadow_buffer_surfacelist = NULL; + r_shadow_buffer_numshadowtrispvsbytes = 0; + r_shadow_buffer_shadowtrispvs = NULL; + r_shadow_buffer_numlighttrispvsbytes = 0; + r_shadow_buffer_lighttrispvs = NULL; } void r_shadow_shutdown(void) { R_Shadow_UncompileWorldLights(); numcubemaps = 0; + r_shadow_attenuationgradienttexture = NULL; r_shadow_attenuation2dtexture = NULL; r_shadow_attenuation3dtexture = NULL; R_FreeTexturePool(&r_shadow_texturepool); @@ -335,6 +364,12 @@ void r_shadow_shutdown(void) if (r_shadow_buffer_surfacelist) Mem_Free(r_shadow_buffer_surfacelist); r_shadow_buffer_surfacelist = NULL; + r_shadow_buffer_numshadowtrispvsbytes = 0; + if (r_shadow_buffer_shadowtrispvs) + Mem_Free(r_shadow_buffer_shadowtrispvs); + r_shadow_buffer_numlighttrispvsbytes = 0; + if (r_shadow_buffer_lighttrispvs) + Mem_Free(r_shadow_buffer_lighttrispvs); } void r_shadow_newmap(void) @@ -352,23 +387,22 @@ void R_Shadow_Help_f(void) "r_shadow_gloss 0/1/2 : no gloss, gloss textures only, force gloss\n" "r_shadow_gloss2intensity : brightness of forced gloss\n" "r_shadow_glossintensity : brightness of textured gloss\n" -"r_shadow_lightattenuationpower : used to generate attenuation texture\n" -"r_shadow_lightattenuationscale : used to generate attenuation texture\n" +"r_shadow_lightattenuationlinearscale : used to generate attenuation texture\n" +"r_shadow_lightattenuationdividebias : used to generate attenuation texture\n" "r_shadow_lightintensityscale : scale rendering brightness of all lights\n" +"r_shadow_lightradiusscale : scale rendering radius of all lights\n" "r_shadow_portallight : use portal visibility for static light precomputation\n" "r_shadow_projectdistance : shadow volume projection distance\n" "r_shadow_realtime_dlight : use high quality dynamic lights in normal mode\n" "r_shadow_realtime_dlight_shadows : cast shadows from dlights\n" -"r_shadow_realtime_dlight_portalculling : work hard to reduce graphics work\n" "r_shadow_realtime_world : use high quality world lighting mode\n" -"r_shadow_realtime_world_dlightshadows : cast shadows from dlights\n" "r_shadow_realtime_world_lightmaps : use lightmaps in addition to lights\n" "r_shadow_realtime_world_shadows : cast shadows from world lights\n" "r_shadow_realtime_world_compile : compile surface/visibility information\n" "r_shadow_realtime_world_compileshadow : compile shadow geometry\n" "r_shadow_scissor : use scissor optimization\n" -"r_shadow_shadow_polygonfactor : nudge shadow volumes closer/further\n" -"r_shadow_shadow_polygonoffset : nudge shadow volumes closer/further\n" +"r_shadow_polygonfactor : nudge shadow volumes closer/further\n" +"r_shadow_polygonoffset : nudge shadow volumes closer/further\n" "r_shadow_texture3d : use 3d attenuation texture (if hardware supports)\n" "r_showlighting : useful for performance testing; bright = slow!\n" "r_showshadowvolumes : useful for performance testing; bright = slow!\n" @@ -381,28 +415,36 @@ void R_Shadow_Init(void) { Cvar_RegisterVariable(&r_shadow_bumpscale_basetexture); Cvar_RegisterVariable(&r_shadow_bumpscale_bumpmap); + Cvar_RegisterVariable(&r_shadow_usenormalmap); Cvar_RegisterVariable(&r_shadow_debuglight); Cvar_RegisterVariable(&r_shadow_gloss); Cvar_RegisterVariable(&r_shadow_gloss2intensity); Cvar_RegisterVariable(&r_shadow_glossintensity); - Cvar_RegisterVariable(&r_shadow_lightattenuationpower); - Cvar_RegisterVariable(&r_shadow_lightattenuationscale); + Cvar_RegisterVariable(&r_shadow_glossexponent); + Cvar_RegisterVariable(&r_shadow_lightattenuationdividebias); + Cvar_RegisterVariable(&r_shadow_lightattenuationlinearscale); Cvar_RegisterVariable(&r_shadow_lightintensityscale); + Cvar_RegisterVariable(&r_shadow_lightradiusscale); Cvar_RegisterVariable(&r_shadow_portallight); Cvar_RegisterVariable(&r_shadow_projectdistance); + Cvar_RegisterVariable(&r_shadow_frontsidecasting); Cvar_RegisterVariable(&r_shadow_realtime_dlight); Cvar_RegisterVariable(&r_shadow_realtime_dlight_shadows); + Cvar_RegisterVariable(&r_shadow_realtime_dlight_svbspculling); Cvar_RegisterVariable(&r_shadow_realtime_dlight_portalculling); Cvar_RegisterVariable(&r_shadow_realtime_world); - Cvar_RegisterVariable(&r_shadow_realtime_world_dlightshadows); Cvar_RegisterVariable(&r_shadow_realtime_world_lightmaps); Cvar_RegisterVariable(&r_shadow_realtime_world_shadows); Cvar_RegisterVariable(&r_shadow_realtime_world_compile); Cvar_RegisterVariable(&r_shadow_realtime_world_compileshadow); + Cvar_RegisterVariable(&r_shadow_realtime_world_compilesvbsp); + Cvar_RegisterVariable(&r_shadow_realtime_world_compileportalculling); Cvar_RegisterVariable(&r_shadow_scissor); - Cvar_RegisterVariable(&r_shadow_shadow_polygonfactor); - Cvar_RegisterVariable(&r_shadow_shadow_polygonoffset); + Cvar_RegisterVariable(&r_shadow_culltriangles); + Cvar_RegisterVariable(&r_shadow_polygonfactor); + Cvar_RegisterVariable(&r_shadow_polygonoffset); Cvar_RegisterVariable(&r_shadow_texture3d); + Cvar_RegisterVariable(&gl_ext_separatestencil); Cvar_RegisterVariable(&gl_ext_stenciltwoside); if (gamemode == GAME_TENEBRAE) { @@ -431,6 +473,8 @@ void R_Shadow_Init(void) r_shadow_buffer_numsurfacepvsbytes = 0; r_shadow_buffer_surfacepvs = NULL; r_shadow_buffer_surfacelist = NULL; + r_shadow_buffer_shadowtrispvs = NULL; + r_shadow_buffer_lighttrispvs = NULL; R_RegisterModule("R_Shadow", r_shadow_start, r_shadow_shutdown, r_shadow_newmap); } @@ -474,10 +518,12 @@ void R_Shadow_ResizeShadowArrays(int numvertices, int numtriangles) } } -static void R_Shadow_EnlargeLeafSurfaceBuffer(int numleafs, int numsurfaces) +static void R_Shadow_EnlargeLeafSurfaceTrisBuffer(int numleafs, int numsurfaces, int numshadowtriangles, int numlighttriangles) { int numleafpvsbytes = (((numleafs + 7) >> 3) + 255) & ~255; int numsurfacepvsbytes = (((numsurfaces + 7) >> 3) + 255) & ~255; + int numshadowtrispvsbytes = (((numshadowtriangles + 7) >> 3) + 255) & ~255; + int numlighttrispvsbytes = (((numlighttriangles + 7) >> 3) + 255) & ~255; if (r_shadow_buffer_numleafpvsbytes < numleafpvsbytes) { if (r_shadow_buffer_leafpvs) @@ -498,6 +544,20 @@ static void R_Shadow_EnlargeLeafSurfaceBuffer(int numleafs, int numsurfaces) r_shadow_buffer_surfacepvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes); r_shadow_buffer_surfacelist = (int *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist)); } + if (r_shadow_buffer_numshadowtrispvsbytes < numshadowtrispvsbytes) + { + if (r_shadow_buffer_shadowtrispvs) + Mem_Free(r_shadow_buffer_shadowtrispvs); + r_shadow_buffer_numshadowtrispvsbytes = numshadowtrispvsbytes; + r_shadow_buffer_shadowtrispvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numshadowtrispvsbytes); + } + if (r_shadow_buffer_numlighttrispvsbytes < numlighttrispvsbytes) + { + if (r_shadow_buffer_lighttrispvs) + Mem_Free(r_shadow_buffer_lighttrispvs); + r_shadow_buffer_numlighttrispvsbytes = numlighttrispvsbytes; + r_shadow_buffer_lighttrispvs = (unsigned char *)Mem_Alloc(r_main_mempool, r_shadow_buffer_numlighttrispvsbytes); + } } void R_Shadow_PrepareShadowMark(int numtris) @@ -524,12 +584,18 @@ void R_Shadow_PrepareShadowMark(int numtris) numshadowmark = 0; } -int R_Shadow_ConstructShadowVolume(int innumvertices, int innumtris, const int *inelement3i, const int *inneighbor3i, const float *invertex3f, int *outnumvertices, int *outelement3i, float *outvertex3f, const float *projectorigin, float projectdistance, int numshadowmarktris, const int *shadowmarktris) +int R_Shadow_ConstructShadowVolume(int innumvertices, int innumtris, const int *inelement3i, const int *inneighbor3i, const float *invertex3f, int *outnumvertices, int *outelement3i, float *outvertex3f, const float *projectorigin, const float *projectdirection, float projectdistance, int numshadowmarktris, const int *shadowmarktris) { int i, j; int outtriangles = 0, outvertices = 0; const int *element; const float *vertex; + float ratio, direction[3], projectvector[3]; + + if (projectdirection) + VectorScale(projectdirection, projectdistance, projectvector); + else + VectorClear(projectvector); if (maxvertexupdate < innumvertices) { @@ -553,91 +619,183 @@ int R_Shadow_ConstructShadowVolume(int innumvertices, int innumtris, const int * for (i = 0;i < numshadowmarktris;i++) shadowmark[shadowmarktris[i]] = shadowmarkcount; - for (i = 0;i < numshadowmarktris;i++) + // create the vertices + if (projectdirection) { - element = inelement3i + shadowmarktris[i] * 3; - // make sure the vertices are created - for (j = 0;j < 3;j++) + for (i = 0;i < numshadowmarktris;i++) { - if (vertexupdate[element[j]] != vertexupdatenum) + element = inelement3i + shadowmarktris[i] * 3; + for (j = 0;j < 3;j++) { - float ratio, direction[3]; - vertexupdate[element[j]] = vertexupdatenum; - vertexremap[element[j]] = outvertices; - vertex = invertex3f + element[j] * 3; - // project one copy of the vertex to the sphere radius of the light - // (FIXME: would projecting it to the light box be better?) - VectorSubtract(vertex, projectorigin, direction); - ratio = projectdistance / VectorLength(direction); - VectorCopy(vertex, outvertex3f); - VectorMA(projectorigin, ratio, direction, (outvertex3f + 3)); - outvertex3f += 6; - outvertices += 2; + if (vertexupdate[element[j]] != vertexupdatenum) + { + vertexupdate[element[j]] = vertexupdatenum; + vertexremap[element[j]] = outvertices; + vertex = invertex3f + element[j] * 3; + // project one copy of the vertex according to projectvector + VectorCopy(vertex, outvertex3f); + VectorAdd(vertex, projectvector, (outvertex3f + 3)); + outvertex3f += 6; + outvertices += 2; + } } } } - - for (i = 0;i < numshadowmarktris;i++) + else { - int remappedelement[3]; - int markindex; - const int *neighbortriangle; - - markindex = shadowmarktris[i] * 3; - element = inelement3i + markindex; - neighbortriangle = inneighbor3i + markindex; - // output the front and back triangles - outelement3i[0] = vertexremap[element[0]]; - outelement3i[1] = vertexremap[element[1]]; - outelement3i[2] = vertexremap[element[2]]; - outelement3i[3] = vertexremap[element[2]] + 1; - outelement3i[4] = vertexremap[element[1]] + 1; - outelement3i[5] = vertexremap[element[0]] + 1; - - outelement3i += 6; - outtriangles += 2; - // output the sides (facing outward from this triangle) - if (shadowmark[neighbortriangle[0]] != shadowmarkcount) - { - remappedelement[0] = vertexremap[element[0]]; - remappedelement[1] = vertexremap[element[1]]; - outelement3i[0] = remappedelement[1]; - outelement3i[1] = remappedelement[0]; - outelement3i[2] = remappedelement[0] + 1; - outelement3i[3] = remappedelement[1]; - outelement3i[4] = remappedelement[0] + 1; - outelement3i[5] = remappedelement[1] + 1; - - outelement3i += 6; - outtriangles += 2; + for (i = 0;i < numshadowmarktris;i++) + { + element = inelement3i + shadowmarktris[i] * 3; + for (j = 0;j < 3;j++) + { + if (vertexupdate[element[j]] != vertexupdatenum) + { + vertexupdate[element[j]] = vertexupdatenum; + vertexremap[element[j]] = outvertices; + vertex = invertex3f + element[j] * 3; + // project one copy of the vertex to the sphere radius of the light + // (FIXME: would projecting it to the light box be better?) + VectorSubtract(vertex, projectorigin, direction); + ratio = projectdistance / VectorLength(direction); + VectorCopy(vertex, outvertex3f); + VectorMA(projectorigin, ratio, direction, (outvertex3f + 3)); + outvertex3f += 6; + outvertices += 2; + } + } } - if (shadowmark[neighbortriangle[1]] != shadowmarkcount) + } + + if (r_shadow_frontsidecasting.integer) + { + for (i = 0;i < numshadowmarktris;i++) { - remappedelement[1] = vertexremap[element[1]]; - remappedelement[2] = vertexremap[element[2]]; - outelement3i[0] = remappedelement[2]; - outelement3i[1] = remappedelement[1]; - outelement3i[2] = remappedelement[1] + 1; - outelement3i[3] = remappedelement[2]; - outelement3i[4] = remappedelement[1] + 1; - outelement3i[5] = remappedelement[2] + 1; + int remappedelement[3]; + int markindex; + const int *neighbortriangle; + + markindex = shadowmarktris[i] * 3; + element = inelement3i + markindex; + neighbortriangle = inneighbor3i + markindex; + // output the front and back triangles + outelement3i[0] = vertexremap[element[0]]; + outelement3i[1] = vertexremap[element[1]]; + outelement3i[2] = vertexremap[element[2]]; + outelement3i[3] = vertexremap[element[2]] + 1; + outelement3i[4] = vertexremap[element[1]] + 1; + outelement3i[5] = vertexremap[element[0]] + 1; outelement3i += 6; outtriangles += 2; + // output the sides (facing outward from this triangle) + if (shadowmark[neighbortriangle[0]] != shadowmarkcount) + { + remappedelement[0] = vertexremap[element[0]]; + remappedelement[1] = vertexremap[element[1]]; + outelement3i[0] = remappedelement[1]; + outelement3i[1] = remappedelement[0]; + outelement3i[2] = remappedelement[0] + 1; + outelement3i[3] = remappedelement[1]; + outelement3i[4] = remappedelement[0] + 1; + outelement3i[5] = remappedelement[1] + 1; + + outelement3i += 6; + outtriangles += 2; + } + if (shadowmark[neighbortriangle[1]] != shadowmarkcount) + { + remappedelement[1] = vertexremap[element[1]]; + remappedelement[2] = vertexremap[element[2]]; + outelement3i[0] = remappedelement[2]; + outelement3i[1] = remappedelement[1]; + outelement3i[2] = remappedelement[1] + 1; + outelement3i[3] = remappedelement[2]; + outelement3i[4] = remappedelement[1] + 1; + outelement3i[5] = remappedelement[2] + 1; + + outelement3i += 6; + outtriangles += 2; + } + if (shadowmark[neighbortriangle[2]] != shadowmarkcount) + { + remappedelement[0] = vertexremap[element[0]]; + remappedelement[2] = vertexremap[element[2]]; + outelement3i[0] = remappedelement[0]; + outelement3i[1] = remappedelement[2]; + outelement3i[2] = remappedelement[2] + 1; + outelement3i[3] = remappedelement[0]; + outelement3i[4] = remappedelement[2] + 1; + outelement3i[5] = remappedelement[0] + 1; + + outelement3i += 6; + outtriangles += 2; + } } - if (shadowmark[neighbortriangle[2]] != shadowmarkcount) + } + else + { + for (i = 0;i < numshadowmarktris;i++) { - remappedelement[0] = vertexremap[element[0]]; - remappedelement[2] = vertexremap[element[2]]; - outelement3i[0] = remappedelement[0]; - outelement3i[1] = remappedelement[2]; - outelement3i[2] = remappedelement[2] + 1; - outelement3i[3] = remappedelement[0]; - outelement3i[4] = remappedelement[2] + 1; - outelement3i[5] = remappedelement[0] + 1; + int remappedelement[3]; + int markindex; + const int *neighbortriangle; + + markindex = shadowmarktris[i] * 3; + element = inelement3i + markindex; + neighbortriangle = inneighbor3i + markindex; + // output the front and back triangles + outelement3i[0] = vertexremap[element[2]]; + outelement3i[1] = vertexremap[element[1]]; + outelement3i[2] = vertexremap[element[0]]; + outelement3i[3] = vertexremap[element[0]] + 1; + outelement3i[4] = vertexremap[element[1]] + 1; + outelement3i[5] = vertexremap[element[2]] + 1; outelement3i += 6; outtriangles += 2; + // output the sides (facing outward from this triangle) + if (shadowmark[neighbortriangle[0]] != shadowmarkcount) + { + remappedelement[0] = vertexremap[element[0]]; + remappedelement[1] = vertexremap[element[1]]; + outelement3i[0] = remappedelement[0]; + outelement3i[1] = remappedelement[1]; + outelement3i[2] = remappedelement[1] + 1; + outelement3i[3] = remappedelement[0]; + outelement3i[4] = remappedelement[1] + 1; + outelement3i[5] = remappedelement[0] + 1; + + outelement3i += 6; + outtriangles += 2; + } + if (shadowmark[neighbortriangle[1]] != shadowmarkcount) + { + remappedelement[1] = vertexremap[element[1]]; + remappedelement[2] = vertexremap[element[2]]; + outelement3i[0] = remappedelement[1]; + outelement3i[1] = remappedelement[2]; + outelement3i[2] = remappedelement[2] + 1; + outelement3i[3] = remappedelement[1]; + outelement3i[4] = remappedelement[2] + 1; + outelement3i[5] = remappedelement[1] + 1; + + outelement3i += 6; + outtriangles += 2; + } + if (shadowmark[neighbortriangle[2]] != shadowmarkcount) + { + remappedelement[0] = vertexremap[element[0]]; + remappedelement[2] = vertexremap[element[2]]; + outelement3i[0] = remappedelement[2]; + outelement3i[1] = remappedelement[0]; + outelement3i[2] = remappedelement[0] + 1; + outelement3i[3] = remappedelement[2]; + outelement3i[4] = remappedelement[0] + 1; + outelement3i[5] = remappedelement[2] + 1; + + outelement3i += 6; + outtriangles += 2; + } } } if (outnumvertices) @@ -645,12 +803,12 @@ int R_Shadow_ConstructShadowVolume(int innumvertices, int innumtris, const int * return outtriangles; } -void R_Shadow_VolumeFromList(int numverts, int numtris, const float *invertex3f, const int *elements, const int *neighbors, const vec3_t projectorigin, float projectdistance, int nummarktris, const int *marktris) +void R_Shadow_VolumeFromList(int numverts, int numtris, const float *invertex3f, const int *elements, const int *neighbors, const vec3_t projectorigin, const vec3_t projectdirection, float projectdistance, int nummarktris, const int *marktris) { int tris, outverts; if (projectdistance < 0.1) { - Con_Printf("R_Shadow_Volume: projectdistance %f\n"); + Con_Printf("R_Shadow_Volume: projectdistance %f\n", projectdistance); return; } if (!numverts || !nummarktris) @@ -658,130 +816,145 @@ void R_Shadow_VolumeFromList(int numverts, int numtris, const float *invertex3f, // make sure shadowelements is big enough for this volume if (maxshadowtriangles < nummarktris || maxshadowvertices < numverts) R_Shadow_ResizeShadowArrays((numverts + 255) & ~255, (nummarktris + 255) & ~255); - tris = R_Shadow_ConstructShadowVolume(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdistance, nummarktris, marktris); - renderstats.lights_dynamicshadowtriangles += tris; + tris = R_Shadow_ConstructShadowVolume(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, shadowvertex3f, projectorigin, projectdirection, projectdistance, nummarktris, marktris); + r_refdef.stats.lights_dynamicshadowtriangles += tris; R_Shadow_RenderVolume(outverts, tris, shadowvertex3f, shadowelements); } -void R_Shadow_MarkVolumeFromBox(int firsttriangle, int numtris, const float *invertex3f, const int *elements, const vec3_t projectorigin, const vec3_t lightmins, const vec3_t lightmaxs, const vec3_t surfacemins, const vec3_t surfacemaxs) +void R_Shadow_MarkVolumeFromBox(int firsttriangle, int numtris, const float *invertex3f, const int *elements, const vec3_t projectorigin, const vec3_t projectdirection, const vec3_t lightmins, const vec3_t lightmaxs, const vec3_t surfacemins, const vec3_t surfacemaxs) { int t, tend; const int *e; const float *v[3]; + float normal[3]; if (!BoxesOverlap(lightmins, lightmaxs, surfacemins, surfacemaxs)) return; tend = firsttriangle + numtris; - if (surfacemins[0] >= lightmins[0] && surfacemaxs[0] <= lightmaxs[0] - && surfacemins[1] >= lightmins[1] && surfacemaxs[1] <= lightmaxs[1] - && surfacemins[2] >= lightmins[2] && surfacemaxs[2] <= lightmaxs[2]) + if (BoxInsideBox(surfacemins, surfacemaxs, lightmins, lightmaxs)) { // surface box entirely inside light box, no box cull - for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3) - if (PointInfrontOfTriangle(projectorigin, invertex3f + e[0] * 3, invertex3f + e[1] * 3, invertex3f + e[2] * 3)) - shadowmarklist[numshadowmark++] = t; + if (projectdirection) + { + for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3) + { + TriangleNormal(invertex3f + e[0] * 3, invertex3f + e[1] * 3, invertex3f + e[2] * 3, normal); + if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0)) + shadowmarklist[numshadowmark++] = t; + } + } + else + { + for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3) + if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, invertex3f + e[0] * 3, invertex3f + e[1] * 3, invertex3f + e[2] * 3)) + shadowmarklist[numshadowmark++] = t; + } } else { // surface box not entirely inside light box, cull each triangle - for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3) + if (projectdirection) { - v[0] = invertex3f + e[0] * 3; - v[1] = invertex3f + e[1] * 3; - v[2] = invertex3f + e[2] * 3; - if (PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2]) - && lightmaxs[0] > min(v[0][0], min(v[1][0], v[2][0])) - && lightmins[0] < max(v[0][0], max(v[1][0], v[2][0])) - && lightmaxs[1] > min(v[0][1], min(v[1][1], v[2][1])) - && lightmins[1] < max(v[0][1], max(v[1][1], v[2][1])) - && lightmaxs[2] > min(v[0][2], min(v[1][2], v[2][2])) - && lightmins[2] < max(v[0][2], max(v[1][2], v[2][2]))) - shadowmarklist[numshadowmark++] = t; + for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3) + { + v[0] = invertex3f + e[0] * 3; + v[1] = invertex3f + e[1] * 3; + v[2] = invertex3f + e[2] * 3; + TriangleNormal(v[0], v[1], v[2], normal); + if (r_shadow_frontsidecasting.integer == (DotProduct(normal, projectdirection) < 0) + && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs)) + shadowmarklist[numshadowmark++] = t; + } + } + else + { + for (t = firsttriangle, e = elements + t * 3;t < tend;t++, e += 3) + { + v[0] = invertex3f + e[0] * 3; + v[1] = invertex3f + e[1] * 3; + v[2] = invertex3f + e[2] * 3; + if (r_shadow_frontsidecasting.integer == PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2]) + && TriangleOverlapsBox(v[0], v[1], v[2], lightmins, lightmaxs)) + shadowmarklist[numshadowmark++] = t; + } } } } void R_Shadow_RenderVolume(int numvertices, int numtriangles, const float *vertex3f, const int *element3i) { - rmeshstate_t m; if (r_shadow_compilingrtlight) { // if we're compiling an rtlight, capture the mesh Mod_ShadowMesh_AddMesh(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow, NULL, NULL, NULL, vertex3f, NULL, NULL, NULL, NULL, numtriangles, element3i); return; } - renderstats.lights_shadowtriangles += numtriangles; - memset(&m, 0, sizeof(m)); - m.pointer_vertex = vertex3f; - R_Mesh_State(&m); + r_refdef.stats.lights_shadowtriangles += numtriangles; + CHECKGLERROR + R_Mesh_VertexPointer(vertex3f, 0, 0); GL_LockArrays(0, numvertices); if (r_shadow_rendermode == R_SHADOW_RENDERMODE_STENCIL) { // decrement stencil if backface is behind depthbuffer - qglCullFace(GL_BACK); // quake is backwards, this culls front faces - qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP); - R_Mesh_Draw(0, numvertices, numtriangles, element3i); + GL_CullFace(GL_BACK); // quake is backwards, this culls front faces + qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);CHECKGLERROR + R_Mesh_Draw(0, numvertices, numtriangles, element3i, 0, 0); // increment stencil if frontface is behind depthbuffer - qglCullFace(GL_FRONT); // quake is backwards, this culls back faces - qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP); + GL_CullFace(GL_FRONT); // quake is backwards, this culls back faces + qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);CHECKGLERROR } - R_Mesh_Draw(0, numvertices, numtriangles, element3i); + R_Mesh_Draw(0, numvertices, numtriangles, element3i, 0, 0); GL_LockArrays(0, 0); + CHECKGLERROR +} + +static unsigned char R_Shadow_MakeTextures_SamplePoint(float x, float y, float z) +{ + float dist = sqrt(x*x+y*y+z*z); + float intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0; + return (unsigned char)bound(0, intensity * 256.0f, 255); } static void R_Shadow_MakeTextures(void) { - int x, y, z, d; - float v[3], intensity; + int x, y, z; + float intensity, dist; unsigned char *data; + unsigned int palette[256]; R_FreeTexturePool(&r_shadow_texturepool); r_shadow_texturepool = R_AllocTexturePool(); - r_shadow_attenpower = r_shadow_lightattenuationpower.value; - r_shadow_attenscale = r_shadow_lightattenuationscale.value; -#define ATTEN2DSIZE 64 -#define ATTEN3DSIZE 32 - data = (unsigned char *)Mem_Alloc(tempmempool, max(ATTEN3DSIZE*ATTEN3DSIZE*ATTEN3DSIZE*4, ATTEN2DSIZE*ATTEN2DSIZE*4)); + r_shadow_attenlinearscale = r_shadow_lightattenuationlinearscale.value; + r_shadow_attendividebias = r_shadow_lightattenuationdividebias.value; + // note this code could suffer byte order issues except that it is multiplying by an integer that reads the same both ways + for (x = 0;x < 256;x++) + palette[x] = x * 0x01010101; + data = (unsigned char *)Mem_Alloc(tempmempool, max(max(ATTEN3DSIZE*ATTEN3DSIZE*ATTEN3DSIZE, ATTEN2DSIZE*ATTEN2DSIZE), ATTEN1DSIZE)); + // the table includes one additional value to avoid the need to clamp indexing due to minor math errors + for (x = 0;x <= ATTENTABLESIZE;x++) + { + dist = (x + 0.5f) * (1.0f / ATTENTABLESIZE) * (1.0f / 0.9375); + intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0; + r_shadow_attentable[x] = bound(0, intensity, 1); + } + // 1D gradient texture + for (x = 0;x < ATTEN1DSIZE;x++) + data[x] = R_Shadow_MakeTextures_SamplePoint((x + 0.5f) * (1.0f / ATTEN1DSIZE) * (1.0f / 0.9375), 0, 0); + r_shadow_attenuationgradienttexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation1d", ATTEN1DSIZE, 1, data, TEXTYPE_PALETTE, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA, palette); + // 2D circle texture for (y = 0;y < ATTEN2DSIZE;y++) - { for (x = 0;x < ATTEN2DSIZE;x++) - { - v[0] = ((x + 0.5f) * (2.0f / ATTEN2DSIZE) - 1.0f) * (1.0f / 0.9375); - v[1] = ((y + 0.5f) * (2.0f / ATTEN2DSIZE) - 1.0f) * (1.0f / 0.9375); - v[2] = 0; - intensity = 1.0f - sqrt(DotProduct(v, v)); - if (intensity > 0) - intensity = pow(intensity, r_shadow_attenpower) * r_shadow_attenscale * 256.0f; - d = (int)bound(0, intensity, 255); - data[(y*ATTEN2DSIZE+x)*4+0] = d; - data[(y*ATTEN2DSIZE+x)*4+1] = d; - data[(y*ATTEN2DSIZE+x)*4+2] = d; - data[(y*ATTEN2DSIZE+x)*4+3] = d; - } - } - r_shadow_attenuation2dtexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation2d", ATTEN2DSIZE, ATTEN2DSIZE, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA, NULL); - if (r_shadow_texture3d.integer) + data[y*ATTEN2DSIZE+x] = R_Shadow_MakeTextures_SamplePoint(((x + 0.5f) * (2.0f / ATTEN2DSIZE) - 1.0f) * (1.0f / 0.9375), ((y + 0.5f) * (2.0f / ATTEN2DSIZE) - 1.0f) * (1.0f / 0.9375), 0); + r_shadow_attenuation2dtexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation2d", ATTEN2DSIZE, ATTEN2DSIZE, data, TEXTYPE_PALETTE, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA, palette); + // 3D sphere texture + if (r_shadow_texture3d.integer && gl_texture3d) { for (z = 0;z < ATTEN3DSIZE;z++) - { for (y = 0;y < ATTEN3DSIZE;y++) - { for (x = 0;x < ATTEN3DSIZE;x++) - { - v[0] = ((x + 0.5f) * (2.0f / ATTEN3DSIZE) - 1.0f) * (1.0f / 0.9375); - v[1] = ((y + 0.5f) * (2.0f / ATTEN3DSIZE) - 1.0f) * (1.0f / 0.9375); - v[2] = ((z + 0.5f) * (2.0f / ATTEN3DSIZE) - 1.0f) * (1.0f / 0.9375); - intensity = 1.0f - sqrt(DotProduct(v, v)); - if (intensity > 0) - intensity = pow(intensity, r_shadow_attenpower) * r_shadow_attenscale * 256.0f; - d = (int)bound(0, intensity, 255); - data[((z*ATTEN3DSIZE+y)*ATTEN3DSIZE+x)*4+0] = d; - data[((z*ATTEN3DSIZE+y)*ATTEN3DSIZE+x)*4+1] = d; - data[((z*ATTEN3DSIZE+y)*ATTEN3DSIZE+x)*4+2] = d; - data[((z*ATTEN3DSIZE+y)*ATTEN3DSIZE+x)*4+3] = d; - } - } - } - r_shadow_attenuation3dtexture = R_LoadTexture3D(r_shadow_texturepool, "attenuation3d", ATTEN3DSIZE, ATTEN3DSIZE, ATTEN3DSIZE, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA, NULL); + data[(z*ATTEN3DSIZE+y)*ATTEN3DSIZE+x] = R_Shadow_MakeTextures_SamplePoint(((x + 0.5f) * (2.0f / ATTEN3DSIZE) - 1.0f) * (1.0f / 0.9375), ((y + 0.5f) * (2.0f / ATTEN3DSIZE) - 1.0f) * (1.0f / 0.9375), ((z + 0.5f) * (2.0f / ATTEN3DSIZE) - 1.0f) * (1.0f / 0.9375)); + r_shadow_attenuation3dtexture = R_LoadTexture3D(r_shadow_texturepool, "attenuation3d", ATTEN3DSIZE, ATTEN3DSIZE, ATTEN3DSIZE, data, TEXTYPE_PALETTE, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA, palette); } + else + r_shadow_attenuation3dtexture = NULL; Mem_Free(data); } @@ -789,51 +962,38 @@ void R_Shadow_ValidateCvars(void) { if (r_shadow_texture3d.integer && !gl_texture3d) Cvar_SetValueQuick(&r_shadow_texture3d, 0); + if (gl_ext_separatestencil.integer && !gl_support_separatestencil) + Cvar_SetValueQuick(&gl_ext_separatestencil, 0); if (gl_ext_stenciltwoside.integer && !gl_support_stenciltwoside) Cvar_SetValueQuick(&gl_ext_stenciltwoside, 0); } -// light currently being rendered -rtlight_t *r_shadow_rtlight; - -// this is the location of the eye in entity space -vec3_t r_shadow_entityeyeorigin; -// this is the location of the light in entity space -vec3_t r_shadow_entitylightorigin; -// this transforms entity coordinates to light filter cubemap coordinates -// (also often used for other purposes) -matrix4x4_t r_shadow_entitytolight; -// based on entitytolight this transforms -1 to +1 to 0 to 1 for purposes -// of attenuation texturing in full 3D (Z result often ignored) -matrix4x4_t r_shadow_entitytoattenuationxyz; -// this transforms only the Z to S, and T is always 0.5 -matrix4x4_t r_shadow_entitytoattenuationz; - void R_Shadow_RenderMode_Begin(void) { - rmeshstate_t m; - R_Shadow_ValidateCvars(); if (!r_shadow_attenuation2dtexture || (!r_shadow_attenuation3dtexture && r_shadow_texture3d.integer) - || r_shadow_lightattenuationpower.value != r_shadow_attenpower - || r_shadow_lightattenuationscale.value != r_shadow_attenscale) + || r_shadow_lightattenuationdividebias.value != r_shadow_attendividebias + || r_shadow_lightattenuationlinearscale.value != r_shadow_attenlinearscale) R_Shadow_MakeTextures(); - memset(&m, 0, sizeof(m)); - R_Mesh_State(&m); + CHECKGLERROR + R_Mesh_ColorPointer(NULL, 0, 0); + R_Mesh_ResetTextureState(); GL_BlendFunc(GL_ONE, GL_ZERO); - GL_DepthMask(false); + GL_DepthRange(0, 1); + GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset); GL_DepthTest(true); + GL_DepthMask(false); GL_Color(0, 0, 0, 1); - qglCullFace(GL_FRONT); // quake is backwards, this culls back faces - qglEnable(GL_CULL_FACE); - GL_Scissor(r_view_x, r_view_y, r_view_width, r_view_height); + GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height); r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE; - if (gl_ext_stenciltwoside.integer) + if (gl_ext_separatestencil.integer) + r_shadow_shadowingrendermode = R_SHADOW_RENDERMODE_SEPARATESTENCIL; + else if (gl_ext_stenciltwoside.integer) r_shadow_shadowingrendermode = R_SHADOW_RENDERMODE_STENCILTWOSIDE; else r_shadow_shadowingrendermode = R_SHADOW_RENDERMODE_STENCIL; @@ -848,87 +1008,84 @@ void R_Shadow_RenderMode_Begin(void) void R_Shadow_RenderMode_ActiveLight(rtlight_t *rtlight) { - r_shadow_rtlight = rtlight; + rsurface.rtlight = rtlight; } void R_Shadow_RenderMode_Reset(void) { - rmeshstate_t m; + CHECKGLERROR if (r_shadow_rendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL) { - qglUseProgramObjectARB(0); - // HACK HACK HACK: work around for bug in NVIDIAI 6xxx drivers that causes GL_OUT_OF_MEMORY and/or software rendering - qglBegin(GL_TRIANGLES); - qglEnd(); - CHECKGLERROR + qglUseProgramObjectARB(0);CHECKGLERROR } else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_STENCILTWOSIDE) - qglDisable(GL_STENCIL_TEST_TWO_SIDE_EXT); - memset(&m, 0, sizeof(m)); - R_Mesh_State(&m); + { + qglDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);CHECKGLERROR + } + R_Mesh_ColorPointer(NULL, 0, 0); + R_Mesh_ResetTextureState(); + GL_DepthRange(0, 1); + GL_DepthTest(true); + GL_DepthMask(false); + qglDepthFunc(GL_LEQUAL);CHECKGLERROR + GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR + qglDisable(GL_STENCIL_TEST);CHECKGLERROR + qglStencilMask(~0);CHECKGLERROR + qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR + qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR + GL_CullFace(GL_FRONT); // quake is backwards, this culls back faces + GL_Color(1, 1, 1, 1); + GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1); + GL_BlendFunc(GL_ONE, GL_ZERO); } -void R_Shadow_RenderMode_StencilShadowVolumes(void) +void R_Shadow_RenderMode_StencilShadowVolumes(qboolean clearstencil) { + CHECKGLERROR R_Shadow_RenderMode_Reset(); - GL_Color(1, 1, 1, 1); GL_ColorMask(0, 0, 0, 0); - GL_BlendFunc(GL_ONE, GL_ZERO); - GL_DepthMask(false); - GL_DepthTest(true); - qglPolygonOffset(r_shadowpolygonfactor, r_shadowpolygonoffset); - qglDepthFunc(GL_LESS); - qglCullFace(GL_FRONT); // quake is backwards, this culls back faces - qglEnable(GL_STENCIL_TEST); - qglStencilFunc(GL_ALWAYS, 128, ~0); + GL_PolygonOffset(r_refdef.shadowpolygonfactor, r_refdef.shadowpolygonoffset);CHECKGLERROR + qglDepthFunc(GL_LESS);CHECKGLERROR + qglEnable(GL_STENCIL_TEST);CHECKGLERROR r_shadow_rendermode = r_shadow_shadowingrendermode; - if (r_shadow_rendermode == R_SHADOW_RENDERMODE_STENCILTWOSIDE) + if (r_shadow_rendermode == R_SHADOW_RENDERMODE_SEPARATESTENCIL) { - qglDisable(GL_CULL_FACE); - qglEnable(GL_STENCIL_TEST_TWO_SIDE_EXT); - qglActiveStencilFaceEXT(GL_BACK); // quake is backwards, this is front faces - qglStencilMask(~0); - qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP); - qglActiveStencilFaceEXT(GL_FRONT); // quake is backwards, this is back faces - qglStencilMask(~0); - qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP); + GL_CullFace(GL_NONE); + qglStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR, GL_KEEP);CHECKGLERROR // quake is backwards, this is front faces + qglStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR, GL_KEEP);CHECKGLERROR // quake is backwards, this is back faces } - else + else if (r_shadow_rendermode == R_SHADOW_RENDERMODE_STENCILTWOSIDE) { - qglEnable(GL_CULL_FACE); - qglStencilMask(~0); - // this is changed by every shadow render so its value here is unimportant - qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); - } - GL_Clear(GL_STENCIL_BUFFER_BIT); - renderstats.lights_clears++; + GL_CullFace(GL_NONE); + qglEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);CHECKGLERROR + qglActiveStencilFaceEXT(GL_BACK);CHECKGLERROR // quake is backwards, this is front faces + qglStencilMask(~0);CHECKGLERROR + qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);CHECKGLERROR + qglActiveStencilFaceEXT(GL_FRONT);CHECKGLERROR // quake is backwards, this is back faces + qglStencilMask(~0);CHECKGLERROR + qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);CHECKGLERROR + } + if (clearstencil) + GL_Clear(GL_STENCIL_BUFFER_BIT); + r_refdef.stats.lights_clears++; } void R_Shadow_RenderMode_Lighting(qboolean stenciltest, qboolean transparent) { + CHECKGLERROR R_Shadow_RenderMode_Reset(); GL_BlendFunc(GL_SRC_ALPHA, GL_ONE); - GL_DepthMask(false); - GL_DepthTest(true); - qglPolygonOffset(r_polygonfactor, r_polygonoffset); - //qglDisable(GL_POLYGON_OFFSET_FILL); - GL_Color(1, 1, 1, 1); - GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 1); - if (transparent) - qglDepthFunc(GL_LEQUAL); - else - qglDepthFunc(GL_EQUAL); - qglCullFace(GL_FRONT); // quake is backwards, this culls back faces - qglEnable(GL_CULL_FACE); + if (!transparent) + { + qglDepthFunc(GL_EQUAL);CHECKGLERROR + } if (stenciltest) - qglEnable(GL_STENCIL_TEST); - else - qglDisable(GL_STENCIL_TEST); - qglStencilMask(~0); - qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); - // only draw light where this geometry was already rendered AND the - // stencil is 128 (values other than this mean shadow) - qglStencilFunc(GL_EQUAL, 128, ~0); + { + qglEnable(GL_STENCIL_TEST);CHECKGLERROR + // only draw light where this geometry was already rendered AND the + // stencil is 128 (values other than this mean shadow) + qglStencilFunc(GL_EQUAL, 128, ~0);CHECKGLERROR + } r_shadow_rendermode = r_shadow_lightingrendermode; // do global setup needed for the chosen lighting mode if (r_shadow_rendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL) @@ -936,76 +1093,60 @@ void R_Shadow_RenderMode_Lighting(qboolean stenciltest, qboolean transparent) R_Mesh_TexBind(0, R_GetTexture(r_texture_blanknormalmap)); // normal R_Mesh_TexBind(1, R_GetTexture(r_texture_white)); // diffuse R_Mesh_TexBind(2, R_GetTexture(r_texture_white)); // gloss - R_Mesh_TexBindCubeMap(3, R_GetTexture(r_shadow_rtlight->currentcubemap)); // light filter + R_Mesh_TexBindCubeMap(3, R_GetTexture(rsurface.rtlight->currentcubemap)); // light filter R_Mesh_TexBind(4, R_GetTexture(r_texture_fogattenuation)); // fog R_Mesh_TexBind(5, R_GetTexture(r_texture_white)); // pants R_Mesh_TexBind(6, R_GetTexture(r_texture_white)); // shirt - //R_Mesh_TexMatrix(3, r_shadow_entitytolight); // light filter matrix + R_Mesh_TexBind(7, R_GetTexture(r_texture_white)); // lightmap + R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap)); // deluxemap + R_Mesh_TexBind(9, R_GetTexture(r_texture_black)); // glow + //R_Mesh_TexMatrix(3, rsurface.entitytolight); // light filter matrix GL_BlendFunc(GL_SRC_ALPHA, GL_ONE); - GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 0); + GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 0); CHECKGLERROR } } void R_Shadow_RenderMode_VisibleShadowVolumes(void) { + CHECKGLERROR R_Shadow_RenderMode_Reset(); GL_BlendFunc(GL_ONE, GL_ONE); - GL_DepthMask(false); - GL_DepthTest(!r_showdisabledepthtest.integer); - qglPolygonOffset(r_polygonfactor, r_polygonoffset); - GL_Color(0.0, 0.0125, 0.1, 1); - GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 1); - qglDepthFunc(GL_GEQUAL); - qglCullFace(GL_FRONT); // this culls back - qglDisable(GL_CULL_FACE); - qglDisable(GL_STENCIL_TEST); + GL_DepthRange(0, 1); + GL_DepthTest(r_showshadowvolumes.integer < 2); + GL_Color(0.0, 0.0125 * r_view.colorscale, 0.1 * r_view.colorscale, 1); + GL_PolygonOffset(r_refdef.shadowpolygonfactor, r_refdef.shadowpolygonoffset);CHECKGLERROR + GL_CullFace(GL_NONE); r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLEVOLUMES; } void R_Shadow_RenderMode_VisibleLighting(qboolean stenciltest, qboolean transparent) { + CHECKGLERROR R_Shadow_RenderMode_Reset(); GL_BlendFunc(GL_ONE, GL_ONE); - GL_DepthMask(false); - GL_DepthTest(!r_showdisabledepthtest.integer); - qglPolygonOffset(r_polygonfactor, r_polygonoffset); - GL_Color(0.1, 0.0125, 0, 1); - GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 1); - if (transparent) - qglDepthFunc(GL_LEQUAL); - else - qglDepthFunc(GL_EQUAL); - qglCullFace(GL_FRONT); // this culls back - qglEnable(GL_CULL_FACE); + GL_DepthRange(0, 1); + GL_DepthTest(r_showlighting.integer < 2); + GL_Color(0.1 * r_view.colorscale, 0.0125 * r_view.colorscale, 0, 1); + if (!transparent) + { + qglDepthFunc(GL_EQUAL);CHECKGLERROR + } if (stenciltest) - qglEnable(GL_STENCIL_TEST); - else - qglDisable(GL_STENCIL_TEST); + { + qglEnable(GL_STENCIL_TEST);CHECKGLERROR + qglStencilFunc(GL_EQUAL, 128, ~0);CHECKGLERROR + } r_shadow_rendermode = R_SHADOW_RENDERMODE_VISIBLELIGHTING; } void R_Shadow_RenderMode_End(void) { + CHECKGLERROR R_Shadow_RenderMode_Reset(); R_Shadow_RenderMode_ActiveLight(NULL); - GL_BlendFunc(GL_ONE, GL_ZERO); GL_DepthMask(true); - GL_DepthTest(true); - qglPolygonOffset(r_polygonfactor, r_polygonoffset); - //qglDisable(GL_POLYGON_OFFSET_FILL); - GL_Color(1, 1, 1, 1); - GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 1); - GL_Scissor(r_view_x, r_view_y, r_view_width, r_view_height); - qglDepthFunc(GL_LEQUAL); - qglCullFace(GL_FRONT); // quake is backwards, this culls back faces - qglEnable(GL_CULL_FACE); - qglDisable(GL_STENCIL_TEST); - qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); - if (gl_support_stenciltwoside) - qglDisable(GL_STENCIL_TEST_TWO_SIDE_EXT); - qglStencilMask(~0); - qglStencilFunc(GL_ALWAYS, 128, ~0); + GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height); r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE; } @@ -1019,18 +1160,18 @@ qboolean R_Shadow_ScissorForBBox(const float *mins, const float *maxs) float vertex3f[256*3]; // if view is inside the light box, just say yes it's visible - if (BoxesOverlap(r_vieworigin, r_vieworigin, mins, maxs)) + if (BoxesOverlap(r_view.origin, r_view.origin, mins, maxs)) { - GL_Scissor(r_view_x, r_view_y, r_view_width, r_view_height); + GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height); return false; } // create a temporary brush describing the area the light can affect in worldspace - VectorNegate(frustum[0].normal, planes[ 0].normal);planes[ 0].dist = -frustum[0].dist; - VectorNegate(frustum[1].normal, planes[ 1].normal);planes[ 1].dist = -frustum[1].dist; - VectorNegate(frustum[2].normal, planes[ 2].normal);planes[ 2].dist = -frustum[2].dist; - VectorNegate(frustum[3].normal, planes[ 3].normal);planes[ 3].dist = -frustum[3].dist; - VectorNegate(frustum[4].normal, planes[ 4].normal);planes[ 4].dist = -frustum[4].dist; + VectorNegate(r_view.frustum[0].normal, planes[ 0].normal);planes[ 0].dist = -r_view.frustum[0].dist; + VectorNegate(r_view.frustum[1].normal, planes[ 1].normal);planes[ 1].dist = -r_view.frustum[1].dist; + VectorNegate(r_view.frustum[2].normal, planes[ 2].normal);planes[ 2].dist = -r_view.frustum[2].dist; + VectorNegate(r_view.frustum[3].normal, planes[ 3].normal);planes[ 3].dist = -r_view.frustum[3].dist; + VectorNegate(r_view.frustum[4].normal, planes[ 4].normal);planes[ 4].dist = -r_view.frustum[4].dist; VectorSet (planes[ 5].normal, 1, 0, 0); planes[ 5].dist = maxs[0]; VectorSet (planes[ 6].normal, -1, 0, 0); planes[ 6].dist = -mins[0]; VectorSet (planes[ 7].normal, 0, 1, 0); planes[ 7].dist = maxs[1]; @@ -1055,6 +1196,7 @@ qboolean R_Shadow_ScissorForBBox(const float *mins, const float *maxs) // if that mesh is not empty, check what area of the screen it covers x1 = y1 = x2 = y2 = 0; v[3] = 1.0f; + //Con_Printf("%i vertices to transform...\n", mesh.numvertices); for (i = 0;i < mesh.numvertices;i++) { VectorCopy(mesh.vertex3f + i * 3, v); @@ -1082,131 +1224,203 @@ qboolean R_Shadow_ScissorForBBox(const float *mins, const float *maxs) //Con_Printf("%f %f %f %f\n", x1, y1, x2, y2); // clamp it to the screen - if (ix1 < r_view_x) ix1 = r_view_x; - if (iy1 < r_view_y) iy1 = r_view_y; - if (ix2 > r_view_x + r_view_width) ix2 = r_view_x + r_view_width; - if (iy2 > r_view_y + r_view_height) iy2 = r_view_y + r_view_height; + if (ix1 < r_view.x) ix1 = r_view.x; + if (iy1 < r_view.y) iy1 = r_view.y; + if (ix2 > r_view.x + r_view.width) ix2 = r_view.x + r_view.width; + if (iy2 > r_view.y + r_view.height) iy2 = r_view.y + r_view.height; // if it is inside out, it's not visible if (ix2 <= ix1 || iy2 <= iy1) return true; // the light area is visible, set up the scissor rectangle - GL_Scissor(ix1, vid.height - iy2, ix2 - ix1, iy2 - iy1); - //qglScissor(ix1, iy1, ix2 - ix1, iy2 - iy1); - //qglEnable(GL_SCISSOR_TEST); - renderstats.lights_scissored++; + GL_Scissor(ix1, iy1, ix2 - ix1, iy2 - iy1); + //qglScissor(ix1, iy1, ix2 - ix1, iy2 - iy1);CHECKGLERROR + //qglEnable(GL_SCISSOR_TEST);CHECKGLERROR + r_refdef.stats.lights_scissored++; return false; } -static void R_Shadow_RenderSurfacesLighting_Light_Vertex_Shading(const msurface_t *surface, const float *diffusecolor, const float *ambientcolor) +static void R_Shadow_RenderLighting_Light_Vertex_Shading(int firstvertex, int numverts, int numtriangles, const int *element3i, const float *diffusecolor, const float *ambientcolor) { - int numverts = surface->num_vertices; - float *vertex3f = rsurface_vertex3f + 3 * surface->num_firstvertex; - float *normal3f = rsurface_normal3f + 3 * surface->num_firstvertex; - float *color4f = rsurface_array_color4f + 4 * surface->num_firstvertex; + float *vertex3f = rsurface.vertex3f + 3 * firstvertex; + float *normal3f = rsurface.normal3f + 3 * firstvertex; + float *color4f = rsurface.array_color4f + 4 * firstvertex; float dist, dot, distintensity, shadeintensity, v[3], n[3]; if (r_textureunits.integer >= 3) { - for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4) + if (VectorLength2(diffusecolor) > 0) { - Matrix4x4_Transform(&r_shadow_entitytolight, vertex3f, v); - Matrix4x4_Transform3x3(&r_shadow_entitytolight, normal3f, n); - if ((dot = DotProduct(n, v)) < 0) + for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4) { - shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n)); - color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]); - color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]); - color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]); - if (fogenabled) + Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v); + Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n); + if ((dot = DotProduct(n, v)) < 0) { - float f = VERTEXFOGTABLE(VectorDistance(v, r_shadow_entityeyeorigin)); + shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n)); + VectorMA(ambientcolor, shadeintensity, diffusecolor, color4f); + } + else + VectorCopy(ambientcolor, color4f); + if (r_refdef.fogenabled) + { + float f; + f = FogPoint_Model(vertex3f); VectorScale(color4f, f, color4f); } + color4f[3] = 1; + } + } + else + { + for (;numverts > 0;numverts--, vertex3f += 3, color4f += 4) + { + VectorCopy(ambientcolor, color4f); + if (r_refdef.fogenabled) + { + float f; + Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v); + f = FogPoint_Model(vertex3f); + VectorScale(color4f, f, color4f); + } + color4f[3] = 1; } - else - VectorClear(color4f); - color4f[3] = 1; } } else if (r_textureunits.integer >= 2) { - for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4) + if (VectorLength2(diffusecolor) > 0) { - Matrix4x4_Transform(&r_shadow_entitytolight, vertex3f, v); - if ((dist = fabs(v[2])) < 1) + for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4) { - distintensity = pow(1 - dist, r_shadow_attenpower) * r_shadow_attenscale; - Matrix4x4_Transform3x3(&r_shadow_entitytolight, normal3f, n); - if ((dot = DotProduct(n, v)) < 0) + Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v); + if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)])) { - shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n)); - color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity; - color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity; - color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity; + Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n); + if ((dot = DotProduct(n, v)) < 0) + { + shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n)); + color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity; + color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity; + color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity; + } + else + { + color4f[0] = ambientcolor[0] * distintensity; + color4f[1] = ambientcolor[1] * distintensity; + color4f[2] = ambientcolor[2] * distintensity; + } + if (r_refdef.fogenabled) + { + float f; + f = FogPoint_Model(vertex3f); + VectorScale(color4f, f, color4f); + } } else + VectorClear(color4f); + color4f[3] = 1; + } + } + else + { + for (;numverts > 0;numverts--, vertex3f += 3, color4f += 4) + { + Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v); + if ((dist = fabs(v[2])) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)])) { color4f[0] = ambientcolor[0] * distintensity; color4f[1] = ambientcolor[1] * distintensity; color4f[2] = ambientcolor[2] * distintensity; + if (r_refdef.fogenabled) + { + float f; + f = FogPoint_Model(vertex3f); + VectorScale(color4f, f, color4f); + } } - if (fogenabled) - { - float f = VERTEXFOGTABLE(VectorDistance(v, r_shadow_entityeyeorigin)); - VectorScale(color4f, f, color4f); - } + else + VectorClear(color4f); + color4f[3] = 1; } - else - VectorClear(color4f); - color4f[3] = 1; } } else { - for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4) + if (VectorLength2(diffusecolor) > 0) { - Matrix4x4_Transform(&r_shadow_entitytolight, vertex3f, v); - if ((dist = DotProduct(v, v)) < 1) + for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4) { - dist = sqrt(dist); - distintensity = pow(1 - dist, r_shadow_attenpower) * r_shadow_attenscale; - Matrix4x4_Transform3x3(&r_shadow_entitytolight, normal3f, n); - if ((dot = DotProduct(n, v)) < 0) + Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v); + if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)])) { - shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n)); - color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity; - color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity; - color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity; + distintensity = (1 - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist); + Matrix4x4_Transform3x3(&rsurface.entitytolight, normal3f, n); + if ((dot = DotProduct(n, v)) < 0) + { + shadeintensity = -dot / sqrt(VectorLength2(v) * VectorLength2(n)); + color4f[0] = (ambientcolor[0] + shadeintensity * diffusecolor[0]) * distintensity; + color4f[1] = (ambientcolor[1] + shadeintensity * diffusecolor[1]) * distintensity; + color4f[2] = (ambientcolor[2] + shadeintensity * diffusecolor[2]) * distintensity; + } + else + { + color4f[0] = ambientcolor[0] * distintensity; + color4f[1] = ambientcolor[1] * distintensity; + color4f[2] = ambientcolor[2] * distintensity; + } + if (r_refdef.fogenabled) + { + float f; + f = FogPoint_Model(vertex3f); + VectorScale(color4f, f, color4f); + } } else + VectorClear(color4f); + color4f[3] = 1; + } + } + else + { + for (;numverts > 0;numverts--, vertex3f += 3, color4f += 4) + { + Matrix4x4_Transform(&rsurface.entitytolight, vertex3f, v); + if ((dist = VectorLength(v)) < 1 && (distintensity = r_shadow_attentable[(int)(dist * ATTENTABLESIZE)])) { + distintensity = (1 - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist); color4f[0] = ambientcolor[0] * distintensity; color4f[1] = ambientcolor[1] * distintensity; color4f[2] = ambientcolor[2] * distintensity; + if (r_refdef.fogenabled) + { + float f; + f = FogPoint_Model(vertex3f); + VectorScale(color4f, f, color4f); + } } - if (fogenabled) - { - float f = VERTEXFOGTABLE(VectorDistance(v, r_shadow_entityeyeorigin)); - VectorScale(color4f, f, color4f); - } + else + VectorClear(color4f); + color4f[3] = 1; } - else - VectorClear(color4f); - color4f[3] = 1; } } } // TODO: use glTexGen instead of feeding vertices to texcoordpointer? -static void R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(float *out3f, int numverts, const float *vertex3f, const float *svector3f, const float *tvector3f, const float *normal3f, const vec3_t relativelightorigin) +static void R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(int firstvertex, int numvertices, int numtriangles, const int *element3i) { int i; + float *out3f = rsurface.array_texcoord3f + 3 * firstvertex; + const float *vertex3f = rsurface.vertex3f + 3 * firstvertex; + const float *svector3f = rsurface.svector3f + 3 * firstvertex; + const float *tvector3f = rsurface.tvector3f + 3 * firstvertex; + const float *normal3f = rsurface.normal3f + 3 * firstvertex; float lightdir[3]; - for (i = 0;i < numverts;i++, vertex3f += 3, svector3f += 3, tvector3f += 3, normal3f += 3, out3f += 3) + for (i = 0;i < numvertices;i++, vertex3f += 3, svector3f += 3, tvector3f += 3, normal3f += 3, out3f += 3) { - VectorSubtract(relativelightorigin, vertex3f, lightdir); + VectorSubtract(rsurface.entitylightorigin, vertex3f, lightdir); // the cubemap normalizes this for us out3f[0] = DotProduct(svector3f, lightdir); out3f[1] = DotProduct(tvector3f, lightdir); @@ -1214,15 +1428,20 @@ static void R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(float *out3f, int numver } } -static void R_Shadow_GenTexCoords_Specular_NormalCubeMap(float *out3f, int numverts, const float *vertex3f, const float *svector3f, const float *tvector3f, const float *normal3f, const vec3_t relativelightorigin, const vec3_t relativeeyeorigin) +static void R_Shadow_GenTexCoords_Specular_NormalCubeMap(int firstvertex, int numvertices, int numtriangles, const int *element3i) { int i; + float *out3f = rsurface.array_texcoord3f + 3 * firstvertex; + const float *vertex3f = rsurface.vertex3f + 3 * firstvertex; + const float *svector3f = rsurface.svector3f + 3 * firstvertex; + const float *tvector3f = rsurface.tvector3f + 3 * firstvertex; + const float *normal3f = rsurface.normal3f + 3 * firstvertex; float lightdir[3], eyedir[3], halfdir[3]; - for (i = 0;i < numverts;i++, vertex3f += 3, svector3f += 3, tvector3f += 3, normal3f += 3, out3f += 3) + for (i = 0;i < numvertices;i++, vertex3f += 3, svector3f += 3, tvector3f += 3, normal3f += 3, out3f += 3) { - VectorSubtract(relativelightorigin, vertex3f, lightdir); + VectorSubtract(rsurface.entitylightorigin, vertex3f, lightdir); VectorNormalize(lightdir); - VectorSubtract(relativeeyeorigin, vertex3f, eyedir); + VectorSubtract(rsurface.modelorg, vertex3f, eyedir); VectorNormalize(eyedir); VectorAdd(lightdir, eyedir, halfdir); // the cubemap normalizes this for us @@ -1232,58 +1451,49 @@ static void R_Shadow_GenTexCoords_Specular_NormalCubeMap(float *out3f, int numve } } -static void R_Shadow_RenderSurfacesLighting_VisibleLighting(const entity_render_t *ent, const texture_t *texture, int numsurfaces, msurface_t **surfacelist, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float specularscale, qboolean dopants, qboolean doshirt) +static void R_Shadow_RenderLighting_VisibleLighting(int firstvertex, int numvertices, int numtriangles, const int *element3i, int element3i_bufferobject, size_t element3i_bufferoffset, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float ambientscale, float diffusescale, float specularscale, qboolean dopants, qboolean doshirt) { // used to display how many times a surface is lit for level design purposes - int surfacelistindex; - model_t *model = ent->model; - rmeshstate_t m; - GL_Color(0.1, 0.025, 0, 1); - memset(&m, 0, sizeof(m)); - R_Mesh_State(&m); - RSurf_SetPointersForPass(false, false); - for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++) - { - const msurface_t *surface = surfacelist[surfacelistindex]; - if (rsurface_dynamicvertex) - RSurf_PrepareDynamicSurfaceVertices(surface); - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, model->surfmesh.data_element3i + 3 * surface->num_firsttriangle); - GL_LockArrays(0, 0); - } + GL_Color(0.1 * r_view.colorscale, 0.025 * r_view.colorscale, 0, 1); + R_Mesh_ColorPointer(NULL, 0, 0); + R_Mesh_ResetTextureState(); + R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset); } -static void R_Shadow_RenderSurfacesLighting_Light_GLSL(const entity_render_t *ent, const texture_t *texture, int numsurfaces, msurface_t **surfacelist, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float specularscale, qboolean dopants, qboolean doshirt) +static void R_Shadow_RenderLighting_Light_GLSL(int firstvertex, int numvertices, int numtriangles, const int *element3i, int element3i_bufferobject, size_t element3i_bufferoffset, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float ambientscale, float diffusescale, float specularscale, qboolean dopants, qboolean doshirt) { // ARB2 GLSL shader path (GFFX5200, Radeon 9500) - int surfacelistindex; - model_t *model = ent->model; - R_SetupSurfaceShader(ent, texture, r_shadow_entityeyeorigin, lightcolorbase, false); - RSurf_SetPointersForPass(false, true); - for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++) + R_SetupSurfaceShader(lightcolorbase, false, ambientscale, diffusescale, specularscale); + R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset); + R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset); + R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset); + R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset); + if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) { - const msurface_t *surface = surfacelist[surfacelistindex]; - const int *elements = model->surfmesh.data_element3i + surface->num_firsttriangle * 3; - if (rsurface_dynamicvertex) - RSurf_PrepareDynamicSurfaceVertices(surface); - R_Mesh_TexCoordPointer(0, 2, model->surfmesh.data_texcoordtexture2f); - R_Mesh_TexCoordPointer(1, 3, rsurface_svector3f); - R_Mesh_TexCoordPointer(2, 3, rsurface_tvector3f); - R_Mesh_TexCoordPointer(3, 3, rsurface_normal3f); - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - GL_LockArrays(0, 0); + qglDepthFunc(GL_EQUAL);CHECKGLERROR + } + R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset); + if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) + { + qglDepthFunc(GL_LEQUAL);CHECKGLERROR } } -static void R_Shadow_RenderSurfacesLighting_Light_Dot3_AmbientPass(const entity_render_t *ent, const texture_t *texture, const msurface_t *surface, const vec3_t lightcolorbase, rtexture_t *basetexture, float colorscale) +static void R_Shadow_RenderLighting_Light_Dot3_Finalize(int firstvertex, int numvertices, int numtriangles, const int *element3i, int element3i_bufferobject, size_t element3i_bufferoffset, float r, float g, float b) { + // shared final code for all the dot3 layers int renders; - model_t *model = ent->model; - float color2[3]; + GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 0); + for (renders = 0;renders < 64 && (r > 0 || g > 0 || b > 0);renders++, r--, g--, b--) + { + GL_Color(bound(0, r, 1), bound(0, g, 1), bound(0, b, 1), 1); + R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset); + } +} + +static void R_Shadow_RenderLighting_Light_Dot3_AmbientPass(int firstvertex, int numvertices, int numtriangles, const int *element3i, int element3i_bufferobject, size_t element3i_bufferoffset, const vec3_t lightcolorbase, rtexture_t *basetexture, float colorscale) +{ rmeshstate_t m; - const int *elements = model->surfmesh.data_element3i + surface->num_firsttriangle * 3; - GL_Color(1,1,1,1); // colorscale accounts for how much we multiply the brightness // during combine. // @@ -1291,125 +1501,138 @@ static void R_Shadow_RenderSurfacesLighting_Light_Dot3_AmbientPass(const entity_ // performed to get more brightness than otherwise possible. // // Limit mult to 64 for sanity sake. - if (r_shadow_texture3d.integer && r_shadow_rtlight->currentcubemap != r_texture_whitecube && r_textureunits.integer >= 4) + GL_Color(1,1,1,1); + if (r_shadow_texture3d.integer && rsurface.rtlight->currentcubemap != r_texture_whitecube && r_textureunits.integer >= 4) { // 3 3D combine path (Geforce3, Radeon 8500) memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture); - m.pointer_texcoord3f[0] = rsurface_vertex3f; - m.texmatrix[0] = r_shadow_entitytoattenuationxyz; + m.pointer_texcoord3f[0] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset; + m.texmatrix[0] = rsurface.entitytoattenuationxyz; m.tex[1] = R_GetTexture(basetexture); - m.pointer_texcoord[1] = model->surfmesh.data_texcoordtexture2f; - m.texmatrix[1] = texture->currenttexmatrix; - m.texcubemap[2] = R_GetTexture(r_shadow_rtlight->currentcubemap); - m.pointer_texcoord3f[2] = rsurface_vertex3f; - m.texmatrix[2] = r_shadow_entitytolight; + m.pointer_texcoord[1] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[1] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[1] = rsurface.texcoordtexture2f_bufferoffset; + m.texmatrix[1] = rsurface.texture->currenttexmatrix; + m.texcubemap[2] = R_GetTexture(rsurface.rtlight->currentcubemap); + m.pointer_texcoord3f[2] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[2] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[2] = rsurface.vertex3f_bufferoffset; + m.texmatrix[2] = rsurface.entitytolight; GL_BlendFunc(GL_ONE, GL_ONE); } - else if (r_shadow_texture3d.integer && r_shadow_rtlight->currentcubemap == r_texture_whitecube && r_textureunits.integer >= 2) + else if (r_shadow_texture3d.integer && rsurface.rtlight->currentcubemap == r_texture_whitecube && r_textureunits.integer >= 2) { // 2 3D combine path (Geforce3, original Radeon) memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture); - m.pointer_texcoord3f[0] = rsurface_vertex3f; - m.texmatrix[0] = r_shadow_entitytoattenuationxyz; + m.pointer_texcoord3f[0] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset; + m.texmatrix[0] = rsurface.entitytoattenuationxyz; m.tex[1] = R_GetTexture(basetexture); - m.pointer_texcoord[1] = model->surfmesh.data_texcoordtexture2f; - m.texmatrix[1] = texture->currenttexmatrix; + m.pointer_texcoord[1] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[1] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[1] = rsurface.texcoordtexture2f_bufferoffset; + m.texmatrix[1] = rsurface.texture->currenttexmatrix; GL_BlendFunc(GL_ONE, GL_ONE); } - else if (r_textureunits.integer >= 4 && r_shadow_rtlight->currentcubemap != r_texture_whitecube) + else if (r_textureunits.integer >= 4 && rsurface.rtlight->currentcubemap != r_texture_whitecube) { // 4 2D combine path (Geforce3, Radeon 8500) memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture); - m.pointer_texcoord3f[0] = rsurface_vertex3f; - m.texmatrix[0] = r_shadow_entitytoattenuationxyz; + m.pointer_texcoord3f[0] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset; + m.texmatrix[0] = rsurface.entitytoattenuationxyz; m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture); - m.pointer_texcoord3f[1] = rsurface_vertex3f; - m.texmatrix[1] = r_shadow_entitytoattenuationz; + m.pointer_texcoord3f[1] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset; + m.texmatrix[1] = rsurface.entitytoattenuationz; m.tex[2] = R_GetTexture(basetexture); - m.pointer_texcoord[2] = model->surfmesh.data_texcoordtexture2f; - m.texmatrix[2] = texture->currenttexmatrix; - if (r_shadow_rtlight->currentcubemap != r_texture_whitecube) + m.pointer_texcoord[2] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[2] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[2] = rsurface.texcoordtexture2f_bufferoffset; + m.texmatrix[2] = rsurface.texture->currenttexmatrix; + if (rsurface.rtlight->currentcubemap != r_texture_whitecube) { - m.texcubemap[3] = R_GetTexture(r_shadow_rtlight->currentcubemap); - m.pointer_texcoord3f[3] = rsurface_vertex3f; - m.texmatrix[3] = r_shadow_entitytolight; + m.texcubemap[3] = R_GetTexture(rsurface.rtlight->currentcubemap); + m.pointer_texcoord3f[3] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[3] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[3] = rsurface.vertex3f_bufferoffset; + m.texmatrix[3] = rsurface.entitytolight; } GL_BlendFunc(GL_ONE, GL_ONE); } - else if (r_textureunits.integer >= 3 && r_shadow_rtlight->currentcubemap == r_texture_whitecube) + else if (r_textureunits.integer >= 3 && rsurface.rtlight->currentcubemap == r_texture_whitecube) { // 3 2D combine path (Geforce3, original Radeon) memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture); - m.pointer_texcoord3f[0] = rsurface_vertex3f; - m.texmatrix[0] = r_shadow_entitytoattenuationxyz; + m.pointer_texcoord3f[0] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset; + m.texmatrix[0] = rsurface.entitytoattenuationxyz; m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture); - m.pointer_texcoord3f[1] = rsurface_vertex3f; - m.texmatrix[1] = r_shadow_entitytoattenuationz; + m.pointer_texcoord3f[1] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset; + m.texmatrix[1] = rsurface.entitytoattenuationz; m.tex[2] = R_GetTexture(basetexture); - m.pointer_texcoord[2] = model->surfmesh.data_texcoordtexture2f; - m.texmatrix[2] = texture->currenttexmatrix; + m.pointer_texcoord[2] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[2] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[2] = rsurface.texcoordtexture2f_bufferoffset; + m.texmatrix[2] = rsurface.texture->currenttexmatrix; GL_BlendFunc(GL_ONE, GL_ONE); } else { // 2/2/2 2D combine path (any dot3 card) memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture); - m.pointer_texcoord3f[0] = rsurface_vertex3f; - m.texmatrix[0] = r_shadow_entitytoattenuationxyz; + m.pointer_texcoord3f[0] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset; + m.texmatrix[0] = rsurface.entitytoattenuationxyz; m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture); - m.pointer_texcoord3f[1] = rsurface_vertex3f; - m.texmatrix[1] = r_shadow_entitytoattenuationz; - R_Mesh_State(&m); + m.pointer_texcoord3f[1] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset; + m.texmatrix[1] = rsurface.entitytoattenuationz; + R_Mesh_TextureState(&m); GL_ColorMask(0,0,0,1); GL_BlendFunc(GL_ONE, GL_ZERO); - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - GL_LockArrays(0, 0); + R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset); + // second pass memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex[0] = R_GetTexture(basetexture); - m.pointer_texcoord[0] = model->surfmesh.data_texcoordtexture2f; - m.texmatrix[0] = texture->currenttexmatrix; - if (r_shadow_rtlight->currentcubemap != r_texture_whitecube) + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; + m.texmatrix[0] = rsurface.texture->currenttexmatrix; + if (rsurface.rtlight->currentcubemap != r_texture_whitecube) { - m.texcubemap[1] = R_GetTexture(r_shadow_rtlight->currentcubemap); - m.pointer_texcoord3f[1] = rsurface_vertex3f; - m.texmatrix[1] = r_shadow_entitytolight; + m.texcubemap[1] = R_GetTexture(rsurface.rtlight->currentcubemap); + m.pointer_texcoord3f[1] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset; + m.texmatrix[1] = rsurface.entitytolight; } GL_BlendFunc(GL_DST_ALPHA, GL_ONE); } // this final code is shared - R_Mesh_State(&m); - GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 0); - VectorScale(lightcolorbase, colorscale, color2); - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--) - { - GL_Color(bound(0, color2[0], 1), bound(0, color2[1], 1), bound(0, color2[2], 1), 1); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - } - GL_LockArrays(0, 0); + R_Mesh_TextureState(&m); + R_Shadow_RenderLighting_Light_Dot3_Finalize(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase[0] * colorscale, lightcolorbase[1] * colorscale, lightcolorbase[2] * colorscale); } -static void R_Shadow_RenderSurfacesLighting_Light_Dot3_DiffusePass(const entity_render_t *ent, const texture_t *texture, const msurface_t *surface, const vec3_t lightcolorbase, rtexture_t *basetexture, rtexture_t *normalmaptexture, float colorscale) +static void R_Shadow_RenderLighting_Light_Dot3_DiffusePass(int firstvertex, int numvertices, int numtriangles, const int *element3i, int element3i_bufferobject, size_t element3i_bufferoffset, const vec3_t lightcolorbase, rtexture_t *basetexture, rtexture_t *normalmaptexture, float colorscale) { - int renders; - model_t *model = ent->model; - float color2[3]; rmeshstate_t m; - const int *elements = model->surfmesh.data_element3i + surface->num_firsttriangle * 3; - GL_Color(1,1,1,1); // colorscale accounts for how much we multiply the brightness // during combine. // @@ -1417,152 +1640,177 @@ static void R_Shadow_RenderSurfacesLighting_Light_Dot3_DiffusePass(const entity_ // performed to get more brightness than otherwise possible. // // Limit mult to 64 for sanity sake. + GL_Color(1,1,1,1); + // generate normalization cubemap texcoords + R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(firstvertex, numvertices, numtriangles, element3i); if (r_shadow_texture3d.integer && r_textureunits.integer >= 4) { // 3/2 3D combine path (Geforce3, Radeon 8500) memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex[0] = R_GetTexture(normalmaptexture); m.texcombinergb[0] = GL_REPLACE; - m.pointer_texcoord[0] = model->surfmesh.data_texcoordtexture2f; - m.texmatrix[0] = texture->currenttexmatrix; + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; + m.texmatrix[0] = rsurface.texture->currenttexmatrix; m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube); m.texcombinergb[1] = GL_DOT3_RGBA_ARB; - m.pointer_texcoord3f[1] = rsurface_array_texcoord3f; - R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(rsurface_array_texcoord3f + 3 * surface->num_firstvertex, surface->num_vertices, rsurface_vertex3f + 3 * surface->num_firstvertex, rsurface_svector3f + 3 * surface->num_firstvertex, rsurface_tvector3f + 3 * surface->num_firstvertex, rsurface_normal3f + 3 * surface->num_firstvertex, r_shadow_entitylightorigin); + m.pointer_texcoord3f[1] = rsurface.array_texcoord3f; + m.pointer_texcoord_bufferobject[1] = 0; + m.pointer_texcoord_bufferoffset[1] = 0; m.tex3d[2] = R_GetTexture(r_shadow_attenuation3dtexture); - m.pointer_texcoord3f[2] = rsurface_vertex3f; - m.texmatrix[2] = r_shadow_entitytoattenuationxyz; - R_Mesh_State(&m); + m.pointer_texcoord3f[2] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[2] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[2] = rsurface.vertex3f_bufferoffset; + m.texmatrix[2] = rsurface.entitytoattenuationxyz; + R_Mesh_TextureState(&m); GL_ColorMask(0,0,0,1); GL_BlendFunc(GL_ONE, GL_ZERO); - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - GL_LockArrays(0, 0); + R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset); + // second pass memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex[0] = R_GetTexture(basetexture); - m.pointer_texcoord[0] = model->surfmesh.data_texcoordtexture2f; - m.texmatrix[0] = texture->currenttexmatrix; - if (r_shadow_rtlight->currentcubemap != r_texture_whitecube) + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; + m.texmatrix[0] = rsurface.texture->currenttexmatrix; + if (rsurface.rtlight->currentcubemap != r_texture_whitecube) { - m.texcubemap[1] = R_GetTexture(r_shadow_rtlight->currentcubemap); - m.pointer_texcoord3f[1] = rsurface_vertex3f; - m.texmatrix[1] = r_shadow_entitytolight; + m.texcubemap[1] = R_GetTexture(rsurface.rtlight->currentcubemap); + m.pointer_texcoord3f[1] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset; + m.texmatrix[1] = rsurface.entitytolight; } GL_BlendFunc(GL_DST_ALPHA, GL_ONE); } - else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && r_shadow_rtlight->currentcubemap != r_texture_whitecube) + else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && rsurface.rtlight->currentcubemap != r_texture_whitecube) { // 1/2/2 3D combine path (original Radeon) memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture); - m.pointer_texcoord3f[0] = rsurface_vertex3f; - m.texmatrix[0] = r_shadow_entitytoattenuationxyz; - R_Mesh_State(&m); + m.pointer_texcoord3f[0] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset; + m.texmatrix[0] = rsurface.entitytoattenuationxyz; + R_Mesh_TextureState(&m); GL_ColorMask(0,0,0,1); GL_BlendFunc(GL_ONE, GL_ZERO); - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - GL_LockArrays(0, 0); + R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset); + // second pass memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex[0] = R_GetTexture(normalmaptexture); m.texcombinergb[0] = GL_REPLACE; - m.pointer_texcoord[0] = model->surfmesh.data_texcoordtexture2f; - m.texmatrix[0] = texture->currenttexmatrix; + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; + m.texmatrix[0] = rsurface.texture->currenttexmatrix; m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube); m.texcombinergb[1] = GL_DOT3_RGBA_ARB; - m.pointer_texcoord3f[1] = rsurface_array_texcoord3f; - R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(rsurface_array_texcoord3f + 3 * surface->num_firstvertex, surface->num_vertices, rsurface_vertex3f + 3 * surface->num_firstvertex, rsurface_svector3f + 3 * surface->num_firstvertex, rsurface_tvector3f + 3 * surface->num_firstvertex, rsurface_normal3f + 3 * surface->num_firstvertex, r_shadow_entitylightorigin); - R_Mesh_State(&m); + m.pointer_texcoord3f[1] = rsurface.array_texcoord3f; + m.pointer_texcoord_bufferobject[1] = 0; + m.pointer_texcoord_bufferoffset[1] = 0; + R_Mesh_TextureState(&m); GL_BlendFunc(GL_DST_ALPHA, GL_ZERO); - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - GL_LockArrays(0, 0); + R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset); + // second pass memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex[0] = R_GetTexture(basetexture); - m.pointer_texcoord[0] = model->surfmesh.data_texcoordtexture2f; - m.texmatrix[0] = texture->currenttexmatrix; - if (r_shadow_rtlight->currentcubemap != r_texture_whitecube) + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; + m.texmatrix[0] = rsurface.texture->currenttexmatrix; + if (rsurface.rtlight->currentcubemap != r_texture_whitecube) { - m.texcubemap[1] = R_GetTexture(r_shadow_rtlight->currentcubemap); - m.pointer_texcoord3f[1] = rsurface_vertex3f; - m.texmatrix[1] = r_shadow_entitytolight; + m.texcubemap[1] = R_GetTexture(rsurface.rtlight->currentcubemap); + m.pointer_texcoord3f[1] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset; + m.texmatrix[1] = rsurface.entitytolight; } GL_BlendFunc(GL_DST_ALPHA, GL_ONE); } - else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && r_shadow_rtlight->currentcubemap == r_texture_whitecube) + else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && rsurface.rtlight->currentcubemap == r_texture_whitecube) { // 2/2 3D combine path (original Radeon) memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex[0] = R_GetTexture(normalmaptexture); m.texcombinergb[0] = GL_REPLACE; - m.pointer_texcoord[0] = model->surfmesh.data_texcoordtexture2f; - m.texmatrix[0] = texture->currenttexmatrix; + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; + m.texmatrix[0] = rsurface.texture->currenttexmatrix; m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube); m.texcombinergb[1] = GL_DOT3_RGBA_ARB; - m.pointer_texcoord3f[1] = rsurface_array_texcoord3f; - R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(rsurface_array_texcoord3f + 3 * surface->num_firstvertex, surface->num_vertices, rsurface_vertex3f + 3 * surface->num_firstvertex, rsurface_svector3f + 3 * surface->num_firstvertex, rsurface_tvector3f + 3 * surface->num_firstvertex, rsurface_normal3f + 3 * surface->num_firstvertex, r_shadow_entitylightorigin); - R_Mesh_State(&m); + m.pointer_texcoord3f[1] = rsurface.array_texcoord3f; + m.pointer_texcoord_bufferobject[1] = 0; + m.pointer_texcoord_bufferoffset[1] = 0; + R_Mesh_TextureState(&m); GL_ColorMask(0,0,0,1); GL_BlendFunc(GL_ONE, GL_ZERO); - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - GL_LockArrays(0, 0); + R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset); + // second pass memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex[0] = R_GetTexture(basetexture); - m.pointer_texcoord[0] = model->surfmesh.data_texcoordtexture2f; - m.texmatrix[0] = texture->currenttexmatrix; + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; + m.texmatrix[0] = rsurface.texture->currenttexmatrix; m.tex3d[1] = R_GetTexture(r_shadow_attenuation3dtexture); - m.pointer_texcoord3f[1] = rsurface_vertex3f; - m.texmatrix[1] = r_shadow_entitytoattenuationxyz; + m.pointer_texcoord3f[1] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset; + m.texmatrix[1] = rsurface.entitytoattenuationxyz; GL_BlendFunc(GL_DST_ALPHA, GL_ONE); } else if (r_textureunits.integer >= 4) { // 4/2 2D combine path (Geforce3, Radeon 8500) memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex[0] = R_GetTexture(normalmaptexture); m.texcombinergb[0] = GL_REPLACE; - m.pointer_texcoord[0] = model->surfmesh.data_texcoordtexture2f; - m.texmatrix[0] = texture->currenttexmatrix; + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; + m.texmatrix[0] = rsurface.texture->currenttexmatrix; m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube); m.texcombinergb[1] = GL_DOT3_RGBA_ARB; - m.pointer_texcoord3f[1] = rsurface_array_texcoord3f; - R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(rsurface_array_texcoord3f + 3 * surface->num_firstvertex, surface->num_vertices, rsurface_vertex3f + 3 * surface->num_firstvertex, rsurface_svector3f + 3 * surface->num_firstvertex, rsurface_tvector3f + 3 * surface->num_firstvertex, rsurface_normal3f + 3 * surface->num_firstvertex, r_shadow_entitylightorigin); + m.pointer_texcoord3f[1] = rsurface.array_texcoord3f; + m.pointer_texcoord_bufferobject[1] = 0; + m.pointer_texcoord_bufferoffset[1] = 0; m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture); - m.pointer_texcoord3f[2] = rsurface_vertex3f; - m.texmatrix[2] = r_shadow_entitytoattenuationxyz; + m.pointer_texcoord3f[2] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[2] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[2] = rsurface.vertex3f_bufferoffset; + m.texmatrix[2] = rsurface.entitytoattenuationxyz; m.tex[3] = R_GetTexture(r_shadow_attenuation2dtexture); - m.pointer_texcoord3f[3] = rsurface_vertex3f; - m.texmatrix[3] = r_shadow_entitytoattenuationz; - R_Mesh_State(&m); + m.pointer_texcoord3f[3] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[3] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[3] = rsurface.vertex3f_bufferoffset; + m.texmatrix[3] = rsurface.entitytoattenuationz; + R_Mesh_TextureState(&m); GL_ColorMask(0,0,0,1); GL_BlendFunc(GL_ONE, GL_ZERO); - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - GL_LockArrays(0, 0); + R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset); + // second pass memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex[0] = R_GetTexture(basetexture); - m.pointer_texcoord[0] = model->surfmesh.data_texcoordtexture2f; - m.texmatrix[0] = texture->currenttexmatrix; - if (r_shadow_rtlight->currentcubemap != r_texture_whitecube) + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; + m.texmatrix[0] = rsurface.texture->currenttexmatrix; + if (rsurface.rtlight->currentcubemap != r_texture_whitecube) { - m.texcubemap[1] = R_GetTexture(r_shadow_rtlight->currentcubemap); - m.pointer_texcoord3f[1] = rsurface_vertex3f; - m.texmatrix[1] = r_shadow_entitytolight; + m.texcubemap[1] = R_GetTexture(rsurface.rtlight->currentcubemap); + m.pointer_texcoord3f[1] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset; + m.texmatrix[1] = rsurface.entitytolight; } GL_BlendFunc(GL_DST_ALPHA, GL_ONE); } @@ -1570,472 +1818,468 @@ static void R_Shadow_RenderSurfacesLighting_Light_Dot3_DiffusePass(const entity_ { // 2/2/2 2D combine path (any dot3 card) memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture); - m.pointer_texcoord3f[0] = rsurface_vertex3f; - m.texmatrix[0] = r_shadow_entitytoattenuationxyz; + m.pointer_texcoord3f[0] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset; + m.texmatrix[0] = rsurface.entitytoattenuationxyz; m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture); - m.pointer_texcoord3f[1] = rsurface_vertex3f; - m.texmatrix[1] = r_shadow_entitytoattenuationz; - R_Mesh_State(&m); + m.pointer_texcoord3f[1] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset; + m.texmatrix[1] = rsurface.entitytoattenuationz; + R_Mesh_TextureState(&m); GL_ColorMask(0,0,0,1); GL_BlendFunc(GL_ONE, GL_ZERO); - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - GL_LockArrays(0, 0); + R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset); + // second pass memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex[0] = R_GetTexture(normalmaptexture); m.texcombinergb[0] = GL_REPLACE; - m.pointer_texcoord[0] = model->surfmesh.data_texcoordtexture2f; - m.texmatrix[0] = texture->currenttexmatrix; + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; + m.texmatrix[0] = rsurface.texture->currenttexmatrix; m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube); m.texcombinergb[1] = GL_DOT3_RGBA_ARB; - m.pointer_texcoord3f[1] = rsurface_array_texcoord3f; - R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(rsurface_array_texcoord3f + 3 * surface->num_firstvertex, surface->num_vertices, rsurface_vertex3f + 3 * surface->num_firstvertex, rsurface_svector3f + 3 * surface->num_firstvertex, rsurface_tvector3f + 3 * surface->num_firstvertex, rsurface_normal3f + 3 * surface->num_firstvertex, r_shadow_entitylightorigin); - R_Mesh_State(&m); + m.pointer_texcoord3f[1] = rsurface.array_texcoord3f; + m.pointer_texcoord_bufferobject[1] = 0; + m.pointer_texcoord_bufferoffset[1] = 0; + R_Mesh_TextureState(&m); GL_BlendFunc(GL_DST_ALPHA, GL_ZERO); - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - GL_LockArrays(0, 0); + R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset); + // second pass memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex[0] = R_GetTexture(basetexture); - m.pointer_texcoord[0] = model->surfmesh.data_texcoordtexture2f; - m.texmatrix[0] = texture->currenttexmatrix; - if (r_shadow_rtlight->currentcubemap != r_texture_whitecube) + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; + m.texmatrix[0] = rsurface.texture->currenttexmatrix; + if (rsurface.rtlight->currentcubemap != r_texture_whitecube) { - m.texcubemap[1] = R_GetTexture(r_shadow_rtlight->currentcubemap); - m.pointer_texcoord3f[1] = rsurface_vertex3f; - m.texmatrix[1] = r_shadow_entitytolight; + m.texcubemap[1] = R_GetTexture(rsurface.rtlight->currentcubemap); + m.pointer_texcoord3f[1] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset; + m.texmatrix[1] = rsurface.entitytolight; } GL_BlendFunc(GL_DST_ALPHA, GL_ONE); } // this final code is shared - R_Mesh_State(&m); - GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 0); - VectorScale(lightcolorbase, colorscale, color2); - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--) - { - GL_Color(bound(0, color2[0], 1), bound(0, color2[1], 1), bound(0, color2[2], 1), 1); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - } - GL_LockArrays(0, 0); + R_Mesh_TextureState(&m); + R_Shadow_RenderLighting_Light_Dot3_Finalize(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase[0] * colorscale, lightcolorbase[1] * colorscale, lightcolorbase[2] * colorscale); } -static void R_Shadow_RenderSurfacesLighting_Light_Dot3_SpecularPass(const entity_render_t *ent, const texture_t *texture, const msurface_t *surface, const vec3_t lightcolorbase, rtexture_t *glosstexture, rtexture_t *normalmaptexture, float colorscale) +static void R_Shadow_RenderLighting_Light_Dot3_SpecularPass(int firstvertex, int numvertices, int numtriangles, const int *element3i, int element3i_bufferobject, size_t element3i_bufferoffset, const vec3_t lightcolorbase, rtexture_t *glosstexture, rtexture_t *normalmaptexture, float colorscale) { - int renders; - model_t *model = ent->model; - float color2[3]; + float glossexponent; rmeshstate_t m; - const int *elements = model->surfmesh.data_element3i + surface->num_firsttriangle * 3; // FIXME: detect blendsquare! //if (!gl_support_blendsquare) // return; GL_Color(1,1,1,1); - if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && r_shadow_rtlight->currentcubemap != r_texture_whitecube /* && gl_support_blendsquare*/) // FIXME: detect blendsquare! + // generate normalization cubemap texcoords + R_Shadow_GenTexCoords_Specular_NormalCubeMap(firstvertex, numvertices, numtriangles, element3i); + if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && rsurface.rtlight->currentcubemap != r_texture_whitecube) { // 2/0/0/1/2 3D combine blendsquare path memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex[0] = R_GetTexture(normalmaptexture); - m.pointer_texcoord[0] = model->surfmesh.data_texcoordtexture2f; - m.texmatrix[0] = texture->currenttexmatrix; + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; + m.texmatrix[0] = rsurface.texture->currenttexmatrix; m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube); m.texcombinergb[1] = GL_DOT3_RGBA_ARB; - m.pointer_texcoord3f[1] = rsurface_array_texcoord3f; - R_Shadow_GenTexCoords_Specular_NormalCubeMap(rsurface_array_texcoord3f + 3 * surface->num_firstvertex, surface->num_vertices, rsurface_vertex3f + 3 * surface->num_firstvertex, rsurface_svector3f + 3 * surface->num_firstvertex, rsurface_tvector3f + 3 * surface->num_firstvertex, rsurface_normal3f + 3 * surface->num_firstvertex, r_shadow_entitylightorigin, r_shadow_entityeyeorigin); - R_Mesh_State(&m); + m.pointer_texcoord3f[1] = rsurface.array_texcoord3f; + m.pointer_texcoord_bufferobject[1] = 0; + m.pointer_texcoord_bufferoffset[1] = 0; + R_Mesh_TextureState(&m); GL_ColorMask(0,0,0,1); // this squares the result GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO); - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - GL_LockArrays(0, 0); + R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset); - memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; - R_Mesh_State(&m); - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); + // second and third pass + R_Mesh_ResetTextureState(); // square alpha in framebuffer a few times to make it shiny GL_BlendFunc(GL_ZERO, GL_DST_ALPHA); - // these comments are a test run through this math for intensity 0.5 - // 0.5 * 0.5 = 0.25 (done by the BlendFunc earlier) - // 0.25 * 0.25 = 0.0625 (this is another pass) - // 0.0625 * 0.0625 = 0.00390625 (this is another pass) - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - GL_LockArrays(0, 0); + for (glossexponent = 2;glossexponent * 2 <= r_shadow_glossexponent.value;glossexponent *= 2) + R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset); + // fourth pass memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture); - m.pointer_texcoord3f[0] = rsurface_vertex3f; - m.texmatrix[0] = r_shadow_entitytoattenuationxyz; - R_Mesh_State(&m); + m.pointer_texcoord3f[0] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset; + m.texmatrix[0] = rsurface.entitytoattenuationxyz; + R_Mesh_TextureState(&m); GL_BlendFunc(GL_DST_ALPHA, GL_ZERO); - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - GL_LockArrays(0, 0); + R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset); + // fifth pass memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex[0] = R_GetTexture(glosstexture); - m.pointer_texcoord[0] = model->surfmesh.data_texcoordtexture2f; - m.texmatrix[0] = texture->currenttexmatrix; - if (r_shadow_rtlight->currentcubemap != r_texture_whitecube) + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; + m.texmatrix[0] = rsurface.texture->currenttexmatrix; + if (rsurface.rtlight->currentcubemap != r_texture_whitecube) { - m.texcubemap[1] = R_GetTexture(r_shadow_rtlight->currentcubemap); - m.pointer_texcoord3f[1] = rsurface_vertex3f; - m.texmatrix[1] = r_shadow_entitytolight; + m.texcubemap[1] = R_GetTexture(rsurface.rtlight->currentcubemap); + m.pointer_texcoord3f[1] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset; + m.texmatrix[1] = rsurface.entitytolight; } GL_BlendFunc(GL_DST_ALPHA, GL_ONE); } - else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && r_shadow_rtlight->currentcubemap == r_texture_whitecube /* && gl_support_blendsquare*/) // FIXME: detect blendsquare! + else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && rsurface.rtlight->currentcubemap == r_texture_whitecube /* && gl_support_blendsquare*/) // FIXME: detect blendsquare! { // 2/0/0/2 3D combine blendsquare path memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex[0] = R_GetTexture(normalmaptexture); - m.pointer_texcoord[0] = model->surfmesh.data_texcoordtexture2f; - m.texmatrix[0] = texture->currenttexmatrix; + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; + m.texmatrix[0] = rsurface.texture->currenttexmatrix; m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube); m.texcombinergb[1] = GL_DOT3_RGBA_ARB; - m.pointer_texcoord3f[1] = rsurface_array_texcoord3f; - R_Shadow_GenTexCoords_Specular_NormalCubeMap(rsurface_array_texcoord3f + 3 * surface->num_firstvertex, surface->num_vertices, rsurface_vertex3f + 3 * surface->num_firstvertex, rsurface_svector3f + 3 * surface->num_firstvertex, rsurface_tvector3f + 3 * surface->num_firstvertex, rsurface_normal3f + 3 * surface->num_firstvertex, r_shadow_entitylightorigin, r_shadow_entityeyeorigin); - R_Mesh_State(&m); + m.pointer_texcoord3f[1] = rsurface.array_texcoord3f; + m.pointer_texcoord_bufferobject[1] = 0; + m.pointer_texcoord_bufferoffset[1] = 0; + R_Mesh_TextureState(&m); GL_ColorMask(0,0,0,1); // this squares the result GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO); - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - GL_LockArrays(0, 0); + R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset); - memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; - R_Mesh_State(&m); - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); + // second and third pass + R_Mesh_ResetTextureState(); // square alpha in framebuffer a few times to make it shiny GL_BlendFunc(GL_ZERO, GL_DST_ALPHA); - // these comments are a test run through this math for intensity 0.5 - // 0.5 * 0.5 = 0.25 (done by the BlendFunc earlier) - // 0.25 * 0.25 = 0.0625 (this is another pass) - // 0.0625 * 0.0625 = 0.00390625 (this is another pass) - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - GL_LockArrays(0, 0); + for (glossexponent = 2;glossexponent * 2 <= r_shadow_glossexponent.value;glossexponent *= 2) + R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset); + // fourth pass memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex[0] = R_GetTexture(glosstexture); - m.pointer_texcoord[0] = model->surfmesh.data_texcoordtexture2f; - m.texmatrix[0] = texture->currenttexmatrix; + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; + m.texmatrix[0] = rsurface.texture->currenttexmatrix; m.tex3d[1] = R_GetTexture(r_shadow_attenuation3dtexture); - m.pointer_texcoord3f[1] = rsurface_vertex3f; - m.texmatrix[1] = r_shadow_entitytoattenuationxyz; + m.pointer_texcoord3f[1] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset; + m.texmatrix[1] = rsurface.entitytoattenuationxyz; GL_BlendFunc(GL_DST_ALPHA, GL_ONE); } else { // 2/0/0/2/2 2D combine blendsquare path memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex[0] = R_GetTexture(normalmaptexture); - m.pointer_texcoord[0] = model->surfmesh.data_texcoordtexture2f; - m.texmatrix[0] = texture->currenttexmatrix; + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; + m.texmatrix[0] = rsurface.texture->currenttexmatrix; m.texcubemap[1] = R_GetTexture(r_texture_normalizationcube); m.texcombinergb[1] = GL_DOT3_RGBA_ARB; - m.pointer_texcoord3f[1] = rsurface_array_texcoord3f; - R_Shadow_GenTexCoords_Specular_NormalCubeMap(rsurface_array_texcoord3f + 3 * surface->num_firstvertex, surface->num_vertices, rsurface_vertex3f + 3 * surface->num_firstvertex, rsurface_svector3f + 3 * surface->num_firstvertex, rsurface_tvector3f + 3 * surface->num_firstvertex, rsurface_normal3f + 3 * surface->num_firstvertex, r_shadow_entitylightorigin, r_shadow_entityeyeorigin); - R_Mesh_State(&m); + m.pointer_texcoord3f[1] = rsurface.array_texcoord3f; + m.pointer_texcoord_bufferobject[1] = 0; + m.pointer_texcoord_bufferoffset[1] = 0; + R_Mesh_TextureState(&m); GL_ColorMask(0,0,0,1); // this squares the result GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO); - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - GL_LockArrays(0, 0); + R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset); - memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; - R_Mesh_State(&m); - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); + // second and third pass + R_Mesh_ResetTextureState(); // square alpha in framebuffer a few times to make it shiny GL_BlendFunc(GL_ZERO, GL_DST_ALPHA); - // these comments are a test run through this math for intensity 0.5 - // 0.5 * 0.5 = 0.25 (done by the BlendFunc earlier) - // 0.25 * 0.25 = 0.0625 (this is another pass) - // 0.0625 * 0.0625 = 0.00390625 (this is another pass) - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - GL_LockArrays(0, 0); + for (glossexponent = 2;glossexponent * 2 <= r_shadow_glossexponent.value;glossexponent *= 2) + R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset); + // fourth pass memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture); - m.pointer_texcoord3f[0] = rsurface_vertex3f; - m.texmatrix[0] = r_shadow_entitytoattenuationxyz; + m.pointer_texcoord3f[0] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[0] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.vertex3f_bufferoffset; + m.texmatrix[0] = rsurface.entitytoattenuationxyz; m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture); - m.pointer_texcoord3f[1] = rsurface_vertex3f; - m.texmatrix[1] = r_shadow_entitytoattenuationz; - R_Mesh_State(&m); + m.pointer_texcoord3f[1] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset; + m.texmatrix[1] = rsurface.entitytoattenuationz; + R_Mesh_TextureState(&m); GL_BlendFunc(GL_DST_ALPHA, GL_ZERO); - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - GL_LockArrays(0, 0); + R_Mesh_Draw(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset); + // fifth pass memset(&m, 0, sizeof(m)); - m.pointer_vertex = rsurface_vertex3f; m.tex[0] = R_GetTexture(glosstexture); - m.pointer_texcoord[0] = model->surfmesh.data_texcoordtexture2f; - m.texmatrix[0] = texture->currenttexmatrix; - if (r_shadow_rtlight->currentcubemap != r_texture_whitecube) + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; + m.texmatrix[0] = rsurface.texture->currenttexmatrix; + if (rsurface.rtlight->currentcubemap != r_texture_whitecube) { - m.texcubemap[1] = R_GetTexture(r_shadow_rtlight->currentcubemap); - m.pointer_texcoord3f[1] = rsurface_vertex3f; - m.texmatrix[1] = r_shadow_entitytolight; + m.texcubemap[1] = R_GetTexture(rsurface.rtlight->currentcubemap); + m.pointer_texcoord3f[1] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset; + m.texmatrix[1] = rsurface.entitytolight; } GL_BlendFunc(GL_DST_ALPHA, GL_ONE); } - R_Mesh_State(&m); - GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 0); - VectorScale(lightcolorbase, colorscale, color2); - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--) - { - GL_Color(bound(0, color2[0], 1), bound(0, color2[1], 1), bound(0, color2[2], 1), 1); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - } - GL_LockArrays(0, 0); + // this final code is shared + R_Mesh_TextureState(&m); + R_Shadow_RenderLighting_Light_Dot3_Finalize(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase[0] * colorscale, lightcolorbase[1] * colorscale, lightcolorbase[2] * colorscale); } -static void R_Shadow_RenderSurfacesLighting_Light_Dot3(const entity_render_t *ent, const texture_t *texture, int numsurfaces, msurface_t **surfacelist, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float specularscale, qboolean dopants, qboolean doshirt) +static void R_Shadow_RenderLighting_Light_Dot3(int firstvertex, int numvertices, int numtriangles, const int *element3i, int element3i_bufferobject, size_t element3i_bufferoffset, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float ambientscale, float diffusescale, float specularscale, qboolean dopants, qboolean doshirt) { // ARB path (any Geforce, any Radeon) - int surfacelistindex; - qboolean doambient = r_shadow_rtlight->ambientscale > 0; - qboolean dodiffuse = r_shadow_rtlight->diffusescale > 0; + qboolean doambient = ambientscale > 0; + qboolean dodiffuse = diffusescale > 0; qboolean dospecular = specularscale > 0; if (!doambient && !dodiffuse && !dospecular) return; - RSurf_SetPointersForPass(false, true); - for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++) + R_Mesh_ColorPointer(NULL, 0, 0); + if (doambient) + R_Shadow_RenderLighting_Light_Dot3_AmbientPass(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase, basetexture, ambientscale * r_view.colorscale); + if (dodiffuse) + R_Shadow_RenderLighting_Light_Dot3_DiffusePass(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase, basetexture, normalmaptexture, diffusescale * r_view.colorscale); + if (dopants) { - const msurface_t *surface = surfacelist[surfacelistindex]; - if (rsurface_dynamicvertex) - RSurf_PrepareDynamicSurfaceVertices(surface); if (doambient) - R_Shadow_RenderSurfacesLighting_Light_Dot3_AmbientPass(ent, texture, surface, lightcolorbase, basetexture, r_shadow_rtlight->ambientscale); + R_Shadow_RenderLighting_Light_Dot3_AmbientPass(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorpants, pantstexture, ambientscale * r_view.colorscale); if (dodiffuse) - R_Shadow_RenderSurfacesLighting_Light_Dot3_DiffusePass(ent, texture, surface, lightcolorbase, basetexture, normalmaptexture, r_shadow_rtlight->diffusescale); - if (dopants) - { - if (doambient) - R_Shadow_RenderSurfacesLighting_Light_Dot3_AmbientPass(ent, texture, surface, lightcolorpants, pantstexture, r_shadow_rtlight->ambientscale); - if (dodiffuse) - R_Shadow_RenderSurfacesLighting_Light_Dot3_DiffusePass(ent, texture, surface, lightcolorpants, pantstexture, normalmaptexture, r_shadow_rtlight->diffusescale); - } - if (doshirt) - { - if (doambient) - R_Shadow_RenderSurfacesLighting_Light_Dot3_AmbientPass(ent, texture, surface, lightcolorshirt, shirttexture, r_shadow_rtlight->ambientscale); - if (dodiffuse) - R_Shadow_RenderSurfacesLighting_Light_Dot3_DiffusePass(ent, texture, surface, lightcolorshirt, shirttexture, normalmaptexture, r_shadow_rtlight->diffusescale); - } - if (dospecular) - R_Shadow_RenderSurfacesLighting_Light_Dot3_SpecularPass(ent, texture, surface, lightcolorbase, glosstexture, normalmaptexture, specularscale); + R_Shadow_RenderLighting_Light_Dot3_DiffusePass(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorpants, pantstexture, normalmaptexture, diffusescale * r_view.colorscale); + } + if (doshirt) + { + if (doambient) + R_Shadow_RenderLighting_Light_Dot3_AmbientPass(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorshirt, shirttexture, ambientscale * r_view.colorscale); + if (dodiffuse) + R_Shadow_RenderLighting_Light_Dot3_DiffusePass(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorshirt, shirttexture, normalmaptexture, diffusescale * r_view.colorscale); } + if (dospecular) + R_Shadow_RenderLighting_Light_Dot3_SpecularPass(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase, glosstexture, normalmaptexture, specularscale * r_view.colorscale); } -void R_Shadow_RenderSurfacesLighting_Light_Vertex_Pass(const model_t *model, const msurface_t *surface, vec3_t diffusecolor2, vec3_t ambientcolor2) +void R_Shadow_RenderLighting_Light_Vertex_Pass(int firstvertex, int numvertices, int numtriangles, const int *element3i, int element3i_bufferobject, size_t element3i_bufferoffset, vec3_t diffusecolor2, vec3_t ambientcolor2) { int renders; - const int *elements = model->surfmesh.data_element3i + surface->num_firsttriangle * 3; - R_Shadow_RenderSurfacesLighting_Light_Vertex_Shading(surface, diffusecolor2, ambientcolor2); - for (renders = 0;renders < 64 && (ambientcolor2[0] > renders || ambientcolor2[1] > renders || ambientcolor2[2] > renders || diffusecolor2[0] > renders || diffusecolor2[1] > renders || diffusecolor2[2] > renders);renders++) - { - int i; - float *c; -#if 1 + int i; + int stop; + int newfirstvertex; + int newlastvertex; + int newnumtriangles; + int *newe; + const int *e; + float *c; + int newelements[4096*3]; + R_Shadow_RenderLighting_Light_Vertex_Shading(firstvertex, numvertices, numtriangles, element3i, diffusecolor2, ambientcolor2); + for (renders = 0;renders < 64;renders++) + { + stop = true; + newfirstvertex = 0; + newlastvertex = 0; + newnumtriangles = 0; + newe = newelements; // due to low fillrate on the cards this vertex lighting path is // designed for, we manually cull all triangles that do not // contain a lit vertex - int draw; - const int *e; - int newnumtriangles; - int *newe; - int newelements[3072]; - draw = false; - newnumtriangles = 0; - newe = newelements; - for (i = 0, e = elements;i < surface->num_triangles;i++, e += 3) + // this builds batches of triangles from multiple surfaces and + // renders them at once + for (i = 0, e = element3i;i < numtriangles;i++, e += 3) { - if (newnumtriangles >= 1024) - { - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, newnumtriangles, newelements); - GL_LockArrays(0, 0); - newnumtriangles = 0; - newe = newelements; - } - if (VectorLength2(rsurface_array_color4f + e[0] * 4) + VectorLength2(rsurface_array_color4f + e[1] * 4) + VectorLength2(rsurface_array_color4f + e[2] * 4) >= 0.01) + if (VectorLength2(rsurface.array_color4f + e[0] * 4) + VectorLength2(rsurface.array_color4f + e[1] * 4) + VectorLength2(rsurface.array_color4f + e[2] * 4) >= 0.01) { + if (newnumtriangles) + { + newfirstvertex = min(newfirstvertex, e[0]); + newlastvertex = max(newlastvertex, e[0]); + } + else + { + newfirstvertex = e[0]; + newlastvertex = e[0]; + } + newfirstvertex = min(newfirstvertex, e[1]); + newlastvertex = max(newlastvertex, e[1]); + newfirstvertex = min(newfirstvertex, e[2]); + newlastvertex = max(newlastvertex, e[2]); newe[0] = e[0]; newe[1] = e[1]; newe[2] = e[2]; newnumtriangles++; newe += 3; - draw = true; + if (newnumtriangles >= (int)(sizeof(newelements)/sizeof(float[3]))) + { + R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, newnumtriangles, newelements, 0, 0); + newnumtriangles = 0; + newe = newelements; + stop = false; + } } } if (newnumtriangles >= 1) { - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, newnumtriangles, newelements); - GL_LockArrays(0, 0); - draw = true; + // if all triangles are included, use the original array to take advantage of the bufferobject if possible + if (newnumtriangles == numtriangles) + R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset); + else + R_Mesh_Draw(newfirstvertex, newlastvertex - newfirstvertex + 1, newnumtriangles, newelements, 0, 0); + stop = false; } - if (!draw) + // if we couldn't find any lit triangles, exit early + if (stop) break; -#else - for (i = 0, c = rsurface_array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4) - if (VectorLength2(c)) - goto goodpass; - break; -goodpass: - GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements); - GL_LockArrays(0, 0); -#endif // now reduce the intensity for the next overbright pass - for (i = 0, c = rsurface_array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4) + // we have to clamp to 0 here incase the drivers have improper + // handling of negative colors + // (some old drivers even have improper handling of >1 color) + stop = true; + for (i = 0, c = rsurface.array_color4f + 4 * firstvertex;i < numvertices;i++, c += 4) { - c[0] = max(0, c[0] - 1); - c[1] = max(0, c[1] - 1); - c[2] = max(0, c[2] - 1); + if (c[0] > 1 || c[1] > 1 || c[2] > 1) + { + c[0] = max(0, c[0] - 1); + c[1] = max(0, c[1] - 1); + c[2] = max(0, c[2] - 1); + stop = false; + } + else + VectorClear(c); } + // another check... + if (stop) + break; } } -static void R_Shadow_RenderSurfacesLighting_Light_Vertex(const entity_render_t *ent, const texture_t *texture, int numsurfaces, msurface_t **surfacelist, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float specularscale, qboolean dopants, qboolean doshirt) +static void R_Shadow_RenderLighting_Light_Vertex(int firstvertex, int numvertices, int numtriangles, const int *element3i, int element3i_bufferobject, size_t element3i_bufferoffset, const vec3_t lightcolorbase, const vec3_t lightcolorpants, const vec3_t lightcolorshirt, rtexture_t *basetexture, rtexture_t *pantstexture, rtexture_t *shirttexture, rtexture_t *normalmaptexture, rtexture_t *glosstexture, float ambientscale, float diffusescale, float specularscale, qboolean dopants, qboolean doshirt) { - int surfacelistindex; - model_t *model = ent->model; + // OpenGL 1.1 path (anything) float ambientcolorbase[3], diffusecolorbase[3]; float ambientcolorpants[3], diffusecolorpants[3]; float ambientcolorshirt[3], diffusecolorshirt[3]; rmeshstate_t m; - VectorScale(lightcolorbase, r_shadow_rtlight->ambientscale * 2, ambientcolorbase); - VectorScale(lightcolorbase, r_shadow_rtlight->diffusescale * 2, diffusecolorbase); - VectorScale(lightcolorpants, r_shadow_rtlight->ambientscale * 2, ambientcolorpants); - VectorScale(lightcolorpants, r_shadow_rtlight->diffusescale * 2, diffusecolorpants); - VectorScale(lightcolorshirt, r_shadow_rtlight->ambientscale * 2, ambientcolorshirt); - VectorScale(lightcolorshirt, r_shadow_rtlight->diffusescale * 2, diffusecolorshirt); + VectorScale(lightcolorbase, ambientscale * 2 * r_view.colorscale, ambientcolorbase); + VectorScale(lightcolorbase, diffusescale * 2 * r_view.colorscale, diffusecolorbase); + VectorScale(lightcolorpants, ambientscale * 2 * r_view.colorscale, ambientcolorpants); + VectorScale(lightcolorpants, diffusescale * 2 * r_view.colorscale, diffusecolorpants); + VectorScale(lightcolorshirt, ambientscale * 2 * r_view.colorscale, ambientcolorshirt); + VectorScale(lightcolorshirt, diffusescale * 2 * r_view.colorscale, diffusecolorshirt); GL_BlendFunc(GL_SRC_ALPHA, GL_ONE); + R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0); memset(&m, 0, sizeof(m)); m.tex[0] = R_GetTexture(basetexture); + m.texmatrix[0] = rsurface.texture->currenttexmatrix; + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; if (r_textureunits.integer >= 2) { - // voodoo2 + // voodoo2 or TNT m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture); - m.texmatrix[1] = r_shadow_entitytoattenuationxyz; + m.texmatrix[1] = rsurface.entitytoattenuationxyz; + m.pointer_texcoord3f[1] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[1] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[1] = rsurface.vertex3f_bufferoffset; if (r_textureunits.integer >= 3) { - // Geforce3/Radeon class but not using dot3 + // Voodoo4 or Kyro (or Geforce3/Radeon with gl_combine off) m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture); - m.texmatrix[2] = r_shadow_entitytoattenuationz; + m.texmatrix[2] = rsurface.entitytoattenuationz; + m.pointer_texcoord3f[2] = rsurface.vertex3f; + m.pointer_texcoord_bufferobject[2] = rsurface.vertex3f_bufferobject; + m.pointer_texcoord_bufferoffset[2] = rsurface.vertex3f_bufferoffset; } } - m.pointer_color = rsurface_array_color4f; - R_Mesh_State(&m); - RSurf_SetPointersForPass(true, false); - for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++) + R_Mesh_TextureState(&m); + //R_Mesh_TexBind(0, R_GetTexture(basetexture)); + R_Shadow_RenderLighting_Light_Vertex_Pass(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, diffusecolorbase, ambientcolorbase); + if (dopants) { - const msurface_t *surface = surfacelist[surfacelistindex]; - if (rsurface_dynamicvertex) - RSurf_PrepareDynamicSurfaceVertices(surface); - // OpenGL 1.1 path (anything) - R_Mesh_TexCoordPointer(0, 2, model->surfmesh.data_texcoordtexture2f); - R_Mesh_TexMatrix(0, &texture->currenttexmatrix); - if (r_textureunits.integer >= 2) - { - // voodoo2 or TNT - R_Mesh_TexCoordPointer(1, 3, rsurface_vertex3f); - if (r_textureunits.integer >= 3) - { - // Voodoo4 or Kyro (or Geforce3/Radeon with gl_combine off) - R_Mesh_TexCoordPointer(2, 3, rsurface_vertex3f); - } - } - R_Mesh_TexBind(0, R_GetTexture(basetexture)); - R_Shadow_RenderSurfacesLighting_Light_Vertex_Pass(model, surface, diffusecolorbase, ambientcolorbase); - if (dopants) - { - R_Mesh_TexBind(0, R_GetTexture(pantstexture)); - R_Shadow_RenderSurfacesLighting_Light_Vertex_Pass(model, surface, diffusecolorpants, ambientcolorpants); - } - if (doshirt) - { - R_Mesh_TexBind(0, R_GetTexture(shirttexture)); - R_Shadow_RenderSurfacesLighting_Light_Vertex_Pass(model, surface, diffusecolorshirt, ambientcolorshirt); - } + R_Mesh_TexBind(0, R_GetTexture(pantstexture)); + R_Shadow_RenderLighting_Light_Vertex_Pass(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, diffusecolorpants, ambientcolorpants); + } + if (doshirt) + { + R_Mesh_TexBind(0, R_GetTexture(shirttexture)); + R_Shadow_RenderLighting_Light_Vertex_Pass(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, diffusecolorshirt, ambientcolorshirt); } } -void R_Shadow_RenderSurfacesLighting(const entity_render_t *ent, const texture_t *texture, int numsurfaces, msurface_t **surfacelist) +void R_Shadow_RenderLighting(int firstvertex, int numvertices, int numtriangles, const int *element3i, int element3i_bufferobject, size_t element3i_bufferoffset) { - // FIXME: support MATERIALFLAG_NODEPTHTEST + float ambientscale, diffusescale, specularscale; vec3_t lightcolorbase, lightcolorpants, lightcolorshirt; // calculate colors to render this texture with - lightcolorbase[0] = r_shadow_rtlight->currentcolor[0] * ent->colormod[0] * texture->currentalpha; - lightcolorbase[1] = r_shadow_rtlight->currentcolor[1] * ent->colormod[1] * texture->currentalpha; - lightcolorbase[2] = r_shadow_rtlight->currentcolor[2] * ent->colormod[2] * texture->currentalpha; - if ((r_shadow_rtlight->ambientscale + r_shadow_rtlight->diffusescale) * VectorLength2(lightcolorbase) + (r_shadow_rtlight->specularscale * texture->specularscale) * VectorLength2(lightcolorbase) < (1.0f / 1048576.0f)) + lightcolorbase[0] = rsurface.rtlight->currentcolor[0] * rsurface.texture->dlightcolor[0]; + lightcolorbase[1] = rsurface.rtlight->currentcolor[1] * rsurface.texture->dlightcolor[1]; + lightcolorbase[2] = rsurface.rtlight->currentcolor[2] * rsurface.texture->dlightcolor[2]; + ambientscale = rsurface.rtlight->ambientscale; + diffusescale = rsurface.rtlight->diffusescale; + specularscale = rsurface.rtlight->specularscale * rsurface.texture->specularscale; + if (!r_shadow_usenormalmap.integer) + { + ambientscale += 1.0f * diffusescale; + diffusescale = 0; + specularscale = 0; + } + if ((ambientscale + diffusescale) * VectorLength2(lightcolorbase) + specularscale * VectorLength2(lightcolorbase) < (1.0f / 1048576.0f)) return; - if ((texture->textureflags & Q3TEXTUREFLAG_TWOSIDED) || (ent->flags & RENDER_NOCULLFACE)) - qglDisable(GL_CULL_FACE); - else - qglEnable(GL_CULL_FACE); - RSurf_PrepareForBatch(ent, texture, r_shadow_entityeyeorigin); - if (texture->colormapping) - { - qboolean dopants = texture->skin.pants != NULL && VectorLength2(ent->colormap_pantscolor) >= (1.0f / 1048576.0f); - qboolean doshirt = texture->skin.shirt != NULL && VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f); + GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1); + GL_PolygonOffset(rsurface.texture->currentpolygonfactor, rsurface.texture->currentpolygonoffset); + GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST)); + GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces + if (rsurface.texture->colormapping) + { + qboolean dopants = rsurface.texture->currentskinframe->pants != NULL && VectorLength2(rsurface.colormap_pantscolor) >= (1.0f / 1048576.0f); + qboolean doshirt = rsurface.texture->currentskinframe->shirt != NULL && VectorLength2(rsurface.colormap_shirtcolor) >= (1.0f / 1048576.0f); if (dopants) { - lightcolorpants[0] = lightcolorbase[0] * ent->colormap_pantscolor[0]; - lightcolorpants[1] = lightcolorbase[1] * ent->colormap_pantscolor[1]; - lightcolorpants[2] = lightcolorbase[2] * ent->colormap_pantscolor[2]; + lightcolorpants[0] = lightcolorbase[0] * rsurface.colormap_pantscolor[0]; + lightcolorpants[1] = lightcolorbase[1] * rsurface.colormap_pantscolor[1]; + lightcolorpants[2] = lightcolorbase[2] * rsurface.colormap_pantscolor[2]; } else VectorClear(lightcolorpants); if (doshirt) { - lightcolorshirt[0] = lightcolorbase[0] * ent->colormap_shirtcolor[0]; - lightcolorshirt[1] = lightcolorbase[1] * ent->colormap_shirtcolor[1]; - lightcolorshirt[2] = lightcolorbase[2] * ent->colormap_shirtcolor[2]; + lightcolorshirt[0] = lightcolorbase[0] * rsurface.colormap_shirtcolor[0]; + lightcolorshirt[1] = lightcolorbase[1] * rsurface.colormap_shirtcolor[1]; + lightcolorshirt[2] = lightcolorbase[2] * rsurface.colormap_shirtcolor[2]; } else VectorClear(lightcolorshirt); switch (r_shadow_rendermode) { case R_SHADOW_RENDERMODE_VISIBLELIGHTING: - R_Shadow_RenderSurfacesLighting_VisibleLighting(ent, texture, numsurfaces, surfacelist, lightcolorbase, lightcolorpants, lightcolorshirt, texture->basetexture, texture->skin.pants, texture->skin.shirt, texture->skin.nmap, texture->glosstexture, r_shadow_rtlight->specularscale * texture->specularscale, dopants, doshirt); + GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST) && !r_showdisabledepthtest.integer); + R_Shadow_RenderLighting_VisibleLighting(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase, lightcolorpants, lightcolorshirt, rsurface.texture->basetexture, rsurface.texture->currentskinframe->pants, rsurface.texture->currentskinframe->shirt, rsurface.texture->currentskinframe->nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, dopants, doshirt); break; case R_SHADOW_RENDERMODE_LIGHT_GLSL: - R_Shadow_RenderSurfacesLighting_Light_GLSL(ent, texture, numsurfaces, surfacelist, lightcolorbase, lightcolorpants, lightcolorshirt, texture->basetexture, texture->skin.pants, texture->skin.shirt, texture->skin.nmap, texture->glosstexture, r_shadow_rtlight->specularscale * texture->specularscale, dopants, doshirt); + R_Shadow_RenderLighting_Light_GLSL(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase, lightcolorpants, lightcolorshirt, rsurface.texture->basetexture, rsurface.texture->currentskinframe->pants, rsurface.texture->currentskinframe->shirt, rsurface.texture->currentskinframe->nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, dopants, doshirt); break; case R_SHADOW_RENDERMODE_LIGHT_DOT3: - R_Shadow_RenderSurfacesLighting_Light_Dot3(ent, texture, numsurfaces, surfacelist, lightcolorbase, lightcolorpants, lightcolorshirt, texture->basetexture, texture->skin.pants, texture->skin.shirt, texture->skin.nmap, texture->glosstexture, r_shadow_rtlight->specularscale * texture->specularscale, dopants, doshirt); + R_Shadow_RenderLighting_Light_Dot3(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase, lightcolorpants, lightcolorshirt, rsurface.texture->basetexture, rsurface.texture->currentskinframe->pants, rsurface.texture->currentskinframe->shirt, rsurface.texture->currentskinframe->nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, dopants, doshirt); break; case R_SHADOW_RENDERMODE_LIGHT_VERTEX: - R_Shadow_RenderSurfacesLighting_Light_Vertex(ent, texture, numsurfaces, surfacelist, lightcolorbase, lightcolorpants, lightcolorshirt, texture->basetexture, texture->skin.pants, texture->skin.shirt, texture->skin.nmap, texture->glosstexture, r_shadow_rtlight->specularscale * texture->specularscale, dopants, doshirt); + R_Shadow_RenderLighting_Light_Vertex(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase, lightcolorpants, lightcolorshirt, rsurface.texture->basetexture, rsurface.texture->currentskinframe->pants, rsurface.texture->currentskinframe->shirt, rsurface.texture->currentskinframe->nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, dopants, doshirt); break; default: - Con_Printf("R_Shadow_RenderSurfacesLighting: unknown r_shadow_rendermode %i\n", r_shadow_rendermode); + Con_Printf("R_Shadow_RenderLighting: unknown r_shadow_rendermode %i\n", r_shadow_rendermode); break; } } @@ -2044,35 +2288,56 @@ void R_Shadow_RenderSurfacesLighting(const entity_render_t *ent, const texture_t switch (r_shadow_rendermode) { case R_SHADOW_RENDERMODE_VISIBLELIGHTING: - R_Shadow_RenderSurfacesLighting_VisibleLighting(ent, texture, numsurfaces, surfacelist, lightcolorbase, vec3_origin, vec3_origin, texture->basetexture, r_texture_black, r_texture_black, texture->skin.nmap, texture->glosstexture, r_shadow_rtlight->specularscale * texture->specularscale, false, false); + GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST) && !r_showdisabledepthtest.integer); + R_Shadow_RenderLighting_VisibleLighting(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase, vec3_origin, vec3_origin, rsurface.texture->basetexture, r_texture_black, r_texture_black, rsurface.texture->currentskinframe->nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, false, false); break; case R_SHADOW_RENDERMODE_LIGHT_GLSL: - R_Shadow_RenderSurfacesLighting_Light_GLSL(ent, texture, numsurfaces, surfacelist, lightcolorbase, vec3_origin, vec3_origin, texture->basetexture, r_texture_black, r_texture_black, texture->skin.nmap, texture->glosstexture, r_shadow_rtlight->specularscale * texture->specularscale, false, false); + R_Shadow_RenderLighting_Light_GLSL(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase, vec3_origin, vec3_origin, rsurface.texture->basetexture, r_texture_black, r_texture_black, rsurface.texture->currentskinframe->nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, false, false); break; case R_SHADOW_RENDERMODE_LIGHT_DOT3: - R_Shadow_RenderSurfacesLighting_Light_Dot3(ent, texture, numsurfaces, surfacelist, lightcolorbase, vec3_origin, vec3_origin, texture->basetexture, r_texture_black, r_texture_black, texture->skin.nmap, texture->glosstexture, r_shadow_rtlight->specularscale * texture->specularscale, false, false); + R_Shadow_RenderLighting_Light_Dot3(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase, vec3_origin, vec3_origin, rsurface.texture->basetexture, r_texture_black, r_texture_black, rsurface.texture->currentskinframe->nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, false, false); break; case R_SHADOW_RENDERMODE_LIGHT_VERTEX: - R_Shadow_RenderSurfacesLighting_Light_Vertex(ent, texture, numsurfaces, surfacelist, lightcolorbase, vec3_origin, vec3_origin, texture->basetexture, r_texture_black, r_texture_black, texture->skin.nmap, texture->glosstexture, r_shadow_rtlight->specularscale * texture->specularscale, false, false); + R_Shadow_RenderLighting_Light_Vertex(firstvertex, numvertices, numtriangles, element3i, element3i_bufferobject, element3i_bufferoffset, lightcolorbase, vec3_origin, vec3_origin, rsurface.texture->basetexture, r_texture_black, r_texture_black, rsurface.texture->currentskinframe->nmap, rsurface.texture->glosstexture, ambientscale, diffusescale, specularscale, false, false); break; default: - Con_Printf("R_Shadow_RenderSurfacesLighting: unknown r_shadow_rendermode %i\n", r_shadow_rendermode); + Con_Printf("R_Shadow_RenderLighting: unknown r_shadow_rendermode %i\n", r_shadow_rendermode); break; } } } -void R_RTLight_Update(dlight_t *light, int isstatic) +void R_RTLight_Update(rtlight_t *rtlight, int isstatic, matrix4x4_t *matrix, vec3_t color, int style, const char *cubemapname, qboolean shadow, vec_t corona, vec_t coronasizescale, vec_t ambientscale, vec_t diffusescale, vec_t specularscale, int flags) { - int j, k; - float scale; - rtlight_t *rtlight = &light->rtlight; + matrix4x4_t tempmatrix = *matrix; + Matrix4x4_Scale(&tempmatrix, r_shadow_lightradiusscale.value, 1); + + // if this light has been compiled before, free the associated data R_RTLight_Uncompile(rtlight); + + // clear it completely to avoid any lingering data memset(rtlight, 0, sizeof(*rtlight)); - VectorCopy(light->origin, rtlight->shadoworigin); - VectorCopy(light->color, rtlight->color); - rtlight->radius = light->radius; + // copy the properties + rtlight->matrix_lighttoworld = tempmatrix; + Matrix4x4_Invert_Simple(&rtlight->matrix_worldtolight, &tempmatrix); + Matrix4x4_OriginFromMatrix(&tempmatrix, rtlight->shadoworigin); + rtlight->radius = Matrix4x4_ScaleFromMatrix(&tempmatrix); + VectorCopy(color, rtlight->color); + rtlight->cubemapname[0] = 0; + if (cubemapname && cubemapname[0]) + strlcpy(rtlight->cubemapname, cubemapname, sizeof(rtlight->cubemapname)); + rtlight->shadow = shadow; + rtlight->corona = corona; + rtlight->style = style; + rtlight->isstatic = isstatic; + rtlight->coronasizescale = coronasizescale; + rtlight->ambientscale = ambientscale; + rtlight->diffusescale = diffusescale; + rtlight->specularscale = specularscale; + rtlight->flags = flags; + + // compute derived data //rtlight->cullradius = rtlight->radius; //rtlight->cullradius2 = rtlight->radius * rtlight->radius; rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius; @@ -2081,34 +2346,15 @@ void R_RTLight_Update(dlight_t *light, int isstatic) rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius; rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius; rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius; - rtlight->cubemapname[0] = 0; - if (light->cubemapname[0]) - strcpy(rtlight->cubemapname, light->cubemapname); - else if (light->cubemapnum > 0) - sprintf(rtlight->cubemapname, "cubemaps/%i", light->cubemapnum); - rtlight->shadow = light->shadow; - rtlight->corona = light->corona; - rtlight->style = light->style; - rtlight->isstatic = isstatic; - rtlight->coronasizescale = light->coronasizescale; - rtlight->ambientscale = light->ambientscale; - rtlight->diffusescale = light->diffusescale; - rtlight->specularscale = light->specularscale; - rtlight->flags = light->flags; - Matrix4x4_Invert_Simple(&rtlight->matrix_worldtolight, &light->matrix); - // ConcatScale won't work here because this needs to scale rotate and - // translate, not just rotate - scale = 1.0f / rtlight->radius; - for (k = 0;k < 3;k++) - for (j = 0;j < 4;j++) - rtlight->matrix_worldtolight.m[k][j] *= scale; } // compiles rtlight geometry // (undone by R_FreeCompiledRTLight, which R_UpdateLight calls) void R_RTLight_Compile(rtlight_t *rtlight) { - int shadowmeshes, shadowtris, numleafs, numleafpvsbytes, numsurfaces; + int i; + int numsurfaces, numleafs, numleafpvsbytes, numshadowtrispvsbytes, numlighttrispvsbytes; + int lighttris, shadowtris, shadowmeshes, shadowmeshtris; entity_render_t *ent = r_refdef.worldentity; model_t *model = r_refdef.worldmodel; unsigned char *data; @@ -2132,24 +2378,34 @@ void R_RTLight_Compile(rtlight_t *rtlight) { // this variable must be set for the CompileShadowVolume code r_shadow_compilingrtlight = rtlight; - R_Shadow_EnlargeLeafSurfaceBuffer(model->brush.num_leafs, model->num_surfaces); - model->GetLightInfo(ent, rtlight->shadoworigin, rtlight->radius, rtlight->cullmins, rtlight->cullmaxs, r_shadow_buffer_leaflist, r_shadow_buffer_leafpvs, &numleafs, r_shadow_buffer_surfacelist, r_shadow_buffer_surfacepvs, &numsurfaces); + R_Shadow_EnlargeLeafSurfaceTrisBuffer(model->brush.num_leafs, model->num_surfaces, model->brush.shadowmesh ? model->brush.shadowmesh->numtriangles : model->surfmesh.num_triangles, model->surfmesh.num_triangles); + model->GetLightInfo(ent, rtlight->shadoworigin, rtlight->radius, rtlight->cullmins, rtlight->cullmaxs, r_shadow_buffer_leaflist, r_shadow_buffer_leafpvs, &numleafs, r_shadow_buffer_surfacelist, r_shadow_buffer_surfacepvs, &numsurfaces, r_shadow_buffer_shadowtrispvs, r_shadow_buffer_lighttrispvs); numleafpvsbytes = (model->brush.num_leafs + 7) >> 3; - data = (unsigned char *)Mem_Alloc(r_main_mempool, sizeof(int) * numleafs + numleafpvsbytes + sizeof(int) * numsurfaces); + numshadowtrispvsbytes = ((model->brush.shadowmesh ? model->brush.shadowmesh->numtriangles : model->surfmesh.num_triangles) + 7) >> 3; + numlighttrispvsbytes = (model->surfmesh.num_triangles + 7) >> 3; + data = (unsigned char *)Mem_Alloc(r_main_mempool, sizeof(int) * numsurfaces + sizeof(int) * numleafs + numleafpvsbytes + numshadowtrispvsbytes + numlighttrispvsbytes); + rtlight->static_numsurfaces = numsurfaces; + rtlight->static_surfacelist = (int *)data;data += sizeof(int) * numsurfaces; rtlight->static_numleafs = numleafs; - rtlight->static_numleafpvsbytes = numleafpvsbytes; rtlight->static_leaflist = (int *)data;data += sizeof(int) * numleafs; + rtlight->static_numleafpvsbytes = numleafpvsbytes; rtlight->static_leafpvs = (unsigned char *)data;data += numleafpvsbytes; - rtlight->static_numsurfaces = numsurfaces; - rtlight->static_surfacelist = (int *)data;data += sizeof(int) * numsurfaces; - if (numleafs) + rtlight->static_numshadowtrispvsbytes = numshadowtrispvsbytes; + rtlight->static_shadowtrispvs = (unsigned char *)data;data += numshadowtrispvsbytes; + rtlight->static_numlighttrispvsbytes = numlighttrispvsbytes; + rtlight->static_lighttrispvs = (unsigned char *)data;data += numlighttrispvsbytes; + if (rtlight->static_numsurfaces) + memcpy(rtlight->static_surfacelist, r_shadow_buffer_surfacelist, rtlight->static_numsurfaces * sizeof(*rtlight->static_surfacelist)); + if (rtlight->static_numleafs) memcpy(rtlight->static_leaflist, r_shadow_buffer_leaflist, rtlight->static_numleafs * sizeof(*rtlight->static_leaflist)); - if (numleafpvsbytes) + if (rtlight->static_numleafpvsbytes) memcpy(rtlight->static_leafpvs, r_shadow_buffer_leafpvs, rtlight->static_numleafpvsbytes); - if (numsurfaces) - memcpy(rtlight->static_surfacelist, r_shadow_buffer_surfacelist, rtlight->static_numsurfaces * sizeof(*rtlight->static_surfacelist)); + if (rtlight->static_numshadowtrispvsbytes) + memcpy(rtlight->static_shadowtrispvs, r_shadow_buffer_shadowtrispvs, rtlight->static_numshadowtrispvsbytes); + if (rtlight->static_numlighttrispvsbytes) + memcpy(rtlight->static_lighttrispvs, r_shadow_buffer_lighttrispvs, rtlight->static_numlighttrispvsbytes); if (model->CompileShadowVolume && rtlight->shadow) - model->CompileShadowVolume(ent, rtlight->shadoworigin, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist); + model->CompileShadowVolume(ent, rtlight->shadoworigin, NULL, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist); // now we're done compiling the rtlight r_shadow_compilingrtlight = NULL; } @@ -2160,19 +2416,31 @@ void R_RTLight_Compile(rtlight_t *rtlight) //rtlight->cullradius = min(rtlight->cullradius, rtlight->radius); shadowmeshes = 0; - shadowtris = 0; + shadowmeshtris = 0; if (rtlight->static_meshchain_shadow) { shadowmesh_t *mesh; for (mesh = rtlight->static_meshchain_shadow;mesh;mesh = mesh->next) { shadowmeshes++; - shadowtris += mesh->numtriangles; + shadowmeshtris += mesh->numtriangles; } } + lighttris = 0; + if (rtlight->static_numlighttrispvsbytes) + for (i = 0;i < rtlight->static_numlighttrispvsbytes*8;i++) + if (CHECKPVSBIT(rtlight->static_lighttrispvs, i)) + lighttris++; + + shadowtris = 0; + if (rtlight->static_numlighttrispvsbytes) + for (i = 0;i < rtlight->static_numshadowtrispvsbytes*8;i++) + if (CHECKPVSBIT(rtlight->static_shadowtrispvs, i)) + shadowtris++; + if (developer.integer >= 10) - Con_Printf("static light built: %f %f %f : %f %f %f box, %i shadow volume triangles (in %i meshes)\n", rtlight->cullmins[0], rtlight->cullmins[1], rtlight->cullmins[2], rtlight->cullmaxs[0], rtlight->cullmaxs[1], rtlight->cullmaxs[2], shadowtris, shadowmeshes); + Con_Printf("static light built: %f %f %f : %f %f %f box, %i light triangles, %i shadow triangles, %i compiled shadow volume triangles (in %i meshes)\n", rtlight->cullmins[0], rtlight->cullmins[1], rtlight->cullmins[2], rtlight->cullmaxs[0], rtlight->cullmaxs[1], rtlight->cullmaxs[2], lighttris, shadowtris, shadowmeshtris, shadowmeshes); } void R_RTLight_Uncompile(rtlight_t *rtlight) @@ -2183,14 +2451,18 @@ void R_RTLight_Uncompile(rtlight_t *rtlight) Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow); rtlight->static_meshchain_shadow = NULL; // these allocations are grouped - if (rtlight->static_leaflist) - Mem_Free(rtlight->static_leaflist); + if (rtlight->static_surfacelist) + Mem_Free(rtlight->static_surfacelist); rtlight->static_numleafs = 0; rtlight->static_numleafpvsbytes = 0; rtlight->static_leaflist = NULL; rtlight->static_leafpvs = NULL; rtlight->static_numsurfaces = 0; rtlight->static_surfacelist = NULL; + rtlight->static_numshadowtrispvsbytes = 0; + rtlight->static_shadowtrispvs = NULL; + rtlight->static_numlighttrispvsbytes = 0; + rtlight->static_lighttrispvs = NULL; rtlight->compiled = false; } } @@ -2202,66 +2474,248 @@ void R_Shadow_UncompileWorldLights(void) R_RTLight_Uncompile(&light->rtlight); } -void R_Shadow_DrawEntityShadow(entity_render_t *ent, int numsurfaces, int *surfacelist) +void R_Shadow_ComputeShadowCasterCullingPlanes(rtlight_t *rtlight) { - model_t *model = ent->model; - vec3_t relativeshadoworigin, relativeshadowmins, relativeshadowmaxs; - vec_t relativeshadowradius; - if (ent == r_refdef.worldentity) + int i, j; + mplane_t plane; + // reset the count of frustum planes + // see rsurface.rtlight_frustumplanes definition for how much this array + // can hold + rsurface.rtlight_numfrustumplanes = 0; + +#if 1 + // generate a deformed frustum that includes the light origin, this is + // used to cull shadow casting surfaces that can not possibly cast a + // shadow onto the visible light-receiving surfaces, which can be a + // performance gain + // + // if the light origin is onscreen the result will be 4 planes exactly + // if the light origin is offscreen on only one axis the result will + // be exactly 5 planes (split-side case) + // if the light origin is offscreen on two axes the result will be + // exactly 4 planes (stretched corner case) + for (i = 0;i < 4;i++) + { + // quickly reject standard frustum planes that put the light + // origin outside the frustum + if (PlaneDiff(rtlight->shadoworigin, &r_view.frustum[i]) < -0.03125) + continue; + // copy the plane + rsurface.rtlight_frustumplanes[rsurface.rtlight_numfrustumplanes++] = r_view.frustum[i]; + } + // if all the standard frustum planes were accepted, the light is onscreen + // otherwise we need to generate some more planes below... + if (rsurface.rtlight_numfrustumplanes < 4) { - if (r_shadow_rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer) + // at least one of the stock frustum planes failed, so we need to + // create one or two custom planes to enclose the light origin + for (i = 0;i < 4;i++) { - shadowmesh_t *mesh; - R_Mesh_Matrix(&ent->matrix); - for (mesh = r_shadow_rtlight->static_meshchain_shadow;mesh;mesh = mesh->next) + // create a plane using the view origin and light origin, and a + // single point from the frustum corner set + TriangleNormal(r_view.origin, r_view.frustumcorner[i], rtlight->shadoworigin, plane.normal); + VectorNormalize(plane.normal); + plane.dist = DotProduct(r_view.origin, plane.normal); + // see if this plane is backwards and flip it if so + for (j = 0;j < 4;j++) + if (j != i && DotProduct(r_view.frustumcorner[j], plane.normal) - plane.dist < -0.03125) + break; + if (j < 4) { - renderstats.lights_shadowtriangles += mesh->numtriangles; - R_Mesh_VertexPointer(mesh->vertex3f); - GL_LockArrays(0, mesh->numverts); - if (r_shadow_rendermode == R_SHADOW_RENDERMODE_STENCIL) - { - // decrement stencil if backface is behind depthbuffer - qglCullFace(GL_BACK); // quake is backwards, this culls front faces - qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP); - R_Mesh_Draw(0, mesh->numverts, mesh->numtriangles, mesh->element3i); - // increment stencil if frontface is behind depthbuffer - qglCullFace(GL_FRONT); // quake is backwards, this culls back faces - qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP); - } - R_Mesh_Draw(0, mesh->numverts, mesh->numtriangles, mesh->element3i); - GL_LockArrays(0, 0); + VectorNegate(plane.normal, plane.normal); + plane.dist *= -1; + // flipped plane, test again to see if it is now valid + for (j = 0;j < 4;j++) + if (j != i && DotProduct(r_view.frustumcorner[j], plane.normal) - plane.dist < -0.03125) + break; + // if the plane is still not valid, then it is dividing the + // frustum and has to be rejected + if (j < 4) + continue; } + // we have created a valid plane, compute extra info + PlaneClassify(&plane); + // copy the plane + rsurface.rtlight_frustumplanes[rsurface.rtlight_numfrustumplanes++] = plane; +#if 1 + // if we've found 5 frustum planes then we have constructed a + // proper split-side case and do not need to keep searching for + // planes to enclose the light origin + if (rsurface.rtlight_numfrustumplanes == 5) + break; +#endif } - else if (numsurfaces) + } +#endif + +#if 0 + for (i = 0;i < rsurface.rtlight_numfrustumplanes;i++) + { + plane = rsurface.rtlight_frustumplanes[i]; + Con_Printf("light %p plane #%i %f %f %f : %f (%f %f %f %f %f)\n", rtlight, i, plane.normal[0], plane.normal[1], plane.normal[2], plane.dist, PlaneDiff(r_view.frustumcorner[0], &plane), PlaneDiff(r_view.frustumcorner[1], &plane), PlaneDiff(r_view.frustumcorner[2], &plane), PlaneDiff(r_view.frustumcorner[3], &plane), PlaneDiff(rtlight->shadoworigin, &plane)); + } +#endif + +#if 0 + // now add the light-space box planes if the light box is rotated, as any + // caster outside the oriented light box is irrelevant (even if it passed + // the worldspace light box, which is axial) + if (rtlight->matrix_lighttoworld.m[0][0] != 1 || rtlight->matrix_lighttoworld.m[1][1] != 1 || rtlight->matrix_lighttoworld.m[2][2] != 1) + { + for (i = 0;i < 6;i++) { - R_Mesh_Matrix(&ent->matrix); - model->DrawShadowVolume(ent, r_shadow_rtlight->shadoworigin, r_shadow_rtlight->radius, numsurfaces, surfacelist, r_shadow_rtlight->cullmins, r_shadow_rtlight->cullmaxs); + vec3_t v; + VectorClear(v); + v[i >> 1] = (i & 1) ? -1 : 1; + Matrix4x4_Transform(&rtlight->matrix_lighttoworld, v, plane.normal); + VectorSubtract(plane.normal, rtlight->shadoworigin, plane.normal); + plane.dist = VectorNormalizeLength(plane.normal); + plane.dist += DotProduct(plane.normal, rtlight->shadoworigin); + rsurface.rtlight_frustumplanes[rsurface.rtlight_numfrustumplanes++] = plane; } } - else +#endif + +#if 0 + // add the world-space reduced box planes + for (i = 0;i < 6;i++) + { + VectorClear(plane.normal); + plane.normal[i >> 1] = (i & 1) ? -1 : 1; + plane.dist = (i & 1) ? -rsurface.rtlight_cullmaxs[i >> 1] : rsurface.rtlight_cullmins[i >> 1]; + rsurface.rtlight_frustumplanes[rsurface.rtlight_numfrustumplanes++] = plane; + } +#endif + +#if 0 + { + int j, oldnum; + vec3_t points[8]; + vec_t bestdist; + // reduce all plane distances to tightly fit the rtlight cull box, which + // is in worldspace + VectorSet(points[0], rsurface.rtlight_cullmins[0], rsurface.rtlight_cullmins[1], rsurface.rtlight_cullmins[2]); + VectorSet(points[1], rsurface.rtlight_cullmaxs[0], rsurface.rtlight_cullmins[1], rsurface.rtlight_cullmins[2]); + VectorSet(points[2], rsurface.rtlight_cullmins[0], rsurface.rtlight_cullmaxs[1], rsurface.rtlight_cullmins[2]); + VectorSet(points[3], rsurface.rtlight_cullmaxs[0], rsurface.rtlight_cullmaxs[1], rsurface.rtlight_cullmins[2]); + VectorSet(points[4], rsurface.rtlight_cullmins[0], rsurface.rtlight_cullmins[1], rsurface.rtlight_cullmaxs[2]); + VectorSet(points[5], rsurface.rtlight_cullmaxs[0], rsurface.rtlight_cullmins[1], rsurface.rtlight_cullmaxs[2]); + VectorSet(points[6], rsurface.rtlight_cullmins[0], rsurface.rtlight_cullmaxs[1], rsurface.rtlight_cullmaxs[2]); + VectorSet(points[7], rsurface.rtlight_cullmaxs[0], rsurface.rtlight_cullmaxs[1], rsurface.rtlight_cullmaxs[2]); + oldnum = rsurface.rtlight_numfrustumplanes; + rsurface.rtlight_numfrustumplanes = 0; + for (j = 0;j < oldnum;j++) + { + // find the nearest point on the box to this plane + bestdist = DotProduct(rsurface.rtlight_frustumplanes[j].normal, points[0]); + for (i = 1;i < 8;i++) + { + dist = DotProduct(rsurface.rtlight_frustumplanes[j].normal, points[i]); + if (bestdist > dist) + bestdist = dist; + } + Con_Printf("light %p %splane #%i %f %f %f : %f < %f\n", rtlight, rsurface.rtlight_frustumplanes[j].dist < bestdist + 0.03125 ? "^2" : "^1", j, rsurface.rtlight_frustumplanes[j].normal[0], rsurface.rtlight_frustumplanes[j].normal[1], rsurface.rtlight_frustumplanes[j].normal[2], rsurface.rtlight_frustumplanes[j].dist, bestdist); + // if the nearest point is near or behind the plane, we want this + // plane, otherwise the plane is useless as it won't cull anything + if (rsurface.rtlight_frustumplanes[j].dist < bestdist + 0.03125) + { + PlaneClassify(&rsurface.rtlight_frustumplanes[j]); + rsurface.rtlight_frustumplanes[rsurface.rtlight_numfrustumplanes++] = rsurface.rtlight_frustumplanes[j]; + } + } + } +#endif +} + +void R_Shadow_DrawWorldShadow(int numsurfaces, int *surfacelist, const unsigned char *trispvs) +{ + RSurf_ActiveWorldEntity(); + if (rsurface.rtlight->compiled && r_shadow_realtime_world_compile.integer && r_shadow_realtime_world_compileshadow.integer) + { + shadowmesh_t *mesh; + CHECKGLERROR + for (mesh = rsurface.rtlight->static_meshchain_shadow;mesh;mesh = mesh->next) + { + r_refdef.stats.lights_shadowtriangles += mesh->numtriangles; + R_Mesh_VertexPointer(mesh->vertex3f, mesh->vbo, mesh->vbooffset_vertex3f); + GL_LockArrays(0, mesh->numverts); + if (r_shadow_rendermode == R_SHADOW_RENDERMODE_STENCIL) + { + // decrement stencil if backface is behind depthbuffer + GL_CullFace(GL_BACK); // quake is backwards, this culls front faces + qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);CHECKGLERROR + R_Mesh_Draw(0, mesh->numverts, mesh->numtriangles, mesh->element3i, mesh->ebo, 0); + // increment stencil if frontface is behind depthbuffer + GL_CullFace(GL_FRONT); // quake is backwards, this culls back faces + qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);CHECKGLERROR + } + R_Mesh_Draw(0, mesh->numverts, mesh->numtriangles, mesh->element3i, mesh->ebo, 0); + GL_LockArrays(0, 0); + } + CHECKGLERROR + } + else if (numsurfaces && r_refdef.worldmodel->brush.shadowmesh && r_shadow_culltriangles.integer) { - Matrix4x4_Transform(&ent->inversematrix, r_shadow_rtlight->shadoworigin, relativeshadoworigin); - relativeshadowradius = r_shadow_rtlight->radius / ent->scale; - relativeshadowmins[0] = relativeshadoworigin[0] - relativeshadowradius; - relativeshadowmins[1] = relativeshadoworigin[1] - relativeshadowradius; - relativeshadowmins[2] = relativeshadoworigin[2] - relativeshadowradius; - relativeshadowmaxs[0] = relativeshadoworigin[0] + relativeshadowradius; - relativeshadowmaxs[1] = relativeshadoworigin[1] + relativeshadowradius; - relativeshadowmaxs[2] = relativeshadoworigin[2] + relativeshadowradius; - R_Mesh_Matrix(&ent->matrix); - model->DrawShadowVolume(ent, relativeshadoworigin, relativeshadowradius, model->nummodelsurfaces, model->surfacelist, relativeshadowmins, relativeshadowmaxs); + int t, tend; + int surfacelistindex; + msurface_t *surface; + R_Shadow_PrepareShadowMark(r_refdef.worldmodel->brush.shadowmesh->numtriangles); + for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++) + { + surface = r_refdef.worldmodel->data_surfaces + surfacelist[surfacelistindex]; + for (t = surface->num_firstshadowmeshtriangle, tend = t + surface->num_triangles;t < tend;t++) + if (CHECKPVSBIT(trispvs, t)) + shadowmarklist[numshadowmark++] = t; + } + R_Shadow_VolumeFromList(r_refdef.worldmodel->brush.shadowmesh->numverts, r_refdef.worldmodel->brush.shadowmesh->numtriangles, r_refdef.worldmodel->brush.shadowmesh->vertex3f, r_refdef.worldmodel->brush.shadowmesh->element3i, r_refdef.worldmodel->brush.shadowmesh->neighbor3i, rsurface.rtlight->shadoworigin, NULL, rsurface.rtlight->radius + r_refdef.worldmodel->radius*2 + r_shadow_projectdistance.value, numshadowmark, shadowmarklist); } + else if (numsurfaces) + r_refdef.worldmodel->DrawShadowVolume(r_refdef.worldentity, rsurface.rtlight->shadoworigin, NULL, rsurface.rtlight->radius, numsurfaces, surfacelist, rsurface.rtlight_cullmins, rsurface.rtlight_cullmaxs); +} + +void R_Shadow_DrawEntityShadow(entity_render_t *ent) +{ + vec3_t relativeshadoworigin, relativeshadowmins, relativeshadowmaxs; + vec_t relativeshadowradius; + RSurf_ActiveModelEntity(ent, false, false); + Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, relativeshadoworigin); + relativeshadowradius = rsurface.rtlight->radius / ent->scale; + relativeshadowmins[0] = relativeshadoworigin[0] - relativeshadowradius; + relativeshadowmins[1] = relativeshadoworigin[1] - relativeshadowradius; + relativeshadowmins[2] = relativeshadoworigin[2] - relativeshadowradius; + relativeshadowmaxs[0] = relativeshadoworigin[0] + relativeshadowradius; + relativeshadowmaxs[1] = relativeshadoworigin[1] + relativeshadowradius; + relativeshadowmaxs[2] = relativeshadoworigin[2] + relativeshadowradius; + ent->model->DrawShadowVolume(ent, relativeshadoworigin, NULL, relativeshadowradius, ent->model->nummodelsurfaces, ent->model->surfacelist, relativeshadowmins, relativeshadowmaxs); } void R_Shadow_SetupEntityLight(const entity_render_t *ent) { // set up properties for rendering light onto this entity - Matrix4x4_Concat(&r_shadow_entitytolight, &r_shadow_rtlight->matrix_worldtolight, &ent->matrix); - Matrix4x4_Concat(&r_shadow_entitytoattenuationxyz, &matrix_attenuationxyz, &r_shadow_entitytolight); - Matrix4x4_Concat(&r_shadow_entitytoattenuationz, &matrix_attenuationz, &r_shadow_entitytolight); - Matrix4x4_Transform(&ent->inversematrix, r_shadow_rtlight->shadoworigin, r_shadow_entitylightorigin); - Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, r_shadow_entityeyeorigin); - R_Mesh_Matrix(&ent->matrix); + RSurf_ActiveModelEntity(ent, true, true); + Matrix4x4_Concat(&rsurface.entitytolight, &rsurface.rtlight->matrix_worldtolight, &ent->matrix); + Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight); + Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight); + Matrix4x4_Transform(&ent->inversematrix, rsurface.rtlight->shadoworigin, rsurface.entitylightorigin); + if (r_shadow_lightingrendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL) + R_Mesh_TexMatrix(3, &rsurface.entitytolight); +} + +void R_Shadow_DrawWorldLight(int numsurfaces, int *surfacelist, const unsigned char *trispvs) +{ + if (!r_refdef.worldmodel->DrawLight) + return; + + // set up properties for rendering light onto this entity + RSurf_ActiveWorldEntity(); + rsurface.entitytolight = rsurface.rtlight->matrix_worldtolight; + Matrix4x4_Concat(&rsurface.entitytoattenuationxyz, &matrix_attenuationxyz, &rsurface.entitytolight); + Matrix4x4_Concat(&rsurface.entitytoattenuationz, &matrix_attenuationz, &rsurface.entitytolight); + VectorCopy(rsurface.rtlight->shadoworigin, rsurface.entitylightorigin); + if (r_shadow_lightingrendermode == R_SHADOW_RENDERMODE_LIGHT_GLSL) + R_Mesh_TexMatrix(3, &rsurface.entitytolight); + + r_refdef.worldmodel->DrawLight(r_refdef.worldentity, numsurfaces, surfacelist, trispvs); } void R_Shadow_DrawEntityLight(entity_render_t *ent, int numsurfaces, int *surfacelist) @@ -2269,24 +2723,27 @@ void R_Shadow_DrawEntityLight(entity_render_t *ent, int numsurfaces, int *surfac model_t *model = ent->model; if (!model->DrawLight) return; + R_Shadow_SetupEntityLight(ent); - if (ent == r_refdef.worldentity) - model->DrawLight(ent, numsurfaces, surfacelist); - else - model->DrawLight(ent, model->nummodelsurfaces, model->surfacelist); + + model->DrawLight(ent, model->nummodelsurfaces, model->surfacelist, NULL); } void R_DrawRTLight(rtlight_t *rtlight, qboolean visible) { - int i, usestencil; + int i; float f; int numleafs, numsurfaces; int *leaflist, *surfacelist; - unsigned char *leafpvs; + unsigned char *leafpvs, *shadowtrispvs, *lighttrispvs; int numlightentities; + int numlightentities_noselfshadow; int numshadowentities; + int numshadowentities_noselfshadow; entity_render_t *lightentities[MAX_EDICTS]; + entity_render_t *lightentities_noselfshadow[MAX_EDICTS]; entity_render_t *shadowentities[MAX_EDICTS]; + entity_render_t *shadowentities_noselfshadow[MAX_EDICTS]; // skip lights that don't light because of ambientscale+diffusescale+specularscale being 0 (corona only lights) // skip lights that are basically invisible (color 0 0 0) @@ -2321,6 +2778,9 @@ void R_DrawRTLight(rtlight_t *rtlight, qboolean visible) if (R_CullBox(rtlight->cullmins, rtlight->cullmaxs)) return; + VectorCopy(rtlight->cullmins, rsurface.rtlight_cullmins); + VectorCopy(rtlight->cullmaxs, rsurface.rtlight_cullmaxs); + if (rtlight->compiled && r_shadow_realtime_world_compile.integer) { // compiled light, world available and can receive realtime lighting @@ -2330,18 +2790,22 @@ void R_DrawRTLight(rtlight_t *rtlight, qboolean visible) leafpvs = rtlight->static_leafpvs; numsurfaces = rtlight->static_numsurfaces; surfacelist = rtlight->static_surfacelist; + shadowtrispvs = rtlight->static_shadowtrispvs; + lighttrispvs = rtlight->static_lighttrispvs; } else if (r_refdef.worldmodel && r_refdef.worldmodel->GetLightInfo) { // dynamic light, world available and can receive realtime lighting // calculate lit surfaces and leafs - R_Shadow_EnlargeLeafSurfaceBuffer(r_refdef.worldmodel->brush.num_leafs, r_refdef.worldmodel->num_surfaces); - r_refdef.worldmodel->GetLightInfo(r_refdef.worldentity, rtlight->shadoworigin, rtlight->radius, rtlight->cullmins, rtlight->cullmaxs, r_shadow_buffer_leaflist, r_shadow_buffer_leafpvs, &numleafs, r_shadow_buffer_surfacelist, r_shadow_buffer_surfacepvs, &numsurfaces); + R_Shadow_EnlargeLeafSurfaceTrisBuffer(r_refdef.worldmodel->brush.num_leafs, r_refdef.worldmodel->num_surfaces, r_refdef.worldmodel->brush.shadowmesh ? r_refdef.worldmodel->brush.shadowmesh->numtriangles : r_refdef.worldmodel->surfmesh.num_triangles, r_refdef.worldmodel->surfmesh.num_triangles); + r_refdef.worldmodel->GetLightInfo(r_refdef.worldentity, rtlight->shadoworigin, rtlight->radius, rsurface.rtlight_cullmins, rsurface.rtlight_cullmaxs, r_shadow_buffer_leaflist, r_shadow_buffer_leafpvs, &numleafs, r_shadow_buffer_surfacelist, r_shadow_buffer_surfacepvs, &numsurfaces, r_shadow_buffer_shadowtrispvs, r_shadow_buffer_lighttrispvs); leaflist = r_shadow_buffer_leaflist; leafpvs = r_shadow_buffer_leafpvs; surfacelist = r_shadow_buffer_surfacelist; + shadowtrispvs = r_shadow_buffer_shadowtrispvs; + lighttrispvs = r_shadow_buffer_lighttrispvs; // if the reduced leaf bounds are offscreen, skip it - if (R_CullBox(rtlight->cullmins, rtlight->cullmaxs)) + if (R_CullBox(rsurface.rtlight_cullmins, rsurface.rtlight_cullmaxs)) return; } else @@ -2352,29 +2816,29 @@ void R_DrawRTLight(rtlight_t *rtlight, qboolean visible) leafpvs = NULL; numsurfaces = 0; surfacelist = NULL; + shadowtrispvs = NULL; + lighttrispvs = NULL; } // check if light is illuminating any visible leafs if (numleafs) { for (i = 0;i < numleafs;i++) - if (r_worldleafvisible[leaflist[i]]) + if (r_viewcache.world_leafvisible[leaflist[i]]) break; if (i == numleafs) return; } // set up a scissor rectangle for this light - if (R_Shadow_ScissorForBBox(rtlight->cullmins, rtlight->cullmaxs)) + if (R_Shadow_ScissorForBBox(rsurface.rtlight_cullmins, rsurface.rtlight_cullmaxs)) return; + R_Shadow_ComputeShadowCasterCullingPlanes(rtlight); + // make a list of lit entities and shadow casting entities numlightentities = 0; + numlightentities_noselfshadow = 0; numshadowentities = 0; - // don't count the world unless some surfaces are actually lit - if (numsurfaces) - { - lightentities[numlightentities++] = r_refdef.worldentity; - shadowentities[numshadowentities++] = r_refdef.worldentity; - } + numshadowentities_noselfshadow = 0; // add dynamic entities that are lit by the light if (r_drawentities.integer) { @@ -2382,22 +2846,67 @@ void R_DrawRTLight(rtlight_t *rtlight, qboolean visible) { model_t *model; entity_render_t *ent = r_refdef.entities[i]; - if (BoxesOverlap(ent->mins, ent->maxs, rtlight->cullmins, rtlight->cullmaxs) - && (model = ent->model) - && !(ent->flags & RENDER_TRANSPARENT) - && (r_refdef.worldmodel == NULL || r_refdef.worldmodel->brush.BoxTouchingLeafPVS == NULL || r_refdef.worldmodel->brush.BoxTouchingLeafPVS(r_refdef.worldmodel, leafpvs, ent->mins, ent->maxs))) + vec3_t org; + if (!BoxesOverlap(ent->mins, ent->maxs, rsurface.rtlight_cullmins, rsurface.rtlight_cullmaxs)) + continue; + // skip the object entirely if it is not within the valid + // shadow-casting region (which includes the lit region) + if (R_CullBoxCustomPlanes(ent->mins, ent->maxs, rsurface.rtlight_numfrustumplanes, rsurface.rtlight_frustumplanes)) + continue; + if (!(model = ent->model)) + continue; + if (r_viewcache.entityvisible[i] && model->DrawLight && (ent->flags & RENDER_LIGHT)) { - // about the VectorDistance2 - light emitting entities should not cast their own shadow - if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(ent->origin, rtlight->shadoworigin) > 0.1) - shadowentities[numshadowentities++] = ent; - if (ent->visframe == r_framecount && (ent->flags & RENDER_LIGHT) && model->DrawLight) + // this entity wants to receive light, is visible, and is + // inside the light box + // TODO: check if the surfaces in the model can receive light + // so now check if it's in a leaf seen by the light + if (r_refdef.worldmodel && r_refdef.worldmodel->brush.BoxTouchingLeafPVS && !r_refdef.worldmodel->brush.BoxTouchingLeafPVS(r_refdef.worldmodel, leafpvs, ent->mins, ent->maxs)) + continue; + if (ent->flags & RENDER_NOSELFSHADOW) + lightentities_noselfshadow[numlightentities_noselfshadow++] = ent; + else lightentities[numlightentities++] = ent; + // since it is lit, it probably also casts a shadow... + // about the VectorDistance2 - light emitting entities should not cast their own shadow + Matrix4x4_OriginFromMatrix(&ent->matrix, org); + if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1) + { + // note: exterior models without the RENDER_NOSELFSHADOW + // flag still create a RENDER_NOSELFSHADOW shadow but + // are lit normally, this means that they are + // self-shadowing but do not shadow other + // RENDER_NOSELFSHADOW entities such as the gun + // (very weird, but keeps the player shadow off the gun) + if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL)) + shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent; + else + shadowentities[numshadowentities++] = ent; + } + } + else if (ent->flags & RENDER_SHADOW) + { + // this entity is not receiving light, but may still need to + // cast a shadow... + // TODO: check if the surfaces in the model can cast shadow + // now check if it is in a leaf seen by the light + if (r_refdef.worldmodel && r_refdef.worldmodel->brush.BoxTouchingLeafPVS && !r_refdef.worldmodel->brush.BoxTouchingLeafPVS(r_refdef.worldmodel, leafpvs, ent->mins, ent->maxs)) + continue; + // about the VectorDistance2 - light emitting entities should not cast their own shadow + Matrix4x4_OriginFromMatrix(&ent->matrix, org); + if ((ent->flags & RENDER_SHADOW) && model->DrawShadowVolume && VectorDistance2(org, rtlight->shadoworigin) > 0.1) + { + if (ent->flags & (RENDER_NOSELFSHADOW | RENDER_EXTERIORMODEL)) + shadowentities_noselfshadow[numshadowentities_noselfshadow++] = ent; + else + shadowentities[numshadowentities++] = ent; + } } } } // return if there's nothing at all to light - if (!numlightentities) + if (!numlightentities && !numsurfaces) return; // don't let sound skip if going slow @@ -2407,49 +2916,102 @@ void R_DrawRTLight(rtlight_t *rtlight, qboolean visible) // make this the active rtlight for rendering purposes R_Shadow_RenderMode_ActiveLight(rtlight); // count this light in the r_speeds - renderstats.lights++; + r_refdef.stats.lights++; - usestencil = false; - if (numshadowentities && rtlight->shadow && (rtlight->isstatic ? r_rtworldshadows : r_rtdlightshadows)) + if (r_showshadowvolumes.integer && numsurfaces + numshadowentities + numshadowentities_noselfshadow && rtlight->shadow && (rtlight->isstatic ? r_refdef.rtworldshadows : r_refdef.rtdlightshadows)) + { + // optionally draw visible shape of the shadow volumes + // for performance analysis by level designers + R_Shadow_RenderMode_VisibleShadowVolumes(); + if (numsurfaces) + R_Shadow_DrawWorldShadow(numsurfaces, surfacelist, shadowtrispvs); + for (i = 0;i < numshadowentities;i++) + R_Shadow_DrawEntityShadow(shadowentities[i]); + for (i = 0;i < numshadowentities_noselfshadow;i++) + R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]); + } + + if (gl_stencil && numsurfaces + numshadowentities + numshadowentities_noselfshadow && rtlight->shadow && (rtlight->isstatic ? r_refdef.rtworldshadows : r_refdef.rtdlightshadows)) { // draw stencil shadow volumes to mask off pixels that are in shadow // so that they won't receive lighting - if (gl_stencil) + R_Shadow_RenderMode_StencilShadowVolumes(true); + if (numsurfaces) + R_Shadow_DrawWorldShadow(numsurfaces, surfacelist, shadowtrispvs); + for (i = 0;i < numshadowentities;i++) + R_Shadow_DrawEntityShadow(shadowentities[i]); + if (numlightentities_noselfshadow) { - usestencil = true; - R_Shadow_RenderMode_StencilShadowVolumes(); - for (i = 0;i < numshadowentities;i++) - R_Shadow_DrawEntityShadow(shadowentities[i], numsurfaces, surfacelist); + // draw lighting in the unmasked areas + R_Shadow_RenderMode_Lighting(true, false); + for (i = 0;i < numlightentities_noselfshadow;i++) + R_Shadow_DrawEntityLight(lightentities_noselfshadow[i], numsurfaces, surfacelist); + + // optionally draw the illuminated areas + // for performance analysis by level designers + if (r_showlighting.integer) + { + R_Shadow_RenderMode_VisibleLighting(!r_showdisabledepthtest.integer, false); + for (i = 0;i < numlightentities_noselfshadow;i++) + R_Shadow_DrawEntityLight(lightentities_noselfshadow[i], numsurfaces, surfacelist); + } + + R_Shadow_RenderMode_StencilShadowVolumes(false); } + for (i = 0;i < numshadowentities_noselfshadow;i++) + R_Shadow_DrawEntityShadow(shadowentities_noselfshadow[i]); - // optionally draw visible shape of the shadow volumes - // for performance analysis by level designers - if (r_showshadowvolumes.integer) + if (numsurfaces + numlightentities) { - R_Shadow_RenderMode_VisibleShadowVolumes(); - for (i = 0;i < numshadowentities;i++) - R_Shadow_DrawEntityShadow(shadowentities[i], numsurfaces, surfacelist); + // draw lighting in the unmasked areas + R_Shadow_RenderMode_Lighting(true, false); + if (numsurfaces) + R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs); + for (i = 0;i < numlightentities;i++) + R_Shadow_DrawEntityLight(lightentities[i], numsurfaces, surfacelist); + + // optionally draw the illuminated areas + // for performance analysis by level designers + if (r_showlighting.integer) + { + R_Shadow_RenderMode_VisibleLighting(!r_showdisabledepthtest.integer, false); + if (numsurfaces) + R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs); + for (i = 0;i < numlightentities;i++) + R_Shadow_DrawEntityLight(lightentities[i], numsurfaces, surfacelist); + } } } - - if (numlightentities) + else { - // draw lighting in the unmasked areas - R_Shadow_RenderMode_Lighting(usestencil, false); - for (i = 0;i < numlightentities;i++) - R_Shadow_DrawEntityLight(lightentities[i], numsurfaces, surfacelist); - - // optionally draw the illuminated areas - // for performance analysis by level designers - if (r_showlighting.integer) + if (numsurfaces + numlightentities) { - R_Shadow_RenderMode_VisibleLighting(usestencil && !r_showdisabledepthtest.integer, false); + // draw lighting in the unmasked areas + R_Shadow_RenderMode_Lighting(false, false); + if (numsurfaces) + R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs); for (i = 0;i < numlightentities;i++) R_Shadow_DrawEntityLight(lightentities[i], numsurfaces, surfacelist); + for (i = 0;i < numlightentities_noselfshadow;i++) + R_Shadow_DrawEntityLight(lightentities_noselfshadow[i], numsurfaces, surfacelist); + + // optionally draw the illuminated areas + // for performance analysis by level designers + if (r_showlighting.integer) + { + R_Shadow_RenderMode_VisibleLighting(false, false); + if (numsurfaces) + R_Shadow_DrawWorldLight(numsurfaces, surfacelist, lighttrispvs); + for (i = 0;i < numlightentities;i++) + R_Shadow_DrawEntityLight(lightentities[i], numsurfaces, surfacelist); + for (i = 0;i < numlightentities_noselfshadow;i++) + R_Shadow_DrawEntityLight(lightentities_noselfshadow[i], numsurfaces, surfacelist); + } } } } +void R_Shadow_DrawLightSprites(void); void R_ShadowVolumeLighting(qboolean visible) { int lnum, flag; @@ -2458,9 +3020,12 @@ void R_ShadowVolumeLighting(qboolean visible) if (r_refdef.worldmodel && strncmp(r_refdef.worldmodel->name, r_shadow_mapname, sizeof(r_shadow_mapname))) R_Shadow_EditLights_Reload_f(); + if (r_editlights.integer) + R_Shadow_DrawLightSprites(); + R_Shadow_RenderMode_Begin(); - flag = r_rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE; + flag = r_refdef.rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE; if (r_shadow_debuglight.integer >= 0) { for (lnum = 0, light = r_shadow_worldlightchain;light;lnum++, light = light->next) @@ -2471,13 +3036,102 @@ void R_ShadowVolumeLighting(qboolean visible) for (lnum = 0, light = r_shadow_worldlightchain;light;lnum++, light = light->next) if (light->flags & flag) R_DrawRTLight(&light->rtlight, visible); - if (r_rtdlight) + if (r_refdef.rtdlight) for (lnum = 0;lnum < r_refdef.numlights;lnum++) - R_DrawRTLight(&r_refdef.lights[lnum]->rtlight, visible); + R_DrawRTLight(&r_refdef.lights[lnum], visible); + + R_Shadow_RenderMode_End(); +} + +extern void R_SetupView(const matrix4x4_t *matrix); +extern cvar_t r_shadows_throwdistance; +void R_DrawModelShadows(void) +{ + int i; + float relativethrowdistance; + entity_render_t *ent; + vec3_t relativelightorigin; + vec3_t relativelightdirection; + vec3_t relativeshadowmins, relativeshadowmaxs; + float vertex3f[12]; + + if (!r_drawentities.integer || !gl_stencil) + return; + + CHECKGLERROR + GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height); + + r_shadow_rendermode = R_SHADOW_RENDERMODE_NONE; + if (gl_ext_separatestencil.integer) + r_shadow_shadowingrendermode = R_SHADOW_RENDERMODE_SEPARATESTENCIL; + else if (gl_ext_stenciltwoside.integer) + r_shadow_shadowingrendermode = R_SHADOW_RENDERMODE_STENCILTWOSIDE; + else + r_shadow_shadowingrendermode = R_SHADOW_RENDERMODE_STENCIL; + + R_Shadow_RenderMode_StencilShadowVolumes(true); + + for (i = 0;i < r_refdef.numentities;i++) + { + ent = r_refdef.entities[i]; + // cast shadows from anything that is not a submodel of the map + if (ent->model && ent->model->DrawShadowVolume != NULL && !ent->model->brush.submodel && (ent->flags & RENDER_SHADOW)) + { + relativethrowdistance = r_shadows_throwdistance.value * Matrix4x4_ScaleFromMatrix(&ent->inversematrix); + VectorSet(relativeshadowmins, -relativethrowdistance, -relativethrowdistance, -relativethrowdistance); + VectorSet(relativeshadowmaxs, relativethrowdistance, relativethrowdistance, relativethrowdistance); + VectorNegate(ent->modellight_lightdir, relativelightdirection); + VectorScale(relativelightdirection, -relativethrowdistance, relativelightorigin); + RSurf_ActiveModelEntity(ent, false, false); + ent->model->DrawShadowVolume(ent, relativelightorigin, relativelightdirection, relativethrowdistance, ent->model->nummodelsurfaces, ent->model->surfacelist, relativeshadowmins, relativeshadowmaxs); + } + } + + // not really the right mode, but this will disable any silly stencil features + R_Shadow_RenderMode_VisibleLighting(true, true); + + // vertex coordinates for a quad that covers the screen exactly + vertex3f[0] = 0;vertex3f[1] = 0;vertex3f[2] = 0; + vertex3f[3] = 1;vertex3f[4] = 0;vertex3f[5] = 0; + vertex3f[6] = 1;vertex3f[7] = 1;vertex3f[8] = 0; + vertex3f[9] = 0;vertex3f[10] = 1;vertex3f[11] = 0; + + // set up ortho view for rendering this pass + GL_SetupView_Mode_Ortho(0, 0, 1, 1, -10, 100); + GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height); + GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1); + GL_ScissorTest(true); + R_Mesh_Matrix(&identitymatrix); + R_Mesh_ResetTextureState(); + R_Mesh_VertexPointer(vertex3f, 0, 0); + R_Mesh_ColorPointer(NULL, 0, 0); + + // set up a 50% darkening blend on shadowed areas + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + GL_DepthRange(0, 1); + GL_DepthTest(false); + GL_DepthMask(false); + GL_PolygonOffset(0, 0);CHECKGLERROR + GL_Color(0, 0, 0, 0.5); + GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1); + qglDepthFunc(GL_ALWAYS);CHECKGLERROR + qglEnable(GL_STENCIL_TEST);CHECKGLERROR + qglStencilMask(~0);CHECKGLERROR + qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR + qglStencilFunc(GL_NOTEQUAL, 128, ~0);CHECKGLERROR + + // apply the blend to the shadowed areas + R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0); + + // restoring the perspective view is done by R_RenderScene + //R_SetupView(&r_view.matrix); + + // restore other state to normal R_Shadow_RenderMode_End(); } + //static char *suffix[6] = {"ft", "bk", "rt", "lf", "up", "dn"}; typedef struct suffixinfo_s { @@ -2585,7 +3239,7 @@ rtexture_t *R_Shadow_Cubemap(const char *basename) if (i >= MAX_CUBEMAPS) return r_texture_whitecube; numcubemaps++; - strcpy(cubemaps[i].basename, basename); + strlcpy(cubemaps[i].basename, basename, sizeof(cubemaps[i].basename)); cubemaps[i].texture = R_Shadow_LoadCubemap(cubemaps[i].basename); if (!cubemaps[i].texture) cubemaps[i].texture = r_texture_whitecube; @@ -2609,6 +3263,17 @@ dlight_t *R_Shadow_NewWorldLight(void) void R_Shadow_UpdateWorldLight(dlight_t *light, vec3_t origin, vec3_t angles, vec3_t color, vec_t radius, vec_t corona, int style, int shadowenable, const char *cubemapname, vec_t coronasizescale, vec_t ambientscale, vec_t diffusescale, vec_t specularscale, int flags) { + matrix4x4_t matrix; + // validate parameters + if (style < 0 || style >= MAX_LIGHTSTYLES) + { + Con_Printf("R_Shadow_NewWorldLight: invalid light style number %i, must be >= 0 and < %i\n", light->style, MAX_LIGHTSTYLES); + style = 0; + } + if (!cubemapname) + cubemapname = ""; + + // copy to light properties VectorCopy(origin, light->origin); light->angles[0] = angles[0] - 360 * floor(angles[0] / 360); light->angles[1] = angles[1] - 360 * floor(angles[1] / 360); @@ -2618,24 +3283,18 @@ void R_Shadow_UpdateWorldLight(dlight_t *light, vec3_t origin, vec3_t angles, ve light->color[2] = max(color[2], 0); light->radius = max(radius, 0); light->style = style; - if (light->style < 0 || light->style >= MAX_LIGHTSTYLES) - { - Con_Printf("R_Shadow_NewWorldLight: invalid light style number %i, must be >= 0 and < %i\n", light->style, MAX_LIGHTSTYLES); - light->style = 0; - } light->shadow = shadowenable; light->corona = corona; - if (!cubemapname) - cubemapname = ""; strlcpy(light->cubemapname, cubemapname, sizeof(light->cubemapname)); light->coronasizescale = coronasizescale; light->ambientscale = ambientscale; light->diffusescale = diffusescale; light->specularscale = specularscale; light->flags = flags; - Matrix4x4_CreateFromQuakeEntity(&light->matrix, light->origin[0], light->origin[1], light->origin[2], light->angles[0], light->angles[1], light->angles[2], 1); - R_RTLight_Update(light, true); + // update renderable light data + Matrix4x4_CreateFromQuakeEntity(&matrix, light->origin[0], light->origin[1], light->origin[2], light->angles[0], light->angles[1], light->angles[2], light->radius); + R_RTLight_Update(&light->rtlight, true, &matrix, light->color, light->style, light->cubemapname[0] ? light->cubemapname : NULL, light->shadow, light->corona, light->coronasizescale, light->ambientscale, light->diffusescale, light->specularscale, light->flags); } void R_Shadow_FreeWorldLight(dlight_t *light) @@ -2666,14 +3325,17 @@ void R_Shadow_SelectLight(dlight_t *light) r_shadow_selectedlight->selected = true; } -void R_Shadow_DrawCursor_TransparentCallback(const entity_render_t *ent, int surfacenumber, const rtlight_t *rtlight) +void R_Shadow_DrawCursor_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist) { + // this is never batched (there can be only one) float scale = r_editlights_cursorgrid.value * 0.5f; - R_DrawSprite(GL_SRC_ALPHA, GL_ONE, r_crosshairs[1]->tex, NULL, false, r_editlights_cursorlocation, r_viewright, r_viewup, scale, -scale, -scale, scale, 1, 1, 1, 0.5f); + R_DrawSprite(GL_SRC_ALPHA, GL_ONE, r_crosshairs[1]->tex, NULL, false, false, r_editlights_cursorlocation, r_view.right, r_view.up, scale, -scale, -scale, scale, 1, 1, 1, 0.5f); } -void R_Shadow_DrawLightSprite_TransparentCallback(const entity_render_t *ent, int surfacenumber, const rtlight_t *rtlight) +void R_Shadow_DrawLightSprite_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist) { + // this is never batched (due to the ent parameter changing every time) + // so numsurfaces == 1 and surfacelist[0] == lightnumber float intensity; const dlight_t *light = (dlight_t *)ent; intensity = 0.5; @@ -2681,7 +3343,7 @@ void R_Shadow_DrawLightSprite_TransparentCallback(const entity_render_t *ent, in intensity = 0.75 + 0.25 * sin(realtime * M_PI * 4.0); if (!light->shadow) intensity *= 0.5f; - R_DrawSprite(GL_SRC_ALPHA, GL_ONE, r_crosshairs[surfacenumber]->tex, NULL, false, light->origin, r_viewright, r_viewup, 8, -8, -8, 8, intensity, intensity, intensity, 0.5); + R_DrawSprite(GL_SRC_ALPHA, GL_ONE, r_crosshairs[surfacelist[0]]->tex, NULL, false, false, light->origin, r_view.right, r_view.up, 8, -8, -8, 8, intensity, intensity, intensity, 0.5f); } void R_Shadow_DrawLightSprites(void) @@ -2702,12 +3364,12 @@ void R_Shadow_SelectLightInView(void) bestrating = 0; for (light = r_shadow_worldlightchain;light;light = light->next) { - VectorSubtract(light->origin, r_vieworigin, temp); - rating = (DotProduct(temp, r_viewforward) / sqrt(DotProduct(temp, temp))); + VectorSubtract(light->origin, r_view.origin, temp); + rating = (DotProduct(temp, r_view.forward) / sqrt(DotProduct(temp, temp))); if (rating >= 0.95) { rating /= (1 + 0.0625f * sqrt(DotProduct(temp, temp))); - if (bestrating < rating && CL_TraceBox(light->origin, vec3_origin, vec3_origin, r_vieworigin, true, NULL, SUPERCONTENTS_SOLID, false).fraction == 1.0f) + if (bestrating < rating && CL_Move(light->origin, vec3_origin, vec3_origin, r_view.origin, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false).fraction == 1.0f) { bestrating = rating; best = light; @@ -2787,8 +3449,10 @@ void R_Shadow_LoadWorldLights(void) // remove quotes on cubemapname if (cubemapname[0] == '"' && cubemapname[strlen(cubemapname) - 1] == '"') { - cubemapname[strlen(cubemapname)-1] = 0; - strcpy(cubemapname, cubemapname + 1); + size_t namelen; + namelen = strlen(cubemapname) - 2; + memmove(cubemapname, cubemapname + 1, namelen); + cubemapname[namelen] = '\0'; } if (a < 8) { @@ -2932,7 +3596,7 @@ void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void) data = r_refdef.worldmodel->brush.entities; if (!data) return; - for (entnum = 0;COM_ParseToken(&data, false) && com_token[0] == '{';entnum++) + for (entnum = 0;COM_ParseToken_Simple(&data, false) && com_token[0] == '{';entnum++) { type = LIGHTTYPE_MINUSX; origin[0] = origin[1] = origin[2] = 0; @@ -2950,19 +3614,19 @@ void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void) islight = false; while (1) { - if (!COM_ParseToken(&data, false)) + if (!COM_ParseToken_Simple(&data, false)) break; // error if (com_token[0] == '}') break; // end of entity if (com_token[0] == '_') - strcpy(key, com_token + 1); + strlcpy(key, com_token + 1, sizeof(key)); else - strcpy(key, com_token); + strlcpy(key, com_token, sizeof(key)); while (key[strlen(key)-1] == ' ') // remove trailing spaces key[strlen(key)-1] = 0; - if (!COM_ParseToken(&data, false)) + if (!COM_ParseToken_Simple(&data, false)) break; // error - strcpy(value, com_token); + strlcpy(value, com_token, sizeof(value)); // now that we have the key pair worked out... if (!strcmp("light", key)) @@ -3133,8 +3797,8 @@ void R_Shadow_SetCursorLocationForView(void) vec_t dist, push; vec3_t dest, endpos; trace_t trace; - VectorMA(r_vieworigin, r_editlights_cursordistance.value, r_viewforward, dest); - trace = CL_TraceBox(r_vieworigin, vec3_origin, vec3_origin, dest, true, NULL, SUPERCONTENTS_SOLID, false); + VectorMA(r_view.origin, r_editlights_cursordistance.value, r_view.forward, dest); + trace = CL_Move(r_view.origin, vec3_origin, vec3_origin, dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false); if (trace.fraction < 1) { dist = trace.fraction * r_editlights_cursordistance.value; @@ -3142,7 +3806,7 @@ void R_Shadow_SetCursorLocationForView(void) if (push > dist) push = dist; push = -push; - VectorMA(trace.endpos, push, r_viewforward, endpos); + VectorMA(trace.endpos, push, r_view.forward, endpos); VectorMA(endpos, r_editlights_cursorpushoff.value, trace.plane.normal, endpos); } else @@ -3160,7 +3824,6 @@ void R_Shadow_UpdateWorldLightSelection(void) { R_Shadow_SetCursorLocationForView(); R_Shadow_SelectLightInView(); - R_Shadow_DrawLightSprites(); } else R_Shadow_SelectLight(NULL); @@ -3437,7 +4100,7 @@ void R_Shadow_EditLights_Edit_f(void) return; } if (Cmd_Argc() == 3) - strcpy(cubemapname, Cmd_Argv(2)); + strlcpy(cubemapname, Cmd_Argv(2), sizeof(cubemapname)); else cubemapname[0] = 0; } @@ -3569,24 +4232,24 @@ void R_Shadow_EditLights_DrawSelectedLightProperties(void) for (lightcount = 0, light = r_shadow_worldlightchain;light;lightcount++, light = light->next) if (light == r_shadow_selectedlight) lightnumber = lightcount; - sprintf(temp, "Cursor %f %f %f Total Lights %i", r_editlights_cursorlocation[0], r_editlights_cursorlocation[1], r_editlights_cursorlocation[2], lightcount);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; + sprintf(temp, "Cursor %f %f %f Total Lights %i", r_editlights_cursorlocation[0], r_editlights_cursorlocation[1], r_editlights_cursorlocation[2], lightcount);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8; if (r_shadow_selectedlight == NULL) return; - sprintf(temp, "Light #%i properties", lightnumber);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; - sprintf(temp, "Origin : %f %f %f\n", r_shadow_selectedlight->origin[0], r_shadow_selectedlight->origin[1], r_shadow_selectedlight->origin[2]);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; - sprintf(temp, "Angles : %f %f %f\n", r_shadow_selectedlight->angles[0], r_shadow_selectedlight->angles[1], r_shadow_selectedlight->angles[2]);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; - sprintf(temp, "Color : %f %f %f\n", r_shadow_selectedlight->color[0], r_shadow_selectedlight->color[1], r_shadow_selectedlight->color[2]);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; - sprintf(temp, "Radius : %f\n", r_shadow_selectedlight->radius);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; - sprintf(temp, "Corona : %f\n", r_shadow_selectedlight->corona);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; - sprintf(temp, "Style : %i\n", r_shadow_selectedlight->style);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; - sprintf(temp, "Shadows : %s\n", r_shadow_selectedlight->shadow ? "yes" : "no");DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; - sprintf(temp, "Cubemap : %s\n", r_shadow_selectedlight->cubemapname);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; - sprintf(temp, "CoronaSize : %f\n", r_shadow_selectedlight->coronasizescale);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; - sprintf(temp, "Ambient : %f\n", r_shadow_selectedlight->ambientscale);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; - sprintf(temp, "Diffuse : %f\n", r_shadow_selectedlight->diffusescale);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; - sprintf(temp, "Specular : %f\n", r_shadow_selectedlight->specularscale);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; - sprintf(temp, "NormalMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_NORMALMODE) ? "yes" : "no");DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; - sprintf(temp, "RealTimeMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_REALTIMEMODE) ? "yes" : "no");DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; + sprintf(temp, "Light #%i properties", lightnumber);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8; + sprintf(temp, "Origin : %f %f %f\n", r_shadow_selectedlight->origin[0], r_shadow_selectedlight->origin[1], r_shadow_selectedlight->origin[2]);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8; + sprintf(temp, "Angles : %f %f %f\n", r_shadow_selectedlight->angles[0], r_shadow_selectedlight->angles[1], r_shadow_selectedlight->angles[2]);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8; + sprintf(temp, "Color : %f %f %f\n", r_shadow_selectedlight->color[0], r_shadow_selectedlight->color[1], r_shadow_selectedlight->color[2]);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8; + sprintf(temp, "Radius : %f\n", r_shadow_selectedlight->radius);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8; + sprintf(temp, "Corona : %f\n", r_shadow_selectedlight->corona);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8; + sprintf(temp, "Style : %i\n", r_shadow_selectedlight->style);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8; + sprintf(temp, "Shadows : %s\n", r_shadow_selectedlight->shadow ? "yes" : "no");DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8; + sprintf(temp, "Cubemap : %s\n", r_shadow_selectedlight->cubemapname);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8; + sprintf(temp, "CoronaSize : %f\n", r_shadow_selectedlight->coronasizescale);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8; + sprintf(temp, "Ambient : %f\n", r_shadow_selectedlight->ambientscale);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8; + sprintf(temp, "Diffuse : %f\n", r_shadow_selectedlight->diffusescale);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8; + sprintf(temp, "Specular : %f\n", r_shadow_selectedlight->specularscale);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8; + sprintf(temp, "NormalMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_NORMALMODE) ? "yes" : "no");DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8; + sprintf(temp, "RealTimeMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_REALTIMEMODE) ? "yes" : "no");DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true);y += 8; } void R_Shadow_EditLights_ToggleShadow_f(void) @@ -3707,7 +4370,7 @@ void R_Shadow_EditLights_CopyInfo_f(void) r_shadow_bufferlight.radius = r_shadow_selectedlight->radius; r_shadow_bufferlight.style = r_shadow_selectedlight->style; if (r_shadow_selectedlight->cubemapname) - strcpy(r_shadow_bufferlight.cubemapname, r_shadow_selectedlight->cubemapname); + strlcpy(r_shadow_bufferlight.cubemapname, r_shadow_selectedlight->cubemapname, sizeof(r_shadow_bufferlight.cubemapname)); else r_shadow_bufferlight.cubemapname[0] = 0; r_shadow_bufferlight.shadow = r_shadow_selectedlight->shadow;