Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

THREE.WebGLShader: gl.getShaderInfoLog() vertex WARNING: 0:1: extension 'GL_ARB_gpu_shader5' is not supported #10316

Closed
therocketforever opened this issue Dec 8, 2016 · 4 comments
Closed

THREE.WebGLShader: gl.getShaderInfoLog() vertex WARNING: 0:1: extension 'GL_ARB_gpu_shader5' is not supported #10316

therocketforever opened this issue Dec 8, 2016 · 4 comments
Labels
Duplicate

Comments

@therocketforever
Copy link

therocketforever commented Dec 8, 2016 •
edited

While following this tutorial errors in firefox console; still seems to render fine. error only appears in firefox. chrome & safari on desktop, mobile(6s) works fine no error.

Firefox Developer Edition - 52.0a2 (2016-12-08) (64-bit)
MacBook (Retina, 12-inch, Early 2015) macOS Sierra 10.12.1

THREE.WebGLShader: gl.getShaderInfoLog() vertex WARNING: 0:1: extension 'GL_ARB_gpu_shader5' is not supported
 1: precision highp float;
2: precision highp int;
3: #define SHADER_NAME MeshLambertMaterial
4: #define VERTEX_TEXTURES
5: #define GAMMA_FACTOR 2
6: #define MAX_BONES 251
7: #define NUM_CLIPPING_PLANES 0
8: uniform mat4 modelMatrix;
9: uniform mat4 modelViewMatrix;
10: uniform mat4 projectionMatrix;
11: uniform mat4 viewMatrix;
12: uniform mat3 normalMatrix;
13: uniform vec3 cameraPosition;
14: attribute vec3 position;
15: attribute vec3 normal;
16: attribute vec2 uv;
17: #ifdef USE_COLOR
18: 	attribute vec3 color;
19: #endif
20: #ifdef USE_MORPHTARGETS
21: 	attribute vec3 morphTarget0;
22: 	attribute vec3 morphTarget1;
23: 	attribute vec3 morphTarget2;
24: 	attribute vec3 morphTarget3;
25: 	#ifdef USE_MORPHNORMALS
26: 		attribute vec3 morphNormal0;
27: 		attribute vec3 morphNormal1;
28: 		attribute vec3 morphNormal2;
29: 		attribute vec3 morphNormal3;
30: 	#else
31: 		attribute vec3 morphTarget4;
32: 		attribute vec3 morphTarget5;
33: 		attribute vec3 morphTarget6;
34: 		attribute vec3 morphTarget7;
35: 	#endif
36: #endif
37: #ifdef USE_SKINNING
38: 	attribute vec4 skinIndex;
39: 	attribute vec4 skinWeight;
40: #endif
41: 
42: #define LAMBERT
43: varying vec3 vLightFront;
44: #ifdef DOUBLE_SIDED
45: 	varying vec3 vLightBack;
46: #endif
47: #define PI 3.14159265359
48: #define PI2 6.28318530718
49: #define RECIPROCAL_PI 0.31830988618
50: #define RECIPROCAL_PI2 0.15915494
51: #define LOG2 1.442695
52: #define EPSILON 1e-6
53: #define saturate(a) clamp( a, 0.0, 1.0 )
54: #define whiteCompliment(a) ( 1.0 - saturate( a ) )
55: float pow2( const in float x ) { return x*x; }
56: float pow3( const in float x ) { return x*x*x; }
57: float pow4( const in float x ) { float x2 = x*x; return x2*x2; }
58: float average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }
59: highp float rand( const in vec2 uv ) {
60: 	const highp float a = 12.9898, b = 78.233, c = 43758.5453;
61: 	highp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );
62: 	return fract(sin(sn) * c);
63: }
64: struct IncidentLight {
65: 	vec3 color;
66: 	vec3 direction;
67: 	bool visible;
68: };
69: struct ReflectedLight {
70: 	vec3 directDiffuse;
71: 	vec3 directSpecular;
72: 	vec3 indirectDiffuse;
73: 	vec3 indirectSpecular;
74: };
75: struct GeometricContext {
76: 	vec3 position;
77: 	vec3 normal;
78: 	vec3 viewDir;
79: };
80: vec3 transformDirection( in vec3 dir, in mat4 matrix ) {
81: 	return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );
82: }
83: vec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {
84: 	return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );
85: }
86: vec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {
87: 	float distance = dot( planeNormal, point - pointOnPlane );
88: 	return - distance * planeNormal + point;
89: }
90: float sideOfPlane( in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {
91: 	return sign( dot( point - pointOnPlane, planeNormal ) );
92: }
93: vec3 linePlaneIntersect( in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal ) {
94: 	return lineDirection * ( dot( planeNormal, pointOnPlane - pointOnLine ) / dot( planeNormal, lineDirection ) ) + pointOnLine;
95: }
96: 
97: #if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )
98: 	varying vec2 vUv;
99: 	uniform vec4 offsetRepeat;
100: #endif
101: 
102: #if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
103: 	attribute vec2 uv2;
104: 	varying vec2 vUv2;
105: #endif
106: #ifdef USE_ENVMAP
107: 	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )
108: 		varying vec3 vWorldPosition;
109: 	#else
110: 		varying vec3 vReflect;
111: 		uniform float refractionRatio;
112: 	#endif
113: #endif
114: 
115: bool testLightInRange( const in float lightDistance, const in float cutoffDistance ) {
116: 	return any( bvec2( cutoffDistance == 0.0, lightDistance < cutoffDistance ) );
117: }
118: float punctualLightIntensityToIrradianceFactor( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {
119: 		if( decayExponent > 0.0 ) {
120: #if defined ( PHYSICALLY_CORRECT_LIGHTS )
121: 			float distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );
122: 			float maxDistanceCutoffFactor = pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );
123: 			return distanceFalloff * maxDistanceCutoffFactor;
124: #else
125: 			return pow( saturate( -lightDistance / cutoffDistance + 1.0 ), decayExponent );
126: #endif
127: 		}
128: 		return 1.0;
129: }
130: vec3 BRDF_Diffuse_Lambert( const in vec3 diffuseColor ) {
131: 	return RECIPROCAL_PI * diffuseColor;
132: }
133: vec3 F_Schlick( const in vec3 specularColor, const in float dotLH ) {
134: 	float fresnel = exp2( ( -5.55473 * dotLH - 6.98316 ) * dotLH );
135: 	return ( 1.0 - specularColor ) * fresnel + specularColor;
136: }
137: float G_GGX_Smith( const in float alpha, const in float dotNL, const in float dotNV ) {
138: 	float a2 = pow2( alpha );
139: 	float gl = dotNL + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );
140: 	float gv = dotNV + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );
141: 	return 1.0 / ( gl * gv );
142: }
143: float G_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {
144: 	float a2 = pow2( alpha );
145: 	float gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );
146: 	float gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );
147: 	return 0.5 / max( gv + gl, EPSILON );
148: }
149: float D_GGX( const in float alpha, const in float dotNH ) {
150: 	float a2 = pow2( alpha );
151: 	float denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;
152: 	return RECIPROCAL_PI * a2 / pow2( denom );
153: }
154: vec3 BRDF_Specular_GGX( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float roughness ) {
155: 	float alpha = pow2( roughness );
156: 	vec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );
157: 	float dotNL = saturate( dot( geometry.normal, incidentLight.direction ) );
158: 	float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );
159: 	float dotNH = saturate( dot( geometry.normal, halfDir ) );
160: 	float dotLH = saturate( dot( incidentLight.direction, halfDir ) );
161: 	vec3 F = F_Schlick( specularColor, dotLH );
162: 	float G = G_GGX_SmithCorrelated( alpha, dotNL, dotNV );
163: 	float D = D_GGX( alpha, dotNH );
164: 	return F * ( G * D );
165: }
166: vec3 BRDF_Specular_GGX_Environment( const in GeometricContext geometry, const in vec3 specularColor, const in float roughness ) {
167: 	float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );
168: 	const vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );
169: 	const vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );
170: 	vec4 r = roughness * c0 + c1;
171: 	float a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;
172: 	vec2 AB = vec2( -1.04, 1.04 ) * a004 + r.zw;
173: 	return specularColor * AB.x + AB.y;
174: }
175: float G_BlinnPhong_Implicit( ) {
176: 	return 0.25;
177: }
178: float D_BlinnPhong( const in float shininess, const in float dotNH ) {
179: 	return RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );
180: }
181: vec3 BRDF_Specular_BlinnPhong( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float shininess ) {
182: 	vec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );
183: 	float dotNH = saturate( dot( geometry.normal, halfDir ) );
184: 	float dotLH = saturate( dot( incidentLight.direction, halfDir ) );
185: 	vec3 F = F_Schlick( specularColor, dotLH );
186: 	float G = G_BlinnPhong_Implicit( );
187: 	float D = D_BlinnPhong( shininess, dotNH );
188: 	return F * ( G * D );
189: }
190: float GGXRoughnessToBlinnExponent( const in float ggxRoughness ) {
191: 	return ( 2.0 / pow2( ggxRoughness + 0.0001 ) - 2.0 );
192: }
193: float BlinnExponentToGGXRoughness( const in float blinnExponent ) {
194: 	return sqrt( 2.0 / ( blinnExponent + 2.0 ) );
195: }
196: 
197: uniform vec3 ambientLightColor;
198: vec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {
199: 	vec3 irradiance = ambientLightColor;
200: 	#ifndef PHYSICALLY_CORRECT_LIGHTS
201: 		irradiance *= PI;
202: 	#endif
203: 	return irradiance;
204: }
205: #if 0 > 0
206: 	struct DirectionalLight {
207: 		vec3 direction;
208: 		vec3 color;
209: 		int shadow;
210: 		float shadowBias;
211: 		float shadowRadius;
212: 		vec2 shadowMapSize;
213: 	};
214: 	uniform DirectionalLight directionalLights[ 0 ];
215: 	void getDirectionalDirectLightIrradiance( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight directLight ) {
216: 		directLight.color = directionalLight.color;
217: 		directLight.direction = directionalLight.direction;
218: 		directLight.visible = true;
219: 	}
220: #endif
221: #if 1 > 0
222: 	struct PointLight {
223: 		vec3 position;
224: 		vec3 color;
225: 		float distance;
226: 		float decay;
227: 		int shadow;
228: 		float shadowBias;
229: 		float shadowRadius;
230: 		vec2 shadowMapSize;
231: 	};
232: 	uniform PointLight pointLights[ 1 ];
233: 	void getPointDirectLightIrradiance( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight directLight ) {
234: 		vec3 lVector = pointLight.position - geometry.position;
235: 		directLight.direction = normalize( lVector );
236: 		float lightDistance = length( lVector );
237: 		if ( testLightInRange( lightDistance, pointLight.distance ) ) {
238: 			directLight.color = pointLight.color;
239: 			directLight.color *= punctualLightIntensityToIrradianceFactor( lightDistance, pointLight.distance, pointLight.decay );
240: 			directLight.visible = true;
241: 		} else {
242: 			directLight.color = vec3( 0.0 );
243: 			directLight.visible = false;
244: 		}
245: 	}
246: #endif
247: #if 0 > 0
248: 	struct SpotLight {
249: 		vec3 position;
250: 		vec3 direction;
251: 		vec3 color;
252: 		float distance;
253: 		float decay;
254: 		float coneCos;
255: 		float penumbraCos;
256: 		int shadow;
257: 		float shadowBias;
258: 		float shadowRadius;
259: 		vec2 shadowMapSize;
260: 	};
261: 	uniform SpotLight spotLights[ 0 ];
262: 	void getSpotDirectLightIrradiance( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight directLight  ) {
263: 		vec3 lVector = spotLight.position - geometry.position;
264: 		directLight.direction = normalize( lVector );
265: 		float lightDistance = length( lVector );
266: 		float angleCos = dot( directLight.direction, spotLight.direction );
267: 		if ( all( bvec2( angleCos > spotLight.coneCos, testLightInRange( lightDistance, spotLight.distance ) ) ) ) {
268: 			float spotEffect = smoothstep( spotLight.coneCos, spotLight.penumbraCos, angleCos );
269: 			directLight.color = spotLight.color;
270: 			directLight.color *= spotEffect * punctualLightIntensityToIrradianceFactor( lightDistance, spotLight.distance, spotLight.decay );
271: 			directLight.visible = true;
272: 		} else {
273: 			directLight.color = vec3( 0.0 );
274: 			directLight.visible = false;
275: 		}
276: 	}
277: #endif
278: #if 0 > 0
279: 	struct HemisphereLight {
280: 		vec3 direction;
281: 		vec3 skyColor;
282: 		vec3 groundColor;
283: 	};
284: 	uniform HemisphereLight hemisphereLights[ 0 ];
285: 	vec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in GeometricContext geometry ) {
286: 		float dotNL = dot( geometry.normal, hemiLight.direction );
287: 		float hemiDiffuseWeight = 0.5 * dotNL + 0.5;
288: 		vec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );
289: 		#ifndef PHYSICALLY_CORRECT_LIGHTS
290: 			irradiance *= PI;
291: 		#endif
292: 		return irradiance;
293: 	}
294: #endif
295: #if defined( USE_ENVMAP ) && defined( PHYSICAL )
296: 	vec3 getLightProbeIndirectIrradiance( const in GeometricContext geometry, const in int maxMIPLevel ) {
297: 		#ifdef DOUBLE_SIDED
298: 	float flipNormal = ( float( gl_FrontFacing ) * 2.0 - 1.0 );
299: #else
300: 	float flipNormal = 1.0;
301: #endif
302: 
303: 		vec3 worldNormal = inverseTransformDirection( geometry.normal, viewMatrix );
304: 		#ifdef ENVMAP_TYPE_CUBE
305: 			vec3 queryVec = flipNormal * vec3( flipEnvMap * worldNormal.x, worldNormal.yz );
306: 			#ifdef TEXTURE_LOD_EXT
307: 				vec4 envMapColor = textureCubeLodEXT( envMap, queryVec, float( maxMIPLevel ) );
308: 			#else
309: 				vec4 envMapColor = textureCube( envMap, queryVec, float( maxMIPLevel ) );
310: 			#endif
311: 			envMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;
312: 		#elif defined( ENVMAP_TYPE_CUBE_UV )
313: 			vec3 queryVec = flipNormal * vec3( flipEnvMap * worldNormal.x, worldNormal.yz );
314: 			vec4 envMapColor = textureCubeUV( queryVec, 1.0 );
315: 		#else
316: 			vec4 envMapColor = vec4( 0.0 );
317: 		#endif
318: 		return PI * envMapColor.rgb * envMapIntensity;
319: 	}
320: 	float getSpecularMIPLevel( const in float blinnShininessExponent, const in int maxMIPLevel ) {
321: 		float maxMIPLevelScalar = float( maxMIPLevel );
322: 		float desiredMIPLevel = maxMIPLevelScalar - 0.79248 - 0.5 * log2( pow2( blinnShininessExponent ) + 1.0 );
323: 		return clamp( desiredMIPLevel, 0.0, maxMIPLevelScalar );
324: 	}
325: 	vec3 getLightProbeIndirectRadiance( const in GeometricContext geometry, const in float blinnShininessExponent, const in int maxMIPLevel ) {
326: 		#ifdef ENVMAP_MODE_REFLECTION
327: 			vec3 reflectVec = reflect( -geometry.viewDir, geometry.normal );
328: 		#else
329: 			vec3 reflectVec = refract( -geometry.viewDir, geometry.normal, refractionRatio );
330: 		#endif
331: 		#ifdef DOUBLE_SIDED
332: 	float flipNormal = ( float( gl_FrontFacing ) * 2.0 - 1.0 );
333: #else
334: 	float flipNormal = 1.0;
335: #endif
336: 
337: 		reflectVec = inverseTransformDirection( reflectVec, viewMatrix );
338: 		float specularMIPLevel = getSpecularMIPLevel( blinnShininessExponent, maxMIPLevel );
339: 		#ifdef ENVMAP_TYPE_CUBE
340: 			vec3 queryReflectVec = flipNormal * vec3( flipEnvMap * reflectVec.x, reflectVec.yz );
341: 			#ifdef TEXTURE_LOD_EXT
342: 				vec4 envMapColor = textureCubeLodEXT( envMap, queryReflectVec, specularMIPLevel );
343: 			#else
344: 				vec4 envMapColor = textureCube( envMap, queryReflectVec, specularMIPLevel );
345: 			#endif
346: 			envMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;
347: 		#elif defined( ENVMAP_TYPE_CUBE_UV )
348: 			vec3 queryReflectVec = flipNormal * vec3( flipEnvMap * reflectVec.x, reflectVec.yz );
349: 			vec4 envMapColor = textureCubeUV(queryReflectVec, BlinnExponentToGGXRoughness(blinnShininessExponent));
350: 		#elif defined( ENVMAP_TYPE_EQUIREC )
351: 			vec2 sampleUV;
352: 			sampleUV.y = saturate( flipNormal * reflectVec.y * 0.5 + 0.5 );
353: 			sampleUV.x = atan( flipNormal * reflectVec.z, flipNormal * reflectVec.x ) * RECIPROCAL_PI2 + 0.5;
354: 			#ifdef TEXTURE_LOD_EXT
355: 				vec4 envMapColor = texture2DLodEXT( envMap, sampleUV, specularMIPLevel );
356: 			#else
357: 				vec4 envMapColor = texture2D( envMap, sampleUV, specularMIPLevel );
358: 			#endif
359: 			envMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;
360: 		#elif defined( ENVMAP_TYPE_SPHERE )
361: 			vec3 reflectView = flipNormal * normalize( ( viewMatrix * vec4( reflectVec, 0.0 ) ).xyz + vec3( 0.0,0.0,1.0 ) );
362: 			#ifdef TEXTURE_LOD_EXT
363: 				vec4 envMapColor = texture2DLodEXT( envMap, reflectView.xy * 0.5 + 0.5, specularMIPLevel );
364: 			#else
365: 				vec4 envMapColor = texture2D( envMap, reflectView.xy * 0.5 + 0.5, specularMIPLevel );
366: 			#endif
367: 			envMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;
368: 		#endif
369: 		return envMapColor.rgb * envMapIntensity;
370: 	}
371: #endif
372: 
373: #ifdef USE_COLOR
374: 	varying vec3 vColor;
375: #endif
376: #ifdef USE_MORPHTARGETS
377: 	#ifndef USE_MORPHNORMALS
378: 	uniform float morphTargetInfluences[ 8 ];
379: 	#else
380: 	uniform float morphTargetInfluences[ 4 ];
381: 	#endif
382: #endif
383: #ifdef USE_SKINNING
384: 	uniform mat4 bindMatrix;
385: 	uniform mat4 bindMatrixInverse;
386: 	#ifdef BONE_TEXTURE
387: 		uniform sampler2D boneTexture;
388: 		uniform int boneTextureWidth;
389: 		uniform int boneTextureHeight;
390: 		mat4 getBoneMatrix( const in float i ) {
391: 			float j = i * 4.0;
392: 			float x = mod( j, float( boneTextureWidth ) );
393: 			float y = floor( j / float( boneTextureWidth ) );
394: 			float dx = 1.0 / float( boneTextureWidth );
395: 			float dy = 1.0 / float( boneTextureHeight );
396: 			y = dy * ( y + 0.5 );
397: 			vec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );
398: 			vec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );
399: 			vec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );
400: 			vec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );
401: 			mat4 bone = mat4( v1, v2, v3, v4 );
402: 			return bone;
403: 		}
404: 	#else
405: 		uniform mat4 boneMatrices[ MAX_BONES ];
406: 		mat4 getBoneMatrix( const in float i ) {
407: 			mat4 bone = boneMatrices[ int(i) ];
408: 			return bone;
409: 		}
410: 	#endif
411: #endif
412: 
413: #ifdef USE_SHADOWMAP
414: 	#if 0 > 0
415: 		uniform mat4 directionalShadowMatrix[ 0 ];
416: 		varying vec4 vDirectionalShadowCoord[ 0 ];
417: 	#endif
418: 	#if 0 > 0
419: 		uniform mat4 spotShadowMatrix[ 0 ];
420: 		varying vec4 vSpotShadowCoord[ 0 ];
421: 	#endif
422: 	#if 1 > 0
423: 		uniform mat4 pointShadowMatrix[ 1 ];
424: 		varying vec4 vPointShadowCoord[ 1 ];
425: 	#endif
426: #endif
427: 
428: #ifdef USE_LOGDEPTHBUF
429: 	#ifdef USE_LOGDEPTHBUF_EXT
430: 		varying float vFragDepth;
431: 	#endif
432: 	uniform float logDepthBufFC;
433: #endif
434: #if NUM_CLIPPING_PLANES > 0 && ! defined( PHYSICAL ) && ! defined( PHONG )
435: 	varying vec3 vViewPosition;
436: #endif
437: 
438: void main() {
439: 	#if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )
440: 	vUv = uv * offsetRepeat.zw + offsetRepeat.xy;
441: #endif
442: 	#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
443: 	vUv2 = uv2;
444: #endif
445: 	#ifdef USE_COLOR
446: 	vColor.xyz = color.xyz;
447: #endif
448: 	
449: vec3 objectNormal = vec3( normal );
450: 
451: 	#ifdef USE_MORPHNORMALS
452: 	objectNormal += ( morphNormal0 - normal ) * morphTargetInfluences[ 0 ];
453: 	objectNormal += ( morphNormal1 - normal ) * morphTargetInfluences[ 1 ];
454: 	objectNormal += ( morphNormal2 - normal ) * morphTargetInfluences[ 2 ];
455: 	objectNormal += ( morphNormal3 - normal ) * morphTargetInfluences[ 3 ];
456: #endif
457: 
458: 	#ifdef USE_SKINNING
459: 	mat4 boneMatX = getBoneMatrix( skinIndex.x );
460: 	mat4 boneMatY = getBoneMatrix( skinIndex.y );
461: 	mat4 boneMatZ = getBoneMatrix( skinIndex.z );
462: 	mat4 boneMatW = getBoneMatrix( skinIndex.w );
463: #endif
464: 	#ifdef USE_SKINNING
465: 	mat4 skinMatrix = mat4( 0.0 );
466: 	skinMatrix += skinWeight.x * boneMatX;
467: 	skinMatrix += skinWeight.y * boneMatY;
468: 	skinMatrix += skinWeight.z * boneMatZ;
469: 	skinMatrix += skinWeight.w * boneMatW;
470: 	skinMatrix  = bindMatrixInverse * skinMatrix * bindMatrix;
471: 	objectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;
472: #endif
473: 
474: 	#ifdef FLIP_SIDED
475: 	objectNormal = -objectNormal;
476: #endif
477: vec3 transformedNormal = normalMatrix * objectNormal;
478: 
479: 	
480: vec3 transformed = vec3( position );
481: 
482: 	#ifdef USE_MORPHTARGETS
483: 	transformed += ( morphTarget0 - position ) * morphTargetInfluences[ 0 ];
484: 	transformed += ( morphTarget1 - position ) * morphTargetInfluences[ 1 ];
485: 	transformed += ( morphTarget2 - position ) * morphTargetInfluences[ 2 ];
486: 	transformed += ( morphTarget3 - position ) * morphTargetInfluences[ 3 ];
487: 	#ifndef USE_MORPHNORMALS
488: 	transformed += ( morphTarget4 - position ) * morphTargetInfluences[ 4 ];
489: 	transformed += ( morphTarget5 - position ) * morphTargetInfluences[ 5 ];
490: 	transformed += ( morphTarget6 - position ) * morphTargetInfluences[ 6 ];
491: 	transformed += ( morphTarget7 - position ) * morphTargetInfluences[ 7 ];
492: 	#endif
493: #endif
494: 
495: 	#ifdef USE_SKINNING
496: 	vec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );
497: 	vec4 skinned = vec4( 0.0 );
498: 	skinned += boneMatX * skinVertex * skinWeight.x;
499: 	skinned += boneMatY * skinVertex * skinWeight.y;
500: 	skinned += boneMatZ * skinVertex * skinWeight.z;
501: 	skinned += boneMatW * skinVertex * skinWeight.w;
502: 	skinned  = bindMatrixInverse * skinned;
503: #endif
504: 
505: 	#ifdef USE_SKINNING
506: 	vec4 mvPosition = modelViewMatrix * skinned;
507: #else
508: 	vec4 mvPosition = modelViewMatrix * vec4( transformed, 1.0 );
509: #endif
510: gl_Position = projectionMatrix * mvPosition;
511: 
512: 	#ifdef USE_LOGDEPTHBUF
513: 	gl_Position.z = log2(max( EPSILON, gl_Position.w + 1.0 )) * logDepthBufFC;
514: 	#ifdef USE_LOGDEPTHBUF_EXT
515: 		vFragDepth = 1.0 + gl_Position.w;
516: 	#else
517: 		gl_Position.z = (gl_Position.z - 1.0) * gl_Position.w;
518: 	#endif
519: #endif
520: 
521: 	#if NUM_CLIPPING_PLANES > 0 && ! defined( PHYSICAL ) && ! defined( PHONG )
522: 	vViewPosition = - mvPosition.xyz;
523: #endif
524: 
525: 	#if defined( USE_ENVMAP ) || defined( PHONG ) || defined( PHYSICAL ) || defined( LAMBERT ) || defined ( USE_SHADOWMAP )
526: 	#ifdef USE_SKINNING
527: 		vec4 worldPosition = modelMatrix * skinned;
528: 	#else
529: 		vec4 worldPosition = modelMatrix * vec4( transformed, 1.0 );
530: 	#endif
531: #endif
532: 
533: 	#ifdef USE_ENVMAP
534: 	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )
535: 		vWorldPosition = worldPosition.xyz;
536: 	#else
537: 		vec3 cameraToVertex = normalize( worldPosition.xyz - cameraPosition );
538: 		vec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
539: 		#ifdef ENVMAP_MODE_REFLECTION
540: 			vReflect = reflect( cameraToVertex, worldNormal );
541: 		#else
542: 			vReflect = refract( cameraToVertex, worldNormal, refractionRatio );
543: 		#endif
544: 	#endif
545: #endif
546: 
547: 	vec3 diffuse = vec3( 1.0 );
548: GeometricContext geometry;
549: geometry.position = mvPosition.xyz;
550: geometry.normal = normalize( transformedNormal );
551: geometry.viewDir = normalize( -mvPosition.xyz );
552: GeometricContext backGeometry;
553: backGeometry.position = geometry.position;
554: backGeometry.normal = -geometry.normal;
555: backGeometry.viewDir = geometry.viewDir;
556: vLightFront = vec3( 0.0 );
557: #ifdef DOUBLE_SIDED
558: 	vLightBack = vec3( 0.0 );
559: #endif
560: IncidentLight directLight;
561: float dotNL;
562: vec3 directLightColor_Diffuse;
563: #if 1 > 0
564: 	
565: 		getPointDirectLightIrradiance( pointLights[ 0 ], geometry, directLight );
566: 		dotNL = dot( geometry.normal, directLight.direction );
567: 		directLightColor_Diffuse = PI * directLight.color;
568: 		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
569: 		#ifdef DOUBLE_SIDED
570: 			vLightBack += saturate( -dotNL ) * directLightColor_Diffuse;
571: 		#endif
572: 	
573: #endif
574: #if 0 > 0
575: 	
576: #endif
577: #if 0 > 0
578: 	
579: #endif
580: #if 0 > 0
581: 	
582: #endif
583: 
584: 	#ifdef USE_SHADOWMAP
585: 	#if 0 > 0
586: 	
587: 	#endif
588: 	#if 0 > 0
589: 	
590: 	#endif
591: 	#if 1 > 0
592: 	
593: 		vPointShadowCoord[ 0 ] = pointShadowMatrix[ 0 ] * worldPosition;
594: 	
595: 	#endif
596: #endif
597: 
598: }
599:   1:84838:4
THREE.WebGLShader: gl.getShaderInfoLog() fragment WARNING: 0:1: extension 'GL_ARB_gpu_shader5' is not supported
 1: precision highp float;
2: precision highp int;
3: #define SHADER_NAME MeshLambertMaterial
4: #define GAMMA_FACTOR 2
5: #define NUM_CLIPPING_PLANES 0
6: #define UNION_CLIPPING_PLANES 0
7: uniform mat4 viewMatrix;
8: uniform vec3 cameraPosition;
9: #define TONE_MAPPING
10: #define saturate(a) clamp( a, 0.0, 1.0 )
11: uniform float toneMappingExposure;
12: uniform float toneMappingWhitePoint;
13: vec3 LinearToneMapping( vec3 color ) {
14:   return toneMappingExposure * color;
15: }
16: vec3 ReinhardToneMapping( vec3 color ) {
17:   color *= toneMappingExposure;
18:   return saturate( color / ( vec3( 1.0 ) + color ) );
19: }
20: #define Uncharted2Helper( x ) max( ( ( x * ( 0.15 * x + 0.10 * 0.50 ) + 0.20 * 0.02 ) / ( x * ( 0.15 * x + 0.50 ) + 0.20 * 0.30 ) ) - 0.02 / 0.30, vec3( 0.0 ) )
21: vec3 Uncharted2ToneMapping( vec3 color ) {
22:   color *= toneMappingExposure;
23:   return saturate( Uncharted2Helper( color ) / Uncharted2Helper( vec3( toneMappingWhitePoint ) ) );
24: }
25: vec3 OptimizedCineonToneMapping( vec3 color ) {
26:   color *= toneMappingExposure;
27:   color = max( vec3( 0.0 ), color - 0.004 );
28:   return pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );
29: }
30: 
31: vec3 toneMapping( vec3 color ) { return LinearToneMapping( color ); }
32: 
33: vec4 LinearToLinear( in vec4 value ) {
34:   return value;
35: }
36: vec4 GammaToLinear( in vec4 value, in float gammaFactor ) {
37:   return vec4( pow( value.xyz, vec3( gammaFactor ) ), value.w );
38: }
39: vec4 LinearToGamma( in vec4 value, in float gammaFactor ) {
40:   return vec4( pow( value.xyz, vec3( 1.0 / gammaFactor ) ), value.w );
41: }
42: vec4 sRGBToLinear( in vec4 value ) {
43:   return vec4( mix( pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), value.rgb * 0.0773993808, vec3( lessThanEqual( value.rgb, vec3( 0.04045 ) ) ) ), value.w );
44: }
45: vec4 LinearTosRGB( in vec4 value ) {
46:   return vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.w );
47: }
48: vec4 RGBEToLinear( in vec4 value ) {
49:   return vec4( value.rgb * exp2( value.a * 255.0 - 128.0 ), 1.0 );
50: }
51: vec4 LinearToRGBE( in vec4 value ) {
52:   float maxComponent = max( max( value.r, value.g ), value.b );
53:   float fExp = clamp( ceil( log2( maxComponent ) ), -128.0, 127.0 );
54:   return vec4( value.rgb / exp2( fExp ), ( fExp + 128.0 ) / 255.0 );
55: }
56: vec4 RGBMToLinear( in vec4 value, in float maxRange ) {
57:   return vec4( value.xyz * value.w * maxRange, 1.0 );
58: }
59: vec4 LinearToRGBM( in vec4 value, in float maxRange ) {
60:   float maxRGB = max( value.x, max( value.g, value.b ) );
61:   float M      = clamp( maxRGB / maxRange, 0.0, 1.0 );
62:   M            = ceil( M * 255.0 ) / 255.0;
63:   return vec4( value.rgb / ( M * maxRange ), M );
64: }
65: vec4 RGBDToLinear( in vec4 value, in float maxRange ) {
66:     return vec4( value.rgb * ( ( maxRange / 255.0 ) / value.a ), 1.0 );
67: }
68: vec4 LinearToRGBD( in vec4 value, in float maxRange ) {
69:     float maxRGB = max( value.x, max( value.g, value.b ) );
70:     float D      = max( maxRange / maxRGB, 1.0 );
71:     D            = min( floor( D ) / 255.0, 1.0 );
72:     return vec4( value.rgb * ( D * ( 255.0 / maxRange ) ), D );
73: }
74: const mat3 cLogLuvM = mat3( 0.2209, 0.3390, 0.4184, 0.1138, 0.6780, 0.7319, 0.0102, 0.1130, 0.2969 );
75: vec4 LinearToLogLuv( in vec4 value )  {
76:   vec3 Xp_Y_XYZp = value.rgb * cLogLuvM;
77:   Xp_Y_XYZp = max(Xp_Y_XYZp, vec3(1e-6, 1e-6, 1e-6));
78:   vec4 vResult;
79:   vResult.xy = Xp_Y_XYZp.xy / Xp_Y_XYZp.z;
80:   float Le = 2.0 * log2(Xp_Y_XYZp.y) + 127.0;
81:   vResult.w = fract(Le);
82:   vResult.z = (Le - (floor(vResult.w*255.0))/255.0)/255.0;
83:   return vResult;
84: }
85: const mat3 cLogLuvInverseM = mat3( 6.0014, -2.7008, -1.7996, -1.3320, 3.1029, -5.7721, 0.3008, -1.0882, 5.6268 );
86: vec4 LogLuvToLinear( in vec4 value ) {
87:   float Le = value.z * 255.0 + value.w;
88:   vec3 Xp_Y_XYZp;
89:   Xp_Y_XYZp.y = exp2((Le - 127.0) / 2.0);
90:   Xp_Y_XYZp.z = Xp_Y_XYZp.y / value.y;
91:   Xp_Y_XYZp.x = value.x * Xp_Y_XYZp.z;
92:   vec3 vRGB = Xp_Y_XYZp.rgb * cLogLuvInverseM;
93:   return vec4( max(vRGB, 0.0), 1.0 );
94: }
95: 
96: vec4 mapTexelToLinear( vec4 value ) { return LinearToLinear( value ); }
97: vec4 envMapTexelToLinear( vec4 value ) { return LinearToLinear( value ); }
98: vec4 emissiveMapTexelToLinear( vec4 value ) { return LinearToLinear( value ); }
99: vec4 linearToOutputTexel( vec4 value ) { return LinearToLinear( value ); }
100: 
101: uniform vec3 diffuse;
102: uniform vec3 emissive;
103: uniform float opacity;
104: varying vec3 vLightFront;
105: #ifdef DOUBLE_SIDED
106: 	varying vec3 vLightBack;
107: #endif
108: #define PI 3.14159265359
109: #define PI2 6.28318530718
110: #define RECIPROCAL_PI 0.31830988618
111: #define RECIPROCAL_PI2 0.15915494
112: #define LOG2 1.442695
113: #define EPSILON 1e-6
114: #define saturate(a) clamp( a, 0.0, 1.0 )
115: #define whiteCompliment(a) ( 1.0 - saturate( a ) )
116: float pow2( const in float x ) { return x*x; }
117: float pow3( const in float x ) { return x*x*x; }
118: float pow4( const in float x ) { float x2 = x*x; return x2*x2; }
119: float average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }
120: highp float rand( const in vec2 uv ) {
121: 	const highp float a = 12.9898, b = 78.233, c = 43758.5453;
122: 	highp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );
123: 	return fract(sin(sn) * c);
124: }
125: struct IncidentLight {
126: 	vec3 color;
127: 	vec3 direction;
128: 	bool visible;
129: };
130: struct ReflectedLight {
131: 	vec3 directDiffuse;
132: 	vec3 directSpecular;
133: 	vec3 indirectDiffuse;
134: 	vec3 indirectSpecular;
135: };
136: struct GeometricContext {
137: 	vec3 position;
138: 	vec3 normal;
139: 	vec3 viewDir;
140: };
141: vec3 transformDirection( in vec3 dir, in mat4 matrix ) {
142: 	return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );
143: }
144: vec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {
145: 	return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );
146: }
147: vec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {
148: 	float distance = dot( planeNormal, point - pointOnPlane );
149: 	return - distance * planeNormal + point;
150: }
151: float sideOfPlane( in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {
152: 	return sign( dot( point - pointOnPlane, planeNormal ) );
153: }
154: vec3 linePlaneIntersect( in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal ) {
155: 	return lineDirection * ( dot( planeNormal, pointOnPlane - pointOnLine ) / dot( planeNormal, lineDirection ) ) + pointOnLine;
156: }
157: 
158: vec3 packNormalToRGB( const in vec3 normal ) {
159:   return normalize( normal ) * 0.5 + 0.5;
160: }
161: vec3 unpackRGBToNormal( const in vec3 rgb ) {
162:   return 1.0 - 2.0 * rgb.xyz;
163: }
164: const float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;
165: const vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256.,  256. );
166: const vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );
167: const float ShiftRight8 = 1. / 256.;
168: vec4 packDepthToRGBA( const in float v ) {
169: 	vec4 r = vec4( fract( v * PackFactors ), v );
170: 	r.yzw -= r.xyz * ShiftRight8;	return r * PackUpscale;
171: }
172: float unpackRGBAToDepth( const in vec4 v ) {
173: 	return dot( v, UnpackFactors );
174: }
175: float viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {
176:   return ( viewZ + near ) / ( near - far );
177: }
178: float orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {
179:   return linearClipZ * ( near - far ) - near;
180: }
181: float viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {
182:   return (( near + viewZ ) * far ) / (( far - near ) * viewZ );
183: }
184: float perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {
185:   return ( near * far ) / ( ( far - near ) * invClipZ - far );
186: }
187: 
188: #ifdef USE_COLOR
189: 	varying vec3 vColor;
190: #endif
191: 
192: #if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )
193: 	varying vec2 vUv;
194: #endif
195: #if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
196: 	varying vec2 vUv2;
197: #endif
198: #ifdef USE_MAP
199: 	uniform sampler2D map;
200: #endif
201: 
202: #ifdef USE_ALPHAMAP
203: 	uniform sampler2D alphaMap;
204: #endif
205: 
206: #ifdef USE_AOMAP
207: 	uniform sampler2D aoMap;
208: 	uniform float aoMapIntensity;
209: #endif
210: #ifdef USE_LIGHTMAP
211: 	uniform sampler2D lightMap;
212: 	uniform float lightMapIntensity;
213: #endif
214: #ifdef USE_EMISSIVEMAP
215: 	uniform sampler2D emissiveMap;
216: #endif
217: 
218: #if defined( USE_ENVMAP ) || defined( PHYSICAL )
219: 	uniform float reflectivity;
220: 	uniform float envMapIntenstiy;
221: #endif
222: #ifdef USE_ENVMAP
223: 	#if ! defined( PHYSICAL ) && ( defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) )
224: 		varying vec3 vWorldPosition;
225: 	#endif
226: 	#ifdef ENVMAP_TYPE_CUBE
227: 		uniform samplerCube envMap;
228: 	#else
229: 		uniform sampler2D envMap;
230: 	#endif
231: 	uniform float flipEnvMap;
232: 	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( PHYSICAL )
233: 		uniform float refractionRatio;
234: 	#else
235: 		varying vec3 vReflect;
236: 	#endif
237: #endif
238: 
239: bool testLightInRange( const in float lightDistance, const in float cutoffDistance ) {
240: 	return any( bvec2( cutoffDistance == 0.0, lightDistance < cutoffDistance ) );
241: }
242: float punctualLightIntensityToIrradianceFactor( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {
243: 		if( decayExponent > 0.0 ) {
244: #if defined ( PHYSICALLY_CORRECT_LIGHTS )
245: 			float distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );
246: 			float maxDistanceCutoffFactor = pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );
247: 			return distanceFalloff * maxDistanceCutoffFactor;
248: #else
249: 			return pow( saturate( -lightDistance / cutoffDistance + 1.0 ), decayExponent );
250: #endif
251: 		}
252: 		return 1.0;
253: }
254: vec3 BRDF_Diffuse_Lambert( const in vec3 diffuseColor ) {
255: 	return RECIPROCAL_PI * diffuseColor;
256: }
257: vec3 F_Schlick( const in vec3 specularColor, const in float dotLH ) {
258: 	float fresnel = exp2( ( -5.55473 * dotLH - 6.98316 ) * dotLH );
259: 	return ( 1.0 - specularColor ) * fresnel + specularColor;
260: }
261: float G_GGX_Smith( const in float alpha, const in float dotNL, const in float dotNV ) {
262: 	float a2 = pow2( alpha );
263: 	float gl = dotNL + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );
264: 	float gv = dotNV + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );
265: 	return 1.0 / ( gl * gv );
266: }
267: float G_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {
268: 	float a2 = pow2( alpha );
269: 	float gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );
270: 	float gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );
271: 	return 0.5 / max( gv + gl, EPSILON );
272: }
273: float D_GGX( const in float alpha, const in float dotNH ) {
274: 	float a2 = pow2( alpha );
275: 	float denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;
276: 	return RECIPROCAL_PI * a2 / pow2( denom );
277: }
278: vec3 BRDF_Specular_GGX( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float roughness ) {
279: 	float alpha = pow2( roughness );
280: 	vec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );
281: 	float dotNL = saturate( dot( geometry.normal, incidentLight.direction ) );
282: 	float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );
283: 	float dotNH = saturate( dot( geometry.normal, halfDir ) );
284: 	float dotLH = saturate( dot( incidentLight.direction, halfDir ) );
285: 	vec3 F = F_Schlick( specularColor, dotLH );
286: 	float G = G_GGX_SmithCorrelated( alpha, dotNL, dotNV );
287: 	float D = D_GGX( alpha, dotNH );
288: 	return F * ( G * D );
289: }
290: vec3 BRDF_Specular_GGX_Environment( const in GeometricContext geometry, const in vec3 specularColor, const in float roughness ) {
291: 	float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );
292: 	const vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );
293: 	const vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );
294: 	vec4 r = roughness * c0 + c1;
295: 	float a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;
296: 	vec2 AB = vec2( -1.04, 1.04 ) * a004 + r.zw;
297: 	return specularColor * AB.x + AB.y;
298: }
299: float G_BlinnPhong_Implicit( ) {
300: 	return 0.25;
301: }
302: float D_BlinnPhong( const in float shininess, const in float dotNH ) {
303: 	return RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );
304: }
305: vec3 BRDF_Specular_BlinnPhong( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float shininess ) {
306: 	vec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );
307: 	float dotNH = saturate( dot( geometry.normal, halfDir ) );
308: 	float dotLH = saturate( dot( incidentLight.direction, halfDir ) );
309: 	vec3 F = F_Schlick( specularColor, dotLH );
310: 	float G = G_BlinnPhong_Implicit( );
311: 	float D = D_BlinnPhong( shininess, dotNH );
312: 	return F * ( G * D );
313: }
314: float GGXRoughnessToBlinnExponent( const in float ggxRoughness ) {
315: 	return ( 2.0 / pow2( ggxRoughness + 0.0001 ) - 2.0 );
316: }
317: float BlinnExponentToGGXRoughness( const in float blinnExponent ) {
318: 	return sqrt( 2.0 / ( blinnExponent + 2.0 ) );
319: }
320: 
321: uniform vec3 ambientLightColor;
322: vec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {
323: 	vec3 irradiance = ambientLightColor;
324: 	#ifndef PHYSICALLY_CORRECT_LIGHTS
325: 		irradiance *= PI;
326: 	#endif
327: 	return irradiance;
328: }
329: #if 0 > 0
330: 	struct DirectionalLight {
331: 		vec3 direction;
332: 		vec3 color;
333: 		int shadow;
334: 		float shadowBias;
335: 		float shadowRadius;
336: 		vec2 shadowMapSize;
337: 	};
338: 	uniform DirectionalLight directionalLights[ 0 ];
339: 	void getDirectionalDirectLightIrradiance( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight directLight ) {
340: 		directLight.color = directionalLight.color;
341: 		directLight.direction = directionalLight.direction;
342: 		directLight.visible = true;
343: 	}
344: #endif
345: #if 1 > 0
346: 	struct PointLight {
347: 		vec3 position;
348: 		vec3 color;
349: 		float distance;
350: 		float decay;
351: 		int shadow;
352: 		float shadowBias;
353: 		float shadowRadius;
354: 		vec2 shadowMapSize;
355: 	};
356: 	uniform PointLight pointLights[ 1 ];
357: 	void getPointDirectLightIrradiance( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight directLight ) {
358: 		vec3 lVector = pointLight.position - geometry.position;
359: 		directLight.direction = normalize( lVector );
360: 		float lightDistance = length( lVector );
361: 		if ( testLightInRange( lightDistance, pointLight.distance ) ) {
362: 			directLight.color = pointLight.color;
363: 			directLight.color *= punctualLightIntensityToIrradianceFactor( lightDistance, pointLight.distance, pointLight.decay );
364: 			directLight.visible = true;
365: 		} else {
366: 			directLight.color = vec3( 0.0 );
367: 			directLight.visible = false;
368: 		}
369: 	}
370: #endif
371: #if 0 > 0
372: 	struct SpotLight {
373: 		vec3 position;
374: 		vec3 direction;
375: 		vec3 color;
376: 		float distance;
377: 		float decay;
378: 		float coneCos;
379: 		float penumbraCos;
380: 		int shadow;
381: 		float shadowBias;
382: 		float shadowRadius;
383: 		vec2 shadowMapSize;
384: 	};
385: 	uniform SpotLight spotLights[ 0 ];
386: 	void getSpotDirectLightIrradiance( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight directLight  ) {
387: 		vec3 lVector = spotLight.position - geometry.position;
388: 		directLight.direction = normalize( lVector );
389: 		float lightDistance = length( lVector );
390: 		float angleCos = dot( directLight.direction, spotLight.direction );
391: 		if ( all( bvec2( angleCos > spotLight.coneCos, testLightInRange( lightDistance, spotLight.distance ) ) ) ) {
392: 			float spotEffect = smoothstep( spotLight.coneCos, spotLight.penumbraCos, angleCos );
393: 			directLight.color = spotLight.color;
394: 			directLight.color *= spotEffect * punctualLightIntensityToIrradianceFactor( lightDistance, spotLight.distance, spotLight.decay );
395: 			directLight.visible = true;
396: 		} else {
397: 			directLight.color = vec3( 0.0 );
398: 			directLight.visible = false;
399: 		}
400: 	}
401: #endif
402: #if 0 > 0
403: 	struct HemisphereLight {
404: 		vec3 direction;
405: 		vec3 skyColor;
406: 		vec3 groundColor;
407: 	};
408: 	uniform HemisphereLight hemisphereLights[ 0 ];
409: 	vec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in GeometricContext geometry ) {
410: 		float dotNL = dot( geometry.normal, hemiLight.direction );
411: 		float hemiDiffuseWeight = 0.5 * dotNL + 0.5;
412: 		vec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );
413: 		#ifndef PHYSICALLY_CORRECT_LIGHTS
414: 			irradiance *= PI;
415: 		#endif
416: 		return irradiance;
417: 	}
418: #endif
419: #if defined( USE_ENVMAP ) && defined( PHYSICAL )
420: 	vec3 getLightProbeIndirectIrradiance( const in GeometricContext geometry, const in int maxMIPLevel ) {
421: 		#ifdef DOUBLE_SIDED
422: 	float flipNormal = ( float( gl_FrontFacing ) * 2.0 - 1.0 );
423: #else
424: 	float flipNormal = 1.0;
425: #endif
426: 
427: 		vec3 worldNormal = inverseTransformDirection( geometry.normal, viewMatrix );
428: 		#ifdef ENVMAP_TYPE_CUBE
429: 			vec3 queryVec = flipNormal * vec3( flipEnvMap * worldNormal.x, worldNormal.yz );
430: 			#ifdef TEXTURE_LOD_EXT
431: 				vec4 envMapColor = textureCubeLodEXT( envMap, queryVec, float( maxMIPLevel ) );
432: 			#else
433: 				vec4 envMapColor = textureCube( envMap, queryVec, float( maxMIPLevel ) );
434: 			#endif
435: 			envMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;
436: 		#elif defined( ENVMAP_TYPE_CUBE_UV )
437: 			vec3 queryVec = flipNormal * vec3( flipEnvMap * worldNormal.x, worldNormal.yz );
438: 			vec4 envMapColor = textureCubeUV( queryVec, 1.0 );
439: 		#else
440: 			vec4 envMapColor = vec4( 0.0 );
441: 		#endif
442: 		return PI * envMapColor.rgb * envMapIntensity;
443: 	}
444: 	float getSpecularMIPLevel( const in float blinnShininessExponent, const in int maxMIPLevel ) {
445: 		float maxMIPLevelScalar = float( maxMIPLevel );
446: 		float desiredMIPLevel = maxMIPLevelScalar - 0.79248 - 0.5 * log2( pow2( blinnShininessExponent ) + 1.0 );
447: 		return clamp( desiredMIPLevel, 0.0, maxMIPLevelScalar );
448: 	}
449: 	vec3 getLightProbeIndirectRadiance( const in GeometricContext geometry, const in float blinnShininessExponent, const in int maxMIPLevel ) {
450: 		#ifdef ENVMAP_MODE_REFLECTION
451: 			vec3 reflectVec = reflect( -geometry.viewDir, geometry.normal );
452: 		#else
453: 			vec3 reflectVec = refract( -geometry.viewDir, geometry.normal, refractionRatio );
454: 		#endif
455: 		#ifdef DOUBLE_SIDED
456: 	float flipNormal = ( float( gl_FrontFacing ) * 2.0 - 1.0 );
457: #else
458: 	float flipNormal = 1.0;
459: #endif
460: 
461: 		reflectVec = inverseTransformDirection( reflectVec, viewMatrix );
462: 		float specularMIPLevel = getSpecularMIPLevel( blinnShininessExponent, maxMIPLevel );
463: 		#ifdef ENVMAP_TYPE_CUBE
464: 			vec3 queryReflectVec = flipNormal * vec3( flipEnvMap * reflectVec.x, reflectVec.yz );
465: 			#ifdef TEXTURE_LOD_EXT
466: 				vec4 envMapColor = textureCubeLodEXT( envMap, queryReflectVec, specularMIPLevel );
467: 			#else
468: 				vec4 envMapColor = textureCube( envMap, queryReflectVec, specularMIPLevel );
469: 			#endif
470: 			envMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;
471: 		#elif defined( ENVMAP_TYPE_CUBE_UV )
472: 			vec3 queryReflectVec = flipNormal * vec3( flipEnvMap * reflectVec.x, reflectVec.yz );
473: 			vec4 envMapColor = textureCubeUV(queryReflectVec, BlinnExponentToGGXRoughness(blinnShininessExponent));
474: 		#elif defined( ENVMAP_TYPE_EQUIREC )
475: 			vec2 sampleUV;
476: 			sampleUV.y = saturate( flipNormal * reflectVec.y * 0.5 + 0.5 );
477: 			sampleUV.x = atan( flipNormal * reflectVec.z, flipNormal * reflectVec.x ) * RECIPROCAL_PI2 + 0.5;
478: 			#ifdef TEXTURE_LOD_EXT
479: 				vec4 envMapColor = texture2DLodEXT( envMap, sampleUV, specularMIPLevel );
480: 			#else
481: 				vec4 envMapColor = texture2D( envMap, sampleUV, specularMIPLevel );
482: 			#endif
483: 			envMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;
484: 		#elif defined( ENVMAP_TYPE_SPHERE )
485: 			vec3 reflectView = flipNormal * normalize( ( viewMatrix * vec4( reflectVec, 0.0 ) ).xyz + vec3( 0.0,0.0,1.0 ) );
486: 			#ifdef TEXTURE_LOD_EXT
487: 				vec4 envMapColor = texture2DLodEXT( envMap, reflectView.xy * 0.5 + 0.5, specularMIPLevel );
488: 			#else
489: 				vec4 envMapColor = texture2D( envMap, reflectView.xy * 0.5 + 0.5, specularMIPLevel );
490: 			#endif
491: 			envMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;
492: 		#endif
493: 		return envMapColor.rgb * envMapIntensity;
494: 	}
495: #endif
496: 
497: #ifdef USE_FOG
498: 	uniform vec3 fogColor;
499: 	#ifdef FOG_EXP2
500: 		uniform float fogDensity;
501: 	#else
502: 		uniform float fogNear;
503: 		uniform float fogFar;
504: 	#endif
505: #endif
506: #ifdef USE_SHADOWMAP
507: 	#if 0 > 0
508: 		uniform sampler2D directionalShadowMap[ 0 ];
509: 		varying vec4 vDirectionalShadowCoord[ 0 ];
510: 	#endif
511: 	#if 0 > 0
512: 		uniform sampler2D spotShadowMap[ 0 ];
513: 		varying vec4 vSpotShadowCoord[ 0 ];
514: 	#endif
515: 	#if 1 > 0
516: 		uniform sampler2D pointShadowMap[ 1 ];
517: 		varying vec4 vPointShadowCoord[ 1 ];
518: 	#endif
519: 	float texture2DCompare( sampler2D depths, vec2 uv, float compare ) {
520: 		return step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );
521: 	}
522: 	float texture2DShadowLerp( sampler2D depths, vec2 size, vec2 uv, float compare ) {
523: 		const vec2 offset = vec2( 0.0, 1.0 );
524: 		vec2 texelSize = vec2( 1.0 ) / size;
525: 		vec2 centroidUV = floor( uv * size + 0.5 ) / size;
526: 		float lb = texture2DCompare( depths, centroidUV + texelSize * offset.xx, compare );
527: 		float lt = texture2DCompare( depths, centroidUV + texelSize * offset.xy, compare );
528: 		float rb = texture2DCompare( depths, centroidUV + texelSize * offset.yx, compare );
529: 		float rt = texture2DCompare( depths, centroidUV + texelSize * offset.yy, compare );
530: 		vec2 f = fract( uv * size + 0.5 );
531: 		float a = mix( lb, lt, f.y );
532: 		float b = mix( rb, rt, f.y );
533: 		float c = mix( a, b, f.x );
534: 		return c;
535: 	}
536: 	float getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {
537: 		shadowCoord.xyz /= shadowCoord.w;
538: 		shadowCoord.z += shadowBias;
539: 		bvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );
540: 		bool inFrustum = all( inFrustumVec );
541: 		bvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );
542: 		bool frustumTest = all( frustumTestVec );
543: 		if ( frustumTest ) {
544: 		#if defined( SHADOWMAP_TYPE_PCF )
545: 			vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
546: 			float dx0 = - texelSize.x * shadowRadius;
547: 			float dy0 = - texelSize.y * shadowRadius;
548: 			float dx1 = + texelSize.x * shadowRadius;
549: 			float dy1 = + texelSize.y * shadowRadius;
550: 			return (
551: 				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +
552: 				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +
553: 				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +
554: 				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +
555: 				texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +
556: 				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +
557: 				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +
558: 				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +
559: 				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )
560: 			) * ( 1.0 / 9.0 );
561: 		#elif defined( SHADOWMAP_TYPE_PCF_SOFT )
562: 			vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
563: 			float dx0 = - texelSize.x * shadowRadius;
564: 			float dy0 = - texelSize.y * shadowRadius;
565: 			float dx1 = + texelSize.x * shadowRadius;
566: 			float dy1 = + texelSize.y * shadowRadius;
567: 			return (
568: 				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +
569: 				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +
570: 				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +
571: 				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +
572: 				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy, shadowCoord.z ) +
573: 				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +
574: 				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +
575: 				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +
576: 				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )
577: 			) * ( 1.0 / 9.0 );
578: 		#else
579: 			return texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );
580: 		#endif
581: 		}
582: 		return 1.0;
583: 	}
584: 	vec2 cubeToUV( vec3 v, float texelSizeY ) {
585: 		vec3 absV = abs( v );
586: 		float scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );
587: 		absV *= scaleToCube;
588: 		v *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );
589: 		vec2 planar = v.xy;
590: 		float almostATexel = 1.5 * texelSizeY;
591: 		float almostOne = 1.0 - almostATexel;
592: 		if ( absV.z >= almostOne ) {
593: 			if ( v.z > 0.0 )
594: 				planar.x = 4.0 - v.x;
595: 		} else if ( absV.x >= almostOne ) {
596: 			float signX = sign( v.x );
597: 			planar.x = v.z * signX + 2.0 * signX;
598: 		} else if ( absV.y >= almostOne ) {
599: 			float signY = sign( v.y );
600: 			planar.x = v.x + 2.0 * signY + 2.0;
601: 			planar.y = v.z * signY - 2.0;
602: 		}
603: 		return vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );
604: 	}
605: 	float getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {
606: 		vec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );
607: 		vec3 lightToPosition = shadowCoord.xyz;
608: 		vec3 bd3D = normalize( lightToPosition );
609: 		float dp = ( length( lightToPosition ) - shadowBias ) / 1000.0;
610: 		#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT )
611: 			vec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;
612: 			return (
613: 				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +
614: 				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +
615: 				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +
616: 				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +
617: 				texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +
618: 				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +
619: 				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +
620: 				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +
621: 				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )
622: 			) * ( 1.0 / 9.0 );
623: 		#else
624: 			return texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );
625: 		#endif
626: 	}
627: #endif
628: 
629: float getShadowMask() {
630: 	float shadow = 1.0;
631: 	#ifdef USE_SHADOWMAP
632: 	#if 0 > 0
633: 	DirectionalLight directionalLight;
634: 	
635: 	#endif
636: 	#if 0 > 0
637: 	SpotLight spotLight;
638: 	
639: 	#endif
640: 	#if 1 > 0
641: 	PointLight pointLight;
642: 	
643: 		pointLight = pointLights[ 0 ];
644: 		shadow *= bool( pointLight.shadow ) ? getPointShadow( pointShadowMap[ 0 ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ 0 ] ) : 1.0;
645: 	
646: 	#endif
647: 	#endif
648: 	return shadow;
649: }
650: 
651: #ifdef USE_SPECULARMAP
652: 	uniform sampler2D specularMap;
653: #endif
654: #ifdef USE_LOGDEPTHBUF
655: 	uniform float logDepthBufFC;
656: 	#ifdef USE_LOGDEPTHBUF_EXT
657: 		varying float vFragDepth;
658: 	#endif
659: #endif
660: 
661: #if NUM_CLIPPING_PLANES > 0
662: 	#if ! defined( PHYSICAL ) && ! defined( PHONG )
663: 		varying vec3 vViewPosition;
664: 	#endif
665: 	uniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];
666: #endif
667: 
668: void main() {
669: 	#if NUM_CLIPPING_PLANES > 0
670: 	for ( int i = 0; i < UNION_CLIPPING_PLANES; ++ i ) {
671: 		vec4 plane = clippingPlanes[ i ];
672: 		if ( dot( vViewPosition, plane.xyz ) > plane.w ) discard;
673: 	}
674: 		
675: 	#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES
676: 		bool clipped = true;
677: 		for ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; ++ i ) {
678: 			vec4 plane = clippingPlanes[ i ];
679: 			clipped = ( dot( vViewPosition, plane.xyz ) > plane.w ) && clipped;
680: 		}
681: 		if ( clipped ) discard;
682: 	
683: 	#endif
684: #endif
685: 
686: 	vec4 diffuseColor = vec4( diffuse, opacity );
687: 	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
688: 	vec3 totalEmissiveRadiance = emissive;
689: 	#if defined(USE_LOGDEPTHBUF) && defined(USE_LOGDEPTHBUF_EXT)
690: 	gl_FragDepthEXT = log2(vFragDepth) * logDepthBufFC * 0.5;
691: #endif
692: 	#ifdef USE_MAP
693: 	vec4 texelColor = texture2D( map, vUv );
694: 	texelColor = mapTexelToLinear( texelColor );
695: 	diffuseColor *= texelColor;
696: #endif
697: 
698: 	#ifdef USE_COLOR
699: 	diffuseColor.rgb *= vColor;
700: #endif
701: 	#ifdef USE_ALPHAMAP
702: 	diffuseColor.a *= texture2D( alphaMap, vUv ).g;
703: #endif
704: 
705: 	#ifdef ALPHATEST
706: 	if ( diffuseColor.a < ALPHATEST ) discard;
707: #endif
708: 
709: 	float specularStrength;
710: #ifdef USE_SPECULARMAP
711: 	vec4 texelSpecular = texture2D( specularMap, vUv );
712: 	specularStrength = texelSpecular.r;
713: #else
714: 	specularStrength = 1.0;
715: #endif
716: 	#ifdef USE_EMISSIVEMAP
717: 	vec4 emissiveColor = texture2D( emissiveMap, vUv );
718: 	emissiveColor.rgb = emissiveMapTexelToLinear( emissiveColor ).rgb;
719: 	totalEmissiveRadiance *= emissiveColor.rgb;
720: #endif
721: 
722: 	reflectedLight.indirectDiffuse = getAmbientLightIrradiance( ambientLightColor );
723: 	#ifdef USE_LIGHTMAP
724: 	reflectedLight.indirectDiffuse += PI * texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;
725: #endif
726: 
727: 	reflectedLight.indirectDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb );
728: 	#ifdef DOUBLE_SIDED
729: 		reflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;
730: 	#else
731: 		reflectedLight.directDiffuse = vLightFront;
732: 	#endif
733: 	reflectedLight.directDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb ) * getShadowMask();
734: 	#ifdef USE_AOMAP
735: 	float ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;
736: 	reflectedLight.indirectDiffuse *= ambientOcclusion;
737: 	#if defined( USE_ENVMAP ) && defined( PHYSICAL )
738: 		float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );
739: 		reflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.specularRoughness );
740: 	#endif
741: #endif
742: 
743: 	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
744: 	#ifdef DOUBLE_SIDED
745: 	float flipNormal = ( float( gl_FrontFacing ) * 2.0 - 1.0 );
746: #else
747: 	float flipNormal = 1.0;
748: #endif
749: 
750: 	#ifdef USE_ENVMAP
751: 	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )
752: 		vec3 cameraToVertex = normalize( vWorldPosition - cameraPosition );
753: 		vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
754: 		#ifdef ENVMAP_MODE_REFLECTION
755: 			vec3 reflectVec = reflect( cameraToVertex, worldNormal );
756: 		#else
757: 			vec3 reflectVec = refract( cameraToVertex, worldNormal, refractionRatio );
758: 		#endif
759: 	#else
760: 		vec3 reflectVec = vReflect;
761: 	#endif
762: 	#ifdef ENVMAP_TYPE_CUBE
763: 		vec4 envColor = textureCube( envMap, flipNormal * vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );
764: 	#elif defined( ENVMAP_TYPE_EQUIREC )
765: 		vec2 sampleUV;
766: 		sampleUV.y = saturate( flipNormal * reflectVec.y * 0.5 + 0.5 );
767: 		sampleUV.x = atan( flipNormal * reflectVec.z, flipNormal * reflectVec.x ) * RECIPROCAL_PI2 + 0.5;
768: 		vec4 envColor = texture2D( envMap, sampleUV );
769: 	#elif defined( ENVMAP_TYPE_SPHERE )
770: 		vec3 reflectView = flipNormal * normalize( ( viewMatrix * vec4( reflectVec, 0.0 ) ).xyz + vec3( 0.0, 0.0, 1.0 ) );
771: 		vec4 envColor = texture2D( envMap, reflectView.xy * 0.5 + 0.5 );
772: 	#else
773: 		vec4 envColor = vec4( 0.0 );
774: 	#endif
775: 	envColor = envMapTexelToLinear( envColor );
776: 	#ifdef ENVMAP_BLENDING_MULTIPLY
777: 		outgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );
778: 	#elif defined( ENVMAP_BLENDING_MIX )
779: 		outgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );
780: 	#elif defined( ENVMAP_BLENDING_ADD )
781: 		outgoingLight += envColor.xyz * specularStrength * reflectivity;
782: 	#endif
783: #endif
784: 
785: 	gl_FragColor = vec4( outgoingLight, diffuseColor.a );
786: 	#ifdef PREMULTIPLIED_ALPHA
787: 	gl_FragColor.rgb *= gl_FragColor.a;
788: #endif
789: 
790: 	#if defined( TONE_MAPPING )
791:   gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );
792: #endif
793: 
794: 	  gl_FragColor = linearToOutputTexel( gl_FragColor );
795: 
796: 	#ifdef USE_FOG
797: 	#ifdef USE_LOGDEPTHBUF_EXT
798: 		float depth = gl_FragDepthEXT / gl_FragCoord.w;
799: 	#else
800: 		float depth = gl_FragCoord.z / gl_FragCoord.w;
801: 	#endif
802: 	#ifdef FOG_EXP2
803: 		float fogFactor = whiteCompliment( exp2( - fogDensity * fogDensity * depth * depth * LOG2 ) );
804: 	#else
805: 		float fogFactor = smoothstep( fogNear, fogFar, depth );
806: 	#endif
807: 	gl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );
808: #endif
809: 
810: }
811:
@mrdoob
Copy link
Owner

mrdoob commented Dec 8, 2016

I think you should report this to Mozilla instead.

@mrdoob mrdoob closed this as completed Dec 8, 2016
@makc makc mentioned this issue Jan 11, 2017
Closed
@Ithamar
Copy link
Contributor

Ithamar commented Apr 10, 2017

This exact warning is now triggering on latest Safari (desktop) versions as well.

@mrdoob
Copy link
Owner

mrdoob commented Apr 12, 2017

#9716

@ajyand
Copy link

ajyand commented Apr 17, 2017

Strangely I did not face this issue while in Firefox 52 on Ubuntu (Unity) 16.10 but started facing the issue in Firefox 52 on Ubuntu-Gnome 17.04.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
Duplicate
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
4 participants
@mrdoob @Ithamar @therocketforever @ajyand