Differential D4501 Diff 14126 extern/gltf-draco/draco/src/draco/compression/mesh/traverser/traverser_base.h

Changeset View

Standalone View

extern/gltf-draco/draco/src/draco/compression/mesh/traverser/traverser_base.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_COMPRESSION_MESH_TRAVERSER_TRAVERSER_BASE_H_
				#define DRACO_COMPRESSION_MESH_TRAVERSER_TRAVERSER_BASE_H_

				#include "draco/mesh/corner_table.h"

				namespace draco {

				// Class providing the basic traversal functionality needed by traversers (such
				// as the DepthFirstTraverser, see depth_first_traverser.h). It keeps a pointer
				// to the corner table that is used for the traversal, plus it provides a basic
				// bookkeeping of visited faces and vertices during the traversal.
				template <class CornerTableT, class TraversalObserverT>
				class TraverserBase {
				public:
				typedef CornerTableT CornerTable;
				typedef TraversalObserverT TraversalObserver;

				TraverserBase() : corner_table_(nullptr) {}
				virtual ~TraverserBase() = default;

				virtual void Init(const CornerTable *corner_table,
				TraversalObserver traversal_observer) {
				corner_table_ = corner_table;
				is_face_visited_.assign(corner_table->num_faces(), false);
				is_vertex_visited_.assign(corner_table_->num_vertices(), false);
				traversal_observer_ = traversal_observer;
				}

				const CornerTable &GetCornerTable() const { return *corner_table_; }

				inline bool IsFaceVisited(FaceIndex face_id) const {
				if (face_id == kInvalidFaceIndex)
				return true; // Invalid faces are always considered as visited.
				return is_face_visited_[face_id.value()];
				}

				// Returns true if the face containing the given corner was visited.
				inline bool IsFaceVisited(CornerIndex corner_id) const {
				if (corner_id == kInvalidCornerIndex)
				return true; // Invalid faces are always considered as visited.
				return is_face_visited_[corner_id.value() / 3];
				}

				inline void MarkFaceVisited(FaceIndex face_id) {
				is_face_visited_[face_id.value()] = true;
				}
				inline bool IsVertexVisited(VertexIndex vert_id) const {
				return is_vertex_visited_[vert_id.value()];
				}
				inline void MarkVertexVisited(VertexIndex vert_id) {
				is_vertex_visited_[vert_id.value()] = true;
				}

				inline const CornerTable *corner_table() const { return corner_table_; }
				inline const TraversalObserverT &traversal_observer() const {
				return traversal_observer_;
				}
				inline TraversalObserverT &traversal_observer() {
				return traversal_observer_;
				}

				private:
				const CornerTable *corner_table_;
				TraversalObserverT traversal_observer_;
				std::vector<bool> is_face_visited_;
				std::vector<bool> is_vertex_visited_;
				};

				} // namespace draco

				#endif // DRACO_COMPRESSION_MESH_TRAVERSER_TRAVERSER_BASE_H_