libs/xassets/animparts.cpp

@@ -0,0 +1,648 @@
+#include "animparts.h"
+
+#include <QIODevice>
+
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimDynamicFrames &aAnimDynamicFramesIn)
+{
+    aDataStream << aAnimDynamicFramesIn.framesPtr;
+
+    return aDataStream;
+}
+
+QDataStream &operator>>(QDataStream &aDataStream, XAnimDynamicFrames &aAnimDynamicFramesOut)
+{
+    aDataStream >> aAnimDynamicFramesOut.framesPtr;
+
+    return aDataStream;
+}
+QString XAnimDynamicFramesToString(const XAnimDynamicFrames &aAnimDynamicFrames) {
+    QString debug;
+
+    debug.append("XAnimDynamicFrames(");
+
+    debug.append(QString("\n  framesPtr: %1").arg(aAnimDynamicFrames.framesPtr));
+    for (int i = 0; i < 3; i++) {
+        debug.append(QString("\n  frames %1: %2").arg(i).arg(aAnimDynamicFrames.frames[i]));
+    }
+
+    debug.append("\n)");
+
+    return debug;
+}
+
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimDynamicIndices &aAnimDynamicIndicesIn)
+{
+    aDataStream << aAnimDynamicIndicesIn.indices[0];
+
+    return aDataStream;
+}
+
+QDataStream &operator>>(QDataStream &aDataStream, XAnimDynamicIndices &aAnimDynamicIndicesOut)
+{
+    aDataStream >> aAnimDynamicIndicesOut.indices[0];
+
+    return aDataStream;
+}
+QString XAnimDynamicIndicesToString(const XAnimDynamicIndices &aAnimDynamicIndices) {
+    QString debug;
+
+    debug.append("XAnimDynamicIndices(");
+
+    debug.append(QString("\n  indices: %1").arg(aAnimDynamicIndices.indices[0]));
+
+    debug.append("\n)");
+
+    return debug;
+}
+
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimPartTransFrames &aAnimPartTransFramesIn)
+{
+    for (int i = 0; i < 3; i++) {
+        aDataStream << aAnimPartTransFramesIn.mins[i];
+    }
+
+    for (int i = 0; i < 3; i++) {
+        aDataStream << aAnimPartTransFramesIn.size[i];
+    }
+
+    aDataStream
+        << aAnimPartTransFramesIn.frames
+        << aAnimPartTransFramesIn.indices;
+
+    return aDataStream;
+}
+
+QDataStream &operator>>(QDataStream &aDataStream, XAnimPartTransFrames &aAnimPartTransFramesOut)
+{
+    for (int i = 0; i < 3; i++) {
+        aDataStream >> aAnimPartTransFramesOut.mins[i];
+    }
+
+    for (int i = 0; i < 3; i++) {
+        aDataStream >> aAnimPartTransFramesOut.size[i];
+    }
+
+    aDataStream
+        >> aAnimPartTransFramesOut.frames
+        >> aAnimPartTransFramesOut.indices;
+
+    return aDataStream;
+}
+QString XAnimPartTransFramesToString(const XAnimPartTransFrames &aAnimPartTransFrames) {
+    QString debug;
+
+    debug.append("XAnimPartTransFrames(");
+
+    for (int i = 0; i < 3; i++) {
+        debug.append(QString("\n  mins %1: %2").arg(i).arg(aAnimPartTransFrames.mins[i]));
+    }
+    for (int i = 0; i < 3; i++) {
+        debug.append(QString("\n  size %1: %2").arg(i).arg(aAnimPartTransFrames.size[i]));
+    }
+    debug.append(QString("\n  frames: %1").arg(XAnimDynamicFramesToString(aAnimPartTransFrames.frames)));
+    debug.append(QString("\n  frames: %1").arg(XAnimDynamicIndicesToString(aAnimPartTransFrames.indices)));
+
+    debug.append("\n)");
+
+    return debug;
+}
+
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimPartTransData &aAnimPartTransDataIn)
+{
+    aDataStream
+        << aAnimPartTransDataIn.frames;
+
+    for (int i = 0; i < 3; i++) {
+        aDataStream << aAnimPartTransDataIn.frame0[i];
+    }
+
+    return aDataStream;
+}
+
+QDataStream &operator>>(QDataStream &aDataStream, XAnimPartTransData &aAnimPartTransDataOut)
+{
+    aDataStream
+        >> aAnimPartTransDataOut.frames;
+
+    for (int i = 0; i < 3; i++) {
+        aDataStream >> aAnimPartTransDataOut.frame0[i];
+    }
+
+    return aDataStream;
+}
+QString XAnimPartTransDataToString(const XAnimPartTransData &aAnimPartTransData) {
+    QString debug;
+
+    debug.append("XAnimPartTransData(");
+
+    debug.append(QString("\n  frames: %1").arg(XAnimPartTransFramesToString(aAnimPartTransData.frames)));
+
+    for (int i = 0; i < 3; i++) {
+        debug.append(QString("\n  smallTrans: %1").arg(aAnimPartTransData.frame0[i]));
+    }
+    debug.append("\n)");
+
+    return debug;
+}
+
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimPartTrans &aAnimPartTransIn)
+{
+    aDataStream
+        << aAnimPartTransIn.size
+        << aAnimPartTransIn.smallTrans
+        << aAnimPartTransIn.data;
+
+    return aDataStream;
+}
+
+QDataStream &operator>>(QDataStream &aDataStream, XAnimPartTrans &aAnimPartTransOut)
+{
+    aDataStream
+        >> aAnimPartTransOut.size
+        >> aAnimPartTransOut.smallTrans
+        >> aAnimPartTransOut.data;
+
+    return aDataStream;
+}
+QString XAnimPartTransToString(const XAnimPartTrans &aAnimPartTrans) {
+    QString debug;
+
+    debug.append("XAnimPartTrans(");
+
+    debug.append(QString("\n  size: %1").arg(aAnimPartTrans.size));
+    debug.append(QString("\n  smallTrans: %1").arg(aAnimPartTrans.smallTrans));
+    debug.append(QString("\n  data: %1").arg(XAnimPartTransDataToString(aAnimPartTrans.data)));
+    debug.append("\n)");
+
+    return debug;
+}
+
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimDeltaPartQuatDataFrames &aAnimDeltaPartQuatDataFramesIn)
+{
+    aDataStream
+        << aAnimDeltaPartQuatDataFramesIn.framesPtr
+        << aAnimDeltaPartQuatDataFramesIn.indices;
+
+    return aDataStream;
+}
+
+QDataStream &operator>>(QDataStream &aDataStream, XAnimDeltaPartQuatDataFrames &aAnimDeltaPartQuatDataFramesOut)
+{
+    aDataStream
+        >> aAnimDeltaPartQuatDataFramesOut.framesPtr
+        >> aAnimDeltaPartQuatDataFramesOut.indices;
+
+    return aDataStream;
+}
+QString XAnimDeltaPartQuatDataFramesToString(const XAnimDeltaPartQuatDataFrames &aAnimDeltaPartQuatDataFrames) {
+    QString debug;
+
+    debug.append("XAnimDeltaPartQuatDataFrames(");
+
+    debug.append(QString("\n  framesPtr: %1").arg(aAnimDeltaPartQuatDataFrames.framesPtr));
+    for (int i = 0; i < 2; i++) {
+        debug.append(QString("\n  frames %1: %2").arg(i).arg(aAnimDeltaPartQuatDataFrames.frames[i]));
+    }
+    debug.append(QString("\n  indices: %1").arg(XAnimDynamicIndicesToString(aAnimDeltaPartQuatDataFrames.indices)));
+    debug.append("\n)");
+
+    return debug;
+}
+
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimDeltaPartQuatData &aAnimDeltaPartQuatDataIn)
+{
+    aDataStream
+        << aAnimDeltaPartQuatDataIn.frames;
+
+    for (int i = 0; i < 2; i++) {
+        aDataStream << aAnimDeltaPartQuatDataIn.frame0[i];
+    }
+
+    return aDataStream;
+}
+
+QDataStream &operator>>(QDataStream &aDataStream, XAnimDeltaPartQuatData &aAnimDeltaPartQuatDataOut)
+{
+    aDataStream
+        >> aAnimDeltaPartQuatDataOut.frames;
+
+    for (int i = 0; i < 2; i++) {
+        aDataStream >> aAnimDeltaPartQuatDataOut.frame0[i];
+    }
+
+    return aDataStream;
+}
+QString XAnimDeltaPartQuatDataToString(const XAnimDeltaPartQuatData &aAnimDeltaPartQuatData) {
+    QString debug;
+
+    debug.append("XAnimDeltaPartQuatData(");
+
+    debug.append(QString("\n  frames: %1").arg(XAnimDeltaPartQuatDataFramesToString(aAnimDeltaPartQuatData.frames)));
+    for (int i = 0; i < 2; i++) {
+        debug.append(QString("\n  frame0 %1: %2").arg(i).arg(aAnimDeltaPartQuatData.frame0[i]));
+    }
+    debug.append("\n)");
+
+    return debug;
+}
+
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimDeltaPartQuat &aAnimDeltaPartQuatIn)
+{
+    aDataStream
+        << aAnimDeltaPartQuatIn.size
+        << aAnimDeltaPartQuatIn.data;
+
+    return aDataStream;
+}
+
+QDataStream &operator>>(QDataStream &aDataStream, XAnimDeltaPartQuat &aAnimDeltaPartQuatOut)
+{
+    aDataStream
+        >> aAnimDeltaPartQuatOut.size
+        >> aAnimDeltaPartQuatOut.data;
+
+    return aDataStream;
+}
+QString XAnimDeltaPartQuatToString(const XAnimDeltaPartQuat &aAnimDeltaPartQuat) {
+    QString debug;
+
+    debug.append("XAnimDeltaPartQuat(");
+
+    debug.append(QString("\n  size: %1").arg(aAnimDeltaPartQuat.size));
+    debug.append(QString("\n  data: %1").arg(XAnimDeltaPartQuatDataToString(aAnimDeltaPartQuat.data)));
+    debug.append("\n)");
+
+    return debug;
+}
+
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimDeltaPart &aAnimDeltaPartIn)
+{
+    aDataStream
+        << aAnimDeltaPartIn.transPtr
+        << aAnimDeltaPartIn.quatPtr;
+
+    return aDataStream;
+}
+
+QDataStream &operator>>(QDataStream &aDataStream, XAnimDeltaPart &aAnimDeltaPartOut)
+{
+    aDataStream
+        >> aAnimDeltaPartOut.transPtr
+        >> aAnimDeltaPartOut.quatPtr;
+
+    return aDataStream;
+}
+QString XAnimDeltaPartToString(const XAnimDeltaPart &aAnimDeltaPart) {
+    QString debug;
+
+    debug.append("XAnimDeltaPart(");
+
+    debug.append(QString("\n  transPtr: %1").arg(aAnimDeltaPart.transPtr));
+    debug.append(QString("\n  trans: %1").arg(XAnimPartTransToString(aAnimDeltaPart.trans)));
+    debug.append(QString("\n  quatPtr: %1").arg(aAnimDeltaPart.quatPtr));
+    debug.append(QString("\n  quat: %1").arg(XAnimDeltaPartQuatToString(aAnimDeltaPart.quat)));
+    debug.append("\n)");
+
+    return debug;
+}
+
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimNotifyInfo &aAnimNotifyInfoIn)
+{
+    aDataStream
+        << aAnimNotifyInfoIn.name
+        << aAnimNotifyInfoIn.time;
+
+    return aDataStream;
+}
+QDebug operator<<(QDebug debug, const XAnimNotifyInfo &aAnimNotifyInfo) {
+    QDebugStateSaver saver(debug);
+    debug.noquote().nospace();
+
+    debug << "XAnimNotifyInfo(";
+
+    debug << "\n  name: " << aAnimNotifyInfo.name;
+    debug << "\n  time: " << aAnimNotifyInfo.time;
+    debug << "\n)";
+
+    return debug;
+}
+QString XAnimNotifyInfoToString(const XAnimNotifyInfo &aAnimNotifyInfo) {
+    QString debug;
+
+    debug.append("XAnimNotifyInfo(");
+
+    debug.append(QString("\n  name: %1").arg(aAnimNotifyInfo.name));
+    debug.append(QString("\n  time: %1").arg(aAnimNotifyInfo.time));
+    debug.append("\n)");
+
+    return debug;
+}
+
+QDataStream &operator>>(QDataStream &aDataStream, XAnimNotifyInfo &aAnimNotifyInfoOut)
+{
+    aDataStream
+        >> aAnimNotifyInfoOut.name
+        >> aAnimNotifyInfoOut.time;
+
+    return aDataStream;
+}
+
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimIndices &aAnimIndicesIn)
+{
+    aDataStream
+        << aAnimIndicesIn.indexPtr
+        << aAnimIndicesIn.index;
+
+    return aDataStream;
+}
+QDebug operator<<(QDebug debug, const XAnimIndices &aAnimIndices) {
+    QDebugStateSaver saver(debug);
+    debug.noquote().nospace();
+
+    debug << "XAnimIndices(";
+
+    debug << "\n  name: " << aAnimIndices.indexPtr;
+    debug << "\n  namePtr: " << aAnimIndices.index;
+    debug << "\n)";
+
+    return debug;
+}
+QString XAnimIndicesToString(const XAnimIndices &aAnimIndices) {
+    QString debug;
+
+    debug.append("XAnimIndices(");
+
+    debug.append(QString("\n  name: %1").arg(aAnimIndices.indexPtr));
+    debug.append(QString("\n  namePtr: %1").arg(aAnimIndices.index));
+    debug.append("\n)");
+
+    return debug;
+}
+
+QDataStream &operator>>(QDataStream &aDataStream, XAnimIndices &aAnimIndicesOut)
+{
+    aDataStream
+        >> aAnimIndicesOut.indexPtr
+        >> aAnimIndicesOut.index;
+
+    return aDataStream;
+}
+
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimParts &aAnimPartIn)
+{
+    aDataStream
+        << aAnimPartIn.name
+        << aAnimPartIn.dataByteCount
+        << aAnimPartIn.dataShortCount
+        << aAnimPartIn.dataIntCount
+        << aAnimPartIn.randomDataByteCount
+        << aAnimPartIn.randomDataIntCount
+        << aAnimPartIn.numframes
+        << aAnimPartIn.bLoop
+        << aAnimPartIn.bDelta;
+
+    for (int i = 0; i < 12; i++) {
+        aDataStream << aAnimPartIn.boneCount[i];
+    }
+
+    aDataStream
+        << aAnimPartIn.notifyCount
+        << aAnimPartIn.pad
+        << aAnimPartIn.randomDataShortCount
+        << aAnimPartIn.indexCount
+        << aAnimPartIn.framerate
+        << aAnimPartIn.frequency
+        << aAnimPartIn.namesPtr
+        << aAnimPartIn.dataBytePtr
+        << aAnimPartIn.dataShortPtr
+        << aAnimPartIn.dataIntPtr
+        << aAnimPartIn.randomDataShortPtr
+        << aAnimPartIn.randomDataBytePtr
+        << aAnimPartIn.randomDataIntPtr
+        << aAnimPartIn.indices
+        << aAnimPartIn.notifyPtr
+        << aAnimPartIn.deltaPartPtr;
+
+    return aDataStream;
+}
+
+quint32 ROL4(quint32 value, int positions) {
+    return (value << positions) | (value >> (32 - positions));
+}
+
+QDataStream &operator>>(QDataStream &aDataStream, XAnimParts &aAnimPartOut)
+{
+    aDataStream
+        >> aAnimPartOut.namePtr
+        >> aAnimPartOut.dataByteCount
+        >> aAnimPartOut.dataShortCount
+        >> aAnimPartOut.dataIntCount
+        >> aAnimPartOut.randomDataByteCount
+        >> aAnimPartOut.randomDataIntCount
+        >> aAnimPartOut.numframes
+        >> aAnimPartOut.bLoop
+        >> aAnimPartOut.bDelta;
+
+    for (int i = 0; i < 12; i++) {
+        aDataStream >> aAnimPartOut.boneCount[i];
+    }
+
+    aDataStream
+        >> aAnimPartOut.notifyCount
+        >> aAnimPartOut.assetType
+        >> aAnimPartOut.pad;
+
+    aDataStream.skipRawData(3);
+
+    aDataStream
+        >> aAnimPartOut.randomDataShortCount
+        >> aAnimPartOut.indexCount;
+
+    quint32 framerateInt, frequencyInt;
+    aDataStream
+        >> framerateInt
+        >> frequencyInt
+        >> aAnimPartOut.namesPtr
+        >> aAnimPartOut.dataBytePtr
+        >> aAnimPartOut.dataShortPtr
+        >> aAnimPartOut.dataIntPtr
+        >> aAnimPartOut.randomDataShortPtr
+        >> aAnimPartOut.randomDataBytePtr
+        >> aAnimPartOut.randomDataIntPtr
+        >> aAnimPartOut.indices
+        >> aAnimPartOut.notifyPtr
+        >> aAnimPartOut.deltaPartPtr;
+
+    aAnimPartOut.framerate = *reinterpret_cast<float*>(&framerateInt);
+    aAnimPartOut.frequency = *reinterpret_cast<float*>(&frequencyInt);
+
+    if (aAnimPartOut.namePtr) {
+        aAnimPartOut.name = "";
+
+        char animNameChar;
+        aDataStream >> animNameChar;
+        while (animNameChar != '\0') {
+            aAnimPartOut.name += animNameChar;
+
+            aDataStream >> animNameChar;
+        }
+    }
+    if (aAnimPartOut.namesPtr) {
+        int nameCount = aAnimPartOut.boneCount[11];
+        aDataStream.skipRawData(2 * nameCount);
+
+        for (int i = 0; i < nameCount; i++) {
+            aDataStream.skipRawData(2);
+        }
+    }
+    if (aAnimPartOut.notifyPtr) {
+        int notifyCount = aAnimPartOut.notifyCount;
+        aDataStream.skipRawData(8 * notifyCount);
+
+        for (int i = 0; i < notifyCount; i++) {
+            aDataStream.skipRawData(8);
+            aDataStream >> aAnimPartOut.notify;
+        }
+    }
+    if (aAnimPartOut.deltaPartPtr) {
+        aDataStream >> aAnimPartOut.deltaPart;
+        if (aAnimPartOut.deltaPart.transPtr) {
+            aDataStream >> aAnimPartOut.deltaPart.trans;
+
+            if (aAnimPartOut.deltaPart.trans.size) {
+                aDataStream >> aAnimPartOut.deltaPart.trans.data.frames;
+                quint32 size = aAnimPartOut.deltaPart.trans.size;
+                quint32 readSize;
+                if (aAnimPartOut.numframes >= 0x100) {
+                    readSize = 2 * (size + 1);
+                } else {
+                    readSize = size + 1;
+                }
+                aDataStream >> aAnimPartOut.deltaPart.trans.data.frames.indices;
+
+                if (aAnimPartOut.deltaPart.trans.smallTrans) {
+                    if (aAnimPartOut.deltaPart.trans.data.frames.frames.framesPtr) {
+                        aDataStream.skipRawData(3 * (aAnimPartOut.deltaPart.trans.size + 1));
+                    }
+                } else if (aAnimPartOut.deltaPart.trans.data.frames.frames.framesPtr) {
+                    aDataStream.skipRawData(6 * (aAnimPartOut.deltaPart.trans.size + 1));
+                }
+            }
+        }
+        if (aAnimPartOut.deltaPart.quatPtr) {
+            aDataStream >> aAnimPartOut.deltaPart.quat;
+
+            if (aAnimPartOut.deltaPart.quat.size) {
+                aDataStream >> aAnimPartOut.deltaPart.quat.data.frames;
+                aDataStream >> aAnimPartOut.deltaPart.quat.data.frames.indices;
+
+                if (aAnimPartOut.deltaPart.quat.data.frames.framesPtr) {
+                    aDataStream.skipRawData(4 * (aAnimPartOut.deltaPart.quat.size + 1));
+                }
+            } else {
+                aDataStream >> aAnimPartOut.deltaPart.quat.data;
+            }
+        }
+    }
+    if (aAnimPartOut.dataBytePtr) {
+        aDataStream.skipRawData(aAnimPartOut.dataByteCount);
+    }
+    if (aAnimPartOut.dataShortPtr) {
+        aDataStream.skipRawData(ROL4(aAnimPartOut.dataShortCount, 1));
+    }
+    if (aAnimPartOut.dataIntPtr) {
+        aDataStream.skipRawData(ROL4(aAnimPartOut.dataIntCount, 2));
+    }
+    if (aAnimPartOut.randomDataShortPtr) {
+        aDataStream.skipRawData(2 * aAnimPartOut.randomDataShortCount);
+    }
+    if (aAnimPartOut.randomDataBytePtr) {
+        aDataStream.skipRawData(2 * aAnimPartOut.randomDataByteCount);
+    }
+    if (aAnimPartOut.randomDataIntPtr) {
+        aDataStream.skipRawData(ROL4(aAnimPartOut.randomDataIntCount, 2));
+    }
+
+    qDebug() << aDataStream.device()->pos();
+
+    return aDataStream;
+}
+
+QString XAnimPartsToString(const XAnimParts &xAnimParts) {
+    QString debug = "";
+
+    debug.append(QString("XAnimParts("));
+
+    debug.append(QString("\n  name: %1").arg(xAnimParts.name));
+    debug.append(QString("\n  namePtr: %1").arg(QString::number(xAnimParts.namePtr, 16)));
+
+    debug.append(QString("\n  dataByteCount: %1").arg(xAnimParts.dataByteCount));
+    debug.append(QString("\n  dataShortCount: %1").arg(xAnimParts.dataShortCount));
+    debug.append(QString("\n  dataIntCount: %1").arg(xAnimParts.dataIntCount));
+    debug.append(QString("\n  randomDataByteCount: %1").arg(xAnimParts.randomDataByteCount));
+    debug.append(QString("\n  randomDataIntCount: %1").arg(xAnimParts.randomDataIntCount));
+    debug.append(QString("\n  numframes: %1").arg(xAnimParts.numframes));
+
+    debug.append(QString("\n  bLoop: %1").arg(xAnimParts.bLoop));
+    debug.append(QString("\n  bDelta: %1").arg(xAnimParts.bDelta));
+
+    for (int i = 0; i < 12; i++) {
+        debug.append(QString("\n  boneCount %1: %2").arg(i).arg(xAnimParts.boneCount[i]));
+    }
+
+    debug.append(QString("\n  notifyCount: %1").arg(xAnimParts.notifyCount));
+    debug.append(QString("\n  assetType: %1").arg(xAnimParts.assetType));
+
+    debug.append(QString("\n  pad: %1").arg(xAnimParts.pad));
+
+    debug.append(QString("\n  randomDataShortCount: %1").arg(xAnimParts.randomDataShortCount));
+    debug.append(QString("\n  indexCount: %1").arg(xAnimParts.indexCount));
+
+    debug.append(QString("\n  framerate: %1").arg(xAnimParts.framerate));
+    debug.append(QString("\n  frequency: %1").arg(xAnimParts.frequency));
+
+    debug.append(QString("\n  namesPtr: %1").arg(QString::number(xAnimParts.namesPtr, 16)));
+    debug.append(QString("\n  names: %1").arg(xAnimParts.names));
+
+    debug.append(QString("\n  dataBytePtr: %1").arg(QString::number(xAnimParts.dataBytePtr, 16)));
+    debug.append(QString("\n  dataByte: %1").arg(xAnimParts.dataByte));
+
+    debug.append(QString("\n  dataShortPtr: %1").arg(QString::number(xAnimParts.dataShortPtr, 16)));
+    debug.append(QString("\n  dataShort: %1").arg(xAnimParts.dataShort));
+
+    debug.append(QString("\n  dataIntPtr: %1").arg(QString::number(xAnimParts.dataIntPtr, 16)));
+    debug.append(QString("\n  dataInt: %1").arg(xAnimParts.dataInt));
+
+    debug.append(QString("\n  randomDataShortPtr: %1").arg(QString::number(xAnimParts.randomDataShortPtr, 16)));
+    debug.append(QString("\n  randomDataShort: %1").arg(xAnimParts.randomDataShort));
+
+    debug.append(QString("\n  randomDataBytePtr: %1").arg(QString::number(xAnimParts.randomDataBytePtr, 16)));
+    debug.append(QString("\n  randomDataByte: %1").arg(xAnimParts.randomDataByte));
+
+    debug.append(QString("\n  randomDataIntPtr: %1").arg(QString::number(xAnimParts.randomDataIntPtr, 16)));
+    debug.append(QString("\n  randomDataInt: %1").arg(xAnimParts.randomDataInt));
+
+    debug.append(QString("\n  indices: %1").arg(XAnimIndicesToString(xAnimParts.indices)));
+
+    debug.append(QString("\n  notifyPtr: %1").arg(QString::number(xAnimParts.notifyPtr, 16)));
+    debug.append(QString("\n  notify: %1").arg(XAnimNotifyInfoToString(xAnimParts.notify)));
+
+    debug.append(QString("\n  deltaPartPtr: %1").arg(QString::number(xAnimParts.deltaPartPtr, 16)));
+    debug.append(QString("\n  deltaPart: %1").arg(XAnimDeltaPartToString(xAnimParts.deltaPart)));
+
+    debug.append(QString("\n)"));
+
+    return debug;
+}
+
+QDebug operator<<(QDebug debug, const XAnimParts &xanimParts) {
+    QDebugStateSaver saver(debug);
+    debug.noquote().nospace();
+
+    debug << XAnimPartsToString(xanimParts);
+
+    return debug;
+}
+
+
+

libs/xassets/animparts.h

@@ -0,0 +1,173 @@
+#ifndef ANIMPARTS_H
+#define ANIMPARTS_H
+
+#include <QString>
+#include <QDataStream>
+#include <QDebug>
+
+struct XAnimDynamicFrames
+{
+    quint32 framesPtr;
+    quint8 frames[3];
+};
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimDynamicFrames &aAnimDynamicFramesIn);
+QDataStream &operator>>(QDataStream &aDataStream, XAnimDynamicFrames &aAnimDynamicFramesOut);
+
+struct XAnimDynamicIndices
+{
+    quint8 indices[1];
+};
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimDynamicIndices &aAnimDynamicIndicesIn);
+QDataStream &operator>>(QDataStream &aDataStream, XAnimDynamicIndices &aAnimDynamicIndicesOut);
+
+struct XAnimPartTransFrames
+{
+    float mins[3];
+    float size[3];
+    XAnimDynamicFrames frames;
+    XAnimDynamicIndices indices;
+};
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimPartTransFrames &aAnimPartTransFramesIn);
+QDataStream &operator>>(QDataStream &aDataStream, XAnimPartTransFrames &aAnimPartTransFramesOut);
+
+union XAnimPartTransData
+{
+    XAnimPartTransFrames frames;
+    float frame0[3];
+};
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimPartTransData &aAnimPartTransDataIn);
+QDataStream &operator>>(QDataStream &aDataStream, XAnimPartTransData &aAnimPartTransDataOut);
+
+struct XAnimPartTrans
+{
+    quint16 size;
+    quint8 smallTrans;
+    XAnimPartTransData data;
+};
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimPartTrans &aAnimPartTransIn);
+QDataStream &operator>>(QDataStream &aDataStream, XAnimPartTrans &aAnimPartTransOut);
+
+struct XAnimDeltaPartQuatDataFrames
+{
+    quint32 framesPtr;
+    qint16 frames[2];
+
+    XAnimDynamicIndices indices;
+};
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimDeltaPartQuatDataFrames &aAnimDeltaPartQuatDataFramesIn);
+QDataStream &operator>>(QDataStream &aDataStream, XAnimDeltaPartQuatDataFrames &aAnimDeltaPartQuatDataFramesOut);
+
+struct XAnimDeltaPartQuatData
+{
+    XAnimDeltaPartQuatDataFrames frames;
+    qint16 frame0[2];
+};
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimDeltaPartQuatData &aAnimDeltaPartQuatDataIn);
+QDataStream &operator>>(QDataStream &aDataStream, XAnimDeltaPartQuatData &aAnimDeltaPartQuatDataOut);
+
+struct XAnimDeltaPartQuat
+{
+    quint16 size;
+    XAnimDeltaPartQuatData data;
+};
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimDeltaPartQuat &aAnimDeltaPartQuatIn);
+QDataStream &operator>>(QDataStream &aDataStream, XAnimDeltaPartQuat &aAnimDeltaPartQuatOut);
+
+struct XAnimDeltaPart
+{
+    quint32 transPtr;
+    XAnimPartTrans trans;
+
+    quint32 quatPtr;
+    XAnimDeltaPartQuat quat;
+};
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimDeltaPart &aAnimDeltaPartIn);
+QDataStream &operator>>(QDataStream &aDataStream, XAnimDeltaPart &aAnimDeltaPartOut);
+
+struct XAnimNotifyInfo
+{
+    quint16 name;
+    float time;
+};
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimNotifyInfo &aAnimNotifyInfoIn);
+QDataStream &operator>>(QDataStream &aDataStream, XAnimNotifyInfo &aAnimNotifyInfoOut);
+QDebug operator<<(QDebug debug, const XAnimNotifyInfo &aAnimNotifyInfo);
+QString XAnimNotifyInfoToString(const XAnimNotifyInfo &aAnimNotifyInfo);
+
+struct XAnimIndices
+{
+    quint32 indexPtr;
+    quint16 index;
+};
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimIndices &aAnimIndicesIn);
+QDataStream &operator>>(QDataStream &aDataStream, XAnimIndices &aAnimIndicesOut);
+QDebug operator<<(QDebug debug, const XAnimIndices &aAnimIndices);
+QString XAnimIndicesToString(const XAnimIndices &aAnimIndices);
+
+struct XAnimParts
+{
+    QString name;
+    quint32 namePtr;
+
+    quint16 dataByteCount;
+    quint16 dataShortCount;
+    quint16 dataIntCount;
+    quint16 randomDataByteCount;
+    quint16 randomDataIntCount;
+    quint16 numframes;
+
+    bool bLoop;
+    bool bDelta;
+
+    quint8 boneCount[12];
+    quint8 notifyCount;
+    quint8 assetType;
+
+    bool pad;
+
+    quint16 randomDataShortCount;
+    quint16 indexCount;
+
+    float framerate;
+    float frequency;
+
+    quint32 namesPtr;
+    quint16 names;
+
+    quint32 dataBytePtr;
+    quint8 dataByte;
+
+    quint32 dataShortPtr;
+    qint16 dataShort;
+
+    quint32 dataIntPtr;
+    int dataInt;
+
+    quint32 randomDataShortPtr;
+    qint16 randomDataShort;
+
+    quint32 randomDataBytePtr;
+    quint8 randomDataByte;
+
+    quint32 randomDataIntPtr;
+    int randomDataInt;
+
+    XAnimIndices indices;
+
+    qint32 notifyPtr;
+    XAnimNotifyInfo notify;
+
+    qint32 deltaPartPtr;
+    XAnimDeltaPart deltaPart;
+};
+QDataStream &operator<<(QDataStream &aDataStream, const XAnimParts &aAnimPartIn);
+QDataStream &operator>>(QDataStream &aDataStream, XAnimParts &aAnimPartOut);
+QDebug operator<<(QDebug debug, const XAnimParts &xanimParts);
+QString XAnimPartsToString(const XAnimParts &xAnimParts);
+
+struct Animation {
+    QString name;
+    XAnimParts animParts;
+};
+
+#endif // ANIMPARTS_H

libs/xassets/assetlist.cpp

@@ -0,0 +1 @@
+#include "assetlist.h"

libs/xassets/assetlist.h

@@ -0,0 +1,14 @@
+#ifndef ASSETLIST_H
+#define ASSETLIST_H
+
+#include "xasset.h"
+#include "scriptstringlist.h"
+
+struct XAssetList
+{
+    ScriptStringList stringList;
+    int assetCount;
+    QVector<XAsset> assets;
+};
+
+#endif // ASSETLIST_H

libs/xassets/assets.h

@@ -1,7 +1,6 @@
 #ifndef ASSETS_H
 #define ASSETS_H
 
-#include "xgfxpixelshaderloaddef.h"
 #include "xmodel.h"
 #include <QDebug>
 #include <QObject>
@@ -212,13 +211,69 @@ struct _XGTEXTURE_DESC
     _D3DMULTISAMPLE_TYPE MultiSampleType;
 };
 
+struct GfxImageLoadDef;
+
+struct GfxTexture
+{
+    qint32 basemapPtr;
+    D3DBaseTexture *basemap;
+    qint32 mapPtr;
+    D3DTexture *map;
+    qint32 volmapPtr;
+    D3DVolumeTexture *volmap;
+    qint32 cubemapPtr;
+    D3DCubeTexture *cubemap;
+    qint32 loadDefPtr;
+    GfxImageLoadDef *loadDef;
+};
+
+struct GfxImageLoadDef
+{
+    quint8 levelCount;
+    quint8 flags;
+    qint16 dimensions[3];
+    int format;
+    GfxTexture texture;
+};
+
+struct CardMemory
+{
+    int platform[1];
+};
+
+struct GfxImage
+{
+    MapType mapType;
+    GfxTexture texture;
+    quint8 semantic;
+    CardMemory cardMemory;
+    quint16 width;
+    quint16 height;
+    quint16 depth;
+    quint8 category;
+    bool delayLoadPixels;
+    qint32 pixelsPtr;
+    QVector<quint8> pixels;
+    uint baseSize;
+    quint16 streamSlot;
+    bool streaming;
+    qint32 namePtr;
+    QString name;
+};
 
 
 union MaterialPixelShaderProgram
 {
     qint32 psPtr;
-    XD3DPixelShader ps;
+    D3DPixelShader ps;
-    XGfxPixelShaderLoadDef loadDef;
+    GfxPixelShaderLoadDef loadDef;
+};
+
+struct stream_source_info_t
+{
+    quint16 Stream;
+    quint16 Offset;
+    uint Type;
 };
 
 struct __declspec(align(4)) XMALOOPREGION
@@ -456,6 +511,38 @@ struct MaterialTechniqueSet
     MaterialTechnique *techniques[26];
 };
 
+struct XModel
+{
+    const char *name;
+    quint8 numBones;
+    quint8 numRootBones;
+    quint8 numsurfs;
+    quint8 lodRampType;
+    quint16 *boneNames;
+    quint8 *parentList;
+    qint16 *quats;
+    float *trans;
+    quint8 *partClassification;
+    DObjAnimMat *baseMat;
+    XSurface *surfs;
+    Material **materialHandles;
+    XModelLodInfo lodInfo[4];
+    XModelCollSurf *collSurfs;
+    int numCollSurfs;
+    int contents;
+    XBoneInfo *boneInfo;
+    float radius;
+    float mins[3];
+    float maxs[3];
+    qint16 numLods;
+    qint16 collLod;
+    XModelStreamInfo streamInfo;
+    int memUsage;
+    quint8 flags;
+    PhysPreset *physPreset;
+    PhysGeomList *physGeoms;
+};
+
 struct XModelPiece
 {
     XModel *model;
@@ -675,7 +762,7 @@ struct CollisionAabbTree
     CollisionAabbTreeIndex u;
 };
 
-struct XCModel
+struct CModel
 {
     float mins[3];
     float maxs[3];
@@ -683,14 +770,14 @@ struct XCModel
     CLeaf leaf;
 };
 
-struct XCBrush
+struct CBrush
 {
     float mins[3];
     int contents;
     float maxs[3];
     uint numsides;
     qint32 sidesPtr;
-    QVector<XCBrushSide> sides;
+    QVector<CBrushSide> sides;
     qint16 axialMaterialNum[2][3];
     qint32 baseAdjacentSidePtr;
     quint8 baseAdjacentSide;
@@ -2785,17 +2872,36 @@ struct FxImpactTable
     QVector<FxImpactEntry> table;
 };
 
+struct RawFile
+{
+    qint32 namePtr;
+    QString name;
+    int len;
+    qint32 bufferPtr;
+    QString buffer;
+};
+
+struct StringTable
+{
+    qint32 namePtr;
+    QString name;
+    int columnCount;
+    int rowCount;
+    qint32 valuesPtr;
+    QStringList values;
+};
+
 union XAssetHeader
 {
     XModelPieces *xmodelPieces;
-    XPhysPreset *physPreset;
+    PhysPreset *physPreset;
     XAnimParts *parts;
     XModel *model;
-    XMaterial *material;
+    Material *material;
-    XMaterialPixelShader *pixelShader;
+    MaterialPixelShader *pixelShader;
-    XMaterialVertexShader *vertexShader;
+    MaterialVertexShader *vertexShader;
     MaterialTechniqueSet *techniqueSet;
-    XGfxImage *image;
+    GfxImage *image;
     SoundAliasList *sound;
     SndCurve *sndCurve;
     LoadedSound *loadSnd;
@@ -2814,9 +2920,300 @@ union XAssetHeader
     XSoundDriverGlobals *sndDriverGlobals;
     const FxEffectDef *fx;
     FxImpactTable *impactFx;
-    XRawFile *rawfile;
+    RawFile *rawfile;
-    XStringTable *stringTable;
+    StringTable *stringTable;
     void *data;
 };
 
+struct StreamDelayInfo
+{
+    const void *ptr;
+    int size;
+};
+
+class Assets : public QObject
+{
+    Q_OBJECT
+public:
+    explicit Assets(QObject *parent = nullptr);
+    ~Assets();
+
+private:
+    QVector<Glyph> Load_GlyphArray(QDataStream *aStream, int count);
+    QVector<GfxLightRegionAxis> Load_GfxLightRegionAxisArray(QDataStream *aStream, int count);
+    QVector<GfxDrawSurf> Load_GfxDrawSurfArray(QDataStream *aStream, int count);
+    QVector<GfxSceneDynBrush> Load_GfxSceneDynBrushArray(QDataStream *aStream, int count);
+    QVector<GfxSceneDynModel> Load_GfxSceneDynModelArray(QDataStream *aStream, int count);
+    QVector<GfxStreamingAabbTree> Load_GfxStreamingAabbTreeArray(QDataStream *aStream, int count);
+    GfxLightGridColors Load_GfxLightGridColors(QDataStream *aStream);
+    QVector<GfxLightGridColors> Load_GfxLightGridColorsArray(QDataStream *aStream, int count);
+    QVector<GfxLightGridEntry> Load_GfxLightGridEntryArray(QDataStream *aStream, int count);
+    QVector<GfxCullGroup> Load_GfxCullGroupArray(QDataStream *aStream, int count);
+    QVector<quint16> Load_StaticModelIndexArray(QDataStream *aStream, int count);
+    QVector<GfxStaticModelInst> Load_GfxStaticModelInstArray(QDataStream *aStream, int count);
+    XItemKeyHandler Load_ItemKeyHandler(QDataStream *aStream);
+    XItemKeyHandler Load_ItemKeyHandlerNext(QDataStream *aStream);
+    XEditFieldDef Load_EditFieldDef(QDataStream *aStream);
+    OperationEnum Load_Operator(QDataStream *aStream);
+    QVector<quint16> Load_LeafBrushArray(QDataStream *aStream, int count);
+    CLeaf Load_CLeaf(QDataStream *aStream);
+    QVector<CModel> Load_CModelArray(QDataStream *aStream, int count);
+    QVector<CollisionAabbTree> Load_CollisionAabbTreeArray(QDataStream *aStream, int count);
+    CollisionBorder Load_CollisionBorder(QDataStream *aStream);
+    QVector<CollisionBorder> Load_CollisionBorderArray(QDataStream *aStream, int count);
+    CLeafBrushNodeChildren Load_cLeafBrushNodeChildren_t(QDataStream *aStream);
+    QVector<CLeaf> Load_cLeaf_tArray(QDataStream *aStream, int count);
+    QVector<DynEntityClient> Load_DynEntityClientArray(QDataStream *aStream, int count);
+    QVector<DynEntityPose> Load_DynEntityPoseArray(QDataStream *aStream, int count);
+    QVector<DynEntityColl> Load_DynEntityCollArray(QDataStream *aStream, int count);
+    QVector<FxTrailVertex> Load_FxTrailVertexArray(QDataStream *aStream, int count);
+    QVector<FxElemVelStateSample> Load_FxElemVelStateSampleArray(QDataStream *aStream, int count);
+    QVector<FxElemVisStateSample> Load_FxElemVisStateSampleArray(QDataStream *aStream, int count);
+    QVector<PathBaseNode> Load_pathbasenode_tArray(QDataStream *aStream, int count);
+    QVector<PathLink> Load_pathlink_tArray(QDataStream *aStream, int count);
+    QVector<XModelHighMipBounds> Load_XModelHighMipBoundsArray(QDataStream *aStream, int count);
+    XModelCollSurf Load_XModelCollSurf(QDataStream *aStream);
+    quint8 Load_cbrushedge_t(QDataStream *aStream);
+    QVector<quint8> Load_cbrushedge_tArray(QDataStream *aStream, size_t count);
+    CPlane Load_cplane_t(QDataStream *aStream);
+    CPlane Load_CPlane(QDataStream *aStream);
+    QVector<CPlane> Load_cplane_tArray(QDataStream *aStream, int count);
+    QVector<MaterialConstantDef> Load_MaterialConstantDefArray(QDataStream *aStream, int count);
+    QVector<GfxStateBits> Load_GfxStateBitsArray(QDataStream *aStream, int count);
+    MaterialArgumentCodeConst Load_MaterialArgumentCodeConst(QDataStream *aStream);
+    MaterialVertexDeclaration Load_MaterialVertexDeclaration(QDataStream *aStream);
+    QVector<quint8> Load_byteShaderArray(QDataStream *aStream, size_t count);
+    QVector<quint8> Load_byte4Array(QDataStream *aStream, size_t count);
+    QVector<GfxTexture> Load_GfxRawTextureArray(QDataStream *aStream, int count);
+    D3DCubeTexture Load_IDirect3DCubeTexture9(QDataStream *aStream);
+    D3DVolumeTexture Load_IDirect3DVolumeTexture9(QDataStream *aStream);
+    D3DTexture Load_IDirect3DTexture9(QDataStream *aStream);
+    QVector<quint16> Load_r_index16_tArray(QDataStream *aStream, int count);
+    QVector<quint16> Load_r_index_tArray(QDataStream *aStream, int count);
+    D3DIndexBuffer Load_GfxIndexBuffer(QDataStream *aStream);
+    QVector<quint16> Load_XBlendInfoArray(QDataStream *aStream, int count);
+    D3DVertexBuffer Load_GfxVertexBuffer(QDataStream *aStream);
+    QVector<XSurfaceCollisionNode> Load_XSurfaceCollisionNodeArray(QDataStream *aStream, int count);
+    QVector<XSurfaceCollisionLeaf> Load_XSurfaceCollisionLeafArray(QDataStream *aStream, int count);
+    QVector<GfxBrushModel> Load_GfxBrushModelArray(QDataStream *aStream, int count);
+    QVector<GfxPackedVertex> Load_GfxPackedVertex0Array(QDataStream *aStream, int count);
+    void Load_GfxWorldVertex0Array(QDataStream *aStream, int count);
+    QVector<XAUDIOCHANNELMAPENTRY> Load_XAUDIOCHANNELMAPENTRYArray(QDataStream *aStream, int count);
+    StreamFileNamePacked Load_StreamFileNamePacked(QDataStream *aStream);
+    QVector<XAudioReverbSettings> Load_XaReverbSettingsArray(QDataStream *aStream, int count);
+    QVector<char> Load_char2048Array(QDataStream *aStream, size_t count);
+    QVector<DObjAnimMat> Load_DObjAnimMatArray(QDataStream *aStream, int count);
+    QVector<XBoneInfo> Load_XBoneInfoArray(QDataStream *aStream, int count);
+    QVector<QVector<quint16>> Load_UShortVecArray(QDataStream *aStream, int count);
+    QVector<QVector<quint8>> Load_ByteVecArray(QDataStream *aStream, int count);
+    QVector<dmaterial_t> Load_dmaterial_tArray(QDataStream *aStream, int count);
+    QVector<const char> Load_ConstCharArray(QDataStream *aStream, size_t count);
+    quint16 Load_ScriptString(QDataStream *aStream);
+    QVector<quint16> Load_UnsignedShortArray(QDataStream *aStream, int count);
+    QVector<qint16> Load_XQuat2(QDataStream *aStream);
+    QVector<QVector<quint16>> Load_XQuat2Array(QDataStream *aStream, int count);
+    QVector<ushort> Load_ushortArray(QDataStream *aStream, int count);
+    QVector<short> Load_shortArray(QDataStream *aStream, int count);
+    QVector<float> Load_vec3_t(QDataStream *aStream);
+    QVector<QVector<float>> Load_vec3_tArray(QDataStream *aStream, int count);
+    QVector<QVector<float>> Load_vec2_tArray(QDataStream *aStream, int count);
+    QVector<quint16> Load_raw_byte16Array(QDataStream *aStream, size_t count);
+    QVector<quint8> Load_raw_byteArray(QDataStream *aStream, size_t count);
+    QVector<uint> Load_raw_uint128Array(QDataStream *aStream, int count);
+    QVector<uint> Load_raw_uintArray(QDataStream *aStream, int count);
+    float Load_float(QDataStream *aStream);
+    QVector<float> Load_floatArray(QDataStream *aStream, int count);
+    uint Load_uint(QDataStream *aStream);
+    QVector<uint> Load_uintArray(QDataStream *aStream, int count);
+    QVector<_DWORD> Load_DWORDArray(QDataStream *aStream, int count);
+    QVector<quint8> Load_byte4096Array(QDataStream *aStream, size_t count);
+    int Load_int(QDataStream *aStream);
+    QVector<int> Load_intArray(QDataStream *aStream, int count);
+    char Load_char(QDataStream *aStream);
+    QVector<char> Load_charArray(QDataStream *aStream, size_t count);
+    QVector<quint8> Load_byteArray(QDataStream *aStream, size_t count);
+    GfxWorldDpvsPlanes Load_GfxWorldDpvsPlanes(QDataStream *aStream, GfxWorld aGfxWorld);
+    GfxWorldDpvsDynamic Load_GfxWorldDpvsDynamic(QDataStream *aStream, GfxWorld aGfxWorld);
+    GfxLightRegionHull Load_GfxLightRegionHull(QDataStream *aStream);
+    quint16 __ROL4__(quint16 value, quint16 bits);
+    GfxShadowGeometry Load_GfxShadowGeometry(QDataStream *aStream);
+    GfxWorldStreamInfo Load_GfxWorldStreamInfo(QDataStream *aStream);
+    GfxLightGrid Load_GfxLightGrid(QDataStream *aStream);
+    GfxWorldVertexLayerData Load_GfxWorldVertexLayerData(QDataStream *aStream, GfxWorld aGfxWorld);
+    GfxWorldVertexData Load_GfxWorldVertexData(QDataStream *aStream, GfxWorld aGfxWorld);
+    GfxAabbTree Load_GfxAabbTree(QDataStream *aStream);
+    QVector<GfxAabbTree> Load_GfxAabbTreeArray(QDataStream *aStream, int count);
+    GfxCell Load_GfxCell(QDataStream *aStream);
+    GfxPortal Load_GfxPortal(QDataStream *aStream);
+    QVector<GfxPortal> Load_GfxPortalArray(QDataStream *aStream, int count);
+    QString Load_XStringCustom(QDataStream *aStream);
+    QString Load_XString(QDataStream *aStream);
+    RawFile Load_RawFile(QDataStream *aStream);
+    XLocalizeEntry Load_LocalizeEntry(QDataStream *aStream);
+    void Load_operandInternalDataUnion(QDataStream *aStream);
+    XComPrimaryLight Load_ComPrimaryLight(QDataStream *aStream);
+    CollisionPartition Load_CollisionPartition(QDataStream *aStream);
+    CLeafBrushNodeLeaf Load_CLeafBrushNodeLeaf(QDataStream *aStream, int leafBrushCount);
+    CLeafBrushNodeData Load_CLeafBrushNodeData(QDataStream *aStream, int aNodeCount);
+    MapEnts Load_MapEnts(QDataStream *aStream);
+    FxTrailDef Load_FxTrailDef(QDataStream *aStream);
+    FxEffectDefRef Load_FxEffectDefRef(QDataStream *aStream);
+    GameWorldMp Load_GameWorldMp(QDataStream *aStream);
+    QVector<PathNodeTree> LoadPathNodeTreeArray(QDataStream *aStream, int count);
+    PathNodeTreeNodes Load_PathNodeTreeNodes(QDataStream *aStream);
+    PathNodeConstant Load_PathNodeConstant(QDataStream *aStream);
+    QVector<XModelCollSurf> Load_XModelCollSurfArray(QDataStream *aStream, int count);
+    PhysPreset Load_PhysPreset(QDataStream *aStream);
+    MaterialArgumentDef Load_MaterialArgumentDef(QDataStream *aStream, MaterialShaderArgument aArgument);
+    GfxPixelShaderLoadDef Load_GfxPixelShaderLoadDef(QDataStream *aStream);
+    GfxVertexShaderLoadDef Load_GfxVertexShaderLoadDef(QDataStream *aStream);
+    QVector<quint8> Load_GfxImagePixels(QDataStream *aStream, GfxImage aGfxImage);
+    GfxTexture Load_GfxTexture(QDataStream *aStream, GfxTexture aGfxTexture, GfxImageLoadDef aGfxImageLoadDef);
+    XSurfaceVertexInfo Load_XSurfaceVertexInfo(QDataStream *aStream);
+    XSurfaceCollisionTree Load_XSurfaceCollisionTree(QDataStream *aStream);
+    MaterialInfo Load_MaterialInfo(QDataStream *aStream);
+    XAUDIOCHANNELMAP Load_XAUDIOCHANNELMAP(QDataStream *aStream);
+    SndCurve Load_SndCurve(QDataStream *aStream);
+    StreamFileNameRaw Load_StreamFileNameRaw(QDataStream *aStream);
+    XSoundDriverGlobals Load_SndDriverGlobals(QDataStream *aStream);
+    XaSeekTable Load_XaSeekTable(QDataStream *aStream);
+    XAUDIOPACKET_ALIGNED Load_XAUDIOPACKET_ALIGNED(QDataStream *aStream);
+    XAnimNotifyInfo Load_XAnimNotifyInfo(QDataStream *aStream);
+    XAnimDynamicFrames Load_XAnimDynamicFrames(QDataStream *aStream, XAnimPartTrans aXAnimPartTrans, XAnimDynamicIndices aXAnimDynamicIndices, XAnimDynamicFrames aXAnimDynamicFrames);
+    XAnimDynamicIndices Load_XAnimDynamicIndicesTrans(QDataStream *aStream, XAnimParts aXAnimParts, XAnimPartTrans aXAnimPartTrans);
+    XAnimDynamicIndices Load_XAnimDynamicIndicesDeltaQuat(QDataStream *aStream);
+    XAnimIndices Load_XAnimIndices(QDataStream *aStream, XAnimParts aXAnimParts, XAnimIndices aXAnimIndices);
+    QStringList Load_XStringArray(QDataStream *aStream, int count);
+    QVector<quint16> Load_ScriptStringArray(QDataStream *aStream, int count);
+    QVector<GfxLightRegionHull> Load_GfxLightRegionHullArray(QDataStream *aStream, int count);
+    QVector<GfxShadowGeometry> Load_GfxShadowGeometryArray(QDataStream *aStream, int count);
+    StringTable Load_StringTable(QDataStream *aStream);
+    RawFile Load_RawFilePtr(QDataStream *aStream);
+    void Load_LocalizeEntryPtr(QDataStream *aStream);
+    XMultiDef Load_MultiDef(QDataStream *aStream);
+    XOperand Load_Operand(QDataStream *aStream);
+    QVector<XComPrimaryLight> Load_ComPrimaryLightArray(QDataStream *aStream, int count);
+    CBrushSide Load_cbrushside_t(QDataStream *aStream);
+    CBrush Load_CBrush(QDataStream *aStream);
+    QVector<CollisionPartition> Load_CollisionPartitionArray(QDataStream *aStream, int count);
+    CLeafBrushNode Load_CLeafBrushNode(QDataStream *aStream);
+    QVector<cNode_t> Load_cNode_tArray(QDataStream *aStream, int count);
+    void Load_MapEntsPtr(QDataStream *aStream);
+    void Load_GameWorldMpPtr(QDataStream *aStream);
+    void Load_pathnode_tree_info_t(QDataStream *aStream);
+    void Load_pathnode_t(QDataStream *aStream);
+    void Load_cbrushside_tArray(QDataStream *aStream, int count);
+    void Load_PhysPresetPtr(QDataStream *aStream);
+    MaterialShaderArgument Load_MaterialShaderArgument(QDataStream *aStream);
+    MaterialPixelShaderProgram Load_MaterialPixelShaderProgram(QDataStream *aStream);
+    void Load_MaterialVertexShaderProgram(QDataStream *aStream);
+    GfxImageLoadDef Load_GfxImageLoadDef(QDataStream *aStream);
+    GfxTexture Load_GfxTextureLoad(QDataStream *aStream);
+    XRigidVertList Load_XRigidVertList(QDataStream *aStream);
+    void Load_snd_alias_list_name(QDataStream *aStream);
+    QVector<XAUDIOCHANNELMAP> Load_XAUDIOCHANNELMAPArray(QDataStream *aStream, int count);
+    SndCurve Load_SndCurvePtr(QDataStream *aStream);
+    void Load_StreamFileInfo(QDataStream *aStream);
+    void Load_SndDriverGlobalsPtr(QDataStream *aStream);
+    XaSound Load_XaSound(QDataStream *aStream);
+    QVector<XAnimNotifyInfo> Load_XAnimNotifyInfoArray(QDataStream *aStream, int count);
+    void Load_XAnimPartTransFrames(QDataStream *aStream);
+    void Load_XAnimDeltaPartQuatDataFrames(QDataStream *aStream);
+    void Load_TempStringArray(QDataStream *aStream, int count);
+    GfxLightRegion Load_GfxLightRegion(QDataStream *aStream);
+    StringTable Load_StringTablePtr(QDataStream *aStream);
+    void Load_entryInternalData(QDataStream *aStream);
+    ComWorld Load_ComWorld(QDataStream *aStream);
+    QVector<CBrush> Load_cbrush_tArray(QDataStream *aStream, int count);
+    QVector<CLeafBrushNode> Load_cLeafBrushNode_tArray(QDataStream *aStream, int count);
+    PathNodeTree Load_PathNodeTree(QDataStream *aStream);
+    void Load_pathnode_tArray(QDataStream *aStream, int count);
+    BrushWrapper Load_BrushWrapper(QDataStream *aStream);
+    void Load_MaterialShaderArgumentArray(QDataStream *aStream, int count);
+    MaterialPixelShader Load_MaterialPixelShader(QDataStream *aStream);
+    void Load_MaterialVertexShader(QDataStream *aStream);
+    GfxImage Load_GfxImage(QDataStream *aStream);
+    void Load_XRigidVertListArray(QDataStream *aStream, int count);
+    void Load_snd_alias_list_nameArray(QDataStream *aStream, int count);
+    void Load_SpeakerMapChannel(QDataStream *aStream);
+    void Load_LoadedSound(QDataStream *aStream);
+    void Load_StreamFileName(QDataStream *aStream);
+    void Load_XAnimPartTransData(QDataStream *aStream);
+    void Load_XAnimDeltaPartQuatData(QDataStream *aStream);
+    void Load_ScriptStringList(QDataStream *aStream);
+    void Load_GfxLightRegionArray(QDataStream *aStream, int count);
+    void Load_GfxCellArray(QDataStream *aStream, int count);
+    void Load_expressionEntry(QDataStream *aStream);
+    void Load_ComWorldPtr(QDataStream *aStream);
+    void Load_pathnode_tree_tArray(QDataStream *aStream, int count);
+    void Load_MaterialPixelShaderPtr(QDataStream *aStream);
+    void Load_GfxImagePtr(QDataStream *aStream);
+    void Load_XSurface(QDataStream *aStream);
+    void Load_SpeakerMapChannelArray(QDataStream *aStream, int count);
+    void Load_StreamedSound(QDataStream *aStream);
+    void Load_LoadedSoundPtr(QDataStream *aStream);
+    void Load_XAnimPartTrans(QDataStream *aStream);
+    void Load_XAnimDeltaPartQuat(QDataStream *aStream);
+    void Load_GfxReflectionProbe(QDataStream *aStream);
+    void Load_PathData(QDataStream *aStream);
+    void Load_PhysGeomInfoArray(QDataStream *aStream, int count);
+    void Load_GfxLightmapArray(QDataStream *aStream);
+    void Load_GfxLightImage(QDataStream *aStream);
+    void Load_MaterialVertexShaderPtrArray(QDataStream *aStream, int count);
+    void Load_water_t(QDataStream *aStream);
+    void Load_XSurfaceArray(QDataStream *aStream, int count);
+    void Load_SpeakerMap(QDataStream *aStream);
+    void Load_SoundFileRef(QDataStream *aStream);
+    void Load_XAnimDeltaPart(QDataStream *aStream);
+    void Load_GfxReflectionProbeArray(QDataStream *aStream, int count);
+    void Load_expressionEntry_ptrArray(QDataStream *aStream, int count);
+    void Load_GameWorldSp(QDataStream *aStream);
+    void Load_PhysGeomList(QDataStream *aStream);
+    void Load_GfxLightmapArrayArray(QDataStream *aStream, int count);
+    void Load_GfxLightDef(QDataStream *aStream);
+    void Load_MaterialTextureDefInfo(QDataStream *aStream);
+    void Load_MaterialPass(QDataStream *aStream);
+    void Load_SoundFile(QDataStream *aStream);
+    void Load_XAnimParts(QDataStream *aStream);
+    void Load_statement(QDataStream *aStream);
+    void Load_GameWorldSpPtr(QDataStream *aStream);
+    void Load_GfxLightDefPtr(QDataStream *aStream);
+    void Load_MaterialTextureDef(QDataStream *aStream);
+    void Load_MaterialPassArray(QDataStream *aStream, int count);
+    void Load_snd_alias_t(QDataStream *aStream);
+    void Load_XAnimPartsPtr(QDataStream *aStream);
+    void Load_GfxLight(QDataStream *aStream);
+    void Load_MaterialTextureDefArray(QDataStream *aStream, int count);
+    void Load_MaterialTechnique(QDataStream *aStream);
+    void Load_snd_alias_tArray(QDataStream *aStream, int count);
+    void Load_snd_alias_list_t(QDataStream *aStream);
+    void Load_MaterialTechniquePtrArray(QDataStream *aStream, int count);
+    void Load_snd_alias_list_ptr(QDataStream *aStream);
+    void Load_MaterialTechniqueSet(QDataStream *aStream);
+    void Load_MaterialTechniqueSetPtr(QDataStream *aStream);
+    void Load_Material(QDataStream *aStream);
+    void Load_MaterialHandle(QDataStream *aStream);
+    void Load_Font(QDataStream *aStream);
+    void Load_MaterialMemory(QDataStream *aStream);
+    void Load_sunflare_t(QDataStream *aStream);
+    void Load_windowDef_t(QDataStream *aStream);
+    void Load_listBoxDef_t(QDataStream *aStream);
+    void Load_GfxSurface(QDataStream *aStream);
+    void Load_MaterialHandleArray(QDataStream *aStream, int count);
+    void Load_FontHandle(QDataStream *aStream);
+    void Load_MaterialMemoryArray(QDataStream *aStream, int count);
+    void Load_Window(QDataStream *aStream);
+    void Load_FxElemMarkVisuals(QDataStream *aStream);
+    void Load_XModel(QDataStream *aStream);
+    void Load_GfxSurfaceArray(QDataStream *aStream, int count);
+    void Load_itemDefData_t(QDataStream *aStream);
+    void Load_FxElemMarkVisualsArray(QDataStream *aStream, int count);
+    void Load_XModelPtr(QDataStream *aStream);
+    void Load_GfxStaticModelDrawInst(QDataStream *aStream);
+    void Load_itemDef_t(QDataStream *aStream);
+    void Load_cStaticModel_t(QDataStream *aStream);
+    void Load_FxElemVisuals(QDataStream *aStream);
+    void Load_XModelPiece(QDataStream *aStream);
+};
+
 #endif // ASSETS_H

libs/xassets/clipmap.cpp

@@ -0,0 +1 @@
+#include "clipmap.h"

libs/xassets/clipmap.h

@@ -0,0 +1,233 @@
+#ifndef CLIPMAP_H
+#define CLIPMAP_H
+
+#include "xmodel.h"
+#include "mapent.h"
+#include "effectdef.h"
+
+struct cStaticModelWritable
+{
+    unsigned __int16 nextModelInWorldSector;
+};
+
+struct cStaticModel_s
+{
+    cStaticModelWritable writable;
+    Model *xmodel;
+    float origin[3];
+    float invScaledAxis[3][3];
+    float absmin[3];
+    float absmax[3];
+};
+
+struct dmaterial_t
+{
+    char material[64];
+    int surfaceFlags;
+    int contentFlags;
+};
+
+struct cNode_t
+{
+    CPlane *plane;
+    __int16 children[2];
+};
+
+struct CLeaf
+{
+    unsigned __int16 firstCollAabbIndex;
+    unsigned __int16 collAabbCount;
+    int brushContents;
+    int terrainContents;
+    float mins[3];
+    float maxs[3];
+    int leafBrushNode;
+    __int16 cluster;
+};
+
+struct CLeafBrushNodeLeaf
+{
+    unsigned __int16 *brushes;
+};
+
+struct CLeafBrushNodeChildren
+{
+    float dist;
+    float range;
+    unsigned __int16 childOffset[2];
+};
+
+union CLeafBrushNodeData
+{
+    CLeafBrushNodeLeaf leaf;
+    CLeafBrushNodeChildren children;
+};
+
+struct CLeafBrushNode
+{
+    unsigned __int8 axis;
+    __int16 leafBrushCount;
+    int contents;
+    CLeafBrushNodeData data;
+};
+
+struct CollisionBorder
+{
+    float distEq[3];
+    float zBase;
+    float zSlope;
+    float start;
+    float length;
+};
+
+struct CollisionPartition
+{
+    unsigned __int8 triCount;
+    unsigned __int8 borderCount;
+    int firstTri;
+    CollisionBorder *borders;
+};
+
+union CollisionAabbTreeIndex
+{
+    int firstChildIndex;
+    int partitionIndex;
+};
+
+struct CollisionAabbTree
+{
+    float origin[3];
+    float halfSize[3];
+    unsigned __int16 materialIndex;
+    unsigned __int16 childCount;
+    CollisionAabbTreeIndex u;
+};
+
+struct CModel
+{
+    float mins[3];
+    float maxs[3];
+    float radius;
+    CLeaf leaf;
+};
+
+struct __declspec(align(16)) CBrush
+{
+    float mins[3];
+    int contents;
+    float maxs[3];
+    unsigned int numsides;
+    CBrushSide *sides;
+    __int16 axialMaterialNum[2][3];
+    unsigned __int8 *baseAdjacentSide;
+    __int16 firstAdjacentSideOffsets[2][3];
+    unsigned __int8 edgeCount[2][3];
+};
+
+enum DynEntityType : __int32
+{
+    DYNENT_TYPE_INVALID = 0x0,
+    DYNENT_TYPE_CLUTTER = 0x1,
+    DYNENT_TYPE_DESTRUCT = 0x2,
+    DYNENT_TYPE_COUNT = 0x3,
+};
+
+struct GfxPlacement
+{
+    float quat[4];
+    float origin[3];
+};
+
+struct XModelPieces;
+struct DynEntityDef
+{
+    DynEntityType type;
+    GfxPlacement pose;
+    Model *xModel;
+    unsigned __int16 brushModel;
+    unsigned __int16 physicsBrushModel;
+    const EffectDef *destroyFx;
+    XModelPieces *destroyPieces;
+    PhysPreset *physPreset;
+    int health;
+    PhysMass mass;
+    int contents;
+};
+
+struct DynEntityPose
+{
+    GfxPlacement pose;
+    float radius;
+};
+
+struct DynEntityClient
+{
+    int physObjId;
+    unsigned __int16 flags;
+    unsigned __int16 lightingHandle;
+    int health;
+};
+
+struct DynEntityColl
+{
+    unsigned __int16 sector;
+    unsigned __int16 nextEntInSector;
+    float linkMins[2];
+    float linkMaxs[2];
+};
+
+struct ClipMap
+{
+    const char *name;
+    int isInUse;
+    int planeCount;
+    CPlane *planes;
+    unsigned int numStaticModels;
+    cStaticModel_s *staticModelList;
+    unsigned int numMaterials;
+    dmaterial_t *materials;
+    unsigned int numBrushSides;
+    CBrushSide *brushsides;
+    unsigned int numBrushEdges;
+    unsigned __int8 *brushEdges;
+    unsigned int numNodes;
+    cNode_t *nodes;
+    unsigned int numLeafs;
+    CLeaf *leafs;
+    unsigned int leafbrushNodesCount;
+    CLeafBrushNode *leafbrushNodes;
+    unsigned int numLeafBrushes;
+    unsigned __int16 *leafbrushes;
+    unsigned int numLeafSurfaces;
+    unsigned int *leafsurfaces;
+    unsigned int vertCount;
+    float (*verts)[3];
+    int triCount;
+    unsigned __int16 *triIndices;
+    unsigned __int8 *triEdgeIsWalkable;
+    int borderCount;
+    CollisionBorder *borders;
+    int partitionCount;
+    CollisionPartition *partitions;
+    int aabbTreeCount;
+    CollisionAabbTree *aabbTrees;
+    unsigned int numSubModels;
+    CModel *cmodels;
+    unsigned __int16 numBrushes;
+    CBrush *brushes;
+    int numClusters;
+    int clusterBytes;
+    unsigned __int8 *visibility;
+    int vised;
+    MapEnts *mapEnts;
+    CBrush *box_brush;
+    CModel box_model;
+    unsigned __int16 dynEntCount[2];
+    DynEntityDef *dynEntDefList[2];
+    DynEntityPose *dynEntPoseList[2];
+    DynEntityClient *dynEntClientList[2];
+    DynEntityColl *dynEntCollList[2];
+    unsigned int checksum;
+};
+
+#endif // CLIPMAP_H

libs/xassets/effectdef.h

@@ -0,0 +1,203 @@
+#ifndef EFFECTDEF_H
+#define EFFECTDEF_H
+
+#include "material.h"
+#include "xmodel.h"
+
+struct FxSpawnDefLooping
+{
+    int intervalMsec;
+    int count;
+};
+
+struct FxIntRange
+{
+    int base;
+    int amplitude;
+};
+
+struct FxSpawnDefOneShot
+{
+    FxIntRange count;
+};
+
+union FxSpawnDef
+{
+    FxSpawnDefLooping looping;
+    FxSpawnDefOneShot oneShot;
+};
+
+struct FxFloatRange
+{
+    float base;
+    float amplitude;
+};
+
+struct FxElemAtlas
+{
+    unsigned __int8 behavior;
+    unsigned __int8 index;
+    unsigned __int8 fps;
+    unsigned __int8 loopCount;
+    unsigned __int8 colIndexBits;
+    unsigned __int8 rowIndexBits;
+    __int16 entryCount;
+};
+
+struct FxElemVec3Range
+{
+    float base[3];
+    float amplitude[3];
+};
+
+struct FxElemVelStateInFrame
+{
+    FxElemVec3Range velocity;
+    FxElemVec3Range totalDelta;
+};
+
+struct FxElemVelStateSample
+{
+    FxElemVelStateInFrame local;
+    FxElemVelStateInFrame world;
+};
+
+struct FxElemVisualState
+{
+    unsigned __int8 color[4];
+    float rotationDelta;
+    float rotationTotal;
+    float size[2];
+    float scale;
+};
+
+struct FxElemVisStateSample
+{
+    FxElemVisualState base;
+    FxElemVisualState amplitude;
+};
+
+struct FxElemMarkVisuals
+{
+    qint32 materialPtrs[2];
+    QVector<Material> materials;
+};
+
+struct EffectDef;
+union EffectDefRef
+{
+    qint32 handlePtr;
+    const EffectDef *handle;
+
+    qint32 namePtr;
+    const char *name;
+};
+
+union FxElemVisuals
+{
+    qint32 anonymousPtr;
+    const void *anonymous;
+
+    qint32 materialPtr;
+    Material *material;
+
+    qint32 modelPtr;
+    Model *model;
+
+    EffectDefRef effectDef;
+
+    qint32 soundNamePtr;
+    const char *soundName;
+};
+
+struct FxElemDefVisuals
+{
+    qint32 markArrayPtr;
+    QVector<FxElemMarkVisuals> markArray;
+
+    qint32 arrayPtr;
+    QVector<FxElemVisuals> array;
+
+    FxElemVisuals instance;
+};
+
+struct FxTrailVertex
+{
+    float pos[2];
+    float normal[2];
+    float texCoord;
+};
+
+struct FxTrailDef
+{
+    int scrollTimeMsec;
+    int repeatDist;
+    int splitDist;
+    int vertCount;
+    FxTrailVertex *verts;
+    int indCount;
+    unsigned __int16 *inds;
+};
+
+struct FxElemDef
+{
+    int flags;
+    FxSpawnDef spawn;
+    FxFloatRange spawnRange;
+    FxFloatRange fadeInRange;
+    FxFloatRange fadeOutRange;
+    float spawnFrustumCullRadius;
+    FxIntRange spawnDelayMsec;
+    FxIntRange lifeSpanMsec;
+    FxFloatRange spawnOrigin[3];
+    FxFloatRange spawnOffsetRadius;
+    FxFloatRange spawnOffsetHeight;
+    FxFloatRange spawnAngles[3];
+    FxFloatRange angularVelocity[3];
+    FxFloatRange initialRotation;
+    FxFloatRange gravity;
+    FxFloatRange reflectionFactor;
+    FxElemAtlas atlas;
+    unsigned __int8 elemType;
+    unsigned __int8 visualCount;
+    unsigned __int8 velIntervalCount;
+    unsigned __int8 visStateIntervalCount;
+    qint32 velSamplesPtr;
+    QVector<FxElemVelStateSample> velSamples;
+    qint32 visSamplesPtr;
+    QVector<FxElemVisStateSample> visSamples;
+    FxElemDefVisuals visuals;
+    float collMins[3];
+    float collMaxs[3];
+    EffectDefRef effectOnImpact;
+    EffectDefRef effectOnDeath;
+    EffectDefRef effectEmitted;
+    FxFloatRange emitDist;
+    FxFloatRange emitDistVariance;
+
+    qint32 trailDefPtr;
+    FxTrailDef *trailDef;
+
+    unsigned __int8 sortOrder;
+    unsigned __int8 lightingFrac;
+    unsigned __int8 useItemClip;
+    unsigned __int8 unused[1];
+};
+
+struct EffectDef
+{
+    qint32 namePtr;
+    QString name;
+
+    int flags;
+    int totalSize;
+    int msecLoopingLife;
+    int elemDefCountLooping;
+    int elemDefCountOneShot;
+    int elemDefCountEmission;
+
+    qint32 elemDefsPtr;
+    QVector<FxElemDef> elemDefs;
+};
+
+#endif // EFFECTDEF_H

libs/xassets/effecttable.cpp

@@ -0,0 +1 @@
+#include "effecttable.h"

libs/xassets/effecttable.h

@@ -0,0 +1,24 @@
+#ifndef EFFECTTABLE_H
+#define EFFECTTABLE_H
+
+#include "effectdef.h"
+
+struct FxImpactEntry
+{
+    QVector<qint32> nonFleshPtrs;
+    QVector<EffectDef> nonFlesh;
+
+    QVector<qint32> fleshPtrs;
+    QVector<EffectDef> flesh;
+};
+
+struct ImpactTable
+{
+    qint32 namePtr;
+    QString name;
+
+    qint32 tablePtr;
+    QVector<FxImpactEntry> table;
+};
+
+#endif // EFFECTTABLE_H

libs/xassets/file.cpp

@@ -0,0 +1 @@
+#include "file.h"

libs/xassets/file.h

@@ -0,0 +1,13 @@
+#ifndef FILE_H
+#define FILE_H
+
+#include <QtTypes>
+
+struct XFile
+{
+    quint32 size;
+    quint32 externalSize;
+    quint32 blockSize[7];
+};
+
+#endif // FILE_H

libs/xassets/gfxworld.h

@@ -5,12 +5,81 @@
 #include "gfxlightdef.h"
 #include "xmodel.h"
 
+struct GfxStreamingAabbTree
+{
+    unsigned __int16 firstItem;
+    unsigned __int16 itemCount;
+    unsigned __int16 firstChild;
+    unsigned __int16 childCount;
+    float mins[3];
+    float maxs[3];
+};
+
+struct GfxWorldStreamInfo
+{
+    int aabbTreeCount;
+    GfxStreamingAabbTree *aabbTrees;
+    int leafRefCount;
+    int *leafRefs;
+};
+
+struct GfxWorldVertex
+{
+    float xyz[3];
+    float binormalSign;
+    GfxColor color;
+    float texCoord[2];
+    float lmapCoord[2];
+    PackedUnitVec normal;
+    PackedUnitVec tangent;
+};
+
+struct GfxWorldVertexData
+{
+    GfxWorldVertex *vertices;
+    D3DVertexBuffer worldVb;
+};
+
 struct GfxWorldVertexLayerData
 {
     unsigned __int8 *data;
     D3DVertexBuffer layerVb;
 };
 
+struct SunLightParseParams
+{
+    char name[64];
+    float ambientScale;
+    float ambientColor[3];
+    float diffuseFraction;
+    float sunLight;
+    float sunColor[3];
+    float diffuseColor[3];
+    bool diffuseColorHasBeenSet;
+    float angles[3];
+};
+
+struct GfxLight
+{
+    unsigned __int8 type;
+    unsigned __int8 canUseShadowMap;
+    unsigned __int8 unused[2];
+    float color[3];
+    float dir[3];
+    float origin[3];
+    float radius;
+    float cosHalfFovOuter;
+    float cosHalfFovInner;
+    int exponent;
+    unsigned int spotShadowIndex;
+    XGfxLightDef *def;
+};
+
+struct GfxReflectionProbe
+{
+    float origin[3];
+    GfxImage *reflectionImage;
+};
 
 struct GfxWorldDpvsPlanes
 {

libs/xassets/material.cpp

@@ -0,0 +1 @@
+#include "material.h"

libs/xassets/material.h

@@ -0,0 +1,283 @@
+#ifndef MATERIAL_H
+#define MATERIAL_H
+
+#include "materialtechset.h"
+
+struct GfxDrawSurfFields
+{
+    quint64 objectId : 16;
+    quint64 reflectionProbeIndex : 8;
+    quint64 customIndex : 5;
+    quint64 materialSortedIndex : 11;
+    quint64 prepass : 2;
+    quint64 primaryLightIndex : 8;
+    quint64 surfType : 4;
+    quint64 primarySortKey : 6;
+    quint64 unused : 4;
+};
+
+struct MaterialInfo
+{
+    qint32 namePtr;
+    QString name;
+
+    quint8 gameFlags;
+    quint8 sortKey;
+    quint8 textureAtlasRowCount;
+    quint8 textureAtlasColumnCount;
+    GfxDrawSurfFields drawSurf;
+    unsigned int surfaceTypeBits;
+};
+
+enum MapType : qint32
+{
+    MAPTYPE_NONE = 0x0,
+    MAPTYPE_INVALID1 = 0x1,
+    MAPTYPE_INVALID2 = 0x2,
+    MAPTYPE_2D = 0x3,
+    MAPTYPE_3D = 0x4,
+    MAPTYPE_CUBE = 0x5,
+    MAPTYPE_COUNT = 0x6,
+};
+
+struct GPUTEXTURESIZE_1D
+{
+    quint32 Width : 24;
+};
+
+struct GPUTEXTURESIZE_2D
+{
+    quint32 Width : 13;
+    quint32 Height : 13;
+};
+
+struct GPUTEXTURESIZE_3D
+{
+    quint32 Width : 11;
+    quint32 Height : 11;
+    quint32 Depth : 10;
+};
+
+struct GPUTEXTURESIZE_STACK
+{
+    quint32 Width : 13;
+    quint32 Height : 13;
+    quint32 Depth : 6;
+};
+
+struct GPUTEXTURE_FETCH_CONSTANT
+{
+    quint32 Type : 2;
+    quint32 SignX : 2;
+    quint32 SignY : 2;
+    quint32 SignZ : 2;
+    quint32 SignW : 2;
+    quint32 ClampX : 3;
+    quint32 ClampY : 3;
+    quint32 ClampZ : 3;
+    quint32 : 3;
+    quint32 Pitch : 9;
+    quint32 Tiled : 1;
+
+    quint32 DataFormat : 6;
+    quint32 Endian : 2;
+    quint32 RequestSize : 2;
+    quint32 Stacked : 1;
+    quint32 ClampPolicy : 1;
+    quint32 BaseAddress : 20;
+    union
+    {
+        GPUTEXTURESIZE_1D OneD;
+        GPUTEXTURESIZE_2D TwoD;
+        GPUTEXTURESIZE_3D ThreeD;
+        GPUTEXTURESIZE_STACK Stack;
+    } Size;
+
+    quint32 NumFormat : 1;
+    quint32 SwizzleX : 3;
+    quint32 SwizzleY : 3;
+    quint32 SwizzleZ : 3;
+    quint32 SwizzleW : 3;
+    qint32 ExpAdjust : 6;
+    quint32 MagFilter : 2;
+    quint32 MinFilter : 2;
+    quint32 MipFilter : 2;
+    quint32 AnisoFilter : 3;
+    quint32 : 3;
+    quint32 BorderSize : 1;
+
+    quint32 VolMagFilter : 1;
+    quint32 VolMinFilter : 1;
+    quint32 MinMipLevel : 4;
+    quint32 MaxMipLevel : 4;
+    quint32 MagAnisoWalk : 1;
+    quint32 MinAnisoWalk : 1;
+    qint32 LODBias : 10;
+    qint32 GradExpAdjustH : 5;
+    qint32 GradExpAdjustV : 5;
+
+    quint32 BorderColor : 2;
+    quint32 ForceBCWToMax : 1;
+    quint32 TriClamp : 2;
+    qint32 AnisoBias : 4;
+    quint32 Dimension : 2;
+    quint32 PackedMips : 1;
+    quint32 MipAddress : 20;
+};
+
+// QDataStream &operator>>(QDataStream &in, GPUTEXTURE_FETCH_CONSTANT &s)
+// {
+//     quint32 raw1, raw2, raw3, raw4, raw5;
+//     in >> raw1 >> raw2 >> raw3 >> raw4 >> raw5;
+
+//     s.Type          =  raw1             & 0b000000000000000000000011;
+//     s.SignX         = (raw1 >> 2)       & 0b000000000000000000000011;
+//     s.SignY         = (raw1 >> 4)       & 0b000000000000000000000011;
+//     s.SignZ         = (raw1 >> 6)       & 0b000000000000000000000011;
+//     s.SignW         = (raw1 >> 8)       & 0b000000000000000000000011;
+//     s.ClampX        = (raw1 >> 10)      & 0b000000000000000000000111;
+//     s.ClampY        = (raw1 >> 13)      & 0b000000000000000000000111;
+//     s.ClampZ        = (raw1 >> 16)      & 0b000000000000000000000111;
+//     s.Pitch         = (raw1 >> 22)      & 0b000000000000000111111111;
+//     s.Tiled         = (raw1 >> 31)      & 0b000000000000000000000001;
+
+//     s.DataFormat    = raw2              & 0b000000000000000000111111;
+//     s.Endian        = (raw2 >> 6)       & 0b000000000000000000000011;
+//     s.RequestSize   = (raw2 >> 8)       & 0b000000000000000000000011;
+//     s.Stacked       = (raw2 >> 10)      & 0b000000000000000000000001;
+//     s.ClampPolicy   = (raw2 >> 11)      & 0b000000000000000000000001;
+//     s.BaseAddress   = (raw2 >> 12)      & 0b000011111111111111111111;
+//     s.Size          = (raw2 >> 32)      & 0b000000000000000000001111;
+
+//     s.NumFormat     = raw3              & 0b000000000000000000000001;
+//     s.SwizzleX      = (raw3 >> 32)      & 0b000000000000000000000111;
+//     s.SwizzleY      = (raw3 >> 32)      & 0b000000000000000000000111;
+//     s.SwizzleZ      = (raw3 >> 32)      & 0b000000000000000000000111;
+//     s.SwizzleW      = (raw3 >> 32)      & 0b000000000000000000000111;
+//     s.ExpAdjust     = (raw3 >> 32)      & 0b000000000000000000111111;
+//     s.MagFilter     = (raw3 >> 32)      & 0b000000000000000000001111;
+//     s.MinFilter     = (raw3 >> 32)      & 0b000000000000000000001111;
+//     s.MipFilter     = (raw3 >> 32)      & 0b000000000000000000001111;
+//     s.AnisoFilter   = (raw3 >> 32)      & 0b000000000000000000001111;
+//     s.: 3;
+//     s.BorderSize =
+//     s.VolMagFilter =
+//     s.VolMinFilter =
+//     s.MinMipLevel =
+//     s.MaxMipLevel =
+//     s.MagAnisoWalk =
+//     s.MinAnisoWalk =
+//     s.LODBias =
+//     s.GradExpAdjustH =
+//     s.GradExpAdjustV =
+//     s.BorderColor =
+//     s.ForceBCWToMax =
+//     s.TriClamp =
+//     s.AnisoBias =
+//     s.Dimension =
+//     s.PackedMips =
+//     s.MipAddress =
+
+
+
+
+
+
+//     return in;
+// }
+
+struct D3DBaseTexture : D3DResource
+{
+    unsigned int MipFlush;
+    GPUTEXTURE_FETCH_CONSTANT Format;
+};
+
+struct D3DTexture : D3DBaseTexture
+{
+};
+
+struct D3DVolumeTexture : D3DBaseTexture
+{
+};
+
+struct D3DCubeTexture : D3DBaseTexture
+{
+};
+
+struct WaterWritable
+{
+    float floatTime;
+};
+
+struct GfxImage;
+struct water_t
+{
+    WaterWritable writable;
+    float *H0X;
+    float *H0Y;
+    float *wTerm;
+    int M;
+    int N;
+    float Lx;
+    float Lz;
+    float gravity;
+    float windvel;
+    float winddir[2];
+    float amplitude;
+    float codeConstant[4];
+    GfxImage *image;
+};
+
+union MaterialTextureDefInfo
+{
+    GfxImage *image;
+    water_t *water;
+};
+
+struct MaterialTextureDef
+{
+    unsigned int nameHash;
+    char nameStart;
+    char nameEnd;
+    quint8 samplerState;
+    quint8 semantic;
+    MaterialTextureDefInfo u;
+};
+
+struct MaterialConstantDef
+{
+    unsigned int nameHash;
+    char name[12];
+    float literal[4];
+};
+
+struct GfxStateBits
+{
+    unsigned int loadBits[2];
+};
+
+struct Material
+{
+    MaterialInfo info;
+
+    quint8 stateBitsEntry[26];
+    quint8 textureCount;
+    quint8 constantCount;
+    quint8 stateBitsCount;
+    quint8 stateFlags;
+    quint8 cameraRegion;
+
+    qint32 techSetPtr;
+    MaterialTechSet *techniqueSet;
+
+    qint32 textureTablePtr;
+    MaterialTextureDef *textureTable;
+
+    qint32 constantTablePtr;
+    MaterialConstantDef *constantTable;
+
+    qint32 stateBitsTablePtr;
+    GfxStateBits *stateBitsTable;
+};
+
+#endif // MATERIAL_H

libs/xassets/materialpixelshader.cpp

@@ -0,0 +1 @@
+#include "materialpixelshader.h"

libs/xassets/materialpixelshader.h

@@ -0,0 +1,34 @@
+#ifndef MATERIAL_PIXERHSHADER_H
+#define MATERIAL_PIXERHSHADER_H
+
+#include "xd3dresource.h"
+#include <QVector>
+#include <QtTypes>
+
+struct GfxPixelShaderLoadDef
+{
+    quint16 cachedPartPtr;
+    QVector<quint8> cachedPart;
+    quint16 physicalPartPtr;
+    QVector<quint8> physicalPart;
+    quint16 cachedPartSize;
+    quint16 physicalPartSize;
+};
+
+struct D3DPixelShader : D3DResource
+{
+};
+
+union Material_PixelShaderProgram
+{
+    D3DPixelShader *ps;
+    GfxPixelShaderLoadDef loadDef;
+};
+
+struct MaterialPixelShader
+{
+    const char *name;
+    Material_PixelShaderProgram prog;
+};
+
+#endif // MATERIAL_PIXERHSHADER_H

libs/xassets/materialtechset.h

@@ -1,29 +1,115 @@
 #ifndef MATERIALTECHSET_H
 #define MATERIALTECHSET_H
 
-#include "xasset.h"
+#include "xd3dresource.h"
+#include "materialpixelshader.h"
 
-#include <QVector>
+#include "QString"
+#include "qobject.h"
 
-class XMaterialTechnique;
+struct MaterialStreamRouting
-
-class XMaterialTechSet : public XAsset
 {
-public:
+    quint8 source;
-    explicit XMaterialTechSet();
+    quint8 dest;
+};
 
-    virtual void ParseData(QDataStream* aStream) override;
+struct D3DVertexDeclaration : D3DResource
-    virtual void Clear() override;
+{
+};
 
-private:
+struct MaterialVertexStreamRouting
-    QString mName;
+{
-    int mWorldVertFormat;
+    MaterialStreamRouting data[16];
+    D3DVertexDeclaration decl[15];
+};
 
-    qint32 mRemappedPtr;
+struct MaterialVertexDeclaration
-    XMaterialTechSet* mRemappedTechniqueSet;
+{
+    int streamCount;
+    bool hasOptionalSource;
+    MaterialVertexStreamRouting routing;
+};
 
-    QVector<qint32> mTechPtrs;
+struct D3DVertexShader : D3DResource
-    QVector<XMaterialTechnique*> mTechniques;
+{
+};
+
+struct GfxVertexShaderLoadDef
+{
+    qint32 cachedPartPtr;
+    QVector<int> cachedPart;
+    qint32 physicalPartPtr;
+    QVector<int> physicalPart;
+    int cachedPartSize;
+    int physicalPartSize;
+};
+
+struct MaterialVertexShaderProgram
+{
+    std::shared_ptr<D3DVertexShader> vertexShader;
+    GfxVertexShaderLoadDef loadDef;
+};
+
+struct MaterialVertexShader
+{
+    QString name;
+    MaterialVertexShaderProgram prog;
+};
+
+struct MaterialArgumentCodeConst
+{
+    int index;
+    int firstRow;
+    int rowCount;
+};
+
+struct MaterialArgumentDef
+{
+    const float *literalConst;
+    MaterialArgumentCodeConst codeConst;
+    unsigned int codeSampler;
+    unsigned int nameHash;
+};
+
+struct MaterialShaderArgument
+{
+    int type;
+    int dest;
+    MaterialArgumentDef u;
+};
+
+struct MaterialPass
+{
+    std::shared_ptr<MaterialVertexDeclaration> vertexDecl;
+    QVector<std::shared_ptr<MaterialVertexShader>> vertexShaderArray;
+    std::shared_ptr<MaterialVertexShader> vertexShader;
+    std::shared_ptr<MaterialPixelShader> pixelShader;
+    int perPrimArgCount;
+    int perObjArgCount;
+    int stableArgCount;
+    int customSamplerFlags;
+    int precompiledIndex;
+    std::shared_ptr<MaterialShaderArgument> args;
+};
+
+struct MaterialTechnique
+{
+    QString *name;
+    int flags;
+    int passCount;
+    QVector<std::shared_ptr<MaterialPass>> passArray;
+};
+
+struct MaterialTechSet
+{
+    QString name;
+    int worldVertFormat;
+
+    qint32 remappedPtr;
+    std::shared_ptr<MaterialTechSet> remappedTechniqueSet;
+
+    QVector<qint32> techPtrs;
+    QVector<std::shared_ptr<MaterialTechnique>> techniques;
 };
 
 #endif // MATERIALTECHSET_H

libs/xassets/scriptstringlist.cpp

@@ -0,0 +1 @@
+#include "scriptstringlist.h"

libs/xassets/scriptstringlist.h

@@ -0,0 +1,13 @@
+#ifndef SCRIPTSTRINGLIST_H
+#define SCRIPTSTRINGLIST_H
+
+#include <QStringList>
+
+struct ScriptStringList
+{
+    int count;
+    QVector<qint32> stringPtrs;
+    QStringList scriptStrings;
+};
+
+#endif // SCRIPTSTRINGLIST_H

libs/xassets/xanimdeltapart.cpp

@@ -1,3 +1,9 @@
+
+
+
+
+
+
 #include "xanimdeltapart.h"
 
 XAnimDeltaPart::XAnimDeltaPart()

libs/xassets/xanimdeltapart.h

@@ -1,3 +1,9 @@
+
+
+
+
+
+
 #ifndef XANIMDELTAPART_H
 #define XANIMDELTAPART_H
 

libs/xassets/xanimdeltapartquatdataframes.cpp

@@ -1,9 +1,25 @@
+
+
+
+
+
+
 #include "xanimdeltapartquatdataframes.h"
 
 XAnimDeltaPartQuatDataFrames::XAnimDeltaPartQuatDataFrames()
     : XAsset() {
 }
 
+void XAnimDeltaPartQuatDataFrames::ParseData(QDataStream *aStream) {
+    if (GetPtr() == -1) {
+        aStream->read((char*)&mFramesPtr, sizeof(quint32));
+        aStream->read((char*)mFrames, 2 * sizeof(qint16));
+
+        // Parse indices
+        mIndices.ParseData(aStream);
+    }
+}
+
 quint32 XAnimDeltaPartQuatDataFrames::GetFramesPtr() const {
     return mFramesPtr;
 }
@@ -34,17 +50,6 @@ void XAnimDeltaPartQuatDataFrames::SetIndices(const XAnimDynamicIndices& indices
     mIndices = indices;
 }
 
-void XAnimDeltaPartQuatDataFrames::ParseData(QDataStream *aStream) {
-    if (GetPtr() == -1) {
-        aStream->read((char*)&mFramesPtr, sizeof(quint32));
-        aStream->read((char*)mFrames, 2 * sizeof(qint16));
 
-        // Parse indices
-        mIndices.ParseData(aStream);
-    }
-}
 
-void XAnimDeltaPartQuatDataFrames::Clear()
-{
 
-}

libs/xassets/xanimdeltapartquatdataframes.h

@@ -1,3 +1,9 @@
+
+
+
+
+
+
 #ifndef XANIMDELTAPARTQUATDATAFRAMES_H
 #define XANIMDELTAPARTQUATDATAFRAMES_H
 
@@ -9,6 +15,8 @@ class XAnimDeltaPartQuatDataFrames : public XAsset
 public:
     explicit XAnimDeltaPartQuatDataFrames();
 
+    void ParseData(QDataStream *aStream) override;
+
     quint32 GetFramesPtr() const;
     void SetFramesPtr(quint32 ptr);
 
@@ -19,9 +27,6 @@ public:
     const XAnimDynamicIndices& GetIndices() const;
     void SetIndices(const XAnimDynamicIndices& indices);
 
-    void ParseData(QDataStream *aStream) override;
-    void Clear() override;
-
 private:
     quint32 mFramesPtr = 0;
     qint16 mFrames[2] = {0};
@@ -29,3 +34,8 @@ private:
 };
 
 #endif // XANIMDELTAPARTQUATDATAFRAMES_H
+
+
+
+
+

libs/xassets/xanimparts.cpp

@@ -1,3 +1,5 @@
+
+
 #include "xanimparts.h"
 
 XAnimParts::XAnimParts()

libs/xassets/xanimparts.h

@@ -1,3 +1,12 @@
+
+
+
+
+
+
+
+
+
 #ifndef XANIMPARTS_H
 #define XANIMPARTS_H
 

libs/xassets/xanimparttrans.h

@@ -1,3 +1,9 @@
+
+
+
+
+
+
 #ifndef XANIMPARTTRANS_H
 #define XANIMPARTTRANS_H
 
@@ -8,7 +14,6 @@ class XAnimPartTrans : public XAsset
 {
 public:
     explicit XAnimPartTrans();
-    ~XAnimPartTrans();
 
     void ParseData(QDataStream *aStream) override;
 

libs/xassets/xanimparttransdata.h

@@ -1,3 +1,8 @@
+
+
+
+
+
 #ifndef XANIMPARTTRANSDATA_H
 #define XANIMPARTTRANSDATA_H
 
@@ -8,7 +13,6 @@ class XAnimPartTransData : public XAsset
 {
 public:
     explicit XAnimPartTransData();
-    ~XAnimPartTransData();
 
     void ParseData(QDataStream *aStream) override;
 

libs/xassets/xasset.h

@@ -1,10 +1,11 @@
 #ifndef XASSET_H
 #define XASSET_H
 
-#include <QDataStream>
+#include <QObject>
 
 class XAsset
 {
+
 public:
     XAsset();
     virtual ~XAsset();

libs/xassets/xassetlist.cpp

@@ -1,37 +1,32 @@
+
+
+
 #include "xassetlist.h"
 
 XAssetList::XAssetList()
-    : XAsset()
+    : XAsset() {
-    , mStringList()
-    , mAssetCount(0)
-    , mAssets()
-{
 }
 
 void XAssetList::ParseData(QDataStream *aStream) {
     if (GetPtr() == -1) {
         // Parse string list
-        mStringList.ParsePtr(aStream);
-
-        // Parse asset count and assets
-        *aStream >> mAssetCount;
-        aStream->skipRawData(2 * 4);
-
         mStringList.ParseData(aStream);
 
-        for (int i = 0; i < mAssetCount; i++) {
+        // Parse asset count and assets
-            //XAsset asset;
+        aStream->read((char*)&mAssetCount, sizeof(int));
-            //asset.ParseData(aStream);
+        for (int i = 0; i < mAssetCount; ++i) {
-            //mAssets.append(asset);
+            XAsset asset;
+            asset.ParseData(aStream);
+            mAssets.append(asset);
         }
     }
 }
 
-XScriptStringList XAssetList::GetStringList() const {
+const ScriptStringList& XAssetList::GetStringList() const {
     return mStringList;
 }
 
-void XAssetList::SetStringList(const XScriptStringList& stringList) {
+void XAssetList::SetStringList(const ScriptStringList& stringList) {
     mStringList = stringList;
 }
 
@@ -43,11 +38,15 @@ void XAssetList::SetAssetCount(int count) {
     mAssetCount = count;
 }
 
-QVector<XAsset*> XAssetList::GetAssets() {
+QVector<XAsset>& XAssetList::GetAssets() {
     return mAssets;
 }
 
-void XAssetList::SetAssets(QVector<XAsset *> assets) {
+const QVector<XAsset>& XAssetList::GetAssets() const {
+    return mAssets;
+}
+
+void XAssetList::SetAssets(const QVector<XAsset>& assets) {
     mAssets = assets;
 }
 

libs/xassets/xassetlist.h

@@ -1,10 +1,11 @@
+
+
 #ifndef XASSETLIST_H
 #define XASSETLIST_H
 
-#include "xscriptstringlist.h"
 #include "xasset.h"
-
 #include <QVector>
+#include "scriptstringlist.h"
 
 class XAssetList : public XAsset
 {
@@ -13,19 +14,20 @@ public:
 
     void ParseData(QDataStream *aStream) override;
 
-    XScriptStringList GetStringList() const;
+    const ScriptStringList& GetStringList() const;
-    void SetStringList(const XScriptStringList& stringList);
+    void SetStringList(const ScriptStringList& stringList);
 
     int GetAssetCount() const;
     void SetAssetCount(int count);
 
-    QVector<XAsset*> GetAssets();
+    QVector<XAsset>& GetAssets();
-    void SetAssets(QVector<XAsset *> assets);
+    const QVector<XAsset>& GetAssets() const;
+    void SetAssets(const QVector<XAsset>& assets);
 
 private:
-    XScriptStringList mStringList;
+    ScriptStringList mStringList;
     int mAssetCount = 0;
-    QVector<XAsset*> mAssets;
+    QVector<XAsset> mAssets;
 };
 
 #endif // XASSETLIST_H

libs/xassets/xboneinfo.cpp

@@ -1,27 +0,0 @@
-#include "xboneinfo.h"
-
-XBoneInfo::XBoneInfo()
-    : XAsset()
-    , mBounds()
-    , mOffset()
-    , mRadiusSquared(0)
-{
-    
-}
-
-XBoneInfo::~XBoneInfo()
-{
-    
-}
-
-void XBoneInfo::ParseData(QDataStream *aStream)
-{
-    
-}
-
-void XBoneInfo::Clear()
-{
-    mBounds = QVector<QVector3D>();
-    mOffset = QVector3D();
-    mRadiusSquared = 0;
-}

libs/xassets/xboneinfo.h

@@ -1,24 +0,0 @@
-#ifndef XBONEINFO_H
-#define XBONEINFO_H
-
-#include "xasset.h"
-
-#include <QVector>
-#include <QVector3D>
-
-class XBoneInfo : public XAsset
-{
-public:
-    XBoneInfo();
-    ~XBoneInfo();
-
-    virtual void ParseData(QDataStream* aStream) override;
-    virtual void Clear() override;
-
-private:
-    QVector<QVector3D> mBounds;
-    QVector3D mOffset;
-    float mRadiusSquared;
-};
-
-#endif // XBONEINFO_H

libs/xassets/xbrushwrapper.cpp

@@ -1,43 +0,0 @@
-#include "xbrushwrapper.h"
-
-XBrushWrapper::XBrushWrapper()
-    : XAsset()
-    , mMins()
-    , mContents(0)
-    , mMaxs()
-    , mNumSides(0)
-    , mSides()
-    , mAxialMaterialNum()
-    , mBaseAdjacentSide(nullptr)
-    , mFirstAdjacentSideOffsets()
-    , mEdgeCount()
-    , mTotalEdgeCount(0)
-    , mPlanes(nullptr)
-{
-    
-}
-
-XBrushWrapper::~XBrushWrapper()
-{
-    
-}
-
-void XBrushWrapper::ParseData(QDataStream *aStream)
-{
-    
-}
-
-void XBrushWrapper::Clear()
-{
-    mMins = QVector3D();
-    mContents = 0;
-    mMaxs = QVector3D();
-    mNumSides = 0;
-    mSides.clear();
-    mAxialMaterialNum.clear();
-    mBaseAdjacentSide = nullptr;
-    mFirstAdjacentSideOffsets.clear();
-    mEdgeCount.clear();
-    mTotalEdgeCount = 0;
-    mPlanes->Clear();
-}

libs/xassets/xbrushwrapper.h

@@ -1,32 +0,0 @@
-#ifndef XBRUSHWRAPPER_H
-#define XBRUSHWRAPPER_H
-
-#include "xasset.h"
-#include "xcbrushside.h"
-
-#include <QVector3D>
-
-class XBrushWrapper : public XAsset
-{
-public:
-    XBrushWrapper();
-    ~XBrushWrapper();
-
-    virtual void ParseData(QDataStream* aStream) override;
-    virtual void Clear() override;
-
-private:
-    QVector3D mMins;
-    int mContents;
-    QVector3D mMaxs;
-    unsigned int mNumSides;
-    QVector<XCBrushSide> mSides;
-    QVector<QVector3D> mAxialMaterialNum;
-    quint8 *mBaseAdjacentSide;
-    QVector<QVector3D> mFirstAdjacentSideOffsets;
-    QVector<QVector3D> mEdgeCount;
-    int mTotalEdgeCount;
-    XCPlane *mPlanes;
-};
-
-#endif // XBRUSHWRAPPER_H

libs/xassets/xcbrushside.cpp

@@ -1,31 +0,0 @@
-#include "xcbrushside.h"
-
-XCBrushSide::XCBrushSide()
-    : XAsset()
-    , mPlanePtr(0)
-    , mPlane()
-    , mMaterialNum(0)
-    , mFirstAdjacentSideOffset(0)
-    , mEdgeCount(0)
-{
-    
-}
-
-XCBrushSide::~XCBrushSide()
-{
-    
-}
-
-void XCBrushSide::ParseData(QDataStream *aStream)
-{
-    
-}
-
-void XCBrushSide::Clear()
-{
-    mPlanePtr = 0;
-    mPlane = XCPlane();
-    mMaterialNum = 0;
-    mFirstAdjacentSideOffset = 0;
-    mEdgeCount = 0;
-}

libs/xassets/xcbrushside.h

@@ -1,24 +0,0 @@
-#ifndef XCBRUSHSIDE_H
-#define XCBRUSHSIDE_H
-
-#include "xasset.h"
-#include "xcplane.h"
-
-class XCBrushSide : public XAsset
-{
-public:
-    XCBrushSide();
-    ~XCBrushSide();
-
-    virtual void ParseData(QDataStream* aStream) override;
-    virtual void Clear() override;
-
-private:
-    qint32 mPlanePtr;
-    XCPlane mPlane;
-    uint mMaterialNum;
-    qint16 mFirstAdjacentSideOffset;
-    quint8 mEdgeCount;
-};
-
-#endif // XCBRUSHSIDE_H

libs/xassets/xcleaf.cpp

@@ -1,33 +1,25 @@
+
+
+
+
+
+
 #include "xcleaf.h"
 
 XCLeaf::XCLeaf()
-    : XAsset()
+    : XAsset() {
-    , mFirstCollAabbIndex(0)
-    , mCollAabbCount(0)
-    , mBrushContents(0)
-    , mTerrainContents(0)
-    , mMins({0.0f, 0.0f, 0.0f})
-    , mMaxs({0.0f, 0.0f, 0.0f})
-    , mLeafBrushNode(0)
-    , mCluster(0)
-{
 }
 
 void XCLeaf::ParseData(QDataStream *aStream) {
     if (GetPtr() == -1) {
-        *aStream
+        aStream->read((char*)&mFirstCollAabbIndex, sizeof(quint16));
-            >> mFirstCollAabbIndex
+        aStream->read((char*)&mCollAabbCount, sizeof(quint16));
-            >> mCollAabbCount
+        aStream->read((char*)&mBrushContents, sizeof(int));
-            >> mBrushContents
+        aStream->read((char*)&mTerrainContents, sizeof(int));
-            >> mTerrainContents
+        aStream->read((char*)mMins, 3 * sizeof(float));
-            >> mMins[0]
+        aStream->read((char*)mMaxs, 3 * sizeof(float));
-            >> mMins[1]
+        aStream->read((char*)&mLeafBrushNode, sizeof(int));
-            >> mMins[2]
+        aStream->read((char*)&mCluster, sizeof(qint16));
-            >> mMaxs[0]
-            >> mMaxs[1]
-            >> mMaxs[2]
-            >> mLeafBrushNode
-            >> mCluster;
     }
 }
 
@@ -63,20 +55,24 @@ void XCLeaf::SetTerrainContents(int contents) {
     mTerrainContents = contents;
 }
 
-QVector<float> XCLeaf::GetMins() const {
+const float* XCLeaf::GetMins() const {
     return mMins;
 }
 
-void XCLeaf::SetMins(QVector<float> aMins) {
+void XCLeaf::SetMins(const float* mins, size_t count) {
-    mMins = aMins;
+    if (count <= 3) {
+        memcpy(mMins, mins, count * sizeof(float));
+    }
 }
 
-QVector<float> XCLeaf::GetMaxs() const {
+const float* XCLeaf::GetMaxs() const {
     return mMaxs;
 }
 
-void XCLeaf::SetMaxs(QVector<float> aMaxs) {
+void XCLeaf::SetMaxs(const float* maxs, size_t count) {
-    mMaxs = aMaxs;
+    if (count <= 3) {
+        memcpy(mMaxs, maxs, count * sizeof(float));
+    }
 }
 
 int XCLeaf::GetLeafBrushNode() const {

libs/xassets/xcleaf.h

@@ -1,10 +1,14 @@
+
+
+
+
+
+
 #ifndef XCLEAF_H
 #define XCLEAF_H
 
 #include "xasset.h"
 
-#include <QVector>
-
 class XCLeaf : public XAsset
 {
 public:
@@ -24,11 +28,11 @@ public:
     int GetTerrainContents() const;
     void SetTerrainContents(int contents);
 
-    QVector<float> GetMins() const;
+    const float* GetMins() const;
-    void SetMins(QVector<float> aMins);
+    void SetMins(const float* mins, size_t count = 3);
 
-    QVector<float> GetMaxs() const;
+    const float* GetMaxs() const;
-    void SetMaxs(QVector<float> aMaxs);
+    void SetMaxs(const float* maxs, size_t count = 3);
 
     int GetLeafBrushNode() const;
     void SetLeafBrushNode(int node);
@@ -37,14 +41,19 @@ public:
     void SetCluster(qint16 cluster);
 
 private:
-    quint16 mFirstCollAabbIndex;
+    quint16 mFirstCollAabbIndex = 0;
-    quint16 mCollAabbCount;
+    quint16 mCollAabbCount = 0;
-    int mBrushContents;
+    int mBrushContents = 0;
-    int mTerrainContents;
+    int mTerrainContents = 0;
-    QVector<float> mMins;
+    float mMins[3] = {0.0f, 0.0f, 0.0f};
-    QVector<float> mMaxs;
+    float mMaxs[3] = {0.0f, 0.0f, 0.0f};
-    int mLeafBrushNode;
+    int mLeafBrushNode = 0;
-    qint16 mCluster;
+    qint16 mCluster = 0;
 };
 
 #endif // XCLEAF_H
+
+
+
+
+

libs/xassets/xcleafbrushnode.cpp

@@ -1,39 +1,22 @@
+
+
 #include "xcleafbrushnode.h"
 
 XCLeafBrushNode::XCLeafBrushNode()
-    : XAsset()
+    : XAsset() {
-    , mAxis(0)
-    , mLeafBrushCount(0)
-    , mContents(0)
-    , mData()
-{
-}
-
-XCLeafBrushNode::~XCLeafBrushNode()
-{
-
 }
 
 void XCLeafBrushNode::ParseData(QDataStream *aStream) {
     if (GetPtr() == -1) {
-        *aStream
+        aStream->read((char*)&mAxis, sizeof(quint8));
-            >> mAxis
+        aStream->read((char*)&mLeafBrushCount, sizeof(qint16));
-            >> mLeafBrushCount
+        aStream->read((char*)&mContents, sizeof(int));
-            >> mContents;
 
         // Parse data
         mData.ParseData(aStream);
     }
 }
 
-void XCLeafBrushNode::Clear()
-{
-    mAxis = 0;
-    mLeafBrushCount = 0;
-    mContents = 0;
-    mData = XCLeafBrushNodeData();
-}
-
 quint8 XCLeafBrushNode::GetAxis() const {
     return mAxis;
 }
@@ -69,3 +52,4 @@ const XCLeafBrushNodeData& XCLeafBrushNode::GetData() const {
 void XCLeafBrushNode::SetData(const XCLeafBrushNodeData& data) {
     mData = data;
 }
+

libs/xassets/xcleafbrushnode.h

@@ -1,3 +1,9 @@
+
+
+
+
+
+
 #ifndef XCLEAFBRUSHNODE_H
 #define XCLEAFBRUSHNODE_H
 
@@ -8,10 +14,8 @@ class XCLeafBrushNode : public XAsset
 {
 public:
     explicit XCLeafBrushNode();
-    ~XCLeafBrushNode();
 
     void ParseData(QDataStream *aStream) override;
-    void Clear() override;
 
     quint8 GetAxis() const;
     void SetAxis(quint8 axis);
@@ -27,10 +31,15 @@ public:
     void SetData(const XCLeafBrushNodeData& data);
 
 private:
-    quint8 mAxis;
+    quint8 mAxis = 0;
-    qint16 mLeafBrushCount;
+    qint16 mLeafBrushCount = 0;
-    int mContents;
+    int mContents = 0;
     XCLeafBrushNodeData mData;
 };
 
 #endif // XCLEAFBRUSHNODE_H
+
+
+
+
+

libs/xassets/xcleafbrushnodedata.cpp

@@ -1,15 +1,13 @@
+
+
+
+
+
+
 #include "xcleafbrushnodedata.h"
 
 XCLeafBrushNodeData::XCLeafBrushNodeData()
-    : XAsset()
+    : XAsset() {
-    , mLeaf()
-    , mChildren()
-{
-}
-
-XCLeafBrushNodeData::~XCLeafBrushNodeData()
-{
-    
 }
 
 void XCLeafBrushNodeData::ParseData(QDataStream *aStream) {
@@ -20,12 +18,6 @@ void XCLeafBrushNodeData::ParseData(QDataStream *aStream) {
     }
 }
 
-void XCLeafBrushNodeData::Clear()
-{
-    mLeaf.Clear();
-    mChildren.Clear();
-}
-
 const XCLeafBrushNodeLeaf& XCLeafBrushNodeData::GetLeaf() const {
     return mLeaf;
 }
@@ -41,3 +33,7 @@ const XCLeafBrushNodeChildren& XCLeafBrushNodeData::GetChildren() const {
 void XCLeafBrushNodeData::SetChildren(const XCLeafBrushNodeChildren& children) {
     mChildren = children;
 }
+
+
+
+

libs/xassets/xcleafbrushnodedata.h

@@ -1,3 +1,9 @@
+
+
+
+
+
+
 #ifndef XCLEAFBRUSHNODEDATA_H
 #define XCLEAFBRUSHNODEDATA_H
 
@@ -9,10 +15,8 @@ class XCLeafBrushNodeData : public XAsset
 {
 public:
     explicit XCLeafBrushNodeData();
-    virtual ~XCLeafBrushNodeData() override;
 
     void ParseData(QDataStream *aStream) override;
-    void Clear() override;
 
     // Option 1: Leaf data
     const XCLeafBrushNodeLeaf& GetLeaf() const;
@@ -23,8 +27,10 @@ public:
     void SetChildren(const XCLeafBrushNodeChildren& children);
 
 private:
-    XCLeafBrushNodeLeaf mLeaf;
+    union {
-    XCLeafBrushNodeChildren mChildren;
+        XCLeafBrushNodeLeaf mLeaf;
+        XCLeafBrushNodeChildren mChildren;
+    };
 };
 
 #endif // XCLEAFBRUSHNODEDATA_H

libs/xassets/xcplane.cpp

@@ -1,31 +0,0 @@
-#include "xcplane.h"
-
-XCPlane::XCPlane()
-    : XAsset()
-    , mNormal()
-    , mDist(0)
-    , mType(0)
-    , mSignbits(0)
-    , mPad()
-{
-    
-}
-
-XCPlane::~XCPlane()
-{
-    
-}
-
-void XCPlane::ParseData(QDataStream *aStream)
-{
-    
-}
-
-void XCPlane::Clear()
-{
-    mNormal = QVector3D();
-    mDist = 0;
-    mType = 0;
-    mSignbits = 0;
-    mPad.clear();
-}

libs/xassets/xcplane.h

@@ -1,26 +0,0 @@
-#ifndef XCPLANE_H
-#define XCPLANE_H
-
-#include "xasset.h"
-
-#include <QVector>
-#include <QVector3D>
-
-class XCPlane : public XAsset
-{
-public:
-    XCPlane();
-    ~XCPlane();
-
-    virtual void ParseData(QDataStream* aStream) override;
-    virtual void Clear() override;
-
-private:
-    QVector3D mNormal;
-    float mDist;
-    quint8 mType;
-    quint8 mSignbits;
-    QVector<quint8> mPad;
-};
-
-#endif // XCPLANE_H

libs/xassets/xd3dbasetexture.h

@@ -2,9 +2,7 @@
 #define XD3DBASETEXTURE_H
 
 #include "xasset.h"
-
+#include "xd3dresource.h"
-class XGpuTextureFetchConstant;
-class XD3DResource;
 
 class XD3DBaseTexture : public XAsset
 {

libs/xassets/xd3dcubetexture.cpp

@@ -1,7 +1,5 @@
 #include "xgfximageloaddef.h"
 
-#include "xgfxtexture.h"
-
 XGfxImageLoadDef::XGfxImageLoadDef()
     : XAsset()
     , mLevelCount(0)

libs/xassets/xd3dcubetexture.h

@@ -1,8 +1,23 @@
-#ifndef XD3DCUBETEXTURE_H
+#ifndef XGFXIMAGELOADDEF_H
-#define XD3DCUBETEXTURE_H
+#define XGFXIMAGELOADDEF_H
 
-#include "xd3dbasetexture.h"
+#include "xasset.h"
 
-typedef XD3DBaseTexture XD3DCubeTexture;
+class XGfxImageLoadDef : public XAsset
+{
+public:
+    XGfxImageLoadDef();
+    ~XGfxImageLoadDef();
 
-#endif // XD3DCUBETEXTURE_H
+    virtual void ParseData(QDataStream* aStream) override;
+    virtual void Clear() override;
+
+private:
+    quint8 mLevelCount;
+    quint8 mFlags;
+    QVector<qint16> mDimensions;
+    int mFormat;
+    XGfxTexture* mTexture;
+};
+
+#endif // XGFXIMAGELOADDEF_H

libs/xassets/xd3dindexbuffer.cpp

@@ -1,19 +0,0 @@
-#include "xd3dindexbuffer.h"
-
-XD3DIndexBuffer::XD3DIndexBuffer()
-    : XD3DResource()
-    , mAddress(0)
-    , mSize(0)
-{
-    
-}
-
-void XD3DIndexBuffer::ParseData(QDataStream *aStream)
-{
-    
-}
-
-void XD3DIndexBuffer::Clear()
-{
-    
-}

libs/xassets/xd3dindexbuffer.h

@@ -1,27 +0,0 @@
-#ifndef XD3DINDEXBUFFER_H
-#define XD3DINDEXBUFFER_H
-
-#include "xd3dresource.h"
-
-class XD3DIndexBuffer : public XD3DResource
-{
-public:
-    explicit XD3DIndexBuffer();
-
-    void ParseData(QDataStream *aStream) override;
-    void Clear() override;
-
-private:
-    quint32 mAddress;
-    quint32 mSize;
-};
-
-#endif // XD3DINDEXBUFFER_H
-
-
-
-
-
-
-
-

libs/xassets/xd3dpixelshader.h

@@ -1,9 +0,0 @@
-#ifndef XD3DPIXELSHADER_H
-#define XD3DPIXELSHADER_H
-
-#include "xd3dresource.h"
-
-typedef XD3DResource XD3DPixelShader;
-
-#endif // XD3DPIXELSHADER_H
-

libs/xassets/xd3dtexture.h

@@ -1,9 +0,0 @@
-#ifndef XD3DTEXTURE_H
-#define XD3DTEXTURE_H
-
-#include "xd3dbasetexture.h"
-
-typedef XD3DBaseTexture XD3DTexture;
-
-#endif // XD3DTEXTURE_H
-

libs/xassets/xd3dvertexbuffer.cpp

@@ -1,18 +0,0 @@
-#include "xd3dvertexbuffer.h"
-
-XD3DVertexBuffer::XD3DVertexBuffer()
-    : XD3DResource()
-    , mFormat()
-{
-    
-}
-
-void XD3DVertexBuffer::ParseData(QDataStream *aStream)
-{
-    
-}
-
-void XD3DVertexBuffer::Clear()
-{
-    
-}

libs/xassets/xd3dvertexbuffer.h

@@ -1,19 +0,0 @@
-#ifndef XD3DVERTEXBUFFER_H
-#define XD3DVERTEXBUFFER_H
-
-#include "xd3dresource.h"
-#include "xgpuvertexfetchconstant.h"
-
-class XD3DVertexBuffer : XD3DResource
-{
-public:
-    explicit XD3DVertexBuffer();
-
-    void ParseData(QDataStream *aStream) override;
-    void Clear() override;
-
-private:
-    XGpuVertexFetchConstant mFormat;
-};
-
-#endif // XD3DVERTEXBUFFER_H

libs/xassets/xd3dvertexdeclaration.h

@@ -1,9 +0,0 @@
-#ifndef XD3DVERTEXDECLARATION_H
-#define XD3DVERTEXDECLARATION_H
-
-#include "xd3dresource.h"
-
-typedef XD3DResource XD3DVertexDeclaration;
-
-#endif // XD3DVERTEXDECLARATION_H
-

libs/xassets/xd3dvertexshader.h

@@ -1,9 +0,0 @@
-#ifndef XD3DVERTEXSHADER_H
-#define XD3DVERTEXSHADER_H
-
-#include "xd3dresource.h"
-
-typedef XD3DResource XD3DVertexShader;
-
-#endif // XD3DVERTEXSHADER_H
-

libs/xassets/xd3dvolumetexture.cpp

@@ -0,0 +1,31 @@
+#include "xgfximageloaddef.h"
+
+XGfxImageLoadDef::XGfxImageLoadDef()
+    : XAsset()
+    , mLevelCount(0)
+    , mFlags(0)
+    , mDimensions(QVector<qint16>(3))
+    , mFormat(0)
+    , mTexture(new XGfxTexture())
+{
+    
+}
+
+XGfxImageLoadDef::~XGfxImageLoadDef()
+{
+    delete mTexture;
+}
+
+void XGfxImageLoadDef::ParseData(QDataStream *aStream)
+{
+    
+}
+
+void XGfxImageLoadDef::Clear()
+{
+    mLevelCount = 0;
+    mFlags = 0;
+    mDimensions = QVector<qint16>(3);
+    mFormat = 0;
+    mTexture->Clear();
+}

libs/xassets/xd3dvolumetexture.h

@@ -1,8 +1,23 @@
-#ifndef XD3DVOLUMETEXTURE_H
+#ifndef XGFXIMAGELOADDEF_H
-#define XD3DVOLUMETEXTURE_H
+#define XGFXIMAGELOADDEF_H
 
-#include "xd3dbasetexture.h"
+#include "xasset.h"
 
-typedef XD3DBaseTexture XD3DVolumeTexture;
+class XGfxImageLoadDef : public XAsset
+{
+public:
+    XGfxImageLoadDef();
+    ~XGfxImageLoadDef();
 
-#endif // XD3DVOLUMETEXTURE_H
+    virtual void ParseData(QDataStream* aStream) override;
+    virtual void Clear() override;
+
+private:
+    quint8 mLevelCount;
+    quint8 mFlags;
+    QVector<qint16> mDimensions;
+    int mFormat;
+    XGfxTexture* mTexture;
+};
+
+#endif // XGFXIMAGELOADDEF_H

libs/xassets/xdmaterial.h

@@ -1,3 +1,9 @@
+
+
+
+
+
+
 #ifndef XDMATERIAL_H
 #define XDMATERIAL_H
 

libs/xassets/xdobjanimmat.cpp

@@ -1,27 +0,0 @@
-#include "xdobjanimmat.h"
-
-XDObjAnimMat::XDObjAnimMat()
-    : XAsset()
-    , mQuat()
-    , mTrans()
-    , mTransWeight(0)
-{
-    
-}
-
-XDObjAnimMat::~XDObjAnimMat()
-{
-    
-}
-
-void XDObjAnimMat::ParseData(QDataStream *aStream)
-{
-    
-}
-
-void XDObjAnimMat::Clear()
-{
-    mQuat = QVector<float>();
-    mTrans = QVector<float>();
-    mTransWeight = 0;
-}

libs/xassets/xdobjanimmat.h

@@ -1,23 +0,0 @@
-#ifndef XDOBJANIMMAT_H
-#define XDOBJANIMMAT_H
-
-#include "xasset.h"
-
-#include <QVector>
-
-class XDObjAnimMat : public XAsset
-{
-public:
-    XDObjAnimMat();
-    ~XDObjAnimMat();
-
-    virtual void ParseData(QDataStream* aStream) override;
-    virtual void Clear() override;
-
-private:
-    QVector<float> mQuat;
-    QVector<float> mTrans;
-    float mTransWeight;
-};
-
-#endif // XDOBJANIMMAT_H

libs/xassets/xeffectdef.h

@@ -1,229 +0,0 @@
-#ifndef EFFECTDEF_H
-#define EFFECTDEF_H
-
-#include "xmaterial.h"
-#include "xmodel.h"
-
-class XFxSpawnDefLooping : public XAsset
-{
-public:
-    explicit XFxSpawnDefLooping();
-    ~XFxSpawnDefLooping();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    int mIntervalMsec;
-    int mCount;
-};
-
-class XFxIntRange : public XAsset
-{
-public:
-    explicit XFxIntRange();
-    ~XFxIntRange();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    int mBase;
-    int mAmplitude;
-};
-
-class XFxSpawnDefOneShot : public XAsset
-{
-public:
-    explicit XFxSpawnDefOneShot();
-    ~XFxSpawnDefOneShot();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    XFxIntRange mCount;
-};
-
-class XFxSpawnDef : public XAsset
-{
-public:
-    explicit XFxSpawnDef();
-    ~XFxSpawnDef();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    XFxSpawnDefLooping mLooping;
-    XFxSpawnDefOneShot omOneShot;
-};
-
-class XFxFloatRange : public XAsset
-{
-public:
-    explicit XFxFloatRange();
-    ~XFxFloatRange();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    float base;
-    float amplitude;
-};
-
-class XFxElemAtlas : public XAsset
-{
-public:
-    explicit XFxElemAtlas();
-    ~XFxElemAtlas();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    quint8 mBehavior;
-    quint8 mIndex;
-    quint8 mFps;
-    quint8 mLoopCount;
-    quint8 mColIndexBits;
-    quint8 mRowIndexBits;
-    qint16 mEntryCount;
-};
-
-class XFxElemVec3Range : public XAsset
-{
-public:
-    explicit XFxElemVec3Range();
-    ~XFxElemVec3Range();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    QVector3D mBase;
-    QVector3D mAmplitude;
-};
-
-class XFxElemVelStateInFrame : public XAsset
-{
-public:
-    explicit XFxElemVelStateInFrame();
-    ~XFxElemVelStateInFrame();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    XFxElemVec3Range mVelocity;
-    XFxElemVec3Range mTotalDelta;
-};
-
-class XFxElemVelStateSample : public XAsset
-{
-public:
-    explicit XFxElemVelStateSample();
-    ~XFxElemVelStateSample();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    XFxElemVelStateInFrame mLocal;
-    XFxElemVelStateInFrame mWorld;
-};
-
-class XFxElemVisualState : public XAsset
-{
-public:
-    explicit XFxElemVisualState();
-    ~XFxElemVisualState();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    quint8 mColor[4];
-    float mRotationDelta;
-    float mRotationTotal;
-    float mSize[2];
-    float mScale;
-};
-
-class XFxElemVisStateSample : public XAsset
-{
-public:
-    explicit XFxElemVisStateSample();
-    ~XFxElemVisStateSample();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    XFxElemVisualState mBase;
-    XFxElemVisualState mAmplitude;
-};
-
-class XFxElemMarkVisuals : public XAsset
-{
-public:
-    explicit XFxElemMarkVisuals();
-    ~XFxElemMarkVisuals();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    qint32 mMaterialPtrs[2];
-    QVector<XMaterial> mMaterials;
-};
-
-class XEffectDefRef : public XAsset
-{
-public:
-    explicit XEffectDefRef();
-    ~XEffectDefRef();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    qint32 mHandlePtr;
-    const XEffectDef *mHandle;
-
-    qint32 mNamePtr;
-    QString mName;
-};
-
-
-
-
-
-
-
-class XEffectDef : public XAsset
-{
-public:
-    explicit XEffectDef();
-    ~XEffectDef();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    qint32 mNamePtr;
-    QString mName;
-
-    int mFlags;
-    int mTotalSize;
-    int mMsecLoopingLife;
-    int mElemDefCountLooping;
-    int mElemDefCountOneShot;
-    int mElemDefCountEmission;
-
-    qint32 mElemDefsPtr;
-    QVector<XFxElemDef> mElemDefs;
-};
-
-#endif // EFFECTDEF_H

libs/xassets/xeffectdef.h.autosave

@@ -1,188 +0,0 @@
-#ifndef EFFECTDEF_H
-#define EFFECTDEF_H
-
-#include "xmaterial.h"
-#include "xmodel.h"
-
-class XFxSpawnDefLooping : public XAsset
-{
-public:
-    explicit XFxSpawnDefLooping();
-    ~XFxSpawnDefLooping();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    int mIntervalMsec;
-    int mCount;
-};
-
-class XFxIntRange : public XAsset
-{
-public:
-    explicit XFxIntRange();
-    ~XFxIntRange();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    int mBase;
-    int mAmplitude;
-};
-
-class XFxSpawnDefOneShot : public XAsset
-{
-public:
-    explicit XFxSpawnDefOneShot();
-    ~XFxSpawnDefOneShot();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    XFxIntRange mCount;
-};
-
-class XFxSpawnDef : public XAsset
-{
-public:
-    explicit XFxSpawnDef();
-    ~XFxSpawnDef();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    XFxSpawnDefLooping mLooping;
-    XFxSpawnDefOneShot omOneShot;
-};
-
-class XFxFloatRange : public XAsset
-{
-public:
-    explicit XFxFloatRange();
-    ~XFxFloatRange();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    float base;
-    float amplitude;
-};
-
-class XFxElemAtlas : public XAsset
-{
-public:
-    explicit XFxElemAtlas();
-    ~XFxElemAtlas();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    quint8 mBehavior;
-    quint8 mIndex;
-    quint8 mFps;
-    quint8 mLoopCount;
-    quint8 mColIndexBits;
-    quint8 mRowIndexBits;
-    qint16 mEntryCount;
-};
-
-class XFxElemVec3Range : public XAsset
-{
-public:
-    explicit XFxElemVec3Range();
-    ~XFxElemVec3Range();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    QVector3D mBase;
-    QVector3D mAmplitude;
-};
-
-class XFxElemVelStateInFrame : public XAsset
-{
-public:
-    explicit XFxElemVelStateInFrame();
-    ~XFxElemVelStateInFrame();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    XFxElemVec3Range mVelocity;
-    XFxElemVec3Range mTotalDelta;
-};
-
-class XFxElemVelStateSample : public XAsset
-{
-public:
-    explicit XFxElemVelStateSample();
-    ~XFxElemVelStateSample();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    XFxElemVelStateInFrame mLocal;
-    XFxElemVelStateInFrame mWorld;
-};
-
-class XFxElemVisualState : public XAsset
-{
-public:
-    explicit XFxElemVisualState();
-    ~XFxElemVisualState();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    quint8 mColor[4];
-    float mRotationDelta;
-    float mRotationTotal;
-    float mSize[2];
-    float mScale;
-};
-
-
-
-
-
-
-
-
-
-
-
-class XEffectDef : public XAsset
-{
-public:
-    explicit XEffectDef();
-    ~XEffectDef();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    qint32 mNamePtr;
-    QString mName;
-
-    int mFlags;
-    int mTotalSize;
-    int mMsecLoopingLife;
-    int mElemDefCountLooping;
-    int mElemDefCountOneShot;
-    int mElemDefCountEmission;
-
-    qint32 mElemDefsPtr;
-    QVector<XFxElemDef> mElemDefs;
-};
-
-#endif // EFFECTDEF_H

libs/xassets/xeffectdefref.cpp

@@ -1,30 +0,0 @@
-#include "xeffectdefref.h"
-
-XEffectDefRef::XEffectDefRef()
-    : XAsset()
-    , mHandlePtr(0)
-    , mHandle(new XEffectDef())
-    , mNamePtr(0)
-    , mName("")
-{
-    
-}
-
-XEffectDefRef::~XEffectDefRef()
-{
-    
-}
-
-void XEffectDefRef::Clear()
-{
-    mHandlePtr = 0;
-    mHandle = new XEffectDef();
-
-    mNamePtr = 0;
-    mName = "";
-}
-
-void XEffectDefRef::ParseData(QDataStream *aStream)
-{
-    
-}

libs/xassets/xeffectdefref.h

@@ -1,24 +0,0 @@
-#ifndef XEFFECTDEFREF_H
-#define XEFFECTDEFREF_H
-
-#include "xasset.h"
-#include "xeffectdef.h"
-
-class XEffectDefRef : public XAsset
-{
-public:
-    explicit XEffectDefRef();
-    ~XEffectDefRef();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    qint32 mHandlePtr;
-    const XEffectDef *mHandle;
-
-    qint32 mNamePtr;
-    QString mName;
-};
-
-#endif // XEFFECTDEFREF_H

libs/xassets/xeffecttable.cpp

@@ -1,29 +0,0 @@
-#include "xeffecttable.h"
-
-XImpactTable::XImpactTable()
-    : XAsset()
-    , mNamePtr(0)
-    , mName("")
-    , mTablePtr(0)
-    , mTable()
-{
-
-}
-
-XImpactTable::~XImpactTable()
-{
-
-}
-
-void XImpactTable::Clear()
-{
-    mNamePtr = 0;
-    mName = "";
-    mTablePtr = 0;
-    mTable = QVector<XFxImpactEntry>();
-}
-
-void XImpactTable::ParseData(QDataStream *aStream)
-{
-
-}

libs/xassets/xeffecttable.h

@@ -1,24 +0,0 @@
-#ifndef EFFECTTABLE_H
-#define EFFECTTABLE_H
-
-#include "xasset.h"
-#include "xfximpactentry.h"
-
-class XImpactTable : public XAsset
-{
-public:
-    explicit XImpactTable();
-    ~XImpactTable();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    qint32 mNamePtr;
-    QString mName;
-
-    qint32 mTablePtr;
-    QVector<XFxImpactEntry> mTable;
-};
-
-#endif // EFFECTTABLE_H

libs/xassets/xfile.cpp

@@ -1,17 +0,0 @@
-#include "xfile.h"
-
-XFile::XFile()
-    : XAsset()
-{
-
-}
-
-void XFile::ParseData(QDataStream *aStream)
-{
-
-}
-
-void XFile::Clear()
-{
-
-}

libs/xassets/xfile.h

@@ -1,20 +0,0 @@
-#ifndef FILE_H
-#define FILE_H
-
-#include "xasset.h"
-
-class XFile : public XAsset
-{
-public:
-    explicit XFile();
-
-    virtual void ParseData(QDataStream* aStream) override;
-    virtual void Clear() override;
-
-private:
-    quint32 mSize;
-    quint32 mExternalSize;
-    quint32 mBlockSize[7];
-};
-
-#endif // FILE_H

libs/xassets/xfxelemdef.cpp

@@ -1,97 +0,0 @@
-#include "xfxelemdef.h"
-
-XFxElemDef::XFxElemDef()
-    : XAsset()
-    , mFlags(0)
-    , mSpawn()
-    , mSpawnRange()
-    , mFadeInRange()
-    , mFadeOutRange()
-    , mSpawnFrustumCullRadius(0)
-    , mSpawnDelayMsec()
-    , mLifeSpanMsec()
-    , mSpawnOrigin()
-    , mSpawnOffsetRadius()
-    , mSpawnOffsetHeight()
-    , mSpawnAngles()
-    , mAngularVelocity()
-    , mInitialRotation()
-    , mGravity()
-    , mReflectionFactor()
-    , mAtlas()
-    , mElemType(0)
-    , mVisualCount(0)
-    , mVelIntervalCount(0)
-    , mVisStateIntervalCount(0)
-    , mVelSamplesPtr(0)
-    , mVelSamples()
-    , mVisSamplesPtr(0)
-    , mVisSamples()
-    , mVisuals()
-    , mCollMins()
-    , mCollMaxs()
-    , mEffectOnImpact()
-    , mEffectOnDeath()
-    , mEffectEmitted()
-    , mEmitDist()
-    , mEmitDistVariance()
-    , mTrailDefPtr(0)
-    , mTrailDef(new XFxTrailDef())
-    , mSortOrder(0)
-    , mLightingFrac(0)
-    , mUseItemClip(0)
-{
-
-}
-
-XFxElemDef::~XFxElemDef()
-{
-    
-}
-
-void XFxElemDef::Clear()
-{
-    mFlags = 0;
-    mSpawn.Clear();
-    mSpawnRange = FxFloatRange();
-    mFadeInRange = FxFloatRange();
-    mFadeOutRange = FxFloatRange();
-    mSpawnFrustumCullRadius = 0;
-    mSpawnDelayMsec = FxIntRange();
-    mLifeSpanMsec = FxIntRange();
-    mSpawnOrigin = QVector<FxFloatRange>();
-    mSpawnOffsetRadius = FxFloatRange();
-    mSpawnOffsetHeight = FxFloatRange();
-    mSpawnAngles = QVector<FxFloatRange>();
-    mAngularVelocity = QVector<FxFloatRange>();
-    mInitialRotation = FxFloatRange();
-    mGravity = FxFloatRange();
-    mReflectionFactor = FxFloatRange();
-    mAtlas = FxElemAtlas();
-    mElemType = 0;
-    mVisualCount = 0;
-    mVelIntervalCount = 0;
-    mVisStateIntervalCount = 0;
-    mVelSamplesPtr = 0;
-    mVelSamples = QVector<FxElemVelStateSample>();
-    mVisSamplesPtr = 0;
-    mVisSamples = QVector<FxElemVisStateSample>();
-    mVisuals = FxElemDefVisuals();
-    mCollMins = QVector3D();
-    mCollMaxs = QVector3D();
-    mEffectOnImpact = ;
-    mEffectOnDeath = ;
-    mEffectEmitted = ;
-    mEmitDist = ;
-    mEmitDistVariance = ;
-    mTrailDefPtr = 0;
-    mTrailDef = new XFxTrailDef = ;;
-    mSortOrder = 0;
-    mLightingFrac = 0;
-    mUseItemClip = 0;
-}
-
-void XFxElemDef::ParseData(QDataStream *aStream)
-{
-    
-}

libs/xassets/xfxelemdef.h

@@ -1,60 +0,0 @@
-#ifndef XFXELEMDEF_H
-#define XFXELEMDEF_H
-
-#include "xasset.h"
-#include "xeffectdef.h"
-#include "xfxtraildef.h"
-
-class XFxElemDef : public XAsset
-{
-public:
-    explicit XFxElemDef();
-    ~XFxElemDef();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    int mFlags;
-    FxSpawnDef mSpawn;
-    FxFloatRange mSpawnRange;
-    FxFloatRange mFadeInRange;
-    FxFloatRange mFadeOutRange;
-    float mSpawnFrustumCullRadius;
-    FxIntRange mSpawnDelayMsec;
-    FxIntRange mLifeSpanMsec;
-    QVector<FxFloatRange> mSpawnOrigin;
-    FxFloatRange mSpawnOffsetRadius;
-    FxFloatRange mSpawnOffsetHeight;
-    QVector<FxFloatRange> mSpawnAngles;
-    QVector<FxFloatRange> mAngularVelocity;
-    FxFloatRange mInitialRotation;
-    FxFloatRange mGravity;
-    FxFloatRange mReflectionFactor;
-    FxElemAtlas mAtlas;
-    quint8 mElemType;
-    quint8 mVisualCount;
-    quint8 mVelIntervalCount;
-    quint8 mVisStateIntervalCount;
-    qint32 mVelSamplesPtr;
-    QVector<FxElemVelStateSample> mVelSamples;
-    qint32 mVisSamplesPtr;
-    QVector<FxElemVisStateSample> mVisSamples;
-    FxElemDefVisuals mVisuals;
-    QVector3D mCollMins;
-    QVector3D mCollMaxs;
-    EffectDefRef mEffectOnImpact;
-    EffectDefRef mEffectOnDeath;
-    EffectDefRef mEffectEmitted;
-    FxFloatRange mEmitDist;
-    FxFloatRange mEmitDistVariance;
-
-    qint32 mTrailDefPtr;
-    XFxTrailDef *mTrailDef;
-
-    quint8 mSortOrder;
-    quint8 mLightingFrac;
-    quint8 mUseItemClip;
-};
-
-#endif // XFXELEMDEF_H

libs/xassets/xfxelemdefvisuals.cpp

@@ -1,31 +0,0 @@
-#include "xfxelemdefvisuals.h"
-
-XFxElemDefVisuals::XFxElemDefVisuals()
-    : XAsset()
-    , mMarkArrayPtr(0)
-    , mMarkArray()
-    , mArrayPtr(0)
-    , mArray()
-    , mInstance()
-{
-    
-}
-
-XFxElemDefVisuals::~XFxElemDefVisuals()
-{
-    
-}
-
-void XFxElemDefVisuals::Clear()
-{
-    mMarkArrayPtr = 0;
-    mMarkArray.clear();
-    mArrayPtr = 0;
-    mArray.clear();
-    mInstance = XFxElemVisuals();
-}
-
-void XFxElemDefVisuals::ParseData(QDataStream *aStream)
-{
-    
-}

libs/xassets/xfxelemdefvisuals.h

@@ -1,26 +0,0 @@
-#ifndef XFXELEMDEFVISUALS_H
-#define XFXELEMDEFVISUALS_H
-
-#include "xasset.h"
-#include "xeffectdef.h"
-
-class XFxElemDefVisuals : public XAsset
-{
-public:
-    explicit XFxElemDefVisuals();
-    ~XFxElemDefVisuals();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    qint32 mMarkArrayPtr;
-    QVector<XFxElemMarkVisuals> mMarkArray;
-
-    qint32 mArrayPtr;
-    QVector<XFxElemVisuals> mArray;
-
-    XFxElemVisuals mInstance;
-};
-
-#endif // XFXELEMDEFVISUALS_H

libs/xassets/xfxelemmarkvisuals.cpp

@@ -1,25 +0,0 @@
-#include "xfxelemmarkvisuals.h"
-
-XFxElemMarkVisuals::XFxElemMarkVisuals()
-    : XAsset()
-    , mMaterialPtrs()
-    , mMaterials()
-{
-
-}
-
-XFxElemMarkVisuals::~XFxElemMarkVisuals()
-{
-
-}
-
-void XFxElemMarkVisuals::Clear()
-{
-    mMaterialPtrs.clear();
-    mMaterials.clear();
-}
-
-void XFxElemMarkVisuals::ParseData(QDataStream *aStream)
-{
-
-}

libs/xassets/xfxelemmarkvisuals.h

@@ -1,23 +0,0 @@
-#ifndef XFXELEMMARKVISUALS_H
-#define XFXELEMMARKVISUALS_H
-
-#include "xasset.h"
-#include "xmaterial.h"
-
-#include <QVector2D>
-
-class XFxElemMarkVisuals : public XAsset
-{
-public:
-    explicit XFxElemMarkVisuals();
-    ~XFxElemMarkVisuals();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    QVector<qint32> mMaterialPtrs;
-    QVector<XMaterial> mMaterials;
-};
-
-#endif // XFXELEMMARKVISUALS_H

libs/xassets/xfxelemvisstatesample.cpp

@@ -1,47 +0,0 @@
-#include "xfxtrailvertex.h"
-
-XFxTrailVertex::XFxTrailVertex()
-    : XAsset()
-    , mPos()
-    , mNormal()
-    , mTexCoord(0)
-{
-    
-}
-
-XFxTrailVertex::~XFxTrailVertex()
-{
-    
-}
-
-void XFxTrailVertex::Clear()
-{
-    mPos = QVector2D();
-    mNormal = QVector2D();
-    mTexCoord = 0;
-}
-
-void XFxTrailVertex::ParseData(QDataStream *aStream)
-{
-    
-}
-
-XFxElemVisStateSample::XFxElemVisStateSample()
-{
-    
-}
-
-XFxElemVisStateSample::~XFxElemVisStateSample()
-{
-    
-}
-
-void XFxElemVisStateSample::Clear()
-{
-    
-}
-
-void XFxElemVisStateSample::ParseData(QDataStream *aStream)
-{
-    
-}

libs/xassets/xfxelemvisstatesample.h

@@ -1,21 +0,0 @@
-#ifndef XFXELEMVISSTATESAMPLE_H
-#define XFXELEMVISSTATESAMPLE_H
-
-#include "xasset.h"
-#include "xeffectdef.h"
-
-class XFxElemVisStateSample : public XAsset
-{
-public:
-    explicit XFxElemVisStateSample();
-    ~XFxElemVisStateSample();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    XFxElemVisualState mBase;
-    XFxElemVisualState mAmplitude;
-};
-
-#endif // XFXELEMVISSTATESAMPLE_H

libs/xassets/xfxelemvisuals.cpp

@@ -1,43 +0,0 @@
-#include "xfxelemvisuals.h"
-
-XFxElemVisuals::XFxElemVisuals()
-    : XAsset()
-    , mAnonymousPtr(0)
-    , mAnonymous(nullptr)
-    , mMaterialPtr(0)
-    , mMaterial(new XMaterial())
-    , mModelPtr(0)
-    , mModel(new XModel())
-    , mEffectDef()
-    , mSoundNamePtr(0)
-    , mSoundName("")
-{
-    
-}
-
-XFxElemVisuals::~XFxElemVisuals()
-{
-    
-}
-
-void XFxElemVisuals::Clear()
-{
-    mAnonymousPtr = 0;
-    mAnonymous = nullptr;
-
-    mMaterialPtr = 0;
-    mMaterial = new XMaterial();
-
-    mModelPtr = 0;
-    mModel = new XModel();
-
-    mEffectDef = XEffectDefRef();
-
-    mSoundNamePtr = 0;
-    mSoundName = "";
-}
-
-void XFxElemVisuals::ParseData(QDataStream *aStream)
-{
-    
-}

libs/xassets/xfxelemvisuals.h

@@ -1,36 +0,0 @@
-#ifndef XFXELEMVISUALS_H
-#define XFXELEMVISUALS_H
-
-#include "xasset.h"
-#include "xeffectdef.h"
-#include "xmaterial.h"
-#include "xmodel.h"
-
-#include <QVector2D>
-
-class XFxElemVisuals : public XAsset
-{
-public:
-    explicit XFxElemVisuals();
-    ~XFxElemVisuals();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    qint32 mAnonymousPtr;
-    const void *mAnonymous;
-
-    qint32 mMaterialPtr;
-    XMaterial *mMaterial;
-
-    qint32 mModelPtr;
-    XModel *mModel;
-
-    XEffectDefRef mEffectDef;
-
-    qint32 mSoundNamePtr;
-    QString mSoundName;
-};
-
-#endif // XFXELEMVISUALS_H

libs/xassets/xfximpactentry.cpp

@@ -1,29 +0,0 @@
-#include "xfximpactentry.h"
-
-XFxImpactEntry::XFxImpactEntry()
-    : XAsset()
-    , mNonFleshPtrs()
-    , mNonFlesh()
-    , mFleshPtrs()
-    , mFlesh()
-{
-    
-}
-
-XFxImpactEntry::~XFxImpactEntry()
-{
-    
-}
-
-void XFxImpactEntry::Clear()
-{
-    mNonFleshPtrs.clear();
-    mNonFlesh.clear();
-    mFleshPtrs.clear();
-    mFlesh.clear();
-}
-
-void XFxImpactEntry::ParseData(QDataStream *aStream)
-{
-    
-}

libs/xassets/xfximpactentry.h

@@ -1,24 +0,0 @@
-#ifndef XFXIMPACTENTRY_H
-#define XFXIMPACTENTRY_H
-
-#include "xasset.h"
-#include "xeffectdef.h"
-
-class XFxImpactEntry : public XAsset
-{
-public:
-    explicit XFxImpactEntry();
-    ~XFxImpactEntry();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    QVector<qint32> mNonFleshPtrs;
-    QVector<XEffectDef> mNonFlesh;
-
-    QVector<qint32> mFleshPtrs;
-    QVector<XEffectDef> mFlesh;
-};
-
-#endif // XFXIMPACTENTRY_H

libs/xassets/xfxtraildef.cpp

@@ -1,35 +0,0 @@
-#include "xfxtraildef.h"
-
-XFxTrailDef::XFxTrailDef()
-    : XAsset()
-    , mScrollTimeMsec(0)
-    , mRepeatDist(0)
-    , mSplitDist(0)
-    , mVertCount(0)
-    , mVerts()
-    , mIndCount(0)
-    , mIndices()
-{
-    
-}
-
-XFxTrailDef::~XFxTrailDef()
-{
-    
-}
-
-void XFxTrailDef::Clear()
-{
-    mScrollTimeMsec = 0;
-    mRepeatDist = 0;
-    mSplitDist = 0;
-    mVertCount = 0;
-    mVerts = QVector<XFxTrailVertex>();
-    mIndCount = 0;
-    mIndices = QVector<quint16>();
-}
-
-void XFxTrailDef::ParseData(QDataStream *aStream)
-{
-    
-}

libs/xassets/xfxtraildef.h

@@ -1,27 +0,0 @@
-#ifndef XFXTRAILDEF_H
-#define XFXTRAILDEF_H
-
-#include "xasset.h"
-
-#include <QVector>
-
-class XFxTrailDef : public XAsset
-{
-public:
-    explicit XFxTrailDef();
-    ~XFxTrailDef();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    int mScrollTimeMsec;
-    int mRepeatDist;
-    int mSplitDist;
-    int mVertCount;
-    QVector<XFxTrailVertex> mVerts;
-    int mIndCount;
-    QVector<quint16> mIndices;
-};
-
-#endif // XFXTRAILDEF_H

libs/xassets/xfxtrailvertex - Copy (2).cpp

@@ -1,27 +0,0 @@
-#include "xfxtrailvertex.h"
-
-XFxTrailVertex::XFxTrailVertex()
-    : XAsset()
-    , mPos()
-    , mNormal()
-    , mTexCoord(0)
-{
-    
-}
-
-XFxTrailVertex::~XFxTrailVertex()
-{
-    
-}
-
-void XFxTrailVertex::Clear()
-{
-    mPos = QVector2D();
-    mNormal = QVector2D();
-    mTexCoord = 0;
-}
-
-void XFxTrailVertex::ParseData(QDataStream *aStream)
-{
-    
-}

libs/xassets/xfxtrailvertex - Copy (2).h

@@ -1,23 +0,0 @@
-#ifndef XFXTRAILVERTEX_H
-#define XFXTRAILVERTEX_H
-
-#include "xasset.h"
-
-#include <QVector2D>
-
-class XFxTrailVertex : public XAsset
-{
-public:
-    explicit XFxTrailVertex();
-    ~XFxTrailVertex();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    QVector2D mPos;
-    QVector2D mNormal;
-    float mTexCoord;
-};
-
-#endif // XFXTRAILVERTEX_H

libs/xassets/xfxtrailvertex - Copy (3).cpp

@@ -1,27 +0,0 @@
-#include "xfxtrailvertex.h"
-
-XFxTrailVertex::XFxTrailVertex()
-    : XAsset()
-    , mPos()
-    , mNormal()
-    , mTexCoord(0)
-{
-    
-}
-
-XFxTrailVertex::~XFxTrailVertex()
-{
-    
-}
-
-void XFxTrailVertex::Clear()
-{
-    mPos = QVector2D();
-    mNormal = QVector2D();
-    mTexCoord = 0;
-}
-
-void XFxTrailVertex::ParseData(QDataStream *aStream)
-{
-    
-}

libs/xassets/xfxtrailvertex - Copy (3).h

@@ -1,23 +0,0 @@
-#ifndef XFXTRAILVERTEX_H
-#define XFXTRAILVERTEX_H
-
-#include "xasset.h"
-
-#include <QVector2D>
-
-class XFxTrailVertex : public XAsset
-{
-public:
-    explicit XFxTrailVertex();
-    ~XFxTrailVertex();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    QVector2D mPos;
-    QVector2D mNormal;
-    float mTexCoord;
-};
-
-#endif // XFXTRAILVERTEX_H

libs/xassets/xfxtrailvertex - Copy (4).cpp

@@ -1,27 +0,0 @@
-#include "xfxtrailvertex.h"
-
-XFxTrailVertex::XFxTrailVertex()
-    : XAsset()
-    , mPos()
-    , mNormal()
-    , mTexCoord(0)
-{
-    
-}
-
-XFxTrailVertex::~XFxTrailVertex()
-{
-    
-}
-
-void XFxTrailVertex::Clear()
-{
-    mPos = QVector2D();
-    mNormal = QVector2D();
-    mTexCoord = 0;
-}
-
-void XFxTrailVertex::ParseData(QDataStream *aStream)
-{
-    
-}

libs/xassets/xfxtrailvertex - Copy (4).h

@@ -1,23 +0,0 @@
-#ifndef XFXTRAILVERTEX_H
-#define XFXTRAILVERTEX_H
-
-#include "xasset.h"
-
-#include <QVector2D>
-
-class XFxTrailVertex : public XAsset
-{
-public:
-    explicit XFxTrailVertex();
-    ~XFxTrailVertex();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    QVector2D mPos;
-    QVector2D mNormal;
-    float mTexCoord;
-};
-
-#endif // XFXTRAILVERTEX_H

libs/xassets/xfxtrailvertex - Copy (5).cpp

@@ -1,27 +0,0 @@
-#include "xfxtrailvertex.h"
-
-XFxTrailVertex::XFxTrailVertex()
-    : XAsset()
-    , mPos()
-    , mNormal()
-    , mTexCoord(0)
-{
-    
-}
-
-XFxTrailVertex::~XFxTrailVertex()
-{
-    
-}
-
-void XFxTrailVertex::Clear()
-{
-    mPos = QVector2D();
-    mNormal = QVector2D();
-    mTexCoord = 0;
-}
-
-void XFxTrailVertex::ParseData(QDataStream *aStream)
-{
-    
-}

libs/xassets/xfxtrailvertex - Copy (5).h

@@ -1,23 +0,0 @@
-#ifndef XFXTRAILVERTEX_H
-#define XFXTRAILVERTEX_H
-
-#include "xasset.h"
-
-#include <QVector2D>
-
-class XFxTrailVertex : public XAsset
-{
-public:
-    explicit XFxTrailVertex();
-    ~XFxTrailVertex();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    QVector2D mPos;
-    QVector2D mNormal;
-    float mTexCoord;
-};
-
-#endif // XFXTRAILVERTEX_H

libs/xassets/xfxtrailvertex - Copy (6).cpp

@@ -1,27 +0,0 @@
-#include "xfxtrailvertex.h"
-
-XFxTrailVertex::XFxTrailVertex()
-    : XAsset()
-    , mPos()
-    , mNormal()
-    , mTexCoord(0)
-{
-    
-}
-
-XFxTrailVertex::~XFxTrailVertex()
-{
-    
-}
-
-void XFxTrailVertex::Clear()
-{
-    mPos = QVector2D();
-    mNormal = QVector2D();
-    mTexCoord = 0;
-}
-
-void XFxTrailVertex::ParseData(QDataStream *aStream)
-{
-    
-}

libs/xassets/xfxtrailvertex - Copy (6).h

@@ -1,23 +0,0 @@
-#ifndef XFXTRAILVERTEX_H
-#define XFXTRAILVERTEX_H
-
-#include "xasset.h"
-
-#include <QVector2D>
-
-class XFxTrailVertex : public XAsset
-{
-public:
-    explicit XFxTrailVertex();
-    ~XFxTrailVertex();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    QVector2D mPos;
-    QVector2D mNormal;
-    float mTexCoord;
-};
-
-#endif // XFXTRAILVERTEX_H

libs/xassets/xfxtrailvertex - Copy (7).cpp

@@ -1,27 +0,0 @@
-#include "xfxtrailvertex.h"
-
-XFxTrailVertex::XFxTrailVertex()
-    : XAsset()
-    , mPos()
-    , mNormal()
-    , mTexCoord(0)
-{
-    
-}
-
-XFxTrailVertex::~XFxTrailVertex()
-{
-    
-}
-
-void XFxTrailVertex::Clear()
-{
-    mPos = QVector2D();
-    mNormal = QVector2D();
-    mTexCoord = 0;
-}
-
-void XFxTrailVertex::ParseData(QDataStream *aStream)
-{
-    
-}

libs/xassets/xfxtrailvertex - Copy (7).h

@@ -1,23 +0,0 @@
-#ifndef XFXTRAILVERTEX_H
-#define XFXTRAILVERTEX_H
-
-#include "xasset.h"
-
-#include <QVector2D>
-
-class XFxTrailVertex : public XAsset
-{
-public:
-    explicit XFxTrailVertex();
-    ~XFxTrailVertex();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    QVector2D mPos;
-    QVector2D mNormal;
-    float mTexCoord;
-};
-
-#endif // XFXTRAILVERTEX_H

libs/xassets/xfxtrailvertex.cpp

@@ -1,27 +0,0 @@
-#include "xfxtrailvertex.h"
-
-XFxTrailVertex::XFxTrailVertex()
-    : XAsset()
-    , mPos()
-    , mNormal()
-    , mTexCoord(0)
-{
-    
-}
-
-XFxTrailVertex::~XFxTrailVertex()
-{
-    
-}
-
-void XFxTrailVertex::Clear()
-{
-    mPos = QVector2D();
-    mNormal = QVector2D();
-    mTexCoord = 0;
-}
-
-void XFxTrailVertex::ParseData(QDataStream *aStream)
-{
-    
-}

libs/xassets/xfxtrailvertex.h

@@ -1,23 +0,0 @@
-#ifndef XFXTRAILVERTEX_H
-#define XFXTRAILVERTEX_H
-
-#include "xasset.h"
-
-#include <QVector2D>
-
-class XFxTrailVertex : public XAsset
-{
-public:
-    explicit XFxTrailVertex();
-    ~XFxTrailVertex();
-
-    void Clear() override;
-    void ParseData(QDataStream *aStream) override;
-
-private:
-    QVector2D mPos;
-    QVector2D mNormal;
-    float mTexCoord;
-};
-
-#endif // XFXTRAILVERTEX_H

libs/xassets/xgameworldmp.h

@@ -1,3 +1,5 @@
+
+
 #ifndef XGAMEWORLDMP_H
 #define XGAMEWORLDMP_H
 

libs/xassets/xgfxcolor.cpp

@@ -1,19 +0,0 @@
-#include "xgfxcolor.h"
-
-XGfxColor::XGfxColor()
-    : XAsset()
-    , mPacked(0)
-    , mArray()
-{
-    
-}
-
-void XGfxColor::ParseData(QDataStream *aStream)
-{
-    
-}
-
-void XGfxColor::Clear()
-{
-    
-}