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

Refactor: Updated compression functions for LZX format.

Browse Source
This commit is contained in:
njohnson 2025-09-15 18:52:05 -04:00
parent 622323117a
commit 8d5e5812ec
33 changed files with 276 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
libs/compression/compression.cpp
View File

@ -31,7 +31,8 @@ QByteArray Compression::CompressXMem(const QByteArray &data)
return output;
}
QByteArray Compression::DecompressXMem(const QByteArray &data, int flags, int windowSize, int partSize)
QByteArray Compression::DecompressXMem(const QByteArray &data,
int flags, int windowSize, int partSize)
{
if (data.isEmpty())
return {};
@ -41,27 +42,49 @@ QByteArray Compression::DecompressXMem(const QByteArray &data, int flags, int wi
lzxParams.WindowSize = windowSize;
lzxParams.CompressionPartitionSize = partSize;
XMEMDECOMPRESSION_CONTEXT ctx = nullptr;
if (FAILED(XMemCreateDecompressionContext(XMEMCODEC_LZX, &lzxParams, 0, &ctx)) || !ctx)
return {};
QByteArray internalState(0x94933, Qt::Uninitialized);
// Allocate large enough buffer for decompression (16 MB is a safe upper bound)
const SIZE_T kMaxOutSize = 16 * 1024 * 1024;
QByteArray output(static_cast<int>(kMaxOutSize), Qt::Uninitialized);
SIZE_T actualSize = kMaxOutSize;
XMEMDECOMPRESSION_CONTEXT ctx = XMemInitializeDecompressionContext(
XMEMCODEC_LZX, &lzxParams, 1,
internalState.data(), internalState.size());
HRESULT hr = XMemDecompress(ctx,
output.data(), &actualSize,
data.constData(), data.size() + 16);
XMemDestroyDecompressionContext(ctx);
if (FAILED(hr)) {
qWarning() << "XMemDecompress failed with HRESULT:" << hr;
if (!ctx || XMemResetDecompressionContext(ctx)) {
qWarning() << "Failed to init LZX context";
return {};
}
output.resize(static_cast<int>(actualSize));
QByteArray output;
output.reserve(16 * 1024 * 1024); // rough guess
const quint8 *nextIn = reinterpret_cast<const quint8*>(data.constData());
SIZE_T availIn = data.size();
QByteArray scratch(0x10000, Qt::Uninitialized); // 64 KB chunks
while (availIn > 0) {
SIZE_T inSize = availIn; // let XMem tell us how much it will consume
SIZE_T outSize = scratch.size(); // max 64 KB per call
HRESULT hr = XMemDecompressStream(ctx,
scratch.data(), &outSize,
nextIn, &inSize);
if (FAILED(hr)) {
qWarning() << "XMemDecompressStream failed, hr=" << hr;
XMemDestroyDecompressionContext(ctx);
return {};
}
if (inSize == 0 && outSize == 0)
break; // no progress
output.append(scratch.constData(), static_cast<int>(outSize));
nextIn += inSize;
availIn -= inSize;
}
XMemDestroyDecompressionContext(ctx);
return output;
}
@ -77,19 +100,18 @@ quint32 Compression::CalculateAdler32Checksum(const QByteArray &data) {
qint64 Compression::FindZlibOffset(const QByteArray &bytes)
{
static const QByteArray iwffs("IWffs");
auto idx = bytes.indexOf(iwffs);
if (idx != -1)
return idx + 0x4000;
QDataStream stream(bytes);
const char header = 0x78; // z-lib: 0x78 [FLG]
int pos = -1;
while ((pos = bytes.indexOf(header, pos + 1)) != -1)
while (!stream.atEnd())
{
QByteArray window = bytes.mid(pos, 0x20);
if (!window.contains(QByteArray::fromHex("000000")) &&
!window.contains(QByteArray::fromHex("FFFFFF")))
return pos;
QByteArray testSegment = stream.device()->peek(2).toHex().toUpper();
if (testSegment == "7801" ||
testSegment == "785E" ||
testSegment == "789C" ||
testSegment == "78DA") {
return stream.device()->pos();
}
stream.skipRawData(1);
}
return -1;
}

6
libs/compression/minilzo.c
View File

@ -25,12 +25,6 @@
http://www.oberhumer.com/opensource/lzo/
*/
/*
* NOTE:
* the full LZO package can be found at
* http://www.oberhumer.com/opensource/lzo/
*/
#define __LZO_IN_MINILZO 1
#if defined(LZO_CFG_FREESTANDING)

18
libs/core/xdatastream.cpp
View File

@ -223,3 +223,21 @@ double XDataStream::ParseDouble(const QString& aDebugString)
}
return val;
}
bool XDataStream::ParseBool(const QString &aDebugString)
{
qint64 start = this->device()->pos();
char val;
*this >> val;
if (mDebug)
{
qDebug() << QString("[%1-%2] Parsed %3: %4")
.arg(start, 10, 10, QChar('0'))
.arg(this->device()->pos(), 10, 10, QChar('0'))
.arg(aDebugString)
.arg(val);
}
return val;
}

1
libs/core/xdatastream.h
View File

@ -25,6 +25,7 @@ public:
quint64 ParseUInt64(const QString& aDebugString = "");
float ParseSingle(const QString& aDebugString = "");
double ParseDouble(const QString& aDebugString = "");
bool ParseBool(const QString& aDebugString = "");
private:
bool mDebug;

6
libs/libs.pro
View File

@ -6,6 +6,6 @@ SUBDIRS += core \
fastfile \
xassets \
zonefile \
ddsfile \
iwifile \
ipakfile
#ddsfile \
#iwifile \
#ipakfile

8
libs/xassets/xd3denums.h
View File

@ -1,7 +1,9 @@
#ifndef XD3DENUMS_H
#define XD3DENUMS_H
enum XD3DResourceType
#include <QtTypes>
enum XD3DResourceType : qint32
{
D3DRTYPE_NONE = 0x0,
D3DRTYPE_VERTEXBUFFER = 0x1,
@ -21,7 +23,7 @@ enum XD3DResourceType
D3DRTYPE_FORCE_DWORD = 0x7FFFFFFF,
};
enum XD3DFormat
enum XD3DFormat : qint32
{
D3DFMT_DXT1 = 0x1A200152,
D3DFMT_LIN_DXT1 = 0x1A200052,
@ -177,7 +179,7 @@ enum XD3DFormat
D3DFMT_FORCE_DWORD = 0x7FFFFFFF,
};
enum XD3DMultiSampleType
enum XD3DMultiSampleType : qint32
{
D3DMULTISAMPLE_NONE = 0x0,
D3DMULTISAMPLE_2_SAMPLES = 0x1,

4
libs/xassets/xoperandinternaldataunion.cpp
View File

@ -16,9 +16,7 @@ XOperandInternalDataUnion::~XOperandInternalDataUnion()
void XOperandInternalDataUnion::ParseData(XDataStream *aStream)
{
Q_UNUSED(aStream);
// TODO: Fill in XOperandInternalDataUnion::ParseData
aStream->ParseSingle(QString("%1 center of mass x").arg(GetName()));
}
void XOperandInternalDataUnion::Clear()

17
libs/xassets/xphysmass.cpp
View File

@ -9,16 +9,19 @@ XPhysMass::XPhysMass()
SetName("Phys Mass");
}
XPhysMass::~XPhysMass()
{
}
void XPhysMass::ParseData(XDataStream *aStream)
{
Q_UNUSED(aStream);
mCenterOfMass.setX(aStream->ParseSingle(QString("%1 center of mass x").arg(GetName())));
mCenterOfMass.setY(aStream->ParseSingle(QString("%1 center of mass y").arg(GetName())));
mCenterOfMass.setZ(aStream->ParseSingle(QString("%1 center of mass z").arg(GetName())));
// TODO: Fill in XPhysMass::ParseData
mMomentsOfInertia.setX(aStream->ParseSingle(QString("%1 moments of inertia x").arg(GetName())));
mMomentsOfInertia.setY(aStream->ParseSingle(QString("%1 moments of inertia y").arg(GetName())));
mMomentsOfInertia.setZ(aStream->ParseSingle(QString("%1 moments of inertia y").arg(GetName())));
mProductsOfInertia.setX(aStream->ParseSingle(QString("%1 products of inertia x").arg(GetName())));
mProductsOfInertia.setY(aStream->ParseSingle(QString("%1 products of inertia y").arg(GetName())));
mProductsOfInertia.setZ(aStream->ParseSingle(QString("%1 products of inertia z").arg(GetName())));
}
void XPhysMass::Clear()

4
libs/xassets/xphysmass.h
View File

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

22
libs/xassets/xrectdef.cpp
View File

@ -4,32 +4,30 @@ XRectDef::XRectDef()
: XAsset()
, mX(0)
, mY(0)
, mW(0)
, mH(0)
, mWidth(0)
, mHeight(0)
, mHorzAlign(0)
, mVertAlign(0)
{
SetName("Rectangle Definition");
}
XRectDef::~XRectDef()
{
}
void XRectDef::ParseData(XDataStream *aStream)
{
Q_UNUSED(aStream);
// TODO: Fill in XRectDef::ParseData
mX = aStream->ParseSingle(QString("%1 x").arg(GetName()));
mY = aStream->ParseSingle(QString("%1 y").arg(GetName()));
mWidth = aStream->ParseSingle(QString("%1 width").arg(GetName()));
mHeight = aStream->ParseSingle(QString("%1 height").arg(GetName()));
mHorzAlign = aStream->ParseInt32(QString("%1 horizontal align").arg(GetName()));
mVertAlign = aStream->ParseInt32(QString("%1 vertical align").arg(GetName()));
}
void XRectDef::Clear()
{
mX = 0;
mY = 0;
mW = 0;
mH = 0;
mWidth = 0;
mHeight = 0;
mHorzAlign = 0;
mVertAlign = 0;
}

10
libs/xassets/xrectdef.h
View File

@ -7,7 +7,7 @@ class XRectDef : public XAsset
{
public:
explicit XRectDef();
~XRectDef();
~XRectDef() = default;
void ParseData(XDataStream *aStream) override;
void Clear() override;
@ -15,10 +15,10 @@ public:
private:
float mX;
float mY;
float mW;
float mH;
int mHorzAlign;
int mVertAlign;
float mWidth;
float mHeight;
qint32 mHorzAlign;
qint32 mVertAlign;
};
#endif // XRECTDEF_H

19
libs/xassets/xsrftriangles.cpp
View File

@ -13,16 +13,21 @@ XSrfTriangles::XSrfTriangles()
SetName("Surface Triangles");
}
XSrfTriangles::~XSrfTriangles()
{
}
void XSrfTriangles::ParseData(XDataStream *aStream)
{
Q_UNUSED(aStream);
mVertexLayerData = aStream->ParseInt32(QString("%1 vertex layer data").arg(GetName()));
mFirstVertex = aStream->ParseInt32(QString("%1 first vertex").arg(GetName()));
mVertexCount = aStream->ParseUInt32(QString("%1 vertex count").arg(GetName()));
mTriCount = aStream->ParseUInt32(QString("%1 tri count").arg(GetName()));
mBaseIndex = aStream->ParseInt32(QString("%1 base index").arg(GetName()));
// TODO: Fill in XSrfTriangles::ParseData
mTopMipMins.setX(aStream->ParseSingle(QString("%1 top mip min x").arg(GetName())));
mTopMipMins.setY(aStream->ParseSingle(QString("%1 top mip min y").arg(GetName())));
mTopMipMins.setZ(aStream->ParseSingle(QString("%1 top mip min z").arg(GetName())));
mTopMipMins.setX(aStream->ParseSingle(QString("%1 top mip max x").arg(GetName())));
mTopMipMins.setY(aStream->ParseSingle(QString("%1 top mip max y").arg(GetName())));
mTopMipMins.setZ(aStream->ParseSingle(QString("%1 top mip max z").arg(GetName())));
}
void XSrfTriangles::Clear()

8
libs/xassets/xsrftriangles.h
View File

@ -9,17 +9,17 @@ class XSrfTriangles : public XAsset
{
public:
explicit XSrfTriangles();
~XSrfTriangles();
~XSrfTriangles() = default;
virtual void ParseData(XDataStream* aStream) override;
virtual void Clear() override;
private:
int mVertexLayerData;
int mFirstVertex;
qint32 mVertexLayerData;
qint32 mFirstVertex;
quint32 mVertexCount;
quint32 mTriCount;
int mBaseIndex;
qint32 mBaseIndex;
QVector3D mTopMipMins;
QVector3D mTopMipMaxs;
};

19
libs/xassets/xstatement.cpp
View File

@ -8,16 +8,21 @@ XStatement::XStatement()
SetName("Statement");
}
XStatement::~XStatement()
{
}
void XStatement::ParseData(XDataStream *aStream)
{
Q_UNUSED(aStream);
mNumEntries = aStream->ParseInt32(QString("%1 # entries").arg(GetName()));
// TODO: Fill in XStatement::ParseData
qint32 entriesPtr;
entriesPtr = aStream->ParseInt32(QString("%1 entries ptr").arg(GetName()));
if (entriesPtr)
{
for (int i = 0; i < mNumEntries; i++)
{
XExpressionEntry newEntry;
newEntry.ParsePtr(aStream);
mEntries.append(newEntry);
}
}
}
void XStatement::Clear()

6
libs/xassets/xstatement.h
View File

@ -10,14 +10,14 @@ class XStatement : public XAsset
{
public:
explicit XStatement();
~XStatement();
~XStatement() = default;
void ParseData(XDataStream *aStream) override;
void Clear() override;
private:
int mNumEntries;
QVector<XExpressionEntry*> mEntries;
qint32 mNumEntries;
QVector<XExpressionEntry> mEntries;
};
#endif // XSTATEMENT_H

12
libs/xassets/xstreamdelayinfo.cpp
View File

@ -2,26 +2,18 @@
XStreamDelayInfo::XStreamDelayInfo()
: XAsset()
, mPtr(0)
, mSize(0)
{
SetName("Stream Delay Info");
}
XStreamDelayInfo::~XStreamDelayInfo()
{
}
void XStreamDelayInfo::Clear()
{
mPtr = nullptr;
//mPtr = nullptr;
mSize = 0;
}
void XStreamDelayInfo::ParseData(XDataStream *aStream)
{
Q_UNUSED(aStream);
// TODO: Fill in XStreamDelayInfo::ParseData
mSize = aStream->ParseInt32(QString("%1 size").arg(GetName()));
}

6
libs/xassets/xstreamdelayinfo.h
View File

@ -7,14 +7,14 @@ class XStreamDelayInfo : public XAsset
{
public:
XStreamDelayInfo();
~XStreamDelayInfo();
~XStreamDelayInfo() = default;
virtual void Clear() override;
virtual void ParseData(XDataStream* aStream) override;
private:
const void *mPtr;
int mSize;
//const void *mPtr;
qint32 mSize;
};
#endif // XSTREAMDELAYINFO_H

12
libs/xassets/xstreamedsound.cpp
View File

@ -2,23 +2,17 @@
XStreamedSound::XStreamedSound()
: XAsset()
, mFileName()
{
SetName("Streamed Sound");
}
XStreamedSound::~XStreamedSound()
{
}
void XStreamedSound::ParseData(XDataStream *aStream)
{
Q_UNUSED(aStream);
// TODO: Fill in XStreamedSound::ParseData
mFileName.ParseData(aStream);
}
void XStreamedSound::Clear()
{
mFileName.Clear();
}

7
libs/xassets/xstreamedsound.h
View File

@ -2,20 +2,19 @@
#define XSTREAMEDSOUND_H
#include "xasset.h"
class XStreamedFileName;
#include "xstreamfilename.h"
class XStreamedSound : public XAsset
{
public:
XStreamedSound();
~XStreamedSound();
~XStreamedSound() = default;
virtual void ParseData(XDataStream* aStream) override;
virtual void Clear() override;
private:
XStreamedFileName* mStreamed;
XStreamFileName mFileName;
};
#endif // XSTREAMEDSOUND_H

19
libs/xassets/xstreamfileinfo.cpp
View File

@ -1,24 +1,31 @@
#include "xstreamfileinfo.h"
#include "xstreamfilename.h"
XStreamFileInfo::XStreamFileInfo()
: XAsset()
, mParent(nullptr)
, mRaw()
{
SetName("Stream File Info");
}
XStreamFileInfo::~XStreamFileInfo()
XStreamFileInfo::XStreamFileInfo(XStreamFileName &aParent)
: XAsset()
, mParent(&aParent)
, mRaw()
{
SetName("Stream File Info");
}
void XStreamFileInfo::Clear()
{
mRaw.Clear();
}
void XStreamFileInfo::ParseData(XDataStream *aStream)
{
Q_UNUSED(aStream);
// TODO: Fill in XStreamFileInfo::ParseData
if (mParent && !mParent->GetFileIndex())
{
mRaw.ParseData(aStream);
}
}

8
libs/xassets/xstreamfileinfo.h
View File

@ -2,21 +2,23 @@
#define XSTREAMFILEINFO_H
#include "xasset.h"
#include "xstreamfilenamepacked.h"
#include "xstreamfilenameraw.h"
class XStreamFileName;
class XStreamFileInfo : public XAsset
{
public:
XStreamFileInfo();
~XStreamFileInfo();
XStreamFileInfo(XStreamFileName& aParent);
~XStreamFileInfo() = default;
virtual void Clear() override;
virtual void ParseData(XDataStream* aStream) override;
private:
XStreamFileName* mParent;
XStreamFileNameRaw mRaw;
XStreamFileNamePacked mPacked;
};
#endif // XSTREAMFILEINFO_H

14
libs/xassets/xstreamfilename.cpp
View File

@ -8,16 +8,11 @@ XStreamFileName::XStreamFileName()
SetName("Stream File Name");
}
XStreamFileName::~XStreamFileName()
{
}
void XStreamFileName::ParseData(XDataStream *aStream)
{
Q_UNUSED(aStream);
mFileIndex = aStream->ParseUInt32(QString("%1 file index").arg(GetName()));
// TODO: Fill in XStreamFileName::ParseData
mInfo.ParseData(aStream);
}
void XStreamFileName::Clear()
@ -25,3 +20,8 @@ void XStreamFileName::Clear()
mFileIndex = 0;
mInfo.Clear();
}
quint32 XStreamFileName::GetFileIndex() const
{
return mFileIndex;
}

4
libs/xassets/xstreamfilename.h
View File

@ -8,11 +8,13 @@ class XStreamFileName : public XAsset
{
public:
explicit XStreamFileName();
~XStreamFileName();
~XStreamFileName() = default;
virtual void ParseData(XDataStream* aStream) override;
virtual void Clear() override;
quint32 GetFileIndex() const;
private:
quint32 mFileIndex;
XStreamFileInfo mInfo;

15
libs/xassets/xstreamfilenamepacked.cpp
View File

@ -2,23 +2,20 @@
XStreamFileNamePacked::XStreamFileNamePacked()
: XAsset()
, mOffset(0)
, mLength(0)
{
SetName("Stream File Name Packed");
}
XStreamFileNamePacked::~XStreamFileNamePacked()
{
}
void XStreamFileNamePacked::ParseData(XDataStream *aStream)
{
Q_UNUSED(aStream);
// TODO: Fill in XStreamFileNamePacked::ParseData
mOffset = aStream->ParseUInt32(QString("%1 offset").arg(GetName()));
mLength = aStream->ParseUInt32(QString("%1 length").arg(GetName()));
}
void XStreamFileNamePacked::Clear()
{
mOffset = 0;
mLength = 0;
}

2
libs/xassets/xstreamfilenamepacked.h
View File

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

16
libs/xassets/xstreamfilenameraw.cpp
View File

@ -2,23 +2,23 @@
XStreamFileNameRaw::XStreamFileNameRaw()
: XAsset()
, mDir()
, mName()
{
SetName("Stream File Name Raw");
}
XStreamFileNameRaw::~XStreamFileNameRaw()
{
}
void XStreamFileNameRaw::ParseData(XDataStream *aStream)
{
Q_UNUSED(aStream);
mDir.ParsePtr(aStream, false);
mName.ParsePtr(aStream, false);
// TODO: Fill in XStreamFileNameRaw::ParseData
mDir.ParseData(aStream);
mName.ParseData(aStream);
}
void XStreamFileNameRaw::Clear()
{
mDir.Clear();
mName.Clear();
}

6
libs/xassets/xstreamfilenameraw.h
View File

@ -8,14 +8,14 @@ class XStreamFileNameRaw : public XAsset
{
public:
XStreamFileNameRaw();
~XStreamFileNameRaw();
~XStreamFileNameRaw() = default;
virtual void ParseData(XDataStream* aStream) override;
virtual void Clear() override;
private:
XString* mDir;
XString* mName;
XString mDir;
XString mName;
};
#endif // XSTREAMFILENAMERAW_H

11
libs/xassets/xstreamsourceinfo.cpp
View File

@ -9,11 +9,6 @@ XStreamSourceInfo::XStreamSourceInfo()
SetName("Stream Source Info");
}
XStreamSourceInfo::~XStreamSourceInfo()
{
}
void XStreamSourceInfo::Clear()
{
mStream = 0;
@ -23,7 +18,7 @@ void XStreamSourceInfo::Clear()
void XStreamSourceInfo::ParseData(XDataStream *aStream)
{
Q_UNUSED(aStream);
// TODO: Fill in XStreamSourceInfo::ParseData
mStream = aStream->ParseUInt16(QString("%1 stream").arg(GetName()));
mOffset = aStream->ParseUInt16(QString("%1 offset").arg(GetName()));
mType = aStream->ParseUInt32(QString("%1 type").arg(GetName()));
}

6
libs/xassets/xstreamsourceinfo.h
View File

@ -7,14 +7,14 @@ class XStreamSourceInfo : public XAsset
{
public:
XStreamSourceInfo();
~XStreamSourceInfo();
~XStreamSourceInfo() = default;
virtual void Clear() override;
virtual void ParseData(XDataStream* aStream) override;
private:
quint32 mStream;
quint32 mOffset;
quint16 mStream;
quint16 mOffset;
quint32 mType;
};

16
libs/xassets/xtexturedesc.cpp
View File

@ -35,5 +35,19 @@ void XTextureDesc::ParseData(XDataStream *aStream)
{
Q_UNUSED(aStream);
// TODO: Fill in XTextureDesc::ParseData
mResourceType = (XD3DResourceType)aStream->ParseInt32(QString("%1 resource type").arg(GetName()));
mWidth = aStream->ParseUInt32(QString("%1 width").arg(GetName()));
mHeight = aStream->ParseUInt32(QString("%1 height").arg(GetName()));
mDepth = aStream->ParseUInt32(QString("%1 depth").arg(GetName()));
mFormat = (XD3DFormat)aStream->ParseInt32(QString("%1 format").arg(GetName()));
mRowPitch = aStream->ParseUInt32(QString("%1 row pitch").arg(GetName()));
mSlicePitch = aStream->ParseUInt32(QString("%1 slice pitch").arg(GetName()));
mBitsPerPixel = aStream->ParseUInt32(QString("%1 bits per pixel").arg(GetName()));
mWidthInBlocks = aStream->ParseUInt32(QString("%1 width in blocks").arg(GetName()));
mHeightInBlocks = aStream->ParseUInt32(QString("%1 height in blocks").arg(GetName()));
mDepthInBlocks = aStream->ParseUInt32(QString("%1 depth in blocks").arg(GetName()));
mBytesPerBlock = aStream->ParseUInt32(QString("%1 bytes per block").arg(GetName()));
mExpBias = aStream->ParseInt32(QString("%1 exp bias").arg(GetName()));
mFlags = aStream->ParseUInt32(QString("%1 flags").arg(GetName()));
mMultiSampleType = (XD3DMultiSampleType)aStream->ParseInt32(QString("%1 multi-sample type").arg(GetName()));
}

2
libs/xassets/xwaterwritable.cpp
View File

@ -16,7 +16,7 @@ void XWaterWritable::ParseData(XDataStream *aStream)
{
Q_UNUSED(aStream);
// TODO: Fill in XWaterWritable::ParseData
mFloatTime = aStream->ParseSingle(QString("%1 float time").arg(GetName()));
}
void XWaterWritable::Clear()

65
libs/xassets/xwindowdef.cpp
View File

@ -2,10 +2,10 @@
XWindowDef::XWindowDef()
: XAsset()
, mName("")
, mName()
, mRect()
, mRectClient()
, mGroup("")
, mGroup()
, mStyle(0)
, mBorder(0)
, mOwnerDraw(0)
@ -18,7 +18,7 @@ XWindowDef::XWindowDef()
, mBackColor()
, mBorderColor()
, mOutlineColor()
, mBackground(new XMaterial())
, mBackground()
{
SetName("Window Definition");
}
@ -32,15 +32,66 @@ void XWindowDef::ParseData(XDataStream *aStream)
{
Q_UNUSED(aStream);
// TODO: Fill in XWindowDef::ParseData
mName.ParsePtr(aStream, false);
mRect.ParseData(aStream);
mRectClient.ParseData(aStream);
mGroup.ParsePtr(aStream, false);
mStyle = aStream->ParseInt32(QString("%1 style").arg(GetName()));
mBorder = aStream->ParseInt32(QString("%1 border").arg(GetName()));
mOwnerDraw = aStream->ParseInt32(QString("%1 owner draw").arg(GetName()));
mOwnerDrawFlags = aStream->ParseInt32(QString("%1 owner draw flags").arg(GetName()));
mBorderSize = aStream->ParseSingle(QString("%1 border size").arg(GetName()));
mStaticFlags = aStream->ParseInt32(QString("%1 static flags").arg(GetName()));
for (int i = 0; i < 4; i++)
{
mDynamicFlags[i] = aStream->ParseInt32(QString("%1 dynamic flag %2").arg(GetName()).arg(i));
}
mNextTime = aStream->ParseInt32(QString("%1 next time").arg(GetName()));
float r, g, b, a;
r = aStream->ParseSingle(QString("%1 foreground red").arg(GetName()));
g = aStream->ParseSingle(QString("%1 foreground green").arg(GetName()));
b = aStream->ParseSingle(QString("%1 foreground blue").arg(GetName()));
a = aStream->ParseSingle(QString("%1 foreground alpha").arg(GetName()));
mForeColor = QColor(r, g, b, a);
r = aStream->ParseSingle(QString("%1 background red").arg(GetName()));
g = aStream->ParseSingle(QString("%1 background green").arg(GetName()));
b = aStream->ParseSingle(QString("%1 background blue").arg(GetName()));
a = aStream->ParseSingle(QString("%1 background alpha").arg(GetName()));
mBackColor = QColor(r, g, b, a);
r = aStream->ParseSingle(QString("%1 border red").arg(GetName()));
g = aStream->ParseSingle(QString("%1 border green").arg(GetName()));
b = aStream->ParseSingle(QString("%1 border blue").arg(GetName()));
a = aStream->ParseSingle(QString("%1 border alpha").arg(GetName()));
mBorderColor = QColor(r, g, b, a);
r = aStream->ParseSingle(QString("%1 outline red").arg(GetName()));
g = aStream->ParseSingle(QString("%1 outline green").arg(GetName()));
b = aStream->ParseSingle(QString("%1 outline blue").arg(GetName()));
a = aStream->ParseSingle(QString("%1 outline alpha").arg(GetName()));
mOutlineColor = QColor(r, g, b, a);
mBackground.ParsePtr(aStream, false);
mName.ParseData(aStream);
mGroup.ParseData(aStream);
mBackground.ParseData(aStream);
}
void XWindowDef::Clear()
{
mName.clear();
mName.Clear();
mRect.Clear();
mRectClient.Clear();
mGroup.clear();
mGroup.Clear();
mStyle = 0;
mBorder = 0;
mOwnerDraw = 0;
@ -53,5 +104,5 @@ void XWindowDef::Clear()
mBackColor = QColor();
mBorderColor = QColor();
mOutlineColor = QColor();
mBackground->Clear();
mBackground.Clear();
}

6
libs/xassets/xwindowdef.h
View File

@ -17,10 +17,10 @@ public:
void Clear() override;
private:
QString mName;
XString mName;
XRectDef mRect;
XRectDef mRectClient;
QString mGroup;
XString mGroup;
int mStyle;
int mBorder;
int mOwnerDraw;
@ -33,7 +33,7 @@ private:
QColor mBackColor;
QColor mBorderColor;
QColor mOutlineColor;
XMaterial *mBackground;
XMaterial mBackground;
};
#endif // XWINDOWDEF_H