@zephyr3d/scene 0.5.0 → 0.6.1

package/dist/shaders/lighting.js

@@ -1,335 +0,0 @@
-import { PBInsideFunctionScope } from '@zephyr3d/device';
-import { RENDER_PASS_TYPE_FORWARD, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_POINT, LIGHT_TYPE_SPOT } from '../values.js';
-import { ShaderFramework } from './framework.js';
-import { nonLinearDepthToLinear } from './misc.js';
-import { Application } from '../app.js';
-
-/**
- * Calculate lighting for forward renderer
- *
- * @param scope - Current shader scope
- * @param lm - The light model
- * @param ctx - The drawing context
- * @returns The final color
- */ function forwardComputeLighting(scope, lm, ctx) {
-    const env = ctx.drawEnvLight ? ctx.env.light.envLight : null;
-    const funcNameIllumPointLight = 'stdmat_illumPointLight';
-    const funcNameIllumDirectionalLight = 'stdmat_illumDirectionalLight';
-    const funcNameIllumSpotLight = 'stdmat_illumSpotLight';
-    const funcNameIllumDirectionalShadowLight = 'stdmat_illumDirectionalShadowLight';
-    const funcNameIllumPointShadowLight = 'stdmat_illumPointShadowLight';
-    const funcNameIllumCascadedShadowLight = 'stdmat_illumCascadedShadowLight';
-    const funcNameIllumUnshadowedLights = 'stdmat_illumUnshadowedLights';
-    const funcNameGetClusterIndex = 'stdmat_getClusterIndex';
-    const funcNameIllumOneLight = 'stdmat_illumOneLight';
-    const funcNameComputeLighting = 'stdmat_computeLighting';
-    const pb = scope.$builder;
-    if (!scope || !(scope instanceof PBInsideFunctionScope)) {
-        throw new Error('forwardComputeLighting() failed: forwardComputeLighting() must be called inside a function');
-    }
-    if (ctx.renderPass.type !== RENDER_PASS_TYPE_FORWARD) {
-        throw new Error(`forwardComputeLighting() failed: invalid render pass type: ${ctx.renderPass.type}`);
-    }
-    function illumPointLight(lm, ...args) {
-        pb.func(funcNameIllumPointLight, [
-            pb.vec4('lightPositionRange'),
-            pb.vec4('lightDirectionCutoff'),
-            pb.vec3('lightDir'),
-            pb.vec3('attenuation')
-        ], function() {
-            this.$l.dist = pb.distance(this.lightPositionRange.xyz, ShaderFramework.getWorldPosition(this).xyz);
-            this.$l.a = pb.div(1, pb.add(1, pb.mul(this.dist, this.dist)));
-            this.$l.falloff = pb.mul(this.a, pb.clamp(pb.sub(1, pb.div(this.dist, this.lightPositionRange.w)), 0, 1));
-            //this.$l.t = pb.div(pb.mul(this.dist, 16), this.lightPositionRange.w);
-            //this.$l.falloff = pb.div(1, pb.add(1, pb.mul(this.t, this.t)));
-            //this.$l.falloff = pb.div(1, )   pb.max(0, pb.sub(1, pb.div(this.dist, this.lightPositionRange.w)));
-            //this.falloff = pb.mul(this.falloff, this.falloff);
-            this.$if(pb.greaterThan(this.falloff, 0), function() {
-                lm.directBRDF(this, this.lightDir, pb.mul(this.attenuation, this.falloff));
-            });
-        });
-        pb.getGlobalScope()[funcNameIllumPointLight](...args);
-    }
-    function illumDirectionalLight(lm, ...args) {
-        pb.func(funcNameIllumDirectionalLight, [
-            pb.vec4('lightPositionRange'),
-            pb.vec4('lightDirectionCutoff'),
-            pb.vec3('lightDir'),
-            pb.vec3('attenuation')
-        ], function() {
-            lm.directBRDF(this, this.lightDir, this.attenuation);
-        });
-        pb.getGlobalScope()[funcNameIllumDirectionalLight](...args);
-    }
-    function illumSpotLight(lm, ...args) {
-        pb.func(funcNameIllumSpotLight, [
-            pb.vec4('lightPositionRange'),
-            pb.vec4('lightDirectionCutoff'),
-            pb.vec3('lightDir'),
-            pb.vec3('attenuation')
-        ], function() {
-            this.$l.spotFactor = pb.dot(this.lightDir, this.lightDirectionCutoff.xyz);
-            this.spotFactor = pb.smoothStep(this.lightDirectionCutoff.w, pb.mix(this.lightDirectionCutoff.w, 1, 0.5), this.spotFactor);
-            this.$if(pb.greaterThan(this.spotFactor, 0), function() {
-                illumPointLight(lm, this.lightPositionRange, this.lightDirectionCutoff, this.lightDir, pb.mul(this.attenuation, this.spotFactor));
-            });
-        });
-        pb.getGlobalScope()[funcNameIllumSpotLight](...args);
-    }
-    function illumLight(scope, lightType, lm, ...args) {
-        if (typeof lightType === 'number') {
-            if (lightType === LIGHT_TYPE_DIRECTIONAL) {
-                illumDirectionalLight(lm, ...args);
-            } else if (lightType === LIGHT_TYPE_POINT) {
-                illumPointLight(lm, ...args);
-            } else if (lightType === LIGHT_TYPE_SPOT) {
-                illumSpotLight(lm, ...args);
-            }
-        } else {
-            scope.$if(pb.equal(lightType, LIGHT_TYPE_DIRECTIONAL), function() {
-                illumDirectionalLight(lm, ...args);
-            }).$elseif(pb.equal(lightType, LIGHT_TYPE_POINT), function() {
-                illumPointLight(lm, ...args);
-            }).$elseif(pb.equal(lightType, LIGHT_TYPE_SPOT), function() {
-                illumSpotLight(lm, ...args);
-            });
-        }
-    }
-    function illumDirectionalShadowLight(lightType, lm) {
-        pb.func(funcNameIllumDirectionalShadowLight, [], function() {
-            this.$l.positionRange = scope.global.light.positionAndRange; //ShaderFramework.getLightPositionAndRange(this, 0);
-            this.$l.directionCutoff = scope.global.light.directionAndCutoff; //ShaderFramework.getLightDirectionAndCutoff(this, 0);
-            this.$l.diffuseIntensity = scope.global.light.diffuseAndIntensity; //ShaderFramework.getLightColorAndIntensity(this, 0);
-            this.$l.lightcolor = pb.mul(this.diffuseIntensity.xyz, this.diffuseIntensity.w);
-            this.$l.lightDir = pb.vec3();
-            this.$l.nl = pb.float();
-            this.$l.NdotL = pb.float();
-            if (lightType === LIGHT_TYPE_DIRECTIONAL) {
-                this.lightDir = this.directionCutoff.xyz;
-                this.nl = pb.dot(this.surfaceData.normal, this.lightDir);
-                this.NdotL = pb.clamp(pb.neg(this.nl), 0, 1);
-            } else {
-                this.lightDir = pb.sub(ShaderFramework.getWorldPosition(this).xyz, this.positionRange.xyz);
-                this.lightDir = pb.normalize(this.lightDir);
-                this.nl = pb.dot(this.surfaceData.normal, this.lightDir);
-                this.NdotL = pb.clamp(pb.neg(this.nl), 0, 1);
-            }
-            this.shadowVertex = ShaderFramework.calculateShadowSpaceVertex(this);
-            const shadowMapParams = ctx.shadowMapInfo.get(ctx.currentShadowLight);
-            this.$l.shadow = shadowMapParams.impl.computeShadow(shadowMapParams, this, this.shadowVertex, this.NdotL);
-            this.$l.shadowDistance = ShaderFramework.getShadowCameraParams(scope).w;
-            this.shadow = pb.mix(this.shadow, 1, pb.smoothStep(pb.mul(this.shadowDistance, 0.8), this.shadowDistance, pb.distance(ShaderFramework.getCameraPosition(this), ShaderFramework.getWorldPosition(this).xyz)));
-            // TODO: cannot early exit, shoud make computeShadow() running in non-uniform control flow
-            if (lightType !== LIGHT_TYPE_DIRECTIONAL) {
-                this.$if(pb.greaterThan(pb.length(this.lightDir), this.positionRange.w), function() {
-                    this.$return();
-                });
-            }
-            this.$if(pb.greaterThan(this.NdotL, 0), function() {
-                this.$l.attenuation = pb.mul(pb.mul(this.lightcolor, this.NdotL), pb.vec3(this.shadow));
-                illumLight(this, lightType, lm, this.positionRange, this.directionCutoff, this.lightDir, this.attenuation);
-            });
-        });
-        pb.getGlobalScope()[funcNameIllumDirectionalShadowLight]();
-    }
-    function illumPointShadowLight(lm) {
-        pb.func(funcNameIllumPointShadowLight, [], function() {
-            const worldPos = ShaderFramework.getWorldPosition(this);
-            this.$l.positionRange = scope.global.light.positionAndRange; //ShaderFramework.getLightPositionAndRange(this, 0);
-            this.$l.directionCutoff = scope.global.light.directionAndCutoff; //ShaderFramework.getLightDirectionAndCutoff(this, 0);
-            this.$l.diffuseIntensity = scope.global.light.diffuseAndIntensity; //ShaderFramework.getLightColorAndIntensity(this, 0);
-            this.$l.lightcolor = pb.mul(this.diffuseIntensity.xyz, this.diffuseIntensity.w);
-            this.$l.lightDir = pb.sub(worldPos.xyz, this.positionRange.xyz);
-            this.$if(pb.greaterThan(pb.length(this.lightDir), this.positionRange.w), function() {
-                this.$return();
-            });
-            this.lightDir = pb.normalize(this.lightDir);
-            this.$l.nl = pb.dot(this.surfaceData.normal, this.lightDir);
-            this.$l.NdotL = pb.clamp(pb.neg(this.nl), 0, 1);
-            this.shadowBound = pb.vec4(0, 0, 1, 1);
-            this.shadowVertex = ShaderFramework.calculateShadowSpaceVertex(this);
-            const shadowMapParams = ctx.shadowMapInfo.get(ctx.currentShadowLight);
-            this.$l.shadow = shadowMapParams.impl.computeShadow(shadowMapParams, this, this.shadowVertex, this.NdotL);
-            this.$l.shadowDistance = ShaderFramework.getShadowCameraParams(scope).w;
-            this.shadow = pb.mix(this.shadow, 1, pb.smoothStep(pb.mul(this.shadowDistance, 0.8), this.shadowDistance, pb.distance(ShaderFramework.getCameraPosition(this), ShaderFramework.getWorldPosition(this).xyz)));
-            this.$if(pb.greaterThan(this.NdotL, 0), function() {
-                this.$l.attenuation = pb.mul(pb.mul(this.lightcolor, this.NdotL), pb.vec3(this.shadow));
-                illumLight(this, LIGHT_TYPE_POINT, lm, this.positionRange, this.directionCutoff, this.lightDir, this.attenuation);
-            });
-        });
-        pb.getGlobalScope()[funcNameIllumPointShadowLight]();
-    }
-    function illumCascadedShadowLight(lm) {
-        pb.func(funcNameIllumCascadedShadowLight, [], function() {
-            this.$l.shadowCascades = this.global.light.shadowCascades; //ShaderFramework.getLightInfo(this, 0).y;
-            this.$l.positionRange = this.global.light.positionAndRange; //ShaderFramework.getLightPositionAndRange(this, 0);
-            this.$l.directionCutoff = this.global.light.directionAndCutoff; //ShaderFramework.getLightDirectionAndCutoff(this, 0);
-            this.$l.diffuseIntensity = this.global.light.diffuseAndIntensity; //ShaderFramework.getLightColorAndIntensity(this, 0);
-            this.$l.lightcolor = pb.mul(this.diffuseIntensity.xyz, this.diffuseIntensity.w);
-            this.$l.lightDir = pb.vec3();
-            this.lightDir = this.directionCutoff.xyz;
-            this.$l.nl = pb.dot(this.surfaceData.normal, this.lightDir);
-            this.$l.NdotL = pb.clamp(pb.neg(this.nl), 0, 1);
-            this.$l.shadowBound = pb.vec4(0, 0, 1, 1);
-            this.$l.linearDepth = nonLinearDepthToLinear(this, this.$builtins.fragCoord.z);
-            this.$l.splitDistances = ShaderFramework.getCascadeDistances(this);
-            this.$l.comparison = pb.vec4(pb.greaterThan(pb.vec4(this.linearDepth), this.splitDistances));
-            this.$l.cascadeFlags = pb.vec4(pb.float(pb.greaterThan(this.shadowCascades, 0)), pb.float(pb.greaterThan(this.shadowCascades, 1)), pb.float(pb.greaterThan(this.shadowCascades, 2)), pb.float(pb.greaterThan(this.shadowCascades, 3)));
-            this.$l.split = pb.int(pb.dot(this.comparison, this.cascadeFlags));
-            this.$l.shadowVertex = pb.vec4();
-            if (Application.instance.device.type === 'webgl') {
-                this.$for(pb.int('cascade'), 0, 4, function() {
-                    this.$if(pb.equal(this.cascade, this.split), function() {
-                        this.shadowVertex = ShaderFramework.calculateShadowSpaceVertex(this, this.cascade);
-                        this.$break();
-                    });
-                });
-            } else {
-                this.shadowVertex = ShaderFramework.calculateShadowSpaceVertex(this, this.split);
-            }
-            const shadowMapParams = ctx.shadowMapInfo.get(ctx.currentShadowLight);
-            this.$l.shadow = shadowMapParams.impl.computeShadowCSM(shadowMapParams, this, this.shadowVertex, this.NdotL, this.split);
-            this.$l.shadowDistance = ShaderFramework.getShadowCameraParams(scope).w;
-            this.shadow = pb.mix(this.shadow, 1, pb.smoothStep(pb.mul(this.shadowDistance, 0.8), this.shadowDistance, pb.distance(ShaderFramework.getCameraPosition(this), ShaderFramework.getWorldPosition(this).xyz)));
-            this.$if(pb.greaterThan(this.NdotL, 0), function() {
-                this.$l.attenuation = pb.mul(pb.mul(this.lightcolor, this.NdotL), pb.vec3(this.shadow));
-                illumLight(this, LIGHT_TYPE_DIRECTIONAL, lm, this.positionRange, this.directionCutoff, this.lightDir, this.attenuation);
-            });
-        });
-        pb.getGlobalScope()[funcNameIllumCascadedShadowLight]();
-    }
-    function illumOneLight(lm, positionRange, directionCutoff, diffuseIntensity) {
-        pb.func(funcNameIllumOneLight, [
-            pb.vec4('positionRange'),
-            pb.vec4('directionCutoff'),
-            pb.vec4('diffuseIntensity')
-        ], function() {
-            this.$l.lightcolor = pb.mul(this.diffuseIntensity.xyz, this.diffuseIntensity.w);
-            this.$l.lightDir = pb.vec3();
-            this.$l.nl = pb.float();
-            this.$l.NdotL = pb.float();
-            this.$l.lightType = pb.int();
-            this.$if(pb.lessThan(this.positionRange.w, 0), function() {
-                this.lightDir = this.directionCutoff.xyz;
-                this.nl = pb.dot(this.surfaceData.normal, this.lightDir);
-                this.NdotL = pb.clamp(pb.neg(this.nl), 0, 1);
-                this.lightType = LIGHT_TYPE_DIRECTIONAL;
-            }).$else(function() {
-                this.lightDir = pb.sub(ShaderFramework.getWorldPosition(this).xyz, this.positionRange.xyz);
-                this.$if(pb.greaterThan(pb.length(this.lightDir), this.positionRange.w), function() {
-                    this.$return();
-                });
-                this.lightDir = pb.normalize(this.lightDir);
-                this.nl = pb.dot(this.surfaceData.normal, this.lightDir);
-                this.NdotL = pb.clamp(pb.neg(this.nl), 0, 1);
-                this.$if(pb.lessThan(this.directionCutoff.w, 0), function() {
-                    this.lightType = LIGHT_TYPE_POINT;
-                }).$else(function() {
-                    this.lightType = LIGHT_TYPE_SPOT;
-                });
-            });
-            this.$if(pb.greaterThan(this.NdotL, 0), function() {
-                illumLight(this, this.lightType, lm, this.positionRange, this.directionCutoff, this.lightDir, pb.mul(this.lightcolor, this.NdotL));
-            });
-        });
-        pb.getGlobalScope()[funcNameIllumOneLight](positionRange, directionCutoff, diffuseIntensity);
-    }
-    function getClusterIndex(fragCoord) {
-        pb.func(funcNameGetClusterIndex, [
-            pb.vec3('fragCoord')
-        ], function() {
-            const clusterParams = ShaderFramework.getClusterParams(this);
-            const countParams = ShaderFramework.getCountParams(this);
-            this.$l.zTile = pb.int(pb.max(pb.add(pb.mul(pb.log2(nonLinearDepthToLinear(this, this.fragCoord.z)), clusterParams.z), clusterParams.w), 0));
-            this.$l.f = pb.vec2(this.fragCoord.x, pb.sub(clusterParams.y, pb.add(this.fragCoord.y, 1)));
-            this.$l.xyTile = pb.ivec2(pb.div(this.f, pb.div(clusterParams.xy, pb.vec2(countParams.xy))));
-            this.$return(pb.ivec3(this.xyTile, this.zTile));
-        });
-        return pb.getGlobalScope()[funcNameGetClusterIndex](fragCoord);
-    }
-    function illumUnshadowedLights(lm) {
-        pb.func(funcNameIllumUnshadowedLights, [], function() {
-            const countParams = ShaderFramework.getCountParams(this);
-            this.$l.cluster = getClusterIndex(this.$builtins.fragCoord.xyz);
-            this.$l.clusterIndex = pb.add(this.cluster.x, pb.mul(this.cluster.y, countParams.x), pb.mul(this.cluster.z, countParams.x, countParams.y));
-            this.$l.texSize = this.global.light.lightIndexTexSize;
-            if (pb.getDevice().type === 'webgl') {
-                this.$l.texCoordX = pb.div(pb.add(pb.mod(pb.float(this.clusterIndex), pb.float(this.texSize.x)), 0.5), pb.float(this.texSize.x));
-                this.$l.texCoordY = pb.div(pb.add(pb.float(pb.div(this.clusterIndex, this.texSize.x)), 0.5), pb.float(this.texSize.y));
-                this.$l.samp = pb.textureSample(ShaderFramework.getClusteredLightIndexTexture(this), pb.vec2(this.texCoordX, this.texCoordY));
-            } else {
-                // this.$l.texSize = pb.ivec2(pb.textureDimensions(ShaderFramework.getClusteredLightIndexTexture(this), 0));
-                this.$l.texCoordX = pb.mod(this.clusterIndex, this.texSize.x);
-                this.$l.texCoordY = pb.div(this.clusterIndex, this.texSize.x);
-                this.$l.samp = pb.textureLoad(ShaderFramework.getClusteredLightIndexTexture(this), pb.ivec2(this.texCoordX, this.texCoordY), 0);
-            }
-            if (pb.getDevice().type === 'webgl') {
-                this.$for(pb.int('i'), 0, 4, function() {
-                    this.$l.k = this.samp.at(this.i);
-                    this.$l.lights = pb.int[2]();
-                    this.$l.lights[0] = pb.int(pb.mod(this.k, 256));
-                    this.$l.lights[1] = pb.int(pb.div(this.k, 256));
-                    this.$for(pb.int('k'), 0, 2, function() {
-                        this.$l.li = this.lights.at(this.k);
-                        this.$if(pb.greaterThan(this.li, 0), function() {
-                            this.$for(pb.int('j'), 1, 256, function() {
-                                this.$if(pb.equal(this.j, this.li), function() {
-                                    this.$l.positionRange = ShaderFramework.getLightPositionAndRange(this, this.j);
-                                    this.$l.directionCutoff = ShaderFramework.getLightDirectionAndCutoff(this, this.j);
-                                    this.$l.diffuseIntensity = ShaderFramework.getLightColorAndIntensity(this, this.j);
-                                    illumOneLight(lm, this.positionRange, this.directionCutoff, this.diffuseIntensity);
-                                    this.$break();
-                                });
-                            });
-                        });
-                    });
-                });
-            } else {
-                this.$for(pb.uint('i'), 0, 4, function() {
-                    this.$for(pb.uint('k'), 0, 4, function() {
-                        this.$l.c = pb.compAnd(pb.sar(this.samp.at(this.i), pb.mul(this.k, 8)), 0xff);
-                        this.$if(pb.greaterThan(this.c, 0), function() {
-                            this.$l.positionRange = ShaderFramework.getLightPositionAndRange(this, this.c);
-                            this.$l.directionCutoff = ShaderFramework.getLightDirectionAndCutoff(this, this.c);
-                            this.$l.diffuseIntensity = ShaderFramework.getLightColorAndIntensity(this, this.c);
-                            illumOneLight(lm, this.positionRange, this.directionCutoff, this.diffuseIntensity);
-                        });
-                    });
-                });
-            }
-        });
-        pb.getGlobalScope()[funcNameIllumUnshadowedLights]();
-    }
-    pb.func(funcNameComputeLighting, [], function() {
-        const worldPosition = ShaderFramework.getWorldPosition(this);
-        const worldNormal = ShaderFramework.getWorldNormal(this);
-        const worldTangent = ShaderFramework.getWorldTangent(this);
-        const worldBinormal = ShaderFramework.getWorldBinormal(this);
-        lm.getSurfaceData(this, env, worldPosition, worldNormal, worldTangent, worldBinormal);
-        ShaderFramework.discardIfClipped(this);
-        if (lm.supportLighting()) {
-            if (env) {
-                lm.envBRDF(env, this);
-            }
-            if (ctx.currentShadowLight) {
-                const shadowMapParams = ctx.shadowMapInfo.get(ctx.currentShadowLight);
-                if (shadowMapParams.numShadowCascades > 1) {
-                    illumCascadedShadowLight(lm);
-                } else if (shadowMapParams.shadowMap.isTextureCube()) {
-                    illumPointShadowLight(lm);
-                } else {
-                    illumDirectionalShadowLight(shadowMapParams.lightType, lm);
-                }
-            } else {
-                illumUnshadowedLights(lm);
-            }
-        }
-        this.$return(lm.finalComposite(this));
-    // this.$l.result = pb.add(this.lightDiffuse, this.lightSpecular);
-    // this.$return(pb.vec4(this.result, this.surfaceData.diffuse.a));
-    });
-    return pb.getGlobalScope()[funcNameComputeLighting]();
-}
-
-export { forwardComputeLighting };
-//# sourceMappingURL=lighting.js.map

package/dist/shaders/lighting.js.map

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

package/dist/utility/sheenlut.js

@@ -1,196 +0,0 @@
-import { Vector3, Vector2 } from '@zephyr3d/base';
-import { Application } from '../app.js';
-
-const bits = new Uint32Array(1);
-//Van der Corput radical inverse
-function radicalInverse_VdC(i) {
-    bits[0] = i;
-    bits[0] = (bits[0] << 16 | bits[0] >> 16) >>> 0;
-    bits[0] = (bits[0] & 0x55555555) << 1 | (bits[0] & 0xaaaaaaaa) >>> 1 >>> 0;
-    bits[0] = (bits[0] & 0x33333333) << 2 | (bits[0] & 0xcccccccc) >>> 2 >>> 0;
-    bits[0] = (bits[0] & 0x0f0f0f0f) << 4 | (bits[0] & 0xf0f0f0f0) >>> 4 >>> 0;
-    bits[0] = (bits[0] & 0x00ff00ff) << 8 | (bits[0] & 0xff00ff00) >>> 8 >>> 0;
-    return bits[0] * 2.3283064365386963e-10; // / 0x100000000 or / 4294967296
-}
-function hammersley(i, iN, out) {
-    out.setXY(i * iN, radicalInverse_VdC(i));
-}
-function distributionCharlie(NdotH, roughness) {
-    // roughness = Math.max(roughness, 0.000001);
-    const invAlpha = 1 / roughness;
-    const cos2h = NdotH * NdotH;
-    const sin2h = 1 - cos2h;
-    return (2 + invAlpha) * Math.pow(sin2h, invAlpha * 0.5) / (2 * Math.PI);
-}
-function visibilityAshikhmin(NdotV, NdotL) {
-    return Math.min(Math.max(1 / (4 * (NdotL + NdotV - NdotL * NdotV)), 0), 1);
-}
-function hemisphereUniformSample(u, out) {
-    const phi = 2 * Math.PI * u.x;
-    const cosTheta = 1 - u.y;
-    const sinTheta = Math.sqrt(1 - cosTheta * cosTheta);
-    out.setXYZ(sinTheta * Math.cos(phi), sinTheta * Math.sin(phi), cosTheta);
-}
-function dfvCharlieUniform(NdotV, roughness, numSamples) {
-    let r = 0;
-    const V = new Vector3(Math.sqrt(1 - NdotV * NdotV), 0, NdotV);
-    const u = new Vector2();
-    const H = new Vector3();
-    const L = new Vector3();
-    for(let i = 0; i < numSamples; i++){
-        hammersley(i, 1 / numSamples, u);
-        hemisphereUniformSample(u, H);
-        Vector3.scale(H, Vector3.dot(V, H) * 2, L).subBy(V);
-        const VdotH = Math.min(Math.max(Vector3.dot(V, H), 0), 1);
-        const NdotL = Math.min(Math.max(L.z, 0), 1);
-        const NdotH = Math.min(Math.max(H.z, 0), 1);
-        if (NdotL > 0) {
-            const v = visibilityAshikhmin(NdotV, NdotL);
-            // const v = visibilityCharlie(NdotV, NdotL, roughness);
-            const d = distributionCharlie(NdotH, roughness);
-            r += v * d * NdotL * VdotH;
-        }
-    }
-    return r * (4 * 2 * Math.PI / numSamples);
-}
-const _tables = function _generateTables() {
-    // float32 to float16 helpers
-    const buffer = new ArrayBuffer(4);
-    const floatView = new Float32Array(buffer);
-    const uint32View = new Uint32Array(buffer);
-    const baseTable = new Uint32Array(512);
-    const shiftTable = new Uint32Array(512);
-    for(let i = 0; i < 256; ++i){
-        const e = i - 127;
-        // very small number (0, -0)
-        if (e < -27) {
-            baseTable[i] = 0x0000;
-            baseTable[i | 0x100] = 0x8000;
-            shiftTable[i] = 24;
-            shiftTable[i | 0x100] = 24;
-        // small number (denorm)
-        } else if (e < -14) {
-            baseTable[i] = 0x0400 >> -e - 14;
-            baseTable[i | 0x100] = 0x0400 >> -e - 14 | 0x8000;
-            shiftTable[i] = -e - 1;
-            shiftTable[i | 0x100] = -e - 1;
-        // normal number
-        } else if (e <= 15) {
-            baseTable[i] = e + 15 << 10;
-            baseTable[i | 0x100] = e + 15 << 10 | 0x8000;
-            shiftTable[i] = 13;
-            shiftTable[i | 0x100] = 13;
-        // large number (Infinity, -Infinity)
-        } else if (e < 128) {
-            baseTable[i] = 0x7c00;
-            baseTable[i | 0x100] = 0xfc00;
-            shiftTable[i] = 24;
-            shiftTable[i | 0x100] = 24;
-        // stay (NaN, Infinity, -Infinity)
-        } else {
-            baseTable[i] = 0x7c00;
-            baseTable[i | 0x100] = 0xfc00;
-            shiftTable[i] = 13;
-            shiftTable[i | 0x100] = 13;
-        }
-    }
-    // float16 to float32 helpers
-    const mantissaTable = new Uint32Array(2048);
-    const exponentTable = new Uint32Array(64);
-    const offsetTable = new Uint32Array(64);
-    for(let i = 1; i < 1024; ++i){
-        let m = i << 13; // zero pad mantissa bits
-        let e = 0; // zero exponent
-        // normalized
-        while((m & 0x00800000) === 0){
-            m <<= 1;
-            e -= 0x00800000; // decrement exponent
-        }
-        m &= ~0x00800000; // clear leading 1 bit
-        e += 0x38800000; // adjust bias
-        mantissaTable[i] = m | e;
-    }
-    for(let i = 1024; i < 2048; ++i){
-        mantissaTable[i] = 0x38000000 + (i - 1024 << 13);
-    }
-    for(let i = 1; i < 31; ++i){
-        exponentTable[i] = i << 23;
-    }
-    exponentTable[31] = 0x47800000;
-    exponentTable[32] = 0x80000000;
-    for(let i = 33; i < 63; ++i){
-        exponentTable[i] = 0x80000000 + (i - 32 << 23);
-    }
-    exponentTable[63] = 0xc7800000;
-    for(let i = 1; i < 64; ++i){
-        if (i !== 32) {
-            offsetTable[i] = 1024;
-        }
-    }
-    return {
-        floatView: floatView,
-        uint32View: uint32View,
-        baseTable: baseTable,
-        shiftTable: shiftTable,
-        mantissaTable: mantissaTable,
-        exponentTable: exponentTable,
-        offsetTable: offsetTable
-    };
-}();
-function encodeF16(val) {
-    val = Math.min(Math.max(val, -65504), 65504);
-    _tables.floatView[0] = val;
-    const f = _tables.uint32View[0];
-    const e = f >> 23 & 0x1ff;
-    return _tables.baseTable[e] + ((f & 0x007fffff) >> _tables.shiftTable[e]);
-}
-/*
-function decodeF16(val: number) {
-  const exponent = (val & 0x7c00) >> 10;
-  const fraction = val & 0x03ff;
-  return (
-    (val >> 15 ? -1 : 1) *
-    (exponent
-      ? exponent === 0x1f
-        ? fraction
-          ? NaN
-          : Infinity
-        : Math.pow(2, exponent - 15) * (1 + fraction / 0x400)
-      : 6.103515625e-5 * (fraction / 0x400))
-  );
-}
-*/ async function createSheenLUT(textureSize, texture) {
-    if (texture) {
-        if (!texture.isTexture2D()) {
-            throw new Error('can not reload sheen lut texture: invalid texture type');
-        }
-        if (texture.format !== 'rgba16f') {
-            throw new Error('can not reload sheen lut texture: invalid texture format');
-        }
-        if (texture.width !== textureSize || texture.height !== textureSize) {
-            throw new Error('can not reload sheen lut texture: invalid texture size');
-        }
-    }
-    const tex = texture || Application.instance.device.createTexture2D('rgba16f', textureSize, textureSize);
-    const image = new Uint16Array(textureSize * textureSize * 4);
-    let p = 0;
-    const one = encodeF16(1);
-    for(let y = textureSize - 1; y >= 0; y--){
-        const coord = Math.min(Math.max((y + 0.5) / textureSize, 0), 1);
-        const roughness = coord * coord;
-        for(let x = 0; x < textureSize; x++){
-            const NdotV = Math.min(Math.max((x + 0.5) / textureSize, 0), 1);
-            const c = dfvCharlieUniform(NdotV, roughness, 512);
-            const f16 = encodeF16(c);
-            image[p++] = 0;
-            image[p++] = 0;
-            image[p++] = f16;
-            image[p++] = one;
-        }
-    }
-    tex.update(image, 0, 0, textureSize, textureSize);
-    return tex;
-}
-
-export { createSheenLUT };
-//# sourceMappingURL=sheenlut.js.map

package/dist/utility/sheenlut.js.map

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