| /* |
| --------------------------------------------------------------------------- |
| Open Asset Import Library (assimp) |
| --------------------------------------------------------------------------- |
| |
| Copyright (c) 2006-2017, 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 "MD3Loader.h" |
| #include <assimp/SceneCombiner.h> |
| #include "GenericProperty.h" |
| #include "RemoveComments.h" |
| #include "ParsingUtils.h" |
| #include "Importer.h" |
| #include <assimp/DefaultLogger.hpp> |
| #include <memory> |
| #include <assimp/IOSystem.hpp> |
| #include <assimp/material.h> |
| #include <assimp/scene.h> |
| #include <assimp/importerdesc.h> |
| #include <cctype> |
| |
| 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; |
| } |
| DefaultLogger::get()->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<IOStream> file( io->Open( pFile, "rt")); |
| if (!file.get()) |
| return false; // if we can't access the file, don't worry and return |
| |
| DefaultLogger::get()->info("Loading Quake3 shader file " + pFile); |
| |
| // read file in memory |
| const size_t s = file->FileSize(); |
| std::vector<char> _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 = NULL; |
| Q3Shader::ShaderMapBlock* curMap = NULL; |
| |
| // read line per line |
| for (;SkipSpacesAndLineEnd(&buff);SkipLine(&buff)) { |
| |
| if (*buff == '{') { |
| ++buff; |
| |
| // append to last section, if any |
| if (!curData) { |
| DefaultLogger::get()->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 = NULL; |
| break; |
| } |
| } |
| |
| } |
| else if (*buff == '}') { |
| ++buff; |
| curData = NULL; |
| 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 DefaultLogger::get()->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<IOStream> file( io->Open( pFile, "rt")); |
| if (!file.get()) |
| return false; // if we can't access the file, don't worry and return |
| |
| DefaultLogger::get()->info("Loading Quake3 skin file " + pFile); |
| |
| // read file in memory |
| const size_t s = file->FileSize(); |
| std::vector<char> _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& s = fill.textures.back(); |
| |
| s.first = ss; |
| s.second = GetNextToken(buff); |
| } |
| return true; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Convert Q3Shader to material |
| void Q3Shader::ConvertShaderToMaterial(aiMaterial* out, const ShaderDataBlock& shader) |
| { |
| ai_assert(NULL != 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< Q3Shader::ShaderMapBlock >::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) |
| DefaultLogger::get()->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) { |
| DefaultLogger::get()->warn("MD3: Quake III triangle limit exceeded"); |
| } |
| |
| if (pcSurf->NUM_SHADER > AI_MD3_MAX_SHADERS) { |
| DefaultLogger::get()->warn("MD3: Quake III shader limit exceeded"); |
| } |
| |
| if (pcSurf->NUM_VERTICES > AI_MD3_MAX_VERTS) { |
| DefaultLogger::get()->warn("MD3: Quake III vertex limit exceeded"); |
| } |
| |
| if (pcSurf->NUM_FRAMES > AI_MD3_MAX_FRAMES) { |
| DefaultLogger::get()->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<unsigned int>(-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 = NULL; |
| aiScene* scene_lower = NULL; |
| aiScene* scene_head = NULL; |
| std::string failure; |
| |
| aiNode* tag_torso, *tag_head; |
| std::vector<AttachmentInfo> attach; |
| |
| DefaultLogger::get()->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("<MD3_Player>"); |
| |
| // ... and get them. We need all of them. |
| scene_lower = batch.GetImport(_lower); |
| if (!scene_lower) { |
| DefaultLogger::get()->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) { |
| DefaultLogger::get()->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) { |
| DefaultLogger::get()->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) { |
| DefaultLogger::get()->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) { |
| DefaultLogger::get()->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<unsigned int>(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 = tolower( *it); |
| |
| // Load multi-part model file, if necessary |
| if (configHandleMP) { |
| if (ReadMultipartFile()) |
| return; |
| } |
| |
| std::unique_ptr<IOStream> file( pIOHandler->Open( pFile)); |
| |
| // Check whether we can read from the file |
| if( file.get() == NULL) |
| 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<unsigned char> 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< Q3Shader::ShaderDataBlock >::iterator dit = shaders.blocks.begin(); dit != shaders.blocks.end(); ++dit) { |
| ConvertPath((*dit).name.c_str(),header_name,(*dit).name); |
| |
| for (std::list< Q3Shader::ShaderMapBlock >::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 = NULL; |
| |
| // Check whether we have a texture record for this surface in the .skin file |
| std::list< Q3Shader::SkinData::TextureEntry >::iterator it = std::find( |
| skins.textures.begin(), skins.textures.end(), pcSurfaces->NAME ); |
| |
| if (it != skins.textures.end()) { |
| texture_name = &*( _texture_name = (*it).second).begin(); |
| DefaultLogger::get()->debug("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 = NULL; |
| |
| // Now search the current shader for a record with this name ( |
| // excluding texture file extension) |
| if (!shaders.blocks.empty()) { |
| |
| std::string::size_type s = convertedPath.find_last_of('.'); |
| if (s == std::string::npos) |
| s = convertedPath.length(); |
| |
| const std::string without_ext = convertedPath.substr(0,s); |
| std::list< Q3Shader::ShaderDataBlock >::const_iterator dit = std::find(shaders.blocks.begin(),shaders.blocks.end(),without_ext); |
| if (dit != shaders.blocks.end()) { |
| // Hurra, wir haben einen. Tolle Sache. |
| shader = &*dit; |
| DefaultLogger::get()->info("Found shader record for " +without_ext ); |
| } |
| else DefaultLogger::get()->warn("Unable to find shader record for " +without_ext ); |
| } |
| |
| aiMaterial* pcHelper = new aiMaterial(); |
| |
| const int iMode = (int)aiShadingMode_Gouraud; |
| pcHelper->AddProperty<int>(&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<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_AMBIENT); |
| |
| clr.b = clr.g = clr.r = 1.0f; |
| pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_DIFFUSE); |
| pcHelper->AddProperty<aiColor3D>(&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 { |
| DefaultLogger::get()->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].U ); |
| } |
| 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< Q3Shader::SkinData::TextureEntry>::const_iterator it = skins.textures.begin();it != skins.textures.end(); ++it) { |
| if (!(*it).resolved) { |
| DefaultLogger::get()->error("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("<MD3Root>"); |
| 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 |
