=0}):n[d]=o.slice())}}return n}function lH(e,t,n){let i=`#extension\\s+GL_${e}\\s+:\\s+[a-zA-Z0-9]+\\s*$`;qbe(new RegExp(i,"g"),"",n),lh(`GL_${e}`,t,n)}var hw=jbe;var mw=`/**
+ * A built-in GLSL floating-point constant for converting radians to degrees.
+ *
+ * @alias czm_degreesPerRadian
+ * @glslConstant
+ *
+ * @see CesiumMath.DEGREES_PER_RADIAN
+ *
+ * @example
+ * // GLSL declaration
+ * const float czm_degreesPerRadian = ...;
+ *
+ * // Example
+ * float deg = czm_degreesPerRadian * rad;
+ */
+const float czm_degreesPerRadian = 57.29577951308232;
+`;var pw=`/**
+ * A built-in GLSL vec2 constant for defining the depth range.
+ * This is a workaround to a bug where IE11 does not implement gl_DepthRange.
+ *
+ * @alias czm_depthRange
+ * @glslConstant
+ *
+ * @example
+ * // GLSL declaration
+ * float depthRangeNear = czm_depthRange.near;
+ * float depthRangeFar = czm_depthRange.far;
+ *
+ */
+const czm_depthRangeStruct czm_depthRange = czm_depthRangeStruct(0.0, 1.0);
+`;var _w=`/**
+ * 0.1
+ *
+ * @name czm_epsilon1
+ * @glslConstant
+ */
+const float czm_epsilon1 = 0.1;
+`;var gw=`/**
+ * 0.01
+ *
+ * @name czm_epsilon2
+ * @glslConstant
+ */
+const float czm_epsilon2 = 0.01;
+`;var yw=`/**
+ * 0.001
+ *
+ * @name czm_epsilon3
+ * @glslConstant
+ */
+const float czm_epsilon3 = 0.001;
+`;var Aw=`/**
+ * 0.0001
+ *
+ * @name czm_epsilon4
+ * @glslConstant
+ */
+const float czm_epsilon4 = 0.0001;
+`;var xw=`/**
+ * 0.00001
+ *
+ * @name czm_epsilon5
+ * @glslConstant
+ */
+const float czm_epsilon5 = 0.00001;
+`;var Cw=`/**
+ * 0.000001
+ *
+ * @name czm_epsilon6
+ * @glslConstant
+ */
+const float czm_epsilon6 = 0.000001;
+`;var Tw=`/**
+ * 0.0000001
+ *
+ * @name czm_epsilon7
+ * @glslConstant
+ */
+const float czm_epsilon7 = 0.0000001;
+`;var Ew=`/**
+ * DOC_TBA
+ *
+ * @name czm_infinity
+ * @glslConstant
+ */
+const float czm_infinity = 5906376272000.0; // Distance from the Sun to Pluto in meters. TODO: What is best given lowp, mediump, and highp?
+`;var bw=`/**
+ * A built-in GLSL floating-point constant for 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 Sw=`/**
+ * 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 ww=`/**
+ * The automatic GLSL constant for {@link Pass#CESIUM_3D_TILE}
+ *
+ * @name czm_passCesium3DTile
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passCesium3DTile = 4.0;
+`;var vw=`/**
+ * 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 Dw=`/**
+ * 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 Pw=`/**
+ * The automatic GLSL constant for {@link Pass#CLASSIFICATION}
+ *
+ * @name czm_passClassification
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passClassification = 7.0;
+`;var Iw=`/**
+ * The automatic GLSL constant for {@link Pass#COMPUTE}
+ *
+ * @name czm_passCompute
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passCompute = 1.0;
+`;var Ow=`/**
+ * The automatic GLSL constant for {@link Pass#ENVIRONMENT}
+ *
+ * @name czm_passEnvironment
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passEnvironment = 0.0;
+`;var Bw=`/**
+ * The automatic GLSL constant for {@link Pass#GLOBE}
+ *
+ * @name czm_passGlobe
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passGlobe = 2.0;
+`;var Rw=`/**
+ * The automatic GLSL constant for {@link Pass#OPAQUE}
+ *
+ * @name czm_passOpaque
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passOpaque = 7.0;
+`;var Mw=`/**
+ * The automatic GLSL constant for {@link Pass#OVERLAY}
+ *
+ * @name czm_passOverlay
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passOverlay = 9.0;
+`;var Lw=`/**
+ * The automatic GLSL constant for {@link Pass#TERRAIN_CLASSIFICATION}
+ *
+ * @name czm_passTerrainClassification
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passTerrainClassification = 3.0;
+`;var Fw=`/**
+ * The automatic GLSL constant for {@link Pass#TRANSLUCENT}
+ *
+ * @name czm_passTranslucent
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passTranslucent = 8.0;
+`;var Nw=`/**
+ * 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 kw=`/**
+ * 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 Vw=`/**
+ * 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 Uw=`/**
+ * 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 zw=`/**
+ * 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 Gw=`/**
+ * 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 Hw=`/**
+ * 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 Ww=`/**
+ * 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 jw=`/**
+ * 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 qw=`/**
+ * 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 Yw=`/**
+ * 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 Xw=`/**
+ * 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 Kw=`/**
+ * 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 Jw=`/**
+ * 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 Zw=`/**
+ * @name czm_depthRangeStruct
+ * @glslStruct
+ */
+struct czm_depthRangeStruct
+{
+ float near;
+ float far;
+};
+`;var Qw=`/**
+ * 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 $w=`/**
+ * 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 ev=`/**
+ * 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 tv=`/**
+ * 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 nv=`/**
+ * 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 iv=`/**
+ * DOC_TBA
+ *
+ * @name czm_ray
+ * @glslStruct
+ */
+struct czm_ray
+{
+ vec3 origin;
+ vec3 direction;
+};
+`;var ov=`/**
+ * 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 rv=`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 sv=`// 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 av=`/**
+ * @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 cv=`/**
+ * 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 lv=`/**
+ * 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 uv=`/**
+ * 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 fv=`/**
+ * 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 dv=`
+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 hv=`
+uniform vec4 shadowMap_cascadeDistances;
+
+float czm_cascadeDistance(vec4 weights)
+{
+ return dot(shadowMap_cascadeDistances, weights);
+}
+`;var mv=`
+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 pv=`
+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 _v=`/**
+ * 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 gv=`/**
+ * 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 yv=`/**
+ * @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 Av=`/**
+ * 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 xv=`/**
+ * 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 Cv=`// emulated noperspective
+#if defined(GL_EXT_frag_depth) && !defined(LOG_DEPTH)
+varying 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
+#ifdef 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 Tv=`/**
+ * 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 coordiantes
+ 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 Ev=`/**
+ * 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 bv=`/**
+ * 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 Sv=`/**
+ * 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 wv=`/**
+ * 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 vv=`/**
+ * 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 Dv=`/**
+ * 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 Pv=`/**
+ * 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 Iv=`/**
+ * 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 Ov=`/**
+ * 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 Bv=`/**
+ * 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 Rv=`/**
+ * 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 Mv=`/**
+ * 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 Lv=`/**
+ * @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 = (texture2D(normalMap, uv0)) +
+ (texture2D(normalMap, uv1)) +
+ (texture2D(normalMap, uv2)) +
+ (texture2D(normalMap, uv3));
+
+ // average and scale to between -1 and 1
+ return ((noise / 4.0) - 0.5) * 2.0;
+}
+`;var Fv=`/**
+ * 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 Nv=`/**
+ * 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 kv=`/**
+ * 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 Vv=`/**
+ * 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 Uv=`/**
+ * 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 zv=`/**
+ * 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 Gv=`/**
+ * 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 Hv=`/**
+ * 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 Wv=`/**
+ * 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 jv=`/**
+ * 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 qv=`/**
+ * 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 Yv=`/**
+ * 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 Xv=`/**
+ * 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 Kv=`/**
+ * 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 Jv=` /**
+ * 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 Zv=`/**
+ * 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 Qv=`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 $v=`/**
+ * 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 eD=`/**
+ * 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 tD=`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 = // ...
+ * gl_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 nD=`/**
+ * 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 iD=`/**
+ * 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 oD=`/**
+ * 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 rD=`/**
+ * 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 sD=`float czm_readDepth(sampler2D depthTexture, vec2 texCoords)
+{
+ return czm_reverseLogDepth(texture2D(depthTexture, texCoords).r);
+}
+`;var aD=`/**
+ * 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 cD=`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 lD=`/**
+ * 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 uD=`/**
+ * 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 fD=`/**
+ * 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 dD=`/**
+ * 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 hD=`/**
+ * 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 = texture2D(projectedMap, coord + vec2(0.0, pixel.y)).rgb;
+ vec3 color2 = texture2D(projectedMap, coord + vec2(pixel.x, 0.0)).rgb;
+ vec3 color3 = texture2D(projectedMap, coord + pixel).rgb;
+ vec3 color4 = texture2D(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 = texture2D(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 mD=`/**
+ * 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 pD=`
+float czm_sampleShadowMap(highp samplerCube shadowMap, vec3 d)
+{
+ return czm_unpackDepth(textureCube(shadowMap, d));
+}
+
+float czm_sampleShadowMap(highp sampler2D shadowMap, vec2 uv)
+{
+#ifdef USE_SHADOW_DEPTH_TEXTURE
+ return texture2D(shadowMap, uv).r;
+#else
+ return czm_unpackDepth(texture2D(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 _D=`
+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 gD=`/**
+ * 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 yD=`/**
+ * 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 AD=`/**
+ * 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 xD=`/**
+ * 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 * texture2D(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 CD=`/**
+ * 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 TD=`/**
+ * 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
+ * attribute vec3 positionHigh;
+ * attribute 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 ED=`/**
+ * @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 bD=`/**
+ * 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 SD=`/**
+ * 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 wD=`/**
+ * 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 vD=`/**
+ * 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 DD=`/**
+ * 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 PD=`#ifdef LOG_DEPTH
+// 1.0 at the near plane, increasing linearly from there.
+varying float v_depthFromNearPlusOne;
+#ifdef SHADOW_MAP
+varying 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 ID=`/**
+ * 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)
+{
+ // Reconstruct NDC coordinates
+ float x = 2.0 * (fragmentCoordinate.x - czm_viewport.x) / czm_viewport.z - 1.0;
+ float y = 2.0 * (fragmentCoordinate.y - czm_viewport.y) / czm_viewport.w - 1.0;
+ float z = (fragmentCoordinate.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 /= fragmentCoordinate.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 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)
+{
+ // See reverseLogDepth.glsl. This is separate to re-use the pow.
+#ifdef LOG_DEPTH
+ 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 windowCoord = vec4(fragmentCoordinateXY, far * (1.0 - near / depthFromCamera) / (far - near), 1.0);
+ vec4 eyeCoordinate = czm_windowToEyeCoordinates(windowCoord);
+ eyeCoordinate.w = 1.0 / depthFromCamera; // Better precision
+ return eyeCoordinate;
+#else
+ vec4 windowCoord = vec4(fragmentCoordinateXY, depthOrLogDepth, 1.0);
+ vec4 eyeCoordinate = czm_windowToEyeCoordinates(windowCoord);
+#endif
+ return eyeCoordinate;
+}
+`;var OD=`// emulated noperspective
+#if defined(GL_EXT_frag_depth) && !defined(LOG_DEPTH)
+varying 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.
+ *
+ * The shader must enable the GL_EXT_frag_depth extension.
+ *
+ *
+ * @name czm_writeDepthClamp
+ * @glslFunction
+ *
+ * @example
+ * gl_FragColor = color;
+ * czm_writeDepthClamp();
+ *
+ * @see czm_depthClamp
+ */
+void czm_writeDepthClamp()
+{
+#if defined(GL_EXT_frag_depth) && !defined(LOG_DEPTH)
+ gl_FragDepthEXT = clamp(v_WindowZ * gl_FragCoord.w, 0.0, 1.0);
+#endif
+}
+`;var BD=`#ifdef LOG_DEPTH
+varying float v_depthFromNearPlusOne;
+
+#ifdef POLYGON_OFFSET
+uniform vec2 u_polygonOffset;
+#ifdef GL_OES_standard_derivatives
+#extension GL_OES_standard_derivatives : enable
+#endif
+#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(GL_EXT_frag_depth) && defined(LOG_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 we can't compute derivatives, just leave out the factor I guess?
+#ifdef GL_OES_standard_derivatives
+ 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_FragDepthEXT = log2(depth) * czm_oneOverLog2FarDepthFromNearPlusOne;
+
+#ifdef POLYGON_OFFSET
+ // Apply the units after the log depth.
+ gl_FragDepthEXT += 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 RD=`/**
+ * 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 MD=`/**
+ * 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 t0={czm_degreesPerRadian:mw,czm_depthRange:pw,czm_epsilon1:_w,czm_epsilon2:gw,czm_epsilon3:yw,czm_epsilon4:Aw,czm_epsilon5:xw,czm_epsilon6:Cw,czm_epsilon7:Tw,czm_infinity:Ew,czm_oneOverPi:bw,czm_oneOverTwoPi:Sw,czm_passCesium3DTile:ww,czm_passCesium3DTileClassification:vw,czm_passCesium3DTileClassificationIgnoreShow:Dw,czm_passClassification:Pw,czm_passCompute:Iw,czm_passEnvironment:Ow,czm_passGlobe:Bw,czm_passOpaque:Rw,czm_passOverlay:Mw,czm_passTerrainClassification:Lw,czm_passTranslucent:Fw,czm_pi:Nw,czm_piOverFour:kw,czm_piOverSix:Vw,czm_piOverThree:Uw,czm_piOverTwo:zw,czm_radiansPerDegree:Gw,czm_sceneMode2D:Hw,czm_sceneMode3D:Ww,czm_sceneModeColumbusView:jw,czm_sceneModeMorphing:qw,czm_solarRadius:Yw,czm_threePiOver2:Xw,czm_twoPi:Kw,czm_webMercatorMaxLatitude:Jw,czm_depthRangeStruct:Zw,czm_material:Qw,czm_materialInput:$w,czm_modelMaterial:ev,czm_modelVertexOutput:tv,czm_pbrParameters:nv,czm_ray:iv,czm_raySegment:ov,czm_shadowParameters:rv,czm_acesTonemapping:sv,czm_alphaWeight:av,czm_antialias:cv,czm_approximateSphericalCoordinates:lv,czm_backFacing:uv,czm_branchFreeTernary:fv,czm_cascadeColor:dv,czm_cascadeDistance:hv,czm_cascadeMatrix:mv,czm_cascadeWeights:pv,czm_columbusViewMorph:_v,czm_computePosition:gv,czm_cosineAndSine:yv,czm_decompressTextureCoordinates:Av,czm_defaultPbrMaterial:xv,czm_depthClamp:Cv,czm_eastNorthUpToEyeCoordinates:Tv,czm_ellipsoidContainsPoint:Ev,czm_ellipsoidWgs84TextureCoordinates:bv,czm_equalsEpsilon:Sv,czm_eyeOffset:wv,czm_eyeToWindowCoordinates:vv,czm_fastApproximateAtan:Dv,czm_fog:Pv,czm_gammaCorrect:Iv,czm_geodeticSurfaceNormal:Ov,czm_getDefaultMaterial:Bv,czm_getLambertDiffuse:Rv,czm_getSpecular:Mv,czm_getWaterNoise:Lv,czm_HSBToRGB:Fv,czm_HSLToRGB:Nv,czm_hue:kv,czm_inverseGamma:Vv,czm_isEmpty:Uv,czm_isFull:zv,czm_latitudeToWebMercatorFraction:Gv,czm_linearToSrgb:Hv,czm_lineDistance:Wv,czm_luminance:jv,czm_metersPerPixel:qv,czm_modelToWindowCoordinates:Yv,czm_multiplyWithColorBalance:Xv,czm_nearFarScalar:Kv,czm_octDecode:Jv,czm_packDepth:Zv,czm_pbrLighting:Qv,czm_pbrMetallicRoughnessMaterial:$v,czm_pbrSpecularGlossinessMaterial:eD,czm_phong:tD,czm_planeDistance:nD,czm_pointAlongRay:iD,czm_rayEllipsoidIntersectionInterval:oD,czm_raySphereIntersectionInterval:rD,czm_readDepth:sD,czm_readNonPerspective:aD,czm_reverseLogDepth:cD,czm_RGBToHSB:lD,czm_RGBToHSL:uD,czm_RGBToXYZ:fD,czm_round:dD,czm_sampleOctahedralProjection:hD,czm_saturation:mD,czm_shadowDepthCompare:pD,czm_shadowVisibility:_D,czm_signNotZero:gD,czm_sphericalHarmonics:yD,czm_srgbToLinear:AD,czm_tangentToEyeSpaceMatrix:xD,czm_transformPlane:CD,czm_translateRelativeToEye:TD,czm_translucentPhong:ED,czm_transpose:bD,czm_unpackDepth:SD,czm_unpackFloat:wD,czm_unpackUint:vD,czm_valueTransform:DD,czm_vertexLogDepth:PD,czm_windowToEyeCoordinates:ID,czm_writeDepthClamp:OD,czm_writeLogDepth:BD,czm_writeNonPerspective:RD,czm_XYZToRGB:MD};function yZ(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 CZ(e,t,n){let i,o,r="",s=e.sources;if(u(s))for(i=0,o=s.length;i 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 B_=`#ifdef GL_EXT_frag_depth
+#extension GL_EXT_frag_depth : enable
+#endif
+
+#ifdef VECTOR_TILE
+uniform vec4 u_highlightColor;
+#endif
+
+void main(void)
+{
+#ifdef VECTOR_TILE
+ gl_FragColor = czm_gammaCorrect(u_highlightColor);
+#else
+ gl_FragColor = vec4(1.0);
+#endif
+ czm_writeDepthClamp();
+}
+`;var bZ={TERRAIN:0,CESIUM_3D_TILE:1,BOTH:2};bZ.NUMBER_OF_CLASSIFICATION_TYPES=3;var Fn=Object.freeze(bZ);var tSe={NEVER:te.NEVER,LESS:te.LESS,EQUAL:te.EQUAL,LESS_OR_EQUAL:te.LEQUAL,GREATER:te.GREATER,NOT_EQUAL:te.NOTEQUAL,GREATER_OR_EQUAL:te.GEQUAL,ALWAYS:te.ALWAYS},Da=Object.freeze(tSe);function uh(){this.high=h.clone(h.ZERO),this.low=h.clone(h.ZERO)}uh.encode=function(e,t){u(t)||(t={high:0,low:0});let n;return e>=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 bm={high:0,low:0};uh.fromCartesian=function(e,t){u(t)||(t=new uh);let n=t.high,i=t.low;return uh.encode(e.x,bm),n.x=bm.high,i.x=bm.low,uh.encode(e.y,bm),n.y=bm.high,i.y=bm.low,uh.encode(e.z,bm),n.z=bm.high,i.z=bm.low,t};var uH=new uh;uh.writeElements=function(e,t,n){uh.fromCartesian(e,uH);let i=uH.high,o=uH.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 Vn=uh;function nSe(e,t){let n=[],i=e.length,o=0;for(;o=I.SIXTY_FOUR_KILOBYTES?new Uint32Array(t):new Uint16Array(t)};us.createTypedArrayFromArrayBuffer=function(e,t,n,i){return e>=I.SIXTY_FOUR_KILOBYTES?new Uint32Array(t,n,i):new Uint16Array(t,n,i)};us.fromTypedArray=function(e){if(e instanceof Uint8Array)return us.UNSIGNED_BYTE;if(e instanceof Uint16Array)return us.UNSIGNED_SHORT;if(e instanceof Uint32Array)return us.UNSIGNED_INT};var Fe=Object.freeze(us);function Su(e){e=y(e,y.EMPTY_OBJECT);let t=e.context._gl,n=e.bufferTarget,i=e.typedArray,o=e.sizeInBytes,r=e.usage,s=u(i);s&&(o=i.byteLength);let a=t.createBuffer();t.bindBuffer(n,a),t.bufferData(n,s?i:o,r),t.bindBuffer(n,null),this._id=kn(),this._gl=t,this._webgl2=e.context._webgl2,this._bufferTarget=n,this._sizeInBytes=o,this._usage=r,this._buffer=a,this.vertexArrayDestroyable=!0}Su.createVertexBuffer=function(e){return new Su({context:e.context,bufferTarget:te.ARRAY_BUFFER,typedArray:e.typedArray,sizeInBytes:e.sizeInBytes,usage:e.usage})};Su.createIndexBuffer=function(e){let t=e.context,n=e.indexDatatype,i=Fe.getSizeInBytes(n),o=new Su({context:t,bufferTarget:te.ELEMENT_ARRAY_BUFFER,typedArray:e.typedArray,sizeInBytes:e.sizeInBytes,usage:e.usage}),r=o.sizeInBytes/i;return Object.defineProperties(o,{indexDatatype:{get:function(){return n}},bytesPerIndex:{get:function(){return i}},numberOfIndices:{get:function(){return r}}}),o};Object.defineProperties(Su.prototype,{sizeInBytes:{get:function(){return this._sizeInBytes}},usage:{get:function(){return this._usage}}});Su.prototype._getBuffer=function(){return this._buffer};Su.prototype.copyFromArrayView=function(e,t){t=y(t,0);let n=this._gl,i=this._bufferTarget;n.bindBuffer(i,this._buffer),n.bufferSubData(i,t,e),n.bindBuffer(i,null)};Su.prototype.copyFromBuffer=function(e,t,n,i){let o=te.COPY_READ_BUFFER,r=te.COPY_WRITE_BUFFER,s=this._gl;s.bindBuffer(r,this._buffer),s.bindBuffer(o,e._buffer),s.copyBufferSubData(o,r,t,n,i),s.bindBuffer(r,null),s.bindBuffer(o,null)};Su.prototype.getBufferData=function(e,t,n,i){t=y(t,0),n=y(n,0);let o=this._gl,r=te.COPY_READ_BUFFER;o.bindBuffer(r,this._buffer),o.getBufferSubData(r,t,e,n,i),o.bindBuffer(r,null)};Su.prototype.isDestroyed=function(){return!1};Su.prototype.destroy=function(){return this._gl.deleteBuffer(this._buffer),le(this)};var st=Su;function iSe(e,t,n,i){let o=u(t.vertexBuffer),r=u(t.value),s=t.value?t.value.length:t.componentsPerAttribute,a={index:y(t.index,n),enabled:y(t.enabled,!0),vertexBuffer:t.vertexBuffer,value:r?t.value.slice(0):void 0,componentsPerAttribute:s,componentDatatype:y(t.componentDatatype,K.FLOAT),normalize:y(t.normalize,!1),offsetInBytes:y(t.offsetInBytes,0),strideInBytes:y(t.strideInBytes,0),instanceDivisor:y(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 wZ(e,t,n){for(let i=0;i0&&(c=!0),u(s[r].value)&&(l=!0);let d;t.vertexArrayObject&&(d=t.glCreateVertexArray(),t.glBindVertexArray(d),wZ(n,s,o),t.glBindVertexArray(null)),this._numberOfVertices=a,this._hasInstancedAttributes=c,this._hasConstantAttributes=l,this._context=t,this._gl=n,this._vao=d,this._attributes=s,this._indexBuffer=o}function SZ(e){return e.values.length/e.componentsPerAttribute}function oSe(e){return K.getSizeInBytes(e.componentDatatype)*e.componentsPerAttribute}function rSe(e){let t,n,i,o=[];for(n in e)e.hasOwnProperty(n)&&u(e[n])&&u(e[n].values)&&(o.push(n),e[n].componentDatatype===K.DOUBLE&&(e[n].componentDatatype=K.FLOAT,e[n].values=K.createTypedArray(K.FLOAT,e[n].values)));let r,s=o.length;if(s>0)for(r=SZ(e[o[0]]),t=1;t0){let l=K.getSizeInBytes(e[o[0]].componentDatatype),f=a%l;f!==0&&(a+=l-f);let d=r*a,p=new ArrayBuffer(d),g={};for(t=0;t=I.SIXTY_FOUR_KILOBYTES&&t.elementIndexUint?p=st.createIndexBuffer({context:t,typedArray:new Uint32Array(g),usage:i,indexDatatype:Fe.UNSIGNED_INT}):p=st.createIndexBuffer({context:t,typedArray:new Uint16Array(g),usage:i,indexDatatype:Fe.UNSIGNED_SHORT})),new Sm({context:t,attributes:f,indexBuffer:p})};Object.defineProperties(Sm.prototype,{numberOfAttributes:{get:function(){return this._attributes.length}},numberOfVertices:{get:function(){return this._numberOfVertices}},indexBuffer:{get:function(){return this._indexBuffer}}});Sm.prototype.getAttribute=function(e){return this._attributes[e]};function sSe(e){let t=e._context,n=e._hasInstancedAttributes;if(!n&&!t._previousDrawInstanced)return;t._previousDrawInstanced=n;let i=t._vertexAttribDivisors,o=e._attributes,r=Nt.maximumVertexAttributes,s;if(n){let a=o.length;for(s=0;s0&&(t.glVertexAttribDivisor(s,0),i[s]=0)}function aSe(e,t){let n=e._attributes,i=n.length;for(let o=0;o>1^-(e&1)}mo.zigZagDeltaDecode=function(e,t,n){let i=e.length,o=0,r=0,s=0;for(let a=0;a>11,f=c>>5&o,d=c&i,p=3*a;t[p]=l*r,t[p+1]=f*s,t[p+2]=d*r}return t};var Un=mo;var BZ=new h,RZ=new h,MZ=new h;function CSe(e,t,n,i,o){u(o)||(o=new h);let r,s,a,c,l,f,d,p;if(u(t.z)){if(h.equalsEpsilon(e,t,I.EPSILON14))return h.clone(h.UNIT_X,o);if(h.equalsEpsilon(e,n,I.EPSILON14))return h.clone(h.UNIT_Y,o);if(h.equalsEpsilon(e,i,I.EPSILON14))return h.clone(h.UNIT_Z,o);r=h.subtract(n,t,BZ),s=h.subtract(i,t,RZ),a=h.subtract(e,t,MZ),c=h.dot(r,r),l=h.dot(r,s),f=h.dot(r,a),d=h.dot(s,s),p=h.dot(s,a)}else{if(H.equalsEpsilon(e,t,I.EPSILON14))return h.clone(h.UNIT_X,o);if(H.equalsEpsilon(e,n,I.EPSILON14))return h.clone(h.UNIT_Y,o);if(H.equalsEpsilon(e,i,I.EPSILON14))return h.clone(h.UNIT_Z,o);r=H.subtract(n,t,BZ),s=H.subtract(i,t,RZ),a=H.subtract(e,t,MZ),c=H.dot(r,r),l=H.dot(r,s),f=H.dot(r,a),d=H.dot(s,s),p=H.dot(s,a)}o.y=d*f-l*p,o.z=c*p-l*f;let g=c*d-l*l;if(g!==0)return o.y/=g,o.z/=g,o.x=1-o.y-o.z,o}var i0=CSe;var hH={};hH.calculateACMR=function(e){e=y(e,y.EMPTY_OBJECT);let t=e.indices,n=e.maximumIndex,i=y(e.cacheSize,24),o=t.length;if(!u(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)};hH.tipsify=function(e){e=y(e,y.EMPTY_OBJECT);let t=e.indices,n=e.maximumIndex,i=y(e.cacheSize,24),o;function r(_,E,w,D){for(;E.length>=1;){let B=E[E.length-1];if(E.splice(E.length-1,1),_[B].numLiveTriangles>0)return B}for(;o0)return++o,o-1;++o}return-1}function s(_,E,w,D,B,N,U){let V=-1,G,k=-1,Y=0;for(;Yk||k===-1)&&(k=G,V=q)),++Y}return V===-1?r(D,N,_,U):V}let a=t.length,c=0,l=0,f=t[l],d=a;if(u(n))c=n+1;else{for(;lc&&(c=f),++l,f=t[l];if(c===-1)return 0;++c}let p=[],g;for(g=0;gi&&(b.timeStamp=x,++x),++l}A=s(t,i,C,p,x,T,c)}return P};var VD=hH;var dc={};function n3(e,t,n,i,o){e[t++]=n,e[t++]=i,e[t++]=i,e[t++]=o,e[t++]=o,e[t]=n}function TSe(e){let t=e.length,n=t/3*6,i=Fe.createTypedArray(t,n),o=0;for(let r=0;r=3){let n=(t-2)*6,i=Fe.createTypedArray(t,n);n3(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=Fe.createTypedArray(t,n),o=e[0],r=0;for(let s=1;so&&(o=n[r]);e.indices=VD.tipsify({indices:n,maximumIndex:o,cacheSize:t})}return e};function LZ(e){let t={};for(let n in e)if(e.hasOwnProperty(n)&&u(e[n])&&u(e[n].values)){let i=e[n];t[n]=new Se({componentDatatype:i.componentDatatype,componentsPerAttribute:i.componentsPerAttribute,normalize:i.normalize,values:[]})}return t}function SSe(e,t,n){for(let i in t)if(t.hasOwnProperty(i)&&u(t[i])&&u(t[i].values)){let o=t[i];for(let r=0;r=I.SIXTY_FOUR_KILOBYTES){let i=[],o=[],r=0,s=LZ(e.attributes),a=e.indices,c=a.length,l;e.primitiveType===Re.TRIANGLES?l=3:e.primitiveType===Re.LINES?l=2:e.primitiveType===Re.POINTS&&(l=1);for(let f=0;f=I.SIXTY_FOUR_KILOBYTES&&(t.push(new rt({attributes:s,indices:o,primitiveType:e.primitiveType,boundingSphere:e.boundingSphere,boundingSphereCV:e.boundingSphereCV})),i=[],o=[],r=0,s=LZ(e.attributes))}o.length!==0&&t.push(new rt({attributes:s,indices:o,primitiveType:e.primitiveType,boundingSphere:e.boundingSphere,boundingSphereCV:e.boundingSphereCV}))}else t.push(e);return t};var FZ=new h,wSe=new fe;dc.projectTo2D=function(e,t,n,i,o){let r=e.attributes[t];o=u(o)?o:new pi;let s=o.ellipsoid,a=r.values,c=new Float64Array(a.length),l=0;for(let f=0;fx&&(x=T)}return new rt({attributes:f,indices:m,primitiveType:l,boundingSphere:u(A)?new re(A,x):void 0})}dc.combineInstances=function(e){let t=[],n=[],i=e.length;for(let r=0;r0&&o.push(gH(t,"geometry")),n.length>0&&(o.push(gH(n,"westHemisphereGeometry")),o.push(gH(n,"eastHemisphereGeometry"))),o};var wu=new h,UD=new h,bC=new h,SC=new h;dc.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(f=0;f3&&(n[3]=0,n[4]=2,n[5]=3);let i=6;for(let o=3;oo?i>r?s=I.sign(e.y):s=I.sign(n.y):o>r?s=I.sign(t.y):s=I.sign(n.y);let a=s<0;R_(e,a),R_(t,a),R_(n,a)}var UZ=new h;function vu(e,t,n,i){h.add(e,h.multiplyByScalar(h.subtract(t,e,UZ),e.y/(e.y-t.y),UZ),n),h.clone(n,i),R_(n,!0),R_(i,!1)}var o0=new h,r0=new h,s0=new h,a0=new h,yH={positions:new Array(7),indices:new Array(3*3)};function VSe(e,t,n){if(e.x>=0||t.x>=0||n.x>=0)return;kSe(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=yH.indices;s===1?(a[1]=3,a[2]=4,a[5]=6,a[7]=6,a[8]=5,i?(vu(e,t,o0,s0),vu(e,n,r0,a0),a[0]=0,a[3]=1,a[4]=2,a[6]=1):o?(vu(t,n,o0,s0),vu(t,e,r0,a0),a[0]=1,a[3]=2,a[4]=0,a[6]=2):r&&(vu(n,e,o0,s0),vu(n,t,r0,a0),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||(vu(n,e,o0,s0),vu(n,t,r0,a0),a[0]=0,a[1]=1,a[3]=0,a[6]=2):(vu(t,n,o0,s0),vu(t,e,r0,a0),a[0]=2,a[1]=0,a[3]=2,a[6]=1):(vu(e,t,o0,s0),vu(e,n,r0,a0),a[0]=1,a[1]=2,a[3]=1,a[6]=0));let c=yH.positions;return c[0]=e,c[1]=t,c[2]=n,c.length=3,(s===1||s===2)&&(c[3]=o0,c[4]=r0,c[5]=s0,c[6]=a0,c.length=7),yH}function zZ(e,t){let n=e.attributes;if(n.position.values.length===0)return;for(let o in n)if(n.hasOwnProperty(o)&&u(n[o])&&u(n[o].values)){let r=n[o];r.values=K.createTypedArray(r.componentDatatype,r.values)}let i=rt.computeNumberOfVertices(e);return e.indices=Fe.createTypedArray(i,e.indices),t&&(e.boundingSphere=re.fromVertices(n.position.values)),e}function vC(e){let t=e.attributes,n={};for(let i in t)if(t.hasOwnProperty(i)&&u(t[i])&&u(t[i].values)){let o=t[i];n[i]=new Se({componentDatatype:o.componentDatatype,componentsPerAttribute:o.componentsPerAttribute,normalize:o.normalize,values:[]})}return new rt({attributes:n,indices:[],primitiveType:e.primitiveType})}function TH(e,t,n){let i=u(e.geometry.boundingSphere);t=zZ(t,i),n=zZ(n,i),u(n)&&!u(t)?e.geometry=n:!u(n)&&u(t)?e.geometry=t:(e.westHemisphereGeometry=t,e.eastHemisphereGeometry=n,e.geometry=void 0)}function EH(e,t){let n=new e,i=new e,o=new e;return function(r,s,a,c,l,f,d,p){let g=e.fromArray(l,r*t,n),m=e.fromArray(l,s*t,i),A=e.fromArray(l,a*t,o);e.multiplyByScalar(g,c.x,g),e.multiplyByScalar(m,c.y,m),e.multiplyByScalar(A,c.z,A);let x=e.add(g,m,g);e.add(x,A,x),p&&e.normalize(x,x),e.pack(x,f,d*t)}}var USe=EH(se,4),t3=EH(h,3),YZ=EH(H,2),zSe=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>I.EPSILON6?1:0},GD=new h,AH=new h,xH=new h,GSe=new h;function $2(e,t,n,i,o,r,s,a,c,l,f,d,p,g,m,A){if(!u(r)&&!u(s)&&!u(a)&&!u(c)&&!u(l)&&g===0)return;let x=h.fromArray(o,e*3,GD),C=h.fromArray(o,t*3,AH),T=h.fromArray(o,n*3,xH),b=i0(i,x,C,T,GSe);if(!!u(b)){if(u(r)&&t3(e,t,n,b,r,d.normal.values,A,!0),u(l)){let S=h.fromArray(l,e*3,GD),v=h.fromArray(l,t*3,AH),P=h.fromArray(l,n*3,xH);h.multiplyByScalar(S,b.x,S),h.multiplyByScalar(v,b.y,v),h.multiplyByScalar(P,b.z,P);let O;!h.equals(S,h.ZERO)||!h.equals(v,h.ZERO)||!h.equals(P,h.ZERO)?(O=h.add(S,v,S),h.add(O,P,O),h.normalize(O,O)):(O=GD,O.x=0,O.y=0,O.z=0),h.pack(O,d.extrudeDirection.values,A*3)}if(u(f)&&zSe(e,t,n,b,f,d.applyOffset.values,A),u(s)&&t3(e,t,n,b,s,d.tangent.values,A,!0),u(a)&&t3(e,t,n,b,a,d.bitangent.values,A,!0),u(c)&&YZ(e,t,n,b,c,d.st.values,A),g>0)for(let S=0;S3){let D=w.positions,B=w.indices,N=B.length;for(let U=0;U0)continue;let c=h.unpack(i,s,JZ);(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,CH);(a.y<0&&l.y>0||a.y>0&&l.y<0)&&(s+30||re.intersectPlane(n,nn.ORIGIN_ZX_PLANE)!==Kt.INTERSECTING))return e;if(t.geometryType!==bu.NONE)switch(t.geometryType){case bu.POLYLINES:QSe(e);break;case bu.TRIANGLES:GZ(e);break;case bu.LINES:HZ(e);break}else NSe(t),t.primitiveType===Re.TRIANGLES?GZ(e):t.primitiveType===Re.LINES&&HZ(e);return e};var Bn=dc;function Qc(e){this._ellipsoid=y(e,ie.WGS84),this._semimajorAxis=this._ellipsoid.maximumRadius,this._oneOverSemimajorAxis=1/this._semimajorAxis}Object.defineProperties(Qc.prototype,{ellipsoid:{get:function(){return this._ellipsoid}}});Qc.mercatorAngleToGeodeticLatitude=function(e){return I.PI_OVER_TWO-2*Math.atan(Math.exp(-e))};Qc.geodeticLatitudeToMercatorAngle=function(e){e>Qc.MaximumLatitude?e=Qc.MaximumLatitude:e<-Qc.MaximumLatitude&&(e=-Qc.MaximumLatitude);let t=Math.sin(e);return .5*Math.log((1+t)/(1-t))};Qc.MaximumLatitude=Qc.mercatorAngleToGeodeticLatitude(Math.PI);Qc.prototype.project=function(e,t){let n=this._semimajorAxis,i=e.longitude*n,o=Qc.geodeticLatitudeToMercatorAngle(e.latitude)*n,r=e.height;return u(t)?(t.x=i,t.y=o,t.z=r,t):new h(i,o,r)};Qc.prototype.unproject=function(e,t){let n=this._oneOverSemimajorAxis,i=e.x*n,o=Qc.mercatorAngleToGeodeticLatitude(e.y*n),r=e.z;return u(t)?(t.longitude=i,t.latitude=o,t.height=r,t):new fe(i,o,r)};var yi=Qc;function $Se(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 nwe(e,t){let n=[];return SH(e,"geometry",t,n),SH(e,"westHemisphereGeometry",t,n),SH(e,"eastHemisphereGeometry",t,n),n}var vm={};vm.combineGeometry=function(e){let t,n,i=e.instances,o=i.length,r,s,a=!1;o>0&&(t=twe(e),t.length>0&&(n=Bn.createAttributeLocations(t[0]),e.createPickOffsets&&(r=nwe(i,t))),u(i[0].attributes)&&u(i[0].attributes.offset)&&(s=new Array(o),a=!0));let c=new Array(o),l=new Array(o);for(let f=0;f0&&(n.set(c.indices,s),s+=m)}return t.push(n.buffer),{stringTable:i,packedData:n}};vm.unpackCreateGeometryResults=function(e){let t=e.stringTable,n=e.packedData,i,o=new Array(n[0]),r=0,s=1;for(;s0){let v=x.length/C;for(S=Fe.createTypedArray(v,A),i=0;i{t._completeLoad=(o,r,s)=>{this._error=s,this._state=r,o.afterRender.push(function(){if(t._ready=t._state===sr.COMPLETE||t._state===sr.FAILED,!u(s))return n(t),!0;i(s)})}}),this._batchTable=void 0,this._batchTableAttributeIndices=void 0,this._offsetInstanceExtend=void 0,this._batchTableOffsetAttribute2DIndex=void 0,this._batchTableOffsetsUpdated=!1,this._instanceBoundingSpheres=void 0,this._instanceBoundingSpheresCV=void 0,this._tempBoundingSpheres=void 0,this._recomputeBoundingSpheres=!1,this._batchTableBoundingSpheresUpdated=!1,this._batchTableBoundingSphereAttributeIndices=void 0}Object.defineProperties(ar.prototype,{vertexCacheOptimize:{get:function(){return this._vertexCacheOptimize}},interleave:{get:function(){return this._interleave}},releaseGeometryInstances:{get:function(){return this._releaseGeometryInstances}},allowPicking:{get:function(){return this._allowPicking}},asynchronous:{get:function(){return this._asynchronous}},compressVertices:{get:function(){return this._compressVertices}},ready:{get:function(){return this._ready}},readyPromise:{get:function(){return this._readyPromise}}});function lwe(e){let t=e.length,n=[],i=e[0].attributes,o;for(o in i)if(i.hasOwnProperty(o)&&u(i[o])){let r=i[o],s=!0;for(let a=1;a= nearSq && distanceSq <= farSq) ? 1.0 : 0.0;
+ gl_Position *= show;
+}`,`${i}
+${o}`};function tQ(e,t){if(!e.compressVertices)return t;let n=t.search(/attribute\s+vec3\s+normal;/g)!==-1,i=t.search(/attribute\s+vec2\s+st;/g)!==-1;if(!n&&!i)return t;let o=t.search(/attribute\s+vec3\s+tangent;/g)!==-1,r=t.search(/attribute\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=`attribute ${a} ${c};`,f="",d="";if(i){f+=`vec2 st;
+`;let m=s>1?`${c}.x`:c;d+=` st = czm_decompressTextureCoordinates(${m});
+`}n&&o&&r?(f+=`vec3 normal;
+vec3 tangent;
+vec3 bitangent;
+`,d+=` czm_octDecode(${c}.${i?"yz":"xy"}, normal, tangent, bitangent);
+`):(n&&(f+=`vec3 normal;
+`,d+=` normal = czm_octDecode(${c}${s>1?`.${i?"y":"x"}`:""});
+`),o&&(f+=`vec3 tangent;
+`,d+=` tangent = czm_octDecode(${c}.${i&&n?"z":"y"});
+`),r&&(f+=`vec3 bitangent;
+`,d+=` bitangent = czm_octDecode(${c}.${i&&n?"z":"y"});
+`));let p=t;p=p.replace(/attribute\s+vec3\s+normal;/g,""),p=p.replace(/attribute\s+vec2\s+st;/g,""),p=p.replace(/attribute\s+vec3\s+tangent;/g,""),p=p.replace(/attribute\s+vec3\s+bitangent;/g,""),p=Ue.replaceMain(p,"czm_non_compressed_main");let g=`void main()
+{
+${d} czm_non_compressed_main();
+}`;return[l,f,p,g].join(`
+`)}function gwe(e){let t=Ue.replaceMain(e,"czm_non_depth_clamp_main");return t+=`void main() {
+ czm_non_depth_clamp_main();
+ gl_Position = czm_depthClamp(gl_Position);}
+`,t}function ywe(e){let t=Ue.replaceMain(e,"czm_non_depth_clamp_main");return t+=`void main() {
+ czm_non_depth_clamp_main();
+#if defined(GL_EXT_frag_depth)
+ #if defined(LOG_DEPTH)
+ czm_writeLogDepth();
+ #else
+ czm_writeDepthClamp();
+ #endif
+#endif
+}
+`,t=`#ifdef GL_EXT_frag_depth
+#extension GL_EXT_frag_depth : enable
+#endif
+${t}`,t}function nQ(e,t){let n=e.vertexAttributes}function Awe(e,t){return function(){return e[t]}}var wH=Math.max(Mt.hardwareConcurrency-1,1),o3,xwe=new ci("combineGeometry");function Cwe(e,t){let n,i,o,r,s=e._instanceIds;if(e._state===sr.READY){n=Array.isArray(e.geometryInstances)?e.geometryInstances:[e.geometryInstances];let a=e._numberOfInstances=n.length,c=[],l=[];for(o=0;o0){let A=new Float64Array(d);for(m=[A.buffer],r=0;r0?(e._recomputeBoundingSpheres=!0,e._state=sr.COMBINED):WD(e,t,sr.FAILED,void 0)}).catch(function(d){WD(e,t,sr.FAILED,d)})}}function Twe(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=sr.COMBINED):WD(e,t,sr.FAILED,void 0)}function Ewe(e,t){let n=e._batchTableAttributeIndices.offset;if(!e._recomputeBoundingSpheres||!u(n)){e._recomputeBoundingSpheres=!1;return}let i,o=e._offsetInstanceExtend,r=e._instanceBoundingSpheres,s=r.length,a=e._tempBoundingSpheres;if(!u(a)){for(a=new Array(s),i=0;i0||re.intersectPlane(A,nn.ORIGIN_ZX_PLANE)!==Kt.INTERSECTING?c.push(A):(l.push(A),f.push(A))}let d=c[0],p=f[0],g=l[0];for(i=1;i0){if(Nt.maximumVertexTextureImageUnits===0)throw new de("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!==sr.COMPLETE&&this._state!==sr.COMBINED&&(this.asynchronous?Cwe(this,e):Twe(this,e)),this._state===sr.COMBINED&&(bwe(this,e),oQ(this,e),wwe(this,e)),!this.show||this._state!==sr.COMPLETE)return;this._batchTableOffsetsUpdated||oQ(this,e),this._recomputeBoundingSpheres&&Ewe(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=u(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),u(this._material)&&this._material.update(t);let l=n.closed&&c;o&&y(this._createRenderStatesFunction,vwe)(this,t,n,l),r&&y(this._createShaderProgramFunction,Dwe)(this,e,n),(o||r)&&y(this._createCommandsFunction,Pwe)(this,n,i,c,l,this._colorCommands,this._pickCommands,e),y(this._updateAndQueueCommandsFunction,Iwe)(this,e,this._colorCommands,this._pickCommands,this.modelMatrix,this.cull,this.debugShowBoundingVolume,l)};var Owe=new re,Bwe=new re;function dQ(e,t,n){if(n===Qt.TOP){let i=re.clone(e,Owe),o=re.clone(e,Bwe);o.center=h.add(o.center,t,o.center),e=re.union(i,o,e)}else n===Qt.ALL&&(e.center=h.add(e.center,t,e.center));return e}function Rwe(e,t,n){return function(){let i=e.getBatchedAttribute(t,n),o=e.attributes[n],r=o.componentsPerAttribute,s=K.createTypedArray(o.componentDatatype,r);return u(i.constructor.pack)?i.constructor.pack(i,s,0):s[0]=i,s}}function Mwe(e,t,n,i,o){return function(r){let s=cQ(r);e.setBatchedAttribute(t,n,s),o==="offset"&&(i._recomputeBoundingSpheres=!0,i._batchTableOffsetsUpdated=!1)}}var Lwe=new h;function Fwe(e,t,n){t.boundingSphere={get:function(){let i=e._instanceBoundingSpheres[n];if(u(i)){i=i.clone();let o=e.modelMatrix,r=t.offset;u(r)&&dQ(i,h.fromArray(r.get(),0,Lwe),e._offsetInstanceExtend[n]),u(o)&&(i=re.transform(i,o))}return i}},t.boundingSphereCV={get:function(){return e._instanceBoundingSpheresCV[n]}}}function Nwe(e,t,n){t.pickId={get:function(){return e._pickIds[n]}}}ar.prototype.getGeometryInstanceAttributes=function(e){let t=-1,n=this._lastPerInstanceAttributeIndex,i=this._instanceIds,o=i.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(texture2D(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) {
+ gl_FragColor.a = 1.0; // 0.0 alpha leads to discard from ShaderSource.createPickFragmentShaderSource
+ czm_writeDepthClamp();
+ }
+#else // CULL_FRAGMENTS
+ gl_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
+ gl_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;
+
+ gl_FragColor = czm_phong(normalize(-eyeCoordinate.xyz), material, czm_lightDirectionEC);
+#endif // FLAT
+
+ // Premultiply alpha. Required for classification primitives on translucent globe.
+ gl_FragColor.rgb *= gl_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
+ gl_FragColor = vec4(material.diffuse + material.emission, material.alpha);
+#else // FLAT
+ gl_FragColor = czm_phong(normalize(-eyeCoordinate.xyz), material, czm_lightDirectionEC);
+#endif // FLAT
+
+ // Premultiply alpha. Required for classification primitives on translucent globe.
+ gl_FragColor.rgb *= gl_FragColor.a;
+
+#endif // PER_INSTANCE_COLOR
+ czm_writeDepthClamp();
+#endif // PICK
+}
+`;function Du(e,t,n){this._projectionExtentDefines={eastMostYhighDefine:"",eastMostYlowDefine:"",westMostYhighDefine:"",westMostYlowDefine:""};let i=new DH;i.requiresTextureCoordinates=e,i.requiresEC=!n.flat;let o=new DH;if(o.requiresTextureCoordinates=e,n instanceof $t)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}Du.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 $t&&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 $t||(o=t.material.shaderSource),new Ue({defines:i,sources:[o,DC]})};Du.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 Ue({defines:n,sources:[DC],pickColorQualifier:"varying"})};Du.prototype.createVertexShader=function(e,t,n,i){return xQ(this._colorShaderDependencies,this._planarExtents,n,e,t,this._appearance,i,this._projectionExtentDefines)};Du.prototype.createPickVertexShader=function(e,t,n,i){return xQ(this._pickShaderDependencies,this._planarExtents,n,e,t,void 0,i,this._projectionExtentDefines)};var hQ=new h,mQ=new fe,pQ={high:0,low:0};function xQ(e,t,n,i,o,r,s,a){let c=i.slice();if(a.eastMostYhighDefine===""){let l=mQ;l.longitude=I.PI,l.latitude=0,l.height=0;let f=s.project(l,hQ),d=Vn.encode(f.x,pQ);a.eastMostYhighDefine=`EAST_MOST_X_HIGH ${d.high.toFixed(`${d.high}`.length+1)}`,a.eastMostYlowDefine=`EAST_MOST_X_LOW ${d.low.toFixed(`${d.low}`.length+1)}`;let p=mQ;p.longitude=-I.PI,p.latitude=0,p.height=0;let g=s.project(p,hQ);d=Vn.encode(g.x,pQ),a.westMostYhighDefine=`WEST_MOST_X_HIGH ${d.high.toFixed(`${d.high}`.length+1)}`,a.westMostYlowDefine=`WEST_MOST_X_LOW ${d.low.toFixed(`${d.low}`.length+1)}`}return n&&(c.push(a.eastMostYhighDefine),c.push(a.eastMostYlowDefine),c.push(a.westMostYhighDefine),c.push(a.westMostYlowDefine)),u(r)&&r instanceof $t&&c.push("PER_INSTANCE_COLOR"),e.requiresTextureCoordinates&&(c.push("TEXTURE_COORDINATES"),t||n||c.push("SPHERICAL"),n&&c.push("COLUMBUS_VIEW_2D")),new Ue({defines:c,sources:[o]})}function DH(){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(DH.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 _Q(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)/H.distance(t,e)}var Vwe=[new H,new H,new H,new H];function CQ(e,t){let n=Vwe,i=H.unpack(t,0,n[0]),o=H.unpack(t,2,n[1]),r=H.unpack(t,4,n[2]);e.uMaxVmax=new Pa({componentDatatype:K.FLOAT,componentsPerAttribute:4,normalize:!1,value:[o.x,o.y,r.x,r.y]});let s=1/_Q(i,o,r),a=1/_Q(i,r,o);e.uvMinAndExtents=new Pa({componentDatatype:K.FLOAT,componentsPerAttribute:4,normalize:!1,value:[i.x,i.y,s,a]})}var TQ=new fe,EQ=new h,Uwe=new h,zwe=new h,r3={high:0,low:0};function bQ(e,t,n){let i=TQ;i.height=0,i.longitude=e.west,i.latitude=e.south;let o=t.project(i,EQ);i.latitude=e.north;let r=t.project(i,Uwe);i.longitude=e.east,i.latitude=e.south;let s=t.project(i,zwe),a=[0,0,0,0],c=[0,0,0,0],l=Vn.encode(o.x,r3);a[0]=l.high,c[0]=l.low,l=Vn.encode(o.y,r3),a[1]=l.high,c[1]=l.low,l=Vn.encode(r.y,r3),a[2]=l.high,c[2]=l.low,l=Vn.encode(s.x,r3),a[3]=l.high,c[3]=l.low,n.planes2D_HIGH=new Pa({componentDatatype:K.FLOAT,componentsPerAttribute:4,normalize:!1,value:a}),n.planes2D_LOW=new Pa({componentDatatype:K.FLOAT,componentsPerAttribute:4,normalize:!1,value:c})}var Gwe=new F,Hwe=new F,gQ=new h,Wwe=new fe,jwe=[new fe,new fe,new fe,new fe,new fe,new fe,new fe,new fe];function qwe(e,t,n,i,o,r){let s=ce.center(e,Wwe);s.height=n;let a=fe.toCartesian(s,t,gQ),c=St.eastNorthUpToFixedFrame(a,t,Gwe),l=F.inverse(c,Hwe),f=e.west,d=e.east,p=e.north,g=e.south,m=jwe;m[0].latitude=g,m[0].longitude=f,m[1].latitude=p,m[1].longitude=f,m[2].latitude=p,m[2].longitude=d,m[3].latitude=g,m[3].longitude=d;let A=(f+d)*.5,x=(p+g)*.5;m[4].latitude=g,m[4].longitude=A,m[5].latitude=p,m[5].longitude=A,m[6].latitude=x,m[6].longitude=f,m[7].latitude=x,m[7].longitude=d;let C=Number.POSITIVE_INFINITY,T=Number.NEGATIVE_INFINITY,b=Number.POSITIVE_INFINITY,S=Number.NEGATIVE_INFINITY;for(let R=0;R<8;R++){m[R].height=n;let M=fe.toCartesian(m[R],t,gQ);F.multiplyByPoint(l,M,M),M.z=0,C=Math.min(C,M.x),T=Math.max(T,M.x),b=Math.min(b,M.y),S=Math.max(S,M.y)}let v=i;v.x=C,v.y=b,v.z=0,F.multiplyByPoint(c,v,v);let P=o;P.x=T,P.y=b,P.z=0,F.multiplyByPoint(c,P,P),h.subtract(P,v,o);let O=r;O.x=C,O.y=S,O.z=0,F.multiplyByPoint(c,O,O),h.subtract(O,v,r)}var Ywe=new h,Xwe=new h,Kwe=new Vn;Du.getPlanarTextureCoordinateAttributes=function(e,t,n,i,o){let r=EQ,s=Ywe,a=Xwe;qwe(e,n,y(o,0),r,s,a);let c={};CQ(c,t);let l=Vn.fromCartesian(r,Kwe);return c.southWest_HIGH=new Pa({componentDatatype:K.FLOAT,componentsPerAttribute:3,normalize:!1,value:h.pack(l.high,[0,0,0])}),c.southWest_LOW=new Pa({componentDatatype:K.FLOAT,componentsPerAttribute:3,normalize:!1,value:h.pack(l.low,[0,0,0])}),c.eastward=new Pa({componentDatatype:K.FLOAT,componentsPerAttribute:3,normalize:!1,value:h.pack(s,[0,0,0])}),c.northward=new Pa({componentDatatype:K.FLOAT,componentsPerAttribute:3,normalize:!1,value:h.pack(a,[0,0,0])}),bQ(e,i,c),c};var Jwe=new h;function yQ(e,t,n,i){let o=TQ;o.latitude=e,o.longitude=t,o.height=0;let r=fe.toCartesian(o,n,Jwe),s=Math.sqrt(r.x*r.x+r.y*r.y),a=I.fastApproximateAtan2(s,r.z),c=I.fastApproximateAtan2(r.x,r.y);return i.x=a,i.y=c,i}var AQ=new H;Du.getSphericalExtentGeometryInstanceAttributes=function(e,t,n,i){let o=yQ(e.south,e.west,n,AQ),r=o.x,s=o.y,a=yQ(e.north,e.east,n,AQ),c=a.x,l=a.y,f=0;s>l&&(f=I.PI-s,s=-I.PI,l+=f),r-=I.EPSILON5,s-=I.EPSILON5,c+=I.EPSILON5,l+=I.EPSILON5;let d=1/(l-s),p=1/(c-r),g={sphericalExtents:new Pa({componentDatatype:K.FLOAT,componentsPerAttribute:4,normalize:!1,value:[r,s,p,d]}),longitudeRotation:new Pa({componentDatatype:K.FLOAT,componentsPerAttribute:1,normalize:!1,value:[f]})};return CQ(g,t),bQ(e,i,g),g};Du.hasAttributesForTextureCoordinatePlanes=function(e){return u(e.southWest_HIGH)&&u(e.southWest_LOW)&&u(e.northward)&&u(e.eastward)&&u(e.planes2D_HIGH)&&u(e.planes2D_LOW)&&u(e.uMaxVmax)&&u(e.uvMinAndExtents)};Du.hasAttributesForSphericalExtents=function(e){return u(e.sphericalExtents)&&u(e.longitudeRotation)&&u(e.planes2D_HIGH)&&u(e.planes2D_LOW)&&u(e.uMaxVmax)&&u(e.uvMinAndExtents)};function Zwe(e){return Math.max(e.width,e.height)>Du.MAX_WIDTH_FOR_PLANAR_EXTENTS}Du.shouldUseSphericalCoordinates=function(e){return Zwe(e)};Du.MAX_WIDTH_FOR_PLANAR_EXTENTS=I.toRadians(1);var Bl=Du;var Qwe={NEVER:te.NEVER,LESS:te.LESS,EQUAL:te.EQUAL,LESS_OR_EQUAL:te.LEQUAL,GREATER:te.GREATER,NOT_EQUAL:te.NOTEQUAL,GREATER_OR_EQUAL:te.GEQUAL,ALWAYS:te.ALWAYS},Nn=Object.freeze(Qwe);var $we={ZERO:te.ZERO,KEEP:te.KEEP,REPLACE:te.REPLACE,INCREMENT:te.INCR,DECREMENT:te.DECR,INVERT:te.INVERT,INCREMENT_WRAP:te.INCR_WRAP,DECREMENT_WRAP:te.DECR_WRAP},at=Object.freeze($we);var s3={CESIUM_3D_TILE_MASK:128,SKIP_LOD_MASK:112,SKIP_LOD_BIT_SHIFT:4,CLASSIFICATION_MASK:15};s3.setCesium3DTileBit=function(){return{enabled:!0,frontFunction:Nn.ALWAYS,frontOperation:{fail:at.KEEP,zFail:at.KEEP,zPass:at.REPLACE},backFunction:Nn.ALWAYS,backOperation:{fail:at.KEEP,zFail:at.KEEP,zPass:at.REPLACE},reference:s3.CESIUM_3D_TILE_MASK,mask:s3.CESIUM_3D_TILE_MASK}};var vt=Object.freeze(s3);function l0(e){e=y(e,y.EMPTY_OBJECT);let t=e.geometryInstances;this.geometryInstances=t,this.show=y(e.show,!0),this.classificationType=y(e.classificationType,Fn.BOTH),this.debugShowBoundingVolume=y(e.debugShowBoundingVolume,!1),this.debugShowShadowVolume=y(e.debugShowShadowVolume,!1),this._debugShowShadowVolume=!1,this._extruded=y(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;let n=this;this._readyPromise=new Promise((i,o)=>{n._completeLoad=()=>{if(this._ready)return;this._ready=!0,this.releaseGeometryInstances&&(this.geometryInstances=void 0);let r=this._error;u(r)?o(r):i(this)}}),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:y(e.vertexCacheOptimize,!1),interleave:y(e.interleave,!1),releaseGeometryInstances:y(e.releaseGeometryInstances,!0),allowPicking:y(e.allowPicking,!0),asynchronous:y(e.asynchronous,!0),compressVertices:y(e.compressVertices,!0),_createBoundingVolumeFunction:void 0,_createRenderStatesFunction:void 0,_createShaderProgramFunction:void 0,_createCommandsFunction:void 0,_updateAndQueueCommandsFunction:void 0,_createPickOffsets:!0}}Object.defineProperties(l0.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}},readyPromise:{get:function(){return this._readyPromise}},_needs2DShader:{get:function(){return this._hasPlanarExtentsAttributes||this._hasSphericalExtentsAttribute}}});l0.isSupported=function(e){return e.context.stencilBuffer};function PC(e,t){let n=t?Nn.EQUAL:Nn.ALWAYS;return{colorMask:{red:!1,green:!1,blue:!1,alpha:!1},stencilTest:{enabled:e,frontFunction:n,frontOperation:{fail:at.KEEP,zFail:at.DECREMENT_WRAP,zPass:at.KEEP},backFunction:n,backOperation:{fail:at.KEEP,zFail:at.INCREMENT_WRAP,zPass:at.KEEP},reference:vt.CESIUM_3D_TILE_MASK,mask:vt.CESIUM_3D_TILE_MASK},stencilMask:vt.CLASSIFICATION_MASK,depthTest:{enabled:!0,func:Da.LESS_OR_EQUAL},depthMask:!1}}function IH(e){return{stencilTest:{enabled:e,frontFunction:Nn.NOT_EQUAL,frontOperation:{fail:at.ZERO,zFail:at.ZERO,zPass:at.ZERO},backFunction:Nn.NOT_EQUAL,backOperation:{fail:at.ZERO,zFail:at.ZERO,zPass:at.ZERO},reference:0,mask:vt.CLASSIFICATION_MASK},stencilMask:vt.CLASSIFICATION_MASK,depthTest:{enabled:!1},depthMask:!1,blending:an.PRE_MULTIPLIED_ALPHA_BLEND}}var eve={stencilTest:{enabled:!0,frontFunction:Nn.NOT_EQUAL,frontOperation:{fail:at.ZERO,zFail:at.ZERO,zPass:at.ZERO},backFunction:Nn.NOT_EQUAL,backOperation:{fail:at.ZERO,zFail:at.ZERO,zPass:at.ZERO},reference:0,mask:vt.CLASSIFICATION_MASK},stencilMask:vt.CLASSIFICATION_MASK,depthTest:{enabled:!1},depthMask:!1};function tve(e,t,n,i){if(u(e._rsStencilDepthPass))return;let o=!e.debugShowShadowVolume;e._rsStencilDepthPass=ke.fromCache(PC(o,!1)),e._rsStencilDepthPass3DTiles=ke.fromCache(PC(o,!0)),e._rsColorPass=ke.fromCache(IH(o,!1)),e._rsPickPass=ke.fromCache(eve)}function nve(e,t){if(!e.compressVertices)return t;if(t.search(/attribute\s+vec3\s+extrudeDirection;/g)!==-1){let n="compressedAttributes",i=`attribute vec2 ${n};`,o=`vec3 extrudeDirection;
+`,r=` extrudeDirection = czm_octDecode(${n}, 65535.0);
+`,s=t;s=s.replace(/attribute\s+vec3\s+extrudeDirection;/g,""),s=Ue.replaceMain(s,"czm_non_compressed_main");let a=`void main()
+{
+${r} czm_non_compressed_main();
+}`;return[i,o,s,a].join(`
+`)}}function ive(e,t){let n=t.context,i=e._primitive,o=LD;o=e._primitive._batchTable.getVertexShaderCallback()(o),o=xn._appendDistanceDisplayConditionToShader(i,o),o=xn._modifyShaderPosition(e,o,t.scene3DOnly),o=xn._updateColorAttribute(i,o);let r=e._hasPlanarExtentsAttributes,s=r||e._hasSphericalExtentsAttribute;e._extruded&&(o=nve(i,o));let a=e._extruded?"EXTRUDED_GEOMETRY":"",c=new Ue({defines:[a],sources:[o]}),l=new Ue({sources:[B_]}),f=e._primitive._attributeLocations,d=new Bl(s,r,e.appearance);if(e._spStencil=jt.replaceCache({context:n,shaderProgram:e._spStencil,vertexShaderSource:c,fragmentShaderSource:l,attributeLocations:f}),e._primitive.allowPicking){let m=Ue.createPickVertexShaderSource(o);m=xn._appendShowToShader(i,m),m=xn._updatePickColorAttribute(m);let A=d.createPickFragmentShader(!1),x=d.createPickVertexShader([a],m,!1,t.mapProjection);if(e._spPick=jt.replaceCache({context:n,shaderProgram:e._spPick,vertexShaderSource:x,fragmentShaderSource:A,attributeLocations:f}),s){let C=n.shaderCache.getDerivedShaderProgram(e._spPick,"2dPick");if(!u(C)){let T=d.createPickFragmentShader(!0),b=d.createPickVertexShader([a],m,!0,t.mapProjection);C=n.shaderCache.createDerivedShaderProgram(e._spPick,"2dPick",{vertexShaderSource:b,fragmentShaderSource:T,attributeLocations:f})}e._spPick2D=C}}else e._spPick=jt.fromCache({context:n,vertexShaderSource:c,fragmentShaderSource:l,attributeLocations:f});o=xn._appendShowToShader(i,o),c=new Ue({defines:[a],sources:[o]}),e._sp=jt.replaceCache({context:n,shaderProgram:e._sp,vertexShaderSource:c,fragmentShaderSource:l,attributeLocations:f});let p=d.createFragmentShader(!1),g=d.createVertexShader([a],o,!1,t.mapProjection);if(e._spColor=jt.replaceCache({context:n,shaderProgram:e._spColor,vertexShaderSource:g,fragmentShaderSource:p,attributeLocations:f}),s){let m=n.shaderCache.getDerivedShaderProgram(e._spColor,"2dColor");if(!u(m)){let A=d.createFragmentShader(!0),x=d.createVertexShader([a],o,!0,t.mapProjection);m=n.shaderCache.createDerivedShaderProgram(e._spColor,"2dColor",{vertexShaderSource:x,fragmentShaderSource:A,attributeLocations:f})}e._spColor2D=m}}function ove(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=Bl.hasAttributesForSphericalExtents(c),g=Bl.hasAttributesForTextureCoordinatePlanes(c),d=c.color),s=0;s{u(this._primitive)&&this._primitive.ready&&this._completeLoad()})};l0.prototype.getGeometryInstanceAttributes=function(e){return this._primitive.getGeometryInstanceAttributes(e)};l0.prototype.isDestroyed=function(){return!1};l0.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,le(this)};var IC=l0;var cve={u_globeMinimumAltitude:function(){return 55e3}};function $c(e){e=y(e,y.EMPTY_OBJECT);let t=e.appearance,n=e.geometryInstances;if(!u(t)&&u(n)){let r=Array.isArray(n)?n:[n],s=r.length;for(let a=0;a{i._completeLoad=()=>{if(this._ready)return;this._ready=!0,this.releaseGeometryInstances&&(this.geometryInstances=void 0);let a=this._error;u(a)?s(a):r(this)}}),this._primitive=void 0,this._maxHeight=void 0,this._minHeight=void 0,this._maxTerrainHeight=ni._defaultMaxTerrainHeight,this._minTerrainHeight=ni._defaultMinTerrainHeight,this._boundingSpheresKeys=[],this._boundingSpheres=[],this._useFragmentCulling=!1,this._zIndex=void 0;let o=this;this._classificationPrimitiveOptions={geometryInstances:void 0,appearance:void 0,vertexCacheOptimize:y(e.vertexCacheOptimize,!1),interleave:y(e.interleave,!1),releaseGeometryInstances:y(e.releaseGeometryInstances,!0),allowPicking:y(e.allowPicking,!0),asynchronous:y(e.asynchronous,!0),compressVertices:y(e.compressVertices,!0),_createBoundingVolumeFunction:void 0,_updateAndQueueCommandsFunction:void 0,_pickPrimitive:o,_extruded:!0,_uniformMap:cve}}Object.defineProperties($c.prototype,{vertexCacheOptimize:{get:function(){return this._classificationPrimitiveOptions.vertexCacheOptimize}},interleave:{get:function(){return this._classificationPrimitiveOptions.interleave}},releaseGeometryInstances:{get:function(){return this._classificationPrimitiveOptions.releaseGeometryInstances}},allowPicking:{get:function(){return this._classificationPrimitiveOptions.allowPicking}},asynchronous:{get:function(){return this._classificationPrimitiveOptions.asynchronous}},compressVertices:{get:function(){return this._classificationPrimitiveOptions.compressVertices}},ready:{get:function(){return this._ready}},readyPromise:{get:function(){return this._readyPromise}}});$c.isSupported=IC.isSupported;function vQ(e){return function(t,n){let i=n.maximumRadius,o=i/Math.cos(t*.5)-i;return e._maxHeight+o}}function DQ(e){return function(t,n){return e._minHeight}}var lve=new h,uve=new h,fve=new h,dve=new fe,hve=new ce;function a3(e,t){let n=e.mapProjection.ellipsoid;if(!u(t.attributes)||!u(t.attributes.position3DHigh))return u(t.rectangle)?t.rectangle:void 0;let i=t.attributes.position3DHigh.values,o=t.attributes.position3DLow.values,r=i.length,s=Number.POSITIVE_INFINITY,a=Number.POSITIVE_INFINITY,c=Number.NEGATIVE_INFINITY,l=Number.NEGATIVE_INFINITY;for(let d=0;d{u(this._primitive)&&this._primitive.ready&&this._completeLoad()})};$c.prototype.getBoundingSphere=function(e){let t=this._boundingSpheresKeys.indexOf(e);if(t!==-1)return this._boundingSpheres[t]};$c.prototype.getGeometryInstanceAttributes=function(e){return this._primitive.getGeometryInstanceAttributes(e)};$c.prototype.isDestroyed=function(){return!1};$c.prototype.destroy=function(){return this._primitive=this._primitive&&this._primitive.destroy(),le(this)};$c._supportsMaterials=function(e){return e.depthTexture};$c.supportsMaterials=function(e){return $c._supportsMaterials(e.frameState.context)};var hc=$c;function OC(){Ae.throwInstantiationError()}Object.defineProperties(OC.prototype,{isConstant:{get:Ae.throwInstantiationError},definitionChanged:{get:Ae.throwInstantiationError}});OC.prototype.getType=Ae.throwInstantiationError;OC.prototype.getValue=Ae.throwInstantiationError;OC.prototype.equals=Ae.throwInstantiationError;OC.getValue=function(e,t,n){let i;return u(t)&&(i=t.getType(e),u(i))?((!u(n)||n.type!==i)&&(n=Xi.fromType(i)),t.getValue(e,n.uniforms),n):((!u(n)||n.type!==Xi.ColorType)&&(n=Xi.fromType(Xi.ColorType)),z.clone(z.WHITE,n.uniforms.color),n)};var Mo=OC;function u0(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}u0.prototype._isHidden=function(e,t,n){return!e.isShowing||!e.isAvailable(n)||!j.getValueOrDefault(t.show,n,!0)};u0.prototype._setOptions=Ae.throwInstantiationError;u0.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(!u(s.fill)||s.fill.getValue(e)){let l=t.fillMaterialProperty,f=l instanceof Pt,d,p=t._getIsClosed(c);if(f)d=new $t({closed:p,flat:n&&!t._supportsMaterialsforEntitiesOnTerrain});else{let g=Mo.getValue(e,l,this._material);this._material=g,d=new eo({material:g,translucent:g.isTranslucent(),closed:p})}if(n)c.vertexFormat=$t.VERTEX_FORMAT,this._primitive=o.add(new hc({geometryInstances:this._geometryUpdater.createFillGeometryInstance(e),appearance:d,asynchronous:!1,shadows:a,classificationType:this._geometryUpdater.classificationTypeProperty.getValue(e)}),j.getValueOrUndefined(this._geometryUpdater.zIndex,e));else{c.vertexFormat=d.vertexFormat;let g=this._geometryUpdater.createFillGeometryInstance(e);f&&(d.translucent=g.attributes.color.value[3]!==255),this._primitive=i.add(new xn({geometryInstances:g,appearance:d,asynchronous:!1,shadows:a}))}}if(!n&&u(s.outline)&&s.outline.getValue(e)){let l=this._geometryUpdater.createOutlineGeometryInstance(e),f=j.getValueOrDefault(s.outlineWidth,e,1);this._outlinePrimitive=i.add(new xn({geometryInstances:l,appearance:new $t({flat:!0,translucent:l.attributes.color.value[3]!==255,renderState:{lineWidth:t._scene.clampLineWidth(f)}}),asynchronous:!1,shadows:a}))}};u0.prototype.getBoundingSphere=function(e){let t=this._entity,n=this._primitive,i=this._outlinePrimitive,o;return u(n)&&n.show&&n.ready&&(o=n.getGeometryInstanceAttributes(t),u(o)&&u(o.boundingSphere))?(re.clone(o.boundingSphere,e),ot.DONE):u(i)&&i.show&&i.ready&&(o=i.getGeometryInstanceAttributes(t),u(o)&&u(o.boundingSphere))?(re.clone(o.boundingSphere,e),ot.DONE):u(n)&&!n.ready||u(i)&&!i.ready?ot.PENDING:ot.FAILED};u0.prototype.isDestroyed=function(){return!1};u0.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),le(this)};var Jn=u0;var IQ={};function jD(e,t){u(IQ[e])||(IQ[e]=!0,console.warn(y(t,e)))}jD.geometryOutlines="Entity geometry outlines are unsupported on terrain. Outlines will be disabled. To enable outlines, disable geometry terrain clamping by explicitly setting height to 0.";jD.geometryZIndex="Entity geometry with zIndex are unsupported when height or extrudedHeight are defined. zIndex will be ignored";jD.geometryHeightReference="Entity corridor, ellipse, polygon or rectangle with heightReference must also have a defined height. heightReference will be ignored";jD.geometryExtrudedHeightReference="Entity corridor, ellipse, polygon or rectangle with extrudedHeightReference must also have a defined extrudedHeight. extrudedHeightReference will be ignored";var Dt=jD;var gve={NONE:0,GEODESIC:1,RHUMB:2},qt=Object.freeze(gve);var OQ=I.EPSILON10;function yve(e,t,n,i){if(!u(e))return;n=y(n,!1);let o=u(i),r=e.length;if(r<2)return e;let s,a=e[0],c,l,f=0,d=-1;for(s=1;sI.EPSILON12);let E=L*(t*t-n*n)/(n*n),w=1+E*(4096+E*(E*(320-175*E)-768))/16384,D=E*(256+E*(E*(74-47*E)-128))/1024,B=_*_,N=D*M*(_+D*(R*(2*B-1)-D*_*(4*M*M-3)*(4*B-3)/6)/4),U=n*w*(O-N),V=Math.atan2(g*P,x-T*v),G=Math.atan2(d*P,x*v-T);e._distance=U,e._startHeading=V,e._endHeading=G,e._uSquared=E}var Tve=new h,RH=new h;function RQ(e,t,n,i){let o=h.normalize(i.cartographicToCartesian(t,RH),Tve),r=h.normalize(i.cartographicToCartesian(n,RH),RH);Cve(e,i.maximumRadius,i.minimumRadius,t.longitude,t.latitude,n.longitude,n.latitude),e._start=fe.clone(t,e._start),e._end=fe.clone(n,e._end),e._start.height=0,e._end.height=0,Ave(e)}function qD(e,t,n){let i=y(n,ie.WGS84);this._ellipsoid=i,this._start=new fe,this._end=new fe,this._constants={},this._startHeading=void 0,this._endHeading=void 0,this._distance=void 0,this._uSquared=void 0,u(e)&&u(t)&&RQ(this,e,t,i)}Object.defineProperties(qD.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}}});qD.prototype.setEndPoints=function(e,t){RQ(this,e,t,this._ellipsoid)};qD.prototype.interpolateUsingFraction=function(e,t){return this.interpolateUsingSurfaceDistance(this._distance*e,t)};qD.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),f=Math.sin(8*i),d=i*i,p=i*d,g=n.u8Over256,m=n.u2Over4,A=n.u6Over64,x=n.u4Over16,C=2*p*g*o/3+i*(1-m+7*x/4-15*A/4+579*g/64-(x-15*A/4+187*g/16)*o-(5*A/4-115*g/16)*r-29*g*s/16)+(m/2-x+71*A/32-85*g/16)*a+(5*x/16-5*A/4+383*g/96)*c-d*((A-11*g/2)*a+5*g*c/2)+(29*A/96-29*g/16)*l+539*g*f/1536,T=Math.asin(Math.sin(C)*n.cosineAlpha),b=Math.atan(n.a/n.b*Math.tan(T));C=C-n.sigma;let S=Math.cos(2*n.sigma+C),v=Math.sin(C),P=Math.cos(C),O=n.cosineU*P,R=n.sineU*v,L=Math.atan2(v*n.sineHeading,O-R*n.cosineHeading)-BQ(n.f,n.sineAlpha,n.cosineSquaredAlpha,C,v,P,S);return u(t)?(t.longitude=this._start.longitude+L,t.latitude=b,t.height=0,t):new fe(this._start.longitude+L,b,0)};var Pu=qD;function LH(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,f=Math.sin(2*l),d=Math.sin(4*l),p=Math.sin(6*l),g=Math.sin(8*l),m=Math.sin(10*l),A=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)*f+(15*o/256+45*r/1024+525*s/16384+1575*a/65536+155925*c/8388608)*d-(35*r/3072+175*s/12288+3675*a/262144+13475*c/1048576)*p+(315*s/131072+2205*a/524288+43659*c/8388608)*g-(693*a/1310720+6237*c/5242880)*m+1001*c/8388608*A)}function Eve(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,f=l*c,d=f*c,p=d*c,g=p*c,m=Math.sin(2*i),A=Math.cos(2*i),x=Math.sin(4*i),C=Math.cos(4*i),T=Math.sin(6*i),b=Math.cos(6*i),S=Math.sin(8*i),v=Math.cos(8*i),P=Math.sin(10*i),O=Math.cos(10*i),R=Math.sin(12*i);return i+i*c/4+7*i*l/64+15*i*f/256+579*i*d/16384+1515*i*p/65536+16837*i*g/1048576+(3*i*l/16+45*i*f/256-i*(32*o-561)*d/4096-i*(232*o-1677)*p/16384+i*(399985-90560*o+512*s)*g/5242880)*A+(21*i*f/256+483*i*d/4096-i*(224*o-1969)*p/16384-i*(33152*o-112599)*g/1048576)*C+(151*i*d/4096+4681*i*p/65536+1479*i*g/16384-453*r*g/32768)*b+(1097*i*p/65536+42783*i*g/1048576)*v+8011*i*g/1048576*O+(3*c/8+3*l/16+213*f/2048-3*o*f/64+255*d/4096-33*o*d/512+20861*p/524288-33*o*p/512+s*p/1024+28273*g/1048576-471*o*g/8192+9*s*g/4096)*m+(21*l/256+21*f/256+533*d/8192-21*o*d/512+197*p/4096-315*o*p/4096+584039*g/16777216-12517*o*g/131072+7*s*g/2048)*x+(151*f/6144+151*d/4096+5019*p/131072-453*o*p/16384+26965*g/786432-8607*o*g/131072)*T+(1097*d/131072+1097*p/65536+225797*g/10485760-1097*o*g/65536)*S+(8011*p/2621440+8011*g/1048576)*P+293393*g/251658240*R}function BC(e,t){if(e===0)return Math.log(Math.tan(.5*(I.PI_OVER_TWO+t)));let n=e*Math.sin(t);return Math.log(Math.tan(.5*(I.PI_OVER_TWO+t)))-e/2*Math.log((1+n)/(1-n))}function bve(e,t,n,i,o){let r=BC(e._ellipticity,n),s=BC(e._ellipticity,o);return Math.atan2(I.negativePiToPi(i-t),s-r)}function Sve(e,t,n,i,o,r,s){let a=e._heading,c=r-i,l=0;if(I.equalsEpsilon(Math.abs(a),I.PI_OVER_TWO,I.EPSILON8))if(t===n)l=t*Math.cos(o)*I.negativePiToPi(c);else{let f=Math.sin(o);l=t*Math.cos(o)*I.negativePiToPi(c)/Math.sqrt(1-e._ellipticitySquared*f*f)}else{let f=LH(e._ellipticity,t,o);l=(LH(e._ellipticity,t,s)-f)/Math.cos(a)}return Math.abs(l)}var wve=new h,MH=new h;function MQ(e,t,n,i){let o=h.normalize(i.cartographicToCartesian(t,MH),wve),r=h.normalize(i.cartographicToCartesian(n,MH),MH),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=fe.clone(t,e._start),e._start.height=0,e._end=fe.clone(n,e._end),e._end.height=0,e._heading=bve(e,t.longitude,t.latitude,n.longitude,n.latitude),e._distance=Sve(e,i.maximumRadius,i.minimumRadius,t.longitude,t.latitude,n.longitude,n.latitude)}function LQ(e,t,n,i,o,r){if(n===0)return fe.clone(e,r);let s=o*o,a,c,l;if(Math.abs(I.PI_OVER_TWO-Math.abs(t))>I.EPSILON8){let f=LH(o,i,e.latitude),d=n*Math.cos(t),p=f+d;c=Eve(p,o,i);let g=BC(o,e.latitude),m=BC(o,c);l=Math.tan(t)*(m-g),a=I.negativePiToPi(e.longitude+l)}else{c=e.latitude;let f;if(o===0)f=i*Math.cos(e.latitude);else{let d=Math.sin(e.latitude);f=i*Math.cos(e.latitude)/Math.sqrt(1-s*d*d)}l=n/f,t>0?a=I.negativePiToPi(e.longitude+l):a=I.negativePiToPi(e.longitude-l)}return u(r)?(r.longitude=a,r.latitude=c,r.height=0,r):new fe(a,c,0)}function Dm(e,t,n){let i=y(n,ie.WGS84);this._ellipsoid=i,this._start=new fe,this._end=new fe,this._heading=void 0,this._distance=void 0,this._ellipticity=void 0,this._ellipticitySquared=void 0,u(e)&&u(t)&&MQ(this,e,t,i)}Object.defineProperties(Dm.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}}});Dm.fromStartHeadingDistance=function(e,t,n,i,o){let r=y(i,ie.WGS84),s=r.maximumRadius,a=r.minimumRadius,c=s*s,l=a*a,f=Math.sqrt((c-l)/c);t=I.negativePiToPi(t);let d=LQ(e,t,n,r.maximumRadius,f);return!u(o)||u(i)&&!i.equals(o.ellipsoid)?new Dm(e,d,r):(o.setEndPoints(e,d),o)};Dm.prototype.setEndPoints=function(e,t){MQ(this,e,t,this._ellipsoid)};Dm.prototype.interpolateUsingFraction=function(e,t){return this.interpolateUsingSurfaceDistance(e*this._distance,t)};Dm.prototype.interpolateUsingSurfaceDistance=function(e,t){return LQ(this._start,this._heading,e,this._ellipsoid.maximumRadius,this._ellipticity,t)};Dm.prototype.findIntersectionWithLongitude=function(e,t){let n=this._ellipticity,i=this._heading,o=Math.abs(i),r=this._start;if(e=I.negativePiToPi(e),I.equalsEpsilon(Math.abs(e),Math.PI,I.EPSILON14)&&(e=I.sign(r.longitude)*Math.PI),u(t)||(t=new fe),Math.abs(I.PI_OVER_TWO-o)<=I.EPSILON8)return t.longitude=e,t.latitude=r.latitude,t.height=0,t;if(I.equalsEpsilon(Math.abs(I.PI_OVER_TWO-o),I.PI_OVER_TWO,I.EPSILON8))return I.equalsEpsilon(e,r.longitude,I.EPSILON12)?void 0:(t.longitude=e,t.latitude=I.PI_OVER_TWO*I.sign(I.PI_OVER_TWO-i),t.height=0,t);let s=r.latitude,a=n*Math.sin(s),c=Math.tan(.5*(I.PI_OVER_TWO+s))*Math.exp((e-r.longitude)/Math.tan(i)),l=(1+a)/(1-a),f=r.latitude,d;do{d=f;let p=n*Math.sin(d),g=(1+p)/(1-p);f=2*Math.atan(c*Math.pow(g/l,n/2))-I.PI_OVER_TWO}while(!I.equalsEpsilon(f,d,I.EPSILON12));return t.longitude=e,t.latitude=f,t.height=0,t};Dm.prototype.findIntersectionWithLatitude=function(e,t){let n=this._ellipticity,i=this._heading,o=this._start;if(I.equalsEpsilon(Math.abs(i),I.PI_OVER_TWO,I.EPSILON8))return;let r=BC(n,o.latitude),s=BC(n,e),a=Math.tan(i)*(s-r),c=I.negativePiToPi(o.longitude+a);return u(t)?(t.longitude=c,t.latitude=e,t.height=0,t):new fe(c,e,0)};var oa=Dm;var HH=[pi,yi],vve=HH.length,t$=Math.cos(I.toRadians(30)),FQ=Math.cos(I.toRadians(150)),n$=0,i$=1e3;function L_(e){e=y(e,y.EMPTY_OBJECT);let t=e.positions;this.width=y(e.width,1),this._positions=t,this.granularity=y(e.granularity,9999),this.loop=y(e.loop,!1),this.arcType=y(e.arcType,qt.GEODESIC),this._ellipsoid=ie.WGS84,this._projectionIndex=0,this._workerName="createGroundPolylineGeometry",this._scene3DOnly=!1}Object.defineProperties(L_.prototype,{packedLength:{get:function(){return 1+this._positions.length*3+1+1+1+ie.packedLength+1+1}}});L_.setProjectionAndEllipsoid=function(e,t){let n=0;for(let i=0;it$||rI.PI_OVER_TWO&&(a=!0,s=h.subtract(r,n,WQ),l=c.cartesianToCartographic(s,HQ)),l.height=0;let f=e.project(l,o);return o=h.subtract(f,i,o),o.z=0,o=h.normalize(o,o),a&&h.negate(o,o),o}var Yve=new h,jQ=new h;function qQ(e,t,n,i,o,r){let s=h.subtract(t,e,Yve);h.normalize(s,s);let a=n-n$,c=h.multiplyByScalar(s,a,jQ);h.add(e,c,o);let l=i-i$;c=h.multiplyByScalar(s,l,jQ),h.add(t,c,r)}var Xve=new h;function u3(e,t){let n=nn.getPointDistance(f3,e),i=nn.getPointDistance(f3,t),o=Xve;I.equalsEpsilon(n,0,I.EPSILON2)?(o=Pm(t,e,o),h.multiplyByScalar(o,I.EPSILON2,o),h.add(e,o,e)):I.equalsEpsilon(i,0,I.EPSILON2)&&(o=Pm(e,t,o),h.multiplyByScalar(o,I.EPSILON2,o),h.add(t,o,t))}function Kve(e,t){let n=Math.abs(e.longitude),i=Math.abs(t.longitude);if(I.equalsEpsilon(n,I.PI,I.EPSILON11)){let o=I.sign(t.longitude);return e.longitude=o*(n-I.EPSILON11),1}else if(I.equalsEpsilon(i,I.PI,I.EPSILON11)){let o=I.sign(e.longitude);return t.longitude=o*(i-I.EPSILON11),2}return 0}var r$=new fe,s$=new fe,YQ=new h,VH=new h,XQ=new h,KQ=new h,Jve=new h,JQ=new h,Zve=[r$,s$],Qve=new ce,$ve=new h,eDe=new h,tDe=new h,nDe=new h,iDe=new h,oDe=new h,UH=new h,zH=new h,rDe=new h,sDe=new h,aDe=new h,ZQ=new h,cDe=new h,lDe=new h,uDe=new Vn,fDe=new Vn,QQ=new h,dDe=new h,$Q=new h,hDe=[new re,new re],a$=[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],e$=a$.length;function mDe(e,t,n,i,o,r,s){let a,c,l=t._ellipsoid,f=n.length/3-1,d=f*8,p=d*4,g=f*36,m=d>65535?new Uint32Array(g):new Uint16Array(g),A=new Float64Array(d*3),x=new Float32Array(p),C=new Float32Array(p),T=new Float32Array(p),b=new Float32Array(p),S=new Float32Array(p),v,P,O,R;s&&(v=new Float32Array(p),P=new Float32Array(p),O=new Float32Array(p),R=new Float32Array(d*2));let M=r.length/2,L=0,_=r$;_.height=0;let E=s$;E.height=0;let w=YQ,D=VH;if(s)for(c=0,a=1;at$?(ln=YD(t,_,We,Ft,UH),mt=YD(t,E,J,Gt,zH)):zi===1?(mt=YD(t,E,J,Gt,zH),ln.x=0,ln.y=I.sign(_.longitude-Math.abs(E.longitude)),ln.z=0):(ln=YD(t,_,We,Ft,UH),mt.x=0,mt.y=I.sign(_.longitude-E.longitude),mt.z=0)}let On=h.distance(Ne,W),ii=Vn.fromCartesian(Ie,uDe),ct=h.subtract(X,Ie,rDe),Ht=h.normalize(ct,ZQ),si=h.subtract(Ne,Ie,sDe);si=h.normalize(si,si);let ge=h.cross(Ht,si,ZQ);ge=h.normalize(ge,ge);let Oe=h.cross(si,We,cDe);Oe=h.normalize(Oe,Oe);let je=h.subtract(W,X,aDe);je=h.normalize(je,je);let Wt=h.cross(J,je,lDe);Wt=h.normalize(Wt,Wt);let Cn=On/N,Vi=Z/N,Ui=0,$i,li,Me,et=0,Ze=0;if(s){Ui=h.distance(Ft,Gt),$i=Vn.fromCartesian(Ft,fDe),li=h.subtract(Gt,Ft,QQ),Me=h.normalize(li,dDe);let zi=Me.x;Me.x=Me.y,Me.y=-zi,et=Ui/L,Ze=he/L}for(U=0;U<8;U++){let zi=Y+U*4,fr=G+U*2,Ir=zi+3,Cu=U<4?1:-1,Gi=U===2||U===3||U===6||U===7?1:-1;h.pack(ii.high,x,zi),x[Ir]=ct.x,h.pack(ii.low,C,zi),C[Ir]=ct.y,h.pack(Oe,T,zi),T[Ir]=ct.z,h.pack(Wt,b,zi),b[Ir]=Cn*Cu,h.pack(ge,S,zi);let Ur=Vi*Gi;Ur===0&&Gi<0&&(Ur=9),S[Ir]=Ur,s&&(v[zi]=$i.high.x,v[zi+1]=$i.high.y,v[zi+2]=$i.low.x,v[zi+3]=$i.low.y,O[zi]=-ln.y,O[zi+1]=ln.x,O[zi+2]=mt.y,O[zi+3]=-mt.x,P[zi]=li.x,P[zi+1]=li.y,P[zi+2]=Me.x,P[zi+3]=Me.y,R[fr]=et*Cu,Ur=Ze*Gi,Ur===0&&Gi<0&&(Ur=9),R[fr+1]=Ur)}let Ye=tDe,lt=nDe,It=$ve,Tn=eDe,To=ce.fromCartographicArray(Zve,Qve),qo=ni.getMinimumMaximumHeights(To,l),Kr=qo.minimumTerrainHeight,bs=qo.maximumTerrainHeight;pe+=Kr,pe+=bs,qQ(Ie,Ne,Kr,bs,Ye,It),qQ(X,W,Kr,bs,lt,Tn);let no=h.multiplyByScalar(ge,I.EPSILON5,$Q);h.add(Ye,no,Ye),h.add(lt,no,lt),h.add(It,no,It),h.add(Tn,no,Tn),u3(Ye,lt),u3(It,Tn),h.pack(Ye,A,k),h.pack(lt,A,k+3),h.pack(Tn,A,k+6),h.pack(It,A,k+9),no=h.multiplyByScalar(ge,-2*I.EPSILON5,$Q),h.add(Ye,no,Ye),h.add(lt,no,lt),h.add(It,no,It),h.add(Tn,no,Tn),u3(Ye,lt),u3(It,Tn),h.pack(Ye,A,k+12),h.pack(lt,A,k+15),h.pack(Tn,A,k+18),h.pack(It,A,k+21),V+=2,c+=3,G+=16,k+=24,Y+=32,Z+=On,he+=Ui}c=0;let oe=0;for(a=0;a halfMaxWidth || distanceFromStart < 0.0 || distanceFromEnd < 0.0) {
+#ifdef DEBUG_SHOW_VOLUME
+ gl_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
+ gl_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);
+ gl_FragColor = vec4(material.diffuse + material.emission, material.alpha);
+#endif // PER_INSTANCE_COLOR
+
+ // Premultiply alpha. Required for classification primitives on translucent globe.
+ gl_FragColor.rgb *= gl_FragColor.a;
+
+ czm_writeDepthClamp();
+}
+`;var KD=`varying vec3 v_forwardDirectionEC;
+varying vec3 v_texcoordNormalizationAndHalfWidth;
+varying float v_batchId;
+
+#ifdef PER_INSTANCE_COLOR
+varying vec4 v_color;
+#else
+varying vec2 v_alignedPlaneDistances;
+varying 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
+ gl_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);
+ gl_FragColor = vec4(material.diffuse + material.emission, material.alpha);
+#endif // PER_INSTANCE_COLOR
+}
+`;var JD=`attribute vec3 position3DHigh;
+attribute vec3 position3DLow;
+
+attribute vec4 startHiAndForwardOffsetX;
+attribute vec4 startLoAndForwardOffsetY;
+attribute vec4 startNormalAndForwardOffsetZ;
+attribute vec4 endNormalAndTextureCoordinateNormalizationX;
+attribute vec4 rightNormalAndTextureCoordinateNormalizationY;
+attribute vec4 startHiLo2D;
+attribute vec4 offsetAndRight2D;
+attribute vec4 startEndNormals2D;
+attribute vec2 texcoordNormalization2D;
+
+attribute float batchId;
+
+varying vec3 v_forwardDirectionEC;
+varying vec3 v_texcoordNormalizationAndHalfWidth;
+varying float v_batchId;
+
+// For materials
+#ifdef WIDTH_VARYING
+varying float v_width;
+#endif
+#ifdef ANGLE_VARYING
+varying float v_polylineAngle;
+#endif
+
+#ifdef PER_INSTANCE_COLOR
+varying vec4 v_color;
+#else
+varying vec2 v_alignedPlaneDistances;
+varying 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 ZD=`attribute vec3 position3DHigh;
+attribute 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
+attribute vec4 startHiAndForwardOffsetX;
+attribute vec4 startLoAndForwardOffsetY;
+attribute vec4 startNormalAndForwardOffsetZ;
+attribute vec4 endNormalAndTextureCoordinateNormalizationX;
+attribute vec4 rightNormalAndTextureCoordinateNormalizationY;
+#else
+attribute vec4 startHiLo2D;
+attribute vec4 offsetAndRight2D;
+attribute vec4 startEndNormals2D;
+attribute vec2 texcoordNormalization2D;
+#endif
+
+attribute float batchId;
+
+varying vec4 v_startPlaneNormalEcAndHalfWidth;
+varying vec4 v_endPlaneNormalEcAndBatchId;
+varying vec4 v_rightPlaneEC;
+varying vec4 v_endEcAndStartEcX;
+varying vec4 v_texcoordNormalizationAndStartEcYZ;
+
+// For materials
+#ifdef WIDTH_VARYING
+varying float v_width;
+#endif
+#ifdef ANGLE_VARYING
+varying float v_polylineAngle;
+#endif
+
+#ifdef PER_INSTANCE_COLOR
+varying 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 QD=`attribute vec3 position3DHigh;
+attribute vec3 position3DLow;
+attribute vec3 prevPosition3DHigh;
+attribute vec3 prevPosition3DLow;
+attribute vec3 nextPosition3DHigh;
+attribute vec3 nextPosition3DLow;
+attribute vec2 expandAndWidth;
+attribute vec4 color;
+attribute float batchId;
+
+varying 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 Rl=`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 WH=`${Rl}
+${QD}`,pDe=Zy;Mt.isInternetExplorer()||(WH=`#define CLIP_POLYLINE
+${WH}`);function d0(e){e=y(e,y.EMPTY_OBJECT);let t=y(e.translucent,!0),n=!1,i=d0.VERTEX_FORMAT;this.material=void 0,this.translucent=t,this._vertexShaderSource=y(e.vertexShaderSource,WH),this._fragmentShaderSource=y(e.fragmentShaderSource,pDe),this._renderState=qi.getDefaultRenderState(t,n,e.renderState),this._closed=n,this._vertexFormat=i}Object.defineProperties(d0.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}}});d0.VERTEX_FORMAT=we.POSITION_ONLY;d0.prototype.getFragmentShaderSource=qi.prototype.getFragmentShaderSource;d0.prototype.isTranslucent=qi.prototype.isTranslucent;d0.prototype.getRenderState=qi.prototype.getRenderState;var Br=d0;var $D=`attribute vec3 position3DHigh;
+attribute vec3 position3DLow;
+attribute vec3 prevPosition3DHigh;
+attribute vec3 prevPosition3DLow;
+attribute vec3 nextPosition3DHigh;
+attribute vec3 nextPosition3DLow;
+attribute vec2 expandAndWidth;
+attribute vec2 st;
+attribute float batchId;
+
+varying float v_width;
+varying vec2 v_st;
+varying 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 h0=`#ifdef VECTOR_TILE
+uniform vec4 u_highlightColor;
+#endif
+
+varying 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);
+ gl_FragColor = vec4(material.diffuse + material.emission, material.alpha);
+#ifdef VECTOR_TILE
+ gl_FragColor *= u_highlightColor;
+#endif
+
+ czm_writeLogDepth();
+}
+`;var jH=`${Rl}
+${$D}`,_De=h0;Mt.isInternetExplorer()||(jH=`#define CLIP_POLYLINE
+${jH}`);function m0(e){e=y(e,y.EMPTY_OBJECT);let t=y(e.translucent,!0),n=!1,i=m0.VERTEX_FORMAT;this.material=u(e.material)?e.material:Xi.fromType(Xi.ColorType),this.translucent=t,this._vertexShaderSource=y(e.vertexShaderSource,jH),this._fragmentShaderSource=y(e.fragmentShaderSource,_De),this._renderState=qi.getDefaultRenderState(t,n,e.renderState),this._closed=n,this._vertexFormat=i}Object.defineProperties(m0.prototype,{vertexShaderSource:{get:function(){let e=this._vertexShaderSource;return this.material.shaderSource.search(/varying\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}}});m0.VERTEX_FORMAT=we.POSITION_AND_ST;m0.prototype.getFragmentShaderSource=qi.prototype.getFragmentShaderSource;m0.prototype.isTranslucent=qi.prototype.isTranslucent;m0.prototype.getRenderState=qi.prototype.getRenderState;var Is=m0;function Im(e){e=y(e,y.EMPTY_OBJECT),this.geometryInstances=e.geometryInstances,this._hasPerInstanceColors=!0;let t=e.appearance;u(t)||(t=new Is),this.appearance=t,this.show=y(e.show,!0),this.classificationType=y(e.classificationType,Fn.BOTH),this.debugShowBoundingVolume=y(e.debugShowBoundingVolume,!1),this._debugShowShadowVolume=y(e.debugShowShadowVolume,!1),this._primitiveOptions={geometryInstances:void 0,appearance:void 0,vertexCacheOptimize:!1,interleave:y(e.interleave,!1),releaseGeometryInstances:y(e.releaseGeometryInstances,!0),allowPicking:y(e.allowPicking,!0),asynchronous:y(e.asynchronous,!0),compressVertices:!1,_createShaderProgramFunction:void 0,_createCommandsFunction:void 0,_updateAndQueueCommandsFunction:void 0},this._zIndex=void 0,this._ready=!1;let n=this;this._readyPromise=new Promise((i,o)=>{n._completeLoad=()=>{this._ready=!0,this.releaseGeometryInstances&&(this.geometryInstances=void 0);let r=this._error;u(r)?o(r):i(this)}}),this._primitive=void 0,this._sp=void 0,this._sp2D=void 0,this._spMorph=void 0,this._renderState=c$(!1),this._renderState3DTiles=c$(!0),this._renderStateMorph=ke.fromCache({cull:{enabled:!0,face:_i.FRONT},depthTest:{enabled:!0},blending:an.PRE_MULTIPLIED_ALPHA_BLEND,depthMask:!1})}Object.defineProperties(Im.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}},readyPromise:{get:function(){return this._readyPromise}},debugShowShadowVolume:{get:function(){return this._debugShowShadowVolume}}});Im.initializeTerrainHeights=function(){return ni.initialize()};function gDe(e,t,n){let i=t.context,o=e._primitive,r=o._attributeLocations,s=o._batchTable.getVertexShaderCallback()(ZD);s=xn._appendShowToShader(o,s),s=xn._appendDistanceDisplayConditionToShader(o,s),s=xn._modifyShaderPosition(e,s,t.scene3DOnly);let a=o._batchTable.getVertexShaderCallback()(JD);a=xn._appendShowToShader(o,a),a=xn._appendDistanceDisplayConditionToShader(o,a),a=xn._modifyShaderPosition(e,a,t.scene3DOnly);let c=o._batchTable.getVertexShaderCallback()(XD),l=[`GLOBE_MINIMUM_ALTITUDE ${t.mapProjection.ellipsoid.minimumRadius.toFixed(1)}`],f="",d="";u(n.material)?(d=u(n.material)?n.material.shaderSource:"",d.search(/varying\s+float\s+v_polylineAngle;/g)!==-1&&l.push("ANGLE_VARYING"),d.search(/varying\s+float\s+v_width;/g)!==-1&&l.push("WIDTH_VARYING")):f="PER_INSTANCE_COLOR",l.push(f);let p=e.debugShowShadowVolume?["DEBUG_SHOW_VOLUME",f]:[f],g=new Ue({defines:l,sources:[s]}),m=new Ue({defines:p,sources:[d,c]});e._sp=jt.replaceCache({context:i,shaderProgram:o._sp,vertexShaderSource:g,fragmentShaderSource:m,attributeLocations:r});let A=i.shaderCache.getDerivedShaderProgram(e._sp,"2dColor");if(!u(A)){let C=new Ue({defines:l.concat(["COLUMBUS_VIEW_2D"]),sources:[s]});A=i.shaderCache.createDerivedShaderProgram(e._sp,"2dColor",{context:i,shaderProgram:e._sp2D,vertexShaderSource:C,fragmentShaderSource:m,attributeLocations:r})}e._sp2D=A;let x=i.shaderCache.getDerivedShaderProgram(e._sp,"MorphColor");if(!u(x)){let C=new Ue({defines:l.concat([`MAX_TERRAIN_HEIGHT ${ni._defaultMaxTerrainHeight.toFixed(1)}`]),sources:[a]});c=o._batchTable.getVertexShaderCallback()(KD);let T=new Ue({defines:p,sources:[d,c]});x=i.shaderCache.createDerivedShaderProgram(e._sp,"MorphColor",{context:i,shaderProgram:e._spMorph,vertexShaderSource:C,fragmentShaderSource:T,attributeLocations:r})}e._spMorph=x}function c$(e){return ke.fromCache({cull:{enabled:!0},blending:an.PRE_MULTIPLIED_ALPHA_BLEND,depthMask:!1,stencilTest:{enabled:e,frontFunction:Nn.EQUAL,frontOperation:{fail:at.KEEP,zFail:at.KEEP,zPass:at.KEEP},backFunction:Nn.EQUAL,backOperation:{fail:at.KEEP,zFail:at.KEEP,zPass:at.KEEP},reference:vt.CESIUM_3D_TILE_MASK,mask:vt.CESIUM_3D_TILE_MASK}})}function yDe(e,t,n,i,o,r){let s=e._primitive,a=s._va.length;o.length=a,r.length=a;let l=t instanceof Br?{}:n._uniforms,f=s._batchTable.getUniformMapCallback()(l);for(let d=0;d (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)
+ {
+ gl_FragColor = texture2D(texture0, uv);
+ }
+ else if(mipLevel == 1.0)
+ {
+ gl_FragColor = texture2D(texture1, uv);
+ }
+ else if(mipLevel == 2.0)
+ {
+ gl_FragColor = texture2D(texture2, uv);
+ }
+ else if(mipLevel == 3.0)
+ {
+ gl_FragColor = texture2D(texture3, uv);
+ }
+ else if(mipLevel == 4.0)
+ {
+ gl_FragColor = texture2D(texture4, uv);
+ }
+ else if(mipLevel == 5.0)
+ {
+ gl_FragColor = texture2D(texture5, uv);
+ }
+ else
+ {
+ gl_FragColor = vec4(0.0);
+ }
+}
+`;var xP=`varying vec3 v_cubeMapCoordinates;
+uniform samplerCube cubeMap;
+
+void main()
+{
+ vec4 rgba = textureCube(cubeMap, v_cubeMapCoordinates);
+ #ifdef RGBA_NORMALIZED
+ gl_FragColor = vec4(rgba.rgb, 1.0);
+ #else
+ float m = rgba.a * 16.0;
+ vec3 r = rgba.rgb * m;
+ gl_FragColor = vec4(r * r, 1.0);
+ #endif
+}
+`;var CP=`attribute vec4 position;
+attribute vec3 cubeMapCoordinates;
+
+varying vec3 v_cubeMapCoordinates;
+
+void main()
+{
+ gl_Position = position;
+ v_cubeMapCoordinates = cubeMapCoordinates;
+}
+`;function w0(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;let t=this;this._readyPromise=new Promise((n,i)=>{t._completeLoadFromCache=o=>{QH(this),this._texture=o,this._maximumMipmapLevel=this._texture.maximumMipmapLevel,this._ready=!0,n()},t._failLoad=o=>{i(o)},t._completeLoad=()=>{this._ready=!0,n()}})}Object.defineProperties(w0.prototype,{url:{get:function(){return this._url}},texture:{get:function(){return this._texture}},maximumMipmapLevel:{get:function(){return this._maximumMipmapLevel}},ready:{get:function(){return this._ready}},readyPromise:{get:function(){return this._readyPromise}}});w0.isSupported=function(e){return e.colorBufferHalfFloat&&e.halfFloatingPointTexture||e.floatingPointTexture&&e.colorBufferFloat};var ePe=new h(1,0,0),tPe=new h(0,0,1),nPe=new h(-1,0,0),iPe=new h(0,0,-1),d3=new h(0,1,0),oPe=new h(0,-1,0),b$=[d3,nPe,tPe,oPe,ePe,d3,iPe,d3,d3],S$=b$.length,w$=new Float32Array(S$*3),T$=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 u(this._sphericalHarmonicCoefficients)||this._useDefaultSphericalHarmonics}},specularEnvironmentMapAtlas:{get:function(){return this._specularEnvironmentMapAtlas}},useDefaultSpecularMaps:{get:function(){return this._useDefaultSpecularMaps}},useSpecularEnvironmentMaps:{get:function(){return u(this._specularEnvironmentMapAtlas)&&this._specularEnvironmentMapAtlas.ready||this._useDefaultSpecularMaps}}});function cPe(e,t){if(!!qf.isSupported(t)){if(e._specularEnvironmentMapAtlas=e._specularEnvironmentMapAtlas&&e._specularEnvironmentMapAtlas.destroy(),u(e._specularEnvironmentMaps)){let n=new qf(e._specularEnvironmentMaps);e._specularEnvironmentMapAtlas=n,n.readyPromise.then(function(){e._specularEnvironmentMapLoaded=!0}).catch(function(i){console.error(`Error loading specularEnvironmentMaps: ${i}`)})}e._shouldRegenerateShaders=!0}}TP.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;H.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=H.clone(this._imageBasedLightingFactor,this._previousImageBasedLightingFactor)),this._luminanceAtZenith!==this._previousLuminanceAtZenith&&(this._shouldRegenerateShaders=this._shouldRegenerateShaders||u(this._luminanceAtZenith)!==u(this._previousLuminanceAtZenith),this._previousLuminanceAtZenith=this._luminanceAtZenith),this._previousSphericalHarmonicCoefficients!==this._sphericalHarmonicCoefficients&&(this._shouldRegenerateShaders=this._shouldRegenerateShaders||u(this._previousSphericalHarmonicCoefficients)!==u(this._sphericalHarmonicCoefficients),this._previousSphericalHarmonicCoefficients=this._sphericalHarmonicCoefficients),this._shouldRegenerateShaders=this._shouldRegenerateShaders||this._previousSpecularEnvironmentMapLoaded!==this._specularEnvironmentMapLoaded,this._previousSpecularEnvironmentMapLoaded=this._specularEnvironmentMapLoaded,this._specularEnvironmentMapAtlasDirty&&(cPe(this,t),this._specularEnvironmentMapAtlasDirty=!1),u(this._specularEnvironmentMapAtlas)&&this._specularEnvironmentMapAtlas.update(e);let o=!u(this._specularEnvironmentMapAtlas)&&u(e.specularEnvironmentMaps)&&!this._useDefaultSpecularMaps,r=!u(e.specularEnvironmentMaps)&&this._useDefaultSpecularMaps,s=!u(this._sphericalHarmonicCoefficients)&&u(e.sphericalHarmonicCoefficients)&&!this._useDefaultSphericalHarmonics,a=!u(e.sphericalHarmonicCoefficients)&&this._useDefaultSphericalHarmonics;this._shouldRegenerateShaders=this._shouldRegenerateShaders||o||r||s||a,this._useDefaultSpecularMaps=!u(this._specularEnvironmentMapAtlas)&&u(e.specularEnvironmentMaps),this._useDefaultSphericalHarmonics=!u(this._sphericalHarmonicCoefficients)&&u(e.sphericalHarmonicCoefficients)};TP.prototype.isDestroyed=function(){return!1};TP.prototype.destroy=function(){return this._specularEnvironmentMapAtlas=this._specularEnvironmentMapAtlas&&this._specularEnvironmentMapAtlas.destroy(),le(this)};var v0=TP;function hh(e){e=y(e,0),this._array=new Array(e),this._length=e}Object.defineProperties(hh.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}}});hh.prototype.get=function(e){return this._array[e]};hh.prototype.set=function(e,t){e>=this._length&&(this.length=e+1),this._array[e]=t};hh.prototype.peek=function(){return this._array[this._length-1]};hh.prototype.push=function(e){let t=this.length++;this._array[t]=e};hh.prototype.pop=function(){if(this._length===0)return;let e=this._array[this._length-1];return--this.length,e};hh.prototype.reserve=function(e){e>this._array.length&&(this._array.length=e)};hh.prototype.resize=function(e){this.length=e};hh.prototype.trim=function(e){e=y(e,this._length),this._array.length=e};var Ll=hh;function h3(e){e=y(e,y.EMPTY_OBJECT),this.color=e.color,this.depth=e.depth,this.stencil=e.stencil,this.renderState=e.renderState,this.framebuffer=e.framebuffer,this.owner=e.owner,this.pass=e.pass}h3.ALL=Object.freeze(new h3({color:new z(0,0,0,0),depth:1,stencil:0}));h3.prototype.execute=function(e,t){e.clear(this,t)};var Qn=h3;var km={X:0,Y:1,Z:2};km.Y_UP_TO_Z_UP=F.fromRotationTranslation(Q.fromRotationX(I.PI_OVER_TWO));km.Z_UP_TO_Y_UP=F.fromRotationTranslation(Q.fromRotationX(-I.PI_OVER_TWO));km.X_UP_TO_Z_UP=F.fromRotationTranslation(Q.fromRotationY(-I.PI_OVER_TWO));km.Z_UP_TO_X_UP=F.fromRotationTranslation(Q.fromRotationY(I.PI_OVER_TWO));km.X_UP_TO_Y_UP=F.fromRotationTranslation(Q.fromRotationZ(I.PI_OVER_TWO));km.Y_UP_TO_X_UP=F.fromRotationTranslation(Q.fromRotationZ(-I.PI_OVER_TWO));km.fromName=function(e){return km[e]};var bo=Object.freeze(km);function Ou(e){this.planes=y(e,[])}var EP=[new h,new h,new h];h.clone(h.UNIT_X,EP[0]);h.clone(h.UNIT_Y,EP[1]);h.clone(h.UNIT_Z,EP[2]);var k_=new h,lPe=new h,v$=new nn(new h(1,0,0),0);Ou.fromBoundingSphere=function(e,t){u(t)||(t=new Ou);let n=EP.length,i=t.planes;i.length=2*n;let o=e.center,r=e.radius,s=0;for(let a=0;a>10)+55296,(r&1023)+56320))}return t};function bP(e,t,n){return t<=e&&e<=n}function hPe(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,Nt.maximumTextureSize),r=Math.ceil(t/Nt.maximumTextureSize),s=1/o,a=s*.5,c=1/r,l=c*.5;n=new H(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(Oa.prototype,{translucentFeaturesLength:{get:function(){return this._translucentFeaturesLength}},byteLength:{get:function(){let e=0;return u(this._pickTexture)&&(e+=this._pickTexture.sizeInBytes),u(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}}});Oa.DEFAULT_COLOR_VALUE=z.WHITE;Oa.DEFAULT_SHOW_VALUE=!0;function I$(e){let t=e._textureDimensions;return t.x*t.y*4}function O$(e){if(!u(e._batchValues)){let t=I$(e),n=new Uint8Array(t).fill(255);e._batchValues=n}return e._batchValues}function B$(e){if(!u(e._showAlphaProperties)){let t=2*e._featuresLength,n=new Uint8Array(t).fill(255);e._showAlphaProperties=n}return e._showAlphaProperties}Oa.prototype.setShow=function(e,t){if(t&&!u(this._showAlphaProperties))return;let n=B$(this),i=e*2,o=t?255:0;if(n[i]!==o){n[i]=o;let r=O$(this),s=e*4+3;r[s]=t?n[i+1]:0,this._batchValuesDirty=!0}};Oa.prototype.setAllShow=function(e){let t=this._featuresLength;for(let n=0;n0){let i=e._pickIds,o=I$(e),r=new Uint8Array(o),s=e._owner,a=e._statistics;for(let c=0;c0;){if(t=f.pop(),c[t]===l)continue;c[t]=l;let d=n(e,t);if(u(d))return d;let p=o[t],g=s[t];for(let m=0;m0?(s="",e&&(s+=`uniform bool tile_translucentCommand;
+`),s+=`uniform sampler2D tile_batchTexture;
+varying vec4 tile_featureColor;
+varying vec2 tile_featureSt;
+void main()
+{
+ vec2 st = computeSt(${t});
+ vec4 featureProperties = texture2D(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=`varying vec2 tile_featureSt;
+void main()
+{
+ tile_color(vec4(1.0));
+ tile_featureSt = computeSt(${t});
+}`,`${r}
+${UPe(i)}${s}`}};function M$(e,t){return e=Ue.replaceMain(e,"tile_main"),t?`${e}uniform float tile_colorBlend;
+void tile_color(vec4 tile_featureColor)
+{
+ tile_main();
+ tile_featureColor = czm_gammaCorrect(tile_featureColor);
+ gl_FragColor.a *= tile_featureColor.a;
+ float highlight = ceil(tile_colorBlend);
+ gl_FragColor.rgb *= mix(tile_featureColor.rgb, vec3(1.0), highlight);
+}
+`:`${e}void tile_color(vec4 tile_featureColor)
+{
+ tile_main();
+}
+`}function zPe(e,t){let n=`texture2D(${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;
+varying vec2 tile_featureSt;
+varying vec4 tile_featureColor;
+void main()
+{
+ tile_color(tile_featureColor);
+`,n&&(i+=` gl_FragColor.rgb *= gl_FragColor.a;
+`),i+="}"):(e&&(i+=`uniform bool tile_translucentCommand;
+`),i+=`uniform sampler2D tile_pickTexture;
+uniform sampler2D tile_batchTexture;
+varying vec2 tile_featureSt;
+void main()
+{
+ vec4 featureProperties = texture2D(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+=` gl_FragColor.rgb *= gl_FragColor.a;
+`),i+=`}
+`),i}};oo.prototype.getClassificationFragmentShaderCallback=function(){if(this.featuresLength!==0)return function(e){return e=Ue.replaceMain(e,"tile_main"),Nt.maximumVertexTextureImageUnits>0?e+=`uniform sampler2D tile_pickTexture;
+varying vec2 tile_featureSt;
+varying vec4 tile_featureColor;
+void main()
+{
+ tile_main();
+ gl_FragColor = tile_featureColor;
+ gl_FragColor.rgb *= gl_FragColor.a;
+}`:e+=`uniform sampler2D tile_batchTexture;
+uniform sampler2D tile_pickTexture;
+varying vec2 tile_featureSt;
+void main()
+{
+ tile_main();
+ vec4 featureProperties = texture2D(tile_batchTexture, tile_featureSt);
+ if (featureProperties.a == 0.0) {
+ discard;
+ }
+ gl_FragColor = featureProperties;
+ gl_FragColor.rgb *= gl_FragColor.a;
+}
+`,e}};function GPe(e){let t=e._content.tileset,n=t.colorBlendMode,i=t.colorBlendAmount;if(n===ol.HIGHLIGHT)return 0;if(n===ol.REPLACE)return 1;if(n===ol.MIX)return I.clamp(i,I.EPSILON4,1)}oo.prototype.getUniformMapCallback=function(){if(this.featuresLength===0)return;let e=this;return function(t){return _t(t,{tile_batchTexture:function(){return y(e._batchTexture.batchTexture,e._batchTexture.defaultTexture)},tile_textureDimensions:function(){return e._batchTexture.textureDimensions},tile_textureStep:function(){return e._batchTexture.textureStep},tile_colorBlend:function(){return GPe(e)},tile_pickTexture:function(){return e._batchTexture.pickTexture}})}};oo.prototype.getPickId=function(){return"texture2D(tile_pickTexture, tile_featureSt)"};var U_={ALL_OPAQUE:0,ALL_TRANSLUCENT:1,OPAQUE_AND_TRANSLUCENT:2};oo.prototype.addDerivedCommands=function(e,t){let n=e.commandList,i=n.length,o=this._content._tile,r=o._finalResolution,s=o.tileset,a=s._skipLevelOfDetail&&s._hasMixedContent&&e.context.stencilBuffer,c=HPe(this);for(let l=t;l>>vt.SKIP_LOD_BIT_SHIFT}function ZPe(e){let t=nt(e,!0);return t.cull.enabled=!1,t.depthTest.enabled=!0,t.depthMask=!1,t.blending=an.ALPHA_BLEND,t.stencilTest=vt.setCesium3DTileBit(),t.stencilMask=vt.CESIUM_3D_TILE_MASK,ke.fromCache(t)}function QPe(e){let t=nt(e,!0);return t.stencilTest=vt.setCesium3DTileBit(),t.stencilMask=vt.CESIUM_3D_TILE_MASK,ke.fromCache(t)}oo.prototype.update=function(e,t){this._batchTexture.update(e,t)};oo.prototype.isDestroyed=function(){return!1};oo.prototype.destroy=function(){return this._batchTexture=this._batchTexture&&this._batchTexture.destroy(),le(this)};var zm=oo;function $Pe(e){this.offset=e.offset,this.count=e.count,this.color=e.color,this.batchIds=e.batchIds}var ph=$Pe;var kC=`attribute vec3 position;
+attribute float a_batchId;
+
+uniform mat4 u_modifiedModelViewProjection;
+
+void main()
+{
+ gl_Position = czm_depthClamp(u_modifiedModelViewProjection * vec4(position, 1.0));
+}
+`;function Bu(e,t){this._content=e,this._batchId=t,this._color=void 0}Object.defineProperties(Bu.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 u(this._color)||(this._color=new z),this._content.batchTable.getColor(this._batchId,this._color)},set:function(e){this._content.batchTable.setColor(this._batchId,e)}},polylinePositions:{get:function(){if(!!u(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)}}});Bu.prototype.hasProperty=function(e){return this._content.batchTable.hasProperty(this._batchId,e)};Bu.prototype.getPropertyIds=function(e){return this._content.batchTable.getPropertyIds(this._batchId,e)};Bu.prototype.getProperty=function(e){return this._content.batchTable.getProperty(this._batchId,e)};Bu.getPropertyInherited=function(e,t,n){let i=e.batchTable;if(u(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(u(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(u(s)){if(s.hasPropertyBySemantic(n))return s.getPropertyBySemantic(n);if(s.hasProperty(n))return s.getProperty(n)}let a;if(u(r.implicitSubtree)&&(a=r.implicitSubtree.metadata),u(a)){if(a.hasPropertyBySemantic(n))return a.getPropertyBySemantic(n);if(a.hasProperty(n))return a.getProperty(n)}let c=u(e.group)?e.group.metadata:void 0;if(u(c)){if(c.hasPropertyBySemantic(n))return c.getPropertyBySemantic(n);if(c.hasProperty(n))return c.getProperty(n)}let l=e.tileset.metadata;if(u(l)){if(l.hasPropertyBySemantic(n))return l.getPropertyBySemantic(n);if(l.hasProperty(n))return l.getProperty(n)}};Bu.prototype.getPropertyInherited=function(e){return Bu.getPropertyInherited(this._content,this._batchId,e)};Bu.prototype.setProperty=function(e,t){this._content.batchTable.setProperty(this._batchId,e,t),this._content.featurePropertiesDirty=!0};Bu.prototype.isExactClass=function(e){return this._content.batchTable.isExactClass(this._batchId,e)};Bu.prototype.isClass=function(e){return this._content.batchTable.isClass(this._batchId,e)};Bu.prototype.getExactClassName=function(){return this._content.batchTable.getExactClassName(this._batchId)};var fs=Bu;var g3=ho(N$(),1);var e1e={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},ut=Object.freeze(e1e);function Xf(e,t){this._expression=e,e=h1e(e,t),e=p1e(m1e(e)),g3.default.addBinaryOp("=~",0),g3.default.addBinaryOp("!~",0);let n;try{n=(0,g3.default)(e)}catch(i){throw new de(i)}this._runtimeAst=fi(this,n)}Object.defineProperties(Xf.prototype,{expression:{get:function(){return this._expression}}});var wn={arrayIndex:0,arrayArray:[[]],cartesian2Index:0,cartesian3Index:0,cartesian4Index:0,cartesian2Array:[new H],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 H),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++]}};Xf.prototype.evaluate=function(e,t){wn.reset();let n=this._runtimeAst.evaluate(e);return t instanceof z&&n instanceof se?z.fromCartesian4(n,t):n instanceof H||n instanceof h||n instanceof se?n.clone(t):n};Xf.prototype.evaluateColor=function(e,t){wn.reset();let n=this._runtimeAst.evaluate(e);return z.fromCartesian4(n,t)};Xf.prototype.getShaderFunction=function(e,t,n,i){let o=this.getShaderExpression(t,n);return o=`${i} ${e}
+{
+ return ${o};
+}
+`,o};Xf.prototype.getShaderExpression=function(e,t){return this._runtimeAst.getShaderExpression(e,t)};Xf.prototype.getVariables=function(){let e=[];return this._runtimeAst.getVariables(e),e=e.filter(function(t,n,i){return i.indexOf(t)===n}),e};var t1e=["!","-","+"],k$=["+","-","*","/","%","===","!==",">",">=","<","<=","&&","||","!~","=~"],y3=/\${(.*?)}/g,n1e=/\\/g,i1e="@#%",o1e=/@#%/g,A3=new z,x3={abs:ds(Math.abs),sqrt:ds(Math.sqrt),cos:ds(Math.cos),sin:ds(Math.sin),tan:ds(Math.tan),acos:ds(Math.acos),asin:ds(Math.asin),atan:ds(Math.atan),radians:ds(I.toRadians),degrees:ds(I.toDegrees),sign:ds(I.sign),floor:ds(Math.floor),ceil:ds(Math.ceil),round:ds(Math.round),exp:ds(Math.exp),exp2:ds(s1e),log:ds(Math.log),log2:ds(a1e),fract:ds(r1e),length:c1e,normalize:l1e},C3={atan2:p3(Math.atan2,!1),pow:p3(Math.pow,!1),min:p3(Math.min,!0),max:p3(Math.max,!0),distance:u1e,dot:f1e,cross:d1e},o8={clamp:V$(I.clamp,!0),mix:V$(I.lerp,!0)};function r1e(e){return e-Math.floor(e)}function s1e(e){return Math.pow(2,e)}function a1e(e){return I.log2(e)}function ds(e){return function(t,n){if(typeof n=="number")return e(n);if(n instanceof H)return H.fromElements(e(n.x),e(n.y),wn.getCartesian2());if(n instanceof h)return h.fromElements(e(n.x),e(n.y),e(n.z),wn.getCartesian3());if(n instanceof se)return se.fromElements(e(n.x),e(n.y),e(n.z),e(n.w),wn.getCartesian4());throw new de(`Function "${t}" requires a vector or number argument. Argument is ${n}.`)}}function p3(e,t){return function(n,i,o){if(t&&typeof o=="number"){if(typeof i=="number")return e(i,o);if(i instanceof H)return H.fromElements(e(i.x,o),e(i.y,o),wn.getCartesian2());if(i instanceof h)return h.fromElements(e(i.x,o),e(i.y,o),e(i.z,o),wn.getCartesian3());if(i instanceof se)return se.fromElements(e(i.x,o),e(i.y,o),e(i.z,o),e(i.w,o),wn.getCartesian4())}if(typeof i=="number"&&typeof o=="number")return e(i,o);if(i instanceof H&&o instanceof H)return H.fromElements(e(i.x,o.x),e(i.y,o.y),wn.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),wn.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),wn.getCartesian4());throw new de(`Function "${n}" requires vector or number arguments of matching types. Arguments are ${i} and ${o}.`)}}function V$(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 H&&o instanceof H)return H.fromElements(e(i.x,o.x,r),e(i.y,o.y,r),wn.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),wn.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),wn.getCartesian4())}if(typeof i=="number"&&typeof o=="number"&&typeof r=="number")return e(i,o,r);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),wn.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),wn.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),wn.getCartesian4());throw new de(`Function "${n}" requires vector or number arguments of matching types. Arguments are ${i}, ${o}, and ${r}.`)}}function c1e(e,t){if(typeof t=="number")return Math.abs(t);if(t instanceof H)return H.magnitude(t);if(t instanceof h)return h.magnitude(t);if(t instanceof se)return se.magnitude(t);throw new de(`Function "${e}" requires a vector or number argument. Argument is ${t}.`)}function l1e(e,t){if(typeof t=="number")return 1;if(t instanceof H)return H.normalize(t,wn.getCartesian2());if(t instanceof h)return h.normalize(t,wn.getCartesian3());if(t instanceof se)return se.normalize(t,wn.getCartesian4());throw new de(`Function "${e}" requires a vector or number argument. Argument is ${t}.`)}function u1e(e,t,n){if(typeof t=="number"&&typeof n=="number")return Math.abs(t-n);if(t instanceof H&&n instanceof H)return H.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 de(`Function "${e}" requires vector or number arguments of matching types. Arguments are ${t} and ${n}.`)}function f1e(e,t,n){if(typeof t=="number"&&typeof n=="number")return t*n;if(t instanceof H&&n instanceof H)return H.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 de(`Function "${e}" requires vector or number arguments of matching types. Arguments are ${t} and ${n}.`)}function d1e(e,t,n){if(t instanceof h&&n instanceof h)return h.cross(t,n,wn.getCartesian3());throw new de(`Function "${e}" requires vec3 arguments. Arguments are ${t} and ${n}.`)}function ht(e,t,n,i,o){this._type=e,this._value=t,this._left=n,this._right=i,this._test=o,this.evaluate=void 0,S1e(this)}function h1e(e,t){if(!u(t))return e;for(let n in t)if(t.hasOwnProperty(n)){let i=new RegExp(`\\$\\{${n}\\}`,"g"),o=`(${t[n]})`;u(o)&&(e=e.replace(i,o))}return e}function m1e(e){return e.replace(n1e,i1e)}function i8(e){return e.replace(o1e,"\\")}function p1e(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 ht(ut.VARIABLE_IN_STRING,e.value):new ht(ut.LITERAL_STRING,i8(e.value))}function g1e(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(c.callee.name!=="regExp")throw new de(`${o} is not a function.`);return i===0?o==="test"?new ht(ut.LITERAL_BOOLEAN,!1):new ht(ut.LITERAL_NULL,null):(s=fi(e,c),a=fi(e,n[0]),new ht(ut.FUNCTION_CALL,o,s,a))}else if(o==="toString")return r=fi(e,c),new ht(ut.FUNCTION_CALL,o,r);throw new de(`Unexpected function call "${o}".`)}if(o=t.callee.name,o==="color"){if(i===0)return new ht(ut.LITERAL_COLOR,o);if(r=fi(e,n[0]),u(n[1])){let c=fi(e,n[1]);return new ht(ut.LITERAL_COLOR,o,[r,c])}return new ht(ut.LITERAL_COLOR,o,[r])}else if(o==="rgb"||o==="hsl"){if(i<3)throw new de(`${o} requires three arguments.`);return r=[fi(e,n[0]),fi(e,n[1]),fi(e,n[2])],new ht(ut.LITERAL_COLOR,o,r)}else if(o==="rgba"||o==="hsla"){if(i<4)throw new de(`${o} requires four arguments.`);return r=[fi(e,n[0]),fi(e,n[1]),fi(e,n[2]),fi(e,n[3])],new ht(ut.LITERAL_COLOR,o,r)}else if(o==="vec2"||o==="vec3"||o==="vec4"){r=new Array(i);for(let c=0;c1)throw new de(`${o} requires exactly one argument.`);return r=fi(e,n[0]),new ht(ut.UNARY,o,r)}else if(o==="getExactClassName"){if(i>0)throw new de(`${o} does not take any argument.`);return new ht(ut.UNARY,o)}else if(u(x3[o])){if(i!==1)throw new de(`${o} requires exactly one argument.`);return r=fi(e,n[0]),new ht(ut.UNARY,o,r)}else if(u(C3[o])){if(i!==2)throw new de(`${o} requires exactly two arguments.`);return s=fi(e,n[0]),a=fi(e,n[1]),new ht(ut.BINARY,o,s,a)}else if(u(o8[o])){if(i!==3)throw new de(`${o} requires exactly three arguments.`);s=fi(e,n[0]),a=fi(e,n[1]);let c=fi(e,n[2]);return new ht(ut.TERNARY,o,s,a,c)}else{if(o==="Boolean")return i===0?new ht(ut.LITERAL_BOOLEAN,!1):(r=fi(e,n[0]),new ht(ut.UNARY,o,r));if(o==="Number")return i===0?new ht(ut.LITERAL_NUMBER,0):(r=fi(e,n[0]),new ht(ut.UNARY,o,r));if(o==="String")return i===0?new ht(ut.LITERAL_STRING,""):(r=fi(e,n[0]),new ht(ut.UNARY,o,r));if(o==="regExp")return y1e(e,t)}}throw new de(`Unexpected function call "${o}".`)}function y1e(e,t){let n=t.arguments;if(n.length===0)return new ht(ut.LITERAL_REGEX,new RegExp);let i=fi(e,n[0]),o;if(n.length>1){let r=fi(e,n[1]);if(n8(i)&&n8(r)){try{o=new RegExp(i8(String(i._value)),r._value)}catch(s){throw new de(s)}return new ht(ut.LITERAL_REGEX,o)}return new ht(ut.REGEX,i,r)}if(n8(i)){try{o=new RegExp(i8(String(i._value)))}catch(r){throw new de(r)}return new ht(ut.LITERAL_REGEX,o)}return new ht(ut.REGEX,i)}function A1e(e){if(E1e(e.name)){let t=b1e(e.name);return t.substr(0,8)==="tiles3d_"?new ht(ut.BUILTIN_VARIABLE,t):new ht(ut.VARIABLE,t)}else{if(e.name==="NaN")return new ht(ut.LITERAL_NUMBER,NaN);if(e.name==="Infinity")return new ht(ut.LITERAL_NUMBER,1/0);if(e.name==="undefined")return new ht(ut.LITERAL_UNDEFINED,void 0)}throw new de(`${e.name} is not defined.`)}function x1e(e){let t=e.property.name;if(t==="PI")return new ht(ut.LITERAL_NUMBER,Math.PI);if(t==="E")return new ht(ut.LITERAL_NUMBER,Math.E)}function C1e(e){if(e.property.name==="POSITIVE_INFINITY")return new ht(ut.LITERAL_NUMBER,Number.POSITIVE_INFINITY)}function T1e(e,t){if(t.object.name==="Math")return x1e(t);if(t.object.name==="Number")return C1e(t);let n,i=fi(e,t.object);return t.computed?(n=fi(e,t.property),new ht(ut.MEMBER,"brackets",i,n)):(n=new ht(ut.LITERAL_STRING,t.property.name),new ht(ut.MEMBER,"dot",i,n))}function n8(e){return e._type>=ut.LITERAL_NULL}function E1e(e){return e.substr(0,4)==="czm_"}function b1e(e){return e.substr(4)}function fi(e,t){let n,i,o,r;if(t.type==="Literal")n=_1e(t);else if(t.type==="CallExpression")n=g1e(e,t);else if(t.type==="Identifier")n=A1e(t);else if(t.type==="UnaryExpression"){i=t.operator;let s=fi(e,t.argument);if(t1e.indexOf(i)>-1)n=new ht(ut.UNARY,i,s);else throw new de(`Unexpected operator "${i}".`)}else if(t.type==="BinaryExpression")if(i=t.operator,o=fi(e,t.left),r=fi(e,t.right),k$.indexOf(i)>-1)n=new ht(ut.BINARY,i,o,r);else throw new de(`Unexpected operator "${i}".`);else if(t.type==="LogicalExpression")i=t.operator,o=fi(e,t.left),r=fi(e,t.right),k$.indexOf(i)>-1&&(n=new ht(ut.BINARY,i,o,r));else if(t.type==="ConditionalExpression"){let s=fi(e,t.test);o=fi(e,t.consequent),r=fi(e,t.alternate),n=new ht(ut.CONDITIONAL,"?",o,r,s)}else if(t.type==="MemberExpression")n=T1e(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:u(C3[e._value])&&(e.evaluate=D1e(e._value)):e._type===ut.TERNARY?e.evaluate=P1e(e._value):e._type===ut.MEMBER?e._value==="brackets"?e.evaluate=e._evaluateMemberBrackets:e.evaluate=e._evaluateMemberDot:e._type===ut.ARRAY?e.evaluate=e._evaluateArray:e._type===ut.VARIABLE?e.evaluate=e._evaluateVariable:e._type===ut.VARIABLE_IN_STRING?e.evaluate=e._evaluateVariableString:e._type===ut.LITERAL_COLOR?e.evaluate=e._evaluateLiteralColor:e._type===ut.LITERAL_VECTOR?e.evaluate=e._evaluateLiteralVector:e._type===ut.LITERAL_STRING?e.evaluate=e._evaluateLiteralString:e._type===ut.REGEX?e.evaluate=e._evaluateRegExp:e._type===ut.BUILTIN_VARIABLE?e._value==="tiles3d_tileset_time"&&(e.evaluate=w1e):e.evaluate=e._evaluateLiteral}function w1e(e){return u(e)?e.content.tileset.timeSinceLoad:0}function v1e(e){let t=x3[e];return function(n){let i=this._left.evaluate(n);return t(e,i)}}function D1e(e){let t=C3[e];return function(n){let i=this._left.evaluate(n),o=this._right.evaluate(n);return t(e,i,o)}}function P1e(e){let t=o8[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 T3(e,t){if(u(e))return e.getPropertyInherited(t)}ht.prototype._evaluateLiteral=function(){return this._value};ht.prototype._evaluateLiteralColor=function(e){let t=A3,n=this._left;if(this._value==="color")u(n)?n.length>1?(z.fromCssColorString(n[0].evaluate(e),t),t.alpha=n[1].evaluate(e)):z.fromCssColorString(n[0].evaluate(e),t):z.fromBytes(255,255,255,255,t);else if(this._value==="rgb")z.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;z.fromBytes(n[0].evaluate(e),n[1].evaluate(e),n[2].evaluate(e),i,t)}else this._value==="hsl"?z.fromHsl(n[0].evaluate(e),n[1].evaluate(e),n[2].evaluate(e),1,t):this._value==="hsla"&&z.fromHsl(n[0].evaluate(e),n[1].evaluate(e),n[2].evaluate(e),n[3].evaluate(e),t);return se.fromColor(t,wn.getCartesian4())};ht.prototype._evaluateLiteralVector=function(e){let t=wn.getArray(),n=this._value,i=this._left,o=i.length;for(let a=0;a1)throw new de(`Invalid ${n} constructor. Not enough arguments.`);if(r>s&&o>1)throw new de(`Invalid ${n} constructor. Too many arguments.`);if(r===1){let a=t[0];t.push(a,a,a)}if(n==="vec2")return H.fromArray(t,0,wn.getCartesian2());if(n==="vec3")return h.fromArray(t,0,wn.getCartesian3());if(n==="vec4")return se.fromArray(t,0,wn.getCartesian4())};ht.prototype._evaluateLiteralString=function(){return this._value};ht.prototype._evaluateVariableString=function(e){let t=this._value,n=y3.exec(t);for(;n!==null;){let i=n[0],o=n[1],r=T3(e,o);u(r)||(r=""),t=t.replace(i,r),n=y3.exec(t)}return t};ht.prototype._evaluateVariable=function(e){return T3(e,this._value)};function O0(e){return e._value==="feature"}ht.prototype._evaluateMemberDot=function(e){if(O0(this._left))return T3(e,this._right.evaluate(e));let t=this._left.evaluate(e);if(!u(t))return;let n=this._right.evaluate(e);if(t instanceof H||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]};ht.prototype._evaluateMemberBrackets=function(e){if(O0(this._left))return T3(e,this._right.evaluate(e));let t=this._left.evaluate(e);if(!u(t))return;let n=this._right.evaluate(e);if(t instanceof H||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]};ht.prototype._evaluateArray=function(e){let t=[];for(let n=0;n" requires number arguments. Arguments are ${t} and ${n}.`);return t>n};ht.prototype._evaluateGreaterThanOrEquals=function(e){let t=this._left.evaluate(e),n=this._right.evaluate(e);if(typeof t!="number"||typeof n!="number")throw new de(`Operator ">=" requires number arguments. Arguments are ${t} and ${n}.`);return t>=n};ht.prototype._evaluateOr=function(e){let t=this._left.evaluate(e);if(typeof t!="boolean")throw new de(`Operator "||" requires boolean arguments. First argument is ${t}.`);if(t)return!0;let n=this._right.evaluate(e);if(typeof n!="boolean")throw new de(`Operator "||" requires boolean arguments. Second argument is ${n}.`);return t||n};ht.prototype._evaluateAnd=function(e){let t=this._left.evaluate(e);if(typeof t!="boolean")throw new de(`Operator "&&" requires boolean arguments. First argument is ${t}.`);if(!t)return!1;let n=this._right.evaluate(e);if(typeof n!="boolean")throw new de(`Operator "&&" requires boolean arguments. Second argument is ${n}.`);return t&&n};ht.prototype._evaluatePlus=function(e){let t=this._left.evaluate(e),n=this._right.evaluate(e);if(n instanceof H&&t instanceof H)return H.add(t,n,wn.getCartesian2());if(n instanceof h&&t instanceof h)return h.add(t,n,wn.getCartesian3());if(n instanceof se&&t instanceof se)return se.add(t,n,wn.getCartesian4());if(typeof t=="string"||typeof n=="string")return t+n;if(typeof t=="number"&&typeof n=="number")return t+n;throw new de(`Operator "+" requires vector or number arguments of matching types, or at least one string argument. Arguments are ${t} and ${n}.`)};ht.prototype._evaluateMinus=function(e){let t=this._left.evaluate(e),n=this._right.evaluate(e);if(n instanceof H&&t instanceof H)return H.subtract(t,n,wn.getCartesian2());if(n instanceof h&&t instanceof h)return h.subtract(t,n,wn.getCartesian3());if(n instanceof se&&t instanceof se)return se.subtract(t,n,wn.getCartesian4());if(typeof t=="number"&&typeof n=="number")return t-n;throw new de(`Operator "-" requires vector or number arguments of matching types. Arguments are ${t} and ${n}.`)};ht.prototype._evaluateTimes=function(e){let t=this._left.evaluate(e),n=this._right.evaluate(e);if(n instanceof H&&t instanceof H)return H.multiplyComponents(t,n,wn.getCartesian2());if(n instanceof H&&typeof t=="number")return H.multiplyByScalar(n,t,wn.getCartesian2());if(t instanceof H&&typeof n=="number")return H.multiplyByScalar(t,n,wn.getCartesian2());if(n instanceof h&&t instanceof h)return h.multiplyComponents(t,n,wn.getCartesian3());if(n instanceof h&&typeof t=="number")return h.multiplyByScalar(n,t,wn.getCartesian3());if(t instanceof h&&typeof n=="number")return h.multiplyByScalar(t,n,wn.getCartesian3());if(n instanceof se&&t instanceof se)return se.multiplyComponents(t,n,wn.getCartesian4());if(n instanceof se&&typeof t=="number")return se.multiplyByScalar(n,t,wn.getCartesian4());if(t instanceof se&&typeof n=="number")return se.multiplyByScalar(t,n,wn.getCartesian4());if(typeof t=="number"&&typeof n=="number")return t*n;throw new de(`Operator "*" requires vector or number arguments. If both arguments are vectors they must be matching types. Arguments are ${t} and ${n}.`)};ht.prototype._evaluateDivide=function(e){let t=this._left.evaluate(e),n=this._right.evaluate(e);if(n instanceof H&&t instanceof H)return H.divideComponents(t,n,wn.getCartesian2());if(t instanceof H&&typeof n=="number")return H.divideByScalar(t,n,wn.getCartesian2());if(n instanceof h&&t instanceof h)return h.divideComponents(t,n,wn.getCartesian3());if(t instanceof h&&typeof n=="number")return h.divideByScalar(t,n,wn.getCartesian3());if(n instanceof se&&t instanceof se)return se.divideComponents(t,n,wn.getCartesian4());if(t instanceof se&&typeof n=="number")return se.divideByScalar(t,n,wn.getCartesian4());if(typeof t=="number"&&typeof n=="number")return t/n;throw new de(`Operator "/" requires vector or number arguments of matching types, or a number as the second argument. Arguments are ${t} and ${n}.`)};ht.prototype._evaluateMod=function(e){let t=this._left.evaluate(e),n=this._right.evaluate(e);if(n instanceof H&&t instanceof H)return H.fromElements(t.x%n.x,t.y%n.y,wn.getCartesian2());if(n instanceof h&&t instanceof h)return h.fromElements(t.x%n.x,t.y%n.y,t.z%n.z,wn.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,wn.getCartesian4());if(typeof t=="number"&&typeof n=="number")return t%n;throw new de(`Operator "%" requires vector or number arguments of matching types. Arguments are ${t} and ${n}.`)};ht.prototype._evaluateEqualsStrict=function(e){let t=this._left.evaluate(e),n=this._right.evaluate(e);return n instanceof H&&t instanceof H||n instanceof h&&t instanceof h||n instanceof se&&t instanceof se?t.equals(n):t===n};ht.prototype._evaluateNotEqualsStrict=function(e){let t=this._left.evaluate(e),n=this._right.evaluate(e);return n instanceof H&&t instanceof H||n instanceof h&&t instanceof h||n instanceof se&&t instanceof se?!t.equals(n):t!==n};ht.prototype._evaluateConditional=function(e){let t=this._test.evaluate(e);if(typeof t!="boolean")throw new de(`Conditional argument of conditional expression must be a boolean. Argument is ${t}.`);return t?this._left.evaluate(e):this._right.evaluate(e)};ht.prototype._evaluateNaN=function(e){return isNaN(this._left.evaluate(e))};ht.prototype._evaluateIsFinite=function(e){return isFinite(this._left.evaluate(e))};ht.prototype._evaluateIsExactClass=function(e){return u(e)?e.isExactClass(this._left.evaluate(e)):!1};ht.prototype._evaluateIsClass=function(e){return u(e)?e.isClass(this._left.evaluate(e)):!1};ht.prototype._evaluateGetExactClassName=function(e){if(u(e))return e.getExactClassName()};ht.prototype._evaluateBooleanConversion=function(e){return Boolean(this._left.evaluate(e))};ht.prototype._evaluateNumberConversion=function(e){return Number(this._left.evaluate(e))};ht.prototype._evaluateStringConversion=function(e){return String(this._left.evaluate(e))};ht.prototype._evaluateRegExp=function(e){let t=this._value.evaluate(e),n="";u(this._left)&&(n=this._left.evaluate(e));let i;try{i=new RegExp(t,n)}catch(o){throw new de(o)}return i};ht.prototype._evaluateRegExpTest=function(e){let t=this._left.evaluate(e),n=this._right.evaluate(e);if(!(t instanceof RegExp&&typeof n=="string"))throw new de(`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)};ht.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 de(`Operator "=~" requires one RegExp argument and one string argument. Arguments are ${t} and ${n}.`)};ht.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 de(`Operator "!~" requires one RegExp argument and one string argument. Arguments are ${t} and ${n}.`)};ht.prototype._evaluateRegExpExec=function(e){let t=this._left.evaluate(e),n=this._right.evaluate(e);if(!(t instanceof RegExp&&typeof n=="string"))throw new de(`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 u(i)?i[1]:null};ht.prototype._evaluateToString=function(e){let t=this._left.evaluate(e);if(t instanceof RegExp||t instanceof H||t instanceof h||t instanceof se)return String(t);throw new de(`Unexpected function call "${this._value}".`)};function U$(e){let t=e._left,n=t.length;for(let a=0;a1){let p=l[0],g=l[1];return g!=="1.0"&&(t.translucent=!0),`vec4(${p}, ${g})`}}else return"vec4(1.0)";return`vec4(${l[0]}, 1.0)`}else{if(c==="rgb")return i=z$(this),u(i)?_3(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=z$(this),u(i)?_3(i):`vec4(${l[0]} / 255.0, ${l[1]} / 255.0, ${l[2]} / 255.0, ${l[3]})`;if(c==="hsl")return i=U$(this),u(i)?_3(i):`vec4(czm_HSLToRGB(vec3(${l[0]}, ${l[1]}, ${l[2]})), 1.0)`;if(c==="hsla")return i=U$(this),u(i)?(i.alpha!==1&&(t.translucent=!0),_3(i)):(l[3]!=="1.0"&&(t.translucent=!0),`vec4(czm_HSLToRGB(vec3(${l[0]}, ${l[1]}, ${l[2]})), ${l[3]})`)}break;case ut.LITERAL_VECTOR:f=o.length,d=`${c}(`;for(let p=0;p0;){let f=t.pop();if(z.equals(f.color,a.color))l=r8(n,s,l,i,o,f.batchIds,r),a.batchIds=a.batchIds.concat(f.batchIds),a.count=l-a.offset;else{let d=l;l=r8(n,s,l,i,o,f.batchIds,r),f.offset=d,f.count=l-d,c.push(f),a=f}}e._va.indexBuffer.copyFromArrayView(s),e._indices=s,e._batchedIndices=c}function s8(e,t,n,i,o,r,s){let a=e.bytesPerIndex,c=r.length;for(let l=0;l0;){let d=t.pop();if(z.equals(d.color,r.color))l=s8(a,c,l,n,i,d.batchIds,o),r.batchIds=r.batchIds.concat(d.batchIds),r.count=l-r.offset;else{let p=l;l=s8(a,c,l,n,i,d.batchIds,o),d.offset=p,d.count=l-p,s.push(d),r=d}}let f=e._va;e._va=e._vaSwap,e._vaSwap=f,e._batchedIndices=s}function U1e(e,t){return t.color.toRgba()-e.color.toRgba()}function z1e(e,t){if(!e._batchDirty)return!1;let n=e._batchedIndices,i=n.length,o=!1,r={};for(let s=0;s=A&&s0&&u(e.BOX_BATCH_IDS)){let m=t.byteOffset+e.BOX_BATCH_IDS.byteOffset;n=new Uint16Array(t.buffer,m,a)}if(c>0&&u(e.CYLINDER_BATCH_IDS)){let m=t.byteOffset+e.CYLINDER_BATCH_IDS.byteOffset;i=new Uint16Array(t.buffer,m,c)}if(l>0&&u(e.ELLIPSOID_BATCH_IDS)){let m=t.byteOffset+e.ELLIPSOID_BATCH_IDS.byteOffset;o=new Uint16Array(t.buffer,m,l)}if(f>0&&u(e.SPHERE_BATCH_IDS)){let m=t.byteOffset+e.SPHERE_BATCH_IDS.byteOffset;r=new Uint16Array(t.buffer,m,f)}let d=u(n)||u(i)||u(o)||u(r),p=a>0&&!u(n)||c>0&&!u(i)||l>0&&!u(o)||f>0&&!u(r);if(d&&p)throw new de("If one group of batch ids is defined, then all batch ids must be defined.");if(!u(n)&&!u(i)&&!u(o)&&!u(r)){let m=0;if(!u(n)&&a>0)for(n=new Uint16Array(a),s=0;s0)for(i=new Uint16Array(c),s=0;s0)for(o=new Uint16Array(l),s=0;s0)for(r=new Uint16Array(f),s=0;s0&&(g=Fo(i,n,l),n+=l,f>0&&(m=new Uint8Array(t,n,f),m=new Uint8Array(m)));let A=y(d.BOXES_LENGTH,0),x=y(d.CYLINDERS_LENGTH,0),C=y(d.ELLIPSOIDS_LENGTH,0),T=y(d.SPHERES_LENGTH,0),b=A+x+C+T,S=new zm(e,b,g,m,rIe(e));if(e._batchTable=S,b===0)return;let v=e.tile.computedTransform,P;u(d.RTC_CENTER)&&(P=h.unpack(d.RTC_CENTER),F.multiplyByPoint(v,P,P));let O=sIe(d,p);if(A>0||x>0||C>0||T>0){let R,M,L,_;if(A>0){let E=p.byteOffset+d.BOXES.byteOffset;R=new Float32Array(p.buffer,E,Hm.packedBoxLength*A)}if(x>0){let E=p.byteOffset+d.CYLINDERS.byteOffset;M=new Float32Array(p.buffer,E,Hm.packedCylinderLength*x)}if(C>0){let E=p.byteOffset+d.ELLIPSOIDS.byteOffset;L=new Float32Array(p.buffer,E,Hm.packedEllipsoidLength*C)}if(T>0){let E=p.byteOffset+d.SPHERES.byteOffset;_=new Float32Array(p.buffer,E,Hm.packedSphereLength*T)}return e._geometries=new Hm({boxes:R,boxBatchIds:O.boxes,cylinders:M,cylinderBatchIds:O.cylinders,ellipsoids:L,ellipsoidBatchIds:O.ellipsoids,spheres:_,sphereBatchIds:O.spheres,center:P,modelMatrix:v,batchTable:S,boundingVolume:e.tile.boundingVolume.boundingVolume}),e._geometries.readyPromise.then(function(){return e})}return Promise.resolve(e)}function Y$(e){let t=e.featuresLength;if(!u(e._features)&&t>0){let n=new Array(t);u(e._geometries)&&e._geometries.createFeatures(e,n),e._features=n}}Wm.prototype.hasProperty=function(e,t){return this._batchTable.hasProperty(e,t)};Wm.prototype.getFeature=function(e){return Y$(this),this._features[e]};Wm.prototype.applyDebugSettings=function(e,t){u(this._geometries)&&this._geometries.applyDebugSettings(e,t)};Wm.prototype.applyStyle=function(e){Y$(this),u(this._geometries)&&this._geometries.applyStyle(e,this._features)};Wm.prototype.update=function(e,t){u(this._geometries)&&(this._geometries.classificationType=this._tileset.classificationType,this._geometries.debugWireframe=this._tileset.debugWireframe,this._geometries.update(t)),u(this._batchTable)&&this._geometries._ready&&this._batchTable.update(e,t)};Wm.prototype.isDestroyed=function(){return!1};Wm.prototype.destroy=function(){return this._geometries=this._geometries&&this._geometries.destroy(),this._batchTable=this._batchTable&&this._batchTable.destroy(),le(this)};var PP=Wm;var a8={};a8.encode2D=function(e,t,n){let i=Math.pow(2,e),o={x:t,y:n},r,s,a,c=BigInt(0);for(a=i/2;a>0;a/=2)r=(o.x&a)>0?1:0,s=(o.y&a)>0?1:0,c+=BigInt((3*r^s)*a*a),X$(i,o,r,s);return c};a8.decode2D=function(e,t){let n=Math.pow(2,e),i={x:0,y:0},o,r,s,a;for(s=1,a=t;s>>0,c8=2*L0+1,G_=4,Z$=[],Q$=[],uIe=[[0,1,3,2],[0,2,3,1],[3,2,0,1],[3,1,0,2]],H_=1,UC=2,E3=[H_,0,0,H_|UC];function Rr(e){if(!Mt.supportsBigInt())throw new de("S2 required BigInt support");this._cellId=e,this._level=Rr.getLevel(e)}Rr.fromToken=function(e){return new Rr(Rr.getIdFromToken(e))};Rr.isValidId=function(e){return!(e<=0||e>>BigInt(c8)>5||!(e&~e+BigInt(1)&BigInt("0x1555555555555555")))};Rr.isValidToken=function(e){return/^[0-9a-fA-F]{1,16}$/.test(e)?Rr.isValidId(Rr.getIdFromToken(e)):!1};Rr.getIdFromToken=function(e){return BigInt("0x"+e+"0".repeat(16-e.length))};Rr.getTokenFromId=function(e){let t=Math.floor(xIe(e)/4),n=e.toString(16).replace(/0*$/,"");return Array(17-t-n.length).join("0")+n};Rr.getLevel=function(e){let t=0;for(;e!==BigInt(0)&&!(e&BigInt(1));)t++,e=e>>BigInt(1);return L0-(t>>1)};Rr.prototype.getChild=function(e){let t=tee(this._cellId)>>BigInt(2),n=this._cellId+BigInt(2*e+1-4)*t;return new Rr(n)};Rr.prototype.getParent=function(){let e=tee(this._cellId)<>1&1;return eee(i[0],o[0][r^n&1],o[1][r])}function hIe(e,t){let n=$$(e),i=n[0],o=n[1],r=n[2],s=t===30,a=!s&&(BigInt(o)^e>>BigInt(2))&BigInt(1),c=s?1:a?2:0,l=(o<<1)+c,f=(r<<1)+c;return[i,l,f]}function $$(e){Z$.length===0&&gIe();let t=Number(e>>BigInt(c8)),n=t&H_,i=(1<=0;s--){let c=(1<<2*(s===7?L0-7*G_:G_))-1;n+=Number(e>>BigInt(s*2*G_+1)&BigInt(c))<<2,n=Q$[n];let l=s*G_;o+=n>>G_+2<>2&i)<=.5?1/3*(4*e*e-1):1/3*(1-4*(1-e)*(1-e))}function K$(e){return 1/lIe*e}function pIe(e,t){let n=[[],[]],i=_Ie(t);for(let o=0;o<2;++o){let r=e[o]&-i,s=r+i;n[o][0]=b3(J$(r)),n[o][1]=b3(J$(s))}return n}function _Ie(e){return 1<