mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-02-13 11:43:49 +00:00
update assimp to 5.2.3 Bugfix-Release
This commit is contained in:
AzaezelX
parent
3f796d2a06
commit
f297476092
1150 changed files with 165834 additions and 112019 deletions
|
|
@ -3,9 +3,7 @@
|
|||
Open Asset Import Library (assimp)
|
||||
---------------------------------------------------------------------------
|
||||
|
||||
Copyright (c) 2006-2019, assimp team
|
||||
|
||||
|
||||
Copyright (c) 2006-2022, assimp team
|
||||
|
||||
All rights reserved.
|
||||
|
||||
|
|
@ -44,15 +42,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
/** @file Defines a post processing step to search an importer's output
|
||||
for data that is obviously invalid */
|
||||
|
||||
|
||||
|
||||
#ifndef ASSIMP_BUILD_NO_FINDINVALIDDATA_PROCESS
|
||||
|
||||
// internal headers
|
||||
#include "FindInvalidDataProcess.h"
|
||||
#include "ProcessHelper.h"
|
||||
|
||||
#include <assimp/Macros.h>
|
||||
#include <assimp/Exceptional.h>
|
||||
#include <assimp/qnan.h>
|
||||
|
||||
|
|
@ -60,9 +55,8 @@ using namespace Assimp;
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Constructor to be privately used by Importer
|
||||
FindInvalidDataProcess::FindInvalidDataProcess()
|
||||
: configEpsilon(0.0)
|
||||
, mIgnoreTexCoods( false ){
|
||||
FindInvalidDataProcess::FindInvalidDataProcess() :
|
||||
configEpsilon(0.0), mIgnoreTexCoods(false) {
|
||||
// nothing to do here
|
||||
}
|
||||
|
||||
|
|
@ -74,47 +68,47 @@ FindInvalidDataProcess::~FindInvalidDataProcess() {
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Returns whether the processing step is present in the given flag field.
|
||||
bool FindInvalidDataProcess::IsActive( unsigned int pFlags) const {
|
||||
bool FindInvalidDataProcess::IsActive(unsigned int pFlags) const {
|
||||
return 0 != (pFlags & aiProcess_FindInvalidData);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Setup import configuration
|
||||
void FindInvalidDataProcess::SetupProperties(const Importer* pImp) {
|
||||
void FindInvalidDataProcess::SetupProperties(const Importer *pImp) {
|
||||
// Get the current value of AI_CONFIG_PP_FID_ANIM_ACCURACY
|
||||
configEpsilon = (0 != pImp->GetPropertyFloat(AI_CONFIG_PP_FID_ANIM_ACCURACY,0.f));
|
||||
configEpsilon = (0 != pImp->GetPropertyFloat(AI_CONFIG_PP_FID_ANIM_ACCURACY, 0.f));
|
||||
mIgnoreTexCoods = pImp->GetPropertyBool(AI_CONFIG_PP_FID_IGNORE_TEXTURECOORDS, false);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Update mesh references in the node graph
|
||||
void UpdateMeshReferences(aiNode* node, const std::vector<unsigned int>& meshMapping) {
|
||||
if (node->mNumMeshes) {
|
||||
void UpdateMeshReferences(aiNode *node, const std::vector<unsigned int> &meshMapping) {
|
||||
if (node->mNumMeshes) {
|
||||
unsigned int out = 0;
|
||||
for (unsigned int a = 0; a < node->mNumMeshes;++a) {
|
||||
for (unsigned int a = 0; a < node->mNumMeshes; ++a) {
|
||||
|
||||
unsigned int ref = node->mMeshes[a];
|
||||
if (UINT_MAX != (ref = meshMapping[ref])) {
|
||||
if (UINT_MAX != (ref = meshMapping[ref])) {
|
||||
node->mMeshes[out++] = ref;
|
||||
}
|
||||
}
|
||||
// just let the members that are unused, that's much cheaper
|
||||
// than a full array realloc'n'copy party ...
|
||||
if(!(node->mNumMeshes = out)) {
|
||||
|
||||
node->mNumMeshes = out;
|
||||
if (0 == out) {
|
||||
delete[] node->mMeshes;
|
||||
node->mMeshes = NULL;
|
||||
node->mMeshes = nullptr;
|
||||
}
|
||||
}
|
||||
// recursively update all children
|
||||
for (unsigned int i = 0; i < node->mNumChildren;++i) {
|
||||
UpdateMeshReferences(node->mChildren[i],meshMapping);
|
||||
for (unsigned int i = 0; i < node->mNumChildren; ++i) {
|
||||
UpdateMeshReferences(node->mChildren[i], meshMapping);
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Executes the post processing step on the given imported data.
|
||||
void FindInvalidDataProcess::Execute( aiScene* pScene) {
|
||||
void FindInvalidDataProcess::Execute(aiScene *pScene) {
|
||||
ASSIMP_LOG_DEBUG("FindInvalidDataProcess begin");
|
||||
|
||||
bool out = false;
|
||||
|
|
@ -122,33 +116,32 @@ void FindInvalidDataProcess::Execute( aiScene* pScene) {
|
|||
unsigned int real = 0;
|
||||
|
||||
// Process meshes
|
||||
for( unsigned int a = 0; a < pScene->mNumMeshes; a++) {
|
||||
|
||||
int result;
|
||||
if ((result = ProcessMesh( pScene->mMeshes[a]))) {
|
||||
for (unsigned int a = 0; a < pScene->mNumMeshes; a++) {
|
||||
int result = ProcessMesh(pScene->mMeshes[a]);
|
||||
if (0 == result) {
|
||||
out = true;
|
||||
|
||||
if (2 == result) {
|
||||
// remove this mesh
|
||||
delete pScene->mMeshes[a];
|
||||
AI_DEBUG_INVALIDATE_PTR(pScene->mMeshes[a]);
|
||||
|
||||
meshMapping[a] = UINT_MAX;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (2 == result) {
|
||||
// remove this mesh
|
||||
delete pScene->mMeshes[a];
|
||||
pScene->mMeshes[a] = nullptr;
|
||||
|
||||
meshMapping[a] = UINT_MAX;
|
||||
out = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
pScene->mMeshes[real] = pScene->mMeshes[a];
|
||||
meshMapping[a] = real++;
|
||||
}
|
||||
|
||||
// Process animations
|
||||
for (unsigned int a = 0; a < pScene->mNumAnimations;++a) {
|
||||
ProcessAnimation( pScene->mAnimations[a]);
|
||||
for (unsigned int animIdx = 0; animIdx < pScene->mNumAnimations; ++animIdx) {
|
||||
ProcessAnimation(pScene->mAnimations[animIdx]);
|
||||
}
|
||||
|
||||
|
||||
if (out) {
|
||||
if ( real != pScene->mNumMeshes) {
|
||||
if (out) {
|
||||
if (real != pScene->mNumMeshes) {
|
||||
if (!real) {
|
||||
throw DeadlyImportError("No meshes remaining");
|
||||
}
|
||||
|
|
@ -156,7 +149,7 @@ void FindInvalidDataProcess::Execute( aiScene* pScene) {
|
|||
// we need to remove some meshes.
|
||||
// therefore we'll also need to remove all references
|
||||
// to them from the scenegraph
|
||||
UpdateMeshReferences(pScene->mRootNode,meshMapping);
|
||||
UpdateMeshReferences(pScene->mRootNode, meshMapping);
|
||||
pScene->mNumMeshes = real;
|
||||
}
|
||||
|
||||
|
|
@ -168,35 +161,32 @@ void FindInvalidDataProcess::Execute( aiScene* pScene) {
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
template <typename T>
|
||||
inline
|
||||
const char* ValidateArrayContents(const T* /*arr*/, unsigned int /*size*/,
|
||||
const std::vector<bool>& /*dirtyMask*/, bool /*mayBeIdentical = false*/, bool /*mayBeZero = true*/)
|
||||
{
|
||||
inline const char *ValidateArrayContents(const T * /*arr*/, unsigned int /*size*/,
|
||||
const std::vector<bool> & /*dirtyMask*/, bool /*mayBeIdentical = false*/, bool /*mayBeZero = true*/) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
template <>
|
||||
inline
|
||||
const char* ValidateArrayContents<aiVector3D>(const aiVector3D* arr, unsigned int size,
|
||||
const std::vector<bool>& dirtyMask, bool mayBeIdentical , bool mayBeZero ) {
|
||||
inline const char *ValidateArrayContents<aiVector3D>(const aiVector3D *arr, unsigned int size,
|
||||
const std::vector<bool> &dirtyMask, bool mayBeIdentical, bool mayBeZero) {
|
||||
bool b = false;
|
||||
unsigned int cnt = 0;
|
||||
for (unsigned int i = 0; i < size;++i) {
|
||||
for (unsigned int i = 0; i < size; ++i) {
|
||||
|
||||
if (dirtyMask.size() && dirtyMask[i]) {
|
||||
continue;
|
||||
}
|
||||
++cnt;
|
||||
|
||||
const aiVector3D& v = arr[i];
|
||||
if (is_special_float(v.x) || is_special_float(v.y) || is_special_float(v.z)) {
|
||||
const aiVector3D &v = arr[i];
|
||||
if (is_special_float(v.x) || is_special_float(v.y) || is_special_float(v.z)) {
|
||||
return "INF/NAN was found in a vector component";
|
||||
}
|
||||
if (!mayBeZero && !v.x && !v.y && !v.z ) {
|
||||
if (!mayBeZero && !v.x && !v.y && !v.z) {
|
||||
return "Found zero-length vector";
|
||||
}
|
||||
if (i && v != arr[i-1])b = true;
|
||||
if (i && v != arr[i - 1]) b = true;
|
||||
}
|
||||
if (cnt > 1 && !b && !mayBeIdentical) {
|
||||
return "All vectors are identical";
|
||||
|
|
@ -206,14 +196,13 @@ const char* ValidateArrayContents<aiVector3D>(const aiVector3D* arr, unsigned in
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
template <typename T>
|
||||
inline
|
||||
bool ProcessArray(T*& in, unsigned int num,const char* name,
|
||||
const std::vector<bool>& dirtyMask, bool mayBeIdentical = false, bool mayBeZero = true) {
|
||||
const char* err = ValidateArrayContents(in,num,dirtyMask,mayBeIdentical,mayBeZero);
|
||||
if (err) {
|
||||
ASSIMP_LOG_ERROR_F( "FindInvalidDataProcess fails on mesh ", name, ": ", err);
|
||||
inline bool ProcessArray(T *&in, unsigned int num, const char *name,
|
||||
const std::vector<bool> &dirtyMask, bool mayBeIdentical = false, bool mayBeZero = true) {
|
||||
const char *err = ValidateArrayContents(in, num, dirtyMask, mayBeIdentical, mayBeZero);
|
||||
if (err) {
|
||||
ASSIMP_LOG_ERROR("FindInvalidDataProcess fails on mesh ", name, ": ", err);
|
||||
delete[] in;
|
||||
in = NULL;
|
||||
in = nullptr;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
|
|
@ -221,49 +210,46 @@ bool ProcessArray(T*& in, unsigned int num,const char* name,
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
template <typename T>
|
||||
AI_FORCE_INLINE bool EpsilonCompare(const T& n, const T& s, ai_real epsilon);
|
||||
AI_FORCE_INLINE bool EpsilonCompare(const T &n, const T &s, ai_real epsilon);
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
AI_FORCE_INLINE bool EpsilonCompare(ai_real n, ai_real s, ai_real epsilon) {
|
||||
return std::fabs(n-s)>epsilon;
|
||||
return std::fabs(n - s) > epsilon;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
template <>
|
||||
bool EpsilonCompare<aiVectorKey>(const aiVectorKey& n, const aiVectorKey& s, ai_real epsilon) {
|
||||
return
|
||||
EpsilonCompare(n.mValue.x,s.mValue.x,epsilon) &&
|
||||
EpsilonCompare(n.mValue.y,s.mValue.y,epsilon) &&
|
||||
EpsilonCompare(n.mValue.z,s.mValue.z,epsilon);
|
||||
bool EpsilonCompare<aiVectorKey>(const aiVectorKey &n, const aiVectorKey &s, ai_real epsilon) {
|
||||
return EpsilonCompare(n.mValue.x, s.mValue.x, epsilon) &&
|
||||
EpsilonCompare(n.mValue.y, s.mValue.y, epsilon) &&
|
||||
EpsilonCompare(n.mValue.z, s.mValue.z, epsilon);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
template <>
|
||||
bool EpsilonCompare<aiQuatKey>(const aiQuatKey& n, const aiQuatKey& s, ai_real epsilon) {
|
||||
return
|
||||
EpsilonCompare(n.mValue.x,s.mValue.x,epsilon) &&
|
||||
EpsilonCompare(n.mValue.y,s.mValue.y,epsilon) &&
|
||||
EpsilonCompare(n.mValue.z,s.mValue.z,epsilon) &&
|
||||
EpsilonCompare(n.mValue.w,s.mValue.w,epsilon);
|
||||
bool EpsilonCompare<aiQuatKey>(const aiQuatKey &n, const aiQuatKey &s, ai_real epsilon) {
|
||||
return EpsilonCompare(n.mValue.x, s.mValue.x, epsilon) &&
|
||||
EpsilonCompare(n.mValue.y, s.mValue.y, epsilon) &&
|
||||
EpsilonCompare(n.mValue.z, s.mValue.z, epsilon) &&
|
||||
EpsilonCompare(n.mValue.w, s.mValue.w, epsilon);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
template <typename T>
|
||||
inline
|
||||
bool AllIdentical(T* in, unsigned int num, ai_real epsilon) {
|
||||
inline bool AllIdentical(T *in, unsigned int num, ai_real epsilon) {
|
||||
if (num <= 1) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (fabs(epsilon) > 0.f) {
|
||||
for (unsigned int i = 0; i < num-1;++i) {
|
||||
if (!EpsilonCompare(in[i],in[i+1],epsilon)) {
|
||||
for (unsigned int i = 0; i < num - 1; ++i) {
|
||||
if (!EpsilonCompare(in[i], in[i + 1], epsilon)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (unsigned int i = 0; i < num-1;++i) {
|
||||
if (in[i] != in[i+1]) {
|
||||
for (unsigned int i = 0; i < num - 1; ++i) {
|
||||
if (in[i] != in[i + 1]) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
|
@ -273,16 +259,16 @@ bool AllIdentical(T* in, unsigned int num, ai_real epsilon) {
|
|||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Search an animation for invalid content
|
||||
void FindInvalidDataProcess::ProcessAnimation (aiAnimation* anim) {
|
||||
void FindInvalidDataProcess::ProcessAnimation(aiAnimation *anim) {
|
||||
// Process all animation channels
|
||||
for ( unsigned int a = 0; a < anim->mNumChannels; ++a ) {
|
||||
ProcessAnimationChannel( anim->mChannels[a]);
|
||||
for (unsigned int a = 0; a < anim->mNumChannels; ++a) {
|
||||
ProcessAnimationChannel(anim->mChannels[a]);
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void FindInvalidDataProcess::ProcessAnimationChannel (aiNodeAnim* anim) {
|
||||
ai_assert( nullptr != anim );
|
||||
void FindInvalidDataProcess::ProcessAnimationChannel(aiNodeAnim *anim) {
|
||||
ai_assert(nullptr != anim);
|
||||
if (anim->mNumPositionKeys == 0 && anim->mNumRotationKeys == 0 && anim->mNumScalingKeys == 0) {
|
||||
ai_assert_entry();
|
||||
return;
|
||||
|
|
@ -292,7 +278,7 @@ void FindInvalidDataProcess::ProcessAnimationChannel (aiNodeAnim* anim) {
|
|||
// we can remove al keys except one.
|
||||
// POSITIONS
|
||||
int i = 0;
|
||||
if (anim->mNumPositionKeys > 1 && AllIdentical(anim->mPositionKeys,anim->mNumPositionKeys,configEpsilon)) {
|
||||
if (anim->mNumPositionKeys > 1 && AllIdentical(anim->mPositionKeys, anim->mNumPositionKeys, configEpsilon)) {
|
||||
aiVectorKey v = anim->mPositionKeys[0];
|
||||
|
||||
// Reallocate ... we need just ONE element, it makes no sense to reuse the array
|
||||
|
|
@ -303,7 +289,7 @@ void FindInvalidDataProcess::ProcessAnimationChannel (aiNodeAnim* anim) {
|
|||
}
|
||||
|
||||
// ROTATIONS
|
||||
if (anim->mNumRotationKeys > 1 && AllIdentical(anim->mRotationKeys,anim->mNumRotationKeys,configEpsilon)) {
|
||||
if (anim->mNumRotationKeys > 1 && AllIdentical(anim->mRotationKeys, anim->mNumRotationKeys, configEpsilon)) {
|
||||
aiQuatKey v = anim->mRotationKeys[0];
|
||||
|
||||
// Reallocate ... we need just ONE element, it makes no sense to reuse the array
|
||||
|
|
@ -314,7 +300,7 @@ void FindInvalidDataProcess::ProcessAnimationChannel (aiNodeAnim* anim) {
|
|||
}
|
||||
|
||||
// SCALINGS
|
||||
if (anim->mNumScalingKeys > 1 && AllIdentical(anim->mScalingKeys,anim->mNumScalingKeys,configEpsilon)) {
|
||||
if (anim->mNumScalingKeys > 1 && AllIdentical(anim->mScalingKeys, anim->mNumScalingKeys, configEpsilon)) {
|
||||
aiVectorKey v = anim->mScalingKeys[0];
|
||||
|
||||
// Reallocate ... we need just ONE element, it makes no sense to reuse the array
|
||||
|
|
@ -323,22 +309,21 @@ void FindInvalidDataProcess::ProcessAnimationChannel (aiNodeAnim* anim) {
|
|||
anim->mScalingKeys[0] = v;
|
||||
i = 1;
|
||||
}
|
||||
if ( 1 == i ) {
|
||||
if (1 == i) {
|
||||
ASSIMP_LOG_WARN("Simplified dummy tracks with just one key");
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Search a mesh for invalid contents
|
||||
int FindInvalidDataProcess::ProcessMesh(aiMesh* pMesh)
|
||||
{
|
||||
int FindInvalidDataProcess::ProcessMesh(aiMesh *pMesh) {
|
||||
bool ret = false;
|
||||
std::vector<bool> dirtyMask(pMesh->mNumVertices, pMesh->mNumFaces != 0);
|
||||
|
||||
// Ignore elements that are not referenced by vertices.
|
||||
// (they are, for example, caused by the FindDegenerates step)
|
||||
for (unsigned int m = 0; m < pMesh->mNumFaces; ++m) {
|
||||
const aiFace& f = pMesh->mFaces[m];
|
||||
const aiFace &f = pMesh->mFaces[m];
|
||||
|
||||
for (unsigned int i = 0; i < f.mNumIndices; ++i) {
|
||||
dirtyMask[f.mIndices[i]] = false;
|
||||
|
|
@ -361,7 +346,7 @@ int FindInvalidDataProcess::ProcessMesh(aiMesh* pMesh)
|
|||
// delete all subsequent texture coordinate sets.
|
||||
for (unsigned int a = i + 1; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
|
||||
delete[] pMesh->mTextureCoords[a];
|
||||
pMesh->mTextureCoords[a] = NULL;
|
||||
pMesh->mTextureCoords[a] = nullptr;
|
||||
pMesh->mNumUVComponents[a] = 0;
|
||||
}
|
||||
|
||||
|
|
@ -374,19 +359,17 @@ int FindInvalidDataProcess::ProcessMesh(aiMesh* pMesh)
|
|||
// they are invalid or not.
|
||||
|
||||
// Normals and tangents are undefined for point and line faces.
|
||||
if (pMesh->mNormals || pMesh->mTangents) {
|
||||
if (pMesh->mNormals || pMesh->mTangents) {
|
||||
|
||||
if (aiPrimitiveType_POINT & pMesh->mPrimitiveTypes ||
|
||||
aiPrimitiveType_LINE & pMesh->mPrimitiveTypes)
|
||||
{
|
||||
aiPrimitiveType_LINE & pMesh->mPrimitiveTypes) {
|
||||
if (aiPrimitiveType_TRIANGLE & pMesh->mPrimitiveTypes ||
|
||||
aiPrimitiveType_POLYGON & pMesh->mPrimitiveTypes)
|
||||
{
|
||||
aiPrimitiveType_POLYGON & pMesh->mPrimitiveTypes) {
|
||||
// We need to update the lookup-table
|
||||
for (unsigned int m = 0; m < pMesh->mNumFaces;++m) {
|
||||
const aiFace& f = pMesh->mFaces[ m ];
|
||||
for (unsigned int m = 0; m < pMesh->mNumFaces; ++m) {
|
||||
const aiFace &f = pMesh->mFaces[m];
|
||||
|
||||
if (f.mNumIndices < 3) {
|
||||
if (f.mNumIndices < 3) {
|
||||
dirtyMask[f.mIndices[0]] = true;
|
||||
if (f.mNumIndices == 2) {
|
||||
dirtyMask[f.mIndices[1]] = true;
|
||||
|
|
@ -402,19 +385,21 @@ int FindInvalidDataProcess::ProcessMesh(aiMesh* pMesh)
|
|||
}
|
||||
|
||||
// Process mesh normals
|
||||
if (pMesh->mNormals && ProcessArray(pMesh->mNormals,pMesh->mNumVertices,
|
||||
"normals",dirtyMask,true,false))
|
||||
if (pMesh->mNormals && ProcessArray(pMesh->mNormals, pMesh->mNumVertices,
|
||||
"normals", dirtyMask, true, false))
|
||||
ret = true;
|
||||
|
||||
// Process mesh tangents
|
||||
if (pMesh->mTangents && ProcessArray(pMesh->mTangents,pMesh->mNumVertices,"tangents",dirtyMask)) {
|
||||
delete[] pMesh->mBitangents; pMesh->mBitangents = NULL;
|
||||
if (pMesh->mTangents && ProcessArray(pMesh->mTangents, pMesh->mNumVertices, "tangents", dirtyMask)) {
|
||||
delete[] pMesh->mBitangents;
|
||||
pMesh->mBitangents = nullptr;
|
||||
ret = true;
|
||||
}
|
||||
|
||||
// Process mesh bitangents
|
||||
if (pMesh->mBitangents && ProcessArray(pMesh->mBitangents,pMesh->mNumVertices,"bitangents",dirtyMask)) {
|
||||
delete[] pMesh->mTangents; pMesh->mTangents = NULL;
|
||||
if (pMesh->mBitangents && ProcessArray(pMesh->mBitangents, pMesh->mNumVertices, "bitangents", dirtyMask)) {
|
||||
delete[] pMesh->mTangents;
|
||||
pMesh->mTangents = nullptr;
|
||||
ret = true;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue