DRACO编译完成的库（win10+mingw11.2.0-x64)

// Copyright 2018 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_IO_GLTF_DECODER_H_ #define DRACO_IO_GLTF_DECODER_H_ #include "draco/draco_features.h" #ifdef DRACO_TRANSCODER_SUPPORTED #include <map> #include <memory> #include <string> #include <unordered_map> #include <unordered_set> #include <vector> #include "draco/core/decoder_buffer.h" #include "draco/core/status.h" #include "draco/core/status_or.h" #include "draco/io/tiny_gltf_utils.h" #include "draco/mesh/mesh.h" #include "draco/mesh/triangle_soup_mesh_builder.h" #include "draco/point_cloud/point_cloud_builder.h" #include "draco/scene/scene.h" namespace draco { // Decodes a glTF file and returns a draco::Mesh. All of the |mesh|'s attributes // will be merged into one draco::Mesh class GltfDecoder { public: GltfDecoder(); // Decodes a glTF file stored in the input |file_name| or |buffer| to a Mesh. // The second form returns a vector of files used as input to the mesh during // the decoding process. Returns nullptr when decode fails. StatusOr<std::unique_ptr<Mesh>> DecodeFromFile(const std::string &file_name); StatusOr<std::unique_ptr<Mesh>> DecodeFromFile( const std::string &file_name, std::vector<std::string> *mesh_files); StatusOr<std::unique_ptr<Mesh>> DecodeFromBuffer(DecoderBuffer *buffer); // Decodes a glTF file stored in the input |file_name| or |buffer| to a Scene. // The second form returns a vector of files used as input to the scene during // the decoding process. Returns nullptr if the decode fails. StatusOr<std::unique_ptr<Scene>> DecodeFromFileToScene( const std::string &file_name); StatusOr<std::unique_ptr<Scene>> DecodeFromFileToScene( const std::string &file_name, std::vector<std::string> *scene_files); StatusOr<std::unique_ptr<Scene>> DecodeFromBufferToScene( DecoderBuffer *buffer); // Scene graph can be loaded either as a tree or a general directed acyclic // graph (DAG) that allows multiple parent nodes. By default. we decode the // scene graph as a tree. If the tree mode is selected and the input contains // nodes with multiple parents, these nodes are duplicated to form a tree. // TODO(ostava): Add support for DAG mode to other parts of the Draco // library. enum class GltfSceneGraphMode { TREE, DAG }; void SetSceneGraphMode(GltfSceneGraphMode mode) { gltf_scene_graph_mode_ = mode; } // By default, the decoder will attempt to deduplicate vertices after decoding // the mesh. This means lower memory usage and smaller output glTFs after // reencoding. However, for very large meshes, this may become an expensive // operation. If that becomes an issue, you might want to consider disabling // deduplication with |SetDeduplicateVertices(false)|. // // Note that at this moment, disabling deduplication works ONLY for point // clouds. void SetDeduplicateVertices(bool deduplicate_vertices) { deduplicate_vertices_ = deduplicate_vertices; } private: // Loads |file_name| into |gltf_model_|. Fills |input_files| with paths to all // input files when non-null. Status LoadFile(const std::string &file_name, std::vector<std::string> *input_files); // Loads |gltf_model_| from |buffer| in GLB format. Status LoadBuffer(const DecoderBuffer &buffer); // Builds mesh from |gltf_model_|. StatusOr<std::unique_ptr<Mesh>> BuildMesh(); // Checks |gltf_model_| for unsupported features. If |gltf_model_| contains // unsupported features then the function will return with a status code of // UNSUPPORTED_FEATURE. Status CheckUnsupportedFeatures(); // Decodes a glTF Node as well as any child Nodes. If |node| contains a mesh // it will process all of the mesh's primitives. Status DecodeNode(int node_index, const Eigen::Matrix4d &parent_matrix); // Decodes the number of entries in the first attribute of a given glTF // |primitive|. Note that all attributes have the same entry count according // to glTF 2.0 spec. StatusOr<int> DecodePrimitiveAttributeCount( const tinygltf::Primitive &primitive) const; // Decodes the number of indices in a given glTF |primitive|. If primitive's // indices property is not defined, the index count is implied from the entry // count of a primitive attribute. StatusOr<int> DecodePrimitiveIndicesCount( const tinygltf::Primitive &primitive) const; // Decodes indices property of a given glTF |primitive|. If primitive's // indices property is not defined, the indices are generated based on entry // count of a primitive attribute. StatusOr<std::vector<uint32_t>> DecodePrimitiveIndices( const tinygltf::Primitive &primitive) const; // Decodes a glTF Primitive. All of the |primitive|'s attributes will be // merged into the draco::Mesh output if they are of the same type that // already has been decoded. Status DecodePrimitive(const tinygltf::Primitive &primitive, const Eigen::Matrix4d &transform_matrix); // Sums the number of elements per attribute for |node|'s mesh and any of // |node|'s children. Fills out the material index map. Status NodeGatherAttributeAndMaterialStats(const tinygltf::Node &node); // Sums the number of elements per attribute for all of the meshes and // primitives. Status GatherAttributeAndMaterialStats(); // Sums the attribute counts into total_attribute_counts_. void SumAttributeStats(const std::string &attribute_name, int count); // Checks that all the same glTF attribute types in different meshes and // primitives contain the same characteristics. Status CheckTypes(const std::string &attribute_name, int component_type, int type, bool normalized); // Accumulates the number of elements per attribute for |primitive|. Status AccumulatePrimitiveStats(const tinygltf::Primitive &primitive); // Adds all of the attributes from the glTF file to a Draco mesh. // GatherAttributeAndMaterialStats() must be called before this function. The // GeometryAttribute::MATERIAL attribute will be created only if the glTF file // contains more than one material. template <typename BuilderT> Status AddAttributesToDracoMesh(BuilderT *builder); // Copies attribute data from |accessor| and adds it to a Draco mesh using the // geometry builder |builder|. template <typename BuilderT> Status AddAttributeValuesToBuilder(const std::string &attribute_name, const tinygltf::Accessor &accessor, const std::vector<uint32_t> &indices_data, int att_id, int number_of_elements, const Eigen::Matrix4d &transform_matrix, BuilderT *builder); // Copies the tangent attribute data from |accessor| and adds it to a Draco // mesh. This function will transform all of the data by |transform_matrix| // and then normalize before adding the data to the Draco mesh. // |indices_data| is the indices data from the glTF file. |att_id| is the // attribute id of the tangent attribute in the Draco mesh. // |number_of_elements| is the number of faces or points this function will // process. |reverse_winding| if set will change