dracox 0.0.1__cp39-cp39-win_amd64.whl

include/draco/mesh/valence_cache.h

@@ -0,0 +1,142 @@
+// 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_MESH_VALENCE_CACHE_H_
+#define DRACO_MESH_VALENCE_CACHE_H_
+
+#include "draco/attributes/geometry_indices.h"
+#include "draco/core/draco_index_type_vector.h"
+#include "draco/core/macros.h"
+
+namespace draco {
+
+// ValenceCache provides support for the caching of valences off of some kind of
+// CornerTable 'type' of class.
+// No valences should be queried before Caching is
+// performed and values should be removed/recached when changes to the
+// underlying mesh are taking place.
+
+template <class CornerTableT>
+class ValenceCache {
+  const CornerTableT &table_;
+
+ public:
+  explicit ValenceCache(const CornerTableT &table) : table_(table) {}
+
+  // Do not call before CacheValences() / CacheValencesInaccurate().
+  inline int8_t ValenceFromCacheInaccurate(CornerIndex c) const {
+    if (c == kInvalidCornerIndex) {
+      return -1;
+    }
+    return ValenceFromCacheInaccurate(table_.Vertex(c));
+  }
+  inline int32_t ValenceFromCache(CornerIndex c) const {
+    if (c == kInvalidCornerIndex) {
+      return -1;
+    }
+    return ValenceFromCache(table_.Vertex(c));
+  }
+
+  inline int32_t ConfidentValenceFromCache(VertexIndex v) const {
+    DRACO_DCHECK_LT(v.value(), table_.num_vertices());
+    DRACO_DCHECK_EQ(vertex_valence_cache_32_bit_.size(), table_.num_vertices());
+    return vertex_valence_cache_32_bit_[v];
+  }
+
+  // Collect the valence for all vertices so they can be reused later.  The
+  // 'inaccurate' versions of this family of functions clips the true valence
+  // of the vertices to 8 signed bits as a space optimization.  This clipping
+  // will lead to occasionally wrong results.  If accurate results are required
+  // under all circumstances, do not use the 'inaccurate' version or else
+  // use it and fetch the correct result in the event the value appears clipped.
+  // The topology of the mesh should be a constant when Valence Cache functions
+  // are being used.  Modification of the mesh while cache(s) are filled will
+  // not guarantee proper results on subsequent calls unless they are rebuilt.
+  void CacheValencesInaccurate() const {
+    if (vertex_valence_cache_8_bit_.size() == 0) {
+      const VertexIndex vertex_count = VertexIndex(table_.num_vertices());
+      vertex_valence_cache_8_bit_.resize(vertex_count.value());
+      for (VertexIndex v = VertexIndex(0); v < vertex_count; v += 1) {
+        vertex_valence_cache_8_bit_[v] = static_cast<int8_t>(
+            (std::min)(static_cast<int32_t>(std::numeric_limits<int8_t>::max()),
+                       table_.Valence(v)));
+      }
+    }
+  }
+  void CacheValences() const {
+    if (vertex_valence_cache_32_bit_.size() == 0) {
+      const VertexIndex vertex_count = VertexIndex(table_.num_vertices());
+      vertex_valence_cache_32_bit_.resize(vertex_count.value());
+      for (VertexIndex v = VertexIndex(0); v < vertex_count; v += 1) {
+        vertex_valence_cache_32_bit_[v] = table_.Valence(v);
+      }
+    }
+  }
+
+  inline int8_t ConfidentValenceFromCacheInaccurate(CornerIndex c) const {
+    DRACO_DCHECK_GE(c.value(), 0);
+    return ConfidentValenceFromCacheInaccurate(table_.ConfidentVertex(c));
+  }
+  inline int32_t ConfidentValenceFromCache(CornerIndex c) const {
+    DRACO_DCHECK_GE(c.value(), 0);
+    return ConfidentValenceFromCache(table_.ConfidentVertex(c));
+  }
+  inline int8_t ValenceFromCacheInaccurate(VertexIndex v) const {
+    DRACO_DCHECK_EQ(vertex_valence_cache_8_bit_.size(), table_.num_vertices());
+    if (v == kInvalidVertexIndex || v.value() >= table_.num_vertices()) {
+      return -1;
+    }
+    return ConfidentValenceFromCacheInaccurate(v);
+  }
+  inline int8_t ConfidentValenceFromCacheInaccurate(VertexIndex v) const {
+    DRACO_DCHECK_LT(v.value(), table_.num_vertices());
+    DRACO_DCHECK_EQ(vertex_valence_cache_8_bit_.size(), table_.num_vertices());
+    return vertex_valence_cache_8_bit_[v];
+  }
+
+  // TODO(draco-eng) Add unit tests for ValenceCache functions.
+  inline int32_t ValenceFromCache(VertexIndex v) const {
+    DRACO_DCHECK_EQ(vertex_valence_cache_32_bit_.size(), table_.num_vertices());
+    if (v == kInvalidVertexIndex || v.value() >= table_.num_vertices()) {
+      return -1;
+    }
+    return ConfidentValenceFromCache(v);
+  }
+
+  // Clear the cache of valences and deallocate the memory.
+  void ClearValenceCacheInaccurate() const {
+    vertex_valence_cache_8_bit_.clear();
+    // Force erasure.
+    IndexTypeVector<VertexIndex, int8_t>().swap(vertex_valence_cache_8_bit_);
+  }
+  void ClearValenceCache() const {
+    vertex_valence_cache_32_bit_.clear();
+    // Force erasure.
+    IndexTypeVector<VertexIndex, int32_t>().swap(vertex_valence_cache_32_bit_);
+  }
+
+  bool IsCacheEmpty() const {
+    return vertex_valence_cache_8_bit_.size() == 0 &&
+           vertex_valence_cache_32_bit_.size() == 0;
+  }
+
+ private:
+  // Retain valences and clip them to char size.
+  mutable IndexTypeVector<VertexIndex, int8_t> vertex_valence_cache_8_bit_;
+  mutable IndexTypeVector<VertexIndex, int32_t> vertex_valence_cache_32_bit_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_VALENCE_CACHE_H_

include/draco/metadata/geometry_metadata.h

@@ -0,0 +1,142 @@
+// Copyright 2017 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_METADATA_GEOMETRY_METADATA_H_
+#define DRACO_METADATA_GEOMETRY_METADATA_H_
+
+#include "draco/metadata/metadata.h"
+
+namespace draco {
+
+// Class for representing specifically metadata of attributes. It must have an
+// attribute id which should be identical to it's counterpart attribute in
+// the point cloud it belongs to.
+class AttributeMetadata : public Metadata {
+ public:
+  AttributeMetadata() : att_unique_id_(0) {}
+  AttributeMetadata(const AttributeMetadata &metadata);
+  explicit AttributeMetadata(const Metadata &metadata)
+      : Metadata(metadata), att_unique_id_(0) {}
+
+  void set_att_unique_id(uint32_t att_unique_id) {
+    att_unique_id_ = att_unique_id;
+  }
+  // The unique id of the attribute that this metadata belongs to.
+  uint32_t att_unique_id() const { return att_unique_id_; }
+
+ private:
+  uint32_t att_unique_id_;
+
+  friend struct AttributeMetadataHasher;
+  friend class PointCloud;
+};
+
+// Functor for computing a hash from data stored in a AttributeMetadata class.
+struct AttributeMetadataHasher {
+  size_t operator()(const AttributeMetadata &metadata) const {
+    size_t hash = metadata.att_unique_id_;
+    MetadataHasher metadata_hasher;
+    hash = HashCombine(metadata_hasher(static_cast<const Metadata &>(metadata)),
+                       hash);
+    return hash;
+  }
+};
+
+// Class for representing the metadata for a point cloud. It could have a list
+// of attribute metadata.
+class GeometryMetadata : public Metadata {
+ public:
+  GeometryMetadata() {}
+  GeometryMetadata(const GeometryMetadata &metadata);
+  explicit GeometryMetadata(const Metadata &metadata) : Metadata(metadata) {}
+
+  const AttributeMetadata *GetAttributeMetadataByStringEntry(
+      const std::string &entry_name, const std::string &entry_value) const;
+  bool AddAttributeMetadata(std::unique_ptr<AttributeMetadata> att_metadata);
+
+  void DeleteAttributeMetadataByUniqueId(int32_t att_unique_id) {
+    if (att_unique_id < 0) {
+      return;
+    }
+    for (auto itr = att_metadatas_.begin(); itr != att_metadatas_.end();
+         ++itr) {
+      if (itr->get()->att_unique_id() == static_cast<uint32_t>(att_unique_id)) {
+        att_metadatas_.erase(itr);
+        return;
+      }
+    }
+  }
+
+  const AttributeMetadata *GetAttributeMetadataByUniqueId(
+      int32_t att_unique_id) const {
+    if (att_unique_id < 0) {
+      return nullptr;
+    }
+
+    // TODO(draco-eng): Consider using unordered_map instead of vector to store
+    // attribute metadata.
+    for (auto &&att_metadata : att_metadatas_) {
+      if (att_metadata->att_unique_id() ==
+          static_cast<uint32_t>(att_unique_id)) {
+        return att_metadata.get();
+      }
+    }
+    return nullptr;
+  }
+
+  AttributeMetadata *attribute_metadata(int32_t att_unique_id) {
+    if (att_unique_id < 0) {
+      return nullptr;
+    }
+
+    // TODO(draco-eng): Consider use unordered_map instead of vector to store
+    // attribute metadata.
+    for (auto &&att_metadata : att_metadatas_) {
+      if (att_metadata->att_unique_id() ==
+          static_cast<uint32_t>(att_unique_id)) {
+        return att_metadata.get();
+      }
+    }
+    return nullptr;
+  }
+
+  const std::vector<std::unique_ptr<AttributeMetadata>> &attribute_metadatas()
+      const {
+    return att_metadatas_;
+  }
+
+ private:
+  std::vector<std::unique_ptr<AttributeMetadata>> att_metadatas_;
+
+  friend struct GeometryMetadataHasher;
+};
+
+// Functor for computing a hash from data stored in a GeometryMetadata class.
+struct GeometryMetadataHasher {
+  size_t operator()(const GeometryMetadata &metadata) const {
+    size_t hash = metadata.att_metadatas_.size();
+    AttributeMetadataHasher att_metadata_hasher;
+    for (auto &&att_metadata : metadata.att_metadatas_) {
+      hash = HashCombine(att_metadata_hasher(*att_metadata), hash);
+    }
+    MetadataHasher metadata_hasher;
+    hash = HashCombine(metadata_hasher(static_cast<const Metadata &>(metadata)),
+                       hash);
+    return hash;
+  }
+};
+
+}  // namespace draco
+
+#endif  // THIRD_PARTY_DRACO_METADATA_GEOMETRY_METADATA_H_

include/draco/metadata/metadata.h

@@ -0,0 +1,209 @@
+// Copyright 2017 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_METADATA_METADATA_H_
+#define DRACO_METADATA_METADATA_H_
+
+#include <cstring>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "draco/core/hash_utils.h"
+
+namespace draco {
+
+// Class for storing a value of an entry in Metadata. Internally it is
+// represented by a buffer of data. It can be accessed by various data types,
+// e.g. int, float, binary data or string.
+class EntryValue {
+ public:
+  template <typename DataTypeT>
+  explicit EntryValue(const DataTypeT &data) {
+    const size_t data_type_size = sizeof(DataTypeT);
+    data_.resize(data_type_size);
+    memcpy(&data_[0], &data, data_type_size);
+  }
+
+  template <typename DataTypeT>
+  explicit EntryValue(const std::vector<DataTypeT> &data) {
+    const size_t total_size = sizeof(DataTypeT) * data.size();
+    data_.resize(total_size);
+    memcpy(&data_[0], &data[0], total_size);
+  }
+
+  EntryValue(const EntryValue &value);
+  explicit EntryValue(const std::string &value);
+
+  template <typename DataTypeT>
+  bool GetValue(DataTypeT *value) const {
+    const size_t data_type_size = sizeof(DataTypeT);
+    if (data_type_size != data_.size()) {
+      return false;
+    }
+    memcpy(value, &data_[0], data_type_size);
+    return true;
+  }
+
+  template <typename DataTypeT>
+  bool GetValue(std::vector<DataTypeT> *value) const {
+    if (data_.empty()) {
+      return false;
+    }
+    const size_t data_type_size = sizeof(DataTypeT);
+    if (data_.size() % data_type_size != 0) {
+      return false;
+    }
+    value->resize(data_.size() / data_type_size);
+    memcpy(&value->at(0), &data_[0], data_.size());
+    return true;
+  }
+
+  const std::vector<uint8_t> &data() const { return data_; }
+
+ private:
+  std::vector<uint8_t> data_;
+
+  friend struct EntryValueHasher;
+};
+
+// Functor for computing a hash from data stored within an EntryValue.
+struct EntryValueHasher {
+  size_t operator()(const EntryValue &ev) const {
+    size_t hash = ev.data_.size();
+    for (size_t i = 0; i < ev.data_.size(); ++i) {
+      hash = HashCombine(ev.data_[i], hash);
+    }
+    return hash;
+  }
+};
+
+// Class for holding generic metadata. It has a list of entries which consist of
+// an entry name and an entry value. Each Metadata could also have nested
+// metadata.
+class Metadata {
+ public:
+  Metadata() {}
+  Metadata(const Metadata &metadata);
+  // In theory, we support all types of data as long as it could be serialized
+  // to binary data. We provide the following functions for inserting and
+  // accessing entries of common data types. For now, developers need to know
+  // the type of entries they are requesting.
+  void AddEntryInt(const std::string &name, int32_t value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is int32_t.
+  bool GetEntryInt(const std::string &name, int32_t *value) const;
+
+  void AddEntryIntArray(const std::string &name,
+                        const std::vector<int32_t> &value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is a vector of int32_t.
+  bool GetEntryIntArray(const std::string &name,
+                        std::vector<int32_t> *value) const;
+
+  void AddEntryDouble(const std::string &name, double value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is double.
+  bool GetEntryDouble(const std::string &name, double *value) const;
+
+  void AddEntryDoubleArray(const std::string &name,
+                           const std::vector<double> &value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is a vector of double.
+  bool GetEntryDoubleArray(const std::string &name,
+                           std::vector<double> *value) const;
+
+  void AddEntryString(const std::string &name, const std::string &value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is std::string.
+  bool GetEntryString(const std::string &name, std::string *value) const;
+
+  // Add a blob of data as an entry.
+  void AddEntryBinary(const std::string &name,
+                      const std::vector<uint8_t> &value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is a vector of uint8_t.
+  bool GetEntryBinary(const std::string &name,
+                      std::vector<uint8_t> *value) const;
+
+  bool AddSubMetadata(const std::string &name,
+                      std::unique_ptr<Metadata> sub_metadata);
+  const Metadata *GetSubMetadata(const std::string &name) const;
+  Metadata *sub_metadata(const std::string &name);
+
+  void RemoveEntry(const std::string &name);
+
+  int num_entries() const { return static_cast<int>(entries_.size()); }
+  const std::map<std::string, EntryValue> &entries() const { return entries_; }
+  const std::map<std::string, std::unique_ptr<Metadata>> &sub_metadatas()
+      const {
+    return sub_metadatas_;
+  }
+
+ private:
+  // Make this function private to avoid adding undefined data types.
+  template <typename DataTypeT>
+  void AddEntry(const std::string &entry_name, const DataTypeT &entry_value) {
+    const auto itr = entries_.find(entry_name);
+    if (itr != entries_.end()) {
+      entries_.erase(itr);
+    }
+    entries_.insert(std::make_pair(entry_name, EntryValue(entry_value)));
+  }
+
+  // Make this function private to avoid adding undefined data types.
+  template <typename DataTypeT>
+  bool GetEntry(const std::string &entry_name, DataTypeT *entry_value) const {
+    const auto itr = entries_.find(entry_name);
+    if (itr == entries_.end()) {
+      return false;
+    }
+    return itr->second.GetValue(entry_value);
+  }
+
+  std::map<std::string, EntryValue> entries_;
+  std::map<std::string, std::unique_ptr<Metadata>> sub_metadatas_;
+
+  friend struct MetadataHasher;
+};
+
+// Functor for computing a hash from data stored within a metadata class.
+struct MetadataHasher {
+  size_t operator()(const Metadata &metadata) const {
+    size_t hash =
+        HashCombine(metadata.entries_.size(), metadata.sub_metadatas_.size());
+    EntryValueHasher entry_value_hasher;
+    for (const auto &entry : metadata.entries_) {
+      hash = HashCombine(entry.first, hash);
+      hash = HashCombine(entry_value_hasher(entry.second), hash);
+    }
+    MetadataHasher metadata_hasher;
+    for (auto &&sub_metadata : metadata.sub_metadatas_) {
+      hash = HashCombine(sub_metadata.first, hash);
+      hash = HashCombine(metadata_hasher(*sub_metadata.second), hash);
+    }
+    return hash;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_METADATA_METADATA_H_

include/draco/metadata/metadata_decoder.h

@@ -0,0 +1,42 @@
+// Copyright 2017 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_METADATA_METADATA_DECODER_H_
+#define DRACO_METADATA_METADATA_DECODER_H_
+
+#include "draco/core/decoder_buffer.h"
+#include "draco/metadata/geometry_metadata.h"
+#include "draco/metadata/metadata.h"
+
+namespace draco {
+
+// Class for decoding the metadata.
+class MetadataDecoder {
+ public:
+  MetadataDecoder();
+  bool DecodeMetadata(DecoderBuffer *in_buffer, Metadata *metadata);
+  bool DecodeGeometryMetadata(DecoderBuffer *in_buffer,
+                              GeometryMetadata *metadata);
+
+ private:
+  bool DecodeMetadata(Metadata *metadata);
+  bool DecodeEntries(Metadata *metadata);
+  bool DecodeEntry(Metadata *metadata);
+  bool DecodeName(std::string *name);
+
+  DecoderBuffer *buffer_;
+};
+}  // namespace draco
+
+#endif  // DRACO_METADATA_METADATA_DECODER_H_

include/draco/metadata/metadata_encoder.h

@@ -0,0 +1,41 @@
+// Copyright 2017 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_METADATA_METADATA_ENCODER_H_
+#define DRACO_METADATA_METADATA_ENCODER_H_
+
+#include "draco/core/encoder_buffer.h"
+#include "draco/metadata/geometry_metadata.h"
+#include "draco/metadata/metadata.h"
+
+namespace draco {
+
+// Class for encoding metadata. It could encode either base Metadata class or
+// a metadata of a geometry, e.g. a point cloud.
+class MetadataEncoder {
+ public:
+  MetadataEncoder() {}
+
+  bool EncodeGeometryMetadata(EncoderBuffer *out_buffer,
+                              const GeometryMetadata *metadata);
+  bool EncodeMetadata(EncoderBuffer *out_buffer, const Metadata *metadata);
+
+ private:
+  bool EncodeAttributeMetadata(EncoderBuffer *out_buffer,
+                               const AttributeMetadata *metadata);
+  bool EncodeString(EncoderBuffer *out_buffer, const std::string &str);
+};
+}  // namespace draco
+
+#endif  // DRACO_METADATA_METADATA_ENCODER_H_

include/draco/metadata/property_attribute.h

@@ -0,0 +1,107 @@
+// Copyright 2023 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_METADATA_PROPERTY_ATTRIBUTE_H_
+#define DRACO_METADATA_PROPERTY_ATTRIBUTE_H_
+
+#include "draco/draco_features.h"
+
+#ifdef DRACO_TRANSCODER_SUPPORTED
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "draco/core/status_or.h"
+
+namespace draco {
+
+// Describes a property attribute as defined in the EXT_structural_metadata glTF
+// extension.
+class PropertyAttribute {
+ public:
+  // Describes where property is stored (as an attribute).
+  class Property {
+   public:
+    // Creates an empty property.
+    Property() = default;
+
+    // Methods for comparing two properties.
+    bool operator==(const Property &other) const;
+    bool operator!=(const Property &other) const { return !(*this == other); }
+
+    // Copies all data from |src| property.
+    void Copy(const Property &src);
+
+    // Name of this property.
+    void SetName(const std::string &name);
+    const std::string &GetName() const;
+
+    // Name of glTF attribute containing property values, like "_DIRECTION".
+    void SetAttributeName(const std::string &name);
+    const std::string &GetAttributeName() const;
+
+   private:
+    // Name of this property as in structural metadata schema class property.
+    std::string name_;
+
+    // Name of glTF attribute containing property values, like "_DIRECTION".
+    std::string attribute_name_;
+
+    // TODO(vytyaz): Support property value modifiers min, max, offset, scale.
+  };
+
+  // Creates an empty property attribute.
+  PropertyAttribute() = default;
+
+  // Methods for comparing two property attributes.
+  bool operator==(const PropertyAttribute &other) const;
+  bool operator!=(const PropertyAttribute &other) const {
+    return !(*this == other);
+  }
+
+  // Copies all data from |src| property attribute.
+  void Copy(const PropertyAttribute &src);
+
+  // Name of this property attribute.
+  void SetName(const std::string &value);
+  const std::string &GetName() const;
+
+  // Class of this property attribute.
+  void SetClass(const std::string &value);
+  const std::string &GetClass() const;
+
+  // Properties.
+  int AddProperty(std::unique_ptr<Property> property);
+  int NumProperties() const;
+  const Property &GetProperty(int index) const;
+  Property &GetProperty(int index);
+  void RemoveProperty(int index);
+
+ private:
+  // The name of the property attribute, e.g., for display purposes.
+  std::string name_;
+
+  // The class in structural metadata schema that property values conform to.
+  std::string class_;
+
+  // Properties corresponding to schema class properties, describing where the
+  // property values are stored (as attributes).
+  std::vector<std::unique_ptr<Property>> properties_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_TRANSCODER_SUPPORTED
+#endif  // DRACO_METADATA_PROPERTY_ATTRIBUTE_H_