问用于小游戏的简单C++ SDL2包装器

EN

Surface(SDL_Surface* surface, bool freeOnDestruction);

void FillSurface(Surface& surface, Color const& color); // fill entire surface!
void FillSurface(Surface& surface, Rect const& rect, Color const& color); // fill a rect on the surface
void BlitSurface(Surface& source, Surface const& dest); // blit whole surfaces
// TODO: rect versions...

#include <iostream>
#include <functional>
#include <memory>
#include <cassert>

// placeholder for testing...
struct SDL_Surface
{
    SDL_Surface() { std::cout << "constructor" << std::endl; }
    ~SDL_Surface() { std::cout << "destructor" << std::endl; }
};

// placeholder for testing...
void SDL_FreeSurface(SDL_Surface* surface)
{
    delete surface;
}

class Surface
{
public:

    Surface(SDL_Surface* sdlSurface, bool freeOnDestruction);

    Surface(Surface&&) = default;
    Surface& operator=(Surface&&) = default;

    Surface(Surface const&) = delete;
    Surface& operator=(Surface const&) = delete;

    SDL_Surface* GetSDLSurface() const; // Blit / Fill etc. should use this to get the SDL_Surface.

private:

    using SDLSurfacePtrDeleterT = std::function<void(SDL_Surface*)>;
    using SDLSurfacePtrT = std::unique_ptr<SDL_Surface, SDLSurfacePtrDeleterT>;
    SDLSurfacePtrT m_sdlSurfacePtr;
};

Surface::Surface(SDL_Surface* sdlSurface, bool freeOnDestruction)
{
    assert(sdlSurface != nullptr); // no null surfaces!
    // (means we don't have to check the inner pointer every time we e.g. blit).

    auto deleter = freeOnDestruction ?
        SDLSurfacePtrDeleterT([] (SDL_Surface* surface) { SDL_FreeSurface(surface); }) :
        SDLSurfacePtrDeleterT([] (SDL_Surface*) { });

    m_sdlSurfacePtr = SDLSurfacePtrT(sdlSurface, deleter);
}

SDL_Surface* Surface::GetSDLSurface() const
{
    assert(m_sdlSurfacePtr != nullptr); // check this surface hasn't been moved from
    // (if the m_sdlSurfacePtr is valid, the inner surface should be valid (or at least non-null) due to the assert in the constructor).

    return m_sdlSurfacePtr.get();
}

int main()
{
    std::cout << "Construct + Destruct:" << std::endl;

    {
        auto sdlSurface = new SDL_Surface();
        auto surface = Surface(sdlSurface, true);
        // should get destructor call...
    }

    std::cout << "Construct + Leak:" << std::endl;

    {
        auto sdlSurface = new SDL_Surface();
        auto surface = Surface(sdlSurface, false);
        // will not get destructor call...
    }

    std::cout << "Construct + Move + Destruct:" << std::endl;

    {
        auto sdlSurface = new SDL_Surface();
        auto surface = Surface(sdlSurface, true);
        auto surface2 = std::move(surface);
        // should get destructor call...
    }
}

#pragma once

#include <iostream>
#include <SDL.h>
#include <string>
#include "Window.h"

        bool IsWindowSurface = false;
        std::string ImagePath = "";

        Surface(std::string path);

SDL2::Surface::Surface(std::string path) :
    ImagePath{ path },
    IsWindowSurface{ false } {}

bool SDL2::Surface::LoadBMP() {
    // Load image from path
    ScreenSurface = SDL_LoadBMP(ImagePath.c_str());

template<typename Result, typename Creator, typename... Arguments>
auto make_resource(Creator c, Arguments&&... args)
{
    auto r = c(std::forward<Arguments>(args)...);
    if (!r) { throw std::system_error(errno, std::generic_category()); }
    return Result(r);
}

template <typename T, std::decay_t<T> t>
struct constant_t {
    constexpr operator T() noexcept const { return t; }
}

using surface_ptr = std::unique_ptr<
    SDL_Surface, constant_t<decltype(SDL_FreeSurface), SDL_FreeSurface>>;

inline auto make_surface(const char* filename) {
  return make_resource<surface_ptr>(SDL_LoadBMP, filename);
}

inline auto make_surface(SDL_Window* ptr) {
  return make_resource<surface_ptr>(SDL_GetWindowSurface, ptr);
}

inline auto make_surface(
    std::uint32_t flags, int width, int height, int depth, 
    std::uint32 Rmask, std::uint32 Gmask, std::uint32_t Bmask, std::uint32_t Amask) {
  return make_resource<surface_ptr>(
      SDL_CreateRGBSurface, flags, width, height, depth, 
      Rmask, Gmask, Bmask, Amask);
}

void meow() {
    auto w = make_window("Purr", SDL_WINDOW_POS_UNDEFINED, SDL_WINDOW_POS_UNDEFINED, 
                              640, 480, 0));
    auto s = make_surface(w.get());
    SDL_FillRect(s.get(), NULL, SDL_MapRGB(s->format, 255, 0, 0));
    SDL_UpdateWindowSurface(w.get());
}

template <typename T, std::decay_t<T> t>
using constant_t = std::integral_t<T, t>;

using surface_ptr = std::unique_ptr<SDL_Surface, constant_t<decltype(SDL_FreeSurface)*, SDL_FreeSurface>>;

template <auto t>
using constant_t = std::integral_constant<std::decay_t<decltype(t)>, t>;

using surface_ptr = std::unique_ptr<SDL_Surface, constant_t<SDL_FreeSurface>>;