Current status of SDL.

test/Surface_test.cpp

@@ -1,10 +1,20 @@
 #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);
 
@@ -25,4 +35,133 @@ TEST_CASE("Surface bindings are exercised") {
   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));
 }