cvar_t r_shadow_glsl_offsetmapping = {0, "r_shadow_glsl_offsetmapping", "1"};
cvar_t r_shadow_glsl_offsetmapping_scale = {0, "r_shadow_glsl_offsetmapping_scale", "-0.04"};
cvar_t r_shadow_glsl_offsetmapping_bias = {0, "r_shadow_glsl_offsetmapping_bias", "0.04"};
+cvar_t r_shadow_glsl_geforcefxlowquality = {0, "r_shadow_glsl_geforcefxlowquality", "1"};
+cvar_t r_shadow_glsl_surfacenormalize = {0, "r_shadow_glsl_surfacenormalize", "1"};
cvar_t gl_ext_stenciltwoside = {0, "gl_ext_stenciltwoside", "1"};
cvar_t r_editlights = {0, "r_editlights", "0"};
cvar_t r_editlights_cursordistance = {0, "r_editlights_cursordistance", "1024"};
#define SHADERPERMUTATION_FOG (1<<1)
#define SHADERPERMUTATION_CUBEFILTER (1<<2)
#define SHADERPERMUTATION_OFFSETMAPPING (1<<3)
-#define SHADERPERMUTATION_COUNT (1<<4)
+#define SHADERPERMUTATION_SURFACENORMALIZE (1<<4)
+#define SHADERPERMUTATION_GEFORCEFX (1<<5)
+#define SHADERPERMUTATION_COUNT (1<<6)
GLhandleARB r_shadow_program_light[SHADERPERMUTATION_COUNT];
"// ambient+diffuse+specular+normalmap+attenuation+cubemap+fog shader\n"
"// written by Forest 'LordHavoc' Hale\n"
"\n"
-"uniform vec3 LightColor;\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"
+"#endif\n"
"\n"
+"uniform hvec3 LightColor;\n"
"#ifdef USEOFFSETMAPPING\n"
-"uniform float OffsetMapping_Scale;\n"
-"uniform float OffsetMapping_Bias;\n"
+"uniform half OffsetMapping_Scale;\n"
+"uniform half OffsetMapping_Bias;\n"
"#endif\n"
"#ifdef USESPECULAR\n"
-"uniform float SpecularPower;\n"
+"uniform half SpecularPower;\n"
"#endif\n"
"#ifdef USEFOG\n"
-"uniform float FogRangeRecip;\n"
+"uniform half FogRangeRecip;\n"
"#endif\n"
-"uniform float AmbientScale;\n"
-"uniform float DiffuseScale;\n"
+"uniform half AmbientScale;\n"
+"uniform half DiffuseScale;\n"
"#ifdef USESPECULAR\n"
-"uniform float SpecularScale;\n"
+"uniform half SpecularScale;\n"
"#endif\n"
"\n"
"uniform sampler2D Texture_Normal;\n"
" //\n"
" // pow(1-(x*x+y*y+z*z), 4) is far more realistic but needs large lights to\n"
" // provide significant illumination, large = slow = pain.\n"
-" float colorscale = max(1.0 - dot(CubeVector, CubeVector), 0.0);\n"
+" half colorscale = max(1.0 - dot(CubeVector, CubeVector), 0.0);\n"
"\n"
"#ifdef USEFOG\n"
" // apply fog\n"
-" colorscale *= texture2D(Texture_FogMask, vec2(length(EyeVector)*FogRangeRecip, 0)).x;\n"
+" colorscale *= texture2D(Texture_FogMask, hvec2(length(EyeVector)*FogRangeRecip, 0)).x;\n"
"#endif\n"
"\n"
"#ifdef USEOFFSETMAPPING\n"
" // this is 3 sample because of ATI Radeon 9500-9800/X300 limits\n"
-" vec2 OffsetVector = normalize(EyeVector).xy * vec2(-0.333, 0.333);\n"
-" vec2 TexCoordOffset = TexCoord + OffsetVector * (OffsetMapping_Bias + OffsetMapping_Scale * texture2D(Texture_Normal, TexCoord).w);\n"
+" 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"
" TexCoordOffset += OffsetVector * (OffsetMapping_Bias + OffsetMapping_Scale * texture2D(Texture_Normal, TexCoordOffset).w);\n"
" TexCoordOffset += OffsetVector * (OffsetMapping_Bias + OffsetMapping_Scale * texture2D(Texture_Normal, TexCoordOffset).w);\n"
"#define TexCoord TexCoordOffset\n"
"#endif\n"
"\n"
-" // get the texels - with a blendmap we'd need to blend multiple here\n"
-" vec3 surfacenormal = -1.0 + 2.0 * vec3(texture2D(Texture_Normal, TexCoord));\n"
-" vec3 colortexel = vec3(texture2D(Texture_Color, TexCoord));\n"
-"#ifdef USESPECULAR\n"
-" vec3 glosstexel = vec3(texture2D(Texture_Gloss, TexCoord));\n"
+" // get the surface normal\n"
+"#ifdef SURFACENORMALIZE\n"
+" hvec3 surfacenormal = normalize(hvec3(texture2D(Texture_Normal, TexCoord)) - 0.5);\n"
+"#else\n"
+" hvec3 surfacenormal = -1.0 + 2.0 * hvec3(texture2D(Texture_Normal, TexCoord));\n"
"#endif\n"
"\n"
" // calculate shading\n"
-" vec3 diffusenormal = normalize(LightVector);\n"
-" vec3 color = colortexel * (AmbientScale + DiffuseScale * max(dot(surfacenormal, diffusenormal), 0.0));\n"
+" hvec3 diffusenormal = hvec3(normalize(LightVector));\n"
+" hvec3 color = hvec3(texture2D(Texture_Color, TexCoord)) * (AmbientScale + DiffuseScale * max(dot(surfacenormal, diffusenormal), 0.0));\n"
"#ifdef USESPECULAR\n"
-" color += glosstexel * (SpecularScale * pow(max(dot(surfacenormal, normalize(diffusenormal + normalize(EyeVector))), 0.0), SpecularPower));\n"
+" 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"
"#endif\n"
"\n"
"#ifdef USECUBEFILTER\n"
" // apply light cubemap filter\n"
-" color *= vec3(textureCube(Texture_Cube, CubeVector));\n"
+" color *= hvec3(textureCube(Texture_Cube, CubeVector));\n"
"#endif\n"
"\n"
-" // calculate fragment color\n"
-" gl_FragColor = vec4(LightColor * color * colorscale, 1);\n"
+" // calculate fragment color (apply light color and attenuation/fog scaling)\n"
+" gl_FragColor = hvec4(color * LightColor * colorscale, 1);\n"
"}\n"
;
void r_shadow_start(void)
{
int i;
+ // if not a GeForce FX, turn off the lowquality cvar
+ if (strncmp(gl_renderer, "GeForce FX ", strlen("GeForce FX ")))
+ Cvar_SetValue("r_shadow_glsl_geforcefxlowquality", 0);
// allocate vertex processing arrays
numcubemaps = 0;
r_shadow_attenuation2dtexture = NULL;
char *vertstring, *fragstring;
int vertstrings_count;
int fragstrings_count;
- const char *vertstrings_list[SHADERPERMUTATION_COUNT];
- const char *fragstrings_list[SHADERPERMUTATION_COUNT];
- vertstring = FS_LoadFile("glsl/light.vert", tempmempool, false);
- fragstring = FS_LoadFile("glsl/light.frag", tempmempool, false);
+ const char *vertstrings_list[SHADERPERMUTATION_COUNT+1];
+ const char *fragstrings_list[SHADERPERMUTATION_COUNT+1];
+ vertstring = (char *)FS_LoadFile("glsl/light.vert", tempmempool, false);
+ fragstring = (char *)FS_LoadFile("glsl/light.frag", tempmempool, false);
for (i = 0;i < SHADERPERMUTATION_COUNT;i++)
{
vertstrings_count = 0;
vertstrings_list[vertstrings_count++] = "#define USEOFFSETMAPPING\n";
fragstrings_list[fragstrings_count++] = "#define USEOFFSETMAPPING\n";
}
+ if (i & SHADERPERMUTATION_SURFACENORMALIZE)
+ {
+ vertstrings_list[vertstrings_count++] = "#define SURFACENORMALIZE\n";
+ fragstrings_list[fragstrings_count++] = "#define SURFACENORMALIZE\n";
+ }
+ if (i & SHADERPERMUTATION_GEFORCEFX)
+ {
+ vertstrings_list[vertstrings_count++] = "#define GEFORCEFX\n";
+ fragstrings_list[fragstrings_count++] = "#define GEFORCEFX\n";
+ }
vertstrings_list[vertstrings_count++] = vertstring ? vertstring : builtinshader_light_vert;
fragstrings_list[fragstrings_count++] = fragstring ? fragstring : builtinshader_light_frag;
r_shadow_program_light[i] = GL_Backend_CompileProgram(vertstrings_count, vertstrings_list, fragstrings_count, fragstrings_list);
"r_shadow_glsl_offsetmapping : enables Offset Mapping bumpmap enhancement\n"
"r_shadow_glsl_offsetmapping_scale : controls depth of Offset Mapping\n"
"r_shadow_glsl_offsetmapping_bias : should be negative half of scale\n"
+"r_shadow_glsl_geforcefxlowquality : use lower quality lighting\n"
+"r_shadow_glsl_surfacenormalize : makes bumpmapping slightly higher quality\n"
"r_shadow_scissor : use scissor optimization\n"
"r_shadow_shadow_polygonfactor : nudge shadow volumes closer/further\n"
"r_shadow_shadow_polygonoffset : nudge shadow volumes closer/further\n"
Cvar_RegisterVariable(&r_shadow_glsl_offsetmapping);
Cvar_RegisterVariable(&r_shadow_glsl_offsetmapping_scale);
Cvar_RegisterVariable(&r_shadow_glsl_offsetmapping_bias);
+ Cvar_RegisterVariable(&r_shadow_glsl_geforcefxlowquality);
+ Cvar_RegisterVariable(&r_shadow_glsl_surfacenormalize);
Cvar_RegisterVariable(&gl_ext_stenciltwoside);
if (gamemode == GAME_TENEBRAE)
{
R_RegisterModule("R_Shadow", r_shadow_start, r_shadow_shutdown, r_shadow_newmap);
}
-static matrix4x4_t matrix_attenuationxyz =
+matrix4x4_t matrix_attenuationxyz =
{
{
{0.5, 0.0, 0.0, 0.5},
}
};
-static matrix4x4_t matrix_attenuationz =
+matrix4x4_t matrix_attenuationz =
{
{
{0.0, 0.0, 0.5, 0.5},
// 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 (r_shadow_rtlight->specularscale && r_shadow_program_light[r_shadow_lightpermutation | SHADERPERMUTATION_SPECULAR])
+ 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;
r_shadow_lightpermutation |= SHADERPERMUTATION_CUBEFILTER;
if (r_shadow_glsl_offsetmapping.integer && r_shadow_program_light[r_shadow_lightpermutation | SHADERPERMUTATION_OFFSETMAPPING])
r_shadow_lightpermutation |= SHADERPERMUTATION_OFFSETMAPPING;
+ if (r_shadow_glsl_surfacenormalize.integer && r_shadow_program_light[r_shadow_lightpermutation | SHADERPERMUTATION_SURFACENORMALIZE])
+ r_shadow_lightpermutation |= SHADERPERMUTATION_SURFACENORMALIZE;
+ if (r_shadow_glsl_geforcefxlowquality.integer && r_shadow_program_light[r_shadow_lightpermutation | SHADERPERMUTATION_GEFORCEFX])
+ r_shadow_lightpermutation |= SHADERPERMUTATION_GEFORCEFX;
r_shadow_lightprog = r_shadow_program_light[r_shadow_lightpermutation];
qglUseProgramObjectARB(r_shadow_lightprog);CHECKGLERROR
// TODO: support fog (after renderer is converted to texture fog)
qglUniform1fARB(qglGetUniformLocationARB(r_shadow_lightprog, "OffsetMapping_Bias"), r_shadow_glsl_offsetmapping_bias.value);CHECKGLERROR
}
}
- else if (gl_dot3arb && gl_texturecubemap && gl_combine.integer && gl_stencil)
+ else if (gl_dot3arb && gl_texturecubemap && r_textureunits.integer >= 2 && gl_combine.integer && gl_stencil)
r_shadowstage = R_SHADOWSTAGE_LIGHT_DOT3;
else
r_shadowstage = R_SHADOWSTAGE_LIGHT_VERTEX;
return true;
// the light area is visible, set up the scissor rectangle
- GL_Scissor(ix1, vid.realheight - iy2, ix2 - ix1, iy2 - iy1);
+ GL_Scissor(ix1, vid.height - iy2, ix2 - ix1, iy2 - iy1);
//qglScissor(ix1, iy1, ix2 - ix1, iy2 - iy1);
//qglEnable(GL_SCISSOR_TEST);
c_rt_scissored++;
for (i = 0;i < numverts;i++, vertex3f += 3, svector3f += 3, tvector3f += 3, normal3f += 3, out3f += 3)
{
VectorSubtract(vertex3f, relativelightorigin, lightdir);
- VectorNormalizeFast(lightdir);
+ VectorNormalize(lightdir);
VectorSubtract(vertex3f, relativeeyeorigin, eyedir);
- VectorNormalizeFast(eyedir);
+ VectorNormalize(eyedir);
VectorAdd(lightdir, eyedir, halfdir);
// the cubemap normalizes this for us
out3f[0] = DotProduct(svector3f, halfdir);
int renders;
float color[3], color2[3], colorscale, specularscale;
rmeshstate_t m;
- // FIXME: support EF_NODEPTHTEST
+ // FIXME: support MATERIALFLAG_NODEPTHTEST
if (!basetexture)
basetexture = r_texture_white;
if (!bumptexture)
int passes = 0;
if (r_shadow_glsl.integer && r_shadow_program_light[0])
passes++; // GLSL shader path (GFFX5200, Radeon 9500)
- else if (gl_dot3arb && gl_texturecubemap && gl_combine.integer && gl_stencil)
+ else if (gl_dot3arb && gl_texturecubemap && r_textureunits.integer >= 2 && gl_combine.integer && gl_stencil)
{
// TODO: add direct pants/shirt rendering
if (pantstexture && (r_shadow_rtlight->ambientscale + r_shadow_rtlight->diffusescale) * VectorLength2(lightcolorpants) > 0.001)
}
FS_StripExtension (r_refdef.worldmodel->name, name, sizeof (name));
strlcat (name, ".rtlights", sizeof (name));
- lightsstring = FS_LoadFile(name, tempmempool, false);
+ lightsstring = (char *)FS_LoadFile(name, tempmempool, false);
if (lightsstring)
{
s = lightsstring;
}
FS_StripExtension (r_refdef.worldmodel->name, name, sizeof (name));
strlcat (name, ".lights", sizeof (name));
- lightsstring = FS_LoadFile(name, tempmempool, false);
+ lightsstring = (char *)FS_LoadFile(name, tempmempool, false);
if (lightsstring)
{
s = lightsstring;
// try to load a .ent file first
FS_StripExtension (r_refdef.worldmodel->name, key, sizeof (key));
strlcat (key, ".ent", sizeof (key));
- data = entfiledata = FS_LoadFile(key, tempmempool, true);
+ data = entfiledata = (char *)FS_LoadFile(key, tempmempool, true);
// and if that is not found, fall back to the bsp file entity string
if (!data)
data = r_refdef.worldmodel->brush.entities;
projects / xonotic / darkplaces.git / blobdiff