diff options
Diffstat (limited to 'src/mesh/assimp-master/code/AssetLib/MD3')
| -rw-r--r-- | src/mesh/assimp-master/code/AssetLib/MD3/MD3FileData.h | 314 | ||||
| -rw-r--r-- | src/mesh/assimp-master/code/AssetLib/MD3/MD3Loader.cpp | 1060 | ||||
| -rw-r--r-- | src/mesh/assimp-master/code/AssetLib/MD3/MD3Loader.h | 314 |
3 files changed, 0 insertions, 1688 deletions
diff --git a/src/mesh/assimp-master/code/AssetLib/MD3/MD3FileData.h b/src/mesh/assimp-master/code/AssetLib/MD3/MD3FileData.h deleted file mode 100644 index 01475e6..0000000 --- a/src/mesh/assimp-master/code/AssetLib/MD3/MD3FileData.h +++ /dev/null @@ -1,314 +0,0 @@ -/* -Open Asset Import Library (assimp) ----------------------------------------------------------------------- - -Copyright (c) 2006-2022, 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 Md3FileData.h - * - * @brief Defines helper data structures for importing MD3 files. - * http://linux.ucla.edu/~phaethon/q3/formats/md3format.html - */ -#ifndef AI_MD3FILEHELPER_H_INC -#define AI_MD3FILEHELPER_H_INC - -#include <string> -#include <vector> -#include <sstream> -#include <stdint.h> - -#include <assimp/types.h> -#include <assimp/mesh.h> -#include <assimp/anim.h> - -#include <assimp/Compiler/pushpack1.h> - -namespace Assimp { -namespace MD3 { - -// to make it easier for us, we test the magic word against both "endianesses" -#define AI_MD3_MAGIC_NUMBER_BE AI_MAKE_MAGIC("IDP3") -#define AI_MD3_MAGIC_NUMBER_LE AI_MAKE_MAGIC("3PDI") - -// common limitations -#define AI_MD3_VERSION 15 -#define AI_MD3_MAXQPATH 64 -#define AI_MD3_MAXFRAME 16 -#define AI_MD3_MAX_FRAMES 1024 -#define AI_MD3_MAX_TAGS 16 -#define AI_MD3_MAX_SURFACES 32 -#define AI_MD3_MAX_SHADERS 256 -#define AI_MD3_MAX_VERTS 4096 -#define AI_MD3_MAX_TRIANGLES 8192 - -// master scale factor for all vertices in a MD3 model -#define AI_MD3_XYZ_SCALE (1.0f/64.0f) - -// ------------------------------------------------------------------------------- -/** @brief Data structure for the MD3 main header - */ -struct Header -{ - //! magic number - uint32_t IDENT; - - //! file format version - uint32_t VERSION; - - //! original name in .pak archive - char NAME[ AI_MD3_MAXQPATH ]; - - //! unknown - int32_t FLAGS; - - //! number of frames in the file - uint32_t NUM_FRAMES; - - //! number of tags in the file - uint32_t NUM_TAGS; - - //! number of surfaces in the file - uint32_t NUM_SURFACES; - - //! number of skins in the file - uint32_t NUM_SKINS; - - //! offset of the first frame - uint32_t OFS_FRAMES; - - //! offset of the first tag - uint32_t OFS_TAGS; - - //! offset of the first surface - uint32_t OFS_SURFACES; - - //! end of file - uint32_t OFS_EOF; -} PACK_STRUCT; - - -// ------------------------------------------------------------------------------- -/** @brief Data structure for the frame header - */ -struct Frame -{ - //! minimum bounds - aiVector3D min; - - //! maximum bounds - aiVector3D max; - - //! local origin for this frame - aiVector3D origin; - - //! radius of bounding sphere - ai_real radius; - - //! name of frame - char name[ AI_MD3_MAXFRAME ]; - -} /* PACK_STRUCT */; - - -// ------------------------------------------------------------------------------- -/** - * @brief Data structure for the tag header - */ -struct Tag { - //! name of the tag - char NAME[ AI_MD3_MAXQPATH ]; - - //! Local tag origin and orientation - aiVector3D origin; - ai_real orientation[3][3]; - -} /* PACK_STRUCT */; - - -// ------------------------------------------------------------------------------- -/** @brief Data structure for the surface header - */ -struct Surface { - //! magic number - int32_t IDENT; - - //! original name of the surface - char NAME[ AI_MD3_MAXQPATH ]; - - //! unknown - int32_t FLAGS; - - //! number of frames in the surface - uint32_t NUM_FRAMES; - - //! number of shaders in the surface - uint32_t NUM_SHADER; - - //! number of vertices in the surface - uint32_t NUM_VERTICES; - - //! number of triangles in the surface - uint32_t NUM_TRIANGLES; - - //! offset to the triangle data - uint32_t OFS_TRIANGLES; - - //! offset to the shader data - uint32_t OFS_SHADERS; - - //! offset to the texture coordinate data - uint32_t OFS_ST; - - //! offset to the vertex/normal data - uint32_t OFS_XYZNORMAL; - - //! offset to the end of the Surface object - int32_t OFS_END; -} /*PACK_STRUCT*/; - -// ------------------------------------------------------------------------------- -/** @brief Data structure for a shader defined in there - */ -struct Shader { - //! filename of the shader - char NAME[ AI_MD3_MAXQPATH ]; - - //! index of the shader - uint32_t SHADER_INDEX; -} /*PACK_STRUCT*/; - - -// ------------------------------------------------------------------------------- -/** @brief Data structure for a triangle - */ -struct Triangle -{ - //! triangle indices - uint32_t INDEXES[3]; -} /*PACK_STRUCT*/; - - -// ------------------------------------------------------------------------------- -/** @brief Data structure for an UV coord - */ -struct TexCoord -{ - //! UV coordinates - ai_real U,V; -} /*PACK_STRUCT*/; - - -// ------------------------------------------------------------------------------- -/** @brief Data structure for a vertex - */ -struct Vertex -{ - //! X/Y/Z coordinates - int16_t X,Y,Z; - - //! encoded normal vector - uint16_t NORMAL; -} /*PACK_STRUCT*/; - -#include <assimp/Compiler/poppack1.h> - -// ------------------------------------------------------------------------------- -/** @brief Unpack a Q3 16 bit vector to its full float3 representation - * - * @param p_iNormal Input normal vector in latitude/longitude form - * @param p_afOut Pointer to an array of three floats to receive the result - * - * @note This has been taken from q3 source (misc_model.c) - */ -inline void LatLngNormalToVec3(uint16_t p_iNormal, ai_real* p_afOut) -{ - ai_real lat = (ai_real)(( p_iNormal >> 8u ) & 0xff); - ai_real lng = (ai_real)(( p_iNormal & 0xff )); - const ai_real invVal( ai_real( 1.0 ) / ai_real( 128.0 ) ); - lat *= ai_real( 3.141926 ) * invVal; - lng *= ai_real( 3.141926 ) * invVal; - - p_afOut[ 0 ] = std::cos(lat) * std::sin(lng); - p_afOut[ 1 ] = std::sin(lat) * std::sin(lng); - p_afOut[ 2 ] = std::cos(lng); -} - - -// ------------------------------------------------------------------------------- -/** @brief Pack a Q3 normal into 16bit latitude/longitude representation - * @param p_vIn Input vector - * @param p_iOut Output normal - * - * @note This has been taken from q3 source (mathlib.c) - */ -inline void Vec3NormalToLatLng( const aiVector3D& p_vIn, uint16_t& p_iOut ) -{ - // check for singularities - if ( 0.0f == p_vIn[0] && 0.0f == p_vIn[1] ) - { - if ( p_vIn[2] > 0.0f ) - { - ((unsigned char*)&p_iOut)[0] = 0; - ((unsigned char*)&p_iOut)[1] = 0; // lat = 0, long = 0 - } - else - { - ((unsigned char*)&p_iOut)[0] = 128; - ((unsigned char*)&p_iOut)[1] = 0; // lat = 0, long = 128 - } - } - else - { - int a, b; - - a = int(57.2957795f * ( std::atan2( p_vIn[1], p_vIn[0] ) ) * (255.0f / 360.0f )); - a &= 0xff; - - b = int(57.2957795f * ( std::acos( p_vIn[2] ) ) * ( 255.0f / 360.0f )); - b &= 0xff; - - ((unsigned char*)&p_iOut)[0] = (unsigned char) b; // longitude - ((unsigned char*)&p_iOut)[1] = (unsigned char) a; // latitude - } -} - -} // Namespace MD3 -} // Namespace Assimp - -#endif // !! AI_MD3FILEHELPER_H_INC diff --git a/src/mesh/assimp-master/code/AssetLib/MD3/MD3Loader.cpp b/src/mesh/assimp-master/code/AssetLib/MD3/MD3Loader.cpp deleted file mode 100644 index 6120bd8..0000000 --- a/src/mesh/assimp-master/code/AssetLib/MD3/MD3Loader.cpp +++ /dev/null @@ -1,1060 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (assimp) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2022, 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 <assimp/GenericProperty.h> -#include <assimp/ParsingUtils.h> -#include <assimp/RemoveComments.h> -#include <assimp/SceneCombiner.h> -#include <assimp/importerdesc.h> -#include <assimp/material.h> -#include <assimp/scene.h> -#include <assimp/DefaultLogger.hpp> -#include <assimp/IOSystem.hpp> - -#include <cctype> -#include <memory> - -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<IOStream> 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 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 = 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)) { // render face's backside, does not function in Q3 engine (bug) - curData->cull = Q3Shader::CULL_CCW; - } else if (!ASSIMP_strincmp(buff, "front", 5)) { // is not valid keyword in Q3, but occurs in shaders - curData->cull = Q3Shader::CULL_CW; - } else if (!ASSIMP_strincmp(buff, "none", 4) || !ASSIMP_strincmp(buff, "twosided", 8) || !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<IOStream> 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<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 &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<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 { - static const uint32_t tokens[] = { AI_MD3_MAGIC_NUMBER_LE }; - return CheckMagicToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens)); -} - -// ------------------------------------------------------------------------------------------------ -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<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_LOAD_SHADERS - configLoadShaders = (pImp->GetPropertyBool(AI_CONFIG_IMPORT_MD3_LOAD_SHADERS, true)); - - // 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()) { - const char sep = mIOHandler->getOsSeparator(); - if (!Q3Shader::LoadShader(fill, path + ".." + sep + ".." + sep + ".." + sep + "scripts" + sep + model_file + ".shader", mIOHandler)) { - Q3Shader::LoadShader(fill, path + ".." + sep + ".." + sep + ".." + sep + "scripts" + sep + 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<AttachmentInfo> 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("<MD3_Player>"); - - // ... 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<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 = static_cast<char>(tolower(static_cast<unsigned char>(*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() == 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<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; - if (configLoadShaders){ - 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 = nullptr; - - // 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(); - ASSIMP_LOG_VERBOSE_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) { - if (configLoadShaders){ - ConvertPath(texture_name, header_name, convertedPath); - } - else{ - convertedPath = texture_name; - } - } - - 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<Q3Shader::ShaderDataBlock>::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<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 { - 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 normally, unless shader is backfacing - if (!(shader && shader->cull == Q3Shader::CULL_CCW)) { - 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) { - ASSIMP_LOG_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 diff --git a/src/mesh/assimp-master/code/AssetLib/MD3/MD3Loader.h b/src/mesh/assimp-master/code/AssetLib/MD3/MD3Loader.h deleted file mode 100644 index d911bb1..0000000 --- a/src/mesh/assimp-master/code/AssetLib/MD3/MD3Loader.h +++ /dev/null @@ -1,314 +0,0 @@ -/* -Open Asset Import Library (assimp) ----------------------------------------------------------------------- - -Copyright (c) 2006-2022, 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.h - * @brief Declaration of the .MD3 importer class. - */ -#ifndef AI_MD3LOADER_H_INCLUDED -#define AI_MD3LOADER_H_INCLUDED - -#include "MD3FileData.h" -#include <assimp/BaseImporter.h> -#include <assimp/ByteSwapper.h> -#include <assimp/StringComparison.h> -#include <assimp/types.h> - -#include <list> - -struct aiMaterial; - -namespace Assimp { - -using namespace MD3; -namespace Q3Shader { - -// --------------------------------------------------------------------------- -/** @brief Tiny utility data structure to hold the data of a .skin file - */ -struct SkinData { - //! A single entry in texture list - struct TextureEntry : public std::pair<std::string, std::string> { - // did we resolve this texture entry? - bool resolved; - - // for std::find() - bool operator==(const std::string &f) const { - return f == first; - } - }; - - //! List of textures - std::list<TextureEntry> textures; - - // rest is ignored for the moment -}; - -// --------------------------------------------------------------------------- -/** @brief Specifies cull modi for Quake shader files. - */ -enum ShaderCullMode { - CULL_NONE, - CULL_CW, - CULL_CCW -}; - -// --------------------------------------------------------------------------- -/** @brief Specifies alpha blend modi (src + dest) for Quake shader files - */ -enum BlendFunc { - BLEND_NONE, - BLEND_GL_ONE, - BLEND_GL_ZERO, - BLEND_GL_DST_COLOR, - BLEND_GL_ONE_MINUS_DST_COLOR, - BLEND_GL_SRC_ALPHA, - BLEND_GL_ONE_MINUS_SRC_ALPHA -}; - -// --------------------------------------------------------------------------- -/** @brief Specifies alpha test modi for Quake texture maps - */ -enum AlphaTestFunc { - AT_NONE, - AT_GT0, - AT_LT128, - AT_GE128 -}; - -// --------------------------------------------------------------------------- -/** @brief Tiny utility data structure to hold a .shader map data block - */ -struct ShaderMapBlock { - ShaderMapBlock() AI_NO_EXCEPT - : blend_src(BLEND_NONE), - blend_dest(BLEND_NONE), - alpha_test(AT_NONE) {} - - //! Name of referenced map - std::string name; - - //! Blend and alpha test settings for texture - BlendFunc blend_src, blend_dest; - AlphaTestFunc alpha_test; - - //! For std::find() - bool operator==(const std::string &o) const { - return !ASSIMP_stricmp(o, name); - } -}; - -// --------------------------------------------------------------------------- -/** @brief Tiny utility data structure to hold a .shader data block - */ -struct ShaderDataBlock { - ShaderDataBlock() AI_NO_EXCEPT - : cull(CULL_CW) {} - - //! Name of referenced data element - std::string name; - - //! Cull mode for the element - ShaderCullMode cull; - - //! Maps defined in the shader - std::list<ShaderMapBlock> maps; - - //! For std::find() - bool operator==(const std::string &o) const { - return !ASSIMP_stricmp(o, name); - } -}; - -// --------------------------------------------------------------------------- -/** @brief Tiny utility data structure to hold the data of a .shader file - */ -struct ShaderData { - //! Shader data blocks - std::list<ShaderDataBlock> blocks; -}; - -// --------------------------------------------------------------------------- -/** @brief Load a shader file - * - * Generally, parsing is error tolerant. There's no failure. - * @param fill Receives output data - * @param file File to be read. - * @param io IOSystem to be used for reading - * @return false if file is not accessible - */ -bool LoadShader(ShaderData &fill, const std::string &file, IOSystem *io); - -// --------------------------------------------------------------------------- -/** @brief Convert a Q3Shader to an aiMaterial - * - * @param[out] out Material structure to be filled. - * @param[in] shader Input shader - */ -void ConvertShaderToMaterial(aiMaterial *out, const ShaderDataBlock &shader); - -// --------------------------------------------------------------------------- -/** @brief Load a skin file - * - * Generally, parsing is error tolerant. There's no failure. - * @param fill Receives output data - * @param file File to be read. - * @param io IOSystem to be used for reading - * @return false if file is not accessible - */ -bool LoadSkin(SkinData &fill, const std::string &file, IOSystem *io); - -} // namespace Q3Shader - -// --------------------------------------------------------------------------- -/** @brief Importer class to load MD3 files -*/ -class MD3Importer : public BaseImporter { -public: - MD3Importer(); - ~MD3Importer() override; - - // ------------------------------------------------------------------- - /** Returns whether the class can handle the format of the given file. - * See BaseImporter::CanRead() for details. */ - bool CanRead(const std::string &pFile, IOSystem *pIOHandler, - bool checkSig) const override; - - // ------------------------------------------------------------------- - /** Called prior to ReadFile(). - * The function is a request to the importer to update its configuration - * basing on the Importer's configuration property list. - */ - void SetupProperties(const Importer *pImp) override; - -protected: - // ------------------------------------------------------------------- - /** Return importer meta information. - * See #BaseImporter::GetInfo for the details - */ - const aiImporterDesc *GetInfo() const override; - - // ------------------------------------------------------------------- - /** Imports the given file into the given scene structure. - * See BaseImporter::InternReadFile() for details - */ - void InternReadFile(const std::string &pFile, aiScene *pScene, - IOSystem *pIOHandler) override; - - // ------------------------------------------------------------------- - /** Validate offsets in the header - */ - void ValidateHeaderOffsets(); - void ValidateSurfaceHeaderOffsets(const MD3::Surface *pcSurfHeader); - - // ------------------------------------------------------------------- - /** Read a Q3 multipart file - * @return true if multi part has been processed - */ - bool ReadMultipartFile(); - - // ------------------------------------------------------------------- - /** Try to read the skin for a MD3 file - * @param fill Receives output information - */ - void ReadSkin(Q3Shader::SkinData &fill) const; - - // ------------------------------------------------------------------- - /** Try to read the shader for a MD3 file - * @param fill Receives output information - */ - void ReadShader(Q3Shader::ShaderData &fill) const; - - // ------------------------------------------------------------------- - /** Convert a texture path in a MD3 file to a proper value - * @param[in] texture_name Path to be converted - * @param[in] header_path Base path specified in MD3 header - * @param[out] out Receives the converted output string - */ - void ConvertPath(const char *texture_name, const char *header_path, - std::string &out) const; - -protected: - /** Configuration option: frame to be loaded */ - unsigned int configFrameID; - - /** Configuration option: process multi-part files */ - bool configHandleMP; - - /** Configuration option: name of skin file to be read */ - std::string configSkinFile; - - /** Configuration option: whether to load shaders */ - bool configLoadShaders; - - /** Configuration option: name or path of shader */ - std::string configShaderFile; - - /** Configuration option: speed flag was set? */ - bool configSpeedFlag; - - /** Header of the MD3 file */ - BE_NCONST MD3::Header *pcHeader; - - /** File buffer */ - BE_NCONST unsigned char *mBuffer; - - /** Size of the file, in bytes */ - unsigned int fileSize; - - /** Current file name */ - std::string mFile; - - /** Current base directory */ - std::string path; - - /** Pure file we're currently reading */ - std::string filename; - - /** Output scene to be filled */ - aiScene *mScene; - - /** IO system to be used to access the data*/ - IOSystem *mIOHandler; -}; - -} // end of namespace Assimp - -#endif // AI_3DSIMPORTER_H_INC |