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