marrub
/
quake-tools
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

yes I did just move everything into a namespace just so I could get a better print of the FileType enum

master
an 2019-10-05 19:58:19 -04:00
parent 18aa69f573
commit dab41d87ef
9 changed files with 216 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
source/common.h
View File

@ -5,6 +5,7 @@
#include <QCoreApplication> #include <QCoreApplication>
#include <QDebug> #include <QDebug>
#include <QMetaEnum>
#include <algorithm> #include <algorithm>
#include <array> #include <array>
@ -19,6 +20,11 @@
#include <utility> #include <utility>
#include <variant> #include <variant>
inline constexpr std::nullopt_t None{std::nullopt};
template<typename T>
using Option = std::optional<T>;
struct Error : public std::runtime_error { struct Error : public std::runtime_error {
using std::runtime_error::runtime_error; using std::runtime_error::runtime_error;
}; };
@ -27,6 +33,35 @@ struct EnumError : public Error {using Error::Error;};
struct FileFormatError : public Error {using Error::Error;}; struct FileFormatError : public Error {using Error::Error;};
struct UnimplementedError : public Error {using Error::Error;}; struct UnimplementedError : public Error {using Error::Error;};
struct MemoryStreamBuf : public std::streambuf {
MemoryStreamBuf(char *base, std::size_t size) {
setg(base, base, base + size);
}
};
struct IMemoryStream : public virtual MemoryStreamBuf, public std::istream {
IMemoryStream(char *base, std::size_t size) :
MemoryStreamBuf{base, size},
std::istream(static_cast<std::streambuf *>(this))
{
}
IMemoryStream(char const *base, std::size_t size) :
IMemoryStream{const_cast<char *>(base), size}
{
}
IMemoryStream(QByteArray &bytes) :
IMemoryStream{bytes.data(), std::size_t(bytes.size())}
{
}
IMemoryStream(QByteArray const &bytes) :
IMemoryStream{bytes.data(), std::size_t(bytes.size())}
{
}
};
static inline QString trMain(char const *sourceText, static inline QString trMain(char const *sourceText,
char const *disambiguation = nullptr, char const *disambiguation = nullptr,
int n = -1) { int n = -1) {
@ -72,6 +107,16 @@ static inline std::string ntbsToString(std::array<char, N> const &ntbs) {
return str; return str;
} }
template<typename T>
static inline char const *enumToString(T const t) {
return QMetaEnum::fromType<T>().valueToKey(int(t));
}
template<typename T>
static inline int enumMax() {
return QMetaEnum::fromType<T>().keyCount();
}
static inline QDebug operator<<(QDebug debug, std::string const &t) { static inline QDebug operator<<(QDebug debug, std::string const &t) {
debug << QString::fromStdString(t); debug << QString::fromStdString(t);
return debug; return debug;

106
source/quam/archive.cc
View File

@ -4,93 +4,84 @@
#include "quam/wad2.h" #include "quam/wad2.h"
#include <QIcon> #include <QIcon>
#include <QMetaEnum>
Arc::FileType Arc::getFileType(int n) { namespace Arc {
if(int t = QMetaEnum::fromType<Arc::FileType>().value(n); n != -1) {
return Arc::FileType(t);
} else {
throw EnumError("invalid file type");
}
}
Arc::ArchiveType Arc::getArchiveType(std::istream &st) noexcept { Option<ArchiveType> getArchiveType(std::istream &st) noexcept {
Arc::ArchiveType ret = Arc::ArcNone;
try { try {
auto pos = st.tellg(); auto pos = st.tellg();
auto magic = readBytes<4>(st); auto magic = readBytes<4>(st);
if(magic == std::array{'P', 'A', 'C', 'K'}) {
ret = Arc::ArcPack;
} else if(magic == std::array{'W', 'A', 'D', '2'}) {
ret = Arc::ArcWad2;
}
st.seekg(pos); st.seekg(pos);
if(magic == std::array{'P', 'A', 'C', 'K'}) {return ArcPack;}
if(magic == std::array{'W', 'A', 'D', '2'}) {return ArcWad2;}
} catch(...) { } catch(...) {
} }
return ret; return None;
} }
ArcDir Arc::readArchive(std::istream &st) { Dir readArchive(std::istream &st) {
switch(Arc::getArchiveType(st)) { switch(auto v = getArchiveType(st);
case Arc::ArcPack: return readPack(st); v.has_value() ? *v : throw FileFormatError("not an archive")) {
case Arc::ArcWad2: return readWad2(st); case ArcPack: return readPack(st);
case Arc::ArcNone: throw FileFormatError("not an archive"); case ArcWad2: return readWad2(st);
} }
} }
ArcDir::iterator ArcDir::findNode(std::string const &name) { Dir::iterator Dir::findNode(std::string const &name) {
return std::find_if(begin(), end(), [&name](ArcNode const &node) { return std::find_if(begin(), end(), [&name](Node const &node) {
return node.name == name; return node.name == name;
}); });
} }
ArcNode::ArcNode(ArcDir &&f, std::string &&n, Arc::FileType t) : Node::Node(Dir &&f, std::string &&n, FileType t) :
super_type(std::move(f)), super_type(std::move(f)),
name(std::move(n)), name(std::move(n)),
type(t) type(t)
{ {
} }
ArcNode::ArcNode(ArcFile &&f, std::string &&n, Arc::FileType t) : Node::Node(File &&f, std::string &&n, FileType t) :
super_type(std::move(f)), super_type(std::move(f)),
name(std::move(n)), name(std::move(n)),
type(t) type(t)
{ {
} }
ArcModel::ArcModel(ArcDir const *root, QObject *parent) : Model::Model(QObject *parent) :
QAbstractItemModel{parent}, QAbstractItemModel{parent},
m_root{root} m_dir{nullptr}
{ {
} }
ArcModel::~ArcModel() { Model::~Model() {
} }
QVariant ArcModel::data(QModelIndex const &index, int role) const { QVariant Model::data(QModelIndex const &index, int role) const {
if(!index.isValid()) { if(!index.isValid()) {
return QVariant{}; return QVariant{};
} }
auto node = static_cast<ArcNode *>(index.internalPointer()); auto node = static_cast<Node const *>(index.internalPointer());
switch(role) { switch(role) {
case Qt::DecorationRole: case Qt::DecorationRole:
if(index.column() == Arc::ColumnName) { if(index.column() == ColumnName) {
auto icon = auto icon =
std::holds_alternative<ArcDir>(*node) ? "folder" std::holds_alternative<Dir>(*node) ? "folder"
: "text-x-generic"; : "text-x-generic";
return QVariant{QIcon::fromTheme(icon)}; return QVariant{QIcon::fromTheme(icon)};
} }
break; break;
case Qt::DisplayRole: case Qt::DisplayRole:
switch(index.column()) { switch(index.column()) {
case Arc::ColumnSize: case ColumnSize:
if(auto file = std::get_if<ArcFile>(node)) { if(auto file = std::get_if<File>(node)) {
return QVariant{QString::number(file->size())}; return QVariant{QString::number(file->size())};
} }
break; break;
case Arc::ColumnName: case ColumnType:
return QVariant{tr(enumToString(node->type))};
case ColumnName:
return QVariant{tr(node->name.data())}; return QVariant{tr(node->name.data())};
} }
default: default:
@ -99,7 +90,7 @@ QVariant ArcModel::data(QModelIndex const &index, int role) const {
return QVariant{}; return QVariant{};
} }
Qt::ItemFlags ArcModel::flags(QModelIndex const &index) const { Qt::ItemFlags Model::flags(QModelIndex const &index) const {
if(!index.isValid()) { if(!index.isValid()) {
return Qt::NoItemFlags; return Qt::NoItemFlags;
} else { } else {
@ -110,40 +101,53 @@ Qt::ItemFlags ArcModel::flags(QModelIndex const &index) const {
} }
} }
QVariant ArcModel::headerData(int section, QVariant Model::headerData(int section,
Qt::Orientation orientation, Qt::Orientation orientation,
int role) const { int role) const {
if(orientation == Qt::Horizontal && role == Qt::DisplayRole) { if(orientation == Qt::Horizontal && role == Qt::DisplayRole) {
switch(section) { switch(section) {
case Arc::ColumnSize: return QVariant{tr("Size")}; case ColumnSize: return QVariant{tr("Size")};
case Arc::ColumnName: return QVariant{tr("Name")}; case ColumnType: return QVariant{tr("Type")};
case ColumnName: return QVariant{tr("Name")};
} }
} }
return QVariant{}; return QVariant{};
} }
QModelIndex ArcModel::index(int row, QModelIndex Model::index(int row, int col, QModelIndex const &parent) const {
int col, if(!m_dir || !hasIndex(row, col, parent) || row > m_dir->size()) {
QModelIndex const &parent) const {
if(!hasIndex(row, col, parent) || row > m_root->size()) {
return QModelIndex{}; return QModelIndex{};
} else { } else {
// despite index data being const, this function does not take a const // despite index data being const, this function does not take a const
// pointer, which is very annoying! // pointer, which is very annoying!
return createIndex(row, col, const_cast<ArcNode *>(&m_root->at(row))); return createIndex(row, col, const_cast<Node *>(&m_dir->at(row)));
} }
} }
QModelIndex ArcModel::parent(QModelIndex const &) const { QModelIndex Model::parent(QModelIndex const &) const {
return QModelIndex{}; return QModelIndex{};
} }
int ArcModel::rowCount(QModelIndex const &) const { int Model::rowCount(QModelIndex const &) const {
return m_root->size(); return m_dir ? m_dir->size() : 0;
}
int Model::columnCount(QModelIndex const &) const {
return enumMax<Column>();
}
Dir *Model::dir() const {
return m_dir;
}
void Model::setDir(Dir *dir) {
if(dir != m_dir) {
m_dir = dir;
emit layoutChanged();
emit dirChanged(dir);
}
} }
int ArcModel::columnCount(QModelIndex const &) const {
return Arc::ColumnMax;
} }
// EOF // EOF

140
source/quam/archive.h
View File

@ -6,92 +6,98 @@
#include <QByteArray> #include <QByteArray>
#include <QObject> #include <QObject>
struct ArcDir;
namespace Arc { namespace Arc {
Q_NAMESPACE Q_NAMESPACE
struct Node;
struct Dir;
enum Column { enum Column {
ColumnSize, ColumnSize,
ColumnType,
ColumnName, ColumnName,
ColumnMax,
}; };
Q_ENUM_NS(Column) Q_ENUM_NS(Column)
enum FileType { enum class FileType {
FileNormal, Label,
FileLabel, MipTexture,
Normal,
FilePalette = 64, Palette,
FileTexture, Picture,
FilePicture, Sound,
FileSound, Texture,
FileMipTexture,
}; };
Q_ENUM_NS(FileType) Q_ENUM_NS(FileType)
enum ArchiveType { enum ArchiveType {
ArcNone,
ArcPack, ArcPack,
ArcWad2, ArcWad2,
}; };
Q_ENUM_NS(ArchiveType) Q_ENUM_NS(ArchiveType)
Arc::FileType getFileType(int n); Option<ArchiveType> getArchiveType(std::istream &st) noexcept;
Arc::ArchiveType getArchiveType(std::istream &st) noexcept;
ArcDir readArchive(std::istream &st); Dir readArchive(std::istream &st);
struct Dir : public std::vector<Node> {
using std::vector<Node>::vector;
Dir::iterator findNode(std::string const &name);
};
struct File : public QByteArray {
using QByteArray::QByteArray;
};
struct Node : public std::variant<Dir, File> {
using super_type = std::variant<Dir, File>;
Node() = default;
Node(Dir &&f, std::string &&n, FileType t = FileType::Normal);
Node(File &&f, std::string &&n, FileType t = FileType::Normal);
Node(Node const &) = default;
Node(Node &&) = default;
std::string name;
FileType type;
};
class Model : public QAbstractItemModel {
Q_OBJECT
public:
explicit Model(QObject *parent);
~Model();
QVariant data(QModelIndex const &index, int role) const override;
Qt::ItemFlags flags(QModelIndex const &index) const override;
QVariant headerData(int section, Qt::Orientation orientation, int role)
const override;
QModelIndex index(int row,
int col,
QModelIndex const &parent = QModelIndex())
const override;
QModelIndex parent(QModelIndex const &index = QModelIndex()) const override;
int rowCount(QModelIndex const &index = QModelIndex()) const override;
int columnCount(QModelIndex const &index = QModelIndex()) const override;
Dir *dir() const;
public slots:
void setDir(Dir *dir);
signals:
void dirChanged(Dir *dir);
private:
Dir *m_dir;
};
} }
Q_DECLARE_METATYPE(Arc::Dir)
struct ArcNode; Q_DECLARE_METATYPE(Arc::File)
Q_DECLARE_METATYPE(Arc::Node)
struct ArcDir : public std::vector<ArcNode> {
using std::vector<ArcNode>::vector;
ArcDir::iterator findNode(std::string const &name);
};
Q_DECLARE_METATYPE(ArcDir)
struct ArcFile : public QByteArray {
using QByteArray::QByteArray;
};
Q_DECLARE_METATYPE(ArcFile)
struct ArcNode : public std::variant<ArcDir, ArcFile> {
using super_type = std::variant<ArcDir, ArcFile>;
ArcNode() = default;
ArcNode(ArcDir &&f, std::string &&n, Arc::FileType t = Arc::FileNormal);
ArcNode(ArcFile &&f, std::string &&n, Arc::FileType t = Arc::FileNormal);
ArcNode(ArcNode const &) = default;
ArcNode(ArcNode &&) = default;
std::string name;
Arc::FileType type;
};
Q_DECLARE_METATYPE(ArcNode)
class ArcModel : public QAbstractItemModel {
Q_OBJECT
public:
explicit ArcModel(ArcDir const *root, QObject *parent);
~ArcModel();
QVariant data(QModelIndex const &index, int role) const override;
Qt::ItemFlags flags(QModelIndex const &index) const override;
QVariant headerData(int section, Qt::Orientation orientation, int role)
const override;
QModelIndex index(int row, int col, QModelIndex const &parent)
const override;
QModelIndex parent(QModelIndex const &) const override;
int rowCount(QModelIndex const &) const override;
int columnCount(QModelIndex const &) const override;
private:
ArcDir const *const m_root;
};
// EOF // EOF

16
source/quam/pack.cc
View File

@ -7,7 +7,7 @@ struct PackHeader {
struct PackEntry { struct PackEntry {
std::string name; std::string name;
ArcFile file; Arc::File file;
}; };
static constexpr quint32 sizeOfPackEntry = 64; static constexpr quint32 sizeOfPackEntry = 64;
@ -41,7 +41,7 @@ static PackEntry readPackEntry(std::istream &st) {
st.seekg(entOffset); st.seekg(entOffset);
ArcFile file; Arc::File file;
file.resize(entSize); file.resize(entSize);
st.read(file.data(), entSize); st.read(file.data(), entSize);
@ -59,8 +59,8 @@ static PackEntry readPackEntry(std::istream &st) {
return ent; return ent;
} }
static void insertFile(ArcDir &dir, std::string name, ArcFile file) { static void insertFile(Arc::Dir &dir, std::string name, Arc::File file) {
std::optional<std::string> next; Option<std::string> next;
if(auto slash = name.find('/'); slash != std::string::npos) { if(auto slash = name.find('/'); slash != std::string::npos) {
next = name.substr(slash + 1); next = name.substr(slash + 1);
@ -73,8 +73,8 @@ static void insertFile(ArcDir &dir, std::string name, ArcFile file) {
auto ref = auto ref =
existing != dir.end() existing != dir.end()
? *existing ? *existing
: dir.emplace_back(ArcDir{}, std::move(name)); : dir.emplace_back(Arc::Dir{}, std::move(name));
insertFile(std::get<ArcDir>(ref), *std::move(next), std::move(file)); insertFile(std::get<Arc::Dir>(ref), *std::move(next), std::move(file));
} else { } else {
if(existing != dir.end()) { if(existing != dir.end()) {
throw FileFormatError("duplicate file"); throw FileFormatError("duplicate file");
@ -83,11 +83,11 @@ static void insertFile(ArcDir &dir, std::string name, ArcFile file) {
} }
} }
ArcDir readPack(std::istream &st) { Arc::Dir readPack(std::istream &st) {
auto hdr = readPackHeader(st); auto hdr = readPackHeader(st);
st.seekg(hdr.dirOffset); st.seekg(hdr.dirOffset);
ArcDir root; Arc::Dir root;
for(quint32 i = 0; i < hdr.dirNum; i++) { for(quint32 i = 0; i < hdr.dirNum; i++) {
auto ent = readPackEntry(st); auto ent = readPackEntry(st);

2
source/quam/pack.h
View File

@ -4,6 +4,6 @@
#include "quam/archive.h" #include "quam/archive.h"
ArcDir readPack(std::istream &st); Arc::Dir readPack(std::istream &st);
// EOF // EOF

11
source/quam/project.cc
View File

@ -5,12 +5,12 @@
#include <QMdiArea> #include <QMdiArea>
#include <QSortFilterProxyModel> #include <QSortFilterProxyModel>
Project::Project(ArcDir &&arc, QErrorMessage *errors, QMdiArea *parent) : Project::Project(Arc::Dir &&arc, QErrorMessage *errors, QMdiArea *parent) :
QMdiSubWindow{parent}, QMdiSubWindow{parent},
Ui::Project{}, Ui::Project{},
m_arc{std::move(arc)}, m_arc{std::move(arc)},
m_errors{errors}, m_errors{errors},
m_model{new ArcModel{&m_arc, this}}, m_model{new Arc::Model{this}},
m_sorter{new QSortFilterProxyModel{this}} m_sorter{new QSortFilterProxyModel{this}}
{ {
auto widget = new QWidget(this); auto widget = new QWidget(this);
@ -19,11 +19,18 @@ Project::Project(ArcDir &&arc, QErrorMessage *errors, QMdiArea *parent) :
setAttribute(Qt::WA_DeleteOnClose); setAttribute(Qt::WA_DeleteOnClose);
showMaximized(); showMaximized();
connect(m_model, &Arc::Model::dirChanged, this, &Project::dirChanged);
m_sorter->setSourceModel(m_model); m_sorter->setSourceModel(m_model);
tableView->setModel(m_sorter); tableView->setModel(m_sorter);
m_model->setDir(&m_arc);
} }
Project::~Project() { Project::~Project() {
} }
void Project::dirChanged(Arc::Dir *) {
tableView->resizeColumnsToContents();
}
// EOF // EOF

9
source/quam/project.h
View File

@ -17,13 +17,16 @@ class Project : public QMdiSubWindow, private Ui::Project {
Q_OBJECT Q_OBJECT
public: public:
explicit Project(ArcDir &&arc, QErrorMessage *errors, QMdiArea *parent); explicit Project(Arc::Dir &&arc, QErrorMessage *errors, QMdiArea *parent);
virtual ~Project(); virtual ~Project();
private slots:
void dirChanged(Arc::Dir *dir);
private: private:
ArcDir m_arc; Arc::Dir m_arc;
QErrorMessage *m_errors; QErrorMessage *m_errors;
QAbstractItemModel *m_model; Arc::Model *m_model;
QSortFilterProxyModel *m_sorter; QSortFilterProxyModel *m_sorter;
}; };

23
source/quam/wad2.cc
View File

@ -15,9 +15,22 @@ struct Wad2Header {
struct Wad2Entry { struct Wad2Entry {
std::string name; std::string name;
Arc::FileType type; Arc::FileType type;
ArcFile file; Arc::File file;
}; };
static Arc::FileType getFileType(int n) {
switch(n) {
case 0: return Arc::FileType::Normal;
case 1: return Arc::FileType::Label;
case 64: return Arc::FileType::Palette;
case 65: return Arc::FileType::Texture;
case 66: return Arc::FileType::Picture;
case 67: return Arc::FileType::Sound;
case 68: return Arc::FileType::MipTexture;
default: throw EnumError("invalid file type");
}
}
static Wad2Header readWad2Header(std::istream &st) { static Wad2Header readWad2Header(std::istream &st) {
auto magic = readBytes<4>(st); auto magic = readBytes<4>(st);
@ -48,7 +61,7 @@ static Wad2Entry readWad2Entry(std::istream &st) {
st.seekg(entOffset); st.seekg(entOffset);
ArcFile file; Arc::File file;
file.resize(entSize); file.resize(entSize);
st.read(file.data(), entSize); st.read(file.data(), entSize);
@ -57,15 +70,15 @@ static Wad2Entry readWad2Entry(std::istream &st) {
Wad2Entry ent; Wad2Entry ent;
ent.name = ntbsToString(entName); ent.name = ntbsToString(entName);
ent.file = std::move(file); ent.file = std::move(file);
ent.type = Arc::getFileType(entType); ent.type = getFileType(entType);
return ent; return ent;
} }
ArcDir readWad2(std::istream &st) { Arc::Dir readWad2(std::istream &st) {
auto hdr = readWad2Header(st); auto hdr = readWad2Header(st);
st.seekg(hdr.dirOffset); st.seekg(hdr.dirOffset);
ArcDir root; Arc::Dir root;
for(quint32 i = 0; i < hdr.dirNum; i++) { for(quint32 i = 0; i < hdr.dirNum; i++) {
auto ent = readWad2Entry(st); auto ent = readWad2Entry(st);

2
source/quam/wad2.h
View File

@ -4,6 +4,6 @@
#include "quam/archive.h" #include "quam/archive.h"
ArcDir readWad2(std::istream &st); Arc::Dir readWad2(std::istream &st);
// EOF // EOF