v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix add checks for indices

pull/5311/head
Kim Kulling 2023-11-03 11:47:13 +01:00 committed by Kim Kulling
parent a7cfa3264a
commit f844c3397d
2 changed files with 216 additions and 218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

426
code/AssetLib/X/XFileImporter.cpp
View File

@ -57,7 +57,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <cctype> #include <cctype>
#include <memory> #include <memory>
using namespace Assimp; namespace Assimp {
using namespace Assimp::Formatter; using namespace Assimp::Formatter;
static const aiImporterDesc desc = { static const aiImporterDesc desc = {
@ -73,142 +74,137 @@ static const aiImporterDesc desc = {
"x" "x"
}; };
// ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer
XFileImporter::XFileImporter() = default;
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file. // Returns whether the class can handle the format of the given file.
bool XFileImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const { bool XFileImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
static const uint32_t token[] = { AI_MAKE_MAGIC("xof ") }; static const uint32_t token[] = { AI_MAKE_MAGIC("xof ") };
return CheckMagicToken(pIOHandler,pFile,token,AI_COUNT_OF(token)); return CheckMagicToken(pIOHandler, pFile, token, AI_COUNT_OF(token));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Get file extension list // Get file extension list
const aiImporterDesc* XFileImporter::GetInfo () const { const aiImporterDesc *XFileImporter::GetInfo() const {
return &desc; return &desc;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Imports the given file into the given scene structure. // Imports the given file into the given scene structure.
void XFileImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) { void XFileImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
// read file into memory // read file into memory
std::unique_ptr<IOStream> file( pIOHandler->Open( pFile)); std::unique_ptr<IOStream> file(pIOHandler->Open(pFile));
if (file == nullptr) { if (file == nullptr) {
throw DeadlyImportError( "Failed to open file ", pFile, "." ); throw DeadlyImportError("Failed to open file ", pFile, ".");
} }
static const size_t MinSize = 16; static const size_t MinSize = 16;
size_t fileSize = file->FileSize(); size_t fileSize = file->FileSize();
if ( fileSize < MinSize ) { if (fileSize < MinSize) {
throw DeadlyImportError( "XFile is too small." ); throw DeadlyImportError("XFile is too small.");
} }
// in the hope that binary files will never start with a BOM ... // in the hope that binary files will never start with a BOM ...
mBuffer.resize( fileSize + 1); mBuffer.resize(fileSize + 1);
file->Read( &mBuffer.front(), 1, fileSize); file->Read(&mBuffer.front(), 1, fileSize);
ConvertToUTF8(mBuffer); ConvertToUTF8(mBuffer);
// parse the file into a temporary representation // parse the file into a temporary representation
XFileParser parser( mBuffer); XFileParser parser(mBuffer);
// and create the proper return structures out of it // and create the proper return structures out of it
CreateDataRepresentationFromImport( pScene, parser.GetImportedData()); CreateDataRepresentationFromImport(pScene, parser.GetImportedData());
// if nothing came from it, report it as error // if nothing came from it, report it as error
if ( !pScene->mRootNode ) { if (!pScene->mRootNode) {
throw DeadlyImportError( "XFile is ill-formatted - no content imported." ); throw DeadlyImportError("XFile is ill-formatted - no content imported.");
} }
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Constructs the return data structure out of the imported data. // Constructs the return data structure out of the imported data.
void XFileImporter::CreateDataRepresentationFromImport( aiScene* pScene, XFile::Scene* pData) void XFileImporter::CreateDataRepresentationFromImport(aiScene *pScene, XFile::Scene *pData) {
{
// Read the global materials first so that meshes referring to them can find them later // Read the global materials first so that meshes referring to them can find them later
ConvertMaterials( pScene, pData->mGlobalMaterials); ConvertMaterials(pScene, pData->mGlobalMaterials);
// copy nodes, extracting meshes and materials on the way // copy nodes, extracting meshes and materials on the way
pScene->mRootNode = CreateNodes( pScene, nullptr, pData->mRootNode); pScene->mRootNode = CreateNodes(pScene, nullptr, pData->mRootNode);
// extract animations // extract animations
CreateAnimations( pScene, pData); CreateAnimations(pScene, pData);
// read the global meshes that were stored outside of any node // read the global meshes that were stored outside of any node
if( !pData->mGlobalMeshes.empty() ) { if (!pData->mGlobalMeshes.empty()) {
// create a root node to hold them if there isn't any, yet // create a root node to hold them if there isn't any, yet
if( pScene->mRootNode == nullptr ) { if (pScene->mRootNode == nullptr) {
pScene->mRootNode = new aiNode; pScene->mRootNode = new aiNode;
pScene->mRootNode->mName.Set( "$dummy_node"); pScene->mRootNode->mName.Set("$dummy_node");
} }
// convert all global meshes and store them in the root node. // convert all global meshes and store them in the root node.
// If there was one before, the global meshes now suddenly have its transformation matrix... // If there was one before, the global meshes now suddenly have its transformation matrix...
// Don't know what to do there, I don't want to insert another node under the present root node // Don't know what to do there, I don't want to insert another node under the present root node
// just to avoid this. // just to avoid this.
CreateMeshes( pScene, pScene->mRootNode, pData->mGlobalMeshes); CreateMeshes(pScene, pScene->mRootNode, pData->mGlobalMeshes);
} }
if (!pScene->mRootNode) { if (!pScene->mRootNode) {
throw DeadlyImportError( "No root node" ); throw DeadlyImportError("No root node");
} }
// Convert everything to OpenGL space... it's the same operation as the conversion back, so we can reuse the step directly // Convert everything to OpenGL space... it's the same operation as the conversion back, so we can reuse the step directly
MakeLeftHandedProcess convertProcess; MakeLeftHandedProcess convertProcess;
convertProcess.Execute( pScene); convertProcess.Execute(pScene);
FlipWindingOrderProcess flipper; FlipWindingOrderProcess flipper;
flipper.Execute(pScene); flipper.Execute(pScene);
// finally: create a dummy material if not material was imported // finally: create a dummy material if not material was imported
if( pScene->mNumMaterials == 0) { if (pScene->mNumMaterials == 0) {
pScene->mNumMaterials = 1; pScene->mNumMaterials = 1;
// create the Material // create the Material
aiMaterial* mat = new aiMaterial; aiMaterial *mat = new aiMaterial;
int shadeMode = (int) aiShadingMode_Gouraud; int shadeMode = (int)aiShadingMode_Gouraud;
mat->AddProperty<int>( &shadeMode, 1, AI_MATKEY_SHADING_MODEL); mat->AddProperty<int>(&shadeMode, 1, AI_MATKEY_SHADING_MODEL);
// material colours // material colours
int specExp = 1; int specExp = 1;
aiColor3D clr = aiColor3D( 0, 0, 0); aiColor3D clr = aiColor3D(0, 0, 0);
mat->AddProperty( &clr, 1, AI_MATKEY_COLOR_EMISSIVE); mat->AddProperty(&clr, 1, AI_MATKEY_COLOR_EMISSIVE);
mat->AddProperty( &clr, 1, AI_MATKEY_COLOR_SPECULAR); mat->AddProperty(&clr, 1, AI_MATKEY_COLOR_SPECULAR);
clr = aiColor3D( 0.5f, 0.5f, 0.5f); clr = aiColor3D(0.5f, 0.5f, 0.5f);
mat->AddProperty( &clr, 1, AI_MATKEY_COLOR_DIFFUSE); mat->AddProperty(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
mat->AddProperty( &specExp, 1, AI_MATKEY_SHININESS); mat->AddProperty(&specExp, 1, AI_MATKEY_SHININESS);
pScene->mMaterials = new aiMaterial*[1]; pScene->mMaterials = new aiMaterial *[1];
pScene->mMaterials[0] = mat; pScene->mMaterials[0] = mat;
} }
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Recursively creates scene nodes from the imported hierarchy. // Recursively creates scene nodes from the imported hierarchy.
aiNode* XFileImporter::CreateNodes( aiScene* pScene, aiNode* pParent, const XFile::Node* pNode) { aiNode *XFileImporter::CreateNodes(aiScene *pScene, aiNode *pParent, const XFile::Node *pNode) {
if ( !pNode ) { if (!pNode) {
return nullptr; return nullptr;
} }
// create node // create node
aiNode* node = new aiNode; aiNode *node = new aiNode;
node->mName.length = (ai_uint32)pNode->mName.length(); node->mName.length = (ai_uint32)pNode->mName.length();
node->mParent = pParent; node->mParent = pParent;
memcpy( node->mName.data, pNode->mName.c_str(), pNode->mName.length()); memcpy(node->mName.data, pNode->mName.c_str(), pNode->mName.length());
node->mName.data[node->mName.length] = 0; node->mName.data[node->mName.length] = 0;
node->mTransformation = pNode->mTrafoMatrix; node->mTransformation = pNode->mTrafoMatrix;
// convert meshes from the source node // convert meshes from the source node
CreateMeshes( pScene, node, pNode->mMeshes); CreateMeshes(pScene, node, pNode->mMeshes);
// handle children // handle children
if( !pNode->mChildren.empty() ) { if (!pNode->mChildren.empty()) {
node->mNumChildren = (unsigned int)pNode->mChildren.size(); node->mNumChildren = (unsigned int)pNode->mChildren.size();
node->mChildren = new aiNode* [node->mNumChildren]; node->mChildren = new aiNode *[node->mNumChildren];
for ( unsigned int a = 0; a < pNode->mChildren.size(); ++a ) { for (unsigned int a = 0; a < pNode->mChildren.size(); ++a) {
node->mChildren[ a ] = CreateNodes( pScene, node, pNode->mChildren[ a ] ); node->mChildren[a] = CreateNodes(pScene, node, pNode->mChildren[a]);
} }
} }
@ -217,55 +213,55 @@ aiNode* XFileImporter::CreateNodes( aiScene* pScene, aiNode* pParent, const XFil
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Creates the meshes for the given node. // Creates the meshes for the given node.
void XFileImporter::CreateMeshes( aiScene* pScene, aiNode* pNode, const std::vector<XFile::Mesh*>& pMeshes) { void XFileImporter::CreateMeshes(aiScene *pScene, aiNode *pNode, const std::vector<XFile::Mesh *> &pMeshes) {
if (pMeshes.empty()) { if (pMeshes.empty()) {
return; return;
} }
// create a mesh for each mesh-material combination in the source node // create a mesh for each mesh-material combination in the source node
std::vector<aiMesh*> meshes; std::vector<aiMesh *> meshes;
for( unsigned int a = 0; a < pMeshes.size(); ++a ) { for (unsigned int a = 0; a < pMeshes.size(); ++a) {
XFile::Mesh* sourceMesh = pMeshes[a]; XFile::Mesh *sourceMesh = pMeshes[a];
if ( nullptr == sourceMesh ) { if (nullptr == sourceMesh) {
continue; continue;
} }
// first convert its materials so that we can find them with their index afterwards // first convert its materials so that we can find them with their index afterwards
ConvertMaterials( pScene, sourceMesh->mMaterials); ConvertMaterials(pScene, sourceMesh->mMaterials);
unsigned int numMaterials = std::max( (unsigned int)sourceMesh->mMaterials.size(), 1u); unsigned int numMaterials = std::max((unsigned int)sourceMesh->mMaterials.size(), 1u);
for( unsigned int b = 0; b < numMaterials; ++b ) { for (unsigned int b = 0; b < numMaterials; ++b) {
// collect the faces belonging to this material // collect the faces belonging to this material
std::vector<unsigned int> faces; std::vector<unsigned int> faces;
unsigned int numVertices = 0; unsigned int numVertices = 0;
if( !sourceMesh->mFaceMaterials.empty() ) { if (!sourceMesh->mFaceMaterials.empty()) {
// if there is a per-face material defined, select the faces with the corresponding material // if there is a per-face material defined, select the faces with the corresponding material
for( unsigned int c = 0; c < sourceMesh->mFaceMaterials.size(); ++c ) { for (unsigned int c = 0; c < sourceMesh->mFaceMaterials.size(); ++c) {
if( sourceMesh->mFaceMaterials[c] == b) { if (sourceMesh->mFaceMaterials[c] == b) {
faces.push_back( c); faces.push_back(c);
numVertices += (unsigned int)sourceMesh->mPosFaces[c].mIndices.size(); numVertices += (unsigned int)sourceMesh->mPosFaces[c].mIndices.size();
} }
} }
} else { } else {
// if there is no per-face material, place everything into one mesh // if there is no per-face material, place everything into one mesh
for( unsigned int c = 0; c < sourceMesh->mPosFaces.size(); ++c ) { for (unsigned int c = 0; c < sourceMesh->mPosFaces.size(); ++c) {
faces.push_back( c); faces.push_back(c);
numVertices += (unsigned int)sourceMesh->mPosFaces[c].mIndices.size(); numVertices += (unsigned int)sourceMesh->mPosFaces[c].mIndices.size();
} }
} }
// no faces/vertices using this material? strange... // no faces/vertices using this material? strange...
if ( numVertices == 0 ) { if (numVertices == 0) {
continue; continue;
} }
// create a submesh using this material // create a submesh using this material
aiMesh* mesh = new aiMesh; aiMesh *mesh = new aiMesh;
meshes.push_back( mesh); meshes.push_back(mesh);
// find the material in the scene's material list. Either own material // find the material in the scene's material list. Either own material
// or referenced material, it should already have a valid index // or referenced material, it should already have a valid index
if( !sourceMesh->mFaceMaterials.empty() ) { if (!sourceMesh->mFaceMaterials.empty()) {
mesh->mMaterialIndex = static_cast<unsigned int>(sourceMesh->mMaterials[b].sceneIndex); mesh->mMaterialIndex = static_cast<unsigned int>(sourceMesh->mMaterials[b].sceneIndex);
} else { } else {
mesh->mMaterialIndex = 0; mesh->mMaterialIndex = 0;
@ -282,41 +278,41 @@ void XFileImporter::CreateMeshes( aiScene* pScene, aiNode* pNode, const std::vec
mesh->mName.Set(sourceMesh->mName); mesh->mName.Set(sourceMesh->mName);
// normals? // normals?
if ( sourceMesh->mNormals.size() > 0 ) { if (sourceMesh->mNormals.size() > 0) {
mesh->mNormals = new aiVector3D[ numVertices ]; mesh->mNormals = new aiVector3D[numVertices];
} }
// texture coords // texture coords
for( unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c ) { for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c) {
if ( !sourceMesh->mTexCoords[ c ].empty() ) { if (!sourceMesh->mTexCoords[c].empty()) {
mesh->mTextureCoords[ c ] = new aiVector3D[ numVertices ]; mesh->mTextureCoords[c] = new aiVector3D[numVertices];
} }
} }
// vertex colors // vertex colors
for( unsigned int c = 0; c < AI_MAX_NUMBER_OF_COLOR_SETS; ++c ) { for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_COLOR_SETS; ++c) {
if ( !sourceMesh->mColors[ c ].empty() ) { if (!sourceMesh->mColors[c].empty()) {
mesh->mColors[ c ] = new aiColor4D[ numVertices ]; mesh->mColors[c] = new aiColor4D[numVertices];
} }
} }
// now collect the vertex data of all data streams present in the imported mesh // now collect the vertex data of all data streams present in the imported mesh
unsigned int newIndex( 0 ); unsigned int newIndex(0);
std::vector<unsigned int> orgPoints; // from which original point each new vertex stems std::vector<unsigned int> orgPoints; // from which original point each new vertex stems
orgPoints.resize( numVertices, 0); orgPoints.resize(numVertices, 0);
for( unsigned int c = 0; c < faces.size(); ++c ) { for (unsigned int c = 0; c < faces.size(); ++c) {
unsigned int f = faces[c]; // index of the source face unsigned int f = faces[c]; // index of the source face
const XFile::Face& pf = sourceMesh->mPosFaces[f]; // position source face const XFile::Face &pf = sourceMesh->mPosFaces[f]; // position source face
// create face. either triangle or triangle fan depending on the index count // create face. either triangle or triangle fan depending on the index count
aiFace& df = mesh->mFaces[c]; // destination face aiFace &df = mesh->mFaces[c]; // destination face
df.mNumIndices = (unsigned int)pf.mIndices.size(); df.mNumIndices = (unsigned int)pf.mIndices.size();
df.mIndices = new unsigned int[ df.mNumIndices]; df.mIndices = new unsigned int[df.mNumIndices];
// collect vertex data for indices of this face // collect vertex data for indices of this face
for( unsigned int d = 0; d < df.mNumIndices; ++d ) { for (unsigned int d = 0; d < df.mNumIndices; ++d) {
df.mIndices[ d ] = newIndex; df.mIndices[d] = newIndex;
const unsigned int newIdx( pf.mIndices[ d ] ); const unsigned int newIdx = pf.mIndices[d];
if ( newIdx > sourceMesh->mPositions.size() ) { if (newIdx >= sourceMesh->mPositions.size()) {
continue; continue;
} }
@ -325,24 +321,26 @@ void XFileImporter::CreateMeshes( aiScene* pScene, aiNode* pNode, const std::vec
// Position // Position
mesh->mVertices[newIndex] = sourceMesh->mPositions[pf.mIndices[d]]; mesh->mVertices[newIndex] = sourceMesh->mPositions[pf.mIndices[d]];
// Normal, if present // Normal, if present
if ( mesh->HasNormals() ) { if (mesh->HasNormals()) {
if ( sourceMesh->mNormFaces[ f ].mIndices.size() > d ) { if (sourceMesh->mNormFaces[f].mIndices.size() > d) {
const size_t idx( sourceMesh->mNormFaces[ f ].mIndices[ d ] ); const size_t idx(sourceMesh->mNormFaces[f].mIndices[d]);
mesh->mNormals[ newIndex ] = sourceMesh->mNormals[ idx ]; if (idx < sourceMesh->mNormals.size()) {
mesh->mNormals[newIndex] = sourceMesh->mNormals[idx];
}
} }
} }
// texture coord sets // texture coord sets
for( unsigned int e = 0; e < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++e ) { for (unsigned int e = 0; e < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++e) {
if( mesh->HasTextureCoords( e)) { if (mesh->HasTextureCoords(e)) {
aiVector2D tex = sourceMesh->mTexCoords[e][pf.mIndices[d]]; aiVector2D tex = sourceMesh->mTexCoords[e][pf.mIndices[d]];
mesh->mTextureCoords[e][newIndex] = aiVector3D( tex.x, 1.0f - tex.y, 0.0f); mesh->mTextureCoords[e][newIndex] = aiVector3D(tex.x, 1.0f - tex.y, 0.0f);
} }
} }
// vertex color sets // vertex color sets
for ( unsigned int e = 0; e < AI_MAX_NUMBER_OF_COLOR_SETS; ++e ) { for (unsigned int e = 0; e < AI_MAX_NUMBER_OF_COLOR_SETS; ++e) {
if ( mesh->HasVertexColors( e ) ) { if (mesh->HasVertexColors(e)) {
mesh->mColors[ e ][ newIndex ] = sourceMesh->mColors[ e ][ pf.mIndices[ d ] ]; mesh->mColors[e][newIndex] = sourceMesh->mColors[e][pf.mIndices[d]];
} }
} }
@ -351,63 +349,66 @@ void XFileImporter::CreateMeshes( aiScene* pScene, aiNode* pNode, const std::vec
} }
// there should be as much new vertices as we calculated before // there should be as much new vertices as we calculated before
ai_assert( newIndex == numVertices); ai_assert(newIndex == numVertices);
// convert all bones of the source mesh which influence vertices in this newly created mesh // convert all bones of the source mesh which influence vertices in this newly created mesh
const std::vector<XFile::Bone>& bones = sourceMesh->mBones; const std::vector<XFile::Bone> &bones = sourceMesh->mBones;
std::vector<aiBone*> newBones; std::vector<aiBone *> newBones;
for( unsigned int c = 0; c < bones.size(); ++c ) { for (unsigned int c = 0; c < bones.size(); ++c) {
const XFile::Bone& obone = bones[c]; const XFile::Bone &obone = bones[c];
// set up a vertex-linear array of the weights for quick searching if a bone influences a vertex // set up a vertex-linear array of the weights for quick searching if a bone influences a vertex
std::vector<ai_real> oldWeights( sourceMesh->mPositions.size(), 0.0); std::vector<ai_real> oldWeights(sourceMesh->mPositions.size(), 0.0);
for ( unsigned int d = 0; d < obone.mWeights.size(); ++d ) { for (unsigned int d = 0; d < obone.mWeights.size(); ++d) {
oldWeights[ obone.mWeights[ d ].mVertex ] = obone.mWeights[ d ].mWeight; const unsigned int boneIdx = obone.mWeights[d].mVertex;
if (boneIdx < obone.mWeights.size()) {
oldWeights[obone.mWeights[d].mVertex] = obone.mWeights[d].mWeight;
}
} }
// collect all vertex weights that influence a vertex in the new mesh // collect all vertex weights that influence a vertex in the new mesh
std::vector<aiVertexWeight> newWeights; std::vector<aiVertexWeight> newWeights;
newWeights.reserve( numVertices); newWeights.reserve(numVertices);
for( unsigned int d = 0; d < orgPoints.size(); ++d ) { for (unsigned int d = 0; d < orgPoints.size(); ++d) {
// does the new vertex stem from an old vertex which was influenced by this bone? // does the new vertex stem from an old vertex which was influenced by this bone?
ai_real w = oldWeights[orgPoints[d]]; ai_real w = oldWeights[orgPoints[d]];
if ( w > 0.0 ) { if (w > 0.0) {
newWeights.emplace_back( d, w ); newWeights.emplace_back(d, w);
} }
} }
// if the bone has no weights in the newly created mesh, ignore it // if the bone has no weights in the newly created mesh, ignore it
if ( newWeights.empty() ) { if (newWeights.empty()) {
continue; continue;
} }
// create // create
aiBone* nbone = new aiBone; aiBone *nbone = new aiBone;
newBones.push_back( nbone); newBones.push_back(nbone);
// copy name and matrix // copy name and matrix
nbone->mName.Set( obone.mName); nbone->mName.Set(obone.mName);
nbone->mOffsetMatrix = obone.mOffsetMatrix; nbone->mOffsetMatrix = obone.mOffsetMatrix;
nbone->mNumWeights = (unsigned int)newWeights.size(); nbone->mNumWeights = (unsigned int)newWeights.size();
nbone->mWeights = new aiVertexWeight[nbone->mNumWeights]; nbone->mWeights = new aiVertexWeight[nbone->mNumWeights];
for ( unsigned int d = 0; d < newWeights.size(); ++d ) { for (unsigned int d = 0; d < newWeights.size(); ++d) {
nbone->mWeights[ d ] = newWeights[ d ]; nbone->mWeights[d] = newWeights[d];
} }
} }
// store the bones in the mesh // store the bones in the mesh
mesh->mNumBones = (unsigned int)newBones.size(); mesh->mNumBones = (unsigned int)newBones.size();
if( !newBones.empty()) { if (!newBones.empty()) {
mesh->mBones = new aiBone*[mesh->mNumBones]; mesh->mBones = new aiBone *[mesh->mNumBones];
std::copy( newBones.begin(), newBones.end(), mesh->mBones); std::copy(newBones.begin(), newBones.end(), mesh->mBones);
} }
} }
} }
// reallocate scene mesh array to be large enough // reallocate scene mesh array to be large enough
aiMesh** prevArray = pScene->mMeshes; aiMesh **prevArray = pScene->mMeshes;
pScene->mMeshes = new aiMesh*[pScene->mNumMeshes + meshes.size()]; pScene->mMeshes = new aiMesh *[pScene->mNumMeshes + meshes.size()];
if( prevArray) { if (prevArray) {
memcpy( pScene->mMeshes, prevArray, pScene->mNumMeshes * sizeof( aiMesh*)); memcpy(pScene->mMeshes, prevArray, pScene->mNumMeshes * sizeof(aiMesh *));
delete [] prevArray; delete[] prevArray;
} }
// allocate mesh index array in the node // allocate mesh index array in the node
@ -415,7 +416,7 @@ void XFileImporter::CreateMeshes( aiScene* pScene, aiNode* pNode, const std::vec
pNode->mMeshes = new unsigned int[pNode->mNumMeshes]; pNode->mMeshes = new unsigned int[pNode->mNumMeshes];
// store all meshes in the mesh library of the scene and store their indices in the node // store all meshes in the mesh library of the scene and store their indices in the node
for( unsigned int a = 0; a < meshes.size(); a++) { for (unsigned int a = 0; a < meshes.size(); a++) {
pScene->mMeshes[pScene->mNumMeshes] = meshes[a]; pScene->mMeshes[pScene->mNumMeshes] = meshes[a];
pNode->mMeshes[a] = pScene->mNumMeshes; pNode->mMeshes[a] = pScene->mNumMeshes;
pScene->mNumMeshes++; pScene->mNumMeshes++;
@ -424,35 +425,34 @@ void XFileImporter::CreateMeshes( aiScene* pScene, aiNode* pNode, const std::vec
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Converts the animations from the given imported data and creates them in the scene. // Converts the animations from the given imported data and creates them in the scene.
void XFileImporter::CreateAnimations( aiScene* pScene, const XFile::Scene* pData) { void XFileImporter::CreateAnimations(aiScene *pScene, const XFile::Scene *pData) {
std::vector<aiAnimation*> newAnims; std::vector<aiAnimation *> newAnims;
for( unsigned int a = 0; a < pData->mAnims.size(); ++a ) { for (unsigned int a = 0; a < pData->mAnims.size(); ++a) {
const XFile::Animation* anim = pData->mAnims[a]; const XFile::Animation *anim = pData->mAnims[a];
// some exporters mock me with empty animation tags. // some exporters mock me with empty animation tags.
if ( anim->mAnims.empty() ) { if (anim->mAnims.empty()) {
continue; continue;
} }
// create a new animation to hold the data // create a new animation to hold the data
aiAnimation* nanim = new aiAnimation; aiAnimation *nanim = new aiAnimation;
newAnims.push_back( nanim); newAnims.push_back(nanim);
nanim->mName.Set( anim->mName); nanim->mName.Set(anim->mName);
// duration will be determined by the maximum length // duration will be determined by the maximum length
nanim->mDuration = 0; nanim->mDuration = 0;
nanim->mTicksPerSecond = pData->mAnimTicksPerSecond; nanim->mTicksPerSecond = pData->mAnimTicksPerSecond;
nanim->mNumChannels = (unsigned int)anim->mAnims.size(); nanim->mNumChannels = (unsigned int)anim->mAnims.size();
nanim->mChannels = new aiNodeAnim*[nanim->mNumChannels]; nanim->mChannels = new aiNodeAnim *[nanim->mNumChannels];
for( unsigned int b = 0; b < anim->mAnims.size(); ++b ) { for (unsigned int b = 0; b < anim->mAnims.size(); ++b) {
const XFile::AnimBone* bone = anim->mAnims[b]; const XFile::AnimBone *bone = anim->mAnims[b];
aiNodeAnim* nbone = new aiNodeAnim; aiNodeAnim *nbone = new aiNodeAnim;
nbone->mNodeName.Set( bone->mBoneName); nbone->mNodeName.Set(bone->mBoneName);
nanim->mChannels[b] = nbone; nanim->mChannels[b] = nbone;
// key-frames are given as combined transformation matrix keys // key-frames are given as combined transformation matrix keys
if( !bone->mTrafoKeys.empty() ) if (!bone->mTrafoKeys.empty()) {
{
nbone->mNumPositionKeys = (unsigned int)bone->mTrafoKeys.size(); nbone->mNumPositionKeys = (unsigned int)bone->mTrafoKeys.size();
nbone->mPositionKeys = new aiVectorKey[nbone->mNumPositionKeys]; nbone->mPositionKeys = new aiVectorKey[nbone->mNumPositionKeys];
nbone->mNumRotationKeys = (unsigned int)bone->mTrafoKeys.size(); nbone->mNumRotationKeys = (unsigned int)bone->mTrafoKeys.size();
@ -460,22 +460,22 @@ void XFileImporter::CreateAnimations( aiScene* pScene, const XFile::Scene* pData
nbone->mNumScalingKeys = (unsigned int)bone->mTrafoKeys.size(); nbone->mNumScalingKeys = (unsigned int)bone->mTrafoKeys.size();
nbone->mScalingKeys = new aiVectorKey[nbone->mNumScalingKeys]; nbone->mScalingKeys = new aiVectorKey[nbone->mNumScalingKeys];
for( unsigned int c = 0; c < bone->mTrafoKeys.size(); ++c) { for (unsigned int c = 0; c < bone->mTrafoKeys.size(); ++c) {
// deconstruct each matrix into separate position, rotation and scaling // deconstruct each matrix into separate position, rotation and scaling
double time = bone->mTrafoKeys[c].mTime; double time = bone->mTrafoKeys[c].mTime;
aiMatrix4x4 trafo = bone->mTrafoKeys[c].mMatrix; aiMatrix4x4 trafo = bone->mTrafoKeys[c].mMatrix;
// extract position // extract position
aiVector3D pos( trafo.a4, trafo.b4, trafo.c4); aiVector3D pos(trafo.a4, trafo.b4, trafo.c4);
nbone->mPositionKeys[c].mTime = time; nbone->mPositionKeys[c].mTime = time;
nbone->mPositionKeys[c].mValue = pos; nbone->mPositionKeys[c].mValue = pos;
// extract scaling // extract scaling
aiVector3D scale; aiVector3D scale;
scale.x = aiVector3D( trafo.a1, trafo.b1, trafo.c1).Length(); scale.x = aiVector3D(trafo.a1, trafo.b1, trafo.c1).Length();
scale.y = aiVector3D( trafo.a2, trafo.b2, trafo.c2).Length(); scale.y = aiVector3D(trafo.a2, trafo.b2, trafo.c2).Length();
scale.z = aiVector3D( trafo.a3, trafo.b3, trafo.c3).Length(); scale.z = aiVector3D(trafo.a3, trafo.b3, trafo.c3).Length();
nbone->mScalingKeys[c].mTime = time; nbone->mScalingKeys[c].mTime = time;
nbone->mScalingKeys[c].mValue = scale; nbone->mScalingKeys[c].mValue = scale;
@ -487,17 +487,17 @@ void XFileImporter::CreateAnimations( aiScene* pScene, const XFile::Scene* pData
// and convert it into a quaternion // and convert it into a quaternion
nbone->mRotationKeys[c].mTime = time; nbone->mRotationKeys[c].mTime = time;
nbone->mRotationKeys[c].mValue = aiQuaternion( rotmat); nbone->mRotationKeys[c].mValue = aiQuaternion(rotmat);
} }
// longest lasting key sequence determines duration // longest lasting key sequence determines duration
nanim->mDuration = std::max( nanim->mDuration, bone->mTrafoKeys.back().mTime); nanim->mDuration = std::max(nanim->mDuration, bone->mTrafoKeys.back().mTime);
} else { } else {
// separate key sequences for position, rotation, scaling // separate key sequences for position, rotation, scaling
nbone->mNumPositionKeys = (unsigned int)bone->mPosKeys.size(); nbone->mNumPositionKeys = (unsigned int)bone->mPosKeys.size();
if (nbone->mNumPositionKeys != 0) { if (nbone->mNumPositionKeys != 0) {
nbone->mPositionKeys = new aiVectorKey[nbone->mNumPositionKeys]; nbone->mPositionKeys = new aiVectorKey[nbone->mNumPositionKeys];
for( unsigned int c = 0; c < nbone->mNumPositionKeys; ++c ) { for (unsigned int c = 0; c < nbone->mNumPositionKeys; ++c) {
aiVector3D pos = bone->mPosKeys[c].mValue; aiVector3D pos = bone->mPosKeys[c].mValue;
nbone->mPositionKeys[c].mTime = bone->mPosKeys[c].mTime; nbone->mPositionKeys[c].mTime = bone->mPosKeys[c].mTime;
@ -509,11 +509,11 @@ void XFileImporter::CreateAnimations( aiScene* pScene, const XFile::Scene* pData
nbone->mNumRotationKeys = (unsigned int)bone->mRotKeys.size(); nbone->mNumRotationKeys = (unsigned int)bone->mRotKeys.size();
if (nbone->mNumRotationKeys != 0) { if (nbone->mNumRotationKeys != 0) {
nbone->mRotationKeys = new aiQuatKey[nbone->mNumRotationKeys]; nbone->mRotationKeys = new aiQuatKey[nbone->mNumRotationKeys];
for( unsigned int c = 0; c < nbone->mNumRotationKeys; ++c ) { for (unsigned int c = 0; c < nbone->mNumRotationKeys; ++c) {
aiMatrix3x3 rotmat = bone->mRotKeys[c].mValue.GetMatrix(); aiMatrix3x3 rotmat = bone->mRotKeys[c].mValue.GetMatrix();
nbone->mRotationKeys[c].mTime = bone->mRotKeys[c].mTime; nbone->mRotationKeys[c].mTime = bone->mRotKeys[c].mTime;
nbone->mRotationKeys[c].mValue = aiQuaternion( rotmat); nbone->mRotationKeys[c].mValue = aiQuaternion(rotmat);
nbone->mRotationKeys[c].mValue.w *= -1.0f; // needs quat inversion nbone->mRotationKeys[c].mValue.w *= -1.0f; // needs quat inversion
} }
} }
@ -522,153 +522,149 @@ void XFileImporter::CreateAnimations( aiScene* pScene, const XFile::Scene* pData
nbone->mNumScalingKeys = (unsigned int)bone->mScaleKeys.size(); nbone->mNumScalingKeys = (unsigned int)bone->mScaleKeys.size();
if (nbone->mNumScalingKeys != 0) { if (nbone->mNumScalingKeys != 0) {
nbone->mScalingKeys = new aiVectorKey[nbone->mNumScalingKeys]; nbone->mScalingKeys = new aiVectorKey[nbone->mNumScalingKeys];
for( unsigned int c = 0; c < nbone->mNumScalingKeys; c++) for (unsigned int c = 0; c < nbone->mNumScalingKeys; c++)
nbone->mScalingKeys[c] = bone->mScaleKeys[c]; nbone->mScalingKeys[c] = bone->mScaleKeys[c];
} }
// longest lasting key sequence determines duration // longest lasting key sequence determines duration
if( bone->mPosKeys.size() > 0) if (bone->mPosKeys.size() > 0)
nanim->mDuration = std::max( nanim->mDuration, bone->mPosKeys.back().mTime); nanim->mDuration = std::max(nanim->mDuration, bone->mPosKeys.back().mTime);
if( bone->mRotKeys.size() > 0) if (bone->mRotKeys.size() > 0)
nanim->mDuration = std::max( nanim->mDuration, bone->mRotKeys.back().mTime); nanim->mDuration = std::max(nanim->mDuration, bone->mRotKeys.back().mTime);
if( bone->mScaleKeys.size() > 0) if (bone->mScaleKeys.size() > 0)
nanim->mDuration = std::max( nanim->mDuration, bone->mScaleKeys.back().mTime); nanim->mDuration = std::max(nanim->mDuration, bone->mScaleKeys.back().mTime);
} }
} }
} }
// store all converted animations in the scene // store all converted animations in the scene
if( newAnims.size() > 0) if (newAnims.size() > 0) {
{
pScene->mNumAnimations = (unsigned int)newAnims.size(); pScene->mNumAnimations = (unsigned int)newAnims.size();
pScene->mAnimations = new aiAnimation* [pScene->mNumAnimations]; pScene->mAnimations = new aiAnimation *[pScene->mNumAnimations];
for( unsigned int a = 0; a < newAnims.size(); a++) for (unsigned int a = 0; a < newAnims.size(); a++)
pScene->mAnimations[a] = newAnims[a]; pScene->mAnimations[a] = newAnims[a];
} }
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Converts all materials in the given array and stores them in the scene's material list. // Converts all materials in the given array and stores them in the scene's material list.
void XFileImporter::ConvertMaterials( aiScene* pScene, std::vector<XFile::Material>& pMaterials) void XFileImporter::ConvertMaterials(aiScene *pScene, std::vector<XFile::Material> &pMaterials) {
{
// count the non-referrer materials in the array // count the non-referrer materials in the array
unsigned int numNewMaterials( 0 ); unsigned int numNewMaterials(0);
for ( unsigned int a = 0; a < pMaterials.size(); ++a ) { for (unsigned int a = 0; a < pMaterials.size(); ++a) {
if ( !pMaterials[ a ].mIsReference ) { if (!pMaterials[a].mIsReference) {
++numNewMaterials; ++numNewMaterials;
} }
} }
// resize the scene's material list to offer enough space for the new materials // resize the scene's material list to offer enough space for the new materials
if( numNewMaterials > 0 ) { if (numNewMaterials > 0) {
aiMaterial** prevMats = pScene->mMaterials; aiMaterial **prevMats = pScene->mMaterials;
pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials + numNewMaterials]; pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials + numNewMaterials];
if( nullptr != prevMats) { if (nullptr != prevMats) {
::memcpy( pScene->mMaterials, prevMats, pScene->mNumMaterials * sizeof( aiMaterial*)); ::memcpy(pScene->mMaterials, prevMats, pScene->mNumMaterials * sizeof(aiMaterial *));
delete [] prevMats; delete[] prevMats;
} }
} }
// convert all the materials given in the array // convert all the materials given in the array
for( unsigned int a = 0; a < pMaterials.size(); ++a ) { for (unsigned int a = 0; a < pMaterials.size(); ++a) {
XFile::Material& oldMat = pMaterials[a]; XFile::Material &oldMat = pMaterials[a];
if( oldMat.mIsReference) { if (oldMat.mIsReference) {
// find the material it refers to by name, and store its index // find the material it refers to by name, and store its index
for( size_t b = 0; b < pScene->mNumMaterials; ++b ) { for (size_t b = 0; b < pScene->mNumMaterials; ++b) {
aiString name; aiString name;
pScene->mMaterials[b]->Get( AI_MATKEY_NAME, name); pScene->mMaterials[b]->Get(AI_MATKEY_NAME, name);
if( strcmp( name.C_Str(), oldMat.mName.data()) == 0 ) { if (strcmp(name.C_Str(), oldMat.mName.data()) == 0) {
oldMat.sceneIndex = b; oldMat.sceneIndex = b;
break; break;
} }
} }
if( oldMat.sceneIndex == SIZE_MAX ) { if (oldMat.sceneIndex == SIZE_MAX) {
ASSIMP_LOG_WARN( "Could not resolve global material reference \"", oldMat.mName, "\"" ); ASSIMP_LOG_WARN("Could not resolve global material reference \"", oldMat.mName, "\"");
oldMat.sceneIndex = 0; oldMat.sceneIndex = 0;
} }
continue; continue;
} }
aiMaterial* mat = new aiMaterial; aiMaterial *mat = new aiMaterial;
aiString name; aiString name;
name.Set( oldMat.mName); name.Set(oldMat.mName);
mat->AddProperty( &name, AI_MATKEY_NAME); mat->AddProperty(&name, AI_MATKEY_NAME);
// Shading model: hard-coded to PHONG, there is no such information in an XFile // Shading model: hard-coded to PHONG, there is no such information in an XFile
// FIX (aramis): If the specular exponent is 0, use gouraud shading. This is a bugfix // FIX (aramis): If the specular exponent is 0, use gouraud shading. This is a bugfix
// for some models in the SDK (e.g. good old tiny.x) // for some models in the SDK (e.g. good old tiny.x)
int shadeMode = (int)oldMat.mSpecularExponent == 0.0f int shadeMode = (int)oldMat.mSpecularExponent == 0.0f ? aiShadingMode_Gouraud : aiShadingMode_Phong;
? aiShadingMode_Gouraud : aiShadingMode_Phong;
mat->AddProperty<int>( &shadeMode, 1, AI_MATKEY_SHADING_MODEL); mat->AddProperty<int>(&shadeMode, 1, AI_MATKEY_SHADING_MODEL);
// material colours // material colours
// Unclear: there's no ambient colour, but emissive. What to put for ambient? // Unclear: there's no ambient colour, but emissive. What to put for ambient?
// Probably nothing at all, let the user select a suitable default. // Probably nothing at all, let the user select a suitable default.
mat->AddProperty( &oldMat.mEmissive, 1, AI_MATKEY_COLOR_EMISSIVE); mat->AddProperty(&oldMat.mEmissive, 1, AI_MATKEY_COLOR_EMISSIVE);
mat->AddProperty( &oldMat.mDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE); mat->AddProperty(&oldMat.mDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
mat->AddProperty( &oldMat.mSpecular, 1, AI_MATKEY_COLOR_SPECULAR); mat->AddProperty(&oldMat.mSpecular, 1, AI_MATKEY_COLOR_SPECULAR);
mat->AddProperty( &oldMat.mSpecularExponent, 1, AI_MATKEY_SHININESS); mat->AddProperty(&oldMat.mSpecularExponent, 1, AI_MATKEY_SHININESS);
// texture, if there is one // texture, if there is one
if (1 == oldMat.mTextures.size() ) { if (1 == oldMat.mTextures.size()) {
const XFile::TexEntry& otex = oldMat.mTextures.back(); const XFile::TexEntry &otex = oldMat.mTextures.back();
if (otex.mName.length()) { if (otex.mName.length()) {
// if there is only one texture assume it contains the diffuse color // if there is only one texture assume it contains the diffuse color
aiString tex( otex.mName); aiString tex(otex.mName);
if ( otex.mIsNormalMap ) { if (otex.mIsNormalMap) {
mat->AddProperty( &tex, AI_MATKEY_TEXTURE_NORMALS( 0 ) ); mat->AddProperty(&tex, AI_MATKEY_TEXTURE_NORMALS(0));
} else { } else {
mat->AddProperty( &tex, AI_MATKEY_TEXTURE_DIFFUSE( 0 ) ); mat->AddProperty(&tex, AI_MATKEY_TEXTURE_DIFFUSE(0));
} }
} }
} else { } else {
// Otherwise ... try to search for typical strings in the // Otherwise ... try to search for typical strings in the
// texture's file name like 'bump' or 'diffuse' // texture's file name like 'bump' or 'diffuse'
unsigned int iHM = 0,iNM = 0,iDM = 0,iSM = 0,iAM = 0,iEM = 0; unsigned int iHM = 0, iNM = 0, iDM = 0, iSM = 0, iAM = 0, iEM = 0;
for( unsigned int b = 0; b < oldMat.mTextures.size(); ++b ) { for (unsigned int b = 0; b < oldMat.mTextures.size(); ++b) {
const XFile::TexEntry& otex = oldMat.mTextures[b]; const XFile::TexEntry &otex = oldMat.mTextures[b];
std::string sz = otex.mName; std::string sz = otex.mName;
if ( !sz.length() ) { if (!sz.length()) {
continue; continue;
} }
// find the file name // find the file name
std::string::size_type s = sz.find_last_of("\\/"); std::string::size_type s = sz.find_last_of("\\/");
if ( std::string::npos == s ) { if (std::string::npos == s) {
s = 0; s = 0;
} }
// cut off the file extension // cut off the file extension
std::string::size_type sExt = sz.find_last_of('.'); std::string::size_type sExt = sz.find_last_of('.');
if (std::string::npos != sExt){ if (std::string::npos != sExt) {
sz[sExt] = '\0'; sz[sExt] = '\0';
} }
// convert to lower case for easier comparison // convert to lower case for easier comparison
for ( unsigned int c = 0; c < sz.length(); ++c ) { for (unsigned int c = 0; c < sz.length(); ++c) {
sz[ c ] = (char) tolower( (unsigned char) sz[ c ] ); sz[c] = (char)tolower((unsigned char)sz[c]);
} }
// Place texture filename property under the corresponding name // Place texture filename property under the corresponding name
aiString tex( oldMat.mTextures[b].mName); aiString tex(oldMat.mTextures[b].mName);
// bump map // bump map
if (std::string::npos != sz.find("bump", s) || std::string::npos != sz.find("height", s)) { if (std::string::npos != sz.find("bump", s) || std::string::npos != sz.find("height", s)) {
mat->AddProperty( &tex, AI_MATKEY_TEXTURE_HEIGHT(iHM++)); mat->AddProperty(&tex, AI_MATKEY_TEXTURE_HEIGHT(iHM++));
} else if (otex.mIsNormalMap || std::string::npos != sz.find( "normal", s) || std::string::npos != sz.find("nm", s)) { } else if (otex.mIsNormalMap || std::string::npos != sz.find("normal", s) || std::string::npos != sz.find("nm", s)) {
mat->AddProperty( &tex, AI_MATKEY_TEXTURE_NORMALS(iNM++)); mat->AddProperty(&tex, AI_MATKEY_TEXTURE_NORMALS(iNM++));
} else if (std::string::npos != sz.find( "spec", s) || std::string::npos != sz.find( "glanz", s)) { } else if (std::string::npos != sz.find("spec", s) || std::string::npos != sz.find("glanz", s)) {
mat->AddProperty( &tex, AI_MATKEY_TEXTURE_SPECULAR(iSM++)); mat->AddProperty(&tex, AI_MATKEY_TEXTURE_SPECULAR(iSM++));
} else if (std::string::npos != sz.find( "ambi", s) || std::string::npos != sz.find( "env", s)) { } else if (std::string::npos != sz.find("ambi", s) || std::string::npos != sz.find("env", s)) {
mat->AddProperty( &tex, AI_MATKEY_TEXTURE_AMBIENT(iAM++)); mat->AddProperty(&tex, AI_MATKEY_TEXTURE_AMBIENT(iAM++));
} else if (std::string::npos != sz.find( "emissive", s) || std::string::npos != sz.find( "self", s)) { } else if (std::string::npos != sz.find("emissive", s) || std::string::npos != sz.find("self", s)) {
mat->AddProperty( &tex, AI_MATKEY_TEXTURE_EMISSIVE(iEM++)); mat->AddProperty(&tex, AI_MATKEY_TEXTURE_EMISSIVE(iEM++));
} else { } else {
// Assume it is a diffuse texture // Assume it is a diffuse texture
mat->AddProperty( &tex, AI_MATKEY_TEXTURE_DIFFUSE(iDM++)); mat->AddProperty(&tex, AI_MATKEY_TEXTURE_DIFFUSE(iDM++));
} }
} }
} }
@ -679,4 +675,6 @@ void XFileImporter::ConvertMaterials( aiScene* pScene, std::vector<XFile::Materi
} }
} }
} // namespace Assimp
#endif // !! ASSIMP_BUILD_NO_X_IMPORTER #endif // !! ASSIMP_BUILD_NO_X_IMPORTER

2
code/AssetLib/X/XFileImporter.h
View File

@ -68,7 +68,7 @@ namespace XFile {
*/ */
class XFileImporter : public BaseImporter { class XFileImporter : public BaseImporter {
public: public:
XFileImporter(); XFileImporter() = default;
~XFileImporter() override = default; ~XFileImporter() override = default;
// ------------------------------------------------------------------- // -------------------------------------------------------------------