C++ / SDL로 망델브로 집합 그려보기 – 4

	void processEvent(SDL_Event* event);
	bool mouseCaptured();
	bool keyCaptured();

	void render(const Mandelbrot* mandelbrot);
	void draw();

	void saveCapture(SDL_Surface* surface);

	struct {
		Acc accelerator;
		float move_speed;
		float scroll_scale;
		bool scaleToCursor;
		bool reset_params;
		char capture_dir[100];
		bool capture_no_ui;
	} settings;
	
	void postErrorMessage(const char* msg);

private:
	SDL_Renderer* renderer;
	SDL_Window* window;
	
	std::string message;
	int msg_timepoint;
};

#include "gui.h"

#define STB_IMAGE_WRITE_IMPLEMENTATION
#ifndef __STDC_LIB_EXT1__
#define __STDC_LIB_EXT1__
#endif 

#include <sstream>
#include <imgui_impl_sdl.h>
#include <imgui_impl_sdlrenderer.h>
#include <stb_image_write.h>

#include "mandelbrot.h"
#include "time.h"

using namespace std;

static string getCaptureName() {
	time_t now = time(0);
	char buf[80];
	tm tstruct;
	localtime_s(&tstruct, &now);
	strftime(buf, sizeof(buf), "%Y-%m-%d-%H-%M-%S.png", &tstruct);
	return { buf };
}
...

	settings.scroll_scale  = 1.1f;
	settings.scaleToCursor = true;
	
	memset(settings.capture_dir, '\0', 100);
	strcat_s(settings.capture_dir, 100, "captures\\");
	settings.capture_no_ui = true;
	
	msg_timepoint = -3000;
...

	if (ImGui::TreeNode("screenshot")) {
		ImGui::Text("directory :");
		ImGui::InputText("##3", settings.capture_dir, 255);
		ImGui::Checkbox("no UI", &settings.capture_no_ui);
		if (ImGui::Button("capture")) {
			if (settings.capture_no_ui) {
				saveCapture(mandelbrot->getSurface());
			} else {
				SDL_Surface* surface = SDL_CreateRGBSurface(0, width, height, 32, 0, 0, 0, 0);
				auto* format         = (uint32_t*)(surface->format);
				SDL_RenderReadPixels(renderer, 0, *format, surface->pixels, width * 4);
				saveCapture(surface);
				SDL_FreeSurface(surface);
			}
		}
		ImGui::TreePop();
	}

	ImGui::SetWindowSize({ 260, ImGui::GetContentRegionAvail().y});

	if (clock() - msg_timepoint < 3000) {
		auto* drawlist = ImGui::GetForegroundDrawList();
		auto position  = ImGui::GetWindowPos();
		ImColor color  = { 255, 0, 0 };

		position.y += ImGui::GetWindowHeight();
		drawlist->AddText(position, color, message.c_str());
	}

	ImGui::End();
	ImGui::Render();
}

void GUI::draw()
{
	ImGui_ImplSDLRenderer_RenderDrawData(ImGui::GetDrawData());
}

void GUI::saveCapture(const Mandelbrot* mandelbrot)
{
	SDL_Surface* surface;
	auto& dir = settings.capture_dir;
	auto name = dir + getCaptureName();

	if (settings.capture_no_ui)
		surface = mandelbrot->getSurface();
	else surface = SDL_GetWindowSurface(window);

	surface = SDL_ConvertSurfaceFormat(surface, SDL_PIXELFORMAT_RGB24, 0);
	int res = stbi_write_png(name.c_str(), surface->w, surface->h, 3, surface->pixels, surface->w * 3);
	SDL_FreeSurface(surface);

	if (res == 0) postErrorMessage("couldn't save capture!\ncheck if your directory exists");
}

void GUI::postErrorMessage(const char* msg)
{
	msg_timepoint = clock();
	message       = msg;
}

void EventAsync(unique_ptr<GUI>& gui, unique_ptr<Mandelbrot>& mandelbrot) {
	if (gui->keyCaptured()) return;
	auto* keyStates = SDL_GetKeyboardState(NULL);
...

		case SDL_KEYDOWN:
			if (gui->keyCaptured()) break;
			KeyProc(e.key, mandelbrot);
			break;

#include <complex>
#include <future>
#include <atomic>
#include <SDL2/SDL.h>

class Mandelbrot
{
public:
	using real_t = double;

	Mandelbrot(SDL_Renderer* renderer);
	~Mandelbrot();

	void render(bool async = true);
	void draw();

	void stop();
	void wait();
	bool isRendering() const;
...

	std::complex<real_t> pixelToComplex(real_t px, real_t py) const;

protected:
	void startAsync();
	void drawSurface();
	void update();
...

	uint32_t iter;

	std::future<void> future;
	std::atomic<bool> is_rendering;
	std::atomic<bool> stop_all;
	bool updated;

	iter  = 100;

	is_rendering = false;
	stop_all     = false;
	updated      = false;
}
...

void Mandelbrot::render(bool async)
{
	if (!updated) {
		if (!async) {
			is_rendering = true; // just in case...
			drawSurface();
			is_rendering = false;
		} else startAsync();

		updated = true;
	}
}

void Mandelbrot::draw()
{
	SDL_UpdateTexture(texture, NULL, surface->pixels, surface->pitch);
	SDL_RenderCopy(renderer, texture, nullptr, nullptr);
}


void Mandelbrot::stop()
{
	if (is_rendering) {
		stop_all = true;
		wait();
		stop_all = false;
		is_rendering = false;
	}
}

void Mandelbrot::wait()
{
	if (is_rendering)
		future.get(); // or wait()
}

bool Mandelbrot::isRendering() const
{
	return is_rendering;
}

void Mandelbrot::resize()
{
	stop();
	SDL_FreeSurface(surface);
...

	texture = SDL_CreateTextureFromSurface(renderer, surface);
	update();
}

void Mandelbrot::setPosition(real_t x, real_t y)
{
	stop();
	pos_x   = x;
	pos_y   = y;
	update();
}

void Mandelbrot::move(int32_t rel_px, int32_t rel_py)
{
	stop();
	real_t dx = 4. * scale * aspect / width;
	real_t dy = 4. * scale / height;
	
	pos_x  -= dx * rel_px;
	pos_y  += dy * rel_py;
	update();
}

void Mandelbrot::setScale(real_t scale)
{
	stop();
	this->scale = scale;
	update();
}

void Mandelbrot::setScaleTo(real_t scale, real_t px, real_t py)
{
	stop();
	auto point  = pixelToComplex(px, py);
...

	pos_y = point.imag() - 2. * scale + py * dy;
	update();
}

void Mandelbrot::setIteration(uint32_t iter)
{
	stop();
	this->iter = iter;
	update();
}
...

void Mandelbrot::startAsync()
{
	future = async(launch::async, [this] {
		is_rendering = true;
		drawSurface();
		is_rendering = false;
	});
}
...

void Mandelbrot::update()
{
	stop();
	updated = false;
}

	while (!closed) {
		closed = EventProc(gui, mandelbrot);
		
		mandelbrot->render(); // async
		gui->render(mandelbrot.get());
		
		if (gui->settings.reset_params) {
			mandelbrot->setPosition(0., 0.);
			mandelbrot->setScale(1.);
			mandelbrot->setIteration(32);
			gui->settings.reset_params = false;
		}
		
		mandelbrot->draw();
		gui->draw();
		SDL_RenderPresent(renderer);

		Time::update();
	}

#include <SDL2/SDL.h>

inline uint32_t make_color(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 0xff) {
	return (a << 24) + (r << 16) + (g << 8) + b;
}


template <class T>
inline uint32_t mandelbrot(T cx, T cy, uint32_t max_iter) {
	T zx = 0., zy = 0.;
	int i = 0;

	do {
		T temp = zx * zx - zy * zy + cx;
		zy = 2. * zx * zy + cy;
		zx = temp;
	} while (zx * zx + zy * zy < 4. && ++i < max_iter);

	return i;
}
...

	virtual ~Mandelbrot();
	
	void render(bool async = true);
	virtual void draw();

	virtual void stop();
	virtual void wait();
	virtual bool isRendering() const;
...

protected:
	virtual void startAsync();
	virtual void drawSurface();
	void update();

			auto iterated = mandelbrot<real_t>(cx, cy , iter);

	unique_ptr<Mandelbrot> mandelbrot = make_unique<MandelbrotTBB>(renderer);