/* --------------------------------------------------------------------------- Open Asset Import Library (assimp) --------------------------------------------------------------------------- Copyright (c) 2006-2021, 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. --------------------------------------------------------------------------- */ /** @file MD3Loader.cpp * @brief Implementation of the MD3 importer class * * Sources: * http://www.gamers.org/dEngine/quake3/UQ3S * http://linux.ucla.edu/~phaethon/q3/formats/md3format.html * http://www.heppler.com/shader/shader/ */ #ifndef ASSIMP_BUILD_NO_MD3_IMPORTER #include "AssetLib/MD3/MD3Loader.h" #include "Common/Importer.h" #include #include #include #include #include #include #include #include #include #include #include using namespace Assimp; static const aiImporterDesc desc = { "Quake III Mesh Importer", "", "", "", aiImporterFlags_SupportBinaryFlavour, 0, 0, 0, 0, "md3" }; // ------------------------------------------------------------------------------------------------ // Convert a Q3 shader blend function to the appropriate enum value Q3Shader::BlendFunc StringToBlendFunc(const std::string &m) { if (m == "GL_ONE") { return Q3Shader::BLEND_GL_ONE; } if (m == "GL_ZERO") { return Q3Shader::BLEND_GL_ZERO; } if (m == "GL_SRC_ALPHA") { return Q3Shader::BLEND_GL_SRC_ALPHA; } if (m == "GL_ONE_MINUS_SRC_ALPHA") { return Q3Shader::BLEND_GL_ONE_MINUS_SRC_ALPHA; } if (m == "GL_ONE_MINUS_DST_COLOR") { return Q3Shader::BLEND_GL_ONE_MINUS_DST_COLOR; } ASSIMP_LOG_ERROR("Q3Shader: Unknown blend function: " + m); return Q3Shader::BLEND_NONE; } // ------------------------------------------------------------------------------------------------ // Load a Quake 3 shader bool Q3Shader::LoadShader(ShaderData &fill, const std::string &pFile, IOSystem *io) { std::unique_ptr file(io->Open(pFile, "rt")); if (!file.get()) return false; // if we can't access the file, don't worry and return ASSIMP_LOG_INFO_F("Loading Quake3 shader file ", pFile); // read file in memory const size_t s = file->FileSize(); std::vector _buff(s + 1); file->Read(&_buff[0], s, 1); _buff[s] = 0; // remove comments from it (C++ style) CommentRemover::RemoveLineComments("//", &_buff[0]); const char *buff = &_buff[0]; Q3Shader::ShaderDataBlock *curData = nullptr; Q3Shader::ShaderMapBlock *curMap = nullptr; // read line per line for (; SkipSpacesAndLineEnd(&buff); SkipLine(&buff)) { if (*buff == '{') { ++buff; // append to last section, if any if (!curData) { ASSIMP_LOG_ERROR("Q3Shader: Unexpected shader section token \'{\'"); return true; // still no failure, the file is there } // read this data section for (; SkipSpacesAndLineEnd(&buff); SkipLine(&buff)) { if (*buff == '{') { ++buff; // add new map section curData->maps.push_back(Q3Shader::ShaderMapBlock()); curMap = &curData->maps.back(); for (; SkipSpacesAndLineEnd(&buff); SkipLine(&buff)) { // 'map' - Specifies texture file name if (TokenMatchI(buff, "map", 3) || TokenMatchI(buff, "clampmap", 8)) { curMap->name = GetNextToken(buff); } // 'blendfunc' - Alpha blending mode else if (TokenMatchI(buff, "blendfunc", 9)) { const std::string blend_src = GetNextToken(buff); if (blend_src == "add") { curMap->blend_src = Q3Shader::BLEND_GL_ONE; curMap->blend_dest = Q3Shader::BLEND_GL_ONE; } else if (blend_src == "filter") { curMap->blend_src = Q3Shader::BLEND_GL_DST_COLOR; curMap->blend_dest = Q3Shader::BLEND_GL_ZERO; } else if (blend_src == "blend") { curMap->blend_src = Q3Shader::BLEND_GL_SRC_ALPHA; curMap->blend_dest = Q3Shader::BLEND_GL_ONE_MINUS_SRC_ALPHA; } else { curMap->blend_src = StringToBlendFunc(blend_src); curMap->blend_dest = StringToBlendFunc(GetNextToken(buff)); } } // 'alphafunc' - Alpha testing mode else if (TokenMatchI(buff, "alphafunc", 9)) { const std::string at = GetNextToken(buff); if (at == "GT0") { curMap->alpha_test = Q3Shader::AT_GT0; } else if (at == "LT128") { curMap->alpha_test = Q3Shader::AT_LT128; } else if (at == "GE128") { curMap->alpha_test = Q3Shader::AT_GE128; } } else if (*buff == '}') { ++buff; // close this map section curMap = nullptr; break; } } } else if (*buff == '}') { ++buff; curData = nullptr; break; } // 'cull' specifies culling behaviour for the model else if (TokenMatchI(buff, "cull", 4)) { SkipSpaces(&buff); if (!ASSIMP_strincmp(buff, "back", 4)) { curData->cull = Q3Shader::CULL_CCW; } else if (!ASSIMP_strincmp(buff, "front", 5)) { curData->cull = Q3Shader::CULL_CW; } else if (!ASSIMP_strincmp(buff, "none", 4) || !ASSIMP_strincmp(buff, "disable", 7)) { curData->cull = Q3Shader::CULL_NONE; } else { ASSIMP_LOG_ERROR("Q3Shader: Unrecognized cull mode"); } } } } else { // add new section fill.blocks.push_back(Q3Shader::ShaderDataBlock()); curData = &fill.blocks.back(); // get the name of this section curData->name = GetNextToken(buff); } } return true; } // ------------------------------------------------------------------------------------------------ // Load a Quake 3 skin bool Q3Shader::LoadSkin(SkinData &fill, const std::string &pFile, IOSystem *io) { std::unique_ptr file(io->Open(pFile, "rt")); if (!file.get()) return false; // if we can't access the file, don't worry and return ASSIMP_LOG_INFO("Loading Quake3 skin file " + pFile); // read file in memory const size_t s = file->FileSize(); std::vector _buff(s + 1); const char *buff = &_buff[0]; file->Read(&_buff[0], s, 1); _buff[s] = 0; // remove commas std::replace(_buff.begin(), _buff.end(), ',', ' '); // read token by token and fill output table for (; *buff;) { SkipSpacesAndLineEnd(&buff); // get first identifier std::string ss = GetNextToken(buff); // ignore tokens starting with tag_ if (!::strncmp(&ss[0], "tag_", std::min((size_t)4, ss.length()))) continue; fill.textures.push_back(SkinData::TextureEntry()); SkinData::TextureEntry &entry = fill.textures.back(); entry.first = ss; entry.second = GetNextToken(buff); } return true; } // ------------------------------------------------------------------------------------------------ // Convert Q3Shader to material void Q3Shader::ConvertShaderToMaterial(aiMaterial *out, const ShaderDataBlock &shader) { ai_assert(nullptr != out); /* IMPORTANT: This is not a real conversion. Actually we're just guessing and * hacking around to build an aiMaterial that looks nearly equal to the * original Quake 3 shader. We're missing some important features like * animatable material properties in our material system, but at least * multiple textures should be handled correctly. */ // Two-sided material? if (shader.cull == Q3Shader::CULL_NONE) { const int twosided = 1; out->AddProperty(&twosided, 1, AI_MATKEY_TWOSIDED); } unsigned int cur_emissive = 0, cur_diffuse = 0, cur_lm = 0; // Iterate through all textures for (std::list::const_iterator it = shader.maps.begin(); it != shader.maps.end(); ++it) { // CONVERSION BEHAVIOUR: // // // If the texture is additive // - if it is the first texture, assume additive blending for the whole material // - otherwise register it as emissive texture. // // If the texture is using standard blend (or if the blend mode is unknown) // - if first texture: assume default blending for material // - in any case: set it as diffuse texture // // If the texture is using 'filter' blending // - take as lightmap // // Textures with alpha funcs // - aiTextureFlags_UseAlpha is set (otherwise aiTextureFlags_NoAlpha is explicitly set) aiString s((*it).name); aiTextureType type; unsigned int index; if ((*it).blend_src == Q3Shader::BLEND_GL_ONE && (*it).blend_dest == Q3Shader::BLEND_GL_ONE) { if (it == shader.maps.begin()) { const int additive = aiBlendMode_Additive; out->AddProperty(&additive, 1, AI_MATKEY_BLEND_FUNC); index = cur_diffuse++; type = aiTextureType_DIFFUSE; } else { index = cur_emissive++; type = aiTextureType_EMISSIVE; } } else if ((*it).blend_src == Q3Shader::BLEND_GL_DST_COLOR && (*it).blend_dest == Q3Shader::BLEND_GL_ZERO) { index = cur_lm++; type = aiTextureType_LIGHTMAP; } else { const int blend = aiBlendMode_Default; out->AddProperty(&blend, 1, AI_MATKEY_BLEND_FUNC); index = cur_diffuse++; type = aiTextureType_DIFFUSE; } // setup texture out->AddProperty(&s, AI_MATKEY_TEXTURE(type, index)); // setup texture flags const int use_alpha = ((*it).alpha_test != Q3Shader::AT_NONE ? aiTextureFlags_UseAlpha : aiTextureFlags_IgnoreAlpha); out->AddProperty(&use_alpha, 1, AI_MATKEY_TEXFLAGS(type, index)); } // If at least one emissive texture was set, set the emissive base color to 1 to ensure // the texture is actually displayed. if (0 != cur_emissive) { aiColor3D one(1.f, 1.f, 1.f); out->AddProperty(&one, 1, AI_MATKEY_COLOR_EMISSIVE); } } // ------------------------------------------------------------------------------------------------ // Constructor to be privately used by Importer MD3Importer::MD3Importer() : configFrameID(0), configHandleMP(true), configSpeedFlag(), pcHeader(), mBuffer(), fileSize(), mScene(), mIOHandler() {} // ------------------------------------------------------------------------------------------------ // Destructor, private as well MD3Importer::~MD3Importer() {} // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. bool MD3Importer::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const { const std::string extension = GetExtension(pFile); if (extension == "md3") return true; // if check for extension is not enough, check for the magic tokens if (!extension.length() || checkSig) { uint32_t tokens[1]; tokens[0] = AI_MD3_MAGIC_NUMBER_LE; return CheckMagicToken(pIOHandler, pFile, tokens, 1); } return false; } // ------------------------------------------------------------------------------------------------ void MD3Importer::ValidateHeaderOffsets() { // Check magic number if (pcHeader->IDENT != AI_MD3_MAGIC_NUMBER_BE && pcHeader->IDENT != AI_MD3_MAGIC_NUMBER_LE) throw DeadlyImportError("Invalid MD3 file: Magic bytes not found"); // Check file format version if (pcHeader->VERSION > 15) ASSIMP_LOG_WARN("Unsupported MD3 file version. Continuing happily ..."); // Check some offset values whether they are valid if (!pcHeader->NUM_SURFACES) throw DeadlyImportError("Invalid md3 file: NUM_SURFACES is 0"); if (pcHeader->OFS_FRAMES >= fileSize || pcHeader->OFS_SURFACES >= fileSize || pcHeader->OFS_EOF > fileSize) { throw DeadlyImportError("Invalid MD3 header: some offsets are outside the file"); } if (pcHeader->NUM_SURFACES > AI_MAX_ALLOC(MD3::Surface)) { throw DeadlyImportError("Invalid MD3 header: too many surfaces, would overflow"); } if (pcHeader->OFS_SURFACES + pcHeader->NUM_SURFACES * sizeof(MD3::Surface) >= fileSize) { throw DeadlyImportError("Invalid MD3 header: some surfaces are outside the file"); } if (pcHeader->NUM_FRAMES <= configFrameID) throw DeadlyImportError("The requested frame is not existing the file"); } // ------------------------------------------------------------------------------------------------ void MD3Importer::ValidateSurfaceHeaderOffsets(const MD3::Surface *pcSurf) { // Calculate the relative offset of the surface const int32_t ofs = int32_t((const unsigned char *)pcSurf - this->mBuffer); // Check whether all data chunks are inside the valid range if (pcSurf->OFS_TRIANGLES + ofs + pcSurf->NUM_TRIANGLES * sizeof(MD3::Triangle) > fileSize || pcSurf->OFS_SHADERS + ofs + pcSurf->NUM_SHADER * sizeof(MD3::Shader) > fileSize || pcSurf->OFS_ST + ofs + pcSurf->NUM_VERTICES * sizeof(MD3::TexCoord) > fileSize || pcSurf->OFS_XYZNORMAL + ofs + pcSurf->NUM_VERTICES * sizeof(MD3::Vertex) > fileSize) { throw DeadlyImportError("Invalid MD3 surface header: some offsets are outside the file"); } // Check whether all requirements for Q3 files are met. We don't // care, but probably someone does. if (pcSurf->NUM_TRIANGLES > AI_MD3_MAX_TRIANGLES) { ASSIMP_LOG_WARN("MD3: Quake III triangle limit exceeded"); } if (pcSurf->NUM_SHADER > AI_MD3_MAX_SHADERS) { ASSIMP_LOG_WARN("MD3: Quake III shader limit exceeded"); } if (pcSurf->NUM_VERTICES > AI_MD3_MAX_VERTS) { ASSIMP_LOG_WARN("MD3: Quake III vertex limit exceeded"); } if (pcSurf->NUM_FRAMES > AI_MD3_MAX_FRAMES) { ASSIMP_LOG_WARN("MD3: Quake III frame limit exceeded"); } } // ------------------------------------------------------------------------------------------------ const aiImporterDesc *MD3Importer::GetInfo() const { return &desc; } // ------------------------------------------------------------------------------------------------ // Setup configuration properties void MD3Importer::SetupProperties(const Importer *pImp) { // The // AI_CONFIG_IMPORT_MD3_KEYFRAME option overrides the // AI_CONFIG_IMPORT_GLOBAL_KEYFRAME option. configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MD3_KEYFRAME, -1); if (static_cast(-1) == configFrameID) { configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME, 0); } // AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART configHandleMP = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART, 1)); // AI_CONFIG_IMPORT_MD3_SKIN_NAME configSkinFile = (pImp->GetPropertyString(AI_CONFIG_IMPORT_MD3_SKIN_NAME, "default")); // AI_CONFIG_IMPORT_MD3_SHADER_SRC configShaderFile = (pImp->GetPropertyString(AI_CONFIG_IMPORT_MD3_SHADER_SRC, "")); // AI_CONFIG_FAVOUR_SPEED configSpeedFlag = (0 != pImp->GetPropertyInteger(AI_CONFIG_FAVOUR_SPEED, 0)); } // ------------------------------------------------------------------------------------------------ // Try to read the skin for a MD3 file void MD3Importer::ReadSkin(Q3Shader::SkinData &fill) const { // skip any postfixes (e.g. lower_1.md3) std::string::size_type s = filename.find_last_of('_'); if (s == std::string::npos) { s = filename.find_last_of('.'); if (s == std::string::npos) { s = filename.size(); } } ai_assert(s != std::string::npos); const std::string skin_file = path + filename.substr(0, s) + "_" + configSkinFile + ".skin"; Q3Shader::LoadSkin(fill, skin_file, mIOHandler); } // ------------------------------------------------------------------------------------------------ // Try to read the shader for a MD3 file void MD3Importer::ReadShader(Q3Shader::ShaderData &fill) const { // Determine Q3 model name from given path const std::string::size_type s = path.find_last_of("\\/", path.length() - 2); const std::string model_file = path.substr(s + 1, path.length() - (s + 2)); // If no specific dir or file is given, use our default search behaviour if (!configShaderFile.length()) { if (!Q3Shader::LoadShader(fill, path + "..\\..\\..\\scripts\\" + model_file + ".shader", mIOHandler)) { Q3Shader::LoadShader(fill, path + "..\\..\\..\\scripts\\" + filename + ".shader", mIOHandler); } } else { // If the given string specifies a file, load this file. // Otherwise it's a directory. const std::string::size_type st = configShaderFile.find_last_of('.'); if (st == std::string::npos) { if (!Q3Shader::LoadShader(fill, configShaderFile + model_file + ".shader", mIOHandler)) { Q3Shader::LoadShader(fill, configShaderFile + filename + ".shader", mIOHandler); } } else { Q3Shader::LoadShader(fill, configShaderFile, mIOHandler); } } } // ------------------------------------------------------------------------------------------------ // Tiny helper to remove a single node from its parent' list void RemoveSingleNodeFromList(aiNode *nd) { if (!nd || nd->mNumChildren || !nd->mParent) return; aiNode *par = nd->mParent; for (unsigned int i = 0; i < par->mNumChildren; ++i) { if (par->mChildren[i] == nd) { --par->mNumChildren; for (; i < par->mNumChildren; ++i) { par->mChildren[i] = par->mChildren[i + 1]; } delete nd; break; } } } // ------------------------------------------------------------------------------------------------ // Read a multi-part Q3 player model bool MD3Importer::ReadMultipartFile() { // check whether the file name contains a common postfix, e.g lower_2.md3 std::string::size_type s = filename.find_last_of('_'), t = filename.find_last_of('.'); if (t == std::string::npos) t = filename.size(); if (s == std::string::npos) s = t; const std::string mod_filename = filename.substr(0, s); const std::string suffix = filename.substr(s, t - s); if (mod_filename == "lower" || mod_filename == "upper" || mod_filename == "head") { const std::string lower = path + "lower" + suffix + ".md3"; const std::string upper = path + "upper" + suffix + ".md3"; const std::string head = path + "head" + suffix + ".md3"; aiScene *scene_upper = nullptr; aiScene *scene_lower = nullptr; aiScene *scene_head = nullptr; std::string failure; aiNode *tag_torso, *tag_head; std::vector attach; ASSIMP_LOG_INFO("Multi part MD3 player model: lower, upper and head parts are joined"); // ensure we won't try to load ourselves recursively BatchLoader::PropertyMap props; SetGenericProperty(props.ints, AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART, 0); // now read these three files BatchLoader batch(mIOHandler); const unsigned int _lower = batch.AddLoadRequest(lower, 0, &props); const unsigned int _upper = batch.AddLoadRequest(upper, 0, &props); const unsigned int _head = batch.AddLoadRequest(head, 0, &props); batch.LoadAll(); // now construct a dummy scene to place these three parts in aiScene *master = new aiScene(); aiNode *nd = master->mRootNode = new aiNode(); nd->mName.Set(""); // ... and get them. We need all of them. scene_lower = batch.GetImport(_lower); if (!scene_lower) { ASSIMP_LOG_ERROR("M3D: Failed to read multi part model, lower.md3 fails to load"); failure = "lower"; goto error_cleanup; } scene_upper = batch.GetImport(_upper); if (!scene_upper) { ASSIMP_LOG_ERROR("M3D: Failed to read multi part model, upper.md3 fails to load"); failure = "upper"; goto error_cleanup; } scene_head = batch.GetImport(_head); if (!scene_head) { ASSIMP_LOG_ERROR("M3D: Failed to read multi part model, head.md3 fails to load"); failure = "head"; goto error_cleanup; } // build attachment infos. search for typical Q3 tags // original root scene_lower->mRootNode->mName.Set("lower"); attach.push_back(AttachmentInfo(scene_lower, nd)); // tag_torso tag_torso = scene_lower->mRootNode->FindNode("tag_torso"); if (!tag_torso) { ASSIMP_LOG_ERROR("M3D: Failed to find attachment tag for multi part model: tag_torso expected"); goto error_cleanup; } scene_upper->mRootNode->mName.Set("upper"); attach.push_back(AttachmentInfo(scene_upper, tag_torso)); // tag_head tag_head = scene_upper->mRootNode->FindNode("tag_head"); if (!tag_head) { ASSIMP_LOG_ERROR("M3D: Failed to find attachment tag for multi part model: tag_head expected"); goto error_cleanup; } scene_head->mRootNode->mName.Set("head"); attach.push_back(AttachmentInfo(scene_head, tag_head)); // Remove tag_head and tag_torso from all other model parts ... // this ensures (together with AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) // that tag_torso/tag_head is also the name of the (unique) output node RemoveSingleNodeFromList(scene_upper->mRootNode->FindNode("tag_torso")); RemoveSingleNodeFromList(scene_head->mRootNode->FindNode("tag_head")); // Undo the rotations which we applied to the coordinate systems. We're // working in global Quake space here scene_head->mRootNode->mTransformation = aiMatrix4x4(); scene_lower->mRootNode->mTransformation = aiMatrix4x4(); scene_upper->mRootNode->mTransformation = aiMatrix4x4(); // and merge the scenes SceneCombiner::MergeScenes(&mScene, master, attach, AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES | AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES | AI_INT_MERGE_SCENE_RESOLVE_CROSS_ATTACHMENTS | (!configSpeedFlag ? AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY : 0)); // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system mScene->mRootNode->mTransformation = aiMatrix4x4(1.f, 0.f, 0.f, 0.f, 0.f, 0.f, 1.f, 0.f, 0.f, -1.f, 0.f, 0.f, 0.f, 0.f, 0.f, 1.f); return true; error_cleanup: delete scene_upper; delete scene_lower; delete scene_head; delete master; if (failure == mod_filename) { throw DeadlyImportError("MD3: failure to read multipart host file"); } } return false; } // ------------------------------------------------------------------------------------------------ // Convert a MD3 path to a proper value void MD3Importer::ConvertPath(const char *texture_name, const char *header_name, std::string &out) const { // If the MD3's internal path itself and the given path are using // the same directory, remove it completely to get right output paths. const char *end1 = ::strrchr(header_name, '\\'); if (!end1) end1 = ::strrchr(header_name, '/'); const char *end2 = ::strrchr(texture_name, '\\'); if (!end2) end2 = ::strrchr(texture_name, '/'); // HACK: If the paths starts with "models", ignore the // next two hierarchy levels, it specifies just the model name. // Ignored by Q3, it might be not equal to the real model location. if (end2) { size_t len2; const size_t len1 = (size_t)(end1 - header_name); if (!ASSIMP_strincmp(texture_name, "models", 6) && (texture_name[6] == '/' || texture_name[6] == '\\')) { len2 = 6; // ignore the seventh - could be slash or backslash if (!header_name[0]) { // Use the file name only out = end2 + 1; return; } } else len2 = std::min(len1, (size_t)(end2 - texture_name)); if (!ASSIMP_strincmp(texture_name, header_name, static_cast(len2))) { // Use the file name only out = end2 + 1; return; } } // Use the full path out = texture_name; } // ------------------------------------------------------------------------------------------------ // Imports the given file into the given scene structure. void MD3Importer::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) { mFile = pFile; mScene = pScene; mIOHandler = pIOHandler; // get base path and file name // todo ... move to PathConverter std::string::size_type s = mFile.find_last_of("/\\"); if (s == std::string::npos) { s = 0; } else { ++s; } filename = mFile.substr(s), path = mFile.substr(0, s); for (std::string::iterator it = filename.begin(); it != filename.end(); ++it) { *it = static_cast(tolower(static_cast(*it))); } // Load multi-part model file, if necessary if (configHandleMP) { if (ReadMultipartFile()) return; } std::unique_ptr file(pIOHandler->Open(pFile)); // Check whether we can read from the file if (file.get() == nullptr) { throw DeadlyImportError("Failed to open MD3 file ", pFile, "."); } // Check whether the md3 file is large enough to contain the header fileSize = (unsigned int)file->FileSize(); if (fileSize < sizeof(MD3::Header)) throw DeadlyImportError("MD3 File is too small."); // Allocate storage and copy the contents of the file to a memory buffer std::vector mBuffer2(fileSize); file->Read(&mBuffer2[0], 1, fileSize); mBuffer = &mBuffer2[0]; pcHeader = (BE_NCONST MD3::Header *)mBuffer; // Ensure correct endianness #ifdef AI_BUILD_BIG_ENDIAN AI_SWAP4(pcHeader->VERSION); AI_SWAP4(pcHeader->FLAGS); AI_SWAP4(pcHeader->IDENT); AI_SWAP4(pcHeader->NUM_FRAMES); AI_SWAP4(pcHeader->NUM_SKINS); AI_SWAP4(pcHeader->NUM_SURFACES); AI_SWAP4(pcHeader->NUM_TAGS); AI_SWAP4(pcHeader->OFS_EOF); AI_SWAP4(pcHeader->OFS_FRAMES); AI_SWAP4(pcHeader->OFS_SURFACES); AI_SWAP4(pcHeader->OFS_TAGS); #endif // Validate the file header ValidateHeaderOffsets(); // Navigate to the list of surfaces BE_NCONST MD3::Surface *pcSurfaces = (BE_NCONST MD3::Surface *)(mBuffer + pcHeader->OFS_SURFACES); // Navigate to the list of tags BE_NCONST MD3::Tag *pcTags = (BE_NCONST MD3::Tag *)(mBuffer + pcHeader->OFS_TAGS); // Allocate output storage pScene->mNumMeshes = pcHeader->NUM_SURFACES; if (pcHeader->NUM_SURFACES == 0) { throw DeadlyImportError("MD3: No surfaces"); } else if (pcHeader->NUM_SURFACES > AI_MAX_ALLOC(aiMesh)) { // We allocate pointers but check against the size of aiMesh // since those pointers will eventually have to point to real objects throw DeadlyImportError("MD3: Too many surfaces, would run out of memory"); } pScene->mMeshes = new aiMesh *[pScene->mNumMeshes]; pScene->mNumMaterials = pcHeader->NUM_SURFACES; pScene->mMaterials = new aiMaterial *[pScene->mNumMeshes]; // Set arrays to zero to ensue proper destruction if an exception is raised ::memset(pScene->mMeshes, 0, pScene->mNumMeshes * sizeof(aiMesh *)); ::memset(pScene->mMaterials, 0, pScene->mNumMaterials * sizeof(aiMaterial *)); // Now read possible skins from .skin file Q3Shader::SkinData skins; ReadSkin(skins); // And check whether we can locate a shader file for this model Q3Shader::ShaderData shaders; ReadShader(shaders); // Adjust all texture paths in the shader const char *header_name = pcHeader->NAME; if (!shaders.blocks.empty()) { for (std::list::iterator dit = shaders.blocks.begin(); dit != shaders.blocks.end(); ++dit) { ConvertPath((*dit).name.c_str(), header_name, (*dit).name); for (std::list::iterator mit = (*dit).maps.begin(); mit != (*dit).maps.end(); ++mit) { ConvertPath((*mit).name.c_str(), header_name, (*mit).name); } } } // Read all surfaces from the file unsigned int iNum = pcHeader->NUM_SURFACES; unsigned int iNumMaterials = 0; while (iNum-- > 0) { // Ensure correct endianness #ifdef AI_BUILD_BIG_ENDIAN AI_SWAP4(pcSurfaces->FLAGS); AI_SWAP4(pcSurfaces->IDENT); AI_SWAP4(pcSurfaces->NUM_FRAMES); AI_SWAP4(pcSurfaces->NUM_SHADER); AI_SWAP4(pcSurfaces->NUM_TRIANGLES); AI_SWAP4(pcSurfaces->NUM_VERTICES); AI_SWAP4(pcSurfaces->OFS_END); AI_SWAP4(pcSurfaces->OFS_SHADERS); AI_SWAP4(pcSurfaces->OFS_ST); AI_SWAP4(pcSurfaces->OFS_TRIANGLES); AI_SWAP4(pcSurfaces->OFS_XYZNORMAL); #endif // Validate the surface header ValidateSurfaceHeaderOffsets(pcSurfaces); // Navigate to the vertex list of the surface BE_NCONST MD3::Vertex *pcVertices = (BE_NCONST MD3::Vertex *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_XYZNORMAL); // Navigate to the triangle list of the surface BE_NCONST MD3::Triangle *pcTriangles = (BE_NCONST MD3::Triangle *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_TRIANGLES); // Navigate to the texture coordinate list of the surface BE_NCONST MD3::TexCoord *pcUVs = (BE_NCONST MD3::TexCoord *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_ST); // Navigate to the shader list of the surface BE_NCONST MD3::Shader *pcShaders = (BE_NCONST MD3::Shader *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_SHADERS); // If the submesh is empty ignore it if (0 == pcSurfaces->NUM_VERTICES || 0 == pcSurfaces->NUM_TRIANGLES) { pcSurfaces = (BE_NCONST MD3::Surface *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_END); pScene->mNumMeshes--; continue; } // Allocate output mesh pScene->mMeshes[iNum] = new aiMesh(); aiMesh *pcMesh = pScene->mMeshes[iNum]; std::string _texture_name; const char *texture_name = nullptr; // Check whether we have a texture record for this surface in the .skin file std::list::iterator it = std::find( skins.textures.begin(), skins.textures.end(), pcSurfaces->NAME); if (it != skins.textures.end()) { texture_name = &*(_texture_name = (*it).second).begin(); ASSIMP_LOG_VERBOSE_DEBUG_F("MD3: Assigning skin texture ", (*it).second, " to surface ", pcSurfaces->NAME); (*it).resolved = true; // mark entry as resolved } // Get the first shader (= texture?) assigned to the surface if (!texture_name && pcSurfaces->NUM_SHADER) { texture_name = pcShaders->NAME; } std::string convertedPath; if (texture_name) { ConvertPath(texture_name, header_name, convertedPath); } const Q3Shader::ShaderDataBlock *shader = nullptr; // Now search the current shader for a record with this name ( // excluding texture file extension) if (!shaders.blocks.empty()) { std::string::size_type sh = convertedPath.find_last_of('.'); if (sh == std::string::npos) { sh = convertedPath.length(); } const std::string without_ext = convertedPath.substr(0, sh); std::list::const_iterator dit = std::find(shaders.blocks.begin(), shaders.blocks.end(), without_ext); if (dit != shaders.blocks.end()) { // We made it! shader = &*dit; ASSIMP_LOG_INFO("Found shader record for " + without_ext); } else { ASSIMP_LOG_WARN("Unable to find shader record for " + without_ext); } } aiMaterial *pcHelper = new aiMaterial(); const int iMode = (int)aiShadingMode_Gouraud; pcHelper->AddProperty(&iMode, 1, AI_MATKEY_SHADING_MODEL); // Add a small ambient color value - Quake 3 seems to have one aiColor3D clr; clr.b = clr.g = clr.r = 0.05f; pcHelper->AddProperty(&clr, 1, AI_MATKEY_COLOR_AMBIENT); clr.b = clr.g = clr.r = 1.0f; pcHelper->AddProperty(&clr, 1, AI_MATKEY_COLOR_DIFFUSE); pcHelper->AddProperty(&clr, 1, AI_MATKEY_COLOR_SPECULAR); // use surface name + skin_name as material name aiString name; name.Set("MD3_[" + configSkinFile + "][" + pcSurfaces->NAME + "]"); pcHelper->AddProperty(&name, AI_MATKEY_NAME); if (!shader) { // Setup dummy texture file name to ensure UV coordinates are kept during postprocessing aiString szString; if (convertedPath.length()) { szString.Set(convertedPath); } else { ASSIMP_LOG_WARN("Texture file name has zero length. Using default name"); szString.Set("dummy_texture.bmp"); } pcHelper->AddProperty(&szString, AI_MATKEY_TEXTURE_DIFFUSE(0)); // prevent transparency by default int no_alpha = aiTextureFlags_IgnoreAlpha; pcHelper->AddProperty(&no_alpha, 1, AI_MATKEY_TEXFLAGS_DIFFUSE(0)); } else { Q3Shader::ConvertShaderToMaterial(pcHelper, *shader); } pScene->mMaterials[iNumMaterials] = (aiMaterial *)pcHelper; pcMesh->mMaterialIndex = iNumMaterials++; // Ensure correct endianness #ifdef AI_BUILD_BIG_ENDIAN for (uint32_t i = 0; i < pcSurfaces->NUM_VERTICES; ++i) { AI_SWAP2(pcVertices[i].NORMAL); AI_SWAP2(pcVertices[i].X); AI_SWAP2(pcVertices[i].Y); AI_SWAP2(pcVertices[i].Z); AI_SWAP4(pcUVs[i].U); AI_SWAP4(pcUVs[i].V); } for (uint32_t i = 0; i < pcSurfaces->NUM_TRIANGLES; ++i) { AI_SWAP4(pcTriangles[i].INDEXES[0]); AI_SWAP4(pcTriangles[i].INDEXES[1]); AI_SWAP4(pcTriangles[i].INDEXES[2]); } #endif // Fill mesh information pcMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE; pcMesh->mNumVertices = pcSurfaces->NUM_TRIANGLES * 3; pcMesh->mNumFaces = pcSurfaces->NUM_TRIANGLES; pcMesh->mFaces = new aiFace[pcSurfaces->NUM_TRIANGLES]; pcMesh->mNormals = new aiVector3D[pcMesh->mNumVertices]; pcMesh->mVertices = new aiVector3D[pcMesh->mNumVertices]; pcMesh->mTextureCoords[0] = new aiVector3D[pcMesh->mNumVertices]; pcMesh->mNumUVComponents[0] = 2; // Fill in all triangles unsigned int iCurrent = 0; for (unsigned int i = 0; i < (unsigned int)pcSurfaces->NUM_TRIANGLES; ++i) { pcMesh->mFaces[i].mIndices = new unsigned int[3]; pcMesh->mFaces[i].mNumIndices = 3; //unsigned int iTemp = iCurrent; for (unsigned int c = 0; c < 3; ++c, ++iCurrent) { pcMesh->mFaces[i].mIndices[c] = iCurrent; // Read vertices aiVector3D &vec = pcMesh->mVertices[iCurrent]; uint32_t index = pcTriangles->INDEXES[c]; if (index >= pcSurfaces->NUM_VERTICES) { throw DeadlyImportError("MD3: Invalid vertex index"); } vec.x = pcVertices[index].X * AI_MD3_XYZ_SCALE; vec.y = pcVertices[index].Y * AI_MD3_XYZ_SCALE; vec.z = pcVertices[index].Z * AI_MD3_XYZ_SCALE; // Convert the normal vector to uncompressed float3 format aiVector3D &nor = pcMesh->mNormals[iCurrent]; LatLngNormalToVec3(pcVertices[index].NORMAL, (ai_real *)&nor); // Read texture coordinates pcMesh->mTextureCoords[0][iCurrent].x = pcUVs[index].U; pcMesh->mTextureCoords[0][iCurrent].y = 1.0f - pcUVs[index].V; } // Flip face order if necessary if (!shader || shader->cull == Q3Shader::CULL_CW) { std::swap(pcMesh->mFaces[i].mIndices[2], pcMesh->mFaces[i].mIndices[1]); } ++pcTriangles; } // Go to the next surface pcSurfaces = (BE_NCONST MD3::Surface *)(((unsigned char *)pcSurfaces) + pcSurfaces->OFS_END); } // For debugging purposes: check whether we found matches for all entries in the skins file if (!DefaultLogger::isNullLogger()) { for (std::list::const_iterator it = skins.textures.begin(); it != skins.textures.end(); ++it) { if (!(*it).resolved) { ASSIMP_LOG_ERROR_F("MD3: Failed to match skin ", (*it).first, " to surface ", (*it).second); } } } if (!pScene->mNumMeshes) { throw DeadlyImportError("MD3: File contains no valid mesh"); } pScene->mNumMaterials = iNumMaterials; // Now we need to generate an empty node graph pScene->mRootNode = new aiNode(""); pScene->mRootNode->mNumMeshes = pScene->mNumMeshes; pScene->mRootNode->mMeshes = new unsigned int[pScene->mNumMeshes]; // Attach tiny children for all tags if (pcHeader->NUM_TAGS) { pScene->mRootNode->mNumChildren = pcHeader->NUM_TAGS; pScene->mRootNode->mChildren = new aiNode *[pcHeader->NUM_TAGS]; for (unsigned int i = 0; i < pcHeader->NUM_TAGS; ++i, ++pcTags) { aiNode *nd = pScene->mRootNode->mChildren[i] = new aiNode(); nd->mName.Set((const char *)pcTags->NAME); nd->mParent = pScene->mRootNode; AI_SWAP4(pcTags->origin.x); AI_SWAP4(pcTags->origin.y); AI_SWAP4(pcTags->origin.z); // Copy local origin, again flip z,y nd->mTransformation.a4 = pcTags->origin.x; nd->mTransformation.b4 = pcTags->origin.y; nd->mTransformation.c4 = pcTags->origin.z; // Copy rest of transformation (need to transpose to match row-order matrix) for (unsigned int a = 0; a < 3; ++a) { for (unsigned int m = 0; m < 3; ++m) { nd->mTransformation[m][a] = pcTags->orientation[a][m]; AI_SWAP4(nd->mTransformation[m][a]); } } } } for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) pScene->mRootNode->mMeshes[i] = i; // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system pScene->mRootNode->mTransformation = aiMatrix4x4( 1.f, 0.f, 0.f, 0.f, 0.f, 0.f, 1.f, 0.f, 0.f, -1.f, 0.f, 0.f, 0.f, 0.f, 0.f, 1.f); } #endif // !! ASSIMP_BUILD_NO_MD3_IMPORTER