examples

sdl-gl.cpp (16758B)

---

 #include <GL/gl.h>
 #include <SDL2/SDL.h>
 #include <SDL2/SDL_events.h>
 #include <SDL2/SDL_keycode.h>
 #include <SDL2/SDL_mouse.h>
 #include <SDL2/SDL_video.h>
 #include <err.h>
 
 #include "coroutine_owner.hpp"
 
 #include <algorithm>
 #include <cassert>
 #include <exception>
 #include <format>
 #include <memory>
 #include <numbers>
 #include <print>
 #include <random>
 #include <ranges>
 #include <vector>
 
 #include <unistd.h>
 #include <sys/wait.h>
 #include <err.h>
 
 extern "C" char const* __asan_default_options() { return "detect_leaks=0"; }
 
 struct coroutine_task
 {
 	struct promise_type
 	{
 		coroutine_task get_return_object(void) noexcept { return {}; }
 		std::suspend_never initial_suspend(void) const noexcept { return {}; }
 		std::suspend_never final_suspend() const noexcept { return {}; }
 		void unhandled_exception() const noexcept { std::terminate(); }
 		void return_void(void) const noexcept {}
 	};
 };
 
 template <typename T>
 struct awaitable_value
 {
 	bool ready(T& e)
 	{
 		assert(not event);
 		if (not waiting)
 			return false;
 
 		event = &e;
 		waiting.release().resume();
 		return true;
 	}
 	bool operator()(T& e)
 	{
 		return ready(e);
 	}
 
 	bool await_ready() const
 	{
 		return event;
 	}
 
 	void await_suspend(std::coroutine_handle<> h)
 	{
 		assert(not waiting);
 		waiting.reset(h);
 	};
 
 	T& await_resume()
 	{
 		assert(event);
 		return *std::exchange(event, nullptr);
 	}
 
 private:
 	T* event = nullptr;
 	coroutine_owner<> waiting = {};
 };
 
 template <typename T>
 struct vec2
 {
 	T x = 0, y = 0;
 	vec2 operator -() const { return {-x, -y}; };
 	vec2 operator *(T rhs) const { return {x * rhs, y * rhs}; }
 	vec2 operator /(T rhs) const { return {x / rhs, y / rhs}; }
 	vec2 operator +(vec2 rhs) const { return {x + rhs.x, y + rhs.y}; }
 	vec2 operator -(vec2 rhs) const { return *this + -rhs; }
 	vec2& operator *=(T rhs) { return *this = *this * rhs; }
 	vec2& operator /=(T rhs) { return *this = *this / rhs; }
 	vec2& operator +=(vec2 rhs) { return *this = *this + rhs; }
 	vec2& operator -=(vec2 rhs) { return *this = *this - rhs; }
 	T magnitude_squared() const { return x*x + y*y; }
 };
 
 using point = vec2<float>;
 using screen_coord = vec2<int>;
 
 screen_coord screen = {800, 450};
 float aspect_ratio = (float) screen.x / screen.y;
 
 bool wireframe;
 
 SDL_Window* window;
 
 void initSDL(void)
 {
 	int windowFlags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE;
 
 	if (SDL_Init(SDL_INIT_VIDEO) < 0)
 		errx(1, "Couldn't initialize SDL: %s\n", SDL_GetError());
 
 	window = SDL_CreateWindow("SDL OpenGL example", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, screen.x, screen.y, windowFlags);
 
 	if (!window)
 		errx(1, "Failed to open %d x %d window: %s\n", screen.x, screen.y, SDL_GetError());
 
 	SDL_GLContext context = SDL_GL_CreateContext(window);
 	if (not context)
 		errx(1, "Failed to create OpenGL context: %s", SDL_GetError());
 	if (SDL_GL_MakeCurrent(window, context))
 		errx(1, "Failed to make OpenGL context current: %s", SDL_GetError());
 }
 
 std::mt19937 gen;
 std::lognormal_distribution<float> dis(-1, .75);
 std::normal_distribution<float> norm_dis{0.f, .5f};
 
 struct rgb
 {
 	float r,g,b;
 
 	rgb operator + (rgb const& rhs) const
 	{
 		return {r + rhs.r, g + rhs.g, b + rhs.b};
 	}
 
 	rgb& operator *=(float rhs) { r *= rhs; g *= rhs; b *= rhs; return *this; }
 	rgb& operator /=(float rhs) { r /= rhs; g /= rhs; b /= rhs; return *this; }
 	rgb operator *(float rhs) const { return rgb{*this} *= rhs; }
 	rgb operator /(float rhs) const { return rgb{*this} /= rhs; }
 
 	static rgb random()
 	{
 		return {dis(gen), dis(gen), dis(gen)};
 	}
 };
 
 void glColor(rgb const& c)
 {
 	glColor3f(c.r, c.g, c.b);
 }
 
 
 void glVertex(point p)
 {
 	glVertex2f(p.x, p.y);
 }
 
 point window_to_gl(screen_coord c)
 {
 	float screen_x = (2.f * c.x / screen.x - 1.f);
 	float screen_y = -2.f * c.y / screen.y + 1.f;
 	return {screen_x, screen_y};
 }
 
 float scale = .5f;
 
 point window_to_local(screen_coord c)
 {
 	auto p = window_to_gl(c);
 	p.x *= aspect_ratio;
 	return p * (1/scale);
 }
 
 struct rotor
 {
 	float s, xy;
 	static rotor angle(float turns) { float radians = turns * 2 * std::numbers::pi; return {cos(radians), sin(radians)}; }
 };
 point operator *(point lhs, rotor rhs)
 {
 	return {lhs.x * rhs.s - lhs.y * rhs.xy, lhs.x * rhs.xy + lhs.y * rhs.s};
 }
 
 point& operator *=(point& lhs, rotor rhs)
 {
 	return lhs = lhs * rhs;
 }
 
 struct circle
 {
 	point pos;
 	float radius;
 
 	bool colliding(point p) const
 	{
 		return (pos - p).magnitude_squared() <= radius * radius;
 	}
 };
 
 point pan = {0, 0};
 
 screen_coord mouse_coord;
 point mouse_pos;
 
 struct shp
 {
 	std::string name;
 	std::vector<point> vertices;
 	std::vector<unsigned char> wireframe;
 	GLuint mode;
 };
 
 std::vector<shp> shapes;
 unsigned current_shape = 0;
 
 struct object
 {
 	circle pos;
 	rgb col;
 	float spin;
 	float rotation;
 	shp& shape;
 };
 std::vector<std::shared_ptr<object>> objs = {};
 
 constexpr auto deref = std::views::transform([](auto const& p) -> auto& { return *p; });
 
 void presentScene(void)
 {
 	glClearColor(0, 0, 0, 1);
 	glClear(GL_COLOR_BUFFER_BIT);
 	for (auto& o : objs | deref) {
 		o.rotation += o.spin / 60;
 		rotor r = rotor::angle(o.rotation);
 		if (o.pos.colliding(mouse_pos))
 			glColor(o.col + rgb{.25f, .25f, .25f,});
 		else
 			glColor(o.col);
 
 		if (not wireframe)
 		{
 			glBegin(o.shape.mode);
 			for (auto p : o.shape.vertices)
 			{
 				p *= o.pos.radius;
 				auto pp = (p * r + pan + o.pos.pos) * scale;
 				glVertex2f(pp.x / aspect_ratio, pp.y);
 			}
 		}
 		else
 		{
 			glBegin(GL_LINE_LOOP);
 			for (auto idx : o.shape.wireframe)
 			{
 				auto p = o.shape.vertices[idx];
 				p *= o.pos.radius;
 				auto pp = (p * r + pan + o.pos.pos) * scale;
 				glVertex2f(pp.x / aspect_ratio, pp.y);
 			}
 		}
 		glEnd();
 	}
 	glFinish();
 }
 
 struct panel
 {
 	screen_coord pos, size;
 	rgb colour;
 	void draw() const;
 	bool colliding(screen_coord c)
 	{
 		auto br = pos + size;
 		return c.x >= pos.x && c.y >= pos.y && c.x < br.x && c.y < br.y;
 	}
 };
 
 panel menu;
 bool details;
 std::vector<panel> panels;
 
 void panel::draw() const
 {
 	auto tl = window_to_gl(pos);
 	auto tr = window_to_gl({pos.x + size.x, pos.y});
 	auto bl = window_to_gl({pos.x, pos.y + size.y});
 	auto br = window_to_gl(pos + size);
 
 	glBegin(GL_TRIANGLE_STRIP);
 	glColor(colour);
 	glVertex(tl);
 	glVertex(tr);
 	glVertex(bl);
 	glVertex(br);
 	glEnd();
 	point half{1 / (2.f * screen.x), 1 / (2.f * screen.y)};
 
 	tl.y -= half.y;
 	tr.y -= half.y;
 	bl.y += half.y;
 	br.y += half.y;
 	tr.x -= half.x;
 	br.x -= half.x;
 	tl.x += half.x;
 	bl.x += half.x;
 
 	glBegin(GL_LINE_STRIP);
 	glColor(colour / 2.f);
 	glVertex(bl);
 	glVertex(br);
 	glVertex(tr);
 	glEnd();
 
 	glBegin(GL_LINE_STRIP);
 	glColor(colour * 1.5f);
 	glVertex(bl);
 	glVertex(tl);
 	glVertex(tr);
 	glEnd();
 }
 
 void key(SDL_KeyboardEvent& e)
 {
 	static std::uniform_real_distribution<float> size_dis{.5f, 1.5f};
 	if (e.repeat)
 		return;
 	static uint8_t ctrls;
 	switch (e.keysym.sym)
 	{
 	case SDLK_LCTRL:
 	case SDLK_RCTRL:
 		ctrls += e.state ? 1 : -1;
 		break;
 
 	case SDLK_c:
 		if (e.state && ctrls)
 			exit(0);
 		break;
 
 	case SDLK_a:
 		if (e.state)
 			objs.push_back(std::make_shared<object>(circle{mouse_pos, size_dis(gen)}, rgb::random(), norm_dis(gen), 0, shapes[current_shape]));
 		break;
 
 	case SDLK_d:
 		if (e.state)
 			std::erase_if(objs, [](auto& o) { return o->pos.colliding(mouse_pos); });
 		break;
 
 	case SDLK_r:
 		if (e.state)
 			for (auto& obj : objs | deref)
 				if (obj.pos.colliding(mouse_pos))
 				{
 					std::swap(obj.col.r, obj.col.g);
 					std::swap(obj.col.g, obj.col.b);
 				}
 		break;
 
 	case SDLK_EQUALS:
 		if (e.state)
 			for (auto& obj : objs | deref)
 				if (obj.pos.colliding(mouse_pos))
 					obj.pos.radius *= 1.2;
 		break;
 
 	case SDLK_MINUS:
 		if (e.state)
 			for (auto& obj : objs | deref)
 				if (obj.pos.colliding(mouse_pos))
 					obj.pos.radius /= 1.2;
 		break;
 
 	case SDLK_s:
 		if (e.state)
 		{
 			for (auto& obj : objs | deref)
 				if (obj.pos.colliding(mouse_pos))
 					obj.spin *= -1;
 
 		}
 		break;
 
 	case SDLK_w:
 		if (e.state)
 			wireframe = !wireframe;
 		break;
 
 	case SDLK_ESCAPE:
 		exit(0);
 	}
 }
 
 void mouse_motion(SDL_MouseMotionEvent& e)
 {
 	mouse_coord = {e.x, e.y};
 	mouse_pos = window_to_local(mouse_coord) - pan;
 }
 
 awaitable_value<SDL_MouseButtonEvent const> click_event;
 awaitable_value<SDL_Event const> motion_or_release_event;
 
 coroutine_task mouse_task()
 {
 	for (;;)
 	{
 	loop:
 		SDL_MouseButtonEvent const& e = co_await click_event;
 		point drag_pos = pan - window_to_local({e.x, e.y});
 		if (menu.colliding(mouse_coord))
 		{
 			if (e.button == SDL_BUTTON_LEFT)
 				details = !details;
 			continue;
 		}
 
 		for (auto const& [i, p] : std::views::enumerate(panels))
 			if (p.colliding(mouse_coord))
 			{
 				if (e.button == SDL_BUTTON_LEFT)
 					current_shape = i;
 				goto loop;
 			}
 
 		switch (e.button)
 		{
 		case SDL_BUTTON_RIGHT:
 		{
 			for (;;)
 			{
 				SDL_Event const& e2 = co_await motion_or_release_event;
 				if (e2.type == SDL_MOUSEMOTION)
 					pan = drag_pos + window_to_local({e2.motion.x, e2.motion.y});
 				else if (auto& b = e2.button; b.button == SDL_BUTTON_RIGHT)
 					break;
 			}
 			break;
 		}
 		case SDL_BUTTON_LEFT:
 		{
 			auto it = std::ranges::find_if(objs, [](auto const& o){return o->pos.colliding(mouse_pos);});
 			if (it == std::end(objs))
 				break;
 
 			drag_pos = (*it)->pos.pos - window_to_local({e.x, e.y});
 			std::weak_ptr<object> wp = *it;
 
 			for (;;)
 			{
 				SDL_Event const& e2 = co_await motion_or_release_event;
 				if (wp.expired())
 					break;
 				else if (e2.type == SDL_MOUSEMOTION)
 					wp.lock()->pos.pos = drag_pos + window_to_local({e2.motion.x, e2.motion.y});
 				else if (auto& b = e2.button; b.button == SDL_BUTTON_LEFT)
 					break;
 			}
 			break;
 		}
 		}
 	}
 }
 
 void wheel(SDL_MouseWheelEvent* e)
 {
 	float factor = exp(0.1f * e->y);
 	pan += window_to_local({e->mouseX, e->mouseY}) * (1/factor-1);
 	scale *= factor;
 }
 
 void window_event(SDL_WindowEvent const* e)
 {
 	switch (e->event)
 	{
 	case SDL_WINDOWEVENT_SIZE_CHANGED:
 		screen.x = e->data1;
 		screen.y = e->data2;
 		aspect_ratio = (float) screen.x / screen.y;
 		glViewport(0, 0, screen.x, screen.y);
 		return;
 	}
 }
 
 void doInput()
 {
 	SDL_Event event;
 	while (SDL_PollEvent(&event))
 	{
 		switch (event.type)
 		{
 		case SDL_QUIT:
 			exit(0);
 		case SDL_KEYDOWN:
 		case SDL_KEYUP:
 			key(event.key);
 			break;
 		case SDL_MOUSEMOTION:
 			mouse_motion(event.motion);
 			motion_or_release_event(event);
 			break;
 		case SDL_MOUSEBUTTONDOWN:
 			click_event.ready(event.button);
 			break;
 		case SDL_MOUSEBUTTONUP:
 			motion_or_release_event(event);
 			break;
 		case SDL_MOUSEWHEEL:
 			wheel(&event.wheel);
 			break;
 
 		case SDL_WINDOWEVENT:
 			window_event(&event.window);
 			break;
 
 		default:
 			break;
 		}
 	}
 }
 
 void init_shape()
 {
 	{
 		constexpr int n = 10;
 		shapes.emplace_back();
 		auto& shape = shapes.back();
 		shape.name = "star";
 		shape.mode = GL_TRIANGLE_FAN;
 		shape.vertices.emplace_back(0,0);
 		for (int i = 0; i <= n; ++i)
 			shape.vertices.push_back(point{0, (.65f + i % 2) / -1.65f} * rotor::angle((float)i / n));
 		for (int i = 0; i < n; ++i)
 			shape.wireframe.push_back(i+1);
 	}
 	{
 		constexpr int n = 3;
 		shapes.emplace_back();
 		auto& shape = shapes.back();
 		shape.name = "triangle";
 		shape.mode = GL_TRIANGLES;
 		for (int i = 0; i < n; ++i)
 			shape.vertices.push_back(point{0, 1} * rotor::angle((float)i / n));
 		for (int i = 0; i < n; ++i)
 			shape.wireframe.push_back(i);
 	}
 	{
 		constexpr int n = 4;
 		shapes.emplace_back();
 		auto& shape = shapes.back();
 		shape.name = "square";
 		shape.mode = GL_TRIANGLE_FAN;
 		for (int i = 0; i < n; ++i)
 			shape.vertices.push_back(point{0, 1} * rotor::angle((float)i / n));
 		for (int i = 0; i < n; ++i)
 			shape.wireframe.push_back(i);
 	}
 	{
 		constexpr int n = 64;
 		shapes.emplace_back();
 		auto& shape = shapes.back();
 		shape.name = "crescent";
 		shape.mode = GL_TRIANGLE_STRIP;
 		for (int i = 0; i <= n; ++i)
 		{
 			float turns = i * .5f / n;
 			point p{0, 1};
 			p *= rotor::angle(turns);
 			p.x *= 1 - i % 2 * .45f;
 			shape.vertices.push_back(p);
 		}
 		for (int i = 0; i <= n / 2; ++i)
 			shape.wireframe.push_back(i * 2);
 		for (int i = n / 2; i > 0; --i)
 			shape.wireframe.push_back(i * 2 - 1);
 	}
 }
 
 void init_scene()
 {
 	objs.push_back(std::make_shared<object>(circle{{-1.5f, -1}, 1.f}, rgb{.7,.2,.2}, .2, 0, shapes[0]));
 	objs.push_back(std::make_shared<object>(circle{{0, 1}, .5f}, rgb{.2,.7,.2}, 0, 0, shapes[0]));
 	objs.push_back(std::make_shared<object>(circle{{1.5f, -1}, 1.f}, rgb{.2,.2,.7}, -.2, 0, shapes[0]));
 }
 
 struct psf2
 {
 	unsigned int magic, version, hdr_size, flags, length, g_size, height, width;
 };
 struct font
 {
 	psf2 hdr;
 	GLuint tex;
 	font(char const* filename)
 	{
 		int fds[2];
 		if (pipe(fds))
 			err(1, "pipe");
 		pid_t child = fork();
 		if (child < 0)
 			err(1, "fork");
 		if (!child)
 		{
 			if (dup2(fds[1], 1) == -1)
 				err(1, "dup2");
 			if (close(fds[0]))
 				err(1, "close");
 			if (close(fds[1]))
 				err(1, "close");
 			execlp("gunzip", "gunzip", "--stdout", filename, nullptr);
 			err(1, "execlp");
 		}
 		close(fds[1]);
 
 		if (read(fds[0], &hdr, sizeof(hdr)) != sizeof(hdr))
 			err(1, "read");
 		if (hdr.magic != 0x864AB572)
 			errx(1, "Not a PSF2 file");
 
 		std::vector<unsigned char> storage(hdr.length * hdr.g_size);
 
 		for (ssize_t read = 0; read < (ssize_t)storage.size(); )
 		{
 			int n = ::read(fds[0], storage.data() + read, storage.size() - read);
 			if (n < 0)
 				err(1, "read");
 			if (n == 0)
 				errx(1, "not enough data from font");
 			read += n;
 		}
 		close(fds[0]);
 		assert(wait(nullptr) == child);
 		std::vector<unsigned char> pix(hdr.length * hdr.height * hdr.width);
 
 		for (size_t i = 0; i < pix.size(); ++i)
 			pix[i] = ((storage[i / 8] >> (7 - i % 8)) & 1) * 255;
 
 		glGenTextures(1, &tex);
 		glBindTexture(GL_TEXTURE_2D, tex);
 		glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, hdr.width, hdr.height * hdr.length, 0, GL_ALPHA, GL_UNSIGNED_BYTE, pix.data());
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 	}
 	screen_coord draw(unsigned char c, screen_coord pos)
 	{
 		screen_coord br_screen{pos.x + (int)hdr.width, pos.y + (int)hdr.height};
 		float text = (float)c / hdr.length;
 		float texb = (float)(c + 1u) / hdr.length;
 		auto tl = window_to_gl(pos);
 		auto tr = window_to_gl({br_screen.x, pos.y});
 		auto bl = window_to_gl({pos.x, br_screen.y});
 		auto br = window_to_gl(br_screen);
 
 		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 		glEnable(GL_BLEND);
 		glEnable(GL_TEXTURE_2D);
 		glBegin(GL_TRIANGLE_STRIP);
 		glTexCoord2f(0,text);
 		glVertex(tl);
 		glTexCoord2f(1,text);
 		glVertex(tr);
 		glTexCoord2f(0,texb);
 		glVertex(bl);
 		glTexCoord2f(1,texb);
 		glVertex(br);
 		glEnd();
 		glDisable(GL_TEXTURE_2D);
 		glDisable(GL_BLEND);
 
 		return br_screen;
 	}
 	screen_coord draw(std::string_view str, screen_coord pos)
 	{
 		for (auto c : str)
 			pos.x = draw(c, pos).x;
 		return pos;
 	}
 };
 
 std::unique_ptr<font> fnt;
 
 void draw_UI()
 {
 	std::vector<std::string> strings;
 	strings.push_back(std::format("scale: {:.2}", scale));
 	strings.push_back(std::format("  pan: ({:.1}, {:.1})", pan.x, pan.y));
 	strings.push_back(std::format("{} shapes", shapes.size()));
 	strings.push_back(std::format("{} objects", objs.size()));
 	int width = (int)(2 + fnt->hdr.width * std::ranges::max(strings | std::views::transform([](auto const& s){ return s.size(); })));
 	int height = (int)(2 + fnt->hdr.height * strings.size());
 	menu.size = {width, height};
 	menu.colour = menu.colliding(mouse_coord) ? rgb{.6, .6, .6} : rgb{.4, .4, .4};
 	menu.draw();
 	glColor3f(0, 0, 0);
 	int y = 1;
 	for (auto const& s : strings)
 	{
 		fnt->draw(s, {1, y});
 		y += fnt->hdr.height;
 	}
 
 	y += 5;
 
 	panels.clear();
 
 	for (auto const& [i, s] : std::views::enumerate(shapes))
 	{
 		auto& p = panels.emplace_back(
 			screen_coord{0, y},
 			screen_coord{width, (int)fnt->hdr.height},
 			rgb{.4, .4, .4}
 		);
 		if (p.colliding(mouse_coord))
 			p.colour = rgb{.3, .6, .3};
 		p.draw();
 		if (current_shape == i)
 			glColor3f(1, 1, 1);
 		else
 			glColor3f(0, 0, 0);
 		fnt->draw(s.name, {1, y});
 		y += fnt->hdr.height;
 	}
 	if (not details)
 		return;
 
 	auto x = (int)width;
 	strings.clear();
 	for (auto const& [i, o] : objs | deref | std::views::enumerate)
 		strings.push_back(std::format("{}: size {}", i, o.pos.radius));
 
 	if (strings.empty())
 		return;
 
 	width = (int)(2 + fnt->hdr.width * std::ranges::max(strings | std::views::transform([](auto const& s){ return s.size(); })));
 	height = (int)(2 + fnt->hdr.height * strings.size());
 	panel{{x, 0}, {width, height}, rgb{.4, .4, .4}}.draw();
 	glColor3f(0, 0, 0);
 	y = 1;
 	for (auto const& s : strings)
 	{
 		fnt->draw(s, {x + 1, y});
 		y += fnt->hdr.height;
 	}
 }
 
 int main()
 {
 	init_shape();
 	init_scene();
 	mouse_task();
 	initSDL();
 	atexit(SDL_Quit);
 
 	fnt.reset(new font{"/usr/share/kbd/consolefonts/lat9-16.psf.gz"});
 
 	for (;;)
 	{
 		doInput();
 		presentScene();
 		draw_UI();
 		SDL_GL_SwapWindow(window);
 	}
 }