conv.cpp

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <cstdio>
#include <filesystem>
#include <cstdint>
#include <cctype>
#include <cstring> //linux g++ requires this

#include "Q2MD2.h"
#include "DKM.h"

using namespace std;
namespace fs = filesystem;

Q2_MD2_file ParseQ2MD2(fs::path inpath) {
    ifstream inFile(inpath, ios::binary);
    Q2_MD2_file NewMD2;

    inFile.read(reinterpret_cast<char*>(&NewMD2.header.magic), sizeof(NewMD2.header.magic));
    inFile.read(reinterpret_cast<char*>(&NewMD2.header.version), sizeof(NewMD2.header.version));
    inFile.read(reinterpret_cast<char*>(&NewMD2.header.skinWidth), sizeof(NewMD2.header.skinWidth));
    inFile.read(reinterpret_cast<char*>(&NewMD2.header.skinHeight), sizeof(NewMD2.header.skinHeight));
    inFile.read(reinterpret_cast<char*>(&NewMD2.header.frameSize), sizeof(NewMD2.header.frameSize));
    inFile.read(reinterpret_cast<char*>(&NewMD2.header.numSkins), sizeof(NewMD2.header.numSkins));
    inFile.read(reinterpret_cast<char*>(&NewMD2.header.numVertices), sizeof(NewMD2.header.numVertices));
    inFile.read(reinterpret_cast<char*>(&NewMD2.header.numTexCoords), sizeof(NewMD2.header.numTexCoords));
    inFile.read(reinterpret_cast<char*>(&NewMD2.header.numTriangles), sizeof(NewMD2.header.numTriangles));
    inFile.read(reinterpret_cast<char*>(&NewMD2.header.numGlCommands), sizeof(NewMD2.header.numGlCommands));
    inFile.read(reinterpret_cast<char*>(&NewMD2.header.numFrames), sizeof(NewMD2.header.numFrames));
    inFile.read(reinterpret_cast<char*>(&NewMD2.header.offsetSkins), sizeof(NewMD2.header.offsetSkins));
    inFile.read(reinterpret_cast<char*>(&NewMD2.header.offsetTexCoords), sizeof(NewMD2.header.offsetTexCoords));
    inFile.read(reinterpret_cast<char*>(&NewMD2.header.offsetTriangles), sizeof(NewMD2.header.offsetTriangles));
    inFile.read(reinterpret_cast<char*>(&NewMD2.header.offsetFrames), sizeof(NewMD2.header.offsetFrames));
    inFile.read(reinterpret_cast<char*>(&NewMD2.header.offsetGlCommands), sizeof(NewMD2.header.offsetGlCommands));
    inFile.read(reinterpret_cast<char*>(&NewMD2.header.offsetEnd), sizeof(NewMD2.header.offsetEnd));

    if (NewMD2.header.offsetSkins < NewMD2.header.offsetTexCoords && NewMD2.header.offsetTexCoords < NewMD2.header.offsetTriangles && NewMD2.header.offsetTriangles < NewMD2.header.offsetFrames && NewMD2.header.offsetFrames < NewMD2.header.offsetGlCommands && NewMD2.header.offsetGlCommands < NewMD2.header.offsetEnd) {
        cout << "Offsets are in ascending order." << endl;
    }
    else {
        cout << "WARNING: Offsets are NOT in ascending order." << endl;
        cout << "header.offsetSkins: " << NewMD2.header.offsetSkins << endl;
        cout << "header.offsetTexCoords: " << NewMD2.header.offsetTexCoords << endl;
        cout << "header.offsetTriangles: " << NewMD2.header.offsetTriangles << endl;
        cout << "header.offsetFrames: " << NewMD2.header.offsetFrames << endl;
        cout << "header.offsetGlCommands: " << NewMD2.header.offsetGlCommands << endl;
        cout << "header.offsetEnd: " << NewMD2.header.offsetEnd << endl;
    }

    inFile.seekg(NewMD2.header.offsetSkins);
    for (int i = 0; i < NewMD2.header.numSkins; i++) {
        char newpath[64];
        inFile.read(newpath, 64);
        NewMD2.skinpaths.emplace_back(newpath);
    }

    inFile.seekg(NewMD2.header.offsetTexCoords);
    for (int i = 0; i < NewMD2.header.numTexCoords; i++) {
        q2_md2_textureCoordinate_t newtexcord;
        inFile.read(reinterpret_cast<char*>(&newtexcord.s), sizeof(newtexcord.s));
        inFile.read(reinterpret_cast<char*>(&newtexcord.t), sizeof(newtexcord.t));
        NewMD2.UV.push_back(newtexcord);
    }

    inFile.seekg(NewMD2.header.offsetTriangles);
    for (int i = 0; i < NewMD2.header.numTriangles; i++) {
        q2_md2_triangle_t newtriangle;
        inFile.read(reinterpret_cast<char*>(&newtriangle.vertexIndices[0]), sizeof(newtriangle.vertexIndices[0]));
        inFile.read(reinterpret_cast<char*>(&newtriangle.vertexIndices[1]), sizeof(newtriangle.vertexIndices[1]));
        inFile.read(reinterpret_cast<char*>(&newtriangle.vertexIndices[2]), sizeof(newtriangle.vertexIndices[2]));
        inFile.read(reinterpret_cast<char*>(&newtriangle.textureIndices[0]), sizeof(newtriangle.textureIndices[0]));
        inFile.read(reinterpret_cast<char*>(&newtriangle.textureIndices[1]), sizeof(newtriangle.textureIndices[1]));
        inFile.read(reinterpret_cast<char*>(&newtriangle.textureIndices[2]), sizeof(newtriangle.textureIndices[2]));
        NewMD2.triangles.push_back(newtriangle);
    }

    inFile.seekg(NewMD2.header.offsetFrames);
    for (int i = 0; i < NewMD2.header.numFrames; i++) {
        q2_md2_frame_t newframe;
        inFile.read(reinterpret_cast<char*>(&newframe.scale[0]), sizeof(newframe.scale[0]));
        inFile.read(reinterpret_cast<char*>(&newframe.scale[1]), sizeof(newframe.scale[1]));
        inFile.read(reinterpret_cast<char*>(&newframe.scale[2]), sizeof(newframe.scale[2]));
        inFile.read(reinterpret_cast<char*>(&newframe.translate[0]), sizeof(newframe.translate[0]));
        inFile.read(reinterpret_cast<char*>(&newframe.translate[1]), sizeof(newframe.translate[1]));
        inFile.read(reinterpret_cast<char*>(&newframe.translate[2]), sizeof(newframe.translate[2]));
        inFile.read(newframe.name, 16);
        for (int j = 0; j < NewMD2.header.numVertices; j++) {
            q2_md2_triangleVertex_t newvert;
            inFile.read(reinterpret_cast<char*>(&newvert.vertex[0]), sizeof(newvert.vertex[0]));
            inFile.read(reinterpret_cast<char*>(&newvert.vertex[1]), sizeof(newvert.vertex[1]));
            inFile.read(reinterpret_cast<char*>(&newvert.vertex[2]), sizeof(newvert.vertex[2]));
            inFile.read(reinterpret_cast<char*>(&newvert.lightNormalIndex), sizeof(newvert.lightNormalIndex));
            newframe.vertices.push_back(newvert);
        }
        NewMD2.frames.push_back(newframe);
    }

    inFile.seekg(NewMD2.header.offsetGlCommands);
    while (true) {
        int command;
        inFile.read(reinterpret_cast<char*>(&command), sizeof(int));

        if (command == 0) break; // End of commands

        q2_md2_glCommand_t cmd;
        cmd.count = command;
        int numVerts = abs(command);

        for (int i = 0; i < numVerts; i++) {
            q2_md2_glCommandVertex_t v;
            inFile.read(reinterpret_cast<char*>(&v.s), sizeof(float));
            inFile.read(reinterpret_cast<char*>(&v.t), sizeof(float));
            inFile.read(reinterpret_cast<char*>(&v.vertexIndex), sizeof(int));
            cmd.vertices.push_back(v);
        }
        NewMD2.GLCommands.push_back(cmd);
    }
    inFile.close();

    return NewMD2;
}

DKM_file ConvertMD2toDKM(Q2_MD2_file OldMD2) {
    DKM_file NewDKM;
    NewDKM.header.version = 1;
    NewDKM.header.origin[0] = 0;
    NewDKM.header.origin[1] = 0;
    NewDKM.header.origin[2] = 0;
    NewDKM.header.numSkins = OldMD2.skinpaths.size();
    NewDKM.header.numTexCoords = OldMD2.UV.size();
    NewDKM.header.numTriangles = OldMD2.triangles.size();
    NewDKM.header.numFrames = OldMD2.frames.size();
    NewDKM.header.numSurfaces = 1;
    NewDKM.header.numVertices = -1;
    for (const auto& f : OldMD2.frames) {
        if (NewDKM.header.numVertices == -1)
            NewDKM.header.numVertices = f.vertices.size();
        else if (NewDKM.header.numVertices != f.vertices.size()) {
            cout << "Error: Frame " << (f.name) << " has " << f.vertices.size() << " verts, but expected " << NewDKM.header.numVertices << endl;
            exit(1);
        }
    }
    NewDKM.header.frameSize = NewDKM.header.numVertices * 4 + 40;
    NewDKM.header.numGlCommands = 0;
    for (const auto& g : OldMD2.GLCommands) {
        NewDKM.header.numGlCommands += 3;
        NewDKM.header.numGlCommands += (g.vertices.size() * 3);
    }
    NewDKM.header.numGlCommands++;
    
    for (const auto& s : OldMD2.skinpaths)
        NewDKM.skinpaths.push_back(s);
    
    for (const auto& u : OldMD2.UV) {
        dkm_textureCoordinate_t newuve;
        newuve.s = u.s;
        newuve.t = u.t;
        NewDKM.UV.push_back(newuve);
    }

    for (const auto& t : OldMD2.triangles) {
        dkm_triangle_t newtri;
        newtri.surfaceIndex = 0;
        newtri.num_uvframes = 1;
        newtri.textureIndices[0] = t.textureIndices[0];
        newtri.textureIndices[1] = t.textureIndices[1];
        newtri.textureIndices[2] = t.textureIndices[2];
        newtri.vertexIndices[0] = t.vertexIndices[0];
        newtri.vertexIndices[1] = t.vertexIndices[1];
        newtri.vertexIndices[2] = t.vertexIndices[2];
        NewDKM.triangles.push_back(newtri);
    }

    for (const auto& f : OldMD2.frames) {
        dkm_frame_t newframe;
        newframe.scale[0] = f.scale[0];
        newframe.scale[1] = f.scale[1];
        newframe.scale[2] = f.scale[2];
        newframe.translate[0] = f.translate[0];
        newframe.translate[1] = f.translate[1];
        newframe.translate[2] = f.translate[2];
        newframe.name = f.name;
        for (const auto& v : f.vertices) {
            dkm_triangleVertex_t newvert;
            newvert.vertex[0] = v.vertex[0];
            newvert.vertex[1] = v.vertex[1];
            newvert.vertex[2] = v.vertex[2];
            newvert.lightNormalIndex = v.lightNormalIndex;
            newframe.vertices.push_back(newvert);
        }
        NewDKM.frames.push_back(newframe);
    }

    for (const auto& g : OldMD2.GLCommands) {
        dkm_glCommand_t newglc;
        newglc.count = g.count;
        newglc.skinIndex = 0;
        newglc.surfIndex = 0;
        for (const auto& v : g.vertices) {
            dkm_glCommandVertex_t newglv;
            newglv.s = v.s;
            newglv.t = v.t;
            newglv.vertexIndex = v.vertexIndex;
            newglc.vertices.push_back(newglv);
        }
        NewDKM.GLCommands.push_back(newglc);
    }

    NewDKM.surface.name = "Default";
    NewDKM.surface.flags = 0;
    NewDKM.surface.skinIndex = 0;
    NewDKM.surface.skinWidth = OldMD2.header.skinWidth;
    NewDKM.surface.skinHeight = OldMD2.header.skinHeight;
    NewDKM.surface.numUVframes = 1;

    string currentSeqName = NewDKM.frames[0].name;
    while (!currentSeqName.empty() && (isdigit(static_cast<unsigned char>(currentSeqName.back())) || currentSeqName.back() == '_'))
        currentSeqName.pop_back();
    int startIndex = 0;
    for (int i = 1; i < NewDKM.frames.size(); i++) {
        string baseName = NewDKM.frames[i].name;
        while (!baseName.empty() && (isdigit(static_cast<unsigned char>(baseName.back())) || baseName.back() == '_'))
            baseName.pop_back();
        if (baseName != currentSeqName) {
            dkm_animSeq_t seq;
            seq.name = currentSeqName;
            seq.startFrame = startIndex;
            seq.endFrame = i - 1;
            NewDKM.sequences.push_back(seq);
            currentSeqName = baseName;
            startIndex = i;
        }
    }
    dkm_animSeq_t finalSeq;
    finalSeq.name = currentSeqName;
    finalSeq.startFrame = startIndex;
    finalSeq.endFrame = static_cast<int>(NewDKM.frames.size()) - 1;
    NewDKM.sequences.push_back(finalSeq);
    NewDKM.header.numSequences = NewDKM.sequences.size();

    return NewDKM;
}

void WriteDKM(fs::path outpath, DKM_file NewDKM) {
    try {
        ofstream outFile(outpath, ios::binary);
        if (!outFile.is_open()) {
            cout << "Error: Could not open output file." << endl;
            return;
        }

        outFile.write("DKMD", 4);
        outFile.write(reinterpret_cast<char*>(&NewDKM.header.version), sizeof(NewDKM.header.version));
        outFile.write(reinterpret_cast<char*>(&NewDKM.header.origin), sizeof(NewDKM.header.origin));
        outFile.write(reinterpret_cast<char*>(&NewDKM.header.frameSize), sizeof(NewDKM.header.frameSize));
        outFile.write(reinterpret_cast<char*>(&NewDKM.header.numSkins), sizeof(NewDKM.header.numSkins));
        outFile.write(reinterpret_cast<char*>(&NewDKM.header.numVertices), sizeof(NewDKM.header.numVertices));
        outFile.write(reinterpret_cast<char*>(&NewDKM.header.numTexCoords), sizeof(NewDKM.header.numTexCoords));
        outFile.write(reinterpret_cast<char*>(&NewDKM.header.numTriangles), sizeof(NewDKM.header.numTriangles));
        outFile.write(reinterpret_cast<char*>(&NewDKM.header.numGlCommands), sizeof(NewDKM.header.numGlCommands));
        outFile.write(reinterpret_cast<char*>(&NewDKM.header.numFrames), sizeof(NewDKM.header.numFrames));
        outFile.write(reinterpret_cast<char*>(&NewDKM.header.numSurfaces), sizeof(NewDKM.header.numSurfaces));
        for (int i = 0; i < 28; i++) outFile.write("X", 1);
        outFile.write(reinterpret_cast<char*>(&NewDKM.header.numSequences), sizeof(NewDKM.header.numSequences));
        for (int i = 0; i < 4; i++) outFile.write("X", 1);
            
        NewDKM.header.offsetSkins = outFile.tellp();
        for (const auto& s : NewDKM.skinpaths) {
            char name[64] = { 0 };
            string sName = s;
            strncpy(name, sName.c_str(), 63);
            outFile.write(name, 64);
        }

        NewDKM.header.offsetTexCoords = outFile.tellp();
        for (auto& uv : NewDKM.UV) {
            outFile.write(reinterpret_cast<char*>(&uv.s), sizeof(uv.s));
            outFile.write(reinterpret_cast<char*>(&uv.t), sizeof(uv.t));
        }

        NewDKM.header.offsetTriangles = outFile.tellp();
        for (auto& tri : NewDKM.triangles) {
            outFile.write(reinterpret_cast<char*>(&tri.surfaceIndex), sizeof(tri.surfaceIndex));
            outFile.write(reinterpret_cast<char*>(&tri.num_uvframes), sizeof(tri.num_uvframes));
            outFile.write(reinterpret_cast<char*>(&tri.vertexIndices), sizeof(tri.vertexIndices));
            outFile.write(reinterpret_cast<char*>(&tri.textureIndices), sizeof(tri.textureIndices));
        }

        NewDKM.header.offsetFrames = outFile.tellp();
        for (auto& f : NewDKM.frames) {
            outFile.write(reinterpret_cast<char*>(&f.scale), sizeof(f.scale));
            outFile.write(reinterpret_cast<char*>(&f.translate), sizeof(f.translate));
            char name[16] = { 0 };
            string sName = f.name;
            strncpy(name, sName.c_str(), 15);
            outFile.write(name, 16);
            for (auto& v : f.vertices) {
                outFile.write(reinterpret_cast<char*>(&v.vertex), sizeof(v.vertex));
                outFile.write(reinterpret_cast<char*>(&v.lightNormalIndex), sizeof(v.lightNormalIndex));
            }
        }

        NewDKM.header.offsetGlCommands = outFile.tellp();
        for (auto& g : NewDKM.GLCommands) {
            outFile.write(reinterpret_cast<char*>(&g.count), sizeof(g.count));
            outFile.write(reinterpret_cast<char*>(&g.skinIndex), sizeof(g.skinIndex));
            outFile.write(reinterpret_cast<char*>(&g.surfIndex), sizeof(g.surfIndex));
            for (auto& v : g.vertices) {
                outFile.write(reinterpret_cast<char*>(&v.vertexIndex), sizeof(v.vertexIndex));
                outFile.write(reinterpret_cast<char*>(&v.s), sizeof(v.s));
                outFile.write(reinterpret_cast<char*>(&v.t), sizeof(v.t));
            }
        }
        outFile.write("\0\0\0\0", 4);

        NewDKM.header.offsetSurfaces = outFile.tellp();
        char surfName[32] = { 0 };
        strncpy(surfName, NewDKM.surface.name.c_str(), 31);
        outFile.write(surfName, 32);
        outFile.write(reinterpret_cast<char*>(&NewDKM.surface.flags), sizeof(NewDKM.surface.flags));
        outFile.write(reinterpret_cast<char*>(&NewDKM.surface.skinIndex), sizeof(NewDKM.surface.skinIndex));
        outFile.write(reinterpret_cast<char*>(&NewDKM.surface.skinWidth), sizeof(NewDKM.surface.skinWidth));
        outFile.write(reinterpret_cast<char*>(&NewDKM.surface.skinHeight), sizeof(NewDKM.surface.skinHeight));
        outFile.write(reinterpret_cast<char*>(&NewDKM.surface.numUVframes), sizeof(NewDKM.surface.numUVframes));

        NewDKM.header.offsetSequences = outFile.tellp();
        for (auto& as : NewDKM.sequences) {
            char name[16] = { 0 };
            strncpy(name, as.name.c_str(), 15);
            outFile.write(name, 16);
            outFile.write(reinterpret_cast<char*>(&as.startFrame), sizeof(as.startFrame));
            outFile.write(reinterpret_cast<char*>(&as.endFrame), sizeof(as.endFrame));
        }

        NewDKM.header.offsetEnd = outFile.tellp();

        outFile.seekp(52);
        outFile.write(reinterpret_cast<char*>(&NewDKM.header.offsetSkins), sizeof(NewDKM.header.offsetSkins));
        outFile.write(reinterpret_cast<char*>(&NewDKM.header.offsetTexCoords), sizeof(NewDKM.header.offsetTexCoords));
        outFile.write(reinterpret_cast<char*>(&NewDKM.header.offsetTriangles), sizeof(NewDKM.header.offsetTriangles));
        outFile.write(reinterpret_cast<char*>(&NewDKM.header.offsetFrames), sizeof(NewDKM.header.offsetFrames));
        outFile.write(reinterpret_cast<char*>(&NewDKM.header.offsetGlCommands), sizeof(NewDKM.header.offsetGlCommands));
        outFile.write(reinterpret_cast<char*>(&NewDKM.header.offsetSurfaces), sizeof(NewDKM.header.offsetSurfaces));
        outFile.write(reinterpret_cast<char*>(&NewDKM.header.offsetEnd), sizeof(NewDKM.header.offsetEnd));
        outFile.write(reinterpret_cast<char*>(&NewDKM.header.numSequences), sizeof(NewDKM.header.numSequences));
        outFile.write(reinterpret_cast<char*>(&NewDKM.header.offsetSequences), sizeof(NewDKM.header.offsetSequences));

        outFile.close();
        cout << "DKM converted successfully: " << outpath << endl;

    }
    catch (exception& e) {
        cout << "Failed to write file. Error: " << e.what() << endl;
    }
}