DRACO编译完成的库（win10+MSVC2019-64)

// 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_ATTRIBUTES_GEOMETRY_ATTRIBUTE_H_ #define DRACO_ATTRIBUTES_GEOMETRY_ATTRIBUTE_H_ #include <algorithm> #include <array> #include <cmath> #include <limits> #include "draco/attributes/geometry_indices.h" #include "draco/core/data_buffer.h" #include "draco/core/hash_utils.h" #include "draco/draco_features.h" #ifdef DRACO_TRANSCODER_SUPPORTED #include "draco/core/status.h" #endif namespace draco { // The class provides access to a specific attribute which is stored in a // DataBuffer, such as normals or coordinates. However, the GeometryAttribute // class does not own the buffer and the buffer itself may store other data // unrelated to this attribute (such as data for other attributes in which case // we can have multiple GeometryAttributes accessing one buffer). Typically, // all attributes for a point (or corner, face) are stored in one block, which // is advantageous in terms of memory access. The length of the entire block is // given by the byte_stride, the position where the attribute starts is given by // the byte_offset, the actual number of bytes that the attribute occupies is // given by the data_type and the number of components. class GeometryAttribute { public: // Supported attribute types. enum Type { INVALID = -1, // Named attributes start here. The difference between named and generic // attributes is that for named attributes we know their purpose and we // can apply some special methods when dealing with them (e.g. during // encoding). POSITION = 0, NORMAL, COLOR, TEX_COORD, // A special id used to mark attributes that are not assigned to any known // predefined use case. Such attributes are often used for a shader specific // data. GENERIC, #ifdef DRACO_TRANSCODER_SUPPORTED // TODO(ostava): Adding a new attribute would be bit-stream change for GLTF. // Older decoders wouldn't know what to do with this attribute type. This // should be open-sourced only when we are ready to increase our bit-stream // version. TANGENT, MATERIAL, JOINTS, WEIGHTS, #endif // Total number of different attribute types. // Always keep behind all named attributes. NAMED_ATTRIBUTES_COUNT, }; GeometryAttribute(); // Initializes and enables the attribute. void Init(Type attribute_type, DataBuffer *buffer, uint8_t num_components, DataType data_type, bool normalized, int64_t byte_stride, int64_t byte_offset); bool IsValid() const { return buffer_ != nullptr; } // Copies data from the source attribute to the this attribute. // This attribute must have a valid buffer allocated otherwise the operation // is going to fail and return false. bool CopyFrom(const GeometryAttribute &src_att); // Function for getting a attribute value with a specific format. // Unsafe. Caller must ensure the accessed memory is valid. // T is the attribute data type. // att_components_t is the number of attribute components. template <typename T, int att_components_t> std::array<T, att_components_t> GetValue( AttributeValueIndex att_index) const { // Byte address of the attribute index. const int64_t byte_pos = byte_offset_ + byte_stride_ * att_index.value(); std::array<T, att_components_t> out; buffer_->Read(byte_pos, &(out[0]), sizeof(out)); return out; } // Function for getting a attribute value with a specific format. // T is the attribute data type. // att_components_t is the number of attribute components. template <typename T, int att_components_t> bool GetValue(AttributeValueIndex att_index, std::array<T, att_components_t> *out) const { // Byte address of the attribute index. const int64_t byte_pos = byte_offset_ + byte_stride_ * att_index.value(); // Check we are not reading past end of data. if (byte_pos + sizeof(*out) > buffer_->data_size()) { return false; } buffer_->Read(byte_pos, &((*out)[0]), sizeof(*out)); return true; } // Returns the byte position of the attribute entry in the data buffer. inline int64_t GetBytePos(AttributeValueIndex att_index) const { return byte_offset_ + byte_stride_ * att_index.value(); } inline const uint8_t *GetAddress(AttributeValueIndex att_index) const { const int64_t byte_pos = GetBytePos(att_index); return buffer_->data() + byte_pos; } inline uint8_t *GetAddress(AttributeValueIndex att_index) { const int64_t byte_pos = GetBytePos(att_index); return buffer_->data() + byte_pos; } inline bool IsAddressValid(const uint8_t *address) const { return ((buffer_->data() + buffer_->data_size()) > address); } // Fills out_data with the raw value of the requested attribute entry. // out_data must be at least byte_stride_ long. void GetValue(AttributeValueIndex att_index, void *out_data) const { const int64_t byte_pos = byte_offset_ + byte_stride_ * att_index.value(); buffer_->Read(byte_pos, out_data, byte_stride_); } // Sets a value of an attribute entry. The input value must be allocated to // cover all components of a single attribute entry. void SetAttributeValue(AttributeValueIndex entry_index, const void *value) { const int64_t byte_pos = entry_index.value() * byte_stride(); buffer_->Write(byte_pos, value, byte_stride()); } #ifdef DRACO_TRANSCODER_SUPPORTED // Sets a value of an attribute entry. The input |value| must have // |input_num_components| entries and it will be automatically converted to // the internal format used by the geometry attribute. If the conversion is // not possible, an error status will be returned. template <typename InputT> Status ConvertAndSetAttributeValue(AttributeValueIndex avi, int input_num_components, const InputT *value); #endif // DEPRECATED: Use // ConvertValue(AttributeValueIndex att_id, // int out_num_components, // OutT *out_val); // // Function for conversion of a attribute to a specific output format. // OutT is the desired data type of the attribute. // out_att_components_t is the number of components of the output format. // Returns false when the conversion failed. template <typename OutT, int out_att_components_t> bool ConvertValue(AttributeValueIndex att_id, OutT *out_val) const { return ConvertValue(att_id, out_att_components_t, out_val); } // Function for conversion of a attribute to a specific output format. // |out_val| needs to be able to store |out_num_components| values. // OutT is the desired data type of the attribute. // Returns false when the conversion failed. template <typename OutT> bool ConvertValue(AttributeValueIndex att_id, int8_t out_num_components, OutT *out_val) const { if (out_val == nullptr) { return false; } switch (data_type_) { case DT_INT8: return ConvertTypedValue<int8_t, OutT>(att_id, out_num_components, out_val); case DT_UINT8: return ConvertTypedValue<uint8_t, OutT>(att_id, out_num_components,