1/pi.
+ *
+ * @alias czm_oneOverPi
+ * @glslConstant
+ *
+ * @see CesiumMath.ONE_OVER_PI
+ *
+ * @example
+ * // GLSL declaration
+ * const float czm_oneOverPi = ...;
+ *
+ * // Example
+ * float pi = 1.0 / czm_oneOverPi;
+ */
+const float czm_oneOverPi = 0.3183098861837907;
+`;var vZt=T(S(),1),IL=`/**
+ * A built-in GLSL floating-point constant for 1/2pi.
+ *
+ * @alias czm_oneOverTwoPi
+ * @glslConstant
+ *
+ * @see CesiumMath.ONE_OVER_TWO_PI
+ *
+ * @example
+ * // GLSL declaration
+ * const float czm_oneOverTwoPi = ...;
+ *
+ * // Example
+ * float pi = 2.0 * czm_oneOverTwoPi;
+ */
+const float czm_oneOverTwoPi = 0.15915494309189535;
+`;var wZt=T(S(),1),WL=`/**
+ * The automatic GLSL constant for {@link Pass#CESIUM_3D_TILE}
+ *
+ * @name czm_passCesium3DTile
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passCesium3DTile = 4.0;
+`;var MZt=T(S(),1),PL=`/**
+ * The automatic GLSL constant for {@link Pass#CESIUM_3D_TILE_CLASSIFICATION}
+ *
+ * @name czm_passCesium3DTileClassification
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passCesium3DTileClassification = 5.0;
+`;var UZt=T(S(),1),vL=`/**
+ * The automatic GLSL constant for {@link Pass#CESIUM_3D_TILE_CLASSIFICATION_IGNORE_SHOW}
+ *
+ * @name czm_passCesium3DTileClassificationIgnoreShow
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passCesium3DTileClassificationIgnoreShow = 6.0;
+`;var DZt=T(S(),1),FL=`/**
+ * The automatic GLSL constant for {@link Pass#CLASSIFICATION}
+ *
+ * @name czm_passClassification
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passClassification = 7.0;
+`;var YZt=T(S(),1),wL=`/**
+ * The automatic GLSL constant for {@link Pass#COMPUTE}
+ *
+ * @name czm_passCompute
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passCompute = 1.0;
+`;var KZt=T(S(),1),AL=`/**
+ * The automatic GLSL constant for {@link Pass#ENVIRONMENT}
+ *
+ * @name czm_passEnvironment
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passEnvironment = 0.0;
+`;var zZt=T(S(),1),ML=`/**
+ * The automatic GLSL constant for {@link Pass#GLOBE}
+ *
+ * @name czm_passGlobe
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passGlobe = 2.0;
+`;var QZt=T(S(),1),NL=`/**
+ * The automatic GLSL constant for {@link Pass#OPAQUE}
+ *
+ * @name czm_passOpaque
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passOpaque = 7.0;
+`;var qZt=T(S(),1),UL=`/**
+ * The automatic GLSL constant for {@link Pass#OVERLAY}
+ *
+ * @name czm_passOverlay
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passOverlay = 10.0;
+`;var eGt=T(S(),1),kL=`/**
+ * The automatic GLSL constant for {@link Pass#TERRAIN_CLASSIFICATION}
+ *
+ * @name czm_passTerrainClassification
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passTerrainClassification = 3.0;
+`;var nGt=T(S(),1),DL=`/**
+ * The automatic GLSL constant for {@link Pass#TRANSLUCENT}
+ *
+ * @name czm_passTranslucent
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passTranslucent = 8.0;
+`;var oGt=T(S(),1),BL=`/**
+ * The automatic GLSL constant for {@link Pass#VOXELS}
+ *
+ * @name czm_passVoxels
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passVoxels = 9.0;
+`;var sGt=T(S(),1),YL=`/**
+ * A built-in GLSL floating-point constant for Math.PI.
+ *
+ * @alias czm_pi
+ * @glslConstant
+ *
+ * @see CesiumMath.PI
+ *
+ * @example
+ * // GLSL declaration
+ * const float czm_pi = ...;
+ *
+ * // Example
+ * float twoPi = 2.0 * czm_pi;
+ */
+const float czm_pi = 3.141592653589793;
+`;var cGt=T(S(),1),OL=`/**
+ * A built-in GLSL floating-point constant for pi/4.
+ *
+ * @alias czm_piOverFour
+ * @glslConstant
+ *
+ * @see CesiumMath.PI_OVER_FOUR
+ *
+ * @example
+ * // GLSL declaration
+ * const float czm_piOverFour = ...;
+ *
+ * // Example
+ * float pi = 4.0 * czm_piOverFour;
+ */
+const float czm_piOverFour = 0.7853981633974483;
+`;var dGt=T(S(),1),KL=`/**
+ * A built-in GLSL floating-point constant for pi/6.
+ *
+ * @alias czm_piOverSix
+ * @glslConstant
+ *
+ * @see CesiumMath.PI_OVER_SIX
+ *
+ * @example
+ * // GLSL declaration
+ * const float czm_piOverSix = ...;
+ *
+ * // Example
+ * float pi = 6.0 * czm_piOverSix;
+ */
+const float czm_piOverSix = 0.5235987755982988;
+`;var mGt=T(S(),1),HL=`/**
+ * A built-in GLSL floating-point constant for pi/3.
+ *
+ * @alias czm_piOverThree
+ * @glslConstant
+ *
+ * @see CesiumMath.PI_OVER_THREE
+ *
+ * @example
+ * // GLSL declaration
+ * const float czm_piOverThree = ...;
+ *
+ * // Example
+ * float pi = 3.0 * czm_piOverThree;
+ */
+const float czm_piOverThree = 1.0471975511965976;
+`;var fGt=T(S(),1),zL=`/**
+ * A built-in GLSL floating-point constant for pi/2.
+ *
+ * @alias czm_piOverTwo
+ * @glslConstant
+ *
+ * @see CesiumMath.PI_OVER_TWO
+ *
+ * @example
+ * // GLSL declaration
+ * const float czm_piOverTwo = ...;
+ *
+ * // Example
+ * float pi = 2.0 * czm_piOverTwo;
+ */
+const float czm_piOverTwo = 1.5707963267948966;
+`;var bGt=T(S(),1),JL=`/**
+ * A built-in GLSL floating-point constant for converting degrees to radians.
+ *
+ * @alias czm_radiansPerDegree
+ * @glslConstant
+ *
+ * @see CesiumMath.RADIANS_PER_DEGREE
+ *
+ * @example
+ * // GLSL declaration
+ * const float czm_radiansPerDegree = ...;
+ *
+ * // Example
+ * float rad = czm_radiansPerDegree * deg;
+ */
+const float czm_radiansPerDegree = 0.017453292519943295;
+`;var gGt=T(S(),1),QL=`/**
+ * The constant identifier for the 2D {@link SceneMode}
+ *
+ * @name czm_sceneMode2D
+ * @glslConstant
+ * @see czm_sceneMode
+ * @see czm_sceneModeColumbusView
+ * @see czm_sceneMode3D
+ * @see czm_sceneModeMorphing
+ */
+const float czm_sceneMode2D = 2.0;
+`;var _Gt=T(S(),1),jL=`/**
+ * The constant identifier for the 3D {@link SceneMode}
+ *
+ * @name czm_sceneMode3D
+ * @glslConstant
+ * @see czm_sceneMode
+ * @see czm_sceneMode2D
+ * @see czm_sceneModeColumbusView
+ * @see czm_sceneModeMorphing
+ */
+const float czm_sceneMode3D = 3.0;
+`;var SGt=T(S(),1),qL=`/**
+ * The constant identifier for the Columbus View {@link SceneMode}
+ *
+ * @name czm_sceneModeColumbusView
+ * @glslConstant
+ * @see czm_sceneMode
+ * @see czm_sceneMode2D
+ * @see czm_sceneMode3D
+ * @see czm_sceneModeMorphing
+ */
+const float czm_sceneModeColumbusView = 1.0;
+`;var VGt=T(S(),1),$L=`/**
+ * The constant identifier for the Morphing {@link SceneMode}
+ *
+ * @name czm_sceneModeMorphing
+ * @glslConstant
+ * @see czm_sceneMode
+ * @see czm_sceneMode2D
+ * @see czm_sceneModeColumbusView
+ * @see czm_sceneMode3D
+ */
+const float czm_sceneModeMorphing = 0.0;
+`;var RGt=T(S(),1),eR=`/**
+ * A built-in GLSL floating-point constant for one solar radius.
+ *
+ * @alias czm_solarRadius
+ * @glslConstant
+ *
+ * @see CesiumMath.SOLAR_RADIUS
+ *
+ * @example
+ * // GLSL declaration
+ * const float czm_solarRadius = ...;
+ */
+const float czm_solarRadius = 695500000.0;
+`;var GGt=T(S(),1),tR=`/**
+ * A built-in GLSL floating-point constant for 3pi/2.
+ *
+ * @alias czm_threePiOver2
+ * @glslConstant
+ *
+ * @see CesiumMath.THREE_PI_OVER_TWO
+ *
+ * @example
+ * // GLSL declaration
+ * const float czm_threePiOver2 = ...;
+ *
+ * // Example
+ * float pi = (2.0 / 3.0) * czm_threePiOver2;
+ */
+const float czm_threePiOver2 = 4.71238898038469;
+`;var XGt=T(S(),1),nR=`/**
+ * A built-in GLSL floating-point constant for 2pi.
+ *
+ * @alias czm_twoPi
+ * @glslConstant
+ *
+ * @see CesiumMath.TWO_PI
+ *
+ * @example
+ * // GLSL declaration
+ * const float czm_twoPi = ...;
+ *
+ * // Example
+ * float pi = czm_twoPi / 2.0;
+ */
+const float czm_twoPi = 6.283185307179586;
+`;var WGt=T(S(),1),iR=`/**
+ * The maximum latitude, in radians, both North and South, supported by a Web Mercator
+ * (EPSG:3857) projection. Technically, the Mercator projection is defined
+ * for any latitude up to (but not including) 90 degrees, but it makes sense
+ * to cut it off sooner because it grows exponentially with increasing latitude.
+ * The logic behind this particular cutoff value, which is the one used by
+ * Google Maps, Bing Maps, and Esri, is that it makes the projection
+ * square. That is, the rectangle is equal in the X and Y directions.
+ *
+ * The constant value is computed as follows:
+ * czm_pi * 0.5 - (2.0 * atan(exp(-czm_pi)))
+ *
+ * @name czm_webMercatorMaxLatitude
+ * @glslConstant
+ */
+const float czm_webMercatorMaxLatitude = 1.4844222297453324;
+`;var vGt=T(S(),1),oR=`/**
+ * @name czm_depthRangeStruct
+ * @glslStruct
+ */
+struct czm_depthRangeStruct
+{
+ float near;
+ float far;
+};
+`;var wGt=T(S(),1),rR=`/**
+ * Holds material information that can be used for lighting. Returned by all czm_getMaterial functions.
+ *
+ * @name czm_material
+ * @glslStruct
+ *
+ * @property {vec3} diffuse Incoming light that scatters evenly in all directions.
+ * @property {float} specular Intensity of incoming light reflecting in a single direction.
+ * @property {float} shininess The sharpness of the specular reflection. Higher values create a smaller, more focused specular highlight.
+ * @property {vec3} normal Surface's normal in eye coordinates. It is used for effects such as normal mapping. The default is the surface's unmodified normal.
+ * @property {vec3} emission Light emitted by the material equally in all directions. The default is vec3(0.0), which emits no light.
+ * @property {float} alpha Alpha of this material. 0.0 is completely transparent; 1.0 is completely opaque.
+ */
+struct czm_material
+{
+ vec3 diffuse;
+ float specular;
+ float shininess;
+ vec3 normal;
+ vec3 emission;
+ float alpha;
+};
+`;var MGt=T(S(),1),sR=`/**
+ * Used as input to every material's czm_getMaterial function.
+ *
+ * @name czm_materialInput
+ * @glslStruct
+ *
+ * @property {float} s 1D texture coordinates.
+ * @property {vec2} st 2D texture coordinates.
+ * @property {vec3} str 3D texture coordinates.
+ * @property {vec3} normalEC Unperturbed surface normal in eye coordinates.
+ * @property {mat3} tangentToEyeMatrix Matrix for converting a tangent space normal to eye space.
+ * @property {vec3} positionToEyeEC Vector from the fragment to the eye in eye coordinates. The magnitude is the distance in meters from the fragment to the eye.
+ * @property {float} height The height of the terrain in meters above or below the WGS84 ellipsoid. Only available for globe materials.
+ * @property {float} slope The slope of the terrain in radians. 0 is flat; pi/2 is vertical. Only available for globe materials.
+ * @property {float} aspect The aspect of the terrain in radians. 0 is East, pi/2 is North, pi is West, 3pi/2 is South. Only available for globe materials.
+ */
+struct czm_materialInput
+{
+ float s;
+ vec2 st;
+ vec3 str;
+ vec3 normalEC;
+ mat3 tangentToEyeMatrix;
+ vec3 positionToEyeEC;
+ float height;
+ float slope;
+ float aspect;
+};
+`;var UGt=T(S(),1),aR=`/**
+ * Struct for representing a material for a {@link Model}. The model
+ * rendering pipeline will pass this struct between material, custom shaders,
+ * and lighting stages. This is not to be confused with {@link czm_material}
+ * which is used by the older Fabric materials system, although they are similar.
+ *
+ * All color values (diffuse, specular, emissive) are in linear color space.
+ *
+ *
+ * @name czm_modelMaterial
+ * @glslStruct
+ *
+ * @property {vec3} diffuse Incoming light that scatters evenly in all directions.
+ * @property {float} alpha Alpha of this material. 0.0 is completely transparent; 1.0 is completely opaque.
+ * @property {vec3} specular Color of reflected light at normal incidence in PBR materials. This is sometimes referred to as f0 in the literature.
+ * @property {float} roughness A number from 0.0 to 1.0 representing how rough the surface is. Values near 0.0 produce glossy surfaces, while values near 1.0 produce rough surfaces.
+ * @property {vec3} normalEC Surface's normal in eye coordinates. It is used for effects such as normal mapping. The default is the surface's unmodified normal.
+ * @property {float} occlusion Ambient occlusion recieved at this point on the material. 1.0 means fully lit, 0.0 means fully occluded.
+ * @property {vec3} emissive Light emitted by the material equally in all directions. The default is vec3(0.0), which emits no light.
+ */
+struct czm_modelMaterial {
+ vec3 diffuse;
+ float alpha;
+ vec3 specular;
+ float roughness;
+ vec3 normalEC;
+ float occlusion;
+ vec3 emissive;
+};
+`;var DGt=T(S(),1),cR=`/**
+ * Struct for representing the output of a custom vertex shader.
+ *
+ * @name czm_modelVertexOutput
+ * @glslStruct
+ *
+ * @see {@link CustomShader}
+ * @see {@link Model}
+ *
+ * @property {vec3} positionMC The position of the vertex in model coordinates
+ * @property {float} pointSize A custom value for gl_PointSize. This is only used for point primitives.
+ */
+struct czm_modelVertexOutput {
+ vec3 positionMC;
+ float pointSize;
+};
+`;var YGt=T(S(),1),lR=`/**
+ * Parameters for {@link czm_pbrLighting}
+ *
+ * @name czm_material
+ * @glslStruct
+ *
+ * @property {vec3} diffuseColor the diffuse color of the material for the lambert term of the rendering equation
+ * @property {float} roughness a value from 0.0 to 1.0 that indicates how rough the surface of the material is.
+ * @property {vec3} f0 The reflectance of the material at normal incidence
+ */
+struct czm_pbrParameters
+{
+ vec3 diffuseColor;
+ float roughness;
+ vec3 f0;
+};
+`;var KGt=T(S(),1),dR=`/**
+ * DOC_TBA
+ *
+ * @name czm_ray
+ * @glslStruct
+ */
+struct czm_ray
+{
+ vec3 origin;
+ vec3 direction;
+};
+`;var zGt=T(S(),1),uR=`/**
+ * DOC_TBA
+ *
+ * @name czm_raySegment
+ * @glslStruct
+ */
+struct czm_raySegment
+{
+ float start;
+ float stop;
+};
+
+/**
+ * DOC_TBA
+ *
+ * @name czm_emptyRaySegment
+ * @glslConstant
+ */
+const czm_raySegment czm_emptyRaySegment = czm_raySegment(-czm_infinity, -czm_infinity);
+
+/**
+ * DOC_TBA
+ *
+ * @name czm_fullRaySegment
+ * @glslConstant
+ */
+const czm_raySegment czm_fullRaySegment = czm_raySegment(0.0, czm_infinity);
+`;var QGt=T(S(),1),mR=`struct czm_shadowParameters
+{
+#ifdef USE_CUBE_MAP_SHADOW
+ vec3 texCoords;
+#else
+ vec2 texCoords;
+#endif
+
+ float depthBias;
+ float depth;
+ float nDotL;
+ vec2 texelStepSize;
+ float normalShadingSmooth;
+ float darkness;
+};
+`;var qGt=T(S(),1),hR=`/**
+ * Converts an HSB color (hue, saturation, brightness) to RGB
+ * HSB <-> RGB conversion with minimal branching: {@link http://lolengine.net/blog/2013/07/27/rgb-to-hsv-in-glsl}
+ *
+ * @name czm_HSBToRGB
+ * @glslFunction
+ *
+ * @param {vec3} hsb The color in HSB.
+ *
+ * @returns {vec3} The color in RGB.
+ *
+ * @example
+ * vec3 hsb = czm_RGBToHSB(rgb);
+ * hsb.z *= 0.1;
+ * rgb = czm_HSBToRGB(hsb);
+ */
+
+const vec4 K_HSB2RGB = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+
+vec3 czm_HSBToRGB(vec3 hsb)
+{
+ vec3 p = abs(fract(hsb.xxx + K_HSB2RGB.xyz) * 6.0 - K_HSB2RGB.www);
+ return hsb.z * mix(K_HSB2RGB.xxx, clamp(p - K_HSB2RGB.xxx, 0.0, 1.0), hsb.y);
+}
+`;var eEt=T(S(),1),fR=`/**
+ * Converts an HSL color (hue, saturation, lightness) to RGB
+ * HSL <-> RGB conversion: {@link http://www.chilliant.com/rgb2hsv.html}
+ *
+ * @name czm_HSLToRGB
+ * @glslFunction
+ *
+ * @param {vec3} rgb The color in HSL.
+ *
+ * @returns {vec3} The color in RGB.
+ *
+ * @example
+ * vec3 hsl = czm_RGBToHSL(rgb);
+ * hsl.z *= 0.1;
+ * rgb = czm_HSLToRGB(hsl);
+ */
+
+vec3 hueToRGB(float hue)
+{
+ float r = abs(hue * 6.0 - 3.0) - 1.0;
+ float g = 2.0 - abs(hue * 6.0 - 2.0);
+ float b = 2.0 - abs(hue * 6.0 - 4.0);
+ return clamp(vec3(r, g, b), 0.0, 1.0);
+}
+
+vec3 czm_HSLToRGB(vec3 hsl)
+{
+ vec3 rgb = hueToRGB(hsl.x);
+ float c = (1.0 - abs(2.0 * hsl.z - 1.0)) * hsl.y;
+ return (rgb - 0.5) * c + hsl.z;
+}
+`;var nEt=T(S(),1),pR=`/**
+ * Converts an RGB color to HSB (hue, saturation, brightness)
+ * HSB <-> RGB conversion with minimal branching: {@link http://lolengine.net/blog/2013/07/27/rgb-to-hsv-in-glsl}
+ *
+ * @name czm_RGBToHSB
+ * @glslFunction
+ *
+ * @param {vec3} rgb The color in RGB.
+ *
+ * @returns {vec3} The color in HSB.
+ *
+ * @example
+ * vec3 hsb = czm_RGBToHSB(rgb);
+ * hsb.z *= 0.1;
+ * rgb = czm_HSBToRGB(hsb);
+ */
+
+const vec4 K_RGB2HSB = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
+
+vec3 czm_RGBToHSB(vec3 rgb)
+{
+ vec4 p = mix(vec4(rgb.bg, K_RGB2HSB.wz), vec4(rgb.gb, K_RGB2HSB.xy), step(rgb.b, rgb.g));
+ vec4 q = mix(vec4(p.xyw, rgb.r), vec4(rgb.r, p.yzx), step(p.x, rgb.r));
+
+ float d = q.x - min(q.w, q.y);
+ return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + czm_epsilon7)), d / (q.x + czm_epsilon7), q.x);
+}
+`;var oEt=T(S(),1),bR=`/**
+ * Converts an RGB color to HSL (hue, saturation, lightness)
+ * HSL <-> RGB conversion: {@link http://www.chilliant.com/rgb2hsv.html}
+ *
+ * @name czm_RGBToHSL
+ * @glslFunction
+ *
+ * @param {vec3} rgb The color in RGB.
+ *
+ * @returns {vec3} The color in HSL.
+ *
+ * @example
+ * vec3 hsl = czm_RGBToHSL(rgb);
+ * hsl.z *= 0.1;
+ * rgb = czm_HSLToRGB(hsl);
+ */
+
+vec3 RGBtoHCV(vec3 rgb)
+{
+ // Based on work by Sam Hocevar and Emil Persson
+ vec4 p = (rgb.g < rgb.b) ? vec4(rgb.bg, -1.0, 2.0 / 3.0) : vec4(rgb.gb, 0.0, -1.0 / 3.0);
+ vec4 q = (rgb.r < p.x) ? vec4(p.xyw, rgb.r) : vec4(rgb.r, p.yzx);
+ float c = q.x - min(q.w, q.y);
+ float h = abs((q.w - q.y) / (6.0 * c + czm_epsilon7) + q.z);
+ return vec3(h, c, q.x);
+}
+
+vec3 czm_RGBToHSL(vec3 rgb)
+{
+ vec3 hcv = RGBtoHCV(rgb);
+ float l = hcv.z - hcv.y * 0.5;
+ float s = hcv.y / (1.0 - abs(l * 2.0 - 1.0) + czm_epsilon7);
+ return vec3(hcv.x, s, l);
+}
+`;var sEt=T(S(),1),yR=`/**
+ * Converts an RGB color to CIE Yxy.
+ * The conversion is described in
+ * {@link http://content.gpwiki.org/index.php/D3DBook:High-Dynamic_Range_Rendering#Luminance_Transform|Luminance Transform}
+ *
+ *
+ * @name czm_RGBToXYZ
+ * @glslFunction
+ *
+ * @param {vec3} rgb The color in RGB.
+ *
+ * @returns {vec3} The color in CIE Yxy.
+ *
+ * @example
+ * vec3 xyz = czm_RGBToXYZ(rgb);
+ * xyz.x = max(xyz.x - luminanceThreshold, 0.0);
+ * rgb = czm_XYZToRGB(xyz);
+ */
+vec3 czm_RGBToXYZ(vec3 rgb)
+{
+ const mat3 RGB2XYZ = mat3(0.4124, 0.2126, 0.0193,
+ 0.3576, 0.7152, 0.1192,
+ 0.1805, 0.0722, 0.9505);
+ vec3 xyz = RGB2XYZ * rgb;
+ vec3 Yxy;
+ Yxy.r = xyz.g;
+ float temp = dot(vec3(1.0), xyz);
+ Yxy.gb = xyz.rg / temp;
+ return Yxy;
+}
+`;var cEt=T(S(),1),gR=`/**
+ * Converts a CIE Yxy color to RGB.
+ * The conversion is described in
+ * {@link http://content.gpwiki.org/index.php/D3DBook:High-Dynamic_Range_Rendering#Luminance_Transform|Luminance Transform}
+ *
+ *
+ * @name czm_XYZToRGB
+ * @glslFunction
+ *
+ * @param {vec3} Yxy The color in CIE Yxy.
+ *
+ * @returns {vec3} The color in RGB.
+ *
+ * @example
+ * vec3 xyz = czm_RGBToXYZ(rgb);
+ * xyz.x = max(xyz.x - luminanceThreshold, 0.0);
+ * rgb = czm_XYZToRGB(xyz);
+ */
+vec3 czm_XYZToRGB(vec3 Yxy)
+{
+ const mat3 XYZ2RGB = mat3( 3.2405, -0.9693, 0.0556,
+ -1.5371, 1.8760, -0.2040,
+ -0.4985, 0.0416, 1.0572);
+ vec3 xyz;
+ xyz.r = Yxy.r * Yxy.g / Yxy.b;
+ xyz.g = Yxy.r;
+ xyz.b = Yxy.r * (1.0 - Yxy.g - Yxy.b) / Yxy.b;
+
+ return XYZ2RGB * xyz;
+}
+`;var dEt=T(S(),1),xR=`// See:
+// https://knarkowicz.wordpress.com/2016/01/06/aces-filmic-tone-mapping-curve/
+
+vec3 czm_acesTonemapping(vec3 color) {
+ float g = 0.985;
+ float a = 0.065;
+ float b = 0.0001;
+ float c = 0.433;
+ float d = 0.238;
+
+ color = (color * (color + a) - b) / (color * (g * color + c) + d);
+
+ color = clamp(color, 0.0, 1.0);
+
+ return color;
+}
+`;var mEt=T(S(),1),_R=`/**
+ * @private
+ */
+float czm_alphaWeight(float a)
+{
+ float z = (gl_FragCoord.z - czm_viewportTransformation[3][2]) / czm_viewportTransformation[2][2];
+
+ // See Weighted Blended Order-Independent Transparency for examples of different weighting functions:
+ // http://jcgt.org/published/0002/02/09/
+ return pow(a + 0.01, 4.0) + max(1e-2, min(3.0 * 1e3, 0.003 / (1e-5 + pow(abs(z) / 200.0, 4.0))));
+}
+`;var fEt=T(S(),1),TR=`/**
+ * Procedural anti-aliasing by blurring two colors that meet at a sharp edge.
+ *
+ * @name czm_antialias
+ * @glslFunction
+ *
+ * @param {vec4} color1 The color on one side of the edge.
+ * @param {vec4} color2 The color on the other side of the edge.
+ * @param {vec4} currentcolor The current color, either color1 or color2.
+ * @param {float} dist The distance to the edge in texture coordinates.
+ * @param {float} [fuzzFactor=0.1] Controls the blurriness between the two colors.
+ * @returns {vec4} The anti-aliased color.
+ *
+ * @example
+ * // GLSL declarations
+ * vec4 czm_antialias(vec4 color1, vec4 color2, vec4 currentColor, float dist, float fuzzFactor);
+ * vec4 czm_antialias(vec4 color1, vec4 color2, vec4 currentColor, float dist);
+ *
+ * // get the color for a material that has a sharp edge at the line y = 0.5 in texture space
+ * float dist = abs(textureCoordinates.t - 0.5);
+ * vec4 currentColor = mix(bottomColor, topColor, step(0.5, textureCoordinates.t));
+ * vec4 color = czm_antialias(bottomColor, topColor, currentColor, dist, 0.1);
+ */
+vec4 czm_antialias(vec4 color1, vec4 color2, vec4 currentColor, float dist, float fuzzFactor)
+{
+ float val1 = clamp(dist / fuzzFactor, 0.0, 1.0);
+ float val2 = clamp((dist - 0.5) / fuzzFactor, 0.0, 1.0);
+ val1 = val1 * (1.0 - val2);
+ val1 = val1 * val1 * (3.0 - (2.0 * val1));
+ val1 = pow(val1, 0.5); //makes the transition nicer
+
+ vec4 midColor = (color1 + color2) * 0.5;
+ return mix(midColor, currentColor, val1);
+}
+
+vec4 czm_antialias(vec4 color1, vec4 color2, vec4 currentColor, float dist)
+{
+ return czm_antialias(color1, color2, currentColor, dist, 0.1);
+}
+`;var bEt=T(S(),1),SR=`/**
+ * Approximately computes spherical coordinates given a normal.
+ * Uses approximate inverse trigonometry for speed and consistency,
+ * since inverse trigonometry can differ from vendor-to-vendor and when compared with the CPU.
+ *
+ * @name czm_approximateSphericalCoordinates
+ * @glslFunction
+ *
+ * @param {vec3} normal arbitrary-length normal.
+ *
+ * @returns {vec2} Approximate latitude and longitude spherical coordinates.
+ */
+vec2 czm_approximateSphericalCoordinates(vec3 normal) {
+ // Project into plane with vertical for latitude
+ float latitudeApproximation = czm_fastApproximateAtan(sqrt(normal.x * normal.x + normal.y * normal.y), normal.z);
+ float longitudeApproximation = czm_fastApproximateAtan(normal.x, normal.y);
+ return vec2(latitudeApproximation, longitudeApproximation);
+}
+`;var gEt=T(S(),1),CR=`/**
+ * Determines if the fragment is back facing
+ *
+ * @name czm_backFacing
+ * @glslFunction
+ *
+ * @returns {bool} true if the fragment is back facing; otherwise, false.
+ */
+bool czm_backFacing()
+{
+ // !gl_FrontFacing doesn't work as expected on Mac/Intel so use the more verbose form instead. See https://github.com/CesiumGS/cesium/pull/8494.
+ return gl_FrontFacing == false;
+}
+`;var _Et=T(S(),1),VR=`/**
+ * Branchless ternary operator to be used when it's inexpensive to explicitly
+ * evaluate both possibilities for a float expression.
+ *
+ * @name czm_branchFreeTernary
+ * @glslFunction
+ *
+ * @param {bool} comparison A comparison statement
+ * @param {float} a Value to return if the comparison is true.
+ * @param {float} b Value to return if the comparison is false.
+ *
+ * @returns {float} equivalent of comparison ? a : b
+ */
+float czm_branchFreeTernary(bool comparison, float a, float b) {
+ float useA = float(comparison);
+ return a * useA + b * (1.0 - useA);
+}
+
+/**
+ * Branchless ternary operator to be used when it's inexpensive to explicitly
+ * evaluate both possibilities for a vec2 expression.
+ *
+ * @name czm_branchFreeTernary
+ * @glslFunction
+ *
+ * @param {bool} comparison A comparison statement
+ * @param {vec2} a Value to return if the comparison is true.
+ * @param {vec2} b Value to return if the comparison is false.
+ *
+ * @returns {vec2} equivalent of comparison ? a : b
+ */
+vec2 czm_branchFreeTernary(bool comparison, vec2 a, vec2 b) {
+ float useA = float(comparison);
+ return a * useA + b * (1.0 - useA);
+}
+
+/**
+ * Branchless ternary operator to be used when it's inexpensive to explicitly
+ * evaluate both possibilities for a vec3 expression.
+ *
+ * @name czm_branchFreeTernary
+ * @glslFunction
+ *
+ * @param {bool} comparison A comparison statement
+ * @param {vec3} a Value to return if the comparison is true.
+ * @param {vec3} b Value to return if the comparison is false.
+ *
+ * @returns {vec3} equivalent of comparison ? a : b
+ */
+vec3 czm_branchFreeTernary(bool comparison, vec3 a, vec3 b) {
+ float useA = float(comparison);
+ return a * useA + b * (1.0 - useA);
+}
+
+/**
+ * Branchless ternary operator to be used when it's inexpensive to explicitly
+ * evaluate both possibilities for a vec4 expression.
+ *
+ * @name czm_branchFreeTernary
+ * @glslFunction
+ *
+ * @param {bool} comparison A comparison statement
+ * @param {vec3} a Value to return if the comparison is true.
+ * @param {vec3} b Value to return if the comparison is false.
+ *
+ * @returns {vec3} equivalent of comparison ? a : b
+ */
+vec4 czm_branchFreeTernary(bool comparison, vec4 a, vec4 b) {
+ float useA = float(comparison);
+ return a * useA + b * (1.0 - useA);
+}
+`;var SEt=T(S(),1),LR=`
+vec4 czm_cascadeColor(vec4 weights)
+{
+ return vec4(1.0, 0.0, 0.0, 1.0) * weights.x +
+ vec4(0.0, 1.0, 0.0, 1.0) * weights.y +
+ vec4(0.0, 0.0, 1.0, 1.0) * weights.z +
+ vec4(1.0, 0.0, 1.0, 1.0) * weights.w;
+}
+`;var VEt=T(S(),1),RR=`
+uniform vec4 shadowMap_cascadeDistances;
+
+float czm_cascadeDistance(vec4 weights)
+{
+ return dot(shadowMap_cascadeDistances, weights);
+}
+`;var REt=T(S(),1),ZR=`
+uniform mat4 shadowMap_cascadeMatrices[4];
+
+mat4 czm_cascadeMatrix(vec4 weights)
+{
+ return shadowMap_cascadeMatrices[0] * weights.x +
+ shadowMap_cascadeMatrices[1] * weights.y +
+ shadowMap_cascadeMatrices[2] * weights.z +
+ shadowMap_cascadeMatrices[3] * weights.w;
+}
+`;var GEt=T(S(),1),GR=`
+uniform vec4 shadowMap_cascadeSplits[2];
+
+vec4 czm_cascadeWeights(float depthEye)
+{
+ // One component is set to 1.0 and all others set to 0.0.
+ vec4 near = step(shadowMap_cascadeSplits[0], vec4(depthEye));
+ vec4 far = step(depthEye, shadowMap_cascadeSplits[1]);
+ return near * far;
+}
+`;var XEt=T(S(),1),ER=`/**
+ * DOC_TBA
+ *
+ * @name czm_columbusViewMorph
+ * @glslFunction
+ */
+vec4 czm_columbusViewMorph(vec4 position2D, vec4 position3D, float time)
+{
+ // Just linear for now.
+ vec3 p = mix(position2D.xyz, position3D.xyz, time);
+ return vec4(p, 1.0);
+}
+`;var WEt=T(S(),1),XR=`/**
+ * Returns a position in model coordinates relative to eye taking into
+ * account the current scene mode: 3D, 2D, or Columbus view.
+ *
+ * This uses standard position attributes, position3DHigh,
+ * position3DLow, position2DHigh, and position2DLow,
+ * and should be used when writing a vertex shader for an {@link Appearance}.
+ *
+ *
+ * @name czm_computePosition
+ * @glslFunction
+ *
+ * @returns {vec4} The position relative to eye.
+ *
+ * @example
+ * vec4 p = czm_computePosition();
+ * v_positionEC = (czm_modelViewRelativeToEye * p).xyz;
+ * gl_Position = czm_modelViewProjectionRelativeToEye * p;
+ *
+ * @see czm_translateRelativeToEye
+ */
+vec4 czm_computePosition();
+`;var vEt=T(S(),1),IR=`/**
+ * @private
+ */
+vec2 cordic(float angle)
+{
+// Scale the vector by the appropriate factor for the 24 iterations to follow.
+ vec2 vector = vec2(6.0725293500888267e-1, 0.0);
+// Iteration 1
+ float sense = (angle < 0.0) ? -1.0 : 1.0;
+ // float factor = sense * 1.0; // 2^-0
+ mat2 rotation = mat2(1.0, sense, -sense, 1.0);
+ vector = rotation * vector;
+ angle -= sense * 7.8539816339744828e-1; // atan(2^-0)
+// Iteration 2
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ float factor = sense * 5.0e-1; // 2^-1
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+ angle -= sense * 4.6364760900080609e-1; // atan(2^-1)
+// Iteration 3
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ factor = sense * 2.5e-1; // 2^-2
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+ angle -= sense * 2.4497866312686414e-1; // atan(2^-2)
+// Iteration 4
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ factor = sense * 1.25e-1; // 2^-3
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+ angle -= sense * 1.2435499454676144e-1; // atan(2^-3)
+// Iteration 5
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ factor = sense * 6.25e-2; // 2^-4
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+ angle -= sense * 6.2418809995957350e-2; // atan(2^-4)
+// Iteration 6
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ factor = sense * 3.125e-2; // 2^-5
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+ angle -= sense * 3.1239833430268277e-2; // atan(2^-5)
+// Iteration 7
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ factor = sense * 1.5625e-2; // 2^-6
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+ angle -= sense * 1.5623728620476831e-2; // atan(2^-6)
+// Iteration 8
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ factor = sense * 7.8125e-3; // 2^-7
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+ angle -= sense * 7.8123410601011111e-3; // atan(2^-7)
+// Iteration 9
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ factor = sense * 3.90625e-3; // 2^-8
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+ angle -= sense * 3.9062301319669718e-3; // atan(2^-8)
+// Iteration 10
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ factor = sense * 1.953125e-3; // 2^-9
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+ angle -= sense * 1.9531225164788188e-3; // atan(2^-9)
+// Iteration 11
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ factor = sense * 9.765625e-4; // 2^-10
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+ angle -= sense * 9.7656218955931946e-4; // atan(2^-10)
+// Iteration 12
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ factor = sense * 4.8828125e-4; // 2^-11
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+ angle -= sense * 4.8828121119489829e-4; // atan(2^-11)
+// Iteration 13
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ factor = sense * 2.44140625e-4; // 2^-12
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+ angle -= sense * 2.4414062014936177e-4; // atan(2^-12)
+// Iteration 14
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ factor = sense * 1.220703125e-4; // 2^-13
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+ angle -= sense * 1.2207031189367021e-4; // atan(2^-13)
+// Iteration 15
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ factor = sense * 6.103515625e-5; // 2^-14
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+ angle -= sense * 6.1035156174208773e-5; // atan(2^-14)
+// Iteration 16
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ factor = sense * 3.0517578125e-5; // 2^-15
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+ angle -= sense * 3.0517578115526096e-5; // atan(2^-15)
+// Iteration 17
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ factor = sense * 1.52587890625e-5; // 2^-16
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+ angle -= sense * 1.5258789061315762e-5; // atan(2^-16)
+// Iteration 18
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ factor = sense * 7.62939453125e-6; // 2^-17
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+ angle -= sense * 7.6293945311019700e-6; // atan(2^-17)
+// Iteration 19
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ factor = sense * 3.814697265625e-6; // 2^-18
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+ angle -= sense * 3.8146972656064961e-6; // atan(2^-18)
+// Iteration 20
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ factor = sense * 1.9073486328125e-6; // 2^-19
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+ angle -= sense * 1.9073486328101870e-6; // atan(2^-19)
+// Iteration 21
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ factor = sense * 9.5367431640625e-7; // 2^-20
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+ angle -= sense * 9.5367431640596084e-7; // atan(2^-20)
+// Iteration 22
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ factor = sense * 4.76837158203125e-7; // 2^-21
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+ angle -= sense * 4.7683715820308884e-7; // atan(2^-21)
+// Iteration 23
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ factor = sense * 2.384185791015625e-7; // 2^-22
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+ angle -= sense * 2.3841857910155797e-7; // atan(2^-22)
+// Iteration 24
+ sense = (angle < 0.0) ? -1.0 : 1.0;
+ factor = sense * 1.1920928955078125e-7; // 2^-23
+ rotation[0][1] = factor;
+ rotation[1][0] = -factor;
+ vector = rotation * vector;
+// angle -= sense * 1.1920928955078068e-7; // atan(2^-23)
+
+ return vector;
+}
+
+/**
+ * Computes the cosine and sine of the provided angle using the CORDIC algorithm.
+ *
+ * @name czm_cosineAndSine
+ * @glslFunction
+ *
+ * @param {float} angle The angle in radians.
+ *
+ * @returns {vec2} The resulting cosine of the angle (as the x coordinate) and sine of the angle (as the y coordinate).
+ *
+ * @example
+ * vec2 v = czm_cosineAndSine(czm_piOverSix);
+ * float cosine = v.x;
+ * float sine = v.y;
+ */
+vec2 czm_cosineAndSine(float angle)
+{
+ if (angle < -czm_piOverTwo || angle > czm_piOverTwo)
+ {
+ if (angle < 0.0)
+ {
+ return -cordic(angle + czm_pi);
+ }
+ else
+ {
+ return -cordic(angle - czm_pi);
+ }
+ }
+ else
+ {
+ return cordic(angle);
+ }
+}
+`;var wEt=T(S(),1),WR=`/**
+ * Decompresses texture coordinates that were packed into a single float.
+ *
+ * @name czm_decompressTextureCoordinates
+ * @glslFunction
+ *
+ * @param {float} encoded The compressed texture coordinates.
+ * @returns {vec2} The decompressed texture coordinates.
+ */
+ vec2 czm_decompressTextureCoordinates(float encoded)
+ {
+ float temp = encoded / 4096.0;
+ float xZeroTo4095 = floor(temp);
+ float stx = xZeroTo4095 / 4095.0;
+ float sty = (encoded - xZeroTo4095 * 4096.0) / 4095.0;
+ return vec2(stx, sty);
+ }
+`;var MEt=T(S(),1),PR=`/**
+ * Get default parameters for physically based rendering. These defaults
+ * describe a rough dielectric (non-metal) surface (e.g. rough plastic).
+ *
+ * @return {czm_pbrParameters} Default parameters for {@link czm_pbrLighting}
+ */
+czm_pbrParameters czm_defaultPbrMaterial()
+{
+ czm_pbrParameters results;
+ results.diffuseColor = vec3(1.0);
+ results.roughness = 1.0;
+
+ const vec3 REFLECTANCE_DIELECTRIC = vec3(0.04);
+ results.f0 = REFLECTANCE_DIELECTRIC;
+ return results;
+}
+`;var UEt=T(S(),1),vR=`// emulated noperspective
+#if (__VERSION__ == 300 || defined(GL_EXT_frag_depth)) && !defined(LOG_DEPTH)
+out float v_WindowZ;
+#endif
+
+/**
+ * Emulates GL_DEPTH_CLAMP, which is not available in WebGL 1 or 2.
+ * GL_DEPTH_CLAMP clamps geometry that is outside the near and far planes,
+ * capping the shadow volume. More information here:
+ * https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_depth_clamp.txt.
+ *
+ * When GL_EXT_frag_depth is available we emulate GL_DEPTH_CLAMP by ensuring
+ * no geometry gets clipped by setting the clip space z value to 0.0 and then
+ * sending the unaltered screen space z value (using emulated noperspective
+ * interpolation) to the frag shader where it is clamped to [0,1] and then
+ * written with gl_FragDepth (see czm_writeDepthClamp). This technique is based on:
+ * https://stackoverflow.com/questions/5960757/how-to-emulate-gl-depth-clamp-nv.
+ *
+ * When GL_EXT_frag_depth is not available, which is the case on some mobile
+ * devices, we must attempt to fix this only in the vertex shader.
+ * The approach is to clamp the z value to the far plane, which closes the
+ * shadow volume but also distorts the geometry, so there can still be artifacts
+ * on frustum seams.
+ *
+ * @name czm_depthClamp
+ * @glslFunction
+ *
+ * @param {vec4} coords The vertex in clip coordinates.
+ * @returns {vec4} The modified vertex.
+ *
+ * @example
+ * gl_Position = czm_depthClamp(czm_modelViewProjection * vec4(position, 1.0));
+ *
+ * @see czm_writeDepthClamp
+ */
+vec4 czm_depthClamp(vec4 coords)
+{
+#ifndef LOG_DEPTH
+#if __VERSION__ == 300 || defined(GL_EXT_frag_depth)
+ v_WindowZ = (0.5 * (coords.z / coords.w) + 0.5) * coords.w;
+ coords.z = 0.0;
+#else
+ coords.z = min(coords.z, coords.w);
+#endif
+#endif
+ return coords;
+}
+`;var DEt=T(S(),1),FR=`/**
+ * Computes a 3x3 rotation matrix that transforms vectors from an ellipsoid's east-north-up coordinate system
+ * to eye coordinates. In east-north-up coordinates, x points east, y points north, and z points along the
+ * surface normal. East-north-up can be used as an ellipsoid's tangent space for operations such as bump mapping.
+ *
+ * The ellipsoid is assumed to be centered at the model coordinate's origin.
+ *
+ * @name czm_eastNorthUpToEyeCoordinates
+ * @glslFunction
+ *
+ * @param {vec3} positionMC The position on the ellipsoid in model coordinates.
+ * @param {vec3} normalEC The normalized ellipsoid surface normal, at positionMC, in eye coordinates.
+ *
+ * @returns {mat3} A 3x3 rotation matrix that transforms vectors from the east-north-up coordinate system to eye coordinates.
+ *
+ * @example
+ * // Transform a vector defined in the east-north-up coordinate
+ * // system, (0, 0, 1) which is the surface normal, to eye
+ * // coordinates.
+ * mat3 m = czm_eastNorthUpToEyeCoordinates(positionMC, normalEC);
+ * vec3 normalEC = m * vec3(0.0, 0.0, 1.0);
+ */
+mat3 czm_eastNorthUpToEyeCoordinates(vec3 positionMC, vec3 normalEC)
+{
+ vec3 tangentMC = normalize(vec3(-positionMC.y, positionMC.x, 0.0)); // normalized surface tangent in model coordinates
+ vec3 tangentEC = normalize(czm_normal3D * tangentMC); // normalized surface tangent in eye coordinates
+ vec3 bitangentEC = normalize(cross(normalEC, tangentEC)); // normalized surface bitangent in eye coordinates
+
+ return mat3(
+ tangentEC.x, tangentEC.y, tangentEC.z,
+ bitangentEC.x, bitangentEC.y, bitangentEC.z,
+ normalEC.x, normalEC.y, normalEC.z);
+}
+`;var YEt=T(S(),1),wR=`/**
+ * DOC_TBA
+ *
+ * @name czm_ellipsoidContainsPoint
+ * @glslFunction
+ *
+ */
+bool czm_ellipsoidContainsPoint(vec3 ellipsoid_inverseRadii, vec3 point)
+{
+ vec3 scaled = ellipsoid_inverseRadii * (czm_inverseModelView * vec4(point, 1.0)).xyz;
+ return (dot(scaled, scaled) <= 1.0);
+}
+`;var KEt=T(S(),1),AR=`/**
+ * DOC_TBA
+ *
+ * @name czm_ellipsoidWgs84TextureCoordinates
+ * @glslFunction
+ */
+vec2 czm_ellipsoidWgs84TextureCoordinates(vec3 normal)
+{
+ return vec2(atan(normal.y, normal.x) * czm_oneOverTwoPi + 0.5, asin(normal.z) * czm_oneOverPi + 0.5);
+}
+`;var zEt=T(S(),1),MR=`/**
+ * Compares left and right componentwise. Returns true
+ * if they are within epsilon and false otherwise. The inputs
+ * left and right can be floats, vec2s,
+ * vec3s, or vec4s.
+ *
+ * @name czm_equalsEpsilon
+ * @glslFunction
+ *
+ * @param {} left The first vector.
+ * @param {} right The second vector.
+ * @param {float} epsilon The epsilon to use for equality testing.
+ * @returns {bool} true if the components are within epsilon and false otherwise.
+ *
+ * @example
+ * // GLSL declarations
+ * bool czm_equalsEpsilon(float left, float right, float epsilon);
+ * bool czm_equalsEpsilon(vec2 left, vec2 right, float epsilon);
+ * bool czm_equalsEpsilon(vec3 left, vec3 right, float epsilon);
+ * bool czm_equalsEpsilon(vec4 left, vec4 right, float epsilon);
+ */
+bool czm_equalsEpsilon(vec4 left, vec4 right, float epsilon) {
+ return all(lessThanEqual(abs(left - right), vec4(epsilon)));
+}
+
+bool czm_equalsEpsilon(vec3 left, vec3 right, float epsilon) {
+ return all(lessThanEqual(abs(left - right), vec3(epsilon)));
+}
+
+bool czm_equalsEpsilon(vec2 left, vec2 right, float epsilon) {
+ return all(lessThanEqual(abs(left - right), vec2(epsilon)));
+}
+
+bool czm_equalsEpsilon(float left, float right, float epsilon) {
+ return (abs(left - right) <= epsilon);
+}
+`;var QEt=T(S(),1),NR=`/**
+ * DOC_TBA
+ *
+ * @name czm_eyeOffset
+ * @glslFunction
+ *
+ * @param {vec4} positionEC DOC_TBA.
+ * @param {vec3} eyeOffset DOC_TBA.
+ *
+ * @returns {vec4} DOC_TBA.
+ */
+vec4 czm_eyeOffset(vec4 positionEC, vec3 eyeOffset)
+{
+ // This equation is approximate in x and y.
+ vec4 p = positionEC;
+ vec4 zEyeOffset = normalize(p) * eyeOffset.z;
+ p.xy += eyeOffset.xy + zEyeOffset.xy;
+ p.z += zEyeOffset.z;
+ return p;
+}
+`;var qEt=T(S(),1),UR=`/**
+ * Transforms a position from eye to window coordinates. The transformation
+ * from eye to clip coordinates is done using {@link czm_projection}.
+ * The transform from normalized device coordinates to window coordinates is
+ * done using {@link czm_viewportTransformation}, which assumes a depth range
+ * of near = 0 and far = 1.
+ *
+ * This transform is useful when there is a need to manipulate window coordinates
+ * in a vertex shader as done by {@link BillboardCollection}.
+ *
+ * @name czm_eyeToWindowCoordinates
+ * @glslFunction
+ *
+ * @param {vec4} position The position in eye coordinates to transform.
+ *
+ * @returns {vec4} The transformed position in window coordinates.
+ *
+ * @see czm_modelToWindowCoordinates
+ * @see czm_projection
+ * @see czm_viewportTransformation
+ * @see BillboardCollection
+ *
+ * @example
+ * vec4 positionWC = czm_eyeToWindowCoordinates(positionEC);
+ */
+vec4 czm_eyeToWindowCoordinates(vec4 positionEC)
+{
+ vec4 q = czm_projection * positionEC; // clip coordinates
+ q.xyz /= q.w; // normalized device coordinates
+ q.xyz = (czm_viewportTransformation * vec4(q.xyz, 1.0)).xyz; // window coordinates
+ return q;
+}
+`;var eXt=T(S(),1),kR=`/**
+ * Approxiamtes atan over the range [0, 1]. Safe to flip output for negative input.
+ *
+ * Based on Michal Drobot's approximation from ShaderFastLibs, which in turn is based on
+ * "Efficient approximations for the arctangent function," Rajan, S. Sichun Wang Inkol, R. Joyal, A., May 2006.
+ * Adapted from ShaderFastLibs under MIT License.
+ *
+ * Chosen for the following characteristics over range [0, 1]:
+ * - basically no error at 0 and 1, important for getting around range limit (naive atan2 via atan requires infinite range atan)
+ * - no visible artifacts from first-derivative discontinuities, unlike latitude via range-reduced sqrt asin approximations (at equator)
+ *
+ * The original code is x * (-0.1784 * abs(x) - 0.0663 * x * x + 1.0301);
+ * Removed the abs() in here because it isn't needed, the input range is guaranteed as [0, 1] by how we're approximating atan2.
+ *
+ * @name czm_fastApproximateAtan
+ * @glslFunction
+ *
+ * @param {float} x Value between 0 and 1 inclusive.
+ *
+ * @returns {float} Approximation of atan(x)
+ */
+float czm_fastApproximateAtan(float x) {
+ return x * (-0.1784 * x - 0.0663 * x * x + 1.0301);
+}
+
+/**
+ * Approximation of atan2.
+ *
+ * Range reduction math based on nvidia's cg reference implementation for atan2: http://developer.download.nvidia.com/cg/atan2.html
+ * However, we replaced their atan curve with Michael Drobot's (see above).
+ *
+ * @name czm_fastApproximateAtan
+ * @glslFunction
+ *
+ * @param {float} x Value between -1 and 1 inclusive.
+ * @param {float} y Value between -1 and 1 inclusive.
+ *
+ * @returns {float} Approximation of atan2(x, y)
+ */
+float czm_fastApproximateAtan(float x, float y) {
+ // atan approximations are usually only reliable over [-1, 1], or, in our case, [0, 1] due to modifications.
+ // So range-reduce using abs and by flipping whether x or y is on top.
+ float t = abs(x); // t used as swap and atan result.
+ float opposite = abs(y);
+ float adjacent = max(t, opposite);
+ opposite = min(t, opposite);
+
+ t = czm_fastApproximateAtan(opposite / adjacent);
+
+ // Undo range reduction
+ t = czm_branchFreeTernary(abs(y) > abs(x), czm_piOverTwo - t, t);
+ t = czm_branchFreeTernary(x < 0.0, czm_pi - t, t);
+ t = czm_branchFreeTernary(y < 0.0, -t, t);
+ return t;
+}
+`;var nXt=T(S(),1),DR=`/**
+ * Gets the color with fog at a distance from the camera.
+ *
+ * @name czm_fog
+ * @glslFunction
+ *
+ * @param {float} distanceToCamera The distance to the camera in meters.
+ * @param {vec3} color The original color.
+ * @param {vec3} fogColor The color of the fog.
+ *
+ * @returns {vec3} The color adjusted for fog at the distance from the camera.
+ */
+vec3 czm_fog(float distanceToCamera, vec3 color, vec3 fogColor)
+{
+ float scalar = distanceToCamera * czm_fogDensity;
+ float fog = 1.0 - exp(-(scalar * scalar));
+ return mix(color, fogColor, fog);
+}
+
+/**
+ * Gets the color with fog at a distance from the camera.
+ *
+ * @name czm_fog
+ * @glslFunction
+ *
+ * @param {float} distanceToCamera The distance to the camera in meters.
+ * @param {vec3} color The original color.
+ * @param {vec3} fogColor The color of the fog.
+ * @param {float} fogModifierConstant A constant to modify the appearance of fog.
+ *
+ * @returns {vec3} The color adjusted for fog at the distance from the camera.
+ */
+vec3 czm_fog(float distanceToCamera, vec3 color, vec3 fogColor, float fogModifierConstant)
+{
+ float scalar = distanceToCamera * czm_fogDensity;
+ float fog = 1.0 - exp(-((fogModifierConstant * scalar + fogModifierConstant) * (scalar * (1.0 + fogModifierConstant))));
+ return mix(color, fogColor, fog);
+}
+`;var oXt=T(S(),1),BR=`/**
+ * Converts a color from RGB space to linear space.
+ *
+ * @name czm_gammaCorrect
+ * @glslFunction
+ *
+ * @param {vec3} color The color in RGB space.
+ * @returns {vec3} The color in linear space.
+ */
+vec3 czm_gammaCorrect(vec3 color) {
+#ifdef HDR
+ color = pow(color, vec3(czm_gamma));
+#endif
+ return color;
+}
+
+vec4 czm_gammaCorrect(vec4 color) {
+#ifdef HDR
+ color.rgb = pow(color.rgb, vec3(czm_gamma));
+#endif
+ return color;
+}
+`;var sXt=T(S(),1),YR=`/**
+ * DOC_TBA
+ *
+ * @name czm_geodeticSurfaceNormal
+ * @glslFunction
+ *
+ * @param {vec3} positionOnEllipsoid DOC_TBA
+ * @param {vec3} ellipsoidCenter DOC_TBA
+ * @param {vec3} oneOverEllipsoidRadiiSquared DOC_TBA
+ *
+ * @returns {vec3} DOC_TBA.
+ */
+vec3 czm_geodeticSurfaceNormal(vec3 positionOnEllipsoid, vec3 ellipsoidCenter, vec3 oneOverEllipsoidRadiiSquared)
+{
+ return normalize((positionOnEllipsoid - ellipsoidCenter) * oneOverEllipsoidRadiiSquared);
+}
+`;var cXt=T(S(),1),OR=`/**
+ * An czm_material with default values. Every material's czm_getMaterial
+ * should use this default material as a base for the material it returns.
+ * The default normal value is given by materialInput.normalEC.
+ *
+ * @name czm_getDefaultMaterial
+ * @glslFunction
+ *
+ * @param {czm_materialInput} input The input used to construct the default material.
+ *
+ * @returns {czm_material} The default material.
+ *
+ * @see czm_materialInput
+ * @see czm_material
+ * @see czm_getMaterial
+ */
+czm_material czm_getDefaultMaterial(czm_materialInput materialInput)
+{
+ czm_material material;
+ material.diffuse = vec3(0.0);
+ material.specular = 0.0;
+ material.shininess = 1.0;
+ material.normal = materialInput.normalEC;
+ material.emission = vec3(0.0);
+ material.alpha = 1.0;
+ return material;
+}
+`;var dXt=T(S(),1),KR=`/**
+ * Calculates the intensity of diffusely reflected light.
+ *
+ * @name czm_getLambertDiffuse
+ * @glslFunction
+ *
+ * @param {vec3} lightDirectionEC Unit vector pointing to the light source in eye coordinates.
+ * @param {vec3} normalEC The surface normal in eye coordinates.
+ *
+ * @returns {float} The intensity of the diffuse reflection.
+ *
+ * @see czm_phong
+ *
+ * @example
+ * float diffuseIntensity = czm_getLambertDiffuse(lightDirectionEC, normalEC);
+ * float specularIntensity = czm_getSpecular(lightDirectionEC, toEyeEC, normalEC, 200);
+ * vec3 color = (diffuseColor * diffuseIntensity) + (specularColor * specularIntensity);
+ */
+float czm_getLambertDiffuse(vec3 lightDirectionEC, vec3 normalEC)
+{
+ return max(dot(lightDirectionEC, normalEC), 0.0);
+}
+`;var mXt=T(S(),1),HR=`/**
+ * Calculates the specular intensity of reflected light.
+ *
+ * @name czm_getSpecular
+ * @glslFunction
+ *
+ * @param {vec3} lightDirectionEC Unit vector pointing to the light source in eye coordinates.
+ * @param {vec3} toEyeEC Unit vector pointing to the eye position in eye coordinates.
+ * @param {vec3} normalEC The surface normal in eye coordinates.
+ * @param {float} shininess The sharpness of the specular reflection. Higher values create a smaller, more focused specular highlight.
+ *
+ * @returns {float} The intensity of the specular highlight.
+ *
+ * @see czm_phong
+ *
+ * @example
+ * float diffuseIntensity = czm_getLambertDiffuse(lightDirectionEC, normalEC);
+ * float specularIntensity = czm_getSpecular(lightDirectionEC, toEyeEC, normalEC, 200);
+ * vec3 color = (diffuseColor * diffuseIntensity) + (specularColor * specularIntensity);
+ */
+float czm_getSpecular(vec3 lightDirectionEC, vec3 toEyeEC, vec3 normalEC, float shininess)
+{
+ vec3 toReflectedLight = reflect(-lightDirectionEC, normalEC);
+ float specular = max(dot(toReflectedLight, toEyeEC), 0.0);
+
+ // pow has undefined behavior if both parameters <= 0.
+ // Prevent this by making sure shininess is at least czm_epsilon2.
+ return pow(specular, max(shininess, czm_epsilon2));
+}
+`;var fXt=T(S(),1),zR=`/**
+ * @private
+ */
+vec4 czm_getWaterNoise(sampler2D normalMap, vec2 uv, float time, float angleInRadians)
+{
+ float cosAngle = cos(angleInRadians);
+ float sinAngle = sin(angleInRadians);
+
+ // time dependent sampling directions
+ vec2 s0 = vec2(1.0/17.0, 0.0);
+ vec2 s1 = vec2(-1.0/29.0, 0.0);
+ vec2 s2 = vec2(1.0/101.0, 1.0/59.0);
+ vec2 s3 = vec2(-1.0/109.0, -1.0/57.0);
+
+ // rotate sampling direction by specified angle
+ s0 = vec2((cosAngle * s0.x) - (sinAngle * s0.y), (sinAngle * s0.x) + (cosAngle * s0.y));
+ s1 = vec2((cosAngle * s1.x) - (sinAngle * s1.y), (sinAngle * s1.x) + (cosAngle * s1.y));
+ s2 = vec2((cosAngle * s2.x) - (sinAngle * s2.y), (sinAngle * s2.x) + (cosAngle * s2.y));
+ s3 = vec2((cosAngle * s3.x) - (sinAngle * s3.y), (sinAngle * s3.x) + (cosAngle * s3.y));
+
+ vec2 uv0 = (uv/103.0) + (time * s0);
+ vec2 uv1 = uv/107.0 + (time * s1) + vec2(0.23);
+ vec2 uv2 = uv/vec2(897.0, 983.0) + (time * s2) + vec2(0.51);
+ vec2 uv3 = uv/vec2(991.0, 877.0) + (time * s3) + vec2(0.71);
+
+ uv0 = fract(uv0);
+ uv1 = fract(uv1);
+ uv2 = fract(uv2);
+ uv3 = fract(uv3);
+ vec4 noise = (texture(normalMap, uv0)) +
+ (texture(normalMap, uv1)) +
+ (texture(normalMap, uv2)) +
+ (texture(normalMap, uv3));
+
+ // average and scale to between -1 and 1
+ return ((noise / 4.0) - 0.5) * 2.0;
+}
+`;var bXt=T(S(),1),JR=`/**
+ * Adjusts the hue of a color.
+ *
+ * @name czm_hue
+ * @glslFunction
+ *
+ * @param {vec3} rgb The color.
+ * @param {float} adjustment The amount to adjust the hue of the color in radians.
+ *
+ * @returns {float} The color with the hue adjusted.
+ *
+ * @example
+ * vec3 adjustHue = czm_hue(color, czm_pi); // The same as czm_hue(color, -czm_pi)
+ */
+vec3 czm_hue(vec3 rgb, float adjustment)
+{
+ const mat3 toYIQ = mat3(0.299, 0.587, 0.114,
+ 0.595716, -0.274453, -0.321263,
+ 0.211456, -0.522591, 0.311135);
+ const mat3 toRGB = mat3(1.0, 0.9563, 0.6210,
+ 1.0, -0.2721, -0.6474,
+ 1.0, -1.107, 1.7046);
+
+ vec3 yiq = toYIQ * rgb;
+ float hue = atan(yiq.z, yiq.y) + adjustment;
+ float chroma = sqrt(yiq.z * yiq.z + yiq.y * yiq.y);
+
+ vec3 color = vec3(yiq.x, chroma * cos(hue), chroma * sin(hue));
+ return toRGB * color;
+}
+`;var gXt=T(S(),1),QR=`/**
+ * Converts a color in linear space to RGB space.
+ *
+ * @name czm_inverseGamma
+ * @glslFunction
+ *
+ * @param {vec3} color The color in linear space.
+ * @returns {vec3} The color in RGB space.
+ */
+vec3 czm_inverseGamma(vec3 color) {
+ return pow(color, vec3(1.0 / czm_gamma));
+}
+`;var _Xt=T(S(),1),jR=`/**
+ * Determines if a time interval is empty.
+ *
+ * @name czm_isEmpty
+ * @glslFunction
+ *
+ * @param {czm_raySegment} interval The interval to test.
+ *
+ * @returns {bool} true if the time interval is empty; otherwise, false.
+ *
+ * @example
+ * bool b0 = czm_isEmpty(czm_emptyRaySegment); // true
+ * bool b1 = czm_isEmpty(czm_raySegment(0.0, 1.0)); // false
+ * bool b2 = czm_isEmpty(czm_raySegment(1.0, 1.0)); // false, contains 1.0.
+ */
+bool czm_isEmpty(czm_raySegment interval)
+{
+ return (interval.stop < 0.0);
+}
+`;var SXt=T(S(),1),qR=`/**
+ * Determines if a time interval is empty.
+ *
+ * @name czm_isFull
+ * @glslFunction
+ *
+ * @param {czm_raySegment} interval The interval to test.
+ *
+ * @returns {bool} true if the time interval is empty; otherwise, false.
+ *
+ * @example
+ * bool b0 = czm_isEmpty(czm_emptyRaySegment); // true
+ * bool b1 = czm_isEmpty(czm_raySegment(0.0, 1.0)); // false
+ * bool b2 = czm_isEmpty(czm_raySegment(1.0, 1.0)); // false, contains 1.0.
+ */
+bool czm_isFull(czm_raySegment interval)
+{
+ return (interval.start == 0.0 && interval.stop == czm_infinity);
+}
+`;var VXt=T(S(),1),$R=`/**
+ * Computes the fraction of a Web Wercator rectangle at which a given geodetic latitude is located.
+ *
+ * @name czm_latitudeToWebMercatorFraction
+ * @glslFunction
+ *
+ * @param {float} latitude The geodetic latitude, in radians.
+ * @param {float} southMercatorY The Web Mercator coordinate of the southern boundary of the rectangle.
+ * @param {float} oneOverMercatorHeight The total height of the rectangle in Web Mercator coordinates.
+ *
+ * @returns {float} The fraction of the rectangle at which the latitude occurs. If the latitude is the southern
+ * boundary of the rectangle, the return value will be zero. If it is the northern boundary, the return
+ * value will be 1.0. Latitudes in between are mapped according to the Web Mercator projection.
+ */
+float czm_latitudeToWebMercatorFraction(float latitude, float southMercatorY, float oneOverMercatorHeight)
+{
+ float sinLatitude = sin(latitude);
+ float mercatorY = 0.5 * log((1.0 + sinLatitude) / (1.0 - sinLatitude));
+
+ return (mercatorY - southMercatorY) * oneOverMercatorHeight;
+}
+`;var RXt=T(S(),1),eZ=`/**
+ * Computes distance from an point in 2D to a line in 2D.
+ *
+ * @name czm_lineDistance
+ * @glslFunction
+ *
+ * param {vec2} point1 A point along the line.
+ * param {vec2} point2 A point along the line.
+ * param {vec2} point A point that may or may not be on the line.
+ * returns {float} The distance from the point to the line.
+ */
+float czm_lineDistance(vec2 point1, vec2 point2, vec2 point) {
+ return abs((point2.y - point1.y) * point.x - (point2.x - point1.x) * point.y + point2.x * point1.y - point2.y * point1.x) / distance(point2, point1);
+}
+`;var GXt=T(S(),1),tZ=`/**
+ * Converts a linear RGB color to an sRGB color.
+ *
+ * @param {vec3|vec4} linearIn The color in linear color space.
+ * @returns {vec3|vec4} The color in sRGB color space. The vector type matches the input.
+ */
+vec3 czm_linearToSrgb(vec3 linearIn)
+{
+ return pow(linearIn, vec3(1.0/2.2));
+}
+
+vec4 czm_linearToSrgb(vec4 linearIn)
+{
+ vec3 srgbOut = pow(linearIn.rgb, vec3(1.0/2.2));
+ return vec4(srgbOut, linearIn.a);
+}
+`;var XXt=T(S(),1),nZ=`/**
+ * Computes the luminance of a color.
+ *
+ * @name czm_luminance
+ * @glslFunction
+ *
+ * @param {vec3} rgb The color.
+ *
+ * @returns {float} The luminance.
+ *
+ * @example
+ * float light = czm_luminance(vec3(0.0)); // 0.0
+ * float dark = czm_luminance(vec3(1.0)); // ~1.0
+ */
+float czm_luminance(vec3 rgb)
+{
+ // Algorithm from Chapter 10 of Graphics Shaders.
+ const vec3 W = vec3(0.2125, 0.7154, 0.0721);
+ return dot(rgb, W);
+}
+`;var WXt=T(S(),1),iZ=`/**
+ * Computes the size of a pixel in meters at a distance from the eye.
+ *
+ * Use this version when passing in a custom pixel ratio. For example, passing in 1.0 will return meters per native device pixel.
+ *
+ * @name czm_metersPerPixel
+ * @glslFunction
+ *
+ * @param {vec3} positionEC The position to get the meters per pixel in eye coordinates.
+ * @param {float} pixelRatio The scaling factor from pixel space to coordinate space
+ *
+ * @returns {float} The meters per pixel at positionEC.
+ */
+float czm_metersPerPixel(vec4 positionEC, float pixelRatio)
+{
+ float width = czm_viewport.z;
+ float height = czm_viewport.w;
+ float pixelWidth;
+ float pixelHeight;
+
+ float top = czm_frustumPlanes.x;
+ float bottom = czm_frustumPlanes.y;
+ float left = czm_frustumPlanes.z;
+ float right = czm_frustumPlanes.w;
+
+ if (czm_sceneMode == czm_sceneMode2D || czm_orthographicIn3D == 1.0)
+ {
+ float frustumWidth = right - left;
+ float frustumHeight = top - bottom;
+ pixelWidth = frustumWidth / width;
+ pixelHeight = frustumHeight / height;
+ }
+ else
+ {
+ float distanceToPixel = -positionEC.z;
+ float inverseNear = 1.0 / czm_currentFrustum.x;
+ float tanTheta = top * inverseNear;
+ pixelHeight = 2.0 * distanceToPixel * tanTheta / height;
+ tanTheta = right * inverseNear;
+ pixelWidth = 2.0 * distanceToPixel * tanTheta / width;
+ }
+
+ return max(pixelWidth, pixelHeight) * pixelRatio;
+}
+
+/**
+ * Computes the size of a pixel in meters at a distance from the eye.
+ *
+ * Use this version when scaling by pixel ratio.
+ *
+ * @name czm_metersPerPixel
+ * @glslFunction
+ *
+ * @param {vec3} positionEC The position to get the meters per pixel in eye coordinates.
+ *
+ * @returns {float} The meters per pixel at positionEC.
+ */
+float czm_metersPerPixel(vec4 positionEC)
+{
+ return czm_metersPerPixel(positionEC, czm_pixelRatio);
+}
+`;var vXt=T(S(),1),oZ=`/**
+ * Transforms a position from model to window coordinates. The transformation
+ * from model to clip coordinates is done using {@link czm_modelViewProjection}.
+ * The transform from normalized device coordinates to window coordinates is
+ * done using {@link czm_viewportTransformation}, which assumes a depth range
+ * of near = 0 and far = 1.
+ *
+ * This transform is useful when there is a need to manipulate window coordinates
+ * in a vertex shader as done by {@link BillboardCollection}.
+ *
+ * This function should not be confused with {@link czm_viewportOrthographic},
+ * which is an orthographic projection matrix that transforms from window
+ * coordinates to clip coordinates.
+ *
+ * @name czm_modelToWindowCoordinates
+ * @glslFunction
+ *
+ * @param {vec4} position The position in model coordinates to transform.
+ *
+ * @returns {vec4} The transformed position in window coordinates.
+ *
+ * @see czm_eyeToWindowCoordinates
+ * @see czm_modelViewProjection
+ * @see czm_viewportTransformation
+ * @see czm_viewportOrthographic
+ * @see BillboardCollection
+ *
+ * @example
+ * vec4 positionWC = czm_modelToWindowCoordinates(positionMC);
+ */
+vec4 czm_modelToWindowCoordinates(vec4 position)
+{
+ vec4 q = czm_modelViewProjection * position; // clip coordinates
+ q.xyz /= q.w; // normalized device coordinates
+ q.xyz = (czm_viewportTransformation * vec4(q.xyz, 1.0)).xyz; // window coordinates
+ return q;
+}
+`;var wXt=T(S(),1),rZ=`/**
+ * DOC_TBA
+ *
+ * @name czm_multiplyWithColorBalance
+ * @glslFunction
+ */
+vec3 czm_multiplyWithColorBalance(vec3 left, vec3 right)
+{
+ // Algorithm from Chapter 10 of Graphics Shaders.
+ const vec3 W = vec3(0.2125, 0.7154, 0.0721);
+
+ vec3 target = left * right;
+ float leftLuminance = dot(left, W);
+ float rightLuminance = dot(right, W);
+ float targetLuminance = dot(target, W);
+
+ return ((leftLuminance + rightLuminance) / (2.0 * targetLuminance)) * target;
+}
+`;var MXt=T(S(),1),sZ=`/**
+ * Computes a value that scales with distance. The scaling is clamped at the near and
+ * far distances, and does not extrapolate. This function works with the
+ * {@link NearFarScalar} JavaScript class.
+ *
+ * @name czm_nearFarScalar
+ * @glslFunction
+ *
+ * @param {vec4} nearFarScalar A vector with 4 components: Near distance (x), Near value (y), Far distance (z), Far value (w).
+ * @param {float} cameraDistSq The square of the current distance from the camera.
+ *
+ * @returns {float} The value at this distance.
+ */
+float czm_nearFarScalar(vec4 nearFarScalar, float cameraDistSq)
+{
+ float valueAtMin = nearFarScalar.y;
+ float valueAtMax = nearFarScalar.w;
+ float nearDistanceSq = nearFarScalar.x * nearFarScalar.x;
+ float farDistanceSq = nearFarScalar.z * nearFarScalar.z;
+
+ float t = (cameraDistSq - nearDistanceSq) / (farDistanceSq - nearDistanceSq);
+
+ t = pow(clamp(t, 0.0, 1.0), 0.2);
+
+ return mix(valueAtMin, valueAtMax, t);
+}
+`;var UXt=T(S(),1),aZ=` /**
+ * Decodes a unit-length vector in 'oct' encoding to a normalized 3-component Cartesian vector.
+ * The 'oct' encoding is described in "A Survey of Efficient Representations of Independent Unit Vectors",
+ * Cigolle et al 2014: http://jcgt.org/published/0003/02/01/
+ *
+ * @name czm_octDecode
+ * @param {vec2} encoded The oct-encoded, unit-length vector
+ * @param {float} range The maximum value of the SNORM range. The encoded vector is stored in log2(rangeMax+1) bits.
+ * @returns {vec3} The decoded and normalized vector
+ */
+ vec3 czm_octDecode(vec2 encoded, float range)
+ {
+ if (encoded.x == 0.0 && encoded.y == 0.0) {
+ return vec3(0.0, 0.0, 0.0);
+ }
+
+ encoded = encoded / range * 2.0 - 1.0;
+ vec3 v = vec3(encoded.x, encoded.y, 1.0 - abs(encoded.x) - abs(encoded.y));
+ if (v.z < 0.0)
+ {
+ v.xy = (1.0 - abs(v.yx)) * czm_signNotZero(v.xy);
+ }
+
+ return normalize(v);
+ }
+
+/**
+ * Decodes a unit-length vector in 'oct' encoding to a normalized 3-component Cartesian vector.
+ * The 'oct' encoding is described in "A Survey of Efficient Representations of Independent Unit Vectors",
+ * Cigolle et al 2014: http://jcgt.org/published/0003/02/01/
+ *
+ * @name czm_octDecode
+ * @param {vec2} encoded The oct-encoded, unit-length vector
+ * @returns {vec3} The decoded and normalized vector
+ */
+ vec3 czm_octDecode(vec2 encoded)
+ {
+ return czm_octDecode(encoded, 255.0);
+ }
+
+ /**
+ * Decodes a unit-length vector in 'oct' encoding packed into a floating-point number to a normalized 3-component Cartesian vector.
+ * The 'oct' encoding is described in "A Survey of Efficient Representations of Independent Unit Vectors",
+ * Cigolle et al 2014: http://jcgt.org/published/0003/02/01/
+ *
+ * @name czm_octDecode
+ * @param {float} encoded The oct-encoded, unit-length vector
+ * @returns {vec3} The decoded and normalized vector
+ */
+ vec3 czm_octDecode(float encoded)
+ {
+ float temp = encoded / 256.0;
+ float x = floor(temp);
+ float y = (temp - x) * 256.0;
+ return czm_octDecode(vec2(x, y));
+ }
+
+/**
+ * Decodes three unit-length vectors in 'oct' encoding packed into two floating-point numbers to normalized 3-component Cartesian vectors.
+ * The 'oct' encoding is described in "A Survey of Efficient Representations of Independent Unit Vectors",
+ * Cigolle et al 2014: http://jcgt.org/published/0003/02/01/
+ *
+ * @name czm_octDecode
+ * @param {vec2} encoded The packed oct-encoded, unit-length vectors.
+ * @param {vec3} vector1 One decoded and normalized vector.
+ * @param {vec3} vector2 One decoded and normalized vector.
+ * @param {vec3} vector3 One decoded and normalized vector.
+ */
+ void czm_octDecode(vec2 encoded, out vec3 vector1, out vec3 vector2, out vec3 vector3)
+ {
+ float temp = encoded.x / 65536.0;
+ float x = floor(temp);
+ float encodedFloat1 = (temp - x) * 65536.0;
+
+ temp = encoded.y / 65536.0;
+ float y = floor(temp);
+ float encodedFloat2 = (temp - y) * 65536.0;
+
+ vector1 = czm_octDecode(encodedFloat1);
+ vector2 = czm_octDecode(encodedFloat2);
+ vector3 = czm_octDecode(vec2(x, y));
+ }
+
+`;var DXt=T(S(),1),cZ=`/**
+ * Packs a depth value into a vec3 that can be represented by unsigned bytes.
+ *
+ * @name czm_packDepth
+ * @glslFunction
+ *
+ * @param {float} depth The floating-point depth.
+ * @returns {vec3} The packed depth.
+ */
+vec4 czm_packDepth(float depth)
+{
+ // See Aras Pranckevi\u010Dius' post Encoding Floats to RGBA
+ // http://aras-p.info/blog/2009/07/30/encoding-floats-to-rgba-the-final/
+ vec4 enc = vec4(1.0, 255.0, 65025.0, 16581375.0) * depth;
+ enc = fract(enc);
+ enc -= enc.yzww * vec4(1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0, 0.0);
+ return enc;
+}
+`;var YXt=T(S(),1),lZ=`vec3 lambertianDiffuse(vec3 diffuseColor)
+{
+ return diffuseColor / czm_pi;
+}
+
+vec3 fresnelSchlick2(vec3 f0, vec3 f90, float VdotH)
+{
+ return f0 + (f90 - f0) * pow(clamp(1.0 - VdotH, 0.0, 1.0), 5.0);
+}
+
+float smithVisibilityG1(float NdotV, float roughness)
+{
+ // this is the k value for direct lighting.
+ // for image based lighting it will be roughness^2 / 2
+ float k = (roughness + 1.0) * (roughness + 1.0) / 8.0;
+ return NdotV / (NdotV * (1.0 - k) + k);
+}
+
+float smithVisibilityGGX(float roughness, float NdotL, float NdotV)
+{
+ return (
+ smithVisibilityG1(NdotL, roughness) *
+ smithVisibilityG1(NdotV, roughness)
+ );
+}
+
+float GGX(float roughness, float NdotH)
+{
+ float roughnessSquared = roughness * roughness;
+ float f = (NdotH * roughnessSquared - NdotH) * NdotH + 1.0;
+ return roughnessSquared / (czm_pi * f * f);
+}
+
+/**
+ * Compute the diffuse and specular contributions using physically based
+ * rendering. This function only handles direct lighting.
+ *
+ * This function only handles the lighting calculations. Metallic/roughness
+ * and specular/glossy must be handled separately. See {@czm_pbrMetallicRoughnessMaterial}, {@czm_pbrSpecularGlossinessMaterial} and {@czm_defaultPbrMaterial}
+ *
+ *
+ * @name czm_pbrlighting
+ * @glslFunction
+ *
+ * @param {vec3} positionEC The position of the fragment in eye coordinates
+ * @param {vec3} normalEC The surface normal in eye coordinates
+ * @param {vec3} lightDirectionEC Unit vector pointing to the light source in eye coordinates.
+ * @param {vec3} lightColorHdr radiance of the light source. This is a HDR value.
+ * @param {czm_pbrParameters} The computed PBR parameters.
+ * @return {vec3} The computed HDR color
+ *
+ * @example
+ * czm_pbrParameters pbrParameters = czm_pbrMetallicRoughnessMaterial(
+ * baseColor,
+ * metallic,
+ * roughness
+ * );
+ * vec3 color = czm_pbrlighting(
+ * positionEC,
+ * normalEC,
+ * lightDirectionEC,
+ * lightColorHdr,
+ * pbrParameters);
+ */
+vec3 czm_pbrLighting(
+ vec3 positionEC,
+ vec3 normalEC,
+ vec3 lightDirectionEC,
+ vec3 lightColorHdr,
+ czm_pbrParameters pbrParameters
+)
+{
+ vec3 v = -normalize(positionEC);
+ vec3 l = normalize(lightDirectionEC);
+ vec3 h = normalize(v + l);
+ vec3 n = normalEC;
+ float NdotL = clamp(dot(n, l), 0.001, 1.0);
+ float NdotV = abs(dot(n, v)) + 0.001;
+ float NdotH = clamp(dot(n, h), 0.0, 1.0);
+ float LdotH = clamp(dot(l, h), 0.0, 1.0);
+ float VdotH = clamp(dot(v, h), 0.0, 1.0);
+
+ vec3 f0 = pbrParameters.f0;
+ float reflectance = max(max(f0.r, f0.g), f0.b);
+ vec3 f90 = vec3(clamp(reflectance * 25.0, 0.0, 1.0));
+ vec3 F = fresnelSchlick2(f0, f90, VdotH);
+
+ float alpha = pbrParameters.roughness;
+ float G = smithVisibilityGGX(alpha, NdotL, NdotV);
+ float D = GGX(alpha, NdotH);
+ vec3 specularContribution = F * G * D / (4.0 * NdotL * NdotV);
+
+ vec3 diffuseColor = pbrParameters.diffuseColor;
+ // F here represents the specular contribution
+ vec3 diffuseContribution = (1.0 - F) * lambertianDiffuse(diffuseColor);
+
+ // Lo = (diffuse + specular) * Li * NdotL
+ return (diffuseContribution + specularContribution) * NdotL * lightColorHdr;
+}
+`;var KXt=T(S(),1),dZ=`/**
+ * Compute parameters for physically based rendering using the
+ * metallic/roughness workflow. All inputs are linear; sRGB texture values must
+ * be decoded beforehand
+ *
+ * @name czm_pbrMetallicRoughnessMaterial
+ * @glslFunction
+ *
+ * @param {vec3} baseColor For dielectrics, this is the base color. For metals, this is the f0 value (reflectance at normal incidence)
+ * @param {float} metallic 0.0 indicates dielectric. 1.0 indicates metal. Values in between are allowed (e.g. to model rust or dirt);
+ * @param {float} roughness A value between 0.0 and 1.0
+ * @return {czm_pbrParameters} parameters to pass into {@link czm_pbrLighting}
+ */
+czm_pbrParameters czm_pbrMetallicRoughnessMaterial(
+ vec3 baseColor,
+ float metallic,
+ float roughness
+)
+{
+ czm_pbrParameters results;
+
+ // roughness is authored as perceptual roughness
+ // square it to get material roughness
+ roughness = clamp(roughness, 0.0, 1.0);
+ results.roughness = roughness * roughness;
+
+ // dielectrics use f0 = 0.04, metals use albedo as f0
+ metallic = clamp(metallic, 0.0, 1.0);
+ const vec3 REFLECTANCE_DIELECTRIC = vec3(0.04);
+ vec3 f0 = mix(REFLECTANCE_DIELECTRIC, baseColor, metallic);
+ results.f0 = f0;
+
+ // diffuse only applies to dielectrics.
+ results.diffuseColor = baseColor * (1.0 - f0) * (1.0 - metallic);
+
+ return results;
+}
+`;var zXt=T(S(),1),uZ=`/**
+ * Compute parameters for physically based rendering using the
+ * specular/glossy workflow. All inputs are linear; sRGB texture values must
+ * be decoded beforehand
+ *
+ * @name czm_pbrSpecularGlossinessMaterial
+ * @glslFunction
+ *
+ * @param {vec3} diffuse The diffuse color for dielectrics (non-metals)
+ * @param {vec3} specular The reflectance at normal incidence (f0)
+ * @param {float} glossiness A number from 0.0 to 1.0 indicating how smooth the surface is.
+ * @return {czm_pbrParameters} parameters to pass into {@link czm_pbrLighting}
+ */
+czm_pbrParameters czm_pbrSpecularGlossinessMaterial(
+ vec3 diffuse,
+ vec3 specular,
+ float glossiness
+)
+{
+ czm_pbrParameters results;
+
+ // glossiness is the opposite of roughness, but easier for artists to use.
+ float roughness = 1.0 - glossiness;
+ results.roughness = roughness * roughness;
+
+ results.diffuseColor = diffuse * (1.0 - max(max(specular.r, specular.g), specular.b));
+ results.f0 = specular;
+
+ return results;
+}
+`;var QXt=T(S(),1),mZ=`float czm_private_getLambertDiffuseOfMaterial(vec3 lightDirectionEC, czm_material material)
+{
+ return czm_getLambertDiffuse(lightDirectionEC, material.normal);
+}
+
+float czm_private_getSpecularOfMaterial(vec3 lightDirectionEC, vec3 toEyeEC, czm_material material)
+{
+ return czm_getSpecular(lightDirectionEC, toEyeEC, material.normal, material.shininess);
+}
+
+/**
+ * Computes a color using the Phong lighting model.
+ *
+ * @name czm_phong
+ * @glslFunction
+ *
+ * @param {vec3} toEye A normalized vector from the fragment to the eye in eye coordinates.
+ * @param {czm_material} material The fragment's material.
+ *
+ * @returns {vec4} The computed color.
+ *
+ * @example
+ * vec3 positionToEyeEC = // ...
+ * czm_material material = // ...
+ * vec3 lightDirectionEC = // ...
+ * out_FragColor = czm_phong(normalize(positionToEyeEC), material, lightDirectionEC);
+ *
+ * @see czm_getMaterial
+ */
+vec4 czm_phong(vec3 toEye, czm_material material, vec3 lightDirectionEC)
+{
+ // Diffuse from directional light sources at eye (for top-down)
+ float diffuse = czm_private_getLambertDiffuseOfMaterial(vec3(0.0, 0.0, 1.0), material);
+ if (czm_sceneMode == czm_sceneMode3D) {
+ // (and horizon views in 3D)
+ diffuse += czm_private_getLambertDiffuseOfMaterial(vec3(0.0, 1.0, 0.0), material);
+ }
+
+ float specular = czm_private_getSpecularOfMaterial(lightDirectionEC, toEye, material);
+
+ // Temporary workaround for adding ambient.
+ vec3 materialDiffuse = material.diffuse * 0.5;
+
+ vec3 ambient = materialDiffuse;
+ vec3 color = ambient + material.emission;
+ color += materialDiffuse * diffuse * czm_lightColor;
+ color += material.specular * specular * czm_lightColor;
+
+ return vec4(color, material.alpha);
+}
+
+vec4 czm_private_phong(vec3 toEye, czm_material material, vec3 lightDirectionEC)
+{
+ float diffuse = czm_private_getLambertDiffuseOfMaterial(lightDirectionEC, material);
+ float specular = czm_private_getSpecularOfMaterial(lightDirectionEC, toEye, material);
+
+ vec3 ambient = vec3(0.0);
+ vec3 color = ambient + material.emission;
+ color += material.diffuse * diffuse * czm_lightColor;
+ color += material.specular * specular * czm_lightColor;
+
+ return vec4(color, material.alpha);
+}
+`;var qXt=T(S(),1),hZ=`/**
+ * Computes distance from a point to a plane.
+ *
+ * @name czm_planeDistance
+ * @glslFunction
+ *
+ * param {vec4} plane A Plane in Hessian Normal Form. See Plane.js
+ * param {vec3} point A point in the same space as the plane.
+ * returns {float} The distance from the point to the plane.
+ */
+float czm_planeDistance(vec4 plane, vec3 point) {
+ return (dot(plane.xyz, point) + plane.w);
+}
+
+/**
+ * Computes distance from a point to a plane.
+ *
+ * @name czm_planeDistance
+ * @glslFunction
+ *
+ * param {vec3} planeNormal Normal for a plane in Hessian Normal Form. See Plane.js
+ * param {float} planeDistance Distance for a plane in Hessian Normal form. See Plane.js
+ * param {vec3} point A point in the same space as the plane.
+ * returns {float} The distance from the point to the plane.
+ */
+float czm_planeDistance(vec3 planeNormal, float planeDistance, vec3 point) {
+ return (dot(planeNormal, point) + planeDistance);
+}
+`;var eIt=T(S(),1),fZ=`/**
+ * Computes the point along a ray at the given time. time can be positive, negative, or zero.
+ *
+ * @name czm_pointAlongRay
+ * @glslFunction
+ *
+ * @param {czm_ray} ray The ray to compute the point along.
+ * @param {float} time The time along the ray.
+ *
+ * @returns {vec3} The point along the ray at the given time.
+ *
+ * @example
+ * czm_ray ray = czm_ray(vec3(0.0), vec3(1.0, 0.0, 0.0)); // origin, direction
+ * vec3 v = czm_pointAlongRay(ray, 2.0); // (2.0, 0.0, 0.0)
+ */
+vec3 czm_pointAlongRay(czm_ray ray, float time)
+{
+ return ray.origin + (time * ray.direction);
+}
+`;var nIt=T(S(),1),pZ=`/**
+ * DOC_TBA
+ *
+ * @name czm_rayEllipsoidIntersectionInterval
+ * @glslFunction
+ */
+czm_raySegment czm_rayEllipsoidIntersectionInterval(czm_ray ray, vec3 ellipsoid_center, vec3 ellipsoid_inverseRadii)
+{
+ // ray and ellipsoid center in eye coordinates. radii in model coordinates.
+ vec3 q = ellipsoid_inverseRadii * (czm_inverseModelView * vec4(ray.origin, 1.0)).xyz;
+ vec3 w = ellipsoid_inverseRadii * (czm_inverseModelView * vec4(ray.direction, 0.0)).xyz;
+
+ q = q - ellipsoid_inverseRadii * (czm_inverseModelView * vec4(ellipsoid_center, 1.0)).xyz;
+
+ float q2 = dot(q, q);
+ float qw = dot(q, w);
+
+ if (q2 > 1.0) // Outside ellipsoid.
+ {
+ if (qw >= 0.0) // Looking outward or tangent (0 intersections).
+ {
+ return czm_emptyRaySegment;
+ }
+ else // qw < 0.0.
+ {
+ float qw2 = qw * qw;
+ float difference = q2 - 1.0; // Positively valued.
+ float w2 = dot(w, w);
+ float product = w2 * difference;
+
+ if (qw2 < product) // Imaginary roots (0 intersections).
+ {
+ return czm_emptyRaySegment;
+ }
+ else if (qw2 > product) // Distinct roots (2 intersections).
+ {
+ float discriminant = qw * qw - product;
+ float temp = -qw + sqrt(discriminant); // Avoid cancellation.
+ float root0 = temp / w2;
+ float root1 = difference / temp;
+ if (root0 < root1)
+ {
+ czm_raySegment i = czm_raySegment(root0, root1);
+ return i;
+ }
+ else
+ {
+ czm_raySegment i = czm_raySegment(root1, root0);
+ return i;
+ }
+ }
+ else // qw2 == product. Repeated roots (2 intersections).
+ {
+ float root = sqrt(difference / w2);
+ czm_raySegment i = czm_raySegment(root, root);
+ return i;
+ }
+ }
+ }
+ else if (q2 < 1.0) // Inside ellipsoid (2 intersections).
+ {
+ float difference = q2 - 1.0; // Negatively valued.
+ float w2 = dot(w, w);
+ float product = w2 * difference; // Negatively valued.
+ float discriminant = qw * qw - product;
+ float temp = -qw + sqrt(discriminant); // Positively valued.
+ czm_raySegment i = czm_raySegment(0.0, temp / w2);
+ return i;
+ }
+ else // q2 == 1.0. On ellipsoid.
+ {
+ if (qw < 0.0) // Looking inward.
+ {
+ float w2 = dot(w, w);
+ czm_raySegment i = czm_raySegment(0.0, -qw / w2);
+ return i;
+ }
+ else // qw >= 0.0. Looking outward or tangent.
+ {
+ return czm_emptyRaySegment;
+ }
+ }
+}
+`;var oIt=T(S(),1),bZ=`/**
+ * Compute the intersection interval of a ray with a sphere.
+ *
+ * @name czm_raySphereIntersectionInterval
+ * @glslFunction
+ *
+ * @param {czm_ray} ray The ray.
+ * @param {vec3} center The center of the sphere.
+ * @param {float} radius The radius of the sphere.
+ * @return {czm_raySegment} The intersection interval of the ray with the sphere.
+ */
+czm_raySegment czm_raySphereIntersectionInterval(czm_ray ray, vec3 center, float radius)
+{
+ vec3 o = ray.origin;
+ vec3 d = ray.direction;
+
+ vec3 oc = o - center;
+
+ float a = dot(d, d);
+ float b = 2.0 * dot(d, oc);
+ float c = dot(oc, oc) - (radius * radius);
+
+ float det = (b * b) - (4.0 * a * c);
+
+ if (det < 0.0) {
+ return czm_emptyRaySegment;
+ }
+
+ float sqrtDet = sqrt(det);
+
+ float t0 = (-b - sqrtDet) / (2.0 * a);
+ float t1 = (-b + sqrtDet) / (2.0 * a);
+
+ czm_raySegment result = czm_raySegment(t0, t1);
+ return result;
+}
+`;var sIt=T(S(),1),yZ=`float czm_readDepth(sampler2D depthTexture, vec2 texCoords)
+{
+ return czm_reverseLogDepth(texture(depthTexture, texCoords).r);
+}
+`;var cIt=T(S(),1),gZ=`/**
+ * Reads a value previously transformed with {@link czm_writeNonPerspective}
+ * by dividing it by \`w\`, the value used in the perspective divide.
+ * This function is intended to be called in a fragment shader to access a
+ * \`varying\` that should not be subject to perspective interpolation.
+ * For example, screen-space texture coordinates. The value should have been
+ * previously written in the vertex shader with a call to
+ * {@link czm_writeNonPerspective}.
+ *
+ * @name czm_readNonPerspective
+ * @glslFunction
+ *
+ * @param {float|vec2|vec3|vec4} value The non-perspective value to be read.
+ * @param {float} oneOverW One over the perspective divide value, \`w\`. Usually this is simply \`gl_FragCoord.w\`.
+ * @returns {float|vec2|vec3|vec4} The usable value.
+ */
+float czm_readNonPerspective(float value, float oneOverW) {
+ return value * oneOverW;
+}
+
+vec2 czm_readNonPerspective(vec2 value, float oneOverW) {
+ return value * oneOverW;
+}
+
+vec3 czm_readNonPerspective(vec3 value, float oneOverW) {
+ return value * oneOverW;
+}
+
+vec4 czm_readNonPerspective(vec4 value, float oneOverW) {
+ return value * oneOverW;
+}
+`;var dIt=T(S(),1),xZ=`float czm_reverseLogDepth(float logZ)
+{
+#ifdef LOG_DEPTH
+ float near = czm_currentFrustum.x;
+ float far = czm_currentFrustum.y;
+ float log2Depth = logZ * czm_log2FarDepthFromNearPlusOne;
+ float depthFromNear = pow(2.0, log2Depth) - 1.0;
+ return far * (1.0 - near / (depthFromNear + near)) / (far - near);
+#endif
+ return logZ;
+}
+`;var mIt=T(S(),1),_Z=`/**
+ * Round a floating point value. This function exists because round() doesn't
+ * exist in GLSL 1.00.
+ *
+ * @param {float|vec2|vec3|vec4} value The value to round
+ * @param {float|vec2|vec3|vec3} The rounded value. The type matches the input.
+ */
+float czm_round(float value) {
+ return floor(value + 0.5);
+}
+
+vec2 czm_round(vec2 value) {
+ return floor(value + 0.5);
+}
+
+vec3 czm_round(vec3 value) {
+ return floor(value + 0.5);
+}
+
+vec4 czm_round(vec4 value) {
+ return floor(value + 0.5);
+}
+`;var fIt=T(S(),1),TZ=`/**
+ * Samples the 4 neighboring pixels and return the weighted average.
+ *
+ * @private
+ */
+vec3 czm_sampleOctahedralProjectionWithFiltering(sampler2D projectedMap, vec2 textureSize, vec3 direction, float lod)
+{
+ direction /= dot(vec3(1.0), abs(direction));
+ vec2 rev = abs(direction.zx) - vec2(1.0);
+ vec2 neg = vec2(direction.x < 0.0 ? rev.x : -rev.x,
+ direction.z < 0.0 ? rev.y : -rev.y);
+ vec2 uv = direction.y < 0.0 ? neg : direction.xz;
+ vec2 coord = 0.5 * uv + vec2(0.5);
+ vec2 pixel = 1.0 / textureSize;
+
+ if (lod > 0.0)
+ {
+ // Each subseqeuent mip level is half the size
+ float scale = 1.0 / pow(2.0, lod);
+ float offset = ((textureSize.y + 1.0) / textureSize.x);
+
+ coord.x *= offset;
+ coord *= scale;
+
+ coord.x += offset + pixel.x;
+ coord.y += (1.0 - (1.0 / pow(2.0, lod - 1.0))) + pixel.y * (lod - 1.0) * 2.0;
+ }
+ else
+ {
+ coord.x *= (textureSize.y / textureSize.x);
+ }
+
+ // Do bilinear filtering
+ #ifndef OES_texture_float_linear
+ vec3 color1 = texture(projectedMap, coord + vec2(0.0, pixel.y)).rgb;
+ vec3 color2 = texture(projectedMap, coord + vec2(pixel.x, 0.0)).rgb;
+ vec3 color3 = texture(projectedMap, coord + pixel).rgb;
+ vec3 color4 = texture(projectedMap, coord).rgb;
+
+ vec2 texturePosition = coord * textureSize;
+
+ float fu = fract(texturePosition.x);
+ float fv = fract(texturePosition.y);
+
+ vec3 average1 = mix(color4, color2, fu);
+ vec3 average2 = mix(color1, color3, fu);
+
+ vec3 color = mix(average1, average2, fv);
+ #else
+ vec3 color = texture(projectedMap, coord).rgb;
+ #endif
+
+ return color;
+}
+
+
+/**
+ * Samples from a cube map that has been projected using an octahedral projection from the given direction.
+ *
+ * @name czm_sampleOctahedralProjection
+ * @glslFunction
+ *
+ * @param {sampler2D} projectedMap The texture with the octahedral projected cube map.
+ * @param {vec2} textureSize The width and height dimensions in pixels of the projected map.
+ * @param {vec3} direction The normalized direction used to sample the cube map.
+ * @param {float} lod The level of detail to sample.
+ * @param {float} maxLod The maximum level of detail.
+ * @returns {vec3} The color of the cube map at the direction.
+ */
+vec3 czm_sampleOctahedralProjection(sampler2D projectedMap, vec2 textureSize, vec3 direction, float lod, float maxLod) {
+ float currentLod = floor(lod + 0.5);
+ float nextLod = min(currentLod + 1.0, maxLod);
+
+ vec3 colorCurrentLod = czm_sampleOctahedralProjectionWithFiltering(projectedMap, textureSize, direction, currentLod);
+ vec3 colorNextLod = czm_sampleOctahedralProjectionWithFiltering(projectedMap, textureSize, direction, nextLod);
+
+ return mix(colorNextLod, colorCurrentLod, nextLod - lod);
+}
+`;var bIt=T(S(),1),SZ=`/**
+ * Adjusts the saturation of a color.
+ *
+ * @name czm_saturation
+ * @glslFunction
+ *
+ * @param {vec3} rgb The color.
+ * @param {float} adjustment The amount to adjust the saturation of the color.
+ *
+ * @returns {float} The color with the saturation adjusted.
+ *
+ * @example
+ * vec3 greyScale = czm_saturation(color, 0.0);
+ * vec3 doubleSaturation = czm_saturation(color, 2.0);
+ */
+vec3 czm_saturation(vec3 rgb, float adjustment)
+{
+ // Algorithm from Chapter 16 of OpenGL Shading Language
+ const vec3 W = vec3(0.2125, 0.7154, 0.0721);
+ vec3 intensity = vec3(dot(rgb, W));
+ return mix(intensity, rgb, adjustment);
+}
+`;var gIt=T(S(),1),CZ=`
+float czm_sampleShadowMap(highp samplerCube shadowMap, vec3 d)
+{
+ return czm_unpackDepth(czm_textureCube(shadowMap, d));
+}
+
+float czm_sampleShadowMap(highp sampler2D shadowMap, vec2 uv)
+{
+#ifdef USE_SHADOW_DEPTH_TEXTURE
+ return texture(shadowMap, uv).r;
+#else
+ return czm_unpackDepth(texture(shadowMap, uv));
+#endif
+}
+
+float czm_shadowDepthCompare(samplerCube shadowMap, vec3 uv, float depth)
+{
+ return step(depth, czm_sampleShadowMap(shadowMap, uv));
+}
+
+float czm_shadowDepthCompare(sampler2D shadowMap, vec2 uv, float depth)
+{
+ return step(depth, czm_sampleShadowMap(shadowMap, uv));
+}
+`;var _It=T(S(),1),VZ=`
+float czm_private_shadowVisibility(float visibility, float nDotL, float normalShadingSmooth, float darkness)
+{
+#ifdef USE_NORMAL_SHADING
+#ifdef USE_NORMAL_SHADING_SMOOTH
+ float strength = clamp(nDotL / normalShadingSmooth, 0.0, 1.0);
+#else
+ float strength = step(0.0, nDotL);
+#endif
+ visibility *= strength;
+#endif
+
+ visibility = max(visibility, darkness);
+ return visibility;
+}
+
+#ifdef USE_CUBE_MAP_SHADOW
+float czm_shadowVisibility(samplerCube shadowMap, czm_shadowParameters shadowParameters)
+{
+ float depthBias = shadowParameters.depthBias;
+ float depth = shadowParameters.depth;
+ float nDotL = shadowParameters.nDotL;
+ float normalShadingSmooth = shadowParameters.normalShadingSmooth;
+ float darkness = shadowParameters.darkness;
+ vec3 uvw = shadowParameters.texCoords;
+
+ depth -= depthBias;
+ float visibility = czm_shadowDepthCompare(shadowMap, uvw, depth);
+ return czm_private_shadowVisibility(visibility, nDotL, normalShadingSmooth, darkness);
+}
+#else
+float czm_shadowVisibility(sampler2D shadowMap, czm_shadowParameters shadowParameters)
+{
+ float depthBias = shadowParameters.depthBias;
+ float depth = shadowParameters.depth;
+ float nDotL = shadowParameters.nDotL;
+ float normalShadingSmooth = shadowParameters.normalShadingSmooth;
+ float darkness = shadowParameters.darkness;
+ vec2 uv = shadowParameters.texCoords;
+
+ depth -= depthBias;
+#ifdef USE_SOFT_SHADOWS
+ vec2 texelStepSize = shadowParameters.texelStepSize;
+ float radius = 1.0;
+ float dx0 = -texelStepSize.x * radius;
+ float dy0 = -texelStepSize.y * radius;
+ float dx1 = texelStepSize.x * radius;
+ float dy1 = texelStepSize.y * radius;
+ float visibility = (
+ czm_shadowDepthCompare(shadowMap, uv, depth) +
+ czm_shadowDepthCompare(shadowMap, uv + vec2(dx0, dy0), depth) +
+ czm_shadowDepthCompare(shadowMap, uv + vec2(0.0, dy0), depth) +
+ czm_shadowDepthCompare(shadowMap, uv + vec2(dx1, dy0), depth) +
+ czm_shadowDepthCompare(shadowMap, uv + vec2(dx0, 0.0), depth) +
+ czm_shadowDepthCompare(shadowMap, uv + vec2(dx1, 0.0), depth) +
+ czm_shadowDepthCompare(shadowMap, uv + vec2(dx0, dy1), depth) +
+ czm_shadowDepthCompare(shadowMap, uv + vec2(0.0, dy1), depth) +
+ czm_shadowDepthCompare(shadowMap, uv + vec2(dx1, dy1), depth)
+ ) * (1.0 / 9.0);
+#else
+ float visibility = czm_shadowDepthCompare(shadowMap, uv, depth);
+#endif
+
+ return czm_private_shadowVisibility(visibility, nDotL, normalShadingSmooth, darkness);
+}
+#endif
+`;var SIt=T(S(),1),LZ=`/**
+ * Returns 1.0 if the given value is positive or zero, and -1.0 if it is negative. This is similar to the GLSL
+ * built-in function sign except that returns 1.0 instead of 0.0 when the input value is 0.0.
+ *
+ * @name czm_signNotZero
+ * @glslFunction
+ *
+ * @param {} value The value for which to determine the sign.
+ * @returns {} 1.0 if the value is positive or zero, -1.0 if the value is negative.
+ */
+float czm_signNotZero(float value)
+{
+ return value >= 0.0 ? 1.0 : -1.0;
+}
+
+vec2 czm_signNotZero(vec2 value)
+{
+ return vec2(czm_signNotZero(value.x), czm_signNotZero(value.y));
+}
+
+vec3 czm_signNotZero(vec3 value)
+{
+ return vec3(czm_signNotZero(value.x), czm_signNotZero(value.y), czm_signNotZero(value.z));
+}
+
+vec4 czm_signNotZero(vec4 value)
+{
+ return vec4(czm_signNotZero(value.x), czm_signNotZero(value.y), czm_signNotZero(value.z), czm_signNotZero(value.w));
+}
+`;var VIt=T(S(),1),RZ=`/**
+ * Computes a color from the third order spherical harmonic coefficients and a normalized direction vector.
+ *
+ * The order of the coefficients is [L00, L1_1, L10, L11, L2_2, L2_1, L20, L21, L22].
+ *
+ *
+ * @name czm_sphericalHarmonics
+ * @glslFunction
+ *
+ * @param {vec3} normal The normalized direction.
+ * @param {vec3[9]} coefficients The third order spherical harmonic coefficients.
+ * @returns {vec3} The color at the direction.
+ *
+ * @see https://graphics.stanford.edu/papers/envmap/envmap.pdf
+ */
+vec3 czm_sphericalHarmonics(vec3 normal, vec3 coefficients[9])
+{
+ vec3 L00 = coefficients[0];
+ vec3 L1_1 = coefficients[1];
+ vec3 L10 = coefficients[2];
+ vec3 L11 = coefficients[3];
+ vec3 L2_2 = coefficients[4];
+ vec3 L2_1 = coefficients[5];
+ vec3 L20 = coefficients[6];
+ vec3 L21 = coefficients[7];
+ vec3 L22 = coefficients[8];
+
+ float x = normal.x;
+ float y = normal.y;
+ float z = normal.z;
+
+ return
+ L00
+ + L1_1 * y
+ + L10 * z
+ + L11 * x
+ + L2_2 * (y * x)
+ + L2_1 * (y * z)
+ + L20 * (3.0 * z * z - 1.0)
+ + L21 * (z * x)
+ + L22 * (x * x - y * y);
+}
+`;var RIt=T(S(),1),ZZ=`/**
+ * Converts an sRGB color to a linear RGB color.
+ *
+ * @param {vec3|vec4} srgbIn The color in sRGB space
+ * @returns {vec3|vec4} The color in linear color space. The vector type matches the input.
+ */
+vec3 czm_srgbToLinear(vec3 srgbIn)
+{
+ return pow(srgbIn, vec3(2.2));
+}
+
+vec4 czm_srgbToLinear(vec4 srgbIn)
+{
+ vec3 linearOut = pow(srgbIn.rgb, vec3(2.2));
+ return vec4(linearOut, srgbIn.a);
+}
+`;var GIt=T(S(),1),GZ=`/**
+ * Creates a matrix that transforms vectors from tangent space to eye space.
+ *
+ * @name czm_tangentToEyeSpaceMatrix
+ * @glslFunction
+ *
+ * @param {vec3} normalEC The normal vector in eye coordinates.
+ * @param {vec3} tangentEC The tangent vector in eye coordinates.
+ * @param {vec3} bitangentEC The bitangent vector in eye coordinates.
+ *
+ * @returns {mat3} The matrix that transforms from tangent space to eye space.
+ *
+ * @example
+ * mat3 tangentToEye = czm_tangentToEyeSpaceMatrix(normalEC, tangentEC, bitangentEC);
+ * vec3 normal = tangentToEye * texture(normalMap, st).xyz;
+ */
+mat3 czm_tangentToEyeSpaceMatrix(vec3 normalEC, vec3 tangentEC, vec3 bitangentEC)
+{
+ vec3 normal = normalize(normalEC);
+ vec3 tangent = normalize(tangentEC);
+ vec3 bitangent = normalize(bitangentEC);
+ return mat3(tangent.x , tangent.y , tangent.z,
+ bitangent.x, bitangent.y, bitangent.z,
+ normal.x , normal.y , normal.z);
+}
+`;var XIt=T(S(),1),EZ=`/**
+ * A wrapper around the texture (WebGL2) / textureCube (WebGL1)
+ * function to allow for WebGL 1 support.
+ *
+ * @name czm_textureCube
+ * @glslFunction
+ *
+ * @param {samplerCube} sampler The sampler.
+ * @param {vec3} p The coordinates to sample the texture at.
+ */
+vec4 czm_textureCube(samplerCube sampler, vec3 p) {
+#if __VERSION__ == 300
+ return texture(sampler, p);
+#else
+ return textureCube(sampler, p);
+#endif
+}`;var WIt=T(S(),1),XZ=`/**
+ * Transforms a plane.
+ *
+ * @name czm_transformPlane
+ * @glslFunction
+ *
+ * @param {vec4} plane The plane in Hessian Normal Form.
+ * @param {mat4} transform The inverse-transpose of a transformation matrix.
+ */
+vec4 czm_transformPlane(vec4 plane, mat4 transform) {
+ vec4 transformedPlane = transform * plane;
+ // Convert the transformed plane to Hessian Normal Form
+ float normalMagnitude = length(transformedPlane.xyz);
+ return transformedPlane / normalMagnitude;
+}
+`;var vIt=T(S(),1),IZ=`/**
+ * Translates a position (or any vec3) that was encoded with {@link EncodedCartesian3},
+ * and then provided to the shader as separate high and low bits to
+ * be relative to the eye. As shown in the example, the position can then be transformed in eye
+ * or clip coordinates using {@link czm_modelViewRelativeToEye} or {@link czm_modelViewProjectionRelativeToEye},
+ * respectively.
+ *
+ * This technique, called GPU RTE, eliminates jittering artifacts when using large coordinates as
+ * described in {@link http://help.agi.com/AGIComponents/html/BlogPrecisionsPrecisions.htm|Precisions, Precisions}.
+ *
+ *
+ * @name czm_translateRelativeToEye
+ * @glslFunction
+ *
+ * @param {vec3} high The position's high bits.
+ * @param {vec3} low The position's low bits.
+ * @returns {vec3} The position translated to be relative to the camera's position.
+ *
+ * @example
+ * in vec3 positionHigh;
+ * in vec3 positionLow;
+ *
+ * void main()
+ * {
+ * vec4 p = czm_translateRelativeToEye(positionHigh, positionLow);
+ * gl_Position = czm_modelViewProjectionRelativeToEye * p;
+ * }
+ *
+ * @see czm_modelViewRelativeToEye
+ * @see czm_modelViewProjectionRelativeToEye
+ * @see czm_computePosition
+ * @see EncodedCartesian3
+ */
+vec4 czm_translateRelativeToEye(vec3 high, vec3 low)
+{
+ vec3 highDifference = high - czm_encodedCameraPositionMCHigh;
+ vec3 lowDifference = low - czm_encodedCameraPositionMCLow;
+
+ return vec4(highDifference + lowDifference, 1.0);
+}
+`;var wIt=T(S(),1),WZ=`/**
+ * @private
+ */
+vec4 czm_translucentPhong(vec3 toEye, czm_material material, vec3 lightDirectionEC)
+{
+ // Diffuse from directional light sources at eye (for top-down and horizon views)
+ float diffuse = czm_getLambertDiffuse(vec3(0.0, 0.0, 1.0), material.normal);
+
+ if (czm_sceneMode == czm_sceneMode3D) {
+ // (and horizon views in 3D)
+ diffuse += czm_getLambertDiffuse(vec3(0.0, 1.0, 0.0), material.normal);
+ }
+
+ diffuse = clamp(diffuse, 0.0, 1.0);
+
+ float specular = czm_getSpecular(lightDirectionEC, toEye, material.normal, material.shininess);
+
+ // Temporary workaround for adding ambient.
+ vec3 materialDiffuse = material.diffuse * 0.5;
+
+ vec3 ambient = materialDiffuse;
+ vec3 color = ambient + material.emission;
+ color += materialDiffuse * diffuse * czm_lightColor;
+ color += material.specular * specular * czm_lightColor;
+
+ return vec4(color, material.alpha);
+}
+`;var MIt=T(S(),1),PZ=`/**
+ * Returns the transpose of the matrix. The input matrix can be
+ * a mat2, mat3, or mat4.
+ *
+ * @name czm_transpose
+ * @glslFunction
+ *
+ * @param {} matrix The matrix to transpose.
+ *
+ * @returns {} The transposed matrix.
+ *
+ * @example
+ * // GLSL declarations
+ * mat2 czm_transpose(mat2 matrix);
+ * mat3 czm_transpose(mat3 matrix);
+ * mat4 czm_transpose(mat4 matrix);
+ *
+ * // Transpose a 3x3 rotation matrix to find its inverse.
+ * mat3 eastNorthUpToEye = czm_eastNorthUpToEyeCoordinates(
+ * positionMC, normalEC);
+ * mat3 eyeToEastNorthUp = czm_transpose(eastNorthUpToEye);
+ */
+mat2 czm_transpose(mat2 matrix)
+{
+ return mat2(
+ matrix[0][0], matrix[1][0],
+ matrix[0][1], matrix[1][1]);
+}
+
+mat3 czm_transpose(mat3 matrix)
+{
+ return mat3(
+ matrix[0][0], matrix[1][0], matrix[2][0],
+ matrix[0][1], matrix[1][1], matrix[2][1],
+ matrix[0][2], matrix[1][2], matrix[2][2]);
+}
+
+mat4 czm_transpose(mat4 matrix)
+{
+ return mat4(
+ matrix[0][0], matrix[1][0], matrix[2][0], matrix[3][0],
+ matrix[0][1], matrix[1][1], matrix[2][1], matrix[3][1],
+ matrix[0][2], matrix[1][2], matrix[2][2], matrix[3][2],
+ matrix[0][3], matrix[1][3], matrix[2][3], matrix[3][3]);
+}
+`;var UIt=T(S(),1),vZ=`/**
+ * Unpacks a vec4 depth value to a float in [0, 1) range.
+ *
+ * @name czm_unpackDepth
+ * @glslFunction
+ *
+ * @param {vec4} packedDepth The packed depth.
+ *
+ * @returns {float} The floating-point depth in [0, 1) range.
+ */
+ float czm_unpackDepth(vec4 packedDepth)
+ {
+ // See Aras Pranckevi\u010Dius' post Encoding Floats to RGBA
+ // http://aras-p.info/blog/2009/07/30/encoding-floats-to-rgba-the-final/
+ return dot(packedDepth, vec4(1.0, 1.0 / 255.0, 1.0 / 65025.0, 1.0 / 16581375.0));
+ }
+`;var DIt=T(S(),1),FZ=`/**
+ * Unpack an IEEE 754 single-precision float that is packed as a little-endian unsigned normalized vec4.
+ *
+ * @name czm_unpackFloat
+ * @glslFunction
+ *
+ * @param {vec4} packedFloat The packed float.
+ *
+ * @returns {float} The floating-point depth in arbitrary range.
+ */
+float czm_unpackFloat(vec4 packedFloat)
+{
+ // Convert to [0.0, 255.0] and round to integer
+ packedFloat = floor(packedFloat * 255.0 + 0.5);
+ float sign = 1.0 - step(128.0, packedFloat[3]) * 2.0;
+ float exponent = 2.0 * mod(packedFloat[3], 128.0) + step(128.0, packedFloat[2]) - 127.0;
+ if (exponent == -127.0)
+ {
+ return 0.0;
+ }
+ float mantissa = mod(packedFloat[2], 128.0) * 65536.0 + packedFloat[1] * 256.0 + packedFloat[0] + float(0x800000);
+ float result = sign * exp2(exponent - 23.0) * mantissa;
+ return result;
+}
+`;var YIt=T(S(),1),wZ=`/**
+ * Unpack unsigned integers of 1-4 bytes. in WebGL 1, there is no uint type,
+ * so the return value is an int.
+ *
+ * There are also precision limitations in WebGL 1. highp int is still limited
+ * to 24 bits. Above the value of 2^24 = 16777216, precision loss may occur.
+ *
+ *
+ * @param {float|vec2|vec3|vec4} packed The packed value. For vectors, the components are listed in little-endian order.
+ *
+ * @return {int} The unpacked value.
+ */
+ int czm_unpackUint(float packedValue) {
+ float rounded = czm_round(packedValue * 255.0);
+ return int(rounded);
+ }
+
+ int czm_unpackUint(vec2 packedValue) {
+ vec2 rounded = czm_round(packedValue * 255.0);
+ return int(dot(rounded, vec2(1.0, 256.0)));
+ }
+
+ int czm_unpackUint(vec3 packedValue) {
+ vec3 rounded = czm_round(packedValue * 255.0);
+ return int(dot(rounded, vec3(1.0, 256.0, 65536.0)));
+ }
+
+ int czm_unpackUint(vec4 packedValue) {
+ vec4 rounded = czm_round(packedValue * 255.0);
+ return int(dot(rounded, vec4(1.0, 256.0, 65536.0, 16777216.0)));
+ }
+`;var KIt=T(S(),1),AZ=`/**
+ * Transform metadata values following the EXT_structural_metadata spec
+ * by multiplying by scale and adding the offset. Operations are always
+ * performed component-wise, even for matrices.
+ *
+ * @param {float|vec2|vec3|vec4|mat2|mat3|mat4} offset The offset to add
+ * @param {float|vec2|vec3|vec4|mat2|mat3|mat4} scale The scale factor to multiply
+ * @param {float|vec2|vec3|vec4|mat2|mat3|mat4} value The original value.
+ *
+ * @return {float|vec2|vec3|vec4|mat2|mat3|mat4} The transformed value of the same scalar/vector/matrix type as the input.
+ */
+float czm_valueTransform(float offset, float scale, float value) {
+ return scale * value + offset;
+}
+
+vec2 czm_valueTransform(vec2 offset, vec2 scale, vec2 value) {
+ return scale * value + offset;
+}
+
+vec3 czm_valueTransform(vec3 offset, vec3 scale, vec3 value) {
+ return scale * value + offset;
+}
+
+vec4 czm_valueTransform(vec4 offset, vec4 scale, vec4 value) {
+ return scale * value + offset;
+}
+
+mat2 czm_valueTransform(mat2 offset, mat2 scale, mat2 value) {
+ return matrixCompMult(scale, value) + offset;
+}
+
+mat3 czm_valueTransform(mat3 offset, mat3 scale, mat3 value) {
+ return matrixCompMult(scale, value) + offset;
+}
+
+mat4 czm_valueTransform(mat4 offset, mat4 scale, mat4 value) {
+ return matrixCompMult(scale, value) + offset;
+}
+`;var zIt=T(S(),1),MZ=`#ifdef LOG_DEPTH
+// 1.0 at the near plane, increasing linearly from there.
+out float v_depthFromNearPlusOne;
+#ifdef SHADOW_MAP
+out vec3 v_logPositionEC;
+#endif
+#endif
+
+vec4 czm_updatePositionDepth(vec4 coords) {
+#if defined(LOG_DEPTH)
+
+#ifdef SHADOW_MAP
+ vec3 logPositionEC = (czm_inverseProjection * coords).xyz;
+ v_logPositionEC = logPositionEC;
+#endif
+
+ // With the very high far/near ratios used with the logarithmic depth
+ // buffer, floating point rounding errors can cause linear depth values
+ // to end up on the wrong side of the far plane, even for vertices that
+ // are really nowhere near it. Since we always write a correct logarithmic
+ // depth value in the fragment shader anyway, we just need to make sure
+ // such errors don't cause the primitive to be clipped entirely before
+ // we even get to the fragment shader.
+ coords.z = clamp(coords.z / coords.w, -1.0, 1.0) * coords.w;
+#endif
+
+ return coords;
+}
+
+/**
+ * Writes the logarithmic depth to gl_Position using the already computed gl_Position.
+ *
+ * @name czm_vertexLogDepth
+ * @glslFunction
+ */
+void czm_vertexLogDepth()
+{
+#ifdef LOG_DEPTH
+ v_depthFromNearPlusOne = (gl_Position.w - czm_currentFrustum.x) + 1.0;
+ gl_Position = czm_updatePositionDepth(gl_Position);
+#endif
+}
+
+/**
+ * Writes the logarithmic depth to gl_Position using the provided clip coordinates.
+ *
+ * An example use case for this function would be moving the vertex in window coordinates
+ * before converting back to clip coordinates. Use the original vertex clip coordinates.
+ *
+ * @name czm_vertexLogDepth
+ * @glslFunction
+ *
+ * @param {vec4} clipCoords The vertex in clip coordinates.
+ *
+ * @example
+ * czm_vertexLogDepth(czm_projection * vec4(positionEyeCoordinates, 1.0));
+ */
+void czm_vertexLogDepth(vec4 clipCoords)
+{
+#ifdef LOG_DEPTH
+ v_depthFromNearPlusOne = (clipCoords.w - czm_currentFrustum.x) + 1.0;
+ czm_updatePositionDepth(clipCoords);
+#endif
+}
+`;var QIt=T(S(),1),NZ=`vec4 czm_screenToEyeCoordinates(vec4 screenCoordinate)
+{
+ // Reconstruct NDC coordinates
+ float x = 2.0 * screenCoordinate.x - 1.0;
+ float y = 2.0 * screenCoordinate.y - 1.0;
+ float z = (screenCoordinate.z - czm_viewportTransformation[3][2]) / czm_viewportTransformation[2][2];
+ vec4 q = vec4(x, y, z, 1.0);
+
+ // Reverse the perspective division to obtain clip coordinates.
+ q /= screenCoordinate.w;
+
+ // Reverse the projection transformation to obtain eye coordinates.
+ if (!(czm_inverseProjection == mat4(0.0))) // IE and Edge sometimes do something weird with != between mat4s
+ {
+ q = czm_inverseProjection * q;
+ }
+ else
+ {
+ float top = czm_frustumPlanes.x;
+ float bottom = czm_frustumPlanes.y;
+ float left = czm_frustumPlanes.z;
+ float right = czm_frustumPlanes.w;
+
+ float near = czm_currentFrustum.x;
+ float far = czm_currentFrustum.y;
+
+ q.x = (q.x * (right - left) + left + right) * 0.5;
+ q.y = (q.y * (top - bottom) + bottom + top) * 0.5;
+ q.z = (q.z * (near - far) - near - far) * 0.5;
+ q.w = 1.0;
+ }
+
+ return q;
+}
+
+/**
+ * Transforms a position from window to eye coordinates.
+ * The transform from window to normalized device coordinates is done using components
+ * of (@link czm_viewport} and {@link czm_viewportTransformation} instead of calculating
+ * the inverse of czm_viewportTransformation. The transformation from
+ * normalized device coordinates to clip coordinates is done using fragmentCoordinate.w,
+ * which is expected to be the scalar used in the perspective divide. The transformation
+ * from clip to eye coordinates is done using {@link czm_inverseProjection}.
+ *
+ * @name czm_windowToEyeCoordinates
+ * @glslFunction
+ *
+ * @param {vec4} fragmentCoordinate The position in window coordinates to transform.
+ *
+ * @returns {vec4} The transformed position in eye coordinates.
+ *
+ * @see czm_modelToWindowCoordinates
+ * @see czm_eyeToWindowCoordinates
+ * @see czm_inverseProjection
+ * @see czm_viewport
+ * @see czm_viewportTransformation
+ *
+ * @example
+ * vec4 positionEC = czm_windowToEyeCoordinates(gl_FragCoord);
+ */
+vec4 czm_windowToEyeCoordinates(vec4 fragmentCoordinate)
+{
+ vec2 screenCoordXY = (fragmentCoordinate.xy - czm_viewport.xy) / czm_viewport.zw;
+ return czm_screenToEyeCoordinates(vec4(screenCoordXY, fragmentCoordinate.zw));
+}
+
+vec4 czm_screenToEyeCoordinates(vec2 screenCoordinateXY, float depthOrLogDepth)
+{
+ // See reverseLogDepth.glsl. This is separate to re-use the pow.
+#if defined(LOG_DEPTH) || defined(LOG_DEPTH_READ_ONLY)
+ float near = czm_currentFrustum.x;
+ float far = czm_currentFrustum.y;
+ float log2Depth = depthOrLogDepth * czm_log2FarDepthFromNearPlusOne;
+ float depthFromNear = pow(2.0, log2Depth) - 1.0;
+ float depthFromCamera = depthFromNear + near;
+ vec4 screenCoord = vec4(screenCoordinateXY, far * (1.0 - near / depthFromCamera) / (far - near), 1.0);
+ vec4 eyeCoordinate = czm_screenToEyeCoordinates(screenCoord);
+ eyeCoordinate.w = 1.0 / depthFromCamera; // Better precision
+ return eyeCoordinate;
+#else
+ vec4 screenCoord = vec4(screenCoordinateXY, depthOrLogDepth, 1.0);
+ vec4 eyeCoordinate = czm_screenToEyeCoordinates(screenCoord);
+#endif
+ return eyeCoordinate;
+}
+
+/**
+ * Transforms a position given as window x/y and a depth or a log depth from window to eye coordinates.
+ * This function produces more accurate results for window positions with log depth than
+ * conventionally unpacking the log depth using czm_reverseLogDepth and using the standard version
+ * of czm_windowToEyeCoordinates.
+ *
+ * @name czm_windowToEyeCoordinates
+ * @glslFunction
+ *
+ * @param {vec2} fragmentCoordinateXY The XY position in window coordinates to transform.
+ * @param {float} depthOrLogDepth A depth or log depth for the fragment.
+ *
+ * @see czm_modelToWindowCoordinates
+ * @see czm_eyeToWindowCoordinates
+ * @see czm_inverseProjection
+ * @see czm_viewport
+ * @see czm_viewportTransformation
+ *
+ * @returns {vec4} The transformed position in eye coordinates.
+ */
+vec4 czm_windowToEyeCoordinates(vec2 fragmentCoordinateXY, float depthOrLogDepth)
+{
+ vec2 screenCoordXY = (fragmentCoordinateXY.xy - czm_viewport.xy) / czm_viewport.zw;
+ return czm_screenToEyeCoordinates(screenCoordXY, depthOrLogDepth);
+}
+`;var qIt=T(S(),1),UZ=`// emulated noperspective
+#if !defined(LOG_DEPTH)
+in float v_WindowZ;
+#endif
+
+/**
+ * Emulates GL_DEPTH_CLAMP. Clamps a fragment to the near and far plane
+ * by writing the fragment's depth. See czm_depthClamp for more details.
+ *
+ * @name czm_writeDepthClamp
+ * @glslFunction
+ *
+ * @example
+ * out_FragColor = color;
+ * czm_writeDepthClamp();
+ *
+ * @see czm_depthClamp
+ */
+void czm_writeDepthClamp()
+{
+#if (!defined(LOG_DEPTH) && (__VERSION__ == 300 || defined(GL_EXT_frag_depth)))
+ gl_FragDepth = clamp(v_WindowZ * gl_FragCoord.w, 0.0, 1.0);
+#endif
+}
+`;var eWt=T(S(),1),kZ=`#ifdef LOG_DEPTH
+in float v_depthFromNearPlusOne;
+
+#ifdef POLYGON_OFFSET
+uniform vec2 u_polygonOffset;
+#endif
+
+#endif
+
+/**
+ * Writes the fragment depth to the logarithmic depth buffer.
+ *
+ * Use this when the vertex shader does not call {@link czm_vertexlogDepth}, for example, when
+ * ray-casting geometry using a full screen quad.
+ *
+ * @name czm_writeLogDepth
+ * @glslFunction
+ *
+ * @param {float} depth The depth coordinate, where 1.0 is on the near plane and
+ * depth increases in eye-space units from there
+ *
+ * @example
+ * czm_writeLogDepth((czm_projection * v_positionEyeCoordinates).w + 1.0);
+ */
+void czm_writeLogDepth(float depth)
+{
+#if (defined(LOG_DEPTH) && (__VERSION__ == 300 || defined(GL_EXT_frag_depth)))
+ // Discard the vertex if it's not between the near and far planes.
+ // We allow a bit of epsilon on the near plane comparison because a 1.0
+ // from the vertex shader (indicating the vertex should be _on_ the near
+ // plane) will not necessarily come here as exactly 1.0.
+ if (depth <= 0.9999999 || depth > czm_farDepthFromNearPlusOne) {
+ discard;
+ }
+
+#ifdef POLYGON_OFFSET
+ // Polygon offset: m * factor + r * units
+ float factor = u_polygonOffset[0];
+ float units = u_polygonOffset[1];
+
+#if (__VERSION__ == 300 || defined(GL_OES_standard_derivatives))
+ // This factor doesn't work in IE 10
+ if (factor != 0.0) {
+ // m = sqrt(dZdX^2 + dZdY^2);
+ float x = dFdx(depth);
+ float y = dFdy(depth);
+ float m = sqrt(x * x + y * y);
+
+ // Apply the factor before computing the log depth.
+ depth += m * factor;
+ }
+#endif
+
+#endif
+
+ gl_FragDepth = log2(depth) * czm_oneOverLog2FarDepthFromNearPlusOne;
+
+#ifdef POLYGON_OFFSET
+ // Apply the units after the log depth.
+ gl_FragDepth += czm_epsilon7 * units;
+#endif
+
+#endif
+}
+
+/**
+ * Writes the fragment depth to the logarithmic depth buffer.
+ *
+ * Use this when the vertex shader calls {@link czm_vertexlogDepth}.
+ *
+ *
+ * @name czm_writeLogDepth
+ * @glslFunction
+ */
+void czm_writeLogDepth() {
+#ifdef LOG_DEPTH
+ czm_writeLogDepth(v_depthFromNearPlusOne);
+#endif
+}
+`;var nWt=T(S(),1),DZ=`/**
+ * Transforms a value for non-perspective interpolation by multiplying
+ * it by w, the value used in the perspective divide. This function is
+ * intended to be called in a vertex shader to compute the value of a
+ * \`varying\` that should not be subject to perspective interpolation.
+ * For example, screen-space texture coordinates. The fragment shader
+ * must call {@link czm_readNonPerspective} to retrieve the final
+ * non-perspective value.
+ *
+ * @name czm_writeNonPerspective
+ * @glslFunction
+ *
+ * @param {float|vec2|vec3|vec4} value The value to be interpolated without accounting for perspective.
+ * @param {float} w The perspective divide value. Usually this is the computed \`gl_Position.w\`.
+ * @returns {float|vec2|vec3|vec4} The transformed value, intended to be stored in a \`varying\` and read in the
+ * fragment shader with {@link czm_readNonPerspective}.
+ */
+float czm_writeNonPerspective(float value, float w) {
+ return value * w;
+}
+
+vec2 czm_writeNonPerspective(vec2 value, float w) {
+ return value * w;
+}
+
+vec3 czm_writeNonPerspective(vec3 value, float w) {
+ return value * w;
+}
+
+vec4 czm_writeNonPerspective(vec4 value, float w) {
+ return value * w;
+}
+`;var vg={czm_degreesPerRadian:_L,czm_depthRange:TL,czm_epsilon1:SL,czm_epsilon2:CL,czm_epsilon3:VL,czm_epsilon4:LL,czm_epsilon5:RL,czm_epsilon6:ZL,czm_epsilon7:GL,czm_infinity:EL,czm_oneOverPi:XL,czm_oneOverTwoPi:IL,czm_passCesium3DTile:WL,czm_passCesium3DTileClassification:PL,czm_passCesium3DTileClassificationIgnoreShow:vL,czm_passClassification:FL,czm_passCompute:wL,czm_passEnvironment:AL,czm_passGlobe:ML,czm_passOpaque:NL,czm_passOverlay:UL,czm_passTerrainClassification:kL,czm_passTranslucent:DL,czm_passVoxels:BL,czm_pi:YL,czm_piOverFour:OL,czm_piOverSix:KL,czm_piOverThree:HL,czm_piOverTwo:zL,czm_radiansPerDegree:JL,czm_sceneMode2D:QL,czm_sceneMode3D:jL,czm_sceneModeColumbusView:qL,czm_sceneModeMorphing:$L,czm_solarRadius:eR,czm_threePiOver2:tR,czm_twoPi:nR,czm_webMercatorMaxLatitude:iR,czm_depthRangeStruct:oR,czm_material:rR,czm_materialInput:sR,czm_modelMaterial:aR,czm_modelVertexOutput:cR,czm_pbrParameters:lR,czm_ray:dR,czm_raySegment:uR,czm_shadowParameters:mR,czm_HSBToRGB:hR,czm_HSLToRGB:fR,czm_RGBToHSB:pR,czm_RGBToHSL:bR,czm_RGBToXYZ:yR,czm_XYZToRGB:gR,czm_acesTonemapping:xR,czm_alphaWeight:_R,czm_antialias:TR,czm_approximateSphericalCoordinates:SR,czm_backFacing:CR,czm_branchFreeTernary:VR,czm_cascadeColor:LR,czm_cascadeDistance:RR,czm_cascadeMatrix:ZR,czm_cascadeWeights:GR,czm_columbusViewMorph:ER,czm_computePosition:XR,czm_cosineAndSine:IR,czm_decompressTextureCoordinates:WR,czm_defaultPbrMaterial:PR,czm_depthClamp:vR,czm_eastNorthUpToEyeCoordinates:FR,czm_ellipsoidContainsPoint:wR,czm_ellipsoidWgs84TextureCoordinates:AR,czm_equalsEpsilon:MR,czm_eyeOffset:NR,czm_eyeToWindowCoordinates:UR,czm_fastApproximateAtan:kR,czm_fog:DR,czm_gammaCorrect:BR,czm_geodeticSurfaceNormal:YR,czm_getDefaultMaterial:OR,czm_getLambertDiffuse:KR,czm_getSpecular:HR,czm_getWaterNoise:zR,czm_hue:JR,czm_inverseGamma:QR,czm_isEmpty:jR,czm_isFull:qR,czm_latitudeToWebMercatorFraction:$R,czm_lineDistance:eZ,czm_linearToSrgb:tZ,czm_luminance:nZ,czm_metersPerPixel:iZ,czm_modelToWindowCoordinates:oZ,czm_multiplyWithColorBalance:rZ,czm_nearFarScalar:sZ,czm_octDecode:aZ,czm_packDepth:cZ,czm_pbrLighting:lZ,czm_pbrMetallicRoughnessMaterial:dZ,czm_pbrSpecularGlossinessMaterial:uZ,czm_phong:mZ,czm_planeDistance:hZ,czm_pointAlongRay:fZ,czm_rayEllipsoidIntersectionInterval:pZ,czm_raySphereIntersectionInterval:bZ,czm_readDepth:yZ,czm_readNonPerspective:gZ,czm_reverseLogDepth:xZ,czm_round:_Z,czm_sampleOctahedralProjection:TZ,czm_saturation:SZ,czm_shadowDepthCompare:CZ,czm_shadowVisibility:VZ,czm_signNotZero:LZ,czm_sphericalHarmonics:RZ,czm_srgbToLinear:ZZ,czm_tangentToEyeSpaceMatrix:GZ,czm_textureCube:EZ,czm_transformPlane:XZ,czm_translateRelativeToEye:IZ,czm_translucentPhong:WZ,czm_transpose:PZ,czm_unpackDepth:vZ,czm_unpackFloat:FZ,czm_unpackUint:wZ,czm_valueTransform:AZ,czm_vertexLogDepth:MZ,czm_windowToEyeCoordinates:NZ,czm_writeDepthClamp:UZ,czm_writeLogDepth:kZ,czm_writeNonPerspective:DZ};var EPt=T(S(),1);function r1e(e,t){let n=e;return n=n.replaceAll("version 300 es",""),n=n.replaceAll(/(texture\()/g,"texture2D("),t?(n=n.replaceAll(/(in)\s+(vec\d|mat\d|float)/g,"varying $2"),/out_FragData_(\d+)/.test(n)&&(n=`#extension GL_EXT_draw_buffers : enable
+${n}`,n=n.replaceAll(/layout\s+\(location\s*=\s*\d+\)\s*out\s+vec4\s+out_FragData_\d+;/g,""),n=n.replaceAll(/out_FragData_(\d+)/g,"gl_FragData[$1]")),n=n.replaceAll(/layout\s+\(location\s*=\s*0\)\s*out\s+vec4\s+out_FragColor;/g,""),n=n.replaceAll(/out_FragColor/g,"gl_FragColor"),n=n.replaceAll(/out_FragColor\[(\d+)\]/g,"gl_FragColor[$1]"),/gl_FragDepth/.test(n)&&(n=`#extension GL_EXT_frag_depth : enable
+${n}`,n=n.replaceAll(/gl_FragDepth/g,"gl_FragDepthEXT")),n=`#ifdef GL_OES_standard_derivatives
+#extension GL_OES_standard_derivatives : enable
+#endif
+${n}`):(n=n.replaceAll(/(in)\s+(vec\d|mat\d|float)/g,"attribute $2"),n=n.replaceAll(/(out)\s+(vec\d|mat\d|float)\s+([\w]+);/g,"varying $2 $3;")),n=`#version 100
+${n}`,n}var BZ=r1e;function H6(e){return e=e.replace(/\/\/.*/g,""),e.replace(/\/\*\*[\s\S]*?\*\//gm,function(t){let n=t.match(/\n/gm).length,i="";for(let o=0;o0;){let o=e.pop();n.push(o),o.requiredBy.length===0&&t.push(o)}for(;t.length>0;){let o=t.shift();e.push(o);for(let r=0;r=0;--o)i=`${i+t[o].glslSource}
+`;return i.replace(n.glslSource,"")}function Q6(e,t,n){let i,o,r="",s=e.sources;if(d(s))for(i=0,o=s.length;i-1&&i.derivedKeywords.splice(s,1)}return this.createDerivedShaderProgram(e,t,n)};im.prototype.getDerivedShaderProgram=function(e,t){let n=e._cachedShader,i=t+n.keyword,o=this._shaders[i];if(d(o))return o.shaderProgram};im.prototype.createDerivedShaderProgram=function(e,t,n){let i=e._cachedShader,o=t+i.keyword,r=n.vertexShaderSource,s=n.fragmentShaderSource,a=n.attributeLocations;typeof r=="string"&&(r=new Be({sources:[r]})),typeof s=="string"&&(s=new Be({sources:[s]}));let c=this._context,l=r.createCombinedVertexShader(c),u=s.createCombinedFragmentShader(c),m=new Qt({gl:c._gl,logShaderCompilation:c.logShaderCompilation,debugShaders:c.debugShaders,vertexShaderSource:r,vertexShaderText:l,fragmentShaderSource:s,fragmentShaderText:u,attributeLocations:a}),p={cache:this,shaderProgram:m,keyword:o,derivedKeywords:[],count:0};return i.derivedKeywords.push(t),m._cachedShader=p,this._shaders[o]=p,m};function kB(e,t){let n=t.derivedKeywords,i=n.length;for(let o=0;o=0?(n=Math.floor(e/65536)*65536,t.high=n,t.low=e-n):(n=Math.floor(-e/65536)*65536,t.high=-n,t.low=e+n),t};var ep={high:0,low:0};vh.fromCartesian=function(e,t){d(t)||(t=new vh);let n=t.high,i=t.low;return vh.encode(e.x,ep),n.x=ep.high,i.x=ep.low,vh.encode(e.y,ep),n.y=ep.high,i.y=ep.low,vh.encode(e.z,ep),n.z=ep.high,i.z=ep.low,t};var DB=new vh;vh.writeElements=function(e,t,n){vh.fromCartesian(e,DB);let i=DB.high,o=DB.low;t[n]=i.x,t[n+1]=i.y,t[n+2]=i.z,t[n+3]=o.x,t[n+4]=o.y,t[n+5]=o.z};var On=vh;var Mvt=T(S(),1);var Wvt=T(S(),1);var Cvt=T(S(),1);var pvt=T(S(),1);function _s(e,t){this.normal=h.clone(e),this.distance=t}_s.fromPointNormal=function(e,t,n){let i=-h.dot(t,e);return d(n)?(h.clone(t,n.normal),n.distance=i,n):new _s(t,i)};var m1e=new h;_s.fromCartesian4=function(e,t){let n=h.fromCartesian4(e,m1e),i=e.w;return d(t)?(h.clone(n,t.normal),t.distance=i,t):new _s(n,i)};_s.getPointDistance=function(e,t){return h.dot(e.normal,t)+e.distance};var h1e=new h;_s.projectPointOntoPlane=function(e,t,n){d(n)||(n=new h);let i=_s.getPointDistance(e,t),o=h.multiplyByScalar(e.normal,i,h1e);return h.subtract(t,o,n)};var f1e=new w,p1e=new se,b1e=new h;_s.transform=function(e,t,n){let i=e.normal,o=e.distance,r=w.inverseTranspose(t,f1e),s=se.fromElements(i.x,i.y,i.z,o,p1e);s=w.multiplyByVector(r,s,s);let a=h.fromCartesian4(s,b1e);return s=se.divideByScalar(s,h.magnitude(a),s),_s.fromCartesian4(s,n)};_s.clone=function(e,t){return d(t)?(h.clone(e.normal,t.normal),t.distance=e.distance,t):new _s(e.normal,e.distance)};_s.equals=function(e,t){return e.distance===t.distance&&h.equals(e.normal,t.normal)};_s.ORIGIN_XY_PLANE=Object.freeze(new _s(h.UNIT_Z,0));_s.ORIGIN_YZ_PLANE=Object.freeze(new _s(h.UNIT_X,0));_s.ORIGIN_ZX_PLANE=Object.freeze(new _s(h.UNIT_Y,0));var on=_s;function zd(e){this.planes=g(e,[])}var KZ=[new h,new h,new h];h.clone(h.UNIT_X,KZ[0]);h.clone(h.UNIT_Y,KZ[1]);h.clone(h.UNIT_Z,KZ[2]);var rb=new h,y1e=new h,$6=new on(new h(1,0,0),0);zd.fromBoundingSphere=function(e,t){d(t)||(t=new zd);let n=KZ.length,i=t.planes;i.length=2*n;let o=e.center,r=e.radius,s=0;for(let a=0;aG1e;++r){o=i;let s=o-t*Math.sin(o)-e,a=1-t*Math.cos(o);i=o-s/a}return o=i+n*W.TWO_PI,o}function X1e(e,t){let n=Math.floor(e/W.TWO_PI);e-=n*W.TWO_PI;let i=Math.cos(e)-t,o=Math.sin(e)*Math.sqrt(1-t*t),r=Math.atan2(o,i);return r=W.zeroToTwoPi(r),e<0&&(r-=W.TWO_PI),r+=n*W.TWO_PI,r}function I1e(e,t,n,i){let o=Math.cos(e),r=Math.sin(e),s=Math.cos(t),a=Math.sin(t),c=Math.cos(n),l=Math.sin(n);return d(i)?(i[0]=c*o-l*r*s,i[1]=l*o+c*r*s,i[2]=r*a,i[3]=-c*r-l*o*s,i[4]=-l*r+c*o*s,i[5]=o*a,i[6]=l*a,i[7]=-c*a,i[8]=s):i=new $(c*o-l*r*s,-c*r-l*o*s,l*a,l*o+c*r*s,-l*r+c*o*s,-c*a,r*a,o*a,s),i}var W1e=1.0000010178*ua,P1e=100.46645683*Jd,v1e=129597742283429e-5*Yl,nq=16002,iq=21863,oq=32004,rq=10931,sq=14529,aq=16368,cq=15318,lq=32794,F1e=64*1e-7*ua,w1e=-152*1e-7*ua,A1e=62*1e-7*ua,M1e=-8*1e-7*ua,N1e=32*1e-7*ua,U1e=-41*1e-7*ua,k1e=19*1e-7*ua,D1e=-11*1e-7*ua,B1e=-150*1e-7*ua,Y1e=-46*1e-7*ua,O1e=68*1e-7*ua,K1e=54*1e-7*ua,H1e=14*1e-7*ua,z1e=24*1e-7*ua,J1e=-28*1e-7*ua,Q1e=22*1e-7*ua,dq=10,uq=16002,mq=21863,hq=10931,fq=1473,pq=32004,bq=4387,yq=73,j1e=-325*1e-7,q1e=-322*1e-7,$1e=-79*1e-7,eVe=232*1e-7,tVe=-52*1e-7,nVe=97*1e-7,iVe=55*1e-7,oVe=-41*1e-7,rVe=-105*1e-7,sVe=-137*1e-7,aVe=258*1e-7,cVe=35*1e-7,lVe=-116*1e-7,dVe=-88*1e-7,uVe=-112*1e-7,mVe=-80*1e-7,cS=new te(0,0,Jn.TAI);function hVe(e,t){xq(e,cS);let i=(cS.dayNumber-HA.dayNumber+(cS.secondsOfDay-HA.secondsOfDay)/Qn.SECONDS_PER_DAY)/(Qn.DAYS_PER_JULIAN_CENTURY*10),o=.3595362*i,r=W1e+F1e*Math.cos(nq*o)+B1e*Math.sin(nq*o)+w1e*Math.cos(iq*o)+Y1e*Math.sin(iq*o)+A1e*Math.cos(oq*o)+O1e*Math.sin(oq*o)+M1e*Math.cos(rq*o)+K1e*Math.sin(rq*o)+N1e*Math.cos(sq*o)+H1e*Math.sin(sq*o)+U1e*Math.cos(aq*o)+z1e*Math.sin(aq*o)+k1e*Math.cos(cq*o)+J1e*Math.sin(cq*o)+D1e*Math.cos(lq*o)+Q1e*Math.sin(lq*o),s=P1e+v1e*i+j1e*Math.cos(dq*o)+rVe*Math.sin(dq*o)+q1e*Math.cos(uq*o)+sVe*Math.sin(uq*o)+$1e*Math.cos(mq*o)+aVe*Math.sin(mq*o)+eVe*Math.cos(hq*o)+cVe*Math.sin(hq*o)+tVe*Math.cos(fq*o)+lVe*Math.sin(fq*o)+nVe*Math.cos(pq*o)+dVe*Math.sin(pq*o)+iVe*Math.cos(bq*o)+uVe*Math.sin(bq*o)+oVe*Math.cos(yq*o)+mVe*Math.sin(yq*o),a=.0167086342-.0004203654*i,c=102.93734808*Jd+11612.3529*Yl*i,l=469.97289*Yl*i,u=174.87317577*Jd-8679.27034*Yl*i;return _q(r,a,l,c,u,s,t)}function Tq(e,t){xq(e,cS);let i=(cS.dayNumber-HA.dayNumber+(cS.secondsOfDay-HA.secondsOfDay)/Qn.SECONDS_PER_DAY)/Qn.DAYS_PER_JULIAN_CENTURY,o=i*i,r=o*i,s=r*i,a=383397.7725+.004*i,c=.055545526-16e-9*i,l=5.15668983*Jd,u=-8e-5*i+.02966*o-42e-6*r-13e-8*s,m=83.35324312*Jd,p=146434202669e-4*i-38.2702*o-.045047*r+21301e-8*s,y=125.04455501*Jd,f=-69679193631e-4*i+6.3602*o+.007625*r-3586e-8*s,x=218.31664563*Jd,_=17325593434847e-4*i-6.391*o+.006588*r-3169e-8*s,C=297.85019547*Jd+Yl*(1602961601209e-3*i-6.3706*o+.006593*r-3169e-8*s),V=93.27209062*Jd+Yl*(17395272628478e-4*i-12.7512*o-.001037*r+417e-8*s),L=134.96340251*Jd+Yl*(17179159232178e-4*i+31.8792*o+.051635*r-2447e-7*s),Z=357.52910918*Jd+Yl*(1295965810481e-4*i-.5532*o+136e-6*r-1149e-8*s),G=310.17137918*Jd-Yl*(6967051436e-3*i+6.2068*o+.007618*r-3219e-8*s),X=2*C,P=4*C,v=6*C,A=2*L,M=3*L,b=4*L,R=2*V;a+=3400.4*Math.cos(X)-635.6*Math.cos(X-L)-235.6*Math.cos(L)+218.1*Math.cos(X-Z)+181*Math.cos(X+L),c+=.014216*Math.cos(X-L)+.008551*Math.cos(X-A)-.001383*Math.cos(L)+.001356*Math.cos(X+L)-.001147*Math.cos(P-M)-914e-6*Math.cos(P-A)+869e-6*Math.cos(X-Z-L)-627e-6*Math.cos(X)-394e-6*Math.cos(P-b)+282e-6*Math.cos(X-Z-A)-279e-6*Math.cos(C-L)-236e-6*Math.cos(A)+231e-6*Math.cos(P)+229e-6*Math.cos(v-b)-201e-6*Math.cos(A-R),u+=486.26*Math.cos(X-R)-40.13*Math.cos(X)+37.51*Math.cos(R)+25.73*Math.cos(A-R)+19.97*Math.cos(X-Z-R),p+=-55609*Math.sin(X-L)-34711*Math.sin(X-A)-9792*Math.sin(L)+9385*Math.sin(P-M)+7505*Math.sin(P-A)+5318*Math.sin(X+L)+3484*Math.sin(P-b)-3417*Math.sin(X-Z-L)-2530*Math.sin(v-b)-2376*Math.sin(X)-2075*Math.sin(X-M)-1883*Math.sin(A)-1736*Math.sin(v-5*L)+1626*Math.sin(Z)-1370*Math.sin(v-M),f+=-5392*Math.sin(X-R)-540*Math.sin(Z)-441*Math.sin(X)+423*Math.sin(R)-288*Math.sin(A-R),_+=-3332.9*Math.sin(X)+1197.4*Math.sin(X-L)-662.5*Math.sin(Z)+396.3*Math.sin(L)-218*Math.sin(X-Z);let E=2*G,I=3*G;u+=46.997*Math.cos(G)*i-.614*Math.cos(X-R+G)*i+.614*Math.cos(X-R-G)*i-.0297*Math.cos(E)*o-.0335*Math.cos(G)*o+.0012*Math.cos(X-R+E)*o-16e-5*Math.cos(G)*r+4e-5*Math.cos(I)*r+4e-5*Math.cos(E)*r;let F=2.116*Math.sin(G)*i-.111*Math.sin(X-R-G)*i-.0015*Math.sin(G)*o;p+=F,_+=F,f+=-520.77*Math.sin(G)*i+13.66*Math.sin(X-R+G)*i+1.12*Math.sin(X-G)*i-1.06*Math.sin(R-G)*i+.66*Math.sin(E)*o+.371*Math.sin(G)*o-.035*Math.sin(X-R+E)*o-.015*Math.sin(X-R+G)*o+.0014*Math.sin(G)*r-.0011*Math.sin(I)*r-9e-4*Math.sin(E)*r,a*=V1e;let N=l+u*Yl,Y=m+p*Yl,k=x+_*Yl,O=y+f*Yl;return _q(a,c,N,Y,O,k,t)}var gq=.012300034,fVe=gq/(gq+1)*-1;function pVe(e,t){return t=Tq(e,t),h.multiplyByScalar(t,fVe,t)}var Sq=new $(1.0000000000000002,5619723173785822e-31,4690511510146299e-34,-5154129427414611e-31,.9174820620691819,-.39777715593191376,-223970096136568e-30,.39777715593191376,.9174820620691819),HZ=new h;YB.computeSunPositionInEarthInertialFrame=function(e,t){return d(e)||(e=te.now()),d(t)||(t=new h),HZ=hVe(e,HZ),t=h.negate(HZ,t),pVe(e,HZ),h.subtract(t,HZ,t),$.multiplyByVector(Sq,t,t),t};YB.computeMoonPositionInEarthInertialFrame=function(e,t){return d(e)||(e=te.now()),t=Tq(e,t),$.multiplyByVector(Sq,t,t),t};var ab=YB;var Jvt=T(S(),1),zA={MORPHING:0,COLUMBUS_VIEW:1,SCENE2D:2,SCENE3D:3};zA.getMorphTime=function(e){return e===zA.SCENE3D?1:e===zA.MORPHING?void 0:0};var ie=Object.freeze(zA);var $vt=T(S(),1);function bVe(e){e=g(e,g.EMPTY_OBJECT),this.color=B.clone(g(e.color,B.WHITE)),this.intensity=g(e.intensity,2)}var tp=bVe;function lS(){this.globeDepthTexture=void 0,this.gamma=void 0,this._viewport=new He,this._viewportCartesian4=new se,this._viewportDirty=!1,this._viewportOrthographicMatrix=w.clone(w.IDENTITY),this._viewportTransformation=w.clone(w.IDENTITY),this._model=w.clone(w.IDENTITY),this._view=w.clone(w.IDENTITY),this._inverseView=w.clone(w.IDENTITY),this._projection=w.clone(w.IDENTITY),this._infiniteProjection=w.clone(w.IDENTITY),this._entireFrustum=new D,this._currentFrustum=new D,this._frustumPlanes=new se,this._farDepthFromNearPlusOne=void 0,this._log2FarDepthFromNearPlusOne=void 0,this._oneOverLog2FarDepthFromNearPlusOne=void 0,this._frameState=void 0,this._temeToPseudoFixed=$.clone(w.IDENTITY),this._view3DDirty=!0,this._view3D=new w,this._inverseView3DDirty=!0,this._inverseView3D=new w,this._inverseModelDirty=!0,this._inverseModel=new w,this._inverseTransposeModelDirty=!0,this._inverseTransposeModel=new $,this._viewRotation=new $,this._inverseViewRotation=new $,this._viewRotation3D=new $,this._inverseViewRotation3D=new $,this._inverseProjectionDirty=!0,this._inverseProjection=new w,this._modelViewDirty=!0,this._modelView=new w,this._modelView3DDirty=!0,this._modelView3D=new w,this._modelViewRelativeToEyeDirty=!0,this._modelViewRelativeToEye=new w,this._inverseModelViewDirty=!0,this._inverseModelView=new w,this._inverseModelView3DDirty=!0,this._inverseModelView3D=new w,this._viewProjectionDirty=!0,this._viewProjection=new w,this._inverseViewProjectionDirty=!0,this._inverseViewProjection=new w,this._modelViewProjectionDirty=!0,this._modelViewProjection=new w,this._inverseModelViewProjectionDirty=!0,this._inverseModelViewProjection=new w,this._modelViewProjectionRelativeToEyeDirty=!0,this._modelViewProjectionRelativeToEye=new w,this._modelViewInfiniteProjectionDirty=!0,this._modelViewInfiniteProjection=new w,this._normalDirty=!0,this._normal=new $,this._normal3DDirty=!0,this._normal3D=new $,this._inverseNormalDirty=!0,this._inverseNormal=new $,this._inverseNormal3DDirty=!0,this._inverseNormal3D=new $,this._encodedCameraPositionMCDirty=!0,this._encodedCameraPositionMC=new On,this._cameraPosition=new h,this._sunPositionWC=new h,this._sunPositionColumbusView=new h,this._sunDirectionWC=new h,this._sunDirectionEC=new h,this._moonDirectionEC=new h,this._lightDirectionWC=new h,this._lightDirectionEC=new h,this._lightColor=new h,this._lightColorHdr=new h,this._pass=void 0,this._mode=void 0,this._mapProjection=void 0,this._ellipsoid=void 0,this._cameraDirection=new h,this._cameraRight=new h,this._cameraUp=new h,this._frustum2DWidth=0,this._eyeHeight=0,this._eyeHeight2D=new D,this._pixelRatio=1,this._orthographicIn3D=!1,this._backgroundColor=new B,this._brdfLut=void 0,this._environmentMap=void 0,this._sphericalHarmonicCoefficients=void 0,this._specularEnvironmentMaps=void 0,this._specularEnvironmentMapsDimensions=new D,this._specularEnvironmentMapsMaximumLOD=void 0,this._fogDensity=void 0,this._invertClassificationColor=void 0,this._splitPosition=0,this._pixelSizePerMeter=void 0,this._geometricToleranceOverMeter=void 0,this._minimumDisableDepthTestDistance=void 0}Object.defineProperties(lS.prototype,{frameState:{get:function(){return this._frameState}},viewport:{get:function(){return this._viewport},set:function(e){if(!He.equals(e,this._viewport)){He.clone(e,this._viewport);let t=this._viewport,n=this._viewportCartesian4;n.x=t.x,n.y=t.y,n.z=t.width,n.w=t.height,this._viewportDirty=!0}}},viewportCartesian4:{get:function(){return this._viewportCartesian4}},viewportOrthographic:{get:function(){return Cq(this),this._viewportOrthographicMatrix}},viewportTransformation:{get:function(){return Cq(this),this._viewportTransformation}},model:{get:function(){return this._model},set:function(e){w.clone(e,this._model),this._modelView3DDirty=!0,this._inverseModelView3DDirty=!0,this._inverseModelDirty=!0,this._inverseTransposeModelDirty=!0,this._modelViewDirty=!0,this._inverseModelViewDirty=!0,this._modelViewRelativeToEyeDirty=!0,this._inverseModelViewDirty=!0,this._modelViewProjectionDirty=!0,this._inverseModelViewProjectionDirty=!0,this._modelViewProjectionRelativeToEyeDirty=!0,this._modelViewInfiniteProjectionDirty=!0,this._normalDirty=!0,this._inverseNormalDirty=!0,this._normal3DDirty=!0,this._inverseNormal3DDirty=!0,this._encodedCameraPositionMCDirty=!0}},inverseModel:{get:function(){return this._inverseModelDirty&&(this._inverseModelDirty=!1,w.inverse(this._model,this._inverseModel)),this._inverseModel}},inverseTransposeModel:{get:function(){let e=this._inverseTransposeModel;return this._inverseTransposeModelDirty&&(this._inverseTransposeModelDirty=!1,w.getMatrix3(this.inverseModel,e),$.transpose(e,e)),e}},view:{get:function(){return this._view}},view3D:{get:function(){return OB(this),this._view3D}},viewRotation:{get:function(){return OB(this),this._viewRotation}},viewRotation3D:{get:function(){return OB(this),this._viewRotation3D}},inverseView:{get:function(){return this._inverseView}},inverseView3D:{get:function(){return Rq(this),this._inverseView3D}},inverseViewRotation:{get:function(){return this._inverseViewRotation}},inverseViewRotation3D:{get:function(){return Rq(this),this._inverseViewRotation3D}},projection:{get:function(){return this._projection}},inverseProjection:{get:function(){return RVe(this),this._inverseProjection}},infiniteProjection:{get:function(){return this._infiniteProjection}},modelView:{get:function(){return ZVe(this),this._modelView}},modelView3D:{get:function(){return GVe(this),this._modelView3D}},modelViewRelativeToEye:{get:function(){return vVe(this),this._modelViewRelativeToEye}},inverseModelView:{get:function(){return EVe(this),this._inverseModelView}},inverseModelView3D:{get:function(){return XVe(this),this._inverseModelView3D}},viewProjection:{get:function(){return IVe(this),this._viewProjection}},inverseViewProjection:{get:function(){return WVe(this),this._inverseViewProjection}},modelViewProjection:{get:function(){return PVe(this),this._modelViewProjection}},inverseModelViewProjection:{get:function(){return FVe(this),this._inverseModelViewProjection}},modelViewProjectionRelativeToEye:{get:function(){return wVe(this),this._modelViewProjectionRelativeToEye}},modelViewInfiniteProjection:{get:function(){return AVe(this),this._modelViewInfiniteProjection}},normal:{get:function(){return MVe(this),this._normal}},normal3D:{get:function(){return NVe(this),this._normal3D}},inverseNormal:{get:function(){return UVe(this),this._inverseNormal}},inverseNormal3D:{get:function(){return kVe(this),this._inverseNormal3D}},entireFrustum:{get:function(){return this._entireFrustum}},currentFrustum:{get:function(){return this._currentFrustum}},frustumPlanes:{get:function(){return this._frustumPlanes}},farDepthFromNearPlusOne:{get:function(){return this._farDepthFromNearPlusOne}},log2FarDepthFromNearPlusOne:{get:function(){return this._log2FarDepthFromNearPlusOne}},oneOverLog2FarDepthFromNearPlusOne:{get:function(){return this._oneOverLog2FarDepthFromNearPlusOne}},eyeHeight:{get:function(){return this._eyeHeight}},eyeHeight2D:{get:function(){return this._eyeHeight2D}},sunPositionWC:{get:function(){return this._sunPositionWC}},sunPositionColumbusView:{get:function(){return this._sunPositionColumbusView}},sunDirectionWC:{get:function(){return this._sunDirectionWC}},sunDirectionEC:{get:function(){return this._sunDirectionEC}},moonDirectionEC:{get:function(){return this._moonDirectionEC}},lightDirectionWC:{get:function(){return this._lightDirectionWC}},lightDirectionEC:{get:function(){return this._lightDirectionEC}},lightColor:{get:function(){return this._lightColor}},lightColorHdr:{get:function(){return this._lightColorHdr}},encodedCameraPositionMCHigh:{get:function(){return Lq(this),this._encodedCameraPositionMC.high}},encodedCameraPositionMCLow:{get:function(){return Lq(this),this._encodedCameraPositionMC.low}},temeToPseudoFixedMatrix:{get:function(){return this._temeToPseudoFixed}},pixelRatio:{get:function(){return this._pixelRatio}},fogDensity:{get:function(){return this._fogDensity}},geometricToleranceOverMeter:{get:function(){return this._geometricToleranceOverMeter}},pass:{get:function(){return this._pass}},backgroundColor:{get:function(){return this._backgroundColor}},brdfLut:{get:function(){return this._brdfLut}},environmentMap:{get:function(){return this._environmentMap}},sphericalHarmonicCoefficients:{get:function(){return this._sphericalHarmonicCoefficients}},specularEnvironmentMaps:{get:function(){return this._specularEnvironmentMaps}},specularEnvironmentMapsDimensions:{get:function(){return this._specularEnvironmentMapsDimensions}},specularEnvironmentMapsMaximumLOD:{get:function(){return this._specularEnvironmentMapsMaximumLOD}},splitPosition:{get:function(){return this._splitPosition}},minimumDisableDepthTestDistance:{get:function(){return this._minimumDisableDepthTestDistance}},invertClassificationColor:{get:function(){return this._invertClassificationColor}},orthographicIn3D:{get:function(){return this._orthographicIn3D}},ellipsoid:{get:function(){return g(this._ellipsoid,re.WGS84)}}});function yVe(e,t){w.clone(t,e._view),w.getMatrix3(t,e._viewRotation),e._view3DDirty=!0,e._inverseView3DDirty=!0,e._modelViewDirty=!0,e._modelView3DDirty=!0,e._modelViewRelativeToEyeDirty=!0,e._inverseModelViewDirty=!0,e._inverseModelView3DDirty=!0,e._viewProjectionDirty=!0,e._inverseViewProjectionDirty=!0,e._modelViewProjectionDirty=!0,e._modelViewProjectionRelativeToEyeDirty=!0,e._modelViewInfiniteProjectionDirty=!0,e._normalDirty=!0,e._inverseNormalDirty=!0,e._normal3DDirty=!0,e._inverseNormal3DDirty=!0}function gVe(e,t){w.clone(t,e._inverseView),w.getMatrix3(t,e._inverseViewRotation)}function xVe(e,t){w.clone(t,e._projection),e._inverseProjectionDirty=!0,e._viewProjectionDirty=!0,e._inverseViewProjectionDirty=!0,e._modelViewProjectionDirty=!0,e._modelViewProjectionRelativeToEyeDirty=!0}function _Ve(e,t){w.clone(t,e._infiniteProjection),e._modelViewInfiniteProjectionDirty=!0}function TVe(e,t){h.clone(t.positionWC,e._cameraPosition),h.clone(t.directionWC,e._cameraDirection),h.clone(t.rightWC,e._cameraRight),h.clone(t.upWC,e._cameraUp);let n=t.positionCartographic;d(n)?e._eyeHeight=n.height:e._eyeHeight=-e._ellipsoid.maximumRadius,e._encodedCameraPositionMCDirty=!0}var zZ=new $,SVe=new he;function CVe(e,t){d(vt.computeIcrfToFixedMatrix(t.time,zZ))||(zZ=vt.computeTemeToPseudoFixedMatrix(t.time,zZ));let n=ab.computeSunPositionInEarthInertialFrame(t.time,e._sunPositionWC);$.multiplyByVector(zZ,n,n),h.normalize(n,e._sunDirectionWC),n=$.multiplyByVector(e.viewRotation3D,n,e._sunDirectionEC),h.normalize(n,n),n=ab.computeMoonPositionInEarthInertialFrame(t.time,e._moonDirectionEC),$.multiplyByVector(zZ,n,n),$.multiplyByVector(e.viewRotation3D,n,n),h.normalize(n,n);let i=t.mapProjection,r=i.ellipsoid.cartesianToCartographic(e._sunPositionWC,SVe);i.project(r,e._sunPositionColumbusView)}lS.prototype.updateCamera=function(e){yVe(this,e.viewMatrix),gVe(this,e.inverseViewMatrix),TVe(this,e),this._entireFrustum.x=e.frustum.near,this._entireFrustum.y=e.frustum.far,this.updateFrustum(e.frustum),this._orthographicIn3D=this._mode!==ie.SCENE2D&&e.frustum instanceof en};lS.prototype.updateFrustum=function(e){xVe(this,e.projectionMatrix),d(e.infiniteProjectionMatrix)&&_Ve(this,e.infiniteProjectionMatrix),this._currentFrustum.x=e.near,this._currentFrustum.y=e.far,this._farDepthFromNearPlusOne=e.far-e.near+1,this._log2FarDepthFromNearPlusOne=W.log2(this._farDepthFromNearPlusOne),this._oneOverLog2FarDepthFromNearPlusOne=1/this._log2FarDepthFromNearPlusOne;let t=e.offCenterFrustum;d(t)&&(e=t),this._frustumPlanes.x=e.top,this._frustumPlanes.y=e.bottom,this._frustumPlanes.z=e.left,this._frustumPlanes.w=e.right};lS.prototype.updatePass=function(e){this._pass=e};var VVe=[],LVe=new tp;lS.prototype.update=function(e){this._mode=e.mode,this._mapProjection=e.mapProjection,this._ellipsoid=e.mapProjection.ellipsoid,this._pixelRatio=e.pixelRatio;let t=e.camera;this.updateCamera(t),e.mode===ie.SCENE2D?(this._frustum2DWidth=t.frustum.right-t.frustum.left,this._eyeHeight2D.x=this._frustum2DWidth*.5,this._eyeHeight2D.y=this._eyeHeight2D.x*this._eyeHeight2D.x):(this._frustum2DWidth=0,this._eyeHeight2D.x=0,this._eyeHeight2D.y=0),CVe(this,e);let n=g(e.light,LVe);n instanceof tp?(this._lightDirectionWC=h.clone(this._sunDirectionWC,this._lightDirectionWC),this._lightDirectionEC=h.clone(this._sunDirectionEC,this._lightDirectionEC)):(this._lightDirectionWC=h.normalize(h.negate(n.direction,this._lightDirectionWC),this._lightDirectionWC),this._lightDirectionEC=$.multiplyByVector(this.viewRotation3D,this._lightDirectionWC,this._lightDirectionEC));let i=n.color,o=h.fromElements(i.red,i.green,i.blue,this._lightColorHdr);o=h.multiplyByScalar(o,n.intensity,o);let r=h.maximumComponent(o);r>1?h.divideByScalar(o,r,this._lightColor):h.clone(o,this._lightColor);let s=e.brdfLutGenerator,a=d(s)?s.colorTexture:void 0;this._brdfLut=a,this._environmentMap=g(e.environmentMap,e.context.defaultCubeMap),this._sphericalHarmonicCoefficients=g(e.sphericalHarmonicCoefficients,VVe),this._specularEnvironmentMaps=e.specularEnvironmentMaps,this._specularEnvironmentMapsMaximumLOD=e.specularEnvironmentMapsMaximumLOD,d(this._specularEnvironmentMaps)&&D.clone(this._specularEnvironmentMaps.dimensions,this._specularEnvironmentMapsDimensions),this._fogDensity=e.fog.density,this._invertClassificationColor=e.invertClassificationColor,this._frameState=e,this._temeToPseudoFixed=vt.computeTemeToPseudoFixedMatrix(e.time,this._temeToPseudoFixed),this._splitPosition=e.splitPosition*e.context.drawingBufferWidth;let c=t.frustum.fov,l=this._viewport,u;d(c)?l.height>l.width?u=Math.tan(.5*c)*2/l.height:u=Math.tan(.5*c)*2/l.width:u=1/Math.max(l.width,l.height),this._geometricToleranceOverMeter=u*e.maximumScreenSpaceError,B.clone(e.backgroundColor,this._backgroundColor),this._minimumDisableDepthTestDistance=e.minimumDisableDepthTestDistance,this._minimumDisableDepthTestDistance*=this._minimumDisableDepthTestDistance,this._minimumDisableDepthTestDistance===Number.POSITIVE_INFINITY&&(this._minimumDisableDepthTestDistance=-1)};function Cq(e){if(e._viewportDirty){let t=e._viewport;w.computeOrthographicOffCenter(t.x,t.x+t.width,t.y,t.y+t.height,0,1,e._viewportOrthographicMatrix),w.computeViewportTransformation(t,0,1,e._viewportTransformation),e._viewportDirty=!1}}function RVe(e){e._inverseProjectionDirty&&(e._inverseProjectionDirty=!1,e._mode!==ie.SCENE2D&&e._mode!==ie.MORPHING&&!e._orthographicIn3D?w.inverse(e._projection,e._inverseProjection):w.clone(w.ZERO,e._inverseProjection))}function ZVe(e){e._modelViewDirty&&(e._modelViewDirty=!1,w.multiplyTransformation(e._view,e._model,e._modelView))}function GVe(e){e._modelView3DDirty&&(e._modelView3DDirty=!1,w.multiplyTransformation(e.view3D,e._model,e._modelView3D))}function EVe(e){e._inverseModelViewDirty&&(e._inverseModelViewDirty=!1,w.inverse(e.modelView,e._inverseModelView))}function XVe(e){e._inverseModelView3DDirty&&(e._inverseModelView3DDirty=!1,w.inverse(e.modelView3D,e._inverseModelView3D))}function IVe(e){e._viewProjectionDirty&&(e._viewProjectionDirty=!1,w.multiply(e._projection,e._view,e._viewProjection))}function WVe(e){e._inverseViewProjectionDirty&&(e._inverseViewProjectionDirty=!1,w.inverse(e.viewProjection,e._inverseViewProjection))}function PVe(e){e._modelViewProjectionDirty&&(e._modelViewProjectionDirty=!1,w.multiply(e._projection,e.modelView,e._modelViewProjection))}function vVe(e){if(e._modelViewRelativeToEyeDirty){e._modelViewRelativeToEyeDirty=!1;let t=e.modelView,n=e._modelViewRelativeToEye;n[0]=t[0],n[1]=t[1],n[2]=t[2],n[3]=t[3],n[4]=t[4],n[5]=t[5],n[6]=t[6],n[7]=t[7],n[8]=t[8],n[9]=t[9],n[10]=t[10],n[11]=t[11],n[12]=0,n[13]=0,n[14]=0,n[15]=t[15]}}function FVe(e){e._inverseModelViewProjectionDirty&&(e._inverseModelViewProjectionDirty=!1,w.inverse(e.modelViewProjection,e._inverseModelViewProjection))}function wVe(e){e._modelViewProjectionRelativeToEyeDirty&&(e._modelViewProjectionRelativeToEyeDirty=!1,w.multiply(e._projection,e.modelViewRelativeToEye,e._modelViewProjectionRelativeToEye))}function AVe(e){e._modelViewInfiniteProjectionDirty&&(e._modelViewInfiniteProjectionDirty=!1,w.multiply(e._infiniteProjection,e.modelView,e._modelViewInfiniteProjection))}function MVe(e){if(e._normalDirty){e._normalDirty=!1;let t=e._normal;w.getMatrix3(e.inverseModelView,t),$.transpose(t,t)}}function NVe(e){if(e._normal3DDirty){e._normal3DDirty=!1;let t=e._normal3D;w.getMatrix3(e.inverseModelView3D,t),$.transpose(t,t)}}function UVe(e){if(e._inverseNormalDirty){e._inverseNormalDirty=!1;let t=e._inverseNormal;w.getMatrix3(e.modelView,t),$.transpose(t,t)}}function kVe(e){if(e._inverseNormal3DDirty){e._inverseNormal3DDirty=!1;let t=e._inverseNormal3D;w.getMatrix3(e.modelView3D,t),$.transpose(t,t)}}var Vq=new h;function Lq(e){e._encodedCameraPositionMCDirty&&(e._encodedCameraPositionMCDirty=!1,w.multiplyByPoint(e.inverseModel,e._cameraPosition,Vq),On.fromCartesian(Vq,e._encodedCameraPositionMC))}var DVe=new h,BVe=new h,YVe=new h,OVe=new h,KVe=new he,HVe=new h,zVe=new w;function JVe(e,t,n,i,o,r,s,a){let c=DVe;c.x=e.y,c.y=e.z,c.z=e.x;let l=BVe;l.x=n.y,l.y=n.z,l.z=n.x;let u=YVe;u.x=i.y,u.y=i.z,u.z=i.x;let m=OVe;m.x=t.y,m.y=t.z,m.z=t.x,r===ie.SCENE2D&&(c.z=o*.5);let p=s.unproject(c,KVe);p.longitude=W.clamp(p.longitude,-Math.PI,Math.PI),p.latitude=W.clamp(p.latitude,-W.PI_OVER_TWO,W.PI_OVER_TWO);let y=s.ellipsoid,f=y.cartographicToCartesian(p,HVe),x=vt.eastNorthUpToFixedFrame(f,y,zVe);return w.multiplyByPointAsVector(x,l,l),w.multiplyByPointAsVector(x,u,u),w.multiplyByPointAsVector(x,m,m),d(a)||(a=new w),a[0]=l.x,a[1]=u.x,a[2]=-m.x,a[3]=0,a[4]=l.y,a[5]=u.y,a[6]=-m.y,a[7]=0,a[8]=l.z,a[9]=u.z,a[10]=-m.z,a[11]=0,a[12]=-h.dot(l,f),a[13]=-h.dot(u,f),a[14]=h.dot(m,f),a[15]=1,a}function OB(e){e._view3DDirty&&(e._mode===ie.SCENE3D?w.clone(e._view,e._view3D):JVe(e._cameraPosition,e._cameraDirection,e._cameraRight,e._cameraUp,e._frustum2DWidth,e._mode,e._mapProjection,e._view3D),w.getMatrix3(e._view3D,e._viewRotation3D),e._view3DDirty=!1)}function Rq(e){e._inverseView3DDirty&&(w.inverseTransformation(e.view3D,e._inverseView3D),w.getMatrix3(e._inverseView3D,e._inverseViewRotation3D),e._inverseView3DDirty=!1)}var JZ=lS;var WFt=T(S(),1);function QVe(e,t,n,i){let o=d(t.vertexBuffer),r=d(t.value),s=t.value?t.value.length:t.componentsPerAttribute,a={index:g(t.index,n),enabled:g(t.enabled,!0),vertexBuffer:t.vertexBuffer,value:r?t.value.slice(0):void 0,componentsPerAttribute:s,componentDatatype:g(t.componentDatatype,Q.FLOAT),normalize:g(t.normalize,!1),offsetInBytes:g(t.offsetInBytes,0),strideInBytes:g(t.strideInBytes,0),instanceDivisor:g(t.instanceDivisor,0)};if(o)a.vertexAttrib=function(c){let l=this.index;c.bindBuffer(c.ARRAY_BUFFER,this.vertexBuffer._getBuffer()),c.vertexAttribPointer(l,this.componentsPerAttribute,this.componentDatatype,this.normalize,this.strideInBytes,this.offsetInBytes),c.enableVertexAttribArray(l),this.instanceDivisor>0&&(i.glVertexAttribDivisor(l,this.instanceDivisor),i._vertexAttribDivisors[l]=this.instanceDivisor,i._previousDrawInstanced=!0)},a.disableVertexAttribArray=function(c){c.disableVertexAttribArray(this.index),this.instanceDivisor>0&&i.glVertexAttribDivisor(n,0)};else{switch(a.componentsPerAttribute){case 1:a.vertexAttrib=function(c){c.vertexAttrib1fv(this.index,this.value)};break;case 2:a.vertexAttrib=function(c){c.vertexAttrib2fv(this.index,this.value)};break;case 3:a.vertexAttrib=function(c){c.vertexAttrib3fv(this.index,this.value)};break;case 4:a.vertexAttrib=function(c){c.vertexAttrib4fv(this.index,this.value)};break}a.disableVertexAttribArray=function(c){}}e.push(a)}function Gq(e,t,n){for(let i=0;i0&&(c=!0),d(s[r].value)&&(l=!0);let m;t.vertexArrayObject&&(m=t.glCreateVertexArray(),t.glBindVertexArray(m),Gq(n,s,o),t.glBindVertexArray(null)),this._numberOfVertices=a,this._hasInstancedAttributes=c,this._hasConstantAttributes=l,this._context=t,this._gl=n,this._vao=m,this._attributes=s,this._indexBuffer=o}function Zq(e){return e.values.length/e.componentsPerAttribute}function jVe(e){return Q.getSizeInBytes(e.componentDatatype)*e.componentsPerAttribute}function qVe(e){let t,n,i,o=[];for(n in e)e.hasOwnProperty(n)&&d(e[n])&&d(e[n].values)&&(o.push(n),e[n].componentDatatype===Q.DOUBLE&&(e[n].componentDatatype=Q.FLOAT,e[n].values=Q.createTypedArray(Q.FLOAT,e[n].values)));let r,s=o.length;if(s>0)for(r=Zq(e[o[0]]),t=1;t0){let l=Q.getSizeInBytes(e[o[0]].componentDatatype),u=a%l;u!==0&&(a+=l-u);let m=r*a,p=new ArrayBuffer(m),y={};for(t=0;t=W.SIXTY_FOUR_KILOBYTES&&t.elementIndexUint?p=mt.createIndexBuffer({context:t,typedArray:new Uint32Array(y),usage:i,indexDatatype:Ue.UNSIGNED_INT}):p=mt.createIndexBuffer({context:t,typedArray:new Uint16Array(y),usage:i,indexDatatype:Ue.UNSIGNED_SHORT})),new np({context:t,attributes:u,indexBuffer:p})};Object.defineProperties(np.prototype,{numberOfAttributes:{get:function(){return this._attributes.length}},numberOfVertices:{get:function(){return this._numberOfVertices}},indexBuffer:{get:function(){return this._indexBuffer}}});np.prototype.getAttribute=function(e){return this._attributes[e]};function $Ve(e){let t=e._context,n=e._hasInstancedAttributes;if(!n&&!t._previousDrawInstanced)return;t._previousDrawInstanced=n;let i=t._vertexAttribDivisors,o=e._attributes,r=kt.maximumVertexAttributes,s;if(n){let a=o.length;for(s=0;s0&&(t.glVertexAttribDivisor(s,0),i[s]=0)}function eLe(e,t){let n=e._attributes,i=n.length;for(let o=0;o"u")throw new me("The browser does not support WebGL. Visit http://get.webgl.org.");!n&&!(typeof WebGL2RenderingContext<"u")&&(n=!0);let o=n?"webgl":"webgl2",r=e.getContext(o,t);if(!d(r))throw new me("The browser supports WebGL, but initialization failed.");return r}function nLe(e,t){let n="WebGL Error: ";switch(t){case e.INVALID_ENUM:n+="INVALID_ENUM";break;case e.INVALID_VALUE:n+="INVALID_VALUE";break;case e.INVALID_OPERATION:n+="INVALID_OPERATION";break;case e.OUT_OF_MEMORY:n+="OUT_OF_MEMORY";break;case e.CONTEXT_LOST_WEBGL:n+="CONTEXT_LOST_WEBGL lost";break;default:n+=`Unknown (${t})`}return n}function iLe(e,t,n,i){let o=`${nLe(e,i)}: ${t.name}(`;for(let r=0;r=8}},antialias:{get:function(){return this._antialias}},msaa:{get:function(){return this._webgl2}},standardDerivatives:{get:function(){return this._standardDerivatives||this._webgl2}},floatBlend:{get:function(){return this._floatBlend}},blendMinmax:{get:function(){return this._blendMinmax||this._webgl2}},elementIndexUint:{get:function(){return this._elementIndexUint||this._webgl2}},depthTexture:{get:function(){return this._depthTexture||this._webgl2}},floatingPointTexture:{get:function(){return this._webgl2||this._textureFloat}},halfFloatingPointTexture:{get:function(){return this._webgl2||this._textureHalfFloat}},textureFloatLinear:{get:function(){return this._textureFloatLinear}},textureHalfFloatLinear:{get:function(){return this._webgl2&&this._textureFloatLinear||!this._webgl2&&this._textureHalfFloatLinear}},textureFilterAnisotropic:{get:function(){return!!this._textureFilterAnisotropic}},s3tc:{get:function(){return this._s3tc}},pvrtc:{get:function(){return this._pvrtc}},astc:{get:function(){return this._astc}},etc:{get:function(){return this._etc}},etc1:{get:function(){return this._etc1}},bc7:{get:function(){return this._bc7}},supportsBasis:{get:function(){return this._s3tc||this._pvrtc||this._astc||this._etc||this._etc1||this._bc7}},vertexArrayObject:{get:function(){return this._vertexArrayObject||this._webgl2}},fragmentDepth:{get:function(){return this._fragDepth||this._webgl2}},instancedArrays:{get:function(){return this._instancedArrays||this._webgl2}},colorBufferFloat:{get:function(){return this._colorBufferFloat}},colorBufferHalfFloat:{get:function(){return this._webgl2&&this._colorBufferFloat||!this._webgl2&&this._colorBufferHalfFloat}},drawBuffers:{get:function(){return this._drawBuffers||this._webgl2}},debugShaders:{get:function(){return this._debugShaders}},throwOnWebGLError:{get:function(){return this._throwOnWebGLError},set:function(e){this._throwOnWebGLError=e,this._gl=sLe(this._originalGLContext,e?oLe:void 0)}},defaultTexture:{get:function(){return this._defaultTexture===void 0&&(this._defaultTexture=new Wt({context:this,source:{width:1,height:1,arrayBufferView:new Uint8Array([255,255,255,255])},flipY:!1})),this._defaultTexture}},defaultEmissiveTexture:{get:function(){return this._defaultEmissiveTexture===void 0&&(this._defaultEmissiveTexture=new Wt({context:this,pixelFormat:st.RGB,source:{width:1,height:1,arrayBufferView:new Uint8Array([0,0,0])},flipY:!1})),this._defaultEmissiveTexture}},defaultNormalTexture:{get:function(){return this._defaultNormalTexture===void 0&&(this._defaultNormalTexture=new Wt({context:this,pixelFormat:st.RGB,source:{width:1,height:1,arrayBufferView:new Uint8Array([128,128,255])},flipY:!1})),this._defaultNormalTexture}},defaultCubeMap:{get:function(){if(this._defaultCubeMap===void 0){let e={width:1,height:1,arrayBufferView:new Uint8Array([255,255,255,255])};this._defaultCubeMap=new Ma({context:this,source:{positiveX:e,negativeX:e,positiveY:e,negativeY:e,positiveZ:e,negativeZ:e},flipY:!1})}return this._defaultCubeMap}},drawingBufferHeight:{get:function(){return this._gl.drawingBufferHeight}},drawingBufferWidth:{get:function(){return this._gl.drawingBufferWidth}},defaultFramebuffer:{get:function(){return aLe}}});function Eq(e,t,n,i){let o=e._currentRenderState,r=e._currentPassState;e._currentRenderState=t,e._currentPassState=n,De.partialApply(e._gl,o,t,r,n,i)}var KB;typeof WebGLRenderingContext<"u"&&(KB=[ne.BACK]);function HB(e,t){if(t!==e._currentFramebuffer){e._currentFramebuffer=t;let n=KB;if(d(t))t._bind(),n=t._getActiveColorAttachments();else{let i=e._gl;i.bindFramebuffer(i.FRAMEBUFFER,null)}e.drawBuffers&&e.glDrawBuffers(n)}}var cLe=new ti;Ol.prototype.clear=function(e,t){e=g(e,cLe),t=g(t,this._defaultPassState);let n=this._gl,i=0,o=e.color,r=e.depth,s=e.stencil;d(o)&&(B.equals(this._clearColor,o)||(B.clone(o,this._clearColor),n.clearColor(o.red,o.green,o.blue,o.alpha)),i|=n.COLOR_BUFFER_BIT),d(r)&&(r!==this._clearDepth&&(this._clearDepth=r,n.clearDepth(r)),i|=n.DEPTH_BUFFER_BIT),d(s)&&(s!==this._clearStencil&&(this._clearStencil=s,n.clearStencil(s)),i|=n.STENCIL_BUFFER_BIT);let a=g(e.renderState,this._defaultRenderState);Eq(this,a,t,!0);let c=g(e.framebuffer,t.framebuffer);HB(this,c),n.clear(i)};function lLe(e,t,n,i,o){HB(e,t),Eq(e,o,n,!1),i._bind(),e._maxFrameTextureUnitIndex=Math.max(e._maxFrameTextureUnitIndex,i.maximumTextureUnitIndex)}function dLe(e,t,n,i){let o=t._primitiveType,r=t._vertexArray,s=t._offset,a=t._count,c=t.instanceCount;e._us.model=g(t._modelMatrix,w.IDENTITY),n._setUniforms(i,e._us,e.validateShaderProgram),r._bind();let l=r.indexBuffer;d(l)?(s=s*l.bytesPerIndex,d(a)?a=Math.min(a,l.numberOfIndices):a=l.numberOfIndices,c===0?e._gl.drawElements(o,a,l.indexDatatype,s):e.glDrawElementsInstanced(o,a,l.indexDatatype,s,c)):(d(a)?a=Math.min(a,r.numberOfVertices):a=r.numberOfVertices,c===0?e._gl.drawArrays(o,s,a):e.glDrawArraysInstanced(o,s,a,c)),r._unBind()}Ol.prototype.draw=function(e,t,n,i){t=g(t,this._defaultPassState);let o=g(e._framebuffer,t.framebuffer),r=g(e._renderState,this._defaultRenderState);n=g(n,e._shaderProgram),i=g(i,e._uniformMap),lLe(this,o,t,n,r),dLe(this,e,n,i)};Ol.prototype.endFrame=function(){let e=this._gl;e.useProgram(null),this._currentFramebuffer=void 0,e.bindFramebuffer(e.FRAMEBUFFER,null);let t=KB;this.drawBuffers&&this.glDrawBuffers(t);let n=this._maxFrameTextureUnitIndex;this._maxFrameTextureUnitIndex=0;for(let i=0;i0&&(a=s.getColorTexture(0).pixelDatatype);let c=st.createTypedArray(st.RGBA,a,o,r);return HB(this,s),t.readPixels(n,i,o,r,st.RGBA,Je.toWebGLConstant(a,this),c),c};var Xq={position:0,textureCoordinates:1};Ol.prototype.getViewportQuadVertexArray=function(){let e=this.cache.viewportQuad_vertexArray;if(!d(e)){let t=new dt({attributes:{position:new Ze({componentDatatype:Q.FLOAT,componentsPerAttribute:2,values:[-1,-1,1,-1,1,1,-1,1]}),textureCoordinates:new Ze({componentDatatype:Q.FLOAT,componentsPerAttribute:2,values:[0,0,1,0,1,1,0,1]})},indices:new Uint16Array([0,1,2,0,2,3]),primitiveType:we.TRIANGLES});e=ni.fromGeometry({context:this,geometry:t,attributeLocations:Xq,bufferUsage:Ne.STATIC_DRAW,interleave:!0}),this.cache.viewportQuad_vertexArray=e}return e};Ol.prototype.createViewportQuadCommand=function(e,t){return t=g(t,g.EMPTY_OBJECT),new nt({vertexArray:this.getViewportQuadVertexArray(),primitiveType:we.TRIANGLES,renderState:t.renderState,shaderProgram:Qt.fromCache({context:this,vertexShaderSource:Sg,fragmentShaderSource:e,attributeLocations:Xq}),uniformMap:t.uniformMap,owner:t.owner,framebuffer:t.framebuffer,pass:t.pass})};Ol.prototype.getObjectByPickColor=function(e){return this._pickObjects[e.toRgba()]};function zB(e,t,n){this._pickObjects=e,this.key=t,this.color=n}Object.defineProperties(zB.prototype,{object:{get:function(){return this._pickObjects[this.key]},set:function(e){this._pickObjects[this.key]=e}}});zB.prototype.destroy=function(){delete this._pickObjects[this.key]};Ol.prototype.createPickId=function(e){++this._nextPickColor[0];let t=this._nextPickColor[0];if(t===0)throw new me("Out of unique Pick IDs.");return this._pickObjects[t]=e,new zB(this._pickObjects,t,B.fromRgba(t))};Ol.prototype.isDestroyed=function(){return!1};Ol.prototype.destroy=function(){let e=this.cache;for(let t in e)if(e.hasOwnProperty(t)){let n=e[t];d(n.destroy)&&n.destroy()}return this._shaderCache=this._shaderCache.destroy(),this._textureCache=this._textureCache.destroy(),this._defaultTexture=this._defaultTexture&&this._defaultTexture.destroy(),this._defaultEmissiveTexture=this._defaultEmissiveTexture&&this._defaultEmissiveTexture.destroy(),this._defaultNormalTexture=this._defaultNormalTexture&&this._defaultNormalTexture.destroy(),this._defaultCubeMap=this._defaultCubeMap&&this._defaultCubeMap.destroy(),ue(this)};Ol._deprecationWarning=zr;var QZ=Ol;var Nwt=T(S(),1);var ywt=T(S(),1);function dS(e){e=g(e,g.EMPTY_OBJECT);let t=e.context,n=e.width,i=e.height;this._width=n,this._height=i;let o=e.colorRenderbuffers,r=e.colorTextures;if(d(o)!==d(r))throw new fe("Both color renderbuffer and texture attachments must be provided.");let s=e.depthStencilRenderbuffer,a=e.depthStencilTexture;if(d(s)!==d(a))throw new fe("Both depth-stencil renderbuffer and texture attachments must be provided.");this._renderFramebuffer=new Us({context:t,colorRenderbuffers:o,depthStencilRenderbuffer:s,destroyAttachments:e.destroyAttachments}),this._colorFramebuffer=new Us({context:t,colorTextures:r,depthStencilTexture:a,destroyAttachments:e.destroyAttachments})}dS.prototype.getRenderFramebuffer=function(){return this._renderFramebuffer};dS.prototype.getColorFramebuffer=function(){return this._colorFramebuffer};dS.prototype.blitFramebuffers=function(e,t){this._renderFramebuffer.bindRead(),this._colorFramebuffer.bindDraw();let n=e._gl,i=0;this._colorFramebuffer._colorTextures.length>0&&(i|=n.COLOR_BUFFER_BIT),d(this._colorFramebuffer.depthStencilTexture)&&(i|=n.DEPTH_BUFFER_BIT|(t?n.STENCIL_BUFFER_BIT:0)),n.blitFramebuffer(0,0,this._width,this._height,0,0,this._width,this._height,i,n.NEAREST),n.bindFramebuffer(n.READ_FRAMEBUFFER,null),n.bindFramebuffer(n.DRAW_FRAMEBUFFER,null)};dS.prototype.isDestroyed=function(){return!1};dS.prototype.destroy=function(){return this._renderFramebuffer.destroy(),this._colorFramebuffer.destroy(),ue(this)};var jZ=dS;var Zwt=T(S(),1);var _wt=T(S(),1);var al={RGBA4:ne.RGBA4,RGBA8:ne.RGBA8,RGBA16F:ne.RGBA16F,RGBA32F:ne.RGBA32F,RGB5_A1:ne.RGB5_A1,RGB565:ne.RGB565,DEPTH_COMPONENT16:ne.DEPTH_COMPONENT16,STENCIL_INDEX8:ne.STENCIL_INDEX8,DEPTH_STENCIL:ne.DEPTH_STENCIL,DEPTH24_STENCIL8:ne.DEPTH24_STENCIL8,validate:function(e){return e===al.RGBA4||e===al.RGBA8||e===al.RGBA16F||e===al.RGBA32F||e===al.RGB5_A1||e===al.RGB565||e===al.DEPTH_COMPONENT16||e===al.STENCIL_INDEX8||e===al.DEPTH_STENCIL||e===al.DEPTH24_STENCIL8},getColorFormat:function(e){return e===ne.FLOAT?al.RGBA32F:e===ne.HALF_FLOAT_OES?al.RGBA16F:al.RGBA8}},xc=Object.freeze(al);function qZ(e){e=g(e,g.EMPTY_OBJECT);let n=e.context._gl,i=kt.maximumRenderbufferSize,o=g(e.format,xc.RGBA4),r=d(e.width)?e.width:n.drawingBufferWidth,s=d(e.height)?e.height:n.drawingBufferHeight,a=g(e.numSamples,1);this._gl=n,this._format=o,this._width=r,this._height=s,this._renderbuffer=this._gl.createRenderbuffer(),n.bindRenderbuffer(n.RENDERBUFFER,this._renderbuffer),a>1?n.renderbufferStorageMultisample(n.RENDERBUFFER,a,o,r,s):n.renderbufferStorage(n.RENDERBUFFER,o,r,s),n.bindRenderbuffer(n.RENDERBUFFER,null)}Object.defineProperties(qZ.prototype,{format:{get:function(){return this._format}},width:{get:function(){return this._width}},height:{get:function(){return this._height}}});qZ.prototype._getRenderbuffer=function(){return this._renderbuffer};qZ.prototype.isDestroyed=function(){return!1};qZ.prototype.destroy=function(){return this._gl.deleteRenderbuffer(this._renderbuffer),ue(this)};var Kl=qZ;function os(e){e=g(e,g.EMPTY_OBJECT),this._numSamples=g(e.numSamples,1),this._colorAttachmentsLength=g(e.colorAttachmentsLength,1),this._color=g(e.color,!0),this._depth=g(e.depth,!1),this._depthStencil=g(e.depthStencil,!1),this._supportsDepthTexture=g(e.supportsDepthTexture,!1),this._createColorAttachments=g(e.createColorAttachments,!0),this._createDepthAttachments=g(e.createDepthAttachments,!0),this._pixelDatatype=e.pixelDatatype,this._pixelFormat=e.pixelFormat,this._width=void 0,this._height=void 0,this._framebuffer=void 0,this._multisampleFramebuffer=void 0,this._colorTextures=void 0,this._color&&(this._colorTextures=new Array(this._colorAttachmentsLength),this._colorRenderbuffers=new Array(this._colorAttachmentsLength)),this._colorRenderbuffer=void 0,this._depthStencilRenderbuffer=void 0,this._depthStencilTexture=void 0,this._depthRenderbuffer=void 0,this._depthTexture=void 0,this._attachmentsDirty=!1}Object.defineProperties(os.prototype,{framebuffer:{get:function(){return this._numSamples>1?this._multisampleFramebuffer.getRenderFramebuffer():this._framebuffer}},numSamples:{get:function(){return this._numSamples}},status:{get:function(){return this.framebuffer.status}}});os.prototype.isDirty=function(e,t,n,i,o){n=g(n,1);let r=this._width!==e||this._height!==t,s=this._numSamples!==n,a=d(i)&&this._pixelDatatype!==i||d(o)&&this._pixelFormat!==o,c=n===1?d(this._framebuffer):d(this._multisampleFramebuffer);return this._attachmentsDirty||r||s||a||!c||this._color&&!d(this._colorTextures[0])};os.prototype.update=function(e,t,n,i,o,r){if(i=e.msaa?g(i,1):1,o=g(o,this._color?g(this._pixelDatatype,Je.UNSIGNED_BYTE):void 0),r=g(r,this._color?g(this._pixelFormat,st.RGBA):void 0),this.isDirty(t,n,i,o,r)){if(this.destroy(),this._width=t,this._height=n,this._numSamples=i,this._pixelDatatype=o,this._pixelFormat=r,this._attachmentsDirty=!1,this._color&&this._createColorAttachments){for(let s=0;s1){let a=xc.getColorFormat(o);this._colorRenderbuffers[s]=new Kl({context:e,width:t,height:n,format:a,numSamples:this._numSamples})}}this._depthStencil&&this._createDepthAttachments&&(this._supportsDepthTexture&&e.depthTexture?(this._depthStencilTexture=new Wt({context:e,width:t,height:n,pixelFormat:st.DEPTH_STENCIL,pixelDatatype:Je.UNSIGNED_INT_24_8,sampler:dn.NEAREST}),this._numSamples>1&&(this._depthStencilRenderbuffer=new Kl({context:e,width:t,height:n,format:xc.DEPTH24_STENCIL8,numSamples:this._numSamples}))):this._depthStencilRenderbuffer=new Kl({context:e,width:t,height:n,format:xc.DEPTH_STENCIL})),this._depth&&this._createDepthAttachments&&(this._supportsDepthTexture&&e.depthTexture?this._depthTexture=new Wt({context:e,width:t,height:n,pixelFormat:st.DEPTH_COMPONENT,pixelDatatype:Je.UNSIGNED_INT,sampler:dn.NEAREST}):this._depthRenderbuffer=new Kl({context:e,width:t,height:n,format:xc.DEPTH_COMPONENT16})),this._numSamples>1?this._multisampleFramebuffer=new jZ({context:e,width:this._width,height:this._height,colorTextures:this._colorTextures,colorRenderbuffers:this._colorRenderbuffers,depthStencilTexture:this._depthStencilTexture,depthStencilRenderbuffer:this._depthStencilRenderbuffer,destroyAttachments:!1}):this._framebuffer=new Us({context:e,colorTextures:this._colorTextures,depthTexture:this._depthTexture,depthRenderbuffer:this._depthRenderbuffer,depthStencilTexture:this._depthStencilTexture,depthStencilRenderbuffer:this._depthStencilRenderbuffer,destroyAttachments:!1})}};os.prototype.getColorTexture=function(e){return e=g(e,0),this._colorTextures[e]};os.prototype.setColorTexture=function(e,t){t=g(t,0),this._attachmentsDirty=e!==this._colorTextures[t],this._colorTextures[t]=e};os.prototype.getColorRenderbuffer=function(e){return e=g(e,0),this._colorRenderbuffers[e]};os.prototype.setColorRenderbuffer=function(e,t){t=g(t,0),this._attachmentsDirty=e!==this._colorRenderbuffers[t],this._colorRenderbuffers[t]=e};os.prototype.getDepthRenderbuffer=function(){return this._depthRenderbuffer};os.prototype.setDepthRenderbuffer=function(e){this._attachmentsDirty=e!==this._depthRenderbuffer,this._depthRenderbuffer=e};os.prototype.getDepthTexture=function(){return this._depthTexture};os.prototype.setDepthTexture=function(e){this._attachmentsDirty=e!==this._depthTexture,this._depthTexture=e};os.prototype.getDepthStencilRenderbuffer=function(){return this._depthStencilRenderbuffer};os.prototype.setDepthStencilRenderbuffer=function(e){this._attachmentsDirty=e!==this._depthStencilRenderbuffer,this._depthStencilRenderbuffer=e};os.prototype.getDepthStencilTexture=function(){return this._depthStencilTexture};os.prototype.setDepthStencilTexture=function(e){this._attachmentsDirty=e!==this._depthStencilTexture,this._depthStencilTexture=e};os.prototype.prepareTextures=function(e,t){this._numSamples>1&&this._multisampleFramebuffer.blitFramebuffers(e,t)};os.prototype.clear=function(e,t,n){let i=t.framebuffer;t.framebuffer=this.framebuffer,t.execute(e,n),t.framebuffer=i};os.prototype.destroyFramebuffer=function(){this._framebuffer=this._framebuffer&&this._framebuffer.destroy(),this._multisampleFramebuffer=this._multisampleFramebuffer&&this._multisampleFramebuffer.destroy()};os.prototype.destroy=function(){if(this._color){let e,t=this._colorTextures.length;for(e=0;e0?Q.getSizeInBytes(e[0].componentDatatype):0,o=i>0?t%i:0,r=o===0?0:i-o;return t+=r,t};Ts._createArrayViews=function(e,t){let n=[],i=0,o=e.length;for(let r=0;r0){let n=new ArrayBuffer(t*e.vertexSizeInBytes);if(d(e.arrayBuffer)){let r=new Uint8Array(n),s=new Uint8Array(e.arrayBuffer),a=s.length;for(let c=0;c0){t.needsCommit=!1;let n=t.vertexBuffer,i=e._size*t.vertexSizeInBytes,o=d(n);if(!o||n.sizeInBytes0){let i=e.vertexSizeInBytes*t,o=e.vertexSizeInBytes*n;e.vertexBuffer.copyFromArrayView(new Uint8Array(e.arrayBuffer,i,o),i)}}Ts.prototype.endSubCommits=function(){let e=this._allBuffers;for(let t=0,n=e.length;t0&&(this._hash={},e.length=0)};var Tt=Mg;var A9t=T(S(),1);function Hl(e,t){e=g(e,0),this._near=e,t=g(t,Number.MAX_VALUE),this._far=t}Object.defineProperties(Hl.prototype,{near:{get:function(){return this._near},set:function(e){this._near=e}},far:{get:function(){return this._far},set:function(e){this._far=e}}});Hl.packedLength=2;Hl.pack=function(e,t,n){return n=g(n,0),t[n++]=e.near,t[n]=e.far,t};Hl.unpack=function(e,t,n){return t=g(t,0),d(n)||(n=new Hl),n.near=e[t++],n.far=e[t],n};Hl.equals=function(e,t){return e===t||d(e)&&d(t)&&e.near===t.near&&e.far===t.far};Hl.clone=function(e,t){if(d(e))return d(t)||(t=new Hl),t.near=e.near,t.far=e.far,t};Hl.prototype.clone=function(e){return Hl.clone(this,e)};Hl.prototype.equals=function(e){return Hl.equals(this,e)};var Gt=Hl;var k9t=T(S(),1);function Qd(e,t,n,i){this.near=g(e,0),this.nearValue=g(t,0),this.far=g(n,1),this.farValue=g(i,0)}Qd.clone=function(e,t){if(d(e))return d(t)?(t.near=e.near,t.nearValue=e.nearValue,t.far=e.far,t.farValue=e.farValue,t):new Qd(e.near,e.nearValue,e.far,e.farValue)};Qd.packedLength=4;Qd.pack=function(e,t,n){return n=g(n,0),t[n++]=e.near,t[n++]=e.nearValue,t[n++]=e.far,t[n]=e.farValue,t};Qd.unpack=function(e,t,n){return t=g(t,0),d(n)||(n=new Qd),n.near=e[t++],n.nearValue=e[t++],n.far=e[t++],n.farValue=e[t],n};Qd.equals=function(e,t){return e===t||d(e)&&d(t)&&e.near===t.near&&e.nearValue===t.nearValue&&e.far===t.far&&e.farValue===t.farValue};Qd.prototype.clone=function(e){return Qd.clone(this,e)};Qd.prototype.equals=function(e){return Qd.equals(this,e)};var Pt=Qd;var B9t=T(S(),1),TLe={NONE:0,CLAMP_TO_GROUND:1,RELATIVE_TO_GROUND:2},Ke=Object.freeze(TLe);var O9t=T(S(),1),SLe={CENTER:0,LEFT:1,RIGHT:-1},bi=Object.freeze(SLe);var H9t=T(S(),1),CLe={CENTER:0,BOTTOM:1,BASELINE:2,TOP:-1},In=Object.freeze(CLe);var J9t=T(S(),1),VLe={DONE:0,PENDING:1,FAILED:2},lt=Object.freeze(VLe);var eAt=T(S(),1);function rm(){fe.throwInstantiationError()}Object.defineProperties(rm.prototype,{isConstant:{get:fe.throwInstantiationError},definitionChanged:{get:fe.throwInstantiationError}});rm.prototype.getValue=fe.throwInstantiationError;rm.prototype.equals=fe.throwInstantiationError;rm.equals=function(e,t){return e===t||d(e)&&e.equals(t)};rm.arrayEquals=function(e,t){if(e===t)return!0;if(!d(e)||!d(t)||e.length!==t.length)return!1;let n=e.length;for(let i=0;i-1;o--)r=t[o],d(r._billboard)&&d(r._position)&&s.set(r.id,new Iq(r));for(o=i.length-1;o>-1;o--)r=i[o],d(r._billboard)&&d(r._position)?s.contains(r.id)||s.set(r.id,new Iq(r)):(qB(s.get(r.id),r,a),s.remove(r.id));for(o=n.length-1;o>-1;o--)r=n[o],qB(s.get(r.id),r,a),s.remove(r.id)};function qB(e,t,n){d(e)&&(e.billboard=void 0,n.removeBillboard(t))}var iG=lb;var Kjt=T(S(),1);var tMt=T(S(),1);var PAt=T(S(),1);var xAt=T(S(),1);function YLe(e,t){this.start=g(e,0),this.stop=g(t,0)}var Tc=YLe;function pn(e,t){this.center=h.clone(g(e,h.ZERO)),this.radius=g(t,0)}var t3=new h,n3=new h,i3=new h,o3=new h,r3=new h,s3=new h,a3=new h,ks=new h,c3=new h,l3=new h,d3=new h,u3=new h,OLe=4/3*W.PI;pn.fromPoints=function(e,t){if(d(t)||(t=new pn),!d(e)||e.length===0)return t.center=h.clone(h.ZERO,t.center),t.radius=0,t;let n=h.clone(e[0],a3),i=h.clone(n,t3),o=h.clone(n,n3),r=h.clone(n,i3),s=h.clone(n,o3),a=h.clone(n,r3),c=h.clone(n,s3),l=e.length,u;for(u=1;us.x&&h.clone(n,s),Aa.y&&h.clone(n,a),Mc.z&&h.clone(n,c)}let m=h.magnitudeSquared(h.subtract(s,i,ks)),p=h.magnitudeSquared(h.subtract(a,o,ks)),y=h.magnitudeSquared(h.subtract(c,r,ks)),f=i,x=s,_=m;p>_&&(_=p,f=o,x=a),y>_&&(_=y,f=r,x=c);let C=c3;C.x=(f.x+x.x)*.5,C.y=(f.y+x.y)*.5,C.z=(f.z+x.z)*.5;let V=h.magnitudeSquared(h.subtract(x,C,ks)),L=Math.sqrt(V),Z=l3;Z.x=i.x,Z.y=o.y,Z.z=r.z;let G=d3;G.x=s.x,G.y=a.y,G.z=c.z;let X=h.midpoint(Z,G,u3),P=0;for(u=0;uP&&(P=v);let A=h.magnitudeSquared(h.subtract(n,C,ks));if(A>V){let M=Math.sqrt(A);L=(L+M)*.5,V=L*L;let b=M-L;C.x=(L*C.x+b*n.x)/M,C.y=(L*C.y+b*n.y)/M,C.z=(L*C.z+b*n.z)/M}}return Lc.x&&h.clone(o,c),bl.y&&h.clone(o,l),Ru.z&&h.clone(o,u)}let y=h.magnitudeSquared(h.subtract(c,r,ks)),f=h.magnitudeSquared(h.subtract(l,s,ks)),x=h.magnitudeSquared(h.subtract(u,a,ks)),_=r,C=c,V=y;f>V&&(V=f,_=s,C=l),x>V&&(V=x,_=a,C=u);let L=c3;L.x=(_.x+C.x)*.5,L.y=(_.y+C.y)*.5,L.z=(_.z+C.z)*.5;let Z=h.magnitudeSquared(h.subtract(C,L,ks)),G=Math.sqrt(Z),X=l3;X.x=r.x,X.y=s.y,X.z=a.z;let P=d3;P.x=c.x,P.y=l.y,P.z=u.z;let v=h.midpoint(X,P,u3),A=0;for(p=0;pA&&(A=M);let b=h.magnitudeSquared(h.subtract(o,L,ks));if(b>Z){let R=Math.sqrt(b);G=(G+R)*.5,Z=G*G;let E=R-G;L.x=(G*L.x+E*o.x)/R,L.y=(G*L.y+E*o.y)/R,L.z=(G*L.z+E*o.z)/R}}return Ga.x&&h.clone(i,a),Mc.y&&h.clone(i,c),bl.z&&h.clone(i,l)}let p=h.magnitudeSquared(h.subtract(a,o,ks)),y=h.magnitudeSquared(h.subtract(c,r,ks)),f=h.magnitudeSquared(h.subtract(l,s,ks)),x=o,_=a,C=p;y>C&&(C=y,x=r,_=c),f>C&&(C=f,x=s,_=l);let V=c3;V.x=(x.x+_.x)*.5,V.y=(x.y+_.y)*.5,V.z=(x.z+_.z)*.5;let L=h.magnitudeSquared(h.subtract(_,V,ks)),Z=Math.sqrt(L),G=l3;G.x=o.x,G.y=r.y,G.z=s.z;let X=d3;X.x=a.x,X.y=c.y,X.z=l.z;let P=h.midpoint(G,X,u3),v=0;for(m=0;mv&&(v=A);let M=h.magnitudeSquared(h.subtract(i,V,ks));if(M>L){let b=Math.sqrt(M);Z=(Z+b)*.5,L=Z*Z;let R=b-Z;V.x=(Z*V.x+R*i.x)/b,V.y=(Z*V.y+R*i.y)/b,V.z=(Z*V.z+R*i.z)/b}}return Z=c+s)return e.clone(n),n;if(s>=c+o)return t.clone(n),n;let l=(o+c+s)*.5,u=h.multiplyByScalar(a,(-o+l)/c,iRe);return h.add(u,i,u),h.clone(u,n.center),n.radius=l,n};var oRe=new h;pn.expand=function(e,t,n){n=pn.clone(e,n);let i=h.magnitude(h.subtract(t,n.center,oRe));return i>n.radius&&(n.radius=i),n};pn.intersectPlane=function(e,t){let n=e.center,i=e.radius,o=t.normal,r=h.dot(o,n)+t.distance;return r<-i?qt.OUTSIDE:r maxHeight) {
+ material.diffuse = vec3(0.0);
+ material.alpha = 0.0;
+ return material;
+ }
+
+ // Binary search to find heights above and below.
+ int idxBelow = 0;
+ int idxAbove = heightsDimensions.x;
+ float heightBelow = minHeight;
+ float heightAbove = maxHeight;
+
+ // while loop not allowed, so use for loop with max iterations.
+ // maxIterations of 16 supports a texture size up to 65536 (2^16).
+ const int maxIterations = 16;
+ for (int i = 0; i < maxIterations; i++) {
+ if (idxBelow >= idxAbove - 1) {
+ break;
+ }
+
+ int idxMid = (idxBelow + idxAbove) / 2;
+ float heightTex = getHeight(idxMid, invTexSize);
+
+ if (height > heightTex) {
+ idxBelow = idxMid;
+ heightBelow = heightTex;
+ } else {
+ idxAbove = idxMid;
+ heightAbove = heightTex;
+ }
+ }
+
+ float lerper = heightBelow == heightAbove ? 1.0 : (height - heightBelow) / (heightAbove - heightBelow);
+ vec2 colorUv = vec2(invTexSize * (float(idxBelow) + 0.5 + lerper), 0.5);
+ vec4 color = texture(colors, colorUv);
+
+ // undo preumultiplied alpha
+ if (color.a > 0.0)
+ {
+ color.rgb /= color.a;
+ }
+
+ color.rgb = czm_gammaCorrect(color.rgb);
+
+ material.diffuse = color.rgb;
+ material.alpha = color.a;
+ return material;
+}
+`;var NNt=T(S(),1),yG=`uniform vec4 color;
+uniform float spacing;
+uniform float width;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+ czm_material material = czm_getDefaultMaterial(materialInput);
+
+ float distanceToContour = mod(materialInput.height, spacing);
+
+#if (__VERSION__ == 300 || defined(GL_OES_standard_derivatives))
+ float dxc = abs(dFdx(materialInput.height));
+ float dyc = abs(dFdy(materialInput.height));
+ float dF = max(dxc, dyc) * czm_pixelRatio * width;
+ float alpha = (distanceToContour < dF) ? 1.0 : 0.0;
+#else
+ // If no derivatives available (IE 10?), use pixel ratio
+ float alpha = (distanceToContour < (czm_pixelRatio * width)) ? 1.0 : 0.0;
+#endif
+
+ vec4 outColor = czm_gammaCorrect(vec4(color.rgb, alpha * color.a));
+ material.diffuse = outColor.rgb;
+ material.alpha = outColor.a;
+
+ return material;
+}
+`;var kNt=T(S(),1),gG=`uniform sampler2D image;
+uniform float minimumHeight;
+uniform float maximumHeight;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+ czm_material material = czm_getDefaultMaterial(materialInput);
+ float scaledHeight = clamp((materialInput.height - minimumHeight) / (maximumHeight - minimumHeight), 0.0, 1.0);
+ vec4 rampColor = texture(image, vec2(scaledHeight, 0.5));
+ rampColor = czm_gammaCorrect(rampColor);
+ material.diffuse = rampColor.rgb;
+ material.alpha = rampColor.a;
+ return material;
+}
+`;var BNt=T(S(),1),xG=`uniform vec4 fadeInColor;
+uniform vec4 fadeOutColor;
+uniform float maximumDistance;
+uniform bool repeat;
+uniform vec2 fadeDirection;
+uniform vec2 time;
+
+float getTime(float t, float coord)
+{
+ float scalar = 1.0 / maximumDistance;
+ float q = distance(t, coord) * scalar;
+ if (repeat)
+ {
+ float r = distance(t, coord + 1.0) * scalar;
+ float s = distance(t, coord - 1.0) * scalar;
+ q = min(min(r, s), q);
+ }
+ return clamp(q, 0.0, 1.0);
+}
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+ czm_material material = czm_getDefaultMaterial(materialInput);
+
+ vec2 st = materialInput.st;
+ float s = getTime(time.x, st.s) * fadeDirection.s;
+ float t = getTime(time.y, st.t) * fadeDirection.t;
+
+ float u = length(vec2(s, t));
+ vec4 color = mix(fadeInColor, fadeOutColor, u);
+
+ color = czm_gammaCorrect(color);
+ material.emission = color.rgb;
+ material.alpha = color.a;
+
+ return material;
+}
+`;var ONt=T(S(),1),_G=`uniform vec4 color;
+uniform float cellAlpha;
+uniform vec2 lineCount;
+uniform vec2 lineThickness;
+uniform vec2 lineOffset;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+ czm_material material = czm_getDefaultMaterial(materialInput);
+
+ vec2 st = materialInput.st;
+
+ float scaledWidth = fract(lineCount.s * st.s - lineOffset.s);
+ scaledWidth = abs(scaledWidth - floor(scaledWidth + 0.5));
+ float scaledHeight = fract(lineCount.t * st.t - lineOffset.t);
+ scaledHeight = abs(scaledHeight - floor(scaledHeight + 0.5));
+
+ float value;
+
+ // Fuzz Factor - Controls blurriness of lines
+#if (__VERSION__ == 300 || defined(GL_OES_standard_derivatives))
+ const float fuzz = 1.2;
+ vec2 thickness = (lineThickness * czm_pixelRatio) - 1.0;
+
+ // From "3D Engine Design for Virtual Globes" by Cozzi and Ring, Listing 4.13.
+ vec2 dx = abs(dFdx(st));
+ vec2 dy = abs(dFdy(st));
+ vec2 dF = vec2(max(dx.s, dy.s), max(dx.t, dy.t)) * lineCount;
+ value = min(
+ smoothstep(dF.s * thickness.s, dF.s * (fuzz + thickness.s), scaledWidth),
+ smoothstep(dF.t * thickness.t, dF.t * (fuzz + thickness.t), scaledHeight));
+#else
+ // If no derivatives available (IE 10?), revert to view-dependent fuzz
+ const float fuzz = 0.05;
+
+ vec2 range = 0.5 - (lineThickness * 0.05);
+ value = min(
+ 1.0 - smoothstep(range.s, range.s + fuzz, scaledWidth),
+ 1.0 - smoothstep(range.t, range.t + fuzz, scaledHeight));
+#endif
+
+ // Edges taken from RimLightingMaterial.glsl
+ // See http://www.fundza.com/rman_shaders/surface/fake_rim/fake_rim1.html
+ float dRim = 1.0 - abs(dot(materialInput.normalEC, normalize(materialInput.positionToEyeEC)));
+ float sRim = smoothstep(0.8, 1.0, dRim);
+ value *= (1.0 - sRim);
+
+ vec4 halfColor;
+ halfColor.rgb = color.rgb * 0.5;
+ halfColor.a = color.a * (1.0 - ((1.0 - cellAlpha) * value));
+ halfColor = czm_gammaCorrect(halfColor);
+ material.diffuse = halfColor.rgb;
+ material.emission = halfColor.rgb;
+ material.alpha = halfColor.a;
+
+ return material;
+}
+`;var HNt=T(S(),1),TG=`uniform sampler2D image;
+uniform float strength;
+uniform vec2 repeat;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+ czm_material material = czm_getDefaultMaterial(materialInput);
+
+ vec4 textureValue = texture(image, fract(repeat * materialInput.st));
+ vec3 normalTangentSpace = textureValue.channels;
+ normalTangentSpace.xy = normalTangentSpace.xy * 2.0 - 1.0;
+ normalTangentSpace.z = clamp(1.0 - strength, 0.1, 1.0);
+ normalTangentSpace = normalize(normalTangentSpace);
+ vec3 normalEC = materialInput.tangentToEyeMatrix * normalTangentSpace;
+
+ material.normal = normalEC;
+
+ return material;
+}
+`;var JNt=T(S(),1),SG=`uniform vec4 color;
+
+float getPointOnLine(vec2 p0, vec2 p1, float x)
+{
+ float slope = (p0.y - p1.y) / (p0.x - p1.x);
+ return slope * (x - p0.x) + p0.y;
+}
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+ czm_material material = czm_getDefaultMaterial(materialInput);
+
+ vec2 st = materialInput.st;
+
+#if (__VERSION__ == 300 || defined(GL_OES_standard_derivatives))
+ float base = 1.0 - abs(fwidth(st.s)) * 10.0 * czm_pixelRatio;
+#else
+ // If no derivatives available (IE 10?), 2.5% of the line will be the arrow head
+ float base = 0.975;
+#endif
+
+ vec2 center = vec2(1.0, 0.5);
+ float ptOnUpperLine = getPointOnLine(vec2(base, 1.0), center, st.s);
+ float ptOnLowerLine = getPointOnLine(vec2(base, 0.0), center, st.s);
+
+ float halfWidth = 0.15;
+ float s = step(0.5 - halfWidth, st.t);
+ s *= 1.0 - step(0.5 + halfWidth, st.t);
+ s *= 1.0 - step(base, st.s);
+
+ float t = step(base, materialInput.st.s);
+ t *= 1.0 - step(ptOnUpperLine, st.t);
+ t *= step(ptOnLowerLine, st.t);
+
+ // Find the distance from the closest separator (region between two colors)
+ float dist;
+ if (st.s < base)
+ {
+ float d1 = abs(st.t - (0.5 - halfWidth));
+ float d2 = abs(st.t - (0.5 + halfWidth));
+ dist = min(d1, d2);
+ }
+ else
+ {
+ float d1 = czm_infinity;
+ if (st.t < 0.5 - halfWidth && st.t > 0.5 + halfWidth)
+ {
+ d1 = abs(st.s - base);
+ }
+ float d2 = abs(st.t - ptOnUpperLine);
+ float d3 = abs(st.t - ptOnLowerLine);
+ dist = min(min(d1, d2), d3);
+ }
+
+ vec4 outsideColor = vec4(0.0);
+ vec4 currentColor = mix(outsideColor, color, clamp(s + t, 0.0, 1.0));
+ vec4 outColor = czm_antialias(outsideColor, color, currentColor, dist);
+
+ outColor = czm_gammaCorrect(outColor);
+ material.diffuse = outColor.rgb;
+ material.alpha = outColor.a;
+ return material;
+}
+`;var jNt=T(S(),1),CG=`uniform vec4 color;
+uniform vec4 gapColor;
+uniform float dashLength;
+uniform float dashPattern;
+in float v_polylineAngle;
+
+const float maskLength = 16.0;
+
+mat2 rotate(float rad) {
+ float c = cos(rad);
+ float s = sin(rad);
+ return mat2(
+ c, s,
+ -s, c
+ );
+}
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+ czm_material material = czm_getDefaultMaterial(materialInput);
+
+ vec2 pos = rotate(v_polylineAngle) * gl_FragCoord.xy;
+
+ // Get the relative position within the dash from 0 to 1
+ float dashPosition = fract(pos.x / (dashLength * czm_pixelRatio));
+ // Figure out the mask index.
+ float maskIndex = floor(dashPosition * maskLength);
+ // Test the bit mask.
+ float maskTest = floor(dashPattern / pow(2.0, maskIndex));
+ vec4 fragColor = (mod(maskTest, 2.0) < 1.0) ? gapColor : color;
+ if (fragColor.a < 0.005) { // matches 0/255 and 1/255
+ discard;
+ }
+
+ fragColor = czm_gammaCorrect(fragColor);
+ material.emission = fragColor.rgb;
+ material.alpha = fragColor.a;
+ return material;
+}
+`;var $Nt=T(S(),1),VG=`uniform vec4 color;
+uniform float glowPower;
+uniform float taperPower;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+ czm_material material = czm_getDefaultMaterial(materialInput);
+
+ vec2 st = materialInput.st;
+ float glow = glowPower / abs(st.t - 0.5) - (glowPower / 0.5);
+
+ if (taperPower <= 0.99999) {
+ glow *= min(1.0, taperPower / (0.5 - st.s * 0.5) - (taperPower / 0.5));
+ }
+
+ vec4 fragColor;
+ fragColor.rgb = max(vec3(glow - 1.0 + color.rgb), color.rgb);
+ fragColor.a = clamp(0.0, 1.0, glow) * color.a;
+ fragColor = czm_gammaCorrect(fragColor);
+
+ material.emission = fragColor.rgb;
+ material.alpha = fragColor.a;
+
+ return material;
+}
+`;var t5t=T(S(),1),LG=`uniform vec4 color;
+uniform vec4 outlineColor;
+uniform float outlineWidth;
+
+in float v_width;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+ czm_material material = czm_getDefaultMaterial(materialInput);
+
+ vec2 st = materialInput.st;
+ float halfInteriorWidth = 0.5 * (v_width - outlineWidth) / v_width;
+ float b = step(0.5 - halfInteriorWidth, st.t);
+ b *= 1.0 - step(0.5 + halfInteriorWidth, st.t);
+
+ // Find the distance from the closest separator (region between two colors)
+ float d1 = abs(st.t - (0.5 - halfInteriorWidth));
+ float d2 = abs(st.t - (0.5 + halfInteriorWidth));
+ float dist = min(d1, d2);
+
+ vec4 currentColor = mix(outlineColor, color, b);
+ vec4 outColor = czm_antialias(outlineColor, color, currentColor, dist);
+ outColor = czm_gammaCorrect(outColor);
+
+ material.diffuse = outColor.rgb;
+ material.alpha = outColor.a;
+
+ return material;
+}
+`;var i5t=T(S(),1),RG=`uniform vec4 color;
+uniform vec4 rimColor;
+uniform float width;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+ czm_material material = czm_getDefaultMaterial(materialInput);
+
+ // See http://www.fundza.com/rman_shaders/surface/fake_rim/fake_rim1.html
+ float d = 1.0 - dot(materialInput.normalEC, normalize(materialInput.positionToEyeEC));
+ float s = smoothstep(1.0 - width, 1.0, d);
+
+ vec4 outColor = czm_gammaCorrect(color);
+ vec4 outRimColor = czm_gammaCorrect(rimColor);
+
+ material.diffuse = outColor.rgb;
+ material.emission = outRimColor.rgb * s;
+ material.alpha = mix(outColor.a, outRimColor.a, s);
+
+ return material;
+}
+`;var r5t=T(S(),1),ZG=`uniform sampler2D image;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+ czm_material material = czm_getDefaultMaterial(materialInput);
+ vec4 rampColor = texture(image, vec2(materialInput.slope / (czm_pi / 2.0), 0.5));
+ rampColor = czm_gammaCorrect(rampColor);
+ material.diffuse = rampColor.rgb;
+ material.alpha = rampColor.a;
+ return material;
+}
+`;var a5t=T(S(),1),GG=`uniform vec4 evenColor;
+uniform vec4 oddColor;
+uniform float offset;
+uniform float repeat;
+uniform bool horizontal;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+ czm_material material = czm_getDefaultMaterial(materialInput);
+
+ // Based on the Stripes Fragment Shader in the Orange Book (11.1.2)
+ float coord = mix(materialInput.st.s, materialInput.st.t, float(horizontal));
+ float value = fract((coord - offset) * (repeat * 0.5));
+ float dist = min(value, min(abs(value - 0.5), 1.0 - value));
+
+ vec4 currentColor = mix(evenColor, oddColor, step(0.5, value));
+ vec4 color = czm_antialias(evenColor, oddColor, currentColor, dist);
+ color = czm_gammaCorrect(color);
+
+ material.diffuse = color.rgb;
+ material.alpha = color.a;
+
+ return material;
+}
+`;var l5t=T(S(),1),EG=`// Thanks for the contribution Jonas
+// http://29a.ch/2012/7/19/webgl-terrain-rendering-water-fog
+
+uniform sampler2D specularMap;
+uniform sampler2D normalMap;
+uniform vec4 baseWaterColor;
+uniform vec4 blendColor;
+uniform float frequency;
+uniform float animationSpeed;
+uniform float amplitude;
+uniform float specularIntensity;
+uniform float fadeFactor;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+ czm_material material = czm_getDefaultMaterial(materialInput);
+
+ float time = czm_frameNumber * animationSpeed;
+
+ // fade is a function of the distance from the fragment and the frequency of the waves
+ float fade = max(1.0, (length(materialInput.positionToEyeEC) / 10000000000.0) * frequency * fadeFactor);
+
+ float specularMapValue = texture(specularMap, materialInput.st).r;
+
+ // note: not using directional motion at this time, just set the angle to 0.0;
+ vec4 noise = czm_getWaterNoise(normalMap, materialInput.st * frequency, time, 0.0);
+ vec3 normalTangentSpace = noise.xyz * vec3(1.0, 1.0, (1.0 / amplitude));
+
+ // fade out the normal perturbation as we move further from the water surface
+ normalTangentSpace.xy /= fade;
+
+ // attempt to fade out the normal perturbation as we approach non water areas (low specular map value)
+ normalTangentSpace = mix(vec3(0.0, 0.0, 50.0), normalTangentSpace, specularMapValue);
+
+ normalTangentSpace = normalize(normalTangentSpace);
+
+ // get ratios for alignment of the new normal vector with a vector perpendicular to the tangent plane
+ float tsPerturbationRatio = clamp(dot(normalTangentSpace, vec3(0.0, 0.0, 1.0)), 0.0, 1.0);
+
+ // fade out water effect as specular map value decreases
+ material.alpha = mix(blendColor.a, baseWaterColor.a, specularMapValue) * specularMapValue;
+
+ // base color is a blend of the water and non-water color based on the value from the specular map
+ // may need a uniform blend factor to better control this
+ material.diffuse = mix(blendColor.rgb, baseWaterColor.rgb, specularMapValue);
+
+ // diffuse highlights are based on how perturbed the normal is
+ material.diffuse += (0.1 * tsPerturbationRatio);
+
+ material.diffuse = material.diffuse;
+
+ material.normal = normalize(materialInput.tangentToEyeMatrix * normalTangentSpace);
+
+ material.specular = specularIntensity;
+ material.shininess = 10.0;
+
+ return material;
+}
+`;function ze(e){this.type=void 0,this.shaderSource=void 0,this.materials=void 0,this.uniforms=void 0,this._uniforms=void 0,this.translucent=void 0,this._minificationFilter=g(e.minificationFilter,cn.LINEAR),this._magnificationFilter=g(e.magnificationFilter,Ti.LINEAR),this._strict=void 0,this._template=void 0,this._count=void 0,this._texturePaths={},this._loadedImages=[],this._loadedCubeMaps=[],this._textures={},this._updateFunctions=[],this._defaultTexture=void 0,VRe(e,this),Object.defineProperties(this,{type:{value:this.type,writable:!1}}),d(ze._uniformList[this.type])||(ze._uniformList[this.type]=Object.keys(this._uniforms))}ze._uniformList={};ze.fromType=function(e,t){let n=new ze({fabric:{type:e}});if(d(t))for(let i in t)t.hasOwnProperty(i)&&(n.uniforms[i]=t[i]);return n};ze.prototype.isTranslucent=function(){if(d(this.translucent))return typeof this.translucent=="function"?this.translucent():this.translucent;let e=!0,t=this._translucentFunctions,n=t.length;for(let i=0;i-1)return!0;return!1}function XRe(e){let t=e._template.components,n=e._template.source;if(d(n))e.shaderSource+=`${n}
+`;else{if(e.shaderSource+=`czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+`,e.shaderSource+=`czm_material material = czm_getDefaultMaterial(materialInput);
+`,d(t)){let i=Object.keys(e._template.materials).length>0;for(let o in t)if(t.hasOwnProperty(o))if(o==="diffuse"||o==="emission"){let s=i&&ERe(t[o],e)?t[o]:`czm_gammaCorrect(${t[o]})`;e.shaderSource+=`material.${o} = ${s};
+`}else o==="alpha"?e.shaderSource+=`material.alpha = ${t.alpha};
+`:e.shaderSource+=`material.${o} = ${t[o]};
+`}e.shaderSource+=`return material;
+}
+`}}var Yq={mat2:$i,mat3:$,mat4:w},IRe=/\.ktx2$/i;function WRe(e){let t;return function(n,i){let o=n.uniforms,r=o[e],s=t!==r,a=!d(r)||r===ze.DefaultImageId;t=r;let c=n._textures[e],l,u;if(r instanceof HTMLVideoElement){if(r.readyState>=2){if(s&&d(c)&&(c!==i.defaultTexture&&c.destroy(),c=void 0),!d(c)||c===i.defaultTexture){let p=new dn({minificationFilter:n._minificationFilter,magnificationFilter:n._magnificationFilter});c=new Wt({context:i,source:r,sampler:p}),n._textures[e]=c;return}c.copyFrom({source:r})}else d(c)||(n._textures[e]=i.defaultTexture);return}if(r instanceof Wt&&r!==c){n._texturePaths[e]=void 0;let p=n._textures[e];d(p)&&p!==n._defaultTexture&&p.destroy(),n._textures[e]=r,l=`${e}Dimensions`,o.hasOwnProperty(l)&&(u=o[l],u.x=r._width,u.y=r._height);return}if(s&&d(c)&&a&&(c!==n._defaultTexture&&c.destroy(),c=void 0),d(c)||(n._texturePaths[e]=void 0,c=n._textures[e]=n._defaultTexture,l=`${e}Dimensions`,o.hasOwnProperty(l)&&(u=o[l],u.x=c._width,u.y=c._height)),a)return;let m=r instanceof Ee;if(!d(n._texturePaths[e])||m&&r.url!==n._texturePaths[e].url||!m&&r!==n._texturePaths[e]){if(typeof r=="string"||m){let p=m?r:Ee.createIfNeeded(r),y;IRe.test(p.url)?y=rl(p.url):y=p.fetchImage(),Promise.resolve(y).then(function(f){n._loadedImages.push({id:e,image:f})}).catch(function(){d(c)&&c!==n._defaultTexture&&c.destroy(),n._textures[e]=n._defaultTexture})}else(r instanceof HTMLCanvasElement||r instanceof HTMLImageElement)&&n._loadedImages.push({id:e,image:r});n._texturePaths[e]=r}}}function PRe(e){return function(t,n){let i=t.uniforms[e];if(i instanceof Ma){let r=t._textures[e];r!==t._defaultTexture&&r.destroy(),t._texturePaths[e]=void 0,t._textures[e]=i;return}if(d(t._textures[e])||(t._texturePaths[e]=void 0,t._textures[e]=n.defaultCubeMap),i===ze.DefaultCubeMapId)return;let o=i.positiveX+i.negativeX+i.positiveY+i.negativeY+i.positiveZ+i.negativeZ;if(o!==t._texturePaths[e]){let r=[Ee.createIfNeeded(i.positiveX).fetchImage(),Ee.createIfNeeded(i.negativeX).fetchImage(),Ee.createIfNeeded(i.positiveY).fetchImage(),Ee.createIfNeeded(i.negativeY).fetchImage(),Ee.createIfNeeded(i.positiveZ).fetchImage(),Ee.createIfNeeded(i.negativeZ).fetchImage()];Promise.all(r).then(function(s){t._loadedCubeMaps.push({id:e,images:s})}),t._texturePaths[e]=o}}}function vRe(e){let t=e._template.uniforms;for(let n in t)t.hasOwnProperty(n)&&Oq(e,n)}function Oq(e,t){let n=e._strict,i=e._template.uniforms,o=i[t],r=FRe(o),s;if(r==="channels")s=XG(e,t,o,!1);else{if(r==="sampler2D"){let l=`${t}Dimensions`;ARe(e,l)>0&&(i[l]={type:"ivec3",x:1,y:1},Oq(e,l))}if(!new RegExp(`uniform\\s+${r}\\s+${t}\\s*;`).test(e.shaderSource)){let l=`uniform ${r} ${t};`;e.shaderSource=l+e.shaderSource}let c=`${t}_${e._count++}`;if(s=XG(e,t,c),e.uniforms[t]=o,r==="sampler2D")e._uniforms[c]=function(){return e._textures[t]},e._updateFunctions.push(WRe(t));else if(r==="samplerCube")e._uniforms[c]=function(){return e._textures[t]},e._updateFunctions.push(PRe(t));else if(r.indexOf("mat")!==-1){let l=new Yq[r];e._uniforms[c]=function(){return Yq[r].fromColumnMajorArray(e.uniforms[t],l)}}else e._uniforms[c]=function(){return e.uniforms[t]}}}function FRe(e){let t=e.type;if(!d(t)){let n=typeof e;if(n==="number")t="float";else if(n==="boolean")t="bool";else if(n==="string"||e instanceof Ee||e instanceof HTMLCanvasElement||e instanceof HTMLImageElement)/^([rgba]){1,4}$/i.test(e)?t="channels":e===ze.DefaultCubeMapId?t="samplerCube":t="sampler2D";else if(n==="object")if(Array.isArray(e))(e.length===4||e.length===9||e.length===16)&&(t=`mat${Math.sqrt(e.length)}`);else{let i=0;for(let o in e)e.hasOwnProperty(o)&&(i+=1);i>=2&&i<=4?t=`vec${i}`:i===6&&(t="samplerCube")}}return t}function wRe(e){let t=e._strict,n=e._template.materials;for(let i in n)if(n.hasOwnProperty(i)){let o=new ze({strict:t,fabric:n[i],count:e._count});e._count=o._count,e._uniforms=xt(e._uniforms,o._uniforms,!0),e.materials[i]=o,e._translucentFunctions=e._translucentFunctions.concat(o._translucentFunctions);let r="czm_getMaterial",s=`${r}_${e._count++}`;XG(o,r,s),e.shaderSource=o.shaderSource+e.shaderSource;let a=`${s}(materialInput)`,c=XG(e,i,a)}}function XG(e,t,n,i){i=g(i,!0);let o=0,r="([\\w])?",s=`([\\w${i?".":""}])?`,a=new RegExp(s+t+r,"g");return e.shaderSource=e.shaderSource.replace(a,function(c,l,u){return l||u?c:(o+=1,n)}),o}function ARe(e,t,n){return XG(e,t,t,n)}ze._materialCache={_materials:{},addMaterial:function(e,t){this._materials[e]=t},getMaterial:function(e){return this._materials[e]}};ze.DefaultImageId="czm_defaultImage";ze.DefaultCubeMapId="czm_defaultCubeMap";ze.ColorType="Color";ze._materialCache.addMaterial(ze.ColorType,{fabric:{type:ze.ColorType,uniforms:{color:new B(1,0,0,.5)},components:{diffuse:"color.rgb",alpha:"color.a"}},translucent:function(e){return e.uniforms.color.alpha<1}});ze.ImageType="Image";ze._materialCache.addMaterial(ze.ImageType,{fabric:{type:ze.ImageType,uniforms:{image:ze.DefaultImageId,repeat:new D(1,1),color:new B(1,1,1,1)},components:{diffuse:"texture(image, fract(repeat * materialInput.st)).rgb * color.rgb",alpha:"texture(image, fract(repeat * materialInput.st)).a * color.a"}},translucent:function(e){return e.uniforms.color.alpha<1}});ze.DiffuseMapType="DiffuseMap";ze._materialCache.addMaterial(ze.DiffuseMapType,{fabric:{type:ze.DiffuseMapType,uniforms:{image:ze.DefaultImageId,channels:"rgb",repeat:new D(1,1)},components:{diffuse:"texture(image, fract(repeat * materialInput.st)).channels"}},translucent:!1});ze.AlphaMapType="AlphaMap";ze._materialCache.addMaterial(ze.AlphaMapType,{fabric:{type:ze.AlphaMapType,uniforms:{image:ze.DefaultImageId,channel:"a",repeat:new D(1,1)},components:{alpha:"texture(image, fract(repeat * materialInput.st)).channel"}},translucent:!0});ze.SpecularMapType="SpecularMap";ze._materialCache.addMaterial(ze.SpecularMapType,{fabric:{type:ze.SpecularMapType,uniforms:{image:ze.DefaultImageId,channel:"r",repeat:new D(1,1)},components:{specular:"texture(image, fract(repeat * materialInput.st)).channel"}},translucent:!1});ze.EmissionMapType="EmissionMap";ze._materialCache.addMaterial(ze.EmissionMapType,{fabric:{type:ze.EmissionMapType,uniforms:{image:ze.DefaultImageId,channels:"rgb",repeat:new D(1,1)},components:{emission:"texture(image, fract(repeat * materialInput.st)).channels"}},translucent:!1});ze.BumpMapType="BumpMap";ze._materialCache.addMaterial(ze.BumpMapType,{fabric:{type:ze.BumpMapType,uniforms:{image:ze.DefaultImageId,channel:"r",strength:.8,repeat:new D(1,1)},source:hG},translucent:!1});ze.NormalMapType="NormalMap";ze._materialCache.addMaterial(ze.NormalMapType,{fabric:{type:ze.NormalMapType,uniforms:{image:ze.DefaultImageId,channels:"rgb",strength:.8,repeat:new D(1,1)},source:TG},translucent:!1});ze.GridType="Grid";ze._materialCache.addMaterial(ze.GridType,{fabric:{type:ze.GridType,uniforms:{color:new B(0,1,0,1),cellAlpha:.1,lineCount:new D(8,8),lineThickness:new D(1,1),lineOffset:new D(0,0)},source:_G},translucent:function(e){let t=e.uniforms;return t.color.alpha<1||t.cellAlpha<1}});ze.StripeType="Stripe";ze._materialCache.addMaterial(ze.StripeType,{fabric:{type:ze.StripeType,uniforms:{horizontal:!0,evenColor:new B(1,1,1,.5),oddColor:new B(0,0,1,.5),offset:0,repeat:5},source:GG},translucent:function(e){let t=e.uniforms;return t.evenColor.alpha<1||t.oddColor.alpha<1}});ze.CheckerboardType="Checkerboard";ze._materialCache.addMaterial(ze.CheckerboardType,{fabric:{type:ze.CheckerboardType,uniforms:{lightColor:new B(1,1,1,.5),darkColor:new B(0,0,0,.5),repeat:new D(5,5)},source:fG},translucent:function(e){let t=e.uniforms;return t.lightColor.alpha<1||t.darkColor.alpha<1}});ze.DotType="Dot";ze._materialCache.addMaterial(ze.DotType,{fabric:{type:ze.DotType,uniforms:{lightColor:new B(1,1,0,.75),darkColor:new B(0,1,1,.75),repeat:new D(5,5)},source:pG},translucent:function(e){let t=e.uniforms;return t.lightColor.alpha<1||t.darkColor.alpha<1}});ze.WaterType="Water";ze._materialCache.addMaterial(ze.WaterType,{fabric:{type:ze.WaterType,uniforms:{baseWaterColor:new B(.2,.3,.6,1),blendColor:new B(0,1,.699,1),specularMap:ze.DefaultImageId,normalMap:ze.DefaultImageId,frequency:10,animationSpeed:.01,amplitude:1,specularIntensity:.5,fadeFactor:1},source:EG},translucent:function(e){let t=e.uniforms;return t.baseWaterColor.alpha<1||t.blendColor.alpha<1}});ze.RimLightingType="RimLighting";ze._materialCache.addMaterial(ze.RimLightingType,{fabric:{type:ze.RimLightingType,uniforms:{color:new B(1,0,0,.7),rimColor:new B(1,1,1,.4),width:.3},source:RG},translucent:function(e){let t=e.uniforms;return t.color.alpha<1||t.rimColor.alpha<1}});ze.FadeType="Fade";ze._materialCache.addMaterial(ze.FadeType,{fabric:{type:ze.FadeType,uniforms:{fadeInColor:new B(1,0,0,1),fadeOutColor:new B(0,0,0,0),maximumDistance:.5,repeat:!0,fadeDirection:{x:!0,y:!0},time:new D(.5,.5)},source:xG},translucent:function(e){let t=e.uniforms;return t.fadeInColor.alpha<1||t.fadeOutColor.alpha<1}});ze.PolylineArrowType="PolylineArrow";ze._materialCache.addMaterial(ze.PolylineArrowType,{fabric:{type:ze.PolylineArrowType,uniforms:{color:new B(1,1,1,1)},source:SG},translucent:!0});ze.PolylineDashType="PolylineDash";ze._materialCache.addMaterial(ze.PolylineDashType,{fabric:{type:ze.PolylineDashType,uniforms:{color:new B(1,0,1,1),gapColor:new B(0,0,0,0),dashLength:16,dashPattern:255},source:CG},translucent:!0});ze.PolylineGlowType="PolylineGlow";ze._materialCache.addMaterial(ze.PolylineGlowType,{fabric:{type:ze.PolylineGlowType,uniforms:{color:new B(0,.5,1,1),glowPower:.25,taperPower:1},source:VG},translucent:!0});ze.PolylineOutlineType="PolylineOutline";ze._materialCache.addMaterial(ze.PolylineOutlineType,{fabric:{type:ze.PolylineOutlineType,uniforms:{color:new B(1,1,1,1),outlineColor:new B(1,0,0,1),outlineWidth:1},source:LG},translucent:function(e){let t=e.uniforms;return t.color.alpha<1||t.outlineColor.alpha<1}});ze.ElevationContourType="ElevationContour";ze._materialCache.addMaterial(ze.ElevationContourType,{fabric:{type:ze.ElevationContourType,uniforms:{spacing:100,color:new B(1,0,0,1),width:1},source:yG},translucent:!1});ze.ElevationRampType="ElevationRamp";ze._materialCache.addMaterial(ze.ElevationRampType,{fabric:{type:ze.ElevationRampType,uniforms:{image:ze.DefaultImageId,minimumHeight:0,maximumHeight:1e4},source:gG},translucent:!1});ze.SlopeRampMaterialType="SlopeRamp";ze._materialCache.addMaterial(ze.SlopeRampMaterialType,{fabric:{type:ze.SlopeRampMaterialType,uniforms:{image:ze.DefaultImageId},source:ZG},translucent:!1});ze.AspectRampMaterialType="AspectRamp";ze._materialCache.addMaterial(ze.AspectRampMaterialType,{fabric:{type:ze.AspectRampMaterialType,uniforms:{image:ze.DefaultImageId},source:mG},translucent:!1});ze.ElevationBandType="ElevationBand";ze._materialCache.addMaterial(ze.ElevationBandType,{fabric:{type:ze.ElevationBandType,uniforms:{heights:ze.DefaultImageId,colors:ze.DefaultImageId},source:bG},translucent:!0});var ki=ze;function Ng(e){e=g(e,g.EMPTY_OBJECT);let t=g(e.translucent,!0),n=g(e.closed,!1),i=g(e.materialSupport,Ng.MaterialSupport.TEXTURED);this.material=d(e.material)?e.material:ki.fromType(ki.ColorType),this.translucent=t,this._vertexShaderSource=g(e.vertexShaderSource,i.vertexShaderSource),this._fragmentShaderSource=g(e.fragmentShaderSource,i.fragmentShaderSource),this._renderState=to.getDefaultRenderState(t,n,e.renderState),this._closed=n,this._materialSupport=i,this._vertexFormat=i.vertexFormat,this._flat=g(e.flat,!1),this._faceForward=g(e.faceForward,!n)}Object.defineProperties(Ng.prototype,{vertexShaderSource:{get:function(){return this._vertexShaderSource}},fragmentShaderSource:{get:function(){return this._fragmentShaderSource}},renderState:{get:function(){return this._renderState}},closed:{get:function(){return this._closed}},materialSupport:{get:function(){return this._materialSupport}},vertexFormat:{get:function(){return this._vertexFormat}},flat:{get:function(){return this._flat}},faceForward:{get:function(){return this._faceForward}}});Ng.prototype.getFragmentShaderSource=to.prototype.getFragmentShaderSource;Ng.prototype.isTranslucent=to.prototype.isTranslucent;Ng.prototype.getRenderState=to.prototype.getRenderState;Ng.MaterialSupport={BASIC:Object.freeze({vertexFormat:We.POSITION_AND_NORMAL,vertexShaderSource:lG,fragmentShaderSource:cG}),TEXTURED:Object.freeze({vertexFormat:We.POSITION_NORMAL_AND_ST,vertexShaderSource:uG,fragmentShaderSource:dG}),ALL:Object.freeze({vertexFormat:We.ALL,vertexShaderSource:aG,fragmentShaderSource:sG})};var so=Ng;var CUt=T(S(),1);var cUt=T(S(),1),IG=`in vec3 v_positionEC;
+in vec3 v_normalEC;
+in vec4 v_color;
+
+void main()
+{
+ vec3 positionToEyeEC = -v_positionEC;
+
+ vec3 normalEC = normalize(v_normalEC);
+#ifdef FACE_FORWARD
+ normalEC = faceforward(normalEC, vec3(0.0, 0.0, 1.0), -normalEC);
+#endif
+
+ vec4 color = czm_gammaCorrect(v_color);
+
+ czm_materialInput materialInput;
+ materialInput.normalEC = normalEC;
+ materialInput.positionToEyeEC = positionToEyeEC;
+ czm_material material = czm_getDefaultMaterial(materialInput);
+ material.diffuse = color.rgb;
+ material.alpha = color.a;
+
+ out_FragColor = czm_phong(normalize(positionToEyeEC), material, czm_lightDirectionEC);
+}
+`;var dUt=T(S(),1),WG=`in vec3 position3DHigh;
+in vec3 position3DLow;
+in vec3 normal;
+in vec4 color;
+in float batchId;
+
+out vec3 v_positionEC;
+out vec3 v_normalEC;
+out vec4 v_color;
+
+void main()
+{
+ vec4 p = czm_computePosition();
+
+ v_positionEC = (czm_modelViewRelativeToEye * p).xyz; // position in eye coordinates
+ v_normalEC = czm_normal * normal; // normal in eye coordinates
+ v_color = color;
+
+ gl_Position = czm_modelViewProjectionRelativeToEye * p;
+}
+`;var mUt=T(S(),1),Ug=`in vec4 v_color;
+
+void main()
+{
+ out_FragColor = czm_gammaCorrect(v_color);
+}
+`;var fUt=T(S(),1),PG=`in vec3 position3DHigh;
+in vec3 position3DLow;
+in vec4 color;
+in float batchId;
+
+out vec4 v_color;
+
+void main()
+{
+ vec4 p = czm_computePosition();
+
+ v_color = color;
+
+ gl_Position = czm_modelViewProjectionRelativeToEye * p;
+}
+`;function op(e){e=g(e,g.EMPTY_OBJECT);let t=g(e.translucent,!0),n=g(e.closed,!1),i=g(e.flat,!1),o=i?PG:WG,r=i?Ug:IG,s=i?op.FLAT_VERTEX_FORMAT:op.VERTEX_FORMAT;this.material=void 0,this.translucent=t,this._vertexShaderSource=g(e.vertexShaderSource,o),this._fragmentShaderSource=g(e.fragmentShaderSource,r),this._renderState=to.getDefaultRenderState(t,n,e.renderState),this._closed=n,this._vertexFormat=s,this._flat=i,this._faceForward=g(e.faceForward,!n)}Object.defineProperties(op.prototype,{vertexShaderSource:{get:function(){return this._vertexShaderSource}},fragmentShaderSource:{get:function(){return this._fragmentShaderSource}},renderState:{get:function(){return this._renderState}},closed:{get:function(){return this._closed}},vertexFormat:{get:function(){return this._vertexFormat}},flat:{get:function(){return this._flat}},faceForward:{get:function(){return this._faceForward}}});op.VERTEX_FORMAT=We.POSITION_AND_NORMAL;op.FLAT_VERTEX_FORMAT=We.POSITION_ONLY;op.prototype.getFragmentShaderSource=to.prototype.getFragmentShaderSource;op.prototype.isTranslucent=to.prototype.isTranslucent;op.prototype.getRenderState=to.prototype.getRenderState;var sn=op;var XUt=T(S(),1);function fS(e){this._definitionChanged=new ye,this._color=void 0,this._colorSubscription=void 0,this.color=e}Object.defineProperties(fS.prototype,{isConstant:{get:function(){return H.isConstant(this._color)}},definitionChanged:{get:function(){return this._definitionChanged}},color:le("color")});fS.prototype.getType=function(e){return"Color"};fS.prototype.getValue=function(e,t){return d(t)||(t={}),t.color=H.getValueOrClonedDefault(this._color,e,B.WHITE,t.color),t};fS.prototype.equals=function(e){return this===e||e instanceof fS&&H.equals(this._color,e._color)};var At=fS;var MOt=T(S(),1);var gOt=T(S(),1);var qUt=T(S(),1);var NUt=T(S(),1);function db(e){e=g(e,g.EMPTY_OBJECT),this._ellipsoid=g(e.ellipsoid,re.WGS84),this._rectangle=g(e.rectangle,de.MAX_VALUE),this._projection=new Zi(this._ellipsoid),this._numberOfLevelZeroTilesX=g(e.numberOfLevelZeroTilesX,2),this._numberOfLevelZeroTilesY=g(e.numberOfLevelZeroTilesY,1)}Object.defineProperties(db.prototype,{ellipsoid:{get:function(){return this._ellipsoid}},rectangle:{get:function(){return this._rectangle}},projection:{get:function(){return this._projection}}});db.prototype.getNumberOfXTilesAtLevel=function(e){return this._numberOfLevelZeroTilesX<=o&&(l=o-1);let u=(i.north-e.latitude)/a|0;return u>=r&&(u=r-1),d(n)?(n.x=l,n.y=u,n):new D(l,u)};var Di=db;var Kq=new h,Hq=new h,zq=new he,f3=new h,MRe=new h,Jq=new ce,NRe=new Di,vG=[new he,new he,new he,new he],FG=new D,vr={};vr.initialize=function(){let e=vr._initPromise;return d(e)||(e=Ee.fetchJson($t("Assets/approximateTerrainHeights.json")).then(function(t){vr._terrainHeights=t}),vr._initPromise=e),e};vr.getMinimumMaximumHeights=function(e,t){t=g(t,re.WGS84);let n=Qq(e),i=vr._defaultMinTerrainHeight,o=vr._defaultMaxTerrainHeight;if(d(n)){let r=`${n.level}-${n.x}-${n.y}`,s=vr._terrainHeights[r];d(s)&&(i=s[0],o=s[1]),t.cartographicToCartesian(de.northeast(e,zq),Kq),t.cartographicToCartesian(de.southwest(e,zq),Hq),h.midpoint(Hq,Kq,f3);let a=t.scaleToGeodeticSurface(f3,MRe);if(d(a)){let c=h.distance(f3,a);i=Math.min(i,-c)}else i=vr._defaultMinTerrainHeight}return i=Math.max(vr._defaultMinTerrainHeight,i),{minimumTerrainHeight:i,maximumTerrainHeight:o}};vr.getBoundingSphere=function(e,t){t=g(t,re.WGS84);let n=Qq(e),i=vr._defaultMaxTerrainHeight;if(d(n)){let r=`${n.level}-${n.x}-${n.y}`,s=vr._terrainHeights[r];d(s)&&(i=s[1])}let o=ce.fromRectangle3D(e,t,0);return ce.fromRectangle3D(e,t,i,Jq),ce.union(o,Jq,o)};function Qq(e){he.fromRadians(e.east,e.north,0,vG[0]),he.fromRadians(e.west,e.north,0,vG[1]),he.fromRadians(e.east,e.south,0,vG[2]),he.fromRadians(e.west,e.south,0,vG[3]);let t=0,n=0,i=0,o=0,r=vr._terrainHeightsMaxLevel,s;for(s=0;s<=r;++s){let a=!1;for(let c=0;c<4;++c){let l=vG[c];if(NRe.positionToTileXY(l,s,FG),c===0)i=FG.x,o=FG.y;else if(i!==FG.x||o!==FG.y){a=!0;break}}if(a)break;t=i,n=o}if(s!==0)return{x:t,y:n,level:s>r?r:s-1}}vr._terrainHeightsMaxLevel=6;vr._defaultMaxTerrainHeight=9e3;vr._defaultMinTerrainHeight=-1e5;vr._terrainHeights=void 0;vr._initPromise=void 0;Object.defineProperties(vr,{initialized:{get:function(){return d(vr._terrainHeights)}}});var li=vr;var lDt=T(S(),1);var Kkt=T(S(),1);var okt=T(S(),1);function Sc(e,t,n){this.minimum=h.clone(g(e,h.ZERO)),this.maximum=h.clone(g(t,h.ZERO)),d(n)?n=h.clone(n):n=h.midpoint(this.minimum,this.maximum,new h),this.center=n}Sc.fromCorners=function(e,t,n){return d(n)||(n=new Sc),n.minimum=h.clone(e,n.minimum),n.maximum=h.clone(t,n.maximum),n.center=h.midpoint(e,t,n.center),n};Sc.fromPoints=function(e,t){if(d(t)||(t=new Sc),!d(e)||e.length===0)return t.minimum=h.clone(h.ZERO,t.minimum),t.maximum=h.clone(h.ZERO,t.maximum),t.center=h.clone(h.ZERO,t.center),t;let n=e[0].x,i=e[0].y,o=e[0].z,r=e[0].x,s=e[0].y,a=e[0].z,c=e.length;for(let m=1;m0?qt.INSIDE:r+o<0?qt.OUTSIDE:qt.INTERSECTING};Sc.prototype.clone=function(e){return Sc.clone(this,e)};Sc.prototype.intersectPlane=function(e){return Sc.intersectPlane(this,e)};Sc.prototype.equals=function(e){return Sc.equals(this,e)};var ub=Sc;var Wkt=T(S(),1);var akt=T(S(),1);var p3={};p3.computeDiscriminant=function(e,t,n){return t*t-4*e*n};function jq(e,t,n){let i=e+t;return W.sign(e)!==W.sign(t)&&Math.abs(i/Math.max(Math.abs(e),Math.abs(t)))l&&l/c0?[a/e,n/a]:[n/a,a/e]};var Cc=p3;var pkt=T(S(),1);var dkt=T(S(),1);var y3={};y3.computeDiscriminant=function(e,t,n,i){let o=e*e,r=t*t,s=n*n,a=i*i;return 18*e*t*n*i+r*s-27*o*a-4*(e*s*n+r*t*i)};function b3(e,t,n,i){let o=e,r=t/3,s=n/3,a=i,c=o*s,l=r*a,u=r*r,m=s*s,p=o*s-u,y=o*a-r*s,f=r*a-m,x=4*p*f-y*y,_,C;if(x<0){let J,z,ee;u*l>=c*m?(J=o,z=p,ee=-2*r*p+o*y):(J=a,z=f,ee=-a*y+2*s*f);let j=-(ee<0?-1:1)*Math.abs(J)*Math.sqrt(-x);C=-ee+j;let q=C/2,be=q<0?-Math.pow(-q,1/3):Math.pow(q,1/3),Te=C===j?-be:-z/be;return _=z<=0?be+Te:-ee/(be*be+Te*Te+z),u*l>=c*m?[(_-r)/o]:[-a/(_+s)]}let V=p,L=-2*r*p+o*y,Z=f,G=-a*y+2*s*f,X=Math.sqrt(x),P=Math.sqrt(3)/2,v=Math.abs(Math.atan2(o*X,-L)/3);_=2*Math.sqrt(-V);let A=Math.cos(v);C=_*A;let M=_*(-A/2-P*Math.sin(v)),b=C+M>2*r?C-r:M-r,R=o,E=b/R;v=Math.abs(Math.atan2(a*X,-G)/3),_=2*Math.sqrt(-Z),A=Math.cos(v),C=_*A,M=_*(-A/2-P*Math.sin(v));let I=-a,F=C+M<2*s?C+s:M+s,N=I/F,Y=R*F,k=-b*F-R*I,O=b*I,U=(s*k-r*O)/(-r*k+s*Y);return E<=U?E<=N?U<=N?[E,U,N]:[E,N,U]:[N,E,U]:E<=N?[U,E,N]:U<=N?[U,N,E]:[N,U,E]}y3.computeRealRoots=function(e,t,n,i){let o,r;if(e===0)return Cc.computeRealRoots(t,n,i);if(t===0){if(n===0){if(i===0)return[0,0,0];r=-i/e;let s=r<0?-Math.pow(-r,1/3):Math.pow(r,1/3);return[s,s,s]}else if(i===0)return o=Cc.computeRealRoots(e,0,n),o.Length===0?[0]:[o[0],0,o[1]];return b3(e,0,n,i)}else{if(n===0)return i===0?(r=-t/e,r<0?[r,0,0]:[0,0,r]):b3(e,t,0,i);if(i===0)return o=Cc.computeRealRoots(e,t,n),o.length===0?[0]:o[1]<=0?[o[0],o[1],0]:o[0]>=0?[0,o[0],o[1]]:[o[0],0,o[1]]}return b3(e,t,n,i)};var kg=y3;var g3={};g3.computeDiscriminant=function(e,t,n,i,o){let r=e*e,s=r*e,a=t*t,c=a*t,l=n*n,u=l*n,m=i*i,p=m*i,y=o*o,f=y*o;return a*l*m-4*c*p-4*e*u*m+18*e*t*n*p-27*r*m*m+256*s*f+o*(18*c*n*i-4*a*u+16*e*l*l-80*e*t*l*i-6*e*a*m+144*r*n*m)+y*(144*e*a*n-27*a*a-128*r*l-192*r*t*i)};function am(e,t,n,i){let o=e*e,r=t-3*o/8,s=n-t*e/2+o*e/8,a=i-n*e/4+t*o/16-3*o*o/256,c=kg.computeRealRoots(1,2*r,r*r-4*a,-s*s);if(c.length>0){let l=-e/4,u=c[c.length-1];if(Math.abs(u)=0&&y>=0){let x=Math.sqrt(p),_=Math.sqrt(y);return[l-_,l-x,l+x,l+_]}else{if(p>=0&&y<0)return f=Math.sqrt(p),[l-f,l+f];if(p<0&&y>=0)return f=Math.sqrt(y),[l-f,l+f]}}return[]}else if(u>0){let m=Math.sqrt(u),p=(r+u-s/m)/2,y=(r+u+s/m)/2,f=Cc.computeRealRoots(1,m,p),x=Cc.computeRealRoots(1,-m,y);return f.length!==0?(f[0]+=l,f[1]+=l,x.length!==0?(x[0]+=l,x[1]+=l,f[1]<=x[0]?[f[0],f[1],x[0],x[1]]:x[1]<=f[0]?[x[0],x[1],f[0],f[1]]:f[0]>=x[0]&&f[1]<=x[1]?[x[0],f[0],f[1],x[1]]:x[0]>=f[0]&&x[1]<=f[1]?[f[0],x[0],x[1],f[1]]:f[0]>x[0]&&f[0]0){let m=u[0],p=t-m,y=p*p,f=e/2,x=p/2,_=y-4*i,C=y+4*Math.abs(i),V=s-4*m,L=s+4*Math.abs(m),Z,G;if(m<0||_*L=b[0]&&M[1]<=b[1]?[b[0],M[0],M[1],b[1]]:b[0]>=M[0]&&b[1]<=M[1]?[M[0],b[0],b[1],M[1]]:M[0]>b[0]&&M[0]u)||(p=h.cross(m,a,$q),f=h.dot(s,p),f<0||y+f>u))return;x=h.dot(c,p)/u}else{if(Math.abs(u)1||(p=h.cross(m,a,$q),f=h.dot(s,p)*_,f<0||y+f>1))return;x=h.dot(c,p)*_}return x};er.rayTriangle=function(e,t,n,i,o,r){let s=er.rayTriangleParametric(e,t,n,i,o);if(!(!d(s)||s<0))return d(r)||(r=new h),h.multiplyByScalar(e.direction,s,r),h.add(e.origin,r,r)};var DRe=new Sn;er.lineSegmentTriangle=function(e,t,n,i,o,r,s){let a=DRe;h.clone(e,a.origin),h.subtract(t,e,a.direction),h.normalize(a.direction,a.direction);let c=er.rayTriangleParametric(a,n,i,o,r);if(!(!d(c)||c<0||c>h.distance(e,t)))return d(s)||(s=new h),h.multiplyByScalar(a.direction,c,s),h.add(a.origin,s,s)};function BRe(e,t,n,i){let o=t*t-4*e*n;if(o<0)return;if(o>0){let s=1/(2*e),a=Math.sqrt(o),c=(-t+a)*s,l=(-t-a)*s;return cs))return i.start=Math.max(i.start,0),i.stop=Math.min(i.stop,s),i};var KRe=new h,HRe=new h;er.rayEllipsoid=function(e,t){let n=t.oneOverRadii,i=h.multiplyComponents(n,e.origin,KRe),o=h.multiplyComponents(n,e.direction,HRe),r=h.magnitudeSquared(i),s=h.dot(i,o),a,c,l,u,m;if(r>1){if(s>=0)return;let p=s*s;if(a=r-1,c=h.magnitudeSquared(o),l=c*a,pl){u=s*s-l,m=-s+Math.sqrt(u);let f=m/c,x=a/m;return f0?y.push(new h(i,o*A,o*-R)):R!==0?(y.push(new h(i,o*A,o*-R)),y.push(new h(i,o*A,o*R)),++v):y.push(new h(i,o*A,o*R))}return y}var x3=new h,e$=new h,t$=new h,qA=new h,JRe=new h,QRe=new $,jRe=new $,qRe=new $,$Re=new $,eZe=new $,n$=new $,i$=new $,o$=new h,tZe=new h,nZe=new he;er.grazingAltitudeLocation=function(e,t){let n=e.origin,i=e.direction;if(!h.equals(n,h.ZERO)){let X=t.geodeticSurfaceNormal(n,x3);if(h.dot(i,X)>=0)return n}let o=d(this.rayEllipsoid(e,t)),r=t.transformPositionToScaledSpace(i,x3),s=h.normalize(r,r),a=h.mostOrthogonalAxis(r,qA),c=h.normalize(h.cross(a,s,e$),e$),l=h.normalize(h.cross(s,c,t$),t$),u=QRe;u[0]=s.x,u[1]=s.y,u[2]=s.z,u[3]=c.x,u[4]=c.y,u[5]=c.z,u[6]=l.x,u[7]=l.y,u[8]=l.z;let m=$.transpose(u,jRe),p=$.fromScale(t.radii,qRe),y=$.fromScale(t.oneOverRadii,$Re),f=eZe;f[0]=0,f[1]=-i.z,f[2]=i.y,f[3]=i.z,f[4]=0,f[5]=-i.x,f[6]=-i.y,f[7]=i.x,f[8]=0;let x=$.multiply($.multiply(m,y,n$),f,n$),_=$.multiply($.multiply(x,p,i$),u,i$),C=$.multiplyByVector(x,n,JRe),V=zRe(_,h.negate(C,x3),0,0,1),L,Z,G=V.length;if(G>0){let X=h.clone(h.ZERO,tZe),P=Number.NEGATIVE_INFINITY;for(let A=0;AP&&(P=b,X=h.clone(L,X))}let v=t.cartesianToCartographic(X,nZe);return P=W.clamp(P,0,1),Z=h.magnitude(h.subtract(X,n,qA))*Math.sqrt(1-P*P),Z=o?-Z:Z,v.height=Z,t.cartographicToCartesian(v,new h)}};var iZe=new h;er.lineSegmentPlane=function(e,t,n,i){d(i)||(i=new h);let o=h.subtract(t,e,iZe),r=n.normal,s=h.dot(r,o);if(Math.abs(s)1))return h.multiplyByScalar(o,c,i),h.add(e,i,i),i};er.trianglePlaneIntersection=function(e,t,n,i){let o=i.normal,r=i.distance,s=h.dot(o,e)+r<0,a=h.dot(o,t)+r<0,c=h.dot(o,n)+r<0,l=0;l+=s?1:0,l+=a?1:0,l+=c?1:0;let u,m;if((l===1||l===2)&&(u=new h,m=new h),l===1){if(s)return er.lineSegmentPlane(e,t,i,u),er.lineSegmentPlane(e,n,i,m),{positions:[e,t,n,u,m],indices:[0,3,4,1,2,4,1,4,3]};if(a)return er.lineSegmentPlane(t,n,i,u),er.lineSegmentPlane(t,e,i,m),{positions:[e,t,n,u,m],indices:[1,3,4,2,0,4,2,4,3]};if(c)return er.lineSegmentPlane(n,e,i,u),er.lineSegmentPlane(n,t,i,m),{positions:[e,t,n,u,m],indices:[2,3,4,0,1,4,0,4,3]}}else if(l===2)if(s)if(a){if(!c)return er.lineSegmentPlane(e,n,i,u),er.lineSegmentPlane(t,n,i,m),{positions:[e,t,n,u,m],indices:[0,1,4,0,4,3,2,3,4]}}else return er.lineSegmentPlane(n,t,i,u),er.lineSegmentPlane(e,t,i,m),{positions:[e,t,n,u,m],indices:[2,0,4,2,4,3,1,3,4]};else return er.lineSegmentPlane(t,e,i,u),er.lineSegmentPlane(n,e,i,m),{positions:[e,t,n,u,m],indices:[1,2,4,1,4,3,0,3,4]}};var Si=er;var _3=new se;function Ah(e,t){t=g(t,re.WGS84),e=t.scaleToGeodeticSurface(e);let n=vt.eastNorthUpToFixedFrame(e,t);this._ellipsoid=t,this._origin=e,this._xAxis=h.fromCartesian4(w.getColumn(n,0,_3)),this._yAxis=h.fromCartesian4(w.getColumn(n,1,_3));let i=h.fromCartesian4(w.getColumn(n,2,_3));this._plane=on.fromPointNormal(e,i)}Object.defineProperties(Ah.prototype,{ellipsoid:{get:function(){return this._ellipsoid}},origin:{get:function(){return this._origin}},plane:{get:function(){return this._plane}},xAxis:{get:function(){return this._xAxis}},yAxis:{get:function(){return this._yAxis}},zAxis:{get:function(){return this._plane.normal}}});var oZe=new ub;Ah.fromPoints=function(e,t){let n=ub.fromPoints(e,oZe);return new Ah(n.center,t)};var a$=new Sn,$A=new h;Ah.prototype.projectPointOntoPlane=function(e,t){let n=a$;n.origin=e,h.normalize(e,n.direction);let i=Si.rayPlane(n,this._plane,$A);if(d(i)||(h.negate(n.direction,n.direction),i=Si.rayPlane(n,this._plane,$A)),d(i)){let o=h.subtract(i,this._origin,i),r=h.dot(this._xAxis,o),s=h.dot(this._yAxis,o);return d(t)?(t.x=r,t.y=s,t):new D(r,s)}};Ah.prototype.projectPointsOntoPlane=function(e,t){d(t)||(t=[]);let n=0,i=e.length;for(let o=0;o0?0:P.latitude,R=he.fromRadians(M,e.north,n,bZe),E=he.fromRadians(e.west,e.north,n,yZe),I=he.fromRadians(e.west,b,n,gZe),F=he.fromRadians(e.west,e.south,n,xZe),N=he.fromRadians(M,e.south,n,_Ze),Y=i.cartographicToCartesian(R,TZe),k=i.cartographicToCartesian(E,d$),O=i.cartographicToCartesian(I,SZe),U=i.cartographicToCartesian(F,u$),J=i.cartographicToCartesian(N,CZe),z=A.projectPointToNearestOnPlane(Y,VZe),ee=A.projectPointToNearestOnPlane(k,LZe),K=A.projectPointToNearestOnPlane(O,RZe),j=A.projectPointToNearestOnPlane(U,ZZe),q=A.projectPointToNearestOnPlane(J,GZe);return r=Math.min(ee.x,K.x,j.x),s=-r,c=Math.max(ee.y,z.y),a=Math.min(j.y,q.y),E.height=F.height=t,k=i.cartographicToCartesian(E,d$),U=i.cartographicToCartesian(F,u$),l=Math.min(on.getPointDistance(m,k),on.getPointDistance(m,U)),u=n,c$(A.origin,A.xAxis,A.yAxis,A.zAxis,r,s,a,c,l,u,o)}let p=e.south>0,y=e.north<0,f=p?e.south:y?e.north:0,x=de.center(e,l$).longitude,_=h.fromRadians(x,f,n,i,EZe);_.z=0;let V=Math.abs(_.x)=c?qt.INSIDE:qt.INTERSECTING};var f$=new h,p$=new h,b$=new h,MZe=new h,m$=new h,NZe=new h;wi.distanceSquaredTo=function(e,t){let n=h.subtract(t,e.center,h$),i=e.halfAxes,o=$.getColumn(i,0,f$),r=$.getColumn(i,1,p$),s=$.getColumn(i,2,b$),a=h.magnitude(o),c=h.magnitude(r),l=h.magnitude(s),u=!0,m=!0,p=!0;a>0?h.divideByScalar(o,a,o):u=!1,c>0?h.divideByScalar(r,c,r):m=!1,l>0?h.divideByScalar(s,l,s):p=!1;let y=!u+!m+!p,f,x,_;if(y===1){let Z=o;f=r,x=s,m?p||(Z=s,x=o):(Z=r,f=o),_=h.cross(f,x,m$),Z===o?o=_:Z===r?r=_:Z===s&&(s=_)}else if(y===2){f=o,m?f=r:p&&(f=s);let Z=h.UNIT_Y;Z.equalsEpsilon(f,W.EPSILON3)&&(Z=h.UNIT_X),x=h.cross(f,Z,MZe),h.normalize(x,x),_=h.cross(f,x,m$),h.normalize(_,_),f===o?(r=x,s=_):f===r?(s=x,o=_):f===s&&(o=x,r=_)}else y===3&&(o=h.UNIT_X,r=h.UNIT_Y,s=h.UNIT_Z);let C=NZe;C.x=h.dot(n,o),C.y=h.dot(n,r),C.z=h.dot(n,s);let V=0,L;return C.x<-a?(L=C.x+a,V+=L*L):C.x>a&&(L=C.x-a,V+=L*L),C.y<-c?(L=C.y+c,V+=L*L):C.y>c&&(L=C.y-c,V+=L*L),C.z<-l?(L=C.z+l,V+=L*L):C.z>l&&(L=C.z-l,V+=L*L),V};var UZe=new h,kZe=new h;wi.computePlaneDistances=function(e,t,n,i){d(i)||(i=new Tc);let o=Number.POSITIVE_INFINITY,r=Number.NEGATIVE_INFINITY,s=e.center,a=e.halfAxes,c=$.getColumn(a,0,f$),l=$.getColumn(a,1,p$),u=$.getColumn(a,2,b$),m=h.add(c,l,UZe);h.add(m,u,m),h.add(m,s,m);let p=h.subtract(m,t,kZe),y=h.dot(n,p);return o=Math.min(y,o),r=Math.max(y,r),h.add(s,c,m),h.add(m,l,m),h.subtract(m,u,m),h.subtract(m,t,p),y=h.dot(n,p),o=Math.min(y,o),r=Math.max(y,r),h.add(s,c,m),h.subtract(m,l,m),h.add(m,u,m),h.subtract(m,t,p),y=h.dot(n,p),o=Math.min(y,o),r=Math.max(y,r),h.add(s,c,m),h.subtract(m,l,m),h.subtract(m,u,m),h.subtract(m,t,p),y=h.dot(n,p),o=Math.min(y,o),r=Math.max(y,r),h.subtract(s,c,m),h.add(m,l,m),h.add(m,u,m),h.subtract(m,t,p),y=h.dot(n,p),o=Math.min(y,o),r=Math.max(y,r),h.subtract(s,c,m),h.add(m,l,m),h.subtract(m,u,m),h.subtract(m,t,p),y=h.dot(n,p),o=Math.min(y,o),r=Math.max(y,r),h.subtract(s,c,m),h.subtract(m,l,m),h.add(m,u,m),h.subtract(m,t,p),y=h.dot(n,p),o=Math.min(y,o),r=Math.max(y,r),h.subtract(s,c,m),h.subtract(m,l,m),h.subtract(m,u,m),h.subtract(m,t,p),y=h.dot(n,p),o=Math.min(y,o),r=Math.max(y,r),i.start=o,i.stop=r,i};var DZe=new h,BZe=new h,YZe=new h;wi.computeCorners=function(e,t){d(t)||(t=[new h,new h,new h,new h,new h,new h,new h,new h]);let n=e.center,i=e.halfAxes,o=$.getColumn(i,0,DZe),r=$.getColumn(i,1,BZe),s=$.getColumn(i,2,YZe);return h.clone(n,t[0]),h.subtract(t[0],o,t[0]),h.subtract(t[0],r,t[0]),h.subtract(t[0],s,t[0]),h.clone(n,t[1]),h.subtract(t[1],o,t[1]),h.subtract(t[1],r,t[1]),h.add(t[1],s,t[1]),h.clone(n,t[2]),h.subtract(t[2],o,t[2]),h.add(t[2],r,t[2]),h.subtract(t[2],s,t[2]),h.clone(n,t[3]),h.subtract(t[3],o,t[3]),h.add(t[3],r,t[3]),h.add(t[3],s,t[3]),h.clone(n,t[4]),h.add(t[4],o,t[4]),h.subtract(t[4],r,t[4]),h.subtract(t[4],s,t[4]),h.clone(n,t[5]),h.add(t[5],o,t[5]),h.subtract(t[5],r,t[5]),h.add(t[5],s,t[5]),h.clone(n,t[6]),h.add(t[6],o,t[6]),h.add(t[6],r,t[6]),h.subtract(t[6],s,t[6]),h.clone(n,t[7]),h.add(t[7],o,t[7]),h.add(t[7],r,t[7]),h.add(t[7],s,t[7]),t};var OZe=new $;wi.computeTransformation=function(e,t){d(t)||(t=new w);let n=e.center,i=$.multiplyByUniformScale(e.halfAxes,2,OZe);return w.fromRotationTranslation(i,n,t)};var KZe=new ce;wi.isOccluded=function(e,t){let n=ce.fromOrientedBoundingBox(e,KZe);return!t.isBoundingSphereVisible(n)};wi.prototype.intersectPlane=function(e){return wi.intersectPlane(this,e)};wi.prototype.distanceSquaredTo=function(e){return wi.distanceSquaredTo(this,e)};wi.prototype.computePlaneDistances=function(e,t,n){return wi.computePlaneDistances(this,e,t,n)};wi.prototype.computeCorners=function(e){return wi.computeCorners(this,e)};wi.prototype.computeTransformation=function(e){return wi.computeTransformation(this,e)};wi.prototype.isOccluded=function(e){return wi.isOccluded(this,e)};wi.equals=function(e,t){return e===t||d(e)&&d(t)&&h.equals(e.center,t.center)&&$.equals(e.halfAxes,t.halfAxes)};wi.prototype.clone=function(e){return wi.clone(this,e)};wi.prototype.equals=function(e){return wi.equals(this,e)};var Wn=wi;var mDt=T(S(),1);var eM={};eM.getHeight=function(e,t,n){return(e-n)*t+n};var HZe=new h;eM.getPosition=function(e,t,n,i,o){let r=t.cartesianToCartographic(e,HZe),s=eM.getHeight(r.height,n,i);return h.fromRadians(r.longitude,r.latitude,s,t,o)};var Vc=eM;var eOt=T(S(),1);var fDt=T(S(),1),MG=`in vec3 position3DHigh;
+in vec3 position3DLow;
+in float batchId;
+
+#ifdef EXTRUDED_GEOMETRY
+in vec3 extrudeDirection;
+
+uniform float u_globeMinimumAltitude;
+#endif // EXTRUDED_GEOMETRY
+
+#ifdef PER_INSTANCE_COLOR
+out vec4 v_color;
+#endif // PER_INSTANCE_COLOR
+
+#ifdef TEXTURE_COORDINATES
+#ifdef SPHERICAL
+out vec4 v_sphericalExtents;
+#else // SPHERICAL
+out vec2 v_inversePlaneExtents;
+out vec4 v_westPlane;
+out vec4 v_southPlane;
+#endif // SPHERICAL
+out vec3 v_uvMinAndSphericalLongitudeRotation;
+out vec3 v_uMaxAndInverseDistance;
+out vec3 v_vMaxAndInverseDistance;
+#endif // TEXTURE_COORDINATES
+
+void main()
+{
+ vec4 position = czm_computePosition();
+
+#ifdef EXTRUDED_GEOMETRY
+ float delta = min(u_globeMinimumAltitude, czm_geometricToleranceOverMeter * length(position.xyz));
+ delta *= czm_sceneMode == czm_sceneMode3D ? 1.0 : 0.0;
+
+ //extrudeDirection is zero for the top layer
+ position = position + vec4(extrudeDirection * delta, 0.0);
+#endif
+
+#ifdef TEXTURE_COORDINATES
+#ifdef SPHERICAL
+ v_sphericalExtents = czm_batchTable_sphericalExtents(batchId);
+ v_uvMinAndSphericalLongitudeRotation.z = czm_batchTable_longitudeRotation(batchId);
+#else // SPHERICAL
+#ifdef COLUMBUS_VIEW_2D
+ vec4 planes2D_high = czm_batchTable_planes2D_HIGH(batchId);
+ vec4 planes2D_low = czm_batchTable_planes2D_LOW(batchId);
+
+ // If the primitive is split across the IDL (planes2D_high.x > planes2D_high.w):
+ // - If this vertex is on the east side of the IDL (position3DLow.y > 0.0, comparison with position3DHigh may produce artifacts)
+ // - existing "east" is on the wrong side of the world, far away (planes2D_high/low.w)
+ // - so set "east" as beyond the eastmost extent of the projection (idlSplitNewPlaneHiLow)
+ vec2 idlSplitNewPlaneHiLow = vec2(EAST_MOST_X_HIGH - (WEST_MOST_X_HIGH - planes2D_high.w), EAST_MOST_X_LOW - (WEST_MOST_X_LOW - planes2D_low.w));
+ bool idlSplit = planes2D_high.x > planes2D_high.w && position3DLow.y > 0.0;
+ planes2D_high.w = czm_branchFreeTernary(idlSplit, idlSplitNewPlaneHiLow.x, planes2D_high.w);
+ planes2D_low.w = czm_branchFreeTernary(idlSplit, idlSplitNewPlaneHiLow.y, planes2D_low.w);
+
+ // - else, if this vertex is on the west side of the IDL (position3DLow.y < 0.0)
+ // - existing "west" is on the wrong side of the world, far away (planes2D_high/low.x)
+ // - so set "west" as beyond the westmost extent of the projection (idlSplitNewPlaneHiLow)
+ idlSplit = planes2D_high.x > planes2D_high.w && position3DLow.y < 0.0;
+ idlSplitNewPlaneHiLow = vec2(WEST_MOST_X_HIGH - (EAST_MOST_X_HIGH - planes2D_high.x), WEST_MOST_X_LOW - (EAST_MOST_X_LOW - planes2D_low.x));
+ planes2D_high.x = czm_branchFreeTernary(idlSplit, idlSplitNewPlaneHiLow.x, planes2D_high.x);
+ planes2D_low.x = czm_branchFreeTernary(idlSplit, idlSplitNewPlaneHiLow.y, planes2D_low.x);
+
+ vec3 southWestCorner = (czm_modelViewRelativeToEye * czm_translateRelativeToEye(vec3(0.0, planes2D_high.xy), vec3(0.0, planes2D_low.xy))).xyz;
+ vec3 northWestCorner = (czm_modelViewRelativeToEye * czm_translateRelativeToEye(vec3(0.0, planes2D_high.x, planes2D_high.z), vec3(0.0, planes2D_low.x, planes2D_low.z))).xyz;
+ vec3 southEastCorner = (czm_modelViewRelativeToEye * czm_translateRelativeToEye(vec3(0.0, planes2D_high.w, planes2D_high.y), vec3(0.0, planes2D_low.w, planes2D_low.y))).xyz;
+#else // COLUMBUS_VIEW_2D
+ // 3D case has smaller "plane extents," so planes encoded as a 64 bit position and 2 vec3s for distances/direction
+ vec3 southWestCorner = (czm_modelViewRelativeToEye * czm_translateRelativeToEye(czm_batchTable_southWest_HIGH(batchId), czm_batchTable_southWest_LOW(batchId))).xyz;
+ vec3 northWestCorner = czm_normal * czm_batchTable_northward(batchId) + southWestCorner;
+ vec3 southEastCorner = czm_normal * czm_batchTable_eastward(batchId) + southWestCorner;
+#endif // COLUMBUS_VIEW_2D
+
+ vec3 eastWard = southEastCorner - southWestCorner;
+ float eastExtent = length(eastWard);
+ eastWard /= eastExtent;
+
+ vec3 northWard = northWestCorner - southWestCorner;
+ float northExtent = length(northWard);
+ northWard /= northExtent;
+
+ v_westPlane = vec4(eastWard, -dot(eastWard, southWestCorner));
+ v_southPlane = vec4(northWard, -dot(northWard, southWestCorner));
+ v_inversePlaneExtents = vec2(1.0 / eastExtent, 1.0 / northExtent);
+#endif // SPHERICAL
+ vec4 uvMinAndExtents = czm_batchTable_uvMinAndExtents(batchId);
+ vec4 uMaxVmax = czm_batchTable_uMaxVmax(batchId);
+
+ v_uMaxAndInverseDistance = vec3(uMaxVmax.xy, uvMinAndExtents.z);
+ v_vMaxAndInverseDistance = vec3(uMaxVmax.zw, uvMinAndExtents.w);
+ v_uvMinAndSphericalLongitudeRotation.xy = uvMinAndExtents.xy;
+#endif // TEXTURE_COORDINATES
+
+#ifdef PER_INSTANCE_COLOR
+ v_color = czm_batchTable_color(batchId);
+#endif
+
+ gl_Position = czm_depthClamp(czm_modelViewProjectionRelativeToEye * position);
+}
+`;var bDt=T(S(),1),mb=`#ifdef VECTOR_TILE
+uniform vec4 u_highlightColor;
+#endif
+
+void main(void)
+{
+#ifdef VECTOR_TILE
+ out_FragColor = czm_gammaCorrect(u_highlightColor);
+#else
+ out_FragColor = vec4(1.0);
+#endif
+ czm_writeDepthClamp();
+}
+`;var gDt=T(S(),1),y$={TERRAIN:0,CESIUM_3D_TILE:1,BOTH:2};y$.NUMBER_OF_CLASSIFICATION_TYPES=3;var kn=Object.freeze(y$);var TDt=T(S(),1);var zZe={NEVER:ne.NEVER,LESS:ne.LESS,EQUAL:ne.EQUAL,LESS_OR_EQUAL:ne.LEQUAL,GREATER:ne.GREATER,NOT_EQUAL:ne.NOTEQUAL,GREATER_OR_EQUAL:ne.GEQUAL,ALWAYS:ne.ALWAYS},ka=Object.freeze(zZe);var Q3t=T(S(),1);var CDt=T(S(),1);function JZe(e,t){let n=[],i=e.length,o=0;for(;o>1^-(e&1)}yo.zigZagDeltaDecode=function(e,t,n){let i=e.length,o=0,r=0,s=0;for(let a=0;a>11,u=c>>5&o,m=c&i,p=3*a;t[p]=l*r,t[p+1]=u*s,t[p+2]=m*r}return t};var Kn=yo;var rBt=T(S(),1);var C$=new h,V$=new h,L$=new h;function lGe(e,t,n,i,o){d(o)||(o=new h);let r,s,a,c,l,u,m,p;if(d(t.z)){if(h.equalsEpsilon(e,t,W.EPSILON14))return h.clone(h.UNIT_X,o);if(h.equalsEpsilon(e,n,W.EPSILON14))return h.clone(h.UNIT_Y,o);if(h.equalsEpsilon(e,i,W.EPSILON14))return h.clone(h.UNIT_Z,o);r=h.subtract(n,t,C$),s=h.subtract(i,t,V$),a=h.subtract(e,t,L$),c=h.dot(r,r),l=h.dot(r,s),u=h.dot(r,a),m=h.dot(s,s),p=h.dot(s,a)}else{if(D.equalsEpsilon(e,t,W.EPSILON14))return h.clone(h.UNIT_X,o);if(D.equalsEpsilon(e,n,W.EPSILON14))return h.clone(h.UNIT_Y,o);if(D.equalsEpsilon(e,i,W.EPSILON14))return h.clone(h.UNIT_Z,o);r=D.subtract(n,t,C$),s=D.subtract(i,t,V$),a=D.subtract(e,t,L$),c=D.dot(r,r),l=D.dot(r,s),u=D.dot(r,a),m=D.dot(s,s),p=D.dot(s,a)}o.y=m*u-l*p,o.z=c*p-l*u;let y=c*m-l*l;if(y!==0)return o.y/=y,o.z/=y,o.x=1-o.y-o.z,o}var Yg=lGe;var lBt=T(S(),1);var C3={};C3.calculateACMR=function(e){e=g(e,g.EMPTY_OBJECT);let t=e.indices,n=e.maximumIndex,i=g(e.cacheSize,24),o=t.length;if(!d(n)){n=0;let a=0,c=t[a];for(;an&&(n=c),++a,c=t[a]}let r=[];for(let a=0;ai&&(r[t[a]]=s,++s);return(s-i+1)/(o/3)};C3.tipsify=function(e){e=g(e,g.EMPTY_OBJECT);let t=e.indices,n=e.maximumIndex,i=g(e.cacheSize,24),o;function r(b,R,E,I){for(;R.length>=1;){let F=R[R.length-1];if(R.splice(R.length-1,1),b[F].numLiveTriangles>0)return F}for(;o0)return++o,o-1;++o}return-1}function s(b,R,E,I,F,N,Y){let k=-1,O,U=-1,J=0;for(;JU||U===-1)&&(U=O,k=z)),++J}return k===-1?r(I,N,b,Y):k}let a=t.length,c=0,l=0,u=t[l],m=a;if(d(n))c=n+1;else{for(;lc&&(c=u),++l,u=t[l];if(c===-1)return 0;++c}let p=[],y;for(y=0;yi&&(L.timeStamp=_,++_),++l}x=s(t,i,C,p,_,V,c)}return X};var DG=C3;var Lc={};function cM(e,t,n,i,o){e[t++]=n,e[t++]=i,e[t++]=i,e[t++]=o,e[t++]=o,e[t]=n}function dGe(e){let t=e.length,n=t/3*6,i=Ue.createTypedArray(t,n),o=0;for(let r=0;r=3){let n=(t-2)*6,i=Ue.createTypedArray(t,n);cM(i,0,e[0],e[1],e[2]);let o=6;for(let r=3;r0){let t=e.length-1,n=(t-1)*6,i=Ue.createTypedArray(t,n),o=e[0],r=0;for(let s=1;so&&(o=n[r]);e.indices=DG.tipsify({indices:n,maximumIndex:o,cacheSize:t})}return e};function R$(e){let t={};for(let n in e)if(e.hasOwnProperty(n)&&d(e[n])&&d(e[n].values)){let i=e[n];t[n]=new Ze({componentDatatype:i.componentDatatype,componentsPerAttribute:i.componentsPerAttribute,normalize:i.normalize,values:[]})}return t}function hGe(e,t,n){for(let i in t)if(t.hasOwnProperty(i)&&d(t[i])&&d(t[i].values)){let o=t[i];for(let r=0;r=W.SIXTY_FOUR_KILOBYTES){let i=[],o=[],r=0,s=R$(e.attributes),a=e.indices,c=a.length,l;e.primitiveType===we.TRIANGLES?l=3:e.primitiveType===we.LINES?l=2:e.primitiveType===we.POINTS&&(l=1);for(let u=0;u=W.SIXTY_FOUR_KILOBYTES&&(t.push(new dt({attributes:s,indices:o,primitiveType:e.primitiveType,boundingSphere:e.boundingSphere,boundingSphereCV:e.boundingSphereCV})),i=[],o=[],r=0,s=R$(e.attributes))}o.length!==0&&t.push(new dt({attributes:s,indices:o,primitiveType:e.primitiveType,boundingSphere:e.boundingSphere,boundingSphereCV:e.boundingSphereCV}))}else t.push(e);return t};var Z$=new h,fGe=new he;Lc.projectTo2D=function(e,t,n,i,o){let r=e.attributes[t];o=d(o)?o:new Zi;let s=o.ellipsoid,a=r.values,c=new Float64Array(a.length),l=0;for(let u=0;u_&&(_=V)}return new dt({attributes:u,indices:f,primitiveType:l,boundingSphere:d(x)?new ce(x,_):void 0})}Lc.combineInstances=function(e){let t=[],n=[],i=e.length;for(let r=0;r0&&o.push(Z3(t,"geometry")),n.length>0&&(o.push(Z3(n,"westHemisphereGeometry")),o.push(Z3(n,"eastHemisphereGeometry"))),o};var jd=new h,BG=new h,pS=new h,bS=new h;Lc.computeNormal=function(e){let t=e.indices,n=e.attributes,i=n.position.values,o=n.position.values.length/3,r=t.length,s=new Array(o),a=new Array(r/3),c=new Array(r),l;for(l=0;l0){for(u=0;u3&&(n[3]=0,n[4]=2,n[5]=3);let i=6;for(let o=3;oo?i>r?s=W.sign(e.y):s=W.sign(n.y):o>r?s=W.sign(t.y):s=W.sign(n.y);let a=s<0;hb(e,a),hb(t,a),hb(n,a)}var I$=new h;function qd(e,t,n,i){h.add(e,h.multiplyByScalar(h.subtract(t,e,I$),e.y/(e.y-t.y),I$),n),h.clone(n,i),hb(n,!0),hb(i,!1)}var Og=new h,Kg=new h,Hg=new h,zg=new h,G3={positions:new Array(7),indices:new Array(3*3)};function ZGe(e,t,n){if(e.x>=0||t.x>=0||n.x>=0)return;RGe(e,t,n);let i=e.y<0,o=t.y<0,r=n.y<0,s=0;s+=i?1:0,s+=o?1:0,s+=r?1:0;let a=G3.indices;s===1?(a[1]=3,a[2]=4,a[5]=6,a[7]=6,a[8]=5,i?(qd(e,t,Og,Hg),qd(e,n,Kg,zg),a[0]=0,a[3]=1,a[4]=2,a[6]=1):o?(qd(t,n,Og,Hg),qd(t,e,Kg,zg),a[0]=1,a[3]=2,a[4]=0,a[6]=2):r&&(qd(n,e,Og,Hg),qd(n,t,Kg,zg),a[0]=2,a[3]=0,a[4]=1,a[6]=0)):s===2&&(a[2]=4,a[4]=4,a[5]=3,a[7]=5,a[8]=6,i?o?r||(qd(n,e,Og,Hg),qd(n,t,Kg,zg),a[0]=0,a[1]=1,a[3]=0,a[6]=2):(qd(t,n,Og,Hg),qd(t,e,Kg,zg),a[0]=2,a[1]=0,a[3]=2,a[6]=1):(qd(e,t,Og,Hg),qd(e,n,Kg,zg),a[0]=1,a[1]=2,a[3]=1,a[6]=0));let c=G3.positions;return c[0]=e,c[1]=t,c[2]=n,c.length=3,(s===1||s===2)&&(c[3]=Og,c[4]=Kg,c[5]=Hg,c[6]=zg,c.length=7),G3}function W$(e,t){let n=e.attributes;if(n.position.values.length===0)return;for(let o in n)if(n.hasOwnProperty(o)&&d(n[o])&&d(n[o].values)){let r=n[o];r.values=Q.createTypedArray(r.componentDatatype,r.values)}let i=dt.computeNumberOfVertices(e);return e.indices=Ue.createTypedArray(i,e.indices),t&&(e.boundingSphere=ce.fromVertices(n.position.values)),e}function gS(e){let t=e.attributes,n={};for(let i in t)if(t.hasOwnProperty(i)&&d(t[i])&&d(t[i].values)){let o=t[i];n[i]=new Ze({componentDatatype:o.componentDatatype,componentsPerAttribute:o.componentsPerAttribute,normalize:o.normalize,values:[]})}return new dt({attributes:n,indices:[],primitiveType:e.primitiveType})}function W3(e,t,n){let i=d(e.geometry.boundingSphere);t=W$(t,i),n=W$(n,i),d(n)&&!d(t)?e.geometry=n:!d(n)&&d(t)?e.geometry=t:(e.westHemisphereGeometry=t,e.eastHemisphereGeometry=n,e.geometry=void 0)}function P3(e,t){let n=new e,i=new e,o=new e;return function(r,s,a,c,l,u,m,p){let y=e.fromArray(l,r*t,n),f=e.fromArray(l,s*t,i),x=e.fromArray(l,a*t,o);e.multiplyByScalar(y,c.x,y),e.multiplyByScalar(f,c.y,f),e.multiplyByScalar(x,c.z,x);let _=e.add(y,f,y);e.add(_,x,_),p&&e.normalize(_,_),e.pack(_,u,m*t)}}var GGe=P3(se,4),aM=P3(h,3),M$=P3(D,2),EGe=function(e,t,n,i,o,r,s){let a=o[e]*i.x,c=o[t]*i.y,l=o[n]*i.z;r[s]=a+c+l>W.EPSILON6?1:0},OG=new h,E3=new h,X3=new h,XGe=new h;function rM(e,t,n,i,o,r,s,a,c,l,u,m,p,y,f,x){if(!d(r)&&!d(s)&&!d(a)&&!d(c)&&!d(l)&&y===0)return;let _=h.fromArray(o,e*3,OG),C=h.fromArray(o,t*3,E3),V=h.fromArray(o,n*3,X3),L=Yg(i,_,C,V,XGe);if(d(L)){if(d(r)&&aM(e,t,n,L,r,m.normal.values,x,!0),d(l)){let Z=h.fromArray(l,e*3,OG),G=h.fromArray(l,t*3,E3),X=h.fromArray(l,n*3,X3);h.multiplyByScalar(Z,L.x,Z),h.multiplyByScalar(G,L.y,G),h.multiplyByScalar(X,L.z,X);let P;!h.equals(Z,h.ZERO)||!h.equals(G,h.ZERO)||!h.equals(X,h.ZERO)?(P=h.add(Z,G,Z),h.add(P,X,P),h.normalize(P,P)):(P=OG,P.x=0,P.y=0,P.z=0),h.pack(P,m.extrudeDirection.values,x*3)}if(d(u)&&EGe(e,t,n,L,u,m.applyOffset.values,x),d(s)&&aM(e,t,n,L,s,m.tangent.values,x,!0),d(a)&&aM(e,t,n,L,a,m.bitangent.values,x,!0),d(c)&&M$(e,t,n,L,c,m.st.values,x),y>0)for(let Z=0;Z3){let I=E.positions,F=E.indices,N=F.length;for(let Y=0;Y0)continue;let c=h.unpack(i,s,k$);(a.y<0&&c.y>0||a.y>0&&c.y<0)&&(s-3>0?(i[s]=n[s-3],i[s+1]=n[s-2],i[s+2]=n[s-1]):h.pack(a,i,s));let l=h.unpack(o,s,I3);(a.y<0&&l.y>0||a.y>0&&l.y<0)&&(s+30||ce.intersectPlane(n,on.ORIGIN_ZX_PLANE)!==qt.INTERSECTING))return e;if(t.geometryType!==Hd.NONE)switch(t.geometryType){case Hd.POLYLINES:UGe(e);break;case Hd.TRIANGLES:P$(e);break;case Hd.LINES:v$(e);break}else LGe(t),t.primitiveType===we.TRIANGLES?P$(e):t.primitiveType===we.LINES&&v$(e);return e};var An=Lc;var BBt=T(S(),1);function ll(e){this._ellipsoid=g(e,re.WGS84),this._semimajorAxis=this._ellipsoid.maximumRadius,this._oneOverSemimajorAxis=1/this._semimajorAxis}Object.defineProperties(ll.prototype,{ellipsoid:{get:function(){return this._ellipsoid}}});ll.mercatorAngleToGeodeticLatitude=function(e){return W.PI_OVER_TWO-2*Math.atan(Math.exp(-e))};ll.geodeticLatitudeToMercatorAngle=function(e){e>ll.MaximumLatitude?e=ll.MaximumLatitude:e<-ll.MaximumLatitude&&(e=-ll.MaximumLatitude);let t=Math.sin(e);return .5*Math.log((1+t)/(1-t))};ll.MaximumLatitude=ll.mercatorAngleToGeodeticLatitude(Math.PI);ll.prototype.project=function(e,t){let n=this._semimajorAxis,i=e.longitude*n,o=ll.geodeticLatitudeToMercatorAngle(e.latitude)*n,r=e.height;return d(t)?(t.x=i,t.y=o,t.z=r,t):new h(i,o,r)};ll.prototype.unproject=function(e,t){let n=this._oneOverSemimajorAxis,i=e.x*n,o=ll.mercatorAngleToGeodeticLatitude(e.y*n),r=e.z;return d(t)?(t.longitude=i,t.latitude=o,t.height=r,t):new he(i,o,r)};var Ei=ll;function kGe(e,t,n){let i=!n,o=e.length,r;if(!i&&o>1){let s=e[0].modelMatrix;for(r=1;r=0){let l=i[a];o=l.offset+l.count,s=l.index,r=n[s].indices.length}else o=0,s=0,r=n[s].indices.length;let c=e.length;for(let l=0;lr&&(o=0,r=n[++s].indices.length),i.push({index:s,offset:o,count:p}),o+=p}}function YGe(e,t){let n=[];return F3(e,"geometry",t,n),F3(e,"westHemisphereGeometry",t,n),F3(e,"eastHemisphereGeometry",t,n),n}var sp={};sp.combineGeometry=function(e){let t,n,i=e.instances,o=i.length,r,s,a=!1;o>0&&(t=BGe(e),t.length>0&&(n=An.createAttributeLocations(t[0]),e.createPickOffsets&&(r=YGe(i,t))),d(i[0].attributes)&&d(i[0].attributes.offset)&&(s=new Array(o),a=!0));let c=new Array(o),l=new Array(o);for(let u=0;u0&&(n.set(c.indices,s),s+=f)}return t.push(n.buffer),{stringTable:i,packedData:n}};sp.unpackCreateGeometryResults=function(e){let t=e.stringTable,n=e.packedData,i,o=new Array(n[0]),r=0,s=1;for(;s0){let G=_.length/C;for(Z=Ue.createTypedArray(G,x),i=0;i= nearSq && distanceSq <= farSq) ? 1.0 : 0.0;
+ gl_Position *= show;
+}`,`${i}
+${o}`};function K$(e,t){if(!e.compressVertices)return t;let n=t.search(/in\s+vec3\s+normal;/g)!==-1,i=t.search(/in\s+vec2\s+st;/g)!==-1;if(!n&&!i)return t;let o=t.search(/in\s+vec3\s+tangent;/g)!==-1,r=t.search(/in\s+vec3\s+bitangent;/g)!==-1,s=i&&n?2:1;s+=o||r?1:0;let a=s>1?`vec${s}`:"float",c="compressedAttributes",l=`in ${a} ${c};`,u="",m="";if(i){u+=`vec2 st;
+`;let f=s>1?`${c}.x`:c;m+=` st = czm_decompressTextureCoordinates(${f});
+`}n&&o&&r?(u+=`vec3 normal;
+vec3 tangent;
+vec3 bitangent;
+`,m+=` czm_octDecode(${c}.${i?"yz":"xy"}, normal, tangent, bitangent);
+`):(n&&(u+=`vec3 normal;
+`,m+=` normal = czm_octDecode(${c}${s>1?`.${i?"y":"x"}`:""});
+`),o&&(u+=`vec3 tangent;
+`,m+=` tangent = czm_octDecode(${c}.${i&&n?"z":"y"});
+`),r&&(u+=`vec3 bitangent;
+`,m+=` bitangent = czm_octDecode(${c}.${i&&n?"z":"y"});
+`));let p=t;p=p.replace(/in\s+vec3\s+normal;/g,""),p=p.replace(/in\s+vec2\s+st;/g,""),p=p.replace(/in\s+vec3\s+tangent;/g,""),p=p.replace(/in\s+vec3\s+bitangent;/g,""),p=Be.replaceMain(p,"czm_non_compressed_main");let y=`void main()
+{
+${m} czm_non_compressed_main();
+}`;return[l,u,p,y].join(`
+`)}function rEe(e){let t=Be.replaceMain(e,"czm_non_depth_clamp_main");return t+=`void main() {
+ czm_non_depth_clamp_main();
+ gl_Position = czm_depthClamp(gl_Position);}
+`,t}function sEe(e){let t=Be.replaceMain(e,"czm_non_depth_clamp_main");return t+=`void main() {
+ czm_non_depth_clamp_main();
+ #if defined(LOG_DEPTH)
+ czm_writeLogDepth();
+ #else
+ czm_writeDepthClamp();
+ #endif
+}
+`,t}function H$(e,t){let n=e.vertexAttributes}function aEe(e,t){return function(){return e[t]}}var w3=Math.max(Mt.hardwareConcurrency-1,1),lM,cEe=new pi("combineGeometry");function lEe(e,t){let n,i,o,r,s=e._instanceIds;if(e._state===mr.READY){n=Array.isArray(e.geometryInstances)?e.geometryInstances:[e.geometryInstances];let a=e._numberOfInstances=n.length,c=[],l=[];for(o=0;o0){let x=new Float64Array(m);for(f=[x.buffer],r=0;r0?(e._recomputeBoundingSpheres=!0,e._state=mr.COMBINED):HG(e,t,mr.FAILED,void 0)}).catch(function(m){HG(e,t,mr.FAILED,m)})}}function dEe(e,t){let n=Array.isArray(e.geometryInstances)?e.geometryInstances:[e.geometryInstances],i=e._numberOfInstances=n.length,o=new Array(i),r=e._instanceIds,s,a,c=0;for(a=0;a0?(e._recomputeBoundingSpheres=!0,e._state=mr.COMBINED):HG(e,t,mr.FAILED,void 0)}function uEe(e,t){let n=e._batchTableAttributeIndices.offset;if(!e._recomputeBoundingSpheres||!d(n)){e._recomputeBoundingSpheres=!1;return}let i,o=e._offsetInstanceExtend,r=e._instanceBoundingSpheres,s=r.length,a=e._tempBoundingSpheres;if(!d(a)){for(a=new Array(s),i=0;i0||ce.intersectPlane(x,on.ORIGIN_ZX_PLANE)!==qt.INTERSECTING?c.push(x):(l.push(x),u.push(x))}let m=c[0],p=u[0],y=l[0];for(i=1;i0){if(kt.maximumVertexTextureImageUnits===0)throw new me("Vertex texture fetch support is required to render primitives with per-instance attributes. The maximum number of vertex texture image units must be greater than zero.");this._batchTable.update(e)}if(this._state!==mr.COMPLETE&&this._state!==mr.COMBINED&&(this.asynchronous?lEe(this,e):dEe(this,e)),this._state===mr.COMBINED&&(mEe(this,e),J$(this,e),fEe(this,e)),!this.show||this._state!==mr.COMPLETE)return;this._batchTableOffsetsUpdated||J$(this,e),this._recomputeBoundingSpheres&&uEe(this,e);let n=this.appearance,i=n.material,o=!1,r=!1;this._appearance!==n?(this._appearance=n,this._material=i,o=!0,r=!0):this._material!==i&&(this._material=i,r=!0);let s=this.depthFailAppearance,a=d(s)?s.material:void 0;this._depthFailAppearance!==s?(this._depthFailAppearance=s,this._depthFailMaterial=a,o=!0,r=!0):this._depthFailMaterial!==a&&(this._depthFailMaterial=a,r=!0);let c=this._appearance.isTranslucent();this._translucent!==c&&(this._translucent=c,o=!0),d(this._material)&&this._material.update(t);let l=n.closed&&c;o&&g(this._createRenderStatesFunction,pEe)(this,t,n,l),r&&g(this._createShaderProgramFunction,bEe)(this,e,n),(o||r)&&g(this._createCommandsFunction,yEe)(this,n,i,c,l,this._colorCommands,this._pickCommands,e),g(this._updateAndQueueCommandsFunction,gEe)(this,e,this._colorCommands,this._pickCommands,this.modelMatrix,this.cull,this.debugShowBoundingVolume,l)};var xEe=new ce,_Ee=new ce;function iee(e,t,n){if(n===rn.TOP){let i=ce.clone(e,xEe),o=ce.clone(e,_Ee);o.center=h.add(o.center,t,o.center),e=ce.union(i,o,e)}else n===rn.ALL&&(e.center=h.add(e.center,t,e.center));return e}function TEe(e,t,n){return function(){let i=e.getBatchedAttribute(t,n),o=e.attributes[n],r=o.componentsPerAttribute,s=Q.createTypedArray(o.componentDatatype,r);return d(i.constructor.pack)?i.constructor.pack(i,s,0):s[0]=i,s}}function SEe(e,t,n,i,o){return function(r){let s=$$(r);e.setBatchedAttribute(t,n,s),o==="offset"&&(i._recomputeBoundingSpheres=!0,i._batchTableOffsetsUpdated=!1)}}var CEe=new h;function VEe(e,t,n){t.boundingSphere={get:function(){let i=e._instanceBoundingSpheres[n];if(d(i)){i=i.clone();let o=e.modelMatrix,r=t.offset;d(r)&&iee(i,h.fromArray(r.get(),0,CEe),e._offsetInstanceExtend[n]),d(o)&&(i=ce.transform(i,o))}return i}},t.boundingSphereCV={get:function(){return e._instanceBoundingSpheresCV[n]}}}function LEe(e,t,n){t.pickId={get:function(){return e._pickIds[n]}}}hr.prototype.getGeometryInstanceAttributes=function(e){let t=this._perInstanceAttributeCache.get(e);if(d(t))return t;let n=-1,i=this._lastPerInstanceAttributeIndex,o=this._instanceIds,r=o.length;for(let l=0;l 0.0 && upOrRightInBounds.x && upOrRightInBounds.y);
+ float useDownOrLeft = float(useUpOrRight == 0.0);
+ vec3 upOrRightEC = getEyeCoordinate3FromWindowCoordinate(glFragCoordXY + positiveOffset, upOrRightLogDepth);
+ vec3 downOrLeftEC = getEyeCoordinate3FromWindowCoordinate(glFragCoordXY - positiveOffset, downOrLeftLogDepth);
+ return (upOrRightEC - (eyeCoordinate.xyz / eyeCoordinate.w)) * useUpOrRight + ((eyeCoordinate.xyz / eyeCoordinate.w) - downOrLeftEC) * useDownOrLeft;
+}
+#endif // NORMAL_EC
+
+void main(void)
+{
+#ifdef REQUIRES_EC
+ float logDepthOrDepth = czm_unpackDepth(texture(czm_globeDepthTexture, gl_FragCoord.xy / czm_viewport.zw));
+ vec4 eyeCoordinate = czm_windowToEyeCoordinates(gl_FragCoord.xy, logDepthOrDepth);
+#endif
+
+#ifdef REQUIRES_WC
+ vec4 worldCoordinate4 = czm_inverseView * eyeCoordinate;
+ vec3 worldCoordinate = worldCoordinate4.xyz / worldCoordinate4.w;
+#endif
+
+#ifdef TEXTURE_COORDINATES
+ vec2 uv;
+#ifdef SPHERICAL
+ // Treat world coords as a sphere normal for spherical coordinates
+ vec2 sphericalLatLong = czm_approximateSphericalCoordinates(worldCoordinate);
+ sphericalLatLong.y += v_uvMinAndSphericalLongitudeRotation.z;
+ sphericalLatLong.y = czm_branchFreeTernary(sphericalLatLong.y < czm_pi, sphericalLatLong.y, sphericalLatLong.y - czm_twoPi);
+ uv.x = (sphericalLatLong.y - v_sphericalExtents.y) * v_sphericalExtents.w;
+ uv.y = (sphericalLatLong.x - v_sphericalExtents.x) * v_sphericalExtents.z;
+#else // SPHERICAL
+ // Unpack planes and transform to eye space
+ uv.x = czm_planeDistance(v_westPlane, eyeCoordinate.xyz / eyeCoordinate.w) * v_inversePlaneExtents.x;
+ uv.y = czm_planeDistance(v_southPlane, eyeCoordinate.xyz / eyeCoordinate.w) * v_inversePlaneExtents.y;
+#endif // SPHERICAL
+#endif // TEXTURE_COORDINATES
+
+#ifdef PICK
+#ifdef CULL_FRAGMENTS
+ // When classifying translucent geometry, logDepthOrDepth == 0.0
+ // indicates a region that should not be classified, possibly due to there
+ // being opaque pixels there in another buffer.
+ // Check for logDepthOrDepth != 0.0 to make sure this should be classified.
+ if (0.0 <= uv.x && uv.x <= 1.0 && 0.0 <= uv.y && uv.y <= 1.0 || logDepthOrDepth != 0.0) {
+ out_FragColor.a = 1.0; // 0.0 alpha leads to discard from ShaderSource.createPickFragmentShaderSource
+ czm_writeDepthClamp();
+ }
+#else // CULL_FRAGMENTS
+ out_FragColor.a = 1.0;
+#endif // CULL_FRAGMENTS
+#else // PICK
+
+#ifdef CULL_FRAGMENTS
+ // When classifying translucent geometry, logDepthOrDepth == 0.0
+ // indicates a region that should not be classified, possibly due to there
+ // being opaque pixels there in another buffer.
+ if (uv.x <= 0.0 || 1.0 <= uv.x || uv.y <= 0.0 || 1.0 <= uv.y || logDepthOrDepth == 0.0) {
+ discard;
+ }
+#endif
+
+#ifdef NORMAL_EC
+ // Compute normal by sampling adjacent pixels in 2x2 block in screen space
+ vec3 downUp = vectorFromOffset(eyeCoordinate, vec2(0.0, 1.0));
+ vec3 leftRight = vectorFromOffset(eyeCoordinate, vec2(1.0, 0.0));
+ vec3 normalEC = normalize(cross(leftRight, downUp));
+#endif
+
+
+#ifdef PER_INSTANCE_COLOR
+
+ vec4 color = czm_gammaCorrect(v_color);
+#ifdef FLAT
+ out_FragColor = color;
+#else // FLAT
+ czm_materialInput materialInput;
+ materialInput.normalEC = normalEC;
+ materialInput.positionToEyeEC = -eyeCoordinate.xyz;
+ czm_material material = czm_getDefaultMaterial(materialInput);
+ material.diffuse = color.rgb;
+ material.alpha = color.a;
+
+ out_FragColor = czm_phong(normalize(-eyeCoordinate.xyz), material, czm_lightDirectionEC);
+#endif // FLAT
+
+ // Premultiply alpha. Required for classification primitives on translucent globe.
+ out_FragColor.rgb *= out_FragColor.a;
+
+#else // PER_INSTANCE_COLOR
+
+ // Material support.
+ // USES_ is distinct from REQUIRES_, because some things are dependencies of each other or
+ // dependencies for culling but might not actually be used by the material.
+
+ czm_materialInput materialInput;
+
+#ifdef USES_NORMAL_EC
+ materialInput.normalEC = normalEC;
+#endif
+
+#ifdef USES_POSITION_TO_EYE_EC
+ materialInput.positionToEyeEC = -eyeCoordinate.xyz;
+#endif
+
+#ifdef USES_TANGENT_TO_EYE
+ materialInput.tangentToEyeMatrix = czm_eastNorthUpToEyeCoordinates(worldCoordinate, normalEC);
+#endif
+
+#ifdef USES_ST
+ // Remap texture coordinates from computed (approximately aligned with cartographic space) to the desired
+ // texture coordinate system, which typically forms a tight oriented bounding box around the geometry.
+ // Shader is provided a set of reference points for remapping.
+ materialInput.st.x = czm_lineDistance(v_uvMinAndSphericalLongitudeRotation.xy, v_uMaxAndInverseDistance.xy, uv) * v_uMaxAndInverseDistance.z;
+ materialInput.st.y = czm_lineDistance(v_uvMinAndSphericalLongitudeRotation.xy, v_vMaxAndInverseDistance.xy, uv) * v_vMaxAndInverseDistance.z;
+#endif
+
+ czm_material material = czm_getMaterial(materialInput);
+
+#ifdef FLAT
+ out_FragColor = vec4(material.diffuse + material.emission, material.alpha);
+#else // FLAT
+ out_FragColor = czm_phong(normalize(-eyeCoordinate.xyz), material, czm_lightDirectionEC);
+#endif // FLAT
+
+ // Premultiply alpha. Required for classification primitives on translucent globe.
+ out_FragColor.rgb *= out_FragColor.a;
+
+#endif // PER_INSTANCE_COLOR
+ czm_writeDepthClamp();
+#endif // PICK
+}
+`;function $d(e,t,n){this._projectionExtentDefines={eastMostYhighDefine:"",eastMostYlowDefine:"",westMostYhighDefine:"",westMostYlowDefine:""};let i=new M3;i.requiresTextureCoordinates=e,i.requiresEC=!n.flat;let o=new M3;if(o.requiresTextureCoordinates=e,n instanceof sn)i.requiresNormalEC=!n.flat;else{let r=`${n.material.shaderSource}
+${n.fragmentShaderSource}`;i.normalEC=r.indexOf("materialInput.normalEC")!==-1||r.indexOf("czm_getDefaultMaterial")!==-1,i.positionToEyeEC=r.indexOf("materialInput.positionToEyeEC")!==-1,i.tangentToEyeMatrix=r.indexOf("materialInput.tangentToEyeMatrix")!==-1,i.st=r.indexOf("materialInput.st")!==-1}this._colorShaderDependencies=i,this._pickShaderDependencies=o,this._appearance=n,this._extentsCulling=e,this._planarExtents=t}$d.prototype.createFragmentShader=function(e){let t=this._appearance,n=this._colorShaderDependencies,i=[];!e&&!this._planarExtents&&i.push("SPHERICAL"),n.requiresEC&&i.push("REQUIRES_EC"),n.requiresWC&&i.push("REQUIRES_WC"),n.requiresTextureCoordinates&&i.push("TEXTURE_COORDINATES"),this._extentsCulling&&i.push("CULL_FRAGMENTS"),n.requiresNormalEC&&i.push("NORMAL_EC"),t instanceof sn&&i.push("PER_INSTANCE_COLOR"),n.normalEC&&i.push("USES_NORMAL_EC"),n.positionToEyeEC&&i.push("USES_POSITION_TO_EYE_EC"),n.tangentToEyeMatrix&&i.push("USES_TANGENT_TO_EYE"),n.st&&i.push("USES_ST"),t.flat&&i.push("FLAT");let o="";return t instanceof sn||(o=t.material.shaderSource),new Be({defines:i,sources:[o,xS]})};$d.prototype.createPickFragmentShader=function(e){let t=this._pickShaderDependencies,n=["PICK"];return!e&&!this._planarExtents&&n.push("SPHERICAL"),t.requiresEC&&n.push("REQUIRES_EC"),t.requiresWC&&n.push("REQUIRES_WC"),t.requiresTextureCoordinates&&n.push("TEXTURE_COORDINATES"),this._extentsCulling&&n.push("CULL_FRAGMENTS"),new Be({defines:n,sources:[xS],pickColorQualifier:"in"})};$d.prototype.createVertexShader=function(e,t,n,i){return uee(this._colorShaderDependencies,this._planarExtents,n,e,t,this._appearance,i,this._projectionExtentDefines)};$d.prototype.createPickVertexShader=function(e,t,n,i){return uee(this._pickShaderDependencies,this._planarExtents,n,e,t,void 0,i,this._projectionExtentDefines)};var oee=new h,ree=new he,see={high:0,low:0};function uee(e,t,n,i,o,r,s,a){let c=i.slice();if(a.eastMostYhighDefine===""){let l=ree;l.longitude=W.PI,l.latitude=0,l.height=0;let u=s.project(l,oee),m=On.encode(u.x,see);a.eastMostYhighDefine=`EAST_MOST_X_HIGH ${m.high.toFixed(`${m.high}`.length+1)}`,a.eastMostYlowDefine=`EAST_MOST_X_LOW ${m.low.toFixed(`${m.low}`.length+1)}`;let p=ree;p.longitude=-W.PI,p.latitude=0,p.height=0;let y=s.project(p,oee);m=On.encode(y.x,see),a.westMostYhighDefine=`WEST_MOST_X_HIGH ${m.high.toFixed(`${m.high}`.length+1)}`,a.westMostYlowDefine=`WEST_MOST_X_LOW ${m.low.toFixed(`${m.low}`.length+1)}`}return n&&(c.push(a.eastMostYhighDefine),c.push(a.eastMostYlowDefine),c.push(a.westMostYhighDefine),c.push(a.westMostYlowDefine)),d(r)&&r instanceof sn&&c.push("PER_INSTANCE_COLOR"),e.requiresTextureCoordinates&&(c.push("TEXTURE_COORDINATES"),t||n||c.push("SPHERICAL"),n&&c.push("COLUMBUS_VIEW_2D")),new Be({defines:c,sources:[o]})}function M3(){this._requiresEC=!1,this._requiresWC=!1,this._requiresNormalEC=!1,this._requiresTextureCoordinates=!1,this._usesNormalEC=!1,this._usesPositionToEyeEC=!1,this._usesTangentToEyeMat=!1,this._usesSt=!1}Object.defineProperties(M3.prototype,{requiresEC:{get:function(){return this._requiresEC},set:function(e){this._requiresEC=e||this._requiresEC}},requiresWC:{get:function(){return this._requiresWC},set:function(e){this._requiresWC=e||this._requiresWC,this.requiresEC=this._requiresWC}},requiresNormalEC:{get:function(){return this._requiresNormalEC},set:function(e){this._requiresNormalEC=e||this._requiresNormalEC,this.requiresEC=this._requiresNormalEC}},requiresTextureCoordinates:{get:function(){return this._requiresTextureCoordinates},set:function(e){this._requiresTextureCoordinates=e||this._requiresTextureCoordinates,this.requiresWC=this._requiresTextureCoordinates}},normalEC:{set:function(e){this.requiresNormalEC=e,this._usesNormalEC=e},get:function(){return this._usesNormalEC}},tangentToEyeMatrix:{set:function(e){this.requiresWC=e,this.requiresNormalEC=e,this._usesTangentToEyeMat=e},get:function(){return this._usesTangentToEyeMat}},positionToEyeEC:{set:function(e){this.requiresEC=e,this._usesPositionToEyeEC=e},get:function(){return this._usesPositionToEyeEC}},st:{set:function(e){this.requiresTextureCoordinates=e,this._usesSt=e},get:function(){return this._usesSt}}});function aee(e,t,n){return Math.abs((t.y-e.y)*n.x-(t.x-e.x)*n.y+t.x*e.y-t.y*e.x)/D.distance(t,e)}var ZEe=[new D,new D,new D,new D];function mee(e,t){let n=ZEe,i=D.unpack(t,0,n[0]),o=D.unpack(t,2,n[1]),r=D.unpack(t,4,n[2]);e.uMaxVmax=new Da({componentDatatype:Q.FLOAT,componentsPerAttribute:4,normalize:!1,value:[o.x,o.y,r.x,r.y]});let s=1/aee(i,o,r),a=1/aee(i,r,o);e.uvMinAndExtents=new Da({componentDatatype:Q.FLOAT,componentsPerAttribute:4,normalize:!1,value:[i.x,i.y,s,a]})}var hee=new he,fee=new h,GEe=new h,EEe=new h,dM={high:0,low:0};function pee(e,t,n){let i=hee;i.height=0,i.longitude=e.west,i.latitude=e.south;let o=t.project(i,fee);i.latitude=e.north;let r=t.project(i,GEe);i.longitude=e.east,i.latitude=e.south;let s=t.project(i,EEe),a=[0,0,0,0],c=[0,0,0,0],l=On.encode(o.x,dM);a[0]=l.high,c[0]=l.low,l=On.encode(o.y,dM),a[1]=l.high,c[1]=l.low,l=On.encode(r.y,dM),a[2]=l.high,c[2]=l.low,l=On.encode(s.x,dM),a[3]=l.high,c[3]=l.low,n.planes2D_HIGH=new Da({componentDatatype:Q.FLOAT,componentsPerAttribute:4,normalize:!1,value:a}),n.planes2D_LOW=new Da({componentDatatype:Q.FLOAT,componentsPerAttribute:4,normalize:!1,value:c})}var XEe=new w,IEe=new w,cee=new h,WEe=new he,PEe=[new he,new he,new he,new he,new he,new he,new he,new he];function vEe(e,t,n,i,o,r){let s=de.center(e,WEe);s.height=n;let a=he.toCartesian(s,t,cee),c=vt.eastNorthUpToFixedFrame(a,t,XEe),l=w.inverse(c,IEe),u=e.west,m=e.east,p=e.north,y=e.south,f=PEe;f[0].latitude=y,f[0].longitude=u,f[1].latitude=p,f[1].longitude=u,f[2].latitude=p,f[2].longitude=m,f[3].latitude=y,f[3].longitude=m;let x=(u+m)*.5,_=(p+y)*.5;f[4].latitude=y,f[4].longitude=x,f[5].latitude=p,f[5].longitude=x,f[6].latitude=_,f[6].longitude=u,f[7].latitude=_,f[7].longitude=m;let C=Number.POSITIVE_INFINITY,V=Number.NEGATIVE_INFINITY,L=Number.POSITIVE_INFINITY,Z=Number.NEGATIVE_INFINITY;for(let v=0;v<8;v++){f[v].height=n;let A=he.toCartesian(f[v],t,cee);w.multiplyByPoint(l,A,A),A.z=0,C=Math.min(C,A.x),V=Math.max(V,A.x),L=Math.min(L,A.y),Z=Math.max(Z,A.y)}let G=i;G.x=C,G.y=L,G.z=0,w.multiplyByPoint(c,G,G);let X=o;X.x=V,X.y=L,X.z=0,w.multiplyByPoint(c,X,X),h.subtract(X,G,o);let P=r;P.x=C,P.y=Z,P.z=0,w.multiplyByPoint(c,P,P),h.subtract(P,G,r)}var FEe=new h,wEe=new h,AEe=new On;$d.getPlanarTextureCoordinateAttributes=function(e,t,n,i,o){let r=fee,s=FEe,a=wEe;vEe(e,n,g(o,0),r,s,a);let c={};mee(c,t);let l=On.fromCartesian(r,AEe);return c.southWest_HIGH=new Da({componentDatatype:Q.FLOAT,componentsPerAttribute:3,normalize:!1,value:h.pack(l.high,[0,0,0])}),c.southWest_LOW=new Da({componentDatatype:Q.FLOAT,componentsPerAttribute:3,normalize:!1,value:h.pack(l.low,[0,0,0])}),c.eastward=new Da({componentDatatype:Q.FLOAT,componentsPerAttribute:3,normalize:!1,value:h.pack(s,[0,0,0])}),c.northward=new Da({componentDatatype:Q.FLOAT,componentsPerAttribute:3,normalize:!1,value:h.pack(a,[0,0,0])}),pee(e,i,c),c};var MEe=new h;function lee(e,t,n,i){let o=hee;o.latitude=e,o.longitude=t,o.height=0;let r=he.toCartesian(o,n,MEe),s=Math.sqrt(r.x*r.x+r.y*r.y),a=W.fastApproximateAtan2(s,r.z),c=W.fastApproximateAtan2(r.x,r.y);return i.x=a,i.y=c,i}var dee=new D;$d.getSphericalExtentGeometryInstanceAttributes=function(e,t,n,i){let o=lee(e.south,e.west,n,dee),r=o.x,s=o.y,a=lee(e.north,e.east,n,dee),c=a.x,l=a.y,u=0;s>l&&(u=W.PI-s,s=-W.PI,l+=u),r-=W.EPSILON5,s-=W.EPSILON5,c+=W.EPSILON5,l+=W.EPSILON5;let m=1/(l-s),p=1/(c-r),y={sphericalExtents:new Da({componentDatatype:Q.FLOAT,componentsPerAttribute:4,normalize:!1,value:[r,s,p,m]}),longitudeRotation:new Da({componentDatatype:Q.FLOAT,componentsPerAttribute:1,normalize:!1,value:[u]})};return mee(y,t),pee(e,i,y),y};$d.hasAttributesForTextureCoordinatePlanes=function(e){return d(e.southWest_HIGH)&&d(e.southWest_LOW)&&d(e.northward)&&d(e.eastward)&&d(e.planes2D_HIGH)&&d(e.planes2D_LOW)&&d(e.uMaxVmax)&&d(e.uvMinAndExtents)};$d.hasAttributesForSphericalExtents=function(e){return d(e.sphericalExtents)&&d(e.longitudeRotation)&&d(e.planes2D_HIGH)&&d(e.planes2D_LOW)&&d(e.uMaxVmax)&&d(e.uvMinAndExtents)};function NEe(e){return Math.max(e.width,e.height)>$d.MAX_WIDTH_FOR_PLANAR_EXTENTS}$d.shouldUseSphericalCoordinates=function(e){return NEe(e)};$d.MAX_WIDTH_FOR_PLANAR_EXTENTS=W.toRadians(1);var Ql=$d;var GYt=T(S(),1);var TYt=T(S(),1);var UEe={NEVER:ne.NEVER,LESS:ne.LESS,EQUAL:ne.EQUAL,LESS_OR_EQUAL:ne.LEQUAL,GREATER:ne.GREATER,NOT_EQUAL:ne.NOTEQUAL,GREATER_OR_EQUAL:ne.GEQUAL,ALWAYS:ne.ALWAYS},Dn=Object.freeze(UEe);var VYt=T(S(),1);var kEe={ZERO:ne.ZERO,KEEP:ne.KEEP,REPLACE:ne.REPLACE,INCREMENT:ne.INCR,DECREMENT:ne.DECR,INVERT:ne.INVERT,INCREMENT_WRAP:ne.INCR_WRAP,DECREMENT_WRAP:ne.DECR_WRAP},ht=Object.freeze(kEe);var uM={CESIUM_3D_TILE_MASK:128,SKIP_LOD_MASK:112,SKIP_LOD_BIT_SHIFT:4,CLASSIFICATION_MASK:15};uM.setCesium3DTileBit=function(){return{enabled:!0,frontFunction:Dn.ALWAYS,frontOperation:{fail:ht.KEEP,zFail:ht.KEEP,zPass:ht.REPLACE},backFunction:Dn.ALWAYS,backOperation:{fail:ht.KEEP,zFail:ht.KEEP,zPass:ht.REPLACE},reference:uM.CESIUM_3D_TILE_MASK,mask:uM.CESIUM_3D_TILE_MASK}};var wt=Object.freeze(uM);function Qg(e){e=g(e,g.EMPTY_OBJECT);let t=e.geometryInstances;this.geometryInstances=t,this.show=g(e.show,!0),this.classificationType=g(e.classificationType,kn.BOTH),this.debugShowBoundingVolume=g(e.debugShowBoundingVolume,!1),this.debugShowShadowVolume=g(e.debugShowShadowVolume,!1),this._debugShowShadowVolume=!1,this._extruded=g(e._extruded,!1),this._uniformMap=e._uniformMap,this._sp=void 0,this._spStencil=void 0,this._spPick=void 0,this._spColor=void 0,this._spPick2D=void 0,this._spColor2D=void 0,this._rsStencilDepthPass=void 0,this._rsStencilDepthPass3DTiles=void 0,this._rsColorPass=void 0,this._rsPickPass=void 0,this._commandsIgnoreShow=[],this._ready=!1,this._primitive=void 0,this._pickPrimitive=e._pickPrimitive,this._hasSphericalExtentsAttribute=!1,this._hasPlanarExtentsAttributes=!1,this._hasPerColorAttribute=!1,this.appearance=e.appearance,this._createBoundingVolumeFunction=e._createBoundingVolumeFunction,this._updateAndQueueCommandsFunction=e._updateAndQueueCommandsFunction,this._usePickOffsets=!1,this._primitiveOptions={geometryInstances:void 0,appearance:void 0,vertexCacheOptimize:g(e.vertexCacheOptimize,!1),interleave:g(e.interleave,!1),releaseGeometryInstances:g(e.releaseGeometryInstances,!0),allowPicking:g(e.allowPicking,!0),asynchronous:g(e.asynchronous,!0),compressVertices:g(e.compressVertices,!0),_createBoundingVolumeFunction:void 0,_createRenderStatesFunction:void 0,_createShaderProgramFunction:void 0,_createCommandsFunction:void 0,_updateAndQueueCommandsFunction:void 0,_createPickOffsets:!0}}Object.defineProperties(Qg.prototype,{vertexCacheOptimize:{get:function(){return this._primitiveOptions.vertexCacheOptimize}},interleave:{get:function(){return this._primitiveOptions.interleave}},releaseGeometryInstances:{get:function(){return this._primitiveOptions.releaseGeometryInstances}},allowPicking:{get:function(){return this._primitiveOptions.allowPicking}},asynchronous:{get:function(){return this._primitiveOptions.asynchronous}},compressVertices:{get:function(){return this._primitiveOptions.compressVertices}},ready:{get:function(){return this._ready}},_needs2DShader:{get:function(){return this._hasPlanarExtentsAttributes||this._hasSphericalExtentsAttribute}}});Qg.isSupported=function(e){return e.context.stencilBuffer};function _S(e,t){let n=t?Dn.EQUAL:Dn.ALWAYS;return{colorMask:{red:!1,green:!1,blue:!1,alpha:!1},stencilTest:{enabled:e,frontFunction:n,frontOperation:{fail:ht.KEEP,zFail:ht.DECREMENT_WRAP,zPass:ht.KEEP},backFunction:n,backOperation:{fail:ht.KEEP,zFail:ht.INCREMENT_WRAP,zPass:ht.KEEP},reference:wt.CESIUM_3D_TILE_MASK,mask:wt.CESIUM_3D_TILE_MASK},stencilMask:wt.CLASSIFICATION_MASK,depthTest:{enabled:!0,func:ka.LESS_OR_EQUAL},depthMask:!1}}function U3(e){return{stencilTest:{enabled:e,frontFunction:Dn.NOT_EQUAL,frontOperation:{fail:ht.ZERO,zFail:ht.ZERO,zPass:ht.ZERO},backFunction:Dn.NOT_EQUAL,backOperation:{fail:ht.ZERO,zFail:ht.ZERO,zPass:ht.ZERO},reference:0,mask:wt.CLASSIFICATION_MASK},stencilMask:wt.CLASSIFICATION_MASK,depthTest:{enabled:!1},depthMask:!1,blending:un.PRE_MULTIPLIED_ALPHA_BLEND}}var DEe={stencilTest:{enabled:!0,frontFunction:Dn.NOT_EQUAL,frontOperation:{fail:ht.ZERO,zFail:ht.ZERO,zPass:ht.ZERO},backFunction:Dn.NOT_EQUAL,backOperation:{fail:ht.ZERO,zFail:ht.ZERO,zPass:ht.ZERO},reference:0,mask:wt.CLASSIFICATION_MASK},stencilMask:wt.CLASSIFICATION_MASK,depthTest:{enabled:!1},depthMask:!1};function BEe(e,t,n,i){if(d(e._rsStencilDepthPass))return;let o=!e.debugShowShadowVolume;e._rsStencilDepthPass=De.fromCache(_S(o,!1)),e._rsStencilDepthPass3DTiles=De.fromCache(_S(o,!0)),e._rsColorPass=De.fromCache(U3(o,!1)),e._rsPickPass=De.fromCache(DEe)}function YEe(e,t){if(!e.compressVertices)return t;if(t.search(/in\s+vec3\s+extrudeDirection;/g)!==-1){let n="compressedAttributes",i=`in vec2 ${n};`,o=`vec3 extrudeDirection;
+`,r=` extrudeDirection = czm_octDecode(${n}, 65535.0);
+`,s=t;s=s.replace(/in\s+vec3\s+extrudeDirection;/g,""),s=Be.replaceMain(s,"czm_non_compressed_main");let a=`void main()
+{
+${r} czm_non_compressed_main();
+}`;return[i,o,s,a].join(`
+`)}}function OEe(e,t){let n=t.context,i=e._primitive,o=MG;o=e._primitive._batchTable.getVertexShaderCallback()(o),o=Zn._appendDistanceDisplayConditionToShader(i,o),o=Zn._modifyShaderPosition(e,o,t.scene3DOnly),o=Zn._updateColorAttribute(i,o);let r=e._hasPlanarExtentsAttributes,s=r||e._hasSphericalExtentsAttribute;e._extruded&&(o=YEe(i,o));let a=e._extruded?"EXTRUDED_GEOMETRY":"",c=new Be({defines:[a],sources:[o]}),l=new Be({sources:[mb]}),u=e._primitive._attributeLocations,m=new Ql(s,r,e.appearance);if(e._spStencil=Qt.replaceCache({context:n,shaderProgram:e._spStencil,vertexShaderSource:c,fragmentShaderSource:l,attributeLocations:u}),e._primitive.allowPicking){let f=Be.createPickVertexShaderSource(o);f=Zn._appendShowToShader(i,f),f=Zn._updatePickColorAttribute(f);let x=m.createPickFragmentShader(!1),_=m.createPickVertexShader([a],f,!1,t.mapProjection);if(e._spPick=Qt.replaceCache({context:n,shaderProgram:e._spPick,vertexShaderSource:_,fragmentShaderSource:x,attributeLocations:u}),s){let C=n.shaderCache.getDerivedShaderProgram(e._spPick,"2dPick");if(!d(C)){let V=m.createPickFragmentShader(!0),L=m.createPickVertexShader([a],f,!0,t.mapProjection);C=n.shaderCache.createDerivedShaderProgram(e._spPick,"2dPick",{vertexShaderSource:L,fragmentShaderSource:V,attributeLocations:u})}e._spPick2D=C}}else e._spPick=Qt.fromCache({context:n,vertexShaderSource:c,fragmentShaderSource:l,attributeLocations:u});o=Zn._appendShowToShader(i,o),c=new Be({defines:[a],sources:[o]}),e._sp=Qt.replaceCache({context:n,shaderProgram:e._sp,vertexShaderSource:c,fragmentShaderSource:l,attributeLocations:u});let p=m.createFragmentShader(!1),y=m.createVertexShader([a],o,!1,t.mapProjection);if(e._spColor=Qt.replaceCache({context:n,shaderProgram:e._spColor,vertexShaderSource:y,fragmentShaderSource:p,attributeLocations:u}),s){let f=n.shaderCache.getDerivedShaderProgram(e._spColor,"2dColor");if(!d(f)){let x=m.createFragmentShader(!0),_=m.createVertexShader([a],o,!0,t.mapProjection);f=n.shaderCache.createDerivedShaderProgram(e._spColor,"2dColor",{vertexShaderSource:_,fragmentShaderSource:x,attributeLocations:u})}e._spColor2D=f}}function KEe(e,t){let n=e._primitive,i=n._va.length*2;t.length=i;let o,r,s,a=0,c=n._batchTable.getUniformMapCallback()(e._uniformMap),l=e._needs2DShader;for(o=0;o0&&(c=o[0].attributes,p=Ql.hasAttributesForSphericalExtents(c),y=Ql.hasAttributesForTextureCoordinatePlanes(c),m=c.color),s=0;s{d(this._primitive)&&this._primitive.ready&&(this._ready=!0,this.releaseGeometryInstances&&(this.geometryInstances=void 0))})};Qg.prototype.getGeometryInstanceAttributes=function(e){return this._primitive.getGeometryInstanceAttributes(e)};Qg.prototype.isDestroyed=function(){return!1};Qg.prototype.destroy=function(){return this._primitive=this._primitive&&this._primitive.destroy(),this._sp=this._sp&&this._sp.destroy(),this._spPick=this._spPick&&this._spPick.destroy(),this._spColor=this._spColor&&this._spColor.destroy(),this._spPick2D=void 0,this._spColor2D=void 0,ue(this)};var TS=Qg;var QEe={u_globeMinimumAltitude:function(){return 55e3}};function dl(e){e=g(e,g.EMPTY_OBJECT);let t=e.appearance,n=e.geometryInstances;if(!d(t)&&d(n)){let o=Array.isArray(n)?n:[n],r=o.length;for(let s=0;s{!this._ready&&d(this._primitive)&&this._primitive.ready&&(this._ready=!0,this.releaseGeometryInstances&&(this.geometryInstances=void 0))})};dl.prototype.getBoundingSphere=function(e){let t=this._boundingSpheresKeys.indexOf(e);if(t!==-1)return this._boundingSpheres[t]};dl.prototype.getGeometryInstanceAttributes=function(e){return this._primitive.getGeometryInstanceAttributes(e)};dl.prototype.isDestroyed=function(){return!1};dl.prototype.destroy=function(){return this._primitive=this._primitive&&this._primitive.destroy(),ue(this)};dl._supportsMaterials=function(e){return e.depthTexture};dl.supportsMaterials=function(e){return dl._supportsMaterials(e.frameState.context)};var Rc=dl;var VOt=T(S(),1);function SS(){fe.throwInstantiationError()}Object.defineProperties(SS.prototype,{isConstant:{get:fe.throwInstantiationError},definitionChanged:{get:fe.throwInstantiationError}});SS.prototype.getType=fe.throwInstantiationError;SS.prototype.getValue=fe.throwInstantiationError;SS.prototype.equals=fe.throwInstantiationError;SS.getValue=function(e,t,n){let i;return d(t)&&(i=t.getType(e),d(i))?((!d(n)||n.type!==i)&&(n=ki.fromType(i)),t.getValue(e,n.uniforms),n):((!d(n)||n.type!==ki.ColorType)&&(n=ki.fromType(ki.ColorType)),B.clone(B.WHITE,n.uniforms.color),n)};var Yo=SS;function jg(e,t,n){this._primitives=t,this._orderedGroundPrimitives=n,this._primitive=void 0,this._outlinePrimitive=void 0,this._geometryUpdater=e,this._options=e._options,this._entity=e._entity,this._material=void 0}jg.prototype._isHidden=function(e,t,n){return!e.isShowing||!e.isAvailable(n)||!H.getValueOrDefault(t.show,n,!0)};jg.prototype._setOptions=fe.throwInstantiationError;jg.prototype.update=function(e){let t=this._geometryUpdater,n=t._onTerrain,i=this._primitives,o=this._orderedGroundPrimitives;n?o.remove(this._primitive):(i.removeAndDestroy(this._primitive),i.removeAndDestroy(this._outlinePrimitive),this._outlinePrimitive=void 0),this._primitive=void 0;let r=this._entity,s=r[this._geometryUpdater._geometryPropertyName];if(this._setOptions(r,s,e),this._isHidden(r,s,e))return;let a=this._geometryUpdater.shadowsProperty.getValue(e),c=this._options;if(!d(s.fill)||s.fill.getValue(e)){let l=t.fillMaterialProperty,u=l instanceof At,m,p=t._getIsClosed(c);if(u)m=new sn({closed:p,flat:n&&!t._supportsMaterialsforEntitiesOnTerrain});else{let y=Yo.getValue(e,l,this._material);this._material=y,m=new so({material:y,translucent:y.isTranslucent(),closed:p})}if(n)c.vertexFormat=sn.VERTEX_FORMAT,this._primitive=o.add(new Rc({geometryInstances:this._geometryUpdater.createFillGeometryInstance(e),appearance:m,asynchronous:!1,shadows:a,classificationType:this._geometryUpdater.classificationTypeProperty.getValue(e)}),H.getValueOrUndefined(this._geometryUpdater.zIndex,e));else{c.vertexFormat=m.vertexFormat;let y=this._geometryUpdater.createFillGeometryInstance(e);u&&(m.translucent=y.attributes.color.value[3]!==255),this._primitive=i.add(new Zn({geometryInstances:y,appearance:m,asynchronous:!1,shadows:a}))}}if(!n&&d(s.outline)&&s.outline.getValue(e)){let l=this._geometryUpdater.createOutlineGeometryInstance(e),u=H.getValueOrDefault(s.outlineWidth,e,1);this._outlinePrimitive=i.add(new Zn({geometryInstances:l,appearance:new sn({flat:!0,translucent:l.attributes.color.value[3]!==255,renderState:{lineWidth:t._scene.clampLineWidth(u)}}),asynchronous:!1,shadows:a}))}};jg.prototype.getBoundingSphere=function(e){let t=this._entity,n=this._primitive,i=this._outlinePrimitive,o;return d(n)&&n.show&&n.ready&&(o=n.getGeometryInstanceAttributes(t),d(o)&&d(o.boundingSphere))?(ce.clone(o.boundingSphere,e),lt.DONE):d(i)&&i.show&&i.ready&&(o=i.getGeometryInstanceAttributes(t),d(o)&&d(o.boundingSphere))?(ce.clone(o.boundingSphere,e),lt.DONE):d(n)&&!n.ready||d(i)&&!i.ready?lt.PENDING:lt.FAILED};jg.prototype.isDestroyed=function(){return!1};jg.prototype.destroy=function(){let e=this._primitives,t=this._orderedGroundPrimitives;this._geometryUpdater._onTerrain?t.remove(this._primitive):e.removeAndDestroy(this._primitive),e.removeAndDestroy(this._outlinePrimitive),ue(this)};var ii=jg;var ijt=T(S(),1);var U4t=T(S(),1);var YHt=T(S(),1);var WKt=T(S(),1);var UOt=T(S(),1),rXe={NONE:0,GEODESIC:1,RHUMB:2},Jt=Object.freeze(rXe);var OOt=T(S(),1);var Tee=W.EPSILON10;function sXe(e,t,n,i){if(!d(e))return;n=g(n,!1);let o=d(i),r=e.length;if(r<2)return e;let s,a=e[0],c,l,u=0,m=-1;for(s=1;sW.EPSILON12);let R=M*(t*t-n*n)/(n*n),E=1+R*(4096+R*(R*(320-175*R)-768))/16384,I=R*(256+R*(R*(74-47*R)-128))/1024,F=b*b,N=I*A*(b+I*(v*(2*F-1)-I*b*(4*A*A-3)*(4*F-3)/6)/4),Y=n*E*(P-N),k=Math.atan2(y*X,_-V*G),O=Math.atan2(m*X,_*G-V);e._distance=Y,e._startHeading=k,e._endHeading=O,e._uSquared=R}var dXe=new h,B3=new h;function Cee(e,t,n,i){let o=h.normalize(i.cartographicToCartesian(t,B3),dXe),r=h.normalize(i.cartographicToCartesian(n,B3),B3);lXe(e,i.maximumRadius,i.minimumRadius,t.longitude,t.latitude,n.longitude,n.latitude),e._start=he.clone(t,e._start),e._end=he.clone(n,e._end),e._start.height=0,e._end.height=0,aXe(e)}function zG(e,t,n){let i=g(n,re.WGS84);this._ellipsoid=i,this._start=new he,this._end=new he,this._constants={},this._startHeading=void 0,this._endHeading=void 0,this._distance=void 0,this._uSquared=void 0,d(e)&&d(t)&&Cee(this,e,t,i)}Object.defineProperties(zG.prototype,{ellipsoid:{get:function(){return this._ellipsoid}},surfaceDistance:{get:function(){return this._distance}},start:{get:function(){return this._start}},end:{get:function(){return this._end}},startHeading:{get:function(){return this._startHeading}},endHeading:{get:function(){return this._endHeading}}});zG.prototype.setEndPoints=function(e,t){Cee(this,e,t,this._ellipsoid)};zG.prototype.interpolateUsingFraction=function(e,t){return this.interpolateUsingSurfaceDistance(this._distance*e,t)};zG.prototype.interpolateUsingSurfaceDistance=function(e,t){let n=this._constants,i=n.distanceRatio+e/n.b,o=Math.cos(2*i),r=Math.cos(4*i),s=Math.cos(6*i),a=Math.sin(2*i),c=Math.sin(4*i),l=Math.sin(6*i),u=Math.sin(8*i),m=i*i,p=i*m,y=n.u8Over256,f=n.u2Over4,x=n.u6Over64,_=n.u4Over16,C=2*p*y*o/3+i*(1-f+7*_/4-15*x/4+579*y/64-(_-15*x/4+187*y/16)*o-(5*x/4-115*y/16)*r-29*y*s/16)+(f/2-_+71*x/32-85*y/16)*a+(5*_/16-5*x/4+383*y/96)*c-m*((x-11*y/2)*a+5*y*c/2)+(29*x/96-29*y/16)*l+539*y*u/1536,V=Math.asin(Math.sin(C)*n.cosineAlpha),L=Math.atan(n.a/n.b*Math.tan(V));C=C-n.sigma;let Z=Math.cos(2*n.sigma+C),G=Math.sin(C),X=Math.cos(C),P=n.cosineU*X,v=n.sineU*G,M=Math.atan2(G*n.sineHeading,P-v*n.cosineHeading)-See(n.f,n.sineAlpha,n.cosineSquaredAlpha,C,G,X,Z);return d(t)?(t.longitude=this._start.longitude+M,t.latitude=L,t.height=0,t):new he(this._start.longitude+M,L,0)};var eu=zG;var aKt=T(S(),1);function O3(e,t,n){if(e===0)return t*n;let i=e*e,o=i*i,r=o*i,s=r*i,a=s*i,c=a*i,l=n,u=Math.sin(2*l),m=Math.sin(4*l),p=Math.sin(6*l),y=Math.sin(8*l),f=Math.sin(10*l),x=Math.sin(12*l);return t*((1-i/4-3*o/64-5*r/256-175*s/16384-441*a/65536-4851*c/1048576)*l-(3*i/8+3*o/32+45*r/1024+105*s/4096+2205*a/131072+6237*c/524288)*u+(15*o/256+45*r/1024+525*s/16384+1575*a/65536+155925*c/8388608)*m-(35*r/3072+175*s/12288+3675*a/262144+13475*c/1048576)*p+(315*s/131072+2205*a/524288+43659*c/8388608)*y-(693*a/1310720+6237*c/5242880)*f+1001*c/8388608*x)}function uXe(e,t,n){let i=e/n;if(t===0)return i;let o=i*i,r=o*i,s=r*i,a=t,c=a*a,l=c*c,u=l*c,m=u*c,p=m*c,y=p*c,f=Math.sin(2*i),x=Math.cos(2*i),_=Math.sin(4*i),C=Math.cos(4*i),V=Math.sin(6*i),L=Math.cos(6*i),Z=Math.sin(8*i),G=Math.cos(8*i),X=Math.sin(10*i),P=Math.cos(10*i),v=Math.sin(12*i);return i+i*c/4+7*i*l/64+15*i*u/256+579*i*m/16384+1515*i*p/65536+16837*i*y/1048576+(3*i*l/16+45*i*u/256-i*(32*o-561)*m/4096-i*(232*o-1677)*p/16384+i*(399985-90560*o+512*s)*y/5242880)*x+(21*i*u/256+483*i*m/4096-i*(224*o-1969)*p/16384-i*(33152*o-112599)*y/1048576)*C+(151*i*m/4096+4681*i*p/65536+1479*i*y/16384-453*r*y/32768)*L+(1097*i*p/65536+42783*i*y/1048576)*G+8011*i*y/1048576*P+(3*c/8+3*l/16+213*u/2048-3*o*u/64+255*m/4096-33*o*m/512+20861*p/524288-33*o*p/512+s*p/1024+28273*y/1048576-471*o*y/8192+9*s*y/4096)*f+(21*l/256+21*u/256+533*m/8192-21*o*m/512+197*p/4096-315*o*p/4096+584039*y/16777216-12517*o*y/131072+7*s*y/2048)*_+(151*u/6144+151*m/4096+5019*p/131072-453*o*p/16384+26965*y/786432-8607*o*y/131072)*V+(1097*m/131072+1097*p/65536+225797*y/10485760-1097*o*y/65536)*Z+(8011*p/2621440+8011*y/1048576)*X+293393*y/251658240*v}function CS(e,t){if(e===0)return Math.log(Math.tan(.5*(W.PI_OVER_TWO+t)));let n=e*Math.sin(t);return Math.log(Math.tan(.5*(W.PI_OVER_TWO+t)))-e/2*Math.log((1+n)/(1-n))}function mXe(e,t,n,i,o){let r=CS(e._ellipticity,n),s=CS(e._ellipticity,o);return Math.atan2(W.negativePiToPi(i-t),s-r)}function hXe(e,t,n,i,o,r,s){let a=e._heading,c=r-i,l=0;if(W.equalsEpsilon(Math.abs(a),W.PI_OVER_TWO,W.EPSILON8))if(t===n)l=t*Math.cos(o)*W.negativePiToPi(c);else{let u=Math.sin(o);l=t*Math.cos(o)*W.negativePiToPi(c)/Math.sqrt(1-e._ellipticitySquared*u*u)}else{let u=O3(e._ellipticity,t,o);l=(O3(e._ellipticity,t,s)-u)/Math.cos(a)}return Math.abs(l)}var fXe=new h,Y3=new h;function Vee(e,t,n,i){let o=h.normalize(i.cartographicToCartesian(t,Y3),fXe),r=h.normalize(i.cartographicToCartesian(n,Y3),Y3),s=i.maximumRadius,a=i.minimumRadius,c=s*s,l=a*a;e._ellipticitySquared=(c-l)/c,e._ellipticity=Math.sqrt(e._ellipticitySquared),e._start=he.clone(t,e._start),e._start.height=0,e._end=he.clone(n,e._end),e._end.height=0,e._heading=mXe(e,t.longitude,t.latitude,n.longitude,n.latitude),e._distance=hXe(e,i.maximumRadius,i.minimumRadius,t.longitude,t.latitude,n.longitude,n.latitude)}function Lee(e,t,n,i,o,r){if(n===0)return he.clone(e,r);let s=o*o,a,c,l;if(Math.abs(W.PI_OVER_TWO-Math.abs(t))>W.EPSILON8){let u=O3(o,i,e.latitude),m=n*Math.cos(t),p=u+m;if(c=uXe(p,o,i),Math.abs(t)0?a=W.negativePiToPi(e.longitude+l):a=W.negativePiToPi(e.longitude-l)}return d(r)?(r.longitude=a,r.latitude=c,r.height=0,r):new he(a,c,0)}function ap(e,t,n){let i=g(n,re.WGS84);this._ellipsoid=i,this._start=new he,this._end=new he,this._heading=void 0,this._distance=void 0,this._ellipticity=void 0,this._ellipticitySquared=void 0,d(e)&&d(t)&&Vee(this,e,t,i)}Object.defineProperties(ap.prototype,{ellipsoid:{get:function(){return this._ellipsoid}},surfaceDistance:{get:function(){return this._distance}},start:{get:function(){return this._start}},end:{get:function(){return this._end}},heading:{get:function(){return this._heading}}});ap.fromStartHeadingDistance=function(e,t,n,i,o){let r=g(i,re.WGS84),s=r.maximumRadius,a=r.minimumRadius,c=s*s,l=a*a,u=Math.sqrt((c-l)/c);t=W.negativePiToPi(t);let m=Lee(e,t,n,r.maximumRadius,u);return!d(o)||d(i)&&!i.equals(o.ellipsoid)?new ap(e,m,r):(o.setEndPoints(e,m),o)};ap.prototype.setEndPoints=function(e,t){Vee(this,e,t,this._ellipsoid)};ap.prototype.interpolateUsingFraction=function(e,t){return this.interpolateUsingSurfaceDistance(e*this._distance,t)};ap.prototype.interpolateUsingSurfaceDistance=function(e,t){return Lee(this._start,this._heading,e,this._ellipsoid.maximumRadius,this._ellipticity,t)};ap.prototype.findIntersectionWithLongitude=function(e,t){let n=this._ellipticity,i=this._heading,o=Math.abs(i),r=this._start;if(e=W.negativePiToPi(e),W.equalsEpsilon(Math.abs(e),Math.PI,W.EPSILON14)&&(e=W.sign(r.longitude)*Math.PI),d(t)||(t=new he),Math.abs(W.PI_OVER_TWO-o)<=W.EPSILON8)return t.longitude=e,t.latitude=r.latitude,t.height=0,t;if(W.equalsEpsilon(Math.abs(W.PI_OVER_TWO-o),W.PI_OVER_TWO,W.EPSILON8))return W.equalsEpsilon(e,r.longitude,W.EPSILON12)?void 0:(t.longitude=e,t.latitude=W.PI_OVER_TWO*W.sign(W.PI_OVER_TWO-i),t.height=0,t);let s=r.latitude,a=n*Math.sin(s),c=Math.tan(.5*(W.PI_OVER_TWO+s))*Math.exp((e-r.longitude)/Math.tan(i)),l=(1+a)/(1-a),u=r.latitude,m;do{m=u;let p=n*Math.sin(m),y=(1+p)/(1-p);u=2*Math.atan(c*Math.pow(y/l,n/2))-W.PI_OVER_TWO}while(!W.equalsEpsilon(u,m,W.EPSILON12));return t.longitude=e,t.latitude=u,t.height=0,t};ap.prototype.findIntersectionWithLatitude=function(e,t){let n=this._ellipticity,i=this._heading,o=this._start;if(W.equalsEpsilon(Math.abs(i),W.PI_OVER_TWO,W.EPSILON8))return;let r=CS(n,o.latitude),s=CS(n,e),a=Math.tan(i)*(s-r),c=W.negativePiToPi(o.longitude+a);return d(t)?(t.longitude=c,t.latitude=e,t.height=0,t):new he(c,e,0)};var ha=ap;var $3=[Zi,Ei],pXe=$3.length,Oee=Math.cos(W.toRadians(30)),Ree=Math.cos(W.toRadians(150)),Kee=0,Hee=1e3;function pb(e){e=g(e,g.EMPTY_OBJECT);let t=e.positions;this.width=g(e.width,1),this._positions=t,this.granularity=g(e.granularity,9999),this.loop=g(e.loop,!1),this.arcType=g(e.arcType,Jt.GEODESIC),this._ellipsoid=re.WGS84,this._projectionIndex=0,this._workerName="createGroundPolylineGeometry",this._scene3DOnly=!1}Object.defineProperties(pb.prototype,{packedLength:{get:function(){return 1+this._positions.length*3+1+1+1+re.packedLength+1+1}}});pb.setProjectionAndEllipsoid=function(e,t){let n=0;for(let i=0;iOee||rW.PI_OVER_TWO&&(a=!0,s=h.subtract(r,n,vee),l=c.cartesianToCartographic(s,Pee)),l.height=0;let u=e.project(l,o);return o=h.subtract(u,i,o),o.z=0,o=h.normalize(o,o),a&&h.negate(o,o),o}var FXe=new h,Fee=new h;function wee(e,t,n,i,o,r){let s=h.subtract(t,e,FXe);h.normalize(s,s);let a=n-Kee,c=h.multiplyByScalar(s,a,Fee);h.add(e,c,o);let l=i-Hee;c=h.multiplyByScalar(s,l,Fee),h.add(t,c,r)}var wXe=new h;function pM(e,t){let n=on.getPointDistance(bM,e),i=on.getPointDistance(bM,t),o=wXe;W.equalsEpsilon(n,0,W.EPSILON2)?(o=cp(t,e,o),h.multiplyByScalar(o,W.EPSILON2,o),h.add(e,o,e)):W.equalsEpsilon(i,0,W.EPSILON2)&&(o=cp(e,t,o),h.multiplyByScalar(o,W.EPSILON2,o),h.add(t,o,t))}function AXe(e,t){let n=Math.abs(e.longitude),i=Math.abs(t.longitude);if(W.equalsEpsilon(n,W.PI,W.EPSILON11)){let o=W.sign(t.longitude);return e.longitude=o*(n-W.EPSILON11),1}else if(W.equalsEpsilon(i,W.PI,W.EPSILON11)){let o=W.sign(e.longitude);return t.longitude=o*(i-W.EPSILON11),2}return 0}var Jee=new he,Qee=new he,Aee=new h,J3=new h,Mee=new h,Nee=new h,MXe=new h,Uee=new h,NXe=[Jee,Qee],UXe=new de,kXe=new h,DXe=new h,BXe=new h,YXe=new h,OXe=new h,KXe=new h,Q3=new h,j3=new h,HXe=new h,zXe=new h,JXe=new h,kee=new h,QXe=new h,jXe=new h,qXe=new On,$Xe=new On,Dee=new h,eIe=new h,Bee=new h,tIe=[new ce,new ce],jee=[0,2,1,0,3,2,0,7,3,0,4,7,0,5,4,0,1,5,5,7,4,5,6,7,5,2,6,5,1,2,3,6,2,3,7,6],Yee=jee.length;function nIe(e,t,n,i,o,r,s){let a,c,l=t._ellipsoid,u=n.length/3-1,m=u*8,p=m*4,y=u*36,f=m>65535?new Uint32Array(y):new Uint16Array(y),x=new Float64Array(m*3),_=new Float32Array(p),C=new Float32Array(p),V=new Float32Array(p),L=new Float32Array(p),Z=new Float32Array(p),G,X,P,v;s&&(G=new Float32Array(p),X=new Float32Array(p),P=new Float32Array(p),v=new Float32Array(m*2));let A=r.length/2,M=0,b=Jee;b.height=0;let R=Qee;R.height=0;let E=Aee,I=J3;if(s)for(c=0,a=1;aOee?(yt=JG(t,b,ve,ke,Q3),ot=JG(t,R,j,ct,j3)):Ki===1?(ot=JG(t,R,j,ct,j3),yt.x=0,yt.y=W.sign(b.longitude-Math.abs(R.longitude)),yt.z=0):(yt=JG(t,b,ve,ke,Q3),ot.x=0,ot.y=W.sign(b.longitude-R.longitude),ot.z=0)}let ln=h.distance(Me,K),vn=On.fromCartesian(Ie,qXe),Dt=h.subtract(ee,Ie,HXe),Nt=h.normalize(Dt,kee),pe=h.subtract(Me,Ie,zXe);pe=h.normalize(pe,pe);let Ce=h.cross(Nt,pe,kee);Ce=h.normalize(Ce,Ce);let Ht=h.cross(pe,ve,QXe);Ht=h.normalize(Ht,Ht);let ut=h.subtract(K,ee,JXe);ut=h.normalize(ut,ut);let hi=h.cross(j,ut,jXe);hi=h.normalize(hi,hi);let ji=ln/N,pc=q/N,bs=0,ys,$r,Fe,je=0,qe=0;if(s){bs=h.distance(ke,ct),ys=On.fromCartesian(ke,$Xe),$r=h.subtract(ct,ke,Dee),Fe=h.normalize($r,eIe);let Ki=Fe.x;Fe.x=Fe.y,Fe.y=-Ki,je=bs/M,qe=be/M}for(Y=0;Y<8;Y++){let Ki=J+Y*4,ns=O+Y*2,zn=Ki+3,Fn=Y<4?1:-1,mn=Y===2||Y===3||Y===6||Y===7?1:-1;h.pack(vn.high,_,Ki),_[zn]=Dt.x,h.pack(vn.low,C,Ki),C[zn]=Dt.y,h.pack(Ht,V,Ki),V[zn]=Dt.z,h.pack(hi,L,Ki),L[zn]=ji*Fn,h.pack(Ce,Z,Ki);let _i=pc*mn;_i===0&&mn<0&&(_i=9),Z[zn]=_i,s&&(G[Ki]=ys.high.x,G[Ki+1]=ys.high.y,G[Ki+2]=ys.low.x,G[Ki+3]=ys.low.y,P[Ki]=-yt.y,P[Ki+1]=yt.x,P[Ki+2]=ot.y,P[Ki+3]=-ot.x,X[Ki]=$r.x,X[Ki+1]=$r.y,X[Ki+2]=Fe.x,X[Ki+3]=Fe.y,v[ns]=je*Fn,_i=qe*mn,_i===0&&mn<0&&(_i=9),v[ns+1]=_i)}let Qe=BXe,pt=YXe,Bt=kXe,Vn=DXe,di=de.fromCartographicArray(NXe,UXe),bo=li.getMinimumMaximumHeights(di,l),es=bo.minimumTerrainHeight,ts=bo.maximumTerrainHeight;Te+=Math.abs(es),Te+=Math.abs(ts),wee(Ie,Me,es,ts,Qe,Bt),wee(ee,K,es,ts,pt,Vn);let Mo=h.multiplyByScalar(Ce,W.EPSILON5,Bee);h.add(Qe,Mo,Qe),h.add(pt,Mo,pt),h.add(Bt,Mo,Bt),h.add(Vn,Mo,Vn),pM(Qe,pt),pM(Bt,Vn),h.pack(Qe,x,U),h.pack(pt,x,U+3),h.pack(Vn,x,U+6),h.pack(Bt,x,U+9),Mo=h.multiplyByScalar(Ce,-2*W.EPSILON5,Bee),h.add(Qe,Mo,Qe),h.add(pt,Mo,pt),h.add(Bt,Mo,Bt),h.add(Vn,Mo,Vn),pM(Qe,pt),pM(Bt,Vn),h.pack(Qe,x,U+12),h.pack(pt,x,U+15),h.pack(Vn,x,U+18),h.pack(Bt,x,U+21),k+=2,c+=3,O+=16,U+=24,J+=32,q+=ln,be+=bs}c=0;let ae=0;for(a=0;a halfMaxWidth || distanceFromStart < 0.0 || distanceFromEnd < 0.0) {
+#ifdef DEBUG_SHOW_VOLUME
+ out_FragColor = vec4(1.0, 0.0, 0.0, 0.5);
+ return;
+#else // DEBUG_SHOW_VOLUME
+ discard;
+#endif // DEBUG_SHOW_VOLUME
+ }
+
+ // Check distance of the eye coordinate against start and end planes with normals in the right plane.
+ // For computing unskewed lengthwise texture coordinate.
+ // Can also be used for clipping extremely pointy miters, but in practice unnecessary because of miter breaking.
+
+ // aligned plane: cross the right plane normal with miter plane normal, then cross the result with right again to point it more "forward"
+ vec3 alignedPlaneNormal;
+
+ // start aligned plane
+ alignedPlaneNormal = cross(v_rightPlaneEC.xyz, v_startPlaneNormalEcAndHalfWidth.xyz);
+ alignedPlaneNormal = normalize(cross(alignedPlaneNormal, v_rightPlaneEC.xyz));
+ distanceFromStart = czm_planeDistance(alignedPlaneNormal, -dot(alignedPlaneNormal, ecStart), eyeCoordinate.xyz);
+
+ // end aligned plane
+ alignedPlaneNormal = cross(v_rightPlaneEC.xyz, v_endPlaneNormalEcAndBatchId.xyz);
+ alignedPlaneNormal = normalize(cross(alignedPlaneNormal, v_rightPlaneEC.xyz));
+ distanceFromEnd = czm_planeDistance(alignedPlaneNormal, -dot(alignedPlaneNormal, v_endEcAndStartEcX.xyz), eyeCoordinate.xyz);
+
+#ifdef PER_INSTANCE_COLOR
+ out_FragColor = czm_gammaCorrect(v_color);
+#else // PER_INSTANCE_COLOR
+ // Clamp - distance to aligned planes may be negative due to mitering,
+ // so fragment texture coordinate might be out-of-bounds.
+ float s = clamp(distanceFromStart / (distanceFromStart + distanceFromEnd), 0.0, 1.0);
+ s = (s * v_texcoordNormalizationAndStartEcYZ.x) + v_texcoordNormalizationAndStartEcYZ.y;
+ float t = (widthwiseDistance + halfMaxWidth) / (2.0 * halfMaxWidth);
+
+ czm_materialInput materialInput;
+
+ materialInput.s = s;
+ materialInput.st = vec2(s, t);
+ materialInput.str = vec3(s, t, 0.0);
+
+ czm_material material = czm_getMaterial(materialInput);
+ out_FragColor = vec4(material.diffuse + material.emission, material.alpha);
+#endif // PER_INSTANCE_COLOR
+
+ // Premultiply alpha. Required for classification primitives on translucent globe.
+ out_FragColor.rgb *= out_FragColor.a;
+
+ czm_writeDepthClamp();
+}
+`;var wKt=T(S(),1),jG=`in vec3 v_forwardDirectionEC;
+in vec3 v_texcoordNormalizationAndHalfWidth;
+in float v_batchId;
+
+#ifdef PER_INSTANCE_COLOR
+in vec4 v_color;
+#else
+in vec2 v_alignedPlaneDistances;
+in float v_texcoordT;
+#endif
+
+float rayPlaneDistanceUnsafe(vec3 origin, vec3 direction, vec3 planeNormal, float planeDistance) {
+ // We don't expect the ray to ever be parallel to the plane
+ return (-planeDistance - dot(planeNormal, origin)) / dot(planeNormal, direction);
+}
+
+void main(void)
+{
+ vec4 eyeCoordinate = gl_FragCoord;
+ eyeCoordinate /= eyeCoordinate.w;
+
+#ifdef PER_INSTANCE_COLOR
+ out_FragColor = czm_gammaCorrect(v_color);
+#else // PER_INSTANCE_COLOR
+ // Use distances for planes aligned with segment to prevent skew in dashing
+ float distanceFromStart = rayPlaneDistanceUnsafe(eyeCoordinate.xyz, -v_forwardDirectionEC, v_forwardDirectionEC.xyz, v_alignedPlaneDistances.x);
+ float distanceFromEnd = rayPlaneDistanceUnsafe(eyeCoordinate.xyz, v_forwardDirectionEC, -v_forwardDirectionEC.xyz, v_alignedPlaneDistances.y);
+
+ // Clamp - distance to aligned planes may be negative due to mitering
+ distanceFromStart = max(0.0, distanceFromStart);
+ distanceFromEnd = max(0.0, distanceFromEnd);
+
+ float s = distanceFromStart / (distanceFromStart + distanceFromEnd);
+ s = (s * v_texcoordNormalizationAndHalfWidth.x) + v_texcoordNormalizationAndHalfWidth.y;
+
+ czm_materialInput materialInput;
+
+ materialInput.s = s;
+ materialInput.st = vec2(s, v_texcoordT);
+ materialInput.str = vec3(s, v_texcoordT, 0.0);
+
+ czm_material material = czm_getMaterial(materialInput);
+ out_FragColor = vec4(material.diffuse + material.emission, material.alpha);
+#endif // PER_INSTANCE_COLOR
+}
+`;var MKt=T(S(),1),qG=`in vec3 position3DHigh;
+in vec3 position3DLow;
+
+in vec4 startHiAndForwardOffsetX;
+in vec4 startLoAndForwardOffsetY;
+in vec4 startNormalAndForwardOffsetZ;
+in vec4 endNormalAndTextureCoordinateNormalizationX;
+in vec4 rightNormalAndTextureCoordinateNormalizationY;
+in vec4 startHiLo2D;
+in vec4 offsetAndRight2D;
+in vec4 startEndNormals2D;
+in vec2 texcoordNormalization2D;
+
+in float batchId;
+
+out vec3 v_forwardDirectionEC;
+out vec3 v_texcoordNormalizationAndHalfWidth;
+out float v_batchId;
+
+// For materials
+#ifdef WIDTH_VARYING
+out float v_width;
+#endif
+#ifdef ANGLE_VARYING
+out float v_polylineAngle;
+#endif
+
+#ifdef PER_INSTANCE_COLOR
+out vec4 v_color;
+#else
+out vec2 v_alignedPlaneDistances;
+out float v_texcoordT;
+#endif
+
+// Morphing planes using SLERP or NLERP doesn't seem to work, so instead draw the material directly on the shadow volume.
+// Morph views are from very far away and aren't meant to be used precisely, so this should be sufficient.
+void main()
+{
+ v_batchId = batchId;
+
+ // Start position
+ vec4 posRelativeToEye2D = czm_translateRelativeToEye(vec3(0.0, startHiLo2D.xy), vec3(0.0, startHiLo2D.zw));
+ vec4 posRelativeToEye3D = czm_translateRelativeToEye(startHiAndForwardOffsetX.xyz, startLoAndForwardOffsetY.xyz);
+ vec4 posRelativeToEye = czm_columbusViewMorph(posRelativeToEye2D, posRelativeToEye3D, czm_morphTime);
+ vec3 posEc2D = (czm_modelViewRelativeToEye * posRelativeToEye2D).xyz;
+ vec3 posEc3D = (czm_modelViewRelativeToEye * posRelativeToEye3D).xyz;
+ vec3 startEC = (czm_modelViewRelativeToEye * posRelativeToEye).xyz;
+
+ // Start plane
+ vec4 startPlane2D;
+ vec4 startPlane3D;
+ startPlane2D.xyz = czm_normal * vec3(0.0, startEndNormals2D.xy);
+ startPlane3D.xyz = czm_normal * startNormalAndForwardOffsetZ.xyz;
+ startPlane2D.w = -dot(startPlane2D.xyz, posEc2D);
+ startPlane3D.w = -dot(startPlane3D.xyz, posEc3D);
+
+ // Right plane
+ vec4 rightPlane2D;
+ vec4 rightPlane3D;
+ rightPlane2D.xyz = czm_normal * vec3(0.0, offsetAndRight2D.zw);
+ rightPlane3D.xyz = czm_normal * rightNormalAndTextureCoordinateNormalizationY.xyz;
+ rightPlane2D.w = -dot(rightPlane2D.xyz, posEc2D);
+ rightPlane3D.w = -dot(rightPlane3D.xyz, posEc3D);
+
+ // End position
+ posRelativeToEye2D = posRelativeToEye2D + vec4(0.0, offsetAndRight2D.xy, 0.0);
+ posRelativeToEye3D = posRelativeToEye3D + vec4(startHiAndForwardOffsetX.w, startLoAndForwardOffsetY.w, startNormalAndForwardOffsetZ.w, 0.0);
+ posRelativeToEye = czm_columbusViewMorph(posRelativeToEye2D, posRelativeToEye3D, czm_morphTime);
+ posEc2D = (czm_modelViewRelativeToEye * posRelativeToEye2D).xyz;
+ posEc3D = (czm_modelViewRelativeToEye * posRelativeToEye3D).xyz;
+ vec3 endEC = (czm_modelViewRelativeToEye * posRelativeToEye).xyz;
+ vec3 forwardEc3D = czm_normal * normalize(vec3(startHiAndForwardOffsetX.w, startLoAndForwardOffsetY.w, startNormalAndForwardOffsetZ.w));
+ vec3 forwardEc2D = czm_normal * normalize(vec3(0.0, offsetAndRight2D.xy));
+
+ // End plane
+ vec4 endPlane2D;
+ vec4 endPlane3D;
+ endPlane2D.xyz = czm_normal * vec3(0.0, startEndNormals2D.zw);
+ endPlane3D.xyz = czm_normal * endNormalAndTextureCoordinateNormalizationX.xyz;
+ endPlane2D.w = -dot(endPlane2D.xyz, posEc2D);
+ endPlane3D.w = -dot(endPlane3D.xyz, posEc3D);
+
+ // Forward direction
+ v_forwardDirectionEC = normalize(endEC - startEC);
+
+ vec2 cleanTexcoordNormalization2D;
+ cleanTexcoordNormalization2D.x = abs(texcoordNormalization2D.x);
+ cleanTexcoordNormalization2D.y = czm_branchFreeTernary(texcoordNormalization2D.y > 1.0, 0.0, abs(texcoordNormalization2D.y));
+ vec2 cleanTexcoordNormalization3D;
+ cleanTexcoordNormalization3D.x = abs(endNormalAndTextureCoordinateNormalizationX.w);
+ cleanTexcoordNormalization3D.y = rightNormalAndTextureCoordinateNormalizationY.w;
+ cleanTexcoordNormalization3D.y = czm_branchFreeTernary(cleanTexcoordNormalization3D.y > 1.0, 0.0, abs(cleanTexcoordNormalization3D.y));
+
+ v_texcoordNormalizationAndHalfWidth.xy = mix(cleanTexcoordNormalization2D, cleanTexcoordNormalization3D, czm_morphTime);
+
+#ifdef PER_INSTANCE_COLOR
+ v_color = czm_batchTable_color(batchId);
+#else // PER_INSTANCE_COLOR
+ // For computing texture coordinates
+
+ v_alignedPlaneDistances.x = -dot(v_forwardDirectionEC, startEC);
+ v_alignedPlaneDistances.y = -dot(-v_forwardDirectionEC, endEC);
+#endif // PER_INSTANCE_COLOR
+
+#ifdef WIDTH_VARYING
+ float width = czm_batchTable_width(batchId);
+ float halfWidth = width * 0.5;
+ v_width = width;
+ v_texcoordNormalizationAndHalfWidth.z = halfWidth;
+#else
+ float halfWidth = 0.5 * czm_batchTable_width(batchId);
+ v_texcoordNormalizationAndHalfWidth.z = halfWidth;
+#endif
+
+ // Compute a normal along which to "push" the position out, extending the miter depending on view distance.
+ // Position has already been "pushed" by unit length along miter normal, and miter normals are encoded in the planes.
+ // Decode the normal to use at this specific vertex, push the position back, and then push to where it needs to be.
+ // Since this is morphing, compute both 3D and 2D positions and then blend.
+
+ // ****** 3D ******
+ // Check distance to the end plane and start plane, pick the plane that is closer
+ vec4 positionEc3D = czm_modelViewRelativeToEye * czm_translateRelativeToEye(position3DHigh, position3DLow); // w = 1.0, see czm_computePosition
+ float absStartPlaneDistance = abs(czm_planeDistance(startPlane3D, positionEc3D.xyz));
+ float absEndPlaneDistance = abs(czm_planeDistance(endPlane3D, positionEc3D.xyz));
+ vec3 planeDirection = czm_branchFreeTernary(absStartPlaneDistance < absEndPlaneDistance, startPlane3D.xyz, endPlane3D.xyz);
+ vec3 upOrDown = normalize(cross(rightPlane3D.xyz, planeDirection)); // Points "up" for start plane, "down" at end plane.
+ vec3 normalEC = normalize(cross(planeDirection, upOrDown)); // In practice, the opposite seems to work too.
+
+ // Nudge the top vertex upwards to prevent flickering
+ vec3 geodeticSurfaceNormal = normalize(cross(normalEC, forwardEc3D));
+ geodeticSurfaceNormal *= float(0.0 <= rightNormalAndTextureCoordinateNormalizationY.w && rightNormalAndTextureCoordinateNormalizationY.w <= 1.0);
+ geodeticSurfaceNormal *= MAX_TERRAIN_HEIGHT;
+ positionEc3D.xyz += geodeticSurfaceNormal;
+
+ // Determine if this vertex is on the "left" or "right"
+ normalEC *= sign(endNormalAndTextureCoordinateNormalizationX.w);
+
+ // A "perfect" implementation would push along normals according to the angle against forward.
+ // In practice, just pushing the normal out by halfWidth is sufficient for morph views.
+ positionEc3D.xyz += halfWidth * max(0.0, czm_metersPerPixel(positionEc3D)) * normalEC; // prevent artifacts when czm_metersPerPixel is negative (behind camera)
+
+ // ****** 2D ******
+ // Check distance to the end plane and start plane, pick the plane that is closer
+ vec4 positionEc2D = czm_modelViewRelativeToEye * czm_translateRelativeToEye(position2DHigh.zxy, position2DLow.zxy); // w = 1.0, see czm_computePosition
+ absStartPlaneDistance = abs(czm_planeDistance(startPlane2D, positionEc2D.xyz));
+ absEndPlaneDistance = abs(czm_planeDistance(endPlane2D, positionEc2D.xyz));
+ planeDirection = czm_branchFreeTernary(absStartPlaneDistance < absEndPlaneDistance, startPlane2D.xyz, endPlane2D.xyz);
+ upOrDown = normalize(cross(rightPlane2D.xyz, planeDirection)); // Points "up" for start plane, "down" at end plane.
+ normalEC = normalize(cross(planeDirection, upOrDown)); // In practice, the opposite seems to work too.
+
+ // Nudge the top vertex upwards to prevent flickering
+ geodeticSurfaceNormal = normalize(cross(normalEC, forwardEc2D));
+ geodeticSurfaceNormal *= float(0.0 <= texcoordNormalization2D.y && texcoordNormalization2D.y <= 1.0);
+ geodeticSurfaceNormal *= MAX_TERRAIN_HEIGHT;
+ positionEc2D.xyz += geodeticSurfaceNormal;
+
+ // Determine if this vertex is on the "left" or "right"
+ normalEC *= sign(texcoordNormalization2D.x);
+#ifndef PER_INSTANCE_COLOR
+ // Use vertex's sidedness to compute its texture coordinate.
+ v_texcoordT = clamp(sign(texcoordNormalization2D.x), 0.0, 1.0);
+#endif
+
+ // A "perfect" implementation would push along normals according to the angle against forward.
+ // In practice, just pushing the normal out by halfWidth is sufficient for morph views.
+ positionEc2D.xyz += halfWidth * max(0.0, czm_metersPerPixel(positionEc2D)) * normalEC; // prevent artifacts when czm_metersPerPixel is negative (behind camera)
+
+ // Blend for actual position
+ gl_Position = czm_projection * mix(positionEc2D, positionEc3D, czm_morphTime);
+
+#ifdef ANGLE_VARYING
+ // Approximate relative screen space direction of the line.
+ vec2 approxLineDirection = normalize(vec2(v_forwardDirectionEC.x, -v_forwardDirectionEC.y));
+ approxLineDirection.y = czm_branchFreeTernary(approxLineDirection.x == 0.0 && approxLineDirection.y == 0.0, -1.0, approxLineDirection.y);
+ v_polylineAngle = czm_fastApproximateAtan(approxLineDirection.x, approxLineDirection.y);
+#endif
+}
+`;var UKt=T(S(),1),$G=`in vec3 position3DHigh;
+in vec3 position3DLow;
+
+// In 2D and in 3D, texture coordinate normalization component signs encodes:
+// * X sign - sidedness relative to right plane
+// * Y sign - is negative OR magnitude is greater than 1.0 if vertex is on bottom of volume
+#ifndef COLUMBUS_VIEW_2D
+in vec4 startHiAndForwardOffsetX;
+in vec4 startLoAndForwardOffsetY;
+in vec4 startNormalAndForwardOffsetZ;
+in vec4 endNormalAndTextureCoordinateNormalizationX;
+in vec4 rightNormalAndTextureCoordinateNormalizationY;
+#else
+in vec4 startHiLo2D;
+in vec4 offsetAndRight2D;
+in vec4 startEndNormals2D;
+in vec2 texcoordNormalization2D;
+#endif
+
+in float batchId;
+
+out vec4 v_startPlaneNormalEcAndHalfWidth;
+out vec4 v_endPlaneNormalEcAndBatchId;
+out vec4 v_rightPlaneEC;
+out vec4 v_endEcAndStartEcX;
+out vec4 v_texcoordNormalizationAndStartEcYZ;
+
+// For materials
+#ifdef WIDTH_VARYING
+out float v_width;
+#endif
+#ifdef ANGLE_VARYING
+out float v_polylineAngle;
+#endif
+
+#ifdef PER_INSTANCE_COLOR
+out vec4 v_color;
+#endif
+
+void main()
+{
+#ifdef COLUMBUS_VIEW_2D
+ vec3 ecStart = (czm_modelViewRelativeToEye * czm_translateRelativeToEye(vec3(0.0, startHiLo2D.xy), vec3(0.0, startHiLo2D.zw))).xyz;
+
+ vec3 forwardDirectionEC = czm_normal * vec3(0.0, offsetAndRight2D.xy);
+ vec3 ecEnd = forwardDirectionEC + ecStart;
+ forwardDirectionEC = normalize(forwardDirectionEC);
+
+ // Right plane
+ v_rightPlaneEC.xyz = czm_normal * vec3(0.0, offsetAndRight2D.zw);
+ v_rightPlaneEC.w = -dot(v_rightPlaneEC.xyz, ecStart);
+
+ // start plane
+ vec4 startPlaneEC;
+ startPlaneEC.xyz = czm_normal * vec3(0.0, startEndNormals2D.xy);
+ startPlaneEC.w = -dot(startPlaneEC.xyz, ecStart);
+
+ // end plane
+ vec4 endPlaneEC;
+ endPlaneEC.xyz = czm_normal * vec3(0.0, startEndNormals2D.zw);
+ endPlaneEC.w = -dot(endPlaneEC.xyz, ecEnd);
+
+ v_texcoordNormalizationAndStartEcYZ.x = abs(texcoordNormalization2D.x);
+ v_texcoordNormalizationAndStartEcYZ.y = texcoordNormalization2D.y;
+
+#else // COLUMBUS_VIEW_2D
+ vec3 ecStart = (czm_modelViewRelativeToEye * czm_translateRelativeToEye(startHiAndForwardOffsetX.xyz, startLoAndForwardOffsetY.xyz)).xyz;
+ vec3 offset = czm_normal * vec3(startHiAndForwardOffsetX.w, startLoAndForwardOffsetY.w, startNormalAndForwardOffsetZ.w);
+ vec3 ecEnd = ecStart + offset;
+
+ vec3 forwardDirectionEC = normalize(offset);
+
+ // start plane
+ vec4 startPlaneEC;
+ startPlaneEC.xyz = czm_normal * startNormalAndForwardOffsetZ.xyz;
+ startPlaneEC.w = -dot(startPlaneEC.xyz, ecStart);
+
+ // end plane
+ vec4 endPlaneEC;
+ endPlaneEC.xyz = czm_normal * endNormalAndTextureCoordinateNormalizationX.xyz;
+ endPlaneEC.w = -dot(endPlaneEC.xyz, ecEnd);
+
+ // Right plane
+ v_rightPlaneEC.xyz = czm_normal * rightNormalAndTextureCoordinateNormalizationY.xyz;
+ v_rightPlaneEC.w = -dot(v_rightPlaneEC.xyz, ecStart);
+
+ v_texcoordNormalizationAndStartEcYZ.x = abs(endNormalAndTextureCoordinateNormalizationX.w);
+ v_texcoordNormalizationAndStartEcYZ.y = rightNormalAndTextureCoordinateNormalizationY.w;
+
+#endif // COLUMBUS_VIEW_2D
+
+ v_endEcAndStartEcX.xyz = ecEnd;
+ v_endEcAndStartEcX.w = ecStart.x;
+ v_texcoordNormalizationAndStartEcYZ.zw = ecStart.yz;
+
+#ifdef PER_INSTANCE_COLOR
+ v_color = czm_batchTable_color(batchId);
+#endif // PER_INSTANCE_COLOR
+
+ // Compute a normal along which to "push" the position out, extending the miter depending on view distance.
+ // Position has already been "pushed" by unit length along miter normal, and miter normals are encoded in the planes.
+ // Decode the normal to use at this specific vertex, push the position back, and then push to where it needs to be.
+ vec4 positionRelativeToEye = czm_computePosition();
+
+ // Check distance to the end plane and start plane, pick the plane that is closer
+ vec4 positionEC = czm_modelViewRelativeToEye * positionRelativeToEye; // w = 1.0, see czm_computePosition
+ float absStartPlaneDistance = abs(czm_planeDistance(startPlaneEC, positionEC.xyz));
+ float absEndPlaneDistance = abs(czm_planeDistance(endPlaneEC, positionEC.xyz));
+ vec3 planeDirection = czm_branchFreeTernary(absStartPlaneDistance < absEndPlaneDistance, startPlaneEC.xyz, endPlaneEC.xyz);
+ vec3 upOrDown = normalize(cross(v_rightPlaneEC.xyz, planeDirection)); // Points "up" for start plane, "down" at end plane.
+ vec3 normalEC = normalize(cross(planeDirection, upOrDown)); // In practice, the opposite seems to work too.
+
+ // Extrude bottom vertices downward for far view distances, like for GroundPrimitives
+ upOrDown = cross(forwardDirectionEC, normalEC);
+ upOrDown = float(czm_sceneMode == czm_sceneMode3D) * upOrDown;
+ upOrDown = float(v_texcoordNormalizationAndStartEcYZ.y > 1.0 || v_texcoordNormalizationAndStartEcYZ.y < 0.0) * upOrDown;
+ upOrDown = min(GLOBE_MINIMUM_ALTITUDE, czm_geometricToleranceOverMeter * length(positionRelativeToEye.xyz)) * upOrDown;
+ positionEC.xyz += upOrDown;
+
+ v_texcoordNormalizationAndStartEcYZ.y = czm_branchFreeTernary(v_texcoordNormalizationAndStartEcYZ.y > 1.0, 0.0, abs(v_texcoordNormalizationAndStartEcYZ.y));
+
+ // Determine distance along normalEC to push for a volume of appropriate width.
+ // Make volumes about double pixel width for a conservative fit - in practice the
+ // extra cost here is minimal compared to the loose volume heights.
+ //
+ // N = normalEC (guaranteed "right-facing")
+ // R = rightEC
+ // p = angle between N and R
+ // w = distance to push along R if R == N
+ // d = distance to push along N
+ //
+ // N R
+ // { p| } * cos(p) = dot(N, R) = w / d
+ // d | |w * d = w / dot(N, R)
+ // { | }
+ // o---------- polyline segment ---->
+ //
+ float width = czm_batchTable_width(batchId);
+#ifdef WIDTH_VARYING
+ v_width = width;
+#endif
+
+ v_startPlaneNormalEcAndHalfWidth.xyz = startPlaneEC.xyz;
+ v_startPlaneNormalEcAndHalfWidth.w = width * 0.5;
+
+ v_endPlaneNormalEcAndBatchId.xyz = endPlaneEC.xyz;
+ v_endPlaneNormalEcAndBatchId.w = batchId;
+
+ width = width * max(0.0, czm_metersPerPixel(positionEC)); // width = distance to push along R
+ width = width / dot(normalEC, v_rightPlaneEC.xyz); // width = distance to push along N
+
+ // Determine if this vertex is on the "left" or "right"
+#ifdef COLUMBUS_VIEW_2D
+ normalEC *= sign(texcoordNormalization2D.x);
+#else
+ normalEC *= sign(endNormalAndTextureCoordinateNormalizationX.w);
+#endif
+
+ positionEC.xyz += width * normalEC;
+ gl_Position = czm_depthClamp(czm_projection * positionEC);
+
+#ifdef ANGLE_VARYING
+ // Approximate relative screen space direction of the line.
+ vec2 approxLineDirection = normalize(vec2(forwardDirectionEC.x, -forwardDirectionEC.y));
+ approxLineDirection.y = czm_branchFreeTernary(approxLineDirection.x == 0.0 && approxLineDirection.y == 0.0, -1.0, approxLineDirection.y);
+ v_polylineAngle = czm_fastApproximateAtan(approxLineDirection.x, approxLineDirection.y);
+#endif
+}
+`;var $Kt=T(S(),1);var DKt=T(S(),1),eE=`in vec3 position3DHigh;
+in vec3 position3DLow;
+in vec3 prevPosition3DHigh;
+in vec3 prevPosition3DLow;
+in vec3 nextPosition3DHigh;
+in vec3 nextPosition3DLow;
+in vec2 expandAndWidth;
+in vec4 color;
+in float batchId;
+
+out vec4 v_color;
+
+void main()
+{
+ float expandDir = expandAndWidth.x;
+ float width = abs(expandAndWidth.y) + 0.5;
+ bool usePrev = expandAndWidth.y < 0.0;
+
+ vec4 p = czm_computePosition();
+ vec4 prev = czm_computePrevPosition();
+ vec4 next = czm_computeNextPosition();
+
+ float angle;
+ vec4 positionWC = getPolylineWindowCoordinates(p, prev, next, expandDir, width, usePrev, angle);
+ gl_Position = czm_viewportOrthographic * positionWC;
+
+ v_color = color;
+}
+`;var YKt=T(S(),1),jl=`void clipLineSegmentToNearPlane(
+ vec3 p0,
+ vec3 p1,
+ out vec4 positionWC,
+ out bool clipped,
+ out bool culledByNearPlane,
+ out vec4 clippedPositionEC)
+{
+ culledByNearPlane = false;
+ clipped = false;
+
+ vec3 p0ToP1 = p1 - p0;
+ float magnitude = length(p0ToP1);
+ vec3 direction = normalize(p0ToP1);
+
+ // Distance that p0 is behind the near plane. Negative means p0 is
+ // in front of the near plane.
+ float endPoint0Distance = czm_currentFrustum.x + p0.z;
+
+ // Camera looks down -Z.
+ // When moving a point along +Z: LESS VISIBLE
+ // * Points in front of the camera move closer to the camera.
+ // * Points behind the camrea move farther away from the camera.
+ // When moving a point along -Z: MORE VISIBLE
+ // * Points in front of the camera move farther away from the camera.
+ // * Points behind the camera move closer to the camera.
+
+ // Positive denominator: -Z, becoming more visible
+ // Negative denominator: +Z, becoming less visible
+ // Nearly zero: parallel to near plane
+ float denominator = -direction.z;
+
+ if (endPoint0Distance > 0.0 && abs(denominator) < czm_epsilon7)
+ {
+ // p0 is behind the near plane and the line to p1 is nearly parallel to
+ // the near plane, so cull the segment completely.
+ culledByNearPlane = true;
+ }
+ else if (endPoint0Distance > 0.0)
+ {
+ // p0 is behind the near plane, and the line to p1 is moving distinctly
+ // toward or away from it.
+
+ // t = (-plane distance - dot(plane normal, ray origin)) / dot(plane normal, ray direction)
+ float t = endPoint0Distance / denominator;
+ if (t < 0.0 || t > magnitude)
+ {
+ // Near plane intersection is not between the two points.
+ // We already confirmed p0 is behind the naer plane, so now
+ // we know the entire segment is behind it.
+ culledByNearPlane = true;
+ }
+ else
+ {
+ // Segment crosses the near plane, update p0 to lie exactly on it.
+ p0 = p0 + t * direction;
+
+ // Numerical noise might put us a bit on the wrong side of the near plane.
+ // Don't let that happen.
+ p0.z = min(p0.z, -czm_currentFrustum.x);
+
+ clipped = true;
+ }
+ }
+
+ clippedPositionEC = vec4(p0, 1.0);
+ positionWC = czm_eyeToWindowCoordinates(clippedPositionEC);
+}
+
+vec4 getPolylineWindowCoordinatesEC(vec4 positionEC, vec4 prevEC, vec4 nextEC, float expandDirection, float width, bool usePrevious, out float angle)
+{
+ // expandDirection +1 is to the _left_ when looking from positionEC toward nextEC.
+
+#ifdef POLYLINE_DASH
+ // Compute the window coordinates of the points.
+ vec4 positionWindow = czm_eyeToWindowCoordinates(positionEC);
+ vec4 previousWindow = czm_eyeToWindowCoordinates(prevEC);
+ vec4 nextWindow = czm_eyeToWindowCoordinates(nextEC);
+
+ // Determine the relative screen space direction of the line.
+ vec2 lineDir;
+ if (usePrevious) {
+ lineDir = normalize(positionWindow.xy - previousWindow.xy);
+ }
+ else {
+ lineDir = normalize(nextWindow.xy - positionWindow.xy);
+ }
+ angle = atan(lineDir.x, lineDir.y) - 1.570796327; // precomputed atan(1,0)
+
+ // Quantize the angle so it doesn't change rapidly between segments.
+ angle = floor(angle / czm_piOverFour + 0.5) * czm_piOverFour;
+#endif
+
+ vec4 clippedPrevWC, clippedPrevEC;
+ bool prevSegmentClipped, prevSegmentCulled;
+ clipLineSegmentToNearPlane(prevEC.xyz, positionEC.xyz, clippedPrevWC, prevSegmentClipped, prevSegmentCulled, clippedPrevEC);
+
+ vec4 clippedNextWC, clippedNextEC;
+ bool nextSegmentClipped, nextSegmentCulled;
+ clipLineSegmentToNearPlane(nextEC.xyz, positionEC.xyz, clippedNextWC, nextSegmentClipped, nextSegmentCulled, clippedNextEC);
+
+ bool segmentClipped, segmentCulled;
+ vec4 clippedPositionWC, clippedPositionEC;
+ clipLineSegmentToNearPlane(positionEC.xyz, usePrevious ? prevEC.xyz : nextEC.xyz, clippedPositionWC, segmentClipped, segmentCulled, clippedPositionEC);
+
+ if (segmentCulled)
+ {
+ return vec4(0.0, 0.0, 0.0, 1.0);
+ }
+
+ vec2 directionToPrevWC = normalize(clippedPrevWC.xy - clippedPositionWC.xy);
+ vec2 directionToNextWC = normalize(clippedNextWC.xy - clippedPositionWC.xy);
+
+ // If a segment was culled, we can't use the corresponding direction
+ // computed above. We should never see both of these be true without
+ // \`segmentCulled\` above also being true.
+ if (prevSegmentCulled)
+ {
+ directionToPrevWC = -directionToNextWC;
+ }
+ else if (nextSegmentCulled)
+ {
+ directionToNextWC = -directionToPrevWC;
+ }
+
+ vec2 thisSegmentForwardWC, otherSegmentForwardWC;
+ if (usePrevious)
+ {
+ thisSegmentForwardWC = -directionToPrevWC;
+ otherSegmentForwardWC = directionToNextWC;
+ }
+ else
+ {
+ thisSegmentForwardWC = directionToNextWC;
+ otherSegmentForwardWC = -directionToPrevWC;
+ }
+
+ vec2 thisSegmentLeftWC = vec2(-thisSegmentForwardWC.y, thisSegmentForwardWC.x);
+
+ vec2 leftWC = thisSegmentLeftWC;
+ float expandWidth = width * 0.5;
+
+ // When lines are split at the anti-meridian, the position may be at the
+ // same location as the next or previous position, and we need to handle
+ // that to avoid producing NaNs.
+ if (!czm_equalsEpsilon(prevEC.xyz - positionEC.xyz, vec3(0.0), czm_epsilon1) && !czm_equalsEpsilon(nextEC.xyz - positionEC.xyz, vec3(0.0), czm_epsilon1))
+ {
+ vec2 otherSegmentLeftWC = vec2(-otherSegmentForwardWC.y, otherSegmentForwardWC.x);
+
+ vec2 leftSumWC = thisSegmentLeftWC + otherSegmentLeftWC;
+ float leftSumLength = length(leftSumWC);
+ leftWC = leftSumLength < czm_epsilon6 ? thisSegmentLeftWC : (leftSumWC / leftSumLength);
+
+ // The sine of the angle between the two vectors is given by the formula
+ // |a x b| = |a||b|sin(theta)
+ // which is
+ // float sinAngle = length(cross(vec3(leftWC, 0.0), vec3(-thisSegmentForwardWC, 0.0)));
+ // Because the z components of both vectors are zero, the x and y coordinate will be zero.
+ // Therefore, the sine of the angle is just the z component of the cross product.
+ vec2 u = -thisSegmentForwardWC;
+ vec2 v = leftWC;
+ float sinAngle = abs(u.x * v.y - u.y * v.x);
+ expandWidth = clamp(expandWidth / sinAngle, 0.0, width * 2.0);
+ }
+
+ vec2 offset = leftWC * expandDirection * expandWidth * czm_pixelRatio;
+ return vec4(clippedPositionWC.xy + offset, -clippedPositionWC.z, 1.0) * (czm_projection * clippedPositionEC).w;
+}
+
+vec4 getPolylineWindowCoordinates(vec4 position, vec4 previous, vec4 next, float expandDirection, float width, bool usePrevious, out float angle)
+{
+ vec4 positionEC = czm_modelViewRelativeToEye * position;
+ vec4 prevEC = czm_modelViewRelativeToEye * previous;
+ vec4 nextEC = czm_modelViewRelativeToEye * next;
+ return getPolylineWindowCoordinatesEC(positionEC, prevEC, nextEC, expandDirection, width, usePrevious, angle);
+}
+`;var eY=`${jl}
+${eE}`,iIe=Ug;Mt.isInternetExplorer()||(eY=`#define CLIP_POLYLINE
+${eY}`);function $g(e){e=g(e,g.EMPTY_OBJECT);let t=g(e.translucent,!0),n=!1,i=$g.VERTEX_FORMAT;this.material=void 0,this.translucent=t,this._vertexShaderSource=g(e.vertexShaderSource,eY),this._fragmentShaderSource=g(e.fragmentShaderSource,iIe),this._renderState=to.getDefaultRenderState(t,n,e.renderState),this._closed=n,this._vertexFormat=i}Object.defineProperties($g.prototype,{vertexShaderSource:{get:function(){return this._vertexShaderSource}},fragmentShaderSource:{get:function(){return this._fragmentShaderSource}},renderState:{get:function(){return this._renderState}},closed:{get:function(){return this._closed}},vertexFormat:{get:function(){return this._vertexFormat}}});$g.VERTEX_FORMAT=We.POSITION_ONLY;$g.prototype.getFragmentShaderSource=to.prototype.getFragmentShaderSource;$g.prototype.isTranslucent=to.prototype.isTranslucent;$g.prototype.getRenderState=to.prototype.getRenderState;var wr=$g;var fHt=T(S(),1);var tHt=T(S(),1),tE=`in vec3 position3DHigh;
+in vec3 position3DLow;
+in vec3 prevPosition3DHigh;
+in vec3 prevPosition3DLow;
+in vec3 nextPosition3DHigh;
+in vec3 nextPosition3DLow;
+in vec2 expandAndWidth;
+in vec2 st;
+in float batchId;
+
+out float v_width;
+out vec2 v_st;
+out float v_polylineAngle;
+
+void main()
+{
+ float expandDir = expandAndWidth.x;
+ float width = abs(expandAndWidth.y) + 0.5;
+ bool usePrev = expandAndWidth.y < 0.0;
+
+ vec4 p = czm_computePosition();
+ vec4 prev = czm_computePrevPosition();
+ vec4 next = czm_computeNextPosition();
+
+ float angle;
+ vec4 positionWC = getPolylineWindowCoordinates(p, prev, next, expandDir, width, usePrev, angle);
+ gl_Position = czm_viewportOrthographic * positionWC;
+
+ v_width = width;
+ v_st.s = st.s;
+ v_st.t = czm_writeNonPerspective(st.t, gl_Position.w);
+ v_polylineAngle = angle;
+}
+`;var iHt=T(S(),1),ex=`#ifdef VECTOR_TILE
+uniform vec4 u_highlightColor;
+#endif
+
+in vec2 v_st;
+
+void main()
+{
+ czm_materialInput materialInput;
+
+ vec2 st = v_st;
+ st.t = czm_readNonPerspective(st.t, gl_FragCoord.w);
+
+ materialInput.s = st.s;
+ materialInput.st = st;
+ materialInput.str = vec3(st, 0.0);
+
+ czm_material material = czm_getMaterial(materialInput);
+ out_FragColor = vec4(material.diffuse + material.emission, material.alpha);
+#ifdef VECTOR_TILE
+ out_FragColor *= u_highlightColor;
+#endif
+
+ czm_writeLogDepth();
+}
+`;var tY=`${jl}
+${tE}`,oIe=ex;Mt.isInternetExplorer()||(tY=`#define CLIP_POLYLINE
+${tY}`);function tx(e){e=g(e,g.EMPTY_OBJECT);let t=g(e.translucent,!0),n=!1,i=tx.VERTEX_FORMAT;this.material=d(e.material)?e.material:ki.fromType(ki.ColorType),this.translucent=t,this._vertexShaderSource=g(e.vertexShaderSource,tY),this._fragmentShaderSource=g(e.fragmentShaderSource,oIe),this._renderState=to.getDefaultRenderState(t,n,e.renderState),this._closed=n,this._vertexFormat=i}Object.defineProperties(tx.prototype,{vertexShaderSource:{get:function(){let e=this._vertexShaderSource;return this.material.shaderSource.search(/in\s+float\s+v_polylineAngle;/g)!==-1&&(e=`#define POLYLINE_DASH
+${e}`),e}},fragmentShaderSource:{get:function(){return this._fragmentShaderSource}},renderState:{get:function(){return this._renderState}},closed:{get:function(){return this._closed}},vertexFormat:{get:function(){return this._vertexFormat}}});tx.VERTEX_FORMAT=We.POSITION_AND_ST;tx.prototype.getFragmentShaderSource=to.prototype.getFragmentShaderSource;tx.prototype.isTranslucent=to.prototype.isTranslucent;tx.prototype.getRenderState=to.prototype.getRenderState;var Ds=tx;function lp(e){e=g(e,g.EMPTY_OBJECT),this.geometryInstances=e.geometryInstances,this._hasPerInstanceColors=!0;let t=e.appearance;d(t)||(t=new Ds),this.appearance=t,this.show=g(e.show,!0),this.classificationType=g(e.classificationType,kn.BOTH),this.debugShowBoundingVolume=g(e.debugShowBoundingVolume,!1),this._debugShowShadowVolume=g(e.debugShowShadowVolume,!1),this._primitiveOptions={geometryInstances:void 0,appearance:void 0,vertexCacheOptimize:!1,interleave:g(e.interleave,!1),releaseGeometryInstances:g(e.releaseGeometryInstances,!0),allowPicking:g(e.allowPicking,!0),asynchronous:g(e.asynchronous,!0),compressVertices:!1,_createShaderProgramFunction:void 0,_createCommandsFunction:void 0,_updateAndQueueCommandsFunction:void 0},this._zIndex=void 0,this._ready=!1,this._primitive=void 0,this._sp=void 0,this._sp2D=void 0,this._spMorph=void 0,this._renderState=qee(!1),this._renderState3DTiles=qee(!0),this._renderStateMorph=De.fromCache({cull:{enabled:!0,face:yi.FRONT},depthTest:{enabled:!0},blending:un.PRE_MULTIPLIED_ALPHA_BLEND,depthMask:!1})}Object.defineProperties(lp.prototype,{interleave:{get:function(){return this._primitiveOptions.interleave}},releaseGeometryInstances:{get:function(){return this._primitiveOptions.releaseGeometryInstances}},allowPicking:{get:function(){return this._primitiveOptions.allowPicking}},asynchronous:{get:function(){return this._primitiveOptions.asynchronous}},ready:{get:function(){return this._ready}},debugShowShadowVolume:{get:function(){return this._debugShowShadowVolume}}});lp.initializeTerrainHeights=function(){return li.initialize()};function rIe(e,t,n){let i=t.context,o=e._primitive,r=o._attributeLocations,s=o._batchTable.getVertexShaderCallback()($G);s=Zn._appendShowToShader(o,s),s=Zn._appendDistanceDisplayConditionToShader(o,s),s=Zn._modifyShaderPosition(e,s,t.scene3DOnly);let a=o._batchTable.getVertexShaderCallback()(qG);a=Zn._appendShowToShader(o,a),a=Zn._appendDistanceDisplayConditionToShader(o,a),a=Zn._modifyShaderPosition(e,a,t.scene3DOnly);let c=o._batchTable.getVertexShaderCallback()(QG),l=[`GLOBE_MINIMUM_ALTITUDE ${t.mapProjection.ellipsoid.minimumRadius.toFixed(1)}`],u="",m="";d(n.material)?(m=d(n.material)?n.material.shaderSource:"",m.search(/in\s+float\s+v_polylineAngle;/g)!==-1&&l.push("ANGLE_VARYING"),m.search(/in\s+float\s+v_width;/g)!==-1&&l.push("WIDTH_VARYING")):u="PER_INSTANCE_COLOR",l.push(u);let p=e.debugShowShadowVolume?["DEBUG_SHOW_VOLUME",u]:[u],y=new Be({defines:l,sources:[s]}),f=new Be({defines:p,sources:[m,c]});e._sp=Qt.replaceCache({context:i,shaderProgram:o._sp,vertexShaderSource:y,fragmentShaderSource:f,attributeLocations:r});let x=i.shaderCache.getDerivedShaderProgram(e._sp,"2dColor");if(!d(x)){let C=new Be({defines:l.concat(["COLUMBUS_VIEW_2D"]),sources:[s]});x=i.shaderCache.createDerivedShaderProgram(e._sp,"2dColor",{context:i,shaderProgram:e._sp2D,vertexShaderSource:C,fragmentShaderSource:f,attributeLocations:r})}e._sp2D=x;let _=i.shaderCache.getDerivedShaderProgram(e._sp,"MorphColor");if(!d(_)){let C=new Be({defines:l.concat([`MAX_TERRAIN_HEIGHT ${li._defaultMaxTerrainHeight.toFixed(1)}`]),sources:[a]});c=o._batchTable.getVertexShaderCallback()(jG);let V=new Be({defines:p,sources:[m,c]});_=i.shaderCache.createDerivedShaderProgram(e._sp,"MorphColor",{context:i,shaderProgram:e._spMorph,vertexShaderSource:C,fragmentShaderSource:V,attributeLocations:r})}e._spMorph=_}function qee(e){return De.fromCache({cull:{enabled:!0},blending:un.PRE_MULTIPLIED_ALPHA_BLEND,depthMask:!1,stencilTest:{enabled:e,frontFunction:Dn.EQUAL,frontOperation:{fail:ht.KEEP,zFail:ht.KEEP,zPass:ht.KEEP},backFunction:Dn.EQUAL,backOperation:{fail:ht.KEEP,zFail:ht.KEEP,zPass:ht.KEEP},reference:wt.CESIUM_3D_TILE_MASK,mask:wt.CESIUM_3D_TILE_MASK}})}function sIe(e,t,n,i,o,r){let s=e._primitive,a=s._va.length;o.length=a,r.length=a;let l=t instanceof wr?{}:n._uniforms,u=s._batchTable.getUniformMapCallback()(l);for(let m=0;m{!this._ready&&d(this._primitive)&&this._primitive.ready&&(this._ready=!0,this.releaseGeometryInstances&&(this.geometryInstances=void 0))})};lp.prototype.getGeometryInstanceAttributes=function(e){return this._primitive.getGeometryInstanceAttributes(e)};lp.isSupported=function(e){return e.frameState.context.depthTexture};lp.prototype.isDestroyed=function(){return!1};lp.prototype.destroy=function(){return this._primitive=this._primitive&&this._primitive.destroy(),this._sp=this._sp&&this._sp.destroy(),this._sp2D=void 0,this._spMorph=void 0,ue(this)};var dm=lp;var hzt=T(S(),1);var szt=T(S(),1);var $Ht=T(S(),1);var cIe=new D(1,1),lIe=!1,dIe=B.WHITE;function VS(e){e=g(e,g.EMPTY_OBJECT),this._definitionChanged=new ye,this._image=void 0,this._imageSubscription=void 0,this._repeat=void 0,this._repeatSubscription=void 0,this._color=void 0,this._colorSubscription=void 0,this._transparent=void 0,this._transparentSubscription=void 0,this.image=e.image,this.repeat=e.repeat,this.color=e.color,this.transparent=e.transparent}Object.defineProperties(VS.prototype,{isConstant:{get:function(){return H.isConstant(this._image)&&H.isConstant(this._repeat)}},definitionChanged:{get:function(){return this._definitionChanged}},image:le("image"),repeat:le("repeat"),color:le("color"),transparent:le("transparent")});VS.prototype.getType=function(e){return"Image"};VS.prototype.getValue=function(e,t){return d(t)||(t={}),t.image=H.getValueOrUndefined(this._image,e),t.repeat=H.getValueOrClonedDefault(this._repeat,e,cIe,t.repeat),t.color=H.getValueOrClonedDefault(this._color,e,dIe,t.color),H.getValueOrDefault(this._transparent,e,lIe)&&(t.color.alpha=Math.min(.99,t.color.alpha)),t};VS.prototype.equals=function(e){return this===e||e instanceof VS&&H.equals(this._image,e._image)&&H.equals(this._repeat,e._repeat)&&H.equals(this._color,e._color)&&H.equals(this._transparent,e._transparent)};var bb=VS;function uIe(e){if(e instanceof B)return new At(e);if(typeof e=="string"||e instanceof Ee||e instanceof HTMLCanvasElement||e instanceof HTMLVideoElement){let t=new bb;return t.image=e,t}}function mIe(e,t){return le(e,t,uIe)}var Ro=mIe;function nE(e){this._definitionChanged=new ye,this._show=void 0,this._showSubscription=void 0,this._dimensions=void 0,this._dimensionsSubscription=void 0,this._heightReference=void 0,this._heightReferenceSubscription=void 0,this._fill=void 0,this._fillSubscription=void 0,this._material=void 0,this._materialSubscription=void 0,this._outline=void 0,this._outlineSubscription=void 0,this._outlineColor=void 0,this._outlineColorSubscription=void 0,this._outlineWidth=void 0,this._outlineWidthSubscription=void 0,this._shadows=void 0,this._shadowsSubscription=void 0,this._distanceDisplayCondition=void 0,this._distanceDisplayConditionSubscription=void 0,this.merge(g(e,g.EMPTY_OBJECT))}Object.defineProperties(nE.prototype,{definitionChanged:{get:function(){return this._definitionChanged}},show:le("show"),dimensions:le("dimensions"),heightReference:le("heightReference"),fill:le("fill"),material:Ro("material"),outline:le("outline"),outlineColor:le("outlineColor"),outlineWidth:le("outlineWidth"),shadows:le("shadows"),distanceDisplayCondition:le("distanceDisplayCondition")});nE.prototype.clone=function(e){return d(e)?(e.show=this.show,e.dimensions=this.dimensions,e.heightReference=this.heightReference,e.fill=this.fill,e.material=this.material,e.outline=this.outline,e.outlineColor=this.outlineColor,e.outlineWidth=this.outlineWidth,e.shadows=this.shadows,e.distanceDisplayCondition=this.distanceDisplayCondition,e):new nE(this)};nE.prototype.merge=function(e){this.show=g(this.show,e.show),this.dimensions=g(this.dimensions,e.dimensions),this.heightReference=g(this.heightReference,e.heightReference),this.fill=g(this.fill,e.fill),this.material=g(this.material,e.material),this.outline=g(this.outline,e.outline),this.outlineColor=g(this.outlineColor,e.outlineColor),this.outlineWidth=g(this.outlineWidth,e.outlineWidth),this.shadows=g(this.shadows,e.shadows),this.distanceDisplayCondition=g(this.distanceDisplayCondition,e.distanceDisplayCondition)};var nx=nE;var Izt=T(S(),1);var pzt=T(S(),1),hIe={FIXED:0,INERTIAL:1},io=Object.freeze(hIe);var Czt=T(S(),1);function LS(){fe.throwInstantiationError()}Object.defineProperties(LS.prototype,{isConstant:{get:fe.throwInstantiationError},definitionChanged:{get:fe.throwInstantiationError},referenceFrame:{get:fe.throwInstantiationError}});LS.prototype.getValue=fe.throwInstantiationError;LS.prototype.getValueInReferenceFrame=fe.throwInstantiationError;LS.prototype.equals=fe.throwInstantiationError;var nY=new $;LS.convertToReferenceFrame=function(e,t,n,i,o){if(!d(t))return t;if(d(o)||(o=new h),n===i)return h.clone(t,o);let r=vt.computeIcrfToFixedMatrix(e,nY);if(d(r)||(r=vt.computeTemeToPseudoFixedMatrix(e,nY)),n===io.INERTIAL)return $.multiplyByVector(r,t,o);if(n===io.FIXED)return $.multiplyByVector($.transpose(r,nY),t,o)};var dp=LS;function ix(e,t){this._definitionChanged=new ye,this._value=h.clone(e),this._referenceFrame=g(t,io.FIXED)}Object.defineProperties(ix.prototype,{isConstant:{get:function(){return!d(this._value)||this._referenceFrame===io.FIXED}},definitionChanged:{get:function(){return this._definitionChanged}},referenceFrame:{get:function(){return this._referenceFrame}}});ix.prototype.getValue=function(e,t){return this.getValueInReferenceFrame(e,io.FIXED,t)};ix.prototype.setValue=function(e,t){let n=!1;h.equals(this._value,e)||(n=!0,this._value=h.clone(e)),d(t)&&this._referenceFrame!==t&&(n=!0,this._referenceFrame=t),n&&this._definitionChanged.raiseEvent(this)};ix.prototype.getValueInReferenceFrame=function(e,t,n){return dp.convertToReferenceFrame(e,this._value,this._referenceFrame,t,n)};ix.prototype.equals=function(e){return this===e||e instanceof ix&&h.equals(this._value,e._value)&&this._referenceFrame===e._referenceFrame};var Gc=ix;var Mzt=T(S(),1);function iE(e){this._definitionChanged=new ye,this._show=void 0,this._showSubscription=void 0,this._positions=void 0,this._positionsSubscription=void 0,this._width=void 0,this._widthSubscription=void 0,this._height=void 0,this._heightSubscription=void 0,this._heightReference=void 0,this._heightReferenceSubscription=void 0,this._extrudedHeight=void 0,this._extrudedHeightSubscription=void 0,this._extrudedHeightReference=void 0,this._extrudedHeightReferenceSubscription=void 0,this._cornerType=void 0,this._cornerTypeSubscription=void 0,this._granularity=void 0,this._granularitySubscription=void 0,this._fill=void 0,this._fillSubscription=void 0,this._material=void 0,this._materialSubscription=void 0,this._outline=void 0,this._outlineSubscription=void 0,this._outlineColor=void 0,this._outlineColorSubscription=void 0,this._outlineWidth=void 0,this._outlineWidthSubscription=void 0,this._shadows=void 0,this._shadowsSubscription=void 0,this._distanceDisplayCondition=void 0,this._distanceDisplayConditionSubscription=void 0,this._classificationType=void 0,this._classificationTypeSubscription=void 0,this._zIndex=void 0,this._zIndexSubscription=void 0,this.merge(g(e,g.EMPTY_OBJECT))}Object.defineProperties(iE.prototype,{definitionChanged:{get:function(){return this._definitionChanged}},show:le("show"),positions:le("positions"),width:le("width"),height:le("height"),heightReference:le("heightReference"),extrudedHeight:le("extrudedHeight"),extrudedHeightReference:le("extrudedHeightReference"),cornerType:le("cornerType"),granularity:le("granularity"),fill:le("fill"),material:Ro("material"),outline:le("outline"),outlineColor:le("outlineColor"),outlineWidth:le("outlineWidth"),shadows:le("shadows"),distanceDisplayCondition:le("distanceDisplayCondition"),classificationType:le("classificationType"),zIndex:le("zIndex")});iE.prototype.clone=function(e){return d(e)?(e.show=this.show,e.positions=this.positions,e.width=this.width,e.height=this.height,e.heightReference=this.heightReference,e.extrudedHeight=this.extrudedHeight,e.extrudedHeightReference=this.extrudedHeightReference,e.cornerType=this.cornerType,e.granularity=this.granularity,e.fill=this.fill,e.material=this.material,e.outline=this.outline,e.outlineColor=this.outlineColor,e.outlineWidth=this.outlineWidth,e.shadows=this.shadows,e.distanceDisplayCondition=this.distanceDisplayCondition,e.classificationType=this.classificationType,e.zIndex=this.zIndex,e):new iE(this)};iE.prototype.merge=function(e){this.show=g(this.show,e.show),this.positions=g(this.positions,e.positions),this.width=g(this.width,e.width),this.height=g(this.height,e.height),this.heightReference=g(this.heightReference,e.heightReference),this.extrudedHeight=g(this.extrudedHeight,e.extrudedHeight),this.extrudedHeightReference=g(this.extrudedHeightReference,e.extrudedHeightReference),this.cornerType=g(this.cornerType,e.cornerType),this.granularity=g(this.granularity,e.granularity),this.fill=g(this.fill,e.fill),this.material=g(this.material,e.material),this.outline=g(this.outline,e.outline),this.outlineColor=g(this.outlineColor,e.outlineColor),this.outlineWidth=g(this.outlineWidth,e.outlineWidth),this.shadows=g(this.shadows,e.shadows),this.distanceDisplayCondition=g(this.distanceDisplayCondition,e.distanceDisplayCondition),this.classificationType=g(this.classificationType,e.classificationType),this.zIndex=g(this.zIndex,e.zIndex)};var ox=iE;var kzt=T(S(),1);function fIe(e){return e}function pIe(e,t){return le(e,t,fIe)}var ul=pIe;var zzt=T(S(),1);function oE(e){this._definitionChanged=new ye,this._show=void 0,this._showSubscription=void 0,this._length=void 0,this._lengthSubscription=void 0,this._topRadius=void 0,this._topRadiusSubscription=void 0,this._bottomRadius=void 0,this._bottomRadiusSubscription=void 0,this._heightReference=void 0,this._heightReferenceSubscription=void 0,this._fill=void 0,this._fillSubscription=void 0,this._material=void 0,this._materialSubscription=void 0,this._outline=void 0,this._outlineSubscription=void 0,this._outlineColor=void 0,this._outlineColorSubscription=void 0,this._outlineWidth=void 0,this._outlineWidthSubscription=void 0,this._numberOfVerticalLines=void 0,this._numberOfVerticalLinesSubscription=void 0,this._slices=void 0,this._slicesSubscription=void 0,this._shadows=void 0,this._shadowsSubscription=void 0,this._distanceDisplayCondition=void 0,this._distanceDisplayConditionSubscription=void 0,this.merge(g(e,g.EMPTY_OBJECT))}Object.defineProperties(oE.prototype,{definitionChanged:{get:function(){return this._definitionChanged}},show:le("show"),length:le("length"),topRadius:le("topRadius"),bottomRadius:le("bottomRadius"),heightReference:le("heightReference"),fill:le("fill"),material:Ro("material"),outline:le("outline"),outlineColor:le("outlineColor"),outlineWidth:le("outlineWidth"),numberOfVerticalLines:le("numberOfVerticalLines"),slices:le("slices"),shadows:le("shadows"),distanceDisplayCondition:le("distanceDisplayCondition")});oE.prototype.clone=function(e){return d(e)?(e.show=this.show,e.length=this.length,e.topRadius=this.topRadius,e.bottomRadius=this.bottomRadius,e.heightReference=this.heightReference,e.fill=this.fill,e.material=this.material,e.outline=this.outline,e.outlineColor=this.outlineColor,e.outlineWidth=this.outlineWidth,e.numberOfVerticalLines=this.numberOfVerticalLines,e.slices=this.slices,e.shadows=this.shadows,e.distanceDisplayCondition=this.distanceDisplayCondition,e):new oE(this)};oE.prototype.merge=function(e){this.show=g(this.show,e.show),this.length=g(this.length,e.length),this.topRadius=g(this.topRadius,e.topRadius),this.bottomRadius=g(this.bottomRadius,e.bottomRadius),this.heightReference=g(this.heightReference,e.heightReference),this.fill=g(this.fill,e.fill),this.material=g(this.material,e.material),this.outline=g(this.outline,e.outline),this.outlineColor=g(this.outlineColor,e.outlineColor),this.outlineWidth=g(this.outlineWidth,e.outlineWidth),this.numberOfVerticalLines=g(this.numberOfVerticalLines,e.numberOfVerticalLines),this.slices=g(this.slices,e.slices),this.shadows=g(this.shadows,e.shadows),this.distanceDisplayCondition=g(this.distanceDisplayCondition,e.distanceDisplayCondition)};var rx=oE;var tJt=T(S(),1);function rE(e){this._definitionChanged=new ye,this._show=void 0,this._showSubscription=void 0,this._semiMajorAxis=void 0,this._semiMajorAxisSubscription=void 0,this._semiMinorAxis=void 0,this._semiMinorAxisSubscription=void 0,this._height=void 0,this._heightSubscription=void 0,this._heightReference=void 0,this._heightReferenceSubscription=void 0,this._extrudedHeight=void 0,this._extrudedHeightSubscription=void 0,this._extrudedHeightReference=void 0,this._extrudedHeightReferenceSubscription=void 0,this._rotation=void 0,this._rotationSubscription=void 0,this._stRotation=void 0,this._stRotationSubscription=void 0,this._granularity=void 0,this._granularitySubscription=void 0,this._fill=void 0,this._fillSubscription=void 0,this._material=void 0,this._materialSubscription=void 0,this._outline=void 0,this._outlineSubscription=void 0,this._outlineColor=void 0,this._outlineColorSubscription=void 0,this._outlineWidth=void 0,this._outlineWidthSubscription=void 0,this._numberOfVerticalLines=void 0,this._numberOfVerticalLinesSubscription=void 0,this._shadows=void 0,this._shadowsSubscription=void 0,this._distanceDisplayCondition=void 0,this._distanceDisplayConditionSubscription=void 0,this._classificationType=void 0,this._classificationTypeSubscription=void 0,this._zIndex=void 0,this._zIndexSubscription=void 0,this.merge(g(e,g.EMPTY_OBJECT))}Object.defineProperties(rE.prototype,{definitionChanged:{get:function(){return this._definitionChanged}},show:le("show"),semiMajorAxis:le("semiMajorAxis"),semiMinorAxis:le("semiMinorAxis"),height:le("height"),heightReference:le("heightReference"),extrudedHeight:le("extrudedHeight"),extrudedHeightReference:le("extrudedHeightReference"),rotation:le("rotation"),stRotation:le("stRotation"),granularity:le("granularity"),fill:le("fill"),material:Ro("material"),outline:le("outline"),outlineColor:le("outlineColor"),outlineWidth:le("outlineWidth"),numberOfVerticalLines:le("numberOfVerticalLines"),shadows:le("shadows"),distanceDisplayCondition:le("distanceDisplayCondition"),classificationType:le("classificationType"),zIndex:le("zIndex")});rE.prototype.clone=function(e){return d(e)?(e.show=this.show,e.semiMajorAxis=this.semiMajorAxis,e.semiMinorAxis=this.semiMinorAxis,e.height=this.height,e.heightReference=this.heightReference,e.extrudedHeight=this.extrudedHeight,e.extrudedHeightReference=this.extrudedHeightReference,e.rotation=this.rotation,e.stRotation=this.stRotation,e.granularity=this.granularity,e.fill=this.fill,e.material=this.material,e.outline=this.outline,e.outlineColor=this.outlineColor,e.outlineWidth=this.outlineWidth,e.numberOfVerticalLines=this.numberOfVerticalLines,e.shadows=this.shadows,e.distanceDisplayCondition=this.distanceDisplayCondition,e.classificationType=this.classificationType,e.zIndex=this.zIndex,e):new rE(this)};rE.prototype.merge=function(e){this.show=g(this.show,e.show),this.semiMajorAxis=g(this.semiMajorAxis,e.semiMajorAxis),this.semiMinorAxis=g(this.semiMinorAxis,e.semiMinorAxis),this.height=g(this.height,e.height),this.heightReference=g(this.heightReference,e.heightReference),this.extrudedHeight=g(this.extrudedHeight,e.extrudedHeight),this.extrudedHeightReference=g(this.extrudedHeightReference,e.extrudedHeightReference),this.rotation=g(this.rotation,e.rotation),this.stRotation=g(this.stRotation,e.stRotation),this.granularity=g(this.granularity,e.granularity),this.fill=g(this.fill,e.fill),this.material=g(this.material,e.material),this.outline=g(this.outline,e.outline),this.outlineColor=g(this.outlineColor,e.outlineColor),this.outlineWidth=g(this.outlineWidth,e.outlineWidth),this.numberOfVerticalLines=g(this.numberOfVerticalLines,e.numberOfVerticalLines),this.shadows=g(this.shadows,e.shadows),this.distanceDisplayCondition=g(this.distanceDisplayCondition,e.distanceDisplayCondition),this.classificationType=g(this.classificationType,e.classificationType),this.zIndex=g(this.zIndex,e.zIndex)};var sx=rE;var cJt=T(S(),1);function sE(e){this._definitionChanged=new ye,this._show=void 0,this._showSubscription=void 0,this._radii=void 0,this._radiiSubscription=void 0,this._innerRadii=void 0,this._innerRadiiSubscription=void 0,this._minimumClock=void 0,this._minimumClockSubscription=void 0,this._maximumClock=void 0,this._maximumClockSubscription=void 0,this._minimumCone=void 0,this._minimumConeSubscription=void 0,this._maximumCone=void 0,this._maximumConeSubscription=void 0,this._heightReference=void 0,this._heightReferenceSubscription=void 0,this._fill=void 0,this._fillSubscription=void 0,this._material=void 0,this._materialSubscription=void 0,this._outline=void 0,this._outlineSubscription=void 0,this._outlineColor=void 0,this._outlineColorSubscription=void 0,this._outlineWidth=void 0,this._outlineWidthSubscription=void 0,this._stackPartitions=void 0,this._stackPartitionsSubscription=void 0,this._slicePartitions=void 0,this._slicePartitionsSubscription=void 0,this._subdivisions=void 0,this._subdivisionsSubscription=void 0,this._shadows=void 0,this._shadowsSubscription=void 0,this._distanceDisplayCondition=void 0,this._distanceDisplayConditionSubscription=void 0,this.merge(g(e,g.EMPTY_OBJECT))}Object.defineProperties(sE.prototype,{definitionChanged:{get:function(){return this._definitionChanged}},show:le("show"),radii:le("radii"),innerRadii:le("innerRadii"),minimumClock:le("minimumClock"),maximumClock:le("maximumClock"),minimumCone:le("minimumCone"),maximumCone:le("maximumCone"),heightReference:le("heightReference"),fill:le("fill"),material:Ro("material"),outline:le("outline"),outlineColor:le("outlineColor"),outlineWidth:le("outlineWidth"),stackPartitions:le("stackPartitions"),slicePartitions:le("slicePartitions"),subdivisions:le("subdivisions"),shadows:le("shadows"),distanceDisplayCondition:le("distanceDisplayCondition")});sE.prototype.clone=function(e){return d(e)?(e.show=this.show,e.radii=this.radii,e.innerRadii=this.innerRadii,e.minimumClock=this.minimumClock,e.maximumClock=this.maximumClock,e.minimumCone=this.minimumCone,e.maximumCone=this.maximumCone,e.heightReference=this.heightReference,e.fill=this.fill,e.material=this.material,e.outline=this.outline,e.outlineColor=this.outlineColor,e.outlineWidth=this.outlineWidth,e.stackPartitions=this.stackPartitions,e.slicePartitions=this.slicePartitions,e.subdivisions=this.subdivisions,e.shadows=this.shadows,e.distanceDisplayCondition=this.distanceDisplayCondition,e):new sE(this)};sE.prototype.merge=function(e){this.show=g(this.show,e.show),this.radii=g(this.radii,e.radii),this.innerRadii=g(this.innerRadii,e.innerRadii),this.minimumClock=g(this.minimumClock,e.minimumClock),this.maximumClock=g(this.maximumClock,e.maximumClock),this.minimumCone=g(this.minimumCone,e.minimumCone),this.maximumCone=g(this.maximumCone,e.maximumCone),this.heightReference=g(this.heightReference,e.heightReference),this.fill=g(this.fill,e.fill),this.material=g(this.material,e.material),this.outline=g(this.outline,e.outline),this.outlineColor=g(this.outlineColor,e.outlineColor),this.outlineWidth=g(this.outlineWidth,e.outlineWidth),this.stackPartitions=g(this.stackPartitions,e.stackPartitions),this.slicePartitions=g(this.slicePartitions,e.slicePartitions),this.subdivisions=g(this.subdivisions,e.subdivisions),this.shadows=g(this.shadows,e.shadows),this.distanceDisplayCondition=g(this.distanceDisplayCondition,e.distanceDisplayCondition)};var ax=sE;var fJt=T(S(),1);function aE(e){this._definitionChanged=new ye,this._show=void 0,this._showSubscription=void 0,this._text=void 0,this._textSubscription=void 0,this._font=void 0,this._fontSubscription=void 0,this._style=void 0,this._styleSubscription=void 0,this._scale=void 0,this._scaleSubscription=void 0,this._showBackground=void 0,this._showBackgroundSubscription=void 0,this._backgroundColor=void 0,this._backgroundColorSubscription=void 0,this._backgroundPadding=void 0,this._backgroundPaddingSubscription=void 0,this._pixelOffset=void 0,this._pixelOffsetSubscription=void 0,this._eyeOffset=void 0,this._eyeOffsetSubscription=void 0,this._horizontalOrigin=void 0,this._horizontalOriginSubscription=void 0,this._verticalOrigin=void 0,this._verticalOriginSubscription=void 0,this._heightReference=void 0,this._heightReferenceSubscription=void 0,this._fillColor=void 0,this._fillColorSubscription=void 0,this._outlineColor=void 0,this._outlineColorSubscription=void 0,this._outlineWidth=void 0,this._outlineWidthSubscription=void 0,this._translucencyByDistance=void 0,this._translucencyByDistanceSubscription=void 0,this._pixelOffsetScaleByDistance=void 0,this._pixelOffsetScaleByDistanceSubscription=void 0,this._scaleByDistance=void 0,this._scaleByDistanceSubscription=void 0,this._distanceDisplayCondition=void 0,this._distanceDisplayConditionSubscription=void 0,this._disableDepthTestDistance=void 0,this._disableDepthTestDistanceSubscription=void 0,this.merge(g(e,g.EMPTY_OBJECT))}Object.defineProperties(aE.prototype,{definitionChanged:{get:function(){return this._definitionChanged}},show:le("show"),text:le("text"),font:le("font"),style:le("style"),scale:le("scale"),showBackground:le("showBackground"),backgroundColor:le("backgroundColor"),backgroundPadding:le("backgroundPadding"),pixelOffset:le("pixelOffset"),eyeOffset:le("eyeOffset"),horizontalOrigin:le("horizontalOrigin"),verticalOrigin:le("verticalOrigin"),heightReference:le("heightReference"),fillColor:le("fillColor"),outlineColor:le("outlineColor"),outlineWidth:le("outlineWidth"),translucencyByDistance:le("translucencyByDistance"),pixelOffsetScaleByDistance:le("pixelOffsetScaleByDistance"),scaleByDistance:le("scaleByDistance"),distanceDisplayCondition:le("distanceDisplayCondition"),disableDepthTestDistance:le("disableDepthTestDistance")});aE.prototype.clone=function(e){return d(e)?(e.show=this.show,e.text=this.text,e.font=this.font,e.style=this.style,e.scale=this.scale,e.showBackground=this.showBackground,e.backgroundColor=this.backgroundColor,e.backgroundPadding=this.backgroundPadding,e.pixelOffset=this.pixelOffset,e.eyeOffset=this.eyeOffset,e.horizontalOrigin=this.horizontalOrigin,e.verticalOrigin=this.verticalOrigin,e.heightReference=this.heightReference,e.fillColor=this.fillColor,e.outlineColor=this.outlineColor,e.outlineWidth=this.outlineWidth,e.translucencyByDistance=this.translucencyByDistance,e.pixelOffsetScaleByDistance=this.pixelOffsetScaleByDistance,e.scaleByDistance=this.scaleByDistance,e.distanceDisplayCondition=this.distanceDisplayCondition,e.disableDepthTestDistance=this.disableDepthTestDistance,e):new aE(this)};aE.prototype.merge=function(e){this.show=g(this.show,e.show),this.text=g(this.text,e.text),this.font=g(this.font,e.font),this.style=g(this.style,e.style),this.scale=g(this.scale,e.scale),this.showBackground=g(this.showBackground,e.showBackground),this.backgroundColor=g(this.backgroundColor,e.backgroundColor),this.backgroundPadding=g(this.backgroundPadding,e.backgroundPadding),this.pixelOffset=g(this.pixelOffset,e.pixelOffset),this.eyeOffset=g(this.eyeOffset,e.eyeOffset),this.horizontalOrigin=g(this.horizontalOrigin,e.horizontalOrigin),this.verticalOrigin=g(this.verticalOrigin,e.verticalOrigin),this.heightReference=g(this.heightReference,e.heightReference),this.fillColor=g(this.fillColor,e.fillColor),this.outlineColor=g(this.outlineColor,e.outlineColor),this.outlineWidth=g(this.outlineWidth,e.outlineWidth),this.translucencyByDistance=g(this.translucencyByDistance,e.translucencyByDistance),this.pixelOffsetScaleByDistance=g(this.pixelOffsetScaleByDistance,e.pixelOffsetScaleByDistance),this.scaleByDistance=g(this.scaleByDistance,e.scaleByDistance),this.distanceDisplayCondition=g(this.distanceDisplayCondition,e.distanceDisplayCondition),this.disableDepthTestDistance=g(this.disableDepthTestDistance,e.disableDepthTestDistance)};var um=aE;var YJt=T(S(),1);var GJt=T(S(),1);var _Jt=T(S(),1);var bIe=new h(1,1,1),yIe=h.ZERO,gIe=Ae.IDENTITY;function ete(e,t,n){this.translation=h.clone(g(e,yIe)),this.rotation=Ae.clone(g(t,gIe)),this.scale=h.clone(g(n,bIe))}ete.prototype.equals=function(e){return this===e||d(e)&&h.equals(this.translation,e.translation)&&Ae.equals(this.rotation,e.rotation)&&h.equals(this.scale,e.scale)};var yb=ete;var iY=new yb;function cE(e){e=g(e,g.EMPTY_OBJECT),this._definitionChanged=new ye,this._translation=void 0,this._translationSubscription=void 0,this._rotation=void 0,this._rotationSubscription=void 0,this._scale=void 0,this._scaleSubscription=void 0,this.translation=e.translation,this.rotation=e.rotation,this.scale=e.scale}Object.defineProperties(cE.prototype,{isConstant:{get:function(){return H.isConstant(this._translation)&&H.isConstant(this._rotation)&&H.isConstant(this._scale)}},definitionChanged:{get:function(){return this._definitionChanged}},translation:le("translation"),rotation:le("rotation"),scale:le("scale")});cE.prototype.getValue=function(e,t){return d(t)||(t=new yb),t.translation=H.getValueOrClonedDefault(this._translation,e,iY.translation,t.translation),t.rotation=H.getValueOrClonedDefault(this._rotation,e,iY.rotation,t.rotation),t.scale=H.getValueOrClonedDefault(this._scale,e,iY.scale,t.scale),t};cE.prototype.equals=function(e){return this===e||e instanceof cE&&H.equals(this._translation,e._translation)&&H.equals(this._rotation,e._rotation)&&H.equals(this._scale,e._scale)};var cx=cE;var wJt=T(S(),1);function up(e,t){this._propertyNames=[],this._definitionChanged=new ye,d(e)&&this.merge(e,t)}Object.defineProperties(up.prototype,{propertyNames:{get:function(){return this._propertyNames}},isConstant:{get:function(){let e=this._propertyNames;for(let t=0,n=e.length;t (textureSize.y / textureSize.x))
+ {
+ mipLevel = 1.0;
+ if (uv.y - pixel.y > yMipLevel1)
+ {
+ mipLevel = 2.0;
+ if (uv.y - pixel.y * 3.0 > yMipLevel2)
+ {
+ mipLevel = 3.0;
+ if (uv.y - pixel.y * 5.0 > yMipLevel3)
+ {
+ mipLevel = 4.0;
+ if (uv.y - pixel.y * 7.0 > yMipLevel4)
+ {
+ mipLevel = 5.0;
+ }
+ }
+ }
+ }
+ }
+
+ if (mipLevel > 0.0)
+ {
+ float scale = pow(2.0, mipLevel);
+
+ uv.y -= (pixel.y * (mipLevel - 1.0) * 2.0);
+ uv.x *= ((textureSize.x - 2.0) / textureSize.y);
+
+ uv.x -= 1.0 + pixel.x;
+ uv.y -= (1.0 - (1.0 / pow(2.0, mipLevel - 1.0)));
+ uv *= scale;
+ }
+ else
+ {
+ uv.x *= (textureSize.x / textureSize.y);
+ }
+
+ if(mipLevel == 0.0)
+ {
+ out_FragColor = texture(texture0, uv);
+ }
+ else if(mipLevel == 1.0)
+ {
+ out_FragColor = texture(texture1, uv);
+ }
+ else if(mipLevel == 2.0)
+ {
+ out_FragColor = texture(texture2, uv);
+ }
+ else if(mipLevel == 3.0)
+ {
+ out_FragColor = texture(texture3, uv);
+ }
+ else if(mipLevel == 4.0)
+ {
+ out_FragColor = texture(texture4, uv);
+ }
+ else if(mipLevel == 5.0)
+ {
+ out_FragColor = texture(texture5, uv);
+ }
+ else
+ {
+ out_FragColor = vec4(0.0);
+ }
+}
+`;var t8t=T(S(),1),SE=`in vec3 v_cubeMapCoordinates;
+uniform samplerCube cubeMap;
+
+void main()
+{
+ vec4 rgba = czm_textureCube(cubeMap, v_cubeMapCoordinates);
+ #ifdef RGBA_NORMALIZED
+ out_FragColor = vec4(rgba.rgb, 1.0);
+ #else
+ float m = rgba.a * 16.0;
+ vec3 r = rgba.rgb * m;
+ out_FragColor = vec4(r * r, 1.0);
+ #endif
+}
+`;var i8t=T(S(),1),CE=`in vec4 position;
+in vec3 cubeMapCoordinates;
+
+out vec3 v_cubeMapCoordinates;
+
+void main()
+{
+ gl_Position = position;
+ v_cubeMapCoordinates = cubeMapCoordinates;
+}
+`;function hx(e){this._url=e,this._cubeMapBuffers=void 0,this._cubeMaps=void 0,this._texture=void 0,this._mipTextures=void 0,this._va=void 0,this._sp=void 0,this._maximumMipmapLevel=void 0,this._loading=!1,this._ready=!1,this._errorEvent=new ye}Object.defineProperties(hx.prototype,{url:{get:function(){return this._url}},errorEvent:{get:function(){return this._errorEvent}},texture:{get:function(){return this._texture}},maximumMipmapLevel:{get:function(){return this._maximumMipmapLevel}},ready:{get:function(){return this._ready}}});hx.isSupported=function(e){return e.colorBufferHalfFloat&&e.halfFloatingPointTexture||e.floatingPointTexture&&e.colorBufferFloat};var kIe=new h(1,0,0),DIe=new h(0,0,1),BIe=new h(-1,0,0),YIe=new h(0,0,-1),yM=new h(0,1,0),OIe=new h(0,-1,0),hte=[yM,BIe,DIe,OIe,kIe,yM,YIe,yM,yM],fte=hte.length,pte=new Float32Array(fte*3),ute=0;for(let e=0;e0||this._imageBasedLightingFactor.y>0}},shouldRegenerateShaders:{get:function(){return this._shouldRegenerateShaders}},useDefaultSphericalHarmonics:{get:function(){return this._useDefaultSphericalHarmonics}},useSphericalHarmonicCoefficients:{get:function(){return d(this._sphericalHarmonicCoefficients)||this._useDefaultSphericalHarmonics}},specularEnvironmentMapAtlas:{get:function(){return this._specularEnvironmentMapAtlas}},useDefaultSpecularMaps:{get:function(){return this._useDefaultSpecularMaps}},useSpecularEnvironmentMaps:{get:function(){return d(this._specularEnvironmentMapAtlas)&&this._specularEnvironmentMapAtlas.ready||this._useDefaultSpecularMaps}}});function JIe(e,t){if(pm.isSupported(t)){if(e._specularEnvironmentMapAtlas=e._specularEnvironmentMapAtlas&&e._specularEnvironmentMapAtlas.destroy(),d(e._specularEnvironmentMaps)){let n=new pm(e._specularEnvironmentMaps);e._specularEnvironmentMapAtlas=n,e._removeErrorListener=n.errorEvent.addEventListener(i=>{console.error(`Error loading specularEnvironmentMaps: ${i}`)})}e._shouldRegenerateShaders=!0}}VE.prototype.update=function(e){if(e.frameNumber===this._previousFrameNumber)return;this._previousFrameNumber=e.frameNumber;let t=e.context;e.brdfLutGenerator.update(e),this._shouldRegenerateShaders=!1;let n=this._imageBasedLightingFactor,i=this._previousImageBasedLightingFactor;D.equals(n,i)||(this._shouldRegenerateShaders=n.x>0&&i.x===0||n.x===0&&i.x>0,this._shouldRegenerateShaders=this._shouldRegenerateShaders||n.y>0&&i.y===0||n.y===0&&i.y>0,this._previousImageBasedLightingFactor=D.clone(this._imageBasedLightingFactor,this._previousImageBasedLightingFactor)),this._luminanceAtZenith!==this._previousLuminanceAtZenith&&(this._shouldRegenerateShaders=this._shouldRegenerateShaders||d(this._luminanceAtZenith)!==d(this._previousLuminanceAtZenith),this._previousLuminanceAtZenith=this._luminanceAtZenith),this._previousSphericalHarmonicCoefficients!==this._sphericalHarmonicCoefficients&&(this._shouldRegenerateShaders=this._shouldRegenerateShaders||d(this._previousSphericalHarmonicCoefficients)!==d(this._sphericalHarmonicCoefficients),this._previousSphericalHarmonicCoefficients=this._sphericalHarmonicCoefficients),this._shouldRegenerateShaders=this._shouldRegenerateShaders||this._previousSpecularEnvironmentMapLoaded!==this._specularEnvironmentMapLoaded,this._previousSpecularEnvironmentMapLoaded=this._specularEnvironmentMapLoaded,this._specularEnvironmentMapAtlasDirty&&(JIe(this,t),this._specularEnvironmentMapAtlasDirty=!1),d(this._specularEnvironmentMapAtlas)&&(this._specularEnvironmentMapAtlas.update(e),this._specularEnvironmentMapAtlas.ready&&(this._specularEnvironmentMapLoaded=!0));let o=!d(this._specularEnvironmentMapAtlas)&&d(e.specularEnvironmentMaps)&&!this._useDefaultSpecularMaps,r=!d(e.specularEnvironmentMaps)&&this._useDefaultSpecularMaps,s=!d(this._sphericalHarmonicCoefficients)&&d(e.sphericalHarmonicCoefficients)&&!this._useDefaultSphericalHarmonics,a=!d(e.sphericalHarmonicCoefficients)&&this._useDefaultSphericalHarmonics;this._shouldRegenerateShaders=this._shouldRegenerateShaders||o||r||s||a,this._useDefaultSpecularMaps=!d(this._specularEnvironmentMapAtlas)&&d(e.specularEnvironmentMaps),this._useDefaultSphericalHarmonics=!d(this._sphericalHarmonicCoefficients)&&d(e.sphericalHarmonicCoefficients)};VE.prototype.isDestroyed=function(){return!1};VE.prototype.destroy=function(){return this._specularEnvironmentMapAtlas=this._specularEnvironmentMapAtlas&&this._specularEnvironmentMapAtlas.destroy(),this._removeErrorListener=this._removeErrorListener&&this._removeErrorListener(),ue(this)};var fx=VE;var O8t=T(S(),1),dY=T(Dl(),1);var A8t=T(S(),1);var lY,bte="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiIyMzVjZDg3Yi0wMjVkLTQ0MzctOTZjOC1jZjMwNjkzZmI5MWUiLCJpZCI6MjU5LCJpYXQiOjE2OTg4NTM0MDl9.L_g01CjNKNVijEJ_8kOxiO02OADnuSjRFLkZWvhupcc",gM={};gM.defaultAccessToken=bte;gM.defaultServer=new Ee({url:"https://api.cesium.com/"});gM.getDefaultTokenCredit=function(e){if(e===bte){if(!d(lY)){let t=` This application is using Cesium's default ion access token. Please assign Cesium.Ion.defaultAccessToken with an access token from your ion account before making any Cesium API calls. You can sign up for a free ion account at https://cesium.com.`;lY=new St(t,!0)}return lY}};var bm=gM;function Xc(e,t){let n,i=e.externalType,o=d(i);if(!o)n={url:e.url,retryAttempts:1,retryCallback:QIe};else if(i==="3DTILES"||i==="STK_TERRAIN_SERVER")n={url:e.options.url};else throw new me("Ion.createResource does not support external imagery assets; use IonImageryProvider instead.");Ee.call(this,n),this._ionEndpoint=e,this._ionEndpointDomain=o?void 0:new dY.default(e.url).authority(),this._ionEndpointResource=t,this._ionRoot=void 0,this._pendingPromise=void 0,this._credits=void 0,this._isExternal=o}d(Object.create)&&(Xc.prototype=Object.create(Ee.prototype),Xc.prototype.constructor=Xc);Xc.fromAssetId=function(e,t){let n=Xc._createEndpointResource(e,t);return n.fetchJson().then(function(i){return new Xc(i,n)})};Object.defineProperties(Xc.prototype,{credits:{get:function(){return d(this._ionRoot)?this._ionRoot.credits:d(this._credits)?this._credits:(this._credits=Xc.getCreditsFromEndpoint(this._ionEndpoint,this._ionEndpointResource),this._credits)}}});Xc.getCreditsFromEndpoint=function(e,t){let n=e.attributions.map(St.getIonCredit),i=bm.getDefaultTokenCredit(t.queryParameters.access_token);return d(i)&&n.push(St.clone(i)),n};Xc.prototype.clone=function(e){let t=g(this._ionRoot,this);return d(e)||(e=new Xc(t._ionEndpoint,t._ionEndpointResource)),e=Ee.prototype.clone.call(this,e),e._ionRoot=t,e._isExternal=this._isExternal,e};Xc.prototype.fetchImage=function(e){if(!this._isExternal){let t=e;e={preferBlob:!0},d(t)&&(e.flipY=t.flipY,e.preferImageBitmap=t.preferImageBitmap)}return Ee.prototype.fetchImage.call(this,e)};Xc.prototype._makeRequest=function(e){return this._isExternal||new dY.default(this.url).authority()!==this._ionEndpointDomain?Ee.prototype._makeRequest.call(this,e):(d(e.headers)||(e.headers={}),e.headers.Authorization=`Bearer ${this._ionEndpoint.accessToken}`,e.headers["X-Cesium-Client"]="CesiumJS",typeof CESIUM_VERSION<"u"&&(e.headers["X-Cesium-Client-Version"]=CESIUM_VERSION),Ee.prototype._makeRequest.call(this,e))};Xc._createEndpointResource=function(e,t){t=g(t,g.EMPTY_OBJECT);let n=g(t.server,bm.defaultServer),i=g(t.accessToken,bm.defaultAccessToken);n=Ee.createIfNeeded(n);let o={url:`v1/assets/${e}/endpoint`};return d(i)&&(o.queryParameters={access_token:i}),n.getDerivedResource(o)};function QIe(e,t){let n=g(e._ionRoot,e),i=n._ionEndpointResource,o=typeof Image<"u";return!d(t)||t.statusCode!==401&&!(o&&t.target instanceof Image)?Promise.resolve(!1):(d(n._pendingPromise)||(n._pendingPromise=i.fetchJson().then(function(r){return n._ionEndpoint=r,r}).finally(function(r){return n._pendingPromise=void 0,r})),n._pendingPromise.then(function(r){return e._ionEndpoint=r,!0}))}var $l=Xc;var z8t=T(S(),1);function kh(e){e=g(e,0),this._array=new Array(e),this._length=e}Object.defineProperties(kh.prototype,{length:{get:function(){return this._length},set:function(e){let t=this._array,n=this._length;if(et.length&&(t.length=e);this._length=e}},values:{get:function(){return this._array}}});kh.prototype.get=function(e){return this._array[e]};kh.prototype.set=function(e,t){e>=this._length&&(this.length=e+1),this._array[e]=t};kh.prototype.peek=function(){return this._array[this._length-1]};kh.prototype.push=function(e){let t=this.length++;this._array[t]=e};kh.prototype.pop=function(){if(this._length===0)return;let e=this._array[this._length-1];return--this.length,e};kh.prototype.reserve=function(e){e>this._array.length&&(this._array.length=e)};kh.prototype.resize=function(e){this.length=e};kh.prototype.trim=function(e){e=g(e,this._length),this._array.length=e};var Ic=kh;var $8t=T(S(),1);var bp={X:0,Y:1,Z:2};bp.Y_UP_TO_Z_UP=w.fromRotationTranslation($.fromRotationX(W.PI_OVER_TWO));bp.Z_UP_TO_Y_UP=w.fromRotationTranslation($.fromRotationX(-W.PI_OVER_TWO));bp.X_UP_TO_Z_UP=w.fromRotationTranslation($.fromRotationY(-W.PI_OVER_TWO));bp.Z_UP_TO_X_UP=w.fromRotationTranslation($.fromRotationY(W.PI_OVER_TWO));bp.X_UP_TO_Y_UP=w.fromRotationTranslation($.fromRotationZ(W.PI_OVER_TWO));bp.Y_UP_TO_X_UP=w.fromRotationTranslation($.fromRotationZ(-W.PI_OVER_TWO));bp.fromName=function(e){return bp[e]};var Zo=Object.freeze(bp);var dvn=T(S(),1);var n7t=T(S(),1);function yte(e){e=g(e,g.EMPTY_OBJECT),this._metadata=e.metadata}Object.defineProperties(yte.prototype,{metadata:{get:function(){return this._metadata}}});var px=yte;var zEn=T(S(),1);var y7t=T(S(),1);var d7t=T(S(),1);var s7t=T(S(),1);function gb(e,t,n){return t=g(t,0),n=g(n,e.byteLength-t),e=e.subarray(t,t+n),gb.decode(e)}gb.decodeWithTextDecoder=function(e){return new TextDecoder("utf-8").decode(e)};gb.decodeWithFromCharCode=function(e){let t="",n=jIe(e),i=n.length;for(let o=0;o>10)+55296,(r&1023)+56320))}return t};function LE(e,t,n){return t<=e&&e<=n}function jIe(e){let t=0,n=0,i=0,o=128,r=191,s=[],a=e.length;for(let c=0;c0){let o=Math.min(t,kt.maximumTextureSize),r=Math.ceil(t/kt.maximumTextureSize),s=1/o,a=s*.5,c=1/r,l=c*.5;n=new D(o,r),i=new se(s,a,c,l)}this._translucentFeaturesLength=0,this._featuresLength=t,this._textureDimensions=n,this._textureStep=i,this._owner=e.owner,this._statistics=e.statistics,this._colorChangedCallback=e.colorChangedCallback}Object.defineProperties(Ya.prototype,{translucentFeaturesLength:{get:function(){return this._translucentFeaturesLength}},byteLength:{get:function(){let e=0;return d(this._pickTexture)&&(e+=this._pickTexture.sizeInBytes),d(this._batchTexture)&&(e+=this._batchTexture.sizeInBytes),e}},textureDimensions:{get:function(){return this._textureDimensions}},textureStep:{get:function(){return this._textureStep}},batchTexture:{get:function(){return this._batchTexture}},defaultTexture:{get:function(){return this._defaultTexture}},pickTexture:{get:function(){return this._pickTexture}}});Ya.DEFAULT_COLOR_VALUE=B.WHITE;Ya.DEFAULT_SHOW_VALUE=!0;function gte(e){let t=e._textureDimensions;return t.x*t.y*4}function xte(e){if(!d(e._batchValues)){let t=gte(e),n=new Uint8Array(t).fill(255);e._batchValues=n}return e._batchValues}function _te(e){if(!d(e._showAlphaProperties)){let t=2*e._featuresLength,n=new Uint8Array(t).fill(255);e._showAlphaProperties=n}return e._showAlphaProperties}Ya.prototype.setShow=function(e,t){if(t&&!d(this._showAlphaProperties))return;let n=_te(this),i=e*2,o=t?255:0;if(n[i]!==o){n[i]=o;let r=xte(this),s=e*4+3;r[s]=t?n[i+1]:0,this._batchValuesDirty=!0}};Ya.prototype.setAllShow=function(e){let t=this._featuresLength;for(let n=0;n0){let i=e._pickIds,o=gte(e),r=new Uint8Array(o),s=e._owner,a=e._statistics;for(let c=0;c0;){if(t=u.pop(),c[t]===l)continue;c[t]=l;let m=n(e,t);if(d(m))return m;let p=o[t],y=s[t];for(let f=0;f0?(s="",e&&(s+=`uniform bool tile_translucentCommand;
+`),s+=`uniform sampler2D tile_batchTexture;
+out vec4 tile_featureColor;
+out vec2 tile_featureSt;
+void main()
+{
+ vec2 st = computeSt(${t});
+ vec4 featureProperties = texture(tile_batchTexture, st);
+ tile_color(featureProperties);
+ float show = ceil(featureProperties.a);
+ gl_Position *= show;
+`,e&&(s+=` bool isStyleTranslucent = (featureProperties.a != 1.0);
+ if (czm_pass == czm_passTranslucent)
+ {
+ if (!isStyleTranslucent && !tile_translucentCommand)
+ {
+ gl_Position *= 0.0;
+ }
+ }
+ else
+ {
+ if (isStyleTranslucent)
+ {
+ gl_Position *= 0.0;
+ }
+ }
+`),s+=` tile_featureColor = featureProperties;
+ tile_featureSt = st;
+}`):s=`out vec2 tile_featureSt;
+void main()
+{
+ tile_color(vec4(1.0));
+ tile_featureSt = computeSt(${t});
+}`,`${r}
+${CWe(i)}${s}`}};function Ste(e,t){return e=Be.replaceMain(e,"tile_main"),t?`${e}uniform float tile_colorBlend;
+void tile_color(vec4 tile_featureColor)
+{
+ tile_main();
+ tile_featureColor = czm_gammaCorrect(tile_featureColor);
+ out_FragColor.a *= tile_featureColor.a;
+ float highlight = ceil(tile_colorBlend);
+ out_FragColor.rgb *= mix(tile_featureColor.rgb, vec3(1.0), highlight);
+}
+`:`${e}void tile_color(vec4 tile_featureColor)
+{
+ tile_main();
+}
+`}function VWe(e,t){let n=`texture(${t}`,i=0,o=e.indexOf(n,i),r;for(;o>-1;){let s=0;for(let l=o;l0?(i+=`uniform sampler2D tile_pickTexture;
+in vec2 tile_featureSt;
+in vec4 tile_featureColor;
+void main()
+{
+ tile_color(tile_featureColor);
+`,n&&(i+=` out_FragColor.rgb *= out_FragColor.a;
+`),i+="}"):(e&&(i+=`uniform bool tile_translucentCommand;
+`),i+=`uniform sampler2D tile_pickTexture;
+uniform sampler2D tile_batchTexture;
+in vec2 tile_featureSt;
+void main()
+{
+ vec4 featureProperties = texture(tile_batchTexture, tile_featureSt);
+ if (featureProperties.a == 0.0) {
+ discard;
+ }
+`,e&&(i+=` bool isStyleTranslucent = (featureProperties.a != 1.0);
+ if (czm_pass == czm_passTranslucent)
+ {
+ if (!isStyleTranslucent && !tile_translucentCommand)
+ {
+ discard;
+ }
+ }
+ else
+ {
+ if (isStyleTranslucent)
+ {
+ discard;
+ }
+ }
+`),i+=` tile_color(featureProperties);
+`,n&&(i+=` out_FragColor.rgb *= out_FragColor.a;
+`),i+=`}
+`),i}};lo.prototype.getClassificationFragmentShaderCallback=function(){if(this.featuresLength!==0)return function(e){return e=Be.replaceMain(e,"tile_main"),kt.maximumVertexTextureImageUnits>0?e+=`uniform sampler2D tile_pickTexture;
+in vec2 tile_featureSt;
+in vec4 tile_featureColor;
+void main()
+{
+ tile_main();
+ out_FragColor = tile_featureColor;
+ out_FragColor.rgb *= out_FragColor.a;
+}`:e+=`uniform sampler2D tile_batchTexture;
+uniform sampler2D tile_pickTexture;
+in vec2 tile_featureSt;
+void main()
+{
+ tile_main();
+ vec4 featureProperties = texture(tile_batchTexture, tile_featureSt);
+ if (featureProperties.a == 0.0) {
+ discard;
+ }
+ out_FragColor = featureProperties;
+ out_FragColor.rgb *= out_FragColor.a;
+}
+`,e}};function LWe(e){let t=e._content.tileset,n=t.colorBlendMode,i=t.colorBlendAmount;if(n===fl.HIGHLIGHT)return 0;if(n===fl.REPLACE)return 1;if(n===fl.MIX)return W.clamp(i,W.EPSILON4,1)}lo.prototype.getUniformMapCallback=function(){if(this.featuresLength===0)return;let e=this;return function(t){return xt(t,{tile_batchTexture:function(){return g(e._batchTexture.batchTexture,e._batchTexture.defaultTexture)},tile_textureDimensions:function(){return e._batchTexture.textureDimensions},tile_textureStep:function(){return e._batchTexture.textureStep},tile_colorBlend:function(){return LWe(e)},tile_pickTexture:function(){return e._batchTexture.pickTexture}})}};lo.prototype.getPickId=function(){return"texture(tile_pickTexture, tile_featureSt)"};var xb={ALL_OPAQUE:0,ALL_TRANSLUCENT:1,OPAQUE_AND_TRANSLUCENT:2};lo.prototype.addDerivedCommands=function(e,t){let n=e.commandList,i=n.length,o=this._content._tile,r=o._finalResolution,s=o.tileset,a=s.isSkippingLevelOfDetail&&s.hasMixedContent&&e.context.stencilBuffer,c=RWe(this);for(let l=t;l>>wt.SKIP_LOD_BIT_SHIFT}function vWe(e){let t=Oe(e,!0);return t.cull.enabled=!1,t.depthTest.enabled=!0,t.depthMask=!1,t.blending=un.ALPHA_BLEND,t.stencilTest=wt.setCesium3DTileBit(),t.stencilMask=wt.CESIUM_3D_TILE_MASK,De.fromCache(t)}function FWe(e){let t=Oe(e,!0);return t.stencilTest=wt.setCesium3DTileBit(),t.stencilMask=wt.CESIUM_3D_TILE_MASK,De.fromCache(t)}lo.prototype.update=function(e,t){this._batchTexture.update(e,t)};lo.prototype.isDestroyed=function(){return!1};lo.prototype.destroy=function(){return this._batchTexture=this._batchTexture&&this._batchTexture.destroy(),ue(this)};var gp=lo;var Mqt=T(S(),1);var G6t=T(S(),1);function wWe(e){this.offset=e.offset,this.count=e.count,this.color=e.color,this.batchIds=e.batchIds}var Dh=wWe;var Lqt=T(S(),1);var X6t=T(S(),1),ES=`in vec3 position;
+in float a_batchId;
+
+uniform mat4 u_modifiedModelViewProjection;
+
+void main()
+{
+ gl_Position = czm_depthClamp(u_modifiedModelViewProjection * vec4(position, 1.0));
+}
+`;var v6t=T(S(),1);function tu(e,t){this._content=e,this._batchId=t,this._color=void 0}Object.defineProperties(tu.prototype,{show:{get:function(){return this._content.batchTable.getShow(this._batchId)},set:function(e){this._content.batchTable.setShow(this._batchId,e)}},color:{get:function(){return d(this._color)||(this._color=new B),this._content.batchTable.getColor(this._batchId,this._color)},set:function(e){this._content.batchTable.setColor(this._batchId,e)}},polylinePositions:{get:function(){if(d(this._content.getPolylinePositions))return this._content.getPolylinePositions(this._batchId)}},content:{get:function(){return this._content}},tileset:{get:function(){return this._content.tileset}},primitive:{get:function(){return this._content.tileset}},featureId:{get:function(){return this._batchId}},pickId:{get:function(){return this._content.batchTable.getPickColor(this._batchId)}}});tu.prototype.hasProperty=function(e){return this._content.batchTable.hasProperty(this._batchId,e)};tu.prototype.getPropertyIds=function(e){return this._content.batchTable.getPropertyIds(this._batchId,e)};tu.prototype.getProperty=function(e){return this._content.batchTable.getProperty(this._batchId,e)};tu.getPropertyInherited=function(e,t,n){let i=e.batchTable;if(d(i)){if(i.hasPropertyBySemantic(t,n))return i.getPropertyBySemantic(t,n);if(i.hasProperty(t,n))return i.getProperty(t,n)}let o=e.metadata;if(d(o)){if(o.hasPropertyBySemantic(n))return o.getPropertyBySemantic(n);if(o.hasProperty(n))return o.getProperty(n)}let r=e.tile,s=r.metadata;if(d(s)){if(s.hasPropertyBySemantic(n))return s.getPropertyBySemantic(n);if(s.hasProperty(n))return s.getProperty(n)}let a;if(d(r.implicitSubtree)&&(a=r.implicitSubtree.metadata),d(a)){if(a.hasPropertyBySemantic(n))return a.getPropertyBySemantic(n);if(a.hasProperty(n))return a.getProperty(n)}let c=d(e.group)?e.group.metadata:void 0;if(d(c)){if(c.hasPropertyBySemantic(n))return c.getPropertyBySemantic(n);if(c.hasProperty(n))return c.getProperty(n)}let l=e.tileset.metadata;if(d(l)){if(l.hasPropertyBySemantic(n))return l.getPropertyBySemantic(n);if(l.hasProperty(n))return l.getProperty(n)}};tu.prototype.getPropertyInherited=function(e){return tu.getPropertyInherited(this._content,this._batchId,e)};tu.prototype.setProperty=function(e,t){this._content.batchTable.setProperty(this._batchId,e,t),this._content.featurePropertiesDirty=!0};tu.prototype.isExactClass=function(e){return this._content.batchTable.isExactClass(this._batchId,e)};tu.prototype.isClass=function(e){return this._content.batchTable.isClass(this._batchId,e)};tu.prototype.getExactClassName=function(){return this._content.batchTable.getExactClassName(this._batchId)};var Ss=tu;var J6t=T(S(),1);var w6t=T(S(),1),hY=class{add(t,n,i){if(typeof arguments[0]!="string")for(let o in arguments[0])this.add(o,arguments[0][o],arguments[1]);else(Array.isArray(t)?t:[t]).forEach(function(o){this[o]=this[o]||[],n&&this[o][i?"unshift":"push"](n)},this)}run(t,n){this[t]=this[t]||[],this[t].forEach(function(i){i.call(n&&n.context?n.context:n,n)})}},fY=class{constructor(t){this.jsep=t,this.registered={}}register(...t){t.forEach(n=>{if(typeof n!="object"||!n.name||!n.init)throw new Error("Invalid JSEP plugin format");this.registered[n.name]||(n.init(this.jsep),this.registered[n.name]=n)})}},pl=class e{static get version(){return"1.3.8"}static toString(){return"JavaScript Expression Parser (JSEP) v"+e.version}static addUnaryOp(t){return e.max_unop_len=Math.max(t.length,e.max_unop_len),e.unary_ops[t]=1,e}static addBinaryOp(t,n,i){return e.max_binop_len=Math.max(t.length,e.max_binop_len),e.binary_ops[t]=n,i?e.right_associative.add(t):e.right_associative.delete(t),e}static addIdentifierChar(t){return e.additional_identifier_chars.add(t),e}static addLiteral(t,n){return e.literals[t]=n,e}static removeUnaryOp(t){return delete e.unary_ops[t],t.length===e.max_unop_len&&(e.max_unop_len=e.getMaxKeyLen(e.unary_ops)),e}static removeAllUnaryOps(){return e.unary_ops={},e.max_unop_len=0,e}static removeIdentifierChar(t){return e.additional_identifier_chars.delete(t),e}static removeBinaryOp(t){return delete e.binary_ops[t],t.length===e.max_binop_len&&(e.max_binop_len=e.getMaxKeyLen(e.binary_ops)),e.right_associative.delete(t),e}static removeAllBinaryOps(){return e.binary_ops={},e.max_binop_len=0,e}static removeLiteral(t){return delete e.literals[t],e}static removeAllLiterals(){return e.literals={},e}get char(){return this.expr.charAt(this.index)}get code(){return this.expr.charCodeAt(this.index)}constructor(t){this.expr=t,this.index=0}static parse(t){return new e(t).parse()}static getMaxKeyLen(t){return Math.max(0,...Object.keys(t).map(n=>n.length))}static isDecimalDigit(t){return t>=48&&t<=57}static binaryPrecedence(t){return e.binary_ops[t]||0}static isIdentifierStart(t){return t>=65&&t<=90||t>=97&&t<=122||t>=128&&!e.binary_ops[String.fromCharCode(t)]||e.additional_identifier_chars.has(String.fromCharCode(t))}static isIdentifierPart(t){return e.isIdentifierStart(t)||e.isDecimalDigit(t)}throwError(t){let n=new Error(t+" at character "+this.index);throw n.index=this.index,n.description=t,n}runHook(t,n){if(e.hooks[t]){let i={context:this,node:n};return e.hooks.run(t,i),i.node}return n}searchHook(t){if(e.hooks[t]){let n={context:this};return e.hooks[t].find(function(i){return i.call(n.context,n),n.node}),n.node}}gobbleSpaces(){let t=this.code;for(;t===e.SPACE_CODE||t===e.TAB_CODE||t===e.LF_CODE||t===e.CR_CODE;)t=this.expr.charCodeAt(++this.index);this.runHook("gobble-spaces")}parse(){this.runHook("before-all");let t=this.gobbleExpressions(),n=t.length===1?t[0]:{type:e.COMPOUND,body:t};return this.runHook("after-all",n)}gobbleExpressions(t){let n=[],i,o;for(;this.index0;){if(e.binary_ops.hasOwnProperty(t)&&(!e.isIdentifierStart(this.code)||this.index+t.lengthr.right_a&&m.right_a?i>m.prec:i<=m.prec;for(;o.length>2&&u(o[o.length-2]);)a=o.pop(),n=o.pop().value,s=o.pop(),t={type:e.BINARY_EXP,operator:n,left:s,right:a},o.push(t);t=this.gobbleToken(),t||this.throwError("Expected expression after "+l),o.push(r,t)}for(c=o.length-1,t=o[c];c>1;)t={type:e.BINARY_EXP,operator:o[c-1].value,left:o[c-2],right:t},c-=2;return t}gobbleToken(){let t,n,i,o;if(this.gobbleSpaces(),o=this.searchHook("gobble-token"),o)return this.runHook("after-token",o);if(t=this.code,e.isDecimalDigit(t)||t===e.PERIOD_CODE)return this.gobbleNumericLiteral();if(t===e.SQUOTE_CODE||t===e.DQUOTE_CODE)o=this.gobbleStringLiteral();else if(t===e.OBRACK_CODE)o=this.gobbleArray();else{for(n=this.expr.substr(this.index,e.max_unop_len),i=n.length;i>0;){if(e.unary_ops.hasOwnProperty(n)&&(!e.isIdentifierStart(this.code)||this.index+n.length=n.length&&this.throwError("Unexpected token "+String.fromCharCode(t));break}else if(r===e.COMMA_CODE){if(this.index++,o++,o!==n.length){if(t===e.CPAREN_CODE)this.throwError("Unexpected token ,");else if(t===e.CBRACK_CODE)for(let s=n.length;s":7,"<=":7,">=":7,"<<":8,">>":8,">>>":8,"+":9,"-":9,"*":10,"/":10,"%":10},right_associative:new Set,additional_identifier_chars:new Set(["$","_"]),literals:{true:!0,false:!1,null:null},this_str:"this"});pl.max_unop_len=pl.getMaxKeyLen(pl.unary_ops);pl.max_binop_len=pl.getMaxKeyLen(pl.binary_ops);var _b=e=>new pl(e).parse(),MWe=Object.getOwnPropertyNames(pl);MWe.forEach(e=>{_b[e]===void 0&&e!=="prototype"&&(_b[e]=pl[e])});_b.Jsep=pl;var NWe="ConditionalExpression",UWe={name:"ternary",init(e){e.hooks.add("after-expression",function(n){if(n.node&&this.code===e.QUMARK_CODE){this.index++;let i=n.node,o=this.gobbleExpression();if(o||this.throwError("Expected expression"),this.gobbleSpaces(),this.code===e.COLON_CODE){this.index++;let r=this.gobbleExpression();if(r||this.throwError("Expected expression"),n.node={type:NWe,test:i,consequent:o,alternate:r},i.operator&&e.binary_ops[i.operator]<=.9){let s=i;for(;s.right.operator&&e.binary_ops[s.right.operator]<=.9;)s=s.right;n.node.test=s.right,s.right=n.node,n.node=i}}else this.throwError("Expected :")}})}};_b.plugins.register(UWe);var M6t=T(S(),1),kWe={VARIABLE:0,UNARY:1,BINARY:2,TERNARY:3,CONDITIONAL:4,MEMBER:5,FUNCTION_CALL:6,ARRAY:7,REGEX:8,VARIABLE_IN_STRING:9,LITERAL_NULL:10,LITERAL_BOOLEAN:11,LITERAL_NUMBER:12,LITERAL_STRING:13,LITERAL_COLOR:14,LITERAL_VECTOR:15,LITERAL_REGEX:16,LITERAL_UNDEFINED:17,BUILTIN_VARIABLE:18},ft=Object.freeze(kWe);function xm(e,t){this._expression=e,e=e2e(e,t),e=n2e(t2e(e)),_b.addBinaryOp("=~",0),_b.addBinaryOp("!~",0);let n;try{n=_b(e)}catch(i){throw new me(i)}this._runtimeAst=Ci(this,n)}Object.defineProperties(xm.prototype,{expression:{get:function(){return this._expression}}});var Pn={arrayIndex:0,arrayArray:[[]],cartesian2Index:0,cartesian3Index:0,cartesian4Index:0,cartesian2Array:[new D],cartesian3Array:[new h],cartesian4Array:[new se],reset:function(){this.arrayIndex=0,this.cartesian2Index=0,this.cartesian3Index=0,this.cartesian4Index=0},getArray:function(){this.arrayIndex>=this.arrayArray.length&&this.arrayArray.push([]);let e=this.arrayArray[this.arrayIndex++];return e.length=0,e},getCartesian2:function(){return this.cartesian2Index>=this.cartesian2Array.length&&this.cartesian2Array.push(new D),this.cartesian2Array[this.cartesian2Index++]},getCartesian3:function(){return this.cartesian3Index>=this.cartesian3Array.length&&this.cartesian3Array.push(new h),this.cartesian3Array[this.cartesian3Index++]},getCartesian4:function(){return this.cartesian4Index>=this.cartesian4Array.length&&this.cartesian4Array.push(new se),this.cartesian4Array[this.cartesian4Index++]}};xm.prototype.evaluate=function(e,t){Pn.reset();let n=this._runtimeAst.evaluate(e);return t instanceof B&&n instanceof se?B.fromCartesian4(n,t):n instanceof D||n instanceof h||n instanceof se?n.clone(t):n};xm.prototype.evaluateColor=function(e,t){Pn.reset();let n=this._runtimeAst.evaluate(e);return B.fromCartesian4(n,t)};xm.prototype.getShaderFunction=function(e,t,n,i){let o=this.getShaderExpression(t,n);return o=`${i} ${e}
+{
+ return ${o};
+}
+`,o};xm.prototype.getShaderExpression=function(e,t){return this._runtimeAst.getShaderExpression(e,t)};xm.prototype.getVariables=function(){let e=[];return this._runtimeAst.getVariables(e),e=e.filter(function(t,n,i){return i.indexOf(t)===n}),e};var DWe=["!","-","+"],Lte=["+","-","*","/","%","===","!==",">",">=","<","<=","&&","||","!~","=~"],TM=/\${(.*?)}/g,BWe=/\\/g,YWe="@#%",OWe=/@#%/g,SM=new B,CM={abs:Cs(Math.abs),sqrt:Cs(Math.sqrt),cos:Cs(Math.cos),sin:Cs(Math.sin),tan:Cs(Math.tan),acos:Cs(Math.acos),asin:Cs(Math.asin),atan:Cs(Math.atan),radians:Cs(W.toRadians),degrees:Cs(W.toDegrees),sign:Cs(W.sign),floor:Cs(Math.floor),ceil:Cs(Math.ceil),round:Cs(Math.round),exp:Cs(Math.exp),exp2:Cs(HWe),log:Cs(Math.log),log2:Cs(zWe),fract:Cs(KWe),length:JWe,normalize:QWe},VM={atan2:xM(Math.atan2,!1),pow:xM(Math.pow,!1),min:xM(Math.min,!0),max:xM(Math.max,!0),distance:jWe,dot:qWe,cross:$We},yY={clamp:Rte(W.clamp,!0),mix:Rte(W.lerp,!0)};function KWe(e){return e-Math.floor(e)}function HWe(e){return Math.pow(2,e)}function zWe(e){return W.log2(e)}function Cs(e){return function(t,n){if(typeof n=="number")return e(n);if(n instanceof D)return D.fromElements(e(n.x),e(n.y),Pn.getCartesian2());if(n instanceof h)return h.fromElements(e(n.x),e(n.y),e(n.z),Pn.getCartesian3());if(n instanceof se)return se.fromElements(e(n.x),e(n.y),e(n.z),e(n.w),Pn.getCartesian4());throw new me(`Function "${t}" requires a vector or number argument. Argument is ${n}.`)}}function xM(e,t){return function(n,i,o){if(t&&typeof o=="number"){if(typeof i=="number")return e(i,o);if(i instanceof D)return D.fromElements(e(i.x,o),e(i.y,o),Pn.getCartesian2());if(i instanceof h)return h.fromElements(e(i.x,o),e(i.y,o),e(i.z,o),Pn.getCartesian3());if(i instanceof se)return se.fromElements(e(i.x,o),e(i.y,o),e(i.z,o),e(i.w,o),Pn.getCartesian4())}if(typeof i=="number"&&typeof o=="number")return e(i,o);if(i instanceof D&&o instanceof D)return D.fromElements(e(i.x,o.x),e(i.y,o.y),Pn.getCartesian2());if(i instanceof h&&o instanceof h)return h.fromElements(e(i.x,o.x),e(i.y,o.y),e(i.z,o.z),Pn.getCartesian3());if(i instanceof se&&o instanceof se)return se.fromElements(e(i.x,o.x),e(i.y,o.y),e(i.z,o.z),e(i.w,o.w),Pn.getCartesian4());throw new me(`Function "${n}" requires vector or number arguments of matching types. Arguments are ${i} and ${o}.`)}}function Rte(e,t){return function(n,i,o,r){if(t&&typeof r=="number"){if(typeof i=="number"&&typeof o=="number")return e(i,o,r);if(i instanceof D&&o instanceof D)return D.fromElements(e(i.x,o.x,r),e(i.y,o.y,r),Pn.getCartesian2());if(i instanceof h&&o instanceof h)return h.fromElements(e(i.x,o.x,r),e(i.y,o.y,r),e(i.z,o.z,r),Pn.getCartesian3());if(i instanceof se&&o instanceof se)return se.fromElements(e(i.x,o.x,r),e(i.y,o.y,r),e(i.z,o.z,r),e(i.w,o.w,r),Pn.getCartesian4())}if(typeof i=="number"&&typeof o=="number"&&typeof r=="number")return e(i,o,r);if(i instanceof D&&o instanceof D&&r instanceof D)return D.fromElements(e(i.x,o.x,r.x),e(i.y,o.y,r.y),Pn.getCartesian2());if(i instanceof h&&o instanceof h&&r instanceof h)return h.fromElements(e(i.x,o.x,r.x),e(i.y,o.y,r.y),e(i.z,o.z,r.z),Pn.getCartesian3());if(i instanceof se&&o instanceof se&&r instanceof se)return se.fromElements(e(i.x,o.x,r.x),e(i.y,o.y,r.y),e(i.z,o.z,r.z),e(i.w,o.w,r.w),Pn.getCartesian4());throw new me(`Function "${n}" requires vector or number arguments of matching types. Arguments are ${i}, ${o}, and ${r}.`)}}function JWe(e,t){if(typeof t=="number")return Math.abs(t);if(t instanceof D)return D.magnitude(t);if(t instanceof h)return h.magnitude(t);if(t instanceof se)return se.magnitude(t);throw new me(`Function "${e}" requires a vector or number argument. Argument is ${t}.`)}function QWe(e,t){if(typeof t=="number")return 1;if(t instanceof D)return D.normalize(t,Pn.getCartesian2());if(t instanceof h)return h.normalize(t,Pn.getCartesian3());if(t instanceof se)return se.normalize(t,Pn.getCartesian4());throw new me(`Function "${e}" requires a vector or number argument. Argument is ${t}.`)}function jWe(e,t,n){if(typeof t=="number"&&typeof n=="number")return Math.abs(t-n);if(t instanceof D&&n instanceof D)return D.distance(t,n);if(t instanceof h&&n instanceof h)return h.distance(t,n);if(t instanceof se&&n instanceof se)return se.distance(t,n);throw new me(`Function "${e}" requires vector or number arguments of matching types. Arguments are ${t} and ${n}.`)}function qWe(e,t,n){if(typeof t=="number"&&typeof n=="number")return t*n;if(t instanceof D&&n instanceof D)return D.dot(t,n);if(t instanceof h&&n instanceof h)return h.dot(t,n);if(t instanceof se&&n instanceof se)return se.dot(t,n);throw new me(`Function "${e}" requires vector or number arguments of matching types. Arguments are ${t} and ${n}.`)}function $We(e,t,n){if(t instanceof h&&n instanceof h)return h.cross(t,n,Pn.getCartesian3());throw new me(`Function "${e}" requires vec3 arguments. Arguments are ${t} and ${n}.`)}function gt(e,t,n,i,o){this._type=e,this._value=t,this._left=n,this._right=i,this._test=o,this.evaluate=void 0,m2e(this)}function e2e(e,t){if(!d(t))return e;for(let n in t)if(t.hasOwnProperty(n)){let i=new RegExp(`\\$\\{${n}\\}`,"g"),o=`(${t[n]})`;d(o)&&(e=e.replace(i,o))}return e}function t2e(e){return e.replace(BWe,YWe)}function bY(e){return e.replace(OWe,"\\")}function n2e(e){let t=e,n="",i=t.indexOf("${");for(;i>=0;){let o=t.indexOf("'"),r=t.indexOf('"'),s;if(o>=0&&o=0&&r=0?new gt(ft.VARIABLE_IN_STRING,e.value):new gt(ft.LITERAL_STRING,bY(e.value))}function o2e(e,t){let n=t.arguments,i=n.length,o,r,s,a;if(t.callee.type==="MemberExpression"){o=t.callee.property.name;let c=t.callee.object;if(o==="test"||o==="exec"){if(!d(c.callee)||c.callee.name!=="regExp")throw new me(`${o} is not a function.`);return i===0?o==="test"?new gt(ft.LITERAL_BOOLEAN,!1):new gt(ft.LITERAL_NULL,null):(s=Ci(e,c),a=Ci(e,n[0]),new gt(ft.FUNCTION_CALL,o,s,a))}else if(o==="toString")return r=Ci(e,c),new gt(ft.FUNCTION_CALL,o,r);throw new me(`Unexpected function call "${o}".`)}if(o=t.callee.name,o==="color"){if(i===0)return new gt(ft.LITERAL_COLOR,o);if(r=Ci(e,n[0]),d(n[1])){let c=Ci(e,n[1]);return new gt(ft.LITERAL_COLOR,o,[r,c])}return new gt(ft.LITERAL_COLOR,o,[r])}else if(o==="rgb"||o==="hsl"){if(i<3)throw new me(`${o} requires three arguments.`);return r=[Ci(e,n[0]),Ci(e,n[1]),Ci(e,n[2])],new gt(ft.LITERAL_COLOR,o,r)}else if(o==="rgba"||o==="hsla"){if(i<4)throw new me(`${o} requires four arguments.`);return r=[Ci(e,n[0]),Ci(e,n[1]),Ci(e,n[2]),Ci(e,n[3])],new gt(ft.LITERAL_COLOR,o,r)}else if(o==="vec2"||o==="vec3"||o==="vec4"){r=new Array(i);for(let c=0;c1)throw new me(`${o} requires exactly one argument.`);return r=Ci(e,n[0]),new gt(ft.UNARY,o,r)}else if(o==="getExactClassName"){if(i>0)throw new me(`${o} does not take any argument.`);return new gt(ft.UNARY,o)}else if(d(CM[o])){if(i!==1)throw new me(`${o} requires exactly one argument.`);return r=Ci(e,n[0]),new gt(ft.UNARY,o,r)}else if(d(VM[o])){if(i!==2)throw new me(`${o} requires exactly two arguments.`);return s=Ci(e,n[0]),a=Ci(e,n[1]),new gt(ft.BINARY,o,s,a)}else if(d(yY[o])){if(i!==3)throw new me(`${o} requires exactly three arguments.`);s=Ci(e,n[0]),a=Ci(e,n[1]);let c=Ci(e,n[2]);return new gt(ft.TERNARY,o,s,a,c)}else{if(o==="Boolean")return i===0?new gt(ft.LITERAL_BOOLEAN,!1):(r=Ci(e,n[0]),new gt(ft.UNARY,o,r));if(o==="Number")return i===0?new gt(ft.LITERAL_NUMBER,0):(r=Ci(e,n[0]),new gt(ft.UNARY,o,r));if(o==="String")return i===0?new gt(ft.LITERAL_STRING,""):(r=Ci(e,n[0]),new gt(ft.UNARY,o,r));if(o==="regExp")return r2e(e,t)}}throw new me(`Unexpected function call "${o}".`)}function r2e(e,t){let n=t.arguments;if(n.length===0)return new gt(ft.LITERAL_REGEX,new RegExp);let i=Ci(e,n[0]),o;if(n.length>1){let r=Ci(e,n[1]);if(pY(i)&&pY(r)){try{o=new RegExp(bY(String(i._value)),r._value)}catch(s){throw new me(s)}return new gt(ft.LITERAL_REGEX,o)}return new gt(ft.REGEX,i,r)}if(pY(i)){try{o=new RegExp(bY(String(i._value)))}catch(r){throw new me(r)}return new gt(ft.LITERAL_REGEX,o)}return new gt(ft.REGEX,i)}function s2e(e){if(d2e(e.name)){let t=u2e(e.name);return t.substr(0,8)==="tiles3d_"?new gt(ft.BUILTIN_VARIABLE,t):new gt(ft.VARIABLE,t)}else{if(e.name==="NaN")return new gt(ft.LITERAL_NUMBER,NaN);if(e.name==="Infinity")return new gt(ft.LITERAL_NUMBER,1/0);if(e.name==="undefined")return new gt(ft.LITERAL_UNDEFINED,void 0)}throw new me(`${e.name} is not defined.`)}function a2e(e){let t=e.property.name;if(t==="PI")return new gt(ft.LITERAL_NUMBER,Math.PI);if(t==="E")return new gt(ft.LITERAL_NUMBER,Math.E)}function c2e(e){if(e.property.name==="POSITIVE_INFINITY")return new gt(ft.LITERAL_NUMBER,Number.POSITIVE_INFINITY)}function l2e(e,t){if(t.object.name==="Math")return a2e(t);if(t.object.name==="Number")return c2e(t);let n,i=Ci(e,t.object);return t.computed?(n=Ci(e,t.property),new gt(ft.MEMBER,"brackets",i,n)):(n=new gt(ft.LITERAL_STRING,t.property.name),new gt(ft.MEMBER,"dot",i,n))}function pY(e){return e._type>=ft.LITERAL_NULL}function d2e(e){return e.substr(0,4)==="czm_"}function u2e(e){return e.substr(4)}function Ci(e,t){let n,i,o,r;if(t.type==="Literal")n=i2e(t);else if(t.type==="CallExpression")n=o2e(e,t);else if(t.type==="Identifier")n=s2e(t);else if(t.type==="UnaryExpression"){i=t.operator;let s=Ci(e,t.argument);if(DWe.indexOf(i)>-1)n=new gt(ft.UNARY,i,s);else throw new me(`Unexpected operator "${i}".`)}else if(t.type==="BinaryExpression")if(i=t.operator,o=Ci(e,t.left),r=Ci(e,t.right),Lte.indexOf(i)>-1)n=new gt(ft.BINARY,i,o,r);else throw new me(`Unexpected operator "${i}".`);else if(t.type==="LogicalExpression")i=t.operator,o=Ci(e,t.left),r=Ci(e,t.right),Lte.indexOf(i)>-1&&(n=new gt(ft.BINARY,i,o,r));else if(t.type==="ConditionalExpression"){let s=Ci(e,t.test);o=Ci(e,t.consequent),r=Ci(e,t.alternate),n=new gt(ft.CONDITIONAL,"?",o,r,s)}else if(t.type==="MemberExpression")n=l2e(e,t);else if(t.type==="ArrayExpression"){let s=[];for(let a=0;a"?e.evaluate=e._evaluateGreaterThan:e._value===">="?e.evaluate=e._evaluateGreaterThanOrEquals:e._value==="&&"?e.evaluate=e._evaluateAnd:e._value==="||"?e.evaluate=e._evaluateOr:e._value==="=~"?e.evaluate=e._evaluateRegExpMatch:e._value==="!~"?e.evaluate=e._evaluateRegExpNotMatch:d(VM[e._value])&&(e.evaluate=p2e(e._value)):e._type===ft.TERNARY?e.evaluate=b2e(e._value):e._type===ft.MEMBER?e._value==="brackets"?e.evaluate=e._evaluateMemberBrackets:e.evaluate=e._evaluateMemberDot:e._type===ft.ARRAY?e.evaluate=e._evaluateArray:e._type===ft.VARIABLE?e.evaluate=e._evaluateVariable:e._type===ft.VARIABLE_IN_STRING?e.evaluate=e._evaluateVariableString:e._type===ft.LITERAL_COLOR?e.evaluate=e._evaluateLiteralColor:e._type===ft.LITERAL_VECTOR?e.evaluate=e._evaluateLiteralVector:e._type===ft.LITERAL_STRING?e.evaluate=e._evaluateLiteralString:e._type===ft.REGEX?e.evaluate=e._evaluateRegExp:e._type===ft.BUILTIN_VARIABLE?e._value==="tiles3d_tileset_time"&&(e.evaluate=h2e):e.evaluate=e._evaluateLiteral}function h2e(e){return d(e)?e.content.tileset.timeSinceLoad:0}function f2e(e){let t=CM[e];return function(n){let i=this._left.evaluate(n);return t(e,i)}}function p2e(e){let t=VM[e];return function(n){let i=this._left.evaluate(n),o=this._right.evaluate(n);return t(e,i,o)}}function b2e(e){let t=yY[e];return function(n){let i=this._left.evaluate(n),o=this._right.evaluate(n),r=this._test.evaluate(n);return t(e,i,o,r)}}function LM(e,t){if(d(e))return e.getPropertyInherited(t)}gt.prototype._evaluateLiteral=function(){return this._value};gt.prototype._evaluateLiteralColor=function(e){let t=SM,n=this._left;if(this._value==="color")d(n)?n.length>1?(B.fromCssColorString(n[0].evaluate(e),t),t.alpha=n[1].evaluate(e)):B.fromCssColorString(n[0].evaluate(e),t):B.fromBytes(255,255,255,255,t);else if(this._value==="rgb")B.fromBytes(n[0].evaluate(e),n[1].evaluate(e),n[2].evaluate(e),255,t);else if(this._value==="rgba"){let i=n[3].evaluate(e)*255;B.fromBytes(n[0].evaluate(e),n[1].evaluate(e),n[2].evaluate(e),i,t)}else this._value==="hsl"?B.fromHsl(n[0].evaluate(e),n[1].evaluate(e),n[2].evaluate(e),1,t):this._value==="hsla"&&B.fromHsl(n[0].evaluate(e),n[1].evaluate(e),n[2].evaluate(e),n[3].evaluate(e),t);return se.fromColor(t,Pn.getCartesian4())};gt.prototype._evaluateLiteralVector=function(e){let t=Pn.getArray(),n=this._value,i=this._left,o=i.length;for(let a=0;a1)throw new me(`Invalid ${n} constructor. Not enough arguments.`);if(r>s&&o>1)throw new me(`Invalid ${n} constructor. Too many arguments.`);if(r===1){let a=t[0];t.push(a,a,a)}if(n==="vec2")return D.fromArray(t,0,Pn.getCartesian2());if(n==="vec3")return h.fromArray(t,0,Pn.getCartesian3());if(n==="vec4")return se.fromArray(t,0,Pn.getCartesian4())};gt.prototype._evaluateLiteralString=function(){return this._value};gt.prototype._evaluateVariableString=function(e){let t=this._value,n=TM.exec(t);for(;n!==null;){let i=n[0],o=n[1],r=LM(e,o);d(r)||(r=""),t=t.replace(i,r),n=TM.exec(t)}return t};gt.prototype._evaluateVariable=function(e){return LM(e,this._value)};function yx(e){return e._value==="feature"}gt.prototype._evaluateMemberDot=function(e){if(yx(this._left))return LM(e,this._right.evaluate(e));let t=this._left.evaluate(e);if(!d(t))return;let n=this._right.evaluate(e);if(t instanceof D||t instanceof h||t instanceof se){if(n==="r")return t.x;if(n==="g")return t.y;if(n==="b")return t.z;if(n==="a")return t.w}return t[n]};gt.prototype._evaluateMemberBrackets=function(e){if(yx(this._left))return LM(e,this._right.evaluate(e));let t=this._left.evaluate(e);if(!d(t))return;let n=this._right.evaluate(e);if(t instanceof D||t instanceof h||t instanceof se){if(n===0||n==="r")return t.x;if(n===1||n==="g")return t.y;if(n===2||n==="b")return t.z;if(n===3||n==="a")return t.w}return t[n]};gt.prototype._evaluateArray=function(e){let t=[];for(let n=0;n" requires number arguments. Arguments are ${t} and ${n}.`);return t>n};gt.prototype._evaluateGreaterThanOrEquals=function(e){let t=this._left.evaluate(e),n=this._right.evaluate(e);if(typeof t!="number"||typeof n!="number")throw new me(`Operator ">=" requires number arguments. Arguments are ${t} and ${n}.`);return t>=n};gt.prototype._evaluateOr=function(e){let t=this._left.evaluate(e);if(typeof t!="boolean")throw new me(`Operator "||" requires boolean arguments. First argument is ${t}.`);if(t)return!0;let n=this._right.evaluate(e);if(typeof n!="boolean")throw new me(`Operator "||" requires boolean arguments. Second argument is ${n}.`);return t||n};gt.prototype._evaluateAnd=function(e){let t=this._left.evaluate(e);if(typeof t!="boolean")throw new me(`Operator "&&" requires boolean arguments. First argument is ${t}.`);if(!t)return!1;let n=this._right.evaluate(e);if(typeof n!="boolean")throw new me(`Operator "&&" requires boolean arguments. Second argument is ${n}.`);return t&&n};gt.prototype._evaluatePlus=function(e){let t=this._left.evaluate(e),n=this._right.evaluate(e);if(n instanceof D&&t instanceof D)return D.add(t,n,Pn.getCartesian2());if(n instanceof h&&t instanceof h)return h.add(t,n,Pn.getCartesian3());if(n instanceof se&&t instanceof se)return se.add(t,n,Pn.getCartesian4());if(typeof t=="string"||typeof n=="string")return t+n;if(typeof t=="number"&&typeof n=="number")return t+n;throw new me(`Operator "+" requires vector or number arguments of matching types, or at least one string argument. Arguments are ${t} and ${n}.`)};gt.prototype._evaluateMinus=function(e){let t=this._left.evaluate(e),n=this._right.evaluate(e);if(n instanceof D&&t instanceof D)return D.subtract(t,n,Pn.getCartesian2());if(n instanceof h&&t instanceof h)return h.subtract(t,n,Pn.getCartesian3());if(n instanceof se&&t instanceof se)return se.subtract(t,n,Pn.getCartesian4());if(typeof t=="number"&&typeof n=="number")return t-n;throw new me(`Operator "-" requires vector or number arguments of matching types. Arguments are ${t} and ${n}.`)};gt.prototype._evaluateTimes=function(e){let t=this._left.evaluate(e),n=this._right.evaluate(e);if(n instanceof D&&t instanceof D)return D.multiplyComponents(t,n,Pn.getCartesian2());if(n instanceof D&&typeof t=="number")return D.multiplyByScalar(n,t,Pn.getCartesian2());if(t instanceof D&&typeof n=="number")return D.multiplyByScalar(t,n,Pn.getCartesian2());if(n instanceof h&&t instanceof h)return h.multiplyComponents(t,n,Pn.getCartesian3());if(n instanceof h&&typeof t=="number")return h.multiplyByScalar(n,t,Pn.getCartesian3());if(t instanceof h&&typeof n=="number")return h.multiplyByScalar(t,n,Pn.getCartesian3());if(n instanceof se&&t instanceof se)return se.multiplyComponents(t,n,Pn.getCartesian4());if(n instanceof se&&typeof t=="number")return se.multiplyByScalar(n,t,Pn.getCartesian4());if(t instanceof se&&typeof n=="number")return se.multiplyByScalar(t,n,Pn.getCartesian4());if(typeof t=="number"&&typeof n=="number")return t*n;throw new me(`Operator "*" requires vector or number arguments. If both arguments are vectors they must be matching types. Arguments are ${t} and ${n}.`)};gt.prototype._evaluateDivide=function(e){let t=this._left.evaluate(e),n=this._right.evaluate(e);if(n instanceof D&&t instanceof D)return D.divideComponents(t,n,Pn.getCartesian2());if(t instanceof D&&typeof n=="number")return D.divideByScalar(t,n,Pn.getCartesian2());if(n instanceof h&&t instanceof h)return h.divideComponents(t,n,Pn.getCartesian3());if(t instanceof h&&typeof n=="number")return h.divideByScalar(t,n,Pn.getCartesian3());if(n instanceof se&&t instanceof se)return se.divideComponents(t,n,Pn.getCartesian4());if(t instanceof se&&typeof n=="number")return se.divideByScalar(t,n,Pn.getCartesian4());if(typeof t=="number"&&typeof n=="number")return t/n;throw new me(`Operator "/" requires vector or number arguments of matching types, or a number as the second argument. Arguments are ${t} and ${n}.`)};gt.prototype._evaluateMod=function(e){let t=this._left.evaluate(e),n=this._right.evaluate(e);if(n instanceof D&&t instanceof D)return D.fromElements(t.x%n.x,t.y%n.y,Pn.getCartesian2());if(n instanceof h&&t instanceof h)return h.fromElements(t.x%n.x,t.y%n.y,t.z%n.z,Pn.getCartesian3());if(n instanceof se&&t instanceof se)return se.fromElements(t.x%n.x,t.y%n.y,t.z%n.z,t.w%n.w,Pn.getCartesian4());if(typeof t=="number"&&typeof n=="number")return t%n;throw new me(`Operator "%" requires vector or number arguments of matching types. Arguments are ${t} and ${n}.`)};gt.prototype._evaluateEqualsStrict=function(e){let t=this._left.evaluate(e),n=this._right.evaluate(e);return n instanceof D&&t instanceof D||n instanceof h&&t instanceof h||n instanceof se&&t instanceof se?t.equals(n):t===n};gt.prototype._evaluateNotEqualsStrict=function(e){let t=this._left.evaluate(e),n=this._right.evaluate(e);return n instanceof D&&t instanceof D||n instanceof h&&t instanceof h||n instanceof se&&t instanceof se?!t.equals(n):t!==n};gt.prototype._evaluateConditional=function(e){let t=this._test.evaluate(e);if(typeof t!="boolean")throw new me(`Conditional argument of conditional expression must be a boolean. Argument is ${t}.`);return t?this._left.evaluate(e):this._right.evaluate(e)};gt.prototype._evaluateNaN=function(e){return isNaN(this._left.evaluate(e))};gt.prototype._evaluateIsFinite=function(e){return isFinite(this._left.evaluate(e))};gt.prototype._evaluateIsExactClass=function(e){return d(e)?e.isExactClass(this._left.evaluate(e)):!1};gt.prototype._evaluateIsClass=function(e){return d(e)?e.isClass(this._left.evaluate(e)):!1};gt.prototype._evaluateGetExactClassName=function(e){if(d(e))return e.getExactClassName()};gt.prototype._evaluateBooleanConversion=function(e){return!!this._left.evaluate(e)};gt.prototype._evaluateNumberConversion=function(e){return Number(this._left.evaluate(e))};gt.prototype._evaluateStringConversion=function(e){return String(this._left.evaluate(e))};gt.prototype._evaluateRegExp=function(e){let t=this._value.evaluate(e),n="";d(this._left)&&(n=this._left.evaluate(e));let i;try{i=new RegExp(t,n)}catch(o){throw new me(o)}return i};gt.prototype._evaluateRegExpTest=function(e){let t=this._left.evaluate(e),n=this._right.evaluate(e);if(!(t instanceof RegExp&&typeof n=="string"))throw new me(`RegExp.test requires the first argument to be a RegExp and the second argument to be a string. Arguments are ${t} and ${n}.`);return t.test(n)};gt.prototype._evaluateRegExpMatch=function(e){let t=this._left.evaluate(e),n=this._right.evaluate(e);if(t instanceof RegExp&&typeof n=="string")return t.test(n);if(n instanceof RegExp&&typeof t=="string")return n.test(t);throw new me(`Operator "=~" requires one RegExp argument and one string argument. Arguments are ${t} and ${n}.`)};gt.prototype._evaluateRegExpNotMatch=function(e){let t=this._left.evaluate(e),n=this._right.evaluate(e);if(t instanceof RegExp&&typeof n=="string")return!t.test(n);if(n instanceof RegExp&&typeof t=="string")return!n.test(t);throw new me(`Operator "!~" requires one RegExp argument and one string argument. Arguments are ${t} and ${n}.`)};gt.prototype._evaluateRegExpExec=function(e){let t=this._left.evaluate(e),n=this._right.evaluate(e);if(!(t instanceof RegExp&&typeof n=="string"))throw new me(`RegExp.exec requires the first argument to be a RegExp and the second argument to be a string. Arguments are ${t} and ${n}.`);let i=t.exec(n);return d(i)?i[1]:null};gt.prototype._evaluateToString=function(e){let t=this._left.evaluate(e);if(t instanceof RegExp||t instanceof D||t instanceof h||t instanceof se)return String(t);throw new me(`Unexpected function call "${this._value}".`)};function Zte(e){let t=e._left,n=t.length;for(let a=0;a1){let p=l[0],y=l[1];return y!=="1.0"&&(t.translucent=!0),`vec4(${p}, ${y})`}}else return"vec4(1.0)";return`vec4(${l[0]}, 1.0)`}else{if(c==="rgb")return i=Gte(this),d(i)?_M(i):`vec4(${l[0]} / 255.0, ${l[1]} / 255.0, ${l[2]} / 255.0, 1.0)`;if(c==="rgba")return l[3]!=="1.0"&&(t.translucent=!0),i=Gte(this),d(i)?_M(i):`vec4(${l[0]} / 255.0, ${l[1]} / 255.0, ${l[2]} / 255.0, ${l[3]})`;if(c==="hsl")return i=Zte(this),d(i)?_M(i):`vec4(czm_HSLToRGB(vec3(${l[0]}, ${l[1]}, ${l[2]})), 1.0)`;if(c==="hsla")return i=Zte(this),d(i)?(i.alpha!==1&&(t.translucent=!0),_M(i)):(l[3]!=="1.0"&&(t.translucent=!0),`vec4(czm_HSLToRGB(vec3(${l[0]}, ${l[1]}, ${l[2]})), ${l[3]})`)}break;case ft.LITERAL_VECTOR:u=o.length,m=`${c}(`;for(let p=0;p0;){let u=t.pop();if(B.equals(u.color,a.color))l=gY(n,s,l,i,o,u.batchIds,r),a.batchIds=a.batchIds.concat(u.batchIds),a.count=l-a.offset;else{let m=l;l=gY(n,s,l,i,o,u.batchIds,r),u.offset=m,u.count=l-m,c.push(u),a=u}}e._va.indexBuffer.copyFromArrayView(s),e._indices=s,e._batchedIndices=c}function xY(e,t,n,i,o,r,s){let a=e.bytesPerIndex,c=r.length;for(let l=0;l0;){let m=t.pop();if(B.equals(m.color,r.color))l=xY(a,c,l,n,i,m.batchIds,o),r.batchIds=r.batchIds.concat(m.batchIds),r.count=l-r.offset;else{let p=l;l=xY(a,c,l,n,i,m.batchIds,o),m.offset=p,m.count=l-p,s.push(m),r=m}}let u=e._va;e._va=e._vaSwap,e._vaSwap=u,e._batchedIndices=s}function Z2e(e,t){return t.color.toRgba()-e.color.toRgba()}function G2e(e,t){if(!e._batchDirty)return!1;let n=e._batchedIndices,i=n.length,o=!1,r={};for(let s=0;s=x&&s{e.isDestroyed()||(e._error=f)}):void 0}}function Y2e(e){d(e._primitive)||(e._primitive=new xx({batchTable:e._batchTable,positions:e._positions,batchIds:e._batchIds,vertexBatchIds:e._vertexBatchIds,indices:e._indices,indexOffsets:e._indexOffsets,indexCounts:e._indexCounts,batchedIndices:e._batchedIndices,boundingVolume:e._boundingVolume,boundingVolumes:e._boundingVolumes,center:e._center,pickObject:g(e._pickObject,e)}),e._boxes=void 0,e._boxBatchIds=void 0,e._cylinders=void 0,e._cylinderBatchIds=void 0,e._ellipsoids=void 0,e._ellipsoidBatchIds=void 0,e._spheres=void 0,e._sphereBatchIds=void 0,e._center=void 0,e._modelMatrix=void 0,e._batchTable=void 0,e._boundingVolume=void 0,e._boundingVolumes=void 0,e._batchedIndices=void 0,e._indices=void 0,e._indexOffsets=void 0,e._indexCounts=void 0,e._positions=void 0,e._vertexBatchIds=void 0,e._batchIds=void 0,e._batchTableColors=void 0,e._packedBuffer=void 0,e._verticesPromise=void 0)}td.prototype.createFeatures=function(e,t){this._primitive.createFeatures(e,t)};td.prototype.applyDebugSettings=function(e,t){this._primitive.applyDebugSettings(e,t)};td.prototype.applyStyle=function(e,t){this._primitive.applyStyle(e,t)};td.prototype.updateCommands=function(e,t){this._primitive.updateCommands(e,t)};td.prototype.update=function(e){if(!this._ready){if(d(this._promise)||(this._promise=B2e(this)),d(this._error)){let t=this._error;throw this._error=void 0,t}return}this._primitive.debugWireframe=this.debugWireframe,this._primitive.forceRebatch=this.forceRebatch,this._primitive.classificationType=this.classificationType,this._primitive.update(e)};td.prototype.isDestroyed=function(){return!1};td.prototype.destroy=function(){return this._primitive=this._primitive&&this._primitive.destroy(),ue(this)};var _p=td;function Tp(e,t,n,i,o){this._tileset=e,this._tile=t,this._resource=n,this._geometries=void 0,this._metadata=void 0,this._batchTable=void 0,this._features=void 0,this.featurePropertiesDirty=!1,this._group=void 0,this._ready=!1,H2e(this,i,o)}Object.defineProperties(Tp.prototype,{featuresLength:{get:function(){return d(this._batchTable)?this._batchTable.featuresLength:0}},pointsLength:{get:function(){return 0}},trianglesLength:{get:function(){return d(this._geometries)?this._geometries.trianglesLength:0}},geometryByteLength:{get:function(){return d(this._geometries)?this._geometries.geometryByteLength:0}},texturesByteLength:{get:function(){return 0}},batchTableByteLength:{get:function(){return d(this._batchTable)?this._batchTable.batchTableByteLength:0}},innerContents:{get:function(){}},ready:{get:function(){return this._ready}},tileset:{get:function(){return this._tileset}},tile:{get:function(){return this._tile}},url:{get:function(){return this._resource.getUrlComponent(!0)}},metadata:{get:function(){return this._metadata},set:function(e){this._metadata=e}},batchTable:{get:function(){return this._batchTable}},group:{get:function(){return this._group},set:function(e){this._group=e}}});function O2e(e){return function(t,n){d(e._geometries)&&e._geometries.updateCommands(t,n)}}function K2e(e,t){let n,i,o,r,s,a=g(e.BOXES_LENGTH,0),c=g(e.CYLINDERS_LENGTH,0),l=g(e.ELLIPSOIDS_LENGTH,0),u=g(e.SPHERES_LENGTH,0);if(a>0&&d(e.BOX_BATCH_IDS)){let f=t.byteOffset+e.BOX_BATCH_IDS.byteOffset;n=new Uint16Array(t.buffer,f,a)}if(c>0&&d(e.CYLINDER_BATCH_IDS)){let f=t.byteOffset+e.CYLINDER_BATCH_IDS.byteOffset;i=new Uint16Array(t.buffer,f,c)}if(l>0&&d(e.ELLIPSOID_BATCH_IDS)){let f=t.byteOffset+e.ELLIPSOID_BATCH_IDS.byteOffset;o=new Uint16Array(t.buffer,f,l)}if(u>0&&d(e.SPHERE_BATCH_IDS)){let f=t.byteOffset+e.SPHERE_BATCH_IDS.byteOffset;r=new Uint16Array(t.buffer,f,u)}let m=d(n)||d(i)||d(o)||d(r),p=a>0&&!d(n)||c>0&&!d(i)||l>0&&!d(o)||u>0&&!d(r);if(m&&p)throw new me("If one group of batch ids is defined, then all batch ids must be defined");if(!d(n)&&!d(i)&&!d(o)&&!d(r)){let f=0;if(!d(n)&&a>0)for(n=new Uint16Array(a),s=0;s