Angle between tangents exceeds tolerance for vertex 990.
Angle between tangents exceeds tolerance for vertex 991.
Loaded material definition: Post Shadow
New materail provider registered for: Materials/Utility/matcap_blueprint.j3m
Child (previewSphere) attached to this node (Preview Node)
Bad compile of:
1	#version 150 core
2	#extension GL_ARB_texture_multisample : enable
3
4	uniform int m_NumSamples;
5	uniform int m_NumSamplesDepth;
6
7	#ifdef RESOLVE_MS
8	    #define COLORTEXTURE sampler2DMS
9	#else
10	    #define COLORTEXTURE sampler2D
11	#endif
12
13	#ifdef RESOLVE_DEPTH_MS
14	    #define DEPTHTEXTURE sampler2DMS
15	#else
16	    #define DEPTHTEXTURE sampler2D
17	#endif
18
19	// NOTE: Only define multisample functions if multisample is available and is being used!
20	#if defined(GL_ARB_texture_multisample) && (defined(RESOLVE_MS) || defined(RESOLVE_DEPTH_MS))
21	vec4 textureFetch(in sampler2DMS tex,in vec2 texC, in int numSamples){
22	      ivec2 iTexC = ivec2(texC * textureSize(tex));
23	      vec4 color = vec4(0.0);
24	      for (int i = 0; i < numSamples; i++){
25	         color += texelFetch(tex, iTexC, i);
26	      }
27	      return color / numSamples;
28	}
29
30	vec4 fetchTextureSample(in sampler2DMS tex,in vec2 texC,in int sample){
31	    ivec2 iTexC = ivec2(texC * textureSize(tex));
32	    return texelFetch(tex, iTexC, sample);
33	}
34
35	vec4 getColor(in sampler2DMS tex, in vec2 texC){
36	      return textureFetch(tex, texC, m_NumSamples);
37	}
38
39	vec4 getColorSingle(in sampler2DMS tex, in vec2 texC){
40	    ivec2 iTexC = ivec2(texC * textureSize(tex));
41	    return texelFetch(tex, iTexC, 0);
42	}
43
44	vec4 getDepth(in sampler2DMS tex,in vec2 texC){
45	      return textureFetch(tex,texC,m_NumSamplesDepth);
46	}
47	#endif
48
49	vec4 fetchTextureSample(in sampler2D tex,in vec2 texC,in int sample){
50	    return texture2D(tex,texC);
51	}
52
53	vec4 getColor(in sampler2D tex, in vec2 texC){
54	    return texture2D(tex,texC);
55	}
56
57	vec4 getColorSingle(in sampler2D tex, in vec2 texC){
58	    return texture2D(tex, texC);
59	}
60
61	vec4 getDepth(in sampler2D tex,in vec2 texC){
62	    return texture2D(tex,texC);
63	}
64	// Because gpu_shader5 is actually where those
65	// gather functions are declared to work on shadowmaps
66	#extension GL_ARB_gpu_shader5 : enable
67
68	#ifdef HARDWARE_SHADOWS
69	    #define SHADOWMAP sampler2DShadow
70	    #define SHADOWCOMPAREOFFSET(tex,coord,offset) textureProjOffset(tex, coord, offset)
71	    #define SHADOWCOMPARE(tex,coord) textureProj(tex, coord)
72	    #define SHADOWGATHER(tex,coord) textureGather(tex, coord.xy, coord.z)
73	#else
74	    #define SHADOWMAP sampler2D
75	    #define SHADOWCOMPAREOFFSET(tex,coord,offset) step(coord.z, textureProjOffset(tex, coord, offset).r)
76	    #define SHADOWCOMPARE(tex,coord) step(coord.z, textureProj(tex, coord).r)
77	    #define SHADOWGATHER(tex,coord) step(coord.z, textureGather(tex, coord.xy))
78	#endif
79
80
81	#if FILTER_MODE == 0
82	    #define GETSHADOW SHADOWCOMPARE
83	    #define KERNEL 1
84	#elif FILTER_MODE == 1
85	    #ifdef HARDWARE_SHADOWS
86	        #define GETSHADOW SHADOWCOMPARE
87	    #else
88	        #define GETSHADOW Shadow_DoBilinear_2x2
89	    #endif
90	    #define KERNEL 1
91	#elif FILTER_MODE == 2
92	    #define GETSHADOW Shadow_DoDither_2x2
93	    #define KERNEL 1
94	#elif FILTER_MODE == 3
95	    #define GETSHADOW Shadow_DoPCF
96	    #define KERNEL 4
97	#elif FILTER_MODE == 4
98	    #define GETSHADOW Shadow_DoPCFPoisson
99	    #define KERNEL 4
100	#elif FILTER_MODE == 5
101	    #define GETSHADOW Shadow_DoPCF
102	    #define KERNEL 8
103	#endif
104
105
106
107	uniform SHADOWMAP m_ShadowMap0;
108	uniform SHADOWMAP m_ShadowMap1;
109	uniform SHADOWMAP m_ShadowMap2;
110	uniform SHADOWMAP m_ShadowMap3;
111
112	uniform vec4 m_Splits;
113	uniform float m_ShadowIntensity;
114
115	const vec2 pixSize2 = vec2(1.0 / SHADOWMAP_SIZE);
116	float shadowBorderScale = 1.0;
117
118	float Shadow_BorderCheck(in vec2 coord){
119	    // Fastest, "hack" method (uses 4-5 instructions)
120	    vec4 t = vec4(coord.xy, 0.0, 1.0);
121	    t = step(t.wwxy, t.xyzz);
122	    return dot(t,t);
123	}
124
125	float Shadow_DoDither_2x2(in SHADOWMAP tex, in vec4 projCoord){
126	    float border = Shadow_BorderCheck(projCoord.xy);
127	    if (border > 0.0)
128	        return 1.0;
129
130	    vec2 pixSize = pixSize2 * shadowBorderScale;
131
132	    float shadow = 0.0;
133	    ivec2 o = ivec2(mod(floor(gl_FragCoord.xy), 2.0));
134	    shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy+pixSize*(vec2(-1.5, 1.5)+o), projCoord.zw));
135	    shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy+pixSize*(vec2( 0.5, 1.5)+o), projCoord.zw));
136	    shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy+pixSize*(vec2(-1.5, -0.5)+o), projCoord.zw));
137	    shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy+pixSize*(vec2( 0.5, -0.5)+o), projCoord.zw));
138	    shadow *= 0.25;
139	    return shadow;
140	}
141
142	float Shadow_DoBilinear_2x2(in SHADOWMAP tex, in vec4 projCoord){
143	    float border = Shadow_BorderCheck(projCoord.xy);
144	    if (border > 0.0)
145	        return 1.0;
146
147	    #ifdef GL_ARB_gpu_shader5
148	        vec4 coord = vec4(projCoord.xyz / projCoord.www,0.0);
149	        vec4 gather = SHADOWGATHER(tex, coord);
150	    #else
151	        vec4 gather = vec4(0.0);
152	        gather.x = SHADOWCOMPAREOFFSET(tex, projCoord, ivec2(0, 0));
153	        gather.y = SHADOWCOMPAREOFFSET(tex, projCoord, ivec2(1, 0));
154	        gather.z = SHADOWCOMPAREOFFSET(tex, projCoord, ivec2(0, 1));
155	        gather.w = SHADOWCOMPAREOFFSET(tex, projCoord, ivec2(1, 1));
156	   #endif
157
158	   vec2 f = fract( projCoord.xy * SHADOWMAP_SIZE );
159	   vec2 mx = mix( gather.xz, gather.yw, f.x );
160	   return mix( mx.x, mx.y, f.y );
161	}
162
163	float Shadow_DoPCF(in SHADOWMAP tex, in vec4 projCoord){
164
165	    vec2 pixSize = pixSize2 * shadowBorderScale;
166	    float shadow = 0.0;
167	    float border = Shadow_BorderCheck(projCoord.xy);
168	    if (border > 0.0)
169	        return 1.0;
170
171	    float bound = KERNEL * 0.5 - 0.5;
172	    bound *= PCFEDGE;
173	    for (float y = -bound; y <= bound; y += PCFEDGE){
174	        for (float x = -bound; x <= bound; x += PCFEDGE){
175	            vec4 coord = vec4(projCoord.xy + vec2(x,y) * pixSize, projCoord.zw);
176	            shadow += SHADOWCOMPARE(tex, coord);
177	        }
178	    }
179
180	    shadow = shadow / (KERNEL * KERNEL);
181	    return shadow;
182	}
183
184
185	//12 tap poisson disk
186	    const vec2 poissonDisk0 =  vec2(-0.1711046, -0.425016);
187	    const vec2 poissonDisk1 =  vec2(-0.7829809, 0.2162201);
188	    const vec2 poissonDisk2 =  vec2(-0.2380269, -0.8835521);
189	    const vec2 poissonDisk3 =  vec2(0.4198045, 0.1687819);
190	    const vec2 poissonDisk4 =  vec2(-0.684418, -0.3186957);
191	    const vec2 poissonDisk5 =  vec2(0.6026866, -0.2587841);
192	    const vec2 poissonDisk6 =  vec2(-0.2412762, 0.3913516);
193	    const vec2 poissonDisk7 =  vec2(0.4720655, -0.7664126);
194	    const vec2 poissonDisk8 =  vec2(0.9571564, 0.2680693);
195	    const vec2 poissonDisk9 =  vec2(-0.5238616, 0.802707);
196	    const vec2 poissonDisk10 = vec2(0.5653144, 0.60262);
197	    const vec2 poissonDisk11 = vec2(0.0123658, 0.8627419);
198
199
200	float Shadow_DoPCFPoisson(in SHADOWMAP tex, in vec4 projCoord){
201
202	    float shadow = 0.0;
203	    float border = Shadow_BorderCheck(projCoord.xy);
204	    if (border > 0.0){
205	        return 1.0;
206	    }
207
208	    vec2 texelSize = pixSize2 * 4.0 * PCFEDGE * shadowBorderScale;
209
210	    shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk0 * texelSize, projCoord.zw));
211	    shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk1 * texelSize, projCoord.zw));
212	    shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk2 * texelSize, projCoord.zw));
213	    shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk3 * texelSize, projCoord.zw));
214	    shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk4 * texelSize, projCoord.zw));
215	    shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk5 * texelSize, projCoord.zw));
216	    shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk6 * texelSize, projCoord.zw));
217	    shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk7 * texelSize, projCoord.zw));
218	    shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk8 * texelSize, projCoord.zw));
219	    shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk9 * texelSize, projCoord.zw));
220	    shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk10 * texelSize, projCoord.zw));
221	    shadow += SHADOWCOMPARE(tex, vec4(projCoord.xy + poissonDisk11 * texelSize, projCoord.zw));
222
223	    //this is divided by 12
224	    return shadow * 0.08333333333;
225	}
226
227
228
229
230	uniform COLORTEXTURE m_Texture;
231	uniform DEPTHTEXTURE m_DepthTexture;
232	uniform mat4 m_ViewProjectionMatrixInverse;
233	uniform vec4 m_ViewProjectionMatrixRow2;
234
235	in vec2 texCoord;
236	out vec4 outFragColor;
237
238	const mat4 biasMat = mat4(0.5, 0.0, 0.0, 0.0,
239	                          0.0, 0.5, 0.0, 0.0,
240	                          0.0, 0.0, 0.5, 0.0,
241	                          0.5, 0.5, 0.5, 1.0);
242
243	uniform mat4 m_LightViewProjectionMatrix0;
244	uniform mat4 m_LightViewProjectionMatrix1;
245	uniform mat4 m_LightViewProjectionMatrix2;
246	uniform mat4 m_LightViewProjectionMatrix3;
247
248
249	vec3 getPosition(in float depth, in vec2 uv){
250	    vec4 pos = vec4(uv, depth, 1.0) * 2.0 - 1.0;
251	    pos = m_ViewProjectionMatrixInverse * pos;
252	    return pos.xyz / pos.w;
253	}
254
255	vec4 main_multiSample(in int numSample){
256	    float depth = fetchTextureSample(m_DepthTexture,texCoord,numSample).r;//getDepth(m_DepthTexture,texCoord).r;
257	    vec4 color = fetchTextureSample(m_Texture,texCoord,numSample);
258
259	    //Discard shadow computation on the sky
260	    if(depth == 1.0){
261	        return color;
262	    }
263
264	    // get the vertex in world space
265	    vec4 worldPos = vec4(getPosition(depth,texCoord),1.0);
266
267	    // populate the light view matrices array and convert vertex to light viewProj space
268	    vec4 projCoord0 = biasMat * m_LightViewProjectionMatrix0 * worldPos;
269	    vec4 projCoord1 = biasMat * m_LightViewProjectionMatrix1 * worldPos;
270	    vec4 projCoord2 = biasMat * m_LightViewProjectionMatrix2 * worldPos;
271	    vec4 projCoord3 = biasMat * m_LightViewProjectionMatrix3 * worldPos;
272
273	    float shadowPosition = m_ViewProjectionMatrixRow2.x * worldPos.x +  m_ViewProjectionMatrixRow2.y * worldPos.y +  m_ViewProjectionMatrixRow2.z * worldPos.z +  m_ViewProjectionMatrixRow2.w;
274
275	float shadow = 0.0;
276	    if(shadowPosition < m_Splits.x){
277	        shadow = GETSHADOW(m_ShadowMap0, projCoord0);
278	    }else if( shadowPosition <  m_Splits.y){
279	        shadowBorderScale = 0.5;
280	        shadow = GETSHADOW(m_ShadowMap1, projCoord1);
281	    }else if( shadowPosition <  m_Splits.z){
282	        shadowBorderScale = 0.25;
283	        shadow = GETSHADOW(m_ShadowMap2, projCoord2);
284	    }else if( shadowPosition <  m_Splits.w){
285	        shadowBorderScale = 0.125;
286	        shadow = GETSHADOW(m_ShadowMap3, projCoord3);
287	    }
288
289	    shadow= shadow * m_ShadowIntensity + (1.0 - m_ShadowIntensity);
290
291	    return color * vec4(shadow, shadow, shadow, 1.0);
292	}
293
294	void main(){
295
296	    #ifdef RESOLVE_MS
297	        vec4 color = vec4(0.0);
298	        for (int i = 0; i < m_NumSamples; i++){
299	            color += main_multiSample(i);
300	        }
301	        outFragColor = color / m_NumSamples;
302	    #else
303	        outFragColor = main_multiSample(0);
304	    #endif
305
306	}