X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=gl_rmain.c;h=b1bb20db820bff0ac4fefb921624a85002ee227e;hp=7eee0963fda1b6b8daa80f89643509d933214aef;hb=649e13e4347e891b622d2dbb1a8502c423d92d31;hpb=bc9063582a5b12986a3f70b4eaa9ffaf1568f735 diff --git a/gl_rmain.c b/gl_rmain.c index 7eee0963..b1bb20db 100644 --- a/gl_rmain.c +++ b/gl_rmain.c @@ -112,6 +112,12 @@ cvar_t gl_skyclip = {0, "gl_skyclip", "4608", "nehahra farclip distance - the re cvar_t r_texture_dds_load = {CVAR_SAVE, "r_texture_dds_load", "0", "load compressed dds/filename.dds texture instead of filename.tga, if the file exists (requires driver support)"}; cvar_t r_texture_dds_save = {CVAR_SAVE, "r_texture_dds_save", "0", "save compressed dds/filename.dds texture when filename.tga is loaded, so that it can be loaded instead next time"}; +cvar_t r_texture_convertsRGB_2d = {0, "r_texture_convertsRGB_2d", "0", "load textures as sRGB and convert to linear for proper shading"}; +cvar_t r_texture_convertsRGB_skin = {0, "r_texture_convertsRGB_skin", "0", "load textures as sRGB and convert to linear for proper shading"}; +cvar_t r_texture_convertsRGB_cubemap = {0, "r_texture_convertsRGB_cubemap", "0", "load textures as sRGB and convert to linear for proper shading"}; +cvar_t r_texture_convertsRGB_skybox = {0, "r_texture_convertsRGB_skybox", "0", "load textures as sRGB and convert to linear for proper shading"}; +cvar_t r_texture_convertsRGB_particles = {0, "r_texture_convertsRGB_particles", "0", "load textures as sRGB and convert to linear for proper shading"}; + cvar_t r_textureunits = {0, "r_textureunits", "32", "number of texture units to use in GL 1.1 and GL 1.3 rendering paths"}; static cvar_t gl_combine = {CVAR_READONLY, "gl_combine", "1", "indicates whether the OpenGL 1.3 rendering path is active"}; static cvar_t r_glsl = {CVAR_READONLY, "r_glsl", "1", "indicates whether the OpenGL 2.0 rendering path is active"}; @@ -162,6 +168,9 @@ cvar_t r_track_sprites = {CVAR_SAVE, "r_track_sprites", "1", "track SPR_LABEL* s cvar_t r_track_sprites_flags = {CVAR_SAVE, "r_track_sprites_flags", "1", "1: Rotate sprites accodringly, 2: Make it a continuous rotation"}; cvar_t r_track_sprites_scalew = {CVAR_SAVE, "r_track_sprites_scalew", "1", "width scaling of tracked sprites"}; cvar_t r_track_sprites_scaleh = {CVAR_SAVE, "r_track_sprites_scaleh", "1", "height scaling of tracked sprites"}; +cvar_t r_overheadsprites_perspective = {CVAR_SAVE, "r_overheadsprites_perspective", "0.15", "fake perspective effect for SPR_OVERHEAD sprites"}; +cvar_t r_overheadsprites_pushback = {CVAR_SAVE, "r_overheadsprites_pushback", "16", "how far to pull the SPR_OVERHEAD sprites toward the eye (used to avoid intersections with 3D models)"}; + cvar_t r_glsl_saturation = {CVAR_SAVE, "r_glsl_saturation", "1", "saturation multiplier (only working in glsl!)"}; cvar_t r_framedatasize = {CVAR_SAVE, "r_framedatasize", "1", "size of renderer data cache used during one frame (for skeletal animation caching, light processing, etc)"}; @@ -208,6 +217,18 @@ rtexture_t *r_texture_fogattenuation; rtexture_t *r_texture_gammaramps; unsigned int r_texture_gammaramps_serial; //rtexture_t *r_texture_fogintensity; +rtexture_t *r_texture_reflectcube; + +// TODO: hash lookups? +typedef struct cubemapinfo_s +{ + char basename[64]; + rtexture_t *texture; +} +cubemapinfo_t; + +int r_texture_numcubemaps; +cubemapinfo_t r_texture_cubemaps[MAX_CUBEMAPS]; unsigned int r_queries[MAX_OCCLUSION_QUERIES]; unsigned int r_numqueries; @@ -232,8 +253,6 @@ const float r_screenvertex3f[12] = 0, 1, 0 }; -extern void R_DrawModelShadows(void); - void R_ModulateColors(float *in, float *out, int verts, float r, float g, float b) { int i; @@ -474,7 +493,7 @@ static const char *builtinshaderstring = "#if defined(MODE_LIGHTMAP) || defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n" "#define USELIGHTMAP\n" "#endif\n" -"#if defined(USESPECULAR) || defined(USEOFFSETMAPPING)\n" +"#if defined(USESPECULAR) || defined(USEOFFSETMAPPING) || defined(USEREFLECTCUBE)\n" "#define USEEYEVECTOR\n" "#endif\n" "\n" @@ -801,6 +820,7 @@ static const char *builtinshaderstring = " vec4 ScreenScaleRefractReflectIW = ScreenScaleRefractReflect * (1.0 / ModelViewProjectionPosition.w);\n" " //vec4 ScreenTexCoord = (ModelViewProjectionPosition.xyxy + normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5)).xyxy * DistortScaleRefractReflect * 100) * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n" " vec4 SafeScreenTexCoord = ModelViewProjectionPosition.xyxy * ScreenScaleRefractReflectIW + ScreenCenterRefractReflect;\n" +" //SafeScreenTexCoord = gl_FragCoord.xyxy * vec4(1.0 / 1920.0, 1.0 / 1200.0, 1.0 / 1920.0, 1.0 / 1200.0);\n" " vec4 ScreenTexCoord = SafeScreenTexCoord + vec2(normalize(vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5))).xyxy * DistortScaleRefractReflect;\n" " // FIXME temporary hack to detect the case that the reflection\n" " // gets blackened at edges due to leaving the area that contains actual\n" @@ -840,10 +860,7 @@ static const char *builtinshaderstring = "varying vec3 CubeVector;\n" "#endif\n" "\n" -"#ifdef MODE_LIGHTSOURCE\n" -"varying vec3 LightVector;\n" -"#endif\n" -"#if defined(MODE_LIGHTDIRECTION)\n" +"#if (defined(MODE_LIGHTSOURCE) || defined(MODE_LIGHTDIRECTION)) && defined(USEDIFFUSE)\n" "varying vec3 LightVector;\n" "#endif\n" "\n" @@ -854,7 +871,7 @@ static const char *builtinshaderstring = "varying vec4 EyeVectorModelSpaceFogPlaneVertexDist;\n" "#endif\n" "\n" -"#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY)\n" +"#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY) || defined(USEREFLECTCUBE)\n" "varying vec3 VectorS; // direction of S texcoord (sometimes crudely called tangent)\n" "varying vec3 VectorT; // direction of T texcoord (sometimes crudely called binormal)\n" "varying vec3 VectorR; // direction of R texcoord (surface normal)\n" @@ -877,6 +894,10 @@ static const char *builtinshaderstring = "#endif\n" "uniform vec4 FogPlane;\n" "\n" +"#ifdef USESHADOWMAPORTHO\n" +"varying vec3 ShadowMapTC;\n" +"#endif\n" +"\n" "\n" "\n" "\n" @@ -888,18 +909,14 @@ static const char *builtinshaderstring = "\n" "uniform sampler2D Texture_Normal;\n" "uniform sampler2D Texture_Color;\n" -"//#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n" "uniform sampler2D Texture_Gloss;\n" -"//#endif\n" "#ifdef USEGLOW\n" "uniform sampler2D Texture_Glow;\n" "#endif\n" "#ifdef USEVERTEXTEXTUREBLEND\n" "uniform sampler2D Texture_SecondaryNormal;\n" "uniform sampler2D Texture_SecondaryColor;\n" -"//#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n" "uniform sampler2D Texture_SecondaryGloss;\n" -"//#endif\n" "#ifdef USEGLOW\n" "uniform sampler2D Texture_SecondaryGlow;\n" "#endif\n" @@ -922,12 +939,12 @@ static const char *builtinshaderstring = "#endif\n" "\n" "#ifdef MODE_DEFERREDLIGHTSOURCE\n" -"uniform sampler2DRect Texture_ScreenDepth;\n" -"uniform sampler2DRect Texture_ScreenNormalMap;\n" +"uniform sampler2D Texture_ScreenDepth;\n" +"uniform sampler2D Texture_ScreenNormalMap;\n" "#endif\n" "#ifdef USEDEFERREDLIGHTMAP\n" -"uniform sampler2DRect Texture_ScreenDiffuse;\n" -"uniform sampler2DRect Texture_ScreenSpecular;\n" +"uniform sampler2D Texture_ScreenDiffuse;\n" +"uniform sampler2D Texture_ScreenSpecular;\n" "#endif\n" "\n" "uniform myhalf3 Color_Pants;\n" @@ -1001,6 +1018,9 @@ static const char *builtinshaderstring = "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE)\n" "uniform sampler2D Texture_Attenuation;\n" "uniform samplerCube Texture_Cube;\n" +"#endif\n" +"\n" +"#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USESHADOWMAPORTHO)\n" "\n" "#ifdef USESHADOWMAPRECT\n" "# ifdef USESHADOWSAMPLER\n" @@ -1036,7 +1056,21 @@ static const char *builtinshaderstring = "#endif\n" "\n" "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D)\n" -"# ifndef USESHADOWMAPVSDCT\n" +"# ifdef USESHADOWMAPORTHO\n" +"# define GetShadowMapTC2D(dir) (min(dir, vec3(ShadowMap_Parameters.zw, 1.0)))\n" +"# else\n" +"# ifdef USESHADOWMAPVSDCT\n" +"vec3 GetShadowMapTC2D(vec3 dir)\n" +"{\n" +" vec3 adir = abs(dir);\n" +" vec4 proj = textureCube(Texture_CubeProjection, dir);\n" +" float ma = max(max(adir.x, adir.y), adir.z);\n" +" vec3 stc = vec3(mix(dir.xy, dir.zz, proj.xy) * ShadowMap_Parameters.x, ShadowMap_Parameters.w) / ma;\n" +" stc.xy += proj.zw * ShadowMap_Parameters.y;\n" +" stc.z += ShadowMap_Parameters.z;\n" +" return stc;\n" +"}\n" +"# else\n" "vec3 GetShadowMapTC2D(vec3 dir)\n" "{\n" " vec3 adir = abs(dir);\n" @@ -1079,17 +1113,7 @@ static const char *builtinshaderstring = " stc.z += ShadowMap_Parameters.z;\n" " return stc;\n" "}\n" -"# else\n" -"vec3 GetShadowMapTC2D(vec3 dir)\n" -"{\n" -" vec3 adir = abs(dir);\n" -" vec4 proj = textureCube(Texture_CubeProjection, dir);\n" -" float ma = max(max(adir.x, adir.y), adir.z);\n" -" vec3 stc = vec3(mix(dir.xy, dir.zz, proj.xy) * ShadowMap_Parameters.x, ShadowMap_Parameters.w) / ma;\n" -" stc.xy += proj.zw * ShadowMap_Parameters.y;\n" -" stc.z += ShadowMap_Parameters.z;\n" -" return stc;\n" -"}\n" +"# endif\n" "# endif\n" "#endif // defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D)\n" "\n" @@ -1141,7 +1165,11 @@ static const char *builtinshaderstring = "# endif\n" "\n" "# endif\n" +"# ifdef USESHADOWMAPORTHO\n" +" return mix(ShadowMap_Parameters.x, ShadowMap_Parameters.y, f);\n" +"# else\n" " return f;\n" +"# endif\n" "}\n" "# endif\n" "\n" @@ -1163,9 +1191,9 @@ static const char *builtinshaderstring = "# ifdef USESHADOWMAPPCF\n" "# if defined(GL_ARB_texture_gather) || defined(GL_AMD_texture_texture4)\n" "# ifdef GL_ARB_texture_gather\n" -"# define texval(x, y) textureGatherOffset(Texture_ShadowMap2D, center, ivec(x, y))\n" +"# define texval(x, y) textureGatherOffset(Texture_ShadowMap2D, center, ivec2(x, y))\n" "# else\n" -"# define texval(x, y) texture4(Texture_ShadowMap2D, center + vec2(x,y)*ShadowMap_TextureScale)\n" +"# define texval(x, y) texture4(Texture_ShadowMap2D, center + vec2(x, y)*ShadowMap_TextureScale)\n" "# endif\n" " vec2 center = shadowmaptc.xy - 0.5, offset = fract(center);\n" " center *= ShadowMap_TextureScale;\n" @@ -1204,7 +1232,11 @@ static const char *builtinshaderstring = " f = step(shadowmaptc.z, texture2D(Texture_ShadowMap2D, shadowmaptc.xy*ShadowMap_TextureScale).r);\n" "# endif\n" "# endif\n" +"# ifdef USESHADOWMAPORTHO\n" +" return mix(ShadowMap_Parameters.x, ShadowMap_Parameters.y, f);\n" +"# else\n" " return f;\n" +"# endif\n" "}\n" "# endif\n" "\n" @@ -1222,7 +1254,7 @@ static const char *builtinshaderstring = " return f;\n" "}\n" "# endif\n" -"#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE)\n" +"#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE) && !defined(USESHADOWMAPORTHO)\n" "#endif // FRAGMENT_SHADER\n" "\n" "\n" @@ -1281,11 +1313,13 @@ static const char *builtinshaderstring = "\n" "#ifdef USEVERTEXTEXTUREBLEND\n" " vec3 surfacenormal = mix(vec3(texture2D(Texture_SecondaryNormal, TexCoord2)), vec3(texture2D(Texture_Normal, TexCoord)), terrainblend) - vec3(0.5, 0.5, 0.5);\n" +" float a = mix(texture2D(Texture_SecondaryGloss, TexCoord2).a, texture2D(Texture_Gloss, TexCoord).a, terrainblend);\n" "#else\n" " vec3 surfacenormal = vec3(texture2D(Texture_Normal, TexCoord)) - vec3(0.5, 0.5, 0.5);\n" +" float a = texture2D(Texture_Gloss, TexCoord).a;\n" "#endif\n" "\n" -" gl_FragColor = vec4(normalize(surfacenormal.x * VectorS + surfacenormal.y * VectorT + surfacenormal.z * VectorR) * 0.5 + vec3(0.5, 0.5, 0.5), 1);\n" +" gl_FragColor = vec4(normalize(surfacenormal.x * VectorS + surfacenormal.y * VectorT + surfacenormal.z * VectorR) * 0.5 + vec3(0.5, 0.5, 0.5), a);\n" "}\n" "#endif // FRAGMENT_SHADER\n" "#else // !MODE_DEFERREDGEOMETRY\n" @@ -1313,14 +1347,16 @@ static const char *builtinshaderstring = "uniform myhalf3 DeferredColor_Specular;\n" "uniform myhalf SpecularPower;\n" "#endif\n" +"uniform myhalf2 PixelToScreenTexCoord;\n" "void main(void)\n" "{\n" " // calculate viewspace pixel position\n" +" vec2 ScreenTexCoord = gl_FragCoord.xy * PixelToScreenTexCoord;\n" " vec3 position;\n" -" position.z = ScreenToDepth.y / (texture2DRect(Texture_ScreenDepth, gl_FragCoord.xy).r + ScreenToDepth.x);\n" +" position.z = ScreenToDepth.y / (texture2D(Texture_ScreenDepth, ScreenTexCoord).r + ScreenToDepth.x);\n" " position.xy = ModelViewPosition.xy * (position.z / ModelViewPosition.z);\n" " // decode viewspace pixel normal\n" -" myhalf4 normalmap = texture2DRect(Texture_ScreenNormalMap, gl_FragCoord.xy);\n" +" myhalf4 normalmap = texture2D(Texture_ScreenNormalMap, ScreenTexCoord);\n" " myhalf3 surfacenormal = normalize(normalmap.rgb - myhalf3(0.5,0.5,0.5));\n" " // surfacenormal = pixel normal in viewspace\n" " // LightVector = pixel to light in viewspace\n" @@ -1337,10 +1373,10 @@ static const char *builtinshaderstring = " // calculate directional shading\n" " vec3 eyevector = position * -1.0;\n" "# ifdef USEEXACTSPECULARMATH\n" -" myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(eyevector)))*-1.0, 0.0)), SpecularPower);\n" +" myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(eyevector)))*-1.0, 0.0)), SpecularPower * normalmap.a);\n" "# else\n" " myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(eyevector)));\n" -" myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n" +" myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * normalmap.a);\n" "# endif\n" "#endif\n" "\n" @@ -1361,8 +1397,8 @@ static const char *builtinshaderstring = "\n" "# ifdef USECUBEFILTER\n" " vec3 cubecolor = textureCube(Texture_Cube, CubeVector).rgb;\n" -" gl_FragData[0] *= cubecolor;\n" -" gl_FragData[1] *= cubecolor;\n" +" gl_FragData[0].rgb *= cubecolor;\n" +" gl_FragData[1].rgb *= cubecolor;\n" "# endif\n" "}\n" "#endif // FRAGMENT_SHADER\n" @@ -1379,6 +1415,9 @@ static const char *builtinshaderstring = "#ifdef MODE_LIGHTSOURCE\n" "uniform mat4 ModelToLight;\n" "#endif\n" +"#ifdef USESHADOWMAPORTHO\n" +"uniform mat4 ShadowMapMatrix;\n" +"#endif\n" "void main(void)\n" "{\n" "#if defined(MODE_VERTEXCOLOR) || defined(USEVERTEXTEXTUREBLEND)\n" @@ -1428,7 +1467,7 @@ static const char *builtinshaderstring = " EyeVectorModelSpaceFogPlaneVertexDist.w = dot(FogPlane, gl_Vertex);\n" "#endif\n" "\n" -"#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n" +"#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(USEREFLECTCUBE)\n" " VectorS = gl_MultiTexCoord1.xyz;\n" " VectorT = gl_MultiTexCoord2.xyz;\n" " VectorR = gl_MultiTexCoord3.xyz;\n" @@ -1437,6 +1476,10 @@ static const char *builtinshaderstring = " // transform vertex to camera space, using ftransform to match non-VS rendering\n" " gl_Position = ModelViewProjectionMatrix * gl_Vertex;\n" "\n" +"#ifdef USESHADOWMAPORTHO\n" +" ShadowMapTC = vec3(ShadowMapMatrix * gl_Position);\n" +"#endif\n" +"\n" "#ifdef USEREFLECTION\n" " ModelViewProjectionPosition = gl_Position;\n" "#endif\n" @@ -1448,6 +1491,7 @@ static const char *builtinshaderstring = "\n" "#ifdef FRAGMENT_SHADER\n" "#ifdef USEDEFERREDLIGHTMAP\n" +"uniform myhalf2 PixelToScreenTexCoord;\n" "uniform myhalf3 DeferredMod_Diffuse;\n" "uniform myhalf3 DeferredMod_Specular;\n" "#endif\n" @@ -1465,6 +1509,11 @@ static const char *builtinshaderstring = "uniform vec4 ScreenCenterRefractReflect;\n" "uniform myhalf4 ReflectColor;\n" "#endif\n" +"#ifdef USEREFLECTCUBE\n" +"uniform mat4 ModelToReflectCube;\n" +"uniform sampler2D Texture_ReflectMask;\n" +"uniform samplerCube Texture_ReflectCube;\n" +"#endif\n" "#ifdef MODE_LIGHTDIRECTION\n" "uniform myhalf3 LightColor;\n" "#endif\n" @@ -1509,28 +1558,39 @@ static const char *builtinshaderstring = " myhalf3 diffusetex = color.rgb;\n" "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n" "# ifdef USEVERTEXTEXTUREBLEND\n" -" myhalf3 glosstex = mix(myhalf3(texture2D(Texture_SecondaryGloss, TexCoord2)), myhalf3(texture2D(Texture_Gloss, TexCoord)), terrainblend);\n" +" myhalf4 glosstex = mix(myhalf4(texture2D(Texture_SecondaryGloss, TexCoord2)), myhalf4(texture2D(Texture_Gloss, TexCoord)), terrainblend);\n" "# else\n" -" myhalf3 glosstex = myhalf3(texture2D(Texture_Gloss, TexCoord));\n" +" myhalf4 glosstex = myhalf4(texture2D(Texture_Gloss, TexCoord));\n" "# endif\n" "#endif\n" "\n" +"#ifdef USEREFLECTCUBE\n" +" vec3 TangentReflectVector = reflect(-EyeVector, surfacenormal);\n" +" vec3 ModelReflectVector = TangentReflectVector.x * VectorS + TangentReflectVector.y * VectorT + TangentReflectVector.z * VectorR;\n" +" vec3 ReflectCubeTexCoord = vec3(ModelToReflectCube * vec4(ModelReflectVector, 0));\n" +" diffusetex += myhalf3(texture2D(Texture_ReflectMask, TexCoord)) * myhalf3(textureCube(Texture_ReflectCube, ReflectCubeTexCoord));\n" +"#endif\n" +"\n" "\n" "\n" "\n" "#ifdef MODE_LIGHTSOURCE\n" " // light source\n" +"#ifdef USEDIFFUSE\n" " myhalf3 lightnormal = myhalf3(normalize(LightVector));\n" " myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n" " color.rgb = diffusetex * (Color_Ambient + diffuse * Color_Diffuse);\n" "#ifdef USESPECULAR\n" "#ifdef USEEXACTSPECULARMATH\n" -" myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower);\n" +" myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a);\n" "#else\n" " myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(EyeVector)));\n" -" myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n" +" myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a);\n" "#endif\n" -" color.rgb += glosstex * (specular * Color_Specular);\n" +" color.rgb += glosstex.rgb * (specular * Color_Specular);\n" +"#endif\n" +"#else\n" +" color.rgb = diffusetex * Color_Ambient;\n" "#endif\n" " color.rgb *= LightColor;\n" " color.rgb *= myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n" @@ -1547,7 +1607,9 @@ static const char *builtinshaderstring = "\n" "#ifdef MODE_LIGHTDIRECTION\n" "#define SHADING\n" +"#ifdef USEDIFFUSE\n" " myhalf3 lightnormal = myhalf3(normalize(LightVector));\n" +"#endif\n" "#define lightcolor LightColor\n" "#endif // MODE_LIGHTDIRECTION\n" "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n" @@ -1599,12 +1661,12 @@ static const char *builtinshaderstring = " myhalf diffuse = myhalf(max(float(dot(surfacenormal, lightnormal)), 0.0));\n" "# ifdef USESPECULAR\n" "# ifdef USEEXACTSPECULARMATH\n" -" myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower);\n" +" myhalf specular = pow(myhalf(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a);\n" "# else\n" " myhalf3 specularnormal = normalize(lightnormal + myhalf3(normalize(EyeVector)));\n" -" myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n" +" myhalf specular = pow(myhalf(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a);\n" "# endif\n" -" color.rgb = diffusetex * Color_Ambient + (diffusetex * Color_Diffuse * diffuse + glosstex * Color_Specular * specular) * lightcolor;\n" +" color.rgb = diffusetex * Color_Ambient + (diffusetex * Color_Diffuse * diffuse + glosstex.rgb * Color_Specular * specular) * lightcolor;\n" "# else\n" " color.rgb = diffusetex * (Color_Ambient + Color_Diffuse * diffuse * lightcolor);\n" "# endif\n" @@ -1613,9 +1675,14 @@ static const char *builtinshaderstring = "# endif\n" "#endif\n" "\n" +"#ifdef USESHADOWMAPORTHO\n" +" color.rgb *= ShadowMapCompare(ShadowMapTC);\n" +"#endif\n" +"\n" "#ifdef USEDEFERREDLIGHTMAP\n" -" color.rgb += diffusetex * myhalf3(texture2DRect(Texture_ScreenDiffuse, gl_FragCoord.xy)) * DeferredMod_Diffuse;\n" -" color.rgb += glosstex * myhalf3(texture2DRect(Texture_ScreenSpecular, gl_FragCoord.xy)) * DeferredMod_Specular;\n" +" vec2 ScreenTexCoord = gl_FragCoord.xy * PixelToScreenTexCoord;\n" +" color.rgb += diffusetex * myhalf3(texture2D(Texture_ScreenDiffuse, ScreenTexCoord)) * DeferredMod_Diffuse;\n" +" color.rgb += glosstex.rgb * myhalf3(texture2D(Texture_ScreenSpecular, ScreenTexCoord)) * DeferredMod_Specular;\n" "#endif\n" "\n" "#ifdef USEGLOW\n" @@ -1707,7 +1774,7 @@ const char *builtincgshaderstring = "#if defined(MODE_LIGHTMAP) || defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_LIGHTDIRECTIONMAP_TANGENTSPACE)\n" "#define USELIGHTMAP\n" "#endif\n" -"#if defined(USESPECULAR) || defined(USEOFFSETMAPPING)\n" +"#if defined(USESPECULAR) || defined(USEOFFSETMAPPING) || defined(USEREFLECTCUBE)\n" "#define USEEYEVECTOR\n" "#endif\n" "\n" @@ -1812,7 +1879,7 @@ const char *builtincgshaderstring = " gl_FragColor += tex2D(Texture_Second, TexCoord2);\n" "#endif\n" "#ifdef USEVIEWTINT\n" -" gl_FragColor = mix(gl_FragColor, ViewTintColor, ViewTintColor.a);\n" +" gl_FragColor = lerp(gl_FragColor, ViewTintColor, ViewTintColor.a);\n" "#endif\n" "\n" "#ifdef USEPOSTPROCESSING\n" @@ -1830,7 +1897,7 @@ const char *builtincgshaderstring = " //apply saturation BEFORE gamma ramps, so v_glslgamma value does not matter\n" " float y = dot(gl_FragColor.rgb, float3(0.299, 0.587, 0.114));\n" " //gl_FragColor = float3(y) + (gl_FragColor.rgb - float3(y)) * Saturation;\n" -" gl_FragColor.rgb = mix(float3(y), gl_FragColor.rgb, Saturation);\n" +" gl_FragColor.rgb = lerp(float3(y), gl_FragColor.rgb, Saturation);\n" "#endif\n" "\n" "#ifdef USEGAMMARAMPS\n" @@ -1901,7 +1968,7 @@ const char *builtincgshaderstring = " gl_FragColor += tex2;\n" "# endif\n" "# ifdef USEVERTEXTEXTUREBLEND\n" -" gl_FragColor = mix(gl_FragColor, tex2, tex2.a);\n" +" gl_FragColor = lerp(gl_FragColor, tex2, tex2.a);\n" "# endif\n" "#endif\n" "}\n" @@ -1957,7 +2024,7 @@ const char *builtincgshaderstring = "float4 gl_Vertex : POSITION,\n" "uniform float4x4 ModelViewProjectionMatrix,\n" "float4 gl_MultiTexCoord0 : TEXCOORD0,\n" -"uniform mat4 TexMatrix,\n" +"uniform float4x4 TexMatrix,\n" "uniform float3 EyePosition,\n" "out float4 gl_Position : POSITION,\n" "out float2 TexCoord : TEXCOORD0,\n" @@ -2000,7 +2067,7 @@ const char *builtincgshaderstring = " f *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord + float2(0.01, -0.01)).rgb) / 0.05);\n" " f *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord + float2(-0.01, 0.01)).rgb) / 0.05);\n" " f *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord + float2(-0.01, -0.01)).rgb) / 0.05);\n" -" ScreenTexCoord = mix(SafeScreenTexCoord, ScreenTexCoord, f);\n" +" ScreenTexCoord = lerp(SafeScreenTexCoord, ScreenTexCoord, f);\n" " gl_FragColor = tex2D(Texture_Refraction, ScreenTexCoord) * RefractColor;\n" "}\n" "#endif\n" @@ -2017,7 +2084,7 @@ const char *builtincgshaderstring = "float4 gl_Vertex : POSITION,\n" "uniform float4x4 ModelViewProjectionMatrix,\n" "float4 gl_MultiTexCoord0 : TEXCOORD0,\n" -"uniform mat4 TexMatrix,\n" +"uniform float4x4 TexMatrix,\n" "uniform float3 EyePosition,\n" "out float4 gl_Position : POSITION,\n" "out float2 TexCoord : TEXCOORD0,\n" @@ -2067,14 +2134,14 @@ const char *builtincgshaderstring = " f *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord.xy + float2(0.01, -0.01)).rgb) / 0.05);\n" " f *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord.xy + float2(-0.01, 0.01)).rgb) / 0.05);\n" " f *= min(1.0, length(tex2D(Texture_Refraction, ScreenTexCoord.xy + float2(-0.01, -0.01)).rgb) / 0.05);\n" -" ScreenTexCoord.xy = mix(SafeScreenTexCoord.xy, ScreenTexCoord.xy, f);\n" +" ScreenTexCoord.xy = lerp(SafeScreenTexCoord.xy, ScreenTexCoord.xy, f);\n" " f = min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord.zw + float2(0.01, 0.01)).rgb) / 0.05);\n" " f *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord.zw + float2(0.01, -0.01)).rgb) / 0.05);\n" " f *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord.zw + float2(-0.01, 0.01)).rgb) / 0.05);\n" " f *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord.zw + float2(-0.01, -0.01)).rgb) / 0.05);\n" -" ScreenTexCoord.zw = mix(SafeScreenTexCoord.zw, ScreenTexCoord.zw, f);\n" +" ScreenTexCoord.zw = lerp(SafeScreenTexCoord.zw, ScreenTexCoord.zw, f);\n" " float Fresnel = pow(min(1.0, 1.0 - float(normalize(EyeVector).z)), 2.0) * ReflectFactor + ReflectOffset;\n" -" gl_FragColor = mix(tex2D(Texture_Refraction, ScreenTexCoord.xy) * RefractColor, tex2D(Texture_Reflection, ScreenTexCoord.zw) * ReflectColor, Fresnel);\n" +" gl_FragColor = lerp(tex2D(Texture_Refraction, ScreenTexCoord.xy) * RefractColor, tex2D(Texture_Reflection, ScreenTexCoord.zw) * ReflectColor, Fresnel);\n" "}\n" "#endif\n" "#else // !MODE_WATER\n" @@ -2145,9 +2212,23 @@ const char *builtincgshaderstring = "}\n" "#endif // USEOFFSETMAPPING\n" "\n" -"#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE)\n" +"#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USESHADOWMAPORTHO)\n" "#if defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D)\n" -"# ifndef USESHADOWMAPVSDCT\n" +"# ifdef USESHADOWMAPORTHO\n" +"# define GetShadowMapTC2D(dir, ShadowMap_Parameters) (min(dir, float3(ShadowMap_Parameters.zw, 1.0)))\n" +"# else\n" +"# ifdef USESHADOWMAPVSDCT\n" +"float3 GetShadowMapTC2D(float3 dir, float4 ShadowMap_Parameters, samplerCUBE Texture_CubeProjection)\n" +"{\n" +" float3 adir = abs(dir);\n" +" float4 proj = texCUBE(Texture_CubeProjection, dir);\n" +" float ma = max(max(adir.x, adir.y), adir.z);\n" +" float3 stc = float3(lerp(dir.xy, dir.zz, proj.xy) * ShadowMap_Parameters.x, ShadowMap_Parameters.w) / ma;\n" +" stc.xy += proj.zw * ShadowMap_Parameters.y;\n" +" stc.z += ShadowMap_Parameters.z;\n" +" return stc;\n" +"}\n" +"# else\n" "float3 GetShadowMapTC2D(float3 dir, float4 ShadowMap_Parameters)\n" "{\n" " float3 adir = abs(dir);\n" @@ -2160,13 +2241,13 @@ const char *builtincgshaderstring = " {\n" " ma = adir.x;\n" " tc = dir.zy;\n" -" offset = float2(mix(0.5, 1.5, dir.x < 0.0), 0.5);\n" +" offset = float2(lerp(0.5, 1.5, dir.x < 0.0), 0.5);\n" " }\n" " else // Z\n" " {\n" " ma = adir.z;\n" " tc = dir.xy;\n" -" offset = float2(mix(0.5, 1.5, dir.z < 0.0), 2.5);\n" +" offset = float2(lerp(0.5, 1.5, dir.z < 0.0), 2.5);\n" " }\n" " }\n" " else\n" @@ -2175,13 +2256,13 @@ const char *builtincgshaderstring = " {\n" " ma = adir.y;\n" " tc = dir.xz;\n" -" offset = float2(mix(0.5, 1.5, dir.y < 0.0), 1.5);\n" +" offset = float2(lerp(0.5, 1.5, dir.y < 0.0), 1.5);\n" " }\n" " else // Z\n" " {\n" " ma = adir.z;\n" " tc = dir.xy;\n" -" offset = float2(mix(0.5, 1.5, dir.z < 0.0), 2.5);\n" +" offset = float2(lerp(0.5, 1.5, dir.z < 0.0), 2.5);\n" " }\n" " }\n" "\n" @@ -2190,19 +2271,9 @@ const char *builtincgshaderstring = " stc.z += ShadowMap_Parameters.z;\n" " return stc;\n" "}\n" -"# else\n" -"float3 GetShadowMapTC2D(float3 dir, float4 ShadowMap_Parameters, samplerCUBE Texture_CubeProjection)\n" -"{\n" -" float3 adir = abs(dir);\n" -" float4 proj = texCUBE(Texture_CubeProjection, dir);\n" -" float ma = max(max(adir.x, adir.y), adir.z);\n" -" float3 stc = float3(mix(dir.xy, dir.zz, proj.xy) * ShadowMap_Parameters.x, ShadowMap_Parameters.w) / ma;\n" -" stc.xy += proj.zw * ShadowMap_Parameters.y;\n" -" stc.z += ShadowMap_Parameters.z;\n" -" return stc;\n" -"}\n" +"# endif\n" "# endif\n" -"#endif // defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D)\n" +"#endif // defined(USESHADOWMAPRECT) || defined(USESHADOWMAP2D) || defined(USESHADOWMAPORTHO)\n" "\n" "#ifdef USESHADOWMAPCUBE\n" "float4 GetShadowMapTCCube(float3 dir, float4 ShadowMap_Parameters)\n" @@ -2239,28 +2310,32 @@ const char *builtincgshaderstring = "# ifdef USESHADOWMAPPCF\n" "# if USESHADOWMAPPCF > 1\n" "# define texval(x, y) texRECT(Texture_ShadowMapRect, center + float2(x, y)).r\n" -" float2 center = shadowmaptc.xy - 0.5, offset = fract(center);\n" +" float2 center = shadowmaptc.xy - 0.5, offset = frac(center);\n" " float4 row1 = step(shadowmaptc.z, float4(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0), texval( 2.0, -1.0)));\n" " float4 row2 = step(shadowmaptc.z, float4(texval(-1.0, 0.0), texval( 0.0, 0.0), texval( 1.0, 0.0), texval( 2.0, 0.0)));\n" " float4 row3 = step(shadowmaptc.z, float4(texval(-1.0, 1.0), texval( 0.0, 1.0), texval( 1.0, 1.0), texval( 2.0, 1.0)));\n" " float4 row4 = step(shadowmaptc.z, float4(texval(-1.0, 2.0), texval( 0.0, 2.0), texval( 1.0, 2.0), texval( 2.0, 2.0)));\n" -" float4 cols = row2 + row3 + mix(row1, row4, offset.y);\n" -" f = dot(mix(cols.xyz, cols.yzw, offset.x), float3(1.0/9.0));\n" +" float4 cols = row2 + row3 + lerp(row1, row4, offset.y);\n" +" f = dot(lerp(cols.xyz, cols.yzw, offset.x), float3(1.0/9.0));\n" "# else\n" "# define texval(x, y) texRECT(Texture_ShadowMapRect, shadowmaptc.xy + float2(x, y)).r\n" -" float2 offset = fract(shadowmaptc.xy);\n" +" float2 offset = frac(shadowmaptc.xy);\n" " float3 row1 = step(shadowmaptc.z, float3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n" " float3 row2 = step(shadowmaptc.z, float3(texval(-1.0, 0.0), texval( 0.0, 0.0), texval( 1.0, 0.0)));\n" " float3 row3 = step(shadowmaptc.z, float3(texval(-1.0, 1.0), texval( 0.0, 1.0), texval( 1.0, 1.0)));\n" -" float3 cols = row2 + mix(row1, row3, offset.y);\n" -" f = dot(mix(cols.xy, cols.yz, offset.x), float2(0.25));\n" +" float3 cols = row2 + lerp(row1, row3, offset.y);\n" +" f = dot(lerp(cols.xy, cols.yz, offset.x), float2(0.25));\n" "# endif\n" "# else\n" " f = step(shadowmaptc.z, texRECT(Texture_ShadowMapRect, shadowmaptc.xy).r);\n" "# endif\n" "\n" "# endif\n" +"# ifdef USESHADOWMAPORTHO\n" +" return lerp(ShadowMap_Parameters.x, ShadowMap_Parameters.y, f);\n" +"# else\n" " return f;\n" +"# endif\n" "}\n" "# endif\n" "\n" @@ -2294,44 +2369,44 @@ const char *builtincgshaderstring = "# else\n" "# define texval(x, y) texture4(Texture_ShadowMap2D, center + float2(x,y)*ShadowMap_TextureScale)\n" "# endif\n" -" float2 center = shadowmaptc.xy - 0.5, offset = fract(center);\n" +" float2 center = shadowmaptc.xy - 0.5, offset = frac(center);\n" " center *= ShadowMap_TextureScale;\n" " float4 group1 = step(shadowmaptc.z, texval(-1.0, -1.0));\n" " float4 group2 = step(shadowmaptc.z, texval( 1.0, -1.0));\n" " float4 group3 = step(shadowmaptc.z, texval(-1.0, 1.0));\n" " float4 group4 = step(shadowmaptc.z, texval( 1.0, 1.0));\n" " float4 cols = float4(group1.rg, group2.rg) + float4(group3.ab, group4.ab) +\n" -" mix(float4(group1.ab, group2.ab), float4(group3.rg, group4.rg), offset.y);\n" -" f = dot(mix(cols.xyz, cols.yzw, offset.x), float3(1.0/9.0));\n" +" lerp(float4(group1.ab, group2.ab), float4(group3.rg, group4.rg), offset.y);\n" +" f = dot(lerp(cols.xyz, cols.yzw, offset.x), float3(1.0/9.0));\n" "# else\n" -"# ifdef GL_EXT_gpu_shader4\n" -"# define texval(x, y) tex2DOffset(Texture_ShadowMap2D, center, ifloat2(x, y)).r\n" -"# else\n" -"# define texval(x, y) tex2D(Texture_ShadowMap2D, center + float2(x, y)*ShadowMap_TextureScale).r \n" -"# endif\n" +"# define texval(x, y) texDepth2D(Texture_ShadowMap2D, center + float2(x, y)*ShadowMap_TextureScale) \n" "# if USESHADOWMAPPCF > 1\n" -" float2 center = shadowmaptc.xy - 0.5, offset = fract(center);\n" +" float2 center = shadowmaptc.xy - 0.5, offset = frac(center);\n" " center *= ShadowMap_TextureScale;\n" " float4 row1 = step(shadowmaptc.z, float4(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0), texval( 2.0, -1.0)));\n" " float4 row2 = step(shadowmaptc.z, float4(texval(-1.0, 0.0), texval( 0.0, 0.0), texval( 1.0, 0.0), texval( 2.0, 0.0)));\n" " float4 row3 = step(shadowmaptc.z, float4(texval(-1.0, 1.0), texval( 0.0, 1.0), texval( 1.0, 1.0), texval( 2.0, 1.0)));\n" " float4 row4 = step(shadowmaptc.z, float4(texval(-1.0, 2.0), texval( 0.0, 2.0), texval( 1.0, 2.0), texval( 2.0, 2.0)));\n" -" float4 cols = row2 + row3 + mix(row1, row4, offset.y);\n" -" f = dot(mix(cols.xyz, cols.yzw, offset.x), float3(1.0/9.0));\n" +" float4 cols = row2 + row3 + lerp(row1, row4, offset.y);\n" +" f = dot(lerp(cols.xyz, cols.yzw, offset.x), float3(1.0/9.0));\n" "# else\n" -" float2 center = shadowmaptc.xy*ShadowMap_TextureScale, offset = fract(shadowmaptc.xy);\n" +" float2 center = shadowmaptc.xy*ShadowMap_TextureScale, offset = frac(shadowmaptc.xy);\n" " float3 row1 = step(shadowmaptc.z, float3(texval(-1.0, -1.0), texval( 0.0, -1.0), texval( 1.0, -1.0)));\n" " float3 row2 = step(shadowmaptc.z, float3(texval(-1.0, 0.0), texval( 0.0, 0.0), texval( 1.0, 0.0)));\n" " float3 row3 = step(shadowmaptc.z, float3(texval(-1.0, 1.0), texval( 0.0, 1.0), texval( 1.0, 1.0)));\n" -" float3 cols = row2 + mix(row1, row3, offset.y);\n" -" f = dot(mix(cols.xy, cols.yz, offset.x), float2(0.25));\n" +" float3 cols = row2 + lerp(row1, row3, offset.y);\n" +" f = dot(lerp(cols.xy, cols.yz, offset.x), float2(0.25));\n" "# endif\n" "# endif\n" "# else\n" " f = step(shadowmaptc.z, tex2D(Texture_ShadowMap2D, shadowmaptc.xy*ShadowMap_TextureScale).r);\n" "# endif\n" "# endif\n" -" return f;\n" +"# ifdef USESHADOWMAPORTHO\n" +" return lerp(ShadowMap_Parameters.x, ShadowMap_Parameters.y, f);\n" +"# else\n" +" return f;\n" +"# endif\n" "}\n" "# endif\n" "\n" @@ -2368,14 +2443,20 @@ const char *builtincgshaderstring = "float4 gl_MultiTexCoord1 : TEXCOORD1,\n" "float4 gl_MultiTexCoord2 : TEXCOORD2,\n" "float4 gl_MultiTexCoord3 : TEXCOORD3,\n" -"uniform mat4 TexMatrix,\n" +"uniform float4x4 TexMatrix,\n" "#ifdef USEVERTEXTEXTUREBLEND\n" -"uniform mat4 BackgroundTexMatrix,\n" +"uniform float4x4 BackgroundTexMatrix,\n" +"#endif\n" +"uniform float4x4 ModelViewMatrix,\n" +"#ifdef USEOFFSETMAPPING\n" +"uniform float3 EyePosition,\n" "#endif\n" -"uniform mat4 ModelViewMatrix,\n" "out float4 gl_Position : POSITION,\n" "out float4 gl_FrontColor : COLOR,\n" "out float4 TexCoordBoth : TEXCOORD0,\n" +"#ifdef USEOFFSETMAPPING\n" +"out float3 EyeVector : TEXCOORD2,\n" +"#endif\n" "out float3 VectorS : TEXCOORD5, // direction of S texcoord (sometimes crudely called tangent)\n" "out float3 VectorT : TEXCOORD6, // direction of T texcoord (sometimes crudely called binormal)\n" "out float3 VectorR : TEXCOORD7 // direction of R texcoord (surface normal)\n" @@ -2414,8 +2495,10 @@ const char *builtincgshaderstring = "#ifdef USEALPHAKILL\n" "uniform sampler2D Texture_Color,\n" "#endif\n" +"uniform sampler2D Texture_Gloss,\n" "#ifdef USEVERTEXTEXTUREBLEND\n" "uniform sampler2D Texture_SecondaryNormal,\n" +"uniform sampler2D Texture_SecondaryGloss,\n" "#endif\n" "#ifdef USEOFFSETMAPPING\n" "uniform float OffsetMapping_Scale,\n" @@ -2444,9 +2527,11 @@ const char *builtincgshaderstring = "#endif\n" "\n" "#ifdef USEVERTEXTEXTUREBLEND\n" -" float3 surfacenormal = mix(float3(tex2D(Texture_SecondaryNormal, TexCoord2)), float3(tex2D(Texture_Normal, TexCoord)), terrainblend) - float3(0.5, 0.5, 0.5);\n" +" float3 surfacenormal = lerp(float3(tex2D(Texture_SecondaryNormal, TexCoord2)), float3(tex2D(Texture_Normal, TexCoord)), terrainblend) - float3(0.5, 0.5, 0.5);\n" +" float a = lerp(tex2D(Texture_SecondaryGloss, TexCoord2), tex2D(Texture_Gloss, TexCoord).a, terrainblend);\n" "#else\n" " float3 surfacenormal = float3(tex2D(Texture_Normal, TexCoord)) - float3(0.5, 0.5, 0.5);\n" +" float a = tex2D(Texture_Gloss, TexCoord).a;\n" "#endif\n" "\n" " gl_FragColor = float4(normalize(surfacenormal.x * VectorS + surfacenormal.y * VectorT + surfacenormal.z * VectorR) * 0.5 + float3(0.5, 0.5, 0.5), 1);\n" @@ -2463,7 +2548,7 @@ const char *builtincgshaderstring = "(\n" "float4 gl_Vertex : POSITION,\n" "uniform float4x4 ModelViewProjectionMatrix,\n" -"uniform mat4 ModelViewMatrix,\n" +"uniform float4x4 ModelViewMatrix,\n" "out float4 gl_Position : POSITION,\n" "out float4 ModelViewPosition : TEXCOORD0\n" ")\n" @@ -2478,9 +2563,10 @@ const char *builtincgshaderstring = "(\n" "float2 Pixel : WPOS,\n" "float4 ModelViewPosition : TEXCOORD0,\n" -"uniform mat4 ViewToLight,\n" +"uniform float4x4 ViewToLight,\n" "uniform float2 ScreenToDepth, // ScreenToDepth = float2(Far / (Far - Near), Far * Near / (Near - Far));\n" "uniform float3 LightPosition,\n" +"uniform half2 PixelToScreenTexCoord,\n" "uniform half3 DeferredColor_Ambient,\n" "uniform half3 DeferredColor_Diffuse,\n" "#ifdef USESPECULAR\n" @@ -2488,8 +2574,8 @@ const char *builtincgshaderstring = "uniform half SpecularPower,\n" "#endif\n" "uniform sampler2D Texture_Attenuation,\n" -"uniform samplerRECT Texture_ScreenDepth,\n" -"uniform samplerRECT Texture_ScreenNormalMap,\n" +"uniform sampler2D Texture_ScreenDepth,\n" +"uniform sampler2D Texture_ScreenNormalMap,\n" "\n" "#ifdef USESHADOWMAPRECT\n" "# ifdef USESHADOWSAMPLER\n" @@ -2529,11 +2615,13 @@ const char *builtincgshaderstring = ")\n" "{\n" " // calculate viewspace pixel position\n" +" float2 ScreenTexCoord = Pixel * PixelToScreenTexCoord;\n" +" ScreenTexCoord.y = ScreenTexCoord.y * -1 + 1; // Cg is opposite?\n" " float3 position;\n" -" position.z = ScreenToDepth.y / (texRECT(Texture_ScreenDepth, Pixel).r + ScreenToDepth.x);\n" +" position.z = ScreenToDepth.y / (texDepth2D(Texture_ScreenDepth, ScreenTexCoord) + ScreenToDepth.x);\n" " position.xy = ModelViewPosition.xy * (position.z / ModelViewPosition.z);\n" " // decode viewspace pixel normal\n" -" half4 normalmap = texRECT(Texture_ScreenNormalMap, Pixel);\n" +" half4 normalmap = tex2D(Texture_ScreenNormalMap, ScreenTexCoord);\n" " half3 surfacenormal = normalize(normalmap.rgb - half3(0.5,0.5,0.5));\n" " // surfacenormal = pixel normal in viewspace\n" " // LightVector = pixel to light in viewspace\n" @@ -2550,10 +2638,10 @@ const char *builtincgshaderstring = " // calculate directional shading\n" " float3 eyevector = position * -1.0;\n" "# ifdef USEEXACTSPECULARMATH\n" -" half specular = pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(eyevector)))*-1.0, 0.0)), SpecularPower);\n" +" half specular = pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(eyevector)))*-1.0, 0.0)), SpecularPower * normalmap.a);\n" "# else\n" " half3 specularnormal = normalize(lightnormal + half3(normalize(eyevector)));\n" -" half specular = pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n" +" half specular = pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * normalmap.a);\n" "# endif\n" "#endif\n" "\n" @@ -2613,12 +2701,12 @@ const char *builtincgshaderstring = "float4 gl_MultiTexCoord4 : TEXCOORD4,\n" "\n" "uniform float3 EyePosition,\n" -"uniform mat4 TexMatrix,\n" +"uniform float4x4 TexMatrix,\n" "#ifdef USEVERTEXTEXTUREBLEND\n" -"uniform mat4 BackgroundTexMatrix,\n" +"uniform float4x4 BackgroundTexMatrix,\n" "#endif\n" "#ifdef MODE_LIGHTSOURCE\n" -"uniform mat4 ModelToLight,\n" +"uniform float4x4 ModelToLight,\n" "#endif\n" "#ifdef MODE_LIGHTSOURCE\n" "uniform float3 LightPosition,\n" @@ -2630,6 +2718,9 @@ const char *builtincgshaderstring = "#ifdef MODE_DEFERREDLIGHTSOURCE\n" "uniform float3 LightPosition,\n" "#endif\n" +"#ifdef USESHADOWMAPORTHO\n" +"uniform float4x4 ShadowMapMatrix,\n" +"#endif\n" "\n" "out float4 gl_FrontColor : COLOR,\n" "out float4 TexCoordBoth : TEXCOORD0,\n" @@ -2651,11 +2742,14 @@ const char *builtincgshaderstring = "#ifdef MODE_LIGHTSOURCE\n" "out float3 CubeVector : TEXCOORD3,\n" "#endif\n" -"#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY)\n" +"#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY) || defined(USEREFLECTCUBE)\n" "out float3 VectorS : TEXCOORD5, // direction of S texcoord (sometimes crudely called tangent)\n" "out float3 VectorT : TEXCOORD6, // direction of T texcoord (sometimes crudely called binormal)\n" "out float3 VectorR : TEXCOORD7, // direction of R texcoord (surface normal)\n" "#endif\n" +"#ifdef USESHADOWMAPORTHO\n" +"out float3 ShadowMapTC : TEXCOORD8,\n" +"#endif\n" "out float4 gl_Position : POSITION\n" ")\n" "{\n" @@ -2715,6 +2809,10 @@ const char *builtincgshaderstring = " // transform vertex to camera space, using ftransform to match non-VS rendering\n" " gl_Position = mul(ModelViewProjectionMatrix, gl_Vertex);\n" "\n" +"#ifdef USESHADOWMAPORTHO\n" +" ShadowMapTC = float3(mul(ShadowMapMatrix, gl_Position));\n" +"#endif\n" +"\n" "#ifdef USEREFLECTION\n" " ModelViewProjectionPosition = gl_Position;\n" "#endif\n" @@ -2753,11 +2851,14 @@ const char *builtincgshaderstring = "#ifdef MODE_DEFERREDLIGHTSOURCE\n" "float4 ModelViewPosition : TEXCOORD0,\n" "#endif\n" -"#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY)\n" +"#if defined(MODE_LIGHTDIRECTIONMAP_MODELSPACE) || defined(MODE_DEFERREDGEOMETRY) || defined(USEREFLECTCUBE)\n" "float3 VectorS : TEXCOORD5, // direction of S texcoord (sometimes crudely called tangent)\n" "float3 VectorT : TEXCOORD6, // direction of T texcoord (sometimes crudely called binormal)\n" "float3 VectorR : TEXCOORD7, // direction of R texcoord (surface normal)\n" "#endif\n" +"#ifdef USESHADOWMAPORTHO\n" +"float3 ShadowMapTC : TEXCOORD8\n" +"#endif\n" "\n" "uniform sampler2D Texture_Normal,\n" "uniform sampler2D Texture_Color,\n" @@ -2794,13 +2895,13 @@ const char *builtincgshaderstring = "uniform sampler2D Texture_Reflection,\n" "#endif\n" "\n" -"//#ifdef MODE_DEFERREDLIGHTSOURCE\n" -"uniform samplerRECT Texture_ScreenDepth,\n" -"uniform samplerRECT Texture_ScreenNormalMap,\n" -"//#endif\n" +"#ifdef MODE_DEFERREDLIGHTSOURCE\n" +"uniform sampler2D Texture_ScreenDepth,\n" +"uniform sampler2D Texture_ScreenNormalMap,\n" +"#endif\n" "#ifdef USEDEFERREDLIGHTMAP\n" -"uniform samplerRECT Texture_ScreenDiffuse,\n" -"uniform samplerRECT Texture_ScreenSpecular,\n" +"uniform sampler2D Texture_ScreenDiffuse,\n" +"uniform sampler2D Texture_ScreenSpecular,\n" "#endif\n" "\n" "#ifdef USECOLORMAPPING\n" @@ -2819,6 +2920,7 @@ const char *builtincgshaderstring = "#endif\n" "\n" "#ifdef USEDEFERREDLIGHTMAP\n" +"uniform half2 PixelToScreenTexCoord,\n" "uniform half3 DeferredMod_Diffuse,\n" "uniform half3 DeferredMod_Specular,\n" "#endif\n" @@ -2836,6 +2938,11 @@ const char *builtincgshaderstring = "uniform float4 ScreenCenterRefractReflect,\n" "uniform half4 ReflectColor,\n" "#endif\n" +"#ifdef USEREFLECTCUBE\n" +"uniform float4x4 ModelToReflectCube,\n" +"uniform sampler2D Texture_ReflectMask,\n" +"uniform samplerCUBE Texture_ReflectCube,\n" +"#endif\n" "#ifdef MODE_LIGHTDIRECTION\n" "uniform half3 LightColor,\n" "#endif\n" @@ -2846,6 +2953,9 @@ const char *builtincgshaderstring = "#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE)\n" "uniform sampler2D Texture_Attenuation,\n" "uniform samplerCUBE Texture_Cube,\n" +"#endif\n" +"\n" +"#if defined(MODE_LIGHTSOURCE) || defined(MODE_DEFERREDLIGHTSOURCE) || defined(USESHADOWMAPORTHO)\n" "\n" "#ifdef USESHADOWMAPRECT\n" "# ifdef USESHADOWSAMPLER\n" @@ -2879,7 +2989,7 @@ const char *builtincgshaderstring = "uniform float2 ShadowMap_TextureScale,\n" "uniform float4 ShadowMap_Parameters,\n" "#endif\n" -"#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE)\n" +"#endif // !defined(MODE_LIGHTSOURCE) && !defined(MODE_DEFERREDLIGHTSOURCE) && !defined(USESHADOWMAPORTHO)\n" "\n" "out float4 gl_FragColor : COLOR\n" ")\n" @@ -2908,14 +3018,14 @@ const char *builtincgshaderstring = " float terrainblend = clamp(half(gl_FrontColor.a) * color.a * 2.0 - 0.5, half(0.0), half(1.0));\n" " //half terrainblend = min(half(gl_FrontColor.a) * color.a * 2.0, half(1.0));\n" " //half terrainblend = half(gl_FrontColor.a) * color.a > 0.5;\n" -" color.rgb = half3(mix(float3(tex2D(Texture_SecondaryColor, TexCoord2)), float3(color.rgb), terrainblend));\n" +" color.rgb = half3(lerp(float3(tex2D(Texture_SecondaryColor, TexCoord2)), float3(color.rgb), terrainblend));\n" " color.a = 1.0;\n" -" //color = mix(half4(1, 0, 0, 1), color, terrainblend);\n" +" //color = lerp(half4(1, 0, 0, 1), color, terrainblend);\n" "#endif\n" "\n" " // get the surface normal\n" "#ifdef USEVERTEXTEXTUREBLEND\n" -" half3 surfacenormal = normalize(half3(mix(float3(tex2D(Texture_SecondaryNormal, TexCoord2)), float3(tex2D(Texture_Normal, TexCoord)), terrainblend)) - half3(0.5, 0.5, 0.5));\n" +" half3 surfacenormal = normalize(half3(lerp(float3(tex2D(Texture_SecondaryNormal, TexCoord2)), float3(tex2D(Texture_Normal, TexCoord)), terrainblend)) - half3(0.5, 0.5, 0.5));\n" "#else\n" " half3 surfacenormal = normalize(half3(tex2D(Texture_Normal, TexCoord)) - half3(0.5, 0.5, 0.5));\n" "#endif\n" @@ -2924,28 +3034,39 @@ const char *builtincgshaderstring = " half3 diffusetex = color.rgb;\n" "#if defined(USESPECULAR) || defined(USEDEFERREDLIGHTMAP)\n" "# ifdef USEVERTEXTEXTUREBLEND\n" -" half3 glosstex = half3(mix(float3(tex2D(Texture_SecondaryGloss, TexCoord2)), float3(tex2D(Texture_Gloss, TexCoord)), terrainblend));\n" +" half4 glosstex = half4(lerp(float4(tex2D(Texture_SecondaryGloss, TexCoord2)), float4(tex2D(Texture_Gloss, TexCoord)), terrainblend));\n" "# else\n" -" half3 glosstex = half3(tex2D(Texture_Gloss, TexCoord));\n" +" half4 glosstex = half4(tex2D(Texture_Gloss, TexCoord));\n" "# endif\n" "#endif\n" "\n" +"#ifdef USEREFLECTCUBE\n" +" vec3 TangentReflectVector = reflect(-EyeVector, surfacenormal);\n" +" vec3 ModelReflectVector = TangentReflectVector.x * VectorS + TangentReflectVector.y * VectorT + TangentReflectVector.z * VectorR;\n" +" vec3 ReflectCubeTexCoord = float3(mul(ModelToReflectCube, float4(ModelReflectVector, 0)));\n" +" diffusetex += half3(tex2D(Texture_ReflectMask, TexCoord)) * half3(texCUBE(Texture_ReflectCube, ReflectCubeTexCoord));\n" +"#endif\n" +"\n" "\n" "\n" "\n" "#ifdef MODE_LIGHTSOURCE\n" " // light source\n" +"#ifdef USEDIFFUSE\n" " half3 lightnormal = half3(normalize(LightVector));\n" " half diffuse = half(max(float(dot(surfacenormal, lightnormal)), 0.0));\n" " color.rgb = diffusetex * (Color_Ambient + diffuse * Color_Diffuse);\n" "#ifdef USESPECULAR\n" "#ifdef USEEXACTSPECULARMATH\n" -" half specular = pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower);\n" +" half specular = pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a);\n" "#else\n" " half3 specularnormal = normalize(lightnormal + half3(normalize(EyeVector)));\n" -" half specular = pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n" +" half specular = pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a);\n" +"#endif\n" +" color.rgb += glosstex.rgb * (specular * Color_Specular);\n" "#endif\n" -" color.rgb += glosstex * (specular * Color_Specular);\n" +"#else\n" +" color.rgb = diffusetex * Color_Ambient;\n" "#endif\n" " color.rgb *= LightColor;\n" " color.rgb *= half(tex2D(Texture_Attenuation, float2(length(CubeVector), 0.0)));\n" @@ -2977,7 +3098,9 @@ const char *builtincgshaderstring = "\n" "#ifdef MODE_LIGHTDIRECTION\n" "#define SHADING\n" +"#ifdef USEDIFFUSE\n" " half3 lightnormal = half3(normalize(LightVector));\n" +"#endif\n" "#define lightcolor LightColor\n" "#endif // MODE_LIGHTDIRECTION\n" "#ifdef MODE_LIGHTDIRECTIONMAP_MODELSPACE\n" @@ -3029,12 +3152,12 @@ const char *builtincgshaderstring = " half diffuse = half(max(float(dot(surfacenormal, lightnormal)), 0.0));\n" "# ifdef USESPECULAR\n" "# ifdef USEEXACTSPECULARMATH\n" -" half specular = pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower);\n" +" half specular = pow(half(max(float(dot(reflect(lightnormal, surfacenormal), normalize(EyeVector)))*-1.0, 0.0)), SpecularPower * glosstex.a);\n" "# else\n" " half3 specularnormal = normalize(lightnormal + half3(normalize(EyeVector)));\n" -" half specular = pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower);\n" +" half specular = pow(half(max(float(dot(surfacenormal, specularnormal)), 0.0)), SpecularPower * glosstex.a);\n" "# endif\n" -" color.rgb = diffusetex * Color_Ambient + (diffusetex * Color_Diffuse * diffuse + glosstex * Color_Specular * specular) * lightcolor;\n" +" color.rgb = diffusetex * Color_Ambient + (diffusetex * Color_Diffuse * diffuse + glosstex.rgb * Color_Specular * specular) * lightcolor;\n" "# else\n" " color.rgb = diffusetex * (Color_Ambient + Color_Diffuse * diffuse * lightcolor);\n" "# endif\n" @@ -3043,15 +3166,26 @@ const char *builtincgshaderstring = "# endif\n" "#endif\n" "\n" +"#ifdef USESHADOWMAPORTHO\n" +" color.rgb *= ShadowMapCompare(ShadowMapTC,\n" +"# if defined(USESHADOWMAP2D)\n" +"Texture_ShadowMap2D, ShadowMap_Parameters, ShadowMap_TextureScale\n" +"# endif\n" +"# if defined(USESHADOWMAPRECT)\n" +"Texture_ShadowMapRect, ShadowMap_Parameters\n" +"# endif\n" +" );\n" +"#endif\n" +"\n" "#ifdef USEDEFERREDLIGHTMAP\n" -" color.rgb += diffusetex * half3(texRECT(Texture_ScreenDiffuse, Pixel)) * DeferredMod_Diffuse;\n" -" color.rgb += glosstex * half3(texRECT(Texture_ScreenSpecular, Pixel)) * DeferredMod_Specular;\n" -" color.rgb = half3(texRECT(Texture_ScreenDepth, Pixel));\n" +" float2 ScreenTexCoord = Pixel * PixelToScreenTexCoord;\n" +" color.rgb += diffusetex * half3(tex2D(Texture_ScreenDiffuse, ScreenTexCoord)) * DeferredMod_Diffuse;\n" +" color.rgb += glosstex.rgb * half3(tex2D(Texture_ScreenSpecular, ScreenTexCoord)) * DeferredMod_Specular;\n" "#endif\n" "\n" "#ifdef USEGLOW\n" "#ifdef USEVERTEXTEXTUREBLEND\n" -" color.rgb += mix(half3(tex2D(Texture_SecondaryGlow, TexCoord2)), half3(tex2D(Texture_Glow, TexCoord)), terrainblend) * Color_Glow;\n" +" color.rgb += lerp(half3(tex2D(Texture_SecondaryGlow, TexCoord2)), half3(tex2D(Texture_Glow, TexCoord)), terrainblend) * Color_Glow;\n" "#else\n" " color.rgb += half3(tex2D(Texture_Glow, TexCoord)) * Color_Glow;\n" "#endif\n" @@ -3059,9 +3193,9 @@ const char *builtincgshaderstring = "\n" "#ifdef USEFOG\n" "#ifdef MODE_LIGHTSOURCE\n" -" color.rgb *= half(FogVertex());\n" +" color.rgb *= half(FogVertex(EyeVectorModelSpaceFogPlaneVertexDist.xyz, EyeVectorModelSpaceFogPlaneVertexDist.w, FogRangeRecip, FogPlaneViewDist, FogHeightFade, Texture_FogMask));\n" "#else\n" -" color.rgb = mix(FogColor, float3(color.rgb), FogVertex(EyeVectorModelSpaceFogPlaneVertexDist.xyz, EyeVectorModelSpaceFogPlaneVertexDist.w, FogRangeRecip, FogPlaneViewDist, FogHeightFade, Texture_FogMask));\n" +" color.rgb = lerp(FogColor, float3(color.rgb), FogVertex(EyeVectorModelSpaceFogPlaneVertexDist.xyz, EyeVectorModelSpaceFogPlaneVertexDist.w, FogRangeRecip, FogPlaneViewDist, FogHeightFade, Texture_FogMask));\n" "#endif\n" "#endif\n" "\n" @@ -3080,8 +3214,8 @@ const char *builtincgshaderstring = " f *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(0.01, -0.01)).rgb) / 0.05);\n" " f *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(-0.01, 0.01)).rgb) / 0.05);\n" " f *= min(1.0, length(tex2D(Texture_Reflection, ScreenTexCoord + float2(-0.01, -0.01)).rgb) / 0.05);\n" -" ScreenTexCoord = mix(SafeScreenTexCoord, ScreenTexCoord, f);\n" -" color.rgb = mix(color.rgb, half3(tex2D(Texture_Reflection, ScreenTexCoord)) * ReflectColor.rgb, ReflectColor.a);\n" +" ScreenTexCoord = lerp(SafeScreenTexCoord, ScreenTexCoord, f);\n" +" color.rgb = lerp(color.rgb, half3(tex2D(Texture_Reflection, ScreenTexCoord)) * ReflectColor.rgb, ReflectColor.a);\n" "#endif\n" "\n" " gl_FragColor = float4(color);\n" @@ -3099,6 +3233,9 @@ const char *builtincgshaderstring = "#endif // !MODE_DEPTH_OR_SHADOW\n" ; +char *glslshaderstring = NULL; +char *cgshaderstring = NULL; + //======================================================================================================================================================= typedef struct shaderpermutationinfo_s @@ -3144,10 +3281,12 @@ typedef enum shaderpermutation_e SHADERPERMUTATION_SHADOWMAPPCF2 = 1<<21, ///< (lightsource) use higher quality percentage closer filtering on shadowmap test results SHADERPERMUTATION_SHADOWSAMPLER = 1<<22, ///< (lightsource) use hardware shadowmap test SHADERPERMUTATION_SHADOWMAPVSDCT = 1<<23, ///< (lightsource) use virtual shadow depth cube texture for shadowmap indexing - SHADERPERMUTATION_DEFERREDLIGHTMAP = 1<<24, ///< (lightmap) read Texture_ScreenDiffuse/Specular textures and add them on top of lightmapping - SHADERPERMUTATION_ALPHAKILL = 1<<25, ///< (deferredgeometry) discard pixel if diffuse texture alpha below 0.5 - SHADERPERMUTATION_LIMIT = 1<<26, ///< size of permutations array - SHADERPERMUTATION_COUNT = 27 ///< size of shaderpermutationinfo array + SHADERPERMUTATION_SHADOWMAPORTHO = 1<<24, //< (lightsource) use orthographic shadowmap projection + SHADERPERMUTATION_DEFERREDLIGHTMAP = 1<<25, ///< (lightmap) read Texture_ScreenDiffuse/Specular textures and add them on top of lightmapping + SHADERPERMUTATION_ALPHAKILL = 1<<26, ///< (deferredgeometry) discard pixel if diffuse texture alpha below 0.5 + SHADERPERMUTATION_REFLECTCUBE = 1<<27, ///< fake reflections using global cubemap (not HDRI light probe) + SHADERPERMUTATION_LIMIT = 1<<28, ///< size of permutations array + SHADERPERMUTATION_COUNT = 28 ///< size of shaderpermutationinfo array } shaderpermutation_t; @@ -3178,8 +3317,10 @@ shaderpermutationinfo_t shaderpermutationinfo[SHADERPERMUTATION_COUNT] = {"#define USESHADOWMAPPCF 2\n", " shadowmappcf2"}, {"#define USESHADOWSAMPLER\n", " shadowsampler"}, {"#define USESHADOWMAPVSDCT\n", " shadowmapvsdct"}, + {"#define USESHADOWMAPORTHO\n", " shadowmaportho"}, {"#define USEDEFERREDLIGHTMAP\n", " deferredlightmap"}, {"#define USEALPHAKILL\n", " alphakill"}, + {"#define USEREFLECTCUBE\n", " reflectcube"}, }; /// this enum is multiplied by SHADERPERMUTATION_MODEBASE @@ -3229,7 +3370,7 @@ shadermodeinfo_t cgshadermodeinfo[SHADERMODE_COUNT] = { {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_GENERIC\n", " generic"}, {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_POSTPROCESS\n", " postprocess"}, - {"cg/default.cg", NULL, NULL , "#define MODE_DEPTH_OR_SHADOW\n", " depth/shadow"}, + {"cg/default.cg", NULL, NULL , "#define MODE_DEPTH_OR_SHADOW\n", " depth"}, {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_FLATCOLOR\n", " flatcolor"}, {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_VERTEXCOLOR\n", " vertexcolor"}, {"cg/default.cg", NULL, "cg/default.cg", "#define MODE_LIGHTMAP\n", " lightmap"}, @@ -3286,6 +3427,8 @@ typedef struct r_glsl_permutation_s int loc_Texture_ScreenNormalMap; int loc_Texture_ScreenDiffuse; int loc_Texture_ScreenSpecular; + int loc_Texture_ReflectMask; + int loc_Texture_ReflectCube; int loc_Alpha; int loc_BloomBlur_Parameters; int loc_ClientTime; @@ -3334,6 +3477,9 @@ typedef struct r_glsl_permutation_s int loc_BackgroundTexMatrix; int loc_ModelViewProjectionMatrix; int loc_ModelViewMatrix; + int loc_PixelToScreenTexCoord; + int loc_ModelToReflectCube; + int loc_ShadowMapMatrix; } r_glsl_permutation_t; @@ -3376,6 +3522,20 @@ static char *R_GLSL_GetText(const char *filename, qboolean printfromdisknotice) char *shaderstring; if (!filename || !filename[0]) return NULL; + if (!strcmp(filename, "glsl/default.glsl")) + { + if (!glslshaderstring) + { + glslshaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL); + if (glslshaderstring) + Con_DPrintf("Loading shaders from file %s...\n", filename); + else + glslshaderstring = (char *)builtinshaderstring; + } + shaderstring = (char *) Mem_Alloc(r_main_mempool, strlen(glslshaderstring) + 1); + memcpy(shaderstring, glslshaderstring, strlen(glslshaderstring) + 1); + return shaderstring; + } shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL); if (shaderstring) { @@ -3383,11 +3543,6 @@ static char *R_GLSL_GetText(const char *filename, qboolean printfromdisknotice) Con_DPrintf("from disk %s... ", filename); return shaderstring; } - else if (!strcmp(filename, "glsl/default.glsl")) - { - shaderstring = (char *) Mem_Alloc(r_main_mempool, strlen(builtinshaderstring) + 1); - memcpy(shaderstring, builtinshaderstring, strlen(builtinshaderstring) + 1); - } return shaderstring; } @@ -3498,6 +3653,8 @@ static void R_GLSL_CompilePermutation(r_glsl_permutation_t *p, unsigned int mode p->loc_Texture_ScreenNormalMap = qglGetUniformLocationARB(p->program, "Texture_ScreenNormalMap"); p->loc_Texture_ScreenDiffuse = qglGetUniformLocationARB(p->program, "Texture_ScreenDiffuse"); p->loc_Texture_ScreenSpecular = qglGetUniformLocationARB(p->program, "Texture_ScreenSpecular"); + p->loc_Texture_ReflectMask = qglGetUniformLocationARB(p->program, "Texture_ReflectMask"); + p->loc_Texture_ReflectCube = qglGetUniformLocationARB(p->program, "Texture_ReflectCube"); p->loc_Alpha = qglGetUniformLocationARB(p->program, "Alpha"); p->loc_BloomBlur_Parameters = qglGetUniformLocationARB(p->program, "BloomBlur_Parameters"); p->loc_ClientTime = qglGetUniformLocationARB(p->program, "ClientTime"); @@ -3546,6 +3703,9 @@ static void R_GLSL_CompilePermutation(r_glsl_permutation_t *p, unsigned int mode p->loc_BackgroundTexMatrix = qglGetUniformLocationARB(p->program, "BackgroundTexMatrix"); p->loc_ModelViewMatrix = qglGetUniformLocationARB(p->program, "ModelViewMatrix"); p->loc_ModelViewProjectionMatrix = qglGetUniformLocationARB(p->program, "ModelViewProjectionMatrix"); + p->loc_PixelToScreenTexCoord = qglGetUniformLocationARB(p->program, "PixelToScreenTexCoord"); + p->loc_ModelToReflectCube = qglGetUniformLocationARB(p->program, "ModelToReflectCube"); + p->loc_ShadowMapMatrix = qglGetUniformLocationARB(p->program, "ShadowMapMatrix"); // initialize the samplers to refer to the texture units we use if (p->loc_Texture_First >= 0) qglUniform1iARB(p->loc_Texture_First , GL20TU_FIRST); if (p->loc_Texture_Second >= 0) qglUniform1iARB(p->loc_Texture_Second , GL20TU_SECOND); @@ -3567,14 +3727,16 @@ static void R_GLSL_CompilePermutation(r_glsl_permutation_t *p, unsigned int mode if (p->loc_Texture_Cube >= 0) qglUniform1iARB(p->loc_Texture_Cube , GL20TU_CUBE); if (p->loc_Texture_Refraction >= 0) qglUniform1iARB(p->loc_Texture_Refraction , GL20TU_REFRACTION); if (p->loc_Texture_Reflection >= 0) qglUniform1iARB(p->loc_Texture_Reflection , GL20TU_REFLECTION); - if (p->loc_Texture_ShadowMapRect >= 0) qglUniform1iARB(p->loc_Texture_ShadowMapRect , GL20TU_SHADOWMAPRECT); + if (p->loc_Texture_ShadowMapRect >= 0) qglUniform1iARB(p->loc_Texture_ShadowMapRect , permutation & SHADERPERMUTATION_SHADOWMAPORTHO ? GL20TU_SHADOWMAPORTHORECT : GL20TU_SHADOWMAPRECT); if (p->loc_Texture_ShadowMapCube >= 0) qglUniform1iARB(p->loc_Texture_ShadowMapCube , GL20TU_SHADOWMAPCUBE); - if (p->loc_Texture_ShadowMap2D >= 0) qglUniform1iARB(p->loc_Texture_ShadowMap2D , GL20TU_SHADOWMAP2D); + if (p->loc_Texture_ShadowMap2D >= 0) qglUniform1iARB(p->loc_Texture_ShadowMap2D , permutation & SHADERPERMUTATION_SHADOWMAPORTHO ? GL20TU_SHADOWMAPORTHO2D : GL20TU_SHADOWMAP2D); if (p->loc_Texture_CubeProjection >= 0) qglUniform1iARB(p->loc_Texture_CubeProjection , GL20TU_CUBEPROJECTION); if (p->loc_Texture_ScreenDepth >= 0) qglUniform1iARB(p->loc_Texture_ScreenDepth , GL20TU_SCREENDEPTH); if (p->loc_Texture_ScreenNormalMap >= 0) qglUniform1iARB(p->loc_Texture_ScreenNormalMap, GL20TU_SCREENNORMALMAP); if (p->loc_Texture_ScreenDiffuse >= 0) qglUniform1iARB(p->loc_Texture_ScreenDiffuse , GL20TU_SCREENDIFFUSE); if (p->loc_Texture_ScreenSpecular >= 0) qglUniform1iARB(p->loc_Texture_ScreenSpecular , GL20TU_SCREENSPECULAR); + if (p->loc_Texture_ReflectMask >= 0) qglUniform1iARB(p->loc_Texture_ReflectMask , GL20TU_REFLECTMASK); + if (p->loc_Texture_ReflectCube >= 0) qglUniform1iARB(p->loc_Texture_ReflectCube , GL20TU_REFLECTCUBE); CHECKGLERROR Con_DPrintf("^5GLSL shader %s compiled.\n", permutationname); } @@ -3631,6 +3793,7 @@ void R_SetupShader_SetPermutationGLSL(unsigned int mode, unsigned int permutatio } if (r_glsl_permutation->loc_ModelViewProjectionMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewProjectionMatrix, 1, false, gl_modelviewprojection16f); if (r_glsl_permutation->loc_ModelViewMatrix >= 0) qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelViewMatrix, 1, false, gl_modelview16f); + if (r_glsl_permutation->loc_ClientTime >= 0) qglUniform1fARB(r_glsl_permutation->loc_ClientTime, cl.time); } #ifdef SUPPORTCG @@ -3658,6 +3821,7 @@ typedef struct r_cg_permutation_s CGparameter vp_BackgroundTexMatrix; CGparameter vp_ModelViewProjectionMatrix; CGparameter vp_ModelViewMatrix; + CGparameter vp_ShadowMapMatrix; CGparameter fp_Texture_First; CGparameter fp_Texture_Second; @@ -3687,6 +3851,8 @@ typedef struct r_cg_permutation_s CGparameter fp_Texture_ScreenNormalMap; CGparameter fp_Texture_ScreenDiffuse; CGparameter fp_Texture_ScreenSpecular; + CGparameter fp_Texture_ReflectMask; + CGparameter fp_Texture_ReflectCube; CGparameter fp_Alpha; CGparameter fp_BloomBlur_Parameters; CGparameter fp_ClientTime; @@ -3730,6 +3896,8 @@ typedef struct r_cg_permutation_s CGparameter fp_UserVec4; CGparameter fp_ViewTintColor; CGparameter fp_ViewToLight; + CGparameter fp_PixelToScreenTexCoord; + CGparameter fp_ModelToReflectCube; } r_cg_permutation_t; @@ -3772,6 +3940,20 @@ static char *R_CG_GetText(const char *filename, qboolean printfromdisknotice) char *shaderstring; if (!filename || !filename[0]) return NULL; + if (!strcmp(filename, "cg/default.cg")) + { + if (!cgshaderstring) + { + cgshaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL); + if (cgshaderstring) + Con_DPrintf("Loading shaders from file %s...\n", filename); + else + cgshaderstring = (char *)builtincgshaderstring; + } + shaderstring = (char *) Mem_Alloc(r_main_mempool, strlen(cgshaderstring) + 1); + memcpy(shaderstring, cgshaderstring, strlen(cgshaderstring) + 1); + return shaderstring; + } shaderstring = (char *)FS_LoadFile(filename, r_main_mempool, false, NULL); if (shaderstring) { @@ -3779,14 +3961,14 @@ static char *R_CG_GetText(const char *filename, qboolean printfromdisknotice) Con_DPrintf("from disk %s... ", filename); return shaderstring; } - else if (!strcmp(filename, "cg/default.cg")) - { - shaderstring = (char *) Mem_Alloc(r_main_mempool, strlen(builtincgshaderstring) + 1); - memcpy(shaderstring, builtincgshaderstring, strlen(builtincgshaderstring) + 1); - } return shaderstring; } +static void R_CG_CacheShader(r_cg_permutation_t *p, const char *cachename, const char *vertstring, const char *fragstring) +{ + // TODO: load or create .fp and .vp shader files +} + static void R_CG_CompilePermutation(r_cg_permutation_t *p, unsigned int mode, unsigned int permutation) { int i; @@ -3801,6 +3983,7 @@ static void R_CG_CompilePermutation(r_cg_permutation_t *p, unsigned int mode, un const char *geomstrings_list[32+3]; const char *fragstrings_list[32+3]; char permutationname[256]; + char cachename[256]; CGprofile vertexProfile; CGprofile fragmentProfile; @@ -3811,11 +3994,13 @@ static void R_CG_CompilePermutation(r_cg_permutation_t *p, unsigned int mode, un p->fprogram = NULL; permutationname[0] = 0; + cachename[0] = 0; vertexstring = R_CG_GetText(modeinfo->vertexfilename, true); geometrystring = R_CG_GetText(modeinfo->geometryfilename, false); fragmentstring = R_CG_GetText(modeinfo->fragmentfilename, false); strlcat(permutationname, modeinfo->vertexfilename, sizeof(permutationname)); + strlcat(cachename, "cg/", sizeof(cachename)); // the first pretext is which type of shader to compile as // (later these will all be bound together as a program object) @@ -3828,6 +4013,7 @@ static void R_CG_CompilePermutation(r_cg_permutation_t *p, unsigned int mode, un geomstrings_list[geomstrings_count++] = modeinfo->pretext; fragstrings_list[fragstrings_count++] = modeinfo->pretext; strlcat(permutationname, modeinfo->name, sizeof(permutationname)); + strlcat(cachename, modeinfo->name, sizeof(cachename)); // now add all the permutation pretexts for (i = 0;i < SHADERPERMUTATION_COUNT;i++) @@ -3838,6 +4024,7 @@ static void R_CG_CompilePermutation(r_cg_permutation_t *p, unsigned int mode, un geomstrings_list[geomstrings_count++] = shaderpermutationinfo[i].pretext; fragstrings_list[fragstrings_count++] = shaderpermutationinfo[i].pretext; strlcat(permutationname, shaderpermutationinfo[i].name, sizeof(permutationname)); + strlcat(cachename, shaderpermutationinfo[i].name, sizeof(cachename)); } else { @@ -3848,6 +4035,11 @@ static void R_CG_CompilePermutation(r_cg_permutation_t *p, unsigned int mode, un } } + // replace spaces in the cachename with _ characters + for (i = 0;cachename[i];i++) + if (cachename[i] == ' ') + cachename[i] = '_'; + // now append the shader text itself vertstrings_list[vertstrings_count++] = vertexstring; geomstrings_list[geomstrings_count++] = geometrystring; @@ -3893,125 +4085,118 @@ static void R_CG_CompilePermutation(r_cg_permutation_t *p, unsigned int mode, un //cgSetAutoCompile(vid.cgcontext, CG_COMPILE_MANUAL);CHECKCGERROR CHECKGLERROR - // compile the vertex program - if (vertstring[0] && (p->vprogram = cgCreateProgram(vid.cgcontext, CG_SOURCE, vertstring, CG_PROFILE_ARBVP1, NULL, NULL))) + // try to load the cached shader, or generate one + R_CG_CacheShader(p, cachename, vertstring, fragstring); + + // if caching failed, do a dynamic compile for now + CHECKCGERROR + if (vertstring[0] && !p->vprogram) + p->vprogram = cgCreateProgram(vid.cgcontext, CG_SOURCE, vertstring, vertexProfile, NULL, NULL); + CHECKCGERROR + if (fragstring[0] && !p->fprogram) + p->fprogram = cgCreateProgram(vid.cgcontext, CG_SOURCE, fragstring, fragmentProfile, NULL, NULL); + CHECKCGERROR + + // look up all the uniform variable names we care about, so we don't + // have to look them up every time we set them + if (p->vprogram) { CHECKCGERROR - cgCompileProgram(p->vprogram);CHECKCGERROR - if (!cgIsProgramCompiled(p->vprogram)) - { - CHECKCGERROR - cgDestroyProgram(p->vprogram);CHECKCGERROR - p->vprogram = 0; - } - else - { - cgGLLoadProgram(p->vprogram);CHECKCGERROR CHECKGLERROR - cgGLEnableProfile(vertexProfile);CHECKCGERROR CHECKGLERROR - // look up all the uniform variable names we care about, so we don't - // have to look them up every time we set them - CHECKCGERROR - p->vp_EyePosition = cgGetNamedParameter(p->vprogram, "EyePosition"); - p->vp_FogPlane = cgGetNamedParameter(p->vprogram, "FogPlane"); - p->vp_LightDir = cgGetNamedParameter(p->vprogram, "LightDir"); - p->vp_LightPosition = cgGetNamedParameter(p->vprogram, "LightPosition"); - p->vp_ModelToLight = cgGetNamedParameter(p->vprogram, "ModelToLight"); - p->vp_TexMatrix = cgGetNamedParameter(p->vprogram, "TexMatrix"); - p->vp_BackgroundTexMatrix = cgGetNamedParameter(p->vprogram, "BackgroundTexMatrix"); - p->vp_ModelViewProjectionMatrix = cgGetNamedParameter(p->vprogram, "ModelViewProjectionMatrix"); - p->vp_ModelViewMatrix = cgGetNamedParameter(p->vprogram, "ModelViewMatrix"); - CHECKCGERROR - } + cgGLLoadProgram(p->vprogram);CHECKCGERROR CHECKGLERROR + cgGLEnableProfile(vertexProfile);CHECKCGERROR CHECKGLERROR + p->vp_EyePosition = cgGetNamedParameter(p->vprogram, "EyePosition"); + p->vp_FogPlane = cgGetNamedParameter(p->vprogram, "FogPlane"); + p->vp_LightDir = cgGetNamedParameter(p->vprogram, "LightDir"); + p->vp_LightPosition = cgGetNamedParameter(p->vprogram, "LightPosition"); + p->vp_ModelToLight = cgGetNamedParameter(p->vprogram, "ModelToLight"); + p->vp_TexMatrix = cgGetNamedParameter(p->vprogram, "TexMatrix"); + p->vp_BackgroundTexMatrix = cgGetNamedParameter(p->vprogram, "BackgroundTexMatrix"); + p->vp_ModelViewProjectionMatrix = cgGetNamedParameter(p->vprogram, "ModelViewProjectionMatrix"); + p->vp_ModelViewMatrix = cgGetNamedParameter(p->vprogram, "ModelViewMatrix"); + p->vp_ShadowMapMatrix = cgGetNamedParameter(p->vprogram, "ShadowMapMatrix"); + CHECKCGERROR } - - // compile the fragment program - if (fragstring[0] && (p->fprogram = cgCreateProgram(vid.cgcontext, CG_SOURCE, fragstring, CG_PROFILE_ARBFP1, NULL, NULL))) + if (p->fprogram) { - cgCompileProgram(p->fprogram);CHECKCGERROR - if (!cgIsProgramCompiled(p->fprogram)) - { - CHECKCGERROR - cgDestroyProgram(p->fprogram);CHECKCGERROR - p->fprogram = 0; - } - else - { - cgGLLoadProgram(p->fprogram);CHECKCGERROR CHECKGLERROR - cgGLEnableProfile(fragmentProfile);CHECKCGERROR CHECKGLERROR - CHECKCGERROR - p->fp_Texture_First = cgGetNamedParameter(p->fprogram, "Texture_First"); - p->fp_Texture_Second = cgGetNamedParameter(p->fprogram, "Texture_Second"); - p->fp_Texture_GammaRamps = cgGetNamedParameter(p->fprogram, "Texture_GammaRamps"); - p->fp_Texture_Normal = cgGetNamedParameter(p->fprogram, "Texture_Normal"); - p->fp_Texture_Color = cgGetNamedParameter(p->fprogram, "Texture_Color"); - p->fp_Texture_Gloss = cgGetNamedParameter(p->fprogram, "Texture_Gloss"); - p->fp_Texture_Glow = cgGetNamedParameter(p->fprogram, "Texture_Glow"); - p->fp_Texture_SecondaryNormal = cgGetNamedParameter(p->fprogram, "Texture_SecondaryNormal"); - p->fp_Texture_SecondaryColor = cgGetNamedParameter(p->fprogram, "Texture_SecondaryColor"); - p->fp_Texture_SecondaryGloss = cgGetNamedParameter(p->fprogram, "Texture_SecondaryGloss"); - p->fp_Texture_SecondaryGlow = cgGetNamedParameter(p->fprogram, "Texture_SecondaryGlow"); - p->fp_Texture_Pants = cgGetNamedParameter(p->fprogram, "Texture_Pants"); - p->fp_Texture_Shirt = cgGetNamedParameter(p->fprogram, "Texture_Shirt"); - p->fp_Texture_FogMask = cgGetNamedParameter(p->fprogram, "Texture_FogMask"); - p->fp_Texture_Lightmap = cgGetNamedParameter(p->fprogram, "Texture_Lightmap"); - p->fp_Texture_Deluxemap = cgGetNamedParameter(p->fprogram, "Texture_Deluxemap"); - p->fp_Texture_Attenuation = cgGetNamedParameter(p->fprogram, "Texture_Attenuation"); - p->fp_Texture_Cube = cgGetNamedParameter(p->fprogram, "Texture_Cube"); - p->fp_Texture_Refraction = cgGetNamedParameter(p->fprogram, "Texture_Refraction"); - p->fp_Texture_Reflection = cgGetNamedParameter(p->fprogram, "Texture_Reflection"); - p->fp_Texture_ShadowMapRect = cgGetNamedParameter(p->fprogram, "Texture_ShadowMapRect"); - p->fp_Texture_ShadowMapCube = cgGetNamedParameter(p->fprogram, "Texture_ShadowMapCube"); - p->fp_Texture_ShadowMap2D = cgGetNamedParameter(p->fprogram, "Texture_ShadowMap2D"); - p->fp_Texture_CubeProjection = cgGetNamedParameter(p->fprogram, "Texture_CubeProjection"); - p->fp_Texture_ScreenDepth = cgGetNamedParameter(p->fprogram, "Texture_ScreenDepth"); - p->fp_Texture_ScreenNormalMap = cgGetNamedParameter(p->fprogram, "Texture_ScreenNormalMap"); - p->fp_Texture_ScreenDiffuse = cgGetNamedParameter(p->fprogram, "Texture_ScreenDiffuse"); - p->fp_Texture_ScreenSpecular = cgGetNamedParameter(p->fprogram, "Texture_ScreenSpecular"); - p->fp_Alpha = cgGetNamedParameter(p->fprogram, "Alpha"); - p->fp_BloomBlur_Parameters = cgGetNamedParameter(p->fprogram, "BloomBlur_Parameters"); - p->fp_ClientTime = cgGetNamedParameter(p->fprogram, "ClientTime"); - p->fp_Color_Ambient = cgGetNamedParameter(p->fprogram, "Color_Ambient"); - p->fp_Color_Diffuse = cgGetNamedParameter(p->fprogram, "Color_Diffuse"); - p->fp_Color_Specular = cgGetNamedParameter(p->fprogram, "Color_Specular"); - p->fp_Color_Glow = cgGetNamedParameter(p->fprogram, "Color_Glow"); - p->fp_Color_Pants = cgGetNamedParameter(p->fprogram, "Color_Pants"); - p->fp_Color_Shirt = cgGetNamedParameter(p->fprogram, "Color_Shirt"); - p->fp_DeferredColor_Ambient = cgGetNamedParameter(p->fprogram, "DeferredColor_Ambient"); - p->fp_DeferredColor_Diffuse = cgGetNamedParameter(p->fprogram, "DeferredColor_Diffuse"); - p->fp_DeferredColor_Specular = cgGetNamedParameter(p->fprogram, "DeferredColor_Specular"); - p->fp_DeferredMod_Diffuse = cgGetNamedParameter(p->fprogram, "DeferredMod_Diffuse"); - p->fp_DeferredMod_Specular = cgGetNamedParameter(p->fprogram, "DeferredMod_Specular"); - p->fp_DistortScaleRefractReflect = cgGetNamedParameter(p->fprogram, "DistortScaleRefractReflect"); - p->fp_EyePosition = cgGetNamedParameter(p->fprogram, "EyePosition"); - p->fp_FogColor = cgGetNamedParameter(p->fprogram, "FogColor"); - p->fp_FogHeightFade = cgGetNamedParameter(p->fprogram, "FogHeightFade"); - p->fp_FogPlane = cgGetNamedParameter(p->fprogram, "FogPlane"); - p->fp_FogPlaneViewDist = cgGetNamedParameter(p->fprogram, "FogPlaneViewDist"); - p->fp_FogRangeRecip = cgGetNamedParameter(p->fprogram, "FogRangeRecip"); - p->fp_LightColor = cgGetNamedParameter(p->fprogram, "LightColor"); - p->fp_LightDir = cgGetNamedParameter(p->fprogram, "LightDir"); - p->fp_LightPosition = cgGetNamedParameter(p->fprogram, "LightPosition"); - p->fp_OffsetMapping_Scale = cgGetNamedParameter(p->fprogram, "OffsetMapping_Scale"); - p->fp_PixelSize = cgGetNamedParameter(p->fprogram, "PixelSize"); - p->fp_ReflectColor = cgGetNamedParameter(p->fprogram, "ReflectColor"); - p->fp_ReflectFactor = cgGetNamedParameter(p->fprogram, "ReflectFactor"); - p->fp_ReflectOffset = cgGetNamedParameter(p->fprogram, "ReflectOffset"); - p->fp_RefractColor = cgGetNamedParameter(p->fprogram, "RefractColor"); - p->fp_Saturation = cgGetNamedParameter(p->fprogram, "Saturation"); - p->fp_ScreenCenterRefractReflect = cgGetNamedParameter(p->fprogram, "ScreenCenterRefractReflect"); - p->fp_ScreenScaleRefractReflect = cgGetNamedParameter(p->fprogram, "ScreenScaleRefractReflect"); - p->fp_ScreenToDepth = cgGetNamedParameter(p->fprogram, "ScreenToDepth"); - p->fp_ShadowMap_Parameters = cgGetNamedParameter(p->fprogram, "ShadowMap_Parameters"); - p->fp_ShadowMap_TextureScale = cgGetNamedParameter(p->fprogram, "ShadowMap_TextureScale"); - p->fp_SpecularPower = cgGetNamedParameter(p->fprogram, "SpecularPower"); - p->fp_UserVec1 = cgGetNamedParameter(p->fprogram, "UserVec1"); - p->fp_UserVec2 = cgGetNamedParameter(p->fprogram, "UserVec2"); - p->fp_UserVec3 = cgGetNamedParameter(p->fprogram, "UserVec3"); - p->fp_UserVec4 = cgGetNamedParameter(p->fprogram, "UserVec4"); - p->fp_ViewTintColor = cgGetNamedParameter(p->fprogram, "ViewTintColor"); - p->fp_ViewToLight = cgGetNamedParameter(p->fprogram, "ViewToLight"); - CHECKCGERROR - } + CHECKCGERROR + cgGLLoadProgram(p->fprogram);CHECKCGERROR CHECKGLERROR + cgGLEnableProfile(fragmentProfile);CHECKCGERROR CHECKGLERROR + p->fp_Texture_First = cgGetNamedParameter(p->fprogram, "Texture_First"); + p->fp_Texture_Second = cgGetNamedParameter(p->fprogram, "Texture_Second"); + p->fp_Texture_GammaRamps = cgGetNamedParameter(p->fprogram, "Texture_GammaRamps"); + p->fp_Texture_Normal = cgGetNamedParameter(p->fprogram, "Texture_Normal"); + p->fp_Texture_Color = cgGetNamedParameter(p->fprogram, "Texture_Color"); + p->fp_Texture_Gloss = cgGetNamedParameter(p->fprogram, "Texture_Gloss"); + p->fp_Texture_Glow = cgGetNamedParameter(p->fprogram, "Texture_Glow"); + p->fp_Texture_SecondaryNormal = cgGetNamedParameter(p->fprogram, "Texture_SecondaryNormal"); + p->fp_Texture_SecondaryColor = cgGetNamedParameter(p->fprogram, "Texture_SecondaryColor"); + p->fp_Texture_SecondaryGloss = cgGetNamedParameter(p->fprogram, "Texture_SecondaryGloss"); + p->fp_Texture_SecondaryGlow = cgGetNamedParameter(p->fprogram, "Texture_SecondaryGlow"); + p->fp_Texture_Pants = cgGetNamedParameter(p->fprogram, "Texture_Pants"); + p->fp_Texture_Shirt = cgGetNamedParameter(p->fprogram, "Texture_Shirt"); + p->fp_Texture_FogMask = cgGetNamedParameter(p->fprogram, "Texture_FogMask"); + p->fp_Texture_Lightmap = cgGetNamedParameter(p->fprogram, "Texture_Lightmap"); + p->fp_Texture_Deluxemap = cgGetNamedParameter(p->fprogram, "Texture_Deluxemap"); + p->fp_Texture_Attenuation = cgGetNamedParameter(p->fprogram, "Texture_Attenuation"); + p->fp_Texture_Cube = cgGetNamedParameter(p->fprogram, "Texture_Cube"); + p->fp_Texture_Refraction = cgGetNamedParameter(p->fprogram, "Texture_Refraction"); + p->fp_Texture_Reflection = cgGetNamedParameter(p->fprogram, "Texture_Reflection"); + p->fp_Texture_ShadowMapRect = cgGetNamedParameter(p->fprogram, "Texture_ShadowMapRect"); + p->fp_Texture_ShadowMapCube = cgGetNamedParameter(p->fprogram, "Texture_ShadowMapCube"); + p->fp_Texture_ShadowMap2D = cgGetNamedParameter(p->fprogram, "Texture_ShadowMap2D"); + p->fp_Texture_CubeProjection = cgGetNamedParameter(p->fprogram, "Texture_CubeProjection"); + p->fp_Texture_ScreenDepth = cgGetNamedParameter(p->fprogram, "Texture_ScreenDepth"); + p->fp_Texture_ScreenNormalMap = cgGetNamedParameter(p->fprogram, "Texture_ScreenNormalMap"); + p->fp_Texture_ScreenDiffuse = cgGetNamedParameter(p->fprogram, "Texture_ScreenDiffuse"); + p->fp_Texture_ScreenSpecular = cgGetNamedParameter(p->fprogram, "Texture_ScreenSpecular"); + p->fp_Texture_ReflectMask = cgGetNamedParameter(p->fprogram, "Texture_ReflectMask"); + p->fp_Texture_ReflectCube = cgGetNamedParameter(p->fprogram, "Texture_ReflectCube"); + p->fp_Alpha = cgGetNamedParameter(p->fprogram, "Alpha"); + p->fp_BloomBlur_Parameters = cgGetNamedParameter(p->fprogram, "BloomBlur_Parameters"); + p->fp_ClientTime = cgGetNamedParameter(p->fprogram, "ClientTime"); + p->fp_Color_Ambient = cgGetNamedParameter(p->fprogram, "Color_Ambient"); + p->fp_Color_Diffuse = cgGetNamedParameter(p->fprogram, "Color_Diffuse"); + p->fp_Color_Specular = cgGetNamedParameter(p->fprogram, "Color_Specular"); + p->fp_Color_Glow = cgGetNamedParameter(p->fprogram, "Color_Glow"); + p->fp_Color_Pants = cgGetNamedParameter(p->fprogram, "Color_Pants"); + p->fp_Color_Shirt = cgGetNamedParameter(p->fprogram, "Color_Shirt"); + p->fp_DeferredColor_Ambient = cgGetNamedParameter(p->fprogram, "DeferredColor_Ambient"); + p->fp_DeferredColor_Diffuse = cgGetNamedParameter(p->fprogram, "DeferredColor_Diffuse"); + p->fp_DeferredColor_Specular = cgGetNamedParameter(p->fprogram, "DeferredColor_Specular"); + p->fp_DeferredMod_Diffuse = cgGetNamedParameter(p->fprogram, "DeferredMod_Diffuse"); + p->fp_DeferredMod_Specular = cgGetNamedParameter(p->fprogram, "DeferredMod_Specular"); + p->fp_DistortScaleRefractReflect = cgGetNamedParameter(p->fprogram, "DistortScaleRefractReflect"); + p->fp_EyePosition = cgGetNamedParameter(p->fprogram, "EyePosition"); + p->fp_FogColor = cgGetNamedParameter(p->fprogram, "FogColor"); + p->fp_FogHeightFade = cgGetNamedParameter(p->fprogram, "FogHeightFade"); + p->fp_FogPlane = cgGetNamedParameter(p->fprogram, "FogPlane"); + p->fp_FogPlaneViewDist = cgGetNamedParameter(p->fprogram, "FogPlaneViewDist"); + p->fp_FogRangeRecip = cgGetNamedParameter(p->fprogram, "FogRangeRecip"); + p->fp_LightColor = cgGetNamedParameter(p->fprogram, "LightColor"); + p->fp_LightDir = cgGetNamedParameter(p->fprogram, "LightDir"); + p->fp_LightPosition = cgGetNamedParameter(p->fprogram, "LightPosition"); + p->fp_OffsetMapping_Scale = cgGetNamedParameter(p->fprogram, "OffsetMapping_Scale"); + p->fp_PixelSize = cgGetNamedParameter(p->fprogram, "PixelSize"); + p->fp_ReflectColor = cgGetNamedParameter(p->fprogram, "ReflectColor"); + p->fp_ReflectFactor = cgGetNamedParameter(p->fprogram, "ReflectFactor"); + p->fp_ReflectOffset = cgGetNamedParameter(p->fprogram, "ReflectOffset"); + p->fp_RefractColor = cgGetNamedParameter(p->fprogram, "RefractColor"); + p->fp_Saturation = cgGetNamedParameter(p->fprogram, "Saturation"); + p->fp_ScreenCenterRefractReflect = cgGetNamedParameter(p->fprogram, "ScreenCenterRefractReflect"); + p->fp_ScreenScaleRefractReflect = cgGetNamedParameter(p->fprogram, "ScreenScaleRefractReflect"); + p->fp_ScreenToDepth = cgGetNamedParameter(p->fprogram, "ScreenToDepth"); + p->fp_ShadowMap_Parameters = cgGetNamedParameter(p->fprogram, "ShadowMap_Parameters"); + p->fp_ShadowMap_TextureScale = cgGetNamedParameter(p->fprogram, "ShadowMap_TextureScale"); + p->fp_SpecularPower = cgGetNamedParameter(p->fprogram, "SpecularPower"); + p->fp_UserVec1 = cgGetNamedParameter(p->fprogram, "UserVec1"); + p->fp_UserVec2 = cgGetNamedParameter(p->fprogram, "UserVec2"); + p->fp_UserVec3 = cgGetNamedParameter(p->fprogram, "UserVec3"); + p->fp_UserVec4 = cgGetNamedParameter(p->fprogram, "UserVec4"); + p->fp_ViewTintColor = cgGetNamedParameter(p->fprogram, "ViewTintColor"); + p->fp_ViewToLight = cgGetNamedParameter(p->fprogram, "ViewToLight"); + p->fp_PixelToScreenTexCoord = cgGetNamedParameter(p->fprogram, "PixelToScreenTexCoord"); + p->fp_ModelToReflectCube = cgGetNamedParameter(p->fprogram, "ModelToReflectCube"); + CHECKCGERROR } if ((p->vprogram || !vertstring[0]) && (p->fprogram || !fragstring[0])) @@ -4075,13 +4260,13 @@ void R_SetupShader_SetPermutationCG(unsigned int mode, unsigned int permutation) CHECKCGERROR if (r_cg_permutation->vprogram) { - //cgGLLoadProgram(r_cg_permutation->vprogram);CHECKCGERROR CHECKGLERROR + cgGLLoadProgram(r_cg_permutation->vprogram);CHECKCGERROR CHECKGLERROR cgGLBindProgram(r_cg_permutation->vprogram);CHECKCGERROR CHECKGLERROR - //cgGLEnableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR + cgGLEnableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR } else { - //cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR + cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR } if (r_cg_permutation->fprogram) @@ -4099,11 +4284,12 @@ void R_SetupShader_SetPermutationCG(unsigned int mode, unsigned int permutation) CHECKCGERROR if (r_cg_permutation->vp_ModelViewProjectionMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewProjectionMatrix, gl_modelviewprojection16f);CHECKCGERROR if (r_cg_permutation->vp_ModelViewMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewMatrix, gl_modelview16f);CHECKCGERROR + if (r_cg_permutation->fp_ClientTime) cgGLSetParameter1f(r_cg_permutation->fp_ClientTime, cl.time);CHECKCGERROR } -void CG_BindTexture(CGparameter param, int texnum) +void CG_BindTexture(CGparameter param, rtexture_t *tex) { - cgGLSetTextureParameter(param, texnum); + cgGLSetTextureParameter(param, R_GetTexture(tex)); cgGLEnableTextureParameter(param); } #endif @@ -4111,11 +4297,18 @@ void CG_BindTexture(CGparameter param, int texnum) void R_GLSL_Restart_f(void) { unsigned int i, limit; + if (glslshaderstring && glslshaderstring != builtinshaderstring) + Mem_Free(glslshaderstring); + glslshaderstring = NULL; + if (cgshaderstring && cgshaderstring != builtincgshaderstring) + Mem_Free(cgshaderstring); + cgshaderstring = NULL; switch(vid.renderpath) { case RENDERPATH_GL20: { r_glsl_permutation_t *p; + r_glsl_permutation = NULL; limit = Mem_ExpandableArray_IndexRange(&r_glsl_permutationarray); for (i = 0;i < limit;i++) { @@ -4132,6 +4325,11 @@ void R_GLSL_Restart_f(void) #ifdef SUPPORTCG { r_cg_permutation_t *p; + r_cg_permutation = NULL; + cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR + cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_VERTEX));CHECKCGERROR CHECKGLERROR + cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR + cgGLUnbindProgram(cgGLGetLatestProfile(CG_GL_FRAGMENT));CHECKCGERROR CHECKGLERROR limit = Mem_ExpandableArray_IndexRange(&r_cg_permutationarray); for (i = 0;i < limit;i++) { @@ -4144,8 +4342,8 @@ void R_GLSL_Restart_f(void) Mem_ExpandableArray_FreeRecord(&r_cg_permutationarray, (void*)p); } } + memset(r_cg_permutationhash, 0, sizeof(r_cg_permutationhash)); } - memset(r_cg_permutationhash, 0, sizeof(r_cg_permutationhash)); break; #endif case RENDERPATH_GL13: @@ -4164,14 +4362,10 @@ void R_GLSL_DumpShader_f(void) { FS_Print(file, "/* The engine may define the following macros:\n"); FS_Print(file, "#define VERTEX_SHADER\n#define GEOMETRY_SHADER\n#define FRAGMENT_SHADER\n"); - for (i = 0;i < SHADERMODE_COUNT;i++) { - if (glslshadermodeinfo[i].pretext) - FS_Print(file, glslshadermodeinfo[i].pretext); - } - for (i = 0;i < SHADERPERMUTATION_COUNT;i++) { - if (shaderpermutationinfo[i].pretext) - FS_Print(file, shaderpermutationinfo[i].pretext); - } + for (i = 0;i < SHADERMODE_COUNT;i++) + FS_Print(file, glslshadermodeinfo[i].pretext); + for (i = 0;i < SHADERPERMUTATION_COUNT;i++) + FS_Print(file, shaderpermutationinfo[i].pretext); FS_Print(file, "*/\n"); FS_Print(file, builtinshaderstring); FS_Close(file); @@ -4281,6 +4475,7 @@ extern rtexture_t *r_shadow_attenuation3dtexture; extern qboolean r_shadow_usingshadowmaprect; extern qboolean r_shadow_usingshadowmapcube; extern qboolean r_shadow_usingshadowmap2d; +extern qboolean r_shadow_usingshadowmaportho; extern float r_shadow_shadowmap_texturescale[2]; extern float r_shadow_shadowmap_parameters[4]; extern qboolean r_shadow_shadowmapvsdct; @@ -4290,6 +4485,7 @@ extern rtexture_t *r_shadow_shadowmaprectangletexture; extern rtexture_t *r_shadow_shadowmap2dtexture; extern rtexture_t *r_shadow_shadowmapcubetexture[R_SHADOW_SHADOWMAP_NUMCUBEMAPS]; extern rtexture_t *r_shadow_shadowmapvsdcttexture; +extern matrix4x4_t r_shadow_shadowmapmatrix; extern int r_shadow_shadowmaplod; // changes for each light based on distance extern int r_shadow_prepass_width; extern int r_shadow_prepass_height; @@ -4396,6 +4592,8 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, else if (r_shadow_shadowmappcf) permutation |= SHADERPERMUTATION_SHADOWMAPPCF; } + if (rsurface.texture->reflectmasktexture) + permutation |= SHADERPERMUTATION_REFLECTCUBE; R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset); if (true || permutation & (SHADERPERMUTATION_DIFFUSE | SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_OFFSETMAPPING)) { @@ -4436,8 +4634,25 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, permutation |= r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE; if (rsurface.texture->colormapping) permutation |= SHADERPERMUTATION_COLORMAPPING; + if (r_shadow_usingshadowmaportho && (r_shadow_usingshadowmaprect || r_shadow_usingshadowmap2d)) + { + permutation |= SHADERPERMUTATION_SHADOWMAPORTHO; + if (r_shadow_usingshadowmaprect) + permutation |= SHADERPERMUTATION_SHADOWMAPRECT; + if (r_shadow_usingshadowmap2d) + permutation |= SHADERPERMUTATION_SHADOWMAP2D; + + if (r_shadow_shadowmapsampler) + permutation |= SHADERPERMUTATION_SHADOWSAMPLER; + if (r_shadow_shadowmappcf > 1) + permutation |= SHADERPERMUTATION_SHADOWMAPPCF2; + else if (r_shadow_shadowmappcf) + permutation |= SHADERPERMUTATION_SHADOWMAPPCF; + } if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION) permutation |= SHADERPERMUTATION_REFLECTION; + if (rsurface.texture->reflectmasktexture) + permutation |= SHADERPERMUTATION_REFLECTCUBE; R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset); if (true || permutation & (SHADERPERMUTATION_DIFFUSE | SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_OFFSETMAPPING)) { @@ -4484,10 +4699,27 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, permutation |= r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE; if (rsurface.texture->colormapping) permutation |= SHADERPERMUTATION_COLORMAPPING; + if (r_shadow_usingshadowmaportho && (r_shadow_usingshadowmaprect || r_shadow_usingshadowmap2d)) + { + permutation |= SHADERPERMUTATION_SHADOWMAPORTHO; + if (r_shadow_usingshadowmaprect) + permutation |= SHADERPERMUTATION_SHADOWMAPRECT; + if (r_shadow_usingshadowmap2d) + permutation |= SHADERPERMUTATION_SHADOWMAP2D; + + if (r_shadow_shadowmapsampler) + permutation |= SHADERPERMUTATION_SHADOWSAMPLER; + if (r_shadow_shadowmappcf > 1) + permutation |= SHADERPERMUTATION_SHADOWMAPPCF2; + else if (r_shadow_shadowmappcf) + permutation |= SHADERPERMUTATION_SHADOWMAPPCF; + } if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION) permutation |= SHADERPERMUTATION_REFLECTION; if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED)) permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP; + if (rsurface.texture->reflectmasktexture) + permutation |= SHADERPERMUTATION_REFLECTCUBE; R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset); if (true || permutation & (SHADERPERMUTATION_DIFFUSE | SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_OFFSETMAPPING)) { @@ -4524,10 +4756,27 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, permutation |= r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE; if (rsurface.texture->colormapping) permutation |= SHADERPERMUTATION_COLORMAPPING; + if (r_shadow_usingshadowmaportho && (r_shadow_usingshadowmaprect || r_shadow_usingshadowmap2d)) + { + permutation |= SHADERPERMUTATION_SHADOWMAPORTHO; + if (r_shadow_usingshadowmaprect) + permutation |= SHADERPERMUTATION_SHADOWMAPRECT; + if (r_shadow_usingshadowmap2d) + permutation |= SHADERPERMUTATION_SHADOWMAP2D; + + if (r_shadow_shadowmapsampler) + permutation |= SHADERPERMUTATION_SHADOWSAMPLER; + if (r_shadow_shadowmappcf > 1) + permutation |= SHADERPERMUTATION_SHADOWMAPPCF2; + else if (r_shadow_shadowmappcf) + permutation |= SHADERPERMUTATION_SHADOWMAPPCF; + } if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION) permutation |= SHADERPERMUTATION_REFLECTION; if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED)) permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP; + if (rsurface.texture->reflectmasktexture) + permutation |= SHADERPERMUTATION_REFLECTCUBE; R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset); if (true || permutation & (SHADERPERMUTATION_DIFFUSE | SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_OFFSETMAPPING)) { @@ -4563,10 +4812,27 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, permutation |= r_refdef.fogplaneviewabove ? SHADERPERMUTATION_FOGOUTSIDE : SHADERPERMUTATION_FOGINSIDE; if (rsurface.texture->colormapping) permutation |= SHADERPERMUTATION_COLORMAPPING; + if (r_shadow_usingshadowmaportho && (r_shadow_usingshadowmaprect || r_shadow_usingshadowmap2d)) + { + permutation |= SHADERPERMUTATION_SHADOWMAPORTHO; + if (r_shadow_usingshadowmaprect) + permutation |= SHADERPERMUTATION_SHADOWMAPRECT; + if (r_shadow_usingshadowmap2d) + permutation |= SHADERPERMUTATION_SHADOWMAP2D; + + if (r_shadow_shadowmapsampler) + permutation |= SHADERPERMUTATION_SHADOWSAMPLER; + if (r_shadow_shadowmappcf > 1) + permutation |= SHADERPERMUTATION_SHADOWMAPPCF2; + else if (r_shadow_shadowmappcf) + permutation |= SHADERPERMUTATION_SHADOWMAPPCF; + } if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION) permutation |= SHADERPERMUTATION_REFLECTION; if (r_shadow_usingdeferredprepass && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED)) permutation |= SHADERPERMUTATION_DEFERREDLIGHTMAP; + if (rsurface.texture->reflectmasktexture) + permutation |= SHADERPERMUTATION_REFLECTCUBE; if (r_glsl_deluxemapping.integer >= 1 && rsurface.uselightmaptexture && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brushq3.deluxemapping) { // deluxemapping (light direction texture) @@ -4641,6 +4907,7 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, { case RENDERPATH_GL20: R_SetupShader_SetPermutationGLSL(mode, permutation); + if (r_glsl_permutation->loc_ModelToReflectCube >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.matrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelToReflectCube, 1, false, m16f);} if (mode == SHADERMODE_LIGHTSOURCE) { if (r_glsl_permutation->loc_ModelToLight >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_ModelToLight, 1, false, m16f);} @@ -4653,8 +4920,6 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, // additive passes are only darkened by fog, not tinted if (r_glsl_permutation->loc_FogColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0); - if (r_glsl_permutation->loc_ShadowMap_TextureScale >= 0) qglUniform2fARB(r_glsl_permutation->loc_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]); - if (r_glsl_permutation->loc_ShadowMap_Parameters >= 0) qglUniform4fARB(r_glsl_permutation->loc_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]); if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f)); } else @@ -4700,6 +4965,10 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, } if (r_glsl_permutation->loc_TexMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currenttexmatrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_TexMatrix, 1, false, m16f);} if (r_glsl_permutation->loc_BackgroundTexMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currentbackgroundtexmatrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_BackgroundTexMatrix, 1, false, m16f);} + if (r_glsl_permutation->loc_ShadowMapMatrix >= 0) {Matrix4x4_ToArrayFloatGL(&r_shadow_shadowmapmatrix, m16f);qglUniformMatrix4fvARB(r_glsl_permutation->loc_ShadowMapMatrix, 1, false, m16f);} + if (r_glsl_permutation->loc_ShadowMap_TextureScale >= 0) qglUniform2fARB(r_glsl_permutation->loc_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]); + if (r_glsl_permutation->loc_ShadowMap_Parameters >= 0) qglUniform4fARB(r_glsl_permutation->loc_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]); + if (r_glsl_permutation->loc_Color_Glow >= 0) qglUniform3fARB(r_glsl_permutation->loc_Color_Glow, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2]); if (r_glsl_permutation->loc_Alpha >= 0) qglUniform1fARB(r_glsl_permutation->loc_Alpha, rsurface.texture->lightmapcolor[3]); if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]); @@ -4723,6 +4992,7 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, if (r_glsl_permutation->loc_FogHeightFade >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogHeightFade, rsurface.fogheightfade); if (r_glsl_permutation->loc_OffsetMapping_Scale >= 0) qglUniform1fARB(r_glsl_permutation->loc_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value); if (r_glsl_permutation->loc_ScreenToDepth >= 0) qglUniform2fARB(r_glsl_permutation->loc_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]); + if (r_glsl_permutation->loc_PixelToScreenTexCoord >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height); // if (r_glsl_permutation->loc_Texture_First >= 0) R_Mesh_TexBind(GL20TU_FIRST , r_texture_white ); // if (r_glsl_permutation->loc_Texture_Second >= 0) R_Mesh_TexBind(GL20TU_SECOND , r_texture_white ); @@ -4737,6 +5007,8 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, if (r_glsl_permutation->loc_Texture_SecondaryGlow >= 0) R_Mesh_TexBind(GL20TU_SECONDARY_GLOW , rsurface.texture->backgroundglowtexture ); if (r_glsl_permutation->loc_Texture_Pants >= 0) R_Mesh_TexBind(GL20TU_PANTS , rsurface.texture->pantstexture ); if (r_glsl_permutation->loc_Texture_Shirt >= 0) R_Mesh_TexBind(GL20TU_SHIRT , rsurface.texture->shirttexture ); + if (r_glsl_permutation->loc_Texture_ReflectMask >= 0) R_Mesh_TexBind(GL20TU_REFLECTMASK , rsurface.texture->reflectmasktexture ); + if (r_glsl_permutation->loc_Texture_ReflectCube >= 0) R_Mesh_TexBind(GL20TU_REFLECTCUBE , rsurface.texture->reflectcubetexture ? rsurface.texture->reflectcubetexture : r_texture_whitecube); if (r_glsl_permutation->loc_Texture_FogMask >= 0) R_Mesh_TexBind(GL20TU_FOGMASK , r_texture_fogattenuation ); if (r_glsl_permutation->loc_Texture_Lightmap >= 0) R_Mesh_TexBind(GL20TU_LIGHTMAP , r_texture_white ); if (r_glsl_permutation->loc_Texture_Deluxemap >= 0) R_Mesh_TexBind(GL20TU_LIGHTMAP , r_texture_blanknormalmap ); @@ -4747,20 +5019,24 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, if (r_glsl_permutation->loc_Texture_ScreenNormalMap >= 0) R_Mesh_TexBind(GL20TU_SCREENNORMALMAP , r_shadow_prepassgeometrynormalmaptexture ); if (r_glsl_permutation->loc_Texture_ScreenDiffuse >= 0) R_Mesh_TexBind(GL20TU_SCREENDIFFUSE , r_shadow_prepasslightingdiffusetexture ); if (r_glsl_permutation->loc_Texture_ScreenSpecular >= 0) R_Mesh_TexBind(GL20TU_SCREENSPECULAR , r_shadow_prepasslightingspeculartexture ); - if (rsurface.rtlight) + if (rsurface.rtlight || r_shadow_usingshadowmaportho) { - if (r_glsl_permutation->loc_Texture_Cube >= 0) R_Mesh_TexBind(GL20TU_CUBE , rsurface.rtlight->currentcubemap ); - if (r_glsl_permutation->loc_Texture_ShadowMapRect >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAPRECT , r_shadow_shadowmaprectangletexture ); - if (r_shadow_usingshadowmapcube) - if (r_glsl_permutation->loc_Texture_ShadowMapCube >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAPCUBE , r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]); - if (r_glsl_permutation->loc_Texture_ShadowMap2D >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAP2D , r_shadow_shadowmap2dtexture ); - if (r_glsl_permutation->loc_Texture_CubeProjection >= 0) R_Mesh_TexBind(GL20TU_CUBEPROJECTION , r_shadow_shadowmapvsdcttexture ); + if (r_glsl_permutation->loc_Texture_ShadowMap2D >= 0) R_Mesh_TexBind(r_shadow_usingshadowmaportho ? GL20TU_SHADOWMAPORTHO2D : GL20TU_SHADOWMAP2D, r_shadow_shadowmap2dtexture ); + if (r_glsl_permutation->loc_Texture_ShadowMapRect >= 0) R_Mesh_TexBind(r_shadow_usingshadowmaportho ? GL20TU_SHADOWMAPORTHORECT : GL20TU_SHADOWMAPRECT, r_shadow_shadowmaprectangletexture ); + if (rsurface.rtlight) + { + if (r_glsl_permutation->loc_Texture_Cube >= 0) R_Mesh_TexBind(GL20TU_CUBE , rsurface.rtlight->currentcubemap ); + if (r_shadow_usingshadowmapcube) + if (r_glsl_permutation->loc_Texture_ShadowMapCube >= 0) R_Mesh_TexBind(GL20TU_SHADOWMAPCUBE , r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]); + if (r_glsl_permutation->loc_Texture_CubeProjection >= 0) R_Mesh_TexBind(GL20TU_CUBEPROJECTION , r_shadow_shadowmapvsdcttexture ); + } } CHECKGLERROR break; case RENDERPATH_CGGL: #ifdef SUPPORTCG R_SetupShader_SetPermutationCG(mode, permutation); + if (r_cg_permutation->fp_ModelToReflectCube) {Matrix4x4_ToArrayFloatGL(&rsurface.matrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->fp_ModelToReflectCube, m16f);}CHECKCGERROR if (mode == SHADERMODE_LIGHTSOURCE) { if (r_cg_permutation->vp_ModelToLight) {Matrix4x4_ToArrayFloatGL(&rsurface.entitytolight, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelToLight, m16f);}CHECKCGERROR @@ -4775,6 +5051,7 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, } if (r_cg_permutation->vp_TexMatrix) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currenttexmatrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_TexMatrix, m16f);}CHECKCGERROR if (r_cg_permutation->vp_BackgroundTexMatrix) {Matrix4x4_ToArrayFloatGL(&rsurface.texture->currentbackgroundtexmatrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_BackgroundTexMatrix, m16f);}CHECKCGERROR + if (r_cg_permutation->vp_ShadowMapMatrix) {Matrix4x4_ToArrayFloatGL(&r_shadow_shadowmapmatrix, m16f);cgGLSetMatrixParameterfc(r_cg_permutation->vp_ShadowMapMatrix, m16f);}CHECKGLERROR if (r_cg_permutation->vp_EyePosition) cgGLSetParameter3f(r_cg_permutation->vp_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);CHECKCGERROR if (r_cg_permutation->vp_FogPlane) cgGLSetParameter4f(r_cg_permutation->vp_FogPlane, rsurface.fogplane[0], rsurface.fogplane[1], rsurface.fogplane[2], rsurface.fogplane[3]);CHECKCGERROR CHECKGLERROR @@ -4789,8 +5066,6 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, // additive passes are only darkened by fog, not tinted if (r_cg_permutation->fp_FogColor) cgGLSetParameter3f(r_cg_permutation->fp_FogColor, 0, 0, 0);CHECKCGERROR - if (r_cg_permutation->fp_ShadowMap_TextureScale) cgGLSetParameter2f(r_cg_permutation->fp_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);CHECKCGERROR - if (r_cg_permutation->fp_ShadowMap_Parameters) cgGLSetParameter4f(r_cg_permutation->fp_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);CHECKCGERROR if (r_cg_permutation->fp_SpecularPower) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));CHECKCGERROR } else @@ -4835,6 +5110,8 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, if (r_cg_permutation->fp_ReflectOffset) cgGLSetParameter1f(r_cg_permutation->fp_ReflectOffset, rsurface.texture->reflectmin);CHECKCGERROR if (r_cg_permutation->fp_SpecularPower) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, rsurface.texture->specularpower * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));CHECKCGERROR } + if (r_cg_permutation->fp_ShadowMap_TextureScale) cgGLSetParameter2f(r_cg_permutation->fp_ShadowMap_TextureScale, r_shadow_shadowmap_texturescale[0], r_shadow_shadowmap_texturescale[1]);CHECKCGERROR + if (r_cg_permutation->fp_ShadowMap_Parameters) cgGLSetParameter4f(r_cg_permutation->fp_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);CHECKCGERROR if (r_cg_permutation->fp_Color_Glow) cgGLSetParameter3f(r_cg_permutation->fp_Color_Glow, rsurface.glowmod[0], rsurface.glowmod[1], rsurface.glowmod[2]);CHECKCGERROR if (r_cg_permutation->fp_Alpha) cgGLSetParameter1f(r_cg_permutation->fp_Alpha, rsurface.texture->lightmapcolor[3]);CHECKCGERROR if (r_cg_permutation->fp_EyePosition) cgGLSetParameter3f(r_cg_permutation->fp_EyePosition, rsurface.localvieworigin[0], rsurface.localvieworigin[1], rsurface.localvieworigin[2]);CHECKCGERROR @@ -4860,6 +5137,7 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, if (r_cg_permutation->fp_FogHeightFade) cgGLSetParameter1f(r_cg_permutation->fp_FogHeightFade, rsurface.fogheightfade);CHECKCGERROR if (r_cg_permutation->fp_OffsetMapping_Scale) cgGLSetParameter1f(r_cg_permutation->fp_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value);CHECKCGERROR if (r_cg_permutation->fp_ScreenToDepth) cgGLSetParameter2f(r_cg_permutation->fp_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);CHECKCGERROR + if (r_cg_permutation->fp_PixelToScreenTexCoord) cgGLSetParameter2f(r_cg_permutation->fp_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);CHECKCGERROR // if (r_cg_permutation->fp_Texture_First ) CG_BindTexture(r_cg_permutation->fp_Texture_First , r_texture_white );CHECKCGERROR // if (r_cg_permutation->fp_Texture_Second ) CG_BindTexture(r_cg_permutation->fp_Texture_Second , r_texture_white );CHECKCGERROR @@ -4874,6 +5152,8 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, if (r_cg_permutation->fp_Texture_SecondaryGlow ) CG_BindTexture(r_cg_permutation->fp_Texture_SecondaryGlow , rsurface.texture->backgroundglowtexture );CHECKCGERROR if (r_cg_permutation->fp_Texture_Pants ) CG_BindTexture(r_cg_permutation->fp_Texture_Pants , rsurface.texture->pantstexture );CHECKCGERROR if (r_cg_permutation->fp_Texture_Shirt ) CG_BindTexture(r_cg_permutation->fp_Texture_Shirt , rsurface.texture->shirttexture );CHECKCGERROR + if (r_cg_permutation->fp_Texture_ReflectMask ) CG_BindTexture(r_cg_permutation->fp_Texture_ReflectMask , rsurface.texture->reflectmasktexture );CHECKCGERROR + if (r_cg_permutation->fp_Texture_ReflectCube ) CG_BindTexture(r_cg_permutation->fp_Texture_ReflectCube , rsurface.texture->reflectcubetexture ? rsurface.texture->reflectcubetexture : r_texture_whitecube);CHECKCGERROR if (r_cg_permutation->fp_Texture_FogMask ) CG_BindTexture(r_cg_permutation->fp_Texture_FogMask , r_texture_fogattenuation );CHECKCGERROR if (r_cg_permutation->fp_Texture_Lightmap ) CG_BindTexture(r_cg_permutation->fp_Texture_Lightmap , r_texture_white );CHECKCGERROR if (r_cg_permutation->fp_Texture_Deluxemap ) CG_BindTexture(r_cg_permutation->fp_Texture_Deluxemap , r_texture_blanknormalmap );CHECKCGERROR @@ -4884,14 +5164,17 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, if (r_cg_permutation->fp_Texture_ScreenNormalMap) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenNormalMap, r_shadow_prepassgeometrynormalmaptexture );CHECKCGERROR if (r_cg_permutation->fp_Texture_ScreenDiffuse ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDiffuse , r_shadow_prepasslightingdiffusetexture );CHECKCGERROR if (r_cg_permutation->fp_Texture_ScreenSpecular ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenSpecular , r_shadow_prepasslightingspeculartexture );CHECKCGERROR - if (rsurface.rtlight) + if (rsurface.rtlight || r_shadow_usingshadowmaportho) { - if (r_cg_permutation->fp_Texture_Cube ) CG_BindTexture(r_cg_permutation->fp_Texture_Cube , rsurface.rtlight->currentcubemap );CHECKCGERROR - if (r_cg_permutation->fp_Texture_ShadowMapRect ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapRect , r_shadow_shadowmaprectangletexture );CHECKCGERROR - if (r_shadow_usingshadowmapcube) - if (r_cg_permutation->fp_Texture_ShadowMapCube ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapCube , r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]);CHECKCGERROR if (r_cg_permutation->fp_Texture_ShadowMap2D ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMap2D , r_shadow_shadowmap2dtexture );CHECKCGERROR - if (r_cg_permutation->fp_Texture_CubeProjection ) CG_BindTexture(r_cg_permutation->fp_Texture_CubeProjection , r_shadow_shadowmapvsdcttexture );CHECKCGERROR + if (r_cg_permutation->fp_Texture_ShadowMapRect ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapRect , r_shadow_shadowmaprectangletexture );CHECKCGERROR + if (rsurface.rtlight) + { + if (r_cg_permutation->fp_Texture_Cube ) CG_BindTexture(r_cg_permutation->fp_Texture_Cube , rsurface.rtlight->currentcubemap );CHECKCGERROR + if (r_shadow_usingshadowmapcube) + if (r_cg_permutation->fp_Texture_ShadowMapCube ) CG_BindTexture(r_cg_permutation->fp_Texture_ShadowMapCube , r_shadow_shadowmapcubetexture[r_shadow_shadowmaplod]);CHECKCGERROR + if (r_cg_permutation->fp_Texture_CubeProjection ) CG_BindTexture(r_cg_permutation->fp_Texture_CubeProjection , r_shadow_shadowmapvsdcttexture );CHECKCGERROR + } } CHECKGLERROR @@ -4969,6 +5252,7 @@ void R_SetupShader_DeferredLight(const rtlight_t *rtlight) if (r_glsl_permutation->loc_ShadowMap_Parameters >= 0) qglUniform4fARB( r_glsl_permutation->loc_ShadowMap_Parameters , r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]); if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB( r_glsl_permutation->loc_SpecularPower , (r_shadow_gloss.integer == 2 ? r_shadow_gloss2exponent.value : r_shadow_glossexponent.value) * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f)); if (r_glsl_permutation->loc_ScreenToDepth >= 0) qglUniform2fARB( r_glsl_permutation->loc_ScreenToDepth , r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]); + if (r_glsl_permutation->loc_PixelToScreenTexCoord >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height); if (r_glsl_permutation->loc_Texture_Attenuation >= 0) R_Mesh_TexBind(GL20TU_ATTENUATION , r_shadow_attenuationgradienttexture ); if (r_glsl_permutation->loc_Texture_ScreenDepth >= 0) R_Mesh_TexBind(GL20TU_SCREENDEPTH , r_shadow_prepassgeometrydepthtexture ); @@ -4992,6 +5276,7 @@ void R_SetupShader_DeferredLight(const rtlight_t *rtlight) if (r_cg_permutation->fp_ShadowMap_Parameters ) cgGLSetParameter4f(r_cg_permutation->fp_ShadowMap_Parameters, r_shadow_shadowmap_parameters[0], r_shadow_shadowmap_parameters[1], r_shadow_shadowmap_parameters[2], r_shadow_shadowmap_parameters[3]);CHECKCGERROR if (r_cg_permutation->fp_SpecularPower ) cgGLSetParameter1f(r_cg_permutation->fp_SpecularPower, (r_shadow_gloss.integer == 2 ? r_shadow_gloss2exponent.value : r_shadow_glossexponent.value) * ((permutation & SHADERPERMUTATION_EXACTSPECULARMATH) ? 0.25f : 1.0f));CHECKCGERROR if (r_cg_permutation->fp_ScreenToDepth ) cgGLSetParameter2f(r_cg_permutation->fp_ScreenToDepth, r_refdef.view.viewport.screentodepth[0], r_refdef.view.viewport.screentodepth[1]);CHECKCGERROR + if (r_cg_permutation->fp_PixelToScreenTexCoord ) cgGLSetParameter2f(r_cg_permutation->fp_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);CHECKCGERROR if (r_cg_permutation->fp_Texture_Attenuation ) CG_BindTexture(r_cg_permutation->fp_Texture_Attenuation , r_shadow_attenuationgradienttexture );CHECKCGERROR if (r_cg_permutation->fp_Texture_ScreenDepth ) CG_BindTexture(r_cg_permutation->fp_Texture_ScreenDepth , r_shadow_prepassgeometrydepthtexture );CHECKCGERROR @@ -5059,6 +5344,7 @@ void R_SkinFrame_Purge(void) R_PurgeTexture(s->gloss );s->gloss = NULL; R_PurgeTexture(s->glow );s->glow = NULL; R_PurgeTexture(s->fog );s->fog = NULL; + R_PurgeTexture(s->reflect);s->reflect = NULL; s->loadsequence = 0; } } @@ -5195,7 +5481,7 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole // check for DDS texture file first if (!r_loaddds || !(ddsbase = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s.dds", basename), textureflags, &ddshasalpha, ddsavgcolor))) { - basepixels = loadimagepixelsbgra(name, complain, true); + basepixels = loadimagepixelsbgra(name, complain, true, r_texture_convertsRGB_skin.integer); if (basepixels == NULL) return NULL; } @@ -5215,6 +5501,7 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole skinframe->gloss = NULL; skinframe->glow = NULL; skinframe->fog = NULL; + skinframe->reflect = NULL; skinframe->hasalpha = false; if (ddsbase) @@ -5273,18 +5560,19 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole skinframe->gloss = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_gloss.dds", skinframe->basename), textureflags, NULL, NULL); skinframe->pants = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_pants.dds", skinframe->basename), textureflags, NULL, NULL); skinframe->shirt = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_shirt.dds", skinframe->basename), textureflags, NULL, NULL); + skinframe->reflect = R_LoadTextureDDSFile(r_main_texturepool, va("dds/%s_reflect.dds", skinframe->basename), textureflags, NULL, NULL); } // _norm is the name used by tenebrae and has been adopted as standard if (r_loadnormalmap && skinframe->nmap == NULL) { - if ((pixels = loadimagepixelsbgra(va("%s_norm", skinframe->basename), false, false)) != NULL) + if ((pixels = loadimagepixelsbgra(va("%s_norm", skinframe->basename), false, false, false)) != NULL) { skinframe->nmap = R_LoadTexture2D (r_main_texturepool, va("%s_nmap", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, (TEXF_ALPHA | skinframe->textureflags) & (gl_texturecompression_normal.integer ? ~0 : ~TEXF_COMPRESS), NULL); Mem_Free(pixels); pixels = NULL; } - else if (r_shadow_bumpscale_bumpmap.value > 0 && (bumppixels = loadimagepixelsbgra(va("%s_bump", skinframe->basename), false, false)) != NULL) + else if (r_shadow_bumpscale_bumpmap.value > 0 && (bumppixels = loadimagepixelsbgra(va("%s_bump", skinframe->basename), false, false, false)) != NULL) { pixels = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4); Image_HeightmapToNormalmap_BGRA(bumppixels, pixels, image_width, image_height, false, r_shadow_bumpscale_bumpmap.value); @@ -5305,7 +5593,7 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole // _luma is supported only for tenebrae compatibility // _glow is the preferred name - if (skinframe->glow == NULL && ((pixels = loadimagepixelsbgra(va("%s_glow", skinframe->basename), false, false)) || (pixels = loadimagepixelsbgra(va("%s_luma", skinframe->basename), false, false)))) + if (skinframe->glow == NULL && ((pixels = loadimagepixelsbgra(va("%s_glow", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer)) || (pixels = loadimagepixelsbgra(va("%s_luma", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer)))) { skinframe->glow = R_LoadTexture2D (r_main_texturepool, va("%s_glow", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_glow.integer ? ~0 : ~TEXF_COMPRESS), NULL); if (r_savedds && qglGetCompressedTexImageARB && skinframe->glow) @@ -5313,7 +5601,7 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole Mem_Free(pixels);pixels = NULL; } - if (skinframe->gloss == NULL && r_loadgloss && (pixels = loadimagepixelsbgra(va("%s_gloss", skinframe->basename), false, false))) + if (skinframe->gloss == NULL && r_loadgloss && (pixels = loadimagepixelsbgra(va("%s_gloss", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer))) { skinframe->gloss = R_LoadTexture2D (r_main_texturepool, va("%s_gloss", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_gloss.integer ? ~0 : ~TEXF_COMPRESS), NULL); if (r_savedds && qglGetCompressedTexImageARB && skinframe->gloss) @@ -5322,7 +5610,7 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole pixels = NULL; } - if (skinframe->pants == NULL && (pixels = loadimagepixelsbgra(va("%s_pants", skinframe->basename), false, false))) + if (skinframe->pants == NULL && (pixels = loadimagepixelsbgra(va("%s_pants", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer))) { skinframe->pants = R_LoadTexture2D (r_main_texturepool, va("%s_pants", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL); if (r_savedds && qglGetCompressedTexImageARB && skinframe->pants) @@ -5331,7 +5619,7 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole pixels = NULL; } - if (skinframe->shirt == NULL && (pixels = loadimagepixelsbgra(va("%s_shirt", skinframe->basename), false, false))) + if (skinframe->shirt == NULL && (pixels = loadimagepixelsbgra(va("%s_shirt", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer))) { skinframe->shirt = R_LoadTexture2D (r_main_texturepool, va("%s_shirt", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_color.integer ? ~0 : ~TEXF_COMPRESS), NULL); if (r_savedds && qglGetCompressedTexImageARB && skinframe->shirt) @@ -5340,6 +5628,15 @@ skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboole pixels = NULL; } + if (skinframe->reflect == NULL && (pixels = loadimagepixelsbgra(va("%s_reflect", skinframe->basename), false, false, r_texture_convertsRGB_skin.integer))) + { + skinframe->reflect = R_LoadTexture2D (r_main_texturepool, va("%s_reflect", skinframe->basename), image_width, image_height, pixels, TEXTYPE_BGRA, skinframe->textureflags & (gl_texturecompression_reflectmask.integer ? ~0 : ~TEXF_COMPRESS), NULL); + if (r_savedds && qglGetCompressedTexImageARB && skinframe->reflect) + R_SaveTextureDDSFile(skinframe->reflect, va("dds/%s_reflect.dds", skinframe->basename), true); + Mem_Free(pixels); + pixels = NULL; + } + if (basepixels) Mem_Free(basepixels); @@ -5370,6 +5667,7 @@ skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, co skinframe->gloss = NULL; skinframe->glow = NULL; skinframe->fog = NULL; + skinframe->reflect = NULL; skinframe->hasalpha = false; // if no data was provided, then clearly the caller wanted to get a blank skinframe @@ -5438,6 +5736,7 @@ skinframe_t *R_SkinFrame_LoadInternalQuake(const char *name, int textureflags, i skinframe->gloss = NULL; skinframe->glow = NULL; skinframe->fog = NULL; + skinframe->reflect = NULL; skinframe->hasalpha = false; // if no data was provided, then clearly the caller wanted to get a blank skinframe @@ -5558,6 +5857,7 @@ skinframe_t *R_SkinFrame_LoadInternal8bit(const char *name, int textureflags, co skinframe->gloss = NULL; skinframe->glow = NULL; skinframe->fog = NULL; + skinframe->reflect = NULL; skinframe->hasalpha = false; // if no data was provided, then clearly the caller wanted to get a blank skinframe @@ -5605,6 +5905,7 @@ skinframe_t *R_SkinFrame_LoadMissing(void) skinframe->gloss = NULL; skinframe->glow = NULL; skinframe->fog = NULL; + skinframe->reflect = NULL; skinframe->hasalpha = false; skinframe->avgcolor[0] = rand() / RAND_MAX; @@ -5615,6 +5916,136 @@ skinframe_t *R_SkinFrame_LoadMissing(void) return skinframe; } +//static char *suffix[6] = {"ft", "bk", "rt", "lf", "up", "dn"}; +typedef struct suffixinfo_s +{ + char *suffix; + qboolean flipx, flipy, flipdiagonal; +} +suffixinfo_t; +static suffixinfo_t suffix[3][6] = +{ + { + {"px", false, false, false}, + {"nx", false, false, false}, + {"py", false, false, false}, + {"ny", false, false, false}, + {"pz", false, false, false}, + {"nz", false, false, false} + }, + { + {"posx", false, false, false}, + {"negx", false, false, false}, + {"posy", false, false, false}, + {"negy", false, false, false}, + {"posz", false, false, false}, + {"negz", false, false, false} + }, + { + {"rt", true, false, true}, + {"lf", false, true, true}, + {"ft", true, true, false}, + {"bk", false, false, false}, + {"up", true, false, true}, + {"dn", true, false, true} + } +}; + +static int componentorder[4] = {0, 1, 2, 3}; + +rtexture_t *R_LoadCubemap(const char *basename) +{ + int i, j, cubemapsize; + unsigned char *cubemappixels, *image_buffer; + rtexture_t *cubemaptexture; + char name[256]; + // must start 0 so the first loadimagepixels has no requested width/height + cubemapsize = 0; + cubemappixels = NULL; + cubemaptexture = NULL; + // keep trying different suffix groups (posx, px, rt) until one loads + for (j = 0;j < 3 && !cubemappixels;j++) + { + // load the 6 images in the suffix group + for (i = 0;i < 6;i++) + { + // generate an image name based on the base and and suffix + dpsnprintf(name, sizeof(name), "%s%s", basename, suffix[j][i].suffix); + // load it + if ((image_buffer = loadimagepixelsbgra(name, false, false, r_texture_convertsRGB_cubemap.integer))) + { + // an image loaded, make sure width and height are equal + if (image_width == image_height && (!cubemappixels || image_width == cubemapsize)) + { + // if this is the first image to load successfully, allocate the cubemap memory + if (!cubemappixels && image_width >= 1) + { + cubemapsize = image_width; + // note this clears to black, so unavailable sides are black + cubemappixels = (unsigned char *)Mem_Alloc(tempmempool, 6*cubemapsize*cubemapsize*4); + } + // copy the image with any flipping needed by the suffix (px and posx types don't need flipping) + if (cubemappixels) + Image_CopyMux(cubemappixels+i*cubemapsize*cubemapsize*4, image_buffer, cubemapsize, cubemapsize, suffix[j][i].flipx, suffix[j][i].flipy, suffix[j][i].flipdiagonal, 4, 4, componentorder); + } + else + Con_Printf("Cubemap image \"%s\" (%ix%i) is not square, OpenGL requires square cubemaps.\n", name, image_width, image_height); + // free the image + Mem_Free(image_buffer); + } + } + } + // if a cubemap loaded, upload it + if (cubemappixels) + { + if (developer_loading.integer) + Con_Printf("loading cubemap \"%s\"\n", basename); + + cubemaptexture = R_LoadTextureCubeMap(r_main_texturepool, basename, cubemapsize, cubemappixels, TEXTYPE_BGRA, (gl_texturecompression_lightcubemaps.integer ? TEXF_COMPRESS : 0) | TEXF_FORCELINEAR, NULL); + Mem_Free(cubemappixels); + } + else + { + Con_DPrintf("failed to load cubemap \"%s\"\n", basename); + if (developer_loading.integer) + { + Con_Printf("(tried tried images "); + for (j = 0;j < 3;j++) + for (i = 0;i < 6;i++) + Con_Printf("%s\"%s%s.tga\"", j + i > 0 ? ", " : "", basename, suffix[j][i].suffix); + Con_Print(" and was unable to find any of them).\n"); + } + } + return cubemaptexture; +} + +rtexture_t *R_GetCubemap(const char *basename) +{ + int i; + for (i = 0;i < r_texture_numcubemaps;i++) + if (!strcasecmp(r_texture_cubemaps[i].basename, basename)) + return r_texture_cubemaps[i].texture ? r_texture_cubemaps[i].texture : r_texture_whitecube; + if (i >= MAX_CUBEMAPS) + return r_texture_whitecube; + r_texture_numcubemaps++; + strlcpy(r_texture_cubemaps[i].basename, basename, sizeof(r_texture_cubemaps[i].basename)); + r_texture_cubemaps[i].texture = R_LoadCubemap(r_texture_cubemaps[i].basename); + return r_texture_cubemaps[i].texture; +} + +void R_FreeCubemaps(void) +{ + int i; + for (i = 0;i < r_texture_numcubemaps;i++) + { + if (developer_loading.integer) + Con_DPrintf("unloading cubemap \"%s\"\n", r_texture_cubemaps[i].basename); + if (r_texture_cubemaps[i].texture) + R_FreeTexture(r_texture_cubemaps[i].texture); + } + r_texture_numcubemaps = 0; +} + void R_Main_FreeViewCache(void) { if (r_refdef.viewcache.entityvisible) @@ -5678,6 +6109,7 @@ void gl_main_start(void) r_texture_normalizationcube = NULL; r_texture_fogattenuation = NULL; r_texture_gammaramps = NULL; + r_texture_numcubemaps = 0; r_loaddds = vid.support.arb_texture_compression && vid.support.ext_texture_compression_s3tc && r_texture_dds_load.integer; r_savedds = vid.support.arb_texture_compression && vid.support.ext_texture_compression_s3tc && r_texture_dds_save.integer; @@ -5741,9 +6173,11 @@ void gl_main_start(void) memset(&r_waterstate, 0, sizeof(r_waterstate)); memset(r_glsl_permutationhash, 0, sizeof(r_glsl_permutationhash)); Mem_ExpandableArray_NewArray(&r_glsl_permutationarray, r_main_mempool, sizeof(r_glsl_permutation_t), 256); + glslshaderstring = NULL; #ifdef SUPPORTCG memset(r_cg_permutationhash, 0, sizeof(r_cg_permutationhash)); Mem_ExpandableArray_NewArray(&r_cg_permutationarray, r_main_mempool, sizeof(r_cg_permutation_t), 256); + cgshaderstring = NULL; #endif memset(&r_svbsp, 0, sizeof (r_svbsp)); @@ -5784,6 +6218,7 @@ void gl_main_shutdown(void) r_texture_normalizationcube = NULL; r_texture_fogattenuation = NULL; r_texture_gammaramps = NULL; + r_texture_numcubemaps = 0; //r_texture_fogintensity = NULL; memset(&r_bloomstate, 0, sizeof(r_bloomstate)); memset(&r_waterstate, 0, sizeof(r_waterstate)); @@ -5896,6 +6331,11 @@ void GL_Main_Init(void) Cvar_RegisterVariable(&r_transparentdepthmasking); Cvar_RegisterVariable(&r_texture_dds_load); Cvar_RegisterVariable(&r_texture_dds_save); + Cvar_RegisterVariable(&r_texture_convertsRGB_2d); + Cvar_RegisterVariable(&r_texture_convertsRGB_skin); + Cvar_RegisterVariable(&r_texture_convertsRGB_cubemap); + Cvar_RegisterVariable(&r_texture_convertsRGB_skybox); + Cvar_RegisterVariable(&r_texture_convertsRGB_particles); Cvar_RegisterVariable(&r_textureunits); Cvar_RegisterVariable(&gl_combine); Cvar_RegisterVariable(&r_glsl); @@ -5943,6 +6383,8 @@ void GL_Main_Init(void) Cvar_RegisterVariable(&r_track_sprites_flags); Cvar_RegisterVariable(&r_track_sprites_scalew); Cvar_RegisterVariable(&r_track_sprites_scaleh); + Cvar_RegisterVariable(&r_overheadsprites_perspective); + Cvar_RegisterVariable(&r_overheadsprites_pushback); } extern void R_Textures_Init(void); @@ -6391,6 +6833,10 @@ static qboolean R_CanSeeBox(int numsamples, vec_t enlarge, vec3_t eye, vec3_t en boxmins[2] = (enlarge+1) * entboxmins[2] - enlarge * entboxmaxs[2]; boxmaxs[2] = (enlarge+1) * entboxmaxs[2] - enlarge * entboxmins[2]; + // return true if eye is inside enlarged box + if (BoxesOverlap(boxmins, boxmaxs, eye, eye)) + return true; + // try center VectorCopy(eye, start); VectorMAM(0.5f, boxmins, 0.5f, boxmaxs, end); @@ -6417,6 +6863,8 @@ static void R_View_UpdateEntityVisible (void) entity_render_t *ent; renderimask = r_refdef.envmap ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL) : ((chase_active.integer || r_waterstate.renderingscene) ? RENDER_VIEWMODEL : RENDER_EXTERIORMODEL); + if (!r_drawviewmodel.integer) + renderimask |= RENDER_VIEWMODEL; if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.BoxTouchingVisibleLeafs) { // worldmodel can check visibility @@ -6982,7 +7430,7 @@ static void R_Water_ProcessPlanes(void) if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION)) { if (!p->texture_refraction) - p->texture_refraction = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_refraction", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP, NULL); + p->texture_refraction = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_refraction", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_FORCELINEAR | TEXF_CLAMP, NULL); if (!p->texture_refraction) goto error; } @@ -6990,7 +7438,7 @@ static void R_Water_ProcessPlanes(void) if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION)) { if (!p->texture_reflection) - p->texture_reflection = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_reflection", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP, NULL); + p->texture_reflection = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_reflection", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_FORCELINEAR | TEXF_CLAMP, NULL); if (!p->texture_reflection) goto error; } @@ -7127,7 +7575,7 @@ void R_Bloom_StartFrame(void) r_bloomstate.screentexturewidth = screentexturewidth; r_bloomstate.screentextureheight = screentextureheight; if (r_bloomstate.screentexturewidth && r_bloomstate.screentextureheight) - r_bloomstate.texture_screen = R_LoadTexture2D(r_main_texturepool, "screen", r_bloomstate.screentexturewidth, r_bloomstate.screentextureheight, NULL, TEXTYPE_BGRA, TEXF_FORCENEAREST | TEXF_CLAMP, NULL); + r_bloomstate.texture_screen = R_LoadTexture2D(r_main_texturepool, "screen", r_bloomstate.screentexturewidth, r_bloomstate.screentextureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_FORCENEAREST | TEXF_CLAMP, NULL); } if (r_bloomstate.bloomtexturewidth != bloomtexturewidth || r_bloomstate.bloomtextureheight != bloomtextureheight) { @@ -7137,7 +7585,7 @@ void R_Bloom_StartFrame(void) r_bloomstate.bloomtexturewidth = bloomtexturewidth; r_bloomstate.bloomtextureheight = bloomtextureheight; if (r_bloomstate.bloomtexturewidth && r_bloomstate.bloomtextureheight) - r_bloomstate.texture_bloom = R_LoadTexture2D(r_main_texturepool, "bloom", r_bloomstate.bloomtexturewidth, r_bloomstate.bloomtextureheight, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_CLAMP, NULL); + r_bloomstate.texture_bloom = R_LoadTexture2D(r_main_texturepool, "bloom", r_bloomstate.bloomtexturewidth, r_bloomstate.bloomtextureheight, NULL, TEXTYPE_COLORBUFFER, TEXF_FORCELINEAR | TEXF_CLAMP, NULL); } // when doing a reduced render (HDR) we want to use a smaller area @@ -7232,9 +7680,7 @@ void R_Bloom_MakeTexture(void) r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight; // copy the vertically blurred bloom view to a texture - GL_ActiveTexture(0); - CHECKGLERROR - qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_bloomstate.viewport.x, r_bloomstate.viewport.y, r_bloomstate.viewport.width, r_bloomstate.viewport.height);CHECKGLERROR + R_Mesh_CopyToTexture(r_bloomstate.texture_bloom, 0, 0, r_bloomstate.viewport.x, r_bloomstate.viewport.y, r_bloomstate.viewport.width, r_bloomstate.viewport.height); r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height; } @@ -7284,9 +7730,7 @@ void R_Bloom_MakeTexture(void) } // copy the vertically blurred bloom view to a texture - GL_ActiveTexture(0); - CHECKGLERROR - qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_bloomstate.viewport.x, r_bloomstate.viewport.y, r_bloomstate.viewport.width, r_bloomstate.viewport.height);CHECKGLERROR + R_Mesh_CopyToTexture(r_bloomstate.texture_bloom, 0, 0, r_bloomstate.viewport.x, r_bloomstate.viewport.y, r_bloomstate.viewport.width, r_bloomstate.viewport.height); r_refdef.stats.bloom_copypixels += r_bloomstate.viewport.width * r_bloomstate.viewport.height; } @@ -7490,13 +7934,13 @@ static void R_BlendView(void) if (r_glsl_permutation->loc_Texture_Second >= 0) R_Mesh_TexBind(GL20TU_SECOND , r_bloomstate.texture_bloom ); if (r_glsl_permutation->loc_Texture_GammaRamps >= 0) R_Mesh_TexBind(GL20TU_GAMMARAMPS, r_texture_gammaramps ); if (r_glsl_permutation->loc_ViewTintColor >= 0) qglUniform4fARB(r_glsl_permutation->loc_ViewTintColor , r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]); - if (r_glsl_permutation->loc_ClientTime >= 0) qglUniform1fARB(r_glsl_permutation->loc_ClientTime , cl.time); if (r_glsl_permutation->loc_PixelSize >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelSize , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight); if (r_glsl_permutation->loc_UserVec1 >= 0) qglUniform4fARB(r_glsl_permutation->loc_UserVec1 , uservecs[0][0], uservecs[0][1], uservecs[0][2], uservecs[0][3]); if (r_glsl_permutation->loc_UserVec2 >= 0) qglUniform4fARB(r_glsl_permutation->loc_UserVec2 , uservecs[1][0], uservecs[1][1], uservecs[1][2], uservecs[1][3]); if (r_glsl_permutation->loc_UserVec3 >= 0) qglUniform4fARB(r_glsl_permutation->loc_UserVec3 , uservecs[2][0], uservecs[2][1], uservecs[2][2], uservecs[2][3]); if (r_glsl_permutation->loc_UserVec4 >= 0) qglUniform4fARB(r_glsl_permutation->loc_UserVec4 , uservecs[3][0], uservecs[3][1], uservecs[3][2], uservecs[3][3]); if (r_glsl_permutation->loc_Saturation >= 0) qglUniform1fARB(r_glsl_permutation->loc_Saturation , r_glsl_saturation.value); + if (r_glsl_permutation->loc_PixelToScreenTexCoord >= 0) qglUniform2fARB(r_glsl_permutation->loc_PixelToScreenTexCoord, 1.0f/vid.width, 1.0f/vid.height); break; case RENDERPATH_CGGL: #ifdef SUPPORTCG @@ -7505,13 +7949,13 @@ static void R_BlendView(void) if (r_cg_permutation->fp_Texture_Second ) CG_BindTexture(r_cg_permutation->fp_Texture_Second , r_bloomstate.texture_bloom );CHECKCGERROR if (r_cg_permutation->fp_Texture_GammaRamps) CG_BindTexture(r_cg_permutation->fp_Texture_GammaRamps, r_texture_gammaramps );CHECKCGERROR if (r_cg_permutation->fp_ViewTintColor ) cgGLSetParameter4f( r_cg_permutation->fp_ViewTintColor , r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);CHECKCGERROR - if (r_cg_permutation->fp_ClientTime ) cgGLSetParameter1f( r_cg_permutation->fp_ClientTime , cl.time);CHECKCGERROR if (r_cg_permutation->fp_PixelSize ) cgGLSetParameter2f( r_cg_permutation->fp_PixelSize , 1.0/r_bloomstate.screentexturewidth, 1.0/r_bloomstate.screentextureheight);CHECKCGERROR if (r_cg_permutation->fp_UserVec1 ) cgGLSetParameter4f( r_cg_permutation->fp_UserVec1 , uservecs[0][0], uservecs[0][1], uservecs[0][2], uservecs[0][3]);CHECKCGERROR if (r_cg_permutation->fp_UserVec2 ) cgGLSetParameter4f( r_cg_permutation->fp_UserVec2 , uservecs[1][0], uservecs[1][1], uservecs[1][2], uservecs[1][3]);CHECKCGERROR if (r_cg_permutation->fp_UserVec3 ) cgGLSetParameter4f( r_cg_permutation->fp_UserVec3 , uservecs[2][0], uservecs[2][1], uservecs[2][2], uservecs[2][3]);CHECKCGERROR if (r_cg_permutation->fp_UserVec4 ) cgGLSetParameter4f( r_cg_permutation->fp_UserVec4 , uservecs[3][0], uservecs[3][1], uservecs[3][2], uservecs[3][3]);CHECKCGERROR if (r_cg_permutation->fp_Saturation ) cgGLSetParameter1f( r_cg_permutation->fp_Saturation , r_glsl_saturation.value);CHECKCGERROR + if (r_cg_permutation->fp_PixelToScreenTexCoord) cgGLSetParameter2f(r_cg_permutation->fp_PixelToScreenTexCoord, 1.0f/vid.width, 1.0/vid.height);CHECKCGERROR #endif break; default: @@ -7739,6 +8183,7 @@ void R_RenderView(void) { if (r_timereport_active) R_TimeReport("start"); + r_textureframe++; // used only by R_GetCurrentTexture rsurface.entity = NULL; // used only by R_GetCurrentTexture and RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity if (!r_drawentities.integer) @@ -7798,7 +8243,11 @@ void R_RenderView(void) // this produces a bloom texture to be used in R_BlendView() later if (r_hdr.integer && r_bloomstate.bloomwidth) + { R_HDR_RenderBloomTexture(); + // we have to bump the texture frame again because r_refdef.view.colorscale is cached in the textures + r_textureframe++; // used only by R_GetCurrentTexture + } r_refdef.view.showdebug = true; @@ -7854,12 +8303,15 @@ extern cvar_t cl_locs_show; static void R_DrawLocs(void); static void R_DrawEntityBBoxes(void); static void R_DrawModelDecals(void); +extern void R_DrawModelShadows(void); +extern void R_DrawModelShadowMaps(void); extern cvar_t cl_decals_newsystem; extern qboolean r_shadow_usingdeferredprepass; void R_RenderScene(void) { + qboolean shadowmapping = false; + r_refdef.stats.renders++; - r_textureframe++; // used only by R_GetCurrentTexture R_UpdateFogColor(); @@ -7908,6 +8360,9 @@ void R_RenderScene(void) if (r_timereport_active) R_TimeReport("preparelights"); + if (R_Shadow_ShadowMappingEnabled()) + shadowmapping = true; + if (r_shadow_usingdeferredprepass) R_Shadow_DrawPrepass(); @@ -7924,6 +8379,15 @@ void R_RenderScene(void) R_TimeReport("modeldepth"); } + if (r_shadows.integer > 0 && shadowmapping && r_refdef.lightmapintensity > 0) + { + R_DrawModelShadowMaps(); + R_ResetViewRendering3D(); + // don't let sound skip if going slow + if (r_refdef.scene.extraupdate) + S_ExtraUpdate (); + } + if (cl.csqc_vidvars.drawworld && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->Draw) { r_refdef.scene.worldmodel->Draw(r_refdef.scene.worldentity); @@ -7943,7 +8407,7 @@ void R_RenderScene(void) if (r_refdef.scene.extraupdate) S_ExtraUpdate (); - if (r_shadows.integer > 0 && !r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0) + if (r_shadows.integer > 0 && !shadowmapping && !r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0) { R_DrawModelShadows(); R_ResetViewRendering3D(); @@ -7963,7 +8427,7 @@ void R_RenderScene(void) if (r_refdef.scene.extraupdate) S_ExtraUpdate (); - if (r_shadows.integer > 0 && r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0) + if (r_shadows.integer > 0 && !shadowmapping && r_shadows_drawafterrtlighting.integer && r_refdef.lightmapintensity > 0) { R_DrawModelShadows(); R_ResetViewRendering3D(); @@ -8553,7 +9017,7 @@ void R_LoadQWSkin(r_qwskincache_t *cache, const char *skinname) f = FS_LoadFile(name, tempmempool, true, &filesize); if (f) { - if (LoadPCX_QWSkin(f, filesize, pixels, 296, 194)) + if (LoadPCX_QWSkin(f, (int)filesize, pixels, 296, 194)) skinframe = R_SkinFrame_LoadInternalQuake(name, textureflags, true, r_fullbrights.integer, pixels, image_width, image_height); Mem_Free(f); } @@ -8691,6 +9155,7 @@ texture_t *R_GetCurrentTexture(texture_t *t) t->glosstexture = r_texture_black; t->glowtexture = t->currentskinframe->glow; t->fogtexture = t->currentskinframe->fog; + t->reflectmasktexture = t->currentskinframe->reflect; if (t->backgroundnumskinframes) { t->backgroundbasetexture = (!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base; @@ -8744,6 +9209,7 @@ texture_t *R_GetCurrentTexture(texture_t *t) t->glosstexture = r_texture_black; t->glowtexture = NULL; t->fogtexture = NULL; + t->reflectmasktexture = NULL; t->backgroundbasetexture = NULL; t->backgroundnmaptexture = r_texture_blanknormalmap; t->backgroundglosstexture = r_texture_black; @@ -10286,12 +10752,14 @@ extern rtexture_t *r_shadow_prepasslightingdiffusetexture; extern rtexture_t *r_shadow_prepasslightingspeculartexture; static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, const msurface_t **texturesurfacelist, qboolean writedepth, qboolean prepass) { + if (r_waterstate.renderingscene && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION))) + return; RSurf_PrepareVerticesForBatch(true, true, texturenumsurfaces, texturesurfacelist); if (prepass) { // render screenspace normalmap to texture GL_DepthMask(true); - R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, prepass ? RSURFPASS_DEFERREDGEOMETRY : RSURFPASS_BASE); + R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_DEFERREDGEOMETRY); RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist); } else if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION)) && !r_waterstate.renderingscene) @@ -10301,14 +10769,17 @@ static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, const msurface R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BACKGROUND); RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist); GL_DepthMask(false); - R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, prepass ? RSURFPASS_DEFERREDGEOMETRY : RSURFPASS_BASE); - RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist); + R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE); + if (rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) + RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist); + else + RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist); } else { // render surface normally GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED)); - R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, prepass ? RSURFPASS_DEFERREDGEOMETRY : RSURFPASS_BASE); + R_SetupShader_Surface(vec3_origin, (rsurface.texture->currentmaterialflags & MATERIALFLAG_MODELLIGHT) != 0, 1, 1, rsurface.texture->specularscale, RSURFPASS_BASE); if (rsurface.texture->currentmaterialflags & MATERIALFLAG_REFLECTION) RSurf_DrawBatch_WithLightmapSwitching_WithWaterTextureSwitching(texturenumsurfaces, texturesurfacelist); else if (rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) @@ -10367,7 +10838,7 @@ static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, const msurface { case TEXTURELAYERTYPE_LITTEXTURE: // single-pass lightmapped texture with 2x rgbscale - //R_Mesh_TexBind(0, r_texture_white); + R_Mesh_TexBind(0, r_texture_white); R_Mesh_TexMatrix(0, NULL); R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1); R_Mesh_TexCoordPointer(0, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset); @@ -10472,7 +10943,7 @@ static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, const msurface { // two-pass lit texture with 2x rgbscale // first the lightmap pass - //R_Mesh_TexBind(0, r_texture_white); + R_Mesh_TexBind(0, r_texture_white); R_Mesh_TexMatrix(0, NULL); R_Mesh_TexCombine(0, GL_MODULATE, GL_MODULATE, 1, 1); R_Mesh_TexCoordPointer(0, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset); @@ -10666,7 +11137,7 @@ static void R_DrawWorldTextureSurfaceList(int texturenumsurfaces, const msurface { CHECKGLERROR RSurf_SetupDepthAndCulling(); - if (r_showsurfaces.integer == 3 && !prepass) + if (r_showsurfaces.integer == 3 && !prepass && (rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY)) { R_DrawTextureSurfaceList_ShowSurfaces3(texturenumsurfaces, texturesurfacelist, writedepth); return; @@ -10691,7 +11162,7 @@ static void R_DrawModelTextureSurfaceList(int texturenumsurfaces, const msurface { CHECKGLERROR RSurf_SetupDepthAndCulling(); - if (r_showsurfaces.integer == 3 && !prepass) + if (r_showsurfaces.integer == 3 && !prepass && (rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY)) { R_DrawTextureSurfaceList_ShowSurfaces3(texturenumsurfaces, texturesurfacelist, writedepth); return; @@ -11122,7 +11593,6 @@ static void R_DecalSystem_SpawnTriangle(decalsystem_t *decalsystem, const float tridecal_t *decal; tridecal_t *decals; int i; - int maxdecals; // expand or initialize the system if (decalsystem->maxdecals <= decalsystem->numdecals) @@ -11149,7 +11619,6 @@ static void R_DecalSystem_SpawnTriangle(decalsystem_t *decalsystem, const float } // grab a decal and search for another free slot for the next one - maxdecals = decalsystem->maxdecals; decals = decalsystem->decals; decal = decalsystem->decals + (i = decalsystem->freedecal++); for (i = decalsystem->freedecal;i < decalsystem->numdecals && decals[i].color4ub[0][3];i++) @@ -11206,13 +11675,11 @@ static void R_DecalSystem_SplatEntity(entity_render_t *ent, const vec3_t worldor const msurface_t *surfaces; const int *surfacelist; const texture_t *texture; - int numvertices; int numtriangles; int numsurfacelist; int surfacelistindex; int surfaceindex; int triangleindex; - int decalsurfaceindex; int cornerindex; int index; int numpoints; @@ -11222,7 +11689,6 @@ static void R_DecalSystem_SplatEntity(entity_render_t *ent, const vec3_t worldor float localmins[3]; float localmaxs[3]; float localsize; - float ilocalsize; float v[9][3]; float tc[9][2]; float c[9][4]; @@ -11258,7 +11724,6 @@ static void R_DecalSystem_SplatEntity(entity_render_t *ent, const vec3_t worldor Matrix4x4_Transform3x3(&rsurface.inversematrix, worldnormal, localnormal); VectorNormalize(localnormal); localsize = worldsize*rsurface.inversematrixscale; - ilocalsize = 1.0f / localsize; localmins[0] = localorigin[0] - localsize; localmins[1] = localorigin[1] - localsize; localmins[2] = localorigin[2] - localsize; @@ -11319,16 +11784,15 @@ static void R_DecalSystem_SplatEntity(entity_render_t *ent, const vec3_t worldor { surfaceindex = surfacelist[surfacelistindex]; surface = surfaces + surfaceindex; + // check cull box first because it rejects more than any other check + if (!dynamic && !BoxesOverlap(surface->mins, surface->maxs, localmins, localmaxs)) + continue; // skip transparent surfaces texture = surface->texture; if (texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_SKY | MATERIALFLAG_SHORTDEPTHRANGE | MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION)) continue; if (texture->surfaceflags & Q3SURFACEFLAG_NOMARKS) continue; - if (!dynamic && !BoxesOverlap(surface->mins, surface->maxs, localmins, localmaxs)) - continue; - decalsurfaceindex = ent == r_refdef.scene.worldentity ? surfaceindex : -1; - numvertices = surface->num_vertices; numtriangles = surface->num_triangles; for (triangleindex = 0, e = model->surfmesh.data_element3i + 3*surface->num_firsttriangle;triangleindex < numtriangles;triangleindex++, e += 3) { @@ -11438,7 +11902,6 @@ typedef struct r_decalsystem_splatqueue_s r_decalsystem_splatqueue_t; int r_decalsystem_numqueued = 0; -#define MAX_DECALSYSTEM_QUEUE 1024 r_decalsystem_splatqueue_t r_decalsystem_queue[MAX_DECALSYSTEM_QUEUE]; void R_DecalSystem_SplatEntities(const vec3_t worldorigin, const vec3_t worldnormal, float r, float g, float b, float a, float s1, float t1, float s2, float t2, float worldsize) @@ -11544,7 +12007,6 @@ static void R_DrawModelDecals_Entity(entity_render_t *ent) decalsystem_t *decalsystem = &ent->decalsystem; int numdecals; tridecal_t *decal; - float fadedelay; float faderate; float alpha; float *v3f; @@ -11578,7 +12040,6 @@ static void R_DrawModelDecals_Entity(entity_render_t *ent) decalsystem->lastupdatetime = cl.time; decal = decalsystem->decals; - fadedelay = cl_decals_time.value; faderate = 1.0f / max(0.001f, cl_decals_fadetime.value); // update vertex positions for animated models @@ -11724,7 +12185,6 @@ void R_DrawDebugModel(void) { entity_render_t *ent = rsurface.entity; int i, j, k, l, flagsmask; - const int *elements; q3mbrush_t *brush; const msurface_t *surface; dp_model_t *model = ent->model; @@ -11793,7 +12253,6 @@ void R_DrawDebugModel(void) GL_Color(r_refdef.view.colorscale, r_refdef.view.colorscale, r_refdef.view.colorscale, r_showtris.value); else GL_Color(0, r_refdef.view.colorscale, 0, r_showtris.value); - elements = (model->surfmesh.data_element3i + 3 * surface->num_firsttriangle); R_Mesh_VertexPointer(rsurface.vertex3f, 0, 0); R_Mesh_ColorPointer(NULL, 0, 0); R_Mesh_TexCoordPointer(0, 0, NULL, 0, 0); @@ -11868,8 +12327,7 @@ int r_maxsurfacelist = 0; const msurface_t **r_surfacelist = NULL; void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass) { - int i, j, endj, f, flagsmask; - texture_t *t; + int i, j, endj, flagsmask; dp_model_t *model = r_refdef.scene.worldmodel; msurface_t *surfaces; unsigned char *update; @@ -11915,8 +12373,6 @@ void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean dep return; } - f = 0; - t = NULL; rsurface.uselightmaptexture = false; rsurface.texture = NULL; rsurface.rtlight = NULL; @@ -11965,8 +12421,7 @@ void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean dep void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass) { - int i, j, endj, f, flagsmask; - texture_t *t; + int i, j, endj, flagsmask; dp_model_t *model = ent->model; msurface_t *surfaces; unsigned char *update; @@ -11992,7 +12447,19 @@ void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean wr else if (prepass) RSurf_ActiveModelEntity(ent, true, true, true); else if (depthonly) - RSurf_ActiveModelEntity(ent, false, false, false); + { + switch (vid.renderpath) + { + case RENDERPATH_GL20: + case RENDERPATH_CGGL: + RSurf_ActiveModelEntity(ent, model->wantnormals, model->wanttangents, false); + break; + case RENDERPATH_GL13: + case RENDERPATH_GL11: + RSurf_ActiveModelEntity(ent, model->wantnormals, false, false); + break; + } + } else { switch (vid.renderpath) @@ -12036,8 +12503,6 @@ void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean wr return; } - f = 0; - t = NULL; rsurface.uselightmaptexture = false; rsurface.texture = NULL; rsurface.rtlight = NULL;