bg2e-js 2.3.1 → 2.3.3

package/dist/bg2e-js.js

@@ -5414,7 +5414,7 @@ async function uo(t) {
 }
 class fe {
   constructor(e = "") {
-    this._sceneChanged = !1, this._name = e, this._enabled = !0, this._steady = !1, this._components = new dr(this), this._parent = null, this._children = [];
+    this._sceneChanged = !1, this._postRedisplayFrames = 0, this._name = e, this._enabled = !0, this._steady = !1, this._components = new dr(this), this._parent = null, this._children = [];
   }
   get name() {
     return this._name;
@@ -5519,6 +5519,16 @@ class fe {
         await this._children[r].asyncAccept(e);
     }
   }
+  // Used by components to require a redraw of the scene for a certain number of frames.
+  // This is needed, for example, when a component changes the material of a drawable,
+  // so the change is reflected inmediately in the screen, or when a component generates
+  // an animation that needs to be updated for a certain number of frames.
+  get postRedisplayFrames() {
+    return this._postRedisplayFrames;
+  }
+  set postRedisplayFrames(e) {
+    this._postRedisplayFrames = e;
+  }
   // Most usual components
   get transform() {
     return this.component("Transform");
@@ -7942,22 +7952,25 @@ class St {
 }
 class Rt extends ce {
   constructor(e) {
-    super(), this._renderQueue = e, this._delta = 0, this._modelMatrix = w.MakeIdentity(), this._matrixStack = [];
+    super(), this._postRedisplayFrames = 0, this._renderQueue = e, this._delta = 0, this._modelMatrix = w.MakeIdentity(), this._matrixStack = [];
   }
   get delta() {
     return this._delta;
   }
-  set delta(e) {
-    this._delta = e;
-  }
   get modelMatrix() {
     return this._modelMatrix;
   }
+  get postRedisplayFrames() {
+    return this._postRedisplayFrames;
+  }
+  beginFrame(e) {
+    this._delta = e, this._postRedisplayFrames = 0;
+  }
   visit(e) {
     this._matrixStack.push(new w(this._modelMatrix)), e.frame(this._delta, this._modelMatrix, this._renderQueue);
   }
   didVisit(e) {
-    this._modelMatrix = this._matrixStack[this._matrixStack.length - 1] || w.MakeIdentity(), this._matrixStack.pop();
+    this._modelMatrix = this._matrixStack[this._matrixStack.length - 1] || w.MakeIdentity(), this._matrixStack.pop(), this._postRedisplayFrames = Math.max(this._postRedisplayFrames, e.postRedisplayFrames), e.postRedisplayFrames = 0;
   }
 }
 class cn extends ce {
@@ -8011,6 +8024,9 @@ class un {
   get renderQueue() {
     return this._renderQueue;
   }
+  get postRedisplayFrames() {
+    return this._frameVisitor ? this._frameVisitor.postRedisplayFrames : 0;
+  }
   async init({ shadowMapSize: e = new h(1024, 1024) } = {}) {
     typeof e == "number" && (e = new h(e, e)), this._shadowMapSize = e, this._mainDirectionalLight = null, this._opaquePipeline = this.renderer.factory.pipeline(), this._opaquePipeline?.setBlendState({ enabled: !1 }), this._opaquePipeline?.create(), this._transparentPipeline = this.renderer.factory.pipeline(), this._transparentPipeline?.setBlendState({
       enabled: !0,
@@ -8055,7 +8071,7 @@ class un {
   async frame(e, r) {
     if (!this._frameVisitor || !this._renderQueue || !this._initVisitor)
       throw new Error("SceneRenderer.frame(): SceneRenderer not initialized. Call SceneRenderer.init() first.");
-    e.sceneChanged && await e.asyncAccept(this._initVisitor), this._sceneRoot = e, this._renderQueue?.newFrame(), this._frameVisitor.delta = r, this._frameVisitor.modelMatrix.identity();
+    e.sceneChanged && await e.asyncAccept(this._initVisitor), this._sceneRoot = e, this._renderQueue?.newFrame(), this._frameVisitor.beginFrame(r), this._frameVisitor.modelMatrix.identity();
     const i = j.GetMain(e);
     let n = this.defaultViewMatrix, s = this.defaultProjectionMatrix;
     i && (s = i.projectionMatrix, n = w.GetInverted(oe.GetWorldMatrix(i.node))), this._renderQueue.viewMatrix = n, this._renderQueue.projectionMatrix = s, e.accept(this._frameVisitor), this._skyCube?.updateRenderState({
@@ -9018,7 +9034,7 @@ class m0 extends en {
     !this.sceneRoot || !this.sceneRenderer || (this.sceneRenderer.resize(this.sceneRoot, e, r), this.selectionManager?.setViewportSize(e, r), this.selectionHighlight?.setViewportSize(e, r), this._debugRenderer?.setViewportSize(e, r));
   }
   async frame(e) {
-    !this.sceneRoot || !this.sceneRenderer || (this._debugRenderer?.beginFrame(), await this.sceneRenderer?.frame(this.sceneRoot, e));
+    !this.sceneRoot || !this.sceneRenderer || (this._debugRenderer?.beginFrame(), await this.sceneRenderer?.frame(this.sceneRoot, e), this.sceneRenderer.postRedisplayFrames > 0 && this.mainLoop.postRedisplay({ frames: this.sceneRenderer.postRedisplayFrames }));
   }
   display() {
     if (!this.sceneRoot || !this.sceneRenderer)
@@ -9064,332 +9080,332 @@ class m0 extends en {
     this.sceneRoot && this.sceneRenderer?.touchEnd(this.sceneRoot, e), this.selectionManager?.touchEnd(e), this.updateOnInputEvents && this.mainLoop.postRedisplay({ frames: this._updateInputEventsFrameCount });
   }
 }
-const bn = `#ifndef COLOR_CORRECTION_GLSL
-#define COLOR_CORRECTION_GLSL
-
-// Convert lineal color to SRGB for shader output
-vec4 lineal2SRGB(vec4 color, float gamma)
-{
-    color = color / (color + vec4(1.0));
-    return vec4(pow(color.rgb, vec3(1.0 / gamma)), color.a);
-}
-
-vec3 lineal2SRGB(vec3 color, float gamma)
-{
-    color = color / (color + vec3(1.0));
-    return pow(color.rgb, vec3(1.0 / gamma));
-}
-
-// Convert SRGB textures to lineal color
-vec4 SRGB2Lineal(vec4 color, float gamma)
-{
-    return vec4(pow(color.rgb, vec3(gamma)), color.a);
-}
-
-vec3 SRGB2lLineal(vec3 color, float gamma)
-{
-    return pow(color, vec3(gamma));
-}
-
-vec4 brightnessContrast(vec4 color, float brightness, float contrast)
-{
-    mat4 brightnessMat = mat4(
-        1.0, 0.0, 0.0, 0.0,
-        0.0, 1.0, 0.0, 0.0,
-        0.0, 0.0, 1.0, 0.0,
-        brightness, brightness, brightness, 1.0
-    );
-    float t = (1.0 - contrast) / 2.0;
-    mat4 contrastMat = mat4(
-        contrast, 0.0, 0.0, 0.0,
-        0.0, contrast, 0.0, 0.0,
-        0.0, 0.0, contrast, 0.0,
-        t, t, t, 1.0
-    );
-    return contrastMat * brightnessMat * color;
-}
-
-#endif // COLOR_CORRECTION_GLSL
-
-`, P0 = `
-#define PI 3.14159265359
-#define LIGHT_TYPE_POINT 5
-#define LIGHT_TYPE_DIRECTIONAL 4
-#define LIGHT_TYPE_SPOT 1
-#define LIGHT_TYPE_DISABLED 10
-`, En = `
-mat3 TBNMatrix(mat4 model, vec3 normal, vec3 tangent)
-{
-    vec3 T = normalize(vec3(model * vec4(tangent, 0.0)));
-    vec3 B = normalize(vec3(model * vec4(cross(tangent, normal), 0.0)));
-    vec3 N = normalize(vec3(model * vec4(normal, 0.0)));
-    return mat3(T, B, N);
-}
-
-`, xn = `
-#include "lib/constants.glsl"
-
-vec3 fresnelSchlick(float cosTheta, vec3 F0)
-{
-    return F0 + (1.0 - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);
-}
-
-vec3 fresnelSchlickRoughness(float cosTheta, vec3 F0, float roughness)
-{
-    // Use the Schlick approximation for fresnel with roughness
-    return F0 + (max(vec3(1.0 - roughness), F0) - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);
-}
-
-float distributionGGX(vec3 normal, vec3 halfVector, float roughness)
-{
-    float a = roughness * roughness;
-    float a2 = a * a;
-
-    float NdotH = max(dot(normal, halfVector), 0.0);
-    float NdotH2 = NdotH * NdotH;
-
-    float denom = NdotH2 * (a2 - 1.0) + 1.0;
-
-    return a2 / (PI * denom * denom);
-}
-
-float geometrySchlickGGX(float NdotV, float roughness)
-{
-    float r = (roughness + 1.0);
-    float k = (r * r) / 8.0;
-
-    float num = NdotV;
-    float denom = NdotV * (1.0 - k) + k;
-
-    return num / denom;
-}
-
-float geometrySmith(vec3 normal, vec3 viewDir, vec3 lightDir, float roughness)
-{
-    float NdotV = max(dot(normal, viewDir), 0.0);
-    float NdotL = max(dot(normal, lightDir), 0.0);
-    float ggx2 = geometrySchlickGGX(NdotV, roughness);
-    float ggx1 = geometrySchlickGGX(NdotL, roughness);
-    return ggx1 * ggx2;
-}
-
-float calcAttenuation(vec3 lightPosition, vec3 fragPosition)
-{
-    float distance = length(lightPosition - fragPosition);
-    return 1.0 / (distance * distance);
-}
-
-vec3 calcRadiancePoint( Light light, vec3 viewDir, vec3 fragPos, float metallic, float roughness, vec3 F0, vec3 normal, vec3 albedo, float sheenIntensity, vec3 sheenColor, float ambientOcclussion) {
-    // calculate per-light radiance
-    vec3 L = normalize(light.position - fragPos);
-    vec3 H = normalize(viewDir + L);
-    float attenuation    = calcAttenuation(light.position, fragPos);
-    vec3 radiance     = light.color.rgb * light.intensity * attenuation;
-    
-    // cook-torrance brdf
-    float NDF = distributionGGX(normal, H, roughness);
-    float G   = geometrySmith(normal, viewDir, L, roughness);
-    vec3 F    = fresnelSchlick(max(dot(H, viewDir), 0.0), F0);
-    
-    vec3 kS = F;
-    vec3 kD = vec3(1.0) - kS;
-    kD *= 1.0 - metallic;
-    
-    vec3 numerator    = NDF * G * F;
-    float denominator = 4.0 * max(dot(normal, viewDir), 0.0) * max(dot(normal, L), 0.0) + 0.0001;
-    vec3 specular     = numerator / denominator;
-        
-    // add to outgoing radiance Lo
-    float NdotL = max(dot(normal, L), 0.0);
-    vec3 base = (kD * albedo / PI + specular) * radiance * NdotL;
-    vec3 sheen = calcSheen(normal, viewDir, sheenColor, sheenIntensity) * ambientOcclussion;
-    return base + sheen;
-}
-
-vec3 calcRadianceDirectional(Light light, vec3 viewDir, vec3 fragPos, float metallic, float roughness, vec3 F0, vec3 normal, vec3 albedo, float sheenIntensity, vec3 sheenColor, float ambientOcclussion)
-{
-    vec3 L = normalize(-light.direction);
-    vec3 H = normalize(viewDir + L);
-    vec3 radiance     = light.color.rgb * light.intensity;
-    
-    // cook-torrance brdf
-    float NDF = distributionGGX(normal, H, roughness);
-    float G   = geometrySmith(normal, viewDir, L, roughness);
-    vec3 F    = fresnelSchlick(max(dot(H, viewDir), 0.0), F0);
-    
-    vec3 kS = F;
-    vec3 kD = vec3(1.0) - kS;
-    kD *= 1.0 - metallic;
-    
-    vec3 numerator    = NDF * G * F;
-    float denominator = 4.0 * max(dot(normal, viewDir), 0.0) * max(dot(normal, L), 0.0) + 0.0001;
-    vec3 specular     = numerator / denominator;
-        
-    // add to outgoing radiance Lo
-    float NdotL = max(dot(normal, L), 0.0);
-    vec3 base = (kD * albedo / PI + specular) * radiance * NdotL;
-    vec3 sheen = calcSheen(normal, viewDir, sheenColor, sheenIntensity) * ambientOcclussion;
-    return base + sheen;
-}
-
-vec3 calcRadiance( Light light, vec3 viewDir, vec3 fragPos, float metallic, float roughness, vec3 F0, vec3 normal, vec3 albedo, float sheenIntensity, vec3 sheenColor, float ambientOcclussion) {
-    if (light.type == LIGHT_TYPE_POINT)
-    {
-        return calcRadiancePoint(light, viewDir, fragPos, metallic, roughness, F0, normal, albedo, sheenIntensity, sheenColor, ambientOcclussion);
-    }
-    else if (light.type == LIGHT_TYPE_DIRECTIONAL)
-    {
-        return calcRadianceDirectional(light, viewDir, fragPos, metallic, roughness, F0, normal, albedo, sheenIntensity, sheenColor, ambientOcclussion);
-    }
-    return vec3(0.0);
-}
-
-vec3 getPrefilteredColor(float roughness,vec3 refVec,samplerCube irrMap,samplerCube specMap,samplerCube envMap) {
-    vec3 specMap0 = textureCube(envMap, refVec).rgb;
-    vec3 specMap1 = textureCube(specMap, refVec).rgb;
-    vec3 specMap2 = textureCube(irrMap, refVec).rgb;
-
-    if (roughness < 0.4) {
-        return mix(specMap0, specMap1, roughness / 0.4);
-    }
-    return mix(specMap1, specMap2, (roughness - 0.4) / 0.6);
-}
-
-vec3 calcAmbientLight( vec3 viewDir, vec3 normal, vec3 F0, vec3 albedo, float metallic, float roughness, samplerCube irradianceMap, samplerCube prefilteredEnvMap, samplerCube envMap, sampler2D brdfLUT, float ambientOcclussion, float sheenIntensity, vec3 sheenColor, vec3 shadowColor, float ambientIntensity) {
-    vec3 R = reflect(-viewDir, normal);
-
-    vec3 F = fresnelSchlickRoughness(max(dot(normal, viewDir), 0.0), F0, roughness)  * max(shadowColor, vec3(0.8));
-    
-    vec3 Ks = F;
-    vec3 Kd = 1.0 - Ks;
-    Kd *= 1.0 - metallic;
-
-    vec3 irradiance = textureCube(irradianceMap, normal).rgb * ambientIntensity;
-    vec3 diffuse = irradiance * albedo;
-
-    vec3 prefilteredColor = getPrefilteredColor(roughness, R, irradianceMap, prefilteredEnvMap, envMap);
-
-    vec2 brdfUV = vec2(clamp(max(dot(normal, viewDir), 0.0), 0.01, 0.99), roughness);
-    vec2 envBRDF = texture2D(brdfLUT, brdfUV).rg;
-    vec3 specular = prefilteredColor * (F * envBRDF.x + envBRDF.y);
-
-    vec3 base = (Kd * diffuse + specular) * ambientOcclussion;
-    vec3 sheen = calcSheen(normal, viewDir, sheenColor, sheenIntensity) * ambientOcclussion * shadowColor;
-    return base + sheen;
-}
-
-// TODO: Extract this function to a shadow map shader function
-vec3 getShadowColor(vec4 positionFromLightPov, sampler2D shadowMap, float shadowBias, float shadowStrength) {
-    // The vertex location rendered from the light source is almost in
-    // normalized device coordinates (NDC), but the perspective division
-    // has not been performed yet. We need to divide by w to get the
-    // vertex location in range [-1, +1]
-    vec3 shadowCoord = positionFromLightPov.xyz / positionFromLightPov.w;
-
-    // Convert from NDC to texture coordinates
-    shadowCoord = shadowCoord * 0.5 + 0.5;
-    
-    if (shadowCoord.x >= 0.0 && shadowCoord.x <= 1.0 &&
-        shadowCoord.y >= 0.0 && shadowCoord.y <= 1.0)
-    {
-        float shadowDepth = texture2D(shadowMap, shadowCoord.xy).r;
-        if (shadowCoord.z > shadowDepth + shadowBias) {
-            return vec3(1.0 - shadowStrength);
-        }
-    }
-    return vec3(1.0);
-}
-`, Qn = `
-struct PBRMaterialData
-{
-    vec4 albedo;
-
-    vec2 albedoScale;
-    vec2 normalScale;
-    vec2 metalnessScale;
-    vec2 roughnessScale;
-    vec2 lightEmissionScale;
-
-    float metalness;
-    float roughness;
-    float lightEmission;
-
-    int albedoUVSet;
-    int normalUVSet;
-    int metalnessUVSet;
-    int roughnessUVSet;
-    int lightEmissionUVSet;
-    int aoUVSet;
-
-    vec4 fresnelTint;
-    vec4 sheenColor;
-    float sheenIntensity;
-};
-
-struct Light
-{
-    vec3 position;
-    float intensity;
-    vec4 color;
-    vec3 direction;
-    int type;
-};
-
-vec4 sampleAlbedo(sampler2D tex, vec2 uv0, vec2 uv1, PBRMaterialData mat, float gamma)
-{
-    vec2 uv = mat.albedoUVSet == 0 ? uv0 : uv1;
-    vec4 texColor = texture2D(tex, uv * mat.albedoScale);
-    return vec4(SRGB2Lineal(texColor, gamma).rgb * mat.albedo.rgb, texColor.a * mat.albedo.a);
-}
-
-float sampleMetallic(sampler2D tex, vec2 uv0, vec2 uv1, PBRMaterialData mat)
-{
-    vec2 uv = mat.metalnessUVSet == 0 ? uv0 : uv1;
-    return texture2D(tex, uv * mat.metalnessScale).r * mat.metalness;
-}
-
-float sampleRoughness(sampler2D tex, vec2 uv0, vec2 uv1, PBRMaterialData mat)
-{
-    const float minRoughness = 0.05; // Minimum roughness value: even a mirror have some roughness
-    const float maxRoughness = 0.98; // Maximum roughness value: avoid completely diffuse surfaces
-    vec2 uv = mat.roughnessUVSet == 0 ? uv0 : uv1;
-    return min(max(texture2D(tex, uv * mat.roughnessScale).g  * mat.roughness, minRoughness), maxRoughness);
-}
-
-
-float sampleLightEmission(sampler2D tex, vec2 uv0, vec2 uv1, PBRMaterialData mat)
-{
-    vec2 uv = mat.lightEmissionUVSet == 0 ? uv0 : uv1;
-    return texture2D(tex, uv * mat.lightEmissionScale).b  * mat.lightEmission;
-}
-
-vec3 sampleNormal(sampler2D tex, vec2 uv0, vec2 uv1, PBRMaterialData mat, mat3 TBN)
-{
-    vec2 uv = mat.normalUVSet == 0 ? uv0 : uv1;
-    vec3 normal = texture2D(tex, uv * mat.normalScale).xyz * 2.0 - 1.0;
-    return normalize(TBN * normal);
-}
-
-float sampleAmbientOcclussion(sampler2D tex, vec2 uv0, vec2 uv1, PBRMaterialData mat)
-{
-    vec2 uv = mat.aoUVSet == 0 ? uv0 : uv1;
-    return texture2D(tex, uv).a;
-}
-
-vec3 calcF0(vec3 albedo, PBRMaterialData mat)
-{
-    return mix(vec3(0.04), albedo, mat.metalness) * mat.fresnelTint.rgb;
-}
-
-vec3 calcSheen(vec3 normal, vec3 viewDir, vec3 sheenColor, float sheenIntensity)
-{
-    float NdotV = max(dot(normal, viewDir), 0.0);
-    float facing = 1.0 - NdotV;
-    
-    // Adjustable power: controls how concentrated the brightness is
-    float falloff = pow(facing, 5.0);
-    return sheenColor * falloff * sheenIntensity;
-}
+const bn = `#ifndef COLOR_CORRECTION_GLSL\r
+#define COLOR_CORRECTION_GLSL\r
+\r
+// Convert lineal color to SRGB for shader output\r
+vec4 lineal2SRGB(vec4 color, float gamma)\r
+{\r
+    color = color / (color + vec4(1.0));\r
+    return vec4(pow(color.rgb, vec3(1.0 / gamma)), color.a);\r
+}\r
+\r
+vec3 lineal2SRGB(vec3 color, float gamma)\r
+{\r
+    color = color / (color + vec3(1.0));\r
+    return pow(color.rgb, vec3(1.0 / gamma));\r
+}\r
+\r
+// Convert SRGB textures to lineal color\r
+vec4 SRGB2Lineal(vec4 color, float gamma)\r
+{\r
+    return vec4(pow(color.rgb, vec3(gamma)), color.a);\r
+}\r
+\r
+vec3 SRGB2lLineal(vec3 color, float gamma)\r
+{\r
+    return pow(color, vec3(gamma));\r
+}\r
+\r
+vec4 brightnessContrast(vec4 color, float brightness, float contrast)\r
+{\r
+    mat4 brightnessMat = mat4(\r
+        1.0, 0.0, 0.0, 0.0,\r
+        0.0, 1.0, 0.0, 0.0,\r
+        0.0, 0.0, 1.0, 0.0,\r
+        brightness, brightness, brightness, 1.0\r
+    );\r
+    float t = (1.0 - contrast) / 2.0;\r
+    mat4 contrastMat = mat4(\r
+        contrast, 0.0, 0.0, 0.0,\r
+        0.0, contrast, 0.0, 0.0,\r
+        0.0, 0.0, contrast, 0.0,\r
+        t, t, t, 1.0\r
+    );\r
+    return contrastMat * brightnessMat * color;\r
+}\r
+\r
+#endif // COLOR_CORRECTION_GLSL\r
+\r
+`, P0 = `\r
+#define PI 3.14159265359\r
+#define LIGHT_TYPE_POINT 5\r
+#define LIGHT_TYPE_DIRECTIONAL 4\r
+#define LIGHT_TYPE_SPOT 1\r
+#define LIGHT_TYPE_DISABLED 10\r
+`, En = `\r
+mat3 TBNMatrix(mat4 model, vec3 normal, vec3 tangent)\r
+{\r
+    vec3 T = normalize(vec3(model * vec4(tangent, 0.0)));\r
+    vec3 B = normalize(vec3(model * vec4(cross(tangent, normal), 0.0)));\r
+    vec3 N = normalize(vec3(model * vec4(normal, 0.0)));\r
+    return mat3(T, B, N);\r
+}\r
+\r
+`, xn = `\r
+#include "lib/constants.glsl"\r
+\r
+vec3 fresnelSchlick(float cosTheta, vec3 F0)\r
+{\r
+    return F0 + (1.0 - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);\r
+}\r
+\r
+vec3 fresnelSchlickRoughness(float cosTheta, vec3 F0, float roughness)\r
+{\r
+    // Use the Schlick approximation for fresnel with roughness\r
+    return F0 + (max(vec3(1.0 - roughness), F0) - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);\r
+}\r
+\r
+float distributionGGX(vec3 normal, vec3 halfVector, float roughness)\r
+{\r
+    float a = roughness * roughness;\r
+    float a2 = a * a;\r
+\r
+    float NdotH = max(dot(normal, halfVector), 0.0);\r
+    float NdotH2 = NdotH * NdotH;\r
+\r
+    float denom = NdotH2 * (a2 - 1.0) + 1.0;\r
+\r
+    return a2 / (PI * denom * denom);\r
+}\r
+\r
+float geometrySchlickGGX(float NdotV, float roughness)\r
+{\r
+    float r = (roughness + 1.0);\r
+    float k = (r * r) / 8.0;\r
+\r
+    float num = NdotV;\r
+    float denom = NdotV * (1.0 - k) + k;\r
+\r
+    return num / denom;\r
+}\r
+\r
+float geometrySmith(vec3 normal, vec3 viewDir, vec3 lightDir, float roughness)\r
+{\r
+    float NdotV = max(dot(normal, viewDir), 0.0);\r
+    float NdotL = max(dot(normal, lightDir), 0.0);\r
+    float ggx2 = geometrySchlickGGX(NdotV, roughness);\r
+    float ggx1 = geometrySchlickGGX(NdotL, roughness);\r
+    return ggx1 * ggx2;\r
+}\r
+\r
+float calcAttenuation(vec3 lightPosition, vec3 fragPosition)\r
+{\r
+    float distance = length(lightPosition - fragPosition);\r
+    return 1.0 / (distance * distance);\r
+}\r
+\r
+vec3 calcRadiancePoint( Light light, vec3 viewDir, vec3 fragPos, float metallic, float roughness, vec3 F0, vec3 normal, vec3 albedo, float sheenIntensity, vec3 sheenColor, float ambientOcclussion) {\r
+    // calculate per-light radiance\r
+    vec3 L = normalize(light.position - fragPos);\r
+    vec3 H = normalize(viewDir + L);\r
+    float attenuation    = calcAttenuation(light.position, fragPos);\r
+    vec3 radiance     = light.color.rgb * light.intensity * attenuation;\r
+    \r
+    // cook-torrance brdf\r
+    float NDF = distributionGGX(normal, H, roughness);\r
+    float G   = geometrySmith(normal, viewDir, L, roughness);\r
+    vec3 F    = fresnelSchlick(max(dot(H, viewDir), 0.0), F0);\r
+    \r
+    vec3 kS = F;\r
+    vec3 kD = vec3(1.0) - kS;\r
+    kD *= 1.0 - metallic;\r
+    \r
+    vec3 numerator    = NDF * G * F;\r
+    float denominator = 4.0 * max(dot(normal, viewDir), 0.0) * max(dot(normal, L), 0.0) + 0.0001;\r
+    vec3 specular     = numerator / denominator;\r
+        \r
+    // add to outgoing radiance Lo\r
+    float NdotL = max(dot(normal, L), 0.0);\r
+    vec3 base = (kD * albedo / PI + specular) * radiance * NdotL;\r
+    vec3 sheen = calcSheen(normal, viewDir, sheenColor, sheenIntensity) * ambientOcclussion;\r
+    return base + sheen;\r
+}\r
+\r
+vec3 calcRadianceDirectional(Light light, vec3 viewDir, vec3 fragPos, float metallic, float roughness, vec3 F0, vec3 normal, vec3 albedo, float sheenIntensity, vec3 sheenColor, float ambientOcclussion)\r
+{\r
+    vec3 L = normalize(-light.direction);\r
+    vec3 H = normalize(viewDir + L);\r
+    vec3 radiance     = light.color.rgb * light.intensity;\r
+    \r
+    // cook-torrance brdf\r
+    float NDF = distributionGGX(normal, H, roughness);\r
+    float G   = geometrySmith(normal, viewDir, L, roughness);\r
+    vec3 F    = fresnelSchlick(max(dot(H, viewDir), 0.0), F0);\r
+    \r
+    vec3 kS = F;\r
+    vec3 kD = vec3(1.0) - kS;\r
+    kD *= 1.0 - metallic;\r
+    \r
+    vec3 numerator    = NDF * G * F;\r
+    float denominator = 4.0 * max(dot(normal, viewDir), 0.0) * max(dot(normal, L), 0.0) + 0.0001;\r
+    vec3 specular     = numerator / denominator;\r
+        \r
+    // add to outgoing radiance Lo\r
+    float NdotL = max(dot(normal, L), 0.0);\r
+    vec3 base = (kD * albedo / PI + specular) * radiance * NdotL;\r
+    vec3 sheen = calcSheen(normal, viewDir, sheenColor, sheenIntensity) * ambientOcclussion;\r
+    return base + sheen;\r
+}\r
+\r
+vec3 calcRadiance( Light light, vec3 viewDir, vec3 fragPos, float metallic, float roughness, vec3 F0, vec3 normal, vec3 albedo, float sheenIntensity, vec3 sheenColor, float ambientOcclussion) {\r
+    if (light.type == LIGHT_TYPE_POINT)\r
+    {\r
+        return calcRadiancePoint(light, viewDir, fragPos, metallic, roughness, F0, normal, albedo, sheenIntensity, sheenColor, ambientOcclussion);\r
+    }\r
+    else if (light.type == LIGHT_TYPE_DIRECTIONAL)\r
+    {\r
+        return calcRadianceDirectional(light, viewDir, fragPos, metallic, roughness, F0, normal, albedo, sheenIntensity, sheenColor, ambientOcclussion);\r
+    }\r
+    return vec3(0.0);\r
+}\r
+\r
+vec3 getPrefilteredColor(float roughness,vec3 refVec,samplerCube irrMap,samplerCube specMap,samplerCube envMap) {\r
+    vec3 specMap0 = textureCube(envMap, refVec).rgb;\r
+    vec3 specMap1 = textureCube(specMap, refVec).rgb;\r
+    vec3 specMap2 = textureCube(irrMap, refVec).rgb;\r
+\r
+    if (roughness < 0.4) {\r
+        return mix(specMap0, specMap1, roughness / 0.4);\r
+    }\r
+    return mix(specMap1, specMap2, (roughness - 0.4) / 0.6);\r
+}\r
+\r
+vec3 calcAmbientLight( vec3 viewDir, vec3 normal, vec3 F0, vec3 albedo, float metallic, float roughness, samplerCube irradianceMap, samplerCube prefilteredEnvMap, samplerCube envMap, sampler2D brdfLUT, float ambientOcclussion, float sheenIntensity, vec3 sheenColor, vec3 shadowColor, float ambientIntensity) {\r
+    vec3 R = reflect(-viewDir, normal);\r
+\r
+    vec3 F = fresnelSchlickRoughness(max(dot(normal, viewDir), 0.0), F0, roughness)  * max(shadowColor, vec3(0.8));\r
+    \r
+    vec3 Ks = F;\r
+    vec3 Kd = 1.0 - Ks;\r
+    Kd *= 1.0 - metallic;\r
+\r
+    vec3 irradiance = textureCube(irradianceMap, normal).rgb * ambientIntensity;\r
+    vec3 diffuse = irradiance * albedo;\r
+\r
+    vec3 prefilteredColor = getPrefilteredColor(roughness, R, irradianceMap, prefilteredEnvMap, envMap);\r
+\r
+    vec2 brdfUV = vec2(clamp(max(dot(normal, viewDir), 0.0), 0.01, 0.99), roughness);\r
+    vec2 envBRDF = texture2D(brdfLUT, brdfUV).rg;\r
+    vec3 specular = prefilteredColor * (F * envBRDF.x + envBRDF.y);\r
+\r
+    vec3 base = (Kd * diffuse + specular) * ambientOcclussion;\r
+    vec3 sheen = calcSheen(normal, viewDir, sheenColor, sheenIntensity) * ambientOcclussion * shadowColor;\r
+    return base + sheen;\r
+}\r
+\r
+// TODO: Extract this function to a shadow map shader function\r
+vec3 getShadowColor(vec4 positionFromLightPov, sampler2D shadowMap, float shadowBias, float shadowStrength) {\r
+    // The vertex location rendered from the light source is almost in\r
+    // normalized device coordinates (NDC), but the perspective division\r
+    // has not been performed yet. We need to divide by w to get the\r
+    // vertex location in range [-1, +1]\r
+    vec3 shadowCoord = positionFromLightPov.xyz / positionFromLightPov.w;\r
+\r
+    // Convert from NDC to texture coordinates\r
+    shadowCoord = shadowCoord * 0.5 + 0.5;\r
+    \r
+    if (shadowCoord.x >= 0.0 && shadowCoord.x <= 1.0 &&\r
+        shadowCoord.y >= 0.0 && shadowCoord.y <= 1.0)\r
+    {\r
+        float shadowDepth = texture2D(shadowMap, shadowCoord.xy).r;\r
+        if (shadowCoord.z > shadowDepth + shadowBias) {\r
+            return vec3(1.0 - shadowStrength);\r
+        }\r
+    }\r
+    return vec3(1.0);\r
+}\r
+`, Qn = `\r
+struct PBRMaterialData\r
+{\r
+    vec4 albedo;\r
+\r
+    vec2 albedoScale;\r
+    vec2 normalScale;\r
+    vec2 metalnessScale;\r
+    vec2 roughnessScale;\r
+    vec2 lightEmissionScale;\r
+\r
+    float metalness;\r
+    float roughness;\r
+    float lightEmission;\r
+\r
+    int albedoUVSet;\r
+    int normalUVSet;\r
+    int metalnessUVSet;\r
+    int roughnessUVSet;\r
+    int lightEmissionUVSet;\r
+    int aoUVSet;\r
+\r
+    vec4 fresnelTint;\r
+    vec4 sheenColor;\r
+    float sheenIntensity;\r
+};\r
+\r
+struct Light\r
+{\r
+    vec3 position;\r
+    float intensity;\r
+    vec4 color;\r
+    vec3 direction;\r
+    int type;\r
+};\r
+\r
+vec4 sampleAlbedo(sampler2D tex, vec2 uv0, vec2 uv1, PBRMaterialData mat, float gamma)\r
+{\r
+    vec2 uv = mat.albedoUVSet == 0 ? uv0 : uv1;\r
+    vec4 texColor = texture2D(tex, uv * mat.albedoScale);\r
+    return vec4(SRGB2Lineal(texColor, gamma).rgb * mat.albedo.rgb, texColor.a * mat.albedo.a);\r
+}\r
+\r
+float sampleMetallic(sampler2D tex, vec2 uv0, vec2 uv1, PBRMaterialData mat)\r
+{\r
+    vec2 uv = mat.metalnessUVSet == 0 ? uv0 : uv1;\r
+    return texture2D(tex, uv * mat.metalnessScale).r * mat.metalness;\r
+}\r
+\r
+float sampleRoughness(sampler2D tex, vec2 uv0, vec2 uv1, PBRMaterialData mat)\r
+{\r
+    const float minRoughness = 0.05; // Minimum roughness value: even a mirror have some roughness\r
+    const float maxRoughness = 0.98; // Maximum roughness value: avoid completely diffuse surfaces\r
+    vec2 uv = mat.roughnessUVSet == 0 ? uv0 : uv1;\r
+    return min(max(texture2D(tex, uv * mat.roughnessScale).g  * mat.roughness, minRoughness), maxRoughness);\r
+}\r
+\r
+\r
+float sampleLightEmission(sampler2D tex, vec2 uv0, vec2 uv1, PBRMaterialData mat)\r
+{\r
+    vec2 uv = mat.lightEmissionUVSet == 0 ? uv0 : uv1;\r
+    return texture2D(tex, uv * mat.lightEmissionScale).b  * mat.lightEmission;\r
+}\r
+\r
+vec3 sampleNormal(sampler2D tex, vec2 uv0, vec2 uv1, PBRMaterialData mat, mat3 TBN)\r
+{\r
+    vec2 uv = mat.normalUVSet == 0 ? uv0 : uv1;\r
+    vec3 normal = texture2D(tex, uv * mat.normalScale).xyz * 2.0 - 1.0;\r
+    return normalize(TBN * normal);\r
+}\r
+\r
+float sampleAmbientOcclussion(sampler2D tex, vec2 uv0, vec2 uv1, PBRMaterialData mat)\r
+{\r
+    vec2 uv = mat.aoUVSet == 0 ? uv0 : uv1;\r
+    return texture2D(tex, uv).a;\r
+}\r
+\r
+vec3 calcF0(vec3 albedo, PBRMaterialData mat)\r
+{\r
+    return mix(vec3(0.04), albedo, mat.metalness) * mat.fresnelTint.rgb;\r
+}\r
+\r
+vec3 calcSheen(vec3 normal, vec3 viewDir, vec3 sheenColor, float sheenIntensity)\r
+{\r
+    float NdotV = max(dot(normal, viewDir), 0.0);\r
+    float facing = 1.0 - NdotV;\r
+    \r
+    // Adjustable power: controls how concentrated the brightness is\r
+    float falloff = pow(facing, 5.0);\r
+    return sheenColor * falloff * sheenIntensity;\r
+}\r
 `;
 let _t = null;
 function B0() {