X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=r_shadow.c;h=f5cbf9fa2b90655b3b7f25eacb23a50c7afbabdc;hp=0b1ec40795b3a775b0e6c45482ce4122a3cc3d46;hb=e40a37e7e99114e259dffe2e36416f0c238a6b40;hpb=3b8b31726da557e99a3019ce561482d175ae2f5a diff --git a/r_shadow.c b/r_shadow.c index 0b1ec407..f5cbf9fa 100644 --- a/r_shadow.c +++ b/r_shadow.c @@ -125,7 +125,6 @@ extern void R_Shadow_EditLights_Init(void); #define SHADOWSTAGE_STENCILTWOSIDE 3 int r_shadowstage = SHADOWSTAGE_NONE; -int r_shadow_reloadlights = false; mempool_t *r_shadow_mempool; @@ -155,9 +154,10 @@ rtexturepool_t *r_shadow_texturepool; rtexture_t *r_shadow_normalcubetexture; rtexture_t *r_shadow_attenuation2dtexture; rtexture_t *r_shadow_attenuation3dtexture; -rtexture_t *r_shadow_blankbumptexture; -rtexture_t *r_shadow_blankglosstexture; -rtexture_t *r_shadow_blankwhitetexture; +rtexture_t *r_shadow_blankwhitecubetexture; + +// lights are reloaded when this changes +char r_shadow_mapname[MAX_QPATH]; // used only for light filters (cubemaps) rtexturepool_t *r_shadow_filters_texturepool; @@ -166,43 +166,235 @@ 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 = {0, "r_shadow_gloss", "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_polygonfactor = {0, "r_shadow_polygonfactor", "0"}; -cvar_t r_shadow_polygonoffset = {0, "r_shadow_polygonoffset", "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 = {0, "r_shadow_realtime_dlight", "1"}; -cvar_t r_shadow_realtime_dlight_shadows = {0, "r_shadow_realtime_dlight_shadows", "0"}; -cvar_t r_shadow_realtime_world = {0, "r_shadow_realtime_world", "0"}; -cvar_t r_shadow_realtime_world_dlightshadows = {0, "r_shadow_realtime_world_dlightshadows", "1"}; -cvar_t r_shadow_realtime_world_lightmaps = {0, "r_shadow_realtime_world_lightmaps", "0"}; -cvar_t r_shadow_realtime_world_shadows = {0, "r_shadow_realtime_world_shadows", "1"}; +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_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; -int c_rt_lights, c_rt_clears, c_rt_scissored; -int c_rt_shadowmeshes, c_rt_shadowtris, c_rt_lightmeshes, c_rt_lighttris; -int c_rtcached_shadowmeshes, c_rtcached_shadowtris; +#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"); + numcubemaps = 0; + r_shadow_normalcubetexture = NULL; + r_shadow_attenuation2dtexture = NULL; + r_shadow_attenuation3dtexture = NULL; + r_shadow_blankwhitecubetexture = NULL; + r_shadow_texturepool = NULL; + r_shadow_filters_texturepool = NULL; + R_Shadow_ValidateCvars(); + R_Shadow_MakeTextures(); maxshadowelements = 0; shadowelements = NULL; maxvertexupdate = 0; @@ -220,54 +412,131 @@ void r_shadow_start(void) r_shadow_buffer_numsurfacepvsbytes = 0; r_shadow_buffer_surfacepvs = NULL; r_shadow_buffer_surfacelist = NULL; - r_shadow_normalcubetexture = NULL; - r_shadow_attenuation2dtexture = NULL; - r_shadow_attenuation3dtexture = NULL; - r_shadow_blankbumptexture = NULL; - r_shadow_blankglosstexture = NULL; - r_shadow_blankwhitetexture = NULL; - r_shadow_texturepool = NULL; - r_shadow_filters_texturepool = NULL; - R_Shadow_ClearWorldLights(); - r_shadow_reloadlights = true; + 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; + 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_attenuation3dtexture = NULL; - r_shadow_blankbumptexture = NULL; - r_shadow_blankglosstexture = NULL; - r_shadow_blankwhitetexture = 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; 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; - Mem_FreePool(&r_shadow_mempool); } void r_shadow_newmap(void) { - R_Shadow_ClearWorldLights(); - r_shadow_reloadlights = true; } void R_Shadow_Help_f(void) @@ -284,8 +553,6 @@ void R_Shadow_Help_f(void) "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_polygonfactor : nudge shadow volumes closer/further\n" -"r_shadow_polygonoffset : nudge shadow volumes closer/further\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" @@ -294,7 +561,13 @@ void R_Shadow_Help_f(void) "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" @@ -315,8 +588,6 @@ void R_Shadow_Init(void) Cvar_RegisterVariable(&r_shadow_lightattenuationpower); Cvar_RegisterVariable(&r_shadow_lightattenuationscale); Cvar_RegisterVariable(&r_shadow_lightintensityscale); - Cvar_RegisterVariable(&r_shadow_polygonfactor); - Cvar_RegisterVariable(&r_shadow_polygonoffset); Cvar_RegisterVariable(&r_shadow_portallight); Cvar_RegisterVariable(&r_shadow_projectdistance); Cvar_RegisterVariable(&r_shadow_realtime_dlight); @@ -326,10 +597,16 @@ void R_Shadow_Init(void) Cvar_RegisterVariable(&r_shadow_realtime_world_lightmaps); Cvar_RegisterVariable(&r_shadow_realtime_world_shadows); Cvar_RegisterVariable(&r_shadow_scissor); + 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) { @@ -338,6 +615,25 @@ void R_Shadow_Init(void) } 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); } @@ -430,9 +726,10 @@ void R_Shadow_PrepareShadowMark(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) { - int i, j, tris = 0, vr[3], t, outvertices = 0; - const int *e, *n; - float f, temp[3]; + int i, j; + int outtriangles = 0, outvertices = 0; + const int *element; + const float *vertex; if (maxvertexupdate < innumvertices) { @@ -452,91 +749,102 @@ int R_Shadow_ConstructShadowVolume(int innumvertices, int innumtris, const int * 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++) { - t = shadowmarktris[i]; - shadowmark[t] = shadowmarkcount; - e = inelement3i + t * 3; + element = inelement3i + shadowmarktris[i] * 3; // make sure the vertices are created for (j = 0;j < 3;j++) { - if (vertexupdate[e[j]] != vertexupdatenum) + if (vertexupdate[element[j]] != vertexupdatenum) { - vertexupdate[e[j]] = vertexupdatenum; - vertexremap[e[j]] = outvertices; - VectorSubtract(invertex3f + e[j] * 3, projectorigin, temp); - f = projectdistance / VectorLength(temp); - VectorCopy(invertex3f + e[j] * 3, outvertex3f); - VectorMA(projectorigin, f, temp, (outvertex3f + 3)); + 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; } } - // output the front and back triangles - outelement3i[0] = vertexremap[e[0]]; - outelement3i[1] = vertexremap[e[1]]; - outelement3i[2] = vertexremap[e[2]]; - outelement3i[3] = vertexremap[e[2]] + 1; - outelement3i[4] = vertexremap[e[1]] + 1; - outelement3i[5] = vertexremap[e[0]] + 1; - outelement3i += 6; - tris += 2; } for (i = 0;i < numshadowmarktris;i++) { - t = shadowmarktris[i]; - e = inelement3i + t * 3; - n = inneighbor3i + t * 3; + 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[n[0]] != shadowmarkcount) - { - vr[0] = vertexremap[e[0]]; - vr[1] = vertexremap[e[1]]; - outelement3i[0] = vr[1]; - outelement3i[1] = vr[0]; - outelement3i[2] = vr[0] + 1; - outelement3i[3] = vr[1]; - outelement3i[4] = vr[0] + 1; - outelement3i[5] = vr[1] + 1; + 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; - tris += 2; - } - if (shadowmark[n[1]] != shadowmarkcount) - { - vr[1] = vertexremap[e[1]]; - vr[2] = vertexremap[e[2]]; - outelement3i[0] = vr[2]; - outelement3i[1] = vr[1]; - outelement3i[2] = vr[1] + 1; - outelement3i[3] = vr[2]; - outelement3i[4] = vr[1] + 1; - outelement3i[5] = vr[2] + 1; + 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; - tris += 2; - } - if (shadowmark[n[2]] != shadowmarkcount) - { - vr[0] = vertexremap[e[0]]; - vr[2] = vertexremap[e[2]]; - outelement3i[0] = vr[0]; - outelement3i[1] = vr[2]; - outelement3i[2] = vr[2] + 1; - outelement3i[3] = vr[0]; - outelement3i[4] = vr[2] + 1; - outelement3i[5] = vr[0] + 1; + 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; - tris += 2; + outtriangles += 2; } } if (outnumvertices) *outnumvertices = outvertices; - return tris; + return outtriangles; } -float varray_vertex3f2[65536*3]; - 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, outverts; @@ -554,39 +862,41 @@ void R_Shadow_VolumeFromList(int numverts, int numtris, const float *invertex3f, R_Shadow_RenderVolume(outverts, tris, varray_vertex3f2, shadowelements); } -void R_Shadow_VolumeFromBox(int numverts, int numtris, const float *invertex3f, const int *elements, const int *neighbors, const vec3_t projectorigin, float projectdistance, const vec3_t mins, const vec3_t maxs) +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) { - int i; + int t, tend; + const int *e; const float *v[3]; - - // check which triangles are facing the , and then output - // triangle elements and vertices... by clever use of elements we - // can construct the whole shadow from the unprojected vertices and - // the projected vertices - - // identify lit faces within the bounding box - R_Shadow_PrepareShadowMark(numtris); - for (i = 0;i < numtris;i++) + if (!BoxesOverlap(lightmins, lightmaxs, surfacemins, surfacemaxs)) + return; + tend = firsttriangle + numtris; + if (surfacemins[0] >= lightmins[0] && surfacemaxs[0] <= lightmaxs[0] + && surfacemins[1] >= lightmins[1] && surfacemaxs[1] <= lightmaxs[1] + && surfacemins[2] >= lightmins[2] && surfacemaxs[2] <= lightmaxs[2]) { - v[0] = invertex3f + elements[i*3+0] * 3; - v[1] = invertex3f + elements[i*3+1] * 3; - v[2] = invertex3f + elements[i*3+2] * 3; - if (PointInfrontOfTriangle(projectorigin, v[0], v[1], v[2]) && maxs[0] > min(v[0][0], min(v[1][0], v[2][0])) && mins[0] < max(v[0][0], max(v[1][0], v[2][0])) && maxs[1] > min(v[0][1], min(v[1][1], v[2][1])) && mins[1] < max(v[0][1], max(v[1][1], v[2][1])) && maxs[2] > min(v[0][2], min(v[1][2], v[2][2])) && mins[2] < max(v[0][2], max(v[1][2], v[2][2]))) - shadowmarklist[numshadowmark++] = i; + // 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_Shadow_VolumeFromList(numverts, numtris, invertex3f, elements, neighbors, projectorigin, projectdistance, numshadowmark, shadowmarklist); -} - -void R_Shadow_VolumeFromSphere(int numverts, int numtris, const float *invertex3f, const int *elements, const int *neighbors, const vec3_t projectorigin, float projectdistance, float radius) -{ - vec3_t mins, maxs; - mins[0] = projectorigin[0] - radius; - mins[1] = projectorigin[1] - radius; - mins[2] = projectorigin[2] - radius; - maxs[0] = projectorigin[0] + radius; - maxs[1] = projectorigin[1] + radius; - maxs[2] = projectorigin[2] + radius; - R_Shadow_VolumeFromBox(numverts, numtris, invertex3f, elements, neighbors, projectorigin, projectdistance, mins, maxs); } void R_Shadow_RenderVolume(int numvertices, int numtriangles, const float *vertex3f, const int *element3i) @@ -607,20 +917,19 @@ void R_Shadow_RenderVolume(int numvertices, int numtriangles, const float *verte // 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(numvertices, numtriangles, element3i); + 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); } - R_Mesh_Draw(numvertices, numtriangles, element3i); + 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, z, d, side; @@ -634,23 +943,17 @@ static void R_Shadow_MakeTextures(void) #define ATTEN2DSIZE 64 #define ATTEN3DSIZE 32 data = Mem_Alloc(tempmempool, max(6*NORMSIZE*NORMSIZE*4, max(ATTEN3DSIZE*ATTEN3DSIZE*ATTEN3DSIZE*4, ATTEN2DSIZE*ATTEN2DSIZE*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] = 255; - data[1] = 255; - data[2] = 255; - 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); + 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++) @@ -702,8 +1005,6 @@ static void R_Shadow_MakeTextures(void) } r_shadow_normalcubetexture = R_LoadTextureCubeMap(r_shadow_texturepool, "normalcube", NORMSIZE, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP, NULL); } - else - r_shadow_normalcubetexture = NULL; for (y = 0;y < ATTEN2DSIZE;y++) { for (x = 0;x < ATTEN2DSIZE;x++) @@ -749,14 +1050,19 @@ static void R_Shadow_MakeTextures(void) Mem_Free(data); } -void R_Shadow_Stage_Begin(void) +void R_Shadow_ValidateCvars(void) { - rmeshstate_t m; - 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; + + R_Shadow_ValidateCvars(); if (!r_shadow_attenuation2dtexture || (!r_shadow_attenuation3dtexture && r_shadow_texture3d.integer) @@ -774,26 +1080,6 @@ void R_Shadow_Stage_Begin(void) qglEnable(GL_CULL_FACE); GL_Scissor(r_view_x, r_view_y, r_view_width, r_view_height); r_shadowstage = SHADOWSTAGE_NONE; - - c_rt_lights = c_rt_clears = c_rt_scissored = 0; - c_rt_shadowmeshes = c_rt_shadowtris = c_rt_lightmeshes = c_rt_lighttris = 0; - c_rtcached_shadowmeshes = c_rtcached_shadowtris = 0; -} - -void R_Shadow_LoadWorldLightsIfNeeded(void) -{ - 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(); - } - } } void R_Shadow_Stage_ShadowVolumes(void) @@ -806,10 +1092,10 @@ void R_Shadow_Stage_ShadowVolumes(void) GL_BlendFunc(GL_ONE, GL_ZERO); GL_DepthMask(false); GL_DepthTest(true); - qglPolygonOffset(r_shadow_polygonfactor.value, r_shadow_polygonoffset.value); - //if (r_shadow_polygonoffset.value != 0) + qglPolygonOffset(r_shadow_shadow_polygonfactor.value, r_shadow_shadow_polygonoffset.value); + //if (r_shadow_shadow_polygonoffset.value != 0) //{ - // qglPolygonOffset(r_shadow_polygonfactor.value, r_shadow_polygonoffset.value); + // qglPolygonOffset(r_shadow_shadow_polygonfactor.value, r_shadow_shadow_polygonoffset.value); // qglEnable(GL_POLYGON_OFFSET_FILL); //} //else @@ -849,7 +1135,7 @@ void R_Shadow_Stage_ShadowVolumes(void) // optimize for them as noted above } -void R_Shadow_Stage_LightWithoutShadows(void) +void R_Shadow_Stage_Light(int shadowtest) { rmeshstate_t m; memset(&m, 0, sizeof(m)); @@ -860,35 +1146,14 @@ void R_Shadow_Stage_LightWithoutShadows(void) qglPolygonOffset(0, 0); //qglDisable(GL_POLYGON_OFFSET_FILL); GL_Color(1, 1, 1, 1); - GL_ColorMask(1, 1, 1, 1); + GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 1); qglDepthFunc(GL_EQUAL); qglCullFace(GL_FRONT); // quake is backwards, this culls back faces qglEnable(GL_CULL_FACE); - qglDisable(GL_STENCIL_TEST); - if (gl_support_stenciltwoside) - qglDisable(GL_STENCIL_TEST_TWO_SIDE_EXT); - qglStencilMask(~0); - qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); - qglStencilFunc(GL_EQUAL, 128, ~0); - r_shadowstage = SHADOWSTAGE_LIGHT; - c_rt_lights++; -} - -void R_Shadow_Stage_LightWithShadows(void) -{ - rmeshstate_t m; - memset(&m, 0, sizeof(m)); - 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); - GL_ColorMask(1, 1, 1, 1); - qglDepthFunc(GL_EQUAL); - qglCullFace(GL_FRONT); // quake is backwards, this culls back faces - qglEnable(GL_STENCIL_TEST); + if (shadowtest) + qglEnable(GL_STENCIL_TEST); + else + qglDisable(GL_STENCIL_TEST); if (gl_support_stenciltwoside) qglDisable(GL_STENCIL_TEST_TWO_SIDE_EXT); qglStencilMask(~0); @@ -911,7 +1176,7 @@ void R_Shadow_Stage_End(void) qglPolygonOffset(0, 0); //qglDisable(GL_POLYGON_OFFSET_FILL); GL_Color(1, 1, 1, 1); - GL_ColorMask(1, 1, 1, 1); + GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 1); GL_Scissor(r_view_x, r_view_y, r_view_width, r_view_height); qglDepthFunc(GL_LEQUAL); qglCullFace(GL_FRONT); // quake is backwards, this culls back faces @@ -1108,7 +1373,7 @@ static void R_Shadow_VertexShadingWithXYZAttenuation(int numverts, const float * if ((dot = DotProduct(n, v)) > 0) { dist = sqrt(dist); - intensity = dot / (VectorLength(v) * VectorLength(n)); + intensity = dot / sqrt(VectorLength2(v) * VectorLength2(n)); intensity *= pow(1 - dist, r_shadow_attenpower) * r_shadow_attenscale; VectorScale(lightcolor, intensity, color4f); color4f[3] = 1; @@ -1139,7 +1404,7 @@ static void R_Shadow_VertexShadingWithZAttenuation(int numverts, const float *ve Matrix4x4_Transform3x3(m, normal3f, n); if ((dot = DotProduct(n, v)) > 0) { - intensity = dot / (VectorLength(v) * VectorLength(n)); + intensity = dot / sqrt(VectorLength2(v) * VectorLength2(n)); intensity *= pow(1 - dist, r_shadow_attenpower) * r_shadow_attenscale; VectorScale(lightcolor, intensity, color4f); color4f[3] = 1; @@ -1168,7 +1433,7 @@ static void R_Shadow_VertexShading(int numverts, const float *vertex3f, const fl Matrix4x4_Transform3x3(m, normal3f, n); if ((dot = DotProduct(n, v)) > 0) { - intensity = dot / (VectorLength(v) * VectorLength(n)); + intensity = dot / sqrt(VectorLength2(v) * VectorLength2(n)); VectorScale(lightcolor, intensity, color4f); color4f[3] = 1; } @@ -1180,10 +1445,55 @@ static void R_Shadow_VertexShading(int numverts, const float *vertex3f, const fl } } -#define USETEXMATRIX 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 -// FIXME: this should be done in a texture matrix or vertex program when possible -// FIXME: if vertex program not available, this would really benefit from 3DNow! or SSE +// 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 @@ -1242,23 +1552,291 @@ static void R_Shadow_GenTexCoords_Specular_NormalCubeMap(float *out3f, int numve } } -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, int lighting) +void R_Shadow_RenderLighting(int firstvertex, int numvertices, 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 renders; float color[3], color2[3], colorscale; rmeshstate_t m; - if (!bumptexture) - bumptexture = r_shadow_blankbumptexture; - if (!glosstexture) - glosstexture = r_shadow_blankglosstexture; + // FIXME: support EF_NODEPTHTEST GL_DepthMask(false); GL_DepthTest(true); - if (gl_dot3arb && gl_texturecubemap && gl_combine.integer && gl_stencil) + if (!bumptexture) + 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.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(firstvertex, numvertices); + R_Mesh_Draw(firstvertex, numvertices, 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 (lighting & LIGHTING_DIFFUSE) + 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] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, 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] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, 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] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, 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] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, 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] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, 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] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, 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] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, 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] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, 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] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, 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] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, matrix_modeltoattenuationz); +#endif + R_Mesh_State(&m); + GL_ColorMask(0,0,0,1); + GL_BlendFunc(GL_ONE, GL_ZERO); + GL_LockArrays(firstvertex, numvertices); + R_Mesh_Draw(firstvertex, numvertices, 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] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, 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(firstvertex, numvertices); + 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(firstvertex, numvertices, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + } + GL_LockArrays(0, 0); + } + if (diffusescale) { GL_Color(1,1,1,1); - colorscale = r_shadow_lightintensityscale.value; + colorscale = diffusescale; // colorscale accounts for how much we multiply the brightness // during combine. // @@ -1277,24 +1855,24 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements 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_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord3f[1] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, svector3f + 3 * firstvertex, tvector3f + 3 * firstvertex, normal3f + 3 * firstvertex, relativelightorigin); m.tex3d[2] = R_GetTexture(r_shadow_attenuation3dtexture); -#if USETEXMATRIX +#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); + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[2] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, 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(numverts, numtriangles, elements); + GL_LockArrays(firstvertex, numvertices); + R_Mesh_Draw(firstvertex, numvertices, 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); @@ -1302,14 +1880,15 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements if (lightcubemap) { m.texcubemap[1] = R_GetTexture(lightcubemap); -#if USETEXMATRIX +#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); + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, matrix_modeltolight); #endif } + GL_BlendFunc(GL_DST_ALPHA, GL_ONE); } else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && lightcubemap) { @@ -1317,22 +1896,22 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements memset(&m, 0, sizeof(m)); m.pointer_vertex = vertex3f; m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture); -#if USETEXMATRIX +#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); + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[0] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, 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(numverts, numtriangles, elements); + GL_LockArrays(firstvertex, numvertices); + R_Mesh_Draw(firstvertex, numvertices, 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); @@ -1341,15 +1920,15 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements 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_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord3f[1] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, svector3f + 3 * firstvertex, tvector3f + 3 * firstvertex, normal3f + 3 * firstvertex, relativelightorigin); R_Mesh_State(&m); GL_BlendFunc(GL_DST_ALPHA, GL_ZERO); - GL_LockArrays(0, numverts); - R_Mesh_Draw(numverts, numtriangles, elements); + GL_LockArrays(firstvertex, numvertices); + R_Mesh_Draw(firstvertex, numvertices, 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); @@ -1357,14 +1936,15 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements if (lightcubemap) { m.texcubemap[1] = R_GetTexture(lightcubemap); -#if USETEXMATRIX +#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); + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, matrix_modeltolight); #endif } + GL_BlendFunc(GL_DST_ALPHA, GL_ONE); } else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && !lightcubemap) { @@ -1377,28 +1957,29 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements 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_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord3f[1] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, svector3f + 3 * firstvertex, tvector3f + 3 * firstvertex, normal3f + 3 * firstvertex, relativelightorigin); R_Mesh_State(&m); GL_ColorMask(0,0,0,1); GL_BlendFunc(GL_ONE, GL_ZERO); - GL_LockArrays(0, numverts); - R_Mesh_Draw(numverts, numtriangles, elements); + GL_LockArrays(firstvertex, numvertices); + R_Mesh_Draw(firstvertex, numvertices, 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); -#if USETEXMATRIX +#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); + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, matrix_modeltoattenuationxyz); #endif + GL_BlendFunc(GL_DST_ALPHA, GL_ONE); } else if (r_textureunits.integer >= 4) { @@ -1411,32 +1992,32 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements 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_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord3f[1] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, svector3f + 3 * firstvertex, tvector3f + 3 * firstvertex, normal3f + 3 * firstvertex, relativelightorigin); m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture); -#if USETEXMATRIX +#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); + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[2] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, matrix_modeltoattenuationxyz); #endif m.tex[3] = R_GetTexture(r_shadow_attenuation2dtexture); -#if USETEXMATRIX +#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); + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[3] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, 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(numverts, numtriangles, elements); + GL_LockArrays(firstvertex, numvertices); + R_Mesh_Draw(firstvertex, numvertices, 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); @@ -1444,14 +2025,15 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements if (lightcubemap) { m.texcubemap[1] = R_GetTexture(lightcubemap); -#if USETEXMATRIX +#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); + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, matrix_modeltolight); #endif } + GL_BlendFunc(GL_DST_ALPHA, GL_ONE); } else { @@ -1459,30 +2041,30 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements memset(&m, 0, sizeof(m)); m.pointer_vertex = vertex3f; m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture); -#if USETEXMATRIX +#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); + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[0] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, matrix_modeltoattenuationxyz); #endif m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture); -#if USETEXMATRIX +#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); + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[1] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, 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(numverts, numtriangles, elements); + GL_LockArrays(firstvertex, numvertices); + R_Mesh_Draw(firstvertex, numvertices, 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); @@ -1491,15 +2073,15 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements 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_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord3f[1] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, svector3f + 3 * firstvertex, tvector3f + 3 * firstvertex, normal3f + 3 * firstvertex, relativelightorigin); R_Mesh_State(&m); GL_BlendFunc(GL_DST_ALPHA, GL_ZERO); - GL_LockArrays(0, numverts); - R_Mesh_Draw(numverts, numtriangles, elements); + GL_LockArrays(firstvertex, numvertices); + R_Mesh_Draw(firstvertex, numvertices, 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); @@ -1507,38 +2089,36 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements if (lightcubemap) { m.texcubemap[1] = R_GetTexture(lightcubemap); -#if USETEXMATRIX +#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); + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, matrix_modeltolight); #endif } + GL_BlendFunc(GL_DST_ALPHA, GL_ONE); } // this final code is shared R_Mesh_State(&m); - GL_ColorMask(1,1,1,0); - GL_BlendFunc(GL_DST_ALPHA, GL_ONE); + GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 0); VectorScale(lightcolor, colorscale, color2); + GL_LockArrays(firstvertex, numvertices); 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); - GL_LockArrays(0, numverts); - R_Mesh_Draw(numverts, numtriangles, elements); - GL_LockArrays(0, 0); + R_Mesh_Draw(firstvertex, numvertices, numtriangles, elements); c_rt_lightmeshes++; c_rt_lighttris += numtriangles; } + GL_LockArrays(0, 0); } - if ((lighting & LIGHTING_SPECULAR) && (r_shadow_gloss.integer >= 2 || (r_shadow_gloss.integer >= 1 && glosstexture != r_shadow_blankglosstexture))) + if (specularscale && glosstexture != r_texture_black) { // FIXME: detect blendsquare! //if (gl_support_blendsquare) { - colorscale = r_shadow_lightintensityscale.value * r_shadow_glossintensity.value; - if (glosstexture == r_shadow_blankglosstexture) - colorscale *= r_shadow_gloss2intensity.value; + colorscale = specularscale; GL_Color(1,1,1,1); if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && lightcubemap /*&& gl_support_blendsquare*/) // FIXME: detect blendsquare! { @@ -1550,53 +2130,53 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements 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_Shadow_GenTexCoords_Specular_NormalCubeMap(varray_texcoord3f[1] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, svector3f + 3 * firstvertex, tvector3f + 3 * firstvertex, normal3f + 3 * firstvertex, 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(numverts, numtriangles, elements); + GL_LockArrays(firstvertex, numvertices); + R_Mesh_Draw(firstvertex, numvertices, 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); + GL_LockArrays(firstvertex, numvertices); // 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(numverts, numtriangles, elements); + R_Mesh_Draw(firstvertex, numvertices, numtriangles, elements); c_rt_lightmeshes++; c_rt_lighttris += numtriangles; - R_Mesh_Draw(numverts, numtriangles, elements); + R_Mesh_Draw(firstvertex, numvertices, 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); -#if USETEXMATRIX +#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); + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[0] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, matrix_modeltoattenuationxyz); #endif R_Mesh_State(&m); GL_BlendFunc(GL_DST_ALPHA, GL_ZERO); - GL_LockArrays(0, numverts); - R_Mesh_Draw(numverts, numtriangles, elements); + GL_LockArrays(firstvertex, numvertices); + R_Mesh_Draw(firstvertex, numvertices, 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); @@ -1604,14 +2184,15 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements if (lightcubemap) { m.texcubemap[1] = R_GetTexture(lightcubemap); -#if USETEXMATRIX +#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); + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, 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! { @@ -1623,47 +2204,48 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements 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_Shadow_GenTexCoords_Specular_NormalCubeMap(varray_texcoord3f[1] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, svector3f + 3 * firstvertex, tvector3f + 3 * firstvertex, normal3f + 3 * firstvertex, 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(numverts, numtriangles, elements); + GL_LockArrays(firstvertex, numvertices); + R_Mesh_Draw(firstvertex, numvertices, 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); + GL_LockArrays(firstvertex, numvertices); // 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(numverts, numtriangles, elements); + R_Mesh_Draw(firstvertex, numvertices, numtriangles, elements); c_rt_lightmeshes++; c_rt_lighttris += numtriangles; - R_Mesh_Draw(numverts, numtriangles, elements); + R_Mesh_Draw(firstvertex, numvertices, 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); -#if USETEXMATRIX +#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); + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, matrix_modeltoattenuationxyz); #endif + GL_BlendFunc(GL_DST_ALPHA, GL_ONE); } else { @@ -1675,61 +2257,61 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements 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_Shadow_GenTexCoords_Specular_NormalCubeMap(varray_texcoord3f[1] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, svector3f + 3 * firstvertex, tvector3f + 3 * firstvertex, normal3f + 3 * firstvertex, 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(numverts, numtriangles, elements); + GL_LockArrays(firstvertex, numvertices); + R_Mesh_Draw(firstvertex, numvertices, 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); + GL_LockArrays(firstvertex, numvertices); // 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(numverts, numtriangles, elements); + R_Mesh_Draw(firstvertex, numvertices, numtriangles, elements); c_rt_lightmeshes++; c_rt_lighttris += numtriangles; - R_Mesh_Draw(numverts, numtriangles, elements); + R_Mesh_Draw(firstvertex, numvertices, 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); -#if USETEXMATRIX +#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); + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[0] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, matrix_modeltoattenuationxyz); #endif m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture); -#if USETEXMATRIX +#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); + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[1] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, matrix_modeltoattenuationz); #endif R_Mesh_State(&m); GL_BlendFunc(GL_DST_ALPHA, GL_ZERO); - GL_LockArrays(0, numverts); - R_Mesh_Draw(numverts, numtriangles, elements); + GL_LockArrays(firstvertex, numvertices); + R_Mesh_Draw(firstvertex, numvertices, 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); @@ -1737,37 +2319,92 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements if (lightcubemap) { m.texcubemap[1] = R_GetTexture(lightcubemap); -#if USETEXMATRIX +#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); + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, 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(firstvertex, numvertices); + 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(firstvertex, numvertices, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + } + GL_LockArrays(0, 0); + } + } + } + else + { + 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] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, 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] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, matrix_modeltoattenuationz); +#endif } } + if (r_textureunits.integer >= 3) + m.pointer_color = NULL; + else + m.pointer_color = varray_color4f; R_Mesh_State(&m); - GL_ColorMask(1,1,1,0); - GL_BlendFunc(GL_DST_ALPHA, GL_ONE); - 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(numverts, numtriangles, elements); + 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(numvertices, vertex3f + 3 * firstvertex, color + 3 * firstvertex, matrix_modeltolight); + else + R_Shadow_VertexNoShadingWithXYZAttenuation(numvertices, vertex3f + 3 * firstvertex, color + 3 * firstvertex, matrix_modeltolight); + GL_LockArrays(firstvertex, numvertices); + R_Mesh_Draw(firstvertex, numvertices, numtriangles, elements); + GL_LockArrays(0, 0); c_rt_lightmeshes++; c_rt_lighttris += numtriangles; } - GL_LockArrays(0, 0); } - } - else - { - if (lighting & LIGHTING_DIFFUSE) + if (diffusescale) { - GL_BlendFunc(GL_SRC_ALPHA, GL_ONE); - VectorScale(lightcolor, r_shadow_lightintensityscale.value, color2); + GL_BlendFunc(GL_ONE, GL_ONE); + VectorScale(lightcolor, diffusescale, color2); memset(&m, 0, sizeof(m)); m.pointer_vertex = vertex3f; m.pointer_color = varray_color4f; @@ -1777,23 +2414,23 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements { // voodoo2 m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture); -#if USETEXMATRIX +#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); + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[1] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, matrix_modeltoattenuationxyz); #endif if (r_textureunits.integer >= 3) { // Geforce3/Radeon class but not using dot3 m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture); -#if USETEXMATRIX +#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); + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[2] + 3 * firstvertex, numvertices, vertex3f + 3 * firstvertex, matrix_modeltoattenuationz); #endif } } @@ -1804,13 +2441,13 @@ void R_Shadow_RenderLighting(int numverts, int numtriangles, const int *elements 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); + R_Shadow_VertexShading(numvertices, vertex3f + 3 * firstvertex, normal3f + 3 * firstvertex, color + 3 * firstvertex, matrix_modeltolight); else if (r_textureunits.integer >= 2) - R_Shadow_VertexShadingWithZAttenuation(numverts, vertex3f, normal3f, color, matrix_modeltolight); + R_Shadow_VertexShadingWithZAttenuation(numvertices, vertex3f + 3 * firstvertex, normal3f + 3 * firstvertex, color + 3 * firstvertex, matrix_modeltolight); else - R_Shadow_VertexShadingWithXYZAttenuation(numverts, vertex3f, normal3f, color, matrix_modeltolight); - GL_LockArrays(0, numverts); - R_Mesh_Draw(numverts, numtriangles, elements); + R_Shadow_VertexShadingWithXYZAttenuation(numvertices, vertex3f + 3 * firstvertex, normal3f + 3 * firstvertex, color + 3 * firstvertex, matrix_modeltolight); + GL_LockArrays(firstvertex, numvertices); + R_Mesh_Draw(firstvertex, numvertices, numtriangles, elements); GL_LockArrays(0, 0); c_rt_lightmeshes++; c_rt_lighttris += numtriangles; @@ -1846,6 +2483,11 @@ void R_RTLight_UpdateFromDLight(rtlight_t *rtlight, const dlight_t *light, int i 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 @@ -1858,19 +2500,17 @@ void R_RTLight_UpdateFromDLight(rtlight_t *rtlight, const dlight_t *light, int i rtlight->lightmap_cullradius = bound(0, rtlight->radius, 2048.0f); rtlight->lightmap_cullradius2 = rtlight->lightmap_cullradius * rtlight->lightmap_cullradius; - VectorScale(rtlight->color, rtlight->radius * d_lightstylevalue[rtlight->style] * 0.125f, rtlight->lightmap_light); + 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; } -rtlight_t *r_shadow_compilingrtlight; - // 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 = &cl_entities[0].render; - model_t *model = ent->model; + entity_render_t *ent = r_refdef.worldentity; + model_t *model = r_refdef.worldmodel; // compile the light rtlight->compiled = true; @@ -1890,27 +2530,27 @@ void R_RTLight_Compile(rtlight_t *rtlight) // 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); + 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_numclusterpvsbytes = (model->brush.num_pvsclusters + 7) >> 3; rtlight->static_clusterlist = Mem_Alloc(r_shadow_mempool, rtlight->static_numclusters * sizeof(*rtlight->static_clusterlist)); - rtlight->static_clusterpvs = Mem_Alloc(r_shadow_mempool, rtlight->static_numclusterpvsbytes); 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); + 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, numsurfaces, r_shadow_buffer_surfacelist); + 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 @@ -1971,37 +2611,62 @@ void R_RTLight_Uncompile(rtlight_t *rtlight) } } -int shadowframecount = 0; - -void R_Shadow_DrawWorldLightShadowVolume(matrix4x4_t *matrix, dlight_t *light); +void R_Shadow_UncompileWorldLights(void) +{ + dlight_t *light; + for (light = r_shadow_worldlightchain;light;light = light->next) + R_RTLight_Uncompile(&light->rtlight); +} void R_DrawRTLight(rtlight_t *rtlight, int visiblevolumes) { - int i, shadow; + int i, shadow, usestencil; entity_render_t *ent; float f; - vec3_t relativelightorigin, relativeeyeorigin, lightcolor; + 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; + vec3_t cullmins, cullmaxs, relativelightmins, relativelightmaxs; shadowmesh_t *mesh; rmeshstate_t m; - if (d_lightstylevalue[rtlight->style] <= 0) + // 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; + 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 (R_CullBox(cullmins, cullmaxs)) + if (rtlight->style >= 0 && d_lightstylevalue[rtlight->style] <= 0) return; - if (rtlight->isstatic && !rtlight->compiled && r_shadow_staticworldlights.integer) - R_RTLight_Compile(rtlight); numclusters = 0; clusterlist = NULL; clusterpvs = NULL; @@ -2009,21 +2674,32 @@ void R_DrawRTLight(rtlight_t *rtlight, int visiblevolumes) surfacelist = NULL; if (rtlight->compiled && r_shadow_staticworldlights.integer) { + // 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); } - else if (cl.worldmodel && cl.worldmodel->GetLightInfo) + else if (r_refdef.worldmodel && r_refdef.worldmodel->GetLightInfo) { - R_Shadow_EnlargeClusterBuffer(cl.worldmodel->brush.num_pvsclusters); - R_Shadow_EnlargeSurfaceBuffer(cl.worldmodel->nummodelsurfaces); - cl.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); + // 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++) @@ -2032,48 +2708,20 @@ void R_DrawRTLight(rtlight_t *rtlight, int visiblevolumes) if (i == numclusters) return; } - if (R_CullBox(cullmins, cullmaxs)) - return; + // set up a scissor rectangle for this light if (R_Shadow_ScissorForBBox(cullmins, cullmaxs)) return; - f = d_lightstylevalue[rtlight->style] * (1.0f / 256.0f); - VectorScale(rtlight->color, f, lightcolor); - /* - if (rtlight->selected) - { - f = 2 + sin(realtime * M_PI * 4.0); - VectorScale(lightcolor, f, lightcolor); - } - */ - - if (rtlight->cubemapname[0]) - cubemaptexture = R_Shadow_Cubemap(rtlight->cubemapname); - else - cubemaptexture = NULL; - -#if 1 - shadow = rtlight->shadow && (rtlight->isstatic ? r_shadow_realtime_world_shadows.integer : (r_shadow_realtime_world.integer ? r_shadow_realtime_world_dlightshadows.integer : r_shadow_realtime_dlight_shadows.integer)); -#else - shadow = false; - if (rtlight->shadow) - { - if (rtlight->isstatic) - shadow = r_shadow_realtime_world_shadows.integer; - else - { - if (r_shadow_realtime_world.integer) - shadow = r_shadow_realtime_world_dlightshadows.integer; - else - shadow = r_shadow_realtime_dlight_shadows.integer; - } - } -#endif + 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) { @@ -2086,26 +2734,26 @@ void R_DrawRTLight(rtlight_t *rtlight, int visiblevolumes) GL_LockArrays(0, mesh->numverts); if (r_shadowstage == SHADOWSTAGE_STENCIL) { - // 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(mesh->numverts, mesh->numtriangles, mesh->element3i); - c_rtcached_shadowmeshes++; - c_rtcached_shadowtris += mesh->numtriangles; // 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(mesh->numverts, mesh->numtriangles, mesh->element3i); + R_Mesh_Draw(0, mesh->numverts, mesh->numtriangles, mesh->element3i); c_rtcached_shadowmeshes++; c_rtcached_shadowtris += mesh->numtriangles; GL_LockArrays(0, 0); } } - else + else if (numsurfaces) { Matrix4x4_Transform(&ent->inversematrix, rtlight->shadoworigin, relativelightorigin); - ent->model->DrawShadowVolume(ent, relativelightorigin, rtlight->radius, numsurfaces, surfacelist); + ent->model->DrawShadowVolume(ent, relativelightorigin, rtlight->radius, numsurfaces, surfacelist, rtlight->cullmins, rtlight->cullmaxs); } if (r_drawentities.integer) { @@ -2117,7 +2765,7 @@ void R_DrawRTLight(rtlight_t *rtlight, int visiblevolumes) { if (!BoxesOverlap(ent->mins, ent->maxs, cullmins, cullmaxs)) continue; - if (cl.worldmodel != NULL && cl.worldmodel->brush.BoxTouchingPVS != NULL && !cl.worldmodel->brush.BoxTouchingPVS(cl.worldmodel, clusterpvs, ent->mins, ent->maxs)) + 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) @@ -2126,21 +2774,27 @@ void R_DrawRTLight(rtlight_t *rtlight, int visiblevolumes) // light emitting entities should not cast their own shadow if (VectorLength2(relativelightorigin) < 0.1) continue; - ent->model->DrawShadowVolume(ent, relativelightorigin, rtlight->radius, ent->model->nummodelsurfaces, ent->model->surfacelist); + 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); } } } if (!visiblevolumes) { - if (shadow && gl_stencil) - R_Shadow_Stage_LightWithShadows(); - else - R_Shadow_Stage_LightWithoutShadows(); + R_Shadow_Stage_Light(usestencil); ent = &cl_entities[0].render; - if (ent->model && ent->model->DrawLight) + 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); @@ -2150,24 +2804,29 @@ void R_DrawRTLight(rtlight_t *rtlight, int visiblevolumes) { 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, lightcolor, &matrix_modeltolight, &matrix_modeltoattenuationxyz, &matrix_modeltoattenuationz, mesh->map_diffuse, mesh->map_normal, mesh->map_specular, cubemaptexture, LIGHTING_DIFFUSE | LIGHTING_SPECULAR); + R_Shadow_RenderLighting(0, 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, lightcolor, &matrix_modeltolight, &matrix_modeltoattenuationxyz, &matrix_modeltoattenuationz, cubemaptexture, numsurfaces, surfacelist); + ent->model->DrawLight(ent, relativelightorigin, relativeeyeorigin, rtlight->radius, lightcolor2, &matrix_modeltolight, &matrix_modeltoattenuationxyz, &matrix_modeltoattenuationz, cubemaptexture, rtlight->ambientscale, rtlight->diffusescale, rtlight->specularscale, numsurfaces, surfacelist); } if (r_drawentities.integer) { for (i = 0;i < r_refdef.numentities;i++) { ent = r_refdef.entities[i]; - if (ent->visframe == r_framecount && BoxesOverlap(ent->mins, ent->maxs, cullmins, cullmaxs) && ent->model && ent->model->DrawLight && (ent->flags & RENDER_LIGHT)) + // 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, lightcolor, &matrix_modeltolight, &matrix_modeltoattenuationxyz, &matrix_modeltoattenuationz, cubemaptexture, ent->model->nummodelsurfaces, ent->model->surfacelist); + 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); } } } @@ -2176,10 +2835,13 @@ void R_DrawRTLight(rtlight_t *rtlight, int visiblevolumes) void R_ShadowVolumeLighting(int visiblevolumes) { - int lnum; + 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)); @@ -2193,21 +2855,18 @@ void R_ShadowVolumeLighting(int visiblevolumes) } else R_Shadow_Stage_Begin(); - shadowframecount++; - if (r_shadow_realtime_world.integer) + flag = r_rtworld ? LIGHTFLAG_REALTIMEMODE : LIGHTFLAG_NORMALMODE; + if (r_shadow_debuglight.integer >= 0) { - R_Shadow_LoadWorldLightsIfNeeded(); - if (r_shadow_debuglight.integer >= 0) - { - for (lnum = 0, light = r_shadow_worldlightchain;light;lnum++, light = light->next) - if (lnum == r_shadow_debuglight.integer) - R_DrawRTLight(&light->rtlight, visiblevolumes); - } - else - for (lnum = 0, light = r_shadow_worldlightchain;light;lnum++, light = light->next) + 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); } - if (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) + 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); @@ -2220,38 +2879,23 @@ void R_ShadowVolumeLighting(int visiblevolumes) R_Shadow_Stage_End(); } -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"}; -dlight_t *r_shadow_worldlightchain; -dlight_t *r_shadow_selectedlight; -vec3_t r_editlights_cursorlocation; - -typedef struct cubemapinfo_s -{ - char basename[64]; - rtexture_t *texture; -} -cubemapinfo_t; - -#define MAX_CUBEMAPS 128 -static int numcubemaps; -static cubemapinfo_t cubemaps[MAX_CUBEMAPS]; - //static char *suffix[6] = {"ft", "bk", "rt", "lf", "up", "dn"}; typedef struct suffixinfo_s { char *suffix; - int flipx, flipy, flipdiagonal; + 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}, @@ -2261,20 +2905,12 @@ static suffixinfo_t suffix[3][6] = {"negz", false, false, false} }, { - {"px", false, false, false}, - {"nx", false, false, false}, - {"py", false, false, false}, - {"ny", false, false, false}, - {"pz", false, false, false}, - {"nz", false, false, false} - }, - { - {"ft", true, false, true}, - {"bk", false, true, true}, - {"lf", true, true, false}, - {"rt", false, false, false}, - {"up", false, false, false}, - {"dn", 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} } }; @@ -2290,30 +2926,39 @@ rtexture_t *R_Shadow_LoadCubemap(const char *basename) 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++) { - snprintf(name, sizeof(name), "%s%s", basename, suffix[j][i].suffix); + // 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))) { + // 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 sizes are black + // 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 a cubemap loaded, upload it if (cubemappixels) { if (!r_shadow_filters_texturepool) @@ -2352,21 +2997,25 @@ void R_Shadow_FreeCubemaps(void) R_FreeTexturePool(&r_shadow_filters_texturepool); } -void R_Shadow_NewWorldLight(vec3_t origin, vec3_t angles, vec3_t color, vec_t radius, vec_t corona, int style, int shadowenable, const char *cubemapname) +dlight_t *R_Shadow_NewWorldLight(void) { dlight_t *light; - - if (radius < 15 || DotProduct(color, color) < 0.03) - { - Con_Print("R_Shadow_NewWorldLight: refusing to create a light too small/dim\n"); - return; - } - 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); - VectorCopy(angles, light->angles); - VectorCopy(color, light->color); - light->radius = radius; + 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) { @@ -2375,25 +3024,27 @@ void R_Shadow_NewWorldLight(vec3_t origin, vec3_t angles, vec3_t color, vec_t ra } light->shadow = shadowenable; light->corona = corona; - if (cubemapname && cubemapname[0] && strlen(cubemapname) < sizeof(light->cubemapname)) - strcpy(light->cubemapname, cubemapname); + 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); - light->next = r_shadow_worldlightchain; - r_shadow_worldlightchain = light; R_RTLight_UpdateFromDLight(&light->rtlight, light, true); - if (r_shadow_staticworldlights.integer) - R_RTLight_Compile(&light->rtlight); } 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; - R_RTLight_Uncompile(&light->rtlight); Mem_Free(light); } @@ -2414,8 +3065,6 @@ void R_Shadow_SelectLight(dlight_t *light) r_shadow_selectedlight->selected = true; } -rtexture_t *lighttextures[5]; - void R_Shadow_DrawCursorCallback(const void *calldata1, int calldata2) { float scale = r_editlights_cursorgrid.value * 0.5f; @@ -2448,8 +3097,8 @@ void R_Shadow_DrawLightSprites(void) lighttextures[i] = pic->tex; } - for (light = r_shadow_worldlightchain;light;light = light->next) - R_MeshQueue_AddTransparent(light->origin, R_Shadow_DrawLightSpriteCallback, light, ((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); } @@ -2478,15 +3127,15 @@ void R_Shadow_SelectLightInView(void) void R_Shadow_LoadWorldLights(void) { - int n, a, style, shadow; - char name[MAX_QPATH], cubemapname[MAX_QPATH], *lightsstring, *s, *t; - float origin[3], radius, color[3], angles[3], corona; - if (cl.worldmodel == NULL) + 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 (cl.worldmodel->name, name, sizeof (name)); + FS_StripExtension (r_refdef.worldmodel->name, name, sizeof (name)); strlcat (name, ".rtlights", sizeof (name)); lightsstring = FS_LoadFile(name, tempmempool, false); if (lightsstring) @@ -2512,11 +3161,11 @@ void R_Shadow_LoadWorldLights(void) } */ t = s; - while (*s && *s != '\n') + while (*s && *s != '\n' && *s != '\r') s++; if (!*s) break; - *s = 0; + tempchar = *s; shadow = true; // check for modifier flags if (*t == '!') @@ -2524,23 +3173,43 @@ void R_Shadow_LoadWorldLights(void) shadow = false; t++; } - a = sscanf(t, "%f %f %f %f %f %f %f %d %s %f %f %f %f", &origin[0], &origin[1], &origin[2], &radius, &color[0], &color[1], &color[2], &style, cubemapname, &corona, &angles[0], &angles[1], &angles[2]); + *s = 0; + 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 more parameters (origin[0] origin[1] origin[2] radius color[0] color[1] color[2] style \"cubemapname\" corona angles[0] angles[1] angles[2])\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; } VectorScale(color, r_editlights_rtlightscolorscale.value, color); radius *= r_editlights_rtlightssizescale.value; - R_Shadow_NewWorldLight(origin, angles, color, radius, corona, style, shadow, cubemapname); - s++; + 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) @@ -2558,18 +3227,23 @@ void R_Shadow_SaveWorldLights(void) char line[1024]; if (!r_shadow_worldlightchain) return; - if (cl.worldmodel == NULL) + if (r_refdef.worldmodel == NULL) { Con_Print("No map loaded.\n"); return; } - FS_StripExtension (cl.worldmodel->name, name, sizeof (name)); + 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, "%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[0] ? light->cubemapname : "\"\"", light->corona, light->angles[0], light->angles[1], light->angles[2]); + 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; @@ -2597,14 +3271,14 @@ 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; - if (cl.worldmodel == NULL) + if (r_refdef.worldmodel == NULL) { Con_Print("No map loaded.\n"); return; } - FS_StripExtension (cl.worldmodel->name, name, sizeof (name)); + FS_StripExtension (r_refdef.worldmodel->name, name, sizeof (name)); strlcat (name, ".lights", sizeof (name)); lightsstring = FS_LoadFile(name, tempmempool, false); if (lightsstring) @@ -2614,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); @@ -2629,8 +3304,11 @@ void R_Shadow_LoadLightsFile(void) radius = sqrt(DotProduct(color, color) / (falloff * falloff * 8192.0f * 8192.0f)); radius = bound(15, radius, 4096); VectorScale(color, (2.0f / (8388608.0f)), color); - R_Shadow_NewWorldLight(origin, vec3_origin, color, radius, 0, style, true, NULL); - s++; + 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) @@ -2639,28 +3317,39 @@ 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, skin, pflags, effects; - char key[256], value[1024]; - float origin[3], angles[3], radius, color[3], light, fadescale, lightscale, 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]; - if (cl.worldmodel == NULL) + if (r_refdef.worldmodel == NULL) { Con_Print("No map loaded.\n"); return; } - data = cl.worldmodel->brush.entities; + // 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, 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; fadescale = 1; lightscale = 1; @@ -2687,7 +3376,27 @@ void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void) // 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)) @@ -2770,7 +3479,7 @@ void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void) } else if (!strcmp("style", key)) style = atoi(value); - else if (cl.worldmodel->type == mod_brushq3) + else if (r_refdef.worldmodel->type == mod_brushq3) { if (!strcmp("scale", key)) lightscale = atof(value); @@ -2784,29 +3493,48 @@ void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void) else if (!strcmp("effects", key)) effects = (int)atof(value); } - if (light <= 0 && islight) - light = 300; + if (!islight) + continue; if (lightscale <= 0) lightscale = 1; if (fadescale <= 0) fadescale = 1; - if (gamemode == GAME_TENEBRAE) + if (color[0] == color[1] && color[0] == color[2]) { - if (effects & EF_NODRAW) - { - pflags |= PFLAGS_FULLDYNAMIC; - effects &= ~EF_NODRAW; - } + 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; } - radius = min(light * r_editlights_quakelightsizescale.value * lightscale / fadescale, 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 && !(pflags & PFLAGS_FULLDYNAMIC)) - R_Shadow_NewWorldLight(origin, angles, color, radius, (pflags & PFLAGS_CORONA) != 0, style, (pflags & PFLAGS_NOSHADOW) == 0, skin >= 16 ? va("cubemaps/%i", skin) : 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); } @@ -2850,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) @@ -2885,14 +3624,14 @@ void R_Shadow_EditLights_Spawn_f(void) return; } color[0] = color[1] = color[2] = 1; - R_Shadow_NewWorldLight(r_editlights_cursorlocation, vec3_origin, color, 200, 0, 0, true, NULL); + 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, angles, color; - vec_t radius, corona; - int style, shadows; + vec_t radius, corona, coronasizescale, ambientscale, diffusescale, specularscale; + int style, shadows, flags, normalmode, realtimemode; char cubemapname[1024]; if (!r_editlights.integer) { @@ -2915,6 +3654,13 @@ void R_Shadow_EditLights_Edit_f(void) 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")) { if (Cmd_Argc() != 5) @@ -3088,43 +3834,134 @@ void R_Shadow_EditLights_Edit_f(void) } 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; + } + 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) + { + 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("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; } - R_Shadow_FreeWorldLight(r_shadow_selectedlight); - r_shadow_selectedlight = NULL; - R_Shadow_NewWorldLight(origin, angles, color, radius, corona, style, shadows, cubemapname); + 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(); + } } -extern int con_vislines; void R_Shadow_EditLights_DrawSelectedLightProperties(void) { + int lightnumber, lightcount; + dlight_t *light; float x, y; char temp[256]; - if (r_shadow_selectedlight == NULL) + if (!r_editlights.integer) return; x = 0; y = con_vislines; - sprintf(temp, "Light properties");DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; - sprintf(temp, "Origin %f %f %f", 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", 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", 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", r_shadow_selectedlight->radius);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; - sprintf(temp, "Corona %f", r_shadow_selectedlight->corona);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; - sprintf(temp, "Style %i", r_shadow_selectedlight->style);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; - sprintf(temp, "Shadows %s", 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", r_shadow_selectedlight->cubemapname);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; + 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) @@ -3139,9 +3976,7 @@ void R_Shadow_EditLights_ToggleShadow_f(void) Con_Print("No selected light.\n"); return; } - R_Shadow_NewWorldLight(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_FreeWorldLight(r_shadow_selectedlight); - r_shadow_selectedlight = NULL; + 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) @@ -3156,9 +3991,7 @@ void R_Shadow_EditLights_ToggleCorona_f(void) Con_Print("No selected light.\n"); return; } - R_Shadow_NewWorldLight(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_FreeWorldLight(r_shadow_selectedlight); - r_shadow_selectedlight = NULL; + 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) @@ -3220,10 +4053,60 @@ void R_Shadow_EditLights_Help_f(void) "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_Print("No selected light.\n"); + return; + } + 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) { Cvar_RegisterVariable(&r_editlights); @@ -3240,10 +4123,13 @@ void R_Shadow_EditLights_Init(void) 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); }