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

Compare commits

base: njohnson:main
Branches Tags
njohnson:main
njohnson:feature/test
njohnson:feature/from_ida
njohnson:feature/icon_factory
njohnson:feature/bo3_ff_processing
njohnson:feature/parse_menu_items
njohnson:feature/parse_bik_file
njohnson:feature/new_shit
njohnson:feature/uplift_ui
njohnson:feature/rebrand
njohnson:v1.6
njohnson:v
njohnson:1.5
njohnson:1.4
njohnson:1.1
njohnson:1.0
..
compare: njohnson:v1.6
Branches Tags
njohnson:main
njohnson:feature/test
njohnson:feature/from_ida
njohnson:feature/icon_factory
njohnson:feature/bo3_ff_processing
njohnson:feature/parse_menu_items
njohnson:feature/parse_bik_file
njohnson:feature/new_shit
njohnson:feature/uplift_ui
njohnson:feature/rebrand
njohnson:v1.6
njohnson:v
njohnson:1.5
njohnson:1.4
njohnson:1.1
njohnson:1.0

No commits in common. "main" and "v1.6" have entirely different histories.
main ... v1.6

988 changed files with 51761 additions and 281286 deletions
Show Stats Expand all files Collapse all files

13
.gitignore vendored
View File

@ -1,10 +1,6 @@
/build/
/data/dlls/
/data/fastfiles/
/releases/
.vscode/*
.qmake.stash
# Ignore Qt Creator user files
*.pro.user
@ -14,12 +10,3 @@
*.creator.user
*.creator.user.*
*.creator.*
*.ps1
version.txt
*.autosave
*.XMODEL_EXPORT
data/obj/*
libs/*/release/*
libs/*/debug/*
.git.stash
*Makefile*

8
XPlor.pro
View File

@ -2,9 +2,9 @@ TEMPLATE = subdirs
SUBDIRS += libs \
app \
#tools \
#tests
tools \
tests
#tests.depends = libs
tests.depends = libs
app.depends = libs
#tools.depends = libs
tools.depends = libs

36
ai-commit.sh
View File

@ -1,36 +0,0 @@
#!/bin/bash
set -e
# 1. Stage everything
git add -A
# 2. Get list of staged files
FILES=$(git diff --cached --name-only)
if [ -z "$FILES" ]; then
echo "No changes to commit."
exit 0
fi
# 3. Loop file by file
for FILE in $FILES; do
# Get diff for this file
DIFF=$(git diff --cached -- "$FILE")
if [ -z "$DIFF" ]; then
continue
fi
# Ask Ollama for a commit message describing this file change
MSG=$(echo "$DIFF" | ollama run gemma3 \
"You are a commit bot. Write a SHORT, clear, concise Git commit message for changes in file: $FILE.
Only output the commit message, nothing else.
Diff:
$DIFF")
# Commit just this file with its message
git commit -m "$MSG" -- "$FILE"
echo "✅ Committed $FILE with message:"
echo "$MSG"
done

77
app/app.pro
View File

@ -6,9 +6,63 @@ SUBDIRS += app
CONFIG += c++17
SOURCES += $$files($$PWD/*.cpp)
HEADERS += $$files($$PWD/*.h)
FORMS += $$files($$PWD/*.ui)
SOURCES += \
aboutdialog.cpp \
ddsviewer.cpp \
fastfileviewer.cpp \
imagewidget.cpp \
iwiviewer.cpp \
localstringviewer.cpp \
main.cpp \
mainwindow.cpp \
materialviewer.cpp \
preferenceeditor.cpp \
soundviewer.cpp \
stringtableviewer.cpp \
rumblegraphviewer.cpp \
rumblefileviewer.cpp \
techsetviewer.cpp \
xtreewidget.cpp \
xtreewidgetitem.cpp \
zonefileviewer.cpp
HEADERS += \
aboutdialog.h \
d3dbsp_structs.h \
ddsviewer.h \
fastfileviewer.h \
imagewidget.h \
iwiviewer.h \
localstringviewer.h \
mainwindow.h \
materialviewer.h \
preferenceeditor.h \
soundviewer.h \
stringtableviewer.h \
rumblegraphviewer.h \
rumblefileviewer.h \
techsetviewer.h \
xtreewidget.h \
xtreewidgetitem.h \
zonefileviewer.h
FORMS += \
aboutdialog.ui \
ddsviewer.ui \
fastfileviewer.ui \
imagewidget.ui \
iwiviewer.ui \
localstringviewer.ui \
mainwindow.ui \
materialviewer.ui \
modelviewer.ui \
preferenceeditor.ui \
soundviewer.ui \
stringtableviewer.ui \
rumblegraphviewer.ui \
rumblefileviewer.ui \
techsetviewer.ui \
zonefileviewer.ui
RESOURCES += ../data/data.qrc
@ -17,7 +71,6 @@ LIBS += \
-L$$PWD/../third_party/zlib/lib/ -lzlib \
-L$$PWD/../third_party/xbox_sdk/lib -lxcompress64 \
-L$$OUT_PWD/../libs/ -lcore \
-L$$OUT_PWD/../libs/ -lxassets\
-L$$OUT_PWD/../libs/ -lcompression \
-L$$OUT_PWD/../libs/ -lencryption \
-L$$OUT_PWD/../libs/ -lfastfile \
@ -37,7 +90,6 @@ INCLUDEPATH += \
$$PWD/../libs/ddsfile \
$$PWD/../libs/ipakfile \
$$PWD/../libs/iwifile \
$$PWD/../libs/xassets \
$$PWD/../libs/zonefile
DEPENDPATH += \
@ -51,11 +103,16 @@ DEPENDPATH += \
$$PWD/../libs/ddsfile \
$$PWD/../libs/ipakfile \
$$PWD/../libs/iwifile \
$$PWD/../libs/xassets \
$$PWD/../libs/zonefile
# Copy DLLs to Debug folder
QMAKE_POST_LINK += xcopy /Y /E /I \"G:/Projects/Qt/XPlor/third_party/devil_sdk/lib\\*.dll\" \"$$OUT_PWD/debug/\" $$escape_expand(\\n\\t)
QMAKE_POST_LINK += xcopy /Y /E /I \"G:/Projects/Qt/XPlor/third_party/zlib/lib\\*.dll\" \"$$OUT_PWD/debug/\" $$escape_expand(\\n\\t)
QMAKE_POST_LINK += xcopy /Y /E /I \"G:/Projects/Qt/XPlor/third_party/xna/lib\\*.dll\" \"$$OUT_PWD/debug/\" $$escape_expand(\\n\\t)
QMAKE_POST_LINK += xcopy /Y /E /I \"$$PWD/../third_party/xbox_sdk/lib\\*.dll\" \"$$OUT_PWD/debug/\" $$escape_expand(\\n\\t)
win32 {
QMAKE_POST_LINK =
QMAKE_POST_LINK += for /D %%G in (\"$$PWD/../third_party/*/lib\") do copy /Y \"%%~G\*.dll\" \"$$OUT_PWD/$$DESTDIR/\" >NUL $$escape_expand(\\n\\t)
}
# Copy DLLs to Release folder
QMAKE_POST_LINK += xcopy /Y /E /I \"G:/Projects/Qt/XPlor/third_party/devil_sdk/lib\\*.dll\" \"$$OUT_PWD/release/\" $$escape_expand(\\n\\t)
QMAKE_POST_LINK += xcopy /Y /E /I \"G:/Projects/Qt/XPlor/third_party/zlib/lib\\*.dll\" \"$$OUT_PWD/release/\" $$escape_expand(\\n\\t)
QMAKE_POST_LINK += xcopy /Y /E /I \"G:/Projects/Qt/XPlor/third_party/xna/lib\\*.dll\" \"$$OUT_PWD/release/\" $$escape_expand(\\n\\t)
QMAKE_POST_LINK += xcopy /Y /E /I \"$$PWD/../third_party/xbox_sdk/lib\\*.dll\" \"$$OUT_PWD/release/\" $$escape_expand(\\n\\t)

4
app/ddsviewer.cpp
View File

@ -14,8 +14,8 @@ DDSViewer::~DDSViewer() {
delete ui;
}
void DDSViewer::SetDDSFile(const DDSFile* aDDSFile) {
mDDSFile = aDDSFile;
void DDSViewer::SetDDSFile(std::shared_ptr<DDSFile> aDDSFile) {
mDDSFile.swap(aDDSFile);
ui->label_Title->setText(mDDSFile->fileStem + ".dds");

4
app/ddsviewer.h
View File

@ -16,14 +16,14 @@ public:
explicit DDSViewer(QWidget *parent = nullptr);
~DDSViewer();
void SetDDSFile(const DDSFile *aDDSFile);
void SetDDSFile(std::shared_ptr<DDSFile> aDDSFile);
private slots:
void MipmapIndexChanged(int aMipmapIndex);
private:
Ui::DDSViewer *ui;
const DDSFile* mDDSFile;
std::shared_ptr<DDSFile> mDDSFile;
};
#endif // DDSVIEWER_H

5
app/fastfileviewer.cpp
View File

@ -1,4 +1,5 @@
#include "fastfileviewer.h"
#include "asset_structs.h"
#include "ui_fastfileviewer.h"
FastFileViewer::FastFileViewer(QWidget *parent)
@ -14,8 +15,8 @@ FastFileViewer::~FastFileViewer()
delete ui;
}
void FastFileViewer::SetFastFile(const FastFile* aFastFile) {
mFastFile = aFastFile;
void FastFileViewer::SetFastFile(std::shared_ptr<FastFile> aFastFile) {
mFastFile.swap(aFastFile);
ui->label_Title->setText(mFastFile->GetStem());
ui->comboBox_Company->setCurrentIndex(mFastFile->GetCompany());

5
app/fastfileviewer.h
View File

@ -1,6 +1,7 @@
#ifndef FASTFILEVIEWER_H
#define FASTFILEVIEWER_H
#include "asset_structs.h"
#include "fastfile.h"
#include <QWidget>
@ -16,10 +17,10 @@ public:
explicit FastFileViewer(QWidget *parent = nullptr);
~FastFileViewer();
void SetFastFile(const FastFile *aFastFile);
void SetFastFile(std::shared_ptr<FastFile> aFastFile);
private:
Ui::FFViewer *ui;
const FastFile* mFastFile;
std::shared_ptr<FastFile> mFastFile;
};
#endif // FASTFILEVIEWER_H

10
app/imagewidget.cpp
View File

@ -13,16 +13,16 @@ ImageWidget::~ImageWidget()
delete ui;
}
void ImageWidget::SetImage(std::shared_ptr<QImage> aImage)
void ImageWidget::SetImage(std::shared_ptr<Image> aImage)
{
mImage = aImage;
//ui->lineEdit_Name->setText(aImage->name);
//ui->lineEdit_Role->setText(aImage->materialName);
//ui->comboBox_Compression->setCurrentIndex(aImage->compression);
ui->lineEdit_Name->setText(aImage->name);
ui->lineEdit_Role->setText(aImage->materialName);
ui->comboBox_Compression->setCurrentIndex(aImage->compression);
}
std::shared_ptr<QImage> ImageWidget::GetImage()
std::shared_ptr<Image> ImageWidget::GetImage()
{
return mImage;
}

7
app/imagewidget.h
View File

@ -4,6 +4,7 @@
#include "enums.h"
#include "dds_structs.h"
#include "d3dbsp_structs.h"
#include "asset_structs.h"
#include "ipak_structs.h"
#include <QWidget>
@ -20,11 +21,11 @@ public:
explicit ImageWidget(QWidget *parent = nullptr);
~ImageWidget();
void SetImage(std::shared_ptr<QImage> aImage);
std::shared_ptr<QImage> GetImage();
void SetImage(std::shared_ptr<Image> aImage);
std::shared_ptr<Image> GetImage();
private:
std::shared_ptr<QImage> mImage;
std::shared_ptr<Image> mImage;
Ui::ImageWidget *ui;
};

4
app/iwiviewer.cpp
View File

@ -14,8 +14,8 @@ IWIViewer::~IWIViewer()
delete ui;
}
void IWIViewer::SetIWIFile(const IWIFile* aIWIFile) {
mIWIFile = aIWIFile;
void IWIViewer::SetIWIFile(std::shared_ptr<IWIFile> aIWIFile) {
mIWIFile.swap(aIWIFile);
ui->label_Title->setText(mIWIFile->fileStem + ".iwi");

4
app/iwiviewer.h
View File

@ -18,10 +18,10 @@ public:
void MipmapIndexChanged(int aMipmapIndex);
void SetIWIFile(const IWIFile *aIWIFile);
void SetIWIFile(std::shared_ptr<IWIFile> aIWIFile);
private:
Ui::IWIViewer *ui;
const IWIFile* mIWIFile;
std::shared_ptr<IWIFile> mIWIFile;
};
#endif // IWIVIEWER_H

34
app/localstringviewer.cpp
View File

@ -37,22 +37,26 @@ void LocalStringViewer::SetFileNotes(const QString aFileNotes) {
ui->plainTextEdit_FileNotes->setPlainText(mFileNotes);
}
void LocalStringViewer::AddLocalString(XLocalizeEntry aLocalString) {
mLocalStrings.append(aLocalString);
ui->tableWidget_Strings->setRowCount(mLocalStrings.size());
ui->groupBox_LocalStrViewer->setTitle(QString("Entries (%1)").arg(mLocalStrings.size()));
QTableWidgetItem *aliasItem = new QTableWidgetItem(aLocalString.GetValue()->GetString());
QTableWidgetItem *stringItem = new QTableWidgetItem(aLocalString.GetName()->GetString());
ui->tableWidget_Strings->setItem(mLocalStrings.size() - 1, 0, aliasItem);
ui->tableWidget_Strings->setItem(mLocalStrings.size() - 1, 1, stringItem);
void LocalStringViewer::AddLocalString(LocalString aLocalString) {
mLocalStrings.append(aLocalString);
ui->tableWidget_Strings->setRowCount(mLocalStrings.size());
ui->groupBox_LocalStrViewer->setTitle(QString("Entries (%1)").arg(mLocalStrings.size()));
QTableWidgetItem *aliasItem = new QTableWidgetItem(aLocalString.alias);
QTableWidgetItem *stringItem = new QTableWidgetItem(aLocalString.string);
ui->tableWidget_Strings->setItem(mLocalStrings.size() - 1, 0, aliasItem);
ui->tableWidget_Strings->setItem(mLocalStrings.size() - 1, 1, stringItem);
}
void LocalStringViewer::SetZoneFile(const ZoneFile* aZoneFile) {
mLocalStrings.clear();
ui->tableWidget_Strings->clear();
void LocalStringViewer::SetZoneFile(std::shared_ptr<ZoneFile> aZoneFile) {
mLocalStrings.clear();
ui->tableWidget_Strings->clear();
ui->label_Title->setText(aZoneFile->GetStem().section('.', 0, 0) + ".str");
// for (const LocalString &localStr : aZoneFile->GetAssetMap().localStrings) {
// AddLocalString(localStr);
// }
ui->label_Title->setText(aZoneFile->GetStem().section('.', 0, 0) + ".str");
for (const LocalString &localStr : aZoneFile->GetAssetMap().localStrings) {
AddLocalString(localStr);
}
}

8
app/localstringviewer.h
View File

@ -1,7 +1,7 @@
#ifndef LOCALSTRINGVIEWER_H
#define LOCALSTRINGVIEWER_H
#include "xlocalizeentry.h"
#include "asset_structs.h"
#include "zonefile.h"
#include <QWidget>
@ -20,15 +20,15 @@ public:
void SetVersion(quint32 aVersion);
void SetConfigPath(const QString aConfigPath);
void SetFileNotes(const QString aFileNotes);
void AddLocalString(XLocalizeEntry aLocalString);
void SetZoneFile(const ZoneFile *aZoneFile);
void AddLocalString(LocalString aLocalString);
void SetZoneFile(std::shared_ptr<ZoneFile> aZoneFile);
private:
Ui::LocalStringViewer *ui;
quint32 mVersion;
QString mConfigPath;
QString mFileNotes;
QVector<XLocalizeEntry> mLocalStrings;
QVector<LocalString> mLocalStrings;
};
#endif // LOCALSTRINGVIEWER_H

246
app/mainwindow.cpp
View File

@ -1,7 +1,4 @@
#include "mainwindow.h"
#include "qtimer.h"
#include "ui_mainwindow.h"
#include "aboutdialog.h"
#include "fastfile.h"
#include "highlighter_gsc.h"
@ -10,10 +7,12 @@
#include "highlighter_rumble.h"
#include "materialviewer.h"
#include "preferenceeditor.h"
#include "reportissuedialog.h"
#include "rumblefileviewer.h"
#include "rumblegraphviewer.h"
#include "soundviewer.h"
#include "stringtableviewer.h"
#include "techsetviewer.h"
#include "ui_mainwindow.h"
#include "fastfile_factory.h"
#include "iwifile.h"
#include "ddsfile.h"
@ -23,11 +22,13 @@
#include "ipak_structs.h"
#include "iwiviewer.h"
#include "localstringviewer.h"
#include "imagewidget.h"
#include "xtreewidget.h"
#include "zonefileviewer.h"
#include "techsetviewer.h"
#include "logmanager.h"
#include <QtMath>
#include <qmath.h>
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent), ui(new Ui::MainWindow) {
@ -35,12 +36,10 @@ MainWindow::MainWindow(QWidget *parent)
setAcceptDrops(true);
XAsset::SetDebug(true);
mTypeMap = QMap<QString, int>();
mTypeOrder = QStringList();
mRawFileMap = QMap<QString, QString>();
//mImageMap = QMap<QString, Image>();
mImageMap = QMap<QString, Image>();
mTreeMap = QMap<QString, QTreeWidgetItem *>();
mStrTableMap = QMap<QString, QVector<QPair<QString, QString>>>();
mBSPVersion = 0;
@ -50,23 +49,13 @@ MainWindow::MainWindow(QWidget *parent)
mTreeWidget = new XTreeWidget(this);
mLogWidget = new QPlainTextEdit(this);
//ModelViewer *mModelViewer = new ModelViewer(container);
//mModelViewer->setAcceptDrops(false);
mProgressBar = new QProgressBar(this);
mProgressBar->setMaximum(100); // Default max value
mProgressBar->setVisible(false); // Initially hidden
connect(ui->actionRun_Tests, &QAction::triggered, this, [](bool checked) {
Q_UNUSED(checked);
});
connect(ui->actionReport_Issue, &QAction::triggered, this, [this](bool checked) {
Q_UNUSED(checked);
ReportIssueDialog issueDialog("https://git.redline.llc", "njohnson", "XPlor", "4738c4d2efd123efac1506c68c59b285c646df9f", this);
if (issueDialog.exec() == QDialog::Accepted) {
}
});
connect(&StatusBarManager::instance(), &StatusBarManager::statusUpdated,
this, &MainWindow::HandleStatusUpdate);
@ -159,7 +148,7 @@ MainWindow::MainWindow(QWidget *parent)
ui->tabWidget->clear();
});
connect(mTreeWidget, &XTreeWidget::RawFileSelected, this, [this](const XRawFile* rawFile, const QString aParentName) {
connect(mTreeWidget, &XTreeWidget::RawFileSelected, this, [this](std::shared_ptr<RawFile> rawFile, const QString aParentName) {
QTabWidget *rawTabWidget = new QTabWidget(this);
rawTabWidget->setProperty("PARENT_NAME", QVariant::fromValue(aParentName));
@ -168,13 +157,13 @@ MainWindow::MainWindow(QWidget *parent)
scriptEditor->setProperty("PARENT_NAME", QVariant::fromValue(aParentName));
scriptEditor->setFont(QFont("Consolas"));
// if (rawFile->contents.isEmpty()) {
// scriptEditor->setPlainText("EMPTY");
// } else {
// scriptEditor->setPlainText(rawFile->contents);
// }
if (rawFile->contents.isEmpty()) {
scriptEditor->setPlainText("EMPTY");
} else {
scriptEditor->setPlainText(rawFile->contents);
}
QString fileStem;// = rawFile->path.split('/').last();
QString fileStem = rawFile->path.split('/').last();
for (int i = 0; i < ui->tabWidget->count(); i++) {
if (ui->tabWidget->tabText(i) == fileStem) {
delete scriptEditor;
@ -186,7 +175,7 @@ MainWindow::MainWindow(QWidget *parent)
QFontMetrics metrics(scriptEditor->font());
scriptEditor->setTabStopDistance(tabStopSpaces * metrics.horizontalAdvance(' '));
QSyntaxHighlighter *highlighter = nullptr;
QSyntaxHighlighter *highlighter;
if (fileStem.contains(".gsc")) {
highlighter = new Highlighter_GSC(scriptEditor->document());
} else if (fileStem.contains(".cfg")) {
@ -202,12 +191,12 @@ MainWindow::MainWindow(QWidget *parent)
rawTabWidget->addTab(scriptEditor, "Text Editor");
ui->tabWidget->addTab(rawTabWidget, fileStem);
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, Utils::CreateAssetIcon(ASSET_TYPE_RUMBLE));
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, ZoneFile::AssetTypeToIcon(ASSET_RUMBLE));
ui->tabWidget->setCurrentIndex(ui->tabWidget->count() - 1);
return;
} else if (fileStem.contains(".shock")) {
highlighter = new Highlighter_Shock(scriptEditor->document());
} /*else if (rawFile->contents.left(6) == "RUMBLE") {
} else if (rawFile->contents.left(6) == "RUMBLE") {
RumbleFileViewer *rmbFileViewer = new RumbleFileViewer(this);
rmbFileViewer->setProperty("PARENT_NAME", QVariant::fromValue(aParentName));
rmbFileViewer->SetRumbleFile(rawFile);
@ -216,61 +205,59 @@ MainWindow::MainWindow(QWidget *parent)
rawTabWidget->addTab(scriptEditor, "Text Editor");
ui->tabWidget->addTab(rawTabWidget, fileStem);
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, Utils::CreateAssetIcon(ASSET_TYPE_RUMBLE));
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, ZoneFile::AssetTypeToIcon(ASSET_RUMBLE));
ui->tabWidget->setCurrentIndex(ui->tabWidget->count() - 1);
return;
}*/ else {
delete highlighter;
}
ui->tabWidget->addTab(scriptEditor, fileStem);
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, Utils::CreateAssetIcon(ASSET_TYPE_RAWFILE));
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, ZoneFile::AssetTypeToIcon(ASSET_RAW_FILE));
ui->tabWidget->setCurrentIndex(ui->tabWidget->count() - 1);
});
// connect(mTreeWidget, &XTreeWidget::ImageSelected, this, [this](std::shared_ptr<Image> image, const QString aParentName) {
// ImageWidget *mImageWidget = new ImageWidget(this);
// mImageWidget->setAcceptDrops(false);
// mImageWidget->SetImage(image);
// mImageWidget->setProperty("PARENT_NAME", QVariant::fromValue(aParentName));
connect(mTreeWidget, &XTreeWidget::ImageSelected, this, [this](std::shared_ptr<Image> image, const QString aParentName) {
ImageWidget *mImageWidget = new ImageWidget(this);
mImageWidget->setAcceptDrops(false);
mImageWidget->SetImage(image);
mImageWidget->setProperty("PARENT_NAME", QVariant::fromValue(aParentName));
// QString fileStem = image->materialName;
// for (int i = 0; i < ui->tabWidget->count(); i++) {
// if (ui->tabWidget->tabText(i) == fileStem) {
// delete mImageWidget;
// return;
// }
// }
QString fileStem = image->materialName;
for (int i = 0; i < ui->tabWidget->count(); i++) {
if (ui->tabWidget->tabText(i) == fileStem) {
delete mImageWidget;
return;
}
}
// ui->tabWidget->addTab(mImageWidget, fileStem);
// ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, Utils::CreateAssetIcon(ASSET_TYPE_IMAGE));
// ui->tabWidget->setCurrentIndex(ui->tabWidget->count() - 1);
// });
ui->tabWidget->addTab(mImageWidget, fileStem);
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, ZoneFile::AssetTypeToIcon(ASSET_IMAGE));
ui->tabWidget->setCurrentIndex(ui->tabWidget->count() - 1);
});
// connect(mTreeWidget, &XTreeWidget::MenuSelected, this, [](std::shared_ptr<Menu> menu, const QString aParentName) {
// Q_UNUSED(menu);
// });
connect(mTreeWidget, &XTreeWidget::MenuSelected, this, [](std::shared_ptr<Menu> menu, const QString aParentName) {
Q_UNUSED(menu);
});
connect(mTreeWidget, &XTreeWidget::MaterialSelected, this, [this](const XMaterial* material, const QString aParentName) {
connect(mTreeWidget, &XTreeWidget::MaterialSelected, this, [this](std::shared_ptr<Material> material, const QString aParentName) {
MaterialViewer *matViewer = new MaterialViewer(this);
matViewer->setAcceptDrops(false);
matViewer->SetMaterial(material);
matViewer->setProperty("PARENT_NAME", QVariant::fromValue(aParentName));
// QString fileStem = material->name;
// for (int i = 0; i < ui->tabWidget->count(); i++) {
// if (ui->tabWidget->tabText(i) == fileStem) {
// delete matViewer;
// return;
// }
// }
QString fileStem = material->name;
for (int i = 0; i < ui->tabWidget->count(); i++) {
if (ui->tabWidget->tabText(i) == fileStem) {
delete matViewer;
return;
}
}
//ui->tabWidget->addTab(matViewer, fileStem);
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, Utils::CreateAssetIcon(ASSET_TYPE_MATERIAL));
ui->tabWidget->addTab(matViewer, fileStem);
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, ZoneFile::AssetTypeToIcon(ASSET_MATERIAL));
ui->tabWidget->setCurrentIndex(ui->tabWidget->count() - 1);
});
connect(mTreeWidget, &XTreeWidget::DDSFileSelected, this, [this](const DDSFile* ddsFile, const QString aParentName) {
connect(mTreeWidget, &XTreeWidget::DDSFileSelected, this, [this](std::shared_ptr<DDSFile> ddsFile, const QString aParentName) {
DDSViewer *ddsViewer = new DDSViewer(this);
ddsViewer->setAcceptDrops(false);
ddsViewer->SetDDSFile(ddsFile);
@ -285,11 +272,11 @@ MainWindow::MainWindow(QWidget *parent)
}
ui->tabWidget->addTab(ddsViewer, fileStem);
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, Utils::CreateAssetIcon(ASSET_TYPE_IMAGE));
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, ZoneFile::AssetTypeToIcon(ASSET_IMAGE));
ui->tabWidget->setCurrentIndex(ui->tabWidget->count() - 1);
});
connect(mTreeWidget, &XTreeWidget::IWIFileSelected, this, [this](const IWIFile* iwiFile, const QString aParentName) {
connect(mTreeWidget, &XTreeWidget::IWIFileSelected, this, [this](std::shared_ptr<IWIFile> iwiFile, const QString aParentName) {
IWIViewer *iwiViewer = new IWIViewer(this);
iwiViewer->setAcceptDrops(false);
iwiViewer->SetIWIFile(iwiFile);
@ -304,11 +291,11 @@ MainWindow::MainWindow(QWidget *parent)
}
ui->tabWidget->addTab(iwiViewer, fileStem);
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, Utils::CreateAssetIcon(ASSET_TYPE_IMAGE));
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, ZoneFile::AssetTypeToIcon(ASSET_IMAGE));
ui->tabWidget->setCurrentIndex(ui->tabWidget->count() - 1);
});
connect(mTreeWidget, &XTreeWidget::FastFileSelected, this, [this](const FastFile* aFastFile, const QString aParentName) {
connect(mTreeWidget, &XTreeWidget::FastFileSelected, this, [this](std::shared_ptr<FastFile> aFastFile, const QString aParentName) {
FastFileViewer *fastFileViewer = new FastFileViewer(this);
fastFileViewer->setAcceptDrops(false);
fastFileViewer->SetFastFile(aFastFile);
@ -323,11 +310,11 @@ MainWindow::MainWindow(QWidget *parent)
}
ui->tabWidget->addTab(fastFileViewer, fileStem);
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, Utils::CreateAssetIcon("FF"));
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, ZoneFile::AssetTypeToIcon(ASSET_FAST_FILE));
ui->tabWidget->setCurrentIndex(ui->tabWidget->count() - 1);
});
connect(mTreeWidget, &XTreeWidget::ZoneFileSelected, this, [this](const ZoneFile* aZoneFile, const QString aParentName) {
connect(mTreeWidget, &XTreeWidget::ZoneFileSelected, this, [this](std::shared_ptr<ZoneFile> aZoneFile, const QString aParentName) {
ZoneFileViewer *zoneFileViewer = new ZoneFileViewer(this);
zoneFileViewer->setAcceptDrops(false);
zoneFileViewer->SetZoneFile(aZoneFile);
@ -354,11 +341,11 @@ MainWindow::MainWindow(QWidget *parent)
scrollArea->setWidget(containerWidget);
ui->tabWidget->addTab(scrollArea, fileStem);
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, Utils::CreateAssetIcon("ZF"));
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, ZoneFile::AssetTypeToIcon(ASSET_ZONE_FILE));
ui->tabWidget->setCurrentIndex(ui->tabWidget->count() - 1);
});
connect(mTreeWidget, &XTreeWidget::LocalStringSelected, this, [this](const ZoneFile* aZoneFile, const QString aParentName) {
connect(mTreeWidget, &XTreeWidget::LocalStringSelected, this, [this](std::shared_ptr<ZoneFile> aZoneFile, const QString aParentName) {
LocalStringViewer *localStrViewer = new LocalStringViewer(this);
localStrViewer->setAcceptDrops(false);
localStrViewer->SetZoneFile(aZoneFile);
@ -373,17 +360,17 @@ MainWindow::MainWindow(QWidget *parent)
}
ui->tabWidget->addTab(localStrViewer, fileStem);
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, Utils::CreateAssetIcon(ASSET_TYPE_LOCALIZE_ENTRY));
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, ZoneFile::AssetTypeToIcon(ASSET_LOCAL_STRING));
ui->tabWidget->setCurrentIndex(ui->tabWidget->count() - 1);
});
connect(mTreeWidget, &XTreeWidget::TechSetSelected, this, [this](const XMaterialTechniqueSet* aTechSet, const QString aParentName) {
connect(mTreeWidget, &XTreeWidget::TechSetSelected, this, [this](std::shared_ptr<TechSet> aTechSet, const QString aParentName) {
TechSetViewer *techSetViewer = new TechSetViewer(this);
techSetViewer->setAcceptDrops(false);
techSetViewer->SetTechSet(aTechSet);
techSetViewer->setProperty("PARENT_NAME", QVariant::fromValue(aParentName));
QString fileStem = aTechSet->GetName();
QString fileStem = aTechSet->name;
for (int i = 0; i < ui->tabWidget->count(); i++) {
if (ui->tabWidget->tabText(i) == fileStem) {
delete techSetViewer;
@ -391,18 +378,18 @@ MainWindow::MainWindow(QWidget *parent)
}
}
ui->tabWidget->addTab(techSetViewer, aTechSet->GetName());
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, Utils::CreateAssetIcon(ASSET_TYPE_TECHNIQUE_SET));
ui->tabWidget->addTab(techSetViewer, aTechSet->name);
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, ZoneFile::AssetTypeToIcon(ASSET_TECH_SET));
ui->tabWidget->setCurrentIndex(ui->tabWidget->count() - 1);
});
connect(mTreeWidget, &XTreeWidget::StrTableSelected, this, [this](const XStringTable* aStrTable, const QString aParentName) {
connect(mTreeWidget, &XTreeWidget::StrTableSelected, this, [this](std::shared_ptr<StringTable> aStrTable, const QString aParentName) {
StringTableViewer *strTableViewer = new StringTableViewer(this);
strTableViewer->setAcceptDrops(false);
strTableViewer->SetStringTable(aStrTable);
strTableViewer->setProperty("PARENT_NAME", QVariant::fromValue(aParentName));
QString fileStem = aStrTable->GetName()->GetString();
QString fileStem = aStrTable->name;
for (int i = 0; i < ui->tabWidget->count(); i++) {
if (ui->tabWidget->tabText(i) == fileStem) {
delete strTableViewer;
@ -411,28 +398,28 @@ MainWindow::MainWindow(QWidget *parent)
}
ui->tabWidget->addTab(strTableViewer, fileStem);
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, Utils::CreateAssetIcon(ASSET_TYPE_STRINGTABLE));
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, ZoneFile::AssetTypeToIcon(ASSET_STRING_TABLE));
ui->tabWidget->setCurrentIndex(ui->tabWidget->count() - 1);
});
// connect(mTreeWidget, &XTreeWidget::SoundSelected, this, [this](std::shared_ptr<Sound> aSound, const QString aParentName) {
// SoundViewer *soundViewer = new SoundViewer(this);
// soundViewer->setAcceptDrops(false);
// soundViewer->SetSound(aSound);
// soundViewer->setProperty("PARENT_NAME", QVariant::fromValue(aParentName));
connect(mTreeWidget, &XTreeWidget::SoundSelected, this, [this](std::shared_ptr<Sound> aSound, const QString aParentName) {
SoundViewer *soundViewer = new SoundViewer(this);
soundViewer->setAcceptDrops(false);
soundViewer->SetSound(aSound);
soundViewer->setProperty("PARENT_NAME", QVariant::fromValue(aParentName));
// QString fileStem = aSound->path.split('/').last();
// for (int i = 0; i < ui->tabWidget->count(); i++) {
// if (ui->tabWidget->tabText(i) == fileStem) {
// delete soundViewer;
// return;
// }
// }
QString fileStem = aSound->path.split('/').last();
for (int i = 0; i < ui->tabWidget->count(); i++) {
if (ui->tabWidget->tabText(i) == fileStem) {
delete soundViewer;
return;
}
}
// ui->tabWidget->addTab(soundViewer, fileStem);
// ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, Utils::CreateAssetIcon(ASSET_TYPE_SOUND));
// ui->tabWidget->setCurrentIndex(ui->tabWidget->count() - 1);
// });
ui->tabWidget->addTab(soundViewer, fileStem);
ui->tabWidget->setTabIcon(ui->tabWidget->count() - 1, ZoneFile::AssetTypeToIcon(ASSET_SOUND));
ui->tabWidget->setCurrentIndex(ui->tabWidget->count() - 1);
});
connect(mTreeWidget, &XTreeWidget::ItemSelected, this, [this](const QString itemText) {
for (int i = 0; i < ui->tabWidget->count(); i++) {
@ -533,22 +520,7 @@ bool MainWindow::OpenFastFile(const QString aFastFilePath) {
return false;
}
FastFile* fastFile = FastFile::Open(aFastFilePath);
fastFile->SetStem(fastFileStem);
mTreeWidget->AddFastFile(fastFile);
// Open zone file after decompressing ff and writing
return true;
}
bool MainWindow::OpenFastFile(const QByteArray& aFastFileData, const QString aFastFilePath) {
const QString fastFileStem = aFastFilePath.section("/", -1, -1);
if (mTreeWidget->HasFastFile(fastFileStem)) {
LogManager::instance().addError("Can't add duplicate file!");
return false;
}
FastFile* fastFile = FastFile::Open(aFastFileData);
std::shared_ptr<FastFile> fastFile = FastFileFactory::Create(aFastFilePath);
fastFile->SetStem(fastFileStem);
mTreeWidget->AddFastFile(fastFile);
@ -563,13 +535,11 @@ bool MainWindow::OpenFastFile(const QByteArray& aFastFileData, const QString aFa
and opens the selected file.
*/
bool MainWindow::OpenFastFile() {
// Open file dialog to steam apps
const QString steamPath = "C:/Program Files (x86)/Steam/steamapps/common/Call of Duty World at War/zone/english/";
QFileDialog::getOpenFileContent(tr("Fast File (*.ff);;All Files (*.*)"), [this](const QString &fileName, const QByteArray &data){
OpenFastFile(data, fileName);
});
const QString fastFileName = Utils::GetOpenFastFileName();
if (!OpenFastFile(fastFileName)) {
qDebug() << "Failed to open Fast file!";
return false;
}
return true;
}
@ -583,25 +553,19 @@ bool MainWindow::OpenZoneFile(const QString aZoneFilePath, bool fromFF) {
Q_UNUSED(aZoneFilePath);
Q_UNUSED(fromFF);
// ZoneFile* zoneFile = ZoneFile::Create();
// if (!zoneFile.Load(aZoneFilePath)) {
// qDebug() << "Error: Failed to load zone file!";
// return false;
// }
// mTreeWidget->AddZoneFile(std::make_shared<ZoneFile>(zoneFile));
//ZoneFile zoneFile;
//if (!zoneFile.Load(aZoneFilePath)) {
// qDebug() << "Error: Failed to load zone file!";
// return false;
//}
//mTreeWidget->AddZoneFile(std::make_shared<ZoneFile>(zoneFile));
return true;
}
bool MainWindow::OpenZoneFile() {
// Open file dialog to steam apps
const QString steamPath = "C:/Program Files (x86)/Steam/steamapps/common/Call of Duty World at War/zone/english/";
const QString zoneFilePath = QFileDialog::getOpenFileName(this, "Open Zone File", steamPath, "Zone File (*.zone);;All Files (*.*)");
if (zoneFilePath.isNull()) {
// User pressed cancel
return false;
} else if (!QFile::exists(zoneFilePath)) {
QMessageBox::warning(this, "Warning!", QString("%1 does not exist!.").arg(zoneFilePath));
const QString zoneFileName = Utils::GetOpenZoneFileName();
if (!OpenZoneFile(zoneFileName)) {
qDebug() << "Failed to open Zone file!";
return false;
}
@ -673,7 +637,7 @@ quint32 DXT3 = 0x33545844; // 'DXT3'
quint32 DXT5 = 0x35545844; // 'DXT5'
int MainWindow::LoadFile_IWI(const QString aFilePath) {
mTreeWidget->AddIWIFile(new IWIFile(aFilePath));
mTreeWidget->AddIWIFile(std::make_shared<IWIFile>(aFilePath));
return 0;
}
@ -684,7 +648,7 @@ int MainWindow::LoadFile_DDSFiles(const QStringList aFilePaths) {
qDebug() << "Error: Invalid filename " << filePath;
return -1;
}
mTreeWidget->AddDDSFile(new DDSFile(filePath));
mTreeWidget->AddDDSFile(std::make_shared<DDSFile>(filePath));
}
return 0;
}
@ -716,7 +680,7 @@ int MainWindow::LoadFile_DDS(const QString aFilePath) {
qDebug() << "Error: Invalid filename " << aFilePath;
return -1;
}
mTreeWidget->AddDDSFile(new DDSFile(aFilePath));
mTreeWidget->AddDDSFile(std::make_shared<DDSFile>(aFilePath));
return 0;
}
@ -789,7 +753,7 @@ int MainWindow::LoadFile_IPAK(const QString aFilePath) {
QVector<IPAKIndexEntry> entries = QVector<IPAKIndexEntry>();
QVector<IPAKSection> sections = QVector<IPAKSection>(header.sectionCount);
for (quint32 i = 0; i < header.sectionCount; i++) {
for (uint i = 0; i < header.sectionCount; i++) {
IPAKSection currentSection;
stream >> currentSection;
sections << currentSection;
@ -811,7 +775,7 @@ int MainWindow::LoadFile_IPAK(const QString aFilePath) {
<< " - Count: " << chunkHeader.count << "\n"
<< " - Offset: " << chunkHeader.offset;
for (quint32 j = 0; j < 31; j++) {
for (uint j = 0; j < 31; j++) {
IPAKDataChunkCommand command;
stream >> command;
if (!command.size) { continue; }
@ -821,7 +785,7 @@ int MainWindow::LoadFile_IPAK(const QString aFilePath) {
<< " - Compressed: " << command.compressed;
}
for (quint32 j = 0; j < chunkHeader.count; j++) {
for (uint j = 0; j < chunkHeader.count; j++) {
auto command = chunkHeader.commands[j];
qDebug() << "Reading from " << stream.device()->pos();
@ -846,7 +810,7 @@ int MainWindow::LoadFile_IPAK(const QString aFilePath) {
stream.skipRawData(sizeof(quint32) * (31 - chunkHeader.count));
qDebug() << stream.device()->pos();
} else if (sectionType == "Index") {
for (quint32 j = 0; j < currentSection.itemCount; j++) {
for (uint j = 0; j < currentSection.itemCount; j++) {
IPAKIndexEntry entry;
stream >> entry;

5
app/mainwindow.h
View File

@ -2,6 +2,7 @@
#define MAINWINDOW_H
#include "d3dbsp_structs.h"
#include "asset_structs.h"
#include "xtreewidget.h"
#include <QMainWindow>
@ -15,6 +16,7 @@
#include <QPlainTextEdit>
#include <QMimeData>
#include <QProgressBar>
#include <windows.h>
QT_BEGIN_NAMESPACE
namespace Ui {
@ -33,7 +35,6 @@ public:
private slots:
bool OpenFastFile(const QString aFastFilePath);
bool OpenFastFile(const QByteArray& aFastFileData, const QString aFastFilePath);
bool OpenFastFile();
bool OpenZoneFile(const QString aZoneFilePath, bool fromFF = false);
@ -63,7 +64,7 @@ private:
quint32 mTagCount;
quint32 mRecordCount;
QMap<QString, QString> mRawFileMap;
//QMap<QString, Image> mImageMap;
QMap<QString, Image> mImageMap;
QMap<QString, QTreeWidgetItem*> mTreeMap;
QMap<QString, QVector<QPair<QString, QString>>> mStrTableMap;
XTreeWidget *mTreeWidget;

22
app/mainwindow.ui
View File

@ -50,7 +50,7 @@
<height>21</height>
</rect>
</property>
<widget class="QMenu" name="MenuDef">
<widget class="QMenu" name="menuFile">
<property name="title">
<string>File</string>
</property>
@ -117,17 +117,9 @@
</property>
<addaction name="actionAbout"/>
<addaction name="actionCheck_for_Updates"/>
<addaction name="actionReport_Issue"/>
</widget>
<widget class="QMenu" name="menuTools">
<property name="title">
<string>Tools</string>
</property>
<addaction name="actionRun_Tests"/>
</widget>
<addaction name="MenuDef"/>
<addaction name="menuFile"/>
<addaction name="menuEdit"/>
<addaction name="menuTools"/>
<addaction name="menuHelp"/>
</widget>
<widget class="QToolBar" name="toolBar">
@ -361,16 +353,6 @@
<string>Preferences...</string>
</property>
</action>
<action name="actionReport_Issue">
<property name="text">
<string>Report Issue</string>
</property>
</action>
<action name="actionRun_Tests">
<property name="text">
<string>Run Tests</string>
</property>
</action>
</widget>
<resources>
<include location="../data/data.qrc"/>

48
app/materialviewer.cpp
View File

@ -3,41 +3,33 @@
MaterialViewer::MaterialViewer(QWidget *parent)
: QWidget(parent)
, ui(new Ui::MaterialViewer)
{
, ui(new Ui::MaterialViewer) {
ui->setupUi(this);
}
MaterialViewer::~MaterialViewer()
{
MaterialViewer::~MaterialViewer() {
delete ui;
}
QString ToHexStr(quint32 in)
{
QString ToHexStr(quint32 in) {
return QString("%1").arg(in, 8, 16, QChar('0')).toUpper();
}
void MaterialViewer::SetMaterial(const XMaterial* aMaterial)
{
Q_UNUSED(aMaterial);
// TODO: Fill in MaterialViewer::SetMaterial
// ui->lineEdit_NamePtr->setText(ToHexStr(aMaterial->namePtr));
// ui->lineEdit_Name->setText(aMaterial->name);
// ui->lineEdit_RefPtr->setText(ToHexStr(aMaterial->refNamePtr));
// ui->lineEdit_RefName->setText(aMaterial->refName);
// QString unknownStr = "";
// foreach (quint32 unknownPtr, aMaterial->pointers) {
// unknownStr += ToHexStr(unknownPtr) + "\n";
// }
// ui->lineEdit_Unknowns->setText(unknownStr);
// ui->lineEdit_StateA->setText(ToHexStr(aMaterial->stateBits[0]));
// ui->lineEdit_StateA->setText(ToHexStr(aMaterial->stateBits[1]));
// ui->spinBox_TextureCount->setValue(aMaterial->textureCount);
// ui->spinBox_ConstCount->setValue(aMaterial->constCount);
// ui->lineEdit_TechSetPtr->setText(ToHexStr(aMaterial->techSetPtr));
// ui->lineEdit_TexturePtr->setText(ToHexStr(aMaterial->texturePtr));
// ui->lineEdit_ConstantPtr->setText(ToHexStr(aMaterial->constPtr));
void MaterialViewer::SetMaterial(std::shared_ptr<Material> aMaterial) {
ui->lineEdit_NamePtr->setText(ToHexStr(aMaterial->namePtr));
ui->lineEdit_Name->setText(aMaterial->name);
ui->lineEdit_RefPtr->setText(ToHexStr(aMaterial->refNamePtr));
ui->lineEdit_RefName->setText(aMaterial->refName);
QString unknownStr = "";
foreach (quint32 unknownPtr, aMaterial->pointers) {
unknownStr += ToHexStr(unknownPtr) + "\n";
}
ui->lineEdit_Unknowns->setText(unknownStr);
ui->lineEdit_StateA->setText(ToHexStr(aMaterial->stateBits[0]));
ui->lineEdit_StateA->setText(ToHexStr(aMaterial->stateBits[1]));
ui->spinBox_TextureCount->setValue(aMaterial->textureCount);
ui->spinBox_ConstCount->setValue(aMaterial->constCount);
ui->lineEdit_TechSetPtr->setText(ToHexStr(aMaterial->techSetPtr));
ui->lineEdit_TexturePtr->setText(ToHexStr(aMaterial->texturePtr));
ui->lineEdit_ConstantPtr->setText(ToHexStr(aMaterial->constPtr));
}

4
app/materialviewer.h
View File

@ -1,7 +1,7 @@
#ifndef MATERIALVIEWER_H
#define MATERIALVIEWER_H
#include "xmaterial.h"
#include "asset_structs.h"
#include <QWidget>
#include <QScrollArea>
@ -18,7 +18,7 @@ public:
explicit MaterialViewer(QWidget *parent = nullptr);
~MaterialViewer();
void SetMaterial(const XMaterial *aMaterial);
void SetMaterial(std::shared_ptr<Material> aMaterial);
private:
Ui::MaterialViewer *ui;

103
app/reportissuedialog.cpp
View File

@ -1,103 +0,0 @@
#include "reportissuedialog.h"
#include "qjsonarray.h"
#include "ui_reportissuedialog.h"
#include <QJsonDocument>
#include <QJsonObject>
#include <QMessageBox>
#include <QNetworkRequest>
ReportIssueDialog::ReportIssueDialog(const QString &giteaBaseUrl,
const QString &repoOwner,
const QString &repoName,
const QString &accessToken,
QWidget *parent) :
QDialog(parent),
ui(new Ui::ReportIssueDialog),
networkManager(new QNetworkAccessManager(this)),
giteaBaseUrl(giteaBaseUrl),
repoOwner(repoOwner),
repoName(repoName),
accessToken(accessToken)
{
ui->setupUi(this);
connect(networkManager, &QNetworkAccessManager::finished, this, &ReportIssueDialog::onNetworkReplyFinished);
}
ReportIssueDialog::~ReportIssueDialog()
{
delete ui;
}
void ReportIssueDialog::on_buttonSend_clicked()
{
QString title = ui->lineEditSummary->text().trimmed();
QString details = ui->textEditDetails->toPlainText().trimmed();
QString contact = ui->lineEditContact->text().trimmed();
if (title.isEmpty()) {
QMessageBox::warning(this, tr("Input Error"), tr("Please enter a summary/title for the issue."));
return;
}
QString body = details;
if (!contact.isEmpty()) {
body += QString("\n\nContact info:\n%1").arg(contact);
}
ui->buttonSend->setEnabled(false);
sendIssueReport(title, body, contact);
}
void ReportIssueDialog::on_buttonCancel_clicked()
{
reject();
}
void ReportIssueDialog::sendIssueReport(const QString &title, const QString &body, const QString &/*contact*/)
{
// Compose URL: e.g. https://gitea.example.com/api/v1/repos/{owner}/{repo}/issues
QUrl url(QString("%1/api/v1/repos/%2/%3/issues").arg(giteaBaseUrl).arg(repoOwner).arg(repoName));
QNetworkRequest request(url);
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
if (!accessToken.isEmpty()) {
request.setRawHeader("Authorization", "token " + accessToken.toUtf8());
}
// Compose JSON body
QJsonObject json;
json["title"] = title;
json["body"] = body;
json["labels"] = QJsonArray{12};
QJsonDocument doc(json);
QByteArray data = doc.toJson();
networkManager->post(request, data);
}
void ReportIssueDialog::onNetworkReplyFinished(QNetworkReply *reply)
{
ui->buttonSend->setEnabled(true);
QByteArray responseData = reply->readAll();
QString responseStr = QString::fromUtf8(responseData);
if (reply->error() != QNetworkReply::NoError) {
QString errorStr = reply->errorString();
if (errorStr.isEmpty()) errorStr = "Unknown network error";
QMessageBox::critical(this, tr("Error"), tr("Failed to send issue report:\n%1\nResponse:\n%2").arg(errorStr).arg(responseStr));
} else {
int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
if (status == 201) {
QMessageBox::information(this, tr("Success"), tr("Issue reported successfully!"));
accept();
} else {
QMessageBox::warning(this, tr("Failed"), tr("Unexpected response from server (%1):\n%2").arg(status).arg(responseStr));
}
}
reply->deleteLater();
}

43
app/reportissuedialog.h
View File

@ -1,43 +0,0 @@
#ifndef REPORTISSUEDIALOG_H
#define REPORTISSUEDIALOG_H
#include <QDialog>
#include <QNetworkAccessManager>
#include <QNetworkReply>
namespace Ui {
class ReportIssueDialog;
}
class ReportIssueDialog : public QDialog
{
Q_OBJECT
public:
explicit ReportIssueDialog(const QString &giteaBaseUrl,
const QString &repoOwner,
const QString &repoName,
const QString &accessToken,
QWidget *parent = nullptr);
~ReportIssueDialog();
private slots:
void on_buttonSend_clicked();
void on_buttonCancel_clicked();
void onNetworkReplyFinished(QNetworkReply *reply);
private:
Ui::ReportIssueDialog *ui;
QNetworkAccessManager *networkManager;
QString giteaBaseUrl;
QString repoOwner;
QString repoName;
QString accessToken;
void sendIssueReport(const QString &title, const QString &body, const QString &contact);
};
#endif // REPORTISSUEDIALOG_H

84
app/reportissuedialog.ui
View File

@ -1,84 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>ReportIssueDialog</class>
<widget class="QDialog" name="ReportIssueDialog">
<property name="windowTitle">
<string>Report a Problem</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QLabel" name="labelInstructions">
<property name="text">
<string>Please describe the problem you encountered. We’ll use this info to help fix it.</string>
</property>
<property name="wordWrap">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="labelSummary">
<property name="text">
<string>Summary (short title):</string>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="lineEditSummary" />
</item>
<item>
<widget class="QLabel" name="labelDetails">
<property name="text">
<string>Details (what happened?):</string>
</property>
</widget>
</item>
<item>
<widget class="QTextEdit" name="textEditDetails" />
</item>
<item>
<widget class="QLabel" name="labelContact">
<property name="text">
<string>Your contact (email or name, optional):</string>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="lineEditContact" />
</item>
<item>
<layout class="QHBoxLayout" name="buttonLayout">
<item>
<spacer name="horizontalSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeType">
<enum>QSizePolicy::Expanding</enum>
</property>
</spacer>
</item>
<item>
<widget class="QPushButton" name="buttonSend">
<property name="text">
<string>Send Report</string>
</property>
<property name="default">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="buttonCancel">
<property name="text">
<string>Cancel</string>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
<resources/>
<connections/>
</ui>

54
app/rumblefileviewer.cpp
View File

@ -18,41 +18,41 @@ RumbleFileViewer::~RumbleFileViewer() {
delete ui;
}
void RumbleFileViewer::SetRumbleFile(XRawFile *aRumbleFile) {
void RumbleFileViewer::SetRumbleFile(std::shared_ptr<RawFile> aRumbleFile) {
mRumbleFile = aRumbleFile;
ui->tableWidget_Properties->clear();
// const QString magic = aRumbleFile->contents.left(6);
// if (magic != "RUMBLE") {
// qDebug() << "Rumble file has invalid magic: " << magic;
// return;
// }
const QString magic = aRumbleFile->contents.left(6);
if (magic != "RUMBLE") {
qDebug() << "Rumble file has invalid magic: " << magic;
return;
}
// int firstIndex = 0;
// int secondIndex = 0;
// int thirdIndex = 0;
int firstIndex = 0;
int secondIndex = 0;
int thirdIndex = 0;
// int startIndex = 0;
// for (int i = 0; i < aRumbleFile->contents.count("\\") / 2; i++) {
// ui->tableWidget_Properties->setRowCount(i + 1);
// ui->spinBox_Entries->setValue(i + 1);
int startIndex = 0;
for (int i = 0; i < aRumbleFile->contents.count("\\") / 2; i++) {
ui->tableWidget_Properties->setRowCount(i + 1);
ui->spinBox_Entries->setValue(i + 1);
// firstIndex = aRumbleFile->contents.indexOf("\\", startIndex);
// secondIndex = aRumbleFile->contents.indexOf("\\", firstIndex + 1);
// thirdIndex = aRumbleFile->contents.indexOf("\\", secondIndex + 1);
// if (thirdIndex == -1) {
// thirdIndex = aRumbleFile->contents.size();
// }
firstIndex = aRumbleFile->contents.indexOf("\\", startIndex);
secondIndex = aRumbleFile->contents.indexOf("\\", firstIndex + 1);
thirdIndex = aRumbleFile->contents.indexOf("\\", secondIndex + 1);
if (thirdIndex == -1) {
thirdIndex = aRumbleFile->contents.size();
}
// const QString keyStr = aRumbleFile->contents.mid(firstIndex + 1, secondIndex - firstIndex - 1);
// QTableWidgetItem *keyItem = new QTableWidgetItem(keyStr);
// ui->tableWidget_Properties->setItem(i, 0, keyItem);
const QString keyStr = aRumbleFile->contents.mid(firstIndex + 1, secondIndex - firstIndex - 1);
QTableWidgetItem *keyItem = new QTableWidgetItem(keyStr);
ui->tableWidget_Properties->setItem(i, 0, keyItem);
// const QString valStr = aRumbleFile->contents.mid(secondIndex + 1, thirdIndex - secondIndex - 1);
// QTableWidgetItem *valueItem = new QTableWidgetItem(valStr);
// ui->tableWidget_Properties->setItem(i, 1, valueItem);
const QString valStr = aRumbleFile->contents.mid(secondIndex + 1, thirdIndex - secondIndex - 1);
QTableWidgetItem *valueItem = new QTableWidgetItem(valStr);
ui->tableWidget_Properties->setItem(i, 1, valueItem);
// startIndex = thirdIndex;
// }
startIndex = thirdIndex;
}
}

8
app/rumblefileviewer.h
View File

@ -1,8 +1,8 @@
#ifndef RUMBLEFILEVIEWER_H
#define RUMBLEFILEVIEWER_H
#include "xrawfile.h"
#include "asset_structs.h"
#include "zonefile.h"
#include <QWidget>
namespace Ui {
@ -17,12 +17,12 @@ public:
explicit RumbleFileViewer(QWidget *parent = nullptr);
~RumbleFileViewer();
void SetRumbleFile(XRawFile* aRumbleFile);
void SetRumbleFile(std::shared_ptr<RawFile> aRumbleFile);
private:
Ui::RumbleFileViewer *ui;
quint32 mPropertyCount;
XRawFile* mRumbleFile;
std::shared_ptr<RawFile> mRumbleFile;
};
#endif // RUMBLEFILEVIEWER_H

4
app/rumblegraphviewer.cpp
View File

@ -19,10 +19,10 @@ RumbleGraphViewer::~RumbleGraphViewer() {
delete ui;
}
void RumbleGraphViewer::SetRumbleGraphFile(const XRawFile* aRawFile) {
void RumbleGraphViewer::SetRumbleGraphFile(const std::shared_ptr<RawFile> aRawFile) {
mRumbleGraphFile = aRawFile;
XDataStream rawFileStream;//(mRumbleGraphFile->contents.toLatin1());
QDataStream rawFileStream(mRumbleGraphFile->contents.toLatin1());
QByteArray magic(15, Qt::Uninitialized);
rawFileStream.readRawData(magic.data(), 15);

8
app/rumblegraphviewer.h
View File

@ -1,7 +1,7 @@
#ifndef RUMBLEGRAPHVIEWER_H
#define RUMBLEGRAPHVIEWER_H
#include "xrawfile.h"
#include "asset_structs.h"
#include "zonefile.h"
#include <QWidget>
@ -18,13 +18,13 @@ public:
~RumbleGraphViewer();
void SetEntryCount(quint32 aCount);
void SetRumbleGraphFile(const XRawFile *aRawFile);
void SetZoneFile(ZoneFile* aZoneFile);
void SetRumbleGraphFile(const std::shared_ptr<RawFile> aRawFile);
void SetZoneFile(std::shared_ptr<ZoneFile> aZoneFile);
private:
Ui::RumbleGraphViewer *ui;
quint32 mEntryCount;
const XRawFile* mRumbleGraphFile;
std::shared_ptr<RawFile> mRumbleGraphFile;
};
#endif // RUMBLEGRAPHVIEWER_H

20
app/soundviewer.cpp
View File

@ -61,17 +61,17 @@ SoundViewer::~SoundViewer()
delete ui;
}
// void SoundViewer::SetSound(std::shared_ptr<Sound> aSound)
// {
// buffer->setData(aSound->data);
// if (!buffer->open(QIODevice::ReadOnly)) {
// qWarning() << "Failed to open QBuffer.";
// return;
// }
void SoundViewer::SetSound(std::shared_ptr<Sound> aSound)
{
buffer->setData(aSound->data);
if (!buffer->open(QIODevice::ReadOnly)) {
qWarning() << "Failed to open QBuffer.";
return;
}
// ui->groupBox->setTitle(aSound->path);
// player->setSourceDevice(buffer);
// }
ui->groupBox->setTitle(aSound->path);
player->setSourceDevice(buffer);
}
void SoundViewer::SetOutput(QAudioOutput *aOutput) {
if (!aOutput) { return; }

4
app/soundviewer.h
View File

@ -1,6 +1,8 @@
#ifndef SOUNDVIEWER_H
#define SOUNDVIEWER_H
#include "asset_structs.h"
#include <QWidget>
#include <QMediaPlayer>
#include <QBuffer>
@ -20,7 +22,7 @@ public:
explicit SoundViewer(QWidget *parent = nullptr);
~SoundViewer();
//void SetSound(std::shared_ptr<Sound> aSound);
void SetSound(std::shared_ptr<Sound> aSound);
void SetOutput(QAudioOutput *aOutput);
private:

13
app/stringtableviewer.cpp
View File

@ -13,21 +13,22 @@ StringTableViewer::~StringTableViewer()
delete ui;
}
void StringTableViewer::SetStringTable(const XStringTable *aStringTable) {
void StringTableViewer::SetStringTable(std::shared_ptr<StringTable> aStringTable) {
ui->tableWidget_Strings->clear();
ui->tableWidget_Strings->setRowCount(aStringTable->GetRowCount());
ui->tableWidget_Strings->setColumnCount(aStringTable->GetColumnCount());
ui->tableWidget_Strings->setRowCount(aStringTable->rowCount);
ui->tableWidget_Strings->setColumnCount(aStringTable->columnCount);
int currentIndex = 0;
for (auto value : *aStringTable->GetValues()) {
for (const QString &key : aStringTable->content.keys()) {
const QString value = aStringTable->content[key];
QTableWidgetItem *tableKeyItem = new QTableWidgetItem();
tableKeyItem->setText(value->GetName());
tableKeyItem->setText(key);
ui->tableWidget_Strings->setItem(currentIndex, 0, tableKeyItem);
QTableWidgetItem *tableValItem = new QTableWidgetItem();
tableValItem->setText(value->GetString());
tableValItem->setText(value);
ui->tableWidget_Strings->setItem(currentIndex, 1, tableValItem);
currentIndex++;

5
app/stringtableviewer.h
View File

@ -1,8 +1,7 @@
#ifndef STRINGTABLEVIEWER_H
#define STRINGTABLEVIEWER_H
#include "xstringtable.h"
#include "asset_structs.h"
#include <QWidget>
namespace Ui {
@ -17,7 +16,7 @@ public:
explicit StringTableViewer(QWidget *parent = nullptr);
~StringTableViewer();
void SetStringTable(const XStringTable *aStringTable);
void SetStringTable(std::shared_ptr<StringTable> aStringTable);
private:
Ui::StringTableViewer *ui;

16
app/techsetviewer.cpp
View File

@ -13,13 +13,13 @@ TechSetViewer::~TechSetViewer()
delete ui;
}
void TechSetViewer::SetTechSet(const XMaterialTechniqueSet* aTechSet) {
//ui->listWidget_Ptrs->clear();
ui->label_Title->setText(aTechSet->GetName());
void TechSetViewer::SetTechSet(std::shared_ptr<TechSet> aTechSet) {
ui->listWidget_Ptrs->clear();
ui->label_Title->setText(aTechSet->name);
// int ptrIndex = 1;
//for (auto ptr : aTechSet->pointers) {
// ui->listWidget_Ptrs->addItem(QString("Pointer %1: %2").arg(ptrIndex).arg(ptr));
// ptrIndex++;
//}
int ptrIndex = 1;
for (auto ptr : aTechSet->pointers) {
ui->listWidget_Ptrs->addItem(QString("Pointer %1: %2").arg(ptrIndex).arg(ptr));
ptrIndex++;
}
}

5
app/techsetviewer.h
View File

@ -1,8 +1,7 @@
#ifndef TECHSETVIEWER_H
#define TECHSETVIEWER_H
#include "xmaterialtechniqueset.h"
#include "asset_structs.h"
#include <QWidget>
namespace Ui {
@ -17,7 +16,7 @@ public:
explicit TechSetViewer(QWidget *parent = nullptr);
~TechSetViewer();
void SetTechSet(const XMaterialTechniqueSet *aTechSet);
void SetTechSet(std::shared_ptr<TechSet> aTechSet);
private:
Ui::TechSetViewer *ui;

132
app/techsetviewer.ui
View File

@ -6,14 +6,14 @@
<rect>
<x>0</x>
<y>0</y>
<width>880</width>
<height>559</height>
<width>961</width>
<height>756</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_3">
<layout class="QVBoxLayout" name="verticalLayout_2">
<item>
<widget class="QLabel" name="label_Title">
<property name="font">
@ -29,121 +29,47 @@
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_7">
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QGroupBox" name="groupBox">
<property name="title">
<string>Set Parameters</string>
<string>Unknown Pointers:</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QLabel" name="label">
<property name="text">
<string>Name:</string>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="lineEdit_Name">
<property name="placeholderText">
<string>Technique set name</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_2">
<item>
<widget class="QLabel" name="label_2">
<property name="text">
<string>World Vertex Format:</string>
</property>
</widget>
</item>
<item>
<widget class="QSpinBox" name="spinBox_WorldVertFormat"/>
</item>
</layout>
</item>
<item>
<widget class="QListWidget" name="listWidget_Techniques"/>
<widget class="QListWidget" name="listWidget_Ptrs"/>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="groupBox_2">
<property name="title">
<string>Current Technique</string>
<spacer name="horizontalSpacer">
<property name="orientation">
<enum>Qt::Orientation::Horizontal</enum>
</property>
<layout class="QVBoxLayout" name="verticalLayout_2">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_4">
<item>
<widget class="QLabel" name="label_4">
<property name="text">
<string>Name:</string>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="lineEdit_TechniqueName">
<property name="placeholderText">
<string>Technique set name</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_5">
<item>
<widget class="QLabel" name="label_5">
<property name="text">
<string>Flags:</string>
</property>
</widget>
</item>
<item>
<widget class="QSpinBox" name="spinBox_Flags"/>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_6">
<item>
<widget class="QLabel" name="label_6">
<property name="text">
<string>Pass Count:</string>
</property>
</widget>
</item>
<item>
<widget class="QSpinBox" name="spinBox_PassCount"/>
</item>
</layout>
</item>
<item>
<widget class="QGroupBox" name="groupBox_3">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="MinimumExpanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="title">
<string>Material Pass</string>
</property>
</widget>
</item>
</layout>
</widget>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
</layout>
</item>
<item>
<spacer name="verticalSpacer">
<property name="orientation">
<enum>Qt::Orientation::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>363</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
<resources/>

535
app/xtreewidget.cpp
View File

@ -5,10 +5,10 @@
XTreeWidget::XTreeWidget(QWidget *parent)
: QTreeWidget(parent) {
mFastFiles = QMap<QString, const FastFile*>();
mZoneFiles = QMap<QString, const ZoneFile*>();
mDDSFiles = QMap<QString, const DDSFile*>();
mIWIFiles = QMap<QString, const IWIFile*>();
mFastFiles = QMap<QString, std::shared_ptr<FastFile>>();
mZoneFiles = QMap<QString, std::shared_ptr<ZoneFile>>();
mDDSFiles = QMap<QString, std::shared_ptr<DDSFile>>();
mIWIFiles = QMap<QString, std::shared_ptr<IWIFile>>();
setContextMenuPolicy(Qt::CustomContextMenu);
setSelectionMode(QTreeWidget::SingleSelection);
@ -37,7 +37,7 @@ XTreeWidget::~XTreeWidget() {
}
void XTreeWidget::AddFastFile(FastFile* aFastFile) {
void XTreeWidget::AddFastFile(std::shared_ptr<FastFile> aFastFile) {
XTreeWidgetItem *fastFileItem = new XTreeWidgetItem(this);
fastFileItem->setText(0, aFastFile->GetStem());
fastFileItem->setIcon(0, Utils::CreateAssetIcon("FF"));
@ -83,189 +83,211 @@ void XTreeWidget::AddFastFile(FastFile* aFastFile) {
sortByColumn(0, Qt::AscendingOrder);
}
void XTreeWidget::AddZoneFile(const ZoneFile* aZoneFile, XTreeWidgetItem *aParentItem) {
void XTreeWidget::AddZoneFile(std::shared_ptr<ZoneFile> aZoneFile, XTreeWidgetItem *aParentItem) {
XTreeWidgetItem *zoneItem;
if (aParentItem != nullptr) {
zoneItem = new XTreeWidgetItem(aParentItem);
} else {
zoneItem = new XTreeWidgetItem(this);
}
zoneItem->setIcon(0, Utils::CreateAssetIcon("ZF"));
zoneItem->setIcon(0, ZoneFile::AssetTypeToIcon(ASSET_ZONE_FILE));
zoneItem->setText(0, aZoneFile->GetBaseStem() + ".zone");
XAssetList assetList = aZoneFile->GetAssetList();
QVector<XAsset*> localizeEntries;
for (int i = 0; i < assetList.Size(); i++)
{
XAsset *currentAsset = assetList.GetAsset(i);
if (currentAsset->GetType() == ASSET_TYPE_LOCALIZE_ENTRY)
{
localizeEntries.append(currentAsset);
} else if (currentAsset->GetType() == ASSET_TYPE_LOCALIZE_ENTRY)
{
localizeEntries.append(currentAsset);
auto assetMap = aZoneFile->GetAssetMap();
if (!assetMap.localStrings.isEmpty()) {
QIcon localStrIcon = ZoneFile::AssetTypeToIcon(ASSET_LOCAL_STRING);
XTreeWidgetItem *localStrRoot = new XTreeWidgetItem(zoneItem);
localStrRoot->setText(0, "String Files");
localStrRoot->setIcon(0, localStrIcon);
localStrRoot->SetCategory(CATEGORY_TYPE);
XTreeWidgetItem *localStrItem = new XTreeWidgetItem(localStrRoot);
localStrItem->setText(0, aZoneFile->GetStem().section('.', 0, 0) + ".str");
localStrItem->setIcon(0, localStrIcon);
}
if (!assetMap.techSets.isEmpty()) {
QIcon techSetIcon = ZoneFile::AssetTypeToIcon(ASSET_TECH_SET);
XTreeWidgetItem *techSetRoot = new XTreeWidgetItem(zoneItem);
techSetRoot->setText(0, "Tech Sets");
techSetRoot->setIcon(0, techSetIcon);
techSetRoot->SetCategory(CATEGORY_TYPE);
for (TechSet techSet : assetMap.techSets) {
XTreeWidgetItem *techSetItem = new XTreeWidgetItem(techSetRoot);
techSetItem->setText(0, techSet.name);
techSetItem->setIcon(0, techSetIcon);
}
}
if (!assetMap.rawFiles.isEmpty()) {
QIcon rawFileIcon = ZoneFile::AssetTypeToIcon(ASSET_RAW_FILE);
// if (!assetMap.localizeEntries.isEmpty()) {
// QIcon localStrIcon = Utils::CreateAssetIcon(ASSET_TYPE_LOCALIZE_ENTRY);
XTreeWidgetItem *rawFileRoot = new XTreeWidgetItem(zoneItem);
rawFileRoot->setText(0, "Raw Files");
rawFileRoot->setIcon(0, rawFileIcon);
rawFileRoot->SetCategory(CATEGORY_TYPE);
for (RawFile rawFile : assetMap.rawFiles) {
if (!rawFile.length) { continue; }
// XTreeWidgetItem *localStrRoot = new XTreeWidgetItem(zoneItem);
// localStrRoot->setText(0, "String Files");
// localStrRoot->setIcon(0, localStrIcon);
// localStrRoot->SetCategory(CATEGORY_TYPE);
XTreeWidgetItem *tempItem = rawFileRoot;
const QStringList pathParts = rawFile.path.split('/');
for (const QString &pathPart : pathParts) {
bool childFound = false;
for (int i = 0; i < tempItem->childCount(); i++) {
QTreeWidgetItem *rawChildItem = tempItem->child(i);
XTreeWidgetItem *childItem = dynamic_cast<XTreeWidgetItem*>(rawChildItem);
if (childItem->text(0) == pathPart) {
tempItem = childItem;
// XTreeWidgetItem *localStrItem = new XTreeWidgetItem(localStrRoot);
// localStrItem->setText(0, aZoneFile->GetStem().section('.', 0, 0) + ".str");
// localStrItem->setIcon(0, localStrIcon);
// }
childFound = true;
break;
}
}
// if (!assetMap.techSets.isEmpty()) {
// QIcon techSetIcon = Utils::CreateAssetIcon(ASSET_TYPE_TECHNIQUE_SET);
const QString rawFileStr = QString("%1 [%2-%3]").arg(pathPart).arg(rawFile.startPos).arg(rawFile.endPos);
//rawFileStr = pathPart;
if (pathPart == pathParts.last()) {
XTreeWidgetItem *rawFileItem = new XTreeWidgetItem(tempItem);
rawFileItem->setText(0, rawFileStr);
// XTreeWidgetItem *techSetRoot = new XTreeWidgetItem(zoneItem);
// techSetRoot->setText(0, "Tech Sets");
// techSetRoot->setIcon(0, techSetIcon);
// techSetRoot->SetCategory(CATEGORY_TYPE);
tempItem = rawFileItem;
} else if (!childFound) {
tempItem = new XTreeWidgetItem(tempItem);
tempItem->setText(0, rawFileStr);
}
// for (auto techSet : assetMap.techSets) {
// XTreeWidgetItem *techSetItem = new XTreeWidgetItem(techSetRoot);
// techSetItem->setText(0, techSet.name);
// techSetItem->setIcon(0, techSetIcon);
// }
// }
}
tempItem->setIcon(0, rawFileIcon);
}
}
// if (!assetMap.rawFiles.isEmpty()) {
// QIcon rawFileIcon = Utils::CreateAssetIcon(ASSET_TYPE_RAWFILE);
if (!assetMap.menuFiles.isEmpty()) {
QIcon menuFileIcon = ZoneFile::AssetTypeToIcon(ASSET_MENU);
// XTreeWidgetItem *rawFileRoot = new XTreeWidgetItem(zoneItem);
// rawFileRoot->setText(0, "Raw Files");
// rawFileRoot->setIcon(0, rawFileIcon);
// rawFileRoot->SetCategory(CATEGORY_TYPE);
// for (auto rawFile : assetMap.rawFiles) {
// if (!rawFile.length) { continue; }
XTreeWidgetItem *menuRoot = new XTreeWidgetItem(zoneItem);
menuRoot->setText(0, "Menu Files");
menuRoot->setIcon(0, menuFileIcon);
menuRoot->SetCategory(CATEGORY_TYPE);
// XTreeWidgetItem *tempItem = rawFileRoot;
// // const QStringList pathParts = rawFile->path.split('/');
// // for (const QString &pathPart : pathParts) {
// // bool childFound = false;
// // for (int i = 0; i < tempItem->childCount(); i++) {
// // QTreeWidgetItem *rawChildItem = tempItem->child(i);
// // XTreeWidgetItem *childItem = dynamic_cast<XTreeWidgetItem*>(rawChildItem);
// // if (childItem->text(0) == pathPart) {
// // tempItem = childItem;
int menuIndex = 1;
for (MenuFile menuFile : assetMap.menuFiles) {
XTreeWidgetItem *menuFileRoot = new XTreeWidgetItem(menuRoot);
menuFileRoot->setText(0, QString("Menu %1").arg(menuIndex));
for (Menu menu : menuFile.menuDefs) {
XTreeWidgetItem *menuItem = new XTreeWidgetItem(menuFileRoot);
menuItem->setText(0, menu.filePath);
menuItem->setIcon(0, menuFileIcon);
}
menuIndex++;
}
}
// // childFound = true;
// // break;
// // }
// // }
if (!assetMap.images.isEmpty()) {
QIcon imageIcon = ZoneFile::AssetTypeToIcon(ASSET_IMAGE);
// // const QString rawFileStr = pathPart;// = QString("%1 [%2-%3]").arg(pathPart).arg(rawFile.startPos).arg(rawFile.endPos);
// // if (pathPart == pathParts.last()) {
// // XTreeWidgetItem *rawFileItem = new XTreeWidgetItem(tempItem);
// // rawFileItem->setText(0, rawFileStr);
XTreeWidgetItem *imageRoot = new XTreeWidgetItem(zoneItem);
imageRoot->setText(0, "Images");
imageRoot->setIcon(0, imageIcon);
imageRoot->SetCategory(CATEGORY_TYPE);
// // tempItem = rawFileItem;
// // } else if (!childFound) {
// // tempItem = new XTreeWidgetItem(tempItem);
// // tempItem->setText(0, rawFileStr);
// // }
for (Image image : assetMap.images) {
XTreeWidgetItem *imageItem = new XTreeWidgetItem(imageRoot);
imageItem->setText(0, image.materialName);
imageItem->setIcon(0, imageIcon);
}
}
// // }
// tempItem->setIcon(0, rawFileIcon);
// }
// }
if (!assetMap.models.isEmpty()) {
QIcon modelIcon = ZoneFile::AssetTypeToIcon(ASSET_MODEL);
// if (!assetMap.menuDefinitions.isEmpty()) {
// // QIcon MenuDefIcon = Utils::CreateAssetIcon(ASSET_TYPE_MENU);
XTreeWidgetItem *modelsRoot = new XTreeWidgetItem(zoneItem);
modelsRoot->setText(0, "Models");
modelsRoot->setIcon(0, modelIcon);
modelsRoot->SetCategory(CATEGORY_TYPE);
// // XTreeWidgetItem *menuRoot = new XTreeWidgetItem(zoneItem);
// // menuRoot->setText(0, "Menu Files");
// // menuRoot->setIcon(0, MenuDefIcon);
// // menuRoot->SetCategory(CATEGORY_TYPE);
for (Model model: assetMap.models) {
XTreeWidgetItem *modelItem = new XTreeWidgetItem(modelsRoot);
modelItem->setText(0, model.modelName);
modelItem->setIcon(0, modelIcon);
}
}
// // int menuIndex = 1;
// // for (MenuDef menuDef : assetMap.menuDefinitions) {
// // XTreeWidgetItem *MenuDefRoot = new XTreeWidgetItem(menuRoot);
// // MenuDefRoot->setText(0, QString("Menu %1").arg(menuIndex));
// // for (Menu menu : menuDef.men) {
// // XTreeWidgetItem *menuItem = new XTreeWidgetItem(MenuDefRoot);
// // menuItem->setText(0, menu.filePath);
// // menuItem->setIcon(0, MenuDefIcon);
// // }
// // menuIndex++;
// // }
// }
if (!assetMap.materials.isEmpty()) {
QIcon materialIcon = ZoneFile::AssetTypeToIcon(ASSET_MATERIAL);
// if (!assetMap.images.isEmpty()) {
// // QIcon imageIcon = Utils::CreateAssetIcon(ASSET_TYPE_IMAGE);
XTreeWidgetItem *materialsRoot = new XTreeWidgetItem(zoneItem);
materialsRoot->setText(0, "Materials");
materialsRoot->setIcon(0, materialIcon);
materialsRoot->SetCategory(CATEGORY_TYPE);
// // XTreeWidgetItem *imageRoot = new XTreeWidgetItem(zoneItem);
// // imageRoot->setText(0, "Images");
// // imageRoot->setIcon(0, imageIcon);
// // imageRoot->SetCategory(CATEGORY_TYPE);
for (Material material: assetMap.materials) {
XTreeWidgetItem *materialItem = new XTreeWidgetItem(materialsRoot);
materialItem->setText(0, material.name);
materialItem->setIcon(0, materialIcon);
}
}
// // for (Image image : assetMap.images) {
// // XTreeWidgetItem *imageItem = new XTreeWidgetItem(imageRoot);
// // imageItem->setText(0, image.materialName);
// // imageItem->setIcon(0, imageIcon);
// // }
// }
if (!assetMap.stringTables.isEmpty()) {
QIcon stringTableIcon = ZoneFile::AssetTypeToIcon(ASSET_STRING_TABLE);
// if (!assetMap.models.isEmpty()) {
// QIcon modelIcon = Utils::CreateAssetIcon(ASSET_TYPE_XMODEL);
XTreeWidgetItem *strTableRoot = new XTreeWidgetItem(zoneItem);
strTableRoot->setText(0, "String Tables");
strTableRoot->setIcon(0, stringTableIcon);
strTableRoot->SetCategory(CATEGORY_TYPE);
// XTreeWidgetItem *modelsRoot = new XTreeWidgetItem(zoneItem);
// modelsRoot->setText(0, "Models");
// modelsRoot->setIcon(0, modelIcon);
// modelsRoot->SetCategory(CATEGORY_TYPE);
for (StringTable strTable: assetMap.stringTables) {
XTreeWidgetItem *modelItem = new XTreeWidgetItem(strTableRoot);
modelItem->setText(0, strTable.name);
modelItem->setIcon(0, stringTableIcon);
}
}
// for (auto model: assetMap.models) {
// XTreeWidgetItem *modelItem = new XTreeWidgetItem(modelsRoot);
// modelItem->setText(0, model.name);
// modelItem->setIcon(0, modelIcon);
// }
// }
if (!assetMap.sounds.isEmpty()) {
QIcon soundIcon = ZoneFile::AssetTypeToIcon(ASSET_SOUND);
// if (!assetMap.materials.isEmpty()) {
// QIcon materialIcon = Utils::CreateAssetIcon(ASSET_TYPE_MATERIAL);
XTreeWidgetItem *soundsRoot = new XTreeWidgetItem(zoneItem);
soundsRoot->setText(0, "Sounds");
soundsRoot->setIcon(0, soundIcon);
soundsRoot->SetCategory(CATEGORY_TYPE);
for (SoundAsset soundAsset : assetMap.sounds) {
for (Sound sound : soundAsset.sounds) {
XTreeWidgetItem *tempItem = soundsRoot;
// XTreeWidgetItem *materialsRoot = new XTreeWidgetItem(zoneItem);
// materialsRoot->setText(0, "Materials");
// materialsRoot->setIcon(0, materialIcon);
// materialsRoot->SetCategory(CATEGORY_TYPE);
if (!sound.dataLength) { continue; }
// for (auto material: assetMap.materials) {
// XTreeWidgetItem *materialItem = new XTreeWidgetItem(materialsRoot);
// //materialItem->setText(0, material.name);
// materialItem->setIcon(0, materialIcon);
// }
// }
for (const QString &pathPart : sound.path.split('/')) {
if (pathPart.isEmpty()) { continue; }
// if (!assetMap.stringTables.isEmpty()) {
// QIcon stringTableIcon = Utils::CreateAssetIcon(ASSET_TYPE_STRINGTABLE);
bool childFound = false;
for (int i = 0; i < tempItem->childCount(); i++) {
XTreeWidgetItem *childItem = dynamic_cast<XTreeWidgetItem*>(tempItem->child(i));
if (childItem->text(0) == pathPart) {
tempItem = childItem;
// XTreeWidgetItem *strTableRoot = new XTreeWidgetItem(zoneItem);
// strTableRoot->setText(0, "String Tables");
// strTableRoot->setIcon(0, stringTableIcon);
// strTableRoot->SetCategory(CATEGORY_TYPE);
childFound = true;
break;
}
}
// for (auto strTable: assetMap.stringTables) {
// XTreeWidgetItem *modelItem = new XTreeWidgetItem(strTableRoot);
// modelItem->setText(0, strTable.name);
// modelItem->setIcon(0, stringTableIcon);
// }
// }
if (pathPart.contains(".wav")) {
XTreeWidgetItem *soundItem = new XTreeWidgetItem(tempItem);
soundItem->setText(0, pathPart);
// if (!assetMap.sounds.isEmpty()) {
// QIcon soundIcon = Utils::CreateAssetIcon(ASSET_TYPE_SOUND);
tempItem = soundItem;
} else if (!childFound) {
tempItem = new XTreeWidgetItem(tempItem);
tempItem->setText(0, pathPart);
}
// XTreeWidgetItem *soundsRoot = new XTreeWidgetItem(zoneItem);
// soundsRoot->setText(0, "Sounds");
// soundsRoot->setIcon(0, soundIcon);
// soundsRoot->SetCategory(CATEGORY_TYPE);
// }
}
tempItem->setIcon(0, soundIcon);
}
}
}
mZoneFiles[aZoneFile->GetBaseStem() + ".zone"] = aZoneFile;
}
@ -302,7 +324,7 @@ void XTreeWidget::PrepareContextMenu(const QPoint &pos) {
QMenu *exportSubmenu = new QMenu("Export...", this);
contextMenu->addMenu(exportSubmenu);
const DDSFile* ddsFile = mDDSFiles[fileStem];
std::shared_ptr<DDSFile> ddsFile = mDDSFiles[fileStem];
QAction *exportIWIAction = new QAction("Export as IWI");
exportSubmenu->addAction(exportIWIAction);
@ -346,7 +368,7 @@ void XTreeWidget::PrepareContextMenu(const QPoint &pos) {
QMenu *exportSubmenu = new QMenu("Export...", this);
contextMenu->addMenu(exportSubmenu);
const IWIFile* iwiFile = mIWIFiles[fileStem];
std::shared_ptr<IWIFile> iwiFile = mIWIFiles[fileStem];
QAction *exportDDSAction = new QAction("Export as DDS");
exportSubmenu->addAction(exportDDSAction);
@ -475,7 +497,7 @@ void XTreeWidget::PrepareContextMenu(const QPoint &pos) {
QMenu *exportSubmenu = new QMenu("Export...", this);
contextMenu->addMenu(exportSubmenu);
const FastFile* fastFile = mFastFiles[fileStem];
std::shared_ptr<FastFile> fastFile = mFastFiles[fileStem];
QAction *exportFastFileAction = new QAction("Export Fast File");
exportSubmenu->addAction(exportFastFileAction);
@ -490,13 +512,13 @@ void XTreeWidget::PrepareContextMenu(const QPoint &pos) {
});
QAction *exportZoneFileAction = new QAction("Export Zone File");
exportSubmenu->addAction(exportZoneFileAction);
connect(exportZoneFileAction, &QAction::triggered, this, [](bool checked) {
connect(exportZoneFileAction, &QAction::triggered, this, [fastFile](bool checked) {
Q_UNUSED(checked);
// const QString zoneFilePath = QFileDialog::getSaveFileName(
// nullptr, "Export Zone File...", QDir::currentPath(),
// "Zone File (*.zone);;All Files(*.*)");
//fastFile->GetZoneFile()->SaveZoneFile(zoneFilePath);
const QString zoneFilePath = QFileDialog::getSaveFileName(
nullptr, "Export Zone File...", QDir::currentPath(),
"Zone File (*.zone);;All Files(*.*)");
fastFile->GetZoneFile()->SaveZoneFile(zoneFilePath);
});
} else if (activeText.contains(".zone")) {
const QString fileStem = activeText;
@ -508,7 +530,7 @@ void XTreeWidget::PrepareContextMenu(const QPoint &pos) {
QMenu *exportSubmenu = new QMenu("Export...", this);
contextMenu->addMenu(exportSubmenu);
//const ZoneFile* zoneFile = mZoneFiles[fileStem];
std::shared_ptr<ZoneFile> zoneFile = mZoneFiles[fileStem];
QAction *exportZoneFileAction = new QAction("Export Zone File");
exportSubmenu->addAction(exportZoneFileAction);
@ -530,41 +552,41 @@ void XTreeWidget::PrepareContextMenu(const QPoint &pos) {
}
}
if (parentItem && parentItem != invisibleRootItem() && parentItem->text(0).contains(".zone")) {
//const QString fileStem = parentItem->text(0).section('.', 0, 0);
// QVector<LoadedSound> LoadedSounds = mZoneFiles[fileStem]->GetAssetMap().sounds;
// for (LoadedSound LoadedSound : LoadedSounds) {
// for (Sound sound : LoadedSound.sounds) {
// if (sound.path.contains(activeText)) {
// QMenu *exportSubmenu = new QMenu("Export...", this);
// contextMenu->addMenu(exportSubmenu);
const QString fileStem = parentItem->text(0).section('.', 0, 0);
QVector<SoundAsset> soundAssets = mZoneFiles[fileStem]->GetAssetMap().sounds;
for (SoundAsset soundAsset : soundAssets) {
for (Sound sound : soundAsset.sounds) {
if (sound.path.contains(activeText)) {
QMenu *exportSubmenu = new QMenu("Export...", this);
contextMenu->addMenu(exportSubmenu);
// QAction *exportWAVAction = new QAction("Export as WAV File");
// exportSubmenu->addAction(exportWAVAction);
// connect(exportWAVAction, &QAction::triggered, this, [sound](bool checked) {
// Q_UNUSED(checked);
QAction *exportWAVAction = new QAction("Export as WAV File");
exportSubmenu->addAction(exportWAVAction);
connect(exportWAVAction, &QAction::triggered, this, [sound](bool checked) {
Q_UNUSED(checked);
// QDir dir = QDir::currentPath();
// if (!dir.exists("exports/")) {
// dir.mkdir("exports/");
// }
QDir dir = QDir::currentPath();
if (!dir.exists("exports/")) {
dir.mkdir("exports/");
}
// if (!dir.exists("exports/sounds/")) {
// dir.mkdir("exports/sounds/");
// }
if (!dir.exists("exports/sounds/")) {
dir.mkdir("exports/sounds/");
}
// const QString fileName = "exports/sounds/" + sound.path.split('/').last();
// QFile wavFile(fileName);
// if (!wavFile.open(QIODevice::WriteOnly)) {
// qDebug() << "Failed to write wav file!";
// return;
// }
// wavFile.write(sound.data);
// wavFile.close();
// });
// break;
// }
// }
// }
const QString fileName = "exports/sounds/" + sound.path.split('/').last();
QFile wavFile(fileName);
if (!wavFile.open(QIODevice::WriteOnly)) {
qDebug() << "Failed to write wav file!";
return;
}
wavFile.write(sound.data);
wavFile.close();
});
break;
}
}
}
}
} else if (activeItem && activeText == "Sounds") {
XTreeWidgetItem *parentItem = dynamic_cast<XTreeWidgetItem*>(activeItem->parent());
@ -577,39 +599,39 @@ void XTreeWidget::PrepareContextMenu(const QPoint &pos) {
}
if (parentItem && parentItem != invisibleRootItem() && parentItem->text(0).contains(".zone")) {
const QString fileStem = parentItem->text(0).section('.', 0, 0);
//auto zoneFile = mZoneFiles[fileStem];
auto zoneFile = mZoneFiles[fileStem];
QMenu *exportSubmenu = new QMenu("Export...", this);
contextMenu->addMenu(exportSubmenu);
QAction *exportAllWAVAction = new QAction("Export ALL as WAV Files");
exportSubmenu->addAction(exportAllWAVAction);
connect(exportAllWAVAction, &QAction::triggered, this, [](bool checked) {
connect(exportAllWAVAction, &QAction::triggered, this, [zoneFile](bool checked) {
Q_UNUSED(checked);
// for (LoadedSound LoadedSound : zoneFile->GetAssetMap().sounds) {
// for (Sound sound : LoadedSound.sounds) {
// if (!sound.dataLength) { continue; }
for (SoundAsset soundAsset : zoneFile->GetAssetMap().sounds) {
for (Sound sound : soundAsset.sounds) {
if (!sound.dataLength) { continue; }
// QDir dir = QDir::currentPath();
// if (!dir.exists("exports/")) {
// dir.mkdir("exports/");
// }
QDir dir = QDir::currentPath();
if (!dir.exists("exports/")) {
dir.mkdir("exports/");
}
// if (!dir.exists("exports/sounds/")) {
// dir.mkdir("exports/sounds/");
// }
if (!dir.exists("exports/sounds/")) {
dir.mkdir("exports/sounds/");
}
// const QString fileName = "exports/sounds/" + sound.path.split('/').last();
// QFile wavFile(fileName);
// if (!wavFile.open(QIODevice::WriteOnly)) {
// qDebug() << "Failed to write wav file!";
// return;
// }
// wavFile.write(sound.data);
// wavFile.close();
// }
// }
const QString fileName = "exports/sounds/" + sound.path.split('/').last();
QFile wavFile(fileName);
if (!wavFile.open(QIODevice::WriteOnly)) {
qDebug() << "Failed to write wav file!";
return;
}
wavFile.write(sound.data);
wavFile.close();
}
}
});
}
}
@ -631,19 +653,20 @@ void XTreeWidget::ItemSelectionChanged() {
XTreeWidgetItem *parentItem = dynamic_cast<XTreeWidgetItem*>(selectedItem->parent());
/*if (selectedText.contains(".dds")) {
if (selectedText.contains(".dds")) {
if (!mDDSFiles.contains(selectedText)) {
LogManager::instance().addError("Could not find " + selectedText + " in DDS map!");
return;
}
emit DDSFileSelected(mDDSFiles[selectedText], selectedText);
std::shared_ptr<DDSFile> ddsFile = mDDSFiles[selectedText];
emit DDSFileSelected(ddsFile, selectedText);
} else if (selectedText.contains(".iwi")) {
if (!mIWIFiles.contains(selectedText)) {
LogManager::instance().addError("Could not find " + selectedText + " in IWI map!");
return;
}
emit IWIFileSelected(mIWIFiles[selectedText], selectedText);
} else */if (selectedText.contains(".ff")) {
} else if (selectedText.contains(".ff")) {
if (!mFastFiles.contains(selectedText)) {
LogManager::instance().addError("Could not find " + selectedText + " in Fast File map!");
return;
@ -665,22 +688,34 @@ void XTreeWidget::ItemSelectionChanged() {
XTreeWidgetItem *grandpaItem = dynamic_cast<XTreeWidgetItem*>(parentItem->parent());
if (grandpaItem && grandpaItem->text(0).contains(".zone")) {
const QString fileStem = grandpaItem->text(0).section('.', 0, 0);
// QVector<Image> images = mZoneFiles[fileStem]->GetAssetMap().images;
// for (Image image : images) {
// if (image.materialName == selectedText) {
// emit ImageSelected(std::make_shared<Image>(image), fileStem);
// break;
// }
// }
QVector<Image> images = mZoneFiles[fileStem]->GetAssetMap().images;
for (Image image : images) {
if (image.materialName == selectedText) {
emit ImageSelected(std::make_shared<Image>(image), fileStem);
break;
}
}
}
} /*else if (parentItem && (parentItem->text(0) == "Tech Sets")) {
} else if (parentItem && (parentItem->text(0) == "Tech Sets")) {
XTreeWidgetItem *grandpaItem = dynamic_cast<XTreeWidgetItem*>(parentItem->parent());
if (grandpaItem && grandpaItem->text(0).contains(".zone")) {
const QString fileStem = grandpaItem->text(0).section('.', 0, 0);
auto techsets = mZoneFiles[fileStem]->GetAssetList().techSets;
auto techsets = mZoneFiles[fileStem]->GetAssetMap().techSets;
for (auto techset : techsets) {
if (techset.name == selectedText) {
emit TechSetSelected(new MaterialTechSet(techset), fileStem);
emit TechSetSelected(std::make_shared<TechSet>(techset), fileStem);
break;
}
}
}
} else if (parentItem && (parentItem->text(0) == "Tech Sets")) {
XTreeWidgetItem *grandpaItem = dynamic_cast<XTreeWidgetItem*>(parentItem->parent());
if (grandpaItem && grandpaItem->text(0).contains(".zone")) {
const QString fileStem = grandpaItem->text(0).section('.', 0, 0);
auto techsets = mZoneFiles[fileStem]->GetAssetMap().techSets;
for (auto techset : techsets) {
if (techset.name == selectedText) {
emit TechSetSelected(std::make_shared<TechSet>(techset), fileStem);
break;
}
}
@ -689,12 +724,12 @@ void XTreeWidget::ItemSelectionChanged() {
XTreeWidgetItem *grandpaItem = dynamic_cast<XTreeWidgetItem*>(parentItem->parent());
if (grandpaItem && grandpaItem->text(0).contains(".zone")) {
const QString fileStem = grandpaItem->text(0).section('.', 0, 0);
auto materials = mZoneFiles[fileStem]->GetAssetMap().materials;
for (auto material : materials) {
// if (material.name == selectedText) {
// emit MaterialSelected(std::make_shared<Material>(material), fileStem);
// break;
// }
QVector<Material> materials = mZoneFiles[fileStem]->GetAssetMap().materials;
for (Material material : materials) {
if (material.name == selectedText) {
emit MaterialSelected(std::make_shared<Material>(material), fileStem);
break;
}
}
}
} else if (parentItem && selectedText.contains(".wav")) {
@ -708,15 +743,15 @@ void XTreeWidget::ItemSelectionChanged() {
}
if (grandpaItem && grandpaItem != invisibleRootItem() && grandpaItem->text(0).contains(".zone")) {
const QString fileStem = grandpaItem->text(0).section('.', 0, 0);
// QVector<LoadedSound> LoadedSounds = mZoneFiles[fileStem]->GetAssetMap().sounds;
// for (LoadedSound LoadedSound : LoadedSounds) {
// for (Sound sound : LoadedSound.sounds) {
// if (sound.path.contains(selectedText)) {
// emit SoundSelected(std::make_shared<Sound>(sound), fileStem);
// break;
// }
// }
// }
QVector<SoundAsset> soundAssets = mZoneFiles[fileStem]->GetAssetMap().sounds;
for (SoundAsset soundAsset : soundAssets) {
for (Sound sound : soundAsset.sounds) {
if (sound.path.contains(selectedText)) {
emit SoundSelected(std::make_shared<Sound>(sound), fileStem);
break;
}
}
}
}
} else if (selectedItem->GetCategory() != CATEGORY_TYPE) {
XTreeWidgetItem *zoneRoot = selectedItem;
@ -737,17 +772,17 @@ void XTreeWidget::ItemSelectionChanged() {
return;
}
auto rawFiles = mZoneFiles[fileStem]->GetAssetMap().rawFiles;
for (auto rawFile : rawFiles) {
//if (rawFile->path.split('/').last() == selectedText) {
// emit RawFileSelected(std::make_shared<RawFile>(rawFile), fileStem);
// return;
//}
QVector<RawFile> rawFiles = mZoneFiles[fileStem]->GetAssetMap().rawFiles;
for (RawFile rawFile : rawFiles) {
if (rawFile.path.split('/').last() == selectedText) {
emit RawFileSelected(std::make_shared<RawFile>(rawFile), fileStem);
return;
}
}
}*/
}
}
const ZoneFile* XTreeWidget::FindZoneFile(const QString aStem) {
std::shared_ptr<ZoneFile> XTreeWidget::FindZoneFile(const QString aStem) {
foreach (auto zoneFile, mZoneFiles) {
if (zoneFile->GetStem() == aStem) {
return zoneFile;
@ -756,7 +791,7 @@ const ZoneFile* XTreeWidget::FindZoneFile(const QString aStem) {
return nullptr;
}
const FastFile *XTreeWidget::FindFastFile(const QString aStem) {
std::shared_ptr<FastFile> XTreeWidget::FindFastFile(const QString aStem) {
foreach (auto fastFile, mFastFiles) {
if (fastFile->GetStem() == aStem) {
return fastFile;
@ -773,7 +808,7 @@ bool XTreeWidget::HasFastFile(const QString aStem) {
return FindFastFile(aStem) != nullptr;
}
void XTreeWidget::AddIWIFile(IWIFile* aIWIFile) {
void XTreeWidget::AddIWIFile(std::shared_ptr<IWIFile> aIWIFile) {
const QString iwiFileName = QString(aIWIFile->fileStem + ".iwi");
for (int i = 0; i < invisibleRootItem()->childCount(); i++) {
@ -784,12 +819,12 @@ void XTreeWidget::AddIWIFile(IWIFile* aIWIFile) {
}
XTreeWidgetItem *iwiItem = new XTreeWidgetItem(this);
iwiItem->setIcon(0, Utils::CreateAssetIcon(ASSET_TYPE_IMAGE));
iwiItem->setIcon(0, ZoneFile::AssetTypeToIcon(ASSET_IMAGE));
iwiItem->setText(0, iwiFileName);
mIWIFiles[aIWIFile->fileStem.section(".", 0, 0)] = aIWIFile;
}
void XTreeWidget::AddDDSFile(DDSFile* aDDSFile) {
void XTreeWidget::AddDDSFile(std::shared_ptr<DDSFile> aDDSFile) {
const QString ddsFileName = QString(aDDSFile->fileStem + ".dds");
for (int i = 0; i < invisibleRootItem()->childCount(); i++) {
@ -800,7 +835,7 @@ void XTreeWidget::AddDDSFile(DDSFile* aDDSFile) {
}
XTreeWidgetItem *ddsItem = new XTreeWidgetItem(this);
ddsItem->setIcon(0, Utils::CreateAssetIcon(ASSET_TYPE_IMAGE));
ddsItem->setIcon(0, ZoneFile::AssetTypeToIcon(ASSET_IMAGE));
ddsItem->setText(0, ddsFileName);
mDDSFiles[aDDSFile->fileStem.section(".", 0, 0)] = aDDSFile;
}

51
app/xtreewidget.h
View File

@ -2,16 +2,13 @@
#define XTREEWIDGET_H
#include "d3dbsp_structs.h"
#include "asset_structs.h"
#include "ddsfile.h"
#include "iwifile.h"
#include "fastfile.h"
#include "xloadedsound.h"
#include "xtreewidgetitem.h"
#include "zonefile.h"
#include "xrawfile.h"
#include "xgfximage.h"
#include "xstringtable.h"
#include "xmenudef.h"
#include "utils.h"
#include <QTreeWidget>
#include <QFileDialog>
@ -23,31 +20,31 @@ public:
explicit XTreeWidget(QWidget *parent = nullptr);
~XTreeWidget();
void AddFastFile(FastFile* aFastFile);
void AddZoneFile(const ZoneFile *aZoneFile, XTreeWidgetItem *aParentItem = nullptr);
void AddIWIFile(IWIFile* aIWIFile);
void AddDDSFile(DDSFile* aDDSFile);
void AddFastFile(std::shared_ptr<FastFile> aFastFile);
void AddZoneFile(std::shared_ptr<ZoneFile> aZoneFile, XTreeWidgetItem *aParentItem = nullptr);
void AddIWIFile(std::shared_ptr<IWIFile> aIWIFile);
void AddDDSFile(std::shared_ptr<DDSFile> aDDSFile);
const ZoneFile *FindZoneFile(const QString aStem);
const FastFile* FindFastFile(const QString aStem);
std::shared_ptr<ZoneFile> FindZoneFile(const QString aStem);
std::shared_ptr<FastFile> FindFastFile(const QString aStem);
bool HasZoneFile(const QString aStem);
bool HasFastFile(const QString aStem);
void CloseFastFile(const QString aFFName);
signals:
void DDSFileSelected(const DDSFile* aDDSFile, const QString aParentName);
void IWIFileSelected(const IWIFile* aIWIFile, const QString aParentName);
void FastFileSelected(const FastFile* aFastFile, const QString aParentName);
void ZoneFileSelected(const ZoneFile* aZoneFile, const QString aParentName);
void LocalStringSelected(const ZoneFile* aZoneFile, const QString aParentName);
void RawFileSelected(const XRawFile* aRawFile, const QString aParentName);
void ImageSelected(const XGfxImage* aImage, const QString aParentName);
void TechSetSelected(const XMaterialTechniqueSet* aZoneFile, const QString aParentName);
void StrTableSelected(const XStringTable* aStrTable, const QString aParentName);
void MenuSelected(const XMenuDef* aMenu, const QString aParentName);
void SoundSelected(const XLoadedSound* aSound, const QString aParentName);
void MaterialSelected(const XMaterial* aMaterial, const QString aParentName);
void DDSFileSelected(std::shared_ptr<DDSFile> aDDSFile, const QString aParentName);
void IWIFileSelected(std::shared_ptr<IWIFile> aIWIFile, const QString aParentName);
void FastFileSelected(std::shared_ptr<FastFile> aFastFile, const QString aParentName);
void ZoneFileSelected(std::shared_ptr<ZoneFile> aZoneFile, const QString aParentName);
void LocalStringSelected(std::shared_ptr<ZoneFile> aZoneFile, const QString aParentName);
void RawFileSelected(std::shared_ptr<RawFile> aRawFile, const QString aParentName);
void ImageSelected(std::shared_ptr<Image> aImage, const QString aParentName);
void TechSetSelected(std::shared_ptr<TechSet> aZoneFile, const QString aParentName);
void StrTableSelected(std::shared_ptr<StringTable> aStrTable, const QString aParentName);
void MenuSelected(std::shared_ptr<Menu> aMenu, const QString aParentName);
void SoundSelected(std::shared_ptr<Sound> aSound, const QString aParentName);
void MaterialSelected(std::shared_ptr<Material> aMaterial, const QString aParentName);
void ItemSelected(const QString itemText);
void ItemClosed(const QString itemText);
@ -58,10 +55,10 @@ protected:
void PrepareContextMenu(const QPoint &pos);
private:
QMap<QString, const FastFile*> mFastFiles;
QMap<QString, const ZoneFile*> mZoneFiles;
QMap<QString, const DDSFile*> mDDSFiles;
QMap<QString, const IWIFile*> mIWIFiles;
QMap<QString, std::shared_ptr<FastFile>> mFastFiles;
QMap<QString, std::shared_ptr<ZoneFile>> mZoneFiles;
QMap<QString, std::shared_ptr<DDSFile>> mDDSFiles;
QMap<QString, std::shared_ptr<IWIFile>> mIWIFiles;
};
#endif // XTREEWIDGET_H

42
app/zonefileviewer.cpp
View File

@ -69,7 +69,7 @@ void ZoneFileViewer::SortTags(const QString &aSearchText) {
ui->listWidget_Tags->addItems(sortedTags);
}
void ZoneFileViewer::SetZoneFile(const ZoneFile* aZoneFile) {
void ZoneFileViewer::SetZoneFile(std::shared_ptr<ZoneFile> aZoneFile) {
mZoneFile = aZoneFile;
ui->tableWidget_RecordCounts->clearContents();
@ -88,36 +88,37 @@ void ZoneFileViewer::SetZoneFile(const ZoneFile* aZoneFile) {
ui->groupBox_Tags->show();
}
QMap<XAssetType, int> recordCounts = QMap<XAssetType, int>();
QVector<QPair<XAssetType, int>> assetOccurances = QVector<QPair<XAssetType, int>>();
for (XAssetType type : mZoneFile->GetTypes()) {
if (!recordCounts.contains(type)) {
recordCounts[type] = 0;
QMap<QString, int> recordCounts = QMap<QString, int>();
QVector<QPair<QString, int>> assetOccurances = QVector<QPair<QString, int>>();
for (const QString &record : mZoneFile->GetRecords()) {
if (!recordCounts.contains(record)) {
recordCounts[record] = 0;
}
recordCounts[type]++;
recordCounts[record]++;
if (!assetOccurances.isEmpty() && assetOccurances.last().first == type) {
if (!assetOccurances.isEmpty() && assetOccurances.last().first == record) {
assetOccurances.last().second++;
continue;
}
QPair<XAssetType, int> assetOccurance(type, 1);
QPair<QString, int> assetOccurance(record, 1);
assetOccurances << assetOccurance;
}
ui->tableWidget_RecordOrder->setRowCount(assetOccurances.size());
int assetIndex = 0;
foreach (auto assetOccurance, assetOccurances) {
XAssetType assetType = assetOccurance.first;
const QString record = assetOccurance.first;
AssetType assetType = mZoneFile->AssetStrToEnum(record);
int assetCount = assetOccurance.second;
QIcon assetIcon = Utils::CreateAssetIcon(assetType);
QIcon assetIcon = mZoneFile->AssetTypeToIcon(assetType);
if (assetIcon.isNull()) {
qDebug() << "Icon is null for record: " << assetType;
qDebug() << "Icon is null for record: " << record;
}
QTableWidgetItem *recordItem = new QTableWidgetItem(QString::number(assetType, 16));
QTableWidgetItem *recordStrItem = new QTableWidgetItem(XAsset::XAssetTypeToString(assetType));
QTableWidgetItem *recordItem = new QTableWidgetItem(record.toUpper());
QTableWidgetItem *recordStrItem = new QTableWidgetItem(mZoneFile->AssetEnumToStr(assetType));
QTableWidgetItem *recordCountItem = new QTableWidgetItem(QString::number(assetCount));
recordItem->setIcon(assetIcon);
@ -129,18 +130,19 @@ void ZoneFileViewer::SetZoneFile(const ZoneFile* aZoneFile) {
}
int recordIndex = 0;
for (XAssetType assetType : recordCounts.keys()) {
int recordCount = recordCounts[assetType];
for (const QString &record : recordCounts.keys()) {
int recordCount = recordCounts[record];
QIcon assetIcon = Utils::CreateAssetIcon(assetType);
AssetType assetType = mZoneFile->AssetStrToEnum(record);
QIcon assetIcon = mZoneFile->AssetTypeToIcon(assetType);
if (assetIcon.isNull()) {
qDebug() << "Icon is null for record: " << assetType;
qDebug() << "Icon is null for record: " << record;
}
ui->tableWidget_RecordCounts->setRowCount(recordIndex + 1);
QTableWidgetItem *recordItem = new QTableWidgetItem(QString::number(assetType, 16));
QTableWidgetItem *recordCountStrItem = new QTableWidgetItem(XAsset::XAssetTypeToString(assetType));
QTableWidgetItem *recordItem = new QTableWidgetItem(record.toUpper());
QTableWidgetItem *recordCountStrItem = new QTableWidgetItem(mZoneFile->AssetEnumToStr(assetType));
QTableWidgetItem *recordCountItem = new QTableWidgetItem(QString::number(recordCount));
recordItem->setIcon(assetIcon);

4
app/zonefileviewer.h
View File

@ -18,7 +18,7 @@ public:
explicit ZoneFileViewer(QWidget *parent = nullptr);
~ZoneFileViewer();
void SetZoneFile(const ZoneFile *aZoneFile);
void SetZoneFile(std::shared_ptr<ZoneFile> aZoneFile);
public slots:
void SortTags(const QString &aSearchText);
@ -27,7 +27,7 @@ public slots:
private:
Ui::ZoneFileViewer *ui;
const ZoneFile* mZoneFile;
std::shared_ptr<ZoneFile> mZoneFile;
};
#endif // ZONEFILEVIEWER_H

1
data/Data.qrc
View File

@ -20,6 +20,7 @@
<file>icons/Icon_Editor.png</file>
<file>icons/Icon_Views.png</file>
<file>icons/Icon_Tree.png</file>
<file>icons/Icon_Copy.png</file>
<file>icons/Icon_Cut.png</file>
<file>icons/Icon_Find.png</file>
<file>icons/Icon_NewFile.png</file>

BIN
data/icons/Icon_Copy.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 316 B

84
libs/compression/compression.cpp
View File

@ -1,10 +1,13 @@
#include "compression.h"
#include "minilzo.h"
#define XBOXAPI __declspec(dllimport)
#include "xcompress.h"
#include <QLibrary>
#include <QDebug>
#include <QFile>
#include <QDataStream>
QByteArray Compression::CompressXMem(const QByteArray &data)
{
@ -31,8 +34,7 @@ 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 {};
@ -42,49 +44,27 @@ QByteArray Compression::DecompressXMem(const QByteArray &data,
lzxParams.WindowSize = windowSize;
lzxParams.CompressionPartitionSize = partSize;
QByteArray internalState(0x94933, Qt::Uninitialized);
XMEMDECOMPRESSION_CONTEXT ctx = nullptr;
if (FAILED(XMemCreateDecompressionContext(XMEMCODEC_LZX, &lzxParams, 0, &ctx)) || !ctx)
return {};
XMEMDECOMPRESSION_CONTEXT ctx = XMemInitializeDecompressionContext(
XMEMCODEC_LZX, &lzxParams, 1,
internalState.data(), internalState.size());
// 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;
if (!ctx || XMemResetDecompressionContext(ctx)) {
qWarning() << "Failed to init LZX context";
HRESULT hr = XMemDecompress(ctx,
output.data(), &actualSize,
data.constData(), data.size() + 16);
XMemDestroyDecompressionContext(ctx);
if (FAILED(hr)) {
qWarning() << "XMemDecompress failed with HRESULT:" << hr;
return {};
}
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);
output.resize(static_cast<int>(actualSize));
return output;
}
@ -100,18 +80,19 @@ quint32 Compression::CalculateAdler32Checksum(const QByteArray &data) {
qint64 Compression::FindZlibOffset(const QByteArray &bytes)
{
QDataStream stream(bytes);
static const QByteArray iwffs("IWffs");
auto idx = bytes.indexOf(iwffs);
if (idx != -1)
return idx + 0x4000;
while (!stream.atEnd())
const char header = 0x78; // z-lib: 0x78 [FLG]
int pos = -1;
while ((pos = bytes.indexOf(header, pos + 1)) != -1)
{
QByteArray testSegment = stream.device()->peek(2).toHex().toUpper();
if (testSegment == "7801" ||
testSegment == "785E" ||
testSegment == "789C" ||
testSegment == "78DA") {
return stream.device()->pos();
}
stream.skipRawData(1);
QByteArray window = bytes.mid(pos, 0x20);
if (!window.contains(QByteArray::fromHex("000000")) &&
!window.contains(QByteArray::fromHex("FFFFFF")))
return pos;
}
return -1;
}
@ -314,12 +295,11 @@ QByteArray Compression::CompressDeflateWithSettings(const QByteArray &aData, int
}
QByteArray Compression::DecompressLZO(const QByteArray &aCompressedData, quint32 aDestSize) {
QByteArray dst;
static bool ok = (lzo_init() == LZO_E_OK);
if (!ok)
throw std::runtime_error("lzo_init failed");
dst = QByteArray(aDestSize, Qt::Uninitialized);
QByteArray dst(aDestSize, Qt::Uninitialized);
lzo_uint out = aDestSize;
int rc = lzo1x_decompress_safe(

2
libs/compression/compression.h
View File

@ -3,7 +3,7 @@
#include "QtZlib/zlib.h"
//#include <windows.h>
#include <windows.h>
#include <QtGlobal>
#include <stddef.h>
#include <QByteArray>

18
libs/compression/compression.pro
View File

@ -3,14 +3,20 @@ TEMPLATE = lib
CONFIG += staticlib c++17
DEFINES += MINILZO_USE_STATIC
SOURCES += $$files($$PWD/*.cpp, true) \
$$files($$PWD/*.c, true)
HEADERS += $$files($$PWD/*.h, true)
SOURCES += \
compression.cpp \
minilzo.c \
lzoconf.h \
lzodefs.h
HEADERS += \
compression.h \
minilzo.h
LIBS += \
-L$$PWD/../../third_party/xbox_sdk/lib -lxcompress64 \
-L$$OUT_PWD/../libs/core -lcore \
-L$$OUT_PWD/../libs/encryption -lencryption
-L$$PWD/../../third_party/xbox_sdk/lib -lxcompress64 \
-L$$OUT_PWD/../libs/core -lcore \
-L$$OUT_PWD/../libs/encryption -lencryption
INCLUDEPATH += \
$$PWD/../../third_party/xbox_sdk/include \

4
libs/compression/lzoconf.h
View File

@ -57,7 +57,7 @@
/* get OS and architecture defines */
#ifndef __LZODEFS_H_INCLUDED
#include <lzodefs.h>
#include <lzo/lzodefs.h>
#endif
@ -105,7 +105,7 @@ extern "C" {
# define LZO_INT_MAX 9223372036854775807LL
# define LZO_INT_MIN (-1LL - LZO_INT_MAX)
# elif (LZO_ABI_IP32L64) /* MIPS R5900 */
typedef quint32 lzo_uint;
typedef unsigned int lzo_uint;
typedef int lzo_int;
# define LZO_SIZEOF_LZO_INT LZO_SIZEOF_INT
# define LZO_TYPEOF_LZO_INT LZO_TYPEOF_INT

24
libs/compression/lzodefs.h
View File

@ -2847,7 +2847,7 @@ LZO_COMPILE_TIME_ASSERT_HEADER(LZO_SIZEOF_PTRDIFF_T == sizeof(ptrdiff_t))
# define LZO_TYPEOF_LZO_INT16E_T LZO_TYPEOF_LONG
#elif (LZO_SIZEOF_INT == 2) && !(LZO_CFG_PREFER_TYPEOF_ACC_INT16E_T == LZO_TYPEOF_SHORT)
# define lzo_int16e_t int
# define lzo_uint16e_t quint32
# define lzo_uint16e_t unsigned int
# define LZO_TYPEOF_LZO_INT16E_T LZO_TYPEOF_INT
#elif (LZO_SIZEOF_SHORT == 2)
# define lzo_int16e_t short int
@ -2856,14 +2856,14 @@ LZO_COMPILE_TIME_ASSERT_HEADER(LZO_SIZEOF_PTRDIFF_T == sizeof(ptrdiff_t))
#elif 1 && !(LZO_CFG_TYPE_NO_MODE_HI) && (LZO_CC_CLANG || (LZO_CC_GNUC >= 0x025f00ul) || LZO_CC_LLVM)
# if !(LZO_LANG_ASSEMBLER)
typedef int lzo_int16e_hi_t__ __attribute__((__mode__(__HI__)));
typedef quint32 lzo_uint16e_hi_t__ __attribute__((__mode__(__HI__)));
typedef unsigned int lzo_uint16e_hi_t__ __attribute__((__mode__(__HI__)));
# endif
# define lzo_int16e_t lzo_int16e_hi_t__
# define lzo_uint16e_t lzo_uint16e_hi_t__
# define LZO_TYPEOF_LZO_INT16E_T LZO_TYPEOF___MODE_HI
#elif (LZO_SIZEOF___INT16 == 2)
# define lzo_int16e_t __int16
# define lzo_uint16e_t quint32
# define lzo_uint16e_t unsigned __int16
# define LZO_TYPEOF_LZO_INT16E_T LZO_TYPEOF___INT16
#else
#endif
@ -2883,7 +2883,7 @@ LZO_COMPILE_TIME_ASSERT_HEADER(LZO_SIZEOF_PTRDIFF_T == sizeof(ptrdiff_t))
# define LZO_TYPEOF_LZO_INT32E_T LZO_TYPEOF_LONG
#elif (LZO_SIZEOF_INT == 4)
# define lzo_int32e_t int
# define lzo_uint32e_t quint32
# define lzo_uint32e_t unsigned int
# define LZO_TYPEOF_LZO_INT32E_T LZO_TYPEOF_INT
#elif (LZO_SIZEOF_SHORT == 4)
# define lzo_int32e_t short int
@ -2896,7 +2896,7 @@ LZO_COMPILE_TIME_ASSERT_HEADER(LZO_SIZEOF_PTRDIFF_T == sizeof(ptrdiff_t))
#elif 1 && !(LZO_CFG_TYPE_NO_MODE_SI) && (LZO_CC_CLANG || (LZO_CC_GNUC >= 0x025f00ul) || LZO_CC_LLVM) && (__INT_MAX__+0 > 2147483647L)
# if !(LZO_LANG_ASSEMBLER)
typedef int lzo_int32e_si_t__ __attribute__((__mode__(__SI__)));
typedef quint32 lzo_uint32e_si_t__ __attribute__((__mode__(__SI__)));
typedef unsigned int lzo_uint32e_si_t__ __attribute__((__mode__(__SI__)));
# endif
# define lzo_int32e_t lzo_int32e_si_t__
# define lzo_uint32e_t lzo_uint32e_si_t__
@ -2904,7 +2904,7 @@ LZO_COMPILE_TIME_ASSERT_HEADER(LZO_SIZEOF_PTRDIFF_T == sizeof(ptrdiff_t))
#elif 1 && !(LZO_CFG_TYPE_NO_MODE_SI) && (LZO_CC_GNUC >= 0x025f00ul) && defined(__AVR__) && (__LONG_MAX__+0 == 32767L)
# if !(LZO_LANG_ASSEMBLER)
typedef int lzo_int32e_si_t__ __attribute__((__mode__(__SI__)));
typedef quint32 lzo_uint32e_si_t__ __attribute__((__mode__(__SI__)));
typedef unsigned int lzo_uint32e_si_t__ __attribute__((__mode__(__SI__)));
# endif
# define lzo_int32e_t lzo_int32e_si_t__
# define lzo_uint32e_t lzo_uint32e_si_t__
@ -2913,7 +2913,7 @@ LZO_COMPILE_TIME_ASSERT_HEADER(LZO_SIZEOF_PTRDIFF_T == sizeof(ptrdiff_t))
# define LZO_TYPEOF_LZO_INT32E_T LZO_TYPEOF___MODE_SI
#elif (LZO_SIZEOF___INT32 == 4)
# define lzo_int32e_t __int32
# define lzo_uint32e_t quint32
# define lzo_uint32e_t unsigned __int32
# define LZO_TYPEOF_LZO_INT32E_T LZO_TYPEOF___INT32
#else
#endif
@ -2937,7 +2937,7 @@ LZO_COMPILE_TIME_ASSERT_HEADER(LZO_SIZEOF_PTRDIFF_T == sizeof(ptrdiff_t))
#endif
#if (LZO_SIZEOF_INT == 8) && (LZO_SIZEOF_INT < LZO_SIZEOF_LONG)
# define lzo_int64e_t int
# define lzo_uint64e_t quint32
# define lzo_uint64e_t unsigned int
# define LZO_TYPEOF_LZO_INT64E_T LZO_TYPEOF_INT
#elif (LZO_SIZEOF_LONG == 8) && !(LZO_CFG_PREFER_TYPEOF_ACC_INT64E_T == LZO_TYPEOF_LONG_LONG) && !(LZO_CFG_PREFER_TYPEOF_ACC_INT64E_T == LZO_TYPEOF___INT64)
# define lzo_int64e_t long int
@ -2984,7 +2984,7 @@ LZO_COMPILE_TIME_ASSERT_HEADER(LZO_SIZEOF_PTRDIFF_T == sizeof(ptrdiff_t))
# define LZO_TYPEOF_LZO_INT32L_T LZO_TYPEOF_LZO_INT32E_T
#elif (LZO_SIZEOF_INT >= 4) && (LZO_SIZEOF_INT < LZO_SIZEOF_LONG)
# define lzo_int32l_t int
# define lzo_uint32l_t quint32
# define lzo_uint32l_t unsigned int
# define LZO_SIZEOF_LZO_INT32L_T LZO_SIZEOF_INT
# define LZO_TYPEOF_LZO_INT32L_T LZO_SIZEOF_INT
#elif (LZO_SIZEOF_LONG >= 4)
@ -3057,7 +3057,7 @@ LZO_COMPILE_TIME_ASSERT_HEADER(LZO_SIZEOF_PTRDIFF_T == sizeof(ptrdiff_t))
#elif (LZO_CC_MSC && (_MSC_VER >= 1300) && (LZO_SIZEOF_VOID_P == 4) && (LZO_SIZEOF_INT == 4))
# if !(LZO_LANG_ASSEMBLER)
typedef __w64 int lzo_intptr_t;
typedef __w64 quint32 lzo_uintptr_t;
typedef __w64 unsigned int lzo_uintptr_t;
# endif
# define lzo_intptr_t lzo_intptr_t
# define lzo_uintptr_t lzo_uintptr_t
@ -3070,7 +3070,7 @@ LZO_COMPILE_TIME_ASSERT_HEADER(LZO_SIZEOF_PTRDIFF_T == sizeof(ptrdiff_t))
# define LZO_TYPEOF_LZO_INTPTR_T LZO_TYPEOF_SHORT
#elif (LZO_SIZEOF_INT >= LZO_SIZEOF_VOID_P) && (LZO_SIZEOF_INT < LZO_SIZEOF_LONG)
# define lzo_intptr_t int
# define lzo_uintptr_t quint32
# define lzo_uintptr_t unsigned int
# define LZO_SIZEOF_LZO_INTPTR_T LZO_SIZEOF_INT
# define LZO_TYPEOF_LZO_INTPTR_T LZO_TYPEOF_INT
#elif (LZO_SIZEOF_LONG >= LZO_SIZEOF_VOID_P)
@ -3104,7 +3104,7 @@ LZO_COMPILE_TIME_ASSERT_HEADER(LZO_SIZEOF_PTRDIFF_T == sizeof(ptrdiff_t))
# define LZO_SIZEOF_LZO_WORD_T LZO_SIZEOF_LONG
# define LZO_TYPEOF_LZO_WORD_T LZO_TYPEOF_LONG
#elif (LZO_WORDSIZE == LZO_SIZEOF_INT)
# define lzo_word_t quint32
# define lzo_word_t unsigned int
# define lzo_sword_t int
# define LZO_SIZEOF_LZO_WORD_T LZO_SIZEOF_INT
# define LZO_TYPEOF_LZO_WORD_T LZO_TYPEOF_INT

6
libs/compression/minilzo.c
View File

@ -25,6 +25,12 @@
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)

7
libs/compression/minilzo.h
View File

@ -25,6 +25,13 @@
http://www.oberhumer.com/opensource/lzo/
*/
/*
* NOTE:
* the full LZO package can be found at
* http://www.oberhumer.com/opensource/lzo/
*/
#ifndef __MINILZO_H_INCLUDED
#define __MINILZO_H_INCLUDED 1

26
libs/core/core.pro
View File

@ -2,15 +2,23 @@ QT += core widgets
TEMPLATE = lib
CONFIG += staticlib c++17
SOURCES += $$files($$PWD/*.cpp, true) \
xdatastream.cpp
HEADERS += $$files($$PWD/*.h, true) \
xdatastream.h
SOURCES += \
highlighter_cfg.cpp \
highlighter_shock.cpp \
highlighter_rumble.cpp \
highlighter_gsc.cpp \
logmanager.cpp \
statusbarmanager.cpp
LIBS += -L$$OUT_PWD/../libs/xassets -lxassets
INCLUDEPATH += $$PWD/../xassets
DEPENDPATH += $$PWD/../xassets
HEADERS += \
enums.h \
highlighter_cfg.h \
highlighter_shock.h \
highlighter_rumble.h \
highlighter_gsc.h \
logmanager.h \
stringutils.h \
utils.h \
statusbarmanager.h
DESTDIR = $$OUT_PWD/../

76
libs/core/enums.h
View File

@ -3,10 +3,32 @@
#include <QString>
enum FF_PLATFORM {
FF_PLATFORM_NONE = 0x00, // No platform
FF_PLATFORM_XBOX = 0x01, // Xbox 360
FF_PLATFORM_PS3 = 0x02, // Playstation 3
FF_PLATFORM_PC = 0x03, // PC
FF_PLATFORM_WII = 0x04, // WII
FF_PLATFORM_WIIU = 0x05 // WII U
};
enum FF_GAME {
FF_GAME_NONE = 0x00, // No game
FF_GAME_COD1 = 0x01, // Call of Duty
FF_GAME_COD2 = 0x02, // Call of Duty 2
FF_GAME_COD3 = 0x03, // Call of Duty 3
FF_GAME_COD4 = 0x04, // Modern Warware 1
FF_GAME_COD5 = 0x05, // World at War
FF_GAME_COD6 = 0x06, // Modern Warfare 2
FF_GAME_COD7 = 0x07, // Black Ops 1
FF_GAME_COD8 = 0x08, // Modern Warfare 3
FF_GAME_COD9 = 0x09, // Black Ops 2
};
enum IWI_VERSION {
IWI_VERSION_COD2 = 0x05, // 05 CoD2
IWI_VERSION_COD4 = 0x06, // 06 CoD4
IWI_VERSION_COD5 = 0x06, // 06 CoD5
IWI_VERSION_COD2 = 0x05, // 05 CoD2
IWI_VERSION_COD4 = 0x06, // 06 CoD4
IWI_VERSION_COD5 = 0x06, // 06 CoD5
IWI_VERSION_CODMW2 = 0x08, // 08 CoDMW2
IWI_VERSION_CODMW3 = 0x08, // 08 CoDMW3
IWI_VERSION_CODBO1 = 0x0D, // 13 CoDBO1
@ -16,37 +38,37 @@ enum IWI_VERSION {
enum IWI_FORMAT {
// IWI Format
IWI_FORMAT_ARGB32 = 0x01, // 01 ARGB32
IWI_FORMAT_RGB24 = 0x02, // 02 RGB24
IWI_FORMAT_GA16 = 0x03, // 03 GA16
IWI_FORMAT_A8 = 0x04, // 04 A8
IWI_FORMAT_DXT1 = 0x0B, // 11 DXT1
IWI_FORMAT_DXT3 = 0x0C, // 12 DXT3
IWI_FORMAT_DXT5 = 0x0D // 13 DXT5
IWI_FORMAT_RGB24 = 0x02, // 02 RGB24
IWI_FORMAT_GA16 = 0x03, // 03 GA16
IWI_FORMAT_A8 = 0x04, // 04 A8
IWI_FORMAT_DXT1 = 0x0B, // 11 DXT1
IWI_FORMAT_DXT3 = 0x0C, // 12 DXT3
IWI_FORMAT_DXT5 = 0x0D // 13 DXT5
};
enum DDS_FLAGS {
DDSD_CAPS = 0x1,
DDSD_HEIGHT = 0x2,
DDSD_WIDTH = 0x4,
DDSD_PITCH = 0x8,
DDSD_CAPS = 0x1,
DDSD_HEIGHT = 0x2,
DDSD_WIDTH = 0x4,
DDSD_PITCH = 0x8,
DDSD_PIXELFORMAT = 0x1000,
DDSD_MIPMAPCOUNT = 0x20000,
DDSD_LINEARSIZE = 0x80000,
DDSD_DEPTH = 0x800000
DDSD_LINEARSIZE = 0x80000,
DDSD_DEPTH = 0x800000
};
enum DDS_PIXELFORMAT_FLAGS {
DDPF_ALPHAPIXELS = 0x1,
DDPF_ALPHA = 0x2,
DDPF_FOURCC = 0x4,
DDPF_RGB = 0x40,
DDPF_YUV = 0x200,
DDPF_LUMINANCE = 0x20000
DDPF_ALPHA = 0x2,
DDPF_FOURCC = 0x4,
DDPF_RGB = 0x40,
DDPF_YUV = 0x200,
DDPF_LUMINANCE = 0x20000
};
enum DDS_CAPS_FLAGS {
DDSCAPS_COMPLEX = 0x8,
DDSCAPS_MIPMAP = 0x400000,
DDSCAPS_MIPMAP = 0x400000,
DDSCAPS_TEXTURE = 0x1000
};
@ -189,15 +211,15 @@ enum MENU_ITEM_TYPE {
ITEM_TYPE_RADIOBUTTON = 2, // toggle button, may be grouped
ITEM_TYPE_CHECKBOX = 3, // check box
ITEM_TYPE_EDITFIELD = 4, // editable text, associated with a dvar
ITEM_TYPE_COMBO = 5, // drop down list
ITEM_TYPE_COMBO = 5, // drop down list
ITEM_TYPE_LISTBOX = 6, // scrollable list
ITEM_TYPE_MODEL = 7, // model
ITEM_TYPE_MODEL = 7, // model
ITEM_TYPE_OWNERDRAW = 8, // owner draw, name specs what it is
ITEM_TYPE_NUMERICFIELD = 9, // editable text, associated with a dvar
ITEM_TYPE_SLIDER = 10, // mouse speed, volume, etc.
ITEM_TYPE_YESNO = 11, // yes no dvar setting
ITEM_TYPE_MULTI = 12, // multiple list setting, enumerated
ITEM_TYPE_DVARENUM = 13, // multiple list setting, enumerated from a dvar
ITEM_TYPE_YESNO = 11, // yes no dvar setting
ITEM_TYPE_MULTI = 12, // multiple list setting, enumerated
ITEM_TYPE_DVARENUM = 13, // multiple list setting, enumerated from a dvar
ITEM_TYPE_BIND = 14, // bind
ITEM_TYPE_MENUMODEL = 15, // special menu model
ITEM_TYPE_VALIDFILEFIELD = 16, // text must be valid for use in a dos filename
@ -410,7 +432,7 @@ enum MENU_FONT_TYPE{
UI_FONT_DEFAULT = 0, // auto-chose betwen big/reg/small
UI_FONT_NORMAL = 1,
UI_FONT_BIG = 2,
UI_GameFontMALL = 3,
UI_FONT_SMALL = 3,
UI_FONT_BOLD = 4,
UI_FONT_CONSOLE = 5,
UI_FONT_OBJECTIVE = 6,

69
libs/core/utils.h
View File

@ -2,19 +2,15 @@
#define UTILS_H
#include "enums.h"
#include "QtZlib/zlib.h"
#include "qdir.h"
#include "qicon.h"
#include "xasset.h"
#include "xassettype.h"
#include <QMetaEnum>
#include <QString>
#include <QtZlib/zlib.h>
#include <QFileDialog>
#include <QMessageBox>
#include <QPainter>
#include <QCryptographicHash>
class Utils : public QObject {
Q_OBJECT
class Utils {
public:
static bool ExportData(const QString aFileName, const QByteArray aData) {
QDir workingDir = QDir::currentPath();
@ -34,29 +30,6 @@ public:
b = (b & 0xAA) >> 1 | (b & 0x55) << 1;
return b;
}
static QIcon CreateAssetIcon(XAssetType aAssetType, QColor color = QColor()) {
const QString assetTypeStr = XAsset::XAssetTypeToString(aAssetType);
QString assetAbbr;
for (int i = 0; i < assetTypeStr.length(); i++)
{
if (assetTypeStr[i].isUpper())
{
assetAbbr += assetTypeStr[i];
}
}
return CreateAssetIcon(assetAbbr, color);
// QString name;
// const QStringList parts = assetTypeStr.split('_').mid(1);
// foreach (const QString part, parts) {
// name += part[0];
// }
// if (parts.size() == 1) {
// name += parts.first()[1];
// }
// return CreateAssetIcon(name, color);
}
static QIcon CreateAssetIcon(const QString& name, QColor color = QColor()) {
constexpr int iconSize = 32;
constexpr int padding = 4;
@ -223,7 +196,7 @@ public:
return color;
}
static bool ReadUntilString(XDataStream* stream, const QString& targetString) {
static bool ReadUntilString(QDataStream* stream, const QString& targetString) {
if (!stream || targetString.isEmpty()) {
return false; // Invalid input
}
@ -257,7 +230,7 @@ public:
return false;
}
static bool ReadUntilHex(XDataStream* stream, const QString& hexString) {
static bool ReadUntilHex(QDataStream* stream, const QString& hexString) {
if (!stream || hexString.isEmpty() || hexString.size() % 2 != 0) {
return false; // Invalid input
}
@ -407,6 +380,34 @@ public:
return PadInt4(size) - size;
}
static QString GetOpenFastFileName(QWidget *parent = nullptr) {
// Open file dialog to steam apps
const QString steamPath = "C:/Program Files (x86)/Steam/steamapps/common/Call of Duty World at War/zone/english/";
const QString fastFilePath = QFileDialog::getOpenFileName(parent, "Open Fast File", steamPath, "Fast File (*.ff);;All Files (*.*)");
if (fastFilePath.isNull()) {
// User pressed cancel
return "";
} else if (!QFile::exists(fastFilePath)) {
QMessageBox::warning(parent, "Warning!", QString("%1 does not exist!.").arg(fastFilePath));
return "";
}
return fastFilePath;
}
static QString GetOpenZoneFileName(QWidget *parent = nullptr) {
// Open file dialog to steam apps
const QString steamPath = "C:/Program Files (x86)/Steam/steamapps/common/Call of Duty World at War/zone/english/";
const QString zoneFilePath = QFileDialog::getOpenFileName(parent, "Open Zone File", steamPath, "Zone File (*.zone);;All Files (*.*)");
if (zoneFilePath.isNull()) {
// User pressed cancel
return "";
} else if (!QFile::exists(zoneFilePath)) {
QMessageBox::warning(parent, "Warning!", QString("%1 does not exist!.").arg(zoneFilePath));
return nullptr;
}
return zoneFilePath;
}
static QString CompanyEnumToStr(FF_COMPANY aCompany) {
switch (aCompany) {
case COMPANY_NONE:

243
libs/core/xdatastream.cpp
View File

@ -1,243 +0,0 @@
#include "xdatastream.h"
#include <QIODevice>
#include <QDebug>
XDataStream::XDataStream(QIODevice *aDevice)
: QDataStream(aDevice)
, mDebug(false)
{
}
XDataStream::XDataStream()
: QDataStream()
, mDebug(false)
{
}
XDataStream::XDataStream(const QByteArray &aData)
: QDataStream(aData)
, mDebug(false)
{
}
XDataStream::XDataStream(QByteArray *aData, OpenMode aFlags)
: QDataStream(aData, aFlags)
, mDebug(false)
{
}
XDataStream::~XDataStream()
{
}
void XDataStream::SetDebug(bool aDebug)
{
mDebug = aDebug;
}
qint8 XDataStream::ParseInt8(const QString& aDebugString)
{
qint64 start = this->device()->pos();
qint8 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;
}
quint8 XDataStream::ParseUInt8(const QString& aDebugString)
{
qint64 start = this->device()->pos();
quint8 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;
}
qint16 XDataStream::ParseInt16(const QString& aDebugString)
{
qint64 start = this->device()->pos();
qint16 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;
}
quint16 XDataStream::ParseUInt16(const QString& aDebugString)
{
qint64 start = this->device()->pos();
quint16 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;
}
qint32 XDataStream::ParseInt32(const QString& aDebugString)
{
qint64 start = this->device()->pos();
qint32 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;
}
quint32 XDataStream::ParseUInt32(const QString& aDebugString)
{
qint64 start = this->device()->pos();
quint32 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;
}
qint64 XDataStream::ParseInt64(const QString& aDebugString)
{
qint64 start = this->device()->pos();
qint64 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;
}
quint64 XDataStream::ParseUInt64(const QString& aDebugString)
{
qint64 start = this->device()->pos();
quint64 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;
}
float XDataStream::ParseSingle(const QString& aDebugString)
{
qint64 start = this->device()->pos();
float val;
quint32 rawVal;
*this >> rawVal;
memcpy(&val, &rawVal, sizeof(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;
}
double XDataStream::ParseDouble(const QString& aDebugString)
{
qint64 start = this->device()->pos();
float 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;
}
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;
}

34
libs/core/xdatastream.h
View File

@ -1,34 +0,0 @@
#ifndef XDATASTREAM_H
#define XDATASTREAM_H
#include <QDataStream>
#include <QString>
class XDataStream : public QDataStream
{
public:
explicit XDataStream(QIODevice* aDevice);
XDataStream();
XDataStream(const QByteArray& aData);
XDataStream(QByteArray* aData, OpenMode aFlags);
~XDataStream();
void SetDebug(bool aDebug = true);
qint8 ParseInt8(const QString& aDebugString = "");
quint8 ParseUInt8(const QString& aDebugString = "");
qint16 ParseInt16(const QString& aDebugString = "");
quint16 ParseUInt16(const QString& aDebugString = "");
qint32 ParseInt32(const QString& aDebugString = "");
quint32 ParseUInt32(const QString& aDebugString = "");
qint64 ParseInt64(const QString& aDebugString = "");
quint64 ParseUInt64(const QString& aDebugString = "");
float ParseSingle(const QString& aDebugString = "");
double ParseDouble(const QString& aDebugString = "");
bool ParseBool(const QString& aDebugString = "");
private:
bool mDebug;
};
#endif // XDATASTREAM_H

152
libs/ddsfile/ddsfile.cpp
View File

@ -35,7 +35,7 @@ DDSPixelFormat DDSFile::CalculatePixelFormat(quint8 aIWIFormat) {
return ddsPixelFormat;
}
void DDSFile::SetupExportDirs() const {
void DDSFile::SetupExportDirs() {
QDir dir = QDir::currentPath();
if (!dir.exists("exports/")) {
dir.mkdir("exports/");
@ -89,92 +89,92 @@ DDSFile::DDSFile(const QString &aFilePath)
}
DDSFile::DDSFile(const QByteArray aDDSData, const QString aFileStem) {
// QDataStream ddsIn(aDDSData);
// ddsIn.setByteOrder(QDataStream::LittleEndian);
QDataStream ddsIn(aDDSData);
ddsIn.setByteOrder(QDataStream::LittleEndian);
// DDSHeader ddsHeader;
// if (ddsIn.readRawData(reinterpret_cast<char*>(&ddsHeader), sizeof(DDSHeader)) != sizeof(DDSHeader)) {
// qDebug() << "Error: Failed to read DDSHeader from QByteArray!";
// return;
// }
DDSHeader ddsHeader;
if (ddsIn.readRawData(reinterpret_cast<char*>(&ddsHeader), sizeof(DDSHeader)) != sizeof(DDSHeader)) {
qDebug() << "Error: Failed to read DDSHeader from QByteArray!";
return;
}
// fileStem = aFileStem;
// header = ddsHeader;
fileStem = aFileStem;
header = ddsHeader;
// // Ensure DevIL is initialized once globally
// static bool devilInitialized = false;
// if (!devilInitialized) {
// ilInit();
// devilInitialized = true;
// }
// Ensure DevIL is initialized once globally
static bool devilInitialized = false;
if (!devilInitialized) {
ilInit();
devilInitialized = true;
}
// // Generate and bind an image
// ILuint imageID;
// ilGenImages(1, &imageID);
// ilBindImage(imageID);
// Generate and bind an image
ILuint imageID;
ilGenImages(1, &imageID);
ilBindImage(imageID);
// ilEnable(IL_ORIGIN_SET);
// ilOriginFunc(IL_ORIGIN_UPPER_LEFT);
ilEnable(IL_ORIGIN_SET);
ilOriginFunc(IL_ORIGIN_UPPER_LEFT);
// // Load DDS file
// if (!ilLoadL(IL_DDS, aDDSData.constData(), aDDSData.size())) {
// ILuint devilError = ilGetError();
// qDebug() << "DevIL Error while loading DDS: " << devilError;
// ilDeleteImages(1, &imageID);
// return;
// }
// Load DDS file
if (!ilLoadL(IL_DDS, aDDSData.constData(), aDDSData.size())) {
ILuint devilError = ilGetError();
qDebug() << "DevIL Error while loading DDS: " << devilError;
ilDeleteImages(1, &imageID);
return;
}
// // Get mipmap count
// ILint numMipmaps = ilGetInteger(IL_NUM_MIPMAPS);
// qDebug() << "Number of mipmaps: " << numMipmaps;
// Get mipmap count
ILint numMipmaps = ilGetInteger(IL_NUM_MIPMAPS);
qDebug() << "Number of mipmaps: " << numMipmaps;
// // Loop over all mipmap levels (0 is the base image)
// for (ILint level = 0; level <= numMipmaps; ++level) {
// ilBindImage(imageID);
// if (!ilActiveMipmap(level)) {
// qDebug() << "DevIL failed to activate mipmap level" << level;
// continue;
// }
// Loop over all mipmap levels (0 is the base image)
for (ILint level = 0; level <= numMipmaps; ++level) {
ilBindImage(imageID);
if (!ilActiveMipmap(level)) {
qDebug() << "DevIL failed to activate mipmap level" << level;
continue;
}
// // Get mipmap properties
// int width = ilGetInteger(IL_IMAGE_WIDTH);
// int height = ilGetInteger(IL_IMAGE_HEIGHT);
// int depth = ilGetInteger(IL_IMAGE_DEPTH);
// int format = ilGetInteger(IL_IMAGE_FORMAT);
// int bpp = 0;
// Get mipmap properties
int width = ilGetInteger(IL_IMAGE_WIDTH);
int height = ilGetInteger(IL_IMAGE_HEIGHT);
int depth = ilGetInteger(IL_IMAGE_DEPTH);
int format = ilGetInteger(IL_IMAGE_FORMAT);
int bpp = 0;
// switch (format) {
// case IL_RGB:
// bpp = 3;
// break;
// case IL_RGBA:
// bpp = 4;
// break;
// default:
// qDebug() << "Unsupported image format.";
// continue;
// }
switch (format) {
case IL_RGB:
bpp = 3;
break;
case IL_RGBA:
bpp = 4;
break;
default:
qDebug() << "Unsupported image format.";
continue;
}
// int dataSize = width * height * depth * bpp;
int dataSize = width * height * depth * bpp;
// ILubyte *data = ilGetData();
// if (!data) {
// qDebug() << "Error: DevIL returned null data for mipmap level" << level;
// continue;
// }
ILubyte *data = ilGetData();
if (!data) {
qDebug() << "Error: DevIL returned null data for mipmap level" << level;
continue;
}
// // Create a mipmap structure
// DDSMipmap mipmap;
// mipmap.width = width;
// mipmap.height = height;
// mipmap.data = QByteArray(reinterpret_cast<const char*>(data), dataSize);
// mipmap.size = dataSize;
// Create a mipmap structure
DDSMipmap mipmap;
mipmap.width = width;
mipmap.height = height;
mipmap.data = QByteArray(reinterpret_cast<const char*>(data), dataSize);
mipmap.size = dataSize;
// // Store in DDS file
// mipmaps.append(mipmap);
// }
// Store in DDS file
mipmaps.append(mipmap);
}
// ilDeleteImages(1, &imageID);
ilDeleteImages(1, &imageID);
}
DDSFile::DDSFile(const DDSFile &ddsFile) :
@ -248,7 +248,7 @@ DDSFile &DDSFile::operator=(const DDSFile &other) {
}
// Write a DDS file from a DDSFile object
bool DDSFile::SaveDDS() const {
bool DDSFile::SaveDDS() {
SetupExportDirs();
QFile file("exports/dds/" + fileStem + ".dds");
@ -268,7 +268,7 @@ bool DDSFile::SaveDDS() const {
return true;
}
bool DDSFile::SaveIWI() const {
bool DDSFile::SaveIWI() {
SetupExportDirs();
IWIFile iwiFile(*this);
@ -279,7 +279,7 @@ bool DDSFile::SaveIWI() const {
return true;
}
bool DDSFile::SavePNG() const {
bool DDSFile::SavePNG() {
SetupExportDirs();
int mipmapIndex = 1;
@ -311,7 +311,7 @@ bool DDSFile::SavePNG() const {
return true;
}
bool DDSFile::SaveJPG() const {
bool DDSFile::SaveJPG() {
SetupExportDirs();
int mipmapIndex = 1;

12
libs/ddsfile/ddsfile.h
View File

@ -9,7 +9,7 @@
#include <QVector>
#include <QDebug>
#include <QImage>
//#include <IL/il.h>
#include <IL/il.h>
struct DDSPixelFormat {
quint32 size;
@ -68,12 +68,12 @@ public:
DDSFile(const DDSFile &ddsFile);
DDSFile& operator=(const DDSFile& other);
bool SaveDDS() const;
bool SaveIWI() const;
bool SavePNG() const;
bool SaveJPG() const;
bool SaveDDS();
bool SaveIWI();
bool SavePNG();
bool SaveJPG();
void SetupExportDirs() const;
void SetupExportDirs();
static DDSPixelFormat CalculatePixelFormat(quint8 aIWIFormat);
private:

19
libs/ddsfile/ddsfile.pro
View File

@ -2,21 +2,26 @@ QT += core
TEMPLATE = lib
CONFIG += staticlib c++17
SOURCES += $$files($$PWD/*.cpp, true)
HEADERS += $$files($$PWD/*.h, true)
SOURCES += \
ddsfile.cpp
HEADERS += \
dds_structs.h \
ddsfile.h \
enums.h
LIBS += \
#-L$$PWD/../../third_party/devil_sdk/lib/ -lDevIL \
#-L$$PWD/../../third_party/devil_sdk/lib/ -lILU \
#-L$$PWD/../../third_party/devil_sdk/lib/ -lILUT \
-L$$PWD/../../third_party/devil_sdk/lib/ -lDevIL \
-L$$PWD/../../third_party/devil_sdk/lib/ -lILU \
-L$$PWD/../../third_party/devil_sdk/lib/ -lILUT \
-L$$OUT_PWD/../libs/iwifile -liwifile
INCLUDEPATH += \
$$PWD/../iwifile/ \
#$$PWD/../../third_party/devil_sdk/include/
$$PWD/../../third_party/devil_sdk/include/
DEPENDPATH += \
$$PWD/../iwifile/ \
#$$PWD/../../third_party/devil_sdk/include/
$$PWD/../../third_party/devil_sdk/include/
DESTDIR = $$OUT_PWD/../

54
libs/ddsfile/enums.h
View File

@ -24,9 +24,9 @@ enum FF_GAME {
};
enum IWI_VERSION {
IWI_VERSION_COD2 = 0x05, // 05 CoD2
IWI_VERSION_COD4 = 0x06, // 06 CoD4
IWI_VERSION_COD5 = 0x06, // 06 CoD5
IWI_VERSION_COD2 = 0x05, // 05 CoD2
IWI_VERSION_COD4 = 0x06, // 06 CoD4
IWI_VERSION_COD5 = 0x06, // 06 CoD5
IWI_VERSION_CODMW2 = 0x08, // 08 CoDMW2
IWI_VERSION_CODMW3 = 0x08, // 08 CoDMW3
IWI_VERSION_CODBO1 = 0x0D, // 13 CoDBO1
@ -36,37 +36,37 @@ enum IWI_VERSION {
enum IWI_FORMAT {
// IWI Format
IWI_FORMAT_ARGB32 = 0x01, // 01 ARGB32
IWI_FORMAT_RGB24 = 0x02, // 02 RGB24
IWI_FORMAT_GA16 = 0x03, // 03 GA16
IWI_FORMAT_A8 = 0x04, // 04 A8
IWI_FORMAT_DXT1 = 0x0B, // 11 DXT1
IWI_FORMAT_DXT3 = 0x0C, // 12 DXT3
IWI_FORMAT_DXT5 = 0x0D // 13 DXT5
IWI_FORMAT_RGB24 = 0x02, // 02 RGB24
IWI_FORMAT_GA16 = 0x03, // 03 GA16
IWI_FORMAT_A8 = 0x04, // 04 A8
IWI_FORMAT_DXT1 = 0x0B, // 11 DXT1
IWI_FORMAT_DXT3 = 0x0C, // 12 DXT3
IWI_FORMAT_DXT5 = 0x0D // 13 DXT5
};
enum DDS_FLAGS {
DDSD_CAPS = 0x1,
DDSD_HEIGHT = 0x2,
DDSD_WIDTH = 0x4,
DDSD_PITCH = 0x8,
DDSD_CAPS = 0x1,
DDSD_HEIGHT = 0x2,
DDSD_WIDTH = 0x4,
DDSD_PITCH = 0x8,
DDSD_PIXELFORMAT = 0x1000,
DDSD_MIPMAPCOUNT = 0x20000,
DDSD_LINEARSIZE = 0x80000,
DDSD_DEPTH = 0x800000
DDSD_LINEARSIZE = 0x80000,
DDSD_DEPTH = 0x800000
};
enum DDS_PIXELFORMAT_FLAGS {
DDPF_ALPHAPIXELS = 0x1,
DDPF_ALPHA = 0x2,
DDPF_FOURCC = 0x4,
DDPF_RGB = 0x40,
DDPF_YUV = 0x200,
DDPF_LUMINANCE = 0x20000
DDPF_ALPHA = 0x2,
DDPF_FOURCC = 0x4,
DDPF_RGB = 0x40,
DDPF_YUV = 0x200,
DDPF_LUMINANCE = 0x20000
};
enum DDS_CAPS_FLAGS {
DDSCAPS_COMPLEX = 0x8,
DDSCAPS_MIPMAP = 0x400000,
DDSCAPS_MIPMAP = 0x400000,
DDSCAPS_TEXTURE = 0x1000
};
@ -209,15 +209,15 @@ enum MENU_ITEM_TYPE {
ITEM_TYPE_RADIOBUTTON = 2, // toggle button, may be grouped
ITEM_TYPE_CHECKBOX = 3, // check box
ITEM_TYPE_EDITFIELD = 4, // editable text, associated with a dvar
ITEM_TYPE_COMBO = 5, // drop down list
ITEM_TYPE_COMBO = 5, // drop down list
ITEM_TYPE_LISTBOX = 6, // scrollable list
ITEM_TYPE_MODEL = 7, // model
ITEM_TYPE_MODEL = 7, // model
ITEM_TYPE_OWNERDRAW = 8, // owner draw, name specs what it is
ITEM_TYPE_NUMERICFIELD = 9, // editable text, associated with a dvar
ITEM_TYPE_SLIDER = 10, // mouse speed, volume, etc.
ITEM_TYPE_YESNO = 11, // yes no dvar setting
ITEM_TYPE_MULTI = 12, // multiple list setting, enumerated
ITEM_TYPE_DVARENUM = 13, // multiple list setting, enumerated from a dvar
ITEM_TYPE_YESNO = 11, // yes no dvar setting
ITEM_TYPE_MULTI = 12, // multiple list setting, enumerated
ITEM_TYPE_DVARENUM = 13, // multiple list setting, enumerated from a dvar
ITEM_TYPE_BIND = 14, // bind
ITEM_TYPE_MENUMODEL = 15, // special menu model
ITEM_TYPE_VALIDFILEFIELD = 16, // text must be valid for use in a dos filename
@ -430,7 +430,7 @@ enum MENU_FONT_TYPE{
UI_FONT_DEFAULT = 0, // auto-chose betwen big/reg/small
UI_FONT_NORMAL = 1,
UI_FONT_BIG = 2,
UI_GameFontMALL = 3,
UI_FONT_SMALL = 3,
UI_FONT_BOLD = 4,
UI_FONT_CONSOLE = 5,
UI_FONT_OBJECTIVE = 6,

18
libs/encryption/ecrypt-portable.h
View File

@ -1,5 +1,15 @@
/* ecrypt-portable.h */
/*
* WARNING: the conversions defined below are implemented as macros,
* and should be used carefully. They should NOT be used with
* parameters which perform some action. E.g., the following two lines
* are not equivalent:
*
* 1) ++x; y = ROTL32(x, n);
* 2) y = ROTL32(++x, n);
*/
/*
* *** Please do not edit this file. ***
*
@ -17,10 +27,10 @@
/*
* The following types are defined (if available):
*
* u8: quint32eger type, at least 8 bits
* u16: quint32eger type, at least 16 bits
* u32: quint32eger type, at least 32 bits
* u64: quint32eger type, at least 64 bits
* u8: unsigned integer type, at least 8 bits
* u16: unsigned integer type, at least 16 bits
* u32: unsigned integer type, at least 32 bits
* u64: unsigned integer type, at least 64 bits
*
* s8, s16, s32, s64 -> signed counterparts of u8, u16, u32, u64
*

200
libs/encryption/encryption.cpp
View File

@ -1,35 +1,27 @@
#include <QtCore>
#include "encryption.h"
#include "QtZlib/zlib.h"
#include "ecrypt-sync.h"
#include "sha1.h"
#include "encryption.h"
#include "compression.h"
static QVector<quint32> ivCounter(4, 1); // start all counters at 1
void Encryption::Convert32BitTo8Bit(quint32 value, quint8 *array)
{
void Encryption::Convert32BitTo8Bit(quint32 value, quint8 *array) {
array[0] = static_cast<quint8>(value >> 0);
array[1] = static_cast<quint8>(value >> 8);
array[2] = static_cast<quint8>(value >> 16);
array[3] = static_cast<quint8>(value >> 24);
}
quint32 Encryption::ConvertArrayTo32Bit(const QByteArray &array)
{
quint32 Encryption::ConvertArrayTo32Bit(const QByteArray &array) {
return ((static_cast<quint32>(static_cast<uchar>(array[0])) << 0) |
(static_cast<quint32>(static_cast<uchar>(array[1])) << 8) |
(static_cast<quint32>(static_cast<uchar>(array[2])) << 16) |
(static_cast<quint32>(static_cast<uchar>(array[3])) << 24));
}
quint32 Encryption::Rotate(quint32 value, quint32 numBits)
{
quint32 Encryption::Rotate(quint32 value, quint32 numBits) {
return (value << numBits) | (value >> (32 - numBits));
}
QByteArray Encryption::InitIVTable(const QByteArray &feed)
{
QByteArray Encryption::InitIVTable(const QByteArray &feed) {
const int tableSize = 0xFB0;
QByteArray table;
table.resize(tableSize);
@ -39,7 +31,7 @@ QByteArray Encryption::InitIVTable(const QByteArray &feed)
if (static_cast<uchar>(feed.at(ptr)) == 0x00)
ptr = 0;
int base = i * 20 + x * 4;
table[base] = feed.at(ptr);
table[base] = feed.at(ptr);
table[base + 1] = feed.at(ptr);
table[base + 2] = feed.at(ptr);
table[base + 3] = feed.at(ptr);
@ -56,23 +48,22 @@ QByteArray Encryption::InitIVTable(const QByteArray &feed)
return table;
}
int Encryption::unk(quint64 arg1, quint8 arg2)
{
int Encryption::unk(quint64 arg1, quint8 arg2) {
if (arg2 >= 0x40)
return 0;
return static_cast<int>(arg1 >> arg2);
}
QByteArray Encryption::GetIV(const QByteArray &table, int index)
{
int num1 = (4 * index % 4 + 0xFA0) + index % 4 + (index - (index % 4));
QByteArray Encryption::GetIV(const QByteArray &table, int index) {
int num1 = 0xFA0 + index;
int num2 = unk(0x51EB851FLL * num1, 0x20);
int startIndex = 20 * (num1 - 200 * ((num2 >> 6) + (num2 >> 31)));
int adjust = ((num2 >> 6) + (num2 >> 31));
int startIndex = 20 * (num1 - 200 * adjust);
// Return 8 bytes from that location.
return table.mid(startIndex, 8);
}
void Encryption::UpdateIVTable(QByteArray &table, int index, const QByteArray &sectionHash)
{
void Encryption::UpdateIVTable(QByteArray &table, int index, const QByteArray &sectionHash) {
int blockNumIndex = index % 4;
int baseOffset = 0xFA0 + blockNumIndex * 4;
quint32 blockNumVal = (static_cast<uchar>(table.at(baseOffset)) ) |
@ -86,7 +77,7 @@ void Encryption::UpdateIVTable(QByteArray &table, int index, const QByteArray &s
int hashIndex = 0;
for (int x = 0; x < 4; ++x) {
table[startIndex - 1] = table.at(startIndex - 1) ^ sectionHash.at(hashIndex);
table[startIndex] = table.at(startIndex) ^ sectionHash.at(hashIndex + 1);
table[startIndex] = table.at(startIndex) ^ sectionHash.at(hashIndex + 1);
table[startIndex + 1] = table.at(startIndex + 1) ^ sectionHash.at(hashIndex + 2);
table[startIndex + 2] = table.at(startIndex + 2) ^ sectionHash.at(hashIndex + 3);
table[startIndex + 3] = table.at(startIndex + 3) ^ sectionHash.at(hashIndex + 4);
@ -95,9 +86,8 @@ void Encryption::UpdateIVTable(QByteArray &table, int index, const QByteArray &s
}
}
quint32 Encryption::ToUInt32(const QByteArray &data, int offset)
{
// Converts 4 bytes (starting at offset) from data into a 32-bit quint32eger (little-endian)
quint32 Encryption::ToUInt32(const QByteArray &data, int offset) {
// Converts 4 bytes (starting at offset) from data into a 32-bit unsigned integer (little-endian)
return ((static_cast<quint32>(static_cast<uchar>(data[offset])) ) |
(static_cast<quint32>(static_cast<uchar>(data[offset+1])) << 8 ) |
(static_cast<quint32>(static_cast<uchar>(data[offset+2])) << 16) |
@ -361,8 +351,96 @@ void Encryption::generateNewIV(int index, const QByteArray &hash, QByteArray &iv
ivCounter[index]++;
}
QByteArray Encryption::decryptFastFile_BO3(const QByteArray &fastFileData)
QByteArray Encryption::decryptFastFile_BO2(const QByteArray &fastFileData)
{
const QByteArray bo2_salsa20_key = QByteArray::fromHex("641D8A2FE31D3AA63622BBC9CE8587229D42B0F8ED9B924130BF88B65EDC50BE");
QByteArray fileData = fastFileData;
QByteArray finalFastFile;
QByteArray ivTable(16000, 0);
fillIVTable(fileData, ivTable, 16000 - 1);
QVector<quint32> ivCounter(4, 1);
QDataStream stream(fileData);
stream.setByteOrder(QDataStream::LittleEndian);
stream.skipRawData(0x138);
QByteArray sha1Hash(20, 0);
QByteArray ivPtr(8, 0);
int chunkIndex = 0;
while (!stream.atEnd()) {
quint32 dataLength;
stream >> dataLength;
if (dataLength == 0 || dataLength > fileData.size() - stream.device()->pos()) {
qWarning() << "Invalid data length at offset: " << stream.device()->pos();
break;
}
fillIV(chunkIndex % 4, ivPtr, ivTable, ivCounter);
ECRYPT_ctx x;
ECRYPT_keysetup(&x, reinterpret_cast<const u8*>(bo2_salsa20_key.constData()), 256, 0);
ECRYPT_ivsetup(&x, reinterpret_cast<const u8*>(ivPtr.constData()));
QByteArray encryptedBlock = fileData.mid(stream.device()->pos(), dataLength);
QByteArray decryptedBlock;
decryptedBlock.resize(dataLength);
ECRYPT_decrypt_bytes(&x, reinterpret_cast<const u8*>(encryptedBlock.constData()),
reinterpret_cast<u8*>(decryptedBlock.data()), dataLength);
QCryptographicHash sha1(QCryptographicHash::Sha1);
sha1.addData(decryptedBlock);
sha1Hash = sha1.result();
z_stream strm = {};
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;
strm.avail_in = static_cast<uInt>(decryptedBlock.size());
strm.next_in = reinterpret_cast<Bytef*>(decryptedBlock.data());
QByteArray decompressedData;
decompressedData.resize(fmax(dataLength * 2, 4096));
strm.avail_out = decompressedData.size();
strm.next_out = reinterpret_cast<Bytef*>(decompressedData.data());
int zReturn = inflateInit2(&strm, -15);
if (zReturn != Z_OK) {
qWarning() << "inflateInit2 failed with error code" << zReturn;
break;
}
zReturn = inflate(&strm, Z_FINISH);
inflateEnd(&strm);
if (zReturn != Z_STREAM_END) {
qDebug() << "Error decompressing at offset: " << stream.device()->pos() << " : " << zReturn;
decompressedData.clear();
} else {
decompressedData.resize(strm.total_out);
}
finalFastFile.append(decompressedData);
generateNewIV(chunkIndex % 4, sha1Hash, ivTable, ivCounter);
if (stream.device()->pos() + static_cast<qint64>(dataLength) > fileData.size()) {
qWarning() << "Skipping past file size!";
break;
}
stream.skipRawData(dataLength);
chunkIndex++;
}
return finalFastFile;
}
QByteArray Encryption::decryptFastFile_BO3(const QByteArray &fastFileData) {
const QByteArray salsaKey = QByteArray::fromHex("0E50F49F412317096038665622DD091332A209BA0A05A00E1377CEDB0A3CB1D3");
QByteArray ivTable(0xFB0, 0);
@ -426,71 +504,3 @@ QByteArray Encryption::decryptFastFile_BO3(const QByteArray &fastFileData)
return finalFastFile;
}
QByteArray Encryption::DecryptFile(const QByteArray &fastFileData, const QString &aFileName, const QByteArray &aKey)
{
Q_UNUSED(aFileName);
const QByteArray salsaKey = QByteArray::fromHex(aKey);
QByteArray ivTable(0xFB0, 0);
fillIVTable(fastFileData, ivTable, 0xFB0 - 1);
QVector<quint32> ivCounter(4, 1);
QDataStream stream(fastFileData);
stream.setByteOrder(QDataStream::LittleEndian);
QByteArray finalFastFile;
QByteArray sha1Hash(20, 0);
QByteArray ivPtr(8, 0);
int chunkIndex = 0;
while (!stream.atEnd()) {
if (stream.device()->bytesAvailable() < 4) {
qWarning() << "No sufficient data for chunk size at offset:" << stream.device()->pos();
break;
}
quint32 dataLength;
stream >> dataLength;
if (dataLength == 0 || dataLength > fastFileData.size() - stream.device()->pos()) {
qWarning() << "Invalid data length at offset:" << stream.device()->pos();
break;
}
fillIV(chunkIndex % 4, ivPtr, ivTable, ivCounter);
ECRYPT_ctx x;
ECRYPT_keysetup(&x, reinterpret_cast<const u8*>(salsaKey.constData()), 256, 0);
ECRYPT_ivsetup(&x, reinterpret_cast<const u8*>(ivPtr.constData()));
QByteArray encryptedBlock = fastFileData.mid(stream.device()->pos(), dataLength);
QByteArray decryptedBlock(dataLength, Qt::Uninitialized);
ECRYPT_decrypt_bytes(&x,
reinterpret_cast<const u8*>(encryptedBlock.constData()),
reinterpret_cast<u8*>(decryptedBlock.data()),
dataLength);
// SHA1 hash update
sha1Hash = QCryptographicHash::hash(decryptedBlock, QCryptographicHash::Sha1);
// Decompress (ZLIB raw DEFLATE)
QByteArray decompressedData = Compression::DecompressDeflate(decryptedBlock);
if (decompressedData.isEmpty()) {
qWarning() << "Failed decompression at chunk index:" << chunkIndex;
return QByteArray();
}
finalFastFile.append(decompressedData);
// Update IV table using SHA1
generateNewIV(chunkIndex % 4, sha1Hash, ivTable, ivCounter);
stream.skipRawData(dataLength);
chunkIndex++;
}
return finalFastFile;
}

3
libs/encryption/encryption.h
View File

@ -46,9 +46,8 @@ public:
static void generateNewIV(int index, const QByteArray& hash, QByteArray& ivTable, QVector<quint32>& ivCounter);
//static QByteArray decryptFastFile_BO2(const QByteArray& fastFileData);
static QByteArray decryptFastFile_BO2(const QByteArray& fastFileData);
static QByteArray decryptFastFile_BO3(const QByteArray& fastFileData);
static QByteArray DecryptFile(const QByteArray& fastFileData, const QString& aFileName, const QByteArray& aKey);
};
#endif // ENCRYPTION_H

16
libs/encryption/encryption.pro
View File

@ -2,8 +2,20 @@ QT += core
TEMPLATE = lib
CONFIG += staticlib c++17
SOURCES += $$files($$PWD/*.cpp, true)
HEADERS += $$files($$PWD/*.h, true)
SOURCES += \
salsa20.cpp \
sha1.cpp \
encryption.cpp
HEADERS += \
ecrypt-config.h \
ecrypt-machine.h \
ecrypt-portable.h \
ecrypt-sync.h \
encryption.h \
os_types.h \
config_win32.h \
sha1.h
app.depends += \
compression

7
libs/encryption/salsa20.cpp
View File

@ -59,7 +59,7 @@ void ECRYPT_encrypt_bytes(ECRYPT_ctx *x,const u8 *m,u8 *c,u32 bytes)
u32 j0, j1, j2, j3, j4, j5, j6, j7, j8, j9, j10, j11, j12, j13, j14, j15;
u8 *ctarget;
u8 tmp[64];
u32 i;
unsigned int i;
if (!bytes) return;
@ -82,10 +82,7 @@ void ECRYPT_encrypt_bytes(ECRYPT_ctx *x,const u8 *m,u8 *c,u32 bytes)
for (;;) {
if (bytes < 64) {
for (i = 0; i < bytes; ++i)
{
tmp[i] = m[i];
}
for (i = 0;i < bytes;++i) tmp[i] = m[i];
m = tmp;
ctarget = c;
c = tmp;

5
libs/encryption/sha1.cpp
View File

@ -10,7 +10,7 @@ Still 100% Public Domain
Corrected a problem which generated improper hash values on 16 bit machines
Routine SHA1Update changed from
void SHA1Update(SHA1_CTX* context, unsigned char* data, quint32
void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int
len)
to
void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned
@ -27,7 +27,7 @@ be guaranteed to generate the wrong hash (e.g. Test Vector #3, a million
"a"s).
I also changed the declaration of variables i & j in SHA1Update to
unsigned long from quint32 for the same reason.
unsigned long from unsigned int for the same reason.
These changes should make no difference to any 32 bit implementations since
an
@ -94,6 +94,7 @@ void SHA1_Transform(uint32_t state[5], const uint8_t buffer[64]);
/* blk0() and blk() perform the initial expand. */
/* I got the idea of expanding during the round function from SSLeay */
/* FIXME: can we do this in an endian-proof way? */
#ifdef WORDS_BIGENDIAN
#define blk0(i) block->l[i]
#else

28
libs/fastfile/360/fastfile_cod10_360.cpp
View File

@ -36,7 +36,7 @@ FastFile_COD10_360::~FastFile_COD10_360() {
}
QByteArray FastFile_COD10_360::GetBinaryData() const {
QByteArray FastFile_COD10_360::GetBinaryData() {
return QByteArray();
}
@ -69,9 +69,15 @@ bool FastFile_COD10_360::Load(const QString aFilePath) {
bool FastFile_COD10_360::Load(const QByteArray aData) {
QByteArray decompressedData;
// Create a XDataStream on the input data.
XDataStream fastFileStream(aData);
fastFileStream.setByteOrder(XDataStream::LittleEndian);
// Create a QDataStream on the input data.
QDataStream fastFileStream(aData);
fastFileStream.setByteOrder(QDataStream::LittleEndian);
// For COD7/COD9, use BigEndian.
fastFileStream.setByteOrder(QDataStream::BigEndian);
// Select key based on game.
QByteArray key = QByteArray::fromHex("0E50F49F412317096038665622DD091332A209BA0A05A00E1377CEDB0A3CB1D3");
// Read the 8-byte magic.
QByteArray fileMagic(8, Qt::Uninitialized);
@ -90,7 +96,7 @@ bool FastFile_COD10_360::Load(const QByteArray aData) {
QByteArray rsaSignature(256, Qt::Uninitialized);
fastFileStream.readRawData(rsaSignature.data(), 256);
decompressedData = Encryption::DecryptFile(aData, fileName, "0E50F49F412317096038665622DD091332A209BA0A05A00E1377CEDB0A3CB1D3");
decompressedData = Encryption::decryptFastFile_BO2(aData);
// For COD9, write out the complete decompressed zone for testing.
QFile testFile("exports/" + GetBaseStem() + ".zone");
@ -98,16 +104,12 @@ bool FastFile_COD10_360::Load(const QByteArray aData) {
testFile.write(decompressedData);
testFile.close();
}
Utils::ExportData(GetBaseStem() + ".zone", decompressedData);
// Load the zone file with the decompressed data (using an Xbox platform flag).
ZoneFile_COD10_360* zoneFile = new ZoneFile_COD10_360();
zoneFile->SetStem(GetBaseStem() + ".zone");
if (!zoneFile->Load(decompressedData)) {
qWarning() << "Failed to load ZoneFile!";
return false;
}
SetZoneFile(zoneFile);
ZoneFile_COD10_360 zoneFile;
zoneFile.SetStem(GetBaseStem() + ".zone");
zoneFile.Load(decompressedData);
SetZoneFile(std::make_shared<ZoneFile_COD10_360>(zoneFile));
return true;
}

2
libs/fastfile/360/fastfile_cod10_360.h
View File

@ -11,7 +11,7 @@ public:
FastFile_COD10_360(const QString aFilePath);
~FastFile_COD10_360();
QByteArray GetBinaryData() const override;
QByteArray GetBinaryData() override;
bool Load(const QString aFilePath) override;
bool Load(const QByteArray aData) override;

76
libs/fastfile/360/fastfile_cod11_360.cpp
View File

@ -38,7 +38,7 @@ FastFile_COD11_360::~FastFile_COD11_360() {
}
QByteArray FastFile_COD11_360::GetBinaryData() const {
QByteArray FastFile_COD11_360::GetBinaryData() {
return QByteArray();
}
@ -68,84 +68,40 @@ bool FastFile_COD11_360::Load(const QString aFilePath) {
return true;
}
enum DB_CompressorType : qint32
{
DB_COMPRESSOR_INVALID = 0x0,
DB_COMPRESSOR_ZLIB = 0x1,
DB_COMPRESSOR_LZX = 0x2,
DB_COMPRESSOR_PASSTHROUGH = 0x3,
};
bool FastFile_COD11_360::Load(const QByteArray aData) {
QByteArray decompressedData;
// Prepare data stream for parsing
XDataStream fastFileStream(aData);
fastFileStream.setByteOrder(XDataStream::BigEndian);
QDataStream fastFileStream(aData);
fastFileStream.setByteOrder(QDataStream::LittleEndian);
// Verify magic header
QByteArray fileMagic(8, Qt::Uninitialized);
fastFileStream.readRawData(fileMagic.data(), 8);
quint32 version = fastFileStream.ParseUInt32();
fastFileStream.skipRawData(1);
DB_CompressorType compressorType = (DB_CompressorType)fastFileStream.ParseInt8();
fastFileStream.skipRawData(10);
qint32 blockCount = fastFileStream.ParseInt32();
if (version != 1838)
{
qWarning() << "Invalid fast file version:" << version << "!";
if (fileMagic != "TAff0000") {
qWarning() << "Invalid fast file magic for COD12!";
return false;
}
if (blockCount > 17280)
{
qWarning() << "Fast file has too many blocks:" << blockCount << "> 17280!";
return false;
}
fastFileStream.skipRawData(12 * blockCount);
// Skip: File size (4 bytes), flags/version (4 bytes), unknown (8 bytes), build tag (32 bytes), RSA signature (256 bytes)
fastFileStream.skipRawData(4 + 4 + 8 + 32 + 256); // total 304 bytes skipped so far + 8 bytes magic = 312 bytes at correct position.
qint32 startPos = fastFileStream.ParseInt32();
Q_UNUSED(startPos);
// Correctly positioned at 0x138
QByteArray encryptedData = aData.mid(0x138);
decompressedData = Encryption::decryptFastFile_BO3(encryptedData);
qint32 endPos = fastFileStream.ParseInt32();
Q_UNUSED(endPos);
if (fileMagic == "S1ffu100")
{
QByteArray compressedData = aData.mid(fastFileStream.device()->pos());
if (compressorType == DB_COMPRESSOR_ZLIB)
{
decompressedData = Compression::DecompressZLIB(compressedData);
}
else if (compressorType == DB_COMPRESSOR_LZX)
{
decompressedData = Compression::DecompressXMem(compressedData, 0, 0x80000, 0);
}
}
else if (fileMagic == "S1ff0100")
{
}
else
{
qWarning() << "Invalid fast file magic:" << fileMagic << "!";
return false;
}
// Output for verification/testing
Utils::ExportData(GetBaseStem() + ".zone", decompressedData);
// Load the zone file with decompressed data
ZoneFile_COD11_360* zoneFile = new ZoneFile_COD11_360();
zoneFile->SetStem(GetBaseStem() + ".zone");
if (!zoneFile->Load(decompressedData)) {
ZoneFile_COD11_360 zoneFile;
zoneFile.SetStem(GetBaseStem() + ".zone");
if (!zoneFile.Load(decompressedData)) {
qWarning() << "Failed to load ZoneFile!";
return false;
}
SetZoneFile(zoneFile);
SetZoneFile(std::make_shared<ZoneFile_COD11_360>(zoneFile));
return true;
}

2
libs/fastfile/360/fastfile_cod11_360.h
View File

@ -11,7 +11,7 @@ public:
FastFile_COD11_360(const QString aFilePath);
~FastFile_COD11_360();
QByteArray GetBinaryData() const override;
QByteArray GetBinaryData() override;
bool Load(const QString aFilePath) override;
bool Load(const QByteArray aData) override;

80
libs/fastfile/360/fastfile_cod12_360.cpp
View File

@ -38,7 +38,7 @@ FastFile_COD12_360::~FastFile_COD12_360() {
}
QByteArray FastFile_COD12_360::GetBinaryData() const {
QByteArray FastFile_COD12_360::GetBinaryData() {
return QByteArray();
}
@ -72,80 +72,36 @@ bool FastFile_COD12_360::Load(const QByteArray aData) {
QByteArray decompressedData;
// Prepare data stream for parsing
XDataStream fastFileStream(aData);
fastFileStream.setByteOrder(XDataStream::LittleEndian);
QDataStream fastFileStream(aData);
fastFileStream.setByteOrder(QDataStream::LittleEndian);
// Skip header magic
fastFileStream.skipRawData(8);
quint32 version;
fastFileStream >> version;
quint8 unknownFlag, compressionFlag, platformFlag, encryptionFlag;
fastFileStream >> unknownFlag >> compressionFlag >> platformFlag >> encryptionFlag;
if (compressionFlag != 1) {
qDebug() << "Invalid fastfile compression: " << compressionFlag;
return false;
} else if (platformFlag != 4) {
qDebug() << "Invalid platform: " << platformFlag;
return false;
} else if (encryptionFlag != 0) {
qDebug() << "Decryption not supported yet!";
// Verify magic header
QByteArray fileMagic(8, Qt::Uninitialized);
fastFileStream.readRawData(fileMagic.data(), 8);
if (fileMagic != "TAff0000") {
qWarning() << "Invalid fast file magic for COD12!";
return false;
}
fastFileStream.skipRawData(128);
// Skip: File size (4 bytes), flags/version (4 bytes), unknown (8 bytes), build tag (32 bytes), RSA signature (256 bytes)
fastFileStream.skipRawData(4 + 4 + 8 + 32 + 256); // total 304 bytes skipped so far + 8 bytes magic = 312 bytes at correct position.
quint64 size;
fastFileStream >> size;
// Correctly positioned at 0x138
QByteArray encryptedData = aData.mid(0x138);
decompressedData = Encryption::decryptFastFile_BO3(encryptedData);
fastFileStream.skipRawData(432);
int consumed = 0;
while(consumed < size)
{
// Read Block Header
quint32 compressedSize, decompressedSize, blockSize, blockPosition;
fastFileStream >> compressedSize >> decompressedSize >> blockSize >> blockPosition;
// Validate the block position, it should match
if(blockPosition != fastFileStream.device()->pos() - 16)
{
qDebug() << "Block Position does not match Stream Position.";
return false;
}
// Check for padding blocks
if(decompressedSize == 0)
{
fastFileStream.device()->read((((fastFileStream.device()->pos()) + ((0x800000) - 1)) & ~((0x800000) - 1)) - fastFileStream.device()->pos());
continue;
}
fastFileStream.device()->read(2);
QByteArray compressedData(compressedSize - 2, Qt::Uninitialized);
qDebug() << "Data position: " << fastFileStream.device()->pos() << " - Size: " << compressedSize;
fastFileStream.readRawData(compressedData.data(), compressedSize - 2);
decompressedData.append(Compression::DecompressDeflate(compressedData));
consumed += decompressedSize;
// Sinze Fast Files are aligns, we must skip the full block
fastFileStream.device()->seek(blockPosition + 16 + blockSize);
}
// Output for verification/testing
Utils::ExportData(GetBaseStem() + ".zone", decompressedData);
// Load the zone file with decompressed data
ZoneFile_COD12_360* zoneFile = new ZoneFile_COD12_360();
zoneFile->SetStem(GetBaseStem() + ".zone");
if (!zoneFile->Load(decompressedData)) {
ZoneFile_COD12_360 zoneFile;
zoneFile.SetStem(GetBaseStem() + ".zone");
if (!zoneFile.Load(decompressedData)) {
qWarning() << "Failed to load ZoneFile!";
return false;
}
SetZoneFile(zoneFile);
SetZoneFile(std::make_shared<ZoneFile_COD12_360>(zoneFile));
return true;
}

2
libs/fastfile/360/fastfile_cod12_360.h
View File

@ -11,7 +11,7 @@ public:
FastFile_COD12_360(const QString aFilePath);
~FastFile_COD12_360();
QByteArray GetBinaryData() const override;
QByteArray GetBinaryData() override;
bool Load(const QString aFilePath) override;
bool Load(const QByteArray aData) override;

19
libs/fastfile/360/fastfile_cod2_360.cpp
View File

@ -38,7 +38,7 @@ FastFile_COD2_360::~FastFile_COD2_360() {
}
QByteArray FastFile_COD2_360::GetBinaryData() const {
QByteArray FastFile_COD2_360::GetBinaryData() {
return QByteArray();
}
@ -68,9 +68,9 @@ bool FastFile_COD2_360::Load(const QString aFilePath) {
}
bool FastFile_COD2_360::Load(const QByteArray aData) {
// Create a XDataStream on the input data.
XDataStream fastFileStream(aData);
fastFileStream.setByteOrder(XDataStream::LittleEndian);
// Create a QDataStream on the input data.
QDataStream fastFileStream(aData);
fastFileStream.setByteOrder(QDataStream::LittleEndian);
Utils::ReadUntilHex(&fastFileStream, "78");
QByteArray compressedData = aData.mid(fastFileStream.device()->pos());
@ -79,13 +79,10 @@ bool FastFile_COD2_360::Load(const QByteArray aData) {
Utils::ExportData(GetBaseStem() + ".zone", decompressedData);
// Load the zone file with the decompressed data (using an Xbox platform flag).
ZoneFile_COD2_360* zoneFile = new ZoneFile_COD2_360();
zoneFile->SetStem(GetBaseStem() + ".zone");
if (!zoneFile->Load(decompressedData)) {
qWarning() << "Failed to load ZoneFile!";
return false;
}
SetZoneFile(zoneFile);
ZoneFile_COD2_360 zoneFile;
zoneFile.SetStem(GetBaseStem() + ".zone");
zoneFile.Load(decompressedData);
SetZoneFile(std::make_shared<ZoneFile_COD2_360>(zoneFile));
return true;
}

2
libs/fastfile/360/fastfile_cod2_360.h
View File

@ -11,7 +11,7 @@ public:
FastFile_COD2_360(const QString aFilePath);
~FastFile_COD2_360();
QByteArray GetBinaryData() const override;
QByteArray GetBinaryData() override;
bool Load(const QString aFilePath) override;
bool Load(const QByteArray aData) override;

21
libs/fastfile/360/fastfile_cod4_360.cpp
View File

@ -39,7 +39,7 @@ FastFile_COD4_360::~FastFile_COD4_360() {
}
QByteArray FastFile_COD4_360::GetBinaryData() const {
QByteArray FastFile_COD4_360::GetBinaryData() {
return QByteArray();
}
@ -80,9 +80,9 @@ bool FastFile_COD4_360::Load(const QByteArray aData) {
// For COD5, simply decompress from offset 12.
decompressedData = Compression::DecompressZLIB(aData.mid(12));
} else if (header == "IWff0100") {
// Create a XDataStream on the input data.
XDataStream fastFileStream(aData.mid(12));
fastFileStream.setByteOrder(XDataStream::LittleEndian);
// Create a QDataStream on the input data.
QDataStream fastFileStream(aData.mid(12));
fastFileStream.setByteOrder(QDataStream::LittleEndian);
QByteArray magic(8, Qt::Uninitialized);
fastFileStream.readRawData(magic.data(), 8);
@ -126,15 +126,14 @@ bool FastFile_COD4_360::Load(const QByteArray aData) {
}
decompressedData = Compression::DecompressZLIB(compressedData);
}
Utils::ExportData(GetBaseStem() + ".zone", decompressedData);
ZoneFile_COD4_360* zoneFile = new ZoneFile_COD4_360();
zoneFile->SetStem(GetBaseStem() + ".zone");
if (!zoneFile->Load(decompressedData)) {
qWarning() << "Failed to load ZoneFile!";
return false;
}
SetZoneFile(zoneFile);
ZoneFile_COD4_360 zoneFile;
zoneFile.SetStem(GetBaseStem() + ".zone");
zoneFile.Load(decompressedData);
SetZoneFile(std::make_shared<ZoneFile_COD4_360>(zoneFile));
return true;
}

2
libs/fastfile/360/fastfile_cod4_360.h
View File

@ -11,7 +11,7 @@ public:
FastFile_COD4_360(const QString aFilePath);
~FastFile_COD4_360();
QByteArray GetBinaryData() const override;
QByteArray GetBinaryData() override;
bool Load(const QString aFilePath) override;
bool Load(const QByteArray aData) override;

13
libs/fastfile/360/fastfile_cod5_360.cpp
View File

@ -39,7 +39,7 @@ FastFile_COD5_360::~FastFile_COD5_360() {
}
QByteArray FastFile_COD5_360::GetBinaryData() const {
QByteArray FastFile_COD5_360::GetBinaryData() {
return QByteArray();
}
@ -80,13 +80,10 @@ bool FastFile_COD5_360::Load(const QByteArray aData) {
Utils::ExportData(GetBaseStem() + ".zone", decompressedData);
ZoneFile_COD5_360* zoneFile = new ZoneFile_COD5_360();
zoneFile->SetStem(GetBaseStem() + ".zone");
if (!zoneFile->Load(decompressedData)) {
qWarning() << "Failed to load ZoneFile!";
return false;
}
SetZoneFile(zoneFile);
ZoneFile_COD5_360 zoneFile;
zoneFile.SetStem(GetBaseStem() + ".zone");
zoneFile.Load(decompressedData);
SetZoneFile(std::make_shared<ZoneFile_COD5_360>(zoneFile));
return true;
}

2
libs/fastfile/360/fastfile_cod5_360.h
View File

@ -11,7 +11,7 @@ public:
FastFile_COD5_360(const QString aFilePath);
~FastFile_COD5_360();
QByteArray GetBinaryData() const override;
QByteArray GetBinaryData() override;
bool Load(const QString aFilePath) override;
bool Load(const QByteArray aData) override;

74
libs/fastfile/360/fastfile_cod6_360.cpp
View File

@ -39,7 +39,7 @@ FastFile_COD6_360::~FastFile_COD6_360() {
}
QByteArray FastFile_COD6_360::GetBinaryData() const {
QByteArray FastFile_COD6_360::GetBinaryData() {
return QByteArray();
}
@ -70,55 +70,39 @@ bool FastFile_COD6_360::Load(const QString aFilePath) {
}
bool FastFile_COD6_360::Load(const QByteArray aData) {
XDataStream fastFileStream(aData);
fastFileStream.setByteOrder(XDataStream::BigEndian);
QByteArray magic(8, Qt::Uninitialized);
fastFileStream.readRawData(magic.data(), 8);
quint32 version = fastFileStream.ParseUInt32();
if (version != 269)
const qint64 zlibOffset = Compression::FindZlibOffset(aData);
if (zlibOffset == -1)
{
qDebug() << QString("Invalid version: %1!").arg(version);
qWarning() << "Z-Lib stream not found";
return false;
}
QByteArray compressed = aData.mid(zlibOffset);
// 2. Try plain decompression first ------------------------------
QByteArray decompressed = Compression::DecompressZLIB(compressed);
// 3. If that failed or looks too small, try stripping hash blocks
if (decompressed.isEmpty() || decompressed.size() < 1024)
{
QByteArray stripped = Compression::StripHashBlocks(compressed);
QByteArray retry = Compression::DecompressZLIB(stripped);
if (!retry.isEmpty())
decompressed.swap(retry);
}
if (decompressed.isEmpty())
{
qWarning() << "Unable to decompress fast-file";
return false;
}
bool localPatch = fastFileStream.ParseBool();
Q_UNUSED(localPatch);
// Optional – keep a copy on disk for quick inspection
Utils::ExportData(GetBaseStem() + ".zone", decompressed);
quint8 compressor = fastFileStream.ParseUInt8();
Q_UNUSED(compressor);
// Skip fastfile date/time
fastFileStream.skipRawData(11);
quint32 hashCount = fastFileStream.ParseUInt32();
fastFileStream.skipRawData(12 * hashCount);
fastFileStream.skipRawData(8);
QByteArray decompressedData;
if (magic == "IWff0100")
{
}
else if (magic == "IWffu100")
{
quint32 zlibSize = aData.size() - fastFileStream.device()->pos();
QByteArray zlibData(zlibSize, Qt::Uninitialized);
fastFileStream.readRawData(zlibData.data(), zlibSize);
decompressedData = Compression::DecompressZLIB(zlibData);
}
Utils::ExportData(GetBaseStem() + ".zone", decompressedData);
ZoneFile_COD6_360* zoneFile = new ZoneFile_COD6_360();
zoneFile->SetStem(GetBaseStem() + ".zone");
if (!zoneFile->Load(decompressedData)) {
qWarning() << "Failed to load ZoneFile!";
return false;
}
// 4. Forward to zone-file loader --------------------------------
auto zoneFile = std::make_shared<ZoneFile_COD6_360>();
zoneFile->SetStem(GetStem());
zoneFile->Load(decompressed);
SetZoneFile(zoneFile);
return true;

2
libs/fastfile/360/fastfile_cod6_360.h
View File

@ -11,7 +11,7 @@ public:
FastFile_COD6_360(const QString aFilePath);
~FastFile_COD6_360();
QByteArray GetBinaryData() const override;
QByteArray GetBinaryData() override;
bool Load(const QString aFilePath) override;
bool Load(const QByteArray aData) override;

31
libs/fastfile/360/fastfile_cod7_360.cpp
View File

@ -38,7 +38,7 @@ FastFile_COD7_360::~FastFile_COD7_360() {
}
QByteArray FastFile_COD7_360::GetBinaryData() const {
QByteArray FastFile_COD7_360::GetBinaryData() {
return QByteArray();
}
@ -71,11 +71,19 @@ bool FastFile_COD7_360::Load(const QString aFilePath) {
bool FastFile_COD7_360::Load(const QByteArray aData) {
QByteArray decompressedData;
// Create a XDataStream on the input data.
XDataStream fastFileStream(aData);
fastFileStream.setByteOrder(XDataStream::BigEndian);
// Create a QDataStream on the input data.
QDataStream fastFileStream(aData);
fastFileStream.skipRawData(16);
// Load the zone file with the decompressed data (using an Xbox platform flag).
ZoneFile_COD7_360 zoneFile;
zoneFile.SetStem(GetBaseStem() + ".zone");
// For COD7/COD9, use BigEndian.
fastFileStream.setByteOrder(QDataStream::BigEndian);
// Select key based on game.
QByteArray key = QByteArray::fromHex("1ac1d12d527c59b40eca619120ff8217ccff09cd16896f81b829c7f52793405d");
fastFileStream.skipRawData(4);
// Read the 8-byte magic.
QByteArray fileMagic(8, Qt::Uninitialized);
@ -97,8 +105,6 @@ bool FastFile_COD7_360::Load(const QByteArray aData) {
QByteArray rsaSignature(256, Qt::Uninitialized);
fastFileStream.readRawData(rsaSignature.data(), 256);
QByteArray key = QByteArray::fromHex("1ac1d12d527c59b40eca619120ff8217ccff09cd16896f81b829c7f52793405d");
// Now the stream should be positioned at 0x13C, where sections begin.
int sectionIndex = 0;
while (true) {
@ -136,15 +142,10 @@ bool FastFile_COD7_360::Load(const QByteArray aData) {
sectionIndex++;
}
Utils::ExportData(GetBaseStem() + ".zone", decompressedData);
ZoneFile_COD7_360* zoneFile = new ZoneFile_COD7_360();
zoneFile->SetStem(GetBaseStem() + ".zone");
if (!zoneFile->Load(decompressedData)) {
qWarning() << "Failed to load ZoneFile!";
return false;
}
SetZoneFile(zoneFile);
zoneFile.Load(decompressedData);
SetZoneFile(std::make_shared<ZoneFile_COD7_360>(zoneFile));
return true;
}

2
libs/fastfile/360/fastfile_cod7_360.h
View File

@ -11,7 +11,7 @@ public:
FastFile_COD7_360(const QString aFilePath);
~FastFile_COD7_360();
QByteArray GetBinaryData() const override;
QByteArray GetBinaryData() override;
bool Load(const QString aFilePath) override;
bool Load(const QByteArray aData) override;

148
libs/fastfile/360/fastfile_cod7_5_360.cpp
View File

@ -1,148 +0,0 @@
#include "fastfile_cod7_5_360.h"
#include "zonefile_cod7_360.h"
#include "compression.h"
#include "encryption.h"
#include <QFile>
#include <QDebug>
FastFile_COD7_5_360::FastFile_COD7_5_360()
: FastFile() {
SetCompany(COMPANY_INFINITY_WARD);
SetType(FILETYPE_FAST_FILE);
SetSignage(SIGNAGE_UNSIGNED);
SetMagic(0);
SetVersion(0);
SetPlatform("360");
SetGame("COD7.5");
}
FastFile_COD7_5_360::FastFile_COD7_5_360(const QByteArray& aData)
: FastFile_COD7_5_360() {
if (!aData.isEmpty()) {
Load(aData);
}
}
FastFile_COD7_5_360::FastFile_COD7_5_360(const QString aFilePath)
: FastFile_COD7_5_360() {
if (!aFilePath.isEmpty()) {
Load(aFilePath);
}
}
FastFile_COD7_5_360::~FastFile_COD7_5_360() {
}
QByteArray FastFile_COD7_5_360::GetBinaryData() const {
return QByteArray();
}
bool FastFile_COD7_5_360::Load(const QString aFilePath) {
if (aFilePath.isEmpty()) {
return false;
}
// Check fastfile can be read
QFile *file = new QFile(aFilePath);
if (!file->open(QIODevice::ReadOnly)) {
qDebug() << QString("Error: Failed to open FastFile: %1!").arg(aFilePath);
return false;
}
// Decompress fastfile and close
const QString fastFileStem = aFilePath.section("/", -1, -1);
SetStem(fastFileStem);
if (!Load(file->readAll())) {
qDebug() << "Error: Failed to load fastfile: " << fastFileStem;
return false;
}
file->close();
// Open zone file after decompressing ff and writing
return true;
}
enum NX_Language : qint32
{
LANGUAGE_ENGLISH = 0x0,
LANGUAGE_FRENCH = 0x1,
LANGUAGE_GERMAN = 0x2,
LANGUAGE_ITALIAN = 0x3,
LANGUAGE_SPANISH = 0x4,
LANGUAGE_BRITISH = 0x5,
LANGUAGE_RUSSIAN = 0x6,
LANGUAGE_POLISH = 0x7,
LANGUAGE_KOREAN = 0x8,
LANGUAGE_TAIWANESE = 0x9,
LANGUAGE_JAPANESE = 0xA,
LANGUAGE_CHINESE = 0xB,
LANGUAGE_THAI = 0xC,
LANGUAGE_LEET = 0xD,
LANGUAGE_CZECH = 0xE,
MAX_LANGUAGES = 0xF,
};
bool FastFile_COD7_5_360::Load(const QByteArray aData) {
// Create a XDataStream on the input data.
XDataStream fastFileStream(aData);
fastFileStream.setByteOrder(XDataStream::BigEndian);
QByteArray magic(8, Qt::Uninitialized);
fastFileStream.readRawData(magic.data(), 8);
quint32 version = fastFileStream.ParseUInt32();
if (version != 357)
{
qDebug() << QString("Invalid version: %1!").arg(version);
return false;
}
bool localPatch = fastFileStream.ParseBool();
Q_UNUSED(localPatch);
quint8 compressor = fastFileStream.ParseUInt8();
Q_UNUSED(compressor);
// Skip fastfile date/time
fastFileStream.skipRawData(8);
NX_Language language = (NX_Language)fastFileStream.ParseInt32();
Q_UNUSED(language);
quint32 hashCount = fastFileStream.ParseUInt32();
fastFileStream.skipRawData(12 * hashCount);
fastFileStream.skipRawData(8);
QByteArray decompressedData;
if (magic == "NXff0100")
{
}
else if (magic == "NXffu100")
{
quint32 zlibSize = aData.size() - fastFileStream.device()->pos();
QByteArray zlibData(zlibSize, Qt::Uninitialized);
fastFileStream.readRawData(zlibData.data(), zlibSize);
decompressedData = Compression::DecompressZLIB(zlibData);
}
Utils::ExportData(GetBaseStem() + ".zone", decompressedData);
ZoneFile_COD7_360* zoneFile = new ZoneFile_COD7_360();
zoneFile->SetStem(GetBaseStem() + ".zone");
if (!zoneFile->Load(decompressedData)) {
qWarning() << "Failed to load ZoneFile!";
return false;
}
SetZoneFile(zoneFile);
return true;
}

20
libs/fastfile/360/fastfile_cod7_5_360.h
View File

@ -1,20 +0,0 @@
#ifndef FASTFILE_COD7_5_360_H
#define FASTFILE_COD7_5_360_H
#include "fastfile.h"
class FastFile_COD7_5_360 : public FastFile
{
public:
FastFile_COD7_5_360();
FastFile_COD7_5_360(const QByteArray& aData);
FastFile_COD7_5_360(const QString aFilePath);
~FastFile_COD7_5_360();
QByteArray GetBinaryData() const override;
bool Load(const QString aFilePath) override;
bool Load(const QByteArray aData) override;
};
#endif // FASTFILE_COD7_5_360_H

30
libs/fastfile/360/fastfile_cod8_360.cpp
View File

@ -36,7 +36,7 @@ FastFile_COD8_360::~FastFile_COD8_360() {
}
QByteArray FastFile_COD8_360::GetBinaryData() const {
QByteArray FastFile_COD8_360::GetBinaryData() {
return QByteArray();
}
@ -69,12 +69,15 @@ bool FastFile_COD8_360::Load(const QString aFilePath) {
bool FastFile_COD8_360::Load(const QByteArray aData) {
QByteArray decompressedData;
// Create a XDataStream on the input data.
XDataStream fastFileStream(aData);
fastFileStream.setByteOrder(XDataStream::LittleEndian);
// Create a QDataStream on the input data.
QDataStream fastFileStream(aData);
fastFileStream.setByteOrder(QDataStream::LittleEndian);
// For COD7/COD9, use BigEndian.
fastFileStream.setByteOrder(XDataStream::BigEndian);
fastFileStream.setByteOrder(QDataStream::BigEndian);
// Select key based on game.
QByteArray key = QByteArray::fromHex("0E50F49F412317096038665622DD091332A209BA0A05A00E1377CEDB0A3CB1D3");
// Read the 8-byte magic.
QByteArray fileMagic(8, Qt::Uninitialized);
@ -89,7 +92,11 @@ bool FastFile_COD8_360::Load(const QByteArray aData) {
QByteArray fileName(32, Qt::Uninitialized);
fastFileStream.readRawData(fileName.data(), 32);
decompressedData = Encryption::DecryptFile(aData, fileName, "0E50F49F412317096038665622DD091332A209BA0A05A00E1377CEDB0A3CB1D3");
// Skip the RSA signature (256 bytes).
QByteArray rsaSignature(256, Qt::Uninitialized);
fastFileStream.readRawData(rsaSignature.data(), 256);
decompressedData = Encryption::decryptFastFile_BO2(aData);
// For COD9, write out the complete decompressed zone for testing.
QFile testFile("exports/" + GetBaseStem() + ".zone");
@ -99,13 +106,10 @@ bool FastFile_COD8_360::Load(const QByteArray aData) {
}
// Load the zone file with the decompressed data (using an Xbox platform flag).
ZoneFile_COD8_360* zoneFile = new ZoneFile_COD8_360();
zoneFile->SetStem(GetBaseStem() + ".zone");
if (!zoneFile->Load(decompressedData)) {
qWarning() << "Failed to load ZoneFile!";
return false;
}
SetZoneFile(zoneFile);
ZoneFile_COD8_360 zoneFile;
zoneFile.SetStem(GetBaseStem() + ".zone");
zoneFile.Load(decompressedData);
SetZoneFile(std::make_shared<ZoneFile_COD8_360>(zoneFile));
return true;
}

2
libs/fastfile/360/fastfile_cod8_360.h
View File

@ -11,7 +11,7 @@ public:
FastFile_COD8_360(const QString aFilePath);
~FastFile_COD8_360();
QByteArray GetBinaryData() const override;
QByteArray GetBinaryData() override;
bool Load(const QString aFilePath) override;
bool Load(const QByteArray aData) override;

26
libs/fastfile/360/fastfile_cod9_360.cpp
View File

@ -36,7 +36,7 @@ FastFile_COD9_360::~FastFile_COD9_360() {
}
QByteArray FastFile_COD9_360::GetBinaryData() const {
QByteArray FastFile_COD9_360::GetBinaryData() {
return QByteArray();
}
@ -69,12 +69,15 @@ bool FastFile_COD9_360::Load(const QString aFilePath) {
bool FastFile_COD9_360::Load(const QByteArray aData) {
QByteArray decompressedData;
// Create a XDataStream on the input data.
XDataStream fastFileStream(aData);
fastFileStream.setByteOrder(XDataStream::LittleEndian);
// Create a QDataStream on the input data.
QDataStream fastFileStream(aData);
fastFileStream.setByteOrder(QDataStream::LittleEndian);
// For COD7/COD9, use BigEndian.
fastFileStream.setByteOrder(XDataStream::BigEndian);
fastFileStream.setByteOrder(QDataStream::BigEndian);
// Select key based on game.
QByteArray key = QByteArray::fromHex("0E50F49F412317096038665622DD091332A209BA0A05A00E1377CEDB0A3CB1D3");
// Read the 8-byte magic.
QByteArray fileMagic(8, Qt::Uninitialized);
@ -93,7 +96,7 @@ bool FastFile_COD9_360::Load(const QByteArray aData) {
QByteArray rsaSignature(256, Qt::Uninitialized);
fastFileStream.readRawData(rsaSignature.data(), 256);
decompressedData = Encryption::DecryptFile(aData, fileName, "0E50F49F412317096038665622DD091332A209BA0A05A00E1377CEDB0A3CB1D3");
decompressedData = Encryption::decryptFastFile_BO2(aData);
// For COD9, write out the complete decompressed zone for testing.
QFile testFile("exports/" + GetBaseStem() + ".zone");
@ -103,13 +106,10 @@ bool FastFile_COD9_360::Load(const QByteArray aData) {
}
// Load the zone file with the decompressed data (using an Xbox platform flag).
ZoneFile_COD9_360* zoneFile = new ZoneFile_COD9_360();
zoneFile->SetStem(GetBaseStem() + ".zone");
if (!zoneFile->Load(decompressedData)) {
qWarning() << "Failed to load ZoneFile!";
return false;
}
SetZoneFile(zoneFile);
ZoneFile_COD9_360 zoneFile;
zoneFile.SetStem(GetBaseStem() + ".zone");
zoneFile.Load(decompressedData);
SetZoneFile(std::make_shared<ZoneFile_COD9_360>(zoneFile));
return true;
}

2
libs/fastfile/360/fastfile_cod9_360.h
View File

@ -11,7 +11,7 @@ public:
FastFile_COD9_360(const QString aFilePath);
~FastFile_COD9_360();
QByteArray GetBinaryData() const override;
QByteArray GetBinaryData() override;
bool Load(const QString aFilePath) override;
bool Load(const QByteArray aData) override;

37
libs/fastfile/PC/fastfile_cod10_pc.cpp
View File

@ -36,7 +36,7 @@ FastFile_COD10_PC::~FastFile_COD10_PC() {
}
QByteArray FastFile_COD10_PC::GetBinaryData() const {
QByteArray FastFile_COD10_PC::GetBinaryData() {
return QByteArray();
}
@ -69,9 +69,9 @@ bool FastFile_COD10_PC::Load(const QString aFilePath) {
bool FastFile_COD10_PC::Load(const QByteArray aData) {
QByteArray decompressedData;
// Create a XDataStream on the input data.
XDataStream fastFileStream(aData);
fastFileStream.setByteOrder(XDataStream::LittleEndian);
// Create a QDataStream on the input data.
QDataStream fastFileStream(aData);
fastFileStream.setByteOrder(QDataStream::LittleEndian);
// Parse header values.
SetCompany(pParseFFCompany(&fastFileStream));
@ -84,13 +84,18 @@ bool FastFile_COD10_PC::Load(const QByteArray aData) {
SetGame("COD9");
// For COD7/COD9, use BigEndian.
fastFileStream.setByteOrder(XDataStream::BigEndian);
fastFileStream.setByteOrder(QDataStream::BigEndian);
if (GetPlatform() == "PC") {
fastFileStream.setByteOrder(XDataStream::LittleEndian);
fastFileStream.setByteOrder(QDataStream::LittleEndian);
}
// Select key based on game.
QByteArray key = QByteArray::fromHex("641D8A2FE31D3AA63622BBC9CE8587229D42B0F8ED9B924130BF88B65EDC50BE");
QByteArray key;
if (GetPlatform() == "360") {
key = QByteArray::fromHex("0E50F49F412317096038665622DD091332A209BA0A05A00E1377CEDB0A3CB1D3");
} else if (GetPlatform() == "PC") {
key = QByteArray::fromHex("641D8A2FE31D3AA63622BBC9CE8587229D42B0F8ED9B924130BF88B65EDC50BE");
}
// Read the 8-byte magic.
QByteArray fileMagic(8, Qt::Uninitialized);
@ -109,7 +114,11 @@ bool FastFile_COD10_PC::Load(const QByteArray aData) {
QByteArray rsaSignature(256, Qt::Uninitialized);
fastFileStream.readRawData(rsaSignature.data(), 256);
//decompressedData = Encryption::decryptFastFile_BO2(aData);
if (GetPlatform() == "360") {
//decompressedData = Compressor::cod9_decryptFastFile(aData);
} else if (GetPlatform() == "PC") {
decompressedData = Encryption::decryptFastFile_BO2(aData);
}
// For COD9, write out the complete decompressed zone for testing.
QFile testFile("exports/" + GetBaseStem() + ".zone");
@ -117,16 +126,12 @@ bool FastFile_COD10_PC::Load(const QByteArray aData) {
testFile.write(decompressedData);
testFile.close();
}
Utils::ExportData(GetBaseStem() + ".zone", decompressedData);
// Load the zone file with the decompressed data (using an Xbox platform flag).
ZoneFile_COD10_PC* zoneFile = new ZoneFile_COD10_PC();
zoneFile->SetStem(GetBaseStem() + ".zone");
if (!zoneFile->Load(decompressedData)) {
qWarning() << "Failed to load ZoneFile!";
return false;
}
SetZoneFile(zoneFile);
ZoneFile_COD10_PC zoneFile;
zoneFile.SetStem(GetBaseStem() + ".zone");
zoneFile.Load(decompressedData);
SetZoneFile(std::make_shared<ZoneFile_COD10_PC>(zoneFile));
return true;
}

2
libs/fastfile/PC/fastfile_cod10_pc.h
View File

@ -11,7 +11,7 @@ public:
FastFile_COD10_PC(const QString aFilePath);
~FastFile_COD10_PC();
QByteArray GetBinaryData() const override;
QByteArray GetBinaryData() override;
bool Load(const QString aFilePath) override;
bool Load(const QByteArray aData) override;

41
libs/fastfile/PC/fastfile_cod11_pc.cpp
View File

@ -36,7 +36,7 @@ FastFile_COD11_PC::~FastFile_COD11_PC() {
}
QByteArray FastFile_COD11_PC::GetBinaryData() const {
QByteArray FastFile_COD11_PC::GetBinaryData() {
return QByteArray();
}
@ -69,9 +69,9 @@ bool FastFile_COD11_PC::Load(const QString aFilePath) {
bool FastFile_COD11_PC::Load(const QByteArray aData) {
QByteArray decompressedData;
// Create a XDataStream on the input data.
XDataStream fastFileStream(aData);
fastFileStream.setByteOrder(XDataStream::LittleEndian);
// Create a QDataStream on the input data.
QDataStream fastFileStream(aData);
fastFileStream.setByteOrder(QDataStream::LittleEndian);
// Parse header values.
SetCompany(pParseFFCompany(&fastFileStream));
@ -80,11 +80,22 @@ bool FastFile_COD11_PC::Load(const QByteArray aData) {
SetMagic(pParseFFMagic(&fastFileStream));
quint32 version = pParseFFVersion(&fastFileStream);
SetVersion(version);
SetPlatform(pCalculateFFPlatform(version));
SetGame("COD9");
fastFileStream.setByteOrder(XDataStream::LittleEndian);
// For COD7/COD9, use BigEndian.
fastFileStream.setByteOrder(QDataStream::BigEndian);
if (GetPlatform() == "PC") {
fastFileStream.setByteOrder(QDataStream::LittleEndian);
}
// Select key based on game.
QByteArray key = QByteArray::fromHex("641D8A2FE31D3AA63622BBC9CE8587229D42B0F8ED9B924130BF88B65EDC50BE");
QByteArray key;
if (GetPlatform() == "360") {
key = QByteArray::fromHex("0E50F49F412317096038665622DD091332A209BA0A05A00E1377CEDB0A3CB1D3");
} else if (GetPlatform() == "PC") {
key = QByteArray::fromHex("641D8A2FE31D3AA63622BBC9CE8587229D42B0F8ED9B924130BF88B65EDC50BE");
}
// Read the 8-byte magic.
QByteArray fileMagic(8, Qt::Uninitialized);
@ -103,7 +114,11 @@ bool FastFile_COD11_PC::Load(const QByteArray aData) {
QByteArray rsaSignature(256, Qt::Uninitialized);
fastFileStream.readRawData(rsaSignature.data(), 256);
//decompressedData = Encryption::decryptFastFile_BO2(aData);
if (GetPlatform() == "360") {
//decompressedData = Compressor::cod9_decryptFastFile(aData);
} else if (GetPlatform() == "PC") {
decompressedData = Encryption::decryptFastFile_BO2(aData);
}
// For COD9, write out the complete decompressed zone for testing.
QFile testFile("exports/" + GetBaseStem() + ".zone");
@ -111,16 +126,12 @@ bool FastFile_COD11_PC::Load(const QByteArray aData) {
testFile.write(decompressedData);
testFile.close();
}
Utils::ExportData(GetBaseStem() + ".zone", decompressedData);
// Load the zone file with the decompressed data (using an Xbox platform flag).
ZoneFile_COD11_PC* zoneFile = new ZoneFile_COD11_PC();
zoneFile->SetStem(GetBaseStem() + ".zone");
if (!zoneFile->Load(decompressedData)) {
qWarning() << "Failed to load ZoneFile!";
return false;
}
SetZoneFile(zoneFile);
ZoneFile_COD11_PC zoneFile;
zoneFile.SetStem(GetBaseStem() + ".zone");
zoneFile.Load(decompressedData);
SetZoneFile(std::make_shared<ZoneFile_COD11_PC>(zoneFile));
return true;
}

2
libs/fastfile/PC/fastfile_cod11_pc.h
View File

@ -11,7 +11,7 @@ public:
FastFile_COD11_PC(const QString aFilePath);
~FastFile_COD11_PC();
QByteArray GetBinaryData() const override;
QByteArray GetBinaryData() override;
bool Load(const QString aFilePath) override;
bool Load(const QByteArray aData) override;

24
libs/fastfile/PC/fastfile_cod12_pc.cpp
View File

@ -39,7 +39,7 @@ FastFile_COD12_PC::~FastFile_COD12_PC() {
}
QByteArray FastFile_COD12_PC::GetBinaryData() const {
QByteArray FastFile_COD12_PC::GetBinaryData() {
return QByteArray();
}
@ -72,9 +72,13 @@ bool FastFile_COD12_PC::Load(const QString aFilePath) {
bool FastFile_COD12_PC::Load(const QByteArray aData) {
QByteArray decompressedData;
// Create a XDataStream on the input data.
XDataStream fastFileStream(aData);
fastFileStream.setByteOrder(XDataStream::LittleEndian);
// Create a QDataStream on the input data.
QDataStream fastFileStream(aData);
fastFileStream.setByteOrder(QDataStream::LittleEndian);
// Load the zone file with the decompressed data (using an Xbox platform flag).
ZoneFile_COD12_PC zoneFile;
zoneFile.SetStem(GetBaseStem() + ".zone");
// Skip header magic
fastFileStream.skipRawData(8);
@ -136,16 +140,12 @@ bool FastFile_COD12_PC::Load(const QByteArray aData) {
// Sinze Fast Files are aligns, we must skip the full block
fastFileStream.device()->seek(blockPosition + 16 + blockSize);
}
Utils::ExportData(GetBaseStem() + ".zone", decompressedData);
// Load the zone file with the decompressed data (using an Xbox platform flag).
ZoneFile_COD12_PC* zoneFile = new ZoneFile_COD12_PC();
zoneFile->SetStem(GetBaseStem() + ".zone");
if (!zoneFile->Load(decompressedData)) {
qWarning() << "Failed to load ZoneFile!";
return false;
}
SetZoneFile(zoneFile);
zoneFile.Load(decompressedData);
SetZoneFile(std::make_shared<ZoneFile_COD12_PC>(zoneFile));
return true;
}

2
libs/fastfile/PC/fastfile_cod12_pc.h
View File

@ -11,7 +11,7 @@ public:
FastFile_COD12_PC(const QString aFilePath);
~FastFile_COD12_PC();
QByteArray GetBinaryData() const override;
QByteArray GetBinaryData() override;
bool Load(const QString aFilePath) override;
bool Load(const QByteArray aData) override;

19
libs/fastfile/PC/fastfile_cod4_pc.cpp
View File

@ -39,7 +39,7 @@ FastFile_COD4_PC::~FastFile_COD4_PC() {
}
QByteArray FastFile_COD4_PC::GetBinaryData() const {
QByteArray FastFile_COD4_PC::GetBinaryData() {
return QByteArray();
}
@ -75,22 +75,19 @@ bool FastFile_COD4_PC::Load(const QByteArray aData) {
StatusBarManager::instance().updateStatus("Loading COD5 Fast File w/data", 1000);
QByteArray decompressedData;
// Create a XDataStream on the input data.
XDataStream fastFileStream(aData);
fastFileStream.setByteOrder(XDataStream::LittleEndian);
// Create a QDataStream on the input data.
QDataStream fastFileStream(aData);
fastFileStream.setByteOrder(QDataStream::LittleEndian);
// For COD5, simply decompress from offset 12.
decompressedData = Compression::DecompressZLIB(aData.mid(12));
Utils::ExportData(GetBaseStem() + ".zone", decompressedData);
ZoneFile_COD4_PC* zoneFile = new ZoneFile_COD4_PC();
zoneFile->SetStem(GetBaseStem() + ".zone");
if (!zoneFile->Load(decompressedData)) {
qWarning() << "Failed to load ZoneFile!";
return false;
}
SetZoneFile(zoneFile);
ZoneFile_COD4_PC zoneFile;
zoneFile.SetStem(GetBaseStem() + ".zone");
zoneFile.Load(decompressedData);
SetZoneFile(std::make_shared<ZoneFile_COD4_PC>(zoneFile));
return true;
}

2
libs/fastfile/PC/fastfile_cod4_pc.h
View File

@ -11,7 +11,7 @@ public:
FastFile_COD4_PC(const QString aFilePath);
~FastFile_COD4_PC();
QByteArray GetBinaryData() const override;
QByteArray GetBinaryData() override;
bool Load(const QString aFilePath) override;
bool Load(const QByteArray aData) override;

19
libs/fastfile/PC/fastfile_cod5_pc.cpp
View File

@ -39,7 +39,7 @@ FastFile_COD5_PC::~FastFile_COD5_PC() {
}
QByteArray FastFile_COD5_PC::GetBinaryData() const {
QByteArray FastFile_COD5_PC::GetBinaryData() {
return QByteArray();
}
@ -75,22 +75,19 @@ bool FastFile_COD5_PC::Load(const QByteArray aData) {
StatusBarManager::instance().updateStatus("Loading COD5 Fast File w/data", 1000);
QByteArray decompressedData;
// Create a XDataStream on the input data.
XDataStream fastFileStream(aData);
fastFileStream.setByteOrder(XDataStream::LittleEndian);
// Create a QDataStream on the input data.
QDataStream fastFileStream(aData);
fastFileStream.setByteOrder(QDataStream::LittleEndian);
// For COD5, simply decompress from offset 12.
decompressedData = Compression::DecompressZLIB(aData.mid(12));
Utils::ExportData(GetBaseStem() + ".zone", decompressedData);
ZoneFile_COD5_PC* zoneFile = new ZoneFile_COD5_PC();
zoneFile->SetStem(GetBaseStem() + ".zone");
if (!zoneFile->Load(decompressedData)) {
qWarning() << "Failed to load ZoneFile!";
return false;
}
SetZoneFile(zoneFile);
ZoneFile_COD5_PC zoneFile;
zoneFile.SetStem(GetBaseStem() + ".zone");
zoneFile.Load(decompressedData);
SetZoneFile(std::make_shared<ZoneFile_COD5_PC>(zoneFile));
return true;
}

2
libs/fastfile/PC/fastfile_cod5_pc.h
View File

@ -11,7 +11,7 @@ public:
FastFile_COD5_PC(const QString aFilePath);
~FastFile_COD5_PC();
QByteArray GetBinaryData() const override;
QByteArray GetBinaryData() override;
bool Load(const QString aFilePath) override;
bool Load(const QByteArray aData) override;

41
libs/fastfile/PC/fastfile_cod6_pc.cpp
View File

@ -39,7 +39,7 @@ FastFile_COD6_PC::~FastFile_COD6_PC() {
}
QByteArray FastFile_COD6_PC::GetBinaryData() const {
QByteArray FastFile_COD6_PC::GetBinaryData() {
return QByteArray();
}
@ -72,40 +72,19 @@ bool FastFile_COD6_PC::Load(const QString aFilePath) {
}
bool FastFile_COD6_PC::Load(const QByteArray aData) {
const qint64 zlibOffset = Compression::FindZlibOffset(aData);
qDebug() << "ZLib Offset: " << zlibOffset;
if (zlibOffset == -1)
{
qWarning() << "Z-Lib stream not found";
return false;
}
QByteArray compressed = aData.mid(zlibOffset);
StatusBarManager::instance().updateStatus("Loading COD5 Fast File w/data", 1000);
QByteArray decompressedData;
QByteArray decompressedData = Compression::DecompressZLIB(compressed);
if (decompressedData.isEmpty() || decompressedData.size() < 1024)
{
QByteArray stripped = Compression::StripHashBlocks(compressed);
QByteArray retry = Compression::DecompressZLIB(stripped);
if (!retry.isEmpty())
decompressedData.swap(retry);
}
if (decompressedData.isEmpty())
{
qWarning() << "Unable to decompress fast-file";
return false;
}
// Assume the first 12 bytes are a header; the rest is zlib-compressed zone data.
const QByteArray compressedData = aData.mid(21);
decompressedData = Compression::DecompressZLIB(compressedData);
Utils::ExportData(GetBaseStem() + ".zone", decompressedData);
ZoneFile_COD6_PC* zoneFile = new ZoneFile_COD6_PC();
zoneFile->SetStem(GetBaseStem() + ".zone");
if (!zoneFile->Load(decompressedData)) {
qWarning() << "Failed to load ZoneFile!";
return false;
}
SetZoneFile(zoneFile);
ZoneFile_COD6_PC zoneFile;
zoneFile.SetStem(GetBaseStem() + ".zone");
zoneFile.Load(decompressedData);
SetZoneFile(std::make_shared<ZoneFile_COD6_PC>(zoneFile));
return true;
}

2
libs/fastfile/PC/fastfile_cod6_pc.h
View File

@ -11,7 +11,7 @@ public:
FastFile_COD6_PC(const QString aFilePath);
~FastFile_COD6_PC();
QByteArray GetBinaryData() const override;
QByteArray GetBinaryData() override;
bool Load(const QString aFilePath) override;
bool Load(const QByteArray aData) override;

94
libs/fastfile/PC/fastfile_cod7_pc.cpp
View File

@ -39,7 +39,7 @@ FastFile_COD7_PC::~FastFile_COD7_PC() {
}
QByteArray FastFile_COD7_PC::GetBinaryData() const {
QByteArray FastFile_COD7_PC::GetBinaryData() {
return QByteArray();
}
@ -72,9 +72,9 @@ bool FastFile_COD7_PC::Load(const QString aFilePath) {
bool FastFile_COD7_PC::Load(const QByteArray aData) {
QByteArray decompressedData;
// Create a XDataStream on the input data.
XDataStream fastFileStream(aData);
fastFileStream.setByteOrder(XDataStream::LittleEndian);
// Create a QDataStream on the input data.
QDataStream fastFileStream(aData);
fastFileStream.setByteOrder(QDataStream::LittleEndian);
// Parse header values.
SetCompany(pParseFFCompany(&fastFileStream));
@ -83,22 +83,88 @@ bool FastFile_COD7_PC::Load(const QByteArray aData) {
SetMagic(pParseFFMagic(&fastFileStream));
quint32 version = pParseFFVersion(&fastFileStream);
SetVersion(version);
SetPlatform("360");
SetPlatform(pCalculateFFPlatform(version));
SetGame("COD7");
// Assume the first 12 bytes are a header; the rest is zlib-compressed zone data.
const QByteArray compressedData = aData.mid(12);
decompressedData = Compression::DecompressZLIB(compressedData);
// Load the zone file with the decompressed data (using an Xbox platform flag).
ZoneFile_COD7_PC zoneFile;
zoneFile.SetStem(GetBaseStem() + ".zone");
Utils::ExportData(GetBaseStem() + ".zone", decompressedData);
// For COD7/COD9, use BigEndian.
fastFileStream.setByteOrder(QDataStream::LittleEndian);
ZoneFile_COD7_PC* zoneFile = new ZoneFile_COD7_PC();
zoneFile->SetStem(GetBaseStem() + ".zone");
if (!zoneFile->Load(decompressedData)) {
qWarning() << "Failed to load ZoneFile!";
// Select key based on game.
QByteArray key;
fastFileStream.skipRawData(4);
if (GetPlatform() == "360") {
key = QByteArray::fromHex("1ac1d12d527c59b40eca619120ff8217ccff09cd16896f81b829c7f52793405d");
} else if (GetPlatform() == "PS3") {
key = QByteArray::fromHex("46D3F997F29C9ACE175B0DAE3AB8C0C1B8E423E2E3BF7E3C311EA35245BF193A");
// or
// key = QByteArray::fromHex("0C99B3DDB8D6D0845D1147E470F28A8BF2AE69A8A9F534767B54E9180FF55370");
}
// Read the 8-byte magic.
QByteArray fileMagic(8, Qt::Uninitialized);
fastFileStream.readRawData(fileMagic.data(), 8);
if (fileMagic != "PHEEBs71") {
qWarning() << "Invalid fast file magic!";
return false;
}
SetZoneFile(zoneFile);
fastFileStream.skipRawData(4);
// Read IV table name (32 bytes).
QByteArray fileName(32, Qt::Uninitialized);
fastFileStream.readRawData(fileName.data(), 32);
// Build the IV table from the fileName.
QByteArray ivTable = Encryption::InitIVTable(fileName);
// Skip the RSA signature (256 bytes).
QByteArray rsaSignature(256, Qt::Uninitialized);
fastFileStream.readRawData(rsaSignature.data(), 256);
// Now the stream should be positioned at 0x13C, where sections begin.
int sectionIndex = 0;
while (true) {
qint32 sectionSize = 0;
fastFileStream >> sectionSize;
qDebug() << "Section index:" << sectionIndex << "Size:" << sectionSize
<< "Pos:" << fastFileStream.device()->pos();
if (sectionSize == 0)
break;
// Read the section data.
QByteArray sectionData;
sectionData.resize(sectionSize);
fastFileStream.readRawData(sectionData.data(), sectionSize);
// Compute the IV for this section.
QByteArray iv = Encryption::GetIV(ivTable, sectionIndex);
// Decrypt the section using Salsa20.
QByteArray decData = Encryption::salsa20DecryptSection(sectionData, key, iv);
// Compute SHA1 hash of the decrypted data.
QByteArray sectionHash = QCryptographicHash::hash(decData, QCryptographicHash::Sha1);
// Update the IV table based on the section hash.
Encryption::UpdateIVTable(ivTable, sectionIndex, sectionHash);
// Build a compressed data buffer by prepending the two-byte zlib header.
QByteArray compressedData;
compressedData.append(char(0x78));
compressedData.append(char(0x01));
compressedData.append(decData);
decompressedData.append(Compression::DecompressZLIB(compressedData));
sectionIndex++;
}
zoneFile.Load(decompressedData);
SetZoneFile(std::make_shared<ZoneFile_COD7_PC>(zoneFile));
return true;
}

2
libs/fastfile/PC/fastfile_cod7_pc.h
View File

@ -11,7 +11,7 @@ public:
FastFile_COD7_PC(const QString aFilePath);
~FastFile_COD7_PC();
QByteArray GetBinaryData() const override;
QByteArray GetBinaryData() override;
bool Load(const QString aFilePath) override;
bool Load(const QByteArray aData) override;

96
libs/fastfile/PC/fastfile_cod8_pc.cpp
View File

@ -39,7 +39,7 @@ FastFile_COD8_PC::~FastFile_COD8_PC() {
}
QByteArray FastFile_COD8_PC::GetBinaryData() const {
QByteArray FastFile_COD8_PC::GetBinaryData() {
return QByteArray();
}
@ -72,27 +72,99 @@ bool FastFile_COD8_PC::Load(const QString aFilePath) {
bool FastFile_COD8_PC::Load(const QByteArray aData) {
QByteArray decompressedData;
// Create a XDataStream on the input data.
XDataStream fastFileStream(aData);
fastFileStream.setByteOrder(XDataStream::LittleEndian);
// Create a QDataStream on the input data.
QDataStream fastFileStream(aData);
fastFileStream.setByteOrder(QDataStream::LittleEndian);
// Parse header values.
SetCompany(pParseFFCompany(&fastFileStream));
SetType(pParseFFFileType(&fastFileStream));
SetSignage(pParseFFSignage(&fastFileStream));
SetMagic(pParseFFMagic(&fastFileStream));
SetVersion(pParseFFVersion(&fastFileStream));
quint32 version = pParseFFVersion(&fastFileStream);
SetVersion(version);
SetPlatform(pCalculateFFPlatform(version));
SetGame("COD7");
decompressedData = Compression::DecompressZLIB(aData.mid(21));
Utils::ExportData(GetBaseStem() + ".zone", decompressedData);
// Load the zone file with the decompressed data (using an Xbox platform flag).
ZoneFile_COD8_PC zoneFile;
zoneFile.SetStem(GetBaseStem() + ".zone");
ZoneFile_COD8_PC* zoneFile = new ZoneFile_COD8_PC();
zoneFile->SetStem(GetBaseStem() + ".zone");
if (!zoneFile->Load(decompressedData)) {
qWarning() << "Failed to load ZoneFile!";
// For COD7/COD9, use BigEndian.
fastFileStream.setByteOrder(QDataStream::LittleEndian);
// Select key based on game.
QByteArray key;
fastFileStream.skipRawData(4);
if (GetPlatform() == "360") {
key = QByteArray::fromHex("1ac1d12d527c59b40eca619120ff8217ccff09cd16896f81b829c7f52793405d");
} else if (GetPlatform() == "PS3") {
key = QByteArray::fromHex("46D3F997F29C9ACE175B0DAE3AB8C0C1B8E423E2E3BF7E3C311EA35245BF193A");
// or
// key = QByteArray::fromHex("0C99B3DDB8D6D0845D1147E470F28A8BF2AE69A8A9F534767B54E9180FF55370");
}
// Read the 8-byte magic.
QByteArray fileMagic(8, Qt::Uninitialized);
fastFileStream.readRawData(fileMagic.data(), 8);
if (fileMagic != "PHEEBs71") {
qWarning() << "Invalid fast file magic!";
return false;
}
SetZoneFile(zoneFile);
fastFileStream.skipRawData(4);
// Read IV table name (32 bytes).
QByteArray fileName(32, Qt::Uninitialized);
fastFileStream.readRawData(fileName.data(), 32);
// Build the IV table from the fileName.
QByteArray ivTable = Encryption::InitIVTable(fileName);
// Skip the RSA signature (256 bytes).
QByteArray rsaSignature(256, Qt::Uninitialized);
fastFileStream.readRawData(rsaSignature.data(), 256);
// Now the stream should be positioned at 0x13C, where sections begin.
int sectionIndex = 0;
while (true) {
qint32 sectionSize = 0;
fastFileStream >> sectionSize;
qDebug() << "Section index:" << sectionIndex << "Size:" << sectionSize
<< "Pos:" << fastFileStream.device()->pos();
if (sectionSize == 0)
break;
// Read the section data.
QByteArray sectionData;
sectionData.resize(sectionSize);
fastFileStream.readRawData(sectionData.data(), sectionSize);
// Compute the IV for this section.
QByteArray iv = Encryption::GetIV(ivTable, sectionIndex);
// Decrypt the section using Salsa20.
QByteArray decData = Encryption::salsa20DecryptSection(sectionData, key, iv);
// Compute SHA1 hash of the decrypted data.
QByteArray sectionHash = QCryptographicHash::hash(decData, QCryptographicHash::Sha1);
// Update the IV table based on the section hash.
Encryption::UpdateIVTable(ivTable, sectionIndex, sectionHash);
// Build a compressed data buffer by prepending the two-byte zlib header.
QByteArray compressedData;
compressedData.append(char(0x78));
compressedData.append(char(0x01));
compressedData.append(decData);
decompressedData.append(Compression::DecompressZLIB(compressedData));
sectionIndex++;
}
zoneFile.Load(decompressedData);
SetZoneFile(std::make_shared<ZoneFile_COD8_PC>(zoneFile));
return true;
}

2
libs/fastfile/PC/fastfile_cod8_pc.h
View File

@ -11,7 +11,7 @@ public:
FastFile_COD8_PC(const QString aFilePath);
~FastFile_COD8_PC();
QByteArray GetBinaryData() const override;
QByteArray GetBinaryData() override;
bool Load(const QString aFilePath) override;
bool Load(const QByteArray aData) override;

139
libs/fastfile/PC/fastfile_cod9_pc.cpp
View File

@ -36,7 +36,7 @@ FastFile_COD9_PC::~FastFile_COD9_PC() {
}
QByteArray FastFile_COD9_PC::GetBinaryData() const {
QByteArray FastFile_COD9_PC::GetBinaryData() {
return QByteArray();
}
@ -67,18 +67,37 @@ bool FastFile_COD9_PC::Load(const QString aFilePath) {
}
bool FastFile_COD9_PC::Load(const QByteArray aData) {
// Create a XDataStream on the input data.
XDataStream fastFileStream(aData);
fastFileStream.setByteOrder(XDataStream::LittleEndian);
QByteArray decompressedData;
// Create a QDataStream on the input data.
QDataStream fastFileStream(aData);
fastFileStream.setByteOrder(QDataStream::LittleEndian);
// Parse header values.
SetCompany(pParseFFCompany(&fastFileStream));
SetType(pParseFFFileType(&fastFileStream));
SetSignage(pParseFFSignage(&fastFileStream));
SetMagic(pParseFFMagic(&fastFileStream));
SetVersion(pParseFFVersion(&fastFileStream));
quint32 version = pParseFFVersion(&fastFileStream);
SetVersion(version);
SetPlatform(pCalculateFFPlatform(version));
SetGame("COD9");
// Validate the fastfile magic.
// For COD7/COD9, use BigEndian.
fastFileStream.setByteOrder(QDataStream::BigEndian);
if (GetPlatform() == "PC") {
fastFileStream.setByteOrder(QDataStream::LittleEndian);
}
// Select key based on game.
QByteArray key;
if (GetPlatform() == "360") {
key = QByteArray::fromHex("0E50F49F412317096038665622DD091332A209BA0A05A00E1377CEDB0A3CB1D3");
} else if (GetPlatform() == "PC") {
key = QByteArray::fromHex("641D8A2FE31D3AA63622BBC9CE8587229D42B0F8ED9B924130BF88B65EDC50BE");
}
// Read the 8-byte magic.
QByteArray fileMagic(8, Qt::Uninitialized);
fastFileStream.readRawData(fileMagic.data(), 8);
if (fileMagic != "PHEEBs71") {
@ -87,100 +106,32 @@ bool FastFile_COD9_PC::Load(const QByteArray aData) {
}
fastFileStream.skipRawData(4);
// Read IV seed name (32 bytes).
QByteArray nameKey(32, Qt::Uninitialized);
fastFileStream.readRawData(nameKey.data(), 32);
// Read IV table name (32 bytes).
QByteArray fileName(32, Qt::Uninitialized);
fastFileStream.readRawData(fileName.data(), 32);
// --- Salsa20 + IV setup ---
static QVector<quint32> ivCounter(4, 1);
QByteArray ivTable = Encryption::InitIVTable(nameKey);
ivCounter.fill(1); // reset global counters
// Skip the RSA signature (256 bytes).
QByteArray rsaSignature(256, Qt::Uninitialized);
fastFileStream.readRawData(rsaSignature.data(), 256);
// Skip RSA signature (0x100)
fastFileStream.skipRawData(0x100);
// Decrypt + decompress loop
QByteArray finalZone;
int chunkIndex = 0;
while (!fastFileStream.atEnd()) {
quint32 dataLength = 0;
fastFileStream >> dataLength;
if (dataLength == 0)
break;
QByteArray encryptedBlock(dataLength, Qt::Uninitialized);
if (fastFileStream.readRawData(encryptedBlock.data(), dataLength) != dataLength) {
qWarning() << "Unexpected EOF while reading block";
break;
}
// Derive IV for this chunk
QByteArray iv = Encryption::GetIV(ivTable, chunkIndex % 4);
// Salsa20 decryption
QByteArray decryptedBlock = Encryption::salsa20DecryptSection(
encryptedBlock,
QByteArray::fromHex("641D8A2FE31D3AA63622BBC9CE8587229D42B0F8ED9B924130BF88B65EDC50BE"),
iv,
64
);
// SHA1 hash of decrypted block
QCryptographicHash sha1(QCryptographicHash::Sha1);
sha1.addData(decryptedBlock);
QByteArray sha1Hash = sha1.result();
// Inflate into buffer
z_stream strm{};
strm.avail_in = static_cast<uInt>(decryptedBlock.size());
strm.next_in = reinterpret_cast<Bytef*>(decryptedBlock.data());
QByteArray decompressedData;
QByteArray buffer(0x10000, Qt::Uninitialized);
inflateInit2(&strm, -15);
int ret;
do {
strm.avail_out = buffer.size();
strm.next_out = reinterpret_cast<Bytef*>(buffer.data());
ret = inflate(&strm, Z_NO_FLUSH);
if (ret != Z_OK && ret != Z_STREAM_END && ret != Z_BUF_ERROR) {
qWarning() << "inflate failed with code" << ret;
break;
}
int have = buffer.size() - strm.avail_out;
if (have > 0)
decompressedData.append(buffer.constData(), have);
} while (ret != Z_STREAM_END);
inflateEnd(&strm);
finalZone.append(decompressedData);
// Update IV table for next block
Encryption::UpdateIVTable(ivTable, chunkIndex % 4, sha1Hash);
chunkIndex++;
if (GetPlatform() == "360") {
//decompressedData = Compressor::cod9_decryptFastFile(aData);
} else if (GetPlatform() == "PC") {
decompressedData = Encryption::decryptFastFile_BO2(aData);
}
// Export decompressed zone
Utils::ExportData(GetBaseStem() + ".zone", finalZone);
// Load zone file
ZoneFile_COD9_PC* zoneFile = new ZoneFile_COD9_PC();
zoneFile->SetStem(GetBaseStem() + ".zone");
if (!zoneFile->Load(finalZone)) {
qWarning() << "Failed to load ZoneFile!";
return false;
// For COD9, write out the complete decompressed zone for testing.
QFile testFile("exports/" + GetBaseStem() + ".zone");
if(testFile.open(QIODevice::WriteOnly)) {
testFile.write(decompressedData);
testFile.close();
}
SetZoneFile(zoneFile);
return true;
// Load the zone file with the decompressed data (using an Xbox platform flag).
ZoneFile_COD9_PC zoneFile;
zoneFile.SetStem(GetBaseStem() + ".zone");
zoneFile.Load(decompressedData);
SetZoneFile(std::make_shared<ZoneFile_COD9_PC>(zoneFile));
return true;
}

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