VTX.cpp

Go to the documentation of this file.

// ReSharper disable CppTooWideScopeInitStatement
// ReSharper disable CppUseStructuredBinding
 
#include <mdlpp/structs/VTX.h>
 
#include <BufferStream.h>
#include <sourcepp/parser/Binary.h>
 
using namespace mdlpp::VTX;
using namespace sourcepp;
 
bool VTX::open(const std::byte* data, std::size_t size, const MDL::MDL& mdl, HasTopologyIndices hasTopologyIndices) {
    const auto openInternal = [this, data, size, checksum = mdl.checksum](bool useTopology) {
        BufferStreamReadOnly stream{data, size};
 
        if (stream.read(this->version); this->version != 7) {
            return false;
        }
 
        stream
            .read(this->vertexCacheSize)
            .read(this->maxBonesPerStrip)
            .read(this->maxBonesPerTriangle)
            .read(this->maxBonesPerVertex);
 
        if (stream.read<int32_t>() != checksum) {
            return false;
        }
 
        stream.read(this->numLODs);
 
        const auto materialReplacementListOffset = stream.read<int32_t>();
 
        const auto bodyPartCount = stream.read<int32_t>();
        const auto bodyPartOffset = stream.read<int32_t>();
 
        if (materialReplacementListOffset > 0) {
            stream.seek(materialReplacementListOffset);
 
            for (int i = 0; i < this->numLODs; i++) {
                const auto replacementListPos = materialReplacementListOffset + i * (sizeof(int32_t) * 2);
                stream.seek_u(replacementListPos);
 
                auto& replacementList = this->materialReplacementLists[i];
 
                const auto replacementCount = stream.read<int32_t>();
                const auto replacementOffset = stream.read<int32_t>();
 
                if (replacementCount > 0 && replacementOffset > 0) {
                    for (int j = 0; j < replacementCount; j++) {
                        const auto replacementPos = replacementOffset + j * (sizeof(int16_t) + sizeof(int32_t));
                        stream.seek_u(replacementListPos + replacementPos);
 
                        auto& replacement = replacementList.emplace_back();
                        stream.read(replacement.materialID);
 
                        parser::binary::readStringAtOffset(stream, replacement.newMaterialPath, std::ios::cur, 6);
                    }
                }
            }
        }
 
        for (int i = 0; i < bodyPartCount; i++) {
            const auto bodyPartPos = bodyPartOffset + i * (sizeof(int32_t) * 2);
            stream.seek_u(bodyPartPos);
 
            auto& bodyPart = this->bodyParts.emplace_back();
 
            const auto modelCount = stream.read<int32_t>();
            const auto modelOffset = stream.read<int32_t>();
 
            for (int j = 0; j < modelCount; j++) {
                const auto modelPos = modelOffset + j * (sizeof(int32_t) * 2);
                stream.seek_u(bodyPartPos + modelPos);
 
                auto& model = bodyPart.models.emplace_back();
 
                const auto modelLODCount = stream.read<int32_t>();
                const auto modelLODOffset = stream.read<int32_t>();
 
                for (int k = 0; k < modelLODCount; k++) {
                    const auto modelLODPos = modelLODOffset + k * (sizeof(int32_t) * 2 + sizeof(float));
                    stream.seek_u(bodyPartPos + modelPos + modelLODPos);
 
                    auto& modelLOD = model.modelLODs.emplace_back();
 
                    const auto meshCount = stream.read<int32_t>();
                    const auto meshOffset = stream.read<int32_t>();
 
                    stream.read(modelLOD.switchDistance);
 
                    for (int l = 0; l < meshCount; l++) {
                        const auto meshPos = meshOffset + l * (sizeof(int32_t) * 2 + sizeof(Mesh::Flags));
                        stream.seek_u(bodyPartPos + modelPos + modelLODPos + meshPos);
 
                        auto& mesh = modelLOD.meshes.emplace_back();
 
                        const auto stripGroupCount = stream.read<int32_t>();
                        const auto stripGroupOffset = stream.read<int32_t>();
 
                        stream.read(mesh.flags);
 
                        for (int m = 0; m < stripGroupCount; m++) {
                            int stripGroupNumInts = 6;
                            if (useTopology) {
                                stripGroupNumInts += 2;
                            }
                            const auto stripGroupPos = stripGroupOffset + m * (sizeof(int32_t) * stripGroupNumInts + sizeof(StripGroup::Flags));
                            stream.seek_u(bodyPartPos + modelPos + modelLODPos + meshPos + stripGroupPos);
 
                            auto& stripGroup = mesh.stripGroups.emplace_back();
 
                            const auto vertexCount = stream.read<int32_t>();
                            const auto vertexOffset = stream.read<int32_t>();
 
                            auto stripGroupCurrentPos = stream.tell();
                            stream.seek_u(bodyPartPos + modelPos + modelLODPos + meshPos + stripGroupPos + vertexOffset);
                            for (int n = 0; n < vertexCount; n++) {
                                auto& vertex = stripGroup.vertices.emplace_back();
 
                                stream
                                    .read(vertex.boneWeightIndex)
                                    .read(vertex.boneCount)
                                    .read(vertex.meshVertexID)
                                    .read(vertex.boneID);
                            }
                            stream.seek_u(stripGroupCurrentPos);
 
                            const auto indexCount = stream.read<int32_t>();
                            const auto indexOffset = stream.read<int32_t>();
 
                            stripGroupCurrentPos = stream.tell();
                            stream.seek_u(bodyPartPos + modelPos + modelLODPos + meshPos + stripGroupPos + indexOffset);
                            for (int n = 0; n < indexCount; n++) {
                                auto& index = stripGroup.indices.emplace_back();
                                stream.read(index);
                            }
                            stream.seek_u(stripGroupCurrentPos);
 
                            const auto stripCount = stream.read<int32_t>();
                            const auto stripOffset = stream.read<int32_t>();
 
                            stream.read(stripGroup.flags);
 
                            if (useTopology) {
                                const auto topologyIndexCount = stream.read<int32_t>();
                                const auto topologyIndexOffset = stream.read<int32_t>();
 
                                stripGroupCurrentPos = stream.tell();
                                stream.seek_u(bodyPartPos + modelPos + modelLODPos + meshPos + stripGroupPos + topologyIndexOffset);
                                for (int n = 0; n < topologyIndexCount; n++) {
                                    auto& topologyIndex = stripGroup.topologyIndices.emplace_back();
                                    stream.read(topologyIndex);
                                }
                                stream.seek_u(stripGroupCurrentPos);
                            }
 
                            stream.seek_u(bodyPartPos + modelPos + modelLODPos + meshPos + stripGroupPos + stripOffset);
                            for (int n = 0; n < stripCount; n++) {
                                auto& strip = stripGroup.strips.emplace_back();
 
                                const auto indicesCount = stream.read<int32_t>();
                                stream.read(strip.indicesOffset);
                                // Note: offset is in elements, not bytes
                                strip.indices = std::span(stripGroup.indices.begin() + strip.indicesOffset, indicesCount);
 
                                const auto verticesCount = stream.read<int32_t>();
                                stream.read(strip.verticesOffset);
                                // Note: offset is in elements, not bytes
                                strip.vertices = std::span(stripGroup.vertices.begin() + strip.verticesOffset, verticesCount);
 
                                stream
                                    .read(strip.boneCount)
                                    .read(strip.flags);
 
                                // bone stuff
                                const auto boneStateChangeCount = stream.read<int32_t>();
                                const auto boneStateChangeOffset = stream.read<int32_t>();
 
                                if (boneStateChangeCount > 0 && boneStateChangeOffset > 0) {
                                    const auto savedPos = stream.tell();
                                    constexpr auto stripHeaderSize = sizeof(int32_t) * 6 + sizeof(int16_t) + sizeof(Strip::Flags);
                                    const auto stripBasePos = bodyPartPos + modelPos + modelLODPos + meshPos + stripGroupPos + stripOffset + n * stripHeaderSize;
                                    stream.seek_u(stripBasePos + boneStateChangeOffset);
 
                                    for (int p = 0; p < boneStateChangeCount; p++) {
                                        auto& boneStateChange = strip.boneStateChanges.emplace_back();
                                        stream
                                            .read(boneStateChange.hardwareID)
                                            .read(boneStateChange.newBoneID);
                                    }
 
                                    stream.seek_u(savedPos);
                                }
 
                                if (useTopology) {
                                    const auto topologyIndicesCount = stream.read<int32_t>();
                                    stream.read(strip.topologyIndicesOffset);
                                    // Note: offset is in elements, not bytes
                                    strip.topologyIndices = std::span(stripGroup.topologyIndices.begin() + strip.topologyIndicesOffset, topologyIndicesCount);
                                }
                            }
                        }
                    }
                }
            }
        }
        return true;
    };
 
    switch (hasTopologyIndices) {
        case HasTopologyIndices::AUTOMATIC: {
            const bool useTopology = mdl.version == 49;
            try {
                return openInternal(useTopology);
            } catch (const std::overflow_error&) {
                if (useTopology) {
                    return openInternal(false);
                }
            }
            return false;
        }
        case HasTopologyIndices::NO:
            return openInternal(false);
        case HasTopologyIndices::YES:
            return openInternal(true);
    }
    return openInternal(false);
}