Upload source

.gitignore

+*.exe
+*.o
+*.pgp
+*.pgs
+*.res

LICENCE.md

+# License (OLC-3)
+
+Copyright 2018-2019 OneLoneCoder.com
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions 
+are met:
+
+1. Redistributions or derivations of source code must retain the above 
+   copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions or derivative works in binary form must reproduce 
+   the above copyright notice. This list of conditions and the following 
+   disclaimer must be reproduced in the documentation and/or other 
+   materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its 
+   contributors may be used to endorse or promote products derived 
+   from this software without specific prior written permission.
+    
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Makefile

+CPPFLAGS=-Wall -Wno-misleading-indentation -Werror --std=c++1z
+LDFLAGS=
+INCLUDES=-I./pge/include
+ifeq ($(OS),Windows_NT)
+	LIBRARIES=-luser32 -lgdi32 -lgdiplus
+	EXECUTABLE=packer.exe
+	CPP=i686-w64-mingw32-g++
+	CC=i686-w64-mingw32-gcc
+else
+	EXECUTABLE=packer
+	LIBRARIES=-lpng
+	CC=gcc
+	CPP=g++
+endif
+ifeq ($(DEBUG),1)
+	CPPFLAGS+=-g -Og
+else
+	CPPFLAGS+=-flto -O3
+endif
+SOURCES=$(wildcard src/*.cpp) $(wildcard pge/src/*.cpp)
+OBJECTS=$(SOURCES:.cpp=.o)
+
+all: $(SOURCES) $(EXECUTABLE)
+
+clean: 
+	$(RM) $(OBJECTS) $(EXECUTABLE)
+	
+$(EXECUTABLE): $(OBJECTS) 
+	$(CPP) $(LDFLAGS) $(OBJECTS) -o $@ $(LIBRARIES)
+
+.cpp.o:
+	$(CPP) $(INCLUDES) -c $(CPPFLAGS) $< -o $@

README.md

+# How to compile on Windows
+
+To compile on windows you need MinGW-32 and MSYS (or Cygwin or Git-Bash) installed in PATH
+
+## Download links: 
+- [MinGW](http://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/installer/mingw-w64-install.exe/download)
+- [MSYS](https://osdn.net/projects/mingw/downloads/68260/mingw-get-setup.exe/)
+
+**WARNING!** _MinGW version from second link is too old, do not install MinGW from mingw-get, install only MSYS_
+
+# How to compile on linux
+
+For Debian/Ubuntu: 
+
+    sudo apt install libpng-dev
+
+
+# Make it!
+
+Just run `make` command to build

pge/include/olcPGEX_Graphics2D.h

+/*
+	olcPGEX_Graphics2D.h
+
+	+-------------------------------------------------------------+
+	|         OneLoneCoder Pixel Game Engine Extension            |
+	|                Advanced 2D Rendering - v0.4                 |
+	+-------------------------------------------------------------+
+
+	What is this?
+	~~~~~~~~~~~~~
+	This is an extension to the olcPixelGameEngine, which provides
+	advanced olc::Sprite manipulation and drawing routines. To use
+	it, simply include this header file.
+
+	License (OLC-3)
+	~~~~~~~~~~~~~~~
+
+	Copyright 2018 - 2019 OneLoneCoder.com
+
+	Redistribution and use in source and binary forms, with or without
+	modification, are permitted provided that the following conditions
+	are met:
+
+	1. Redistributions or derivations of source code must retain the above
+	copyright notice, this list of conditions and the following disclaimer.
+
+	2. Redistributions or derivative works in binary form must reproduce
+	the above copyright notice. This list of conditions and the following
+	disclaimer must be reproduced in the documentation and/or other
+	materials provided with the distribution.
+
+	3. Neither the name of the copyright holder nor the names of its
+	contributors may be used to endorse or promote products derived
+	from this software without specific prior written permission.
+
+	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+	"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+	A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+	HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+	SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+	LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+	OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+	Links
+	~~~~~
+	YouTube:	https://www.youtube.com/javidx9
+	Discord:	https://discord.gg/WhwHUMV
+	Twitter:	https://www.twitter.com/javidx9
+	Twitch:		https://www.twitch.tv/javidx9
+	GitHub:		https://www.github.com/onelonecoder
+	Homepage:	https://www.onelonecoder.com
+
+	Author
+	~~~~~~
+	David Barr, aka javidx9, �OneLoneCoder 2019
+*/
+
+/*
+	Matrices stored as [Column][Row] (i.e. x, y)
+
+	|C0R0 C1R0 C2R0|   | x |   | x'|
+	|C0R1 C1R1 C2R1| * | y | = | y'|
+	|C0R2 C1R2 C2R2|   |1.0|   | - |
+*/
+
+#ifndef OLC_PGEX_GFX2D
+#define OLC_PGEX_GFX2D
+
+#include "olcPixelGameEngine.h"
+#include <algorithm>
+#undef min
+#undef max
+
+namespace olc
+{
+	// Container class for Advanced 2D Drawing functions
+	class GFX2D : public olc::PGEX
+	{
+		// A representation of an affine transform, used to rotate, scale, offset & shear space
+	public:
+		class Transform2D
+		{
+		public:
+			Transform2D();
+
+		public:
+			// Set this transformation to unity
+			void Reset();
+			// Append a rotation of fTheta radians to this transform
+			void Rotate(float fTheta);
+			// Append a translation (ox, oy) to this transform
+			void Translate(float ox, float oy);
+			// Append a scaling operation (sx, sy) to this transform
+			void Scale(float sx, float sy);
+			// Append a shear operation (sx, sy) to this transform
+			void Shear(float sx, float sy);
+
+		    void Perspective(float ox, float oy);
+			// Calculate the Forward Transformation of the coordinate (in_x, in_y) -> (out_x, out_y)
+			void Forward(float in_x, float in_y, float &out_x, float &out_y);
+			// Calculate the Inverse Transformation of the coordinate (in_x, in_y) -> (out_x, out_y)
+			void Backward(float in_x, float in_y, float &out_x, float &out_y);
+			// Regenerate the Inverse Transformation
+			void Invert();
+
+		private:
+			void Multiply();
+			float matrix[4][3][3];
+			int nTargetMatrix;
+			int nSourceMatrix;
+			bool bDirty;
+		};
+
+	public:
+		// Draws a sprite with the transform applied
+		static void DrawSprite(olc::Sprite *sprite, olc::GFX2D::Transform2D &transform, bool centered = false);
+		static void DrawPartialSprite(olc::Sprite *sprite, int32_t ox, int32_t oy, int32_t w, int32_t h, olc::GFX2D::Transform2D &transform, bool centered = false);
+	};
+}
+
+#endif

pge/include/olcPGEX_Sound.h

+/*
+	olcPGEX_Sound.h
+
+	+-------------------------------------------------------------+
+	|         OneLoneCoder Pixel Game Engine Extension            |
+	|                       Sound - v0.3                          |
+	+-------------------------------------------------------------+
+
+	What is this?
+	~~~~~~~~~~~~~
+	This is an extension to the olcPixelGameEngine, which provides
+	sound generation and wave playing routines.
+
+	Special Thanks:
+	~~~~~~~~~~~~~~~	
+	Slavka - For entire non-windows system back end!
+	Gorbit99 - Testing, Bug Fixes
+	Cyberdroid - Testing, Bug Fixes
+	Dragoneye - Testing
+	Puol - Testing
+
+	License (OLC-3)
+	~~~~~~~~~~~~~~~
+
+	Copyright 2018 - 2019 OneLoneCoder.com
+
+	Redistribution and use in source and binary forms, with or without
+	modification, are permitted provided that the following conditions
+	are met:
+
+	1. Redistributions or derivations of source code must retain the above
+	copyright notice, this list of conditions and the following disclaimer.
+
+	2. Redistributions or derivative works in binary form must reproduce
+	the above copyright notice. This list of conditions and the following
+	disclaimer must be reproduced in the documentation and/or other
+	materials provided with the distribution.
+
+	3. Neither the name of the copyright holder nor the names of its
+	contributors may be used to endorse or promote products derived
+	from this software without specific prior written permission.
+
+	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+	"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+	A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+	HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+	SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+	LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+	OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+	Links
+	~~~~~
+	YouTube:	https://www.youtube.com/javidx9
+	Discord:	https://discord.gg/WhwHUMV
+	Twitter:	https://www.twitter.com/javidx9
+	Twitch:		https://www.twitch.tv/javidx9
+	GitHub:		https://www.github.com/onelonecoder
+	Homepage:	https://www.onelonecoder.com
+	Patreon:	https://www.patreon.com/javidx9
+
+	Author
+	~~~~~~
+	David Barr, aka javidx9, �OneLoneCoder 2019
+*/
+
+
+#ifndef OLC_PGEX_SOUND_H
+#define OLC_PGEX_SOUND_H
+
+#include "olcPixelGameEngine.h"
+#include <istream>
+#include <cstring>
+#include <climits>
+
+#include <algorithm>
+#undef min
+#undef max
+
+// Choose a default sound backend
+#if !defined(USE_ALSA) && !defined(USE_OPENAL) && !defined(USE_WINDOWS)
+#ifdef __linux__
+#define USE_ALSA
+#endif
+
+#ifdef __EMSCRIPTEN__
+#define USE_OPENAL
+#endif
+
+#ifdef _WIN32
+#define USE_WINDOWS
+#endif
+
+#endif
+
+#ifdef USE_ALSA
+#define ALSA_PCM_NEW_HW_PARAMS_API
+#include <alsa/asoundlib.h>
+#endif
+
+#ifdef USE_OPENAL
+#include <AL/al.h>
+#include <AL/alc.h>
+#include <queue>
+#endif
+
+#pragma pack(push, 1)
+typedef struct {
+	uint16_t wFormatTag;
+	uint16_t nChannels;
+	uint32_t nSamplesPerSec;
+	uint32_t nAvgBytesPerSec;
+	uint16_t nBlockAlign;
+	uint16_t wBitsPerSample;
+	uint16_t cbSize;
+} OLC_WAVEFORMATEX;
+#pragma pack(pop)
+
+namespace olc
+{
+	// Container class for Advanced 2D Drawing functions
+	class SOUND : public olc::PGEX
+	{
+		// A representation of an affine transform, used to rotate, scale, offset & shear space
+	public:
+		class AudioSample
+		{
+		public:
+			AudioSample();
+			AudioSample(std::string sWavFile, olc::ResourcePack *pack = nullptr);
+			olc::rcode LoadFromFile(std::string sWavFile, olc::ResourcePack *pack = nullptr);
+
+		public:
+			OLC_WAVEFORMATEX wavHeader;
+			float *fSample = nullptr;
+			long nSamples = 0;
+			int nChannels = 0;
+			bool bSampleValid = false;
+		};
+
+		struct sCurrentlyPlayingSample
+		{
+			int nAudioSampleID = 0;
+			long nSamplePosition = 0;
+			bool bFinished = false;
+			bool bLoop = false;
+			bool bFlagForStop = false;
+		};
+
+		static std::list<sCurrentlyPlayingSample> listActiveSamples;
+
+	public:
+		static bool InitialiseAudio(unsigned int nSampleRate = 44100, unsigned int nChannels = 1, unsigned int nBlocks = 8, unsigned int nBlockSamples = 512);
+		static bool DestroyAudio();
+		static void SetUserSynthFunction(std::function<float(int, float, float)> func);
+		static void SetUserFilterFunction(std::function<float(int, float, float)> func);
+
+	public:
+		static int LoadAudioSample(std::string sWavFile, olc::ResourcePack *pack = nullptr);
+		static void PlaySample(int id, bool bLoop = false);
+		static void StopSample(int id);
+		static void StopAll();
+		static float GetMixerOutput(int nChannel, float fGlobalTime, float fTimeStep);
+
+
+	private:
+#ifdef USE_WINDOWS // Windows specific sound management
+		static void CALLBACK waveOutProc(HWAVEOUT hWaveOut, UINT uMsg, DWORD_PTR dwInstance, DWORD dwParam1, DWORD dwParam2);
+		static unsigned int m_nSampleRate;
+		static unsigned int m_nChannels;
+		static unsigned int m_nBlockCount;
+		static unsigned int m_nBlockSamples;
+		static unsigned int m_nBlockCurrent;
+		static short* m_pBlockMemory;
+		static WAVEHDR *m_pWaveHeaders;
+		static HWAVEOUT m_hwDevice;
+		static std::atomic<unsigned int> m_nBlockFree;
+		static std::condition_variable m_cvBlockNotZero;
+		static std::mutex m_muxBlockNotZero;
+#endif
+
+#ifdef USE_ALSA
+		static snd_pcm_t *m_pPCM;
+		static unsigned int m_nSampleRate;
+		static unsigned int m_nChannels;
+		static unsigned int m_nBlockSamples;
+		static short* m_pBlockMemory;
+#endif
+
+#ifdef USE_OPENAL
+		static std::queue<ALuint> m_qAvailableBuffers;
+		static ALuint *m_pBuffers;
+		static ALuint m_nSource;
+		static ALCdevice *m_pDevice;
+		static ALCcontext *m_pContext;
+		static unsigned int m_nSampleRate;
+		static unsigned int m_nChannels;
+		static unsigned int m_nBlockCount;
+		static unsigned int m_nBlockSamples;
+		static short* m_pBlockMemory;
+#endif
+
+		static void AudioThread();
+		static std::thread m_AudioThread;
+		static std::atomic<bool> m_bAudioThreadActive;
+		static std::atomic<float> m_fGlobalTime;
+		static std::function<float(int, float, float)> funcUserSynth;
+		static std::function<float(int, float, float)> funcUserFilter;
+	};
+}
+
+#endif // OLC_PGEX_SOUND

pge/include/olcPGE_Common.h

+#ifndef OLC_PGE_COMMON
+#define OLC_PGE_COMMON
+
+#ifdef _WIN32
+	// Link to libraries
+#ifndef __MINGW32__
+	#pragma comment(lib, "user32.lib")
+	#pragma comment(lib, "gdi32.lib")
+	#pragma comment(lib, "gdiplus.lib")
+#else
+	// In Code::Blocks, Select C++14 in your build options, and add the
+	// following libs to your linker: user32 gdi32 opengl32 gdiplus
+	#if !defined _WIN32_WINNT
+        #ifdef HAVE_MSMF
+            #define _WIN32_WINNT 0x0600 // Windows Vista
+        #else
+            #define _WIN32_WINNT 0x0500 // Windows 2000
+        #endif
+    #endif
+#endif
+	// Include WinAPI
+	#include <windows.h>
+    #include <gdiplus.h>
+#else
+#endif
+
+#include <string>
+#include <cmath>
+
+namespace olc {
+    enum rcode {
+        FAIL = 0,
+        OK = 1,
+        NO_FILE = -1,
+    };
+    std::wstring ConvertS2W(std::string s);
+
+    
+	template <class T>
+	struct v2d_generic
+	{
+		T x = 0;
+		T y = 0;
+
+		inline v2d_generic() : x(0), y(0)                        {                                                      }
+		inline v2d_generic(T _x, T _y) : x(_x), y(_y)            {                                                      }
+		inline v2d_generic(const v2d_generic& v) : x(v.x), y(v.y){                                                      }
+		inline T mag()                                           { return sqrt(x * x + y * y);                          }
+		inline v2d_generic  norm()                               { T r = 1 / mag(); return v2d_generic(x*r, y*r);       }
+		inline v2d_generic  perp()                               { return v2d_generic(-y, x);                           }
+		inline T dot(const v2d_generic& rhs)                     { return this->x * rhs.x + this->y * rhs.y;            }
+		inline T cross(const v2d_generic& rhs)                   { return this->x * rhs.y - this->y * rhs.x;            }
+		inline v2d_generic  operator +  (const v2d_generic& rhs) const { return v2d_generic(this->x + rhs.x, this->y + rhs.y);}
+		inline v2d_generic  operator -  (const v2d_generic& rhs) const { return v2d_generic(this->x - rhs.x, this->y - rhs.y);}
+		inline v2d_generic  operator *  (const T& rhs)           const { return v2d_generic(this->x * rhs, this->y * rhs);    }
+		inline v2d_generic  operator /  (const T& rhs)           const { return v2d_generic(this->x / rhs, this->y / rhs);    }
+		inline v2d_generic& operator += (const v2d_generic& rhs) { this->x += rhs.x; this->y += rhs.y; return *this;    }
+		inline v2d_generic& operator -= (const v2d_generic& rhs) { this->x -= rhs.x; this->y -= rhs.y; return *this;    }
+		inline v2d_generic& operator *= (const T& rhs)           { this->x *= rhs; this->y *= rhs; return *this;        }
+		inline v2d_generic& operator /= (const T& rhs)           { this->x /= rhs; this->y /= rhs; return *this;        }
+		inline T& operator [] (std::size_t i)                    { return *((T*)this + i);	   /* <-- D'oh :( */        }
+	};
+
+	template<class T> inline v2d_generic<T> operator * (const float& lhs, const v2d_generic<T>& rhs) { return v2d_generic<T>(lhs * rhs.x, lhs * rhs.y); }
+	template<class T> inline v2d_generic<T> operator * (const double& lhs, const v2d_generic<T>& rhs){ return v2d_generic<T>(lhs * rhs.x, lhs * rhs.y); }
+	template<class T> inline v2d_generic<T> operator * (const int& lhs, const v2d_generic<T>& rhs)   { return v2d_generic<T>(lhs * rhs.x, lhs * rhs.y); }
+	template<class T> inline v2d_generic<T> operator / (const float& lhs, const v2d_generic<T>& rhs) { return v2d_generic<T>(lhs / rhs.x, lhs / rhs.y); }
+	template<class T> inline v2d_generic<T> operator / (const double& lhs, const v2d_generic<T>& rhs){ return v2d_generic<T>(lhs / rhs.x, lhs / rhs.y); }
+	template<class T> inline v2d_generic<T> operator / (const int& lhs, const v2d_generic<T>& rhs)   { return v2d_generic<T>(lhs / rhs.x, lhs / rhs.y); }
+
+	typedef v2d_generic<int> vi2d;
+	typedef v2d_generic<float> vf2d;
+	typedef v2d_generic<double> vd2d;
+}
+
+#endif

pge/include/olcPGE_Pixel.h

+#ifndef OLC_PGE_PIXEL
+#define OLC_PGE_PIXEL
+
+#include <cstdint>
+#include "olcPGE_Common.h"
+
+namespace olc {
+    struct Pixel
+	{
+		union
+		{
+			uint32_t n = 0xFF000000;
+			struct
+			{
+				uint8_t r;	uint8_t g;	uint8_t b;	uint8_t a;
+			};
+		};
+
+		Pixel();
+		Pixel(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha = 255);
+		Pixel(uint32_t p);
+
+		static Pixel CreateFromHSV(uint8_t h, uint8_t s, uint8_t v, uint8_t alpha = 255);
+		enum Mode { NORMAL, MASK, ALPHA, CUSTOM };
+	};
+
+	// Some constants for symbolic naming of Pixels
+	static const Pixel
+		WHITE(255, 255, 255),
+		GREY(192, 192, 192), DARK_GREY(128, 128, 128), VERY_DARK_GREY(64, 64, 64),
+		RED(255, 0, 0), DARK_RED(128, 0, 0), VERY_DARK_RED(64, 0, 0),
+		YELLOW(255, 255, 0), DARK_YELLOW(128, 128, 0), VERY_DARK_YELLOW(64, 64, 0),
+		GREEN(0, 255, 0), DARK_GREEN(0, 128, 0), VERY_DARK_GREEN(0, 64, 0),
+		CYAN(0, 255, 255), DARK_CYAN(0, 128, 128), VERY_DARK_CYAN(0, 64, 64),
+		BLUE(0, 0, 255), DARK_BLUE(0, 0, 128), VERY_DARK_BLUE(0, 0, 64),
+		MAGENTA(255, 0, 255), DARK_MAGENTA(128, 0, 128), VERY_DARK_MAGENTA(64, 0, 64),
+		BLACK(0, 0, 0),
+		BLANK(0, 0, 0, 0);
+
+	//==================================================================================
+}
+
+#endif

pge/include/olcPGE_ResourcePack.h

+#ifndef OLC_PGE_RESOURCE_PACK
+#define OLC_PGE_RESOURCE_PACK
+
+#include <cstdint>
+#include <string>
+#include <map>
+#include <vector>
+#include <streambuf>
+#include <iostream>
+#include <fstream>
+#include "olcPGE_Common.h"
+
+namespace olc {
+	class ResourcePack
+	{
+	public:
+		ResourcePack();
+		~ResourcePack();
+		struct sEntry : public std::streambuf {
+			uint32_t nID, nFileOffset, nFileSize; uint8_t* data; void _config() { this->setg((char*)data, (char*)data, (char*)(data + nFileSize)); }
+		};
+
+	public:
+		olc::rcode AddToPack(std::string sFile);
+		olc::rcode RemoveFromPack(std::string sFile);
+
+	public:
+		olc::rcode SavePack(std::string sFile);
+		olc::rcode LoadPack(std::string sFile);
+		olc::rcode ClearPack();
+
+	public:
+		olc::ResourcePack::sEntry GetStreamBuffer(std::string sFile);
+		std::vector<std::string> GetEntries();
+
+	private:
+		std::map<std::string, sEntry> mapFiles;
+	};
+}
+#endif

pge/include/olcPGE_Sprite.h

+#ifndef OLC_PGE_SPRITE
+#define OLC_PGE_SPRITE
+
+#ifdef _WIN32
+	// Link to libraries
+#ifndef __MINGW32__
+	#pragma comment(lib, "user32.lib")		// Visual Studio Only
+	#pragma comment(lib, "gdi32.lib")		// For other Windows Compilers please add
+	#pragma comment(lib, "gdiplus.lib")		// these libs to your linker input
+#else
+	// In Code::Blocks, Select C++14 in your build options, and add the
+	// following libs to your linker: user32 gdi32 opengl32 gdiplus
+	#if !defined _WIN32_WINNT
+        #ifdef HAVE_MSMF
+            #define _WIN32_WINNT 0x0600 // Windows Vista
+        #else
+            #define _WIN32_WINNT 0x0500 // Windows 2000
+        #endif
+    #endif
+#endif
+	// Include WinAPI
+	#include <windows.h>
+	#include <gdiplus.h>
+#else
+	#include <png.h>
+#endif
+
+#include <cstdint>
+#include <cmath>
+#include <string>
+#include <map>
+#include <vector>
+#include <streambuf>
+#include <iostream>
+#include <fstream>
+#include "olcPGE_Common.h"
+#include "olcPGE_Pixel.h"
+#include "olcPGE_ResourcePack.h"
+
+namespace olc {
+	// A bitmap-like structure that stores a 2D array of Pixels
+	class Sprite
+	{
+	public:
+		Sprite();
+		Sprite(std::string sImageFile);
+		Sprite(std::string sImageFile, olc::ResourcePack *pack);
+		Sprite(int32_t w, int32_t h);
+		~Sprite();
+
+	public:
+		olc::rcode LoadFromFile(std::string sImageFile, olc::ResourcePack *pack = nullptr);
+		olc::rcode LoadFromPGESprFile(std::string sImageFile, olc::ResourcePack *pack = nullptr);
+		olc::rcode SaveToPGESprFile(std::string sImageFile);
+
+	public:
+		int32_t width = 0;
+		int32_t height = 0;
+		enum Mode { NORMAL, PERIODIC };
+
+	public:
+		void SetSampleMode(olc::Sprite::Mode mode = olc::Sprite::Mode::NORMAL);
+		Pixel GetPixel(int32_t x, int32_t y);
+		bool  SetPixel(int32_t x, int32_t y, Pixel p);
+
+		Pixel Sample(float x, float y);
+		Pixel SampleBL(float u, float v);
+		Pixel* GetData();
+
+	private:
+		Pixel *pColData = nullptr;
+		Mode modeSample = Mode::NORMAL;
+
+#ifdef OLC_DBG_OVERDRAW
+	public:
+		static int nOverdrawCount;
+#endif
+	};
+}
+#endif

pge/include/olcPixelGameEngine.h

+/*
+	olcPixelGameEngine.h
+
+	+-------------------------------------------------------------+
+	|           OneLoneCoder Pixel Game Engine v1.17              |
+	| "Like the command prompt console one, but not..." - javidx9 |
+	+-------------------------------------------------------------+
+
+	What is this?
+	~~~~~~~~~~~~~
+	The olcConsoleGameEngine has been a surprising and wonderful success for me,
+	and I'm delighted how people have reacted so positively towards it, so thanks
+	for that.
+
+	However, there are limitations that I simply cannot avoid. Firstly, I need to
+	maintain several different versions of it to accommodate users on Windows7,
+	8, 10, Linux, Mac, Visual Studio & Code::Blocks. Secondly, this year I've been
+	pushing the console to the limits of its graphical capabilities	and the effect
+	is becoming underwhelming. The engine itself is not slow at all, but the process
+	that Windows uses to draw the command prompt to the screen is, and worse still,
+	it's dynamic based upon the variation of character colours and glyphs. Sadly
+	I have no control over this, and recent videos that are extremely graphical
+	(for a command prompt :P ) have been dipping to unacceptable framerates. As
+	the channel	has been popular with aspiring game developers, I'm concerned that
+	the visual appeal of the command prompt is perhaps limited to us oldies, and I
+	dont want to alienate younger learners. Finally, I'd like to demonstrate many
+	more algorithms and image processing that exist in the graphical domain, for
+	which the console is insufficient.
+
+	For this reason, I have created olcPixelGameEngine! The look and feel to the
+	programmer is almost identical, so all of my existing code from the videos is
+	easily portable, and the programmer uses this file in exactly the same way. But
+	I've decided that rather than just build a command prompt emulator,	that I
+	would at least harness some modern(ish) portable technologies.
+
+	As a result, the olcPixelGameEngine supports 32-bit colour, is written in a
+	cross-platform style, uses modern(ish) C++ conventions and most importantly,
+	renders much much faster. I	will use this version when my applications are
+	predominantly graphics based, but use the console version when they are
+	predominantly text based - Don't worry, loads more command prompt silliness to
+	come yet, but evolution is important!!
+
+	License (OLC-3)
+	~~~~~~~~~~~~~~~
+
+	Copyright 2018 - 2019 OneLoneCoder.com
+
+	Redistribution and use in source and binary forms, with or without modification,
+	are permitted provided that the following conditions are met:
+
+	1. Redistributions or derivations of source code must retain the above copyright
+	notice, this list of conditions and the following disclaimer.
+
+	2. Redistributions or derivative works in binary form must reproduce the above
+	copyright notice. This list of conditions and the following	disclaimer must be
+	reproduced in the documentation and/or other materials provided with the distribution.
+
+	3. Neither the name of the copyright holder nor the names of its contributors may
+	be used to endorse or promote products derived from this software without specific
+	prior written permission.
+
+	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS	"AS IS" AND ANY
+	EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+	OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+	SHALL THE COPYRIGHT	HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+	INCIDENTAL,	SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+	TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+	BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+	CONTRACT, STRICT LIABILITY, OR TORT	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+	ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+	SUCH DAMAGE.
+
+	Links
+	~~~~~
+	YouTube:	https://www.youtube.com/javidx9
+				https://www.youtube.com/javidx9extra
+	Discord:	https://discord.gg/WhwHUMV
+	Twitter:	https://www.twitter.com/javidx9
+	Twitch:		https://www.twitch.tv/javidx9
+	GitHub:		https://www.github.com/onelonecoder
+	Homepage:	https://www.onelonecoder.com
+	Patreon:	https://www.patreon.com/javidx9
+
+	Relevant Videos
+	~~~~~~~~~~~~~~~
+	https://youtu.be/kRH6oJLFYxY Introducing olcPixelGameEngine
+
+	Compiling in Linux
+	~~~~~~~~~~~~~~~~~~
+	You will need a modern C++ compiler, so update yours!
+	To compile use the command:
+
+	g++ -o YourProgName YourSource.cpp -lX11 -lGL -lpthread -lpng
+
+	On some Linux configurations, the frame rate is locked to the refresh
+	rate of the monitor. This engine tries to unlock it but may not be
+	able to, in which case try launching your program like this:
+
+	vblank_mode=0 ./YourProgName
+
+
+	Compiling in Code::Blocks on Windows
+	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+	Well I wont judge you, but make sure your Code::Blocks installation
+	is really up to date - you may even consider updating your C++ toolchain
+	to use MinGW32-W64, so google this. You will also need to enable C++14
+	in your build options, and add to your linker the following libraries:
+	user32 gdi32 opengl32 gdiplus
+
+	Ports
+	~~~~~
+	olc::PixelGameEngine has been ported and tested with varying degrees of
+	success to: WinXP, Win7, Win8, Win10, Various Linux, Rapberry Pi,
+	Chromebook, Playstation Portable (PSP) and Nintendo Switch. If you are
+	interested in the details of these ports, come and visit the Discord!
+
+	Thanks
+	~~~~~~
+	I'd like to extend thanks to Eremiell, slavka, gurkanctn, Phantim,
+	JackOJC, KrossX, Huhlig, Dragoneye, Appa, JustinRichardsMusic, SliceNDice
+	Ralakus, Gorbit99, raoul, joshinils, benedani & MagetzUb for advice, ideas and
+	testing, and I'd like to extend my appreciation to the 40K YouTube followers,
+	22 Patreons and 2.6K Discord server	members who give me the motivation to keep
+	going with all this :D
+
+	Special thanks to those who bring gifts!
+	GnarGnarHead.......Domina
+	Gorbit99...........Bastion, Ori & The Blind Forest
+	Marti Morta........Gris
+
+	Special thanks to my Patreons too - I wont name you on here, but I've
+	certainly enjoyed my tea and flapjacks :D
+
+	Author
+	~~~~~~
+	David Barr, aka javidx9, ©OneLoneCoder 2018, 2019
+*/
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+/* Example Usage (main.cpp)
+	#define OLC_PGE_APPLICATION
+	#include "olcPixelGameEngine.h"
+	// Override base class with your custom functionality
+	class Example : public olc::PixelGameEngine
+	{
+	public:
+		Example()
+		{
+			sAppName = "Example";
+		}
+	public:
+		bool OnUserCreate() override
+		{
+			// Called once at the start, so create things here
+			return true;
+		}
+		bool OnUserUpdate(float fElapsedTime) override
+		{
+			// called once per frame, draws random coloured pixels
+			for (int x = 0; x < ScreenWidth(); x++)
+				for (int y = 0; y < ScreenHeight(); y++)
+					Draw(x, y, olc::Pixel(rand() % 255, rand() % 255, rand()% 255));
+			return true;
+		}
+	};
+	int main()
+	{
+		Example demo;
+		if (demo.Construct(256, 240, 4, 4))
+			demo.Start();
+		return 0;
+	}
+*/
+
+#ifndef OLC_PGE_DEF
+#define OLC_PGE_DEF
+
+#ifdef _WIN32
+	// Link to libraries
+#ifndef __MINGW32__
+	#pragma comment(lib, "user32.lib")		// Visual Studio Only
+	#pragma comment(lib, "gdi32.lib")		// For other Windows Compilers please add
+	#pragma comment(lib, "opengl32.lib")	// these libs to your linker input
+	#pragma comment(lib, "gdiplus.lib")
+#else
+	// In Code::Blocks, Select C++14 in your build options, and add the
+	// following libs to your linker: user32 gdi32 opengl32 gdiplus
+	#if !defined _WIN32_WINNT
+        #ifdef HAVE_MSMF
+            #define _WIN32_WINNT 0x0600 // Windows Vista
+        #else
+            #define _WIN32_WINNT 0x0500 // Windows 2000
+        #endif
+    #endif
+#endif
+	// Include WinAPI
+	#include <windows.h>
+	#include <gdiplus.h>
+
+	// OpenGL Extension
+	#include <GL/gl.h>
+	typedef BOOL(WINAPI wglSwapInterval_t) (int interval);
+#else
+	#include <GL/gl.h>
+	#include <GL/glx.h>
+	#include <X11/X.h>
+	#include <X11/Xlib.h>
+	typedef int(glSwapInterval_t) (Display *dpy, GLXDrawable drawable, int interval);
+#endif
+
+
+// Standard includes
+#include <cmath>
+#include <cstdint>
+#include <string>
+#include <iostream>
+#include <streambuf>
+#include <chrono>
+#include <vector>
+#include <list>
+#include <thread>
+#include <atomic>
+#include <condition_variable>
+#include <fstream>
+#include <map>
+#include <functional>
+#include <algorithm>
+#include "olcPGE_Common.h"
+#include "olcPGE_Sprite.h"
+#include "olcPGE_ResourcePack.h"
+
+#undef min
+#undef max
+
+namespace olc // All OneLoneCoder stuff will now exist in the "olc" namespace
+{
+	struct HWButton
+	{
+		bool bPressed = false;	// Set once during the frame the event occurs
+		bool bReleased = false;	// Set once during the frame the event occurs
+		bool bHeld = false;		// Set true for all frames between pressed and released events
+	};
+
+	//=============================================================
+
+	enum Key
+	{
+		NONE,
+		A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z,
+		K0, K1, K2, K3, K4, K5, K6, K7, K8, K9,
+		F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12,
+		UP, DOWN, LEFT, RIGHT,
+		SPACE, TAB, SHIFT, CTRL, INS, DEL, HOME, END, PGUP, PGDN,
+		BACK, ESCAPE, RETURN, ENTER, PAUSE, SCROLL,
+		NP0, NP1, NP2, NP3, NP4, NP5, NP6, NP7, NP8, NP9,
+		NP_MUL, NP_DIV, NP_ADD, NP_SUB, NP_DECIMAL,
+	};
+
+
+	//=============================================================
+
+	class PixelGameEngine
+	{
+	public:
+		PixelGameEngine();
+
+	public:
+		olc::rcode	Construct(uint32_t screen_w, uint32_t screen_h, uint32_t pixel_w, uint32_t pixel_h, bool full_screen = false);
+		// Selects maximum pixel size to fit in the display resolution
+		olc::rcode	ConstructAuto(uint32_t screen_w, uint32_t screen_h, bool full_screen = false);
+		olc::rcode	Start();
+
+	public: // Override Interfaces
+		// Called once on application startup, use to load your resources
+		virtual bool OnUserCreate();
+		// Called every frame, and provides you with a time per frame value
+		virtual bool OnUserUpdate(float fElapsedTime);
+		// Called once on application termination, so you can be a clean coder
+		virtual bool OnUserDestroy();
+
+	public: // Hardware Interfaces
+		// Returns true if window is currently in focus
+		bool IsFocused();
+		// Get the state of a specific keyboard button
+		HWButton GetKey(Key k);
+		// Get the state of a specific mouse button
+		HWButton GetMouse(uint32_t b);
+		// Get Mouse X coordinate in "pixel" space
+		int32_t GetMouseX();
+		// Get Mouse Y coordinate in "pixel" space
+		int32_t GetMouseY();
+		// Get Mouse Wheel Delta
+		int32_t GetMouseWheel();
+
+	public: // Utility
+		// Returns the width of the screen in "pixels"
+		int32_t ScreenWidth();
+		// Returns the height of the screen in "pixels"
+		int32_t ScreenHeight();
+		// Returns the width of the currently selected drawing target in "pixels"
+		int32_t GetDrawTargetWidth();
+		// Returns the height of the currently selected drawing target in "pixels"
+		int32_t GetDrawTargetHeight();
+		// Returns the currently active draw target
+		Sprite* GetDrawTarget();
+
+	public: // Draw Routines
+		// Specify which Sprite should be the target of drawing functions, use nullptr
+		// to specify the primary screen
+		void SetDrawTarget(Sprite *target);
+		// Change the pixel mode for different optimisations
+		// olc::Pixel::NORMAL = No transparency
+		// olc::Pixel::MASK   = Transparent if alpha is < 255
+		// olc::Pixel::ALPHA  = Full transparency
+		void SetPixelMode(Pixel::Mode m);
+		Pixel::Mode GetPixelMode();
+		// Use a custom blend function
+		void SetPixelMode(std::function<olc::Pixel(const int x, const int y, const olc::Pixel& pSource, const olc::Pixel& pDest)> pixelMode);
+		// Change the blend factor form between 0.0f to 1.0f;
+		void SetPixelBlend(float fBlend);
+		// Offset texels by sub-pixel amount (advanced, do not use)
+		void SetSubPixelOffset(float ox, float oy);
+
+		// Draws a single Pixel
+		virtual bool Draw(int32_t x, int32_t y, Pixel p = olc::WHITE);
+		// Draws a line from (x1,y1) to (x2,y2)
+		void DrawLine(int32_t x1, int32_t y1, int32_t x2, int32_t y2, Pixel p = olc::WHITE, uint32_t pattern = 0xFFFFFFFF);
+		// Draws a circle located at (x,y) with radius
+		void DrawCircle(int32_t x, int32_t y, int32_t radius, Pixel p = olc::WHITE, uint8_t mask = 0xFF);
+		// Fills a circle located at (x,y) with radius
+		void FillCircle(int32_t x, int32_t y, int32_t radius, Pixel p = olc::WHITE);
+		// Draws a rectangle at (x,y) to (x+w,y+h)
+		void DrawRect(int32_t x, int32_t y, int32_t w, int32_t h, Pixel p = olc::WHITE);
+		// Fills a rectangle at (x,y) to (x+w,y+h)
+		void FillRect(int32_t x, int32_t y, int32_t w, int32_t h, Pixel p = olc::WHITE);
+		// Draws a triangle between points (x1,y1), (x2,y2) and (x3,y3)
+		void DrawTriangle(int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t x3, int32_t y3, Pixel p = olc::WHITE);
+		// Flat fills a triangle between points (x1,y1), (x2,y2) and (x3,y3)
+		void FillTriangle(int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t x3, int32_t y3, Pixel p = olc::WHITE);
+		// Draws an entire sprite at location (x,y)
+		void DrawSprite(int32_t x, int32_t y, Sprite *sprite, uint32_t scale = 1, bool centered = false);
+		// Draws an area of a sprite at location (x,y), where the
+		// selected area is (ox,oy) to (ox+w,oy+h)
+		void DrawPartialSprite(int32_t x, int32_t y, Sprite *sprite, int32_t ox, int32_t oy, int32_t w, int32_t h, uint32_t scale = 1, bool centered = false);
+		// Draws a single line of text
+		void DrawString(int32_t x, int32_t y, std::string sText, Pixel col = olc::WHITE, uint32_t scale = 1);
+		// Clears entire draw target to Pixel
+		void Clear(Pixel p);
+
+	public: // Branding
+		std::string sAppName;
+
+	private: // Inner mysterious workings
+		Sprite		*pDefaultDrawTarget = nullptr;
+		Sprite		*pDrawTarget = nullptr;
+		Pixel::Mode	nPixelMode = Pixel::NORMAL;
+		float		fBlendFactor = 1.0f;
+		uint32_t	nScreenWidth = 256;
+		uint32_t	nScreenHeight = 240;
+		uint32_t	nPixelWidth = 4;
+		uint32_t	nPixelHeight = 4;
+		int32_t		nMousePosX = 0;
+		int32_t		nMousePosY = 0;
+		int32_t		nMouseWheelDelta = 0;
+		int32_t		nMousePosXcache = 0;
+		int32_t		nMousePosYcache = 0;
+		int32_t		nMouseWheelDeltaCache = 0;
+		int32_t		nWindowWidth = 0;
+		int32_t		nWindowHeight = 0;
+		int32_t		nViewX = 0;
+		int32_t		nViewY = 0;
+		int32_t		nViewW = 0;
+		int32_t		nViewH = 0;
+		bool		bFullScreen = false;
+		float		fPixelX = 1.0f;
+		float		fPixelY = 1.0f;
+		float		fSubPixelOffsetX = 0.0f;
+		float		fSubPixelOffsetY = 0.0f;
+		bool		bHasInputFocus = false;
+		bool		bHasMouseFocus = false;
+		float		fFrameTimer = 1.0f;
+		int			nFrameCount = 0;
+		Sprite		*fontSprite = nullptr;
+		std::function<olc::Pixel(const int x, const int y, const olc::Pixel&, const olc::Pixel&)> funcPixelMode;
+
+		static std::map<uint16_t, uint8_t> mapKeys;
+		bool		pKeyNewState[256]{ 0 };
+		bool		pKeyOldState[256]{ 0 };
+		HWButton	pKeyboardState[256];
+
+		bool		pMouseNewState[5]{ 0 };
+		bool		pMouseOldState[5]{ 0 };
+		HWButton	pMouseState[5];
+
+#ifdef _WIN32
+		HDC			glDeviceContext = nullptr;
+		HGLRC		glRenderContext = nullptr;
+#else
+		GLXContext	glDeviceContext = nullptr;
+		GLXContext	glRenderContext = nullptr;
+#endif
+		GLuint		glBuffer;
+
+		void		EngineThread();
+
+		// If anything sets this flag to false, the engine
+		// "should" shut down gracefully
+		static std::atomic<bool> bAtomActive;
+
+		// Common initialisation functions
+		void olc_UpdateMouse(int32_t x, int32_t y);
+		void olc_UpdateMouseWheel(int32_t delta);
+		void olc_UpdateWindowSize(int32_t x, int32_t y);
+		void olc_UpdateViewport();
+		bool olc_OpenGLCreate();
+		void olc_ConstructFontSheet();
+		uint32_t olc_GetMaximumPixelSize(uint32_t w, uint32_t h);
+
+
+#ifdef _WIN32
+		// Windows specific window handling
+		HWND olc_hWnd = nullptr;
+		HWND olc_WindowCreate();
+		std::wstring wsAppName;
+		static LRESULT CALLBACK olc_WindowEvent(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
+#else
+		// Non-Windows specific window handling
+		Display*				olc_Display = nullptr;
+		Window					olc_WindowRoot;
+		Window					olc_Window;
+		XVisualInfo*            olc_VisualInfo;
+		Colormap                olc_ColourMap;
+		XSetWindowAttributes    olc_SetWindowAttribs;
+		XSizeHints			    olc_SizeHints;
+		Display*				olc_WindowCreate();
+#endif
+
+	};
+
+
+	class PGEX
+	{
+		friend class olc::PixelGameEngine;
+	protected:
+		static PixelGameEngine* pge;
+	};
+
+	//=============================================================
+}
+
+#endif // OLC_PGE_DEF

pge/src/olcPGE_Common.cpp

+#include "olcPGE_Common.h"
+
+namespace olc {
+	std::wstring ConvertS2W(std::string s)
+	{
+#ifdef _WIN32
+		int count = MultiByteToWideChar(CP_UTF8, 0, s.c_str(), -1, NULL, 0);
+		wchar_t* buffer = new wchar_t[count];
+		MultiByteToWideChar(CP_UTF8, 0, s.c_str(), -1, buffer, count);
+		std::wstring w(buffer);
+		delete[] buffer;
+		return w;
+#else
+		return L"SVN FTW!";
+#endif
+	}
+	
+#ifdef _WIN32
+	// Thanks @MaGetzUb for this, which allows sprites to be defined
+	// at construction, by initialising the GDI subsystem
+	static class GDIPlusStartup
+	{
+	public:
+		GDIPlusStartup()
+		{
+			Gdiplus::GdiplusStartupInput startupInput;
+			ULONG_PTR	token;
+			Gdiplus::GdiplusStartup(&token, &startupInput, NULL);
+		};
+	} gdistartup;
+#endif
+
+}

pge/src/olcPGE_Pixel.cpp

+#include "olcPGE_Pixel.h"
+
+namespace olc {
+    Pixel::Pixel()
+	{
+		r = 0; g = 0; b = 0; a = 255;
+	}
+
+	Pixel::Pixel(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha)
+	{
+		r = red; g = green; b = blue; a = alpha;
+	}
+
+	Pixel::Pixel(uint32_t p)
+	{
+		n = p;
+	}
+
+	Pixel Pixel::CreateFromHSV(uint8_t h, uint8_t s, uint8_t v, uint8_t alpha) {
+		Pixel rgb;
+		rgb.a = alpha;
+		uint8_t region, remainder, p, q, t;
+
+		if (s == 0)
+		{
+			rgb.r = v;
+			rgb.g = v;
+			rgb.b = v;
+			return rgb;
+		}
+
+		region = h / 43;
+		remainder = (h - (region * 43)) * 6; 
+
+		p = (v * (255 - s)) >> 8;
+		q = (v * (255 - ((s * remainder) >> 8))) >> 8;
+		t = (v * (255 - ((s * (255 - remainder)) >> 8))) >> 8;
+
+		switch (region)
+		{
+			case 0:
+				rgb.r = v; rgb.g = t; rgb.b = p;
+				break;
+			case 1:
+				rgb.r = q; rgb.g = v; rgb.b = p;
+				break;
+			case 2:
+				rgb.r = p; rgb.g = v; rgb.b = t;
+				break;
+			case 3:
+				rgb.r = p; rgb.g = q; rgb.b = v;
+				break;
+			case 4:
+				rgb.r = t; rgb.g = p; rgb.b = v;
+				break;
+			default:
+				rgb.r = v; rgb.g = p; rgb.b = q;
+				break;
+		}
+
+		return rgb;
+	}
+}

pge/src/olcPGE_ResourcePack.cpp

+#include "olcPGE_ResourcePack.h"
+
+namespace olc {
+	ResourcePack::ResourcePack()
+	{
+
+	}
+
+	ResourcePack::~ResourcePack()
+	{
+		ClearPack();
+	}
+
+	olc::rcode ResourcePack::AddToPack(std::string sFile)
+	{
+		std::ifstream ifs(sFile, std::ifstream::binary);
+		if (!ifs.is_open()) return olc::FAIL;
+
+		// Get File Size
+		std::streampos p = 0;
+		p = ifs.tellg();
+		ifs.seekg(0, std::ios::end);
+		p = ifs.tellg() - p;
+		ifs.seekg(0, std::ios::beg);
+
+		// Create entry
+		sEntry e;
+		e.data = nullptr;
+		e.nFileSize = (uint32_t)p;
+
+		// Read file into memory
+		e.data = new uint8_t[(uint32_t)e.nFileSize];
+		ifs.read((char*)e.data, e.nFileSize);
+		ifs.close();
+
+		// Add To Map
+		mapFiles[sFile] = e;
+		return olc::OK;
+	}
+
+	olc::rcode ResourcePack::RemoveFromPack(std::string sFile)
+	{	
+		if (mapFiles.count(sFile) > 0) {	
+			sEntry e = mapFiles.at(sFile);
+			if (e.data != nullptr) {
+				delete[] e.data;
+			}
+			mapFiles.erase(sFile);
+			return olc::OK;
+		} else {
+			return olc::FAIL;
+		}
+	}
+
+	olc::rcode ResourcePack::SavePack(std::string sFile)
+	{
+		std::ofstream ofs(sFile, std::ofstream::binary);
+		if (!ofs.is_open()) return olc::FAIL;
+
+		// 1) Write Map
+		size_t nMapSize = mapFiles.size();
+		ofs.write((char*)&nMapSize, sizeof(size_t));
+		for (auto &e : mapFiles)
+		{
+			size_t nPathSize = e.first.size();
+			ofs.write((char*)&nPathSize, sizeof(size_t));
+			ofs.write(e.first.c_str(), nPathSize);
+			ofs.write((char*)&e.second.nID, sizeof(uint32_t));
+			ofs.write((char*)&e.second.nFileSize, sizeof(uint32_t));
+			ofs.write((char*)&e.second.nFileOffset, sizeof(uint32_t));
+		}
+
+		// 2) Write Data
+		std::streampos offset = ofs.tellp();
+		for (auto &e : mapFiles)
+		{
+			e.second.nFileOffset = (uint32_t)offset;
+			ofs.write((char*)e.second.data, e.second.nFileSize);
+			offset += e.second.nFileSize;
+		}
+
+		// 3) Rewrite Map (it has been updated with offsets now)
+		ofs.seekp(std::ios::beg);
+		ofs.write((char*)&nMapSize, sizeof(size_t));
+		for (auto &e : mapFiles)
+		{
+			size_t nPathSize = e.first.size();
+			ofs.write((char*)&nPathSize, sizeof(size_t));
+			ofs.write(e.first.c_str(), nPathSize);
+			ofs.write((char*)&e.second.nID, sizeof(uint32_t));
+			ofs.write((char*)&e.second.nFileSize, sizeof(uint32_t));
+			ofs.write((char*)&e.second.nFileOffset, sizeof(uint32_t));
+		}
+		ofs.close();
+
+		return olc::OK;
+	}
+
+	olc::rcode ResourcePack::LoadPack(std::string sFile)
+	{
+		std::ifstream ifs(sFile, std::ifstream::binary);
+		if (!ifs.is_open()) return olc::FAIL;
+
+		// 1) Read Map
+		size_t nMapEntries;
+		ifs.read((char*)&nMapEntries, sizeof(size_t));
+		for (size_t i = 0; i < nMapEntries; i++)
+		{
+			size_t nFilePathSize = 0;
+			ifs.read((char*)&nFilePathSize, sizeof(size_t));
+
+			std::string sFileName(nFilePathSize, ' ');
+			for (size_t j = 0; j < nFilePathSize; j++)
+				sFileName[j] = ifs.get();
+
+			sEntry e;
+			e.data = nullptr;
+			ifs.read((char*)&e.nID, sizeof(uint32_t));
+			ifs.read((char*)&e.nFileSize, sizeof(uint32_t));
+			ifs.read((char*)&e.nFileOffset, sizeof(uint32_t));
+			mapFiles[sFileName] = e;
+		}
+
+		// 2) Read Data
+		for (auto &e : mapFiles)
+		{
+			e.second.data = new uint8_t[(uint32_t)e.second.nFileSize];
+			ifs.seekg(e.second.nFileOffset);
+			ifs.read((char*)e.second.data, e.second.nFileSize);
+			e.second._config();
+		}
+
+		ifs.close();
+		return olc::OK;
+	}
+
+	olc::ResourcePack::sEntry ResourcePack::GetStreamBuffer(std::string sFile)
+	{
+		return mapFiles[sFile];
+	}
+
+	std::vector<std::string> ResourcePack::GetEntries() 
+	{
+		std::vector<std::string> result;
+		result.reserve(mapFiles.size());
+		for (auto& e: mapFiles) {
+			result.push_back(e.first);
+		}
+		return result;
+	}
+
+	olc::rcode ResourcePack::ClearPack()
+	{
+		for (auto &e : mapFiles)
+		{
+			if (e.second.data != nullptr)
+				delete[] e.second.data;
+		}
+
+		mapFiles.clear();
+		return olc::OK;
+	}
+}

pge/src/olcPGE_Sprite.cpp

+#include "olcPGE_Sprite.h"
+
+namespace olc {
+	Sprite::Sprite()
+	{
+		pColData = nullptr;
+		width = 0;
+		height = 0;
+	}
+
+	Sprite::Sprite(std::string sImageFile)
+	{
+		LoadFromFile(sImageFile);
+	}
+
+	Sprite::Sprite(std::string sImageFile, olc::ResourcePack *pack)
+	{
+		LoadFromPGESprFile(sImageFile, pack);
+	}
+
+	Sprite::Sprite(int32_t w, int32_t h)
+	{
+		if(pColData) delete[] pColData;
+		width = w;		height = h;
+		pColData = new Pixel[width * height];
+		for (int32_t i = 0; i < width*height; i++)
+			pColData[i] = Pixel();
+	}
+
+	Sprite::~Sprite()
+	{
+		if (pColData) delete pColData;
+	}
+
+	olc::rcode Sprite::LoadFromPGESprFile(std::string sImageFile, olc::ResourcePack *pack)
+	{
+		if (pColData) delete[] pColData;
+
+		auto ReadData = [&](std::istream &is)
+		{
+			is.read((char*)&width, sizeof(int32_t));
+			is.read((char*)&height, sizeof(int32_t));
+			pColData = new Pixel[width * height];
+			is.read((char*)pColData, width * height * sizeof(uint32_t));
+		};
+
+		// These are essentially Memory Surfaces represented by olc::Sprite
+		// which load very fast, but are completely uncompressed
+		if (pack == nullptr)
+		{
+			std::ifstream ifs;
+			ifs.open(sImageFile, std::ifstream::binary);
+			if (ifs.is_open())
+			{
+				ReadData(ifs);
+				return olc::OK;
+			}
+			else
+				return olc::FAIL;
+		}
+		else
+		{
+			auto streamBuffer = pack->GetStreamBuffer(sImageFile);
+			if (streamBuffer.data == nullptr) 
+				return olc::FAIL;
+				
+			std::istream is(&streamBuffer);
+			ReadData(is);
+			return olc::OK;
+		}
+
+		return olc::FAIL;
+	}
+
+	olc::rcode Sprite::SaveToPGESprFile(std::string sImageFile)
+	{
+		if (pColData == nullptr) return olc::FAIL;
+
+		std::ofstream ofs;
+		ofs.open(sImageFile, std::ifstream::binary);
+		if (ofs.is_open())
+		{
+			ofs.write((char*)&width, sizeof(int32_t));
+			ofs.write((char*)&height, sizeof(int32_t));
+			ofs.write((char*)pColData, width*height*sizeof(uint32_t));
+			ofs.close();
+			return olc::OK;
+		}
+
+		return olc::FAIL;
+	}
+
+	olc::rcode Sprite::LoadFromFile(std::string sImageFile, olc::ResourcePack *pack)
+	{
+#ifdef _WIN32
+		// Use GDI+
+		std::wstring wsImageFile;
+#ifdef __MINGW32__
+        wchar_t *buffer = new wchar_t[sImageFile.length() + 1];
+        mbstowcs(buffer, sImageFile.c_str(), sImageFile.length());
+        buffer[sImageFile.length()] = L'\0';
+        wsImageFile = buffer;
+        delete [] buffer;
+#else
+		wsImageFile = ConvertS2W(sImageFile);
+#endif
+        Gdiplus::Bitmap *bmp = Gdiplus::Bitmap::FromFile(wsImageFile.c_str());
+		if (bmp == nullptr)
+			return olc::NO_FILE;
+
+		width = bmp->GetWidth();
+		height = bmp->GetHeight();
+		pColData = new Pixel[width * height];
+
+		for(int x=0; x<width; x++)
+			for (int y = 0; y < height; y++)
+			{
+				Gdiplus::Color c;
+				bmp->GetPixel(x, y, &c);
+				SetPixel(x, y, Pixel(c.GetRed(), c.GetGreen(), c.GetBlue(), c.GetAlpha()));
+			}
+		delete bmp;
+		return olc::OK;
+#else
+		////////////////////////////////////////////////////////////////////////////
+		// Use libpng, Thanks to Guillaume Cottenceau
+		// https://gist.github.com/niw/5963798
+		png_structp png;
+		png_infop info;
+
+		FILE *f = fopen(sImageFile.c_str(), "rb");
+		if (!f) return olc::NO_FILE;
+
+		png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+		if (!png) goto fail_load;
+
+		info = png_create_info_struct(png);
+		if (!info) goto fail_load;
+
+		if (setjmp(png_jmpbuf(png))) goto fail_load;
+
+		png_init_io(png, f);
+		png_read_info(png, info);
+
+		png_byte color_type;
+		png_byte bit_depth;
+		png_bytep *row_pointers;
+		width = png_get_image_width(png, info);
+		height = png_get_image_height(png, info);
+		color_type = png_get_color_type(png, info);
+		bit_depth = png_get_bit_depth(png, info);
+
+#ifdef _DEBUG
+		std::cout << "Loading PNG: " << sImageFile << "\n";
+		std::cout << "W:" << width << " H:" << height << " D:" << (int)bit_depth << "\n";
+#endif
+
+		if (bit_depth == 16) png_set_strip_16(png);
+		if (color_type == PNG_COLOR_TYPE_PALETTE) png_set_palette_to_rgb(png);
+		if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)	png_set_expand_gray_1_2_4_to_8(png);
+		if (png_get_valid(png, info, PNG_INFO_tRNS)) png_set_tRNS_to_alpha(png);
+		if (color_type == PNG_COLOR_TYPE_RGB ||
+			color_type == PNG_COLOR_TYPE_GRAY ||
+			color_type == PNG_COLOR_TYPE_PALETTE)
+			png_set_filler(png, 0xFF, PNG_FILLER_AFTER);
+		if (color_type == PNG_COLOR_TYPE_GRAY ||
+			color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+			png_set_gray_to_rgb(png);
+
+		png_read_update_info(png, info);
+		row_pointers = (png_bytep*)malloc(sizeof(png_bytep) * height);
+		for (int y = 0; y < height; y++) {
+			row_pointers[y] = (png_byte*)malloc(png_get_rowbytes(png, info));
+		}
+		png_read_image(png, row_pointers);
+		////////////////////////////////////////////////////////////////////////////
+
+		// Create sprite array
+		pColData = new Pixel[width * height];
+
+		// Iterate through image rows, converting into sprite format
+		for (int y = 0; y < height; y++)
+		{
+			png_bytep row = row_pointers[y];
+			for (int x = 0; x < width; x++)
+			{
+				png_bytep px = &(row[x * 4]);
+				SetPixel(x, y, Pixel(px[0], px[1], px[2], px[3]));
+			}
+		}
+
+		fclose(f);
+		return olc::OK;
+
+	fail_load:
+		width = 0;
+		height = 0;
+		fclose(f);
+		pColData = nullptr;
+		return olc::FAIL;
+#endif
+	}
+
+	void Sprite::SetSampleMode(olc::Sprite::Mode mode)
+	{
+		modeSample = mode;
+	}
+
+
+	Pixel Sprite::GetPixel(int32_t x, int32_t y)
+	{
+		if (modeSample == olc::Sprite::Mode::NORMAL)
+		{
+			if (x >= 0 && x < width && y >= 0 && y < height)
+				return pColData[y*width + x];
+			else
+				return Pixel(0, 0, 0, 0);
+		}
+		else
+		{
+			return pColData[abs(y%height)*width + abs(x%width)];
+		}
+	}
+
+	bool Sprite::SetPixel(int32_t x, int32_t y, Pixel p)
+	{
+
+#ifdef OLC_DBG_OVERDRAW
+		nOverdrawCount++;
+#endif
+
+		if (x >= 0 && x < width && y >= 0 && y < height)
+		{
+			pColData[y*width + x] = p;
+			return true;
+		}
+		else
+			return false;
+	}
+
+	Pixel Sprite::Sample(float x, float y)
+	{
+		int32_t sx = std::min((int32_t)((x * (float)width)), width - 1);
+		int32_t sy = std::min((int32_t)((y * (float)height)), height - 1);
+		return GetPixel(sx, sy);
+	}
+
+	Pixel Sprite::SampleBL(float u, float v)
+	{
+		u = u * width - 0.5f;
+		v = v * height - 0.5f;
+		int x = (int)floor(u); // cast to int rounds toward zero, not downward
+		int y = (int)floor(v); // Thanks @joshinils
+		float u_ratio = u - x;
+		float v_ratio = v - y;
+		float u_opposite = 1 - u_ratio;
+		float v_opposite = 1 - v_ratio;
+
+		olc::Pixel p1 = GetPixel(std::max(x, 0), std::max(y, 0));
+		olc::Pixel p2 = GetPixel(std::min(x + 1, (int)width - 1), std::max(y, 0));
+		olc::Pixel p3 = GetPixel(std::max(x, 0), std::min(y + 1, (int)height - 1));
+		olc::Pixel p4 = GetPixel(std::min(x + 1, (int)width - 1), std::min(y + 1, (int)height - 1));
+
+		return olc::Pixel(
+			(uint8_t)((p1.r * u_opposite + p2.r * u_ratio) * v_opposite + (p3.r * u_opposite + p4.r * u_ratio) * v_ratio),
+			(uint8_t)((p1.g * u_opposite + p2.g * u_ratio) * v_opposite + (p3.g * u_opposite + p4.g * u_ratio) * v_ratio),
+			(uint8_t)((p1.b * u_opposite + p2.b * u_ratio) * v_opposite + (p3.b * u_opposite + p4.b * u_ratio) * v_ratio));
+	}
+
+	Pixel* Sprite::GetData() { return pColData; }
+}

src/packer.cpp

+#include "olcPGE_Sprite.h"
+#include "olcPGE_ResourcePack.h"
+#include <iostream>
+#include <string>
+
+void PrintUsage() {
+    std::cout << "Usage: packer --list PACK_FILE"            << std::endl;
+    std::cout << "       packer --add PACK_FILE FILE"        << std::endl;
+    std::cout << "       packer --remove PACK_FILE FILE"     << std::endl;
+    std::cout << "       packer --convert PNG_FILE SPR_FILE" << std::endl;
+}
+
+void ListEntries(olc::ResourcePack& pack) {
+    auto entries = pack.GetEntries();
+    std::cout << "Total entries: " << entries.size() << std::endl;
+    for (auto entry: entries) {
+        std::cout << entry << std::endl;
+    }
+}
+
+int main(int argc, char *argv[])
+{
+    std::cout << "ResourcePack tool for PixelGameEngine (onelonecoder.com)" << std::endl;
+    std::string packFile;
+    std::string action;
+
+    if (argc < 3) {
+        PrintUsage();
+        return -1;
+    }
+
+    action = argv[1];
+    packFile = argv[2];
+
+    olc::ResourcePack pack;
+    if (action != "--convert") {
+        pack.LoadPack(packFile);
+    }
+
+    if (action == "--list") {
+        ListEntries(pack);
+    } else if (action == "--add" || action == "--remove") {
+        if (argc < 4) {
+            PrintUsage();
+            return -1;
+        }
+        for (int i = 3; i < argc; i++) {
+            std::string fileName = argv[i];
+            if (action == "--add") {
+                if (!pack.AddToPack(fileName)) {
+                    std::cerr << "Could not open file " << fileName << std::endl;
+                    return -3;
+                }
+                std::cout << "+ " << fileName << std::endl;
+            } else if (action == "--remove") {
+                if (!pack.RemoveFromPack(fileName)) {
+                    std::cerr << "Could not open file " << fileName << std::endl;
+                    return -3;
+                }
+                std::cout << "- " << fileName << std::endl;
+            }
+        }
+        std::cout << std::endl;
+        ListEntries(pack);
+    } else if (action == "--convert") {
+        if (argc < 4) {
+            PrintUsage();
+            return -1;
+        }
+        olc::Sprite sprite;
+        if (sprite.LoadFromFile(packFile) != olc::OK) {
+            std::cerr << "Not valid PNG file " << packFile << std::endl;
+            return -4;
+        }
+        std::string sprFile = argv[3];
+        if (!sprite.SaveToPGESprFile(sprFile)) {
+            std::cerr << "Could not save file " << sprFile << std::endl;
+            return -3;
+        }
+        return 0;
+    } else {
+        PrintUsage();
+        return -1;
+    }
+
+    if (!pack.SavePack(packFile)) {
+        std::cerr << "Could not save file " << packFile << std::endl;
+    }
+
+    return 0;
+}