this repo has no description
0
fork

Configure Feed

Select the types of activity you want to include in your feed.

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
··· 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
··· 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
··· 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
··· 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
··· 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