diff options
Diffstat (limited to 'libs/assimp/code/AssetLib/Obj/ObjFileImporter.cpp')
| -rw-r--r-- | libs/assimp/code/AssetLib/Obj/ObjFileImporter.cpp | 783 |
1 files changed, 783 insertions, 0 deletions
diff --git a/libs/assimp/code/AssetLib/Obj/ObjFileImporter.cpp b/libs/assimp/code/AssetLib/Obj/ObjFileImporter.cpp new file mode 100644 index 0000000..68fdb21 --- /dev/null +++ b/libs/assimp/code/AssetLib/Obj/ObjFileImporter.cpp @@ -0,0 +1,783 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (assimp) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2020, 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 ASSIMP_BUILD_NO_OBJ_IMPORTER + +#include "ObjFileImporter.h" +#include "ObjFileData.h" +#include "ObjFileParser.h" +#include <assimp/DefaultIOSystem.h> +#include <assimp/IOStreamBuffer.h> +#include <assimp/ai_assert.h> +#include <assimp/importerdesc.h> +#include <assimp/scene.h> +#include <assimp/DefaultLogger.hpp> +#include <assimp/Importer.hpp> +#include <assimp/ObjMaterial.h> +#include <memory> + +static const aiImporterDesc desc = { + "Wavefront Object Importer", + "", + "", + "surfaces not supported", + aiImporterFlags_SupportTextFlavour, + 0, + 0, + 0, + 0, + "obj" +}; + +static const unsigned int ObjMinSize = 16; + +namespace Assimp { + +using namespace std; + +// ------------------------------------------------------------------------------------------------ +// Default constructor +ObjFileImporter::ObjFileImporter() : + m_Buffer(), + m_pRootObject(nullptr), + m_strAbsPath(std::string(1, DefaultIOSystem().getOsSeparator())) {} + +// ------------------------------------------------------------------------------------------------ +// Destructor. +ObjFileImporter::~ObjFileImporter() { + delete m_pRootObject; + m_pRootObject = nullptr; +} + +// ------------------------------------------------------------------------------------------------ +// Returns true if file is an obj file. +bool ObjFileImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { + static const char *tokens[] = { "mtllib", "usemtl", "v ", "vt ", "vn ", "o ", "g ", "s ", "f " }; + return BaseImporter::SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens), 200, false, true); +} + +// ------------------------------------------------------------------------------------------------ +const aiImporterDesc *ObjFileImporter::GetInfo() const { + return &desc; +} + +// ------------------------------------------------------------------------------------------------ +// Obj-file import implementation +void ObjFileImporter::InternReadFile(const std::string &file, aiScene *pScene, IOSystem *pIOHandler) { + // Read file into memory + static const std::string mode = "rb"; + auto streamCloser = [&](IOStream *pStream) { + pIOHandler->Close(pStream); + }; + std::unique_ptr<IOStream, decltype(streamCloser)> fileStream(pIOHandler->Open(file, mode), streamCloser); + if (!fileStream.get()) { + throw DeadlyImportError("Failed to open file ", file, "."); + } + + // Get the file-size and validate it, throwing an exception when fails + size_t fileSize = fileStream->FileSize(); + if (fileSize < ObjMinSize) { + throw DeadlyImportError("OBJ-file is too small."); + } + + IOStreamBuffer<char> streamedBuffer; + streamedBuffer.open(fileStream.get()); + + // Allocate buffer and read file into it + //TextFileToBuffer( fileStream.get(),m_Buffer); + + // Get the model name + std::string modelName, folderName; + std::string::size_type pos = file.find_last_of("\\/"); + if (pos != std::string::npos) { + modelName = file.substr(pos + 1, file.size() - pos - 1); + folderName = file.substr(0, pos); + if (!folderName.empty()) { + pIOHandler->PushDirectory(folderName); + } + } else { + modelName = file; + } + + // parse the file into a temporary representation + ObjFileParser parser(streamedBuffer, modelName, pIOHandler, m_progress, file); + + // And create the proper return structures out of it + CreateDataFromImport(parser.GetModel(), pScene); + + streamedBuffer.close(); + + // Clean up allocated storage for the next import + m_Buffer.clear(); + + // Pop directory stack + if (pIOHandler->StackSize() > 0) { + pIOHandler->PopDirectory(); + } +} + +// ------------------------------------------------------------------------------------------------ +// Create the data from parsed obj-file +void ObjFileImporter::CreateDataFromImport(const ObjFile::Model *pModel, aiScene *pScene) { + if (nullptr == pModel) { + return; + } + + // Create the root node of the scene + pScene->mRootNode = new aiNode; + if (!pModel->m_ModelName.empty()) { + // Set the name of the scene + pScene->mRootNode->mName.Set(pModel->m_ModelName); + } else { + // This is a fatal error, so break down the application + ai_assert(false); + } + + if (!pModel->m_Objects.empty()) { + + unsigned int meshCount = 0; + unsigned int childCount = 0; + + for (auto object : pModel->m_Objects) { + if (object) { + ++childCount; + meshCount += (unsigned int)object->m_Meshes.size(); + } + } + + // Allocate space for the child nodes on the root node + pScene->mRootNode->mChildren = new aiNode *[childCount]; + + // Create nodes for the whole scene + std::vector<aiMesh *> MeshArray; + MeshArray.reserve(meshCount); + for (size_t index = 0; index < pModel->m_Objects.size(); ++index) { + createNodes(pModel, pModel->m_Objects[index], pScene->mRootNode, pScene, MeshArray); + } + + ai_assert(pScene->mRootNode->mNumChildren == childCount); + + // Create mesh pointer buffer for this scene + if (pScene->mNumMeshes > 0) { + pScene->mMeshes = new aiMesh *[MeshArray.size()]; + for (size_t index = 0; index < MeshArray.size(); ++index) { + pScene->mMeshes[index] = MeshArray[index]; + } + } + + // Create all materials + createMaterials(pModel, pScene); + } else { + if (pModel->m_Vertices.empty()) { + return; + } + + std::unique_ptr<aiMesh> mesh(new aiMesh); + mesh->mPrimitiveTypes = aiPrimitiveType_POINT; + unsigned int n = (unsigned int)pModel->m_Vertices.size(); + mesh->mNumVertices = n; + + mesh->mVertices = new aiVector3D[n]; + memcpy(mesh->mVertices, pModel->m_Vertices.data(), n * sizeof(aiVector3D)); + + if (!pModel->m_Normals.empty()) { + mesh->mNormals = new aiVector3D[n]; + if (pModel->m_Normals.size() < n) { + throw DeadlyImportError("OBJ: vertex normal index out of range"); + } + memcpy(mesh->mNormals, pModel->m_Normals.data(), n * sizeof(aiVector3D)); + } + + if (!pModel->m_VertexColors.empty()) { + mesh->mColors[0] = new aiColor4D[mesh->mNumVertices]; + for (unsigned int i = 0; i < n; ++i) { + if (i < pModel->m_VertexColors.size()) { + const aiVector3D &color = pModel->m_VertexColors[i]; + mesh->mColors[0][i] = aiColor4D(color.x, color.y, color.z, 1.0); + } else { + throw DeadlyImportError("OBJ: vertex color index out of range"); + } + } + } + + pScene->mRootNode->mNumMeshes = 1; + pScene->mRootNode->mMeshes = new unsigned int[1]; + pScene->mRootNode->mMeshes[0] = 0; + pScene->mMeshes = new aiMesh *[1]; + pScene->mNumMeshes = 1; + pScene->mMeshes[0] = mesh.release(); + } +} + +// ------------------------------------------------------------------------------------------------ +// Creates all nodes of the model +aiNode *ObjFileImporter::createNodes(const ObjFile::Model *pModel, const ObjFile::Object *pObject, + aiNode *pParent, aiScene *pScene, + std::vector<aiMesh *> &MeshArray) { + ai_assert(nullptr != pModel); + if (nullptr == pObject) { + return nullptr; + } + + // Store older mesh size to be able to computes mesh offsets for new mesh instances + const size_t oldMeshSize = MeshArray.size(); + aiNode *pNode = new aiNode; + + pNode->mName = pObject->m_strObjName; + + // If we have a parent node, store it + ai_assert(nullptr != pParent); + appendChildToParentNode(pParent, pNode); + + for (size_t i = 0; i < pObject->m_Meshes.size(); ++i) { + unsigned int meshId = pObject->m_Meshes[i]; + aiMesh *pMesh = createTopology(pModel, pObject, meshId); + if (pMesh) { + if (pMesh->mNumFaces > 0) { + MeshArray.push_back(pMesh); + } else { + delete pMesh; + } + } + } + + // Create all nodes from the sub-objects stored in the current object + if (!pObject->m_SubObjects.empty()) { + size_t numChilds = pObject->m_SubObjects.size(); + pNode->mNumChildren = static_cast<unsigned int>(numChilds); + pNode->mChildren = new aiNode *[numChilds]; + pNode->mNumMeshes = 1; + pNode->mMeshes = new unsigned int[1]; + } + + // Set mesh instances into scene- and node-instances + const size_t meshSizeDiff = MeshArray.size() - oldMeshSize; + if (meshSizeDiff > 0) { + pNode->mMeshes = new unsigned int[meshSizeDiff]; + pNode->mNumMeshes = static_cast<unsigned int>(meshSizeDiff); + size_t index = 0; + for (size_t i = oldMeshSize; i < MeshArray.size(); ++i) { + pNode->mMeshes[index] = pScene->mNumMeshes; + pScene->mNumMeshes++; + ++index; + } + } + + return pNode; +} + +// ------------------------------------------------------------------------------------------------ +// Create topology data +aiMesh *ObjFileImporter::createTopology(const ObjFile::Model *pModel, const ObjFile::Object *pData, unsigned int meshIndex) { + // Checking preconditions + ai_assert(nullptr != pModel); + + if (nullptr == pData) { + return nullptr; + } + + // Create faces + ObjFile::Mesh *pObjMesh = pModel->m_Meshes[meshIndex]; + if (!pObjMesh) { + return nullptr; + } + + if (pObjMesh->m_Faces.empty()) { + return nullptr; + } + + std::unique_ptr<aiMesh> pMesh(new aiMesh); + if (!pObjMesh->m_name.empty()) { + pMesh->mName.Set(pObjMesh->m_name); + } + + for (size_t index = 0; index < pObjMesh->m_Faces.size(); index++) { + ObjFile::Face *const inp = pObjMesh->m_Faces[index]; + ai_assert(nullptr != inp); + + if (inp->m_PrimitiveType == aiPrimitiveType_LINE) { + pMesh->mNumFaces += static_cast<unsigned int>(inp->m_vertices.size() - 1); + pMesh->mPrimitiveTypes |= aiPrimitiveType_LINE; + } else if (inp->m_PrimitiveType == aiPrimitiveType_POINT) { + pMesh->mNumFaces += static_cast<unsigned int>(inp->m_vertices.size()); + pMesh->mPrimitiveTypes |= aiPrimitiveType_POINT; + } else { + ++pMesh->mNumFaces; + if (inp->m_vertices.size() > 3) { + pMesh->mPrimitiveTypes |= aiPrimitiveType_POLYGON; + } else { + pMesh->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE; + } + } + } + + unsigned int uiIdxCount(0u); + if (pMesh->mNumFaces > 0) { + pMesh->mFaces = new aiFace[pMesh->mNumFaces]; + if (pObjMesh->m_uiMaterialIndex != ObjFile::Mesh::NoMaterial) { + pMesh->mMaterialIndex = pObjMesh->m_uiMaterialIndex; + } + + unsigned int outIndex(0); + + // Copy all data from all stored meshes + for (auto &face : pObjMesh->m_Faces) { + ObjFile::Face *const inp = face; + if (inp->m_PrimitiveType == aiPrimitiveType_LINE) { + for (size_t i = 0; i < inp->m_vertices.size() - 1; ++i) { + aiFace &f = pMesh->mFaces[outIndex++]; + uiIdxCount += f.mNumIndices = 2; + f.mIndices = new unsigned int[2]; + } + continue; + } else if (inp->m_PrimitiveType == aiPrimitiveType_POINT) { + for (size_t i = 0; i < inp->m_vertices.size(); ++i) { + aiFace &f = pMesh->mFaces[outIndex++]; + uiIdxCount += f.mNumIndices = 1; + f.mIndices = new unsigned int[1]; + } + continue; + } + + aiFace *pFace = &pMesh->mFaces[outIndex++]; + const unsigned int uiNumIndices = (unsigned int)face->m_vertices.size(); + uiIdxCount += pFace->mNumIndices = (unsigned int)uiNumIndices; + if (pFace->mNumIndices > 0) { + pFace->mIndices = new unsigned int[uiNumIndices]; + } + } + } + + // Create mesh vertices + createVertexArray(pModel, pData, meshIndex, pMesh.get(), uiIdxCount); + + return pMesh.release(); +} + +// ------------------------------------------------------------------------------------------------ +// Creates a vertex array +void ObjFileImporter::createVertexArray(const ObjFile::Model *pModel, + const ObjFile::Object *pCurrentObject, + unsigned int uiMeshIndex, + aiMesh *pMesh, + unsigned int numIndices) { + // Checking preconditions + ai_assert(nullptr != pCurrentObject); + + // Break, if no faces are stored in object + if (pCurrentObject->m_Meshes.empty()) + return; + + // Get current mesh + ObjFile::Mesh *pObjMesh = pModel->m_Meshes[uiMeshIndex]; + if (nullptr == pObjMesh || pObjMesh->m_uiNumIndices < 1) { + return; + } + + // Copy vertices of this mesh instance + pMesh->mNumVertices = numIndices; + if (pMesh->mNumVertices == 0) { + throw DeadlyImportError("OBJ: no vertices"); + } else if (pMesh->mNumVertices > AI_MAX_VERTICES) { + throw DeadlyImportError("OBJ: Too many vertices"); + } + pMesh->mVertices = new aiVector3D[pMesh->mNumVertices]; + + // Allocate buffer for normal vectors + if (!pModel->m_Normals.empty() && pObjMesh->m_hasNormals) + pMesh->mNormals = new aiVector3D[pMesh->mNumVertices]; + + // Allocate buffer for vertex-color vectors + if (!pModel->m_VertexColors.empty()) + pMesh->mColors[0] = new aiColor4D[pMesh->mNumVertices]; + + // Allocate buffer for texture coordinates + if (!pModel->m_TextureCoord.empty() && pObjMesh->m_uiUVCoordinates[0]) { + pMesh->mNumUVComponents[0] = pModel->m_TextureCoordDim; + pMesh->mTextureCoords[0] = new aiVector3D[pMesh->mNumVertices]; + } + + // Copy vertices, normals and textures into aiMesh instance + bool normalsok = true, uvok = true; + unsigned int newIndex = 0, outIndex = 0; + for (auto sourceFace : pObjMesh->m_Faces) { + // Copy all index arrays + for (size_t vertexIndex = 0, outVertexIndex = 0; vertexIndex < sourceFace->m_vertices.size(); vertexIndex++) { + const unsigned int vertex = sourceFace->m_vertices.at(vertexIndex); + if (vertex >= pModel->m_Vertices.size()) { + throw DeadlyImportError("OBJ: vertex index out of range"); + } + + if (pMesh->mNumVertices <= newIndex) { + throw DeadlyImportError("OBJ: bad vertex index"); + } + + pMesh->mVertices[newIndex] = pModel->m_Vertices[vertex]; + + // Copy all normals + if (normalsok && !pModel->m_Normals.empty() && vertexIndex < sourceFace->m_normals.size()) { + const unsigned int normal = sourceFace->m_normals.at(vertexIndex); + if (normal >= pModel->m_Normals.size()) { + normalsok = false; + } else { + pMesh->mNormals[newIndex] = pModel->m_Normals[normal]; + } + } + + // Copy all vertex colors + if (vertex < pModel->m_VertexColors.size()) { + const aiVector3D &color = pModel->m_VertexColors[vertex]; + pMesh->mColors[0][newIndex] = aiColor4D(color.x, color.y, color.z, 1.0); + } + + // Copy all texture coordinates + if (uvok && !pModel->m_TextureCoord.empty() && vertexIndex < sourceFace->m_texturCoords.size()) { + const unsigned int tex = sourceFace->m_texturCoords.at(vertexIndex); + + if (tex >= pModel->m_TextureCoord.size()) { + uvok = false; + } else { + const aiVector3D &coord3d = pModel->m_TextureCoord[tex]; + pMesh->mTextureCoords[0][newIndex] = aiVector3D(coord3d.x, coord3d.y, coord3d.z); + } + } + + // Get destination face + aiFace *pDestFace = &pMesh->mFaces[outIndex]; + + const bool last = (vertexIndex == sourceFace->m_vertices.size() - 1); + if (sourceFace->m_PrimitiveType != aiPrimitiveType_LINE || !last) { + pDestFace->mIndices[outVertexIndex] = newIndex; + outVertexIndex++; + } + + if (sourceFace->m_PrimitiveType == aiPrimitiveType_POINT) { + outIndex++; + outVertexIndex = 0; + } else if (sourceFace->m_PrimitiveType == aiPrimitiveType_LINE) { + outVertexIndex = 0; + + if (!last) + outIndex++; + + if (vertexIndex) { + if (!last) { + pMesh->mVertices[newIndex + 1] = pMesh->mVertices[newIndex]; + if (!sourceFace->m_normals.empty() && !pModel->m_Normals.empty()) { + pMesh->mNormals[newIndex + 1] = pMesh->mNormals[newIndex]; + } + if (!pModel->m_TextureCoord.empty()) { + for (size_t i = 0; i < pMesh->GetNumUVChannels(); i++) { + pMesh->mTextureCoords[i][newIndex + 1] = pMesh->mTextureCoords[i][newIndex]; + } + } + ++newIndex; + } + + pDestFace[-1].mIndices[1] = newIndex; + } + } else if (last) { + outIndex++; + } + ++newIndex; + } + } + + if (!normalsok) { + delete[] pMesh->mNormals; + pMesh->mNormals = nullptr; + } + + if (!uvok) { + delete[] pMesh->mTextureCoords[0]; + pMesh->mTextureCoords[0] = nullptr; + } +} + +// ------------------------------------------------------------------------------------------------ +// Counts all stored meshes +void ObjFileImporter::countObjects(const std::vector<ObjFile::Object *> &rObjects, int &iNumMeshes) { + iNumMeshes = 0; + if (rObjects.empty()) + return; + + iNumMeshes += static_cast<unsigned int>(rObjects.size()); + for (auto object : rObjects) { + if (!object->m_SubObjects.empty()) { + countObjects(object->m_SubObjects, iNumMeshes); + } + } +} + +// ------------------------------------------------------------------------------------------------ +// Add clamp mode property to material if necessary +void ObjFileImporter::addTextureMappingModeProperty(aiMaterial *mat, aiTextureType type, int clampMode, int index) { + if (nullptr == mat) { + return; + } + + mat->AddProperty<int>(&clampMode, 1, AI_MATKEY_MAPPINGMODE_U(type, index)); + mat->AddProperty<int>(&clampMode, 1, AI_MATKEY_MAPPINGMODE_V(type, index)); +} + +// ------------------------------------------------------------------------------------------------ +// Creates the material +void ObjFileImporter::createMaterials(const ObjFile::Model *pModel, aiScene *pScene) { + if (nullptr == pScene) { + return; + } + + const unsigned int numMaterials = (unsigned int)pModel->m_MaterialLib.size(); + pScene->mNumMaterials = 0; + if (pModel->m_MaterialLib.empty()) { + ASSIMP_LOG_DEBUG("OBJ: no materials specified"); + return; + } + + pScene->mMaterials = new aiMaterial *[numMaterials]; + for (unsigned int matIndex = 0; matIndex < numMaterials; matIndex++) { + // Store material name + std::map<std::string, ObjFile::Material *>::const_iterator it; + it = pModel->m_MaterialMap.find(pModel->m_MaterialLib[matIndex]); + + // No material found, use the default material + if (pModel->m_MaterialMap.end() == it) + continue; + + aiMaterial *mat = new aiMaterial; + ObjFile::Material *pCurrentMaterial = (*it).second; + mat->AddProperty(&pCurrentMaterial->MaterialName, AI_MATKEY_NAME); + + // convert illumination model + int sm = 0; + switch (pCurrentMaterial->illumination_model) { + case 0: + sm = aiShadingMode_NoShading; + break; + case 1: + sm = aiShadingMode_Gouraud; + break; + case 2: + sm = aiShadingMode_Phong; + break; + default: + sm = aiShadingMode_Gouraud; + ASSIMP_LOG_ERROR("OBJ: unexpected illumination model (0-2 recognized)"); + } + + mat->AddProperty<int>(&sm, 1, AI_MATKEY_SHADING_MODEL); + + // Preserve the original illum value + mat->AddProperty<int>(&pCurrentMaterial->illumination_model, 1, AI_MATKEY_OBJ_ILLUM); + + // Adding material colors + mat->AddProperty(&pCurrentMaterial->ambient, 1, AI_MATKEY_COLOR_AMBIENT); + mat->AddProperty(&pCurrentMaterial->diffuse, 1, AI_MATKEY_COLOR_DIFFUSE); + mat->AddProperty(&pCurrentMaterial->specular, 1, AI_MATKEY_COLOR_SPECULAR); + mat->AddProperty(&pCurrentMaterial->emissive, 1, AI_MATKEY_COLOR_EMISSIVE); + mat->AddProperty(&pCurrentMaterial->shineness, 1, AI_MATKEY_SHININESS); + mat->AddProperty(&pCurrentMaterial->alpha, 1, AI_MATKEY_OPACITY); + mat->AddProperty(&pCurrentMaterial->transparent, 1, AI_MATKEY_COLOR_TRANSPARENT); + mat->AddProperty(&pCurrentMaterial->roughness, 1, AI_MATKEY_ROUGHNESS_FACTOR); + mat->AddProperty(&pCurrentMaterial->metallic, 1, AI_MATKEY_METALLIC_FACTOR); + mat->AddProperty(&pCurrentMaterial->sheen, 1, AI_MATKEY_SHEEN_COLOR_FACTOR); + mat->AddProperty(&pCurrentMaterial->clearcoat_thickness, 1, AI_MATKEY_CLEARCOAT_FACTOR); + mat->AddProperty(&pCurrentMaterial->clearcoat_roughness, 1, AI_MATKEY_CLEARCOAT_ROUGHNESS_FACTOR); + mat->AddProperty(&pCurrentMaterial->anisotropy, 1, AI_MATKEY_ANISOTROPY_FACTOR); + + // Adding refraction index + mat->AddProperty(&pCurrentMaterial->ior, 1, AI_MATKEY_REFRACTI); + + // Adding textures + const int uvwIndex = 0; + + if (0 != pCurrentMaterial->texture.length) { + mat->AddProperty(&pCurrentMaterial->texture, AI_MATKEY_TEXTURE_DIFFUSE(0)); + mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_DIFFUSE(0)); + if (pCurrentMaterial->clamp[ObjFile::Material::TextureDiffuseType]) { + addTextureMappingModeProperty(mat, aiTextureType_DIFFUSE); + } + } + + if (0 != pCurrentMaterial->textureAmbient.length) { + mat->AddProperty(&pCurrentMaterial->textureAmbient, AI_MATKEY_TEXTURE_AMBIENT(0)); + mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_AMBIENT(0)); + if (pCurrentMaterial->clamp[ObjFile::Material::TextureAmbientType]) { + addTextureMappingModeProperty(mat, aiTextureType_AMBIENT); + } + } + + if (0 != pCurrentMaterial->textureEmissive.length) { + mat->AddProperty(&pCurrentMaterial->textureEmissive, AI_MATKEY_TEXTURE_EMISSIVE(0)); + mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_EMISSIVE(0)); + } + + if (0 != pCurrentMaterial->textureSpecular.length) { + mat->AddProperty(&pCurrentMaterial->textureSpecular, AI_MATKEY_TEXTURE_SPECULAR(0)); + mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_SPECULAR(0)); + if (pCurrentMaterial->clamp[ObjFile::Material::TextureSpecularType]) { + addTextureMappingModeProperty(mat, aiTextureType_SPECULAR); + } + } + + if (0 != pCurrentMaterial->textureBump.length) { + mat->AddProperty(&pCurrentMaterial->textureBump, AI_MATKEY_TEXTURE_HEIGHT(0)); + mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_HEIGHT(0)); + if (pCurrentMaterial->bump_multiplier != 1.0) { + mat->AddProperty(&pCurrentMaterial->bump_multiplier, 1, AI_MATKEY_OBJ_BUMPMULT_HEIGHT(0)); + } + if (pCurrentMaterial->clamp[ObjFile::Material::TextureBumpType]) { + addTextureMappingModeProperty(mat, aiTextureType_HEIGHT); + } + } + + if (0 != pCurrentMaterial->textureNormal.length) { + mat->AddProperty(&pCurrentMaterial->textureNormal, AI_MATKEY_TEXTURE_NORMALS(0)); + mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_NORMALS(0)); + if (pCurrentMaterial->bump_multiplier != 1.0) { + mat->AddProperty(&pCurrentMaterial->bump_multiplier, 1, AI_MATKEY_OBJ_BUMPMULT_NORMALS(0)); + } + if (pCurrentMaterial->clamp[ObjFile::Material::TextureNormalType]) { + addTextureMappingModeProperty(mat, aiTextureType_NORMALS); + } + } + + if (0 != pCurrentMaterial->textureReflection[0].length) { + ObjFile::Material::TextureType type = 0 != pCurrentMaterial->textureReflection[1].length ? + ObjFile::Material::TextureReflectionCubeTopType : + ObjFile::Material::TextureReflectionSphereType; + + unsigned count = type == ObjFile::Material::TextureReflectionSphereType ? 1 : 6; + for (unsigned i = 0; i < count; i++) { + mat->AddProperty(&pCurrentMaterial->textureReflection[i], AI_MATKEY_TEXTURE_REFLECTION(i)); + mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_REFLECTION(i)); + + if (pCurrentMaterial->clamp[type]) + addTextureMappingModeProperty(mat, aiTextureType_REFLECTION, 1, i); + } + } + + if (0 != pCurrentMaterial->textureDisp.length) { + mat->AddProperty(&pCurrentMaterial->textureDisp, AI_MATKEY_TEXTURE_DISPLACEMENT(0)); + mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_DISPLACEMENT(0)); + if (pCurrentMaterial->clamp[ObjFile::Material::TextureDispType]) { + addTextureMappingModeProperty(mat, aiTextureType_DISPLACEMENT); + } + } + + if (0 != pCurrentMaterial->textureOpacity.length) { + mat->AddProperty(&pCurrentMaterial->textureOpacity, AI_MATKEY_TEXTURE_OPACITY(0)); + mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_OPACITY(0)); + if (pCurrentMaterial->clamp[ObjFile::Material::TextureOpacityType]) { + addTextureMappingModeProperty(mat, aiTextureType_OPACITY); + } + } + + if (0 != pCurrentMaterial->textureSpecularity.length) { + mat->AddProperty(&pCurrentMaterial->textureSpecularity, AI_MATKEY_TEXTURE_SHININESS(0)); + mat->AddProperty(&uvwIndex, 1, AI_MATKEY_UVWSRC_SHININESS(0)); + if (pCurrentMaterial->clamp[ObjFile::Material::TextureSpecularityType]) { + addTextureMappingModeProperty(mat, aiTextureType_SHININESS); + } + } + + if (0 != pCurrentMaterial->textureRoughness.length) { + mat->AddProperty(&pCurrentMaterial->textureRoughness, _AI_MATKEY_TEXTURE_BASE, aiTextureType_DIFFUSE_ROUGHNESS, 0); + mat->AddProperty(&uvwIndex, 1, _AI_MATKEY_UVWSRC_BASE, aiTextureType_DIFFUSE_ROUGHNESS, 0 ); + if (pCurrentMaterial->clamp[ObjFile::Material::TextureRoughnessType]) { + addTextureMappingModeProperty(mat, aiTextureType_DIFFUSE_ROUGHNESS); + } + } + + if (0 != pCurrentMaterial->textureMetallic.length) { + mat->AddProperty(&pCurrentMaterial->textureMetallic, _AI_MATKEY_TEXTURE_BASE, aiTextureType_METALNESS, 0); + mat->AddProperty(&uvwIndex, 1, _AI_MATKEY_UVWSRC_BASE, aiTextureType_METALNESS, 0 ); + if (pCurrentMaterial->clamp[ObjFile::Material::TextureMetallicType]) { + addTextureMappingModeProperty(mat, aiTextureType_METALNESS); + } + } + + if (0 != pCurrentMaterial->textureSheen.length) { + mat->AddProperty(&pCurrentMaterial->textureSheen, _AI_MATKEY_TEXTURE_BASE, aiTextureType_SHEEN, 0); + mat->AddProperty(&uvwIndex, 1, _AI_MATKEY_UVWSRC_BASE, aiTextureType_SHEEN, 0 ); + if (pCurrentMaterial->clamp[ObjFile::Material::TextureSheenType]) { + addTextureMappingModeProperty(mat, aiTextureType_SHEEN); + } + } + + if (0 != pCurrentMaterial->textureRMA.length) { + // NOTE: glTF importer places Rough/Metal/AO texture in Unknown so doing the same here for consistency. + mat->AddProperty(&pCurrentMaterial->textureRMA, _AI_MATKEY_TEXTURE_BASE, aiTextureType_UNKNOWN, 0); + mat->AddProperty(&uvwIndex, 1, _AI_MATKEY_UVWSRC_BASE, aiTextureType_UNKNOWN, 0 ); + if (pCurrentMaterial->clamp[ObjFile::Material::TextureRMAType]) { + addTextureMappingModeProperty(mat, aiTextureType_UNKNOWN); + } + } + + // Store material property info in material array in scene + pScene->mMaterials[pScene->mNumMaterials] = mat; + pScene->mNumMaterials++; + } + + // Test number of created materials. + ai_assert(pScene->mNumMaterials == numMaterials); +} + +// ------------------------------------------------------------------------------------------------ +// Appends this node to the parent node +void ObjFileImporter::appendChildToParentNode(aiNode *pParent, aiNode *pChild) { + // Checking preconditions + ai_assert(nullptr != pParent); + ai_assert(nullptr != pChild); + + // Assign parent to child + pChild->mParent = pParent; + + // Copy node instances into parent node + pParent->mNumChildren++; + pParent->mChildren[pParent->mNumChildren - 1] = pChild; +} + +// ------------------------------------------------------------------------------------------------ + +} // Namespace Assimp + +#endif // !! ASSIMP_BUILD_NO_OBJ_IMPORTER |