From 145854d9456820b518bf9b4c91c3411015c41093 Mon Sep 17 00:00:00 2001 From: Ben Date: Tue, 5 Feb 2019 16:02:30 +0000 Subject: [PATCH] MAZE --- C++/Maze/main.cpp | 68 + C++/Maze/olcPixelGameEngine.h | 2534 +++++++++++++++++++++++++++++++++ C++/Maze/output.o | Bin 0 -> 496208 bytes 3 files changed, 2602 insertions(+) create mode 100644 C++/Maze/main.cpp create mode 100644 C++/Maze/olcPixelGameEngine.h create mode 100755 C++/Maze/output.o diff --git a/C++/Maze/main.cpp b/C++/Maze/main.cpp new file mode 100644 index 0000000..c92bf25 --- /dev/null +++ b/C++/Maze/main.cpp @@ -0,0 +1,68 @@ +#define OLC_PGE_APPLICATION +#include "olcPixelGameEngine.h" + +#include +#include + +typedef enum class Direction { + NORTH, + SOUTH, + EAST, + WEST +} Direction; + +struct Cell { + bool visited = false; + int width = 3; +}; + +class Maze : public olc::PixelGameEngine { +public: + Maze() + : m_mazeDimensions(50, 50) { + sAppName = "Maze"; + } + + bool OnUserCreate() { + m_maze = new Cell[m_mazeDimensions.x * m_mazeDimensions.y]; + m_maze[0].visited = true; + m_stack.push({0, 0}); + return true; + } + + bool OnUserUpdate(float fElapsedTime) { + + + draw(); + + return true; + } + + void draw() { + + for (int x = 0; x < m_mazeDimensions.x; x++) { + for (int y = 0; y < m_mazeDimensions.y; y++) { + int index = x + y * m_mazeDimensions.x; + int width = m_maze[index].width; + + if (m_maze[index].visited) { + DrawRect(x + m_mazeDimensions.x * width, y + m_mazeDimensions.y * width, width, width, olc::BLACK); + } else { + DrawRect(x + m_mazeDimensions.x * width, y + m_mazeDimensions.y * width, width, width, olc::RED); + } + } + } + + } +private: + std::stack> m_stack; + Vec2 m_mazeDimensions; + Cell* m_maze; +}; + +int main(int argc, char** argv) { + Maze maze; + maze.Construct(500,500,2,2); + maze.Start(); + // return 0; +} diff --git a/C++/Maze/olcPixelGameEngine.h b/C++/Maze/olcPixelGameEngine.h new file mode 100644 index 0000000..4382a62 --- /dev/null +++ b/C++/Maze/olcPixelGameEngine.h @@ -0,0 +1,2534 @@ +/* + olcPixelGameEngine.h + + +-------------------------------------------------------------+ + | OneLoneCoder Pixel Game Engine v1.12 | + | "Like the command prompt console one, but not..." - javidx9 | + +-------------------------------------------------------------+ + + What is this? + ~~~~~~~~~~~~~ + The olcConsoleGameEngine has been a surprsing 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 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 + + 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 + + Thanks + ~~~~~~ + I'd like to extend thanks to Eremiell, slavka, gurkanctn, Phantim, + JackOJC, KrossX, Huhlig, Dragoneye, Appa, JustinRichardsMusic, SliceNDice + Ralakus, Gorbit99, raoul & MagetzUb for advice, ideas and testing, and I'd like + to extend my appreciation to the 23K YouTube followers and 1.5K 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 + + 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 +#endif + // Include WinAPI + #include + #include + + // OpenGL Extension + #include + typedef BOOL(WINAPI wglSwapInterval_t) (int interval); + static wglSwapInterval_t *wglSwapInterval; +#else + #include + #include + #include + #include + #include + typedef int(glSwapInterval_t) (Display *dpy, GLXDrawable drawable, int interval); + static glSwapInterval_t *glSwapIntervalEXT; +#endif + + +// Standard includes +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#undef min +#undef max + +class Rect; + +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); + 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); + + enum rcode + { + FAIL = 0, + OK = 1, + NO_FILE = -1, + }; + + //============================================================= + + 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 tru for all frames between pressed and released events + }; + + //============================================================= + + 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); + + public: + olc::rcode SavePack(std::string sFile); + olc::rcode LoadPack(std::string sFile); + olc::rcode ClearPack(); + + public: + olc::ResourcePack::sEntry GetStreamBuffer(std::string sFile); + + private: + + std::map mapFiles; + }; + + //============================================================= + + // 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); + void SetPixel(int32_t x, int32_t y, Pixel p); + Pixel Sample(float x, float y); + Pixel* GetData(); + + private: + Pixel *pColData = nullptr; + Mode modeSample = Mode::NORMAL; + +#ifdef OLC_DBG_OVERDRAW + public: + static int nOverdrawCount; +#endif + + }; + + //============================================================= + + enum Key + { + 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); + 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(); + + 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 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 void 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); + // Draws a circle located at (x,y) with radius + void DrawCircle(int32_t x, int32_t y, int32_t radius, Pixel p = olc::WHITE); + // 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); + // 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); + // 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; + 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 funcPixelMode; + + static std::map 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 bAtomActive; + + // Common initialisation functions + void olc_UpdateMouse(int32_t x, int32_t y); + bool olc_OpenGLCreate(); + void olc_ConstructFontSheet(); + +#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; + Display* olc_WindowCreate(); +#endif + + }; + + + class PGEX + { + friend class olc::PixelGameEngine; + protected: + static PixelGameEngine* pge; + }; + + //============================================================= +} + +#endif // OLC_PGE_DEF + + + + +/* + Object Oriented Mode + ~~~~~~~~~~~~~~~~~~~~ + + If the olcPixelGameEngine.h is called from several sources it can cause + multiple definitions of objects. To prevent this, ONLY ONE of the pathways + to including this file must have OLC_PGE_APPLICATION defined before it. This prevents + the definitions being duplicated. + + Consider the following project structure: + + Class1.h - Includes olcPixelGameEngine.h, overrides olc::PixelGameEngine + Class1.cpp - #define OLC_PGE_APPLICATION #include "Class1.h" + Class2.h - Includes Class1.h, which includes olcPixelGameEngine.h + Class2.cpp - #define OLC_PGE_APPLICATION #include "Class2.h" + main.cpp - Includes Class1.h and Class2.h + + If all of this is a bit too confusing, you can split this file in two! + Everything below this comment block can go into olcPixelGameEngineOOP.cpp + and everything above it can go into olcPixelGameEngineOOP.h + +*/ + +#ifdef OLC_PGE_APPLICATION +#undef OLC_PGE_APPLICATION + +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; + } + + //========================================================== + +// 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; +// #endif +//#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 + // } + + 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; xGetPixel(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)]; + } + } + + void 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; + } + + Pixel Sprite::Sample(float x, float y) + { + int32_t sx = (int32_t)(x * (float)width); + int32_t sy = (int32_t)(y * (float)height); + return GetPixel(sx, sy); + } + + Pixel* Sprite::GetData() { return pColData; } + + //========================================================== + + 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::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]; + } + + olc::rcode ResourcePack::ClearPack() + { + for (auto &e : mapFiles) + { + if (e.second.data != nullptr) + delete[] e.second.data; + } + + mapFiles.clear(); + return olc::OK; + } + + //========================================================== + + PixelGameEngine::PixelGameEngine() + { + sAppName = "Undefined"; + olc::PGEX::pge = this; + } + + olc::rcode PixelGameEngine::Construct(uint32_t screen_w, uint32_t screen_h, uint32_t pixel_w, uint32_t pixel_h) + { + nScreenWidth = screen_w; + nScreenHeight = screen_h; + nPixelWidth = pixel_w; + nPixelHeight = pixel_h; + + fPixelX = 2.0f / (float)(nScreenWidth); + fPixelY = 2.0f / (float)(nScreenHeight); + + if (nPixelWidth == 0 || nPixelHeight == 0 || nScreenWidth == 0 || nScreenHeight == 0) + return olc::FAIL; + +#ifdef _WIN32 +#ifdef UNICODE +#ifndef __MINGW32__ + wsAppName = ConvertS2W(sAppName); +#endif +#endif +#endif + // Load the default font sheet + olc_ConstructFontSheet(); + + // Create a sprite that represents the primary drawing target + pDefaultDrawTarget = new Sprite(nScreenWidth, nScreenHeight); + SetDrawTarget(nullptr); + return olc::OK; + } + + olc::rcode PixelGameEngine::Start() + { + // Construct the window + if (!olc_WindowCreate()) + return olc::FAIL; + + // Load libraries required for PNG file interaction +#ifdef _WIN32 + // Windows use GDI+ + Gdiplus::GdiplusStartupInput startupInput; + ULONG_PTR token; + Gdiplus::GdiplusStartup(&token, &startupInput, NULL); +#else + // Linux use libpng + +#endif + // Start the thread + bAtomActive = true; + std::thread t = std::thread(&PixelGameEngine::EngineThread, this); + +#ifdef _WIN32 + // Handle Windows Message Loop + MSG msg; + while (GetMessage(&msg, NULL, 0, 0) > 0) + { + TranslateMessage(&msg); + DispatchMessage(&msg); + } +#endif + + // Wait for thread to be exited + t.join(); + return olc::OK; + } + + void PixelGameEngine::SetDrawTarget(Sprite *target) + { + if (target) + pDrawTarget = target; + else + pDrawTarget = pDefaultDrawTarget; + } + + Sprite* PixelGameEngine::GetDrawTarget() + { + return pDrawTarget; + } + + int32_t PixelGameEngine::GetDrawTargetWidth() + { + if (pDrawTarget) + return pDrawTarget->width; + else + return 0; + } + + int32_t PixelGameEngine::GetDrawTargetHeight() + { + if (pDrawTarget) + return pDrawTarget->height; + else + return 0; + } + + bool PixelGameEngine::IsFocused() + { + return bHasInputFocus; + } + + HWButton PixelGameEngine::GetKey(Key k) + { + return pKeyboardState[k]; + } + + HWButton PixelGameEngine::GetMouse(uint32_t b) + { + return pMouseState[b]; + } + + int32_t PixelGameEngine::GetMouseX() + { + return nMousePosX; + } + + int32_t PixelGameEngine::GetMouseY() + { + return nMousePosY; + } + + int32_t PixelGameEngine::ScreenWidth() + { + return nScreenWidth; + } + + int32_t PixelGameEngine::ScreenHeight() + { + return nScreenHeight; + } + + void PixelGameEngine::Draw(int32_t x, int32_t y, Pixel p) + { + if (!pDrawTarget) return; + + + if (nPixelMode == Pixel::NORMAL) + { + pDrawTarget->SetPixel(x, y, p); + return; + } + + if (nPixelMode == Pixel::MASK) + { + if(p.a == 255) + pDrawTarget->SetPixel(x, y, p); + return; + } + + if (nPixelMode == Pixel::ALPHA) + { + Pixel d = pDrawTarget->GetPixel(x, y); + float a = (float)(p.a / 255.0f) * fBlendFactor; + float c = 1.0f - a; + float r = a * (float)p.r + c * (float)d.r; + float g = a * (float)p.g + c * (float)d.g; + float b = a * (float)p.b + c * (float)d.b; + pDrawTarget->SetPixel(x, y, Pixel((uint8_t)r, (uint8_t)g, (uint8_t)b)); + return; + } + + if (nPixelMode == Pixel::CUSTOM) + { + pDrawTarget->SetPixel(x, y, funcPixelMode(x, y, p, pDrawTarget->GetPixel(x, y))); + return; + } + } + + void PixelGameEngine::SetSubPixelOffset(float ox, float oy) + { + fSubPixelOffsetX = ox * fPixelX; + fSubPixelOffsetY = oy * fPixelY; + } + + void PixelGameEngine::DrawLine(int32_t x1, int32_t y1, int32_t x2, int32_t y2, Pixel p) + { + int x, y, dx, dy, dx1, dy1, px, py, xe, ye, i; + dx = x2 - x1; dy = y2 - y1; + + // straight lines idea by gurkanctn + if (dx == 0) // Line is vertical + { + if (y2 < y1) std::swap(y1, y2); + for (y = y1; y <= y2; y++) + Draw(x1, y, p); + return; + } + + if (dy == 0) // Line is horizontal + { + if (x2 < x1) std::swap(x1, x2); + for (x = x1; x <= x2; x++) + Draw(x, y1, p); + return; + } + + // Line is Funk-aye + dx1 = abs(dx); dy1 = abs(dy); + px = 2 * dy1 - dx1; py = 2 * dx1 - dy1; + if (dy1 <= dx1) + { + if (dx >= 0) + { + x = x1; y = y1; xe = x2; + } + else + { + x = x2; y = y2; xe = x1; + } + + Draw(x, y, p); + + for (i = 0; x0 && dy>0)) y = y + 1; else y = y - 1; + px = px + 2 * (dy1 - dx1); + } + Draw(x, y, p); + } + } + else + { + if (dy >= 0) + { + x = x1; y = y1; ye = y2; + } + else + { + x = x2; y = y2; ye = y1; + } + + Draw(x, y, p); + + for (i = 0; y0 && dy>0)) x = x + 1; else x = x - 1; + py = py + 2 * (dx1 - dy1); + } + Draw(x, y, p); + } + } + } + + void PixelGameEngine::DrawCircle(int32_t x, int32_t y, int32_t radius, Pixel p) + { + int x0 = 0; + int y0 = radius; + int d = 3 - 2 * radius; + if (!radius) return; + + while (y0 >= x0) // only formulate 1/8 of circle + { + Draw(x - x0, y - y0, p);//upper left left + Draw(x - y0, y - x0, p);//upper upper left + Draw(x + y0, y - x0, p);//upper upper right + Draw(x + x0, y - y0, p);//upper right right + Draw(x - x0, y + y0, p);//lower left left + Draw(x - y0, y + x0, p);//lower lower left + Draw(x + y0, y + x0, p);//lower lower right + Draw(x + x0, y + y0, p);//lower right right + if (d < 0) d += 4 * x0++ + 6; + else d += 4 * (x0++ - y0--) + 10; + } + } + + void PixelGameEngine::FillCircle(int32_t x, int32_t y, int32_t radius, Pixel p) + { + // Taken from wikipedia + int x0 = 0; + int y0 = radius; + int d = 3 - 2 * radius; + if (!radius) return; + + auto drawline = [&](int sx, int ex, int ny) + { + for (int i = sx; i <= ex; i++) + Draw(i, ny, p); + }; + + while (y0 >= x0) + { + // Modified to draw scan-lines instead of edges + drawline(x - x0, x + x0, y - y0); + drawline(x - y0, x + y0, y - x0); + drawline(x - x0, x + x0, y + y0); + drawline(x - y0, x + y0, y + x0); + if (d < 0) d += 4 * x0++ + 6; + else d += 4 * (x0++ - y0--) + 10; + } + } + + void PixelGameEngine::DrawRect(int32_t x, int32_t y, int32_t w, int32_t h, Pixel p) + { + w--; h--; + DrawLine(x, y, x+w, y, p); + DrawLine(x+w, y, x+w, y+h, p); + DrawLine(x+w, y+h, x, y+h, p); + DrawLine(x, y+h, x, y, p); + } + + void PixelGameEngine::Clear(Pixel p) + { + int pixels = GetDrawTargetWidth() * GetDrawTargetHeight(); + Pixel* m = GetDrawTarget()->GetData(); + for (int i = 0; i < pixels; i++) + m[i] = p; +#ifdef OLC_DBG_OVERDRAW + olc::Sprite::nOverdrawCount += pixels; +#endif + } + + void PixelGameEngine::FillRect(int32_t x, int32_t y, int32_t w, int32_t h, Pixel p) + { + int32_t x2 = x + w; + int32_t y2 = y + h; + + if (x < 0) x = 0; + if (x >= (int32_t)nScreenWidth) x = (int32_t)nScreenWidth; + if (y < 0) y = 0; + if (y >= (int32_t)nScreenHeight) y = (int32_t)nScreenHeight; + + if (x2 < 0) x2 = 0; + if (x2 >= (int32_t)nScreenWidth) x2 = (int32_t)nScreenWidth; + if (y2 < 0) y2 = 0; + if (y2 >= (int32_t)nScreenHeight) y2 = (int32_t)nScreenHeight; + + for (int i = x; i < x2; i++) + for (int j = y; j < y2; j++) + Draw(i, j, p); + } + + void PixelGameEngine::DrawTriangle(int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t x3, int32_t y3, Pixel p) + { + DrawLine(x1, y1, x2, y2, p); + DrawLine(x2, y2, x3, y3, p); + DrawLine(x3, y3, x1, y1, p); + } + + // https://www.avrfreaks.net/sites/default/files/triangles.c + void PixelGameEngine::FillTriangle(int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t x3, int32_t y3, Pixel p) + { + auto SWAP = [](int &x, int &y) { int t = x; x = y; y = t; }; + auto drawline = [&](int sx, int ex, int ny) { for (int i = sx; i <= ex; i++) Draw(i, ny, p); }; + + int t1x, t2x, y, minx, maxx, t1xp, t2xp; + bool changed1 = false; + bool changed2 = false; + int signx1, signx2, dx1, dy1, dx2, dy2; + int e1, e2; + // Sort vertices + if (y1>y2) { SWAP(y1, y2); SWAP(x1, x2); } + if (y1>y3) { SWAP(y1, y3); SWAP(x1, x3); } + if (y2>y3) { SWAP(y2, y3); SWAP(x2, x3); } + + t1x = t2x = x1; y = y1; // Starting points + dx1 = (int)(x2 - x1); if (dx1<0) { dx1 = -dx1; signx1 = -1; } + else signx1 = 1; + dy1 = (int)(y2 - y1); + + dx2 = (int)(x3 - x1); if (dx2<0) { dx2 = -dx2; signx2 = -1; } + else signx2 = 1; + dy2 = (int)(y3 - y1); + + if (dy1 > dx1) { // swap values + SWAP(dx1, dy1); + changed1 = true; + } + if (dy2 > dx2) { // swap values + SWAP(dy2, dx2); + changed2 = true; + } + + e2 = (int)(dx2 >> 1); + // Flat top, just process the second half + if (y1 == y2) goto next; + e1 = (int)(dx1 >> 1); + + for (int i = 0; i < dx1;) { + t1xp = 0; t2xp = 0; + if (t1x= dx1) { + e1 -= dx1; + if (changed1) t1xp = signx1;//t1x += signx1; + else goto next1; + } + if (changed1) break; + else t1x += signx1; + } + // Move line + next1: + // process second line until y value is about to change + while (1) { + e2 += dy2; + while (e2 >= dx2) { + e2 -= dx2; + if (changed2) t2xp = signx2;//t2x += signx2; + else goto next2; + } + if (changed2) break; + else t2x += signx2; + } + next2: + if (minx>t1x) minx = t1x; if (minx>t2x) minx = t2x; + if (maxx dx1) { // swap values + SWAP(dy1, dx1); + changed1 = true; + } + else changed1 = false; + + e1 = (int)(dx1 >> 1); + + for (int i = 0; i <= dx1; i++) { + t1xp = 0; t2xp = 0; + if (t1x= dx1) { + e1 -= dx1; + if (changed1) { t1xp = signx1; break; }//t1x += signx1; + else goto next3; + } + if (changed1) break; + else t1x += signx1; + if (i= dx2) { + e2 -= dx2; + if (changed2) t2xp = signx2; + else goto next4; + } + if (changed2) break; + else t2x += signx2; + } + next4: + + if (minx>t1x) minx = t1x; if (minx>t2x) minx = t2x; + if (maxxy3) return; + } + } + + void PixelGameEngine::DrawSprite(int32_t x, int32_t y, Sprite *sprite, uint32_t scale) + { + if (sprite == nullptr) + return; + + if (scale > 1) + { + for (int32_t i = 0; i < sprite->width; i++) + for (int32_t j = 0; j < sprite->height; j++) + for (uint32_t is = 0; is < scale; is++) + for (uint32_t js = 0; js < scale; js++) + Draw(x + (i*scale) + is, y + (j*scale) + js, sprite->GetPixel(i, j)); + } + else + { + for (int32_t i = 0; i < sprite->width; i++) + for (int32_t j = 0; j < sprite->height; j++) + Draw(x + i, y + j, sprite->GetPixel(i, j)); + } + } + + void PixelGameEngine::DrawPartialSprite(int32_t x, int32_t y, Sprite *sprite, int32_t ox, int32_t oy, int32_t w, int32_t h, uint32_t scale) + { + if (sprite == nullptr) + return; + + if (scale > 1) + { + for (int32_t i = 0; i < w; i++) + for (int32_t j = 0; j < h; j++) + for (uint32_t is = 0; is < scale; is++) + for (uint32_t js = 0; js < scale; js++) + Draw(x + (i*scale) + is, y + (j*scale) + js, sprite->GetPixel(i + ox, j + oy)); + } + else + { + for (int32_t i = 0; i < w; i++) + for (int32_t j = 0; j < h; j++) + Draw(x + i, y + j, sprite->GetPixel(i + ox, j + oy)); + } + } + + void PixelGameEngine::DrawString(int32_t x, int32_t y, std::string sText, Pixel col, uint32_t scale) + { + int32_t sx = 0; + int32_t sy = 0; + Pixel::Mode m = nPixelMode; + if(col.ALPHA != 255) SetPixelMode(Pixel::ALPHA); + else SetPixelMode(Pixel::MASK); + for (auto c : sText) + { + if (c == '\n') + { + sx = 0; sy += 8 * scale; + } + else + { + int32_t ox = (c - 32) % 16; + int32_t oy = (c - 32) / 16; + + if (scale > 1) + { + for (uint32_t i = 0; i < 8; i++) + for (uint32_t j = 0; j < 8; j++) + if (fontSprite->GetPixel(i + ox * 8, j + oy * 8).r > 0) + for (uint32_t is = 0; is < scale; is++) + for (uint32_t js = 0; js < scale; js++) + Draw(x + sx + (i*scale) + is, y + sy + (j*scale) + js, col); + } + else + { + for (uint32_t i = 0; i < 8; i++) + for (uint32_t j = 0; j < 8; j++) + if (fontSprite->GetPixel(i + ox * 8, j + oy * 8).r > 0) + Draw(x + sx + i, y + sy + j, col); + } + sx += 8 * scale; + } + } + SetPixelMode(m); + } + + void PixelGameEngine::SetPixelMode(Pixel::Mode m) + { + nPixelMode = m; + } + + Pixel::Mode PixelGameEngine::GetPixelMode() + { + return nPixelMode; + } + + void PixelGameEngine::SetPixelMode(std::function pixelMode) + { + funcPixelMode = pixelMode; + nPixelMode = Pixel::Mode::CUSTOM; + } + + void PixelGameEngine::SetPixelBlend(float fBlend) + { + fBlendFactor = fBlend; + if (fBlendFactor < 0.0f) fBlendFactor = 0.0f; + if (fBlendFactor > 1.0f) fBlendFactor = 1.0f; + } + + // User must override these functions as required. I have not made + // them abstract because I do need a default behaviour to occur if + // they are not overwritten + bool PixelGameEngine::OnUserCreate() + { return false; } + bool PixelGameEngine::OnUserUpdate(float fElapsedTime) + { return false; } + bool PixelGameEngine::OnUserDestroy() + { return true; } + ////////////////////////////////////////////////////////////////// + + void PixelGameEngine::olc_UpdateMouse(int32_t x, int32_t y) + { + // Mouse coords come in screen space + // But leave in pixel space + nMousePosX = x / (int32_t)nPixelWidth; + nMousePosY = y / (int32_t)nPixelHeight; + + if (nMousePosX >= (int32_t)nScreenWidth) + nMousePosX = nScreenWidth - 1; + if (nMousePosY >= (int32_t)nScreenHeight) + nMousePosY = nScreenHeight - 1; + + if (nMousePosX < 0) + nMousePosX = 0; + if (nMousePosY < 0) + nMousePosY = 0; + } + + void PixelGameEngine::EngineThread() + { + // Start OpenGL, the context is owned by the game thread + olc_OpenGLCreate(); + + // Create Screen Texture - disable filtering + glEnable(GL_TEXTURE_2D); + glGenTextures(1, &glBuffer); + glBindTexture(GL_TEXTURE_2D, glBuffer); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); + + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, nScreenWidth, nScreenHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, pDefaultDrawTarget->GetData()); + + + // Create user resources as part of this thread + if (!OnUserCreate()) + bAtomActive = false; + + auto tp1 = std::chrono::system_clock::now(); + auto tp2 = std::chrono::system_clock::now(); + + while (bAtomActive) + { + // Run as fast as possible + while (bAtomActive) + { + // Handle Timing + tp2 = std::chrono::system_clock::now(); + std::chrono::duration elapsedTime = tp2 - tp1; + tp1 = tp2; + + // Our time per frame coefficient + float fElapsedTime = elapsedTime.count(); + +#ifndef _WIN32 + // Handle Xlib Message Loop - we do this in the + // same thread that OpenGL was created so we dont + // need to worry too much about multithreading with X11 + XEvent xev; + while (XPending(olc_Display)) + { + XNextEvent(olc_Display, &xev); + if (xev.type == Expose) + { + XWindowAttributes gwa; + XGetWindowAttributes(olc_Display, olc_Window, &gwa); + glViewport(0, 0, gwa.width, gwa.height); + } + else if (xev.type == KeyPress) + { + KeySym sym = XLookupKeysym(&xev.xkey, 0); + pKeyNewState[mapKeys[sym]] = true; + } + else if (xev.type == KeyRelease) + { + KeySym sym = XLookupKeysym(&xev.xkey, 0); + pKeyNewState[mapKeys[sym]] = false; + } + else if (xev.type == ButtonPress) + { + pMouseNewState[xev.xbutton.button-1] = true; + } + else if (xev.type == ButtonRelease) + { + pMouseNewState[xev.xbutton.button-1] = false; + } + else if (xev.type == MotionNotify) + { + olc_UpdateMouse(xev.xmotion.x, xev.xmotion.y); + } + else if (xev.type == FocusIn) + { + bHasInputFocus = true; + } + else if (xev.type == FocusOut) + { + bHasInputFocus = false; + } + else if (xev.type == ClientMessage) + { + bAtomActive = false; + } + } +#endif + + // Handle User Input - Keyboard + for (int i = 0; i < 256; i++) + { + pKeyboardState[i].bPressed = false; + pKeyboardState[i].bReleased = false; + + if (pKeyNewState[i] != pKeyOldState[i]) + { + if (pKeyNewState[i]) + { + pKeyboardState[i].bPressed = !pKeyboardState[i].bHeld; + pKeyboardState[i].bHeld = true; + } + else + { + pKeyboardState[i].bReleased = true; + pKeyboardState[i].bHeld = false; + } + } + + pKeyOldState[i] = pKeyNewState[i]; + } + + // Handle User Input - Mouse + for (int i = 0; i < 5; i++) + { + pMouseState[i].bPressed = false; + pMouseState[i].bReleased = false; + + if (pMouseNewState[i] != pMouseOldState[i]) + { + if (pMouseNewState[i]) + { + pMouseState[i].bPressed = !pMouseState[i].bHeld; + pMouseState[i].bHeld = true; + } + else + { + pMouseState[i].bReleased = true; + pMouseState[i].bHeld = false; + } + } + + pMouseOldState[i] = pMouseNewState[i]; + } + +#ifdef OLC_DBG_OVERDRAW + olc::Sprite::nOverdrawCount = 0; +#endif + + // Handle Frame Update + if (!OnUserUpdate(fElapsedTime)) + bAtomActive = false; + + // Display Graphics + + // TODO: This is a bit slow (especially in debug, but 100x faster in release mode???) + // Copy pixel array into texture + glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, nScreenWidth, nScreenHeight, GL_RGBA, GL_UNSIGNED_BYTE, pDefaultDrawTarget->GetData()); + + // Display texture on screen + glBegin(GL_QUADS); + glTexCoord2f(0.0, 1.0); glVertex3f(-1.0f + (fSubPixelOffsetX), -1.0f + (fSubPixelOffsetY), 0.0f); + glTexCoord2f(0.0, 0.0); glVertex3f(-1.0f + (fSubPixelOffsetX), 1.0f + (fSubPixelOffsetY), 0.0f); + glTexCoord2f(1.0, 0.0); glVertex3f( 1.0f + (fSubPixelOffsetX), 1.0f + (fSubPixelOffsetY), 0.0f); + glTexCoord2f(1.0, 1.0); glVertex3f( 1.0f + (fSubPixelOffsetX), -1.0f + (fSubPixelOffsetY), 0.0f); + glEnd(); + + // Present Graphics to screen +#ifdef _WIN32 + SwapBuffers(glDeviceContext); +#else + glXSwapBuffers(olc_Display, olc_Window); +#endif + + // Update Title Bar + fFrameTimer += fElapsedTime; + nFrameCount++; + if (fFrameTimer >= 1.0f) + { + fFrameTimer -= 1.0f; + + std::string sTitle = sAppName + " - FPS: " + std::to_string(nFrameCount); +#ifdef _WIN32 +#ifdef UNICODE + SetWindowText(olc_hWnd, ConvertS2W(sTitle).c_str()); +#else + SetWindowText(olc_hWnd, sTitle.c_str()); +#endif +#else + XStoreName(olc_Display, olc_Window, sTitle.c_str()); +#endif + nFrameCount = 0; + } + } + + // Allow the user to free resources if they have overrided the destroy function + if (OnUserDestroy()) + { + // User has permitted destroy, so exit and clean up + } + else + { + // User denied destroy for some reason, so continue running + bAtomActive = true; + } + } + +#ifdef _WIN32 + wglDeleteContext(glRenderContext); + PostMessage(olc_hWnd, WM_DESTROY, 0, 0); +#else + glXMakeCurrent(olc_Display, None, NULL); + glXDestroyContext(olc_Display, glDeviceContext); + XDestroyWindow(olc_Display, olc_Window); + XCloseDisplay(olc_Display); +#endif + + } + + + void PixelGameEngine::olc_ConstructFontSheet() + { + std::string data; + data += "?Q`0001oOch0o01o@F40o000000000"; + data += "O000000nOT0063Qo4d8>?7a14Gno94AA4gno94AaOT0>o3`oO400o7QN00000400"; + data += "Of80001oOg<7O7moBGT7O7lABET024@aBEd714AiOdl717a_=TH013Q>00000000"; + data += "720D000V?V5oB3Q_HdUoE7a9@DdDE4A9@DmoE4A;Hg]oM4Aj8S4D84@`00000000"; + data += "OaPT1000Oa`^13P1@AI[?g`1@A=[OdAoHgljA4Ao?WlBA7l1710007l100000000"; + data += "ObM6000oOfMV?3QoBDD`O7a0BDDH@5A0BDD<@5A0BGeVO5ao@CQR?5Po00000000"; + data += "Oc``000?Ogij70PO2D]??0Ph2DUM@7i`2DTg@7lh2GUj?0TO0C1870T?00000000"; + data += "70<4001o?P<7?1QoHg43O;`h@GT0@:@LB@d0>:@hN@L0@?aoN@<0O7ao0000?000"; + data += "OcH0001SOglLA7mg24TnK7ln24US>0PL24U140PnOgl0>7QgOcH0K71S0000A000"; + data += "00H00000@Dm1S007@DUSg00?OdTnH7YhOfTL<7Yh@Cl0700?@Ah0300700000000"; + data += "<008001QL00ZA41a@6HnI<1i@FHLM81M@@0LG81?O`0nC?Y7?`0ZA7Y300080000"; + data += "O`082000Oh0827mo6>Hn?Wmo?6HnMb11MP08@C11H`08@FP0@@0004@000000000"; + data += "00P00001Oab00003OcKP0006@6=PMgl<@440MglH@000000`@000001P00000000"; + data += "Ob@8@@00Ob@8@Ga13R@8Mga172@8?PAo3R@827QoOb@820@0O`0007`0000007P0"; + data += "O`000P08Od400g`<3V=P0G`673IP0`@3>1`00P@6O`P00g`SetPixel(px, py, olc::Pixel(k, k, k, k)); + if (++py == 48) { px++; py = 0; } + } + } + } + +#ifdef _WIN32 + HWND PixelGameEngine::olc_WindowCreate() + { + WNDCLASS wc; + wc.hIcon = LoadIcon(NULL, IDI_APPLICATION); + wc.hCursor = LoadCursor(NULL, IDC_ARROW); + wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; + wc.hInstance = GetModuleHandle(nullptr); + wc.lpfnWndProc = olc_WindowEvent; + wc.cbClsExtra = 0; + wc.cbWndExtra = 0; + wc.lpszMenuName = nullptr; + wc.hbrBackground = nullptr; +#ifdef UNICODE + wc.lpszClassName = L"OLC_PIXEL_GAME_ENGINE"; +#else + wc.lpszClassName = "OLC_PIXEL_GAME_ENGINE"; +#endif + + RegisterClass(&wc); + + // Define window furniture + DWORD dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; + DWORD dwStyle = WS_CAPTION | WS_SYSMENU | WS_VISIBLE; + RECT rWndRect = { 0, 0, (LONG)nScreenWidth * (LONG)nPixelWidth, (LONG)nScreenHeight * (LONG)nPixelHeight }; + + // Keep client size as requested + AdjustWindowRectEx(&rWndRect, dwStyle, FALSE, dwExStyle); + + int width = rWndRect.right - rWndRect.left; + int height = rWndRect.bottom - rWndRect.top; + +#ifdef UNICODE + olc_hWnd = CreateWindowEx(dwExStyle, L"OLC_PIXEL_GAME_ENGINE", L"", dwStyle, + 30, 30, width, height, NULL, NULL, GetModuleHandle(nullptr), this); +#else + olc_hWnd = CreateWindowEx(dwExStyle, "OLC_PIXEL_GAME_ENGINE", "", dwStyle, + 30, 30, width, height, NULL, NULL, GetModuleHandle(nullptr), this); +#endif + + // Create Keyboard Mapping + mapKeys[0x41] = Key::A; mapKeys[0x42] = Key::B; mapKeys[0x43] = Key::C; mapKeys[0x44] = Key::D; mapKeys[0x45] = Key::E; + mapKeys[0x46] = Key::F; mapKeys[0x47] = Key::G; mapKeys[0x48] = Key::H; mapKeys[0x49] = Key::I; mapKeys[0x4A] = Key::J; + mapKeys[0x4B] = Key::K; mapKeys[0x4C] = Key::L; mapKeys[0x4D] = Key::M; mapKeys[0x4E] = Key::N; mapKeys[0x4F] = Key::O; + mapKeys[0x50] = Key::P; mapKeys[0x51] = Key::Q; mapKeys[0x52] = Key::R; mapKeys[0x53] = Key::S; mapKeys[0x54] = Key::T; + mapKeys[0x55] = Key::U; mapKeys[0x56] = Key::V; mapKeys[0x57] = Key::W; mapKeys[0x58] = Key::X; mapKeys[0x59] = Key::Y; + mapKeys[0x5A] = Key::Z; + + mapKeys[VK_F1] = Key::F1; mapKeys[VK_F2] = Key::F2; mapKeys[VK_F3] = Key::F3; mapKeys[VK_F4] = Key::F4; + mapKeys[VK_F5] = Key::F5; mapKeys[VK_F6] = Key::F6; mapKeys[VK_F7] = Key::F7; mapKeys[VK_F8] = Key::F8; + mapKeys[VK_F9] = Key::F9; mapKeys[VK_F10] = Key::F10; mapKeys[VK_F11] = Key::F11; mapKeys[VK_F12] = Key::F12; + + mapKeys[VK_DOWN] = Key::DOWN; mapKeys[VK_LEFT] = Key::LEFT; mapKeys[VK_RIGHT] = Key::RIGHT; mapKeys[VK_UP] = Key::UP; + mapKeys[VK_RETURN] = Key::ENTER; //mapKeys[VK_RETURN] = Key::RETURN; + + mapKeys[VK_BACK] = Key::BACK; mapKeys[VK_ESCAPE] = Key::ESCAPE; mapKeys[VK_RETURN] = Key::ENTER; mapKeys[VK_PAUSE] = Key::PAUSE; + mapKeys[VK_SCROLL] = Key::SCROLL; mapKeys[VK_TAB] = Key::TAB; mapKeys[VK_DELETE] = Key::DEL; mapKeys[VK_HOME] = Key::HOME; + mapKeys[VK_END] = Key::END; mapKeys[VK_PRIOR] = Key::PGUP; mapKeys[VK_NEXT] = Key::PGDN; mapKeys[VK_INSERT] = Key::INS; + mapKeys[VK_SHIFT] = Key::SHIFT; mapKeys[VK_CONTROL] = Key::CTRL; + mapKeys[VK_SPACE] = Key::SPACE; + + mapKeys[0x30] = Key::K0; mapKeys[0x31] = Key::K1; mapKeys[0x32] = Key::K2; mapKeys[0x33] = Key::K3; mapKeys[0x34] = Key::K4; + mapKeys[0x35] = Key::K5; mapKeys[0x36] = Key::K6; mapKeys[0x37] = Key::K7; mapKeys[0x38] = Key::K8; mapKeys[0x39] = Key::K9; + + mapKeys[VK_NUMPAD0] = Key::NP0; mapKeys[VK_NUMPAD1] = Key::NP1; mapKeys[VK_NUMPAD2] = Key::NP2; mapKeys[VK_NUMPAD3] = Key::NP3; mapKeys[VK_NUMPAD4] = Key::NP4; + mapKeys[VK_NUMPAD5] = Key::NP5; mapKeys[VK_NUMPAD6] = Key::NP6; mapKeys[VK_NUMPAD7] = Key::NP7; mapKeys[VK_NUMPAD8] = Key::NP8; mapKeys[VK_NUMPAD9] = Key::NP9; + mapKeys[VK_MULTIPLY] = Key::NP_MUL; mapKeys[VK_ADD] = Key::NP_ADD; mapKeys[VK_DIVIDE] = Key::NP_DIV; mapKeys[VK_SUBTRACT] = Key::NP_SUB; mapKeys[VK_DECIMAL] = Key::NP_DECIMAL; + + return olc_hWnd; + } + + bool PixelGameEngine::olc_OpenGLCreate() + { + // Create Device Context + glDeviceContext = GetDC(olc_hWnd); + PIXELFORMATDESCRIPTOR pfd = + { + sizeof(PIXELFORMATDESCRIPTOR), 1, + PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER, + PFD_TYPE_RGBA, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + PFD_MAIN_PLANE, 0, 0, 0, 0 + }; + + int pf = 0; + if (!(pf = ChoosePixelFormat(glDeviceContext, &pfd))) return false; + SetPixelFormat(glDeviceContext, pf, &pfd); + + if (!(glRenderContext = wglCreateContext(glDeviceContext))) return false; + wglMakeCurrent(glDeviceContext, glRenderContext); + + // Remove Frame cap + wglSwapInterval = (wglSwapInterval_t*)wglGetProcAddress("wglSwapIntervalEXT"); + wglSwapInterval(0); + return true; + } + + // Windows Event Handler + LRESULT CALLBACK PixelGameEngine::olc_WindowEvent(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) + { + static PixelGameEngine *sge; + switch (uMsg) + { + case WM_CREATE: sge = (PixelGameEngine*)((LPCREATESTRUCT)lParam)->lpCreateParams; return 0; + case WM_MOUSEMOVE: + { + uint16_t x = lParam & 0xFFFF; // Thanks @ForAbby (Discord) + uint16_t y = (lParam >> 16) & 0xFFFF; + int16_t ix = *(int16_t*)&x; + int16_t iy = *(int16_t*)&y; + sge->olc_UpdateMouse(ix, iy); + return 0; + } + case WM_MOUSELEAVE: sge->bHasMouseFocus = false; + case WM_SETFOCUS: sge->bHasInputFocus = true; return 0; + case WM_KILLFOCUS: sge->bHasInputFocus = false; return 0; + case WM_KEYDOWN: sge->pKeyNewState[mapKeys[wParam]] = true; return 0; + case WM_KEYUP: sge->pKeyNewState[mapKeys[wParam]] = false; return 0; + case WM_LBUTTONDOWN:sge->pMouseNewState[0] = true; return 0; + case WM_LBUTTONUP: sge->pMouseNewState[0] = false; return 0; + case WM_RBUTTONDOWN:sge->pMouseNewState[1] = true; return 0; + case WM_RBUTTONUP: sge->pMouseNewState[1] = false; return 0; + case WM_MBUTTONDOWN:sge->pMouseNewState[2] = true; return 0; + case WM_MBUTTONUP: sge->pMouseNewState[2] = false; return 0; + case WM_CLOSE: bAtomActive = false; return 0; + case WM_DESTROY: PostQuitMessage(0); return 0; + } + return DefWindowProc(hWnd, uMsg, wParam, lParam); + } +#else + // Do the Linux stuff! + Display* PixelGameEngine::olc_WindowCreate() + { + XInitThreads(); + + // Grab the deafult display and window + olc_Display = XOpenDisplay(NULL); + olc_WindowRoot = DefaultRootWindow(olc_Display); + + // Based on the display capabilities, configure the appearance of the window + GLint olc_GLAttribs[] = { GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None }; + olc_VisualInfo = glXChooseVisual(olc_Display, 0, olc_GLAttribs); + olc_ColourMap = XCreateColormap(olc_Display, olc_WindowRoot, olc_VisualInfo->visual, AllocNone); + olc_SetWindowAttribs.colormap = olc_ColourMap; + + // Register which events we are interested in receiving + olc_SetWindowAttribs.event_mask = ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | FocusChangeMask; + + // Create the window + olc_Window = XCreateWindow(olc_Display, olc_WindowRoot, 30, 30, nScreenWidth * nPixelWidth, nScreenHeight * nPixelHeight, 0, olc_VisualInfo->depth, InputOutput, olc_VisualInfo->visual, CWColormap | CWEventMask, &olc_SetWindowAttribs); + + Atom wmDelete = XInternAtom(olc_Display, "WM_DELETE_WINDOW", true); + XSetWMProtocols(olc_Display, olc_Window, &wmDelete, 1); + + XMapWindow(olc_Display, olc_Window); + XStoreName(olc_Display, olc_Window, ""); + + // Create Keyboard Mapping + mapKeys[0x61] = Key::A; mapKeys[0x62] = Key::B; mapKeys[0x63] = Key::C; mapKeys[0x64] = Key::D; mapKeys[0x65] = Key::E; + mapKeys[0x66] = Key::F; mapKeys[0x67] = Key::G; mapKeys[0x68] = Key::H; mapKeys[0x69] = Key::I; mapKeys[0x6A] = Key::J; + mapKeys[0x6B] = Key::K; mapKeys[0x6C] = Key::L; mapKeys[0x6D] = Key::M; mapKeys[0x6E] = Key::N; mapKeys[0x6F] = Key::O; + mapKeys[0x70] = Key::P; mapKeys[0x71] = Key::Q; mapKeys[0x72] = Key::R; mapKeys[0x73] = Key::S; mapKeys[0x74] = Key::T; + mapKeys[0x75] = Key::U; mapKeys[0x76] = Key::V; mapKeys[0x77] = Key::W; mapKeys[0x78] = Key::X; mapKeys[0x79] = Key::Y; + mapKeys[0x7A] = Key::Z; + + mapKeys[XK_F1] = Key::F1; mapKeys[XK_F2] = Key::F2; mapKeys[XK_F3] = Key::F3; mapKeys[XK_F4] = Key::F4; + mapKeys[XK_F5] = Key::F5; mapKeys[XK_F6] = Key::F6; mapKeys[XK_F7] = Key::F7; mapKeys[XK_F8] = Key::F8; + mapKeys[XK_F9] = Key::F9; mapKeys[XK_F10] = Key::F10; mapKeys[XK_F11] = Key::F11; mapKeys[XK_F12] = Key::F12; + + mapKeys[XK_Down] = Key::DOWN; mapKeys[XK_Left] = Key::LEFT; mapKeys[XK_Right] = Key::RIGHT; mapKeys[XK_Up] = Key::UP; + mapKeys[XK_KP_Enter] = Key::ENTER; mapKeys[XK_Return] = Key::ENTER; + + mapKeys[XK_BackSpace] = Key::BACK; mapKeys[XK_Escape] = Key::ESCAPE; mapKeys[XK_Linefeed] = Key::ENTER; mapKeys[XK_Pause] = Key::PAUSE; + mapKeys[XK_Scroll_Lock] = Key::SCROLL; mapKeys[XK_Tab] = Key::TAB; mapKeys[XK_Delete] = Key::DEL; mapKeys[XK_Home] = Key::HOME; + mapKeys[XK_End] = Key::END; mapKeys[XK_Page_Up] = Key::PGUP; mapKeys[XK_Page_Down] = Key::PGDN; mapKeys[XK_Insert] = Key::INS; + mapKeys[XK_Shift_L] = Key::SHIFT; mapKeys[XK_Shift_R] = Key::SHIFT; mapKeys[XK_Control_L] = Key::CTRL; mapKeys[XK_Control_R] = Key::CTRL; + mapKeys[XK_space] = Key::SPACE; + + mapKeys[XK_0] = Key::K0; mapKeys[XK_1] = Key::K1; mapKeys[XK_2] = Key::K2; mapKeys[XK_3] = Key::K3; mapKeys[XK_4] = Key::K4; + mapKeys[XK_5] = Key::K5; mapKeys[XK_6] = Key::K6; mapKeys[XK_7] = Key::K7; mapKeys[XK_8] = Key::K8; mapKeys[XK_9] = Key::K9; + + mapKeys[XK_KP_0] = Key::NP0; mapKeys[XK_KP_1] = Key::NP1; mapKeys[XK_KP_2] = Key::NP2; mapKeys[XK_KP_3] = Key::NP3; mapKeys[XK_KP_4] = Key::NP4; + mapKeys[XK_KP_5] = Key::NP5; mapKeys[XK_KP_6] = Key::NP6; mapKeys[XK_KP_7] = Key::NP7; mapKeys[XK_KP_8] = Key::NP8; mapKeys[XK_KP_9] = Key::NP9; + mapKeys[XK_KP_Multiply] = Key::NP_MUL; mapKeys[XK_KP_Add] = Key::NP_ADD; mapKeys[XK_KP_Divide] = Key::NP_DIV; mapKeys[XK_KP_Subtract] = Key::NP_SUB; mapKeys[XK_KP_Decimal] = Key::NP_DECIMAL; + + return olc_Display; + } + + bool PixelGameEngine::olc_OpenGLCreate() + { + glDeviceContext = glXCreateContext(olc_Display, olc_VisualInfo, nullptr, GL_TRUE); + glXMakeCurrent(olc_Display, olc_Window, glDeviceContext); + + XWindowAttributes gwa; + XGetWindowAttributes(olc_Display, olc_Window, &gwa); + glViewport(0, 0, gwa.width, gwa.height); + + glSwapIntervalEXT = nullptr; + glSwapIntervalEXT = (glSwapInterval_t*)glXGetProcAddress((unsigned char*)"glXSwapIntervalEXT"); + if (glSwapIntervalEXT) + glSwapIntervalEXT(olc_Display, olc_Window, 0); + else + { + printf("NOTE: Could not disable VSYNC, glXSwapIntervalEXT() was not found!\n"); + printf(" Don't worry though, things will still work, it's just the\n"); + printf(" frame rate will be capped to your monitors refresh rate - javidx9\n"); + } + + return true; + } + +#endif + + // Need a couple of statics as these are singleton instances + // read from multiple locations + std::atomic PixelGameEngine::bAtomActive{ false }; + std::map PixelGameEngine::mapKeys; + olc::PixelGameEngine* olc::PGEX::pge = nullptr; +#ifdef OLC_DBG_OVERDRAW + int olc::Sprite::nOverdrawCount = 0; +#endif + //============================================================= +} + +#endif + +#ifndef MATHS_H_ +#define MATHS_H_ + +const float DEG2RAD = 0.01745329251994329576923690768f; +const float RAD2DEG = 57.2957795130823208767981548141f; + +inline float ToRadian(const float Degree) { + return (Degree * DEG2RAD); +} + +inline float ToDegree(const float Radian) { + return (Radian * RAD2DEG); +} + +template +struct Vec4 { + T x, y, z, w; + template + Vec4(P x, P y, P z, P w) : x(x), y(y), z(z), w(w) {} + template + Vec4(P all) : x(all), y(all), z(all), w(all) {} + Vec4() : x(0), y(0), z(0), w(0) {} + inline Vec4& dot(const Vec4& v) { + return (x * v.x + y * v.y + z * v.z + w * v.w); + } + inline const Vec4& operator+() { + return *this; + } + inline Vec4& operator-() { + return Vec4(-x, -y, -z, -w); + } + inline Vec4& operator+(const Vec4& v) { + return new Vec4(x + v.x, y + v.y, z + v.z, w + v.w); + } + inline Vec4& operator-(const Vec4& v) { + return new Vec4(x - v.x, y - v.y, z - v.z, w - v.w); + } + inline Vec4& operator*(const Vec4& v) { + return new Vec4(x * v.x, y * v.y, z * v.z, w * v.w); + } + inline Vec4& operator/(const Vec4& v) { + return new Vec4(x / v.x, y / v.y, z / v.z, w / v.w); + } + inline Vec4& operator+=(const Vec4& v) { + x+=v.x; y+=v.y; z+=v.z; w+=v.w; + return *this; + } + inline Vec4& operator-=(const Vec4& v) { + x-=v.x; y-=v.y; z-=v.z; w-=v.w; + return *this; + } + inline Vec4& operator*=(const Vec4& v) { + x*=v.x; y*=v.y; z*=v.z; w*=v.w; + return *this; + } + inline Vec4& operator/=(const Vec4& v) { + x/=v.x; y/=v.y; z/=v.z; w/=v.w; + return *this; + } + template + inline Vec4& operator+=(P s) { + x+=s; y+=s; z+=s; w+=s; + return *this; + } + template + inline Vec4& operator-=(P s) { + x-=s; y-=s; z-=s; w-=s; + return *this; + } + template + inline Vec4& operator*=(P s) { + x*=s; y*=s; z*=s; w*=s; + return *this; + } + template + inline Vec4& operator/=(P s) { + x/=s; y/=s; z/=s; w/=s; + return *this; + } +}; + +template +struct Vec3 { + T x, y, z; + template + Vec3(P x, P y, P z) : x(x), y(y), z(z) {} + template + Vec3(P all) : x(all), y(all), z(all) {} + Vec3() : x(0), y(0), z(0) {} + inline Vec3& cross(const Vec3& v) { + return new Vec3( + (y * v.z - z * v.y), + (x * v.z - z * v.x), + (x * v.y - y * v.x) + ); + } + inline Vec3& dot(const Vec3& v) { + return (x * v.x + y * v.y + z * v.z); + } + inline const Vec3& operator+() { + return *this; + } + inline Vec3& operator-() { + return Vec3(-x, -y, -z); + } + inline Vec3& operator+(const Vec3& v) { + return new Vec3(x + v.x, y + v.y, z + v.z); + } + inline Vec3& operator-(const Vec3& v) { + return new Vec3(x - v.x, y - v.y, z - v.z); + } + inline Vec3& operator*(const Vec3& v) { + return new Vec3(x * v.x, y * v.y, z * v.z); + } + inline Vec3& operator/(const Vec3& v) { + return new Vec3(x / v.x, y / v.y, z / v.z); + } + inline Vec3& operator+=(const Vec3& v) { + x+=v.x; y+=v.y; z+=v.z; + return *this; + } + inline Vec3& operator-=(const Vec3& v) { + x-=v.x; y-=v.y; z-=v.z; + return *this; + } + inline Vec3& operator*=(const Vec3& v) { + x*=v.x; y*=v.y; z*=v.z; + return *this; + } + inline Vec3& operator/=(const Vec3& v) { + x/=v.x; y/=v.y; z/=v.z; + return *this; + } + template + inline Vec3& operator+=(P s) { + x+=s; y+=s; z+=s; + return *this; + } + template + inline Vec3& operator-=(P s) { + x-=s; y-=s; z-=s; + return *this; + } + template + inline Vec3& operator*=(P s) { + x*=s; y*=s; z*=s; + return *this; + } + template + inline Vec3& operator/=(P s) { + x/=s; y/=s; z/=s; + return *this; + } +}; + +template +struct Vec2 { + T x, y; + template + Vec2(P x, P y) : x(x), y(y) {} + template + Vec2(P all) : x(all), y(all) {} + Vec2() : x(0), y(0) {} + inline const Vec2& operator+() { + return *this; + } + inline Vec2& dot(const Vec3& v) { + return (x * v.x + y * v.y); + } + inline Vec2& operator-() { + return Vec3(-x, -y); + } + inline Vec2& operator+(const Vec2& v) { + return new Vec2(x + v.x, y + v.y); + } + inline Vec2& operator-(const Vec2& v) { + return new Vec2(x - v.x, y - v.y); + } + inline Vec2& operator*(const Vec2& v) { + return new Vec2(x * v.x, y * v.y); + } + inline Vec2& operator/(const Vec2& v) { + return new Vec2(x / v.x, y / v.y); + } + inline Vec2& operator+=(const Vec2& v) { + x+=v.x; y+=v.y; + return *this; + } + inline Vec2& operator-=(const Vec2& v) { + x-=v.x; y-=v.y; + return *this; + } + inline Vec2& operator*=(const Vec2& v) { + x*=v.x; y*=v.y; + return *this; + } + inline Vec2& operator/=(const Vec2& v) { + x/=v.x; y/=v.y; + return *this; + } + template + inline Vec2& operator+=(P s) { + x+=s; y+=s; + return *this; + } + template + inline Vec2& operator-=(P s) { + x-=s; y-=s; + return *this; + } + template + inline Vec2& operator*=(P s) { + x*=s; y*=s; + return *this; + } + template + inline Vec2& operator/=(P s) { + x/=s; y/=s; + return *this; + } +}; + +#endif + +#ifndef RECT_H_ +#define RECT_H_ + +#include + +class Rect { +public: + Rect(); + Rect(int x, int y, int w, int h); + void Clear(); + + static Rect CreateRect(int x, int y, int w, int h) { + Rect tempRect(x, y, w, h); + return tempRect; + } + + Rect operator+(Rect* rect) { + return Rect(this->x + rect->x, this->y + this->x, w, h); + } + Rect operator-(Rect* rect) { + return Rect(this->x - rect->x, this->y - this->x, w, h); + } + bool operator==(const Rect* rect) { + return (x == rect->x && y == rect->y && w == rect->w && h == rect->h); + } + bool operator!=(const Rect* rect) { + return !(x == rect->x && y == rect->y && w == rect->w && h == rect->h); + } + + std::string ToString(); + + bool Intersects(Rect* rect); + // bool Intersects(int x, int y, int w, int h); + + bool Contains(Rect* rect); + bool Contains(Vec2* point); + bool Contains(Vec2 point); + bool Contains(int x, int y, int w, int h); + + Vec2* Position(); + Vec2* Center(); + int CenterX(); + int CenterY(); + + int Left(); + int Right(); + int Top(); + int Bottom(); + int Perimiter(); + int Area(); + + int GetX(); + int GetY(); + int GetW(); + int GetH(); + + void SetRect(int x, int y, int w, int h); + void SetSize(Vec2* size); + void SetPos(Vec2* pos); + void SetPos(int x, int y); + void Translate(Vec2* offset); + void TranslateX(int x); + void TranslateY(int y); + + int x, y, w, h; + + virtual ~Rect(); +private: +}; + +#endif + +#ifdef OLC_PGE_APPLICATION +#undef OLC_PGE_APPLICATION + +Rect::Rect() { + Clear(); +} + +Rect::Rect(int x, int y, int w, int h) { + SetRect(x, y, w, h); +} + +void Rect::Clear() { + SetRect(0, 0, 0, 0); +} + +std::string Rect::ToString() { + std::string res = "("; + res += std::to_string(x); + res += ", "; + res += std::to_string(y); + res += ", "; + res += std::to_string(w); + res += ", "; + res += std::to_string(h); + res += ")"; + return res; +} + +bool Rect::Intersects(Rect* rect) { + int leftA = x; + int rightA = x + w; + int topA = y; + int bottomA = y + h; + + int leftB = rect->x; + int rightB = rect->x + rect->w; + int topB = rect->y; + int bottomB = rect->y + rect->h; + + if (bottomA <= topB) return false; + if (topA >= bottomB) return false; + if (rightA <= leftB) return false; + if (leftA >= rightB) return false; + + return true; +} + +// bool Rect::Intersects(int x, int y, int w, int h) { +// return Intersects(&CreateRect(x, y, w, h)); +// } + +bool Rect::Contains(Rect* rect) { + return (rect->x >= x && rect->Right() <= (x + w) && rect->y >= y && rect->Bottom() <= (y + h)); +} + +bool Rect::Contains(Vec2* point) { + return (point->x >= x && point->x <= (x + w) && point->y >= y && point->y <= (y + h)); +} + + +bool Rect::Contains(Vec2 point) { + return (point.x >= x && point.x <= (x + w) && point.y >= y && point.y <= (y + h)); +} + +bool Rect::Contains(int x, int y, int w, int h) { + Rect tempRect(x, y, w, h); + return Contains(&tempRect); +} + +Vec2* Rect::Position() { + Vec2* res = new Vec2(x, y); + return res; +} + +Vec2* Rect::Center() { + Vec2* res = new Vec2(x + (w / 2), y + (h / 2)); + return res; +} + +int Rect::CenterX() { + return (x + (w / 2)); +} + +int Rect::CenterY() { + return (y + (h / 2)); +} + +int Rect::Left() { + return x; +} + +int Rect::Right() { + return (x + w); +} + +int Rect::Top() { + return y; +} + +int Rect::Bottom() { + return y + h; +} + +int Rect::Perimiter() { + return (w + w + h + h); +} + +int Rect::Area() { + return (w + h); +} + +int Rect::GetX() { + return x; +} + +int Rect::GetY() { + return y; +} + +int Rect::GetW() { + return w; +} + +int Rect::GetH() { + return h; +} + +void Rect::SetRect(int x, int y, int w, int h) { + this->x = x; + this->y = y; + this->w = w; + this->h = h; +} + +void Rect::SetSize(Vec2* size) { + this->x = size->x; + this->y = size->y; +} + +void Rect::SetPos(Vec2* pos) { + this->w = pos->x; + this->h = pos->y; +} + +void Rect::SetPos(int x, int y) { + this->w = x; + this->h = y; +} + +void Rect::Translate(Vec2* offset) { + this->x += offset->x; + this->y += offset->y; +} + +void Rect::TranslateX(int x) { + this->x += x; +} + +void Rect::TranslateY(int y) { + this->y += y; +} + +Rect::~Rect() { + +} + +#endif diff --git a/C++/Maze/output.o b/C++/Maze/output.o new file mode 100755 index 0000000000000000000000000000000000000000..16d9f18fb8fb602166515aec4f9c31c88541ce7a GIT binary patch literal 496208 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