@cesium/engine 23.0.1 → 25.0.0

package/Source/Scene/renderBufferPolylineCollection.js

@@ -0,0 +1,478 @@
+// @ts-check
+
+import defined from "../Core/defined.js";
+import Cartesian3 from "../Core/Cartesian3.js";
+import Color from "../Core/Color.js";
+import BufferPolyline from "./BufferPolyline.js";
+import Buffer from "../Renderer/Buffer.js";
+import BufferUsage from "../Renderer/BufferUsage.js";
+import VertexArray from "../Renderer/VertexArray.js";
+import ComponentDatatype from "../Core/ComponentDatatype.js";
+import RenderState from "../Renderer/RenderState.js";
+import BlendingState from "./BlendingState.js";
+import ShaderSource from "../Renderer/ShaderSource.js";
+import ShaderProgram from "../Renderer/ShaderProgram.js";
+import DrawCommand from "../Renderer/DrawCommand.js";
+import Pass from "../Renderer/Pass.js";
+import PrimitiveType from "../Core/PrimitiveType.js";
+import BufferPolylineMaterialVS from "../Shaders/BufferPolylineMaterialVS.js";
+import BufferPolylineMaterialFS from "../Shaders/BufferPolylineMaterialFS.js";
+import EncodedCartesian3 from "../Core/EncodedCartesian3.js";
+import AttributeCompression from "../Core/AttributeCompression.js";
+import IndexDatatype from "../Core/IndexDatatype.js";
+import PolylineCommon from "../Shaders/PolylineCommon.js";
+import BufferPolylineMaterial from "./BufferPolylineMaterial.js";
+
+/** @import FrameState from "./FrameState.js"; */
+/** @import BufferPolylineCollection from "./BufferPolylineCollection.js"; */
+/** @import {TypedArray} from "../Core/globalTypes.js"; */
+
+/**
+ * TODO(PR#13211): Need 'keyof' syntax to avoid duplicating attribute names.
+ * @typedef {'positionHigh' | 'positionLow' | 'prevPositionHigh' | 'prevPositionLow' | 'nextPositionHigh' | 'nextPositionLow' | 'pickColor' | 'showColorWidthAndTexCoord'} BufferPolylineAttribute
+ * @ignore
+ */
+
+/**
+ * @type {Record<BufferPolylineAttribute, number>}
+ * @ignore
+ */
+const BufferPolylineAttributeLocations = {
+  positionHigh: 0,
+  positionLow: 1,
+  prevPositionHigh: 2,
+  prevPositionLow: 3,
+  nextPositionHigh: 4,
+  nextPositionLow: 5,
+  pickColor: 6,
+  showColorWidthAndTexCoord: 7,
+};
+
+/**
+ * @typedef {object} BufferPolylineRenderContext
+ * @property {VertexArray} [vertexArray]
+ * @property {Record<BufferPolylineAttribute, TypedArray>} [attributeArrays]
+ * @property {TypedArray} [indexArray]
+ * @property {RenderState} [renderState]
+ * @property {ShaderProgram} [shaderProgram]
+ * @property {DrawCommand} [command]
+ * @property {Function} destroy
+ * @ignore
+ */
+
+// Scratch variables.
+const polyline = new BufferPolyline();
+const material = new BufferPolylineMaterial();
+const pickColor = new Color();
+const cartesian = new Cartesian3();
+const prevCartesian = new Cartesian3();
+const nextCartesian = new Cartesian3();
+const cartesianEnc = new EncodedCartesian3();
+const prevCartesianEnc = new EncodedCartesian3();
+const nextCartesianEnc = new EncodedCartesian3();
+
+/**
+ * Renders line segments as quads, each composed of two triangles. Writes each
+ * vertex twice, extruding the pairs in opposing directions outward.
+ *
+ * Tips:
+ * - # segments in polyline primitive = vertexCount - 1
+ * - # segments in collection = vertexCount - primitiveCount
+ * - # vertices rendered = vertexCount * 2
+ * - # indices = segmentCount * 6
+ *
+ * 0 - 2 - 4 - 6 - 8
+ * | \ | \ | \ | \ | ...
+ * 1 - 3 - 5 - 7 - 9
+ *
+ * @param {BufferPolylineCollection} collection
+ * @param {FrameState} frameState
+ * @param {BufferPolylineRenderContext} [renderContext]
+ * @returns {BufferPolylineRenderContext}
+ * @ignore
+ */
+function renderBufferPolylineCollection(collection, frameState, renderContext) {
+  const context = frameState.context;
+  renderContext = renderContext || { destroy: destroyRenderContext };
+
+  if (
+    !defined(renderContext.attributeArrays) ||
+    !defined(renderContext.indexArray)
+  ) {
+    // Number of primitives can only increase, which _decreases_ remaining
+    // segment capacity: use `primitiveCount` here, not `primitiveCountMax`.
+    const segmentCountMax =
+      collection.vertexCountMax - collection.primitiveCount;
+    const vertexCountMax = collection.vertexCountMax * 2;
+
+    // @ts-expect-error https://github.com/CesiumGS/cesium/issues/13420
+    renderContext.indexArray = IndexDatatype.createTypedArray(
+      vertexCountMax,
+      segmentCountMax * 6,
+    );
+
+    renderContext.attributeArrays = {
+      positionHigh: new Float32Array(vertexCountMax * 3),
+      positionLow: new Float32Array(vertexCountMax * 3),
+      prevPositionHigh: new Float32Array(vertexCountMax * 3),
+      prevPositionLow: new Float32Array(vertexCountMax * 3),
+      nextPositionHigh: new Float32Array(vertexCountMax * 3),
+      nextPositionLow: new Float32Array(vertexCountMax * 3),
+      pickColor: new Uint8Array(vertexCountMax * 4),
+      showColorWidthAndTexCoord: new Float32Array(vertexCountMax * 4),
+    };
+  }
+
+  if (collection._dirtyCount > 0) {
+    const { _dirtyOffset, _dirtyCount } = collection;
+    const { attributeArrays } = renderContext;
+
+    const indexArray = renderContext.indexArray;
+    const positionHighArray = attributeArrays.positionHigh;
+    const positionLowArray = attributeArrays.positionLow;
+    const prevPositionHighArray = attributeArrays.prevPositionHigh;
+    const prevPositionLowArray = attributeArrays.prevPositionLow;
+    const nextPositionHighArray = attributeArrays.nextPositionHigh;
+    const nextPositionLowArray = attributeArrays.nextPositionLow;
+    const pickColorArray = attributeArrays.pickColor;
+    const showColorWidthAndTexCoordArray =
+      attributeArrays.showColorWidthAndTexCoord;
+
+    for (let i = _dirtyOffset, il = _dirtyOffset + _dirtyCount; i < il; i++) {
+      collection.get(i, polyline);
+
+      if (!polyline._dirty) {
+        continue;
+      }
+
+      const cartesianArray = polyline.getPositions();
+      polyline.getMaterial(material);
+      const encodedColor = AttributeCompression.encodeRGB8(material.color);
+      Color.fromRgba(polyline._pickId, pickColor);
+      const show = polyline.show;
+
+      let vOffset = polyline.vertexOffset * 2; // vertex offset
+      let iOffset = (polyline.vertexOffset - i) * 6; // index offset
+
+      for (let j = 0, jl = polyline.vertexCount; j < jl; j++) {
+        const isFirstSegment = j === 0;
+        const isLastSegment = j === jl - 1;
+
+        // For first/last vertices, infer missing vertices by mirroring the segment.
+        // @ts-expect-error TODO(tsd-jsdoc): See https://github.com/CesiumGS/cesium/pull/13302.
+        Cartesian3.fromArray(cartesianArray, j * 3, cartesian);
+        if (isFirstSegment) {
+          // @ts-expect-error TODO(tsd-jsdoc): See https://github.com/CesiumGS/cesium/pull/13302.
+          Cartesian3.fromArray(cartesianArray, (j + 1) * 3, nextCartesian);
+          Cartesian3.subtract(cartesian, nextCartesian, prevCartesian);
+          Cartesian3.add(cartesian, prevCartesian, prevCartesian);
+        } else if (isLastSegment) {
+          // @ts-expect-error TODO(tsd-jsdoc): See https://github.com/CesiumGS/cesium/pull/13302.
+          Cartesian3.fromArray(cartesianArray, (j - 1) * 3, prevCartesian);
+          Cartesian3.subtract(cartesian, prevCartesian, nextCartesian);
+          Cartesian3.add(cartesian, nextCartesian, nextCartesian);
+        } else {
+          // @ts-expect-error TODO(tsd-jsdoc): See https://github.com/CesiumGS/cesium/pull/13302.
+          Cartesian3.fromArray(cartesianArray, (j - 1) * 3, prevCartesian);
+          // @ts-expect-error TODO(tsd-jsdoc): See https://github.com/CesiumGS/cesium/pull/13302.
+          Cartesian3.fromArray(cartesianArray, (j + 1) * 3, nextCartesian);
+        }
+
+        // For each segment, draw two triangles.
+        if (!isLastSegment) {
+          indexArray[iOffset] = vOffset;
+          indexArray[iOffset + 1] = vOffset + 1;
+          indexArray[iOffset + 2] = vOffset + 2;
+
+          indexArray[iOffset + 3] = vOffset + 2;
+          indexArray[iOffset + 4] = vOffset + 1;
+          indexArray[iOffset + 5] = vOffset + 3;
+
+          iOffset += 6;
+        }
+
+        EncodedCartesian3.fromCartesian(cartesian, cartesianEnc);
+        EncodedCartesian3.fromCartesian(prevCartesian, prevCartesianEnc);
+        EncodedCartesian3.fromCartesian(nextCartesian, nextCartesianEnc);
+
+        // TODO(donmccurdy): Diverging from PolylineCollection.js, which writes
+        // internal vertices to buffer 4x, not 2x. Not sure that's needed?
+        for (let k = 0; k < 2; k++) {
+          // Position.
+          positionHighArray[vOffset * 3] = cartesianEnc.high.x;
+          positionHighArray[vOffset * 3 + 1] = cartesianEnc.high.y;
+          positionHighArray[vOffset * 3 + 2] = cartesianEnc.high.z;
+
+          positionLowArray[vOffset * 3] = cartesianEnc.low.x;
+          positionLowArray[vOffset * 3 + 1] = cartesianEnc.low.y;
+          positionLowArray[vOffset * 3 + 2] = cartesianEnc.low.z;
+
+          // Previous position.
+          prevPositionHighArray[vOffset * 3] = prevCartesianEnc.high.x;
+          prevPositionHighArray[vOffset * 3 + 1] = prevCartesianEnc.high.y;
+          prevPositionHighArray[vOffset * 3 + 2] = prevCartesianEnc.high.z;
+
+          prevPositionLowArray[vOffset * 3] = prevCartesianEnc.low.x;
+          prevPositionLowArray[vOffset * 3 + 1] = prevCartesianEnc.low.y;
+          prevPositionLowArray[vOffset * 3 + 2] = prevCartesianEnc.low.z;
+
+          // Next position.
+          nextPositionHighArray[vOffset * 3] = nextCartesianEnc.high.x;
+          nextPositionHighArray[vOffset * 3 + 1] = nextCartesianEnc.high.y;
+          nextPositionHighArray[vOffset * 3 + 2] = nextCartesianEnc.high.z;
+
+          nextPositionLowArray[vOffset * 3] = nextCartesianEnc.low.x;
+          nextPositionLowArray[vOffset * 3 + 1] = nextCartesianEnc.low.y;
+          nextPositionLowArray[vOffset * 3 + 2] = nextCartesianEnc.low.z;
+
+          // Pick ID.
+          pickColorArray[vOffset * 4] = Color.floatToByte(pickColor.red);
+          pickColorArray[vOffset * 4 + 1] = Color.floatToByte(pickColor.green);
+          pickColorArray[vOffset * 4 + 2] = Color.floatToByte(pickColor.blue);
+          pickColorArray[vOffset * 4 + 3] = Color.floatToByte(pickColor.alpha);
+
+          // Properties.
+          showColorWidthAndTexCoordArray[vOffset * 4] = show ? 1 : 0;
+          showColorWidthAndTexCoordArray[vOffset * 4 + 1] = encodedColor;
+          showColorWidthAndTexCoordArray[vOffset * 4 + 2] = material.width;
+          showColorWidthAndTexCoordArray[vOffset * 4 + 3] = j / (jl - 1); // texcoord.s
+
+          vOffset++;
+        }
+      }
+
+      polyline._dirty = false;
+    }
+  }
+
+  if (!defined(renderContext.vertexArray)) {
+    const attributeArrays = renderContext.attributeArrays;
+
+    renderContext.vertexArray = new VertexArray({
+      context,
+
+      indexBuffer: Buffer.createIndexBuffer({
+        context,
+        typedArray: renderContext.indexArray,
+        usage: BufferUsage.STATIC_DRAW,
+        // @ts-expect-error https://github.com/CesiumGS/cesium/issues/13420
+        indexDatatype: IndexDatatype.fromTypedArray(renderContext.indexArray),
+      }),
+
+      attributes: [
+        {
+          index: BufferPolylineAttributeLocations.positionHigh,
+          componentDatatype: ComponentDatatype.FLOAT,
+          componentsPerAttribute: 3,
+          vertexBuffer: Buffer.createVertexBuffer({
+            typedArray: attributeArrays.positionHigh,
+            context,
+            usage: BufferUsage.STATIC_DRAW,
+          }),
+        },
+        {
+          index: BufferPolylineAttributeLocations.positionLow,
+          componentDatatype: ComponentDatatype.FLOAT,
+          componentsPerAttribute: 3,
+          vertexBuffer: Buffer.createVertexBuffer({
+            typedArray: attributeArrays.positionLow,
+            context,
+            usage: BufferUsage.STATIC_DRAW,
+          }),
+        },
+
+        {
+          index: BufferPolylineAttributeLocations.prevPositionHigh,
+          componentDatatype: ComponentDatatype.FLOAT,
+          componentsPerAttribute: 3,
+          vertexBuffer: Buffer.createVertexBuffer({
+            typedArray: attributeArrays.prevPositionHigh,
+            context,
+            usage: BufferUsage.STATIC_DRAW,
+          }),
+        },
+        {
+          index: BufferPolylineAttributeLocations.prevPositionLow,
+          componentDatatype: ComponentDatatype.FLOAT,
+          componentsPerAttribute: 3,
+          vertexBuffer: Buffer.createVertexBuffer({
+            typedArray: attributeArrays.prevPositionLow,
+            context,
+            usage: BufferUsage.STATIC_DRAW,
+          }),
+        },
+
+        {
+          index: BufferPolylineAttributeLocations.nextPositionHigh,
+          componentDatatype: ComponentDatatype.FLOAT,
+          componentsPerAttribute: 3,
+          vertexBuffer: Buffer.createVertexBuffer({
+            typedArray: attributeArrays.nextPositionHigh,
+            context,
+            usage: BufferUsage.STATIC_DRAW,
+          }),
+        },
+        {
+          index: BufferPolylineAttributeLocations.nextPositionLow,
+          componentDatatype: ComponentDatatype.FLOAT,
+          componentsPerAttribute: 3,
+          vertexBuffer: Buffer.createVertexBuffer({
+            typedArray: attributeArrays.nextPositionLow,
+            context,
+            usage: BufferUsage.STATIC_DRAW,
+          }),
+        },
+        {
+          index: BufferPolylineAttributeLocations.pickColor,
+          componentDatatype: ComponentDatatype.UNSIGNED_BYTE,
+          componentsPerAttribute: 4,
+          vertexBuffer: Buffer.createVertexBuffer({
+            typedArray: attributeArrays.pickColor,
+            context,
+            usage: BufferUsage.STATIC_DRAW,
+          }),
+        },
+        {
+          index: BufferPolylineAttributeLocations.showColorWidthAndTexCoord,
+          componentDatatype: ComponentDatatype.FLOAT,
+          componentsPerAttribute: 4,
+          vertexBuffer: Buffer.createVertexBuffer({
+            typedArray: attributeArrays.showColorWidthAndTexCoord,
+            context,
+            usage: BufferUsage.STATIC_DRAW,
+          }),
+        },
+      ],
+    });
+  } else if (collection._dirtyCount > 0) {
+    const { indexOffset, indexCount, vertexOffset, vertexCount } =
+      getPolylineDirtyRanges(collection);
+
+    renderContext.vertexArray.copyIndexFromRange(
+      renderContext.indexArray,
+      indexOffset,
+      indexCount,
+    );
+
+    for (const key in BufferPolylineAttributeLocations) {
+      if (Object.hasOwn(BufferPolylineAttributeLocations, key)) {
+        const attribute = /** @type {BufferPolylineAttribute} */ (key);
+        renderContext.vertexArray.copyAttributeFromRange(
+          BufferPolylineAttributeLocations[attribute],
+          renderContext.attributeArrays[attribute],
+          vertexOffset,
+          vertexCount,
+        );
+      }
+    }
+  }
+
+  if (!defined(renderContext.renderState)) {
+    renderContext.renderState = RenderState.fromCache({
+      blending: BlendingState.DISABLED,
+      depthTest: { enabled: true },
+    });
+  }
+
+  if (!defined(renderContext.shaderProgram)) {
+    renderContext.shaderProgram = ShaderProgram.fromCache({
+      context,
+      vertexShaderSource: new ShaderSource({
+        sources: [PolylineCommon, BufferPolylineMaterialVS],
+      }),
+      fragmentShaderSource: new ShaderSource({
+        sources: [BufferPolylineMaterialFS],
+      }),
+      attributeLocations: BufferPolylineAttributeLocations,
+    });
+  }
+
+  const drawCount = getDrawIndexCount(collection);
+
+  if (!defined(renderContext.command)) {
+    renderContext.command = new DrawCommand({
+      vertexArray: renderContext.vertexArray,
+      renderState: renderContext.renderState,
+      shaderProgram: renderContext.shaderProgram,
+      primitiveType: PrimitiveType.TRIANGLES,
+      pass: Pass.OPAQUE,
+      pickId: collection._allowPicking ? "v_pickColor" : undefined,
+      owner: collection,
+      count: drawCount,
+      modelMatrix: collection.modelMatrix, // shared reference
+      boundingVolume: collection.boundingVolumeWC, // shared reference
+      debugShowBoundingVolume: collection.debugShowBoundingVolume,
+    });
+  }
+
+  const command = renderContext.command;
+
+  if (command.count !== drawCount) {
+    command.count = drawCount;
+  }
+
+  if (command.debugShowBoundingVolume !== collection.debugShowBoundingVolume) {
+    command.debugShowBoundingVolume = collection.debugShowBoundingVolume;
+  }
+
+  frameState.commandList.push(command);
+
+  collection._dirtyCount = 0;
+  collection._dirtyOffset = 0;
+
+  return renderContext;
+}
+
+/**
+ * Returns number of drawn (not allocated) indices for given collection.
+ * @param {BufferPolylineCollection} collection
+ * @ignore
+ */
+function getDrawIndexCount(collection) {
+  return (collection.vertexCount - collection.primitiveCount) * 6;
+}
+
+/**
+ * Computes dirty ranges for attribute and index buffers in a collection.
+ * @param {BufferPolylineCollection} collection
+ * @ignore
+ */
+function getPolylineDirtyRanges(collection) {
+  const { _dirtyOffset, _dirtyCount } = collection;
+
+  collection.get(_dirtyOffset, polyline);
+  const vertexOffset = polyline.vertexOffset * 2;
+  const segmentOffset = polyline.vertexOffset - _dirtyOffset;
+  const indexOffset = segmentOffset * 6;
+
+  collection.get(_dirtyOffset + _dirtyCount - 1, polyline);
+  const vertexCount =
+    (polyline.vertexOffset + polyline.vertexCount) * 2 - vertexOffset;
+  const segmentCount = vertexCount / 2 - _dirtyCount;
+  const indexCount = segmentCount * 6;
+
+  return { indexOffset, indexCount, vertexOffset, vertexCount };
+}
+
+/**
+ * Destroys render context resources. Deleting properties from the context
+ * object isn't necessary, as collection.destroy() will discard the object.
+ * @ignore
+ */
+function destroyRenderContext() {
+  const context = /** @type {BufferPolylineRenderContext} */ (this);
+
+  if (defined(context.vertexArray)) {
+    context.vertexArray.destroy();
+  }
+
+  if (defined(context.shaderProgram)) {
+    context.shaderProgram.destroy();
+  }
+
+  if (defined(context.renderState)) {
+    RenderState.removeFromCache(context.renderState);
+  }
+}
+
+export default renderBufferPolylineCollection;

package/Source/Shaders/BillboardCollectionFS.glsl

@@ -20,16 +20,6 @@ in vec4 v_compressed;                               // x: eyeDepth, y: applyTran
 const float SHIFT_LEFT1 = 2.0;
 const float SHIFT_RIGHT1 = 1.0 / 2.0;
 
-#ifdef FS_THREE_POINT_DEPTH_CHECK
-in vec4 v_textureCoordinateBounds;                  // the min and max x and y values for the texture coordinates
-in vec4 v_originTextureCoordinateAndTranslate;      // texture coordinate at the origin, billboard translate (used for label glyphs)
-in mat2 v_rotationMatrix;
-
-const float SHIFT_LEFT12 = 4096.0;
-
-const float SHIFT_RIGHT12 = 1.0 / 4096.0;
-#endif
-
 float getGlobeDepthAtCoords(vec2 st)
 {
     float logDepthOrDepth = czm_unpackDepth(texture(czm_globeDepthTexture, st));
@@ -42,27 +32,6 @@ float getGlobeDepthAtCoords(vec2 st)
     return eyeCoordinate.z / eyeCoordinate.w;
 }
 
-#ifdef FS_THREE_POINT_DEPTH_CHECK
-float getGlobeDepth(vec2 adjustedST, vec2 depthLookupST, bool applyTranslate, vec2 dimensions, vec2 imageSize)
-{
-    vec2 lookupVector = imageSize * (depthLookupST - adjustedST);
-    lookupVector = v_rotationMatrix * lookupVector;
-    vec2 labelOffset = (dimensions - imageSize) * (depthLookupST - vec2(0.0, v_originTextureCoordinateAndTranslate.y)); // aligns label glyph with bounding rectangle.  Will be zero for billboards because dimensions and imageSize will be equal
-
-    vec2 translation = v_originTextureCoordinateAndTranslate.zw;
-
-    if (applyTranslate)
-    {
-        // this is only needed for labels where the horizontal origin is not LEFT
-        // it moves the label back to where the "origin" should be since all label glyphs are set to HorizontalOrigin.LEFT
-        translation += (dimensions * v_originTextureCoordinateAndTranslate.xy * vec2(1.0, 0.0));
-    }
-
-    vec2 st = ((lookupVector - translation + labelOffset) + gl_FragCoord.xy) / czm_viewport.zw;
-    return getGlobeDepthAtCoords(st);
-}
-#endif
-
 #ifdef SDF
 
 // Get the distance from the edge of a glyph at a given position sampling an SDF texture.
@@ -93,44 +62,6 @@ vec4 getSDFColor(vec2 position, float outlineWidth, vec4 outlineColor, float smo
 }
 #endif
 
-#ifdef FS_THREE_POINT_DEPTH_CHECK
-void doThreePointDepthTest(float eyeDepth, bool applyTranslate) {
-
-    if (eyeDepth < -u_threePointDepthTestDistance) return;
-    float temp = v_compressed.z;
-    temp = temp * SHIFT_RIGHT12;
-
-    vec2 dimensions;
-    dimensions.y = (temp - floor(temp)) * SHIFT_LEFT12;
-    dimensions.x = floor(temp);
-
-    temp = v_compressed.w;
-    temp = temp * SHIFT_RIGHT12;
-
-    vec2 imageSize;
-    imageSize.y = (temp - floor(temp)) * SHIFT_LEFT12;
-    imageSize.x = floor(temp);
-
-    vec2 adjustedST = v_textureCoordinates - v_textureCoordinateBounds.xy;
-    adjustedST = adjustedST / vec2(v_textureCoordinateBounds.z - v_textureCoordinateBounds.x, v_textureCoordinateBounds.w - v_textureCoordinateBounds.y);
-
-    float epsilonEyeDepth = v_compressed.x + czm_epsilon1;
-    float globeDepth1 = getGlobeDepth(adjustedST, v_originTextureCoordinateAndTranslate.xy, applyTranslate, dimensions, imageSize);
-
-    // negative values go into the screen
-    if (globeDepth1 == 0.0 || globeDepth1 < epsilonEyeDepth) return;
-
-    float globeDepth2 = getGlobeDepth(adjustedST, vec2(0.0, 1.0), applyTranslate, dimensions, imageSize); // top left corner
-    if (globeDepth2 == 0.0 || globeDepth2 < epsilonEyeDepth) return;
-
-    float globeDepth3 = getGlobeDepth(adjustedST, vec2(1.0, 1.0), applyTranslate, dimensions, imageSize); // top right corner
-    if (globeDepth3 == 0.0 || globeDepth3 < epsilonEyeDepth) return;
-
-    // All three key points are occluded, discard the fragment (and by extension the entire billboard)
-    discard;
-}
-#endif
-
 bool getDepthTestEnabled() {
     float temp = v_compressed.y;
     temp = temp * SHIFT_RIGHT1;
@@ -153,13 +84,7 @@ float getRelativeEyeDepth(float eyeDepth, float distanceToEllipsoid, float epsil
 // by the globe when near and far from the camera.
 void doDepthTest(float eyeDepth, float globeDepth) {
 
-#ifdef FS_THREE_POINT_DEPTH_CHECK
-    // If the billboard is clamped to the ground and within a given distance, we do a 3-point depth test. This test is performed in the vertex shader, unless
-    // vertex texture sampling is not supported, in which case we do it here.
-    bool applyTranslate = floor(temp) != 0.0;
-    doThreePointDepthTest(eyeDepth, applyTranslate);
-
-#elif defined(VS_THREE_POINT_DEPTH_CHECK)
+#ifdef VS_THREE_POINT_DEPTH_CHECK
     // Since discarding vertices is not possible, the vertex shader sets eyeDepth to 0 to indicate the depth test failed. Apply the discard here.
     if (eyeDepth > -u_threePointDepthTestDistance) {
         if (eyeDepth == 0.0) {
@@ -188,7 +113,7 @@ void writeDepth(float eyeDepth, float globeDepth, float distanceToEllipsoid) {
 
     float depthArg = v_depthFromNearPlusOne;
 
-    if (globeDepth != 0.0 && getRelativeEyeDepth(eyeDepth, distanceToEllipsoid, czm_epsilon3) > 0.0) { 
+    if (globeDepth != 0.0 && getRelativeEyeDepth(eyeDepth, distanceToEllipsoid, czm_epsilon3) > 0.0) {
         float globeDepthFromNearPlusOne = (-globeDepth - czm_currentFrustum.x) + 1.0;
         float nudge = max(globeDepthFromNearPlusOne * 5e-6, czm_epsilon7);
         float globeOnTop = max(1.0, globeDepthFromNearPlusOne - nudge);