libs/xassets/xboneinfo.cpp

@@ -2,7 +2,7 @@
 
 XBoneInfo::XBoneInfo()
     : XAsset()
-    , mBounds(3)
+    , mBounds()
     , mOffset()
     , mRadiusSquared(0)
 {
@@ -16,25 +16,12 @@ XBoneInfo::~XBoneInfo()
 
 void XBoneInfo::ParseData(QDataStream *aStream)
 {
-    if (GetPtr() == -1)
+    
-    {
-        *aStream
-            >> mBounds[0][0]
-            >> mBounds[0][1]
-            >> mBounds[0][2]
-            >> mBounds[1][0]
-            >> mBounds[1][1]
-            >> mBounds[1][2]
-            >> mOffset[0]
-            >> mOffset[1]
-            >> mOffset[2]
-            >> mRadiusSquared;
-    }
 }
 
 void XBoneInfo::Clear()
 {
-    mBounds.clear();
+    mBounds = QVector<QVector3D>();
     mOffset = QVector3D();
     mRadiusSquared = 0;
 }

libs/xassets/xcbrush.cpp

@@ -6,8 +6,10 @@ XCBrush::XCBrush()
     , mContents(0)
     , mMaxs()
     , mNumsides()
+    , mSidesPtr()
     , mSides()
     , mAxialMaterialNum()
+    , mBaseAdjacentSidePtr()
     , mBaseAdjacentSide()
     , mFirstAdjacentSideOffsets()
     , mEdgeCount()
@@ -22,59 +24,7 @@ XCBrush::~XCBrush()
 
 void XCBrush::ParseData(QDataStream *aStream)
 {
-    if (GetPtr() == -1)
+    
-    {
-        qint32 sidesPtr, baseAdjacentSidePtr;
-        *aStream
-            >> mMins[0]
-            >> mMins[1]
-            >> mMins[2]
-            >> mContents
-            >> mMaxs[0]
-            >> mMaxs[1]
-            >> mMaxs[2]
-            >> mNumsides
-            >> sidesPtr;
-
-        for (int i = 0; i < 3; i++)
-        {
-            *aStream
-                >> mAxialMaterialNum[i][0]
-                >> mAxialMaterialNum[i][1]
-                >> mAxialMaterialNum[i][2];
-        }
-
-        *aStream >> baseAdjacentSidePtr;
-
-        for (int i = 0; i < 3; i++)
-        {
-            *aStream
-                >> mFirstAdjacentSideOffsets[i][0]
-                >> mFirstAdjacentSideOffsets[i][1]
-                >> mFirstAdjacentSideOffsets[i][2];
-        }
-        for (int i = 0; i < 3; i++)
-        {
-            *aStream
-                >> mEdgeCount[i][0]
-                >> mEdgeCount[i][1]
-                >> mEdgeCount[i][2];
-        }
-
-        aStream->skipRawData(10);
-
-        if (sidesPtr == -1)
-        {
-            XCBrushSide newSize;
-            newSize.ParseData(aStream);
-        }
-
-        if (baseAdjacentSidePtr == -1)
-        {
-            XCBrushSide newSize;
-            newSize.ParseData(aStream);
-        }
-    }
 }
 
 void XCBrush::Clear()
@@ -83,8 +33,10 @@ void XCBrush::Clear()
     mContents = 0;
     mMaxs = QVector3D();
     mNumsides = 0;
+    mSidesPtr = 0;
     mSides = QVector<XCBrushSide>();
     mAxialMaterialNum = QVector<QVector3D>();
+    mBaseAdjacentSidePtr = 0;
     mBaseAdjacentSide = 0;
     mFirstAdjacentSideOffsets = QVector<QVector3D>();
     mEdgeCount = QVector<QVector3D>();

libs/xassets/xcbrush.h

@@ -20,8 +20,10 @@ private:
     int mContents;
     QVector3D mMaxs;
     uint mNumsides;
+    qint32 mSidesPtr;
     QVector<XCBrushSide> mSides;
     QVector<QVector3D> mAxialMaterialNum;
+    qint32 mBaseAdjacentSidePtr;
     quint8 mBaseAdjacentSide;
     QVector<QVector3D> mFirstAdjacentSideOffsets;
     QVector<QVector3D> mEdgeCount;

libs/xassets/xclipmap.cpp

@@ -70,7 +70,7 @@ void XClipMap::ParseData(QDataStream *aStream)
 
         qint32 planePtr, staticModelPtr, materialsPtr, brushSidesPtr,
             brushEdgesPtr, nodesPtr, leafsPtr, leafsBrushNodesPtr,
-            leafBrushesPtr, leafSurfacesPtr, vertPtr,
+            leafBrushesPtr, leafSurfacesPtr, vertPtr1, vertPtr2, vertPtr3,
             triIndicesPtr, triEdgeWalkablePtr, bordersPtr, partitionsPtr, aabbTreesPtr,
             cModelsPtr;
         *aStream
@@ -96,7 +96,9 @@ void XClipMap::ParseData(QDataStream *aStream)
             >> mNumLeafSurfaces
             >> leafSurfacesPtr
             >> mVertCount
-            >> vertPtr
+            >> vertPtr1
+            >> vertPtr2
+            >> vertPtr3
             >> mTriCount
             >> triIndicesPtr
             >> triEdgeWalkablePtr
@@ -112,17 +114,15 @@ void XClipMap::ParseData(QDataStream *aStream)
 
         aStream->skipRawData(2);
 
-        qint32 brushesPtr, visibilityPtr, mapEntsPtr;
+        qint32 brushesPtr, visibilityPtr, mapEntsPtr, boxBrushPtr;
         *aStream
             >> brushesPtr
             >> mNumClusters
             >> mClusterBytes
             >> visibilityPtr
             >> mVised
-            >> mapEntsPtr;
+            >> mapEntsPtr
-
+            >> boxBrushPtr;
-        mMapEnts.ParsePtr(aStream, false);
-        mBoxBrush.ParsePtr(aStream, false);
 
         mBoxModel.ParseData(aStream);
 
@@ -236,117 +236,24 @@ void XClipMap::ParseData(QDataStream *aStream)
             }
         }
 
-        if (leafSurfacesPtr)
+        // mLeafsurfaces()
-        {
+        // mVerts()
-            for (int i = 0; i < mNumLeafBrushes; i++)
+        // mTriIndices()
-            {
+        // mTriEdgeIsWalkable()
-                quint32 newBrush;
+        // mBorders()
-                *aStream >> newBrush;
+        // mPartitions()
-                mLeafSurfaces.append(newBrush);
+        // mAabbTrees()
-            }
+        // mCodels()
-        }
+        // mBrushes()
-
+        // mVisibility()
-        if (vertPtr)
+        // mMapEnts()
-        {
+        // mBoxBrush()
-            for (int i = 0; i < mVertCount; i++)
+        // mBoxModel()
-            {
+        // mDynEntCount(0)
-                QVector3D newVert;
+        // mDynEntDefList()
-                *aStream
+        // mDynEntPoseList()
-                    >> newVert[0]
+        // mDynEntClientList()
-                    >> newVert[1]
+        // mDynEntCollList()
-                    >> newVert[2];
-                mVerts.append(newVert);
-            }
-        }
-
-        if (triIndicesPtr)
-        {
-            for (int i = 0; i < mTriCount; i++)
-            {
-                quint32 newTri;
-                *aStream >> newTri;
-                mTriIndices.append(newTri);
-            }
-        }
-
-        if (triEdgeWalkablePtr)
-        {
-            aStream->readRawData(mTriEdgeIsWalkable.data(), ((3 * mTriCount + 31) >> 3) & 0xFFFFFFFC);
-        }
-
-        if (bordersPtr)
-        {
-            for (int i = 0; i < mBorderCount; i++)
-            {
-                XCollisionBorder newBorder;
-                newBorder.ParseData(aStream);
-                mBorders.append(newBorder);
-            }
-        }
-
-        if (partitionsPtr)
-        {
-            for (int i = 0; i < mPartitionCount; i++)
-            {
-                XCollisionPartition newPartition;
-                newPartition.ParseData(aStream);
-                mPartitions.append(newPartition);
-            }
-        }
-
-        if (aabbTreesPtr)
-        {
-            for (int i = 0; i < mAabbTreeCount; i++)
-            {
-                XCollisionAabbTree newTree;
-                newTree.ParseData(aStream);
-                mAabbTrees.append(newTree);
-            }
-        }
-
-        if (cModelsPtr)
-        {
-            for (int i = 0; i < mNumSubModels; i++)
-            {
-                XCModel newCModel;
-                newCModel.ParseData(aStream);
-                mCModels.append(newCModel);
-            }
-        }
-
-        if (brushesPtr)
-        {
-            for (int i = 0; i < mNumBrushes; i++)
-            {
-                XCBrush newCBrush;
-                newCBrush.ParseData(aStream);
-                mBrushes.append(newCBrush);
-            }
-        }
-
-        if (visibilityPtr)
-        {
-            aStream->readRawData(mVisibility.data(), mClusterBytes * mNumClusters);
-        }
-
-        if (mapEntsPtr)
-        {
-            mMapEnts.ParseData(aStream);
-        }
-
-        mBoxBrush.ParseData(aStream);
-
-        mDynEntDefList[0].ParseData(aStream);
-        mDynEntDefList[0].ParseData(aStream);
-
-        mDynEntPoseList[0].ParseData(aStream);
-        mDynEntPoseList[0].ParseData(aStream);
-
-        mDynEntClientList[0].ParseData(aStream);
-        mDynEntClientList[0].ParseData(aStream);
-
-        mDynEntCollList[0].ParseData(aStream);
-        mDynEntCollList[0].ParseData(aStream);
     }
 }
 

libs/xassets/xclipmap.h

@@ -61,14 +61,14 @@ private:
     QVector<quint32> mLeafBrushes;
 
     quint32 mNumLeafSurfaces;
-    QVector<quint32> mLeafSurfaces;
+    QVector<uint> mLeafSurfaces;
 
     quint32 mVertCount;
-    QVector<QVector3D> mVerts;
+    QVector<float> mVerts;
 
     int mTriCount;
     QVector<quint32> mTriIndices;
-    QByteArray mTriEdgeIsWalkable;
+    QVector<quint8> mTriEdgeIsWalkable;
 
     int mBorderCount;
     QVector<XCollisionBorder> mBorders;
@@ -89,9 +89,9 @@ private:
     int mClusterBytes;
 
     qint32 mVisibilityPtr;
-    QByteArray mVisibility;
+    QVector<quint8> mVisibility;
     int mVised;
-    XMapEnts mMapEnts;
+    QVector<XMapEnts> mMapEnts;
     XCBrush mBoxBrush;
     XCModel mBoxModel;
     QVector<quint32> mDynEntCounts;

libs/xassets/xcmodel.cpp

@@ -17,16 +17,7 @@ XCModel::~XCModel()
 
 void XCModel::ParseData(QDataStream *aStream)
 {
-    *aStream
+    
-        >> mMins[0]
-        >> mMins[1]
-        >> mMins[2]
-        >> mMaxs[0]
-        >> mMaxs[1]
-        >> mMaxs[2]
-        >> mRadius;
-
-    mLeaf.ParseData(aStream);
 }
 
 void XCModel::Clear()

libs/xassets/xcollisionaabbtreeindex.cpp

@@ -15,9 +15,7 @@ XCollisionAabbTreeIndex::~XCollisionAabbTreeIndex()
 
 void XCollisionAabbTreeIndex::ParseData(QDataStream *aStream) {
     if (GetPtr() == -1) {
-        *aStream
+        *aStream >> mFirstChildIndex;
-            >> mFirstChildIndex
-            >> mPartitionIndex;
     }
 }
 

libs/xassets/xcollisionborder.cpp

@@ -2,7 +2,7 @@
 
 XCollisionBorder::XCollisionBorder()
     : XAsset()
-    , mDistEq(3)
+    , mDistEq()
     , mZBase(0.0f)
     , mZSlope(0.0f)
     , mStart(0.0f)
@@ -18,9 +18,7 @@ XCollisionBorder::~XCollisionBorder()
 void XCollisionBorder::ParseData(QDataStream *aStream) {
     if (GetPtr() == -1) {
         *aStream
-            >> mDistEq[0]
+            >> mDistEq
-            >> mDistEq[1]
-            >> mDistEq[2]
             >> mZBase
             >> mZSlope
             >> mStart
@@ -30,7 +28,7 @@ void XCollisionBorder::ParseData(QDataStream *aStream) {
 
 void XCollisionBorder::Clear()
 {
-    mDistEq.clear();
+    mDistEq = QVector3D();
     mZBase = 0.0f;
     mZSlope = 0.0f;
     mStart = 0.0f;

libs/xassets/xcollisionborder.h

@@ -15,7 +15,7 @@ public:
     void Clear() override;
 
 private:
-    QVector<float> mDistEq;
+    QVector3D mDistEq;
     float mZBase;
     float mZSlope;
     float mStart;

libs/xassets/xcollisionpartition.cpp

@@ -17,25 +17,9 @@ XCollisionPartition::~XCollisionPartition()
 void XCollisionPartition::ParseData(QDataStream *aStream) {
     if (GetPtr() == -1) {
         *aStream
-            >> mTriCount
+            >>mTriCount
-            >> mBorderCount;
+            >>mBorderCount
-
+            >>mFirstTri;
-        aStream->skipRawData(2);
-
-        qint32 bordersPtr;
-        *aStream
-            >> mFirstTri
-            >> bordersPtr;
-
-        if (bordersPtr == -1)
-        {
-            for (int i = 0; i < mBorderCount; i++)
-            {
-                XCollisionBorder newBorder;
-                newBorder.ParseData(aStream);
-                mBorders.append(newBorder);
-            }
-        }
     }
 }
 

libs/xassets/xd3dindexbuffer.cpp

@@ -10,15 +10,10 @@ XD3DIndexBuffer::XD3DIndexBuffer()
 
 void XD3DIndexBuffer::ParseData(QDataStream *aStream)
 {
-    XD3DResource::ParseData(aStream);
+    
-
-    *aStream
-        >> mAddress
-        >> mSize;
 }
 
 void XD3DIndexBuffer::Clear()
 {
-    mAddress = 0;
+    
-    mSize = 0;
 }

libs/xassets/xdobjanimmat.cpp

@@ -16,23 +16,12 @@ XDObjAnimMat::~XDObjAnimMat()
 
 void XDObjAnimMat::ParseData(QDataStream *aStream)
 {
-    if (GetPtr() == -1)
+    
-    {
-        *aStream
-            >> mQuat[0]
-            >> mQuat[1]
-            >> mQuat[2]
-            >> mQuat[3]
-            >> mTrans[0]
-            >> mTrans[1]
-            >> mTrans[2]
-            >> mTransWeight;
-    }
 }
 
 void XDObjAnimMat::Clear()
 {
-    mQuat.clear();
+    mQuat = QVector<float>();
-    mTrans.clear();
+    mTrans = QVector<float>();
     mTransWeight = 0;
 }

libs/xassets/xdynentityclient.cpp

@@ -17,14 +17,7 @@ XDynEntityClient::~XDynEntityClient()
 
 void XDynEntityClient::ParseData(QDataStream *aStream)
 {
-    if (GetPtr())
+    
-    {
-        *aStream
-            >> mPhysObjId
-            >> mFlags
-            >> mLightingHandle
-            >> mHealth;
-    }
 }
 
 void XDynEntityClient::Clear()

libs/xassets/xdynentitycoll.cpp

@@ -17,23 +17,13 @@ XDynEntityColl::~XDynEntityColl()
 
 void XDynEntityColl::ParseData(QDataStream *aStream)
 {
-
+    
-    if (GetPtr())
-    {
-        *aStream
-            >> mSector
-            >> mNextEntInSector
-            >> mLinkMins[0]
-            >> mLinkMins[1]
-            >> mLinkMaxs[0]
-            >> mLinkMaxs[1];
-    }
 }
 
 void XDynEntityColl::Clear()
 {
     mSector = 0;
     mNextEntInSector = 0;
-    mLinkMins = QVector2D();
+    mLinkMins.clear();
-    mLinkMaxs = QVector2D();
+    mLinkMaxs.clear();
 }

libs/xassets/xdynentitycoll.h

@@ -3,7 +3,7 @@
 
 #include "xasset.h"
 
-#include <QVector2D>
+#include <QVector>
 
 class XDynEntityColl : public XAsset
 {
@@ -17,8 +17,8 @@ public:
 private:
     quint32 mSector;
     quint32 mNextEntInSector;
-    QVector2D mLinkMins;
+    QVector<float> mLinkMins;
-    QVector2D mLinkMaxs;
+    QVector<float> mLinkMaxs;
 };
 
 #endif // XDYNENTITYCOLL_H

libs/xassets/xdynentitydef.cpp

@@ -4,11 +4,15 @@ XDynEntityDef::XDynEntityDef()
     : XAsset()
     , mType()
     , mPose()
+    , mModelPtr(0)
     , mModel()
     , mBrushModel(0)
     , mPhysicsBrushModel(0)
+    , mBestroyFxPtr(0)
     , mDestroyFx()
+    , mDestroyPiecesPtr(0)
     , mDestroyPieces()
+    , mPhysPresetPtr(0)
     , mPhysPreset()
     , mHealth(0)
     , mMass()
@@ -24,32 +28,7 @@ XDynEntityDef::~XDynEntityDef()
 
 void XDynEntityDef::ParseData(QDataStream *aStream)
 {
-    if (GetPtr())
+    
-    {
-        *aStream >> mType;
-
-        mPose.ParseData(aStream);
-        mModel.ParsePtr(aStream, false);
-
-        *aStream
-            >> mBrushModel
-            >> mPhysicsBrushModel;
-
-        mDestroyFx.ParsePtr(aStream, false);
-        mDestroyPieces.ParsePtr(aStream, false);
-        mPhysPreset.ParsePtr(aStream, false);
-
-        *aStream >> mHealth;
-
-        mMass.ParseData(aStream);
-
-        *aStream >> mContents;
-
-        mModel.ParseData(aStream);
-        mDestroyFx.ParseData(aStream);
-        mDestroyPieces.ParseData(aStream);
-        mPhysPreset.ParseData(aStream);
-    }
 }
 
 void XDynEntityDef::Clear()

libs/xassets/xdynentitydef.h

@@ -27,11 +27,15 @@ public:
 private:
     XDynEntityType mType;
     XGfxPlacement mPose;
+    qint32 mModelPtr;
     XModel mModel;
     quint32 mBrushModel;
     quint32 mPhysicsBrushModel;
+    qint32 mBestroyFxPtr;
     XFxEffectDef mDestroyFx;
+    qint32 mDestroyPiecesPtr;
     XModelPieces mDestroyPieces;
+    qint32 mPhysPresetPtr;
     XPhysPreset mPhysPreset;
     int mHealth;
     XPhysMass mMass;

libs/xassets/xdynentitypose.cpp

@@ -15,16 +15,11 @@ XDynEntityPose::~XDynEntityPose()
 
 void XDynEntityPose::ParseData(QDataStream *aStream)
 {
-    if (GetPtr())
+    mPose = XGfxPlacement();
-    {
+    mRadius = 0.0f;
-        mPose.ParseData(aStream);
-
-        *aStream >> mRadius;
-    }
 }
 
 void XDynEntityPose::Clear()
 {
-    mPose.Clear();
+    
-    mRadius = 0.0f;
 }

libs/xassets/xfont.cpp

@@ -2,11 +2,11 @@
 
 XFont::XFont()
     : XAsset()
-    , mFontName()
+    , mFontName("")
     , mPixelHeight(0)
     , mGlyphCount(0)
-    , mMaterial()
+    , mMaterial(new XMaterial())
-    , mGlowMaterial()
+    , mGlowMaterial(new XMaterial())
     , mGlyphs()
 {
     SetType(ASSET_TYPE_FONT);
@@ -20,42 +20,15 @@ XFont::~XFont()
 
 void XFont::Clear()
 {
-    mFontName.Clear();
+    mFontName = "";
     mPixelHeight = 0;
     mGlyphCount = 0;
-    mMaterial.Clear();
+    delete mMaterial;
-    mGlowMaterial.Clear();
+    delete mGlowMaterial;
     mGlyphs.clear();
 }
 
 void XFont::ParseData(QDataStream *aStream)
 {
-    if (GetPtr() == -1)
+    
-    {
-        mFontName.ParsePtr(aStream, false);
-
-        qint32 glyphsPtr;
-        *aStream
-            >> mPixelHeight
-            >> mGlyphCount;
-
-        mMaterial.ParsePtr(aStream, false);
-        mGlowMaterial.ParsePtr(aStream, false);
-
-        *aStream >> glyphsPtr;
-
-        mFontName.ParseData(aStream);
-        mMaterial.ParseData(aStream);
-        mGlowMaterial.ParseData(aStream);
-
-        if (glyphsPtr == -1)
-        {
-            for (int i = 0; i < mGlyphCount; i++)
-            {
-                XGlyph newGlyph;
-                newGlyph.ParseData(aStream);
-                mGlyphs.append(newGlyph);
-            }
-        }
-    }
 }

libs/xassets/xfont.h

@@ -15,11 +15,11 @@ public:
     void ParseData(QDataStream *aStream) override;
 
 private:
-    XString mFontName;
+    QString mFontName;
     int mPixelHeight;
     int mGlyphCount;
-    XMaterial mMaterial;
+    XMaterial *mMaterial;
-    XMaterial mGlowMaterial;
+    XMaterial *mGlowMaterial;
     QVector<XGlyph> mGlyphs;
 };
 

libs/xassets/xfxeffectdef.cpp

@@ -2,7 +2,7 @@
 
 XFxEffectDef::XFxEffectDef()
     : XAsset()
-    , mName()
+    , mName("")
     , mFlags(0)
     , mTotalSize(0)
     , mMsecLoopingLife(0)
@@ -27,27 +27,5 @@ void XFxEffectDef::Clear()
 
 void XFxEffectDef::ParseData(QDataStream *aStream)
 {
-    mName.ParsePtr(aStream, false);
+    
-
-    qint32 elemDefsPtr;
-    *aStream
-        >> mFlags
-        >> mTotalSize
-        >> mMsecLoopingLife
-        >> mElemDefCountLooping
-        >> mElemDefCountOneShot
-        >> mElemDefCountEmission
-        >> elemDefsPtr;
-
-    mName.ParseData(aStream);
-
-    if (elemDefsPtr)
-    {
-        for (int i = 0; i < mElemDefCountEmission + mElemDefCountOneShot + mElemDefCountLooping; i++)
-        {
-            XFxElemDef newElemDef;
-            newElemDef.ParseData(aStream);
-            mElemDefs.append(newElemDef);
-        }
-    }
 }

libs/xassets/xfxeffectdef.h

@@ -14,7 +14,7 @@ public:
     void ParseData(QDataStream *aStream) override;
 
 private:
-    XString mName;
+    QString mName;
     int mFlags;
     int mTotalSize;
     int mMsecLoopingLife;

libs/xassets/xfxelemdef.cpp

@@ -1,4 +1,5 @@
 #include "xfxelemdef.h"
+#include "xfxtraildef.h"
 
 XFxElemDef::XFxElemDef()
     : XAsset()
@@ -10,11 +11,11 @@ XFxElemDef::XFxElemDef()
     , mSpawnFrustumCullRadius(0)
     , mSpawnDelayMsec()
     , mLifeSpanMsec()
-    , mSpawnOrigin(3)
+    , mSpawnOrigin()
     , mSpawnOffsetRadius()
     , mSpawnOffsetHeight()
-    , mSpawnAngles(3)
+    , mSpawnAngles()
-    , mAngularVelocity(3)
+    , mAngularVelocity()
     , mInitialRotation()
     , mGravity()
     , mReflectionFactor()
@@ -35,7 +36,8 @@ XFxElemDef::XFxElemDef()
     , mEffectEmitted()
     , mEmitDist()
     , mEmitDistVariance()
-    , mTrailDef()
+    , mTrailDefPtr(0)
+    , mTrailDef(new XFxTrailDef())
     , mSortOrder(0)
     , mLightingFrac(0)
     , mUseItemClip(0)
@@ -83,7 +85,8 @@ void XFxElemDef::Clear()
     mEffectEmitted.Clear();
     mEmitDist.Clear();
     mEmitDistVariance.Clear();
-    mTrailDef.Clear();
+    mTrailDefPtr = 0;
+    mTrailDef->Clear();
     mSortOrder = 0;
     mLightingFrac = 0;
     mUseItemClip = 0;
@@ -91,90 +94,5 @@ void XFxElemDef::Clear()
 
 void XFxElemDef::ParseData(QDataStream *aStream)
 {
-    *aStream >> mFlags;
+    
-
-    mSpawn.ParseData(aStream);
-    mSpawnRange.ParseData(aStream);
-    mFadeInRange.ParseData(aStream);
-    mFadeOutRange.ParseData(aStream);
-
-    *aStream >> mSpawnFrustumCullRadius;
-
-    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
-        >> mVisualCount
-        >> mVelIntervalCount
-        >> mVisStateIntervalCount
-        >> velSamplesPtr
-        >> visSamplesPtr;
-
-    mVisuals.ParseData(aStream);
-
-    *aStream
-        >> mCollMins[0]
-        >> mCollMins[1]
-        >> mCollMins[2]
-        >> mCollMaxs[0]
-        >> mCollMaxs[1]
-        >> mCollMaxs[2];
-
-    mEffectOnImpact.ParseData(aStream);
-    mEffectOnDeath.ParseData(aStream);
-    mEffectEmitted.ParseData(aStream);
-    mEmitDist.ParseData(aStream);
-    mEmitDistVariance.ParseData(aStream);
-    mEffectOnImpact.ParseData(aStream);
-
-    qint32 trailDefPtr;
-    *aStream
-        >> trailDefPtr
-        >> mSortOrder
-        >> mLightingFrac
-        >> mUseItemClip;
-
-    aStream->skipRawData(1);
-
-    if (velSamplesPtr)
-    {
-        for (int i = 0; i < mVelIntervalCount + 1; i++)
-        {
-            XFxElemVelStateSample newVelSample;
-            newVelSample.ParseData(aStream);
-            mVelSamples.append(newVelSample);
-        }
-    }
-
-    if (visSamplesPtr)
-    {
-        for (int i = 0; i < mVisStateIntervalCount + 1; i++)
-        {
-            XFxElemVisStateSample newVisSample;
-            newVisSample.ParseData(aStream);
-            mVisSamples.append(newVisSample);
-        }
-    }
-
-    // TODO: Finish this ugh
 }

libs/xassets/xfxelemdef.h

@@ -10,7 +10,8 @@
 #include "xfxelemvisstatesample.h"
 #include "xeffectdefref.h"
 #include "xfxelemdefvisuals.h"
-#include "xfxtraildef.h"
+
+class XFxTrailDef;
 
 class XFxElemDef : public XAsset
 {
@@ -56,7 +57,8 @@ private:
     XFxFloatRange mEmitDist;
     XFxFloatRange mEmitDistVariance;
 
-    XFxTrailDef mTrailDef;
+    qint32 mTrailDefPtr;
+    XFxTrailDef* mTrailDef;
 
     quint8 mSortOrder;
     quint8 mLightingFrac;

libs/xassets/xfxelemvec3range.cpp

@@ -21,11 +21,5 @@ void XFxElemVec3Range::Clear()
 
 void XFxElemVec3Range::ParseData(QDataStream *aStream)
 {
-    *aStream
+    
-        >> mBase[0]
-        >> mBase[1]
-        >> mBase[2]
-        >> mAmplitude[0]
-        >> mAmplitude[1]
-        >> mAmplitude[2];
 }

libs/xassets/xfxelemvelstateinframe.cpp

@@ -21,6 +21,5 @@ void XFxElemVelStateInFrame::Clear()
 
 void XFxElemVelStateInFrame::ParseData(QDataStream *aStream)
 {
-    mVelocity.ParseData(aStream);
+    
-    mTotalDelta.ParseData(aStream);
 }

libs/xassets/xfxelemvelstatesample.cpp

@@ -21,6 +21,5 @@ void XFxElemVelStateSample::Clear()
 
 void XFxElemVelStateSample::ParseData(QDataStream *aStream)
 {
-    mLocal.ParseData(aStream);
+    
-    mWorld.ParseData(aStream);
 }

libs/xassets/xfxelemvisstatesample.cpp

@@ -21,6 +21,5 @@ void XFxElemVisStateSample::Clear()
 
 void XFxElemVisStateSample::ParseData(QDataStream *aStream)
 {
-    mBase.ParseData(aStream);
+    
-    mAmplitude.ParseData(aStream);
 }

libs/xassets/xfxelemvisualstate.cpp

@@ -27,23 +27,5 @@ void XFxElemVisualState::Clear()
 
 void XFxElemVisualState::ParseData(QDataStream *aStream)
 {
-    quint8 r, g, b, a;
+    
-    *aStream
-        >> r
-        >> g
-        >> b
-        >> a;
-    mColor = QColor(r, g, b, a);
-
-    *aStream
-        >> mRotationDelta
-        >> mRotationTotal;
-
-    float width, height;
-    *aStream
-        >> width
-        >> height;
-    mSize = QSize(width, height);
-
-    *aStream >> mScale;
 }

libs/xassets/xgameworldmp.cpp

@@ -3,7 +3,7 @@
 
 XGameWorldMp::XGameWorldMp()
     : XAsset()
-    , mName()
+    , mName("")
 {
     SetType(ASSET_TYPE_GAMEWORLD_MP);
     SetName("GameWorld MP");
@@ -17,11 +17,19 @@ XGameWorldMp::~XGameWorldMp()
 void XGameWorldMp::ParseData(QDataStream *aStream) {
     // Parse the name string
     if (GetPtr() == -1) {
-        mName.ParsePtr(aStream);
+        mName = XString::ParseCustom(aStream);
     }
 }
 
 void XGameWorldMp::Clear()
 {
-    mName.Clear();
+    mName.clear();
+}
+
+QString XGameWorldMp::GetName() const {
+    return mName;
+}
+
+void XGameWorldMp::SetName(const QString& name) {
+    mName = name;
 }

libs/xassets/xgameworldmp.h

@@ -2,7 +2,6 @@
 #define XGAMEWORLDMP_H
 
 #include "xasset.h"
-#include "xstring.h"
 
 #include <QString>
 
@@ -15,8 +14,11 @@ public:
     void ParseData(QDataStream *aStream) override;
     void Clear() override;
 
+    QString GetName() const;
+    void SetName(const QString& name);
+
 private:
-    XString mName;
+    QString mName;
 };
 
 #endif // XGAMEWORLDMP_H

libs/xassets/xgameworldsp.cpp

@@ -3,7 +3,7 @@
 
 XGameWorldSp::XGameWorldSp()
     : XAsset()
-    , mName()
+    , mName("")
     , mPath()
 {
     SetType(ASSET_TYPE_GAMEWORLD_SP);
@@ -18,14 +18,24 @@ XGameWorldSp::~XGameWorldSp()
 void XGameWorldSp::ParseData(QDataStream *aStream) {
     // Parse the name string
     if (GetPtr() == -1) {
-        mName.ParsePtr(aStream, false);
+        mName = XString::ParseCustom(aStream);
 
+        // Parse the path data using our new XPathData class
         mPath.ParseData(aStream);
     }
 }
 
 void XGameWorldSp::Clear()
 {
-    mName.Clear();
+    mName.clear();
     mPath.Clear();
 }
+
+QString XGameWorldSp::GetName() const {
+    return mName;
+}
+
+void XGameWorldSp::SetName(const QString& name) {
+    mName = name;
+}
+

libs/xassets/xgameworldsp.h

@@ -3,7 +3,8 @@
 
 #include "xasset.h"
 #include "xpathdata.h"
-#include "xstring.h"
+
+#include <QString>
 
 class XGameWorldSp : public XAsset
 {
@@ -14,8 +15,11 @@ public:
     void ParseData(QDataStream *aStream) override;
     void Clear() override;
 
+    QString GetName() const;
+    void SetName(const QString& name);
+
 private:
-    XString mName;
+    QString mName;
     XPathData mPath;
 };
 

libs/xassets/xgfxcell.cpp

@@ -23,62 +23,7 @@ XGfxCell::~XGfxCell()
 
 void XGfxCell::ParseData(QDataStream *aStream)
 {
-    qint32 aabbTreePtr, portalsPtr, cullGroupsPtr, reflectionProbesPtr;
-    *aStream
-        >> mMins[0]
-        >> mMins[1]
-        >> mMins[2]
-        >> mMaxs[0]
-        >> mMaxs[1]
-        >> mMaxs[2]
-        >> mAabbTreeCount
-        >> aabbTreePtr
-        >> mPortalCount
-        >> portalsPtr
-        >> mCullGroupCount
-        >> cullGroupsPtr
-        >> mReflectionProbeCount
-        >> reflectionProbesPtr;
 
-    if (aabbTreePtr)
-    {
-        for (int i = 0; i < mAabbTreeCount; i++)
-        {
-            XGfxAabbTree newTree;
-            newTree.ParseData(aStream);
-            mAabbTree.append(newTree);
-        }
-    }
-
-    if (portalsPtr)
-    {
-        for (int i = 0; i < mPortalCount; i++)
-        {
-            XGfxPortal newPortal;
-            newPortal.ParseData(aStream);
-            mPortals.append(newPortal);
-        }
-    }
-
-    if (cullGroupsPtr)
-    {
-        for (int i = 0; i < mCullGroupCount; i++)
-        {
-            qint32 newCullGroup;
-            *aStream >> newCullGroup;
-            mCullGroups.append(newCullGroup);
-        }
-    }
-
-    if (reflectionProbesPtr)
-    {
-        for (int i = 0; i < mReflectionProbeCount; i++)
-        {
-            quint8 newReflectionProbe;
-            *aStream >> newReflectionProbe;
-            mReflectionProbes.append(newReflectionProbe);
-        }
-    }
 }
 
 void XGfxCell::Clear()

libs/xassets/xgfxcell.h

@@ -28,7 +28,7 @@ private:
     QVector<XGfxPortal> mPortals;
 
     int mCullGroupCount;
-    QVector<qint32> mCullGroups;
+    QVector<int> mCullGroups;
 
     quint8 mReflectionProbeCount;
     QVector<quint8> mReflectionProbes;

libs/xassets/xgfxcolor.cpp

@@ -2,18 +2,15 @@
 
 XGfxColor::XGfxColor()
     : XAsset()
-    , mArray(4)
+    , mPacked(0)
+    , mArray()
 {
     
 }
 
 void XGfxColor::ParseData(QDataStream *aStream)
 {
-    *aStream
+    
-        >> mArray[0]
-        >> mArray[1]
-        >> mArray[2]
-        >> mArray[3];
 }
 
 void XGfxColor::Clear()

libs/xassets/xgfxcolor.h

@@ -14,7 +14,8 @@ public:
     void SetColor(quint8 r, quint8 g, quint8 b, quint8 a);
 
 private:
-    QVector<quint8> mArray;
+    quint32 mPacked;
+    quint8 mArray[4];
 };
 
 #endif // XGFXCOLOR_H

libs/xassets/xgfxdrawsurf.cpp

@@ -3,21 +3,18 @@
 XGfxDrawSurf::XGfxDrawSurf()
     : XAsset()
     , mFields()
+    , mPacked(0)
 {
     
 }
 
-XGfxDrawSurf::~XGfxDrawSurf()
-{
-
-}
-
 void XGfxDrawSurf::ParseData(QDataStream *aStream)
 {
-    mFields.ParseData(aStream);
+    
 }
 
 void XGfxDrawSurf::Clear()
 {
-    mFields.Clear();
+    mFields = XGfxDrawSurfFields();
+    mPacked = 0;
 }

libs/xassets/xgfxdrawsurf.h

@@ -8,13 +8,13 @@ class XGfxDrawSurf : public XAsset
 {
 public:
     explicit XGfxDrawSurf();
-    ~XGfxDrawSurf();
 
     void ParseData(QDataStream *aStream) override;
     void Clear() override;
 
 private:
     XGfxDrawSurfFields mFields;
+    quint64 mPacked;
 };
 
 #endif // XGFXDRAWSURF_H

libs/xassets/xgfxdrawsurffields.cpp

@@ -17,20 +17,7 @@ XGfxDrawSurfFields::XGfxDrawSurfFields()
 
 void XGfxDrawSurfFields::ParseData(QDataStream *aStream)
 {
-    // Read the raw 64-bit value from the stream
+    
-    quint64 raw = 0;
-    *aStream >> raw;
-
-    // Decode bitfields from the 64-bit packed value
-    mObjectId             =  raw        & 0xFFFF;        // bits 0-15
-    mReflectionProbeIndex = (raw >> 16) & 0xFF;          // bits 16-23
-    mCustomIndex          = (raw >> 24) & 0x1F;          // bits 24-28
-    mMaterialSortedIndex  = (raw >> 29) & 0x7FF;         // bits 29-39
-    mPrepass              = (raw >> 40) & 0x3;           // bits 40-41
-    mPrimaryLightIndex    = (raw >> 42) & 0xFF;          // bits 42-49
-    mSurfType             = (raw >> 50) & 0xF;           // bits 50-53
-    mPrimarySortKey       = (raw >> 54) & 0x3F;          // bits 54-59
-    mUnused               = (raw >> 60) & 0xF;           // bits 60-63
 }
 
 void XGfxDrawSurfFields::Clear()

libs/xassets/xgfximage.cpp

@@ -28,47 +28,44 @@ XGfxImage::~XGfxImage()
 
 void XGfxImage::ParseData(QDataStream *aStream)
 {
-    if (GetPtr() == -1)
+    *aStream >> mMapType;
+
+    mTexture.ParseData(aStream);
+
+    *aStream >> mSemantic;
+
+    aStream->skipRawData(3);
+
+    mCardMemory.ParseData(aStream);
+
+    qint32 pixelsPtr;
+    *aStream
+        >> mWidth
+        >> mHeight
+        >> mDepth
+        >> mCategory
+        >> mDelayLoadPixels
+        >> pixelsPtr
+        >> mBaseSize
+        >> mStreamSlot
+        >> mStreaming;
+
+    aStream->skipRawData(1);
+
+    mName.ParsePtr(aStream);
+
+    int variableSkip = 5;
+    if (mDelayLoadPixels)
     {
-        *aStream >> mMapType;
+        variableSkip = 2;
-
-        mTexture.ParseData(aStream);
-
-        *aStream >> mSemantic;
-
-        aStream->skipRawData(3);
-
-        mCardMemory.ParseData(aStream);
-
-        qint32 pixelsPtr;
-        *aStream
-            >> mWidth
-            >> mHeight
-            >> mDepth
-            >> mCategory
-            >> mDelayLoadPixels
-            >> pixelsPtr
-            >> mBaseSize
-            >> mStreamSlot
-            >> mStreaming;
-
-        aStream->skipRawData(1);
-
-        mName.ParsePtr(aStream);
-
-        int variableSkip = 5;
-        if (mDelayLoadPixels)
-        {
-            variableSkip = 2;
-        }
-        aStream->skipRawData(variableSkip);
-        if (pixelsPtr)
-        {
-            aStream->readRawData(mPixels.data(), mCardMemory.GetPlatform());
-        }
-        // TODO: This is wrong
-        mTexture.ParseData(aStream);
     }
+    aStream->skipRawData(variableSkip);
+    if (pixelsPtr)
+    {
+        aStream->readRawData(mPixels.data(), mCardMemory.GetPlatform());
+    }
+    // TODO: This is wrong
+    mTexture.ParseData(aStream);
 }
 
 void XGfxImage::Clear()

libs/xassets/xgfxlightdef.cpp

@@ -2,8 +2,8 @@
 
 XGfxLightDef::XGfxLightDef()
     : XAsset()
-    , mName()
+    , mName(new XString())
-    , mAttenuation()
+    , mAttenuation(new XGfxLightImage())
     , mLmapLookupStart(0)
 {
     SetType(ASSET_TYPE_LIGHT_DEF);
@@ -12,22 +12,24 @@ XGfxLightDef::XGfxLightDef()
 
 XGfxLightDef::~XGfxLightDef()
 {
-
+    delete mName;
+    delete mAttenuation;
 }
 
 void XGfxLightDef::Clear()
 {
-    mName.Clear();
+    mName->Clear();
-    mAttenuation.Clear();
+    mAttenuation->Clear();
     mLmapLookupStart = 0;
 }
 
 void XGfxLightDef::ParseData(QDataStream *aStream)
 {
-    mName.ParsePtr(aStream, false);
+    mName->ParsePtr(aStream, false);
-    mAttenuation.ParseData(aStream);
+    mAttenuation->ParseData(aStream);
     *aStream >> mLmapLookupStart;
 
-    mName.ParseData(aStream);
+    mName->ParseData(aStream);
-    mAttenuation.ParseData(aStream);
+
+    //mAttenuation->
 }

libs/xassets/xgfxlightdef.h

@@ -8,15 +8,15 @@
 struct XGfxLightDef : public XAsset
 {
 public:
-    explicit XGfxLightDef();
+    XGfxLightDef();
     ~XGfxLightDef();
 
     virtual void Clear() override;
     virtual void ParseData(QDataStream *aStream) override;
 
 private:
-    XString mName;
+    XString* mName;
-    XGfxLightImage mAttenuation;
+    XGfxLightImage* mAttenuation;
     int mLmapLookupStart;
 };
 

libs/xassets/xgfxpackedvertex.cpp

@@ -14,19 +14,7 @@ XGfxPackedVertex::XGfxPackedVertex()
 
 void XGfxPackedVertex::ParseData(QDataStream *aStream)
 {
-    if (GetPtr() == -1)
+    
-    {
-        *aStream
-            >> mXYZ[0]
-            >> mXYZ[1]
-            >> mXYZ[2]
-            >> mBinormalSign;
-
-        mColor.ParseData(aStream);
-        mTexCoord.ParseData(aStream);
-        mNormal.ParseData(aStream);
-        mTangent.ParseData(aStream);
-    }
 }
 
 void XGfxPackedVertex::Clear()

libs/xassets/xgfxpackedvertex.h

@@ -6,8 +6,6 @@
 #include "xpackedtexcoords.h"
 #include "xpackedunitvec.h"
 
-#include <QVector3D>
-
 class XGfxPackedVertex : public XAsset
 {
 public:
@@ -17,7 +15,7 @@ public:
     void Clear() override;
 
 private:
-    QVector3D mXYZ;
+    float mXYZ[3];
     float mBinormalSign;
     XGfxColor mColor;
     XPackedTexCoords mTexCoord;

libs/xassets/xgfxplacement.cpp

@@ -15,14 +15,7 @@ XGfxPlacement::~XGfxPlacement()
 
 void XGfxPlacement::ParseData(QDataStream *aStream)
 {
-    *aStream
+    
-        >> mQuat[0]
-        >> mQuat[1]
-        >> mQuat[2]
-        >> mQuat[3]
-        >> mOrigin[0]
-        >> mOrigin[2]
-        >> mOrigin[3];
 }
 
 void XGfxPlacement::Clear()

libs/xassets/xgfxstatebits.cpp

@@ -2,7 +2,7 @@
 
 XGfxStateBits::XGfxStateBits()
     : XAsset()
-    , mLoadBits(2)
+    , mLoadBits()
 {
     
 }
@@ -14,15 +14,10 @@ XGfxStateBits::~XGfxStateBits()
 
 void XGfxStateBits::ParseData(QDataStream *aStream)
 {
-    if (GetPtr() == -1)
+    
-    {
-        *aStream
-            >> mLoadBits[0]
-            >> mLoadBits[1];
-    }
 }
 
 void XGfxStateBits::Clear()
 {
-    mLoadBits.clear();
+    mLoadBits = QVector<quint32>();
 }

libs/xassets/xgfxworld.cpp

@@ -3,60 +3,12 @@
 
 XGfxWorld::XGfxWorld()
     : XAsset()
-    , mName()
+    , mName("")
-    , mBaseName()
+    , mStreamingInfo()
-    , mPlaneCount(0)
-    , mNodeCount(0)
-    , mIndexCount(0)
-    , mIndices(0)
-    , mIndexBuffer()
-    , mSurfaceCount(0)
-    , mStreamInfo()
-    , mSkySurfCount(0)
-    , mSkyStartSurfs()
-    , mSkyImage()
-    , mSkySamplerState(0)
-    , mVertexCount(0)
     , mVertexData()
-    , mVertexLayerDataSize(0)
+    , mSunLightParams()
-    , mVertexLayerData()
+    , mLights()
-    , mSunParse()
-    , mSunLight()
-    , mSunColorFromBsp()
-    , mSunPrimaryLightIndex(0)
-    , mPrimaryLightCount(0)
-    , mCullGroupCount(0)
-    , mReflectionProbeCount(0)
     , mReflectionProbes()
-    , mReflectionProbeTextures()
-    , mDpvsPlanes()
-    , mCellBitsCount(0)
-    , mCells()
-    , mLightmapCount(0)
-    , mLightmaps()
-    , mLightGrid()
-    , mLightmapPrimaryTextures()
-    , mLightmapSecondaryTextures()
-    , mModelCount(0)
-    , mModels()
-    , mMins()
-    , mMaxs()
-    , mChecksum(0)
-    , mMaterialMemoryCount(0)
-    , mMaterialMemory()
-    , mSun()
-    , mOutdoorLookupMatrix()
-    , mOutdoorImage()
-    , mCellCasterBits()
-    , mSceneDynModel()
-    , mSceneDynBrush()
-    , mPrimaryLightEntityShadowVis()
-    , mPrimaryLightDynEntShadowVis()
-    , mNonSunPrimaryLightForModelDynEnt()
-    , mShadowGeom()
-    , mLightRegion()
-    , mDpvs()
-    , mDpvsDyn()
 {
     SetType(ASSET_TYPE_GFXWORLD);
     SetName("GFXWorld");
@@ -69,252 +21,35 @@ XGfxWorld::~XGfxWorld()
 
 void XGfxWorld::ParseData(QDataStream *aStream) {
     if (GetPtr() == -1) {
-        mName.ParsePtr(aStream, false);
+        mName = XString::ParseCustom(aStream);
-        mBaseName.ParsePtr(aStream, false);
 
-        qint32 indicesPtr;
+        // Parse streaming info
-        *aStream
+        mStreamingInfo.ParseData(aStream);
-            >> mPlaneCount
-            >> mNodeCount
-            >> mIndexCount
-            >> indicesPtr;
-
-        mIndexBuffer.ParseData(aStream);
-
-        *aStream >> mSurfaceCount;
-
-        mStreamInfo.SetPtr(-1);
-        mStreamInfo.ParseData(aStream);
-
-        qint32 skyStartSurfPtr, skyImagePtr;
-        *aStream
-            >> mSkySurfCount
-            >> skyStartSurfPtr
-            >> skyImagePtr
-            >> mSkySamplerState;
-
-        aStream->skipRawData(3);
-
-        *aStream >> mVertexCount;
 
+        // Parse vertex data
         mVertexData.ParseData(aStream);
 
-        *aStream >> mVertexLayerDataSize;
+        // Parse sun light params
+        mSunLightParams.ParseData(aStream);
 
-        mVertexLayerData.ParseData(aStream);
+        // Parse lights count and array
-        mSunParse.ParseData(aStream);
+        int lightCount;
-
+        *aStream >> lightCount;
-        mSunLight.ParsePtr(aStream, false);
+        for (int i = 0; i < lightCount; ++i) {
-
+            XGfxLight light;
-        float r, g, b;
+            light.ParseData(aStream);
-        *aStream
+            mLights.append(light);
-            >> r
-            >> g
-            >> b;
-        mSunColorFromBsp = QColor(r, g, b);
-
-        qint32 reflectionProbesPtr, reflectionProbeTexturesPtr;
-        *aStream
-            >> mSunPrimaryLightIndex
-            >> mPrimaryLightCount
-            >> mCullGroupCount
-            >> mReflectionProbeCount
-            >> reflectionProbesPtr
-            >> reflectionProbeTexturesPtr;
-
-        mDpvsPlanes.ParseData(aStream);
-
-        qint32 cellsPtr, lightmapsPtr;
-        *aStream
-            >> mCellBitsCount
-            >> cellsPtr
-            >> mLightmapCount
-            >> lightmapsPtr;
-
-        mLightGrid.ParseData(aStream);
-
-        qint32 lightMapsPrimaryPtr, lightmapSecondaryPtr, modelsPtr, materialMemoryPtr;
-        *aStream
-            >> lightMapsPrimaryPtr
-            >> lightmapSecondaryPtr
-            >> mModelCount
-            >> modelsPtr
-            >> mMins[0]
-            >> mMins[1]
-            >> mMins[2]
-            >> mMaxs[0]
-            >> mMaxs[1]
-            >> mMaxs[2]
-            >> mChecksum
-            >> mMaterialMemoryCount
-            >> materialMemoryPtr;
-
-        mSun.ParseData(aStream);
-
-        for (int i = 0; i < 4; i++)
-        {
-            for (int j = 0; j < 4; j++)
-            {
-                mOutdoorLookupMatrix[i][j];
-            }
         }
 
-        qint32 outdoorImagePtr, cellCasterBitsPtr, sceneDynModelPtr, sceneDynBrushPtr,
+        // Parse reflection probes count and array
-            primaryLightEntPtr, primaryLightDynPtr, nonSunPrimaryPtr, shadowGeomPtr, lightRegionPtr;
+        int probeCount;
-        *aStream
+        *aStream >> probeCount;
-            >> outdoorImagePtr
+        for (int i = 0; i < probeCount; ++i) {
-            >> cellCasterBitsPtr
+            XGfxReflectionProbe probe;
-            >> sceneDynModelPtr
+            probe.ParseData(aStream);
-            >> sceneDynBrushPtr
+            mReflectionProbes.append(probe);
-            >> primaryLightEntPtr
-            >> primaryLightDynPtr
-            >> nonSunPrimaryPtr
-            >> shadowGeomPtr
-            >> lightRegionPtr;
-
-        mDpvs.ParseData(aStream);
-        mDpvsDyn.ParseData(aStream);
-
-        mName.ParseData(aStream);
-        mBaseName.ParseData(aStream);
-
-        if (indicesPtr)
-        {
-            aStream->readRawData(mIndices.data(), 2 * mIndexCount);
-        }
-
-        //mIndexBuffer.ParseData(aStream);
-
-        if (skyStartSurfPtr)
-        {
-            for (int i = 0; i < mSkySurfCount; i++)
-            {
-                qint32 newSurface;
-                *aStream >> newSurface;
-                mSkyStartSurfs.append(newSurface);
-            }
-        }
-
-        mSkyImage.ParseData(aStream);
-        mSunLight.ParseData(aStream);
-
-        if (reflectionProbesPtr)
-        {
-            for (int i = 0; i < mReflectionProbeCount; i++)
-            {
-                XGfxReflectionProbe newProbe;
-                newProbe.ParseData(aStream);
-                mReflectionProbes.append(newProbe);
-            }
-        }
-
-        if (reflectionProbeTexturesPtr)
-        {
-            for (int i = 0; i < mReflectionProbeCount; i++)
-            {
-                XGfxTexture newProbeTexture;
-                newProbeTexture.ParseData(aStream);
-                mReflectionProbeTextures.append(newProbeTexture);
-            }
-        }
-
-        mDpvsPlanes.ParseData(aStream);
-
-        if (cellsPtr)
-        {
-            for (int i = 0; i < mDpvsPlanes.GetCellCount(); i++)
-            {
-                XGfxCell newCell;
-                newCell.ParseData(aStream);
-                mCells.append(newCell);
-            }
-        }
-
-        if (lightmapsPtr)
-        {
-            for (int i = 0; i < mLightmapCount; i++)
-            {
-                XGfxLightmapArray lightMapArray;
-                lightMapArray.ParseData(aStream);
-                mLightmaps.append(lightMapArray);
-            }
-        }
-
-        mLightGrid.ParseData(aStream);
-
-        if (lightMapsPrimaryPtr)
-        {
-            for (int i = 0; i < mLightmapCount; i++)
-            {
-                XGfxTexture primaryTexture;
-                primaryTexture.ParseData(aStream);
-                mLightmapPrimaryTextures.append(primaryTexture);
-            }
-        }
-        if (lightmapSecondaryPtr)
-        {
-            for (int i = 0; i < mLightmapCount; i++)
-            {
-                XGfxTexture secondaryTexture;
-                secondaryTexture.ParseData(aStream);
-                mLightmapSecondaryTextures.append(secondaryTexture);
-            }
-        }
-        if (modelsPtr)
-        {
-            for (int i = 0; i < mModelCount; i++)
-            {
-                XGfxBrushModel newModel;
-                newModel.ParseData(aStream);
-                mModels.append(newModel);
-            }
-        }
-        if (materialMemoryPtr)
-        {
-            for (int i = 0; i < mMaterialMemoryCount; i++)
-            {
-                XMaterialMemory newMaterialMemory;
-                newMaterialMemory.ParseData(aStream);
-                mMaterialMemory.append(newMaterialMemory);
-            }
-        }
-
-        //mVertexData.ParseData(aStream);
-        //mVertexLayerData.ParseData(aStream);
-
-        mSun.ParseData(aStream);
-        mOutdoorImage.ParseData(aStream);
-
-        if (cellCasterBitsPtr)
-        {
-            for (int i = 0; i < ((mDpvsPlanes.GetCellCount() + 31) >> 5) * mDpvsPlanes.GetCellCount(); i++)
-            {
-                quint32 casterBit;
-                *aStream >> casterBit;
-                mCellCasterBits.append(casterBit);
-            }
-        }
-
-        if (sceneDynModelPtr)
-        {
-            for (int i = 0; i < mDpvsDyn.GetClientCount(1); i++)
-            {
-                XGfxSceneDynModel dynModel;
-                dynModel.ParseData(aStream);
-                mSceneDynModel.append(dynModel);
-            }
-        }
-        if (sceneDynBrushPtr)
-        {
-            for (int i = 0; i < mDpvsDyn.GetClientCount(1); i++)
-            {
-                XGfxSceneDynBrush dynBrush;
-                dynBrush.ParseData(aStream);
-                mSceneDynBrush.append(dynBrush);
-            }
         }
     }
-    // TODO: Finish this... Double ugh
 }
 
 void XGfxWorld::Clear()

libs/xassets/xgfxworld.h

@@ -2,25 +2,10 @@
 #define XGFXWORLD_H
 
 #include "xasset.h"
-#include "xd3dindexbuffer.h"
-#include "xgfxbrushmodel.h"
-#include "xgfxcell.h"
-#include "xgfxlightgrid.h"
-#include "xgfxlightmaparray.h"
-#include "xgfxlightregion.h"
-#include "xgfxscenedynmodel.h"
-#include "xgfxscenedynbrush.h"
-#include "xgfxshadowgeometry.h"
-#include "xgfxworlddpvsdynamic.h"
-#include "xgfxworlddpvsplanes.h"
-#include "xgfxworlddpvsstatic.h"
 #include "xgfxworldstreaminfo.h"
 #include "xgfxworldvertexdata.h"
-#include "xgfxworldvertexlayerdata.h"
-#include "xmaterialmemory.h"
 #include "xsunlightparseparams.h"
 #include "xgfxlight.h"
-#include "xsunflare.h"
 #include "xgfxreflectionprobe.h"
 
 class XGfxWorld : public XAsset
@@ -33,60 +18,12 @@ public:
     void Clear() override;
 
 private:
-    XString mName;
+    QString mName;
-    XString mBaseName;
+    XGfxWorldStreamInfo mStreamingInfo;
-    qint32 mPlaneCount;
-    qint32 mNodeCount;
-    qint32 mIndexCount;
-    QByteArray mIndices;
-    XD3DIndexBuffer mIndexBuffer;
-    qint32 mSurfaceCount;
-    XGfxWorldStreamInfo mStreamInfo;
-    qint32 mSkySurfCount;
-    QVector<qint32> mSkyStartSurfs;
-    XGfxImage mSkyImage;
-    quint8 mSkySamplerState;
-    quint32 mVertexCount;
     XGfxWorldVertexData mVertexData;
-    quint32 mVertexLayerDataSize;
+    XSunLightParseParams mSunLightParams;
-    XGfxWorldVertexLayerData mVertexLayerData;
+    QVector<XGfxLight> mLights;
-    XSunLightParseParams mSunParse;
-    XGfxLight mSunLight;
-    QColor mSunColorFromBsp;
-    quint32 mSunPrimaryLightIndex;
-    quint32 mPrimaryLightCount;
-    qint32 mCullGroupCount;
-    quint32 mReflectionProbeCount;
     QVector<XGfxReflectionProbe> mReflectionProbes;
-    QVector<XGfxTexture> mReflectionProbeTextures;
-    XGfxWorldDpvsPlanes mDpvsPlanes;
-    qint32 mCellBitsCount;
-    QVector<XGfxCell> mCells;
-    qint32 mLightmapCount;
-    QVector<XGfxLightmapArray> mLightmaps;
-    XGfxLightGrid mLightGrid;
-    QVector<XGfxTexture> mLightmapPrimaryTextures;
-    QVector<XGfxTexture> mLightmapSecondaryTextures;
-    qint32 mModelCount;
-    QVector<XGfxBrushModel> mModels;
-    QVector3D mMins;
-    QVector3D mMaxs;
-    quint32 mChecksum;
-    qint32 mMaterialMemoryCount;
-    QVector<XMaterialMemory> mMaterialMemory;
-    XSunFlare mSun;
-    QVector<QVector<float>> mOutdoorLookupMatrix;
-    XGfxImage mOutdoorImage;
-    QVector<quint32> mCellCasterBits;
-    QVector<XGfxSceneDynModel> mSceneDynModel;
-    QVector<XGfxSceneDynBrush> mSceneDynBrush;
-    quint32 mPrimaryLightEntityShadowVis;
-    quint32 mPrimaryLightDynEntShadowVis[2];
-    quint8 mNonSunPrimaryLightForModelDynEnt;
-    XGfxShadowGeometry mShadowGeom;
-    XGfxLightRegion mLightRegion;
-    XGfxWorldDpvsStatic mDpvs;
-    XGfxWorldDpvsDynamic mDpvsDyn;
 };
 
 #endif // XGFXWORLD_H

libs/xassets/xgfxworlddpvsdynamic.cpp

@@ -17,11 +17,6 @@ XGfxWorldDpvsDynamic::~XGfxWorldDpvsDynamic()
     
 }
 
-uint XGfxWorldDpvsDynamic::GetClientCount(int aIndex) const
-{
-    return mDynEntClientCount[aIndex];
-}
-
 void XGfxWorldDpvsDynamic::ParseData(QDataStream *aStream)
 {
     

libs/xassets/xgfxworlddpvsdynamic.h

@@ -11,8 +11,6 @@ public:
     XGfxWorldDpvsDynamic();
     ~XGfxWorldDpvsDynamic();
 
-    uint GetClientCount(int aIndex) const;
-
     virtual void ParseData(QDataStream* aStream) override;
     virtual void Clear() override;
 

libs/xassets/xgfxworlddpvsplanes.cpp

@@ -18,11 +18,6 @@ XGfxWorldDpvsPlanes::~XGfxWorldDpvsPlanes()
     
 }
 
-int XGfxWorldDpvsPlanes::GetCellCount() const
-{
-    return aCellCount;
-}
-
 void XGfxWorldDpvsPlanes::ParseData(QDataStream *aStream)
 {
     

libs/xassets/xgfxworlddpvsplanes.h

@@ -12,8 +12,6 @@ public:
     explicit XGfxWorldDpvsPlanes();
     ~XGfxWorldDpvsPlanes();
 
-    int GetCellCount() const;
-
     void ParseData(QDataStream *aStream) override;
     void Clear() override;
 

libs/xassets/xgfxworldvertexdata.cpp

@@ -1,30 +1,51 @@
 #include "xgfxworldvertexdata.h"
 
 XGfxWorldVertexData::XGfxWorldVertexData()
-    : XAsset()
+    : XAsset() {
-    , mVertices()
-    , mWorldVertexBuffer()
-{
-
-}
-
-XGfxWorldVertexData::~XGfxWorldVertexData()
-{
-
-}
-
-void XGfxWorldVertexData::Clear()
-{
-    mVertices.clear();
-    mWorldVertexBuffer.Clear();
 }
 
 void XGfxWorldVertexData::ParseData(QDataStream *aStream) {
     if (GetPtr() == -1) {
+        // Parse vertex count
+        int vertexCount;
+        *aStream >> vertexCount;
 
-        qint32 worldVertexPtr;
+        // Clear existing data before parsing new data
-        *aStream >> worldVertexPtr;
+        mVertices.clear();
 
-        mWorldVertexBuffer.ParseData(aStream);
+        // Parse vertices
+        for (int i = 0; i < vertexCount; ++i) {
+            XGfxWorldVertex vertex;
+            vertex.ParseData(aStream);
+            mVertices.append(vertex);
+        }
+
+        // Skip D3DVertexBuffer pointer - we'll handle this appropriately later
+        qint32 bufferPtr;
+        *aStream >> bufferPtr;
+        if (bufferPtr == -1)
+        {
+
+        }
     }
 }
+
+QVector<XGfxWorldVertex>& XGfxWorldVertexData::GetVertices() {
+    return mVertices;
+}
+
+const QVector<XGfxWorldVertex>& XGfxWorldVertexData::GetVertices() const {
+    return mVertices;
+}
+
+void XGfxWorldVertexData::SetVertices(const QVector<XGfxWorldVertex>& vertices) {
+    mVertices = vertices;
+}
+
+int XGfxWorldVertexData::GetVertexBufferPtr() const {
+    return mVertexBufferPtr;
+}
+
+void XGfxWorldVertexData::SetVertexBufferPtr(int ptr) {
+    mVertexBufferPtr = ptr;
+}

libs/xassets/xgfxworldvertexdata.h

@@ -2,7 +2,6 @@
 #define XGFXWORLDVERTEXDATA_H
 
 #include "xasset.h"
-#include "xd3dvertexbuffer.h"
 #include "xgfxworldvertex.h"
 
 #include <QVector>
@@ -11,14 +10,20 @@ class XGfxWorldVertexData : public XAsset
 {
 public:
     explicit XGfxWorldVertexData();
-    ~XGfxWorldVertexData();
 
     void ParseData(QDataStream *aStream) override;
-    void Clear() override;
+
+    QVector<XGfxWorldVertex>& GetVertices();
+    const QVector<XGfxWorldVertex>& GetVertices() const;
+    void SetVertices(const QVector<XGfxWorldVertex>& vertices);
+
+    // Note: D3DVertexBuffer is a placeholder - we need to handle this appropriately
+    int GetVertexBufferPtr() const;
+    void SetVertexBufferPtr(int ptr);
 
 private:
-    QVector<XGfxWorldVertex> mVertices;
+    QVector<XGfxWorldVertex> mVertices; // Using QVector for automatic memory management
-    XD3DVertexBuffer mWorldVertexBuffer;
+    int mVertexBufferPtr = 0; // Placeholder for D3DVertexBuffer pointer
 };
 
 #endif // XGFXWORLDVERTEXDATA_H

libs/xassets/xitemdef.cpp

@@ -53,11 +53,6 @@ XItemDef::~XItemDef()
 
 }
 
-int XItemDef::GetType() const
-{
-    return mType;
-}
-
 void XItemDef::Clear()
 {
 

libs/xassets/xitemdef.h

@@ -15,8 +15,6 @@ public:
     explicit XItemDef();
     ~XItemDef();
 
-    int GetType() const;
-
     void Clear() override;
     void ParseData(QDataStream *aStream) override;
 

libs/xassets/xitemdefdata.cpp

@@ -1,78 +1,41 @@
-#include "xitemdefdata.h"
+#include "xglyph.h"
-#include "xitemdef.h"
 
-XItemDefData::XItemDefData()
+XGlyph::XGlyph()
     : XAsset()
-    , mListBox()
+    , mLetter(0)
-    , mEditField()
+    , mX0(0)
-    , mMulti()
+    , mY0(0)
-    , mEnumDvarName()
+    , mDx(0)
-    , mParent(nullptr)
+    , mPixelWidth(0)
+    , mPixelHeight(0)
+    , mS0(0)
+    , mT0(0)
+    , mS1(0)
+    , mT1(0)
 {
-
+    
 }
 
-XItemDefData::XItemDefData(XItemDef &aParent)
+XGlyph::~XGlyph()
-    : XAsset()
-    , mListBox()
-    , mEditField()
-    , mMulti()
-    , mEnumDvarName()
-    , mParent(&aParent)
 {
-
+    
 }
 
-XItemDefData::~XItemDefData()
+void XGlyph::Clear()
 {
-    delete mParent;
+    mLetter = 0;
+    mX0 = 0;
+    mY0 = 0;
+    mDx = 0;
+    mPixelWidth = 0;
+    mPixelHeight = 0;
+    mS0 = 0;
+    mT0 = 0;
+    mS1 = 0;
+    mT1 = 0;
 }
 
-void XItemDefData::Clear()
+void XGlyph::ParseData(QDataStream *aStream)
 {
-    mListBox.Clear();
+    
-    mEditField.Clear();
-    mMulti.Clear();
-    mEnumDvarName.Clear();
-    mParent = nullptr;
-}
-
-void XItemDefData::ParseData(QDataStream *aStream)
-{
-    if (!mParent)
-    {
-        return;
-    }
-
-    mListBox.ParsePtr(aStream, false);
-    mEditField.ParsePtr(aStream, false);
-    mMulti.ParsePtr(aStream, false);
-    mEnumDvarName.ParsePtr(aStream, false);
-
-    qint32 dataPtr;
-    *aStream >> dataPtr;
-
-    switch (mParent->GetType())
-    {
-    case 6:
-        mListBox.ParseData(aStream);
-        break;
-    case 0:
-    case 4:
-    case 9:
-    case 10:
-    case 11:
-    case 14:
-    case 16:
-    case 17:
-    case 18:
-        mListBox.ParseData(aStream);
-        break;
-    case 12:
-        mMulti.ParseData(aStream);
-        break;
-    case 13:
-        mEnumDvarName.ParseData(aStream);
-        break;
-    }
 }

libs/xassets/xitemdefdata.h

@@ -6,24 +6,21 @@
 #include "xeditfielddefinition.h"
 #include "xmultidef.h"
 
-class XItemDef;
-
 class XItemDefData : public XAsset
 {
 public:
     explicit XItemDefData();
-    XItemDefData(XItemDef& aParent);
     ~XItemDefData();
 
     void Clear() override;
     void ParseData(QDataStream *aStream) override;
 
 private:
-    XListBoxDef mListBox;
+    XListBoxDef *listBox;
-    XEditFieldDefinition mEditField;
+    XEditFieldDefinition *editField;
-    XMultiDef mMulti;
+    XMultiDef *multi;
-    XString mEnumDvarName;
+    const char *enumDvarName;
-    XItemDef* mParent;
+    void *data;
 };
 
 #endif // XITEMDEFDATA_H

libs/xassets/xitemkeyhandler.cpp

@@ -3,8 +3,8 @@
 XItemKeyHandler::XItemKeyHandler()
     : XAsset()
     , mKey(0)
-    , mAction()
+    , mAction("")
-    , mNext(nullptr)
+    , mNext(new XItemKeyHandler())
 {
     
 }
@@ -16,28 +16,13 @@ XItemKeyHandler::~XItemKeyHandler()
 
 void XItemKeyHandler::ParseData(QDataStream *aStream)
 {
-    if (GetPtr() == -1)
+    
-    {
-        *aStream >> mKey;
-
-        mAction.ParsePtr(aStream, false);
-
-        qint32 nextPtr;
-        *aStream >> nextPtr;
-
-        mAction.ParseData(aStream);
-
-        if (nextPtr)
-        {
-            mNext = new XItemKeyHandler();
-            mNext->ParseData(aStream);
-        }
-    }
 }
 
 void XItemKeyHandler::Clear()
 {
     mKey = 0;
-    mAction.Clear();
+    mAction = "";
-    mNext = nullptr;
+    delete mNext;
+    mNext = new XItemKeyHandler();
 }

libs/xassets/xitemkeyhandler.h

@@ -2,7 +2,8 @@
 #define XITEMKEYHANDLER_H
 
 #include "xasset.h"
-#include "xstring.h"
+
+#include <QString>
 
 class XItemKeyHandler : public XAsset
 {
@@ -15,7 +16,7 @@ public:
 
 private:
     int mKey;
-    XString mAction;
+    QString mAction;
     XItemKeyHandler *mNext;
 };
 

libs/xassets/xlocalizeentry.cpp

@@ -33,14 +33,11 @@ void XLocalizeEntry::Clear()
 
 void XLocalizeEntry::ParseData(QDataStream *aStream)
 {
-    if (GetPtr() == -1)
+    mValue->ParsePtr(aStream, false);
-    {
+    mName->ParsePtr(aStream, false);
-        mValue->ParsePtr(aStream, false);
-        mName->ParsePtr(aStream, false);
 
-        mValue->ParseData(aStream);
+    mValue->ParseData(aStream);
-        mName->ParseData(aStream);
+    mName->ParseData(aStream);
-    }
 }
 
 void XLocalizeEntry::SetValue(XString* aValue)

libs/xassets/xmapents.cpp

@@ -2,9 +2,6 @@
 
 XMapEnts::XMapEnts()
     : XAsset()
-    , mName()
-    , mEntityString()
-    , mNumEntityChars()
 {
     SetType(ASSET_TYPE_MAP_ENTS);
     SetName("Map Ents");
@@ -17,20 +14,10 @@ XMapEnts::~XMapEnts()
 
 void XMapEnts::Clear()
 {
-    mName.Clear();
+    
-    mEntityString.Clear();
-    mNumEntityChars = 0;
 }
 
 void XMapEnts::ParseData(QDataStream *aStream)
 {
-    mName.ParsePtr(aStream, false);
+    
-    mEntityString.ParsePtr(aStream, false);
-
-    *aStream >> mNumEntityChars;
-
-    mName.ParseData(aStream);
-
-    mEntityString.SetContentLength(mNumEntityChars);
-    mEntityString.ParseData(aStream);
 }

libs/xassets/xmapents.h

@@ -7,15 +7,15 @@
 class XMapEnts : public XAsset
 {
 public:
-    explicit XMapEnts();
+    XMapEnts();
     ~XMapEnts();
 
     virtual void Clear() override;
     virtual void ParseData(QDataStream *aStream) override;
 
 private:
-    XString mName;
+    XString* mName;
-    XString mEntityString;
+    XString* mEntityString;
     int mNumEntityChars;
 };
 

libs/xassets/xmaterial.cpp

@@ -3,7 +3,7 @@
 XMaterial::XMaterial()
     : XAsset()
     , mInfo()
-    , mStateBitsEntry(26)
+    , mStateBitsEntry()
     , mTextureCount(0)
     , mConstantCount(0)
     , mStateBitsCount(0)
@@ -25,31 +25,7 @@ XMaterial::~XMaterial()
 
 void XMaterial::ParseData(QDataStream *aStream)
 {
-    mInfo.ParseData(aStream);
+    
-
-    for (int i = 0; i < 26; i++)
-    {
-        *aStream >> mStateBitsEntry[i];
-    }
-
-    *aStream
-        >> mTextureCount
-        >> mConstantCount
-        >> mStateBitsCount
-        >> mStateFlags
-        >> mCameraRegion;
-
-    aStream->skipRawData(1);
-
-    mTechniqueSet.ParsePtr(aStream, false);
-    mTextureTable.ParsePtr(aStream, false);
-    mConstantTable.ParsePtr(aStream, false);
-    mStateBitsTable.ParsePtr(aStream, false);
-
-    mTechniqueSet.ParseData(aStream);
-    mTextureTable.ParseData(aStream);
-    mConstantTable.ParseData(aStream);
-    mStateBitsTable.ParseData(aStream);
 }
 
 void XMaterial::Clear()

libs/xassets/xmaterialconstantdef.cpp

@@ -3,7 +3,7 @@
 XMaterialConstantDef::XMaterialConstantDef()
     : XAsset()
     , mNameHash(0)
-    , mName()
+    , mName("")
     , mLiteral()
 {
     
@@ -16,26 +16,12 @@ XMaterialConstantDef::~XMaterialConstantDef()
 
 void XMaterialConstantDef::ParseData(QDataStream *aStream)
 {
-    if (GetPtr() == -1)
+    
-    {
-        *aStream >> mNameHash;
-
-        QByteArray rawName(12, Qt::Uninitialized);
-        aStream->readRawData(rawName.data(), 12);
-
-        mName.SetString(QString::fromUtf8(rawName));
-
-        *aStream
-            >> mLiteral[0]
-            >> mLiteral[1]
-            >> mLiteral[2]
-            >> mLiteral[3];
-    }
 }
 
 void XMaterialConstantDef::Clear()
 {
     mNameHash = 0;
-    mName.Clear();
+    mName = "";
     mLiteral.clear();
 }

libs/xassets/xmaterialconstantdef.h

@@ -2,14 +2,13 @@
 #define XMATERIALCONSTANTDEF_H
 
 #include "xasset.h"
-#include "xstring.h"
 
 #include <QVector>
 
 class XMaterialConstantDef : public XAsset
 {
 public:
-    explicit XMaterialConstantDef();
+    XMaterialConstantDef();
     ~XMaterialConstantDef();
 
     virtual void ParseData(QDataStream* aStream) override;
@@ -17,7 +16,7 @@ public:
 
 private:
     quint32 mNameHash;
-    XString mName;
+    QString mName;
     QVector<float> mLiteral;
 };
 

libs/xassets/xmaterialinfo.cpp

@@ -2,7 +2,7 @@
 
 XMaterialInfo::XMaterialInfo()
     : XAsset()
-    , mName()
+    , mName("")
     , mGameFlags(0)
     , mSortKey(0)
     , mTextureAtlasRowCount(0)
@@ -20,20 +20,7 @@ XMaterialInfo::~XMaterialInfo()
 
 void XMaterialInfo::ParseData(QDataStream *aStream)
 {
-    mName.ParsePtr(aStream, false);
 
-    *aStream
-        >> mGameFlags
-        >> mSortKey
-        >> mTextureAtlasRowCount
-        >> mTextureAtlasColumnCount;
-
-    mDrawSurf.ParseData(aStream);
-
-    *aStream >> mSurfaceTypeBits;
-    aStream->skipRawData(4);
-
-    mName.ParseData(aStream);
 }
 
 void XMaterialInfo::Clear()

libs/xassets/xmaterialinfo.h

@@ -3,7 +3,8 @@
 
 #include "xasset.h"
 #include "xgfxdrawsurf.h"
-#include "xstring.h"
+
+#include <QString>
 
 class XMaterialInfo : public XAsset
 {
@@ -15,7 +16,7 @@ public:
     void Clear() override;
 
 private:
-    XString mName;
+    QString mName;
     quint8 mGameFlags;
     quint8 mSortKey;
     quint8 mTextureAtlasRowCount;

libs/xassets/xmaterialtechniqueset.cpp

@@ -18,44 +18,40 @@ XMaterialTechniqueSet::~XMaterialTechniqueSet()
 
 void XMaterialTechniqueSet::ParseData(QDataStream *aStream)
 {
-    if (GetPtr() == -1)
+    if (IsDebug())
     {
-        if (IsDebug())
+        qDebug() << QString("[%1] Parsing data for %2").arg(aStream->device()->pos(), 10, 10, QChar('0')).arg(GetName());
-        {
+    }
-            qDebug() << QString("[%1] Parsing data for %2").arg(aStream->device()->pos(), 10, 10, QChar('0')).arg(GetName());
+    mName.ParsePtr(aStream, false);
-        }
-        mName.ParsePtr(aStream, false);
 
-        *aStream >> mWorldVertFormat;
+    *aStream >> mWorldVertFormat;
-        if (IsDebug())
+    if (IsDebug())
-        {
+    {
-            qDebug() << QString("[%1] mWorldVertFormat = %2").arg(aStream->device()->pos(), 10, 10, QChar('0')).arg(mWorldVertFormat);
+        qDebug() << QString("[%1] mWorldVertFormat = %2").arg(aStream->device()->pos(), 10, 10, QChar('0')).arg(mWorldVertFormat);
-        }
+    }
 
-        aStream->skipRawData(3);
+    aStream->skipRawData(3);
 
-        qint32 remappedPtr;
+    qint32 remappedPtr;
-        *aStream >> remappedPtr;
+    *aStream >> remappedPtr;
-        if (IsDebug())
+    if (IsDebug())
-        {
+    {
-            qDebug() << QString("[%1] remappedPtr = %2").arg(aStream->device()->pos(), 10, 10, QChar('0')).arg(remappedPtr);
+        qDebug() << QString("[%1] remappedPtr = %2").arg(aStream->device()->pos(), 10, 10, QChar('0')).arg(remappedPtr);
 
-            qDebug() << QString("Parsing techniques.");
+        qDebug() << QString("Parsing techniques.");
-        }
+    }
-        for (int i = 0; i < 26; i++)
+    for (int i = 0; i < 26; i++)
-        {
+    {
-            XMaterialTechnique newTechnique;
+        XMaterialTechnique newTechnique;
-            newTechnique.ParsePtr(aStream, false);
+        newTechnique.ParsePtr(aStream, false);
-            mTechniques.append(newTechnique);
+        mTechniques.append(newTechnique);
-        }
+    }
 
-        mName.SetRemoveString(",");
+    mName.ParseData(aStream, ",");
-        mName.ParseData(aStream);
 
-        for (int i = 0; i < 26; i++)
+    for (int i = 0; i < 26; i++)
-        {
+    {
-            mTechniques[i].ParseData(aStream);
+        mTechniques[i].ParseData(aStream);
-        }
     }
 }
 

libs/xassets/xmaterialtexturedef.cpp

@@ -7,7 +7,7 @@ XMaterialTextureDef::XMaterialTextureDef()
     , mNameEnd(0)
     , mSamplerState(0)
     , mSemantic(0)
-    , mDefInfo(*this)
+    , mDefInfo()
 {
     
 }
@@ -17,33 +17,9 @@ XMaterialTextureDef::~XMaterialTextureDef()
     
 }
 
-quint8 XMaterialTextureDef::GetSemantic() const
-{
-    return mSemantic;
-}
-
 void XMaterialTextureDef::ParseData(QDataStream *aStream)
 {
-    if (GetPtr() == -1)
+    
-    {
-        *aStream
-            >> mNameHash
-            >> mNameStart
-            >> mNameEnd
-            >> mSamplerState
-            >> mSemantic;
-
-        mDefInfo.ParseData(aStream);
-
-        if (mSemantic == 11)
-        {
-
-        }
-        else
-        {
-
-        }
-    }
 }
 
 void XMaterialTextureDef::Clear()

libs/xassets/xmaterialtexturedef.h

@@ -10,8 +10,6 @@ public:
     XMaterialTextureDef();
     ~XMaterialTextureDef();
 
-    quint8 GetSemantic() const;
-
     virtual void ParseData(QDataStream* aStream) override;
     virtual void Clear() override;
 

libs/xassets/xmaterialtexturedefinfo.cpp

@@ -1,24 +1,13 @@
 #include "xmaterialtexturedefinfo.h"
-#include "xmaterialtexturedef.h"
 
 XMaterialTextureDefInfo::XMaterialTextureDefInfo()
     : XAsset()
     , mImage()
     , mWater()
-    , aParent(nullptr)
 {
     
 }
 
-XMaterialTextureDefInfo::XMaterialTextureDefInfo(XMaterialTextureDef &aParent)
-    : XAsset()
-    , mImage()
-    , mWater()
-    , aParent(&aParent)
-{
-
-}
-
 XMaterialTextureDefInfo::~XMaterialTextureDefInfo()
 {
 
@@ -26,18 +15,7 @@ XMaterialTextureDefInfo::~XMaterialTextureDefInfo()
 
 void XMaterialTextureDefInfo::ParseData(QDataStream *aStream)
 {
-    mImage.ParsePtr(aStream, false);
+    
-
-    if (aParent->GetSemantic() == 11) {
-        if (mImage.GetPtr() == -1)
-        {
-            mWater.ParseData(aStream);
-        }
-    }
-    else
-    {
-        mImage.ParseData(aStream);
-    }
 }
 
 void XMaterialTextureDefInfo::Clear()

libs/xassets/xmaterialtexturedefinfo.h

@@ -5,13 +5,10 @@
 #include "xgfximage.h"
 #include "xwater.h"
 
-class XMaterialTextureDef;
-
 class XMaterialTextureDefInfo : public XAsset
 {
 public:
-    explicit XMaterialTextureDefInfo();
+    XMaterialTextureDefInfo();
-    XMaterialTextureDefInfo(XMaterialTextureDef& aParent);
     ~XMaterialTextureDefInfo();
 
     virtual void ParseData(QDataStream* aStream) override;
@@ -20,7 +17,6 @@ public:
 private:
     XGfxImage mImage;
     XWater mWater;
-    XMaterialTextureDef* aParent;
 };
 
 #endif // XMATERIALTEXTUREDEFINFO_H

libs/xassets/xmenudef.cpp

@@ -5,15 +5,15 @@ XMenuDef::XMenuDef()
     : XAsset()
     , mWindow()
     , mFont()
-    , mFullScreen(0)
+    , mFullScreen()
-    , mItemCount(0)
+    , mItemCount()
-    , mFontIndex(0)
+    , mFontIndex()
-    , mCursorItem(4)
+    , mCursorItem()
-    , mFadeCycle(0)
+    , mFadeCycle()
-    , mFadeClamp(0.0f)
+    , mFadeClamp()
-    , mFadeAmount(0.0f)
+    , mFadeAmount()
-    , mFadeInAmount(0.0f)
+    , mFadeInAmount()
-    , mBlurRadius(0.0f)
+    , mBlurRadius()
     , mOnOpen()
     , mOnClose()
     , mOnESC()
@@ -21,7 +21,7 @@ XMenuDef::XMenuDef()
     , mVisibleExp()
     , mAllowedBinding()
     , mSoundName()
-    , mImageTrack(0)
+    , mImageTrack()
     , mFocusColor()
     , mDisableColor()
     , mRectXExp()
@@ -44,76 +44,5 @@ void XMenuDef::Clear()
 
 void XMenuDef::ParseData(QDataStream *aStream)
 {
-    mWindow.ParseData(aStream);
 
-    mFont.ParsePtr(aStream, false);
-
-    *aStream
-        >> mFullScreen
-        >> mItemCount
-        >> mFontIndex;
-
-    for (int i = 0; i < 4; i++)
-    {
-        *aStream >> mCursorItem[i];
-    }
-
-    *aStream
-        >> mFadeCycle
-        >> mFadeClamp
-        >> mFadeAmount
-        >> mFadeInAmount
-        >> mBlurRadius;
-
-    mOnOpen.ParsePtr(aStream, false);
-    mOnClose.ParsePtr(aStream, false);
-    mOnESC.ParsePtr(aStream, false);
-    mOnKey.ParsePtr(aStream, false);
-
-    mVisibleExp.ParseData(aStream);
-
-    mAllowedBinding.ParsePtr(aStream, false);
-    mSoundName.ParsePtr(aStream, false);
-
-    *aStream >> mImageTrack;
-
-    float focusR, focusG, focusB, focusA,
-        disableR, disableG, disableB, disableA;
-
-    *aStream
-        >> focusR
-        >> focusG
-        >> focusB
-        >> focusA
-        >> disableR
-        >> disableG
-        >> disableB
-        >> disableA;
-
-    mRectXExp.ParseData(aStream);
-    mRectYExp.ParseData(aStream);
-
-    qint32 itemsPtr;
-    *aStream >> itemsPtr;
-
-    mFont.ParseData(aStream);
-    mOnOpen.ParseData(aStream);
-    mOnClose.ParseData(aStream);
-    mOnESC.ParseData(aStream);
-    mOnKey.ParseData(aStream);
-    mVisibleExp.ParseData(aStream);
-    mAllowedBinding.ParseData(aStream);
-    mSoundName.ParseData(aStream);
-    mRectXExp.ParseData(aStream);
-    mRectYExp.ParseData(aStream);
-
-    if (itemsPtr)
-    {
-        for (int i = 0; i < mItemCount; i++)
-        {
-            XItemDef newItemDef;
-            newItemDef.ParsePtr(aStream);
-            mItems.append(newItemDef);
-        }
-    }
 }

libs/xassets/xmenudef.h

@@ -13,7 +13,7 @@ class XItemDef;
 class XMenuDef : public XAsset
 {
 public:
-    explicit XMenuDef();
+    XMenuDef();
     ~XMenuDef();
 
     virtual void Clear() override;
@@ -21,29 +21,29 @@ public:
 
 private:
     XWindowDef mWindow;
-    XString mFont;
+    XString* mFont;
-    qint32 mFullScreen;
+    int mFullScreen;
-    qint32 mItemCount;
+    int mItemCount;
-    qint32 mFontIndex;
+    int mFontIndex;
-    QVector<qint32> mCursorItem;
+    int mCursorItem[4];
-    qint32 mFadeCycle;
+    int mFadeCycle;
     float mFadeClamp;
     float mFadeAmount;
     float mFadeInAmount;
     float mBlurRadius;
-    XString mOnOpen;
+    XString* mOnOpen;
-    XString mOnClose;
+    XString* mOnClose;
-    XString mOnESC;
+    XString* mOnESC;
-    XItemKeyHandler mOnKey;
+    XItemKeyHandler *mOnKey;
     XStatement mVisibleExp;
-    XString mAllowedBinding;
+    XString* mAllowedBinding;
-    XString mSoundName;
+    XString* mSoundName;
-    qint32 mImageTrack;
+    int mImageTrack;
     QColor mFocusColor;
     QColor mDisableColor;
     XStatement mRectXExp;
     XStatement mRectYExp;
-    QVector<XItemDef> mItems;
+    QVector<XItemDef*> mItems;
 };
 
 #endif // XMENUDEF_H

libs/xassets/xmodel.cpp

@@ -3,7 +3,7 @@
 
 XModel::XModel()
     : XAsset()
-    , mName()
+    , mName("")
     , mNumBones(0)
     , mNumRootBones(0)
     , mNumSurfs(0)
@@ -12,15 +12,15 @@ XModel::XModel()
     , mParentList()
     , mQuats()
     , mTrans(0)
-    , mPartClassification()
+    , mPartClassification(0)
-    , mBaseMat()
+    , mBaseMat(0)
     , mSurfs()
     , mMaterialHandles()
     , mLodInfo()
     , mCollSurfs()
     , mNumCollSurfs(0)
     , mContents(0)
-    , mBoneInfo()
+    , mBoneInfo(new XBoneInfo())
     , mRadius(0)
     , mMins()
     , mMaxs()
@@ -29,8 +29,8 @@ XModel::XModel()
     , mStreamInfo()
     , mMemUsage(0)
     , mFlags(0)
-    , mPhysPreset()
+    , mPhysPreset(new XPhysPreset)
-    , mPhysGeoms()
+    , mPhysGeoms(new XPhysGeomList)
 {
     SetType(ASSET_TYPE_XMODEL);
 }
@@ -41,142 +41,13 @@ XModel::~XModel()
 }
 
 void XModel::ParseData(QDataStream *aStream) {
-
+    qint32 namePtr, boneNamesPtr;
-    mName.ParsePtr(aStream, false);
 
     *aStream
-        >> mNumBones
+        >> namePtr;
-        >> mNumRootBones
-        >> mNumSurfs
-        >> mLodRampType;
 
-    qint32 boneNamesPtr, parentListPtr, quatsPtr, transPtr, partClassPtr;
+    mName = XString::ParseCustom(aStream);
 
-    *aStream
-        >> boneNamesPtr
-        >> parentListPtr
-        >> quatsPtr
-        >> transPtr
-        >> partClassPtr;
-
-    mBaseMat.ParsePtr(aStream, false);
-
-    qint32 surfsPtr, matHandlesPtr, lodInfoPtr, collSurfsPtr;
-
-    *aStream
-        >> surfsPtr
-        >> matHandlesPtr
-        >> lodInfoPtr
-        >> collSurfsPtr
-        >> mNumCollSurfs
-        >> mContents;
-
-    mBoneInfo.ParsePtr(aStream, false);
-
-    *aStream
-        >> mRadius
-        >> mMins
-        >> mMaxs
-        >> mNumLods
-        >> mCollLod;
-
-    mStreamInfo.ParseData(aStream);
-
-    *aStream
-        >> mMemUsage
-        >> mFlags;
-    aStream->skipRawData(3);
-
-    mPhysPreset.ParsePtr(aStream, false);
-    mPhysGeoms.ParsePtr(aStream, false);
-
-    mName.ParseData(aStream);
-
-    if (boneNamesPtr == -1)
-    {
-        for (int i = 0; i < mNumBones; i++)
-        {
-            quint16 bone;
-            *aStream >> bone;
-            mBoneNames.append(bone);
-        }
-    }
-
-    if (parentListPtr == -1)
-    {
-        for (int i = 0; i < mNumBones - mNumRootBones; i++)
-        {
-            quint8 parent;
-            *aStream >> parent;
-            mParentList.append(parent);
-        }
-    }
-
-    if (quatsPtr == -1)
-    {
-        for (int i = 0; i < 8 * (mNumBones - mNumRootBones); i++)
-        {
-            quint8 quat;
-            *aStream >> quat;
-            mQuats.append(quat);
-        }
-    }
-
-    if (transPtr == -1)
-    {
-        for (int i = 0; i < 16 * (mNumBones - mNumRootBones); i++)
-        {
-            quint8 trans;
-            *aStream >> trans;
-            mTrans.append(trans);
-        }
-    }
-
-    if (partClassPtr == -1)
-    {
-        for (int i = 0; i < mNumBones; i++)
-        {
-            quint8 partClass;
-            *aStream >> partClass;
-            mPartClassification.append(partClass);
-        }
-    }
-
-    mBaseMat.ParseData(aStream);
-
-    if (surfsPtr == -1)
-    {
-        for (int i = 0; i < mNumSurfs; i++)
-        {
-            XSurface newSurf;
-            newSurf.ParseData(aStream);
-            mSurfs.append(newSurf);
-        }
-    }
-
-    if (matHandlesPtr == -1)
-    {
-        for (int i = 0; i < mNumSurfs; i++)
-        {
-            XMaterial newMaterial;
-            newMaterial.ParseData(aStream);
-            mMaterialHandles.append(newMaterial);
-        }
-    }
-
-    if (collSurfsPtr == -1)
-    {
-        for (int i = 0; i < mNumCollSurfs; i++)
-        {
-            XModelCollSurf newCollSurf;
-            newCollSurf.ParseData(aStream);
-            mCollSurfs.append(newCollSurf);
-        }
-    }
-
-    mBoneInfo.ParseData(aStream);
-
-    // TODO: Fill out rest of this
 }
 
 void XModel::Clear()

libs/xassets/xmodel.h

@@ -23,24 +23,24 @@ public:
     virtual void Clear() override;
 
 private:
-    XString mName;
+    QString mName;
     quint8 mNumBones;
     quint8 mNumRootBones;
     quint8 mNumSurfs;
     quint8 mLodRampType;
-    QVector<quint16> mBoneNames;
+    XScriptStringList mBoneNames;
     QVector<quint8> mParentList;
     QVector<quint8> mQuats;
-    QVector<float> mTrans;
+    float *mTrans;
-    QVector<quint8> mPartClassification;
+    quint8 *mPartClassification;
-    XDObjAnimMat mBaseMat;
+    XDObjAnimMat *mBaseMat;
     QVector<XSurface> mSurfs;
-    QVector<XMaterial> mMaterialHandles;
+    QVector<XMaterial*> mMaterialHandles;
     QVector<XModelLodInfo> mLodInfo;
     QVector<XModelCollSurf> mCollSurfs;
     int mNumCollSurfs;
     int mContents;
-    XBoneInfo mBoneInfo;
+    XBoneInfo* mBoneInfo;
     float mRadius;
     QVector3D mMins;
     QVector3D mMaxs;
@@ -49,8 +49,8 @@ private:
     XModelStreamInfo mStreamInfo;
     int mMemUsage;
     quint8 mFlags;
-    XPhysPreset mPhysPreset;
+    XPhysPreset* mPhysPreset;
-    XPhysGeomList mPhysGeoms;
+    XPhysGeomList* mPhysGeoms;
 };
 
 #endif // XMODEL_H

libs/xassets/xmodelcollsurf.cpp

@@ -18,16 +18,7 @@ XModelCollSurf::~XModelCollSurf()
 
 void XModelCollSurf::ParseData(QDataStream *aStream)
 {
-    *aStream
+    
-        >> mMins[0]
-        >> mMins[1]
-        >> mMins[2]
-        >> mMaxs[0]
-        >> mMaxs[1]
-        >> mMaxs[2]
-        >> mBoneIdx
-        >> mContents
-        >> mSurfFlags;
 }
 
 void XModelCollSurf::Clear()

libs/xassets/xmodelpiece.cpp

@@ -2,7 +2,7 @@
 
 XModelPiece::XModelPiece()
     : XAsset()
-    , mModel()
+    , mModel(new XModel())
     , mOffset()
 {
     
@@ -10,23 +10,16 @@ XModelPiece::XModelPiece()
 
 XModelPiece::~XModelPiece()
 {
-
+    delete mModel;
 }
 
 void XModelPiece::ParseData(QDataStream *aStream)
 {
-    mModel.ParsePtr(aStream, false);
+    
-
-    *aStream
-        >> mOffset[0]
-        >> mOffset[1]
-        >> mOffset[2];
-
-    mModel.ParseData(aStream);
 }
 
 void XModelPiece::Clear()
 {
-    mModel.Clear();
+    mModel->Clear();
     mOffset = QVector3D();
 }

libs/xassets/xmodelpiece.h

@@ -14,7 +14,7 @@ public:
     virtual void Clear() override;
 
 private:
-    XModel mModel;
+    XModel *mModel;
     QVector3D mOffset;
 };
 

libs/xassets/xmodelpieces.cpp

@@ -2,7 +2,7 @@
 
 XModelPieces::XModelPieces()
     : XAsset()
-    , mName()
+    , mName("")
     , mNumPieces(0)
     , mPieces()
 {
@@ -17,32 +17,12 @@ XModelPieces::~XModelPieces()
 
 void XModelPieces::ParseData(QDataStream *aStream)
 {
-    if (GetPtr() == -1)
+    
-    {
-        mName.ParsePtr(aStream, false);
-
-        qint32 piecesPtr;
-        *aStream
-            >> mNumPieces
-            >> piecesPtr;
-
-        mName.ParseData(aStream);
-
-        if (piecesPtr)
-        {
-            for (int i = 0; i < mNumPieces; i++)
-            {
-                XModelPiece newPiece;
-                newPiece.ParseData(aStream);
-                mPieces.append(newPiece);
-            }
-        }
-    }
 }
 
 void XModelPieces::Clear()
 {
-    mName.Clear();
+    mName.clear();
     mNumPieces = 0;
     mPieces.clear();
 }

libs/xassets/xmodelpieces.h

@@ -14,7 +14,7 @@ public:
     virtual void Clear() override;
 
 private:
-    XString mName;
+    QString mName;
     int mNumPieces;
     QVector<XModelPiece> mPieces;
 };

libs/xassets/xpackedtexcoords.cpp

@@ -9,7 +9,7 @@ XPackedTexCoords::XPackedTexCoords()
 
 void XPackedTexCoords::ParseData(QDataStream *aStream)
 {
-    *aStream >> mPacked;
+    
 }
 
 void XPackedTexCoords::Clear()

libs/xassets/xpackedunitvec.cpp

@@ -9,7 +9,7 @@ XPackedUnitVec::XPackedUnitVec()
 
 void XPackedUnitVec::ParseData(QDataStream *aStream)
 {
-    *aStream >> mPacked;
+    
 }
 
 void XPackedUnitVec::Clear()

libs/xassets/xphyspreset.cpp

@@ -2,14 +2,16 @@
 
 XPhysPreset::XPhysPreset()
     : XAsset()
-    , mName()
+    , mNamePtr(0)
+    , mName("")
     , mType(0)
     , mMass(0)
     , mBounce(0)
     , mFriction(0)
     , mBulletForceScale(0)
     , mExplosiveForceScale(0)
-    , mSndAliasPrefix()
+    , mSndAliasPrefixPtr(0)
+    , mSndAliasPrefix("")
     , mPiecesSpreadFraction(0)
     , mPiecesUpwardVelocity(0)
     , mTempDefaultToCylinder(false)
@@ -25,40 +27,21 @@ XPhysPreset::~XPhysPreset()
 
 void XPhysPreset::ParseData(QDataStream *aStream)
 {
-    if (GetPtr() == -1)
+    
-    {
-        mName.ParsePtr(aStream, false);
-
-        *aStream
-            >> mType
-            >> mMass
-            >> mBounce
-            >> mFriction
-            >> mBulletForceScale
-            >> mExplosiveForceScale;
-
-        mSndAliasPrefix.ParsePtr(aStream, false);
-
-        *aStream
-            >> mPiecesSpreadFraction
-            >> mPiecesUpwardVelocity
-            >> mTempDefaultToCylinder;
-
-        mName.ParseData(aStream);
-        mSndAliasPrefix.ParseData(aStream);
-    }
 }
 
 void XPhysPreset::Clear()
 {
-    mName.Clear();
+    mNamePtr = 0;
+    mName.clear();
     mType = 0;
     mMass = 0;
     mBounce = 0;
     mFriction = 0;
     mBulletForceScale = 0;
     mExplosiveForceScale = 0;
-    mSndAliasPrefix.Clear();
+    mSndAliasPrefixPtr = 0;
+    mSndAliasPrefix.clear();
     mPiecesSpreadFraction = 0;
     mPiecesUpwardVelocity = 0;
     mTempDefaultToCylinder = false;

libs/xassets/xphyspreset.h

@@ -2,28 +2,36 @@
 #define XPHYSPRESET_H
 
 #include "xasset.h"
-#include "xstring.h"
+
+#include <QString>
 
 class XPhysPreset : public XAsset
 {
 public:
-    explicit XPhysPreset();
+    XPhysPreset();
     ~XPhysPreset();
 
     virtual void ParseData(QDataStream* aStream) override;
     virtual void Clear() override;
 
 private:
-    XString mName;
+    qint32 mNamePtr;
+    QString mName;
+
     int mType;
+
     float mMass;
     float mBounce;
     float mFriction;
     float mBulletForceScale;
     float mExplosiveForceScale;
-    XString mSndAliasPrefix;
+
+    qint32 mSndAliasPrefixPtr;
+    QString mSndAliasPrefix;
+
     float mPiecesSpreadFraction;
     float mPiecesUpwardVelocity;
+
     bool mTempDefaultToCylinder;
 };
 

libs/xassets/xstring.cpp

@@ -6,8 +6,6 @@
 XString::XString()
     : XAsset()
     , mString("")
-    , mRemoveString("")
-    , mContentLength(-1)
 {
     SetName("String");
 }
@@ -15,8 +13,6 @@ XString::XString()
 XString::XString(const QString aString)
     : XAsset()
     , mString(aString)
-    , mRemoveString("")
-    , mContentLength(-1)
 {
 
 }
@@ -31,16 +27,6 @@ QString XString::GetString() const
     return mString;
 }
 
-void XString::SetRemoveString(const QString aRemoveString)
-{
-    mRemoveString = aRemoveString;
-}
-
-void XString::SetContentLength(int aContentLength)
-{
-    mContentLength = aContentLength;
-}
-
 void XString::SetString(const QString& aString)
 {
     mString = aString;
@@ -82,28 +68,23 @@ void XString::Clear()
 }
 
 void XString::ParseData(QDataStream *aStream)
+{
+    ParseData(aStream, "");
+}
+
+void XString::ParseData(QDataStream *aStream, QString aRemoveStr)
 {
     if (GetPtr() == -1)
     {
-        if (mContentLength == -1)
+        mString = ParseCustom(aStream);
+        if (!aRemoveStr.isEmpty())
         {
-            mString = ParseCustom(aStream);
+            mString = mString.replace(aRemoveStr, "");
         }
-        else if (mContentLength != 0)
-        {
-            QByteArray rawString(mContentLength, Qt::Uninitialized);
-            aStream->readRawData(rawString.data(), mContentLength);
-            mString = QString::fromUtf8(rawString);
-        }
-
-        if (!mRemoveString.isEmpty())
-        {
-            mString = mString.replace(mRemoveString, "");
-        }
-
         if (IsDebug())
         {
             qDebug() << QString("[%1] mString = %2").arg(aStream->device()->pos(), 10, 10, QChar('0')).arg(mString);
         }
     }
 }
+

libs/xassets/xstring.h

@@ -17,19 +17,15 @@ public:
     void SetString(const QString& aString);
     QString GetString() const;
 
-    void SetRemoveString(const QString aRemoveString);
-    void SetContentLength(int aContentLength);
-
     static QString ParseCustom(QDataStream* aStream);
     static XStringArray* ParseArray(QDataStream* aStream, int aCount);
 
     virtual void Clear() override;
     virtual void ParseData(QDataStream* aStream) override;
+    virtual void ParseData(QDataStream* aStream, QString aRemoveStr);
 
 private:
     QString mString;
-    QString mRemoveString;
-    int mContentLength;
 };
 
 #endif // XSTRING_H

libs/xassets/xsunflare.cpp

@@ -1,10 +1,10 @@
 #include "xsunflare.h"
 
-XSunFlare::XSunFlare()
+XSunflare::XSunflare()
     : XAsset()
     , mHasValidData(false)
-    , mSpriteMaterial()
+    , mSpriteMaterial(new XMaterial())
-    , mFlareMaterial()
+    , mFlareMaterial(new XMaterial())
     , mSpriteSize(0.0f)
     , mFlareMinSize(0.0f)
     , mFlareMinDot(0.0f)
@@ -28,70 +28,17 @@ XSunFlare::XSunFlare()
     
 }
 
-XSunFlare::~XSunFlare()
+XSunflare::~XSunflare()
 {
     
 }
 
-void XSunFlare::ParseData(QDataStream *aStream)
+void XSunflare::ParseData(QDataStream *aStream)
 {
-    *aStream
+    
-        >> mHasValidData;
-
-    aStream->skipRawData(3);
-
-    mSpriteMaterial.ParsePtr(aStream, false);
-    mFlareMaterial.ParsePtr(aStream, false);
-
-    *aStream
-        >> mSpriteSize
-        >> mFlareMinSize
-        >> mFlareMinDot
-        >> mFlareMaxSize
-        >> mFlareMaxDot
-        >> mFlareMaxAlpha
-        >> mFlareFadeInTime
-        >> mFlareFadeOutTime
-        >> mBlindMinDot
-        >> mBlindMaxDot
-        >> mBlindMaxDarken
-        >> mBlindFadeInTime
-        >> mBlindFadeOutTime
-        >> mGlareMinDot
-        >> mGlareMaxDot
-        >> mGlareMaxLighten
-        >> mGlareFadeInTime
-        >> mGlareFadeOutTime
-        >> mSunFxPosition[0]
-        >> mSunFxPosition[1]
-        >> mSunFxPosition[2];
-
-    mSpriteMaterial.ParseData(aStream);
-    mFlareMaterial.ParseData(aStream);
 }
 
-void XSunFlare::Clear()
+void XSunflare::Clear()
 {
-    mHasValidData = false;
+    
-    mSpriteMaterial.Clear();
-    mFlareMaterial.Clear();
-    mSpriteSize = 0.0f;
-    mFlareMinSize = 0.0f;
-    mFlareMinDot = 0.0f;
-    mFlareMaxSize = 0.0f;
-    mFlareMaxDot = 0.0f;
-    mFlareMaxAlpha = 0.0f;
-    mFlareFadeInTime = 0;
-    mFlareFadeOutTime = 0;
-    mBlindMinDot = 0.0f;
-    mBlindMaxDot = 0.0f;
-    mBlindMaxDarken = 0.0f;
-    mBlindFadeInTime = 0;
-    mBlindFadeOutTime = 0;
-    mGlareMinDot = 0.0f;
-    mGlareMaxDot = 0.0f;
-    mGlareMaxLighten = 0.0f;
-    mGlareFadeInTime = 0;
-    mGlareFadeOutTime = 0;
-    mSunFxPosition = QVector3D();
 }

libs/xassets/xsunflare.h

@@ -6,19 +6,19 @@
 
 #include <QVector3D>
 
-class XSunFlare : public XAsset
+class XSunflare : public XAsset
 {
 public:
-    explicit XSunFlare();
+    XSunflare();
-    ~XSunFlare();
+    ~XSunflare();
 
     virtual void ParseData(QDataStream* aStream) override;
     virtual void Clear() override;
 
 private:
     bool mHasValidData;
-    XMaterial mSpriteMaterial;
+    XMaterial *mSpriteMaterial;
-    XMaterial mFlareMaterial;
+    XMaterial *mFlareMaterial;
     float mSpriteSize;
     float mFlareMinSize;
     float mFlareMinDot;

libs/xassets/xsurface.cpp

@@ -8,8 +8,8 @@ XSurface::XSurface()
     , mTriCount(0)
     , mTriIndices(0)
     , mVertInfo()
-    , mVert()
+    , mVerts0(new XGfxPackedVertex())
-    , mVertBuffer()
+    , mVb0()
     , mVertListCount(0)
     , mVertList()
     , mIndexBuffer()
@@ -18,46 +18,9 @@ XSurface::XSurface()
     
 }
 
-XSurface::~XSurface()
-{
-
-}
-
 void XSurface::ParseData(QDataStream *aStream)
 {
-    *aStream
+    
-        >> mTileMode
-        >> mDeformed
-        >> mVertCount
-        >> mTriCount;
-
-    aStream->skipRawData(2);
-
-    qint32 triIndicesPtr;
-    *aStream
-        >> triIndicesPtr;
-
-    mVertInfo.ParsePtr(aStream, false);
-    mVert.ParsePtr(aStream, false);
-
-    qint32 vertBuffersPtr, vertListPtr;
-    *aStream
-        >> vertBuffersPtr
-        >> mVertListCount
-        >> vertListPtr;
-
-    mIndexBuffer.ParseData(aStream);
-
-    *aStream
-        >> mPartBits[0]
-        >> mPartBits[1]
-        >> mPartBits[2]
-        >> mPartBits[3];
-
-    mVertInfo.ParseData(aStream);
-    mVert.ParseData(aStream);
-
-    // TODO: Fill out the rest of this
 }
 
 void XSurface::Clear()

libs/xassets/xsurface.h

@@ -12,7 +12,6 @@ class XSurface : public XAsset
 {
 public:
     explicit XSurface();
-    ~XSurface();
 
     void ParseData(QDataStream *aStream) override;
     void Clear() override;
@@ -22,14 +21,14 @@ private:
     bool mDeformed;
     quint32 mVertCount;
     quint32 mTriCount;
-    QVector<quint32> mTriIndices;
+    quint32 *mTriIndices;
     XSurfaceVertexInfo mVertInfo;
-    XGfxPackedVertex mVert;
+    XGfxPackedVertex *mVerts0;
-    XD3DVertexBuffer mVertBuffer;
+    XD3DVertexBuffer mVb0;
     quint32 mVertListCount;
     QVector<XRigidVertList> mVertList;
     XD3DIndexBuffer mIndexBuffer;
-    QVector<int> mPartBits;
+    int mPartBits[4];
 };
 
 #endif // XSURFACE_H

libs/xassets/xsurfacevertexinfo.cpp

@@ -2,7 +2,8 @@
 
 XSurfaceVertexInfo::XSurfaceVertexInfo()
     : XAsset()
-    , mVertCount(4)
+    , mVertCount()
+    , mVertsBlendPtr()
     , mVertsBlend()
 {
     
@@ -10,21 +11,7 @@ XSurfaceVertexInfo::XSurfaceVertexInfo()
 
 void XSurfaceVertexInfo::ParseData(QDataStream *aStream)
 {
-    if (GetPtr() == -1)
+    
-    {
-        qint32 vertBlendPtr;
-        *aStream
-            >> mVertCount[0]
-            >> mVertCount[1]
-            >> mVertCount[2]
-            >> mVertCount[3]
-            >> vertBlendPtr;
-
-        if (vertBlendPtr == -1)
-        {
-            aStream->readRawData(mVertsBlend.data(), 2 * (mVertCount[0] + 3 * mVertCount[1] + 5 * mVertCount[2] + 7 * mVertCount[3]));
-        }
-    }
 }
 
 void XSurfaceVertexInfo::Clear()

libs/xassets/xsurfacevertexinfo.h

@@ -12,8 +12,9 @@ public:
     void Clear() override;
 
 private:
-    QVector<qint16> mVertCount;
+    qint16 mVertCount[4];
-    QByteArray mVertsBlend;
+    qint32 mVertsBlendPtr;
+    quint32 mVertsBlend;
 };
 
 #endif // XSURFACEVERTEXINFO_H

libs/xassets/xwater.cpp

@@ -3,19 +3,19 @@
 XWater::XWater()
     : XAsset()
     , mWritable()
-    , mH0X()
+    , mH0X(0)
-    , mH0Y()
+    , mH0Y(0)
-    , mWTerm()
+    , mWTerm(0)
     , mM(0)
     , mN(0)
     , mLx(0)
     , mLz(0)
     , mGravity(0)
-    , mWindVel(0)
+    , mWindvel(0)
-    , mWindDir(1)
+    , mWinddir({ 0, 0 })
     , mAmplitude(0)
-    , mCodeConstant(4)
+    , mCodeConstant({ 0, 0, 0, 0 })
-    , mImage()
+    , mImage(new XGfxImage())
 {
     
 }
@@ -27,48 +27,12 @@ XWater::~XWater()
 
 void XWater::ParseData(QDataStream *aStream)
 {
-    mWritable.ParseData(aStream);
+    
-
-    qint32 h0xPtr, h0yPtr, wTermPtr;
-    *aStream
-        >> h0xPtr
-        >> h0yPtr
-        >> wTermPtr
-        >> mM
-        >> mN
-        >> mLx
-        >> mLz
-        >> mGravity
-        >> mWindVel
-        >> mWindDir[0]
-        >> mWindDir[1]
-        >> mAmplitude
-        >> mWindDir[0]
-        >> mWindDir[1]
-        >> mWindDir[2]
-        >> mWindDir[3];
-
-    mImage.ParsePtr(aStream, false);
-
-    if (h0xPtr)
-    {
-        aStream->readRawData(mH0X.data(), 4 * mM * mN);
-    }
-    if (h0yPtr)
-    {
-        aStream->readRawData(mH0X.data(), 4 * mM * mN);
-    }
-    if (wTermPtr)
-    {
-        aStream->readRawData(mWTerm.data(), 4 * mM * mN);
-    }
-
-    mImage.ParseData(aStream);
 }
 
 void XWater::Clear()
 {
-    mWritable.Clear();
+    mWritable = XWaterWritable();
     mH0X = 0;
     mH0Y = 0;
     mWTerm = 0;
@@ -77,9 +41,9 @@ void XWater::Clear()
     mLx = 0;
     mLz = 0;
     mGravity = 0;
-    mWindVel = 0;
+    mWindvel = 0;
-    mWindDir.clear();
+    mWinddir = { 0, 0 };
     mAmplitude = 0;
-    mCodeConstant.clear();
+    mCodeConstant = { 0, 0, 0, 0 };
-    mImage.Clear();
+    mImage = new XGfxImage();
 }

libs/xassets/xwater.h

@@ -18,19 +18,19 @@ public:
 
 private:
     XWaterWritable mWritable;
-    QByteArray mH0X;
+    float *mH0X;
-    QByteArray mH0Y;
+    float *mH0Y;
-    QByteArray mWTerm;
+    float *mWTerm;
     int mM;
     int mN;
     float mLx;
     float mLz;
     float mGravity;
-    float mWindVel;
+    float mWindvel;
-    QVector<float> mWindDir;
+    QVector<float> mWinddir;
     float mAmplitude;
     QVector<float> mCodeConstant;
-    XGfxImage mImage;
+    XGfxImage *mImage;
 };
 
 #endif // XWATER_H