dracox 0.0.1__cp39-cp39-win_amd64.whl

include/draco/point_cloud/point_cloud.h

@@ -0,0 +1,289 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_POINT_CLOUD_POINT_CLOUD_H_
+#define DRACO_POINT_CLOUD_POINT_CLOUD_H_
+
+#include "draco/attributes/point_attribute.h"
+#include "draco/core/bounding_box.h"
+#include "draco/core/vector_d.h"
+#include "draco/draco_features.h"
+#include "draco/metadata/geometry_metadata.h"
+
+#ifdef DRACO_TRANSCODER_SUPPORTED
+#include "draco/compression/draco_compression_options.h"
+#endif
+
+namespace draco {
+
+// PointCloud is a collection of n-dimensional points that are described by a
+// set of PointAttributes that can represent data such as positions or colors
+// of individual points (see point_attribute.h).
+class PointCloud {
+ public:
+  PointCloud();
+  virtual ~PointCloud() = default;
+
+#ifdef DRACO_TRANSCODER_SUPPORTED
+  // Copies all data from the |src| point cloud.
+  void Copy(const PointCloud &src);
+#endif
+
+  // Returns the number of named attributes of a given type.
+  int32_t NumNamedAttributes(GeometryAttribute::Type type) const;
+
+  // Returns attribute id of the first named attribute with a given type or -1
+  // when the attribute is not used by the point cloud.
+  int32_t GetNamedAttributeId(GeometryAttribute::Type type) const;
+
+  // Returns the id of the i-th named attribute of a given type.
+  int32_t GetNamedAttributeId(GeometryAttribute::Type type, int i) const;
+
+  // Returns the first named attribute of a given type or nullptr if the
+  // attribute is not used by the point cloud.
+  const PointAttribute *GetNamedAttribute(GeometryAttribute::Type type) const;
+
+  // Returns the i-th named attribute of a given type.
+  const PointAttribute *GetNamedAttribute(GeometryAttribute::Type type,
+                                          int i) const;
+
+  // Returns the named attribute of a given unique id.
+  const PointAttribute *GetNamedAttributeByUniqueId(
+      GeometryAttribute::Type type, uint32_t id) const;
+
+  // Returns the attribute of a given unique id.
+  const PointAttribute *GetAttributeByUniqueId(uint32_t id) const;
+  int32_t GetAttributeIdByUniqueId(uint32_t unique_id) const;
+
+#ifdef DRACO_TRANSCODER_SUPPORTED
+  // Returns the named attribute with a given name.
+  const PointAttribute *GetNamedAttributeByName(GeometryAttribute::Type type,
+                                                const std::string &name) const;
+#endif  // DRACO_TRANSCODER_SUPPORTED
+
+  int32_t num_attributes() const {
+    return static_cast<int32_t>(attributes_.size());
+  }
+  const PointAttribute *attribute(int32_t att_id) const {
+    DRACO_DCHECK_LE(0, att_id);
+    DRACO_DCHECK_LT(att_id, static_cast<int32_t>(attributes_.size()));
+    return attributes_[att_id].get();
+  }
+
+  // Returned attribute can be modified, but it's caller's responsibility to
+  // maintain the attribute's consistency with draco::PointCloud.
+  PointAttribute *attribute(int32_t att_id) {
+    DRACO_DCHECK_LE(0, att_id);
+    DRACO_DCHECK_LT(att_id, static_cast<int32_t>(attributes_.size()));
+    return attributes_[att_id].get();
+  }
+
+  // Adds a new attribute to the point cloud.
+  // Returns the attribute id.
+  int AddAttribute(std::unique_ptr<PointAttribute> pa);
+
+  // Creates and adds a new attribute to the point cloud. The attribute has
+  // properties derived from the provided GeometryAttribute |att|.
+  // If |identity_mapping| is set to true, the attribute will use identity
+  // mapping between point indices and attribute value indices (i.e., each
+  // point has a unique attribute value). If |identity_mapping| is false, the
+  // mapping between point indices and attribute value indices is set to
+  // explicit, and it needs to be initialized manually using the
+  // PointAttribute::SetPointMapEntry() method. |num_attribute_values| can be
+  // used to specify the number of attribute values that are going to be
+  // stored in the newly created attribute. Returns attribute id of the newly
+  // created attribute or -1 in case of failure.
+  int AddAttribute(const GeometryAttribute &att, bool identity_mapping,
+                   AttributeValueIndex::ValueType num_attribute_values);
+
+  // Creates and returns a new attribute or nullptr in case of failure. This
+  // method is similar to AddAttribute(), except that it returns the new
+  // attribute instead of adding it to the point cloud.
+  std::unique_ptr<PointAttribute> CreateAttribute(
+      const GeometryAttribute &att, bool identity_mapping,
+      AttributeValueIndex::ValueType num_attribute_values) const;
+
+  // Assigns an attribute id to a given PointAttribute. If an attribute with
+  // the same attribute id already exists, it is deleted.
+  virtual void SetAttribute(int att_id, std::unique_ptr<PointAttribute> pa);
+
+  // Deletes an attribute with specified attribute id. Note that this changes
+  // attribute ids of all subsequent attributes.
+  virtual void DeleteAttribute(int att_id);
+
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+  // Deduplicates all attribute values (all attribute entries with the same
+  // value are merged into a single entry).
+  virtual bool DeduplicateAttributeValues();
+#endif
+
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+  // Removes duplicate point ids (two point ids are duplicate when all of their
+  // attributes are mapped to the same entry ids).
+  virtual void DeduplicatePointIds();
+#endif
+
+  // Get bounding box.
+  BoundingBox ComputeBoundingBox() const;
+
+  // Add metadata.
+  void AddMetadata(std::unique_ptr<GeometryMetadata> metadata) {
+    metadata_ = std::move(metadata);
+  }
+
+  // Add metadata for an attribute.
+  void AddAttributeMetadata(int32_t att_id,
+                            std::unique_ptr<AttributeMetadata> metadata) {
+    if (!metadata_) {
+      metadata_ = std::unique_ptr<GeometryMetadata>(new GeometryMetadata());
+    }
+    const int32_t att_unique_id = attribute(att_id)->unique_id();
+    metadata->set_att_unique_id(att_unique_id);
+    metadata_->AddAttributeMetadata(std::move(metadata));
+  }
+
+  const AttributeMetadata *GetAttributeMetadataByAttributeId(
+      int32_t att_id) const {
+    if (metadata_ == nullptr) {
+      return nullptr;
+    }
+    const uint32_t unique_id = attribute(att_id)->unique_id();
+    return metadata_->GetAttributeMetadataByUniqueId(unique_id);
+  }
+
+  // Returns the attribute metadata that has the requested metadata entry.
+  const AttributeMetadata *GetAttributeMetadataByStringEntry(
+      const std::string &name, const std::string &value) const {
+    if (metadata_ == nullptr) {
+      return nullptr;
+    }
+    return metadata_->GetAttributeMetadataByStringEntry(name, value);
+  }
+
+  // Returns the first attribute that has the requested metadata entry.
+  int GetAttributeIdByMetadataEntry(const std::string &name,
+                                    const std::string &value) const {
+    if (metadata_ == nullptr) {
+      return -1;
+    }
+    const AttributeMetadata *att_metadata =
+        metadata_->GetAttributeMetadataByStringEntry(name, value);
+    if (!att_metadata) {
+      return -1;
+    }
+    return GetAttributeIdByUniqueId(att_metadata->att_unique_id());
+  }
+
+  // Get a const pointer of the metadata of the point cloud.
+  const GeometryMetadata *GetMetadata() const { return metadata_.get(); }
+
+  // Get a pointer to the metadata of the point cloud.
+  GeometryMetadata *metadata() { return metadata_.get(); }
+
+  // Returns the number of n-dimensional points stored within the point cloud.
+  PointIndex::ValueType num_points() const { return num_points_; }
+
+  // Sets the number of points. It's the caller's responsibility to ensure the
+  // new number is valid with respect to the PointAttributes stored in the point
+  // cloud.
+  void set_num_points(PointIndex::ValueType num) { num_points_ = num; }
+
+#ifdef DRACO_TRANSCODER_SUPPORTED
+  // Enables or disables Draco geometry compression for this mesh.
+  void SetCompressionEnabled(bool enabled) { compression_enabled_ = enabled; }
+  bool IsCompressionEnabled() const { return compression_enabled_; }
+
+  // Sets |options| that configure Draco geometry compression. This does not
+  // enable or disable compression.
+  void SetCompressionOptions(const DracoCompressionOptions &options) {
+    compression_options_ = options;
+  }
+  const DracoCompressionOptions &GetCompressionOptions() const {
+    return compression_options_;
+  }
+  DracoCompressionOptions &GetCompressionOptions() {
+    return compression_options_;
+  }
+#endif  // DRACO_TRANSCODER_SUPPORTED
+
+ protected:
+#ifdef DRACO_TRANSCODER_SUPPORTED
+  // Copies metadata from the |src| point cloud.
+  void CopyMetadata(const PointCloud &src);
+#endif
+
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+  // Applies id mapping of deduplicated points (called by DeduplicatePointIds).
+  virtual void ApplyPointIdDeduplication(
+      const IndexTypeVector<PointIndex, PointIndex> &id_map,
+      const std::vector<PointIndex> &unique_point_ids);
+#endif
+
+ private:
+  // Metadata for the point cloud.
+  std::unique_ptr<GeometryMetadata> metadata_;
+
+  // Attributes describing the point cloud.
+  std::vector<std::unique_ptr<PointAttribute>> attributes_;
+
+  // Ids of named attributes of the given type.
+  std::vector<int32_t>
+      named_attribute_index_[GeometryAttribute::NAMED_ATTRIBUTES_COUNT];
+
+  // The number of n-dimensional points. All point attribute values are stored
+  // in corresponding PointAttribute instances in the |attributes_| array.
+  PointIndex::ValueType num_points_;
+
+#ifdef DRACO_TRANSCODER_SUPPORTED
+  // Compression options for this geometry.
+  // TODO(vytyaz): Store encoded bitstream that this geometry compresses into.
+  bool compression_enabled_ = false;
+  DracoCompressionOptions compression_options_;
+#endif  // DRACO_TRANSCODER_SUPPORTED
+
+  friend struct PointCloudHasher;
+};
+
+// Functor for computing a hash from data stored within a point cloud.
+// Note that this can be quite slow. Two point clouds will have the same hash
+// only when all points have the same order and when all attribute values are
+// exactly the same.
+struct PointCloudHasher {
+  size_t operator()(const PointCloud &pc) const {
+    size_t hash = pc.num_points_;
+    hash = HashCombine(pc.attributes_.size(), hash);
+    for (int i = 0; i < GeometryAttribute::NAMED_ATTRIBUTES_COUNT; ++i) {
+      hash = HashCombine(pc.named_attribute_index_[i].size(), hash);
+      for (int j = 0; j < static_cast<int>(pc.named_attribute_index_[i].size());
+           ++j) {
+        hash = HashCombine(pc.named_attribute_index_[i][j], hash);
+      }
+    }
+    // Hash attributes.
+    for (int i = 0; i < static_cast<int>(pc.attributes_.size()); ++i) {
+      PointAttributeHasher att_hasher;
+      hash = HashCombine(att_hasher(*pc.attributes_[i]), hash);
+    }
+    // Hash metadata.
+    GeometryMetadataHasher metadata_hasher;
+    if (pc.metadata_) {
+      hash = HashCombine(metadata_hasher(*pc.metadata_), hash);
+    }
+    return hash;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_POINT_CLOUD_POINT_CLOUD_H_

include/draco/point_cloud/point_cloud_builder.h

@@ -0,0 +1,101 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_POINT_CLOUD_POINT_CLOUD_BUILDER_H_
+#define DRACO_POINT_CLOUD_POINT_CLOUD_BUILDER_H_
+
+#include <utility>
+
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+// A helper class for constructing PointCloud instances from other data sources.
+// Usage:
+//   PointCloudBuilder builder;
+//   // Initialize the builder for a given number of points (required).
+//   builder.Start(num_points);
+//   // Specify desired attributes.
+//   int pos_att_id =
+//       builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+//   // Add attribute values.
+//   for (PointIndex i(0); i < num_points; ++i) {
+//     builder.SetAttributeValueForPoint(pos_att_id, i, input_pos[i.value()]);
+//   }
+//   // Get the final PointCloud.
+//   constexpr bool deduplicate_points = false;
+//   std::unique_ptr<PointCloud> pc = builder.Finalize(deduplicate_points);
+
+class PointCloudBuilder {
+ public:
+  // Index type of the inserted element.
+  typedef PointIndex ElementIndex;
+
+  PointCloudBuilder();
+
+  // Starts collecting point cloud data.
+  // The behavior of other functions is undefined before this method is called.
+  void Start(PointIndex::ValueType num_points);
+
+  int AddAttribute(GeometryAttribute::Type attribute_type,
+                   int8_t num_components, DataType data_type);
+  int AddAttribute(GeometryAttribute::Type attribute_type,
+                   int8_t num_components, DataType data_type, bool normalized);
+
+  // Sets attribute value for a specific point.
+  // |attribute_value| must contain data in the format specified by the
+  // AddAttribute method.
+  void SetAttributeValueForPoint(int att_id, PointIndex point_index,
+                                 const void *attribute_value);
+
+  // Sets attribute values for all points. All the values must be stored in the
+  // input |attribute_values| buffer. |stride| can be used to define the byte
+  // offset between two consecutive attribute values. If |stride| is set to 0,
+  // the stride is automatically computed based on the format of the given
+  // attribute.
+  void SetAttributeValuesForAllPoints(int att_id, const void *attribute_values,
+                                      int stride);
+
+  // Sets the unique ID for an attribute created with AddAttribute().
+  void SetAttributeUniqueId(int att_id, uint32_t unique_id);
+
+#ifdef DRACO_TRANSCODER_SUPPORTED
+  // Sets attribute name.
+  void SetAttributeName(int att_id, const std::string &name);
+#endif  // DRACO_TRANSCODER_SUPPORTED
+
+  // Finalizes the PointCloud or returns nullptr on error.
+  // If |deduplicate_points| is set to true, the following happens:
+  //   1. Attribute values with duplicate entries are deduplicated.
+  //   2. Point ids that are mapped to the same attribute values are
+  //      deduplicated.
+  // Therefore, if |deduplicate_points| is true the final PointCloud can have
+  // a different number of point from the value specified in the Start method.
+  // Once this function is called, the builder becomes invalid and cannot be
+  // used until the method Start() is called again.
+  std::unique_ptr<PointCloud> Finalize(bool deduplicate_points);
+
+  // Add metadata for an attribute.
+  void AddAttributeMetadata(int32_t att_id,
+                            std::unique_ptr<AttributeMetadata> metadata) {
+    point_cloud_->AddAttributeMetadata(att_id, std::move(metadata));
+  }
+
+ private:
+  std::unique_ptr<PointCloud> point_cloud_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_POINT_CLOUD_POINT_CLOUD_BUILDER_H_

lib/pkgconfig/draco.pc

@@ -0,0 +1,6 @@
+Name: draco
+Description: Draco geometry de(com)pression library.
+Version: 1.5.7
+Cflags: -Iinclude
+Libs: -Llib -ldraco
+Libs.private: 

share/cmake/draco/draco-config-version.cmake

@@ -0,0 +1,43 @@
+# This is a basic version file for the Config-mode of find_package().
+# It is used by write_basic_package_version_file() as input file for configure_file()
+# to create a version-file which can be installed along a config.cmake file.
+#
+# The created file sets PACKAGE_VERSION_EXACT if the current version string and
+# the requested version string are exactly the same and it sets
+# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version.
+# The variable CVF_VERSION must be set before calling configure_file().
+
+set(PACKAGE_VERSION "1.5.7")
+
+if (PACKAGE_FIND_VERSION_RANGE)
+  # Package version must be in the requested version range
+  if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN)
+      OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX)
+        OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX)))
+    set(PACKAGE_VERSION_COMPATIBLE FALSE)
+  else()
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  endif()
+else()
+  if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
+    set(PACKAGE_VERSION_COMPATIBLE FALSE)
+  else()
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
+      set(PACKAGE_VERSION_EXACT TRUE)
+    endif()
+  endif()
+endif()
+
+
+# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it:
+if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "")
+  return()
+endif()
+
+# check that the installed version has the same 32/64bit-ness as the one which is currently searching:
+if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8")
+  math(EXPR installedBits "8 * 8")
+  set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)")
+  set(PACKAGE_VERSION_UNSUITABLE TRUE)
+endif()

share/cmake/draco/draco-config.cmake

@@ -0,0 +1,27 @@
+
+####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() #######
+####### Any changes to this file will be overwritten by the next CMake run ####
+####### The input file was draco-config.cmake.template                            ########
+
+get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE)
+
+macro(set_and_check _var _file)
+  set(${_var} "${_file}")
+  if(NOT EXISTS "${_file}")
+    message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !")
+  endif()
+endmacro()
+
+macro(check_required_components _NAME)
+  foreach(comp ${${_NAME}_FIND_COMPONENTS})
+    if(NOT ${_NAME}_${comp}_FOUND)
+      if(${_NAME}_FIND_REQUIRED_${comp})
+        set(${_NAME}_FOUND FALSE)
+      endif()
+    endif()
+  endforeach()
+endmacro()
+
+####################################################################################
+
+include("${CMAKE_CURRENT_LIST_DIR}/draco-targets.cmake")

share/cmake/draco/draco-targets-release.cmake

@@ -0,0 +1,19 @@
+#----------------------------------------------------------------
+# Generated CMake target import file for configuration "Release".
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Import target "draco::draco" for configuration "Release"
+set_property(TARGET draco::draco APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(draco::draco PROPERTIES
+  IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/draco.lib"
+  )
+
+list(APPEND _cmake_import_check_targets draco::draco )
+list(APPEND _cmake_import_check_files_for_draco::draco "${_IMPORT_PREFIX}/lib/draco.lib" )
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)

share/cmake/draco/draco-targets.cmake

@@ -0,0 +1,107 @@
+# Generated by CMake
+
+if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8)
+   message(FATAL_ERROR "CMake >= 2.8.3 required")
+endif()
+if(CMAKE_VERSION VERSION_LESS "2.8.3")
+   message(FATAL_ERROR "CMake >= 2.8.3 required")
+endif()
+cmake_policy(PUSH)
+cmake_policy(VERSION 2.8.3...3.29)
+#----------------------------------------------------------------
+# Generated CMake target import file.
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Protect against multiple inclusion, which would fail when already imported targets are added once more.
+set(_cmake_targets_defined "")
+set(_cmake_targets_not_defined "")
+set(_cmake_expected_targets "")
+foreach(_cmake_expected_target IN ITEMS draco::draco)
+  list(APPEND _cmake_expected_targets "${_cmake_expected_target}")
+  if(TARGET "${_cmake_expected_target}")
+    list(APPEND _cmake_targets_defined "${_cmake_expected_target}")
+  else()
+    list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}")
+  endif()
+endforeach()
+unset(_cmake_expected_target)
+if(_cmake_targets_defined STREQUAL _cmake_expected_targets)
+  unset(_cmake_targets_defined)
+  unset(_cmake_targets_not_defined)
+  unset(_cmake_expected_targets)
+  unset(CMAKE_IMPORT_FILE_VERSION)
+  cmake_policy(POP)
+  return()
+endif()
+if(NOT _cmake_targets_defined STREQUAL "")
+  string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}")
+  string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}")
+  message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n")
+endif()
+unset(_cmake_targets_defined)
+unset(_cmake_targets_not_defined)
+unset(_cmake_expected_targets)
+
+
+# Compute the installation prefix relative to this file.
+get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+if(_IMPORT_PREFIX STREQUAL "/")
+  set(_IMPORT_PREFIX "")
+endif()
+
+# Create imported target draco::draco
+add_library(draco::draco STATIC IMPORTED)
+
+set_target_properties(draco::draco PROPERTIES
+  INTERFACE_COMPILE_FEATURES "cxx_std_11"
+  INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include"
+)
+
+# Load information for each installed configuration.
+file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/draco-targets-*.cmake")
+foreach(_cmake_config_file IN LISTS _cmake_config_files)
+  include("${_cmake_config_file}")
+endforeach()
+unset(_cmake_config_file)
+unset(_cmake_config_files)
+
+# Cleanup temporary variables.
+set(_IMPORT_PREFIX)
+
+# Loop over all imported files and verify that they actually exist
+foreach(_cmake_target IN LISTS _cmake_import_check_targets)
+  if(CMAKE_VERSION VERSION_LESS "3.28"
+      OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target}
+      OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}")
+    foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}")
+      if(NOT EXISTS "${_cmake_file}")
+        message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file
+   \"${_cmake_file}\"
+but this file does not exist.  Possible reasons include:
+* The file was deleted, renamed, or moved to another location.
+* An install or uninstall procedure did not complete successfully.
+* The installation package was faulty and contained
+   \"${CMAKE_CURRENT_LIST_FILE}\"
+but not all the files it references.
+")
+      endif()
+    endforeach()
+  endif()
+  unset(_cmake_file)
+  unset("_cmake_import_check_files_for_${_cmake_target}")
+endforeach()
+unset(_cmake_target)
+unset(_cmake_import_check_targets)
+
+# This file does not depend on other imported targets which have
+# been exported from the same project but in a separate export set.
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
+cmake_policy(POP)