this repo has no description
Exposed GPU_FreeRenderer(). Renamed some internal renderer control functions.
+47
-22
+5
-3
include/SDL_gpu.h
+5
-3
include/SDL_gpu.h
···
740
740
/*! Gets an array of identifiers for the active renderers. */
741
741
DECLSPEC void SDLCALL GPU_GetActiveRendererList(GPU_RendererID* renderers_array);
742
742
743
-
/*! \return The renderer matching the given identifier. */
744
-
DECLSPEC GPU_Renderer* SDLCALL GPU_GetRenderer(GPU_RendererID id);
745
-
746
743
/*! \return The current renderer */
747
744
DECLSPEC GPU_Renderer* SDLCALL GPU_GetCurrentRenderer(void);
748
745
749
746
/*! Switches the current renderer to the renderer matching the given identifier. */
750
747
DECLSPEC void SDLCALL GPU_SetCurrentRenderer(GPU_RendererID id);
748
+
749
+
/*! \return The renderer matching the given identifier. */
750
+
DECLSPEC GPU_Renderer* SDLCALL GPU_GetRenderer(GPU_RendererID id);
751
+
752
+
DECLSPEC void SDLCALL GPU_FreeRenderer(GPU_Renderer* renderer);
751
753
752
754
/*! Reapplies the renderer state to the backend API (e.g. OpenGL, Direct3D). Use this if you want SDL_gpu to be able to render after you've used direct backend calls. */
753
755
DECLSPEC void SDLCALL GPU_ResetRendererState(void);
+5
-8
src/SDL_gpu.c
+5
-8
src/SDL_gpu.c
···
28
28
int GPU_strcasecmp(const char* s1, const char* s2);
29
29
30
30
void GPU_InitRendererRegister(void);
31
-
GPU_Renderer* GPU_AddRenderer(GPU_RendererID id);
32
-
void GPU_RemoveRenderer(GPU_RendererID id);
31
+
GPU_Renderer* GPU_CreateAndAddRenderer(GPU_RendererID id);
33
32
34
33
static GPU_Renderer* current_renderer = NULL;
35
34
···
394
393
if(!init_SDL())
395
394
return NULL;
396
395
397
-
renderer = GPU_AddRenderer(renderer_request);
396
+
renderer = GPU_CreateAndAddRenderer(renderer_request);
398
397
if(renderer == NULL)
399
398
return NULL;
400
399
···
500
499
return;
501
500
502
501
current_renderer->impl->Quit(current_renderer);
503
-
GPU_RemoveRenderer(current_renderer->id);
504
-
current_renderer = NULL;
502
+
GPU_FreeRenderer(current_renderer);
505
503
}
506
504
507
505
void GPU_Quit(void)
···
520
518
}
521
519
inited_error_code_stack = 0;
522
520
523
-
// FIXME: Remove all renderers
524
521
if(current_renderer == NULL)
525
522
return;
526
523
527
524
current_renderer->impl->Quit(current_renderer);
528
-
GPU_RemoveRenderer(current_renderer->id);
529
-
current_renderer = NULL;
525
+
GPU_FreeRenderer(current_renderer);
526
+
// FIXME: Free all renderers
530
527
531
528
if(GPU_GetNumActiveRenderers() == 0)
532
529
SDL_Quit();
+37
-11
src/SDL_gpu_renderer.c
+37
-11
src/SDL_gpu_renderer.c
···
140
140
if(i >= MAX_REGISTERED_RENDERERS)
141
141
return;
142
142
143
+
if(id.renderer == GPU_RENDERER_UNKNOWN)
144
+
{
145
+
GPU_PushErrorCode(__func__, GPU_ERROR_USER_ERROR, "Invalid renderer ID");
146
+
return;
147
+
}
148
+
if(create_renderer == NULL)
149
+
{
150
+
GPU_PushErrorCode(__func__, GPU_ERROR_USER_ERROR, "NULL renderer create callback");
151
+
return;
152
+
}
153
+
if(free_renderer == NULL)
154
+
{
155
+
GPU_PushErrorCode(__func__, GPU_ERROR_USER_ERROR, "NULL renderer free callback");
156
+
return;
157
+
}
158
+
143
159
rendererRegister[i].id = id;
144
160
rendererRegister[i].createFn = create_renderer;
145
161
rendererRegister[i].freeFn = free_renderer;
146
162
}
147
163
148
-
void GPU_RegisterRenderers(void)
164
+
void GPU_RegisterBuiltInRenderers(void)
149
165
{
150
166
#ifndef SDL_GPU_DISABLE_OPENGL
151
167
#ifndef SDL_GPU_DISABLE_OPENGL_1_BASE
···
215
231
216
232
initialized = 1;
217
233
218
-
GPU_RegisterRenderers();
234
+
GPU_RegisterBuiltInRenderers();
219
235
}
220
236
221
237
···
324
340
}
325
341
326
342
// Create a new renderer based on a registered id and store it in the map.
327
-
GPU_Renderer* GPU_AddRenderer(GPU_RendererID id)
343
+
GPU_Renderer* GPU_CreateAndAddRenderer(GPU_RendererID id)
328
344
{
329
345
int i;
330
346
for(i = 0; i < MAX_ACTIVE_RENDERERS; i++)
···
349
365
return NULL;
350
366
}
351
367
352
-
void GPU_FreeRenderer(GPU_Renderer* renderer)
368
+
// Free renderer memory according to how the registry instructs
369
+
void GPU_FreeRendererMemory(GPU_Renderer* renderer)
353
370
{
354
371
int i;
372
+
if(renderer == NULL)
373
+
return;
374
+
355
375
for(i = 0; i < MAX_REGISTERED_RENDERERS; i++)
356
376
{
357
377
if(rendererRegister[i].id.renderer == GPU_RENDERER_UNKNOWN)
···
365
385
}
366
386
}
367
387
368
-
// Remove a renderer from the map and free it.
369
-
void GPU_RemoveRenderer(GPU_RendererID id)
388
+
// Remove a renderer from the active map and free it.
389
+
void GPU_FreeRenderer(GPU_Renderer* renderer)
370
390
{
371
391
int i;
392
+
GPU_Renderer* current_renderer;
393
+
394
+
if(renderer == NULL)
395
+
return;
396
+
397
+
current_renderer = GPU_GetCurrentRenderer();
398
+
if(current_renderer == renderer)
399
+
current_renderer = NULL;
400
+
372
401
for(i = 0; i < MAX_ACTIVE_RENDERERS; i++)
373
402
{
374
-
if(rendererMap[i] == NULL)
375
-
continue;
376
-
377
-
if(id.renderer == rendererMap[i]->id.renderer)
403
+
if(renderer == rendererMap[i])
378
404
{
379
-
GPU_FreeRenderer(rendererMap[i]);
405
+
GPU_FreeRendererMemory(renderer);
380
406
rendererMap[i] = NULL;
381
407
return;
382
408
}