@shapediver/viewer.rendering-engine.rendering-engine-threejs 3.19.3 → 3.20.1

package/dist/shaders/PCSS.js

@@ -1,127 +1,148 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.entry = exports.main = void 0;
+exports.getShadow = exports.main = void 0;
 exports.main = `
 
+// PCSS implementation
 uniform float lightSizeUV;
 uniform float blending;
 
-#ifdef SHADOWMAP_TYPE_PCF
+#if defined( SHADOWMAP_TYPE_BASIC )
 
-#define NEAR_PLANE 0.1
-#define NUM_SAMPLES 20
-#define NUM_RINGS 11
+#define PCSS_NEAR_PLANE 0.1
+#define PCSS_NUM_SAMPLES 20
+#define PCSS_NUM_RINGS 11
 
-vec2 poissonDisk[NUM_SAMPLES];
+vec2 pcssPoissonDisk[PCSS_NUM_SAMPLES];
 
-void initPoissonSamples( const in vec2 randomSeed ) {
-    float ANGLE_STEP = PI2 * float(NUM_RINGS) / float(NUM_SAMPLES);
-    float INV_NUM_SAMPLES = 1.0 / float(NUM_SAMPLES);
+void initPCSSPoissonSamples( const in vec2 randomSeed ) {
+    float angleStep = PI2 * float( PCSS_NUM_RINGS ) / float( PCSS_NUM_SAMPLES );
+    float invNumSamples = 1.0 / float( PCSS_NUM_SAMPLES );
 
-    // jsfiddle that shows sample pattern: https://jsfiddle.net/a16ff1p7/
-    float angle = rand(randomSeed) * PI2;
-    float radius = INV_NUM_SAMPLES;
+    float angle = rand( randomSeed ) * PI2;
+    float radius = invNumSamples;
     float radiusStep = radius;
 
-    for (int i = 0; i < int(NUM_SAMPLES); i++ ) {
-        poissonDisk[i] = vec2(cos(angle), sin(angle)) * pow(radius, 0.75);
+    for ( int i = 0; i < PCSS_NUM_SAMPLES; i ++ ) {
+        pcssPoissonDisk[ i ] = vec2( cos( angle ), sin( angle ) ) * pow( radius, 0.75 );
         radius += radiusStep;
-        angle += ANGLE_STEP;
+        angle += angleStep;
     }
 }
 
-float penumbraSize( const in float zReceiver, const in float zBlocker ) { // Parallel plane estimation
-    return (zReceiver - zBlocker) / zBlocker;
+float getPCSSDepth( sampler2D shadowMap, const in vec2 uv ) {
+    float depth = texture2D( shadowMap, uv ).r;
+
+    #ifdef USE_REVERSED_DEPTH_BUFFER
+        depth = 1.0 - depth;
+    #endif
+
+    return depth;
 }
 
-float findBlocker(sampler2D shadowMap, const in vec2 uv, const in float zReceiver ) {
-    // This uses similar triangles to compute what
-    // area of the shadow map we should search
-    float searchRadius = lightSizeUV * (zReceiver - NEAR_PLANE) / zReceiver;
+float getPCSSDepthCompare( sampler2D shadowMap, const in vec2 uv, const in float compare ) {
+    return step( compare, getPCSSDepth( shadowMap, uv ) );
+}
+
+float findPCSSBlocker( sampler2D shadowMap, const in vec2 uv, const in float zReceiver ) {
+    float searchRadius = lightSizeUV * ( zReceiver - PCSS_NEAR_PLANE ) / max( zReceiver, 0.0001 );
     float blockerDepthSum = 0.0;
     int numBlockers = 0;
 
-    for (int i = 0; i < int(NUM_SAMPLES); i++ ) {
-        float shadowMapDepth = unpackRGBAToDepth(texture2D(shadowMap, uv + poissonDisk[i] * searchRadius));
-        if (shadowMapDepth < zReceiver) {
+    for ( int i = 0; i < PCSS_NUM_SAMPLES; i ++ ) {
+        float shadowMapDepth = getPCSSDepth( shadowMap, uv + pcssPoissonDisk[ i ] * searchRadius );
+        if ( shadowMapDepth < zReceiver ) {
             blockerDepthSum += shadowMapDepth;
-            numBlockers++;
+            numBlockers ++;
         }
     }
 
-    if (numBlockers == 0) return -1.0;
+    if ( numBlockers == 0 ) return -1.0;
 
-    return blockerDepthSum / float(numBlockers);
+    return blockerDepthSum / float( numBlockers );
 }
 
-float PCF_Filter(sampler2D shadowMap, vec2 uv, float zReceiver, float filterRadius) {
-    float sum = 0.0;
-    for (int i = 0; i < int(NUM_SAMPLES); i++ ) {
-        float depth = unpackRGBAToDepth(texture2D(shadowMap, uv + poissonDisk[i] * filterRadius));
-        if (zReceiver <= depth) sum += 1.0;
+float getPCSSFilteredShadow( sampler2D shadowMap, const in vec2 uv, const in float zReceiver, const in float filterRadius ) {
+    float shadow = 0.0;
+
+    for ( int i = 0; i < PCSS_NUM_SAMPLES; i ++ ) {
+        shadow += getPCSSDepthCompare( shadowMap, uv + pcssPoissonDisk[ i ] * filterRadius, zReceiver );
     }
-    for (int i = 0; i < int(NUM_SAMPLES); i++ ) {
-        float depth = unpackRGBAToDepth(texture2D(shadowMap, uv + -poissonDisk[i].yx * filterRadius));
-        if (zReceiver <= depth) sum += 1.0;
+    for ( int i = 0; i < PCSS_NUM_SAMPLES; i ++ ) {
+        shadow += getPCSSDepthCompare( shadowMap, uv - pcssPoissonDisk[ i ].yx * filterRadius, zReceiver );
     }
-    return sum / (2.0 * float(NUM_SAMPLES));
-}
 
-float PCSS(sampler2D shadowMap, vec4 coords) {
-    vec2 uv = coords.xy;
-    float zReceiver = coords.z; // Assumed to be eye-space z in this code
+    return shadow / ( 2.0 * float( PCSS_NUM_SAMPLES ) );
+}
 
-    initPoissonSamples(uv);
-    // STEP 1: blocker search
-    float avgBlockerDepth = findBlocker(shadowMap, uv, zReceiver);
+float getPCSSShadow( sampler2D shadowMap, const in vec2 uv, const in float zReceiver ) {
+    initPCSSPoissonSamples( uv );
 
-    //There are no occluders so early out (this saves filtering)
-    if (avgBlockerDepth == -1.0) return 1.0;
+    float avgBlockerDepth = findPCSSBlocker( shadowMap, uv, zReceiver );
+    if ( avgBlockerDepth == -1.0 ) return 1.0;
 
-    // STEP 2: penumbra size
-    float penumbraRatio = penumbraSize(zReceiver, avgBlockerDepth);
-    float filterRadius = penumbraRatio * lightSizeUV * NEAR_PLANE / zReceiver;
+    float penumbraRatio = ( zReceiver - avgBlockerDepth ) / max( avgBlockerDepth, 0.0001 );
+    float filterRadius = penumbraRatio * lightSizeUV * PCSS_NEAR_PLANE / max( zReceiver, 0.0001 );
 
-    // STEP 3: filtering
-    //return avgBlockerDepth;
-    return PCF_Filter(shadowMap, uv, zReceiver, filterRadius);
+    return getPCSSFilteredShadow( shadowMap, uv, zReceiver, filterRadius );
 }
+
 #endif
 `;
-exports.entry = `
-// PCSS implementation
-vec2 texelSize = vec2( 1.0 / 1024.0 ); // Always use  1024 for consistency
-float dx = texelSize.x;
-float dy = texelSize.y;
-vec2 uv = shadowCoord.xy;
-vec2 f = fract( uv * shadowMapSize + 0.5 );
-uv -= f * texelSize;
-float shadow1 = (
-    texture2DCompare( shadowMap, uv, shadowCoord.z ) +
-    texture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +
-    texture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +
-    texture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +
-    mix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ), 
-         texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),
-         f.x ) +
-    mix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ), 
-         texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),
-         f.x ) +
-    mix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ), 
-         texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),
-         f.y ) +
-    mix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ), 
-         texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),
-         f.y ) +
-    mix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ), 
-              texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),
-              f.x ),
-         mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ), 
-              texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),
-              f.x ),
-         f.y )
-) * ( 1.0 / 9.0 );
-float shadow2 = PCSS( shadowMap, shadowCoord );
-shadow = shadow1 * (1.0 - blending) + blending * shadow2;
-            `;
+exports.getShadow = `
+float getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowIntensity, float shadowBias, float shadowRadius, vec4 shadowCoord ) {
+    float shadow = 1.0;
+
+    shadowCoord.xyz /= shadowCoord.w;
+
+    #ifdef USE_REVERSED_DEPTH_BUFFER
+        shadowCoord.z -= shadowBias;
+    #else
+        shadowCoord.z += shadowBias;
+    #endif
+
+    bool inFrustum = shadowCoord.x >= 0.0 && shadowCoord.x <= 1.0 && shadowCoord.y >= 0.0 && shadowCoord.y <= 1.0;
+    bool frustumTest = inFrustum && shadowCoord.z <= 1.0;
+
+    if ( frustumTest ) {
+        vec2 texelSize = vec2( 1.0 / 1024.0 );
+        float dx = texelSize.x;
+        float dy = texelSize.y;
+        vec2 uv = shadowCoord.xy;
+        vec2 f = fract( uv * shadowMapSize + 0.5 );
+        uv -= f * texelSize;
+
+        float pcfShadow = (
+            getPCSSDepthCompare( shadowMap, uv, shadowCoord.z ) +
+            getPCSSDepthCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +
+            getPCSSDepthCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +
+            getPCSSDepthCompare( shadowMap, uv + texelSize, shadowCoord.z ) +
+            mix( getPCSSDepthCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ),
+                 getPCSSDepthCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),
+                 f.x ) +
+            mix( getPCSSDepthCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ),
+                 getPCSSDepthCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),
+                 f.x ) +
+            mix( getPCSSDepthCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ),
+                 getPCSSDepthCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),
+                 f.y ) +
+            mix( getPCSSDepthCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ),
+                 getPCSSDepthCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),
+                 f.y ) +
+            mix( mix( getPCSSDepthCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ),
+                      getPCSSDepthCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),
+                      f.x ),
+                 mix( getPCSSDepthCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ),
+                      getPCSSDepthCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),
+                      f.x ),
+                 f.y )
+        ) * ( 1.0 / 9.0 );
+
+        float pcssShadow = getPCSSShadow( shadowMap, shadowCoord.xy, shadowCoord.z );
+        shadow = mix( pcfShadow, pcssShadow, blending );
+    }
+
+    return mix( 1.0, shadow, shadowIntensity );
+}
+`;
 //# sourceMappingURL=PCSS.js.map

package/dist/shaders/PCSS.js.map

@@ -1 +1 @@
-{"version":3,"file":"PCSS.js","sourceRoot":"","sources":["../../src/shaders/PCSS.ts"],"names":[],"mappings":";;;AAAa,QAAA,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsFnB,CAAC;AAEW,QAAA,KAAK,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAmCR,CAAC"}
+{"version":3,"file":"PCSS.js","sourceRoot":"","sources":["../../src/shaders/PCSS.ts"],"names":[],"mappings":";;;AAAa,QAAA,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuFnB,CAAC;AAEW,QAAA,SAAS,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuDxB,CAAC"}

package/dist/shaders/gem.d.ts

@@ -1,3 +1,3 @@
-export declare const vert = "\n#define STANDARD\nvarying vec3 vViewPosition;\n#ifdef USE_TRANSMISSION\n\tvarying vec3 vWorldPosition;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\n\n// CUSTOM START\nvarying vec3 frag_position;\nvarying vec3 frag_normal;\n// CUSTOM END\n\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphcolor_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n    #ifdef USE_TRANSMISSION\n        vWorldPosition = worldPosition.xyz;\n    #endif\n\n    // CUSTOM START\n    frag_position = position;\n    frag_normal = objectNormal;\n    // CUSTOM END\n}\n";
-export declare const frag = "\n#define STANDARD\n#ifdef PHYSICAL\n\t#define IOR\n\t#define SPECULAR\n#endif\n\n// CUSTOM START\n#ifdef USE_IMPURITYMAP\n\tuniform sampler2D impurityMap;\n#endif\n// CUSTOM END\n\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\n#ifdef IOR\n\tuniform float ior;\n#endif\n#ifdef SPECULAR\n\tuniform float specularIntensity;\n\tuniform vec3 specularColor;\n\t#ifdef USE_SPECULARINTENSITYMAP\n\t\tuniform sampler2D specularIntensityMap;\n\t#endif\n\t#ifdef USE_SPECULARCOLORMAP\n\t\tuniform sampler2D specularColorMap;\n\t#endif\n#endif\n#ifdef USE_CLEARCOAT\n\tuniform float clearcoat;\n\tuniform float clearcoatRoughness;\n#endif\n#ifdef USE_IRIDESCENCE\n\tuniform float iridescence;\n\tuniform float iridescenceIOR;\n\tuniform float iridescenceThicknessMinimum;\n\tuniform float iridescenceThicknessMaximum;\n#endif\n#ifdef USE_SHEEN\n\tuniform vec3 sheenColor;\n\tuniform float sheenRoughness;\n\t#ifdef USE_SHEENCOLORMAP\n\t\tuniform sampler2D sheenColorMap;\n\t#endif\n\t#ifdef USE_SHEENROUGHNESSMAP\n\t\tuniform sampler2D sheenRoughnessMap;\n\t#endif\n#endif\nvarying vec3 vViewPosition;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <bsdfs>\n#include <iridescence_fragment>\n#include <cube_uv_reflection_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_physical_pars_fragment>\n#include <fog_pars_fragment>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_physical_pars_fragment>\n#include <transmission_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <clearcoat_pars_fragment>\n#include <iridescence_pars_fragment>\n#include <roughnessmap_pars_fragment>\n#include <metalnessmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\n\n\n\n// CUSTOM START\n\nvarying vec4 initialPosition;\nvarying vec3 initialNormal;\n\nvarying vec3 frag_position;\nvarying vec3 frag_normal;\n\nuniform vec3 center;\nuniform float radius;\nuniform samplerCube sphericalNormalMap;\nuniform mat3 normalMatrix;\nuniform mat4 modelMatrix;\n\nuniform float impurityScale;\nuniform vec3 colorTransferBegin;\nuniform vec3 colorTransferEnd;\nuniform float refractionIndex;\nuniform float gamma;\nuniform float contrast;\nuniform float brightness;\nuniform float dispersion;\nuniform float tracingOpacity;\n\n\nvec3 getIBLRadianceVariation( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {\n\t#if defined( ENVMAP_TYPE_CUBE_UV )\n\t\tvec3 reflectVec = reflect( - viewDir, normal );\n\t\t// Mixing the reflection with the normal is more accurate and keeps rough objects from gathering light from behind their tangent plane.\n\t\treflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );\n\t\treflectVec = inverseTransformDirection( reflectVec, viewMatrix );\n\t\tvec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );\n\t\treturn min(envMapColor.rgb * envMapIntensity, vec3(1.0));\n\t#else\n\t\treturn vec3( 0.0 );\n\t#endif\n}\n\nvec3 calculateReflectedLight(vec3 position, vec3 normal, vec3 viewDir, PhysicalMaterial material, int depth) {\n\t\n\tvec3 currentGeometryPosition = (modelMatrix * vec4(position, 1.0)).xyz;\n\n\tmat3 normalMatrix;\n\tnormalMatrix[0] = normalize(modelMatrix[0].xyz);\n\tnormalMatrix[1] = normalize(modelMatrix[1].xyz);\n\tnormalMatrix[2] = normalize(modelMatrix[2].xyz);\n\t\n\t// Calculate the normal vector in world space\n\tvec3 currentGeometryNormal = normalize(normalMatrix * normal);\n\t\n\t// Calculate the view direction vector in world space\n\tvec3 currentGeometryViewDir = normalize(normalMatrix * -viewDir);\n\n    vec3 currentGeometryClearcoatNormal;\n\t\n\t#ifdef USE_CLEARCOAT\n        currentGeometryClearcoatNormal = clearcoatNormal;\n    #endif\n\n\tReflectedLight rLight;\n\tIncidentLight dLight;\n\n\tfloat temp = material.roughness;\n\tmaterial.roughness = 0.5;\n\n\t#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\n\n\t\tPointLight pointLight;\n        #if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0\n            PointLightShadow pointLightShadow;\n        #endif\n\n\t    #pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\t\tpointLight = pointLights[ i ];\n            getPointLightInfo( pointLight, currentGeometryPosition, dLight );\n            #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )\n                pointLightShadow = pointLightShadows[ i ];\n                dLight.color *= all( bvec2( dLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;\n            #endif\n\t\t    RE_Direct( dLight, currentGeometryPosition, currentGeometryNormal, currentGeometryViewDir, currentGeometryClearcoatNormal, material, rLight );\n\t\t}\n        #pragma unroll_loop_end\n\t#endif\n\t#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n        SpotLight spotLight;\n        #if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0\n            SpotLightShadow spotLightShadow;\n        #endif\n        #pragma unroll_loop_start\n        for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n            spotLight = spotLights[ i ];\n            getSpotLightInfo( spotLight, currentGeometryPosition, dLight );\n            #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n                spotLightShadow = spotLightShadows[ i ];\n                dLight.color *= all( bvec2( dLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n            #endif\n            RE_Direct( dLight, currentGeometryPosition, currentGeometryNormal, currentGeometryViewDir, currentGeometryClearcoatNormal, material, rLight );\n        }\n        #pragma unroll_loop_end\n\t#endif\n\n    #if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\n        DirectionalLight directionalLight;\n        #if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0\n            DirectionalLightShadow directionalLightShadow;\n        #endif\n        #pragma unroll_loop_start\n        for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n            directionalLight = directionalLights[ i ];\n            getDirectionalLightInfo( directionalLight, dLight );\n            #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\n                directionalLightShadow = directionalLightShadows[ i ];\n                dLight.color *= all( bvec2( dLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n            #endif\n            RE_Direct( dLight, currentGeometryPosition, currentGeometryNormal, currentGeometryViewDir, currentGeometryClearcoatNormal, material, rLight );\n        }\n        #pragma unroll_loop_end\n    #endif\n\tmaterial.roughness = temp;\n\t\n    #if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\n        RectAreaLight rectAreaLight;\n        #pragma unroll_loop_start\n        for ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\n            rectAreaLight = rectAreaLights[ i ];\n            RE_Direct_RectArea( rectAreaLight, currentGeometryPosition, currentGeometryNormal, currentGeometryViewDir, currentGeometryClearcoatNormal, material, rLight );\n        }\n        #pragma unroll_loop_end\n    #endif\n    #if defined( RE_IndirectDiffuse )\n        vec3 iblIrradiance = vec3( 0.0 );\n        vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n\t\t\n\t\t#if defined( USE_LIGHT_PROBES )\n        \tirradiance += getLightProbeIrradiance( lightProbe, currentGeometryNormal );\n\t\t#endif\n        #if ( NUM_HEMI_LIGHTS > 0 )\n            #pragma unroll_loop_start\n            for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n                irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], currentGeometryNormal );\n            }\n            #pragma unroll_loop_end\n        #endif\n    #endif\n    #if defined( RE_IndirectSpecular )\n        vec3 radiance = vec3( 0.0 );\n        vec3 clearcoatRadiance = vec3( 0.0 );\n    #endif\n\n\n    #if defined( RE_IndirectDiffuse )\n        #ifdef USE_LIGHTMAP\n            vec4 lightMapTexel = texture2D( lightMap, vUv2 );\n            vec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;\n            irradiance += lightMapIrradiance;\n        #endif\n        #if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )\n            iblIrradiance += getIBLIrradiance( currentGeometryNormal );\n        #endif\n    #endif\n    #if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\n        radiance += getIBLRadianceVariation( currentGeometryViewDir, currentGeometryNormal, material.roughness );\n        #ifdef USE_CLEARCOAT\n            clearcoatRadiance += getIBLRadianceVariation( currentGeometryViewDir, currentGeometryClearcoatNormal, material.clearcoatRoughness );\n        #endif\n    #endif\n\n    #if defined( RE_IndirectDiffuse )\n        RE_IndirectDiffuse( irradiance, currentGeometryPosition, currentGeometryNormal, currentGeometryViewDir, currentGeometryClearcoatNormal, material, rLight );\n    #endif\n    #if defined( RE_IndirectSpecular )\n        RE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, currentGeometryPosition, currentGeometryNormal, currentGeometryViewDir, currentGeometryClearcoatNormal, material, rLight );\n    #endif\n\n\tif(depth >= 0) {\n\t\tfloat frac = float(depth) / float(TRACING_DEPTH);\n\t\tvec3 colorTransfer = (1.0-frac) * colorTransferBegin + frac * colorTransferEnd;\n\t\trLight.indirectSpecular *= colorTransfer;\n\t\trLight.directSpecular *= colorTransfer;\n\t}\n\n\tvec3 color = rLight.indirectSpecular + rLight.directSpecular + rLight.indirectDiffuse + rLight.directDiffuse;\n\n\t// gamma\n\tcolor = pow(color, vec3(1.0/gamma)); \n\n\t// contrast\n\tcolor.rgb = ((color.rgb - 0.5) * max(contrast, 0.0)) + 0.5; \n\n\t// brightness\n\tcolor.r = min(max(color.r + brightness, 0.0), 1.0);\n\tcolor.g = min(max(color.g + brightness, 0.0), 1.0);\n\tcolor.b = min(max(color.b + brightness, 0.0), 1.0);\n\n\treturn color;\n}\n\nvec3 normalLookUp(vec3 dir) {\n\tvec4 s = textureCube(sphericalNormalMap, dir);\n\tif(s.a < 1.0/256.0) {\n\t\treturn normalize(vec3(-s.x, -s.y, -s.z));\n\t} else if(s.a < 3.0/256.0) {\n\t\treturn normalize(vec3(-s.x, -s.y, s.z));\n\t} else if(s.a < 5.0/256.0) {\n\t\treturn normalize(vec3(-s.x, s.y, -s.z));\n\t} else if(s.a < 7.0/256.0) {\n\t\treturn normalize(vec3(s.x, -s.y, -s.z));\n\t} else if(s.a < 9.0/256.0) {\n\t\treturn normalize(vec3(-s.x, s.y, s.z));\n\t} else if(s.a < 11.0/256.0) {\n\t\treturn normalize(vec3(s.x, -s.y, s.z));\n\t} else if(s.a < 13.0/256.0) {\n\t\treturn normalize(vec3(s.x, s.y, -s.z));\n\t} else {\n\t\treturn normalize(s.xyz);\n\t}\n}\n\n#ifdef USE_IMPURITYMAP\n\tfloat impurityLookUp(vec3 dir) {\n\t\tvec3 c = textureCube(impurityMap, dir.xy).rgb;\n\t\treturn (c.x + c.y + c.z) / 3.0;\n\t}\n#endif\n\nvec3 raySphereIntersection(vec3 o, vec3 d) {\n\n\tvec3 oc = o - center;\n    float a = dot(d, d);\n    float b = 2.0 * dot(oc, d);\n    float c = dot(oc,oc) - radius*radius;\n    float discriminant = b*b - 4.0*a*c;\n    if(discriminant < 0.0){\n        return vec3(0.0);\n    }\n    else{\n        return o +( (-b + sqrt(discriminant)) / (2.0*a)) * d;\n    }\n}\n\nvec3 hueToSaturatedColor(float hue) {\n    float r,g,b;\n    if (hue < 0.25){\n\t\tfloat t = 1.0 - (hue / 0.25);\n        r = 1.0;\n        g = 1.0;\n        b = t;    \n\t} else if (hue < 0.5){\n    \tfloat t = 1.0 - (hue - 0.25 / 0.25);\n\t\tr = 1.0;\n        g = t;\n        b = 0.0;\n\t} else if (hue < 0.75){\n    \tfloat t = 1.0 - (hue - 0.5 / 0.25);\n\t\tr = t;\n        g = 0.0;\n        b = 1.0 - t;\n    } else {\n    \tfloat t = hue - 0.75 / 0.25;\n        r = t;\n        g = t;\n        b = 1.0;\n    }\n    return vec3(r, g, b) / 0.5 + 0.5;\n}\n// CUSTOM END\n\nvoid main() {    \n    // CUSTOM START\n    vec3 frag_normal_normalized = frag_normal;\n    // CUSTOM END\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <roughnessmap_fragment>\n\t#include <metalnessmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <clearcoat_normal_fragment_begin>\n\t#include <clearcoat_normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_physical_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;\n\tvec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;\n\t#include <transmission_fragment>\n\tvec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;\n\t#ifdef USE_SHEEN\n\t\tfloat sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );\n\t\toutgoingLight = outgoingLight * sheenEnergyComp + sheenSpecular;\n\t#endif\n\t#ifdef USE_CLEARCOAT\n\t\tfloat dotNVcc = saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );\n\t\tvec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );\n\t\toutgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + clearcoatSpecular * material.clearcoat;\n\t#endif\n\t#include <opaque_fragment>\n\n    // CUSTOM START\n\t\n    // Extract the translation part of the model matrix\n\tvec3 translation = modelMatrix[3].xyz;\n\n\t// Extract the rotation part of the model matrix (3x3 upper-left submatrix)\n\tmat3 rotationMatrix = mat3(modelMatrix);\n\n\t// Calculate the inverse of the rotation matrix (transpose since it's orthogonal)\n\tmat3 inverseRotationMatrix;\n\tinverseRotationMatrix[0] = vec3(rotationMatrix[0].x, rotationMatrix[1].x, rotationMatrix[2].x);\n\tinverseRotationMatrix[1] = vec3(rotationMatrix[0].y, rotationMatrix[1].y, rotationMatrix[2].y);\n\tinverseRotationMatrix[2] = vec3(rotationMatrix[0].z, rotationMatrix[1].z, rotationMatrix[2].z);\n\n\t// Calculate the camera position in model space\n\tvec3 cameraPositionInModelSpace = inverseRotationMatrix * (cameraPosition - translation);\n\n\t// Calculate the initial direction\n\tvec3 initialDirection = normalize(frag_position.xyz - cameraPositionInModelSpace);\n\n\tvec4 outgoingLight2;\n\tfloat r_0 = (1.0-refractionIndex)/(1.0+refractionIndex);\n\tr_0 = r_0*r_0;\n\n\tfloat cos_theta_0 = -dot(initialDirection, frag_normal_normalized);\n\tfloat r_0_outside = (refractionIndex-1.0)/(refractionIndex+1.0);\n\tr_0_outside = r_0_outside*r_0_outside;\n\tfloat initialProbability = r_0_outside + (1.0 - r_0_outside)*pow(1.0 - cos_theta_0, 5.0);\n\n\toutgoingLight2 = vec4(calculateReflectedLight(frag_position, frag_normal_normalized, initialDirection, material, -1), 1.0);\n\t// gl_FragColor = outgoingLight2;\n\t// return;\n\tif(TRACING_DEPTH > 0) \n\t\toutgoingLight2 *= initialProbability;\n\t\t\n\tvec3 tempColor;\n\n\t#ifdef DISPERSION\n\t\tconst int loop = 3;\n\t\tvec3 dispersionColor;\n\t#else\n\t\tconst int loop = 1;\n\t#endif\n\t\t#pragma unroll_loop_start\n\t\tfor(int j = 0; j < loop; j++){\n\t\t\tvec3 refractedDirection = refract(initialDirection, frag_normal_normalized, 1.0/refractionIndex + float(j)*dispersion * 0.025);\n\t\t\tvec3 newPosition = raySphereIntersection(frag_position, refractedDirection);\n\t\t\tvec3 lookUpVector = normalize(newPosition - center);\n\t\t\tvec3 newNormal = normalLookUp(lookUpVector);\n\t\t\tvec3 newDirection = reflect(refractedDirection, newNormal);\n\n\t\t\tfloat currentProbability = 1.0;\n\n\t\t\t#ifdef USE_IMPURITYMAP\n\t\t\t\tfloat impurityProbability = impurityLookUp(lookUpVector);\n\t\t\t\tcurrentProbability -= impurityProbability * impurityScale;\n\t\t\t\t// gl_FragColor = vec4(vec3(impurityProbability), 1.0);\n\t\t\t\t// return;\n\t\t\t#endif\n\t\t\t\n\t\t\t// if(0 == TRACING_DEPTH) {\n\t\t\t// \tgl_FragColor = vec4(0.5 * newNormal + 0.5, 1.0);\n\t\t\t// \treturn;\n\t\t\t// }\n\n\t\t\ttempColor = vec3(0.0);\n\t\t\t#pragma unroll_loop_start\n\t\t\tfor(int i = 0; i < TRACING_DEPTH; i++) {\n\t\t\t\t// small position correction to avoid artefacts\n\t\t\t\tnewPosition = newPosition - lookUpVector * 1e-6;\n\t\t\t\tnewPosition = raySphereIntersection(newPosition, newDirection);\n\t\t\t\tlookUpVector = normalize(newPosition - center);\n\t\t\t\tnewNormal = normalLookUp(lookUpVector);\n\t\t\t\n\t\t\t\tfloat cos_theta = dot(newDirection, newNormal);\n\t\t\t\tfloat ratio;\n\t\t\t\tif(cos_theta > 0.0) {\n\t\t\t\t\tratio = refractionIndex;\n\t\t\t\t} else {\n\t\t\t\t\tcos_theta = -cos_theta;\n\t\t\t\t\tratio = 1.0 / refractionIndex;\n\t\t\t\t}\n\t\t\t\tfloat cos_theta_2 = 1.0 - ratio*ratio * (1.0 - cos_theta*cos_theta);\n\t\t\t\tfloat probability = r_0 + (1.0 - r_0)*pow(1.0 - cos_theta, 5.0);\n\t\t\t\tif(cos_theta_2 < 0.0) probability = 0.0;\n\n\t\t\t\tvec3 refracted = refract(newDirection, newNormal*-1.0, 1.0/refractionIndex);\n\t\t\t\ttempColor += probability * currentProbability * calculateReflectedLight(newPosition, newNormal*-1.0, reflect(refracted, newNormal), material, i);\n\t\t\t\tif(i+1 == TRACING_DEPTH)\n\t\t\t\t\ttempColor += (1.0 - probability) * currentProbability * calculateReflectedLight(newPosition, newNormal, newDirection, material, i);\n\n\t\t\t\tnewDirection = reflect(newDirection, newNormal);\n\n\t\t\t\t// if(i+1 == TRACING_DEPTH) {\n\t\t\t\t// \tgl_FragColor = vec4(0.5 * newNormal + 0.5, 1.0);\n\t\t\t\t// \treturn;\n\t\t\t\t// }\n\n\t\t\t\tcurrentProbability *= (1.0 - probability);\n\t\t\t}\n\t\t\t#pragma unroll_loop_end\n\n\t\t\t#ifdef DISPERSION\n\t\t\t\tif(j == 0) {\n\t\t\t\t\tdispersionColor.r = tempColor.r;\t\n\t\t\t\t} else if(j == 1) {\n\t\t\t\t\tdispersionColor.g = tempColor.g;\t\n\t\t\t\t} else if(j == 2) {\n\t\t\t\t\tdispersionColor.b = tempColor.b;\t\n\t\t\t\t}\n\t\t\t\ttempColor = dispersionColor;\n\t\t\t#endif\n\t\t}\t\n\t\t#pragma unroll_loop_end\n\n\tif(TRACING_DEPTH > 0)\n\t\toutgoingLight2.rgb += (1.0 - initialProbability) * tempColor;\n\n\tfloat alpha = (1.0 - initialProbability) + initialProbability*tracingOpacity;\n\tgl_FragColor = vec4(outgoingLight2.rgb, alpha*diffuseColor.a);\n\n    // CUSTOM END\n\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}\n\n";
+export declare const vert = "\n#define STANDARD\nvarying vec3 vViewPosition;\n#ifdef USE_TRANSMISSION\n\tvarying vec3 vWorldPosition;\n#endif\n#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\n\n// CUSTOM START\nvarying vec3 frag_position;\nvarying vec3 frag_normal;\n// CUSTOM END\n\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphinstance_vertex>\n\t#include <morphcolor_vertex>\n\t#include <batching_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n    #ifdef USE_TRANSMISSION\n        vWorldPosition = worldPosition.xyz;\n    #endif\n\n    // CUSTOM START\n    frag_position = position;\n    frag_normal = objectNormal;\n    // CUSTOM END\n}\n";
+export declare const frag = "\n#define STANDARD\n#ifdef PHYSICAL\n\t#define IOR\n\t#define USE_SPECULAR\n#endif\n\n// CUSTOM START\n#ifdef USE_IMPURITYMAP\n\tuniform sampler2D impurityMap;\n#endif\n// CUSTOM END\n\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\n#ifdef IOR\n\tuniform float ior;\n#endif\n#ifdef USE_SPECULAR\n\tuniform float specularIntensity;\n\tuniform vec3 specularColor;\n\t#ifdef USE_SPECULAR_INTENSITYMAP\n\t\tuniform sampler2D specularIntensityMap;\n\t#endif\n\t#ifdef USE_SPECULAR_COLORMAP\n\t\tuniform sampler2D specularColorMap;\n\t#endif\n#endif\n#ifdef USE_CLEARCOAT\n\tuniform float clearcoat;\n\tuniform float clearcoatRoughness;\n#endif\n#ifdef USE_IRIDESCENCE\n\tuniform float iridescence;\n\tuniform float iridescenceIOR;\n\tuniform float iridescenceThicknessMinimum;\n\tuniform float iridescenceThicknessMaximum;\n#endif\n#ifdef USE_SHEEN\n\tuniform vec3 sheenColor;\n\tuniform float sheenRoughness;\n\t#ifdef USE_SHEEN_COLORMAP\n\t\tuniform sampler2D sheenColorMap;\n\t#endif\n\t#ifdef USE_SHEEN_ROUGHNESSMAP\n\t\tuniform sampler2D sheenRoughnessMap;\n\t#endif\n#endif\nvarying vec3 vViewPosition;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <bsdfs>\n#include <iridescence_fragment>\n#include <cube_uv_reflection_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_physical_pars_fragment>\n#include <fog_pars_fragment>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_physical_pars_fragment>\n#include <transmission_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <clearcoat_pars_fragment>\n#include <iridescence_pars_fragment>\n#include <roughnessmap_pars_fragment>\n#include <metalnessmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\n\n\n\n// CUSTOM START\n\nvarying vec4 initialPosition;\nvarying vec3 initialNormal;\n\nvarying vec3 frag_position;\nvarying vec3 frag_normal;\n\nuniform vec3 center;\nuniform float radius;\nuniform samplerCube sphericalNormalMap;\nuniform mat3 normalMatrix;\nuniform mat4 modelMatrix;\n\nuniform float impurityScale;\nuniform vec3 colorTransferBegin;\nuniform vec3 colorTransferEnd;\nuniform float refractionIndex;\nuniform float gamma;\nuniform float contrast;\nuniform float brightness;\nuniform float dispersion;\nuniform float tracingOpacity;\n\n\nvec3 getIBLRadianceVariation( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {\n\t#if defined( ENVMAP_TYPE_CUBE_UV )\n\t\tvec3 reflectVec = reflect( - viewDir, normal );\n\t\t// Mixing the reflection with the normal is more accurate and keeps rough objects from gathering light from behind their tangent plane.\n\t\treflectVec = normalize( mix( reflectVec, normal, pow4( roughness ) ) );\n\t\treflectVec = inverseTransformDirection( reflectVec, viewMatrix );\n\t\tvec4 envMapColor = textureCubeUV( envMap, envMapRotation * reflectVec, roughness );\n\t\treturn envMapColor.rgb * envMapIntensity;\n\t#else\n\t\treturn vec3( 0.0 );\n\t#endif\n}\n\nvec3 calculateReflectedLight(vec3 position, vec3 normal, vec3 viewDir, PhysicalMaterial material, int depth) {\n\t\n\tvec3 currentGeometryPosition = (modelMatrix * vec4(position, 1.0)).xyz;\n\n\tmat3 normalMatrix;\n\tnormalMatrix[0] = normalize(modelMatrix[0].xyz);\n\tnormalMatrix[1] = normalize(modelMatrix[1].xyz);\n\tnormalMatrix[2] = normalize(modelMatrix[2].xyz);\n\t\n\t// Calculate the normal vector in world space\n\tvec3 currentGeometryNormal = normalize(normalMatrix * normal);\n\t\n\t// Calculate the view direction vector in world space\n\tvec3 currentGeometryViewDir = normalize(normalMatrix * -viewDir);\n\n    vec3 currentGeometryClearcoatNormal = vec3( 0.0 );\n\t\n\t#ifdef USE_CLEARCOAT\n        currentGeometryClearcoatNormal = clearcoatNormal;\n    #endif\n\n\tReflectedLight rLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tIncidentLight dLight;\n\n\tfloat temp = material.roughness;\n\tmaterial.roughness = 0.5;\n\n\t#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\n\n\t\tPointLight pointLight;\n        #if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0\n            PointLightShadow pointLightShadow;\n        #endif\n\n\t    #pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\t\tpointLight = pointLights[ i ];\n            getPointLightInfo( pointLight, currentGeometryPosition, dLight );\n            #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )\n                pointLightShadow = pointLightShadows[ i ];\n                dLight.color *= ( dLight.visible && receiveShadow ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowIntensity, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;\n            #endif\n\t\t    RE_Direct( dLight, currentGeometryPosition, currentGeometryNormal, currentGeometryViewDir, currentGeometryClearcoatNormal, material, rLight );\n\t\t}\n        #pragma unroll_loop_end\n\t#endif\n\t#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n        SpotLight spotLight;\n        #if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0\n            SpotLightShadow spotLightShadow;\n        #endif\n        #pragma unroll_loop_start\n        for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n            spotLight = spotLights[ i ];\n            getSpotLightInfo( spotLight, currentGeometryPosition, dLight );\n            #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n                spotLightShadow = spotLightShadows[ i ];\n                dLight.color *= ( dLight.visible && receiveShadow ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowIntensity, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;\n            #endif\n            RE_Direct( dLight, currentGeometryPosition, currentGeometryNormal, currentGeometryViewDir, currentGeometryClearcoatNormal, material, rLight );\n        }\n        #pragma unroll_loop_end\n\t#endif\n\n    #if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\n        DirectionalLight directionalLight;\n        #if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0\n            DirectionalLightShadow directionalLightShadow;\n        #endif\n        #pragma unroll_loop_start\n        for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n            directionalLight = directionalLights[ i ];\n            getDirectionalLightInfo( directionalLight, dLight );\n            #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\n                directionalLightShadow = directionalLightShadows[ i ];\n                dLight.color *= ( dLight.visible && receiveShadow ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowIntensity, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n            #endif\n            RE_Direct( dLight, currentGeometryPosition, currentGeometryNormal, currentGeometryViewDir, currentGeometryClearcoatNormal, material, rLight );\n        }\n        #pragma unroll_loop_end\n    #endif\n\tmaterial.roughness = temp;\n\t\n    #if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\n        RectAreaLight rectAreaLight;\n        #pragma unroll_loop_start\n        for ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\n            rectAreaLight = rectAreaLights[ i ];\n            RE_Direct_RectArea( rectAreaLight, currentGeometryPosition, currentGeometryNormal, currentGeometryViewDir, currentGeometryClearcoatNormal, material, rLight );\n        }\n        #pragma unroll_loop_end\n    #endif\n    #if defined( RE_IndirectDiffuse )\n        vec3 iblIrradiance = vec3( 0.0 );\n        vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n\t\t\n\t\t#if defined( USE_LIGHT_PROBES )\n        \tirradiance += getLightProbeIrradiance( lightProbe, currentGeometryNormal );\n\t\t#endif\n        #if ( NUM_HEMI_LIGHTS > 0 )\n            #pragma unroll_loop_start\n            for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n                irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], currentGeometryNormal );\n            }\n            #pragma unroll_loop_end\n        #endif\n    #endif\n    #if defined( RE_IndirectSpecular )\n        vec3 radiance = vec3( 0.0 );\n        vec3 clearcoatRadiance = vec3( 0.0 );\n    #endif\n\n\n    #if defined( RE_IndirectDiffuse )\n        #ifdef USE_LIGHTMAP\n            vec4 lightMapTexel = texture2D( lightMap, vLightMapUv );\n            vec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;\n            irradiance += lightMapIrradiance;\n        #endif\n        #if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )\n            iblIrradiance += getIBLIrradiance( currentGeometryNormal );\n        #endif\n    #endif\n    #if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\n        radiance += getIBLRadianceVariation( currentGeometryViewDir, currentGeometryNormal, material.roughness );\n        #ifdef USE_CLEARCOAT\n            clearcoatRadiance += getIBLRadianceVariation( currentGeometryViewDir, currentGeometryClearcoatNormal, material.clearcoatRoughness );\n        #endif\n    #endif\n\n    #if defined( RE_IndirectDiffuse )\n        RE_IndirectDiffuse( irradiance, currentGeometryPosition, currentGeometryNormal, currentGeometryViewDir, currentGeometryClearcoatNormal, material, rLight );\n    #endif\n    #if defined( RE_IndirectSpecular )\n        RE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, currentGeometryPosition, currentGeometryNormal, currentGeometryViewDir, currentGeometryClearcoatNormal, material, rLight );\n    #endif\n\n\tif(depth >= 0) {\n\t\tfloat frac = float(depth) / float(TRACING_DEPTH);\n\t\tvec3 colorTransfer = (1.0-frac) * colorTransferBegin + frac * colorTransferEnd;\n\t\trLight.indirectSpecular *= colorTransfer;\n\t\trLight.directSpecular *= colorTransfer;\n\t}\n\n\tvec3 color = rLight.indirectSpecular + rLight.directSpecular + rLight.indirectDiffuse + rLight.directDiffuse;\n\n\t// gamma\n\tcolor = pow(color, vec3(1.0/gamma)); \n\n\t// contrast\n\tcolor.rgb = ((color.rgb - 0.5) * max(contrast, 0.0)) + 0.5; \n\n\t// brightness\n\tcolor.r = min(max(color.r + brightness, 0.0), 1.0);\n\tcolor.g = min(max(color.g + brightness, 0.0), 1.0);\n\tcolor.b = min(max(color.b + brightness, 0.0), 1.0);\n\n\treturn color;\n}\n\nvec3 normalLookUp(vec3 dir) {\n\tvec4 s = textureCube(sphericalNormalMap, dir);\n\tif(s.a < 1.0/256.0) {\n\t\treturn normalize(vec3(-s.x, -s.y, -s.z));\n\t} else if(s.a < 3.0/256.0) {\n\t\treturn normalize(vec3(-s.x, -s.y, s.z));\n\t} else if(s.a < 5.0/256.0) {\n\t\treturn normalize(vec3(-s.x, s.y, -s.z));\n\t} else if(s.a < 7.0/256.0) {\n\t\treturn normalize(vec3(s.x, -s.y, -s.z));\n\t} else if(s.a < 9.0/256.0) {\n\t\treturn normalize(vec3(-s.x, s.y, s.z));\n\t} else if(s.a < 11.0/256.0) {\n\t\treturn normalize(vec3(s.x, -s.y, s.z));\n\t} else if(s.a < 13.0/256.0) {\n\t\treturn normalize(vec3(s.x, s.y, -s.z));\n\t} else {\n\t\treturn normalize(s.xyz);\n\t}\n}\n\n#ifdef USE_IMPURITYMAP\n\tfloat impurityLookUp(vec3 dir) {\n\t\tvec3 c = texture2D(impurityMap, dir.xy * 0.5 + 0.5).rgb;\n\t\treturn (c.x + c.y + c.z) / 3.0;\n\t}\n#endif\n\nvec3 raySphereIntersection(vec3 o, vec3 d) {\n\n\tvec3 oc = o - center;\n    float a = dot(d, d);\n    float b = 2.0 * dot(oc, d);\n    float c = dot(oc,oc) - radius*radius;\n    float discriminant = b*b - 4.0*a*c;\n    if(discriminant < 0.0){\n        return vec3(0.0);\n    }\n    else{\n        return o +( (-b + sqrt(discriminant)) / (2.0*a)) * d;\n    }\n}\n\nvec3 hueToSaturatedColor(float hue) {\n    float r,g,b;\n    if (hue < 0.25){\n\t\tfloat t = 1.0 - (hue / 0.25);\n        r = 1.0;\n        g = 1.0;\n        b = t;    \n\t} else if (hue < 0.5){\n    \tfloat t = 1.0 - (hue - 0.25 / 0.25);\n\t\tr = 1.0;\n        g = t;\n        b = 0.0;\n\t} else if (hue < 0.75){\n    \tfloat t = 1.0 - (hue - 0.5 / 0.25);\n\t\tr = t;\n        g = 0.0;\n        b = 1.0 - t;\n    } else {\n    \tfloat t = hue - 0.75 / 0.25;\n        r = t;\n        g = t;\n        b = 1.0;\n    }\n    return vec3(r, g, b) / 0.5 + 0.5;\n}\n// CUSTOM END\n\nvoid main() {    \n    // CUSTOM START\n    vec3 frag_normal_normalized = frag_normal;\n    // CUSTOM END\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <roughnessmap_fragment>\n\t#include <metalnessmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <clearcoat_normal_fragment_begin>\n\t#include <clearcoat_normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_physical_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;\n\tvec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;\n\t#include <transmission_fragment>\n\tvec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;\n\t#ifdef USE_SHEEN\n\t\toutgoingLight = outgoingLight + sheenSpecularDirect + sheenSpecularIndirect;\n\t#endif\n\t#ifdef USE_CLEARCOAT\n\t\tfloat dotNVcc = saturate( dot( geometryClearcoatNormal, geometryViewDir ) );\n\t\tvec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );\n\t\toutgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + ( clearcoatSpecularDirect + clearcoatSpecularIndirect ) * material.clearcoat;\n\t#endif\n\t#include <opaque_fragment>\n\n    // CUSTOM START\n\t\n    // Extract the translation part of the model matrix\n\tvec3 translation = modelMatrix[3].xyz;\n\n\t// Extract the rotation part of the model matrix (3x3 upper-left submatrix)\n\tmat3 rotationMatrix = mat3(modelMatrix);\n\n\t// Calculate the inverse of the rotation matrix (transpose since it's orthogonal)\n\tmat3 inverseRotationMatrix;\n\tinverseRotationMatrix[0] = vec3(rotationMatrix[0].x, rotationMatrix[1].x, rotationMatrix[2].x);\n\tinverseRotationMatrix[1] = vec3(rotationMatrix[0].y, rotationMatrix[1].y, rotationMatrix[2].y);\n\tinverseRotationMatrix[2] = vec3(rotationMatrix[0].z, rotationMatrix[1].z, rotationMatrix[2].z);\n\n\t// Calculate the camera position in model space\n\tvec3 cameraPositionInModelSpace = inverseRotationMatrix * (cameraPosition - translation);\n\n\t// Calculate the initial direction\n\tvec3 initialDirection = normalize(frag_position.xyz - cameraPositionInModelSpace);\n\n\tvec4 outgoingLight2;\n\tfloat r_0 = (1.0-refractionIndex)/(1.0+refractionIndex);\n\tr_0 = r_0*r_0;\n\n\tfloat cos_theta_0 = -dot(initialDirection, frag_normal_normalized);\n\tfloat r_0_outside = (refractionIndex-1.0)/(refractionIndex+1.0);\n\tr_0_outside = r_0_outside*r_0_outside;\n\tfloat initialProbability = r_0_outside + (1.0 - r_0_outside)*pow(1.0 - cos_theta_0, 5.0);\n\n\toutgoingLight2 = vec4(calculateReflectedLight(frag_position, frag_normal_normalized, initialDirection, material, -1), 1.0);\n\t// gl_FragColor = outgoingLight2;\n\t// return;\n\tif(TRACING_DEPTH > 0) \n\t\toutgoingLight2 *= initialProbability;\n\t\t\n\tvec3 tempColor;\n\n\t#ifdef DISPERSION\n\t\tconst int loop = 3;\n\t\tvec3 dispersionColor;\n\t#else\n\t\tconst int loop = 1;\n\t#endif\n\t\t#pragma unroll_loop_start\n\t\tfor(int j = 0; j < loop; j++){\n\t\t\tvec3 refractedDirection = refract(initialDirection, frag_normal_normalized, 1.0/refractionIndex + float(j)*dispersion * 0.025);\n\t\t\tvec3 newPosition = raySphereIntersection(frag_position, refractedDirection);\n\t\t\tvec3 lookUpVector = normalize(newPosition - center);\n\t\t\tvec3 newNormal = normalLookUp(lookUpVector);\n\t\t\tvec3 newDirection = reflect(refractedDirection, newNormal);\n\n\t\t\tfloat currentProbability = 1.0;\n\n\t\t\t#ifdef USE_IMPURITYMAP\n\t\t\t\tfloat impurityProbability = impurityLookUp(lookUpVector);\n\t\t\t\tcurrentProbability -= impurityProbability * impurityScale;\n\t\t\t\t// gl_FragColor = vec4(vec3(impurityProbability), 1.0);\n\t\t\t\t// return;\n\t\t\t#endif\n\t\t\t\n\t\t\t// if(0 == TRACING_DEPTH) {\n\t\t\t// \tgl_FragColor = vec4(0.5 * newNormal + 0.5, 1.0);\n\t\t\t// \treturn;\n\t\t\t// }\n\n\t\t\ttempColor = vec3(0.0);\n\t\t\t#pragma unroll_loop_start\n\t\t\tfor(int i = 0; i < TRACING_DEPTH; i++) {\n\t\t\t\t// small position correction to avoid artefacts\n\t\t\t\tnewPosition = newPosition - lookUpVector * 1e-6;\n\t\t\t\tnewPosition = raySphereIntersection(newPosition, newDirection);\n\t\t\t\tlookUpVector = normalize(newPosition - center);\n\t\t\t\tnewNormal = normalLookUp(lookUpVector);\n\t\t\t\n\t\t\t\tfloat cos_theta = dot(newDirection, newNormal);\n\t\t\t\tfloat ratio;\n\t\t\t\tif(cos_theta > 0.0) {\n\t\t\t\t\tratio = refractionIndex;\n\t\t\t\t} else {\n\t\t\t\t\tcos_theta = -cos_theta;\n\t\t\t\t\tratio = 1.0 / refractionIndex;\n\t\t\t\t}\n\t\t\t\tfloat cos_theta_2 = 1.0 - ratio*ratio * (1.0 - cos_theta*cos_theta);\n\t\t\t\tfloat probability = r_0 + (1.0 - r_0)*pow(1.0 - cos_theta, 5.0);\n\t\t\t\tif(cos_theta_2 < 0.0) probability = 0.0;\n\n\t\t\t\tvec3 refracted = refract(newDirection, newNormal*-1.0, 1.0/refractionIndex);\n\t\t\t\ttempColor += probability * currentProbability * calculateReflectedLight(newPosition, newNormal*-1.0, reflect(refracted, newNormal), material, i);\n\t\t\t\tif(i+1 == TRACING_DEPTH)\n\t\t\t\t\ttempColor += (1.0 - probability) * currentProbability * calculateReflectedLight(newPosition, newNormal, newDirection, material, i);\n\n\t\t\t\tnewDirection = reflect(newDirection, newNormal);\n\n\t\t\t\t// if(i+1 == TRACING_DEPTH) {\n\t\t\t\t// \tgl_FragColor = vec4(0.5 * newNormal + 0.5, 1.0);\n\t\t\t\t// \treturn;\n\t\t\t\t// }\n\n\t\t\t\tcurrentProbability *= (1.0 - probability);\n\t\t\t}\n\t\t\t#pragma unroll_loop_end\n\n\t\t\t#ifdef DISPERSION\n\t\t\t\tif(j == 0) {\n\t\t\t\t\tdispersionColor.r = tempColor.r;\t\n\t\t\t\t} else if(j == 1) {\n\t\t\t\t\tdispersionColor.g = tempColor.g;\t\n\t\t\t\t} else if(j == 2) {\n\t\t\t\t\tdispersionColor.b = tempColor.b;\t\n\t\t\t\t}\n\t\t\t\ttempColor = dispersionColor;\n\t\t\t#endif\n\t\t}\t\n\t\t#pragma unroll_loop_end\n\n\tif(TRACING_DEPTH > 0)\n\t\toutgoingLight2.rgb += (1.0 - initialProbability) * tempColor;\n\n\tfloat alpha = (1.0 - initialProbability) + initialProbability*tracingOpacity;\n\tgl_FragColor = vec4(outgoingLight2.rgb, alpha*diffuseColor.a);\n\n    // CUSTOM END\n\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}\n\n";
 //# sourceMappingURL=gem.d.ts.map

package/dist/shaders/gem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gem.d.ts","sourceRoot":"","sources":["../../src/shaders/gem.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,s3CAqDhB,CAAC;AAEF,eAAO,MAAM,IAAI,q9lBA2gBhB,CAAC"}
+{"version":3,"file":"gem.d.ts","sourceRoot":"","sources":["../../src/shaders/gem.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,w9CAwDhB,CAAC;AAEF,eAAO,MAAM,IAAI,8rmBA4gBhB,CAAC"}

package/dist/shaders/gem.js

@@ -8,6 +8,7 @@ varying vec3 vViewPosition;
 	varying vec3 vWorldPosition;
 #endif
 #include <common>
+#include <batching_pars_vertex>
 #include <uv_pars_vertex>
 #include <displacementmap_pars_vertex>
 #include <color_pars_vertex>
@@ -27,7 +28,9 @@ varying vec3 frag_normal;
 void main() {
 	#include <uv_vertex>
 	#include <color_vertex>
+	#include <morphinstance_vertex>
 	#include <morphcolor_vertex>
+	#include <batching_vertex>
 	#include <beginnormal_vertex>
 	#include <morphnormal_vertex>
 	#include <skinbase_vertex>
@@ -59,7 +62,7 @@ exports.frag = `
 #define STANDARD
 #ifdef PHYSICAL
 	#define IOR
-	#define SPECULAR
+	#define USE_SPECULAR
 #endif
 
 // CUSTOM START
@@ -76,13 +79,13 @@ uniform float opacity;
 #ifdef IOR
 	uniform float ior;
 #endif
-#ifdef SPECULAR
+#ifdef USE_SPECULAR
 	uniform float specularIntensity;
 	uniform vec3 specularColor;
-	#ifdef USE_SPECULARINTENSITYMAP
+	#ifdef USE_SPECULAR_INTENSITYMAP
 		uniform sampler2D specularIntensityMap;
 	#endif
-	#ifdef USE_SPECULARCOLORMAP
+	#ifdef USE_SPECULAR_COLORMAP
 		uniform sampler2D specularColorMap;
 	#endif
 #endif
@@ -99,10 +102,10 @@ uniform float opacity;
 #ifdef USE_SHEEN
 	uniform vec3 sheenColor;
 	uniform float sheenRoughness;
-	#ifdef USE_SHEENCOLORMAP
+	#ifdef USE_SHEEN_COLORMAP
 		uniform sampler2D sheenColorMap;
 	#endif
-	#ifdef USE_SHEENROUGHNESSMAP
+	#ifdef USE_SHEEN_ROUGHNESSMAP
 		uniform sampler2D sheenRoughnessMap;
 	#endif
 #endif
@@ -115,6 +118,7 @@ varying vec3 vViewPosition;
 #include <map_pars_fragment>
 #include <alphamap_pars_fragment>
 #include <alphatest_pars_fragment>
+#include <alphahash_pars_fragment>
 #include <aomap_pars_fragment>
 #include <lightmap_pars_fragment>
 #include <emissivemap_pars_fragment>
@@ -169,10 +173,10 @@ vec3 getIBLRadianceVariation( const in vec3 viewDir, const in vec3 normal, const
 	#if defined( ENVMAP_TYPE_CUBE_UV )
 		vec3 reflectVec = reflect( - viewDir, normal );
 		// Mixing the reflection with the normal is more accurate and keeps rough objects from gathering light from behind their tangent plane.
-		reflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );
+		reflectVec = normalize( mix( reflectVec, normal, pow4( roughness ) ) );
 		reflectVec = inverseTransformDirection( reflectVec, viewMatrix );
-		vec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );
-		return min(envMapColor.rgb * envMapIntensity, vec3(1.0));
+		vec4 envMapColor = textureCubeUV( envMap, envMapRotation * reflectVec, roughness );
+		return envMapColor.rgb * envMapIntensity;
 	#else
 		return vec3( 0.0 );
 	#endif
@@ -193,13 +197,13 @@ vec3 calculateReflectedLight(vec3 position, vec3 normal, vec3 viewDir, PhysicalM
 	// Calculate the view direction vector in world space
 	vec3 currentGeometryViewDir = normalize(normalMatrix * -viewDir);
 
-    vec3 currentGeometryClearcoatNormal;
+    vec3 currentGeometryClearcoatNormal = vec3( 0.0 );
 	
 	#ifdef USE_CLEARCOAT
         currentGeometryClearcoatNormal = clearcoatNormal;
     #endif
 
-	ReflectedLight rLight;
+	ReflectedLight rLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
 	IncidentLight dLight;
 
 	float temp = material.roughness;
@@ -218,7 +222,7 @@ vec3 calculateReflectedLight(vec3 position, vec3 normal, vec3 viewDir, PhysicalM
             getPointLightInfo( pointLight, currentGeometryPosition, dLight );
             #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )
                 pointLightShadow = pointLightShadows[ i ];
-                dLight.color *= all( bvec2( dLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;
+                dLight.color *= ( dLight.visible && receiveShadow ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowIntensity, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;
             #endif
 		    RE_Direct( dLight, currentGeometryPosition, currentGeometryNormal, currentGeometryViewDir, currentGeometryClearcoatNormal, material, rLight );
 		}
@@ -235,7 +239,7 @@ vec3 calculateReflectedLight(vec3 position, vec3 normal, vec3 viewDir, PhysicalM
             getSpotLightInfo( spotLight, currentGeometryPosition, dLight );
             #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )
                 spotLightShadow = spotLightShadows[ i ];
-                dLight.color *= all( bvec2( dLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;
+                dLight.color *= ( dLight.visible && receiveShadow ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowIntensity, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;
             #endif
             RE_Direct( dLight, currentGeometryPosition, currentGeometryNormal, currentGeometryViewDir, currentGeometryClearcoatNormal, material, rLight );
         }
@@ -253,7 +257,7 @@ vec3 calculateReflectedLight(vec3 position, vec3 normal, vec3 viewDir, PhysicalM
             getDirectionalLightInfo( directionalLight, dLight );
             #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )
                 directionalLightShadow = directionalLightShadows[ i ];
-                dLight.color *= all( bvec2( dLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
+                dLight.color *= ( dLight.visible && receiveShadow ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowIntensity, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
             #endif
             RE_Direct( dLight, currentGeometryPosition, currentGeometryNormal, currentGeometryViewDir, currentGeometryClearcoatNormal, material, rLight );
         }
@@ -293,7 +297,7 @@ vec3 calculateReflectedLight(vec3 position, vec3 normal, vec3 viewDir, PhysicalM
 
     #if defined( RE_IndirectDiffuse )
         #ifdef USE_LIGHTMAP
-            vec4 lightMapTexel = texture2D( lightMap, vUv2 );
+            vec4 lightMapTexel = texture2D( lightMap, vLightMapUv );
             vec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;
             irradiance += lightMapIrradiance;
         #endif
@@ -361,7 +365,7 @@ vec3 normalLookUp(vec3 dir) {
 
 #ifdef USE_IMPURITYMAP
 	float impurityLookUp(vec3 dir) {
-		vec3 c = textureCube(impurityMap, dir.xy).rgb;
+		vec3 c = texture2D(impurityMap, dir.xy * 0.5 + 0.5).rgb;
 		return (c.x + c.y + c.z) / 3.0;
 	}
 #endif
@@ -421,6 +425,7 @@ void main() {
 	#include <color_fragment>
 	#include <alphamap_fragment>
 	#include <alphatest_fragment>
+	#include <alphahash_fragment>
 	#include <roughnessmap_fragment>
 	#include <metalnessmap_fragment>
 	#include <normal_fragment_begin>
@@ -438,13 +443,12 @@ void main() {
 	#include <transmission_fragment>
 	vec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;
 	#ifdef USE_SHEEN
-		float sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );
-		outgoingLight = outgoingLight * sheenEnergyComp + sheenSpecular;
+		outgoingLight = outgoingLight + sheenSpecularDirect + sheenSpecularIndirect;
 	#endif
 	#ifdef USE_CLEARCOAT
-		float dotNVcc = saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );
+		float dotNVcc = saturate( dot( geometryClearcoatNormal, geometryViewDir ) );
 		vec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );
-		outgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + clearcoatSpecular * material.clearcoat;
+		outgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + ( clearcoatSpecularDirect + clearcoatSpecularIndirect ) * material.clearcoat;
 	#endif
 	#include <opaque_fragment>
 

package/dist/shaders/gem.js.map

@@ -1 +1 @@
-{"version":3,"file":"gem.js","sourceRoot":"","sources":["../../src/shaders/gem.ts"],"names":[],"mappings":";;;AAAa,QAAA,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDnB,CAAC;AAEW,QAAA,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2gBnB,CAAC"}
+{"version":3,"file":"gem.js","sourceRoot":"","sources":["../../src/shaders/gem.ts"],"names":[],"mappings":";;;AAAa,QAAA,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwDnB,CAAC;AAEW,QAAA,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4gBnB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@shapediver/viewer.rendering-engine.rendering-engine-threejs",
-	"version": "3.19.3",
+	"version": "3.20.1",
 	"description": "",
 	"keywords": [],
 	"author": "Michael Oppitz <michael@shapediver.com>",
@@ -37,28 +37,28 @@
 		"testEnvironment": "node"
 	},
 	"dependencies": {
-		"@shapediver/viewer.data-engine.gltf-converter": "3.19.3",
-		"@shapediver/viewer.data-engine.shared-types": "3.19.3",
-		"@shapediver/viewer.data-engine.tag3d-engine": "3.19.3",
-		"@shapediver/viewer.rendering-engine.animation-engine": "3.19.3",
-		"@shapediver/viewer.rendering-engine.animation-frame-engine": "3.19.3",
-		"@shapediver/viewer.rendering-engine.camera-engine": "3.19.3",
-		"@shapediver/viewer.rendering-engine.canvas-engine": "3.19.3",
-		"@shapediver/viewer.rendering-engine.intersection-engine": "3.19.3",
-		"@shapediver/viewer.rendering-engine.light-engine": "3.19.3",
-		"@shapediver/viewer.rendering-engine.rendering-engine": "3.19.3",
-		"@shapediver/viewer.shared.global-access-objects": "3.19.3",
-		"@shapediver/viewer.shared.math": "3.19.3",
-		"@shapediver/viewer.shared.node-tree": "3.19.3",
-		"@shapediver/viewer.shared.services": "3.19.3",
-		"@shapediver/viewer.shared.types": "3.19.3",
+		"@shapediver/viewer.data-engine.gltf-converter": "3.20.1",
+		"@shapediver/viewer.data-engine.shared-types": "3.20.1",
+		"@shapediver/viewer.data-engine.tag3d-engine": "3.20.1",
+		"@shapediver/viewer.rendering-engine.animation-engine": "3.20.1",
+		"@shapediver/viewer.rendering-engine.animation-frame-engine": "3.20.1",
+		"@shapediver/viewer.rendering-engine.camera-engine": "3.20.1",
+		"@shapediver/viewer.rendering-engine.canvas-engine": "3.20.1",
+		"@shapediver/viewer.rendering-engine.intersection-engine": "3.20.1",
+		"@shapediver/viewer.rendering-engine.light-engine": "3.20.1",
+		"@shapediver/viewer.rendering-engine.rendering-engine": "3.20.1",
+		"@shapediver/viewer.shared.global-access-objects": "3.20.1",
+		"@shapediver/viewer.shared.math": "3.20.1",
+		"@shapediver/viewer.shared.node-tree": "3.20.1",
+		"@shapediver/viewer.shared.services": "3.20.1",
+		"@shapediver/viewer.shared.types": "3.20.1",
 		"@tweenjs/tween.js": "25.0.0",
 		"@types/stats.js": "0.17.4",
-		"@types/three": "0.162.0",
+		"@types/three": "0.184.1",
 		"gl-matrix": "3.4.4",
-		"postprocessing": "6.35.3",
+		"postprocessing": "6.39.1",
 		"stats.js": "0.17.0",
-		"three": "0.162.0"
+		"three": "0.184.0"
 	},
-	"gitHead": "447c1056900cc0a6add0a5d363c705b703e95c11"
+	"gitHead": "1496133cb9d6973f9ee07de4d26decee7e7417fd"
 }