Lotta changes

libs/xassets/xclipmap.cpp

@@ -54,302 +54,274 @@ XClipMap::XClipMap()
     , mChecksum(0)
 {
     SetType(ASSET_TYPE_CLIPMAP);
-    SetName("ClipMap");
+    SetName("Clip Map");
 }
 
-XClipMap::~XClipMap()
+void XClipMap::ParseData(XDataStream *aStream)
-{
-
-}
-
-void XClipMap::ParseData(QDataStream *aStream)
 {
     if (GetPtr() == -1)
     {
+        // name / header
         mName.ParsePtr(aStream, false);
 
-        qint32 planePtr, staticModelPtr, materialsPtr, brushSidesPtr,
+        mIsInUse = aStream->ParseUInt32(QString("%1 is in use").arg(GetName()));
-            brushEdgesPtr, nodesPtr, leafsPtr, leafsBrushNodesPtr,
+        mPlaneCount = aStream->ParseInt32 (QString("%1 plane count").arg(GetName()));
-            leafBrushesPtr, leafSurfacesPtr, vertPtr,
+        qint32 planePtr = aStream->ParseInt32(QString("%1 plane ptr").arg(GetName()));
-            triIndicesPtr, triEdgeWalkablePtr, bordersPtr, partitionsPtr, aabbTreesPtr,
-            cModelsPtr;
-        *aStream
-            >> mIsInUse
-            >> mPlaneCount
-            >> planePtr
-            >> mNumStaticModels
-            >> staticModelPtr
-            >> mNumMaterials
-            >> materialsPtr
-            >> mNumBrushSides
-            >> brushSidesPtr
-            >> mNumBrushEdges
-            >> brushEdgesPtr
-            >> mNumNodes
-            >> nodesPtr
-            >> mNumLeafs
-            >> leafsPtr
-            >> mLeafBrushNodesCount
-            >> leafsBrushNodesPtr
-            >> mNumLeafBrushes
-            >> leafBrushesPtr
-            >> mNumLeafSurfaces
-            >> leafSurfacesPtr
-            >> mVertCount
-            >> vertPtr
-            >> mTriCount
-            >> triIndicesPtr
-            >> triEdgeWalkablePtr
-            >> mBorderCount
-            >> bordersPtr
-            >> mPartitionCount
-            >> partitionsPtr
-            >> mAabbTreeCount
-            >> aabbTreesPtr
-            >> mNumSubModels
-            >> cModelsPtr
-            >> mNumBrushes;
 
+        // static models / materials / brushes
+        mNumStaticModels = aStream->ParseUInt32(QString("%1 num static models").arg(GetName()));
+        qint32 staticModelPtr = aStream->ParseInt32(QString("%1 static model ptr").arg(GetName()));
+
+        mNumMaterials = aStream->ParseUInt32(QString("%1 num materials").arg(GetName()));
+        qint32 materialsPtr = aStream->ParseInt32(QString("%1 materials ptr").arg(GetName()));
+
+        mNumBrushSides = aStream->ParseUInt32(QString("%1 num brush sides").arg(GetName()));
+        qint32 brushSidesPtr = aStream->ParseInt32(QString("%1 brush sides ptr").arg(GetName()));
+
+        mNumBrushEdges = aStream->ParseUInt32(QString("%1 num brush edges").arg(GetName()));
+        qint32 brushEdgesPtr = aStream->ParseInt32(QString("%1 brush edges ptr").arg(GetName()));
+
+        mNumNodes = aStream->ParseUInt32(QString("%1 num nodes").arg(GetName()));
+        qint32 nodesPtr = aStream->ParseInt32(QString("%1 nodes ptr").arg(GetName()));
+
+        mNumLeafs = aStream->ParseUInt32(QString("%1 num leafs").arg(GetName()));
+        qint32 leafsPtr = aStream->ParseInt32(QString("%1 leafs ptr").arg(GetName()));
+
+        mLeafBrushNodesCount = aStream->ParseUInt32(QString("%1 leaf brush nodes count").arg(GetName()));
+        qint32 leafsBrushNodesPtr= aStream->ParseInt32(QString("%1 leaf brush nodes ptr").arg(GetName()));
+
+        mNumLeafBrushes = aStream->ParseUInt32(QString("%1 num leaf brushes").arg(GetName()));
+        qint32 leafBrushesPtr = aStream->ParseInt32(QString("%1 leaf brushes ptr").arg(GetName()));
+
+        mNumLeafSurfaces = aStream->ParseUInt32(QString("%1 num leaf surfaces").arg(GetName()));
+        qint32 leafSurfacesPtr = aStream->ParseInt32(QString("%1 leaf surfaces ptr").arg(GetName()));
+
+        mVertCount = aStream->ParseUInt32(QString("%1 vert count").arg(GetName()));
+        qint32 vertPtr = aStream->ParseInt32(QString("%1 vert ptr").arg(GetName()));
+
+        mTriCount = aStream->ParseInt32(QString("%1 tri count").arg(GetName()));
+        qint32 triIndicesPtr = aStream->ParseInt32(QString("%1 tri indices ptr").arg(GetName()));
+        qint32 triEdgeWalkablePtr= aStream->ParseInt32(QString("%1 tri edge walkable ptr").arg(GetName()));
+
+        mBorderCount = aStream->ParseInt32(QString("%1 border count").arg(GetName()));
+        qint32 bordersPtr = aStream->ParseInt32(QString("%1 borders ptr").arg(GetName()));
+
+        mPartitionCount = aStream->ParseInt32(QString("%1 partition count").arg(GetName()));
+        qint32 partitionsPtr = aStream->ParseInt32(QString("%1 partitions ptr").arg(GetName()));
+
+        mAabbTreeCount = aStream->ParseInt32(QString("%1 aabb tree count").arg(GetName()));
+        qint32 aabbTreesPtr = aStream->ParseInt32(QString("%1 aabb trees ptr").arg(GetName()));
+
+        mNumSubModels = aStream->ParseUInt32(QString("%1 num sub models").arg(GetName()));
+        qint32 cModelsPtr = aStream->ParseInt32(QString("%1 c models ptr").arg(GetName()));
+
+        mNumBrushes = aStream->ParseUInt32(QString("%1 num brushes").arg(GetName()));
+
+        // skip padding
         aStream->skipRawData(2);
 
-        qint32 brushesPtr, visibilityPtr, mapEntsPtr;
+        // visibility + ents
-        *aStream
+        qint32 brushesPtr = aStream->ParseInt32(QString("%1 brushes ptr").arg(GetName()));
-            >> brushesPtr
+        mNumClusters = aStream->ParseInt32(QString("%1 num clusters").arg(GetName()));
-            >> mNumClusters
+        mClusterBytes = aStream->ParseInt32(QString("%1 cluster bytes").arg(GetName()));
-            >> mClusterBytes
+        qint32 visibilityPtr = aStream->ParseInt32(QString("%1 visibility ptr").arg(GetName()));
-            >> visibilityPtr
+        mVised = aStream->ParseInt32(QString("%1 vised").arg(GetName()));
-            >> mVised
+        qint32 mapEntsPtr = aStream->ParseInt32(QString("%1 map ents ptr").arg(GetName()));
-            >> mapEntsPtr;
 
         mMapEnts.ParsePtr(aStream, false);
         mBoxBrush.ParsePtr(aStream, false);
-
         mBoxModel.ParseData(aStream);
 
+        // dynEnt counts
         quint16 dynEntCount;
-        *aStream >> dynEntCount;
+        dynEntCount = aStream->ParseUInt16(QString("%1 dyn ent count [0]").arg(GetName()));
         mDynEntCounts.append(dynEntCount);
-        *aStream >> dynEntCount;
+        dynEntCount = aStream->ParseUInt16(QString("%1 dyn ent count [1]").arg(GetName()));
         mDynEntCounts.append(dynEntCount);
 
+        // dynEnt lists (ParsePtr once each)
         mDynEntDefList[0].ParsePtr(aStream, false);
-        mDynEntDefList[0].ParsePtr(aStream, false);
+        mDynEntDefList[1].ParsePtr(aStream, false);
 
         mDynEntPoseList[0].ParsePtr(aStream, false);
-        mDynEntPoseList[0].ParsePtr(aStream, false);
+        mDynEntPoseList[1].ParsePtr(aStream, false);
 
         mDynEntClientList[0].ParsePtr(aStream, false);
-        mDynEntClientList[0].ParsePtr(aStream, false);
+        mDynEntClientList[1].ParsePtr(aStream, false);
 
         mDynEntCollList[0].ParsePtr(aStream, false);
-        mDynEntCollList[0].ParsePtr(aStream, false);
+        mDynEntCollList[1].ParsePtr(aStream, false);
 
-        *aStream >> mChecksum;
+        mChecksum = aStream->ParseUInt32(QString("%1 checksum").arg(GetName()));
 
-        if (planePtr)
+        // =====================
-        {
+        // Sectioned data blocks
-            for (int i = 0; i < mPlaneCount; i++)
+        // =====================
-            {
+        if (planePtr) {
+            for (int i = 0; i < mPlaneCount; i++) {
                 XCPlane newCPlane;
                 newCPlane.ParseData(aStream);
                 mPlanes.append(newCPlane);
             }
         }
 
-        if (staticModelPtr)
+        if (staticModelPtr) {
-        {
+            for (quint32 i = 0; i < mNumStaticModels; i++) {
-            for (int i = 0; i < mNumStaticModels; i++)
-            {
                 XCStaticModel newModel;
                 newModel.ParseData(aStream);
                 mStaticModelList.append(newModel);
             }
         }
 
-        if (materialsPtr)
+        if (materialsPtr) {
-        {
+            for (quint32 i = 0; i < mNumMaterials; i++) {
-            for (int i = 0; i < mNumMaterials; i++)
+                XDMaterial newMat;
-            {
+                newMat.ParseData(aStream);
-                XDMaterial newDMaterial;
+                mMaterials.append(newMat);
-                newDMaterial.ParseData(aStream);
-                mMaterials.append(newDMaterial);
             }
         }
 
-        if (brushSidesPtr)
+        if (brushSidesPtr) {
-        {
+            for (quint32 i = 0; i < mNumBrushSides; i++) {
-            for (int i = 0; i < mNumBrushSides; i++)
+                XCBrushSide newSide;
-            {
+                newSide.ParseData(aStream);
-                XCBrushSide newBrushSide;
+                mBrushsides.append(newSide);
-                newBrushSide.ParseData(aStream);
-                mBrushsides.append(newBrushSide);
             }
         }
 
-        if (brushEdgesPtr)
+        if (brushEdgesPtr) {
-        {
+            for (quint32 i = 0; i < mNumBrushEdges; i++) {
-            for (int i = 0; i < mNumBrushEdges; i++)
+                quint8 edge = aStream->ParseUInt8(QString("%1 edge %2").arg(GetName()).arg(i));
-            {
+                mBrushEdges.append(edge);
-                quint8 newBrushEdge;
-                *aStream >> newBrushEdge;
-                mBrushEdges.append(newBrushEdge);
             }
         }
 
-        if (nodesPtr)
+        if (nodesPtr) {
-        {
+            for (quint32 i = 0; i < mNumNodes; i++) {
-            for (int i = 0; i < mNumNodes; i++)
-            {
                 XCNode newNode;
                 newNode.ParseData(aStream);
                 mNodes.append(newNode);
             }
         }
 
-        if (leafsPtr)
+        if (leafsPtr) {
-        {
+            for (quint32 i = 0; i < mNumLeafs; i++) {
-            for (int i = 0; i < mNumLeafs; i++)
-            {
                 XCLeaf newLeaf;
                 newLeaf.ParseData(aStream);
                 mLeafs.append(newLeaf);
             }
         }
 
-        if (leafBrushesPtr)
+        if (leafBrushesPtr) {
-        {
+            for (quint32 i = 0; i < mNumLeafBrushes; i++) {
-            for (int i = 0; i < mNumLeafBrushes; i++)
+                quint32 brush = aStream->ParseUInt32(QString("%1 brush %2").arg(GetName()).arg(i));
-            {
+                mLeafBrushes.append(brush);
-                quint32 newBrush;
-                *aStream >> newBrush;
-                mLeafBrushes.append(newBrush);
             }
         }
 
-        if (leafsBrushNodesPtr)
+        if (leafsBrushNodesPtr) {
-        {
+            for (quint32 i = 0; i < mLeafBrushNodesCount; i++) {
-            for (int i = 0; i < mNumLeafBrushes; i++)
+                XCLeafBrushNode newNode;
-            {
+                newNode.ParseData(aStream);
-                XCLeafBrushNode newBrushNode;
+                mLeafBrushNodes.append(newNode);
-                newBrushNode.ParseData(aStream);
-                mLeafBrushNodes.append(newBrushNode);
             }
         }
 
-        if (leafSurfacesPtr)
+        if (leafSurfacesPtr) {
-        {
+            for (quint32 i = 0; i < mNumLeafSurfaces; i++) {
-            for (int i = 0; i < mNumLeafBrushes; i++)
+                quint32 surf = aStream->ParseUInt32(QString("%1 surf %2").arg(GetName()).arg(i));
-            {
+                mLeafSurfaces.append(surf);
-                quint32 newBrush;
-                *aStream >> newBrush;
-                mLeafSurfaces.append(newBrush);
             }
         }
 
-        if (vertPtr)
+        if (vertPtr) {
-        {
+            for (quint32 i = 0; i < mVertCount; i++) {
-            for (int i = 0; i < mVertCount; i++)
+                for (int j = 0; j < 3; j++) {
-            {
+                    QVector3D v;
-                QVector3D newVert;
+                    v[j] = aStream->ParseSingle(QString("%1 vert (%2, %3)").arg(GetName()).arg(i).arg(j));
-                *aStream
+                    mVerts.append(v);
-                    >> newVert[0]
+                }
-                    >> newVert[1]
-                    >> newVert[2];
-                mVerts.append(newVert);
             }
         }
 
-        if (triIndicesPtr)
+        if (triIndicesPtr) {
-        {
+            for (int i = 0; i < mTriCount; i++) {
-            for (int i = 0; i < mTriCount; i++)
+                quint32 tri = aStream->ParseUInt32(QString("%1 tri %2").arg(GetName()).arg(i));
-            {
+                mTriIndices.append(tri);
-                quint32 newTri;
-                *aStream >> newTri;
-                mTriIndices.append(newTri);
             }
         }
 
-        if (triEdgeWalkablePtr)
+        if (triEdgeWalkablePtr) {
-        {
+            aStream->readRawData(mTriEdgeIsWalkable.data(),
-            aStream->readRawData(mTriEdgeIsWalkable.data(), ((3 * mTriCount + 31) >> 3) & 0xFFFFFFFC);
+                                 ((3 * mTriCount + 31) >> 3) & 0xFFFFFFFC);
         }
 
-        if (bordersPtr)
+        if (bordersPtr) {
-        {
+            for (int i = 0; i < mBorderCount; i++) {
-            for (int i = 0; i < mBorderCount; i++)
+                XCollisionBorder b;
-            {
+                b.ParseData(aStream);
-                XCollisionBorder newBorder;
+                mBorders.append(b);
-                newBorder.ParseData(aStream);
-                mBorders.append(newBorder);
             }
         }
 
-        if (partitionsPtr)
+        if (partitionsPtr) {
-        {
+            for (int i = 0; i < mPartitionCount; i++) {
-            for (int i = 0; i < mPartitionCount; i++)
+                XCollisionPartition p;
-            {
+                p.ParseData(aStream);
-                XCollisionPartition newPartition;
+                mPartitions.append(p);
-                newPartition.ParseData(aStream);
-                mPartitions.append(newPartition);
             }
         }
 
-        if (aabbTreesPtr)
+        if (aabbTreesPtr) {
-        {
+            for (int i = 0; i < mAabbTreeCount; i++) {
-            for (int i = 0; i < mAabbTreeCount; i++)
+                XCollisionAabbTree t;
-            {
+                t.ParseData(aStream);
-                XCollisionAabbTree newTree;
+                mAabbTrees.append(t);
-                newTree.ParseData(aStream);
-                mAabbTrees.append(newTree);
             }
         }
 
-        if (cModelsPtr)
+        if (cModelsPtr) {
-        {
+            for (quint32 i = 0; i < mNumSubModels; i++) {
-            for (int i = 0; i < mNumSubModels; i++)
+                XCModel m;
-            {
+                m.ParseData(aStream);
-                XCModel newCModel;
+                mCModels.append(m);
-                newCModel.ParseData(aStream);
-                mCModels.append(newCModel);
             }
         }
 
-        if (brushesPtr)
+        if (brushesPtr) {
-        {
+            for (quint32 i = 0; i < mNumBrushes; i++) {
-            for (int i = 0; i < mNumBrushes; i++)
+                XCBrush b;
-            {
+                b.ParseData(aStream);
-                XCBrush newCBrush;
+                mBrushes.append(b);
-                newCBrush.ParseData(aStream);
-                mBrushes.append(newCBrush);
             }
         }
 
-        if (visibilityPtr)
+        if (visibilityPtr) {
-        {
             aStream->readRawData(mVisibility.data(), mClusterBytes * mNumClusters);
         }
 
-        if (mapEntsPtr)
+        if (mapEntsPtr) {
-        {
             mMapEnts.ParseData(aStream);
         }
 
+        // box brush / dynEnt blocks
         mBoxBrush.ParseData(aStream);
 
         mDynEntDefList[0].ParseData(aStream);
-        mDynEntDefList[0].ParseData(aStream);
+        mDynEntDefList[1].ParseData(aStream);
 
         mDynEntPoseList[0].ParseData(aStream);
-        mDynEntPoseList[0].ParseData(aStream);
+        mDynEntPoseList[1].ParseData(aStream);
 
         mDynEntClientList[0].ParseData(aStream);
-        mDynEntClientList[0].ParseData(aStream);
+        mDynEntClientList[1].ParseData(aStream);
 
         mDynEntCollList[0].ParseData(aStream);
-        mDynEntCollList[0].ParseData(aStream);
+        mDynEntCollList[1].ParseData(aStream);
     }
 }
 
+
 void XClipMap::Clear()
 {
 

libs/xassets/xclipmap.h

@@ -23,9 +23,9 @@ class XClipMap : public XAsset
 {
 public:
     explicit XClipMap();
-    ~XClipMap();
+    ~XClipMap() = default;
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
 private:
@@ -33,7 +33,7 @@ private:
 
     quint32 mIsInUse;
 
-    int mPlaneCount;
+    qint32 mPlaneCount;
     QVector<XCPlane> mPlanes;
 
     quint32 mNumStaticModels;
@@ -66,20 +66,20 @@ private:
     quint32 mVertCount;
     QVector<QVector3D> mVerts;
 
-    int mTriCount;
+    qint32 mTriCount;
     QVector<quint32> mTriIndices;
     QByteArray mTriEdgeIsWalkable;
 
-    int mBorderCount;
+    qint32 mBorderCount;
     QVector<XCollisionBorder> mBorders;
 
-    int mPartitionCount;
+    qint32 mPartitionCount;
     QVector<XCollisionPartition> mPartitions;
 
-    int mAabbTreeCount;
+    qint32 mAabbTreeCount;
     QVector<XCollisionAabbTree> mAabbTrees;
 
-    uint mNumSubModels;
+    quint32 mNumSubModels;
     QVector<XCModel> mCModels;
 
     quint32 mNumBrushes;

libs/xassets/xcmodel.cpp

@@ -7,7 +7,7 @@ XCModel::XCModel()
     , mRadius(0.0f)
     , mLeaf()
 {
-    
+    SetName("C Model");
 }
 
 XCModel::~XCModel()
@@ -15,16 +15,17 @@ XCModel::~XCModel()
     
 }
 
-void XCModel::ParseData(QDataStream *aStream)
+void XCModel::ParseData(XDataStream *aStream)
 {
-    *aStream
+    for (int i = 0; i < 3; i++) {
-        >> mMins[0]
+        mMins[i] = aStream->ParseSingle(QString("%1 min %2").arg(GetName()).arg(i));
-        >> mMins[1]
+    }
-        >> mMins[2]
+
-        >> mMaxs[0]
+    for (int i = 0; i < 3; i++) {
-        >> mMaxs[1]
+        mMaxs[i] = aStream->ParseSingle(QString("%1 max %2").arg(GetName()).arg(i));
-        >> mMaxs[2]
+    }
-        >> mRadius;
+
+    mRadius = aStream->ParseSingle(QString("%1 radius").arg(GetName()));
 
     mLeaf.ParseData(aStream);
 }

libs/xassets/xcmodel.h

@@ -12,7 +12,7 @@ public:
     XCModel();
     ~XCModel();
 
-    virtual void ParseData(QDataStream* aStream) override;
+    virtual void ParseData(XDataStream* aStream) override;
     virtual void Clear() override;
 
 private:

libs/xassets/xcnode.cpp

@@ -3,23 +3,23 @@
 XCNode::XCNode()
     : XAsset()
     , mPlane()
-    , mChildren()
+    , mChildren(2)
 {
+    SetName("C Node");
 }
 
 XCNode::~XCNode()
 {
-
 }
 
-void XCNode::ParseData(QDataStream *aStream) {
+void XCNode::ParseData(XDataStream *aStream)
-    if (GetPtr() == -1) {
+{
+    if (GetPtr() == -1)
+    {
         mPlane.ParsePtr(aStream);
 
-        // Parse children
+        mChildren[0] = aStream->ParseInt16(QString("%1 child 0").arg(GetName()));
-        *aStream
+        mChildren[1] = aStream->ParseInt16(QString("%1 child 1").arg(GetName()));
-            >> mChildren[0]
-            >> mChildren[1];
 
         mPlane.ParseData(aStream);
     }
@@ -30,7 +30,3 @@ void XCNode::Clear()
     mPlane.Clear();
     mChildren.clear();
 }
-
-
-
-

libs/xassets/xcnode.h

@@ -10,7 +10,7 @@ public:
     explicit XCNode();
     ~XCNode();
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
 private:

libs/xassets/xcollisionaabbtree.cpp

@@ -8,30 +8,41 @@ XCollisionAabbTree::XCollisionAabbTree()
     , mChildCount(0)
     , mTreeIndex()
 {
+    SetName("Collision AABB Tree");
 }
 
 XCollisionAabbTree::~XCollisionAabbTree()
 {
-
 }
 
-void XCollisionAabbTree::ParseData(QDataStream *aStream) {
+void XCollisionAabbTree::ParseData(XDataStream *aStream)
-    if (GetPtr() == -1) {
+{
-        *aStream
+    if (GetPtr() == -1)
-            >> mOrigin[0]
+    {
-            >> mOrigin[1]
+        mOrigin.setX(aStream->ParseSingle(QString("%1 origin x").arg(GetName())));
-            >> mOrigin[2]
+        mOrigin.setY(aStream->ParseSingle(QString("%1 origin y").arg(GetName())));
-            >> mHalfSize[0]
+        mOrigin.setZ(aStream->ParseSingle(QString("%1 origin z").arg(GetName())));
-            >> mHalfSize[1]
+
-            >> mHalfSize[2]
+        mHalfSize.setX(aStream->ParseSingle(QString("%1 half size x").arg(GetName())));
-            >> mMaterialIndex
+        mHalfSize.setY(aStream->ParseSingle(QString("%1 half size y").arg(GetName())));
-            >> mChildCount;
+        mHalfSize.setZ(aStream->ParseSingle(QString("%1 half size z").arg(GetName())));
+
+        mMaterialIndex = aStream->ParseUInt32(QString("%1 material index").arg(GetName()));
+        mChildCount = aStream->ParseUInt32(QString("%1 child count").arg(GetName()));
 
-        // Parse union
         mTreeIndex.ParseData(aStream);
     }
 }
 
+void XCollisionAabbTree::Clear()
+{
+    mOrigin = QVector3D();
+    mHalfSize = QVector3D();
+    mMaterialIndex = 0;
+    mChildCount = 0;
+    mTreeIndex.Clear();
+}
+
 QVector3D XCollisionAabbTree::GetOrigin() const {
     return mOrigin;
 }
@@ -71,6 +82,3 @@ XCollisionAabbTreeIndex& XCollisionAabbTree::GetTreeIndex() {
 void XCollisionAabbTree::SetTreeIndex(const XCollisionAabbTreeIndex& aTreeIndex) {
     mTreeIndex = aTreeIndex;
 }
-
-
-

libs/xassets/xcollisionaabbtree.h

@@ -12,7 +12,8 @@ public:
     explicit XCollisionAabbTree();
     ~XCollisionAabbTree();
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
+    void Clear() override;
 
     QVector3D GetOrigin() const;
     void SetOrigin(QVector3D aOrigin);
@@ -32,8 +33,8 @@ public:
 private:
     QVector3D mOrigin;
     QVector3D mHalfSize;
-    quint32 mMaterialIndex = 0;
+    quint32 mMaterialIndex;
-    quint32 mChildCount = 0;
+    quint32 mChildCount;
     XCollisionAabbTreeIndex mTreeIndex;
 };
 

libs/xassets/xcollisionaabbtreeindex.cpp

@@ -5,7 +5,7 @@ XCollisionAabbTreeIndex::XCollisionAabbTreeIndex()
     , mFirstChildIndex(0)
     , mPartitionIndex(0)
 {
-
+    SetName("Collision AABB Tree Index");
 }
 
 XCollisionAabbTreeIndex::~XCollisionAabbTreeIndex()
@@ -13,11 +13,10 @@ XCollisionAabbTreeIndex::~XCollisionAabbTreeIndex()
 
 }
 
-void XCollisionAabbTreeIndex::ParseData(QDataStream *aStream) {
+void XCollisionAabbTreeIndex::ParseData(XDataStream *aStream) {
     if (GetPtr() == -1) {
-        *aStream
+        mFirstChildIndex = aStream->ParseInt32(QString("%1 first child index").arg(GetName()));
-            >> mFirstChildIndex
+        mPartitionIndex = aStream->ParseInt32(QString("%1 partition index").arg(GetName()));
-            >> mPartitionIndex;
     }
 }
 

libs/xassets/xcollisionaabbtreeindex.h

@@ -9,7 +9,7 @@ public:
     explicit XCollisionAabbTreeIndex();
     ~XCollisionAabbTreeIndex();
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
     // Option 1: First child index
     int GetFirstChildIndex() const;
@@ -20,8 +20,8 @@ public:
     void SetPartitionIndex(int index);
 
 private:
-    int mFirstChildIndex;
+    qint32 mFirstChildIndex;
-    int mPartitionIndex;
+    qint32 mPartitionIndex;
 };
 
 #endif // XCOLLISIONAABBTREEINDEX_H

libs/xassets/xcollisionborder.cpp

@@ -2,29 +2,33 @@
 
 XCollisionBorder::XCollisionBorder()
     : XAsset()
-    , mDistEq(3)
+    , mDistEq(3)   // Always 3 elements
     , mZBase(0.0f)
     , mZSlope(0.0f)
     , mStart(0.0f)
     , mLength(0.0f)
 {
+    SetName("Collision Border");
 }
 
 XCollisionBorder::~XCollisionBorder()
 {
-
 }
 
-void XCollisionBorder::ParseData(QDataStream *aStream) {
+void XCollisionBorder::ParseData(XDataStream *aStream)
-    if (GetPtr() == -1) {
+{
-        *aStream
+    if (GetPtr() == -1)
-            >> mDistEq[0]
+    {
-            >> mDistEq[1]
+        // Distance equation components
-            >> mDistEq[2]
+        mDistEq[0] = aStream->ParseSingle(QString("%1 dist eq x").arg(GetName()));
-            >> mZBase
+        mDistEq[1] = aStream->ParseSingle(QString("%1 dist eq y").arg(GetName()));
-            >> mZSlope
+        mDistEq[2] = aStream->ParseSingle(QString("%1 dist eq z").arg(GetName()));
-            >> mStart
+
-            >> mLength;
+        // Other properties
+        mZBase = aStream->ParseSingle(QString("%1 z base").arg(GetName()));
+        mZSlope = aStream->ParseSingle(QString("%1 z slope").arg(GetName()));
+        mStart = aStream->ParseSingle(QString("%1 start").arg(GetName()));
+        mLength = aStream->ParseSingle(QString("%1 length").arg(GetName()));
     }
 }
 

libs/xassets/xcollisionborder.h

@@ -11,7 +11,7 @@ public:
     explicit XCollisionBorder();
     ~XCollisionBorder();
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
 private:

libs/xassets/xcollisionpartition.cpp

@@ -7,6 +7,7 @@ XCollisionPartition::XCollisionPartition()
     , mFirstTri(0)
     , mBorders()
 {
+    SetName("Collision Partition");
 }
 
 XCollisionPartition::~XCollisionPartition()
@@ -14,7 +15,7 @@ XCollisionPartition::~XCollisionPartition()
 
 }
 
-void XCollisionPartition::ParseData(QDataStream *aStream) {
+void XCollisionPartition::ParseData(XDataStream *aStream) {
     if (GetPtr() == -1) {
         *aStream
             >> mTriCount

libs/xassets/xcollisionpartition.h

@@ -12,7 +12,7 @@ public:
     explicit XCollisionPartition();
     ~XCollisionPartition();
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
 private:

libs/xassets/xcolumninfo.cpp

@@ -7,17 +7,14 @@ XColumnInfo::XColumnInfo()
     , mMaxChars(0)
     , mAlignment(0)
 {
-    
+    SetName("Column Info");
 }
 
-XColumnInfo::~XColumnInfo()
+void XColumnInfo::ParseData(XDataStream *aStream)
 {
-    
+    Q_UNUSED(aStream);
-}
 
-void XColumnInfo::ParseData(QDataStream *aStream)
+    // TODOL Fill in XColumnInfo::ParseData
-{
-    
 }
 
 void XColumnInfo::Clear()

libs/xassets/xcolumninfo.h

@@ -7,9 +7,9 @@ class XColumnInfo : public XAsset
 {
 public:
     explicit XColumnInfo();
-    ~XColumnInfo();
+    ~XColumnInfo() = default;
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
 private:

libs/xassets/xcomprimarylight.cpp

@@ -15,9 +15,9 @@ XComPrimaryLight::XComPrimaryLight()
     , mCosHalfFovExpanded(0.0)
     , mRotationLimit(0.0)
     , mTranslationLimit(0.0)
-    , mDefName(new XString())
+    , mDefName()
 {
-
+    SetName("Com Primary Light");
 }
 
 XComPrimaryLight::~XComPrimaryLight()
@@ -27,10 +27,10 @@ XComPrimaryLight::~XComPrimaryLight()
 
 void XComPrimaryLight::Clear()
 {
-    delete mDefName;
+
 }
 
-XComPrimaryLightArray *XComPrimaryLight::ParseArray(QDataStream *aStream, int aCount)
+XComPrimaryLightArray *XComPrimaryLight::ParseArray(XDataStream *aStream, int aCount)
 {
     XComPrimaryLightArray* result = new XComPrimaryLightArray();
 
@@ -45,24 +45,37 @@ XComPrimaryLightArray *XComPrimaryLight::ParseArray(QDataStream *aStream, int aC
     return result;
 }
 
-void XComPrimaryLight::ParseData(QDataStream *aStream)
+void XComPrimaryLight::ParseData(XDataStream *aStream)
 {
-    *aStream
+    if (GetPtr() == -1)
-        >> mType
+    {
-        >> mCanUseShadowMap
+        mType             = aStream->ParseUInt8(QString("%1 type").arg(GetName()));
-        >> mExponent
+        mCanUseShadowMap  = aStream->ParseUInt8(QString("%1 can use shadow map").arg(GetName()));
-        >> mUnused
+        mExponent         = aStream->ParseUInt8(QString("%1 exponent").arg(GetName()));
-        >> mColor
+        mUnused           = aStream->ParseUInt8(QString("%1 unused").arg(GetName()));
-        >> mDir
-        >> mOrigin
-        >> mRadius
-        >> mCosHalfFovOuter
-        >> mCosHalfFovInner
-        >> mCosHalfFovExpanded
-        >> mRotationLimit
-        >> mTranslationLimit;
 
-    mDefName->ParseData(aStream);
+        float r = aStream->ParseSingle(QString("%1 color r").arg(GetName()));
+        float g = aStream->ParseSingle(QString("%1 color g").arg(GetName()));
+        float b = aStream->ParseSingle(QString("%1 color b").arg(GetName()));
+        mColor = QColor::fromRgbF(r, g, b);
+
+        mDir.setX(aStream->ParseSingle(QString("%1 dir x").arg(GetName())));
+        mDir.setY(aStream->ParseSingle(QString("%1 dir y").arg(GetName())));
+        mDir.setZ(aStream->ParseSingle(QString("%1 dir z").arg(GetName())));
+
+        mOrigin.setX(aStream->ParseSingle(QString("%1 origin x").arg(GetName())));
+        mOrigin.setY(aStream->ParseSingle(QString("%1 origin y").arg(GetName())));
+        mOrigin.setZ(aStream->ParseSingle(QString("%1 origin z").arg(GetName())));
+
+        mRadius             = aStream->ParseSingle(QString("%1 radius").arg(GetName()));
+        mCosHalfFovOuter    = aStream->ParseSingle(QString("%1 cos half fov outer").arg(GetName()));
+        mCosHalfFovInner    = aStream->ParseSingle(QString("%1 cos half fov inner").arg(GetName()));
+        mCosHalfFovExpanded = aStream->ParseSingle(QString("%1 cos half fov expanded").arg(GetName()));
+        mRotationLimit      = aStream->ParseSingle(QString("%1 rotation limit").arg(GetName()));
+        mTranslationLimit   = aStream->ParseSingle(QString("%1 translation limit").arg(GetName()));
+
+        mDefName.ParseData(aStream);
+    }
 }
 
 quint8 XComPrimaryLight::GetType() const
@@ -130,11 +143,6 @@ float XComPrimaryLight::GetTranslationLimit() const
     return mTranslationLimit;
 }
 
-XString* XComPrimaryLight::GetDefName() const
-{
-    return mDefName;
-}
-
 void XComPrimaryLight::SetType(quint8 aType)
 {
     mType = aType;
@@ -199,15 +207,3 @@ void XComPrimaryLight::SetTranslationLimit(float aTranslationLimit)
 {
     mTranslationLimit = aTranslationLimit;
 }
-
-void XComPrimaryLight::SetDefName(XString* aDefName)
-{
-    mDefName = aDefName;
-}
-
-void XComPrimaryLight::SetDefName(const QString aDefName)
-{
-    if (mDefName != nullptr) {
-        mDefName->SetString(aDefName);
-    }
-}

libs/xassets/xcomprimarylight.h

@@ -29,12 +29,11 @@ public:
     float GetCosHalfFovExpanded() const;
     float GetRotationLimit() const;
     float GetTranslationLimit() const;
-    XString* GetDefName() const;
 
-    static XComPrimaryLightArray* ParseArray(QDataStream *aStream, int aCount);
+    static XComPrimaryLightArray* ParseArray(XDataStream *aStream, int aCount);
 
     virtual void Clear() override;
-    virtual void ParseData(QDataStream *aStream) override;
+    virtual void ParseData(XDataStream *aStream) override;
 
 public slots:
     void SetType(quint8 aType);
@@ -50,8 +49,6 @@ public slots:
     void SetCosHalfFovExpanded(float aCosHalfFovExpanded);
     void SetRotationLimit(float aRotationLimit);
     void SetTranslationLimit(float aTranslationLimit);
-    void SetDefName(XString* aDefName);
-    void SetDefName(const QString aDefName);
 
 private:
     quint8    mType;
@@ -67,7 +64,7 @@ private:
     float     mCosHalfFovExpanded;
     float     mRotationLimit;
     float     mTranslationLimit;
-    XString*  mDefName;
+    XString   mDefName;
 };
 
 #endif // XCOMPRIMARYLIGHT_H

libs/xassets/xcomworld.cpp

@@ -8,7 +8,7 @@ XComWorld::XComWorld()
     , mPrimaryLights(new XComPrimaryLightArray())
 {
     SetType(ASSET_TYPE_COMWORLD);
-    SetName("ComWorld");
+    SetName("Com World");
 }
 
 XComWorld::~XComWorld()
@@ -27,7 +27,7 @@ void XComWorld::Clear()
     delete mName;
 }
 
-void XComWorld::ParseData(QDataStream *aStream)
+void XComWorld::ParseData(XDataStream *aStream)
 {
     mName->ParsePtr(aStream, false);
 

libs/xassets/xcomworld.h

@@ -15,7 +15,7 @@ public:
     ~XComWorld();
 
     virtual void Clear() override;
-    virtual void ParseData(QDataStream *aStream) override;
+    virtual void ParseData(XDataStream *aStream) override;
 
     QString GetName() const;
     bool IsInUse() const;

libs/xassets/xcplane.cpp

@@ -8,7 +8,7 @@ XCPlane::XCPlane()
     , mSignbits(0)
     , mPad()
 {
-    
+    SetName("C Plane");
 }
 
 XCPlane::~XCPlane()
@@ -16,19 +16,18 @@ XCPlane::~XCPlane()
     
 }
 
-void XCPlane::ParseData(QDataStream *aStream)
+void XCPlane::ParseData(XDataStream *aStream)
 {
     if (GetPtr() == -1)
     {
-        *aStream
+        mNormal.setX(aStream->ParseSingle(QString("%1 normal x").arg(GetName())));
-            >> mNormal[0]
+        mNormal.setY(aStream->ParseSingle(QString("%1 normal y").arg(GetName())));
-            >> mNormal[1]
+        mNormal.setZ(aStream->ParseSingle(QString("%1 normal z").arg(GetName())));
-            >> mNormal[2]
+        mDist = aStream->ParseSingle(QString("%1 dist").arg(GetName()));
-            >> mDist
+        mType = aStream->ParseUInt8(QString("%1 type").arg(GetName()));
-            >> mType
+        mSignbits = aStream->ParseUInt8(QString("%1 signbits").arg(GetName()));
-            >> mSignbits
+        mPad[0] = aStream->ParseUInt8(QString("%1 pad 0").arg(GetName()));
-            >> mPad[0]
+        mPad[1] = aStream->ParseUInt8(QString("%1 pad 1").arg(GetName()));
-            >> mPad[1];
     }
 }
 

libs/xassets/xcplane.h

@@ -12,7 +12,7 @@ public:
     XCPlane();
     ~XCPlane();
 
-    virtual void ParseData(QDataStream* aStream) override;
+    virtual void ParseData(XDataStream* aStream) override;
     virtual void Clear() override;
 
 private:

libs/xassets/xcstaticmodel.cpp

@@ -9,6 +9,7 @@ XCStaticModel::XCStaticModel()
     , mAbsmin()
     , mAbsmax()
 {
+    SetName("C Static Model");
 }
 
 XCStaticModel::~XCStaticModel()
@@ -16,36 +17,40 @@ XCStaticModel::~XCStaticModel()
 
 }
 
-void XCStaticModel::ParseData(QDataStream *aStream) {
+void XCStaticModel::ParseData(XDataStream *aStream)
-    if (GetPtr() == -1) {
+{
-        // Parse writable
+    if (GetPtr() == -1)
+    {
         mWritable.ParseData(aStream);
 
         aStream->skipRawData(2);
 
-        qint32 xModelPtr;
+        qint32 xModelPtr = aStream->ParseInt32(QString("%1 model ptr").arg(GetName()));
-        *aStream
-            >> xModelPtr
-            >> mOrigin[0]
-            >> mOrigin[1]
-            >> mOrigin[2];
 
-        // Parse invScaledAxis
+        mOrigin.setX(aStream->ParseSingle(QString("%1 origin x").arg(GetName())));
-        for (int i = 0; i < 3; ++i) {
+        mOrigin.setY(aStream->ParseSingle(QString("%1 origin y").arg(GetName())));
-            *aStream
+        mOrigin.setZ(aStream->ParseSingle(QString("%1 origin z").arg(GetName())));
-                >> mInvScaledAxis[i][0]
+
-                >> mInvScaledAxis[i][1]
+        if (xModelPtr)
-                >> mInvScaledAxis[i][2];
+        {
+            mModel.ParsePtr(aStream, false);
+            mModel.ParseData(aStream);
         }
 
-        // Parse absmin and absmax
+        for (int i = 0; i < 3; ++i)
-        *aStream
+        {
-            >> mAbsmin[0]
+            mInvScaledAxis[i].setX(aStream->ParseSingle(QString("%1 inv scaled axis[%2] x").arg(GetName()).arg(i)));
-            >> mAbsmin[1]
+            mInvScaledAxis[i].setY(aStream->ParseSingle(QString("%1 inv scaled axis[%2] y").arg(GetName()).arg(i)));
-            >> mAbsmin[2]
+            mInvScaledAxis[i].setZ(aStream->ParseSingle(QString("%1 inv scaled axis[%2] z").arg(GetName()).arg(i)));
-            >> mAbsmax[0]
+        }
-            >> mAbsmax[1]
+
-            >> mAbsmax[2];
+        mAbsmin.setX(aStream->ParseSingle(QString("%1 absmin x").arg(GetName())));
+        mAbsmin.setY(aStream->ParseSingle(QString("%1 absmin y").arg(GetName())));
+        mAbsmin.setZ(aStream->ParseSingle(QString("%1 absmin z").arg(GetName())));
+
+        mAbsmax.setX(aStream->ParseSingle(QString("%1 absmax x").arg(GetName())));
+        mAbsmax.setY(aStream->ParseSingle(QString("%1 absmax y").arg(GetName())));
+        mAbsmax.setZ(aStream->ParseSingle(QString("%1 absmax z").arg(GetName())));
     }
 }
 

libs/xassets/xcstaticmodel.h

@@ -11,7 +11,7 @@ public:
     explicit XCStaticModel();
     ~XCStaticModel();
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
 private:

libs/xassets/xcstaticmodelwritable.cpp

@@ -4,6 +4,7 @@ XCStaticModelWritable::XCStaticModelWritable()
     : XAsset()
     , mNextModelInWorldSector(0)
 {
+    SetName("C Static Model Writable");
 }
 
 XCStaticModelWritable::~XCStaticModelWritable()
@@ -11,7 +12,7 @@ XCStaticModelWritable::~XCStaticModelWritable()
 
 }
 
-void XCStaticModelWritable::ParseData(QDataStream *aStream) {
+void XCStaticModelWritable::ParseData(XDataStream *aStream) {
     if (GetPtr() == -1) {
         *aStream >> mNextModelInWorldSector;
     }

libs/xassets/xcstaticmodelwritable.h

@@ -9,7 +9,7 @@ public:
     explicit XCStaticModelWritable();
     ~XCStaticModelWritable();
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
     quint32 GetNextModelInWorldSector() const;
     void SetNextModelInWorldSector(quint32 nextModel);

libs/xassets/xd3dbasetexture.cpp

@@ -6,17 +6,14 @@ XD3DBaseTexture::XD3DBaseTexture()
     , mFormat()
     , mResource()
 {
-    
+    SetName("D3D Base Texture");
 }
 
-XD3DBaseTexture::~XD3DBaseTexture()
+void XD3DBaseTexture::ParseData(XDataStream *aStream)
 {
+    Q_UNUSED(aStream);
 
-}
+    // TODO: Fill in XD3DBaseTexture::ParseData
-
-void XD3DBaseTexture::ParseData(QDataStream *aStream)
-{
-    
 }
 
 void XD3DBaseTexture::Clear()

libs/xassets/xd3dbasetexture.h

@@ -9,9 +9,9 @@ class XD3DBaseTexture : public XAsset
 {
 public:
     XD3DBaseTexture();
-    ~XD3DBaseTexture();
+    ~XD3DBaseTexture() = default;
 
-    virtual void ParseData(QDataStream* aStream) override;
+    virtual void ParseData(XDataStream* aStream) override;
     virtual void Clear() override;
 
 private:

libs/xassets/xd3dcubetexture.cpp

@@ -1,33 +0,0 @@
-#include "xgfximageloaddef.h"
-
-#include "xgfxtexture.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/xd3dindexbuffer.cpp

@@ -5,16 +5,25 @@ XD3DIndexBuffer::XD3DIndexBuffer()
     , mAddress(0)
     , mSize(0)
 {
-    
+    SetName("D3D Index Buffer");
 }
 
-void XD3DIndexBuffer::ParseData(QDataStream *aStream)
+void XD3DIndexBuffer::ParseData(XDataStream *aStream)
 {
     XD3DResource::ParseData(aStream);
 
-    *aStream
+    *aStream >> mAddress;
-        >> mAddress
+    if (IsDebug())
-        >> mSize;
+    {
+        qDebug() << QString("[%1] mAddress = %2").arg(aStream->device()->pos(), 10, 10, QChar('0')).arg(mAddress);
+    }
+
+
+    *aStream >> mSize;
+    if (IsDebug())
+    {
+        qDebug() << QString("[%1] mSize = %2").arg(aStream->device()->pos(), 10, 10, QChar('0')).arg(mSize);
+    }
 }
 
 void XD3DIndexBuffer::Clear()

libs/xassets/xd3dindexbuffer.h

@@ -8,7 +8,7 @@ class XD3DIndexBuffer : public XD3DResource
 public:
     explicit XD3DIndexBuffer();
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
 private:

libs/xassets/xd3dresource.cpp

@@ -9,7 +9,7 @@ XD3DResource::XD3DResource()
     , mIdentifier(0)
     , mBaseFlush(0)
 {
-
+    SetName("D3D Resource");
 }
 
 XD3DResource::~XD3DResource()
@@ -17,15 +17,43 @@ XD3DResource::~XD3DResource()
 
 }
 
-void XD3DResource::ParseData(QDataStream *aStream)
+void XD3DResource::ParseData(XDataStream *aStream)
 {
-    *aStream
+    *aStream >> mCommon;
-        >> mCommon
+    if (IsDebug())
-        >> mReferenceCount
+    {
-        >> mFence
+        qDebug() << QString("[%1] mCommon = %2").arg(aStream->device()->pos(), 10, 10, QChar('0')).arg(mCommon);
-        >> mReadFence
+    }
-        >> mIdentifier
+
-        >> mBaseFlush;
+    *aStream >> mReferenceCount;
+    if (IsDebug())
+    {
+        qDebug() << QString("[%1] mReferenceCount = %2").arg(aStream->device()->pos(), 10, 10, QChar('0')).arg(mReferenceCount);
+    }
+
+    *aStream >> mFence;
+    if (IsDebug())
+    {
+        qDebug() << QString("[%1] mFence = %2").arg(aStream->device()->pos(), 10, 10, QChar('0')).arg(mFence);
+    }
+
+    *aStream >> mReadFence;
+    if (IsDebug())
+    {
+        qDebug() << QString("[%1] mReadFence = %2").arg(aStream->device()->pos(), 10, 10, QChar('0')).arg(mReadFence);
+    }
+
+    *aStream >> mIdentifier;
+    if (IsDebug())
+    {
+        qDebug() << QString("[%1] mIdentifier = %2").arg(aStream->device()->pos(), 10, 10, QChar('0')).arg(mIdentifier);
+    }
+
+    *aStream >> mBaseFlush;
+    if (IsDebug())
+    {
+        qDebug() << QString("[%1] mBaseFlush = %2").arg(aStream->device()->pos(), 10, 10, QChar('0')).arg(mBaseFlush);
+    }
 }
 
 void XD3DResource::Clear()

libs/xassets/xd3dresource.h

@@ -6,10 +6,10 @@
 class XD3DResource : public XAsset
 {
 public:
-    XD3DResource();
+    explicit XD3DResource();
     ~XD3DResource();
 
-    virtual void ParseData(QDataStream* aStream) override;
+    virtual void ParseData(XDataStream* aStream) override;
     virtual void Clear() override;
 
 private:

libs/xassets/xd3dvertexbuffer.cpp

@@ -4,12 +4,14 @@ XD3DVertexBuffer::XD3DVertexBuffer()
     : XD3DResource()
     , mFormat()
 {
-    
+    SetName("D3D Vertex Buffer");
 }
 
-void XD3DVertexBuffer::ParseData(QDataStream *aStream)
+void XD3DVertexBuffer::ParseData(XDataStream *aStream)
 {
-    
+    XD3DResource::ParseData(aStream);
+
+    mFormat.ParseData(aStream);
 }
 
 void XD3DVertexBuffer::Clear()

libs/xassets/xd3dvertexbuffer.h

@@ -9,7 +9,7 @@ class XD3DVertexBuffer : XD3DResource
 public:
     explicit XD3DVertexBuffer();
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
 private:

libs/xassets/xdmaterial.cpp

@@ -2,7 +2,9 @@
 #include "xstring.h"
 
 XDMaterial::XDMaterial()
-    : XAsset() {
+    : XAsset()
+{
+    SetName("D Material");
 }
 
 XDMaterial::~XDMaterial()
@@ -10,7 +12,7 @@ XDMaterial::~XDMaterial()
 
 }
 
-void XDMaterial::ParseData(QDataStream *aStream) {
+void XDMaterial::ParseData(XDataStream *aStream) {
     if (GetPtr() == -1) {
         mMaterial = XString::ParseCustom(aStream);
 

libs/xassets/xdmaterial.h

@@ -10,7 +10,7 @@ public:
     explicit XDMaterial();
     ~XDMaterial();
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
     const QString& GetMaterial() const;
     void SetMaterial(const QString& material);

libs/xassets/xdobjanimmat.cpp

@@ -2,11 +2,11 @@
 
 XDObjAnimMat::XDObjAnimMat()
     : XAsset()
-    , mQuat()
+    , mQuat(4)
-    , mTrans()
+    , mTrans(3)
     , mTransWeight(0)
 {
-    
+    SetName("Object Animation Map");
 }
 
 XDObjAnimMat::~XDObjAnimMat()
@@ -14,19 +14,27 @@ XDObjAnimMat::~XDObjAnimMat()
     
 }
 
-void XDObjAnimMat::ParseData(QDataStream *aStream)
+void XDObjAnimMat::ParseData(XDataStream *aStream)
 {
     if (GetPtr() == -1)
     {
-        *aStream
+        for (int i = 0; i < 4; i++)
-            >> mQuat[0]
+        {
-            >> mQuat[1]
+            quint32 rawQuat;
-            >> mQuat[2]
+            *aStream >> rawQuat;
-            >> mQuat[3]
+            memcpy(&mQuat[i], &rawQuat, sizeof(mQuat[i]));
-            >> mTrans[0]
+        }
-            >> mTrans[1]
+
-            >> mTrans[2]
+        for (int i = 0; i < 3; i++)
-            >> mTransWeight;
+        {
+            quint32 rawTrans;
+            *aStream >> rawTrans;
+            memcpy(&mTrans[i], &rawTrans, sizeof(mTrans[i]));
+        }
+
+        quint32 rawTransWeight;
+        *aStream >> rawTransWeight;
+        memcpy(&mTransWeight, &rawTransWeight, sizeof(mTransWeight));
     }
 }
 

libs/xassets/xdobjanimmat.h

@@ -11,7 +11,7 @@ public:
     XDObjAnimMat();
     ~XDObjAnimMat();
 
-    virtual void ParseData(QDataStream* aStream) override;
+    virtual void ParseData(XDataStream* aStream) override;
     virtual void Clear() override;
 
 private:

libs/xassets/xdvpsplane.cpp

@@ -6,17 +6,14 @@ XDpvsPlane::XDpvsPlane()
     , mSide()
     , mPad(0)
 {
-    
+    SetName("DPVS Plane");
 }
 
-XDpvsPlane::~XDpvsPlane()
+void XDpvsPlane::ParseData(XDataStream *aStream)
 {
-    
+    Q_UNUSED(aStream);
-}
 
-void XDpvsPlane::ParseData(QDataStream *aStream)
+    // TODO: Fill in XDpvsPlane::ParseData
-{
-    
 }
 
 void XDpvsPlane::Clear()

libs/xassets/xdvpsplane.h

@@ -9,9 +9,9 @@ class XDpvsPlane : public XAsset
 {
 public:
     explicit XDpvsPlane();
-    ~XDpvsPlane();
+    ~XDpvsPlane() = default;
 
-    virtual void ParseData(QDataStream* aStream) override;
+    virtual void ParseData(XDataStream* aStream) override;
     virtual void Clear() override;
 
 private:

libs/xassets/xdynentityclient.cpp

@@ -7,7 +7,7 @@ XDynEntityClient::XDynEntityClient()
     , mLightingHandle(0)
     , mHealth(0)
 {
-    
+    SetName("Dynamic Entity Client");
 }
 
 XDynEntityClient::~XDynEntityClient()
@@ -15,7 +15,7 @@ XDynEntityClient::~XDynEntityClient()
     
 }
 
-void XDynEntityClient::ParseData(QDataStream *aStream)
+void XDynEntityClient::ParseData(XDataStream *aStream)
 {
     if (GetPtr())
     {

libs/xassets/xdynentityclient.h

@@ -9,7 +9,7 @@ public:
     explicit XDynEntityClient();
     ~XDynEntityClient();
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
 private:

libs/xassets/xdynentitycoll.cpp

@@ -7,7 +7,7 @@ XDynEntityColl::XDynEntityColl()
     , mLinkMins()
     , mLinkMaxs()
 {
-    
+    SetName("Dynamic Entity Coll");
 }
 
 XDynEntityColl::~XDynEntityColl()
@@ -15,7 +15,7 @@ XDynEntityColl::~XDynEntityColl()
     
 }
 
-void XDynEntityColl::ParseData(QDataStream *aStream)
+void XDynEntityColl::ParseData(XDataStream *aStream)
 {
 
     if (GetPtr())

libs/xassets/xdynentitycoll.h

@@ -11,7 +11,7 @@ public:
     explicit XDynEntityColl();
     ~XDynEntityColl();
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
 private:

libs/xassets/xdynentitydef.cpp

@@ -14,7 +14,7 @@ XDynEntityDef::XDynEntityDef()
     , mMass()
     , mContents(0)
 {
-    
+    SetName("Dynamic Entity Definition");
 }
 
 XDynEntityDef::~XDynEntityDef()
@@ -22,7 +22,7 @@ XDynEntityDef::~XDynEntityDef()
     
 }
 
-void XDynEntityDef::ParseData(QDataStream *aStream)
+void XDynEntityDef::ParseData(XDataStream *aStream)
 {
     if (GetPtr())
     {

libs/xassets/xdynentitydef.h

@@ -21,7 +21,7 @@ public:
     explicit XDynEntityDef();
     ~XDynEntityDef();
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
 private:

libs/xassets/xdynentitypose.cpp

@@ -5,7 +5,7 @@ XDynEntityPose::XDynEntityPose()
     , mPose()
     , mRadius(0.0f)
 {
-    
+    SetName("Dynamic Entity Pose");
 }
 
 XDynEntityPose::~XDynEntityPose()
@@ -13,7 +13,7 @@ XDynEntityPose::~XDynEntityPose()
     
 }
 
-void XDynEntityPose::ParseData(QDataStream *aStream)
+void XDynEntityPose::ParseData(XDataStream *aStream)
 {
     if (GetPtr())
     {

libs/xassets/xdynentitypose.h

@@ -10,7 +10,7 @@ public:
     explicit XDynEntityPose();
     ~XDynEntityPose();
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
 private:

libs/xassets/xeditfielddefinition.cpp

@@ -10,59 +10,25 @@ XEditFieldDefinition::XEditFieldDefinition()
     , mMaxCharsGotoNext(0)
     , mMaxPaintChars(0)
     , mPaintOffset(0)
-{}
-
-float XEditFieldDefinition::GetMinVal() const
 {
-    return mMinVal;
+    SetName("Edit Field Definition");
 }
 
-float XEditFieldDefinition::GetMaxVal() const
+XEditFieldDefinition::~XEditFieldDefinition()
 {
-    return mMaxVal;
+
 }
 
-float XEditFieldDefinition::GetDefVal() const
+void XEditFieldDefinition::ParseData(XDataStream *aStream)
 {
-    return mDefVal;
+    mMinVal = aStream->ParseSingle(QString("%1 min val").arg(GetName()));
-}
+    mMaxVal = aStream->ParseSingle(QString("%1 max val").arg(GetName()));
-
+    mDefVal = aStream->ParseSingle(QString("%1 def val").arg(GetName()));
-float XEditFieldDefinition::GetRange() const
+    mRange = aStream->ParseSingle(QString("%1 range").arg(GetName()));
-{
+    mMaxChars = aStream->ParseInt32(QString("%1 max chars").arg(GetName()));
-    return mRange;
+    mMaxCharsGotoNext = aStream->ParseInt32(QString("%1 max chars goto next").arg(GetName()));
-}
+    mMaxPaintChars = aStream->ParseInt32(QString("%1 max paint chars").arg(GetName()));
-
+    mPaintOffset = aStream->ParseInt32(QString("%1 paint offset").arg(GetName()));
-int XEditFieldDefinition::GetMaxChars() const
-{
-    return mMaxChars;
-}
-
-int XEditFieldDefinition::GetMaxCharsGotoNext() const
-{
-    return mMaxCharsGotoNext;
-}
-
-int XEditFieldDefinition::GetMaxPaintChars() const
-{
-    return mMaxPaintChars;
-}
-
-int XEditFieldDefinition::GetPaintOffset() const
-{
-    return mPaintOffset;
-}
-
-void XEditFieldDefinition::ParseData(QDataStream *aStream)
-{
-    *aStream
-        >> mMinVal
-        >> mMaxVal
-        >> mDefVal
-        >> mRange
-        >> mMaxChars
-        >> mMaxCharsGotoNext
-        >> mMaxPaintChars
-        >> mPaintOffset;
 }
 
 void XEditFieldDefinition::Clear()
@@ -76,43 +42,3 @@ void XEditFieldDefinition::Clear()
     mMaxPaintChars = 0;
     mPaintOffset = 0;
 }
-
-void XEditFieldDefinition::SetMinVal(float aMinVal)
-{
-    mMinVal = aMinVal;
-}
-
-void XEditFieldDefinition::SetMaxVal(float aMaxVal)
-{
-    mMaxVal = aMaxVal;
-}
-
-void XEditFieldDefinition::SetDefVal(float aDefVal)
-{
-    mDefVal = aDefVal;
-}
-
-void XEditFieldDefinition::SetRange(float aRange)
-{
-    mRange = aRange;
-}
-
-void XEditFieldDefinition::SetMaxChars(int aMaxChars)
-{
-    mMaxChars = aMaxChars;
-}
-
-void XEditFieldDefinition::SetMaxCharsGotoNext(int aMaxCharsGotoNext)
-{
-    mMaxCharsGotoNext = aMaxCharsGotoNext;
-}
-
-void XEditFieldDefinition::SetMaxPaintChars(int aMaxPaintChars)
-{
-    mMaxPaintChars = aMaxPaintChars;
-}
-
-void XEditFieldDefinition::SetPaintOffset(int aPaintOffset)
-{
-    mPaintOffset = aPaintOffset;
-}

libs/xassets/xeditfielddefinition.h

@@ -6,34 +6,11 @@
 class XEditFieldDefinition : public XAsset
 {
 public:
-    XEditFieldDefinition();
+    explicit XEditFieldDefinition();
+    ~XEditFieldDefinition();
 
-    float GetMinVal() const;
+    void ParseData(XDataStream* aStream) override;
-    void SetMinVal(float aMinVal);
+    void Clear() override;
-
-    float GetMaxVal() const;
-    void SetMaxVal(float aMaxVal);
-
-    float GetDefVal() const;
-    void SetDefVal(float aDefVal);
-
-    float GetRange() const;
-    void SetRange(float aRange);
-
-    int GetMaxChars() const;
-    void SetMaxChars(int aMaxChars);
-
-    int GetMaxCharsGotoNext() const;
-    void SetMaxCharsGotoNext(int aMaxCharsGotoNext);
-
-    int GetMaxPaintChars() const;
-    void SetMaxPaintChars(int aMaxPaintChars);
-
-    int GetPaintOffset() const;
-    void SetPaintOffset(int aPaintOffset);
-
-    virtual void ParseData(QDataStream* aStream);
-    virtual void Clear();
 
 private:
     float mMinVal;

libs/xassets/xeffectdef.cpp

@@ -11,7 +11,7 @@ XEffectDef::XEffectDef()
     , mElemDefCountEmission(0)
     , mElemDefs()
 {
-
+    SetName("Effect Definition");
 }
 
 XEffectDef::~XEffectDef()
@@ -31,7 +31,9 @@ void XEffectDef::Clear()
     mElemDefs.clear();
 }
 
-void XEffectDef::ParseData(QDataStream *aStream)
+void XEffectDef::ParseData(XDataStream *aStream)
 {
+    Q_UNUSED(aStream);
 
+    // TODO: Fill in XEffectDef::ParseData
 }

libs/xassets/xeffectdef.h

@@ -13,7 +13,7 @@ public:
     ~XEffectDef();
 
     void Clear() override;
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
 private:
     QString mName;

libs/xassets/xeffectdefref.cpp

@@ -3,29 +3,27 @@
 
 XEffectDefRef::XEffectDefRef()
     : XAsset()
-    , mHandlePtr(0)
     , mHandle(new XEffectDef())
-    , mNamePtr(0)
+    , mName()
-    , mName("")
 {
-    
+    SetName("Effect Definition Reference");
 }
 
 XEffectDefRef::~XEffectDefRef()
 {
-    
+    delete mHandle;
+}
+
+void XEffectDefRef::ParseData(XDataStream *aStream)
+{
+    Q_UNUSED(aStream);
+
+    // TODO: Fill in XEffectDefRef::ParseData
 }
 
 void XEffectDefRef::Clear()
 {
-    mHandlePtr = 0;
+    delete mHandle;
     mHandle = new XEffectDef();
-
+    mName.Clear();
-    mNamePtr = 0;
-    mName = "";
-}
-
-void XEffectDefRef::ParseData(QDataStream *aStream)
-{
-    
 }

libs/xassets/xeffectdefref.h

@@ -2,6 +2,7 @@
 #define XEFFECTDEFREF_H
 
 #include "xasset.h"
+#include "xstring.h"
 
 #include <QString>
 
@@ -11,17 +12,14 @@ class XEffectDefRef : public XAsset
 {
 public:
     explicit XEffectDefRef();
-    ~XEffectDefRef();
+    ~XEffectDefRef() override;
 
     void Clear() override;
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
 private:
-    qint32 mHandlePtr;
+    XEffectDef* mHandle;
-    const XEffectDef *mHandle;
+    XString mName;
-
-    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/xentryinternaldata.cpp

@@ -5,17 +5,14 @@ XEntryInternalData::XEntryInternalData()
     , mOp()
     , mOperand()
 {
-    
+    SetName("Entry Internal Data");
 }
 
-XEntryInternalData::~XEntryInternalData()
+void XEntryInternalData::ParseData(XDataStream *aStream)
 {
-    
+    Q_UNUSED(aStream);
-}
 
-void XEntryInternalData::ParseData(QDataStream *aStream)
+    // TODO: Fill in XEntryInternalData::ParseData
-{
-    
 }
 
 void XEntryInternalData::Clear()

libs/xassets/xentryinternaldata.h

@@ -9,9 +9,9 @@ class XEntryInternalData : public XAsset
 {
 public:
     explicit XEntryInternalData();
-    ~XEntryInternalData();
+    ~XEntryInternalData() = default;
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
 private:

libs/xassets/xexpressionentry.cpp

@@ -5,17 +5,14 @@ XExpressionEntry::XExpressionEntry()
     , mType(0)
     , mData()
 {
-    
+    SetName("Expression Entry");
 }
 
-XExpressionEntry::~XExpressionEntry()
+void XExpressionEntry::ParseData(XDataStream *aStream)
 {
-    
+    Q_UNUSED(aStream);
-}
 
-void XExpressionEntry::ParseData(QDataStream *aStream)
+    // TODO: Fill in XExpressionEntry::ParseData
-{
-    
 }
 
 void XExpressionEntry::Clear()

libs/xassets/xexpressionentry.h

@@ -8,9 +8,9 @@ class XExpressionEntry : public XAsset
 {
 public:
     explicit XExpressionEntry();
-    ~XExpressionEntry();
+    ~XExpressionEntry() = default;
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
 private:

libs/xassets/xfile.cpp

@@ -5,10 +5,10 @@
 XFile::XFile()
     : XAsset()
 {
-
+    SetName("File");
 }
 
-void XFile::ParseData(QDataStream *aStream)
+void XFile::ParseData(XDataStream *aStream)
 {
     quint32 contentLength;
     *aStream

libs/xassets/xfile.h

@@ -8,7 +8,7 @@ class XFile : public XAsset
 public:
     explicit XFile();
 
-    virtual void ParseData(QDataStream* aStream) override;
+    virtual void ParseData(XDataStream* aStream) override;
     virtual void Clear() override;
 
 private:

libs/xassets/xfont.cpp

@@ -28,7 +28,7 @@ void XFont::Clear()
     mGlyphs.clear();
 }
 
-void XFont::ParseData(QDataStream *aStream)
+void XFont::ParseData(XDataStream *aStream)
 {
     if (GetPtr() == -1)
     {

libs/xassets/xfont.h

@@ -12,7 +12,7 @@ public:
     ~XFont();
 
     void Clear() override;
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
 private:
     XString mFontName;

libs/xassets/xfxeffectdef.cpp

@@ -12,7 +12,7 @@ XFxEffectDef::XFxEffectDef()
     , mElemDefs()
 {
     SetType(ASSET_TYPE_FX);
-    SetName("Effect Def");
+    SetName("Effect Definition");
 }
 
 XFxEffectDef::~XFxEffectDef()
@@ -25,19 +25,18 @@ void XFxEffectDef::Clear()
     
 }
 
-void XFxEffectDef::ParseData(QDataStream *aStream)
+void XFxEffectDef::ParseData(XDataStream *aStream)
 {
     mName.ParsePtr(aStream, false);
 
     qint32 elemDefsPtr;
-    *aStream
+    mFlags = aStream->ParseInt32(QString("%1 flags").arg(GetName()));
-        >> mFlags
+    mTotalSize = aStream->ParseInt32(QString("%1 total size").arg(GetName()));
-        >> mTotalSize
+    mMsecLoopingLife = aStream->ParseInt32(QString("%1 msec looping life").arg(GetName()));
-        >> mMsecLoopingLife
+    mElemDefCountLooping = aStream->ParseInt32(QString("%1 elem def count looping").arg(GetName()));
-        >> mElemDefCountLooping
+    mElemDefCountOneShot = aStream->ParseInt32(QString("%1 elem def count one shot").arg(GetName()));
-        >> mElemDefCountOneShot
+    mElemDefCountEmission = aStream->ParseInt32(QString("%1 elem def count emission").arg(GetName()));
-        >> mElemDefCountEmission
+    elemDefsPtr = aStream->ParseInt32(QString("%1 elem defs ptr").arg(GetName()));
-        >> elemDefsPtr;
 
     mName.ParseData(aStream);
 
@@ -51,3 +50,5 @@ void XFxEffectDef::ParseData(QDataStream *aStream)
         }
     }
 }
+
+

libs/xassets/xfxeffectdef.h

@@ -11,7 +11,7 @@ public:
     ~XFxEffectDef();
 
     void Clear() override;
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
 private:
     XString mName;

libs/xassets/xfxelematlas.cpp

@@ -10,12 +10,7 @@ XFxElemAtlas::XFxElemAtlas()
     , mRowIndexBits(0)
     , mEntryCount(0)
 {
-    
+    SetName("Element Atlas");
-}
-
-XFxElemAtlas::~XFxElemAtlas()
-{
-    
 }
 
 void XFxElemAtlas::Clear()
@@ -29,7 +24,9 @@ void XFxElemAtlas::Clear()
     mEntryCount = 0;
 }
 
-void XFxElemAtlas::ParseData(QDataStream *aStream)
+void XFxElemAtlas::ParseData(XDataStream *aStream)
 {
-    
+    Q_UNUSED(aStream);
+
+    // TODO: Fill in XFxElemAtlas::ParseData
 }

libs/xassets/xfxelematlas.h

@@ -7,10 +7,10 @@ class XFxElemAtlas : public XAsset
 {
 public:
     explicit XFxElemAtlas();
-    ~XFxElemAtlas();
+    ~XFxElemAtlas() = default;
 
     void Clear() override;
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
 private:
     quint8 mBehavior;

libs/xassets/xfxelemdef.cpp

@@ -40,7 +40,7 @@ XFxElemDef::XFxElemDef()
     , mLightingFrac(0)
     , mUseItemClip(0)
 {
-
+    SetName("Element Definition");
 }
 
 XFxElemDef::~XFxElemDef()
@@ -89,70 +89,65 @@ void XFxElemDef::Clear()
     mUseItemClip = 0;
 }
 
-void XFxElemDef::ParseData(QDataStream *aStream)
+void XFxElemDef::ParseData(XDataStream *aStream)
 {
-    *aStream >> mFlags;
+    mFlags = aStream->ParseInt32(QString("%1 flags").arg(GetName()));
 
     mSpawn.ParseData(aStream);
     mSpawnRange.ParseData(aStream);
     mFadeInRange.ParseData(aStream);
     mFadeOutRange.ParseData(aStream);
 
-    *aStream >> mSpawnFrustumCullRadius;
+    mSpawnFrustumCullRadius = aStream->ParseSingle(QString("%1 spawn frustum cull radius").arg(GetName()));
 
     mSpawnDelayMsec.ParseData(aStream);
     mLifeSpanMsec.ParseData(aStream);
+
     for (int i = 0; i < 3; i++)
-    {
         mSpawnOrigin[i].ParseData(aStream);
-    }
+
     mSpawnOffsetRadius.ParseData(aStream);
     mSpawnOffsetHeight.ParseData(aStream);
+
     for (int i = 0; i < 3; i++)
-    {
         mSpawnAngles[i].ParseData(aStream);
-    }
+
     for (int i = 0; i < 3; i++)
-    {
         mAngularVelocity[i].ParseData(aStream);
-    }
+
     mInitialRotation.ParseData(aStream);
     mGravity.ParseData(aStream);
     mReflectionFactor.ParseData(aStream);
     mAtlas.ParseData(aStream);
 
     qint32 velSamplesPtr, visSamplesPtr;
-    *aStream
+    mElemType = aStream->ParseUInt8(QString("%1 elem type").arg(GetName()));
-        >> mElemType
+    mVisualCount = aStream->ParseUInt8(QString("%1 visual count").arg(GetName()));
-        >> mVisualCount
+    mVelIntervalCount = aStream->ParseUInt8(QString("%1 vel interval count").arg(GetName()));
-        >> mVelIntervalCount
+    mVisStateIntervalCount = aStream->ParseUInt8(QString("%1 vis state interval count").arg(GetName()));
-        >> mVisStateIntervalCount
+    velSamplesPtr = aStream->ParseInt32(QString("%1 vel samples ptr").arg(GetName()));
-        >> velSamplesPtr
+    visSamplesPtr = aStream->ParseInt32(QString("%1 vis samples ptr").arg(GetName()));
-        >> visSamplesPtr;
 
     mVisuals.ParseData(aStream);
 
-    *aStream
+    mCollMins.setX(aStream->ParseSingle(QString("%1 coll mins x").arg(GetName())));
-        >> mCollMins[0]
+    mCollMins.setY(aStream->ParseSingle(QString("%1 coll mins y").arg(GetName())));
-        >> mCollMins[1]
+    mCollMins.setZ(aStream->ParseSingle(QString("%1 coll mins z").arg(GetName())));
-        >> mCollMins[2]
+    mCollMaxs.setX(aStream->ParseSingle(QString("%1 coll maxs x").arg(GetName())));
-        >> mCollMaxs[0]
+    mCollMaxs.setY(aStream->ParseSingle(QString("%1 coll maxs y").arg(GetName())));
-        >> mCollMaxs[1]
+    mCollMaxs.setZ(aStream->ParseSingle(QString("%1 coll maxs z").arg(GetName())));
-        >> mCollMaxs[2];
 
     mEffectOnImpact.ParseData(aStream);
     mEffectOnDeath.ParseData(aStream);
     mEffectEmitted.ParseData(aStream);
     mEmitDist.ParseData(aStream);
     mEmitDistVariance.ParseData(aStream);
-    mEffectOnImpact.ParseData(aStream);
 
     qint32 trailDefPtr;
-    *aStream
+    trailDefPtr = aStream->ParseInt32(QString("%1 trail def ptr").arg(GetName()));
-        >> trailDefPtr
+    mSortOrder = aStream->ParseUInt8(QString("%1 sort order").arg(GetName()));
-        >> mSortOrder
+    mLightingFrac = aStream->ParseUInt8(QString("%1 lighting frac").arg(GetName()));
-        >> mLightingFrac
+    mUseItemClip = aStream->ParseUInt8(QString("%1 use item clip").arg(GetName()));
-        >> mUseItemClip;
 
     aStream->skipRawData(1);
 

libs/xassets/xfxelemdef.h

@@ -19,7 +19,7 @@ public:
     ~XFxElemDef();
 
     void Clear() override;
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
 private:
     int mFlags;

libs/xassets/xfxelemdefvisuals.cpp

@@ -2,30 +2,23 @@
 
 XFxElemDefVisuals::XFxElemDefVisuals()
     : XAsset()
-    , mMarkArrayPtr(0)
     , mMarkArray()
-    , mArrayPtr(0)
     , mArray()
     , mInstance()
 {
-    
+    SetName("Element Definition Visuals");
-}
-
-XFxElemDefVisuals::~XFxElemDefVisuals()
-{
-    
 }
 
 void XFxElemDefVisuals::Clear()
 {
-    mMarkArrayPtr = 0;
     mMarkArray.clear();
-    mArrayPtr = 0;
     mArray.clear();
-    mInstance = XFxElemVisuals();
+    mInstance.Clear();
 }
 
-void XFxElemDefVisuals::ParseData(QDataStream *aStream)
+void XFxElemDefVisuals::ParseData(XDataStream *aStream)
 {
-    
+    Q_UNUSED(aStream);
+
+    // TODO: Fill in XFxElemDefVisuals::ParseData
 }

libs/xassets/xfxelemdefvisuals.h

@@ -9,18 +9,14 @@ class XFxElemDefVisuals : public XAsset
 {
 public:
     explicit XFxElemDefVisuals();
-    ~XFxElemDefVisuals();
+    ~XFxElemDefVisuals() = default;
 
     void Clear() override;
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
 private:
-    qint32 mMarkArrayPtr;
     QVector<XFxElemMarkVisuals> mMarkArray;
-
-    qint32 mArrayPtr;
     QVector<XFxElemVisuals> mArray;
-
     XFxElemVisuals mInstance;
 };
 

libs/xassets/xfxelemmarkvisuals.cpp

@@ -5,12 +5,7 @@ XFxElemMarkVisuals::XFxElemMarkVisuals()
     , mMaterialPtrs()
     , mMaterials()
 {
-
+    SetName("Element Mark Visuals");
-}
-
-XFxElemMarkVisuals::~XFxElemMarkVisuals()
-{
-
 }
 
 void XFxElemMarkVisuals::Clear()
@@ -19,7 +14,9 @@ void XFxElemMarkVisuals::Clear()
     mMaterials.clear();
 }
 
-void XFxElemMarkVisuals::ParseData(QDataStream *aStream)
+void XFxElemMarkVisuals::ParseData(XDataStream *aStream)
 {
+    Q_UNUSED(aStream);
 
+    // TODO: Fill in XFxElemMarkVisuals::ParseData
 }

libs/xassets/xfxelemmarkvisuals.h

@@ -13,7 +13,7 @@ public:
     ~XFxElemMarkVisuals();
 
     void Clear() override;
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
 private:
     QVector<qint32> mMaterialPtrs;

libs/xassets/xfxelemvec3range.cpp

@@ -5,7 +5,7 @@ XFxElemVec3Range::XFxElemVec3Range()
     , mBase()
     , mAmplitude()
 {
-    
+    SetName("Element Vec3 Range");
 }
 
 XFxElemVec3Range::~XFxElemVec3Range()
@@ -19,7 +19,7 @@ void XFxElemVec3Range::Clear()
     mAmplitude = QVector3D();
 }
 
-void XFxElemVec3Range::ParseData(QDataStream *aStream)
+void XFxElemVec3Range::ParseData(XDataStream *aStream)
 {
     *aStream
         >> mBase[0]

libs/xassets/xfxelemvec3range.h

@@ -12,7 +12,7 @@ public:
     ~XFxElemVec3Range();
 
     void Clear() override;
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
 private:
     QVector3D mBase;

libs/xassets/xfxelemvelstateinframe.cpp

@@ -5,7 +5,7 @@ XFxElemVelStateInFrame::XFxElemVelStateInFrame()
     , mVelocity()
     , mTotalDelta()
 {
-    
+    SetName("Element Vel State in Frame");
 }
 
 XFxElemVelStateInFrame::~XFxElemVelStateInFrame()
@@ -19,7 +19,7 @@ void XFxElemVelStateInFrame::Clear()
     mTotalDelta.Clear();
 }
 
-void XFxElemVelStateInFrame::ParseData(QDataStream *aStream)
+void XFxElemVelStateInFrame::ParseData(XDataStream *aStream)
 {
     mVelocity.ParseData(aStream);
     mTotalDelta.ParseData(aStream);

libs/xassets/xfxelemvelstateinframe.h

@@ -11,7 +11,7 @@ public:
     ~XFxElemVelStateInFrame();
 
     void Clear() override;
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
 private:
     XFxElemVec3Range mVelocity;

libs/xassets/xfxelemvelstatesample.cpp

@@ -5,7 +5,7 @@ XFxElemVelStateSample::XFxElemVelStateSample()
     , mLocal()
     , mWorld()
 {
-    
+    SetName("Element Vel State Sample");
 }
 
 XFxElemVelStateSample::~XFxElemVelStateSample()
@@ -19,7 +19,7 @@ void XFxElemVelStateSample::Clear()
     mWorld.Clear();
 }
 
-void XFxElemVelStateSample::ParseData(QDataStream *aStream)
+void XFxElemVelStateSample::ParseData(XDataStream *aStream)
 {
     mLocal.ParseData(aStream);
     mWorld.ParseData(aStream);

libs/xassets/xfxelemvelstatesample.h

@@ -11,7 +11,7 @@ public:
     ~XFxElemVelStateSample();
 
     void Clear() override;
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
 private:
     XFxElemVelStateInFrame mLocal;

libs/xassets/xfxelemvisstatesample.cpp

@@ -5,7 +5,7 @@ XFxElemVisStateSample::XFxElemVisStateSample()
     , mBase()
     , mAmplitude()
 {
-    
+    SetName("Element Vis State Sample");
 }
 
 XFxElemVisStateSample::~XFxElemVisStateSample()
@@ -19,7 +19,7 @@ void XFxElemVisStateSample::Clear()
     mAmplitude.Clear();
 }
 
-void XFxElemVisStateSample::ParseData(QDataStream *aStream)
+void XFxElemVisStateSample::ParseData(XDataStream *aStream)
 {
     mBase.ParseData(aStream);
     mAmplitude.ParseData(aStream);

libs/xassets/xfxelemvisstatesample.h

@@ -11,7 +11,7 @@ public:
     ~XFxElemVisStateSample();
 
     void Clear() override;
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
 private:
     XFxElemVisualState mBase;

libs/xassets/xfxelemvisuals.cpp

@@ -12,7 +12,7 @@ XFxElemVisuals::XFxElemVisuals()
     , mSoundNamePtr(0)
     , mSoundName("")
 {
-    
+    SetName("Element Visuals");
 }
 
 XFxElemVisuals::~XFxElemVisuals()
@@ -37,7 +37,9 @@ void XFxElemVisuals::Clear()
     mSoundName = "";
 }
 
-void XFxElemVisuals::ParseData(QDataStream *aStream)
+void XFxElemVisuals::ParseData(XDataStream *aStream)
 {
-    
+    Q_UNUSED(aStream);
+
+    // TODO: Fill in XFxElemVisuals::ParseData
 }

libs/xassets/xfxelemvisuals.h

@@ -15,7 +15,7 @@ public:
     ~XFxElemVisuals();
 
     void Clear() override;
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
 private:
     qint32 mAnonymousPtr;

libs/xassets/xfxelemvisualstate.cpp

@@ -8,7 +8,7 @@ XFxElemVisualState::XFxElemVisualState()
     , mSize(0, 0)
     , mScale(0)
 {
-    
+    SetName("Element Visual State");
 }
 
 XFxElemVisualState::~XFxElemVisualState()
@@ -25,7 +25,7 @@ void XFxElemVisualState::Clear()
     mScale = 0;
 }
 
-void XFxElemVisualState::ParseData(QDataStream *aStream)
+void XFxElemVisualState::ParseData(XDataStream *aStream)
 {
     quint8 r, g, b, a;
     *aStream

libs/xassets/xfxelemvisualstate.h

@@ -13,7 +13,7 @@ public:
     ~XFxElemVisualState();
 
     void Clear() override;
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
 private:
     QColor mColor;

libs/xassets/xfxfloatrange.cpp

@@ -5,7 +5,7 @@ XFxFloatRange::XFxFloatRange()
     , mBase(0)
     , mAmplitude(0)
 {
-    
+    SetName("Float Range");
 }
 
 XFxFloatRange::~XFxFloatRange()
@@ -19,7 +19,9 @@ void XFxFloatRange::Clear()
     mAmplitude = 0;
 }
 
-void XFxFloatRange::ParseData(QDataStream *aStream)
+void XFxFloatRange::ParseData(XDataStream *aStream)
 {
-    
+    Q_UNUSED(aStream);
+
+    // TODO: Fill in XFxFloatRange::ParseData
 }

libs/xassets/xfxfloatrange.h

@@ -10,7 +10,7 @@ public:
     ~XFxFloatRange();
 
     void Clear() override;
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
 private:
     float mBase;

libs/xassets/xfximpactentry.cpp

@@ -7,7 +7,7 @@ XFxImpactEntry::XFxImpactEntry()
     , mFleshPtrs()
     , mFlesh()
 {
-    
+    SetName("Impact Entry");
 }
 
 XFxImpactEntry::~XFxImpactEntry()
@@ -23,7 +23,9 @@ void XFxImpactEntry::Clear()
     mFlesh.clear();
 }
 
-void XFxImpactEntry::ParseData(QDataStream *aStream)
+void XFxImpactEntry::ParseData(XDataStream *aStream)
 {
-    
+    Q_UNUSED(aStream);
+
+    // TODO: Fill in XFxImpactEntry::ParseData
 }

libs/xassets/xfximpactentry.h

@@ -11,7 +11,7 @@ public:
     ~XFxImpactEntry();
 
     void Clear() override;
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
 private:
     QVector<qint32> mNonFleshPtrs;

libs/xassets/xfximpacttable.cpp

@@ -24,7 +24,9 @@ void XFxImpactTable::Clear()
     mTable = QVector<XFxImpactEntry>();
 }
 
-void XFxImpactTable::ParseData(QDataStream *aStream)
+void XFxImpactTable::ParseData(XDataStream *aStream)
 {
-    
+    Q_UNUSED(aStream);
+
+    // TODO: Fill in XFxImpactTable::ParseData
 }

libs/xassets/xfximpacttable.h

@@ -11,7 +11,7 @@ public:
     ~XFxImpactTable();
 
     void Clear() override;
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
 private:
     qint32 mNamePtr;

libs/xassets/xfxintrange.cpp

@@ -5,7 +5,7 @@ XFxIntRange::XFxIntRange()
     , mBase(0)
     , mAmplitude(0)
 {
-    
+    SetName("Int Range");
 }
 
 XFxIntRange::~XFxIntRange()
@@ -19,7 +19,9 @@ void XFxIntRange::Clear()
     mAmplitude = 0;
 }
 
-void XFxIntRange::ParseData(QDataStream *aStream)
+void XFxIntRange::ParseData(XDataStream *aStream)
 {
-    
+    Q_UNUSED(aStream);
+
+    // TODO: Fill in XFxIntRange::ParseData
 }

libs/xassets/xfxintrange.h

@@ -10,7 +10,7 @@ public:
     ~XFxIntRange();
 
     void Clear() override;
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
 private:
     int mBase;

libs/xassets/xfxspawndef.cpp

@@ -5,7 +5,7 @@ XFxSpawnDef::XFxSpawnDef()
     , mLooping()
     , mOneShot()
 {
-    
+    SetName("Spawn Definition");
 }
 
 XFxSpawnDef::~XFxSpawnDef()
@@ -19,7 +19,9 @@ void XFxSpawnDef::Clear()
     mOneShot.Clear();
 }
 
-void XFxSpawnDef::ParseData(QDataStream *aStream)
+void XFxSpawnDef::ParseData(XDataStream *aStream)
 {
-    
+    Q_UNUSED(aStream);
+
+    // TODO: Fill in XFxSpawnDef::ParseData
 }

libs/xassets/xfxspawndef.h

@@ -12,7 +12,7 @@ public:
     ~XFxSpawnDef();
 
     void Clear() override;
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
 private:
     XFxSpawnDefLooping mLooping;

libs/xassets/xfxspawndeflooping.cpp

@@ -5,7 +5,7 @@ XFxSpawnDefLooping::XFxSpawnDefLooping()
     , mIntervalMsec(0)
     , mCount(0)
 {
-    
+    SetName("Spawn Definition Looping");
 }
 
 XFxSpawnDefLooping::~XFxSpawnDefLooping()
@@ -19,7 +19,9 @@ void XFxSpawnDefLooping::Clear()
     mCount = 0;
 }
 
-void XFxSpawnDefLooping::ParseData(QDataStream *aStream)
+void XFxSpawnDefLooping::ParseData(XDataStream *aStream)
 {
-    
+    Q_UNUSED(aStream);
+
+    // TODO: Fill in XFxSpawnDefLooping::ParseData
 }

libs/xassets/xfxspawndeflooping.h

@@ -12,7 +12,7 @@ public:
     ~XFxSpawnDefLooping();
 
     void Clear() override;
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
 private:
     int mIntervalMsec;

libs/xassets/xfxspawndefoneshot.cpp

@@ -4,7 +4,7 @@ XFxSpawnDefOneShot::XFxSpawnDefOneShot()
     : XAsset()
     , mCount()
 {
-    
+    SetName("Spawn Definition Oneshot");
 }
 
 XFxSpawnDefOneShot::~XFxSpawnDefOneShot()
@@ -17,7 +17,9 @@ void XFxSpawnDefOneShot::Clear()
     mCount.Clear();
 }
 
-void XFxSpawnDefOneShot::ParseData(QDataStream *aStream)
+void XFxSpawnDefOneShot::ParseData(XDataStream *aStream)
 {
-    
+    Q_UNUSED(aStream);
+
+    // TODO: Fill in XFxSpawnDefOneShot::ParseData
 }