1059 lines
42 KiB
C++
1059 lines
42 KiB
C++
/*
|
|
---------------------------------------------------------------------------
|
|
Open Asset Import Library (assimp)
|
|
---------------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2021, assimp team
|
|
|
|
|
|
|
|
All rights reserved.
|
|
|
|
Redistribution and use of this software in source and binary forms,
|
|
with or without modification, are permitted provided that the following
|
|
conditions are met:
|
|
|
|
* Redistributions of source code must retain the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer.
|
|
|
|
* Redistributions in binary form must reproduce the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer in the documentation and/or other
|
|
materials provided with the distribution.
|
|
|
|
* Neither the name of the assimp team, nor the names of its
|
|
contributors may be used to endorse or promote products
|
|
derived from this software without specific prior
|
|
written permission of the assimp team.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
---------------------------------------------------------------------------
|
|
*/
|
|
|
|
/** @file MD3Loader.cpp
|
|
* @brief Implementation of the MD3 importer class
|
|
*
|
|
* Sources:
|
|
* http://www.gamers.org/dEngine/quake3/UQ3S
|
|
* http://linux.ucla.edu/~phaethon/q3/formats/md3format.html
|
|
* http://www.heppler.com/shader/shader/
|
|
*/
|
|
|
|
#ifndef ASSIMP_BUILD_NO_MD3_IMPORTER
|
|
|
|
#include "AssetLib/MD3/MD3Loader.h"
|
|
#include "Common/Importer.h"
|
|
|
|
#include <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)) {
|
|
curData->cull = Q3Shader::CULL_CCW;
|
|
} else if (!ASSIMP_strincmp(buff, "front", 5)) {
|
|
curData->cull = Q3Shader::CULL_CW;
|
|
} else if (!ASSIMP_strincmp(buff, "none", 4) || !ASSIMP_strincmp(buff, "disable", 7)) {
|
|
curData->cull = Q3Shader::CULL_NONE;
|
|
} else {
|
|
ASSIMP_LOG_ERROR("Q3Shader: Unrecognized cull mode");
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// add new section
|
|
fill.blocks.push_back(Q3Shader::ShaderDataBlock());
|
|
curData = &fill.blocks.back();
|
|
|
|
// get the name of this section
|
|
curData->name = GetNextToken(buff);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Load a Quake 3 skin
|
|
bool Q3Shader::LoadSkin(SkinData &fill, const std::string &pFile, IOSystem *io) {
|
|
std::unique_ptr<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 {
|
|
const std::string extension = GetExtension(pFile);
|
|
if (extension == "md3")
|
|
return true;
|
|
|
|
// if check for extension is not enough, check for the magic tokens
|
|
if (!extension.length() || checkSig) {
|
|
uint32_t tokens[1];
|
|
tokens[0] = AI_MD3_MAGIC_NUMBER_LE;
|
|
return CheckMagicToken(pIOHandler, pFile, tokens, 1);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void MD3Importer::ValidateHeaderOffsets() {
|
|
// Check magic number
|
|
if (pcHeader->IDENT != AI_MD3_MAGIC_NUMBER_BE &&
|
|
pcHeader->IDENT != AI_MD3_MAGIC_NUMBER_LE)
|
|
throw DeadlyImportError("Invalid MD3 file: Magic bytes not found");
|
|
|
|
// Check file format version
|
|
if (pcHeader->VERSION > 15)
|
|
ASSIMP_LOG_WARN("Unsupported MD3 file version. Continuing happily ...");
|
|
|
|
// Check some offset values whether they are valid
|
|
if (!pcHeader->NUM_SURFACES)
|
|
throw DeadlyImportError("Invalid md3 file: NUM_SURFACES is 0");
|
|
|
|
if (pcHeader->OFS_FRAMES >= fileSize || pcHeader->OFS_SURFACES >= fileSize ||
|
|
pcHeader->OFS_EOF > fileSize) {
|
|
throw DeadlyImportError("Invalid MD3 header: some offsets are outside the file");
|
|
}
|
|
|
|
if (pcHeader->NUM_SURFACES > AI_MAX_ALLOC(MD3::Surface)) {
|
|
throw DeadlyImportError("Invalid MD3 header: too many surfaces, would overflow");
|
|
}
|
|
|
|
if (pcHeader->OFS_SURFACES + pcHeader->NUM_SURFACES * sizeof(MD3::Surface) >= fileSize) {
|
|
throw DeadlyImportError("Invalid MD3 header: some surfaces are outside the file");
|
|
}
|
|
|
|
if (pcHeader->NUM_FRAMES <= configFrameID)
|
|
throw DeadlyImportError("The requested frame is not existing the file");
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void MD3Importer::ValidateSurfaceHeaderOffsets(const MD3::Surface *pcSurf) {
|
|
// Calculate the relative offset of the surface
|
|
const int32_t ofs = int32_t((const unsigned char *)pcSurf - this->mBuffer);
|
|
|
|
// Check whether all data chunks are inside the valid range
|
|
if (pcSurf->OFS_TRIANGLES + ofs + pcSurf->NUM_TRIANGLES * sizeof(MD3::Triangle) > fileSize ||
|
|
pcSurf->OFS_SHADERS + ofs + pcSurf->NUM_SHADER * sizeof(MD3::Shader) > fileSize ||
|
|
pcSurf->OFS_ST + ofs + pcSurf->NUM_VERTICES * sizeof(MD3::TexCoord) > fileSize ||
|
|
pcSurf->OFS_XYZNORMAL + ofs + pcSurf->NUM_VERTICES * sizeof(MD3::Vertex) > fileSize) {
|
|
|
|
throw DeadlyImportError("Invalid MD3 surface header: some offsets are outside the file");
|
|
}
|
|
|
|
// Check whether all requirements for Q3 files are met. We don't
|
|
// care, but probably someone does.
|
|
if (pcSurf->NUM_TRIANGLES > AI_MD3_MAX_TRIANGLES) {
|
|
ASSIMP_LOG_WARN("MD3: Quake III triangle limit exceeded");
|
|
}
|
|
|
|
if (pcSurf->NUM_SHADER > AI_MD3_MAX_SHADERS) {
|
|
ASSIMP_LOG_WARN("MD3: Quake III shader limit exceeded");
|
|
}
|
|
|
|
if (pcSurf->NUM_VERTICES > AI_MD3_MAX_VERTS) {
|
|
ASSIMP_LOG_WARN("MD3: Quake III vertex limit exceeded");
|
|
}
|
|
|
|
if (pcSurf->NUM_FRAMES > AI_MD3_MAX_FRAMES) {
|
|
ASSIMP_LOG_WARN("MD3: Quake III frame limit exceeded");
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
const aiImporterDesc *MD3Importer::GetInfo() const {
|
|
return &desc;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Setup configuration properties
|
|
void MD3Importer::SetupProperties(const Importer *pImp) {
|
|
// The
|
|
// AI_CONFIG_IMPORT_MD3_KEYFRAME option overrides the
|
|
// AI_CONFIG_IMPORT_GLOBAL_KEYFRAME option.
|
|
configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MD3_KEYFRAME, -1);
|
|
if (static_cast<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 = 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;
|
|
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) {
|
|
ConvertPath(texture_name, header_name, convertedPath);
|
|
}
|
|
|
|
const Q3Shader::ShaderDataBlock *shader = nullptr;
|
|
|
|
// Now search the current shader for a record with this name (
|
|
// excluding texture file extension)
|
|
if (!shaders.blocks.empty()) {
|
|
std::string::size_type sh = convertedPath.find_last_of('.');
|
|
if (sh == std::string::npos) {
|
|
sh = convertedPath.length();
|
|
}
|
|
|
|
const std::string without_ext = convertedPath.substr(0, sh);
|
|
std::list<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 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) {
|
|
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
|