X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=r_shadow.c;h=aa2d935b41e99a3a3b281744f8eebe439ff6b602;hp=a438837aac7736e8d5de7e24754728c4bc6c6f7c;hb=fdfa815d659f4ceec149ce3f907c107f38022c3d;hpb=0fe5e8ce16bf03a06a4d76cc4a7182c2a6294350 diff --git a/r_shadow.c b/r_shadow.c index a438837a..aa2d935b 100644 --- a/r_shadow.c +++ b/r_shadow.c @@ -1,7 +1,111 @@ +/* +Terminology: Stencil Shadow Volume (sometimes called Stencil Shadows) +An extrusion of the lit faces, beginning at the original geometry and ending +further from the light source than the original geometry (presumably at least +as far as the light's radius, if the light has a radius at all), capped at +both front and back to avoid any problems (extrusion from dark faces also +works but has a different set of problems) + +This is rendered using Carmack's Reverse technique, in which backfaces behind +zbuffer (zfail) increment the stencil, and frontfaces behind zbuffer (zfail) +decrement the stencil, the result is a stencil value of zero where shadows +did not intersect the visible geometry, suitable as a stencil mask for +rendering lighting everywhere but shadow. + +In our case we use a biased stencil clear of 128 to avoid requiring the +stencil wrap extension (but probably should support it). + + + +Terminology: Stencil Light Volume (sometimes called Light Volumes) +Similar to a Stencil Shadow Volume, but inverted; rather than containing the +areas in shadow it contanis the areas in light, this can only be built +quickly for certain limited cases (such as portal visibility from a point), +but is quite useful for some effects (sunlight coming from sky polygons is +one possible example, translucent occluders is another example). + + + +Terminology: Optimized Stencil Shadow Volume +A Stencil Shadow Volume that has been processed sufficiently to ensure it has +no duplicate coverage of areas (no need to shadow an area twice), often this +greatly improves performance but is an operation too costly to use on moving +lights (however completely optimal Stencil Light Volumes can be constructed +in some ideal cases). + + + +Terminology: Per Pixel Lighting (sometimes abbreviated PPL) +Per pixel evaluation of lighting equations, at a bare minimum this involves +DOT3 shading of diffuse lighting (per pixel dotproduct of negated incidence +vector and surface normal, using a texture of the surface bumps, called a +NormalMap) if supported by hardware; in our case there is support for cards +which are incapable of DOT3, the quality is quite poor however. Additionally +it is desirable to have specular evaluation per pixel, per vertex +normalization of specular halfangle vectors causes noticable distortion but +is unavoidable on hardware without GL_ARB_fragment_program. + + + +Terminology: Normalization CubeMap +A cubemap containing normalized dot3-encoded (vectors of length 1 or less +encoded as RGB colors) for any possible direction, this technique allows per +pixel calculation of incidence vector for per pixel lighting purposes, which +would not otherwise be possible per pixel without GL_ARB_fragment_program. + + + +Terminology: 2D Attenuation Texturing +A very crude approximation of light attenuation with distance which results +in cylindrical light shapes which fade vertically as a streak (some games +such as Doom3 allow this to be rotated to be less noticable in specific +cases), the technique is simply modulating lighting by two 2D textures (which +can be the same) on different axes of projection (XY and Z, typically), this +is the best technique available without 3D Attenuation Texturing or +GL_ARB_fragment_program technology. + + + +Terminology: 3D Attenuation Texturing +A slightly crude approximation of light attenuation with distance, its flaws +are limited radius and resolution (performance tradeoffs). + + + +Terminology: 3D Attenuation-Normalization Texturing +A 3D Attenuation Texture merged with a Normalization CubeMap, by making the +vectors shorter the lighting becomes darker, a very effective optimization of +diffuse lighting if 3D Attenuation Textures are already used. + + + +Terminology: Light Cubemap Filtering +A technique for modeling non-uniform light distribution according to +direction, for example projecting a stained glass window image onto a wall, +this is done by texturing the lighting with a cubemap. + + + +Terminology: Light Projection Filtering +A technique for modeling shadowing of light passing through translucent +surfaces, allowing stained glass windows and other effects to be done more +elegantly than possible with Light Cubemap Filtering by applying an occluder +texture to the lighting combined with a stencil light volume to limit the lit +area (this allows evaluating multiple translucent occluders in a scene). + + + +Terminology: Doom3 Lighting +A combination of Stencil Shadow Volume, Per Pixel Lighting, Normalization +CubeMap, 2D Attenuation Texturing, and Light Filtering, as demonstrated by +the (currently upcoming) game Doom3. +*/ + #include "quakedef.h" #include "r_shadow.h" #include "cl_collision.h" +#include "portals.h" extern void R_Shadow_EditLights_Init(void); @@ -13,32 +117,47 @@ extern void R_Shadow_EditLights_Init(void); int r_shadowstage = SHADOWSTAGE_NONE; int r_shadow_reloadlights = false; -int r_shadow_lightingmode = 0; - mempool_t *r_shadow_mempool; int maxshadowelements; int *shadowelements; int maxtrianglefacinglight; qbyte *trianglefacinglight; +int *trianglefacinglightlist; + +int maxvertexupdate; +int *vertexupdate; +int *vertexremap; +int vertexupdatenum; rtexturepool_t *r_shadow_texturepool; -rtexture_t *r_shadow_normalsattenuationtexture; -rtexture_t *r_shadow_normalscubetexture; +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; -cvar_t r_shadow_lightattenuationscale = {0, "r_shadow_lightattenuationscale", "2"}; +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_realtime = {0, "r_shadow_realtime", "0"}; -cvar_t r_shadow_erasebydrawing = {0, "r_shadow_erasebydrawing", "0"}; -cvar_t r_shadow_texture3d = {0, "r_shadow_texture3d", "0"}; +cvar_t r_shadow_realtime_world = {0, "r_shadow_realtime_world", "0"}; +cvar_t r_shadow_realtime_dlight = {0, "r_shadow_realtime_dlight", "0"}; +cvar_t r_shadow_visiblevolumes = {0, "r_shadow_visiblevolumes", "0"}; cvar_t r_shadow_gloss = {0, "r_shadow_gloss", "1"}; cvar_t r_shadow_debuglight = {0, "r_shadow_debuglight", "-1"}; cvar_t r_shadow_scissor = {0, "r_shadow_scissor", "1"}; -cvar_t r_shadow_bumpscale = {0, "r_shadow_bumpscale", "4"}; +cvar_t r_shadow_bumpscale_bumpmap = {0, "r_shadow_bumpscale_bumpmap", "4"}; +cvar_t r_shadow_bumpscale_basetexture = {0, "r_shadow_bumpscale_basetexture", "0"}; +cvar_t r_shadow_polygonoffset = {0, "r_shadow_polygonoffset", "0"}; +cvar_t r_shadow_portallight = {0, "r_shadow_portallight", "1"}; +cvar_t r_shadow_projectdistance = {0, "r_shadow_projectdistance", "10000"}; +cvar_t r_shadow_texture3d = {0, "r_shadow_texture3d", "1"}; +cvar_t r_shadow_singlepassvolumegeneration = {0, "r_shadow_singlepassvolumegeneration", "1"}; + +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; void R_Shadow_ClearWorldLights(void); void R_Shadow_SaveWorldLights(void); @@ -52,11 +171,16 @@ void r_shadow_start(void) r_shadow_mempool = Mem_AllocPool("R_Shadow"); maxshadowelements = 0; shadowelements = NULL; + maxvertexupdate = 0; + vertexupdate = NULL; + vertexremap = NULL; + vertexupdatenum = 0; maxtrianglefacinglight = 0; trianglefacinglight = NULL; - r_shadow_normalsattenuationtexture = NULL; - r_shadow_normalscubetexture = NULL; + trianglefacinglightlist = 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; @@ -69,17 +193,22 @@ void r_shadow_shutdown(void) { R_Shadow_ClearWorldLights(); r_shadow_reloadlights = true; - r_shadow_normalsattenuationtexture = NULL; - r_shadow_normalscubetexture = 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_FreeTexturePool(&r_shadow_texturepool); maxshadowelements = 0; shadowelements = NULL; + maxvertexupdate = 0; + vertexupdate = NULL; + vertexremap = NULL; + vertexupdatenum = 0; maxtrianglefacinglight = 0; trianglefacinglight = NULL; + trianglefacinglightlist = NULL; Mem_FreePool(&r_shadow_mempool); } @@ -91,252 +220,344 @@ void r_shadow_newmap(void) void R_Shadow_Init(void) { + Cvar_RegisterVariable(&r_shadow_lightattenuationpower); Cvar_RegisterVariable(&r_shadow_lightattenuationscale); Cvar_RegisterVariable(&r_shadow_lightintensityscale); - Cvar_RegisterVariable(&r_shadow_realtime); - Cvar_RegisterVariable(&r_shadow_texture3d); + Cvar_RegisterVariable(&r_shadow_realtime_world); + Cvar_RegisterVariable(&r_shadow_realtime_dlight); + Cvar_RegisterVariable(&r_shadow_visiblevolumes); Cvar_RegisterVariable(&r_shadow_gloss); Cvar_RegisterVariable(&r_shadow_debuglight); - Cvar_RegisterVariable(&r_shadow_erasebydrawing); Cvar_RegisterVariable(&r_shadow_scissor); - Cvar_RegisterVariable(&r_shadow_bumpscale); + Cvar_RegisterVariable(&r_shadow_bumpscale_bumpmap); + Cvar_RegisterVariable(&r_shadow_bumpscale_basetexture); + Cvar_RegisterVariable(&r_shadow_polygonoffset); + Cvar_RegisterVariable(&r_shadow_portallight); + Cvar_RegisterVariable(&r_shadow_projectdistance); + Cvar_RegisterVariable(&r_shadow_texture3d); + Cvar_RegisterVariable(&r_shadow_singlepassvolumegeneration); R_Shadow_EditLights_Init(); R_RegisterModule("R_Shadow", r_shadow_start, r_shadow_shutdown, r_shadow_newmap); } -void R_Shadow_ProjectVertices(const float *in, float *out, int numverts, const float *relativelightorigin, float projectdistance) +void R_Shadow_ResizeTriangleFacingLight(int numtris) { - int i; - for (i = 0;i < numverts;i++, in += 4, out += 4) - { -#if 1 - out[0] = in[0] + 1000000.0f * (in[0] - relativelightorigin[0]); - out[1] = in[1] + 1000000.0f * (in[1] - relativelightorigin[1]); - out[2] = in[2] + 1000000.0f * (in[2] - relativelightorigin[2]); -#elif 0 - VectorSubtract(in, relativelightorigin, temp); - f = lightradius / sqrt(DotProduct(temp,temp)); - if (f < 1) - f = 1; - VectorMA(relativelightorigin, f, temp, out); -#else - VectorSubtract(in, relativelightorigin, temp); - f = projectdistance / sqrt(DotProduct(temp,temp)); - VectorMA(in, f, temp, out); -#endif + // make sure trianglefacinglight is big enough for this volume + // ameks ru ertaignelaficgnilhg tsib gie ongu hof rhtsiv lomu e + // m4k3 5ur3 7r14ng13f4c1n5115h7 15 b15 3n0u5h f0r 7h15 v01um3 + if (maxtrianglefacinglight < numtris) + { + maxtrianglefacinglight = numtris; + if (trianglefacinglight) + Mem_Free(trianglefacinglight); + if (trianglefacinglightlist) + Mem_Free(trianglefacinglightlist); + trianglefacinglight = Mem_Alloc(r_shadow_mempool, maxtrianglefacinglight); + trianglefacinglightlist = Mem_Alloc(r_shadow_mempool, sizeof(int) * maxtrianglefacinglight); } } -void R_Shadow_MakeTriangleShadowFlags(const int *elements, const float *vertex, int numtris, qbyte *trianglefacinglight, const float *relativelightorigin, float lightradius) +int *R_Shadow_ResizeShadowElements(int numtris) { - int i; - const float *v0, *v1, *v2; - for (i = 0;i < numtris;i++, elements += 3) - { - // calculate triangle facing flag - v0 = vertex + elements[0] * 4; - v1 = vertex + elements[1] * 4; - v2 = vertex + elements[2] * 4; - // we do not need to normalize the surface normal because both sides - // of the comparison use it, therefore they are both multiplied the - // same amount... furthermore the subtract can be done on the - // vectors, saving a little bit of math in the dotproducts -#if 0 - // fast version - // subtracts v1 from v0 and v2, combined into a crossproduct, - // combined with a dotproduct of the light location relative to the - // first point of the triangle (any point works, since the triangle - // is obviously flat), and finally a comparison to determine if the - // light is infront of the triangle (the goal of this statement) - trianglefacinglight[i] = - (relativelightorigin[0] - v0[0]) * ((v0[1] - v1[1]) * (v2[2] - v1[2]) - (v0[2] - v1[2]) * (v2[1] - v1[1])) - + (relativelightorigin[1] - v0[1]) * ((v0[2] - v1[2]) * (v2[0] - v1[0]) - (v0[0] - v1[0]) * (v2[2] - v1[2])) - + (relativelightorigin[2] - v0[2]) * ((v0[0] - v1[0]) * (v2[1] - v1[1]) - (v0[1] - v1[1]) * (v2[0] - v1[0])) > 0; -#else - // readable version - { - float dir0[3], dir1[3], temp[3], f; - - // calculate two mostly perpendicular edge directions - VectorSubtract(v0, v1, dir0); - VectorSubtract(v2, v1, dir1); - - // we have two edge directions, we can calculate a third vector from - // them, which is the direction of the surface normal (it's magnitude - // is not 1 however) - CrossProduct(dir0, dir1, temp); - - // this is entirely unnecessary, but kept for clarity - //VectorNormalize(temp); - - // compare distance of light along normal, with distance of any point - // of the triangle along the same normal (the triangle is planar, - // I.E. flat, so all points give the same answer) - // the normal is not normalized because it is used on both sides of - // the comparison, so it's magnitude does not matter - //trianglefacinglight[i] = DotProduct(relativelightorigin, temp) >= DotProduct(v0, temp); - f = DotProduct(relativelightorigin, temp) - DotProduct(v0, temp); - trianglefacinglight[i] = f > 0 && f < lightradius * sqrt(DotProduct(temp, temp)); - } -#endif + // make sure shadowelements is big enough for this volume + if (maxshadowelements < numtris * 24) + { + maxshadowelements = numtris * 24; + if (shadowelements) + Mem_Free(shadowelements); + shadowelements = Mem_Alloc(r_shadow_mempool, maxshadowelements * sizeof(int)); } + return shadowelements; } -int R_Shadow_BuildShadowVolumeTriangles(const int *elements, const int *neighbors, int numtris, int numverts, const qbyte *trianglefacinglight, int *out) +int R_Shadow_ConstructShadowVolume(int innumvertices, int trianglerange_start, int trianglerange_end, const int *inelement3i, const int *inneighbor3i, const float *invertex3f, int *outnumvertices, int *outelement3i, float *outvertex3f, const float *relativelightorigin, float projectdistance) { - int i, tris; - // check each frontface for bordering backfaces, - // and cast shadow polygons from those edges, - // also create front and back caps for shadow volume - tris = 0; - for (i = 0;i < numtris;i++, elements += 3, neighbors += 3) - { - if (trianglefacinglight[i]) + int i, j, tris = 0, numfacing = 0, vr[3], t, outvertices = 0; + const float *v[3]; + const int *e, *n, *te; + float f, temp[3]; + + // make sure trianglefacinglight is big enough for this volume + if (maxtrianglefacinglight < trianglerange_end) + R_Shadow_ResizeTriangleFacingLight(trianglerange_end); + + if (maxvertexupdate < innumvertices) + { + maxvertexupdate = innumvertices; + if (vertexupdate) + Mem_Free(vertexupdate); + if (vertexremap) + Mem_Free(vertexremap); + vertexupdate = Mem_Alloc(r_shadow_mempool, maxvertexupdate * sizeof(int)); + vertexremap = Mem_Alloc(r_shadow_mempool, maxvertexupdate * sizeof(int)); + } + vertexupdatenum++; + + if (r_shadow_singlepassvolumegeneration.integer) + { + // one pass approach (identify lit/dark faces and generate sides while doing so) + for (i = trianglerange_start, e = inelement3i + i * 3, n = inneighbor3i + i * 3;i < trianglerange_end;i++, e += 3, n += 3) + { + // calculate triangle facing flag + v[0] = invertex3f + e[0] * 3; + v[1] = invertex3f + e[1] * 3; + v[2] = invertex3f + e[2] * 3; + if((trianglefacinglight[i] = PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2]))) + { + // make sure the vertices are created + for (j = 0;j < 3;j++) + { + if (vertexupdate[e[j]] != vertexupdatenum) + { + vertexupdate[e[j]] = vertexupdatenum; + vertexremap[e[j]] = outvertices; + VectorCopy(v[j], outvertex3f); + VectorSubtract(v[j], relativelightorigin, temp); + f = projectdistance / VectorLength(temp); + VectorMA(relativelightorigin, f, temp, (outvertex3f + 3)); + outvertex3f += 6; + outvertices += 2; + } + } + // output the front and back triangles + vr[0] = vertexremap[e[0]]; + vr[1] = vertexremap[e[1]]; + vr[2] = vertexremap[e[2]]; + outelement3i[0] = vr[0]; + outelement3i[1] = vr[1]; + outelement3i[2] = vr[2]; + outelement3i[3] = vr[2] + 1; + outelement3i[4] = vr[1] + 1; + outelement3i[5] = vr[0] + 1; + outelement3i += 6; + tris += 2; + // output the sides (facing outward from this triangle) + t = n[0]; + if ((t >= trianglerange_start && t < trianglerange_end) ? (t < i && !trianglefacinglight[t]) : (t < 0 || (te = inelement3i + t * 3, v[0] = invertex3f + te[0] * 3, v[1] = invertex3f + te[1] * 3, v[2] = invertex3f + te[2] * 3, !PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2])))) + { + 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; + outelement3i += 6; + tris += 2; + } + t = n[1]; + if ((t >= trianglerange_start && t < trianglerange_end) ? (t < i && !trianglefacinglight[t]) : (t < 0 || (te = inelement3i + t * 3, v[0] = invertex3f + te[0] * 3, v[1] = invertex3f + te[1] * 3, v[2] = invertex3f + te[2] * 3, !PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[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; + outelement3i += 6; + tris += 2; + } + t = n[2]; + if ((t >= trianglerange_start && t < trianglerange_end) ? (t < i && !trianglefacinglight[t]) : (t < 0 || (te = inelement3i + t * 3, v[0] = invertex3f + te[0] * 3, v[1] = invertex3f + te[1] * 3, v[2] = invertex3f + te[2] * 3, !PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[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; + outelement3i += 6; + tris += 2; + } + } + else + { + // this triangle is not facing the light + // output the sides (facing inward to this triangle) + t = n[0]; + if (t < i && t >= trianglerange_start && t < trianglerange_end && trianglefacinglight[t]) + { + vr[0] = vertexremap[e[0]]; + vr[1] = vertexremap[e[1]]; + outelement3i[0] = vr[1]; + outelement3i[1] = vr[0] + 1; + outelement3i[2] = vr[0]; + outelement3i[3] = vr[1]; + outelement3i[4] = vr[1] + 1; + outelement3i[5] = vr[0] + 1; + outelement3i += 6; + tris += 2; + } + t = n[1]; + if (t < i && t >= trianglerange_start && t < trianglerange_end && trianglefacinglight[t]) + { + vr[1] = vertexremap[e[1]]; + vr[2] = vertexremap[e[2]]; + outelement3i[0] = vr[2]; + outelement3i[1] = vr[1] + 1; + outelement3i[2] = vr[1]; + outelement3i[3] = vr[2]; + outelement3i[4] = vr[2] + 1; + outelement3i[5] = vr[1] + 1; + outelement3i += 6; + tris += 2; + } + t = n[2]; + if (t < i && t >= trianglerange_start && t < trianglerange_end && trianglefacinglight[t]) + { + vr[0] = vertexremap[e[0]]; + vr[2] = vertexremap[e[2]]; + outelement3i[0] = vr[0]; + outelement3i[1] = vr[2] + 1; + outelement3i[2] = vr[2]; + outelement3i[3] = vr[0]; + outelement3i[4] = vr[0] + 1; + outelement3i[5] = vr[2] + 1; + outelement3i += 6; + tris += 2; + } + } + } + } + else + { + // two pass approach (identify lit/dark faces and then generate sides) + for (i = trianglerange_start, e = inelement3i + i * 3, numfacing = 0;i < trianglerange_end;i++, e += 3) { - // triangle is frontface and therefore casts shadow, - // output front and back caps for shadow volume - // front cap - out[0] = elements[0]; - out[1] = elements[1]; - out[2] = elements[2]; - // rear cap (with flipped winding order) - out[3] = elements[0] + numverts; - out[4] = elements[2] + numverts; - out[5] = elements[1] + numverts; - out += 6; - tris += 2; - // check the edges - if (neighbors[0] < 0 || !trianglefacinglight[neighbors[0]]) + // calculate triangle facing flag + v[0] = invertex3f + e[0] * 3; + v[1] = invertex3f + e[1] * 3; + v[2] = invertex3f + e[2] * 3; + if((trianglefacinglight[i] = PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2]))) { - out[0] = elements[1]; - out[1] = elements[0]; - out[2] = elements[0] + numverts; - out[3] = elements[1]; - out[4] = elements[0] + numverts; - out[5] = elements[1] + numverts; - out += 6; + trianglefacinglightlist[numfacing++] = i; + // make sure the vertices are created + for (j = 0;j < 3;j++) + { + if (vertexupdate[e[j]] != vertexupdatenum) + { + vertexupdate[e[j]] = vertexupdatenum; + vertexremap[e[j]] = outvertices; + VectorSubtract(v[j], relativelightorigin, temp); + f = projectdistance / VectorLength(temp); + VectorCopy(v[j], outvertex3f); + VectorMA(relativelightorigin, f, temp, (outvertex3f + 3)); + outvertex3f += 6; + outvertices += 2; + } + } + // output the front and back triangles + outelement3i[3] = vertexremap[e[0]]; + outelement3i[4] = vertexremap[e[1]]; + outelement3i[5] = vertexremap[e[2]]; + outelement3i[0] = vertexremap[e[2]] + 1; + outelement3i[1] = vertexremap[e[1]] + 1; + outelement3i[2] = vertexremap[e[0]] + 1; + outelement3i += 6; tris += 2; } - if (neighbors[1] < 0 || !trianglefacinglight[neighbors[1]]) + } + for (i = 0;i < numfacing;i++) + { + t = trianglefacinglightlist[i]; + e = inelement3i + t * 3; + n = inneighbor3i + t * 3; + // output the sides (facing outward from this triangle) + t = n[0]; + if ((t >= trianglerange_start && t < trianglerange_end) ? (!trianglefacinglight[t]) : (t < 0 || (te = inelement3i + t * 3, v[0] = invertex3f + te[0] * 3, v[1] = invertex3f + te[1] * 3, v[2] = invertex3f + te[2] * 3, !PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2])))) { - out[0] = elements[2]; - out[1] = elements[1]; - out[2] = elements[1] + numverts; - out[3] = elements[2]; - out[4] = elements[1] + numverts; - out[5] = elements[2] + numverts; - out += 6; + 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; + outelement3i += 6; tris += 2; } - if (neighbors[2] < 0 || !trianglefacinglight[neighbors[2]]) + t = n[1]; + if ((t >= trianglerange_start && t < trianglerange_end) ? (!trianglefacinglight[t]) : (t < 0 || (te = inelement3i + t * 3, v[0] = invertex3f + te[0] * 3, v[1] = invertex3f + te[1] * 3, v[2] = invertex3f + te[2] * 3, !PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2])))) { - out[0] = elements[0]; - out[1] = elements[2]; - out[2] = elements[2] + numverts; - out[3] = elements[0]; - out[4] = elements[2] + numverts; - out[5] = elements[0] + numverts; - out += 6; + 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; + outelement3i += 6; + tris += 2; + } + t = n[2]; + if ((t >= trianglerange_start && t < trianglerange_end) ? (!trianglefacinglight[t]) : (t < 0 || (te = inelement3i + t * 3, v[0] = invertex3f + te[0] * 3, v[1] = invertex3f + te[1] * 3, v[2] = invertex3f + te[2] * 3, !PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2])))) + { + 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; + outelement3i += 6; tris += 2; } } } + if (outnumvertices) + *outnumvertices = outvertices; return tris; } -void R_Shadow_ResizeTriangleFacingLight(int numtris) -{ - // make sure trianglefacinglight is big enough for this volume - if (maxtrianglefacinglight < numtris) - { - maxtrianglefacinglight = numtris; - if (trianglefacinglight) - Mem_Free(trianglefacinglight); - trianglefacinglight = Mem_Alloc(r_shadow_mempool, maxtrianglefacinglight); - } -} +float varray_vertex3f2[65536*3]; -void R_Shadow_ResizeShadowElements(int numtris) +void R_Shadow_Volume(int numverts, int numtris, const float *invertex3f, int *elements, int *neighbors, vec3_t relativelightorigin, float lightradius, float projectdistance) { - // make sure shadowelements is big enough for this volume - if (maxshadowelements < numtris * 24) - { - maxshadowelements = numtris * 24; - if (shadowelements) - Mem_Free(shadowelements); - shadowelements = Mem_Alloc(r_shadow_mempool, maxshadowelements * sizeof(int)); - } -} - -void R_Shadow_Volume(int numverts, int numtris, int *elements, int *neighbors, vec3_t relativelightorigin, float lightradius, float projectdistance) -{ - int tris; + int tris, outverts; if (projectdistance < 0.1) { Con_Printf("R_Shadow_Volume: projectdistance %f\n"); return; } -// terminology: -// -// frontface: -// a triangle facing the light source -// -// backface: -// a triangle not facing the light source -// -// shadow volume: -// an extrusion of the frontfaces, beginning at the original geometry and -// ending further from the light source than the original geometry -// (presumably at least as far as the light's radius, if the light has a -// radius at all), capped at both front and back to avoid any problems -// -// description: -// draws the shadow volumes of the model. -// requirements: -// vertex locations must already be in varray_vertex before use. -// varray_vertex must have capacity for numverts * 2. - - // make sure trianglefacinglight is big enough for this volume - if (maxtrianglefacinglight < numtris) - R_Shadow_ResizeTriangleFacingLight(numtris); + if (!numverts) + return; // make sure shadowelements is big enough for this volume if (maxshadowelements < numtris * 24) R_Shadow_ResizeShadowElements(numtris); - // generate projected vertices - // by clever use of elements we'll construct the whole shadow from - // the unprojected vertices and these projected vertices - R_Shadow_ProjectVertices(varray_vertex, varray_vertex + numverts * 4, numverts, relativelightorigin, projectdistance); - - // check which triangles are facing the light - R_Shadow_MakeTriangleShadowFlags(elements, varray_vertex, numtris, trianglefacinglight, relativelightorigin, lightradius); - - // output triangle elements - tris = R_Shadow_BuildShadowVolumeTriangles(elements, neighbors, numtris, numverts, trianglefacinglight, shadowelements); - R_Shadow_RenderVolume(numverts * 2, tris, shadowelements); -} - -void R_Shadow_RenderVolume(int numverts, int numtris, int *elements) -{ - if (!numverts || !numtris) - return; - if (r_shadowstage == SHADOWSTAGE_STENCIL) + // check which triangles are facing the light, 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 + if ((tris = R_Shadow_ConstructShadowVolume(numverts, 0, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, varray_vertex3f2, relativelightorigin, projectdistance))) { - // increment stencil if backface is behind depthbuffer - qglCullFace(GL_BACK); // quake is backwards, this culls front faces - qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP); - R_Mesh_Draw(numverts, numtris, elements); - // decrement stencil if frontface is behind depthbuffer - qglCullFace(GL_FRONT); // quake is backwards, this culls back faces - qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP); + GL_VertexPointer(varray_vertex3f2); + if (r_shadowstage == SHADOWSTAGE_STENCIL) + { + // increment stencil if backface is behind depthbuffer + qglCullFace(GL_BACK); // quake is backwards, this culls front faces + qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP); + R_Mesh_Draw(outverts, tris, shadowelements); + c_rt_shadowmeshes++; + c_rt_shadowtris += numtris; + // 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(outverts, tris, shadowelements); + c_rt_shadowmeshes++; + c_rt_shadowtris += numtris; } - R_Mesh_Draw(numverts, numtris, elements); } void R_Shadow_RenderShadowMeshVolume(shadowmesh_t *firstmesh) { shadowmesh_t *mesh; + rmeshstate_t m; + memset(&m, 0, sizeof(m)); if (r_shadowstage == SHADOWSTAGE_STENCIL) { // increment stencil if backface is behind depthbuffer @@ -344,9 +565,10 @@ void R_Shadow_RenderShadowMeshVolume(shadowmesh_t *firstmesh) qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP); for (mesh = firstmesh;mesh;mesh = mesh->next) { - R_Mesh_ResizeCheck(mesh->numverts); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); - R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->elements); + GL_VertexPointer(mesh->vertex3f); + R_Mesh_Draw(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 @@ -354,60 +576,27 @@ void R_Shadow_RenderShadowMeshVolume(shadowmesh_t *firstmesh) } for (mesh = firstmesh;mesh;mesh = mesh->next) { - R_Mesh_ResizeCheck(mesh->numverts); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); - R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->elements); - } -} - -float r_shadow_atten1; -#define ATTEN3DSIZE 64 -static void R_Shadow_Make3DTextures(void) -{ - int x, y, z; - float v[3], intensity, ilen, bordercolor[4]; - qbyte *data; - if (r_shadow_texture3d.integer != 1 || !gl_texture3d) - return; - data = Mem_Alloc(tempmempool, ATTEN3DSIZE * ATTEN3DSIZE * ATTEN3DSIZE * 4); - for (z = 0;z < ATTEN3DSIZE;z++) - { - for (y = 0;y < ATTEN3DSIZE;y++) - { - for (x = 0;x < ATTEN3DSIZE;x++) - { - v[0] = (x + 0.5f) * (2.0f / (float) ATTEN3DSIZE) - 1.0f; - v[1] = (y + 0.5f) * (2.0f / (float) ATTEN3DSIZE) - 1.0f; - v[2] = (z + 0.5f) * (2.0f / (float) ATTEN3DSIZE) - 1.0f; - intensity = 1.0f - sqrt(DotProduct(v, v)); - if (intensity > 0) - intensity *= intensity; - ilen = 127.0f * bound(0, intensity * r_shadow_atten1, 1) / sqrt(DotProduct(v, v)); - data[((z*ATTEN3DSIZE+y)*ATTEN3DSIZE+x)*4+0] = 128.0f + ilen * v[0]; - data[((z*ATTEN3DSIZE+y)*ATTEN3DSIZE+x)*4+1] = 128.0f + ilen * v[1]; - data[((z*ATTEN3DSIZE+y)*ATTEN3DSIZE+x)*4+2] = 128.0f + ilen * v[2]; - data[((z*ATTEN3DSIZE+y)*ATTEN3DSIZE+x)*4+3] = 255; - } - } + GL_VertexPointer(mesh->vertex3f); + R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i); + c_rtcached_shadowmeshes++; + c_rtcached_shadowtris += mesh->numtriangles; } - r_shadow_normalsattenuationtexture = R_LoadTexture3D(r_shadow_texturepool, "normalsattenuation", ATTEN3DSIZE, ATTEN3DSIZE, ATTEN3DSIZE, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL); - bordercolor[0] = 0.5f; - bordercolor[1] = 0.5f; - bordercolor[2] = 0.5f; - bordercolor[3] = 1.0f; - qglTexParameterfv(GL_TEXTURE_3D, GL_TEXTURE_BORDER_COLOR, bordercolor); - Mem_Free(data); } +float r_shadow_attenpower, r_shadow_attenscale; static void R_Shadow_MakeTextures(void) { - int x, y, d, side; + int x, y, z, d, side; float v[3], s, t, intensity; qbyte *data; - data = Mem_Alloc(tempmempool, 6*128*128*4); R_FreeTexturePool(&r_shadow_texturepool); r_shadow_texturepool = R_AllocTexturePool(); - r_shadow_atten1 = r_shadow_lightattenuationscale.value; + r_shadow_attenpower = r_shadow_lightattenuationpower.value; + r_shadow_attenscale = r_shadow_lightattenuationscale.value; +#define NORMSIZE 64 +#define ATTEN2DSIZE 64 +#define ATTEN3DSIZE 32 + data = Mem_Alloc(tempmempool, max(6*NORMSIZE*NORMSIZE*4, max(ATTEN3DSIZE*ATTEN3DSIZE*ATTEN3DSIZE*4, ATTEN2DSIZE*ATTEN2DSIZE*4))); data[0] = 128; data[1] = 128; data[2] = 255; @@ -423,95 +612,141 @@ static void R_Shadow_MakeTextures(void) data[2] = 255; data[3] = 255; r_shadow_blankwhitetexture = R_LoadTexture2D(r_shadow_texturepool, "blankwhite", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL); - for (side = 0;side < 6;side++) + if (gl_texturecubemap) { - for (y = 0;y < 128;y++) + for (side = 0;side < 6;side++) { - for (x = 0;x < 128;x++) + for (y = 0;y < NORMSIZE;y++) { - s = (x + 0.5f) * (2.0f / 128.0f) - 1.0f; - t = (y + 0.5f) * (2.0f / 128.0f) - 1.0f; - switch(side) + for (x = 0;x < NORMSIZE;x++) { - case 0: - v[0] = 1; - v[1] = -t; - v[2] = -s; - break; - case 1: - v[0] = -1; - v[1] = -t; - v[2] = s; - break; - case 2: - v[0] = s; - v[1] = 1; - v[2] = t; - break; - case 3: - v[0] = s; - v[1] = -1; - v[2] = -t; - break; - case 4: - v[0] = s; - v[1] = -t; - v[2] = 1; - break; - case 5: - v[0] = -s; - v[1] = -t; - v[2] = -1; - break; + s = (x + 0.5f) * (2.0f / NORMSIZE) - 1.0f; + t = (y + 0.5f) * (2.0f / NORMSIZE) - 1.0f; + switch(side) + { + case 0: + v[0] = 1; + v[1] = -t; + v[2] = -s; + break; + case 1: + v[0] = -1; + v[1] = -t; + v[2] = s; + break; + case 2: + v[0] = s; + v[1] = 1; + v[2] = t; + break; + case 3: + v[0] = s; + v[1] = -1; + v[2] = -t; + break; + case 4: + v[0] = s; + v[1] = -t; + v[2] = 1; + break; + case 5: + v[0] = -s; + v[1] = -t; + v[2] = -1; + break; + } + intensity = 127.0f / sqrt(DotProduct(v, v)); + data[((side*NORMSIZE+y)*NORMSIZE+x)*4+0] = 128.0f + intensity * v[0]; + data[((side*NORMSIZE+y)*NORMSIZE+x)*4+1] = 128.0f + intensity * v[1]; + data[((side*NORMSIZE+y)*NORMSIZE+x)*4+2] = 128.0f + intensity * v[2]; + data[((side*NORMSIZE+y)*NORMSIZE+x)*4+3] = 255; } - intensity = 127.0f / sqrt(DotProduct(v, v)); - data[((side*128+y)*128+x)*4+0] = 128.0f + intensity * v[0]; - data[((side*128+y)*128+x)*4+1] = 128.0f + intensity * v[1]; - data[((side*128+y)*128+x)*4+2] = 128.0f + intensity * v[2]; - data[((side*128+y)*128+x)*4+3] = 255; } } + r_shadow_normalcubetexture = R_LoadTextureCubeMap(r_shadow_texturepool, "normalcube", NORMSIZE, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP, NULL); } - r_shadow_normalscubetexture = R_LoadTextureCubeMap(r_shadow_texturepool, "normalscube", 128, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP, NULL); - for (y = 0;y < 128;y++) + else + r_shadow_normalcubetexture = NULL; + for (y = 0;y < ATTEN2DSIZE;y++) { - for (x = 0;x < 128;x++) + for (x = 0;x < ATTEN2DSIZE;x++) { - v[0] = (x + 0.5f) * (2.0f / 128.0f) - 1.0f; - v[1] = (y + 0.5f) * (2.0f / 128.0f) - 1.0f; + v[0] = ((x + 0.5f) * (2.0f / ATTEN2DSIZE) - 1.0f) * (1.0f / 0.9375); + v[1] = ((y + 0.5f) * (2.0f / ATTEN2DSIZE) - 1.0f) * (1.0f / 0.9375); v[2] = 0; intensity = 1.0f - sqrt(DotProduct(v, v)); if (intensity > 0) - intensity *= intensity; - intensity = bound(0, intensity * r_shadow_atten1 * 256.0f, 255.0f); + intensity = pow(intensity, r_shadow_attenpower) * r_shadow_attenscale * 256.0f; d = bound(0, intensity, 255); - data[((0*128+y)*128+x)*4+0] = d; - data[((0*128+y)*128+x)*4+1] = d; - data[((0*128+y)*128+x)*4+2] = d; - data[((0*128+y)*128+x)*4+3] = d; + data[(y*ATTEN2DSIZE+x)*4+0] = d; + data[(y*ATTEN2DSIZE+x)*4+1] = d; + data[(y*ATTEN2DSIZE+x)*4+2] = d; + data[(y*ATTEN2DSIZE+x)*4+3] = d; } } - r_shadow_attenuation2dtexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation2d", 128, 128, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA | TEXF_MIPMAP, NULL); + r_shadow_attenuation2dtexture = R_LoadTexture2D(r_shadow_texturepool, "attenuation2d", ATTEN2DSIZE, ATTEN2DSIZE, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA, NULL); + if (r_shadow_texture3d.integer) + { + for (z = 0;z < ATTEN3DSIZE;z++) + { + for (y = 0;y < ATTEN3DSIZE;y++) + { + for (x = 0;x < ATTEN3DSIZE;x++) + { + v[0] = ((x + 0.5f) * (2.0f / ATTEN3DSIZE) - 1.0f) * (1.0f / 0.9375); + v[1] = ((y + 0.5f) * (2.0f / ATTEN3DSIZE) - 1.0f) * (1.0f / 0.9375); + v[2] = ((z + 0.5f) * (2.0f / ATTEN3DSIZE) - 1.0f) * (1.0f / 0.9375); + intensity = 1.0f - sqrt(DotProduct(v, v)); + if (intensity > 0) + intensity = pow(intensity, r_shadow_attenpower) * r_shadow_attenscale * 256.0f; + d = bound(0, intensity, 255); + data[((z*ATTEN3DSIZE+y)*ATTEN3DSIZE+x)*4+0] = d; + data[((z*ATTEN3DSIZE+y)*ATTEN3DSIZE+x)*4+1] = d; + data[((z*ATTEN3DSIZE+y)*ATTEN3DSIZE+x)*4+2] = d; + data[((z*ATTEN3DSIZE+y)*ATTEN3DSIZE+x)*4+3] = d; + } + } + } + r_shadow_attenuation3dtexture = R_LoadTexture3D(r_shadow_texturepool, "attenuation3d", ATTEN3DSIZE, ATTEN3DSIZE, ATTEN3DSIZE, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP | TEXF_ALPHA, NULL); + } Mem_Free(data); - R_Shadow_Make3DTextures(); } void R_Shadow_Stage_Begin(void) { rmeshstate_t m; - if (r_shadow_texture3d.integer == 1 && !gl_texture3d) - { - Con_Printf("3D texture support not detected, falling back on slower 2D + 1D + normalization lighting\n"); + if (r_shadow_texture3d.integer && !gl_texture3d) Cvar_SetValueQuick(&r_shadow_texture3d, 0); - } + //cl.worldmodel->numlights = min(cl.worldmodel->numlights, 1); if (!r_shadow_attenuation2dtexture - || (r_shadow_texture3d.integer == 1 && !r_shadow_normalsattenuationtexture) - || r_shadow_lightattenuationscale.value != r_shadow_atten1) + || (!r_shadow_attenuation3dtexture && r_shadow_texture3d.integer) + || r_shadow_lightattenuationpower.value != r_shadow_attenpower + || r_shadow_lightattenuationscale.value != r_shadow_attenscale) R_Shadow_MakeTextures(); + + GL_BlendFunc(GL_ONE, GL_ZERO); + GL_DepthMask(false); + GL_DepthTest(true); + GL_Color(0, 0, 0, 1); + + memset(&m, 0, sizeof(m)); + R_Mesh_State_Texture(&m); + + qglDisable(GL_SCISSOR_TEST); + 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) @@ -521,110 +756,121 @@ void R_Shadow_Stage_Begin(void) R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(); } } - - memset(&m, 0, sizeof(m)); - m.blendfunc1 = GL_ONE; - m.blendfunc2 = GL_ZERO; - R_Mesh_State(&m); - GL_Color(0, 0, 0, 1); - r_shadowstage = SHADOWSTAGE_NONE; } void R_Shadow_Stage_ShadowVolumes(void) { rmeshstate_t m; + memset(&m, 0, sizeof(m)); - R_Mesh_TextureState(&m); + R_Mesh_State_Texture(&m); + GL_Color(1, 1, 1, 1); + GL_BlendFunc(GL_ONE, GL_ZERO); + GL_DepthMask(false); + GL_DepthTest(true); + + if (r_shadow_polygonoffset.value != 0) + { + qglPolygonOffset(1.0f, r_shadow_polygonoffset.value); + qglEnable(GL_POLYGON_OFFSET_FILL); + } + else + qglDisable(GL_POLYGON_OFFSET_FILL); qglColorMask(0, 0, 0, 0); - qglDisable(GL_BLEND); - qglDepthMask(0); qglDepthFunc(GL_LESS); qglEnable(GL_STENCIL_TEST); qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); - qglStencilFunc(GL_ALWAYS, 0, 0xFF); - qglEnable(GL_CULL_FACE); - qglEnable(GL_DEPTH_TEST); + qglStencilFunc(GL_ALWAYS, 128, 0xFF); r_shadowstage = SHADOWSTAGE_STENCIL; - if (!r_shadow_erasebydrawing.integer) - qglClear(GL_STENCIL_BUFFER_BIT); + + qglClear(GL_STENCIL_BUFFER_BIT); + c_rt_clears++; + // LordHavoc note: many shadow volumes reside entirely inside the world + // (that is to say they are entirely bounded by their lit surfaces), + // which can be optimized by handling things as an inverted light volume, + // with the shadow boundaries of the world being simulated by an altered + // (129) bias to stencil clearing on such lights + // FIXME: generate inverted light volumes for use as shadow volumes and + // optimize for them as noted above } -void R_Shadow_Stage_Light(void) +void R_Shadow_Stage_LightWithoutShadows(void) { rmeshstate_t m; + memset(&m, 0, sizeof(m)); - R_Mesh_TextureState(&m); - qglActiveTexture(GL_TEXTURE0_ARB); + R_Mesh_State_Texture(&m); - qglEnable(GL_BLEND); - qglBlendFunc(GL_ONE, GL_ONE); GL_Color(1, 1, 1, 1); + GL_BlendFunc(GL_ONE, GL_ONE); + GL_DepthMask(false); + GL_DepthTest(true); + qglDisable(GL_POLYGON_OFFSET_FILL); + + //GL_DepthTest(false); + qglColorMask(1, 1, 1, 1); - qglDepthMask(0); - qglDepthFunc(GL_EQUAL); - qglEnable(GL_STENCIL_TEST); + qglDepthFunc(GL_LEQUAL); + qglDisable(GL_STENCIL_TEST); qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); - // only draw light where this geometry was already rendered AND the - // stencil is 0 (non-zero means shadow) - qglStencilFunc(GL_EQUAL, 0, 0xFF); - qglEnable(GL_CULL_FACE); - qglEnable(GL_DEPTH_TEST); + qglStencilFunc(GL_EQUAL, 128, 0xFF); + r_shadowstage = SHADOWSTAGE_LIGHT; + c_rt_lights++; } -int R_Shadow_Stage_EraseShadowVolumes(void) +void R_Shadow_Stage_LightWithShadows(void) { - if (r_shadow_erasebydrawing.integer) - { - rmeshstate_t m; - memset(&m, 0, sizeof(m)); - R_Mesh_TextureState(&m); - GL_Color(1, 1, 1, 1); - qglColorMask(0, 0, 0, 0); - qglDisable(GL_BLEND); - qglDepthMask(0); - qglDepthFunc(GL_LESS); - qglEnable(GL_STENCIL_TEST); - qglStencilOp(GL_ZERO, GL_ZERO, GL_ZERO); - qglStencilFunc(GL_ALWAYS, 0, 0xFF); - qglDisable(GL_CULL_FACE); - qglDisable(GL_DEPTH_TEST); - r_shadowstage = SHADOWSTAGE_ERASESTENCIL; - return true; - } - else - return false; + rmeshstate_t m; + + memset(&m, 0, sizeof(m)); + R_Mesh_State_Texture(&m); + + GL_Color(1, 1, 1, 1); + GL_BlendFunc(GL_ONE, GL_ONE); + GL_DepthMask(false); + GL_DepthTest(true); + qglDisable(GL_POLYGON_OFFSET_FILL); + + //GL_DepthTest(false); + + qglColorMask(1, 1, 1, 1); + qglDepthFunc(GL_LEQUAL); + qglEnable(GL_STENCIL_TEST); + qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); + // only draw light where this geometry was already rendered AND the + // stencil is 128 (values other than this mean shadow) + qglStencilFunc(GL_EQUAL, 128, 0xFF); + + r_shadowstage = SHADOWSTAGE_LIGHT; + c_rt_lights++; } void R_Shadow_Stage_End(void) { rmeshstate_t m; - // attempt to restore state to what Mesh_State thinks it is - qglDisable(GL_BLEND); - qglBlendFunc(GL_ONE, GL_ZERO); - qglDepthMask(1); - // now restore the rest of the state to normal + + memset(&m, 0, sizeof(m)); + R_Mesh_State_Texture(&m); + GL_Color(1, 1, 1, 1); + GL_BlendFunc(GL_ONE, GL_ZERO); + GL_DepthMask(true); + GL_DepthTest(true); + qglDisable(GL_POLYGON_OFFSET_FILL); + qglColorMask(1, 1, 1, 1); qglDisable(GL_SCISSOR_TEST); qglDepthFunc(GL_LEQUAL); qglDisable(GL_STENCIL_TEST); qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); - qglStencilFunc(GL_ALWAYS, 0, 0xFF); - qglEnable(GL_CULL_FACE); - qglEnable(GL_DEPTH_TEST); - // force mesh state to reset by using various combinations of features - memset(&m, 0, sizeof(m)); - m.blendfunc1 = GL_SRC_ALPHA; - m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA; - R_Mesh_State(&m); - m.blendfunc1 = GL_ONE; - m.blendfunc2 = GL_ZERO; - R_Mesh_State(&m); + qglStencilFunc(GL_ALWAYS, 128, 0xFF); + r_shadowstage = SHADOWSTAGE_NONE; } +#if 0 int R_Shadow_ScissorForBBoxAndSphere(const float *mins, const float *maxs, const float *origin, float radius) { int i, ix1, iy1, ix2, iy2; @@ -694,6 +940,8 @@ int R_Shadow_ScissorForBBoxAndSphere(const float *mins, const float *maxs, const return true; // ok some of it is infront of the view, transform each corner back to // worldspace and then to screenspace and make screen rect + // initialize these variables just to avoid compiler warnings + x1 = y1 = x2 = y2 = 0; for (i = 0;i < 8;i++) { v2[0] = (i & 1) ? smins[0] : smaxs[0]; @@ -758,344 +1006,793 @@ int R_Shadow_ScissorForBBoxAndSphere(const float *mins, const float *maxs, const // set up the scissor rectangle qglScissor(ix1, iy1, ix2 - ix1, iy2 - iy1); qglEnable(GL_SCISSOR_TEST); + c_rt_scissored++; return false; } +#endif -void R_Shadow_GenTexCoords_Attenuation2D1D(float *out2d, float *out1d, int numverts, const float *vertex, const float *svectors, const float *tvectors, const float *normals, const vec3_t relativelightorigin, float lightradius) +int R_Shadow_ScissorForBBox(const float *mins, const float *maxs) { - int i; - float lightvec[3], iradius; - iradius = 0.5f / lightradius; - for (i = 0;i < numverts;i++, vertex += 4, svectors += 4, tvectors += 4, normals += 4, out2d += 4, out1d += 4) - { - VectorSubtract(vertex, relativelightorigin, lightvec); - out2d[0] = 0.5f + DotProduct(svectors, lightvec) * iradius; - out2d[1] = 0.5f + DotProduct(tvectors, lightvec) * iradius; - out2d[2] = 0; - out1d[0] = 0.5f + DotProduct(normals, lightvec) * iradius; - out1d[1] = 0.5f; - out1d[2] = 0; + int i, ix1, iy1, ix2, iy2; + float x1, y1, x2, y2, x, y, f; + vec3_t smins, smaxs; + vec4_t v, v2; + if (!r_shadow_scissor.integer) + return false; + // if view is inside the box, just say yes it's visible + // LordHavoc: for some odd reason scissor seems broken without stencil + // (?!? seems like a driver bug) so abort if gl_stencil is false + if (!gl_stencil || BoxesOverlap(r_origin, r_origin, mins, maxs)) + { + qglDisable(GL_SCISSOR_TEST); + return false; + } + for (i = 0;i < 3;i++) + { + if (vpn[i] >= 0) + { + v[i] = mins[i]; + v2[i] = maxs[i]; + } + else + { + v[i] = maxs[i]; + v2[i] = mins[i]; + } + } + f = DotProduct(vpn, r_origin) + 1; + if (DotProduct(vpn, v2) <= f) + { + // entirely behind nearclip plane + return true; + } + if (DotProduct(vpn, v) >= f) + { + // entirely infront of nearclip plane + x1 = y1 = x2 = y2 = 0; + for (i = 0;i < 8;i++) + { + v[0] = (i & 1) ? mins[0] : maxs[0]; + v[1] = (i & 2) ? mins[1] : maxs[1]; + v[2] = (i & 4) ? mins[2] : maxs[2]; + v[3] = 1.0f; + GL_TransformToScreen(v, v2); + //Con_Printf("%.3f %.3f %.3f %.3f transformed to %.3f %.3f %.3f %.3f\n", v[0], v[1], v[2], v[3], v2[0], v2[1], v2[2], v2[3]); + x = v2[0]; + y = v2[1]; + if (i) + { + if (x1 > x) x1 = x; + if (x2 < x) x2 = x; + if (y1 > y) y1 = y; + if (y2 < y) y2 = y; + } + else + { + x1 = x2 = x; + y1 = y2 = y; + } + } + } + else + { + // clipped by nearclip plane + // this is nasty and crude... + // create viewspace bbox + for (i = 0;i < 8;i++) + { + v[0] = ((i & 1) ? mins[0] : maxs[0]) - r_origin[0]; + v[1] = ((i & 2) ? mins[1] : maxs[1]) - r_origin[1]; + v[2] = ((i & 4) ? mins[2] : maxs[2]) - r_origin[2]; + v2[0] = DotProduct(v, vright); + v2[1] = DotProduct(v, vup); + v2[2] = DotProduct(v, vpn); + if (i) + { + if (smins[0] > v2[0]) smins[0] = v2[0]; + if (smaxs[0] < v2[0]) smaxs[0] = v2[0]; + if (smins[1] > v2[1]) smins[1] = v2[1]; + if (smaxs[1] < v2[1]) smaxs[1] = v2[1]; + if (smins[2] > v2[2]) smins[2] = v2[2]; + if (smaxs[2] < v2[2]) smaxs[2] = v2[2]; + } + else + { + smins[0] = smaxs[0] = v2[0]; + smins[1] = smaxs[1] = v2[1]; + smins[2] = smaxs[2] = v2[2]; + } + } + // now we have a bbox in viewspace + // clip it to the view plane + if (smins[2] < 1) + smins[2] = 1; + // return true if that culled the box + if (smins[2] >= smaxs[2]) + return true; + // ok some of it is infront of the view, transform each corner back to + // worldspace and then to screenspace and make screen rect + // initialize these variables just to avoid compiler warnings + x1 = y1 = x2 = y2 = 0; + for (i = 0;i < 8;i++) + { + v2[0] = (i & 1) ? smins[0] : smaxs[0]; + v2[1] = (i & 2) ? smins[1] : smaxs[1]; + v2[2] = (i & 4) ? smins[2] : smaxs[2]; + v[0] = v2[0] * vright[0] + v2[1] * vup[0] + v2[2] * vpn[0] + r_origin[0]; + v[1] = v2[0] * vright[1] + v2[1] * vup[1] + v2[2] * vpn[1] + r_origin[1]; + v[2] = v2[0] * vright[2] + v2[1] * vup[2] + v2[2] * vpn[2] + r_origin[2]; + v[3] = 1.0f; + GL_TransformToScreen(v, v2); + //Con_Printf("%.3f %.3f %.3f %.3f transformed to %.3f %.3f %.3f %.3f\n", v[0], v[1], v[2], v[3], v2[0], v2[1], v2[2], v2[3]); + x = v2[0]; + y = v2[1]; + if (i) + { + if (x1 > x) x1 = x; + if (x2 < x) x2 = x; + if (y1 > y) y1 = y; + if (y2 < y) y2 = y; + } + else + { + x1 = x2 = x; + y1 = y2 = y; + } + } + /* + // this code doesn't handle boxes with any points behind view properly + x1 = 1000;x2 = -1000; + y1 = 1000;y2 = -1000; + for (i = 0;i < 8;i++) + { + v[0] = (i & 1) ? mins[0] : maxs[0]; + v[1] = (i & 2) ? mins[1] : maxs[1]; + v[2] = (i & 4) ? mins[2] : maxs[2]; + v[3] = 1.0f; + GL_TransformToScreen(v, v2); + //Con_Printf("%.3f %.3f %.3f %.3f transformed to %.3f %.3f %.3f %.3f\n", v[0], v[1], v[2], v[3], v2[0], v2[1], v2[2], v2[3]); + if (v2[2] > 0) + { + x = v2[0]; + y = v2[1]; + + if (x1 > x) x1 = x; + if (x2 < x) x2 = x; + if (y1 > y) y1 = y; + if (y2 < y) y2 = y; + } + } + */ + } + ix1 = x1 - 1.0f; + iy1 = y1 - 1.0f; + ix2 = x2 + 1.0f; + iy2 = y2 + 1.0f; + //Con_Printf("%f %f %f %f\n", x1, y1, x2, y2); + if (ix1 < r_refdef.x) ix1 = r_refdef.x; + if (iy1 < r_refdef.y) iy1 = r_refdef.y; + if (ix2 > r_refdef.x + r_refdef.width) ix2 = r_refdef.x + r_refdef.width; + if (iy2 > r_refdef.y + r_refdef.height) iy2 = r_refdef.y + r_refdef.height; + if (ix2 <= ix1 || iy2 <= iy1) + return true; + // set up the scissor rectangle + qglScissor(ix1, iy1, ix2 - ix1, iy2 - iy1); + qglEnable(GL_SCISSOR_TEST); + c_rt_scissored++; + return false; +} + +void R_Shadow_VertexLighting(int numverts, const float *vertex3f, const float *normal3f, const float *lightcolor, const matrix4x4_t *m) +{ + float *color4f = varray_color4f; + float dist, dot, intensity, v[3], n[3]; + for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4) + { + Matrix4x4_Transform(m, vertex3f, v); + if ((dist = DotProduct(v, v)) < 1) + { + Matrix4x4_Transform3x3(m, normal3f, n); + if ((dot = DotProduct(n, v)) > 0) + { + dist = sqrt(dist); + intensity = pow(1 - dist, r_shadow_attenpower) * r_shadow_attenscale * dot / sqrt(DotProduct(n,n)); + VectorScale(lightcolor, intensity, color4f); + color4f[3] = 1; + } + else + { + VectorClear(color4f); + color4f[3] = 1; + } + } + else + { + VectorClear(color4f); + color4f[3] = 1; + } } } -void R_Shadow_GenTexCoords_Diffuse_Attenuation3D(float *out, int numverts, const float *vertex, const float *svectors, const float *tvectors, const float *normals, const vec3_t relativelightorigin, float lightradius) +void R_Shadow_VertexLightingWithXYAttenuationTexture(int numverts, const float *vertex3f, const float *normal3f, const float *lightcolor, const matrix4x4_t *m) { - int i; - float lightvec[3], iradius; - iradius = 0.5f / lightradius; - for (i = 0;i < numverts;i++, vertex += 4, svectors += 4, tvectors += 4, normals += 4, out += 4) + float *color4f = varray_color4f; + float dist, dot, intensity, v[3], n[3]; + for (;numverts > 0;numverts--, vertex3f += 3, normal3f += 3, color4f += 4) + { + Matrix4x4_Transform(m, vertex3f, v); + if ((dist = fabs(v[2])) < 1) + { + Matrix4x4_Transform3x3(m, normal3f, n); + if ((dot = DotProduct(n, v)) > 0) + { + intensity = pow(1 - dist, r_shadow_attenpower) * r_shadow_attenscale * dot / sqrt(DotProduct(n,n)); + VectorScale(lightcolor, intensity, color4f); + color4f[3] = 1; + } + else + { + VectorClear(color4f); + color4f[3] = 1; + } + } + else + { + VectorClear(color4f); + color4f[3] = 1; + } + } +} + +// FIXME: this should be done in a vertex program when possible +// FIXME: if vertex program not available, this would really benefit from 3DNow! or SSE +void R_Shadow_Transform_Vertex3f_TexCoord3f(float *tc3f, int numverts, const float *vertex3f, const matrix4x4_t *matrix) +{ + do { - VectorSubtract(vertex, relativelightorigin, lightvec); - out[0] = 0.5f + DotProduct(svectors, lightvec) * iradius; - out[1] = 0.5f + DotProduct(tvectors, lightvec) * iradius; - out[2] = 0.5f + DotProduct(normals, lightvec) * iradius; + tc3f[0] = vertex3f[0] * matrix->m[0][0] + vertex3f[1] * matrix->m[0][1] + vertex3f[2] * matrix->m[0][2] + matrix->m[0][3]; + tc3f[1] = vertex3f[0] * matrix->m[1][0] + vertex3f[1] * matrix->m[1][1] + vertex3f[2] * matrix->m[1][2] + matrix->m[1][3]; + tc3f[2] = vertex3f[0] * matrix->m[2][0] + vertex3f[1] * matrix->m[2][1] + vertex3f[2] * matrix->m[2][2] + matrix->m[2][3]; + vertex3f += 3; + tc3f += 3; } + while (--numverts); } -void R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(float *out, int numverts, const float *vertex, const float *svectors, const float *tvectors, const float *normals, const vec3_t relativelightorigin) +void R_Shadow_Transform_Vertex3f_TexCoord2f(float *tc2f, int numverts, const float *vertex3f, const matrix4x4_t *matrix) { - int i; - float lightdir[3]; - for (i = 0;i < numverts;i++, vertex += 4, svectors += 4, tvectors += 4, normals += 4, out += 4) + do { - VectorSubtract(vertex, relativelightorigin, lightdir); - // the cubemap normalizes this for us - out[0] = DotProduct(svectors, lightdir); - out[1] = DotProduct(tvectors, lightdir); - out[2] = DotProduct(normals, lightdir); + tc2f[0] = vertex3f[0] * matrix->m[0][0] + vertex3f[1] * matrix->m[0][1] + vertex3f[2] * matrix->m[0][2] + matrix->m[0][3]; + tc2f[1] = vertex3f[0] * matrix->m[1][0] + vertex3f[1] * matrix->m[1][1] + vertex3f[2] * matrix->m[1][2] + matrix->m[1][3]; + vertex3f += 3; + tc2f += 2; } + while (--numverts); } -void R_Shadow_GenTexCoords_Specular_Attenuation3D(float *out, int numverts, const float *vertex, const float *svectors, const float *tvectors, const float *normals, const vec3_t relativelightorigin, const vec3_t relativeeyeorigin, float lightradius) +void R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(float *out3f, int numverts, const float *vertex3f, const float *svector3f, const float *tvector3f, const float *normal3f, const vec3_t relativelightorigin) { int i; - float lightdir[3], eyedir[3], halfdir[3], lightdirlen, iradius; - iradius = 0.5f / lightradius; - for (i = 0;i < numverts;i++, vertex += 4, svectors += 4, tvectors += 4, normals += 4, out += 4) + float lightdir[3]; + for (i = 0;i < numverts;i++, vertex3f += 3, svector3f += 3, tvector3f += 3, normal3f += 3, out3f += 3) { - VectorSubtract(vertex, relativelightorigin, lightdir); - // this is used later to make the attenuation correct - lightdirlen = sqrt(DotProduct(lightdir, lightdir)) * iradius; - VectorNormalizeFast(lightdir); - VectorSubtract(vertex, relativeeyeorigin, eyedir); - VectorNormalizeFast(eyedir); - VectorAdd(lightdir, eyedir, halfdir); - VectorNormalizeFast(halfdir); - out[0] = 0.5f + DotProduct(svectors, halfdir) * lightdirlen; - out[1] = 0.5f + DotProduct(tvectors, halfdir) * lightdirlen; - out[2] = 0.5f + DotProduct(normals, halfdir) * lightdirlen; + VectorSubtract(vertex3f, relativelightorigin, lightdir); + // the cubemap normalizes this for us + out3f[0] = DotProduct(svector3f, lightdir); + out3f[1] = DotProduct(tvector3f, lightdir); + out3f[2] = DotProduct(normal3f, lightdir); } } -void R_Shadow_GenTexCoords_Specular_NormalCubeMap(float *out, int numverts, const float *vertex, const float *svectors, const float *tvectors, const float *normals, const vec3_t relativelightorigin, const vec3_t relativeeyeorigin) +void R_Shadow_GenTexCoords_Specular_NormalCubeMap(float *out3f, int numverts, const float *vertex3f, const float *svector3f, const float *tvector3f, const float *normal3f, const vec3_t relativelightorigin, const vec3_t relativeeyeorigin) { int i; float lightdir[3], eyedir[3], halfdir[3]; - for (i = 0;i < numverts;i++, vertex += 4, svectors += 4, tvectors += 4, normals += 4, out += 4) + for (i = 0;i < numverts;i++, vertex3f += 3, svector3f += 3, tvector3f += 3, normal3f += 3, out3f += 3) { - VectorSubtract(vertex, relativelightorigin, lightdir); + VectorSubtract(vertex3f, relativelightorigin, lightdir); VectorNormalizeFast(lightdir); - VectorSubtract(vertex, relativeeyeorigin, eyedir); + VectorSubtract(vertex3f, relativeeyeorigin, eyedir); VectorNormalizeFast(eyedir); VectorAdd(lightdir, eyedir, halfdir); // the cubemap normalizes this for us - out[0] = DotProduct(svectors, halfdir); - out[1] = DotProduct(tvectors, halfdir); - out[2] = DotProduct(normals, halfdir); + out3f[0] = DotProduct(svector3f, halfdir); + out3f[1] = DotProduct(tvector3f, halfdir); + out3f[2] = DotProduct(normal3f, halfdir); } } -void R_Shadow_GenTexCoords_LightCubeMap(float *out, int numverts, const float *vertex, const vec3_t relativelightorigin) +void R_Shadow_DiffuseLighting(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, float lightradius, const float *lightcolor, const matrix4x4_t *matrix_modeltofilter, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *basetexture, rtexture_t *bumptexture, rtexture_t *lightcubemap) { - int i; - // FIXME: this needs to be written - // this code assumes the vertices are in worldspace (a false assumption) - for (i = 0;i < numverts;i++, vertex += 4, out += 4) - VectorSubtract(vertex, relativelightorigin, out); + int renders; + float color[3], color2[3]; + rmeshstate_t m; + GL_VertexPointer(vertex3f); + if (gl_dot3arb && gl_texturecubemap && gl_combine.integer && gl_stencil) + { + if (!bumptexture) + bumptexture = r_shadow_blankbumptexture; + GL_Color(1,1,1,1); + // colorscale accounts for how much we multiply the brightness during combine + // mult is how many times the final pass of the lighting will be + // performed to get more brightness than otherwise possible + // limit mult to 64 for sanity sake + if (r_shadow_texture3d.integer && r_textureunits.integer >= 4) + { + // 3/2 3D combine path (Geforce3, Radeon 8500) + memset(&m, 0, sizeof(m)); + m.tex[0] = R_GetTexture(bumptexture); + m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture); + m.tex3d[2] = R_GetTexture(r_shadow_attenuation3dtexture); + m.texcombinergb[0] = GL_REPLACE; + m.texcombinergb[1] = GL_DOT3_RGBA_ARB; + m.pointer_texcoord[0] = texcoord2f; + m.pointer_texcoord[1] = varray_texcoord3f[1]; + m.pointer_texcoord[2] = varray_texcoord3f[2]; + R_Mesh_State_Texture(&m); + qglColorMask(0,0,0,1); + GL_BlendFunc(GL_ONE, GL_ZERO); + R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin); + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[2], numverts, vertex3f, matrix_modeltoattenuationxyz); + R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.tex[0] = R_GetTexture(basetexture); + m.texcubemap[1] = R_GetTexture(lightcubemap); + m.pointer_texcoord[0] = texcoord2f; + m.pointer_texcoord[1] = lightcubemap ? varray_texcoord3f[1] : NULL; + R_Mesh_State_Texture(&m); + qglColorMask(1,1,1,0); + GL_BlendFunc(GL_DST_ALPHA, GL_ONE); + if (lightcubemap) + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltofilter); + VectorScale(lightcolor, r_colorscale * r_shadow_lightintensityscale.value, color2); + for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--) + { + color[0] = bound(0, color2[0], 1); + color[1] = bound(0, color2[1], 1); + color[2] = bound(0, color2[2], 1); + GL_Color(color[0], color[1], color[2], 1); + R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + } + } + else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && lightcubemap) + { + // 1/2/2 3D combine path (original Radeon) + memset(&m, 0, sizeof(m)); + m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture); + m.pointer_texcoord[0] = varray_texcoord3f[0]; + R_Mesh_State_Texture(&m); + qglColorMask(0,0,0,1); + GL_BlendFunc(GL_ONE, GL_ZERO); + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[0], numverts, vertex3f, matrix_modeltoattenuationxyz); + R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.tex[0] = R_GetTexture(bumptexture); + m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture); + m.texcombinergb[0] = GL_REPLACE; + m.texcombinergb[1] = GL_DOT3_RGBA_ARB; + m.pointer_texcoord[0] = texcoord2f; + m.pointer_texcoord[1] = varray_texcoord3f[1]; + R_Mesh_State_Texture(&m); + GL_BlendFunc(GL_DST_ALPHA, GL_ZERO); + R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin); + R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.tex[0] = R_GetTexture(basetexture); + m.texcubemap[1] = R_GetTexture(lightcubemap); + m.pointer_texcoord[0] = texcoord2f; + m.pointer_texcoord[1] = lightcubemap ? varray_texcoord3f[1] : NULL; + R_Mesh_State_Texture(&m); + qglColorMask(1,1,1,0); + GL_BlendFunc(GL_DST_ALPHA, GL_ONE); + if (lightcubemap) + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltofilter); + VectorScale(lightcolor, r_colorscale * r_shadow_lightintensityscale.value, color2); + for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--) + { + color[0] = bound(0, color2[0], 1); + color[1] = bound(0, color2[1], 1); + color[2] = bound(0, color2[2], 1); + GL_Color(color[0], color[1], color[2], 1); + R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + } + } + else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && !lightcubemap) + { + // 2/2 3D combine path (original Radeon) + memset(&m, 0, sizeof(m)); + m.tex[0] = R_GetTexture(bumptexture); + m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture); + m.texcombinergb[0] = GL_REPLACE; + m.texcombinergb[1] = GL_DOT3_RGBA_ARB; + m.pointer_texcoord[0] = texcoord2f; + m.pointer_texcoord[1] = varray_texcoord3f[1]; + R_Mesh_State_Texture(&m); + qglColorMask(0,0,0,1); + GL_BlendFunc(GL_ONE, GL_ZERO); + R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin); + R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.tex[0] = R_GetTexture(basetexture); + m.tex3d[1] = R_GetTexture(r_shadow_attenuation3dtexture); + m.pointer_texcoord[0] = texcoord2f; + m.pointer_texcoord[1] = varray_texcoord3f[1]; + R_Mesh_State_Texture(&m); + qglColorMask(1,1,1,0); + GL_BlendFunc(GL_DST_ALPHA, GL_ONE); + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltoattenuationxyz); + VectorScale(lightcolor, r_colorscale * r_shadow_lightintensityscale.value, color2); + for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--) + { + color[0] = bound(0, color2[0], 1); + color[1] = bound(0, color2[1], 1); + color[2] = bound(0, color2[2], 1); + GL_Color(color[0], color[1], color[2], 1); + R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + } + } + else if (r_textureunits.integer >= 4) + { + // 4/2 2D combine path (Geforce3, Radeon 8500) + memset(&m, 0, sizeof(m)); + m.tex[0] = R_GetTexture(bumptexture); + m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture); + m.texcombinergb[0] = GL_REPLACE; + m.texcombinergb[1] = GL_DOT3_RGBA_ARB; + m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture); + m.tex[3] = R_GetTexture(r_shadow_attenuation2dtexture); + m.pointer_texcoord[0] = texcoord2f; + m.pointer_texcoord[1] = varray_texcoord3f[1]; + m.pointer_texcoord[2] = varray_texcoord2f[2]; + m.pointer_texcoord[3] = varray_texcoord2f[3]; + R_Mesh_State_Texture(&m); + qglColorMask(0,0,0,1); + GL_BlendFunc(GL_ONE, GL_ZERO); + R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin); + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[2], numverts, vertex3f, matrix_modeltoattenuationxyz); + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[3], numverts, vertex3f, matrix_modeltoattenuationz); + R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.tex[0] = R_GetTexture(basetexture); + m.texcubemap[1] = R_GetTexture(lightcubemap); + m.pointer_texcoord[0] = texcoord2f; + m.pointer_texcoord[1] = lightcubemap ? varray_texcoord3f[1] : NULL; + R_Mesh_State_Texture(&m); + qglColorMask(1,1,1,0); + GL_BlendFunc(GL_DST_ALPHA, GL_ONE); + if (lightcubemap) + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltofilter); + VectorScale(lightcolor, r_colorscale * r_shadow_lightintensityscale.value, color2); + for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--) + { + color[0] = bound(0, color2[0], 1); + color[1] = bound(0, color2[1], 1); + color[2] = bound(0, color2[2], 1); + GL_Color(color[0], color[1], color[2], 1); + R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + } + } + else + { + // 2/2/2 2D combine path (any dot3 card) + memset(&m, 0, sizeof(m)); + m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture); + m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture); + m.pointer_texcoord[0] = varray_texcoord2f[0]; + m.pointer_texcoord[1] = varray_texcoord2f[1]; + R_Mesh_State_Texture(&m); + qglColorMask(0,0,0,1); + GL_BlendFunc(GL_ONE, GL_ZERO); + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[0], numverts, vertex3f, matrix_modeltoattenuationxyz); + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[1], numverts, vertex3f, matrix_modeltoattenuationz); + R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.tex[0] = R_GetTexture(bumptexture); + m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture); + m.texcombinergb[0] = GL_REPLACE; + m.texcombinergb[1] = GL_DOT3_RGBA_ARB; + m.pointer_texcoord[0] = texcoord2f; + m.pointer_texcoord[1] = varray_texcoord3f[1]; + R_Mesh_State_Texture(&m); + GL_BlendFunc(GL_DST_ALPHA, GL_ZERO); + R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin); + R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.tex[0] = R_GetTexture(basetexture); + m.texcubemap[1] = R_GetTexture(lightcubemap); + m.pointer_texcoord[0] = texcoord2f; + m.pointer_texcoord[1] = lightcubemap ? varray_texcoord3f[1] : NULL; + R_Mesh_State_Texture(&m); + qglColorMask(1,1,1,0); + GL_BlendFunc(GL_DST_ALPHA, GL_ONE); + if (lightcubemap) + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltofilter); + VectorScale(lightcolor, r_colorscale * r_shadow_lightintensityscale.value, color2); + for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--) + { + color[0] = bound(0, color2[0], 1); + color[1] = bound(0, color2[1], 1); + color[2] = bound(0, color2[2], 1); + GL_Color(color[0], color[1], color[2], 1); + R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + } + } + } + else + { + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE); + GL_DepthMask(false); + GL_DepthTest(true); + GL_ColorPointer(varray_color4f); + VectorScale(lightcolor, r_colorscale * r_shadow_lightintensityscale.value, color2); + memset(&m, 0, sizeof(m)); + 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); + m.pointer_texcoord[1] = varray_texcoord2f[1]; + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[1], numverts, vertex3f, matrix_modeltoattenuationxyz); + } + R_Mesh_State_Texture(&m); + for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--) + { + color[0] = bound(0, color2[0], 1); + color[1] = bound(0, color2[1], 1); + color[2] = bound(0, color2[2], 1); + if (r_textureunits.integer >= 2) + R_Shadow_VertexLightingWithXYAttenuationTexture(numverts, vertex3f, normal3f, color, matrix_modeltofilter); + else + R_Shadow_VertexLighting(numverts, vertex3f, normal3f, color, matrix_modeltofilter); + R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + } + } } -void R_Shadow_DiffuseLighting(int numverts, int numtriangles, const int *elements, const float *svectors, const float *tvectors, const float *normals, const float *texcoords, const float *relativelightorigin, float lightradius, const float *lightcolor, rtexture_t *basetexture, rtexture_t *bumptexture, rtexture_t *lightcubemap) +void R_Shadow_SpecularLighting(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, float lightradius, const float *lightcolor, const matrix4x4_t *matrix_modeltofilter, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *glosstexture, rtexture_t *bumptexture, rtexture_t *lightcubemap) { - int renders, mult; - float scale, colorscale; + int renders; + float color[3], color2[3]; rmeshstate_t m; - memset(&m, 0, sizeof(m)); + if (!gl_dot3arb || !gl_texturecubemap || !gl_combine.integer || !gl_stencil) + return; if (!bumptexture) bumptexture = r_shadow_blankbumptexture; - // colorscale accounts for how much we multiply the brightness during combine - // mult is how many times the final pass of the lighting will be - // performed to get more brightness than otherwise possible - // limit mult to 64 for sanity sake - if (r_shadow_texture3d.integer) + if (!glosstexture) + glosstexture = r_shadow_blankglosstexture; + if (r_shadow_gloss.integer >= 2 || (r_shadow_gloss.integer >= 1 && glosstexture != r_shadow_blankglosstexture)) { - if (r_textureunits.integer >= 4 && !lightcubemap) + GL_VertexPointer(vertex3f); + GL_Color(1,1,1,1); + if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && lightcubemap /*&& gl_support_blendsquare*/) // FIXME: detect blendsquare! { - // 4 texture 3D combine path, one pass, no light cubemap support + // 2/0/0/1/2 3D combine blendsquare path + memset(&m, 0, sizeof(m)); m.tex[0] = R_GetTexture(bumptexture); - m.tex3d[1] = R_GetTexture(r_shadow_normalsattenuationtexture); - m.tex[2] = R_GetTexture(basetexture); - m.tex[3] = R_GetTexture(r_shadow_blankwhitetexture); - m.texcombinergb[0] = GL_REPLACE; - m.texcombinergb[1] = GL_DOT3_RGB_ARB; - m.texcombinergb[2] = GL_MODULATE; - m.texcombinergb[3] = GL_MODULATE; - m.texrgbscale[1] = 1; - m.texrgbscale[3] = 4; - R_Mesh_TextureState(&m); - memcpy(varray_texcoord[0], texcoords, numverts * sizeof(float[4])); - memcpy(varray_texcoord[2], texcoords, numverts * sizeof(float[4])); - R_Shadow_GenTexCoords_Diffuse_Attenuation3D(varray_texcoord[1], numverts, varray_vertex, svectors, tvectors, normals, relativelightorigin, lightradius); - qglActiveTexture(GL_TEXTURE3_ARB); - qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PRIMARY_COLOR_ARB); - colorscale = r_colorscale * 0.25f * r_shadow_lightintensityscale.value; - for (mult = 1, scale = ixtable[mult];mult < 64 && (lightcolor[0] * scale * colorscale > 1 || lightcolor[1] * scale * colorscale > 1 || lightcolor[2] * scale * colorscale > 1);mult++, scale = ixtable[mult]); - colorscale *= scale; - GL_Color(lightcolor[0] * colorscale, lightcolor[1] * colorscale, lightcolor[2] * colorscale, 1); - for (renders = 0;renders < mult;renders++) + m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture); + m.texcombinergb[1] = GL_DOT3_RGBA_ARB; + m.pointer_texcoord[0] = texcoord2f; + m.pointer_texcoord[1] = varray_texcoord3f[1]; + R_Mesh_State_Texture(&m); + qglColorMask(0,0,0,1); + // this squares the result + GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO); + R_Shadow_GenTexCoords_Specular_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin, relativeeyeorigin); + R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + R_Mesh_State_Texture(&m); + // 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); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.tex3d[0] = R_GetTexture(r_shadow_attenuation3dtexture); + m.pointer_texcoord[0] = varray_texcoord3f[0]; + R_Mesh_State_Texture(&m); + GL_BlendFunc(GL_DST_ALPHA, GL_ZERO); + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[0], numverts, vertex3f, matrix_modeltoattenuationxyz); + R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.tex[0] = R_GetTexture(glosstexture); + m.texcubemap[1] = R_GetTexture(lightcubemap); + m.pointer_texcoord[0] = texcoord2f; + m.pointer_texcoord[1] = lightcubemap ? varray_texcoord3f[1] : NULL; + R_Mesh_State_Texture(&m); + qglColorMask(1,1,1,0); + GL_BlendFunc(GL_DST_ALPHA, GL_ONE); + if (lightcubemap) + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltofilter); + VectorScale(lightcolor, r_colorscale * r_shadow_lightintensityscale.value * 0.25f, color2); + for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--) + { + color[0] = bound(0, color2[0], 1); + color[1] = bound(0, color2[1], 1); + color[2] = bound(0, color2[2], 1); + GL_Color(color[0], color[1], color[2], 1); R_Mesh_Draw(numverts, numtriangles, elements); - qglActiveTexture(GL_TEXTURE3_ARB); - qglTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + } } - else + else if (r_shadow_texture3d.integer && r_textureunits.integer >= 2 && !lightcubemap /*&& gl_support_blendsquare*/) // FIXME: detect blendsquare! { - // 2 texture no3D combine path, two pass + // 2/0/0/2 3D combine blendsquare path + memset(&m, 0, sizeof(m)); m.tex[0] = R_GetTexture(bumptexture); - m.tex3d[1] = R_GetTexture(r_shadow_normalsattenuationtexture); - m.texcombinergb[0] = GL_REPLACE; + m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture); m.texcombinergb[1] = GL_DOT3_RGBA_ARB; - m.texalphascale[1] = 1; - R_Mesh_TextureState(&m); + m.pointer_texcoord[0] = texcoord2f; + m.pointer_texcoord[1] = varray_texcoord3f[1]; + R_Mesh_State_Texture(&m); qglColorMask(0,0,0,1); - qglDisable(GL_BLEND); - GL_Color(1,1,1,1); - memcpy(varray_texcoord[0], texcoords, numverts * sizeof(float[4])); - R_Shadow_GenTexCoords_Diffuse_Attenuation3D(varray_texcoord[1], numverts, varray_vertex, svectors, tvectors, normals, relativelightorigin, lightradius); + // this squares the result + GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO); + R_Shadow_GenTexCoords_Specular_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin, relativeeyeorigin); + R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + R_Mesh_State_Texture(&m); + // 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); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.tex[0] = R_GetTexture(glosstexture); + m.tex3d[1] = R_GetTexture(r_shadow_attenuation3dtexture); + m.pointer_texcoord[0] = texcoord2f; + m.pointer_texcoord[1] = varray_texcoord3f[1]; + R_Mesh_State_Texture(&m); + qglColorMask(1,1,1,0); + GL_BlendFunc(GL_DST_ALPHA, GL_ONE); + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltoattenuationxyz); + VectorScale(lightcolor, r_colorscale * r_shadow_lightintensityscale.value * 0.25f, color2); + for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--) + { + color[0] = bound(0, color2[0], 1); + color[1] = bound(0, color2[1], 1); + color[2] = bound(0, color2[2], 1); + GL_Color(color[0], color[1], color[2], 1); + R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + } + } + else if (r_textureunits.integer >= 2 /*&& gl_support_blendsquare*/) // FIXME: detect blendsquare! + { + // 2/0/0/2/2 2D combine blendsquare path + memset(&m, 0, sizeof(m)); + m.tex[0] = R_GetTexture(bumptexture); + m.texcubemap[1] = R_GetTexture(r_shadow_normalcubetexture); + m.texcombinergb[1] = GL_DOT3_RGBA_ARB; + m.pointer_texcoord[0] = texcoord2f; + m.pointer_texcoord[1] = varray_texcoord3f[1]; + R_Mesh_State_Texture(&m); + qglColorMask(0,0,0,1); + // this squares the result + GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO); + R_Shadow_GenTexCoords_Specular_NormalCubeMap(varray_texcoord3f[1], numverts, vertex3f, svector3f, tvector3f, normal3f, relativelightorigin, relativeeyeorigin); + R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + R_Mesh_State_Texture(&m); + // 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); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + + memset(&m, 0, sizeof(m)); + m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture); + m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture); + m.pointer_texcoord[0] = varray_texcoord2f[0]; + m.pointer_texcoord[1] = varray_texcoord2f[1]; + R_Mesh_State_Texture(&m); + GL_BlendFunc(GL_DST_ALPHA, GL_ZERO); + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[0], numverts, vertex3f, matrix_modeltoattenuationxyz); + R_Shadow_Transform_Vertex3f_TexCoord2f(varray_texcoord2f[1], numverts, vertex3f, matrix_modeltoattenuationz); + R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; - m.tex[0] = R_GetTexture(basetexture); - m.tex3d[1] = 0; + memset(&m, 0, sizeof(m)); + m.tex[0] = R_GetTexture(glosstexture); m.texcubemap[1] = R_GetTexture(lightcubemap); - m.texcombinergb[0] = GL_MODULATE; - m.texcombinergb[1] = GL_MODULATE; - m.texrgbscale[1] = 1; - m.texalphascale[1] = 1; - R_Mesh_TextureState(&m); - qglColorMask(1,1,1,1); - qglBlendFunc(GL_DST_ALPHA, GL_ONE); - qglEnable(GL_BLEND); + m.pointer_texcoord[0] = texcoord2f; + m.pointer_texcoord[1] = lightcubemap ? varray_texcoord3f[1] : NULL; + R_Mesh_State_Texture(&m); + qglColorMask(1,1,1,0); + GL_BlendFunc(GL_DST_ALPHA, GL_ONE); if (lightcubemap) - R_Shadow_GenTexCoords_LightCubeMap(varray_texcoord[1], numverts, varray_vertex, relativelightorigin); - - colorscale = r_colorscale * 1.0f * r_shadow_lightintensityscale.value; - for (mult = 1, scale = ixtable[mult];mult < 64 && (lightcolor[0] * scale * colorscale > 1 || lightcolor[1] * scale * colorscale > 1 || lightcolor[2] * scale * colorscale > 1);mult++, scale = ixtable[mult]); - colorscale *= scale; - GL_Color(lightcolor[0] * colorscale, lightcolor[1] * colorscale, lightcolor[2] * colorscale, 1); - for (renders = 0;renders < mult;renders++) + R_Shadow_Transform_Vertex3f_TexCoord3f(varray_texcoord3f[1], numverts, vertex3f, matrix_modeltofilter); + VectorScale(lightcolor, r_colorscale * r_shadow_lightintensityscale.value * 0.25f, color2); + for (renders = 0;renders < 64 && (color2[0] > 0 || color2[1] > 0 || color2[2] > 0);renders++, color2[0]--, color2[1]--, color2[2]--) + { + color[0] = bound(0, color2[0], 1); + color[1] = bound(0, color2[1], 1); + color[2] = bound(0, color2[2], 1); + GL_Color(color[0], color[1], color[2], 1); R_Mesh_Draw(numverts, numtriangles, elements); + c_rt_lightmeshes++; + c_rt_lighttris += numtriangles; + } } } - else if (r_textureunits.integer >= 4) - { - // 4 texture no3D combine path, two pass - m.tex[0] = R_GetTexture(bumptexture); - m.texcubemap[1] = R_GetTexture(r_shadow_normalscubetexture); - m.texcombinergb[0] = GL_REPLACE; - m.texcombinergb[1] = GL_DOT3_RGBA_ARB; - m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture); - m.tex[3] = R_GetTexture(r_shadow_attenuation2dtexture); - R_Mesh_TextureState(&m); - qglColorMask(0,0,0,1); - qglDisable(GL_BLEND); - GL_Color(1,1,1,1); - memcpy(varray_texcoord[0], texcoords, numverts * sizeof(float[4])); - R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord[1], numverts, varray_vertex, svectors, tvectors, normals, relativelightorigin); - R_Shadow_GenTexCoords_Attenuation2D1D(varray_texcoord[2], varray_texcoord[3], numverts, varray_vertex, svectors, tvectors, normals, relativelightorigin, lightradius); - R_Mesh_Draw(numverts, numtriangles, elements); - - m.tex[0] = R_GetTexture(basetexture); - m.texcubemap[1] = R_GetTexture(lightcubemap); - m.texcombinergb[0] = GL_MODULATE; - m.texcombinergb[1] = GL_MODULATE; - m.tex[2] = 0; - m.tex[3] = 0; - R_Mesh_TextureState(&m); - qglColorMask(1,1,1,1); - qglBlendFunc(GL_DST_ALPHA, GL_ONE); - qglEnable(GL_BLEND); - if (lightcubemap) - R_Shadow_GenTexCoords_LightCubeMap(varray_texcoord[1], numverts, varray_vertex, relativelightorigin); - - colorscale = r_colorscale * 1.0f * r_shadow_lightintensityscale.value; - for (mult = 1, scale = ixtable[mult];mult < 64 && (lightcolor[0] * scale * colorscale > 1 || lightcolor[1] * scale * colorscale > 1 || lightcolor[2] * scale * colorscale > 1);mult++, scale = ixtable[mult]); - colorscale *= scale; - GL_Color(lightcolor[0] * colorscale, lightcolor[1] * colorscale, lightcolor[2] * colorscale, 1); - for (renders = 0;renders < mult;renders++) - R_Mesh_Draw(numverts, numtriangles, elements); - } - else - { - // 2 texture no3D combine path, three pass - m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture); - m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture); - R_Mesh_TextureState(&m); - qglColorMask(0,0,0,1); - qglDisable(GL_BLEND); - GL_Color(1,1,1,1); - R_Shadow_GenTexCoords_Attenuation2D1D(varray_texcoord[0], varray_texcoord[1], numverts, varray_vertex, svectors, tvectors, normals, relativelightorigin, lightradius); - R_Mesh_Draw(numverts, numtriangles, elements); - - m.tex[0] = R_GetTexture(bumptexture); - m.tex[1] = 0; - m.texcubemap[1] = R_GetTexture(r_shadow_normalscubetexture); - m.texcombinergb[1] = GL_DOT3_RGBA_ARB; - R_Mesh_TextureState(&m); - qglBlendFunc(GL_DST_ALPHA, GL_ZERO); - qglEnable(GL_BLEND); - memcpy(varray_texcoord[0], texcoords, numverts * sizeof(float[4])); - R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord[1], numverts, varray_vertex, svectors, tvectors, normals, relativelightorigin); - R_Mesh_Draw(numverts, numtriangles, elements); - - m.tex[0] = R_GetTexture(basetexture); - m.texcubemap[1] = R_GetTexture(lightcubemap); - m.texcombinergb[1] = GL_MODULATE; - R_Mesh_TextureState(&m); - qglColorMask(1,1,1,1); - qglBlendFunc(GL_DST_ALPHA, GL_ONE); - if (lightcubemap) - R_Shadow_GenTexCoords_LightCubeMap(varray_texcoord[1], numverts, varray_vertex, relativelightorigin); - - colorscale = r_colorscale * 1.0f * r_shadow_lightintensityscale.value; - for (mult = 1, scale = ixtable[mult];mult < 64 && (lightcolor[0] * scale * colorscale > 1 || lightcolor[1] * scale * colorscale > 1 || lightcolor[2] * scale * colorscale > 1);mult++, scale = ixtable[mult]); - colorscale *= scale; - GL_Color(lightcolor[0] * colorscale, lightcolor[1] * colorscale, lightcolor[2] * colorscale, 1); - for (renders = 0;renders < mult;renders++) - R_Mesh_Draw(numverts, numtriangles, elements); - } -} - -void R_Shadow_SpecularLighting(int numverts, int numtriangles, const int *elements, const float *svectors, const float *tvectors, const float *normals, const float *texcoords, const float *relativelightorigin, const float *relativeeyeorigin, float lightradius, const float *lightcolor, rtexture_t *glosstexture, rtexture_t *bumptexture, rtexture_t *lightcubemap) -{ - int renders, mult; - float scale, colorscale; - rmeshstate_t m; - memset(&m, 0, sizeof(m)); - if (!bumptexture) - bumptexture = r_shadow_blankbumptexture; - if (!glosstexture) - glosstexture = r_shadow_blankglosstexture; - if (r_shadow_gloss.integer >= 2 || (r_shadow_gloss.integer >= 1 && glosstexture != r_shadow_blankglosstexture)) - { - // 2 texture no3D combine path, five pass - memset(&m, 0, sizeof(m)); - - m.tex[0] = R_GetTexture(bumptexture); - m.texcubemap[1] = R_GetTexture(r_shadow_normalscubetexture); - m.texcombinergb[1] = GL_DOT3_RGBA_ARB; - R_Mesh_TextureState(&m); - qglColorMask(0,0,0,1); - qglDisable(GL_BLEND); - GL_Color(1,1,1,1); - memcpy(varray_texcoord[0], texcoords, numverts * sizeof(float[4])); - R_Shadow_GenTexCoords_Specular_NormalCubeMap(varray_texcoord[1], numverts, varray_vertex, svectors, tvectors, normals, relativelightorigin, relativeeyeorigin); - R_Mesh_Draw(numverts, numtriangles, elements); - - m.tex[0] = 0; - m.texcubemap[1] = 0; - m.texcombinergb[1] = GL_MODULATE; - R_Mesh_TextureState(&m); - // square alpha in framebuffer a few times to make it shiny - qglBlendFunc(GL_ZERO, GL_DST_ALPHA); - qglEnable(GL_BLEND); - // these comments are a test run through this math for intensity 0.5 - // 0.5 * 0.5 = 0.25 - R_Mesh_Draw(numverts, numtriangles, elements); - // 0.25 * 0.25 = 0.0625 - R_Mesh_Draw(numverts, numtriangles, elements); - // 0.0625 * 0.0625 = 0.00390625 - R_Mesh_Draw(numverts, numtriangles, elements); - - m.tex[0] = R_GetTexture(r_shadow_attenuation2dtexture); - m.tex[1] = R_GetTexture(r_shadow_attenuation2dtexture); - R_Mesh_TextureState(&m); - qglBlendFunc(GL_DST_ALPHA, GL_ZERO); - R_Shadow_GenTexCoords_Attenuation2D1D(varray_texcoord[0], varray_texcoord[1], numverts, varray_vertex, svectors, tvectors, normals, relativelightorigin, lightradius); - R_Mesh_Draw(numverts, numtriangles, elements); - - m.tex[0] = R_GetTexture(glosstexture); - m.texcubemap[1] = R_GetTexture(lightcubemap); - R_Mesh_TextureState(&m); - qglColorMask(1,1,1,1); - qglBlendFunc(GL_DST_ALPHA, GL_ONE); - memcpy(varray_texcoord[0], texcoords, numverts * sizeof(float[4])); - if (lightcubemap) - R_Shadow_GenTexCoords_LightCubeMap(varray_texcoord[1], numverts, varray_vertex, relativelightorigin); - - // the 0.25f makes specular lighting much dimmer than diffuse (intentionally) - colorscale = r_colorscale * 0.25f * r_shadow_lightintensityscale.value; - for (mult = 1, scale = ixtable[mult];mult < 64 && (lightcolor[0] * scale * colorscale > 1 || lightcolor[1] * scale * colorscale > 1 || lightcolor[2] * scale * colorscale > 1);mult++, scale = ixtable[mult]); - colorscale *= scale; - GL_Color(lightcolor[0] * colorscale, lightcolor[1] * colorscale, lightcolor[2] * colorscale, 1); - for (renders = 0;renders < mult;renders++) - R_Mesh_Draw(numverts, numtriangles, elements); - } } -#define PRECOMPUTEDSHADOWVOLUMES 1 void R_Shadow_DrawWorldLightShadowVolume(matrix4x4_t *matrix, worldlight_t *light) { -#if PRECOMPUTEDSHADOWVOLUMES R_Mesh_Matrix(matrix); R_Shadow_RenderShadowMeshVolume(light->shadowvolume); -#else - shadowmesh_t *mesh; - R_Mesh_Matrix(matrix); - for (mesh = light->shadowvolume;mesh;mesh = mesh->next) - { - R_Mesh_ResizeCheck(mesh->numverts * 2); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); - R_Shadow_Volume(mesh->numverts, mesh->numtriangles, varray_vertex, mesh->elements, mesh->neighbors, light->origin, light->lightradius, light->lightradius); - } -#endif } cvar_t r_editlights = {0, "r_editlights", "0"}; @@ -1103,32 +1800,53 @@ 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"}; worldlight_t *r_shadow_worldlightchain; worldlight_t *r_shadow_selectedlight; vec3_t r_editlights_cursorlocation; static int castshadowcount = 1; -void R_Shadow_NewWorldLight(vec3_t origin, float radius, vec3_t color, int style, const char *cubemapname) +void R_Shadow_NewWorldLight(vec3_t origin, float radius, vec3_t color, int style, const char *cubemapname, int castshadow) { - int i, j, k, l, maxverts, *mark; - float *verts, *v, *v0, *v1, f, projectdistance, temp[3], temp2[3], temp3[3], radius2; + int i, j, k, l, maxverts = 256, *mark, tris; + float *vertex3f = NULL; worldlight_t *e; - shadowmesh_t *mesh; + shadowmesh_t *mesh, *castmesh; mleaf_t *leaf; msurface_t *surf; qbyte *pvs; + surfmesh_t *surfmesh; + + if (radius < 15 || DotProduct(color, color) < 0.03) + { + Con_Printf("R_Shadow_NewWorldLight: refusing to create a light too small/dim\n"); + return; + } e = Mem_Alloc(r_shadow_mempool, sizeof(worldlight_t)); VectorCopy(origin, e->origin); VectorCopy(color, e->light); e->lightradius = radius; - VectorCopy(origin, e->mins); - VectorCopy(origin, e->maxs); - e->cullradius = 0; e->style = style; + if (e->style < 0 || e->style >= MAX_LIGHTSTYLES) + { + Con_Printf("R_Shadow_NewWorldLight: invalid light style number %i, must be >= 0 and < %i\n", e->style, MAX_LIGHTSTYLES); + e->style = 0; + } + e->castshadows = castshadow; + + e->cullradius = e->lightradius; + for (k = 0;k < 3;k++) + { + e->mins[k] = e->origin[k] - e->lightradius; + e->maxs[k] = e->origin[k] + e->lightradius; + } + e->next = r_shadow_worldlightchain; r_shadow_worldlightchain = e; - if (cubemapname) + if (cubemapname && cubemapname[0]) { e->cubemapname = Mem_Alloc(r_shadow_mempool, strlen(cubemapname) + 1); strcpy(e->cubemapname, cubemapname); @@ -1137,38 +1855,42 @@ void R_Shadow_NewWorldLight(vec3_t origin, float radius, vec3_t color, int style if (cl.worldmodel) { castshadowcount++; - leaf = Mod_PointInLeaf(origin, cl.worldmodel); - pvs = Mod_LeafPVS(leaf, cl.worldmodel); - for (i = 0, leaf = cl.worldmodel->leafs + 1;i < cl.worldmodel->numleafs;i++, leaf++) + i = cl.worldmodel->PointContents(cl.worldmodel, e->origin); + if (r_shadow_portallight.integer && i != CONTENTS_SOLID && i != CONTENTS_SKY) { - if (pvs[i >> 3] & (1 << (i & 7))) + qbyte *byteleafpvs; + qbyte *bytesurfacepvs; + + byteleafpvs = Mem_Alloc(tempmempool, cl.worldmodel->numleafs + 1); + bytesurfacepvs = Mem_Alloc(tempmempool, cl.worldmodel->numsurfaces); + + Portal_Visibility(cl.worldmodel, e->origin, byteleafpvs, bytesurfacepvs, NULL, 0, true, RadiusFromBoundsAndOrigin(e->mins, e->maxs, e->origin)); + + for (i = 0, leaf = cl.worldmodel->leafs + 1;i < cl.worldmodel->numleafs;i++, leaf++) + if (byteleafpvs[i+1] && BoxesOverlap(leaf->mins, leaf->maxs, e->mins, e->maxs)) + leaf->worldnodeframe = castshadowcount; + + for (i = 0, surf = cl.worldmodel->surfaces;i < cl.worldmodel->numsurfaces;i++, surf++) + if (bytesurfacepvs[i] && BoxesOverlap(surf->poly_mins, surf->poly_maxs, e->mins, e->maxs)) + surf->castshadow = castshadowcount; + + Mem_Free(byteleafpvs); + Mem_Free(bytesurfacepvs); + } + else + { + leaf = cl.worldmodel->PointInLeaf(cl.worldmodel, origin); + pvs = cl.worldmodel->LeafPVS(cl.worldmodel, leaf); + for (i = 0, leaf = cl.worldmodel->leafs + 1;i < cl.worldmodel->numleafs;i++, leaf++) { - VectorCopy(origin, temp); - if (temp[0] < leaf->mins[0]) temp[0] = leaf->mins[0]; - if (temp[0] > leaf->maxs[0]) temp[0] = leaf->maxs[0]; - if (temp[1] < leaf->mins[1]) temp[1] = leaf->mins[1]; - if (temp[1] > leaf->maxs[1]) temp[1] = leaf->maxs[1]; - if (temp[2] < leaf->mins[2]) temp[2] = leaf->mins[2]; - if (temp[2] > leaf->maxs[2]) temp[2] = leaf->maxs[2]; - VectorSubtract(temp, origin, temp); - if (DotProduct(temp, temp) < e->lightradius * e->lightradius) + if (pvs[i >> 3] & (1 << (i & 7)) && BoxesOverlap(leaf->mins, leaf->maxs, e->mins, e->maxs)) { leaf->worldnodeframe = castshadowcount; for (j = 0, mark = leaf->firstmarksurface;j < leaf->nummarksurfaces;j++, mark++) { surf = cl.worldmodel->surfaces + *mark; - if (surf->castshadow != castshadowcount) - { - f = DotProduct(e->origin, surf->plane->normal) - surf->plane->dist; - if (surf->flags & SURF_PLANEBACK) - f = -f; - if (f > 0 && f < e->lightradius) - { - VectorSubtract(e->origin, surf->poly_center, temp); - if (DotProduct(temp, temp) - surf->poly_radius2 < e->lightradius * e->lightradius) - surf->castshadow = castshadowcount; - } - } + if (surf->castshadow != castshadowcount && BoxesOverlap(surf->poly_mins, surf->poly_maxs, e->mins, e->maxs)) + surf->castshadow = castshadowcount; } } } @@ -1195,167 +1917,81 @@ void R_Shadow_NewWorldLight(vec3_t origin, float radius, vec3_t color, int style for (i = 0, surf = cl.worldmodel->surfaces + cl.worldmodel->firstmodelsurface;i < cl.worldmodel->nummodelsurfaces;i++, surf++) if (surf->castshadow == castshadowcount) e->surfaces[e->numsurfaces++] = surf; - // find bounding box and sphere of lit surfaces - // (these will be used for creating a shape to clip the light) - radius2 = 0; + + // find bounding box of lit leafs VectorCopy(e->origin, e->mins); VectorCopy(e->origin, e->maxs); - for (j = 0;j < e->numsurfaces;j++) + for (j = 0;j < e->numleafs;j++) { - surf = e->surfaces[j]; - for (k = 0, v = surf->poly_verts;k < surf->poly_numverts;k++, v += 3) + leaf = e->leafs[j]; + for (k = 0;k < 3;k++) { - if (e->mins[0] > v[0]) e->mins[0] = v[0];if (e->maxs[0] < v[0]) e->maxs[0] = v[0]; - if (e->mins[1] > v[1]) e->mins[1] = v[1];if (e->maxs[1] < v[1]) e->maxs[1] = v[1]; - if (e->mins[2] > v[2]) e->mins[2] = v[2];if (e->maxs[2] < v[2]) e->maxs[2] = v[2]; - VectorSubtract(v, e->origin, temp); - f = DotProduct(temp, temp); - if (radius2 < f) - radius2 = f; + if (e->mins[k] > leaf->mins[k]) e->mins[k] = leaf->mins[k]; + if (e->maxs[k] < leaf->maxs[k]) e->maxs[k] = leaf->maxs[k]; } } - e->cullradius = sqrt(radius2); - if (e->cullradius > e->lightradius) - e->cullradius = e->lightradius; - if (e->mins[0] < e->origin[0] - e->lightradius) e->mins[0] = e->origin[0] - e->lightradius; - if (e->maxs[0] > e->origin[0] + e->lightradius) e->maxs[0] = e->origin[0] + e->lightradius; - if (e->mins[1] < e->origin[1] - e->lightradius) e->mins[1] = e->origin[1] - e->lightradius; - if (e->maxs[1] > e->origin[1] + e->lightradius) e->maxs[1] = e->origin[1] + e->lightradius; - if (e->mins[2] < e->origin[2] - e->lightradius) e->mins[2] = e->origin[2] - e->lightradius; - if (e->maxs[2] > e->origin[2] + e->lightradius) e->maxs[2] = e->origin[2] + e->lightradius; - Con_Printf("%f %f %f, %f %f %f, %f, %f, %d, %d\n", e->mins[0], e->mins[1], e->mins[2], e->maxs[0], e->maxs[1], e->maxs[2], e->cullradius, e->lightradius, e->numleafs, e->numsurfaces); - // clip shadow volumes against eachother to remove unnecessary - // polygons (and sections of polygons) - maxverts = 256; - verts = NULL; - castshadowcount++; - for (j = 0;j < e->numsurfaces;j++) + + for (k = 0;k < 3;k++) { - surf = e->surfaces[j]; - if (surf->flags & SURF_SHADOWCAST) - { - surf->castshadow = castshadowcount; - if (maxverts < surf->poly_numverts) - maxverts = surf->poly_numverts; - } + if (e->mins[k] < e->origin[k] - e->lightradius) e->mins[k] = e->origin[k] - e->lightradius; + if (e->maxs[k] > e->origin[k] + e->lightradius) e->maxs[k] = e->origin[k] + e->lightradius; } - e->shadowvolume = Mod_ShadowMesh_Begin(r_shadow_mempool, 32768); -#if !PRECOMPUTEDSHADOWVOLUMES - // make a mesh to cast a shadow volume from - for (j = 0;j < e->numsurfaces;j++) - if (e->surfaces[j]->castshadow == castshadowcount) - Mod_ShadowMesh_AddPolygon(r_shadow_mempool, e->shadowvolume, e->surfaces[j]->poly_numverts, e->surfaces[j]->poly_verts); -#else -#if 1 - { - int tris; - shadowmesh_t *castmesh, *mesh; - surfmesh_t *surfmesh; - // make a mesh to cast a shadow volume from - castmesh = Mod_ShadowMesh_Begin(r_shadow_mempool, 32768); - for (j = 0;j < e->numsurfaces;j++) - if (e->surfaces[j]->castshadow == castshadowcount) - for (surfmesh = e->surfaces[j]->mesh;surfmesh;surfmesh = surfmesh->chain) - Mod_ShadowMesh_AddMesh(r_shadow_mempool, castmesh, surfmesh->numverts, surfmesh->verts, surfmesh->numtriangles, surfmesh->index); - castmesh = Mod_ShadowMesh_Finish(r_shadow_mempool, castmesh); - - // cast shadow volume from castmesh - for (mesh = castmesh;mesh;mesh = mesh->next) - { - R_Shadow_ResizeTriangleFacingLight(castmesh->numtriangles); - R_Shadow_ResizeShadowElements(castmesh->numtriangles); + e->cullradius = RadiusFromBoundsAndOrigin(e->mins, e->maxs, e->origin); - if (maxverts < castmesh->numverts * 2) - { - maxverts = castmesh->numverts * 2; - if (verts) - Mem_Free(verts); - verts = NULL; - } - if (verts == NULL && maxverts > 0) - verts = Mem_Alloc(r_shadow_mempool, maxverts * sizeof(float[4])); - - // now that we have the buffers big enough, construct shadow volume mesh - memcpy(verts, castmesh->verts, castmesh->numverts * sizeof(float[4])); - R_Shadow_ProjectVertices(verts, verts + castmesh->numverts * 4, castmesh->numverts, e->origin, e->lightradius); - R_Shadow_MakeTriangleShadowFlags(castmesh->elements, verts, castmesh->numtriangles, trianglefacinglight, e->origin, e->lightradius); - tris = R_Shadow_BuildShadowVolumeTriangles(castmesh->elements, castmesh->neighbors, castmesh->numtriangles, castmesh->numverts, trianglefacinglight, shadowelements); - // add the constructed shadow volume mesh - Mod_ShadowMesh_AddMesh(r_shadow_mempool, e->shadowvolume, castmesh->numverts, verts, tris, shadowelements); - } - // we're done with castmesh now - Mod_ShadowMesh_Free(castmesh); - } -#else - // make a shadow volume mesh - if (verts == NULL && maxverts > 0) - verts = Mem_Alloc(r_shadow_mempool, maxverts * sizeof(float[4])); - for (j = 0;j < e->numsurfaces;j++) + if (e->castshadows) { - surf = e->surfaces[j]; - if (surf->castshadow != castshadowcount) - continue; - projectdistance = 1000000.0f;//e->lightradius; - // copy the original polygon, for the front cap of the volume - for (k = 0, v0 = surf->poly_verts, v1 = verts;k < surf->poly_numverts;k++, v0 += 3, v1 += 3) - VectorCopy(v0, v1); - Mod_ShadowMesh_AddPolygon(r_shadow_mempool, e->shadowvolume, surf->poly_numverts, verts); - // project the original polygon, reversed, for the back cap of the volume - for (k = 0, v0 = surf->poly_verts + (surf->poly_numverts - 1) * 3, v1 = verts;k < surf->poly_numverts;k++, v0 -= 3, v1 += 3) + castshadowcount++; + for (j = 0;j < e->numsurfaces;j++) { - VectorSubtract(v0, e->origin, temp); - //VectorNormalize(temp); - VectorMA(v0, projectdistance, temp, v1); + surf = e->surfaces[j]; + if (surf->flags & SURF_SHADOWCAST) + { + surf->castshadow = castshadowcount; + if (maxverts < surf->poly_numverts) + maxverts = surf->poly_numverts; + } } - Mod_ShadowMesh_AddPolygon(r_shadow_mempool, e->shadowvolume, surf->poly_numverts, verts); - // project the shadow volume sides - for (l = surf->poly_numverts - 1, k = 0, v0 = surf->poly_verts + (surf->poly_numverts - 1) * 3, v1 = surf->poly_verts;k < surf->poly_numverts;l = k, k++, v0 = v1, v1 += 3) + e->shadowvolume = Mod_ShadowMesh_Begin(r_shadow_mempool, 32768); + // make a mesh to cast a shadow volume from + castmesh = Mod_ShadowMesh_Begin(r_shadow_mempool, 32768); + for (j = 0;j < e->numsurfaces;j++) + if (e->surfaces[j]->castshadow == castshadowcount) + for (surfmesh = e->surfaces[j]->mesh;surfmesh;surfmesh = surfmesh->chain) + Mod_ShadowMesh_AddMesh(r_shadow_mempool, castmesh, surfmesh->vertex3f, surfmesh->numtriangles, surfmesh->element3i); + castmesh = Mod_ShadowMesh_Finish(r_shadow_mempool, castmesh); + + // cast shadow volume from castmesh + for (mesh = castmesh;mesh;mesh = mesh->next) { - if (surf->neighborsurfaces == NULL || surf->neighborsurfaces[l] == NULL || surf->neighborsurfaces[l]->castshadow != castshadowcount) - { - VectorCopy(v1, &verts[0]); - VectorCopy(v0, &verts[3]); - VectorCopy(v0, &verts[6]); - VectorCopy(v1, &verts[9]); - VectorSubtract(&verts[6], e->origin, temp); - //VectorNormalize(temp); - VectorMA(&verts[6], projectdistance, temp, &verts[6]); - VectorSubtract(&verts[9], e->origin, temp); - //VectorNormalize(temp); - VectorMA(&verts[9], projectdistance, temp, &verts[9]); - -#if 0 - VectorSubtract(&verts[0], &verts[3], temp); - VectorSubtract(&verts[6], &verts[3], temp2); - CrossProduct(temp, temp2, temp3); - VectorNormalize(temp3); - if (DotProduct(surf->poly_center, temp3) > DotProduct(&verts[0], temp3)) - { - VectorCopy(v0, &verts[0]); - VectorCopy(v1, &verts[3]); - VectorCopy(v1, &verts[6]); - VectorCopy(v0, &verts[9]); - VectorSubtract(&verts[6], e->origin, temp); - //VectorNormalize(temp); - VectorMA(&verts[6], projectdistance, temp, &verts[6]); - VectorSubtract(&verts[9], e->origin, temp); - //VectorNormalize(temp); - VectorMA(&verts[9], projectdistance, temp, &verts[9]); - Con_Printf("flipped shadow volume edge %8p %i\n", surf, l); - } -#endif + R_Shadow_ResizeShadowElements(castmesh->numtriangles); - Mod_ShadowMesh_AddPolygon(r_shadow_mempool, e->shadowvolume, 4, verts); + if (maxverts < castmesh->numverts * 2) + { + maxverts = castmesh->numverts * 2; + if (vertex3f) + Mem_Free(vertex3f); + vertex3f = NULL; } + if (vertex3f == NULL && maxverts > 0) + vertex3f = Mem_Alloc(r_shadow_mempool, maxverts * sizeof(float[3])); + + // now that we have the buffers big enough, construct and add + // the shadow volume mesh + if ((tris = R_Shadow_ConstructShadowVolume(castmesh->numverts, 0, castmesh->numtriangles, castmesh->element3i, castmesh->neighbor3i, castmesh->vertex3f, NULL, shadowelements, vertex3f, e->origin, r_shadow_projectdistance.value))) + Mod_ShadowMesh_AddMesh(r_shadow_mempool, e->shadowvolume, vertex3f, tris, shadowelements); } + if (vertex3f) + Mem_Free(vertex3f); + vertex3f = NULL; + // we're done with castmesh now + Mod_ShadowMesh_Free(castmesh); + e->shadowvolume = Mod_ShadowMesh_Finish(r_shadow_mempool, e->shadowvolume); + for (l = 0, mesh = e->shadowvolume;mesh;mesh = mesh->next) + l += mesh->numtriangles; + Con_Printf("static shadow volume built containing %i triangles\n", l); } -#endif -#endif - e->shadowvolume = Mod_ShadowMesh_Finish(r_shadow_mempool, e->shadowvolume); - for (l = 0, mesh = e->shadowvolume;mesh;mesh = mesh->next) - l += mesh->numtriangles; - Con_Printf("static shadow volume built containing %i triangles\n", l); } + Con_Printf("%f %f %f, %f %f %f, %f, %f, %d, %d\n", e->mins[0], e->mins[1], e->mins[2], e->maxs[0], e->maxs[1], e->maxs[2], e->cullradius, e->lightradius, e->numleafs, e->numsurfaces); } void R_Shadow_FreeWorldLight(worldlight_t *light) @@ -1392,29 +2028,63 @@ void R_Shadow_SelectLight(worldlight_t *light) r_shadow_selectedlight->selected = true; } -void R_Shadow_FreeSelectedWorldLight(void) +rtexture_t *lighttextures[5]; + +void R_Shadow_DrawCursorCallback(const void *calldata1, int calldata2) { - if (r_shadow_selectedlight) + float scale = r_editlights_cursorgrid.value * 0.5f; + R_DrawSprite(GL_SRC_ALPHA, GL_ONE, lighttextures[0], false, r_editlights_cursorlocation, vright, vup, scale, -scale, -scale, scale, 1, 1, 1, 0.5f); +} + +void R_Shadow_DrawLightSpriteCallback(const void *calldata1, int calldata2) +{ + float intensity; + const worldlight_t *light; + light = calldata1; + intensity = 0.5; + if (light->selected) + intensity = 0.75 + 0.25 * sin(realtime * M_PI * 4.0); + if (!light->shadowvolume) + intensity *= 0.5f; + R_DrawSprite(GL_SRC_ALPHA, GL_ONE, lighttextures[calldata2], false, light->origin, vright, vup, 8, -8, -8, 8, intensity, intensity, intensity, 0.5); +} + +void R_Shadow_DrawLightSprites(void) +{ + int i; + cachepic_t *pic; + worldlight_t *light; + + for (i = 0;i < 5;i++) { - R_Shadow_FreeWorldLight(r_shadow_selectedlight); - r_shadow_selectedlight = NULL; + lighttextures[i] = NULL; + if ((pic = Draw_CachePic(va("gfx/crosshair%i.tga", i + 1)))) + lighttextures[i] = pic->tex; } + + for (light = r_shadow_worldlightchain;light;light = light->next) + R_MeshQueue_AddTransparent(light->origin, R_Shadow_DrawLightSpriteCallback, light, ((int) light) % 5); + R_MeshQueue_AddTransparent(r_editlights_cursorlocation, R_Shadow_DrawCursorCallback, NULL, 0); } void R_Shadow_SelectLightInView(void) { - float bestrating, rating, temp[3], dist; + float bestrating, rating, temp[3]; worldlight_t *best, *light; best = NULL; - bestrating = 1e30; + bestrating = 0; for (light = r_shadow_worldlightchain;light;light = light->next) { VectorSubtract(light->origin, r_refdef.vieworg, temp); - dist = sqrt(DotProduct(temp, temp)); - if (DotProduct(temp, vpn) >= 0.97 * dist && bestrating > dist && CL_TraceLine(light->origin, r_refdef.vieworg, NULL, NULL, 0, true, NULL) == 1.0f) + rating = (DotProduct(temp, vpn) / sqrt(DotProduct(temp, temp))); + if (rating >= 0.95) { - bestrating = dist; - best = light; + rating /= (1 + 0.0625f * sqrt(DotProduct(temp, temp))); + if (bestrating < rating && CL_TraceLine(light->origin, r_refdef.vieworg, NULL, NULL, 0, true, NULL) == 1.0f) + { + bestrating = rating; + best = light; + } } } R_Shadow_SelectLight(best); @@ -1422,12 +2092,17 @@ void R_Shadow_SelectLightInView(void) void R_Shadow_LoadWorldLights(void) { - int n, a, style; + int n, a, style, shadow; char name[MAX_QPATH], cubemapname[MAX_QPATH], *lightsstring, *s, *t; float origin[3], radius, color[3]; - COM_StripExtension(cl.worldmodel->name, name); + if (cl.worldmodel == NULL) + { + Con_Printf("No map loaded.\n"); + return; + } + FS_StripExtension(cl.worldmodel->name, name); strcat(name, ".rtlights"); - lightsstring = COM_LoadFile(name, false); + lightsstring = FS_LoadFile(name, false); if (lightsstring) { s = lightsstring; @@ -1440,7 +2115,14 @@ void R_Shadow_LoadWorldLights(void) if (!*s) break; *s = 0; - a = sscanf(t, "%f %f %f %f %f %f %f %d %s", &origin[0], &origin[1], &origin[2], &radius, &color[0], &color[1], &color[2], &style, &cubemapname); + shadow = true; + // check for modifier flags + if (*t == '!') + { + shadow = false; + t++; + } + a = sscanf(t, "%f %f %f %f %f %f %f %d %s", &origin[0], &origin[1], &origin[2], &radius, &color[0], &color[1], &color[2], &style, cubemapname); if (a < 9) cubemapname[0] = 0; *s = '\n'; @@ -1449,7 +2131,9 @@ void R_Shadow_LoadWorldLights(void) Con_Printf("found %d parameters on line %i, should be 8 or 9 parameters (origin[0] origin[1] origin[2] radius color[0] color[1] color[2] style cubemapname)\n", a, n + 1); break; } - R_Shadow_NewWorldLight(origin, radius, color, style, cubemapname); + VectorScale(color, r_editlights_rtlightscolorscale.value, color); + radius *= r_editlights_rtlightssizescale.value; + R_Shadow_NewWorldLight(origin, radius, color, style, cubemapname, shadow); s++; n++; } @@ -1468,14 +2152,19 @@ void R_Shadow_SaveWorldLights(void) char line[1024]; if (!r_shadow_worldlightchain) return; - COM_StripExtension(cl.worldmodel->name, name); + if (cl.worldmodel == NULL) + { + Con_Printf("No map loaded.\n"); + return; + } + FS_StripExtension(cl.worldmodel->name, name); strcat(name, ".rtlights"); bufchars = bufmaxchars = 0; buf = NULL; for (light = r_shadow_worldlightchain;light;light = light->next) { - sprintf(line, "%g %g %g %g %g %g %g %d %s\n", light->origin[0], light->origin[1], light->origin[2], light->lightradius, light->light[0], light->light[1], light->light[2], light->style, light->cubemapname ? light->cubemapname : ""); - if (bufchars + strlen(line) > bufmaxchars) + sprintf(line, "%s%g %g %g %g %g %g %g %d %s\n", light->castshadows ? "" : "!", light->origin[0], light->origin[1], light->origin[2], light->lightradius / r_editlights_rtlightssizescale.value, light->light[0] / r_editlights_rtlightscolorscale.value, light->light[1] / r_editlights_rtlightscolorscale.value, light->light[2] / r_editlights_rtlightscolorscale.value, light->style, light->cubemapname ? light->cubemapname : ""); + if (bufchars + (int) strlen(line) > bufmaxchars) { bufmaxchars = bufchars + strlen(line) + 2048; oldbuf = buf; @@ -1494,7 +2183,7 @@ void R_Shadow_SaveWorldLights(void) } } if (bufchars) - COM_WriteFile(name, buf, bufchars); + FS_WriteFile(name, buf, bufchars); if (buf) Mem_Free(buf); } @@ -1502,11 +2191,16 @@ void R_Shadow_SaveWorldLights(void) void R_Shadow_LoadLightsFile(void) { int n, a, style; - char name[MAX_QPATH], cubemapname[MAX_QPATH], *lightsstring, *s, *t; + char name[MAX_QPATH], *lightsstring, *s, *t; float origin[3], radius, color[3], subtract, spotdir[3], spotcone, falloff, distbias; - COM_StripExtension(cl.worldmodel->name, name); + if (cl.worldmodel == NULL) + { + Con_Printf("No map loaded.\n"); + return; + } + FS_StripExtension(cl.worldmodel->name, name); strcat(name, ".lights"); - lightsstring = COM_LoadFile(name, false); + lightsstring = FS_LoadFile(name, false); if (lightsstring) { s = lightsstring; @@ -1528,8 +2222,8 @@ void R_Shadow_LoadLightsFile(void) } radius = sqrt(DotProduct(color, color) / (falloff * falloff * 8192.0f * 8192.0f)); radius = bound(15, radius, 4096); - VectorScale(color, (1.0f / (8388608.0f)), color); - R_Shadow_NewWorldLight(origin, radius, color, style, NULL); + VectorScale(color, (2.0f / (8388608.0f)), color); + R_Shadow_NewWorldLight(origin, radius, color, style, NULL, true); s++; n++; } @@ -1543,9 +2237,14 @@ void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void) { int entnum, style, islight; char key[256], value[1024]; - float origin[3], radius, color[3], light, scale, originhack[3]; + float origin[3], radius, color[3], light, scale, originhack[3], overridecolor[3]; const char *data; + if (cl.worldmodel == NULL) + { + Con_Printf("No map loaded.\n"); + return; + } data = cl.worldmodel->entities; if (!data) return; @@ -1555,6 +2254,7 @@ void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void) origin[0] = origin[1] = origin[2] = 0; originhack[0] = originhack[1] = originhack[2] = 0; color[0] = color[1] = color[2] = 1; + overridecolor[0] = overridecolor[1] = overridecolor[2] = 1; scale = 1; style = 0; islight = false; @@ -1588,29 +2288,68 @@ void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void) if (!strncmp(value, "light", 5)) { islight = true; + if (!strcmp(value, "light_fluoro")) + { + originhack[0] = 0; + originhack[1] = 0; + originhack[2] = 0; + overridecolor[0] = 1; + overridecolor[1] = 1; + overridecolor[2] = 1; + } + if (!strcmp(value, "light_fluorospark")) + { + originhack[0] = 0; + originhack[1] = 0; + originhack[2] = 0; + overridecolor[0] = 1; + overridecolor[1] = 1; + overridecolor[2] = 1; + } + if (!strcmp(value, "light_globe")) + { + originhack[0] = 0; + originhack[1] = 0; + originhack[2] = 0; + overridecolor[0] = 1; + overridecolor[1] = 0.8; + overridecolor[2] = 0.4; + } if (!strcmp(value, "light_flame_large_yellow")) { originhack[0] = 0; originhack[1] = 0; - originhack[2] = 40; + originhack[2] = 48; + overridecolor[0] = 1; + overridecolor[1] = 0.5; + overridecolor[2] = 0.1; } if (!strcmp(value, "light_flame_small_yellow")) { originhack[0] = 0; originhack[1] = 0; originhack[2] = 40; + overridecolor[0] = 1; + overridecolor[1] = 0.5; + overridecolor[2] = 0.1; } if (!strcmp(value, "light_torch_small_white")) { originhack[0] = 0; originhack[1] = 0; originhack[2] = 40; + overridecolor[0] = 1; + overridecolor[1] = 0.5; + overridecolor[2] = 0.1; } if (!strcmp(value, "light_torch_small_walltorch")) { originhack[0] = 0; originhack[1] = 0; originhack[2] = 40; + overridecolor[0] = 1; + overridecolor[1] = 0.5; + overridecolor[2] = 0.1; } } } @@ -1619,12 +2358,14 @@ void R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(void) } if (light <= 0 && islight) light = 300; - radius = bound(0, light / scale, 1048576) + 15.0f; - light = bound(0, light, 1048576) * (1.0f / 256.0f); + radius = min(light * r_editlights_quakelightsizescale.value / scale, 1048576); + light = sqrt(bound(0, light, 1048576)) * (1.0f / 16.0f); + if (color[0] == 1 && color[1] == 1 && color[2] == 1) + VectorCopy(overridecolor, color); VectorScale(color, light, color); VectorAdd(origin, originhack, origin); if (radius >= 15) - R_Shadow_NewWorldLight(origin, radius, color, style, NULL); + R_Shadow_NewWorldLight(origin, radius, color, style, NULL, true); } } @@ -1650,39 +2391,13 @@ void R_Shadow_SetCursorLocationForView(void) r_editlights_cursorlocation[2] = floor(endpos[2] / r_editlights_cursorgrid.value + 0.5f) * r_editlights_cursorgrid.value; } -extern void R_DrawCrosshairSprite(rtexture_t *texture, vec3_t origin, vec_t scale, float cr, float cg, float cb, float ca); -void R_Shadow_DrawCursorCallback(const void *calldata1, int calldata2) -{ - cachepic_t *pic; - pic = Draw_CachePic("gfx/crosshair1.tga"); - if (pic) - R_DrawCrosshairSprite(pic->tex, r_editlights_cursorlocation, r_editlights_cursorgrid.value * 0.5f, 1, 1, 1, 1); -} - -void R_Shadow_DrawCursor(void) -{ - R_MeshQueue_AddTransparent(r_editlights_cursorlocation, R_Shadow_DrawCursorCallback, NULL, 0); -} - -void R_Shadow_UpdateLightingMode(void) -{ - r_shadow_lightingmode = 0; - if (r_shadow_realtime.integer) - { - if (r_shadow_worldlightchain) - r_shadow_lightingmode = 2; - else - r_shadow_lightingmode = 1; - } -} - void R_Shadow_UpdateWorldLightSelection(void) { + R_Shadow_SetCursorLocationForView(); if (r_editlights.integer) { R_Shadow_SelectLightInView(); - R_Shadow_SetCursorLocationForView(); - R_Shadow_DrawCursor(); + R_Shadow_DrawLightSprites(); } else R_Shadow_SelectLight(NULL); @@ -1695,11 +2410,7 @@ void R_Shadow_EditLights_Clear_f(void) void R_Shadow_EditLights_Reload_f(void) { - if (cl.worldmodel) - { - R_Shadow_ClearWorldLights(); - R_Shadow_LoadWorldLights(); - } + r_shadow_reloadlights = true; } void R_Shadow_EditLights_Save_f(void) @@ -1722,60 +2433,27 @@ void R_Shadow_EditLights_ImportLightsFile_f(void) void R_Shadow_EditLights_Spawn_f(void) { - vec3_t origin, color; - vec_t radius; - int style; - const char *cubemapname; + vec3_t color; if (!r_editlights.integer) { Con_Printf("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n"); return; } - if (Cmd_Argc() <= 7) + if (Cmd_Argc() != 1) { - radius = 200; - color[0] = color[1] = color[2] = 1; - style = 0; - cubemapname = NULL; - if (Cmd_Argc() >= 2) - { - radius = atof(Cmd_Argv(1)); - if (Cmd_Argc() >= 3) - { - color[0] = atof(Cmd_Argv(2)); - color[1] = color[0]; - color[2] = color[0]; - if (Cmd_Argc() >= 5) - { - color[1] = atof(Cmd_Argv(3)); - color[2] = atof(Cmd_Argv(4)); - if (Cmd_Argc() >= 6) - { - style = atoi(Cmd_Argv(5)); - if (Cmd_Argc() >= 7) - cubemapname = Cmd_Argv(6); - } - } - } - } - if (cubemapname && !cubemapname[0]) - cubemapname = NULL; - if (radius >= 16 && color[0] >= 0 && color[1] >= 0 && color[2] >= 0 && style >= 0 && style < 256 && (color[0] >= 0.1 || color[1] >= 0.1 || color[2] >= 0.1)) - { - VectorCopy(r_editlights_cursorlocation, origin); - R_Shadow_NewWorldLight(origin, radius, color, style, cubemapname); - return; - } + Con_Printf("r_editlights_spawn does not take parameters\n"); + return; } - Con_Printf("usage: r_editlights_spawn radius red green blue [style [cubemap]]\n"); + color[0] = color[1] = color[2] = 1; + R_Shadow_NewWorldLight(r_editlights_cursorlocation, 200, color, 0, NULL, true); } void R_Shadow_EditLights_Edit_f(void) { vec3_t origin, color; vec_t radius; - int style; - const char *cubemapname; + int style, shadows; + char cubemapname[1024]; if (!r_editlights.integer) { Con_Printf("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n"); @@ -1786,45 +2464,191 @@ void R_Shadow_EditLights_Edit_f(void) Con_Printf("No selected light.\n"); return; } - if (Cmd_Argc() <= 7) + VectorCopy(r_shadow_selectedlight->origin, origin); + radius = r_shadow_selectedlight->lightradius; + VectorCopy(r_shadow_selectedlight->light, color); + style = r_shadow_selectedlight->style; + if (r_shadow_selectedlight->cubemapname) + strcpy(cubemapname, r_shadow_selectedlight->cubemapname); + else + cubemapname[0] = 0; + shadows = r_shadow_selectedlight->castshadows; + if (!strcmp(Cmd_Argv(1), "origin")) { - radius = 200; - color[0] = color[1] = color[2] = 1; - style = 0; - cubemapname = NULL; - if (Cmd_Argc() >= 2) + if (Cmd_Argc() != 5) { - radius = atof(Cmd_Argv(1)); - if (Cmd_Argc() >= 3) - { - color[0] = atof(Cmd_Argv(2)); - color[1] = color[0]; - color[2] = color[0]; - if (Cmd_Argc() >= 5) - { - color[1] = atof(Cmd_Argv(3)); - color[2] = atof(Cmd_Argv(4)); - if (Cmd_Argc() >= 6) - { - style = atoi(Cmd_Argv(5)); - if (Cmd_Argc() >= 7) - cubemapname = Cmd_Argv(6); - } - } - } + Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(0)); + return; + } + origin[0] = atof(Cmd_Argv(2)); + origin[1] = atof(Cmd_Argv(3)); + origin[2] = atof(Cmd_Argv(4)); + } + else if (!strcmp(Cmd_Argv(1), "originx")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(0)); + return; + } + origin[0] = atof(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "originy")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(0)); + return; + } + origin[1] = atof(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "originz")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(0)); + return; + } + origin[2] = atof(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "move")) + { + if (Cmd_Argc() != 5) + { + Con_Printf("usage: r_editlights_edit %s x y z\n", Cmd_Argv(0)); + return; + } + origin[0] += atof(Cmd_Argv(2)); + origin[1] += atof(Cmd_Argv(3)); + origin[2] += atof(Cmd_Argv(4)); + } + else if (!strcmp(Cmd_Argv(1), "movex")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(0)); + return; + } + origin[0] += atof(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "movey")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(0)); + return; + } + origin[1] += atof(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "movez")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(0)); + return; + } + origin[2] += atof(Cmd_Argv(2)); + } + else if (!strcmp(Cmd_Argv(1), "color")) + { + if (Cmd_Argc() != 5) + { + Con_Printf("usage: r_editlights_edit %s red green blue\n", Cmd_Argv(0)); + return; + } + color[0] = atof(Cmd_Argv(2)); + color[1] = atof(Cmd_Argv(3)); + color[2] = atof(Cmd_Argv(4)); + } + else if (!strcmp(Cmd_Argv(1), "radius")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(0)); + return; + } + radius = atof(Cmd_Argv(2)); + } + else if (Cmd_Argc() == 3 && !strcmp(Cmd_Argv(1), "style")) + { + if (Cmd_Argc() != 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(0)); + return; } - if (cubemapname && !cubemapname[0]) - cubemapname = NULL; - if (radius >= 16 && color[0] >= 0 && color[1] >= 0 && color[2] >= 0 && style >= 0 && style < 256 && (color[0] >= 0.1 || color[1] >= 0.1 || color[2] >= 0.1)) + style = atoi(Cmd_Argv(2)); + } + else if (Cmd_Argc() == 3 && !strcmp(Cmd_Argv(1), "cubemap")) + { + if (Cmd_Argc() > 3) + { + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(0)); + return; + } + if (Cmd_Argc() == 3) + strcpy(cubemapname, Cmd_Argv(2)); + else + cubemapname[0] = 0; + } + else if (Cmd_Argc() == 3 && !strcmp(Cmd_Argv(1), "shadows")) + { + if (Cmd_Argc() != 3) { - VectorCopy(r_shadow_selectedlight->origin, origin); - R_Shadow_FreeWorldLight(r_shadow_selectedlight); - r_shadow_selectedlight = NULL; - R_Shadow_NewWorldLight(origin, radius, color, style, cubemapname); + Con_Printf("usage: r_editlights_edit %s value\n", Cmd_Argv(0)); return; } + shadows = Cmd_Argv(2)[0] == 'y' || Cmd_Argv(2)[0] == 'Y' || Cmd_Argv(2)[0] == 't' || atoi(Cmd_Argv(2)); + } + else + { + Con_Printf("usage: r_editlights_edit [property] [value]\n"); + Con_Printf("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("Radius: %f\n", r_shadow_selectedlight->lightradius); + Con_Printf("Color: %f %f %f\n", r_shadow_selectedlight->light[0], r_shadow_selectedlight->light[1], r_shadow_selectedlight->light[2]); + Con_Printf("Style: %i\n", r_shadow_selectedlight->style); + Con_Printf("Cubemap: %s\n", r_shadow_selectedlight->cubemapname); + Con_Printf("Shadows: %s\n", r_shadow_selectedlight->castshadows ? "yes" : "no"); + return; + } + R_Shadow_FreeWorldLight(r_shadow_selectedlight); + r_shadow_selectedlight = NULL; + R_Shadow_NewWorldLight(origin, radius, color, style, cubemapname, shadows); +} + +extern int con_vislines; +void R_Shadow_EditLights_DrawSelectedLightProperties(void) +{ + float x, y; + char temp[256]; + if (r_shadow_selectedlight == NULL) + 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, "Radius %f", r_shadow_selectedlight->lightradius);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; + sprintf(temp, "Color %f %f %f", r_shadow_selectedlight->light[0], r_shadow_selectedlight->light[1], r_shadow_selectedlight->light[2]);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, "Cubemap %s", r_shadow_selectedlight->cubemapname);DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; + sprintf(temp, "Shadows %s", r_shadow_selectedlight->castshadows ? "yes" : "no");DrawQ_String(x, y, temp, 0, 8, 8, 1, 1, 1, 1, 0);y += 8; +} + +void R_Shadow_EditLights_ToggleShadow_f(void) +{ + if (!r_editlights.integer) + { + Con_Printf("Cannot spawn light when not in editing mode. Set r_editlights to 1.\n"); + return; + } + if (!r_shadow_selectedlight) + { + Con_Printf("No selected light.\n"); + return; } - Con_Printf("usage: r_editlights_edit radius red green blue [style [cubemap]]\n"); + R_Shadow_NewWorldLight(r_shadow_selectedlight->origin, r_shadow_selectedlight->lightradius, r_shadow_selectedlight->light, r_shadow_selectedlight->style, r_shadow_selectedlight->cubemapname, !r_shadow_selectedlight->castshadows); + R_Shadow_FreeWorldLight(r_shadow_selectedlight); + r_shadow_selectedlight = NULL; } void R_Shadow_EditLights_Remove_f(void) @@ -1839,7 +2663,8 @@ void R_Shadow_EditLights_Remove_f(void) Con_Printf("No selected light.\n"); return; } - R_Shadow_FreeSelectedWorldLight(); + R_Shadow_FreeWorldLight(r_shadow_selectedlight); + r_shadow_selectedlight = NULL; } void R_Shadow_EditLights_Init(void) @@ -1849,12 +2674,16 @@ void R_Shadow_EditLights_Init(void) Cvar_RegisterVariable(&r_editlights_cursorpushback); Cvar_RegisterVariable(&r_editlights_cursorpushoff); Cvar_RegisterVariable(&r_editlights_cursorgrid); + Cvar_RegisterVariable(&r_editlights_quakelightsizescale); + Cvar_RegisterVariable(&r_editlights_rtlightssizescale); + Cvar_RegisterVariable(&r_editlights_rtlightscolorscale); Cmd_AddCommand("r_editlights_clear", R_Shadow_EditLights_Clear_f); Cmd_AddCommand("r_editlights_reload", R_Shadow_EditLights_Reload_f); Cmd_AddCommand("r_editlights_save", R_Shadow_EditLights_Save_f); Cmd_AddCommand("r_editlights_spawn", R_Shadow_EditLights_Spawn_f); Cmd_AddCommand("r_editlights_edit", R_Shadow_EditLights_Edit_f); Cmd_AddCommand("r_editlights_remove", R_Shadow_EditLights_Remove_f); + Cmd_AddCommand("r_editlights_toggleshadow", R_Shadow_EditLights_ToggleShadow_f); Cmd_AddCommand("r_editlights_importlightentitiesfrommap", R_Shadow_EditLights_ImportLightEntitiesFromMap_f); Cmd_AddCommand("r_editlights_importlightsfile", R_Shadow_EditLights_ImportLightsFile_f); }