GltfUtilities.h

#pragma once
 
#include <CesiumGeospatial/BoundingRegion.h>
#include <CesiumGeospatial/Ellipsoid.h>
#include <CesiumGeospatial/GlobeRectangle.h>
#include <CesiumGltfContent/Library.h>
 
#include <glm/fwd.hpp>
 
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace CesiumGltf {
struct Buffer;
struct Model;
struct Node;
} // namespace CesiumGltf
 
namespace CesiumGeometry {
class Ray;
} // namespace CesiumGeometry
 
namespace CesiumGltfContent {
struct CESIUMGLTFCONTENT_API GltfUtilities {
  static std::optional<glm::dmat4x4>
  getNodeTransform(const CesiumGltf::Node& node);
 
  static void
  setNodeTransform(CesiumGltf::Node& node, const glm::dmat4x4& newTransform);
 
  static glm::dmat4x4 applyRtcCenter(
      const CesiumGltf::Model& gltf,
      const glm::dmat4x4& rootTransform);
 
  static glm::dmat4x4 applyGltfUpAxisTransform(
      const CesiumGltf::Model& model,
      const glm::dmat4x4& rootTransform);
 
  static CesiumGeospatial::BoundingRegion computeBoundingRegion(
      const CesiumGltf::Model& gltf,
      const glm::dmat4& transform,
      const CesiumGeospatial::Ellipsoid& ellipsoid CESIUM_DEFAULT_ELLIPSOID);
 
  static std::vector<std::string_view>
  parseGltfCopyright(const CesiumGltf::Model& gltf);
 
  static std::vector<std::string_view>
  parseGltfCopyright(const std::string_view& s);
 
  static void collapseToSingleBuffer(CesiumGltf::Model& gltf);
 
  static void moveBufferContent(
      CesiumGltf::Model& gltf,
      CesiumGltf::Buffer& destination,
      CesiumGltf::Buffer& source);
 
  static void removeUnusedTextures(
      CesiumGltf::Model& gltf,
      const std::vector<int32_t>& extraUsedTextureIndices = {});
 
  static void removeUnusedSamplers(
      CesiumGltf::Model& gltf,
      const std::vector<int32_t>& extraUsedSamplerIndices = {});
 
  static void removeUnusedImages(
      CesiumGltf::Model& gltf,
      const std::vector<int32_t>& extraUsedImageIndices = {});
 
  static void removeUnusedAccessors(
      CesiumGltf::Model& gltf,
      const std::vector<int32_t>& extraUsedAccessorIndices = {});
 
  static void removeUnusedBufferViews(
      CesiumGltf::Model& gltf,
      const std::vector<int32_t>& extraUsedBufferViewIndices = {});
 
  static void removeUnusedBuffers(
      CesiumGltf::Model& gltf,
      const std::vector<int32_t>& extraUsedBufferIndices = {});
 
  static void removeUnusedMeshes(
      CesiumGltf::Model& gltf,
      const std::vector<int32_t>& extraUsedMeshIndices = {});
 
  static void removeUnusedMaterials(
      CesiumGltf::Model& gltf,
      const std::vector<int32_t>& extraUsedMaterialIndices = {});
 
  static void compactBuffers(CesiumGltf::Model& gltf);
 
  static void compactBuffer(CesiumGltf::Model& gltf, int32_t bufferIndex);
 
  struct RayGltfHit {
    glm::dvec3 primitivePoint = {};
 
    glm::dmat4x4 primitiveToWorld = {};
 
    glm::dvec3 worldPoint = {};
 
    double rayToWorldPointDistanceSq = -1.0;
 
    int32_t meshId = -1;
 
    int32_t primitiveId = -1;
  };
 
  struct IntersectResult {
    std::optional<RayGltfHit> hit;
 
    std::vector<std::string> warnings{};
  };
 
  static IntersectResult intersectRayGltfModel(
      const CesiumGeometry::Ray& ray,
      const CesiumGltf::Model& gltf,
      bool cullBackFaces = true,
      const glm::dmat4x4& gltfTransform = glm::dmat4(1.0));
};
} // namespace CesiumGltfContent