Method resolveExternalData

CesiumGltfReader/src/GltfReader.cpp:529–765

static*/

}

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

  // TODO: Can we avoid this copy conversion?
  std::vector<IAssetAccessor::THeader> tHeaders(headers.begin(), headers.end());

  if (!result.model) {
    return asyncSystem.createResolvedFuture(std::move(result));
  }

  // Get a rough count of how many external buffers we may have.
  // Some of these may be data uris though.
  size_t uriBuffersCount = 0;
  for (const Buffer& buffer : result.model->buffers) {
    if (buffer.uri) {
      ++uriBuffersCount;
    }
  }

  for (const Image& image : result.model->images) {
    if (image.uri) {
      ++uriBuffersCount;
    }
  }

  {
    // We need to obtain the extension to find out if we have another buffer we
    // need to resolve. We can't use this pointer later since the result is
    // moved, so we'll do it twice.
    ExtensionModelExtStructuralMetadata* pStructuralMetadataTemp =
        result.model->getExtension<ExtensionModelExtStructuralMetadata>();

    if (pStructuralMetadataTemp &&
        pStructuralMetadataTemp->schemaUri.has_value()) {
      ++uriBuffersCount;
    }
  }

  if (uriBuffersCount == 0) {
    return asyncSystem.createResolvedFuture(std::move(result));
  }

  auto pResult = std::make_unique<GltfReaderResult>(std::move(result));

  struct ExternalBufferLoadResult {
    bool success = false;
    std::string bufferUri;
    ErrorList warningsAndErrors;
  };

  std::vector<Future<ExternalBufferLoadResult>> resolvedBuffers;
  resolvedBuffers.reserve(uriBuffersCount);