Restore QDM urban shader technique for quality level >= 4
[fg:toms-fgdata.git] / Shaders / urban.frag
1 // -*- mode: C; -*-
2 // Licence: GPL v2
3 // Author: Frederic Bouvier.
4 //  Adapted from the paper by F. Policarpo et al. : Real-time Relief Mapping on Arbitrary Polygonal Surfaces
5
6 #version 120
7
8 #define TEXTURE_MIP_LEVELS 10
9 #define TEXTURE_PIX_COUNT  1024 //pow(2,TEXTURE_MIP_LEVELS)
10 #define BINARY_SEARCH_COUNT 10
11 #define BILINEAR_SMOOTH_FACTOR 2.0
12
13 varying vec4  rawpos;
14 varying vec4  ecPosition;
15 varying vec3  VNormal;
16 varying vec3  VTangent;
17 varying vec3  VBinormal;
18 varying vec3  Normal;
19 varying vec4  constantColor;
20
21 uniform sampler3D NoiseTex;
22 uniform sampler2D BaseTex;
23 uniform sampler2D NormalTex;
24 uniform sampler2D QDMTex;
25 uniform float depth_factor;
26 uniform float tile_size;
27 uniform float quality_level; // From /sim/rendering/quality-level
28 uniform float snowlevel; // From /sim/rendering/snow-level-m
29 uniform vec3 night_color;
30
31 const float scale = 1.0;
32 int linear_search_steps = 10;
33 int GlobalIterationCount = 0;
34 int gIterationCap = 64;
35
36 void QDM(inout vec3 p, inout vec3 v)
37 {
38         const int MAX_LEVEL = TEXTURE_MIP_LEVELS;
39         const float NODE_COUNT = TEXTURE_PIX_COUNT;
40         const float TEXEL_SPAN_HALF = 1.0 / NODE_COUNT / 2.0;
41
42         float fDeltaNC = TEXEL_SPAN_HALF * depth_factor;
43
44         vec3 p2 = p;
45         float level = MAX_LEVEL;
46     vec2 dirSign = (sign(v.xy) + 1.0) * 0.5;
47     GlobalIterationCount = 0;
48     float d = 0.0;
49
50         while (level >= 0.0 && GlobalIterationCount < gIterationCap)
51         {
52                 vec4 uv = vec4(p2.xyz, level);
53                 d = texture2DLod(QDMTex, uv.xy, uv.w).w;
54
55                 if (d > p2.z)
56                 {
57                         //predictive point of ray traversal
58                         vec3 tmpP2 = p + v * d;
59
60                         //current node count
61                         float nodeCount = pow(2.0, (MAX_LEVEL - level));
62                         //current and predictive node ID
63                         vec4 nodeID = floor(vec4(p2.xy, tmpP2.xy)*nodeCount);
64
65                         //check if we are crossing the current cell
66                         if (nodeID.x != nodeID.z || nodeID.y != nodeID.w)
67                         {
68                                 //calculate distance to nearest bound
69                                 vec2 a = p2.xy - p.xy;
70                                 vec2 p3 = (nodeID.xy + dirSign) / nodeCount;
71                                 vec2 b = p3.xy - p.xy;
72
73                                 vec2 dNC = (b.xy * p2.z) / a.xy;
74                                 //take the nearest cell
75                                 d = min(d,min(dNC.x, dNC.y))+fDeltaNC;
76
77                                 level++;
78
79                                 //use additional convergence speed-up
80                     #ifdef USE_QDM_ASCEND_INTERVAL
81                             if(frac(level*0.5) > EPSILON)
82                                   level++;
83                                 #elseif USE_QDM_ASCEND_CONST
84                                  level++;
85                                 #endif
86                         }
87                         p2 = p + v * d;
88                 }
89                 level--;
90                 GlobalIterationCount++;
91         }
92
93         //
94         // Manual Bilinear filtering
95         //
96         float rayLength =  length(p2.xy - p.xy) + fDeltaNC;
97
98         float dA = p2.z * (rayLength - BILINEAR_SMOOTH_FACTOR * TEXEL_SPAN_HALF) / rayLength;
99         float dB = p2.z * (rayLength + BILINEAR_SMOOTH_FACTOR * TEXEL_SPAN_HALF) / rayLength;
100
101         vec4 p2a = vec4(p + v * dA, 0.0);
102         vec4 p2b = vec4(p + v * dB, 0.0);
103         dA = texture2DLod(NormalTex, p2a.xy, p2a.w).w;
104         dB = texture2DLod(NormalTex, p2b.xy, p2b.w).w;
105
106         dA = abs(p2a.z - dA);
107         dB = abs(p2b.z - dB);
108
109         p2 = mix(p2a.xyz, p2b.xyz, dA / (dA + dB));
110
111         p = p2;
112 }
113
114 float ray_intersect_QDM(vec2 dp, vec2 ds)
115 {
116     vec3 p = vec3( dp, 0.0 );
117     vec3 v = vec3( ds, 1.0 );
118     QDM( p, v );
119     return p.z;
120 }
121
122 float ray_intersect_relief(vec2 dp, vec2 ds)
123 {
124         float size = 1.0 / float(linear_search_steps);
125         float depth = 0.0;
126         float best_depth = 1.0;
127
128         for(int i = 0; i < linear_search_steps - 1; ++i)
129         {
130                 depth += size;
131                 float t = step(0.95, texture2D(NormalTex, dp + ds * depth).a);
132                 if(best_depth > 0.996)
133                         if(depth >= t)
134                                 best_depth = depth;
135         }
136         depth = best_depth;
137
138         const int binary_search_steps = 5;
139
140         for(int i = 0; i < binary_search_steps; ++i)
141         {
142                 size *= 0.5;
143                 float t = step(0.95, texture2D(NormalTex, dp + ds * depth).a);
144                 if(depth >= t)
145                 {
146                         best_depth = depth;
147                         depth -= 2.0 * size;
148                 }
149                 depth += size;
150         }
151
152         return(best_depth);
153 }
154
155 float ray_intersect(vec2 dp, vec2 ds)
156 {
157     if ( quality_level >= 4.0 )
158         return ray_intersect_QDM( dp, ds );
159     else
160         return ray_intersect_relief( dp, ds );
161 }
162
163 void main (void)
164 {
165         if ( quality_level >= 3.5 ) {
166                 linear_search_steps = 20;
167         }
168         vec3 ecPos3 = ecPosition.xyz / ecPosition.w;
169         vec3 V = normalize(ecPos3);
170         vec3 s = vec3(dot(V, VTangent), dot(V, VBinormal), dot(VNormal, -V));
171         vec2 ds = s.xy * depth_factor / s.z;
172         vec2 dp = gl_TexCoord[0].st - ds;
173         float d = ray_intersect(dp, ds);
174
175         vec2 uv = dp + ds * d;
176         vec3 N = texture2D(NormalTex, uv).xyz * 2.0 - 1.0;
177
178
179         float emis = N.z;
180         N.z = sqrt(1.0 - min(1.0,dot(N.xy, N.xy)));
181         float Nz = N.z;
182         N = normalize(N.x * VTangent + N.y * VBinormal + N.z * VNormal);
183
184         vec3 l = gl_LightSource[0].position.xyz;
185         vec3 diffuse = gl_Color.rgb * max(0.0, dot(N, l));
186         float shadow_factor = 1.0;
187
188         // Shadow
189         if ( quality_level >= 3.0 ) {
190                 dp += ds * d;
191                 vec3 sl = normalize( vec3( dot( l, VTangent ), dot( l, VBinormal ), dot( -l, VNormal ) ) );
192                 ds = sl.xy * depth_factor / sl.z;
193                 dp -= ds * d;
194                 float dl = ray_intersect(dp, ds);
195                 if ( dl < d - 0.05 )
196                         shadow_factor = dot( constantColor.xyz, vec3( 1.0, 1.0, 1.0 ) ) * 0.25;
197         }
198         // end shadow
199
200         vec4 ambient_light = constantColor + gl_LightSource[0].diffuse * vec4(diffuse, 1.0);
201         float reflectance = ambient_light.r * 0.3 + ambient_light.g * 0.59 + ambient_light.b * 0.11;
202         if ( shadow_factor < 1.0 )
203                 ambient_light = constantColor + gl_LightSource[0].diffuse * shadow_factor * vec4(diffuse, 1.0);
204         float emission_factor = (1.0 - smoothstep(0.15, 0.25, reflectance)) * emis;
205         vec4 tc = texture2D(BaseTex, uv);
206         emission_factor *= 0.5*pow(tc.r+0.8*tc.g+0.2*tc.b, 2.0) -0.2;
207         ambient_light += (emission_factor * vec4(night_color, 0.0));
208
209         float fogFactor;
210         float fogCoord = ecPos3.z / (1.0 + smoothstep(0.3, 0.7, emission_factor));
211         const float LOG2 = 1.442695;
212         fogFactor = exp2(-gl_Fog.density * gl_Fog.density * fogCoord * fogCoord * LOG2);
213         fogFactor = clamp(fogFactor, 0.0, 1.0);
214
215         vec4 noisevec   = texture3D(NoiseTex, (rawpos.xyz)*0.01*scale);
216         vec4 nvL   = texture3D(NoiseTex, (rawpos.xyz)*0.00066*scale);
217
218         float n=0.06;
219         n += nvL[0]*0.4;
220         n += nvL[1]*0.6;
221         n += nvL[2]*2.0;
222         n += nvL[3]*4.0;
223         n += noisevec[0]*0.1;
224         n += noisevec[1]*0.4;
225
226         n += noisevec[2]*0.8;
227         n += noisevec[3]*2.1;
228         n = mix(0.6, n, fogFactor);
229
230         vec4 finalColor = texture2D(BaseTex, uv);
231         finalColor = mix(finalColor, clamp(n+nvL[2]*4.1+vec4(0.1, 0.1, nvL[2]*2.2, 1.0), 0.7, 1.0),
232                         step(0.8,Nz)*(1.0-emis)*smoothstep(snowlevel+300.0, snowlevel+360.0, (rawpos.z)+nvL[1]*3000.0));
233         finalColor *= ambient_light;
234
235         if (gl_Fog.density == 1.0)
236                 fogFactor=1.0;
237
238         vec4 p = vec4( ecPos3 + tile_size * V * (d-1.0) * depth_factor / s.z, 1.0 );
239         vec4 iproj = gl_ProjectionMatrix * p;
240         iproj /= iproj.w;
241         gl_FragColor = mix(gl_Fog.color ,finalColor, fogFactor);
242         gl_FragDepth = (iproj.z+1.0)/2.0;
243 }