njohnson/XPlor
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases 1 Wiki Activity

Lotta changes

Browse Source
This commit is contained in:
njohnson 2025-09-10 21:58:26 -04:00
parent 324e84eafc
commit ba83aa5247
471 changed files with 2370 additions and 4003 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

342
libs/xassets/xclipmap.cpp
View File

@ -54,302 +54,274 @@ XClipMap::XClipMap()
, mChecksum(0)
{
SetType(ASSET_TYPE_CLIPMAP);
SetName("ClipMap");
SetName("Clip Map");
}
XClipMap::~XClipMap()
{
}
void XClipMap::ParseData(QDataStream *aStream)
void XClipMap::ParseData(XDataStream *aStream)
{
if (GetPtr() == -1)
{
// name / header
mName.ParsePtr(aStream, false);
qint32 planePtr, staticModelPtr, materialsPtr, brushSidesPtr,
brushEdgesPtr, nodesPtr, leafsPtr, leafsBrushNodesPtr,
leafBrushesPtr, leafSurfacesPtr, vertPtr,
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;
mIsInUse = aStream->ParseUInt32(QString("%1 is in use").arg(GetName()));
mPlaneCount = aStream->ParseInt32 (QString("%1 plane count").arg(GetName()));
qint32 planePtr = aStream->ParseInt32(QString("%1 plane ptr").arg(GetName()));
// 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;
*aStream
>> brushesPtr
>> mNumClusters
>> mClusterBytes
>> visibilityPtr
>> mVised
>> mapEntsPtr;
// visibility + ents
qint32 brushesPtr = aStream->ParseInt32(QString("%1 brushes ptr").arg(GetName()));
mNumClusters = aStream->ParseInt32(QString("%1 num clusters").arg(GetName()));
mClusterBytes = aStream->ParseInt32(QString("%1 cluster bytes").arg(GetName()));
qint32 visibilityPtr = aStream->ParseInt32(QString("%1 visibility ptr").arg(GetName()));
mVised = aStream->ParseInt32(QString("%1 vised").arg(GetName()));
qint32 mapEntsPtr = aStream->ParseInt32(QString("%1 map ents ptr").arg(GetName()));
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)
{
for (int i = 0; i < mPlaneCount; i++)
{
// =====================
// Sectioned data blocks
// =====================
if (planePtr) {
for (int i = 0; i < mPlaneCount; i++) {
XCPlane newCPlane;
newCPlane.ParseData(aStream);
mPlanes.append(newCPlane);
}
}
if (staticModelPtr)
{
for (int i = 0; i < mNumStaticModels; i++)
{
if (staticModelPtr) {
for (quint32 i = 0; i < mNumStaticModels; i++) {
XCStaticModel newModel;
newModel.ParseData(aStream);
mStaticModelList.append(newModel);
}
}
if (materialsPtr)
{
for (int i = 0; i < mNumMaterials; i++)
{
XDMaterial newDMaterial;
newDMaterial.ParseData(aStream);
mMaterials.append(newDMaterial);
if (materialsPtr) {
for (quint32 i = 0; i < mNumMaterials; i++) {
XDMaterial newMat;
newMat.ParseData(aStream);
mMaterials.append(newMat);
}
}
if (brushSidesPtr)
{
for (int i = 0; i < mNumBrushSides; i++)
{
XCBrushSide newBrushSide;
newBrushSide.ParseData(aStream);
mBrushsides.append(newBrushSide);
if (brushSidesPtr) {
for (quint32 i = 0; i < mNumBrushSides; i++) {
XCBrushSide newSide;
newSide.ParseData(aStream);
mBrushsides.append(newSide);
}
}
if (brushEdgesPtr)
{
for (int i = 0; i < mNumBrushEdges; i++)
{
quint8 newBrushEdge;
*aStream >> newBrushEdge;
mBrushEdges.append(newBrushEdge);
if (brushEdgesPtr) {
for (quint32 i = 0; i < mNumBrushEdges; i++) {
quint8 edge = aStream->ParseUInt8(QString("%1 edge %2").arg(GetName()).arg(i));
mBrushEdges.append(edge);
}
}
if (nodesPtr)
{
for (int i = 0; i < mNumNodes; i++)
{
if (nodesPtr) {
for (quint32 i = 0; i < mNumNodes; i++) {
XCNode newNode;
newNode.ParseData(aStream);
mNodes.append(newNode);
}
}
if (leafsPtr)
{
for (int i = 0; i < mNumLeafs; i++)
{
if (leafsPtr) {
for (quint32 i = 0; i < mNumLeafs; i++) {
XCLeaf newLeaf;
newLeaf.ParseData(aStream);
mLeafs.append(newLeaf);
}
}
if (leafBrushesPtr)
{
for (int i = 0; i < mNumLeafBrushes; i++)
{
quint32 newBrush;
*aStream >> newBrush;
mLeafBrushes.append(newBrush);
if (leafBrushesPtr) {
for (quint32 i = 0; i < mNumLeafBrushes; i++) {
quint32 brush = aStream->ParseUInt32(QString("%1 brush %2").arg(GetName()).arg(i));
mLeafBrushes.append(brush);
}
}
if (leafsBrushNodesPtr)
{
for (int i = 0; i < mNumLeafBrushes; i++)
{
XCLeafBrushNode newBrushNode;
newBrushNode.ParseData(aStream);
mLeafBrushNodes.append(newBrushNode);
if (leafsBrushNodesPtr) {
for (quint32 i = 0; i < mLeafBrushNodesCount; i++) {
XCLeafBrushNode newNode;
newNode.ParseData(aStream);
mLeafBrushNodes.append(newNode);
}
}
if (leafSurfacesPtr)
{
for (int i = 0; i < mNumLeafBrushes; i++)
{
quint32 newBrush;
*aStream >> newBrush;
mLeafSurfaces.append(newBrush);
if (leafSurfacesPtr) {
for (quint32 i = 0; i < mNumLeafSurfaces; i++) {
quint32 surf = aStream->ParseUInt32(QString("%1 surf %2").arg(GetName()).arg(i));
mLeafSurfaces.append(surf);
}
}
if (vertPtr)
{
for (int i = 0; i < mVertCount; i++)
{
QVector3D newVert;
*aStream
>> newVert[0]
>> newVert[1]
>> newVert[2];
mVerts.append(newVert);
if (vertPtr) {
for (quint32 i = 0; i < mVertCount; i++) {
for (int j = 0; j < 3; j++) {
QVector3D v;
v[j] = aStream->ParseSingle(QString("%1 vert (%2, %3)").arg(GetName()).arg(i).arg(j));
mVerts.append(v);
}
}
}
if (triIndicesPtr)
{
for (int i = 0; i < mTriCount; i++)
{
quint32 newTri;
*aStream >> newTri;
mTriIndices.append(newTri);
if (triIndicesPtr) {
for (int i = 0; i < mTriCount; i++) {
quint32 tri = aStream->ParseUInt32(QString("%1 tri %2").arg(GetName()).arg(i));
mTriIndices.append(tri);
}
}
if (triEdgeWalkablePtr)
{
aStream->readRawData(mTriEdgeIsWalkable.data(), ((3 * mTriCount + 31) >> 3) & 0xFFFFFFFC);
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 (bordersPtr) {
for (int i = 0; i < mBorderCount; i++) {
XCollisionBorder b;
b.ParseData(aStream);
mBorders.append(b);
}
}
if (partitionsPtr)
{
for (int i = 0; i < mPartitionCount; i++)
{
XCollisionPartition newPartition;
newPartition.ParseData(aStream);
mPartitions.append(newPartition);
if (partitionsPtr) {
for (int i = 0; i < mPartitionCount; i++) {
XCollisionPartition p;
p.ParseData(aStream);
mPartitions.append(p);
}
}
if (aabbTreesPtr)
{
for (int i = 0; i < mAabbTreeCount; i++)
{
XCollisionAabbTree newTree;
newTree.ParseData(aStream);
mAabbTrees.append(newTree);
if (aabbTreesPtr) {
for (int i = 0; i < mAabbTreeCount; i++) {
XCollisionAabbTree t;
t.ParseData(aStream);
mAabbTrees.append(t);
}
}
if (cModelsPtr)
{
for (int i = 0; i < mNumSubModels; i++)
{
XCModel newCModel;
newCModel.ParseData(aStream);
mCModels.append(newCModel);
if (cModelsPtr) {
for (quint32 i = 0; i < mNumSubModels; i++) {
XCModel m;
m.ParseData(aStream);
mCModels.append(m);
}
}
if (brushesPtr)
{
for (int i = 0; i < mNumBrushes; i++)
{
XCBrush newCBrush;
newCBrush.ParseData(aStream);
mBrushes.append(newCBrush);
if (brushesPtr) {
for (quint32 i = 0; i < mNumBrushes; i++) {
XCBrush b;
b.ParseData(aStream);
mBrushes.append(b);
}
}
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()
{

16
libs/xassets/xclipmap.h
View File

@ -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;

21
libs/xassets/xcmodel.cpp
View File

@ -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
>> mMins[0]
>> mMins[1]
>> mMins[2]
>> mMaxs[0]
>> mMaxs[1]
>> mMaxs[2]
>> mRadius;
for (int i = 0; i < 3; i++) {
mMins[i] = aStream->ParseSingle(QString("%1 min %2").arg(GetName()).arg(i));
}
for (int i = 0; i < 3; i++) {
mMaxs[i] = aStream->ParseSingle(QString("%1 max %2").arg(GetName()).arg(i));
}
mRadius = aStream->ParseSingle(QString("%1 radius").arg(GetName()));
mLeaf.ParseData(aStream);
}

2
libs/xassets/xcmodel.h
View File

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

20
libs/xassets/xcnode.cpp
View File

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

2
libs/xassets/xcnode.h
View File

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

40
libs/xassets/xcollisionaabbtree.cpp
View File

@ -8,30 +8,41 @@ XCollisionAabbTree::XCollisionAabbTree()
, mChildCount(0)
, mTreeIndex()
{
SetName("Collision AABB Tree");
}
XCollisionAabbTree::~XCollisionAabbTree()
{
}
void XCollisionAabbTree::ParseData(QDataStream *aStream) {
if (GetPtr() == -1) {
*aStream
>> mOrigin[0]
>> mOrigin[1]
>> mOrigin[2]
>> mHalfSize[0]
>> mHalfSize[1]
>> mHalfSize[2]
>> mMaterialIndex
>> mChildCount;
void XCollisionAabbTree::ParseData(XDataStream *aStream)
{
if (GetPtr() == -1)
{
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())));
mHalfSize.setX(aStream->ParseSingle(QString("%1 half size x").arg(GetName())));
mHalfSize.setY(aStream->ParseSingle(QString("%1 half size y").arg(GetName())));
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;
}

7
libs/xassets/xcollisionaabbtree.h
View File

@ -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 mChildCount = 0;
quint32 mMaterialIndex;
quint32 mChildCount;
XCollisionAabbTreeIndex mTreeIndex;
};

9
libs/xassets/xcollisionaabbtreeindex.cpp
View File

@ -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
>> mPartitionIndex;
mFirstChildIndex = aStream->ParseInt32(QString("%1 first child index").arg(GetName()));
mPartitionIndex = aStream->ParseInt32(QString("%1 partition index").arg(GetName()));
}
}

6
libs/xassets/xcollisionaabbtreeindex.h
View File

@ -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;
int mPartitionIndex;
qint32 mFirstChildIndex;
qint32 mPartitionIndex;
};
#endif // XCOLLISIONAABBTREEINDEX_H

28
libs/xassets/xcollisionborder.cpp
View File

@ -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) {
if (GetPtr() == -1) {
*aStream
>> mDistEq[0]
>> mDistEq[1]
>> mDistEq[2]
>> mZBase
>> mZSlope
>> mStart
>> mLength;
void XCollisionBorder::ParseData(XDataStream *aStream)
{
if (GetPtr() == -1)
{
// Distance equation components
mDistEq[0] = aStream->ParseSingle(QString("%1 dist eq x").arg(GetName()));
mDistEq[1] = aStream->ParseSingle(QString("%1 dist eq y").arg(GetName()));
mDistEq[2] = aStream->ParseSingle(QString("%1 dist eq z").arg(GetName()));
// 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()));
}
}

2
libs/xassets/xcollisionborder.h
View File

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

3
libs/xassets/xcollisionpartition.cpp
View File

@ -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

2
libs/xassets/xcollisionpartition.h
View File

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

11
libs/xassets/xcolumninfo.cpp
View File

@ -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()

4
libs/xassets/xcolumninfo.h
View File

@ -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:

70
libs/xassets/xcomprimarylight.cpp
View File

@ -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
>> mType
>> mCanUseShadowMap
>> mExponent
>> mUnused
>> mColor
>> mDir
>> mOrigin
>> mRadius
>> mCosHalfFovOuter
>> mCosHalfFovInner
>> mCosHalfFovExpanded
>> mRotationLimit
>> mTranslationLimit;
if (GetPtr() == -1)
{
mType = aStream->ParseUInt8(QString("%1 type").arg(GetName()));
mCanUseShadowMap = aStream->ParseUInt8(QString("%1 can use shadow map").arg(GetName()));
mExponent = aStream->ParseUInt8(QString("%1 exponent").arg(GetName()));
mUnused = aStream->ParseUInt8(QString("%1 unused").arg(GetName()));
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);
}
}

9
libs/xassets/xcomprimarylight.h
View File

@ -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

4
libs/xassets/xcomworld.cpp
View File

@ -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);

2
libs/xassets/xcomworld.h
View File

@ -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;

21
libs/xassets/xcplane.cpp
View File

@ -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[0]
>> mNormal[1]
>> mNormal[2]
>> mDist
>> mType
>> mSignbits
>> mPad[0]
>> mPad[1];
mNormal.setX(aStream->ParseSingle(QString("%1 normal x").arg(GetName())));
mNormal.setY(aStream->ParseSingle(QString("%1 normal y").arg(GetName())));
mNormal.setZ(aStream->ParseSingle(QString("%1 normal z").arg(GetName())));
mDist = aStream->ParseSingle(QString("%1 dist").arg(GetName()));
mType = aStream->ParseUInt8(QString("%1 type").arg(GetName()));
mSignbits = aStream->ParseUInt8(QString("%1 signbits").arg(GetName()));
mPad[0] = aStream->ParseUInt8(QString("%1 pad 0").arg(GetName()));
mPad[1] = aStream->ParseUInt8(QString("%1 pad 1").arg(GetName()));
}
}

2
libs/xassets/xcplane.h
View File

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

51
libs/xassets/xcstaticmodel.cpp
View File

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

2
libs/xassets/xcstaticmodel.h
View File

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

3
libs/xassets/xcstaticmodelwritable.cpp
View File

@ -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;
}

2
libs/xassets/xcstaticmodelwritable.h
View File

@ -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);

11
libs/xassets/xd3dbasetexture.cpp
View File

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

4
libs/xassets/xd3dbasetexture.h
View File

@ -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:

33
libs/xassets/xd3dcubetexture.cpp
View File

@ -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();
}

19
libs/xassets/xd3dindexbuffer.cpp
View File

@ -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
>> mAddress
>> mSize;
*aStream >> mAddress;
if (IsDebug())
{
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()

2
libs/xassets/xd3dindexbuffer.h
View File

@ -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:

46
libs/xassets/xd3dresource.cpp
View File

@ -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
>> mCommon
>> mReferenceCount
>> mFence
>> mReadFence
>> mIdentifier
>> mBaseFlush;
*aStream >> mCommon;
if (IsDebug())
{
qDebug() << QString("[%1] mCommon = %2").arg(aStream->device()->pos(), 10, 10, QChar('0')).arg(mCommon);
}
*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()

4
libs/xassets/xd3dresource.h
View File

@ -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:

8
libs/xassets/xd3dvertexbuffer.cpp
View File

@ -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()

2
libs/xassets/xd3dvertexbuffer.h
View File

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

6
libs/xassets/xdmaterial.cpp
View File

@ -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);

2
libs/xassets/xdmaterial.h
View File

@ -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);

34
libs/xassets/xdobjanimmat.cpp
View File

@ -2,11 +2,11 @@
XDObjAnimMat::XDObjAnimMat()
: XAsset()
, mQuat()
, mTrans()
, mQuat(4)
, 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
>> mQuat[0]
>> mQuat[1]
>> mQuat[2]
>> mQuat[3]
>> mTrans[0]
>> mTrans[1]
>> mTrans[2]
>> mTransWeight;
for (int i = 0; i < 4; i++)
{
quint32 rawQuat;
*aStream >> rawQuat;
memcpy(&mQuat[i], &rawQuat, sizeof(mQuat[i]));
}
for (int i = 0; i < 3; i++)
{
quint32 rawTrans;
*aStream >> rawTrans;
memcpy(&mTrans[i], &rawTrans, sizeof(mTrans[i]));
}
quint32 rawTransWeight;
*aStream >> rawTransWeight;
memcpy(&mTransWeight, &rawTransWeight, sizeof(mTransWeight));
}
}

2
libs/xassets/xdobjanimmat.h
View File

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

11
libs/xassets/xdvpsplane.cpp
View File

@ -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()

4
libs/xassets/xdvpsplane.h
View File

@ -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:

4
libs/xassets/xdynentityclient.cpp
View File

@ -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())
{

2
libs/xassets/xdynentityclient.h
View File

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

4
libs/xassets/xdynentitycoll.cpp
View File

@ -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())

2
libs/xassets/xdynentitycoll.h
View File

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

4
libs/xassets/xdynentitydef.cpp
View File

@ -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())
{

2
libs/xassets/xdynentitydef.h
View File

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

4
libs/xassets/xdynentitypose.cpp
View File

@ -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())
{

2
libs/xassets/xdynentitypose.h
View File

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

98
libs/xassets/xeditfielddefinition.cpp
View File

@ -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;
}
float XEditFieldDefinition::GetRange() const
{
return mRange;
}
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;
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()));
mRange = aStream->ParseSingle(QString("%1 range").arg(GetName()));
mMaxChars = aStream->ParseInt32(QString("%1 max chars").arg(GetName()));
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()));
}
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;
}

31
libs/xassets/xeditfielddefinition.h
View File

@ -6,34 +6,11 @@
class XEditFieldDefinition : public XAsset
{
public:
XEditFieldDefinition();
explicit XEditFieldDefinition();
~XEditFieldDefinition();
float GetMinVal() const;
void SetMinVal(float aMinVal);
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();
void ParseData(XDataStream* aStream) override;
void Clear() override;
private:
float mMinVal;

6
libs/xassets/xeffectdef.cpp
View File

@ -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
}

2
libs/xassets/xeffectdef.h
View File

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

26
libs/xassets/xeffectdefref.cpp
View File

@ -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();
mNamePtr = 0;
mName = "";
}
void XEffectDefRef::ParseData(QDataStream *aStream)
{
mName.Clear();
}

12
libs/xassets/xeffectdefref.h
View File

@ -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;
const XEffectDef *mHandle;
qint32 mNamePtr;
QString mName;
XEffectDef* mHandle;
XString mName;
};
#endif // XEFFECTDEFREF_H

29
libs/xassets/xeffecttable.cpp
View File

@ -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)
{
}

24
libs/xassets/xeffecttable.h
View File

@ -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

11
libs/xassets/xentryinternaldata.cpp
View File

@ -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()

4
libs/xassets/xentryinternaldata.h
View File

@ -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:

11
libs/xassets/xexpressionentry.cpp
View File

@ -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()

4
libs/xassets/xexpressionentry.h
View File

@ -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:

4
libs/xassets/xfile.cpp
View File

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

2
libs/xassets/xfile.h
View File

@ -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:

2
libs/xassets/xfont.cpp
View File

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

2
libs/xassets/xfont.h
View File

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

21
libs/xassets/xfxeffectdef.cpp
View File

@ -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
>> mTotalSize
>> mMsecLoopingLife
>> mElemDefCountLooping
>> mElemDefCountOneShot
>> mElemDefCountEmission
>> elemDefsPtr;
mFlags = aStream->ParseInt32(QString("%1 flags").arg(GetName()));
mTotalSize = aStream->ParseInt32(QString("%1 total size").arg(GetName()));
mMsecLoopingLife = aStream->ParseInt32(QString("%1 msec looping life").arg(GetName()));
mElemDefCountLooping = aStream->ParseInt32(QString("%1 elem def count looping").arg(GetName()));
mElemDefCountOneShot = aStream->ParseInt32(QString("%1 elem def count one shot").arg(GetName()));
mElemDefCountEmission = aStream->ParseInt32(QString("%1 elem def count emission").arg(GetName()));
elemDefsPtr = aStream->ParseInt32(QString("%1 elem defs ptr").arg(GetName()));
mName.ParseData(aStream);
@ -51,3 +50,5 @@ void XFxEffectDef::ParseData(QDataStream *aStream)
}
}
}

2
libs/xassets/xfxeffectdef.h
View File

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

13
libs/xassets/xfxelematlas.cpp
View File

@ -10,12 +10,7 @@ XFxElemAtlas::XFxElemAtlas()
, mRowIndexBits(0)
, mEntryCount(0)
{
}
XFxElemAtlas::~XFxElemAtlas()
{
SetName("Element Atlas");
}
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
}

4
libs/xassets/xfxelematlas.h
View File

@ -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;

55
libs/xassets/xfxelemdef.cpp
View File

@ -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
>> mVisualCount
>> mVelIntervalCount
>> mVisStateIntervalCount
>> velSamplesPtr
>> visSamplesPtr;
mElemType = aStream->ParseUInt8(QString("%1 elem type").arg(GetName()));
mVisualCount = aStream->ParseUInt8(QString("%1 visual count").arg(GetName()));
mVelIntervalCount = aStream->ParseUInt8(QString("%1 vel interval count").arg(GetName()));
mVisStateIntervalCount = aStream->ParseUInt8(QString("%1 vis state interval count").arg(GetName()));
velSamplesPtr = aStream->ParseInt32(QString("%1 vel samples ptr").arg(GetName()));
visSamplesPtr = aStream->ParseInt32(QString("%1 vis samples ptr").arg(GetName()));
mVisuals.ParseData(aStream);
*aStream
>> mCollMins[0]
>> mCollMins[1]
>> mCollMins[2]
>> mCollMaxs[0]
>> mCollMaxs[1]
>> mCollMaxs[2];
mCollMins.setX(aStream->ParseSingle(QString("%1 coll mins x").arg(GetName())));
mCollMins.setY(aStream->ParseSingle(QString("%1 coll mins y").arg(GetName())));
mCollMins.setZ(aStream->ParseSingle(QString("%1 coll mins z").arg(GetName())));
mCollMaxs.setX(aStream->ParseSingle(QString("%1 coll maxs x").arg(GetName())));
mCollMaxs.setY(aStream->ParseSingle(QString("%1 coll maxs y").arg(GetName())));
mCollMaxs.setZ(aStream->ParseSingle(QString("%1 coll maxs z").arg(GetName())));
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;
trailDefPtr = aStream->ParseInt32(QString("%1 trail def ptr").arg(GetName()));
mSortOrder = aStream->ParseUInt8(QString("%1 sort order").arg(GetName()));
mLightingFrac = aStream->ParseUInt8(QString("%1 lighting frac").arg(GetName()));
mUseItemClip = aStream->ParseUInt8(QString("%1 use item clip").arg(GetName()));
aStream->skipRawData(1);

2
libs/xassets/xfxelemdef.h
View File

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

19
libs/xassets/xfxelemdefvisuals.cpp
View File

@ -2,30 +2,23 @@
XFxElemDefVisuals::XFxElemDefVisuals()
: XAsset()
, mMarkArrayPtr(0)
, mMarkArray()
, mArrayPtr(0)
, mArray()
, mInstance()
{
}
XFxElemDefVisuals::~XFxElemDefVisuals()
{
SetName("Element Definition Visuals");
}
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
}

8
libs/xassets/xfxelemdefvisuals.h
View File

@ -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;
};

11
libs/xassets/xfxelemmarkvisuals.cpp
View File

@ -5,12 +5,7 @@ XFxElemMarkVisuals::XFxElemMarkVisuals()
, mMaterialPtrs()
, mMaterials()
{
}
XFxElemMarkVisuals::~XFxElemMarkVisuals()
{
SetName("Element Mark Visuals");
}
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
}

2
libs/xassets/xfxelemmarkvisuals.h
View File

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

4
libs/xassets/xfxelemvec3range.cpp
View File

@ -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]

2
libs/xassets/xfxelemvec3range.h
View File

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

4
libs/xassets/xfxelemvelstateinframe.cpp
View File

@ -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);

2
libs/xassets/xfxelemvelstateinframe.h
View File

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

4
libs/xassets/xfxelemvelstatesample.cpp
View File

@ -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);

2
libs/xassets/xfxelemvelstatesample.h
View File

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

4
libs/xassets/xfxelemvisstatesample.cpp
View File

@ -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);

2
libs/xassets/xfxelemvisstatesample.h
View File

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

8
libs/xassets/xfxelemvisuals.cpp
View File

@ -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
}

2
libs/xassets/xfxelemvisuals.h
View File

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

4
libs/xassets/xfxelemvisualstate.cpp
View File

@ -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

2
libs/xassets/xfxelemvisualstate.h
View File

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

8
libs/xassets/xfxfloatrange.cpp
View File

@ -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
}

2
libs/xassets/xfxfloatrange.h
View File

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

8
libs/xassets/xfximpactentry.cpp
View File

@ -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
}

2
libs/xassets/xfximpactentry.h
View File

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

6
libs/xassets/xfximpacttable.cpp
View File

@ -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
}

2
libs/xassets/xfximpacttable.h
View File

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

8
libs/xassets/xfxintrange.cpp
View File

@ -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
}

2
libs/xassets/xfxintrange.h
View File

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

8
libs/xassets/xfxspawndef.cpp
View File

@ -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
}

2
libs/xassets/xfxspawndef.h
View File

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

8
libs/xassets/xfxspawndeflooping.cpp
View File

@ -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
}

2
libs/xassets/xfxspawndeflooping.h
View File

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

8
libs/xassets/xfxspawndefoneshot.cpp
View File

@ -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
}

Some files were not shown because too many files have changed in this diff Show More