Initial commit

.gitignore

@@ -0,0 +1,4 @@
+.vs
+out
+
+*.json

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "SDLFramework"]
+	path = SDLFramework
+	url = https://github.com/Lauchmelder23/SDLFramework

CMakeLists.txt

@@ -0,0 +1,32 @@
+# CMakeList.txt : Top-level CMake project file, do global configuration
+# and include sub-projects here.
+#
+cmake_minimum_required (VERSION 3.8)
+
+project ("Mandelbrot")
+enable_language(CUDA)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR})
+
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+
+
+if(WIN32)
+	set(SDL2_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/SDLFramework/3rdparty/include/SDL)
+	set(SDL2_LIBRARIES 
+		${CMAKE_SOURCE_DIR}/SDLFramework/3rdparty/lib/SDL2.lib 
+		${CMAKE_SOURCE_DIR}/SDLFramework/3rdparty/lib/SDL2main.lib
+	)
+	set(SDL2_DLL
+		${CMAKE_SOURCE_DIR}/SDLFramework/3rdparty/lib/SDL2.dll
+	)
+else()
+	find_package(SDL2 REQUIRED)
+
+	SET(CMAKE_CXX_FLAGS -pthread)
+endif(WIN32)
+
+# Include sub-projects.
+add_subdirectory ("SDLFramework")
+add_subdirectory ("Mandelbrot")

Mandelbrot/CMakeLists.txt

@@ -0,0 +1,29 @@
+# CMakeList.txt : CMake project for Mandelbrot, include source and define
+# project specific logic here.
+#
+cmake_minimum_required (VERSION 3.8)
+
+set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --expt-relaxed-constexpr")
+
+# Add source to this project's executable.
+add_executable (Mandelbrot  "main.cu" 
+	"MainWindow.cu"
+)
+
+# TODO: Add tests and install targets if needed.
+target_include_directories(Mandelbrot PRIVATE
+	${SDL2_INCLUDE_DIRS}
+	${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES}
+	${CMAKE_SOURCE_DIR}/SDLFramework/src/sdlf
+)
+
+target_link_libraries(Mandelbrot PRIVATE
+	${SDL2_LIBRARIES}
+	sdlf
+)
+
+if(WIN32)
+	add_custom_command(TARGET Mandelbrot POST_BUILD
+		COMMAND ${CMAKE_COMMAND} -E copy ${SDL2_DLL} $<TARGET_FILE_DIR:Mandelbrot>
+	)
+endif(WIN32)

Mandelbrot/MainWindow.cu

@@ -0,0 +1,202 @@
+#include "MainWindow.cuh"
+#include <iostream>
+#include <string>
+
+#define WIN32_LEAN_AND_MEAN
+
+#include <Windows.h>
+
+#include <cuda_runtime.h>
+#include <device_launch_parameters.h>
+
+#define CHECK_CUDA_ERROR(error, msg) {											\
+	if(error != cudaSuccess) {													\
+		std::cerr << msg << std::endl << cudaGetErrorString(error) << std::endl;\
+		return false;															\
+	}																			\
+}
+
+__global__ void PopulateArrayWithIndexed(uint32_t* out, int n)
+{
+	int index = blockIdx.x * blockDim.x + threadIdx.x;
+
+	if(index < n)
+		out[index] = ((uint32_t)(index % WIDTH) << 16 | (uint32_t)(index / WIDTH));
+}
+
+__global__ void Mandelbrot(uint32_t* in, uint32_t* out, 
+	double centerX, double centerY, 
+	double cmplxCenterX, double cmplxCenterY, 
+	double pixelSize, 
+	int maxIteration, int maxValue,
+	int n)
+{
+	int index = blockIdx.x * blockDim.x + threadIdx.x;
+	int stride = 1;
+
+	double x, cx;
+	double y, cy;
+	double tempX;
+
+	if(index < n)
+	{
+		x = 0;
+		y = 0;
+
+		cx = (((in[index] & 0xFFFF0000) >> 16) - centerX) * pixelSize + cmplxCenterX;
+		cy = (((in[index] & 0x0000FFFF) >> 0) - centerY) * pixelSize - cmplxCenterY;
+
+		for (uint32_t j = 0; j < maxIteration; j++)
+		{
+			tempX = x * x - y * y + cx;
+			y = 2 * x * y + cy;
+			x = tempX;
+
+			if (x * x + y * y >= maxValue)
+			{
+				out[index] = 0xFFFFFFFF;
+				return;
+			}
+		}
+
+		out[index] = 0x000000FF;
+	}
+}
+
+
+MainWindow::MainWindow() :
+	sf::IWindow(sf::Vector2u(1000, 800), 
+		sf::UnitVector2i * SDL_WINDOWPOS_UNDEFINED,
+		"Mandelbrot"),
+	pRender(nullptr)
+{
+
+}
+
+void MainWindow::SetFunction(FractalSequence func)
+{
+	pFunction = func;
+}
+
+bool MainWindow::OnCreate()
+{
+	pRender = SDL_CreateTexture(m_pRenderer, 
+		SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_STREAMING, 
+		WIDTH, HEIGHT
+	);
+	if (pRender == nullptr)
+	{
+		std::cerr << "Failed to initialize Render Texture: " << SDL_GetError() << std::endl;
+		return false;
+	}
+
+	SDL_SetRenderDrawColor(m_pRenderer, 0, 0, 0, 255);
+
+	return true;
+}
+
+bool MainWindow::GetMandelbrotColors(Uint32** pixels)
+{
+	constexpr int ARR_SIZE = WIDTH * HEIGHT;
+
+	// Calculate / set thread/block size
+	constexpr int threadsPerBlock = 256;
+	constexpr int blocksPerGrid = (ARR_SIZE + threadsPerBlock - 1) / threadsPerBlock;
+
+	cudaError_t err;
+
+	// Create device memory for screen indices
+	if (cuda_screen == NULL)
+	{
+		err = cudaMalloc((void**)&cuda_screen, ARR_SIZE * sizeof(uint32_t));
+		CHECK_CUDA_ERROR(err, "Failed to create array on device");
+
+		// Call device kernel to fill array
+		PopulateArrayWithIndexed<<<blocksPerGrid, threadsPerBlock>>>(cuda_screen, ARR_SIZE);
+		err = cudaGetLastError();
+		CHECK_CUDA_ERROR(err, "Failed to launch kernel: ");
+	}
+
+	// Create device memory for color data;
+	if (cuda_colors == NULL)
+	{
+		err = cudaMalloc((void**)&cuda_colors, ARR_SIZE * sizeof(uint32_t));
+		CHECK_CUDA_ERROR(err, "Failed to create array on device");
+	}
+
+	// Call device kernel to calculate mandelbrot colors for each pixel
+	Mandelbrot<<<blocksPerGrid, threadsPerBlock>>>(cuda_screen, cuda_colors,
+		WIDTH / 2, HEIGHT / 2,
+		-0.77568377f, 0.13646737,
+		xInterval / WIDTH,
+		1000, 100000,
+		ARR_SIZE);
+	err = cudaGetLastError();
+	CHECK_CUDA_ERROR(err, "Failed to launch kernel: ");
+
+	// Free given memory to avoid memory leaks
+	if (*pixels == nullptr)
+	{
+		*pixels = (Uint32*)malloc(ARR_SIZE * sizeof(Uint32));
+	}
+
+	err = cudaMemcpy(*pixels, cuda_colors, ARR_SIZE * sizeof(Uint32), cudaMemcpyDeviceToHost);
+	CHECK_CUDA_ERROR(err, "Failed to memcpy from device to host");
+
+	return true;
+}
+
+bool MainWindow::OnUpdate(double frametime)
+{
+	SDL_SetWindowTitle(m_pWindow, (std::to_string(1.f / frametime) + std::string(" FPS")).c_str());
+
+	static int pitch = 0;
+	SDL_LockTexture(pRender, NULL, (void**)&pPixels, &pitch);
+
+	if (!GetMandelbrotColors(&pPixels))
+	{
+		SDL_UnlockTexture(pRender);
+		return false;
+	}
+
+	SDL_UnlockTexture(pRender);
+
+	xInterval -= frametime * xInterval * 0.5;
+
+	return true;
+}
+
+void MainWindow::OnRender(SDL_Renderer* renderer)
+{
+	SDL_RenderClear(m_pRenderer);
+	SDL_RenderCopy(m_pRenderer, pRender, NULL, NULL);
+}
+
+void MainWindow::OnClose()
+{
+	//SDL_DestroyTexture(pRender);
+	
+	//free(pPixels);
+	
+	//cudaError_t err;
+
+	// Free device memory for color data
+	// err = cudaFree(cuda_colors);
+
+	// Free device memory for screen indices
+	// err = cudaFree((void*)cuda_screen);
+}
+
+fComplex64 MainWindow::MapComplex(const fComplex64& value, const SDL_Rect& from, const SDL_Rect& to)
+{
+	fComplex64 ret(
+		(value.real() - from.x) * (to.w - to.x) / (from.w - from.x) + to.x,
+		(value.imag() - from.y) * (to.h - to.y) / (from.h - from.y) + to.y
+	);
+	return ret;
+}
+
+fComplex64 MainWindow::MapComplex(const fComplex64& value, const fComplex64& centerPoint, double pixelSize)
+{
+	return ((value - centerPoint) * pixelSize);
+}

Mandelbrot/MainWindow.cuh

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <complex>
+#include <functional>
+
+#include <SDL.h>
+#include "Window.hpp"
+
+typedef std::complex<double> fComplex64;
+typedef std::function<fComplex64(fComplex64, fComplex64)> FractalSequence;
+
+constexpr uint16_t WIDTH = 1000;
+constexpr uint16_t HEIGHT = 800;
+
+
+class MainWindow: public sf::IWindow
+{
+public:
+	MainWindow();
+	~MainWindow() = default;
+
+	void SetFunction(FractalSequence func);
+
+private:
+	bool OnCreate() override;
+	bool OnUpdate(double frametime) override;
+	void OnRender(SDL_Renderer* renderer) override;
+	void OnClose() override;
+
+	fComplex64 MapComplex(const fComplex64& value, const SDL_Rect& from, const SDL_Rect& to);
+	fComplex64 MapComplex(const fComplex64& value, const fComplex64& centerPoint, double pixelSize);
+
+	bool GetMandelbrotColors(Uint32** pixels);
+
+private:
+	FractalSequence pFunction;
+
+	Uint32* cuda_screen = nullptr;
+	Uint32* cuda_colors = nullptr;
+
+	double xInterval = 3.f;
+
+	Uint32* pPixels = nullptr;
+
+	SDL_Texture* pRender;
+};

Mandelbrot/main.cu

@@ -0,0 +1,21 @@
+#include <complex>
+
+#include "MainWindow.cuh"
+
+fComplex64 func(fComplex64 z, fComplex64 c)
+{
+	return z * z + c;
+}
+
+int main(int argc, char** argv)
+{
+	SDL_Init(SDL_INIT_VIDEO);
+
+	MainWindow window;
+	window.SetFunction(func);
+
+	window.Launch(false);
+	window.Stop();
+
+	return 0;
+}

README.me

@@ -0,0 +1 @@
+# Mandelbrot

SDLFramework

@@ -0,0 +1 @@
+Subproject commit f46ca19d3294f2dd9480c6bccf59d734718240db