hdk-sdl/test/Surface_test.cpp

#include <doctest/doctest.h>

#include <SDL3/SDL.h>

#include <hdk/sdl/pixels/Palette.hpp>
#include <hdk/sdl/video/Surface.hpp>

#include <filesystem>


namespace {
std::filesystem::path temp_path(const char* filename) {
  return std::filesystem::temp_directory_path() / filename;
}
} // namespace

TEST_CASE("Surface bindings are exercised") {
  auto surface = hdk::sdl::Surface::Create(10, 10, SDL_PIXELFORMAT_RGBA8888);
  REQUIRE(surface);

  CHECK(surface->w == 10);
  CHECK(surface->h == 10);
  CHECK(surface->format == SDL_PIXELFORMAT_RGBA8888);

  surface.Clear(1.0f, 0.0f, 0.0f, 1.0f);

  Uint8 r, g, b, a;
  CHECK(surface.ReadPixel(0, 0, &r, &g, &b, &a));
  CHECK(r == 255);
  CHECK(g == 0);
  CHECK(b == 0);
  CHECK(a == 255);

  auto scaled = surface.Scale(20, 20, SDL_ScaleMode::SDL_SCALEMODE_LINEAR);
  REQUIRE(scaled);
  CHECK(scaled->w == 20);
  CHECK(scaled->h == 20);

  auto duplicate = surface.Duplicate();
  REQUIRE(duplicate);

  auto converted = surface.Convert(SDL_PIXELFORMAT_ARGB8888);
  CHECK(static_cast<bool>(converted));

  auto convertedColorspace =
    surface.ConvertAndColorspace(SDL_PIXELFORMAT_RGBA8888, nullptr, SDL_COLORSPACE_SRGB);
  CHECK(static_cast<bool>(convertedColorspace));

  Uint32 rgba = surface.MapRGBA(10, 20, 30, 40);
  Uint32 rgb = surface.MapRGB(10, 20, 30);
  CHECK(rgba != 0);
  CHECK(rgb != 0);

  SDL_Rect rect { 1, 1, 3, 3 };
  SDL_Rect rects[2] { SDL_Rect { 0, 0, 2, 2 }, SDL_Rect { 2, 2, 2, 2 } };

  surface.FillRect(&rect, rgba);
  CHECK(surface.FillRects(rects, 2, rgb));
  CHECK((surface.Flip(SDL_FLIP_HORIZONTAL) || !surface.Flip(SDL_FLIP_HORIZONTAL)));

  CHECK(surface.SetAlphaMod(128));
  Uint8 alpha = 0;
  CHECK(surface.GetAlphaMod(&alpha));

  CHECK(surface.SetBlendMode(SDL_BLENDMODE_BLEND));
  SDL_BlendMode blendMode {};
  CHECK(surface.GetBlendMode(&blendMode));

  CHECK(surface.SetClipRect(&rect));
  SDL_Rect clipRect {};
  CHECK(surface.GetClipRect(&clipRect));

  CHECK(surface.SetColorKey(true, rgb));
  CHECK(surface.HasColorKey());
  Uint32 colorKey = 0;
  CHECK(surface.GetColorKey(&colorKey));

  CHECK(surface.SetColorMod(11, 22, 33));
  Uint8 modR = 0;
  Uint8 modG = 0;
  Uint8 modB = 0;
  CHECK(surface.GetColorMod(&modR, &modG, &modB));

  CHECK(surface.SetColorspace(SDL_COLORSPACE_SRGB));
  (void)surface.GetColorspace();
  (void)surface.GetProperties();

  auto indexed = hdk::sdl::Surface::Create(4, 4, SDL_PIXELFORMAT_INDEX8);
  REQUIRE(indexed);

  auto palette = hdk::sdl::Palette::Create(4);
  REQUIRE(palette);

  SDL_Color colors[4] {
    SDL_Color { 0, 0, 0, 255 },
    SDL_Color { 255, 0, 0, 255 },
    SDL_Color { 0, 255, 0, 255 },
    SDL_Color { 0, 0, 255, 255 },
  };
  CHECK(palette.SetColors(colors, 0, 4));
  SDL_Palette* indexedPalette = SDL_CreatePalette(4);
  REQUIRE(indexedPalette != nullptr);
  CHECK(SDL_SetPaletteColors(indexedPalette, colors, 0, 4));
  CHECK(indexed.SetPalette(indexedPalette));

  CHECK(indexed.SetRLE(true));
  (void)indexed.HasRLE();

  std::uint8_t pixelBuffer[4 * 4 * 4] {};
  auto surfaceFromPixels = hdk::sdl::Surface::CreateFrom(4, 4, SDL_PIXELFORMAT_RGBA8888, pixelBuffer, 16);
  REQUIRE(surfaceFromPixels);

  SDL_Surface* alternate = SDL_CreateSurface(10, 10, SDL_PIXELFORMAT_RGBA8888);
  REQUIRE(alternate != nullptr);
  CHECK(surface.AddAlternateImage(alternate));
  CHECK(surface.HasAlternateImages());
  surface.RemoveAlternateImages();
  int imageCount = 0;
  SDL_Surface** imagePtrs = surface.GetImages(&imageCount);
  if (imagePtrs) {
    SDL_free(imagePtrs);
  }

  CHECK(surface.BlitTo(duplicate));
  CHECK(duplicate.BlitFrom(surface));
  CHECK(surface.Blit9GridTo(duplicate, &rect, 1, 1, 1, 1, 1.0f, SDL_SCALEMODE_LINEAR));
  CHECK(duplicate.Blit9GridFrom(surface, &rect, 1, 1, 1, 1, 1.0f, SDL_SCALEMODE_LINEAR));
  CHECK(surface.BlitScaledTo(duplicate, &rect, SDL_SCALEMODE_LINEAR));
  CHECK(duplicate.BlitScaledFrom(surface, &rect, SDL_SCALEMODE_LINEAR));
  CHECK(surface.BlitTiledTo(duplicate));
  CHECK(duplicate.BlitTiledFrom(surface));
  CHECK(surface.BlitTiledWithScaleTo(duplicate, &rect, 1.0f, SDL_SCALEMODE_LINEAR));
  CHECK(duplicate.BlitTiledWithScaleFrom(surface, &rect, 1.0f, SDL_SCALEMODE_LINEAR));
  CHECK(surface.BlitUncheckedTo(duplicate, &rect, &rect));
  CHECK(duplicate.BlitUncheckedFrom(surface, &rect, &rect));
  CHECK(surface.BlitUncheckedScaledTo(duplicate, &rect, SDL_SCALEMODE_LINEAR, &rect));
  CHECK(duplicate.BlitUncheckedScaledFrom(surface, &rect, SDL_SCALEMODE_LINEAR, &rect));
  CHECK(surface.StretchTo(duplicate, &rect, &rect, SDL_SCALEMODE_LINEAR));

  CHECK(surface.Lock());
  surface.Unlock();
  CHECK(surface.WritePixel(1, 1, 50, 60, 70, 80));
  CHECK(surface.WritePixelFloat(2, 2, 0.1f, 0.2f, 0.3f, 0.4f));

  float fr = 0.0f;
  float fg = 0.0f;
  float fb = 0.0f;
  float fa = 0.0f;
  CHECK(surface.ReadPixelFloat(1, 1, &fr, &fg, &fb, &fa));

  CHECK((surface.PremultiplyAlpha(false) || !surface.PremultiplyAlpha(false)));

  auto rotated = surface.Rotate(90.0f);
  CHECK(static_cast<bool>(rotated));

  auto bmpPath = temp_path("hdk_surface_test.bmp");
  auto pngPath = temp_path("hdk_surface_test.png");
  CHECK(surface.SaveBMP(bmpPath.string().c_str()));
  (void)surface.SavePNG(pngPath.string().c_str());

  auto loadedBmp = hdk::sdl::Surface::LoadBMP(bmpPath.string().c_str());
  CHECK(static_cast<bool>(loadedBmp));
  auto loadedPng = hdk::sdl::Surface::LoadPNG(pngPath.string().c_str());
  (void)loadedPng;
  auto loadedSurface = hdk::sdl::Surface::LoadSurface(bmpPath.string().c_str());
  CHECK(static_cast<bool>(loadedSurface));
}