@zephyr3d/scene 0.4.0 → 0.5.0

package/dist/material/mixins/pbr/common.js

@@ -1,5 +1,5 @@
 import { applyMaterialMixins } from '../../meshmaterial.js';
-import { Vector4 } from '@zephyr3d/base';
+import { Vector4, Vector3, Vector2 } from '@zephyr3d/base';
 import { getGGXLUT } from '../ggxlut.js';
 import { mixinTextureProps } from '../texture.js';
 import { ShaderHelper } from '../../shader/helper.js';
@@ -14,9 +14,11 @@ import { ShaderHelper } from '../../shader/helper.js';
     if (BaseCls.pbrCommonMixed) {
         return BaseCls;
     }
-    const S = applyMaterialMixins(BaseCls, mixinTextureProps('occlusion'), mixinTextureProps('emissive'), mixinTextureProps('sheenColor'), mixinTextureProps('sheenRoughness'), mixinTextureProps('clearcoatIntensity'), mixinTextureProps('clearcoatRoughness'), mixinTextureProps('clearcoatNormal'));
+    const S = applyMaterialMixins(BaseCls, mixinTextureProps('occlusion'), mixinTextureProps('emissive'), mixinTextureProps('sheenColor'), mixinTextureProps('sheenRoughness'), mixinTextureProps('clearcoatIntensity'), mixinTextureProps('clearcoatRoughness'), mixinTextureProps('clearcoatNormal'), mixinTextureProps('transmission'), mixinTextureProps('thickness'), mixinTextureProps('iridescence'), mixinTextureProps('iridescenceThickness'));
     let FEATURE_SHEEN = 0;
     let FEATURE_CLEARCOAT = 0;
+    let FEATURE_TRANSMISSION = 0;
+    let FEATURE_IRIDESCENCE = 0;
     const cls = class extends S {
         static pbrCommonMixed = true;
         _f0;
@@ -24,6 +26,12 @@ import { ShaderHelper } from '../../shader/helper.js';
         _occlusionStrength;
         _sheenFactor;
         _clearcoatFactor;
+        _transmissionFactor;
+        _thicknessFactor;
+        _attenuationColor;
+        _attenuationDistance;
+        _iridescenceFactor;
+        _sceneColorTexSize;
         constructor(){
             super();
             this._f0 = new Vector4(0.04, 0.04, 0.04, 1.5);
@@ -31,6 +39,12 @@ import { ShaderHelper } from '../../shader/helper.js';
             this._emissiveFactor = new Vector4(0, 0, 0, 1);
             this._sheenFactor = Vector4.zero();
             this._clearcoatFactor = new Vector4(0, 0, 1, 0);
+            this._transmissionFactor = 0;
+            this._thicknessFactor = 0;
+            this._attenuationColor = Vector3.one();
+            this._attenuationDistance = 99999;
+            this._iridescenceFactor = new Vector4(0, 1.3, 100, 400);
+            this._sceneColorTexSize = new Vector2();
         }
         get ior() {
             return this._f0.w;
@@ -43,6 +57,78 @@ import { ShaderHelper } from '../../shader/helper.js';
                 this.uniformChanged();
             }
         }
+        get transmissionFactor() {
+            return this._transmissionFactor;
+        }
+        set transmissionFactor(val) {
+            if (val !== this._transmissionFactor) {
+                this._transmissionFactor = val;
+                this.uniformChanged();
+            }
+        }
+        get thicknessFactor() {
+            return this._thicknessFactor;
+        }
+        set thicknessFactor(val) {
+            if (this._thicknessFactor !== val) {
+                this._thicknessFactor = val;
+                this.uniformChanged();
+            }
+        }
+        get attenuationColor() {
+            return this._attenuationColor;
+        }
+        set attenuationColor(val) {
+            if (!val.equalsTo(this._attenuationColor)) {
+                this._attenuationColor.set(val);
+                this.uniformChanged();
+            }
+        }
+        get attenuationDistance() {
+            return this._attenuationDistance;
+        }
+        set attenuationDistance(val) {
+            if (val !== this._attenuationDistance) {
+                this._attenuationDistance = val;
+                this.uniformChanged();
+            }
+        }
+        get iridescenceFactor() {
+            return this._iridescenceFactor.x;
+        }
+        set iridescenceFactor(val) {
+            if (this._iridescenceFactor.x !== val) {
+                this._iridescenceFactor.x = val;
+                this.uniformChanged();
+            }
+        }
+        get iridescenceIor() {
+            return this._iridescenceFactor.y;
+        }
+        set iridescenceIor(val) {
+            if (this._iridescenceFactor.y !== val) {
+                this._iridescenceFactor.y = val;
+                this.uniformChanged();
+            }
+        }
+        get iridescenceThicknessMin() {
+            return this._iridescenceFactor.z;
+        }
+        set iridescenceThicknessMin(val) {
+            if (this._iridescenceFactor.z !== val) {
+                this._iridescenceFactor.z = val;
+                this.uniformChanged();
+            }
+        }
+        get iridescenceThicknessMax() {
+            return this._iridescenceFactor.w;
+        }
+        set iridescenceThicknessMax(val) {
+            if (this._iridescenceFactor.w !== val) {
+                this._iridescenceFactor.w = val;
+                this.uniformChanged();
+            }
+        }
         get occlusionStrength() {
             return this._occlusionStrength;
         }
@@ -72,6 +158,18 @@ import { ShaderHelper } from '../../shader/helper.js';
                 this.uniformChanged();
             }
         }
+        get transmission() {
+            return this.featureUsed(FEATURE_TRANSMISSION);
+        }
+        set transmission(val) {
+            this.useFeature(FEATURE_TRANSMISSION, !!val);
+        }
+        get iridescence() {
+            return this.featureUsed(FEATURE_IRIDESCENCE);
+        }
+        set iridescence(val) {
+            this.useFeature(FEATURE_IRIDESCENCE, !!val);
+        }
         get clearcoat() {
             return this.featureUsed(FEATURE_CLEARCOAT);
         }
@@ -146,11 +244,25 @@ import { ShaderHelper } from '../../shader/helper.js';
                 if (this.clearcoat) {
                     scope.zClearcoatFactor = pb.vec4().uniform(2);
                 }
+                if (this.transmission) {
+                    scope.zTransmissionFactor = pb.float().uniform(2);
+                    scope.zThicknessFactor = pb.float().uniform(2);
+                    scope.zAttenuationColor = pb.vec3().uniform(2);
+                    scope.zAttenuationDistance = pb.float().uniform(2);
+                    scope.zSceneColorTex = pb.tex2D().uniform(2);
+                    scope.zSceneColorTexSize = pb.vec2().uniform(2);
+                }
+                if (this.iridescence) {
+                    scope.zIridescenceFactor = pb.vec4().uniform(2);
+                }
                 if (this.drawContext.drawEnvLight) {
                     scope.zGGXLut = pb.tex2D().uniform(2);
                 }
             }
         }
+        needSceneColor() {
+            return this.transmission;
+        }
         applyUniformValues(bindGroup, ctx, pass) {
             super.applyUniformValues(bindGroup, ctx, pass);
             if (this.needFragmentColor(ctx)) {
@@ -165,6 +277,18 @@ import { ShaderHelper } from '../../shader/helper.js';
                 if (this.clearcoat) {
                     bindGroup.setValue('zClearcoatFactor', this._clearcoatFactor);
                 }
+                if (this.transmission) {
+                    bindGroup.setValue('zTransmissionFactor', this._transmissionFactor);
+                    bindGroup.setValue('zThicknessFactor', this._thicknessFactor);
+                    bindGroup.setValue('zAttenuationColor', this._attenuationColor);
+                    bindGroup.setValue('zAttenuationDistance', this._attenuationDistance);
+                    bindGroup.setTexture('zSceneColorTex', ctx.sceneColorTexture);
+                    this._sceneColorTexSize.setXY(ctx.sceneColorTexture.width, ctx.sceneColorTexture.height);
+                    bindGroup.setValue('zSceneColorTexSize', this._sceneColorTexSize);
+                }
+                if (this.iridescence) {
+                    bindGroup.setValue('zIridescenceFactor', this._iridescenceFactor);
+                }
                 if (ctx.drawEnvLight) {
                     bindGroup.setTexture('zGGXLut', getGGXLUT(1024));
                 }
@@ -192,25 +316,37 @@ import { ShaderHelper } from '../../shader/helper.js';
                     pb.vec3('ccNormal'),
                     pb.float('ccNoV'),
                     pb.float('ccFresnel')
+                ] : [],
+                ...this.transmission ? [
+                    pb.float('transmissionFactor'),
+                    pb.float('thicknessFactor'),
+                    pb.vec3('attenuationColor'),
+                    pb.float('attenuationDistance')
+                ] : [],
+                ...this.iridescence ? [
+                    pb.vec4('iridescenceFactor'),
+                    pb.vec3('iridescenceFresnel'),
+                    pb.vec3('iridescenceF0')
                 ] : []
             ]);
         }
-        getCommonData(scope, albedo, viewVec, TBN) {
+        getCommonData(scope, albedo, normal, viewVec, TBN) {
             const pb = scope.$builder;
             const that = this;
             const funcName = 'Z_getCommonData';
             pb.func(funcName, [
                 pb.vec4('albedo'),
+                pb.vec3('normal'),
                 pb.vec3('viewVec'),
                 pb.mat3('TBN')
             ], function() {
                 this.$l.data = that.getCommonDatasStruct(this)();
-                that.calculateCommonData(this, this.albedo, this.viewVec, this.TBN, this.data);
+                that.calculateCommonData(this, this.albedo, this.normal, this.viewVec, this.TBN, this.data);
                 this.$return(this.data);
             });
-            return scope.$g[funcName](albedo, viewVec, TBN);
+            return scope.$g[funcName](albedo, normal, viewVec, TBN);
         }
-        calculateCommonData(scope, albedo, viewVec, TBN, data) {
+        calculateCommonData(scope, albedo, normal, viewVec, TBN, data) {
             const pb = scope.$builder;
             if (this.sheen) {
                 if (this.sheenColorTexture) {
@@ -242,6 +378,31 @@ import { ShaderHelper } from '../../shader/helper.js';
                     data.ccFactor.y = pb.clamp(pb.mul(data.ccFactor.y, this.sampleClearcoatRoughnessTexture(scope).g), 0, 1);
                 }
             }
+            if (this.transmission) {
+                if (this.transmissionTexture) {
+                    data.transmissionFactor = pb.mul(this.sampleTransmissionTexture(scope).r, scope.zTransmissionFactor);
+                } else {
+                    data.transmissionFactor = scope.zTransmissionFactor;
+                }
+                if (this.thicknessTexture) {
+                    data.thicknessFactor = pb.mul(this.sampleThicknessTexture(scope).g, scope.zThicknessFactor);
+                } else {
+                    data.thicknessFactor = scope.zThicknessFactor;
+                }
+                data.attenuationColor = scope.zAttenuationColor;
+                data.attenuationDistance = scope.zAttenuationDistance;
+            }
+            if (this.iridescence) {
+                data.iridescenceFactor = scope.zIridescenceFactor;
+                if (this.iridescenceTexture) {
+                    data.iridescenceFactor.x = pb.mul(this.sampleIridescenceTexture(scope).r, data.iridescenceFactor.x);
+                }
+                if (this.iridescenceThicknessTexture) {
+                    data.iridescenceFactor.w = pb.mix(data.iridescenceFactor.z, data.iridescenceFactor.w, this.sampleIridescenceThicknessTexture(scope).g);
+                }
+                data.iridescenceFresnel = this.evalIridescence(scope, 1, data.iridescenceFactor.y, pb.clamp(pb.dot(normal, viewVec), 0, 1), data.iridescenceFactor.w, data.f0.rgb);
+                data.iridescenceF0 = this.schlickToF0(scope, data.iridescenceFresnel, pb.vec3(1), pb.clamp(pb.dot(normal, viewVec), 0, 1));
+            }
         }
         calculateEmissiveColor(scope) {
             const pb = scope.$builder;
@@ -277,6 +438,107 @@ import { ShaderHelper } from '../../shader/helper.js';
             });
             return scope.$g[funcNameVAshikhmin](NdotL, NdotV);
         }
+        getVolumeTransmissionRay(scope, normal, viewVec, thickness, ior) {
+            const pb = scope.$builder;
+            const funcName = 'getVolumeTransmissionRay';
+            pb.func(funcName, [
+                pb.vec3('normal'),
+                pb.vec3('viewVec'),
+                pb.float('thickness'),
+                pb.float('ior')
+            ], function() {
+                this.$l.refractionVector = pb.refract(pb.neg(this.viewVec), this.normal, pb.div(1, this.ior));
+                this.$return(pb.mul(this.refractionVector, this.$inputs.modelScale, this.thickness));
+            });
+            return pb.getGlobalScope()[funcName](normal, viewVec, thickness, ior);
+        }
+        getTransmissionSample(scope, fragCoord, roughness, ior) {
+            const pb = scope.$builder;
+            const funcName = 'getTransmissionSample';
+            pb.func(funcName, [
+                pb.vec2('fragCoord'),
+                pb.float('roughness'),
+                pb.float('ior')
+            ], function() {
+                this.$l.applyIorToRoughness = pb.mul(this.roughness, pb.clamp(pb.sub(pb.mul(this.ior, 2), 2), 0.0, 1.0));
+                this.$l.framebufferLod = pb.mul(pb.log2(this.zSceneColorTexSize.x), this.applyIorToRoughness);
+                this.$return(pb.textureSampleLevel(this.zSceneColorTex, this.fragCoord, this.framebufferLod).rgb);
+            });
+            return pb.getGlobalScope()[funcName](fragCoord, roughness, ior);
+        }
+        getPunctualRadianceTransmission(scope, normal, viewVec, lightDir, alphaRoughness, f0, f90, baseColor, ior) {
+            const pb = scope.$builder;
+            const that = this;
+            const funcName = 'getPunctualRadianceTransmission';
+            pb.func(funcName, [
+                pb.vec3('normal'),
+                pb.vec3('viewVec'),
+                pb.vec3('L'),
+                pb.float('alphaRoughness'),
+                pb.vec3('f0'),
+                pb.vec3('f90'),
+                pb.vec3('baseColor'),
+                pb.float('ior')
+            ], function() {
+                this.$l.transmissionRoughness = pb.mul(this.alphaRoughness, pb.clamp(pb.sub(pb.mul(this.ior, 2), 2), 0.0, 1.0));
+                this.$l.mirrorL = pb.normalize(pb.add(this.L, pb.mul(this.normal, pb.dot(pb.neg(this.L), this.normal), 2)));
+                this.$l.h = pb.normalize(pb.add(this.viewVec, this.mirrorL));
+                this.$l.D = that.distributionGGX(this, pb.clamp(pb.dot(this.normal, this.h), 0, 1), this.transmissionRoughness);
+                this.$l.F = that.fresnelSchlick(this, pb.clamp(pb.dot(this.viewVec, this.h), 0, 1), this.f0, this.f90);
+                this.$l.V = that.visGGX(this, pb.clamp(pb.dot(this.normal, this.viewVec), 0, 1), pb.clamp(pb.dot(this.normal, this.mirrorL), 0, 1), this.transmissionRoughness);
+                this.$return(pb.mul(pb.sub(pb.vec3(1), this.F), this.baseColor, this.D, this.V));
+            });
+            return pb.getGlobalScope()[funcName](normal, viewVec, lightDir, alphaRoughness, f0, f90, baseColor, ior);
+        }
+        applyVolumeAttenuation(scope, radiance, transmissionDistance, attenuationColor, attenuationDistance) {
+            const pb = scope.$builder;
+            const funcName = 'applyVolumeAttenuation';
+            pb.func(funcName, [
+                pb.vec3('radiance'),
+                pb.float('transmissionDistance'),
+                pb.vec3('attenuationColor'),
+                pb.float('attenuationDistance')
+            ], function() {
+                this.$if(pb.equal(this.attenuationDistance, 0), function() {
+                    this.$return(this.radiance);
+                }).$else(function() {
+                    this.$l.attenuationCoefficient = pb.div(pb.neg(pb.log(this.attenuationColor)), this.attenuationDistance);
+                    this.$l.transmittance = pb.exp(pb.mul(pb.neg(this.attenuationCoefficient), this.transmissionDistance));
+                    this.$return(pb.mul(this.radiance, this.transmittance));
+                });
+            });
+            return pb.getGlobalScope()[funcName](radiance, transmissionDistance, attenuationColor, attenuationDistance);
+        }
+        getIBLVolumnRefraction(scope, brdf, normal, viewVec, roughness, baseColor, f0, f90, position, ior, thickness, attenuationColor, attenuationDistance) {
+            const pb = scope.$builder;
+            const funcName = 'getIBLVolumeRefraction';
+            const that = this;
+            pb.func(funcName, [
+                pb.vec2('brdf'),
+                pb.vec3('normal'),
+                pb.vec3('viewVec'),
+                pb.float('roughness'),
+                pb.vec3('baseColor'),
+                pb.vec3('f0'),
+                pb.vec3('f90'),
+                pb.vec3('position'),
+                pb.float('ior'),
+                pb.float('thickness'),
+                pb.vec3('attenuationColor'),
+                pb.float('attenuationDistance')
+            ], function() {
+                this.$l.transmissionRay = that.getVolumeTransmissionRay(this, this.normal, this.viewVec, this.thickness, this.ior);
+                this.$l.transmissionRayLength = pb.length(this.transmissionRay);
+                this.$l.refractedRayExit = pb.add(this.position, this.transmissionRay);
+                this.$l.ndcPos = pb.mul(ShaderHelper.getViewProjectionMatrix(this), pb.vec4(this.refractedRayExit, 1));
+                this.$l.refractionCoords = pb.add(pb.mul(pb.div(this.ndcPos.xy, this.ndcPos.w), 0.5), pb.vec2(0.5));
+                this.$l.transmittedLight = that.getTransmissionSample(this, this.refractionCoords, this.roughness, this.ior);
+                this.$l.attColor = that.applyVolumeAttenuation(this, this.transmittedLight, this.transmissionRayLength, this.attenuationColor, this.attenuationDistance);
+                this.$l.specularColor = pb.add(pb.mul(this.f0, this.brdf.x), pb.mul(this.f90, this.brdf.y));
+                this.$return(pb.mul(pb.sub(pb.vec3(1), this.specularColor), this.attColor, this.baseColor));
+            });
+            return pb.getGlobalScope()[funcName](brdf, normal, viewVec, roughness, baseColor, f0, f90, position, ior, thickness, attenuationColor, attenuationDistance);
+        }
         directLighting(scope, lightDir, lightColor, normal, viewVec, commonData, outColor) {
             const pb = scope.$builder;
             const that = this;
@@ -295,7 +557,12 @@ import { ShaderHelper } from '../../shader/helper.js';
                 this.$l.NoV = pb.clamp(pb.dot(this.normal, this.viewVec), 0, 1);
                 this.$if(pb.greaterThan(this.NoL, 0), function() {
                     this.$l.VoH = pb.clamp(pb.dot(this.viewVec, this.H), 0, 1);
-                    this.$l.F = that.fresnelSchlick(this, this.VoH, this.data.f0.rgb, this.data.f90);
+                    this.$l.schlickFresnel = that.fresnelSchlick(this, this.VoH, this.data.f0.rgb, this.data.f90);
+                    if (that.iridescence) {
+                        this.$l.F = pb.mix(this.schlickFresnel, this.data.iridescenceFresnel, this.data.iridescenceFactor.x);
+                    } else {
+                        this.$l.F = this.schlickFresnel;
+                    }
                     this.$l.alphaRoughness = pb.mul(this.data.roughness, this.data.roughness);
                     this.$l.D = that.distributionGGX(this, this.NoH, this.alphaRoughness);
                     this.$l.V = that.visGGX(this, this.NoV, this.NoL, this.alphaRoughness);
@@ -304,7 +571,19 @@ import { ShaderHelper } from '../../shader/helper.js';
                         this.specular = pb.mul(this.specular, this.data.sheenAlbedoScaling);
                     }
                     this.outColor = pb.add(this.outColor, this.specular);
-                    this.$l.diffuse = pb.mul(this.lightColor, pb.max(pb.mul(pb.sub(pb.vec3(1), pb.mul(this.F, this.data.specularWeight)), pb.div(this.data.diffuse.rgb, Math.PI)), pb.vec3(0)));
+                    if (that.iridescence) {
+                        this.$l.iridescenceFresnelMax = pb.vec3(pb.max(pb.max(this.data.iridescenceFresnel.r, this.data.iridescenceFresnel.g), this.data.iridescenceFresnel.b));
+                        this.F = pb.mix(this.schlickFresnel, this.iridescenceFresnelMax, this.data.iridescenceFactor.x);
+                    }
+                    this.$l.diffuseBRDF = pb.mul(pb.sub(pb.vec3(1), pb.mul(this.F, this.data.specularWeight)), pb.div(this.data.diffuse.rgb, Math.PI));
+                    this.$l.diffuse = pb.mul(this.lightColor, pb.max(this.diffuseBRDF, pb.vec3(0)));
+                    if (that.transmission) {
+                        this.$l.transmissionRay = that.getVolumeTransmissionRay(this, this.normal, this.viewVec, this.data.thicknessFactor, this.data.f0.a);
+                        this.$l.pointToLight = pb.normalize(pb.sub(this.L, this.transmissionRay));
+                        this.$l.transmittedLight = pb.mul(this.lightColor, that.getPunctualRadianceTransmission(this, this.normal, this.viewVec, this.pointToLight, this.alphaRoughness, this.data.f0.rgb, this.data.f90.rgb, this.data.diffuse.rgb, this.data.f0.a));
+                        this.transmittedLight = that.applyVolumeAttenuation(this, this.transmittedLight, pb.length(this.transmissionRay), this.data.attenuationColor, this.data.attenuationDistance);
+                        this.diffuse = pb.mix(this.diffuse, this.transmittedLight, this.data.transmissionFactor);
+                    }
                     if (that.sheen) {
                         this.diffuse = pb.mul(this.diffuse, this.data.sheenAlbedoScaling);
                     }
@@ -328,6 +607,132 @@ import { ShaderHelper } from '../../shader/helper.js';
             });
             scope.$g[funcName](lightDir, lightColor, normal, viewVec, commonData, outColor);
         }
+        fresnel0ToIor(scope, fresnel0) {
+            const pb = scope.$builder;
+            const funcName = 'Z_fresnel0ToIor';
+            pb.func(funcName, [
+                pb.vec3('fresnel0')
+            ], function() {
+                this.$l.sqrtF0 = pb.sqrt(this.fresnel0);
+                this.$return(pb.div(pb.add(this.sqrtF0, pb.vec3(1)), pb.sub(pb.vec3(1), this.sqrtF0)));
+            });
+            return pb.getGlobalScope()[funcName](fresnel0);
+        }
+        iorToFresnel0v(scope, transmittedIor, incidentIor) {
+            const pb = scope.$builder;
+            const funcName = 'Z_iorToFresnel0v';
+            pb.func(funcName, [
+                pb.vec3('transmittedIor'),
+                pb.float('incidentIor')
+            ], function() {
+                this.$l.t = pb.div(pb.sub(this.transmittedIor, pb.vec3(this.incidentIor)), pb.add(this.transmittedIor, pb.vec3(this.incidentIor)));
+                this.$return(pb.mul(this.t, this.t));
+            });
+            return pb.getGlobalScope()[funcName](transmittedIor, incidentIor);
+        }
+        iorToFresnel0(scope, transmittedIor, incidentIor) {
+            const pb = scope.$builder;
+            const funcName = 'Z_iorToFresnel0';
+            pb.func(funcName, [
+                pb.float('transmittedIor'),
+                pb.float('incidentIor')
+            ], function() {
+                this.$l.t = pb.div(pb.sub(this.transmittedIor, this.incidentIor), pb.add(this.transmittedIor, this.incidentIor));
+                this.$return(pb.mul(this.t, this.t));
+            });
+            return pb.getGlobalScope()[funcName](transmittedIor, incidentIor);
+        }
+        evalSensitivity(scope, OPD, shift) {
+            const pb = scope.$builder;
+            const funcName = 'Z_evalSensitivity';
+            pb.func(funcName, [
+                pb.float('OPD'),
+                pb.vec3('shift')
+            ], function() {
+                this.$l.phase = pb.mul(Math.PI * 2, this.OPD, 1e-9);
+                this.$l.val = pb.vec3(5.4856e-13, 4.4201e-13, 5.2481e-13);
+                this.$l.pos = pb.vec3(1.681e6, 1.7953e6, 2.2084e6);
+                this.$l.va = pb.vec3(4.3278e9, 9.3046e9, 6.6121e9);
+                this.$l.xyz = pb.mul(this.val, pb.sqrt(pb.mul(Math.PI * 2, this.va)), pb.cos(pb.add(pb.mul(this.pos, this.phase), this.shift)), pb.exp(pb.neg(pb.mul(this.phase, this.phase, this.va))));
+                this.xyz.x = pb.add(this.xyz.x, pb.mul(9.747e-14, Math.sqrt(Math.PI * 2 * 4.5282e9), pb.cos(pb.add(pb.mul(this.phase, 2.2399e6), this.shift.x)), pb.exp(pb.mul(-4.5282e9, this.phase, this.phase))));
+                this.xyz = pb.div(this.xyz, 1.0685e-7);
+                this.$return(pb.mul(pb.mat3(3.2404542, -0.969266, 0.0556434, -1.5371385, 1.8760108, -0.2040259, -0.4985314, 0.041556, 1.0572252), this.xyz));
+            });
+            return pb.getGlobalScope()[funcName](OPD, shift);
+        }
+        schlickToF0(scope, f, f90, VdotH) {
+            const pb = scope.$builder;
+            const funcName = 'Z_schlickToF0';
+            pb.func(funcName, [
+                pb.vec3('f'),
+                pb.vec3('f90'),
+                pb.float('VdotH')
+            ], function() {
+                this.$l.x = pb.clamp(pb.sub(1, this.VdotH), 0, 1);
+                this.$l.x2 = pb.mul(this.x, this.x);
+                this.$l.x5 = pb.clamp(pb.mul(this.x, this.x2, this.x2), 0, 0.9999);
+                this.$return(pb.div(pb.sub(this.f, pb.mul(this.f90, this.x5)), pb.sub(1, this.x5)));
+            });
+            return pb.getGlobalScope()[funcName](f, f90, VdotH);
+        }
+        evalIridescence(scope, outsideIOR, eta2, cosTheta1, thinFilmThickness, baseF0) {
+            const pb = scope.$builder;
+            const that = this;
+            const funcName = 'Z_evalIridescence';
+            pb.func(funcName, [
+                pb.float('outsideIOR'),
+                pb.float('eta2'),
+                pb.float('cosTheta1'),
+                pb.float('thinFilmThickness'),
+                pb.vec3('baseF0')
+            ], function() {
+                this.$l.iridescenceIor = pb.mix(this.outsideIOR, this.eta2, pb.smoothStep(0, 0.03, this.thinFilmThickness));
+                this.$l.t = pb.div(this.outsideIOR, this.iridescenceIor);
+                this.$l.sinTheta2Sq = pb.mul(this.t, this.t, pb.sub(1, pb.mul(this.cosTheta1, this.cosTheta1)));
+                this.$l.cosTheta2Sq = pb.sub(1, this.sinTheta2Sq);
+                this.$if(pb.lessThan(this.cosTheta2Sq, 0), function() {
+                    this.$return(pb.vec3(1));
+                });
+                this.$l.cosTheta2 = pb.sqrt(this.cosTheta2Sq);
+                this.$l.R0 = that.iorToFresnel0(this, this.iridescenceIor, this.outsideIOR);
+                this.$l.R12 = that.fresnelSchlick(this, this.cosTheta1, pb.vec3(this.R0), pb.vec3(1)).x;
+                this.$l.R21 = this.R12;
+                this.$l.T121 = pb.sub(1, this.R12);
+                this.$l.phi12 = pb.float(0);
+                this.$if(pb.lessThan(this.iridescenceIor, this.outsideIOR), function() {
+                    this.phi12 = Math.PI;
+                });
+                this.$l.phi21 = pb.sub(Math.PI, this.phi12);
+                this.$l.baseIOR = that.fresnel0ToIor(this, pb.clamp(this.baseF0, pb.vec3(0), pb.vec3(0.9999)));
+                this.$l.R1 = that.iorToFresnel0v(this, this.baseIOR, this.iridescenceIor);
+                this.$l.R23 = that.fresnelSchlick(this, this.cosTheta2, this.R1, pb.vec3(1));
+                this.$l.phi23 = pb.vec3(0);
+                this.$if(pb.lessThan(this.baseIOR.x, this.iridescenceIor), function() {
+                    this.phi23.x = Math.PI;
+                });
+                this.$if(pb.lessThan(this.baseIOR.y, this.iridescenceIor), function() {
+                    this.phi23.y = Math.PI;
+                });
+                this.$if(pb.lessThan(this.baseIOR.z, this.iridescenceIor), function() {
+                    this.phi23.z = Math.PI;
+                });
+                this.$l.OPD = pb.mul(this.iridescenceIor, this.thinFilmThickness, this.cosTheta2, 2);
+                this.$l.phi = pb.add(pb.vec3(this.phi21), this.phi23);
+                this.$l.R123 = pb.clamp(pb.mul(this.R12, this.R23), pb.vec3(1e-5), pb.vec3(0.9999));
+                this.$l.r123 = pb.sqrt(this.R123);
+                this.$l.Rs = pb.div(pb.mul(this.T121, this.T121, this.R23), pb.sub(pb.vec3(1), this.R123));
+                this.$l.C0 = pb.add(pb.vec3(this.R12), this.Rs);
+                this.$l.I = this.C0;
+                this.$l.Cm = pb.sub(this.Rs, pb.vec3(this.T121));
+                this.$for(pb.int('m'), 1, 3, function() {
+                    this.Cm = pb.mul(this.Cm, this.r123);
+                    this.$l.Sm = pb.mul(that.evalSensitivity(this, pb.mul(this.OPD, pb.float(this.m)), pb.mul(this.phi, pb.float(this.m))), 2);
+                    this.I = pb.add(this.I, pb.mul(this.Cm, this.Sm));
+                });
+                this.$return(pb.max(this.I, pb.vec3(0)));
+            });
+            return pb.getGlobalScope()[funcName](outsideIOR, eta2, cosTheta1, thinFilmThickness, baseF0);
+        }
         indirectLighting(scope, normal, viewVec, commonData, outColor) {
             const pb = scope.$builder;
             const that = this;
@@ -353,7 +758,11 @@ import { ShaderHelper } from '../../shader/helper.js';
                 this.$l.ggxLutSample = pb.clamp(pb.textureSampleLevel(this.zGGXLut, pb.clamp(pb.vec2(this.NoV, this.data.roughness), pb.vec2(0), pb.vec2(1)), 0), pb.vec4(0), pb.vec4(1));
                 this.$l.f_ab = this.ggxLutSample.rg;
                 this.$l.Fr = pb.sub(pb.max(pb.vec3(pb.sub(1, this.data.roughness)), this.data.f0.rgb), this.data.f0.rgb);
-                this.$l.k_S = pb.add(this.data.f0.rgb, pb.mul(this.Fr, pb.pow(pb.sub(1, this.NoV), 5)));
+                if (that.iridescence) {
+                    this.$l.k_S = pb.mix(pb.add(this.data.f0.rgb, pb.mul(this.Fr, pb.pow(pb.sub(1, this.NoV), 5))), this.data.iridescenceFresnel, this.data.iridescenceFactor.x);
+                } else {
+                    this.$l.k_S = pb.add(this.data.f0.rgb, pb.mul(this.Fr, pb.pow(pb.sub(1, this.NoV), 5)));
+                }
                 if (ctx.env.light.envLight.hasRadiance()) {
                     this.$l.radiance = ctx.env.light.envLight.getRadiance(this, pb.reflect(pb.neg(this.viewVec), this.normal), this.data.roughness);
                     this.$l.FssEss = pb.add(pb.mul(this.k_S, this.f_ab.x), pb.vec3(this.f_ab.y));
@@ -365,15 +774,27 @@ import { ShaderHelper } from '../../shader/helper.js';
                 }
                 if (ctx.env.light.envLight.hasIrradiance()) {
                     this.$l.irradiance = ctx.env.light.envLight.getIrradiance(this, this.normal);
+                    if (that.iridescence) {
+                        this.$l.iridescenceF0Max = pb.vec3(pb.max(pb.max(this.data.iridescenceF0.r, this.data.iridescenceF0.g), this.data.iridescenceF0.b));
+                        this.$l.mixedF0 = pb.mix(this.data.f0.rgb, this.iridescenceF0Max, this.data.iridescenceFactor.x);
+                        this.Fr = pb.sub(pb.max(pb.vec3(pb.sub(1, this.data.roughness)), this.mixedF0), this.mixedF0);
+                        this.k_S = pb.add(this.mixedF0, pb.mul(this.Fr, pb.pow(pb.sub(1, this.NoV), 5)));
+                    } else {
+                        this.$l.mixedF0 = this.data.f0.rgb;
+                    }
                     this.$l.FssEss = pb.add(pb.mul(this.k_S, this.f_ab.x, this.data.specularWeight), pb.vec3(this.f_ab.y));
                     this.$l.Ems = pb.sub(1, pb.add(this.f_ab.x, this.f_ab.y));
-                    this.$l.F_avg = pb.mul(pb.add(this.data.f0.rgb, pb.div(pb.sub(pb.vec3(1), this.data.f0.rgb), 21)), this.data.specularWeight);
+                    this.$l.F_avg = pb.mul(pb.add(this.mixedF0, pb.div(pb.sub(pb.vec3(1), this.mixedF0), 21)), this.data.specularWeight);
                     this.$l.FmsEms = pb.div(pb.mul(this.FssEss, this.F_avg, this.Ems), pb.sub(pb.vec3(1), pb.mul(this.F_avg, this.Ems)));
                     this.$l.k_D = pb.mul(this.data.diffuse.rgb, pb.add(pb.sub(pb.vec3(1), this.FssEss), this.FmsEms));
                     this.$l.iblDiffuse = pb.mul(pb.add(this.FmsEms, this.k_D), this.irradiance, this.occlusion);
                     if (that.sheen) {
                         this.iblDiffuse = pb.mul(this.iblDiffuse, this.data.sheenAlbedoScaling);
                     }
+                    if (that.transmission) {
+                        this.$l.iblTransmission = that.getIBLVolumnRefraction(this, this.ggxLutSample.rg, this.normal, this.viewVec, this.data.roughness, this.data.diffuse.rgb, this.data.f0.rgb, this.data.f90, this.$inputs.worldPos, this.data.f0.a, this.data.thicknessFactor, this.data.attenuationColor, this.data.attenuationDistance);
+                        this.iblDiffuse = pb.mix(this.iblDiffuse, this.iblTransmission, this.data.transmissionFactor);
+                    }
                     this.outColor = pb.add(this.outColor, this.iblDiffuse);
                 }
                 if (that.sheen && ctx.env.light.envLight.hasIrradiance()) {
@@ -446,6 +867,8 @@ import { ShaderHelper } from '../../shader/helper.js';
     };
     FEATURE_SHEEN = cls.defineFeature();
     FEATURE_CLEARCOAT = cls.defineFeature();
+    FEATURE_TRANSMISSION = cls.defineFeature();
+    FEATURE_IRIDESCENCE = cls.defineFeature();
     return cls;
 }
 

package/dist/material/mixins/pbr/common.js.map

@@ -1 +1 @@
-{"version":3,"file":"common.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"common.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/material/pbrmr.js

@@ -2,6 +2,7 @@ import { applyMaterialMixins, MeshMaterial } from './meshmaterial.js';
 import { mixinVertexColor } from './mixins/vertexcolor.js';
 import { mixinPBRMetallicRoughness } from './mixins/lightmodel/pbrmetallicroughness.js';
 import { ShaderHelper } from './shader/helper.js';
+import { RENDER_PASS_TYPE_LIGHT } from '../values.js';
 
 /**
  * PBRMetallicRoughnessMaterial class
@@ -30,9 +31,15 @@ import { ShaderHelper } from './shader/helper.js';
     vertexShader(scope) {
         super.vertexShader(scope);
         const pb = scope.$builder;
+        const worldMatrix = ShaderHelper.getWorldMatrix(scope);
         scope.$l.oPos = ShaderHelper.resolveVertexPosition(scope);
-        scope.$outputs.worldPos = pb.mul(ShaderHelper.getWorldMatrix(scope), pb.vec4(scope.oPos, 1)).xyz;
-        ShaderHelper.setClipSpacePosition(scope, pb.mul(ShaderHelper.getViewProjectionMatrix(scope), pb.vec4(scope.$outputs.worldPos, 1)));
+        scope.$outputs.worldPos = pb.mul(worldMatrix, pb.vec4(scope.oPos, 1)).xyz;
+        scope.$l.csPos = pb.mul(ShaderHelper.getViewProjectionMatrix(scope), pb.vec4(scope.$outputs.worldPos, 1));
+        ShaderHelper.setClipSpacePosition(scope, scope.csPos);
+        if (this.transmission) {
+            scope.$outputs.screenUV = pb.add(pb.mul(pb.div(scope.csPos.xy, scope.csPos.w), 0.5), pb.vec2(0.5));
+            scope.$outputs.modelScale = pb.vec3(pb.length(worldMatrix[0].xyz), pb.length(worldMatrix[1].xyz), pb.length(worldMatrix[2].xyz));
+        }
         if (this.vertexNormal) {
             scope.$l.oNorm = ShaderHelper.resolveVertexNormal(scope);
             scope.$outputs.wNorm = pb.mul(ShaderHelper.getNormalMatrix(scope), pb.vec4(scope.oNorm, 0)).xyz;
@@ -51,10 +58,14 @@ import { ShaderHelper } from './shader/helper.js';
             if (this.vertexColor) {
                 scope.albedo = pb.mul(scope.albedo, this.getVertexColor(scope));
             }
-            scope.$l.normalInfo = this.calculateNormalAndTBN(scope, scope.$inputs.worldPos, scope.$inputs.wNorm, scope.$inputs.wTangent, scope.$inputs.wBinormal);
-            scope.$l.viewVec = this.calculateViewVector(scope, scope.$inputs.worldPos);
-            scope.$l.litColor = this.PBRLight(scope, scope.$inputs.worldPos, scope.normalInfo.normal, scope.viewVec, scope.albedo, scope.normalInfo.TBN);
-            this.outputFragmentColor(scope, scope.$inputs.worldPos, pb.vec4(scope.litColor, scope.albedo.a));
+            if (this.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
+                scope.$l.normalInfo = this.calculateNormalAndTBN(scope, scope.$inputs.worldPos, scope.$inputs.wNorm, scope.$inputs.wTangent, scope.$inputs.wBinormal);
+                scope.$l.viewVec = this.calculateViewVector(scope, scope.$inputs.worldPos);
+                scope.$l.litColor = this.PBRLight(scope, scope.$inputs.worldPos, scope.normalInfo.normal, scope.viewVec, scope.albedo, scope.normalInfo.TBN);
+                this.outputFragmentColor(scope, scope.$inputs.worldPos, pb.vec4(scope.litColor, scope.albedo.a));
+            } else {
+                this.outputFragmentColor(scope, scope.$inputs.worldPos, scope.albedo);
+            }
         } else {
             this.outputFragmentColor(scope, scope.$inputs.worldPos, null);
         }

package/dist/material/pbrmr.js.map

@@ -1 +1 @@
-{"version":3,"file":"pbrmr.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"pbrmr.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}