+ R_Shadow_LoadLightsFile();
+ if (r_shadow_worldlightchain == NULL)
+ R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite();
+ }
+ }
+
+ memset(&m, 0, sizeof(m));
+ m.blendfunc1 = GL_ONE;
+ m.blendfunc2 = GL_ZERO;
+ 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);
+ 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_KEEP, GL_KEEP, GL_KEEP);
+ qglStencilFunc(GL_ALWAYS, 128, 0xFF);
+ qglEnable(GL_CULL_FACE);
+ qglEnable(GL_DEPTH_TEST);
+ r_shadowstage = SHADOWSTAGE_STENCIL;
+ qglClear(GL_STENCIL_BUFFER_BIT);
+}
+
+void R_Shadow_Stage_Light(void)
+{
+ rmeshstate_t m;
+ memset(&m, 0, sizeof(m));
+ R_Mesh_TextureState(&m);
+ qglActiveTexture(GL_TEXTURE0_ARB);
+
+ qglEnable(GL_BLEND);
+ qglBlendFunc(GL_ONE, GL_ONE);
+ GL_Color(1, 1, 1, 1);
+ qglColorMask(1, 1, 1, 1);
+ qglDepthMask(0);
+ qglDepthFunc(GL_EQUAL);
+ 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);
+ qglEnable(GL_CULL_FACE);
+ qglEnable(GL_DEPTH_TEST);
+ r_shadowstage = SHADOWSTAGE_LIGHT;
+}
+
+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
+ GL_Color(1, 1, 1, 1);
+ 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, 128, 0xFF);
+ qglEnable(GL_CULL_FACE);
+ qglEnable(GL_DEPTH_TEST);
+ // force mesh state to reset by using various combinations of features
+ memset(&m, 0, sizeof(m));
+ m.blendfunc1 = GL_SRC_ALPHA;
+ m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
+ R_Mesh_State(&m);
+ m.blendfunc1 = GL_ONE;
+ m.blendfunc2 = GL_ZERO;
+ R_Mesh_State(&m);
+ r_shadowstage = SHADOWSTAGE_NONE;
+}
+
+int R_Shadow_ScissorForBBoxAndSphere(const float *mins, const float *maxs, const float *origin, float radius)
+{
+ int i, ix1, iy1, ix2, iy2;
+ float x1, y1, x2, y2, x, y;
+ vec3_t smins, smaxs;
+ vec4_t v, v2;
+ if (!r_shadow_scissor.integer)
+ return false;
+ // if view is inside the box, just say yes it's visible
+ if (r_origin[0] >= mins[0] && r_origin[0] <= maxs[0]
+ && r_origin[1] >= mins[1] && r_origin[1] <= maxs[1]
+ && r_origin[2] >= mins[2] && r_origin[2] <= maxs[2])
+ {
+ qglDisable(GL_SCISSOR_TEST);
+ return false;
+ }
+ VectorSubtract(r_origin, origin, v);
+ if (DotProduct(v, v) < radius * radius)
+ {
+ qglDisable(GL_SCISSOR_TEST);
+ return false;
+ }
+ // create viewspace bbox
+ for (i = 0;i < 8;i++)
+ {
+ v[0] = ((i & 1) ? mins[0] : maxs[0]) - r_origin[0];
+ v[1] = ((i & 2) ? mins[1] : maxs[1]) - r_origin[1];
+ v[2] = ((i & 4) ? mins[2] : maxs[2]) - r_origin[2];
+ v2[0] = DotProduct(v, vright);
+ v2[1] = DotProduct(v, vup);
+ v2[2] = DotProduct(v, vpn);
+ if (i)
+ {
+ if (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 viewspace version of the sphere
+ v[0] = origin[0] - r_origin[0];
+ v[1] = origin[1] - r_origin[1];
+ v[2] = origin[2] - r_origin[2];
+ v2[0] = DotProduct(v, vright);
+ v2[1] = DotProduct(v, vup);
+ v2[2] = DotProduct(v, vpn);
+ if (smins[0] < v2[0] - radius) smins[0] = v2[0] - radius;
+ if (smaxs[0] < v2[0] - radius) smaxs[0] = v2[0] + radius;
+ if (smins[1] < v2[1] - radius) smins[1] = v2[1] - radius;
+ if (smaxs[1] < v2[1] - radius) smaxs[1] = v2[1] + radius;
+ if (smins[2] < v2[2] - radius) smins[2] = v2[2] - radius;
+ if (smaxs[2] < v2[2] - radius) smaxs[2] = v2[2] + radius;
+ // clip it to the view plane
+ if (smins[2] < 1)
+ smins[2] = 1;
+ // return true if that culled the box
+ if (smins[2] >= smaxs[2])
+ return true;
+ // ok some of it is infront of the view, transform each corner back to
+ // worldspace and then to screenspace and make screen rect
+ 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);
+ return false;
+}
+
+void R_Shadow_GenTexCoords_Attenuation2D1D(float *out2d, float *out1d, int numverts, const float *vertex, const float *svectors, const float *tvectors, const float *normals, const vec3_t relativelightorigin, float lightradius)
+{
+ 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;
+ }
+}
+
+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)
+{
+ 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)
+ {
+ 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;
+ }
+}
+
+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)
+{
+ int i;
+ float lightdir[3];
+ for (i = 0;i < numverts;i++, vertex += 4, svectors += 4, tvectors += 4, normals += 4, out += 4)
+ {
+ VectorSubtract(vertex, relativelightorigin, lightdir);
+ // the cubemap normalizes this for us
+ out[0] = DotProduct(svectors, lightdir);
+ out[1] = DotProduct(tvectors, lightdir);
+ out[2] = DotProduct(normals, lightdir);
+ }
+}
+
+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)
+{
+ 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)
+ {
+ 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;
+ }
+}
+
+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)
+{
+ 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)
+ {
+ VectorSubtract(vertex, relativelightorigin, lightdir);
+ VectorNormalizeFast(lightdir);
+ VectorSubtract(vertex, 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);
+ }
+}
+
+void R_Shadow_GenTexCoords_LightCubeMap(float *out, int numverts, const float *vertex, const vec3_t relativelightorigin)
+{
+ int i;
+ // FIXME: this needs to be written
+ // this code assumes the vertices are in worldspace (a false assumption)
+ for (i = 0;i < numverts;i++, vertex += 4, out += 4)
+ VectorSubtract(vertex, relativelightorigin, out);
+}
+
+void R_Shadow_DiffuseLighting(int numverts, int numtriangles, const int *elements, const float *svectors, const float *tvectors, const float *normals, const float *texcoords, const float *relativelightorigin, float lightradius, const float *lightcolor, rtexture_t *basetexture, rtexture_t *bumptexture, rtexture_t *lightcubemap)
+{
+ int renders, mult;
+ float scale, colorscale;
+ rmeshstate_t m;
+ memset(&m, 0, sizeof(m));
+ if (!bumptexture)
+ bumptexture = r_shadow_blankbumptexture;
+ // colorscale accounts for how much we multiply the brightness during combine
+ // mult is how many times the final pass of the lighting will be
+ // performed to get more brightness than otherwise possible
+ // limit mult to 64 for sanity sake
+ if (r_textureunits.integer >= 4)
+ {
+ // 4 texture no3D combine path, two pass
+ m.tex[0] = R_GetTexture(bumptexture);
+ m.texcubemap[1] = R_GetTexture(r_shadow_normalscubetexture);
+ m.texcombinergb[0] = GL_REPLACE;
+ m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
+ m.tex[2] = R_GetTexture(r_shadow_attenuation2dtexture);
+ m.tex[3] = R_GetTexture(r_shadow_attenuation2dtexture);
+ R_Mesh_TextureState(&m);
+ qglColorMask(0,0,0,1);
+ qglDisable(GL_BLEND);
+ GL_Color(1,1,1,1);
+ memcpy(varray_texcoord[0], texcoords, numverts * sizeof(float[4]));
+ R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord[1], numverts, varray_vertex, svectors, tvectors, normals, relativelightorigin);
+ R_Shadow_GenTexCoords_Attenuation2D1D(varray_texcoord[2], varray_texcoord[3], numverts, varray_vertex, svectors, tvectors, normals, relativelightorigin, lightradius);
+ R_Mesh_Draw(numverts, numtriangles, elements);
+
+ m.tex[0] = R_GetTexture(basetexture);
+ m.texcubemap[1] = R_GetTexture(lightcubemap);
+ m.texcombinergb[0] = GL_MODULATE;
+ m.texcombinergb[1] = GL_MODULATE;
+ m.tex[2] = 0;
+ m.tex[3] = 0;
+ R_Mesh_TextureState(&m);
+ qglColorMask(1,1,1,1);
+ qglBlendFunc(GL_DST_ALPHA, GL_ONE);
+ qglEnable(GL_BLEND);
+ if (lightcubemap)
+ R_Shadow_GenTexCoords_LightCubeMap(varray_texcoord[1], numverts, varray_vertex, relativelightorigin);
+
+ colorscale = r_colorscale * r_shadow_lightintensityscale.value;
+ for (mult = 1, scale = ixtable[mult];mult < 64 && (lightcolor[0] * scale * colorscale > 1 || lightcolor[1] * scale * colorscale > 1 || lightcolor[2] * scale * colorscale > 1);mult++, scale = ixtable[mult]);
+ colorscale *= scale;
+ GL_Color(lightcolor[0] * colorscale, lightcolor[1] * colorscale, lightcolor[2] * colorscale, 1);
+ for (renders = 0;renders < mult;renders++)
+ R_Mesh_Draw(numverts, numtriangles, elements);
+ }
+ 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[0] = GL_REPLACE;
+ m.texcombinergb[1] = GL_DOT3_RGBA_ARB;
+ R_Mesh_TextureState(&m);
+ qglBlendFunc(GL_DST_ALPHA, GL_ZERO);
+ qglEnable(GL_BLEND);
+ memcpy(varray_texcoord[0], texcoords, numverts * sizeof(float[4]));
+ R_Shadow_GenTexCoords_Diffuse_NormalCubeMap(varray_texcoord[1], numverts, varray_vertex, svectors, tvectors, normals, relativelightorigin);
+ R_Mesh_Draw(numverts, numtriangles, elements);
+
+ m.tex[0] = R_GetTexture(basetexture);
+ m.texcubemap[1] = R_GetTexture(lightcubemap);
+ m.texcombinergb[0] = GL_MODULATE;
+ m.texcombinergb[1] = GL_MODULATE;
+ R_Mesh_TextureState(&m);
+ qglColorMask(1,1,1,1);
+ qglBlendFunc(GL_DST_ALPHA, GL_ONE);
+ if (lightcubemap)
+ R_Shadow_GenTexCoords_LightCubeMap(varray_texcoord[1], numverts, varray_vertex, relativelightorigin);
+
+ colorscale = r_colorscale * r_shadow_lightintensityscale.value;
+ for (mult = 1, scale = ixtable[mult];mult < 64 && (lightcolor[0] * scale * colorscale > 1 || lightcolor[1] * scale * colorscale > 1 || lightcolor[2] * scale * colorscale > 1);mult++, scale = ixtable[mult]);
+ colorscale *= scale;
+ GL_Color(lightcolor[0] * colorscale, lightcolor[1] * colorscale, lightcolor[2] * colorscale, 1);
+ for (renders = 0;renders < mult;renders++)
+ R_Mesh_Draw(numverts, numtriangles, elements);
+ }
+}
+
+void R_Shadow_SpecularLighting(int numverts, int numtriangles, const int *elements, const float *svectors, const float *tvectors, const float *normals, const float *texcoords, const float *relativelightorigin, const float *relativeeyeorigin, float lightradius, const float *lightcolor, rtexture_t *glosstexture, rtexture_t *bumptexture, rtexture_t *lightcubemap)
+{
+ int renders, mult;
+ float scale, colorscale;
+ rmeshstate_t m;
+ memset(&m, 0, sizeof(m));
+ if (!bumptexture)
+ bumptexture = r_shadow_blankbumptexture;
+ if (!glosstexture)
+ glosstexture = r_shadow_blankglosstexture;
+ if (r_shadow_gloss.integer >= 2 || (r_shadow_gloss.integer >= 1 && glosstexture != r_shadow_blankglosstexture))
+ {
+ // 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);
+
+ colorscale = r_colorscale * r_shadow_lightintensityscale.value;
+ for (mult = 1, scale = ixtable[mult];mult < 64 && (lightcolor[0] * scale * colorscale > 1 || lightcolor[1] * scale * colorscale > 1 || lightcolor[2] * scale * colorscale > 1);mult++, scale = ixtable[mult]);
+ colorscale *= scale;
+ GL_Color(lightcolor[0] * colorscale, lightcolor[1] * colorscale, lightcolor[2] * colorscale, 1);
+ for (renders = 0;renders < mult;renders++)
+ R_Mesh_Draw(numverts, numtriangles, elements);
+ }
+}
+
+void R_Shadow_DrawWorldLightShadowVolume(matrix4x4_t *matrix, worldlight_t *light)
+{
+ R_Mesh_Matrix(matrix);
+ R_Shadow_RenderShadowMeshVolume(light->shadowvolume);
+}
+
+cvar_t r_editlights = {0, "r_editlights", "0"};
+cvar_t r_editlights_cursordistance = {0, "r_editlights_distance", "1024"};
+cvar_t r_editlights_cursorpushback = {0, "r_editlights_pushback", "0"};
+cvar_t r_editlights_cursorpushoff = {0, "r_editlights_pushoff", "4"};
+cvar_t r_editlights_cursorgrid = {0, "r_editlights_grid", "4"};
+cvar_t r_editlights_quakelightsizescale = {CVAR_SAVE, "r_editlights_quakelightsizescale", "0.8"};
+worldlight_t *r_shadow_worldlightchain;
+worldlight_t *r_shadow_selectedlight;
+vec3_t r_editlights_cursorlocation;
+
+static int castshadowcount = 1;
+void R_Shadow_NewWorldLight(vec3_t origin, float radius, vec3_t color, int style, const char *cubemapname)
+{
+ int i, j, k, l, maxverts, *mark, tris;
+ float *verts, *v, f, temp[3], radius2;
+ //float projectdistance, *v0, *v1, temp2[3], temp3[3];
+ worldlight_t *e;
+ shadowmesh_t *mesh, *castmesh;
+ mleaf_t *leaf;
+ msurface_t *surf;
+ qbyte *pvs;
+ surfmesh_t *surfmesh;
+
+ 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;
+ e->next = r_shadow_worldlightchain;
+ r_shadow_worldlightchain = e;
+ if (cubemapname)
+ {
+ e->cubemapname = Mem_Alloc(r_shadow_mempool, strlen(cubemapname) + 1);
+ strcpy(e->cubemapname, cubemapname);
+ // FIXME: add cubemap loading (and don't load a cubemap twice)
+ }
+ 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++)
+ {
+ if (pvs[i >> 3] & (1 << (i & 7)))