diff options
Diffstat (limited to 'src/mesh/assimp-master/code/AssetLib/Obj/ObjFileImporter.cpp')
| -rw-r--r-- | src/mesh/assimp-master/code/AssetLib/Obj/ObjFileImporter.cpp | 783 |
1 files changed, 0 insertions, 783 deletions
diff --git a/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileImporter.cpp b/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileImporter.cpp deleted file mode 100644 index 68fdb21..0000000 --- a/src/mesh/assimp-master/code/AssetLib/Obj/ObjFileImporter.cpp +++ /dev/null @@ -1,783 +0,0 @@ -/* ---------------------------------------------------------------------------- -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 |