GltfReader.h

#pragma once
 
#include "CesiumGltfReader/ImageDecoder.h"
#include "CesiumGltfReader/Library.h"
 
#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 <CesiumJsonReader/IExtensionJsonHandler.h>
#include <CesiumJsonReader/JsonReaderOptions.h>
 
#include <gsl/span>
 
#include <functional>
#include <memory>
#include <optional>
#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 dequantizeMeshData = true;
 
  bool applyTextureTransform = true;
 
  CesiumGltf::Ktx2TranscodeTargets ktx2TranscodeTargets;
 
  CesiumUtility::IntrusivePointer<GltfSharedAssetSystem> pSharedAssetSystem =
      GltfSharedAssetSystem::getDefault();
};
 
class CESIUMGLTFREADER_API GltfReader {
public:
  GltfReader();
 
  CesiumJsonReader::JsonReaderOptions& getOptions();
 
  const CesiumJsonReader::JsonReaderOptions& getExtensions() const;
 
  GltfReaderResult readGltf(
      const gsl::span<const std::byte>& data,
      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(
      CesiumAsync::AsyncSystem asyncSystem,
      const std::string& baseUrl,
      const CesiumAsync::HttpHeaders& headers,
      std::shared_ptr<CesiumAsync::IAssetAccessor> pAssetAccessor,
      const GltfReaderOptions& options,
      GltfReaderResult&& result);
 
  [[deprecated(
      "Use ImageDecoder::readImage instead.")]] static ImageReaderResult
  readImage(
      const gsl::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