X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=r_shadow.c;h=9575f9c785c8ed8d23a7ff5146ad1661325efdb2;hb=8bd9d978b4c3c249c7adf0b7f645e61b0f4ec513;hp=f8a0e3dec69b8b410ba16d5cd65d661cecdd3feb;hpb=aee09d1c9af512a6dd365ae572464a4df0223207;p=xonotic%2Fdarkplaces.git diff --git a/r_shadow.c b/r_shadow.c index f8a0e3de..9575f9c7 100644 --- a/r_shadow.c +++ b/r_shadow.c @@ -1,479 +1,1084 @@ +/* +Terminology: Stencil Shadow Volume (sometimes called Stencil Shadows) +An extrusion of the lit faces, beginning at the original geometry and ending +further from the light source than the original geometry (presumably at least +as far as the light's radius, if the light has a radius at all), capped at +both front and back to avoid any problems (extrusion from dark faces also +works but has a different set of problems) + +This is rendered using Carmack's Reverse technique, in which backfaces behind +zbuffer (zfail) increment the stencil, and frontfaces behind zbuffer (zfail) +decrement the stencil, the result is a stencil value of zero where shadows +did not intersect the visible geometry, suitable as a stencil mask for +rendering lighting everywhere but shadow. + +In our case we use a biased stencil clear of 128 to avoid requiring the +stencil wrap extension (but probably should support it), and to address +Creative's patent on this sort of technology we also draw the frontfaces +first, and backfaces second (decrement, increment). + +Patent warning: +This algorithm may be covered by Creative's patent (US Patent #6384822) +on Carmack's Reverse paper (which I have not read), however that patent +seems to be about drawing a stencil shadow from a model in an otherwise +unshadowed scene, where as realtime lighting technology draws light where +shadows do not lie. + + + +Terminology: Stencil Light Volume (sometimes called Light Volumes) +Similar to a Stencil Shadow Volume, but inverted; rather than containing the +areas in shadow it contanis the areas in light, this can only be built +quickly for certain limited cases (such as portal visibility from a point), +but is quite useful for some effects (sunlight coming from sky polygons is +one possible example, translucent occluders is another example). + + + +Terminology: Optimized Stencil Shadow Volume +A Stencil Shadow Volume that has been processed sufficiently to ensure it has +no duplicate coverage of areas (no need to shadow an area twice), often this +greatly improves performance but is an operation too costly to use on moving +lights (however completely optimal Stencil Light Volumes can be constructed +in some ideal cases). + + + +Terminology: Per Pixel Lighting (sometimes abbreviated PPL) +Per pixel evaluation of lighting equations, at a bare minimum this involves +DOT3 shading of diffuse lighting (per pixel dotproduct of negated incidence +vector and surface normal, using a texture of the surface bumps, called a +NormalMap) if supported by hardware; in our case there is support for cards +which are incapable of DOT3, the quality is quite poor however. Additionally +it is desirable to have specular evaluation per pixel, per vertex +normalization of specular halfangle vectors causes noticable distortion but +is unavoidable on hardware without GL_ARB_fragment_program. + + + +Terminology: Normalization CubeMap +A cubemap containing normalized dot3-encoded (vectors of length 1 or less +encoded as RGB colors) for any possible direction, this technique allows per +pixel calculation of incidence vector for per pixel lighting purposes, which +would not otherwise be possible per pixel without GL_ARB_fragment_program. + + + +Terminology: 2D Attenuation Texturing +A very crude approximation of light attenuation with distance which results +in cylindrical light shapes which fade vertically as a streak (some games +such as Doom3 allow this to be rotated to be less noticable in specific +cases), the technique is simply modulating lighting by two 2D textures (which +can be the same) on different axes of projection (XY and Z, typically), this +is the best technique available without 3D Attenuation Texturing or +GL_ARB_fragment_program technology. + + + +Terminology: 3D Attenuation Texturing +A slightly crude approximation of light attenuation with distance, its flaws +are limited radius and resolution (performance tradeoffs). + + + +Terminology: 3D Attenuation-Normalization Texturing +A 3D Attenuation Texture merged with a Normalization CubeMap, by making the +vectors shorter the lighting becomes darker, a very effective optimization of +diffuse lighting if 3D Attenuation Textures are already used. + + + +Terminology: Light Cubemap Filtering +A technique for modeling non-uniform light distribution according to +direction, for example projecting a stained glass window image onto a wall, +this is done by texturing the lighting with a cubemap. + + + +Terminology: Light Projection Filtering +A technique for modeling shadowing of light passing through translucent +surfaces, allowing stained glass windows and other effects to be done more +elegantly than possible with Light Cubemap Filtering by applying an occluder +texture to the lighting combined with a stencil light volume to limit the lit +area (this allows evaluating multiple translucent occluders in a scene). + + + +Terminology: Doom3 Lighting +A combination of Stencil Shadow Volume, Per Pixel Lighting, Normalization +CubeMap, 2D Attenuation Texturing, and Light Filtering, as demonstrated by +the (currently upcoming) game Doom3. +*/ + #include "quakedef.h" #include "r_shadow.h" #include "cl_collision.h" +#include "portals.h" +#include "image.h" extern void R_Shadow_EditLights_Init(void); #define SHADOWSTAGE_NONE 0 #define SHADOWSTAGE_STENCIL 1 #define SHADOWSTAGE_LIGHT 2 -#define SHADOWSTAGE_ERASESTENCIL 3 +#define SHADOWSTAGE_STENCILTWOSIDE 3 int r_shadowstage = SHADOWSTAGE_NONE; -int r_shadow_reloadlights = false; - -int r_shadow_lightingmode = 0; mempool_t *r_shadow_mempool; int maxshadowelements; int *shadowelements; -int maxtrianglefacinglight; -qbyte *trianglefacinglight; + +int maxshadowmark; +int numshadowmark; +int *shadowmark; +int *shadowmarklist; +int shadowmarkcount; + +int maxvertexupdate; +int *vertexupdate; +int *vertexremap; +int vertexupdatenum; + +int r_shadow_buffer_numclusterpvsbytes; +qbyte *r_shadow_buffer_clusterpvs; +int *r_shadow_buffer_clusterlist; + +int r_shadow_buffer_numsurfacepvsbytes; +qbyte *r_shadow_buffer_surfacepvs; +int *r_shadow_buffer_surfacelist; rtexturepool_t *r_shadow_texturepool; -rtexture_t *r_shadow_normalscubetexture; +rtexture_t *r_shadow_normalcubetexture; rtexture_t *r_shadow_attenuation2dtexture; -rtexture_t *r_shadow_blankbumptexture; -rtexture_t *r_shadow_blankglosstexture; -rtexture_t *r_shadow_blankwhitetexture; +rtexture_t *r_shadow_attenuation3dtexture; +rtexture_t *r_shadow_blankwhitecubetexture; -cvar_t r_shadow_lightattenuationpower = {0, "r_shadow_lightattenuationpower", "2"}; -cvar_t r_shadow_lightattenuationscale = {0, "r_shadow_lightattenuationscale", "2"}; -cvar_t r_shadow_lightintensityscale = {0, "r_shadow_lightintensityscale", "1"}; -cvar_t r_shadow_realtime = {0, "r_shadow_realtime", "0"}; -cvar_t r_shadow_gloss = {0, "r_shadow_gloss", "1"}; +// lights are reloaded when this changes +char r_shadow_mapname[MAX_QPATH]; + +// used only for light filters (cubemaps) +rtexturepool_t *r_shadow_filters_texturepool; + +cvar_t r_shadow_bumpscale_basetexture = {0, "r_shadow_bumpscale_basetexture", "0"}; +cvar_t r_shadow_bumpscale_bumpmap = {0, "r_shadow_bumpscale_bumpmap", "4"}; +cvar_t r_shadow_cull = {0, "r_shadow_cull", "1"}; cvar_t r_shadow_debuglight = {0, "r_shadow_debuglight", "-1"}; +cvar_t r_shadow_gloss = {CVAR_SAVE, "r_shadow_gloss", "1"}; +cvar_t r_shadow_gloss2intensity = {0, "r_shadow_gloss2intensity", "0.25"}; +cvar_t r_shadow_glossintensity = {0, "r_shadow_glossintensity", "1"}; +cvar_t r_shadow_lightattenuationpower = {0, "r_shadow_lightattenuationpower", "0.5"}; +cvar_t r_shadow_lightattenuationscale = {0, "r_shadow_lightattenuationscale", "1"}; +cvar_t r_shadow_lightintensityscale = {0, "r_shadow_lightintensityscale", "1"}; +cvar_t r_shadow_portallight = {0, "r_shadow_portallight", "1"}; +cvar_t r_shadow_projectdistance = {0, "r_shadow_projectdistance", "1000000"}; +cvar_t r_shadow_realtime_dlight = {CVAR_SAVE, "r_shadow_realtime_dlight", "1"}; +cvar_t r_shadow_realtime_dlight_shadows = {CVAR_SAVE, "r_shadow_realtime_dlight_shadows", "0"}; +cvar_t r_shadow_realtime_world = {CVAR_SAVE, "r_shadow_realtime_world", "0"}; +cvar_t r_shadow_realtime_world_dlightshadows = {CVAR_SAVE, "r_shadow_realtime_world_dlightshadows", "1"}; +cvar_t r_shadow_realtime_world_lightmaps = {CVAR_SAVE, "r_shadow_realtime_world_lightmaps", "0"}; +cvar_t r_shadow_realtime_world_shadows = {CVAR_SAVE, "r_shadow_realtime_world_shadows", "1"}; cvar_t r_shadow_scissor = {0, "r_shadow_scissor", "1"}; -cvar_t r_shadow_bumpscale_bumpmap = {0, "r_shadow_bumpscale_bumpmap", "4"}; -cvar_t r_shadow_bumpscale_basetexture = {0, "r_shadow_bumpscale_basetexture", "4"}; -cvar_t r_shadow_shadownudge = {0, "r_shadow_shadownudge", "1"}; +cvar_t r_shadow_shadow_polygonfactor = {0, "r_shadow_shadow_polygonfactor", "0"}; +cvar_t r_shadow_shadow_polygonoffset = {0, "r_shadow_shadow_polygonoffset", "1"}; +cvar_t r_shadow_singlepassvolumegeneration = {0, "r_shadow_singlepassvolumegeneration", "1"}; +cvar_t r_shadow_staticworldlights = {0, "r_shadow_staticworldlights", "1"}; +cvar_t r_shadow_texture3d = {0, "r_shadow_texture3d", "1"}; +cvar_t r_shadow_visiblevolumes = {0, "r_shadow_visiblevolumes", "0"}; +cvar_t r_shadow_glsl = {0, "r_shadow_glsl", "1"}; +cvar_t r_shadow_glsl_offsetmapping = {0, "r_shadow_glsl_offsetmapping", "1"}; +cvar_t r_shadow_glsl_offsetmapping_scale = {0, "r_shadow_glsl_offsetmapping_scale", "0.04"}; +cvar_t r_shadow_glsl_offsetmapping_bias = {0, "r_shadow_glsl_offsetmapping_bias", "-0.04"}; +cvar_t gl_ext_stenciltwoside = {0, "gl_ext_stenciltwoside", "1"}; +cvar_t r_editlights = {0, "r_editlights", "0"}; +cvar_t r_editlights_cursordistance = {0, "r_editlights_distance", "1024"}; +cvar_t r_editlights_cursorpushback = {0, "r_editlights_pushback", "0"}; +cvar_t r_editlights_cursorpushoff = {0, "r_editlights_pushoff", "4"}; +cvar_t r_editlights_cursorgrid = {0, "r_editlights_grid", "4"}; +cvar_t r_editlights_quakelightsizescale = {CVAR_SAVE, "r_editlights_quakelightsizescale", "0.8"}; +cvar_t r_editlights_rtlightssizescale = {CVAR_SAVE, "r_editlights_rtlightssizescale", "0.7"}; +cvar_t r_editlights_rtlightscolorscale = {CVAR_SAVE, "r_editlights_rtlightscolorscale", "2"}; + +float r_shadow_attenpower, r_shadow_attenscale; + +rtlight_t *r_shadow_compilingrtlight; +dlight_t *r_shadow_worldlightchain; +dlight_t *r_shadow_selectedlight; +dlight_t r_shadow_bufferlight; +vec3_t r_editlights_cursorlocation; + +rtexture_t *lighttextures[5]; +extern int con_vislines; + +typedef struct cubemapinfo_s +{ + char basename[64]; + rtexture_t *texture; +} +cubemapinfo_t; + +#define MAX_CUBEMAPS 256 +static int numcubemaps; +static cubemapinfo_t cubemaps[MAX_CUBEMAPS]; + +#define SHADERPERMUTATION_SPECULAR (1<<0) +#define SHADERPERMUTATION_FOG (1<<1) +#define SHADERPERMUTATION_CUBEFILTER (1<<2) +#define SHADERPERMUTATION_OFFSETMAPPING (1<<3) +#define SHADERPERMUTATION_COUNT (1<<4) + +GLhandleARB r_shadow_program_light[SHADERPERMUTATION_COUNT]; + +void R_Shadow_UncompileWorldLights(void); void R_Shadow_ClearWorldLights(void); void R_Shadow_SaveWorldLights(void); void R_Shadow_LoadWorldLights(void); void R_Shadow_LoadLightsFile(void); 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); + +const char *builtinshader_light_vert = +"// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n" +"// written by Forest 'LordHavoc' Hale\n" +"\n" +"uniform vec3 LightPosition;\n" +"\n" +"varying vec2 TexCoord;\n" +"varying vec3 CubeVector;\n" +"varying vec3 LightVector;\n" +"\n" +"#if defined(USESPECULAR) || defined(USEFOG) || defined(USEOFFSETMAPPING)\n" +"uniform vec3 EyePosition;\n" +"varying vec3 EyeVector;\n" +"#endif\n" +"\n" +"// TODO: get rid of tangentt (texcoord2) and use a crossproduct to regenerate it from tangents (texcoord1) and normal (texcoord3)\n" +"\n" +"void main(void)\n" +"{\n" +" // copy the surface texcoord\n" +" TexCoord = gl_MultiTexCoord0.st;\n" +"\n" +" // transform vertex position into light attenuation/cubemap space\n" +" // (-1 to +1 across the light box)\n" +" CubeVector = vec3(gl_TextureMatrix[3] * gl_Vertex);\n" +"\n" +" // transform unnormalized light direction into tangent space\n" +" // (we use unnormalized to ensure that it interpolates correctly and then\n" +" // normalize it per pixel)\n" +" vec3 lightminusvertex = LightPosition - gl_Vertex.xyz;\n" +" LightVector.x = -dot(lightminusvertex, gl_MultiTexCoord1.xyz);\n" +" LightVector.y = -dot(lightminusvertex, gl_MultiTexCoord2.xyz);\n" +" LightVector.z = -dot(lightminusvertex, gl_MultiTexCoord3.xyz);\n" +"\n" +"#if defined(USESPECULAR) || defined(USEFOG) || defined(USEOFFSETMAPPING)\n" +" // transform unnormalized eye direction into tangent space\n" +" vec3 eyeminusvertex = EyePosition - gl_Vertex.xyz;\n" +" EyeVector.x = -dot(eyeminusvertex, gl_MultiTexCoord1.xyz);\n" +" EyeVector.y = -dot(eyeminusvertex, gl_MultiTexCoord2.xyz);\n" +" EyeVector.z = -dot(eyeminusvertex, gl_MultiTexCoord3.xyz);\n" +"#endif\n" +"\n" +" // transform vertex to camera space, using ftransform to match non-VS\n" +" // rendering\n" +" gl_Position = ftransform();\n" +"}\n" +; + +const char *builtinshader_light_frag = +"// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n" +"// written by Forest 'LordHavoc' Hale\n" +"\n" +"uniform vec3 LightColor;\n" +"\n" +"#ifdef USEOFFSETMAPPING\n" +"uniform float OffsetMapping_Scale;\n" +"uniform float OffsetMapping_Bias;\n" +"#endif\n" +"#ifdef USESPECULAR\n" +"uniform float SpecularPower;\n" +"#endif\n" +"#ifdef USEFOG\n" +"uniform float FogRangeRecip;\n" +"#endif\n" +"uniform float AmbientScale;\n" +"uniform float DiffuseScale;\n" +"#ifdef USESPECULAR\n" +"uniform float SpecularScale;\n" +"#endif\n" +"\n" +"uniform sampler2D Texture_Normal;\n" +"uniform sampler2D Texture_Color;\n" +"#ifdef USESPECULAR\n" +"uniform sampler2D Texture_Gloss;\n" +"#endif\n" +"#ifdef USECUBEFILTER\n" +"uniform samplerCube Texture_Cube;\n" +"#endif\n" +"#ifdef USEFOG\n" +"uniform sampler2D Texture_FogMask;\n" +"#endif\n" +"\n" +"varying vec2 TexCoord;\n" +"varying vec3 CubeVector;\n" +"varying vec3 LightVector;\n" +"#if defined(USESPECULAR) || defined(USEFOG) || defined(USEOFFSETMAPPING)\n" +"varying vec3 EyeVector;\n" +"#endif\n" +"\n" +"void main(void)\n" +"{\n" +" // attenuation\n" +" //\n" +" // the attenuation is (1-(x*x+y*y+z*z)) which gives a large bright\n" +" // center and sharp falloff at the edge, this is about the most efficient\n" +" // we can get away with as far as providing illumination.\n" +" //\n" +" // pow(1-(x*x+y*y+z*z), 4) is far more realistic but needs large lights to\n" +" // provide significant illumination, large = slow = pain.\n" +" float colorscale = max(1.0 - dot(CubeVector, CubeVector), 0.0);\n" +"\n" +"#ifdef USEFOG\n" +" // apply fog\n" +" colorscale *= texture2D(Texture_FogMask, vec2(length(EyeVector)*FogRangeRecip, 0)).x;\n" +"#endif\n" +"\n" +"#ifdef USEOFFSETMAPPING\n" +" // this is 3 sample because of ATI Radeon 9500-9800/X300 limits\n" +" vec2 OffsetVector = normalize(EyeVector).xy * vec2(-0.333, 0.333);\n" +" vec2 TexCoordOffset = TexCoord + OffsetVector * (OffsetMapping_Bias + OffsetMapping_Scale * texture2D(Texture_Normal, TexCoord).w);\n" +" TexCoordOffset += OffsetVector * (OffsetMapping_Bias + OffsetMapping_Scale * texture2D(Texture_Normal, TexCoordOffset).w);\n" +" TexCoordOffset += OffsetVector * (OffsetMapping_Bias + OffsetMapping_Scale * texture2D(Texture_Normal, TexCoordOffset).w);\n" +"#define TexCoord TexCoordOffset\n" +"#endif\n" +"\n" +" // get the texels - with a blendmap we'd need to blend multiple here\n" +" vec3 surfacenormal = -1.0 + 2.0 * vec3(texture2D(Texture_Normal, TexCoord));\n" +" vec3 colortexel = vec3(texture2D(Texture_Color, TexCoord));\n" +"#ifdef USESPECULAR\n" +" vec3 glosstexel = vec3(texture2D(Texture_Gloss, TexCoord));\n" +"#endif\n" +"\n" +" // calculate shading\n" +" vec3 diffusenormal = normalize(LightVector);\n" +" vec3 color = colortexel * (AmbientScale + DiffuseScale * max(dot(surfacenormal, diffusenormal), 0.0));\n" +"#ifdef USESPECULAR\n" +" color += glosstexel * (SpecularScale * pow(max(dot(surfacenormal, normalize(diffusenormal + normalize(EyeVector))), 0.0), SpecularPower));\n" +"#endif\n" +"\n" +"#ifdef USECUBEFILTER\n" +" // apply light cubemap filter\n" +" color *= vec3(textureCube(Texture_Cube, CubeVector));\n" +"#endif\n" +"\n" +" // calculate fragment color\n" +" gl_FragColor = vec4(LightColor * color * colorscale, 1);\n" +"}\n" +; void r_shadow_start(void) { + int i; // allocate vertex processing arrays - r_shadow_mempool = Mem_AllocPool("R_Shadow"); - maxshadowelements = 0; - shadowelements = NULL; - maxtrianglefacinglight = 0; - trianglefacinglight = NULL; - r_shadow_normalscubetexture = NULL; + numcubemaps = 0; + r_shadow_normalcubetexture = NULL; r_shadow_attenuation2dtexture = NULL; - r_shadow_blankbumptexture = NULL; - r_shadow_blankglosstexture = NULL; - r_shadow_blankwhitetexture = NULL; + r_shadow_attenuation3dtexture = NULL; + r_shadow_blankwhitecubetexture = NULL; r_shadow_texturepool = NULL; - R_Shadow_ClearWorldLights(); - r_shadow_reloadlights = true; + r_shadow_filters_texturepool = NULL; + R_Shadow_ValidateCvars(); + R_Shadow_MakeTextures(); + maxshadowelements = 0; + shadowelements = NULL; + maxvertexupdate = 0; + vertexupdate = NULL; + vertexremap = NULL; + vertexupdatenum = 0; + maxshadowmark = 0; + numshadowmark = 0; + shadowmark = NULL; + shadowmarklist = NULL; + shadowmarkcount = 0; + r_shadow_buffer_numclusterpvsbytes = 0; + r_shadow_buffer_clusterpvs = NULL; + r_shadow_buffer_clusterlist = NULL; + r_shadow_buffer_numsurfacepvsbytes = 0; + r_shadow_buffer_surfacepvs = NULL; + r_shadow_buffer_surfacelist = NULL; + for (i = 0;i < SHADERPERMUTATION_COUNT;i++) + r_shadow_program_light[i] = 0; + if (gl_support_fragment_shader) + { + char *vertstring, *fragstring; + int vertstrings_count; + int fragstrings_count; + const char *vertstrings_list[SHADERPERMUTATION_COUNT]; + const char *fragstrings_list[SHADERPERMUTATION_COUNT]; + vertstring = FS_LoadFile("glsl/light.vert", tempmempool, false); + fragstring = FS_LoadFile("glsl/light.frag", tempmempool, false); + for (i = 0;i < SHADERPERMUTATION_COUNT;i++) + { + vertstrings_count = 0; + fragstrings_count = 0; + if (i & SHADERPERMUTATION_SPECULAR) + { + vertstrings_list[vertstrings_count++] = "#define USESPECULAR\n"; + fragstrings_list[fragstrings_count++] = "#define USESPECULAR\n"; + } + if (i & SHADERPERMUTATION_FOG) + { + vertstrings_list[vertstrings_count++] = "#define USEFOG\n"; + fragstrings_list[fragstrings_count++] = "#define USEFOG\n"; + } + if (i & SHADERPERMUTATION_CUBEFILTER) + { + vertstrings_list[vertstrings_count++] = "#define USECUBEFILTER\n"; + fragstrings_list[fragstrings_count++] = "#define USECUBEFILTER\n"; + } + if (i & SHADERPERMUTATION_OFFSETMAPPING) + { + vertstrings_list[vertstrings_count++] = "#define USEOFFSETMAPPING\n"; + fragstrings_list[fragstrings_count++] = "#define USEOFFSETMAPPING\n"; + } + vertstrings_list[vertstrings_count++] = vertstring ? vertstring : builtinshader_light_vert; + fragstrings_list[fragstrings_count++] = fragstring ? fragstring : builtinshader_light_frag; + r_shadow_program_light[i] = GL_Backend_CompileProgram(vertstrings_count, vertstrings_list, fragstrings_count, fragstrings_list); + if (!r_shadow_program_light[i]) + { + Con_Printf("permutation %s %s %s %s failed for shader %s, some features may not work properly!\n", i & 1 ? "specular" : "", i & 2 ? "fog" : "", i & 4 ? "cubefilter" : "", i & 8 ? "offsetmapping" : "", "glsl/light"); + continue; + } + qglUseProgramObjectARB(r_shadow_program_light[i]); + qglUniform1iARB(qglGetUniformLocationARB(r_shadow_program_light[i], "Texture_Normal"), 0);CHECKGLERROR + qglUniform1iARB(qglGetUniformLocationARB(r_shadow_program_light[i], "Texture_Color"), 1);CHECKGLERROR + if (i & SHADERPERMUTATION_SPECULAR) + { + qglUniform1iARB(qglGetUniformLocationARB(r_shadow_program_light[i], "Texture_Gloss"), 2);CHECKGLERROR + } + if (i & SHADERPERMUTATION_CUBEFILTER) + { + qglUniform1iARB(qglGetUniformLocationARB(r_shadow_program_light[i], "Texture_Cube"), 3);CHECKGLERROR + } + if (i & SHADERPERMUTATION_FOG) + { + qglUniform1iARB(qglGetUniformLocationARB(r_shadow_program_light[i], "Texture_FogMask"), 4);CHECKGLERROR + } + } + qglUseProgramObjectARB(0); + if (fragstring) + Mem_Free(fragstring); + if (vertstring) + Mem_Free(vertstring); + } } void r_shadow_shutdown(void) { - R_Shadow_ClearWorldLights(); - r_shadow_reloadlights = true; - r_shadow_normalscubetexture = NULL; + int i; + R_Shadow_UncompileWorldLights(); + for (i = 0;i < SHADERPERMUTATION_COUNT;i++) + { + if (r_shadow_program_light[i]) + { + GL_Backend_FreeProgram(r_shadow_program_light[i]); + r_shadow_program_light[i] = 0; + } + } + numcubemaps = 0; + r_shadow_normalcubetexture = NULL; r_shadow_attenuation2dtexture = NULL; - r_shadow_blankbumptexture = NULL; - r_shadow_blankglosstexture = NULL; - r_shadow_blankwhitetexture = NULL; + r_shadow_attenuation3dtexture = NULL; + r_shadow_blankwhitecubetexture = NULL; R_FreeTexturePool(&r_shadow_texturepool); + R_FreeTexturePool(&r_shadow_filters_texturepool); maxshadowelements = 0; + if (shadowelements) + Mem_Free(shadowelements); shadowelements = NULL; - maxtrianglefacinglight = 0; - trianglefacinglight = NULL; - Mem_FreePool(&r_shadow_mempool); + maxvertexupdate = 0; + if (vertexupdate) + Mem_Free(vertexupdate); + vertexupdate = NULL; + if (vertexremap) + Mem_Free(vertexremap); + vertexremap = NULL; + vertexupdatenum = 0; + maxshadowmark = 0; + numshadowmark = 0; + if (shadowmark) + Mem_Free(shadowmark); + shadowmark = NULL; + if (shadowmarklist) + Mem_Free(shadowmarklist); + shadowmarklist = NULL; + shadowmarkcount = 0; + r_shadow_buffer_numclusterpvsbytes = 0; + if (r_shadow_buffer_clusterpvs) + Mem_Free(r_shadow_buffer_clusterpvs); + r_shadow_buffer_clusterpvs = NULL; + if (r_shadow_buffer_clusterlist) + Mem_Free(r_shadow_buffer_clusterlist); + r_shadow_buffer_clusterlist = NULL; + r_shadow_buffer_numsurfacepvsbytes = 0; + if (r_shadow_buffer_surfacepvs) + Mem_Free(r_shadow_buffer_surfacepvs); + r_shadow_buffer_surfacepvs = NULL; + if (r_shadow_buffer_surfacelist) + Mem_Free(r_shadow_buffer_surfacelist); + r_shadow_buffer_surfacelist = NULL; } void r_shadow_newmap(void) { - R_Shadow_ClearWorldLights(); - r_shadow_reloadlights = true; +} + +void R_Shadow_Help_f(void) +{ + Con_Printf( +"Documentation on r_shadow system:\n" +"Settings:\n" +"r_shadow_bumpscale_basetexture : base texture as bumpmap with this scale\n" +"r_shadow_bumpscale_bumpmap : depth scale for bumpmap conversion\n" +"r_shadow_debuglight : render only this light number (-1 = all)\n" +"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_lightintensityscale : scale rendering brightness 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_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_glsl : use OpenGL Shading Language for lighting\n" +"r_shadow_glsl_offsetmapping : enables Offset Mapping bumpmap enhancement\n" +"r_shadow_glsl_offsetmapping_scale : controls depth of Offset Mapping\n" +"r_shadow_glsl_offsetmapping_bias : should be negative half of scale\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_singlepassvolumegeneration : selects shadow volume algorithm\n" +"r_shadow_texture3d : use 3d attenuation texture (if hardware supports)\n" +"r_shadow_visiblevolumes : useful for performance testing; bright = slow!\n" +"Commands:\n" +"r_shadow_help : this help\n" + ); } void R_Shadow_Init(void) { + Cvar_RegisterVariable(&r_shadow_bumpscale_basetexture); + Cvar_RegisterVariable(&r_shadow_bumpscale_bumpmap); + Cvar_RegisterVariable(&r_shadow_cull); + 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_lightintensityscale); - Cvar_RegisterVariable(&r_shadow_realtime); - Cvar_RegisterVariable(&r_shadow_gloss); - Cvar_RegisterVariable(&r_shadow_debuglight); + Cvar_RegisterVariable(&r_shadow_portallight); + Cvar_RegisterVariable(&r_shadow_projectdistance); + Cvar_RegisterVariable(&r_shadow_realtime_dlight); + Cvar_RegisterVariable(&r_shadow_realtime_dlight_shadows); + 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_scissor); - Cvar_RegisterVariable(&r_shadow_bumpscale_bumpmap); - Cvar_RegisterVariable(&r_shadow_bumpscale_basetexture); - Cvar_RegisterVariable(&r_shadow_shadownudge); + Cvar_RegisterVariable(&r_shadow_shadow_polygonfactor); + Cvar_RegisterVariable(&r_shadow_shadow_polygonoffset); + Cvar_RegisterVariable(&r_shadow_singlepassvolumegeneration); + Cvar_RegisterVariable(&r_shadow_staticworldlights); + Cvar_RegisterVariable(&r_shadow_texture3d); + Cvar_RegisterVariable(&r_shadow_visiblevolumes); + Cvar_RegisterVariable(&r_shadow_glsl); + Cvar_RegisterVariable(&r_shadow_glsl_offsetmapping); + Cvar_RegisterVariable(&r_shadow_glsl_offsetmapping_scale); + Cvar_RegisterVariable(&r_shadow_glsl_offsetmapping_bias); + Cvar_RegisterVariable(&gl_ext_stenciltwoside); + if (gamemode == GAME_TENEBRAE) + { + Cvar_SetValue("r_shadow_gloss", 2); + Cvar_SetValue("r_shadow_bumpscale_basetexture", 4); + } + Cmd_AddCommand("r_shadow_help", R_Shadow_Help_f); R_Shadow_EditLights_Init(); + r_shadow_mempool = Mem_AllocPool("R_Shadow", 0, NULL); + r_shadow_worldlightchain = NULL; + maxshadowelements = 0; + shadowelements = NULL; + maxvertexupdate = 0; + vertexupdate = NULL; + vertexremap = NULL; + vertexupdatenum = 0; + maxshadowmark = 0; + numshadowmark = 0; + shadowmark = NULL; + shadowmarklist = NULL; + shadowmarkcount = 0; + r_shadow_buffer_numclusterpvsbytes = 0; + r_shadow_buffer_clusterpvs = NULL; + r_shadow_buffer_clusterlist = NULL; + r_shadow_buffer_numsurfacepvsbytes = 0; + r_shadow_buffer_surfacepvs = NULL; + r_shadow_buffer_surfacelist = NULL; R_RegisterModule("R_Shadow", r_shadow_start, r_shadow_shutdown, r_shadow_newmap); } -void R_Shadow_ProjectVertices(float *verts, int numverts, const float *relativelightorigin, float projectdistance) +matrix4x4_t matrix_attenuationxyz = { - int i; - float *in, *out, diff[4]; - in = verts; - out = verts + numverts * 4; - for (i = 0;i < numverts;i++, in += 4, out += 4) { - VectorSubtract(in, relativelightorigin, diff); - VectorNormalizeFast(diff); - VectorMA(in, projectdistance, diff, out); - VectorMA(in, r_shadow_shadownudge.value, diff, in); + {0.5, 0.0, 0.0, 0.5}, + {0.0, 0.5, 0.0, 0.5}, + {0.0, 0.0, 0.5, 0.5}, + {0.0, 0.0, 0.0, 1.0} } -} +}; -void R_Shadow_MakeTriangleShadowFlags(const int *elements, const float *vertex, int numtris, qbyte *trianglefacinglight, const float *relativelightorigin, float lightradius) +matrix4x4_t matrix_attenuationz = { - int i; - const float *v0, *v1, *v2; - for (i = 0;i < numtris;i++, elements += 3) - { - // calculate triangle facing flag - v0 = vertex + elements[0] * 4; - v1 = vertex + elements[1] * 4; - v2 = vertex + elements[2] * 4; - // we do not need to normalize the surface normal because both sides - // of the comparison use it, therefore they are both multiplied the - // same amount... furthermore the subtract can be done on the - // vectors, saving a little bit of math in the dotproducts -#if 1 - // fast version - // subtracts v1 from v0 and v2, combined into a crossproduct, - // combined with a dotproduct of the light location relative to the - // first point of the triangle (any point works, since the triangle - // is obviously flat), and finally a comparison to determine if the - // light is infront of the triangle (the goal of this statement) - trianglefacinglight[i] = - (relativelightorigin[0] - v0[0]) * ((v0[1] - v1[1]) * (v2[2] - v1[2]) - (v0[2] - v1[2]) * (v2[1] - v1[1])) - + (relativelightorigin[1] - v0[1]) * ((v0[2] - v1[2]) * (v2[0] - v1[0]) - (v0[0] - v1[0]) * (v2[2] - v1[2])) - + (relativelightorigin[2] - v0[2]) * ((v0[0] - v1[0]) * (v2[1] - v1[1]) - (v0[1] - v1[1]) * (v2[0] - v1[0])) > 0; -#else - // readable version - { - float dir0[3], dir1[3], temp[3]; - - // calculate two mostly perpendicular edge directions - VectorSubtract(v0, v1, dir0); - VectorSubtract(v2, v1, dir1); - - // we have two edge directions, we can calculate a third vector from - // them, which is the direction of the surface normal (it's magnitude - // is not 1 however) - CrossProduct(dir0, dir1, temp); + { + {0.0, 0.0, 0.5, 0.5}, + {0.0, 0.0, 0.0, 0.5}, + {0.0, 0.0, 0.0, 0.5}, + {0.0, 0.0, 0.0, 1.0} + } +}; - // this is entirely unnecessary, but kept for clarity - //VectorNormalize(temp); +int *R_Shadow_ResizeShadowElements(int numtris) +{ + // make sure shadowelements is big enough for this volume + if (maxshadowelements < numtris * 24) + { + maxshadowelements = numtris * 24; + if (shadowelements) + Mem_Free(shadowelements); + shadowelements = Mem_Alloc(r_shadow_mempool, maxshadowelements * sizeof(int)); + } + return shadowelements; +} - // compare distance of light along normal, with distance of any point - // of the triangle along the same normal (the triangle is planar, - // I.E. flat, so all points give the same answer) - // the normal is not normalized because it is used on both sides of - // the comparison, so it's magnitude does not matter - trianglefacinglight[i] = DotProduct(relativelightorigin, temp) >= DotProduct(v0, temp); - } -#endif +void R_Shadow_EnlargeClusterBuffer(int numclusters) +{ + int numclusterpvsbytes = (((numclusters + 7) >> 3) + 255) & ~255; + if (r_shadow_buffer_numclusterpvsbytes < numclusterpvsbytes) + { + if (r_shadow_buffer_clusterpvs) + Mem_Free(r_shadow_buffer_clusterpvs); + if (r_shadow_buffer_clusterlist) + Mem_Free(r_shadow_buffer_clusterlist); + r_shadow_buffer_numclusterpvsbytes = numclusterpvsbytes; + r_shadow_buffer_clusterpvs = Mem_Alloc(r_shadow_mempool, r_shadow_buffer_numclusterpvsbytes); + r_shadow_buffer_clusterlist = Mem_Alloc(r_shadow_mempool, r_shadow_buffer_numclusterpvsbytes * 8 * sizeof(*r_shadow_buffer_clusterlist)); } } -int R_Shadow_BuildShadowVolumeTriangles(const int *elements, const int *neighbors, int numtris, int numverts, const qbyte *trianglefacinglight, int *out) -{ - int i, tris; - // check each frontface for bordering backfaces, - // and cast shadow polygons from those edges, - // also create front and back caps for shadow volume - tris = 0; - for (i = 0;i < numtris;i++, elements += 3, neighbors += 3) - { - if (trianglefacinglight[i]) - { - // triangle is frontface and therefore casts shadow, - // output front and back caps for shadow volume - // front cap - out[0] = elements[0]; - out[1] = elements[1]; - out[2] = elements[2]; - // rear cap (with flipped winding order) - out[3] = elements[0] + numverts; - out[4] = elements[2] + numverts; - out[5] = elements[1] + numverts; - out += 6; - tris += 2; - // check the edges - if (neighbors[0] < 0 || !trianglefacinglight[neighbors[0]]) - { - out[0] = elements[1]; - out[1] = elements[0]; - out[2] = elements[0] + numverts; - out[3] = elements[1]; - out[4] = elements[0] + numverts; - out[5] = elements[1] + numverts; - out += 6; - tris += 2; - } - if (neighbors[1] < 0 || !trianglefacinglight[neighbors[1]]) - { - out[0] = elements[2]; - out[1] = elements[1]; - out[2] = elements[1] + numverts; - out[3] = elements[2]; - out[4] = elements[1] + numverts; - out[5] = elements[2] + numverts; - out += 6; - tris += 2; - } - if (neighbors[2] < 0 || !trianglefacinglight[neighbors[2]]) - { - out[0] = elements[0]; - out[1] = elements[2]; - out[2] = elements[2] + numverts; - out[3] = elements[0]; - out[4] = elements[2] + numverts; - out[5] = elements[0] + numverts; - out += 6; - tris += 2; - } - } +void R_Shadow_EnlargeSurfaceBuffer(int numsurfaces) +{ + int numsurfacepvsbytes = (((numsurfaces + 7) >> 3) + 255) & ~255; + if (r_shadow_buffer_numsurfacepvsbytes < numsurfacepvsbytes) + { + if (r_shadow_buffer_surfacepvs) + Mem_Free(r_shadow_buffer_surfacepvs); + if (r_shadow_buffer_surfacelist) + Mem_Free(r_shadow_buffer_surfacelist); + r_shadow_buffer_numsurfacepvsbytes = numsurfacepvsbytes; + r_shadow_buffer_surfacepvs = Mem_Alloc(r_shadow_mempool, r_shadow_buffer_numsurfacepvsbytes); + r_shadow_buffer_surfacelist = Mem_Alloc(r_shadow_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist)); } - return tris; } -void R_Shadow_ResizeTriangleFacingLight(int numtris) +void R_Shadow_PrepareShadowMark(int numtris) { - // make sure trianglefacinglight is big enough for this volume - if (maxtrianglefacinglight < numtris) + // make sure shadowmark is big enough for this volume + if (maxshadowmark < numtris) + { + maxshadowmark = numtris; + if (shadowmark) + Mem_Free(shadowmark); + if (shadowmarklist) + Mem_Free(shadowmarklist); + shadowmark = Mem_Alloc(r_shadow_mempool, maxshadowmark * sizeof(*shadowmark)); + shadowmarklist = Mem_Alloc(r_shadow_mempool, maxshadowmark * sizeof(*shadowmarklist)); + shadowmarkcount = 0; + } + shadowmarkcount++; + // if shadowmarkcount wrapped we clear the array and adjust accordingly + if (shadowmarkcount == 0) { - maxtrianglefacinglight = numtris; - if (trianglefacinglight) - Mem_Free(trianglefacinglight); - trianglefacinglight = Mem_Alloc(r_shadow_mempool, maxtrianglefacinglight); + shadowmarkcount = 1; + memset(shadowmark, 0, maxshadowmark * sizeof(*shadowmark)); } + numshadowmark = 0; } -void R_Shadow_ResizeShadowElements(int numtris) +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) { - // make sure shadowelements is big enough for this volume - if (maxshadowelements < numtris * 24) + int i, j; + int outtriangles = 0, outvertices = 0; + const int *element; + const float *vertex; + + if (maxvertexupdate < innumvertices) { - maxshadowelements = numtris * 24; - if (shadowelements) - Mem_Free(shadowelements); - shadowelements = Mem_Alloc(r_shadow_mempool, maxshadowelements * sizeof(int)); + maxvertexupdate = innumvertices; + if (vertexupdate) + Mem_Free(vertexupdate); + if (vertexremap) + Mem_Free(vertexremap); + vertexupdate = Mem_Alloc(r_shadow_mempool, maxvertexupdate * sizeof(int)); + vertexremap = Mem_Alloc(r_shadow_mempool, maxvertexupdate * sizeof(int)); + vertexupdatenum = 0; + } + vertexupdatenum++; + if (vertexupdatenum == 0) + { + vertexupdatenum = 1; + memset(vertexupdate, 0, maxvertexupdate * sizeof(int)); + memset(vertexremap, 0, maxvertexupdate * sizeof(int)); + } + + for (i = 0;i < numshadowmarktris;i++) + shadowmark[shadowmarktris[i]] = shadowmarkcount; + + for (i = 0;i < numshadowmarktris;i++) + { + element = inelement3i + shadowmarktris[i] * 3; + // make sure the vertices are created + for (j = 0;j < 3;j++) + { + if (vertexupdate[element[j]] != vertexupdatenum) + { + 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; + } + } + } + + for (i = 0;i < numshadowmarktris;i++) + { + 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 (outnumvertices) + *outnumvertices = outvertices; + return outtriangles; } -void R_Shadow_Volume(int numverts, int numtris, int *elements, int *neighbors, vec3_t relativelightorigin, float lightradius, float projectdistance) +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) { - int tris; + int tris, outverts; if (projectdistance < 0.1) { Con_Printf("R_Shadow_Volume: projectdistance %f\n"); return; } -// terminology: -// -// frontface: -// a triangle facing the light source -// -// backface: -// a triangle not facing the light source -// -// shadow volume: -// an extrusion of the frontfaces, beginning at the original geometry and -// ending further from the light source than the original geometry -// (presumably at least as far as the light's radius, if the light has a -// radius at all), capped at both front and back to avoid any problems -// -// description: -// draws the shadow volumes of the model. -// requirements: -// vertex locations must already be in varray_vertex before use. -// varray_vertex must have capacity for numverts * 2. - - // make sure trianglefacinglight is big enough for this volume - if (maxtrianglefacinglight < numtris) - R_Shadow_ResizeTriangleFacingLight(numtris); - + if (!numverts || !nummarktris) + return; // make sure shadowelements is big enough for this volume - if (maxshadowelements < numtris * 24) - R_Shadow_ResizeShadowElements(numtris); - - // check which triangles are facing the light - R_Shadow_MakeTriangleShadowFlags(elements, varray_vertex, numtris, trianglefacinglight, relativelightorigin, lightradius); - - // generate projected vertices - // by clever use of elements we'll construct the whole shadow from - // the unprojected vertices and these projected vertices - R_Shadow_ProjectVertices(varray_vertex, numverts, relativelightorigin, projectdistance); - - // output triangle elements - tris = R_Shadow_BuildShadowVolumeTriangles(elements, neighbors, numtris, numverts, trianglefacinglight, shadowelements); - R_Shadow_RenderVolume(numverts * 2, tris, shadowelements); + if (maxshadowelements < nummarktris * 24) + R_Shadow_ResizeShadowElements((nummarktris + 256) * 24); + tris = R_Shadow_ConstructShadowVolume(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, varray_vertex3f2, projectorigin, projectdistance, nummarktris, marktris); + R_Shadow_RenderVolume(outverts, tris, varray_vertex3f2, shadowelements); } -void R_Shadow_RenderVolume(int numverts, int numtris, int *elements) +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) { - if (!numverts || !numtris) + int t, tend; + const int *e; + const float *v[3]; + if (!BoxesOverlap(lightmins, lightmaxs, surfacemins, surfacemaxs)) return; - if (r_shadowstage == SHADOWSTAGE_STENCIL) + 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]) { - // increment stencil if backface is behind depthbuffer - qglCullFace(GL_BACK); // quake is backwards, this culls front faces - qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP); - R_Mesh_Draw(numverts, numtris, elements); - // decrement stencil if frontface is behind depthbuffer - qglCullFace(GL_FRONT); // quake is backwards, this culls back faces - qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP); + // 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; + } + else + { + // surface box not entirely inside light box, cull each triangle + 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 (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; + } } - R_Mesh_Draw(numverts, numtris, elements); } -void R_Shadow_RenderShadowMeshVolume(shadowmesh_t *firstmesh) +void R_Shadow_RenderVolume(int numvertices, int numtriangles, const float *vertex3f, const int *element3i) { - shadowmesh_t *mesh; + rmeshstate_t m; + if (r_shadow_compilingrtlight) + { + // if we're compiling an rtlight, capture the mesh + Mod_ShadowMesh_AddMesh(r_shadow_mempool, r_shadow_compilingrtlight->static_meshchain_shadow, NULL, NULL, NULL, vertex3f, NULL, NULL, NULL, NULL, numtriangles, element3i); + return; + } + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + R_Mesh_State(&m); + GL_LockArrays(0, numvertices); if (r_shadowstage == SHADOWSTAGE_STENCIL) { // increment stencil if backface is behind depthbuffer qglCullFace(GL_BACK); // quake is backwards, this culls front faces qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP); - for (mesh = firstmesh;mesh;mesh = mesh->next) - { - R_Mesh_ResizeCheck(mesh->numverts); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); - R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->elements); - } + R_Mesh_Draw(0, numvertices, numtriangles, element3i); + c_rt_shadowmeshes++; + c_rt_shadowtris += numtriangles; // decrement stencil if frontface is behind depthbuffer qglCullFace(GL_FRONT); // quake is backwards, this culls back faces qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP); } - for (mesh = firstmesh;mesh;mesh = mesh->next) - { - R_Mesh_ResizeCheck(mesh->numverts); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); - R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->elements); - } + R_Mesh_Draw(0, numvertices, numtriangles, element3i); + c_rt_shadowmeshes++; + c_rt_shadowtris += numtriangles; + GL_LockArrays(0, 0); } -float r_shadow_attenpower, r_shadow_attenscale; static void R_Shadow_MakeTextures(void) { - int x, y, d, side; + int x, y, z, d, side; float v[3], s, t, intensity; qbyte *data; R_FreeTexturePool(&r_shadow_texturepool); r_shadow_texturepool = R_AllocTexturePool(); r_shadow_attenpower = r_shadow_lightattenuationpower.value; r_shadow_attenscale = r_shadow_lightattenuationscale.value; - data = Mem_Alloc(tempmempool, 6*128*128*4); - data[0] = 128; - data[1] = 128; - data[2] = 255; - data[3] = 255; - r_shadow_blankbumptexture = R_LoadTexture2D(r_shadow_texturepool, "blankbump", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL); - data[0] = 64; - data[1] = 64; - data[2] = 64; - data[3] = 255; - r_shadow_blankglosstexture = R_LoadTexture2D(r_shadow_texturepool, "blankgloss", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL); - data[0] = 255; - data[1] = 255; - data[2] = 255; - data[3] = 255; - r_shadow_blankwhitetexture = R_LoadTexture2D(r_shadow_texturepool, "blankwhite", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL); - for (side = 0;side < 6;side++) - { - for (y = 0;y < 128;y++) - { - for (x = 0;x < 128;x++) +#define NORMSIZE 64 +#define ATTEN2DSIZE 64 +#define ATTEN3DSIZE 32 + data = Mem_Alloc(tempmempool, max(6*NORMSIZE*NORMSIZE*4, max(ATTEN3DSIZE*ATTEN3DSIZE*ATTEN3DSIZE*4, ATTEN2DSIZE*ATTEN2DSIZE*4))); + r_shadow_blankwhitecubetexture = NULL; + r_shadow_normalcubetexture = NULL; + if (gl_texturecubemap) + { + data[ 0] = 255;data[ 1] = 255;data[ 2] = 255;data[ 3] = 255; + data[ 4] = 255;data[ 5] = 255;data[ 6] = 255;data[ 7] = 255; + data[ 8] = 255;data[ 9] = 255;data[10] = 255;data[11] = 255; + data[12] = 255;data[13] = 255;data[14] = 255;data[15] = 255; + data[16] = 255;data[17] = 255;data[18] = 255;data[19] = 255; + data[20] = 255;data[21] = 255;data[22] = 255;data[23] = 255; + r_shadow_blankwhitecubetexture = R_LoadTextureCubeMap(r_shadow_texturepool, "blankwhitecube", 1, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP, NULL); + for (side = 0;side < 6;side++) + { + for (y = 0;y < NORMSIZE;y++) { - s = (x + 0.5f) * (2.0f / 128.0f) - 1.0f; - t = (y + 0.5f) * (2.0f / 128.0f) - 1.0f; - switch(side) + for (x = 0;x < NORMSIZE;x++) { - case 0: - v[0] = 1; - v[1] = -t; - v[2] = -s; - break; - case 1: - v[0] = -1; - v[1] = -t; - v[2] = s; - break; - case 2: - v[0] = s; - v[1] = 1; - v[2] = t; - break; - case 3: - v[0] = s; - v[1] = -1; - v[2] = -t; - break; - case 4: - v[0] = s; - v[1] = -t; - v[2] = 1; - break; - case 5: - v[0] = -s; - v[1] = -t; - v[2] = -1; - break; + s = (x + 0.5f) * (2.0f / NORMSIZE) - 1.0f; + t = (y + 0.5f) * (2.0f / NORMSIZE) - 1.0f; + switch(side) + { + case 0: + v[0] = 1; + v[1] = -t; + v[2] = -s; + break; + case 1: + v[0] = -1; + v[1] = -t; + v[2] = s; + break; + case 2: + v[0] = s; + v[1] = 1; + v[2] = t; + break; + case 3: + v[0] = s; + v[1] = -1; + v[2] = -t; + break; + case 4: + v[0] = s; + v[1] = -t; + v[2] = 1; + break; + case 5: + v[0] = -s; + v[1] = -t; + v[2] = -1; + break; + } + intensity = 127.0f / sqrt(DotProduct(v, v)); + data[((side*NORMSIZE+y)*NORMSIZE+x)*4+0] = 128.0f + intensity * v[0]; + data[((side*NORMSIZE+y)*NORMSIZE+x)*4+1] = 128.0f + intensity * v[1]; + data[((side*NORMSIZE+y)*NORMSIZE+x)*4+2] = 128.0f + intensity * v[2]; + data[((side*NORMSIZE+y)*NORMSIZE+x)*4+3] = 255; } - intensity = 127.0f / sqrt(DotProduct(v, v)); - data[((side*128+y)*128+x)*4+0] = 128.0f + intensity * v[0]; - data[((side*128+y)*128+x)*4+1] = 128.0f + intensity * v[1]; - data[((side*128+y)*128+x)*4+2] = 128.0f + intensity * v[2]; - data[((side*128+y)*128+x)*4+3] = 255; } } + r_shadow_normalcubetexture = R_LoadTextureCubeMap(r_shadow_texturepool, "normalcube", NORMSIZE, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP, NULL); } - r_shadow_normalscubetexture = R_LoadTextureCubeMap(r_shadow_texturepool, "normalscube", 128, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP, NULL); - for (y = 0;y < 128;y++) + for (y = 0;y < ATTEN2DSIZE;y++) { - for (x = 0;x < 128;x++) + for (x = 0;x < ATTEN2DSIZE;x++) { - v[0] = (x + 0.5f) * (2.0f / 128.0f) - 1.0f; - v[1] = (y + 0.5f) * (2.0f / 128.0f) - 1.0f; + 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); - intensity = bound(0, intensity * r_shadow_attenscale * 256.0f, 255.0f); + intensity = pow(intensity, r_shadow_attenpower) * r_shadow_attenscale * 256.0f; d = bound(0, intensity, 255); - data[((0*128+y)*128+x)*4+0] = d; - data[((0*128+y)*128+x)*4+1] = d; - data[((0*128+y)*128+x)*4+2] = d; - data[((0*128+y)*128+x)*4+3] = d; + 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) + { + 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 = 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); } - r_shadow_attenuation2dtexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation2d", 128, 128, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA | TEXF_MIPMAP, NULL); Mem_Free(data); } +void R_Shadow_ValidateCvars(void) +{ + if (r_shadow_texture3d.integer && !gl_texture3d) + Cvar_SetValueQuick(&r_shadow_texture3d, 0); + if (gl_ext_stenciltwoside.integer && !gl_support_stenciltwoside) + Cvar_SetValueQuick(&gl_ext_stenciltwoside, 0); +} + void R_Shadow_Stage_Begin(void) { rmeshstate_t m; - //cl.worldmodel->numlights = min(cl.worldmodel->numlights, 1); + 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_MakeTextures(); - if (r_shadow_reloadlights && cl.worldmodel) - { - R_Shadow_ClearWorldLights(); - r_shadow_reloadlights = false; - R_Shadow_LoadWorldLights(); - if (r_shadow_worldlightchain == NULL) - { - R_Shadow_LoadLightsFile(); - if (r_shadow_worldlightchain == NULL) - R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(); - } - } memset(&m, 0, sizeof(m)); - m.blendfunc1 = GL_ONE; - m.blendfunc2 = GL_ZERO; + GL_BlendFunc(GL_ONE, GL_ZERO); + GL_DepthMask(false); + GL_DepthTest(true); R_Mesh_State(&m); 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); r_shadowstage = SHADOWSTAGE_NONE; } @@ -481,677 +1086,1965 @@ void R_Shadow_Stage_ShadowVolumes(void) { rmeshstate_t m; memset(&m, 0, sizeof(m)); - R_Mesh_TextureState(&m); + R_Mesh_State(&m); GL_Color(1, 1, 1, 1); - qglColorMask(0, 0, 0, 0); - qglDisable(GL_BLEND); - qglDepthMask(0); + GL_ColorMask(0, 0, 0, 0); + GL_BlendFunc(GL_ONE, GL_ZERO); + GL_DepthMask(false); + GL_DepthTest(true); + qglPolygonOffset(r_shadow_shadow_polygonfactor.value, r_shadow_shadow_polygonoffset.value); + //if (r_shadow_shadow_polygonoffset.value != 0) + //{ + // qglPolygonOffset(r_shadow_shadow_polygonfactor.value, r_shadow_shadow_polygonoffset.value); + // qglEnable(GL_POLYGON_OFFSET_FILL); + //} + //else + // qglDisable(GL_POLYGON_OFFSET_FILL); qglDepthFunc(GL_LESS); + qglCullFace(GL_FRONT); // quake is backwards, this culls back faces qglEnable(GL_STENCIL_TEST); - qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); - qglStencilFunc(GL_ALWAYS, 128, 0xFF); - qglEnable(GL_CULL_FACE); - qglEnable(GL_DEPTH_TEST); - r_shadowstage = SHADOWSTAGE_STENCIL; - qglClear(GL_STENCIL_BUFFER_BIT); + qglStencilFunc(GL_ALWAYS, 128, ~0); + if (gl_ext_stenciltwoside.integer) + { + r_shadowstage = SHADOWSTAGE_STENCILTWOSIDE; + 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_DECR, GL_KEEP); + qglActiveStencilFaceEXT(GL_FRONT); // quake is backwards, this is back faces + qglStencilMask(~0); + qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP); + } + else + { + r_shadowstage = SHADOWSTAGE_STENCIL; + 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); + c_rt_clears++; + // LordHavoc note: many shadow volumes reside entirely inside the world + // (that is to say they are entirely bounded by their lit surfaces), + // which can be optimized by handling things as an inverted light volume, + // with the shadow boundaries of the world being simulated by an altered + // (129) bias to stencil clearing on such lights + // FIXME: generate inverted light volumes for use as shadow volumes and + // optimize for them as noted above } -void R_Shadow_Stage_Light(void) +void R_Shadow_Stage_Light(int shadowtest) { rmeshstate_t m; memset(&m, 0, sizeof(m)); - R_Mesh_TextureState(&m); - qglActiveTexture(GL_TEXTURE0_ARB); - - qglEnable(GL_BLEND); - qglBlendFunc(GL_ONE, GL_ONE); + R_Mesh_State(&m); + GL_BlendFunc(GL_ONE, GL_ONE); + GL_DepthMask(false); + GL_DepthTest(true); + qglPolygonOffset(0, 0); + //qglDisable(GL_POLYGON_OFFSET_FILL); GL_Color(1, 1, 1, 1); - qglColorMask(1, 1, 1, 1); - qglDepthMask(0); + GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 1); qglDepthFunc(GL_EQUAL); - qglEnable(GL_STENCIL_TEST); + qglCullFace(GL_FRONT); // quake is backwards, this culls back faces + qglEnable(GL_CULL_FACE); + if (shadowtest) + qglEnable(GL_STENCIL_TEST); + else + qglDisable(GL_STENCIL_TEST); + if (gl_support_stenciltwoside) + qglDisable(GL_STENCIL_TEST_TWO_SIDE_EXT); + 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, 0xFF); - qglEnable(GL_CULL_FACE); - qglEnable(GL_DEPTH_TEST); + qglStencilFunc(GL_EQUAL, 128, ~0); r_shadowstage = SHADOWSTAGE_LIGHT; + c_rt_lights++; } void R_Shadow_Stage_End(void) { rmeshstate_t m; - // attempt to restore state to what Mesh_State thinks it is - qglDisable(GL_BLEND); - qglBlendFunc(GL_ONE, GL_ZERO); - qglDepthMask(1); - // now restore the rest of the state to normal + memset(&m, 0, sizeof(m)); + R_Mesh_State(&m); + GL_BlendFunc(GL_ONE, GL_ZERO); + GL_DepthMask(true); + GL_DepthTest(true); + qglPolygonOffset(0, 0); + //qglDisable(GL_POLYGON_OFFSET_FILL); GL_Color(1, 1, 1, 1); - qglColorMask(1, 1, 1, 1); - qglDisable(GL_SCISSOR_TEST); + 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 qglDisable(GL_STENCIL_TEST); qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); - qglStencilFunc(GL_ALWAYS, 128, 0xFF); - qglEnable(GL_CULL_FACE); - qglEnable(GL_DEPTH_TEST); - // force mesh state to reset by using various combinations of features - memset(&m, 0, sizeof(m)); - m.blendfunc1 = GL_SRC_ALPHA; - m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA; - R_Mesh_State(&m); - m.blendfunc1 = GL_ONE; - m.blendfunc2 = GL_ZERO; - R_Mesh_State(&m); + if (gl_support_stenciltwoside) + qglDisable(GL_STENCIL_TEST_TWO_SIDE_EXT); + qglStencilMask(~0); + qglStencilFunc(GL_ALWAYS, 128, ~0); r_shadowstage = SHADOWSTAGE_NONE; } -int R_Shadow_ScissorForBBoxAndSphere(const float *mins, const float *maxs, const float *origin, float radius) +int R_Shadow_ScissorForBBox(const float *mins, const float *maxs) { int i, ix1, iy1, ix2, iy2; - float x1, y1, x2, y2, x, y; + float x1, y1, x2, y2, x, y, f; vec3_t smins, smaxs; vec4_t v, v2; if (!r_shadow_scissor.integer) return false; // if view is inside the box, just say yes it's visible - if (r_origin[0] >= mins[0] && r_origin[0] <= maxs[0] - && r_origin[1] >= mins[1] && r_origin[1] <= maxs[1] - && r_origin[2] >= mins[2] && r_origin[2] <= maxs[2]) + if (BoxesOverlap(r_vieworigin, r_vieworigin, mins, maxs)) { - qglDisable(GL_SCISSOR_TEST); + GL_Scissor(r_view_x, r_view_y, r_view_width, r_view_height); return false; } - VectorSubtract(r_origin, origin, v); - if (DotProduct(v, v) < radius * radius) + for (i = 0;i < 3;i++) { - qglDisable(GL_SCISSOR_TEST); - return false; - } - // create viewspace bbox - for (i = 0;i < 8;i++) - { - v[0] = ((i & 1) ? mins[0] : maxs[0]) - r_origin[0]; - v[1] = ((i & 2) ? mins[1] : maxs[1]) - r_origin[1]; - v[2] = ((i & 4) ? mins[2] : maxs[2]) - r_origin[2]; - v2[0] = DotProduct(v, vright); - v2[1] = DotProduct(v, vup); - v2[2] = DotProduct(v, vpn); - if (i) + if (r_viewforward[i] >= 0) { - if (smins[0] > v2[0]) smins[0] = v2[0]; - if (smaxs[0] < v2[0]) smaxs[0] = v2[0]; - if (smins[1] > v2[1]) smins[1] = v2[1]; - if (smaxs[1] < v2[1]) smaxs[1] = v2[1]; - if (smins[2] > v2[2]) smins[2] = v2[2]; - if (smaxs[2] < v2[2]) smaxs[2] = v2[2]; + v[i] = mins[i]; + v2[i] = maxs[i]; } else { - smins[0] = smaxs[0] = v2[0]; - smins[1] = smaxs[1] = v2[1]; - smins[2] = smaxs[2] = v2[2]; - } - } - // now we have a bbox in viewspace - // clip it to the viewspace version of the sphere - v[0] = origin[0] - r_origin[0]; - v[1] = origin[1] - r_origin[1]; - v[2] = origin[2] - r_origin[2]; - v2[0] = DotProduct(v, vright); - v2[1] = DotProduct(v, vup); - v2[2] = DotProduct(v, vpn); - if (smins[0] < v2[0] - radius) smins[0] = v2[0] - radius; - if (smaxs[0] < v2[0] - radius) smaxs[0] = v2[0] + radius; - if (smins[1] < v2[1] - radius) smins[1] = v2[1] - radius; - if (smaxs[1] < v2[1] - radius) smaxs[1] = v2[1] + radius; - if (smins[2] < v2[2] - radius) smins[2] = v2[2] - radius; - if (smaxs[2] < v2[2] - radius) smaxs[2] = v2[2] + radius; - // clip it to the view plane - if (smins[2] < 1) - smins[2] = 1; - // return true if that culled the box - if (smins[2] >= smaxs[2]) - return true; - // ok some of it is infront of the view, transform each corner back to - // worldspace and then to screenspace and make screen rect - // initialize these variables just to avoid compiler warnings - x1 = y1 = x2 = y2 = 0; - for (i = 0;i < 8;i++) - { - v2[0] = (i & 1) ? smins[0] : smaxs[0]; - v2[1] = (i & 2) ? smins[1] : smaxs[1]; - v2[2] = (i & 4) ? smins[2] : smaxs[2]; - v[0] = v2[0] * vright[0] + v2[1] * vup[0] + v2[2] * vpn[0] + r_origin[0]; - v[1] = v2[0] * vright[1] + v2[1] * vup[1] + v2[2] * vpn[1] + r_origin[1]; - v[2] = v2[0] * vright[2] + v2[1] * vup[2] + v2[2] * vpn[2] + r_origin[2]; - v[3] = 1.0f; - GL_TransformToScreen(v, v2); - //Con_Printf("%.3f %.3f %.3f %.3f transformed to %.3f %.3f %.3f %.3f\n", v[0], v[1], v[2], v[3], v2[0], v2[1], v2[2], v2[3]); - x = v2[0]; - y = v2[1]; - if (i) - { - if (x1 > x) x1 = x; - if (x2 < x) x2 = x; - if (y1 > y) y1 = y; - if (y2 < y) y2 = y; + v[i] = maxs[i]; + v2[i] = mins[i]; } - else + } + f = DotProduct(r_viewforward, r_vieworigin) + 1; + if (DotProduct(r_viewforward, v2) <= f) + { + // entirely behind nearclip plane + return true; + } + if (DotProduct(r_viewforward, v) >= f) + { + // entirely infront of nearclip plane + x1 = y1 = x2 = y2 = 0; + for (i = 0;i < 8;i++) { - x1 = x2 = x; - y1 = y2 = y; + v[0] = (i & 1) ? mins[0] : maxs[0]; + v[1] = (i & 2) ? mins[1] : maxs[1]; + v[2] = (i & 4) ? mins[2] : maxs[2]; + v[3] = 1.0f; + GL_TransformToScreen(v, v2); + //Con_Printf("%.3f %.3f %.3f %.3f transformed to %.3f %.3f %.3f %.3f\n", v[0], v[1], v[2], v[3], v2[0], v2[1], v2[2], v2[3]); + x = v2[0]; + y = v2[1]; + if (i) + { + if (x1 > x) x1 = x; + if (x2 < x) x2 = x; + if (y1 > y) y1 = y; + if (y2 < y) y2 = y; + } + else + { + x1 = x2 = x; + y1 = y2 = y; + } } } - /* - // this code doesn't handle boxes with any points behind view properly - x1 = 1000;x2 = -1000; - y1 = 1000;y2 = -1000; - for (i = 0;i < 8;i++) - { - v[0] = (i & 1) ? mins[0] : maxs[0]; - v[1] = (i & 2) ? mins[1] : maxs[1]; - v[2] = (i & 4) ? mins[2] : maxs[2]; - v[3] = 1.0f; - GL_TransformToScreen(v, v2); - //Con_Printf("%.3f %.3f %.3f %.3f transformed to %.3f %.3f %.3f %.3f\n", v[0], v[1], v[2], v[3], v2[0], v2[1], v2[2], v2[3]); - if (v2[2] > 0) + else + { + // clipped by nearclip plane + // this is nasty and crude... + // create viewspace bbox + for (i = 0;i < 8;i++) + { + v[0] = ((i & 1) ? mins[0] : maxs[0]) - r_vieworigin[0]; + v[1] = ((i & 2) ? mins[1] : maxs[1]) - r_vieworigin[1]; + v[2] = ((i & 4) ? mins[2] : maxs[2]) - r_vieworigin[2]; + v2[0] = -DotProduct(v, r_viewleft); + v2[1] = DotProduct(v, r_viewup); + v2[2] = DotProduct(v, r_viewforward); + if (i) + { + if (smins[0] > v2[0]) smins[0] = v2[0]; + if (smaxs[0] < v2[0]) smaxs[0] = v2[0]; + if (smins[1] > v2[1]) smins[1] = v2[1]; + if (smaxs[1] < v2[1]) smaxs[1] = v2[1]; + if (smins[2] > v2[2]) smins[2] = v2[2]; + if (smaxs[2] < v2[2]) smaxs[2] = v2[2]; + } + else + { + smins[0] = smaxs[0] = v2[0]; + smins[1] = smaxs[1] = v2[1]; + smins[2] = smaxs[2] = v2[2]; + } + } + // now we have a bbox in viewspace + // clip it to the view plane + if (smins[2] < 1) + smins[2] = 1; + // return true if that culled the box + if (smins[2] >= smaxs[2]) + return true; + // ok some of it is infront of the view, transform each corner back to + // worldspace and then to screenspace and make screen rect + // initialize these variables just to avoid compiler warnings + x1 = y1 = x2 = y2 = 0; + for (i = 0;i < 8;i++) { + v2[0] = (i & 1) ? smins[0] : smaxs[0]; + v2[1] = (i & 2) ? smins[1] : smaxs[1]; + v2[2] = (i & 4) ? smins[2] : smaxs[2]; + v[0] = v2[0] * -r_viewleft[0] + v2[1] * r_viewup[0] + v2[2] * r_viewforward[0] + r_vieworigin[0]; + v[1] = v2[0] * -r_viewleft[1] + v2[1] * r_viewup[1] + v2[2] * r_viewforward[1] + r_vieworigin[1]; + v[2] = v2[0] * -r_viewleft[2] + v2[1] * r_viewup[2] + v2[2] * r_viewforward[2] + r_vieworigin[2]; + v[3] = 1.0f; + GL_TransformToScreen(v, v2); + //Con_Printf("%.3f %.3f %.3f %.3f transformed to %.3f %.3f %.3f %.3f\n", v[0], v[1], v[2], v[3], v2[0], v2[1], v2[2], v2[3]); x = v2[0]; y = v2[1]; + if (i) + { + if (x1 > x) x1 = x; + if (x2 < x) x2 = x; + if (y1 > y) y1 = y; + if (y2 < y) y2 = y; + } + else + { + x1 = x2 = x; + y1 = y2 = y; + } + } + /* + // this code doesn't handle boxes with any points behind view properly + x1 = 1000;x2 = -1000; + y1 = 1000;y2 = -1000; + for (i = 0;i < 8;i++) + { + v[0] = (i & 1) ? mins[0] : maxs[0]; + v[1] = (i & 2) ? mins[1] : maxs[1]; + v[2] = (i & 4) ? mins[2] : maxs[2]; + v[3] = 1.0f; + GL_TransformToScreen(v, v2); + //Con_Printf("%.3f %.3f %.3f %.3f transformed to %.3f %.3f %.3f %.3f\n", v[0], v[1], v[2], v[3], v2[0], v2[1], v2[2], v2[3]); + if (v2[2] > 0) + { + x = v2[0]; + y = v2[1]; - if (x1 > x) x1 = x; - if (x2 < x) x2 = x; - if (y1 > y) y1 = y; - if (y2 < y) y2 = y; + if (x1 > x) x1 = x; + if (x2 < x) x2 = x; + if (y1 > y) y1 = y; + if (y2 < y) y2 = y; + } } + */ } - */ ix1 = x1 - 1.0f; iy1 = y1 - 1.0f; ix2 = x2 + 1.0f; iy2 = y2 + 1.0f; //Con_Printf("%f %f %f %f\n", x1, y1, x2, y2); - if (ix1 < r_refdef.x) ix1 = r_refdef.x; - if (iy1 < r_refdef.y) iy1 = r_refdef.y; - if (ix2 > r_refdef.x + r_refdef.width) ix2 = r_refdef.x + r_refdef.width; - if (iy2 > r_refdef.y + r_refdef.height) iy2 = r_refdef.y + r_refdef.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 (ix2 <= ix1 || iy2 <= iy1) return true; // set up the scissor rectangle - qglScissor(ix1, iy1, ix2 - ix1, iy2 - iy1); - qglEnable(GL_SCISSOR_TEST); + GL_Scissor(ix1, vid.realheight - iy2, ix2 - ix1, iy2 - iy1); + //qglScissor(ix1, iy1, ix2 - ix1, iy2 - iy1); + //qglEnable(GL_SCISSOR_TEST); + c_rt_scissored++; return false; } -void R_Shadow_GenTexCoords_Attenuation2D1D(float *out2d, float *out1d, int numverts, const float *vertex, const float *svectors, const float *tvectors, const float *normals, const vec3_t relativelightorigin, float lightradius) +static void R_Shadow_VertexShadingWithXYZAttenuation(int numverts, const float *vertex3f, const float *normal3f, const float *lightcolor, const matrix4x4_t *m) { - int i; - float lightvec[3], iradius; - iradius = 0.5f / lightradius; - for (i = 0;i < numverts;i++, vertex += 4, svectors += 4, tvectors += 4, normals += 4, out2d += 4, out1d += 4) + float *color4f = varray_color4f; + float dist, dot, intensity, v[3], n[3]; + for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4) { - VectorSubtract(vertex, relativelightorigin, lightvec); - out2d[0] = 0.5f + DotProduct(svectors, lightvec) * iradius; - out2d[1] = 0.5f + DotProduct(tvectors, lightvec) * iradius; - out2d[2] = 0; - out1d[0] = 0.5f + DotProduct(normals, lightvec) * iradius; - out1d[1] = 0.5f; - out1d[2] = 0; + Matrix4x4_Transform(m, vertex3f, v); + if ((dist = DotProduct(v, v)) < 1) + { + Matrix4x4_Transform3x3(m, normal3f, n); + if ((dot = DotProduct(n, v)) > 0) + { + dist = sqrt(dist); + intensity = dot / sqrt(VectorLength2(v) * VectorLength2(n)); + intensity *= pow(1 - dist, r_shadow_attenpower) * r_shadow_attenscale; + VectorScale(lightcolor, intensity, color4f); + color4f[3] = 1; + } + else + { + VectorClear(color4f); + color4f[3] = 1; + } + } + else + { + VectorClear(color4f); + color4f[3] = 1; + } } } -void R_Shadow_GenTexCoords_Diffuse_Attenuation3D(float *out, int numverts, const float *vertex, const float *svectors, const float *tvectors, const float *normals, const vec3_t relativelightorigin, float lightradius) +static void R_Shadow_VertexShadingWithZAttenuation(int numverts, const float *vertex3f, const float *normal3f, const float *lightcolor, const matrix4x4_t *m) { - int i; - float lightvec[3], iradius; - iradius = 0.5f / lightradius; - for (i = 0;i < numverts;i++, vertex += 4, svectors += 4, tvectors += 4, normals += 4, out += 4) + float *color4f = varray_color4f; + float dist, dot, intensity, v[3], n[3]; + for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4) { - VectorSubtract(vertex, relativelightorigin, lightvec); - out[0] = 0.5f + DotProduct(svectors, lightvec) * iradius; - out[1] = 0.5f + DotProduct(tvectors, lightvec) * iradius; - out[2] = 0.5f + DotProduct(normals, lightvec) * iradius; + Matrix4x4_Transform(m, vertex3f, v); + if ((dist = fabs(v[2])) < 1) + { + Matrix4x4_Transform3x3(m, normal3f, n); + if ((dot = DotProduct(n, v)) > 0) + { + intensity = dot / sqrt(VectorLength2(v) * VectorLength2(n)); + intensity *= pow(1 - dist, r_shadow_attenpower) * r_shadow_attenscale; + VectorScale(lightcolor, intensity, color4f); + color4f[3] = 1; + } + else + { + VectorClear(color4f); + color4f[3] = 1; + } + } + else + { + VectorClear(color4f); + color4f[3] = 1; + } } } -void R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(float *out, int numverts, const float *vertex, const float *svectors, const float *tvectors, const float *normals, const vec3_t relativelightorigin) +static void R_Shadow_VertexShading(int numverts, const float *vertex3f, const float *normal3f, const float *lightcolor, const matrix4x4_t *m) { - int i; - float lightdir[3]; - for (i = 0;i < numverts;i++, vertex += 4, svectors += 4, tvectors += 4, normals += 4, out += 4) + float *color4f = varray_color4f; + float dot, intensity, v[3], n[3]; + for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4) { - VectorSubtract(vertex, relativelightorigin, lightdir); - // the cubemap normalizes this for us - out[0] = DotProduct(svectors, lightdir); - out[1] = DotProduct(tvectors, lightdir); - out[2] = DotProduct(normals, lightdir); + Matrix4x4_Transform(m, vertex3f, v); + Matrix4x4_Transform3x3(m, normal3f, n); + if ((dot = DotProduct(n, v)) > 0) + { + intensity = dot / sqrt(VectorLength2(v) * VectorLength2(n)); + VectorScale(lightcolor, intensity, color4f); + color4f[3] = 1; + } + else + { + VectorClear(color4f); + color4f[3] = 1; + } + } +} + +static void R_Shadow_VertexNoShadingWithXYZAttenuation(int numverts, const float *vertex3f, const float *lightcolor, const matrix4x4_t *m) +{ + float *color4f = varray_color4f; + float dist, intensity, v[3]; + for (;numverts > 0;numverts--, vertex3f += 3, color4f += 4) + { + Matrix4x4_Transform(m, vertex3f, v); + if ((dist = DotProduct(v, v)) < 1) + { + dist = sqrt(dist); + intensity = pow(1 - dist, r_shadow_attenpower) * r_shadow_attenscale; + VectorScale(lightcolor, intensity, color4f); + color4f[3] = 1; + } + else + { + VectorClear(color4f); + color4f[3] = 1; + } + } +} + +static void R_Shadow_VertexNoShadingWithZAttenuation(int numverts, const float *vertex3f, const float *lightcolor, const matrix4x4_t *m) +{ + float *color4f = varray_color4f; + float dist, intensity, v[3]; + for (;numverts > 0;numverts--, vertex3f += 3, color4f += 4) + { + Matrix4x4_Transform(m, vertex3f, v); + if ((dist = fabs(v[2])) < 1) + { + intensity = pow(1 - dist, r_shadow_attenpower) * r_shadow_attenscale; + VectorScale(lightcolor, intensity, color4f); + color4f[3] = 1; + } + else + { + VectorClear(color4f); + color4f[3] = 1; + } + } +} + +// TODO: use glTexGen instead of feeding vertices to texcoordpointer? +#define USETEXMATRIX + +#ifndef USETEXMATRIX +// this should be done in a texture matrix or vertex program when possible, but here's code to do it manually +// if hardware texcoord manipulation is not available (or not suitable, this would really benefit from 3DNow! or SSE +static void R_Shadow_Transform_Vertex3f_TexCoord3f(float *tc3f, int numverts, const float *vertex3f, const matrix4x4_t *matrix) +{ + do + { + tc3f[0] = vertex3f[0] * matrix->m[0][0] + vertex3f[1] * matrix->m[0][1] + vertex3f[2] * matrix->m[0][2] + matrix->m[0][3]; + tc3f[1] = vertex3f[0] * matrix->m[1][0] + vertex3f[1] * matrix->m[1][1] + vertex3f[2] * matrix->m[1][2] + matrix->m[1][3]; + tc3f[2] = vertex3f[0] * matrix->m[2][0] + vertex3f[1] * matrix->m[2][1] + vertex3f[2] * matrix->m[2][2] + matrix->m[2][3]; + vertex3f += 3; + tc3f += 3; + } + while (--numverts); +} + +static void R_Shadow_Transform_Vertex3f_TexCoord2f(float *tc2f, int numverts, const float *vertex3f, const matrix4x4_t *matrix) +{ + do + { + tc2f[0] = vertex3f[0] * matrix->m[0][0] + vertex3f[1] * matrix->m[0][1] + vertex3f[2] * matrix->m[0][2] + matrix->m[0][3]; + tc2f[1] = vertex3f[0] * matrix->m[1][0] + vertex3f[1] * matrix->m[1][1] + vertex3f[2] * matrix->m[1][2] + matrix->m[1][3]; + vertex3f += 3; + tc2f += 2; } + while (--numverts); } +#endif -void R_Shadow_GenTexCoords_Specular_Attenuation3D(float *out, int numverts, const float *vertex, const float *svectors, const float *tvectors, const float *normals, const vec3_t relativelightorigin, const vec3_t relativeeyeorigin, float lightradius) +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) { int i; - float lightdir[3], eyedir[3], halfdir[3], lightdirlen, iradius; - iradius = 0.5f / lightradius; - for (i = 0;i < numverts;i++, vertex += 4, svectors += 4, tvectors += 4, normals += 4, out += 4) + float lightdir[3]; + for (i = 0;i < numverts;i++, vertex3f += 3, svector3f += 3, tvector3f += 3, normal3f += 3, out3f += 3) { - VectorSubtract(vertex, relativelightorigin, lightdir); - // this is used later to make the attenuation correct - lightdirlen = sqrt(DotProduct(lightdir, lightdir)) * iradius; - VectorNormalizeFast(lightdir); - VectorSubtract(vertex, relativeeyeorigin, eyedir); - VectorNormalizeFast(eyedir); - VectorAdd(lightdir, eyedir, halfdir); - VectorNormalizeFast(halfdir); - out[0] = 0.5f + DotProduct(svectors, halfdir) * lightdirlen; - out[1] = 0.5f + DotProduct(tvectors, halfdir) * lightdirlen; - out[2] = 0.5f + DotProduct(normals, halfdir) * lightdirlen; + VectorSubtract(vertex3f, relativelightorigin, lightdir); + // the cubemap normalizes this for us + out3f[0] = DotProduct(svector3f, lightdir); + out3f[1] = DotProduct(tvector3f, lightdir); + out3f[2] = DotProduct(normal3f, lightdir); } } -void R_Shadow_GenTexCoords_Specular_NormalCubeMap(float *out, int numverts, const float *vertex, const float *svectors, const float *tvectors, const float *normals, const vec3_t relativelightorigin, const vec3_t relativeeyeorigin) +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) { int i; float lightdir[3], eyedir[3], halfdir[3]; - for (i = 0;i < numverts;i++, vertex += 4, svectors += 4, tvectors += 4, normals += 4, out += 4) + for (i = 0;i < numverts;i++, vertex3f += 3, svector3f += 3, tvector3f += 3, normal3f += 3, out3f += 3) { - VectorSubtract(vertex, relativelightorigin, lightdir); + VectorSubtract(vertex3f, relativelightorigin, lightdir); VectorNormalizeFast(lightdir); - VectorSubtract(vertex, relativeeyeorigin, eyedir); + VectorSubtract(vertex3f, relativeeyeorigin, eyedir); VectorNormalizeFast(eyedir); VectorAdd(lightdir, eyedir, halfdir); // the cubemap normalizes this for us - out[0] = DotProduct(svectors, halfdir); - out[1] = DotProduct(tvectors, halfdir); - out[2] = DotProduct(normals, halfdir); + out3f[0] = DotProduct(svector3f, halfdir); + out3f[1] = DotProduct(tvector3f, halfdir); + out3f[2] = DotProduct(normal3f, halfdir); } } -void R_Shadow_GenTexCoords_LightCubeMap(float *out, int numverts, const float *vertex, const vec3_t relativelightorigin) +void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements, const float *vertex3f, const float *svector3f, const float *tvector3f, const float *normal3f, const float *texcoord2f, const float *relativelightorigin, const float *relativeeyeorigin, const float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *basetexture, rtexture_t *bumptexture, rtexture_t *glosstexture, rtexture_t *lightcubemap, vec_t ambientscale, vec_t diffusescale, vec_t specularscale) { - int i; - // FIXME: this needs to be written - // this code assumes the vertices are in worldspace (a false assumption) - for (i = 0;i < numverts;i++, vertex += 4, out += 4) - VectorSubtract(vertex, relativelightorigin, out); -} - -void R_Shadow_DiffuseLighting(int numverts, int numtriangles, const int *elements, const float *svectors, const float *tvectors, const float *normals, const float *texcoords, const float *relativelightorigin, float lightradius, const float *lightcolor, rtexture_t *basetexture, rtexture_t *bumptexture, rtexture_t *lightcubemap) -{ - int renders, mult; - float scale, colorscale; + int renders; + float color[3], color2[3], colorscale; rmeshstate_t m; - memset(&m, 0, sizeof(m)); + // FIXME: support EF_NODEPTHTEST + GL_DepthMask(false); + GL_DepthTest(true); if (!bumptexture) - bumptexture = r_shadow_blankbumptexture; - // colorscale accounts for how much we multiply the brightness during combine - // mult is how many times the final pass of the lighting will be - // performed to get more brightness than otherwise possible - // limit mult to 64 for sanity sake - if (r_textureunits.integer >= 4) - { - // 4 texture no3D combine path, two pass + bumptexture = r_texture_blanknormalmap; + specularscale *= r_shadow_glossintensity.value; + if (!glosstexture) + { + if (r_shadow_gloss.integer >= 2) + { + glosstexture = r_texture_white; + specularscale *= r_shadow_gloss2intensity.value; + } + else + { + glosstexture = r_texture_black; + specularscale = 0; + } + } + if (r_shadow_gloss.integer < 1) + specularscale = 0; + if (!lightcubemap) + lightcubemap = r_shadow_blankwhitecubetexture; + if (ambientscale + diffusescale + specularscale < 0.01) + return; + if (r_shadow_glsl.integer && r_shadow_program_light[0]) + { + unsigned int perm, prog; + // GLSL shader path (GFFX5200, Radeon 9500) + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.pointer_texcoord[0] = texcoord2f; + m.pointer_texcoord3f[1] = svector3f; + m.pointer_texcoord3f[2] = tvector3f; + m.pointer_texcoord3f[3] = normal3f; m.tex[0] = R_GetTexture(bumptexture); - m.texcubemap[1] = R_GetTexture(r_shadow_normalscubetexture); - m.texcombinergb[0] = GL_REPLACE; - m.texcombinergb[1] = GL_DOT3_RGBA_ARB; - m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture); - m.tex[3] = R_GetTexture(r_shadow_attenuation2dtexture); - R_Mesh_TextureState(&m); - qglColorMask(0,0,0,1); - qglDisable(GL_BLEND); - GL_Color(1,1,1,1); - memcpy(varray_texcoord[0], texcoords, numverts * sizeof(float[4])); - R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord[1], numverts, varray_vertex, svectors, tvectors, normals, relativelightorigin); - R_Shadow_GenTexCoords_Attenuation2D1D(varray_texcoord[2], varray_texcoord[3], numverts, varray_vertex, svectors, tvectors, normals, relativelightorigin, lightradius); - R_Mesh_Draw(numverts, numtriangles, elements); - - m.tex[0] = R_GetTexture(basetexture); - m.texcubemap[1] = R_GetTexture(lightcubemap); - m.texcombinergb[0] = GL_MODULATE; - m.texcombinergb[1] = GL_MODULATE; - m.tex[2] = 0; - m.tex[3] = 0; - R_Mesh_TextureState(&m); - qglColorMask(1,1,1,1); - qglBlendFunc(GL_DST_ALPHA, GL_ONE); - qglEnable(GL_BLEND); - if (lightcubemap) - R_Shadow_GenTexCoords_LightCubeMap(varray_texcoord[1], numverts, varray_vertex, relativelightorigin); - - colorscale = r_colorscale * r_shadow_lightintensityscale.value; - for (mult = 1, scale = ixtable[mult];mult < 64 && (lightcolor[0] * scale * colorscale > 1 || lightcolor[1] * scale * colorscale > 1 || lightcolor[2] * scale * colorscale > 1);mult++, scale = ixtable[mult]); - colorscale *= scale; - GL_Color(lightcolor[0] * colorscale, lightcolor[1] * colorscale, lightcolor[2] * colorscale, 1); - for (renders = 0;renders < mult;renders++) - R_Mesh_Draw(numverts, numtriangles, elements); + m.tex[1] = R_GetTexture(basetexture); + m.tex[2] = R_GetTexture(glosstexture); + m.texcubemap[3] = R_GetTexture(lightcubemap); + // TODO: support fog (after renderer is converted to texture fog) + m.tex[4] = R_GetTexture(r_texture_white); + m.texmatrix[3] = *matrix_modeltolight; + R_Mesh_State(&m); + GL_BlendFunc(GL_ONE, GL_ONE); + GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 0); + CHECKGLERROR + perm = 0; + // only add a feature to the permutation if that permutation exists + // (otherwise it might end up not using a shader at all, which looks + // worse than using less features) + if (specularscale && r_shadow_program_light[perm | SHADERPERMUTATION_SPECULAR]) + perm |= SHADERPERMUTATION_SPECULAR; + //if (fog && r_shadow_program_light[perm | SHADERPERMUTATION_FOG]) + // perm |= SHADERPERMUTATION_FOG; + if (lightcubemap && r_shadow_program_light[perm | SHADERPERMUTATION_CUBEFILTER]) + perm |= SHADERPERMUTATION_CUBEFILTER; + if (r_shadow_glsl_offsetmapping.integer && r_shadow_program_light[perm | SHADERPERMUTATION_OFFSETMAPPING]) + perm |= SHADERPERMUTATION_OFFSETMAPPING; + prog = r_shadow_program_light[perm]; + qglUseProgramObjectARB(prog);CHECKGLERROR + // TODO: support fog (after renderer is converted to texture fog) + if (perm & SHADERPERMUTATION_FOG) + { + qglUniform1fARB(qglGetUniformLocationARB(prog, "FogRangeRecip"), 0);CHECKGLERROR + } + qglUniform1fARB(qglGetUniformLocationARB(prog, "AmbientScale"), ambientscale);CHECKGLERROR + qglUniform1fARB(qglGetUniformLocationARB(prog, "DiffuseScale"), diffusescale);CHECKGLERROR + if (perm & SHADERPERMUTATION_SPECULAR) + { + qglUniform1fARB(qglGetUniformLocationARB(prog, "SpecularPower"), 8);CHECKGLERROR + qglUniform1fARB(qglGetUniformLocationARB(prog, "SpecularScale"), specularscale);CHECKGLERROR + } + qglUniform3fARB(qglGetUniformLocationARB(prog, "LightColor"), lightcolor[0], lightcolor[1], lightcolor[2]);CHECKGLERROR + qglUniform3fARB(qglGetUniformLocationARB(prog, "LightPosition"), relativelightorigin[0], relativelightorigin[1], relativelightorigin[2]);CHECKGLERROR + if (perm & (SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_FOG | SHADERPERMUTATION_OFFSETMAPPING)) + { + qglUniform3fARB(qglGetUniformLocationARB(prog, "EyePosition"), relativeeyeorigin[0], relativeeyeorigin[1], relativeeyeorigin[2]);CHECKGLERROR + } + if (perm & SHADERPERMUTATION_OFFSETMAPPING) + { + qglUniform1fARB(qglGetUniformLocationARB(prog, "OffsetMapping_Scale"), r_shadow_glsl_offsetmapping_scale.value);CHECKGLERROR + qglUniform1fARB(qglGetUniformLocationARB(prog, "OffsetMapping_Bias"), r_shadow_glsl_offsetmapping_bias.value);CHECKGLERROR + } + CHECKGLERROR + GL_LockArrays(0, numverts); + R_Mesh_Draw(0, numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + GL_LockArrays(0, 0); + qglUseProgramObjectARB(0); + // HACK HACK HACK: work around for stupid NVIDIA bug that causes GL_OUT_OF_MEMORY and/or software rendering + qglBegin(GL_TRIANGLES); + qglEnd(); + CHECKGLERROR + } + else if (gl_dot3arb && gl_texturecubemap && gl_combine.integer && gl_stencil) + { + if (!bumptexture) + bumptexture = r_texture_blanknormalmap; + if (!glosstexture) + glosstexture = r_texture_white; + if (ambientscale) + { + GL_Color(1,1,1,1); + colorscale = ambientscale; + // colorscale accounts for how much we multiply the brightness + // during combine. + // + // mult is how many times the final pass of the lighting will be + // performed to get more brightness than otherwise possible. + // + // Limit mult to 64 for sanity sake. + if (r_shadow_texture3d.integer && lightcubemap && r_textureunits.integer >= 4) + { + // 3 3D combine path (Geforce3, Radeon 8500) + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[0] = vertex3f; + m.texmatrix[0] = *matrix_modeltoattenuationxyz; +#else + m.pointer_texcoord3f[0] = varray_texcoord3f[0]; + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[0], numverts, vertex3f, matrix_modeltoattenuationxyz); +#endif + m.tex[1] = R_GetTexture(basetexture); + m.pointer_texcoord[1] = texcoord2f; + m.texcubemap[2] = R_GetTexture(lightcubemap); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[2] = vertex3f; + m.texmatrix[2] = *matrix_modeltolight; +#else + m.pointer_texcoord3f[2] = varray_texcoord3f[2]; + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[2], numverts, vertex3f, matrix_modeltolight); +#endif + GL_BlendFunc(GL_ONE, GL_ONE); + } + else if (r_shadow_texture3d.integer && !lightcubemap && r_textureunits.integer >= 2) + { + // 2 3D combine path (Geforce3, original Radeon) + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[0] = vertex3f; + m.texmatrix[0] = *matrix_modeltoattenuationxyz; +#else + m.pointer_texcoord3f[0] = varray_texcoord3f[0]; + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[0], numverts, vertex3f, matrix_modeltoattenuationxyz); +#endif + m.tex[1] = R_GetTexture(basetexture); + m.pointer_texcoord[1] = texcoord2f; + GL_BlendFunc(GL_ONE, GL_ONE); + } + else if (r_textureunits.integer >= 4 && lightcubemap) + { + // 4 2D combine path (Geforce3, Radeon 8500) + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[0] = vertex3f; + m.texmatrix[0] = *matrix_modeltoattenuationxyz; +#else + m.pointer_texcoord[0] = varray_texcoord2f[0]; + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[0], numverts, vertex3f, matrix_modeltoattenuationxyz); +#endif + m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[1] = vertex3f; + m.texmatrix[1] = *matrix_modeltoattenuationz; +#else + m.pointer_texcoord[1] = varray_texcoord2f[1]; + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[1], numverts, vertex3f, matrix_modeltoattenuationz); +#endif + m.tex[2] = R_GetTexture(basetexture); + m.pointer_texcoord[2] = texcoord2f; + if (lightcubemap) + { + m.texcubemap[3] = R_GetTexture(lightcubemap); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[3] = vertex3f; + m.texmatrix[3] = *matrix_modeltolight; +#else + m.pointer_texcoord3f[3] = varray_texcoord3f[3]; + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[3], numverts, vertex3f, matrix_modeltolight); +#endif + } + GL_BlendFunc(GL_ONE, GL_ONE); + } + else if (r_textureunits.integer >= 3 && !lightcubemap) + { + // 3 2D combine path (Geforce3, original Radeon) + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[0] = vertex3f; + m.texmatrix[0] = *matrix_modeltoattenuationxyz; +#else + m.pointer_texcoord[0] = varray_texcoord2f[0]; + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[0], numverts, vertex3f, matrix_modeltoattenuationxyz); +#endif + m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[1] = vertex3f; + m.texmatrix[1] = *matrix_modeltoattenuationz; +#else + m.pointer_texcoord[1] = varray_texcoord2f[1]; + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[1], numverts, vertex3f, matrix_modeltoattenuationz); +#endif + m.tex[2] = R_GetTexture(basetexture); + m.pointer_texcoord[2] = texcoord2f; + GL_BlendFunc(GL_ONE, GL_ONE); + } + else + { + // 2/2/2 2D combine path (any dot3 card) + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[0] = vertex3f; + m.texmatrix[0] = *matrix_modeltoattenuationxyz; +#else + m.pointer_texcoord[0] = varray_texcoord2f[0]; + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[0], numverts, vertex3f, matrix_modeltoattenuationxyz); +#endif + m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[1] = vertex3f; + m.texmatrix[1] = *matrix_modeltoattenuationz; +#else + m.pointer_texcoord[1] = varray_texcoord2f[1]; + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[1], numverts, vertex3f, matrix_modeltoattenuationz); +#endif + R_Mesh_State(&m); + GL_ColorMask(0,0,0,1); + GL_BlendFunc(GL_ONE, GL_ZERO); + GL_LockArrays(0, numverts); + R_Mesh_Draw(0, numverts, numtriangles, elements); + GL_LockArrays(0, 0); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex[0] = R_GetTexture(basetexture); + m.pointer_texcoord[0] = texcoord2f; + if (lightcubemap) + { + m.texcubemap[1] = R_GetTexture(lightcubemap); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[1] = vertex3f; + m.texmatrix[1] = *matrix_modeltolight; +#else + m.pointer_texcoord3f[1] = varray_texcoord3f[1]; + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltolight); +#endif + } + 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(lightcolor, colorscale, color2); + GL_LockArrays(0, numverts); + 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(0, numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + } + GL_LockArrays(0, 0); + } + if (diffusescale) + { + GL_Color(1,1,1,1); + colorscale = diffusescale; + // colorscale accounts for how much we multiply the brightness + // during combine. + // + // mult is how many times the final pass of the lighting will be + // performed to get more brightness than otherwise possible. + // + // Limit mult to 64 for sanity sake. + 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 = vertex3f; + m.tex[0] = R_GetTexture(bumptexture); + m.texcombinergb[0] = GL_REPLACE; + m.pointer_texcoord[0] = texcoord2f; + m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture); + m.texcombinergb[1] = GL_DOT3_RGBA_ARB; + m.pointer_texcoord3f[1] = varray_texcoord3f[1]; + R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin); + m.tex3d[2] = R_GetTexture(r_shadow_attenuation3dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[2] = vertex3f; + m.texmatrix[2] = *matrix_modeltoattenuationxyz; +#else + m.pointer_texcoord3f[2] = varray_texcoord3f[2]; + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[2], numverts, vertex3f, matrix_modeltoattenuationxyz); +#endif + R_Mesh_State(&m); + GL_ColorMask(0,0,0,1); + GL_BlendFunc(GL_ONE, GL_ZERO); + GL_LockArrays(0, numverts); + R_Mesh_Draw(0, numverts, numtriangles, elements); + GL_LockArrays(0, 0); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex[0] = R_GetTexture(basetexture); + m.pointer_texcoord[0] = texcoord2f; + if (lightcubemap) + { + m.texcubemap[1] = R_GetTexture(lightcubemap); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[1] = vertex3f; + m.texmatrix[1] = *matrix_modeltolight; +#else + m.pointer_texcoord3f[1] = varray_texcoord3f[1]; + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltolight); +#endif + } + GL_BlendFunc(GL_DST_ALPHA, GL_ONE); + } + else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && lightcubemap) + { + // 1/2/2 3D combine path (original Radeon) + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[0] = vertex3f; + m.texmatrix[0] = *matrix_modeltoattenuationxyz; +#else + m.pointer_texcoord3f[0] = varray_texcoord3f[0]; + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[0], numverts, vertex3f, matrix_modeltoattenuationxyz); +#endif + R_Mesh_State(&m); + GL_ColorMask(0,0,0,1); + GL_BlendFunc(GL_ONE, GL_ZERO); + GL_LockArrays(0, numverts); + R_Mesh_Draw(0, numverts, numtriangles, elements); + GL_LockArrays(0, 0); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex[0] = R_GetTexture(bumptexture); + m.texcombinergb[0] = GL_REPLACE; + m.pointer_texcoord[0] = texcoord2f; + m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture); + m.texcombinergb[1] = GL_DOT3_RGBA_ARB; + m.pointer_texcoord3f[1] = varray_texcoord3f[1]; + R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin); + R_Mesh_State(&m); + GL_BlendFunc(GL_DST_ALPHA, GL_ZERO); + GL_LockArrays(0, numverts); + R_Mesh_Draw(0, numverts, numtriangles, elements); + GL_LockArrays(0, 0); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex[0] = R_GetTexture(basetexture); + m.pointer_texcoord[0] = texcoord2f; + if (lightcubemap) + { + m.texcubemap[1] = R_GetTexture(lightcubemap); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[1] = vertex3f; + m.texmatrix[1] = *matrix_modeltolight; +#else + m.pointer_texcoord3f[1] = varray_texcoord3f[1]; + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltolight); +#endif + } + GL_BlendFunc(GL_DST_ALPHA, GL_ONE); + } + else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && !lightcubemap) + { + // 2/2 3D combine path (original Radeon) + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex[0] = R_GetTexture(bumptexture); + m.texcombinergb[0] = GL_REPLACE; + m.pointer_texcoord[0] = texcoord2f; + m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture); + m.texcombinergb[1] = GL_DOT3_RGBA_ARB; + m.pointer_texcoord3f[1] = varray_texcoord3f[1]; + R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin); + R_Mesh_State(&m); + GL_ColorMask(0,0,0,1); + GL_BlendFunc(GL_ONE, GL_ZERO); + GL_LockArrays(0, numverts); + R_Mesh_Draw(0, numverts, numtriangles, elements); + GL_LockArrays(0, 0); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex[0] = R_GetTexture(basetexture); + m.pointer_texcoord[0] = texcoord2f; + m.tex3d[1] = R_GetTexture(r_shadow_attenuation3dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[1] = vertex3f; + m.texmatrix[1] = *matrix_modeltoattenuationxyz; +#else + m.pointer_texcoord3f[1] = varray_texcoord3f[1]; + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltoattenuationxyz); +#endif + 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 = vertex3f; + m.tex[0] = R_GetTexture(bumptexture); + m.texcombinergb[0] = GL_REPLACE; + m.pointer_texcoord[0] = texcoord2f; + m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture); + m.texcombinergb[1] = GL_DOT3_RGBA_ARB; + m.pointer_texcoord3f[1] = varray_texcoord3f[1]; + R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin); + m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[2] = vertex3f; + m.texmatrix[2] = *matrix_modeltoattenuationxyz; +#else + m.pointer_texcoord[2] = varray_texcoord2f[2]; + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[2], numverts, vertex3f, matrix_modeltoattenuationxyz); +#endif + m.tex[3] = R_GetTexture(r_shadow_attenuation2dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[3] = vertex3f; + m.texmatrix[3] = *matrix_modeltoattenuationz; +#else + m.pointer_texcoord[3] = varray_texcoord2f[3]; + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[3], numverts, vertex3f, matrix_modeltoattenuationz); +#endif + R_Mesh_State(&m); + GL_ColorMask(0,0,0,1); + GL_BlendFunc(GL_ONE, GL_ZERO); + GL_LockArrays(0, numverts); + R_Mesh_Draw(0, numverts, numtriangles, elements); + GL_LockArrays(0, 0); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex[0] = R_GetTexture(basetexture); + m.pointer_texcoord[0] = texcoord2f; + if (lightcubemap) + { + m.texcubemap[1] = R_GetTexture(lightcubemap); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[1] = vertex3f; + m.texmatrix[1] = *matrix_modeltolight; +#else + m.pointer_texcoord3f[1] = varray_texcoord3f[1]; + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltolight); +#endif + } + GL_BlendFunc(GL_DST_ALPHA, GL_ONE); + } + else + { + // 2/2/2 2D combine path (any dot3 card) + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[0] = vertex3f; + m.texmatrix[0] = *matrix_modeltoattenuationxyz; +#else + m.pointer_texcoord[0] = varray_texcoord2f[0]; + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[0], numverts, vertex3f, matrix_modeltoattenuationxyz); +#endif + m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[1] = vertex3f; + m.texmatrix[1] = *matrix_modeltoattenuationz; +#else + m.pointer_texcoord[1] = varray_texcoord2f[1]; + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[1], numverts, vertex3f, matrix_modeltoattenuationz); +#endif + R_Mesh_State(&m); + GL_ColorMask(0,0,0,1); + GL_BlendFunc(GL_ONE, GL_ZERO); + GL_LockArrays(0, numverts); + R_Mesh_Draw(0, numverts, numtriangles, elements); + GL_LockArrays(0, 0); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex[0] = R_GetTexture(bumptexture); + m.texcombinergb[0] = GL_REPLACE; + m.pointer_texcoord[0] = texcoord2f; + m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture); + m.texcombinergb[1] = GL_DOT3_RGBA_ARB; + m.pointer_texcoord3f[1] = varray_texcoord3f[1]; + R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin); + R_Mesh_State(&m); + GL_BlendFunc(GL_DST_ALPHA, GL_ZERO); + GL_LockArrays(0, numverts); + R_Mesh_Draw(0, numverts, numtriangles, elements); + GL_LockArrays(0, 0); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex[0] = R_GetTexture(basetexture); + m.pointer_texcoord[0] = texcoord2f; + if (lightcubemap) + { + m.texcubemap[1] = R_GetTexture(lightcubemap); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[1] = vertex3f; + m.texmatrix[1] = *matrix_modeltolight; +#else + m.pointer_texcoord3f[1] = varray_texcoord3f[1]; + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltolight); +#endif + } + 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(lightcolor, colorscale, color2); + GL_LockArrays(0, numverts); + 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(0, numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + } + GL_LockArrays(0, 0); + } + if (specularscale && glosstexture != r_texture_black) + { + // FIXME: detect blendsquare! + //if (gl_support_blendsquare) + { + colorscale = specularscale; + GL_Color(1,1,1,1); + if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && lightcubemap /*&& gl_support_blendsquare*/) // FIXME: detect blendsquare! + { + // 2/0/0/1/2 3D combine blendsquare path + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex[0] = R_GetTexture(bumptexture); + m.pointer_texcoord[0] = texcoord2f; + m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture); + m.texcombinergb[1] = GL_DOT3_RGBA_ARB; + m.pointer_texcoord3f[1] = varray_texcoord3f[1]; + R_Shadow_GenTexCoords_Specular_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin, relativeeyeorigin); + R_Mesh_State(&m); + GL_ColorMask(0,0,0,1); + // this squares the result + GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO); + GL_LockArrays(0, numverts); + R_Mesh_Draw(0, numverts, numtriangles, elements); + GL_LockArrays(0, 0); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + R_Mesh_State(&m); + GL_LockArrays(0, numverts); + // 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(0, numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + R_Mesh_Draw(0, numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + GL_LockArrays(0, 0); + + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[0] = vertex3f; + m.texmatrix[0] = *matrix_modeltoattenuationxyz; +#else + m.pointer_texcoord3f[0] = varray_texcoord3f[0]; + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[0], numverts, vertex3f, matrix_modeltoattenuationxyz); +#endif + R_Mesh_State(&m); + GL_BlendFunc(GL_DST_ALPHA, GL_ZERO); + GL_LockArrays(0, numverts); + R_Mesh_Draw(0, numverts, numtriangles, elements); + GL_LockArrays(0, 0); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex[0] = R_GetTexture(glosstexture); + m.pointer_texcoord[0] = texcoord2f; + if (lightcubemap) + { + m.texcubemap[1] = R_GetTexture(lightcubemap); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[1] = vertex3f; + m.texmatrix[1] = *matrix_modeltolight; +#else + m.pointer_texcoord3f[1] = varray_texcoord3f[1]; + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltolight); +#endif + } + GL_BlendFunc(GL_DST_ALPHA, GL_ONE); + } + else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && !lightcubemap /*&& gl_support_blendsquare*/) // FIXME: detect blendsquare! + { + // 2/0/0/2 3D combine blendsquare path + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex[0] = R_GetTexture(bumptexture); + m.pointer_texcoord[0] = texcoord2f; + m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture); + m.texcombinergb[1] = GL_DOT3_RGBA_ARB; + m.pointer_texcoord3f[1] = varray_texcoord3f[1]; + R_Shadow_GenTexCoords_Specular_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin, relativeeyeorigin); + R_Mesh_State(&m); + GL_ColorMask(0,0,0,1); + // this squares the result + GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO); + GL_LockArrays(0, numverts); + R_Mesh_Draw(0, numverts, numtriangles, elements); + GL_LockArrays(0, 0); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + R_Mesh_State(&m); + GL_LockArrays(0, numverts); + // 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(0, numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + R_Mesh_Draw(0, numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + GL_LockArrays(0, 0); + + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex[0] = R_GetTexture(glosstexture); + m.pointer_texcoord[0] = texcoord2f; + m.tex3d[1] = R_GetTexture(r_shadow_attenuation3dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[1] = vertex3f; + m.texmatrix[1] = *matrix_modeltoattenuationxyz; +#else + m.pointer_texcoord3f[1] = varray_texcoord3f[1]; + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltoattenuationxyz); +#endif + 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 = vertex3f; + m.tex[0] = R_GetTexture(bumptexture); + m.pointer_texcoord[0] = texcoord2f; + m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture); + m.texcombinergb[1] = GL_DOT3_RGBA_ARB; + m.pointer_texcoord3f[1] = varray_texcoord3f[1]; + R_Shadow_GenTexCoords_Specular_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin, relativeeyeorigin); + R_Mesh_State(&m); + GL_ColorMask(0,0,0,1); + // this squares the result + GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO); + GL_LockArrays(0, numverts); + R_Mesh_Draw(0, numverts, numtriangles, elements); + GL_LockArrays(0, 0); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + R_Mesh_State(&m); + GL_LockArrays(0, numverts); + // 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(0, numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + R_Mesh_Draw(0, numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + GL_LockArrays(0, 0); + + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[0] = vertex3f; + m.texmatrix[0] = *matrix_modeltoattenuationxyz; +#else + m.pointer_texcoord[0] = varray_texcoord2f[0]; + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[0], numverts, vertex3f, matrix_modeltoattenuationxyz); +#endif + m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[1] = vertex3f; + m.texmatrix[1] = *matrix_modeltoattenuationz; +#else + m.pointer_texcoord[1] = varray_texcoord2f[1]; + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[1], numverts, vertex3f, matrix_modeltoattenuationz); +#endif + R_Mesh_State(&m); + GL_BlendFunc(GL_DST_ALPHA, GL_ZERO); + GL_LockArrays(0, numverts); + R_Mesh_Draw(0, numverts, numtriangles, elements); + GL_LockArrays(0, 0); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex[0] = R_GetTexture(glosstexture); + m.pointer_texcoord[0] = texcoord2f; + if (lightcubemap) + { + m.texcubemap[1] = R_GetTexture(lightcubemap); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[1] = vertex3f; + m.texmatrix[1] = *matrix_modeltolight; +#else + m.pointer_texcoord3f[1] = varray_texcoord3f[1]; + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltolight); +#endif + } + 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(lightcolor, colorscale, color2); + GL_LockArrays(0, numverts); + 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(0, numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + } + GL_LockArrays(0, 0); + } + } } else { - // 2 texture no3D combine path, three pass - m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture); - m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture); - R_Mesh_TextureState(&m); - qglColorMask(0,0,0,1); - qglDisable(GL_BLEND); - GL_Color(1,1,1,1); - R_Shadow_GenTexCoords_Attenuation2D1D(varray_texcoord[0], varray_texcoord[1], numverts, varray_vertex, svectors, tvectors, normals, relativelightorigin, lightradius); - R_Mesh_Draw(numverts, numtriangles, elements); + if (ambientscale) + { + GL_BlendFunc(GL_ONE, GL_ONE); + VectorScale(lightcolor, ambientscale, color2); + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.tex[0] = R_GetTexture(basetexture); + m.pointer_texcoord[0] = texcoord2f; + if (r_textureunits.integer >= 2) + { + // voodoo2 + m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[1] = vertex3f; + m.texmatrix[1] = *matrix_modeltoattenuationxyz; +#else + m.pointer_texcoord[1] = varray_texcoord2f[1]; + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[1], numverts, vertex3f, matrix_modeltoattenuationxyz); +#endif + if (r_textureunits.integer >= 3) + { + // Geforce3/Radeon class but not using dot3 + m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[2] = vertex3f; + m.texmatrix[2] = *matrix_modeltoattenuationz; +#else + m.pointer_texcoord[2] = varray_texcoord2f[2]; + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[2], numverts, vertex3f, matrix_modeltoattenuationz); +#endif + } + } + if (r_textureunits.integer >= 3) + m.pointer_color = NULL; + else + m.pointer_color = varray_color4f; + R_Mesh_State(&m); + for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--) + { + color[0] = bound(0, color2[0], 1); + color[1] = bound(0, color2[1], 1); + color[2] = bound(0, color2[2], 1); + if (r_textureunits.integer >= 3) + GL_Color(color[0], color[1], color[2], 1); + else if (r_textureunits.integer >= 2) + R_Shadow_VertexNoShadingWithZAttenuation(numverts, vertex3f, color, matrix_modeltolight); + else + R_Shadow_VertexNoShadingWithXYZAttenuation(numverts, vertex3f, color, matrix_modeltolight); + GL_LockArrays(0, numverts); + R_Mesh_Draw(0, numverts, numtriangles, elements); + GL_LockArrays(0, 0); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + } + } + if (diffusescale) + { + GL_BlendFunc(GL_ONE, GL_ONE); + VectorScale(lightcolor, diffusescale, color2); + memset(&m, 0, sizeof(m)); + m.pointer_vertex = vertex3f; + m.pointer_color = varray_color4f; + m.tex[0] = R_GetTexture(basetexture); + m.pointer_texcoord[0] = texcoord2f; + if (r_textureunits.integer >= 2) + { + // voodoo2 + m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[1] = vertex3f; + m.texmatrix[1] = *matrix_modeltoattenuationxyz; +#else + m.pointer_texcoord[1] = varray_texcoord2f[1]; + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[1], numverts, vertex3f, matrix_modeltoattenuationxyz); +#endif + if (r_textureunits.integer >= 3) + { + // Geforce3/Radeon class but not using dot3 + m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture); +#ifdef USETEXMATRIX + m.pointer_texcoord3f[2] = vertex3f; + m.texmatrix[2] = *matrix_modeltoattenuationz; +#else + m.pointer_texcoord[2] = varray_texcoord2f[2]; + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[2], numverts, vertex3f, matrix_modeltoattenuationz); +#endif + } + } + R_Mesh_State(&m); + for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--) + { + color[0] = bound(0, color2[0], 1); + color[1] = bound(0, color2[1], 1); + color[2] = bound(0, color2[2], 1); + if (r_textureunits.integer >= 3) + R_Shadow_VertexShading(numverts, vertex3f, normal3f, color, matrix_modeltolight); + else if (r_textureunits.integer >= 2) + R_Shadow_VertexShadingWithZAttenuation(numverts, vertex3f, normal3f, color, matrix_modeltolight); + else + R_Shadow_VertexShadingWithXYZAttenuation(numverts, vertex3f, normal3f, color, matrix_modeltolight); + GL_LockArrays(0, numverts); + R_Mesh_Draw(0, numverts, numtriangles, elements); + GL_LockArrays(0, 0); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + } + } + } +} - m.tex[0] = R_GetTexture(bumptexture); - m.tex[1] = 0; - m.texcubemap[1] = R_GetTexture(r_shadow_normalscubetexture); - m.texcombinergb[0] = GL_REPLACE; - m.texcombinergb[1] = GL_DOT3_RGBA_ARB; - R_Mesh_TextureState(&m); - qglBlendFunc(GL_DST_ALPHA, GL_ZERO); - qglEnable(GL_BLEND); - memcpy(varray_texcoord[0], texcoords, numverts * sizeof(float[4])); - R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord[1], numverts, varray_vertex, svectors, tvectors, normals, relativelightorigin); - R_Mesh_Draw(numverts, numtriangles, elements); - - m.tex[0] = R_GetTexture(basetexture); - m.texcubemap[1] = R_GetTexture(lightcubemap); - m.texcombinergb[0] = GL_MODULATE; - m.texcombinergb[1] = GL_MODULATE; - R_Mesh_TextureState(&m); - qglColorMask(1,1,1,1); - qglBlendFunc(GL_DST_ALPHA, GL_ONE); - if (lightcubemap) - R_Shadow_GenTexCoords_LightCubeMap(varray_texcoord[1], numverts, varray_vertex, relativelightorigin); - - colorscale = r_colorscale * r_shadow_lightintensityscale.value; - for (mult = 1, scale = ixtable[mult];mult < 64 && (lightcolor[0] * scale * colorscale > 1 || lightcolor[1] * scale * colorscale > 1 || lightcolor[2] * scale * colorscale > 1);mult++, scale = ixtable[mult]); - colorscale *= scale; - GL_Color(lightcolor[0] * colorscale, lightcolor[1] * colorscale, lightcolor[2] * colorscale, 1); - for (renders = 0;renders < mult;renders++) - R_Mesh_Draw(numverts, numtriangles, elements); - } -} - -void R_Shadow_SpecularLighting(int numverts, int numtriangles, const int *elements, const float *svectors, const float *tvectors, const float *normals, const float *texcoords, const float *relativelightorigin, const float *relativeeyeorigin, float lightradius, const float *lightcolor, rtexture_t *glosstexture, rtexture_t *bumptexture, rtexture_t *lightcubemap) -{ - int renders, mult; - float scale, colorscale; - rmeshstate_t m; - memset(&m, 0, sizeof(m)); - if (!bumptexture) - bumptexture = r_shadow_blankbumptexture; - if (!glosstexture) - glosstexture = r_shadow_blankglosstexture; - if (r_shadow_gloss.integer >= 2 || (r_shadow_gloss.integer >= 1 && glosstexture != r_shadow_blankglosstexture)) +void R_RTLight_UpdateFromDLight(rtlight_t *rtlight, const dlight_t *light, int isstatic) +{ + int j, k; + float scale; + R_RTLight_Uncompile(rtlight); + memset(rtlight, 0, sizeof(*rtlight)); + + VectorCopy(light->origin, rtlight->shadoworigin); + VectorCopy(light->color, rtlight->color); + rtlight->radius = light->radius; + //rtlight->cullradius = rtlight->radius; + //rtlight->cullradius2 = rtlight->radius * rtlight->radius; + rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius; + rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius; + rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius; + 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; + Matrix4x4_Concat(&rtlight->matrix_worldtoattenuationxyz, &matrix_attenuationxyz, &rtlight->matrix_worldtolight); + Matrix4x4_Concat(&rtlight->matrix_worldtoattenuationz, &matrix_attenuationz, &rtlight->matrix_worldtolight); + + rtlight->lightmap_cullradius = bound(0, rtlight->radius, 2048.0f); + rtlight->lightmap_cullradius2 = rtlight->lightmap_cullradius * rtlight->lightmap_cullradius; + VectorScale(rtlight->color, rtlight->radius * (rtlight->style >= 0 ? d_lightstylevalue[rtlight->style] : 128) * 0.125f, rtlight->lightmap_light); + rtlight->lightmap_subtract = 1.0f / rtlight->lightmap_cullradius2; +} + +// compiles rtlight geometry +// (undone by R_FreeCompiledRTLight, which R_UpdateLight calls) +void R_RTLight_Compile(rtlight_t *rtlight) +{ + int shadowmeshes, shadowtris, lightmeshes, lighttris, numclusters, numsurfaces; + entity_render_t *ent = r_refdef.worldentity; + model_t *model = r_refdef.worldmodel; + + // compile the light + rtlight->compiled = true; + rtlight->static_numclusters = 0; + rtlight->static_numclusterpvsbytes = 0; + rtlight->static_clusterlist = NULL; + rtlight->static_clusterpvs = NULL; + rtlight->cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius; + rtlight->cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius; + rtlight->cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius; + rtlight->cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius; + rtlight->cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius; + rtlight->cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius; + + if (model && model->GetLightInfo) { - // 2 texture no3D combine path, five pass - memset(&m, 0, sizeof(m)); + // this variable directs the DrawShadowVolume and DrawLight code to capture into the mesh chain instead of rendering + r_shadow_compilingrtlight = rtlight; + R_Shadow_EnlargeClusterBuffer(model->brush.num_pvsclusters); + R_Shadow_EnlargeSurfaceBuffer(model->nummodelsurfaces); + model->GetLightInfo(ent, rtlight->shadoworigin, rtlight->radius, rtlight->cullmins, rtlight->cullmaxs, r_shadow_buffer_clusterlist, r_shadow_buffer_clusterpvs, &numclusters, r_shadow_buffer_surfacelist, r_shadow_buffer_surfacepvs, &numsurfaces); + rtlight->static_numclusterpvsbytes = (model->brush.num_pvsclusters + 7) >> 3; + rtlight->static_clusterpvs = Mem_Alloc(r_shadow_mempool, rtlight->static_numclusterpvsbytes); + if (numclusters) + { + rtlight->static_numclusters = numclusters; + rtlight->static_clusterlist = Mem_Alloc(r_shadow_mempool, rtlight->static_numclusters * sizeof(*rtlight->static_clusterlist)); + memcpy(rtlight->static_clusterlist, r_shadow_buffer_clusterlist, rtlight->static_numclusters * sizeof(*rtlight->static_clusterlist)); + memcpy(rtlight->static_clusterpvs, r_shadow_buffer_clusterpvs, rtlight->static_numclusterpvsbytes); + } + if (model->DrawShadowVolume && rtlight->shadow) + { + rtlight->static_meshchain_shadow = Mod_ShadowMesh_Begin(r_shadow_mempool, 32768, 32768, NULL, NULL, NULL, false, false, true); + model->DrawShadowVolume(ent, rtlight->shadoworigin, rtlight->radius, numsurfaces, r_shadow_buffer_surfacelist, rtlight->cullmins, rtlight->cullmaxs); + rtlight->static_meshchain_shadow = Mod_ShadowMesh_Finish(r_shadow_mempool, rtlight->static_meshchain_shadow, false, false); + } + if (model->DrawLight) + { + rtlight->static_meshchain_light = Mod_ShadowMesh_Begin(r_shadow_mempool, 32768, 32768, NULL, NULL, NULL, true, false, true); + model->DrawLight(ent, rtlight->shadoworigin, vec3_origin, rtlight->radius, vec3_origin, &r_identitymatrix, &r_identitymatrix, &r_identitymatrix, NULL, 0, 0, 0, numsurfaces, r_shadow_buffer_surfacelist); + rtlight->static_meshchain_light = Mod_ShadowMesh_Finish(r_shadow_mempool, rtlight->static_meshchain_light, true, false); + } + // switch back to rendering when DrawShadowVolume or DrawLight is called + r_shadow_compilingrtlight = NULL; + } - m.tex[0] = R_GetTexture(bumptexture); - m.texcubemap[1] = R_GetTexture(r_shadow_normalscubetexture); - m.texcombinergb[1] = GL_DOT3_RGBA_ARB; - R_Mesh_TextureState(&m); - qglColorMask(0,0,0,1); - qglDisable(GL_BLEND); - GL_Color(1,1,1,1); - memcpy(varray_texcoord[0], texcoords, numverts * sizeof(float[4])); - R_Shadow_GenTexCoords_Specular_NormalCubeMap(varray_texcoord[1], numverts, varray_vertex, svectors, tvectors, normals, relativelightorigin, relativeeyeorigin); - R_Mesh_Draw(numverts, numtriangles, elements); - - m.tex[0] = 0; - m.texcubemap[1] = 0; - m.texcombinergb[1] = GL_MODULATE; - R_Mesh_TextureState(&m); - // square alpha in framebuffer a few times to make it shiny - qglBlendFunc(GL_ZERO, GL_DST_ALPHA); - qglEnable(GL_BLEND); - // these comments are a test run through this math for intensity 0.5 - // 0.5 * 0.5 = 0.25 - R_Mesh_Draw(numverts, numtriangles, elements); - // 0.25 * 0.25 = 0.0625 - R_Mesh_Draw(numverts, numtriangles, elements); - // 0.0625 * 0.0625 = 0.00390625 - R_Mesh_Draw(numverts, numtriangles, elements); - - m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture); - m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture); - R_Mesh_TextureState(&m); - qglBlendFunc(GL_DST_ALPHA, GL_ZERO); - R_Shadow_GenTexCoords_Attenuation2D1D(varray_texcoord[0], varray_texcoord[1], numverts, varray_vertex, svectors, tvectors, normals, relativelightorigin, lightradius); - R_Mesh_Draw(numverts, numtriangles, elements); - - m.tex[0] = R_GetTexture(glosstexture); - m.texcubemap[1] = R_GetTexture(lightcubemap); - R_Mesh_TextureState(&m); - qglColorMask(1,1,1,1); - qglBlendFunc(GL_DST_ALPHA, GL_ONE); - memcpy(varray_texcoord[0], texcoords, numverts * sizeof(float[4])); - if (lightcubemap) - R_Shadow_GenTexCoords_LightCubeMap(varray_texcoord[1], numverts, varray_vertex, relativelightorigin); - - colorscale = r_colorscale * r_shadow_lightintensityscale.value; - for (mult = 1, scale = ixtable[mult];mult < 64 && (lightcolor[0] * scale * colorscale > 1 || lightcolor[1] * scale * colorscale > 1 || lightcolor[2] * scale * colorscale > 1);mult++, scale = ixtable[mult]); - colorscale *= scale; - GL_Color(lightcolor[0] * colorscale, lightcolor[1] * colorscale, lightcolor[2] * colorscale, 1); - for (renders = 0;renders < mult;renders++) - R_Mesh_Draw(numverts, numtriangles, elements); - } -} - -void R_Shadow_DrawWorldLightShadowVolume(matrix4x4_t *matrix, worldlight_t *light) -{ - R_Mesh_Matrix(matrix); - R_Shadow_RenderShadowMeshVolume(light->shadowvolume); + + // use smallest available cullradius - box radius or light radius + //rtlight->cullradius = RadiusFromBoundsAndOrigin(rtlight->cullmins, rtlight->cullmaxs, rtlight->shadoworigin); + //rtlight->cullradius = min(rtlight->cullradius, rtlight->radius); + + shadowmeshes = 0; + shadowtris = 0; + if (rtlight->static_meshchain_shadow) + { + shadowmesh_t *mesh; + for (mesh = rtlight->static_meshchain_shadow;mesh;mesh = mesh->next) + { + shadowmeshes++; + shadowtris += mesh->numtriangles; + } + } + + lightmeshes = 0; + lighttris = 0; + if (rtlight->static_meshchain_light) + { + shadowmesh_t *mesh; + for (mesh = rtlight->static_meshchain_light;mesh;mesh = mesh->next) + { + lightmeshes++; + lighttris += mesh->numtriangles; + } + } + + Con_DPrintf("static light built: %f %f %f : %f %f %f box, %i shadow volume triangles (in %i meshes), %i light 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, lighttris, lightmeshes); } -cvar_t r_editlights = {0, "r_editlights", "0"}; -cvar_t r_editlights_cursordistance = {0, "r_editlights_distance", "1024"}; -cvar_t r_editlights_cursorpushback = {0, "r_editlights_pushback", "0"}; -cvar_t r_editlights_cursorpushoff = {0, "r_editlights_pushoff", "4"}; -cvar_t r_editlights_cursorgrid = {0, "r_editlights_grid", "4"}; -cvar_t r_editlights_quakelightsizescale = {CVAR_SAVE, "r_editlights_quakelightsizescale", "0.8"}; -worldlight_t *r_shadow_worldlightchain; -worldlight_t *r_shadow_selectedlight; -vec3_t r_editlights_cursorlocation; +void R_RTLight_Uncompile(rtlight_t *rtlight) +{ + if (rtlight->compiled) + { + if (rtlight->static_meshchain_shadow) + Mod_ShadowMesh_Free(rtlight->static_meshchain_shadow); + rtlight->static_meshchain_shadow = NULL; + if (rtlight->static_meshchain_light) + Mod_ShadowMesh_Free(rtlight->static_meshchain_light); + rtlight->static_meshchain_light = NULL; + if (rtlight->static_clusterlist) + Mem_Free(rtlight->static_clusterlist); + rtlight->static_clusterlist = NULL; + if (rtlight->static_clusterpvs) + Mem_Free(rtlight->static_clusterpvs); + rtlight->static_clusterpvs = NULL; + rtlight->static_numclusters = 0; + rtlight->static_numclusterpvsbytes = 0; + rtlight->compiled = false; + } +} -static int castshadowcount = 1; -void R_Shadow_NewWorldLight(vec3_t origin, float radius, vec3_t color, int style, const char *cubemapname) +void R_Shadow_UncompileWorldLights(void) { - int i, j, k, l, maxverts, *mark, tris; - float *verts, *v, f, temp[3], radius2; - //float projectdistance, *v0, *v1, temp2[3], temp3[3]; - worldlight_t *e; - shadowmesh_t *mesh, *castmesh; - mleaf_t *leaf; - msurface_t *surf; - qbyte *pvs; - surfmesh_t *surfmesh; + dlight_t *light; + for (light = r_shadow_worldlightchain;light;light = light->next) + R_RTLight_Uncompile(&light->rtlight); +} - if (radius < 15 || DotProduct(color, color) < 0.03) - { - Con_Printf("R_Shadow_NewWorldLight: refusing to create a light too small/dim\n"); +void R_DrawRTLight(rtlight_t *rtlight, int visiblevolumes) +{ + int i, shadow, usestencil; + entity_render_t *ent; + float f; + vec3_t relativelightorigin, relativeeyeorigin, lightcolor, lightcolor2; + rtexture_t *cubemaptexture; + matrix4x4_t matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz; + int numclusters, numsurfaces; + int *clusterlist, *surfacelist; + qbyte *clusterpvs; + vec3_t cullmins, cullmaxs, relativelightmins, relativelightmaxs; + shadowmesh_t *mesh; + rmeshstate_t m; + + // skip lights that don't light (corona only lights) + if (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale < 0.01) + return; + + f = (rtlight->style >= 0 ? d_lightstylevalue[rtlight->style] : 128) * (1.0f / 256.0f) * r_shadow_lightintensityscale.value; + VectorScale(rtlight->color, f, lightcolor); + if (VectorLength2(lightcolor) < 0.01) return; + /* + if (rtlight->selected) + { + f = 2 + sin(realtime * M_PI * 4.0); + VectorScale(lightcolor, f, lightcolor); } + */ + + // loading is done before visibility checks because loading should happen + // all at once at the start of a level, not when it stalls gameplay. + // (especially important to benchmarks) + if (rtlight->isstatic && !rtlight->compiled && r_shadow_staticworldlights.integer) + R_RTLight_Compile(rtlight); + if (rtlight->cubemapname[0]) + cubemaptexture = R_Shadow_Cubemap(rtlight->cubemapname); + else + cubemaptexture = NULL; - e = Mem_Alloc(r_shadow_mempool, sizeof(worldlight_t)); - VectorCopy(origin, e->origin); - VectorCopy(color, e->light); - e->lightradius = radius; - VectorCopy(origin, e->mins); - VectorCopy(origin, e->maxs); - e->cullradius = 0; - e->style = style; - e->next = r_shadow_worldlightchain; - r_shadow_worldlightchain = e; - if (cubemapname) + cullmins[0] = rtlight->shadoworigin[0] - rtlight->radius; + cullmins[1] = rtlight->shadoworigin[1] - rtlight->radius; + cullmins[2] = rtlight->shadoworigin[2] - rtlight->radius; + cullmaxs[0] = rtlight->shadoworigin[0] + rtlight->radius; + cullmaxs[1] = rtlight->shadoworigin[1] + rtlight->radius; + cullmaxs[2] = rtlight->shadoworigin[2] + rtlight->radius; + if (rtlight->style >= 0 && d_lightstylevalue[rtlight->style] <= 0) + return; + numclusters = 0; + clusterlist = NULL; + clusterpvs = NULL; + numsurfaces = 0; + surfacelist = NULL; + if (rtlight->compiled && r_shadow_staticworldlights.integer) { - e->cubemapname = Mem_Alloc(r_shadow_mempool, strlen(cubemapname) + 1); - strcpy(e->cubemapname, cubemapname); - // FIXME: add cubemap loading (and don't load a cubemap twice) + // compiled light, world available and can receive realtime lighting + // retrieve cluster information + numclusters = rtlight->static_numclusters; + clusterlist = rtlight->static_clusterlist; + clusterpvs = rtlight->static_clusterpvs; + VectorCopy(rtlight->cullmins, cullmins); + VectorCopy(rtlight->cullmaxs, cullmaxs); } - if (cl.worldmodel) + else if (r_refdef.worldmodel && r_refdef.worldmodel->GetLightInfo) { - castshadowcount++; - leaf = Mod_PointInLeaf(origin, cl.worldmodel); - pvs = Mod_LeafPVS(leaf, cl.worldmodel); - for (i = 0, leaf = cl.worldmodel->leafs + 1;i < cl.worldmodel->numleafs;i++, leaf++) + // dynamic light, world available and can receive realtime lighting + // if the light box is offscreen, skip it right away + if (R_CullBox(cullmins, cullmaxs)) + return; + // calculate lit surfaces and clusters + R_Shadow_EnlargeClusterBuffer(r_refdef.worldmodel->brush.num_pvsclusters); + R_Shadow_EnlargeSurfaceBuffer(r_refdef.worldmodel->nummodelsurfaces); + r_refdef.worldmodel->GetLightInfo(&cl_entities[0].render, rtlight->shadoworigin, rtlight->radius, cullmins, cullmaxs, r_shadow_buffer_clusterlist, r_shadow_buffer_clusterpvs, &numclusters, r_shadow_buffer_surfacelist, r_shadow_buffer_surfacepvs, &numsurfaces); + clusterlist = r_shadow_buffer_clusterlist; + clusterpvs = r_shadow_buffer_clusterpvs; + surfacelist = r_shadow_buffer_surfacelist; + } + // if the reduced cluster bounds are offscreen, skip it + if (R_CullBox(cullmins, cullmaxs)) + return; + // check if light is illuminating any visible clusters + if (numclusters) + { + for (i = 0;i < numclusters;i++) + if (CHECKPVSBIT(r_pvsbits, clusterlist[i])) + break; + if (i == numclusters) + return; + } + // set up a scissor rectangle for this light + if (R_Shadow_ScissorForBBox(cullmins, cullmaxs)) + return; + + shadow = rtlight->shadow && (rtlight->isstatic ? r_rtworldshadows : r_rtdlightshadows); + usestencil = false; + + if (shadow && (gl_stencil || visiblevolumes)) + { + if (!visiblevolumes) + { + R_Shadow_Stage_ShadowVolumes(); + usestencil = true; + } + ent = &cl_entities[0].render; + if (r_shadow_staticworldlights.integer && rtlight->compiled) { - if (pvs[i >> 3] & (1 << (i & 7))) + memset(&m, 0, sizeof(m)); + R_Mesh_Matrix(&ent->matrix); + for (mesh = rtlight->static_meshchain_shadow;mesh;mesh = mesh->next) { - VectorCopy(origin, temp); - if (temp[0] < leaf->mins[0]) temp[0] = leaf->mins[0]; - if (temp[0] > leaf->maxs[0]) temp[0] = leaf->maxs[0]; - if (temp[1] < leaf->mins[1]) temp[1] = leaf->mins[1]; - if (temp[1] > leaf->maxs[1]) temp[1] = leaf->maxs[1]; - if (temp[2] < leaf->mins[2]) temp[2] = leaf->mins[2]; - if (temp[2] > leaf->maxs[2]) temp[2] = leaf->maxs[2]; - VectorSubtract(temp, origin, temp); - if (DotProduct(temp, temp) < e->lightradius * e->lightradius) + m.pointer_vertex = mesh->vertex3f; + R_Mesh_State(&m); + GL_LockArrays(0, mesh->numverts); + if (r_shadowstage == SHADOWSTAGE_STENCIL) { - leaf->worldnodeframe = castshadowcount; - for (j = 0, mark = leaf->firstmarksurface;j < leaf->nummarksurfaces;j++, mark++) - { - surf = cl.worldmodel->surfaces + *mark; - if (surf->castshadow != castshadowcount) - { - f = DotProduct(e->origin, surf->plane->normal) - surf->plane->dist; - if (surf->flags & SURF_PLANEBACK) - f = -f; - if (f > 0 && f < e->lightradius) - { - temp[0] = bound(surf->poly_mins[0], e->origin[0], surf->poly_maxs[0]) - e->origin[0]; - temp[1] = bound(surf->poly_mins[1], e->origin[1], surf->poly_maxs[1]) - e->origin[1]; - temp[2] = bound(surf->poly_mins[2], e->origin[2], surf->poly_maxs[2]) - e->origin[2]; - if (DotProduct(temp, temp) < e->lightradius * e->lightradius) - surf->castshadow = castshadowcount; - } - } - } + // increment stencil if backface is behind depthbuffer + qglCullFace(GL_BACK); // quake is backwards, this culls front faces + qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP); + R_Mesh_Draw(0, mesh->numverts, mesh->numtriangles, mesh->element3i); + c_rtcached_shadowmeshes++; + c_rtcached_shadowtris += mesh->numtriangles; + // decrement stencil if frontface is behind depthbuffer + qglCullFace(GL_FRONT); // quake is backwards, this culls back faces + qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP); } + R_Mesh_Draw(0, mesh->numverts, mesh->numtriangles, mesh->element3i); + c_rtcached_shadowmeshes++; + c_rtcached_shadowtris += mesh->numtriangles; + GL_LockArrays(0, 0); } } + else if (numsurfaces) + { + Matrix4x4_Transform(&ent->inversematrix, rtlight->shadoworigin, relativelightorigin); + ent->model->DrawShadowVolume(ent, relativelightorigin, rtlight->radius, numsurfaces, surfacelist, rtlight->cullmins, rtlight->cullmaxs); + } + if (r_drawentities.integer) + { + for (i = 0;i < r_refdef.numentities;i++) + { + ent = r_refdef.entities[i]; + // rough checks + if (r_shadow_cull.integer) + { + if (!BoxesOverlap(ent->mins, ent->maxs, cullmins, cullmaxs)) + continue; + if (r_refdef.worldmodel != NULL && r_refdef.worldmodel->brush.BoxTouchingPVS != NULL && !r_refdef.worldmodel->brush.BoxTouchingPVS(r_refdef.worldmodel, clusterpvs, ent->mins, ent->maxs)) + continue; + } + if (!(ent->flags & RENDER_SHADOW) || !ent->model || !ent->model->DrawShadowVolume) + continue; + Matrix4x4_Transform(&ent->inversematrix, rtlight->shadoworigin, relativelightorigin); + // light emitting entities should not cast their own shadow + if (VectorLength2(relativelightorigin) < 0.1) + continue; + relativelightmins[0] = relativelightorigin[0] - rtlight->radius; + relativelightmins[1] = relativelightorigin[1] - rtlight->radius; + relativelightmins[2] = relativelightorigin[2] - rtlight->radius; + relativelightmaxs[0] = relativelightorigin[0] + rtlight->radius; + relativelightmaxs[1] = relativelightorigin[1] + rtlight->radius; + relativelightmaxs[2] = relativelightorigin[2] + rtlight->radius; + ent->model->DrawShadowVolume(ent, relativelightorigin, rtlight->radius, ent->model->nummodelsurfaces, ent->model->surfacelist, relativelightmins, relativelightmaxs); + } + } + } - e->numleafs = 0; - for (i = 0, leaf = cl.worldmodel->leafs + 1;i < cl.worldmodel->numleafs;i++, leaf++) - if (leaf->worldnodeframe == castshadowcount) - e->numleafs++; - e->numsurfaces = 0; - for (i = 0, surf = cl.worldmodel->surfaces + cl.worldmodel->firstmodelsurface;i < cl.worldmodel->nummodelsurfaces;i++, surf++) - if (surf->castshadow == castshadowcount) - e->numsurfaces++; - - if (e->numleafs) - e->leafs = Mem_Alloc(r_shadow_mempool, e->numleafs * sizeof(mleaf_t *)); - if (e->numsurfaces) - e->surfaces = Mem_Alloc(r_shadow_mempool, e->numsurfaces * sizeof(msurface_t *)); - e->numleafs = 0; - for (i = 0, leaf = cl.worldmodel->leafs + 1;i < cl.worldmodel->numleafs;i++, leaf++) - if (leaf->worldnodeframe == castshadowcount) - e->leafs[e->numleafs++] = leaf; - e->numsurfaces = 0; - for (i = 0, surf = cl.worldmodel->surfaces + cl.worldmodel->firstmodelsurface;i < cl.worldmodel->nummodelsurfaces;i++, surf++) - if (surf->castshadow == castshadowcount) - e->surfaces[e->numsurfaces++] = surf; - // find bounding box and sphere of lit surfaces - // (these will be used for creating a shape to clip the light) - radius2 = 0; - VectorCopy(e->origin, e->mins); - VectorCopy(e->origin, e->maxs); - for (j = 0;j < e->numsurfaces;j++) - { - surf = e->surfaces[j]; - for (k = 0, v = surf->poly_verts;k < surf->poly_numverts;k++, v += 3) + if (!visiblevolumes) + { + R_Shadow_Stage_Light(usestencil); + + ent = &cl_entities[0].render; + if (ent->model && ent->model->DrawLight && (ent->flags & RENDER_LIGHT)) + { + lightcolor2[0] = lightcolor[0] * ent->colormod[0] * ent->alpha; + lightcolor2[1] = lightcolor[1] * ent->colormod[1] * ent->alpha; + lightcolor2[2] = lightcolor[2] * ent->colormod[2] * ent->alpha; + Matrix4x4_Transform(&ent->inversematrix, rtlight->shadoworigin, relativelightorigin); + Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, relativeeyeorigin); + Matrix4x4_Concat(&matrix_modeltolight, &rtlight->matrix_worldtolight, &ent->matrix); + Matrix4x4_Concat(&matrix_modeltoattenuationxyz, &rtlight->matrix_worldtoattenuationxyz, &ent->matrix); + Matrix4x4_Concat(&matrix_modeltoattenuationz, &rtlight->matrix_worldtoattenuationz, &ent->matrix); + if (r_shadow_staticworldlights.integer && rtlight->compiled) { - if (e->mins[0] > v[0]) e->mins[0] = v[0];if (e->maxs[0] < v[0]) e->maxs[0] = v[0]; - if (e->mins[1] > v[1]) e->mins[1] = v[1];if (e->maxs[1] < v[1]) e->maxs[1] = v[1]; - if (e->mins[2] > v[2]) e->mins[2] = v[2];if (e->maxs[2] < v[2]) e->maxs[2] = v[2]; - VectorSubtract(v, e->origin, temp); - f = DotProduct(temp, temp); - if (radius2 < f) - radius2 = f; + R_Mesh_Matrix(&ent->matrix); + for (mesh = rtlight->static_meshchain_light;mesh;mesh = mesh->next) + R_Shadow_RenderLighting(mesh->numverts, mesh->numtriangles, mesh->element3i, mesh->vertex3f, mesh->svector3f, mesh->tvector3f, mesh->normal3f, mesh->texcoord2f, relativelightorigin, relativeeyeorigin, lightcolor2, &matrix_modeltolight, &matrix_modeltoattenuationxyz, &matrix_modeltoattenuationz, mesh->map_diffuse, mesh->map_normal, mesh->map_specular, cubemaptexture, rtlight->ambientscale, rtlight->diffusescale, rtlight->specularscale); } + else + ent->model->DrawLight(ent, relativelightorigin, relativeeyeorigin, rtlight->radius, lightcolor2, &matrix_modeltolight, &matrix_modeltoattenuationxyz, &matrix_modeltoattenuationz, cubemaptexture, rtlight->ambientscale, rtlight->diffusescale, rtlight->specularscale, numsurfaces, surfacelist); } - e->cullradius = sqrt(radius2); - if (e->cullradius > e->lightradius) - e->cullradius = e->lightradius; - if (e->mins[0] < e->origin[0] - e->lightradius) e->mins[0] = e->origin[0] - e->lightradius; - if (e->maxs[0] > e->origin[0] + e->lightradius) e->maxs[0] = e->origin[0] + e->lightradius; - if (e->mins[1] < e->origin[1] - e->lightradius) e->mins[1] = e->origin[1] - e->lightradius; - if (e->maxs[1] > e->origin[1] + e->lightradius) e->maxs[1] = e->origin[1] + e->lightradius; - if (e->mins[2] < e->origin[2] - e->lightradius) e->mins[2] = e->origin[2] - e->lightradius; - if (e->maxs[2] > e->origin[2] + e->lightradius) e->maxs[2] = e->origin[2] + e->lightradius; - Con_Printf("%f %f %f, %f %f %f, %f, %f, %d, %d\n", e->mins[0], e->mins[1], e->mins[2], e->maxs[0], e->maxs[1], e->maxs[2], e->cullradius, e->lightradius, e->numleafs, e->numsurfaces); - // clip shadow volumes against eachother to remove unnecessary - // polygons (and sections of polygons) - maxverts = 256; - verts = NULL; - castshadowcount++; - for (j = 0;j < e->numsurfaces;j++) - { - surf = e->surfaces[j]; - if (surf->flags & SURF_SHADOWCAST) + if (r_drawentities.integer) + { + for (i = 0;i < r_refdef.numentities;i++) { - surf->castshadow = castshadowcount; - if (maxverts < surf->poly_numverts) - maxverts = surf->poly_numverts; + ent = r_refdef.entities[i]; + // can't draw transparent entity lighting here because + // transparent meshes are deferred for later + if (ent->visframe == r_framecount && BoxesOverlap(ent->mins, ent->maxs, cullmins, cullmaxs) && ent->model && ent->model->DrawLight && (ent->flags & (RENDER_LIGHT | RENDER_TRANSPARENT)) == RENDER_LIGHT) + { + lightcolor2[0] = lightcolor[0] * ent->colormod[0] * ent->alpha; + lightcolor2[1] = lightcolor[1] * ent->colormod[1] * ent->alpha; + lightcolor2[2] = lightcolor[2] * ent->colormod[2] * ent->alpha; + Matrix4x4_Transform(&ent->inversematrix, rtlight->shadoworigin, relativelightorigin); + Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, relativeeyeorigin); + Matrix4x4_Concat(&matrix_modeltolight, &rtlight->matrix_worldtolight, &ent->matrix); + Matrix4x4_Concat(&matrix_modeltoattenuationxyz, &rtlight->matrix_worldtoattenuationxyz, &ent->matrix); + Matrix4x4_Concat(&matrix_modeltoattenuationz, &rtlight->matrix_worldtoattenuationz, &ent->matrix); + ent->model->DrawLight(ent, relativelightorigin, relativeeyeorigin, rtlight->radius, lightcolor2, &matrix_modeltolight, &matrix_modeltoattenuationxyz, &matrix_modeltoattenuationz, cubemaptexture, rtlight->ambientscale, rtlight->diffusescale, rtlight->specularscale, ent->model->nummodelsurfaces, ent->model->surfacelist); + } } } - e->shadowvolume = Mod_ShadowMesh_Begin(r_shadow_mempool, 32768); - // make a mesh to cast a shadow volume from - castmesh = Mod_ShadowMesh_Begin(r_shadow_mempool, 32768); - for (j = 0;j < e->numsurfaces;j++) - if (e->surfaces[j]->castshadow == castshadowcount) - for (surfmesh = e->surfaces[j]->mesh;surfmesh;surfmesh = surfmesh->chain) - Mod_ShadowMesh_AddMesh(r_shadow_mempool, castmesh, surfmesh->numverts, surfmesh->verts, surfmesh->numtriangles, surfmesh->index); - castmesh = Mod_ShadowMesh_Finish(r_shadow_mempool, castmesh); + } +} - // cast shadow volume from castmesh - for (mesh = castmesh;mesh;mesh = mesh->next) - { - R_Shadow_ResizeTriangleFacingLight(castmesh->numtriangles); - R_Shadow_ResizeShadowElements(castmesh->numtriangles); +void R_ShadowVolumeLighting(int visiblevolumes) +{ + int lnum, flag; + dlight_t *light; + rmeshstate_t m; + + if (r_refdef.worldmodel && strncmp(r_refdef.worldmodel->name, r_shadow_mapname, sizeof(r_shadow_mapname))) + R_Shadow_EditLights_Reload_f(); + + if (visiblevolumes) + { + memset(&m, 0, sizeof(m)); + R_Mesh_State(&m); - if (maxverts < castmesh->numverts * 2) + GL_BlendFunc(GL_ONE, GL_ONE); + GL_DepthMask(false); + GL_DepthTest(r_shadow_visiblevolumes.integer < 2); + qglDisable(GL_CULL_FACE); + GL_Color(0.0, 0.0125, 0.1, 1); + } + else + R_Shadow_Stage_Begin(); + flag = r_rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE; + if (r_shadow_debuglight.integer >= 0) + { + for (lnum = 0, light = r_shadow_worldlightchain;light;lnum++, light = light->next) + if (lnum == r_shadow_debuglight.integer && (light->flags & flag)) + R_DrawRTLight(&light->rtlight, visiblevolumes); + } + else + for (lnum = 0, light = r_shadow_worldlightchain;light;lnum++, light = light->next) + if (light->flags & flag) + R_DrawRTLight(&light->rtlight, visiblevolumes); + if (r_rtdlight) + for (lnum = 0, light = r_dlight;lnum < r_numdlights;lnum++, light++) + R_DrawRTLight(&light->rtlight, visiblevolumes); + + if (visiblevolumes) + { + qglEnable(GL_CULL_FACE); + GL_Scissor(r_view_x, r_view_y, r_view_width, r_view_height); + } + else + R_Shadow_Stage_End(); +} + +//static char *suffix[6] = {"ft", "bk", "rt", "lf", "up", "dn"}; +typedef struct suffixinfo_s +{ + char *suffix; + qboolean flipx, flipy, flipdiagonal; +} +suffixinfo_t; +static suffixinfo_t suffix[3][6] = +{ + { + {"px", false, false, false}, + {"nx", false, false, false}, + {"py", false, false, false}, + {"ny", false, false, false}, + {"pz", false, false, false}, + {"nz", false, false, false} + }, + { + {"posx", false, false, false}, + {"negx", false, false, false}, + {"posy", false, false, false}, + {"negy", false, false, false}, + {"posz", false, false, false}, + {"negz", false, false, false} + }, + { + {"rt", true, false, true}, + {"lf", false, true, true}, + {"ft", true, true, false}, + {"bk", false, false, false}, + {"up", true, false, true}, + {"dn", true, false, true} + } +}; + +static int componentorder[4] = {0, 1, 2, 3}; + +rtexture_t *R_Shadow_LoadCubemap(const char *basename) +{ + int i, j, cubemapsize; + qbyte *cubemappixels, *image_rgba; + rtexture_t *cubemaptexture; + char name[256]; + // must start 0 so the first loadimagepixels has no requested width/height + cubemapsize = 0; + cubemappixels = NULL; + cubemaptexture = NULL; + // keep trying different suffix groups (posx, px, rt) until one loads + for (j = 0;j < 3 && !cubemappixels;j++) + { + // load the 6 images in the suffix group + for (i = 0;i < 6;i++) + { + // generate an image name based on the base and and suffix + dpsnprintf(name, sizeof(name), "%s%s", basename, suffix[j][i].suffix); + // load it + if ((image_rgba = loadimagepixels(name, false, cubemapsize, cubemapsize))) { - maxverts = castmesh->numverts * 2; - if (verts) - Mem_Free(verts); - verts = NULL; + // an image loaded, make sure width and height are equal + if (image_width == image_height) + { + // if this is the first image to load successfully, allocate the cubemap memory + if (!cubemappixels && image_width >= 1) + { + cubemapsize = image_width; + // note this clears to black, so unavailable sides are black + cubemappixels = Mem_Alloc(tempmempool, 6*cubemapsize*cubemapsize*4); + } + // copy the image with any flipping needed by the suffix (px and posx types don't need flipping) + if (cubemappixels) + Image_CopyMux(cubemappixels+i*cubemapsize*cubemapsize*4, image_rgba, cubemapsize, cubemapsize, suffix[j][i].flipx, suffix[j][i].flipy, suffix[j][i].flipdiagonal, 4, 4, componentorder); + } + else + Con_Printf("Cubemap image \"%s\" (%ix%i) is not square, OpenGL requires square cubemaps.\n", name, image_width, image_height); + // free the image + Mem_Free(image_rgba); } - if (verts == NULL && maxverts > 0) - verts = Mem_Alloc(r_shadow_mempool, maxverts * sizeof(float[4])); - - // now that we have the buffers big enough, construct shadow volume mesh - memcpy(verts, castmesh->verts, castmesh->numverts * sizeof(float[4])); - R_Shadow_ProjectVertices(verts, castmesh->numverts, e->origin, 1000000.0f);//, e->lightradius); - R_Shadow_MakeTriangleShadowFlags(castmesh->elements, verts, castmesh->numtriangles, trianglefacinglight, e->origin, e->lightradius); - tris = R_Shadow_BuildShadowVolumeTriangles(castmesh->elements, castmesh->neighbors, castmesh->numtriangles, castmesh->numverts, trianglefacinglight, shadowelements); - // add the constructed shadow volume mesh - Mod_ShadowMesh_AddMesh(r_shadow_mempool, e->shadowvolume, castmesh->numverts, verts, tris, shadowelements); } - // we're done with castmesh now - Mod_ShadowMesh_Free(castmesh); - e->shadowvolume = Mod_ShadowMesh_Finish(r_shadow_mempool, e->shadowvolume); - for (l = 0, mesh = e->shadowvolume;mesh;mesh = mesh->next) - l += mesh->numtriangles; - Con_Printf("static shadow volume built containing %i triangles\n", l); } + // if a cubemap loaded, upload it + if (cubemappixels) + { + if (!r_shadow_filters_texturepool) + r_shadow_filters_texturepool = R_AllocTexturePool(); + cubemaptexture = R_LoadTextureCubeMap(r_shadow_filters_texturepool, basename, cubemapsize, cubemappixels, TEXTYPE_RGBA, TEXF_PRECACHE, NULL); + Mem_Free(cubemappixels); + } + else + { + Con_Printf("Failed to load Cubemap \"%s\", tried ", basename); + for (j = 0;j < 3;j++) + for (i = 0;i < 6;i++) + Con_Printf("%s\"%s%s.tga\"", j + i > 0 ? ", " : "", basename, suffix[j][i].suffix); + Con_Print(" and was unable to find any of them.\n"); + } + return cubemaptexture; } -void R_Shadow_FreeWorldLight(worldlight_t *light) +rtexture_t *R_Shadow_Cubemap(const char *basename) { - worldlight_t **lightpointer; + int i; + for (i = 0;i < numcubemaps;i++) + if (!strcasecmp(cubemaps[i].basename, basename)) + return cubemaps[i].texture; + if (i >= MAX_CUBEMAPS) + return NULL; + numcubemaps++; + strcpy(cubemaps[i].basename, basename); + cubemaps[i].texture = R_Shadow_LoadCubemap(cubemaps[i].basename); + return cubemaps[i].texture; +} + +void R_Shadow_FreeCubemaps(void) +{ + numcubemaps = 0; + R_FreeTexturePool(&r_shadow_filters_texturepool); +} + +dlight_t *R_Shadow_NewWorldLight(void) +{ + dlight_t *light; + light = Mem_Alloc(r_shadow_mempool, sizeof(dlight_t)); + light->next = r_shadow_worldlightchain; + r_shadow_worldlightchain = light; + return light; +} + +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) +{ + VectorCopy(origin, light->origin); + light->angles[0] = angles[0] - 360 * floor(angles[0] / 360); + light->angles[1] = angles[1] - 360 * floor(angles[1] / 360); + light->angles[2] = angles[2] - 360 * floor(angles[2] / 360); + light->color[0] = max(color[0], 0); + light->color[1] = max(color[1], 0); + 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_UpdateFromDLight(&light->rtlight, light, true); +} + +void R_Shadow_FreeWorldLight(dlight_t *light) +{ + dlight_t **lightpointer; + R_RTLight_Uncompile(&light->rtlight); for (lightpointer = &r_shadow_worldlightchain;*lightpointer && *lightpointer != light;lightpointer = &(*lightpointer)->next); if (*lightpointer != light) Sys_Error("R_Shadow_FreeWorldLight: light not linked into chain\n"); *lightpointer = light->next; - if (light->cubemapname) - Mem_Free(light->cubemapname); - if (light->shadowvolume) - Mod_ShadowMesh_Free(light->shadowvolume); - if (light->surfaces) - Mem_Free(light->surfaces); - if (light->leafs) - Mem_Free(light->leafs); Mem_Free(light); } @@ -1160,9 +3053,10 @@ void R_Shadow_ClearWorldLights(void) while (r_shadow_worldlightchain) R_Shadow_FreeWorldLight(r_shadow_worldlightchain); r_shadow_selectedlight = NULL; + R_Shadow_FreeCubemaps(); } -void R_Shadow_SelectLight(worldlight_t *light) +void R_Shadow_SelectLight(dlight_t *light) { if (r_shadow_selectedlight) r_shadow_selectedlight->selected = false; @@ -1171,109 +3065,57 @@ void R_Shadow_SelectLight(worldlight_t *light) r_shadow_selectedlight->selected = true; } -void R_Shadow_FreeSelectedWorldLight(void) -{ - if (r_shadow_selectedlight) - { - R_Shadow_FreeWorldLight(r_shadow_selectedlight); - r_shadow_selectedlight = NULL; - } -} - -void R_DrawLightSprite(int texnum, const vec3_t origin, vec_t scale, float cr, float cg, float cb, float ca) -{ - rmeshstate_t m; - float diff[3]; - - if (fogenabled) - { - VectorSubtract(origin, r_origin, diff); - ca *= 1 - exp(fogdensity/DotProduct(diff,diff)); - } - - memset(&m, 0, sizeof(m)); - m.blendfunc1 = GL_SRC_ALPHA; - m.blendfunc2 = GL_ONE; - m.tex[0] = texnum; - R_Mesh_Matrix(&r_identitymatrix); - R_Mesh_State(&m); - - GL_Color(cr * r_colorscale, cg * r_colorscale, cb * r_colorscale, ca); - varray_texcoord[0][ 0] = 0;varray_texcoord[0][ 1] = 0; - varray_texcoord[0][ 4] = 0;varray_texcoord[0][ 5] = 1; - varray_texcoord[0][ 8] = 1;varray_texcoord[0][ 9] = 1; - varray_texcoord[0][12] = 1;varray_texcoord[0][13] = 0; - varray_vertex[0] = origin[0] - vright[0] * scale - vup[0] * scale; - varray_vertex[1] = origin[1] - vright[1] * scale - vup[1] * scale; - varray_vertex[2] = origin[2] - vright[2] * scale - vup[2] * scale; - varray_vertex[4] = origin[0] - vright[0] * scale + vup[0] * scale; - varray_vertex[5] = origin[1] - vright[1] * scale + vup[1] * scale; - varray_vertex[6] = origin[2] - vright[2] * scale + vup[2] * scale; - varray_vertex[8] = origin[0] + vright[0] * scale + vup[0] * scale; - varray_vertex[9] = origin[1] + vright[1] * scale + vup[1] * scale; - varray_vertex[10] = origin[2] + vright[2] * scale + vup[2] * scale; - varray_vertex[12] = origin[0] + vright[0] * scale - vup[0] * scale; - varray_vertex[13] = origin[1] + vright[1] * scale - vup[1] * scale; - varray_vertex[14] = origin[2] + vright[2] * scale - vup[2] * scale; - R_Mesh_Draw(4, 2, polygonelements); -} - void R_Shadow_DrawCursorCallback(const void *calldata1, int calldata2) { - cachepic_t *pic; - pic = Draw_CachePic("gfx/crosshair1.tga"); - if (pic) - R_DrawLightSprite(R_GetTexture(pic->tex), r_editlights_cursorlocation, r_editlights_cursorgrid.value * 0.5f, 1, 1, 1, 0.5); + float scale = r_editlights_cursorgrid.value * 0.5f; + R_DrawSprite(GL_SRC_ALPHA, GL_ONE, lighttextures[0], false, r_editlights_cursorlocation, r_viewright, r_viewup, scale, -scale, -scale, scale, 1, 1, 1, 0.5f); } void R_Shadow_DrawLightSpriteCallback(const void *calldata1, int calldata2) { float intensity; - const worldlight_t *light; + const dlight_t *light; light = calldata1; intensity = 0.5; if (light->selected) intensity = 0.75 + 0.25 * sin(realtime * M_PI * 4.0); - if (light->shadowvolume) - R_DrawLightSprite(calldata2, light->origin, 8, intensity, intensity, intensity, 0.5); - else - R_DrawLightSprite(calldata2, light->origin, 8, intensity * 0.5, intensity * 0.5, intensity * 0.5, 0.5); + if (!light->shadow) + intensity *= 0.5f; + R_DrawSprite(GL_SRC_ALPHA, GL_ONE, lighttextures[calldata2], false, light->origin, r_viewright, r_viewup, 8, -8, -8, 8, intensity, intensity, intensity, 0.5); } void R_Shadow_DrawLightSprites(void) { - int i, texnums[5]; + int i; cachepic_t *pic; - worldlight_t *light; + dlight_t *light; for (i = 0;i < 5;i++) { - pic = Draw_CachePic(va("gfx/crosshair%i.tga", i + 1)); - if (pic) - texnums[i] = R_GetTexture(pic->tex); - else - texnums[i] = 0; + lighttextures[i] = NULL; + if ((pic = Draw_CachePic(va("gfx/crosshair%i.tga", i + 1)))) + lighttextures[i] = pic->tex; } - for (light = r_shadow_worldlightchain;light;light = light->next) - R_MeshQueue_AddTransparent(light->origin, R_Shadow_DrawLightSpriteCallback, light, texnums[((int) light) % 5]); + for (i = 0, light = r_shadow_worldlightchain;light;i++, light = light->next) + R_MeshQueue_AddTransparent(light->origin, R_Shadow_DrawLightSpriteCallback, light, i % 5); R_MeshQueue_AddTransparent(r_editlights_cursorlocation, R_Shadow_DrawCursorCallback, NULL, 0); } void R_Shadow_SelectLightInView(void) { float bestrating, rating, temp[3]; - worldlight_t *best, *light; + dlight_t *best, *light; best = NULL; bestrating = 0; for (light = r_shadow_worldlightchain;light;light = light->next) { - VectorSubtract(light->origin, r_refdef.vieworg, temp); - rating = (DotProduct(temp, vpn) / sqrt(DotProduct(temp, temp))); + VectorSubtract(light->origin, r_vieworigin, temp); + rating = (DotProduct(temp, r_viewforward) / sqrt(DotProduct(temp, temp))); if (rating >= 0.95) { rating /= (1 + 0.0625f * sqrt(DotProduct(temp, temp))); - if (bestrating < rating && CL_TraceLine(light->origin, r_refdef.vieworg, NULL, NULL, 0, true, NULL) == 1.0f) + if (bestrating < rating && CL_TraceLine(light->origin, r_vieworigin, NULL, NULL, true, NULL, SUPERCONTENTS_SOLID) == 1.0f) { bestrating = rating; best = light; @@ -1285,12 +3127,17 @@ void R_Shadow_SelectLightInView(void) void R_Shadow_LoadWorldLights(void) { - int n, a, style; - char name[MAX_QPATH], cubemapname[MAX_QPATH], *lightsstring, *s, *t; - float origin[3], radius, color[3]; - COM_StripExtension(cl.worldmodel->name, name); - strcat(name, ".rtlights"); - lightsstring = COM_LoadFile(name, false); + int n, a, style, shadow, flags; + char tempchar, *lightsstring, *s, *t, name[MAX_QPATH], cubemapname[MAX_QPATH]; + float origin[3], radius, color[3], angles[3], corona, coronasizescale, ambientscale, diffusescale, specularscale; + if (r_refdef.worldmodel == NULL) + { + Con_Print("No map loaded.\n"); + return; + } + FS_StripExtension (r_refdef.worldmodel->name, name, sizeof (name)); + strlcat (name, ".rtlights", sizeof (name)); + lightsstring = FS_LoadFile(name, tempmempool, false); if (lightsstring) { s = lightsstring; @@ -1298,22 +3145,71 @@ void R_Shadow_LoadWorldLights(void) while (*s) { t = s; - while (*s && *s != '\n') + /* + shadow = true; + for (;COM_Parse(t, true) && strcmp( + if (COM_Parse(t, true)) + { + if (com_token[0] == '!') + { + shadow = false; + origin[0] = atof(com_token+1); + } + else + origin[0] = atof(com_token); + if (Com_Parse(t + } + */ + t = s; + while (*s && *s != '\n' && *s != '\r') s++; if (!*s) break; + tempchar = *s; + shadow = true; + // check for modifier flags + if (*t == '!') + { + shadow = false; + t++; + } *s = 0; - a = sscanf(t, "%f %f %f %f %f %f %f %d %s", &origin[0], &origin[1], &origin[2], &radius, &color[0], &color[1], &color[2], &style, &cubemapname); - if (a < 9) + a = sscanf(t, "%f %f %f %f %f %f %f %d %s %f %f %f %f %f %f %f %f %i", &origin[0], &origin[1], &origin[2], &radius, &color[0], &color[1], &color[2], &style, cubemapname, &corona, &angles[0], &angles[1], &angles[2], &coronasizescale, &ambientscale, &diffusescale, &specularscale, &flags); + *s = tempchar; + if (a < 18) + flags = LIGHTFLAG_REALTIMEMODE; + if (a < 17) + specularscale = 1; + if (a < 16) + diffusescale = 1; + if (a < 15) + ambientscale = 0; + if (a < 14) + coronasizescale = 0.25f; + if (a < 13) + VectorClear(angles); + if (a < 10) + corona = 0; + if (a < 9 || !strcmp(cubemapname, "\"\"")) cubemapname[0] = 0; - *s = '\n'; + // remove quotes on cubemapname + if (cubemapname[0] == '"' && cubemapname[strlen(cubemapname) - 1] == '"') + { + cubemapname[strlen(cubemapname)-1] = 0; + strcpy(cubemapname, cubemapname + 1); + } if (a < 8) { - Con_Printf("found %d parameters on line %i, should be 8 or 9 parameters (origin[0] origin[1] origin[2] radius color[0] color[1] color[2] style cubemapname)\n", a, n + 1); + Con_Printf("found %d parameters on line %i, should be 8 or more parameters (origin[0] origin[1] origin[2] radius color[0] color[1] color[2] style \"cubemapname\" corona angles[0] angles[1] angles[2] coronasizescale ambientscale diffusescale specularscale flags)\n", a, n + 1); break; } - R_Shadow_NewWorldLight(origin, radius, color, style, cubemapname); - s++; + VectorScale(color, r_editlights_rtlightscolorscale.value, color); + radius *= r_editlights_rtlightssizescale.value; + R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, angles, color, radius, corona, style, shadow, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags); + if (*s == '\r') + s++; + if (*s == '\n') + s++; n++; } if (*s) @@ -1324,21 +3220,31 @@ void R_Shadow_LoadWorldLights(void) void R_Shadow_SaveWorldLights(void) { - worldlight_t *light; + dlight_t *light; int bufchars, bufmaxchars; char *buf, *oldbuf; char name[MAX_QPATH]; char line[1024]; if (!r_shadow_worldlightchain) return; - COM_StripExtension(cl.worldmodel->name, name); - strcat(name, ".rtlights"); + if (r_refdef.worldmodel == NULL) + { + Con_Print("No map loaded.\n"); + return; + } + FS_StripExtension (r_refdef.worldmodel->name, name, sizeof (name)); + strlcat (name, ".rtlights", sizeof (name)); bufchars = bufmaxchars = 0; buf = NULL; for (light = r_shadow_worldlightchain;light;light = light->next) { - sprintf(line, "%g %g %g %g %g %g %g %d %s\n", light->origin[0], light->origin[1], light->origin[2], light->lightradius, light->light[0], light->light[1], light->light[2], light->style, light->cubemapname ? light->cubemapname : ""); - if (bufchars + strlen(line) > bufmaxchars) + if (light->coronasizescale != 0.25f || light->ambientscale != 0 || light->diffusescale != 1 || light->specularscale != 1 || light->flags != LIGHTFLAG_REALTIMEMODE) + sprintf(line, "%s%f %f %f %f %f %f %f %d \"%s\" %f %f %f %f %f %f %f %f %i\n", light->shadow ? "" : "!", light->origin[0], light->origin[1], light->origin[2], light->radius / r_editlights_rtlightssizescale.value, light->color[0] / r_editlights_rtlightscolorscale.value, light->color[1] / r_editlights_rtlightscolorscale.value, light->color[2] / r_editlights_rtlightscolorscale.value, light->style, light->cubemapname, light->corona, light->angles[0], light->angles[1], light->angles[2], light->coronasizescale, light->ambientscale, light->diffusescale, light->specularscale, light->flags); + else if (light->cubemapname[0] || light->corona || light->angles[0] || light->angles[1] || light->angles[2]) + sprintf(line, "%s%f %f %f %f %f %f %f %d \"%s\" %f %f %f %f\n", light->shadow ? "" : "!", light->origin[0], light->origin[1], light->origin[2], light->radius / r_editlights_rtlightssizescale.value, light->color[0] / r_editlights_rtlightscolorscale.value, light->color[1] / r_editlights_rtlightscolorscale.value, light->color[2] / r_editlights_rtlightscolorscale.value, light->style, light->cubemapname, light->corona, light->angles[0], light->angles[1], light->angles[2]); + else + sprintf(line, "%s%f %f %f %f %f %f %f %d\n", light->shadow ? "" : "!", light->origin[0], light->origin[1], light->origin[2], light->radius / r_editlights_rtlightssizescale.value, light->color[0] / r_editlights_rtlightscolorscale.value, light->color[1] / r_editlights_rtlightscolorscale.value, light->color[2] / r_editlights_rtlightscolorscale.value, light->style); + if (bufchars + (int) strlen(line) > bufmaxchars) { bufmaxchars = bufchars + strlen(line) + 2048; oldbuf = buf; @@ -1357,7 +3263,7 @@ void R_Shadow_SaveWorldLights(void) } } if (bufchars) - COM_WriteFile(name, buf, bufchars); + FS_WriteFile(name, buf, bufchars); if (buf) Mem_Free(buf); } @@ -1365,11 +3271,16 @@ void R_Shadow_SaveWorldLights(void) void R_Shadow_LoadLightsFile(void) { int n, a, style; - char name[MAX_QPATH], *lightsstring, *s, *t; + char tempchar, *lightsstring, *s, *t, name[MAX_QPATH]; float origin[3], radius, color[3], subtract, spotdir[3], spotcone, falloff, distbias; - COM_StripExtension(cl.worldmodel->name, name); - strcat(name, ".lights"); - lightsstring = COM_LoadFile(name, false); + if (r_refdef.worldmodel == NULL) + { + Con_Print("No map loaded.\n"); + return; + } + FS_StripExtension (r_refdef.worldmodel->name, name, sizeof (name)); + strlcat (name, ".lights", sizeof (name)); + lightsstring = FS_LoadFile(name, tempmempool, false); if (lightsstring) { s = lightsstring; @@ -1377,13 +3288,14 @@ void R_Shadow_LoadLightsFile(void) while (*s) { t = s; - while (*s && *s != '\n') + while (*s && *s != '\n' && *s != '\r') s++; if (!*s) break; + tempchar = *s; *s = 0; a = sscanf(t, "%f %f %f %f %f %f %f %f %f %f %f %f %f %d", &origin[0], &origin[1], &origin[2], &falloff, &color[0], &color[1], &color[2], &subtract, &spotdir[0], &spotdir[1], &spotdir[2], &spotcone, &distbias, &style); - *s = '\n'; + *s = tempchar; if (a < 14) { Con_Printf("invalid lights file, found %d parameters on line %i, should be 14 parameters (origin[0] origin[1] origin[2] falloff light[0] light[1] light[2] subtract spotdir[0] spotdir[1] spotdir[2] spotcone distancebias style)\n", a, n + 1); @@ -1391,9 +3303,12 @@ void R_Shadow_LoadLightsFile(void) } radius = sqrt(DotProduct(color, color) / (falloff * falloff * 8192.0f * 8192.0f)); radius = bound(15, radius, 4096); - VectorScale(color, (1.0f / (8388608.0f)), color); - R_Shadow_NewWorldLight(origin, radius, color, style, NULL); - s++; + VectorScale(color, (2.0f / (8388608.0f)), color); + R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, vec3_origin, color, radius, 0, style, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE); + if (*s == '\r') + s++; + if (*s == '\n') + s++; n++; } if (*s) @@ -1402,29 +3317,50 @@ void R_Shadow_LoadLightsFile(void) } } +// tyrlite/hmap2 light types in the delay field +typedef enum lighttype_e {LIGHTTYPE_MINUSX, LIGHTTYPE_RECIPX, LIGHTTYPE_RECIPXX, LIGHTTYPE_NONE, LIGHTTYPE_SUN, LIGHTTYPE_MINUSXX} lighttype_t; + void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void) { - int entnum, style, islight; - char key[256], value[1024]; - float origin[3], radius, color[3], light, scale, originhack[3], overridecolor[3]; + int entnum, style, islight, skin, pflags, effects, type, n; + char *entfiledata; const char *data; + float origin[3], angles[3], radius, color[3], light[4], fadescale, lightscale, originhack[3], overridecolor[3], vec[4]; + char key[256], value[1024]; - data = cl.worldmodel->entities; + if (r_refdef.worldmodel == NULL) + { + Con_Print("No map loaded.\n"); + return; + } + // try to load a .ent file first + FS_StripExtension (r_refdef.worldmodel->name, key, sizeof (key)); + strlcat (key, ".ent", sizeof (key)); + data = entfiledata = FS_LoadFile(key, tempmempool, true); + // and if that is not found, fall back to the bsp file entity string + if (!data) + data = r_refdef.worldmodel->brush.entities; if (!data) return; - for (entnum = 0;COM_ParseToken(&data) && com_token[0] == '{';entnum++) + for (entnum = 0;COM_ParseToken(&data, false) && com_token[0] == '{';entnum++) { - light = 0; + type = LIGHTTYPE_MINUSX; origin[0] = origin[1] = origin[2] = 0; originhack[0] = originhack[1] = originhack[2] = 0; + angles[0] = angles[1] = angles[2] = 0; color[0] = color[1] = color[2] = 1; + light[0] = light[1] = light[2] = 1;light[3] = 300; overridecolor[0] = overridecolor[1] = overridecolor[2] = 1; - scale = 1; + fadescale = 1; + lightscale = 1; style = 0; + skin = 0; + pflags = 0; + effects = 0; islight = false; while (1) { - if (!COM_ParseToken(&data)) + if (!COM_ParseToken(&data, false)) break; // error if (com_token[0] == '}') break; // end of entity @@ -1434,19 +3370,43 @@ void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void) strcpy(key, com_token); while (key[strlen(key)-1] == ' ') // remove trailing spaces key[strlen(key)-1] = 0; - if (!COM_ParseToken(&data)) + if (!COM_ParseToken(&data, false)) break; // error strcpy(value, com_token); // now that we have the key pair worked out... if (!strcmp("light", key)) - light = atof(value); + { + n = sscanf(value, "%f %f %f %f", &vec[0], &vec[1], &vec[2], &vec[3]); + if (n == 1) + { + // quake + light[0] = vec[0] * (1.0f / 256.0f); + light[1] = vec[0] * (1.0f / 256.0f); + light[2] = vec[0] * (1.0f / 256.0f); + light[3] = vec[0]; + } + else if (n == 4) + { + // halflife + light[0] = vec[0] * (1.0f / 255.0f); + light[1] = vec[1] * (1.0f / 255.0f); + light[2] = vec[2] * (1.0f / 255.0f); + light[3] = vec[3]; + } + } + else if (!strcmp("delay", key)) + type = atoi(value); else if (!strcmp("origin", key)) sscanf(value, "%f %f %f", &origin[0], &origin[1], &origin[2]); + else if (!strcmp("angle", key)) + angles[0] = 0, angles[1] = atof(value), angles[2] = 0; + else if (!strcmp("angles", key)) + sscanf(value, "%f %f %f", &angles[0], &angles[1], &angles[2]); else if (!strcmp("color", key)) sscanf(value, "%f %f %f", &color[0], &color[1], &color[2]); else if (!strcmp("wait", key)) - scale = atof(value); + fadescale = atof(value); else if (!strcmp("classname", key)) { if (!strncmp(value, "light", 5)) @@ -1485,8 +3445,8 @@ void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void) originhack[1] = 0; originhack[2] = 48; overridecolor[0] = 1; - overridecolor[1] = 0.7; - overridecolor[2] = 0.2; + overridecolor[1] = 0.5; + overridecolor[2] = 0.1; } if (!strcmp(value, "light_flame_small_yellow")) { @@ -1494,8 +3454,8 @@ void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void) originhack[1] = 0; originhack[2] = 40; overridecolor[0] = 1; - overridecolor[1] = 0.7; - overridecolor[2] = 0.2; + overridecolor[1] = 0.5; + overridecolor[2] = 0.1; } if (!strcmp(value, "light_torch_small_white")) { @@ -1503,8 +3463,8 @@ void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void) originhack[1] = 0; originhack[2] = 40; overridecolor[0] = 1; - overridecolor[1] = 0.9; - overridecolor[2] = 0.7; + overridecolor[1] = 0.5; + overridecolor[2] = 0.1; } if (!strcmp(value, "light_torch_small_walltorch")) { @@ -1512,25 +3472,69 @@ void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void) originhack[1] = 0; originhack[2] = 40; overridecolor[0] = 1; - overridecolor[1] = 0.7; - overridecolor[2] = 0.2; + overridecolor[1] = 0.5; + overridecolor[2] = 0.1; } } } else if (!strcmp("style", key)) style = atoi(value); + else if (r_refdef.worldmodel->type == mod_brushq3) + { + if (!strcmp("scale", key)) + lightscale = atof(value); + if (!strcmp("fade", key)) + fadescale = atof(value); + } + else if (!strcmp("skin", key)) + skin = (int)atof(value); + else if (!strcmp("pflags", key)) + pflags = (int)atof(value); + else if (!strcmp("effects", key)) + effects = (int)atof(value); + } + if (!islight) + continue; + if (lightscale <= 0) + lightscale = 1; + if (fadescale <= 0) + fadescale = 1; + if (color[0] == color[1] && color[0] == color[2]) + { + color[0] *= overridecolor[0]; + color[1] *= overridecolor[1]; + color[2] *= overridecolor[2]; + } + radius = light[3] * r_editlights_quakelightsizescale.value * lightscale / fadescale; + color[0] = color[0] * light[0]; + color[1] = color[1] * light[1]; + color[2] = color[2] * light[2]; + switch (type) + { + case LIGHTTYPE_MINUSX: + break; + case LIGHTTYPE_RECIPX: + radius *= 2; + VectorScale(color, (1.0f / 16.0f), color); + break; + case LIGHTTYPE_RECIPXX: + radius *= 2; + VectorScale(color, (1.0f / 16.0f), color); + break; + default: + case LIGHTTYPE_NONE: + break; + case LIGHTTYPE_SUN: + break; + case LIGHTTYPE_MINUSXX: + break; } - if (light <= 0 && islight) - light = 300; - radius = bound(15, light * r_editlights_quakelightsizescale.value / scale, 1048576); - light = sqrt(bound(0, light, 1048576)) * (1.0f / 16.0f); - if (color[0] == 1 && color[1] == 1 && color[2] == 1) - VectorCopy(overridecolor, color); - VectorScale(color, light, color); VectorAdd(origin, originhack, origin); - if (radius >= 15) - R_Shadow_NewWorldLight(origin, radius, color, style, NULL); + if (radius >= 1) + R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), origin, angles, color, radius, (pflags & PFLAGS_CORONA) != 0, style, (pflags & PFLAGS_NOSHADOW) == 0, skin >= 16 ? va("cubemaps/%i", skin) : NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE); } + if (entfiledata) + Mem_Free(entfiledata); } @@ -1538,8 +3542,8 @@ void R_Shadow_SetCursorLocationForView(void) { vec_t dist, push, frac; vec3_t dest, endpos, normal; - VectorMA(r_refdef.vieworg, r_editlights_cursordistance.value, vpn, dest); - frac = CL_TraceLine(r_refdef.vieworg, dest, endpos, normal, 0, true, NULL); + VectorMA(r_vieworigin, r_editlights_cursordistance.value, r_viewforward, dest); + frac = CL_TraceLine(r_vieworigin, dest, endpos, normal, true, NULL, SUPERCONTENTS_SOLID); if (frac < 1) { dist = frac * r_editlights_cursordistance.value; @@ -1547,7 +3551,7 @@ void R_Shadow_SetCursorLocationForView(void) if (push > dist) push = dist; push = -push; - VectorMA(endpos, push, vpn, endpos); + VectorMA(endpos, push, r_viewforward, endpos); VectorMA(endpos, r_editlights_cursorpushoff.value, normal, endpos); } r_editlights_cursorlocation[0] = floor(endpos[0] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value; @@ -1555,18 +3559,6 @@ void R_Shadow_SetCursorLocationForView(void) r_editlights_cursorlocation[2] = floor(endpos[2] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value; } -void R_Shadow_UpdateLightingMode(void) -{ - r_shadow_lightingmode = 0; - if (r_shadow_realtime.integer) - { - if (r_shadow_worldlightchain) - r_shadow_lightingmode = 2; - else - r_shadow_lightingmode = 1; - } -} - void R_Shadow_UpdateWorldLightSelection(void) { if (r_editlights.integer) @@ -1586,13 +3578,24 @@ void R_Shadow_EditLights_Clear_f(void) void R_Shadow_EditLights_Reload_f(void) { - r_shadow_reloadlights = true; + if (!r_refdef.worldmodel) + return; + strlcpy(r_shadow_mapname, r_refdef.worldmodel->name, sizeof(r_shadow_mapname)); + R_Shadow_ClearWorldLights(); + R_Shadow_LoadWorldLights(); + if (r_shadow_worldlightchain == NULL) + { + R_Shadow_LoadLightsFile(); + if (r_shadow_worldlightchain == NULL) + R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(); + } } void R_Shadow_EditLights_Save_f(void) { - if (cl.worldmodel) - R_Shadow_SaveWorldLights(); + if (!r_refdef.worldmodel) + return; + R_Shadow_SaveWorldLights(); } void R_Shadow_EditLights_ImportLightEntitiesFromMap_f(void) @@ -1609,124 +3612,499 @@ void R_Shadow_EditLights_ImportLightsFile_f(void) void R_Shadow_EditLights_Spawn_f(void) { - vec3_t origin, color; - vec_t radius; - int style; - const char *cubemapname; + vec3_t color; if (!r_editlights.integer) { - Con_Printf("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n"); + Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n"); return; } - if (Cmd_Argc() <= 7) + if (Cmd_Argc() != 1) { - radius = 200; - color[0] = color[1] = color[2] = 1; - style = 0; - cubemapname = NULL; - if (Cmd_Argc() >= 2) - { - radius = atof(Cmd_Argv(1)); - if (Cmd_Argc() >= 3) - { - color[0] = atof(Cmd_Argv(2)); - color[1] = color[0]; - color[2] = color[0]; - if (Cmd_Argc() >= 5) - { - color[1] = atof(Cmd_Argv(3)); - color[2] = atof(Cmd_Argv(4)); - if (Cmd_Argc() >= 6) - { - style = atoi(Cmd_Argv(5)); - if (Cmd_Argc() >= 7) - cubemapname = Cmd_Argv(6); - } - } - } - } - if (cubemapname && !cubemapname[0]) - cubemapname = NULL; - if (radius >= 16 && color[0] >= 0 && color[1] >= 0 && color[2] >= 0 && style >= 0 && style < 256 && (color[0] >= 0.1 || color[1] >= 0.1 || color[2] >= 0.1)) - { - VectorCopy(r_editlights_cursorlocation, origin); - R_Shadow_NewWorldLight(origin, radius, color, style, cubemapname); - return; - } + Con_Print("r_editlights_spawn does not take parameters\n"); + return; } - Con_Printf("usage: r_editlights_spawn radius red green blue [style [cubemap]]\n"); + color[0] = color[1] = color[2] = 1; + R_Shadow_UpdateWorldLight(R_Shadow_NewWorldLight(), r_editlights_cursorlocation, vec3_origin, color, 200, 0, 0, true, NULL, 0.25, 0, 1, 1, LIGHTFLAG_REALTIMEMODE); } void R_Shadow_EditLights_Edit_f(void) { - vec3_t origin, color; - vec_t radius; - int style; - const char *cubemapname; + vec3_t origin, angles, color; + vec_t radius, corona, coronasizescale, ambientscale, diffusescale, specularscale; + int style, shadows, flags, normalmode, realtimemode; + char cubemapname[1024]; if (!r_editlights.integer) { - Con_Printf("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n"); + Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n"); return; } if (!r_shadow_selectedlight) { - Con_Printf("No selected light.\n"); + Con_Print("No selected light.\n"); return; } - if (Cmd_Argc() <= 7) + VectorCopy(r_shadow_selectedlight->origin, origin); + VectorCopy(r_shadow_selectedlight->angles, angles); + VectorCopy(r_shadow_selectedlight->color, color); + radius = r_shadow_selectedlight->radius; + style = r_shadow_selectedlight->style; + if (r_shadow_selectedlight->cubemapname) + strcpy(cubemapname, r_shadow_selectedlight->cubemapname); + else + cubemapname[0] = 0; + shadows = r_shadow_selectedlight->shadow; + corona = r_shadow_selectedlight->corona; + coronasizescale = r_shadow_selectedlight->coronasizescale; + ambientscale = r_shadow_selectedlight->ambientscale; + diffusescale = r_shadow_selectedlight->diffusescale; + specularscale = r_shadow_selectedlight->specularscale; + flags = r_shadow_selectedlight->flags; + normalmode = (flags & LIGHTFLAG_NORMALMODE) != 0; + realtimemode = (flags & LIGHTFLAG_REALTIMEMODE) != 0; + if (!strcmp(Cmd_Argv(1), "origin")) { - radius = 200; - color[0] = color[1] = color[2] = 1; - style = 0; - cubemapname = NULL; - if (Cmd_Argc() >= 2) + if (Cmd_Argc() != 5) { - radius = atof(Cmd_Argv(1)); - if (Cmd_Argc() >= 3) - { - color[0] = atof(Cmd_Argv(2)); - color[1] = color[0]; - color[2] = color[0]; - if (Cmd_Argc() >= 5) - { - color[1] = atof(Cmd_Argv(3)); - color[2] = atof(Cmd_Argv(4)); - if (Cmd_Argc() >= 6) - { - style = atoi(Cmd_Argv(5)); - if (Cmd_Argc() >= 7) - cubemapname = Cmd_Argv(6); - } - } - } + Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1)); + return; + } + origin[0] = atof(Cmd_Argv(2)); + origin[1] = atof(Cmd_Argv(3)); + origin[2] = atof(Cmd_Argv(4)); + } + else if (!strcmp(Cmd_Argv(1), "originx")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1)); + return; + } + origin[0] = atof(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "originy")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1)); + return; + } + origin[1] = atof(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "originz")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1)); + return; + } + origin[2] = atof(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "move")) + { + if (Cmd_Argc() != 5) + { + Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1)); + return; + } + origin[0] += atof(Cmd_Argv(2)); + origin[1] += atof(Cmd_Argv(3)); + origin[2] += atof(Cmd_Argv(4)); + } + else if (!strcmp(Cmd_Argv(1), "movex")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1)); + return; + } + origin[0] += atof(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "movey")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1)); + return; + } + origin[1] += atof(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "movez")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1)); + return; + } + origin[2] += atof(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "angles")) + { + if (Cmd_Argc() != 5) + { + Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(1)); + return; + } + angles[0] = atof(Cmd_Argv(2)); + angles[1] = atof(Cmd_Argv(3)); + angles[2] = atof(Cmd_Argv(4)); + } + else if (!strcmp(Cmd_Argv(1), "anglesx")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1)); + return; + } + angles[0] = atof(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "anglesy")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1)); + return; + } + angles[1] = atof(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "anglesz")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1)); + return; + } + angles[2] = atof(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "color")) + { + if (Cmd_Argc() != 5) + { + Con_Printf("usage: r_editlights_edit %s red green blue\n", Cmd_Argv(1)); + return; + } + color[0] = atof(Cmd_Argv(2)); + color[1] = atof(Cmd_Argv(3)); + color[2] = atof(Cmd_Argv(4)); + } + else if (!strcmp(Cmd_Argv(1), "radius")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1)); + return; + } + radius = atof(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "style")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1)); + return; + } + style = atoi(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "cubemap")) + { + if (Cmd_Argc() > 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1)); + return; + } + if (Cmd_Argc() == 3) + strcpy(cubemapname, Cmd_Argv(2)); + else + cubemapname[0] = 0; + } + else if (!strcmp(Cmd_Argv(1), "shadows")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1)); + return; + } + shadows = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "corona")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1)); + return; + } + corona = atof(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "coronasize")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1)); + return; + } + coronasizescale = atof(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "ambient")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1)); + return; + } + ambientscale = atof(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "diffuse")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1)); + return; + } + diffusescale = atof(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "specular")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1)); + return; + } + specularscale = atof(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "normalmode")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1)); + return; } - if (cubemapname && !cubemapname[0]) - cubemapname = NULL; - if (radius >= 16 && color[0] >= 0 && color[1] >= 0 && color[2] >= 0 && style >= 0 && style < 256 && (color[0] >= 0.1 || color[1] >= 0.1 || color[2] >= 0.1)) + normalmode = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "realtimemode")) + { + if (Cmd_Argc() != 3) { - VectorCopy(r_shadow_selectedlight->origin, origin); - R_Shadow_FreeWorldLight(r_shadow_selectedlight); - r_shadow_selectedlight = NULL; - R_Shadow_NewWorldLight(origin, radius, color, style, cubemapname); + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(1)); return; } + realtimemode = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2)); + } + else + { + Con_Print("usage: r_editlights_edit [property] [value]\n"); + Con_Print("Selected light's properties:\n"); + Con_Printf("Origin : %f %f %f\n", r_shadow_selectedlight->origin[0], r_shadow_selectedlight->origin[1], r_shadow_selectedlight->origin[2]); + Con_Printf("Angles : %f %f %f\n", r_shadow_selectedlight->angles[0], r_shadow_selectedlight->angles[1], r_shadow_selectedlight->angles[2]); + Con_Printf("Color : %f %f %f\n", r_shadow_selectedlight->color[0], r_shadow_selectedlight->color[1], r_shadow_selectedlight->color[2]); + Con_Printf("Radius : %f\n", r_shadow_selectedlight->radius); + Con_Printf("Corona : %f\n", r_shadow_selectedlight->corona); + Con_Printf("Style : %i\n", r_shadow_selectedlight->style); + Con_Printf("Shadows : %s\n", r_shadow_selectedlight->shadow ? "yes" : "no"); + Con_Printf("Cubemap : %s\n", r_shadow_selectedlight->cubemapname); + Con_Printf("CoronaSize : %f\n", r_shadow_selectedlight->coronasizescale); + Con_Printf("Ambient : %f\n", r_shadow_selectedlight->ambientscale); + Con_Printf("Diffuse : %f\n", r_shadow_selectedlight->diffusescale); + Con_Printf("Specular : %f\n", r_shadow_selectedlight->specularscale); + Con_Printf("NormalMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_NORMALMODE) ? "yes" : "no"); + Con_Printf("RealTimeMode : %s\n", (r_shadow_selectedlight->flags & LIGHTFLAG_REALTIMEMODE) ? "yes" : "no"); + return; + } + flags = (normalmode ? LIGHTFLAG_NORMALMODE : 0) | (realtimemode ? LIGHTFLAG_REALTIMEMODE : 0); + R_Shadow_UpdateWorldLight(r_shadow_selectedlight, origin, angles, color, radius, corona, style, shadows, cubemapname, coronasizescale, ambientscale, diffusescale, specularscale, flags); +} + +void R_Shadow_EditLights_EditAll_f(void) +{ + dlight_t *light; + + if (!r_editlights.integer) + { + Con_Print("Cannot edit lights when not in editing mode. Set r_editlights to 1.\n"); + return; + } + + for (light = r_shadow_worldlightchain;light;light = light->next) + { + R_Shadow_SelectLight(light); + R_Shadow_EditLights_Edit_f(); + } +} + +void R_Shadow_EditLights_DrawSelectedLightProperties(void) +{ + int lightnumber, lightcount; + dlight_t *light; + float x, y; + char temp[256]; + if (!r_editlights.integer) + return; + x = 0; + y = con_vislines; + lightnumber = -1; + lightcount = 0; + 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; + 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; +} + +void R_Shadow_EditLights_ToggleShadow_f(void) +{ + if (!r_editlights.integer) + { + Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n"); + return; + } + if (!r_shadow_selectedlight) + { + Con_Print("No selected light.\n"); + return; + } + R_Shadow_UpdateWorldLight(r_shadow_selectedlight, r_shadow_selectedlight->origin, r_shadow_selectedlight->angles, r_shadow_selectedlight->color, r_shadow_selectedlight->radius, r_shadow_selectedlight->corona, r_shadow_selectedlight->style, !r_shadow_selectedlight->shadow, r_shadow_selectedlight->cubemapname, r_shadow_selectedlight->coronasizescale, r_shadow_selectedlight->ambientscale, r_shadow_selectedlight->diffusescale, r_shadow_selectedlight->specularscale, r_shadow_selectedlight->flags); +} + +void R_Shadow_EditLights_ToggleCorona_f(void) +{ + if (!r_editlights.integer) + { + Con_Print("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n"); + return; } - Con_Printf("usage: r_editlights_edit radius red green blue [style [cubemap]]\n"); + if (!r_shadow_selectedlight) + { + Con_Print("No selected light.\n"); + return; + } + R_Shadow_UpdateWorldLight(r_shadow_selectedlight, r_shadow_selectedlight->origin, r_shadow_selectedlight->angles, r_shadow_selectedlight->color, r_shadow_selectedlight->radius, !r_shadow_selectedlight->corona, r_shadow_selectedlight->style, r_shadow_selectedlight->shadow, r_shadow_selectedlight->cubemapname, r_shadow_selectedlight->coronasizescale, r_shadow_selectedlight->ambientscale, r_shadow_selectedlight->diffusescale, r_shadow_selectedlight->specularscale, r_shadow_selectedlight->flags); } void R_Shadow_EditLights_Remove_f(void) { if (!r_editlights.integer) { - Con_Printf("Cannot remove light when not in editing mode. Set r_editlights to 1.\n"); + Con_Print("Cannot remove light when not in editing mode. Set r_editlights to 1.\n"); + return; + } + if (!r_shadow_selectedlight) + { + Con_Print("No selected light.\n"); + return; + } + R_Shadow_FreeWorldLight(r_shadow_selectedlight); + r_shadow_selectedlight = NULL; +} + +void R_Shadow_EditLights_Help_f(void) +{ + Con_Print( +"Documentation on r_editlights system:\n" +"Settings:\n" +"r_editlights : enable/disable editing mode\n" +"r_editlights_cursordistance : maximum distance of cursor from eye\n" +"r_editlights_cursorpushback : push back cursor this far from surface\n" +"r_editlights_cursorpushoff : push cursor off surface this far\n" +"r_editlights_cursorgrid : snap cursor to grid of this size\n" +"r_editlights_quakelightsizescale : imported quake light entity size scaling\n" +"r_editlights_rtlightssizescale : imported rtlight size scaling\n" +"r_editlights_rtlightscolorscale : imported rtlight color scaling\n" +"Commands:\n" +"r_editlights_help : this help\n" +"r_editlights_clear : remove all lights\n" +"r_editlights_reload : reload .rtlights, .lights file, or entities\n" +"r_editlights_save : save to .rtlights file\n" +"r_editlights_spawn : create a light with default settings\n" +"r_editlights_edit command : edit selected light - more documentation below\n" +"r_editlights_remove : remove selected light\n" +"r_editlights_toggleshadow : toggles on/off selected light's shadow property\n" +"r_editlights_importlightentitiesfrommap : reload light entities\n" +"r_editlights_importlightsfile : reload .light file (produced by hlight)\n" +"Edit commands:\n" +"origin x y z : set light location\n" +"originx x: set x component of light location\n" +"originy y: set y component of light location\n" +"originz z: set z component of light location\n" +"move x y z : adjust light location\n" +"movex x: adjust x component of light location\n" +"movey y: adjust y component of light location\n" +"movez z: adjust z component of light location\n" +"angles x y z : set light angles\n" +"anglesx x: set x component of light angles\n" +"anglesy y: set y component of light angles\n" +"anglesz z: set z component of light angles\n" +"color r g b : set color of light (can be brighter than 1 1 1)\n" +"radius radius : set radius (size) of light\n" +"style style : set lightstyle of light (flickering patterns, switches, etc)\n" +"cubemap basename : set filter cubemap of light (not yet supported)\n" +"shadows 1/0 : turn on/off shadows\n" +"corona n : set corona intensity\n" +"coronasize n : set corona size (0-1)\n" +"ambient n : set ambient intensity (0-1)\n" +"diffuse n : set diffuse intensity (0-1)\n" +"specular n : set specular intensity (0-1)\n" +"normalmode 1/0 : turn on/off rendering of this light in rtworld 0 mode\n" +"realtimemode 1/0 : turn on/off rendering of this light in rtworld 1 mode\n" +" : print light properties to console\n" + ); +} + +void R_Shadow_EditLights_CopyInfo_f(void) +{ + if (!r_editlights.integer) + { + Con_Print("Cannot copy light info when not in editing mode. Set r_editlights to 1.\n"); + return; + } + if (!r_shadow_selectedlight) + { + Con_Print("No selected light.\n"); + return; + } + VectorCopy(r_shadow_selectedlight->angles, r_shadow_bufferlight.angles); + VectorCopy(r_shadow_selectedlight->color, r_shadow_bufferlight.color); + 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); + else + r_shadow_bufferlight.cubemapname[0] = 0; + r_shadow_bufferlight.shadow = r_shadow_selectedlight->shadow; + r_shadow_bufferlight.corona = r_shadow_selectedlight->corona; + r_shadow_bufferlight.coronasizescale = r_shadow_selectedlight->coronasizescale; + r_shadow_bufferlight.ambientscale = r_shadow_selectedlight->ambientscale; + r_shadow_bufferlight.diffusescale = r_shadow_selectedlight->diffusescale; + r_shadow_bufferlight.specularscale = r_shadow_selectedlight->specularscale; + r_shadow_bufferlight.flags = r_shadow_selectedlight->flags; +} + +void R_Shadow_EditLights_PasteInfo_f(void) +{ + if (!r_editlights.integer) + { + Con_Print("Cannot paste light info when not in editing mode. Set r_editlights to 1.\n"); return; } if (!r_shadow_selectedlight) { - Con_Printf("No selected light.\n"); + Con_Print("No selected light.\n"); return; } - R_Shadow_FreeSelectedWorldLight(); + R_Shadow_UpdateWorldLight(r_shadow_selectedlight, r_shadow_selectedlight->origin, r_shadow_bufferlight.angles, r_shadow_bufferlight.color, r_shadow_bufferlight.radius, r_shadow_bufferlight.corona, r_shadow_bufferlight.style, r_shadow_bufferlight.shadow, r_shadow_bufferlight.cubemapname, r_shadow_bufferlight.coronasizescale, r_shadow_bufferlight.ambientscale, r_shadow_bufferlight.diffusescale, r_shadow_bufferlight.specularscale, r_shadow_bufferlight.flags); } void R_Shadow_EditLights_Init(void) @@ -1737,12 +4115,21 @@ void R_Shadow_EditLights_Init(void) Cvar_RegisterVariable(&r_editlights_cursorpushoff); Cvar_RegisterVariable(&r_editlights_cursorgrid); Cvar_RegisterVariable(&r_editlights_quakelightsizescale); + Cvar_RegisterVariable(&r_editlights_rtlightssizescale); + Cvar_RegisterVariable(&r_editlights_rtlightscolorscale); + Cmd_AddCommand("r_editlights_help", R_Shadow_EditLights_Help_f); Cmd_AddCommand("r_editlights_clear", R_Shadow_EditLights_Clear_f); Cmd_AddCommand("r_editlights_reload", R_Shadow_EditLights_Reload_f); Cmd_AddCommand("r_editlights_save", R_Shadow_EditLights_Save_f); Cmd_AddCommand("r_editlights_spawn", R_Shadow_EditLights_Spawn_f); Cmd_AddCommand("r_editlights_edit", R_Shadow_EditLights_Edit_f); + Cmd_AddCommand("r_editlights_editall", R_Shadow_EditLights_EditAll_f); Cmd_AddCommand("r_editlights_remove", R_Shadow_EditLights_Remove_f); + Cmd_AddCommand("r_editlights_toggleshadow", R_Shadow_EditLights_ToggleShadow_f); + Cmd_AddCommand("r_editlights_togglecorona", R_Shadow_EditLights_ToggleCorona_f); Cmd_AddCommand("r_editlights_importlightentitiesfrommap", R_Shadow_EditLights_ImportLightEntitiesFromMap_f); Cmd_AddCommand("r_editlights_importlightsfile", R_Shadow_EditLights_ImportLightsFile_f); + Cmd_AddCommand("r_editlights_copyinfo", R_Shadow_EditLights_CopyInfo_f); + Cmd_AddCommand("r_editlights_pasteinfo", R_Shadow_EditLights_PasteInfo_f); } +