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