@shapediver/viewer.rendering-engine.rendering-engine-threejs 3.19.2 → 3.20.0

package/dist/managers/postprocessing/effects/tone-mapping/ToneMappingEffect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ToneMappingEffect.d.ts","sourceRoot":"","sources":["../../../../../src/managers/postprocessing/effects/tone-mapping/ToneMappingEffect.ts"],"names":[],"mappings":"AACA,OAAO,EACN,qBAAqB,EACrB,aAAa,EACb,MAAM,EAEN,aAAa,EACb,eAAe,EACf,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAIN,aAAa,EACb,iBAAiB,EACjB,MAAM,OAAO,CAAC;AAGf;;;;;;;;GAQG;AAEH,qBAAa,iBAAkB,SAAQ,MAAM;IAC5C,qBAAqB,EAAE,qBAAqB,CAAC;IACtC,aAAa,EAAE,aAAa,CAAC;IAC7B,qBAAqB,EAAE,iBAAiB,CAAC;IAEhD;;;;;;;;;;;;;;;;OAgBG;gBACS,EACX,aAAiC,EACjC,QAAgB,EAChB,IAEsB,EACtB,UAAgB,EAChB,YAAkB,EAClB,UAAyB,EACzB,UAAgB,EAChB,YAAmB,EACnB,gBAAsB,EACtB,cAAoB,GACpB,GAAE;QACF,aAAa,CAAC,EAAE,aAAa,CAAC;QAC9B,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,IAAI,CAAC,EAAE,eAAe,CAAC;QACvB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;KACnB;IA4DN;;;;;OAKG;IAEH,IAAW,cAAc,QAExB;IAED,IAAW,cAAc,CAAC,KAAK,KAAA,EAE9B;IAED;;;;;OAKG;IAEH,IAAW,QAAQ,YAElB;IAED,IAAW,QAAQ,CAAC,KAAK,SAAA,EAIxB;IAED;;;;OAIG;IAEH,IAAW,yBAAyB,6BAEnC;IAED;;;;;;OAMG;IAEH,IAAW,gBAAgB,QAE1B;IAED,IAAW,gBAAgB,CAAC,KAAK,KAAA,EAEhC;IAED;;;OAGG;IAEH,IAAW,WAAW,WAGrB;IAED,IAAW,WAAW,CAAC,KAAK,QAAA,EAE3B;IAED;;;;;;OAMG;IAEH,IAAW,UAAU,QAEpB;IAED,IAAW,UAAU,CAAC,KAAK,KAAA,EAE1B;IAED;;;;OAIG;IAEH,IAAW,IAAI,WAEd;IAED,IAAW,IAAI,CAAC,KAAK,QAAA,EA4DpB;IAED;;;;OAIG;IAEH,IAAW,UAAU,WAEpB;IAED,IAAW,UAAU,CAAC,KAAK,QAAA,EAO1B;IAED;;;;;;OAMG;IAEH,IAAW,UAAU,QAEpB;IAED,IAAW,UAAU,CAAC,KAAK,KAAA,EAE1B;IAED;;;;;OAKG;IAEI,4BAA4B;IAInC;;;;;OAKG;IAEI,OAAO;IAId;;;;;OAKG;IAEI,aAAa;IAIpB;;;;;;OAMG;IAEI,UAAU,CAChB,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,OAAO,EACd,eAAe,EAAE,MAAM;IAKxB;;;;;OAKG;IAEI,OAAO,CAAC,KAAK,EAAE,eAAe;IAIrC;;;;;OAKG;IAEI,aAAa,CAAC,KAAK,EAAE,MAAM;IAIlC;;;;;;OAMG;IAEI,MAAM,CACZ,QAAQ,EAAE,aAAa,EACvB,WAAW,EAAE,iBAAiB,EAC9B,SAAS,EAAE,MAAM;CAOlB"}
+{"version":3,"file":"ToneMappingEffect.d.ts","sourceRoot":"","sources":["../../../../../src/managers/postprocessing/effects/tone-mapping/ToneMappingEffect.ts"],"names":[],"mappings":"AACA,OAAO,EACN,qBAAqB,EACrB,aAAa,EACb,MAAM,EAEN,aAAa,EACb,eAAe,EACf,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAIN,aAAa,EACb,iBAAiB,EACjB,MAAM,OAAO,CAAC;AAGf;;;;;;;;GAQG;AAEH,qBAAa,iBAAkB,SAAQ,MAAM;IAC5C,qBAAqB,EAAE,qBAAqB,CAAC;IACtC,aAAa,EAAE,aAAa,CAAC;IAC7B,qBAAqB,EAAE,iBAAiB,CAAC;IAEhD;;;;;;;;;;;;;;;;OAgBG;gBACS,EACX,aAAiC,EACjC,QAAgB,EAChB,IAEsB,EACtB,UAAgB,EAChB,YAAkB,EAClB,UAAyB,EACzB,UAAgB,EAChB,YAAmB,EACnB,gBAAsB,EACtB,cAAoB,GACpB,GAAE;QACF,aAAa,CAAC,EAAE,aAAa,CAAC;QAC9B,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,IAAI,CAAC,EAAE,eAAe,CAAC;QACvB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;KACnB;IA4DN;;;;;OAKG;IAEH,IAAW,cAAc,QAExB;IAED,IAAW,cAAc,CAAC,KAAK,KAAA,EAE9B;IAED;;;;;OAKG;IAEH,IAAW,QAAQ,YAElB;IAED,IAAW,QAAQ,CAAC,KAAK,SAAA,EAIxB;IAED;;;;OAIG;IAEH,IAAW,yBAAyB,+DAEnC;IAED;;;;;;OAMG;IAEH,IAAW,gBAAgB,QAE1B;IAED,IAAW,gBAAgB,CAAC,KAAK,KAAA,EAEhC;IAED;;;OAGG;IAEH,IAAW,WAAW,WAGrB;IAED,IAAW,WAAW,CAAC,KAAK,QAAA,EAE3B;IAED;;;;;;OAMG;IAEH,IAAW,UAAU,QAEpB;IAED,IAAW,UAAU,CAAC,KAAK,KAAA,EAE1B;IAED;;;;OAIG;IAEH,IAAW,IAAI,WAEd;IAED,IAAW,IAAI,CAAC,KAAK,QAAA,EA4DpB;IAED;;;;OAIG;IAEH,IAAW,UAAU,WAEpB;IAED,IAAW,UAAU,CAAC,KAAK,QAAA,EAO1B;IAED;;;;;;OAMG;IAEH,IAAW,UAAU,QAEpB;IAED,IAAW,UAAU,CAAC,KAAK,KAAA,EAE1B;IAED;;;;;OAKG;IAEI,4BAA4B;IAInC;;;;;OAKG;IAEI,OAAO;IAId;;;;;OAKG;IAEI,aAAa;IAIpB;;;;;;OAMG;IAEI,UAAU,CAChB,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,OAAO,EACd,eAAe,EAAE,MAAM;IAKxB;;;;;OAKG;IAEI,OAAO,CAAC,KAAK,EAAE,eAAe;IAIrC;;;;;OAKG;IAEI,aAAa,CAAC,KAAK,EAAE,MAAM;IAIlC;;;;;;OAMG;IAEI,MAAM,CACZ,QAAQ,EAAE,aAAa,EACvB,WAAW,EAAE,iBAAiB,EAC9B,SAAS,EAAE,MAAM;CAOlB"}

package/dist/managers/postprocessing/utils/FullScreenQuad.d.ts

@@ -4,7 +4,7 @@ export declare class FullScreenQuad {
     constructor(material: Material);
     dispose(): void;
     render(renderer: WebGLRenderer): void;
-    get material(): Material | Material[];
-    set material(value: Material | Material[]);
+    get material(): Material<import("three").MaterialEventMap> | Material<import("three").MaterialEventMap>[];
+    set material(value: Material<import("three").MaterialEventMap> | Material<import("three").MaterialEventMap>[]);
 }
 //# sourceMappingURL=FullScreenQuad.d.ts.map

package/dist/managers/postprocessing/utils/FullScreenQuad.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FullScreenQuad.d.ts","sourceRoot":"","sources":["../../../../src/managers/postprocessing/utils/FullScreenQuad.ts"],"names":[],"mappings":"AAEA,OAAO,EAGN,QAAQ,EACR,IAAI,EAEJ,aAAa,EACb,MAAM,OAAO,CAAC;AAaf,qBAAa,cAAc;IAC1B,KAAK,EAAE,IAAI,CAAC;gBAEA,QAAQ,EAAE,QAAQ;IAI9B,OAAO;IAIP,MAAM,CAAC,QAAQ,EAAE,aAAa;IAI9B,IAAI,QAAQ,0BAEX;IAED,IAAI,QAAQ,CAAC,KAAK,uBAAA,EAEjB;CACD"}
+{"version":3,"file":"FullScreenQuad.d.ts","sourceRoot":"","sources":["../../../../src/managers/postprocessing/utils/FullScreenQuad.ts"],"names":[],"mappings":"AAEA,OAAO,EAGN,QAAQ,EACR,IAAI,EAEJ,aAAa,EACb,MAAM,OAAO,CAAC;AAaf,qBAAa,cAAc;IAC1B,KAAK,EAAE,IAAI,CAAC;gBAEA,QAAQ,EAAE,QAAQ;IAI9B,OAAO;IAIP,MAAM,CAAC,QAAQ,EAAE,aAAa;IAI9B,IAAI,QAAQ,8FAEX;IAED,IAAI,QAAQ,CAAC,KAAK,2FAAA,EAEjB;CACD"}

package/dist/managers/postprocessing/utils/NormalPass.d.ts

@@ -37,8 +37,8 @@ export declare class NormalPass extends Pass {
      *
      * @type {Texture}
      */
-    get texture(): Texture | undefined;
-    get depthTexture(): DepthTexture | undefined;
+    get texture(): Texture<unknown, import("three").TextureEventMap> | undefined;
+    get depthTexture(): DepthTexture | null | undefined;
     /**
      * The normal texture.
      *

package/dist/managers/postprocessing/utils/NormalPass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NormalPass.d.ts","sourceRoot":"","sources":["../../../../src/managers/postprocessing/utils/NormalPass.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAE,UAAU,EAAC,MAAM,gBAAgB,CAAC;AAChD,OAAO,EACN,MAAM,EAGN,YAAY,EAGZ,KAAK,EACL,OAAO,EAGP,aAAa,EACb,iBAAiB,EACjB,MAAM,OAAO,CAAC;AACf,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AAExC;;GAEG;AAEH,qBAAa,UAAW,SAAQ,IAAI;IACnC,UAAU,EAAE,UAAU,CAAC;IACvB,YAAY,EAAE,iBAAiB,GAAG,SAAS,CAAC;IAC5C,UAAU,EAAE,UAAU,CAAC;IACvB,QAAQ,EAAE,GAAG,CAAC;IAEd;;;;;;;;;;;;OAYG;gBAGF,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,EACC,YAAY,EACZ,eAAqB,EACrB,KAA4B,EAC5B,MAA6B,EAC7B,WAAmB,EACnB,WAAoB,GACpB,GAAE;QACF,YAAY,CAAC,EAAE,iBAAiB,CAAC;QACjC,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;KACX;IA4EP,IAAI,SAAS,CAAC,KAAK,EAAE,KAAK,EAEzB;IAED,IAAI,UAAU,CAAC,KAAK,EAAE,MAAM,EAE3B;IAED;;;;OAIG;IAEH,IAAI,OAAO,wBAEV;IAED,IAAI,YAAY,6BAEf;IAED;;;;;OAKG;IAEH,UAAU,IAAI,OAAO,GAAG,SAAS;IAIjC;;;;;OAKG;IAEH,aAAa,IAAI,UAAU;IAI3B;;;;;OAKG;IAEH,kBAAkB,IAAI,MAAM;IAI5B;;;;;OAKG;IAEH,kBAAkB,CAAC,KAAK,EAAE,MAAM;IAIhC;;;;;;;;OAQG;IAEH,MAAM,CAAC,QAAQ,EAAE,aAAa;IAK9B;;;;;OAKG;IAEH,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAKrC"}
+{"version":3,"file":"NormalPass.d.ts","sourceRoot":"","sources":["../../../../src/managers/postprocessing/utils/NormalPass.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAE,UAAU,EAAC,MAAM,gBAAgB,CAAC;AAChD,OAAO,EACN,MAAM,EAGN,YAAY,EAGZ,KAAK,EACL,OAAO,EAGP,aAAa,EACb,iBAAiB,EACjB,MAAM,OAAO,CAAC;AACf,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AAExC;;GAEG;AAEH,qBAAa,UAAW,SAAQ,IAAI;IACnC,UAAU,EAAE,UAAU,CAAC;IACvB,YAAY,EAAE,iBAAiB,GAAG,SAAS,CAAC;IAC5C,UAAU,EAAE,UAAU,CAAC;IACvB,QAAQ,EAAE,GAAG,CAAC;IAEd;;;;;;;;;;;;OAYG;gBAGF,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,EACC,YAAY,EACZ,eAAqB,EACrB,KAA4B,EAC5B,MAA6B,EAC7B,WAAmB,EACnB,WAAoB,GACpB,GAAE;QACF,YAAY,CAAC,EAAE,iBAAiB,CAAC;QACjC,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;KACX;IA4EP,IAAI,SAAS,CAAC,KAAK,EAAE,KAAK,EAEzB;IAED,IAAI,UAAU,CAAC,KAAK,EAAE,MAAM,EAE3B;IAED;;;;OAIG;IAEH,IAAI,OAAO,kEAEV;IAED,IAAI,YAAY,oCAEf;IAED;;;;;OAKG;IAEH,UAAU,IAAI,OAAO,GAAG,SAAS;IAIjC;;;;;OAKG;IAEH,aAAa,IAAI,UAAU;IAI3B;;;;;OAKG;IAEH,kBAAkB,IAAI,MAAM;IAI5B;;;;;OAKG;IAEH,kBAAkB,CAAC,KAAK,EAAE,MAAM;IAIhC;;;;;;;;OAQG;IAEH,MAAM,CAAC,QAAQ,EAAE,aAAa;IAK9B;;;;;OAKG;IAEH,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAKrC"}

package/dist/materials/SpecularGlossinessMaterial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpecularGlossinessMaterial.d.ts","sourceRoot":"","sources":["../../src/materials/SpecularGlossinessMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAC,oBAAoB,EAAE,8BAA8B,EAAC,MAAM,OAAO,CAAC;AAE3E,MAAM,WAAW,oCAChB,SAAQ,8BAA8B;IAGtC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,aAAa,CAAC,EAAE,KAAK,CAAC,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC;IACjD,QAAQ,CAAC,EAAE,KAAK,CAAC,mBAAmB,GAAG,SAAS,CAAC;IACjD,YAAY,CAAC,EAAE,KAAK,CAAC,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC;CAGhD;AAED,qBAAa,0BAA2B,SAAQ,oBAAoB;IAG5D,gCAAgC,EAAE,OAAO,CAAC;gBAMrC,MAAM,EAAE,oCAAoC;IAyJjD,IAAI,CAAC,MAAM,EAAE,0BAA0B;CAe9C"}
+{"version":3,"file":"SpecularGlossinessMaterial.d.ts","sourceRoot":"","sources":["../../src/materials/SpecularGlossinessMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAC,oBAAoB,EAAE,8BAA8B,EAAC,MAAM,OAAO,CAAC;AAE3E,MAAM,WAAW,oCAChB,SAAQ,8BAA8B;IAGtC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,aAAa,CAAC,EAAE,KAAK,CAAC,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC;IACjD,QAAQ,CAAC,EAAE,KAAK,CAAC,mBAAmB,GAAG,SAAS,CAAC;IACjD,YAAY,CAAC,EAAE,KAAK,CAAC,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC;CAGhD;AAED,qBAAa,0BAA2B,SAAQ,oBAAoB;IAG5D,gCAAgC,EAAE,OAAO,CAAC;gBAMrC,MAAM,EAAE,oCAAoC;IAkKjD,IAAI,CAAC,MAAM,EAAE,0BAA0B;CAe9C"}

package/dist/materials/SpecularGlossinessMaterial.js

@@ -71,13 +71,20 @@ class SpecularGlossinessMaterial extends three_1.MeshStandardMaterial {
         ].join("\n");
         const lightPhysicalFragmentChunk = [
             "PhysicalMaterial material;",
-            "material.diffuseColor = diffuseColor.rgb * ( 1. - max( specularFactor.r, max( specularFactor.g, specularFactor.b ) ) );",
-            "vec3 dxy = max( abs( dFdx( nonPerturbedNormal  ) ), abs( dFdy( nonPerturbedNormal ) ) );",
+            "material.diffuseColor = diffuseColor.rgb * ( 1.0 - max( specularFactor.r, max( specularFactor.g, specularFactor.b ) ) );",
+            "material.diffuseContribution = material.diffuseColor;",
+            "material.metalness = 0.0;",
+            "vec3 dxy = max( abs( dFdx( nonPerturbedNormal ) ), abs( dFdy( nonPerturbedNormal ) ) );",
             "float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );",
             "material.roughness = max( 1.0 - glossinessFactor, 0.0525 ); // 0.0525 corresponds to the base mip of a 256 cubemap.",
             "material.roughness += geometryRoughness;",
             "material.roughness = min( material.roughness, 1.0 );",
             "material.specularColor = specularFactor;",
+            "material.specularColorBlended = specularFactor;",
+            "material.specularF90 = 1.0;",
+            "#ifdef USE_DISPERSION",
+            "\tmaterial.dispersion = dispersion;",
+            "#endif",
         ].join("\n");
         const uniforms = {
             specular: { value: new THREE.Color().setHex(0xffffff) },
@@ -115,10 +122,12 @@ class SpecularGlossinessMaterial extends three_1.MeshStandardMaterial {
                 set: function (v) {
                     uniforms.specularMap2.value = v;
                     if (v) {
-                        this.defines.USE_SPECULARMAP2 = ""; // USE_UV is set by the renderer for specular maps
+                        this.defines.USE_SPECULARMAP2 = "";
+                        this.defines.USE_UV = "";
                     }
                     else {
                         delete this.defines.USE_SPECULARMAP2;
+                        delete this.defines.USE_UV;
                     }
                 },
             },

package/dist/materials/SpecularGlossinessMaterial.js.map

@@ -1 +1 @@
-{"version":3,"file":"SpecularGlossinessMaterial.js","sourceRoot":"","sources":["../../src/materials/SpecularGlossinessMaterial.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"SpecularGlossinessMaterial.js","sourceRoot":"","sources":["../../src/materials/SpecularGlossinessMaterial.ts"],"names":[],"mappings":"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"}

package/dist/shaders/PCSS.d.ts

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

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

@@ -1 +1 @@
-{"version":3,"file":"PCSS.d.ts","sourceRoot":"","sources":["../../src/shaders/PCSS.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,82FAsFhB,CAAC;AAEF,eAAO,MAAM,KAAK,gyDAmCL,CAAC"}
+{"version":3,"file":"PCSS.d.ts","sourceRoot":"","sources":["../../src/shaders/PCSS.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,61FAuFhB,CAAC;AAEF,eAAO,MAAM,SAAS,yoFAuDrB,CAAC"}

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"}