1 files changed, 142 insertions, 0 deletions
diff --git a/extern/draco/draco/src/draco/mesh/valence_cache.h b/extern/draco/draco/src/draco/mesh/valence_cache.h
new file mode 100644
index 00000000000..3540377db81
--- /dev/null
+++ b/extern/draco/draco/src/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_