From 058f98a63658dc1a2579826ba167fd61bed1e21f Mon Sep 17 00:00:00 2001 From: sanine Date: Fri, 4 Mar 2022 10:47:15 -0600 Subject: add assimp submodule --- .../code/PostProcessing/ProcessHelper.h | 376 +++++++++++++++++++++ 1 file changed, 376 insertions(+) create mode 100644 src/mesh/assimp-master/code/PostProcessing/ProcessHelper.h (limited to 'src/mesh/assimp-master/code/PostProcessing/ProcessHelper.h') diff --git a/src/mesh/assimp-master/code/PostProcessing/ProcessHelper.h b/src/mesh/assimp-master/code/PostProcessing/ProcessHelper.h new file mode 100644 index 0000000..78df94c --- /dev/null +++ b/src/mesh/assimp-master/code/PostProcessing/ProcessHelper.h @@ -0,0 +1,376 @@ +/* +Open Asset Import Library (assimp) +---------------------------------------------------------------------- + +Copyright (c) 2006-2022, assimp team + + +All rights reserved. + +Redistribution and use of this software in source and binary forms, +with or without modification, are permitted provided that the +following conditions are met: + +* Redistributions of source code must retain the above + copyright notice, this list of conditions and the + following disclaimer. + +* Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the + following disclaimer in the documentation and/or other + materials provided with the distribution. + +* Neither the name of the assimp team, nor the names of its + contributors may be used to endorse or promote products + derived from this software without specific prior + written permission of the assimp team. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +---------------------------------------------------------------------- +*/ + +#ifndef AI_PROCESS_HELPER_H_INCLUDED +#define AI_PROCESS_HELPER_H_INCLUDED + +#include +#include +#include +#include +#include +#include + +#include "Common/BaseProcess.h" +#include +#include + +#include + +// ------------------------------------------------------------------------------- +// Some extensions to std namespace. Mainly std::min and std::max for all +// flat data types in the aiScene. They're used to quickly determine the +// min/max bounds of data arrays. +#ifdef __cplusplus +namespace std { + +// std::min for aiVector3D +template +inline ::aiVector3t min(const ::aiVector3t &a, const ::aiVector3t &b) { + return ::aiVector3t(min(a.x, b.x), min(a.y, b.y), min(a.z, b.z)); +} + +// std::max for aiVector3t +template +inline ::aiVector3t max(const ::aiVector3t &a, const ::aiVector3t &b) { + return ::aiVector3t(max(a.x, b.x), max(a.y, b.y), max(a.z, b.z)); +} + +// std::min for aiVector2t +template +inline ::aiVector2t min(const ::aiVector2t &a, const ::aiVector2t &b) { + return ::aiVector2t(min(a.x, b.x), min(a.y, b.y)); +} + +// std::max for aiVector2t +template +inline ::aiVector2t max(const ::aiVector2t &a, const ::aiVector2t &b) { + return ::aiVector2t(max(a.x, b.x), max(a.y, b.y)); +} + +// std::min for aiColor4D +template +inline ::aiColor4t min(const ::aiColor4t &a, const ::aiColor4t &b) { + return ::aiColor4t(min(a.r, b.r), min(a.g, b.g), min(a.b, b.b), min(a.a, b.a)); +} + +// std::max for aiColor4D +template +inline ::aiColor4t max(const ::aiColor4t &a, const ::aiColor4t &b) { + return ::aiColor4t(max(a.r, b.r), max(a.g, b.g), max(a.b, b.b), max(a.a, b.a)); +} + +// std::min for aiQuaterniont +template +inline ::aiQuaterniont min(const ::aiQuaterniont &a, const ::aiQuaterniont &b) { + return ::aiQuaterniont(min(a.w, b.w), min(a.x, b.x), min(a.y, b.y), min(a.z, b.z)); +} + +// std::max for aiQuaterniont +template +inline ::aiQuaterniont max(const ::aiQuaterniont &a, const ::aiQuaterniont &b) { + return ::aiQuaterniont(max(a.w, b.w), max(a.x, b.x), max(a.y, b.y), max(a.z, b.z)); +} + +// std::min for aiVectorKey +inline ::aiVectorKey min(const ::aiVectorKey &a, const ::aiVectorKey &b) { + return ::aiVectorKey(min(a.mTime, b.mTime), min(a.mValue, b.mValue)); +} + +// std::max for aiVectorKey +inline ::aiVectorKey max(const ::aiVectorKey &a, const ::aiVectorKey &b) { + return ::aiVectorKey(max(a.mTime, b.mTime), max(a.mValue, b.mValue)); +} + +// std::min for aiQuatKey +inline ::aiQuatKey min(const ::aiQuatKey &a, const ::aiQuatKey &b) { + return ::aiQuatKey(min(a.mTime, b.mTime), min(a.mValue, b.mValue)); +} + +// std::max for aiQuatKey +inline ::aiQuatKey max(const ::aiQuatKey &a, const ::aiQuatKey &b) { + return ::aiQuatKey(max(a.mTime, b.mTime), max(a.mValue, b.mValue)); +} + +// std::min for aiVertexWeight +inline ::aiVertexWeight min(const ::aiVertexWeight &a, const ::aiVertexWeight &b) { + return ::aiVertexWeight(min(a.mVertexId, b.mVertexId),static_cast(min(a.mWeight, b.mWeight))); +} + +// std::max for aiVertexWeight +inline ::aiVertexWeight max(const ::aiVertexWeight &a, const ::aiVertexWeight &b) { + return ::aiVertexWeight(max(a.mVertexId, b.mVertexId), static_cast(max(a.mWeight, b.mWeight))); +} + +} // end namespace std +#endif // !! C++ + +namespace Assimp { + +// ------------------------------------------------------------------------------- +// Start points for ArrayBounds for all supported Ts +template +struct MinMaxChooser; + +template <> +struct MinMaxChooser { + void operator()(float &min, float &max) { + max = -1e10f; + min = 1e10f; + } +}; +template <> +struct MinMaxChooser { + void operator()(double &min, double &max) { + max = -1e10; + min = 1e10; + } +}; +template <> +struct MinMaxChooser { + void operator()(unsigned int &min, unsigned int &max) { + max = 0; + min = (1u << (sizeof(unsigned int) * 8 - 1)); + } +}; + +template +struct MinMaxChooser> { + void operator()(aiVector3t &min, aiVector3t &max) { + max = aiVector3t(-1e10f, -1e10f, -1e10f); + min = aiVector3t(1e10f, 1e10f, 1e10f); + } +}; +template +struct MinMaxChooser> { + void operator()(aiVector2t &min, aiVector2t &max) { + max = aiVector2t(-1e10f, -1e10f); + min = aiVector2t(1e10f, 1e10f); + } +}; +template +struct MinMaxChooser> { + void operator()(aiColor4t &min, aiColor4t &max) { + max = aiColor4t(-1e10f, -1e10f, -1e10f, -1e10f); + min = aiColor4t(1e10f, 1e10f, 1e10f, 1e10f); + } +}; + +template +struct MinMaxChooser> { + void operator()(aiQuaterniont &min, aiQuaterniont &max) { + max = aiQuaterniont(-1e10f, -1e10f, -1e10f, -1e10f); + min = aiQuaterniont(1e10f, 1e10f, 1e10f, 1e10f); + } +}; + +template <> +struct MinMaxChooser { + void operator()(aiVectorKey &min, aiVectorKey &max) { + MinMaxChooser()(min.mTime, max.mTime); + MinMaxChooser()(min.mValue, max.mValue); + } +}; +template <> +struct MinMaxChooser { + void operator()(aiQuatKey &min, aiQuatKey &max) { + MinMaxChooser()(min.mTime, max.mTime); + MinMaxChooser()(min.mValue, max.mValue); + } +}; + +template <> +struct MinMaxChooser { + void operator()(aiVertexWeight &min, aiVertexWeight &max) { + MinMaxChooser()(min.mVertexId, max.mVertexId); + MinMaxChooser()(min.mWeight, max.mWeight); + } +}; + +// ------------------------------------------------------------------------------- +/** @brief Find the min/max values of an array of Ts + * @param in Input array + * @param size Number of elements to process + * @param[out] min minimum value + * @param[out] max maximum value + */ +template +inline void ArrayBounds(const T *in, unsigned int size, T &min, T &max) { + MinMaxChooser()(min, max); + for (unsigned int i = 0; i < size; ++i) { + min = std::min(in[i], min); + max = std::max(in[i], max); + } +} + +// ------------------------------------------------------------------------------- +/** Little helper function to calculate the quadratic difference + * of two colors. + * @param pColor1 First color + * @param pColor2 second color + * @return Quadratic color difference */ +inline ai_real GetColorDifference(const aiColor4D &pColor1, const aiColor4D &pColor2) { + const aiColor4D c(pColor1.r - pColor2.r, pColor1.g - pColor2.g, pColor1.b - pColor2.b, pColor1.a - pColor2.a); + return c.r * c.r + c.g * c.g + c.b * c.b + c.a * c.a; +} + +// ------------------------------------------------------------------------------- +/** @brief Extract single strings from a list of identifiers + * @param in Input string list. + * @param out Receives a list of clean output strings + * @sdee #AI_CONFIG_PP_OG_EXCLUDE_LIST */ +void ConvertListToStrings(const std::string &in, std::list &out); + +// ------------------------------------------------------------------------------- +/** @brief Compute the AABB of a mesh after applying a given transform + * @param mesh Input mesh + * @param[out] min Receives minimum transformed vertex + * @param[out] max Receives maximum transformed vertex + * @param m Transformation matrix to be applied */ +void FindAABBTransformed(const aiMesh *mesh, aiVector3D &min, aiVector3D &max, const aiMatrix4x4 &m); + +// ------------------------------------------------------------------------------- +/** @brief Helper function to determine the 'real' center of a mesh + * + * That is the center of its axis-aligned bounding box. + * @param mesh Input mesh + * @param[out] min Minimum vertex of the mesh + * @param[out] max maximum vertex of the mesh + * @param[out] out Center point */ +void FindMeshCenter(aiMesh *mesh, aiVector3D &out, aiVector3D &min, aiVector3D &max); + +// ------------------------------------------------------------------------------- +/** @brief Helper function to determine the 'real' center of a scene + * + * That is the center of its axis-aligned bounding box. + * @param scene Input scene + * @param[out] min Minimum vertex of the scene + * @param[out] max maximum vertex of the scene + * @param[out] out Center point */ +void FindSceneCenter(aiScene *scene, aiVector3D &out, aiVector3D &min, aiVector3D &max); + +// ------------------------------------------------------------------------------- +// Helper function to determine the 'real' center of a mesh after applying a given transform +void FindMeshCenterTransformed(aiMesh *mesh, aiVector3D &out, aiVector3D &min, aiVector3D &max, const aiMatrix4x4 &m); + +// ------------------------------------------------------------------------------- +// Helper function to determine the 'real' center of a mesh +void FindMeshCenter(aiMesh *mesh, aiVector3D &out); + +// ------------------------------------------------------------------------------- +// Helper function to determine the 'real' center of a mesh after applying a given transform +void FindMeshCenterTransformed(aiMesh *mesh, aiVector3D &out, const aiMatrix4x4 &m); + +// ------------------------------------------------------------------------------- +// Compute a good epsilon value for position comparisons on a mesh +ai_real ComputePositionEpsilon(const aiMesh *pMesh); + +// ------------------------------------------------------------------------------- +// Compute a good epsilon value for position comparisons on a array of meshes +ai_real ComputePositionEpsilon(const aiMesh *const *pMeshes, size_t num); + +// ------------------------------------------------------------------------------- +// Compute an unique value for the vertex format of a mesh +unsigned int GetMeshVFormatUnique(const aiMesh *pcMesh); + +// defs for ComputeVertexBoneWeightTable() +using PerVertexWeight = std::pair; +using VertexWeightTable = std::vector; + +// ------------------------------------------------------------------------------- +// Compute a per-vertex bone weight table +VertexWeightTable *ComputeVertexBoneWeightTable(const aiMesh *pMesh); + +// ------------------------------------------------------------------------------- +// Get a string for a given aiTextureMapping +const char *MappingTypeToString(aiTextureMapping in); + +// flags for MakeSubmesh() +#define AI_SUBMESH_FLAGS_SANS_BONES 0x1 + +// ------------------------------------------------------------------------------- +// Split a mesh given a list of faces to be contained in the sub mesh +aiMesh *MakeSubmesh(const aiMesh *superMesh, const std::vector &subMeshFaces, unsigned int subFlags); + +// ------------------------------------------------------------------------------- +// Utility post-process step to share the spatial sort tree between +// all steps which use it to speedup its computations. +class ComputeSpatialSortProcess : public BaseProcess { + bool IsActive(unsigned int pFlags) const { + return nullptr != shared && 0 != (pFlags & (aiProcess_CalcTangentSpace | + aiProcess_GenNormals | aiProcess_JoinIdenticalVertices)); + } + + void Execute(aiScene *pScene) { + typedef std::pair _Type; + ASSIMP_LOG_DEBUG("Generate spatially-sorted vertex cache"); + + std::vector<_Type> *p = new std::vector<_Type>(pScene->mNumMeshes); + std::vector<_Type>::iterator it = p->begin(); + + for (unsigned int i = 0; i < pScene->mNumMeshes; ++i, ++it) { + aiMesh *mesh = pScene->mMeshes[i]; + _Type &blubb = *it; + blubb.first.Fill(mesh->mVertices, mesh->mNumVertices, sizeof(aiVector3D)); + blubb.second = ComputePositionEpsilon(mesh); + } + + shared->AddProperty(AI_SPP_SPATIAL_SORT, p); + } +}; + +// ------------------------------------------------------------------------------- +// ... and the same again to cleanup the whole stuff +class DestroySpatialSortProcess : public BaseProcess { + bool IsActive(unsigned int pFlags) const { + return nullptr != shared && 0 != (pFlags & (aiProcess_CalcTangentSpace | + aiProcess_GenNormals | aiProcess_JoinIdenticalVertices)); + } + + void Execute(aiScene * /*pScene*/) { + shared->RemoveProperty(AI_SPP_SPATIAL_SORT); + } +}; + +} // namespace Assimp + +#endif // !! AI_PROCESS_HELPER_H_INCLUDED -- cgit v1.2.1