128 lines
No EOL
3.3 KiB
C++
128 lines
No EOL
3.3 KiB
C++
|
|
|
|
#include <SDL2/SDL.h>
|
|
|
|
#include <chrono>
|
|
#include <memory>
|
|
#include <print>
|
|
#include <random>
|
|
|
|
namespace {
|
|
|
|
template <typename SDLT, auto deletef>
|
|
struct sdl_wrapper_t : std::unique_ptr<SDLT, decltype(deletef)> {
|
|
explicit sdl_wrapper_t(SDLT* p)
|
|
: std::unique_ptr<SDLT, decltype(deletef)>{p, deletef} {}
|
|
|
|
operator SDLT*() { return std::unique_ptr<SDLT, decltype(deletef)>::get(); }
|
|
};
|
|
|
|
using window_t = sdl_wrapper_t<SDL_Window, SDL_DestroyWindow>;
|
|
using surface_t = sdl_wrapper_t<SDL_Surface, SDL_FreeSurface>;
|
|
using renderer_t = sdl_wrapper_t<SDL_Renderer, SDL_DestroyRenderer>;
|
|
|
|
auto operator+(SDL_Point a, SDL_Point b) {
|
|
return SDL_Point{.x = a.x + b.x, .y = a.y + b.y};
|
|
}
|
|
|
|
auto operator<=>(const SDL_Point& a, const SDL_Point& b) {
|
|
auto y_comp = a.x <=> b.x;
|
|
if (y_comp != std::strong_ordering::equal) { return y_comp; }
|
|
return a.y <=> b.y;
|
|
}
|
|
|
|
auto operator==(const SDL_Point& a, const SDL_Point& b) {
|
|
return a.x == b.x && a.y == b.y;
|
|
}
|
|
|
|
constexpr int width = 1000;
|
|
constexpr int height = 1000;
|
|
|
|
template <auto EF>
|
|
struct [[nodiscard("give this a name so SDL_Quit is called at the end"
|
|
)]] Defer {
|
|
Defer() = default;
|
|
Defer(const Defer&) = delete;
|
|
Defer(Defer&&) = delete;
|
|
auto operator=(Defer&&) = delete;
|
|
auto operator=(const Defer&) = delete;
|
|
|
|
~Defer() { EF(); }
|
|
};
|
|
|
|
using clock = std::chrono::steady_clock;
|
|
|
|
auto poll_events(bool& continu) {
|
|
for (SDL_Event e; SDL_PollEvent(&e);) {
|
|
if (e.type == SDL_QUIT) { continu = false; }
|
|
}
|
|
}
|
|
} // namespace
|
|
|
|
int main() {
|
|
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
|
|
std::println("fuck");
|
|
return EXIT_FAILURE;
|
|
}
|
|
Defer<SDL_Quit> defer_SDL_Quit;
|
|
|
|
window_t window{SDL_CreateWindow(
|
|
"random walk", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, width,
|
|
height, 0
|
|
)};
|
|
if (!window) {
|
|
std::println(
|
|
"Window could not be created! SDL_Error: {}", SDL_GetError()
|
|
);
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
// owned by window
|
|
auto* window_surface = SDL_GetWindowSurface(window);
|
|
if (!window_surface) { return EXIT_FAILURE; }
|
|
if (window_surface->format->palette) { return EXIT_FAILURE; }
|
|
std::println(
|
|
"got surface with {} bits per pixel",
|
|
window_surface->format->BitsPerPixel
|
|
);
|
|
if (!(window_surface->format->format & SDL_PIXELFORMAT_RGBA32)) {
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
SDL_Point pos{.x = width / 2, .y = height / 2};
|
|
const SDL_Point directions[] = {
|
|
{.x = -1, .y = 0}, {.x = 1, .y = 0}, {.x = 0, .y = -1}, {.x = 0, .y = 1}
|
|
};
|
|
|
|
std::mt19937_64 rne(std::random_device{}());
|
|
std::uniform_int_distribution dist(0, 3);
|
|
// aarrggbb??
|
|
constexpr Uint32 walk_color = 0xff00ff00;
|
|
|
|
const auto start_time = clock::now();
|
|
auto next_poll_events_time = start_time;
|
|
for (bool continu = true; continu;) {
|
|
|
|
SDL_LockSurface(window_surface);
|
|
for (auto batch = 0z; batch < 1000; ++batch) {
|
|
SDL_Point newpoint;
|
|
do {
|
|
newpoint = pos + directions[dist(rne)];
|
|
} while (newpoint.x < 0 or newpoint.x >= width or newpoint.y < 0 or
|
|
newpoint.y >= height);
|
|
pos = newpoint;
|
|
static_cast<Uint32*>(window_surface->pixels
|
|
)[pos.x + pos.y * window_surface->h] = walk_color;
|
|
}
|
|
SDL_UnlockSurface(window_surface);
|
|
SDL_UpdateWindowSurface(window);
|
|
|
|
const auto now = clock::now();
|
|
if (now >= next_poll_events_time) {
|
|
next_poll_events_time = now + std::chrono::milliseconds{100};
|
|
poll_events(continu);
|
|
}
|
|
}
|
|
|
|
// leaking memory, nothing I can do
|
|
} |