GltfReader.h

#pragma once
 
#include <CesiumAsync/AsyncSystem.h>
#include <CesiumAsync/Future.h>
#include <CesiumAsync/HttpHeaders.h>
#include <CesiumAsync/IAssetAccessor.h>
#include <CesiumGltf/ImageAsset.h>
#include <CesiumGltf/Ktx2TranscodeTargets.h>
#include <CesiumGltf/Model.h>
#include <CesiumGltfReader/GltfSharedAssetSystem.h>
#include <CesiumGltfReader/ImageDecoder.h>
#include <CesiumGltfReader/Library.h>
#include <CesiumJsonReader/IExtensionJsonHandler.h>
#include <CesiumJsonReader/JsonReaderOptions.h>
 
#include <functional>
#include <memory>
#include <optional>
#include <span>
#include <string>
#include <vector>
 
namespace CesiumGltfReader {

struct CESIUMGLTFREADER_API GltfReaderResult {
  std::optional<CesiumGltf::Model> model;

  std::vector<std::string> errors;

  std::vector<std::string> warnings;
};

struct CESIUMGLTFREADER_API GltfReaderOptions {
  bool decodeDataUrls = true;

  bool clearDecodedDataUrls = true;

  bool decodeEmbeddedImages = true;

  bool resolveExternalImages = true;

  bool decodeDraco = true;

  bool decodeMeshOptData = true;

  bool decodeSpz = true;

  bool dequantizeMeshData = true;

  bool applyTextureTransform = true;

  CesiumGltf::Ktx2TranscodeTargets ktx2TranscodeTargets;

  CesiumUtility::IntrusivePointer<GltfSharedAssetSystem> pSharedAssetSystem =
      GltfSharedAssetSystem::getDefault();

  bool resolveExternalStructuralMetadata = true;
};

class CESIUMGLTFREADER_API GltfReader {
public:
  GltfReader();

  CesiumJsonReader::JsonReaderOptions& getOptions();

  const CesiumJsonReader::JsonReaderOptions& getExtensions() const;

  GltfReaderResult readGltf(
      const std::span<const std::byte>& data,
      const GltfReaderOptions& options = GltfReaderOptions()) const;

  CesiumAsync::Future<GltfReaderResult> readGltfAndExternalData(
      const std::span<const std::byte>& data,
      const CesiumAsync::AsyncSystem& asyncSystem,
      const CesiumAsync::HttpHeaders& headers,
      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
      const std::string& baseUrl = {},
      const GltfReaderOptions& options = GltfReaderOptions()) const;

  CesiumAsync::Future<GltfReaderResult> readGltfAndExternalData(
      const std::span<const std::byte>& data,
      const CesiumAsync::AsyncSystem& asyncSystem,
      const std::vector<CesiumAsync::IAssetAccessor::THeader>& headers,
      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
      const std::string& baseUrl = {},
      const GltfReaderOptions& options = GltfReaderOptions()) const;

  CesiumAsync::Future<GltfReaderResult> loadGltf(
      const CesiumAsync::AsyncSystem& asyncSystem,
      const std::string& url,
      const std::vector<CesiumAsync::IAssetAccessor::THeader>& headers,
      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
      const GltfReaderOptions& options = GltfReaderOptions()) const;

  void
  postprocessGltf(GltfReaderResult& readGltf, const GltfReaderOptions& options);

  static CesiumAsync::Future<GltfReaderResult> resolveExternalData(
      const CesiumAsync::AsyncSystem& asyncSystem,
      const std::string& baseUrl,
      const CesiumAsync::HttpHeaders& headers,
      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
      const GltfReaderOptions& options,
      GltfReaderResult&& result);

  [[deprecated(
      "Use ImageDecoder::readImage instead.")]] static ImageReaderResult
  readImage(
      const std::span<const std::byte>& data,
      const CesiumGltf::Ktx2TranscodeTargets& ktx2TranscodeTargets);

  [[deprecated("Use ImageDecoder::generateMipMaps instead.")]] static std::
      optional<std::string>
      generateMipMaps(CesiumGltf::ImageAsset& image);
 
private:
  CesiumJsonReader::JsonReaderOptions _context;
};
 
} // namespace CesiumGltfReader