iw4x-client/src/Components/Modules/AssetInterfaces/IXModel.cpp

393 lines
12 KiB
C++
Raw Normal View History

2016-07-11 11:14:58 -04:00
#include <STDInclude.hpp>
2017-01-01 14:04:20 -05:00
#define IW4X_MODEL_VERSION 3
2016-07-11 11:14:58 -04:00
namespace Assets
{
void IXModel::load(Game::XAssetHeader* header, std::string name, Components::ZoneBuilder::Zone* builder)
2016-07-11 11:14:58 -04:00
{
Components::FileSystem::File modelFile(fmt::sprintf("xmodel/%s.iw4xModel", name.data()));
if (modelFile.exists())
2016-07-11 11:14:58 -04:00
{
Game::XModel* baseModel = Components::AssetHandler::FindOriginalAsset(Game::XAssetType::ASSET_TYPE_XMODEL, "viewmodel_mp5k").model;
// Allocate new model and copy the base data to it
Game::XModel* model = builder->getAllocator()->allocate<Game::XModel>();
2016-07-11 11:14:58 -04:00
std::memcpy(model, baseModel, sizeof(Game::XModel));
Utils::Stream::Reader reader(builder->getAllocator(), modelFile.getBuffer());
2016-07-11 11:14:58 -04:00
if (reader.read<__int64>() != *reinterpret_cast<__int64*>("IW4xModl"))
{
Components::Logger::Error(0, "Reading model '%s' failed, header is invalid!", name.data());
}
int version = reader.read<int>();
if (version != IW4X_MODEL_VERSION)
{
Components::Logger::Error(0, "Reading model '%s' failed, expected version is %d, but it was %d!", name.data(), IW4X_MODEL_VERSION, version);
}
model->name = reader.readCString();
model->numBones = reader.readByte();
model->numRootBones = reader.readByte();
model->numSurfaces = reader.read<unsigned char>();
model->numColSurfs = reader.read<int>();
2017-01-01 14:04:20 -05:00
model->numLods = static_cast<char>(reader.read<short>());
model->collLod = reader.read<short>();
2016-07-11 11:14:58 -04:00
// Read bone names
model->boneNames = builder->getAllocator()->allocateArray<short>(model->numBones);
2016-07-11 11:14:58 -04:00
for (int i = 0; i < model->numBones; ++i)
{
model->boneNames[i] = Game::SL_GetString(reader.readCString(), 0);
2016-07-11 11:14:58 -04:00
}
// Bone count
int boneCount = (model->numBones - model->numRootBones);
// Read bone data
model->parentList = reader.readArray<char>(boneCount);
model->tagAngles = reader.readArray<Game::XModelAngle>(boneCount);
model->tagPositions = reader.readArray<Game::XModelTagPos>(boneCount);
model->partClassification = reader.readArray<char>(boneCount);
model->animMatrix = reader.readArray<Game::DObjAnimMat>(boneCount);
2016-07-11 11:14:58 -04:00
// Prepare surfaces
2017-01-01 14:04:20 -05:00
Game::XModelSurfs surf;
Utils::Memory::Allocator allocator;
Game::XSurface* baseSurface = &baseModel->lods[0].modelSurfs[0].surfaces[0];
2016-07-11 11:14:58 -04:00
2017-01-01 14:04:20 -05:00
std::memcpy(&surf, baseModel->lods[0].modelSurfs, sizeof(Game::XModelSurfs));
surf.surfaces = allocator.allocateArray<Game::XSurface>(model->numSurfaces);
surf.numSurfaces = model->numSurfaces;
2016-07-11 11:14:58 -04:00
2017-01-01 14:04:20 -05:00
for (int i = 0; i < 4; ++i)
2016-07-11 11:14:58 -04:00
{
2017-01-01 14:04:20 -05:00
model->lods[i].dist = reader.read<float>();
model->lods[i].numsurfs = reader.read<unsigned short>();
model->lods[i].surfIndex = reader.read<unsigned short>();
model->lods[i].partBits[0] = reader.read<int>();
model->lods[i].partBits[1] = reader.read<int>();
model->lods[i].partBits[2] = reader.read<int>();
model->lods[i].partBits[3] = reader.read<int>();
model->lods[i].partBits[4] = 0;
model->lods[i].partBits[5] = 0;
2016-07-11 11:14:58 -04:00
}
// Read surfaces
2017-01-01 14:04:20 -05:00
for (int i = 0; i < surf.numSurfaces; ++i)
2016-07-11 11:14:58 -04:00
{
2017-01-01 14:04:20 -05:00
Game::XSurface* surface = &surf.surfaces[i];
2016-07-11 11:14:58 -04:00
std::memcpy(surface, baseSurface, sizeof(Game::XSurface));
surface->tileMode = reader.read<char>();
surface->deformed = reader.read<char>();
2016-11-05 21:24:30 -04:00
surface->streamHandle = reader.read<unsigned char>();
2016-12-20 12:15:28 -05:00
surface->partBits[0] = reader.read<int>();
surface->partBits[1] = reader.read<int>();
surface->partBits[2] = reader.read<int>();
surface->partBits[3] = reader.read<int>();
2017-01-01 14:04:20 -05:00
surface->partBits[4] = 0;
surface->partBits[5] = 0;
2016-07-11 11:14:58 -04:00
2016-12-20 12:15:28 -05:00
surface->baseTriIndex = reader.read<unsigned __int16>();
surface->baseVertIndex = reader.read<unsigned __int16>();
2016-11-05 21:24:30 -04:00
surface->numVertices = reader.read<unsigned short>();
surface->numPrimitives = reader.read<unsigned short>();
surface->numCT = reader.read<int>();
2016-07-11 11:14:58 -04:00
surface->blendNum1 = reader.read<short>();
surface->blendNum2 = reader.read<short>();
surface->blendNum3 = reader.read<short>();
surface->blendNum4 = reader.read<short>();
2016-07-11 11:14:58 -04:00
surface->blendInfo = reinterpret_cast<char*>(reader.read(2, surface->blendNum1 + (3 * surface->blendNum2) + (5 * surface->blendNum3) + (7 * surface->blendNum4)));
2016-07-11 11:14:58 -04:00
surface->vertexBuffer = reader.readArray<Game::GfxPackedVertex>(surface->numVertices);
surface->indexBuffer = reader.readArray<Game::Face>(surface->numPrimitives);
2016-07-11 11:14:58 -04:00
// Read vert list
if (reader.readByte())
2016-07-11 11:14:58 -04:00
{
surface->ct = reader.readArray<Game::XRigidVertList>(surface->numCT);
2016-07-11 11:14:58 -04:00
for (int j = 0; j < surface->numCT; ++j)
{
Game::XRigidVertList* vertList = &surface->ct[j];
vertList->entry = reader.readArray<Game::XSurfaceCollisionTree>();
vertList->entry->node = reinterpret_cast<char*>(reader.read(16, vertList->entry->numNode));
vertList->entry->leaf = reader.readArray<short>(vertList->entry->numLeaf);
2016-07-11 11:14:58 -04:00
}
}
else
{
surface->ct = nullptr;
}
}
2017-01-01 14:04:20 -05:00
// When all surfaces are loaded, split them up.
for (char i = 0; i < model->numLods; ++i)
{
Game::XModelSurfs* realSurf = builder->getAllocator()->allocate<Game::XModelSurfs>();
// Usually, a binary representation is used for the index, but meh.
realSurf->name = builder->getAllocator()->duplicateString(fmt::sprintf("%s_lod%d", model->name, i & 0xFF));
realSurf->numSurfaces = model->lods[i].numsurfs;
realSurf->surfaces = builder->getAllocator()->allocateArray<Game::XSurface>(realSurf->numSurfaces);
std::memcpy(realSurf->surfaces, &surf.surfaces[model->lods[i].surfIndex], sizeof(Game::XSurface) * realSurf->numSurfaces);
std::memcpy(realSurf->partBits, model->lods[i].partBits, sizeof(realSurf->partBits));
model->lods[i].modelSurfs = realSurf;
model->lods[i].surfs = realSurf->surfaces;
// Store surfs for later writing
Components::AssetHandler::StoreTemporaryAsset(Game::XAssetType::ASSET_TYPE_XMODELSURFS, { realSurf });
}
2016-07-11 11:14:58 -04:00
// Read materials
model->materials = builder->getAllocator()->allocateArray<Game::Material*>(model->numSurfaces);
for (unsigned char i = 0; i < model->numSurfaces; ++i)
2016-07-11 11:14:58 -04:00
{
model->materials[i] = Components::AssetHandler::FindAssetForZone(Game::XAssetType::ASSET_TYPE_MATERIAL, reader.readString(), builder).material;
2016-07-11 11:14:58 -04:00
}
// Read collision surfaces
if (reader.readByte())
2016-07-11 11:14:58 -04:00
{
model->colSurf = reader.readArray<Game::XModelCollSurf>(model->numColSurfs);
2016-07-11 11:14:58 -04:00
for (int i = 0; i < model->numColSurfs; ++i)
{
2017-01-02 13:31:32 -05:00
if (model->colSurf[i].collTris)
2016-07-11 11:14:58 -04:00
{
2017-01-02 13:31:32 -05:00
model->colSurf[i].collTris = reader.readArray<Game::XModelCollTri_s>(model->colSurf[i].numCollTris);
2016-07-11 11:14:58 -04:00
}
}
}
else
{
model->colSurf = nullptr;
}
// Read bone info
if (reader.readByte())
2016-07-11 11:14:58 -04:00
{
model->boneInfo = reader.readArray<Game::XBoneInfo>(model->numBones);
2016-07-11 11:14:58 -04:00
}
else
{
model->boneInfo = nullptr;
}
if (!reader.end())
2016-07-11 11:14:58 -04:00
{
Components::Logger::Error(0, "Reading model '%s' failed, remaining raw data found!", name.data());
}
header->model = model;
}
}
void IXModel::mark(Game::XAssetHeader header, Components::ZoneBuilder::Zone* builder)
2016-07-11 11:14:58 -04:00
{
Game::XModel* asset = header.model;
if (asset->boneNames)
{
for (char i = 0; i < asset->numBones; ++i)
{
builder->addScriptString(asset->boneNames[i]);
2016-07-11 11:14:58 -04:00
}
}
if (asset->materials)
{
for (unsigned char i = 0; i < asset->numSurfaces; ++i)
2016-07-11 11:14:58 -04:00
{
if (asset->materials[i])
{
builder->loadAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, asset->materials[i]);
2016-07-11 11:14:58 -04:00
}
}
}
for (int i = 0; i < 4; ++i)
{
2017-01-01 14:04:20 -05:00
if (asset->lods[i].modelSurfs)
2016-07-11 11:14:58 -04:00
{
2017-01-01 14:04:20 -05:00
builder->loadAsset(Game::XAssetType::ASSET_TYPE_XMODELSURFS, asset->lods[i].modelSurfs);
2016-07-11 11:14:58 -04:00
}
}
if (asset->physPreset)
{
builder->loadAsset(Game::XAssetType::ASSET_TYPE_PHYSPRESET, asset->physPreset);
2016-07-11 11:14:58 -04:00
}
if (asset->physCollmap)
{
builder->loadAsset(Game::XAssetType::ASSET_TYPE_PHYS_COLLMAP, asset->physCollmap);
2016-07-11 11:14:58 -04:00
}
}
void IXModel::save(Game::XAssetHeader header, Components::ZoneBuilder::Zone* builder)
2016-07-11 11:14:58 -04:00
{
AssertSize(Game::XModel, 304);
2016-07-11 11:14:58 -04:00
Utils::Stream* buffer = builder->getBuffer();
2016-07-11 11:14:58 -04:00
Game::XModel* asset = header.model;
Game::XModel* dest = buffer->dest<Game::XModel>();
buffer->save(asset);
2016-07-11 11:14:58 -04:00
buffer->pushBlock(Game::XFILE_BLOCK_VIRTUAL);
2016-07-11 11:14:58 -04:00
if (asset->name)
{
buffer->saveString(builder->getAssetName(this->getType(), asset->name));
2016-07-11 11:14:58 -04:00
Utils::Stream::ClearPointer(&dest->name);
}
if (asset->boneNames)
{
buffer->align(Utils::Stream::ALIGN_2);
2016-07-11 11:14:58 -04:00
unsigned short* destBoneNames = buffer->dest<unsigned short>();
buffer->saveArray(asset->boneNames, asset->numBones);
2016-07-11 11:14:58 -04:00
for (char i = 0; i < asset->numBones; ++i)
{
builder->mapScriptString(&destBoneNames[i]);
2016-07-11 11:14:58 -04:00
}
Utils::Stream::ClearPointer(&dest->boneNames);
}
if (asset->parentList)
{
buffer->save(asset->parentList, asset->numBones - asset->numRootBones);
2016-07-11 11:14:58 -04:00
Utils::Stream::ClearPointer(&dest->parentList);
}
if (asset->tagAngles)
{
AssertSize(Game::XModelAngle, 8);
2016-07-11 11:14:58 -04:00
buffer->align(Utils::Stream::ALIGN_2);
buffer->saveArray(asset->tagAngles, asset->numBones - asset->numRootBones);
2016-07-11 11:14:58 -04:00
Utils::Stream::ClearPointer(&dest->tagAngles);
}
if (asset->tagPositions)
{
AssertSize(Game::XModelTagPos, 12);
2016-07-11 11:14:58 -04:00
buffer->align(Utils::Stream::ALIGN_4);
buffer->saveArray(asset->tagPositions, asset->numBones - asset->numRootBones);
2016-07-11 11:14:58 -04:00
Utils::Stream::ClearPointer(&dest->tagPositions);
}
if (asset->partClassification)
{
buffer->save(asset->partClassification, asset->numBones);
2016-07-11 11:14:58 -04:00
Utils::Stream::ClearPointer(&dest->partClassification);
}
if (asset->animMatrix)
{
AssertSize(Game::DObjAnimMat, 32);
2016-07-11 11:14:58 -04:00
buffer->align(Utils::Stream::ALIGN_4);
buffer->saveArray(asset->animMatrix, asset->numBones);
2016-07-11 11:14:58 -04:00
Utils::Stream::ClearPointer(&dest->animMatrix);
}
if (asset->materials)
{
buffer->align(Utils::Stream::ALIGN_4);
2016-07-11 11:14:58 -04:00
Game::Material** destMaterials = buffer->dest<Game::Material*>();
buffer->saveArray(asset->materials, asset->numSurfaces);
2016-07-11 11:14:58 -04:00
for (unsigned char i = 0; i < asset->numSurfaces; ++i)
2016-07-11 11:14:58 -04:00
{
if (asset->materials[i])
{
destMaterials[i] = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_MATERIAL, asset->materials[i]).material;
2016-07-11 11:14:58 -04:00
}
}
Utils::Stream::ClearPointer(&dest->materials);
}
// Save_XModelLodInfoArray
{
AssertSize(Game::XModelLodInfo, 44);
2016-07-11 11:14:58 -04:00
for (int i = 0; i < 4; ++i)
{
2017-01-01 14:04:20 -05:00
if (asset->lods[i].modelSurfs)
2016-07-11 11:14:58 -04:00
{
2017-01-01 14:04:20 -05:00
dest->lods[i].modelSurfs = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_XMODELSURFS, asset->lods[i].modelSurfs).surfaces;
2016-07-11 11:14:58 -04:00
}
}
}
// Save_XModelCollSurfArray
if (asset->colSurf)
{
AssertSize(Game::XModelCollSurf, 44);
2016-07-11 11:14:58 -04:00
buffer->align(Utils::Stream::ALIGN_4);
2016-07-11 11:14:58 -04:00
Game::XModelCollSurf* destColSurfs = buffer->dest<Game::XModelCollSurf>();
buffer->saveArray(asset->colSurf, asset->numColSurfs);
2016-07-11 11:14:58 -04:00
for (int i = 0; i < asset->numColSurfs; ++i)
{
Game::XModelCollSurf* destColSurf = &destColSurfs[i];
Game::XModelCollSurf* colSurf = &asset->colSurf[i];
2017-01-02 13:31:32 -05:00
if (colSurf->collTris)
2016-07-11 11:14:58 -04:00
{
buffer->align(Utils::Stream::ALIGN_4);
2016-07-11 11:14:58 -04:00
2017-01-02 13:31:32 -05:00
buffer->save(colSurf->collTris, 48, colSurf->numCollTris);
Utils::Stream::ClearPointer(&destColSurf->collTris);
2016-07-11 11:14:58 -04:00
}
}
Utils::Stream::ClearPointer(&dest->colSurf);
}
if (asset->boneInfo)
{
AssertSize(Game::XBoneInfo, 28);
2016-07-11 11:14:58 -04:00
buffer->align(Utils::Stream::ALIGN_4);
2016-07-11 11:14:58 -04:00
buffer->saveArray(asset->boneInfo, asset->numBones);
2016-07-11 11:14:58 -04:00
Utils::Stream::ClearPointer(&dest->boneInfo);
}
if (asset->physPreset)
{
dest->physPreset = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_PHYSPRESET, asset->physPreset).physPreset;
2016-07-11 11:14:58 -04:00
}
if (asset->physCollmap)
{
dest->physCollmap = builder->saveSubAsset(Game::XAssetType::ASSET_TYPE_PHYS_COLLMAP, asset->physCollmap).physCollmap;
2016-07-11 11:14:58 -04:00
}
buffer->popBlock();
2016-07-11 11:14:58 -04:00
}
}