Spaces:
Running
Running
| import { ShaderChunk } from 'three'; | |
| const CSMShader = { | |
| lights_fragment_begin: /* glsl */` | |
| vec3 geometryPosition = - vViewPosition; | |
| vec3 geometryNormal = normal; | |
| vec3 geometryViewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition ); | |
| vec3 geometryClearcoatNormal = vec3( 0.0 ); | |
| #ifdef USE_CLEARCOAT | |
| geometryClearcoatNormal = clearcoatNormal; | |
| #endif | |
| #ifdef USE_IRIDESCENCE | |
| float dotNVi = saturate( dot( normal, geometryViewDir ) ); | |
| if ( material.iridescenceThickness == 0.0 ) { | |
| material.iridescence = 0.0; | |
| } else { | |
| material.iridescence = saturate( material.iridescence ); | |
| } | |
| if ( material.iridescence > 0.0 ) { | |
| material.iridescenceFresnel = evalIridescence( 1.0, material.iridescenceIOR, dotNVi, material.iridescenceThickness, material.specularColor ); | |
| // Iridescence F0 approximation | |
| material.iridescenceF0 = Schlick_to_F0( material.iridescenceFresnel, 1.0, dotNVi ); | |
| } | |
| #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 ]; | |
| getPointLightInfo( pointLight, geometryPosition, directLight ); | |
| #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS ) | |
| pointLightShadow = pointLightShadows[ i ]; | |
| directLight.color *= ( directLight.visible && receiveShadow ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0; | |
| #endif | |
| RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight ); | |
| } | |
| #pragma unroll_loop_end | |
| #endif | |
| #if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct ) | |
| SpotLight spotLight; | |
| vec4 spotColor; | |
| vec3 spotLightCoord; | |
| bool inSpotLightMap; | |
| #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 ]; | |
| getSpotLightInfo( spotLight, geometryPosition, directLight ); | |
| // spot lights are ordered [shadows with maps, shadows without maps, maps without shadows, none] | |
| #if ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS ) | |
| #define SPOT_LIGHT_MAP_INDEX UNROLLED_LOOP_INDEX | |
| #elif ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS ) | |
| #define SPOT_LIGHT_MAP_INDEX NUM_SPOT_LIGHT_MAPS | |
| #else | |
| #define SPOT_LIGHT_MAP_INDEX ( UNROLLED_LOOP_INDEX - NUM_SPOT_LIGHT_SHADOWS + NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS ) | |
| #endif | |
| #if ( SPOT_LIGHT_MAP_INDEX < NUM_SPOT_LIGHT_MAPS ) | |
| spotLightCoord = vSpotLightCoord[ i ].xyz / vSpotLightCoord[ i ].w; | |
| inSpotLightMap = all( lessThan( abs( spotLightCoord * 2. - 1. ), vec3( 1.0 ) ) ); | |
| spotColor = texture2D( spotLightMap[ SPOT_LIGHT_MAP_INDEX ], spotLightCoord.xy ); | |
| directLight.color = inSpotLightMap ? directLight.color * spotColor.rgb : directLight.color; | |
| #endif | |
| #undef SPOT_LIGHT_MAP_INDEX | |
| #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS ) | |
| spotLightShadow = spotLightShadows[ i ]; | |
| directLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowIntensity, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotLightCoord[ i ] ) : 1.0; | |
| #endif | |
| RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, 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 ]; | |
| getDirectionalLightInfo( directionalLight, directLight ); | |
| #if ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS ) | |
| // 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( 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 ); | |
| vec3 prevColor = directLight.color; | |
| directionalLightShadow = directionalLightShadows[ i ]; | |
| directLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowIntensity, 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, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, 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 ); | |
| } | |
| #endif | |
| } | |
| #pragma unroll_loop_end | |
| #elif defined (USE_SHADOWMAP) | |
| #pragma unroll_loop_start | |
| for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) { | |
| directionalLight = directionalLights[ i ]; | |
| getDirectionalLightInfo( directionalLight, directLight ); | |
| #if ( 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 *= ( directLight.visible && receiveShadow ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowIntensity, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0; | |
| if(linearDepth >= CSM_cascades[UNROLLED_LOOP_INDEX].x && (linearDepth < CSM_cascades[UNROLLED_LOOP_INDEX].y || UNROLLED_LOOP_INDEX == CSM_CASCADES - 1)) RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight ); | |
| #endif | |
| } | |
| #pragma unroll_loop_end | |
| #elif ( NUM_DIR_LIGHT_SHADOWS > 0 ) | |
| // note: no loop here - all CSM lights are in fact one light only | |
| getDirectionalLightInfo( directionalLights[0], directLight ); | |
| RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight ); | |
| #endif | |
| #if ( NUM_DIR_LIGHTS > NUM_DIR_LIGHT_SHADOWS) | |
| // compute the lights not casting shadows (if any) | |
| #pragma unroll_loop_start | |
| for ( int i = NUM_DIR_LIGHT_SHADOWS; i < NUM_DIR_LIGHTS; i ++ ) { | |
| directionalLight = directionalLights[ i ]; | |
| getDirectionalLightInfo( directionalLight, directLight ); | |
| RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, 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 ]; | |
| getDirectionalLightInfo( directionalLight, directLight ); | |
| #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS ) | |
| directionalLightShadow = directionalLightShadows[ i ]; | |
| directLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowIntensity, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0; | |
| #endif | |
| RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, 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, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight ); | |
| } | |
| #pragma unroll_loop_end | |
| #endif | |
| #if defined( RE_IndirectDiffuse ) | |
| vec3 iblIrradiance = vec3( 0.0 ); | |
| vec3 irradiance = getAmbientLightIrradiance( ambientLightColor ); | |
| #if defined( USE_LIGHT_PROBES ) | |
| irradiance += getLightProbeIrradiance( lightProbe, geometryNormal ); | |
| #endif | |
| #if ( NUM_HEMI_LIGHTS > 0 ) | |
| #pragma unroll_loop_start | |
| for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) { | |
| irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometryNormal ); | |
| } | |
| #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 | |
| ` + ShaderChunk.lights_pars_begin | |
| }; | |
| export { CSMShader }; | |