From 69724adfdc7839083075c791e0504bb1978cad5d Mon Sep 17 00:00:00 2001 From: Alexis Maiquez Date: Fri, 16 Aug 2019 14:56:16 +0200 Subject: [PATCH] ~ More class name changes and namespace modifictions (fs and irr) Signed-off-by: Alexis Maiquez --- CMakeLists.txt | 20 +- WallpaperEngine/Core/CProject.cpp | 2 +- WallpaperEngine/Core/CScene.cpp | 2 +- WallpaperEngine/Core/Objects/CEffect.cpp | 2 +- WallpaperEngine/Core/Objects/CImage.cpp | 2 +- .../Core/Objects/Images/CMaterial.cpp | 2 +- .../Core/Objects/Particles/CParticle.cpp | 2 +- WallpaperEngine/FileSystem/utils.cpp | 27 + WallpaperEngine/FileSystem/utils.h | 24 + WallpaperEngine/Irrlicht/CFileList.cpp | 146 +++++ WallpaperEngine/Irrlicht/CFileList.h | 123 ++++ WallpaperEngine/Irrlicht/CImageLoaderTEX.cpp | 549 +++++++++++++++++ WallpaperEngine/Irrlicht/CImageLoaderTEX.h | 91 +++ .../{irr => Irrlicht}/CPkgReader.cpp | 12 +- WallpaperEngine/Irrlicht/CPkgReader.h | 79 +++ WallpaperEngine/Irrlicht/Irrlicht.cpp | 8 + WallpaperEngine/Irrlicht/Irrlicht.h | 10 + WallpaperEngine/effect.cpp | 10 +- WallpaperEngine/fs/utils.cpp | 33 -- WallpaperEngine/fs/utils.h | 36 -- WallpaperEngine/image.cpp | 10 +- WallpaperEngine/irr/CFileList.cpp | 157 ----- WallpaperEngine/irr/CFileList.h | 136 ----- WallpaperEngine/irr/CImageLoaderTEX.cpp | 553 ------------------ WallpaperEngine/irr/CImageLoaderTEX.h | 97 --- WallpaperEngine/irr/CPkgReader.h | 82 --- WallpaperEngine/irrlicht.cpp | 8 - WallpaperEngine/irrlicht.h | 18 - WallpaperEngine/project.cpp | 4 +- WallpaperEngine/scene.cpp | 2 +- WallpaperEngine/shaders/compiler.cpp | 16 +- WallpaperEngine/shaders/compiler.h | 3 + WallpaperEngine/sound.cpp | 8 +- WallpaperEngine/texture.cpp | 4 +- WallpaperEngine/video/material.cpp | 6 +- WallpaperEngine/video/renderer.cpp | 18 +- main.cpp | 52 +- 37 files changed, 1146 insertions(+), 1208 deletions(-) create mode 100644 WallpaperEngine/FileSystem/utils.cpp create mode 100644 WallpaperEngine/FileSystem/utils.h create mode 100644 WallpaperEngine/Irrlicht/CFileList.cpp create mode 100644 WallpaperEngine/Irrlicht/CFileList.h create mode 100644 WallpaperEngine/Irrlicht/CImageLoaderTEX.cpp create mode 100644 WallpaperEngine/Irrlicht/CImageLoaderTEX.h rename WallpaperEngine/{irr => Irrlicht}/CPkgReader.cpp (95%) create mode 100644 WallpaperEngine/Irrlicht/CPkgReader.h create mode 100644 WallpaperEngine/Irrlicht/Irrlicht.cpp create mode 100644 WallpaperEngine/Irrlicht/Irrlicht.h delete mode 100644 WallpaperEngine/fs/utils.cpp delete mode 100644 WallpaperEngine/fs/utils.h delete mode 100644 WallpaperEngine/irr/CFileList.cpp delete mode 100644 WallpaperEngine/irr/CFileList.h delete mode 100644 WallpaperEngine/irr/CImageLoaderTEX.cpp delete mode 100644 WallpaperEngine/irr/CImageLoaderTEX.h delete mode 100644 WallpaperEngine/irr/CPkgReader.h delete mode 100644 WallpaperEngine/irrlicht.cpp delete mode 100644 WallpaperEngine/irrlicht.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 2350846..0a36135 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -38,10 +38,8 @@ add_executable( WallpaperEngine/object3d.h WallpaperEngine/effect.cpp WallpaperEngine/effect.h - WallpaperEngine/fs/utils.cpp - WallpaperEngine/fs/utils.h - WallpaperEngine/irrlicht.cpp - WallpaperEngine/irrlicht.h + WallpaperEngine/FileSystem/utils.cpp + WallpaperEngine/FileSystem/utils.h WallpaperEngine/video/renderer.cpp WallpaperEngine/video/renderer.h WallpaperEngine/video/node.cpp @@ -50,12 +48,14 @@ add_executable( WallpaperEngine/video/material.h WallpaperEngine/texture.cpp WallpaperEngine/texture.h - WallpaperEngine/irr/CImageLoaderTEX.h - WallpaperEngine/irr/CImageLoaderTEX.cpp - WallpaperEngine/irr/CPkgReader.h - WallpaperEngine/irr/CPkgReader.cpp - WallpaperEngine/irr/CFileList.h - WallpaperEngine/irr/CFileList.cpp + WallpaperEngine/Irrlicht/CImageLoaderTEX.h + WallpaperEngine/Irrlicht/CImageLoaderTEX.cpp + WallpaperEngine/Irrlicht/CPkgReader.h + WallpaperEngine/Irrlicht/CPkgReader.cpp + WallpaperEngine/Irrlicht/CFileList.h + WallpaperEngine/Irrlicht/CFileList.cpp + WallpaperEngine/Irrlicht/Irrlicht.cpp + WallpaperEngine/Irrlicht/Irrlicht.h WallpaperEngine/sound.cpp WallpaperEngine/sound.h diff --git a/WallpaperEngine/Core/CProject.cpp b/WallpaperEngine/Core/CProject.cpp index 0b0a6fc..d89bdb7 100644 --- a/WallpaperEngine/Core/CProject.cpp +++ b/WallpaperEngine/Core/CProject.cpp @@ -16,7 +16,7 @@ CProject::CProject (std::string title, std::string type, CScene *scene) : CProject* CProject::fromFile (const irr::io::path& filename) { - json content = json::parse (WallpaperEngine::fs::utils::loadFullFile (filename)); + json content = json::parse (WallpaperEngine::FileSystem::loadFullFile (filename)); json::const_iterator title = content.find ("title"); json::const_iterator type = content.find ("type"); diff --git a/WallpaperEngine/Core/CScene.cpp b/WallpaperEngine/Core/CScene.cpp index b33d38c..1a7bd89 100644 --- a/WallpaperEngine/Core/CScene.cpp +++ b/WallpaperEngine/Core/CScene.cpp @@ -48,7 +48,7 @@ CScene::CScene ( CScene* CScene::fromFile (const irr::io::path& filename) { - json content = json::parse (WallpaperEngine::fs::utils::loadFullFile (filename)); + json content = json::parse (WallpaperEngine::FileSystem::loadFullFile (filename)); json::const_iterator camera_it = content.find ("camera"); json::const_iterator general_it = content.find ("general"); diff --git a/WallpaperEngine/Core/Objects/CEffect.cpp b/WallpaperEngine/Core/Objects/CEffect.cpp index b631949..8908afa 100644 --- a/WallpaperEngine/Core/Objects/CEffect.cpp +++ b/WallpaperEngine/Core/Objects/CEffect.cpp @@ -27,7 +27,7 @@ CEffect* CEffect::fromJSON (json data) throw std::runtime_error ("Object effect must have a file"); } - json content = json::parse (WallpaperEngine::fs::utils::loadFullFile ((*file_it).get ().c_str ())); + json content = json::parse (WallpaperEngine::FileSystem::loadFullFile ((*file_it).get ().c_str ())); json::const_iterator name_it = content.find ("name"); json::const_iterator description_it = content.find ("description"); diff --git a/WallpaperEngine/Core/Objects/CImage.cpp b/WallpaperEngine/Core/Objects/CImage.cpp index b36b533..bc38728 100644 --- a/WallpaperEngine/Core/Objects/CImage.cpp +++ b/WallpaperEngine/Core/Objects/CImage.cpp @@ -38,7 +38,7 @@ WallpaperEngine::Core::CObject* CImage::fromJSON ( throw std::runtime_error ("Images must have size"); } - json content = json::parse (WallpaperEngine::fs::utils::loadFullFile ((*image_it).get ().c_str ())); + json content = json::parse (WallpaperEngine::FileSystem::loadFullFile ((*image_it).get ().c_str ())); json::const_iterator material_it = content.find ("material"); diff --git a/WallpaperEngine/Core/Objects/Images/CMaterial.cpp b/WallpaperEngine/Core/Objects/Images/CMaterial.cpp index f806a58..4e99e14 100644 --- a/WallpaperEngine/Core/Objects/Images/CMaterial.cpp +++ b/WallpaperEngine/Core/Objects/Images/CMaterial.cpp @@ -14,7 +14,7 @@ CMaterial::CMaterial () CMaterial* CMaterial::fromFile (irr::io::path filename) { return fromJSON ( - json::parse (WallpaperEngine::fs::utils::loadFullFile (filename)) + json::parse (WallpaperEngine::FileSystem::loadFullFile (filename)) ); } diff --git a/WallpaperEngine/Core/Objects/Particles/CParticle.cpp b/WallpaperEngine/Core/Objects/Particles/CParticle.cpp index 4182d40..26f4ef9 100644 --- a/WallpaperEngine/Core/Objects/Particles/CParticle.cpp +++ b/WallpaperEngine/Core/Objects/Particles/CParticle.cpp @@ -12,7 +12,7 @@ CParticle* CParticle::fromFile ( const irr::core::vector3df& origin, const irr::core::vector3df& scale) { - json data = json::parse (WallpaperEngine::fs::utils::loadFullFile (filename)); + json data = json::parse (WallpaperEngine::FileSystem::loadFullFile (filename)); json::const_iterator controlpoint_it = data.find ("controlpoint"); json::const_iterator starttime_it = data.find ("starttime"); json::const_iterator maxcount_it = data.find ("maxcount"); diff --git a/WallpaperEngine/FileSystem/utils.cpp b/WallpaperEngine/FileSystem/utils.cpp new file mode 100644 index 0000000..425fb81 --- /dev/null +++ b/WallpaperEngine/FileSystem/utils.cpp @@ -0,0 +1,27 @@ +// filesystem includes +#include "utils.h" + +// engine includes +#include "../Irrlicht/Irrlicht.h" + +namespace WallpaperEngine::FileSystem +{ + std::string loadFullFile (irr::io::path file) + { + irr::io::IReadFile* reader = WallpaperEngine::Irrlicht::device->getFileSystem ()->createAndOpenFile (file); + + if (reader == NULL) + throw std::runtime_error ("Cannot open file " + std::string (file.c_str ()) + " for reading"); + + char* filedata = new char [reader->getSize () + 1]; + memset (filedata, 0, reader->getSize () + 1); + + reader->read (filedata, reader->getSize ()); + reader->drop (); + + std::string content = filedata; + delete [] filedata; + + return content; + } +}; \ No newline at end of file diff --git a/WallpaperEngine/FileSystem/utils.h b/WallpaperEngine/FileSystem/utils.h new file mode 100644 index 0000000..b73040b --- /dev/null +++ b/WallpaperEngine/FileSystem/utils.h @@ -0,0 +1,24 @@ +/** + * @author Alexis Maiquez Murcia + */ +#ifndef WALLENGINE_RESOLVER_H +#define WALLENGINE_RESOLVER_H + +#include +#include +#include +#include + +namespace WallpaperEngine::FileSystem +{ + /** + * Loads a full file into an std::string + * + * @param file + * @return + */ + std::string loadFullFile (irr::io::path file); +} + + +#endif //WALLENGINE_RESOLVER_H diff --git a/WallpaperEngine/Irrlicht/CFileList.cpp b/WallpaperEngine/Irrlicht/CFileList.cpp new file mode 100644 index 0000000..01ad29d --- /dev/null +++ b/WallpaperEngine/Irrlicht/CFileList.cpp @@ -0,0 +1,146 @@ +#include + +#include "CFileList.h" + +using namespace WallpaperEngine::Irrlicht; +using namespace irr; + +static const io::path emptyFileListEntry; + +CFileList::CFileList(const io::path& path, bool ignoreCase, bool ignorePaths) + : IgnorePaths(ignorePaths), IgnoreCase(ignoreCase), Path(path) +{ + Path.replace('\\', '/'); +} + +CFileList::~CFileList() +{ + Files.clear(); +} + +u32 CFileList::getFileCount() const +{ + return Files.size(); +} + +void CFileList::sort() +{ + Files.sort(); +} + +const io::path& CFileList::getFileName(u32 index) const +{ + if (index >= Files.size()) + return emptyFileListEntry; + + return Files[index].Name; +} + + +//! Gets the full name of a file in the list, path included, based on an index. +const io::path& CFileList::getFullFileName(u32 index) const +{ + if (index >= Files.size()) + return emptyFileListEntry; + + return Files[index].FullName; +} + +//! adds a file or folder +u32 CFileList::addItem(const io::path& fullPath, u32 offset, u32 size, bool isDirectory, u32 id) +{ + SFileListEntry entry; + entry.ID = id ? id : Files.size(); + entry.Offset = offset; + entry.Size = size; + entry.Name = fullPath; + entry.Name.replace('\\', '/'); + entry.IsDirectory = isDirectory; + + // remove trailing slash + if (entry.Name.lastChar() == '/') + { + entry.IsDirectory = true; + entry.Name[entry.Name.size()-1] = 0; + entry.Name.validate(); + } + + if (IgnoreCase) + entry.Name.make_lower(); + + entry.FullName = entry.Name; + + core::deletePathFromFilename(entry.Name); + + if (IgnorePaths) + entry.FullName = entry.Name; + + //os::Printer::log(Path.c_str(), entry.FullName); + + Files.push_back(entry); + + return Files.size() - 1; +} + +//! Returns the ID of a file in the file list, based on an index. +u32 CFileList::getID(u32 index) const +{ + return index < Files.size() ? Files[index].ID : 0; +} + +bool CFileList::isDirectory(u32 index) const +{ + bool ret = false; + if (index < Files.size()) + ret = Files[index].IsDirectory; + + return ret; +} + +//! Returns the size of a file +u32 CFileList::getFileSize(u32 index) const +{ + return index < Files.size() ? Files[index].Size : 0; +} + +//! Returns the size of a file +u32 CFileList::getFileOffset(u32 index) const +{ + return index < Files.size() ? Files[index].Offset : 0; +} + + +//! Searches for a file or folder within the list, returns the index +s32 CFileList::findFile(const io::path& filename, bool isDirectory = false) const +{ + SFileListEntry entry; + // we only need FullName to be set for the search + entry.FullName = filename; + entry.IsDirectory = isDirectory; + + // exchange + entry.FullName.replace('\\', '/'); + + // remove trailing slash + if (entry.FullName.lastChar() == '/') + { + entry.IsDirectory = true; + entry.FullName[entry.FullName.size()-1] = 0; + entry.FullName.validate(); + } + + if (IgnoreCase) + entry.FullName.make_lower(); + + if (IgnorePaths) + core::deletePathFromFilename(entry.FullName); + + return Files.binary_search(entry); +} + + +//! Returns the base path of the file list +const io::path& CFileList::getPath() const +{ + return Path; +} diff --git a/WallpaperEngine/Irrlicht/CFileList.h b/WallpaperEngine/Irrlicht/CFileList.h new file mode 100644 index 0000000..fe658db --- /dev/null +++ b/WallpaperEngine/Irrlicht/CFileList.h @@ -0,0 +1,123 @@ +#pragma once + +#include + +using namespace irr; + +namespace WallpaperEngine::Irrlicht +{ + //! An entry in a list of files, can be a folder or a file. + struct SFileListEntry + { + //! The name of the file + /** If this is a file or folder in the virtual filesystem and the archive + was created with the ignoreCase flag then the file name will be lower case. */ + io::path Name; + + //! The name of the file including the path + /** If this is a file or folder in the virtual filesystem and the archive was + created with the ignoreDirs flag then it will be the same as Name. */ + io::path FullName; + + //! The size of the file in bytes + u32 Size; + + //! The ID of the file in an archive + /** This is used to link the FileList entry to extra info held about this + file in an archive, which can hold things like data offset and CRC. */ + u32 ID; + + //! FileOffset inside an archive + u32 Offset; + + //! True if this is a folder, false if not. + bool IsDirectory; + + //! The == operator is provided so that CFileList can slowly search the list! + bool operator ==(const struct SFileListEntry& other) const + { + if (IsDirectory != other.IsDirectory) + return false; + + return FullName.equals_ignore_case(other.FullName); + } + + //! The < operator is provided so that CFileList can sort and quickly search the list. + bool operator <(const struct SFileListEntry& other) const + { + if (IsDirectory != other.IsDirectory) + return IsDirectory; + + return FullName.lower_ignore_case(other.FullName); + } + }; + + + //! Implementation of a file list + class CFileList : public io::IFileList + { + public: + + // CFileList methods + + //! Constructor + /** \param path The path of this file archive */ + CFileList(const io::path& path, bool ignoreCase, bool ignorePaths); + + //! Destructor + virtual ~CFileList(); + + //! Add as a file or folder to the list + /** \param fullPath The file name including path, up to the root of the file list. + \param isDirectory True if this is a directory rather than a file. + \param offset The offset where the file is stored in an archive + \param size The size of the file in bytes. + \param id The ID of the file in the archive which owns it */ + virtual u32 addItem(const io::path& fullPath, u32 offset, u32 size, bool isDirectory, u32 id=0); + + //! Sorts the file list. You should call this after adding any items to the file list + virtual void sort(); + + //! Returns the amount of files in the filelist. + virtual u32 getFileCount() const; + + //! Gets the name of a file in the list, based on an index. + virtual const io::path& getFileName(u32 index) const; + + //! Gets the full name of a file in the list, path included, based on an index. + virtual const io::path& getFullFileName(u32 index) const; + + //! Returns the ID of a file in the file list, based on an index. + virtual u32 getID(u32 index) const; + + //! Returns true if the file is a directory + virtual bool isDirectory(u32 index) const; + + //! Returns the size of a file + virtual u32 getFileSize(u32 index) const; + + //! Returns the offest of a file + virtual u32 getFileOffset(u32 index) const; + + //! Searches for a file or folder within the list, returns the index + virtual s32 findFile(const io::path& filename, bool isFolder) const; + + //! Returns the base path of the file list + virtual const io::path& getPath() const; + + protected: + + //! Ignore paths when adding or searching for files + bool IgnorePaths; + + //! Ignore case when adding or searching for files + bool IgnoreCase; + + //! Path to the file list + io::path Path; + + //! List of files + core::array Files; + }; +} + diff --git a/WallpaperEngine/Irrlicht/CImageLoaderTEX.cpp b/WallpaperEngine/Irrlicht/CImageLoaderTEX.cpp new file mode 100644 index 0000000..3566a28 --- /dev/null +++ b/WallpaperEngine/Irrlicht/CImageLoaderTEX.cpp @@ -0,0 +1,549 @@ +#include "CImageLoaderTEX.h" + +#include +#include +#include +#include + +using namespace irr::video; +using namespace WallpaperEngine::Irrlicht; + +//! returns true if the file maybe is able to be loaded by this class +//! based on the file extension (e.g. ".tga") +bool CImageLoaderTex::isALoadableFileExtension (const io::path &filename) const +{ + return core::hasFileExtension (filename, "tex"); +} + + +//! returns true if the file maybe is able to be loaded by this class +bool CImageLoaderTex::isALoadableFileFormat (io::IReadFile *file) const +{ + return false; +} + + +// load in the image data +IImage *CImageLoaderTex::loadImage (io::IReadFile *input) const +{ + if (!input) + return nullptr; + + video::IImage *image = nullptr; + + char buffer [1024]; + + if (input->read (buffer, 9) != 9) + { + WallpaperEngine::Irrlicht::device->getLogger ()->log ("LOAD TEX: cannot read header\n", input->getFileName ().c_str (), irr::ELL_ERROR); + return nullptr; + } + + if (memcmp (buffer, "TEXV0005", 9) != 0) + { + WallpaperEngine::Irrlicht::device->getLogger ()->log ("LOAD TEX: not really a tex\n", input->getFileName ().c_str (), irr::ELL_ERROR); + return nullptr; + } + + if (input->read (buffer, 9) != 9) + { + WallpaperEngine::Irrlicht::device->getLogger ()->log ("LOAD TEX: cannot read second header\n", input->getFileName ().c_str (), irr::ELL_ERROR); + return nullptr; + } + + if (memcmp (buffer, "TEXI0001", 9) != 0) + { + WallpaperEngine::Irrlicht::device->getLogger ()->log ("LOAD TEX: not really a tex\n", input->getFileName ().c_str (), irr::ELL_ERROR); + return nullptr; + } + + u32 width; + u32 height; + u32 texture_width; + u32 texture_height; + u32 format; + u32 imageFormat = FREE_IMAGE_FORMAT::FIF_UNKNOWN; + u8 containerVersion = 0; + + input->read (&format, 4); + input->seek (4, true); // ignore bytes + input->read (&texture_width, 4); + input->read (&texture_height, 4); + input->read (&width, 4); + input->read (&height, 4); + input->seek (4, true); // ignore bytes + input->read (buffer, 9); + + if (memcmp (buffer, "TEXB0003", 9) == 0) + { + containerVersion = 3; + input->seek (4, true); + input->read (&imageFormat, 4); + } + else if (memcmp (buffer, "TEXB0002", 9) == 0) + { + containerVersion = 2; + + input->seek (4, true); + } + else if (memcmp (buffer, "TEXB0001", 9) == 0) + { + containerVersion = 1; + input->seek (4, true); + } + else + { + WallpaperEngine::Irrlicht::device->getLogger ()->log ("LOAD TEX: Unknown container type\n", input->getFileName ().c_str (), irr::ELL_ERROR); + return nullptr; + } + + if (format == TextureFormat::A8) + { + WallpaperEngine::Irrlicht::device->getLogger ()-> log ("LOAD TEX: A8 not supported\n", input->getFileName ().c_str (), irr::ELL_ERROR); + return nullptr; + } + + if (format == TextureFormat::RA88) + { + WallpaperEngine::Irrlicht::device->getLogger ()->log ("LOAD TEX: RA88 not supported\n", input->getFileName ().c_str (), irr::ELL_ERROR); + return nullptr; + } + + u32 mipmap_count = 0; + + input->read (&mipmap_count, 4); + + u32 mipmap_width = 0; + u32 mipmap_height = 0; + u32 mipmap_compression = 0; + u32 mipmap_uncompressed_size = 0; + u32 mipmap_compressed_size = 0; + + input->read (&mipmap_width, 4); + input->read (&mipmap_height, 4); + + if (containerVersion > 1) + { + input->read (&mipmap_compression, 4); + input->read (&mipmap_uncompressed_size, 4); + } + + input->read (&mipmap_compressed_size, 4); + + // TODO: BETTER POSITION FOR THIS + if (mipmap_compression == 0) + { + // this might be better named as mipmap_bytes_size instead of compressed_size + // as in uncompressed files this variable actually holds the file length + mipmap_uncompressed_size = mipmap_compressed_size; + } + + char *decompressedBuffer = new char [mipmap_uncompressed_size]; + + if (mipmap_compression == 1) + { + char *compressedBuffer = new char [mipmap_compressed_size]; + + input->read (compressedBuffer, mipmap_compressed_size); + + int result = LZ4_decompress_safe (compressedBuffer, decompressedBuffer, mipmap_compressed_size, mipmap_uncompressed_size); + + if (!result) + { + delete [] decompressedBuffer; + delete [] compressedBuffer; + WallpaperEngine::Irrlicht::device->getLogger ()->log ("LOAD TEX: cannot decompress texture data\n", input->getFileName ().c_str (), irr::ELL_ERROR); + return nullptr; + } + + delete [] compressedBuffer; + } + else + { + input->read (decompressedBuffer, mipmap_uncompressed_size); + } + + if (imageFormat == FREE_IMAGE_FORMAT::FIF_UNKNOWN) + { + image = WallpaperEngine::Irrlicht::driver->createImage (ECF_A8R8G8B8, irr::core::dimension2d (width, height)); + + if (!image) + { + delete [] decompressedBuffer; + delete image; + WallpaperEngine::Irrlicht::device->getLogger ()->log ("LOAD TEX: cannot create destination image\n", input->getFileName ().c_str (), irr::ELL_ERROR); + return nullptr; + } + + switch (format) + { + case TextureFormat::ARGB8888: + this->loadImageFromARGB8Data (image, decompressedBuffer, width, height, mipmap_width); + break; + case TextureFormat::DXT5: + this->loadImageFromDXT5 (image, decompressedBuffer, width, height, mipmap_width, mipmap_height); + break; + case TextureFormat::DXT1: + this->loadImageFromDXT1 (image, decompressedBuffer, width, height, mipmap_width, mipmap_height); + break; + case TextureFormat::DXT3: + WallpaperEngine::Irrlicht::device->getLogger ()->log ("LOAD TEX: DXT3 textures not supported yet\n", input->getFileName ().c_str (), irr::ELL_ERROR); + delete [] decompressedBuffer; + delete image; + return nullptr; + } + } + else + { + // copy the buffer to a new address + char* filebuffer = new char [mipmap_uncompressed_size]; + char tmpname [TMP_MAX]; + + // copy file data to the final file buffer to be used + memcpy (filebuffer, decompressedBuffer, mipmap_uncompressed_size); + // generate temporal name + std::tmpnam (tmpname); + // store it in a std::string + std::string filename = tmpname; + irr::io::IReadFile* file; + + // free image format + switch (imageFormat) + { + case FREE_IMAGE_FORMAT::FIF_BMP: + // add extension to the file + filename += ".bmp"; + file = WallpaperEngine::Irrlicht::device->getFileSystem ()->createMemoryReadFile (filebuffer, mipmap_uncompressed_size, filename.c_str (), true); + break; + case FREE_IMAGE_FORMAT::FIF_PNG: + // add extension to the file + filename += ".png"; + file = WallpaperEngine::Irrlicht::device->getFileSystem ()->createMemoryReadFile (filebuffer, mipmap_uncompressed_size, filename.c_str (), true); + break; + case FREE_IMAGE_FORMAT::FIF_JPEG: + // add extension to the file + filename += ".jpg"; + WallpaperEngine::Irrlicht::device->getFileSystem ()->createAndWriteFile ("/tmp/test.jpg", false)->write (filebuffer, mipmap_uncompressed_size); + file = WallpaperEngine::Irrlicht::device->getFileSystem ()->createMemoryReadFile (filebuffer, mipmap_uncompressed_size, filename.c_str (), true); + break; + case FREE_IMAGE_FORMAT::FIF_GIF: + filename += ".gif"; + file = WallpaperEngine::Irrlicht::device->getFileSystem ()->createMemoryReadFile (filebuffer, mipmap_uncompressed_size, filename.c_str (), true); + break; + default: + WallpaperEngine::Irrlicht::device->getLogger ()->log ("LOAD TEX: detected unsupported free-image format\n", input->getFileName ().c_str (), irr::ELL_ERROR); + delete [] decompressedBuffer; + delete [] filebuffer; + return nullptr; + } + + image = WallpaperEngine::Irrlicht::driver->createImageFromFile (file); + + if (!image) + { + file->drop (); + + delete [] decompressedBuffer; + delete image; + WallpaperEngine::Irrlicht::device->getLogger ()->log ("LOAD TEX: cannot create destination image\n", input->getFileName ().c_str (), irr::ELL_ERROR); + return nullptr; + } + } + + delete [] decompressedBuffer; + + return image; +} + +void CImageLoaderTex::loadImageFromARGB8Data (IImage* output, const char* input, u32 width, u32 height, u32 mipmap_width) const +{ + u32 bytesPerPixel = output->getBytesPerPixel (); + char *imagedata = (char *) output->lock (); + + for (u32 y = 0; y < height; y ++) + { + u32 baseDestination = y * output->getPitch (); + u32 baseOrigin = y * (mipmap_width * 4); + + for (u32 x = 0; x < width; x ++) + { + imagedata [baseDestination + (x * bytesPerPixel) + 2] = input [baseOrigin + ((width - x) * 4) + 0]; // r + imagedata [baseDestination + (x * bytesPerPixel) + 1] = input [baseOrigin + ((width - x) * 4) + 1]; // g + imagedata [baseDestination + (x * bytesPerPixel) + 0] = input [baseOrigin + ((width - x) * 4) + 2]; // b + imagedata [baseDestination + (x * bytesPerPixel) + 3] = input [baseOrigin + ((width - x) * 4) + 3]; // alpha + } + } + + output->unlock (); +} + +void CImageLoaderTex::loadImageFromDXT1 (IImage* output, const char* input, u32 destination_width, u32 destination_height, u32 origin_width, u32 origin_height) const +{ + char* decompressedBuffer = new char [origin_width * origin_height * 4]; + + this->BlockDecompressImageDXT1 (origin_width, origin_height, (const unsigned char*) input, (unsigned long*) decompressedBuffer); + this->loadImageFromARGB8Data (output, decompressedBuffer, destination_width, destination_height, origin_width); + + delete [] decompressedBuffer; +} + +void CImageLoaderTex::loadImageFromDXT5 (IImage* output, const char* input, u32 destination_width, u32 destination_height, u32 origin_width, u32 origin_height) const +{ + char* decompressedBuffer = new char [origin_width * origin_height * 4]; + + this->BlockDecompressImageDXT5 (origin_width, origin_height, (const unsigned char*) input, (unsigned long*) decompressedBuffer); + this->loadImageFromARGB8Data (output, decompressedBuffer, destination_width, destination_height, origin_width); + + delete [] decompressedBuffer; +} + +// ------------------------------------------------------------------------------------ +// The following code is a slightly modified version of this repository +// https://github.com/Benjamin-Dobell/s3tc-dxt-decompression +// ------------------------------------------------------------------------------------ + +// unsigned long PackRGBA(): Helper method that packs RGBA channels into a single 4 byte pixel. +// +// unsigned char r: red channel. +// unsigned char g: green channel. +// unsigned char b: blue channel. +// unsigned char a: alpha channel. + +unsigned long CImageLoaderTex::PackRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a) const +{ + return ((r << 24) | (g << 16) | (b << 8) | a); +} + +// void DecompressBlockDXT1(): Decompresses one block of a DXT1 texture and stores the resulting pixels at the appropriate offset in 'image'. +// +// unsigned long x: x-coordinate of the first pixel in the block. +// unsigned long y: y-coordinate of the first pixel in the block. +// unsigned long width: width of the texture being decompressed. +// unsigned long height: height of the texture being decompressed. +// const unsigned char *blockStorage: pointer to the block to decompress. +// unsigned long *image: pointer to image where the decompressed pixel data should be stored. + +void CImageLoaderTex::DecompressBlockDXT1(unsigned long x, unsigned long y, unsigned long width, const unsigned char *blockStorage, unsigned long *image) const +{ + unsigned short color0 = *reinterpret_cast(blockStorage); + unsigned short color1 = *reinterpret_cast(blockStorage + 2); + + unsigned long temp; + + temp = (color0 >> 11) * 255 + 16; + unsigned char r0 = (unsigned char)((temp/32 + temp)/32); + temp = ((color0 & 0x07E0) >> 5) * 255 + 32; + unsigned char g0 = (unsigned char)((temp/64 + temp)/64); + temp = (color0 & 0x001F) * 255 + 16; + unsigned char b0 = (unsigned char)((temp/32 + temp)/32); + + temp = (color1 >> 11) * 255 + 16; + unsigned char r1 = (unsigned char)((temp/32 + temp)/32); + temp = ((color1 & 0x07E0) >> 5) * 255 + 32; + unsigned char g1 = (unsigned char)((temp/64 + temp)/64); + temp = (color1 & 0x001F) * 255 + 16; + unsigned char b1 = (unsigned char)((temp/32 + temp)/32); + + unsigned long code = *reinterpret_cast(blockStorage + 4); + + for (int j=0; j < 4; j++) + { + for (int i=0; i < 4; i++) + { + unsigned long finalColor = 0; + unsigned char positionCode = (code >> 2*(4*j+i)) & 0x03; + + if (color0 > color1) + { + switch (positionCode) + { + case 0: + finalColor = PackRGBA(r0, g0, b0, 255); + break; + case 1: + finalColor = PackRGBA(r1, g1, b1, 255); + break; + case 2: + finalColor = PackRGBA((2*r0+r1)/3, (2*g0+g1)/3, (2*b0+b1)/3, 255); + break; + case 3: + finalColor = PackRGBA((r0+2*r1)/3, (g0+2*g1)/3, (b0+2*b1)/3, 255); + break; + } + } + else + { + switch (positionCode) + { + case 0: + finalColor = PackRGBA(r0, g0, b0, 255); + break; + case 1: + finalColor = PackRGBA(r1, g1, b1, 255); + break; + case 2: + finalColor = PackRGBA((r0+r1)/2, (g0+g1)/2, (b0+b1)/2, 255); + break; + case 3: + finalColor = PackRGBA(0, 0, 0, 255); + break; + } + } + + if (x + i < width) + image[(y + j)*width + (x + i)] = finalColor; + } + } +} + +// void BlockDecompressImageDXT1(): Decompresses all the blocks of a DXT1 compressed texture and stores the resulting pixels in 'image'. +// +// unsigned long width: Texture width. +// unsigned long height: Texture height. +// const unsigned char *blockStorage: pointer to compressed DXT1 blocks. +// unsigned long *image: pointer to the image where the decompressed pixels will be stored. + +void CImageLoaderTex::BlockDecompressImageDXT1(unsigned long width, unsigned long height, const unsigned char *blockStorage, unsigned long *image) const +{ + unsigned long blockCountX = (width + 3) / 4; + unsigned long blockCountY = (height + 3) / 4; + unsigned long blockWidth = (width < 4) ? width : 4; + unsigned long blockHeight = (height < 4) ? height : 4; + + for (unsigned long j = 0; j < blockCountY; j++) + { + for (unsigned long i = 0; i < blockCountX; i++) DecompressBlockDXT1(i*4, j*4, width, blockStorage + i * 8, image); + blockStorage += blockCountX * 8; + } +} + +// void DecompressBlockDXT5(): Decompresses one block of a DXT5 texture and stores the resulting pixels at the appropriate offset in 'image'. +// +// unsigned long x: x-coordinate of the first pixel in the block. +// unsigned long y: y-coordinate of the first pixel in the block. +// unsigned long width: width of the texture being decompressed. +// unsigned long height: height of the texture being decompressed. +// const unsigned char *blockStorage: pointer to the block to decompress. +// unsigned long *image: pointer to image where the decompressed pixel data should be stored. + +void CImageLoaderTex::DecompressBlockDXT5(unsigned long x, unsigned long y, unsigned long width, const unsigned char *blockStorage, unsigned long *image) const +{ + unsigned char alpha0 = *reinterpret_cast(blockStorage); + unsigned char alpha1 = *reinterpret_cast(blockStorage + 1); + + const unsigned char *bits = blockStorage + 2; + unsigned long alphaCode1 = bits[2] | (bits[3] << 8) | (bits[4] << 16) | (bits[5] << 24); + unsigned short alphaCode2 = bits[0] | (bits[1] << 8); + + unsigned short color0 = *reinterpret_cast(blockStorage + 8); + unsigned short color1 = *reinterpret_cast(blockStorage + 10); + + unsigned long temp; + + temp = (color0 >> 11) * 255 + 16; + unsigned char r0 = (unsigned char)((temp/32 + temp)/32); + temp = ((color0 & 0x07E0) >> 5) * 255 + 32; + unsigned char g0 = (unsigned char)((temp/64 + temp)/64); + temp = (color0 & 0x001F) * 255 + 16; + unsigned char b0 = (unsigned char)((temp/32 + temp)/32); + + temp = (color1 >> 11) * 255 + 16; + unsigned char r1 = (unsigned char)((temp/32 + temp)/32); + temp = ((color1 & 0x07E0) >> 5) * 255 + 32; + unsigned char g1 = (unsigned char)((temp/64 + temp)/64); + temp = (color1 & 0x001F) * 255 + 16; + unsigned char b1 = (unsigned char)((temp/32 + temp)/32); + + unsigned long code = *reinterpret_cast(blockStorage + 12); + + for (int j=0; j < 4; j++) + { + for (int i=0; i < 4; i++) + { + int alphaCodeIndex = 3*(4*j+i); + int alphaCode; + + if (alphaCodeIndex <= 12) + { + alphaCode = (alphaCode2 >> alphaCodeIndex) & 0x07; + } + else if (alphaCodeIndex == 15) + { + alphaCode = (alphaCode2 >> 15) | ((alphaCode1 << 1) & 0x06); + } + else // alphaCodeIndex >= 18 && alphaCodeIndex <= 45 + { + alphaCode = (alphaCode1 >> (alphaCodeIndex - 16)) & 0x07; + } + + unsigned char finalAlpha; + if (alphaCode == 0) + { + finalAlpha = alpha0; + } + else if (alphaCode == 1) + { + finalAlpha = alpha1; + } + else + { + if (alpha0 > alpha1) + { + finalAlpha = ((8-alphaCode)*alpha0 + (alphaCode-1)*alpha1)/7; + } + else + { + if (alphaCode == 6) + finalAlpha = 0; + else if (alphaCode == 7) + finalAlpha = 255; + else + finalAlpha = ((6-alphaCode)*alpha0 + (alphaCode-1)*alpha1)/5; + } + } + + unsigned char colorCode = (code >> 2*(4*j+i)) & 0x03; + + unsigned long finalColor; + switch (colorCode) + { + case 0: + finalColor = PackRGBA(r0, g0, b0, finalAlpha); + break; + case 1: + finalColor = PackRGBA(r1, g1, b1, finalAlpha); + break; + case 2: + finalColor = PackRGBA((2*r0+r1)/3, (2*g0+g1)/3, (2*b0+b1)/3, finalAlpha); + break; + case 3: + finalColor = PackRGBA((r0+2*r1)/3, (g0+2*g1)/3, (b0+2*b1)/3, finalAlpha); + break; + } + + if (x + i < width) + image[(y + j)*width + (x + i)] = finalColor; + } + } +} + +// void BlockDecompressImageDXT5(): Decompresses all the blocks of a DXT5 compressed texture and stores the resulting pixels in 'image'. +// +// unsigned long width: Texture width. +// unsigned long height: Texture height. +// const unsigned char *blockStorage: pointer to compressed DXT5 blocks. +// unsigned long *image: pointer to the image where the decompressed pixels will be stored. + +void CImageLoaderTex::BlockDecompressImageDXT5(unsigned long width, unsigned long height, const unsigned char *blockStorage, unsigned long *image) const +{ + unsigned long blockCountX = (width + 3) / 4; + unsigned long blockCountY = (height + 3) / 4; + unsigned long blockWidth = (width < 4) ? width : 4; + unsigned long blockHeight = (height < 4) ? height : 4; + + for (unsigned long j = 0; j < blockCountY; j++) + { + for (unsigned long i = 0; i < blockCountX; i++) DecompressBlockDXT5(i*4, j*4, width, blockStorage + i * 16, image); + blockStorage += blockCountX * 16; + } +} diff --git a/WallpaperEngine/Irrlicht/CImageLoaderTEX.h b/WallpaperEngine/Irrlicht/CImageLoaderTEX.h new file mode 100644 index 0000000..8ec2848 --- /dev/null +++ b/WallpaperEngine/Irrlicht/CImageLoaderTEX.h @@ -0,0 +1,91 @@ +#pragma once + +#include + +using namespace irr; +using namespace irr::video; + +namespace WallpaperEngine::Irrlicht +{ + //! Surface Loader for PNG files + class CImageLoaderTex : public IImageLoader + { + public: + + //! returns true if the file maybe is able to be loaded by this class + //! based on the file extension (e.g. ".png") + virtual bool isALoadableFileExtension(const io::path& filename) const; + + //! returns true if the file maybe is able to be loaded by this class + virtual bool isALoadableFileFormat(io::IReadFile* file) const; + + //! creates a surface from the file + virtual IImage* loadImage(io::IReadFile* input) const; + + virtual void loadImageFromARGB8Data (IImage* output, const char* input, u32 width, u32 height, u32 mipmap_width) const; + + virtual void loadImageFromDXT1 (IImage* output, const char* input, u32 destination_width, u32 destination_height, u32 origin_width, u32 origin_height) const; + virtual void loadImageFromDXT5 (IImage* output, const char* input, u32 destination_width, u32 destination_height, u32 origin_width, u32 origin_height) const; + + private: + void BlockDecompressImageDXT1(unsigned long width, unsigned long height, const unsigned char *blockStorage, unsigned long *image) const; + void DecompressBlockDXT1(unsigned long x, unsigned long y, unsigned long width, const unsigned char *blockStorage, unsigned long *image) const; + unsigned long PackRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a) const; + void BlockDecompressImageDXT5(unsigned long width, unsigned long height, const unsigned char *blockStorage, unsigned long *image) const; + void DecompressBlockDXT5(unsigned long x, unsigned long y, unsigned long width, const unsigned char *blockStorage, unsigned long *image) const; + + enum TextureFormat + { + ARGB8888, + RA88, + A8, + DXT5, + DXT3, + DXT1 + }; + + // extracted from the free image library + enum FREE_IMAGE_FORMAT + { + FIF_UNKNOWN = -1, + FIF_BMP = 0, + FIF_ICO = 1, + FIF_JPEG = 2, + FIF_JNG = 3, + FIF_KOALA = 4, + FIF_LBM = 5, + FIF_IFF = FIF_LBM, + FIF_MNG = 6, + FIF_PBM = 7, + FIF_PBMRAW = 8, + FIF_PCD = 9, + FIF_PCX = 10, + FIF_PGM = 11, + FIF_PGMRAW = 12, + FIF_PNG = 13, + FIF_PPM = 14, + FIF_PPMRAW = 15, + FIF_RAS = 16, + FIF_TARGA = 17, + FIF_TIFF = 18, + FIF_WBMP = 19, + FIF_PSD = 20, + FIF_CUT = 21, + FIF_XBM = 22, + FIF_XPM = 23, + FIF_DDS = 24, + FIF_GIF = 25, + FIF_HDR = 26, + FIF_FAXG3 = 27, + FIF_SGI = 28, + FIF_EXR = 29, + FIF_J2K = 30, + FIF_JP2 = 31, + FIF_PFM = 32, + FIF_PICT = 33, + FIF_RAW = 34, + FIF_WEBP = 35, + FIF_JXR = 36 + }; + }; +} diff --git a/WallpaperEngine/irr/CPkgReader.cpp b/WallpaperEngine/Irrlicht/CPkgReader.cpp similarity index 95% rename from WallpaperEngine/irr/CPkgReader.cpp rename to WallpaperEngine/Irrlicht/CPkgReader.cpp index f94dc29..4440ecd 100644 --- a/WallpaperEngine/irr/CPkgReader.cpp +++ b/WallpaperEngine/Irrlicht/CPkgReader.cpp @@ -1,10 +1,8 @@ -// -// Created by almamu on 4/04/19. -// - -#include +#include #include "CPkgReader.h" +using namespace WallpaperEngine::Irrlicht; + CArchiveLoaderPkg::CArchiveLoaderPkg(irr::io::IFileSystem* fs) : FileSystem(fs) { @@ -123,7 +121,7 @@ void CPkgReader::scanPkgHeader () if (strcmp ("PKGV0002", headerVersion) != 0 && strcmp ("PKGV0001", headerVersion) != 0) { - WallpaperEngine::irrlicht::device->getLogger ()->log ("Unexpected package header... Aborting load", this->mFile->getFileName ().c_str (), irr::ELL_ERROR); + WallpaperEngine::Irrlicht::device->getLogger ()->log ("Unexpected package header... Aborting load", this->mFile->getFileName ().c_str (), irr::ELL_ERROR); delete [] headerVersion; return; @@ -189,6 +187,6 @@ irr::io::IReadFile* CPkgReader::createAndOpenFile (irr::u32 index) if (index > this->Files.size ()) return nullptr; - const irr::io::SFileListEntry entry = Files [index]; + const SFileListEntry entry = Files [index]; return irr::io::createLimitReadFile (entry.FullName, mFile, entry.Offset, entry.Size); } \ No newline at end of file diff --git a/WallpaperEngine/Irrlicht/CPkgReader.h b/WallpaperEngine/Irrlicht/CPkgReader.h new file mode 100644 index 0000000..a5feb65 --- /dev/null +++ b/WallpaperEngine/Irrlicht/CPkgReader.h @@ -0,0 +1,79 @@ +#pragma once +#include +#include + +#include "CFileList.h" + +using namespace irr; + +namespace WallpaperEngine::Irrlicht +{ +//! Archiveloader capable of loading WAD Archives + class CArchiveLoaderPkg : public irr::io::IArchiveLoader + { + public: + + //! Constructor + CArchiveLoaderPkg(irr::io::IFileSystem *fs); + + //! returns true if the file maybe is able to be loaded by this class + //! based on the file extension (e.g. ".zip") + virtual bool isALoadableFileFormat(const irr::io::path &filename) const; + + //! Check if the file might be loaded by this class + /** Check might look into the file. + \param file File handle to check. + \return True if file seems to be loadable. */ + virtual bool isALoadableFileFormat(irr::io::IReadFile *file) const; + + //! Check to see if the loader can create archives of this type. + /** Check based on the archive type. + \param fileType The archive type to check. + \return True if the archile loader supports this type, false if not */ + virtual bool isALoadableFileFormat(irr::io::E_FILE_ARCHIVE_TYPE fileType) const; + + //! Creates an archive from the filename + /** \param file File handle to check. + \return Pointer to newly created archive, or 0 upon error. */ + virtual irr::io::IFileArchive * + createArchive(const irr::io::path &filename, bool ignoreCase, bool ignorePaths) const; + + //! creates/loads an archive from the file. + //! \return Pointer to the created archive. Returns 0 if loading failed. + virtual irr::io::IFileArchive *createArchive(irr::io::IReadFile *file, bool ignoreCase, bool ignorePaths) const; + + private: + irr::io::IFileSystem *FileSystem; + }; + + class CPkgReader : public virtual irr::io::IFileArchive, virtual CFileList + { + public: + + //! constructor + CPkgReader(irr::io::IReadFile *file, bool ignoreCase, bool ignorePaths); + + //! destructor + virtual ~CPkgReader(); + + //! opens a file by file name + virtual irr::io::IReadFile *createAndOpenFile(const irr::io::path &filename); + + //! opens a file by index + virtual irr::io::IReadFile *createAndOpenFile(unsigned int index); + + //! returns the list of files + virtual const IFileList *getFileList() const; + + //! get the archive type + virtual irr::io::E_FILE_ARCHIVE_TYPE getType() const; + + protected: + void scanPkgHeader(); + + char *readSizedString(); + + irr::io::IFileSystem *mFileSystem; + irr::io::IReadFile *mFile; + }; +} \ No newline at end of file diff --git a/WallpaperEngine/Irrlicht/Irrlicht.cpp b/WallpaperEngine/Irrlicht/Irrlicht.cpp new file mode 100644 index 0000000..0304b10 --- /dev/null +++ b/WallpaperEngine/Irrlicht/Irrlicht.cpp @@ -0,0 +1,8 @@ +#include + +namespace WallpaperEngine::Irrlicht +{ + irr::video::IVideoDriver* driver = nullptr; + irr::IrrlichtDevice* device = nullptr; + irr::scene::ICameraSceneNode* camera = nullptr; +} \ No newline at end of file diff --git a/WallpaperEngine/Irrlicht/Irrlicht.h b/WallpaperEngine/Irrlicht/Irrlicht.h new file mode 100644 index 0000000..62bc948 --- /dev/null +++ b/WallpaperEngine/Irrlicht/Irrlicht.h @@ -0,0 +1,10 @@ +#pragma once + +#include + +namespace WallpaperEngine::Irrlicht +{ + extern irr::video::IVideoDriver* driver; + extern irr::IrrlichtDevice* device; + extern irr::scene::ICameraSceneNode* camera; +}; \ No newline at end of file diff --git a/WallpaperEngine/effect.cpp b/WallpaperEngine/effect.cpp index 7bf2659..7abffad 100644 --- a/WallpaperEngine/effect.cpp +++ b/WallpaperEngine/effect.cpp @@ -2,7 +2,7 @@ #include "shaders/compiler.h" #include "effect.h" -#include "irrlicht.h" +#include "WallpaperEngine/Irrlicht/Irrlicht.h" #include "WallpaperEngine/Core/Core.h" extern irr::f32 g_Time; @@ -57,7 +57,7 @@ namespace WallpaperEngine } } - this->m_content = WallpaperEngine::fs::utils::loadFullFile (this->m_file); + this->m_content = WallpaperEngine::FileSystem::loadFullFile (this->m_file); this->m_json = json::parse (this->m_content); json::const_iterator passes = this->m_json.find ("passes"); @@ -76,7 +76,7 @@ namespace WallpaperEngine continue; irr::io::path material = (*material_it).get ().c_str (); - std::string content = WallpaperEngine::fs::utils::loadFullFile (material); + std::string content = WallpaperEngine::FileSystem::loadFullFile (material); json material_json = json::parse (content); json::const_iterator shader_passes = material_json.find ("passes"); @@ -97,7 +97,7 @@ namespace WallpaperEngine this->m_fragShader = new WallpaperEngine::shaders::compiler (fragpath, WallpaperEngine::shaders::compiler::Type::Type_Pixel, &this->m_combos, false); this->m_vertShader = new WallpaperEngine::shaders::compiler (vertpath, WallpaperEngine::shaders::compiler::Type::Type_Vertex, &this->m_combos, false); - this->m_materialType = WallpaperEngine::irrlicht::driver->getGPUProgrammingServices () + this->m_materialType = WallpaperEngine::Irrlicht::driver->getGPUProgrammingServices () ->addHighLevelShaderMaterial ( this->m_vertShader->precompile ().c_str (), "main", irr::video::EVST_VS_2_0, this->m_fragShader->precompile ().c_str (), "main", irr::video::EPST_PS_2_0, @@ -336,7 +336,7 @@ namespace WallpaperEngine } else { - WallpaperEngine::irrlicht::device->getLogger ()->log ("Unknown type for combo value", name.c_str (), irr::ELL_ERROR); + WallpaperEngine::Irrlicht::device->getLogger ()->log ("Unknown type for combo value", name.c_str (), irr::ELL_ERROR); } } } diff --git a/WallpaperEngine/fs/utils.cpp b/WallpaperEngine/fs/utils.cpp deleted file mode 100644 index 9a820a2..0000000 --- a/WallpaperEngine/fs/utils.cpp +++ /dev/null @@ -1,33 +0,0 @@ -#include -#include - -// filesystem includes -#include - -// engine includes -#include - -namespace WallpaperEngine -{ - namespace fs - { - std::string utils::loadFullFile (irr::io::path file) - { - irr::io::IReadFile* reader = WallpaperEngine::irrlicht::device->getFileSystem ()->createAndOpenFile (file); - - if (reader == NULL) - throw std::runtime_error ("Cannot open file " + std::string (file.c_str ()) + " for reading"); - - char* filedata = new char [reader->getSize () + 1]; - memset (filedata, 0, reader->getSize () + 1); - - reader->read (filedata, reader->getSize ()); - reader->drop (); - - std::string content = filedata; - delete [] filedata; - - return content; - } - } -} \ No newline at end of file diff --git a/WallpaperEngine/fs/utils.h b/WallpaperEngine/fs/utils.h deleted file mode 100644 index a7a2789..0000000 --- a/WallpaperEngine/fs/utils.h +++ /dev/null @@ -1,36 +0,0 @@ -/** - * @author Alexis Maiquez Murcia - */ -#ifndef WALLENGINE_RESOLVER_H -#define WALLENGINE_RESOLVER_H - -#include -#include -#include -#include - -namespace WallpaperEngine -{ - using json = nlohmann::json; - - namespace fs - { - /** - * Custom file resolver to limit our searches to specific folders - */ - class utils - { - public: - /** - * Loads a full file into an std::string - * - * @param file - * @return - */ - static std::string loadFullFile (irr::io::path file); - }; - }; -} - - -#endif //WALLENGINE_RESOLVER_H diff --git a/WallpaperEngine/image.cpp b/WallpaperEngine/image.cpp index 8f11bcd..01b5bb7 100644 --- a/WallpaperEngine/image.cpp +++ b/WallpaperEngine/image.cpp @@ -5,7 +5,7 @@ #include #include -#include +#include #include namespace WallpaperEngine @@ -27,7 +27,7 @@ namespace WallpaperEngine if (file_it != json_data.end () && (*file_it).is_string () == true) { this->m_file = (*file_it).get ().c_str (); - this->m_content = WallpaperEngine::fs::utils::loadFullFile (this->m_file); + this->m_content = WallpaperEngine::FileSystem::loadFullFile (this->m_file); json content = json::parse (this->m_content); json::const_iterator it = content.find ("material"); @@ -35,7 +35,7 @@ namespace WallpaperEngine if (it != content.end () && (*it).is_string () == true) { irr::io::path materialfile = (*it).get ().c_str (); - std::string texturejson_content = WallpaperEngine::fs::utils::loadFullFile (materialfile); + std::string texturejson_content = WallpaperEngine::FileSystem::loadFullFile (materialfile); json materialcontent = json::parse (texturejson_content); // now try to read the texture if any @@ -153,8 +153,8 @@ namespace WallpaperEngine 0, 1, 2, 3 }; - WallpaperEngine::irrlicht::driver->setMaterial (this->getMaterial ()); - WallpaperEngine::irrlicht::driver->drawVertexPrimitiveList (this->m_vertices, 4, indices, 1, irr::video::EVT_STANDARD, irr::scene::EPT_QUADS, irr::video::EIT_16BIT); + WallpaperEngine::Irrlicht::driver->setMaterial (this->getMaterial ()); + WallpaperEngine::Irrlicht::driver->drawVertexPrimitiveList (this->m_vertices, 4, indices, 1, irr::video::EVT_STANDARD, irr::scene::EPT_QUADS, irr::video::EIT_16BIT); } } \ No newline at end of file diff --git a/WallpaperEngine/irr/CFileList.cpp b/WallpaperEngine/irr/CFileList.cpp deleted file mode 100644 index 62348a5..0000000 --- a/WallpaperEngine/irr/CFileList.cpp +++ /dev/null @@ -1,157 +0,0 @@ -// Copyright (C) 2002-2012 Nikolaus Gebhardt -// This file is part of the "Irrlicht Engine". -// For conditions of distribution and use, see copyright notice in irrlicht.h - -#include - -#include "CFileList.h" - -namespace irr -{ - namespace io - { - - static const io::path emptyFileListEntry; - - CFileList::CFileList(const io::path& path, bool ignoreCase, bool ignorePaths) - : IgnorePaths(ignorePaths), IgnoreCase(ignoreCase), Path(path) - { - Path.replace('\\', '/'); - } - - CFileList::~CFileList() - { - Files.clear(); - } - - u32 CFileList::getFileCount() const - { - return Files.size(); - } - - void CFileList::sort() - { - Files.sort(); - } - - const io::path& CFileList::getFileName(u32 index) const - { - if (index >= Files.size()) - return emptyFileListEntry; - - return Files[index].Name; - } - - -//! Gets the full name of a file in the list, path included, based on an index. - const io::path& CFileList::getFullFileName(u32 index) const - { - if (index >= Files.size()) - return emptyFileListEntry; - - return Files[index].FullName; - } - -//! adds a file or folder - u32 CFileList::addItem(const io::path& fullPath, u32 offset, u32 size, bool isDirectory, u32 id) - { - SFileListEntry entry; - entry.ID = id ? id : Files.size(); - entry.Offset = offset; - entry.Size = size; - entry.Name = fullPath; - entry.Name.replace('\\', '/'); - entry.IsDirectory = isDirectory; - - // remove trailing slash - if (entry.Name.lastChar() == '/') - { - entry.IsDirectory = true; - entry.Name[entry.Name.size()-1] = 0; - entry.Name.validate(); - } - - if (IgnoreCase) - entry.Name.make_lower(); - - entry.FullName = entry.Name; - - core::deletePathFromFilename(entry.Name); - - if (IgnorePaths) - entry.FullName = entry.Name; - - //os::Printer::log(Path.c_str(), entry.FullName); - - Files.push_back(entry); - - return Files.size() - 1; - } - -//! Returns the ID of a file in the file list, based on an index. - u32 CFileList::getID(u32 index) const - { - return index < Files.size() ? Files[index].ID : 0; - } - - bool CFileList::isDirectory(u32 index) const - { - bool ret = false; - if (index < Files.size()) - ret = Files[index].IsDirectory; - - return ret; - } - -//! Returns the size of a file - u32 CFileList::getFileSize(u32 index) const - { - return index < Files.size() ? Files[index].Size : 0; - } - -//! Returns the size of a file - u32 CFileList::getFileOffset(u32 index) const - { - return index < Files.size() ? Files[index].Offset : 0; - } - - -//! Searches for a file or folder within the list, returns the index - s32 CFileList::findFile(const io::path& filename, bool isDirectory = false) const - { - SFileListEntry entry; - // we only need FullName to be set for the search - entry.FullName = filename; - entry.IsDirectory = isDirectory; - - // exchange - entry.FullName.replace('\\', '/'); - - // remove trailing slash - if (entry.FullName.lastChar() == '/') - { - entry.IsDirectory = true; - entry.FullName[entry.FullName.size()-1] = 0; - entry.FullName.validate(); - } - - if (IgnoreCase) - entry.FullName.make_lower(); - - if (IgnorePaths) - core::deletePathFromFilename(entry.FullName); - - return Files.binary_search(entry); - } - - -//! Returns the base path of the file list - const io::path& CFileList::getPath() const - { - return Path; - } - - - } // end namespace irr -} // end namespace io - diff --git a/WallpaperEngine/irr/CFileList.h b/WallpaperEngine/irr/CFileList.h deleted file mode 100644 index 2483b6c..0000000 --- a/WallpaperEngine/irr/CFileList.h +++ /dev/null @@ -1,136 +0,0 @@ -// Copyright (C) 2002-2012 Nikolaus Gebhardt -// This file is part of the "Irrlicht Engine". -// For conditions of distribution and use, see copyright notice in irrlicht.h - -#ifndef __C_FILE_LIST_H_INCLUDED__ -#define __C_FILE_LIST_H_INCLUDED__ - -#include - - -namespace irr -{ -namespace io -{ - -//! An entry in a list of files, can be a folder or a file. -struct SFileListEntry -{ - //! The name of the file - /** If this is a file or folder in the virtual filesystem and the archive - was created with the ignoreCase flag then the file name will be lower case. */ - io::path Name; - - //! The name of the file including the path - /** If this is a file or folder in the virtual filesystem and the archive was - created with the ignoreDirs flag then it will be the same as Name. */ - io::path FullName; - - //! The size of the file in bytes - u32 Size; - - //! The ID of the file in an archive - /** This is used to link the FileList entry to extra info held about this - file in an archive, which can hold things like data offset and CRC. */ - u32 ID; - - //! FileOffset inside an archive - u32 Offset; - - //! True if this is a folder, false if not. - bool IsDirectory; - - //! The == operator is provided so that CFileList can slowly search the list! - bool operator ==(const struct SFileListEntry& other) const - { - if (IsDirectory != other.IsDirectory) - return false; - - return FullName.equals_ignore_case(other.FullName); - } - - //! The < operator is provided so that CFileList can sort and quickly search the list. - bool operator <(const struct SFileListEntry& other) const - { - if (IsDirectory != other.IsDirectory) - return IsDirectory; - - return FullName.lower_ignore_case(other.FullName); - } -}; - - -//! Implementation of a file list -class CFileList : public IFileList -{ -public: - - // CFileList methods - - //! Constructor - /** \param path The path of this file archive */ - CFileList(const io::path& path, bool ignoreCase, bool ignorePaths); - - //! Destructor - virtual ~CFileList(); - - //! Add as a file or folder to the list - /** \param fullPath The file name including path, up to the root of the file list. - \param isDirectory True if this is a directory rather than a file. - \param offset The offset where the file is stored in an archive - \param size The size of the file in bytes. - \param id The ID of the file in the archive which owns it */ - virtual u32 addItem(const io::path& fullPath, u32 offset, u32 size, bool isDirectory, u32 id=0); - - //! Sorts the file list. You should call this after adding any items to the file list - virtual void sort(); - - //! Returns the amount of files in the filelist. - virtual u32 getFileCount() const; - - //! Gets the name of a file in the list, based on an index. - virtual const io::path& getFileName(u32 index) const; - - //! Gets the full name of a file in the list, path included, based on an index. - virtual const io::path& getFullFileName(u32 index) const; - - //! Returns the ID of a file in the file list, based on an index. - virtual u32 getID(u32 index) const; - - //! Returns true if the file is a directory - virtual bool isDirectory(u32 index) const; - - //! Returns the size of a file - virtual u32 getFileSize(u32 index) const; - - //! Returns the offest of a file - virtual u32 getFileOffset(u32 index) const; - - //! Searches for a file or folder within the list, returns the index - virtual s32 findFile(const io::path& filename, bool isFolder) const; - - //! Returns the base path of the file list - virtual const io::path& getPath() const; - -protected: - - //! Ignore paths when adding or searching for files - bool IgnorePaths; - - //! Ignore case when adding or searching for files - bool IgnoreCase; - - //! Path to the file list - io::path Path; - - //! List of files - core::array Files; -}; - - -} // end namespace irr -} // end namespace io - - -#endif - diff --git a/WallpaperEngine/irr/CImageLoaderTEX.cpp b/WallpaperEngine/irr/CImageLoaderTEX.cpp deleted file mode 100644 index fe48902..0000000 --- a/WallpaperEngine/irr/CImageLoaderTEX.cpp +++ /dev/null @@ -1,553 +0,0 @@ - -#include "CImageLoaderTEX.h" - -#include -#include -#include -#include - -namespace irr { - namespace video { - - //! returns true if the file maybe is able to be loaded by this class - //! based on the file extension (e.g. ".tga") - bool CImageLoaderTex::isALoadableFileExtension (const io::path &filename) const - { - return core::hasFileExtension (filename, "tex"); - } - - - //! returns true if the file maybe is able to be loaded by this class - bool CImageLoaderTex::isALoadableFileFormat (io::IReadFile *file) const - { - return false; - } - - - // load in the image data - IImage *CImageLoaderTex::loadImage (io::IReadFile *input) const - { - if (!input) - return nullptr; - - video::IImage *image = nullptr; - - char buffer [1024]; - - if (input->read (buffer, 9) != 9) - { - WallpaperEngine::irrlicht::device->getLogger ()->log ("LOAD TEX: cannot read header\n", input->getFileName ().c_str (), irr::ELL_ERROR); - return nullptr; - } - - if (memcmp (buffer, "TEXV0005", 9) != 0) - { - WallpaperEngine::irrlicht::device->getLogger ()->log ("LOAD TEX: not really a tex\n", input->getFileName ().c_str (), irr::ELL_ERROR); - return nullptr; - } - - if (input->read (buffer, 9) != 9) - { - WallpaperEngine::irrlicht::device->getLogger ()->log ("LOAD TEX: cannot read second header\n", input->getFileName ().c_str (), irr::ELL_ERROR); - return nullptr; - } - - if (memcmp (buffer, "TEXI0001", 9) != 0) - { - WallpaperEngine::irrlicht::device->getLogger ()->log ("LOAD TEX: not really a tex\n", input->getFileName ().c_str (), irr::ELL_ERROR); - return nullptr; - } - - u32 width; - u32 height; - u32 texture_width; - u32 texture_height; - u32 format; - u32 imageFormat = FREE_IMAGE_FORMAT::FIF_UNKNOWN; - u8 containerVersion = 0; - - input->read (&format, 4); - input->seek (4, true); // ignore bytes - input->read (&texture_width, 4); - input->read (&texture_height, 4); - input->read (&width, 4); - input->read (&height, 4); - input->seek (4, true); // ignore bytes - input->read (buffer, 9); - - if (memcmp (buffer, "TEXB0003", 9) == 0) - { - containerVersion = 3; - input->seek (4, true); - input->read (&imageFormat, 4); - } - else if (memcmp (buffer, "TEXB0002", 9) == 0) - { - containerVersion = 2; - - input->seek (4, true); - } - else if (memcmp (buffer, "TEXB0001", 9) == 0) - { - containerVersion = 1; - input->seek (4, true); - } - else - { - WallpaperEngine::irrlicht::device->getLogger ()->log ("LOAD TEX: Unknown container type\n", input->getFileName ().c_str (), irr::ELL_ERROR); - return nullptr; - } - - if (format == TextureFormat::A8) - { - WallpaperEngine::irrlicht::device->getLogger ()-> log ("LOAD TEX: A8 not supported\n", input->getFileName ().c_str (), irr::ELL_ERROR); - return nullptr; - } - - if (format == TextureFormat::RA88) - { - WallpaperEngine::irrlicht::device->getLogger ()->log ("LOAD TEX: RA88 not supported\n", input->getFileName ().c_str (), irr::ELL_ERROR); - return nullptr; - } - - u32 mipmap_count = 0; - - input->read (&mipmap_count, 4); - - u32 mipmap_width = 0; - u32 mipmap_height = 0; - u32 mipmap_compression = 0; - u32 mipmap_uncompressed_size = 0; - u32 mipmap_compressed_size = 0; - - input->read (&mipmap_width, 4); - input->read (&mipmap_height, 4); - - if (containerVersion > 1) - { - input->read (&mipmap_compression, 4); - input->read (&mipmap_uncompressed_size, 4); - } - - input->read (&mipmap_compressed_size, 4); - - // TODO: BETTER POSITION FOR THIS - if (mipmap_compression == 0) - { - // this might be better named as mipmap_bytes_size instead of compressed_size - // as in uncompressed files this variable actually holds the file length - mipmap_uncompressed_size = mipmap_compressed_size; - } - - char *decompressedBuffer = new char [mipmap_uncompressed_size]; - - if (mipmap_compression == 1) - { - char *compressedBuffer = new char [mipmap_compressed_size]; - - input->read (compressedBuffer, mipmap_compressed_size); - - int result = LZ4_decompress_safe (compressedBuffer, decompressedBuffer, mipmap_compressed_size, mipmap_uncompressed_size); - - if (!result) - { - delete [] decompressedBuffer; - delete [] compressedBuffer; - WallpaperEngine::irrlicht::device->getLogger ()->log ("LOAD TEX: cannot decompress texture data\n", input->getFileName ().c_str (), irr::ELL_ERROR); - return nullptr; - } - - delete [] compressedBuffer; - } - else - { - input->read (decompressedBuffer, mipmap_uncompressed_size); - } - - if (imageFormat == FREE_IMAGE_FORMAT::FIF_UNKNOWN) - { - image = WallpaperEngine::irrlicht::driver->createImage (ECF_A8R8G8B8, irr::core::dimension2d (width, height)); - - if (!image) - { - delete [] decompressedBuffer; - delete image; - WallpaperEngine::irrlicht::device->getLogger ()->log ("LOAD TEX: cannot create destination image\n", input->getFileName ().c_str (), irr::ELL_ERROR); - return nullptr; - } - - switch (format) - { - case TextureFormat::ARGB8888: - this->loadImageFromARGB8Data (image, decompressedBuffer, width, height, mipmap_width); - break; - case TextureFormat::DXT5: - this->loadImageFromDXT5 (image, decompressedBuffer, width, height, mipmap_width, mipmap_height); - break; - case TextureFormat::DXT1: - this->loadImageFromDXT1 (image, decompressedBuffer, width, height, mipmap_width, mipmap_height); - break; - case TextureFormat::DXT3: - WallpaperEngine::irrlicht::device->getLogger ()->log ("LOAD TEX: DXT3 textures not supported yet\n", input->getFileName ().c_str (), irr::ELL_ERROR); - delete [] decompressedBuffer; - delete image; - return nullptr; - } - } - else - { - // copy the buffer to a new address - char* filebuffer = new char [mipmap_uncompressed_size]; - char tmpname [TMP_MAX]; - - // copy file data to the final file buffer to be used - memcpy (filebuffer, decompressedBuffer, mipmap_uncompressed_size); - // generate temporal name - std::tmpnam (tmpname); - // store it in a std::string - std::string filename = tmpname; - irr::io::IReadFile* file; - - // free image format - switch (imageFormat) - { - case FREE_IMAGE_FORMAT::FIF_BMP: - // add extension to the file - filename += ".bmp"; - file = WallpaperEngine::irrlicht::device->getFileSystem ()->createMemoryReadFile (filebuffer, mipmap_uncompressed_size, filename.c_str (), true); - break; - case FREE_IMAGE_FORMAT::FIF_PNG: - // add extension to the file - filename += ".png"; - file = WallpaperEngine::irrlicht::device->getFileSystem ()->createMemoryReadFile (filebuffer, mipmap_uncompressed_size, filename.c_str (), true); - break; - case FREE_IMAGE_FORMAT::FIF_JPEG: - // add extension to the file - filename += ".jpg"; - WallpaperEngine::irrlicht::device->getFileSystem ()->createAndWriteFile ("/tmp/test.jpg", false)->write (filebuffer, mipmap_uncompressed_size); - file = WallpaperEngine::irrlicht::device->getFileSystem ()->createMemoryReadFile (filebuffer, mipmap_uncompressed_size, filename.c_str (), true); - break; - case FREE_IMAGE_FORMAT::FIF_GIF: - filename += ".gif"; - file = WallpaperEngine::irrlicht::device->getFileSystem ()->createMemoryReadFile (filebuffer, mipmap_uncompressed_size, filename.c_str (), true); - break; - default: - WallpaperEngine::irrlicht::device->getLogger ()->log ("LOAD TEX: detected unsupported free-image format\n", input->getFileName ().c_str (), irr::ELL_ERROR); - delete [] decompressedBuffer; - delete [] filebuffer; - return nullptr; - } - - image = WallpaperEngine::irrlicht::driver->createImageFromFile (file); - - if (!image) - { - file->drop (); - - delete [] decompressedBuffer; - delete image; - WallpaperEngine::irrlicht::device->getLogger ()->log ("LOAD TEX: cannot create destination image\n", input->getFileName ().c_str (), irr::ELL_ERROR); - return nullptr; - } - } - - delete [] decompressedBuffer; - - return image; - } - - void CImageLoaderTex::loadImageFromARGB8Data (IImage* output, const char* input, u32 width, u32 height, u32 mipmap_width) const - { - u32 bytesPerPixel = output->getBytesPerPixel (); - char *imagedata = (char *) output->lock (); - - for (u32 y = 0; y < height; y ++) - { - u32 baseDestination = y * output->getPitch (); - u32 baseOrigin = y * (mipmap_width * 4); - - for (u32 x = 0; x < width; x ++) - { - imagedata [baseDestination + (x * bytesPerPixel) + 2] = input [baseOrigin + ((width - x) * 4) + 0]; // r - imagedata [baseDestination + (x * bytesPerPixel) + 1] = input [baseOrigin + ((width - x) * 4) + 1]; // g - imagedata [baseDestination + (x * bytesPerPixel) + 0] = input [baseOrigin + ((width - x) * 4) + 2]; // b - imagedata [baseDestination + (x * bytesPerPixel) + 3] = input [baseOrigin + ((width - x) * 4) + 3]; // alpha - } - } - - output->unlock (); - } - - void CImageLoaderTex::loadImageFromDXT1 (IImage* output, const char* input, u32 destination_width, u32 destination_height, u32 origin_width, u32 origin_height) const - { - char* decompressedBuffer = new char [origin_width * origin_height * 4]; - - this->BlockDecompressImageDXT1 (origin_width, origin_height, (const unsigned char*) input, (unsigned long*) decompressedBuffer); - this->loadImageFromARGB8Data (output, decompressedBuffer, destination_width, destination_height, origin_width); - - delete [] decompressedBuffer; - } - - void CImageLoaderTex::loadImageFromDXT5 (IImage* output, const char* input, u32 destination_width, u32 destination_height, u32 origin_width, u32 origin_height) const - { - char* decompressedBuffer = new char [origin_width * origin_height * 4]; - - this->BlockDecompressImageDXT5 (origin_width, origin_height, (const unsigned char*) input, (unsigned long*) decompressedBuffer); - this->loadImageFromARGB8Data (output, decompressedBuffer, destination_width, destination_height, origin_width); - - delete [] decompressedBuffer; - } - - // ------------------------------------------------------------------------------------ - // The following code is a slightly modified version of this repository - // https://github.com/Benjamin-Dobell/s3tc-dxt-decompression - // ------------------------------------------------------------------------------------ - - // unsigned long PackRGBA(): Helper method that packs RGBA channels into a single 4 byte pixel. - // - // unsigned char r: red channel. - // unsigned char g: green channel. - // unsigned char b: blue channel. - // unsigned char a: alpha channel. - - unsigned long CImageLoaderTex::PackRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a) const - { - return ((r << 24) | (g << 16) | (b << 8) | a); - } - - // void DecompressBlockDXT1(): Decompresses one block of a DXT1 texture and stores the resulting pixels at the appropriate offset in 'image'. - // - // unsigned long x: x-coordinate of the first pixel in the block. - // unsigned long y: y-coordinate of the first pixel in the block. - // unsigned long width: width of the texture being decompressed. - // unsigned long height: height of the texture being decompressed. - // const unsigned char *blockStorage: pointer to the block to decompress. - // unsigned long *image: pointer to image where the decompressed pixel data should be stored. - - void CImageLoaderTex::DecompressBlockDXT1(unsigned long x, unsigned long y, unsigned long width, const unsigned char *blockStorage, unsigned long *image) const - { - unsigned short color0 = *reinterpret_cast(blockStorage); - unsigned short color1 = *reinterpret_cast(blockStorage + 2); - - unsigned long temp; - - temp = (color0 >> 11) * 255 + 16; - unsigned char r0 = (unsigned char)((temp/32 + temp)/32); - temp = ((color0 & 0x07E0) >> 5) * 255 + 32; - unsigned char g0 = (unsigned char)((temp/64 + temp)/64); - temp = (color0 & 0x001F) * 255 + 16; - unsigned char b0 = (unsigned char)((temp/32 + temp)/32); - - temp = (color1 >> 11) * 255 + 16; - unsigned char r1 = (unsigned char)((temp/32 + temp)/32); - temp = ((color1 & 0x07E0) >> 5) * 255 + 32; - unsigned char g1 = (unsigned char)((temp/64 + temp)/64); - temp = (color1 & 0x001F) * 255 + 16; - unsigned char b1 = (unsigned char)((temp/32 + temp)/32); - - unsigned long code = *reinterpret_cast(blockStorage + 4); - - for (int j=0; j < 4; j++) - { - for (int i=0; i < 4; i++) - { - unsigned long finalColor = 0; - unsigned char positionCode = (code >> 2*(4*j+i)) & 0x03; - - if (color0 > color1) - { - switch (positionCode) - { - case 0: - finalColor = PackRGBA(r0, g0, b0, 255); - break; - case 1: - finalColor = PackRGBA(r1, g1, b1, 255); - break; - case 2: - finalColor = PackRGBA((2*r0+r1)/3, (2*g0+g1)/3, (2*b0+b1)/3, 255); - break; - case 3: - finalColor = PackRGBA((r0+2*r1)/3, (g0+2*g1)/3, (b0+2*b1)/3, 255); - break; - } - } - else - { - switch (positionCode) - { - case 0: - finalColor = PackRGBA(r0, g0, b0, 255); - break; - case 1: - finalColor = PackRGBA(r1, g1, b1, 255); - break; - case 2: - finalColor = PackRGBA((r0+r1)/2, (g0+g1)/2, (b0+b1)/2, 255); - break; - case 3: - finalColor = PackRGBA(0, 0, 0, 255); - break; - } - } - - if (x + i < width) - image[(y + j)*width + (x + i)] = finalColor; - } - } - } - - // void BlockDecompressImageDXT1(): Decompresses all the blocks of a DXT1 compressed texture and stores the resulting pixels in 'image'. - // - // unsigned long width: Texture width. - // unsigned long height: Texture height. - // const unsigned char *blockStorage: pointer to compressed DXT1 blocks. - // unsigned long *image: pointer to the image where the decompressed pixels will be stored. - - void CImageLoaderTex::BlockDecompressImageDXT1(unsigned long width, unsigned long height, const unsigned char *blockStorage, unsigned long *image) const - { - unsigned long blockCountX = (width + 3) / 4; - unsigned long blockCountY = (height + 3) / 4; - unsigned long blockWidth = (width < 4) ? width : 4; - unsigned long blockHeight = (height < 4) ? height : 4; - - for (unsigned long j = 0; j < blockCountY; j++) - { - for (unsigned long i = 0; i < blockCountX; i++) DecompressBlockDXT1(i*4, j*4, width, blockStorage + i * 8, image); - blockStorage += blockCountX * 8; - } - } - - // void DecompressBlockDXT5(): Decompresses one block of a DXT5 texture and stores the resulting pixels at the appropriate offset in 'image'. - // - // unsigned long x: x-coordinate of the first pixel in the block. - // unsigned long y: y-coordinate of the first pixel in the block. - // unsigned long width: width of the texture being decompressed. - // unsigned long height: height of the texture being decompressed. - // const unsigned char *blockStorage: pointer to the block to decompress. - // unsigned long *image: pointer to image where the decompressed pixel data should be stored. - - void CImageLoaderTex::DecompressBlockDXT5(unsigned long x, unsigned long y, unsigned long width, const unsigned char *blockStorage, unsigned long *image) const - { - unsigned char alpha0 = *reinterpret_cast(blockStorage); - unsigned char alpha1 = *reinterpret_cast(blockStorage + 1); - - const unsigned char *bits = blockStorage + 2; - unsigned long alphaCode1 = bits[2] | (bits[3] << 8) | (bits[4] << 16) | (bits[5] << 24); - unsigned short alphaCode2 = bits[0] | (bits[1] << 8); - - unsigned short color0 = *reinterpret_cast(blockStorage + 8); - unsigned short color1 = *reinterpret_cast(blockStorage + 10); - - unsigned long temp; - - temp = (color0 >> 11) * 255 + 16; - unsigned char r0 = (unsigned char)((temp/32 + temp)/32); - temp = ((color0 & 0x07E0) >> 5) * 255 + 32; - unsigned char g0 = (unsigned char)((temp/64 + temp)/64); - temp = (color0 & 0x001F) * 255 + 16; - unsigned char b0 = (unsigned char)((temp/32 + temp)/32); - - temp = (color1 >> 11) * 255 + 16; - unsigned char r1 = (unsigned char)((temp/32 + temp)/32); - temp = ((color1 & 0x07E0) >> 5) * 255 + 32; - unsigned char g1 = (unsigned char)((temp/64 + temp)/64); - temp = (color1 & 0x001F) * 255 + 16; - unsigned char b1 = (unsigned char)((temp/32 + temp)/32); - - unsigned long code = *reinterpret_cast(blockStorage + 12); - - for (int j=0; j < 4; j++) - { - for (int i=0; i < 4; i++) - { - int alphaCodeIndex = 3*(4*j+i); - int alphaCode; - - if (alphaCodeIndex <= 12) - { - alphaCode = (alphaCode2 >> alphaCodeIndex) & 0x07; - } - else if (alphaCodeIndex == 15) - { - alphaCode = (alphaCode2 >> 15) | ((alphaCode1 << 1) & 0x06); - } - else // alphaCodeIndex >= 18 && alphaCodeIndex <= 45 - { - alphaCode = (alphaCode1 >> (alphaCodeIndex - 16)) & 0x07; - } - - unsigned char finalAlpha; - if (alphaCode == 0) - { - finalAlpha = alpha0; - } - else if (alphaCode == 1) - { - finalAlpha = alpha1; - } - else - { - if (alpha0 > alpha1) - { - finalAlpha = ((8-alphaCode)*alpha0 + (alphaCode-1)*alpha1)/7; - } - else - { - if (alphaCode == 6) - finalAlpha = 0; - else if (alphaCode == 7) - finalAlpha = 255; - else - finalAlpha = ((6-alphaCode)*alpha0 + (alphaCode-1)*alpha1)/5; - } - } - - unsigned char colorCode = (code >> 2*(4*j+i)) & 0x03; - - unsigned long finalColor; - switch (colorCode) - { - case 0: - finalColor = PackRGBA(r0, g0, b0, finalAlpha); - break; - case 1: - finalColor = PackRGBA(r1, g1, b1, finalAlpha); - break; - case 2: - finalColor = PackRGBA((2*r0+r1)/3, (2*g0+g1)/3, (2*b0+b1)/3, finalAlpha); - break; - case 3: - finalColor = PackRGBA((r0+2*r1)/3, (g0+2*g1)/3, (b0+2*b1)/3, finalAlpha); - break; - } - - if (x + i < width) - image[(y + j)*width + (x + i)] = finalColor; - } - } - } - - // void BlockDecompressImageDXT5(): Decompresses all the blocks of a DXT5 compressed texture and stores the resulting pixels in 'image'. - // - // unsigned long width: Texture width. - // unsigned long height: Texture height. - // const unsigned char *blockStorage: pointer to compressed DXT5 blocks. - // unsigned long *image: pointer to the image where the decompressed pixels will be stored. - - void CImageLoaderTex::BlockDecompressImageDXT5(unsigned long width, unsigned long height, const unsigned char *blockStorage, unsigned long *image) const - { - unsigned long blockCountX = (width + 3) / 4; - unsigned long blockCountY = (height + 3) / 4; - unsigned long blockWidth = (width < 4) ? width : 4; - unsigned long blockHeight = (height < 4) ? height : 4; - - for (unsigned long j = 0; j < blockCountY; j++) - { - for (unsigned long i = 0; i < blockCountX; i++) DecompressBlockDXT5(i*4, j*4, width, blockStorage + i * 16, image); - blockStorage += blockCountX * 16; - } - } - }// end namespace irr -}//end namespace video - diff --git a/WallpaperEngine/irr/CImageLoaderTEX.h b/WallpaperEngine/irr/CImageLoaderTEX.h deleted file mode 100644 index a89216e..0000000 --- a/WallpaperEngine/irr/CImageLoaderTEX.h +++ /dev/null @@ -1,97 +0,0 @@ -#ifndef __C_IMAGE_LOADER_TEX_H_INCLUDED__ -#define __C_IMAGE_LOADER_TEX_H_INCLUDED__ - -#include - -namespace irr -{ -namespace video -{ - -//! Surface Loader for PNG files -class CImageLoaderTex : public IImageLoader -{ -public: - - //! returns true if the file maybe is able to be loaded by this class - //! based on the file extension (e.g. ".png") - virtual bool isALoadableFileExtension(const io::path& filename) const; - - //! returns true if the file maybe is able to be loaded by this class - virtual bool isALoadableFileFormat(io::IReadFile* file) const; - - //! creates a surface from the file - virtual IImage* loadImage(io::IReadFile* input) const; - - virtual void loadImageFromARGB8Data (IImage* output, const char* input, u32 width, u32 height, u32 mipmap_width) const; - - virtual void loadImageFromDXT1 (IImage* output, const char* input, u32 destination_width, u32 destination_height, u32 origin_width, u32 origin_height) const; - virtual void loadImageFromDXT5 (IImage* output, const char* input, u32 destination_width, u32 destination_height, u32 origin_width, u32 origin_height) const; - -private: - void BlockDecompressImageDXT1(unsigned long width, unsigned long height, const unsigned char *blockStorage, unsigned long *image) const; - void DecompressBlockDXT1(unsigned long x, unsigned long y, unsigned long width, const unsigned char *blockStorage, unsigned long *image) const; - unsigned long PackRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a) const; - void BlockDecompressImageDXT5(unsigned long width, unsigned long height, const unsigned char *blockStorage, unsigned long *image) const; - void DecompressBlockDXT5(unsigned long x, unsigned long y, unsigned long width, const unsigned char *blockStorage, unsigned long *image) const; - - enum TextureFormat - { - ARGB8888, - RA88, - A8, - DXT5, - DXT3, - DXT1 - }; - - // extracted from the free image library - enum FREE_IMAGE_FORMAT - { - FIF_UNKNOWN = -1, - FIF_BMP = 0, - FIF_ICO = 1, - FIF_JPEG = 2, - FIF_JNG = 3, - FIF_KOALA = 4, - FIF_LBM = 5, - FIF_IFF = FIF_LBM, - FIF_MNG = 6, - FIF_PBM = 7, - FIF_PBMRAW = 8, - FIF_PCD = 9, - FIF_PCX = 10, - FIF_PGM = 11, - FIF_PGMRAW = 12, - FIF_PNG = 13, - FIF_PPM = 14, - FIF_PPMRAW = 15, - FIF_RAS = 16, - FIF_TARGA = 17, - FIF_TIFF = 18, - FIF_WBMP = 19, - FIF_PSD = 20, - FIF_CUT = 21, - FIF_XBM = 22, - FIF_XPM = 23, - FIF_DDS = 24, - FIF_GIF = 25, - FIF_HDR = 26, - FIF_FAXG3 = 27, - FIF_SGI = 28, - FIF_EXR = 29, - FIF_J2K = 30, - FIF_JP2 = 31, - FIF_PFM = 32, - FIF_PICT = 33, - FIF_RAW = 34, - FIF_WEBP = 35, - FIF_JXR = 36 - }; -}; - - -} // end namespace video -} // end namespace irr - -#endif /* !__C_IMAGE_LOADER_TEX_H_INCLUDED__ */ diff --git a/WallpaperEngine/irr/CPkgReader.h b/WallpaperEngine/irr/CPkgReader.h deleted file mode 100644 index 7f958d6..0000000 --- a/WallpaperEngine/irr/CPkgReader.h +++ /dev/null @@ -1,82 +0,0 @@ -// -// Created by almamu on 4/04/19. -// - -#ifndef WALLENGINE_CPKGREADER_H -#define WALLENGINE_CPKGREADER_H - -#include -#include - -#include "CFileList.h" - -//! Archiveloader capable of loading WAD Archives -class CArchiveLoaderPkg : public irr::io::IArchiveLoader -{ -public: - - //! Constructor - CArchiveLoaderPkg(irr::io::IFileSystem* fs); - - //! returns true if the file maybe is able to be loaded by this class - //! based on the file extension (e.g. ".zip") - virtual bool isALoadableFileFormat(const irr::io::path& filename) const; - - //! Check if the file might be loaded by this class - /** Check might look into the file. - \param file File handle to check. - \return True if file seems to be loadable. */ - virtual bool isALoadableFileFormat(irr::io::IReadFile* file) const; - - //! Check to see if the loader can create archives of this type. - /** Check based on the archive type. - \param fileType The archive type to check. - \return True if the archile loader supports this type, false if not */ - virtual bool isALoadableFileFormat(irr::io::E_FILE_ARCHIVE_TYPE fileType) const; - - //! Creates an archive from the filename - /** \param file File handle to check. - \return Pointer to newly created archive, or 0 upon error. */ - virtual irr::io::IFileArchive* createArchive(const irr::io::path& filename, bool ignoreCase, bool ignorePaths) const; - - //! creates/loads an archive from the file. - //! \return Pointer to the created archive. Returns 0 if loading failed. - virtual irr::io::IFileArchive* createArchive(irr::io::IReadFile* file, bool ignoreCase, bool ignorePaths) const; - -private: - irr::io::IFileSystem* FileSystem; -}; - -class CPkgReader : public virtual irr::io::IFileArchive, virtual irr::io::CFileList -{ -public: - - //! constructor - CPkgReader (irr::io::IReadFile* file, bool ignoreCase, bool ignorePaths); - - //! destructor - virtual ~CPkgReader (); - - //! opens a file by file name - virtual irr::io::IReadFile* createAndOpenFile (const irr::io::path& filename); - - //! opens a file by index - virtual irr::io::IReadFile* createAndOpenFile (unsigned int index); - - //! returns the list of files - virtual const IFileList* getFileList () const; - - //! get the archive type - virtual irr::io::E_FILE_ARCHIVE_TYPE getType () const; - -protected: - void scanPkgHeader (); - - char* readSizedString (); - - irr::io::IFileSystem* mFileSystem; - irr::io::IReadFile* mFile; -}; - - -#endif //WALLENGINE_CPKGREADER_H diff --git a/WallpaperEngine/irrlicht.cpp b/WallpaperEngine/irrlicht.cpp deleted file mode 100644 index 0cad482..0000000 --- a/WallpaperEngine/irrlicht.cpp +++ /dev/null @@ -1,8 +0,0 @@ -#include - -namespace WallpaperEngine -{ - irr::video::IVideoDriver* irrlicht::driver = nullptr; - irr::IrrlichtDevice* irrlicht::device = nullptr; - irr::scene::ICameraSceneNode* irrlicht::camera = nullptr; -} \ No newline at end of file diff --git a/WallpaperEngine/irrlicht.h b/WallpaperEngine/irrlicht.h deleted file mode 100644 index 64f7ee6..0000000 --- a/WallpaperEngine/irrlicht.h +++ /dev/null @@ -1,18 +0,0 @@ -#ifndef WALLENGINE_IRRLICHT_H -#define WALLENGINE_IRRLICHT_H - -#include - -namespace WallpaperEngine -{ - class irrlicht - { - public: - static irr::video::IVideoDriver* driver; - static irr::IrrlichtDevice* device; - static irr::scene::ICameraSceneNode* camera; - }; -} - - -#endif //WALLENGINE_IRRLICHT_H diff --git a/WallpaperEngine/project.cpp b/WallpaperEngine/project.cpp index 34c88c2..d0d7ffb 100644 --- a/WallpaperEngine/project.cpp +++ b/WallpaperEngine/project.cpp @@ -6,13 +6,13 @@ #include "WallpaperEngine/fs/utils.h" #include "project.h" -#include "irrlicht.h" +#include "WallpaperEngine/Irrlicht/Irrlicht.h" namespace WallpaperEngine { project::project (irr::io::path& jsonfile_path) { - this->m_content = WallpaperEngine::fs::utils::loadFullFile (jsonfile_path); + this->m_content = WallpaperEngine::FileSystem::loadFullFile (jsonfile_path); this->m_projectFile = json::parse (this->m_content); json::const_iterator file_it = this->m_projectFile.find ("file"); diff --git a/WallpaperEngine/scene.cpp b/WallpaperEngine/scene.cpp index 878924f..49e97ab 100644 --- a/WallpaperEngine/scene.cpp +++ b/WallpaperEngine/scene.cpp @@ -14,7 +14,7 @@ namespace WallpaperEngine scene::scene (irr::io::path& file) { - this->m_content = WallpaperEngine::fs::utils::loadFullFile (file); + this->m_content = WallpaperEngine::FileSystem::loadFullFile (file); this->m_json = json::parse (this->m_content); // check basic elements diff --git a/WallpaperEngine/shaders/compiler.cpp b/WallpaperEngine/shaders/compiler.cpp index 68433e3..a5aec39 100644 --- a/WallpaperEngine/shaders/compiler.cpp +++ b/WallpaperEngine/shaders/compiler.cpp @@ -7,7 +7,7 @@ #include // video engine -#include +#include // shader compiler #include @@ -58,7 +58,7 @@ namespace WallpaperEngine this->m_content = ""; } - this->m_content.append (WallpaperEngine::fs::utils::loadFullFile (file)); + this->m_content.append (WallpaperEngine::FileSystem::loadFullFile (file)); // append file content this->m_type = type; @@ -244,7 +244,7 @@ namespace WallpaperEngine std::string compiler::precompile() { - #define BREAK_IF_ERROR if (this->m_error == true) { WallpaperEngine::irrlicht::device->getLogger ()->log ("ERROR PRE-COMPILING SHADER", irr::ELL_ERROR); WallpaperEngine::irrlicht::device->getLogger ()->log (this->m_errorInfo.c_str (), irr::ELL_ERROR); return ""; } + #define BREAK_IF_ERROR if (this->m_error == true) { WallpaperEngine::Irrlicht::device->getLogger ()->log ("ERROR PRE-COMPILING SHADER", irr::ELL_ERROR); WallpaperEngine::Irrlicht::device->getLogger ()->log (this->m_errorInfo.c_str (), irr::ELL_ERROR); return ""; } // parse the shader and find #includes and such things and translate them to the correct name // also remove any #version definition to prevent errors std::string::const_iterator it = this->m_content.begin (); @@ -445,8 +445,8 @@ namespace WallpaperEngine if (this->m_recursive == false) { - WallpaperEngine::irrlicht::device->getLogger ()->log ("Compiled shader output for", this->m_file.c_str ()); - WallpaperEngine::irrlicht::device->getLogger ()->log (this->m_compiledContent.c_str ()); + WallpaperEngine::Irrlicht::device->getLogger ()->log ("Compiled shader output for", this->m_file.c_str ()); + WallpaperEngine::Irrlicht::device->getLogger ()->log (this->m_compiledContent.c_str ()); } return this->m_compiledContent; @@ -464,7 +464,7 @@ namespace WallpaperEngine if (combo == data.end () || defvalue == data.end ()) { - WallpaperEngine::irrlicht::device->getLogger ()->log ("Cannot parse combo information", irr::ELL_ERROR); + WallpaperEngine::Irrlicht::device->getLogger ()->log ("Cannot parse combo information", irr::ELL_ERROR); return; } @@ -490,7 +490,7 @@ namespace WallpaperEngine } else { - WallpaperEngine::irrlicht::device->getLogger ()->log ("Cannot parse combo information, unknown type", irr::ELL_ERROR); + WallpaperEngine::Irrlicht::device->getLogger ()->log ("Cannot parse combo information, unknown type", irr::ELL_ERROR); } } } @@ -506,7 +506,7 @@ namespace WallpaperEngine if (material == data.end () || defvalue == data.end ()) { if (type != "sampler2D") - WallpaperEngine::irrlicht::device->getLogger ()->log ("Cannot parse parameter info for ", name.c_str (), irr::ELL_ERROR); + WallpaperEngine::Irrlicht::device->getLogger ()->log ("Cannot parse parameter info for ", name.c_str (), irr::ELL_ERROR); return; } diff --git a/WallpaperEngine/shaders/compiler.h b/WallpaperEngine/shaders/compiler.h index b4eb173..14d750d 100644 --- a/WallpaperEngine/shaders/compiler.h +++ b/WallpaperEngine/shaders/compiler.h @@ -5,6 +5,7 @@ #include #include #include +#include #include @@ -12,6 +13,8 @@ namespace WallpaperEngine { namespace shaders { + using json = nlohmann::json; + /** * A basic shader loader that adds basic function definitions to every loaded shader */ diff --git a/WallpaperEngine/sound.cpp b/WallpaperEngine/sound.cpp index 084454b..668bcbe 100644 --- a/WallpaperEngine/sound.cpp +++ b/WallpaperEngine/sound.cpp @@ -5,7 +5,7 @@ #include #include #include "sound.h" -#include "irrlicht.h" +#include "WallpaperEngine/Irrlicht/Irrlicht.h" namespace WallpaperEngine { @@ -31,7 +31,7 @@ namespace WallpaperEngine { SDL_RWops* sdlRwops = nullptr; Mix_Music* music = nullptr; - irr::io::IReadFile* readfile = WallpaperEngine::irrlicht::device->getFileSystem ()->createAndOpenFile ((*cur).c_str ()); + irr::io::IReadFile* readfile = WallpaperEngine::Irrlicht::device->getFileSystem ()->createAndOpenFile ((*cur).c_str ()); int filesize = readfile->getSize (); char* filebuffer = new char [filesize]; @@ -43,7 +43,7 @@ namespace WallpaperEngine if (music == nullptr) { - WallpaperEngine::irrlicht::device->getLogger ()->log ("Cannot load audio", Mix_GetError (), irr::ELL_ERROR); + WallpaperEngine::Irrlicht::device->getLogger ()->log ("Cannot load audio", Mix_GetError (), irr::ELL_ERROR); } this->m_bufferReader.push_back (sdlRwops); @@ -58,7 +58,7 @@ namespace WallpaperEngine { if (Mix_PlayMusic ((*mixcur), -1) == -1) { - WallpaperEngine::irrlicht::device->getLogger ()->log ("Cannot play audio", Mix_GetError (), irr::ELL_ERROR); + WallpaperEngine::Irrlicht::device->getLogger ()->log ("Cannot play audio", Mix_GetError (), irr::ELL_ERROR); } } } diff --git a/WallpaperEngine/texture.cpp b/WallpaperEngine/texture.cpp index db3454d..9eac572 100644 --- a/WallpaperEngine/texture.cpp +++ b/WallpaperEngine/texture.cpp @@ -2,13 +2,13 @@ #include #include -#include "irrlicht.h" +#include "WallpaperEngine/Irrlicht/Irrlicht.h" namespace WallpaperEngine { texture::texture (irr::io::path& file) { - this->m_texture = WallpaperEngine::irrlicht::driver->getTexture (file); + this->m_texture = WallpaperEngine::Irrlicht::driver->getTexture (file); } irr::video::ITexture* texture::getIrrTexture () diff --git a/WallpaperEngine/video/material.cpp b/WallpaperEngine/video/material.cpp index 4433098..73db00c 100644 --- a/WallpaperEngine/video/material.cpp +++ b/WallpaperEngine/video/material.cpp @@ -1,4 +1,4 @@ -#include +#include #include namespace WallpaperEngine @@ -56,8 +56,8 @@ namespace WallpaperEngine 0, 1, 2, 3 }; - WallpaperEngine::irrlicht::driver->setMaterial (m_material); - WallpaperEngine::irrlicht::driver->drawVertexPrimitiveList (m_vertices, 4, indices, 1, irr::video::EVT_STANDARD, irr::scene::EPT_QUADS, irr::video::EIT_16BIT); + WallpaperEngine::Irrlicht::driver->setMaterial (m_material); + WallpaperEngine::Irrlicht::driver->drawVertexPrimitiveList (m_vertices, 4, indices, 1, irr::video::EVT_STANDARD, irr::scene::EPT_QUADS, irr::video::EIT_16BIT); } } } \ No newline at end of file diff --git a/WallpaperEngine/video/renderer.cpp b/WallpaperEngine/video/renderer.cpp index 8e7aaf6..f4c87b8 100644 --- a/WallpaperEngine/video/renderer.cpp +++ b/WallpaperEngine/video/renderer.cpp @@ -1,4 +1,4 @@ -#include +#include #include namespace WallpaperEngine @@ -31,19 +31,19 @@ namespace WallpaperEngine znear, zfar ); - WallpaperEngine::irrlicht::camera = WallpaperEngine::irrlicht::device->getSceneManager ()->addCameraSceneNode (0, position, lookat); - WallpaperEngine::irrlicht::camera->setProjectionMatrix (orthoProjection); + WallpaperEngine::Irrlicht::camera = WallpaperEngine::Irrlicht::device->getSceneManager ()->addCameraSceneNode (0, position, lookat); + WallpaperEngine::Irrlicht::camera->setProjectionMatrix (orthoProjection); - WallpaperEngine::irrlicht::driver->setTransform (irr::video::ETS_PROJECTION, orthoProjection); - WallpaperEngine::irrlicht::driver->setTransform (irr::video::ETS_VIEW, identity); - WallpaperEngine::irrlicht::driver->setTransform (irr::video::ETS_WORLD, identity); + WallpaperEngine::Irrlicht::driver->setTransform (irr::video::ETS_PROJECTION, orthoProjection); + WallpaperEngine::Irrlicht::driver->setTransform (irr::video::ETS_VIEW, identity); + WallpaperEngine::Irrlicht::driver->setTransform (irr::video::ETS_WORLD, identity); } void renderer::render () { - if (WallpaperEngine::irrlicht::driver == nullptr) return; + if (WallpaperEngine::Irrlicht::driver == nullptr) return; - WallpaperEngine::irrlicht::driver->beginScene(true, true, irr::video::SColor(0, 0, 0, 0)); + WallpaperEngine::Irrlicht::driver->beginScene(true, true, irr::video::SColor(0, 0, 0, 0)); std::vector::const_iterator cur = s_nodes.begin (); std::vector::const_iterator end = s_nodes.end (); @@ -53,7 +53,7 @@ namespace WallpaperEngine (*cur)->render (); } - WallpaperEngine::irrlicht::driver->endScene (); + WallpaperEngine::Irrlicht::driver->endScene (); } std::vector renderer::s_nodes; diff --git a/main.cpp b/main.cpp index 460067a..dfd3dd1 100644 --- a/main.cpp +++ b/main.cpp @@ -3,15 +3,15 @@ #include #include #include -#include +#include #include #include #include #include "WallpaperEngine/shaders/compiler.h" #include "WallpaperEngine/project.h" -#include "WallpaperEngine/irrlicht.h" -#include "WallpaperEngine/irr/CImageLoaderTEX.h" +#include "WallpaperEngine/Irrlicht/Irrlicht.h" +#include "WallpaperEngine/Irrlicht/CImageLoaderTEX.h" #include "WallpaperEngine/Core/CProject.h" @@ -25,7 +25,7 @@ int init_irrlicht() // prepare basic configuration for irrlicht _irr_params.AntiAlias = 8; _irr_params.Bits = 16; - // _irr_params.DeviceType = irr::EIDT_X11; + // _irr_params.DeviceType = Irrlicht::EIDT_X11; _irr_params.DriverType = irr::video::EDT_OPENGL; _irr_params.Doublebuffer = true; _irr_params.EventReceiver = nullptr; @@ -40,29 +40,29 @@ int init_irrlicht() _irr_params.LoggingLevel = irr::ELL_DEBUG; _irr_params.WindowId = reinterpret_cast (WinID); - WallpaperEngine::irrlicht::device = irr::createDeviceEx (_irr_params); + WallpaperEngine::Irrlicht::device = irr::createDeviceEx (_irr_params); - if (WallpaperEngine::irrlicht::device == nullptr) + if (WallpaperEngine::Irrlicht::device == nullptr) { return 1; } - WallpaperEngine::irrlicht::device->setWindowCaption (L"Test game"); - WallpaperEngine::irrlicht::driver = WallpaperEngine::irrlicht::device->getVideoDriver(); + WallpaperEngine::Irrlicht::device->setWindowCaption (L"Test game"); + WallpaperEngine::Irrlicht::driver = WallpaperEngine::Irrlicht::device->getVideoDriver(); // check for ps and vs support if ( - WallpaperEngine::irrlicht::driver->queryFeature (irr::video::EVDF_PIXEL_SHADER_1_1) == false && - WallpaperEngine::irrlicht::driver->queryFeature (irr::video::EVDF_ARB_FRAGMENT_PROGRAM_1) == false) + WallpaperEngine::Irrlicht::driver->queryFeature (irr::video::EVDF_PIXEL_SHADER_1_1) == false && + WallpaperEngine::Irrlicht::driver->queryFeature (irr::video::EVDF_ARB_FRAGMENT_PROGRAM_1) == false) { - WallpaperEngine::irrlicht::device->getLogger ()->log ("WARNING: Pixel shaders disabled because of missing driver/hardware support"); + WallpaperEngine::Irrlicht::device->getLogger ()->log ("WARNING: Pixel shaders disabled because of missing driver/hardware support"); } if ( - WallpaperEngine::irrlicht::driver->queryFeature (irr::video::EVDF_VERTEX_SHADER_1_1) == false && - WallpaperEngine::irrlicht::driver->queryFeature (irr::video::EVDF_ARB_VERTEX_PROGRAM_1) == false) + WallpaperEngine::Irrlicht::driver->queryFeature (irr::video::EVDF_VERTEX_SHADER_1_1) == false && + WallpaperEngine::Irrlicht::driver->queryFeature (irr::video::EVDF_ARB_VERTEX_PROGRAM_1) == false) { - WallpaperEngine::irrlicht::device->getLogger ()->log ("WARNING: Vertex shaders disabled because of missing driver/hardware support"); + WallpaperEngine::Irrlicht::device->getLogger ()->log ("WARNING: Vertex shaders disabled because of missing driver/hardware support"); } return 0; @@ -71,11 +71,11 @@ int init_irrlicht() void preconfigure_wallpaper_engine () { // load the assets from wallpaper engine - WallpaperEngine::irrlicht::device->getFileSystem ()->addFileArchive ("assets.zip", true, false); + WallpaperEngine::Irrlicht::device->getFileSystem ()->addFileArchive ("assets.zip", true, false); // register custom loaders - WallpaperEngine::irrlicht::driver->addExternalImageLoader (new irr::video::CImageLoaderTex ()); - WallpaperEngine::irrlicht::device->getFileSystem ()->addArchiveLoader (new CArchiveLoaderPkg (WallpaperEngine::irrlicht::device->getFileSystem ())); + WallpaperEngine::Irrlicht::driver->addExternalImageLoader (new WallpaperEngine::Irrlicht::CImageLoaderTex ()); + WallpaperEngine::Irrlicht::device->getFileSystem ()->addArchiveLoader (new WallpaperEngine::Irrlicht::CArchiveLoaderPkg (WallpaperEngine::Irrlicht::device->getFileSystem ())); } void print_help (const char* route) @@ -164,20 +164,20 @@ int main (int argc, char* argv[]) // pkg mode case 1: - wallpaper_path = WallpaperEngine::irrlicht::device->getFileSystem ()->getAbsolutePath (path.c_str ()); + wallpaper_path = WallpaperEngine::Irrlicht::device->getFileSystem ()->getAbsolutePath (path.c_str ()); project_path = wallpaper_path + "project.json"; scene_path = wallpaper_path + "scene.pkg"; - WallpaperEngine::irrlicht::device->getFileSystem ()->addFileArchive (scene_path, true, false); // add the pkg file to the lookup list + WallpaperEngine::Irrlicht::device->getFileSystem ()->addFileArchive (scene_path, true, false); // add the pkg file to the lookup list break; // folder mode case 2: - wallpaper_path = WallpaperEngine::irrlicht::device->getFileSystem ()->getAbsolutePath (path.c_str ()); + wallpaper_path = WallpaperEngine::Irrlicht::device->getFileSystem ()->getAbsolutePath (path.c_str ()); project_path = wallpaper_path + "project.json"; // set our working directory - WallpaperEngine::irrlicht::device->getFileSystem ()->changeWorkingDirectoryTo (wallpaper_path); + WallpaperEngine::Irrlicht::device->getFileSystem ()->changeWorkingDirectoryTo (wallpaper_path); break; default: @@ -190,7 +190,7 @@ int main (int argc, char* argv[]) if (SDL_Init (SDL_INIT_AUDIO) < 0 || mixer_flags != Mix_Init (mixer_flags)) { - WallpaperEngine::irrlicht::device->getLogger ()->log ("Cannot initialize SDL audio system", irr::ELL_ERROR); + WallpaperEngine::Irrlicht::device->getLogger ()->log ("Cannot initialize SDL audio system", irr::ELL_ERROR); return -1; } @@ -206,7 +206,7 @@ int main (int argc, char* argv[]) } else { - WallpaperEngine::irrlicht::device->getLogger ()->log ("Non-orthogonal cameras not supported yet!!", irr::ELL_ERROR); + WallpaperEngine::Irrlicht::device->getLogger ()->log ("Non-orthogonal cameras not supported yet!!", irr::ELL_ERROR); return -2; } @@ -217,11 +217,11 @@ int main (int argc, char* argv[]) int32_t minimumTime = 1000 / 90; int32_t currentTime = 0; - while (WallpaperEngine::irrlicht::device->run () && WallpaperEngine::irrlicht::driver) + while (WallpaperEngine::Irrlicht::device->run () && WallpaperEngine::Irrlicht::driver) { // if (device->isWindowActive ()) { - currentTime = WallpaperEngine::irrlicht::device->getTimer ()->getTime (); + currentTime = WallpaperEngine::Irrlicht::device->getTimer ()->getTime (); g_Time = currentTime / 1000.0f; if (currentTime - lastTime > minimumTime) @@ -231,7 +231,7 @@ int main (int argc, char* argv[]) } else { - WallpaperEngine::irrlicht::device->sleep (1, false); + WallpaperEngine::Irrlicht::device->sleep (1, false); } } }