Skip to content

Commit

Permalink
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
fix XSurface writing for IW4
Browse files Browse the repository at this point in the history
RektInator committed Dec 3, 2020

Verified

This commit was created on GitHub.com and signed with GitHub’s verified signature. The key has expired.
1 parent b45c5aa commit 34e3904
Showing 5 changed files with 43 additions and 228 deletions.
244 changes: 33 additions & 211 deletions src/IW4/Assets/XSurface.cpp
Original file line number Diff line number Diff line change
@@ -121,7 +121,7 @@ namespace ZoneTool
return xmodelsurfs;
}

template <typename T> void write_xsurfaces(IZone* zone, ZoneBuffer* buf, T* data, T* dest, std::uint16_t count, bool is_console)
void IXSurface::write_xsurfaces(IZone* zone, ZoneBuffer* buf, XSurface* data, std::uint16_t count)
{
assert(sizeof XSurface, 64);
assert(sizeof Face, 6);
@@ -133,57 +133,25 @@ namespace ZoneTool
assert(sizeof GfxPackedVertex, 32);
assert(sizeof XSurfaceVertexInfo, 12);

auto* dest = buf->write(data, count);

for (auto surf = 0u; surf < count; surf++)
{
if (data[surf].vertexInfo.vertsBlend)
{
unsigned __int16* destverts = nullptr;
const auto vertcount = data[surf].vertexInfo.vertCount[0] +
(data[surf].vertexInfo.vertCount[1] * 3) +
(data[surf].vertexInfo.vertCount[2] * 5) +
(data[surf].vertexInfo.vertCount[3] * 7);

dest[surf].vertexInfo.vertsBlend = buf->write_s(1, data[surf].vertexInfo.vertsBlend, count, sizeof (unsigned __int16), &destverts);

if (is_console && dest[surf].vertexInfo.vertsBlend == reinterpret_cast<unsigned __int16*>(-1))
{
for (auto a = 0u; a < vertcount; a++)
{
endian_convert(&destverts[a]);
}
}
dest[surf].vertexInfo.vertsBlend = buf->write_s(1, data[surf].vertexInfo.vertsBlend,
data[surf].vertexInfo.vertCount[0] +
(data[surf].vertexInfo.vertCount[1] * 3) + (data[
surf].vertexInfo.vertCount[2] * 5) + (data[
surf].vertexInfo.vertCount[3] * 7));
}

if (!is_console)
{
buf->push_stream(6);
}

buf->push_stream(6);
if (data[surf].verticies)
{
GfxPackedVertex* destverticies = nullptr;
dest[surf].verticies = buf->write_s(15, data[surf].verticies, data[surf].vertCount, sizeof GfxPackedVertex, &destverticies);

if (is_console && dest[surf].verticies == reinterpret_cast<GfxPackedVertex*>(-1))
{
for (auto a = 0; a < data[surf].vertCount; a++)
{
endian_convert(&destverticies[a].xyz[0]);
endian_convert(&destverticies[a].xyz[1]);
endian_convert(&destverticies[a].xyz[2]);
endian_convert(&destverticies[a].binormalSign);
// packed data probably consists of single bytes?
//endian_convert(&destverticies[a].texCoord.packed);
//endian_convert(&destverticies[a].normal.packed);
//endian_convert(&destverticies[a].tangent.packed);
}
}
}

if (!is_console)
{
buf->pop_stream();
dest[surf].verticies = buf->write_s(15, data[surf].verticies, data[surf].vertCount);
}
buf->pop_stream();

if (data[surf].rigidVertLists)
{
@@ -193,7 +161,7 @@ namespace ZoneTool

if (dest[surf].rigidVertLists == reinterpret_cast<XRigidVertList*>(-1))
{
for (int k = 0; k < data[surf].vertListCount; k++)
for (auto k = 0; k < data[surf].vertListCount; k++)
{
if (ct[k].collisionTree)
{
@@ -205,195 +173,49 @@ namespace ZoneTool
{
if (entry->nodes)
{
XSurfaceCollisionNode* destnode = nullptr;
entry->nodes = buf->write_s(15, entry->nodes, entry->nodeCount, sizeof (XSurfaceCollisionNode), &destnode);

if (entry->nodes == reinterpret_cast<XSurfaceCollisionNode*>(-1) && is_console)
{
for (auto a = 0u; a < entry->leafCount; a++)
{
for (auto b = 0; b < 3; b++)
{
endian_convert(&destnode[a].aabb.mins[b]);
endian_convert(&destnode[a].aabb.maxs[b]);
}

endian_convert(&destnode[a].childBeginIndex);
endian_convert(&destnode[a].childCount);
}
}
entry->nodes = buf->write_s(15, entry->nodes, entry->nodeCount);
}

if (entry->leafs)
{
XSurfaceCollisionLeaf* destleaf = nullptr;
entry->leafs = buf->write_s(1, entry->leafs, entry->leafCount, sizeof (XSurfaceCollisionLeaf), &destleaf);

if (entry->leafs == reinterpret_cast<XSurfaceCollisionLeaf *>(-1) && is_console)
{
for (auto a = 0u; a < entry->leafCount; a++)
{
endian_convert(&destleaf[a].triangleBeginIndex);
}
}
}

if (is_console)
{
for (auto a = 0; a < 3; a++)
{
endian_convert(&entry->trans[a]);
endian_convert(&entry->scale[a]);
}
endian_convert(&entry->nodeCount);
endian_convert(&entry->nodes);
endian_convert(&entry->leafCount);
endian_convert(&entry->leafs);
entry->leafs = buf->write_s(1, entry->leafs, entry->leafCount);
}
}
}

if (is_console)
{
endian_convert(&ct[k].boneOffset);
endian_convert(&ct[k].vertCount);
endian_convert(&ct[k].triOffset);
endian_convert(&ct[k].triCount);
endian_convert(&ct[k].collisionTree);
}
}
}
}

if (!is_console)
{
buf->push_stream(7);
}

buf->push_stream(7);
if (data[surf].triIndices)
{
Face* dest_tris = nullptr;
dest[surf].triIndices = buf->write_s(15, data[surf].triIndices, data[surf].triCount, sizeof(unsigned __int16), &dest_tris);

if (is_console && dest[surf].triIndices == reinterpret_cast<Face*>(-1))
{
for (auto a = 0u; a < data[surf].triCount; a++)
{
endian_convert(&dest_tris[a].v1);
endian_convert(&dest_tris[a].v2);
endian_convert(&dest_tris[a].v3);
}
}
}

if (!is_console)
{
buf->pop_stream();
}

if (is_console)
{
endian_convert(&dest[surf].vertCount);
endian_convert(&dest[surf].triCount);
endian_convert(&dest[surf].triIndices);
endian_convert(&dest[surf].vertexInfo.vertCount[0]);
endian_convert(&dest[surf].vertexInfo.vertCount[1]);
endian_convert(&dest[surf].vertexInfo.vertCount[2]);
endian_convert(&dest[surf].vertexInfo.vertCount[3]);
endian_convert(&dest[surf].verticies);
endian_convert(&dest[surf].vertListCount);
endian_convert(&dest[surf].rigidVertLists);
for (auto a = 0; a < 5; a++)
{
endian_convert(&dest[surf].partBits[a]);
}
dest[surf].triIndices = buf->write_s(15, data[surf].triIndices, data[surf].triCount);
}
buf->pop_stream();
}
}

void IXSurface::write(IZone* zone, ZoneBuffer* buf)
{
if (zone->get_target() == zone_target::pc)
{
auto data = this->asset_;
auto dest = buf->write<XModelSurfs>(data);

assert(sizeof XModelSurfs, 36);
auto* data = this->asset_;
auto* dest = buf->write<XModelSurfs>(data);

buf->push_stream(3);
START_LOG_STREAM;
assert(sizeof XModelSurfs, 36);

dest->name = buf->write_str(this->name());
buf->push_stream(3);
START_LOG_STREAM;

if (data->surfs)
{
buf->align(3);
auto destsurfaces = buf->write(data->surfs, data->numsurfs);
write_xsurfaces<XSurface>(zone, buf, data->surfs, destsurfaces, data->numsurfs, false);
ZoneBuffer::clear_pointer(&dest->surfs);
}
dest->name = buf->write_str(this->name());

END_LOG_STREAM;
buf->pop_stream();
}
else
if (data->surfs)
{
std::vector<alpha::XSurface> surfs;
surfs.resize(this->asset_->numsurfs);

for (auto i = 0u; i < this->asset_->numsurfs; i++)
{
//
surfs[i].tileMode = this->asset_->surfs[i].tileMode;
surfs[i].deformed = this->asset_->surfs[i].deformed;
surfs[i].vertCount = this->asset_->surfs[i].vertCount;
surfs[i].triCount = this->asset_->surfs[i].triCount;
surfs[i].triIndices = this->asset_->surfs[i].triIndices;
surfs[i].verticies = this->asset_->surfs[i].verticies;
surfs[i].vertListCount = this->asset_->surfs[i].vertListCount;
surfs[i].rigidVertLists = this->asset_->surfs[i].rigidVertLists;
memcpy(&surfs[i].vertexInfo, &this->asset_->surfs[i].vertexInfo, sizeof XSurfaceVertexInfo);
memcpy(surfs[i].partBits, this->asset_->surfs[i].partBits, sizeof(int) * 5);

// memset console shit to 0
memset(&surfs[i].vb0, 0, sizeof alpha::D3DVertexBuffer);
memset(&surfs[i].indexBuffer, 0, sizeof alpha::D3DIndexBuffer);
}

alpha::XModelSurfs alpha_surfs = {};
memcpy(&alpha_surfs, this->asset_, sizeof alpha::XModelSurfs);
alpha_surfs.surfs = surfs.data();

auto data = &alpha_surfs;
auto dest = buf->write(data);

assert(sizeof alpha::XModelSurfs, 32);

buf->push_stream(3);
START_LOG_STREAM;

dest->name = buf->write_str(this->name());

if (data->surfs)
{
buf->align(3);
auto destsurfaces = buf->write(data->surfs, data->numsurfs);
write_xsurfaces<alpha::XSurface>(zone, buf, data->surfs, destsurfaces, data->numsurfs, true);
ZoneBuffer::clear_pointer(&dest->surfs);
}

END_LOG_STREAM;
buf->pop_stream();

endian_convert(&dest->name);
endian_convert(&dest->surfs);
endian_convert(&dest->numsurfs);
for (auto a = 0; a < 5; a++)
{
endian_convert(&dest->partBits[a]);
}
buf->align(3);
write_xsurfaces(zone, buf, data->surfs, data->numsurfs);
ZoneBuffer::clear_pointer(&dest->surfs);
}


END_LOG_STREAM;
buf->pop_stream();
}

void IXSurface::dump(XModelSurfs* asset)
@@ -409,14 +231,14 @@ namespace ZoneTool
dump.dump_array(asset, 1);
dump.dump_string(asset->name);

for (int i = 0; i < asset->numsurfs; i++)
for (auto i = 0u; i < asset->numsurfs; i++)
{
dump.dump_int(asset->surfs[i].tileMode);
dump.dump_int(asset->surfs[i].deformed);
dump.dump_int(asset->surfs[i].baseTriIndex);
dump.dump_int(asset->surfs[i].baseVertIndex);

for (int j = 0; j < 6; j++)
for (auto j = 0; j < 6; j++)
{
dump.dump_int(asset->surfs[i].partBits[j]);
}
@@ -438,7 +260,7 @@ namespace ZoneTool

dump.dump_int(asset->surfs[i].vertListCount);
dump.dump_array(asset->surfs[i].rigidVertLists, asset->surfs[i].vertListCount);
for (int vert = 0; vert < asset->surfs[i].vertListCount; vert++)
for (auto vert = 0; vert < asset->surfs[i].vertListCount; vert++)
{
if (asset->surfs[i].rigidVertLists[vert].collisionTree)
{
1 change: 1 addition & 0 deletions src/IW4/Assets/XSurface.hpp
Original file line number Diff line number Diff line change
@@ -30,6 +30,7 @@ namespace ZoneTool
void* pointer() override { return asset_; }
std::string name() override;
std::int32_t type() override;
void write_xsurfaces(IZone* zone, ZoneBuffer* buf, XSurface* data, std::uint16_t count);
void write(IZone* zone, ZoneBuffer* buffer) override;

static void dump(XModelSurfs* asset);
12 changes: 2 additions & 10 deletions src/IW5/Assets/MenuDef.cpp
Original file line number Diff line number Diff line change
@@ -12,14 +12,6 @@ namespace ZoneTool
{
namespace IW5
{
IMenuDef::IMenuDef()
{
}

IMenuDef::~IMenuDef()
{
}

void IMenuDef::init(const std::string& name, ZoneMemory* mem)
{
this->name_ = name;
@@ -44,7 +36,7 @@ namespace ZoneTool
return menu;
}

void IMenuDef::write_MenuData(IZone* zone, ZoneBuffer* buf, menuData_t* data)
void IMenuDef::write_menu_data(IZone* zone, ZoneBuffer* buf, menuData_t* data)
{
auto* dest = buf->write(data);
memset(dest, 0, sizeof menuData_t);
@@ -66,7 +58,7 @@ namespace ZoneTool
if (data->data)
{
buf->align(3);
write_MenuData(zone, buf, data->data);
write_menu_data(zone, buf, data->data);
ZoneBuffer::clear_pointer(&dest->data);
}

Loading

0 comments on commit 34e3904

Please sign in to comment.