this repo has no description
Added stuff to make renderer order selection work. For now, highest API levels are preferred. The GL context and window are destroyed between initialization tries. This should be fixed.
+167
-93
+31
-23
SDL_gpu/GL_common/SDL_gpu_GL_common.inl
+31
-23
SDL_gpu/GL_common/SDL_gpu_GL_common.inl
···
784
784
785
785
// Create or re-init the current target. This also creates the GL context and initializes enabled_features.
786
786
#ifdef SDL_GPU_USE_SDL2
787
-
renderer->CreateTargetFromWindow(renderer, SDL_GetWindowID(window), renderer->current_context_target);
787
+
if(renderer->CreateTargetFromWindow(renderer, SDL_GetWindowID(window), renderer->current_context_target) == NULL)
788
+
return NULL;
788
789
#else
789
-
renderer->CreateTargetFromWindow(renderer, 0, renderer->current_context_target);
790
+
if(renderer->CreateTargetFromWindow(renderer, 0, renderer->current_context_target) == NULL)
791
+
return NULL;
790
792
#endif
791
793
792
794
// Update our renderer info from the current GL context.
···
916
918
917
919
#endif
918
920
919
-
920
-
#ifdef SDL_GPU_USE_OPENGL
921
-
GLenum err = glewInit();
922
-
if (GLEW_OK != err)
923
-
{
924
-
/* Problem: glewInit failed, something is seriously wrong. */
925
-
GPU_LogError("Failed to initialize: %s\n", glewGetErrorString(err));
926
-
}
927
-
#endif
928
-
929
-
init_features(renderer);
930
-
931
-
if(!renderer->IsFeatureEnabled(renderer, GPU_FEATURE_RENDER_TARGETS))
932
-
GPU_LogError("RENDER TARGETS not supported.\n");
933
-
if(!renderer->IsFeatureEnabled(renderer, GPU_FEATURE_NON_POWER_OF_TWO))
934
-
GPU_LogError("NPOT TEXTURES not supported.\n");
935
-
if(!renderer->IsFeatureEnabled(renderer, GPU_FEATURE_BLEND_FUNC_SEPARATE))
936
-
GPU_LogError("BLEND FUNC SEPARATE not supported.\n");
937
921
938
922
((TARGET_DATA*)target->data)->handle = 0;
939
923
((TARGET_DATA*)target->data)->format = GL_RGBA;
···
960
944
cdata->last_use_blending = 0;
961
945
cdata->last_blend_mode = GPU_BLEND_NORMAL;
962
946
cdata->last_camera = target->camera; // Redundant due to applyTargetCamera()
947
+
948
+
949
+
#ifdef SDL_GPU_USE_OPENGL
950
+
GLenum err = glewInit();
951
+
if (GLEW_OK != err)
952
+
{
953
+
// Probably don't have the right GL version for this renderer
954
+
return NULL;
955
+
}
956
+
#endif
957
+
958
+
init_features(renderer);
959
+
960
+
if(!renderer->IsFeatureEnabled(renderer, GPU_FEATURE_RENDER_TARGETS))
961
+
GPU_LogError("RENDER TARGETS not supported.\n");
962
+
if(!renderer->IsFeatureEnabled(renderer, GPU_FEATURE_NON_POWER_OF_TWO))
963
+
GPU_LogError("NPOT TEXTURES not supported.\n");
964
+
if(!renderer->IsFeatureEnabled(renderer, GPU_FEATURE_BLEND_FUNC_SEPARATE))
965
+
GPU_LogError("BLEND FUNC SEPARATE not supported.\n");
963
966
964
967
// Set up GL state
965
968
···
2316
2319
2317
2320
if(renderer->enabled_features & GPU_FEATURE_RENDER_TARGETS)
2318
2321
{
2319
-
flushAndClearBlitBufferIfCurrentFramebuffer(renderer, target);
2320
-
glDeleteFramebuffers(1, &data->handle);
2322
+
if(renderer->current_context_target != NULL)
2323
+
flushAndClearBlitBufferIfCurrentFramebuffer(renderer, target);
2324
+
if(data->handle != 0)
2325
+
glDeleteFramebuffers(1, &data->handle);
2321
2326
}
2322
2327
2323
2328
if(target->image != NULL)
···
2336
2341
#endif
2337
2342
2338
2343
#ifdef SDL_GPU_USE_GL_TIER3
2339
-
glDeleteBuffers(2, data->blit_VBO);
2344
+
if(data->handle != 0)
2345
+
{
2346
+
glDeleteBuffers(2, data->blit_VBO);
2340
2347
#if !defined(SDL_GPU_USE_GLES) || SDL_GPU_GLES_MAJOR_VERSION != 2
2341
2348
glDeleteVertexArrays(1, &data->blit_VAO);
2342
2349
#endif
2350
+
}
2343
2351
#endif
2344
2352
2345
2353
free(target->context->data);
+48
-28
SDL_gpu/SDL_gpu.c
+48
-28
SDL_gpu/SDL_gpu.c
···
67
67
}
68
68
69
69
70
-
static Uint32 isolate_renderer_flags(Uint32 flags)
70
+
static Uint8 init_SDL(void)
71
71
{
72
-
// TODO: Make video/window/renderer flags combinable and make this work right.
73
-
return 0;
74
-
}
75
-
76
-
77
-
78
-
79
-
GPU_Target* GPU_Init(Uint16 w, Uint16 h, Uint32 flags)
80
-
{
81
-
return GPU_InitRenderer(GPU_MakeRendererIDRequest(GPU_RENDERER_DEFAULT, 0, 0, isolate_renderer_flags(flags)), w, h, flags);
82
-
}
83
-
84
-
GPU_Target* GPU_InitRenderer(GPU_RendererID renderer_request, Uint16 w, Uint16 h, Uint32 flags)
85
-
{
86
-
GPU_InitRendererRegister();
87
-
88
72
if(GPU_GetNumActiveRenderers() == 0)
89
73
{
90
74
Uint32 subsystems = SDL_WasInit(SDL_INIT_EVERYTHING);
···
94
78
if(SDL_Init(SDL_INIT_VIDEO) < 0)
95
79
{
96
80
GPU_LogError("GPU_Init() failed to initialize SDL.\n");
97
-
return NULL;
81
+
return 0;
98
82
}
99
83
}
100
84
else if(!(subsystems & SDL_INIT_VIDEO))
···
103
87
if(SDL_InitSubSystem(SDL_INIT_VIDEO) < 0)
104
88
{
105
89
GPU_LogError("GPU_Init() failed to initialize SDL video subsystem.\n");
106
-
return NULL;
90
+
return 0;
107
91
}
108
92
}
109
93
}
94
+
return 1;
95
+
}
96
+
97
+
GPU_Target* GPU_Init(Uint16 w, Uint16 h, Uint32 flags)
98
+
{
99
+
GPU_InitRendererRegister();
100
+
101
+
if(!init_SDL())
102
+
return NULL;
103
+
104
+
int renderer_order_size = 0;
105
+
GPU_RendererID renderer_order[GPU_RENDERER_ORDER_MAX];
106
+
GPU_GetRendererOrder(&renderer_order_size, renderer_order);
107
+
108
+
// Init the renderers in order
109
+
int i;
110
+
for(i = 0; i < renderer_order_size; i++)
111
+
{
112
+
GPU_Target* screen = GPU_InitRendererByID(renderer_order[i], w, h, flags);
113
+
if(screen != NULL)
114
+
return screen;
115
+
}
116
+
117
+
return NULL;
118
+
}
119
+
120
+
GPU_Target* GPU_InitRenderer(GPU_RendererEnum renderer_enum, Uint16 w, Uint16 h, Uint32 flags)
121
+
{
122
+
return GPU_InitRendererByID(GPU_MakeRendererID(renderer_enum, 0, 0, 0), w, h, flags);
123
+
}
124
+
125
+
GPU_Target* GPU_InitRendererByID(GPU_RendererID renderer_request, Uint16 w, Uint16 h, Uint32 flags)
126
+
{
127
+
GPU_InitRendererRegister();
128
+
129
+
if(!init_SDL())
130
+
return NULL;
110
131
111
132
GPU_Renderer* renderer = GPU_AddRenderer(renderer_request);
112
133
if(renderer == NULL || renderer->Init == NULL)
···
114
135
115
136
GPU_SetCurrentRenderer(renderer->id);
116
137
117
-
return renderer->Init(renderer, renderer_request, w, h, flags);
138
+
GPU_Target* screen = renderer->Init(renderer, renderer_request, w, h, flags);
139
+
if(screen == NULL)
140
+
{
141
+
// Init failed, destroy the renderer...
142
+
GPU_CloseCurrentRenderer();
143
+
}
144
+
return screen;
118
145
}
119
146
120
147
Uint8 GPU_IsFeatureEnabled(GPU_FeatureEnum feature)
···
240
267
return r;
241
268
}
242
269
243
-
GPU_RendererID GPU_MakeRendererIDRequest(GPU_RendererEnum id, int major_version, int minor_version, Uint32 flags)
270
+
GPU_RendererID GPU_MakeRendererID(GPU_RendererEnum id, int major_version, int minor_version, Uint32 flags)
244
271
{
245
272
GPU_RendererID r = {id, major_version, minor_version, flags, -1};
246
-
return r;
247
-
}
248
-
249
-
GPU_RendererID GPU_MakeRendererID(GPU_RendererEnum id, int major_version, int minor_version, int index)
250
-
{
251
-
GPU_RendererID r = {id, major_version, minor_version, 0, index};
252
273
return r;
253
274
}
254
275
···
867
888
if(pass_colors)
868
889
src_color_floats_per_sprite = 16; // 4 vertices of r, g, b, a
869
890
870
-
int src_floats_per_sprite = src_position_floats_per_sprite + src_rect_floats_per_sprite + src_color_floats_per_sprite;
871
891
int size = numSprites*(8 + 8 + 16);
872
892
float* values = (float*)malloc(sizeof(float)*size);
873
893
+33
-22
SDL_gpu/SDL_gpu.h
+33
-22
SDL_gpu/SDL_gpu.h
···
30
30
float w, h;
31
31
} GPU_Rect;
32
32
33
+
#define GPU_RENDERER_ORDER_MAX 10
34
+
33
35
typedef Uint32 GPU_RendererEnum;
34
36
static const GPU_RendererEnum GPU_RENDERER_UNKNOWN = 0x0; // invalid value
35
-
static const GPU_RendererEnum GPU_RENDERER_DEFAULT = 0x1;
36
-
static const GPU_RendererEnum GPU_RENDERER_OPENGL_1 = 0x2;
37
-
static const GPU_RendererEnum GPU_RENDERER_OPENGL_2 = 0x4;
38
-
static const GPU_RendererEnum GPU_RENDERER_OPENGL_3 = 0x8;
39
-
static const GPU_RendererEnum GPU_RENDERER_OPENGL_4 = 0x10;
40
-
static const GPU_RendererEnum GPU_RENDERER_GLES_1 = 0x20;
41
-
static const GPU_RendererEnum GPU_RENDERER_GLES_2 = 0x40;
42
-
static const GPU_RendererEnum GPU_RENDERER_GLES_3 = 0x80;
43
-
static const GPU_RendererEnum GPU_RENDERER_D3D9 = 0x100;
37
+
static const GPU_RendererEnum GPU_RENDERER_OPENGL_1 = 0x1;
38
+
static const GPU_RendererEnum GPU_RENDERER_OPENGL_2 = 0x2;
39
+
static const GPU_RendererEnum GPU_RENDERER_OPENGL_3 = 0x4;
40
+
static const GPU_RendererEnum GPU_RENDERER_OPENGL_4 = 0x8;
41
+
static const GPU_RendererEnum GPU_RENDERER_GLES_1 = 0x100;
42
+
static const GPU_RendererEnum GPU_RENDERER_GLES_2 = 0x200;
43
+
static const GPU_RendererEnum GPU_RENDERER_GLES_3 = 0x400;
44
+
static const GPU_RendererEnum GPU_RENDERER_D3D9 = 0x10000;
45
+
static const GPU_RendererEnum GPU_RENDERER_D3D10 = 0x20000;
46
+
static const GPU_RendererEnum GPU_RENDERER_D3D11 = 0x40000;
44
47
45
48
/*! Renderer ID object for identifying a specific renderer.
46
49
* \see GPU_MakeRendererID()
47
-
* \see GPU_MakeRendererIDRequest()
48
-
* \see GPU_Init()
49
-
* \see GPU_InitRenderer()
50
+
* \see GPU_InitRendererByID()
50
51
*/
51
52
typedef struct GPU_RendererID
52
53
{
···
275
276
GPU_Target* current_context_target;
276
277
277
278
278
-
/*! \see GPU_Init() */
279
+
/*! \see GPU_Init()
280
+
* \see GPU_InitRenderer()
281
+
* \see GPU_InitRendererByID()
282
+
*/
279
283
GPU_Target* (*Init)(GPU_Renderer* renderer, GPU_RendererID renderer_request, Uint16 w, Uint16 h, Uint32 flags);
280
284
281
285
/*! \see GPU_IsFeatureEnabled() */
···
525
529
526
530
527
531
// Setup calls
528
-
/*! Initializes SDL and SDL_gpu. Creates a window and the default renderer context. */
532
+
/*! Initializes SDL and SDL_gpu. Creates a window and goes through the renderer order to create a renderer context.
533
+
* \see GPU_SetRendererOrder()
534
+
*/
529
535
GPU_Target* GPU_Init(Uint16 w, Uint16 h, Uint32 flags);
530
536
531
-
/*! Initializes SDL and SDL_gpu. Creates a window and renderer context. */
532
-
GPU_Target* GPU_InitRenderer(GPU_RendererID renderer_request, Uint16 w, Uint16 h, Uint32 flags);
537
+
/*! Initializes SDL and SDL_gpu. Creates a window and the requested renderer context. */
538
+
GPU_Target* GPU_InitRenderer(GPU_RendererEnum renderer_enum, Uint16 w, Uint16 h, Uint32 flags);
533
539
534
-
/*! Returns the default renderer ID for the current platform. */
535
-
GPU_RendererID GPU_GetDefaultRendererID(void);
540
+
/*! Initializes SDL and SDL_gpu. Creates a window and the requested renderer context.
541
+
* By requesting a renderer via ID, you can specify the major and minor versions of an individual renderer backend.
542
+
*/
543
+
GPU_Target* GPU_InitRendererByID(GPU_RendererID renderer_request, Uint16 w, Uint16 h, Uint32 flags);
544
+
545
+
/*! Gets the current renderer ID order for initialization. Pass NULL for 'order' to just get the size of the renderer order array. */
546
+
void GPU_GetRendererOrder(int* order_size, GPU_RendererID* order);
547
+
548
+
/*! Gets the default renderer IDs for the current platform. Pass NULL for 'order' to just get the size of the renderer order array. */
549
+
void GPU_GetDefaultRendererOrder(int* order_size, GPU_RendererID* order);
536
550
537
551
/*! Checks for important GPU features which may not be supported depending on a device's extension support. Feature flags (GPU_FEATURE_*) can be bitwise OR'd together.
538
552
* \return 1 if all of the passed features are enabled/supported
···
583
597
/*! Translates a GPU_RendererEnum into a string. */
584
598
const char* GPU_GetRendererEnumString(GPU_RendererEnum id);
585
599
586
-
/*! Returns an initialized GPU_RendererRequestID. */
587
-
GPU_RendererID GPU_MakeRendererIDRequest(GPU_RendererEnum id, int major_version, int minor_version, Uint32 flags);
588
-
589
600
/*! Returns an initialized GPU_RendererID. */
590
-
GPU_RendererID GPU_MakeRendererID(GPU_RendererEnum id, int major_version, int minor_version, int index);
601
+
GPU_RendererID GPU_MakeRendererID(GPU_RendererEnum id, int major_version, int minor_version, Uint32 flags);
591
602
592
603
/*! Gets the renderer identifier for the given registration index. */
593
604
GPU_RendererID GPU_GetRendererID(unsigned int index);
+45
-19
SDL_gpu/SDL_gpu_Renderer.c
+45
-19
SDL_gpu/SDL_gpu_Renderer.c
···
19
19
static RendererRegistration rendererRegister[MAX_REGISTERED_RENDERERS];
20
20
21
21
22
+
23
+
static GPU_RendererID makeRendererID(GPU_RendererEnum id, int major_version, int minor_version, int index)
24
+
{
25
+
GPU_RendererID r = {id, major_version, minor_version, 0, index};
26
+
return r;
27
+
}
28
+
29
+
22
30
void GPU_InitRendererRegister(void);
23
31
24
32
int GPU_GetNumActiveRenderers(void)
···
88
96
GPU_RendererID GPU_GetRendererID(unsigned int index)
89
97
{
90
98
if(index >= MAX_REGISTERED_RENDERERS)
91
-
return GPU_MakeRendererID(GPU_RENDERER_UNKNOWN, 0, 0, -1);
99
+
return makeRendererID(GPU_RENDERER_UNKNOWN, 0, 0, -1);
92
100
93
101
return rendererRegister[index].id;
94
102
}
···
113
121
114
122
#ifndef SDL_GPU_DISABLE_OPENGL
115
123
#ifndef SDL_GPU_DISABLE_OPENGL_1
116
-
rendererRegister[i].id = GPU_MakeRendererID(GPU_RENDERER_OPENGL_1, 1, 1, i);
124
+
rendererRegister[i].id = makeRendererID(GPU_RENDERER_OPENGL_1, 1, 1, i);
117
125
rendererRegister[i].createFn = &GPU_CreateRenderer_OpenGL_1;
118
126
rendererRegister[i].freeFn = &GPU_FreeRenderer_OpenGL_1;
119
127
···
123
131
#endif
124
132
125
133
#ifndef SDL_GPU_DISABLE_OPENGL_2
126
-
rendererRegister[i].id = GPU_MakeRendererID(GPU_RENDERER_OPENGL_2, 2, 0, i);
134
+
rendererRegister[i].id = makeRendererID(GPU_RENDERER_OPENGL_2, 2, 0, i);
127
135
rendererRegister[i].createFn = &GPU_CreateRenderer_OpenGL_2;
128
136
rendererRegister[i].freeFn = &GPU_FreeRenderer_OpenGL_2;
129
137
···
133
141
#endif
134
142
135
143
#ifndef SDL_GPU_DISABLE_OPENGL_3
136
-
rendererRegister[i].id = GPU_MakeRendererID(GPU_RENDERER_OPENGL_3, 3, 0, i);
144
+
rendererRegister[i].id = makeRendererID(GPU_RENDERER_OPENGL_3, 3, 0, i);
137
145
rendererRegister[i].createFn = &GPU_CreateRenderer_OpenGL_3;
138
146
rendererRegister[i].freeFn = &GPU_FreeRenderer_OpenGL_3;
139
147
···
145
153
146
154
#ifndef SDL_GPU_DISABLE_GLES
147
155
#ifndef SDL_GPU_DISABLE_GLES_1
148
-
rendererRegister[i].id = GPU_MakeRendererID(GPU_RENDERER_GLES_1, 1, 1, i);
156
+
rendererRegister[i].id = makeRendererID(GPU_RENDERER_GLES_1, 1, 1, i);
149
157
rendererRegister[i].createFn = &GPU_CreateRenderer_GLES_1;
150
158
rendererRegister[i].freeFn = &GPU_FreeRenderer_GLES_1;
151
159
···
154
162
return;
155
163
#endif
156
164
#ifndef SDL_GPU_DISABLE_GLES_2
157
-
rendererRegister[i].id = GPU_MakeRendererID(GPU_RENDERER_GLES_2, 2, 0, i);
165
+
rendererRegister[i].id = makeRendererID(GPU_RENDERER_GLES_2, 2, 0, i);
158
166
rendererRegister[i].createFn = &GPU_CreateRenderer_GLES_2;
159
167
rendererRegister[i].freeFn = &GPU_FreeRenderer_GLES_2;
160
168
···
167
175
}
168
176
169
177
178
+
static int renderer_order_size = 0;
179
+
static GPU_RendererID renderer_order[GPU_RENDERER_ORDER_MAX];
180
+
170
181
void GPU_InitRendererRegister(void)
171
182
{
172
183
if(initialized)
···
185
196
rendererMap[i] = NULL;
186
197
}
187
198
199
+
GPU_GetDefaultRendererOrder(&renderer_order_size, renderer_order);
200
+
188
201
initialized = 1;
189
202
190
203
GPU_RegisterRenderers();
191
204
}
192
205
193
206
207
+
void GPU_GetRendererOrder(int* order_size, GPU_RendererID* order)
208
+
{
209
+
if(order_size != NULL)
210
+
*order_size = renderer_order_size;
211
+
212
+
if(order != NULL && renderer_order_size > 0)
213
+
memcpy(order, renderer_order, renderer_order_size*sizeof(GPU_RendererID));
214
+
}
194
215
195
216
196
217
197
-
GPU_RendererID GPU_GetDefaultRendererID(void)
218
+
void GPU_GetDefaultRendererOrder(int* order_size, GPU_RendererID* order)
198
219
{
220
+
int count = 0;
221
+
GPU_RendererID default_order[GPU_RENDERER_ORDER_MAX];
199
222
200
223
#if defined(__ANDROID__) || defined(__IPHONEOS__)
201
-
#ifdef SDL_GPU_PREFER_GLES_2
202
-
return GPU_MakeRendererIDRequest(GPU_RENDERER_GLES_2, 2, 0, 0);
203
-
#else
204
-
return GPU_MakeRendererIDRequest(GPU_RENDERER_GLES_1, 1, 1, 0);
205
-
#endif
224
+
default_order[count++] = GPU_MakeRendererID(GPU_RENDERER_GLES_2, 2, 0, 0);
225
+
default_order[count++] = GPU_MakeRendererID(GPU_RENDERER_GLES_1, 1, 1, 0);
206
226
#else
207
-
return GPU_MakeRendererIDRequest(GPU_RENDERER_OPENGL_1, 1, 1, 0);
227
+
default_order[count++] = GPU_MakeRendererID(GPU_RENDERER_OPENGL_3, 3, 0, 0);
228
+
default_order[count++] = GPU_MakeRendererID(GPU_RENDERER_OPENGL_2, 2, 0, 0);
229
+
default_order[count++] = GPU_MakeRendererID(GPU_RENDERER_OPENGL_1, 1, 1, 0);
208
230
#endif
231
+
232
+
if(order_size != NULL)
233
+
*order_size = count;
234
+
235
+
if(order != NULL && count > 0)
236
+
memcpy(order, default_order, count*sizeof(GPU_RendererID));
209
237
}
210
238
211
239
const char* GPU_GetRendererEnumString(GPU_RendererEnum id)
212
240
{
213
-
if(id == GPU_RENDERER_DEFAULT)
214
-
id = GPU_GetDefaultRendererID().id;
215
-
216
241
if(id == GPU_RENDERER_OPENGL_1)
217
242
return "OpenGL 1.x";
218
243
if(id == GPU_RENDERER_OPENGL_2)
···
229
254
return "OpenGLES 3.x";
230
255
if(id == GPU_RENDERER_D3D9)
231
256
return "Direct3D 9";
257
+
if(id == GPU_RENDERER_D3D10)
258
+
return "Direct3D 10";
259
+
if(id == GPU_RENDERER_D3D11)
260
+
return "Direct3D 11";
232
261
233
262
return "Unknown";
234
263
}
···
281
310
// Create a new renderer based on a registered id and store it in the map.
282
311
GPU_Renderer* GPU_AddRenderer(GPU_RendererID id)
283
312
{
284
-
if(id.id == GPU_RENDERER_DEFAULT)
285
-
id = GPU_GetDefaultRendererID();
286
-
287
313
int i;
288
314
for(i = 0; i < MAX_ACTIVE_RENDERERS; i++)
289
315
{
+10
-1
demos/common/common.c
+10
-1
demos/common/common.c
···
9
9
int i;
10
10
for(i = 0; i < GPU_GetNumRegisteredRenderers(); i++)
11
11
{
12
-
printf("%d) %s (%d.%d)\n", i+1, GPU_GetRendererEnumString(renderers[i].id), renderers[i].major_version, renderers[i].minor_version);
12
+
printf("* %s (%d.%d)\n", GPU_GetRendererEnumString(renderers[i].id), renderers[i].major_version, renderers[i].minor_version);
13
+
}
14
+
printf("Renderer order:\n");
15
+
16
+
int order_size;
17
+
GPU_RendererID order[GPU_RENDERER_ORDER_MAX];
18
+
GPU_GetRendererOrder(&order_size, order);
19
+
for(i = 0; i < order_size; i++)
20
+
{
21
+
printf("%d) %s (%d.%d)\n", i+1, GPU_GetRendererEnumString(order[i].id), order[i].major_version, order[i].minor_version);
13
22
}
14
23
}
15
24