2008-05-09 17:24:28 +00:00
|
|
|
|
/*
|
|
|
|
|
---------------------------------------------------------------------------
|
2008-05-22 10:20:31 +00:00
|
|
|
|
Open Asset Import Library (ASSIMP)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
Copyright (c) 2006-2008, ASSIMP Development 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 Development 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.
|
|
|
|
|
---------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
/** @file Implementation of the main parts of the MDL importer class */
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// internal headers
|
2008-05-09 17:24:28 +00:00
|
|
|
|
#include "MaterialSystem.h"
|
|
|
|
|
#include "MDLLoader.h"
|
|
|
|
|
#include "MDLDefaultColorMap.h"
|
2008-06-22 10:09:26 +00:00
|
|
|
|
#include "MD2FileData.h"
|
|
|
|
|
#include "qnan.h"
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// public ASSIMP headers
|
|
|
|
|
#include "../include/DefaultLogger.h"
|
2008-05-09 17:24:28 +00:00
|
|
|
|
#include "../include/IOStream.h"
|
|
|
|
|
#include "../include/IOSystem.h"
|
|
|
|
|
#include "../include/aiMesh.h"
|
|
|
|
|
#include "../include/aiScene.h"
|
|
|
|
|
#include "../include/aiAssert.h"
|
2008-08-06 23:01:38 +00:00
|
|
|
|
#include "../include/assimp.hpp"
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// boost headers
|
2008-05-09 17:24:28 +00:00
|
|
|
|
#include <boost/scoped_ptr.hpp>
|
|
|
|
|
|
|
|
|
|
using namespace Assimp;
|
|
|
|
|
|
|
|
|
|
extern float g_avNormals[162][3];
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// macros used by the MDL7 loader
|
|
|
|
|
|
|
|
|
|
#if (!defined _AI_MDL7_ACCESS)
|
|
|
|
|
# define _AI_MDL7_ACCESS(_data, _index, _limit, _type) \
|
|
|
|
|
(*((const _type*)(((const char*)_data) + _index * _limit)))
|
|
|
|
|
#endif
|
|
|
|
|
#if (!defined _AI_MDL7_ACCESS_PTR)
|
|
|
|
|
# define _AI_MDL7_ACCESS_PTR(_data, _index, _limit, _type) \
|
|
|
|
|
((const _type*)(((const char*)_data) + _index * _limit))
|
|
|
|
|
#endif
|
|
|
|
|
#if (!defined _AI_MDL7_ACCESS_VERT)
|
|
|
|
|
# define _AI_MDL7_ACCESS_VERT(_data, _index, _limit) \
|
|
|
|
|
_AI_MDL7_ACCESS(_data,_index,_limit,MDL::Vertex_MDL7)
|
|
|
|
|
#endif
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
|
// Constructor to be privately used by Importer
|
|
|
|
|
MDLImporter::MDLImporter()
|
|
|
|
|
{
|
|
|
|
|
// nothing to do here
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
|
// Destructor, private as well
|
|
|
|
|
MDLImporter::~MDLImporter()
|
|
|
|
|
{
|
|
|
|
|
// nothing to do here
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
|
// Returns whether the class can handle the format of the given file.
|
|
|
|
|
bool MDLImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler) const
|
|
|
|
|
{
|
|
|
|
|
// simple check of file extension is enough for the moment
|
|
|
|
|
std::string::size_type pos = pFile.find_last_of('.');
|
|
|
|
|
// no file extension - can't read
|
|
|
|
|
if( pos == std::string::npos)
|
|
|
|
|
return false;
|
|
|
|
|
std::string extension = pFile.substr( pos);
|
|
|
|
|
|
|
|
|
|
if (extension.length() < 4)return false;
|
|
|
|
|
if (extension[0] != '.')return false;
|
|
|
|
|
if (extension[1] != 'm' && extension[1] != 'M')return false;
|
|
|
|
|
if (extension[2] != 'd' && extension[2] != 'D')return false;
|
|
|
|
|
if (extension[3] != 'l' && extension[3] != 'L')return false;
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
|
// Imports the given file into the given scene structure.
|
|
|
|
|
void MDLImporter::InternReadFile(
|
|
|
|
|
const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler)
|
|
|
|
|
{
|
|
|
|
|
boost::scoped_ptr<IOStream> file( pIOHandler->Open( pFile));
|
|
|
|
|
|
|
|
|
|
// Check whether we can read from the file
|
|
|
|
|
if( file.get() == NULL)
|
|
|
|
|
{
|
|
|
|
|
throw new ImportErrorException( "Failed to open MDL file " + pFile + ".");
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-06 23:01:38 +00:00
|
|
|
|
// The AI_CONFIG_IMPORT_MDL_KEYFRAME option overrides the
|
|
|
|
|
// AI_CONFIG_IMPORT_GLOBAL_KEYFRAME option.
|
|
|
|
|
#if 0
|
|
|
|
|
if(0xffffffff == (this->configFrameID = this->mImporter->GetProperty(
|
|
|
|
|
AI_CONFIG_IMPORT_MDL_KEYFRAME,0xffffffff)))
|
|
|
|
|
{
|
|
|
|
|
this->configFrameID = this->mImporter->GetProperty(
|
|
|
|
|
AI_CONFIG_IMPORT_GLOBAL_KEYFRAME,0);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// this should work for all other types of MDL files, too ...
|
|
|
|
|
// the quake header is one of the smallest, afaik
|
|
|
|
|
this->iFileSize = (unsigned int)file->FileSize();
|
|
|
|
|
if( this->iFileSize < sizeof(MDL::Header))
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
throw new ImportErrorException( "MDL File is too small.");
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// allocate storage and copy the contents of the file to a memory buffer
|
|
|
|
|
this->pScene = pScene;
|
|
|
|
|
this->pIOHandler = pIOHandler;
|
2008-06-22 10:09:26 +00:00
|
|
|
|
this->mBuffer = new unsigned char[this->iFileSize+1];
|
|
|
|
|
file->Read( (void*)mBuffer, 1, this->iFileSize);
|
|
|
|
|
|
|
|
|
|
// append a binary zero to the end of the buffer.
|
|
|
|
|
// this is just for safety that string parsing routines
|
|
|
|
|
// find the end of the buffer ...
|
|
|
|
|
this->mBuffer[this->iFileSize] = '\0';
|
|
|
|
|
uint32_t iMagicWord = *((uint32_t*)this->mBuffer);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// determine the file subtype and call the appropriate member function
|
2008-06-22 10:09:26 +00:00
|
|
|
|
try {
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// Original Quake1 format
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (AI_MDL_MAGIC_NUMBER_BE == iMagicWord ||
|
|
|
|
|
AI_MDL_MAGIC_NUMBER_LE == iMagicWord)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-05-22 10:20:31 +00:00
|
|
|
|
DefaultLogger::get()->debug("MDL subtype: Quake 1, magic word is IDPO");
|
2008-06-22 10:09:26 +00:00
|
|
|
|
this->iGSFileVersion = 0;
|
|
|
|
|
this->InternReadFile_Quake1();
|
|
|
|
|
}
|
|
|
|
|
// GameStudio A<old> MDL2 format - used by some test models that come with 3DGS
|
|
|
|
|
else if (AI_MDL_MAGIC_NUMBER_BE_GS3 == iMagicWord ||
|
|
|
|
|
AI_MDL_MAGIC_NUMBER_LE_GS3 == iMagicWord)
|
|
|
|
|
{
|
|
|
|
|
DefaultLogger::get()->debug("MDL subtype: 3D GameStudio A2, magic word is MDL2");
|
|
|
|
|
this->iGSFileVersion = 2;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
this->InternReadFile_Quake1();
|
|
|
|
|
}
|
|
|
|
|
// GameStudio A4 MDL3 format
|
2008-06-22 10:09:26 +00:00
|
|
|
|
else if (AI_MDL_MAGIC_NUMBER_BE_GS4 == iMagicWord ||
|
|
|
|
|
AI_MDL_MAGIC_NUMBER_LE_GS4 == iMagicWord)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-05-22 10:20:31 +00:00
|
|
|
|
DefaultLogger::get()->debug("MDL subtype: 3D GameStudio A4, magic word is MDL3");
|
2008-05-09 17:24:28 +00:00
|
|
|
|
this->iGSFileVersion = 3;
|
2008-06-22 10:09:26 +00:00
|
|
|
|
this->InternReadFile_3DGS_MDL345();
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
// GameStudio A5+ MDL4 format
|
2008-06-22 10:09:26 +00:00
|
|
|
|
else if (AI_MDL_MAGIC_NUMBER_BE_GS5a == iMagicWord ||
|
|
|
|
|
AI_MDL_MAGIC_NUMBER_LE_GS5a == iMagicWord)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-05-22 10:20:31 +00:00
|
|
|
|
DefaultLogger::get()->debug("MDL subtype: 3D GameStudio A4, magic word is MDL4");
|
2008-05-09 17:24:28 +00:00
|
|
|
|
this->iGSFileVersion = 4;
|
2008-06-22 10:09:26 +00:00
|
|
|
|
this->InternReadFile_3DGS_MDL345();
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
// GameStudio A5+ MDL5 format
|
2008-06-22 10:09:26 +00:00
|
|
|
|
else if (AI_MDL_MAGIC_NUMBER_BE_GS5b == iMagicWord ||
|
|
|
|
|
AI_MDL_MAGIC_NUMBER_LE_GS5b == iMagicWord)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-05-22 10:20:31 +00:00
|
|
|
|
DefaultLogger::get()->debug("MDL subtype: 3D GameStudio A5, magic word is MDL5");
|
2008-05-09 17:24:28 +00:00
|
|
|
|
this->iGSFileVersion = 5;
|
2008-06-22 10:09:26 +00:00
|
|
|
|
this->InternReadFile_3DGS_MDL345();
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// GameStudio A6+ MDL6 format (not sure whether it is really existing ... )
|
|
|
|
|
else if (AI_MDL_MAGIC_NUMBER_BE_GS6 == iMagicWord ||
|
|
|
|
|
AI_MDL_MAGIC_NUMBER_LE_GS6 == iMagicWord)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-05-22 10:20:31 +00:00
|
|
|
|
DefaultLogger::get()->debug("MDL subtype: 3D GameStudio A6, magic word is MDL6");
|
2008-05-09 17:24:28 +00:00
|
|
|
|
this->iGSFileVersion = 6;
|
2008-06-22 10:09:26 +00:00
|
|
|
|
this->InternReadFile_3DGS_MDL345();
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
// GameStudio A7 MDL7 format
|
2008-06-22 10:09:26 +00:00
|
|
|
|
else if (AI_MDL_MAGIC_NUMBER_BE_GS7 == iMagicWord ||
|
|
|
|
|
AI_MDL_MAGIC_NUMBER_LE_GS7 == iMagicWord)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-05-22 10:20:31 +00:00
|
|
|
|
DefaultLogger::get()->debug("MDL subtype: 3D GameStudio A7, magic word is MDL7");
|
2008-05-09 17:24:28 +00:00
|
|
|
|
this->iGSFileVersion = 7;
|
2008-06-22 10:09:26 +00:00
|
|
|
|
this->InternReadFile_3DGS_MDL7();
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
2008-05-22 10:20:31 +00:00
|
|
|
|
// IDST/IDSQ Format (CS:S/HL<48>, etc ...)
|
2008-06-22 10:09:26 +00:00
|
|
|
|
else if (AI_MDL_MAGIC_NUMBER_BE_HL2a == iMagicWord ||
|
|
|
|
|
AI_MDL_MAGIC_NUMBER_LE_HL2a == iMagicWord ||
|
|
|
|
|
AI_MDL_MAGIC_NUMBER_BE_HL2b == iMagicWord ||
|
|
|
|
|
AI_MDL_MAGIC_NUMBER_LE_HL2b == iMagicWord)
|
2008-05-22 10:20:31 +00:00
|
|
|
|
{
|
|
|
|
|
DefaultLogger::get()->debug("MDL subtype: CS:S\\HL<EFBFBD>, magic word is IDST/IDSQ");
|
2008-06-22 10:09:26 +00:00
|
|
|
|
this->iGSFileVersion = 0;
|
2008-05-22 10:20:31 +00:00
|
|
|
|
this->InternReadFile_HL2();
|
|
|
|
|
}
|
2008-05-09 17:24:28 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// print the magic word to the logger
|
|
|
|
|
char szBuffer[5];
|
|
|
|
|
szBuffer[0] = ((char*)&iMagicWord)[0];
|
|
|
|
|
szBuffer[1] = ((char*)&iMagicWord)[1];
|
|
|
|
|
szBuffer[2] = ((char*)&iMagicWord)[2];
|
|
|
|
|
szBuffer[3] = ((char*)&iMagicWord)[3];
|
|
|
|
|
szBuffer[4] = '\0';
|
|
|
|
|
|
2008-05-09 17:24:28 +00:00
|
|
|
|
// we're definitely unable to load this file
|
|
|
|
|
throw new ImportErrorException( "Unknown MDL subformat " + pFile +
|
2008-06-22 10:09:26 +00:00
|
|
|
|
". Magic word (" + szBuffer + ") is not known");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
} catch (ImportErrorException* ex) {
|
|
|
|
|
delete[] this->mBuffer;
|
|
|
|
|
throw ex;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// delete the file buffer and cleanup
|
2008-05-09 17:24:28 +00:00
|
|
|
|
delete[] this->mBuffer;
|
2008-08-06 23:01:38 +00:00
|
|
|
|
AI_DEBUG_INVALIDATE_PTR(this->mBuffer);
|
|
|
|
|
AI_DEBUG_INVALIDATE_PTR(this->pIOHandler);
|
|
|
|
|
AI_DEBUG_INVALIDATE_PTR(this->pScene);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
2008-06-22 10:09:26 +00:00
|
|
|
|
void MDLImporter::SizeCheck(const void* szPos)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (!szPos || (const unsigned char*)szPos > this->mBuffer + this->iFileSize)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-08-06 23:01:38 +00:00
|
|
|
|
throw new ImportErrorException("Invalid MDL file. The file is too small "
|
2008-06-22 10:09:26 +00:00
|
|
|
|
"or contains invalid data.");
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
2008-06-22 10:09:26 +00:00
|
|
|
|
void MDLImporter::SizeCheck(const void* szPos, const char* szFile, unsigned int iLine)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (!szFile)return SizeCheck(szPos);
|
|
|
|
|
if (!szPos || (const unsigned char*)szPos > this->mBuffer + this->iFileSize)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// remove a directory if there is one
|
|
|
|
|
const char* szFilePtr = ::strrchr(szFile,'\\');
|
|
|
|
|
if (!szFilePtr)
|
|
|
|
|
{
|
|
|
|
|
if(!(szFilePtr = ::strrchr(szFile,'/')))szFilePtr = szFile;
|
|
|
|
|
}
|
|
|
|
|
if (szFilePtr)++szFilePtr;
|
|
|
|
|
|
|
|
|
|
char szBuffer[1024];
|
|
|
|
|
#if _MSC_VER >= 1400
|
|
|
|
|
::sprintf_s(szBuffer,
|
|
|
|
|
#else
|
|
|
|
|
::sprintf(szBuffer,
|
|
|
|
|
#endif
|
2008-08-06 23:01:38 +00:00
|
|
|
|
"Invalid MDL file. The file is too small "
|
2008-06-22 10:09:26 +00:00
|
|
|
|
"or contains invalid data (File: %s Line: %i)",szFilePtr,iLine);
|
|
|
|
|
|
|
|
|
|
throw new ImportErrorException(szBuffer);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
2008-06-22 10:09:26 +00:00
|
|
|
|
void MDLImporter::ValidateHeader_Quake1(const MDL::Header* pcHeader)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// some values may not be NULL
|
|
|
|
|
if (!pcHeader->num_frames)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
throw new ImportErrorException( "[Quake 1 MDL] There are no frames in the file");
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (!pcHeader->num_verts)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
throw new ImportErrorException( "[Quake 1 MDL] There are no vertices in the file");
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (!pcHeader->num_tris)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
throw new ImportErrorException( "[Quake 1 MDL] There are no triangles in the file");
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
2008-08-06 23:01:38 +00:00
|
|
|
|
// check whether the maxima are exceeded ...however, this applies for Quake 1 MDLs only
|
|
|
|
|
if (!this->iGSFileVersion)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-08-06 23:01:38 +00:00
|
|
|
|
if (pcHeader->num_verts > AI_MDL_MAX_VERTS)
|
|
|
|
|
{
|
|
|
|
|
DefaultLogger::get()->warn("Quake 1 MDL model has more than AI_MDL_MAX_VERTS vertices");
|
|
|
|
|
}
|
|
|
|
|
if (pcHeader->num_tris > AI_MDL_MAX_TRIANGLES)
|
|
|
|
|
{
|
|
|
|
|
DefaultLogger::get()->warn("Quake 1 MDL model has more than AI_MDL_MAX_TRIANGLES triangles");
|
|
|
|
|
}
|
|
|
|
|
if (pcHeader->num_frames > AI_MDL_MAX_FRAMES)
|
|
|
|
|
{
|
|
|
|
|
DefaultLogger::get()->warn("Quake 1 MDL model has more than AI_MDL_MAX_FRAMES frames");
|
|
|
|
|
}
|
|
|
|
|
// (this does not apply for 3DGS MDLs)
|
|
|
|
|
if (!this->iGSFileVersion && pcHeader->version != AI_MDL_VERSION)
|
|
|
|
|
{
|
|
|
|
|
DefaultLogger::get()->warn("Quake 1 MDL model has an unknown version: AI_MDL_VERSION (=6) is "
|
|
|
|
|
"the expected file format version");
|
|
|
|
|
}
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-08-06 23:01:38 +00:00
|
|
|
|
if (pcHeader->num_skins)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-08-06 23:01:38 +00:00
|
|
|
|
if(!pcHeader->skinwidth || !pcHeader->skinheight)
|
|
|
|
|
{
|
|
|
|
|
DefaultLogger::get()->warn("Skin width or height are 0. Division through "
|
|
|
|
|
"zero would occur ...");
|
|
|
|
|
}
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
|
void MDLImporter::InternReadFile_Quake1( )
|
|
|
|
|
{
|
|
|
|
|
ai_assert(NULL != pScene);
|
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
const MDL::Header* pcHeader = (const MDL::Header*)this->mBuffer;
|
|
|
|
|
ValidateHeader_Quake1(pcHeader);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// current cursor position in the file
|
2008-06-22 10:09:26 +00:00
|
|
|
|
const unsigned char* szCurrent = (const unsigned char*)(pcHeader+1);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// need to read all textures
|
2008-06-22 10:09:26 +00:00
|
|
|
|
for (unsigned int i = 0; i < (unsigned int)pcHeader->num_skins;++i)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
|
|
|
|
union{const MDL::Skin* pcSkin;const MDL::GroupSkin* pcGroupSkin;};
|
|
|
|
|
pcSkin = (const MDL::Skin*)szCurrent;
|
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
|
|
|
|
|
// Quake 1 groupskins
|
|
|
|
|
if (1 == pcSkin->group)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
|
|
|
|
// need to skip multiple images
|
|
|
|
|
const unsigned int iNumImages = (unsigned int)pcGroupSkin->nb;
|
|
|
|
|
szCurrent += sizeof(uint32_t) * 2;
|
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (0 != iNumImages)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (!i) {
|
|
|
|
|
// however, create only one output image (the first)
|
|
|
|
|
this->CreateTextureARGB8_3DGS_MDL3(szCurrent + iNumImages * sizeof(float));
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// go to the end of the skin section / the beginning of the next skin
|
|
|
|
|
szCurrent += pcHeader->skinheight * pcHeader->skinwidth +
|
|
|
|
|
sizeof(float) * iNumImages;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// 3DGS has a few files that are using other 3DGS like texture formats here
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
szCurrent += sizeof(uint32_t);
|
|
|
|
|
unsigned int iSkip = i ? 0xffffffff : 0;
|
|
|
|
|
this->CreateTexture_3DGS_MDL4(szCurrent,pcSkin->group,&iSkip);
|
|
|
|
|
szCurrent += iSkip;
|
|
|
|
|
}
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
// get a pointer to the texture coordinates
|
|
|
|
|
const MDL::TexCoord* pcTexCoords = (const MDL::TexCoord*)szCurrent;
|
2008-06-22 10:09:26 +00:00
|
|
|
|
szCurrent += sizeof(MDL::TexCoord) * pcHeader->num_verts;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// get a pointer to the triangles
|
|
|
|
|
const MDL::Triangle* pcTriangles = (const MDL::Triangle*)szCurrent;
|
2008-06-22 10:09:26 +00:00
|
|
|
|
szCurrent += sizeof(MDL::Triangle) * pcHeader->num_tris;
|
|
|
|
|
VALIDATE_FILE_SIZE(szCurrent);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// now get a pointer to the first frame in the file
|
|
|
|
|
const MDL::Frame* pcFrames = (const MDL::Frame*)szCurrent;
|
|
|
|
|
const MDL::SimpleFrame* pcFirstFrame;
|
|
|
|
|
|
|
|
|
|
if (0 == pcFrames->type)
|
|
|
|
|
{
|
|
|
|
|
// get address of single frame
|
|
|
|
|
pcFirstFrame = &pcFrames->frame;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
// get the first frame in the group
|
|
|
|
|
const MDL::GroupFrame* pcFrames2 = (const MDL::GroupFrame*)pcFrames;
|
|
|
|
|
pcFirstFrame = (const MDL::SimpleFrame*)(&pcFrames2->time + pcFrames->type);
|
|
|
|
|
}
|
|
|
|
|
const MDL::Vertex* pcVertices = (const MDL::Vertex*) ((pcFirstFrame->name) +
|
|
|
|
|
sizeof(pcFirstFrame->name));
|
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
VALIDATE_FILE_SIZE((const unsigned char*)(pcVertices + pcHeader->num_verts));
|
|
|
|
|
|
|
|
|
|
// setup materials
|
|
|
|
|
this->SetupMaterialProperties_3DGS_MDL5_Quake1();
|
|
|
|
|
|
|
|
|
|
// allocate enough storage to hold all vertices and triangles
|
|
|
|
|
aiMesh* pcMesh = new aiMesh();
|
|
|
|
|
|
|
|
|
|
pcMesh->mNumVertices = pcHeader->num_tris * 3;
|
|
|
|
|
pcMesh->mNumFaces = pcHeader->num_tris;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
pcMesh->mVertices = new aiVector3D[pcMesh->mNumVertices];
|
|
|
|
|
pcMesh->mTextureCoords[0] = new aiVector3D[pcMesh->mNumVertices];
|
|
|
|
|
pcMesh->mFaces = new aiFace[pcMesh->mNumFaces];
|
|
|
|
|
pcMesh->mNormals = new aiVector3D[pcMesh->mNumVertices];
|
|
|
|
|
pcMesh->mNumUVComponents[0] = 2;
|
|
|
|
|
|
|
|
|
|
// there won't be more than one mesh inside the file
|
|
|
|
|
pScene->mRootNode = new aiNode();
|
|
|
|
|
pScene->mRootNode->mNumMeshes = 1;
|
|
|
|
|
pScene->mRootNode->mMeshes = new unsigned int[1];
|
|
|
|
|
pScene->mRootNode->mMeshes[0] = 0;
|
|
|
|
|
pScene->mNumMeshes = 1;
|
|
|
|
|
pScene->mMeshes = new aiMesh*[1];
|
|
|
|
|
pScene->mMeshes[0] = pcMesh;
|
|
|
|
|
|
|
|
|
|
// now iterate through all triangles
|
|
|
|
|
unsigned int iCurrent = 0;
|
2008-06-22 10:09:26 +00:00
|
|
|
|
for (unsigned int i = 0; i < (unsigned int) pcHeader->num_tris;++i)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
|
|
|
|
pcMesh->mFaces[i].mIndices = new unsigned int[3];
|
|
|
|
|
pcMesh->mFaces[i].mNumIndices = 3;
|
|
|
|
|
|
2008-05-25 22:29:05 +00:00
|
|
|
|
unsigned int iTemp = iCurrent;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
for (unsigned int c = 0; c < 3;++c,++iCurrent)
|
|
|
|
|
{
|
|
|
|
|
pcMesh->mFaces[i].mIndices[c] = iCurrent;
|
|
|
|
|
|
|
|
|
|
// read vertices
|
|
|
|
|
unsigned int iIndex = pcTriangles->vertex[c];
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (iIndex >= (unsigned int)pcHeader->num_verts)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
iIndex = pcHeader->num_verts-1;
|
2008-05-13 23:26:52 +00:00
|
|
|
|
|
|
|
|
|
DefaultLogger::get()->warn("Index overflow in Q1-MDL vertex list.");
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
aiVector3D& vec = pcMesh->mVertices[iCurrent];
|
2008-06-22 10:09:26 +00:00
|
|
|
|
vec.x = (float)pcVertices[iIndex].v[0] * pcHeader->scale[0];
|
|
|
|
|
vec.x += pcHeader->translate[0];
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// (flip z and y component)
|
2008-06-22 10:09:26 +00:00
|
|
|
|
vec.z = (float)pcVertices[iIndex].v[1] * pcHeader->scale[1];
|
|
|
|
|
vec.z += pcHeader->translate[1];
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
vec.y = (float)pcVertices[iIndex].v[2] * pcHeader->scale[2];
|
|
|
|
|
vec.y += pcHeader->translate[2];
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// read the normal vector from the precalculated normal table
|
2008-06-22 10:09:26 +00:00
|
|
|
|
MD2::LookupNormalIndex(pcVertices[iIndex].normalIndex,pcMesh->mNormals[iCurrent]);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
std::swap ( pcMesh->mNormals[iCurrent].y,pcMesh->mNormals[iCurrent].z );
|
|
|
|
|
|
|
|
|
|
// read texture coordinates
|
|
|
|
|
float s = (float)pcTexCoords[iIndex].s;
|
|
|
|
|
float t = (float)pcTexCoords[iIndex].t;
|
|
|
|
|
|
|
|
|
|
// translate texture coordinates
|
|
|
|
|
if (0 == pcTriangles->facesfront &&
|
|
|
|
|
0 != pcTexCoords[iIndex].onseam)
|
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
s += pcHeader->skinwidth * 0.5f;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Scale s and t to range from 0.0 to 1.0
|
2008-06-22 10:09:26 +00:00
|
|
|
|
pcMesh->mTextureCoords[0][iCurrent].x = (s + 0.5f) / pcHeader->skinwidth;
|
|
|
|
|
pcMesh->mTextureCoords[0][iCurrent].y = 1.0f-(t + 0.5f) / pcHeader->skinheight;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
}
|
2008-05-25 22:29:05 +00:00
|
|
|
|
pcMesh->mFaces[i].mIndices[0] = iTemp+2;
|
|
|
|
|
pcMesh->mFaces[i].mIndices[1] = iTemp+1;
|
|
|
|
|
pcMesh->mFaces[i].mIndices[2] = iTemp+0;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
pcTriangles++;
|
|
|
|
|
}
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
2008-06-22 10:09:26 +00:00
|
|
|
|
void MDLImporter::SetupMaterialProperties_3DGS_MDL5_Quake1( )
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// get a pointer to the file header
|
|
|
|
|
const MDL::Header* const pcHeader = (const MDL::Header*)this->mBuffer;
|
|
|
|
|
|
|
|
|
|
// allocate ONE material
|
|
|
|
|
pScene->mMaterials = new aiMaterial*[1];
|
|
|
|
|
pScene->mMaterials[0] = new MaterialHelper();
|
|
|
|
|
pScene->mNumMaterials = 1;
|
|
|
|
|
|
|
|
|
|
// setup the material properties
|
|
|
|
|
const int iMode = (int)aiShadingMode_Gouraud;
|
|
|
|
|
MaterialHelper* const pcHelper = (MaterialHelper*)pScene->mMaterials[0];
|
|
|
|
|
pcHelper->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
aiColor4D clr;
|
|
|
|
|
if (0 != pcHeader->num_skins && pScene->mNumTextures)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// can we replace the texture with a single color?
|
|
|
|
|
clr = this->ReplaceTextureWithColor(pScene->mTextures[0]);
|
|
|
|
|
if (is_not_qnan(clr.r))
|
|
|
|
|
{
|
|
|
|
|
delete pScene->mTextures[0];
|
|
|
|
|
delete[] pScene->mTextures;
|
|
|
|
|
pScene->mNumTextures = 0;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
clr.b = clr.a = clr.g = clr.r = 1.0f;
|
|
|
|
|
aiString szString;
|
|
|
|
|
::memcpy(szString.data,AI_MAKE_EMBEDDED_TEXNAME(0),3);
|
|
|
|
|
szString.length = 2;
|
|
|
|
|
pcHelper->AddProperty(&szString,AI_MATKEY_TEXTURE_DIFFUSE(0));
|
|
|
|
|
}
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
pcHelper->AddProperty<aiColor4D>(&clr, 1,AI_MATKEY_COLOR_DIFFUSE);
|
|
|
|
|
pcHelper->AddProperty<aiColor4D>(&clr, 1,AI_MATKEY_COLOR_SPECULAR);
|
|
|
|
|
|
|
|
|
|
clr.r *= 0.05f;clr.g *= 0.05f;
|
|
|
|
|
clr.b *= 0.05f;clr.a = 1.0f;
|
|
|
|
|
pcHelper->AddProperty<aiColor4D>(&clr, 1,AI_MATKEY_COLOR_AMBIENT);
|
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
|
void MDLImporter::InternReadFile_3DGS_MDL345( )
|
|
|
|
|
{
|
|
|
|
|
ai_assert(NULL != pScene);
|
|
|
|
|
|
|
|
|
|
// the header of MDL 3/4/5 is nearly identical to the original Quake1 header
|
|
|
|
|
const MDL::Header* pcHeader = (const MDL::Header*)this->mBuffer;
|
|
|
|
|
this->ValidateHeader_Quake1(pcHeader);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// current cursor position in the file
|
2008-06-22 10:09:26 +00:00
|
|
|
|
const unsigned char* szCurrent = (const unsigned char*)(pcHeader+1);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// need to read all textures
|
2008-06-22 10:09:26 +00:00
|
|
|
|
for (unsigned int i = 0; i < (unsigned int)pcHeader->num_skins;++i)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
const MDL::Skin* pcSkin;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
pcSkin = (const MDL::Skin*)szCurrent;
|
|
|
|
|
|
|
|
|
|
// create one output image
|
2008-06-22 10:09:26 +00:00
|
|
|
|
unsigned int iSkip = i ? 0xffffffff : 0;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
if (5 <= this->iGSFileVersion)
|
|
|
|
|
{
|
|
|
|
|
// MDL5 format could contain MIPmaps
|
2008-06-22 10:09:26 +00:00
|
|
|
|
this->CreateTexture_3DGS_MDL5((unsigned char*)pcSkin + sizeof(uint32_t),
|
2008-05-09 17:24:28 +00:00
|
|
|
|
pcSkin->group,&iSkip);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
this->CreateTexture_3DGS_MDL4((unsigned char*)pcSkin + sizeof(uint32_t),
|
2008-05-09 17:24:28 +00:00
|
|
|
|
pcSkin->group,&iSkip);
|
|
|
|
|
}
|
|
|
|
|
// need to skip one image
|
|
|
|
|
szCurrent += iSkip + sizeof(uint32_t);
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
// get a pointer to the texture coordinates
|
|
|
|
|
const MDL::TexCoord_MDL3* pcTexCoords = (const MDL::TexCoord_MDL3*)szCurrent;
|
2008-06-22 10:09:26 +00:00
|
|
|
|
szCurrent += sizeof(MDL::TexCoord_MDL3) * pcHeader->synctype;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// NOTE: for MDLn formats "synctype" corresponds to the number of UV coords
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// get a pointer to the triangles
|
|
|
|
|
const MDL::Triangle_MDL3* pcTriangles = (const MDL::Triangle_MDL3*)szCurrent;
|
2008-06-22 10:09:26 +00:00
|
|
|
|
szCurrent += sizeof(MDL::Triangle_MDL3) * pcHeader->num_tris;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
VALIDATE_FILE_SIZE(szCurrent);
|
|
|
|
|
|
|
|
|
|
// setup materials
|
|
|
|
|
this->SetupMaterialProperties_3DGS_MDL5_Quake1();
|
|
|
|
|
|
|
|
|
|
// allocate enough storage to hold all vertices and triangles
|
|
|
|
|
aiMesh* pcMesh = new aiMesh();
|
|
|
|
|
|
|
|
|
|
pcMesh->mNumVertices = pcHeader->num_tris * 3;
|
|
|
|
|
pcMesh->mNumFaces = pcHeader->num_tris;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
pcMesh->mFaces = new aiFace[pcMesh->mNumFaces];
|
|
|
|
|
|
|
|
|
|
// there won't be more than one mesh inside the file
|
|
|
|
|
pScene->mRootNode = new aiNode();
|
|
|
|
|
pScene->mRootNode->mNumMeshes = 1;
|
|
|
|
|
pScene->mRootNode->mMeshes = new unsigned int[1];
|
|
|
|
|
pScene->mRootNode->mMeshes[0] = 0;
|
|
|
|
|
pScene->mNumMeshes = 1;
|
|
|
|
|
pScene->mMeshes = new aiMesh*[1];
|
|
|
|
|
pScene->mMeshes[0] = pcMesh;
|
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// allocate output storage
|
|
|
|
|
pcMesh->mNumVertices = (unsigned int)pcHeader->num_tris*3;
|
|
|
|
|
pcMesh->mVertices = new aiVector3D[pcMesh->mNumVertices];
|
|
|
|
|
pcMesh->mNormals = new aiVector3D[pcMesh->mNumVertices];
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (pcHeader->synctype)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
pcMesh->mTextureCoords[0] = new aiVector3D[pcMesh->mNumVertices];
|
|
|
|
|
pcMesh->mNumUVComponents[0] = 2;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// now get a pointer to the first frame in the file
|
|
|
|
|
const MDL::Frame* pcFrames = (const MDL::Frame*)szCurrent;
|
|
|
|
|
|
|
|
|
|
// byte packed vertices
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// ***********************************************************************
|
|
|
|
|
if (0 == pcFrames->type || 3 >= this->iGSFileVersion)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
const MDL::SimpleFrame* pcFirstFrame =
|
|
|
|
|
(const MDL::SimpleFrame*)(szCurrent + sizeof(uint32_t));
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// get a pointer to the vertices
|
2008-06-22 10:09:26 +00:00
|
|
|
|
const MDL::Vertex* pcVertices = (const MDL::Vertex*) (
|
|
|
|
|
(pcFirstFrame->name) + sizeof(pcFirstFrame->name));
|
|
|
|
|
|
|
|
|
|
VALIDATE_FILE_SIZE(pcVertices + pcHeader->num_verts);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// now iterate through all triangles
|
|
|
|
|
unsigned int iCurrent = 0;
|
2008-06-22 10:09:26 +00:00
|
|
|
|
for (unsigned int i = 0; i < (unsigned int) pcHeader->num_tris;++i)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
|
|
|
|
pcMesh->mFaces[i].mIndices = new unsigned int[3];
|
|
|
|
|
pcMesh->mFaces[i].mNumIndices = 3;
|
|
|
|
|
|
2008-05-25 22:29:05 +00:00
|
|
|
|
unsigned int iTemp = iCurrent;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
for (unsigned int c = 0; c < 3;++c,++iCurrent)
|
|
|
|
|
{
|
|
|
|
|
// read vertices
|
|
|
|
|
unsigned int iIndex = pcTriangles->index_xyz[c];
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (iIndex >= (unsigned int)pcHeader->num_verts)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
iIndex = pcHeader->num_verts-1;
|
|
|
|
|
DefaultLogger::get()->warn("Index overflow in MDLn vertex list");
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
aiVector3D& vec = pcMesh->mVertices[iCurrent];
|
|
|
|
|
vec.x = (float)pcVertices[iIndex].v[0] * pcHeader->scale[0];
|
|
|
|
|
vec.x += pcHeader->translate[0];
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// (flip z and y component)
|
2008-06-22 10:09:26 +00:00
|
|
|
|
vec.z = (float)pcVertices[iIndex].v[1] * pcHeader->scale[1];
|
|
|
|
|
vec.z += pcHeader->translate[1];
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
vec.y = (float)pcVertices[iIndex].v[2] * pcHeader->scale[2];
|
|
|
|
|
vec.y += pcHeader->translate[2];
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// read the normal vector from the precalculated normal table
|
2008-06-22 10:09:26 +00:00
|
|
|
|
MD2::LookupNormalIndex(pcVertices[iIndex].normalIndex,pcMesh->mNormals[iCurrent]);
|
|
|
|
|
std::swap ( pcMesh->mNormals[iCurrent].y,pcMesh->mNormals[iCurrent].z );
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// read texture coordinates
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (pcHeader->synctype)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
this->ImportUVCoordinate_3DGS_MDL345(pcMesh->mTextureCoords[0][iCurrent],
|
|
|
|
|
pcTexCoords,pcTriangles->index_uv[c]);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2008-05-25 22:29:05 +00:00
|
|
|
|
pcMesh->mFaces[i].mIndices[0] = iTemp+2;
|
|
|
|
|
pcMesh->mFaces[i].mIndices[1] = iTemp+1;
|
|
|
|
|
pcMesh->mFaces[i].mIndices[2] = iTemp+0;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
pcTriangles++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// short packed vertices
|
|
|
|
|
// ***********************************************************************
|
2008-05-09 17:24:28 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
// now get a pointer to the first frame in the file
|
2008-06-22 10:09:26 +00:00
|
|
|
|
const MDL::SimpleFrame_MDLn_SP* pcFirstFrame =
|
|
|
|
|
(const MDL::SimpleFrame_MDLn_SP*) (szCurrent + sizeof(uint32_t));
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// get a pointer to the vertices
|
2008-06-22 10:09:26 +00:00
|
|
|
|
const MDL::Vertex_MDL4* pcVertices = (const MDL::Vertex_MDL4*)
|
|
|
|
|
((pcFirstFrame->name) + sizeof(pcFirstFrame->name));
|
|
|
|
|
|
|
|
|
|
VALIDATE_FILE_SIZE(pcVertices + pcHeader->num_verts);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// now iterate through all triangles
|
|
|
|
|
unsigned int iCurrent = 0;
|
2008-06-22 10:09:26 +00:00
|
|
|
|
for (unsigned int i = 0; i < (unsigned int) pcHeader->num_tris;++i)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
|
|
|
|
pcMesh->mFaces[i].mIndices = new unsigned int[3];
|
|
|
|
|
pcMesh->mFaces[i].mNumIndices = 3;
|
|
|
|
|
|
2008-05-25 22:29:05 +00:00
|
|
|
|
unsigned int iTemp = iCurrent;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
for (unsigned int c = 0; c < 3;++c,++iCurrent)
|
|
|
|
|
{
|
|
|
|
|
// read vertices
|
|
|
|
|
unsigned int iIndex = pcTriangles->index_xyz[c];
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (iIndex >= (unsigned int)pcHeader->num_verts)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
iIndex = pcHeader->num_verts-1;
|
|
|
|
|
DefaultLogger::get()->warn("Index overflow in MDLn vertex list");
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
aiVector3D& vec = pcMesh->mVertices[iCurrent];
|
|
|
|
|
vec.x = (float)pcVertices[iIndex].v[0] * pcHeader->scale[0];
|
|
|
|
|
vec.x += pcHeader->translate[0];
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// (flip z and y component)
|
2008-06-22 10:09:26 +00:00
|
|
|
|
vec.z = (float)pcVertices[iIndex].v[1] * pcHeader->scale[1];
|
|
|
|
|
vec.z += pcHeader->translate[1];
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
vec.y = (float)pcVertices[iIndex].v[2] * pcHeader->scale[2];
|
|
|
|
|
vec.y += pcHeader->translate[2];
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// read the normal vector from the precalculated normal table
|
2008-06-22 10:09:26 +00:00
|
|
|
|
MD2::LookupNormalIndex(pcVertices[iIndex].normalIndex,pcMesh->mNormals[iCurrent]);
|
|
|
|
|
std::swap ( pcMesh->mNormals[iCurrent].y,pcMesh->mNormals[iCurrent].z );
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// read texture coordinates
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (pcHeader->synctype)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
this->ImportUVCoordinate_3DGS_MDL345(pcMesh->mTextureCoords[0][iCurrent],
|
|
|
|
|
pcTexCoords,pcTriangles->index_uv[c]);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2008-05-25 22:29:05 +00:00
|
|
|
|
pcMesh->mFaces[i].mIndices[0] = iTemp+2;
|
|
|
|
|
pcMesh->mFaces[i].mIndices[1] = iTemp+1;
|
|
|
|
|
pcMesh->mFaces[i].mIndices[2] = iTemp+0;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
pcTriangles++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// For MDL5 we will need to build valid texture coordinates
|
|
|
|
|
// basing upon the file loaded (only support one file as skin)
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (0x5 == this->iGSFileVersion)
|
|
|
|
|
this->CalculateUVCoordinates_MDL5();
|
2008-05-09 17:24:28 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
2008-06-22 10:09:26 +00:00
|
|
|
|
void MDLImporter::ImportUVCoordinate_3DGS_MDL345(
|
|
|
|
|
aiVector3D& vOut,
|
|
|
|
|
const MDL::TexCoord_MDL3* pcSrc,
|
|
|
|
|
unsigned int iIndex)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
ai_assert(NULL != pcSrc);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
const MDL::Header* const pcHeader = (const MDL::Header*)this->mBuffer;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// validate UV indices
|
|
|
|
|
if (iIndex >= (unsigned int) pcHeader->synctype)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
iIndex = pcHeader->synctype-1;
|
|
|
|
|
DefaultLogger::get()->warn("Index overflow in MDLn UV coord list");
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
float s = (float)pcSrc[iIndex].u;
|
|
|
|
|
float t = (float)pcSrc[iIndex].v;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// Scale s and t to range from 0.0 to 1.0
|
|
|
|
|
if (0x5 != this->iGSFileVersion)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
s = (s + 0.5f) / pcHeader->skinwidth;
|
|
|
|
|
t = 1.0f-(t + 0.5f) / pcHeader->skinheight;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
|
|
|
|
|
vOut.x = s;
|
|
|
|
|
vOut.y = t;
|
|
|
|
|
vOut.z = 0.0f;
|
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
|
void MDLImporter::CalculateUVCoordinates_MDL5()
|
|
|
|
|
{
|
|
|
|
|
const MDL::Header* const pcHeader = (const MDL::Header*)this->mBuffer;
|
|
|
|
|
if (pcHeader->num_skins && this->pScene->mNumTextures)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
const aiTexture* pcTex = this->pScene->mTextures[0];
|
|
|
|
|
|
|
|
|
|
// if the file is loaded in DDS format: get the size of the
|
|
|
|
|
// texture from the header of the DDS file
|
|
|
|
|
// skip three DWORDs and read first height, then the width
|
|
|
|
|
unsigned int iWidth, iHeight;
|
|
|
|
|
if (!pcTex->mHeight)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
const uint32_t* piPtr = (uint32_t*)pcTex->pcData;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
piPtr += 3;
|
|
|
|
|
iHeight = (unsigned int)*piPtr++;
|
|
|
|
|
iWidth = (unsigned int)*piPtr;
|
|
|
|
|
if (!iHeight || !iWidth)
|
2008-05-13 23:26:52 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
DefaultLogger::get()->warn("Either the width or the height of the "
|
|
|
|
|
"embedded DDS texture is zero. Unable to compute final texture "
|
|
|
|
|
"coordinates. The texture coordinates remain in their original "
|
|
|
|
|
"0-x/0-y (x,y = texture size) range.");
|
|
|
|
|
iWidth = 1;
|
|
|
|
|
iHeight = 1;
|
2008-05-13 23:26:52 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
iWidth = pcTex->mWidth;
|
|
|
|
|
iHeight = pcTex->mHeight;
|
2008-05-13 23:26:52 +00:00
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
|
|
|
|
|
if (1 != iWidth || 1 != iHeight)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
const float fWidth = (float)iWidth;
|
|
|
|
|
const float fHeight = (float)iHeight;
|
|
|
|
|
aiMesh* pcMesh = this->pScene->mMeshes[0];
|
|
|
|
|
for (unsigned int i = 0; i < pcMesh->mNumVertices;++i)
|
|
|
|
|
{
|
|
|
|
|
// width and height can't be 0 here
|
|
|
|
|
pcMesh->mTextureCoords[0][i].x /= fWidth;
|
|
|
|
|
pcMesh->mTextureCoords[0][i].y /= fHeight;
|
|
|
|
|
pcMesh->mTextureCoords[0][i].y = 1.0f - pcMesh->mTextureCoords[0][i].y; // DX to OGL
|
|
|
|
|
}
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
|
void MDLImporter::ValidateHeader_3DGS_MDL7(const MDL::Header_MDL7* pcHeader)
|
|
|
|
|
{
|
|
|
|
|
ai_assert(NULL != pcHeader);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (sizeof(MDL::ColorValue_MDL7) != pcHeader->colorvalue_stc_size)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// LOG
|
|
|
|
|
throw new ImportErrorException(
|
|
|
|
|
"[3DGS MDL7] sizeof(MDL::ColorValue_MDL7) != pcHeader->colorvalue_stc_size");
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (sizeof(MDL::TexCoord_MDL7) != pcHeader->skinpoint_stc_size)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
|
|
|
|
// LOG
|
|
|
|
|
throw new ImportErrorException(
|
|
|
|
|
"[3DGS MDL7] sizeof(MDL::TexCoord_MDL7) != pcHeader->skinpoint_stc_size");
|
|
|
|
|
}
|
|
|
|
|
if (sizeof(MDL::Skin_MDL7) != pcHeader->skin_stc_size)
|
|
|
|
|
{
|
|
|
|
|
// LOG
|
|
|
|
|
throw new ImportErrorException(
|
|
|
|
|
"sizeof(MDL::Skin_MDL7) != pcHeader->skin_stc_size");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// if there are no groups ... how should we load such a file?
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if(!pcHeader->groups_num)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
|
|
|
|
// LOG
|
|
|
|
|
throw new ImportErrorException( "[3DGS MDL7] No frames found");
|
|
|
|
|
}
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
2008-06-22 10:09:26 +00:00
|
|
|
|
void MDLImporter::CalcAbsBoneMatrices_3DGS_MDL7(const MDL::Bone_MDL7* pcBones,
|
|
|
|
|
MDL::IntBone_MDL7** apcOutBones)
|
2008-06-03 21:50:53 +00:00
|
|
|
|
{
|
|
|
|
|
ai_assert(NULL != pcBones);
|
|
|
|
|
ai_assert(NULL != apcOutBones);
|
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
const MDL::Header_MDL7* const pcHeader = (const MDL::Header_MDL7*)this->mBuffer;
|
2008-06-03 21:50:53 +00:00
|
|
|
|
|
|
|
|
|
// first find the bone that has NO parent, calculate the
|
|
|
|
|
// animation matrix for it, then go on and search for the next parent
|
|
|
|
|
// index (0) and so on until we can't find a new node.
|
|
|
|
|
uint16_t iParent = 0xffff;
|
2008-06-22 10:09:26 +00:00
|
|
|
|
uint32_t iIterations = 0;
|
2008-06-03 21:50:53 +00:00
|
|
|
|
while (iIterations++ < pcHeader->bones_num)
|
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
for (uint32_t iBone = 0; iBone < pcHeader->bones_num;++iBone)
|
2008-06-03 21:50:53 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
const MDL::Bone_MDL7* pcBone = _AI_MDL7_ACCESS_PTR(pcBones,iBone,
|
|
|
|
|
pcHeader->bone_stc_size,MDL::Bone_MDL7);
|
2008-06-03 21:50:53 +00:00
|
|
|
|
|
|
|
|
|
if (iParent == pcBone->parent_index)
|
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// extract from MDL7 readme ...
|
2008-06-03 21:50:53 +00:00
|
|
|
|
/************************************************************
|
|
|
|
|
The animation matrix is then calculated the following way:
|
|
|
|
|
|
|
|
|
|
vector3 bPos = <absolute bone position>
|
|
|
|
|
matrix44 laM; // local animation matrix
|
|
|
|
|
sphrvector key_rotate = <bone rotation>
|
|
|
|
|
|
|
|
|
|
matrix44 m1,m2;
|
|
|
|
|
create_trans_matrix(m1, -bPos.x, -bPos.y, -bPos.z);
|
|
|
|
|
create_trans_matrix(m2, -bPos.x, -bPos.y, -bPos.z);
|
|
|
|
|
|
|
|
|
|
create_rotation_matrix(laM,key_rotate);
|
|
|
|
|
|
|
|
|
|
laM = sm1 * laM;
|
|
|
|
|
laM = laM * sm2;
|
2008-06-22 10:09:26 +00:00
|
|
|
|
*************************************************************/
|
|
|
|
|
|
|
|
|
|
MDL::IntBone_MDL7* const pcOutBone = apcOutBones[iBone];
|
|
|
|
|
|
|
|
|
|
// store the parent index of the bone
|
|
|
|
|
pcOutBone->iParent = pcBone->parent_index;
|
2008-06-03 21:50:53 +00:00
|
|
|
|
if (0xffff != iParent)
|
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
const MDL::IntBone_MDL7* pcParentBone = apcOutBones[iParent];
|
|
|
|
|
pcOutBone->mOffsetMatrix.a4 = -pcParentBone->vPosition.x;
|
|
|
|
|
pcOutBone->mOffsetMatrix.b4 = -pcParentBone->vPosition.y;
|
|
|
|
|
pcOutBone->mOffsetMatrix.c4 = -pcParentBone->vPosition.z;
|
|
|
|
|
}
|
|
|
|
|
pcOutBone->vPosition.x = pcBone->x;
|
|
|
|
|
pcOutBone->vPosition.y = pcBone->y;
|
|
|
|
|
pcOutBone->vPosition.z = pcBone->z;
|
|
|
|
|
pcOutBone->mOffsetMatrix.a4 -= pcBone->x;
|
|
|
|
|
pcOutBone->mOffsetMatrix.b4 -= pcBone->y;
|
|
|
|
|
pcOutBone->mOffsetMatrix.c4 -= pcBone->z;
|
|
|
|
|
|
|
|
|
|
if (AI_MDL7_BONE_STRUCT_SIZE__NAME_IS_NOT_THERE == pcHeader->bone_stc_size)
|
|
|
|
|
{
|
|
|
|
|
// no real name for our poor bone :-(
|
|
|
|
|
# if (_MSC_VER >= 1400)
|
|
|
|
|
pcOutBone->mName.length = ::sprintf_s(pcOutBone->mName.data,
|
|
|
|
|
MAXLEN,"UnnamedBone_%i",iBone);
|
|
|
|
|
# else
|
|
|
|
|
pcOutBone->mName.length = ::sprintf(pcOutBone->mName.data,
|
|
|
|
|
"UnnamedBone_%i",iBone);
|
|
|
|
|
# endif
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
// make sure we won't run over the buffer's end if there is no
|
|
|
|
|
// terminal 0 character (however the documentation says there
|
|
|
|
|
// should be one)
|
|
|
|
|
uint32_t iMaxLen = pcHeader->bone_stc_size-16;
|
|
|
|
|
for (uint32_t qq = 0; qq < iMaxLen;++qq)
|
|
|
|
|
{
|
|
|
|
|
if (!pcBone->name[qq])
|
|
|
|
|
{
|
|
|
|
|
iMaxLen = qq;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// store the name of the bone
|
|
|
|
|
pcOutBone->mName.length = (size_t)iMaxLen;
|
|
|
|
|
::memcpy(pcOutBone->mName.data,pcBone->name,pcOutBone->mName.length);
|
|
|
|
|
pcOutBone->mName.data[pcOutBone->mName.length] = '\0';
|
2008-06-03 21:50:53 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
++iParent;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
2008-06-22 10:09:26 +00:00
|
|
|
|
MDL::IntBone_MDL7** MDLImporter::LoadBones_3DGS_MDL7()
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// again, get a pointer to the file header, the bone data
|
|
|
|
|
// is stored directly behind it
|
|
|
|
|
const MDL::Header_MDL7* const pcHeader = (const MDL::Header_MDL7*)this->mBuffer;
|
|
|
|
|
const MDL::Bone_MDL7* pcBones = (const MDL::Bone_MDL7*)(pcHeader+1);
|
2008-06-03 21:50:53 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (pcHeader->bones_num)
|
2008-06-03 21:50:53 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// validate the size of the bone data structure in the file
|
|
|
|
|
if (AI_MDL7_BONE_STRUCT_SIZE__NAME_IS_20_CHARS != pcHeader->bone_stc_size &&
|
|
|
|
|
AI_MDL7_BONE_STRUCT_SIZE__NAME_IS_32_CHARS != pcHeader->bone_stc_size &&
|
|
|
|
|
AI_MDL7_BONE_STRUCT_SIZE__NAME_IS_NOT_THERE != pcHeader->bone_stc_size)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
DefaultLogger::get()->warn("Unknown size of bone data structure");
|
|
|
|
|
return NULL;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
MDL::IntBone_MDL7** apcBonesOut = new MDL::IntBone_MDL7*[pcHeader->bones_num];
|
|
|
|
|
for (uint32_t crank = 0; crank < pcHeader->bones_num;++crank)
|
|
|
|
|
apcBonesOut[crank] = new MDL::IntBone_MDL7();
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// and calculate absolute bone offset matrices ...
|
|
|
|
|
this->CalcAbsBoneMatrices_3DGS_MDL7(pcBones,apcBonesOut);
|
|
|
|
|
return apcBonesOut;
|
|
|
|
|
}
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
|
void MDLImporter::ReadFaces_3DGS_MDL7(
|
|
|
|
|
const MDL::IntGroupInfo_MDL7& groupInfo,
|
|
|
|
|
MDL::IntGroupData_MDL7& groupData)
|
|
|
|
|
{
|
|
|
|
|
// get a pointer to the file header
|
|
|
|
|
const MDL::Header_MDL7* const pcHeader = (const MDL::Header_MDL7*)this->mBuffer;
|
|
|
|
|
const MDL::Triangle_MDL7* pcGroupTris = groupInfo.pcGroupTris;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// iterate through all triangles and build valid display lists
|
|
|
|
|
unsigned int iOutIndex = 0;
|
|
|
|
|
for (unsigned int iTriangle = 0; iTriangle < (unsigned int)groupInfo.pcGroup->numtris; ++iTriangle)
|
|
|
|
|
{
|
|
|
|
|
// iterate through all indices of the current triangle
|
|
|
|
|
for (unsigned int c = 0; c < 3;++c,++iOutIndex)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// validate the vertex index
|
|
|
|
|
unsigned int iIndex = pcGroupTris->v_index[c];
|
|
|
|
|
if(iIndex > (unsigned int)groupInfo.pcGroup->numverts)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-08-06 23:01:38 +00:00
|
|
|
|
// (we might need to read this section a second time - to process
|
|
|
|
|
// frame vertices correctly)
|
|
|
|
|
const_cast<MDL::Triangle_MDL7*>(pcGroupTris)->v_index[c] = iIndex = groupInfo.pcGroup->numverts-1;
|
2008-06-22 10:09:26 +00:00
|
|
|
|
DefaultLogger::get()->warn("Index overflow in MDL7 vertex list");
|
|
|
|
|
}
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// write the output face index
|
|
|
|
|
groupData.pcFaces[iTriangle].mIndices[2-c] = iOutIndex;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// swap z and y axis
|
|
|
|
|
aiVector3D& vPosition = groupData.vPositions[ iOutIndex ];
|
|
|
|
|
vPosition.x = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts,iIndex,pcHeader->mainvertex_stc_size) .x;
|
|
|
|
|
vPosition.z = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts,iIndex,pcHeader->mainvertex_stc_size) .y;
|
|
|
|
|
vPosition.y = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts,iIndex,pcHeader->mainvertex_stc_size) .z;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// if we have bones, save the index
|
|
|
|
|
if (!groupData.aiBones.empty())
|
|
|
|
|
{
|
|
|
|
|
groupData.aiBones[iOutIndex] = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts,iIndex,pcHeader->mainvertex_stc_size).vertindex;
|
|
|
|
|
}
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// now read the normal vector
|
|
|
|
|
if (AI_MDL7_FRAMEVERTEX030305_STCSIZE <= pcHeader->mainvertex_stc_size)
|
|
|
|
|
{
|
|
|
|
|
// read the full normal vector
|
|
|
|
|
aiVector3D& vNormal = groupData.vNormals[ iOutIndex ];
|
|
|
|
|
vNormal.x = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts,iIndex,pcHeader->mainvertex_stc_size) .norm[0];
|
|
|
|
|
vNormal.z = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts,iIndex,pcHeader->mainvertex_stc_size) .norm[1];
|
|
|
|
|
vNormal.y = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts,iIndex,pcHeader->mainvertex_stc_size) .norm[2];
|
|
|
|
|
}
|
|
|
|
|
else if (AI_MDL7_FRAMEVERTEX120503_STCSIZE <= pcHeader->mainvertex_stc_size)
|
|
|
|
|
{
|
|
|
|
|
// read the normal vector from Quake2's smart table
|
|
|
|
|
aiVector3D& vNormal = groupData.vNormals[ iOutIndex ];
|
|
|
|
|
MD2::LookupNormalIndex(_AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts,iIndex,
|
|
|
|
|
pcHeader->mainvertex_stc_size) .norm162index,vNormal);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
std::swap(groupData.vNormals[iOutIndex].z,groupData.vNormals[iOutIndex].y);
|
|
|
|
|
}
|
|
|
|
|
// validate and process the first uv coordinate set
|
|
|
|
|
// *************************************************************
|
|
|
|
|
if (pcHeader->triangle_stc_size >= AI_MDL7_TRIANGLE_STD_SIZE_ONE_UV)
|
|
|
|
|
{
|
|
|
|
|
if (groupInfo.pcGroup->num_stpts)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
|
|
|
|
iIndex = pcGroupTris->skinsets[0].st_index[c];
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if(iIndex > (unsigned int)groupInfo.pcGroup->num_stpts)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
iIndex = groupInfo.pcGroup->num_stpts-1;
|
|
|
|
|
DefaultLogger::get()->warn("Index overflow in MDL7 UV coordinate list (#1)");
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
float u = groupInfo.pcGroupUVs[iIndex].u;
|
|
|
|
|
float v = 1.0f-groupInfo.pcGroupUVs[iIndex].v; // DX to OGL
|
|
|
|
|
|
|
|
|
|
groupData.vTextureCoords1[iOutIndex].x = u;
|
|
|
|
|
groupData.vTextureCoords1[iOutIndex].y = v;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// assign the material index, but only if it is existing
|
|
|
|
|
if (pcHeader->triangle_stc_size >= AI_MDL7_TRIANGLE_STD_SIZE_ONE_UV_WITH_MATINDEX)
|
|
|
|
|
{
|
|
|
|
|
groupData.pcFaces[iTriangle].iMatIndex[0] = pcGroupTris->skinsets[0].material;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// validate and process the second uv coordinate set
|
|
|
|
|
// *************************************************************
|
|
|
|
|
if (pcHeader->triangle_stc_size >= AI_MDL7_TRIANGLE_STD_SIZE_TWO_UV)
|
|
|
|
|
{
|
|
|
|
|
if (groupInfo.pcGroup->num_stpts)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
|
|
|
|
iIndex = pcGroupTris->skinsets[1].st_index[c];
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if(iIndex > (unsigned int)groupInfo.pcGroup->num_stpts)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
iIndex = groupInfo.pcGroup->num_stpts-1;
|
|
|
|
|
DefaultLogger::get()->warn("Index overflow in MDL7 UV coordinate list (#2)");
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
float u = groupInfo.pcGroupUVs[ iIndex ].u;
|
|
|
|
|
float v = 1.0f-groupInfo.pcGroupUVs[ iIndex ].v;
|
|
|
|
|
|
|
|
|
|
groupData.vTextureCoords2[ iOutIndex ].x = u;
|
|
|
|
|
groupData.vTextureCoords2[ iOutIndex ].y = v; // DX to OGL
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// check whether we do really need the second texture
|
|
|
|
|
// coordinate set ... wastes memory and loading time
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (0 != iIndex && (u != groupData.vTextureCoords1[ iOutIndex ].x ||
|
|
|
|
|
v != groupData.vTextureCoords1[ iOutIndex ].y ) )
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
groupData.bNeed2UV = true;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
// if the material differs, we need a second skin, too
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (pcGroupTris->skinsets[ 1 ].material != pcGroupTris->skinsets[ 0 ].material)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
groupData.bNeed2UV = true;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// assign the material index
|
|
|
|
|
groupData.pcFaces[ iTriangle ].iMatIndex[ 1 ] = pcGroupTris->skinsets[ 1 ].material;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
}
|
|
|
|
|
// get the next triangle in the list
|
|
|
|
|
pcGroupTris = (const MDL::Triangle_MDL7*)((const char*)pcGroupTris +
|
|
|
|
|
pcHeader->triangle_stc_size);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
|
bool MDLImporter::ProcessFrames_3DGS_MDL7(const MDL::IntGroupInfo_MDL7& groupInfo,
|
2008-08-06 23:01:38 +00:00
|
|
|
|
MDL::IntGroupData_MDL7& groupData,
|
2008-06-22 10:09:26 +00:00
|
|
|
|
MDL::IntSharedData_MDL7& shared,
|
|
|
|
|
const unsigned char* szCurrent,
|
|
|
|
|
const unsigned char** szCurrentOut)
|
|
|
|
|
{
|
|
|
|
|
ai_assert(NULL != szCurrent && NULL != szCurrentOut);
|
|
|
|
|
|
|
|
|
|
// get a pointer to the file header
|
|
|
|
|
const MDL::Header_MDL7* const pcHeader = (const MDL::Header_MDL7*)this->mBuffer;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// if we have no bones we can simply skip all frames,
|
|
|
|
|
// otherwise we'll need to process them.
|
2008-08-06 23:01:38 +00:00
|
|
|
|
// FIX: If we need another frame than the first we must apply frame vertex replacements ...
|
2008-06-22 10:09:26 +00:00
|
|
|
|
for(unsigned int iFrame = 0; iFrame < (unsigned int)groupInfo.pcGroup->numframes;++iFrame)
|
|
|
|
|
{
|
2008-08-06 23:01:38 +00:00
|
|
|
|
MDL::IntFrameInfo_MDL7 frame ((const MDL::Frame_MDL7*)szCurrent,iFrame);
|
2008-06-22 10:09:26 +00:00
|
|
|
|
|
|
|
|
|
const unsigned int iAdd = pcHeader->frame_stc_size +
|
|
|
|
|
frame.pcFrame->vertices_count * pcHeader->framevertex_stc_size +
|
|
|
|
|
frame.pcFrame->transmatrix_count * pcHeader->bonetrans_stc_size;
|
|
|
|
|
|
|
|
|
|
if (((const char*)szCurrent - (const char*)pcHeader) + iAdd > (unsigned int)pcHeader->data_size)
|
|
|
|
|
{
|
2008-08-06 23:01:38 +00:00
|
|
|
|
DefaultLogger::get()->warn("Index overflow in frame area. "
|
|
|
|
|
"Ignoring all frames and all further mesh groups, too.");
|
2008-06-22 10:09:26 +00:00
|
|
|
|
|
|
|
|
|
// don't parse more groups if we can't even read one
|
|
|
|
|
// FIXME: sometimes this seems to occur even for valid files ...
|
|
|
|
|
*szCurrentOut = szCurrent;
|
|
|
|
|
return false;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
2008-08-06 23:01:38 +00:00
|
|
|
|
// our output frame?
|
|
|
|
|
if (configFrameID == iFrame)
|
|
|
|
|
{
|
|
|
|
|
const MDL::Vertex_MDL7* pcFrameVertices = (const MDL::Vertex_MDL7*)
|
|
|
|
|
(szCurrent + pcHeader->framevertex_stc_size);
|
|
|
|
|
|
|
|
|
|
for (unsigned int qq = 0; qq < frame.pcFrame->vertices_count;++qq)
|
|
|
|
|
{
|
|
|
|
|
// I assume this are simple replacements for normal
|
|
|
|
|
// vertices, the bone index serving as the index of the
|
|
|
|
|
// vertex to be replaced.
|
|
|
|
|
uint16_t iIndex = _AI_MDL7_ACCESS(pcFrameVertices,qq,
|
|
|
|
|
pcHeader->framevertex_stc_size,MDL::Vertex_MDL7).vertindex;
|
|
|
|
|
|
|
|
|
|
if (iIndex >= groupInfo.pcGroup->numverts)
|
|
|
|
|
{
|
|
|
|
|
DefaultLogger::get()->warn("Invalid vertex index in frame vertex section. "
|
|
|
|
|
"Skipping this frame vertex");
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
aiVector3D vPosition,vNormal;
|
|
|
|
|
|
|
|
|
|
vPosition.x = _AI_MDL7_ACCESS_VERT(pcFrameVertices,qq,pcHeader->framevertex_stc_size) .x;
|
|
|
|
|
vPosition.z = _AI_MDL7_ACCESS_VERT(pcFrameVertices,qq,pcHeader->framevertex_stc_size) .y;
|
|
|
|
|
vPosition.y = _AI_MDL7_ACCESS_VERT(pcFrameVertices,qq,pcHeader->framevertex_stc_size) .z;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-08-06 23:01:38 +00:00
|
|
|
|
// now read the normal vector
|
|
|
|
|
if (AI_MDL7_FRAMEVERTEX030305_STCSIZE <= pcHeader->mainvertex_stc_size)
|
|
|
|
|
{
|
|
|
|
|
// read the full normal vector
|
|
|
|
|
vNormal.x = _AI_MDL7_ACCESS_VERT(pcFrameVertices,qq,pcHeader->framevertex_stc_size) .norm[0];
|
|
|
|
|
vNormal.z = _AI_MDL7_ACCESS_VERT(pcFrameVertices,qq,pcHeader->framevertex_stc_size) .norm[1];
|
|
|
|
|
vNormal.y = _AI_MDL7_ACCESS_VERT(pcFrameVertices,qq,pcHeader->framevertex_stc_size) .norm[2];
|
|
|
|
|
}
|
|
|
|
|
else if (AI_MDL7_FRAMEVERTEX120503_STCSIZE <= pcHeader->mainvertex_stc_size)
|
|
|
|
|
{
|
|
|
|
|
// read the normal vector from Quake2's smart table
|
|
|
|
|
MD2::LookupNormalIndex(_AI_MDL7_ACCESS_VERT(pcFrameVertices,qq,
|
|
|
|
|
pcHeader->framevertex_stc_size) .norm162index,vNormal);
|
|
|
|
|
|
|
|
|
|
std::swap(vNormal.z,vNormal.y);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// FIXME: O(n^2) at the moment ...
|
|
|
|
|
// shouldn't be too worse, frame vertices aren't required more
|
|
|
|
|
// than once a century ...
|
|
|
|
|
const MDL::Triangle_MDL7* pcGroupTris = groupInfo.pcGroupTris;
|
|
|
|
|
unsigned int iOutIndex = 0;
|
|
|
|
|
for (unsigned int iTriangle = 0; iTriangle < (unsigned int)groupInfo.pcGroup->numtris; ++iTriangle)
|
|
|
|
|
{
|
|
|
|
|
// iterate through all indices of the current triangle
|
|
|
|
|
for (unsigned int c = 0; c < 3;++c,++iOutIndex)
|
|
|
|
|
{
|
|
|
|
|
// replace the vertex with the new data
|
|
|
|
|
const unsigned int iCurIndex = pcGroupTris->v_index[c];
|
|
|
|
|
if (iCurIndex == iIndex)
|
|
|
|
|
{
|
|
|
|
|
groupData.vPositions[iOutIndex] = vPosition;
|
|
|
|
|
groupData.vNormals[iOutIndex] = vNormal;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// get the next triangle in the list
|
|
|
|
|
pcGroupTris = (const MDL::Triangle_MDL7*)((const char*)pcGroupTris +
|
|
|
|
|
pcHeader->triangle_stc_size);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// parse bone trafo matrix keys (only if there are bones ...)
|
|
|
|
|
if (shared.apcOutBones)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
this->ParseBoneTrafoKeys_3DGS_MDL7(groupInfo,frame,shared);
|
|
|
|
|
}
|
|
|
|
|
szCurrent += iAdd;
|
|
|
|
|
}
|
|
|
|
|
*szCurrentOut = szCurrent;
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
|
void MDLImporter::SortByMaterials_3DGS_MDL7(
|
|
|
|
|
const MDL::IntGroupInfo_MDL7& groupInfo,
|
|
|
|
|
MDL::IntGroupData_MDL7& groupData,
|
|
|
|
|
MDL::IntSplittedGroupData_MDL7& splittedGroupData)
|
|
|
|
|
{
|
|
|
|
|
const unsigned int iNumMaterials = (unsigned int)splittedGroupData.shared.pcMats.size();
|
|
|
|
|
|
|
|
|
|
// if we don't need a second set of texture coordinates there is no reason to keep it in memory ...
|
|
|
|
|
if (!groupData.bNeed2UV)
|
|
|
|
|
{
|
|
|
|
|
groupData.vTextureCoords2.clear();
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// allocate the array
|
|
|
|
|
splittedGroupData.aiSplit = new std::vector<unsigned int>*[iNumMaterials];
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
for (unsigned int m = 0; m < iNumMaterials;++m)
|
|
|
|
|
splittedGroupData.aiSplit[m] = new std::vector<unsigned int>();
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// iterate through all faces and sort by material
|
|
|
|
|
for (unsigned int iFace = 0; iFace < (unsigned int)groupInfo.pcGroup->numtris;++iFace)
|
|
|
|
|
{
|
|
|
|
|
// check range
|
|
|
|
|
if (groupData.pcFaces[iFace].iMatIndex[0] >= iNumMaterials)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// use the last material instead
|
|
|
|
|
splittedGroupData.aiSplit[iNumMaterials-1]->push_back(iFace);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// sometimes MED writes -1, but normally only if there is only
|
|
|
|
|
// one skin assigned. No warning in this case
|
|
|
|
|
if(0xFFFFFFFF != groupData.pcFaces[iFace].iMatIndex[0])
|
|
|
|
|
DefaultLogger::get()->warn("Index overflow in MDL7 material list [#0]");
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
else splittedGroupData.aiSplit[groupData.pcFaces[iFace].
|
|
|
|
|
iMatIndex[0]]->push_back(iFace);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
// we need to build combined materials for each combination of
|
|
|
|
|
std::vector<MDL::IntMaterial_MDL7> avMats;
|
|
|
|
|
avMats.reserve(iNumMaterials*2);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
std::vector<std::vector<unsigned int>* > aiTempSplit;
|
|
|
|
|
aiTempSplit.reserve(iNumMaterials*2);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
for (unsigned int m = 0; m < iNumMaterials;++m)
|
|
|
|
|
aiTempSplit[m] = new std::vector<unsigned int>();
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// iterate through all faces and sort by material
|
|
|
|
|
for (unsigned int iFace = 0; iFace < (unsigned int)groupInfo.pcGroup->numtris;++iFace)
|
|
|
|
|
{
|
|
|
|
|
// check range
|
|
|
|
|
unsigned int iMatIndex = groupData.pcFaces[iFace].iMatIndex[0];
|
|
|
|
|
if (iMatIndex >= iNumMaterials)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// sometimes MED writes -1, but normally only if there is only
|
|
|
|
|
// one skin assigned. No warning in this case
|
|
|
|
|
if(0xffffffff != iMatIndex)
|
|
|
|
|
DefaultLogger::get()->warn("Index overflow in MDL7 material list [#1]");
|
|
|
|
|
iMatIndex = iNumMaterials-1;
|
|
|
|
|
}
|
|
|
|
|
unsigned int iMatIndex2 = groupData.pcFaces[iFace].iMatIndex[1];
|
2008-05-13 23:26:52 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
unsigned int iNum = iMatIndex;
|
|
|
|
|
if (0xffffffff != iMatIndex2 && iMatIndex != iMatIndex2)
|
|
|
|
|
{
|
2008-05-09 17:24:28 +00:00
|
|
|
|
if (iMatIndex2 >= iNumMaterials)
|
|
|
|
|
{
|
2008-05-13 23:26:52 +00:00
|
|
|
|
// sometimes MED writes -1, but normally only if there is only
|
|
|
|
|
// one skin assigned. No warning in this case
|
2008-06-22 10:09:26 +00:00
|
|
|
|
DefaultLogger::get()->warn("Index overflow in MDL7 material list [#2]");
|
|
|
|
|
iMatIndex2 = iNumMaterials-1;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// do a slow seach in the list ...
|
|
|
|
|
iNum = 0;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
bool bFound = false;
|
|
|
|
|
for (std::vector<MDL::IntMaterial_MDL7>::iterator
|
|
|
|
|
i = avMats.begin();
|
|
|
|
|
i != avMats.end();++i,++iNum)
|
|
|
|
|
{
|
|
|
|
|
if ((*i).iOldMatIndices[0] == iMatIndex &&
|
|
|
|
|
(*i).iOldMatIndices[1] == iMatIndex2)
|
|
|
|
|
{
|
|
|
|
|
// reuse this material
|
|
|
|
|
bFound = true;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (!bFound)
|
|
|
|
|
{
|
|
|
|
|
// build a new material ...
|
|
|
|
|
MDL::IntMaterial_MDL7 sHelper;
|
|
|
|
|
sHelper.pcMat = new MaterialHelper();
|
|
|
|
|
sHelper.iOldMatIndices[0] = iMatIndex;
|
|
|
|
|
sHelper.iOldMatIndices[1] = iMatIndex2;
|
2008-06-22 10:09:26 +00:00
|
|
|
|
this->JoinSkins_3DGS_MDL7(splittedGroupData.shared.pcMats[iMatIndex],
|
|
|
|
|
splittedGroupData.shared.pcMats[iMatIndex2],sHelper.pcMat);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// and add it to the list
|
|
|
|
|
avMats.push_back(sHelper);
|
2008-06-01 12:46:17 +00:00
|
|
|
|
iNum = (unsigned int)avMats.size()-1;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
// adjust the size of the file array
|
|
|
|
|
if (iNum == aiTempSplit.size())
|
|
|
|
|
{
|
|
|
|
|
aiTempSplit.push_back(new std::vector<unsigned int>());
|
|
|
|
|
}
|
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
aiTempSplit[iNum]->push_back(iFace);
|
|
|
|
|
}
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// now add the newly created materials to the old list
|
|
|
|
|
if (0 == groupInfo.iIndex)
|
|
|
|
|
{
|
|
|
|
|
splittedGroupData.shared.pcMats.resize(avMats.size());
|
|
|
|
|
for (unsigned int o = 0; o < avMats.size();++o)
|
|
|
|
|
splittedGroupData.shared.pcMats[o] = avMats[o].pcMat;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
// TODO: This might result in redundant materials ...
|
|
|
|
|
splittedGroupData.shared.pcMats.resize(iNumMaterials + avMats.size());
|
|
|
|
|
for (unsigned int o = iNumMaterials; o < avMats.size();++o)
|
|
|
|
|
splittedGroupData.shared.pcMats[o] = avMats[o].pcMat;
|
|
|
|
|
}
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// and build the final face-to-material array
|
|
|
|
|
splittedGroupData.aiSplit = new std::vector<unsigned int>*[aiTempSplit.size()];
|
|
|
|
|
for (unsigned int m = 0; m < iNumMaterials;++m)
|
|
|
|
|
splittedGroupData.aiSplit[m] = aiTempSplit[m];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
|
void MDLImporter::InternReadFile_3DGS_MDL7( )
|
|
|
|
|
{
|
|
|
|
|
ai_assert(NULL != pScene);
|
|
|
|
|
|
|
|
|
|
MDL::IntSharedData_MDL7 sharedData;
|
|
|
|
|
|
|
|
|
|
// current cursor position in the file
|
|
|
|
|
const MDL::Header_MDL7* const pcHeader = (const MDL::Header_MDL7*)this->mBuffer;
|
|
|
|
|
const unsigned char* szCurrent = (const unsigned char*)(pcHeader+1);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// validate the header of the file. There are some structure
|
|
|
|
|
// sizes that are expected by the loader to be constant
|
|
|
|
|
this->ValidateHeader_3DGS_MDL7(pcHeader);
|
|
|
|
|
|
|
|
|
|
// load all bones (they are shared by all groups, so
|
|
|
|
|
// we'll need to add them to all groups/meshes later)
|
|
|
|
|
// apcBonesOut is a list of all bones or NULL if they could not been loaded
|
|
|
|
|
// TODO (aramis): Make apcBonesOut an MDL::IntBone_MDL7*
|
|
|
|
|
szCurrent += pcHeader->bones_num * pcHeader->bone_stc_size;
|
|
|
|
|
sharedData.apcOutBones = this->LoadBones_3DGS_MDL7();
|
|
|
|
|
|
|
|
|
|
// vector to held all created meshes
|
|
|
|
|
std::vector<aiMesh*>* avOutList;
|
|
|
|
|
|
|
|
|
|
// 3 meshes per group - that should be OK for most models
|
|
|
|
|
avOutList = new std::vector<aiMesh*>[pcHeader->groups_num];
|
|
|
|
|
for (uint32_t i = 0; i < pcHeader->groups_num;++i)
|
|
|
|
|
avOutList[i].reserve(3);
|
|
|
|
|
|
|
|
|
|
// buffer to held the names of all groups in the file
|
|
|
|
|
char* aszGroupNameBuffer = new char[AI_MDL7_MAX_GROUPNAMESIZE*pcHeader->groups_num];
|
|
|
|
|
|
|
|
|
|
// read all groups
|
|
|
|
|
for (unsigned int iGroup = 0; iGroup < (unsigned int)pcHeader->groups_num;++iGroup)
|
|
|
|
|
{
|
|
|
|
|
MDL::IntGroupInfo_MDL7 groupInfo((const MDL::Group_MDL7*)szCurrent,iGroup);
|
|
|
|
|
szCurrent = (const unsigned char*)(groupInfo.pcGroup+1);
|
|
|
|
|
|
|
|
|
|
VALIDATE_FILE_SIZE(szCurrent);
|
|
|
|
|
|
|
|
|
|
if (1 != groupInfo.pcGroup->typ)
|
|
|
|
|
{
|
|
|
|
|
// Not a triangle-based mesh
|
|
|
|
|
DefaultLogger::get()->warn("[3DGS MDL7] Mesh group is not basing on"
|
|
|
|
|
"triangles. Continuing happily");
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// store the name of the group
|
2008-08-06 23:01:38 +00:00
|
|
|
|
const unsigned int ofs = iGroup*AI_MDL7_MAX_GROUPNAMESIZE;
|
|
|
|
|
::memcpy(&aszGroupNameBuffer[ofs],
|
2008-06-22 10:09:26 +00:00
|
|
|
|
groupInfo.pcGroup->name,AI_MDL7_MAX_GROUPNAMESIZE);
|
|
|
|
|
|
2008-08-06 23:01:38 +00:00
|
|
|
|
// make sure '\0' is at the end
|
|
|
|
|
aszGroupNameBuffer[ofs+AI_MDL7_MAX_GROUPNAMESIZE-1] = '\0';
|
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// read all skins
|
|
|
|
|
sharedData.pcMats.reserve(sharedData.pcMats.size() + groupInfo.pcGroup->numskins);
|
|
|
|
|
sharedData.abNeedMaterials.resize(sharedData.abNeedMaterials.size() +
|
|
|
|
|
groupInfo.pcGroup->numskins,false);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
for (unsigned int iSkin = 0; iSkin < (unsigned int)groupInfo.pcGroup->numskins;++iSkin)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
this->ParseSkinLump_3DGS_MDL7(szCurrent,&szCurrent,sharedData.pcMats);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// if we have absolutely no skin loaded we need to generate a default material
|
|
|
|
|
if (sharedData.pcMats.empty())
|
|
|
|
|
{
|
|
|
|
|
const int iMode = (int)aiShadingMode_Gouraud;
|
|
|
|
|
sharedData.pcMats.push_back(new MaterialHelper());
|
|
|
|
|
MaterialHelper* pcHelper = (MaterialHelper*)sharedData.pcMats[0];
|
|
|
|
|
pcHelper->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
aiColor3D clr;
|
|
|
|
|
clr.b = clr.g = clr.r = 0.6f;
|
|
|
|
|
pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_DIFFUSE);
|
|
|
|
|
pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_SPECULAR);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
clr.b = clr.g = clr.r = 0.05f;
|
|
|
|
|
pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_AMBIENT);
|
|
|
|
|
|
|
|
|
|
aiString szName;
|
|
|
|
|
szName.Set(AI_DEFAULT_MATERIAL_NAME);
|
|
|
|
|
pcHelper->AddProperty(&szName,AI_MATKEY_NAME);
|
2008-08-06 23:01:38 +00:00
|
|
|
|
|
|
|
|
|
sharedData.abNeedMaterials.resize(1,false);
|
2008-06-22 10:09:26 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// now get a pointer to all texture coords in the group
|
|
|
|
|
groupInfo.pcGroupUVs = (const MDL::TexCoord_MDL7*)szCurrent;
|
|
|
|
|
szCurrent += pcHeader->skinpoint_stc_size * groupInfo.pcGroup->num_stpts;
|
|
|
|
|
|
|
|
|
|
// now get a pointer to all triangle in the group
|
|
|
|
|
groupInfo.pcGroupTris = (const MDL::Triangle_MDL7*)szCurrent;
|
|
|
|
|
szCurrent += pcHeader->triangle_stc_size * groupInfo.pcGroup->numtris;
|
|
|
|
|
|
|
|
|
|
// now get a pointer to all vertices in the group
|
|
|
|
|
groupInfo.pcGroupVerts = (const MDL::Vertex_MDL7*)szCurrent;
|
|
|
|
|
szCurrent += pcHeader->mainvertex_stc_size * groupInfo.pcGroup->numverts;
|
|
|
|
|
|
|
|
|
|
VALIDATE_FILE_SIZE(szCurrent);
|
|
|
|
|
|
|
|
|
|
MDL::IntSplittedGroupData_MDL7 splittedGroupData(sharedData,avOutList[iGroup]);
|
2008-08-06 23:01:38 +00:00
|
|
|
|
MDL::IntGroupData_MDL7 groupData;
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (groupInfo.pcGroup->numtris && groupInfo.pcGroup->numverts)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// build output vectors
|
|
|
|
|
const unsigned int iNumVertices = groupInfo.pcGroup->numtris*3;
|
|
|
|
|
groupData.vPositions.resize(iNumVertices);
|
|
|
|
|
groupData.vNormals.resize(iNumVertices);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (sharedData.apcOutBones)groupData.aiBones.resize(iNumVertices,0xffffffff);
|
|
|
|
|
|
|
|
|
|
// it is also possible that there are 0 UV coordinate sets
|
|
|
|
|
if (groupInfo.pcGroup->num_stpts)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
groupData.vTextureCoords1.resize(iNumVertices,aiVector3D());
|
|
|
|
|
|
|
|
|
|
// check whether the triangle data structure is large enough
|
|
|
|
|
// to contain a second UV coodinate set
|
|
|
|
|
if (pcHeader->triangle_stc_size >= AI_MDL7_TRIANGLE_STD_SIZE_TWO_UV)
|
|
|
|
|
{
|
|
|
|
|
groupData.vTextureCoords2.resize(iNumVertices,aiVector3D());
|
|
|
|
|
groupData.bNeed2UV = true;
|
|
|
|
|
}
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
groupData.pcFaces = new MDL::IntFace_MDL7[groupInfo.pcGroup->numtris];
|
|
|
|
|
|
|
|
|
|
// read all faces into the preallocated arrays
|
|
|
|
|
this->ReadFaces_3DGS_MDL7(groupInfo, groupData);
|
|
|
|
|
|
|
|
|
|
// sort by materials
|
|
|
|
|
this->SortByMaterials_3DGS_MDL7(groupInfo, groupData,
|
|
|
|
|
splittedGroupData);
|
|
|
|
|
|
|
|
|
|
for (unsigned int qq = 0; qq < sharedData.pcMats.size();++qq)
|
|
|
|
|
{
|
|
|
|
|
if (!splittedGroupData.aiSplit[qq]->empty())
|
|
|
|
|
sharedData.abNeedMaterials[qq] = true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// now generate output meshes
|
|
|
|
|
this->GenerateOutputMeshes_3DGS_MDL7(groupData,
|
|
|
|
|
splittedGroupData);
|
|
|
|
|
}
|
|
|
|
|
else DefaultLogger::get()->warn("[3DGS MDL7] Mesh group consists of 0 "
|
|
|
|
|
"vertices or faces. It will be skipped.");
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// process all frames
|
2008-08-06 23:01:38 +00:00
|
|
|
|
if(!ProcessFrames_3DGS_MDL7(groupInfo,groupData, sharedData,szCurrent,&szCurrent))
|
2008-06-22 10:09:26 +00:00
|
|
|
|
{
|
|
|
|
|
break;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
|
|
|
|
|
// generate a nodegraph and subnodes for each group
|
|
|
|
|
this->pScene->mRootNode = new aiNode();
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// now we need to build a final mesh list
|
2008-06-22 10:09:26 +00:00
|
|
|
|
for (uint32_t i = 0; i < pcHeader->groups_num;++i)
|
|
|
|
|
{
|
|
|
|
|
this->pScene->mNumMeshes += (unsigned int)avOutList[i].size();
|
|
|
|
|
}
|
|
|
|
|
this->pScene->mMeshes = new aiMesh*[this->pScene->mNumMeshes];
|
|
|
|
|
{
|
|
|
|
|
unsigned int p = 0,q = 0;
|
|
|
|
|
for (uint32_t i = 0; i < pcHeader->groups_num;++i)
|
|
|
|
|
{
|
|
|
|
|
for (unsigned int a = 0; a < avOutList[i].size();++a)
|
|
|
|
|
{
|
|
|
|
|
this->pScene->mMeshes[p++] = avOutList[i][a];
|
|
|
|
|
}
|
|
|
|
|
if (!avOutList[i].empty())++this->pScene->mRootNode->mNumChildren;
|
|
|
|
|
}
|
|
|
|
|
// we will later need an extra node to serve as parent for all bones
|
|
|
|
|
if (sharedData.apcOutBones)++this->pScene->mRootNode->mNumChildren;
|
|
|
|
|
this->pScene->mRootNode->mChildren = new aiNode*[this->pScene->mRootNode->mNumChildren];
|
|
|
|
|
p = 0;
|
|
|
|
|
for (uint32_t i = 0; i < pcHeader->groups_num;++i)
|
|
|
|
|
{
|
|
|
|
|
if (avOutList[i].empty())continue;
|
|
|
|
|
|
|
|
|
|
aiNode* const pcNode = this->pScene->mRootNode->mChildren[p] = new aiNode();
|
|
|
|
|
pcNode->mNumMeshes = (unsigned int)avOutList[i].size();
|
|
|
|
|
pcNode->mMeshes = new unsigned int[pcNode->mNumMeshes];
|
|
|
|
|
pcNode->mParent = this->pScene->mRootNode;
|
|
|
|
|
for (unsigned int a = 0; a < pcNode->mNumMeshes;++a)
|
|
|
|
|
pcNode->mMeshes[a] = q + a;
|
|
|
|
|
q += (unsigned int)avOutList[i].size();
|
|
|
|
|
|
|
|
|
|
// setup the name of the node
|
|
|
|
|
char* const szBuffer = &aszGroupNameBuffer[i*AI_MDL7_MAX_GROUPNAMESIZE];
|
|
|
|
|
if ('\0' == *szBuffer)
|
|
|
|
|
{
|
|
|
|
|
#if _MSC_VER >= 1400
|
|
|
|
|
::sprintf_s(szBuffer,AI_MDL7_MAX_GROUPNAMESIZE,"Group_%i",p);
|
|
|
|
|
#else
|
|
|
|
|
::sprintf(szBuffer,"Group_%i",p);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
::strcpy(pcNode->mName.data,szBuffer);
|
|
|
|
|
pcNode->mName.length = ::strlen(szBuffer);
|
|
|
|
|
++p;
|
|
|
|
|
}
|
|
|
|
|
}
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// if there is only one root node with a single child we can optimize it a bit ...
|
|
|
|
|
if (1 == this->pScene->mRootNode->mNumChildren && !sharedData.apcOutBones)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
aiNode* pcOldRoot = this->pScene->mRootNode;
|
|
|
|
|
this->pScene->mRootNode = pcOldRoot->mChildren[0];
|
|
|
|
|
pcOldRoot->mChildren[0] = NULL;
|
|
|
|
|
delete pcOldRoot;
|
|
|
|
|
|
|
|
|
|
this->pScene->mRootNode->mParent = NULL;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
else this->pScene->mRootNode->mName.Set("mesh_root");
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
delete[] avOutList;
|
|
|
|
|
delete[] aszGroupNameBuffer;
|
2008-08-06 23:01:38 +00:00
|
|
|
|
AI_DEBUG_INVALIDATE_PTR(avOutList);
|
|
|
|
|
AI_DEBUG_INVALIDATE_PTR(aszGroupNameBuffer);
|
2008-06-22 10:09:26 +00:00
|
|
|
|
|
|
|
|
|
// build a final material list.
|
|
|
|
|
this->CopyMaterials_3DGS_MDL7(sharedData);
|
|
|
|
|
|
|
|
|
|
// handle materials that are just referencing another material correctly
|
|
|
|
|
this->HandleMaterialReferences_3DGS_MDL7();
|
|
|
|
|
|
|
|
|
|
// generate output bone animations and add all bones to the scenegraph
|
|
|
|
|
if (sharedData.apcOutBones)
|
|
|
|
|
{
|
|
|
|
|
// this step adds empty dummy bones to the nodegraph
|
|
|
|
|
// insert another dummy node to avoid name conflicts
|
|
|
|
|
aiNode* const pc = this->pScene->mRootNode->mChildren[
|
|
|
|
|
this->pScene->mRootNode->mNumChildren-1] = new aiNode();
|
|
|
|
|
|
|
|
|
|
pc->mName.Set("skeleton_root");
|
|
|
|
|
|
|
|
|
|
// add bones to the nodegraph
|
|
|
|
|
this->AddBonesToNodeGraph_3DGS_MDL7((const Assimp::MDL::IntBone_MDL7 **)
|
|
|
|
|
sharedData.apcOutBones,pc,0xffff);
|
|
|
|
|
|
|
|
|
|
// this steps build a valid output animation
|
|
|
|
|
this->BuildOutputAnims_3DGS_MDL7((const Assimp::MDL::IntBone_MDL7 **)
|
|
|
|
|
sharedData.apcOutBones);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
|
void MDLImporter::CopyMaterials_3DGS_MDL7(MDL::IntSharedData_MDL7 &shared)
|
|
|
|
|
{
|
|
|
|
|
unsigned int iNewNumMaterials = 0;
|
|
|
|
|
unsigned int p = 0;
|
|
|
|
|
for (;p < shared.pcMats.size();++p)
|
|
|
|
|
if (shared.abNeedMaterials[p])++iNewNumMaterials;
|
|
|
|
|
|
|
|
|
|
this->pScene->mMaterials = new aiMaterial*[iNewNumMaterials];
|
|
|
|
|
if ((unsigned int)shared.pcMats.size() == iNewNumMaterials)
|
|
|
|
|
{
|
|
|
|
|
this->pScene->mNumMaterials = (unsigned int)shared.pcMats.size();
|
|
|
|
|
for (unsigned int i = 0; i < this->pScene->mNumMaterials;++i)
|
|
|
|
|
this->pScene->mMaterials[i] = shared.pcMats[i];
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
p = 0;
|
|
|
|
|
const unsigned int iMSB = 0x1u << (sizeof (unsigned int)*8-1);
|
|
|
|
|
for (unsigned int i = 0; i < (unsigned int)shared.pcMats.size();++i)
|
|
|
|
|
{
|
|
|
|
|
if (!shared.abNeedMaterials[i])
|
|
|
|
|
{
|
|
|
|
|
// destruction is done by the destructor of sh
|
|
|
|
|
delete shared.pcMats[i];
|
2008-08-06 23:01:38 +00:00
|
|
|
|
AI_DEBUG_INVALIDATE_PTR(shared.pcMats[i]);
|
2008-06-22 10:09:26 +00:00
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
this->pScene->mMaterials[p] = shared.pcMats[i];
|
|
|
|
|
|
|
|
|
|
if (p != i)
|
|
|
|
|
{
|
|
|
|
|
// replace the material index and MSB in all material
|
|
|
|
|
// indices that have been replaced to make sure they won't be
|
|
|
|
|
// replaced again (this won't work if there are more than
|
|
|
|
|
// 2^31 materials in the model - but this shouldn't care :-)).
|
|
|
|
|
for (unsigned int qq = 0; qq < this->pScene->mNumMeshes;++qq)
|
|
|
|
|
{
|
|
|
|
|
aiMesh* const pcMesh = this->pScene->mMeshes[qq];
|
|
|
|
|
if (i == pcMesh->mMaterialIndex)
|
|
|
|
|
{
|
|
|
|
|
pcMesh->mMaterialIndex = p | iMSB;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
++p;
|
|
|
|
|
}
|
|
|
|
|
this->pScene->mNumMaterials = iNewNumMaterials;
|
|
|
|
|
|
|
|
|
|
// Remove the MSB from all material indices
|
|
|
|
|
for (unsigned int qq = 0; qq < this->pScene->mNumMeshes;++qq)
|
|
|
|
|
{
|
|
|
|
|
this->pScene->mMeshes[qq]->mMaterialIndex &= ~iMSB;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
|
void MDLImporter::HandleMaterialReferences_3DGS_MDL7()
|
|
|
|
|
{
|
2008-05-09 17:24:28 +00:00
|
|
|
|
// search for referrer materials
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// (there is no test file but Conitec's docs say it is supported ... :cry: )
|
2008-05-09 17:24:28 +00:00
|
|
|
|
for (unsigned int i = 0; i < this->pScene->mNumMaterials;++i)
|
|
|
|
|
{
|
|
|
|
|
int iIndex = 0;
|
|
|
|
|
if (AI_SUCCESS == aiGetMaterialInteger(this->pScene->mMaterials[i],
|
2008-06-22 10:09:26 +00:00
|
|
|
|
AI_MDL7_REFERRER_MATERIAL, &iIndex) )
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
for (unsigned int a = 0; a < this->pScene->mNumMeshes;++a)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
aiMesh* const pcMesh = this->pScene->mMeshes[a];
|
|
|
|
|
if (i == pcMesh->mMaterialIndex)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
pcMesh->mMaterialIndex = iIndex;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// collapse the rest of the array
|
|
|
|
|
delete this->pScene->mMaterials[i];
|
|
|
|
|
for (unsigned int pp = i; pp < this->pScene->mNumMaterials-1;++pp)
|
|
|
|
|
{
|
|
|
|
|
this->pScene->mMaterials[pp] = this->pScene->mMaterials[pp+1];
|
|
|
|
|
for (unsigned int a = 0; a < this->pScene->mNumMeshes;++a)
|
|
|
|
|
{
|
|
|
|
|
aiMesh* const pcMesh = this->pScene->mMeshes[a];
|
|
|
|
|
if (pcMesh->mMaterialIndex > i)--pcMesh->mMaterialIndex;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
--this->pScene->mNumMaterials;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
|
void MDLImporter::ParseBoneTrafoKeys_3DGS_MDL7(
|
|
|
|
|
const MDL::IntGroupInfo_MDL7& groupInfo,
|
|
|
|
|
IntFrameInfo_MDL7& frame,
|
|
|
|
|
MDL::IntSharedData_MDL7& shared)
|
|
|
|
|
{
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// get a pointer to the header ...
|
|
|
|
|
const MDL::Header_MDL7* const pcHeader = (const MDL::Header_MDL7*)this->mBuffer;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// only the first group contains bone animation keys
|
|
|
|
|
if (frame.pcFrame->transmatrix_count)
|
|
|
|
|
{
|
|
|
|
|
if (!groupInfo.iIndex)
|
|
|
|
|
{
|
|
|
|
|
// skip all frames vertices. We can't support them
|
|
|
|
|
const MDL::BoneTransform_MDL7* pcBoneTransforms = (const MDL::BoneTransform_MDL7*)
|
|
|
|
|
(((const char*)frame.pcFrame) + pcHeader->frame_stc_size +
|
|
|
|
|
frame.pcFrame->vertices_count * pcHeader->framevertex_stc_size);
|
|
|
|
|
|
|
|
|
|
// read all transformation matrices
|
|
|
|
|
for (unsigned int iTrafo = 0; iTrafo < frame.pcFrame->transmatrix_count;++iTrafo)
|
|
|
|
|
{
|
|
|
|
|
if(pcBoneTransforms->bone_index >= pcHeader->bones_num)
|
|
|
|
|
{
|
|
|
|
|
DefaultLogger::get()->warn("Index overflow in frame area. "
|
|
|
|
|
"Unable to parse this bone transformation");
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
this->AddAnimationBoneTrafoKey_3DGS_MDL7(frame.iIndex,
|
|
|
|
|
pcBoneTransforms,shared.apcOutBones);
|
|
|
|
|
}
|
|
|
|
|
pcBoneTransforms = (const MDL::BoneTransform_MDL7*)(
|
|
|
|
|
(const char*)pcBoneTransforms + pcHeader->bonetrans_stc_size);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
DefaultLogger::get()->warn("Found animation keyframes "
|
|
|
|
|
"in a group that is not the first. They will be igored, "
|
|
|
|
|
"the format specification says this should not occur");
|
|
|
|
|
}
|
|
|
|
|
}
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
2008-06-22 10:09:26 +00:00
|
|
|
|
void MDLImporter::AddBonesToNodeGraph_3DGS_MDL7(const MDL::IntBone_MDL7** apcBones,
|
|
|
|
|
aiNode* pcParent,uint16_t iParentIndex)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
ai_assert(NULL != apcBones && NULL != pcParent);
|
|
|
|
|
|
|
|
|
|
// get a pointer to the header ...
|
|
|
|
|
const MDL::Header_MDL7* const pcHeader = (const MDL::Header_MDL7*)this->mBuffer;
|
2008-05-22 10:20:31 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
const MDL::IntBone_MDL7** apcBones2 = apcBones;
|
|
|
|
|
for (uint32_t i = 0; i < pcHeader->bones_num;++i)
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
const MDL::IntBone_MDL7* const pcBone = *apcBones2++;
|
|
|
|
|
if (pcBone->iParent == iParentIndex)++pcParent->mNumChildren;
|
|
|
|
|
}
|
|
|
|
|
pcParent->mChildren = new aiNode*[pcParent->mNumChildren];
|
|
|
|
|
unsigned int qq = 0;
|
|
|
|
|
for (uint32_t i = 0; i < pcHeader->bones_num;++i)
|
|
|
|
|
{
|
|
|
|
|
const MDL::IntBone_MDL7* const pcBone = *apcBones++;
|
|
|
|
|
if (pcBone->iParent != iParentIndex)continue;
|
|
|
|
|
|
|
|
|
|
aiNode* pcNode = pcParent->mChildren[qq++] = new aiNode();
|
|
|
|
|
pcNode->mName = aiString( pcBone->mName );
|
|
|
|
|
|
|
|
|
|
this->AddBonesToNodeGraph_3DGS_MDL7(apcBones,pcNode,i);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
|
void MDLImporter::BuildOutputAnims_3DGS_MDL7(
|
|
|
|
|
const MDL::IntBone_MDL7** apcBonesOut)
|
|
|
|
|
{
|
|
|
|
|
ai_assert(NULL != apcBonesOut);
|
|
|
|
|
|
|
|
|
|
// get a pointer to the header ...
|
|
|
|
|
const MDL::Header_MDL7* const pcHeader = (const MDL::Header_MDL7*)this->mBuffer;
|
|
|
|
|
|
|
|
|
|
// one animation ...
|
|
|
|
|
aiAnimation* pcAnim = new aiAnimation();
|
|
|
|
|
for (uint32_t i = 0; i < pcHeader->bones_num;++i)
|
|
|
|
|
{
|
|
|
|
|
if (!apcBonesOut[i]->pkeyPositions.empty())
|
|
|
|
|
{
|
|
|
|
|
// get the last frame ... (needn't be equal to pcHeader->frames_num)
|
|
|
|
|
for (size_t qq = 0; qq < apcBonesOut[i]->pkeyPositions.size();++qq)
|
|
|
|
|
{
|
|
|
|
|
pcAnim->mDuration = std::max(pcAnim->mDuration, (double)
|
|
|
|
|
apcBonesOut[i]->pkeyPositions[qq].mTime);
|
|
|
|
|
}
|
|
|
|
|
++pcAnim->mNumBones;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (pcAnim->mDuration)
|
|
|
|
|
{
|
|
|
|
|
pcAnim->mBones = new aiBoneAnim*[pcAnim->mNumBones];
|
|
|
|
|
|
|
|
|
|
unsigned int iCnt = 0;
|
|
|
|
|
for (uint32_t i = 0; i < pcHeader->bones_num;++i)
|
|
|
|
|
{
|
|
|
|
|
if (!apcBonesOut[i]->pkeyPositions.empty())
|
|
|
|
|
{
|
|
|
|
|
const MDL::IntBone_MDL7* const intBone = apcBonesOut[i];
|
|
|
|
|
|
|
|
|
|
aiBoneAnim* const pcBoneAnim = pcAnim->mBones[iCnt++] = new aiBoneAnim();
|
|
|
|
|
pcBoneAnim->mBoneName = aiString( intBone->mName );
|
|
|
|
|
|
|
|
|
|
// allocate enough storahe for all keys
|
|
|
|
|
pcBoneAnim->mNumPositionKeys = (unsigned int)intBone->pkeyPositions.size();
|
|
|
|
|
pcBoneAnim->mNumScalingKeys = (unsigned int)intBone->pkeyPositions.size();
|
|
|
|
|
pcBoneAnim->mNumRotationKeys = (unsigned int)intBone->pkeyPositions.size();
|
|
|
|
|
|
|
|
|
|
pcBoneAnim->mPositionKeys = new aiVectorKey[pcBoneAnim->mNumPositionKeys];
|
|
|
|
|
pcBoneAnim->mScalingKeys = new aiVectorKey[pcBoneAnim->mNumPositionKeys];
|
|
|
|
|
pcBoneAnim->mRotationKeys = new aiQuatKey[pcBoneAnim->mNumPositionKeys];
|
|
|
|
|
|
|
|
|
|
// copy all keys
|
|
|
|
|
for (unsigned int qq = 0; qq < pcBoneAnim->mNumPositionKeys;++qq)
|
|
|
|
|
{
|
|
|
|
|
pcBoneAnim->mPositionKeys[qq] = intBone->pkeyPositions[qq];
|
|
|
|
|
pcBoneAnim->mScalingKeys[qq] = intBone->pkeyScalings[qq];
|
|
|
|
|
pcBoneAnim->mRotationKeys[qq] = intBone->pkeyRotations[qq];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// store the output animation
|
|
|
|
|
this->pScene->mNumAnimations = 1;
|
|
|
|
|
this->pScene->mAnimations = new aiAnimation*[1];
|
|
|
|
|
this->pScene->mAnimations[0] = pcAnim;
|
|
|
|
|
}
|
|
|
|
|
else delete pcAnim;
|
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
|
void MDLImporter::AddAnimationBoneTrafoKey_3DGS_MDL7(unsigned int iTrafo,
|
|
|
|
|
const MDL::BoneTransform_MDL7* pcBoneTransforms,
|
|
|
|
|
MDL::IntBone_MDL7** apcBonesOut)
|
|
|
|
|
{
|
|
|
|
|
ai_assert(NULL != pcBoneTransforms);
|
|
|
|
|
ai_assert(NULL != apcBonesOut);
|
|
|
|
|
|
|
|
|
|
// first .. get the transformation matrix
|
|
|
|
|
aiMatrix4x4 mTransform;
|
|
|
|
|
mTransform.a1 = pcBoneTransforms->m[0];
|
|
|
|
|
mTransform.b1 = pcBoneTransforms->m[1];
|
|
|
|
|
mTransform.c1 = pcBoneTransforms->m[2];
|
|
|
|
|
mTransform.d1 = pcBoneTransforms->m[3];
|
|
|
|
|
|
|
|
|
|
mTransform.a2 = pcBoneTransforms->m[4];
|
|
|
|
|
mTransform.b2 = pcBoneTransforms->m[5];
|
|
|
|
|
mTransform.c2 = pcBoneTransforms->m[6];
|
|
|
|
|
mTransform.d2 = pcBoneTransforms->m[7];
|
|
|
|
|
|
|
|
|
|
mTransform.a3 = pcBoneTransforms->m[8];
|
|
|
|
|
mTransform.b3 = pcBoneTransforms->m[9];
|
|
|
|
|
mTransform.c3 = pcBoneTransforms->m[10];
|
|
|
|
|
mTransform.d3 = pcBoneTransforms->m[11];
|
|
|
|
|
|
|
|
|
|
// now decompose the transformation matrix into separate
|
|
|
|
|
// scaling, rotation and translation
|
|
|
|
|
aiVectorKey vScaling,vPosition;
|
|
|
|
|
aiQuatKey qRotation;
|
|
|
|
|
|
|
|
|
|
// FIXME: Decompose will assert in debug builds if the
|
|
|
|
|
// matrix is invalid ...
|
|
|
|
|
mTransform.Decompose(vScaling.mValue,qRotation.mValue,vPosition.mValue);
|
|
|
|
|
|
|
|
|
|
// now generate keys
|
|
|
|
|
vScaling.mTime = qRotation.mTime = vPosition.mTime = (double)iTrafo;
|
|
|
|
|
|
|
|
|
|
// add the keys to the bone
|
|
|
|
|
MDL::IntBone_MDL7* const pcBoneOut = apcBonesOut[pcBoneTransforms->bone_index];
|
|
|
|
|
pcBoneOut->pkeyPositions.push_back ( vPosition );
|
|
|
|
|
pcBoneOut->pkeyScalings.push_back ( vScaling );
|
|
|
|
|
pcBoneOut->pkeyRotations.push_back ( qRotation );
|
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
|
void MDLImporter::GenerateOutputMeshes_3DGS_MDL7(
|
|
|
|
|
MDL::IntGroupData_MDL7& groupData,
|
|
|
|
|
MDL::IntSplittedGroupData_MDL7& splittedGroupData)
|
|
|
|
|
{
|
|
|
|
|
const MDL::IntSharedData_MDL7& shared = splittedGroupData.shared;
|
|
|
|
|
|
|
|
|
|
// get a pointer to the header ...
|
|
|
|
|
const MDL::Header_MDL7* const pcHeader = (const MDL::Header_MDL7*)this->mBuffer;
|
|
|
|
|
const unsigned int iNumOutBones = pcHeader->bones_num;
|
|
|
|
|
|
|
|
|
|
for (std::vector<MaterialHelper*>::size_type i = 0; i < shared.pcMats.size();++i)
|
|
|
|
|
{
|
|
|
|
|
if (!splittedGroupData.aiSplit[i]->empty())
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
|
|
|
|
// allocate the output mesh
|
|
|
|
|
aiMesh* pcMesh = new aiMesh();
|
2008-06-22 10:09:26 +00:00
|
|
|
|
pcMesh->mMaterialIndex = (unsigned int)i;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// allocate output storage
|
2008-06-22 10:09:26 +00:00
|
|
|
|
pcMesh->mNumFaces = (unsigned int)splittedGroupData.aiSplit[i]->size();
|
2008-05-09 17:24:28 +00:00
|
|
|
|
pcMesh->mFaces = new aiFace[pcMesh->mNumFaces];
|
|
|
|
|
|
|
|
|
|
pcMesh->mNumVertices = pcMesh->mNumFaces*3;
|
|
|
|
|
pcMesh->mVertices = new aiVector3D[pcMesh->mNumVertices];
|
|
|
|
|
pcMesh->mNormals = new aiVector3D[pcMesh->mNumVertices];
|
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (!groupData.vTextureCoords1.empty())
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
pcMesh->mNumUVComponents[0] = 2;
|
|
|
|
|
pcMesh->mTextureCoords[0] = new aiVector3D[pcMesh->mNumVertices];
|
|
|
|
|
if (!groupData.vTextureCoords2.empty())
|
|
|
|
|
{
|
|
|
|
|
pcMesh->mNumUVComponents[1] = 2;
|
|
|
|
|
pcMesh->mTextureCoords[1] = new aiVector3D[pcMesh->mNumVertices];
|
|
|
|
|
}
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// iterate through all faces and build an unique set of vertices
|
|
|
|
|
unsigned int iCurrent = 0;
|
|
|
|
|
for (unsigned int iFace = 0; iFace < pcMesh->mNumFaces;++iFace)
|
|
|
|
|
{
|
|
|
|
|
pcMesh->mFaces[iFace].mNumIndices = 3;
|
|
|
|
|
pcMesh->mFaces[iFace].mIndices = new unsigned int[3];
|
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
unsigned int iSrcFace = splittedGroupData.aiSplit[i]->operator[](iFace);
|
|
|
|
|
const MDL::IntFace_MDL7& oldFace = groupData.pcFaces[iSrcFace];
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// iterate through all face indices
|
|
|
|
|
for (unsigned int c = 0; c < 3;++c)
|
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
const uint32_t iIndex = oldFace.mIndices[c];
|
|
|
|
|
pcMesh->mVertices[iCurrent] = groupData.vPositions[iIndex];
|
|
|
|
|
pcMesh->mNormals[iCurrent] = groupData.vNormals[iIndex];
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
if (!groupData.vTextureCoords1.empty())
|
2008-05-09 17:24:28 +00:00
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
pcMesh->mTextureCoords[0][iCurrent] = groupData.vTextureCoords1[iIndex];
|
|
|
|
|
if (!groupData.vTextureCoords2.empty())
|
|
|
|
|
{
|
|
|
|
|
pcMesh->mTextureCoords[1][iCurrent] = groupData.vTextureCoords2[iIndex];
|
|
|
|
|
}
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
2008-06-22 10:09:26 +00:00
|
|
|
|
pcMesh->mFaces[iFace].mIndices[c] = iCurrent++;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-06-22 10:09:26 +00:00
|
|
|
|
// if we have bones in the mesh we'll need to generate
|
|
|
|
|
// proper vertex weights for them
|
|
|
|
|
if (!groupData.aiBones.empty())
|
|
|
|
|
{
|
|
|
|
|
std::vector<std::vector<unsigned int> > aaiVWeightList;
|
|
|
|
|
aaiVWeightList.resize(iNumOutBones);
|
|
|
|
|
|
|
|
|
|
int iCurrent = 0;
|
|
|
|
|
for (unsigned int iFace = 0; iFace < pcMesh->mNumFaces;++iFace)
|
|
|
|
|
{
|
|
|
|
|
unsigned int iSrcFace = splittedGroupData.aiSplit[i]->operator[](iFace);
|
|
|
|
|
const MDL::IntFace_MDL7& oldFace = groupData.pcFaces[iSrcFace];
|
|
|
|
|
|
|
|
|
|
// iterate through all face indices
|
|
|
|
|
for (unsigned int c = 0; c < 3;++c)
|
|
|
|
|
{
|
|
|
|
|
unsigned int iBone = groupData.aiBones[ oldFace.mIndices[c] ];
|
|
|
|
|
if (0xffffffff != iBone)
|
|
|
|
|
{
|
|
|
|
|
if (iBone >= iNumOutBones)
|
|
|
|
|
{
|
|
|
|
|
DefaultLogger::get()->error("Bone index overflow. "
|
|
|
|
|
"The bone index of a vertex exceeds the allowed range. ");
|
|
|
|
|
iBone = iNumOutBones-1;
|
|
|
|
|
}
|
|
|
|
|
aaiVWeightList[ iBone ].push_back ( iCurrent );
|
|
|
|
|
}
|
|
|
|
|
++iCurrent;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// now check which bones are required ...
|
|
|
|
|
for (std::vector<std::vector<unsigned int> >::const_iterator
|
|
|
|
|
kimmi = aaiVWeightList.begin();
|
|
|
|
|
kimmi != aaiVWeightList.end();++kimmi)
|
|
|
|
|
{
|
|
|
|
|
if (!(*kimmi).empty())++pcMesh->mNumBones;
|
|
|
|
|
}
|
|
|
|
|
pcMesh->mBones = new aiBone*[pcMesh->mNumBones];
|
|
|
|
|
iCurrent = 0;
|
|
|
|
|
for (std::vector<std::vector<unsigned int> >::const_iterator
|
|
|
|
|
kimmi = aaiVWeightList.begin();
|
|
|
|
|
kimmi != aaiVWeightList.end();++kimmi,++iCurrent)
|
|
|
|
|
{
|
|
|
|
|
if ((*kimmi).empty())continue;
|
|
|
|
|
|
|
|
|
|
// seems we'll need this node
|
|
|
|
|
aiBone* pcBone = pcMesh->mBones[ iCurrent ] = new aiBone();
|
|
|
|
|
pcBone->mName = aiString(shared.apcOutBones[ iCurrent ]->mName);
|
|
|
|
|
pcBone->mOffsetMatrix = shared.apcOutBones[ iCurrent ]->mOffsetMatrix;
|
|
|
|
|
|
|
|
|
|
// setup vertex weights
|
|
|
|
|
pcBone->mNumWeights = (unsigned int)(*kimmi).size();
|
|
|
|
|
pcBone->mWeights = new aiVertexWeight[pcBone->mNumWeights];
|
|
|
|
|
|
|
|
|
|
for (unsigned int weight = 0; weight < pcBone->mNumWeights;++weight)
|
|
|
|
|
{
|
|
|
|
|
pcBone->mWeights[weight].mVertexId = (*kimmi)[weight];
|
|
|
|
|
pcBone->mWeights[weight].mWeight = 1.0f;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2008-05-09 17:24:28 +00:00
|
|
|
|
// add the mesh to the list of output meshes
|
2008-06-22 10:09:26 +00:00
|
|
|
|
splittedGroupData.avOutList.push_back(pcMesh);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
2008-06-22 10:09:26 +00:00
|
|
|
|
void MDLImporter::JoinSkins_3DGS_MDL7(
|
2008-05-09 17:24:28 +00:00
|
|
|
|
MaterialHelper* pcMat1,
|
|
|
|
|
MaterialHelper* pcMat2,
|
|
|
|
|
MaterialHelper* pcMatOut)
|
|
|
|
|
{
|
2008-06-22 10:09:26 +00:00
|
|
|
|
ai_assert(NULL != pcMat1 && NULL != pcMat2 && NULL != pcMatOut);
|
2008-05-09 17:24:28 +00:00
|
|
|
|
|
|
|
|
|
// first create a full copy of the first skin property set
|
|
|
|
|
// and assign it to the output material
|
|
|
|
|
MaterialHelper::CopyPropertyList(pcMatOut,pcMat1);
|
|
|
|
|
|
|
|
|
|
int iVal = 0;
|
|
|
|
|
pcMatOut->AddProperty<int>(&iVal,1,AI_MATKEY_UVWSRC_DIFFUSE(0));
|
|
|
|
|
|
|
|
|
|
// then extract the diffuse texture from the second skin,
|
|
|
|
|
// setup 1 as UV source and we have it
|
|
|
|
|
|
|
|
|
|
aiString sString;
|
|
|
|
|
if(AI_SUCCESS == aiGetMaterialString ( pcMat2, AI_MATKEY_TEXTURE_DIFFUSE(0),&sString ))
|
|
|
|
|
{
|
|
|
|
|
iVal = 1;
|
|
|
|
|
pcMatOut->AddProperty<int>(&iVal,1,AI_MATKEY_UVWSRC_DIFFUSE(1));
|
|
|
|
|
pcMatOut->AddProperty(&sString,AI_MATKEY_TEXTURE_DIFFUSE(1));
|
|
|
|
|
}
|
2008-05-22 10:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
|
|
|
void MDLImporter::InternReadFile_HL2( )
|
|
|
|
|
{
|
|
|
|
|
const MDL::Header_HL2* pcHeader = (const MDL::Header_HL2*)this->mBuffer;
|
2008-05-09 17:24:28 +00:00
|
|
|
|
}
|