this repo has no description
Removed GPU_GetRendererEnumString(). Added name to GPU_RendererID and changed 'id' to 'renderer'. Changed GPU_GetRendererID() to GPU_GetRendererIDByIndex() and made GPU_GetRendererID() accept an enum value instead. Made GPU_InitRenderer() use GPU_GetRendererID() so it passes the right id values.
+83
-85
+1
-1
SDL_gpu/GLES_1/SDL_gpu_GLES_1.c
+1
-1
SDL_gpu/GLES_1/SDL_gpu_GLES_1.c
+1
-1
SDL_gpu/GLES_2/SDL_gpu_GLES_2.c
+1
-1
SDL_gpu/GLES_2/SDL_gpu_GLES_2.c
+1
-1
SDL_gpu/OpenGL_1/SDL_gpu_OpenGL_1.c
+1
-1
SDL_gpu/OpenGL_1/SDL_gpu_OpenGL_1.c
···
33
33
memset(renderer, 0, sizeof(GPU_Renderer));
34
34
35
35
renderer->id = request;
36
-
renderer->id.id = GPU_RENDERER_OPENGL_1;
36
+
renderer->id.renderer = GPU_RENDERER_OPENGL_1;
37
37
renderer->shader_language = GPU_LANGUAGE_GLSL;
38
38
renderer->shader_version = SDL_GPU_GLSL_VERSION;
39
39
+1
-1
SDL_gpu/OpenGL_1_BASE/SDL_gpu_OpenGL_1_BASE.c
+1
-1
SDL_gpu/OpenGL_1_BASE/SDL_gpu_OpenGL_1_BASE.c
+1
-1
SDL_gpu/OpenGL_2/SDL_gpu_OpenGL_2.c
+1
-1
SDL_gpu/OpenGL_2/SDL_gpu_OpenGL_2.c
···
31
31
memset(renderer, 0, sizeof(GPU_Renderer));
32
32
33
33
renderer->id = request;
34
-
renderer->id.id = GPU_RENDERER_OPENGL_2;
34
+
renderer->id.renderer = GPU_RENDERER_OPENGL_2;
35
35
renderer->shader_language = GPU_LANGUAGE_GLSL;
36
36
renderer->shader_version = SDL_GPU_GLSL_VERSION;
37
37
+1
-1
SDL_gpu/OpenGL_3/SDL_gpu_OpenGL_3.c
+1
-1
SDL_gpu/OpenGL_3/SDL_gpu_OpenGL_3.c
···
31
31
memset(renderer, 0, sizeof(GPU_Renderer));
32
32
33
33
renderer->id = request;
34
-
renderer->id.id = GPU_RENDERER_OPENGL_3;
34
+
renderer->id.renderer = GPU_RENDERER_OPENGL_3;
35
35
renderer->shader_language = GPU_LANGUAGE_GLSL;
36
36
renderer->shader_version = SDL_GPU_GLSL_VERSION;
37
37
+4
-3
SDL_gpu/SDL_gpu.c
+4
-3
SDL_gpu/SDL_gpu.c
···
372
372
373
373
GPU_Target* GPU_InitRenderer(GPU_RendererEnum renderer_enum, Uint16 w, Uint16 h, GPU_WindowFlagEnum SDL_flags)
374
374
{
375
-
return GPU_InitRendererByID(GPU_MakeRendererID(renderer_enum, 0, 0), w, h, SDL_flags);
375
+
// Search registry for this renderer and use that id
376
+
return GPU_InitRendererByID(GPU_GetRendererID(renderer_enum), w, h, SDL_flags);
376
377
}
377
378
378
379
GPU_Target* GPU_InitRendererByID(GPU_RendererID renderer_request, Uint16 w, Uint16 h, GPU_WindowFlagEnum SDL_flags)
···
652
653
return c;
653
654
}
654
655
655
-
GPU_RendererID GPU_MakeRendererID(GPU_RendererEnum id, int major_version, int minor_version)
656
+
GPU_RendererID GPU_MakeRendererID(const char* name, GPU_RendererEnum renderer, int major_version, int minor_version)
656
657
{
657
-
GPU_RendererID r = {id, major_version, minor_version, -1};
658
+
GPU_RendererID r = {name, renderer, major_version, minor_version, -1};
658
659
return r;
659
660
}
660
661
+7
-6
SDL_gpu/SDL_gpu.h
+7
-6
SDL_gpu/SDL_gpu.h
···
88
88
*/
89
89
typedef struct GPU_RendererID
90
90
{
91
-
GPU_RendererEnum id;
91
+
const char* name;
92
+
GPU_RendererEnum renderer;
92
93
int major_version;
93
94
int minor_version;
94
95
···
695
696
/*! \ingroup RendererSetup
696
697
* @{ */
697
698
698
-
/*! Translates a GPU_RendererEnum into a string. */
699
-
const char* GPU_GetRendererEnumString(GPU_RendererEnum id);
700
-
701
699
/*! Returns an initialized GPU_RendererID. */
702
-
GPU_RendererID GPU_MakeRendererID(GPU_RendererEnum id, int major_version, int minor_version);
700
+
GPU_RendererID GPU_MakeRendererID(const char* name, GPU_RendererEnum renderer, int major_version, int minor_version);
701
+
702
+
/*! Gets the first registered renderer identifier for the given enum value. */
703
+
GPU_RendererID GPU_GetRendererID(GPU_RendererEnum renderer);
703
704
704
705
/*! Gets the renderer identifier for the given registration index. */
705
-
GPU_RendererID GPU_GetRendererID(unsigned int index);
706
+
GPU_RendererID GPU_GetRendererIDByIndex(unsigned int index);
706
707
707
708
/*! Gets the number of registered (available) renderers. */
708
709
int GPU_GetNumRegisteredRenderers(void);
+41
-51
SDL_gpu/SDL_gpu_Renderer.c
+41
-51
SDL_gpu/SDL_gpu_Renderer.c
···
25
25
26
26
27
27
28
-
static GPU_RendererID makeRendererID(GPU_RendererEnum id, int major_version, int minor_version, int index)
28
+
static GPU_RendererID makeRendererID(const char* name, GPU_RendererEnum renderer, int major_version, int minor_version, int index)
29
29
{
30
-
GPU_RendererID r = {id, major_version, minor_version, index};
30
+
GPU_RendererID r = {name, renderer, major_version, minor_version, index};
31
31
return r;
32
32
}
33
33
···
86
86
count = 0;
87
87
for(i = 0; i < MAX_REGISTERED_RENDERERS; i++)
88
88
{
89
-
if(rendererRegister[i].id.id != GPU_RENDERER_UNKNOWN)
89
+
if(rendererRegister[i].id.renderer != GPU_RENDERER_UNKNOWN)
90
90
count++;
91
91
}
92
92
return count;
···
102
102
count = 0;
103
103
for(i = 0; i < MAX_REGISTERED_RENDERERS; i++)
104
104
{
105
-
if(rendererRegister[i].id.id != GPU_RENDERER_UNKNOWN)
105
+
if(rendererRegister[i].id.renderer != GPU_RENDERER_UNKNOWN)
106
106
{
107
107
renderers_array[count] = rendererRegister[i].id;
108
108
count++;
···
111
111
}
112
112
113
113
114
-
GPU_RendererID GPU_GetRendererID(unsigned int index)
114
+
GPU_RendererID GPU_GetRendererID(GPU_RendererEnum renderer)
115
+
{
116
+
int i;
117
+
118
+
GPU_InitRendererRegister();
119
+
120
+
for(i = 0; i < MAX_REGISTERED_RENDERERS; i++)
121
+
{
122
+
if(rendererRegister[i].id.renderer == renderer)
123
+
return rendererRegister[i].id;
124
+
}
125
+
126
+
return makeRendererID("Unknown", GPU_RENDERER_UNKNOWN, 0, 0, -1);
127
+
}
128
+
129
+
GPU_RendererID GPU_GetRendererIDByIndex(unsigned int index)
115
130
{
116
131
if(index >= MAX_REGISTERED_RENDERERS)
117
-
return makeRendererID(GPU_RENDERER_UNKNOWN, 0, 0, -1);
132
+
return makeRendererID("Unknown", GPU_RENDERER_UNKNOWN, 0, 0, -1);
118
133
119
134
return rendererRegister[index].id;
120
135
}
···
149
164
{
150
165
#ifndef SDL_GPU_DISABLE_OPENGL
151
166
#ifndef SDL_GPU_DISABLE_OPENGL_1_BASE
152
-
GPU_RegisterRenderer(GPU_MakeRendererID(GPU_RENDERER_OPENGL_1_BASE, 1, 1),
167
+
GPU_RegisterRenderer(GPU_MakeRendererID("OpenGL 1 BASE", GPU_RENDERER_OPENGL_1_BASE, 1, 1),
153
168
&GPU_CreateRenderer_OpenGL_1_BASE,
154
169
&GPU_FreeRenderer_OpenGL_1_BASE);
155
170
#endif
156
171
157
172
#ifndef SDL_GPU_DISABLE_OPENGL_1
158
-
GPU_RegisterRenderer(GPU_MakeRendererID(GPU_RENDERER_OPENGL_1, 1, 1),
173
+
GPU_RegisterRenderer(GPU_MakeRendererID("OpenGL 1", GPU_RENDERER_OPENGL_1, 1, 1),
159
174
&GPU_CreateRenderer_OpenGL_1,
160
175
&GPU_FreeRenderer_OpenGL_1);
161
176
#endif
162
177
163
178
#ifndef SDL_GPU_DISABLE_OPENGL_2
164
-
GPU_RegisterRenderer(GPU_MakeRendererID(GPU_RENDERER_OPENGL_2, 2, 0),
179
+
GPU_RegisterRenderer(GPU_MakeRendererID("OpenGL 2", GPU_RENDERER_OPENGL_2, 2, 0),
165
180
&GPU_CreateRenderer_OpenGL_2,
166
181
&GPU_FreeRenderer_OpenGL_2);
167
182
#endif
168
183
169
184
#ifndef SDL_GPU_DISABLE_OPENGL_3
170
-
GPU_RegisterRenderer(GPU_MakeRendererID(GPU_RENDERER_OPENGL_3, 3, 0),
185
+
GPU_RegisterRenderer(GPU_MakeRendererID("OpenGL 3", GPU_RENDERER_OPENGL_3, 3, 0),
171
186
&GPU_CreateRenderer_OpenGL_3,
172
187
&GPU_FreeRenderer_OpenGL_3);
173
188
#endif
···
175
190
176
191
#ifndef SDL_GPU_DISABLE_GLES
177
192
#ifndef SDL_GPU_DISABLE_GLES_1
178
-
GPU_RegisterRenderer(GPU_MakeRendererID(GPU_RENDERER_GLES_1, 1, 1),
193
+
GPU_RegisterRenderer(GPU_MakeRendererID("OpenGLES 1", GPU_RENDERER_GLES_1, 1, 1),
179
194
&GPU_CreateRenderer_GLES_1,
180
195
&GPU_FreeRenderer_GLES_1);
181
196
#endif
182
197
#ifndef SDL_GPU_DISABLE_GLES_2
183
-
GPU_RegisterRenderer(GPU_MakeRendererID(GPU_RENDERER_GLES_2, 2, 0),
198
+
GPU_RegisterRenderer(GPU_MakeRendererID("OpenGLES 2", GPU_RENDERER_GLES_2, 2, 0),
184
199
&GPU_CreateRenderer_GLES_2,
185
200
&GPU_FreeRenderer_GLES_2);
186
201
#endif
···
201
216
202
217
for(i = 0; i < MAX_REGISTERED_RENDERERS; i++)
203
218
{
204
-
rendererRegister[i].id.id = GPU_RENDERER_UNKNOWN;
219
+
rendererRegister[i].id.name = "Unknown";
220
+
rendererRegister[i].id.renderer = GPU_RENDERER_UNKNOWN;
205
221
rendererRegister[i].id.index = i;
206
222
rendererRegister[i].createFn = NULL;
207
223
rendererRegister[i].freeFn = NULL;
···
261
277
GPU_RendererID default_order[GPU_RENDERER_ORDER_MAX];
262
278
263
279
#if defined(__ANDROID__) || defined(__IPHONEOS__)
264
-
default_order[count++] = GPU_MakeRendererID(GPU_RENDERER_GLES_2, 2, 0);
265
-
default_order[count++] = GPU_MakeRendererID(GPU_RENDERER_GLES_1, 1, 1);
280
+
default_order[count++] = GPU_MakeRendererID("OpenGLES 2", GPU_RENDERER_GLES_2, 2, 0);
281
+
default_order[count++] = GPU_MakeRendererID("OpenGLES 1", GPU_RENDERER_GLES_1, 1, 1);
266
282
#else
267
-
default_order[count++] = GPU_MakeRendererID(GPU_RENDERER_OPENGL_3, 3, 0);
268
-
default_order[count++] = GPU_MakeRendererID(GPU_RENDERER_OPENGL_2, 2, 0);
269
-
default_order[count++] = GPU_MakeRendererID(GPU_RENDERER_OPENGL_1, 1, 1);
283
+
default_order[count++] = GPU_MakeRendererID("OpenGL 3", GPU_RENDERER_OPENGL_3, 3, 0);
284
+
default_order[count++] = GPU_MakeRendererID("OpenGL 2", GPU_RENDERER_OPENGL_2, 2, 0);
285
+
default_order[count++] = GPU_MakeRendererID("OpenGL 1", GPU_RENDERER_OPENGL_1, 1, 1);
270
286
#endif
271
287
272
288
if(order_size != NULL)
···
276
292
memcpy(order, default_order, count*sizeof(GPU_RendererID));
277
293
}
278
294
279
-
const char* GPU_GetRendererEnumString(GPU_RendererEnum id)
280
-
{
281
-
if(id == GPU_RENDERER_OPENGL_1_BASE)
282
-
return "OpenGL 1 BASE";
283
-
if(id == GPU_RENDERER_OPENGL_1)
284
-
return "OpenGL 1.x";
285
-
if(id == GPU_RENDERER_OPENGL_2)
286
-
return "OpenGL 2.x";
287
-
if(id == GPU_RENDERER_OPENGL_3)
288
-
return "OpenGL 3.x";
289
-
if(id == GPU_RENDERER_OPENGL_4)
290
-
return "OpenGL 4.x";
291
-
if(id == GPU_RENDERER_GLES_1)
292
-
return "OpenGLES 1.x";
293
-
if(id == GPU_RENDERER_GLES_2)
294
-
return "OpenGLES 2.x";
295
-
if(id == GPU_RENDERER_GLES_3)
296
-
return "OpenGLES 3.x";
297
-
if(id == GPU_RENDERER_D3D9)
298
-
return "Direct3D 9";
299
-
if(id == GPU_RENDERER_D3D10)
300
-
return "Direct3D 10";
301
-
if(id == GPU_RENDERER_D3D11)
302
-
return "Direct3D 11";
303
-
304
-
return "Unknown";
305
-
}
306
-
307
295
308
296
GPU_Renderer* GPU_CreateRenderer(GPU_RendererID id)
309
297
{
···
311
299
int i;
312
300
for(i = 0; i < MAX_REGISTERED_RENDERERS; i++)
313
301
{
314
-
if(rendererRegister[i].id.id == GPU_RENDERER_UNKNOWN)
302
+
if(rendererRegister[i].id.renderer == GPU_RENDERER_UNKNOWN)
315
303
continue;
316
304
317
-
if(id.id == rendererRegister[i].id.id)
305
+
if(id.renderer == rendererRegister[i].id.renderer)
318
306
{
319
307
if(rendererRegister[i].createFn != NULL)
320
308
{
309
+
// Use the registered name
310
+
id.name = rendererRegister[i].id.name;
321
311
result = rendererRegister[i].createFn(id);
322
312
}
323
313
break;
···
383
373
int i;
384
374
for(i = 0; i < MAX_REGISTERED_RENDERERS; i++)
385
375
{
386
-
if(rendererRegister[i].id.id == GPU_RENDERER_UNKNOWN)
376
+
if(rendererRegister[i].id.renderer == GPU_RENDERER_UNKNOWN)
387
377
continue;
388
378
389
-
if(renderer->id.id == rendererRegister[i].id.id)
379
+
if(renderer->id.renderer == rendererRegister[i].id.renderer)
390
380
{
391
381
rendererRegister[i].freeFn(renderer);
392
382
return;
···
403
393
if(rendererMap[i] == NULL)
404
394
continue;
405
395
406
-
if(i == id.index && id.id == rendererMap[i]->id.id)
396
+
if(i == id.index && id.renderer == rendererMap[i]->id.renderer)
407
397
{
408
398
GPU_FreeRenderer(rendererMap[i]);
409
399
rendererMap[i] = NULL;
+10
-9
demos/common/common.c
+10
-9
demos/common/common.c
···
1
1
#include "SDL_gpu.h"
2
+
#include <string.h>
3
+
#include <strings.h>
2
4
3
5
void printRenderers(void)
4
6
{
···
24
26
GPU_Log("\nAvailable renderers:\n");
25
27
for(i = 0; i < GPU_GetNumRegisteredRenderers(); i++)
26
28
{
27
-
GPU_Log("* %s (%d.%d)\n", GPU_GetRendererEnumString(renderers[i].id), renderers[i].major_version, renderers[i].minor_version);
29
+
GPU_Log("* %s (%d.%d)\n", renderers[i].name, renderers[i].major_version, renderers[i].minor_version);
28
30
}
29
31
GPU_Log("Renderer init order:\n");
30
32
31
33
GPU_GetRendererOrder(&order_size, order);
32
34
for(i = 0; i < order_size; i++)
33
35
{
34
-
GPU_Log("%d) %s (%d.%d)\n", i+1, GPU_GetRendererEnumString(order[i].id), order[i].major_version, order[i].minor_version);
36
+
GPU_Log("%d) %s (%d.%d)\n", i+1, order[i].name, order[i].major_version, order[i].minor_version);
35
37
}
36
38
GPU_Log("\n");
37
39
···
41
43
void printCurrentRenderer(void)
42
44
{
43
45
GPU_RendererID id = GPU_GetCurrentRenderer()->id;
44
-
const char* renderer_string = GPU_GetRendererEnumString(id.id);
45
46
46
-
GPU_Log("Using renderer: %s (%d.%d)\n\n", renderer_string, id.major_version, id.minor_version);
47
+
GPU_Log("Using renderer: %s (%d.%d)\n\n", id.name, id.major_version, id.minor_version);
47
48
}
48
49
49
50
GPU_Target* initialize_demo(int argc, char** argv, int w, int h)
···
68
69
break;
69
70
70
71
s = argv[i];
71
-
if(strcasecmp(s, "BASE") == 0 || strcasecmp(s, "OpenGL_BASE") == 0 || strcasecmp(s, "OpenGL_1_BASE") == 0)
72
+
if(SDL_strcasecmp(s, "BASE") == 0 || SDL_strcasecmp(s, "OpenGL_BASE") == 0 || SDL_strcasecmp(s, "OpenGL_1_BASE") == 0)
72
73
renderer = GPU_RENDERER_OPENGL_1_BASE;
73
-
else if(strcasecmp(s, "OpenGL_1") == 0)
74
+
else if(SDL_strcasecmp(s, "OpenGL_1") == 0)
74
75
renderer = GPU_RENDERER_OPENGL_1;
75
-
else if(strcasecmp(s, "OpenGL_2") == 0)
76
+
else if(SDL_strcasecmp(s, "OpenGL_2") == 0)
76
77
renderer = GPU_RENDERER_OPENGL_2;
77
-
else if(strcasecmp(s, "OpenGL_3") == 0)
78
+
else if(SDL_strcasecmp(s, "OpenGL_3") == 0)
78
79
renderer = GPU_RENDERER_OPENGL_3;
79
-
else if(strcasecmp(s, "OpenGL_4") == 0)
80
+
else if(SDL_strcasecmp(s, "OpenGL_4") == 0)
80
81
renderer = GPU_RENDERER_OPENGL_4;
81
82
}
82
83
}
+15
-10
demos/renderer/main.c
+15
-10
demos/renderer/main.c
···
1306
1306
1307
1307
memset(renderer, 0, sizeof(GPU_Renderer));
1308
1308
1309
-
renderer->id = GPU_MakeRendererID(request.id, 1, 0);
1309
+
renderer->id = request;
1310
1310
renderer->shader_language = GPU_LANGUAGE_NONE;
1311
1311
renderer->shader_version = 0;
1312
1312
···
1332
1332
GPU_Target* screen;
1333
1333
1334
1334
// Prepare renderer for SDL_gpu to use
1335
-
GPU_RendererID rendererID = GPU_MakeRendererID(GPU_ReserveNextRendererEnum(), 1, 0);
1335
+
GPU_RendererID rendererID = GPU_MakeRendererID("Dummy", GPU_ReserveNextRendererEnum(), 1, 0);
1336
1336
GPU_RegisterRenderer(rendererID, &create_dummy_renderer, &free_dummy_renderer);
1337
1337
1338
1338
printRenderers();
1339
1339
1340
1340
// Request this specific renderer
1341
-
screen = GPU_InitRenderer(rendererID.id, 800, 600, GPU_DEFAULT_INIT_FLAGS);
1341
+
screen = GPU_InitRenderer(rendererID.renderer, 800, 600, GPU_DEFAULT_INIT_FLAGS);
1342
1342
if(screen == NULL)
1343
1343
return -1;
1344
1344
···
1349
1349
long frameCount;
1350
1350
Uint8 done;
1351
1351
SDL_Event event;
1352
+
1353
+
GPU_Image* image = GPU_LoadImage("data/test.bmp");
1354
+
if(image == NULL)
1355
+
GPU_Log("Failed to load image.\n");
1352
1356
1353
1357
startTime = SDL_GetTicks();
1354
1358
frameCount = 0;
···
1367
1371
}
1368
1372
}
1369
1373
1370
-
GPU_Clear(screen);
1374
+
GPU_Clear(screen);
1375
+
1376
+
GPU_Blit(image, NULL, screen, screen->w/2, screen->h/2);
1371
1377
1372
1378
GPU_Flip(screen);
1373
-
1374
-
frameCount++;
1375
-
if(frameCount%500 == 0)
1376
-
printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime));
1379
+
1380
+
// Long delay to keep the logging from piling up too much
1381
+
SDL_Delay(500);
1377
1382
}
1378
-
1379
-
printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime));
1383
+
1384
+
GPU_FreeImage(image);
1380
1385
}
1381
1386
1382
1387
GPU_Quit();