THREE.js Shader Extension Errors

Question

My application works fine on pretty much every machine I've tried, however one of my users are reporting the following console errors in google chrome (works fine in firefox). The app is only partially loading for him.

THREE.WebGLRenderer 58 Three58.js:18430
THREE.WebGLRenderer: Float textures not supported. Three58.js:25713
THREE.WebGLRenderer: Standard derivatives not supported. Three58.js:25719

I have never seen this before. I am not using any custom shaders, only the ones provided by three.js. I cannot easilly debug this since I cannot reproduce the issue.

Any ideas?

EDIT

Ok so I set overwrote those lines with:

_glExtensionTextureFloat = null;
_glExtensionStandardDerivatives = null;

I was hoping this would allow me to debug the situation. Wrong. Even with those set to null, I can load my app no problem on my machine in chrome. After looking further into three.js code i saw this on line 24836:

( parameters.bumpMap || parameters.normalMap ) ? "#extension GL_OES_standard_derivatives : enable" : "",

Which I did see in my users error log. I don't use bumpMaps, however I do use normalMaps. How could normalMaps be an issue on such a new machine/videocard? I mean they work fine on my crappy 5 year old laptop. Here is the remainder of the console error log he provided:

WARNING: 0:2: 'GL_OES_standard_derivatives' : extension is not supported
ERROR: 0:150: 'dFdx' : no matching overloaded function found 
ERROR: 0:150: '=' :  cannot convert from 'const mediump float' to '3-component vector of float'
ERROR: 0:151: 'dFdy' : no matching overloaded function found 
ERROR: 0:151: '=' :  cannot convert from 'const mediump float' to '3-component vector of float'
ERROR: 0:152: 'dFdx' : no matching overloaded function found 
ERROR: 0:152: '=' :  cannot convert from 'const mediump float' to '2-component vector of float'
ERROR: 0:153: 'dFdy' : no matching overloaded function found 
ERROR: 0:153: '=' :  cannot convert from 'const mediump float' to '2-component vector of float'
 Three58.js:25038
1: precision highp float;
2: #extension GL_OES_standard_derivatives : enable
3: 
4: #define MAX_DIR_LIGHTS 1
5: #define MAX_POINT_LIGHTS 1
6: #define MAX_SPOT_LIGHTS 0
7: #define MAX_HEMI_LIGHTS 0
8: #define MAX_SHADOWS 1
9: #define ALPHATEST 0.5
10: 
11: 
12: 
13: #define USE_FOG
14: #define FOG_EXP2
15: #define USE_MAP
16: 
17: 
18: 
19: #define USE_NORMALMAP
20: 
21: 
22: 
23: #define PHONG_PER_PIXEL
24: 
25: 
26: 
27: #define USE_SHADOWMAP
28: #define SHADOWMAP_TYPE_PCF
29: 
30: 
31: uniform mat4 viewMatrix;
32: uniform vec3 cameraPosition;
33: uniform vec3 diffuse;
34: uniform float opacity;
35: uniform vec3 ambient;
36: uniform vec3 emissive;
37: uniform vec3 specular;
38: uniform float shininess;
39: #ifdef USE_COLOR
40: varying vec3 vColor;
41: #endif
42: #if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP )
43: varying vec2 vUv;
44: #endif
45: #ifdef USE_MAP
46: uniform sampler2D map;
47: #endif
48: #ifdef USE_LIGHTMAP
49: varying vec2 vUv2;
50: uniform sampler2D lightMap;
51: #endif
52: #ifdef USE_ENVMAP
53: uniform float reflectivity;
54: uniform samplerCube envMap;
55: uniform float flipEnvMap;
56: uniform int combine;
57: #if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP )
58: uniform bool useRefract;
59: uniform float refractionRatio;
60: #else
61: varying vec3 vReflect;
62: #endif
63: #endif
64: #ifdef USE_FOG
65: uniform vec3 fogColor;
66: #ifdef FOG_EXP2
67: uniform float fogDensity;
68: #else
69: uniform float fogNear;
70: uniform float fogFar;
71: #endif
72: #endif
73: uniform vec3 ambientLightColor;
74: #if MAX_DIR_LIGHTS > 0
75: uniform vec3 directionalLightColor[ MAX_DIR_LIGHTS ];
76: uniform vec3 directionalLightDirection[ MAX_DIR_LIGHTS ];
77: #endif
78: #if MAX_HEMI_LIGHTS > 0
79: uniform vec3 hemisphereLightSkyColor[ MAX_HEMI_LIGHTS ];
80: uniform vec3 hemisphereLightGroundColor[ MAX_HEMI_LIGHTS ];
81: uniform vec3 hemisphereLightDirection[ MAX_HEMI_LIGHTS ];
82: #endif
83: #if MAX_POINT_LIGHTS > 0
84: uniform vec3 pointLightColor[ MAX_POINT_LIGHTS ];
85: #ifdef PHONG_PER_PIXEL
86: uniform vec3 pointLightPosition[ MAX_POINT_LIGHTS ];
87: uniform float pointLightDistance[ MAX_POINT_LIGHTS ];
88: #else
89: varying vec4 vPointLight[ MAX_POINT_LIGHTS ];
90: #endif
91: #endif
92: #if MAX_SPOT_LIGHTS > 0
93: uniform vec3 spotLightColor[ MAX_SPOT_LIGHTS ];
94: uniform vec3 spotLightPosition[ MAX_SPOT_LIGHTS ];
95: uniform vec3 spotLightDirection[ MAX_SPOT_LIGHTS ];
96: uniform float spotLightAngleCos[ MAX_SPOT_LIGHTS ];
97: uniform float spotLightExponent[ MAX_SPOT_LIGHTS ];
98: #ifdef PHONG_PER_PIXEL
99: uniform float spotLightDistance[ MAX_SPOT_LIGHTS ];
100: #else
101: varying vec4 vSpotLight[ MAX_SPOT_LIGHTS ];
102: #endif
103: #endif
104: #if MAX_SPOT_LIGHTS > 0 || defined( USE_BUMPMAP )
105: varying vec3 vWorldPosition;
106: #endif
107: #ifdef WRAP_AROUND
108: uniform vec3 wrapRGB;
109: #endif
110: varying vec3 vViewPosition;
111: varying vec3 vNormal;
112: #ifdef USE_SHADOWMAP
113: uniform sampler2D shadowMap[ MAX_SHADOWS ];
114: uniform vec2 shadowMapSize[ MAX_SHADOWS ];
115: uniform float shadowDarkness[ MAX_SHADOWS ];
116: uniform float shadowBias[ MAX_SHADOWS ];
117: varying vec4 vShadowCoord[ MAX_SHADOWS ];
118: float unpackDepth( const in vec4 rgba_depth ) {
119: const vec4 bit_shift = vec4( 1.0 / ( 256.0 * 256.0 * 256.0 ), 1.0 / ( 256.0 * 256.0 ), 1.0 / 256.0, 1.0 );
120: float depth = dot( rgba_depth, bit_shift );
121: return depth;
122: }
123: #endif
124: #ifdef USE_BUMPMAP
125: uniform sampler2D bumpMap;
126: uniform float bumpScale;
127: vec2 dHdxy_fwd() {
128: vec2 dSTdx = dFdx( vUv );
129: vec2 dSTdy = dFdy( vUv );
130: float Hll = bumpScale * texture2D( bumpMap, vUv ).x;
131: float dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;
132: float dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;
133: return vec2( dBx, dBy );
134: }
135: vec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy ) {
136: vec3 vSigmaX = dFdx( surf_pos );
137: vec3 vSigmaY = dFdy( surf_pos );
138: vec3 vN = surf_norm;
139: vec3 R1 = cross( vSigmaY, vN );
140: vec3 R2 = cross( vN, vSigmaX );
141: float fDet = dot( vSigmaX, R1 );
142: vec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );
143: return normalize( abs( fDet ) * surf_norm - vGrad );
144: }
145: #endif
146: #ifdef USE_NORMALMAP
147: uniform sampler2D normalMap;
148: uniform vec2 normalScale;
149: vec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm ) {
150: vec3 q0 = dFdx( eye_pos.xyz );
151: vec3 q1 = dFdy( eye_pos.xyz );
152: vec2 st0 = dFdx( vUv.st );
153: vec2 st1 = dFdy( vUv.st );
154: vec3 S = normalize(  q0 * st1.t - q1 * st0.t );
155: vec3 T = normalize( -q0 * st1.s + q1 * st0.s );
156: vec3 N = normalize( surf_norm );
157: vec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;
158: mapN.xy = normalScale * mapN.xy;
159: mat3 tsn = mat3( S, T, N );
160: return normalize( tsn * mapN );
161: }
162: #endif
163: #ifdef USE_SPECULARMAP
164: uniform sampler2D specularMap;
165: #endif
166: void main() {
167: gl_FragColor = vec4( vec3 ( 1.0 ), opacity );
168: #ifdef USE_MAP
169: vec4 texelColor = texture2D( map, vUv );
170: #ifdef GAMMA_INPUT
171: texelColor.xyz *= texelColor.xyz;
172: #endif
173: gl_FragColor = gl_FragColor * texelColor;
174: #endif
175: #ifdef ALPHATEST
176: if ( gl_FragColor.a < ALPHATEST ) discard;
177: #endif
178: float specularStrength;
179: #ifdef USE_SPECULARMAP
180: vec4 texelSpecular = texture2D( specularMap, vUv );
181: specularStrength = texelSpecular.r;
182: #else
183: specularStrength = 1.0;
184: #endif
185: vec3 normal = normalize( vNormal );
186: vec3 viewPosition = normalize( vViewPosition );
187: #ifdef DOUBLE_SIDED
188: normal = normal * ( -1.0 + 2.0 * float( gl_FrontFacing ) );
189: #endif
190: #ifdef USE_NORMALMAP
191: normal = perturbNormal2Arb( -vViewPosition, normal );
192: #elif defined( USE_BUMPMAP )
193: normal = perturbNormalArb( -vViewPosition, normal, dHdxy_fwd() );
194: #endif
195: #if MAX_POINT_LIGHTS > 0
196: vec3 pointDiffuse  = vec3( 0.0 );
197: vec3 pointSpecular = vec3( 0.0 );
198: for ( int i = 0; i < MAX_POINT_LIGHTS; i ++ ) {
199: #ifdef PHONG_PER_PIXEL
200: vec4 lPosition = viewMatrix * vec4( pointLightPosition[ i ], 1.0 );
201: vec3 lVector = lPosition.xyz + vViewPosition.xyz;
202: float lDistance = 1.0;
203: if ( pointLightDistance[ i ] > 0.0 )
204: lDistance = 1.0 - min( ( length( lVector ) / pointLightDistance[ i ] ), 1.0 );
205: lVector = normalize( lVector );
206: #else
207: vec3 lVector = normalize( vPointLight[ i ].xyz );
208: float lDistance = vPointLight[ i ].w;
209: #endif
210: float dotProduct = dot( normal, lVector );
211: #ifdef WRAP_AROUND
212: float pointDiffuseWeightFull = max( dotProduct, 0.0 );
213: float pointDiffuseWeightHalf = max( 0.5 * dotProduct + 0.5, 0.0 );
214: vec3 pointDiffuseWeight = mix( vec3 ( pointDiffuseWeightFull ), vec3( pointDiffuseWeightHalf ), wrapRGB );
215: #else
216: float pointDiffuseWeight = max( dotProduct, 0.0 );
217: #endif
218: pointDiffuse  += diffuse * pointLightColor[ i ] * pointDiffuseWeight * lDistance;
219: vec3 pointHalfVector = normalize( lVector + viewPosition );
220: float pointDotNormalHalf = max( dot( normal, pointHalfVector ), 0.0 );
221: float pointSpecularWeight = specularStrength * max( pow( pointDotNormalHalf, shininess ), 0.0 );
222: #ifdef PHYSICALLY_BASED_SHADING
223: float specularNormalization = ( shininess + 2.0001 ) / 8.0;
224: vec3 schlick = specular + vec3( 1.0 - specular ) * pow( 1.0 - dot( lVector, pointHalfVector ), 5.0 );
225: pointSpecular += schlick * pointLightColor[ i ] * pointSpecularWeight * pointDiffuseWeight * lDistance * specularNormalization;
226: #else
227: pointSpecular += specular * pointLightColor[ i ] * pointSpecularWeight * pointDiffuseWeight * lDistance;
228: #endif
229: }
230: #endif
231: #if MAX_SPOT_LIGHTS > 0
232: vec3 spotDiffuse  = vec3( 0.0 );
233: vec3 spotSpecular = vec3( 0.0 );
234: for ( int i = 0; i < MAX_SPOT_LIGHTS; i ++ ) {
235: #ifdef PHONG_PER_PIXEL
236: vec4 lPosition = viewMatrix * vec4( spotLightPosition[ i ], 1.0 );
237: vec3 lVector = lPosition.xyz + vViewPosition.xyz;
238: float lDistance = 1.0;
239: if ( spotLightDistance[ i ] > 0.0 )
240: lDistance = 1.0 - min( ( length( lVector ) / spotLightDistance[ i ] ), 1.0 );
241: lVector = normalize( lVector );
242: #else
243: vec3 lVector = normalize( vSpotLight[ i ].xyz );
244: float lDistance = vSpotLight[ i ].w;
245: #endif
246: float spotEffect = dot( spotLightDirection[ i ], normalize( spotLightPosition[ i ] - vWorldPosition ) );
247: if ( spotEffect > spotLightAngleCos[ i ] ) {
248: spotEffect = max( pow( spotEffect, spotLightExponent[ i ] ), 0.0 );
249: float dotProduct = dot( normal, lVector );
250: #ifdef WRAP_AROUND
251: float spotDiffuseWeightFull = max( dotProduct, 0.0 );
252: float spotDiffuseWeightHalf = max( 0.5 * dotProduct + 0.5, 0.0 );
253: vec3 spotDiffuseWeight = mix( vec3 ( spotDiffuseWeightFull ), vec3( spotDiffuseWeightHalf ), wrapRGB );
254: #else
255: float spotDiffuseWeight = max( dotProduct, 0.0 );
256: #endif
257: spotDiffuse += diffuse * spotLightColor[ i ] * spotDiffuseWeight * lDistance * spotEffect;
258: vec3 spotHalfVector = normalize( lVector + viewPosition );
259: float spotDotNormalHalf = max( dot( normal, spotHalfVector ), 0.0 );
260: float spotSpecularWeight = specularStrength * max( pow( spotDotNormalHalf, shininess ), 0.0 );
261: #ifdef PHYSICALLY_BASED_SHADING
262: float specularNormalization = ( shininess + 2.0001 ) / 8.0;
263: vec3 schlick = specular + vec3( 1.0 - specular ) * pow( 1.0 - dot( lVector, spotHalfVector ), 5.0 );
264: spotSpecular += schlick * spotLightColor[ i ] * spotSpecularWeight * spotDiffuseWeight * lDistance * specularNormalization * spotEffect;
265: #else
266: spotSpecular += specular * spotLightColor[ i ] * spotSpecularWeight * spotDiffuseWeight * lDistance * spotEffect;
267: #endif
268: }
269: }
270: #endif
271: #if MAX_DIR_LIGHTS > 0
272: vec3 dirDiffuse  = vec3( 0.0 );
273: vec3 dirSpecular = vec3( 0.0 );
274: for( int i = 0; i < MAX_DIR_LIGHTS; i ++ ) {
275: vec4 lDirection = viewMatrix * vec4( directionalLightDirection[ i ], 0.0 );
276: vec3 dirVector = normalize( lDirection.xyz );
277: float dotProduct = dot( normal, dirVector );
278: #ifdef WRAP_AROUND
279: float dirDiffuseWeightFull = max( dotProduct, 0.0 );
280: float dirDiffuseWeightHalf = max( 0.5 * dotProduct + 0.5, 0.0 );
281: vec3 dirDiffuseWeight = mix( vec3( dirDiffuseWeightFull ), vec3( dirDiffuseWeightHalf ), wrapRGB );
282: #else
283: float dirDiffuseWeight = max( dotProduct, 0.0 );
284: #endif
285: dirDiffuse  += diffuse * directionalLightColor[ i ] * dirDiffuseWeight;
286: vec3 dirHalfVector = normalize( dirVector + viewPosition );
287: float dirDotNormalHalf = max( dot( normal, dirHalfVector ), 0.0 );
288: float dirSpecularWeight = specularStrength * max( pow( dirDotNormalHalf, shininess ), 0.0 );
289: #ifdef PHYSICALLY_BASED_SHADING
290: float specularNormalization = ( shininess + 2.0001 ) / 8.0;
291: vec3 schlick = specular + vec3( 1.0 - specular ) * pow( 1.0 - dot( dirVector, dirHalfVector ), 5.0 );
292: dirSpecular += schlick * directionalLightColor[ i ] * dirSpecularWeight * dirDiffuseWeight * specularNormalization;
293: #else
294: dirSpecular += specular * directionalLightColor[ i ] * dirSpecularWeight * dirDiffuseWeight;
295: #endif
296: }
297: #endif
298: #if MAX_HEMI_LIGHTS > 0
299: vec3 hemiDiffuse  = vec3( 0.0 );
300: vec3 hemiSpecular = vec3( 0.0 );
301: for( int i = 0; i < MAX_HEMI_LIGHTS; i ++ ) {
302: vec4 lDirection = viewMatrix * vec4( hemisphereLightDirection[ i ], 0.0 );
303: vec3 lVector = normalize( lDirection.xyz );
304: float dotProduct = dot( normal, lVector );
305: float hemiDiffuseWeight = 0.5 * dotProduct + 0.5;
306: vec3 hemiColor = mix( hemisphereLightGroundColor[ i ], hemisphereLightSkyColor[ i ], hemiDiffuseWeight );
307: hemiDiffuse += diffuse * hemiColor;
308: vec3 hemiHalfVectorSky = normalize( lVector + viewPosition );
309: float hemiDotNormalHalfSky = 0.5 * dot( normal, hemiHalfVectorSky ) + 0.5;
310: float hemiSpecularWeightSky = specularStrength * max( pow( hemiDotNormalHalfSky, shininess ), 0.0 );
311: vec3 lVectorGround = -lVector;
312: vec3 hemiHalfVectorGround = normalize( lVectorGround + viewPosition );
313: float hemiDotNormalHalfGround = 0.5 * dot( normal, hemiHalfVectorGround ) + 0.5;
314: float hemiSpecularWeightGround = specularStrength * max( pow( hemiDotNormalHalfGround, shininess ), 0.0 );
315: #ifdef PHYSICALLY_BASED_SHADING
316: float dotProductGround = dot( normal, lVectorGround );
317: float specularNormalization = ( shininess + 2.0001 ) / 8.0;
318: vec3 schlickSky = specular + vec3( 1.0 - specular ) * pow( 1.0 - dot( lVector, hemiHalfVectorSky ), 5.0 );
319: vec3 schlickGround = specular + vec3( 1.0 - specular ) * pow( 1.0 - dot( lVectorGround, hemiHalfVectorGround ), 5.0 );
320: hemiSpecular += hemiColor * specularNormalization * ( schlickSky * hemiSpecularWeightSky * max( dotProduct, 0.0 ) + schlickGround * hemiSpecularWeightGround * max( dotProductGround, 0.0 ) );
321: #else
322: hemiSpecular += specular * hemiColor * ( hemiSpecularWeightSky + hemiSpecularWeightGround ) * hemiDiffuseWeight;
323: #endif
324: }
325: #endif
326: vec3 totalDiffuse = vec3( 0.0 );
327: vec3 totalSpecular = vec3( 0.0 );
328: #if MAX_DIR_LIGHTS > 0
329: totalDiffuse += dirDiffuse;
330: totalSpecular += dirSpecular;
331: #endif
332: #if MAX_HEMI_LIGHTS > 0
333: totalDiffuse += hemiDiffuse;
334: totalSpecular += hemiSpecular;
335: #endif
336: #if MAX_POINT_LIGHTS > 0
337: totalDiffuse += pointDiffuse;
338: totalSpecular += pointSpecular;
339: #endif
340: #if MAX_SPOT_LIGHTS > 0
341: totalDiffuse += spotDiffuse;
342: totalSpecular += spotSpecular;
343: #endif
344: #ifdef METAL
345: gl_FragColor.xyz = gl_FragColor.xyz * ( emissive + totalDiffuse + ambientLightColor * ambient + totalSpecular );
346: #else
347: gl_FragColor.xyz = gl_FragColor.xyz * ( emissive + totalDiffuse + ambientLightColor * ambient ) + totalSpecular;
348: #endif
349: #ifdef USE_LIGHTMAP
350: gl_FragColor = gl_FragColor * texture2D( lightMap, vUv2 );
351: #endif
352: #ifdef USE_COLOR
353: gl_FragColor = gl_FragColor * vec4( vColor, opacity );
354: #endif
355: #ifdef USE_ENVMAP
356: vec3 reflectVec;
357: #if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP )
358: vec3 cameraToVertex = normalize( vWorldPosition - cameraPosition );
359: if ( useRefract ) {
360: reflectVec = refract( cameraToVertex, normal, refractionRatio );
361: } else { 
362: reflectVec = reflect( cameraToVertex, normal );
363: }
364: #else
365: reflectVec = vReflect;
366: #endif
367: #ifdef DOUBLE_SIDED
368: float flipNormal = ( -1.0 + 2.0 * float( gl_FrontFacing ) );
369: vec4 cubeColor = textureCube( envMap, flipNormal * vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );
370: #else
371: vec4 cubeColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );
372: #endif
373: #ifdef GAMMA_INPUT
374: cubeColor.xyz *= cubeColor.xyz;
375: #endif
376: if ( combine == 1 ) {
377: gl_FragColor.xyz = mix( gl_FragColor.xyz, cubeColor.xyz, specularStrength * reflectivity );
378: } else if ( combine == 2 ) {
379: gl_FragColor.xyz += cubeColor.xyz * specularStrength * reflectivity;
380: } else {
381: gl_FragColor.xyz = mix( gl_FragColor.xyz, gl_FragColor.xyz * cubeColor.xyz, specularStrength * reflectivity );
382: }
383: #endif
384: #ifdef USE_SHADOWMAP
385: #ifdef SHADOWMAP_DEBUG
386: vec3 frustumColors[3];
387: frustumColors[0] = vec3( 1.0, 0.5, 0.0 );
388: frustumColors[1] = vec3( 0.0, 1.0, 0.8 );
389: frustumColors[2] = vec3( 0.0, 0.5, 1.0 );
390: #endif
391: #ifdef SHADOWMAP_CASCADE
392: int inFrustumCount = 0;
393: #endif
394: float fDepth;
395: vec3 shadowColor = vec3( 1.0 );
396: for( int i = 0; i < MAX_SHADOWS; i ++ ) {
397: vec3 shadowCoord = vShadowCoord[ i ].xyz / vShadowCoord[ i ].w;
398: bvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );
399: bool inFrustum = all( inFrustumVec );
400: #ifdef SHADOWMAP_CASCADE
401: inFrustumCount += int( inFrustum );
402: bvec3 frustumTestVec = bvec3( inFrustum, inFrustumCount == 1, shadowCoord.z <= 1.0 );
403: #else
404: bvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );
405: #endif
406: bool frustumTest = all( frustumTestVec );
407: if ( frustumTest ) {
408: shadowCoord.z += shadowBias[ i ];
409: #if defined( SHADOWMAP_TYPE_PCF )
410: float shadow = 0.0;
411: const float shadowDelta = 1.0 / 9.0;
412: float xPixelOffset = 1.0 / shadowMapSize[ i ].x;
413: float yPixelOffset = 1.0 / shadowMapSize[ i ].y;
414: float dx0 = -1.25 * xPixelOffset;
415: float dy0 = -1.25 * yPixelOffset;
416: float dx1 = 1.25 * xPixelOffset;
417: float dy1 = 1.25 * yPixelOffset;
418: fDepth = unpackDepth( texture2D( shadowMap[ i ], shadowCoord.xy + vec2( dx0, dy0 ) ) );
419: if ( fDepth < shadowCoord.z ) shadow += shadowDelta;
420: fDepth = unpackDepth( texture2D( shadowMap[ i ], shadowCoord.xy + vec2( 0.0, dy0 ) ) );
421: if ( fDepth < shadowCoord.z ) shadow += shadowDelta;
422: fDepth = unpackDepth( texture2D( shadowMap[ i ], shadowCoord.xy + vec2( dx1, dy0 ) ) );
423: if ( fDepth < shadowCoord.z ) shadow += shadowDelta;
424: fDepth = unpackDepth( texture2D( shadowMap[ i ], shadowCoord.xy + vec2( dx0, 0.0 ) ) );
425: if ( fDepth < shadowCoord.z ) shadow += shadowDelta;
426: fDepth = unpackDepth( texture2D( shadowMap[ i ], shadowCoord.xy ) );
427: if ( fDepth < shadowCoord.z ) shadow += shadowDelta;
428: fDepth = unpackDepth( texture2D( shadowMap[ i ], shadowCoord.xy + vec2( dx1, 0.0 ) ) );
429: if ( fDepth < shadowCoord.z ) shadow += shadowDelta;
430: fDepth = unpackDepth( texture2D( shadowMap[ i ], shadowCoord.xy + vec2( dx0, dy1 ) ) );
431: if ( fDepth < shadowCoord.z ) shadow += shadowDelta;
432: fDepth = unpackDepth( texture2D( shadowMap[ i ], shadowCoord.xy + vec2( 0.0, dy1 ) ) );
433: if ( fDepth < shadowCoord.z ) shadow += shadowDelta;
434: fDepth = unpackDepth( texture2D( shadowMap[ i ], shadowCoord.xy + vec2( dx1, dy1 ) ) );
435: if ( fDepth < shadowCoord.z ) shadow += shadowDelta;
436: shadowColor = shadowColor * vec3( ( 1.0 - shadowDarkness[ i ] * shadow ) );
437: #elif defined( SHADOWMAP_TYPE_PCF_SOFT )
438: float shadow = 0.0;
439: float xPixelOffset = 1.0 / shadowMapSize[ i ].x;
440: float yPixelOffset = 1.0 / shadowMapSize[ i ].y;
441: float dx0 = -1.0 * xPixelOffset;
442: float dy0 = -1.0 * yPixelOffset;
443: float dx1 = 1.0 * xPixelOffset;
444: float dy1 = 1.0 * yPixelOffset;
445: mat3 shadowKernel;
446: mat3 depthKernel;
447: depthKernel[0][0] = unpackDepth( texture2D( shadowMap[ i ], shadowCoord.xy + vec2( dx0, dy0 ) ) );
448: depthKernel[0][1] = unpackDepth( texture2D( shadowMap[ i ], shadowCoord.xy + vec2( dx0, 0.0 ) ) );
449: depthKernel[0][2] = unpackDepth( texture2D( shadowMap[ i ], shadowCoord.xy + vec2( dx0, dy1 ) ) );
450: depthKernel[1][0] = unpackDepth( texture2D( shadowMap[ i ], shadowCoord.xy + vec2( 0.0, dy0 ) ) );
451: depthKernel[1][1] = unpackDepth( texture2D( shadowMap[ i ], shadowCoord.xy ) );
452: depthKernel[1][2] = unpackDepth( texture2D( shadowMap[ i ], shadowCoord.xy + vec2( 0.0, dy1 ) ) );
453: depthKernel[2][0] = unpackDepth( texture2D( shadowMap[ i ], shadowCoord.xy + vec2( dx1, dy0 ) ) );
454: depthKernel[2][1] = unpackDepth( texture2D( shadowMap[ i ], shadowCoord.xy + vec2( dx1, 0.0 ) ) );
455: depthKernel[2][2] = unpackDepth( texture2D( shadowMap[ i ], shadowCoord.xy + vec2( dx1, dy1 ) ) );
456: vec3 shadowZ = vec3( shadowCoord.z );
457: shadowKernel[0] = vec3(lessThan(depthKernel[0], shadowZ ));
458: shadowKernel[0] *= vec3(0.25);
459: shadowKernel[1] = vec3(lessThan(depthKernel[1], shadowZ ));
460: shadowKernel[1] *= vec3(0.25);
461: shadowKernel[2] = vec3(lessThan(depthKernel[2], shadowZ ));
462: shadowKernel[2] *= vec3(0.25);
463: vec2 fractionalCoord = 1.0 - fract( shadowCoord.xy * shadowMapSize[i].xy );
464: shadowKernel[0] = mix( shadowKernel[1], shadowKernel[0], fractionalCoord.x );
465: shadowKernel[1] = mix( shadowKernel[2], shadowKernel[1], fractionalCoord.x );
466: vec4 shadowValues;
467: shadowValues.x = mix( shadowKernel[0][1], shadowKernel[0][0], fractionalCoord.y );
468: shadowValues.y = mix( shadowKernel[0][2], shadowKernel[0][1], fractionalCoord.y );
469: shadowValues.z = mix( shadowKernel[1][1], shadowKernel[1][0], fractionalCoord.y );
470: shadowValues.w = mix( shadowKernel[1][2], shadowKernel[1][1], fractionalCoord.y );
471: shadow = dot( shadowValues, vec4( 1.0 ) );
472: shadowColor = shadowColor * vec3( ( 1.0 - shadowDarkness[ i ] * shadow ) );
473: #else
474: vec4 rgbaDepth = texture2D( shadowMap[ i ], shadowCoord.xy );
475: float fDepth = unpackDepth( rgbaDepth );
476: if ( fDepth < shadowCoord.z )
477: shadowColor = shadowColor * vec3( 1.0 - shadowDarkness[ i ] );
478: #endif
479: }
480: #ifdef SHADOWMAP_DEBUG
481: #ifdef SHADOWMAP_CASCADE
482: if ( inFrustum && inFrustumCount == 1 ) gl_FragColor.xyz *= frustumColors[ i ];
483: #else
484: if ( inFrustum ) gl_FragColor.xyz *= frustumColors[ i ];
485: #endif
486: #endif
487: }
488: #ifdef GAMMA_OUTPUT
489: shadowColor *= shadowColor;
490: #endif
491: gl_FragColor.xyz = gl_FragColor.xyz * shadowColor;
492: #endif
493: #ifdef GAMMA_OUTPUT
494: gl_FragColor.xyz = sqrt( gl_FragColor.xyz );
495: #endif
496: #ifdef USE_FOG
497: float depth = gl_FragCoord.z / gl_FragCoord.w;
498: #ifdef FOG_EXP2
499: const float LOG2 = 1.442695;
500: float fogFactor = exp2( - fogDensity * fogDensity * depth * depth * LOG2 );
501: fogFactor = 1.0 - clamp( fogFactor, 0.0, 1.0 );
502: #else
503: float fogFactor = smoothstep( fogNear, fogFar, depth );
504: #endif
505: gl_FragColor = mix( gl_FragColor, vec4( fogColor, gl_FragColor.w ), fogFactor );
506: #endif
507: } Three58.js:25039
WebGL: INVALID_VALUE: attachShader: no object or object deleted www.titansoftime.com/:1

Answer 1

I'm using version 55 of three.js and find similar problem. On some very old PC in chrome I saw this warnings:

THREE.WebGLRenderer: Float textures not supported.
THREE.WebGLRenderer: Standard derivatives not supported.

It created problem, that some models were invisible. It was caused by HemisphereLight. I used two HemisphereLights. That doesn't work if PC doesn't support float textures or standard derivatives. So I had to remove second light from my code, to fix this.

Answer 2

In release r58 if you look in three.js line 26037 you will see that three.js checks whether the OES_texture_float extension is supported. Then at line 26051 gives the error message if it is not. So in your app you could check for the extension before it gets to three.js and inform your users about the requirement.