Function addSkirt

CesiumQuantizedMeshTerrain/src/QuantizedMeshLoader.cpp:393–461

template <class E, class I>
void addSkirt(
    const CesiumGeospatial::Ellipsoid& ellipsoid,
    const glm::dvec3& center,
    const CesiumGeospatial::GlobeRectangle& rectangle,
    double minimumHeight,
    double maximumHeight,
    uint32_t currentVertexCount,
    uint32_t currentIndicesCount,
    double skirtHeight,
    double longitudeOffset,
    double latitudeOffset,
    const std::vector<glm::dvec3>& uvsAndHeights,
    const std::span<const E>& edgeIndices,
    const std::span<float>& positions,
    const std::span<float>& normals,
    const std::span<I>& indices,
    glm::dvec3& positionMinimums,
    glm::dvec3& positionMaximums) {
  const double west = rectangle.getWest();
  const double south = rectangle.getSouth();
  const double east = rectangle.getEast();
  const double north = rectangle.getNorth();

  size_t newEdgeIndex = currentVertexCount;
  size_t positionIdx = static_cast<size_t>(currentVertexCount * 3);
  size_t indexIdx = currentIndicesCount;
  for (size_t i = 0; i < edgeIndices.size(); ++i) {
    E edgeIdx = edgeIndices[i];

    const double uRatio = uvsAndHeights[edgeIdx].x;
    const double vRatio = uvsAndHeights[edgeIdx].y;
    const double heightRatio = uvsAndHeights[edgeIdx].z;
    const double longitude = Math::lerp(west, east, uRatio) + longitudeOffset;
    const double latitude = Math::lerp(south, north, vRatio) + latitudeOffset;
    const double heightMeters =
        Math::lerp(minimumHeight, maximumHeight, heightRatio) - skirtHeight;
    glm::dvec3 position = ellipsoid.cartographicToCartesian(
        Cartographic(longitude, latitude, heightMeters));
    position -= center;

    positions[positionIdx] = static_cast<float>(position.x);
    positions[positionIdx + 1] = static_cast<float>(position.y);
    positions[positionIdx + 2] = static_cast<float>(position.z);

    positionMinimums = glm::min(positionMinimums, position);
    positionMaximums = glm::max(positionMaximums, position);

    if (!normals.empty()) {
      const size_t componentIndex = static_cast<size_t>(3 * edgeIdx);
      normals[positionIdx] = normals[componentIndex];
      normals[positionIdx + 1] = normals[componentIndex + 1];
      normals[positionIdx + 2] = normals[componentIndex + 2];
    }

    if (i < edgeIndices.size() - 1) {
      E nextEdgeIdx = edgeIndices[i + 1];
      indices[indexIdx++] = static_cast<I>(edgeIdx);
      indices[indexIdx++] = static_cast<I>(nextEdgeIdx);