Makefile for resources

.gitignore

@@ -2,3 +2,5 @@ awoorwa
 awoorwae
 *.exe
 *.o
+*.pack
+*.spr

.vscode/settings.json

@@ -3,6 +3,64 @@
         "*.py": "python",
         "cstdint": "cpp",
         "algorithm": "cpp",
-        "fstream": "cpp"
+        "fstream": "cpp",
+        "cmath": "cpp",
+        "chrono": "cpp",
+        "cctype": "cpp",
+        "clocale": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "hash_map": "cpp",
+        "strstream": "cpp",
+        "*.tcc": "cpp",
+        "bitset": "cpp",
+        "complex": "cpp",
+        "condition_variable": "cpp",
+        "deque": "cpp",
+        "list": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "functional": "cpp",
+        "initializer_list": "cpp",
+        "iomanip": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "ostream": "cpp",
+        "numeric": "cpp",
+        "ratio": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "system_error": "cpp",
+        "thread": "cpp",
+        "cfenv": "cpp",
+        "cinttypes": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "utility": "cpp",
+        "typeindex": "cpp",
+        "typeinfo": "cpp",
+        "optional": "cpp",
+        "string_view": "cpp",
+        "memory": "cpp",
+        "iterator": "cpp",
+        "map": "cpp",
+        "memory_resource": "cpp",
+        "random": "cpp",
+        "set": "cpp",
+        "string": "cpp"
     }
 }

Makefile

@@ -1,12 +1,14 @@
 # To compile this you will need MinGW with MSYS installed in PATH
 
-CPPFLAGS=-Wall -Wno-misleading-indentation -Werror --std=c++1z -g -flto
+CPPFLAGS=-Wall -Wno-misleading-indentation -Werror --std=c++1z
 LDFLAGS=
 INCLUDES=-Ipge/include
 EXECUTABLE=awoorwae
+PACKER=packer/packer
 ifeq ($(OS),Windows_NT)
 	LIBRARIES=-luser32 -lgdi32 -lopengl32 -lgdiplus -lwinmm
 	EXECUTABLE+=.exe
+	PACKER+=.exe
 	LDFLAGS+=--machine=windows
 	CPP=i686-w64-mingw32-g++
 	CC=i686-w64-mingw32-gcc
@@ -15,21 +17,33 @@ else
 	CC=gcc
 	CPP=g++
 endif
+ifeq ($(DEBUG),1)
+	CPPFLAGS+=-g -Og
+else
+	CPPFLAGS+=-flto -O3
+endif
 SOURCES=$(wildcard src/*.cpp) $(wildcard src/**/*.cpp) $(wildcard pge/src/*.cpp)
+IMAGES=$(wildcard res/*.png)
+
 OBJECTS=$(SOURCES:.cpp=.o)
+SPRITES=$(IMAGES:.png=.spr)
 
-all: $(SOURCES) $(EXECUTABLE)
-	$(MAKE) -C packer all
+all: $(SOURCES) $(SPRITES) $(EXECUTABLE)
 
 clean: 
-	$(RM) $(OBJECTS) $(EXECUTABLE)
-	$(MAKE) -C packer clean
+	$(RM) $(OBJECTS) $(SPRITES) $(EXECUTABLE)
 	
-$(EXECUTABLE): $(OBJECTS) 
+$(EXECUTABLE): $(OBJECTS)
 	$(CPP) $(LDFLAGS) $(OBJECTS) -o $@ $(LIBRARIES)
 
 .cpp.o:
 	$(CPP) $(INCLUDES) -c $(CPPFLAGS) $< -o $@
 
-run: $(EXECUTABLE)
+%.spr: %.png $(PACKER)
+	$(PACKER) --convert $< $@
+
+run: $(SPRITES) $(EXECUTABLE)
 	./$(EXECUTABLE)
+
+$(PACKER):
+	$(MAKE) -C packer

packer/.gitignore

@@ -1,3 +1,4 @@
 *.pack
+*.spr
 *.o
 packer

packer/Makefile

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

packer/packer.cpp

@@ -1,3 +1,4 @@
+#include "olcPGE_Sprite.h"
 #include "olcPGE_ResourcePack.h"
 #include <iostream>
 #include <string>
@@ -6,7 +7,7 @@ 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;
+    std::cout << "       packer --convert PNG_FILE SPR_FILE" << std::endl;
 }
 
 void ListEntries(olc::ResourcePack& pack) {
@@ -31,7 +32,9 @@ int main(int argc, char *argv[])
     packFile = argv[2];
 
     olc::ResourcePack pack;
-    pack.LoadPack(packFile);
+    if (action != "--convert") {
+        pack.LoadPack(packFile);
+    }
 
     if (action == "--list") {
         ListEntries(pack);
@@ -58,12 +61,30 @@ int main(int argc, char *argv[])
         }
         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;
     }
 
-    pack.SavePack(packFile);
+    if (!pack.SavePack(packFile)) {
+        std::cerr << "Could not save file " << packFile << std::endl;
+    }
 
     return 0;
 }

pge/include/olcPGE_Common.h

@@ -1,12 +1,35 @@
 #ifndef OLC_PGE_COMMON
 #define OLC_PGE_COMMON
 
+#ifdef _WIN32
+	// Link to libraries
+#ifndef __MINGW32__
+	#pragma comment(lib, "user32.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>
+#else
+#endif
+
+#include <string>
+
 namespace olc {
     enum rcode {
         FAIL = 0,
         OK = 1,
         NO_FILE = -1,
     };
+    std::wstring ConvertS2W(std::string s);
 }
 
 #endif

pge/include/olcPGE_Pixel.h

@@ -0,0 +1,43 @@
+#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_Sprite.h

@@ -0,0 +1,80 @@
+#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

@@ -206,7 +206,6 @@
 	#include <GL/glx.h>
 	#include <X11/X.h>
 	#include <X11/Xlib.h>
-	#include <png.h>
 	typedef int(glSwapInterval_t) (Display *dpy, GLXDrawable drawable, int interval);
 #endif
 
@@ -228,6 +227,7 @@
 #include <functional>
 #include <algorithm>
 #include "olcPGE_Common.h"
+#include "olcPGE_Sprite.h"
 #include "olcPGE_ResourcePack.h"
 
 #undef min
@@ -235,40 +235,6 @@
 
 namespace olc // All OneLoneCoder stuff will now exist in the "olc" namespace
 {
-	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);
-
-	//==================================================================================
-
 	template <class T>
 	struct v2d_generic
 	{
@@ -316,48 +282,6 @@ namespace olc // All OneLoneCoder stuff will now exist in the "olc" namespace
 
 	//=============================================================
 
-	// 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
-
-	};
-
-	//=============================================================
-
 	enum Key
 	{
 		NONE,

pge/src/olcPGE_Common.cpp

@@ -0,0 +1,17 @@
+#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
+	}
+}

pge/src/olcPGE_Pixel.cpp

@@ -0,0 +1,63 @@
+#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_Sprite.cpp

@@ -0,0 +1,268 @@
+#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);
+			std::istream is(&streamBuffer);
+			ReadData(is);
+		}
+
+
+		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; }
+}

pge/src/olcPixelGameEngine.cpp

@@ -8,349 +8,6 @@
 
 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;
-	}
-
-	//==========================================================
-
-	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
-	}
-
-	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);
-			std::istream is(&streamBuffer);
-			ReadData(is);
-		}
-
-
-		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; }
-
-	//==========================================================
-
 	PixelGameEngine::PixelGameEngine()
 	{
 		sAppName = "Undefined";

src/pabloader/awoorwae.cpp

@@ -4,6 +4,17 @@
 
 namespace pabloader {
 
+bool Awoorwae::OnUserCreate() {
+    if (!player->Load()) {
+        std::cerr << "Could not load awoorwa.spr" << std::endl;
+        return false;
+    }
+
+    SetPixelMode(olc::Pixel::MASK);
+
+    return true;
+}
+
 bool Awoorwae::OnUserUpdate(float fElapsedTime)
 {
     Clear(olc::BLACK);
@@ -25,35 +36,40 @@ Entity::Entity(Awoorwae* game_, float x_, float y_)
     yv = 10;
 }
 
+olc::rcode Entity::Load() 
+{
+    return img.LoadFromPGESprFile("res/awoorwa.spr");
+}
+
 void Entity::Update(float dt)
 {
     x += dt * xv;
     y += dt * yv;
 
-    if (x > game->ScreenWidth() - 20) {
-        xv *= -1;
-        x = game->ScreenWidth() - 20;
+    if (x > game->ScreenWidth() - img.width) {
+        xv *= -1.1;
+        x = game->ScreenWidth() - img.width;
     }
 
-    if (x < 20) {
+    if (x < 0) {
         xv *= -1.1;
-        x = 20;
+        x = 0;
     }
 
-    if (y > game->ScreenHeight() - 20) {
-        yv *= -1;
-        y = game->ScreenHeight() - 20;
+    if (y > game->ScreenHeight() - img.height) {
+        yv *= -1.1;
+        y = game->ScreenHeight() - img.height;
     }
 
-    if (y < 20) {
+    if (y < 0) {
         yv *= -1.1;
-        y = 20;
+        y = 0;
     }
     color = fmodf(color + 256 * dt, 256);
 }
 
 void Entity::Draw()
 {
-    game->DrawCircle((int)x, (int)y, 20, olc::Pixel::CreateFromHSV((int)color, 255, 255));
+    game->DrawSprite((int)x, (int)y, &img);
 }
 }

src/pabloader/awoorwae.h

@@ -10,6 +10,7 @@ class Awoorwae;
 class Entity {
 private:
     Awoorwae* game;
+    olc::Sprite img;
     float x;
     float y;
     float xv;
@@ -21,6 +22,7 @@ public:
 
     void Update(float dt);
     void Draw();
+    olc::rcode Load(); 
 };
 
 class Awoorwae : public olc::PixelGameEngine {
@@ -40,11 +42,7 @@ public:
     }
 
 public:
-    bool OnUserCreate() override
-    {
-        return true;
-    }
-
+    bool OnUserCreate() override;
     bool OnUserUpdate(float fElapsedTime) override;
 };
 }