@arcgis/core 5.0.0-next.70 → 5.0.0-next.71

package/views/3d/layers/support/MediaLayerInteractionOptions.d.ts

@@ -2,17 +2,28 @@ import type Accessor from "../../../../core/Accessor.js";
 import type MediaLayerInteractionReshapeOptions from "./MediaLayerInteractionReshapeOptions.js";
 import type { MediaLayerInteractionReshapeOptionsProperties } from "./MediaLayerInteractionReshapeOptions.js";
 
+/** @since 5.0 */
 export interface MediaLayerInteractionOptionsProperties extends Partial<Pick<MediaLayerInteractionOptions, "tool">> {
-  /** Changes the behavior of the `reshape` tool. */
+  /**
+   * Changes the behavior of the `reshape` tool.
+   *
+   * @since 5.0
+   */
   reshapeOptions?: MediaLayerInteractionReshapeOptionsProperties;
 }
 
 /**
  * Options for when the media layer view is interactive in 3D.
  * Configure the interaction tool and reshape behavior for media elements.
+ *
+ * @since 5.0
  */
 export default abstract class MediaLayerInteractionOptions extends Accessor {
-  /** Changes the behavior of the `reshape` tool. */
+  /**
+   * Changes the behavior of the `reshape` tool.
+   *
+   * @since 5.0
+   */
   get reshapeOptions(): MediaLayerInteractionReshapeOptions;
   set reshapeOptions(value: MediaLayerInteractionReshapeOptionsProperties);
   /**
@@ -25,8 +36,10 @@ export default abstract class MediaLayerInteractionOptions extends Accessor {
    * reshape | The four corners of the media element can be moved individually.
    *
    * @default "transform"
+   * @since 5.0
    */
   accessor tool: MediaLayerInteractionTool;
 }
 
+/** @since 5.0 */
 export type MediaLayerInteractionTool = "transform" | "reshape";

package/views/3d/layers/support/MediaLayerInteractionReshapeOptions.d.ts

@@ -1,7 +1,9 @@
 import type Accessor from "../../../../core/Accessor.js";
 
+/** @since 5.0 */
 export interface MediaLayerInteractionReshapeOptionsProperties extends Partial<Pick<MediaLayerInteractionReshapeOptions, "editSourcePoints">> {}
 
+/** @since 5.0 */
 export default abstract class MediaLayerInteractionReshapeOptions extends Accessor {
   /**
    * Indicates if the source point should be edited
@@ -10,6 +12,7 @@ export default abstract class MediaLayerInteractionReshapeOptions extends Access
    * Only supported in 3D.
    *
    * @default false
+   * @since 5.0
    */
   accessor editSourcePoints: boolean;
 }

package/views/3d/types.d.ts

@@ -13,57 +13,109 @@ import type { OGCFeatureLayerView } from "../layers/OGCFeatureLayerView.js";
 import type { PointCloudLayerView } from "../layers/PointCloudLayerView.js";
 import type { StreamLayerView } from "../layers/StreamLayerView.js";
 
+/** @since 5.0 */
 export interface LayerView3DMap {
+  /** @since 5.0 */
   "base-dynamic": never;
+  /** @since 5.0 */
   "base-elevation": never;
+  /** @since 5.0 */
   "base-tile": never;
+  /** @since 5.0 */
   "bing-maps": never;
+  /** @since 5.0 */
   "building-scene": never;
+  /** @since 5.0 */
   catalog: never;
+  /** @since 5.0 */
   "catalog-dynamic-group": never;
+  /** @since 5.0 */
   "catalog-footprint": never;
+  /** @since 5.0 */
   csv: CSVLayerView;
+  /** @since 5.0 */
   dimension: DimensionLayerView;
+  /** @since 5.0 */
   elevation: never;
+  /** @since 5.0 */
   feature: FeatureLayerView;
+  /** @since 5.0 */
   "gaussian-splat": never;
+  /** @since 5.0 */
   "geo-rss": never;
+  /** @since 5.0 */
   geojson: GeoJSONLayerView;
+  /** @since 5.0 */
   graphics: GeoJSONLayerView;
+  /** @since 5.0 */
   group: never;
+  /** @since 5.0 */
   imagery: ImageryLayerView;
+  /** @since 5.0 */
   "imagery-tile": never;
+  /** @since 5.0 */
   "integrated-mesh": never;
+  /** @since 5.0 */
   "integrated-mesh-3dtiles": never;
+  /** @since 5.0 */
   kml: never;
+  /** @since 5.0 */
   "knowledge-graph": never;
+  /** @since 5.0 */
   "knowledge-graph-sublayer": never;
+  /** @since 5.0 */
   "line-of-sight": LineOfSightLayerView;
+  /** @since 5.0 */
   "link-chart": never;
+  /** @since 5.0 */
   "map-image": never;
+  /** @since 5.0 */
   "map-notes": never;
+  /** @since 5.0 */
   media: MediaLayerView;
+  /** @since 5.0 */
   "ogc-feature": OGCFeatureLayerView;
+  /** @since 5.0 */
   "open-street-map": never;
+  /** @since 5.0 */
   "oriented-imagery": never;
+  /** @since 5.0 */
   parquet: never;
+  /** @since 5.0 */
   "point-cloud": PointCloudLayerView;
+  /** @since 5.0 */
   route: never;
+  /** @since 5.0 */
   scene: SceneLayerView;
+  /** @since 5.0 */
   stream: StreamLayerView;
+  /** @since 5.0 */
   "subtype-group": never;
+  /** @since 5.0 */
   tile: never;
+  /** @since 5.0 */
   unknown: never;
+  /** @since 5.0 */
   unsupported: never;
+  /** @since 5.0 */
   "vector-tile": never;
+  /** @since 5.0 */
   video: never;
+  /** @since 5.0 */
   viewshed: ViewshedLayerView;
+  /** @since 5.0 */
   voxel: never;
+  /** @since 5.0 */
   wcs: never;
+  /** @since 5.0 */
   "web-tile": never;
+  /** @since 5.0 */
   wfs: WFSLayerView;
+  /** @since 5.0 */
   wms: never;
+  /** @since 5.0 */
   wmts: never;
 }
 
+/** @since 5.0 */
 export type LayerView3DFor<TLayer extends Layer> = LayerView3DMap[TLayer["type"]];

package/views/3d/webgl/ManagedColorAttachment.d.ts

@@ -3,5 +3,7 @@ import type ManagedFBOAttachment from "./ManagedFBOAttachment.js";
 /**
  * Describes a single attachment of a managed framebuffer. A managed color
  * attachment is also memory managed by the [SceneView](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-SceneView.html).
+ *
+ * @since 5.0
  */
 export default abstract class ManagedColorAttachment extends ManagedFBOAttachment {}

package/views/3d/webgl/ManagedDepthAttachment.d.ts

@@ -3,5 +3,7 @@ import type ManagedFBOAttachment from "./ManagedFBOAttachment.js";
 /**
  * Describes the depth attachment of a managed framebuffer. The depth attachment is memory managed by
  * the [SceneView](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-SceneView.html).
+ *
+ * @since 5.0
  */
 export default abstract class ManagedDepthAttachment extends ManagedFBOAttachment {}

package/views/3d/webgl/ManagedFBO.d.ts

@@ -82,12 +82,16 @@ export default abstract class ManagedFBO extends ManagedFBOResource {
    * Release this managed framebuffer.
    *
    * If more than one reference exists this will not have an effect.
+   *
+   * @since 5.0
    */
   release(): boolean;
   /**
    * Increase reference counting on this managed framebuffer.
    *
    * You can use this functionality to hold framebuffer contents for several frames and then release the framebuffer.
+   *
+   * @since 5.0
    */
   retain(): void;
 }

package/views/3d/webgl/ManagedFBOAttachment.d.ts

@@ -1,3 +1,4 @@
 import type ManagedFBOResource from "./ManagedFBOResource.js";
 
+/** @since 5.0 */
 export default abstract class ManagedFBOAttachment extends ManagedFBOResource {}

package/views/3d/webgl/ManagedFBOResource.d.ts

@@ -1,15 +1,20 @@
 
+/** @since 5.0 */
 export default abstract class ManagedFBOResource {
   /**
    * Release this managed framebuffer into cache again.
    *
    * If more than one reference exists this will not have an effect.
+   *
+   * @since 5.0
    */
   release(): boolean;
   /**
    * Increase reference counting on this managed framebuffer.
    *
    * You can use this functionality to hold framebuffer contents for several frames and then release the framebuffer.
+   *
+   * @since 5.0
    */
   retain(): void;
 }

package/views/3d/webgl/types.d.ts

@@ -1,13 +1,25 @@
 
-/** Tuple of an RGB color value and an intensity value. */
+/**
+ * Tuple of an RGB color value and an intensity value.
+ *
+ * @since 5.0
+ */
 export interface ColorAndIntensity {
-  /** RGB color with values between 0 and 1. */
+  /**
+   * RGB color with values between 0 and 1.
+   *
+   * @since 5.0
+   */
   color: [
       number,
       number,
       number
   ];
-  /** Scalar intensity value by which the color should be scaled for compositing. */
+  /**
+   * Scalar intensity value by which the color should be scaled for compositing.
+   *
+   * @since 5.0
+   */
   intensity: number;
 }
 
@@ -16,13 +28,27 @@ export interface ColorAndIntensity {
  * lighting model. It consists of a directional
  * Lambertian (`diffuse`) and a constant (`ambient`) term, which should be treated in the sense of the
  * [Phong Reflection Model](https://en.wikipedia.org/wiki/Phong_reflection_model).
+ *
+ * @since 5.0
  */
 export interface SunLight {
-  /** The ambient light color and intensity. */
+  /**
+   * The ambient light color and intensity.
+   *
+   * @since 5.0
+   */
   ambient: ColorAndIntensity;
-  /** The diffuse light color and intensity. */
+  /**
+   * The diffuse light color and intensity.
+   *
+   * @since 5.0
+   */
   diffuse: ColorAndIntensity;
-  /** The incident light direction in render coordinates. */
+  /**
+   * The incident light direction in render coordinates.
+   *
+   * @since 5.0
+   */
   direction: [
       number,
       number,

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

@@ -2,31 +2,29 @@
 All material copyright Esri, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/5.0/esri/copyright.txt for details.
 */
-import{colorGamma as i}from"../../../../../../colorUtils.js";import{EvaluateAmbientLighting as n}from"./EvaluateAmbientLighting.glsl.js";import{EvaluateAmbientOcclusion as o}from"./EvaluateAmbientOcclusion.glsl.js";import{addMainLightDirection as e,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{glsl as m,If 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 v(i){i.uniforms.add(new d("lightingGlobalFactor",i=>i.lighting.globalFactor))}function f(g,f){const{pbrMode:L,spherical:b,hasColorTexture:C}=f;g.include(o,f),0!==L&&g.include(r,f),g.include(n,f),g.include(l),g.include(u,f);const N=!(2===L&&!C);switch(N&&g.include(h),g.code.add(m`
-    const float GAMMA_SRGB = ${m.float(i)};
-    const float INV_GAMMA_SRGB = 0.4761904;
-    ${s(0!==L,"const float GROUND_REFLECTANCE = 0.2;")}
-  `),p(g),v(g),e(g),g.code.add(m`
+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`
     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?m`normalize(vPosWorld)`:m`vec3(0.0, 0.0, 1.0)`}, mainLightDirection);
+      float lightAlignment = dot(${b?s`normalize(vPosWorld)`:s`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(m`vec3 evaluateAdditionalLighting(float ambientOcclusion, vec3 vPosWorld) {
+  `),t(g),g.code.add(s`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(m`vec3 evaluateSceneLighting(vec3 normalWorld, vec3 albedo, float shadow, float ssao, vec3 additionalLight) {
+}`),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) {
 vec3 mainLighting = applyShading(normalWorld, shadow);
 vec3 ambientLighting = calculateAmbientIrradiance(normalWorld, ssao);
-vec3 albedoLinear = pow(albedo, vec3(GAMMA_SRGB));
+vec3 albedoLinear = linearizeGamma(albedo);
 vec3 totalLight = mainLighting + ambientLighting + additionalLight;
 totalLight = min(totalLight, vec3(PI));
 vec3 outColor = vec3((albedoLinear / PI) * totalLight);
-return pow(outColor, vec3(INV_GAMMA_SRGB));
-}`);break;case 1:case 2:g.code.add(m`const float fillLightIntensity = 0.25;
+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,
@@ -38,12 +36,12 @@ 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 = pow(albedo, vec3(GAMMA_SRGB));
+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(m`inputs.f0 = (0.16 * mrr[2] * mrr[2]) * (1.0 - inputs.metalness) + inputs.albedoLinear * inputs.metalness;
+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);`),f.useFillLights?g.uniforms.add(new c("hasFillLights",i=>i.enableFillLights)):g.constants.add("hasFillLights","bool",!1),g.code.add(m`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]);
+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);
@@ -51,7 +49,7 @@ 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(m`vec3 horizonRingDir = inputs.RdotNG * groundNormal - reflectedView;
+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);
@@ -61,14 +59,14 @@ vec3 ambientLightRadianceComponent = lightingEnvironmentStrength * calculateAmbi
 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(m`
+inputs.averageAmbientRadiance = ambientLightIrradianceComponent[1] * (1.0 + GROUND_REFLECTANCE);`),g.code.add(s`
         vec3 reflectedColorComponent = evaluateEnvironmentIllumination(inputs);
         vec3 additionalMaterialReflectanceComponent = inputs.albedoLinear * additionalAmbientIrradiance;
         vec3 outColorLinear = reflectedColorComponent + additionalMaterialReflectanceComponent;
-        ${N?m`vec3 outColor = pow(blackLevelSoftCompression(outColorLinear, inputs.averageAmbientRadiance), vec3(INV_GAMMA_SRGB));`:m`vec3 outColor = pow(max(vec3(0.0), outColorLinear - 0.005 * inputs.averageAmbientRadiance), vec3(INV_GAMMA_SRGB));`}
-        return outColor;
+        ${N?s`vec3 outColor = blackLevelSoftCompression(outColorLinear, inputs.averageAmbientRadiance);`:s`vec3 outColor = max(vec3(0.0), outColorLinear - 0.005 * inputs.averageAmbientRadiance);`}
+        return delinearizeGamma(outColor);
       }
-    `);break;case 5:case 6:e(g),t(g),g.code.add(m`const float roughnessTerrain = 0.5;
+    `);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) {
@@ -78,7 +76,7 @@ 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 = pow(c, vec3(GAMMA_SRGB));
+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));
@@ -92,6 +90,6 @@ vec2 dfg = prefilteredDFGAnalytical(roughnessTerrain, NdotV);
 vec3 specularColor = f0 * dfg.x + f90 * dfg.y;
 vec3 specularComponent = specularityTerrain * specularColor * mainLightRadianceComponent;
 vec3 outColorLinear = outDiffColor + specularComponent;
-vec3 outColor = pow(outColorLinear, vec3(INV_GAMMA_SRGB));
+vec3 outColor = delinearizeGamma(outColorLinear);
 return outColor;
-}`)}}export{f as EvaluateSceneLighting,p as addAmbientBoostFactor,v as addLightingGlobalFactor};
+}`)}}export{v as EvaluateSceneLighting,p as addAmbientBoostFactor,f as addLightingGlobalFactor};

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

@@ -2,15 +2,19 @@
 All material copyright Esri, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/5.0/esri/copyright.txt for details.
 */
-import{colorGamma as o}from"../../../../../../colorUtils.js";import{glsl as r}from"../../shaderModules/glsl.js";function e(e){e.code.add(r`
-    const float GAMMA = ${r.float(o)};
-    const float INV_GAMMA = ${r.float(1/o)};
+import{colorGamma as o}from"../../../../../../colorUtils.js";import{glsl as e}from"../../shaderModules/glsl.js";function r(r){r.code.add(e`
+    const float GAMMA = ${e.float(o)};
+    const float INV_GAMMA = ${e.float(1/o)};
+
+    vec3 delinearizeGamma(vec3 color) {
+       return pow(color, vec3(INV_GAMMA));
+    }
 
     vec4 delinearizeGamma(vec4 color) {
-      return vec4(pow(color.rgb, vec3(INV_GAMMA)), color.a);
+      return vec4(delinearizeGamma(color.rgb), color.a);
     }
 
     vec3 linearizeGamma(vec3 color) {
       return pow(color, vec3(GAMMA));
     }
-  `)}export{e as Gamma};
+  `)}export{r as Gamma};

package/views/3d/webgl-engine/core/shaderLibrary/terrain/TerrainTexture.glsl.js

@@ -8,12 +8,14 @@ import{ReadShadowMapPassParameters as e}from"../shading/ReadShadowMap.glsl.js";i
     ${o(p,"nvtc = nextTexOffsetAndScale.xy + uv * nextTexOffsetAndScale.zw;")}
   }`),s.code.add(r`
     vec4 getColor(vec4 color, vec2 uv, vec3 opacities) {
-      ${o(m||g,r`if (opacities.y <= 0.0) {
-           return color * opacities.z * opacities.x;
-         }
-         vec4 bg = vec4(${g?r`backgroundColor`:r`gridColor(uv)`} * opacities.y, opacities.y);
-         vec4 layer = color * opacities.z;
-         return (bg * (1.0 - layer.a) + layer) * opacities.x;`,"return color;")}
+      ${o(m||g,r`
+          if (opacities.y <= 0.0) {
+            return color * opacities.z * opacities.x;
+          }
+          vec4 bg = vec4(${g?r`backgroundColor`:r`gridColor(uv)`} * opacities.y, opacities.y);
+          vec4 layer = color * opacities.z;
+          return (bg * (1.0 - layer.a) + layer) * opacities.x;
+        `,"return color;")}
     }`),p?s.code.add(r`vec4 getTileColor() {
 vec4 color = getColor(texture(tex, vtc), vtc, textureOpacities);
 if (fadeFactor >= 1.0) {

package/views/3d/webgl-engine/shaders/OutputColorHighlightOLID.glsl.js

@@ -2,16 +2,17 @@
 All material copyright Esri, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/5.0/esri/copyright.txt for details.
 */
-import{isColor as o}from"../core/shaderLibrary/ShaderOutput.js";import{Emissions as r}from"../core/shaderLibrary/output/Emissions.glsl.js";import{OutputHighlight as l}from"../core/shaderLibrary/output/OutputHighlight.glsl.js";import{ColorConversion as i}from"../core/shaderLibrary/util/ColorConversion.glsl.js";import{If as s,glsl as a}from"../core/shaderModules/glsl.js";import{alphaCutoff as t}from"../../../../webscene/support/AlphaCutoff.js";function e(e,n){e.include(l,n),e.include(r,n),e.fragment.include(i);const{output:f,oitPass:u,hasEmission:d,discardInvisibleFragments:m,oitPremultipliedAlpha:p,snowCover:c}=n,C=9===f,g=o(f)&&1===u,h=o(f)&&1!==u;let v=0;(h||g)&&e.outputs.add("fragColor","vec4",v++),d&&e.outputs.add("fragEmission","vec4",v++),g&&e.outputs.add("fragAlpha","float",v++),e.fragment.code.add(a`
-    void outputColorHighlightOLID(vec4 finalColor, const in vec3 vWorldPosition, vec3 emissiveSymbolColor ${s(c,", float snow")}) {
-      ${s(C,"finalColor.a = 1.0;")}
-      ${s(m,`if (finalColor.a < ${a.float(t)}) { discard; }`)}
+import{isColor as o}from"../core/shaderLibrary/ShaderOutput.js";import{Emissions as r}from"../core/shaderLibrary/output/Emissions.glsl.js";import{OutputHighlight as l}from"../core/shaderLibrary/output/OutputHighlight.glsl.js";import{ColorConversion as i}from"../core/shaderLibrary/util/ColorConversion.glsl.js";import{If as a,glsl as s}from"../core/shaderModules/glsl.js";import{alphaCutoff as t}from"../../../../webscene/support/AlphaCutoff.js";function e(e,n){e.include(l,n),e.include(r,n),e.fragment.include(i);const{output:f,oitPass:u,hasEmission:d,discardInvisibleFragments:m,oitPremultipliedAlpha:p,snowCover:c}=n,C=9===f,g=o(f)&&1===u,h=o(f)&&2===u,v=o(f)&&1!==u;let b=0;(v||g)&&e.outputs.add("fragColor","vec4",b++),d&&e.outputs.add("fragEmission","vec4",b++),g&&e.outputs.add("fragAlpha","float",b++),e.fragment.code.add(s`
+    void outputColorHighlightOLID(vec4 finalColor, const in vec3 vWorldPosition, vec3 emissiveSymbolColor ${a(c,", float snow")}) {
+      ${a(C,"finalColor.a = 1.0;")}
+      ${a(m,`if (finalColor.a < ${s.float(t)}) { discard; }`)}
       finalColor = applySlice(finalColor, vWorldPosition);
 
-      ${s(g,`${s(p,"fragColor = finalColor;","fragColor = premultiplyAlpha(finalColor);")}\n           fragAlpha = finalColor.a;`)}
-      ${s(h,"fragColor = finalColor;")}
-      ${s(d,`fragEmission = ${s(c,"mix(finalColor.a * getEmissions(emissiveSymbolColor), vec4(0.0), snow);","finalColor.a * getEmissions(emissiveSymbolColor);")}`)}
+      ${a(g,`${a(p,"fragColor = finalColor;","fragColor = premultiplyAlpha(finalColor);")}\n           fragAlpha = finalColor.a;`)}
+      ${a(h&&p&&m,"finalColor.rgb /= finalColor.a;")}
+      ${a(v,"fragColor = finalColor;")}
+      ${a(d,`fragEmission = ${a(c,"mix(finalColor.a * getEmissions(emissiveSymbolColor), vec4(0.0), snow);","finalColor.a * getEmissions(emissiveSymbolColor);")}`)}
       calculateOcclusionAndOutputHighlight();
-      ${s(C,"outputObjectAndLayerIdColor();")}
+      ${a(C,"outputObjectAndLayerIdColor();")}
     }
   `)}export{e as outputColorHighlightOLID};

package/views/MapViewOrSceneView.d.ts

@@ -1,4 +1,5 @@
 import type MapView from "./MapView.js";
 import type SceneView from "./SceneView.js";
 
+/** @since 5.0 */
 export type MapViewOrSceneView = MapView | SceneView;

package/views/SceneView.d.ts

@@ -15,6 +15,7 @@ import type Constraints from "./3d/constraints/Constraints.js";
 import type SceneViewEnvironment from "./3d/environment/SceneViewEnvironment.js";
 import type SceneViewPerformanceInfo from "./3d/support/SceneViewPerformanceInfo.js";
 import type LayerView from "./layers/LayerView.js";
+import type HighlightOptions from "./support/HighlightOptions.js";
 import type { CameraProperties } from "../Camera.js";
 import type { ReadonlyArrayOrCollection } from "../core/Collection.js";
 import type { EventNames } from "../core/Evented.js";
@@ -32,6 +33,7 @@ import type { ExtentProperties } from "../geometry/Extent.js";
 import type { ConstraintsProperties } from "./3d/constraints/Constraints.js";
 import type { SpatialReferenceProperties } from "../geometry/SpatialReference.js";
 import type { ViewpointProperties } from "../Viewpoint.js";
+import type { HighlightOptionsProperties } from "./support/HighlightOptions.js";
 import type { ViewProperties } from "./View.js";
 
 export interface SceneViewProperties extends ViewProperties, DOMContainerProperties, PopupViewProperties, BreakpointsOwnerProperties, Partial<Pick<SceneView, "alphaCompositingEnabled" | "qualityProfile" | "scale" | "zoom">> {
@@ -297,6 +299,34 @@ export interface SceneViewProperties extends ViewProperties, DOMContainerPropert
    * @since 4.19
    */
   floors?: ReadonlyArrayOrCollection<string>;
+  /**
+   * Options for configuring the highlight. Use the highlight method on the
+   * appropriate [LayerView](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-layers-LayerView.html) to highlight a feature.
+   *
+   * Release-specific changes:
+   * * As of 4.32, it is recommended to use the [highlights](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-SceneView.html#highlights) property instead. These two properties should
+   * not be used simultaneously.
+   * * As of 4.19, highlighting a feature influences the shadow of the feature as well. By default, the shadow of the
+   * highlighted feature is displayed in a darker shade.
+   *
+   * @deprecated since version 4.32. Use the [highlights](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-SceneView.html#highlights) property instead.
+   * @since 4.4
+   * @see [FeatureLayerView#highlight()](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-layers-FeatureLayerView.html#highlight)
+   * @see [Sample: Highlight SceneLayer](https://developers.arcgis.com/javascript/latest/sample-code/highlight-scenelayer/)
+   * @example
+   * const view = new SceneView({
+   *   map: map,
+   *   highlightOptions: {
+   *     color: [255, 255, 0, 1],
+   *     haloColor: "white",
+   *     haloOpacity: 0.9,
+   *     fillOpacity: 0.2,
+   *     shadowColor: "black",
+   *     shadowOpacity: 0.5
+   *   }
+   * });
+   */
+  highlightOptions?: HighlightOptionsProperties;
   /**
    * The spatial reference of the view.
    *
@@ -1094,6 +1124,35 @@ export default class SceneView extends SceneViewSuperclass {
    * @since 4.7
    */
   get groundView(): GroundView;
+  /**
+   * Options for configuring the highlight. Use the highlight method on the
+   * appropriate [LayerView](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-layers-LayerView.html) to highlight a feature.
+   *
+   * Release-specific changes:
+   * * As of 4.32, it is recommended to use the [highlights](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-SceneView.html#highlights) property instead. These two properties should
+   * not be used simultaneously.
+   * * As of 4.19, highlighting a feature influences the shadow of the feature as well. By default, the shadow of the
+   * highlighted feature is displayed in a darker shade.
+   *
+   * @deprecated since version 4.32. Use the [highlights](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-SceneView.html#highlights) property instead.
+   * @since 4.4
+   * @see [FeatureLayerView#highlight()](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-layers-FeatureLayerView.html#highlight)
+   * @see [Sample: Highlight SceneLayer](https://developers.arcgis.com/javascript/latest/sample-code/highlight-scenelayer/)
+   * @example
+   * const view = new SceneView({
+   *   map: map,
+   *   highlightOptions: {
+   *     color: [255, 255, 0, 1],
+   *     haloColor: "white",
+   *     haloOpacity: 0.9,
+   *     fillOpacity: 0.2,
+   *     shadowColor: "black",
+   *     shadowOpacity: 0.5
+   *   }
+   * });
+   */
+  get highlightOptions(): HighlightOptions;
+  set highlightOptions(value: HighlightOptionsProperties);
   /**
    * This property contains performance information in a SceneView like global memory usage and additional details for
    * layers about memory consumption and number of features.