dracox 0.0.1__cp39-cp39-win_amd64.whl

include/draco/mesh/mesh_cleanup.h

@@ -0,0 +1,61 @@
+// 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_MESH_CLEANUP_H_
+#define DRACO_MESH_MESH_CLEANUP_H_
+
+#include "draco/core/status.h"
+#include "draco/draco_features.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Options used by the MeshCleanup class.
+struct MeshCleanupOptions {
+  // If true, the cleanup tool removes any face where two or more vertices
+  // share the same position index.
+  bool remove_degenerated_faces = true;
+
+  // If true, the cleanup tool removes all duplicate faces. A pair of faces is
+  // duplicate if both faces share the same position indices on all vertices
+  // (that is, position values have to be duduplicated). Note that all
+  // non-position properties are currently ignored.
+  bool remove_duplicate_faces = true;
+
+  // If true, the cleanup tool removes any unused attribute value or unused
+  // point id. For example, it can be used to remove isolated vertices.
+  bool remove_unused_attributes = true;
+
+  // If true, the cleanup tool splits vertices along non-manifold edges and
+  // vertices. This ensures that the connectivity defined by position indices
+  // is manifold.
+  bool make_geometry_manifold = false;
+};
+
+// Tool that can be used for removing bad or unused data from draco::Meshes.
+class MeshCleanup {
+ public:
+  // Performs in-place cleanup of the input mesh according to the input options.
+  static Status Cleanup(Mesh *mesh, const MeshCleanupOptions &options);
+
+ private:
+  static void RemoveDegeneratedFaces(Mesh *mesh);
+  static void RemoveDuplicateFaces(Mesh *mesh);
+  static void RemoveUnusedAttributes(Mesh *mesh);
+  static Status MakeGeometryManifold(Mesh *mesh);
+};
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_MESH_CLEANUP_H_

include/draco/mesh/mesh_features.h

@@ -0,0 +1,93 @@
+// Copyright 2022 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_MESH_FEATURES_H_
+#define DRACO_MESH_MESH_FEATURES_H_
+
+#include "draco/draco_features.h"
+
+#ifdef DRACO_TRANSCODER_SUPPORTED
+#include <string>
+#include <vector>
+
+#include "draco/texture/texture_library.h"
+#include "draco/texture/texture_map.h"
+
+namespace draco {
+
+// Describes a mesh feature ID set according to the EXT_mesh_features glTF
+// extension. Feature IDs are either associated with geometry vertices or with
+// texture pixels and stored in a geometry attribute or in texture channels,
+// respectively. Optionally, the feature ID set may be associated with a
+// property table defined in the EXT_structural_metadata glTF extension.
+class MeshFeatures {
+ public:
+  // Creates an empty feature ID set that is associated neither with vertices,
+  // nor with texture pixels, nor with property tables.
+  MeshFeatures();
+
+  // Copies all data from |src| mesh feature ID set.
+  void Copy(const MeshFeatures &src);
+
+  // Label assigned to this feature ID set.
+  void SetLabel(const std::string &label);
+  const std::string &GetLabel() const;
+
+  // The number of unique features in this feature ID set.
+  void SetFeatureCount(int feature_count);
+  int GetFeatureCount() const;
+
+  // Non-negative null feature ID value indicating the absence of an associated
+  // feature. The value of -1 indicates that the null feature ID is not set.
+  void SetNullFeatureId(int null_feature_id);
+  int GetNullFeatureId() const;
+
+  // Index of the feature ID vertex attribute in draco::Mesh or -1 if the
+  // feature ID is not associated with vertices.
+  void SetAttributeIndex(int attribute_index);
+  int GetAttributeIndex() const;
+
+  // Feature ID texture map and texture channels containing feature IDs
+  // associated with texture pixels. Only used when |attribute_index_| is -1.
+  // The RGBA channels are numbered from 0 to 3. See the glTF extension
+  // documentation for reconstruction of feature ID from the channel values.
+  void SetTextureMap(const TextureMap &texture_map);
+  void SetTextureMap(Texture *texture, int tex_coord_index);
+  const TextureMap &GetTextureMap() const;
+  TextureMap &GetTextureMap();
+  void SetTextureChannels(const std::vector<int> &texture_channels);
+  const std::vector<int> &GetTextureChannels() const;
+  std::vector<int> &GetTextureChannels();
+
+  // Non-negative index of the property table this feature ID set is associated
+  // with. Property tables are defined in the EXT_structural_metadata glTF
+  // extension. The value of -1 indicates that this feature ID set is not
+  // associated with any property tables.
+  void SetPropertyTableIndex(int property_table_index);
+  int GetPropertyTableIndex() const;
+
+ private:
+  std::string label_;
+  int feature_count_;
+  int null_feature_id_;
+  int attribute_index_;
+  TextureMap texture_map_;
+  std::vector<int> texture_channels_;
+  int property_table_index_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_TRANSCODER_SUPPORTED
+#endif  // DRACO_MESH_MESH_FEATURES_H_

include/draco/mesh/mesh_indices.h

@@ -0,0 +1,37 @@
+// Copyright 2022 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.
+//
+#ifdef DRACO_TRANSCODER_SUPPORTED
+#ifndef DRACO_MESH_MESH_INDICES_H_
+#define DRACO_MESH_MESH_INDICES_H_
+
+#include <inttypes.h>
+
+#include <limits>
+
+#include "draco/core/draco_index_type.h"
+
+namespace draco {
+
+// Index of a mesh feature ID set.
+DEFINE_NEW_DRACO_INDEX_TYPE(uint32_t, MeshFeaturesIndex)
+
+// Constants denoting invalid indices.
+static constexpr MeshFeaturesIndex kInvalidMeshFeaturesIndex(
+    std::numeric_limits<uint32_t>::max());
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_MESH_INDICES_H_
+#endif  // DRACO_TRANSCODER_SUPPORTED

include/draco/mesh/mesh_misc_functions.h

@@ -0,0 +1,105 @@
+// 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.
+//
+// This file contains misc functions that are needed by several mesh related
+// algorithms.
+
+#ifndef DRACO_MESH_MESH_MISC_FUNCTIONS_H_
+#define DRACO_MESH_MESH_MISC_FUNCTIONS_H_
+
+#include <array>
+#include <cmath>
+#include <memory>
+
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/mesh.h"
+
+// The file contains functions that use both Mesh and CornerTable as inputs.
+namespace draco {
+
+// Creates a CornerTable from the position attribute of |mesh|. Returns nullptr
+// on error.
+std::unique_ptr<CornerTable> CreateCornerTableFromPositionAttribute(
+    const Mesh *mesh);
+
+// Creates a CornerTable from the first named attribute of |mesh| with a given
+// type. Returns nullptr on error.
+std::unique_ptr<CornerTable> CreateCornerTableFromAttribute(
+    const Mesh *mesh, GeometryAttribute::Type type);
+
+// Creates a CornerTable from all attributes of |mesh|. Boundaries are
+// automatically introduced on all attribute seams. Returns nullptr on error.
+std::unique_ptr<CornerTable> CreateCornerTableFromAllAttributes(
+    const Mesh *mesh);
+
+// Returns true when the given corner lies opposite to an attribute seam.
+inline bool IsCornerOppositeToAttributeSeam(CornerIndex ci,
+                                            const PointAttribute &att,
+                                            const Mesh &mesh,
+                                            const CornerTable &ct) {
+  const CornerIndex opp_ci = ct.Opposite(ci);
+  if (opp_ci == kInvalidCornerIndex) {
+    return false;  // No opposite corner == no attribute seam.
+  }
+  // Compare attribute value indices on both ends of the opposite edge.
+  CornerIndex c0 = ct.Next(ci);
+  CornerIndex c1 = ct.Previous(opp_ci);
+  if (att.mapped_index(mesh.CornerToPointId(c0)) !=
+      att.mapped_index(mesh.CornerToPointId(c1))) {
+    return true;
+  }
+  c0 = ct.Previous(ci);
+  c1 = ct.Next(opp_ci);
+  if (att.mapped_index(mesh.CornerToPointId(c0)) !=
+      att.mapped_index(mesh.CornerToPointId(c1))) {
+    return true;
+  }
+  return false;
+}
+
+// Interpolates an attribute value on a face using given barycentric
+// coordinates. InterpolatedVectorT should be a VectorD that corresponds to the
+// values stored in the attribute.
+template <typename InterpolatedVectorT>
+InterpolatedVectorT ComputeInterpolatedAttributeValueOnMeshFace(
+    const Mesh &mesh, const PointAttribute &attribute, FaceIndex fi,
+    const std::array<float, 3> &barycentric_coord) {
+  const Mesh::Face &face = mesh.face(fi);
+  // Get values for all three corners of the face.
+  InterpolatedVectorT val[3];
+  for (int c = 0; c < 3; ++c) {
+    attribute.GetMappedValue(face[c], &(val[c][0]));
+  }
+  if (val[1] == val[0] && val[2] == val[0]) {
+    // No need to interpolate anything if all values are the same.
+    return val[0];
+  }
+  // Return an interpolated value.
+  InterpolatedVectorT res;
+  for (int d = 0; d < InterpolatedVectorT::dimension; ++d) {
+    const float interpolated_component = barycentric_coord[0] * val[0][d] +
+                                         barycentric_coord[1] * val[1][d] +
+                                         barycentric_coord[2] * val[2][d];
+    if (std::is_integral<typename InterpolatedVectorT::Scalar>::value) {
+      res[d] = std::floor(interpolated_component + 0.5f);
+    } else {
+      res[d] = interpolated_component;
+    }
+  }
+  return res;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_MESH_MISC_FUNCTIONS_H_

include/draco/mesh/mesh_stripifier.h

@@ -0,0 +1,258 @@
+// 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_MESH_MESH_STRIPIFIER_H_
+#define DRACO_MESH_MESH_STRIPIFIER_H_
+
+#include "draco/mesh/mesh_misc_functions.h"
+
+namespace draco {
+
+// Class that generates triangle strips from a provided draco::Mesh data
+// structure. The strips represent a more memory efficient storage of triangle
+// connectivity that can be used directly on the GPU (see
+// https://en.wikipedia.org/wiki/Triangle_strip ). In general, a mesh needs to
+// be represented by several triangle strips and it has been proven that finding
+// the optimal set of triangle strips is an NP-complete problem. The algorithm
+// implemented by this class finds this set of triangle strips based on a greedy
+// heuristic that always selects the longest available strip that covers the
+// next unprocessed face. The longest strip is found by analyzing all strips
+// that can cover the given face (three strips corresponding to three
+// directions).
+class MeshStripifier {
+ public:
+  MeshStripifier()
+      : mesh_(nullptr),
+        num_strips_(0),
+        num_encoded_faces_(0),
+        last_encoded_point_(kInvalidPointIndex) {}
+
+  // Generate triangle strips for a given mesh and output them to the output
+  // iterator |out_it|. In most cases |out_it| stores the values in a buffer
+  // that can be used directly on the GPU. Note that the algorithm can generate
+  // multiple strips to represent the whole mesh. In such cases multiple strips
+  // are separated using a so called primitive restart index that is specified
+  // by the |primitive_restart_index| (usually defined as the maximum allowed
+  // value for the given type).
+  // https://www.khronos.org/opengl/wiki/Vertex_Rendering#Primitive_Restart
+  template <typename OutputIteratorT, typename IndexTypeT>
+  bool GenerateTriangleStripsWithPrimitiveRestart(
+      const Mesh &mesh, IndexTypeT primitive_restart_index,
+      OutputIteratorT out_it);
+
+  // The same as above but disjoint triangle strips are separated by degenerate
+  // triangles instead of the primitive restart index. Degenerate triangles are
+  // zero area triangles that are automatically discarded by the GPU. Using
+  // degenerate triangles usually results in a slightly longer output indices
+  // array compared to the similar triangle strips that use primitive restart
+  // index. The advantage of this method is that it is supported by all hardware
+  // and all relevant APIs (including WebGL 1.0).
+  template <typename OutputIteratorT>
+  bool GenerateTriangleStripsWithDegenerateTriangles(const Mesh &mesh,
+                                                     OutputIteratorT out_it);
+
+  // Returns the number of strips generated by the last call of the
+  // GenerateTriangleStrips() method.
+  int num_strips() const { return num_strips_; }
+
+ private:
+  bool Prepare(const Mesh &mesh) {
+    mesh_ = &mesh;
+    num_strips_ = 0;
+    num_encoded_faces_ = 0;
+    corner_table_ = CreateCornerTableFromPositionAttribute(mesh_);
+    if (corner_table_ == nullptr) {
+      return false;
+    }
+
+    // Mark all faces as unvisited.
+    is_face_visited_.assign(mesh.num_faces(), false);
+    return true;
+  }
+
+  // Returns local id of the longest strip that can be created from the given
+  // face |fi|.
+  int FindLongestStripFromFace(FaceIndex fi) {
+    // There are three possible strip directions that can contain the provided
+    // input face. We try all of them and select the direction that result in
+    // the longest strip.
+    const CornerIndex first_ci = corner_table_->FirstCorner(fi);
+    int longest_strip_id = -1;
+    int longest_strip_length = 0;
+    for (int i = 0; i < 3; ++i) {
+      GenerateStripsFromCorner(i, first_ci + i);
+      if (strip_faces_[i].size() > longest_strip_length) {
+        longest_strip_length = static_cast<int>(strip_faces_[i].size());
+        longest_strip_id = i;
+      }
+    }
+    return longest_strip_id;
+  }
+
+  // Generates strip from the data stored in |strip_faces_| and
+  // |strip_start_start_corners_| and stores it to |out_it|.
+  template <typename OutputIteratorT>
+  void StoreStrip(int local_strip_id, OutputIteratorT out_it) {
+    ++num_strips_;
+
+    const int num_strip_faces = strip_faces_[local_strip_id].size();
+    CornerIndex ci = strip_start_corners_[local_strip_id];
+    for (int i = 0; i < num_strip_faces; ++i) {
+      const FaceIndex fi = corner_table_->Face(ci);
+      is_face_visited_[fi] = true;
+      ++num_encoded_faces_;
+
+      if (i == 0) {
+        // Add the start face (three indices).
+        *out_it++ = CornerToPointIndex(ci).value();
+        *out_it++ = CornerToPointIndex(corner_table_->Next(ci)).value();
+        last_encoded_point_ = CornerToPointIndex(corner_table_->Previous(ci));
+        *out_it++ = last_encoded_point_.value();
+      } else {
+        // Store the point on the newly reached corner.
+        last_encoded_point_ = CornerToPointIndex(ci);
+        *out_it++ = last_encoded_point_.value();
+
+        // Go to the correct source corner to proceed to the next face.
+        if (i & 1) {
+          ci = corner_table_->Previous(ci);
+        } else {
+          ci = corner_table_->Next(ci);
+        }
+      }
+      ci = corner_table_->Opposite(ci);
+    }
+  }
+
+  PointIndex CornerToPointIndex(CornerIndex ci) const {
+    return mesh_->CornerToPointId(ci);
+  }
+
+  // Returns the opposite corner in case the opposite triangle does not lie
+  // across an attribute seam. Otherwise return kInvalidCornerIndex.
+  CornerIndex GetOppositeCorner(CornerIndex ci) const {
+    const CornerIndex oci = corner_table_->Opposite(ci);
+    if (oci < 0) {
+      return kInvalidCornerIndex;
+    }
+    // Ensure the point ids are same on both sides of the shared edge between
+    // the triangles.
+    if (CornerToPointIndex(corner_table_->Next(ci)) !=
+        CornerToPointIndex(corner_table_->Previous(oci))) {
+      return kInvalidCornerIndex;
+    }
+    if (CornerToPointIndex(corner_table_->Previous(ci)) !=
+        CornerToPointIndex(corner_table_->Next(oci))) {
+      return kInvalidCornerIndex;
+    }
+    return oci;
+  }
+
+  void GenerateStripsFromCorner(int local_strip_id, CornerIndex ci);
+
+  const Mesh *mesh_;
+  std::unique_ptr<CornerTable> corner_table_;
+
+  // Store strip faces for each of three possible directions from a given face.
+  std::vector<FaceIndex> strip_faces_[3];
+  // Start corner for each direction of the strip containing the processed face.
+  CornerIndex strip_start_corners_[3];
+  IndexTypeVector<FaceIndex, bool> is_face_visited_;
+  // The number of strips generated by this method.
+  int num_strips_;
+  // The number of encoded triangles.
+  int num_encoded_faces_;
+  // Last encoded point.
+  PointIndex last_encoded_point_;
+};
+
+template <typename OutputIteratorT, typename IndexTypeT>
+bool MeshStripifier::GenerateTriangleStripsWithPrimitiveRestart(
+    const Mesh &mesh, IndexTypeT primitive_restart_index,
+    OutputIteratorT out_it) {
+  if (!Prepare(mesh)) {
+    return false;
+  }
+
+  // Go over all faces and generate strips from the first unvisited one.
+  for (FaceIndex fi(0); fi < mesh.num_faces(); ++fi) {
+    if (is_face_visited_[fi]) {
+      continue;
+    }
+
+    const int longest_strip_id = FindLongestStripFromFace(fi);
+
+    // Separate triangle strips with the primitive restart index.
+    if (num_strips_ > 0) {
+      *out_it++ = primitive_restart_index;
+    }
+
+    StoreStrip(longest_strip_id, out_it);
+  }
+
+  return true;
+}
+
+template <typename OutputIteratorT>
+bool MeshStripifier::GenerateTriangleStripsWithDegenerateTriangles(
+    const Mesh &mesh, OutputIteratorT out_it) {
+  if (!Prepare(mesh)) {
+    return false;
+  }
+
+  // Go over all faces and generate strips from the first unvisited one.
+  for (FaceIndex fi(0); fi < mesh.num_faces(); ++fi) {
+    if (is_face_visited_[fi]) {
+      continue;
+    }
+
+    const int longest_strip_id = FindLongestStripFromFace(fi);
+
+    // Separate triangle strips by degenerate triangles. There will be either
+    // three or four degenerate triangles inserted based on the number of
+    // triangles that are already encoded in the output strip (three degenerate
+    // triangles for even number of existing triangles, four degenerate
+    // triangles for odd number of triangles).
+    if (num_strips_ > 0) {
+      // Duplicate last encoded index (first degenerate face).
+      *out_it++ = last_encoded_point_.value();
+
+      // Connect it to the start point of the new triangle strip (second
+      // degenerate face).
+      const CornerIndex new_start_corner =
+          strip_start_corners_[longest_strip_id];
+      const PointIndex new_start_point = CornerToPointIndex(new_start_corner);
+      *out_it++ = new_start_point.value();
+      num_encoded_faces_ += 2;
+      // If we have previously encoded number of faces we need to duplicate the
+      // point one more time to preserve the correct orientation of the next
+      // strip.
+      if (num_encoded_faces_ & 1) {
+        *out_it++ = new_start_point.value();
+        num_encoded_faces_ += 1;
+      }
+      // The last degenerate face will be added implicitly in the StoreStrip()
+      // function below as the first point index is going to be encoded there
+      // again.
+    }
+
+    StoreStrip(longest_strip_id, out_it);
+  }
+
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_MESH_STRIPIFIER_H_

include/draco/mesh/triangle_soup_mesh_builder.h

@@ -0,0 +1,134 @@
+// 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_TRIANGLE_SOUP_MESH_BUILDER_H_
+#define DRACO_MESH_TRIANGLE_SOUP_MESH_BUILDER_H_
+
+#include <utility>
+#include <vector>
+
+#include "draco/draco_features.h"
+
+#ifdef DRACO_TRANSCODER_SUPPORTED
+#include "draco/core/status.h"
+#endif
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Class for building meshes directly from attribute values that can be
+// specified for each face corner. All attributes are automatically
+// deduplicated.
+class TriangleSoupMeshBuilder {
+ public:
+  // Index type of the inserted element.
+  typedef FaceIndex ElementIndex;
+
+  // Starts mesh building for a given number of faces.
+  // TODO(ostava): Currently it's necessary to select the correct number of
+  // faces upfront. This should be generalized, but it will require us to
+  // rewrite our attribute resizing functions.
+  void Start(int num_faces);
+
+#ifdef DRACO_TRANSCODER_SUPPORTED
+  // Sets mesh name.
+  void SetName(const std::string &name);
+#endif  // DRACO_TRANSCODER_SUPPORTED
+
+  // Adds an empty attribute to the mesh. Returns the new attribute's id.
+  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 values for a given attribute on all corners of a given face.
+  void SetAttributeValuesForFace(int att_id, FaceIndex face_id,
+                                 const void *corner_value_0,
+                                 const void *corner_value_1,
+                                 const void *corner_value_2);
+
+#ifdef DRACO_TRANSCODER_SUPPORTED
+  // Converts input values of type T into internal representation used by
+  // |att_id|. Each input value needs to have |input_num_components| entries.
+  template <typename T>
+  Status ConvertAndSetAttributeValuesForFace(int att_id, FaceIndex face_id,
+                                             int input_num_components,
+                                             const T *corner_value_0,
+                                             const T *corner_value_1,
+                                             const T *corner_value_2);
+#endif
+
+  // Sets value for a per-face attribute. If all faces of a given attribute are
+  // set with this method, the attribute will be marked as per-face, otherwise
+  // it will be marked as per-corner attribute.
+  void SetPerFaceAttributeValueForFace(int att_id, FaceIndex face_id,
+                                       const void *value);
+
+  // Add metadata.
+  void AddMetadata(std::unique_ptr<GeometryMetadata> metadata) {
+    mesh_->AddMetadata(std::move(metadata));
+  }
+
+  // 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
+
+  // Add metadata for an attribute.
+  void AddAttributeMetadata(int32_t att_id,
+                            std::unique_ptr<AttributeMetadata> metadata) {
+    mesh_->AddAttributeMetadata(att_id, std::move(metadata));
+  }
+
+  // Finalizes the mesh or returns nullptr on error.
+  // Once this function is called, the builder becomes invalid and cannot be
+  // used until the method Start() is called again.
+  std::unique_ptr<Mesh> Finalize();
+
+ private:
+  std::vector<int8_t> attribute_element_types_;
+
+  std::unique_ptr<Mesh> mesh_;
+};
+
+#ifdef DRACO_TRANSCODER_SUPPORTED
+template <typename T>
+Status TriangleSoupMeshBuilder::ConvertAndSetAttributeValuesForFace(
+    int att_id, FaceIndex face_id, int input_num_components,
+    const T *corner_value_0, const T *corner_value_1, const T *corner_value_2) {
+  const int start_index = 3 * face_id.value();
+  PointAttribute *const att = mesh_->attribute(att_id);
+  DRACO_RETURN_IF_ERROR(
+      att->ConvertAndSetAttributeValue(AttributeValueIndex(start_index + 0),
+                                       input_num_components, corner_value_0));
+  DRACO_RETURN_IF_ERROR(
+      att->ConvertAndSetAttributeValue(AttributeValueIndex(start_index + 1),
+                                       input_num_components, corner_value_1));
+  DRACO_RETURN_IF_ERROR(
+      att->ConvertAndSetAttributeValue(AttributeValueIndex(start_index + 2),
+                                       input_num_components, corner_value_2));
+  mesh_->SetFace(face_id,
+                 {{PointIndex(start_index), PointIndex(start_index + 1),
+                   PointIndex(start_index + 2)}});
+  attribute_element_types_[att_id] = MESH_CORNER_ATTRIBUTE;
+  return OkStatus();
+}
+#endif  // DRACO_TRANSCODER_SUPPORTED
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_TRIANGLE_SOUP_MESH_BUILDER_H_