diff --git a/shuriken.yaml b/shuriken.yaml index 5983465..8dd0a71 100644 --- a/shuriken.yaml +++ b/shuriken.yaml @@ -8,4 +8,3 @@ default_target: linux targets: linux: output_file: rutile_game - # TODO: In a release build, set -DNDEBUG diff --git a/src/app.cppm b/src/app.cppm deleted file mode 100644 index 7b59948..0000000 --- a/src/app.cppm +++ /dev/null @@ -1,87 +0,0 @@ -module; - -#include -#include -#include - -export module app; - -import config; -import core.engine; -import game.game; -import wrappers.sdl; - -export -{ - class App - { - std::unique_ptr engine_{nullptr}; - std::unique_ptr game_{nullptr}; - - public: - App() = default; - - sdl::AppResult initialize() - { - try { - // Set SDL application metadata - sdl::SetAppMetadataProperty(SDL_PROP_APP_METADATA_NAME_STRING, config::app_name); - sdl::SetAppMetadataProperty(SDL_PROP_APP_METADATA_VERSION_STRING, config::app_version); - sdl::SetAppMetadataProperty(SDL_PROP_APP_METADATA_IDENTIFIER_STRING, config::app_identifier); - sdl::SetAppMetadataProperty(SDL_PROP_APP_METADATA_CREATOR_STRING, config::app_creator); - sdl::SetAppMetadataProperty(SDL_PROP_APP_METADATA_COPYRIGHT_STRING, config::app_copyright); - sdl::SetAppMetadataProperty(SDL_PROP_APP_METADATA_URL_STRING, config::app_url); - sdl::SetAppMetadataProperty(SDL_PROP_APP_METADATA_TYPE_STRING, "game"); - - // Initialize SDL subsystems - sdl::Init(sdl::InitFlags::Video | sdl::InitFlags::Events); - - // Create engine (includes window and renderer) and game state - engine_ = core::Engine::create(); - game_ = game::Game::create(*engine_); - } - catch (const std::runtime_error& e) { - std::cerr << "Unhandled exception during initialization: " << e.what() << '\n'; - return sdl::AppResult::Failure; - } - - return sdl::AppResult::Continue; - } - - sdl::AppResult handle_event(const sdl::Event* event) - { - try { - if (!engine_->handle_event(event)) { - game_->handle_event(event); - } - } - catch (const std::runtime_error& e) { - std::cerr << "Unhandled exception during event handling: " << e.what() << '\n'; - return sdl::AppResult::Failure; - } - - return engine_->keep_running() ? sdl::AppResult::Continue : sdl::AppResult::Success; - } - - sdl::AppResult iterate() - { - try { - engine_->update(); - game_->update(); - game_->render(); - } - catch (const std::runtime_error& e) { - std::cerr << "Unhandled exception during updating: " << e.what() << '\n'; - return sdl::AppResult::Failure; - } - - return engine_->keep_running() ? sdl::AppResult::Continue : sdl::AppResult::Success; - } - - void shutdown() const - { - engine_->shutdown(); - game_->shutdown(); - } - }; -} diff --git a/src/config.cppm b/src/config.cppm deleted file mode 100644 index 0ed9a38..0000000 --- a/src/config.cppm +++ /dev/null @@ -1,36 +0,0 @@ -module; - -#include - -#ifdef NDEBUG -#define DEBUG_BOOL false -#else -#define DEBUG_BOOL true -#endif - -export module config; - -export namespace config -{ - constexpr auto debug = DEBUG_BOOL; - - constexpr auto app_name = "Rutile Game Prototype"; - constexpr auto app_version = "0.0.1-dev"; - constexpr auto app_identifier = "dev.binarydiv.rutile_game"; - constexpr auto app_creator = "binaryDiv"; - constexpr auto app_copyright = "Copyright (c) 2025 binaryDiv"; - constexpr auto app_url = "https://git.0xbd.space/binaryDiv/rutile-game"; - - constexpr auto window_width = 640; - constexpr auto window_height = 480; - - constexpr auto get_window_title() - { - if constexpr (debug) { - return std::format("{} ({}) [DEBUG]", app_name, app_version); - } - else { - return std::format("{} ({})", app_name, app_version); - } - } -} diff --git a/src/core/engine.cppm b/src/core/engine.cppm deleted file mode 100644 index 3d50323..0000000 --- a/src/core/engine.cppm +++ /dev/null @@ -1,107 +0,0 @@ -module; - -#include -#include -#include - -export module core.engine; - -import config; -import core.renderer; -import wrappers.sdl; - -export namespace core -{ - using Window = sdl::Window; - - class Engine - { - // Whether this class is currently instantiated (to prevent multiple instances) - static bool instantiated_; - - // If this is set to false, the application will exit - bool keep_running_ = true; - - Window window_; - Renderer renderer_; - - // Private constructor - Engine(Window&& window, Renderer&& renderer) - : window_{std::move(window)}, - renderer_{std::move(renderer)} - { - instantiated_ = true; - } - - public: - Engine() = delete; - - // No copy or move operations - Engine(const Engine&) = delete; - Engine& operator=(const Engine&) = delete; - Engine(Engine&&) = delete; - Engine& operator=(Engine&&) = delete; - - ~Engine() - { - instantiated_ = false; - } - - static std::unique_ptr create() - { - // Prevent the class from being instantiated multiple times - assert(!instantiated_); - - auto [sdl_window, sdl_renderer] = sdl::CreateWindowAndRenderer( - config::get_window_title(), - config::window_width, - config::window_height, - 0 - ); - - return std::unique_ptr{ - new Engine{ - std::move(sdl_window), - Renderer{std::move(sdl_renderer)} - } - }; - } - - bool keep_running() const - { - return keep_running_; - } - - Window& get_window() - { - return window_; - } - - Renderer& get_renderer() - { - return renderer_; - } - - // Handles an SDL event. Returns true if the event has been handled. - bool handle_event(const sdl::Event* event) - { - if (event->type == SDL_EVENT_QUIT) { - // Exit the application - keep_running_ = false; - return true; - } - - return false; - } - - void update() - { - } - - void shutdown() - { - } - }; - - bool Engine::instantiated_ = false; -} diff --git a/src/core/renderer.cppm b/src/core/renderer.cppm deleted file mode 100644 index 1704c2f..0000000 --- a/src/core/renderer.cppm +++ /dev/null @@ -1,47 +0,0 @@ -module; - -#include - -export module core.renderer; - -import wrappers.sdl; - -export namespace core -{ - // TODO: Rename this class to RenderServer or something to distinguish it from sdl::Renderer? - class Renderer - { - sdl::Renderer sdl_renderer_; - - public: - Renderer() = delete; - - explicit Renderer(sdl::Renderer&& sdl_renderer) - : sdl_renderer_{std::move(sdl_renderer)} - {} - - constexpr sdl::Renderer& get_sdl_renderer() - { - return sdl_renderer_; - } - - void start_frame() const - { - sdl_renderer_.clear(); - } - - void finish_frame() const - { - sdl_renderer_.present(); - } - - void render_texture( - const sdl::Texture& texture, - const sdl::FRect* src_rect, - const sdl::FRect* dest_rect - ) const - { - sdl_renderer_.render_texture(texture, src_rect, dest_rect); - } - }; -} diff --git a/src/game/game.cppm b/src/game/game.cppm deleted file mode 100644 index 1d68ace..0000000 --- a/src/game/game.cppm +++ /dev/null @@ -1,95 +0,0 @@ -module; - -#include -#include -#include - -export module game.game; - -import core.engine; -import core.renderer; -import game.sprite; -import wrappers.sdl; -import wrappers.sdl_image; - -export namespace game -{ - class Game - { - // Whether this class is currently instantiated (to prevent multiple instances) - static bool instantiated_; - - // Reference to the engine - core::Engine& engine_; - - // Sprite for testing - std::unique_ptr sprite_{nullptr}; - - // Private constructor - explicit Game(core::Engine& engine) - : engine_(engine) - { - // TODO: Texture should be a reference/pointer to an object managed by a ResourceManager or similar. - auto texture = sdl_image::LoadTexture( - engine_.get_renderer().get_sdl_renderer(), - "assets/neocat.png" - ); - - sprite_ = std::make_unique(std::move(texture), 100, 100); - } - - public: - Game() = delete; - - // No copy or move operations because we have a reference to the engine - Game(const Game&) = delete; - Game& operator=(const Game&) = delete; - Game(Game&&) = delete; - Game& operator=(Game&&) = delete; - - ~Game() - { - instantiated_ = false; - } - - static std::unique_ptr create(core::Engine& engine) - { - // Prevent the class from being instantiated multiple times - assert(!instantiated_); - return std::unique_ptr{ - new Game(engine) - }; - } - - // Handles an SDL event. Returns true if the event has been handled. - bool handle_event(const sdl::Event* event) const - { - if (event->type == SDL_EVENT_MOUSE_MOTION) { - sprite_->move( - event->motion.x - 50, - event->motion.y - 50 - ); - return true; - } - return false; - } - - void update() - { - } - - void render() const - { - const auto& renderer = engine_.get_renderer(); - renderer.start_frame(); - sprite_->draw(renderer); - renderer.finish_frame(); - } - - void shutdown() - { - } - }; - - bool Game::instantiated_ = false; -} diff --git a/src/game/sprite.cppm b/src/game/sprite.cppm deleted file mode 100644 index 901ea28..0000000 --- a/src/game/sprite.cppm +++ /dev/null @@ -1,43 +0,0 @@ -module; - -#include -#include - -export module game.sprite; - -import core.renderer; -import wrappers.sdl; - -// TODO: Move this to a different namespace (core, drawing, ...?) -export namespace game -{ - class Sprite - { - // TODO: Texture should be a reference/pointer to an object managed by a ResourceManager or similar. - sdl::Texture texture_; - sdl::FRect dest_rect_{0, 0, 0, 0}; - - public: - explicit Sprite( - sdl::Texture&& texture, - const int width, - const int height - ) - : texture_{std::move(texture)} - { - dest_rect_.w = static_cast(width); - dest_rect_.h = static_cast(height); - } - - void move(const float x, const float y) - { - dest_rect_.x = x; - dest_rect_.y = y; - } - - void draw(const core::Renderer& renderer) const - { - renderer.render_texture(texture_, nullptr, &dest_rect_); - } - }; -} diff --git a/src/main.cpp b/src/main.cpp index 4a0a4fc..cdfe69e 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1,30 +1,27 @@ -import app; +import sdl_app; #define SDL_MAIN_USE_CALLBACKS #include -SDL_AppResult SDL_AppInit(void** appstate, const int /*argc*/, char** /*argv*/) +SDL_AppResult SDL_AppInit(void** appstate, int /*argc*/, char** /*argv*/) { - auto* app = new App; - *appstate = app; - return static_cast(app->initialize()); -} - -SDL_AppResult SDL_AppEvent(void* appstate, SDL_Event* event) -{ - auto* app = static_cast(appstate); - return static_cast(app->handle_event(event)); + *appstate = new AppState; + return sdl_app_init(static_cast(*appstate)); } SDL_AppResult SDL_AppIterate(void* appstate) { - auto* app = static_cast(appstate); - return static_cast(app->iterate()); + return sdl_app_iterate(static_cast(appstate)); } -void SDL_AppQuit(void* appstate, const SDL_AppResult /*result*/) +SDL_AppResult SDL_AppEvent(void* appstate, SDL_Event* event) { - const auto* app = static_cast(appstate); - app->shutdown(); - delete app; + return sdl_app_event(static_cast(appstate), event); +} + +void SDL_AppQuit(void* appstate, SDL_AppResult /*result*/) +{ + const auto* game_app_state = static_cast(appstate); + sdl_app_shutdown(game_app_state); + delete game_app_state; } diff --git a/src/sdl_app.cppm b/src/sdl_app.cppm new file mode 100644 index 0000000..7e14111 --- /dev/null +++ b/src/sdl_app.cppm @@ -0,0 +1,95 @@ +module; + +#include +#include +#include + +export module sdl_app; + +import sprite; + +export { + struct AppState + { + SDL_Window* window = nullptr; + SDL_Renderer* renderer = nullptr; + Sprite* sprite = nullptr; + }; + + SDL_AppResult sdl_panic( + const std::string& error_prefix, + SDL_Window* window = nullptr, + SDL_Renderer* renderer = nullptr + ) + { + std::cerr << error_prefix << ": " << SDL_GetError() << '\n'; + + if (renderer != nullptr) { + SDL_DestroyRenderer(renderer); + } + if (window != nullptr) { + SDL_DestroyWindow(window); + } + + SDL_Quit(); + return SDL_APP_FAILURE; + } + + SDL_AppResult sdl_app_init(AppState* app_state) + { + if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS)) { + return sdl_panic("SDL_Init error"); + } + + app_state->window = SDL_CreateWindow("BuildSystemTest", 640, 480, 0); + if (app_state->window == nullptr) { + return sdl_panic("SDL_CreateWindow error"); + } + + app_state->renderer = SDL_CreateRenderer(app_state->window, nullptr); + if (app_state->renderer == nullptr) { + return sdl_panic("SDL_CreateRenderer error", app_state->window); + } + + try { + app_state->sprite = new Sprite(app_state->renderer, "assets/neocat.png", 100, 100); + } + catch (const std::runtime_error& e) { + return sdl_panic(e.what(), app_state->window, app_state->renderer); + } + + return SDL_APP_CONTINUE; + } + + SDL_AppResult sdl_app_event(const AppState* app_state, const SDL_Event* event) + { + if (event->type == SDL_EVENT_QUIT) { + return SDL_APP_SUCCESS; + } + + if (event->type == SDL_EVENT_MOUSE_MOTION) { + app_state->sprite->move( + event->motion.x - 50, + event->motion.y - 50 + ); + } + + return SDL_APP_CONTINUE; + } + + SDL_AppResult sdl_app_iterate(const AppState* app_state) + { + SDL_RenderClear(app_state->renderer); + app_state->sprite->render(app_state->renderer); + SDL_RenderPresent(app_state->renderer); + + return SDL_APP_CONTINUE; + } + + void sdl_app_shutdown(const AppState* app_state) + { + delete app_state->sprite; + SDL_DestroyRenderer(app_state->renderer); + SDL_DestroyWindow(app_state->window); + } +} diff --git a/src/sprite.cppm b/src/sprite.cppm new file mode 100644 index 0000000..3318180 --- /dev/null +++ b/src/sprite.cppm @@ -0,0 +1,81 @@ +module; + +#include +#include +#include +#include + +export module sprite; + +export class Sprite +{ + SDL_Texture* sdl_texture; + SDL_FRect dest_rect{0, 0, 0, 0}; + + public: + explicit Sprite( + SDL_Renderer* renderer, + const std::string& filename, + const int width, + const int height + ) + { + SDL_Surface* texture_surface = IMG_Load(filename.c_str()); + if (texture_surface == nullptr) { + throw std::runtime_error("IMG_Load error"); + } + + sdl_texture = SDL_CreateTextureFromSurface(renderer, texture_surface); + SDL_DestroySurface(texture_surface); + + if (sdl_texture == nullptr) { + throw std::runtime_error("SDL_CreateTextureFromSurface error"); + } + + dest_rect.w = static_cast(width); + dest_rect.h = static_cast(height); + } + + // Don't allow copy operations + Sprite(const Sprite&) = delete; + Sprite& operator=(const Sprite&) = delete; + + // Move constructor + Sprite(Sprite&& other) noexcept + : sdl_texture(other.sdl_texture), + dest_rect(other.dest_rect) + { + other.sdl_texture = nullptr; + } + + // Move assignment + Sprite& operator=(Sprite&& other) noexcept + { + // Move inner resources from other + sdl_texture = other.sdl_texture; + dest_rect = other.dest_rect; + + // Reset other to make it safe for deletion + other.sdl_texture = nullptr; + + return *this; + } + + ~Sprite() + { + if (sdl_texture != nullptr) { + SDL_DestroyTexture(sdl_texture); + } + } + + void move(const float x, const float y) + { + dest_rect.x = x; + dest_rect.y = y; + } + + void render(SDL_Renderer* renderer) const + { + SDL_RenderTexture(renderer, sdl_texture, nullptr, &dest_rect); + } +}; diff --git a/src/utils/memory.cppm b/src/utils/memory.cppm deleted file mode 100644 index d1e16ad..0000000 --- a/src/utils/memory.cppm +++ /dev/null @@ -1,21 +0,0 @@ -module; - -export module utils.memory; - -export namespace utils -{ - /** - * Template to generate deleters for `std::unique_ptr` from functions, e.g. to free SDL resources. - * - * @tparam delete_func Function that takes a pointer to a resource and deletes the resource. - */ - template - struct FuncDeleter - { - template - constexpr void operator()(T* ptr) const noexcept - { - delete_func(ptr); - } - }; -} diff --git a/src/wrappers/sdl.cppm b/src/wrappers/sdl.cppm deleted file mode 100644 index 8e8088d..0000000 --- a/src/wrappers/sdl.cppm +++ /dev/null @@ -1,11 +0,0 @@ -module; - -export module wrappers.sdl; - -// Export submodules -export import wrappers.sdl.error; -export import wrappers.sdl.events; -export import wrappers.sdl.init; -export import wrappers.sdl.rect; -export import wrappers.sdl.render; -export import wrappers.sdl.video; diff --git a/src/wrappers/sdl/error.cppm b/src/wrappers/sdl/error.cppm deleted file mode 100644 index ceaedf0..0000000 --- a/src/wrappers/sdl/error.cppm +++ /dev/null @@ -1,24 +0,0 @@ -module; - -#include -#include -#include - -export module wrappers.sdl.error; - -export namespace sdl -{ - // Exception that wraps an SDL error (which SDL function caused the error, what's the error). - // SDL_GetError() is used in the constructor to get the error message unless specified explicitly. - class SDLException final : public std::runtime_error - { - public: - explicit SDLException(const std::string& sdl_func, const std::string& sdl_error) - : runtime_error(std::format("Error in SDL function {}: {}", sdl_func, sdl_error)) - {} - - explicit SDLException(const std::string& sdl_func) - : SDLException(sdl_func, SDL_GetError()) - {} - }; -} diff --git a/src/wrappers/sdl/events.cppm b/src/wrappers/sdl/events.cppm deleted file mode 100644 index a168af0..0000000 --- a/src/wrappers/sdl/events.cppm +++ /dev/null @@ -1,11 +0,0 @@ -module; - -#include - -export module wrappers.sdl.events; - -export namespace sdl -{ - // Simple alias for SDL_Event union - using Event = SDL_Event; -} diff --git a/src/wrappers/sdl/init.cppm b/src/wrappers/sdl/init.cppm deleted file mode 100644 index 9044776..0000000 --- a/src/wrappers/sdl/init.cppm +++ /dev/null @@ -1,62 +0,0 @@ -module; - -#include -#include - -export module wrappers.sdl.init; - -import wrappers.sdl.error; - -export namespace sdl -{ - using InitFlags_t = SDL_InitFlags; - - /** - * Wrapper for the SDL_InitFlags enum/constants. - * - * We're using a namespace here to emulate an enum-like interface. If we used an actual enum, we would have to - * explicitly define bit-wise operations for it (as well as for every other kind of bit flag enum. - * (Maybe in the future this can be replaced with a more elegant template-based solution or something.) - */ - namespace InitFlags - { - constexpr InitFlags_t Audio = SDL_INIT_AUDIO; - constexpr InitFlags_t Video = SDL_INIT_VIDEO; - constexpr InitFlags_t Joystick = SDL_INIT_JOYSTICK; - constexpr InitFlags_t Haptic = SDL_INIT_HAPTIC; - constexpr InitFlags_t Gamepad = SDL_INIT_GAMEPAD; - constexpr InitFlags_t Events = SDL_INIT_EVENTS; - constexpr InitFlags_t Sensor = SDL_INIT_SENSOR; - constexpr InitFlags_t Camera = SDL_INIT_CAMERA; - } - - /** - * Wrapper around the SDL_AppResult enum. - */ - enum class AppResult : std::underlying_type_t - { - Continue = SDL_APP_CONTINUE, - Success = SDL_APP_SUCCESS, - Failure = SDL_APP_FAILURE, - }; - - /** - * Wrapper around SDL_Init(). - */ - constexpr void Init(const InitFlags_t flags) - { - if (!SDL_Init(flags)) { - throw SDLException("SDL_Init"); - } - } - - /** - * Wrapper around SDL_SetAppMetadataProperty(). - */ - constexpr void SetAppMetadataProperty(const char* property_name, const char* value) - { - if (!SDL_SetAppMetadataProperty(property_name, value)) { - throw SDLException("SDL_SetAppMetadataProperty"); - } - } -} diff --git a/src/wrappers/sdl/rect.cppm b/src/wrappers/sdl/rect.cppm deleted file mode 100644 index a42648a..0000000 --- a/src/wrappers/sdl/rect.cppm +++ /dev/null @@ -1,42 +0,0 @@ -module; - -#include - -export module wrappers.sdl.rect; - -export namespace sdl -{ - // Wrappers around SDL_Point and SDL_FPoint (change to wrapper classes when needed) - using FPoint = SDL_FPoint; - using Point = SDL_Point; - - /** - * Wrapper around SDL_FRect using class inheritance. - */ - class FRect : public SDL_FRect - { - /** - * Wrapper around SDL_RectEmptyFloat(). - * @return True if the floating point rectangle takes no space. - */ - constexpr bool is_empty() const - { - return SDL_RectEmptyFloat(this); - } - }; - - /** - * Wrapper around SDL_Rect using class inheritance. - */ - class Rect : public SDL_Rect - { - /** - * Wrapper around SDL_RectEmpty(). - * @return True if the rectangle takes no space. - */ - constexpr bool is_empty() const - { - return SDL_RectEmpty(this); - } - }; -} diff --git a/src/wrappers/sdl/render.cppm b/src/wrappers/sdl/render.cppm deleted file mode 100644 index e0b28c0..0000000 --- a/src/wrappers/sdl/render.cppm +++ /dev/null @@ -1,125 +0,0 @@ -module; - -#include -#include -#include - -export module wrappers.sdl.render; - -import utils.memory; -import wrappers.sdl.error; -import wrappers.sdl.rect; -import wrappers.sdl.video; - -export namespace sdl -{ - /** - * Wrapper around SDL_Texture that manages its lifecycle with a unique_ptr. - */ - class Texture - { - std::unique_ptr< - SDL_Texture, - utils::FuncDeleter - > raw_texture_; - - public: - Texture() = delete; - - explicit Texture(SDL_Texture* raw_texture) - : raw_texture_{raw_texture} - {} - - constexpr SDL_Texture* get_raw() const - { - assert(raw_texture_); - return raw_texture_.get(); - } - }; - - /** - * Wrapper around SDL_Renderer that manages its lifecycle with a unique_ptr. - */ - class Renderer - { - std::unique_ptr< - SDL_Renderer, - utils::FuncDeleter - > raw_renderer_; - - public: - Renderer() = delete; - - explicit Renderer(SDL_Renderer* raw_renderer) - : raw_renderer_{raw_renderer} - {} - - constexpr SDL_Renderer* get_raw() const - { - assert(raw_renderer_); - return raw_renderer_.get(); - } - - /** - * Wrapper around SDL_RenderClear(). - * Uses assert to verify the function returned true. - */ - constexpr void clear() const - { - // TODO: These functions probably should never fail? Change this to a runtime exception if necessary. - if (!SDL_RenderClear(get_raw())) { - assert(!"SDL_RenderClear returned false"); - } - } - - /** - * Wrapper around SDL_RenderPresent(). - * Uses assert to verify the function returned true. - */ - constexpr void present() const - { - if (!SDL_RenderPresent(get_raw())) { - assert(!"SDL_RenderPresent returned false"); - } - } - - /** - * Wrapper around SDL_RenderTexture(). - * Uses assert to verify the function returned true. - */ - constexpr void render_texture( - const Texture& texture, - const FRect* src_rect, - const FRect* dest_rect - ) const - { - if (!SDL_RenderTexture(get_raw(), texture.get_raw(), src_rect, dest_rect)) { - assert(!"SDL_RenderTexture returned false"); - } - } - }; - - /** - * Wrapper around SDL_CreateWindowAndRenderer(). - * Returns a pair of a Window and a Renderer object. - * Throws an SDLException on failure. - */ - std::pair CreateWindowAndRenderer( - const std::string& title, - const int width, - const int height, - const SDL_WindowFlags window_flags - ) - { - SDL_Window* raw_window = nullptr; - SDL_Renderer* raw_renderer = nullptr; - - if (!SDL_CreateWindowAndRenderer( - title.c_str(), width, height, window_flags, &raw_window, &raw_renderer - )) { - throw SDLException("SDL_CreateWindowAndRenderer"); - } - - return {Window{raw_window}, Renderer{raw_renderer}}; - } -} diff --git a/src/wrappers/sdl/video.cppm b/src/wrappers/sdl/video.cppm deleted file mode 100644 index f80c93f..0000000 --- a/src/wrappers/sdl/video.cppm +++ /dev/null @@ -1,36 +0,0 @@ -module; - -#include -#include -#include - -export module wrappers.sdl.video; - -import utils.memory; - -export namespace sdl -{ - /** - * Wrapper around SDL_Window that manages its lifecycle with a unique_ptr. - */ - class Window - { - std::unique_ptr< - SDL_Window, - utils::FuncDeleter - > raw_window_; - - public: - Window() = delete; - - explicit Window(SDL_Window* raw_window) - : raw_window_{raw_window} - {} - - constexpr SDL_Window* get_raw() const - { - assert(raw_window_); - return raw_window_.get(); - } - }; -} diff --git a/src/wrappers/sdl_image.cppm b/src/wrappers/sdl_image.cppm deleted file mode 100644 index a434564..0000000 --- a/src/wrappers/sdl_image.cppm +++ /dev/null @@ -1,28 +0,0 @@ -module; - -#include -#include -#include - -export module wrappers.sdl_image; - -import utils.memory; -import wrappers.sdl.error; -import wrappers.sdl.render; - -export namespace sdl_image -{ - /** - * Wrapper around IMG_LoadTexture(). - */ - sdl::Texture LoadTexture(const sdl::Renderer& renderer, const std::string& filename) - { - SDL_Texture* sdl_texture = IMG_LoadTexture(renderer.get_raw(), filename.c_str()); - - if (sdl_texture == nullptr) { - throw sdl::SDLException("IMG_LoadTexture"); - } - - return sdl::Texture{sdl_texture}; - } -}