Removed width/height parameters from LoadTexture()

slouken · slouken · commit efe122be4dfa · 2025-03-14T11:38:13.000-07:00
You can directly access the texture width and height now.
diff --git a/VisualC-GDK/tests/testgdk/src/testgdk.cpp b/VisualC-GDK/tests/testgdk/src/testgdk.cpp
@@ -56,8 +56,7 @@ static struct
 static SDL_AudioStream *stream;
 
 /* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
-static void
-quit(int rc)
+static void quit(int rc)
 {
     SDL_free(sprites);
     SDL_DestroyAudioStream(stream);
@@ -80,8 +79,7 @@ static int fillerup(void)
     return 0;
 }
 
-void
-UserLoggedIn(XUserHandle user)
+static void UserLoggedIn(XUserHandle user)
 {
     HRESULT hr;
     char gamertag[128];
@@ -96,8 +94,7 @@ UserLoggedIn(XUserHandle user)
     XUserCloseHandle(user);
 }
 
-void
-AddUserUICallback(XAsyncBlock *asyncBlock)
+static void AddUserUICallback(XAsyncBlock *asyncBlock)
 {
     HRESULT hr;
     XUserHandle user = NULL;
@@ -123,8 +120,7 @@ AddUserUICallback(XAsyncBlock *asyncBlock)
     delete asyncBlock;
 }
 
-void
-AddUserUI()
+static void AddUserUI()
 {
     HRESULT hr;
     XAsyncBlock *asyncBlock = new XAsyncBlock;
@@ -141,8 +137,7 @@ AddUserUI()
     }
 }
 
-void
-AddUserSilentCallback(XAsyncBlock *asyncBlock)
+static void AddUserSilentCallback(XAsyncBlock *asyncBlock)
 {
     HRESULT hr;
     XUserHandle user = NULL;
@@ -168,8 +163,7 @@ AddUserSilentCallback(XAsyncBlock *asyncBlock)
     delete asyncBlock;
 }
 
-void
-AddUserSilent()
+static void AddUserSilent()
 {
     HRESULT hr;
     XAsyncBlock *asyncBlock = new XAsyncBlock;
@@ -186,30 +180,27 @@ AddUserSilent()
     }
 }
 
-int
-LoadSprite(const char *file)
+static bool LoadSprite(const char *file)
 {
     int i;
 
     for (i = 0; i < state->num_windows; ++i) {
         /* This does the SDL_LoadBMP step repeatedly, but that's OK for test code. */
-        sprites[i] = LoadTexture(state->renderers[i], file, true, &sprite_w, &sprite_h);
+        sprites[i] = LoadTexture(state->renderers[i], file, true);
         if (!sprites[i]) {
-            return -1;
-        }
-        if (!SDL_SetTextureBlendMode(sprites[i], blendMode)) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't set blend mode: %s", SDL_GetError());
-            SDL_DestroyTexture(sprites[i]);
-            return -1;
+            return false;
         }
+        sprite_w = sprites[i]->w;
+        sprite_h = sprites[i]->h;
+
+        SDL_SetTextureBlendMode(sprites[i], blendMode);
     }
 
     /* We're ready to roll. :) */
-    return 0;
+    return true;
 }
 
-void
-DrawSprites(SDL_Renderer * renderer, SDL_Texture * sprite)
+static void DrawSprites(SDL_Renderer * renderer, SDL_Texture * sprite)
 {
     SDL_Rect viewport;
     SDL_FRect temp;
@@ -300,8 +291,7 @@ DrawSprites(SDL_Renderer * renderer, SDL_Texture * sprite)
     SDL_RenderPresent(renderer);
 }
 
-void
-loop()
+static void loop()
 {
     int i;
     SDL_Event event;
@@ -329,8 +319,7 @@ loop()
     fillerup();
 }
 
-int
-main(int argc, char *argv[])
+int main(int argc, char *argv[])
 {
     int i;
     const char *icon = "icon.bmp";
@@ -413,7 +402,7 @@ main(int argc, char *argv[])
         SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
         SDL_RenderClear(renderer);
     }
-    if (LoadSprite(icon) < 0) {
+    if (!LoadSprite(icon)) {
         quit(2);
     }
 
diff --git a/test/testaudio.c b/test/testaudio.c
@@ -718,16 +718,15 @@ static Texture *CreateTexture(const char *fname)
     if (!tex) {
         SDL_Log("Out of memory!");
     } else {
-        int texw, texh;
-        tex->texture = LoadTexture(state->renderers[0], fname, true, &texw, &texh);
+        tex->texture = LoadTexture(state->renderers[0], fname, true);
         if (!tex->texture) {
             SDL_Log("Failed to load '%s': %s", fname, SDL_GetError());
             SDL_free(tex);
             return NULL;
         }
         SDL_SetTextureBlendMode(tex->texture, SDL_BLENDMODE_BLEND);
-        tex->w = (float) texw;
-        tex->h = (float) texh;
+        tex->w = (float)tex->texture->w;
+        tex->h = (float)tex->texture->h;
     }
     return tex;
 }
diff --git a/test/testgeometry.c b/test/testgeometry.c
@@ -28,7 +28,6 @@ static bool use_texture = false;
 static SDL_Texture **sprites;
 static SDL_BlendMode blendMode = SDL_BLENDMODE_NONE;
 static float angle = 0.0f;
-static int sprite_w, sprite_h;
 static int translate_cx = 0;
 static int translate_cy = 0;
 
@@ -52,7 +51,7 @@ static int LoadSprite(const char *file)
 
     for (i = 0; i < state->num_windows; ++i) {
         /* This does the SDL_LoadBMP step repeatedly, but that's OK for test code. */
-        sprites[i] = LoadTexture(state->renderers[i], file, true, &sprite_w, &sprite_h);
+        sprites[i] = LoadTexture(state->renderers[i], file, true);
         if (!sprites[i]) {
             return -1;
         }
diff --git a/test/testgpurender_effects.c b/test/testgpurender_effects.c
@@ -263,13 +263,13 @@ SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[])
         return SDL_APP_FAILURE;
     }
 
-    background = LoadTexture(renderer, "sample.bmp", false, NULL, NULL);
+    background = LoadTexture(renderer, "sample.bmp", false);
     if (!background) {
         SDL_Log("Couldn't create background: %s", SDL_GetError());
         return SDL_APP_FAILURE;
     }
 
-    sprite = LoadTexture(renderer, "icon.bmp", true, NULL, NULL);
+    sprite = LoadTexture(renderer, "icon.bmp", true);
     if (!sprite) {
         SDL_Log("Couldn't create sprite: %s", SDL_GetError());
         return SDL_APP_FAILURE;
diff --git a/test/testgpurender_msdf.c b/test/testgpurender_msdf.c
@@ -55,7 +55,7 @@ static GlyphInfo glyphs[128];
 
 static bool LoadFontTexture(void)
 {
-    font_texture = LoadTexture(renderer, "msdf_font.bmp", false, NULL, NULL);
+    font_texture = LoadTexture(renderer, "msdf_font.bmp", false);
     if (!font_texture) {
         SDL_Log("Failed to create font texture: %s", SDL_GetError());
         return false;
diff --git a/test/testime.c b/test/testime.c
@@ -987,18 +987,19 @@ int main(int argc, char *argv[])
         WindowState *ctx = &windowstate[i];
         SDL_Window *window = state->windows[i];
         SDL_Renderer *renderer = state->renderers[i];
-        int icon_w = 0, icon_h = 0;
 
         SDL_SetRenderLogicalPresentation(renderer, WINDOW_WIDTH, WINDOW_HEIGHT, SDL_LOGICAL_PRESENTATION_LETTERBOX);
 
         ctx->window = window;
         ctx->renderer = renderer;
         ctx->rendererID = i;
-        ctx->settings_icon = LoadTexture(renderer, "icon.bmp", true, &icon_w, &icon_h);
-        ctx->settings_rect.x = (float)WINDOW_WIDTH - icon_w - MARGIN;
-        ctx->settings_rect.y = MARGIN;
-        ctx->settings_rect.w = (float)icon_w;
-        ctx->settings_rect.h = (float)icon_h;
+        ctx->settings_icon = LoadTexture(renderer, "icon.bmp", true);
+        if (ctx->settings_icon) {
+            ctx->settings_rect.w = (float)ctx->settings_icon->w;
+            ctx->settings_rect.h = (float)ctx->settings_icon->h;
+            ctx->settings_rect.x = (float)WINDOW_WIDTH - ctx->settings_rect.w - MARGIN;
+            ctx->settings_rect.y = MARGIN;
+        }
 
         InitInput(ctx);
 
diff --git a/test/testnative.c b/test/testnative.c
@@ -168,7 +168,7 @@ int main(int argc, char *argv[])
     SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
     SDL_RenderClear(renderer);
 
-    sprite = LoadTexture(renderer, "icon.bmp", true, NULL, NULL);
+    sprite = LoadTexture(renderer, "icon.bmp", true);
     if (!sprite) {
         quit(6);
     }
diff --git a/test/testrendercopyex.c b/test/testrendercopyex.c
@@ -135,8 +135,8 @@ int main(int argc, char *argv[])
 
         drawstate->window = state->windows[i];
         drawstate->renderer = state->renderers[i];
-        drawstate->sprite = LoadTexture(drawstate->renderer, "icon.bmp", true, NULL, NULL);
-        drawstate->background = LoadTexture(drawstate->renderer, "sample.bmp", false, NULL, NULL);
+        drawstate->sprite = LoadTexture(drawstate->renderer, "icon.bmp", true);
+        drawstate->background = LoadTexture(drawstate->renderer, "sample.bmp", false);
         if (!drawstate->sprite || !drawstate->background) {
             quit(2);
         }
diff --git a/test/testrendertarget.c b/test/testrendertarget.c
@@ -253,11 +253,11 @@ int main(int argc, char *argv[])
         drawstate->window = state->windows[i];
         drawstate->renderer = state->renderers[i];
         if (test_composite) {
-            drawstate->sprite = LoadTexture(drawstate->renderer, "icon-alpha.bmp", true, NULL, NULL);
+            drawstate->sprite = LoadTexture(drawstate->renderer, "icon-alpha.bmp", true);
         } else {
-            drawstate->sprite = LoadTexture(drawstate->renderer, "icon.bmp", true, NULL, NULL);
+            drawstate->sprite = LoadTexture(drawstate->renderer, "icon.bmp", true);
         }
-        drawstate->background = LoadTexture(drawstate->renderer, "sample.bmp", false, NULL, NULL);
+        drawstate->background = LoadTexture(drawstate->renderer, "sample.bmp", false);
         if (!drawstate->sprite || !drawstate->background) {
             quit(2);
         }
diff --git a/test/testscale.c b/test/testscale.c
@@ -126,8 +126,8 @@ int main(int argc, char *argv[])
 
         drawstate->window = state->windows[i];
         drawstate->renderer = state->renderers[i];
-        drawstate->sprite = LoadTexture(drawstate->renderer, "icon.bmp", true, NULL, NULL);
-        drawstate->background = LoadTexture(drawstate->renderer, "sample.bmp", false, NULL, NULL);
+        drawstate->sprite = LoadTexture(drawstate->renderer, "icon.bmp", true);
+        drawstate->background = LoadTexture(drawstate->renderer, "sample.bmp", false);
         if (!drawstate->sprite || !drawstate->background) {
             quit(2);
         }
diff --git a/test/testsprite.c b/test/testsprite.c
@@ -53,16 +53,18 @@ void SDL_AppQuit(void *appstate, SDL_AppResult result)
 
 static int LoadSprite(const char *file)
 {
-    int i, w, h;
+    int i;
 
     for (i = 0; i < state->num_windows; ++i) {
         /* This does the SDL_LoadBMP step repeatedly, but that's OK for test code. */
         if (sprites[i]) {
             SDL_DestroyTexture(sprites[i]);
         }
-        sprites[i] = LoadTexture(state->renderers[i], file, true, &w, &h);
-        sprite_w = (float)w;
-        sprite_h = (float)h;
+        sprites[i] = LoadTexture(state->renderers[i], file, true);
+        if (sprites[i]) {
+            sprite_w = (float)sprites[i]->w;
+            sprite_h = (float)sprites[i]->h;
+        }
         if (!sprites[i]) {
             return -1;
         }
diff --git a/test/testutils.c b/test/testutils.c
@@ -72,7 +72,7 @@ char *GetResourceFilename(const char *user_specified, const char *def)
  *
  * If height_out is non-NULL, set it to the texture height.
  */
-SDL_Texture *LoadTexture(SDL_Renderer *renderer, const char *file, bool transparent, int *width_out, int *height_out)
+SDL_Texture *LoadTexture(SDL_Renderer *renderer, const char *file, bool transparent)
 {
     SDL_Surface *temp = NULL;
     SDL_Texture *texture = NULL;
@@ -117,14 +117,6 @@ SDL_Texture *LoadTexture(SDL_Renderer *renderer, const char *file, bool transpar
             }
         }
 
-        if (width_out) {
-            *width_out = temp->w;
-        }
-
-        if (height_out) {
-            *height_out = temp->h;
-        }
-
         texture = SDL_CreateTextureFromSurface(renderer, temp);
         if (!texture) {
             SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create texture: %s", SDL_GetError());
diff --git a/test/testutils.h b/test/testutils.h
@@ -16,8 +16,7 @@
 
 #include <SDL3/SDL.h>
 
-SDL_Texture *LoadTexture(SDL_Renderer *renderer, const char *file, bool transparent,
-                         int *width_out, int *height_out);
+SDL_Texture *LoadTexture(SDL_Renderer *renderer, const char *file, bool transparent);
 char *GetNearbyFilename(const char *file);
 char *GetResourceFilename(const char *user_specified, const char *def);
 
diff --git a/test/testviewport.c b/test/testviewport.c
@@ -31,7 +31,6 @@ static bool use_target = false;
 static Uint32 wait_start;
 #endif
 static SDL_Texture *sprite;
-static int sprite_w, sprite_h;
 
 /* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
 static void
@@ -184,8 +183,7 @@ int main(int argc, char *argv[])
         quit(2);
     }
 
-    sprite = LoadTexture(state->renderers[0], "icon.bmp", true, &sprite_w, &sprite_h);
-
+    sprite = LoadTexture(state->renderers[0], "icon.bmp", true);
     if (!sprite) {
         quit(2);
     }

Original file line number	Diff line number	Diff line change
`@@ -56,8 +56,7 @@ static struct`
`56`	`56`	`static SDL_AudioStream *stream;`
`57`	`57`
`58`	`58`	`/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */`
`59`		`-static void`
`60`		`-quit(int rc)`
	`59`	`+static void quit(int rc)`
`61`	`60`	`{`
`62`	`61`	`SDL_free(sprites);`
`63`	`62`	`SDL_DestroyAudioStream(stream);`
`@@ -80,8 +79,7 @@ static int fillerup(void)`
`80`	`79`	`return 0;`
`81`	`80`	`}`
`82`	`81`
`83`		`-void`
`84`		`-UserLoggedIn(XUserHandle user)`
	`82`	`+static void UserLoggedIn(XUserHandle user)`
`85`	`83`	`{`
`86`	`84`	`HRESULT hr;`
`87`	`85`	`char gamertag[128];`
`@@ -96,8 +94,7 @@ UserLoggedIn(XUserHandle user)`
`96`	`94`	`XUserCloseHandle(user);`
`97`	`95`	`}`
`98`	`96`
`99`		`-void`
`100`		`-AddUserUICallback(XAsyncBlock *asyncBlock)`
	`97`	`+static void AddUserUICallback(XAsyncBlock *asyncBlock)`
`101`	`98`	`{`
`102`	`99`	`HRESULT hr;`
`103`	`100`	`XUserHandle user = NULL;`
`@@ -123,8 +120,7 @@ AddUserUICallback(XAsyncBlock *asyncBlock)`
`123`	`120`	`delete asyncBlock;`
`124`	`121`	`}`
`125`	`122`
`126`		`-void`
`127`		`-AddUserUI()`
	`123`	`+static void AddUserUI()`
`128`	`124`	`{`
`129`	`125`	`HRESULT hr;`
`130`	`126`	`XAsyncBlock *asyncBlock = new XAsyncBlock;`
`@@ -141,8 +137,7 @@ AddUserUI()`
`141`	`137`	`}`
`142`	`138`	`}`
`143`	`139`
`144`		`-void`
`145`		`-AddUserSilentCallback(XAsyncBlock *asyncBlock)`
	`140`	`+static void AddUserSilentCallback(XAsyncBlock *asyncBlock)`
`146`	`141`	`{`
`147`	`142`	`HRESULT hr;`
`148`	`143`	`XUserHandle user = NULL;`
`@@ -168,8 +163,7 @@ AddUserSilentCallback(XAsyncBlock *asyncBlock)`
`168`	`163`	`delete asyncBlock;`
`169`	`164`	`}`
`170`	`165`
`171`		`-void`
`172`		`-AddUserSilent()`
	`166`	`+static void AddUserSilent()`
`173`	`167`	`{`
`174`	`168`	`HRESULT hr;`
`175`	`169`	`XAsyncBlock *asyncBlock = new XAsyncBlock;`
`@@ -186,30 +180,27 @@ AddUserSilent()`
`186`	`180`	`}`
`187`	`181`	`}`
`188`	`182`
`189`		`-int`
`190`		`-LoadSprite(const char *file)`
	`183`	`+static bool LoadSprite(const char *file)`
`191`	`184`	`{`
`192`	`185`	`int i;`
`193`	`186`
`194`	`187`	`for (i = 0; i < state->num_windows; ++i) {`
`195`	`188`	`/* This does the SDL_LoadBMP step repeatedly, but that's OK for test code. */`
`196`		`- sprites[i] = LoadTexture(state->renderers[i], file, true, &sprite_w, &sprite_h);`
	`189`	`+ sprites[i] = LoadTexture(state->renderers[i], file, true);`
`197`	`190`	`if (!sprites[i]) {`
`198`		`- return -1;`
`199`		`- }`
`200`		`- if (!SDL_SetTextureBlendMode(sprites[i], blendMode)) {`
`201`		`- SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't set blend mode: %s", SDL_GetError());`
`202`		`- SDL_DestroyTexture(sprites[i]);`
`203`		`- return -1;`
	`191`	`+ return false;`
`204`	`192`	`}`
	`193`	`+ sprite_w = sprites[i]->w;`
	`194`	`+ sprite_h = sprites[i]->h;`
	`195`	`+`
	`196`	`+ SDL_SetTextureBlendMode(sprites[i], blendMode);`
`205`	`197`	`}`
`206`	`198`
`207`	`199`	`/* We're ready to roll. :) */`
`208`		`- return 0;`
	`200`	`+ return true;`
`209`	`201`	`}`
`210`	`202`
`211`		`-void`
`212`		`-DrawSprites(SDL_Renderer * renderer, SDL_Texture * sprite)`
	`203`	`+static void DrawSprites(SDL_Renderer * renderer, SDL_Texture * sprite)`
`213`	`204`	`{`
`214`	`205`	`SDL_Rect viewport;`
`215`	`206`	`SDL_FRect temp;`
`@@ -300,8 +291,7 @@ DrawSprites(SDL_Renderer * renderer, SDL_Texture * sprite)`
`300`	`291`	`SDL_RenderPresent(renderer);`
`301`	`292`	`}`
`302`	`293`
`303`		`-void`
`304`		`-loop()`
	`294`	`+static void loop()`
`305`	`295`	`{`
`306`	`296`	`int i;`
`307`	`297`	`SDL_Event event;`
`@@ -329,8 +319,7 @@ loop()`
`329`	`319`	`fillerup();`
`330`	`320`	`}`
`331`	`321`
`332`		`-int`
`333`		`-main(int argc, char *argv[])`
	`322`	`+int main(int argc, char *argv[])`
`334`	`323`	`{`
`335`	`324`	`int i;`
`336`	`325`	`const char *icon = "icon.bmp";`
`@@ -413,7 +402,7 @@ main(int argc, char *argv[])`
`413`	`402`	`SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);`
`414`	`403`	`SDL_RenderClear(renderer);`
`415`	`404`	`}`
`416`		`- if (LoadSprite(icon) < 0) {`
	`405`	`+ if (!LoadSprite(icon)) {`
`417`	`406`	`quit(2);`
`418`	`407`	`}`
`419`	`408`
Original file line number	Diff line number	Diff line change
`@@ -263,13 +263,13 @@ SDL_AppResult SDL_AppInit(void *appstate, int argc, char argv[])`
`263`	`263`	`return SDL_APP_FAILURE;`
`264`	`264`	`}`
`265`	`265`
`266`		`- background = LoadTexture(renderer, "sample.bmp", false, NULL, NULL);`
	`266`	`+ background = LoadTexture(renderer, "sample.bmp", false);`
`267`	`267`	`if (!background) {`
`268`	`268`	`SDL_Log("Couldn't create background: %s", SDL_GetError());`
`269`	`269`	`return SDL_APP_FAILURE;`
`270`	`270`	`}`
`271`	`271`
`272`		`- sprite = LoadTexture(renderer, "icon.bmp", true, NULL, NULL);`
	`272`	`+ sprite = LoadTexture(renderer, "icon.bmp", true);`
`273`	`273`	`if (!sprite) {`
`274`	`274`	`SDL_Log("Couldn't create sprite: %s", SDL_GetError());`
`275`	`275`	`return SDL_APP_FAILURE;`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ static GlyphInfo glyphs[128];`
`55`	`55`
`56`	`56`	`static bool LoadFontTexture(void)`
`57`	`57`	`{`
`58`		`- font_texture = LoadTexture(renderer, "msdf_font.bmp", false, NULL, NULL);`
	`58`	`+ font_texture = LoadTexture(renderer, "msdf_font.bmp", false);`
`59`	`59`	`if (!font_texture) {`
`60`	`60`	`SDL_Log("Failed to create font texture: %s", SDL_GetError());`
`61`	`61`	`return false;`
Original file line number	Diff line number	Diff line change
`@@ -168,7 +168,7 @@ int main(int argc, char *argv[])`
`168`	`168`	`SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);`
`169`	`169`	`SDL_RenderClear(renderer);`
`170`	`170`
`171`		`- sprite = LoadTexture(renderer, "icon.bmp", true, NULL, NULL);`
	`171`	`+ sprite = LoadTexture(renderer, "icon.bmp", true);`
`172`	`172`	`if (!sprite) {`
`173`	`173`	`quit(6);`
`174`	`174`	`}`