"// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n"
"// written by Forest 'LordHavoc' Hale\n"
"\n"
+"// use half floats if available for math performance\n"
+"#ifdef GEFORCEFX\n"
+"#define myhalf half\n"
+"#define myhvec2 hvec2\n"
+"#define myhvec3 hvec3\n"
+"#define myhvec4 hvec4\n"
+"#else\n"
+"#define myhalf float\n"
+"#define myhvec2 vec2\n"
+"#define myhvec3 vec3\n"
+"#define myhvec4 vec4\n"
+"#endif\n"
+"\n"
"uniform vec3 LightPosition;\n"
"\n"
"varying vec2 TexCoord;\n"
-"varying vec3 CubeVector;\n"
+"varying myhvec3 CubeVector;\n"
"varying vec3 LightVector;\n"
"\n"
"#if defined(USESPECULAR) || defined(USEFOG) || defined(USEOFFSETMAPPING)\n"
"void main(void)\n"
"{\n"
" // copy the surface texcoord\n"
-" TexCoord = vec2(gl_TextureMatrix[0] * glMultiTexCoord0);\n"
+" TexCoord = vec2(gl_TextureMatrix[0] * gl_MultiTexCoord0);\n"
"\n"
" // transform vertex position into light attenuation/cubemap space\n"
" // (-1 to +1 across the light box)\n"
"// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n"
"// written by Forest 'LordHavoc' Hale\n"
"\n"
-"// use half floats on GEFORCEFX for math performance, otherwise don't\n"
-"#ifndef GEFORCEFX\n"
-"#define half float\n"
-"#define hvec2 vec2\n"
-"#define hvec3 vec3\n"
-"#define hvec4 vec4\n"
+"// use half floats if available for math performance\n"
+"#ifdef GEFORCEFX\n"
+"#define myhalf half\n"
+"#define myhvec2 hvec2\n"
+"#define myhvec3 hvec3\n"
+"#define myhvec4 hvec4\n"
+"#else\n"
+"#define myhalf float\n"
+"#define myhvec2 vec2\n"
+"#define myhvec3 vec3\n"
+"#define myhvec4 vec4\n"
"#endif\n"
"\n"
-"uniform hvec3 LightColor;\n"
+"uniform myhvec3 LightColor;\n"
"#ifdef USEOFFSETMAPPING\n"
-"uniform half OffsetMapping_Scale;\n"
-"uniform half OffsetMapping_Bias;\n"
+"uniform myhalf OffsetMapping_Scale;\n"
+"uniform myhalf OffsetMapping_Bias;\n"
"#endif\n"
"#ifdef USESPECULAR\n"
-"uniform half SpecularPower;\n"
+"uniform myhalf SpecularPower;\n"
"#endif\n"
"#ifdef USEFOG\n"
-"uniform half FogRangeRecip;\n"
+"uniform myhalf FogRangeRecip;\n"
"#endif\n"
-"uniform half AmbientScale;\n"
-"uniform half DiffuseScale;\n"
+"uniform myhalf AmbientScale;\n"
+"uniform myhalf DiffuseScale;\n"
"#ifdef USESPECULAR\n"
-"uniform half SpecularScale;\n"
+"uniform myhalf SpecularScale;\n"
"#endif\n"
"\n"
"uniform sampler2D Texture_Normal;\n"
"#endif\n"
"\n"
"varying vec2 TexCoord;\n"
-"varying vec3 CubeVector;\n"
+"varying myhvec3 CubeVector;\n"
"varying vec3 LightVector;\n"
"#if defined(USESPECULAR) || defined(USEFOG) || defined(USEOFFSETMAPPING)\n"
"varying vec3 EyeVector;\n"
" //\n"
" // pow(1-(x*x+y*y+z*z), 4) is far more realistic but needs large lights to\n"
" // provide significant illumination, large = slow = pain.\n"
-" half colorscale = max(1.0 - dot(CubeVector, CubeVector), 0.0);\n"
+" myhalf colorscale = max(1.0 - dot(CubeVector, CubeVector), 0.0);\n"
"\n"
"#ifdef USEFOG\n"
" // apply fog\n"
-" colorscale *= texture2D(Texture_FogMask, hvec2(length(EyeVector)*FogRangeRecip, 0)).x;\n"
+" colorscale *= texture2D(Texture_FogMask, myhvec2(length(EyeVector)*FogRangeRecip, 0)).x;\n"
"#endif\n"
"\n"
"#ifdef USEOFFSETMAPPING\n"
" // this is 3 sample because of ATI Radeon 9500-9800/X300 limits\n"
-" hvec2 OffsetVector = normalize(EyeVector).xy * vec2(-0.333, 0.333);\n"
-" hvec2 TexCoordOffset = TexCoord + OffsetVector * (OffsetMapping_Bias + OffsetMapping_Scale * texture2D(Texture_Normal, TexCoord).w);\n"
+" myhvec2 OffsetVector = normalize(EyeVector).xy * vec2(-0.333, 0.333);\n"
+" myhvec2 TexCoordOffset = TexCoord + OffsetVector * (OffsetMapping_Bias + OffsetMapping_Scale * texture2D(Texture_Normal, TexCoord).w);\n"
" TexCoordOffset += OffsetVector * (OffsetMapping_Bias + OffsetMapping_Scale * texture2D(Texture_Normal, TexCoordOffset).w);\n"
" TexCoordOffset += OffsetVector * (OffsetMapping_Bias + OffsetMapping_Scale * texture2D(Texture_Normal, TexCoordOffset).w);\n"
"#define TexCoord TexCoordOffset\n"
"\n"
" // get the surface normal\n"
"#ifdef SURFACENORMALIZE\n"
-" hvec3 surfacenormal = normalize(hvec3(texture2D(Texture_Normal, TexCoord)) - 0.5);\n"
+" myhvec3 surfacenormal = normalize(myhvec3(texture2D(Texture_Normal, TexCoord)) - 0.5);\n"
"#else\n"
-" hvec3 surfacenormal = -1.0 + 2.0 * hvec3(texture2D(Texture_Normal, TexCoord));\n"
+" myhvec3 surfacenormal = -1.0 + 2.0 * myhvec3(texture2D(Texture_Normal, TexCoord));\n"
"#endif\n"
"\n"
" // calculate shading\n"
-" hvec3 diffusenormal = hvec3(normalize(LightVector));\n"
-" hvec3 color = hvec3(texture2D(Texture_Color, TexCoord)) * (AmbientScale + DiffuseScale * max(dot(surfacenormal, diffusenormal), 0.0));\n"
+" myhvec3 diffusenormal = myhvec3(normalize(LightVector));\n"
+" myhvec3 color = myhvec3(texture2D(Texture_Color, TexCoord)) * (AmbientScale + DiffuseScale * max(dot(surfacenormal, diffusenormal), 0.0));\n"
"#ifdef USESPECULAR\n"
-" hvec3 specularnormal = hvec3(normalize(diffusenormal + hvec3(normalize(EyeVector))));\n"
-" color += hvec3(texture2D(Texture_Gloss, TexCoord)) * (SpecularScale * pow(max(dot(surfacenormal, specularnormal), 0.0), SpecularPower));\n"
+" myhvec3 specularnormal = myhvec3(normalize(diffusenormal + myhvec3(normalize(EyeVector))));\n"
+" color += myhvec3(texture2D(Texture_Gloss, TexCoord)) * SpecularScale * pow(max(dot(surfacenormal, specularnormal), 0.0), SpecularPower);\n"
"#endif\n"
"\n"
"#ifdef USECUBEFILTER\n"
" // apply light cubemap filter\n"
-" color *= hvec3(textureCube(Texture_Cube, CubeVector));\n"
+" color *= myhvec3(textureCube(Texture_Cube, CubeVector));\n"
"#endif\n"
"\n"
" // calculate fragment color (apply light color and attenuation/fog scaling)\n"
-" gl_FragColor = hvec4(color * LightColor * colorscale, 1);\n"
+" gl_FragColor = myhvec4(color * LightColor * colorscale, 1);\n"
"}\n"
;
}
if (i & SHADERPERMUTATION_GEFORCEFX)
{
+ // if the extension does not exist, don't try to compile it
+ if (!gl_support_half_float)
+ continue;
vertstrings_list[vertstrings_count++] = "#define GEFORCEFX\n";
fragstrings_list[fragstrings_count++] = "#define GEFORCEFX\n";
}
maxshadowelements = numtris * 24;
if (shadowelements)
Mem_Free(shadowelements);
- shadowelements = Mem_Alloc(r_shadow_mempool, maxshadowelements * sizeof(int));
+ shadowelements = (int *)Mem_Alloc(r_shadow_mempool, maxshadowelements * sizeof(int));
}
return shadowelements;
}
if (r_shadow_buffer_leaflist)
Mem_Free(r_shadow_buffer_leaflist);
r_shadow_buffer_numleafpvsbytes = numleafpvsbytes;
- r_shadow_buffer_leafpvs = Mem_Alloc(r_shadow_mempool, r_shadow_buffer_numleafpvsbytes);
- r_shadow_buffer_leaflist = Mem_Alloc(r_shadow_mempool, r_shadow_buffer_numleafpvsbytes * 8 * sizeof(*r_shadow_buffer_leaflist));
+ r_shadow_buffer_leafpvs = (qbyte *)Mem_Alloc(r_shadow_mempool, r_shadow_buffer_numleafpvsbytes);
+ r_shadow_buffer_leaflist = (int *)Mem_Alloc(r_shadow_mempool, r_shadow_buffer_numleafpvsbytes * 8 * sizeof(*r_shadow_buffer_leaflist));
}
if (r_shadow_buffer_numsurfacepvsbytes < numsurfacepvsbytes)
{
if (r_shadow_buffer_surfacelist)
Mem_Free(r_shadow_buffer_surfacelist);
r_shadow_buffer_numsurfacepvsbytes = numsurfacepvsbytes;
- r_shadow_buffer_surfacepvs = Mem_Alloc(r_shadow_mempool, r_shadow_buffer_numsurfacepvsbytes);
- r_shadow_buffer_surfacelist = Mem_Alloc(r_shadow_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist));
+ r_shadow_buffer_surfacepvs = (qbyte *)Mem_Alloc(r_shadow_mempool, r_shadow_buffer_numsurfacepvsbytes);
+ r_shadow_buffer_surfacelist = (int *)Mem_Alloc(r_shadow_mempool, r_shadow_buffer_numsurfacepvsbytes * 8 * sizeof(*r_shadow_buffer_surfacelist));
}
}
Mem_Free(shadowmark);
if (shadowmarklist)
Mem_Free(shadowmarklist);
- shadowmark = Mem_Alloc(r_shadow_mempool, maxshadowmark * sizeof(*shadowmark));
- shadowmarklist = Mem_Alloc(r_shadow_mempool, maxshadowmark * sizeof(*shadowmarklist));
+ shadowmark = (int *)Mem_Alloc(r_shadow_mempool, maxshadowmark * sizeof(*shadowmark));
+ shadowmarklist = (int *)Mem_Alloc(r_shadow_mempool, maxshadowmark * sizeof(*shadowmarklist));
shadowmarkcount = 0;
}
shadowmarkcount++;
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));
+ vertexupdate = (int *)Mem_Alloc(r_shadow_mempool, maxvertexupdate * sizeof(int));
+ vertexremap = (int *)Mem_Alloc(r_shadow_mempool, maxvertexupdate * sizeof(int));
vertexupdatenum = 0;
}
vertexupdatenum++;
if (maxshadowelements < nummarktris * 24)
R_Shadow_ResizeShadowElements((nummarktris + 256) * 24);
tris = R_Shadow_ConstructShadowVolume(numverts, numtris, elements, neighbors, invertex3f, &outverts, shadowelements, varray_vertex3f2, projectorigin, projectdistance, nummarktris, marktris);
+ renderstats.lights_dynamicshadowtriangles += tris;
R_Shadow_RenderVolume(outverts, tris, varray_vertex3f2, shadowelements);
}
Mod_ShadowMesh_AddMesh(r_shadow_mempool, r_shadow_compilingrtlight->static_meshchain_shadow, NULL, NULL, NULL, vertex3f, NULL, NULL, NULL, NULL, numtriangles, element3i);
return;
}
+ renderstats.lights_shadowtriangles += numtriangles;
memset(&m, 0, sizeof(m));
m.pointer_vertex = vertex3f;
R_Mesh_State(&m);
qglCullFace(GL_BACK); // quake is backwards, this culls front faces
qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);
R_Mesh_Draw(0, numvertices, numtriangles, element3i);
- c_rt_shadowmeshes++;
- c_rt_shadowtris += numtriangles;
// increment stencil if frontface is behind depthbuffer
qglCullFace(GL_FRONT); // quake is backwards, this culls back faces
qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);
}
R_Mesh_Draw(0, numvertices, numtriangles, element3i);
- c_rt_shadowmeshes++;
- c_rt_shadowtris += numtriangles;
GL_LockArrays(0, 0);
}
r_shadow_attenscale = r_shadow_lightattenuationscale.value;
#define ATTEN2DSIZE 64
#define ATTEN3DSIZE 32
- data = Mem_Alloc(tempmempool, max(ATTEN3DSIZE*ATTEN3DSIZE*ATTEN3DSIZE*4, ATTEN2DSIZE*ATTEN2DSIZE*4));
+ data = (qbyte *)Mem_Alloc(tempmempool, max(ATTEN3DSIZE*ATTEN3DSIZE*ATTEN3DSIZE*4, ATTEN2DSIZE*ATTEN2DSIZE*4));
for (y = 0;y < ATTEN2DSIZE;y++)
{
for (x = 0;x < ATTEN2DSIZE;x++)
static matrix4x4_t r_shadow_entitytoattenuationxyz;
// this transforms only the Z to S, and T is always 0.5
static matrix4x4_t r_shadow_entitytoattenuationz;
-// rtlight->color * r_dlightstylevalue[rtlight->style] / 256 * r_shadow_lightintensityscale.value * ent->colormod * ent->alpha
-static vec3_t r_shadow_entitylightcolor;
+// rtlight->color * r_refdef.lightstylevalue[rtlight->style] / 256 * r_shadow_lightintensityscale.value * ent->colormod * ent->alpha
+static vec3_t r_shadow_entitylightcolorbase;
+// rtlight->color * r_refdef.lightstylevalue[rtlight->style] / 256 * r_shadow_lightintensityscale.value * ent->colormap_pantscolor * ent->alpha
+static vec3_t r_shadow_entitylightcolorpants;
+// rtlight->color * r_refdef.lightstylevalue[rtlight->style] / 256 * r_shadow_lightintensityscale.value * ent->colormap_shirtcolor * ent->alpha
+static vec3_t r_shadow_entitylightcolorshirt;
static int r_shadow_lightpermutation;
static int r_shadow_lightprog;
qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
}
GL_Clear(GL_STENCIL_BUFFER_BIT);
- c_rt_clears++;
+ renderstats.lights_clears++;
}
void R_Shadow_Stage_Lighting(int stenciltest)
m.tex[1] = R_GetTexture(r_texture_white); // diffuse
m.tex[2] = R_GetTexture(r_texture_white); // gloss
m.texcubemap[3] = R_GetTexture(r_shadow_lightcubemap); // light filter
- // TODO: support fog (after renderer is converted to texture fog)
- m.tex[4] = R_GetTexture(r_texture_white); // fog
+ m.tex[4] = R_GetTexture(r_texture_fogattenuation); // fog
//m.texmatrix[3] = r_shadow_entitytolight; // light filter matrix
R_Mesh_State(&m);
GL_BlendFunc(GL_ONE, GL_ONE);
// only add a feature to the permutation if that permutation exists
// (otherwise it might end up not using a shader at all, which looks
// worse than using less features)
+ if (fogenabled && r_shadow_program_light[r_shadow_lightpermutation | SHADERPERMUTATION_FOG])
+ r_shadow_lightpermutation |= SHADERPERMUTATION_FOG;
if (r_shadow_rtlight->specularscale && r_shadow_gloss.integer >= 1 && r_shadow_program_light[r_shadow_lightpermutation | SHADERPERMUTATION_SPECULAR])
r_shadow_lightpermutation |= SHADERPERMUTATION_SPECULAR;
- //if (fog && r_shadow_program_light[r_shadow_lightpermutation | SHADERPERMUTATION_FOG])
- // r_shadow_lightpermutation |= SHADERPERMUTATION_FOG;
if (r_shadow_lightcubemap != r_texture_whitecube && r_shadow_program_light[r_shadow_lightpermutation | SHADERPERMUTATION_CUBEFILTER])
r_shadow_lightpermutation |= SHADERPERMUTATION_CUBEFILTER;
if (r_shadow_glsl_offsetmapping.integer && r_shadow_program_light[r_shadow_lightpermutation | SHADERPERMUTATION_OFFSETMAPPING])
// TODO: support fog (after renderer is converted to texture fog)
if (r_shadow_lightpermutation & SHADERPERMUTATION_FOG)
{
- qglUniform1fARB(qglGetUniformLocationARB(r_shadow_lightprog, "FogRangeRecip"), 0);CHECKGLERROR
+ qglUniform1fARB(qglGetUniformLocationARB(r_shadow_lightprog, "FogRangeRecip"), fograngerecip);CHECKGLERROR
}
qglUniform1fARB(qglGetUniformLocationARB(r_shadow_lightprog, "AmbientScale"), r_shadow_rtlight->ambientscale);CHECKGLERROR
qglUniform1fARB(qglGetUniformLocationARB(r_shadow_lightprog, "DiffuseScale"), r_shadow_rtlight->diffusescale);CHECKGLERROR
GL_Scissor(ix1, vid.height - iy2, ix2 - ix1, iy2 - iy1);
//qglScissor(ix1, iy1, ix2 - ix1, iy2 - iy1);
//qglEnable(GL_SCISSOR_TEST);
- c_rt_scissored++;
+ renderstats.lights_scissored++;
return false;
}
qboolean doambientshirt = r_shadow_rtlight->ambientscale * VectorLength2(lightcolorshirt) > 0.00001 && shirttexture != r_texture_black;
qboolean dodiffuseshirt = r_shadow_rtlight->diffusescale * VectorLength2(lightcolorshirt) > 0.00001 && shirttexture != r_texture_black;
qboolean dospecular = specularscale * VectorLength2(lightcolorbase) > 0.00001 && glosstexture != r_texture_black;
- //qboolean dowatershader = (texture->currentmaterialflags & MATERIALFLAG_WATER) && r_watershader.value;
// TODO: add direct pants/shirt rendering
if (doambientpants || dodiffusepants)
R_Shadow_RenderSurfacesLighting_Light_GLSL(ent, texture, numsurfaces, surfacelist, lightcolorpants, vec3_origin, vec3_origin, pantstexture, r_texture_black, r_texture_black, normalmaptexture, r_texture_black, 0, modelorg);
R_Mesh_TexCoordPointer(3, 3, rsurface_normal3f);
GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
GL_LockArrays(0, 0);
}
}
GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
GL_LockArrays(0, 0);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
memset(&m, 0, sizeof(m));
m.pointer_vertex = rsurface_vertex3f;
{
GL_Color(bound(0, color2[0], 1), bound(0, color2[1], 1), bound(0, color2[2], 1), 1);
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
}
GL_LockArrays(0, 0);
}
GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
GL_LockArrays(0, 0);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
memset(&m, 0, sizeof(m));
m.pointer_vertex = rsurface_vertex3f;
GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
GL_LockArrays(0, 0);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
memset(&m, 0, sizeof(m));
m.pointer_vertex = rsurface_vertex3f;
GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
GL_LockArrays(0, 0);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
memset(&m, 0, sizeof(m));
m.pointer_vertex = rsurface_vertex3f;
GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
GL_LockArrays(0, 0);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
memset(&m, 0, sizeof(m));
m.pointer_vertex = rsurface_vertex3f;
GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
GL_LockArrays(0, 0);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
memset(&m, 0, sizeof(m));
m.pointer_vertex = rsurface_vertex3f;
GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
GL_LockArrays(0, 0);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
memset(&m, 0, sizeof(m));
m.pointer_vertex = rsurface_vertex3f;
GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
GL_LockArrays(0, 0);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
memset(&m, 0, sizeof(m));
m.pointer_vertex = rsurface_vertex3f;
{
GL_Color(bound(0, color2[0], 1), bound(0, color2[1], 1), bound(0, color2[2], 1), 1);
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
}
GL_LockArrays(0, 0);
}
GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
GL_LockArrays(0, 0);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
memset(&m, 0, sizeof(m));
m.pointer_vertex = rsurface_vertex3f;
// 0.25 * 0.25 = 0.0625 (this is another pass)
// 0.0625 * 0.0625 = 0.00390625 (this is another pass)
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
GL_LockArrays(0, 0);
memset(&m, 0, sizeof(m));
GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
GL_LockArrays(0, 0);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
memset(&m, 0, sizeof(m));
m.pointer_vertex = rsurface_vertex3f;
GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
GL_LockArrays(0, 0);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
memset(&m, 0, sizeof(m));
m.pointer_vertex = rsurface_vertex3f;
// 0.25 * 0.25 = 0.0625 (this is another pass)
// 0.0625 * 0.0625 = 0.00390625 (this is another pass)
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
GL_LockArrays(0, 0);
memset(&m, 0, sizeof(m));
GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
GL_LockArrays(0, 0);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
memset(&m, 0, sizeof(m));
m.pointer_vertex = rsurface_vertex3f;
// 0.25 * 0.25 = 0.0625 (this is another pass)
// 0.0625 * 0.0625 = 0.00390625 (this is another pass)
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
GL_LockArrays(0, 0);
memset(&m, 0, sizeof(m));
GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
GL_LockArrays(0, 0);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
memset(&m, 0, sizeof(m));
m.pointer_vertex = rsurface_vertex3f;
{
GL_Color(bound(0, color2[0], 1), bound(0, color2[1], 1), bound(0, color2[2], 1), 1);
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
}
GL_LockArrays(0, 0);
}
GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, elements);
GL_LockArrays(0, 0);
- c_rt_lightmeshes++;
- c_rt_lighttris += surface->num_triangles;
}
}
}
}
}
-void R_RTLight_UpdateFromDLight(rtlight_t *rtlight, const dlight_t *light, int isstatic)
+void R_RTLight_Update(dlight_t *light, int isstatic)
{
int j, k;
float scale;
+ rtlight_t *rtlight = &light->rtlight;
R_RTLight_Uncompile(rtlight);
memset(rtlight, 0, sizeof(*rtlight));
rtlight->lightmap_cullradius = bound(0, rtlight->radius, 2048.0f);
rtlight->lightmap_cullradius2 = rtlight->lightmap_cullradius * rtlight->lightmap_cullradius;
- VectorScale(rtlight->color, rtlight->radius * (rtlight->style >= 0 ? d_lightstylevalue[rtlight->style] : 128) * 0.125f, rtlight->lightmap_light);
+ VectorScale(rtlight->color, rtlight->radius * (rtlight->style >= 0 ? r_refdef.lightstylevalue[rtlight->style] : 128) * 0.125f, rtlight->lightmap_light);
rtlight->lightmap_subtract = 1.0f / rtlight->lightmap_cullradius2;
}
R_Shadow_EnlargeLeafSurfaceBuffer(model->brush.num_leafs, model->num_surfaces);
model->GetLightInfo(ent, rtlight->shadoworigin, rtlight->radius, rtlight->cullmins, rtlight->cullmaxs, r_shadow_buffer_leaflist, r_shadow_buffer_leafpvs, &numleafs, r_shadow_buffer_surfacelist, r_shadow_buffer_surfacepvs, &numsurfaces);
numleafpvsbytes = (model->brush.num_leafs + 7) >> 3;
- data = Mem_Alloc(r_shadow_mempool, sizeof(int) * numleafs + numleafpvsbytes + sizeof(int) * numsurfaces);
+ data = (qbyte *)Mem_Alloc(r_shadow_mempool, sizeof(int) * numleafs + numleafpvsbytes + sizeof(int) * numsurfaces);
rtlight->static_numleafs = numleafs;
rtlight->static_numleafpvsbytes = numleafpvsbytes;
- rtlight->static_leaflist = (void *)data;data += sizeof(int) * numleafs;
- rtlight->static_leafpvs = (void *)data;data += numleafpvsbytes;
+ rtlight->static_leaflist = (int *)data;data += sizeof(int) * numleafs;
+ rtlight->static_leafpvs = (qbyte *)data;data += numleafpvsbytes;
rtlight->static_numsurfaces = numsurfaces;
- rtlight->static_surfacelist = (void *)data;data += sizeof(int) * numsurfaces;
+ rtlight->static_surfacelist = (int *)data;data += sizeof(int) * numsurfaces;
if (numleafs)
memcpy(rtlight->static_leaflist, r_shadow_buffer_leaflist, rtlight->static_numleafs * sizeof(*rtlight->static_leaflist));
if (numleafpvsbytes)
R_Mesh_Matrix(&ent->matrix);
for (mesh = rtlight->static_meshchain_shadow;mesh;mesh = mesh->next)
{
+ renderstats.lights_shadowtriangles += mesh->numtriangles;
R_Mesh_VertexPointer(mesh->vertex3f);
GL_LockArrays(0, mesh->numverts);
if (r_shadowstage == R_SHADOWSTAGE_STENCIL)
qglCullFace(GL_BACK); // quake is backwards, this culls front faces
qglStencilOp(GL_KEEP, GL_DECR, GL_KEEP);
R_Mesh_Draw(0, mesh->numverts, mesh->numtriangles, mesh->element3i);
- c_rtcached_shadowmeshes++;
- c_rtcached_shadowtris += mesh->numtriangles;
// increment stencil if frontface is behind depthbuffer
qglCullFace(GL_FRONT); // quake is backwards, this culls back faces
qglStencilOp(GL_KEEP, GL_INCR, GL_KEEP);
}
R_Mesh_Draw(0, mesh->numverts, mesh->numtriangles, mesh->element3i);
- c_rtcached_shadowmeshes++;
- c_rtcached_shadowtris += mesh->numtriangles;
GL_LockArrays(0, 0);
}
}
}
}
-void R_Shadow_DrawEntityLight(entity_render_t *ent, rtlight_t *rtlight, vec3_t lightcolorbase, int numsurfaces, int *surfacelist)
+void R_Shadow_DrawEntityLight(entity_render_t *ent, rtlight_t *rtlight, vec3_t lightcolor, int numsurfaces, int *surfacelist)
{
// set up properties for rendering light onto this entity
- r_shadow_entitylightcolor[0] = lightcolorbase[0] * ent->colormod[0] * ent->alpha;
- r_shadow_entitylightcolor[1] = lightcolorbase[1] * ent->colormod[1] * ent->alpha;
- r_shadow_entitylightcolor[2] = lightcolorbase[2] * ent->colormod[2] * ent->alpha;
+ r_shadow_entitylightcolorbase[0] = lightcolor[0] * ent->colormod[0] * ent->alpha;
+ r_shadow_entitylightcolorbase[1] = lightcolor[1] * ent->colormod[1] * ent->alpha;
+ r_shadow_entitylightcolorbase[2] = lightcolor[2] * ent->colormod[2] * ent->alpha;
+ r_shadow_entitylightcolorpants[0] = lightcolor[0] * ent->colormap_pantscolor[0] * ent->alpha;
+ r_shadow_entitylightcolorpants[1] = lightcolor[1] * ent->colormap_pantscolor[1] * ent->alpha;
+ r_shadow_entitylightcolorpants[2] = lightcolor[2] * ent->colormap_pantscolor[2] * ent->alpha;
+ r_shadow_entitylightcolorshirt[0] = lightcolor[0] * ent->colormap_shirtcolor[0] * ent->alpha;
+ r_shadow_entitylightcolorshirt[1] = lightcolor[1] * ent->colormap_shirtcolor[1] * ent->alpha;
+ r_shadow_entitylightcolorshirt[2] = lightcolor[2] * ent->colormap_shirtcolor[2] * ent->alpha;
Matrix4x4_Concat(&r_shadow_entitytolight, &rtlight->matrix_worldtolight, &ent->matrix);
Matrix4x4_Concat(&r_shadow_entitytoattenuationxyz, &matrix_attenuationxyz, &r_shadow_entitytolight);
Matrix4x4_Concat(&r_shadow_entitytoattenuationz, &matrix_attenuationz, &r_shadow_entitytolight);
}
}
if (ent == r_refdef.worldentity)
- ent->model->DrawLight(ent, r_shadow_entitylightcolor, numsurfaces, surfacelist);
+ ent->model->DrawLight(ent, r_shadow_entitylightcolorbase, r_shadow_entitylightcolorpants, r_shadow_entitylightcolorshirt, numsurfaces, surfacelist);
else
- ent->model->DrawLight(ent, r_shadow_entitylightcolor, ent->model->nummodelsurfaces, ent->model->surfacelist);
+ ent->model->DrawLight(ent, r_shadow_entitylightcolorbase, r_shadow_entitylightcolorpants, r_shadow_entitylightcolorshirt, ent->model->nummodelsurfaces, ent->model->surfacelist);
}
void R_DrawRTLight(rtlight_t *rtlight, qboolean visible)
if (rtlight->ambientscale + rtlight->diffusescale + rtlight->specularscale < (1.0f / 32768.0f))
return;
- f = (rtlight->style >= 0 ? d_lightstylevalue[rtlight->style] : 128) * (1.0f / 256.0f) * r_shadow_lightintensityscale.value;
+ f = (rtlight->style >= 0 ? r_refdef.lightstylevalue[rtlight->style] : 128) * (1.0f / 256.0f) * r_shadow_lightintensityscale.value;
VectorScale(rtlight->color, f, lightcolor);
if (VectorLength2(lightcolor) < (1.0f / 32768.0f))
return;
return;
R_Shadow_Stage_ActiveLight(rtlight);
- c_rt_lights++;
+ renderstats.lights++;
usestencil = false;
if (numshadowentities && (!visible || r_shadow_visiblelighting.integer == 1) && gl_stencil && rtlight->shadow && (rtlight->isstatic ? r_rtworldshadows : r_rtdlightshadows))
if (light->flags & flag)
R_DrawRTLight(&light->rtlight, visible);
if (r_rtdlight)
- for (lnum = 0, light = r_dlight;lnum < r_numdlights;lnum++, light++)
- R_DrawRTLight(&light->rtlight, visible);
+ for (lnum = 0;lnum < r_refdef.numlights;lnum++)
+ R_DrawRTLight(&r_refdef.lights[lnum]->rtlight, visible);
R_Shadow_Stage_End();
}
{
cubemapsize = image_width;
// note this clears to black, so unavailable sides are black
- cubemappixels = Mem_Alloc(tempmempool, 6*cubemapsize*cubemapsize*4);
+ cubemappixels = (qbyte *)Mem_Alloc(tempmempool, 6*cubemapsize*cubemapsize*4);
}
// copy the image with any flipping needed by the suffix (px and posx types don't need flipping)
if (cubemappixels)
dlight_t *R_Shadow_NewWorldLight(void)
{
dlight_t *light;
- light = Mem_Alloc(r_shadow_mempool, sizeof(dlight_t));
+ light = (dlight_t *)Mem_Alloc(r_shadow_mempool, sizeof(dlight_t));
light->next = r_shadow_worldlightchain;
r_shadow_worldlightchain = light;
return light;
light->flags = flags;
Matrix4x4_CreateFromQuakeEntity(&light->matrix, light->origin[0], light->origin[1], light->origin[2], light->angles[0], light->angles[1], light->angles[2], 1);
- R_RTLight_UpdateFromDLight(&light->rtlight, light, true);
+ R_RTLight_Update(light, true);
}
void R_Shadow_FreeWorldLight(dlight_t *light)
void R_Shadow_DrawCursorCallback(const void *calldata1, int calldata2)
{
float scale = r_editlights_cursorgrid.value * 0.5f;
- R_DrawSprite(GL_SRC_ALPHA, GL_ONE, lighttextures[0], false, r_editlights_cursorlocation, r_viewright, r_viewup, scale, -scale, -scale, scale, 1, 1, 1, 0.5f);
+ R_DrawSprite(GL_ONE, GL_ONE, lighttextures[0], NULL, false, r_editlights_cursorlocation, r_viewright, r_viewup, scale, -scale, -scale, scale, 1, 1, 1, 0.5f);
}
void R_Shadow_DrawLightSpriteCallback(const void *calldata1, int calldata2)
{
float intensity;
const dlight_t *light;
- light = calldata1;
+ light = (dlight_t *)calldata1;
intensity = 0.5;
if (light->selected)
intensity = 0.75 + 0.25 * sin(realtime * M_PI * 4.0);
if (!light->shadow)
intensity *= 0.5f;
- R_DrawSprite(GL_SRC_ALPHA, GL_ONE, lighttextures[calldata2], false, light->origin, r_viewright, r_viewup, 8, -8, -8, 8, intensity, intensity, intensity, 0.5);
+ R_DrawSprite(GL_ONE, GL_ONE, lighttextures[calldata2], NULL, false, light->origin, r_viewright, r_viewup, 8, -8, -8, 8, intensity, intensity, intensity, 0.5);
}
void R_Shadow_DrawLightSprites(void)
{
bufmaxchars = bufchars + strlen(line) + 2048;
oldbuf = buf;
- buf = Mem_Alloc(tempmempool, bufmaxchars);
+ buf = (char *)Mem_Alloc(tempmempool, bufmaxchars);
if (oldbuf)
{
if (bufchars)
projects / xonotic / darkplaces.git / blobdiff