this repo has no description
Made GPU_Quit() reset some static globals. Fixed GPU_FreeRenderer() so it does actually unset the current renderer.
+74
-36
+30
-17
src/SDL_gpu.c
+30
-17
src/SDL_gpu.c
···
1
1
#include "SDL_gpu.h"
2
2
#include "SDL_gpu_RendererImpl.h"
3
3
#include "SDL_platform.h"
4
+
#include "stb_image.h"
5
+
#include "stb_image_write.h"
4
6
#include <stdlib.h>
5
7
#include <string.h>
6
8
···
31
33
int gpu_strcasecmp(const char* s1, const char* s2);
32
34
33
35
void gpu_init_renderer_register(void);
36
+
void gpu_free_renderer_register(void);
34
37
GPU_Renderer* gpu_create_and_add_renderer(GPU_RendererID id);
38
+
39
+
int gpu_default_print(GPU_LogLevelEnum log_level, const char* format, va_list args);
40
+
41
+
/*! A mapping of windowID to a GPU_Target to facilitate GPU_GetWindowTarget(). */
42
+
typedef struct GPU_WindowMapping
43
+
{
44
+
Uint32 windowID;
45
+
GPU_Target* target;
46
+
} GPU_WindowMapping;
35
47
36
48
static GPU_Renderer* _gpu_current_renderer = NULL;
37
49
···
44
56
static unsigned int _gpu_num_error_codes = 0;
45
57
static unsigned int _gpu_error_code_stack_size = GPU_DEFAULT_MAX_NUM_ERRORS;
46
58
47
-
/*! A mapping of windowID to a GPU_Target to facilitate GPU_GetWindowTarget(). */
48
-
typedef struct GPU_WindowMapping
49
-
{
50
-
Uint32 windowID;
51
-
GPU_Target* target;
52
-
} GPU_WindowMapping;
53
-
54
59
#define GPU_INITIAL_WINDOW_MAPPINGS_SIZE 10
55
60
static GPU_WindowMapping* _gpu_window_mappings = NULL;
56
61
static int _gpu_window_mappings_size = 0;
57
62
static int _gpu_num_window_mappings = 0;
58
63
64
+
static Uint32 _gpu_init_windowID = 0;
65
+
66
+
static GPU_InitFlagEnum _gpu_preinit_flags = GPU_DEFAULT_INIT_FLAGS;
67
+
static GPU_InitFlagEnum _gpu_required_features = 0;
68
+
69
+
static int (*_gpu_print)(GPU_LogLevelEnum log_level, const char* format, va_list args) = &gpu_default_print;
70
+
59
71
60
72
SDL_version GPU_GetLinkedVersion(void)
61
73
{
···
132
144
}
133
145
}
134
146
135
-
static int (*_gpu_print)(GPU_LogLevelEnum log_level, const char* format, va_list args) = &gpu_default_print;
136
-
137
147
void GPU_SetLogCallback(int (*callback)(GPU_LogLevelEnum log_level, const char* format, va_list args))
138
148
{
139
149
if(callback == NULL)
···
194
204
return 1;
195
205
}
196
206
197
-
static Uint32 _gpu_init_windowID = 0;
198
-
199
207
void GPU_SetInitWindow(Uint32 windowID)
200
208
{
201
209
_gpu_init_windowID = windowID;
···
205
213
{
206
214
return _gpu_init_windowID;
207
215
}
208
-
209
-
static GPU_InitFlagEnum _gpu_preinit_flags = GPU_DEFAULT_INIT_FLAGS;
210
-
static GPU_InitFlagEnum _gpu_required_features = 0;
211
216
212
217
void GPU_SetPreInitFlags(GPU_InitFlagEnum GPU_flags)
213
218
{
···
628
633
_gpu_current_renderer->impl->Quit(_gpu_current_renderer);
629
634
GPU_FreeRenderer(_gpu_current_renderer);
630
635
// FIXME: Free all renderers
636
+
_gpu_current_renderer = NULL;
637
+
638
+
_gpu_init_windowID = 0;
639
+
640
+
// Free window mappings
641
+
SDL_free(_gpu_window_mappings);
642
+
_gpu_window_mappings = NULL;
643
+
_gpu_window_mappings_size = 0;
644
+
_gpu_num_window_mappings = 0;
631
645
632
646
if(GPU_GetNumActiveRenderers() == 0)
633
647
SDL_Quit();
648
+
649
+
gpu_free_renderer_register();
634
650
}
635
651
636
652
void GPU_SetDebugLevel(GPU_DebugLevelEnum level)
···
989
1005
990
1006
return result;
991
1007
}
992
-
993
-
#include "stb_image.h"
994
-
#include "stb_image_write.h"
995
1008
996
1009
// From http://stackoverflow.com/questions/5309471/getting-file-extension-in-c
997
1010
static const char *get_filename_ext(const char *filename)
+37
-12
src/SDL_gpu_renderer.c
+37
-12
src/SDL_gpu_renderer.c
···
11
11
#define GPU_MAX_ACTIVE_RENDERERS 20
12
12
#define GPU_MAX_REGISTERED_RENDERERS 10
13
13
14
+
void gpu_init_renderer_register(void);
15
+
void gpu_free_renderer_register(void);
16
+
14
17
typedef struct GPU_RendererRegistration
15
18
{
16
19
GPU_RendererID id;
···
23
26
static GPU_Renderer* _gpu_renderer_map[GPU_MAX_ACTIVE_RENDERERS];
24
27
static GPU_RendererRegistration _gpu_renderer_register[GPU_MAX_REGISTERED_RENDERERS];
25
28
29
+
static int _gpu_renderer_order_size = 0;
30
+
static GPU_RendererID _gpu_renderer_order[GPU_RENDERER_ORDER_MAX];
31
+
26
32
27
33
28
34
29
-
void gpu_init_renderer_register(void);
30
35
31
36
32
37
GPU_RendererEnum GPU_ReserveNextRendererEnum(void)
···
211
216
212
217
}
213
218
214
-
215
-
static int renderer_order_size = 0;
216
-
static GPU_RendererID renderer_order[GPU_RENDERER_ORDER_MAX];
217
-
218
219
void gpu_init_renderer_register(void)
219
220
{
220
221
int i;
···
234
235
_gpu_renderer_map[i] = NULL;
235
236
}
236
237
237
-
GPU_GetDefaultRendererOrder(&renderer_order_size, renderer_order);
238
+
GPU_GetDefaultRendererOrder(&_gpu_renderer_order_size, _gpu_renderer_order);
238
239
239
240
_gpu_renderer_register_is_initialized = 1;
240
241
241
242
gpu_register_built_in_renderers();
242
243
}
243
244
245
+
void gpu_free_renderer_register(void)
246
+
{
247
+
int i;
248
+
249
+
for(i = 0; i < GPU_MAX_REGISTERED_RENDERERS; i++)
250
+
{
251
+
_gpu_renderer_register[i].id.name = "Unknown";
252
+
_gpu_renderer_register[i].id.renderer = GPU_RENDERER_UNKNOWN;
253
+
_gpu_renderer_register[i].createFn = NULL;
254
+
_gpu_renderer_register[i].freeFn = NULL;
255
+
}
256
+
for(i = 0; i < GPU_MAX_ACTIVE_RENDERERS; i++)
257
+
{
258
+
_gpu_renderer_map[i] = NULL;
259
+
}
260
+
261
+
_gpu_renderer_register_is_initialized = 0;
262
+
_gpu_renderer_order_size = 0;
263
+
}
264
+
244
265
245
266
void GPU_GetRendererOrder(int* order_size, GPU_RendererID* order)
246
267
{
247
268
if(order_size != NULL)
248
-
*order_size = renderer_order_size;
269
+
*order_size = _gpu_renderer_order_size;
249
270
250
-
if(order != NULL && renderer_order_size > 0)
251
-
memcpy(order, renderer_order, renderer_order_size*sizeof(GPU_RendererID));
271
+
if(order != NULL && _gpu_renderer_order_size > 0)
272
+
memcpy(order, _gpu_renderer_order, _gpu_renderer_order_size*sizeof(GPU_RendererID));
252
273
}
253
274
254
275
void GPU_SetRendererOrder(int order_size, GPU_RendererID* order)
···
272
293
order_size = GPU_RENDERER_ORDER_MAX;
273
294
}
274
295
275
-
memcpy(renderer_order, order, order_size*sizeof(GPU_RendererID));
276
-
renderer_order_size = order_size;
296
+
memcpy(_gpu_renderer_order, order, order_size*sizeof(GPU_RendererID));
297
+
_gpu_renderer_order_size = order_size;
277
298
}
278
299
279
300
···
342
363
int i;
343
364
gpu_init_renderer_register();
344
365
366
+
// Invalid enum?
367
+
if(id.renderer == GPU_RENDERER_UNKNOWN)
368
+
return NULL;
369
+
345
370
for(i = 0; i < GPU_MAX_ACTIVE_RENDERERS; i++)
346
371
{
347
372
if(_gpu_renderer_map[i] == NULL)
···
412
437
413
438
current_renderer = GPU_GetCurrentRenderer();
414
439
if(current_renderer == renderer)
415
-
current_renderer = NULL;
440
+
GPU_SetCurrentRenderer(GPU_MakeRendererID("Unknown", GPU_RENDERER_UNKNOWN, 0, 0));
416
441
417
442
for(i = 0; i < GPU_MAX_ACTIVE_RENDERERS; i++)
418
443
{
+7
-7
src/renderer_GL_common.inl
+7
-7
src/renderer_GL_common.inl
···
93
93
#endif
94
94
95
95
96
+
// Workaround for Intel HD glVertexAttrib() bug.
97
+
#ifdef SDL_GPU_USE_OPENGL
98
+
// FIXME: This should probably exist in context storage, as I expect it to be a problem across contexts.
99
+
static Uint8 apply_Intel_attrib_workaround = 0;
100
+
static Uint8 vendor_is_Intel = 0;
101
+
#endif
102
+
96
103
97
104
98
105
static SDL_PixelFormat* AllocFormat(GLenum glFormat);
···
816
823
}
817
824
#endif
818
825
819
-
820
-
// Workaround for Intel HD glVertexAttrib() bug.
821
-
#ifdef SDL_GPU_USE_OPENGL
822
-
// FIXME: This should probably exist in context storage, as I expect it to be a problem across contexts.
823
-
static Uint8 apply_Intel_attrib_workaround = 0;
824
-
static Uint8 vendor_is_Intel = 0;
825
-
#endif
826
826
827
827
static GPU_Target* Init(GPU_Renderer* renderer, GPU_RendererID renderer_request, Uint16 w, Uint16 h, GPU_WindowFlagEnum SDL_flags)
828
828
{