Differential D4501 Diff 14697 extern/draco/dracoenc/src/draco/mesh/valence_cache.h

Changeset View

Standalone View

extern/draco/dracoenc/src/draco/mesh/valence_cache.h

This file was added.

				// 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_