Improved Random building texturesa - Gabo Huerta
[fg:toms-fgdata.git] / Shaders / urban-gbuffer.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 varying vec4  specular;
25
26 uniform sampler3D NoiseTex;
27 uniform sampler2D BaseTex;
28 uniform sampler2D NormalTex;
29 uniform sampler2D QDMTex;
30 uniform float depth_factor;
31 uniform float tile_size;
32 uniform float quality_level;
33 uniform float snowlevel;
34 uniform bool random_buildings;
35
36 const float scale = 1.0;
37 int linear_search_steps = 10;
38 int GlobalIterationCount = 0;
39 int gIterationCap = 64;
40
41 void encode_gbuffer(vec3 normal, vec3 color, int mId, float specular, float shininess, float emission, float depth);
42
43 void QDM(inout vec3 p, inout vec3 v)
44 {
45     const int MAX_LEVEL = TEXTURE_MIP_LEVELS;
46     const float NODE_COUNT = TEXTURE_PIX_COUNT;
47     const float TEXEL_SPAN_HALF = 1.0 / NODE_COUNT / 2.0;
48
49     float fDeltaNC = TEXEL_SPAN_HALF * depth_factor;
50
51     vec3 p2 = p;
52     float level = MAX_LEVEL;
53     vec2 dirSign = (sign(v.xy) + 1.0) * 0.5;
54     GlobalIterationCount = 0;
55     float d = 0.0;
56
57     while (level >= 0.0 && GlobalIterationCount < gIterationCap)
58     {
59         vec4 uv = vec4(p2.xyz, level);
60         d = texture2DLod(QDMTex, uv.xy, uv.w).w;
61
62         if (d > p2.z)
63         {
64             //predictive point of ray traversal
65             vec3 tmpP2 = p + v * d;
66
67             //current node count
68             float nodeCount = pow(2.0, (MAX_LEVEL - level));
69             //current and predictive node ID
70             vec4 nodeID = floor(vec4(p2.xy, tmpP2.xy)*nodeCount);
71
72             //check if we are crossing the current cell
73             if (nodeID.x != nodeID.z || nodeID.y != nodeID.w)
74             {
75                 //calculate distance to nearest bound
76                 vec2 a = p2.xy - p.xy;
77                 vec2 p3 = (nodeID.xy + dirSign) / nodeCount;
78                 vec2 b = p3.xy - p.xy;
79
80                 vec2 dNC = (b.xy * p2.z) / a.xy;
81                 //take the nearest cell
82                 d = min(d,min(dNC.x, dNC.y))+fDeltaNC;
83
84                 level++;
85
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 ( random_buildings )
158         return 0.0;
159     else if ( quality_level >= 4.0 )
160         return ray_intersect_QDM( dp, ds );
161     else
162         return ray_intersect_relief( dp, ds );
163 }
164
165 void main (void)
166 {
167     if ( quality_level >= 3.0 ) {
168         linear_search_steps = 20;
169     }
170
171     float depthfactor = depth_factor;
172     if ( random_buildings )
173         depthfactor = 0.0;
174
175     vec3 normal = normalize(VNormal);
176     vec3 tangent = normalize(VTangent);
177     vec3 binormal = normalize(VBinormal);
178     vec3 ecPos3 = ecPosition.xyz / ecPosition.w;
179     vec3 V = normalize(ecPos3);
180     vec3 s = vec3(dot(V, tangent), dot(V, binormal), dot(normal, -V));
181     vec2 ds = s.xy * depthfactor / 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;
187     float emis = N.z;
188     N = N * 2.0 - 1.0;
189
190
191     N.z = sqrt(1.0 - min(1.0,dot(N.xy, N.xy)));
192     float Nz = N.z;
193     N = normalize(N.x * tangent + N.y * binormal + N.z * normal);
194
195     vec4 ambient_light = constantColor + vec4(gl_Color.rgb, 1.0);
196
197     // vec4 noisevec   = texture3D(NoiseTex, (rawpos.xyz)*0.01*scale);
198     // vec4 nvL   = texture3D(NoiseTex, (rawpos.xyz)*0.00066*scale);
199
200     // float n=0.06;
201     // n += nvL[0]*0.4;
202     // n += nvL[1]*0.6;
203     // n += nvL[2]*2.0;
204     // n += nvL[3]*4.0;
205     // n += noisevec[0]*0.1;
206     // n += noisevec[1]*0.4;
207
208     // n += noisevec[2]*0.8;
209     // n += noisevec[3]*2.1;
210     // n = mix(0.6, n, length(ecPosition.xyz) );
211
212     vec4 finalColor = texture2D(BaseTex, uv);
213     // finalColor = mix(finalColor, clamp(n+nvL[2]*4.1+vec4(0.1, 0.1, nvL[2]*2.2, 1.0), 0.7, 1.0),
214             // step(0.8,Nz)*(1.0-emis)*smoothstep(snowlevel+300.0, snowlevel+360.0, (rawpos.z)+nvL[1]*3000.0));
215     // finalColor *= ambient_light;
216
217     vec4 p = vec4( ecPos3 + tile_size * V * (d-1.0) * depthfactor / s.z, 1.0 );
218
219     if (dot(normal,-V) > 0.1) {
220         vec4 iproj = gl_ProjectionMatrix * p;
221         iproj /= iproj.w;
222         gl_FragDepth = (iproj.z+1.0)/2.0;
223     } else {
224         gl_FragDepth = gl_FragCoord.z;
225     }
226     encode_gbuffer(N, finalColor.rgb, 1, dot(specular.xyz,vec3(0.3, 0.59, 0.11 )), specular.w, 0.0, gl_FragDepth);
227 }