First build that actually works. SDL_main errors before but didn't figure out the cause.

7 days ago · 6b181382bd
commit 6b181382bd
21 changed files with 2853 additions and 0 deletions
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1,29 @@
 # ---> Vim
 # Swap
 [._]*.s[a-v][a-z]
 !*.svg  # comment out if you don't need vector files
 [._]*.sw[a-p]
 [._]s[a-rt-v][a-z]
 [._]ss[a-gi-z]
 [._]sw[a-p]
 # Session
 Session.vim
 Sessionx.vim
 # Temporary
 .netrwhist
 *~
 # Auto-generated tag files
 tags
 # Persistent undo
 [._]*.un~
 subprojects
 builddir
 ttassets
 backup
 *.exe
 *.dll
 *.world
 coverage
--- a/.vimrc_proj
+++ b/.vimrc_proj
@ -0,0 +1 @@
 set makeprg=meson\ compile\ -C\ .
--- a/26
+++ b/26
@ -0,0 +1,26 @@
 all: build test
 reset:
 	powershell -executionpolicy bypass .\scripts\reset_build.ps1
 %.cpp : %.rl
 	ragel -o $@ $<
 build:
 	meson compile -j 10 -C builddir
 test: build
 	./builddir/runtests
 run: build test
 	powershell "cp ./builddir/lodecaster.exe ."
 	./lodecaster
 clean:
 	meson compile --clean -C builddir
 debug_test: build
 	gdb --nx -x .gdbinit --ex run --args builddir/runtests.exe
 cover:
 	gcovr --html coverage/index.html  --gcov-ignore-errors=no_working_dir_found --exclude "scratchpad.*" --exclude "subprojects.*" --html-nested coverage/
--- a/charset.png
+++ b/charset.png
--- a/main.cpp
+++ b/main.cpp
@ -0,0 +1,34 @@
 /*
 Copyright (c) 2004, Lode Vandevenne
 All rights reserved.
 */
 #include <cmath>
 #include <string>
 #include <vector>
 #include <iostream>
 #include "quickcg.h"
 using namespace QuickCG;
 using namespace std;
 //place the example code below here:
 int main(int argc, char *argv[])
 {
 	screen(256, 256, 0, "Small Test Script");
 	for (int x = 0; x < w; x++)
 		for (int y = 0; y < h; y++)
 		{
 			pset(x, y, ColorRGBA(x, y, 128, 255));
 		}
 	print("Hello, world!", 8, 8);
 	std::string test;
 	test.resize(20);
 	redraw();
 	sleep();
 	return 0;
 }
--- a/meson.build
+++ b/meson.build
@ -0,0 +1,27 @@
 project('lodecaster', 'cpp',
        default_options: ['cpp_std=c++20'])
 catch2 = dependency('catch2-with-main')
 fmt = dependency('fmt')
 json = dependency('nlohmann_json')
 sdl2 = dependency('sdl2')
 sdl2_main = dependency('sdl2main')
 dependencies = [
  sdl2, sdl2_main,
  fmt, json
 ]
 executable('runtests', [
            'quickcg.cpp',
            'main.cpp',
           ],
           win_subsystem: 'windows',
           dependencies: dependencies)
 executable('lodecaster', [
            'quickcg.cpp',
            'raycaster_flat.cpp',
           ],
           win_subsystem: 'windows',
           dependencies: dependencies)
--- a/quickcg.cpp
+++ b/quickcg.cpp
--- a/quickcg.h
+++ b/quickcg.h
@ -0,0 +1,334 @@
 /*
 QuickCG SDL2 20190709
 Copyright (c) 2004-2007, Lode Vandevenne
 All rights reserved.
 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
 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 OWNER 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.
 */
 /*
 QuickCG is an SDL 2.0 codebase that wraps some of the SDL 2.0 functionality.
 It's used by Lode's Computer Graphics Tutorial to work with simple function calls
 to demonstrate graphical programs. It may or may not be of industrial strength
 for games, though I've actually used it for some.
 QuickCG can handle some things that standard C++ does not but that are useful, such as:
 -drawing graphics
 -a bitmap font
 -simplified saving and loading of files
 -reading keyboard and mouse input
 -playing sound
 -color models
 -loading images
 Contact info:
 My email address is (puzzle the account and domain together with an @ symbol):
 Domain: gmail dot com.
 Account: lode dot vandevenne.
 */
 #ifndef _quickcg_h_included
 #define _quickcg_h_included
 #include <SDL.h>
 #include <string>
 #include <sstream>
 #include <iomanip>
 #include <vector>
 #include <algorithm> //std::min and std::max
 namespace QuickCG
 {
 ////////////////////////////////////////////////////////////////////////////////
 //useful templates//////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 //don't know why, but the standard C++ abs sometimes gives cryptic errors? if so use this :D
 template<typename T>
 const T template_abs(const T &a)
 {
  return (a < 0) ? -a : a;
 }
 //usage: std::string str = valtostr(25454.91654654f);
 template<typename T>
 std::string valtostr(const T& val)
 {
  std::ostringstream sstream;
  sstream << val;
  return sstream.str();
 }
 //usage: double val = strtoval<double>("465498.654");
 template<typename T>
 T strtoval(const std::string& s)
 {
  std::istringstream sstream(s);
  T val;
  sstream >> val;
  return val;
 }
 //length is decimal precision of the floating point number
 template<typename T>
 std::string valtostr(const T& val, int length, bool fixed = true)
 {
  std::ostringstream sstream;
  if(fixed) sstream << std::fixed;
  sstream << std::setprecision(length) << val;
  return sstream.str();
 }
 ////////////////////////////////////////////////////////////////////////////////
 //COLOR STRUCTS/////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 struct ColorRGBA8bit;
 //a color with 4 components: r, g, b and a
 struct ColorRGBA
 {
  int r;
  int g;
  int b;
  int a;
  ColorRGBA(Uint8 r, Uint8 g, Uint8 b, Uint8 a);
  ColorRGBA(const ColorRGBA8bit& color);
  ColorRGBA();
 };
 ColorRGBA operator+(const ColorRGBA& color, const ColorRGBA& color2);
 ColorRGBA operator-(const ColorRGBA& color, const ColorRGBA& color2);
 ColorRGBA operator*(const ColorRGBA& color, int a);
 ColorRGBA operator*(int a, const ColorRGBA& color);
 ColorRGBA operator/(const ColorRGBA& color, int a);
 ColorRGBA overlay(const ColorRGBA& color, const ColorRGBA& color2);
 bool operator==(const ColorRGBA& color, const ColorRGBA& color2);
 bool operator!=(const ColorRGBA& color, const ColorRGBA& color2);
 static const ColorRGBA RGB_Black    (  0,   0,   0, 255);
 static const ColorRGBA RGB_Red		(255,   0,   0, 255);
 static const ColorRGBA RGB_Green	(  0, 255,   0, 255);
 static const ColorRGBA RGB_Blue		(  0,   0, 255, 255);
 static const ColorRGBA RGB_Cyan		(  0, 255, 255, 255);
 static const ColorRGBA RGB_Magenta	(255,   0, 255, 255);
 static const ColorRGBA RGB_Yellow	(255, 255,   0, 255);
 static const ColorRGBA RGB_White	(255, 255, 255, 255);
 static const ColorRGBA RGB_Gray		(128, 128, 128, 255);
 static const ColorRGBA RGB_Grey		(192, 192, 192, 255);
 static const ColorRGBA RGB_Maroon	(128,   0,   0, 255);
 static const ColorRGBA RGB_Darkgreen(  0, 128,   0, 255);
 static const ColorRGBA RGB_Navy		(  0,   0, 128, 255);
 static const ColorRGBA RGB_Teal		(  0, 128, 128, 255);
 static const ColorRGBA RGB_Purple	(128,   0, 128, 255);
 static const ColorRGBA RGB_Olive	(128, 128,   0, 255);
 //a color with 4 components: r, g, b and a
 struct ColorRGBA8bit
 {
  Uint8 r;
  Uint8 g;
  Uint8 b;
  Uint8 a;
  ColorRGBA8bit(Uint8 r, Uint8 g, Uint8 b, Uint8 a);
  ColorRGBA8bit(const ColorRGBA& color);
  ColorRGBA8bit();
 };
 //a color with 3 components: h, s and l
 struct ColorHSL
 {
  int h;
  int s;
  int l;
  int a;
  ColorHSL(Uint8 h, Uint8 s, Uint8 l, Uint8 a);
  ColorHSL();
 };
 //a color with 3 components: h, s and v
 struct ColorHSV
 {
  int h;
  int s;
  int v;
  int a;
  ColorHSV(Uint8 h, Uint8 s, Uint8 v, Uint8 a);
  ColorHSV();
 };
 ////////////////////////////////////////////////////////////////////////////////
 //GLOBAL VARIABLES//////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 extern int w;
 extern int h;
 ////////////////////////////////////////////////////////////////////////////////
 //KEYBOARD FUNCTIONS////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 bool keyDown(int key); //this checks if the key is held down, returns true all the time until the key is up
 bool keyPressed(int key); //this checks if the key is *just* pressed, returns true only once until the key is up again
 ////////////////////////////////////////////////////////////////////////////////
 //BASIC SCREEN FUNCTIONS////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 void screen(int width = 640, int height = 400, bool fullscreen = 0, const std::string& text = " ");
 void lock();
 void unlock();
 void redraw();
 void cls(const ColorRGBA& color = RGB_Black);
 void pset(int x, int y, const ColorRGBA& color);
 ColorRGBA pget(int x, int y);
 void drawBuffer(Uint32* buffer);
 bool onScreen(int x, int y);
 ////////////////////////////////////////////////////////////////////////////////
 //NON GRAPHICAL FUNCTIONS///////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 void sleep();
 void sleep(double seconds);
 void waitFrame(double oldTime, double frameDuration); //in seconds
 bool done(bool quit_if_esc = true, bool delay = true);
 void end();
 void readKeys();
 void getMouseState(int& mouseX, int& mouseY);
 void getMouseState(int& mouseX, int& mouseY, bool& LMB, bool& RMB);
 unsigned long getTicks(); //ticks in milliseconds
 inline double getTime() { return getTicks() / 1000.0; } //time in seconds
 ////////////////////////////////////////////////////////////////////////////////
 //2D SHAPES/////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 bool horLine(int y, int x1, int x2, const ColorRGBA& color);
 bool verLine(int x, int y1, int y2, const ColorRGBA& color);
 bool drawLine(int x1, int y1, int x2, int y2, const ColorRGBA& color);
 bool drawCircle(int xc, int yc, int radius, const ColorRGBA& color);
 bool drawDisk(int xc, int yc, int radius, const ColorRGBA& color);
 bool drawRect(int x1, int y1, int x2, int y2, const ColorRGBA& color);
 bool clipLine(int x1,int y1,int x2, int y2, int & x3, int & y3, int & x4, int & y4);
 ////////////////////////////////////////////////////////////////////////////////
 //COLOR CONVERSIONS/////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 ColorHSL RGBtoHSL(const ColorRGBA& ColorRGBA);
 ColorRGBA HSLtoRGB(const ColorHSL& colorHSL);
 ColorHSV RGBtoHSV(const ColorRGBA& ColorRGBA);
 ColorRGBA HSVtoRGB(const ColorHSV& colorHSV);
 Uint32 RGBtoINT(const ColorRGBA& ColorRGBA);
 ColorRGBA INTtoRGB(Uint32 colorINT);
 ////////////////////////////////////////////////////////////////////////////////
 //FILE FUNCTIONS////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 void loadFile(std::vector<unsigned char>& buffer, const std::string& filename);
 void saveFile(const std::vector<unsigned char>& buffer, const std::string& filename);
 ////////////////////////////////////////////////////////////////////////////////
 //IMAGE FUNCTIONS///////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 int loadImage(std::vector<ColorRGBA>& out, unsigned long& w, unsigned long& h, const std::string& filename);
 int loadImage(std::vector<Uint32>& out, unsigned long& w, unsigned long& h, const std::string& filename);
 int decodePNG(std::vector<unsigned char>& out_image, unsigned long& image_width, unsigned long& image_height, const unsigned char* in_png, size_t in_size, bool convert_to_rgba32 = true);
 int decodePNG(std::vector<unsigned char>& out_image_32bit, unsigned long& image_width, unsigned long& image_height, const std::vector<unsigned char>& in_png);
 ////////////////////////////////////////////////////////////////////////////////
 //TEXT FUNCTIONS////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 extern bool font[256][8][8];
 void drawLetter(unsigned char n, int x, int y, const ColorRGBA& color = RGB_White, bool bg = 0, const ColorRGBA& color2 = RGB_Black);
 int printString(const std::string& text, int x = 0, int y = 0, const ColorRGBA& color = RGB_White, bool bg = 0, const ColorRGBA& color2 = RGB_Black, int forceLength = 0);
 //print something (string, int, float, ...)
 template<typename T>
 int print(const T& val, int x = 0, int y = 0, const ColorRGBA& color = RGB_White, bool bg = 0, const ColorRGBA& color2 = RGB_Black, int forceLength = 0)
 {
  std::string text = valtostr(val);
  return printString(text, x, y, color, bg, color2, forceLength);
 }
 //print some floating point number, this one allows printing floating point numbers with limited length
 template<typename T>
 int fprint(const T& val, int length, int x = 0, int y = 0, const ColorRGBA& color = RGB_White, bool bg = 0, const ColorRGBA& color2 = RGB_Black, int forceLength = 0)
 {
  std::string text = valtostr(val, length, true);
  return printString(text, x, y, color, bg, color2, forceLength);
 }
 ////////////////////////////////////////////////////////////////////////////////
 //TEXT INPUT FUNCTIONS//////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 Uint8 getInputCharacter();
 void getInputString(std::string& text, const std::string& message = "", bool clear = false, int x = 0, int y = 0, const ColorRGBA& color = RGB_White, bool bg = 0, const ColorRGBA& color2 = RGB_Black);
 template<typename T>
 T getInput(const std::string& message = "", bool clear = false, int x = 0, int y = 0, const ColorRGBA& color = RGB_White, bool bg = 0, const ColorRGBA& color2 = RGB_Black)
 {
  std::string text;
  getInputString(text, message, clear, x, y, color, bg, color2);
  return strtoval<T>(text);
 }
 ////////////////////////////////////////////////////////////////////////////////
 //SOUNDCARD FUNCTIONS///////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 int audioOpen(int samplerate, int framesize); //always 16-bit mono sound for now; returns 0 if no error happened
 void audioClose();
 int audioReOpen(); //closes and opens again with same parameters
 /*
 push samples to the soundcard, making sure not to cause shortage or overflow
 pos and end are the range in the samples vector that you want to push to the audio card
 */
 void audioPushSamples(const std::vector<double>& samples, size_t pos, size_t end);
 size_t audioSamplesShortage(); //returns value > 0 if the soundcard is consuming more samples than you're producing
 size_t audioSamplesOverflow(); //returns value > 0 if you're producing more samples than the soundard is consuming - so take it easy a bit
 void audioSetBufferSamplesRange(size_t min_samples, size_t max_samples); //set shortage and overflow values. E.g. 4096 and 8192.
 /*
 This plays the sound starting at this time, until it's done
 The difference with audioPushSamples is:
 audioPlay allows playing multiple sounds at the same time: it doesn't push at the end,
 but elementwise-adds or pushes back samples if needed.
 The duration depends on samplerate, make sure the samples in the vector have the correct samplerate.
 */
 void audioPlay(const std::vector<double>& samples);
 void audioSetMode(int mode); //0: silent, 1: full (no volume calculations ==> faster), 2: volume-controlled (= default value)
 void audioSetVolume(double volume); //multiplier used if mode is 2 (volume-controlled). Default value is 1.0.
 } //end of namespace QuickCG
 #endif
--- a/raycaster_flat.cpp
+++ b/raycaster_flat.cpp
@ -0,0 +1,242 @@
 /*
 Copyright (c) 2004-2021, Lode Vandevenne
 All rights reserved.
 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
 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 OWNER 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.
 */
 #include <cmath>
 #include <string>
 #include <vector>
 #include <iostream>
 #include "quickcg.h"
 using namespace QuickCG;
 /*
 g++ *.cpp -lSDL -O3 -W -Wall -ansi -pedantic
 g++ *.cpp -lSDL
 */
 //place the example code below here:
 #define screenWidth 640
 #define screenHeight 480
 #define mapWidth 24
 #define mapHeight 24
 int worldMap[mapWidth][mapHeight]=
 {
  {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
  {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
  {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
  {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
  {1,0,0,0,0,0,2,2,2,2,2,0,0,0,0,3,0,3,0,3,0,0,0,1},
  {1,0,0,0,0,0,2,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,1},
  {1,0,0,0,0,0,2,0,0,0,2,0,0,0,0,3,0,0,0,3,0,0,0,1},
  {1,0,0,0,0,0,2,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,1},
  {1,0,0,0,0,0,2,2,0,2,2,0,0,0,0,3,0,3,0,3,0,0,0,1},
  {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
  {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
  {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
  {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
  {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
  {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
  {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
  {1,4,4,4,4,4,4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
  {1,4,0,4,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
  {1,4,0,0,0,0,5,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
  {1,4,0,4,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
  {1,4,0,4,4,4,4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
  {1,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
  {1,4,4,4,4,4,4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
  {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
 };
 int main(int /*argc*/, char */*argv*/[])
 {
  double posX = 22, posY = 12;  //x and y start position
  double dirX = -1, dirY = 0; //initial direction vector
  double planeX = 0, planeY = 0.66; //the 2d raycaster version of camera plane
  double time = 0; //time of current frame
  double oldTime = 0; //time of previous frame
  screen(screenWidth, screenHeight, 0, "Raycaster");
  while(!done())
  {
    for(int x = 0; x < w; x++)
    {
      //calculate ray position and direction
      double cameraX = 2 * x / (double)w - 1; //x-coordinate in camera space
      double rayDirX = dirX + planeX * cameraX;
      double rayDirY = dirY + planeY * cameraX;
      //which box of the map we're in
      int mapX = int(posX);
      int mapY = int(posY);
      //length of ray from current position to next x or y-side
      double sideDistX;
      double sideDistY;
      //length of ray from one x or y-side to next x or y-side
      //these are derived as:
      //deltaDistX = sqrt(1 + (rayDirY * rayDirY) / (rayDirX * rayDirX))
      //deltaDistY = sqrt(1 + (rayDirX * rayDirX) / (rayDirY * rayDirY))
      //which can be simplified to abs(|rayDir| / rayDirX) and abs(|rayDir| / rayDirY)
      //where |rayDir| is the length of the vector (rayDirX, rayDirY). Its length,
      //unlike (dirX, dirY) is not 1, however this does not matter, only the
      //ratio between deltaDistX and deltaDistY matters, due to the way the DDA
      //stepping further below works. So the values can be computed as below.
      // Division through zero is prevented, even though technically that's not
      // needed in C++ with IEEE 754 floating point values.
      double deltaDistX = (rayDirX == 0) ? 1e30 : std::abs(1 / rayDirX);
      double deltaDistY = (rayDirY == 0) ? 1e30 : std::abs(1 / rayDirY);
      double perpWallDist;
      //what direction to step in x or y-direction (either +1 or -1)
      int stepX;
      int stepY;
      int hit = 0; //was there a wall hit?
      int side; //was a NS or a EW wall hit?
      //calculate step and initial sideDist
      if(rayDirX < 0)
      {
        stepX = -1;
        sideDistX = (posX - mapX) * deltaDistX;
      }
      else
      {
        stepX = 1;
        sideDistX = (mapX + 1.0 - posX) * deltaDistX;
      }
      if(rayDirY < 0)
      {
        stepY = -1;
        sideDistY = (posY - mapY) * deltaDistY;
      }
      else
      {
        stepY = 1;
        sideDistY = (mapY + 1.0 - posY) * deltaDistY;
      }
      //perform DDA
      while(hit == 0)
      {
        //jump to next map square, either in x-direction, or in y-direction
        if(sideDistX < sideDistY)
        {
          sideDistX += deltaDistX;
          mapX += stepX;
          side = 0;
        }
        else
        {
          sideDistY += deltaDistY;
          mapY += stepY;
          side = 1;
        }
        //Check if ray has hit a wall
        if(worldMap[mapX][mapY] > 0) hit = 1;
      }
      //Calculate distance projected on camera direction. This is the shortest distance from the point where the wall is
      //hit to the camera plane. Euclidean to center camera point would give fisheye effect!
      //This can be computed as (mapX - posX + (1 - stepX) / 2) / rayDirX for side == 0, or same formula with Y
      //for size == 1, but can be simplified to the code below thanks to how sideDist and deltaDist are computed:
      //because they were left scaled to |rayDir|. sideDist is the entire length of the ray above after the multiple
      //steps, but we subtract deltaDist once because one step more into the wall was taken above.
      if(side == 0) perpWallDist = (sideDistX - deltaDistX);
      else          perpWallDist = (sideDistY - deltaDistY);
      //Calculate height of line to draw on screen
      int lineHeight = (int)(h / perpWallDist);
      //calculate lowest and highest pixel to fill in current stripe
      int drawStart = -lineHeight / 2 + h / 2;
      if(drawStart < 0) drawStart = 0;
      int drawEnd = lineHeight / 2 + h / 2;
      if(drawEnd >= h) drawEnd = h - 1;
      //choose wall color
      ColorRGB color;
      switch(worldMap[mapX][mapY])
      {
        case 1:  color = RGB_Red;    break; //red
        case 2:  color = RGB_Green;  break; //green
        case 3:  color = RGB_Blue;   break; //blue
        case 4:  color = RGB_White;  break; //white
        default: color = RGB_Yellow; break; //yellow
      }
      //give x and y sides different brightness
      if(side == 1) {color = color / 2;}
      //draw the pixels of the stripe as a vertical line
      verLine(x, drawStart, drawEnd, color);
    }
    //timing for input and FPS counter
    oldTime = time;
    time = getTicks();
    double frameTime = (time - oldTime) / 1000.0; //frameTime is the time this frame has taken, in seconds
    print(1.0 / frameTime); //FPS counter
    redraw();
    cls();
    //speed modifiers
    double moveSpeed = frameTime * 5.0; //the constant value is in squares/second
    double rotSpeed = frameTime * 3.0; //the constant value is in radians/second
    readKeys();
    //move forward if no wall in front of you
    if(keyDown(SDLK_UP))
    {
      if(worldMap[int(posX + dirX * moveSpeed)][int(posY)] == false) posX += dirX * moveSpeed;
      if(worldMap[int(posX)][int(posY + dirY * moveSpeed)] == false) posY += dirY * moveSpeed;
    }
    //move backwards if no wall behind you
    if(keyDown(SDLK_DOWN))
    {
      if(worldMap[int(posX - dirX * moveSpeed)][int(posY)] == false) posX -= dirX * moveSpeed;
      if(worldMap[int(posX)][int(posY - dirY * moveSpeed)] == false) posY -= dirY * moveSpeed;
    }
    //rotate to the right
    if(keyDown(SDLK_RIGHT))
    {
      //both camera direction and camera plane must be rotated
      double oldDirX = dirX;
      dirX = dirX * cos(-rotSpeed) - dirY * sin(-rotSpeed);
      dirY = oldDirX * sin(-rotSpeed) + dirY * cos(-rotSpeed);
      double oldPlaneX = planeX;
      planeX = planeX * cos(-rotSpeed) - planeY * sin(-rotSpeed);
      planeY = oldPlaneX * sin(-rotSpeed) + planeY * cos(-rotSpeed);
    }
    //rotate to the left
    if(keyDown(SDLK_LEFT))
    {
      //both camera direction and camera plane must be rotated
      double oldDirX = dirX;
      dirX = dirX * cos(rotSpeed) - dirY * sin(rotSpeed);
      dirY = oldDirX * sin(rotSpeed) + dirY * cos(rotSpeed);
      double oldPlaneX = planeX;
      planeX = planeX * cos(rotSpeed) - planeY * sin(rotSpeed);
      planeY = oldPlaneX * sin(rotSpeed) + planeY * cos(rotSpeed);
    }
  }
 }
--- a/scripts/coverage_reset.ps1
+++ b/scripts/coverage_reset.ps1
@ -0,0 +1,7 @@
 mv .\subprojects\packagecache .
 rm -recurse -force .\subprojects\,.\builddir\
 mkdir subprojects
 mv .\packagecache .\subprojects\
 mkdir builddir
 cp wraps\*.wrap subprojects\
 meson setup --default-library=static --prefer-static -Db_coverage=true builddir
--- a/scripts/coverage_reset.sh
+++ b/scripts/coverage_reset.sh
@ -0,0 +1,11 @@
 #!/usr/bin/env bash
 set -e
 mv -f ./subprojects/packagecache .
 rm -rf subprojects builddir
 mkdir subprojects
 mv packagecache ./subprojects/
 mkdir builddir
 cp wraps/*.wrap subprojects/
 # on OSX you can't do this with static
 meson setup -Db_coverage=true builddir
--- a/scripts/reset_build.ps1
+++ b/scripts/reset_build.ps1
@ -0,0 +1,7 @@
 mv .\subprojects\packagecache .
 rm -recurse -force .\subprojects\,.\builddir\
 mkdir subprojects
 mv .\packagecache .\subprojects\
 mkdir builddir
 cp wraps\*.wrap subprojects\
 meson setup --default-library=static --prefer-static builddir
--- a/scripts/reset_build.sh
+++ b/scripts/reset_build.sh
@ -0,0 +1,11 @@
 #!/usr/bin/env bash
 set -e
 mv -f ./subprojects/packagecache .
 rm -rf subprojects builddir
 mkdir subprojects
 mv packagecache ./subprojects/
 mkdir builddir
 cp wraps/*.wrap subprojects/
 # on OSX you can't do this with static
 meson setup builddir
--- a/sdlprog.cpp
+++ b/sdlprog.cpp
@ -0,0 +1,36 @@
 #include "SDL.h"
 int main(int argc, char *argv[])
 {
    SDL_Window *window;
    SDL_Renderer *renderer;
    SDL_Surface *surface;
    SDL_Event event;
    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize SDL: %s", SDL_GetError());
        return 3;
    }
    if (SDL_CreateWindowAndRenderer(320, 240, SDL_WINDOW_RESIZABLE, &window, &renderer)) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create window and renderer: %s", SDL_GetError());
        return 3;
    }
    while (1) {
        SDL_PollEvent(&event);
        if (event.type == SDL_QUIT) {
            break;
        }
        SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0x00, 0x00);
        SDL_RenderClear(renderer);
        SDL_RenderPresent(renderer);
    }
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();
    return 0;
 }
--- a/tests/base.cpp
+++ b/tests/base.cpp
@ -0,0 +1,9 @@
 #include <catch2/catch_test_macros.hpp>
 #include <fmt/core.h>
 #include <string>
 using namespace fmt;
 TEST_CASE("base test", "[base]") {
  REQUIRE(1 == 1);
 }
--- a/wraps/catch2.wrap
+++ b/wraps/catch2.wrap
@ -0,0 +1,11 @@
 [wrap-file]
 directory = Catch2-3.7.1
 source_url = https://github.com/catchorg/Catch2/archive/v3.7.1.tar.gz
 source_filename = Catch2-3.7.1.tar.gz
 source_hash = c991b247a1a0d7bb9c39aa35faf0fe9e19764213f28ffba3109388e62ee0269c
 source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/catch2_3.7.1-1/Catch2-3.7.1.tar.gz
 wrapdb_version = 3.7.1-1
 [provide]
 catch2 = catch2_dep
 catch2-with-main = catch2_with_main_dep
--- a/wraps/fmt.wrap
+++ b/wraps/fmt.wrap
@ -0,0 +1,13 @@
 [wrap-file]
 directory = fmt-11.0.2
 source_url = https://github.com/fmtlib/fmt/archive/11.0.2.tar.gz
 source_filename = fmt-11.0.2.tar.gz
 source_hash = 6cb1e6d37bdcb756dbbe59be438790db409cdb4868c66e888d5df9f13f7c027f
 patch_filename = fmt_11.0.2-1_patch.zip
 patch_url = https://wrapdb.mesonbuild.com/v2/fmt_11.0.2-1/get_patch
 patch_hash = 90c9e3b8e8f29713d40ca949f6f93ad115d78d7fb921064112bc6179e6427c5e
 source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/fmt_11.0.2-1/fmt-11.0.2.tar.gz
 wrapdb_version = 11.0.2-1
 [provide]
 fmt = fmt_dep
--- a/wraps/freetype2.wrap
+++ b/wraps/freetype2.wrap
@ -0,0 +1,11 @@
 [wrap-file]
 directory = freetype-2.13.3
 source_url = https://download.savannah.gnu.org/releases/freetype/freetype-2.13.3.tar.xz
 source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/freetype2_2.13.3-1/freetype-2.13.3.tar.xz
 source_filename = freetype-2.13.3.tar.xz
 source_hash = 0550350666d427c74daeb85d5ac7bb353acba5f76956395995311a9c6f063289
 wrapdb_version = 2.13.3-1
 [provide]
 freetype2 = freetype_dep
 freetype = freetype_dep
--- a/wraps/libpng.wrap
+++ b/wraps/libpng.wrap
@ -0,0 +1,13 @@
 [wrap-file]
 directory = libpng-1.6.44
 source_url = https://github.com/glennrp/libpng/archive/v1.6.44.tar.gz
 source_filename = libpng-1.6.44.tar.gz
 source_hash = 0ef5b633d0c65f780c4fced27ff832998e71478c13b45dfb6e94f23a82f64f7c
 patch_filename = libpng_1.6.44-1_patch.zip
 patch_url = https://wrapdb.mesonbuild.com/v2/libpng_1.6.44-1/get_patch
 patch_hash = 394b07614c45fbd1beac8b660386216a490fe12f841a1a445799b676c9c892fb
 source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/libpng_1.6.44-1/libpng-1.6.44.tar.gz
 wrapdb_version = 1.6.44-1
 [provide]
 libpng = libpng_dep
--- a/wraps/nlohmann_json.wrap
+++ b/wraps/nlohmann_json.wrap
@ -0,0 +1,11 @@
 [wrap-file]
 directory = nlohmann_json-3.11.3
 lead_directory_missing = true
 source_url = https://github.com/nlohmann/json/releases/download/v3.11.3/include.zip
 source_filename = nlohmann_json-3.11.3.zip
 source_hash = a22461d13119ac5c78f205d3df1db13403e58ce1bb1794edc9313677313f4a9d
 source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/nlohmann_json_3.11.3-1/nlohmann_json-3.11.3.zip
 wrapdb_version = 3.11.3-1
 [provide]
 nlohmann_json = nlohmann_json_dep
--- a/wraps/sdl2.wrap
+++ b/wraps/sdl2.wrap
@ -0,0 +1,15 @@
 [wrap-file]
 directory = SDL2-2.30.6
 source_url = https://github.com/libsdl-org/SDL/releases/download/release-2.30.6/SDL2-2.30.6.tar.gz
 source_filename = SDL2-2.30.6.tar.gz
 source_hash = c6ef64ca18a19d13df6eb22df9aff19fb0db65610a74cc81dae33a82235cacd4
 patch_filename = sdl2_2.30.6-2_patch.zip
 patch_url = https://wrapdb.mesonbuild.com/v2/sdl2_2.30.6-2/get_patch
 patch_hash = aa9f6a4947b07510c2ea84fb457e965bebe5a5deeb9f5059fbcf10dfe6b76d1f
 source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/sdl2_2.30.6-2/SDL2-2.30.6.tar.gz
 wrapdb_version = 2.30.6-2
 [provide]
 sdl2 = sdl2_dep
 sdl2main = sdl2main_dep
 sdl2_test = sdl2_test_dep