X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=gl_rmain.c;h=6e67797341063219c231de17d3afec744448def0;hb=4ea02ee535ced34477f22481d6c51f672d3dedf4;hp=68045ed108b4a964e30b02ca7fdfaffc984eac47;hpb=006ce514d0c3f0b307caed2f4fe951ea4f6ffb62;p=xonotic%2Fdarkplaces.git diff --git a/gl_rmain.c b/gl_rmain.c index 68045ed1..6e677973 100644 --- a/gl_rmain.c +++ b/gl_rmain.c @@ -162,6 +162,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 +211,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; @@ -474,7 +489,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 +816,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 +856,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) && defined(USEDIFFUSE)\n" +"#if (defined(MODE_LIGHTSOURCE) || defined(MODE_LIGHTDIRECTION)) && defined(USEDIFFUSE)\n" "varying vec3 LightVector;\n" "#endif\n" "\n" @@ -854,7 +867,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" @@ -888,18 +901,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 +931,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" @@ -1163,9 +1172,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" @@ -1281,11 +1290,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 +1324,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 +1350,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" @@ -1428,7 +1441,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" @@ -1448,6 +1461,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 +1479,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 +1528,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.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 *= myhalf(texture2D(Texture_Attenuation, vec2(length(CubeVector), 0.0)));\n" @@ -1601,12 +1631,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" @@ -1616,8 +1646,9 @@ static const char *builtinshaderstring = "#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" @@ -1709,7 +1740,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" @@ -1814,7 +1845,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" @@ -1832,7 +1863,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" @@ -1903,7 +1934,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" @@ -1959,7 +1990,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" @@ -2002,7 +2033,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" @@ -2019,7 +2050,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" @@ -2069,14 +2100,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" @@ -2162,13 +2193,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" @@ -2177,13 +2208,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" @@ -2198,7 +2229,7 @@ const char *builtincgshaderstring = " 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" +" 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" @@ -2241,21 +2272,21 @@ 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" @@ -2296,37 +2327,33 @@ 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" @@ -2370,14 +2397,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" @@ -2416,8 +2449,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" @@ -2446,9 +2481,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" @@ -2465,7 +2502,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" @@ -2480,9 +2517,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" @@ -2490,8 +2528,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" @@ -2531,11 +2569,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" @@ -2552,10 +2592,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" @@ -2615,12 +2655,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" @@ -2653,7 +2693,7 @@ 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" @@ -2755,7 +2795,7 @@ 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" @@ -2796,13 +2836,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" @@ -2821,6 +2861,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" @@ -2838,6 +2879,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" @@ -2910,14 +2956,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" @@ -2926,28 +2972,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 * (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 *= half(tex2D(Texture_Attenuation, float2(length(CubeVector), 0.0)));\n" @@ -3033,12 +3090,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" @@ -3048,14 +3105,14 @@ const char *builtincgshaderstring = "#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" @@ -3063,9 +3120,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" @@ -3084,8 +3141,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" @@ -3103,6 +3160,9 @@ const char *builtincgshaderstring = "#endif // !MODE_DEPTH_OR_SHADOW\n" ; +char *glslshaderstring = NULL; +char *cgshaderstring = NULL; + //======================================================================================================================================================= typedef struct shaderpermutationinfo_s @@ -3150,8 +3210,9 @@ typedef enum shaderpermutation_e 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 = 26 ///< size of shaderpermutationinfo array + SHADERPERMUTATION_REFLECTCUBE = 1<<26, ///< fake reflections using global cubemap (not HDRI light probe) + SHADERPERMUTATION_LIMIT = 1<<27, ///< size of permutations array + SHADERPERMUTATION_COUNT = 27 ///< size of shaderpermutationinfo array } shaderpermutation_t; @@ -3184,6 +3245,7 @@ shaderpermutationinfo_t shaderpermutationinfo[SHADERPERMUTATION_COUNT] = {"#define USESHADOWMAPVSDCT\n", " shadowmapvsdct"}, {"#define USEDEFERREDLIGHTMAP\n", " deferredlightmap"}, {"#define USEALPHAKILL\n", " alphakill"}, + {"#define USEREFLECTCUBE\n", " reflectcube"}, }; /// this enum is multiplied by SHADERPERMUTATION_MODEBASE @@ -3233,7 +3295,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"}, @@ -3290,6 +3352,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; @@ -3338,6 +3402,8 @@ typedef struct r_glsl_permutation_s int loc_BackgroundTexMatrix; int loc_ModelViewProjectionMatrix; int loc_ModelViewMatrix; + int loc_PixelToScreenTexCoord; + int loc_ModelToReflectCube; } r_glsl_permutation_t; @@ -3380,6 +3446,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) { @@ -3387,11 +3467,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; } @@ -3502,6 +3577,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"); @@ -3550,6 +3627,8 @@ 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"); // 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); @@ -3579,6 +3658,8 @@ static void R_GLSL_CompilePermutation(r_glsl_permutation_t *p, unsigned int mode 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); } @@ -3691,6 +3772,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; @@ -3734,6 +3817,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; @@ -3776,6 +3861,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) { @@ -3783,14 +3882,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; @@ -3805,6 +3904,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; @@ -3815,11 +3915,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) @@ -3832,6 +3934,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++) @@ -3842,6 +3945,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 { @@ -3852,6 +3956,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; @@ -3897,125 +4006,117 @@ 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"); + 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])) @@ -4079,13 +4180,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) @@ -4105,9 +4206,9 @@ void R_SetupShader_SetPermutationCG(unsigned int mode, unsigned int permutation) if (r_cg_permutation->vp_ModelViewMatrix) cgGLSetMatrixParameterfc(r_cg_permutation->vp_ModelViewMatrix, gl_modelview16f);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 @@ -4115,11 +4216,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++) { @@ -4136,6 +4244,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++) { @@ -4148,8 +4261,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: @@ -4396,6 +4509,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)) { @@ -4438,6 +4553,8 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, permutation |= SHADERPERMUTATION_COLORMAPPING; 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)) { @@ -4488,6 +4605,8 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, 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)) { @@ -4528,6 +4647,8 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, 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)) { @@ -4567,6 +4688,8 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, 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 +4764,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);} @@ -4723,6 +4847,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 +4862,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 ); @@ -4761,6 +4888,7 @@ void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, 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 @@ -4860,6 +4988,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 +5003,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 @@ -4969,6 +5100,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 +5124,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 +5192,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; } } @@ -5215,6 +5349,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,6 +5408,7 @@ 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 @@ -5340,6 +5476,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))) + { + 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 +5515,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 +5584,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 +5705,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 +5753,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 +5764,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))) + { + // 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 +5957,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 +6021,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 +6066,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)); @@ -5943,6 +6226,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); @@ -6982,7 +7267,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 +7275,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 +7412,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 +7422,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 +7517,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 +7567,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; } @@ -7497,6 +7778,7 @@ static void R_BlendView(void) 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 @@ -7512,6 +7794,7 @@ static void R_BlendView(void) 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 +8022,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 +8082,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; @@ -7859,7 +8147,6 @@ extern qboolean r_shadow_usingdeferredprepass; void R_RenderScene(void) { r_refdef.stats.renders++; - r_textureframe++; // used only by R_GetCurrentTexture R_UpdateFogColor(); @@ -7892,8 +8179,11 @@ void R_RenderScene(void) if (skyrendermasked && skyrenderlater) { // we have to force off the water clipping plane while rendering sky + qboolean save = r_refdef.view.showdebug; R_SetupView(false); + r_refdef.view.showdebug = false; R_Sky(); + r_refdef.view.showdebug = save; R_SetupView(true); if (r_timereport_active) R_TimeReport("sky"); @@ -8691,6 +8981,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 +9035,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 +10578,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 +10595,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 +10664,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 +10769,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); @@ -11319,14 +11616,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; @@ -11438,7 +11736,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)