Added Mandelbrot Video

5 years ago · deaadfef4a
parent 64c3ec7f27
commit deaadfef4a
1 changed files with 592 additions and 0 deletions
--- a/Videos/OneLoneCoder_PGE_Mandelbrot.cpp
+++ b/Videos/OneLoneCoder_PGE_Mandelbrot.cpp
@ -0,0 +1,592 @@
+/*
+	Brute Force Processing a Mandelbrot Renderer
+	"Dammit Moros & Saladin, you guys keep making tools, I'll have nothing left to video..." - javidx9
+
+	License (OLC-3)
+	~~~~~~~~~~~~~~~
+
+	Copyright 2018-2020 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.
+
+	Relevant Video: https://youtu.be/PBvLs88hvJ8
+
+	Links
+	~~~~~
+	YouTube:	https://www.youtube.com/javidx9
+				https://www.youtube.com/javidx9extra
+	Discord:	https://discord.gg/WhwHUMV
+	Twitter:	https://www.twitter.com/javidx9
+	Twitch:		https://www.twitch.tv/javidx9
+	GitHub:		https://www.github.com/onelonecoder
+	Patreon:	https://www.patreon.com/javidx9
+	Homepage:	https://www.onelonecoder.com
+
+	Community Blog: https://community.onelonecoder.com
+
+	Author
+	~~~~~~
+	David Barr, aka javidx9, ©OneLoneCoder 2018, 2019, 2020
+*/
+
+#define OLC_PGE_APPLICATION
+#include "olcPixelGameEngine.h"
+
+#include <condition_variable>
+#include <atomic>
+#include <complex>
+#include <cstdlib>
+#include <immintrin.h>
+
+constexpr int nMaxThreads = 32;
+
+class olcFractalExplorer : public olc::PixelGameEngine
+{
+public:
+	olcFractalExplorer()
+	{
+		sAppName = "Brute Force Processing";
+	}
+
+	int* pFractal = nullptr;
+	int nMode = 4;
+	int nIterations = 128;
+
+public:
+	bool OnUserCreate() override
+	{
+		//pFractal = new int[ScreenWidth() * ScreenHeight()]{ 0 };
+
+		// Using Vector extensions, align memory (not as necessary as it used to be)
+		// MS Specific - see std::aligned_alloc for others
+		pFractal = (int*)_aligned_malloc(size_t(ScreenWidth()) * size_t(ScreenHeight()) * sizeof(int), 64);
+
+		InitialiseThreadPool();
+		return true;
+	}
+
+	bool OnUserDestroy() override
+	{
+		// Stop Worker threads
+		for (int i = 0; i < nMaxThreads; i++)
+		{
+			workers[i].alive = false;		 // Allow thread exit
+			workers[i].cvStart.notify_one(); // Fake starting gun
+		}
+
+		// Clean up worker threads
+		for (int i = 0; i < nMaxThreads; i++)
+			workers[i].thread.join();
+
+		// Clean up memory
+		_aligned_free(pFractal);
+		return true;
+	}
+
+	// Method 1) - Super simple, no effort at optimising
+	void CreateFractalBasic(const olc::vi2d& pix_tl, const olc::vi2d& pix_br, const olc::vd2d& frac_tl, const olc::vd2d& frac_br, const int iterations)
+	{
+		double x_scale = (frac_br.x - frac_tl.x) / (double(pix_br.x) - double(pix_tl.x));
+		double y_scale = (frac_br.y - frac_tl.y) / (double(pix_br.y) - double(pix_tl.y));
+		
+		for (int y = pix_tl.y; y < pix_br.y; y++)
+		{
+			for (int x = pix_tl.x; x < pix_br.x; x++)
+			{
+				std::complex<double> c(x * x_scale + frac_tl.x, y * y_scale + frac_tl.y);
+				std::complex<double> z(0, 0);
+
+				int n = 0;
+				while (abs(z) < 2.0 && n < iterations)
+				{
+					z = (z * z) + c;
+					n++;
+				}
+
+				pFractal[y * ScreenWidth() + x] = n;
+			}
+		}
+	}
+
+	// Method 2) - Attempt to pre-calculate as much as possible, and reduce
+	// repeated multiplications
+	void CreateFractalPreCalculate(const olc::vi2d& pix_tl, const olc::vi2d& pix_br, const olc::vd2d& frac_tl, const olc::vd2d& frac_br, const int iterations)
+	{
+		double x_scale = (frac_br.x - frac_tl.x) / (double(pix_br.x) - double(pix_tl.x));
+		double y_scale = (frac_br.y - frac_tl.y) / (double(pix_br.y) - double(pix_tl.y));
+
+		double x_pos = frac_tl.x;
+		double y_pos = frac_tl.y;
+
+		int y_offset = 0;
+		int row_size = pix_br.x - pix_tl.x;
+
+		int x, y, n;
+		std::complex<double> c, z;
+
+		for (y = pix_tl.y; y < pix_br.y; y++)
+		{
+			x_pos = frac_tl.x;
+			for (x = pix_tl.x; x < pix_br.x; x++)
+			{				
+				c = { x_pos, y_pos };
+				z = { 0,0 };
+
+				n = 0;
+				while (abs(z) < 2.0 && n < iterations)
+				{
+					z = (z * z) + c;
+					n++;
+				}
+
+				pFractal[y_offset + x] = n;
+				x_pos += x_scale;
+			}
+
+			y_pos += y_scale;
+			y_offset += row_size;
+		}
+	}
+
+
+	// Method 3) - Replace std::complex with just hard coded mathematics
+	void CreateFractalNoComplex(const olc::vi2d& pix_tl, const olc::vi2d& pix_br, const olc::vd2d& frac_tl, const olc::vd2d& frac_br, const int iterations)
+	{
+		double x_scale = (frac_br.x - frac_tl.x) / (double(pix_br.x) - double(pix_tl.x));
+		double y_scale = (frac_br.y - frac_tl.y) / (double(pix_br.y) - double(pix_tl.y));
+
+		double x_pos = frac_tl.x;
+		double y_pos = frac_tl.y;
+
+		int y_offset = 0;
+		int row_size = ScreenWidth();
+
+		int x, y, n;
+
+		double cr = 0;
+		double ci = 0;
+		double zr = 0;
+		double zi = 0;
+		double re = 0;
+		double im = 0;
+
+		for (y = pix_tl.y; y < pix_br.y; y++)
+		{
+			x_pos = frac_tl.x;
+			ci = y_pos;
+			for (x = pix_tl.x; x < pix_br.x; x++)
+			{
+				cr = x_pos;
+				zr = 0;
+				zi = 0;
+
+				n = 0;
+				while ((zr * zr + zi * zi) < 4.0 && n < iterations)
+				{
+					re = zr * zr - zi * zi + cr;
+					im = zr * zi * 2.0 + ci;
+					zr = re;
+					zi = im;
+					n++;
+				}
+
+				pFractal[y_offset + x] = n;
+				x_pos += x_scale;
+			}
+
+			y_pos += y_scale;
+			y_offset += row_size;
+		}
+	}
+
+	// Method 4) - Use AVX2 Vector co-processor to handle 4 fractal locations at once
+	void CreateFractalIntrinsics(const olc::vi2d& pix_tl, const olc::vi2d& pix_br, const olc::vd2d& frac_tl, const olc::vd2d& frac_br, const int iterations)
+	{
+		double x_scale = (frac_br.x - frac_tl.x) / (double(pix_br.x) - double(pix_tl.x));
+		double y_scale = (frac_br.y - frac_tl.y) / (double(pix_br.y) - double(pix_tl.y));
+
+		double y_pos = frac_tl.y;
+
+		int y_offset = 0;
+		int row_size = ScreenWidth();
+
+		int x, y;
+
+		__m256d _a, _b, _two, _four, _mask1;
+		__m256d _zr, _zi, _zr2, _zi2, _cr, _ci;
+		__m256d _x_pos_offsets, _x_pos, _x_scale, _x_jump;
+		__m256i _one, _c, _n, _iterations, _mask2;
+
+		_one = _mm256_set1_epi64x(1);
+		_two = _mm256_set1_pd(2.0);
+		_four = _mm256_set1_pd(4.0);
+		_iterations = _mm256_set1_epi64x(iterations);
+
+		_x_scale = _mm256_set1_pd(x_scale);
+		_x_jump = _mm256_set1_pd(x_scale * 4);
+		_x_pos_offsets = _mm256_set_pd(0, 1, 2, 3);
+		_x_pos_offsets = _mm256_mul_pd(_x_pos_offsets, _x_scale);
+
+
+		for (y = pix_tl.y; y < pix_br.y; y++)
+		{
+			// Reset x_position
+			_a = _mm256_set1_pd(frac_tl.x);
+			_x_pos = _mm256_add_pd(_a, _x_pos_offsets);
+
+			_ci = _mm256_set1_pd(y_pos);
+
+			for (x = pix_tl.x; x < pix_br.x; x += 4)
+			{
+				_cr = _x_pos;
+				_zr = _mm256_setzero_pd();
+				_zi = _mm256_setzero_pd();
+				_n = _mm256_setzero_si256();
+
+
+			repeat:
+				_zr2 = _mm256_mul_pd(_zr, _zr);
+				_zi2 = _mm256_mul_pd(_zi, _zi);
+				_a = _mm256_sub_pd(_zr2, _zi2);
+				_a = _mm256_add_pd(_a, _cr);
+				_b = _mm256_mul_pd(_zr, _zi);
+				_b = _mm256_fmadd_pd(_b, _two, _ci);
+				_zr = _a;
+				_zi = _b;
+				_a = _mm256_add_pd(_zr2, _zi2);
+				_mask1 = _mm256_cmp_pd(_a, _four, _CMP_LT_OQ);
+				_mask2 = _mm256_cmpgt_epi64(_iterations, _n);
+				_mask2 = _mm256_and_si256(_mask2, _mm256_castpd_si256(_mask1));
+				_c = _mm256_and_si256(_one, _mask2); // Zero out ones where n < iterations													
+				_n = _mm256_add_epi64(_n, _c); // n++ Increase all n
+				if (_mm256_movemask_pd(_mm256_castsi256_pd(_mask2)) > 0)
+					goto repeat;
+
+				pFractal[y_offset + x + 0] = int(_n.m256i_i64[3]);
+				pFractal[y_offset + x + 1] = int(_n.m256i_i64[2]);
+				pFractal[y_offset + x + 2] = int(_n.m256i_i64[1]);
+				pFractal[y_offset + x + 3] = int(_n.m256i_i64[0]);
+				_x_pos = _mm256_add_pd(_x_pos, _x_jump);
+			}
+
+			y_pos += y_scale;
+			y_offset += row_size;
+		}
+	}
+
+	// Method 5) - Spawn threads that use AVX method above
+	void CreateFractalThreads(const olc::vi2d& pix_tl, const olc::vi2d& pix_br, const olc::vd2d& frac_tl, const olc::vd2d& frac_br, const int iterations)
+	{
+		int nSectionWidth = (pix_br.x - pix_tl.x) / nMaxThreads;
+		double dFractalWidth = (frac_br.x - frac_tl.x) / double(nMaxThreads);
+
+		std::thread t[nMaxThreads];
+
+		for (size_t i = 0; i < nMaxThreads; i++)
+			t[i] = std::thread(&olcFractalExplorer::CreateFractalIntrinsics, this,
+				olc::vi2d(pix_tl.x + nSectionWidth * (i), pix_tl.y),
+				olc::vi2d(pix_tl.x + nSectionWidth * (i + 1), pix_br.y),
+				olc::vd2d(frac_tl.x + dFractalWidth * double(i), frac_tl.y),
+				olc::vd2d(frac_tl.x + dFractalWidth * double(i + 1), frac_br.y),
+				iterations);
+
+		for (size_t i = 0; i < nMaxThreads; i++)
+			t[i].join();
+
+	}
+
+
+	// Method 6) - Threadpool, keep threads alive and reuse them, reducing setup overhead
+	struct WorkerThread
+	{
+		olc::vi2d pix_tl = { 0,0 };
+		olc::vi2d pix_br = { 0,0 };
+		olc::vd2d frac_tl = { 0,0 };
+		olc::vd2d frac_br = { 0,0 };
+		int iterations = 0;
+		std::condition_variable cvStart;
+		bool alive = true;
+		std::mutex mux;
+		int screen_width = 0;
+		int* fractal = nullptr;
+
+		std::thread thread;
+
+		void Start(const olc::vi2d& ptl, const olc::vi2d& pbr, const olc::vd2d& ftl, const olc::vd2d& fbr, const int it)
+		{
+			pix_tl = ptl;
+			pix_br = pbr;
+			frac_tl = ftl;
+			frac_br = fbr;
+			iterations = it;
+			std::unique_lock<std::mutex> lm(mux);
+			cvStart.notify_one();
+		}
+
+		void CreateFractal()
+		{
+			while (alive)
+			{
+				std::unique_lock<std::mutex> lm(mux);
+				cvStart.wait(lm);
+
+				double x_scale = (frac_br.x - frac_tl.x) / (double(pix_br.x) - double(pix_tl.x));
+				double y_scale = (frac_br.y - frac_tl.y) / (double(pix_br.y) - double(pix_tl.y));
+
+				double y_pos = frac_tl.y;
+
+				int y_offset = 0;
+				int row_size = screen_width;
+
+				int x, y;
+
+				__m256d _a, _b, _two, _four, _mask1;
+				__m256d _zr, _zi, _zr2, _zi2, _cr, _ci;
+				__m256d _x_pos_offsets, _x_pos, _x_scale, _x_jump;
+				__m256i _one, _c, _n, _iterations, _mask2;
+
+				_one = _mm256_set1_epi64x(1);
+				_two = _mm256_set1_pd(2.0);
+				_four = _mm256_set1_pd(4.0);
+				_iterations = _mm256_set1_epi64x(iterations);
+
+				_x_scale = _mm256_set1_pd(x_scale);
+				_x_jump = _mm256_set1_pd(x_scale * 4);
+				_x_pos_offsets = _mm256_set_pd(0, 1, 2, 3);
+				_x_pos_offsets = _mm256_mul_pd(_x_pos_offsets, _x_scale);
+
+
+				for (y = pix_tl.y; y < pix_br.y; y++)
+				{
+					// Reset x_position
+					_a = _mm256_set1_pd(frac_tl.x);
+					_x_pos = _mm256_add_pd(_a, _x_pos_offsets);
+
+					_ci = _mm256_set1_pd(y_pos);
+
+					for (x = pix_tl.x; x < pix_br.x; x += 4)
+					{
+						_cr = _x_pos;
+						_zr = _mm256_setzero_pd();
+						_zi = _mm256_setzero_pd();
+						_n = _mm256_setzero_si256();
+
+					repeat:
+						_zr2 = _mm256_mul_pd(_zr, _zr);
+						_zi2 = _mm256_mul_pd(_zi, _zi);
+						_a = _mm256_sub_pd(_zr2, _zi2);
+						_a = _mm256_add_pd(_a, _cr);
+						_b = _mm256_mul_pd(_zr, _zi);
+						_b = _mm256_fmadd_pd(_b, _two, _ci);
+						_zr = _a;
+						_zi = _b;
+						_a = _mm256_add_pd(_zr2, _zi2);
+						_mask1 = _mm256_cmp_pd(_a, _four, _CMP_LT_OQ);
+						_mask2 = _mm256_cmpgt_epi64(_iterations, _n);
+						_mask2 = _mm256_and_si256(_mask2, _mm256_castpd_si256(_mask1));
+						_c = _mm256_and_si256(_one, _mask2); // Zero out ones where n < iterations													
+						_n = _mm256_add_epi64(_n, _c); // n++ Increase all n
+						if (_mm256_movemask_pd(_mm256_castsi256_pd(_mask2)) > 0)
+							goto repeat;
+
+						fractal[y_offset + x + 0] = int(_n.m256i_i64[3]);
+						fractal[y_offset + x + 1] = int(_n.m256i_i64[2]);
+						fractal[y_offset + x + 2] = int(_n.m256i_i64[1]);
+						fractal[y_offset + x + 3] = int(_n.m256i_i64[0]);
+						_x_pos = _mm256_add_pd(_x_pos, _x_jump);
+					}
+
+					y_pos += y_scale;
+					y_offset += row_size;
+				}
+				nWorkerComplete++;
+			}
+		}
+	};
+
+	WorkerThread workers[nMaxThreads];
+	static std::atomic<int> nWorkerComplete;
+
+	void InitialiseThreadPool()
+	{
+		for (int i = 0; i < nMaxThreads; i++)
+		{
+			workers[i].alive = true;
+			workers[i].fractal = pFractal;
+			workers[i].screen_width = ScreenWidth();
+			workers[i].thread = std::thread(&WorkerThread::CreateFractal, &workers[i]);
+		}
+	}
+
+	void CreateFractalThreadPool(const olc::vi2d& pix_tl, const olc::vi2d& pix_br, const olc::vd2d& frac_tl, const olc::vd2d& frac_br, const int iterations)
+	{
+		int nSectionWidth = (pix_br.x - pix_tl.x) / nMaxThreads;
+		double dFractalWidth = (frac_br.x - frac_tl.x) / double(nMaxThreads);
+		nWorkerComplete = 0;
+
+		for (size_t i = 0; i < nMaxThreads; i++)
+			workers[i].Start(
+				olc::vi2d(pix_tl.x + nSectionWidth * i, pix_tl.y), 
+				olc::vi2d(pix_tl.x + nSectionWidth * (i + 1), pix_br.y), 
+				olc::vd2d(frac_tl.x + dFractalWidth * double(i), frac_tl.y), 
+				olc::vd2d(frac_tl.x + dFractalWidth * double(i + 1), frac_br.y), 
+				iterations);
+
+
+		while (nWorkerComplete < nMaxThreads) // Wait for all workers to complete
+		{ }			
+	}
+
+
+	bool OnUserUpdate(float fElapsedTime) override
+	{
+
+		// Get mouse location this frame
+		olc::vd2d vMouse = { (double)GetMouseX(), (double)GetMouseY() };
+
+		// Handle Pan & Zoom
+		if (GetMouse(2).bPressed)
+		{
+			vStartPan = vMouse;
+		}
+
+		if (GetMouse(2).bHeld)
+		{
+			vOffset -= (vMouse - vStartPan) / vScale;
+			vStartPan = vMouse;
+		}
+
+		olc::vd2d vMouseBeforeZoom;
+		ScreenToWorld(vMouse, vMouseBeforeZoom);
+
+		if (GetKey(olc::Key::Q).bHeld || GetMouseWheel() > 0) vScale *= 1.1;
+		if (GetKey(olc::Key::A).bHeld || GetMouseWheel() < 0) vScale *= 0.9;
+		
+		olc::vd2d vMouseAfterZoom;
+		ScreenToWorld(vMouse, vMouseAfterZoom);
+		vOffset += (vMouseBeforeZoom - vMouseAfterZoom);
+		
+		olc::vi2d pix_tl = { 0,0 };
+		olc::vi2d pix_br = { ScreenWidth(), ScreenHeight() };
+		olc::vd2d frac_tl = { -2.0, -1.0 };
+		olc::vd2d frac_br = { 1.0, 1.0 };
+
+		ScreenToWorld(pix_tl, frac_tl);
+		ScreenToWorld(pix_br, frac_br);
+
+		// Handle User Input
+		if (GetKey(olc::K1).bPressed) nMode = 0;
+		if (GetKey(olc::K2).bPressed) nMode = 1;
+		if (GetKey(olc::K3).bPressed) nMode = 2;
+		if (GetKey(olc::K4).bPressed) nMode = 3;
+		if (GetKey(olc::K5).bPressed) nMode = 4;
+		if (GetKey(olc::K6).bPressed) nMode = 5;
+		if (GetKey(olc::UP).bPressed) nIterations += 64;
+		if (GetKey(olc::DOWN).bPressed) nIterations -= 64;
+		if (nIterations < 64) nIterations = 64;
+
+
+		// START TIMING
+		auto tp1 = std::chrono::high_resolution_clock::now();
+
+		// Do the computation
+		switch (nMode)
+		{
+		case 0: CreateFractalBasic(pix_tl, pix_br, frac_tl, frac_br, nIterations); break;
+		case 1: CreateFractalPreCalculate(pix_tl, pix_br, frac_tl, frac_br, nIterations); break;
+		case 2: CreateFractalNoComplex(pix_tl, pix_br, frac_tl, frac_br, nIterations); break;
+		case 3: CreateFractalIntrinsics(pix_tl, pix_br, frac_tl, frac_br, nIterations); break;
+		case 4: CreateFractalThreads(pix_tl, pix_br, frac_tl, frac_br, nIterations); break;
+		case 5: CreateFractalThreadPool(pix_tl, pix_br, frac_tl, frac_br, nIterations); break;
+		}
+
+		// STOP TIMING
+		auto tp2 = std::chrono::high_resolution_clock::now();
+		std::chrono::duration<double> elapsedTime = tp2 - tp1;
+
+
+		// Render result to screen
+		for (int y = 0; y < ScreenHeight(); y++)
+		{
+			for (int x = 0; x < ScreenWidth(); x++)
+			{
+				int i = pFractal[y * ScreenWidth() + x];
+				float n = (float)i;
+				float a = 0.1f;
+				// Thank you @Eriksonn - Wonderful Magic Fractal Oddball Man
+				Draw(x, y, olc::PixelF(0.5f * sin(a * n) + 0.5f, 0.5f * sin(a * n + 2.094f) + 0.5f,  0.5f * sin(a * n + 4.188f) + 0.5f));
+			}
+		}
+
+		// Render UI
+		switch (nMode)
+		{
+		case 0: DrawString(0, 0, "1) Naive Method", olc::WHITE, 3); break;
+		case 1: DrawString(0, 0, "2) Precalculate Method", olc::WHITE, 3); break;
+		case 2: DrawString(0, 0, "3) Hand-code Maths Method", olc::WHITE, 3); break;
+		case 3: DrawString(0, 0, "4) Vector Extensions (AVX2) Method", olc::WHITE, 3); break;
+		case 4: DrawString(0, 0, "5) Threads Method", olc::WHITE, 3); break;
+		case 5: DrawString(0, 0, "6) ThreadPool Method", olc::WHITE, 3); break;
+		}
+
+		DrawString(0, 30, "Time Taken: " + std::to_string(elapsedTime.count()) + "s", olc::WHITE, 3);
+		DrawString(0, 60, "Iterations: " + std::to_string(nIterations), olc::WHITE, 3);
+		return !(GetKey(olc::Key::ESCAPE).bPressed);
+	}
+
+	// Pan & Zoom variables
+	olc::vd2d vOffset = { 0.0, 0.0 };
+	olc::vd2d vStartPan = { 0.0, 0.0 };
+	olc::vd2d vScale = { 1280.0 / 2.0, 720.0 };
+	
+
+	// Convert coordinates from World Space --> Screen Space
+	void WorldToScreen(const olc::vd2d& v, olc::vi2d &n)
+	{
+		n.x = (int)((v.x - vOffset.x) * vScale.x);
+		n.y = (int)((v.y - vOffset.y) * vScale.y);
+	}
+
+	// Convert coordinates from Screen Space --> World Space
+	void ScreenToWorld(const olc::vi2d& n, olc::vd2d& v)
+	{
+		v.x = (double)(n.x) / vScale.x + vOffset.x;
+		v.y = (double)(n.y) / vScale.y + vOffset.y;
+	}
+};
+
+std::atomic<int> olcFractalExplorer::nWorkerComplete = 0;
+
+int main()
+{
+	olcFractalExplorer demo;
+	if (demo.Construct(1280, 720, 1, 1, false, false))
+		demo.Start();
+	return 0;
+}