@arcgis/core 5.1.0-next.57 → 5.1.0-next.59

package/views/3d/webgl-engine/core/shaderLibrary/shading/EvaluateSceneLighting.glsl.js

@@ -1,92 +1,113 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
-import{EvaluateAmbientLighting as i}from"./EvaluateAmbientLighting.glsl.js";import{EvaluateAmbientOcclusion as n}from"./EvaluateAmbientOcclusion.glsl.js";import{Gamma as e}from"./Gamma.glsl.js";import{addMainLightDirection as o,addMainLightIntensity as t,applyShading as a}from"./MainLighting.glsl.js";import{PhysicallyBasedRendering as r}from"./PhysicallyBasedRendering.glsl.js";import{PiUtils as l}from"./PiUtils.glsl.js";import{BooleanBindUniform as c}from"../../shaderModules/BooleanBindUniform.js";import{FloatBindUniform as d}from"../../shaderModules/FloatBindUniform.js";import{If as m,glsl as s}from"../../shaderModules/glsl.js";import{ambientBoost as g}from"../../../lighting/SceneLighting.js";import{BlackLevelLightSoftCompression as h}from"../../../shaders/BlackLevelLightSoftCompression.glsl.js";import{ToneMapping as u}from"../../../shaders/ToneMapping.glsl.js";function p(i){i.constants.add("ambientBoostFactor","float",g)}function f(i){i.uniforms.add(new d("lightingGlobalFactor",i=>i.lighting.globalFactor))}function v(g,v){const{pbrMode:L,spherical:b,hasColorTexture:C}=v;g.include(n,v),0!==L&&g.include(r,v),g.include(i,v),g.include(l),g.include(u,v),g.include(e);const N=!(2===L&&!C);switch(N&&g.include(h),g.code.add(s`
-    ${m(0!==L,"const float GROUND_REFLECTANCE = 0.2;")}
-  `),p(g),f(g),o(g),g.code.add(s`
+import{EvaluateAmbientLighting as i}from"./EvaluateAmbientLighting.glsl.js";import{EvaluateAmbientOcclusion as n}from"./EvaluateAmbientOcclusion.glsl.js";import{Gamma as e}from"./Gamma.glsl.js";import{addMainLightDirection as t,addMainLightIntensity as a,applyShading as o}from"./MainLighting.glsl.js";import{PhysicallyBasedRendering as l}from"./PhysicallyBasedRendering.glsl.js";import{PiUtils as r}from"./PiUtils.glsl.js";import{ReadGlobalIllumination as c}from"./ReadGlobalIllumination.glsl.js";import{BooleanBindUniform as s}from"../../shaderModules/BooleanBindUniform.js";import{FloatBindUniform as d}from"../../shaderModules/FloatBindUniform.js";import{glsl as m,If as u}from"../../shaderModules/glsl.js";import{ambientBoost as g}from"../../../lighting/SceneLighting.js";import{BlackLevelLightSoftCompression as h}from"../../../shaders/BlackLevelLightSoftCompression.glsl.js";import{ToneMapping as p}from"../../../shaders/ToneMapping.glsl.js";function f(i){i.constants.add("ambientBoostFactor","float",g)}function b(i){i.uniforms.add(new d("lightingGlobalFactor",i=>i.lighting.globalFactor))}function v(g,v){const{pbrMode:L,spherical:C,hasColorTexture:I,receiveGlobalIllumination:D}=v;g.include(e),g.include(c,v),g.include(n,v),0!==L&&g.include(l,v),g.include(i,v),g.include(r),g.include(p,v);const R=!(2===L&&!I);R&&g.include(h),f(g),b(g),t(g),g.code.add(m`
     float additionalDirectedAmbientLight(float lightAlignment) {
       return smoothstep(0.0, 1.0, clamp(lightAlignment * 2.5, 0.0, 1.0));
     }
 
     float additionalDirectedAmbientLight(vec3 vPosWorld) {
-      float lightAlignment = dot(${b?s`normalize(vPosWorld)`:s`vec3(0.0, 0.0, 1.0)`}, mainLightDirection);
+      float lightAlignment = dot(${C?m`normalize(vPosWorld)`:m`vec3(0.0, 0.0, 1.0)`}, mainLightDirection);
       return smoothstep(0.0, 1.0, clamp(lightAlignment * 2.5, 0.0, 1.0));
     }
-  `),t(g),g.code.add(s`vec3 evaluateAdditionalLighting(float ambientOcclusion, vec3 vPosWorld) {
+  `),a(g),g.code.add(m`vec3 evaluateAdditionalLighting(float ambientOcclusion, vec3 vPosWorld) {
 float additionalAmbientScale = additionalDirectedAmbientLight(vPosWorld);
 return (1.0 - ambientOcclusion) * additionalAmbientScale * ambientBoostFactor * lightingGlobalFactor * mainLightIntensity;
-}`),L){case 0:case 4:case 3:g.include(a),g.code.add(s`vec3 evaluateSceneLighting(vec3 normalWorld, vec3 albedo, float shadow, float ssao, vec3 additionalLight) {
+}`);const y=D?"globalIlluminationOcclusion":"ssao",A=D?.75:1,S=D?1.5:1;switch(L){case 0:case 4:case 3:g.include(o),g.code.add(m`vec3 evaluateSceneLighting(vec3 normalWorld, vec3 albedo, float shadow, float ssao, vec3 additionalLight) {
 vec3 mainLighting = applyShading(normalWorld, shadow);
-vec3 ambientLighting = calculateAmbientIrradiance(normalWorld, ssao);
+vec3 ambientLighting = calculateAmbientIrradiance(normalWorld) * (1.0 - ssao);
 vec3 albedoLinear = linearizeGamma(albedo);
 vec3 totalLight = mainLighting + ambientLighting + additionalLight;
 totalLight = min(totalLight, vec3(PI));
 vec3 outColor = vec3((albedoLinear / PI) * totalLight);
 return delinearizeGamma(outColor);
-}`);break;case 1:case 2:g.code.add(s`const float fillLightIntensity = 0.25;
-const float horizonLightDiffusion = 0.4;
-const float additionalAmbientIrradianceFactor = 0.02;
-vec3 evaluateSceneLightingPBR(vec3 normal, vec3 albedo, float shadow, float ssao, vec3 additionalLight,
-vec3 viewDir, vec3 groundNormal, vec3 mrr, float additionalAmbientIrradiance) {
-vec3 viewDirection = -viewDir;
-vec3 h = normalize(viewDirection + mainLightDirection);
-PBRShadingInfo inputs;
-inputs.NdotV = clamp(abs(dot(normal, viewDirection)), 0.001, 1.0);
-inputs.NdotNG = clamp(dot(normal, groundNormal), -1.0, 1.0);
-vec3 reflectedView = normalize(reflect(viewDirection, normal));
-inputs.RdotNG = clamp(dot(reflectedView, groundNormal), -1.0, 1.0);
-inputs.albedoLinear = linearizeGamma(albedo);
-inputs.ssao = ssao;
-inputs.metalness = mrr[0];
-inputs.roughness = clamp(mrr[1] * mrr[1], 0.001, 0.99);`),g.code.add(s`inputs.f0 = (0.16 * mrr[2] * mrr[2]) * (1.0 - inputs.metalness) + inputs.albedoLinear * inputs.metalness;
-inputs.f90 = vec3(clamp(dot(inputs.f0, vec3(50.0 * 0.33)), 0.0, 1.0));
-inputs.diffuseColor = inputs.albedoLinear * (vec3(1.0) - inputs.f0) * (1.0 - inputs.metalness);`),v.useFillLights?g.uniforms.add(new c("hasFillLights",i=>i.enableFillLights)):g.constants.add("hasFillLights","bool",!1),g.code.add(s`vec3 ambientDir = vec3(5.0 * groundNormal[1] - groundNormal[0] * groundNormal[2], - 5.0 * groundNormal[0] - groundNormal[2] * groundNormal[1], groundNormal[1] * groundNormal[1] + groundNormal[0] * groundNormal[0]);
-ambientDir = ambientDir != vec3(0.0) ? normalize(ambientDir) : normalize(vec3(5.0, -1.0, 0.0));
-inputs.NdotAmbDir = hasFillLights ? abs(dot(normal, ambientDir)) : 1.0;
-float NdotL = clamp(dot(normal, mainLightDirection), 0.001, 1.0);
-vec3 mainLightIrradianceComponent = NdotL * (1.0 - shadow) * mainLightIntensity;
-vec3 fillLightsIrradianceComponent = inputs.NdotAmbDir * mainLightIntensity * fillLightIntensity;
-vec3 ambientLightIrradianceComponent = calculateAmbientIrradiance(normal, ssao) + additionalLight;
-inputs.skyIrradianceToSurface = ambientLightIrradianceComponent + mainLightIrradianceComponent + fillLightsIrradianceComponent ;
-inputs.groundIrradianceToSurface = GROUND_REFLECTANCE * ambientLightIrradianceComponent + mainLightIrradianceComponent + fillLightsIrradianceComponent ;`),g.uniforms.add(new d("lightingSpecularStrength",i=>i.lighting.mainLight.specularStrength),new d("lightingEnvironmentStrength",i=>i.lighting.mainLight.environmentStrength)).code.add(s`vec3 horizonRingDir = inputs.RdotNG * groundNormal - reflectedView;
-vec3 horizonRingH = normalize(viewDirection + horizonRingDir);
-inputs.NdotH_Horizon = dot(normal, horizonRingH);
-float NdotH = clamp(dot(normal, h), 0.0, 1.0);
-vec3 mainLightRadianceComponent = lightingSpecularStrength * normalDistribution(NdotH, inputs.roughness) * mainLightIntensity * (1.0 - shadow);
-vec3 horizonLightRadianceComponent = lightingEnvironmentStrength * normalDistribution(inputs.NdotH_Horizon, min(inputs.roughness + horizonLightDiffusion, 1.0)) * mainLightIntensity * fillLightIntensity;
-vec3 ambientLightRadianceComponent = lightingEnvironmentStrength * calculateAmbientRadiance(ssao) + additionalLight;
-float normalDirectionModifier = mix(1., min(mix(0.1, 2.0, (inputs.NdotNG + 1.) * 0.5), 1.0), clamp(inputs.roughness * 5.0, 0.0 , 1.0));
-inputs.skyRadianceToSurface = (ambientLightRadianceComponent + horizonLightRadianceComponent) * normalDirectionModifier + mainLightRadianceComponent;
-inputs.groundRadianceToSurface = 0.5 * GROUND_REFLECTANCE * (ambientLightRadianceComponent + horizonLightRadianceComponent) * normalDirectionModifier + mainLightRadianceComponent;
-inputs.averageAmbientRadiance = ambientLightIrradianceComponent[1] * (1.0 + GROUND_REFLECTANCE);`),g.code.add(s`
+}`);break;case 1:case 2:{const i=D?.35:.2;g.code.add(m`
+        const float fillLightIntensity = 0.25;
+        const float horizonLightDiffusion = 0.4;
+        const float additionalAmbientIrradianceFactor = 0.02;
+        const float groundReflectance = ${m.float(i)};
+
+        vec3 evaluateSceneLightingPBR(vec3 normal, vec3 albedo, float shadow, float ssao, vec3 additionalLight,
+                                      vec3 viewDirection, vec3 upDirection, vec3 mrr, float additionalAmbientIrradiance) {
+          PBRShadingInfo inputs;
+          calculatePBRInputs(inputs, normal, viewDirection, upDirection, albedo, mrr);
+
+          ${u(D,m`vec3 globalIlluminationOcclusion = min(1.2 * readGlobalIlluminationOcclusion(), 1.0);`)}
+      `),v.useFillLights?g.uniforms.add(new s("hasFillLights",i=>i.enableFillLights)):g.constants.add("hasFillLights","bool",!1),g.code.add(m`
+        vec3 ambientDir = vec3(5.0 * upDirection[1] - upDirection[0] * upDirection[2], - 5.0 * upDirection[0] - upDirection[2] * upDirection[1], upDirection[1] * upDirection[1] + upDirection[0] * upDirection[0]);
+        ambientDir = ambientDir != vec3(0.0) ? normalize(ambientDir) : normalize(vec3(5.0, -1.0, 0.0));
+
+        inputs.NdotAmbDir = hasFillLights ? abs(dot(normal, ambientDir)) : 1.0;
+
+        // Calculate the irradiance components: sun, fill lights and the sky.
+        vec3 mainLightIrradianceComponent = ${m.float(A)} * inputs.NdotL * (1.0 - shadow) * mainLightIntensity;
+        vec3 fillLightsIrradianceComponent = inputs.NdotAmbDir * mainLightIntensity * fillLightIntensity;
+        // calculate ambient irradiance for localView and additionalLight for globalView
+        vec3 ambientLightIrradianceComponent = ${m.float(S)} * calculateAmbientIrradiance(normal) * (1.0 - ${y}) + additionalLight;
+
+        // Assemble the overall irradiance of the sky that illuminates the surface
+        inputs.skyIrradianceToSurface = ambientLightIrradianceComponent + mainLightIrradianceComponent + fillLightsIrradianceComponent ;
+        // Assemble the overall irradiance of the ground that illuminates the surface. for this we use the simple model that changes only the sky irradiance by the groundReflectance
+        inputs.groundIrradianceToSurface = groundReflectance * ambientLightIrradianceComponent + mainLightIrradianceComponent + fillLightsIrradianceComponent ;
+      `),g.uniforms.add(new d("lightingSpecularStrength",i=>i.lighting.mainLight.specularStrength),new d("lightingEnvironmentStrength",i=>i.lighting.mainLight.environmentStrength)).code.add(m`
+        vec3 horizonRingDir = inputs.RdotUP * upDirection - inputs.reflectedView;
+        vec3 horizonRingH = normalize(horizonRingDir - viewDirection);
+        inputs.NdotH_Horizon = dot(normal, horizonRingH);
+
+        vec3 mainLightRadianceComponent = lightingSpecularStrength * normalDistribution(inputs.NdotH, inputs.roughness) * mainLightIntensity * (1.0 - shadow);
+        vec3 horizonLightRadianceComponent = lightingEnvironmentStrength * normalDistribution(inputs.NdotH_Horizon, min(inputs.roughness + horizonLightDiffusion, 1.0)) * mainLightIntensity * fillLightIntensity;
+
+        // calculateAmbientRadiance for localView and additionalLight for global view
+        vec3 ambientLightRadianceComponent = lightingEnvironmentStrength * calculateAmbientRadiance() * (1.0 - ${y}) + additionalLight;
+        float normalDirectionModifier = mix(1., min(mix(0.1, 2.0, (inputs.NdotUP + 1.) * 0.5), 1.0), clamp(inputs.roughness * 5.0, 0.0 , 1.0));
+
+        // Assemble the overall radiance of the sky that illuminates the surface
+        inputs.skyRadianceToSurface = (ambientLightRadianceComponent + horizonLightRadianceComponent) * normalDirectionModifier + mainLightRadianceComponent;
+
+        // Assemble the overall radiance of the ground that illuminates the surface. for this we use the simple model that changes only the sky radiance by the groundReflectance
+        inputs.groundRadianceToSurface = 0.5 * groundReflectance * (ambientLightRadianceComponent + horizonLightRadianceComponent) * normalDirectionModifier + mainLightRadianceComponent;
+
+        // Calculate average ambient radiance - This is used in the gamut mapping process to determine the black level for compression
+        inputs.averageAmbientRadiance = ambientLightIrradianceComponent[1] * (1.0 + groundReflectance);
+      `),g.code.add(m`
         vec3 reflectedColorComponent = evaluateEnvironmentIllumination(inputs);
         vec3 additionalMaterialReflectanceComponent = inputs.albedoLinear * additionalAmbientIrradiance;
         vec3 outColorLinear = reflectedColorComponent + additionalMaterialReflectanceComponent;
-        ${N?s`vec3 outColor = blackLevelSoftCompression(outColorLinear, inputs.averageAmbientRadiance);`:s`vec3 outColor = max(vec3(0.0), outColorLinear - 0.005 * inputs.averageAmbientRadiance);`}
-        return delinearizeGamma(outColor);
+
+        ${u(D,m`
+        vec3 globalIlluminationEmission = 2.25 * (0.75 * inputs.albedoLinear + 0.25) * readGlobalIlluminationEmission().rgb;
+        outColorLinear += globalIlluminationEmission;`)}
+
+      ${R?m`vec3 adjustedOutColorLinear = blackLevelSoftCompression(outColorLinear, inputs.averageAmbientRadiance);`:m`vec3 adjustedOutColorLinear = max(vec3(0.0), outColorLinear - 0.005 * inputs.averageAmbientRadiance);`}
+
+        return delinearizeGamma(adjustedOutColorLinear);
+      }
+    `);break}case 5:case 6:{const i=D?.35:.5,n=D?.75:1,e=D?1.5:1;t(g),a(g),g.code.add(m`
+      const float roughnessTerrain = 0.5;
+      const float specularityTerrain = ${m.float(i)};
+
+      vec3 evaluatePBRSimplifiedLighting(vec3 normal, vec3 albedo, float shadow, float ssao, vec3 additionalLight, vec3 viewDirection, vec3 upDirection) {
+        PBRShadingInfo inputs;
+        calculateSimplifiedInputs(inputs, normal, viewDirection, upDirection, albedo);
+
+        ${u(D,m`vec3 globalIlluminationOcclusion = min(1.2 * readGlobalIlluminationOcclusion(), 1.0);`)}
+
+        vec3 mainLightIrradianceComponent = ${m.float(n)} * (1.0 - shadow) * inputs.NdotL * mainLightIntensity;
+        vec3 ambientLightIrradianceComponent = ${m.float(e)} * calculateAmbientIrradiance(normal) * (1.0 - ${y}) + additionalLight;
+        vec3 ambientSky = ambientLightIrradianceComponent + mainLightIrradianceComponent;
+
+        vec3 indirectDiffuse = ((1.0 - inputs.NdotUP) * mainLightIrradianceComponent + (1.0 + inputs.NdotUP ) * ambientSky) * 0.5;
+        vec3 outDiffColor = inputs.albedoLinear * (1.0 - inputs.f0) * indirectDiffuse / PI;
+
+        vec3 mainLightRadianceComponent = normalDistribution(inputs.NdotH, roughnessTerrain) * mainLightIntensity;
+        vec2 dfg = prefilteredDFGAnalytical(roughnessTerrain, inputs.NdotV);
+        vec3 specularColor = inputs.f0 * dfg.x + inputs.f90 * dfg.y;
+        vec3 specularComponent = specularityTerrain * specularColor * mainLightRadianceComponent;
+
+        vec3 outColorLinear = outDiffColor + specularComponent;
+
+        ${u(D,m`
+        vec3 globalIlluminationEmission = 2.25 * (0.75 * inputs.albedoLinear + 0.25) * readGlobalIlluminationEmission().rgb;
+        outColorLinear += globalIlluminationEmission;`)}
+
+        return delinearizeGamma(outColorLinear);
       }
-    `);break;case 5:case 6:o(g),t(g),g.code.add(s`const float roughnessTerrain = 0.5;
-const float specularityTerrain = 0.5;
-const vec3 fresnelReflectionTerrain = vec3(0.04);
-vec3 evaluatePBRSimplifiedLighting(vec3 n, vec3 c, float shadow, float ssao, vec3 al, vec3 vd, vec3 nup) {
-vec3 viewDirection = -vd;
-vec3 h = normalize(viewDirection + mainLightDirection);
-float NdotL = clamp(dot(n, mainLightDirection), 0.001, 1.0);
-float NdotV = clamp(abs(dot(n, viewDirection)), 0.001, 1.0);
-float NdotH = clamp(dot(n, h), 0.0, 1.0);
-float NdotNG = clamp(dot(n, nup), -1.0, 1.0);
-vec3 albedoLinear = linearizeGamma(c);
-float lightness = 0.3 * albedoLinear[0] + 0.5 * albedoLinear[1] + 0.2 * albedoLinear[2];
-vec3 f0 = (0.85 * lightness + 0.15) * fresnelReflectionTerrain;
-vec3 f90 =  vec3(clamp(dot(f0, vec3(50.0 * 0.33)), 0.0, 1.0));
-vec3 mainLightIrradianceComponent = (1. - shadow) * NdotL * mainLightIntensity;
-vec3 ambientLightIrradianceComponent = calculateAmbientIrradiance(n, ssao) + al;
-vec3 ambientSky = ambientLightIrradianceComponent + mainLightIrradianceComponent;
-vec3 indirectDiffuse = ((1.0 - NdotNG) * mainLightIrradianceComponent + (1.0 + NdotNG ) * ambientSky) * 0.5;
-vec3 outDiffColor = albedoLinear * (1.0 - f0) * indirectDiffuse / PI;
-vec3 mainLightRadianceComponent = normalDistribution(NdotH, roughnessTerrain) * mainLightIntensity;
-vec2 dfg = prefilteredDFGAnalytical(roughnessTerrain, NdotV);
-vec3 specularColor = f0 * dfg.x + f90 * dfg.y;
-vec3 specularComponent = specularityTerrain * specularColor * mainLightRadianceComponent;
-vec3 outColorLinear = outDiffColor + specularComponent;
-vec3 outColor = delinearizeGamma(outColorLinear);
-return outColor;
-}`)}}export{v as EvaluateSceneLighting,p as addAmbientBoostFactor,f as addLightingGlobalFactor};
+      `);break}}}export{v as EvaluateSceneLighting,f as addAmbientBoostFactor,b as addLightingGlobalFactor};

package/views/3d/webgl-engine/core/shaderLibrary/shading/PhysicallyBasedRendering.glsl.js

@@ -1,65 +1,89 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
-import{AnalyticalSkyModel as e}from"./AnalyticalSkyModel.glsl.js";import{PiUtils as o}from"./PiUtils.glsl.js";import{glsl as t}from"../../shaderModules/glsl.js";function n(n,a){n.include(o),1!==a.pbrMode&&2!==a.pbrMode&&5!==a.pbrMode&&6!==a.pbrMode||(n.code.add(t`float normalDistribution(float NdotH, float roughness)
+import{AnalyticalSkyModel as e}from"./AnalyticalSkyModel.glsl.js";import{Gamma as o}from"./Gamma.glsl.js";import{PiUtils as t}from"./PiUtils.glsl.js";import{glsl as n}from"../../shaderModules/glsl.js";function a(a,i){a.include(o),a.include(t),1!==i.pbrMode&&2!==i.pbrMode&&5!==i.pbrMode&&6!==i.pbrMode||(a.code.add(n`float normalDistribution(float NdotH, float roughness)
 {
 float a = NdotH * roughness;
 float b = roughness / (1.0 - NdotH * NdotH + a * a);
 return b * b * INV_PI;
-}`),n.code.add(t`const vec4 c0 = vec4(-1.0, -0.0275, -0.572,  0.022);
+}`),a.code.add(n`const vec4 c0 = vec4(-1.0, -0.0275, -0.572,  0.022);
 const vec4 c1 = vec4( 1.0,  0.0425,  1.040, -0.040);
 const vec2 c2 = vec2(-1.04, 1.04);
 vec2 prefilteredDFGAnalytical(float roughness, float NdotV) {
 vec4 r = roughness * c0 + c1;
 float a004 = min(r.x * r.x, exp2(-9.28 * NdotV)) * r.x + r.y;
 return c2 * a004 + r.zw;
-}`)),1!==a.pbrMode&&2!==a.pbrMode||(n.include(e),n.code.add(t`struct PBRShadingInfo
+}`),a.code.add(n`struct PBRShadingInfo
 {
 float NdotV;
+float NdotL;
 float LdotH;
-float NdotNG;
-float RdotNG;
+float NdotUP;
+float RdotUP;
 float NdotAmbDir;
 float NdotH_Horizon;
+float NdotH;
 vec3 skyRadianceToSurface;
 vec3 groundRadianceToSurface;
 vec3 skyIrradianceToSurface;
 vec3 groundIrradianceToSurface;
+vec3 reflectedView;
 float averageAmbientRadiance;
-float ssao;
 vec3 albedoLinear;
 vec3 f0;
 vec3 f90;
 vec3 diffuseColor;
 float metalness;
 float roughness;
-};`),n.code.add(t`vec3 evaluateEnvironmentIllumination(PBRShadingInfo inputs) {
-vec3 indirectDiffuse = evaluateDiffuseIlluminationHemisphere(inputs.groundIrradianceToSurface, inputs.skyIrradianceToSurface, inputs.NdotNG);
-vec3 indirectSpecular = evaluateSpecularIlluminationHemisphere(inputs.groundRadianceToSurface, inputs.skyRadianceToSurface, inputs.RdotNG, inputs.roughness);
+};`),a.code.add(n`void calculateCommonInputs(out PBRShadingInfo inputs, vec3 normal, vec3 viewDirection, vec3 upDirection, vec3 albedo) {
+vec3 h = normalize(mainLightDirection - viewDirection);
+inputs.NdotV = clamp(abs(dot(normal, -viewDirection)), 0.001, 1.0);
+inputs.NdotUP = clamp(dot(normal, upDirection), -1.0, 1.0);
+inputs.reflectedView = normalize(reflect(-viewDirection, normal));
+inputs.RdotUP = clamp(dot(inputs.reflectedView, upDirection), -1.0, 1.0);
+inputs.albedoLinear = linearizeGamma(albedo);
+inputs.NdotH = clamp(dot(normal, h), 0.0, 1.0);
+inputs.NdotL = clamp(dot(normal, mainLightDirection), 0.001, 1.0);
+}`)),1!==i.pbrMode&&2!==i.pbrMode||(a.include(e),a.code.add(n`vec3 evaluateEnvironmentIllumination(PBRShadingInfo inputs) {
+vec3 indirectDiffuse = evaluateDiffuseIlluminationHemisphere(inputs.groundIrradianceToSurface, inputs.skyIrradianceToSurface, inputs.NdotUP);
+vec3 indirectSpecular = evaluateSpecularIlluminationHemisphere(inputs.groundRadianceToSurface, inputs.skyRadianceToSurface, inputs.RdotUP, inputs.roughness);
 vec3 diffuseComponent = inputs.diffuseColor * indirectDiffuse * INV_PI;
 vec2 dfg = prefilteredDFGAnalytical(inputs.roughness, inputs.NdotV);
 vec3 specularColor = inputs.f0 * dfg.x + inputs.f90 * dfg.y;
 vec3 specularComponent = specularColor * indirectSpecular;
 return (diffuseComponent + specularComponent);
-}`))}function a(e,n){e.include(o),e.code.add(t`
+}`),a.code.add(n`void calculatePBRInputs(out PBRShadingInfo inputs, vec3 normal, vec3 viewDirection, vec3 upDirection, vec3 albedo, vec3 mrr) {
+calculateCommonInputs(inputs, normal, viewDirection, upDirection, albedo);
+inputs.metalness = mrr[0];
+inputs.roughness = clamp(mrr[1] * mrr[1], 0.001, 0.99);
+inputs.f0 = (0.16 * mrr[2] * mrr[2]) * (1.0 - inputs.metalness) + inputs.albedoLinear * inputs.metalness;
+inputs.f90 = vec3(clamp(dot(inputs.f0, vec3(50.0 * 0.33)), 0.0, 1.0));
+inputs.diffuseColor = inputs.albedoLinear * (vec3(1.0) - inputs.f0) * (1.0 - inputs.metalness);
+}`)),5!==i.pbrMode&&6!==i.pbrMode||a.code.add(n`const vec3 fresnelReflectionSimplified = vec3(0.04);
+void calculateSimplifiedInputs(out PBRShadingInfo inputs, vec3 normal, vec3 viewDirection, vec3 upDirection, vec3 albedo) {
+calculateCommonInputs(inputs, normal, viewDirection, upDirection, albedo);
+float lightness = 0.3 * inputs.albedoLinear[0] + 0.5 * inputs.albedoLinear[1] + 0.2 * inputs.albedoLinear[2];
+inputs.f0 = (0.85 * lightness + 0.15) * fresnelReflectionSimplified;
+inputs.f90 =  vec3(clamp(dot(inputs.f0, vec3(50.0 * 0.33)), 0.0, 1.0));
+}`)}function i(e,o){e.include(t),e.code.add(n`
     struct PBRShadingWater {
-        float NdotL;   // cos angle between normal and light direction
-        float NdotV;   // cos angle between normal and view direction
-        float NdotH;   // cos angle between normal and half vector
-        float VdotH;   // cos angle between view direction and half vector
-        float LdotH;   // cos angle between light direction and half vector
-        float VdotN;   // cos angle between view direction and normal vector
+      float NdotL;   // cos angle between normal and light direction
+      float NdotV;   // cos angle between normal and view direction
+      float NdotH;   // cos angle between normal and half vector
+      float VdotH;   // cos angle between view direction and half vector
+      float LdotH;   // cos angle between light direction and half vector
+      float VdotN;   // cos angle between view direction and normal vector
     };
 
-    float dtrExponent = ${n.useCustomDTRExponentForWater?"2.2":"2.0"};
-  `),e.code.add(t`vec3 fresnelReflection(float angle, vec3 f0, float f90) {
+    float dtrExponent = ${o.useCustomDTRExponentForWater?"2.2":"2.0"};
+  `),e.code.add(n`vec3 fresnelReflection(float angle, vec3 f0, float f90) {
 return f0 + (f90 - f0) * pow(1.0 - angle, 5.0);
-}`),e.code.add(t`float normalDistributionWater(float NdotH, float roughness) {
+}`),e.code.add(n`float normalDistributionWater(float NdotH, float roughness) {
 float r2 = roughness * roughness;
 float NdotH2 = NdotH * NdotH;
 float denom = pow((NdotH2 * (r2 - 1.0) + 1.0), dtrExponent) * PI;
 return r2 / denom;
-}`),e.code.add(t`float geometricOcclusionKelemen(float LoH) {
+}`),e.code.add(n`float geometricOcclusionKelemen(float LoH) {
 return 0.25 / (LoH * LoH);
-}`),e.code.add(t`vec3 brdfSpecularWater(in PBRShadingWater props, float roughness, vec3 F0, float F0Max) {
+}`),e.code.add(n`vec3 brdfSpecularWater(in PBRShadingWater props, float roughness, vec3 F0, float F0Max) {
 vec3  F = fresnelReflection(props.VdotH, F0, F0Max);
 float dSun = normalDistributionWater(props.NdotH, roughness);
 float V = geometricOcclusionKelemen(props.LdotH);
@@ -67,4 +91,4 @@ float diffusionSunHaze = mix(roughness + 0.045, roughness + 0.385, 1.0 - props.V
 float strengthSunHaze  = 1.2;
 float dSunHaze = normalDistributionWater(props.NdotH, diffusionSunHaze) * strengthSunHaze;
 return ((dSun + dSunHaze) * V) * F;
-}`)}export{n as PhysicallyBasedRendering,a as PhysicallyBasedRenderingWater};
+}`)}export{a as PhysicallyBasedRendering,i as PhysicallyBasedRenderingWater};

package/views/3d/webgl-engine/core/shaderLibrary/shading/ReadGlobalIllumination.glsl.js

@@ -0,0 +1,20 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+import{EncodeEmissionColors as e}from"./EncodingColor.glsl.js";import{glsl as l}from"../../shaderModules/glsl.js";import{Texture2DBindUniform as n}from"../../shaderModules/Texture2DBindUniform.js";import{blurSizePixels as o}from"../../../effects/globalIllumination/GlobalIllumination.js";function i(i,r){r.receiveGlobalIllumination?(i.include(e),i.uniforms.add(new n("globalIlluminationTexture",e=>e.globalIllumination?.getTexture())),i.constants.add("blurSizePixelsInverse","float",1/o),i.code.add(l`vec3 readGlobalIlluminationOcclusionInverse() {
+ivec2 texel = ivec2(gl_FragCoord.xy * blurSizePixelsInverse);
+return vec3(texelFetch(globalIlluminationTexture, texel, 0).a);
+}
+vec3 readGlobalIlluminationOcclusion() {
+return 1.0 - readGlobalIlluminationOcclusionInverse();
+}
+vec4 readGlobalIlluminationEmissionInverse() {
+ivec2 texel = ivec2(gl_FragCoord.xy * blurSizePixelsInverse);
+vec3 encodedEmission = texelFetch(globalIlluminationTexture, texel, 0).rgb;
+vec3 rgb = decodeVec2ToRGB(encodedEmission.rg);
+return 1.0 - vec4(rgb, 0.0);
+}
+vec4 readGlobalIlluminationEmission() {
+return max((1.0 - readGlobalIlluminationEmissionInverse() - 0.01) / 0.99, 0.);
+}`)):i.code.add(l`vec3 readGlobalIlluminationOcclusionInverse() { return vec3(1.0); }
+vec3 readGlobalIlluminationOcclusion() { return vec3(0.0); }
+vec4 readGlobalIlluminationEmissionInverse() { return vec4(1.0); }
+vec4 readGlobalIlluminationEmission() { return vec4(0.0); }`)}export{i as ReadGlobalIllumination};

package/views/3d/webgl-engine/core/shaderLibrary/shading/ReadShadowMap.glsl.js

@@ -1,18 +1,23 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
-import{create as a}from"../../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";import{ForwardLinearDepthToReadShadowMap as o}from"../ForwardLinearDepthToReadShadowMap.glsl.js";import{calculateUVZShadowPass as e,calculateUVZShadowDraw as d,ReadShadowMapOrigin as t}from"./calculateUVZShadow.glsl.js";import{ShadowmapFiltering as r}from"./ShadowmapFiltering.glsl.js";import{BooleanBindUniform as i}from"../../shaderModules/BooleanBindUniform.js";import{FloatBindUniform as s}from"../../shaderModules/FloatBindUniform.js";import{If as l,glsl as n}from"../../shaderModules/glsl.js";import{Texture2DShadowBindUniform as h}from"../../shaderModules/Texture2DShadowBindUniform.js";import{NoParameters as w}from"../../../../../webgl/NoParameters.js";class u extends t{}class c extends w{constructor(){super(...arguments),this.origin=a()}}function p(a,o){o.receiveShadows&&a.include(e),m(a,o)}function f(a,o){o.receiveShadows&&a.include(d),m(a,o)}function m(a,e){a.fragment.uniforms.add(new s("lightingGlobalFactor",a=>a.lighting.globalFactor));const{receiveShadows:d,spherical:t}=e;a.include(o,e),d&&g(a),a.fragment.code.add(n`
+import{create as a}from"../../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";import{ForwardLinearDepthToReadShadowMap as e}from"../ForwardLinearDepthToReadShadowMap.glsl.js";import{calculateUVZShadowPass as o,calculateUVZShadowDraw as r,ReadShadowMapOrigin as t}from"./calculateUVZShadow.glsl.js";import{ShadowmapFiltering as d}from"./ShadowmapFiltering.glsl.js";import{FloatBindUniform as i}from"../../shaderModules/FloatBindUniform.js";import{If as s,glsl as n}from"../../shaderModules/glsl.js";import{Texture2DBindUniform as l}from"../../shaderModules/Texture2DBindUniform.js";import{Texture2DShadowBindUniform as h}from"../../shaderModules/Texture2DShadowBindUniform.js";import{NoParameters as c}from"../../../../../webgl/NoParameters.js";class w extends t{}class u extends c{constructor(){super(...arguments),this.origin=a()}}function g(a,e){e.receiveShadows&&a.include(o),p(a,e)}function m(a,e){e.receiveShadows&&a.include(r),p(a,e)}function p(a,o){a.fragment.uniforms.add(new i("lightingGlobalFactor",a=>a.lighting.globalFactor));const{hasShadowHighlights:r,receiveShadows:t,spherical:d}=o;a.include(e,o),t&&f(a,r),a.fragment.code.add(n`
     float readShadow(float additionalAmbientScale, vec3 vpos) {
-      return ${d?"max(lightingGlobalFactor * (1.0 - additionalAmbientScale), readShadowMap(vpos, linearDepth))":l(t,"lightingGlobalFactor * (1.0 - additionalAmbientScale)","0.0")};
+      return ${t?"max(lightingGlobalFactor * (1.0 - additionalAmbientScale), readShadowMap(vpos, linearDepth))":s(d,"lightingGlobalFactor * (1.0 - additionalAmbientScale)","0.0")};
     }
-  `)}function g(a){a.include(r),S(a),a.fragment.code.add(n`float readShadowMap(const in vec3 _worldPos, float _linearDepth) {
+  `)}function f(a,e){a.include(d),S(a,e),a.fragment.code.add(n`float readShadowMap(const in vec3 _worldPos, float _linearDepth) {
 vec3 uvzShadow = calculateUVZShadow(_worldPos, _linearDepth, textureSize(shadowMap, 0));
 return readShadowMaps(uvzShadow);
-}`)}function S(a){a.include(r),a.fragment.uniforms.add(new i("singleShadowMap",({shadowMap:a})=>!!a.getOutput(5)),new h("shadowMap",({shadowMap:a})=>a.getOutput(5)??a.getOutput(7)),new h("shadowMapHighlight",({shadowMap:a})=>a.getOutput(5)??a.getOutput(6))).code.add(n`float readShadowMaps(const in vec3 uvzShadow) {
-if (uvzShadow.z < 0.0) {
-return 0.0;
-}
-float shadow1 = readShadowMapUVZ(uvzShadow, shadowMap);
-if (singleShadowMap)
-return shadow1;
-float shadow2 = readShadowMapUVZ(uvzShadow, shadowMapHighlight);
-return shadow1 > shadow2 ? shadow1 : shadow2;
-}`)}export{f as ReadShadowMapDraw,u as ReadShadowMapDrawParameters,p as ReadShadowMapPass,c as ReadShadowMapPassParameters,S as readShadowMaps};
+}`)}function S(a,e){a.include(d),a.fragment.uniforms.add(new h("shadowMap",({shadowMap:a})=>a.getOutput(5)??a.getOutput(7))),e&&a.fragment.uniforms.add(new l("screenSpaceShadowHighlight",({screenSpaceShadowHighlightFbo:a})=>a?.getTexture())),a.fragment.code.add(n`
+    float readShadowMaps(const in vec3 uvzShadow) {
+      if (uvzShadow.z < 0.0) {
+        return 0.0;
+      }
+
+      float shadow1 = readShadowMapUVZ(uvzShadow, shadowMap);
+      // screenSpaceShadowHighlight is generated in camera screen space and assumes a
+      ${s(e,n`
+            // matching full-resolution receiver viewport when this helper is used.
+            float shadow2 = texelFetch(screenSpaceShadowHighlight, ivec2(gl_FragCoord.xy), 0).r;
+            return shadow1 > shadow2 ? shadow1 : shadow2;
+          `,n`return shadow1;`)}
+    }
+  `)}export{m as ReadShadowMapDraw,w as ReadShadowMapDrawParameters,g as ReadShadowMapPass,u as ReadShadowMapPassParameters,S as readShadowMaps};

package/views/3d/webgl-engine/core/shaderLibrary/shading/ScreenSpaceReflections.glsl.js

@@ -1,5 +1,5 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
-import{ReadDepth as e}from"../output/ReadDepth.glsl.js";import{Float2BindUniform as t}from"../../shaderModules/Float2BindUniform.js";import{FloatBindUniform as o}from"../../shaderModules/FloatBindUniform.js";import{glsl as r}from"../../shaderModules/glsl.js";import{Matrix4BindUniform as i}from"../../shaderModules/Matrix4BindUniform.js";import{Texture2DBindUniform as a}from"../../shaderModules/Texture2DBindUniform.js";function d(d,n){if(!n.screenSpaceReflections)return;const c=d.fragment;c.include(e),c.uniforms.add(new t("nearFar",e=>e.camera.nearFar),new a("depthMap",e=>e.depth?.attachment),new i("proj",e=>e.camera.projectionMatrix),new o("invResolutionHeight",e=>1/e.camera.height),new i("reprojectionMatrix",e=>e.reprojection.matrix)).code.add(r`
+import{ReadDepth as e}from"../output/ReadDepth.glsl.js";import{Float2BindUniform as t}from"../../shaderModules/Float2BindUniform.js";import{FloatBindUniform as o}from"../../shaderModules/FloatBindUniform.js";import{glsl as r}from"../../shaderModules/glsl.js";import{Matrix4BindUniform as a}from"../../shaderModules/Matrix4BindUniform.js";import{Texture2DBindUniform as i}from"../../shaderModules/Texture2DBindUniform.js";function d(d,n){if(!n.screenSpaceReflections)return;const c=d.fragment;c.include(e),c.uniforms.add(new t("nearFar",e=>e.camera.nearFar),new i("depthMap",e=>e.depth?.attachment),new a("proj",e=>e.camera.projectionMatrix),new o("invResolutionHeight",e=>1/e.camera.height),new a("reprojectionMatrix",e=>e.reprojection.matrix)).code.add(r`
   vec2 reprojectionCoordinate(vec3 projectionCoordinate)
   {
     vec4 zw = proj * vec4(0.0, 0.0, -projectionCoordinate.z, 1.0);
@@ -8,8 +8,6 @@ import{ReadDepth as e}from"../output/ReadDepth.glsl.js";import{Float2BindUniform
     return reprojectedCoord.xy * 0.5 + 0.5;
   }
 
-  const int maxSteps = ${n.highStepCount?"150":"75"};
-
   vec4 applyProjectionMat(mat4 projectionMat, vec3 x)
   {
     vec4 projectedCoord =  projectionMat * vec4(x, 1.0);
@@ -18,7 +16,7 @@ import{ReadDepth as e}from"../output/ReadDepth.glsl.js";import{Float2BindUniform
     return projectedCoord;
   }
 
-  vec3 screenSpaceIntersection(vec3 dir, vec3 startPosition, vec3 viewDir, vec3 normal)
+  vec3 screenSpaceIntersection(vec3 dir, vec3 startPosition, vec3 viewDir, vec3 normal, float offset, bool globalIllumination)
   {
     vec3 viewPos = startPosition;
     vec3 viewPosEnd = startPosition;
@@ -42,18 +40,20 @@ import{ReadDepth as e}from"../output/ReadDepth.glsl.js";import{Float2BindUniform
     vec2 projectedCoordDir = (projectedCoordEnd.xy - projectedCoordStart.xy);
     vec2 projectedCoordDistVanishingPoint = (projectedCoordVanishingPoint.xy - projectedCoordStart.xy);
 
-    float yMod = min(abs(projectedCoordDistVanishingPoint.y), 1.0);
+    float maxReach = globalIllumination ? 0.15 : 1.0;
+    float distMod = min(globalIllumination ? length(projectedCoordDistVanishingPoint.xy) : abs(projectedCoordDistVanishingPoint.y), maxReach);
 
     float projectedCoordDirLength = length(projectedCoordDir);
+    int maxSteps = globalIllumination ? 16 : ${n.highStepCount?"150":"75"};
     float maxSt = float(maxSteps);
 
     // normalize the projection direction depending on maximum steps
     // this determines how blocky the reflection looks
-    vec2 dP = yMod * (projectedCoordDir)/(maxSt * projectedCoordDirLength);
+    vec2 dP = distMod * (projectedCoordDir)/(maxSt * projectedCoordDirLength);
 
     // Normalize the homogeneous camera space coordinates
-    vec3  dQ = yMod * (Q1 - Q0)/(maxSt * projectedCoordDirLength);
-    float dk = yMod * (k1 - k0)/(maxSt * projectedCoordDirLength);
+    vec3  dQ = distMod * (Q1 - Q0)/(maxSt * projectedCoordDirLength);
+    float dk = distMod * (k1 - k0)/(maxSt * projectedCoordDirLength);
 
     // initialize the variables for ray marching
     vec2 P = projectedCoordStart.xy;
@@ -72,6 +72,10 @@ import{ReadDepth as e}from"../output/ReadDepth.glsl.js";import{Float2BindUniform
       return vec3(P, 0.0);
     float dDepthBefore = 0.0;
 
+    P = clamp(P + offset * dP, vec2(0.0), vec2(0.999));
+    Q.z += offset * dQ.z;
+    k += offset * dk;
+
     for(int i = 0; i < maxSteps-1; i++)
     {
       depth = -linearDepthFromTexture(depthMap, P); // get linear depth from the depth buffer
@@ -106,12 +110,22 @@ import{ReadDepth as e}from"../output/ReadDepth.glsl.js";import{Float2BindUniform
         }
       }
 
+      if (globalIllumination && (P.x <= 0.0  || P.x >= 1.0)) {
+        return vec3(P, 0.0);
+      }
+
       // continue with ray marching
-      P = clamp(P + dP, vec2(0.0), vec2(0.999));
+      // Clamp to 0.999 to avoid sampling edge artifacts for water reflections
+      P = P + dP;
       Q.z += dQ.z;
       k += dk;
       rayDiffZOld = rayDiffZ;
       dDepthBefore = dDepth;
+
+      // Clamp to 0.999 to avoid sampling edge artifacts for water reflections
+      if (!globalIllumination) {
+        P = clamp(P, vec2(0.0), vec2(0.999));
+      }
     }
     return vec3(P, 0.0);
   }

package/views/3d/webgl-engine/core/shaderLibrary/shading/WaterColor.glsl.js

@@ -46,7 +46,7 @@ vec3 viewNormal = normalize(viewNormalVectorCoordinate.xyz);
 vec4 viewUp = view * vec4(localUp, 0.0);
 vec3 viewNormalCorrectedSSR = mix(viewUp.xyz, viewNormal, correctionViewingFactor);
 vec3 reflected = normalize(reflect(viewDir, viewNormalCorrectedSSR));
-vec3 hitCoordinate = screenSpaceIntersection(reflected, viewPosition, viewDir, viewUp.xyz);
+vec3 hitCoordinate = screenSpaceIntersection(reflected, viewPosition, viewDir, viewUp.xyz, 0.0, false);
 vec3 reflectedColor = vec3(0.0);
 if (hitCoordinate.z > 0.0)
 {

package/views/3d/webgl-engine/core/shaderLibrary/util/CloudsParallaxShading.glsl.js

@@ -14,7 +14,7 @@ return (rotMat * vec4(inVec, 0.0)).xyz;
 float upDotLight = dot(cameraPosition, mainLightDirection);
 float dirDotLight = max(dot(worldSpaceRay, mainLightDirection), 0.0);
 float sunsetTransition = clamp(pow(max(upDotLight, 0.0), sunsetTransitionFactor), 0.0, 1.0);
-vec3 ambientLight = calculateAmbientIrradiance(cameraPosition,  0.0);
+vec3 ambientLight = calculateAmbientIrradiance(cameraPosition);
 vec3 combinedLight = clamp((mainLightIntensity + ambientLight )/PI, vec3(0.0), vec3(1.0));
 vec3 baseCloudColor = pow(combinedLight * pow(clouds.xyz, vec3(GAMMA)), vec3(INV_GAMMA));
 float scatteringMod = max(clouds.a < 0.5 ? clouds.a / 0.5 : - clouds.a / 0.5 + 2.0, 0.0);

package/views/3d/webgl-engine/effects/RenderPlugin.js

@@ -1,2 +1,2 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
-import e from"../../../../core/Accessor.js";const r={required:[]},t={required:[3]};class s extends e{precompile(e){return!!this.acquireTechniques(e)}get usedMemory(){return 0}get renderOccludedFlags(){return 1}get testsTransparentRenderOrder(){return 0}get isDecoration(){return!1}get readyToRun(){return!1}get numGeometries(){return 0}get hasOccludees(){return!1}get hasEmitters(){return!1}forEachGeometry(e){}}class n extends s{}class u extends s{}export{u as AsyncRenderPlugin,t as ConsumesDepth,r as ConsumesNone,n as SyncRenderPlugin};
+import e from"../../../../core/Accessor.js";const r={required:[]},t={required:[3]};class s extends e{precompile(e){return!!this.acquireTechniques(e)}get usedMemory(){return 0}get renderOccludedFlags(){return 1}get testsTransparentRenderOrder(){return 0}get isDecoration(){return!1}get readyToRun(){return!1}get numGeometries(){return 0}get hasOccludees(){return!1}get hasEmissions(){return 0}forEachGeometry(e){}}class n extends s{}class u extends s{}export{u as AsyncRenderPlugin,t as ConsumesDepth,r as ConsumesNone,n as SyncRenderPlugin};

package/views/3d/webgl-engine/effects/RenderPluginManager.js

@@ -1,2 +1,2 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
-import{removeUnordered as e}from"../../../../core/arrayUtils.js";import"../../../../core/has.js";import{sort as t}from"../../../../core/heapSort.js";import{isPromiseLike as r,createAbortError as s}from"../../../../core/promiseUtils.js";import{signal as n}from"../../../../core/signal.js";import{DepthRange as o}from"../lib/DepthRange.js";class i{constructor(e){this.context=e,this._renderPlugins=new Array,this._slots=new Array,this._version=n(0);for(let t=0;t<21;++t)this._slots[t]=[]}destroy(){this._renderPlugins.forEach(e=>e.destroy()),this._renderPlugins.length=0}get plugins(){return this._renderPlugins}add(e,t){const n=()=>{if(t?.aborted)throw e.uninitializeRenderContext(),s();this._renderPlugins.push(e),e.produces.forEach((t,r)=>this._slots[r].push(e)),this.context.requestRender(),this._version.value++},o=e.initializeRenderContext(this.context,t);if(r(o))return o.then(n);n()}remove(t){e(this._renderPlugins,t),t.uninitializeRenderContext();for(let e=0;e<this._slots.length;++e)this._slots[e]=this._slots[e].filter(e=>e!==t);this.context.requestRender(),this._version.value++}sortTestsTransparentOrderedSlots(e){if("test"!==process.env.NODE_ENV)return;if(this._renderPlugins.some(e=>0!==e.testsTransparentRenderOrder))for(const r of e){const e=this._slots[r];t(e,0,e.length,(e,t)=>(e.testsTransparentRenderOrder??0)-(t.testsTransparentRenderOrder??0))}}prepareRender(){this._renderPlugins.forEach(e=>{e.prepareRender&&e.prepareRender(this.context.renderContext)})}updateAnimation(e){let t=!1;return this._renderPlugins.forEach(r=>t=r.updateAnimation?.(e)||t),t}precompile(...e){++this.context.techniques.precompiling;const t=this.context.renderContext.bind.slot;for(const r of e)this.context.renderContext.bind.slot=r,this._forEachRender(()=>{});this.context.renderContext.bind.slot=t,--this.context.techniques.precompiling}render(...e){for(const t of e)this.context.renderContext.bind.slot=t,this._forEachRender((e,t)=>e.render(this.context.renderContext,t))}_forEachRender(e){const t=this.context.renderContext.bind.slot,r=this.context.renderContext.output;this._slots[t].forEach(s=>{const n=s.produces.get(t);if(!n?.(r)||s.isDecoration&&!this.context.renderContext.bind.decorations)return;const o=s.acquireTechniques(this.context.renderContext);o&&e(s,o)})}queryDepthRange(e){return this._renderPlugins.reduce((t,r)=>t.union(r.queryDepthRange?.(e)),new o)}get updating(){return this._version.value>=0&&this._renderPlugins.some(e=>e.readyToRun)}produces(e,...t){return t.some(t=>this._slots[t].some(r=>{const s=r.produces.get(t);return!!s&&s(e)}))}hasHighlight(e){return h.some(t=>this._slots[t].some(t=>t.hasHighlight(e)))}get hasDecorations(){return this._renderPlugins.some(e=>e.isDecoration)}get hasOccludees(){return this._renderPlugins.some(e=>e.hasOccludees)}get hasEmitters(){return this._renderPlugins.some(e=>e.hasEmitters)}get renderOccludedFlags(){return this._renderPlugins.reduce((e,t)=>e|(t.renderOccludedFlags??0),0)}get usedMemory(){return this._renderPlugins.reduce((e,t)=>t.material?e:e+(t.usedMemory??0),0)}get test(){}}const h=[2,4,19,13,14,15];export{i as RenderPluginManager};
+import{removeUnordered as e}from"../../../../core/arrayUtils.js";import"../../../../core/has.js";import{sort as t}from"../../../../core/heapSort.js";import{isPromiseLike as r,createAbortError as s}from"../../../../core/promiseUtils.js";import{signal as n}from"../../../../core/signal.js";import{someEmissions as o}from"./emissive/emissions.js";import{DepthRange as i}from"../lib/DepthRange.js";class h{constructor(e){this.context=e,this._renderPlugins=new Array,this._slots=new Array,this._version=n(0);for(let t=0;t<21;++t)this._slots[t]=[]}destroy(){this._renderPlugins.forEach(e=>e.destroy()),this._renderPlugins.length=0}get plugins(){return this._renderPlugins}add(e,t){const n=()=>{if(t?.aborted)throw e.uninitializeRenderContext(),s();this._renderPlugins.push(e),e.produces.forEach((t,r)=>this._slots[r].push(e)),this.context.requestRender(),this._version.value++},o=e.initializeRenderContext(this.context,t);if(r(o))return o.then(n);n()}remove(t){e(this._renderPlugins,t),t.uninitializeRenderContext();for(let e=0;e<this._slots.length;++e)this._slots[e]=this._slots[e].filter(e=>e!==t);this.context.requestRender(),this._version.value++}sortTestsTransparentOrderedSlots(e){if("test"!==process.env.NODE_ENV)return;if(this._renderPlugins.some(e=>0!==e.testsTransparentRenderOrder))for(const r of e){const e=this._slots[r];t(e,0,e.length,(e,t)=>(e.testsTransparentRenderOrder??0)-(t.testsTransparentRenderOrder??0))}}prepareRender(){this._renderPlugins.forEach(e=>{e.prepareRender&&e.prepareRender(this.context.renderContext)})}updateAnimation(e){let t=!1;return this._renderPlugins.forEach(r=>t=r.updateAnimation?.(e)||t),t}precompile(...e){++this.context.techniques.precompiling;const t=this.context.renderContext.bind.slot;for(const r of e)this.context.renderContext.bind.slot=r,this._forEachRender(()=>{});this.context.renderContext.bind.slot=t,--this.context.techniques.precompiling}render(...e){for(const t of e)this.context.renderContext.bind.slot=t,this._forEachRender((e,t)=>e.render(this.context.renderContext,t))}_forEachRender(e){const t=this.context.renderContext.bind.slot,r=this.context.renderContext.output;this._slots[t].forEach(s=>{const n=s.produces.get(t);if(!n?.(r)||s.isDecoration&&!this.context.renderContext.bind.decorations)return;const o=s.acquireTechniques(this.context.renderContext);o&&e(s,o)})}queryDepthRange(e){return this._renderPlugins.reduce((t,r)=>t.union(r.queryDepthRange?.(e)),new i)}get updating(){return this._version.value>=0&&this._renderPlugins.some(e=>e.readyToRun)}produces(e,...t){return t.some(t=>this._slots[t].some(r=>{const s=r.produces.get(t);return!!s&&s(e)}))}hasHighlight(e){return d.some(t=>this._slots[t].some(t=>t.hasHighlight(e)))}get hasDecorations(){return this._renderPlugins.some(e=>e.isDecoration)}get hasOccludees(){return this._renderPlugins.some(e=>e.hasOccludees)}get hasEmissions(){return o(this._renderPlugins)}get renderOccludedFlags(){return this._renderPlugins.reduce((e,t)=>e|(t.renderOccludedFlags??0),0)}get usedMemory(){return this._renderPlugins.reduce((e,t)=>t.material?e:e+(t.usedMemory??0),0)}get test(){}}const d=[2,4,19,13,14,15];export{h as RenderPluginManager};

package/views/3d/webgl-engine/effects/emissive/emissions.js

@@ -0,0 +1,2 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+function n(n){let o=0;for(const t of n){const n=t.hasEmissions;if(2===n&&1===o||1===n&&2===o?o=3:0!==n&&0===o&&(o=n),3===o)return o}return o}export{n as someEmissions};