Hi,
I get the following error on my craptop
17:30:31.668 [LWJGL Renderer Thread] ERROR d.v.jme.RendererApplication - Error loading {}
com.jme3.renderer.RendererException: compile error in:ShaderSource[name=Common/MatDefs/Shadow/PostShadowFilter.frag, defines, type=Fragment, language=GLSL100] error:0:296(15): error: could not implicitly convert operands to relational operator
0:296(15): error: if-statement condition must be scalar booleanThe offending line is:
if( dot(m_LightDir,lightDir)<0){
If i understand right the mesa driver has a point here, correctly it should be 0.0 as there is a implicit cast from 0(int) to 0.0(float)
Aug 17, 2014 5:30:31 PM com.jme3.renderer.lwjgl.LwjglRenderer updateShaderSourceData
WARNING: Bad compile of:
1 #define FILTER_MODE 1
2 #define HARDWARE_SHADOWS 1
3 #define PCFEDGE 1.0
4 #define SHADOWMAP_SIZE 2048.0
5 #ifdef HARDWARE_SHADOWS
6 #define SHADOWMAP sampler2DShadow
7 #define SHADOWCOMPARE(tex,coord) shadow2DProj(tex, coord).r
8 #else
9 #define SHADOWMAP sampler2D
10 #define SHADOWCOMPARE(tex,coord) step(coord.z, texture2DProj(tex, coord).r)
11 #endif
12
13 #if FILTER_MODE == 0
14 #define GETSHADOW Shadow_DoShadowCompare
15 #define KERNEL 1.0
16 #elif FILTER_MODE == 1
17 #ifdef HARDWARE_SHADOWS
18 #define GETSHADOW Shadow_DoShadowCompare
19 #else
20 #define GETSHADOW Shadow_DoBilinear_2x2
21 #endif
22 #define KERNEL 1.0
23 #elif FILTER_MODE == 2
24 #define GETSHADOW Shadow_DoDither_2x2
25 #define KERNEL 1.0
26 #elif FILTER_MODE == 3
27 #define GETSHADOW Shadow_DoPCF
28 #define KERNEL 4.0
29 #elif FILTER_MODE == 4
30 #define GETSHADOW Shadow_DoPCFPoisson
31 #define KERNEL 4.0
32 #elif FILTER_MODE == 5
33 #define GETSHADOW Shadow_DoPCF
34 #define KERNEL 8.0
35 #endif
36
37
38 uniform SHADOWMAP m_ShadowMap0;
39 uniform SHADOWMAP m_ShadowMap1;
40 uniform SHADOWMAP m_ShadowMap2;
41 uniform SHADOWMAP m_ShadowMap3;
42 #ifdef POINTLIGHT
43 uniform SHADOWMAP m_ShadowMap4;
44 uniform SHADOWMAP m_ShadowMap5;
45 #endif
46
47 #ifdef PSSM
48 uniform vec4 m_Splits;
49 #endif
50
51 uniform float m_ShadowIntensity;
52
53 const vec2 pixSize2 = vec2(1.0 / SHADOWMAP_SIZE);
54 float shadowBorderScale = 1.0;
55
56 float Shadow_DoShadowCompareOffset(SHADOWMAP tex, vec4 projCoord, vec2 offset){
57 vec4 coord = vec4(projCoord.xy + offset.xy * pixSize2 * shadowBorderScale, projCoord.zw);
58 return SHADOWCOMPARE(tex, coord);
59 }
60
61 float Shadow_DoShadowCompare(SHADOWMAP tex, vec4 projCoord){
62 return SHADOWCOMPARE(tex, projCoord);
63 }
64
65 float Shadow_BorderCheck(vec2 coord){
66 // Fastest, "hack" method (uses 4-5 instructions)
67 vec4 t = vec4(coord.xy, 0.0, 1.0);
68 t = step(t.wwxy, t.xyzz);
69 return dot(t,t);
70 }
71
72 float Shadow_Nearest(SHADOWMAP tex, vec4 projCoord){
73 float border = Shadow_BorderCheck(projCoord.xy);
74 if (border > 0.0){
75 return 1.0;
76 }
77 return Shadow_DoShadowCompare(tex,projCoord);
78 }
79
80 float Shadow_DoDither_2x2(SHADOWMAP tex, vec4 projCoord){
81 float border = Shadow_BorderCheck(projCoord.xy);
82 if (border > 0.0)
83 return 1.0;
84
85
86 float shadow = 0.0;
87 vec2 o = mod(floor(gl_FragCoord.xy), 2.0);
88 shadow += Shadow_DoShadowCompareOffset(tex,projCoord,vec2(-1.5, 1.5) + o);
89 shadow += Shadow_DoShadowCompareOffset(tex,projCoord,vec2( 0.5, 1.5) + o);
90 shadow += Shadow_DoShadowCompareOffset(tex,projCoord,vec2(-1.5, -0.5) + o);
91 shadow += Shadow_DoShadowCompareOffset(tex,projCoord,vec2( 0.5, -0.5) + o);
92 shadow *= 0.25 ;
93 return shadow;
94 }
95
96 float Shadow_DoBilinear_2x2(SHADOWMAP tex, vec4 projCoord){
97 float border = Shadow_BorderCheck(projCoord.xy);
98 if (border > 0.0)
99 return 1.0;
100 vec4 gather = vec4(0.0);
101 gather.x = Shadow_DoShadowCompareOffset(tex, projCoord, vec2(0.0, 0.0));
102 gather.y = Shadow_DoShadowCompareOffset(tex, projCoord, vec2(1.0, 0.0));
103 gather.z = Shadow_DoShadowCompareOffset(tex, projCoord, vec2(0.0, 1.0));
104 gather.w = Shadow_DoShadowCompareOffset(tex, projCoord, vec2(1.0, 1.0));
105
106 vec2 f = fract( projCoord.xy * SHADOWMAP_SIZE );
107 vec2 mx = mix( gather.xz, gather.yw, f.x );
108 return mix( mx.x, mx.y, f.y );
109 }
110
111 float Shadow_DoPCF(SHADOWMAP tex, vec4 projCoord){
112 float shadow = 0.0;
113 float border = Shadow_BorderCheck(projCoord.xy);
114 if (border > 0.0)
115 return 1.0;
116 float bound = KERNEL * 0.5 - 0.5;
117 bound *= PCFEDGE;
118 for (float y = -bound; y <= bound; y += PCFEDGE){
119 for (float x = -bound; x <= bound; x += PCFEDGE){
120 shadow += clamp(Shadow_DoShadowCompareOffset(tex,projCoord,vec2(x,y)) +
121 border,
122 0.0, 1.0);
123 }
124 }
125
126 shadow = shadow / (KERNEL * KERNEL);
127 return shadow;
128 }
129
130
131 //12 tap poisson disk
132 const vec2 poissonDisk0 = vec2(-0.1711046, -0.425016);
133 const vec2 poissonDisk1 = vec2(-0.7829809, 0.2162201);
134 const vec2 poissonDisk2 = vec2(-0.2380269, -0.8835521);
135 const vec2 poissonDisk3 = vec2(0.4198045, 0.1687819);
136 const vec2 poissonDisk4 = vec2(-0.684418, -0.3186957);
137 const vec2 poissonDisk5 = vec2(0.6026866, -0.2587841);
138 const vec2 poissonDisk6 = vec2(-0.2412762, 0.3913516);
139 const vec2 poissonDisk7 = vec2(0.4720655, -0.7664126);
140 const vec2 poissonDisk8 = vec2(0.9571564, 0.2680693);
141 const vec2 poissonDisk9 = vec2(-0.5238616, 0.802707);
142 const vec2 poissonDisk10 = vec2(0.5653144, 0.60262);
143 const vec2 poissonDisk11 = vec2(0.0123658, 0.8627419);
144
145 float Shadow_DoPCFPoisson(SHADOWMAP tex, vec4 projCoord){
146 float shadow = 0.0;
147 float border = Shadow_BorderCheck(projCoord.xy);
148 if (border > 0.0)
149 return 1.0;
150
151 vec2 texelSize = vec2( 4.0 * PCFEDGE * shadowBorderScale);
152
153 shadow += Shadow_DoShadowCompareOffset(tex, projCoord , poissonDisk0 * texelSize);
154 shadow += Shadow_DoShadowCompareOffset(tex, projCoord , poissonDisk1 * texelSize);
155 shadow += Shadow_DoShadowCompareOffset(tex, projCoord , poissonDisk2 * texelSize);
156 shadow += Shadow_DoShadowCompareOffset(tex, projCoord , poissonDisk3 * texelSize);
157 shadow += Shadow_DoShadowCompareOffset(tex, projCoord , poissonDisk4 * texelSize);
158 shadow += Shadow_DoShadowCompareOffset(tex, projCoord , poissonDisk5 * texelSize);
159 shadow += Shadow_DoShadowCompareOffset(tex, projCoord , poissonDisk6 * texelSize);
160 shadow += Shadow_DoShadowCompareOffset(tex, projCoord , poissonDisk7 * texelSize);
161 shadow += Shadow_DoShadowCompareOffset(tex, projCoord , poissonDisk8 * texelSize);
162 shadow += Shadow_DoShadowCompareOffset(tex, projCoord , poissonDisk9 * texelSize);
163 shadow += Shadow_DoShadowCompareOffset(tex, projCoord , poissonDisk10 * texelSize);
164 shadow += Shadow_DoShadowCompareOffset(tex, projCoord , poissonDisk11 * texelSize);
165
166 shadow = shadow * 0.08333333333;//this is divided by 12
167 return shadow;
168 }
169
170
171 #ifdef POINTLIGHT
172 float getPointLightShadows(vec4 worldPos,vec3 lightPos,
173 SHADOWMAP shadowMap0,SHADOWMAP shadowMap1,SHADOWMAP shadowMap2,SHADOWMAP shadowMap3,SHADOWMAP shadowMap4,SHADOWMAP shadowMap5,
174 vec4 projCoord0,vec4 projCoord1,vec4 projCoord2,vec4 projCoord3,vec4 projCoord4,vec4 projCoord5){
175 float shadow = 1.0;
176 vec3 vect = worldPos.xyz - lightPos;
177 vec3 absv= abs(vect);
178 float maxComp = max(absv.x,max(absv.y,absv.z));
179 if(maxComp == absv.y){
180 if(vect.y < 0.0){
181 shadow = GETSHADOW(shadowMap0, projCoord0 / projCoord0.w);
182 }else{
183 shadow = GETSHADOW(shadowMap1, projCoord1 / projCoord1.w);
184 }
185 }else if(maxComp == absv.z){
186 if(vect.z < 0.0){
187 shadow = GETSHADOW(shadowMap2, projCoord2 / projCoord2.w);
188 }else{
189 shadow = GETSHADOW(shadowMap3, projCoord3 / projCoord3.w);
190 }
191 }else if(maxComp == absv.x){
192 if(vect.x < 0.0){
193 shadow = GETSHADOW(shadowMap4, projCoord4 / projCoord4.w);
194 }else{
195 shadow = GETSHADOW(shadowMap5, projCoord5 / projCoord5.w);
196 }
197 }
198 return shadow;
199 }
200 #else
201 #ifdef PSSM
202 float getDirectionalLightShadows(vec4 splits,float shadowPosition,
203 SHADOWMAP shadowMap0,SHADOWMAP shadowMap1,SHADOWMAP shadowMap2,SHADOWMAP shadowMap3,
204 vec4 projCoord0,vec4 projCoord1,vec4 projCoord2,vec4 projCoord3){
205 float shadow = 1.0;
206 if(shadowPosition < splits.x){
207 shadow = GETSHADOW(shadowMap0, projCoord0 );
208 }else if( shadowPosition < splits.y){
209 shadowBorderScale = 0.5;
210 shadow = GETSHADOW(shadowMap1, projCoord1);
211 }else if( shadowPosition < splits.z){
212 shadowBorderScale = 0.25;
213 shadow = GETSHADOW(shadowMap2, projCoord2);
214 }else if( shadowPosition < splits.w){
215 shadowBorderScale = 0.125;
216 shadow = GETSHADOW(shadowMap3, projCoord3);
217 }
218 return shadow;
219 }
220 #else
221 float getSpotLightShadows(SHADOWMAP shadowMap, vec4 projCoord){
222 float shadow = 1.0;
223 projCoord /= projCoord.w;
224 shadow = GETSHADOW(shadowMap, projCoord);
225
226 //a small falloff to make the shadow blend nicely into the not lighten
227 //we translate the texture coordinate value to a -1,1 range so the length
228 //of the texture coordinate vector is actually the radius of the lighten area on the ground
229 projCoord = projCoord * 2.0 - 1.0;
230 float fallOff = ( length(projCoord.xy) - 0.9 ) / 0.1;
231 return mix(shadow,1.0,clamp(fallOff,0.0,1.0));
232
233 }
234 #endif
235 #endif
236
237 uniform sampler2D m_Texture;
238 uniform sampler2D m_DepthTexture;
239 uniform mat4 m_ViewProjectionMatrixInverse;
240 uniform vec4 m_ViewProjectionMatrixRow2;
241
242 varying vec2 texCoord;
243
244
245 const mat4 biasMat = mat4(0.5, 0.0, 0.0, 0.0,
246 0.0, 0.5, 0.0, 0.0,
247 0.0, 0.0, 0.5, 0.0,
248 0.5, 0.5, 0.5, 1.0);
249
250 uniform mat4 m_LightViewProjectionMatrix0;
251 uniform mat4 m_LightViewProjectionMatrix1;
252 uniform mat4 m_LightViewProjectionMatrix2;
253 uniform mat4 m_LightViewProjectionMatrix3;
254
255 #ifdef POINTLIGHT
256 uniform vec3 m_LightPos;
257 uniform mat4 m_LightViewProjectionMatrix4;
258 uniform mat4 m_LightViewProjectionMatrix5;
259 #else
260 #ifndef PSSM
261 uniform vec3 m_LightPos;
262 uniform vec3 m_LightDir;
263 #endif
264 #endif
265
266 #ifdef FADE
267 uniform vec2 m_FadeInfo;
268 #endif
269
270 vec3 getPosition(in float depth, in vec2 uv){
271 vec4 pos = vec4(uv, depth, 1.0) * 2.0 - 1.0;
272 pos = m_ViewProjectionMatrixInverse * pos;
273 return pos.xyz / pos.w;
274 }
275
276 void main(){
277 #if !defined( RENDER_SHADOWS )
278 gl_FragColor = texture2D(m_Texture,texCoord);
279 return;
280 #endif
281
282 float depth = texture2D(m_DepthTexture,texCoord).r;
283 vec4 color = texture2D(m_Texture,texCoord);
284
285 //Discard shadow computation on the sky
286 if(depth == 1.0){
287 gl_FragColor = color;
288 return;
289 }
290
291 // get the vertex in world space
292 vec4 worldPos = vec4(getPosition(depth,texCoord),1.0);
293
294 #if (!defined(POINTLIGHT) && !defined(PSSM))
295 vec3 lightDir = worldPos.xyz - m_LightPos;
296 if( dot(m_LightDir,lightDir)<0){
297 gl_FragColor = color;
298 return;
299 }
300 #endif
301
302 // populate the light view matrices array and convert vertex to light viewProj space
303 vec4 projCoord0 = biasMat * m_LightViewProjectionMatrix0 * worldPos;
304 vec4 projCoord1 = biasMat * m_LightViewProjectionMatrix1 * worldPos;
305 vec4 projCoord2 = biasMat * m_LightViewProjectionMatrix2 * worldPos;
306 vec4 projCoord3 = biasMat * m_LightViewProjectionMatrix3 * worldPos;
307 #ifdef POINTLIGHT
308 vec4 projCoord4 = biasMat * m_LightViewProjectionMatrix4 * worldPos;
309 vec4 projCoord5 = biasMat * m_LightViewProjectionMatrix5 * worldPos;
310 #endif
311
312 float shadow = 1.0;
313
314 #ifdef POINTLIGHT
315 shadow = getPointLightShadows(worldPos, m_LightPos,
316 m_ShadowMap0,m_ShadowMap1,m_ShadowMap2,m_ShadowMap3,m_ShadowMap4,m_ShadowMap5,
317 projCoord0, projCoord1, projCoord2, projCoord3, projCoord4, projCoord5);
318 #else
319 #ifdef PSSM
320 float shadowPosition = m_ViewProjectionMatrixRow2.x * worldPos.x + m_ViewProjectionMatrixRow2.y * worldPos.y + m_ViewProjectionMatrixRow2.z * worldPos.z + m_ViewProjectionMatrixRow2.w;
321 shadow = getDirectionalLightShadows(m_Splits, shadowPosition,
322 m_ShadowMap0,m_ShadowMap1,m_ShadowMap2,m_ShadowMap3,
323 projCoord0, projCoord1, projCoord2, projCoord3);
324 #else
325 //spotlight
326 shadow = getSpotLightShadows(m_ShadowMap0,projCoord0);
327 #endif
328 #endif
329
330 #ifdef FADE
331 shadow = max(0.0,mix(shadow,1.0,(shadowPosition - m_FadeInfo.x) * m_FadeInfo.y));
332 #endif
333 shadow= shadow * m_ShadowIntensity + (1.0 - m_ShadowIntensity);
334 gl_FragColor = color * vec4(shadow, shadow, shadow, 1.0);
335
336 }