text: /**
   * Generated from 'examples/jsm/csm/Shader.js'
   */
  
  (function (global, factory) {
  	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('three')) :
  	typeof define === 'function' && define.amd ? define(['three'], factory) :
  	(global = global || self, global.THREE = factory(global.THREE));
  }(this, (function (THREE) { 'use strict';
  
  	/**
  	 * @author vHawk / https://github.com/vHawk/
  	 */
  
  	var Shader = {
  		lights_fragment_begin: /* glsl */`
  GeometricContext geometry;
  
  geometry.position = - vViewPosition;
  geometry.normal = normal;
  geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );
  
  #ifdef CLEARCOAT
  
  	geometry.clearcoatNormal = clearcoatNormal;
  
  #endif
  
  IncidentLight directLight;
  
  #if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )
  
  	PointLight pointLight;
  	#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0
  	PointLightShadow pointLightShadow;
  	#endif
  
  	#pragma unroll_loop_start
  	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
  
  		pointLight = pointLights[ i ];
  
  		getPointDirectLightIrradiance( pointLight, geometry, directLight );
  
  		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )
  		pointLightShadow = pointLightShadows[ i ];
  		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;
  		#endif
  
  		RE_Direct( directLight, geometry, material, reflectedLight );
  
  	}
  	#pragma unroll_loop_end
  
  #endif
  
  #if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )
  
  	SpotLight spotLight;
  	#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0
  	SpotLightShadow spotLightShadow;
  	#endif
  
  	#pragma unroll_loop_start
  	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
  
  		spotLight = spotLights[ i ];
  
  		getSpotDirectLightIrradiance( spotLight, geometry, directLight );
  
  		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )
  		spotLightShadow = spotLightShadows[ i ];
  		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;
  		#endif
  
  		RE_Direct( directLight, geometry, material, reflectedLight );
  
  	}
  	#pragma unroll_loop_end
  
  #endif
  
  #if ( NUM_DIR_LIGHTS > 0) && defined( RE_Direct ) && defined( USE_CSM ) && defined( CSM_CASCADES )
  
  	DirectionalLight directionalLight;
  	float linearDepth = (vViewPosition.z) / (shadowFar - cameraNear);
  	#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0
  	DirectionalLightShadow directionalLightShadow;
  	#endif
  
  	#if defined( USE_SHADOWMAP ) && defined( CSM_FADE )
  	vec2 cascade;
  	float cascadeCenter;
  	float closestEdge;
  	float margin;
  	float csmx;
  	float csmy;
  
  	#pragma unroll_loop_start
  	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
  
  		directionalLight = directionalLights[ i ];
  		getDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );
  
  		// NOTE: Depth gets larger away from the camera.
  		// cascade.x is closer, cascade.y is further
  		cascade = CSM_cascades[ i ];
  		cascadeCenter = ( cascade.x + cascade.y ) / 2.0;
  		closestEdge = linearDepth < cascadeCenter ? cascade.x : cascade.y;
  		margin = 0.25 * pow( closestEdge, 2.0 );
  		csmx = cascade.x - margin / 2.0;
  		csmy = cascade.y + margin / 2.0;
  		if( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS && linearDepth >= csmx && ( linearDepth < csmy || UNROLLED_LOOP_INDEX == CSM_CASCADES - 1 ) ) {
  
  			float dist = min( linearDepth - csmx, csmy - linearDepth );
  			float ratio = clamp( dist / margin, 0.0, 1.0 );
  			if( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS ) {
  
  				vec3 prevColor = directLight.color;
  				directionalLightShadow = directionalLightShadows[ i ];
  				directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
  
  				bool shouldFadeLastCascade = UNROLLED_LOOP_INDEX == CSM_CASCADES - 1 && linearDepth > cascadeCenter;
  				directLight.color = mix( prevColor, directLight.color, shouldFadeLastCascade ? ratio : 1.0 );
  
  			}
  
  			ReflectedLight prevLight = reflectedLight;
  			RE_Direct( directLight, geometry, material, reflectedLight );
  
  			bool shouldBlend = UNROLLED_LOOP_INDEX != CSM_CASCADES - 1 || UNROLLED_LOOP_INDEX == CSM_CASCADES - 1 && linearDepth < cascadeCenter;
  			float blendRatio = shouldBlend ? ratio : 1.0;
  
  			reflectedLight.directDiffuse = mix( prevLight.directDiffuse, reflectedLight.directDiffuse, blendRatio );
  			reflectedLight.directSpecular = mix( prevLight.directSpecular, reflectedLight.directSpecular, blendRatio );
  			reflectedLight.indirectDiffuse = mix( prevLight.indirectDiffuse, reflectedLight.indirectDiffuse, blendRatio );
  			reflectedLight.indirectSpecular = mix( prevLight.indirectSpecular, reflectedLight.indirectSpecular, blendRatio );
  
  		}
  
  	}
  	#pragma unroll_loop_end
  	#else
  
  	#pragma unroll_loop_start
  	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
  
  		directionalLight = directionalLights[ i ];
  		getDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );
  
  		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )
  
  		directionalLightShadow = directionalLightShadows[ i ];
  		if(linearDepth >= CSM_cascades[UNROLLED_LOOP_INDEX].x && linearDepth < CSM_cascades[UNROLLED_LOOP_INDEX].y) directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
  
  		#endif
  
  		if(linearDepth >= CSM_cascades[UNROLLED_LOOP_INDEX].x && (linearDepth < CSM_cascades[UNROLLED_LOOP_INDEX].y || UNROLLED_LOOP_INDEX == CSM_CASCADES - 1)) RE_Direct( directLight, geometry, material, reflectedLight );
  
  	}
  	#pragma unroll_loop_end
  
  	#endif
  
  #endif
  
  
  #if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct ) && !defined( USE_CSM ) && !defined( CSM_CASCADES )
  
  	DirectionalLight directionalLight;
  	#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0
  	DirectionalLightShadow directionalLightShadow;
  	#endif
  
  	#pragma unroll_loop_start
  	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
  
  		directionalLight = directionalLights[ i ];
  
  		getDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );
  
  		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )
  		directionalLightShadow = directionalLightShadows[ i ];
  		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
  		#endif
  
  		RE_Direct( directLight, geometry, material, reflectedLight );
  
  	}
  	#pragma unroll_loop_end
  
  #endif
  
  #if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )
  
  	RectAreaLight rectAreaLight;
  
  	#pragma unroll_loop_start
  	for ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {
  
  		rectAreaLight = rectAreaLights[ i ];
  		RE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );
  
  	}
  	#pragma unroll_loop_end
  
  #endif
  
  #if defined( RE_IndirectDiffuse )
  
  	vec3 iblIrradiance = vec3( 0.0 );
  
  	vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );
  
  	irradiance += getLightProbeIrradiance( lightProbe, geometry );
  
  	#if ( NUM_HEMI_LIGHTS > 0 )
  
  		#pragma unroll_loop_start
  		for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
  
  			irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );
  
  		}
  		#pragma unroll_loop_end
  
  	#endif
  
  #endif
  
  #if defined( RE_IndirectSpecular )
  
  	vec3 radiance = vec3( 0.0 );
  	vec3 clearcoatRadiance = vec3( 0.0 );
  
  #endif
  `,
  		lights_pars_begin: /* glsl */`
  #if defined( USE_CSM ) && defined( CSM_CASCADES )
  uniform vec2 CSM_cascades[CSM_CASCADES];
  uniform float cameraNear;
  uniform float shadowFar;
  #endif
  	` + THREE.ShaderChunk.lights_pars_begin
  	};
  
  	return Shader;
  
  })));
  