Irrlichtirrlicht

13 files changed, 577 insertions, 0 deletions

diff --git a/src/irrlicht/CMakeLists.txt b/src/irrlicht/CMakeLists.txt
new file mode 100644
index 0000000..8c0c33e
--- /dev/null
+++ b/src/irrlicht/CMakeLists.txt
@@ -0,0 +1,9 @@
+target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_LIST_DIR})
+target_sources(${PROJECT_NAME} PRIVATE
+    DTXImage.cpp
+    DTXImageLoader.cpp
+    RezArchive.cpp
+    RezFileList.cpp
+    RezLoader.cpp
+    RezReadFile.cpp
+)
diff --git a/src/irrlicht/DTXImage.cpp b/src/irrlicht/DTXImage.cpp
new file mode 100644
index 0000000..b6e6cdc
--- /dev/null
+++ b/src/irrlicht/DTXImage.cpp
@@ -0,0 +1,116 @@
+#include <DTXImage.h>
+#include <irrlicht.h>
+
+void *DTXImage::lock()
+{
+    return nullptr;
+}
+
+void DTXImage::unlock()
+{
+}
+
+const irr::core::dimension2d<irr::u32> &DTXImage::getDimension() const
+{
+    static const irr::core::dimension2d<irr::u32> d;
+
+    return d;
+}
+
+irr::u32 DTXImage::getBitsPerPixel() const
+{
+    return 0;
+}
+
+irr::u32 DTXImage::getBytesPerPixel() const
+{
+    return 0;
+}
+
+irr::u32 DTXImage::getImageDataSizeInBytes() const
+{
+    return 0;
+}
+
+irr::u32 DTXImage::getImageDataSizeInPixels() const
+{
+    return 0;
+}
+
+irr::video::SColor DTXImage::getPixel(irr::u32 x, irr::u32 y) const
+{
+    return irr::video::SColor();
+}
+
+void DTXImage::setPixel(irr::u32 x, irr::u32 y, const irr::video::SColor &color,
+    bool blend)
+{
+}
+
+irr::video::ECOLOR_FORMAT DTXImage::getColorFormat() const
+{
+    return irr::video::ECOLOR_FORMAT::ECF_UNKNOWN;
+}
+
+irr::u32 DTXImage::getRedMask() const
+{
+    return 0;
+}
+
+irr::u32 DTXImage::getGreenMask() const
+{
+    return 0;
+}
+
+irr::u32 DTXImage::getBlueMask() const
+{
+    return 0;
+}
+
+irr::u32 DTXImage::getAlphaMask() const
+{
+    return 0;
+}
+
+irr::u32 DTXImage::getPitch() const
+{
+    return 0;
+}
+
+void DTXImage::copyToScaling(void *target, irr::u32 width, irr::u32 height,
+    irr::video::ECOLOR_FORMAT format,
+    irr::u32 pitch)
+{
+}
+
+void DTXImage::copyToScaling(IImage *target)
+{
+}
+
+void DTXImage::copyTo(IImage *target, const irr::core::position2d<irr::s32> &)
+{
+}
+
+void DTXImage::copyTo(IImage *target,
+    const irr::core::position2d<irr::s32> &pos,
+    const irr::core::rect<irr::s32> &sourceRect,
+    const irr::core::rect<irr::s32> *clipRect)
+{
+}
+
+void DTXImage::copyToWithAlpha(IImage* target,
+    const irr::core::position2d<irr::s32> &pos,
+    const irr::core::rect<irr::s32> &sourceRect,
+    const irr::video::SColor &color,
+    const irr::core::rect<irr::s32>* clipRect)
+{
+}
+
+void DTXImage::copyToScalingBoxFilter(IImage* target, irr::s32 bias,
+    bool blend)
+{
+}
+
+void DTXImage::fill(const irr::video::SColor &color)
+{
+}
diff --git a/src/irrlicht/DTXImage.h b/src/irrlicht/DTXImage.h
new file mode 100644
index 0000000..a4912d3
--- /dev/null
+++ b/src/irrlicht/DTXImage.h
@@ -0,0 +1,44 @@
+#ifndef DTXIMAGE_H
+#define DTXIMAGE_H
+
+#include <irrlicht.h>
+
+class DTXImage : public irr::video::IImage
+{
+    void *lock();
+    void unlock();
+    const irr::core::dimension2d<irr::u32> &getDimension() const;
+    irr::u32 getBitsPerPixel() const;
+    irr::u32 getBytesPerPixel() const;
+    irr::u32 getImageDataSizeInBytes() const;
+    irr::u32 getImageDataSizeInPixels() const;
+    irr::video::SColor getPixel(irr::u32 x, irr::u32 y) const;
+    void setPixel(irr::u32 x, irr::u32 y, const irr::video::SColor &color,
+        bool blend = false);
+    irr::video::ECOLOR_FORMAT getColorFormat() const;
+    irr::u32 getRedMask() const;
+    irr::u32 getGreenMask() const;
+    irr::u32 getBlueMask() const;
+    irr::u32 getAlphaMask() const;
+    irr::u32 getPitch() const;
+    void copyToScaling(void *target, irr::u32 width, irr::u32 height,
+        irr::video::ECOLOR_FORMAT format = irr::video::ECF_A8R8G8B8,
+        irr::u32 pitch = 0);
+    void copyToScaling(IImage *target);
+    void copyTo(IImage *target,
+        const irr::core::position2d<irr::s32>
+            &pos=irr::core::position2d<irr::s32>(0, 0));
+    void copyTo(IImage *target, const irr::core::position2d<irr::s32> &pos,
+        const irr::core::rect<irr::s32> &sourceRect,
+        const irr::core::rect<irr::s32> *clipRect = nullptr);
+    void copyToWithAlpha(IImage* target,
+        const irr::core::position2d<irr::s32> &pos,
+        const irr::core::rect<irr::s32> &sourceRect,
+        const irr::video::SColor &color,
+        const irr::core::rect<irr::s32>* clipRect = 0);
+    void copyToScalingBoxFilter(IImage* target, irr::s32 bias = 0,
+        bool blend = false);
+    void fill(const irr::video::SColor &color);
+};
+
+#endif
diff --git a/src/irrlicht/DTXImageLoader.cpp b/src/irrlicht/DTXImageLoader.cpp
new file mode 100644
index 0000000..965cca7
--- /dev/null
+++ b/src/irrlicht/DTXImageLoader.cpp
@@ -0,0 +1,18 @@
+#include <DTXImageLoader.h>
+#include <DTXImage.h>
+
+bool DTXImageLoader::isALoadableFileExtension(const irr::io::path &filename)
+    const
+{
+    return irr::core::hasFileExtension(filename, ".dtx");
+}
+
+bool DTXImageLoader::isALoadableFileFormat(irr::io::IReadFile *file) const
+{
+    return false;
+}
+
+irr::video::IImage *DTXImageLoader::loadImage(irr::io::IReadFile *file) const
+{
+    return new DTXImage;
+}
diff --git a/src/irrlicht/DTXImageLoader.h b/src/irrlicht/DTXImageLoader.h
new file mode 100644
index 0000000..7cd9a7e
--- /dev/null
+++ b/src/irrlicht/DTXImageLoader.h
@@ -0,0 +1,13 @@
+#ifndef DTXIMAGELOADER_H
+#define DTXIMAGELOADER_H
+
+#include <irrlicht.h>
+
+class DTXImageLoader : public irr::video::IImageLoader
+{
+    bool isALoadableFileExtension(const irr::io::path &filename) const;
+    bool isALoadableFileFormat(irr::io::IReadFile *file) const;
+    irr::video::IImage *loadImage(irr::io::IReadFile *file) const;
+};
+
+#endif
diff --git a/src/irrlicht/RezArchive.cpp b/src/irrlicht/RezArchive.cpp
new file mode 100644
index 0000000..8b9ff05
--- /dev/null
+++ b/src/irrlicht/RezArchive.cpp
@@ -0,0 +1,44 @@
+#include <RezArchive.h>
+#include <RezReadFile.h>
+#include <rez.h>
+#include <memory>
+
+irr::io::IReadFile *RezArchive::createAndOpenFile(const irr::io::path &filename)
+{
+    std::unique_ptr<rez::file> f = rez.open(filename.c_str());
+
+    if (!f)
+        return nullptr;
+
+    return new RezReadFile(std::move(f), filename);
+}
+
+irr::io::IReadFile *RezArchive::createAndOpenFile(irr::u32 index)
+{
+    return nullptr;
+}
+
+const irr::io::IFileList *RezArchive::getFileList() const
+{
+    return filelist.get();
+}
+
+irr::io::E_FILE_ARCHIVE_TYPE RezArchive::getType() const
+{
+    return static_cast<irr::io::E_FILE_ARCHIVE_TYPE>
+        (MAKE_IRR_ID('r', 'e', 'z', 0));
+}
+
+int RezArchive::parse()
+{
+    if (rez.parse())
+        return -1;
+
+    filelist = std::make_unique<RezFileList>(rez);
+    return 0;
+}
+
+RezArchive::RezArchive(const irr::io::path &filename) :
+    rez(filename.c_str())
+{
+}
diff --git a/src/irrlicht/RezArchive.h b/src/irrlicht/RezArchive.h
new file mode 100644
index 0000000..442d80b
--- /dev/null
+++ b/src/irrlicht/RezArchive.h
@@ -0,0 +1,24 @@
+#ifndef REZARCHIVE_H
+#define REZARCHIVE_H
+
+#include <rez.h>
+#include <RezFileList.h>
+#include <irrlicht.h>
+#include <memory>
+
+class RezArchive : public irr::io::IFileArchive
+{
+public:
+	RezArchive(const irr::io::path &filename);
+	int parse();
+	virtual irr::io::IReadFile *createAndOpenFile(const irr::io::path &filename);
+	virtual irr::io::IReadFile *createAndOpenFile(irr::u32 index);
+	virtual const irr::io::IFileList *getFileList() const;
+	virtual irr::io::E_FILE_ARCHIVE_TYPE getType() const;
+
+protected:
+	std::unique_ptr<RezFileList> filelist;
+	rez::ball rez;
+};
+
+#endif
diff --git a/src/irrlicht/RezFileList.cpp b/src/irrlicht/RezFileList.cpp
new file mode 100644
index 0000000..1932b85
--- /dev/null
+++ b/src/irrlicht/RezFileList.cpp
@@ -0,0 +1,143 @@
+#include <RezFileList.h>
+#include <rez/dir.h>
+#include <rez.h>
+#include <iostream>
+
+static const irr::io::path s;
+
+irr::u32 RezFileList::getFileCount(const rez::dir &dir) const
+{
+    irr::u32 ret = 0;
+
+    for (const auto &d : dir.entries())
+    {
+        const auto &entry = d.second;
+
+        if (std::holds_alternative<rez::dir>(entry))
+            ret += getFileCount(std::get<rez::dir>(entry));
+        else if (std::holds_alternative<rez::resource>(entry))
+            ret++;
+    }
+
+    return ret;
+}
+
+irr::u32 RezFileList::getFileCount() const
+{
+    return getFileCount(rez.root());
+}
+
+const irr::io::path &RezFileList::getFileName(irr::u32 index) const
+{
+    return s;
+}
+
+const irr::io::path &RezFileList::getFullFileName(irr::u32 index) const
+{
+    return s;
+}
+
+irr::u32 RezFileList::getFileSize(irr::u32 index) const
+{
+    return 0;
+}
+
+irr::u32 RezFileList::getFileOffset(irr::u32 index) const
+{
+    return 0;
+}
+
+irr::u32 RezFileList::getID(irr::u32 index) const
+{
+    return 0;
+}
+
+bool RezFileList::isDirectory(irr::u32 index) const
+{
+    if (index >= entries.size())
+        return false;
+
+    return std::holds_alternative<rez::dir>(*entries.at(index));
+}
+
+int RezFileList::findFile(const irr::io::path &filename, bool isFolder,
+    const rez::dir::direntry *entry) const
+{
+    if (std::holds_alternative<rez::resource>(*entry))
+    {
+        const auto &resource = std::get<rez::resource>(*entry);
+
+        if (resource.name() == filename.c_str())
+        {
+            if (isFolder)
+            {
+                std::cerr << filename.c_str() << " expected to be a "
+                    "directory, but is a file\n";
+                return -1;
+            }
+            else
+                return 1;
+        }
+    }
+    else if (std::holds_alternative<rez::dir>(*entry) && isFolder)
+    {
+        const auto &dir = std::get<rez::dir>(*entry);
+
+        if (dir.name() == filename.c_str())
+        {
+            if (!isFolder)
+            {
+                std::cerr << filename.c_str() << " expected to be a "
+                    "file, but is a directory\n";
+                return -1;
+            }
+            else
+                return 1;
+        }
+    }
+
+    return 0;
+}
+
+irr::s32 RezFileList::findFile(const irr::io::path &filename, bool isFolder)
+    const
+{
+    for (irr::u32 i = 0; i < entries.size(); i++)
+    {
+        auto entry = entries.at(i);
+        int n = findFile(filename, isFolder, entry);
+
+        if (n < 0)
+            return -1;
+        else if (n)
+            return i;
+    }
+
+    const rez::dir::direntry *entry = rez.access(filename.c_str());
+
+    if (!entry || findFile(filename, isFolder, entry) <= 0)
+        return -1;
+
+    entries.push_back(entry);
+    return entries.size() - 1;
+}
+
+const irr::io::path &RezFileList::getPath() const
+{
+    return s;
+}
+
+irr::u32 RezFileList::addItem(const irr::io::path &fullPath, irr::u32 offset,
+    irr::u32 size, bool isDirectory, irr::u32 id)
+{
+    return 0;
+}
+
+void RezFileList::sort()
+{
+}
+
+RezFileList::RezFileList(const rez::ball &rez) :
+    rez(rez)
+{
+}
diff --git a/src/irrlicht/RezFileList.h b/src/irrlicht/RezFileList.h
new file mode 100644
index 0000000..a5ce077
--- /dev/null
+++ b/src/irrlicht/RezFileList.h
@@ -0,0 +1,35 @@
+#ifndef REZFILELIST_H
+#define REZFILELIST_H
+
+#include <rez.h>
+#include <irrlicht.h>
+#include <vector>
+
+class RezFileList : public irr::io::IFileList
+{
+public:
+    RezFileList(const rez::ball &rez);
+	virtual irr::u32 getFileCount() const;
+	virtual const irr::io::path &getFileName(irr::u32 index) const;
+	virtual const irr::io::path &getFullFileName(irr::u32 index) const;
+	virtual irr::u32 getFileSize(irr::u32 index) const;
+	virtual irr::u32 getFileOffset(irr::u32 index) const;
+	virtual irr::u32 getID(irr::u32 index) const;
+	virtual bool isDirectory(irr::u32 index) const;
+	virtual irr::s32 findFile(const irr::io::path &filename, bool isFolder) const;
+	virtual const irr::io::path &getPath() const;
+	virtual irr::u32 addItem(const irr::io::path& fullPath, irr::u32 offset,
+		irr::u32 size, bool isDirectory, irr::u32 id);
+	virtual void sort();
+
+protected:
+    const rez::ball &rez;
+
+private:
+	irr::u32 getFileCount(const rez::dir &dir) const;
+	int findFile(const irr::io::path &filename, bool isFolder,
+		const rez::dir::direntry *entry) const;
+	mutable std::vector<const rez::dir::direntry *> entries;
+};
+
+#endif
diff --git a/src/irrlicht/RezLoader.cpp b/src/irrlicht/RezLoader.cpp
new file mode 100644
index 0000000..118a96d
--- /dev/null
+++ b/src/irrlicht/RezLoader.cpp
@@ -0,0 +1,56 @@
+#include <RezLoader.h>
+#include <RezArchive.h>
+#include <rez.h>
+#include <irrlicht.h>
+#include <cstring>
+
+bool RezLoader::isALoadableFileFormat(const irr::io::path &filename) const
+{
+    return irr::core::hasFileExtension(filename, "rez");
+}
+
+bool RezLoader::isALoadableFileFormat(irr::io::IReadFile *file) const
+{
+    char buf[sizeof rez::ball::title], *p = buf;
+    size_t rem = sizeof buf;
+
+    while (rem)
+    {
+        irr::s32 n = file->read(p, rem);
+
+        if (n < 0)
+            return false;
+
+        p += n;
+        rem -= n;
+    }
+
+    return !strcmp(buf, rez::ball::title);
+}
+
+bool RezLoader::isALoadableFileFormat(irr::io::E_FILE_ARCHIVE_TYPE fileType) const
+{
+    return fileType == static_cast<irr::io::E_FILE_ARCHIVE_TYPE>
+        (MAKE_IRR_ID('r', 'e', 'z', 0));
+}
+
+irr::io::IFileArchive *RezLoader::createArchive(const irr::io::path &filename,
+    bool ignoreCase, bool ignorePaths) const
+{
+    RezArchive *archive = new RezArchive(filename);
+
+    if (archive->parse())
+    {
+        delete archive;
+        return nullptr;
+    }
+
+    return archive;
+}
+
+irr::io::IFileArchive *RezLoader::createArchive(irr::io::IReadFile *file,
+    bool ignoreCase, bool ignorePaths) const
+{
+    // TODO: how to do that?
+    return nullptr;
+}
diff --git a/src/irrlicht/RezLoader.h b/src/irrlicht/RezLoader.h
new file mode 100644
index 0000000..85a614d
--- /dev/null
+++ b/src/irrlicht/RezLoader.h
@@ -0,0 +1,19 @@
+#ifndef REZLOADER_H
+#define REZLOADER_H
+
+#include <irrlicht.h>
+
+class RezLoader : public irr::io::IArchiveLoader
+{
+public:
+	virtual bool isALoadableFileFormat(const irr::io::path &filename) const;
+	virtual bool isALoadableFileFormat(irr::io::IReadFile *file) const;
+	virtual bool isALoadableFileFormat(irr::io::E_FILE_ARCHIVE_TYPE fileType)
+        const;
+	virtual irr::io::IFileArchive *createArchive(const irr::io::path &filename,
+        bool ignoreCase, bool ignorePaths) const;
+	virtual irr::io::IFileArchive *createArchive(irr::io::IReadFile *file,
+        bool ignoreCase, bool ignorePaths) const;
+};
+
+#endif
diff --git a/src/irrlicht/RezReadFile.cpp b/src/irrlicht/RezReadFile.cpp
new file mode 100644
index 0000000..ebeeebd
--- /dev/null
+++ b/src/irrlicht/RezReadFile.cpp
@@ -0,0 +1,33 @@
+#include <RezReadFile.h>
+
+irr::s32 RezReadFile::read(void *buffer, irr::u32 sizeToRead)
+{
+    return f->read(buffer, sizeToRead);
+}
+
+bool RezReadFile::seek(long finalPos, bool relativeMovement)
+{
+    return false;
+}
+
+long RezReadFile::getSize() const
+{
+    return -1;
+}
+
+long RezReadFile::getPos() const
+{
+    return f->tell();
+}
+
+const irr::io::path &RezReadFile::getFileName() const
+{
+    return filename;
+}
+
+RezReadFile::RezReadFile(std::unique_ptr<rez::file> f,
+    const irr::io::path &filename) :
+    f(std::move(f)),
+    filename(filename)
+{
+}
diff --git a/src/irrlicht/RezReadFile.h b/src/irrlicht/RezReadFile.h
new file mode 100644
index 0000000..892c396
--- /dev/null
+++ b/src/irrlicht/RezReadFile.h
@@ -0,0 +1,23 @@
+#ifndef REZREADFILE_H
+#define REZREADFILE_H
+
+#include <rez/file.h>
+#include <irrlicht.h>
+#include <memory>
+
+class RezReadFile : public irr::io::IReadFile
+{
+public:
+    RezReadFile(std::unique_ptr<rez::file> f, const irr::io::path &filename);
+    virtual irr::s32 read(void *buffer, irr::u32 sizeToRead);
+    virtual bool seek(long finalPos, bool relativeMovement);
+    virtual long getSize() const;
+    virtual long getPos() const;
+    virtual const irr::io::path &getFileName() const;
+
+private:
+    std::unique_ptr<rez::file> f;
+    irr::io::path filename;
+};
+
+#endif