/** * Original code: automated SDL platform test written by Edgar Simo "bobbens" * Extended and extensively updated by aschiffler at ferzkopp dot net */ #include #include #include "testautomation_images.h" #include "testautomation_suites.h" /* ================= Test Case Implementation ================== */ #define TESTRENDER_WINDOW_W 320 #define TESTRENDER_WINDOW_H 240 #define TESTRENDER_SCREEN_W 80 #define TESTRENDER_SCREEN_H 60 #define RENDER_COMPARE_FORMAT SDL_PIXELFORMAT_ARGB8888 #define RENDER_COLOR_CLEAR 0xFF000000 #define RENDER_COLOR_GREEN 0xFF00FF00 #define ALLOWABLE_ERROR_OPAQUE 0 #define ALLOWABLE_ERROR_BLENDED 0 #define CHECK_FUNC(FUNC, PARAMS) \ { \ bool result = FUNC PARAMS; \ if (!result) { \ SDLTest_AssertCheck(result, "Validate result from %s, expected: true, got: false, %s", #FUNC, SDL_GetError()); \ } \ } /* Test window and renderer */ static SDL_Window *window = NULL; static SDL_Renderer *renderer = NULL; /* Prototypes for helper functions */ static int clearScreen(void); static void compare(SDL_Surface *reference, int allowable_error); static void compare2x(SDL_Surface *reference, int allowable_error); static SDL_Texture *loadTestFace(void); static bool isSupported(int code); static bool hasDrawColor(void); /** * Create software renderer for tests */ static void SDLCALL InitCreateRenderer(void **arg) { const char *renderer_name = NULL; renderer = NULL; window = SDL_CreateWindow("render_testCreateRenderer", TESTRENDER_WINDOW_W, TESTRENDER_WINDOW_H, 0); SDLTest_AssertPass("SDL_CreateWindow()"); SDLTest_AssertCheck(window != NULL, "Check SDL_CreateWindow result"); if (window == NULL) { return; } renderer = SDL_CreateRenderer(window, renderer_name); SDLTest_AssertPass("SDL_CreateRenderer()"); SDLTest_AssertCheck(renderer != NULL, "Check SDL_CreateRenderer result: %s", renderer != NULL ? "success" : SDL_GetError()); if (renderer == NULL) { SDL_DestroyWindow(window); return; } } /** * Destroy renderer for tests */ static void SDLCALL CleanupDestroyRenderer(void *arg) { if (renderer) { SDL_DestroyRenderer(renderer); renderer = NULL; SDLTest_AssertPass("SDL_DestroyRenderer()"); } if (window) { SDL_DestroyWindow(window); window = NULL; SDLTest_AssertPass("SDL_DestroyWindow"); } } /** * Tests call to SDL_GetNumRenderDrivers * * \sa SDL_GetNumRenderDrivers */ static int SDLCALL render_testGetNumRenderDrivers(void *arg) { int n; n = SDL_GetNumRenderDrivers(); SDLTest_AssertCheck(n >= 1, "Number of renderers >= 1, reported as %i", n); return TEST_COMPLETED; } /** * Tests the SDL primitives for rendering. * * \sa SDL_SetRenderDrawColor * \sa SDL_RenderFillRect * \sa SDL_RenderLine * */ static int SDLCALL render_testPrimitives(void *arg) { int ret; int x, y; SDL_FRect rect; SDL_Surface *referenceSurface = NULL; int checkFailCount1; int checkFailCount2; /* Clear surface. */ clearScreen(); /* Need drawcolor or just skip test. */ SDLTest_AssertCheck(hasDrawColor(), "hasDrawColor"); /* Draw a rectangle. */ rect.x = 40.0f; rect.y = 0.0f; rect.w = 40.0f; rect.h = 80.0f; CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 13, 73, 200, SDL_ALPHA_OPAQUE)) CHECK_FUNC(SDL_RenderFillRect, (renderer, &rect)) /* Draw a rectangle with negative width and height. */ rect.x = 10.0f + 60.0f; rect.y = 10.0f + 40.0f; rect.w = -60.0f; rect.h = -40.0f; CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 200, 0, 100, SDL_ALPHA_OPAQUE)) CHECK_FUNC(SDL_RenderFillRect, (renderer, &rect)) /* Draw a rectangle with zero width and height. */ rect.x = 10.0f; rect.y = 10.0f; rect.w = 0.0f; rect.h = 0.0f; CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 255, 0, 0, SDL_ALPHA_OPAQUE)) CHECK_FUNC(SDL_RenderFillRect, (renderer, &rect)) /* Draw some points like so: * X.X.X.X.. * .X.X.X.X. * X.X.X.X.. */ checkFailCount1 = 0; checkFailCount2 = 0; for (y = 0; y < 3; y++) { for (x = y % 2; x < TESTRENDER_SCREEN_W; x += 2) { ret = SDL_SetRenderDrawColor(renderer, (Uint8)(x * y), (Uint8)(x * y / 2), (Uint8)(x * y / 3), SDL_ALPHA_OPAQUE); if (!ret) { checkFailCount1++; } ret = SDL_RenderPoint(renderer, (float)x, (float)y); if (!ret) { checkFailCount2++; } } } SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetRenderDrawColor, expected: 0, got: %i", checkFailCount1); SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_RenderPoint, expected: 0, got: %i", checkFailCount2); /* Draw some lines. */ CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0, 255, 0, SDL_ALPHA_OPAQUE)) CHECK_FUNC(SDL_RenderLine, (renderer, 0.0f, 30.0f, TESTRENDER_SCREEN_W, 30.0f)) CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 55, 55, 5, SDL_ALPHA_OPAQUE)) CHECK_FUNC(SDL_RenderLine, (renderer, 40.0f, 30.0f, 40.0f, 60.0f)) CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 5, 105, 105, SDL_ALPHA_OPAQUE)) CHECK_FUNC(SDL_RenderLine, (renderer, 0.0f, 0.0f, 29.0f, 29.0f)) CHECK_FUNC(SDL_RenderLine, (renderer, 29.0f, 30.0f, 0.0f, 59.0f)) CHECK_FUNC(SDL_RenderLine, (renderer, 79.0f, 0.0f, 50.0f, 29.0f)) CHECK_FUNC(SDL_RenderLine, (renderer, 79.0f, 59.0f, 50.0f, 30.0f)) /* See if it's the same. */ referenceSurface = SDLTest_ImagePrimitives(); compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); /* Make current */ SDL_RenderPresent(renderer); /* Clean up. */ SDL_DestroySurface(referenceSurface); referenceSurface = NULL; return TEST_COMPLETED; } /** * Tests the SDL primitives for rendering within a viewport. * * \sa SDL_SetRenderDrawColor * \sa SDL_RenderFillRect * \sa SDL_RenderLine * */ static int SDLCALL render_testPrimitivesWithViewport(void *arg) { SDL_Rect viewport; SDL_Surface *surface; /* Clear surface. */ clearScreen(); viewport.x = 2; viewport.y = 2; viewport.w = 2; viewport.h = 2; CHECK_FUNC(SDL_SetRenderViewport, (renderer, &viewport)); CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 255, 255, 255, SDL_ALPHA_OPAQUE)) CHECK_FUNC(SDL_RenderLine, (renderer, 0.0f, 0.0f, 1.0f, 1.0f)); viewport.x = 3; viewport.y = 3; viewport.w = 1; viewport.h = 1; CHECK_FUNC(SDL_SetRenderViewport, (renderer, &viewport)); surface = SDL_RenderReadPixels(renderer, NULL); if (surface) { Uint8 r, g, b, a; CHECK_FUNC(SDL_ReadSurfacePixel, (surface, 0, 0, &r, &g, &b, &a)); SDLTest_AssertCheck(r == 0xFF && g == 0xFF && b == 0xFF && a == 0xFF, "Validate diagonal line drawing with viewport, expected 0xFFFFFFFF, got 0x%.2x%.2x%.2x%.2x", r, g, b, a); SDL_DestroySurface(surface); } else { SDLTest_AssertCheck(surface != NULL, "Validate result from SDL_RenderReadPixels, got NULL, %s", SDL_GetError()); } return TEST_COMPLETED; } /** * Tests some blitting routines. * * \sa SDL_RenderTexture * \sa SDL_DestroyTexture */ static int SDLCALL render_testBlit(void *arg) { int ret; SDL_FRect rect; SDL_Texture *tface; SDL_Surface *referenceSurface = NULL; int i, j, ni, nj; int checkFailCount1; /* Clear surface. */ clearScreen(); /* Need drawcolor or just skip test. */ SDLTest_AssertCheck(hasDrawColor(), "hasDrawColor)"); /* Create face surface. */ tface = loadTestFace(); SDLTest_AssertCheck(tface != NULL, "Verify loadTestFace() result"); if (tface == NULL) { return TEST_ABORTED; } /* Constant values. */ rect.w = (float)tface->w; rect.h = (float)tface->h; ni = TESTRENDER_SCREEN_W - tface->w; nj = TESTRENDER_SCREEN_H - tface->h; /* Loop blit. */ checkFailCount1 = 0; for (j = 0; j <= nj; j += 4) { for (i = 0; i <= ni; i += 4) { /* Blitting. */ rect.x = (float)i; rect.y = (float)j; ret = SDL_RenderTexture(renderer, tface, NULL, &rect); if (!ret) { checkFailCount1++; } } } SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_RenderTexture, expected: 0, got: %i", checkFailCount1); /* See if it's the same */ referenceSurface = SDLTest_ImageBlit(); compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); /* Make current */ SDL_RenderPresent(renderer); /* Clean up. */ SDL_DestroyTexture(tface); SDL_DestroySurface(referenceSurface); referenceSurface = NULL; return TEST_COMPLETED; } /** * Tests tiled blitting routines. */ static int SDLCALL render_testBlitTiled(void *arg) { int ret; SDL_FRect rect; SDL_Texture *tface; SDL_Surface *referenceSurface = NULL; SDL_Surface *referenceSurface2x = NULL; /* Create face surface. */ tface = loadTestFace(); SDLTest_AssertCheck(tface != NULL, "Verify loadTestFace() result"); if (tface == NULL) { return TEST_ABORTED; } SDL_SetTextureScaleMode(tface, SDL_SCALEMODE_NEAREST); /* So 2x scaling is pixel perfect */ /* Tiled blit - 1.0 scale */ { /* Clear surface. */ clearScreen(); /* Tiled blit. */ rect.x = 0.0f; rect.y = 0.0f; rect.w = (float)TESTRENDER_SCREEN_W; rect.h = (float)TESTRENDER_SCREEN_H; ret = SDL_RenderTextureTiled(renderer, tface, NULL, 1.0f, &rect); SDLTest_AssertCheck(ret == true, "Validate results from call to SDL_RenderTextureTiled, expected: true, got: %i", ret); /* See if it's the same */ referenceSurface = SDLTest_ImageBlitTiled(); compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); /* Make current */ SDL_RenderPresent(renderer); } /* Tiled blit - 2.0 scale */ { /* Clear surface. */ clearScreen(); /* Tiled blit. */ rect.x = 0.0f; rect.y = 0.0f; rect.w = (float)TESTRENDER_SCREEN_W * 2; rect.h = (float)TESTRENDER_SCREEN_H * 2; ret = SDL_RenderTextureTiled(renderer, tface, NULL, 2.0f, &rect); SDLTest_AssertCheck(ret == true, "Validate results from call to SDL_RenderTextureTiled, expected: true, got: %i", ret); /* See if it's the same */ referenceSurface2x = SDL_CreateSurface(referenceSurface->w * 2, referenceSurface->h * 2, referenceSurface->format); SDL_BlitSurfaceScaled(referenceSurface, NULL, referenceSurface2x, NULL, SDL_SCALEMODE_NEAREST); SDLTest_AssertCheck(ret == true, "Validate results from call to SDL_BlitSurfaceScaled, expected: 0, got: %i", ret); compare2x(referenceSurface2x, ALLOWABLE_ERROR_OPAQUE); /* Make current */ SDL_RenderPresent(renderer); } /* Clean up. */ SDL_DestroyTexture(tface); SDL_DestroySurface(referenceSurface); SDL_DestroySurface(referenceSurface2x); referenceSurface = NULL; return TEST_COMPLETED; } static const Uint8 COLOR_SEPARATION = 85; static void Fill9GridReferenceSurface(SDL_Surface *surface, int left_width, int right_width, int top_height, int bottom_height) { SDL_Rect rect; // Upper left rect.x = 0; rect.y = 0; rect.w = left_width; rect.h = top_height; SDL_FillSurfaceRect(surface, &rect, SDL_MapSurfaceRGB(surface, 1 * COLOR_SEPARATION, 1 * COLOR_SEPARATION, 0)); // Top rect.x = left_width; rect.y = 0; rect.w = surface->w - left_width - right_width; rect.h = top_height; SDL_FillSurfaceRect(surface, &rect, SDL_MapSurfaceRGB(surface, 2 * COLOR_SEPARATION, 1 * COLOR_SEPARATION, 0)); // Upper right rect.x = surface->w - right_width; rect.y = 0; rect.w = right_width; rect.h = top_height; SDL_FillSurfaceRect(surface, &rect, SDL_MapSurfaceRGB(surface, 3 * COLOR_SEPARATION, 1 * COLOR_SEPARATION, 0)); // Left rect.x = 0; rect.y = top_height; rect.w = left_width; rect.h = surface->h - top_height - bottom_height; SDL_FillSurfaceRect(surface, &rect, SDL_MapSurfaceRGB(surface, 1 * COLOR_SEPARATION, 2 * COLOR_SEPARATION, 0)); // Center rect.x = left_width; rect.y = top_height; rect.w = surface->w - right_width - left_width; rect.h = surface->h - top_height - bottom_height; SDL_FillSurfaceRect(surface, &rect, SDL_MapSurfaceRGB(surface, 2 * COLOR_SEPARATION, 2 * COLOR_SEPARATION, 0)); // Right rect.x = surface->w - right_width; rect.y = top_height; rect.w = right_width; rect.h = surface->h - top_height - bottom_height; SDL_FillSurfaceRect(surface, &rect, SDL_MapSurfaceRGB(surface, 3 * COLOR_SEPARATION, 2 * COLOR_SEPARATION, 0)); // Lower left rect.x = 0; rect.y = surface->h - bottom_height; rect.w = left_width; rect.h = bottom_height; SDL_FillSurfaceRect(surface, &rect, SDL_MapSurfaceRGB(surface, 1 * COLOR_SEPARATION, 3 * COLOR_SEPARATION, 0)); // Bottom rect.x = left_width; rect.y = surface->h - bottom_height; rect.w = surface->w - left_width - right_width; rect.h = bottom_height; SDL_FillSurfaceRect(surface, &rect, SDL_MapSurfaceRGB(surface, 2 * COLOR_SEPARATION, 3 * COLOR_SEPARATION, 0)); // Lower right rect.x = surface->w - right_width; rect.y = surface->h - bottom_height; rect.w = right_width; rect.h = bottom_height; SDL_FillSurfaceRect(surface, &rect, SDL_MapSurfaceRGB(surface, 3 * COLOR_SEPARATION, 3 * COLOR_SEPARATION, 0)); } /** * Tests 9-grid blitting. */ static int SDLCALL render_testBlit9Grid(void *arg) { SDL_Surface *referenceSurface = NULL; SDL_Surface *source = NULL; SDL_Texture *texture; int x, y; SDL_FRect rect; int ret = 0; /* Create source surface */ source = SDL_CreateSurface(3, 3, SDL_PIXELFORMAT_RGBA32); SDLTest_AssertCheck(source != NULL, "Verify source surface is not NULL"); for (y = 0; y < 3; ++y) { for (x = 0; x < 3; ++x) { SDL_WriteSurfacePixel(source, x, y, (Uint8)((1 + x) * COLOR_SEPARATION), (Uint8)((1 + y) * COLOR_SEPARATION), 0, 255); } } texture = SDL_CreateTextureFromSurface(renderer, source); SDLTest_AssertCheck(texture != NULL, "Verify source texture is not NULL"); ret = SDL_SetTextureScaleMode(texture, SDL_SCALEMODE_NEAREST); SDLTest_AssertCheck(ret == true, "Validate results from call to SDL_SetTextureScaleMode, expected: true, got: %i", ret); /* 9-grid blit - 1.0 scale */ { SDLTest_Log("9-grid blit - 1.0 scale"); /* Create reference surface */ SDL_DestroySurface(referenceSurface); referenceSurface = SDL_CreateSurface(TESTRENDER_SCREEN_W, TESTRENDER_SCREEN_H, SDL_PIXELFORMAT_RGBA32); SDLTest_AssertCheck(referenceSurface != NULL, "Verify reference surface is not NULL"); Fill9GridReferenceSurface(referenceSurface, 1, 1, 1, 1); /* Clear surface. */ clearScreen(); /* Tiled blit. */ rect.x = 0.0f; rect.y = 0.0f; rect.w = (float)TESTRENDER_SCREEN_W; rect.h = (float)TESTRENDER_SCREEN_H; ret = SDL_RenderTexture9Grid(renderer, texture, NULL, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, &rect); SDLTest_AssertCheck(ret == true, "Validate results from call to SDL_RenderTexture9Grid, expected: true, got: %i", ret); /* See if it's the same */ compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); /* Make current */ SDL_RenderPresent(renderer); } /* 9-grid blit - 2.0 scale */ { SDLTest_Log("9-grid blit - 2.0 scale"); /* Create reference surface */ SDL_DestroySurface(referenceSurface); referenceSurface = SDL_CreateSurface(TESTRENDER_SCREEN_W, TESTRENDER_SCREEN_H, SDL_PIXELFORMAT_RGBA32); SDLTest_AssertCheck(referenceSurface != NULL, "Verify reference surface is not NULL"); Fill9GridReferenceSurface(referenceSurface, 2, 2, 2, 2); /* Clear surface. */ clearScreen(); /* Tiled blit. */ rect.x = 0.0f; rect.y = 0.0f; rect.w = (float)TESTRENDER_SCREEN_W; rect.h = (float)TESTRENDER_SCREEN_H; ret = SDL_RenderTexture9Grid(renderer, texture, NULL, 1.0f, 1.0f, 1.0f, 1.0f, 2.0f, &rect); SDLTest_AssertCheck(ret == true, "Validate results from call to SDL_RenderTexture9Grid, expected: true, got: %i", ret); /* See if it's the same */ compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); /* Make current */ SDL_RenderPresent(renderer); } /* Clean up. */ SDL_DestroySurface(source); SDL_DestroyTexture(texture); /* Create complex source surface */ source = SDL_CreateSurface(5, 5, SDL_PIXELFORMAT_RGBA32); SDLTest_AssertCheck(source != NULL, "Verify source surface is not NULL"); SDL_WriteSurfacePixel(source, 0, 0, (Uint8)((1) * COLOR_SEPARATION), (Uint8)((1) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 1, 0, (Uint8)((2) * COLOR_SEPARATION), (Uint8)((1) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 2, 0, (Uint8)((2) * COLOR_SEPARATION), (Uint8)((1) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 3, 0, (Uint8)((3) * COLOR_SEPARATION), (Uint8)((1) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 4, 0, (Uint8)((3) * COLOR_SEPARATION), (Uint8)((1) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 0, 1, (Uint8)((1) * COLOR_SEPARATION), (Uint8)((2) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 1, 1, (Uint8)((2) * COLOR_SEPARATION), (Uint8)((2) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 2, 1, (Uint8)((2) * COLOR_SEPARATION), (Uint8)((2) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 3, 1, (Uint8)((3) * COLOR_SEPARATION), (Uint8)((2) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 4, 1, (Uint8)((3) * COLOR_SEPARATION), (Uint8)((2) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 0, 2, (Uint8)((1) * COLOR_SEPARATION), (Uint8)((2) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 1, 2, (Uint8)((2) * COLOR_SEPARATION), (Uint8)((2) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 2, 2, (Uint8)((2) * COLOR_SEPARATION), (Uint8)((2) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 3, 2, (Uint8)((3) * COLOR_SEPARATION), (Uint8)((2) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 4, 2, (Uint8)((3) * COLOR_SEPARATION), (Uint8)((2) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 0, 3, (Uint8)((1) * COLOR_SEPARATION), (Uint8)((3) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 1, 3, (Uint8)((2) * COLOR_SEPARATION), (Uint8)((3) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 2, 3, (Uint8)((2) * COLOR_SEPARATION), (Uint8)((3) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 3, 3, (Uint8)((3) * COLOR_SEPARATION), (Uint8)((3) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 4, 3, (Uint8)((3) * COLOR_SEPARATION), (Uint8)((3) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 0, 4, (Uint8)((1) * COLOR_SEPARATION), (Uint8)((3) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 1, 4, (Uint8)((2) * COLOR_SEPARATION), (Uint8)((3) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 2, 4, (Uint8)((2) * COLOR_SEPARATION), (Uint8)((3) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 3, 4, (Uint8)((3) * COLOR_SEPARATION), (Uint8)((3) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 4, 4, (Uint8)((3) * COLOR_SEPARATION), (Uint8)((3) * COLOR_SEPARATION), 0, 255); texture = SDL_CreateTextureFromSurface(renderer, source); SDLTest_AssertCheck(texture != NULL, "Verify source texture is not NULL"); ret = SDL_SetTextureScaleMode(texture, SDL_SCALEMODE_NEAREST); SDLTest_AssertCheck(ret == true, "Validate results from call to SDL_SetTextureScaleMode, expected: true, got: %i", ret); /* complex 9-grid blit - 1.0 scale */ { SDLTest_Log("complex 9-grid blit - 1.0 scale"); /* Create reference surface */ SDL_DestroySurface(referenceSurface); referenceSurface = SDL_CreateSurface(TESTRENDER_SCREEN_W, TESTRENDER_SCREEN_H, SDL_PIXELFORMAT_RGBA32); SDLTest_AssertCheck(referenceSurface != NULL, "Verify reference surface is not NULL"); Fill9GridReferenceSurface(referenceSurface, 1, 2, 1, 2); /* Clear surface. */ clearScreen(); /* Tiled blit. */ rect.x = 0.0f; rect.y = 0.0f; rect.w = (float)TESTRENDER_SCREEN_W; rect.h = (float)TESTRENDER_SCREEN_H; ret = SDL_RenderTexture9Grid(renderer, texture, NULL, 1.0f, 2.0f, 1.0f, 2.0f, 1.0f, &rect); SDLTest_AssertCheck(ret == true, "Validate results from call to SDL_RenderTexture9Grid, expected: true, got: %i", ret); /* See if it's the same */ compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); /* Make current */ SDL_RenderPresent(renderer); } /* complex 9-grid blit - 2.0 scale */ { SDLTest_Log("complex 9-grid blit - 2.0 scale"); /* Create reference surface */ SDL_DestroySurface(referenceSurface); referenceSurface = SDL_CreateSurface(TESTRENDER_SCREEN_W, TESTRENDER_SCREEN_H, SDL_PIXELFORMAT_RGBA32); SDLTest_AssertCheck(referenceSurface != NULL, "Verify reference surface is not NULL"); Fill9GridReferenceSurface(referenceSurface, 2, 4, 2, 4); /* Clear surface. */ clearScreen(); /* Tiled blit. */ rect.x = 0.0f; rect.y = 0.0f; rect.w = (float)TESTRENDER_SCREEN_W; rect.h = (float)TESTRENDER_SCREEN_H; ret = SDL_RenderTexture9Grid(renderer, texture, NULL, 1.0f, 2.0f, 1.0f, 2.0f, 2.0f, &rect); SDLTest_AssertCheck(ret == true, "Validate results from call to SDL_RenderTexture9Grid, expected: true, got: %i", ret); /* See if it's the same */ compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); /* Make current */ SDL_RenderPresent(renderer); } /* Clean up. */ SDL_DestroySurface(referenceSurface); SDL_DestroySurface(source); SDL_DestroyTexture(texture); return TEST_COMPLETED; } /** * Tests tiled 9-grid blitting. */ static int SDLCALL render_testBlit9GridTiled(void *arg) { SDL_Surface *referenceSurface = NULL; SDL_Surface *source = NULL; SDL_Texture *texture; int x, y; SDL_FRect rect; int ret = 0; /* Create source surface */ source = SDL_CreateSurface(3, 3, SDL_PIXELFORMAT_RGBA32); SDLTest_AssertCheck(source != NULL, "Verify source surface is not NULL"); for (y = 0; y < 3; ++y) { for (x = 0; x < 3; ++x) { SDL_WriteSurfacePixel(source, x, y, (Uint8)((1 + x) * COLOR_SEPARATION), (Uint8)((1 + y) * COLOR_SEPARATION), 0, 255); } } texture = SDL_CreateTextureFromSurface(renderer, source); SDLTest_AssertCheck(texture != NULL, "Verify source texture is not NULL"); ret = SDL_SetTextureScaleMode(texture, SDL_SCALEMODE_NEAREST); SDLTest_AssertCheck(ret == true, "Validate results from call to SDL_SetTextureScaleMode, expected: true, got: %i", ret); /* Tiled 9-grid blit - 1.0 scale */ { SDLTest_Log("tiled 9-grid blit - 1.0 scale"); /* Create reference surface */ SDL_DestroySurface(referenceSurface); referenceSurface = SDL_CreateSurface(TESTRENDER_SCREEN_W, TESTRENDER_SCREEN_H, SDL_PIXELFORMAT_RGBA32); SDLTest_AssertCheck(referenceSurface != NULL, "Verify reference surface is not NULL"); Fill9GridReferenceSurface(referenceSurface, 1, 1, 1, 1); /* Clear surface. */ clearScreen(); /* Tiled blit. */ rect.x = 0.0f; rect.y = 0.0f; rect.w = (float)TESTRENDER_SCREEN_W; rect.h = (float)TESTRENDER_SCREEN_H; ret = SDL_RenderTexture9GridTiled(renderer, texture, NULL, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, &rect, 1.0f); SDLTest_AssertCheck(ret == true, "Validate results from call to SDL_RenderTexture9GridTiled, expected: true, got: %i", ret); /* See if it's the same */ compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); /* Make current */ SDL_RenderPresent(renderer); } /* Tiled 9-grid blit - 2.0 scale */ { SDLTest_Log("tiled 9-grid blit - 2.0 scale"); /* Create reference surface */ SDL_DestroySurface(referenceSurface); referenceSurface = SDL_CreateSurface(TESTRENDER_SCREEN_W, TESTRENDER_SCREEN_H, SDL_PIXELFORMAT_RGBA32); SDLTest_AssertCheck(referenceSurface != NULL, "Verify reference surface is not NULL"); Fill9GridReferenceSurface(referenceSurface, 2, 2, 2, 2); /* Clear surface. */ clearScreen(); /* Tiled blit. */ rect.x = 0.0f; rect.y = 0.0f; rect.w = (float)TESTRENDER_SCREEN_W; rect.h = (float)TESTRENDER_SCREEN_H; ret = SDL_RenderTexture9GridTiled(renderer, texture, NULL, 1.0f, 1.0f, 1.0f, 1.0f, 2.0f, &rect, 2.0f); SDLTest_AssertCheck(ret == true, "Validate results from call to SDL_RenderTexture9GridTiled, expected: true, got: %i", ret); /* See if it's the same */ compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); /* Make current */ SDL_RenderPresent(renderer); } /* Clean up. */ SDL_DestroySurface(source); SDL_DestroyTexture(texture); /* Create complex source surface */ source = SDL_CreateSurface(5, 5, SDL_PIXELFORMAT_RGBA32); SDLTest_AssertCheck(source != NULL, "Verify source surface is not NULL"); SDL_WriteSurfacePixel(source, 0, 0, (Uint8)((1) * COLOR_SEPARATION), (Uint8)((1) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 1, 0, (Uint8)((2) * COLOR_SEPARATION), (Uint8)((1) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 2, 0, (Uint8)((2) * COLOR_SEPARATION), (Uint8)((1) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 3, 0, (Uint8)((3) * COLOR_SEPARATION), (Uint8)((1) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 4, 0, (Uint8)((3) * COLOR_SEPARATION), (Uint8)((1) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 0, 1, (Uint8)((1) * COLOR_SEPARATION), (Uint8)((2) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 1, 1, (Uint8)((2) * COLOR_SEPARATION), (Uint8)((2) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 2, 1, (Uint8)((2) * COLOR_SEPARATION), (Uint8)((2) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 3, 1, (Uint8)((3) * COLOR_SEPARATION), (Uint8)((2) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 4, 1, (Uint8)((3) * COLOR_SEPARATION), (Uint8)((2) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 0, 2, (Uint8)((1) * COLOR_SEPARATION), (Uint8)((2) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 1, 2, (Uint8)((2) * COLOR_SEPARATION), (Uint8)((2) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 2, 2, (Uint8)((2) * COLOR_SEPARATION), (Uint8)((2) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 3, 2, (Uint8)((3) * COLOR_SEPARATION), (Uint8)((2) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 4, 2, (Uint8)((3) * COLOR_SEPARATION), (Uint8)((2) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 0, 3, (Uint8)((1) * COLOR_SEPARATION), (Uint8)((3) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 1, 3, (Uint8)((2) * COLOR_SEPARATION), (Uint8)((3) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 2, 3, (Uint8)((2) * COLOR_SEPARATION), (Uint8)((3) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 3, 3, (Uint8)((3) * COLOR_SEPARATION), (Uint8)((3) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 4, 3, (Uint8)((3) * COLOR_SEPARATION), (Uint8)((3) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 0, 4, (Uint8)((1) * COLOR_SEPARATION), (Uint8)((3) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 1, 4, (Uint8)((2) * COLOR_SEPARATION), (Uint8)((3) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 2, 4, (Uint8)((2) * COLOR_SEPARATION), (Uint8)((3) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 3, 4, (Uint8)((3) * COLOR_SEPARATION), (Uint8)((3) * COLOR_SEPARATION), 0, 255); SDL_WriteSurfacePixel(source, 4, 4, (Uint8)((3) * COLOR_SEPARATION), (Uint8)((3) * COLOR_SEPARATION), 0, 255); texture = SDL_CreateTextureFromSurface(renderer, source); SDLTest_AssertCheck(texture != NULL, "Verify source texture is not NULL"); ret = SDL_SetTextureScaleMode(texture, SDL_SCALEMODE_NEAREST); SDLTest_AssertCheck(ret == true, "Validate results from call to SDL_SetTextureScaleMode, expected: true, got: %i", ret); /* complex tiled 9-grid blit - 1.0 scale */ { SDLTest_Log("complex tiled 9-grid blit - 1.0 scale"); /* Create reference surface */ SDL_DestroySurface(referenceSurface); referenceSurface = SDL_CreateSurface(TESTRENDER_SCREEN_W, TESTRENDER_SCREEN_H, SDL_PIXELFORMAT_RGBA32); SDLTest_AssertCheck(referenceSurface != NULL, "Verify reference surface is not NULL"); Fill9GridReferenceSurface(referenceSurface, 1, 2, 1, 2); /* Clear surface. */ clearScreen(); /* Tiled blit. */ rect.x = 0.0f; rect.y = 0.0f; rect.w = (float)TESTRENDER_SCREEN_W; rect.h = (float)TESTRENDER_SCREEN_H; ret = SDL_RenderTexture9GridTiled(renderer, texture, NULL, 1.0f, 2.0f, 1.0f, 2.0f, 1.0f, &rect, 1.0f); SDLTest_AssertCheck(ret == true, "Validate results from call to SDL_RenderTexture9GridTiled, expected: true, got: %i", ret); /* See if it's the same */ compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); /* Make current */ SDL_RenderPresent(renderer); } /* complex tiled 9-grid blit - 2.0 scale */ { SDLTest_Log("complex tiled 9-grid blit - 2.0 scale"); /* Create reference surface */ SDL_DestroySurface(referenceSurface); referenceSurface = SDL_CreateSurface(TESTRENDER_SCREEN_W, TESTRENDER_SCREEN_H, SDL_PIXELFORMAT_RGBA32); SDLTest_AssertCheck(referenceSurface != NULL, "Verify reference surface is not NULL"); Fill9GridReferenceSurface(referenceSurface, 2, 4, 2, 4); /* Clear surface. */ clearScreen(); /* Tiled blit. */ rect.x = 0.0f; rect.y = 0.0f; rect.w = (float)TESTRENDER_SCREEN_W; rect.h = (float)TESTRENDER_SCREEN_H; ret = SDL_RenderTexture9GridTiled(renderer, texture, NULL, 1.0f, 2.0f, 1.0f, 2.0f, 2.0f, &rect, 2.0f); SDLTest_AssertCheck(ret == true, "Validate results from call to SDL_RenderTexture9GridTiled, expected: true, got: %i", ret); /* See if it's the same */ compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); /* Make current */ SDL_RenderPresent(renderer); } /* Clean up. */ SDL_DestroySurface(referenceSurface); SDL_DestroySurface(source); SDL_DestroyTexture(texture); return TEST_COMPLETED; } /** * Blits doing color tests. * * \sa SDL_SetTextureColorMod * \sa SDL_RenderTexture * \sa SDL_DestroyTexture */ static int SDLCALL render_testBlitColor(void *arg) { int ret; SDL_FRect rect; SDL_Texture *tface; SDL_Surface *referenceSurface = NULL; int i, j, ni, nj; int checkFailCount1; int checkFailCount2; /* Clear surface. */ clearScreen(); /* Create face surface. */ tface = loadTestFace(); SDLTest_AssertCheck(tface != NULL, "Verify loadTestFace() result"); if (tface == NULL) { return TEST_ABORTED; } /* Constant values. */ rect.w = (float)tface->w; rect.h = (float)tface->h; ni = TESTRENDER_SCREEN_W - tface->w; nj = TESTRENDER_SCREEN_H - tface->h; /* Test blitting with color mod. */ checkFailCount1 = 0; checkFailCount2 = 0; for (j = 0; j <= nj; j += 4) { for (i = 0; i <= ni; i += 4) { /* Set color mod. */ ret = SDL_SetTextureColorMod(tface, (Uint8)((255 / nj) * j), (Uint8)((255 / ni) * i), (Uint8)((255 / nj) * j)); if (!ret) { checkFailCount1++; } /* Blitting. */ rect.x = (float)i; rect.y = (float)j; ret = SDL_RenderTexture(renderer, tface, NULL, &rect); if (!ret) { checkFailCount2++; } } } SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetTextureColorMod, expected: 0, got: %i", checkFailCount1); SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_RenderTexture, expected: 0, got: %i", checkFailCount2); /* See if it's the same. */ referenceSurface = SDLTest_ImageBlitColor(); compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); /* Make current */ SDL_RenderPresent(renderer); /* Clean up. */ SDL_DestroyTexture(tface); SDL_DestroySurface(referenceSurface); referenceSurface = NULL; return TEST_COMPLETED; } typedef enum TestRenderOperation { TEST_RENDER_POINT, TEST_RENDER_LINE, TEST_RENDER_RECT, TEST_RENDER_COPY_XRGB, TEST_RENDER_COPY_ARGB, } TestRenderOperation; /** * Helper that tests a specific operation and blend mode, -1 for color mod, -2 for alpha mod */ static void testBlendModeOperation(TestRenderOperation op, int mode, SDL_PixelFormat dst_format) { /* Allow up to 2 delta from theoretical value to account for rounding error. * We allow 2 rounding errors because the software renderer breaks drawing operations into alpha multiplication and a separate blend operation. */ const int MAXIMUM_ERROR = 2; int ret; SDL_Texture *src = NULL; SDL_Texture *dst; SDL_Surface *result; Uint8 srcR = 10, srcG = 128, srcB = 240, srcA = 100; Uint8 dstR = 128, dstG = 128, dstB = 128, dstA = 128; Uint8 expectedR, expectedG, expectedB, expectedA; Uint8 actualR, actualG, actualB, actualA; int deltaR, deltaG, deltaB, deltaA; const char *operation = "UNKNOWN"; const char *mode_name = "UNKNOWN"; /* Create dst surface */ dst = SDL_CreateTexture(renderer, dst_format, SDL_TEXTUREACCESS_TARGET, 3, 3); SDLTest_AssertCheck(dst != NULL, "Verify dst surface is not NULL"); if (dst == NULL) { return; } if (SDL_ISPIXELFORMAT_ALPHA(dst_format)) { SDL_BlendMode blendMode = SDL_BLENDMODE_NONE; ret = SDL_GetTextureBlendMode(dst, &blendMode); SDLTest_AssertCheck(ret == true, "Verify result from SDL_GetTextureBlendMode(), expected: true, got: %i", ret); SDLTest_AssertCheck(blendMode == SDL_BLENDMODE_BLEND, "Verify alpha texture blend mode, expected %d, got %" SDL_PRIu32, SDL_BLENDMODE_BLEND, blendMode); } /* Set as render target */ SDL_SetRenderTarget(renderer, dst); /* Clear surface. */ if (!SDL_ISPIXELFORMAT_ALPHA(dst_format)) { dstA = 255; } ret = SDL_SetRenderDrawColor(renderer, dstR, dstG, dstB, dstA); SDLTest_AssertCheck(ret == true, "Verify result from SDL_SetRenderDrawColor(), expected: true, got: %i", ret); ret = SDL_RenderClear(renderer); SDLTest_AssertPass("Call to SDL_RenderClear()"); SDLTest_AssertCheck(ret == true, "Verify result from SDL_RenderClear, expected: true, got: %i", ret); if (op == TEST_RENDER_COPY_XRGB || op == TEST_RENDER_COPY_ARGB) { Uint8 pixels[4]; /* Create src surface */ src = SDL_CreateTexture(renderer, op == TEST_RENDER_COPY_XRGB ? SDL_PIXELFORMAT_RGBX32 : SDL_PIXELFORMAT_RGBA32, SDL_TEXTUREACCESS_STATIC, 1, 1); SDLTest_AssertCheck(src != NULL, "Verify src surface is not NULL"); if (src == NULL) { return; } /* Clear surface. */ if (op == TEST_RENDER_COPY_XRGB) { srcA = 255; } pixels[0] = srcR; pixels[1] = srcG; pixels[2] = srcB; pixels[3] = srcA; SDL_UpdateTexture(src, NULL, pixels, sizeof(pixels)); /* Set blend mode. */ if (mode >= 0) { ret = SDL_SetTextureBlendMode(src, (SDL_BlendMode)mode); SDLTest_AssertPass("Call to SDL_SetTextureBlendMode()"); SDLTest_AssertCheck(ret == true, "Verify result from SDL_SetTextureBlendMode(..., %i), expected: true, got: %i", mode, ret); } else { ret = SDL_SetTextureBlendMode(src, SDL_BLENDMODE_BLEND); SDLTest_AssertPass("Call to SDL_SetTextureBlendMode()"); SDLTest_AssertCheck(ret == true, "Verify result from SDL_SetTextureBlendMode(..., %i), expected: true, got: %i", mode, ret); } } else { /* Set draw color */ ret = SDL_SetRenderDrawColor(renderer, srcR, srcG, srcB, srcA); SDLTest_AssertCheck(ret == true, "Verify result from SDL_SetRenderDrawColor(), expected: true, got: %i", ret); /* Set blend mode. */ if (mode >= 0) { ret = SDL_SetRenderDrawBlendMode(renderer, (SDL_BlendMode)mode); SDLTest_AssertPass("Call to SDL_SetRenderDrawBlendMode()"); SDLTest_AssertCheck(ret == true, "Verify result from SDL_SetRenderDrawBlendMode(..., %i), expected: true, got: %i", mode, ret); } else { ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND); SDLTest_AssertPass("Call to SDL_SetRenderDrawBlendMode()"); SDLTest_AssertCheck(ret == true, "Verify result from SDL_SetRenderDrawBlendMode(..., %i), expected: true, got: %i", mode, ret); } } /* Test blend mode. */ #define FLOAT(X) ((float)X / 255.0f) switch (mode) { case -1: mode_name = "color modulation"; ret = SDL_SetTextureColorMod(src, srcR, srcG, srcB); SDLTest_AssertCheck(ret == true, "Validate results from calls to SDL_SetTextureColorMod, expected: true, got: %i", ret); expectedR = (Uint8)SDL_roundf(SDL_clamp((FLOAT(srcR) * FLOAT(srcR)) * FLOAT(srcA) + FLOAT(dstR) * (1.0f - FLOAT(srcA)), 0.0f, 1.0f) * 255.0f); expectedG = (Uint8)SDL_roundf(SDL_clamp((FLOAT(srcG) * FLOAT(srcG)) * FLOAT(srcA) + FLOAT(dstG) * (1.0f - FLOAT(srcA)), 0.0f, 1.0f) * 255.0f); expectedB = (Uint8)SDL_roundf(SDL_clamp((FLOAT(srcB) * FLOAT(srcB)) * FLOAT(srcA) + FLOAT(dstB) * (1.0f - FLOAT(srcA)), 0.0f, 1.0f) * 255.0f); expectedA = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcA) + FLOAT(dstA) * (1.0f - FLOAT(srcA)), 0.0f, 1.0f) * 255.0f); break; case -2: mode_name = "alpha modulation"; ret = SDL_SetTextureAlphaMod(src, srcA); SDLTest_AssertCheck(ret == true, "Validate results from calls to SDL_SetTextureAlphaMod, expected: true, got: %i", ret); expectedR = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcR) * (FLOAT(srcA) * FLOAT(srcA)) + FLOAT(dstR) * (1.0f - (FLOAT(srcA) * FLOAT(srcA))), 0.0f, 1.0f) * 255.0f); expectedG = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcG) * (FLOAT(srcA) * FLOAT(srcA)) + FLOAT(dstG) * (1.0f - (FLOAT(srcA) * FLOAT(srcA))), 0.0f, 1.0f) * 255.0f); expectedB = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcB) * (FLOAT(srcA) * FLOAT(srcA)) + FLOAT(dstB) * (1.0f - (FLOAT(srcA) * FLOAT(srcA))), 0.0f, 1.0f) * 255.0f); expectedA = (Uint8)SDL_roundf(SDL_clamp((FLOAT(srcA) * FLOAT(srcA)) + FLOAT(dstA) * (1.0f - (FLOAT(srcA) * FLOAT(srcA))), 0.0f, 1.0f) * 255.0f); break; case SDL_BLENDMODE_NONE: mode_name = "SDL_BLENDMODE_NONE"; expectedR = srcR; expectedG = srcG; expectedB = srcB; expectedA = SDL_ISPIXELFORMAT_ALPHA(dst_format) ? srcA : 255; break; case SDL_BLENDMODE_BLEND: mode_name = "SDL_BLENDMODE_BLEND"; expectedR = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcR) * FLOAT(srcA) + FLOAT(dstR) * (1.0f - FLOAT(srcA)), 0.0f, 1.0f) * 255.0f); expectedG = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcG) * FLOAT(srcA) + FLOAT(dstG) * (1.0f - FLOAT(srcA)), 0.0f, 1.0f) * 255.0f); expectedB = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcB) * FLOAT(srcA) + FLOAT(dstB) * (1.0f - FLOAT(srcA)), 0.0f, 1.0f) * 255.0f); expectedA = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcA) + FLOAT(dstA) * (1.0f - FLOAT(srcA)), 0.0f, 1.0f) * 255.0f); break; case SDL_BLENDMODE_BLEND_PREMULTIPLIED: mode_name = "SDL_BLENDMODE_BLEND_PREMULTIPLIED"; expectedR = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcR) + FLOAT(dstR) * (1.0f - FLOAT(srcA)), 0.0f, 1.0f) * 255.0f); expectedG = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcG) + FLOAT(dstG) * (1.0f - FLOAT(srcA)), 0.0f, 1.0f) * 255.0f); expectedB = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcB) + FLOAT(dstB) * (1.0f - FLOAT(srcA)), 0.0f, 1.0f) * 255.0f); expectedA = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcA) + FLOAT(dstA) * (1.0f - FLOAT(srcA)), 0.0f, 1.0f) * 255.0f); break; case SDL_BLENDMODE_ADD: mode_name = "SDL_BLENDMODE_ADD"; expectedR = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcR) * FLOAT(srcA) + FLOAT(dstR), 0.0f, 1.0f) * 255.0f); expectedG = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcG) * FLOAT(srcA) + FLOAT(dstG), 0.0f, 1.0f) * 255.0f); expectedB = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcB) * FLOAT(srcA) + FLOAT(dstB), 0.0f, 1.0f) * 255.0f); expectedA = dstA; break; case SDL_BLENDMODE_ADD_PREMULTIPLIED: mode_name = "SDL_BLENDMODE_ADD_PREMULTIPLIED"; expectedR = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcR) + FLOAT(dstR), 0.0f, 1.0f) * 255.0f); expectedG = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcG) + FLOAT(dstG), 0.0f, 1.0f) * 255.0f); expectedB = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcB) + FLOAT(dstB), 0.0f, 1.0f) * 255.0f); expectedA = dstA; break; case SDL_BLENDMODE_MOD: mode_name = "SDL_BLENDMODE_MOD"; expectedR = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcR) * FLOAT(dstR), 0.0f, 1.0f) * 255.0f); expectedG = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcG) * FLOAT(dstG), 0.0f, 1.0f) * 255.0f); expectedB = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcB) * FLOAT(dstB), 0.0f, 1.0f) * 255.0f); expectedA = dstA; break; case SDL_BLENDMODE_MUL: mode_name = "SDL_BLENDMODE_MUL"; expectedR = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcR) * FLOAT(dstR) + FLOAT(dstR) * (1.0f - FLOAT(srcA)), 0.0f, 1.0f) * 255.0f); expectedG = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcG) * FLOAT(dstG) + FLOAT(dstG) * (1.0f - FLOAT(srcA)), 0.0f, 1.0f) * 255.0f); expectedB = (Uint8)SDL_roundf(SDL_clamp(FLOAT(srcB) * FLOAT(dstB) + FLOAT(dstB) * (1.0f - FLOAT(srcA)), 0.0f, 1.0f) * 255.0f); expectedA = dstA; break; default: SDLTest_LogError("Invalid blending mode: %d", mode); return; } switch (op) { case TEST_RENDER_POINT: operation = "render point"; ret = SDL_RenderPoint(renderer, 0.0f, 0.0f); SDLTest_AssertCheck(ret == true, "Validate results from calls to SDL_RenderPoint, expected: 0, got: %i", ret); break; case TEST_RENDER_LINE: operation = "render line"; ret = SDL_RenderLine(renderer, 0.0f, 0.0f, 2.0f, 2.0f); SDLTest_AssertCheck(ret == true, "Validate results from calls to SDL_RenderLine, expected: true, got: %i", ret); break; case TEST_RENDER_RECT: operation = "render rect"; ret = SDL_RenderFillRect(renderer, NULL); SDLTest_AssertCheck(ret == true, "Validate results from calls to SDL_RenderFillRect, expected: 0, got: %i", ret); break; case TEST_RENDER_COPY_XRGB: case TEST_RENDER_COPY_ARGB: operation = (op == TEST_RENDER_COPY_XRGB) ? "render XRGB" : "render ARGB"; ret = SDL_RenderTexture(renderer, src, NULL, NULL); SDLTest_AssertCheck(ret == true, "Validate results from calls to SDL_RenderTexture, expected: true, got: %i", ret); break; default: SDLTest_LogError("Invalid blending operation: %d", op); return; } result = SDL_RenderReadPixels(renderer, NULL); SDL_ReadSurfacePixel(result, 0, 0, &actualR, &actualG, &actualB, &actualA); deltaR = SDL_abs((int)actualR - expectedR); deltaG = SDL_abs((int)actualG - expectedG); deltaB = SDL_abs((int)actualB - expectedB); deltaA = SDL_abs((int)actualA - expectedA); SDLTest_AssertCheck( deltaR <= MAXIMUM_ERROR && deltaG <= MAXIMUM_ERROR && deltaB <= MAXIMUM_ERROR && deltaA <= MAXIMUM_ERROR, "Checking %s %s operation results, expected %d,%d,%d,%d, got %d,%d,%d,%d", operation, mode_name, expectedR, expectedG, expectedB, expectedA, actualR, actualG, actualB, actualA); /* Clean up */ SDL_DestroySurface(result); SDL_DestroyTexture(src); SDL_DestroyTexture(dst); } static void testBlendMode(int mode) { const TestRenderOperation operations[] = { TEST_RENDER_POINT, TEST_RENDER_LINE, TEST_RENDER_RECT, TEST_RENDER_COPY_XRGB, TEST_RENDER_COPY_ARGB }; const SDL_PixelFormat dst_formats[] = { SDL_PIXELFORMAT_XRGB8888, SDL_PIXELFORMAT_ARGB8888 }; int i, j; for (i = 0; i < SDL_arraysize(operations); ++i) { for (j = 0; j < SDL_arraysize(dst_formats); ++j) { TestRenderOperation op = operations[i]; if (mode < 0) { if (op != TEST_RENDER_COPY_XRGB && op != TEST_RENDER_COPY_ARGB) { /* Unsupported mode for this operation */ continue; } } testBlendModeOperation(op, mode, dst_formats[j]); } } } /** * Tests render operations with blend modes */ static int SDLCALL render_testBlendModes(void *arg) { testBlendMode(-1); testBlendMode(-2); testBlendMode(SDL_BLENDMODE_NONE); testBlendMode(SDL_BLENDMODE_BLEND); testBlendMode(SDL_BLENDMODE_BLEND_PREMULTIPLIED); testBlendMode(SDL_BLENDMODE_ADD); testBlendMode(SDL_BLENDMODE_ADD_PREMULTIPLIED); testBlendMode(SDL_BLENDMODE_MOD); testBlendMode(SDL_BLENDMODE_MUL); return TEST_COMPLETED; } /** * Test viewport */ static int SDLCALL render_testViewport(void *arg) { SDL_Surface *referenceSurface; SDL_Rect viewport; viewport.x = TESTRENDER_SCREEN_W / 3; viewport.y = TESTRENDER_SCREEN_H / 3; viewport.w = TESTRENDER_SCREEN_W / 2; viewport.h = TESTRENDER_SCREEN_H / 2; /* Create expected result */ referenceSurface = SDL_CreateSurface(TESTRENDER_SCREEN_W, TESTRENDER_SCREEN_H, RENDER_COMPARE_FORMAT); CHECK_FUNC(SDL_FillSurfaceRect, (referenceSurface, NULL, RENDER_COLOR_CLEAR)) CHECK_FUNC(SDL_FillSurfaceRect, (referenceSurface, &viewport, RENDER_COLOR_GREEN)) /* Clear surface. */ clearScreen(); /* Set the viewport and do a fill operation */ CHECK_FUNC(SDL_SetRenderViewport, (renderer, &viewport)) CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0, 255, 0, SDL_ALPHA_OPAQUE)) CHECK_FUNC(SDL_RenderFillRect, (renderer, NULL)) CHECK_FUNC(SDL_SetRenderViewport, (renderer, NULL)) /* Check to see if final image matches. */ compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); /* * Verify that clear ignores the viewport */ /* Create expected result */ CHECK_FUNC(SDL_FillSurfaceRect, (referenceSurface, NULL, RENDER_COLOR_GREEN)) /* Clear surface. */ clearScreen(); /* Set the viewport and do a clear operation */ CHECK_FUNC(SDL_SetRenderViewport, (renderer, &viewport)) CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0, 255, 0, SDL_ALPHA_OPAQUE)) CHECK_FUNC(SDL_RenderClear, (renderer)) CHECK_FUNC(SDL_SetRenderViewport, (renderer, NULL)) /* Check to see if final image matches. */ compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); /* Make current */ SDL_RenderPresent(renderer); SDL_DestroySurface(referenceSurface); return TEST_COMPLETED; } static int SDLCALL render_testRGBSurfaceNoAlpha(void* arg) { SDL_Surface *surface; SDL_Renderer *software_renderer; SDL_Surface *surface2; SDL_Texture *texture2; bool result; SDL_FRect dest_rect; SDL_FPoint point; const SDL_PixelFormatDetails *format_details; Uint8 r, g, b, a; SDLTest_AssertPass("About to call SDL_CreateSurface(128, 128, SDL_PIXELFORMAT_RGBX32)"); surface = SDL_CreateSurface(128, 128, SDL_PIXELFORMAT_RGBX32); SDLTest_AssertCheck(surface != NULL, "Returned surface must be not NULL"); if (surface == NULL) { return TEST_ABORTED; } SDLTest_AssertPass("About to call SDL_GetPixelFormatDetails(surface->format)"); format_details = SDL_GetPixelFormatDetails(surface->format); SDLTest_AssertCheck(format_details != NULL, "Result must be non-NULL, is %p", format_details); if (format_details == NULL) { SDL_DestroySurface(surface); return TEST_ABORTED; } SDLTest_AssertCheck(format_details->bits_per_pixel == 32, "format_details->bits_per_pixel is %d, should be %d", format_details->bits_per_pixel, 32); SDLTest_AssertCheck(format_details->bytes_per_pixel == 4, "format_details->bytes_per_pixel is %d, should be %d", format_details->bytes_per_pixel, 4); SDLTest_AssertPass("About to call SDL_CreateSoftwareRenderer(surface)"); software_renderer = SDL_CreateSoftwareRenderer(surface); SDLTest_AssertCheck(software_renderer != NULL, "Returned renderer must be not NULL"); if (software_renderer == NULL) { SDL_DestroySurface(surface); return TEST_ABORTED; } SDLTest_AssertPass("About to call SDL_CreateSurface(16, 16, SDL_PIXELFORMAT_RGBX32)"); surface2 = SDL_CreateSurface(16, 16, SDL_PIXELFORMAT_RGBX32); SDLTest_AssertCheck(surface2 != NULL, "Returned surface must be not NULL"); if (surface2 == NULL) { SDL_DestroySurface(surface); SDL_DestroyRenderer(software_renderer); return TEST_ABORTED; } SDLTest_AssertPass("About to call SDL_FillRect(surface2, NULL, 0)"); result = SDL_FillSurfaceRect(surface2, NULL, SDL_MapRGB(SDL_GetPixelFormatDetails(surface2->format), NULL, 0, 0, 0)); SDLTest_AssertCheck(result == true, "Result is %d, should be %d", result, true); SDLTest_AssertPass("About to call SDL_CreateTextureFromSurface(software_renderer, surface2)"); texture2 = SDL_CreateTextureFromSurface(software_renderer, surface2); SDLTest_AssertCheck(texture2 != NULL, "Returned texture is not NULL"); SDLTest_AssertPass("About to call SDL_SetRenderDrawColor(renderer, 0xaa, 0xbb, 0xcc, 0x0)"); result = SDL_SetRenderDrawColor(software_renderer, 0xaa, 0xbb, 0xcc, 0x0); SDLTest_AssertCheck(result == true, "Result is %d, should be %d", result, true); SDLTest_AssertPass("About to call SDL_RenderClear(renderer)"); result = SDL_RenderClear(software_renderer); SDLTest_AssertCheck(result == true, "Result is %d, should be %d", result, true); SDLTest_AssertPass("About to call SDL_SetRenderDrawColor(renderer, 0x0, 0x0, 0x0, 0x0)"); result = SDL_SetRenderDrawColor(software_renderer, 0x0, 0x0, 0x0, 0x0); SDLTest_AssertCheck(result == true, "Result is %d, should be %d", result, true); dest_rect.x = 32; dest_rect.y = 32; dest_rect.w = (float)surface2->w; dest_rect.h = (float)surface2->h; point.x = 0; point.y = 0; SDLTest_AssertPass("About to call SDL_RenderCopy(software_renderer, texture, NULL, &{%g, %g, %g, %g})", dest_rect.x, dest_rect.h, dest_rect.w, dest_rect.h); result = SDL_RenderTextureRotated(software_renderer, texture2, NULL, &dest_rect, 180, &point, SDL_FLIP_NONE); SDLTest_AssertCheck(result == true, "Result is %d, should be %d", result, true); SDLTest_AssertPass("About to call SDL_RenderPresent(software_renderer)"); SDL_RenderPresent(software_renderer); SDLTest_AssertPass("About to call SDL_ReadSurfacePixel(0, 0)"); result = SDL_ReadSurfacePixel(surface, 0, 0, &r, &g, &b, &a); SDLTest_AssertCheck(result == true, "Result is %d, should be %d", result, true); SDLTest_AssertCheck(r == 0xaa && g == 0xbb && b == 0xcc && a == SDL_ALPHA_OPAQUE, "Pixel at (0, 0) is {0x%02x,0x%02x,0x%02x,0x%02x}, should be {0x%02x,0x%02x,0x%02x,0x%02x}", r, g, b, a, 0xaa, 0xbb, 0xcc, SDL_ALPHA_OPAQUE); SDLTest_AssertPass("About to call SDL_ReadSurfacePixel(15, 15)"); result = SDL_ReadSurfacePixel(surface, 15, 15, &r, &g, &b, &a); SDLTest_AssertCheck(result == true, "Result is %d, should be %d", result, true); SDLTest_AssertCheck(r == 0xaa && g == 0xbb && b == 0xcc && a == SDL_ALPHA_OPAQUE, "Pixel at (0, 0) is {0x%02x,0x%02x,0x%02x,0x%02x}, should be {0x%02x,0x%02x,0x%02x,0x%02x}", r, g, b, a, 0xaa, 0xbb, 0xcc, SDL_ALPHA_OPAQUE); SDLTest_AssertPass("About to call SDL_ReadSurfacePixel(16, 16)"); result = SDL_ReadSurfacePixel(surface, 16, 16, &r, &g, &b, &a); SDLTest_AssertCheck(result == true, "Result is %d, should be %d", result, true); SDLTest_AssertCheck(r == 0x00 && g == 0x00 && b == 0x00 && a == SDL_ALPHA_OPAQUE, "Pixel at (0, 0) is {0x%02x,0x%02x,0x%02x,0x%02x}, should be {0x%02x,0x%02x,0x%02x,0x%02x}", r, g, b, a, 0x00, 0x00, 0x00, SDL_ALPHA_OPAQUE); SDLTest_AssertPass("About to call SDL_ReadSurfacePixel(31, 31)"); result = SDL_ReadSurfacePixel(surface, 31, 31, &r, &g, &b, &a); SDLTest_AssertCheck(result == true, "Result is %d, should be %d", result, true); SDLTest_AssertCheck(r == 0x00 && g == 0x00 && b == 0x00 && a == SDL_ALPHA_OPAQUE, "Pixel at (0, 0) is {0x%02x,0x%02x,0x%02x,0x%02x}, should be {0x%02x,0x%02x,0x%02x,0x%02x}", r, g, b, a, 0x00, 0x00, 0x00, SDL_ALPHA_OPAQUE); SDLTest_AssertPass("About to call SDL_ReadSurfacePixel(32, 32)"); result = SDL_ReadSurfacePixel(surface, 32, 32, &r, &g, &b, &a); SDLTest_AssertCheck(result == true, "Result is %d, should be %d", result, true); SDLTest_AssertCheck(r == 0xaa && g == 0xbb && b == 0xcc && a == SDL_ALPHA_OPAQUE, "Pixel at (0, 0) is {0x%02x,0x%02x,0x%02x,0x%02x}, should be {0x%02x,0x%02x,0x%02x,0x%02x}", r, g, b, a, 0xaa, 0xbb, 0xcc, SDL_ALPHA_OPAQUE); SDL_DestroyTexture(texture2); SDL_DestroySurface(surface2); SDL_DestroyRenderer(software_renderer); SDL_DestroySurface(surface); return TEST_COMPLETED; } /** * Test clip rect */ static int SDLCALL render_testClipRect(void *arg) { SDL_Surface *referenceSurface; SDL_Rect cliprect; cliprect.x = TESTRENDER_SCREEN_W / 3; cliprect.y = TESTRENDER_SCREEN_H / 3; cliprect.w = TESTRENDER_SCREEN_W / 2; cliprect.h = TESTRENDER_SCREEN_H / 2; /* Create expected result */ referenceSurface = SDL_CreateSurface(TESTRENDER_SCREEN_W, TESTRENDER_SCREEN_H, RENDER_COMPARE_FORMAT); CHECK_FUNC(SDL_FillSurfaceRect, (referenceSurface, NULL, RENDER_COLOR_CLEAR)) CHECK_FUNC(SDL_FillSurfaceRect, (referenceSurface, &cliprect, RENDER_COLOR_GREEN)) /* Clear surface. */ clearScreen(); /* Set the cliprect and do a fill operation */ CHECK_FUNC(SDL_SetRenderClipRect, (renderer, &cliprect)) CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0, 255, 0, SDL_ALPHA_OPAQUE)) CHECK_FUNC(SDL_RenderFillRect, (renderer, NULL)) CHECK_FUNC(SDL_SetRenderClipRect, (renderer, NULL)) /* Check to see if final image matches. */ compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); /* * Verify that empty cliprect clips all drawing */ /* Set the cliprect and do a fill operation */ cliprect.h = 0; CHECK_FUNC(SDL_SetRenderClipRect, (renderer, &cliprect)) CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 255, 0, 0, SDL_ALPHA_OPAQUE)) CHECK_FUNC(SDL_RenderFillRect, (renderer, NULL)) CHECK_FUNC(SDL_SetRenderClipRect, (renderer, NULL)) /* Check to see if final image matches. */ compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); /* * Verify that clear ignores the cliprect */ /* Create expected result */ CHECK_FUNC(SDL_FillSurfaceRect, (referenceSurface, NULL, RENDER_COLOR_GREEN)) /* Clear surface. */ clearScreen(); /* Set the cliprect and do a clear operation */ CHECK_FUNC(SDL_SetRenderClipRect, (renderer, &cliprect)) CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0, 255, 0, SDL_ALPHA_OPAQUE)) CHECK_FUNC(SDL_RenderClear, (renderer)) CHECK_FUNC(SDL_SetRenderClipRect, (renderer, NULL)) /* Check to see if final image matches. */ compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); /* Make current */ SDL_RenderPresent(renderer); SDL_DestroySurface(referenceSurface); return TEST_COMPLETED; } /** * Test logical size */ static int SDLCALL render_testLogicalSize(void *arg) { SDL_Surface *referenceSurface; SDL_Rect viewport; SDL_FRect rect; int w = 0, h = 0; int set_w, set_h; SDL_RendererLogicalPresentation set_presentation_mode; SDL_FRect set_rect; const int factor = 2; SDL_GetWindowSize(window, &w, &h); if (w != TESTRENDER_WINDOW_W || h != TESTRENDER_WINDOW_H) { SDLTest_Log("Skipping test render_testLogicalSize: expected window %dx%d, got %dx%d", TESTRENDER_WINDOW_W, TESTRENDER_WINDOW_H, w, h); return TEST_SKIPPED; } viewport.x = ((TESTRENDER_SCREEN_W / 4) / factor) * factor; viewport.y = ((TESTRENDER_SCREEN_H / 4) / factor) * factor; viewport.w = ((TESTRENDER_SCREEN_W / 2) / factor) * factor; viewport.h = ((TESTRENDER_SCREEN_H / 2) / factor) * factor; /* Create expected result */ referenceSurface = SDL_CreateSurface(TESTRENDER_SCREEN_W, TESTRENDER_SCREEN_H, RENDER_COMPARE_FORMAT); CHECK_FUNC(SDL_FillSurfaceRect, (referenceSurface, NULL, RENDER_COLOR_CLEAR)) CHECK_FUNC(SDL_FillSurfaceRect, (referenceSurface, &viewport, RENDER_COLOR_GREEN)) /* Clear surface. */ clearScreen(); /* Set the logical size and do a fill operation */ CHECK_FUNC(SDL_GetCurrentRenderOutputSize, (renderer, &w, &h)) CHECK_FUNC(SDL_SetRenderLogicalPresentation, (renderer, w / factor, h / factor, SDL_LOGICAL_PRESENTATION_LETTERBOX)) CHECK_FUNC(SDL_GetRenderLogicalPresentation, (renderer, &set_w, &set_h, &set_presentation_mode)) SDLTest_AssertCheck( set_w == (w / factor) && set_h == (h / factor) && set_presentation_mode == SDL_LOGICAL_PRESENTATION_LETTERBOX, "Validate result from SDL_GetRenderLogicalPresentation, got %d, %d, %d", set_w, set_h, set_presentation_mode); CHECK_FUNC(SDL_GetRenderLogicalPresentationRect, (renderer, &set_rect)) SDLTest_AssertCheck( set_rect.x == 0.0f && set_rect.y == 0.0f && set_rect.w == (float)w && set_rect.h == (float)h, "Validate result from SDL_GetRenderLogicalPresentationRect, got {%g, %g, %gx%g}", set_rect.x, set_rect.y, set_rect.w, set_rect.h); CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0, 255, 0, SDL_ALPHA_OPAQUE)) rect.x = (float)viewport.x / factor; rect.y = (float)viewport.y / factor; rect.w = (float)viewport.w / factor; rect.h = (float)viewport.h / factor; CHECK_FUNC(SDL_RenderFillRect, (renderer, &rect)) CHECK_FUNC(SDL_SetRenderLogicalPresentation, (renderer, 0, 0, SDL_LOGICAL_PRESENTATION_DISABLED)) CHECK_FUNC(SDL_GetRenderLogicalPresentation, (renderer, &set_w, &set_h, &set_presentation_mode)) SDLTest_AssertCheck( set_w == 0 && set_h == 0 && set_presentation_mode == SDL_LOGICAL_PRESENTATION_DISABLED, "Validate result from SDL_GetRenderLogicalPresentation, got %d, %d, %d", set_w, set_h, set_presentation_mode); CHECK_FUNC(SDL_GetRenderLogicalPresentationRect, (renderer, &set_rect)) SDLTest_AssertCheck( set_rect.x == 0.0f && set_rect.y == 0.0f && set_rect.w == (float)w && set_rect.h == (float)h, "Validate result from SDL_GetRenderLogicalPresentationRect, got {%g, %g, %gx%g}", set_rect.x, set_rect.y, set_rect.w, set_rect.h); /* Check to see if final image matches. */ compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); /* Clear surface. */ clearScreen(); /* Set the logical size and viewport and do a fill operation */ CHECK_FUNC(SDL_GetCurrentRenderOutputSize, (renderer, &w, &h)) CHECK_FUNC(SDL_SetRenderLogicalPresentation, (renderer, w / factor, h / factor, SDL_LOGICAL_PRESENTATION_LETTERBOX)) viewport.x = (TESTRENDER_SCREEN_W / 4) / factor; viewport.y = (TESTRENDER_SCREEN_H / 4) / factor; viewport.w = (TESTRENDER_SCREEN_W / 2) / factor; viewport.h = (TESTRENDER_SCREEN_H / 2) / factor; CHECK_FUNC(SDL_SetRenderViewport, (renderer, &viewport)) CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0, 255, 0, SDL_ALPHA_OPAQUE)) CHECK_FUNC(SDL_RenderFillRect, (renderer, NULL)) CHECK_FUNC(SDL_SetRenderViewport, (renderer, NULL)) CHECK_FUNC(SDL_SetRenderLogicalPresentation, (renderer, 0, 0, SDL_LOGICAL_PRESENTATION_DISABLED)) /* Check to see if final image matches. */ compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); /* * Test a logical size that isn't the same aspect ratio as the window */ viewport.x = (TESTRENDER_SCREEN_W / 4); viewport.y = 0; viewport.w = TESTRENDER_SCREEN_W; viewport.h = TESTRENDER_SCREEN_H; /* Create expected result */ CHECK_FUNC(SDL_FillSurfaceRect, (referenceSurface, NULL, RENDER_COLOR_CLEAR)) CHECK_FUNC(SDL_FillSurfaceRect, (referenceSurface, &viewport, RENDER_COLOR_GREEN)) /* Clear surface. */ clearScreen(); /* Set the logical size and do a fill operation */ CHECK_FUNC(SDL_GetCurrentRenderOutputSize, (renderer, &w, &h)) CHECK_FUNC(SDL_SetRenderLogicalPresentation, (renderer, w - 2 * (TESTRENDER_SCREEN_W / 4), h, SDL_LOGICAL_PRESENTATION_LETTERBOX)) CHECK_FUNC(SDL_GetRenderLogicalPresentation, (renderer, &set_w, &set_h, &set_presentation_mode)) SDLTest_AssertCheck( set_w == w - 2 * (TESTRENDER_SCREEN_W / 4) && set_h == h && set_presentation_mode == SDL_LOGICAL_PRESENTATION_LETTERBOX, "Validate result from SDL_GetRenderLogicalPresentation, got %d, %d, %d", set_w, set_h, set_presentation_mode); CHECK_FUNC(SDL_GetRenderLogicalPresentationRect, (renderer, &set_rect)) SDLTest_AssertCheck( set_rect.x == 20.0f && set_rect.y == 0.0f && set_rect.w == 280.0f && set_rect.h == 240.0f, "Validate result from SDL_GetRenderLogicalPresentationRect, got {%g, %g, %gx%g}", set_rect.x, set_rect.y, set_rect.w, set_rect.h); CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0, 255, 0, SDL_ALPHA_OPAQUE)) CHECK_FUNC(SDL_RenderFillRect, (renderer, NULL)) CHECK_FUNC(SDL_SetRenderLogicalPresentation, (renderer, 0, 0, SDL_LOGICAL_PRESENTATION_DISABLED)) CHECK_FUNC(SDL_GetRenderLogicalPresentation, (renderer, &set_w, &set_h, &set_presentation_mode)) SDLTest_AssertCheck( set_w == 0 && set_h == 0 && set_presentation_mode == SDL_LOGICAL_PRESENTATION_DISABLED, "Validate result from SDL_GetRenderLogicalPresentation, got %d, %d, %d", set_w, set_h, set_presentation_mode); CHECK_FUNC(SDL_GetRenderLogicalPresentationRect, (renderer, &set_rect)) SDLTest_AssertCheck( set_rect.x == 0.0f && set_rect.y == 0.0f && set_rect.w == 320.0f && set_rect.h == 240.0f, "Validate result from SDL_GetRenderLogicalPresentationRect, got {%g, %g, %gx%g}", set_rect.x, set_rect.y, set_rect.w, set_rect.h); /* Check to see if final image matches. */ compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); /* Clear surface. */ clearScreen(); /* Make current */ SDL_RenderPresent(renderer); SDL_DestroySurface(referenceSurface); return TEST_COMPLETED; } /** * @brief Tests setting and getting texture scale mode. * * \sa * http://wiki.libsdl.org/SDL2/SDL_SetTextureScaleMode * http://wiki.libsdl.org/SDL2/SDL_GetTextureScaleMode */ static int SDLCALL render_testGetSetTextureScaleMode(void *arg) { const struct { const char *name; SDL_ScaleMode mode; } modes[] = { { "SDL_SCALEMODE_NEAREST", SDL_SCALEMODE_NEAREST }, { "SDL_SCALEMODE_LINEAR", SDL_SCALEMODE_LINEAR }, { "SDL_SCALEMODE_PIXELART", SDL_SCALEMODE_PIXELART }, }; size_t i; for (i = 0; i < SDL_arraysize(modes); i++) { SDL_Texture *texture; bool result; SDL_ScaleMode actual_mode = SDL_SCALEMODE_NEAREST; SDL_ClearError(); SDLTest_AssertPass("About to call SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, 16, 16)"); texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, 16, 16); SDLTest_AssertCheck(texture != NULL, "SDL_CreateTexture must return a non-NULL texture"); SDLTest_AssertPass("About to call SDL_SetTextureScaleMode(texture, %s)", modes[i].name); result = SDL_SetTextureScaleMode(texture, modes[i].mode); SDLTest_AssertCheck(result == true, "SDL_SetTextureScaleMode returns %d, expected %d", result, true); SDLTest_AssertPass("About to call SDL_GetTextureScaleMode(texture)"); result = SDL_GetTextureScaleMode(texture, &actual_mode); SDLTest_AssertCheck(result == true, "SDL_SetTextureScaleMode returns %d, expected %d", result, true); SDLTest_AssertCheck(actual_mode == modes[i].mode, "SDL_GetTextureScaleMode must return %s (%d), actual=%d", modes[i].name, modes[i].mode, actual_mode); } return TEST_COMPLETED; } /* Helper functions */ /** * Checks to see if functionality is supported. Helper function. */ static bool isSupported(int code) { return (code != false); } /** * Test to see if we can vary the draw color. Helper function. * * \sa SDL_SetRenderDrawColor * \sa SDL_GetRenderDrawColor */ static bool hasDrawColor(void) { int ret, fail; Uint8 r, g, b, a; fail = 0; /* Set color. */ ret = SDL_SetRenderDrawColor(renderer, 100, 100, 100, 100); if (!isSupported(ret)) { fail = 1; } ret = SDL_GetRenderDrawColor(renderer, &r, &g, &b, &a); if (!isSupported(ret)) { fail = 1; } /* Restore natural. */ ret = SDL_SetRenderDrawColor(renderer, 0, 0, 0, SDL_ALPHA_OPAQUE); if (!isSupported(ret)) { fail = 1; } /* Something failed, consider not available. */ if (fail) { return false; } /* Not set properly, consider failed. */ else if ((r != 100) || (g != 100) || (b != 100) || (a != 100)) { return false; } return true; } /** * Loads the test image 'Face' as texture. Helper function. * * \sa SDL_CreateTextureFromSurface */ static SDL_Texture * loadTestFace(void) { SDL_Surface *face; SDL_Texture *tface; face = SDLTest_ImageFace(); if (!face) { return NULL; } tface = SDL_CreateTextureFromSurface(renderer, face); if (!tface) { SDLTest_LogError("SDL_CreateTextureFromSurface() failed with error: %s", SDL_GetError()); } SDL_DestroySurface(face); return tface; } /** * Compares screen pixels with image pixels. Helper function. * * \param referenceSurface Image to compare against. * \param allowable_error allowed difference from the reference image * * \sa SDL_RenderReadPixels * \sa SDL_CreateSurfaceFrom * \sa SDL_DestroySurface */ static void compare(SDL_Surface *referenceSurface, int allowable_error) { int ret; SDL_Rect rect; SDL_Surface *surface, *testSurface; /* Explicitly specify the rect in case the window isn't the expected size... */ rect.x = 0; rect.y = 0; rect.w = TESTRENDER_SCREEN_W; rect.h = TESTRENDER_SCREEN_H; surface = SDL_RenderReadPixels(renderer, &rect); if (!surface) { SDLTest_AssertCheck(surface != NULL, "Validate result from SDL_RenderReadPixels, got NULL, %s", SDL_GetError()); return; } testSurface = SDL_ConvertSurface(surface, RENDER_COMPARE_FORMAT); SDL_DestroySurface(surface); if (!testSurface) { SDLTest_AssertCheck(testSurface != NULL, "Validate result from SDL_ConvertSurface, got NULL, %s", SDL_GetError()); return; } /* Compare surface. */ ret = SDLTest_CompareSurfaces(testSurface, referenceSurface, allowable_error); SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret); /* Clean up. */ SDL_DestroySurface(testSurface); } static void compare2x(SDL_Surface *referenceSurface, int allowable_error) { int ret; SDL_Rect rect; SDL_Surface *surface, *testSurface; /* Explicitly specify the rect in case the window isn't the expected size... */ rect.x = 0; rect.y = 0; rect.w = TESTRENDER_SCREEN_W * 2; rect.h = TESTRENDER_SCREEN_H * 2; surface = SDL_RenderReadPixels(renderer, &rect); if (!surface) { SDLTest_AssertCheck(surface != NULL, "Validate result from SDL_RenderReadPixels, got NULL, %s", SDL_GetError()); return; } testSurface = SDL_ConvertSurface(surface, RENDER_COMPARE_FORMAT); SDL_DestroySurface(surface); if (!testSurface) { SDLTest_AssertCheck(testSurface != NULL, "Validate result from SDL_ConvertSurface, got NULL, %s", SDL_GetError()); return; } /* Compare surface. */ ret = SDLTest_CompareSurfaces(testSurface, referenceSurface, allowable_error); SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret); /* Clean up. */ SDL_DestroySurface(testSurface); } /** * Clears the screen. Helper function. * * \sa SDL_SetRenderDrawColor * \sa SDL_RenderClear * \sa SDL_RenderPresent * \sa SDL_SetRenderDrawBlendMode */ static int clearScreen(void) { int ret; /* Make current */ SDL_RenderPresent(renderer); /* Set color. */ ret = SDL_SetRenderDrawColor(renderer, 0, 0, 0, SDL_ALPHA_OPAQUE); SDLTest_AssertCheck(ret == true, "Validate result from SDL_SetRenderDrawColor, expected: true, got: %i", ret); /* Clear screen. */ ret = SDL_RenderClear(renderer); SDLTest_AssertCheck(ret == true, "Validate result from SDL_RenderClear, expected: true, got: %i", ret); /* Set defaults. */ ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE); SDLTest_AssertCheck(ret == true, "Validate result from SDL_SetRenderDrawBlendMode, expected: true, got: %i", ret); ret = SDL_SetRenderDrawColor(renderer, 255, 255, 255, SDL_ALPHA_OPAQUE); SDLTest_AssertCheck(ret == true, "Validate result from SDL_SetRenderDrawColor, expected: true, got: %i", ret); return 0; } /** * Tests geometry UV clamping */ static int SDLCALL render_testUVClamping(void *arg) { SDL_Vertex vertices[6]; SDL_Vertex *verts = vertices; SDL_FColor color = { 1.0f, 1.0f, 1.0f, 1.0f }; SDL_FRect rect; float min_U = -0.5f; float max_U = 1.5f; float min_V = -0.5f; float max_V = 1.5f; SDL_Texture *tface; SDL_Surface *referenceSurface = NULL; /* Clear surface. */ clearScreen(); /* Create face surface. */ tface = loadTestFace(); SDLTest_AssertCheck(tface != NULL, "Verify loadTestFace() result"); if (tface == NULL) { return TEST_ABORTED; } rect.w = (float)tface->w * 2; rect.h = (float)tface->h * 2; rect.x = (TESTRENDER_SCREEN_W - rect.w) / 2; rect.y = (TESTRENDER_SCREEN_H - rect.h) / 2; /* * 0--1 * | /| * |/ | * 3--2 * * Draw sprite2 as triangles that can be recombined as rect by software renderer */ /* 0 */ verts->position.x = rect.x; verts->position.y = rect.y; verts->color = color; verts->tex_coord.x = min_U; verts->tex_coord.y = min_V; verts++; /* 1 */ verts->position.x = rect.x + rect.w; verts->position.y = rect.y; verts->color = color; verts->tex_coord.x = max_U; verts->tex_coord.y = min_V; verts++; /* 2 */ verts->position.x = rect.x + rect.w; verts->position.y = rect.y + rect.h; verts->color = color; verts->tex_coord.x = max_U; verts->tex_coord.y = max_V; verts++; /* 0 */ verts->position.x = rect.x; verts->position.y = rect.y; verts->color = color; verts->tex_coord.x = min_U; verts->tex_coord.y = min_V; verts++; /* 2 */ verts->position.x = rect.x + rect.w; verts->position.y = rect.y + rect.h; verts->color = color; verts->tex_coord.x = max_U; verts->tex_coord.y = max_V; verts++; /* 3 */ verts->position.x = rect.x; verts->position.y = rect.y + rect.h; verts->color = color; verts->tex_coord.x = min_U; verts->tex_coord.y = max_V; verts++; /* Set texture address mode to clamp */ SDL_SetRenderTextureAddressMode(renderer, SDL_TEXTURE_ADDRESS_CLAMP, SDL_TEXTURE_ADDRESS_CLAMP); /* Blit sprites as triangles onto the screen */ SDL_RenderGeometry(renderer, tface, vertices, 6, NULL, 0); /* See if it's the same */ referenceSurface = SDLTest_ImageClampedSprite(); compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); /* Make current */ SDL_RenderPresent(renderer); /* Clean up. */ SDL_DestroyTexture(tface); SDL_DestroySurface(referenceSurface); referenceSurface = NULL; return TEST_COMPLETED; } /** * Tests geometry UV wrapping */ static int SDLCALL render_testUVWrapping(void *arg) { SDL_Vertex vertices[6]; SDL_Vertex *verts = vertices; SDL_FColor color = { 1.0f, 1.0f, 1.0f, 1.0f }; SDL_FRect rect; float min_U = -0.5f; float max_U = 1.5f; float min_V = -0.5f; float max_V = 1.5f; SDL_Texture *tface; SDL_Surface *referenceSurface = NULL; /* Clear surface. */ clearScreen(); /* Create face surface. */ tface = loadTestFace(); SDLTest_AssertCheck(tface != NULL, "Verify loadTestFace() result"); if (tface == NULL) { return TEST_ABORTED; } rect.w = (float)tface->w * 2; rect.h = (float)tface->h * 2; rect.x = (TESTRENDER_SCREEN_W - rect.w) / 2; rect.y = (TESTRENDER_SCREEN_H - rect.h) / 2; /* * 0--1 * | /| * |/ | * 3--2 * * Draw sprite2 as triangles that can be recombined as rect by software renderer */ /* 0 */ verts->position.x = rect.x; verts->position.y = rect.y; verts->color = color; verts->tex_coord.x = min_U; verts->tex_coord.y = min_V; verts++; /* 1 */ verts->position.x = rect.x + rect.w; verts->position.y = rect.y; verts->color = color; verts->tex_coord.x = max_U; verts->tex_coord.y = min_V; verts++; /* 2 */ verts->position.x = rect.x + rect.w; verts->position.y = rect.y + rect.h; verts->color = color; verts->tex_coord.x = max_U; verts->tex_coord.y = max_V; verts++; /* 0 */ verts->position.x = rect.x; verts->position.y = rect.y; verts->color = color; verts->tex_coord.x = min_U; verts->tex_coord.y = min_V; verts++; /* 2 */ verts->position.x = rect.x + rect.w; verts->position.y = rect.y + rect.h; verts->color = color; verts->tex_coord.x = max_U; verts->tex_coord.y = max_V; verts++; /* 3 */ verts->position.x = rect.x; verts->position.y = rect.y + rect.h; verts->color = color; verts->tex_coord.x = min_U; verts->tex_coord.y = max_V; verts++; /* Blit sprites as triangles onto the screen */ SDL_RenderGeometry(renderer, tface, vertices, 6, NULL, 0); /* See if it's the same */ referenceSurface = SDLTest_ImageWrappingSprite(); compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); /* Make current */ SDL_RenderPresent(renderer); /* Clean up. */ SDL_DestroyTexture(tface); SDL_DestroySurface(referenceSurface); referenceSurface = NULL; return TEST_COMPLETED; } /** * Tests texture state changes */ static int SDLCALL render_testTextureState(void *arg) { const Uint8 pixels[8] = { 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; const SDL_Color expected[] = { /* Step 0: plain copy */ { 0x00, 0x00, 0x00, 0xFF }, { 0xFF, 0xFF, 0xFF, 0xFF }, /* Step 1: color mod to red */ { 0x00, 0x00, 0x00, 0xFF }, { 0xFF, 0x00, 0x00, 0xFF }, /* Step 2: alpha mod to 128 (cleared to green) */ { 0x00, 0x7F, 0x00, 0xFF }, { 0x80, 0xFF, 0x80, 0xFF }, /* Step 3: nearest stretch */ { 0xFF, 0xFF, 0xFF, 0xFF }, { 0x00, 0xFF, 0x00, 0xFF }, /* Step 4: linear stretch */ { 0x80, 0x80, 0x80, 0xFF }, { 0x00, 0xFF, 0x00, 0xFF }, }; SDL_Texture *texture; SDL_Rect rect; SDL_FRect dst; int i; /* Clear surface to green */ SDL_SetRenderDrawColor(renderer, 0, 255, 0, SDL_ALPHA_OPAQUE); SDL_RenderClear(renderer); /* Create 2-pixel surface. */ texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA32, SDL_TEXTUREACCESS_STATIC, 2, 1); SDLTest_AssertCheck(texture != NULL, "Verify SDL_CreateTexture() result"); if (texture == NULL) { return TEST_ABORTED; } SDL_UpdateTexture(texture, NULL, pixels, sizeof(pixels)); dst.x = 0.0f; dst.y = 0.0f; dst.w = 2.0f; dst.h = 1.0f; /* Step 0: plain copy */ SDL_RenderTexture(renderer, texture, NULL, &dst); dst.y += 1; /* Step 1: color mod to red */ SDL_SetTextureColorMod(texture, 0xFF, 0x00, 0x00); SDL_RenderTexture(renderer, texture, NULL, &dst); SDL_SetTextureColorMod(texture, 0xFF, 0xFF, 0xFF); dst.y += 1; /* Step 2: alpha mod to 128 */ SDL_SetTextureAlphaMod(texture, 0x80); SDL_RenderTexture(renderer, texture, NULL, &dst); SDL_SetTextureAlphaMod(texture, 0xFF); dst.y += 1; /* Step 3: nearest stretch */ dst.w = 1; SDL_SetTextureScaleMode(texture, SDL_SCALEMODE_NEAREST); SDL_RenderTexture(renderer, texture, NULL, &dst); dst.y += 1; /* Step 4: linear stretch */ dst.w = 1; SDL_SetTextureScaleMode(texture, SDL_SCALEMODE_LINEAR); SDL_RenderTexture(renderer, texture, NULL, &dst); dst.y += 1; /* Verify results */ rect.x = 0; rect.y = 0; rect.w = 2; rect.h = 1; for (i = 0; i < SDL_arraysize(expected); ) { const int MAX_DELTA = 1; SDL_Color actual; int deltaR, deltaG, deltaB, deltaA; SDL_Surface *surface = SDL_RenderReadPixels(renderer, &rect); SDL_ReadSurfacePixel(surface, 0, 0, &actual.r, &actual.g, &actual.b, &actual.a); deltaR = (actual.r - expected[i].r); deltaG = (actual.g - expected[i].g); deltaB = (actual.b - expected[i].b); deltaA = (actual.a - expected[i].a); SDLTest_AssertCheck(SDL_abs(deltaR) <= MAX_DELTA && SDL_abs(deltaG) <= MAX_DELTA && SDL_abs(deltaB) <= MAX_DELTA && SDL_abs(deltaA) <= MAX_DELTA, "Validate left pixel at step %d, expected %d,%d,%d,%d, got %d,%d,%d,%d", i/2, expected[i].r, expected[i].g, expected[i].b, expected[i].a, actual.r, actual.g, actual.b, actual.a); ++i; SDL_ReadSurfacePixel(surface, 1, 0, &actual.r, &actual.g, &actual.b, &actual.a); deltaR = (actual.r - expected[i].r); deltaG = (actual.g - expected[i].g); deltaB = (actual.b - expected[i].b); deltaA = (actual.a - expected[i].a); SDLTest_AssertCheck(SDL_abs(deltaR) <= MAX_DELTA && SDL_abs(deltaG) <= MAX_DELTA && SDL_abs(deltaB) <= MAX_DELTA && SDL_abs(deltaA) <= MAX_DELTA, "Validate right pixel at step %d, expected %d,%d,%d,%d, got %d,%d,%d,%d", i/2, expected[i].r, expected[i].g, expected[i].b, expected[i].a, actual.r, actual.g, actual.b, actual.a); ++i; SDL_DestroySurface(surface); rect.y += 1; } /* Clean up. */ SDL_DestroyTexture(texture); return TEST_COMPLETED; } static void CheckUniformColor(float expected) { SDL_Surface *surface = SDL_RenderReadPixels(renderer, NULL); if (surface) { const float epsilon = 0.001f; float r, g, b, a; CHECK_FUNC(SDL_ReadSurfacePixelFloat, (surface, 0, 0, &r, &g, &b, &a)); SDLTest_AssertCheck( SDL_fabs(r - expected) <= epsilon && SDL_fabs(g - expected) <= epsilon && SDL_fabs(b - expected) <= epsilon && a == 1.0f, "Check color, expected %g,%g,%g,%g, got %g,%g,%g,%g", expected, expected, expected, 1.0f, r, g, b, a); SDL_DestroySurface(surface); } else { SDLTest_AssertCheck(surface != NULL, "Validate result from SDL_RenderReadPixels, got NULL, %s", SDL_GetError()); } } /** * Tests colorspace support (sRGB -> linear) */ static int SDLCALL render_testColorspaceLinear(void *arg) { SDL_PropertiesID props; SDL_Texture *texture; Uint32 pixel = 0xFF404040; SDL_DestroyRenderer(renderer); props = SDL_CreateProperties(); #ifdef SDL_PLATFORM_EMSCRIPTEN // Something about falling back to the software renderer and failing causes window surface updates to fail in video_getWindowSurface() // Adding this as a workaround to prevent software fallback until we figure this out. SDL_SetStringProperty(props, SDL_PROP_RENDERER_CREATE_NAME_STRING, "opengles2"); #endif SDL_SetPointerProperty(props, SDL_PROP_RENDERER_CREATE_WINDOW_POINTER, window); SDL_SetNumberProperty(props, SDL_PROP_RENDERER_CREATE_OUTPUT_COLORSPACE_NUMBER, SDL_COLORSPACE_SRGB_LINEAR); renderer = SDL_CreateRendererWithProperties(props); SDL_DestroyProperties(props); if (!renderer) { SDLTest_Log("Skipping test render_testColorspaceLinear, couldn't create a linear colorspace renderer"); return TEST_SKIPPED; } /* Verify conversion between sRGB and linear colorspaces */ texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STATIC, 1, 1); SDLTest_AssertPass("Create texture"); SDLTest_AssertCheck(texture != NULL, "Check SDL_CreateTexture result"); CHECK_FUNC(SDL_UpdateTexture, (texture, NULL, &pixel, sizeof(pixel))); CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0, 0, 0, 255)); CHECK_FUNC(SDL_RenderClear, (renderer)); CheckUniformColor(0.0f); SDLTest_AssertPass("Checking sRGB clear 0x40"); CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0x40, 0x40, 0x40, 255)); CHECK_FUNC(SDL_RenderClear, (renderer)); CheckUniformColor(0.0512695f); /* Clear target to 0 */ CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0, 0, 0, 255)); CHECK_FUNC(SDL_RenderClear, (renderer)); SDLTest_AssertPass("Checking sRGB draw 0x40"); CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0x40, 0x40, 0x40, 255)); CHECK_FUNC(SDL_RenderPoint, (renderer, 0.0f, 0.0f)); CheckUniformColor(0.0512695f); /* Clear target to 0 */ CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0, 0, 0, 255)); CHECK_FUNC(SDL_RenderClear, (renderer)); SDLTest_AssertPass("Checking sRGB texture 0x40"); CHECK_FUNC(SDL_RenderTexture, (renderer, texture, NULL, NULL)); CheckUniformColor(0.0512695f); /* Clear target to 0 */ CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0, 0, 0, 255)); CHECK_FUNC(SDL_RenderClear, (renderer)); SDL_SetRenderColorScale(renderer, 2.0f); SDLTest_AssertPass("Checking sRGB clear 0x40 with color scale 2.0"); CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0x40, 0x40, 0x40, 255)); CHECK_FUNC(SDL_RenderClear, (renderer)); CheckUniformColor(0.102478f); /* Clear target to 0 */ CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0, 0, 0, 255)); CHECK_FUNC(SDL_RenderClear, (renderer)); SDLTest_AssertPass("Checking sRGB draw 0x40 with color scale 2.0f"); CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0x40, 0x40, 0x40, 255)); CHECK_FUNC(SDL_RenderPoint, (renderer, 0.0f, 0.0f)); CheckUniformColor(0.102478f); /* Clear target to 0 */ CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0, 0, 0, 255)); CHECK_FUNC(SDL_RenderClear, (renderer)); SDLTest_AssertPass("Checking sRGB texture 0x40 with color scale 2.0f"); CHECK_FUNC(SDL_RenderTexture, (renderer, texture, NULL, NULL)); CheckUniformColor(0.102478f); SDL_DestroyTexture(texture); return TEST_COMPLETED; } /** * Tests colorspace support (linear -> sRGB) */ static int SDLCALL render_testColorspaceSRGB(void *arg) { bool supports_float_textures; const SDL_PixelFormat *texture_formats; int i; SDL_Texture *texture; float pixel[4] = { 0.25f, 0.25f, 0.25f, 1.0f }; supports_float_textures = false; texture_formats = (const SDL_PixelFormat *)SDL_GetPointerProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_TEXTURE_FORMATS_POINTER, NULL); if (texture_formats) { for (i = 0; texture_formats[i] != SDL_PIXELFORMAT_UNKNOWN; ++i) { if (SDL_ISPIXELFORMAT_FLOAT(texture_formats[i])) { supports_float_textures = true; break; } } } if (!supports_float_textures) { SDLTest_Log("Skipping test render_testColorspaceSRGB, renderer doesn't support float textures"); return TEST_SKIPPED; } /* Verify conversion between sRGB and linear colorspaces */ texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA128_FLOAT, SDL_TEXTUREACCESS_STATIC, 1, 1); SDLTest_AssertPass("Create texture"); SDLTest_AssertCheck(texture != NULL, "Check SDL_CreateTexture result"); CHECK_FUNC(SDL_UpdateTexture, (texture, NULL, &pixel, sizeof(pixel))); CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0, 0, 0, 255)); CHECK_FUNC(SDL_RenderClear, (renderer)); CheckUniformColor(0.0f); SDLTest_AssertPass("Checking sRGB clear 0x40"); CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0x40, 0x40, 0x40, 255)); CHECK_FUNC(SDL_RenderClear, (renderer)); CheckUniformColor(0.25098f); /* Clear target to 0 */ CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0, 0, 0, 255)); CHECK_FUNC(SDL_RenderClear, (renderer)); SDLTest_AssertPass("Checking sRGB draw 0x40"); CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0x40, 0x40, 0x40, 255)); CHECK_FUNC(SDL_RenderPoint, (renderer, 0.0f, 0.0f)); CheckUniformColor(0.25098f); /* Clear target to 0 */ CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0, 0, 0, 255)); CHECK_FUNC(SDL_RenderClear, (renderer)); SDLTest_AssertPass("Checking linear texture 0.25"); CHECK_FUNC(SDL_RenderTexture, (renderer, texture, NULL, NULL)); CheckUniformColor(0.537255f); /* Clear target to 0 */ CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0, 0, 0, 255)); CHECK_FUNC(SDL_RenderClear, (renderer)); SDL_SetRenderColorScale(renderer, 2.0f); SDLTest_AssertPass("Checking sRGB clear 0x40 with color scale 2.0"); CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0x40, 0x40, 0x40, 255)); CHECK_FUNC(SDL_RenderClear, (renderer)); CheckUniformColor(0.501961f); /* Clear target to 0 */ CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0, 0, 0, 255)); CHECK_FUNC(SDL_RenderClear, (renderer)); SDLTest_AssertPass("Checking sRGB draw 0x40 with color scale 2.0f"); CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0x40, 0x40, 0x40, 255)); CHECK_FUNC(SDL_RenderPoint, (renderer, 0.0f, 0.0f)); CheckUniformColor(0.501961f); /* Clear target to 0 */ CHECK_FUNC(SDL_SetRenderDrawColor, (renderer, 0, 0, 0, 255)); CHECK_FUNC(SDL_RenderClear, (renderer)); SDLTest_AssertPass("Checking linear texture 0.25 with color scale 2.0f"); CHECK_FUNC(SDL_RenderTexture, (renderer, texture, NULL, NULL)); CheckUniformColor(0.737255f); SDL_DestroyTexture(texture); return TEST_COMPLETED; } /* ================= Test References ================== */ /* Render test cases */ static const SDLTest_TestCaseReference renderTestGetNumRenderDrivers = { render_testGetNumRenderDrivers, "render_testGetNumRenderDrivers", "Tests call to SDL_GetNumRenderDrivers", TEST_ENABLED }; static const SDLTest_TestCaseReference renderTestPrimitives = { render_testPrimitives, "render_testPrimitives", "Tests rendering primitives", TEST_ENABLED }; static const SDLTest_TestCaseReference renderTestPrimitivesWithViewport = { render_testPrimitivesWithViewport, "render_testPrimitivesWithViewport", "Tests rendering primitives within a viewport", TEST_ENABLED }; static const SDLTest_TestCaseReference renderTestBlit = { render_testBlit, "render_testBlit", "Tests blitting", TEST_ENABLED }; static const SDLTest_TestCaseReference renderTestBlitTiled = { render_testBlitTiled, "render_testBlitTiled", "Tests tiled blitting", TEST_ENABLED }; static const SDLTest_TestCaseReference renderTestBlit9Grid = { render_testBlit9Grid, "render_testBlit9Grid", "Tests 9-grid blitting", TEST_ENABLED }; static const SDLTest_TestCaseReference renderTestBlit9GridTiled = { render_testBlit9GridTiled, "render_testBlit9GridTiled", "Tests tiled 9-grid blitting", TEST_ENABLED }; static const SDLTest_TestCaseReference renderTestBlitColor = { render_testBlitColor, "render_testBlitColor", "Tests blitting with color", TEST_ENABLED }; static const SDLTest_TestCaseReference renderTestBlendModes = { render_testBlendModes, "render_testBlendModes", "Tests rendering blend modes", TEST_ENABLED }; static const SDLTest_TestCaseReference renderTestViewport = { render_testViewport, "render_testViewport", "Tests viewport", TEST_ENABLED }; static const SDLTest_TestCaseReference renderTestClipRect = { render_testClipRect, "render_testClipRect", "Tests clip rect", TEST_ENABLED }; static const SDLTest_TestCaseReference renderTestLogicalSize = { render_testLogicalSize, "render_testLogicalSize", "Tests logical size", TEST_ENABLED }; static const SDLTest_TestCaseReference renderTestUVClamping = { render_testUVClamping, "render_testUVClamping", "Tests geometry UV clamping", TEST_ENABLED }; static const SDLTest_TestCaseReference renderTestUVWrapping = { render_testUVWrapping, "render_testUVWrapping", "Tests geometry UV wrapping", TEST_ENABLED }; static const SDLTest_TestCaseReference renderTestTextureState = { render_testTextureState, "render_testTextureState", "Tests texture state changes", TEST_ENABLED }; static const SDLTest_TestCaseReference renderTestGetSetTextureScaleMode = { render_testGetSetTextureScaleMode, "render_testGetSetTextureScaleMode", "Tests setting/getting texture scale mode", TEST_ENABLED }; static const SDLTest_TestCaseReference renderTestRGBSurfaceNoAlpha = { render_testRGBSurfaceNoAlpha, "render_testRGBSurfaceNoAlpha", "Tests RGB surface with no alpha using software renderer", TEST_ENABLED }; static const SDLTest_TestCaseReference renderTestColorspaceLinear = { render_testColorspaceLinear, "render_testColorspaceLinear", "Tests colorspace support (sRGB -> linear)", TEST_ENABLED }; static const SDLTest_TestCaseReference renderTestColorspaceSRGB = { render_testColorspaceSRGB, "render_testColorspaceSRGB", "Tests colorspace support (linear -> sRGB)", TEST_ENABLED }; /* Sequence of Render test cases */ static const SDLTest_TestCaseReference *renderTests[] = { &renderTestGetNumRenderDrivers, &renderTestPrimitives, &renderTestPrimitivesWithViewport, &renderTestBlit, &renderTestBlitTiled, &renderTestBlit9Grid, &renderTestBlit9GridTiled, &renderTestBlitColor, &renderTestBlendModes, &renderTestViewport, &renderTestClipRect, &renderTestLogicalSize, &renderTestUVClamping, &renderTestUVWrapping, &renderTestTextureState, &renderTestGetSetTextureScaleMode, &renderTestRGBSurfaceNoAlpha, &renderTestColorspaceLinear, &renderTestColorspaceSRGB, NULL }; /* Render test suite (global) */ SDLTest_TestSuiteReference renderTestSuite = { "Render", InitCreateRenderer, renderTests, CleanupDestroyRenderer };