assimp/code/AssetLib/MDL/MDLLoader.cpp

1985 lines
86 KiB
C++
Raw Normal View History

/*
---------------------------------------------------------------------------
Open Asset Import Library (assimp)
---------------------------------------------------------------------------
2022-01-10 20:13:43 +00:00
Copyright (c) 2006-2022, assimp team
2018-01-28 18:42:05 +00:00
All rights reserved.
2015-05-19 03:52:10 +00:00
Redistribution and use of this software in source and binary forms,
with or without modification, are permitted provided that the following
conditions are met:
* Redistributions of source code must retain the above
copyright notice, this list of conditions and the
following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other
materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products
derived from this software without specific prior
written permission of the assimp team.
2015-05-19 03:52:10 +00:00
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
2015-05-19 03:52:10 +00:00
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
2015-05-19 03:52:10 +00:00
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
2015-05-19 03:52:10 +00:00
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
/** @file MDLLoader.cpp
* @brief Implementation of the main parts of the MDL importer class
* *TODO* Cleanup and further testing of some parts necessary
*/
// internal headers
#ifndef ASSIMP_BUILD_NO_MDL_IMPORTER
#include "AssetLib/MDL/MDLLoader.h"
#include "AssetLib/MD2/MD2FileData.h"
#include "AssetLib/MDL/HalfLife/HL1MDLLoader.h"
#include "AssetLib/MDL/MDLDefaultColorMap.h"
#include <assimp/StringUtils.h>
2020-02-18 13:41:19 +00:00
#include <assimp/importerdesc.h>
#include <assimp/qnan.h>
2016-06-06 20:04:29 +00:00
#include <assimp/scene.h>
#include <assimp/DefaultLogger.hpp>
2020-02-18 13:41:19 +00:00
#include <assimp/IOSystem.hpp>
#include <assimp/Importer.hpp>
2016-06-06 20:04:29 +00:00
#include <memory>
using namespace Assimp;
static const aiImporterDesc desc = {
2015-05-19 03:57:13 +00:00
"Quake Mesh / 3D GameStudio Mesh Importer",
"",
"",
"",
aiImporterFlags_SupportBinaryFlavour,
0,
0,
7,
0,
"mdl"
};
// ------------------------------------------------------------------------------------------------
// Ugly stuff ... nevermind
2020-02-18 13:41:19 +00:00
#define _AI_MDL7_ACCESS(_data, _index, _limit, _type) \
(*((const _type *)(((const char *)_data) + _index * _limit)))
2020-02-18 13:41:19 +00:00
#define _AI_MDL7_ACCESS_PTR(_data, _index, _limit, _type) \
((BE_NCONST _type *)(((const char *)_data) + _index * _limit))
2020-02-18 13:41:19 +00:00
#define _AI_MDL7_ACCESS_VERT(_data, _index, _limit) \
_AI_MDL7_ACCESS(_data, _index, _limit, MDL::Vertex_MDL7)
// ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer
2020-02-18 13:41:19 +00:00
MDLImporter::MDLImporter() :
configFrameID(), mBuffer(), iGSFileVersion(), mIOHandler(nullptr), pScene(), iFileSize() {
2019-09-17 19:58:46 +00:00
// empty
}
// ------------------------------------------------------------------------------------------------
2015-05-19 03:52:10 +00:00
// Destructor, private as well
MDLImporter::~MDLImporter() = default;
// ------------------------------------------------------------------------------------------------
2015-05-19 03:52:10 +00:00
// Returns whether the class can handle the format of the given file.
bool MDLImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
static const uint32_t tokens[] = {
AI_MDL_MAGIC_NUMBER_LE_HL2a,
AI_MDL_MAGIC_NUMBER_LE_HL2b,
AI_MDL_MAGIC_NUMBER_LE_GS7,
AI_MDL_MAGIC_NUMBER_LE_GS5b,
AI_MDL_MAGIC_NUMBER_LE_GS5a,
AI_MDL_MAGIC_NUMBER_LE_GS4,
AI_MDL_MAGIC_NUMBER_LE_GS3,
AI_MDL_MAGIC_NUMBER_LE
};
return CheckMagicToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
}
// ------------------------------------------------------------------------------------------------
// Setup configuration properties
2020-02-18 13:41:19 +00:00
void MDLImporter::SetupProperties(const Importer *pImp) {
configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MDL_KEYFRAME, -1);
2015-05-19 03:57:13 +00:00
// The
// AI_CONFIG_IMPORT_MDL_KEYFRAME option overrides the
// AI_CONFIG_IMPORT_GLOBAL_KEYFRAME option.
2020-02-18 13:41:19 +00:00
if (static_cast<unsigned int>(-1) == configFrameID) {
configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME, 0);
2015-05-19 03:57:13 +00:00
}
2018-05-13 14:35:03 +00:00
// AI_CONFIG_IMPORT_MDL_COLORMAP - palette file
2020-02-18 13:41:19 +00:00
configPalette = pImp->GetPropertyString(AI_CONFIG_IMPORT_MDL_COLORMAP, "colormap.lmp");
// Read configuration specific to MDL (Half-Life 1).
mHL1ImportSettings.read_animations = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_ANIMATIONS, true);
if (mHL1ImportSettings.read_animations) {
mHL1ImportSettings.read_animation_events = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_ANIMATION_EVENTS, true);
mHL1ImportSettings.read_blend_controllers = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_BLEND_CONTROLLERS, true);
mHL1ImportSettings.read_sequence_transitions = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_SEQUENCE_TRANSITIONS, true);
}
mHL1ImportSettings.read_attachments = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_ATTACHMENTS, true);
mHL1ImportSettings.read_bone_controllers = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_BONE_CONTROLLERS, true);
mHL1ImportSettings.read_hitboxes = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_HITBOXES, true);
mHL1ImportSettings.read_misc_global_info = pImp->GetPropertyBool(AI_CONFIG_IMPORT_MDL_HL1_READ_MISC_GLOBAL_INFO, true);
}
// ------------------------------------------------------------------------------------------------
// Get a list of all supported extensions
2020-02-18 13:41:19 +00:00
const aiImporterDesc *MDLImporter::GetInfo() const {
2015-05-19 03:57:13 +00:00
return &desc;
}
// ------------------------------------------------------------------------------------------------
2015-05-19 03:52:10 +00:00
// Imports the given file into the given scene structure.
2020-02-18 13:41:19 +00:00
void MDLImporter::InternReadFile(const std::string &pFile,
aiScene *_pScene, IOSystem *pIOHandler) {
pScene = _pScene;
mIOHandler = pIOHandler;
std::unique_ptr<IOStream> file(pIOHandler->Open(pFile));
2015-05-19 03:57:13 +00:00
// Check whether we can read from the file
if (file == nullptr) {
throw DeadlyImportError("Failed to open MDL file ", pFile, ".");
2015-05-19 03:57:13 +00:00
}
// This should work for all other types of MDL files, too ...
// the HL1 sequence group header is one of the smallest, afaik
2015-05-19 03:57:13 +00:00
iFileSize = (unsigned int)file->FileSize();
2020-02-18 13:41:19 +00:00
if (iFileSize < sizeof(MDL::HalfLife::SequenceHeader_HL1)) {
throw DeadlyImportError("MDL File is too small.");
2015-05-19 03:57:13 +00:00
}
2020-02-18 13:41:19 +00:00
// delete the file buffer and cleanup.
auto DeleteBufferAndCleanup = [&]() {
if (mBuffer) {
2020-02-18 13:41:19 +00:00
delete[] mBuffer;
mBuffer = nullptr;
}
2020-02-18 13:41:19 +00:00
AI_DEBUG_INVALIDATE_PTR(mIOHandler);
AI_DEBUG_INVALIDATE_PTR(pScene);
};
2020-02-18 13:41:19 +00:00
try {
// Allocate storage and copy the contents of the file to a memory buffer
2020-02-18 13:41:19 +00:00
mBuffer = new unsigned char[iFileSize + 1];
file->Read((void *)mBuffer, 1, 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 ...
mBuffer[iFileSize] = '\0';
2020-02-18 13:41:19 +00:00
const uint32_t iMagicWord = *((uint32_t *)mBuffer);
// Determine the file subtype and call the appropriate member function
bool is_half_life = false;
// Original Quake1 format
2020-02-18 13:41:19 +00:00
if (AI_MDL_MAGIC_NUMBER_BE == iMagicWord || AI_MDL_MAGIC_NUMBER_LE == iMagicWord) {
ASSIMP_LOG_DEBUG("MDL subtype: Quake 1, magic word is IDPO");
iGSFileVersion = 0;
InternReadFile_Quake1();
}
// GameStudio A<old> MDL2 format - used by some test models that come with 3DGS
2020-02-18 13:41:19 +00:00
else if (AI_MDL_MAGIC_NUMBER_BE_GS3 == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS3 == iMagicWord) {
ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A2, magic word is MDL2");
iGSFileVersion = 2;
InternReadFile_Quake1();
}
// GameStudio A4 MDL3 format
2020-02-18 13:41:19 +00:00
else if (AI_MDL_MAGIC_NUMBER_BE_GS4 == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS4 == iMagicWord) {
ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A4, magic word is MDL3");
iGSFileVersion = 3;
InternReadFile_3DGS_MDL345();
}
// GameStudio A5+ MDL4 format
2020-02-18 13:41:19 +00:00
else if (AI_MDL_MAGIC_NUMBER_BE_GS5a == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS5a == iMagicWord) {
ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A4, magic word is MDL4");
iGSFileVersion = 4;
InternReadFile_3DGS_MDL345();
}
// GameStudio A5+ MDL5 format
2020-02-18 13:41:19 +00:00
else if (AI_MDL_MAGIC_NUMBER_BE_GS5b == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS5b == iMagicWord) {
ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A5, magic word is MDL5");
iGSFileVersion = 5;
InternReadFile_3DGS_MDL345();
}
// GameStudio A7 MDL7 format
2020-02-18 13:41:19 +00:00
else if (AI_MDL_MAGIC_NUMBER_BE_GS7 == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS7 == iMagicWord) {
ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A7, magic word is MDL7");
iGSFileVersion = 7;
InternReadFile_3DGS_MDL7();
}
// IDST/IDSQ Format (CS:S/HL^2, etc ...)
else if (AI_MDL_MAGIC_NUMBER_BE_HL2a == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_HL2a == iMagicWord ||
2020-02-18 13:41:19 +00:00
AI_MDL_MAGIC_NUMBER_BE_HL2b == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_HL2b == iMagicWord) {
iGSFileVersion = 0;
is_half_life = true;
HalfLife::HalfLifeMDLBaseHeader *pHeader = (HalfLife::HalfLifeMDLBaseHeader *)mBuffer;
2020-02-18 13:41:19 +00:00
if (pHeader->version == AI_MDL_HL1_VERSION) {
ASSIMP_LOG_DEBUG("MDL subtype: Half-Life 1/Goldsrc Engine, magic word is IDST/IDSQ");
InternReadFile_HL1(pFile, iMagicWord);
2020-02-18 13:41:19 +00:00
} else {
ASSIMP_LOG_DEBUG("MDL subtype: Source(tm) Engine, magic word is IDST/IDSQ");
InternReadFile_HL2();
}
2020-02-18 13:41:19 +00:00
} else {
// print the magic word to the log file
throw DeadlyImportError("Unknown MDL subformat ", pFile,
". Magic word (", ai_str_toprintable((const char *)&iMagicWord, sizeof(iMagicWord)), ") is not known");
}
2015-05-19 03:57:13 +00:00
if (is_half_life){
// Now rotate the whole scene 90 degrees around the z and x axes to convert to internal coordinate system
pScene->mRootNode->mTransformation = aiMatrix4x4(
0.f, -1.f, 0.f, 0.f,
0.f, 0.f, 1.f, 0.f,
-1.f, 0.f, 0.f, 0.f,
0.f, 0.f, 0.f, 1.f);
}
else {
// Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
pScene->mRootNode->mTransformation = aiMatrix4x4(1.f, 0.f, 0.f, 0.f,
0.f, 0.f, 1.f, 0.f, 0.f, -1.f, 0.f, 0.f, 0.f, 0.f, 0.f, 1.f);
}
2015-05-19 03:57:13 +00:00
DeleteBufferAndCleanup();
2020-02-18 13:41:19 +00:00
} catch (...) {
DeleteBufferAndCleanup();
throw;
}
}
// ------------------------------------------------------------------------------------------------
// Check whether we're still inside the valid file range
2020-02-18 13:41:19 +00:00
void MDLImporter::SizeCheck(const void *szPos) {
if (!szPos || (const unsigned char *)szPos > this->mBuffer + this->iFileSize || szPos < this->mBuffer) {
2015-05-19 03:57:13 +00:00
throw DeadlyImportError("Invalid MDL file. The file is too small "
2020-02-18 13:41:19 +00:00
"or contains invalid data.");
2015-05-19 03:57:13 +00:00
}
}
// ------------------------------------------------------------------------------------------------
2018-04-19 15:21:21 +00:00
// Just for debugging purposes
2020-02-18 13:41:19 +00:00
void MDLImporter::SizeCheck(const void *szPos, const char *szFile, unsigned int iLine) {
ai_assert(nullptr != szFile);
2020-02-18 13:41:19 +00:00
if (!szPos || (const unsigned char *)szPos > mBuffer + iFileSize) {
2015-05-19 03:57:13 +00:00
// remove a directory if there is one
2020-02-18 13:41:19 +00:00
const char *szFilePtr = ::strrchr(szFile, '\\');
2015-05-19 03:57:13 +00:00
if (!szFilePtr) {
2020-02-18 13:41:19 +00:00
szFilePtr = ::strrchr(szFile, '/');
if (nullptr == szFilePtr) {
2015-05-19 03:57:13 +00:00
szFilePtr = szFile;
2020-02-18 13:41:19 +00:00
}
}
if (szFilePtr) {
++szFilePtr;
2015-05-19 03:57:13 +00:00
}
char szBuffer[1024];
::snprintf(szBuffer, sizeof(szBuffer), "Invalid MDL file. The file is too small "
2020-02-18 13:41:19 +00:00
"or contains invalid data (File: %s Line: %u)",
szFilePtr, iLine);
2015-05-19 03:57:13 +00:00
throw DeadlyImportError(szBuffer);
}
}
// ------------------------------------------------------------------------------------------------
// Validate a quake file header
2020-02-18 13:41:19 +00:00
void MDLImporter::ValidateHeader_Quake1(const MDL::Header *pcHeader) {
// some values may not be nullptr
2015-05-19 03:57:13 +00:00
if (!pcHeader->num_frames)
2020-02-18 13:41:19 +00:00
throw DeadlyImportError("[Quake 1 MDL] There are no frames in the file");
2015-05-19 03:57:13 +00:00
if (!pcHeader->num_verts)
2020-02-18 13:41:19 +00:00
throw DeadlyImportError("[Quake 1 MDL] There are no vertices in the file");
2015-05-19 03:57:13 +00:00
if (!pcHeader->num_tris)
2020-02-18 13:41:19 +00:00
throw DeadlyImportError("[Quake 1 MDL] There are no triangles in the file");
2015-05-19 03:57:13 +00:00
// check whether the maxima are exceeded ...however, this applies for Quake 1 MDLs only
2020-02-18 13:41:19 +00:00
if (!this->iGSFileVersion) {
2015-05-19 03:57:13 +00:00
if (pcHeader->num_verts > AI_MDL_MAX_VERTS)
2018-04-19 15:21:21 +00:00
ASSIMP_LOG_WARN("Quake 1 MDL model has more than AI_MDL_MAX_VERTS vertices");
2015-05-19 03:57:13 +00:00
if (pcHeader->num_tris > AI_MDL_MAX_TRIANGLES)
2018-04-19 15:21:21 +00:00
ASSIMP_LOG_WARN("Quake 1 MDL model has more than AI_MDL_MAX_TRIANGLES triangles");
2015-05-19 03:57:13 +00:00
if (pcHeader->num_frames > AI_MDL_MAX_FRAMES)
2018-04-19 15:21:21 +00:00
ASSIMP_LOG_WARN("Quake 1 MDL model has more than AI_MDL_MAX_FRAMES frames");
2015-05-19 03:57:13 +00:00
// (this does not apply for 3DGS MDLs)
if (!this->iGSFileVersion && pcHeader->version != AI_MDL_VERSION)
2018-04-19 15:21:21 +00:00
ASSIMP_LOG_WARN("Quake 1 MDL model has an unknown version: AI_MDL_VERSION (=6) is "
2020-02-18 13:41:19 +00:00
"the expected file format version");
if (pcHeader->num_skins && (!pcHeader->skinwidth || !pcHeader->skinheight))
2018-04-19 15:21:21 +00:00
ASSIMP_LOG_WARN("Skin width or height are 0");
2015-05-19 03:57:13 +00:00
}
}
#ifdef AI_BUILD_BIG_ENDIAN
// ------------------------------------------------------------------------------------------------
2020-02-18 13:41:19 +00:00
void FlipQuakeHeader(BE_NCONST MDL::Header *pcHeader) {
AI_SWAP4(pcHeader->ident);
AI_SWAP4(pcHeader->version);
AI_SWAP4(pcHeader->boundingradius);
AI_SWAP4(pcHeader->flags);
AI_SWAP4(pcHeader->num_frames);
AI_SWAP4(pcHeader->num_skins);
AI_SWAP4(pcHeader->num_tris);
AI_SWAP4(pcHeader->num_verts);
for (unsigned int i = 0; i < 3; ++i) {
AI_SWAP4(pcHeader->scale[i]);
AI_SWAP4(pcHeader->translate[i]);
2015-05-19 03:57:13 +00:00
}
2020-02-18 13:41:19 +00:00
AI_SWAP4(pcHeader->size);
AI_SWAP4(pcHeader->skinheight);
AI_SWAP4(pcHeader->skinwidth);
AI_SWAP4(pcHeader->synctype);
}
#endif
// ------------------------------------------------------------------------------------------------
// Read a Quake 1 file
void MDLImporter::InternReadFile_Quake1() {
ai_assert(nullptr != pScene);
2020-02-18 13:41:19 +00:00
BE_NCONST MDL::Header *pcHeader = (BE_NCONST MDL::Header *)this->mBuffer;
#ifdef AI_BUILD_BIG_ENDIAN
2015-05-19 03:57:13 +00:00
FlipQuakeHeader(pcHeader);
#endif
2015-05-19 03:57:13 +00:00
ValidateHeader_Quake1(pcHeader);
// current cursor position in the file
2020-02-18 13:41:19 +00:00
const unsigned char *szCurrent = (const unsigned char *)(pcHeader + 1);
2015-05-19 03:57:13 +00:00
// need to read all textures
2020-02-18 13:41:19 +00:00
for (unsigned int i = 0; i < (unsigned int)pcHeader->num_skins; ++i) {
union {
2020-02-18 13:41:19 +00:00
BE_NCONST MDL::Skin *pcSkin;
BE_NCONST MDL::GroupSkin *pcGroupSkin;
};
if (szCurrent + sizeof(MDL::Skin) > this->mBuffer + this->iFileSize) {
throw DeadlyImportError("[Quake 1 MDL] Unexpected EOF");
}
2020-02-18 13:41:19 +00:00
pcSkin = (BE_NCONST MDL::Skin *)szCurrent;
2015-05-19 03:57:13 +00:00
2020-02-18 13:41:19 +00:00
AI_SWAP4(pcSkin->group);
2015-05-19 03:57:13 +00:00
// Quake 1 group-skins
if (1 == pcSkin->group) {
2020-02-18 13:41:19 +00:00
AI_SWAP4(pcGroupSkin->nb);
2015-05-19 03:57:13 +00:00
// need to skip multiple images
const unsigned int iNumImages = (unsigned int)pcGroupSkin->nb;
szCurrent += sizeof(uint32_t) * 2;
if (0 != iNumImages) {
2015-05-19 03:57:13 +00:00
if (!i) {
// however, create only one output image (the first)
this->CreateTextureARGB8_3DGS_MDL3(szCurrent + iNumImages * sizeof(float));
}
// go to the end of the skin section / the beginning of the next skin
bool overflow = false;
if (pcHeader->skinwidth != 0 || pcHeader->skinheight != 0) {
if ((pcHeader->skinheight > INT_MAX / pcHeader->skinwidth) || (pcHeader->skinwidth > INT_MAX / pcHeader->skinheight)){
overflow = true;
}
if (!overflow) {
szCurrent += pcHeader->skinheight * pcHeader->skinwidth +sizeof(float) * iNumImages;
}
}
2015-05-19 03:57:13 +00:00
}
} else {
2015-05-19 03:57:13 +00:00
szCurrent += sizeof(uint32_t);
unsigned int iSkip = i ? UINT_MAX : 0;
2020-02-18 13:41:19 +00:00
CreateTexture_3DGS_MDL4(szCurrent, pcSkin->group, &iSkip);
2015-05-19 03:57:13 +00:00
szCurrent += iSkip;
}
}
// get a pointer to the texture coordinates
2020-02-18 13:41:19 +00:00
BE_NCONST MDL::TexCoord *pcTexCoords = (BE_NCONST MDL::TexCoord *)szCurrent;
2015-05-19 03:57:13 +00:00
szCurrent += sizeof(MDL::TexCoord) * pcHeader->num_verts;
// get a pointer to the triangles
2020-02-18 13:41:19 +00:00
BE_NCONST MDL::Triangle *pcTriangles = (BE_NCONST MDL::Triangle *)szCurrent;
2015-05-19 03:57:13 +00:00
szCurrent += sizeof(MDL::Triangle) * pcHeader->num_tris;
VALIDATE_FILE_SIZE(szCurrent);
// now get a pointer to the first frame in the file
2020-02-18 13:41:19 +00:00
BE_NCONST MDL::Frame *pcFrames = (BE_NCONST MDL::Frame *)szCurrent;
MDL::SimpleFrame *pcFirstFrame;
2015-05-19 03:57:13 +00:00
if (0 == pcFrames->type) {
2015-05-19 03:57:13 +00:00
// get address of single frame
2020-02-18 13:41:19 +00:00
pcFirstFrame = (MDL::SimpleFrame *)&pcFrames->frame;
} else {
2015-05-19 03:57:13 +00:00
// get the first frame in the group
2021-05-30 08:45:50 +00:00
BE_NCONST MDL::GroupFrame *pcFrames2 = (BE_NCONST MDL::GroupFrame *)szCurrent;
pcFirstFrame = (MDL::SimpleFrame *)( szCurrent + sizeof(MDL::GroupFrame::type) + sizeof(MDL::GroupFrame::numframes)
+ sizeof(MDL::GroupFrame::min) + sizeof(MDL::GroupFrame::max) + sizeof(*MDL::GroupFrame::times) * pcFrames2->numframes );
2015-05-19 03:57:13 +00:00
}
2020-02-18 13:41:19 +00:00
BE_NCONST MDL::Vertex *pcVertices = (BE_NCONST MDL::Vertex *)((pcFirstFrame->name) + sizeof(pcFirstFrame->name));
VALIDATE_FILE_SIZE((const unsigned char *)(pcVertices + pcHeader->num_verts));
#ifdef AI_BUILD_BIG_ENDIAN
2020-02-18 13:41:19 +00:00
for (int i = 0; i < pcHeader->num_verts; ++i) {
AI_SWAP4(pcTexCoords[i].onseam);
AI_SWAP4(pcTexCoords[i].s);
AI_SWAP4(pcTexCoords[i].t);
2015-05-19 03:57:13 +00:00
}
2020-02-18 13:41:19 +00:00
for (int i = 0; i < pcHeader->num_tris; ++i) {
AI_SWAP4(pcTriangles[i].facesfront);
AI_SWAP4(pcTriangles[i].vertex[0]);
AI_SWAP4(pcTriangles[i].vertex[1]);
AI_SWAP4(pcTriangles[i].vertex[2]);
2015-05-19 03:57:13 +00:00
}
#endif
2015-05-19 03:57:13 +00:00
// setup materials
SetupMaterialProperties_3DGS_MDL5_Quake1();
// allocate enough storage to hold all vertices and triangles
2020-02-18 13:41:19 +00:00
aiMesh *pcMesh = new aiMesh();
2015-05-19 03:57:13 +00:00
pcMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
pcMesh->mNumVertices = pcHeader->num_tris * 3;
pcMesh->mNumFaces = pcHeader->num_tris;
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;
2020-02-18 13:41:19 +00:00
pScene->mMeshes = new aiMesh *[1];
2015-05-19 03:57:13 +00:00
pScene->mMeshes[0] = pcMesh;
// now iterate through all triangles
unsigned int iCurrent = 0;
2020-02-18 13:41:19 +00:00
for (unsigned int i = 0; i < (unsigned int)pcHeader->num_tris; ++i) {
2015-05-19 03:57:13 +00:00
pcMesh->mFaces[i].mIndices = new unsigned int[3];
pcMesh->mFaces[i].mNumIndices = 3;
unsigned int iTemp = iCurrent;
2020-02-18 13:41:19 +00:00
for (unsigned int c = 0; c < 3; ++c, ++iCurrent) {
2015-05-19 03:57:13 +00:00
pcMesh->mFaces[i].mIndices[c] = iCurrent;
// read vertices
unsigned int iIndex = pcTriangles->vertex[c];
2020-02-18 13:41:19 +00:00
if (iIndex >= (unsigned int)pcHeader->num_verts) {
iIndex = pcHeader->num_verts - 1;
2018-04-26 12:10:18 +00:00
ASSIMP_LOG_WARN("Index overflow in Q1-MDL vertex list.");
2015-05-19 03:57:13 +00:00
}
2020-02-18 13:41:19 +00:00
aiVector3D &vec = pcMesh->mVertices[iCurrent];
2015-05-19 03:57:13 +00:00
vec.x = (float)pcVertices[iIndex].v[0] * pcHeader->scale[0];
vec.x += pcHeader->translate[0];
vec.y = (float)pcVertices[iIndex].v[1] * pcHeader->scale[1];
vec.y += pcHeader->translate[1];
//vec.y *= -1.0f;
vec.z = (float)pcVertices[iIndex].v[2] * pcHeader->scale[2];
vec.z += pcHeader->translate[2];
// read the normal vector from the precalculated normal table
2020-02-18 13:41:19 +00:00
MD2::LookupNormalIndex(pcVertices[iIndex].normalIndex, pcMesh->mNormals[iCurrent]);
2015-05-19 03:57:13 +00:00
//pcMesh->mNormals[iCurrent].y *= -1.0f;
// read texture coordinates
float s = (float)pcTexCoords[iIndex].s;
float t = (float)pcTexCoords[iIndex].t;
// translate texture coordinates
2020-02-18 13:41:19 +00:00
if (0 == pcTriangles->facesfront && 0 != pcTexCoords[iIndex].onseam) {
2015-05-19 03:57:13 +00:00
s += pcHeader->skinwidth * 0.5f;
}
// Scale s and t to range from 0.0 to 1.0
pcMesh->mTextureCoords[0][iCurrent].x = (s + 0.5f) / pcHeader->skinwidth;
2020-02-18 13:41:19 +00:00
pcMesh->mTextureCoords[0][iCurrent].y = 1.0f - (t + 0.5f) / pcHeader->skinheight;
2015-05-19 03:57:13 +00:00
}
2020-02-18 13:41:19 +00:00
pcMesh->mFaces[i].mIndices[0] = iTemp + 2;
pcMesh->mFaces[i].mIndices[1] = iTemp + 1;
pcMesh->mFaces[i].mIndices[2] = iTemp + 0;
2015-05-19 03:57:13 +00:00
pcTriangles++;
}
return;
}
// ------------------------------------------------------------------------------------------------
// Setup material properties for Quake and older GameStudio files
2020-02-18 13:41:19 +00:00
void MDLImporter::SetupMaterialProperties_3DGS_MDL5_Quake1() {
const MDL::Header *const pcHeader = (const MDL::Header *)this->mBuffer;
2015-05-19 03:57:13 +00:00
// allocate ONE material
2020-02-18 13:41:19 +00:00
pScene->mMaterials = new aiMaterial *[1];
2015-05-19 03:57:13 +00:00
pScene->mMaterials[0] = new aiMaterial();
pScene->mNumMaterials = 1;
// setup the material's properties
const int iMode = (int)aiShadingMode_Gouraud;
2020-02-18 13:41:19 +00:00
aiMaterial *const pcHelper = (aiMaterial *)pScene->mMaterials[0];
2015-05-19 03:57:13 +00:00
pcHelper->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL);
aiColor4D clr;
2020-02-18 13:41:19 +00:00
if (0 != pcHeader->num_skins && pScene->mNumTextures) {
2015-05-19 03:57:13 +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->mTextures = nullptr;
2015-05-19 03:57:13 +00:00
pScene->mNumTextures = 0;
2020-02-18 13:41:19 +00:00
} else {
2015-05-19 03:57:13 +00:00
clr.b = clr.a = clr.g = clr.r = 1.0f;
aiString szString;
2020-02-18 13:41:19 +00:00
::memcpy(szString.data, AI_MAKE_EMBEDDED_TEXNAME(0), 3);
2015-05-19 03:57:13 +00:00
szString.length = 2;
2020-02-18 13:41:19 +00:00
pcHelper->AddProperty(&szString, AI_MATKEY_TEXTURE_DIFFUSE(0));
2015-05-19 03:57:13 +00:00
}
}
2020-02-18 13:41:19 +00:00
pcHelper->AddProperty<aiColor4D>(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
pcHelper->AddProperty<aiColor4D>(&clr, 1, AI_MATKEY_COLOR_SPECULAR);
2015-05-19 03:57:13 +00:00
2020-02-18 13:41:19 +00:00
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);
}
// ------------------------------------------------------------------------------------------------
// Read a MDL 3,4,5 file
2020-02-18 13:41:19 +00:00
void MDLImporter::InternReadFile_3DGS_MDL345() {
ai_assert(nullptr != pScene);
2015-05-19 03:57:13 +00:00
// the header of MDL 3/4/5 is nearly identical to the original Quake1 header
2020-02-18 13:41:19 +00:00
BE_NCONST MDL::Header *pcHeader = (BE_NCONST MDL::Header *)this->mBuffer;
#ifdef AI_BUILD_BIG_ENDIAN
2015-05-19 03:57:13 +00:00
FlipQuakeHeader(pcHeader);
#endif
2015-05-19 03:57:13 +00:00
ValidateHeader_Quake1(pcHeader);
// current cursor position in the file
2020-02-18 13:41:19 +00:00
const unsigned char *szCurrent = (const unsigned char *)(pcHeader + 1);
const unsigned char *szEnd = mBuffer + iFileSize;
2015-05-19 03:57:13 +00:00
// need to read all textures
2020-02-18 13:41:19 +00:00
for (unsigned int i = 0; i < (unsigned int)pcHeader->num_skins; ++i) {
if (szCurrent + sizeof(uint32_t) > szEnd) {
2020-02-18 13:41:19 +00:00
throw DeadlyImportError("Texture data past end of file.");
}
2020-02-18 13:41:19 +00:00
BE_NCONST MDL::Skin *pcSkin;
pcSkin = (BE_NCONST MDL::Skin *)szCurrent;
AI_SWAP4(pcSkin->group);
2015-05-19 03:57:13 +00:00
// create one output image
unsigned int iSkip = i ? UINT_MAX : 0;
2020-02-18 13:41:19 +00:00
if (5 <= iGSFileVersion) {
2015-05-19 03:57:13 +00:00
// MDL5 format could contain MIPmaps
2020-02-18 13:41:19 +00:00
CreateTexture_3DGS_MDL5((unsigned char *)pcSkin + sizeof(uint32_t),
pcSkin->group, &iSkip);
} else {
CreateTexture_3DGS_MDL4((unsigned char *)pcSkin + sizeof(uint32_t),
pcSkin->group, &iSkip);
2015-05-19 03:57:13 +00:00
}
// need to skip one image
szCurrent += iSkip + sizeof(uint32_t);
}
// get a pointer to the texture coordinates
2020-02-18 13:41:19 +00:00
BE_NCONST MDL::TexCoord_MDL3 *pcTexCoords = (BE_NCONST MDL::TexCoord_MDL3 *)szCurrent;
2015-05-19 03:57:13 +00:00
szCurrent += sizeof(MDL::TexCoord_MDL3) * pcHeader->synctype;
// NOTE: for MDLn formats "synctype" corresponds to the number of UV coords
// get a pointer to the triangles
2020-02-18 13:41:19 +00:00
BE_NCONST MDL::Triangle_MDL3 *pcTriangles = (BE_NCONST MDL::Triangle_MDL3 *)szCurrent;
2015-05-19 03:57:13 +00:00
szCurrent += sizeof(MDL::Triangle_MDL3) * pcHeader->num_tris;
#ifdef AI_BUILD_BIG_ENDIAN
2020-02-18 13:41:19 +00:00
for (int i = 0; i < pcHeader->synctype; ++i) {
AI_SWAP2(pcTexCoords[i].u);
AI_SWAP2(pcTexCoords[i].v);
2015-05-19 03:57:13 +00:00
}
2020-02-18 13:41:19 +00:00
for (int i = 0; i < pcHeader->num_tris; ++i) {
AI_SWAP2(pcTriangles[i].index_xyz[0]);
AI_SWAP2(pcTriangles[i].index_xyz[1]);
AI_SWAP2(pcTriangles[i].index_xyz[2]);
AI_SWAP2(pcTriangles[i].index_uv[0]);
AI_SWAP2(pcTriangles[i].index_uv[1]);
AI_SWAP2(pcTriangles[i].index_uv[2]);
2015-05-19 03:57:13 +00:00
}
#endif
2015-05-19 03:57:13 +00:00
VALIDATE_FILE_SIZE(szCurrent);
// setup materials
SetupMaterialProperties_3DGS_MDL5_Quake1();
// allocate enough storage to hold all vertices and triangles
2020-02-18 13:41:19 +00:00
aiMesh *pcMesh = new aiMesh();
2015-05-19 03:57:13 +00:00
pcMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
pcMesh->mNumVertices = pcHeader->num_tris * 3;
pcMesh->mNumFaces = pcHeader->num_tris;
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;
2020-02-18 13:41:19 +00:00
pScene->mMeshes = new aiMesh *[1];
2015-05-19 03:57:13 +00:00
pScene->mMeshes[0] = pcMesh;
// allocate output storage
2020-02-18 13:41:19 +00:00
pcMesh->mNumVertices = (unsigned int)pcHeader->num_tris * 3;
pcMesh->mVertices = new aiVector3D[pcMesh->mNumVertices];
pcMesh->mNormals = new aiVector3D[pcMesh->mNumVertices];
2015-05-19 03:57:13 +00:00
if (pcHeader->synctype) {
pcMesh->mTextureCoords[0] = new aiVector3D[pcMesh->mNumVertices];
pcMesh->mNumUVComponents[0] = 2;
}
// now get a pointer to the first frame in the file
2020-02-18 13:41:19 +00:00
BE_NCONST MDL::Frame *pcFrames = (BE_NCONST MDL::Frame *)szCurrent;
2015-05-19 03:57:13 +00:00
AI_SWAP4(pcFrames->type);
// byte packed vertices
// FIXME: these two snippets below are almost identical ... join them?
/////////////////////////////////////////////////////////////////////////////////////
2020-02-18 13:41:19 +00:00
if (0 == pcFrames->type || 3 >= this->iGSFileVersion) {
2015-05-19 03:57:13 +00:00
2020-02-18 13:41:19 +00:00
const MDL::SimpleFrame *pcFirstFrame = (const MDL::SimpleFrame *)(szCurrent + sizeof(uint32_t));
const MDL::Vertex *pcVertices = (const MDL::Vertex *)((pcFirstFrame->name) + sizeof(pcFirstFrame->name));
2015-05-19 03:57:13 +00:00
VALIDATE_FILE_SIZE(pcVertices + pcHeader->num_verts);
// now iterate through all triangles
unsigned int iCurrent = 0;
2020-02-18 13:41:19 +00:00
for (unsigned int i = 0; i < (unsigned int)pcHeader->num_tris; ++i) {
2015-05-19 03:57:13 +00:00
pcMesh->mFaces[i].mIndices = new unsigned int[3];
pcMesh->mFaces[i].mNumIndices = 3;
unsigned int iTemp = iCurrent;
2020-02-18 13:41:19 +00:00
for (unsigned int c = 0; c < 3; ++c, ++iCurrent) {
2015-05-19 03:57:13 +00:00
// read vertices
unsigned int iIndex = pcTriangles->index_xyz[c];
2020-02-18 13:41:19 +00:00
if (iIndex >= (unsigned int)pcHeader->num_verts) {
iIndex = pcHeader->num_verts - 1;
2018-04-19 15:21:21 +00:00
ASSIMP_LOG_WARN("Index overflow in MDLn vertex list");
2015-05-19 03:57:13 +00:00
}
2020-02-18 13:41:19 +00:00
aiVector3D &vec = pcMesh->mVertices[iCurrent];
2015-05-19 03:57:13 +00:00
vec.x = (float)pcVertices[iIndex].v[0] * pcHeader->scale[0];
vec.x += pcHeader->translate[0];
vec.y = (float)pcVertices[iIndex].v[1] * pcHeader->scale[1];
vec.y += pcHeader->translate[1];
// vec.y *= -1.0f;
vec.z = (float)pcVertices[iIndex].v[2] * pcHeader->scale[2];
vec.z += pcHeader->translate[2];
// read the normal vector from the precalculated normal table
2020-02-18 13:41:19 +00:00
MD2::LookupNormalIndex(pcVertices[iIndex].normalIndex, pcMesh->mNormals[iCurrent]);
2015-05-19 03:57:13 +00:00
// pcMesh->mNormals[iCurrent].y *= -1.0f;
// read texture coordinates
if (pcHeader->synctype) {
ImportUVCoordinate_3DGS_MDL345(pcMesh->mTextureCoords[0][iCurrent],
2020-02-18 13:41:19 +00:00
pcTexCoords, pcTriangles->index_uv[c]);
2015-05-19 03:57:13 +00:00
}
}
2020-02-18 13:41:19 +00:00
pcMesh->mFaces[i].mIndices[0] = iTemp + 2;
pcMesh->mFaces[i].mIndices[1] = iTemp + 1;
pcMesh->mFaces[i].mIndices[2] = iTemp + 0;
2015-05-19 03:57:13 +00:00
pcTriangles++;
}
}
// short packed vertices
/////////////////////////////////////////////////////////////////////////////////////
2020-02-18 13:41:19 +00:00
else {
2015-05-19 03:57:13 +00:00
// now get a pointer to the first frame in the file
2020-02-18 13:41:19 +00:00
const MDL::SimpleFrame_MDLn_SP *pcFirstFrame = (const MDL::SimpleFrame_MDLn_SP *)(szCurrent + sizeof(uint32_t));
2015-05-19 03:57:13 +00:00
// get a pointer to the vertices
2020-02-18 13:41:19 +00:00
const MDL::Vertex_MDL4 *pcVertices = (const MDL::Vertex_MDL4 *)((pcFirstFrame->name) +
sizeof(pcFirstFrame->name));
2015-05-19 03:57:13 +00:00
VALIDATE_FILE_SIZE(pcVertices + pcHeader->num_verts);
// now iterate through all triangles
unsigned int iCurrent = 0;
2020-02-18 13:41:19 +00:00
for (unsigned int i = 0; i < (unsigned int)pcHeader->num_tris; ++i) {
2015-05-19 03:57:13 +00:00
pcMesh->mFaces[i].mIndices = new unsigned int[3];
pcMesh->mFaces[i].mNumIndices = 3;
unsigned int iTemp = iCurrent;
2020-02-18 13:41:19 +00:00
for (unsigned int c = 0; c < 3; ++c, ++iCurrent) {
2015-05-19 03:57:13 +00:00
// read vertices
unsigned int iIndex = pcTriangles->index_xyz[c];
2020-02-18 13:41:19 +00:00
if (iIndex >= (unsigned int)pcHeader->num_verts) {
iIndex = pcHeader->num_verts - 1;
2018-04-19 15:21:21 +00:00
ASSIMP_LOG_WARN("Index overflow in MDLn vertex list");
2015-05-19 03:57:13 +00:00
}
2020-02-18 13:41:19 +00:00
aiVector3D &vec = pcMesh->mVertices[iCurrent];
2015-05-19 03:57:13 +00:00
vec.x = (float)pcVertices[iIndex].v[0] * pcHeader->scale[0];
vec.x += pcHeader->translate[0];
vec.y = (float)pcVertices[iIndex].v[1] * pcHeader->scale[1];
vec.y += pcHeader->translate[1];
// vec.y *= -1.0f;
vec.z = (float)pcVertices[iIndex].v[2] * pcHeader->scale[2];
vec.z += pcHeader->translate[2];
// read the normal vector from the precalculated normal table
2020-02-18 13:41:19 +00:00
MD2::LookupNormalIndex(pcVertices[iIndex].normalIndex, pcMesh->mNormals[iCurrent]);
2015-05-19 03:57:13 +00:00
// pcMesh->mNormals[iCurrent].y *= -1.0f;
// read texture coordinates
if (pcHeader->synctype) {
ImportUVCoordinate_3DGS_MDL345(pcMesh->mTextureCoords[0][iCurrent],
2020-02-18 13:41:19 +00:00
pcTexCoords, pcTriangles->index_uv[c]);
2015-05-19 03:57:13 +00:00
}
}
2020-02-18 13:41:19 +00:00
pcMesh->mFaces[i].mIndices[0] = iTemp + 2;
pcMesh->mFaces[i].mIndices[1] = iTemp + 1;
pcMesh->mFaces[i].mIndices[2] = iTemp + 0;
2015-05-19 03:57:13 +00:00
pcTriangles++;
}
}
// For MDL5 we will need to build valid texture coordinates
// basing upon the file loaded (only support one file as skin)
if (0x5 == iGSFileVersion)
CalculateUVCoordinates_MDL5();
return;
}
// ------------------------------------------------------------------------------------------------
// Get a single UV coordinate for Quake and older GameStudio files
2015-05-19 03:52:10 +00:00
void MDLImporter::ImportUVCoordinate_3DGS_MDL345(
2020-02-18 13:41:19 +00:00
aiVector3D &vOut,
const MDL::TexCoord_MDL3 *pcSrc,
unsigned int iIndex) {
ai_assert(nullptr != pcSrc);
2020-02-18 13:41:19 +00:00
const MDL::Header *const pcHeader = (const MDL::Header *)this->mBuffer;
2015-05-19 03:57:13 +00:00
// validate UV indices
2020-02-18 13:41:19 +00:00
if (iIndex >= (unsigned int)pcHeader->synctype) {
iIndex = pcHeader->synctype - 1;
2018-04-19 15:21:21 +00:00
ASSIMP_LOG_WARN("Index overflow in MDLn UV coord list");
2015-05-19 03:57:13 +00:00
}
float s = (float)pcSrc[iIndex].u;
float t = (float)pcSrc[iIndex].v;
// Scale s and t to range from 0.0 to 1.0
2020-02-18 13:41:19 +00:00
if (0x5 != iGSFileVersion) {
s = (s + 0.5f) / pcHeader->skinwidth;
t = 1.0f - (t + 0.5f) / pcHeader->skinheight;
2015-05-19 03:57:13 +00:00
}
vOut.x = s;
vOut.y = t;
vOut.z = 0.0f;
}
// ------------------------------------------------------------------------------------------------
// Compute UV coordinates for a MDL5 file
2020-02-18 13:41:19 +00:00
void MDLImporter::CalculateUVCoordinates_MDL5() {
const MDL::Header *const pcHeader = (const MDL::Header *)this->mBuffer;
if (pcHeader->num_skins && this->pScene->mNumTextures) {
const aiTexture *pcTex = this->pScene->mTextures[0];
2015-05-19 03:57:13 +00:00
// 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;
2020-02-18 13:41:19 +00:00
if (!pcTex->mHeight) {
const uint32_t *piPtr = (uint32_t *)pcTex->pcData;
2015-05-19 03:57:13 +00:00
piPtr += 3;
iHeight = (unsigned int)*piPtr++;
2020-02-18 13:41:19 +00:00
iWidth = (unsigned int)*piPtr;
if (!iHeight || !iWidth) {
2018-04-19 15:21:21 +00:00
ASSIMP_LOG_WARN("Either the width or the height of the "
2020-02-18 13:41:19 +00:00
"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;
2015-05-19 03:57:13 +00:00
iHeight = 1;
}
2020-02-18 13:41:19 +00:00
} else {
iWidth = pcTex->mWidth;
2015-05-19 03:57:13 +00:00
iHeight = pcTex->mHeight;
}
2020-02-18 13:41:19 +00:00
if (1 != iWidth || 1 != iHeight) {
2015-05-19 03:57:13 +00:00
const float fWidth = (float)iWidth;
const float fHeight = (float)iHeight;
2020-02-18 13:41:19 +00:00
aiMesh *pcMesh = this->pScene->mMeshes[0];
for (unsigned int i = 0; i < pcMesh->mNumVertices; ++i) {
if (!pcMesh->HasTextureCoords(0)) {
continue;
}
2015-05-19 03:57:13 +00:00
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
}
}
}
}
// ------------------------------------------------------------------------------------------------
// Validate the header of a MDL7 file
2020-02-18 13:41:19 +00:00
void MDLImporter::ValidateHeader_3DGS_MDL7(const MDL::Header_MDL7 *pcHeader) {
ai_assert(nullptr != pcHeader);
2015-05-19 03:57:13 +00:00
// There are some fixed sizes ...
2020-02-18 13:41:19 +00:00
if (sizeof(MDL::ColorValue_MDL7) != pcHeader->colorvalue_stc_size) {
2015-05-19 03:57:13 +00:00
throw DeadlyImportError(
2020-02-18 13:41:19 +00:00
"[3DGS MDL7] sizeof(MDL::ColorValue_MDL7) != pcHeader->colorvalue_stc_size");
2015-05-19 03:57:13 +00:00
}
if (sizeof(MDL::TexCoord_MDL7) != pcHeader->skinpoint_stc_size) {
throw DeadlyImportError(
2020-02-18 13:41:19 +00:00
"[3DGS MDL7] sizeof(MDL::TexCoord_MDL7) != pcHeader->skinpoint_stc_size");
2015-05-19 03:57:13 +00:00
}
2020-02-18 13:41:19 +00:00
if (sizeof(MDL::Skin_MDL7) != pcHeader->skin_stc_size) {
2015-05-19 03:57:13 +00:00
throw DeadlyImportError(
2020-02-18 13:41:19 +00:00
"sizeof(MDL::Skin_MDL7) != pcHeader->skin_stc_size");
2015-05-19 03:57:13 +00:00
}
// if there are no groups ... how should we load such a file?
2020-02-18 13:41:19 +00:00
if (!pcHeader->groups_num) {
throw DeadlyImportError("[3DGS MDL7] No frames found");
2015-05-19 03:57:13 +00:00
}
}
// ------------------------------------------------------------------------------------------------
// resolve bone animation matrices
2020-02-18 13:41:19 +00:00
void MDLImporter::CalcAbsBoneMatrices_3DGS_MDL7(MDL::IntBone_MDL7 **apcOutBones) {
const MDL::Header_MDL7 *pcHeader = (const MDL::Header_MDL7 *)this->mBuffer;
const MDL::Bone_MDL7 *pcBones = (const MDL::Bone_MDL7 *)(pcHeader + 1);
ai_assert(nullptr != apcOutBones);
2015-05-19 03:57:13 +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;
uint32_t iIterations = 0;
while (iIterations++ < pcHeader->bones_num) {
2020-02-18 13:41:19 +00:00
for (uint32_t iBone = 0; iBone < pcHeader->bones_num; ++iBone) {
BE_NCONST MDL::Bone_MDL7 *pcBone = _AI_MDL7_ACCESS_PTR(pcBones, iBone,
pcHeader->bone_stc_size, MDL::Bone_MDL7);
2015-05-19 03:57:13 +00:00
AI_SWAP2(pcBone->parent_index);
AI_SWAP4(pcBone->x);
AI_SWAP4(pcBone->y);
AI_SWAP4(pcBone->z);
2020-02-18 13:41:19 +00:00
if (iParent == pcBone->parent_index) {
2015-05-19 03:57:13 +00:00
// MDL7 readme
////////////////////////////////////////////////////////////////
/*
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;
*/
/////////////////////////////////////////////////////////////////
2020-02-18 13:41:19 +00:00
MDL::IntBone_MDL7 *const pcOutBone = apcOutBones[iBone];
2015-05-19 03:57:13 +00:00
// store the parent index of the bone
pcOutBone->iParent = pcBone->parent_index;
2020-02-18 13:41:19 +00:00
if (0xffff != iParent) {
const MDL::IntBone_MDL7 *pcParentBone = apcOutBones[iParent];
2015-05-19 03:57:13 +00:00
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 is specified :-(
pcOutBone->mName.length = ai_snprintf(pcOutBone->mName.data, MAXLEN,
2020-02-18 13:41:19 +00:00
"UnnamedBone_%i", iBone);
} else {
2015-05-19 03:57:13 +00:00
// 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)
2020-02-18 13:41:19 +00:00
uint32_t iMaxLen = pcHeader->bone_stc_size - 16;
for (uint32_t qq = 0; qq < iMaxLen; ++qq) {
if (!pcBone->name[qq]) {
2015-05-19 03:57:13 +00:00
iMaxLen = qq;
break;
}
}
// store the name of the bone
2023-02-17 19:20:00 +00:00
pcOutBone->mName.length = static_cast<ai_uint32>(iMaxLen);
2020-02-18 13:41:19 +00:00
::memcpy(pcOutBone->mName.data, pcBone->name, pcOutBone->mName.length);
2015-05-19 03:57:13 +00:00
pcOutBone->mName.data[pcOutBone->mName.length] = '\0';
}
}
}
++iParent;
}
}
// ------------------------------------------------------------------------------------------------
// read bones from a MDL7 file
2020-02-18 13:41:19 +00:00
MDL::IntBone_MDL7 **MDLImporter::LoadBones_3DGS_MDL7() {
const MDL::Header_MDL7 *pcHeader = (const MDL::Header_MDL7 *)this->mBuffer;
if (pcHeader->bones_num) {
2015-05-19 03:57:13 +00:00
// validate the size of the bone data structure in the file
2020-02-18 13:41:19 +00:00
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) {
2018-04-19 15:21:21 +00:00
ASSIMP_LOG_WARN("Unknown size of bone data structure");
return nullptr;
2015-05-19 03:57:13 +00:00
}
2020-02-18 13:41:19 +00:00
MDL::IntBone_MDL7 **apcBonesOut = new MDL::IntBone_MDL7 *[pcHeader->bones_num];
for (uint32_t crank = 0; crank < pcHeader->bones_num; ++crank)
2015-05-19 03:57:13 +00:00
apcBonesOut[crank] = new MDL::IntBone_MDL7();
// and calculate absolute bone offset matrices ...
CalcAbsBoneMatrices_3DGS_MDL7(apcBonesOut);
return apcBonesOut;
}
return nullptr;
}
// ------------------------------------------------------------------------------------------------
// read faces from a MDL7 file
2020-02-18 13:41:19 +00:00
void MDLImporter::ReadFaces_3DGS_MDL7(const MDL::IntGroupInfo_MDL7 &groupInfo,
MDL::IntGroupData_MDL7 &groupData) {
const MDL::Header_MDL7 *pcHeader = (const MDL::Header_MDL7 *)this->mBuffer;
MDL::Triangle_MDL7 *pcGroupTris = groupInfo.pcGroupTris;
2015-05-19 03:57:13 +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) {
AI_SWAP2(pcGroupTris->v_index[0]);
AI_SWAP2(pcGroupTris->v_index[1]);
AI_SWAP2(pcGroupTris->v_index[2]);
// iterate through all indices of the current triangle
2020-02-18 13:41:19 +00:00
for (unsigned int c = 0; c < 3; ++c, ++iOutIndex) {
2015-05-19 03:57:13 +00:00
// validate the vertex index
unsigned int iIndex = pcGroupTris->v_index[c];
2020-02-18 13:41:19 +00:00
if (iIndex > (unsigned int)groupInfo.pcGroup->numverts) {
2015-05-19 03:57:13 +00:00
// (we might need to read this section a second time - to process frame vertices correctly)
pcGroupTris->v_index[c] = (uint16_t)(iIndex = groupInfo.pcGroup->numverts - 1);
2018-04-26 12:10:18 +00:00
ASSIMP_LOG_WARN("Index overflow in MDL7 vertex list");
2015-05-19 03:57:13 +00:00
}
// write the output face index
2020-02-18 13:41:19 +00:00
groupData.pcFaces[iTriangle].mIndices[2 - c] = iOutIndex;
2015-05-19 03:57:13 +00:00
2020-02-18 13:41:19 +00:00
aiVector3D &vPosition = groupData.vPositions[iOutIndex];
vPosition.x = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts, iIndex, pcHeader->mainvertex_stc_size).x;
vPosition.y = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts, iIndex, pcHeader->mainvertex_stc_size).y;
vPosition.z = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts, iIndex, pcHeader->mainvertex_stc_size).z;
2015-05-19 03:57:13 +00:00
// if we have bones, save the index
if (!groupData.aiBones.empty()) {
groupData.aiBones[iOutIndex] = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts,
2020-02-18 13:41:19 +00:00
iIndex, pcHeader->mainvertex_stc_size)
.vertindex;
2015-05-19 03:57:13 +00:00
}
// now read the normal vector
if (AI_MDL7_FRAMEVERTEX030305_STCSIZE <= pcHeader->mainvertex_stc_size) {
// read the full normal vector
2020-02-18 13:41:19 +00:00
aiVector3D &vNormal = groupData.vNormals[iOutIndex];
vNormal.x = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts, iIndex, pcHeader->mainvertex_stc_size).norm[0];
2015-05-19 03:57:13 +00:00
AI_SWAP4(vNormal.x);
2020-02-18 13:41:19 +00:00
vNormal.y = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts, iIndex, pcHeader->mainvertex_stc_size).norm[1];
2015-05-19 03:57:13 +00:00
AI_SWAP4(vNormal.y);
2020-02-18 13:41:19 +00:00
vNormal.z = _AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts, iIndex, pcHeader->mainvertex_stc_size).norm[2];
2015-05-19 03:57:13 +00:00
AI_SWAP4(vNormal.z);
2020-02-18 13:41:19 +00:00
} else if (AI_MDL7_FRAMEVERTEX120503_STCSIZE <= pcHeader->mainvertex_stc_size) {
2015-05-19 03:57:13 +00:00
// read the normal vector from Quake2's smart table
2020-02-18 13:41:19 +00:00
aiVector3D &vNormal = groupData.vNormals[iOutIndex];
MD2::LookupNormalIndex(_AI_MDL7_ACCESS_VERT(groupInfo.pcGroupVerts, iIndex,
pcHeader->mainvertex_stc_size)
.norm162index,
vNormal);
2015-05-19 03:57:13 +00:00
}
// validate and process the first uv coordinate set
2020-02-18 13:41:19 +00:00
if (pcHeader->triangle_stc_size >= AI_MDL7_TRIANGLE_STD_SIZE_ONE_UV) {
2015-05-19 03:57:13 +00:00
2020-02-18 13:41:19 +00:00
if (groupInfo.pcGroup->num_stpts) {
2015-05-19 03:57:13 +00:00
AI_SWAP2(pcGroupTris->skinsets[0].st_index[0]);
AI_SWAP2(pcGroupTris->skinsets[0].st_index[1]);
AI_SWAP2(pcGroupTris->skinsets[0].st_index[2]);
iIndex = pcGroupTris->skinsets[0].st_index[c];
2020-02-18 13:41:19 +00:00
if (iIndex > (unsigned int)groupInfo.pcGroup->num_stpts) {
iIndex = groupInfo.pcGroup->num_stpts - 1;
2018-04-19 15:21:21 +00:00
ASSIMP_LOG_WARN("Index overflow in MDL7 UV coordinate list (#1)");
2015-05-19 03:57:13 +00:00
}
float u = groupInfo.pcGroupUVs[iIndex].u;
2020-02-18 13:41:19 +00:00
float v = 1.0f - groupInfo.pcGroupUVs[iIndex].v; // DX to OGL
2015-05-19 03:57:13 +00:00
groupData.vTextureCoords1[iOutIndex].x = u;
groupData.vTextureCoords1[iOutIndex].y = v;
}
// assign the material index, but only if it is existing
2020-02-18 13:41:19 +00:00
if (pcHeader->triangle_stc_size >= AI_MDL7_TRIANGLE_STD_SIZE_ONE_UV_WITH_MATINDEX) {
2015-05-19 03:57:13 +00:00
AI_SWAP4(pcGroupTris->skinsets[0].material);
groupData.pcFaces[iTriangle].iMatIndex[0] = pcGroupTris->skinsets[0].material;
}
}
// validate and process the second uv coordinate set
2020-02-18 13:41:19 +00:00
if (pcHeader->triangle_stc_size >= AI_MDL7_TRIANGLE_STD_SIZE_TWO_UV) {
2015-05-19 03:57:13 +00:00
2020-02-18 13:41:19 +00:00
if (groupInfo.pcGroup->num_stpts) {
2015-05-19 03:57:13 +00:00
AI_SWAP2(pcGroupTris->skinsets[1].st_index[0]);
AI_SWAP2(pcGroupTris->skinsets[1].st_index[1]);
AI_SWAP2(pcGroupTris->skinsets[1].st_index[2]);
AI_SWAP4(pcGroupTris->skinsets[1].material);
iIndex = pcGroupTris->skinsets[1].st_index[c];
2020-02-18 13:41:19 +00:00
if (iIndex > (unsigned int)groupInfo.pcGroup->num_stpts) {
iIndex = groupInfo.pcGroup->num_stpts - 1;
2018-04-19 15:21:21 +00:00
ASSIMP_LOG_WARN("Index overflow in MDL7 UV coordinate list (#2)");
2015-05-19 03:57:13 +00:00
}
2020-02-18 13:41:19 +00:00
float u = groupInfo.pcGroupUVs[iIndex].u;
float v = 1.0f - groupInfo.pcGroupUVs[iIndex].v;
2015-05-19 03:57:13 +00:00
2020-02-18 13:41:19 +00:00
groupData.vTextureCoords2[iOutIndex].x = u;
groupData.vTextureCoords2[iOutIndex].y = v; // DX to OGL
2015-05-19 03:57:13 +00:00
// check whether we do really need the second texture
// coordinate set ... wastes memory and loading time
2020-02-18 13:41:19 +00:00
if (0 != iIndex && (u != groupData.vTextureCoords1[iOutIndex].x ||
v != groupData.vTextureCoords1[iOutIndex].y))
2015-05-19 03:57:13 +00:00
groupData.bNeed2UV = true;
// if the material differs, we need a second skin, too
2020-02-18 13:41:19 +00:00
if (pcGroupTris->skinsets[1].material != pcGroupTris->skinsets[0].material)
2015-05-19 03:57:13 +00:00
groupData.bNeed2UV = true;
}
// assign the material index
2020-02-18 13:41:19 +00:00
groupData.pcFaces[iTriangle].iMatIndex[1] = pcGroupTris->skinsets[1].material;
2015-05-19 03:57:13 +00:00
}
}
// get the next triangle in the list
2020-02-18 13:41:19 +00:00
pcGroupTris = (MDL::Triangle_MDL7 *)((const char *)pcGroupTris + pcHeader->triangle_stc_size);
2015-05-19 03:57:13 +00:00
}
}
// ------------------------------------------------------------------------------------------------
// handle frames in a MDL7 file
2020-02-18 13:41:19 +00:00
bool MDLImporter::ProcessFrames_3DGS_MDL7(const MDL::IntGroupInfo_MDL7 &groupInfo,
MDL::IntGroupData_MDL7 &groupData,
MDL::IntSharedData_MDL7 &shared,
const unsigned char *szCurrent,
const unsigned char **szCurrentOut) {
ai_assert(nullptr != szCurrent);
ai_assert(nullptr != szCurrentOut);
2020-02-18 13:41:19 +00:00
const MDL::Header_MDL7 *pcHeader = (const MDL::Header_MDL7 *)mBuffer;
2015-05-19 03:57:13 +00:00
// if we have no bones we can simply skip all frames,
// otherwise we'll need to process them.
// FIX: If we need another frame than the first we must apply frame vertex replacements ...
2020-02-18 13:41:19 +00:00
for (unsigned int iFrame = 0; iFrame < (unsigned int)groupInfo.pcGroup->numframes; ++iFrame) {
MDL::IntFrameInfo_MDL7 frame((BE_NCONST MDL::Frame_MDL7 *)szCurrent, iFrame);
2015-05-19 03:57:13 +00:00
AI_SWAP4(frame.pcFrame->vertices_count);
AI_SWAP4(frame.pcFrame->transmatrix_count);
const unsigned int iAdd = pcHeader->frame_stc_size +
2020-02-18 13:41:19 +00:00
frame.pcFrame->vertices_count * pcHeader->framevertex_stc_size +
frame.pcFrame->transmatrix_count * pcHeader->bonetrans_stc_size;
2015-05-19 03:57:13 +00:00
2020-02-18 13:41:19 +00:00
if (((const char *)szCurrent - (const char *)pcHeader) + iAdd > (unsigned int)pcHeader->data_size) {
2018-04-19 15:21:21 +00:00
ASSIMP_LOG_WARN("Index overflow in frame area. "
2020-02-18 13:41:19 +00:00
"Ignoring all frames and all further mesh groups, too.");
2015-05-19 03:57:13 +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;
}
// our output frame?
2020-02-18 13:41:19 +00:00
if (configFrameID == iFrame) {
BE_NCONST MDL::Vertex_MDL7 *pcFrameVertices = (BE_NCONST MDL::Vertex_MDL7 *)(szCurrent + pcHeader->frame_stc_size);
2015-05-19 03:57:13 +00:00
2020-02-18 13:41:19 +00:00
for (unsigned int qq = 0; qq < frame.pcFrame->vertices_count; ++qq) {
2015-05-19 03:57:13 +00:00
// I assume this are simple replacements for normal vertices, the bone index serving
// as the index of the vertex to be replaced.
2020-02-18 13:41:19 +00:00
uint16_t iIndex = _AI_MDL7_ACCESS(pcFrameVertices, qq, pcHeader->framevertex_stc_size, MDL::Vertex_MDL7).vertindex;
2015-05-19 03:57:13 +00:00
AI_SWAP2(iIndex);
2020-02-18 13:41:19 +00:00
if (iIndex >= groupInfo.pcGroup->numverts) {
2018-04-19 15:21:21 +00:00
ASSIMP_LOG_WARN("Invalid vertex index in frame vertex section");
2015-05-19 03:57:13 +00:00
continue;
}
2020-02-18 13:41:19 +00:00
aiVector3D vPosition, vNormal;
2015-05-19 03:57:13 +00:00
2020-02-18 13:41:19 +00:00
vPosition.x = _AI_MDL7_ACCESS_VERT(pcFrameVertices, qq, pcHeader->framevertex_stc_size).x;
2015-05-19 03:57:13 +00:00
AI_SWAP4(vPosition.x);
2020-02-18 13:41:19 +00:00
vPosition.y = _AI_MDL7_ACCESS_VERT(pcFrameVertices, qq, pcHeader->framevertex_stc_size).y;
2015-05-19 03:57:13 +00:00
AI_SWAP4(vPosition.y);
2020-02-18 13:41:19 +00:00
vPosition.z = _AI_MDL7_ACCESS_VERT(pcFrameVertices, qq, pcHeader->framevertex_stc_size).z;
2015-05-19 03:57:13 +00:00
AI_SWAP4(vPosition.z);
// now read the normal vector
if (AI_MDL7_FRAMEVERTEX030305_STCSIZE <= pcHeader->mainvertex_stc_size) {
// read the full normal vector
2020-02-18 13:41:19 +00:00
vNormal.x = _AI_MDL7_ACCESS_VERT(pcFrameVertices, qq, pcHeader->framevertex_stc_size).norm[0];
2015-05-19 03:57:13 +00:00
AI_SWAP4(vNormal.x);
2020-02-18 13:41:19 +00:00
vNormal.y = _AI_MDL7_ACCESS_VERT(pcFrameVertices, qq, pcHeader->framevertex_stc_size).norm[1];
2015-05-19 03:57:13 +00:00
AI_SWAP4(vNormal.y);
2020-02-18 13:41:19 +00:00
vNormal.z = _AI_MDL7_ACCESS_VERT(pcFrameVertices, qq, pcHeader->framevertex_stc_size).norm[2];
2015-05-19 03:57:13 +00:00
AI_SWAP4(vNormal.z);
2020-02-18 13:41:19 +00:00
} else if (AI_MDL7_FRAMEVERTEX120503_STCSIZE <= pcHeader->mainvertex_stc_size) {
2015-05-19 03:57:13 +00:00
// read the normal vector from Quake2's smart table
2020-02-18 13:41:19 +00:00
MD2::LookupNormalIndex(_AI_MDL7_ACCESS_VERT(pcFrameVertices, qq,
pcHeader->framevertex_stc_size)
.norm162index,
vNormal);
2015-05-19 03:57:13 +00:00
}
// FIXME: O(n^2) at the moment ...
2020-02-18 13:41:19 +00:00
BE_NCONST MDL::Triangle_MDL7 *pcGroupTris = groupInfo.pcGroupTris;
2015-05-19 03:57:13 +00:00
unsigned int iOutIndex = 0;
for (unsigned int iTriangle = 0; iTriangle < (unsigned int)groupInfo.pcGroup->numtris; ++iTriangle) {
// iterate through all indices of the current triangle
2020-02-18 13:41:19 +00:00
for (unsigned int c = 0; c < 3; ++c, ++iOutIndex) {
2015-05-19 03:57:13 +00:00
// replace the vertex with the new data
const unsigned int iCurIndex = pcGroupTris->v_index[c];
2020-02-18 13:41:19 +00:00
if (iCurIndex == iIndex) {
2015-05-19 03:57:13 +00:00
groupData.vPositions[iOutIndex] = vPosition;
groupData.vNormals[iOutIndex] = vNormal;
}
}
// get the next triangle in the list
2020-02-18 13:41:19 +00:00
pcGroupTris = (BE_NCONST MDL::Triangle_MDL7 *)((const char *)
pcGroupTris +
pcHeader->triangle_stc_size);
2015-05-19 03:57:13 +00:00
}
}
}
// parse bone trafo matrix keys (only if there are bones ...)
if (shared.apcOutBones) {
2020-02-18 13:41:19 +00:00
ParseBoneTrafoKeys_3DGS_MDL7(groupInfo, frame, shared);
2015-05-19 03:57:13 +00:00
}
szCurrent += iAdd;
}
*szCurrentOut = szCurrent;
return true;
}
// ------------------------------------------------------------------------------------------------
// Sort faces by material, handle multiple UVs correctly
void MDLImporter::SortByMaterials_3DGS_MDL7(
2020-02-18 13:41:19 +00:00
const MDL::IntGroupInfo_MDL7 &groupInfo,
MDL::IntGroupData_MDL7 &groupData,
MDL::IntSplitGroupData_MDL7 &splitGroupData) {
2015-05-19 03:57:13 +00:00
const unsigned int iNumMaterials = (unsigned int)splitGroupData.shared.pcMats.size();
2020-02-18 13:41:19 +00:00
if (!groupData.bNeed2UV) {
2015-05-19 03:57:13 +00:00
// if we don't need a second set of texture coordinates there is no reason to keep it in memory ...
groupData.vTextureCoords2.clear();
// allocate the array
2020-02-18 13:41:19 +00:00
splitGroupData.aiSplit = new std::vector<unsigned int> *[iNumMaterials];
2015-05-19 03:57:13 +00:00
2020-02-18 13:41:19 +00:00
for (unsigned int m = 0; m < iNumMaterials; ++m)
2015-05-19 03:57:13 +00:00
splitGroupData.aiSplit[m] = new std::vector<unsigned int>();
// iterate through all faces and sort by material
2020-02-18 13:41:19 +00:00
for (unsigned int iFace = 0; iFace < (unsigned int)groupInfo.pcGroup->numtris; ++iFace) {
2015-05-19 03:57:13 +00:00
// check range
if (groupData.pcFaces[iFace].iMatIndex[0] >= iNumMaterials) {
// use the last material instead
2020-02-18 13:41:19 +00:00
splitGroupData.aiSplit[iNumMaterials - 1]->push_back(iFace);
2015-05-19 03:57:13 +00:00
// sometimes MED writes -1, but normally only if there is only
// one skin assigned. No warning in this case
2020-02-18 13:41:19 +00:00
if (0xFFFFFFFF != groupData.pcFaces[iFace].iMatIndex[0])
2018-04-19 15:21:21 +00:00
ASSIMP_LOG_WARN("Index overflow in MDL7 material list [#0]");
2020-02-18 13:41:19 +00:00
} else
splitGroupData.aiSplit[groupData.pcFaces[iFace].iMatIndex[0]]->push_back(iFace);
2015-05-19 03:57:13 +00:00
}
2020-02-18 13:41:19 +00:00
} else {
2015-05-19 03:57:13 +00:00
// we need to build combined materials for each combination of
std::vector<MDL::IntMaterial_MDL7> avMats;
2020-02-18 13:41:19 +00:00
avMats.reserve(iNumMaterials * 2);
2015-05-19 03:57:13 +00:00
// fixme: why on the heap?
2020-02-18 13:41:19 +00:00
std::vector<std::vector<unsigned int> *> aiTempSplit(iNumMaterials * 2);
for (unsigned int m = 0; m < iNumMaterials; ++m)
2015-05-19 03:57:13 +00:00
aiTempSplit[m] = new std::vector<unsigned int>();
// iterate through all faces and sort by material
2020-02-18 13:41:19 +00:00
for (unsigned int iFace = 0; iFace < (unsigned int)groupInfo.pcGroup->numtris; ++iFace) {
2015-05-19 03:57:13 +00:00
// check range
unsigned int iMatIndex = groupData.pcFaces[iFace].iMatIndex[0];
if (iMatIndex >= iNumMaterials) {
// sometimes MED writes -1, but normally only if there is only
// one skin assigned. No warning in this case
2020-02-18 13:41:19 +00:00
if (UINT_MAX != iMatIndex)
2018-04-19 15:21:21 +00:00
ASSIMP_LOG_WARN("Index overflow in MDL7 material list [#1]");
2020-02-18 13:41:19 +00:00
iMatIndex = iNumMaterials - 1;
2015-05-19 03:57:13 +00:00
}
unsigned int iMatIndex2 = groupData.pcFaces[iFace].iMatIndex[1];
unsigned int iNum = iMatIndex;
2020-02-18 13:41:19 +00:00
if (UINT_MAX != iMatIndex2 && iMatIndex != iMatIndex2) {
if (iMatIndex2 >= iNumMaterials) {
2015-05-19 03:57:13 +00:00
// sometimes MED writes -1, but normally only if there is only
// one skin assigned. No warning in this case
2018-04-19 15:21:21 +00:00
ASSIMP_LOG_WARN("Index overflow in MDL7 material list [#2]");
2020-02-18 13:41:19 +00:00
iMatIndex2 = iNumMaterials - 1;
2015-05-19 03:57:13 +00:00
}
2016-04-03 00:38:00 +00:00
// do a slow search in the list ...
2015-05-19 03:57:13 +00:00
iNum = 0;
bool bFound = false;
2020-02-18 13:41:19 +00:00
for (std::vector<MDL::IntMaterial_MDL7>::iterator i = avMats.begin(); i != avMats.end(); ++i, ++iNum) {
if ((*i).iOldMatIndices[0] == iMatIndex && (*i).iOldMatIndices[1] == iMatIndex2) {
2015-05-19 03:57:13 +00:00
// reuse this material
bFound = true;
break;
}
}
2020-02-18 13:41:19 +00:00
if (!bFound) {
2015-05-19 03:57:13 +00:00
// build a new material ...
MDL::IntMaterial_MDL7 sHelper;
sHelper.pcMat = new aiMaterial();
sHelper.iOldMatIndices[0] = iMatIndex;
sHelper.iOldMatIndices[1] = iMatIndex2;
JoinSkins_3DGS_MDL7(splitGroupData.shared.pcMats[iMatIndex],
2020-02-18 13:41:19 +00:00
splitGroupData.shared.pcMats[iMatIndex2], sHelper.pcMat);
2015-05-19 03:57:13 +00:00
// and add it to the list
avMats.push_back(sHelper);
2020-02-18 13:41:19 +00:00
iNum = (unsigned int)avMats.size() - 1;
2015-05-19 03:57:13 +00:00
}
// adjust the size of the file array
if (iNum == aiTempSplit.size()) {
aiTempSplit.push_back(new std::vector<unsigned int>());
}
}
aiTempSplit[iNum]->push_back(iFace);
}
// now add the newly created materials to the old list
2020-02-18 13:41:19 +00:00
if (0 == groupInfo.iIndex) {
2015-05-19 03:57:13 +00:00
splitGroupData.shared.pcMats.resize(avMats.size());
2020-02-18 13:41:19 +00:00
for (unsigned int o = 0; o < avMats.size(); ++o)
2015-05-19 03:57:13 +00:00
splitGroupData.shared.pcMats[o] = avMats[o].pcMat;
2020-02-18 13:41:19 +00:00
} else {
2015-05-19 03:57:13 +00:00
// This might result in redundant materials ...
splitGroupData.shared.pcMats.resize(iNumMaterials + avMats.size());
2020-02-18 13:41:19 +00:00
for (unsigned int o = iNumMaterials; o < avMats.size(); ++o)
2015-05-19 03:57:13 +00:00
splitGroupData.shared.pcMats[o] = avMats[o].pcMat;
}
// and build the final face-to-material array
2020-02-18 13:41:19 +00:00
splitGroupData.aiSplit = new std::vector<unsigned int> *[aiTempSplit.size()];
for (unsigned int m = 0; m < iNumMaterials; ++m)
2015-05-19 03:57:13 +00:00
splitGroupData.aiSplit[m] = aiTempSplit[m];
}
}
// ------------------------------------------------------------------------------------------------
// Read a MDL7 file
2020-02-18 13:41:19 +00:00
void MDLImporter::InternReadFile_3DGS_MDL7() {
ai_assert(nullptr != pScene);
2015-05-19 03:57:13 +00:00
MDL::IntSharedData_MDL7 sharedData;
// current cursor position in the file
2020-02-18 13:41:19 +00:00
BE_NCONST MDL::Header_MDL7 *pcHeader = (BE_NCONST MDL::Header_MDL7 *)this->mBuffer;
const unsigned char *szCurrent = (const unsigned char *)(pcHeader + 1);
2015-05-19 03:57:13 +00:00
AI_SWAP4(pcHeader->version);
AI_SWAP4(pcHeader->bones_num);
AI_SWAP4(pcHeader->groups_num);
AI_SWAP4(pcHeader->data_size);
AI_SWAP4(pcHeader->entlump_size);
AI_SWAP4(pcHeader->medlump_size);
AI_SWAP2(pcHeader->bone_stc_size);
AI_SWAP2(pcHeader->skin_stc_size);
AI_SWAP2(pcHeader->colorvalue_stc_size);
AI_SWAP2(pcHeader->material_stc_size);
AI_SWAP2(pcHeader->skinpoint_stc_size);
AI_SWAP2(pcHeader->triangle_stc_size);
AI_SWAP2(pcHeader->mainvertex_stc_size);
AI_SWAP2(pcHeader->framevertex_stc_size);
AI_SWAP2(pcHeader->bonetrans_stc_size);
AI_SWAP2(pcHeader->frame_stc_size);
// 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 nullptr if they could not been loaded
2015-05-19 03:57:13 +00:00
szCurrent += pcHeader->bones_num * pcHeader->bone_stc_size;
sharedData.apcOutBones = this->LoadBones_3DGS_MDL7();
// vector to held all created meshes
2020-02-18 13:41:19 +00:00
std::vector<aiMesh *> *avOutList;
2015-05-19 03:57:13 +00:00
// 3 meshes per group - that should be OK for most models
2020-02-18 13:41:19 +00:00
avOutList = new std::vector<aiMesh *>[pcHeader->groups_num];
for (uint32_t i = 0; i < pcHeader->groups_num; ++i)
2015-05-19 03:57:13 +00:00
avOutList[i].reserve(3);
// buffer to held the names of all groups in the file
2020-02-18 13:41:19 +00:00
const size_t buffersize(AI_MDL7_MAX_GROUPNAMESIZE * pcHeader->groups_num);
char *aszGroupNameBuffer = new char[buffersize];
2015-05-19 03:57:13 +00:00
// read all groups
2020-02-03 18:06:36 +00:00
for (unsigned int iGroup = 0; iGroup < (unsigned int)pcHeader->groups_num; ++iGroup) {
2020-02-18 13:41:19 +00:00
MDL::IntGroupInfo_MDL7 groupInfo((BE_NCONST MDL::Group_MDL7 *)szCurrent, iGroup);
szCurrent = (const unsigned char *)(groupInfo.pcGroup + 1);
2015-05-19 03:57:13 +00:00
VALIDATE_FILE_SIZE(szCurrent);
AI_SWAP4(groupInfo.pcGroup->groupdata_size);
AI_SWAP4(groupInfo.pcGroup->numskins);
AI_SWAP4(groupInfo.pcGroup->num_stpts);
AI_SWAP4(groupInfo.pcGroup->numtris);
AI_SWAP4(groupInfo.pcGroup->numverts);
AI_SWAP4(groupInfo.pcGroup->numframes);
2020-02-18 13:41:19 +00:00
if (1 != groupInfo.pcGroup->typ) {
2015-05-19 03:57:13 +00:00
// Not a triangle-based mesh
2018-04-19 15:21:21 +00:00
ASSIMP_LOG_WARN("[3DGS MDL7] Not a triangle mesh group. Continuing happily");
2015-05-19 03:57:13 +00:00
}
// store the name of the group
2020-02-18 13:41:19 +00:00
const unsigned int ofs = iGroup * AI_MDL7_MAX_GROUPNAMESIZE;
2015-05-19 03:57:13 +00:00
::memcpy(&aszGroupNameBuffer[ofs],
2020-02-18 13:41:19 +00:00
groupInfo.pcGroup->name, AI_MDL7_MAX_GROUPNAMESIZE);
2015-05-19 03:57:13 +00:00
// make sure '\0' is at the end
2020-02-18 13:41:19 +00:00
aszGroupNameBuffer[ofs + AI_MDL7_MAX_GROUPNAMESIZE - 1] = '\0';
2015-05-19 03:57:13 +00:00
// read all skins
sharedData.pcMats.reserve(sharedData.pcMats.size() + groupInfo.pcGroup->numskins);
sharedData.abNeedMaterials.resize(sharedData.abNeedMaterials.size() +
2020-02-18 13:41:19 +00:00
groupInfo.pcGroup->numskins,
false);
2015-05-19 03:57:13 +00:00
2020-02-18 13:41:19 +00:00
for (unsigned int iSkin = 0; iSkin < (unsigned int)groupInfo.pcGroup->numskins; ++iSkin) {
ParseSkinLump_3DGS_MDL7(szCurrent, &szCurrent, sharedData.pcMats);
2015-05-19 03:57:13 +00:00
}
// if we have absolutely no skin loaded we need to generate a default material
2020-02-18 13:41:19 +00:00
if (sharedData.pcMats.empty()) {
2015-05-19 03:57:13 +00:00
const int iMode = (int)aiShadingMode_Gouraud;
sharedData.pcMats.push_back(new aiMaterial());
2020-02-18 13:41:19 +00:00
aiMaterial *pcHelper = (aiMaterial *)sharedData.pcMats[0];
2015-05-19 03:57:13 +00:00
pcHelper->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL);
aiColor3D clr;
clr.b = clr.g = clr.r = 0.6f;
2020-02-18 13:41:19 +00:00
pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_SPECULAR);
2015-05-19 03:57:13 +00:00
clr.b = clr.g = clr.r = 0.05f;
2020-02-18 13:41:19 +00:00
pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_AMBIENT);
2015-05-19 03:57:13 +00:00
aiString szName;
szName.Set(AI_DEFAULT_MATERIAL_NAME);
2020-02-18 13:41:19 +00:00
pcHelper->AddProperty(&szName, AI_MATKEY_NAME);
2015-05-19 03:57:13 +00:00
2020-02-18 13:41:19 +00:00
sharedData.abNeedMaterials.resize(1, false);
2015-05-19 03:57:13 +00:00
}
// now get a pointer to all texture coords in the group
2020-02-18 13:41:19 +00:00
groupInfo.pcGroupUVs = (BE_NCONST MDL::TexCoord_MDL7 *)szCurrent;
for (int i = 0; i < groupInfo.pcGroup->num_stpts; ++i) {
2015-05-19 03:57:13 +00:00
AI_SWAP4(groupInfo.pcGroupUVs[i].u);
AI_SWAP4(groupInfo.pcGroupUVs[i].v);
}
szCurrent += pcHeader->skinpoint_stc_size * groupInfo.pcGroup->num_stpts;
// now get a pointer to all triangle in the group
2020-02-18 13:41:19 +00:00
groupInfo.pcGroupTris = (Triangle_MDL7 *)szCurrent;
2015-05-19 03:57:13 +00:00
szCurrent += pcHeader->triangle_stc_size * groupInfo.pcGroup->numtris;
// now get a pointer to all vertices in the group
2020-02-18 13:41:19 +00:00
groupInfo.pcGroupVerts = (BE_NCONST MDL::Vertex_MDL7 *)szCurrent;
for (int i = 0; i < groupInfo.pcGroup->numverts; ++i) {
2015-05-19 03:57:13 +00:00
AI_SWAP4(groupInfo.pcGroupVerts[i].x);
AI_SWAP4(groupInfo.pcGroupVerts[i].y);
AI_SWAP4(groupInfo.pcGroupVerts[i].z);
AI_SWAP2(groupInfo.pcGroupVerts[i].vertindex);
//We can not swap the normal information now as we don't know which of the two kinds it is
}
szCurrent += pcHeader->mainvertex_stc_size * groupInfo.pcGroup->numverts;
VALIDATE_FILE_SIZE(szCurrent);
2020-02-18 13:41:19 +00:00
MDL::IntSplitGroupData_MDL7 splitGroupData(sharedData, avOutList[iGroup]);
2015-05-19 03:57:13 +00:00
MDL::IntGroupData_MDL7 groupData;
2020-02-18 13:41:19 +00:00
if (groupInfo.pcGroup->numtris && groupInfo.pcGroup->numverts) {
2015-05-19 03:57:13 +00:00
// build output vectors
2020-02-18 13:41:19 +00:00
const unsigned int iNumVertices = groupInfo.pcGroup->numtris * 3;
2015-05-19 03:57:13 +00:00
groupData.vPositions.resize(iNumVertices);
groupData.vNormals.resize(iNumVertices);
2020-02-18 13:41:19 +00:00
if (sharedData.apcOutBones) groupData.aiBones.resize(iNumVertices, UINT_MAX);
2015-05-19 03:57:13 +00:00
// it is also possible that there are 0 UV coordinate sets
2020-02-18 13:41:19 +00:00
if (groupInfo.pcGroup->num_stpts) {
groupData.vTextureCoords1.resize(iNumVertices, aiVector3D());
2015-05-19 03:57:13 +00:00
// check whether the triangle data structure is large enough
2018-05-13 14:35:03 +00:00
// to contain a second UV coordinate set
2020-02-18 13:41:19 +00:00
if (pcHeader->triangle_stc_size >= AI_MDL7_TRIANGLE_STD_SIZE_TWO_UV) {
groupData.vTextureCoords2.resize(iNumVertices, aiVector3D());
2015-05-19 03:57:13 +00:00
groupData.bNeed2UV = true;
}
}
groupData.pcFaces.resize(groupInfo.pcGroup->numtris);
2015-05-19 03:57:13 +00:00
// read all faces into the preallocated arrays
ReadFaces_3DGS_MDL7(groupInfo, groupData);
// sort by materials
SortByMaterials_3DGS_MDL7(groupInfo, groupData,
2020-02-18 13:41:19 +00:00
splitGroupData);
2015-05-19 03:57:13 +00:00
2020-02-18 13:41:19 +00:00
for (unsigned int qq = 0; qq < sharedData.pcMats.size(); ++qq) {
2015-05-19 03:57:13 +00:00
if (!splitGroupData.aiSplit[qq]->empty())
sharedData.abNeedMaterials[qq] = true;
}
2020-02-18 13:41:19 +00:00
} else
ASSIMP_LOG_WARN("[3DGS MDL7] Mesh group consists of 0 "
"vertices or faces. It will be skipped.");
2015-05-19 03:57:13 +00:00
// process all frames and generate output meshes
2020-02-18 13:41:19 +00:00
ProcessFrames_3DGS_MDL7(groupInfo, groupData, sharedData, szCurrent, &szCurrent);
GenerateOutputMeshes_3DGS_MDL7(groupData, splitGroupData);
2015-05-19 03:57:13 +00:00
}
// generate a nodegraph and subnodes for each group
pScene->mRootNode = new aiNode();
// now we need to build a final mesh list
2020-02-18 13:41:19 +00:00
for (uint32_t i = 0; i < pcHeader->groups_num; ++i)
2015-05-19 03:57:13 +00:00
pScene->mNumMeshes += (unsigned int)avOutList[i].size();
2020-02-18 13:41:19 +00:00
pScene->mMeshes = new aiMesh *[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) {
2015-05-19 03:57:13 +00:00
pScene->mMeshes[p++] = avOutList[i][a];
}
2020-02-18 13:41:19 +00:00
if (!avOutList[i].empty()) ++pScene->mRootNode->mNumChildren;
2015-05-19 03:57:13 +00:00
}
// we will later need an extra node to serve as parent for all bones
2020-02-18 13:41:19 +00:00
if (sharedData.apcOutBones) ++pScene->mRootNode->mNumChildren;
this->pScene->mRootNode->mChildren = new aiNode *[pScene->mRootNode->mNumChildren];
2015-05-19 03:57:13 +00:00
p = 0;
2020-02-18 13:41:19 +00:00
for (uint32_t i = 0; i < pcHeader->groups_num; ++i) {
if (avOutList[i].empty()) continue;
2015-05-19 03:57:13 +00:00
2020-02-18 13:41:19 +00:00
aiNode *const pcNode = pScene->mRootNode->mChildren[p] = new aiNode();
2015-05-19 03:57:13 +00:00
pcNode->mNumMeshes = (unsigned int)avOutList[i].size();
pcNode->mMeshes = new unsigned int[pcNode->mNumMeshes];
pcNode->mParent = this->pScene->mRootNode;
2020-02-18 13:41:19 +00:00
for (unsigned int a = 0; a < pcNode->mNumMeshes; ++a)
2015-05-19 03:57:13 +00:00
pcNode->mMeshes[a] = q + a;
q += (unsigned int)avOutList[i].size();
// setup the name of the node
2020-02-18 13:41:19 +00:00
char *const szBuffer = &aszGroupNameBuffer[i * AI_MDL7_MAX_GROUPNAMESIZE];
if ('\0' == *szBuffer) {
const size_t maxSize(buffersize - (i * AI_MDL7_MAX_GROUPNAMESIZE));
pcNode->mName.length = ai_snprintf(szBuffer, maxSize, "Group_%u", p);
} else {
pcNode->mName.length = (ai_uint32)::strlen(szBuffer);
}
::strncpy(pcNode->mName.data, szBuffer, MAXLEN - 1);
2015-05-19 03:57:13 +00:00
++p;
}
}
// if there is only one root node with a single child we can optimize it a bit ...
2020-02-18 13:41:19 +00:00
if (1 == pScene->mRootNode->mNumChildren && !sharedData.apcOutBones) {
aiNode *pcOldRoot = this->pScene->mRootNode;
2015-05-19 03:57:13 +00:00
pScene->mRootNode = pcOldRoot->mChildren[0];
pcOldRoot->mChildren[0] = nullptr;
2015-05-19 03:57:13 +00:00
delete pcOldRoot;
pScene->mRootNode->mParent = nullptr;
2020-02-18 13:41:19 +00:00
} else
pScene->mRootNode->mName.Set("<mesh_root>");
2015-05-19 03:57:13 +00:00
delete[] avOutList;
delete[] aszGroupNameBuffer;
AI_DEBUG_INVALIDATE_PTR(avOutList);
AI_DEBUG_INVALIDATE_PTR(aszGroupNameBuffer);
// build a final material list.
CopyMaterials_3DGS_MDL7(sharedData);
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
2020-02-18 13:41:19 +00:00
aiNode *const pc = pScene->mRootNode->mChildren[pScene->mRootNode->mNumChildren - 1] = new aiNode();
2015-05-19 03:57:13 +00:00
pc->mName.Set("<skeleton_root>");
// add bones to the nodegraph
AddBonesToNodeGraph_3DGS_MDL7((const Assimp::MDL::IntBone_MDL7 **)
2020-02-18 13:41:19 +00:00
sharedData.apcOutBones,
pc, 0xffff);
2015-05-19 03:57:13 +00:00
// this steps build a valid output animation
BuildOutputAnims_3DGS_MDL7((const Assimp::MDL::IntBone_MDL7 **)
2020-02-18 13:41:19 +00:00
sharedData.apcOutBones);
2015-05-19 03:57:13 +00:00
}
}
// ------------------------------------------------------------------------------------------------
// Copy materials
2020-02-18 13:41:19 +00:00
void MDLImporter::CopyMaterials_3DGS_MDL7(MDL::IntSharedData_MDL7 &shared) {
2015-05-19 03:57:13 +00:00
pScene->mNumMaterials = (unsigned int)shared.pcMats.size();
2020-02-18 13:41:19 +00:00
pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
for (unsigned int i = 0; i < pScene->mNumMaterials; ++i)
2015-05-19 03:57:13 +00:00
pScene->mMaterials[i] = shared.pcMats[i];
}
// ------------------------------------------------------------------------------------------------
// Process material references
2020-02-18 13:41:19 +00:00
void MDLImporter::HandleMaterialReferences_3DGS_MDL7() {
2015-05-19 03:57:13 +00:00
// search for referrer materials
2020-02-18 13:41:19 +00:00
for (unsigned int i = 0; i < pScene->mNumMaterials; ++i) {
2015-05-19 03:57:13 +00:00
int iIndex = 0;
2020-02-18 13:41:19 +00:00
if (AI_SUCCESS == aiGetMaterialInteger(pScene->mMaterials[i], AI_MDL7_REFERRER_MATERIAL, &iIndex)) {
for (unsigned int a = 0; a < pScene->mNumMeshes; ++a) {
aiMesh *const pcMesh = pScene->mMeshes[a];
2015-05-19 03:57:13 +00:00
if (i == pcMesh->mMaterialIndex) {
pcMesh->mMaterialIndex = iIndex;
}
}
// collapse the rest of the array
delete pScene->mMaterials[i];
2020-02-18 13:41:19 +00:00
for (unsigned int pp = i; pp < pScene->mNumMaterials - 1; ++pp) {
2015-05-19 03:57:13 +00:00
2020-02-18 13:41:19 +00:00
pScene->mMaterials[pp] = pScene->mMaterials[pp + 1];
for (unsigned int a = 0; a < pScene->mNumMeshes; ++a) {
aiMesh *const pcMesh = pScene->mMeshes[a];
if (pcMesh->mMaterialIndex > i) --pcMesh->mMaterialIndex;
2015-05-19 03:57:13 +00:00
}
}
--pScene->mNumMaterials;
}
}
}
// ------------------------------------------------------------------------------------------------
// Read bone transformation keys
void MDLImporter::ParseBoneTrafoKeys_3DGS_MDL7(
2020-02-18 13:41:19 +00:00
const MDL::IntGroupInfo_MDL7 &groupInfo,
IntFrameInfo_MDL7 &frame,
MDL::IntSharedData_MDL7 &shared) {
const MDL::Header_MDL7 *const pcHeader = (const MDL::Header_MDL7 *)this->mBuffer;
2015-05-19 03:57:13 +00:00
// only the first group contains bone animation keys
2020-02-18 13:41:19 +00:00
if (frame.pcFrame->transmatrix_count) {
if (!groupInfo.iIndex) {
2015-05-19 03:57:13 +00:00
// skip all frames vertices. We can't support them
2020-02-18 13:41:19 +00:00
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);
2015-05-19 03:57:13 +00:00
// read all transformation matrices
2020-02-18 13:41:19 +00:00
for (unsigned int iTrafo = 0; iTrafo < frame.pcFrame->transmatrix_count; ++iTrafo) {
if (pcBoneTransforms->bone_index >= pcHeader->bones_num) {
2018-04-19 15:21:21 +00:00
ASSIMP_LOG_WARN("Index overflow in frame area. "
2020-02-18 13:41:19 +00:00
"Unable to parse this bone transformation");
} else {
2015-05-19 03:57:13 +00:00
AddAnimationBoneTrafoKey_3DGS_MDL7(frame.iIndex,
2020-02-18 13:41:19 +00:00
pcBoneTransforms, shared.apcOutBones);
2015-05-19 03:57:13 +00:00
}
2020-02-18 13:41:19 +00:00
pcBoneTransforms = (const MDL::BoneTransform_MDL7 *)((const char *)pcBoneTransforms + pcHeader->bonetrans_stc_size);
2015-05-19 03:57:13 +00:00
}
2020-02-18 13:41:19 +00:00
} else {
2018-04-19 15:21:21 +00:00
ASSIMP_LOG_WARN("Ignoring animation keyframes in groups != 0");
2015-05-19 03:57:13 +00:00
}
}
}
// ------------------------------------------------------------------------------------------------
// Attach bones to the output nodegraph
2020-02-18 13:41:19 +00:00
void MDLImporter::AddBonesToNodeGraph_3DGS_MDL7(const MDL::IntBone_MDL7 **apcBones,
aiNode *pcParent, uint16_t iParentIndex) {
ai_assert(nullptr != apcBones);
ai_assert(nullptr != pcParent);
2015-05-19 03:57:13 +00:00
// get a pointer to the header ...
2020-02-18 13:41:19 +00:00
const MDL::Header_MDL7 *const pcHeader = (const MDL::Header_MDL7 *)this->mBuffer;
2020-02-18 13:41:19 +00:00
const MDL::IntBone_MDL7 **apcBones2 = apcBones;
for (uint32_t i = 0; i < pcHeader->bones_num; ++i) {
2020-02-18 13:41:19 +00:00
const MDL::IntBone_MDL7 *const pcBone = *apcBones2++;
2015-05-19 03:57:13 +00:00
if (pcBone->iParent == iParentIndex) {
++pcParent->mNumChildren;
}
}
2020-02-18 13:41:19 +00:00
pcParent->mChildren = new aiNode *[pcParent->mNumChildren];
2015-05-19 03:57:13 +00:00
unsigned int qq = 0;
2020-02-18 13:41:19 +00:00
for (uint32_t i = 0; i < pcHeader->bones_num; ++i) {
2020-02-18 13:41:19 +00:00
const MDL::IntBone_MDL7 *const pcBone = *apcBones++;
if (pcBone->iParent != iParentIndex) continue;
2020-02-18 13:41:19 +00:00
aiNode *pcNode = pcParent->mChildren[qq++] = new aiNode();
pcNode->mName = aiString(pcBone->mName);
2020-02-18 13:41:19 +00:00
AddBonesToNodeGraph_3DGS_MDL7(apcBones, pcNode, (uint16_t)i);
2015-05-19 03:57:13 +00:00
}
}
// ------------------------------------------------------------------------------------------------
// Build output animations
void MDLImporter::BuildOutputAnims_3DGS_MDL7(
2020-02-18 13:41:19 +00:00
const MDL::IntBone_MDL7 **apcBonesOut) {
ai_assert(nullptr != apcBonesOut);
2020-02-18 13:41:19 +00:00
const MDL::Header_MDL7 *const pcHeader = (const MDL::Header_MDL7 *)mBuffer;
2015-05-19 03:57:13 +00:00
// one animation ...
2020-02-18 13:41:19 +00:00
aiAnimation *pcAnim = new aiAnimation();
for (uint32_t i = 0; i < pcHeader->bones_num; ++i) {
2015-05-19 03:57:13 +00:00
if (!apcBonesOut[i]->pkeyPositions.empty()) {
// get the last frame ... (needn't be equal to pcHeader->frames_num)
2020-02-18 13:41:19 +00:00
for (size_t qq = 0; qq < apcBonesOut[i]->pkeyPositions.size(); ++qq) {
2015-05-19 03:57:13 +00:00
pcAnim->mDuration = std::max(pcAnim->mDuration, (double)
2020-02-18 13:41:19 +00:00
apcBonesOut[i]
->pkeyPositions[qq]
.mTime);
2015-05-19 03:57:13 +00:00
}
++pcAnim->mNumChannels;
}
}
2020-02-18 13:41:19 +00:00
if (pcAnim->mDuration) {
pcAnim->mChannels = new aiNodeAnim *[pcAnim->mNumChannels];
2015-05-19 03:57:13 +00:00
unsigned int iCnt = 0;
2020-02-18 13:41:19 +00:00
for (uint32_t i = 0; i < pcHeader->bones_num; ++i) {
2015-05-19 03:57:13 +00:00
if (!apcBonesOut[i]->pkeyPositions.empty()) {
2020-02-18 13:41:19 +00:00
const MDL::IntBone_MDL7 *const intBone = apcBonesOut[i];
2015-05-19 03:57:13 +00:00
2020-02-18 13:41:19 +00:00
aiNodeAnim *const pcNodeAnim = pcAnim->mChannels[iCnt++] = new aiNodeAnim();
pcNodeAnim->mNodeName = aiString(intBone->mName);
2015-05-19 03:57:13 +00:00
// allocate enough storage for all keys
pcNodeAnim->mNumPositionKeys = (unsigned int)intBone->pkeyPositions.size();
2020-02-18 13:41:19 +00:00
pcNodeAnim->mNumScalingKeys = (unsigned int)intBone->pkeyPositions.size();
2015-05-19 03:57:13 +00:00
pcNodeAnim->mNumRotationKeys = (unsigned int)intBone->pkeyPositions.size();
pcNodeAnim->mPositionKeys = new aiVectorKey[pcNodeAnim->mNumPositionKeys];
2020-02-18 13:41:19 +00:00
pcNodeAnim->mScalingKeys = new aiVectorKey[pcNodeAnim->mNumPositionKeys];
2015-05-19 03:57:13 +00:00
pcNodeAnim->mRotationKeys = new aiQuatKey[pcNodeAnim->mNumPositionKeys];
// copy all keys
2020-02-18 13:41:19 +00:00
for (unsigned int qq = 0; qq < pcNodeAnim->mNumPositionKeys; ++qq) {
2015-05-19 03:57:13 +00:00
pcNodeAnim->mPositionKeys[qq] = intBone->pkeyPositions[qq];
pcNodeAnim->mScalingKeys[qq] = intBone->pkeyScalings[qq];
pcNodeAnim->mRotationKeys[qq] = intBone->pkeyRotations[qq];
}
}
}
// store the output animation
pScene->mNumAnimations = 1;
2020-02-18 13:41:19 +00:00
pScene->mAnimations = new aiAnimation *[1];
2015-05-19 03:57:13 +00:00
pScene->mAnimations[0] = pcAnim;
2020-02-18 13:41:19 +00:00
} else
delete pcAnim;
}
// ------------------------------------------------------------------------------------------------
void MDLImporter::AddAnimationBoneTrafoKey_3DGS_MDL7(unsigned int iTrafo,
2020-02-18 13:41:19 +00:00
const MDL::BoneTransform_MDL7 *pcBoneTransforms,
MDL::IntBone_MDL7 **apcBonesOut) {
ai_assert(nullptr != pcBoneTransforms);
ai_assert(nullptr != apcBonesOut);
2015-05-19 03:57:13 +00:00
// 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
2020-02-18 13:41:19 +00:00
aiVectorKey vScaling, vPosition;
2015-05-19 03:57:13 +00:00
aiQuatKey qRotation;
// FIXME: Decompose will assert in debug builds if the matrix is invalid ...
2020-02-18 13:41:19 +00:00
mTransform.Decompose(vScaling.mValue, qRotation.mValue, vPosition.mValue);
2015-05-19 03:57:13 +00:00
// now generate keys
vScaling.mTime = qRotation.mTime = vPosition.mTime = (double)iTrafo;
// add the keys to the bone
2020-02-18 13:41:19 +00:00
MDL::IntBone_MDL7 *const pcBoneOut = apcBonesOut[pcBoneTransforms->bone_index];
pcBoneOut->pkeyPositions.push_back(vPosition);
pcBoneOut->pkeyScalings.push_back(vScaling);
pcBoneOut->pkeyRotations.push_back(qRotation);
}
// ------------------------------------------------------------------------------------------------
// Construct output meshes
void MDLImporter::GenerateOutputMeshes_3DGS_MDL7(
2020-02-18 13:41:19 +00:00
MDL::IntGroupData_MDL7 &groupData,
MDL::IntSplitGroupData_MDL7 &splitGroupData) {
const MDL::IntSharedData_MDL7 &shared = splitGroupData.shared;
2015-05-19 03:57:13 +00:00
// get a pointer to the header ...
2020-02-18 13:41:19 +00:00
const MDL::Header_MDL7 *const pcHeader = (const MDL::Header_MDL7 *)this->mBuffer;
2015-05-19 03:57:13 +00:00
const unsigned int iNumOutBones = pcHeader->bones_num;
2020-02-18 13:41:19 +00:00
for (std::vector<aiMaterial *>::size_type i = 0; i < shared.pcMats.size(); ++i) {
if (!splitGroupData.aiSplit[i]->empty()) {
2015-05-19 03:57:13 +00:00
// allocate the output mesh
2020-02-18 13:41:19 +00:00
aiMesh *pcMesh = new aiMesh();
2015-05-19 03:57:13 +00:00
pcMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
pcMesh->mMaterialIndex = (unsigned int)i;
// allocate output storage
pcMesh->mNumFaces = (unsigned int)splitGroupData.aiSplit[i]->size();
pcMesh->mFaces = new aiFace[pcMesh->mNumFaces];
2020-02-18 13:41:19 +00:00
pcMesh->mNumVertices = pcMesh->mNumFaces * 3;
2015-05-19 03:57:13 +00:00
pcMesh->mVertices = new aiVector3D[pcMesh->mNumVertices];
pcMesh->mNormals = new aiVector3D[pcMesh->mNumVertices];
if (!groupData.vTextureCoords1.empty()) {
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];
}
}
// iterate through all faces and build an unique set of vertices
unsigned int iCurrent = 0;
2020-02-18 13:41:19 +00:00
for (unsigned int iFace = 0; iFace < pcMesh->mNumFaces; ++iFace) {
2015-05-19 03:57:13 +00:00
pcMesh->mFaces[iFace].mNumIndices = 3;
pcMesh->mFaces[iFace].mIndices = new unsigned int[3];
unsigned int iSrcFace = splitGroupData.aiSplit[i]->operator[](iFace);
2020-02-18 13:41:19 +00:00
const MDL::IntFace_MDL7 &oldFace = groupData.pcFaces[iSrcFace];
2015-05-19 03:57:13 +00:00
// iterate through all face indices
2020-02-18 13:41:19 +00:00
for (unsigned int c = 0; c < 3; ++c) {
2015-05-19 03:57:13 +00:00
const uint32_t iIndex = oldFace.mIndices[c];
pcMesh->mVertices[iCurrent] = groupData.vPositions[iIndex];
pcMesh->mNormals[iCurrent] = groupData.vNormals[iIndex];
if (!groupData.vTextureCoords1.empty()) {
pcMesh->mTextureCoords[0][iCurrent] = groupData.vTextureCoords1[iIndex];
if (!groupData.vTextureCoords2.empty()) {
pcMesh->mTextureCoords[1][iCurrent] = groupData.vTextureCoords2[iIndex];
}
}
pcMesh->mFaces[iFace].mIndices[c] = iCurrent++;
}
}
// if we have bones in the mesh we'll need to generate
// proper vertex weights for them
if (!groupData.aiBones.empty()) {
2020-02-18 13:41:19 +00:00
std::vector<std::vector<unsigned int>> aaiVWeightList;
2015-05-19 03:57:13 +00:00
aaiVWeightList.resize(iNumOutBones);
2020-02-18 13:41:19 +00:00
int iCurrentWeight = 0;
for (unsigned int iFace = 0; iFace < pcMesh->mNumFaces; ++iFace) {
2015-05-19 03:57:13 +00:00
unsigned int iSrcFace = splitGroupData.aiSplit[i]->operator[](iFace);
2020-02-18 13:41:19 +00:00
const MDL::IntFace_MDL7 &oldFace = groupData.pcFaces[iSrcFace];
2015-05-19 03:57:13 +00:00
// iterate through all face indices
2020-02-18 13:41:19 +00:00
for (unsigned int c = 0; c < 3; ++c) {
unsigned int iBone = groupData.aiBones[oldFace.mIndices[c]];
if (UINT_MAX != iBone) {
if (iBone >= iNumOutBones) {
2018-04-26 12:10:18 +00:00
ASSIMP_LOG_ERROR("Bone index overflow. "
2020-02-18 13:41:19 +00:00
"The bone index of a vertex exceeds the allowed range. ");
iBone = iNumOutBones - 1;
2015-05-19 03:57:13 +00:00
}
2020-02-18 13:41:19 +00:00
aaiVWeightList[iBone].push_back(iCurrentWeight);
2015-05-19 03:57:13 +00:00
}
2020-02-18 13:41:19 +00:00
++iCurrentWeight;
2015-05-19 03:57:13 +00:00
}
}
// now check which bones are required ...
2020-02-18 13:41:19 +00:00
for (std::vector<std::vector<unsigned int>>::const_iterator k = aaiVWeightList.begin(); k != aaiVWeightList.end(); ++k) {
2015-05-19 03:57:13 +00:00
if (!(*k).empty()) {
++pcMesh->mNumBones;
}
}
2020-02-18 13:41:19 +00:00
pcMesh->mBones = new aiBone *[pcMesh->mNumBones];
2015-05-19 03:57:13 +00:00
iCurrent = 0;
2020-02-18 13:41:19 +00:00
for (std::vector<std::vector<unsigned int>>::const_iterator k = aaiVWeightList.begin(); k != aaiVWeightList.end(); ++k, ++iCurrent) {
2015-05-19 03:57:13 +00:00
if ((*k).empty())
continue;
// seems we'll need this node
2020-02-18 13:41:19 +00:00
aiBone *pcBone = pcMesh->mBones[iCurrent] = new aiBone();
pcBone->mName = aiString(shared.apcOutBones[iCurrent]->mName);
pcBone->mOffsetMatrix = shared.apcOutBones[iCurrent]->mOffsetMatrix;
2015-05-19 03:57:13 +00:00
// setup vertex weights
pcBone->mNumWeights = (unsigned int)(*k).size();
pcBone->mWeights = new aiVertexWeight[pcBone->mNumWeights];
2020-02-18 13:41:19 +00:00
for (unsigned int weight = 0; weight < pcBone->mNumWeights; ++weight) {
2015-05-19 03:57:13 +00:00
pcBone->mWeights[weight].mVertexId = (*k)[weight];
pcBone->mWeights[weight].mWeight = 1.0f;
}
}
}
// add the mesh to the list of output meshes
splitGroupData.avOutList.push_back(pcMesh);
}
}
}
// ------------------------------------------------------------------------------------------------
// Join to materials
void MDLImporter::JoinSkins_3DGS_MDL7(
2020-02-18 13:41:19 +00:00
aiMaterial *pcMat1,
aiMaterial *pcMat2,
aiMaterial *pcMatOut) {
ai_assert(nullptr != pcMat1);
ai_assert(nullptr != pcMat2);
ai_assert(nullptr != pcMatOut);
2015-05-19 03:57:13 +00:00
// first create a full copy of the first skin property set
// and assign it to the output material
2020-02-18 13:41:19 +00:00
aiMaterial::CopyPropertyList(pcMatOut, pcMat1);
2015-05-19 03:57:13 +00:00
int iVal = 0;
2020-02-18 13:41:19 +00:00
pcMatOut->AddProperty<int>(&iVal, 1, AI_MATKEY_UVWSRC_DIFFUSE(0));
2015-05-19 03:57:13 +00:00
// then extract the diffuse texture from the second skin,
// setup 1 as UV source and we have it
aiString sString;
2020-02-18 13:41:19 +00:00
if (AI_SUCCESS == aiGetMaterialString(pcMat2, AI_MATKEY_TEXTURE_DIFFUSE(0), &sString)) {
2015-05-19 03:57:13 +00:00
iVal = 1;
2020-02-18 13:41:19 +00:00
pcMatOut->AddProperty<int>(&iVal, 1, AI_MATKEY_UVWSRC_DIFFUSE(1));
pcMatOut->AddProperty(&sString, AI_MATKEY_TEXTURE_DIFFUSE(1));
2015-05-19 03:57:13 +00:00
}
}
// ------------------------------------------------------------------------------------------------
// Read a Half-life 1 MDL
2020-02-18 13:41:19 +00:00
void MDLImporter::InternReadFile_HL1(const std::string &pFile, const uint32_t iMagicWord) {
// We can't correctly load an MDL from a MDL "sequence" file.
if (iMagicWord == AI_MDL_MAGIC_NUMBER_BE_HL2b || iMagicWord == AI_MDL_MAGIC_NUMBER_LE_HL2b)
throw DeadlyImportError("Impossible to properly load a model from an MDL sequence file.");
// Read the MDL file.
HalfLife::HL1MDLLoader loader(
2020-02-18 13:41:19 +00:00
pScene,
mIOHandler,
mBuffer,
pFile,
mHL1ImportSettings);
}
// ------------------------------------------------------------------------------------------------
// Read a half-life 2 MDL
2020-02-18 13:41:19 +00:00
void MDLImporter::InternReadFile_HL2() {
2015-05-19 03:57:13 +00:00
//const MDL::Header_HL2* pcHeader = (const MDL::Header_HL2*)this->mBuffer;
throw DeadlyImportError("HL2 MDLs are not implemented");
}
#endif // !! ASSIMP_BUILD_NO_MDL_IMPORTER