+303 -303

src/SDL_gpu.c

reviewed

··· 21 21 #define GET_ALPHA(sdl_color) ((sdl_color).unused) 22 22 #endif 23 23 24 24 - #define CHECK_RENDERER (current_renderer != NULL) 25 25 - #define CHECK_CONTEXT (current_renderer->current_context_target != NULL) 24 24 + #define CHECK_RENDERER (_gpu_current_renderer != NULL) 25 25 + #define CHECK_CONTEXT (_gpu_current_renderer->current_context_target != NULL) 26 26 #define RETURN_ERROR(code, details) do{ GPU_PushErrorCode(__func__, code, "%s", details); return; } while(0) 27 27 28 28 - int GPU_strcasecmp(const char* s1, const char* s2); 28 28 + int gpu_strcasecmp(const char* s1, const char* s2); 29 29 30 30 - void GPU_InitRendererRegister(void); 31 31 - GPU_Renderer* GPU_CreateAndAddRenderer(GPU_RendererID id); 30 30 + void gpu_init_renderer_register(void); 31 31 + GPU_Renderer* gpu_create_and_add_renderer(GPU_RendererID id); 32 32 33 33 - static GPU_Renderer* current_renderer = NULL; 33 33 + static GPU_Renderer* _gpu_current_renderer = NULL; 34 34 35 35 - static GPU_DebugLevelEnum debug_level = GPU_DEBUG_LEVEL_0; 35 35 + static GPU_DebugLevelEnum _gpu_debug_level = GPU_DEBUG_LEVEL_0; 36 36 37 37 #define GPU_DEFAULT_MAX_NUM_ERRORS 20 38 38 #define GPU_ERROR_FUNCTION_STRING_MAX 128 39 39 #define GPU_ERROR_DETAILS_STRING_MAX 512 40 40 - static GPU_ErrorObject* error_code_stack = NULL; 41 41 - static unsigned int num_error_codes = 0; 42 42 - static unsigned int error_code_stack_size = GPU_DEFAULT_MAX_NUM_ERRORS; 40 40 + static GPU_ErrorObject* _gpu_error_code_stack = NULL; 41 41 + static unsigned int _gpu_num_error_codes = 0; 42 42 + static unsigned int _gpu_error_code_stack_size = GPU_DEFAULT_MAX_NUM_ERRORS; 43 43 44 44 /*! A mapping of windowID to a GPU_Target to facilitate GPU_GetWindowTarget(). */ 45 45 typedef struct GPU_WindowMapping ··· 49 49 } GPU_WindowMapping; 50 50 51 51 #define GPU_INITIAL_WINDOW_MAPPINGS_SIZE 10 52 52 - static GPU_WindowMapping* window_mappings = NULL; 53 53 - static int window_mappings_size = 0; 54 54 - static int num_window_mappings = 0; 52 52 + static GPU_WindowMapping* _gpu_window_mappings = NULL; 53 53 + static int _gpu_window_mappings_size = 0; 54 54 + static int _gpu_num_window_mappings = 0; 55 55 56 56 57 57 SDL_version GPU_GetLinkedVersion(void) ··· 61 61 62 62 void GPU_SetCurrentRenderer(GPU_RendererID id) 63 63 { 64 64 - current_renderer = GPU_GetRenderer(id); 64 64 + _gpu_current_renderer = GPU_GetRenderer(id); 65 65 66 66 - if(current_renderer != NULL) 67 67 - current_renderer->impl->SetAsCurrent(current_renderer); 66 66 + if(_gpu_current_renderer != NULL) 67 67 + _gpu_current_renderer->impl->SetAsCurrent(_gpu_current_renderer); 68 68 } 69 69 70 70 void GPU_ResetRendererState(void) 71 71 { 72 72 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 72 72 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 73 73 return; 74 74 75 75 - current_renderer->impl->ResetRendererState(current_renderer); 75 75 + _gpu_current_renderer->impl->ResetRendererState(_gpu_current_renderer); 76 76 } 77 77 78 78 GPU_Renderer* GPU_GetCurrentRenderer(void) 79 79 { 80 80 - return current_renderer; 80 80 + return _gpu_current_renderer; 81 81 } 82 82 83 83 Uint32 GPU_GetCurrentShaderProgram(void) 84 84 { 85 85 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 85 85 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 86 86 return 0; 87 87 88 88 - return current_renderer->current_context_target->context->current_shader_program; 88 88 + return _gpu_current_renderer->current_context_target->context->current_shader_program; 89 89 } 90 90 91 91 92 92 - int GPU_DefaultPrint(GPU_LogLevelEnum log_level, const char* format, va_list args) 92 92 + int gpu_default_print(GPU_LogLevelEnum log_level, const char* format, va_list args) 93 93 { 94 94 switch(log_level) 95 95 { ··· 113 113 } 114 114 } 115 115 116 116 - static int (*gpu_print)(GPU_LogLevelEnum log_level, const char* format, va_list args) = &GPU_DefaultPrint; 116 116 + static int (*_gpu_print)(GPU_LogLevelEnum log_level, const char* format, va_list args) = &gpu_default_print; 117 117 118 118 void GPU_SetLogCallback(int (*callback)(GPU_LogLevelEnum log_level, const char* format, va_list args)) 119 119 { 120 120 if(callback == NULL) 121 121 - gpu_print = &GPU_DefaultPrint; 121 121 + _gpu_print = &gpu_default_print; 122 122 else 123 123 - gpu_print = callback; 123 123 + _gpu_print = callback; 124 124 } 125 125 126 126 void GPU_LogInfo(const char* format, ...) 127 127 { 128 128 va_list args; 129 129 va_start(args, format); 130 130 - gpu_print(GPU_LOG_INFO, format, args); 130 130 + _gpu_print(GPU_LOG_INFO, format, args); 131 131 va_end(args); 132 132 } 133 133 ··· 135 135 { 136 136 va_list args; 137 137 va_start(args, format); 138 138 - gpu_print(GPU_LOG_WARNING, format, args); 138 138 + _gpu_print(GPU_LOG_WARNING, format, args); 139 139 va_end(args); 140 140 } 141 141 ··· 143 143 { 144 144 va_list args; 145 145 va_start(args, format); 146 146 - gpu_print(GPU_LOG_ERROR, format, args); 146 146 + _gpu_print(GPU_LOG_ERROR, format, args); 147 147 va_end(args); 148 148 } 149 149 150 150 151 151 - static Uint8 init_SDL(void) 151 151 + static Uint8 gpu_init_SDL(void) 152 152 { 153 153 if(GPU_GetNumActiveRenderers() == 0) 154 154 { ··· 175 175 return 1; 176 176 } 177 177 178 178 - static Uint32 init_windowID = 0; 178 178 + static Uint32 _gpu_init_windowID = 0; 179 179 180 180 void GPU_SetInitWindow(Uint32 windowID) 181 181 { 182 182 - init_windowID = windowID; 182 182 + _gpu_init_windowID = windowID; 183 183 } 184 184 185 185 Uint32 GPU_GetInitWindow(void) 186 186 { 187 187 - return init_windowID; 187 187 + return _gpu_init_windowID; 188 188 } 189 189 190 190 - static GPU_InitFlagEnum preinit_flags = GPU_DEFAULT_INIT_FLAGS; 191 191 - static GPU_InitFlagEnum required_features = 0; 190 190 + static GPU_InitFlagEnum _gpu_preinit_flags = GPU_DEFAULT_INIT_FLAGS; 191 191 + static GPU_InitFlagEnum _gpu_required_features = 0; 192 192 193 193 void GPU_SetPreInitFlags(GPU_InitFlagEnum GPU_flags) 194 194 { 195 195 - preinit_flags = GPU_flags; 195 195 + _gpu_preinit_flags = GPU_flags; 196 196 } 197 197 198 198 GPU_InitFlagEnum GPU_GetPreInitFlags(void) 199 199 { 200 200 - return preinit_flags; 200 200 + return _gpu_preinit_flags; 201 201 } 202 202 203 203 void GPU_SetRequiredFeatures(GPU_FeatureEnum features) 204 204 { 205 205 - required_features = features; 205 205 + _gpu_required_features = features; 206 206 } 207 207 208 208 GPU_FeatureEnum GPU_GetRequiredFeatures(void) 209 209 { 210 210 - return required_features; 210 210 + return _gpu_required_features; 211 211 } 212 212 213 213 - static void init_error_stack(void) 213 213 + static void gpu_init_error_stack(void) 214 214 { 215 215 - if(error_code_stack == NULL) 215 215 + if(_gpu_error_code_stack == NULL) 216 216 { 217 217 unsigned int i; 218 218 - error_code_stack = (GPU_ErrorObject*)malloc(sizeof(GPU_ErrorObject)*error_code_stack_size); 218 218 + _gpu_error_code_stack = (GPU_ErrorObject*)malloc(sizeof(GPU_ErrorObject)*_gpu_error_code_stack_size); 219 219 220 220 - for(i = 0; i < error_code_stack_size; i++) 220 220 + for(i = 0; i < _gpu_error_code_stack_size; i++) 221 221 { 222 222 - error_code_stack[i].function = (char*)malloc(GPU_ERROR_FUNCTION_STRING_MAX+1); 223 223 - error_code_stack[i].details = (char*)malloc(GPU_ERROR_DETAILS_STRING_MAX+1); 222 222 + _gpu_error_code_stack[i].function = (char*)malloc(GPU_ERROR_FUNCTION_STRING_MAX+1); 223 223 + _gpu_error_code_stack[i].details = (char*)malloc(GPU_ERROR_DETAILS_STRING_MAX+1); 224 224 } 225 225 - num_error_codes = 0; 225 225 + _gpu_num_error_codes = 0; 226 226 } 227 227 } 228 228 229 229 - static void init_window_mappings(void) 229 229 + static void gpu_init_window_mappings(void) 230 230 { 231 231 - if(window_mappings == NULL) 231 231 + if(_gpu_window_mappings == NULL) 232 232 { 233 233 - window_mappings_size = GPU_INITIAL_WINDOW_MAPPINGS_SIZE; 234 234 - window_mappings = (GPU_WindowMapping*)malloc(window_mappings_size * sizeof(GPU_WindowMapping)); 235 235 - num_window_mappings = 0; 233 233 + _gpu_window_mappings_size = GPU_INITIAL_WINDOW_MAPPINGS_SIZE; 234 234 + _gpu_window_mappings = (GPU_WindowMapping*)malloc(_gpu_window_mappings_size * sizeof(GPU_WindowMapping)); 235 235 + _gpu_num_window_mappings = 0; 236 236 } 237 237 } 238 238 ··· 241 241 Uint32 windowID; 242 242 int i; 243 243 244 244 - if(window_mappings == NULL) 245 245 - init_window_mappings(); 244 244 + if(_gpu_window_mappings == NULL) 245 245 + gpu_init_window_mappings(); 246 246 247 247 if(target == NULL || target->context == NULL) 248 248 return; ··· 252 252 return; 253 253 254 254 // Check for duplicates 255 255 - for(i = 0; i < num_window_mappings; i++) 255 255 + for(i = 0; i < _gpu_num_window_mappings; i++) 256 256 { 257 257 - if(window_mappings[i].windowID == windowID) 257 257 + if(_gpu_window_mappings[i].windowID == windowID) 258 258 { 259 259 - if(window_mappings[i].target != target) 259 259 + if(_gpu_window_mappings[i].target != target) 260 260 GPU_PushErrorCode(__func__, GPU_ERROR_DATA_ERROR, "WindowID %u already has a mapping.", windowID); 261 261 return; 262 262 } ··· 264 264 } 265 265 266 266 // Check if list is big enough to hold another 267 267 - if(num_window_mappings >= window_mappings_size) 267 267 + if(_gpu_num_window_mappings >= _gpu_window_mappings_size) 268 268 { 269 269 GPU_WindowMapping* new_array; 270 270 - window_mappings_size *= 2; 271 271 - new_array = (GPU_WindowMapping*)malloc(window_mappings_size * sizeof(GPU_WindowMapping)); 272 272 - memcpy(new_array, window_mappings, num_window_mappings * sizeof(GPU_WindowMapping)); 273 273 - free(window_mappings); 274 274 - window_mappings = new_array; 270 270 + _gpu_window_mappings_size *= 2; 271 271 + new_array = (GPU_WindowMapping*)malloc(_gpu_window_mappings_size * sizeof(GPU_WindowMapping)); 272 272 + memcpy(new_array, _gpu_window_mappings, _gpu_num_window_mappings * sizeof(GPU_WindowMapping)); 273 273 + free(_gpu_window_mappings); 274 274 + _gpu_window_mappings = new_array; 275 275 } 276 276 277 277 // Add to end of list ··· 279 279 GPU_WindowMapping m; 280 280 m.windowID = windowID; 281 281 m.target = target; 282 282 - window_mappings[num_window_mappings] = m; 282 282 + _gpu_window_mappings[_gpu_num_window_mappings] = m; 283 283 } 284 284 - num_window_mappings++; 284 284 + _gpu_num_window_mappings++; 285 285 } 286 286 287 287 void GPU_RemoveWindowMapping(Uint32 windowID) 288 288 { 289 289 int i; 290 290 291 291 - if(window_mappings == NULL) 292 292 - init_window_mappings(); 291 291 + if(_gpu_window_mappings == NULL) 292 292 + gpu_init_window_mappings(); 293 293 294 294 if(windowID == 0) // Invalid window ID 295 295 return; 296 296 297 297 // Find the occurrence 298 298 - for(i = 0; i < num_window_mappings; i++) 298 298 + for(i = 0; i < _gpu_num_window_mappings; i++) 299 299 { 300 300 - if(window_mappings[i].windowID == windowID) 300 300 + if(_gpu_window_mappings[i].windowID == windowID) 301 301 { 302 302 int num_to_move; 303 303 304 304 // Unset the target's window 305 305 - window_mappings[i].target->context->windowID = 0; 305 305 + _gpu_window_mappings[i].target->context->windowID = 0; 306 306 307 307 // Move the remaining entries to replace the removed one 308 308 - num_window_mappings--; 309 309 - num_to_move = num_window_mappings - i; 308 308 + _gpu_num_window_mappings--; 309 309 + num_to_move = _gpu_num_window_mappings - i; 310 310 if(num_to_move > 0) 311 311 - memmove(&window_mappings[i], &window_mappings[i+1], num_to_move * sizeof(GPU_WindowMapping)); 311 311 + memmove(&_gpu_window_mappings[i], &_gpu_window_mappings[i+1], num_to_move * sizeof(GPU_WindowMapping)); 312 312 return; 313 313 } 314 314 } ··· 320 320 Uint32 windowID; 321 321 int i; 322 322 323 323 - if(window_mappings == NULL) 324 324 - init_window_mappings(); 323 323 + if(_gpu_window_mappings == NULL) 324 324 + gpu_init_window_mappings(); 325 325 326 326 if(target == NULL || target->context == NULL) 327 327 return; ··· 334 334 target->context->windowID = 0; 335 335 336 336 // Find the occurrences 337 337 - for(i = 0; i < num_window_mappings; ) 337 337 + for(i = 0; i < _gpu_num_window_mappings; ) 338 338 { 339 339 - if(window_mappings[i].target == target) 339 339 + if(_gpu_window_mappings[i].target == target) 340 340 { 341 341 // Move the remaining entries to replace the removed one 342 342 int num_to_move; 343 343 - num_window_mappings--; 344 344 - num_to_move = num_window_mappings - i; 343 343 + _gpu_num_window_mappings--; 344 344 + num_to_move = _gpu_num_window_mappings - i; 345 345 if(num_to_move > 0) 346 346 - memmove(&window_mappings[i], &window_mappings[i+1], num_to_move * sizeof(GPU_WindowMapping)); 346 346 + memmove(&_gpu_window_mappings[i], &_gpu_window_mappings[i+1], num_to_move * sizeof(GPU_WindowMapping)); 347 347 return; 348 348 } 349 349 else ··· 356 356 { 357 357 int i; 358 358 359 359 - if(window_mappings == NULL) 360 360 - init_window_mappings(); 359 359 + if(_gpu_window_mappings == NULL) 360 360 + gpu_init_window_mappings(); 361 361 362 362 if(windowID == 0) // Invalid window ID 363 363 return NULL; 364 364 365 365 // Find the occurrence 366 366 - for(i = 0; i < num_window_mappings; i++) 366 366 + for(i = 0; i < _gpu_num_window_mappings; i++) 367 367 { 368 368 - if(window_mappings[i].windowID == windowID) 369 369 - return window_mappings[i].target; 368 368 + if(_gpu_window_mappings[i].windowID == windowID) 369 369 + return _gpu_window_mappings[i].target; 370 370 } 371 371 372 372 return NULL; ··· 378 378 int i; 379 379 GPU_RendererID renderer_order[GPU_RENDERER_ORDER_MAX]; 380 380 381 381 - init_error_stack(); 381 381 + gpu_init_error_stack(); 382 382 383 383 - GPU_InitRendererRegister(); 383 383 + gpu_init_renderer_register(); 384 384 385 385 - if(!init_SDL()) 385 385 + if(!gpu_init_SDL()) 386 386 return NULL; 387 387 388 388 renderer_order_size = 0; ··· 410 410 GPU_Renderer* renderer; 411 411 GPU_Target* screen; 412 412 413 413 - init_error_stack(); 414 414 - GPU_InitRendererRegister(); 413 413 + gpu_init_error_stack(); 414 414 + gpu_init_renderer_register(); 415 415 416 416 - if(!init_SDL()) 416 416 + if(!gpu_init_SDL()) 417 417 return NULL; 418 418 419 419 - renderer = GPU_CreateAndAddRenderer(renderer_request); 419 419 + renderer = gpu_create_and_add_renderer(renderer_request); 420 420 if(renderer == NULL) 421 421 return NULL; 422 422 ··· 427 427 { 428 428 // Init failed, destroy the renderer... 429 429 // Erase the window mappings 430 430 - num_window_mappings = 0; 430 430 + _gpu_num_window_mappings = 0; 431 431 GPU_CloseCurrentRenderer(); 432 432 } 433 433 else ··· 437 437 438 438 Uint8 GPU_IsFeatureEnabled(GPU_FeatureEnum feature) 439 439 { 440 440 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 440 440 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 441 441 return 0; 442 442 443 443 - return ((current_renderer->enabled_features & feature) == feature); 443 443 + return ((_gpu_current_renderer->enabled_features & feature) == feature); 444 444 } 445 445 446 446 GPU_Target* GPU_CreateTargetFromWindow(Uint32 windowID) 447 447 { 448 448 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 448 448 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 449 449 return NULL; 450 450 451 451 - return current_renderer->impl->CreateTargetFromWindow(current_renderer, windowID, NULL); 451 451 + return _gpu_current_renderer->impl->CreateTargetFromWindow(_gpu_current_renderer, windowID, NULL); 452 452 } 453 453 454 454 GPU_Target* GPU_CreateAliasTarget(GPU_Target* target) 455 455 { 456 456 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 456 456 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 457 457 return NULL; 458 458 459 459 - return current_renderer->impl->CreateAliasTarget(current_renderer, target); 459 459 + return _gpu_current_renderer->impl->CreateAliasTarget(_gpu_current_renderer, target); 460 460 } 461 461 462 462 void GPU_MakeCurrent(GPU_Target* target, Uint32 windowID) 463 463 { 464 464 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 464 464 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 465 465 return; 466 466 467 467 - current_renderer->impl->MakeCurrent(current_renderer, target, windowID); 467 467 + _gpu_current_renderer->impl->MakeCurrent(_gpu_current_renderer, target, windowID); 468 468 } 469 469 470 470 Uint8 GPU_SetFullscreen(Uint8 enable_fullscreen, Uint8 use_desktop_resolution) 471 471 { 472 472 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 472 472 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 473 473 return 0; 474 474 475 475 - return current_renderer->impl->SetFullscreen(current_renderer, enable_fullscreen, use_desktop_resolution); 475 475 + return _gpu_current_renderer->impl->SetFullscreen(_gpu_current_renderer, enable_fullscreen, use_desktop_resolution); 476 476 } 477 477 478 478 Uint8 GPU_GetFullscreen(void) ··· 493 493 494 494 Uint8 GPU_SetWindowResolution(Uint16 w, Uint16 h) 495 495 { 496 496 - if(current_renderer == NULL || current_renderer->current_context_target == NULL || w == 0 || h == 0) 496 496 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL || w == 0 || h == 0) 497 497 return 0; 498 498 499 499 - return current_renderer->impl->SetWindowResolution(current_renderer, w, h); 499 499 + return _gpu_current_renderer->impl->SetWindowResolution(_gpu_current_renderer, w, h); 500 500 } 501 501 502 502 503 503 void GPU_SetVirtualResolution(GPU_Target* target, Uint16 w, Uint16 h) 504 504 { 505 505 - if(current_renderer == NULL || current_renderer->current_context_target == NULL || w == 0 || h == 0) 505 505 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL || w == 0 || h == 0) 506 506 return; 507 507 508 508 - current_renderer->impl->SetVirtualResolution(current_renderer, target, w, h); 508 508 + _gpu_current_renderer->impl->SetVirtualResolution(_gpu_current_renderer, target, w, h); 509 509 } 510 510 511 511 void GPU_UnsetVirtualResolution(GPU_Target* target) 512 512 { 513 513 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 513 513 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 514 514 return; 515 515 516 516 - current_renderer->impl->UnsetVirtualResolution(current_renderer, target); 516 516 + _gpu_current_renderer->impl->UnsetVirtualResolution(_gpu_current_renderer, target); 517 517 } 518 518 519 519 void GPU_SetImageVirtualResolution(GPU_Image* image, Uint16 w, Uint16 h) 520 520 { 521 521 - if(current_renderer == NULL || current_renderer->current_context_target == NULL || w == 0 || h == 0) 521 521 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL || w == 0 || h == 0) 522 522 return; 523 523 524 524 if(image == NULL) ··· 531 531 532 532 void GPU_UnsetImageVirtualResolution(GPU_Image* image) 533 533 { 534 534 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 534 534 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 535 535 return; 536 536 537 537 if(image == NULL) ··· 547 547 { 548 548 unsigned int i; 549 549 // Free the error stack 550 550 - for(i = 0; i < error_code_stack_size; i++) 550 550 + for(i = 0; i < _gpu_error_code_stack_size; i++) 551 551 { 552 552 - free(error_code_stack[i].function); 553 553 - error_code_stack[i].function = NULL; 554 554 - free(error_code_stack[i].details); 555 555 - error_code_stack[i].details = NULL; 552 552 + free(_gpu_error_code_stack[i].function); 553 553 + _gpu_error_code_stack[i].function = NULL; 554 554 + free(_gpu_error_code_stack[i].details); 555 555 + _gpu_error_code_stack[i].details = NULL; 556 556 } 557 557 - free(error_code_stack); 558 558 - error_code_stack = NULL; 559 559 - num_error_codes = 0; 557 557 + free(_gpu_error_code_stack); 558 558 + _gpu_error_code_stack = NULL; 559 559 + _gpu_num_error_codes = 0; 560 560 561 561 // Reallocate with new size 562 562 - error_code_stack_size = max; 563 563 - init_error_stack(); 562 562 + _gpu_error_code_stack_size = max; 563 563 + gpu_init_error_stack(); 564 564 } 565 565 566 566 void GPU_CloseCurrentRenderer(void) 567 567 { 568 568 - if(current_renderer == NULL) 568 568 + if(_gpu_current_renderer == NULL) 569 569 return; 570 570 571 571 - current_renderer->impl->Quit(current_renderer); 572 572 - GPU_FreeRenderer(current_renderer); 571 571 + _gpu_current_renderer->impl->Quit(_gpu_current_renderer); 572 572 + GPU_FreeRenderer(_gpu_current_renderer); 573 573 } 574 574 575 575 void GPU_Quit(void) 576 576 { 577 577 unsigned int i; 578 578 - if(num_error_codes > 0 && GPU_GetDebugLevel() >= GPU_DEBUG_LEVEL_1) 579 579 - GPU_LogError("GPU_Quit: %d uncleared error%s.\n", num_error_codes, (num_error_codes > 1? "s" : "")); 578 578 + if(_gpu_num_error_codes > 0 && GPU_GetDebugLevel() >= GPU_DEBUG_LEVEL_1) 579 579 + GPU_LogError("GPU_Quit: %d uncleared error%s.\n", _gpu_num_error_codes, (_gpu_num_error_codes > 1? "s" : "")); 580 580 581 581 // Free the error stack 582 582 - for(i = 0; i < error_code_stack_size; i++) 582 582 + for(i = 0; i < _gpu_error_code_stack_size; i++) 583 583 { 584 584 - free(error_code_stack[i].function); 585 585 - error_code_stack[i].function = NULL; 586 586 - free(error_code_stack[i].details); 587 587 - error_code_stack[i].details = NULL; 584 584 + free(_gpu_error_code_stack[i].function); 585 585 + _gpu_error_code_stack[i].function = NULL; 586 586 + free(_gpu_error_code_stack[i].details); 587 587 + _gpu_error_code_stack[i].details = NULL; 588 588 } 589 589 - free(error_code_stack); 590 590 - error_code_stack = NULL; 591 591 - num_error_codes = 0; 589 589 + free(_gpu_error_code_stack); 590 590 + _gpu_error_code_stack = NULL; 591 591 + _gpu_num_error_codes = 0; 592 592 593 593 - if(current_renderer == NULL) 593 593 + if(_gpu_current_renderer == NULL) 594 594 return; 595 595 596 596 - current_renderer->impl->Quit(current_renderer); 597 597 - GPU_FreeRenderer(current_renderer); 596 596 + _gpu_current_renderer->impl->Quit(_gpu_current_renderer); 597 597 + GPU_FreeRenderer(_gpu_current_renderer); 598 598 // FIXME: Free all renderers 599 599 600 600 if(GPU_GetNumActiveRenderers() == 0) ··· 605 605 { 606 606 if(level > GPU_DEBUG_LEVEL_MAX) 607 607 level = GPU_DEBUG_LEVEL_MAX; 608 608 - debug_level = level; 608 608 + _gpu_debug_level = level; 609 609 } 610 610 611 611 GPU_DebugLevelEnum GPU_GetDebugLevel(void) 612 612 { 613 613 - return debug_level; 613 613 + return _gpu_debug_level; 614 614 } 615 615 616 616 void GPU_PushErrorCode(const char* function, GPU_ErrorEnum error, const char* details, ...) ··· 632 632 GPU_LogError("%s: %s\n", (function == NULL? "NULL" : function), GPU_GetErrorString(error)); 633 633 } 634 634 635 635 - if(num_error_codes < error_code_stack_size) 635 635 + if(_gpu_num_error_codes < _gpu_error_code_stack_size) 636 636 { 637 637 if(function == NULL) 638 638 - error_code_stack[num_error_codes].function[0] = '\0'; 638 638 + _gpu_error_code_stack[_gpu_num_error_codes].function[0] = '\0'; 639 639 else 640 640 { 641 641 - strncpy(error_code_stack[num_error_codes].function, function, GPU_ERROR_FUNCTION_STRING_MAX); 642 642 - error_code_stack[num_error_codes].function[GPU_ERROR_FUNCTION_STRING_MAX] = '\0'; 641 641 + strncpy(_gpu_error_code_stack[_gpu_num_error_codes].function, function, GPU_ERROR_FUNCTION_STRING_MAX); 642 642 + _gpu_error_code_stack[_gpu_num_error_codes].function[GPU_ERROR_FUNCTION_STRING_MAX] = '\0'; 643 643 } 644 644 - error_code_stack[num_error_codes].error = error; 644 644 + _gpu_error_code_stack[_gpu_num_error_codes].error = error; 645 645 if(details == NULL) 646 646 - error_code_stack[num_error_codes].details[0] = '\0'; 646 646 + _gpu_error_code_stack[_gpu_num_error_codes].details[0] = '\0'; 647 647 else 648 648 { 649 649 va_list lst; 650 650 va_start(lst, details); 651 651 - vsnprintf(error_code_stack[num_error_codes].details, GPU_ERROR_DETAILS_STRING_MAX, details, lst); 651 651 + vsnprintf(_gpu_error_code_stack[_gpu_num_error_codes].details, GPU_ERROR_DETAILS_STRING_MAX, details, lst); 652 652 va_end(lst); 653 653 } 654 654 - num_error_codes++; 654 654 + _gpu_num_error_codes++; 655 655 } 656 656 } 657 657 658 658 GPU_ErrorObject GPU_PopErrorCode(void) 659 659 { 660 660 - if(num_error_codes <= 0) 660 660 + if(_gpu_num_error_codes <= 0) 661 661 { 662 662 GPU_ErrorObject e = {NULL, GPU_ERROR_NONE, NULL}; 663 663 return e; 664 664 } 665 665 666 666 - return error_code_stack[--num_error_codes]; 666 666 + return _gpu_error_code_stack[--_gpu_num_error_codes]; 667 667 } 668 668 669 669 const char* GPU_GetErrorString(GPU_ErrorEnum error) ··· 771 771 772 772 GPU_Camera GPU_SetCamera(GPU_Target* target, GPU_Camera* cam) 773 773 { 774 774 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 774 774 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 775 775 return GPU_GetDefaultCamera(); 776 776 777 777 - return current_renderer->impl->SetCamera(current_renderer, target, cam); 777 777 + return _gpu_current_renderer->impl->SetCamera(_gpu_current_renderer, target, cam); 778 778 } 779 779 780 780 GPU_Image* GPU_CreateImage(Uint16 w, Uint16 h, GPU_FormatEnum format) 781 781 { 782 782 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 782 782 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 783 783 return NULL; 784 784 785 785 - return current_renderer->impl->CreateImage(current_renderer, w, h, format); 785 785 + return _gpu_current_renderer->impl->CreateImage(_gpu_current_renderer, w, h, format); 786 786 } 787 787 788 788 GPU_Image* GPU_CreateImageUsingTexture(Uint32 handle, Uint8 take_ownership) 789 789 { 790 790 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 790 790 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 791 791 return NULL; 792 792 793 793 - return current_renderer->impl->CreateImageUsingTexture(current_renderer, handle, take_ownership); 793 793 + return _gpu_current_renderer->impl->CreateImageUsingTexture(_gpu_current_renderer, handle, take_ownership); 794 794 } 795 795 796 796 GPU_Image* GPU_LoadImage(const char* filename) 797 797 { 798 798 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 798 798 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 799 799 return NULL; 800 800 801 801 - return current_renderer->impl->LoadImage(current_renderer, filename); 801 801 + return _gpu_current_renderer->impl->LoadImage(_gpu_current_renderer, filename); 802 802 } 803 803 804 804 GPU_Image* GPU_CreateAliasImage(GPU_Image* image) 805 805 { 806 806 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 806 806 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 807 807 return NULL; 808 808 809 809 - return current_renderer->impl->CreateAliasImage(current_renderer, image); 809 809 + return _gpu_current_renderer->impl->CreateAliasImage(_gpu_current_renderer, image); 810 810 } 811 811 812 812 Uint8 GPU_SaveImage(GPU_Image* image, const char* filename, GPU_FileFormatEnum format) 813 813 { 814 814 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 814 814 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 815 815 return 0; 816 816 817 817 - return current_renderer->impl->SaveImage(current_renderer, image, filename, format); 817 817 + return _gpu_current_renderer->impl->SaveImage(_gpu_current_renderer, image, filename, format); 818 818 } 819 819 820 820 GPU_Image* GPU_CopyImage(GPU_Image* image) 821 821 { 822 822 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 822 822 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 823 823 return NULL; 824 824 825 825 - return current_renderer->impl->CopyImage(current_renderer, image); 825 825 + return _gpu_current_renderer->impl->CopyImage(_gpu_current_renderer, image); 826 826 } 827 827 828 828 void GPU_UpdateImage(GPU_Image* image, const GPU_Rect* image_rect, SDL_Surface* surface, const GPU_Rect* surface_rect) 829 829 { 830 830 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 830 830 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 831 831 return; 832 832 833 833 - current_renderer->impl->UpdateImage(current_renderer, image, image_rect, surface, surface_rect); 833 833 + _gpu_current_renderer->impl->UpdateImage(_gpu_current_renderer, image, image_rect, surface, surface_rect); 834 834 } 835 835 836 836 void GPU_UpdateImageBytes(GPU_Image* image, const GPU_Rect* image_rect, const unsigned char* bytes, int bytes_per_row) 837 837 { 838 838 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 838 838 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 839 839 return; 840 840 841 841 - current_renderer->impl->UpdateImageBytes(current_renderer, image, image_rect, bytes, bytes_per_row); 841 841 + _gpu_current_renderer->impl->UpdateImageBytes(_gpu_current_renderer, image, image_rect, bytes, bytes_per_row); 842 842 } 843 843 844 844 SDL_Surface* GPU_LoadSurface(const char* filename) ··· 975 975 if(format == GPU_FILE_AUTO) 976 976 { 977 977 const char* extension = get_filename_ext(filename); 978 978 - if(GPU_strcasecmp(extension, "png") == 0) 978 978 + if(gpu_strcasecmp(extension, "png") == 0) 979 979 format = GPU_FILE_PNG; 980 980 - else if(GPU_strcasecmp(extension, "bmp") == 0) 980 980 + else if(gpu_strcasecmp(extension, "bmp") == 0) 981 981 format = GPU_FILE_BMP; 982 982 - else if(GPU_strcasecmp(extension, "tga") == 0) 982 982 + else if(gpu_strcasecmp(extension, "tga") == 0) 983 983 format = GPU_FILE_TGA; 984 984 else 985 985 { ··· 1010 1010 1011 1011 GPU_Image* GPU_CopyImageFromSurface(SDL_Surface* surface) 1012 1012 { 1013 1013 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1013 1013 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1014 1014 return NULL; 1015 1015 1016 1016 - return current_renderer->impl->CopyImageFromSurface(current_renderer, surface); 1016 1016 + return _gpu_current_renderer->impl->CopyImageFromSurface(_gpu_current_renderer, surface); 1017 1017 } 1018 1018 1019 1019 GPU_Image* GPU_CopyImageFromTarget(GPU_Target* target) 1020 1020 { 1021 1021 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1021 1021 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1022 1022 return NULL; 1023 1023 1024 1024 - return current_renderer->impl->CopyImageFromTarget(current_renderer, target); 1024 1024 + return _gpu_current_renderer->impl->CopyImageFromTarget(_gpu_current_renderer, target); 1025 1025 } 1026 1026 1027 1027 SDL_Surface* GPU_CopySurfaceFromTarget(GPU_Target* target) 1028 1028 { 1029 1029 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1029 1029 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1030 1030 return NULL; 1031 1031 1032 1032 - return current_renderer->impl->CopySurfaceFromTarget(current_renderer, target); 1032 1032 + return _gpu_current_renderer->impl->CopySurfaceFromTarget(_gpu_current_renderer, target); 1033 1033 } 1034 1034 1035 1035 SDL_Surface* GPU_CopySurfaceFromImage(GPU_Image* image) 1036 1036 { 1037 1037 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1037 1037 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1038 1038 return NULL; 1039 1039 1040 1040 - return current_renderer->impl->CopySurfaceFromImage(current_renderer, image); 1040 1040 + return _gpu_current_renderer->impl->CopySurfaceFromImage(_gpu_current_renderer, image); 1041 1041 } 1042 1042 1043 1043 void GPU_FreeImage(GPU_Image* image) 1044 1044 { 1045 1045 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1045 1045 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1046 1046 return; 1047 1047 1048 1048 - current_renderer->impl->FreeImage(current_renderer, image); 1048 1048 + _gpu_current_renderer->impl->FreeImage(_gpu_current_renderer, image); 1049 1049 } 1050 1050 1051 1051 1052 1052 GPU_Target* GPU_GetContextTarget(void) 1053 1053 { 1054 1054 - if(current_renderer == NULL) 1054 1054 + if(_gpu_current_renderer == NULL) 1055 1055 return NULL; 1056 1056 1057 1057 - return current_renderer->current_context_target; 1057 1057 + return _gpu_current_renderer->current_context_target; 1058 1058 } 1059 1059 1060 1060 1061 1061 GPU_Target* GPU_LoadTarget(GPU_Image* image) 1062 1062 { 1063 1063 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1063 1063 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1064 1064 return NULL; 1065 1065 1066 1066 - return current_renderer->impl->LoadTarget(current_renderer, image); 1066 1066 + return _gpu_current_renderer->impl->LoadTarget(_gpu_current_renderer, image); 1067 1067 } 1068 1068 1069 1069 1070 1070 1071 1071 void GPU_FreeTarget(GPU_Target* target) 1072 1072 { 1073 1073 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1073 1073 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1074 1074 return; 1075 1075 1076 1076 - current_renderer->impl->FreeTarget(current_renderer, target); 1076 1076 + _gpu_current_renderer->impl->FreeTarget(_gpu_current_renderer, target); 1077 1077 } 1078 1078 1079 1079 ··· 1090 1090 if(target == NULL) 1091 1091 RETURN_ERROR(GPU_ERROR_NULL_ARGUMENT, "target"); 1092 1092 1093 1093 - current_renderer->impl->Blit(current_renderer, image, src_rect, target, x, y); 1093 1093 + _gpu_current_renderer->impl->Blit(_gpu_current_renderer, image, src_rect, target, x, y); 1094 1094 } 1095 1095 1096 1096 ··· 1106 1106 if(target == NULL) 1107 1107 RETURN_ERROR(GPU_ERROR_NULL_ARGUMENT, "target"); 1108 1108 1109 1109 - current_renderer->impl->BlitRotate(current_renderer, image, src_rect, target, x, y, angle); 1109 1109 + _gpu_current_renderer->impl->BlitRotate(_gpu_current_renderer, image, src_rect, target, x, y, angle); 1110 1110 } 1111 1111 1112 1112 void GPU_BlitScale(GPU_Image* image, GPU_Rect* src_rect, GPU_Target* target, float x, float y, float scaleX, float scaleY) ··· 1121 1121 if(target == NULL) 1122 1122 RETURN_ERROR(GPU_ERROR_NULL_ARGUMENT, "target"); 1123 1123 1124 1124 - current_renderer->impl->BlitScale(current_renderer, image, src_rect, target, x, y, scaleX, scaleY); 1124 1124 + _gpu_current_renderer->impl->BlitScale(_gpu_current_renderer, image, src_rect, target, x, y, scaleX, scaleY); 1125 1125 } 1126 1126 1127 1127 void GPU_BlitTransform(GPU_Image* image, GPU_Rect* src_rect, GPU_Target* target, float x, float y, float angle, float scaleX, float scaleY) ··· 1136 1136 if(target == NULL) 1137 1137 RETURN_ERROR(GPU_ERROR_NULL_ARGUMENT, "target"); 1138 1138 1139 1139 - current_renderer->impl->BlitTransform(current_renderer, image, src_rect, target, x, y, angle, scaleX, scaleY); 1139 1139 + _gpu_current_renderer->impl->BlitTransform(_gpu_current_renderer, image, src_rect, target, x, y, angle, scaleX, scaleY); 1140 1140 } 1141 1141 1142 1142 void GPU_BlitTransformX(GPU_Image* image, GPU_Rect* src_rect, GPU_Target* target, float x, float y, float pivot_x, float pivot_y, float angle, float scaleX, float scaleY) ··· 1151 1151 if(target == NULL) 1152 1152 RETURN_ERROR(GPU_ERROR_NULL_ARGUMENT, "target"); 1153 1153 1154 1154 - current_renderer->impl->BlitTransformX(current_renderer, image, src_rect, target, x, y, pivot_x, pivot_y, angle, scaleX, scaleY); 1154 1154 + _gpu_current_renderer->impl->BlitTransformX(_gpu_current_renderer, image, src_rect, target, x, y, pivot_x, pivot_y, angle, scaleX, scaleY); 1155 1155 } 1156 1156 1157 1157 void GPU_BlitTransformMatrix(GPU_Image* image, GPU_Rect* src_rect, GPU_Target* target, float x, float y, float* matrix3x3) ··· 1169 1169 if(matrix3x3 == NULL) 1170 1170 return; 1171 1171 1172 1172 - current_renderer->impl->BlitTransformMatrix(current_renderer, image, src_rect, target, x, y, matrix3x3); 1172 1172 + _gpu_current_renderer->impl->BlitTransformMatrix(_gpu_current_renderer, image, src_rect, target, x, y, matrix3x3); 1173 1173 } 1174 1174 1175 1175 void GPU_TriangleBatch(GPU_Image* image, GPU_Target* target, unsigned short num_vertices, float* values, unsigned int num_indices, unsigned short* indices, GPU_BatchFlagEnum flags) ··· 1186 1186 return; 1187 1187 1188 1188 1189 1189 - current_renderer->impl->TriangleBatch(current_renderer, image, target, num_vertices, values, num_indices, indices, flags); 1189 1189 + _gpu_current_renderer->impl->TriangleBatch(_gpu_current_renderer, image, target, num_vertices, values, num_indices, indices, flags); 1190 1190 } 1191 1191 1192 1192 ··· 1194 1194 1195 1195 void GPU_GenerateMipmaps(GPU_Image* image) 1196 1196 { 1197 1197 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1197 1197 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1198 1198 return; 1199 1199 1200 1200 - current_renderer->impl->GenerateMipmaps(current_renderer, image); 1200 1200 + _gpu_current_renderer->impl->GenerateMipmaps(_gpu_current_renderer, image); 1201 1201 } 1202 1202 1203 1203 ··· 1205 1205 1206 1206 GPU_Rect GPU_SetClipRect(GPU_Target* target, GPU_Rect rect) 1207 1207 { 1208 1208 - if(target == NULL || current_renderer == NULL || current_renderer->current_context_target == NULL) 1208 1208 + if(target == NULL || _gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1209 1209 { 1210 1210 GPU_Rect r = {0,0,0,0}; 1211 1211 return r; 1212 1212 } 1213 1213 1214 1214 - return current_renderer->impl->SetClip(current_renderer, target, (Sint16)rect.x, (Sint16)rect.y, (Uint16)rect.w, (Uint16)rect.h); 1214 1214 + return _gpu_current_renderer->impl->SetClip(_gpu_current_renderer, target, (Sint16)rect.x, (Sint16)rect.y, (Uint16)rect.w, (Uint16)rect.h); 1215 1215 } 1216 1216 1217 1217 GPU_Rect GPU_SetClip(GPU_Target* target, Sint16 x, Sint16 y, Uint16 w, Uint16 h) 1218 1218 { 1219 1219 - if(target == NULL || current_renderer == NULL || current_renderer->current_context_target == NULL) 1219 1219 + if(target == NULL || _gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1220 1220 { 1221 1221 GPU_Rect r = {0,0,0,0}; 1222 1222 return r; 1223 1223 } 1224 1224 1225 1225 - return current_renderer->impl->SetClip(current_renderer, target, x, y, w, h); 1225 1225 + return _gpu_current_renderer->impl->SetClip(_gpu_current_renderer, target, x, y, w, h); 1226 1226 } 1227 1227 1228 1228 void GPU_UnsetClip(GPU_Target* target) 1229 1229 { 1230 1230 - if(target == NULL || current_renderer == NULL || current_renderer->current_context_target == NULL) 1230 1230 + if(target == NULL || _gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1231 1231 return; 1232 1232 1233 1233 - current_renderer->impl->UnsetClip(current_renderer, target); 1233 1233 + _gpu_current_renderer->impl->UnsetClip(_gpu_current_renderer, target); 1234 1234 } 1235 1235 1236 1236 ··· 1349 1349 1350 1350 void GPU_SetShapeBlending(Uint8 enable) 1351 1351 { 1352 1352 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1352 1352 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1353 1353 return; 1354 1354 1355 1355 - current_renderer->current_context_target->context->shapes_use_blending = enable; 1355 1355 + _gpu_current_renderer->current_context_target->context->shapes_use_blending = enable; 1356 1356 } 1357 1357 1358 1358 ··· 1468 1468 void GPU_SetShapeBlendFunction(GPU_BlendFuncEnum source_color, GPU_BlendFuncEnum dest_color, GPU_BlendFuncEnum source_alpha, GPU_BlendFuncEnum dest_alpha) 1469 1469 { 1470 1470 GPU_Context* context; 1471 1471 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1471 1471 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1472 1472 return; 1473 1473 1474 1474 - context = current_renderer->current_context_target->context; 1474 1474 + context = _gpu_current_renderer->current_context_target->context; 1475 1475 1476 1476 context->shapes_blend_mode.source_color = source_color; 1477 1477 context->shapes_blend_mode.dest_color = dest_color; ··· 1482 1482 void GPU_SetShapeBlendEquation(GPU_BlendEqEnum color_equation, GPU_BlendEqEnum alpha_equation) 1483 1483 { 1484 1484 GPU_Context* context; 1485 1485 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1485 1485 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1486 1486 return; 1487 1487 1488 1488 - context = current_renderer->current_context_target->context; 1488 1488 + context = _gpu_current_renderer->current_context_target->context; 1489 1489 1490 1490 context->shapes_blend_mode.color_equation = color_equation; 1491 1491 context->shapes_blend_mode.alpha_equation = alpha_equation; ··· 1494 1494 void GPU_SetShapeBlendMode(GPU_BlendPresetEnum preset) 1495 1495 { 1496 1496 GPU_BlendMode b; 1497 1497 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1497 1497 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1498 1498 return; 1499 1499 1500 1500 b = GPU_GetBlendModeFromPreset(preset); ··· 1504 1504 1505 1505 void GPU_SetImageFilter(GPU_Image* image, GPU_FilterEnum filter) 1506 1506 { 1507 1507 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1507 1507 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1508 1508 return; 1509 1509 if(image == NULL) 1510 1510 return; 1511 1511 1512 1512 - current_renderer->impl->SetImageFilter(current_renderer, image, filter); 1512 1512 + _gpu_current_renderer->impl->SetImageFilter(_gpu_current_renderer, image, filter); 1513 1513 } 1514 1514 1515 1515 GPU_SnapEnum GPU_GetSnapMode(GPU_Image* image) ··· 1530 1530 1531 1531 void GPU_SetWrapMode(GPU_Image* image, GPU_WrapEnum wrap_mode_x, GPU_WrapEnum wrap_mode_y) 1532 1532 { 1533 1533 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1533 1533 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1534 1534 return; 1535 1535 if(image == NULL) 1536 1536 return; 1537 1537 1538 1538 - current_renderer->impl->SetWrapMode(current_renderer, image, wrap_mode_x, wrap_mode_y); 1538 1538 + _gpu_current_renderer->impl->SetWrapMode(_gpu_current_renderer, image, wrap_mode_x, wrap_mode_y); 1539 1539 } 1540 1540 1541 1541 1542 1542 SDL_Color GPU_GetPixel(GPU_Target* target, Sint16 x, Sint16 y) 1543 1543 { 1544 1544 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1544 1544 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1545 1545 { 1546 1546 SDL_Color c = {0,0,0,0}; 1547 1547 return c; 1548 1548 } 1549 1549 1550 1550 - return current_renderer->impl->GetPixel(current_renderer, target, x, y); 1550 1550 + return _gpu_current_renderer->impl->GetPixel(_gpu_current_renderer, target, x, y); 1551 1551 } 1552 1552 1553 1553 ··· 1558 1558 1559 1559 void GPU_Clear(GPU_Target* target) 1560 1560 { 1561 1561 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1561 1561 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1562 1562 return; 1563 1563 1564 1564 - current_renderer->impl->ClearRGBA(current_renderer, target, 0, 0, 0, 0); 1564 1564 + _gpu_current_renderer->impl->ClearRGBA(_gpu_current_renderer, target, 0, 0, 0, 0); 1565 1565 } 1566 1566 1567 1567 void GPU_ClearColor(GPU_Target* target, SDL_Color color) 1568 1568 { 1569 1569 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1569 1569 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1570 1570 return; 1571 1571 1572 1572 - current_renderer->impl->ClearRGBA(current_renderer, target, color.r, color.g, color.b, GET_ALPHA(color)); 1572 1572 + _gpu_current_renderer->impl->ClearRGBA(_gpu_current_renderer, target, color.r, color.g, color.b, GET_ALPHA(color)); 1573 1573 } 1574 1574 1575 1575 void GPU_ClearRGB(GPU_Target* target, Uint8 r, Uint8 g, Uint8 b) 1576 1576 { 1577 1577 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1577 1577 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1578 1578 return; 1579 1579 1580 1580 - current_renderer->impl->ClearRGBA(current_renderer, target, r, g, b, 255); 1580 1580 + _gpu_current_renderer->impl->ClearRGBA(_gpu_current_renderer, target, r, g, b, 255); 1581 1581 } 1582 1582 1583 1583 void GPU_ClearRGBA(GPU_Target* target, Uint8 r, Uint8 g, Uint8 b, Uint8 a) 1584 1584 { 1585 1585 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1585 1585 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1586 1586 return; 1587 1587 1588 1588 - current_renderer->impl->ClearRGBA(current_renderer, target, r, g, b, a); 1588 1588 + _gpu_current_renderer->impl->ClearRGBA(_gpu_current_renderer, target, r, g, b, a); 1589 1589 } 1590 1590 1591 1591 void GPU_FlushBlitBuffer(void) 1592 1592 { 1593 1593 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1593 1593 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1594 1594 return; 1595 1595 1596 1596 - current_renderer->impl->FlushBlitBuffer(current_renderer); 1596 1596 + _gpu_current_renderer->impl->FlushBlitBuffer(_gpu_current_renderer); 1597 1597 } 1598 1598 1599 1599 void GPU_Flip(GPU_Target* target) 1600 1600 { 1601 1601 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1601 1601 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1602 1602 return; 1603 1603 1604 1604 - current_renderer->impl->Flip(current_renderer, target); 1604 1604 + _gpu_current_renderer->impl->Flip(_gpu_current_renderer, target); 1605 1605 } 1606 1606 1607 1607 ··· 1613 1613 1614 1614 Uint32 GPU_CompileShader_RW(GPU_ShaderEnum shader_type, SDL_RWops* shader_source) 1615 1615 { 1616 1616 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1616 1616 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1617 1617 return 0; 1618 1618 1619 1619 - return current_renderer->impl->CompileShader_RW(current_renderer, shader_type, shader_source); 1619 1619 + return _gpu_current_renderer->impl->CompileShader_RW(_gpu_current_renderer, shader_type, shader_source); 1620 1620 } 1621 1621 1622 1622 Uint32 GPU_LoadShader(GPU_ShaderEnum shader_type, const char* filename) ··· 1642 1642 1643 1643 Uint32 GPU_CompileShader(GPU_ShaderEnum shader_type, const char* shader_source) 1644 1644 { 1645 1645 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1645 1645 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1646 1646 return 0; 1647 1647 1648 1648 - return current_renderer->impl->CompileShader(current_renderer, shader_type, shader_source); 1648 1648 + return _gpu_current_renderer->impl->CompileShader(_gpu_current_renderer, shader_type, shader_source); 1649 1649 } 1650 1650 1651 1651 Uint8 GPU_LinkShaderProgram(Uint32 program_object) 1652 1652 { 1653 1653 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1653 1653 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1654 1654 return 0; 1655 1655 1656 1656 - return current_renderer->impl->LinkShaderProgram(current_renderer, program_object); 1656 1656 + return _gpu_current_renderer->impl->LinkShaderProgram(_gpu_current_renderer, program_object); 1657 1657 } 1658 1658 1659 1659 Uint32 GPU_CreateShaderProgram(void) 1660 1660 { 1661 1661 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1661 1661 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1662 1662 return 0; 1663 1663 1664 1664 - return current_renderer->impl->CreateShaderProgram(current_renderer); 1664 1664 + return _gpu_current_renderer->impl->CreateShaderProgram(_gpu_current_renderer); 1665 1665 } 1666 1666 1667 1667 Uint32 GPU_LinkShaders(Uint32 shader_object1, Uint32 shader_object2) 1668 1668 { 1669 1669 Uint32 p; 1670 1670 1671 1671 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1671 1671 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1672 1672 return 0; 1673 1673 1674 1674 - if((current_renderer->enabled_features & GPU_FEATURE_BASIC_SHADERS) != GPU_FEATURE_BASIC_SHADERS) 1674 1674 + if((_gpu_current_renderer->enabled_features & GPU_FEATURE_BASIC_SHADERS) != GPU_FEATURE_BASIC_SHADERS) 1675 1675 return 0; 1676 1676 1677 1677 - p = current_renderer->impl->CreateShaderProgram(current_renderer); 1677 1677 + p = _gpu_current_renderer->impl->CreateShaderProgram(_gpu_current_renderer); 1678 1678 1679 1679 - current_renderer->impl->AttachShader(current_renderer, p, shader_object1); 1680 1680 - current_renderer->impl->AttachShader(current_renderer, p, shader_object2); 1679 1679 + _gpu_current_renderer->impl->AttachShader(_gpu_current_renderer, p, shader_object1); 1680 1680 + _gpu_current_renderer->impl->AttachShader(_gpu_current_renderer, p, shader_object2); 1681 1681 1682 1682 - if(current_renderer->impl->LinkShaderProgram(current_renderer, p)) 1682 1682 + if(_gpu_current_renderer->impl->LinkShaderProgram(_gpu_current_renderer, p)) 1683 1683 return p; 1684 1684 1685 1685 - current_renderer->impl->FreeShaderProgram(current_renderer, p); 1685 1685 + _gpu_current_renderer->impl->FreeShaderProgram(_gpu_current_renderer, p); 1686 1686 return 0; 1687 1687 } 1688 1688 1689 1689 void GPU_FreeShader(Uint32 shader_object) 1690 1690 { 1691 1691 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1691 1691 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1692 1692 return; 1693 1693 1694 1694 - current_renderer->impl->FreeShader(current_renderer, shader_object); 1694 1694 + _gpu_current_renderer->impl->FreeShader(_gpu_current_renderer, shader_object); 1695 1695 } 1696 1696 1697 1697 void GPU_FreeShaderProgram(Uint32 program_object) 1698 1698 { 1699 1699 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1699 1699 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1700 1700 return; 1701 1701 1702 1702 - current_renderer->impl->FreeShaderProgram(current_renderer, program_object); 1702 1702 + _gpu_current_renderer->impl->FreeShaderProgram(_gpu_current_renderer, program_object); 1703 1703 } 1704 1704 1705 1705 void GPU_AttachShader(Uint32 program_object, Uint32 shader_object) 1706 1706 { 1707 1707 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1707 1707 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1708 1708 return; 1709 1709 1710 1710 - current_renderer->impl->AttachShader(current_renderer, program_object, shader_object); 1710 1710 + _gpu_current_renderer->impl->AttachShader(_gpu_current_renderer, program_object, shader_object); 1711 1711 } 1712 1712 1713 1713 void GPU_DetachShader(Uint32 program_object, Uint32 shader_object) 1714 1714 { 1715 1715 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1715 1715 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1716 1716 return; 1717 1717 1718 1718 - current_renderer->impl->DetachShader(current_renderer, program_object, shader_object); 1718 1718 + _gpu_current_renderer->impl->DetachShader(_gpu_current_renderer, program_object, shader_object); 1719 1719 } 1720 1720 1721 1721 Uint8 GPU_IsDefaultShaderProgram(Uint32 program_object) 1722 1722 { 1723 1723 GPU_Context* context; 1724 1724 1725 1725 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1725 1725 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1726 1726 return 0; 1727 1727 1728 1728 - context = current_renderer->current_context_target->context; 1728 1728 + context = _gpu_current_renderer->current_context_target->context; 1729 1729 return (program_object == context->default_textured_shader_program || program_object == context->default_untextured_shader_program); 1730 1730 } 1731 1731 1732 1732 void GPU_ActivateShaderProgram(Uint32 program_object, GPU_ShaderBlock* block) 1733 1733 { 1734 1734 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1734 1734 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1735 1735 return; 1736 1736 1737 1737 - current_renderer->impl->ActivateShaderProgram(current_renderer, program_object, block); 1737 1737 + _gpu_current_renderer->impl->ActivateShaderProgram(_gpu_current_renderer, program_object, block); 1738 1738 } 1739 1739 1740 1740 void GPU_DeactivateShaderProgram(void) 1741 1741 { 1742 1742 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1742 1742 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1743 1743 return; 1744 1744 1745 1745 - current_renderer->impl->DeactivateShaderProgram(current_renderer); 1745 1745 + _gpu_current_renderer->impl->DeactivateShaderProgram(_gpu_current_renderer); 1746 1746 } 1747 1747 1748 1748 const char* GPU_GetShaderMessage(void) 1749 1749 { 1750 1750 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1750 1750 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1751 1751 return NULL; 1752 1752 1753 1753 - return current_renderer->impl->GetShaderMessage(current_renderer); 1753 1753 + return _gpu_current_renderer->impl->GetShaderMessage(_gpu_current_renderer); 1754 1754 } 1755 1755 1756 1756 int GPU_GetAttributeLocation(Uint32 program_object, const char* attrib_name) 1757 1757 { 1758 1758 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1758 1758 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1759 1759 return 0; 1760 1760 1761 1761 - return current_renderer->impl->GetAttributeLocation(current_renderer, program_object, attrib_name); 1761 1761 + return _gpu_current_renderer->impl->GetAttributeLocation(_gpu_current_renderer, program_object, attrib_name); 1762 1762 } 1763 1763 1764 1764 GPU_AttributeFormat GPU_MakeAttributeFormat(int num_elems_per_vertex, GPU_TypeEnum type, Uint8 normalize, int stride_bytes, int offset_bytes) ··· 1784 1784 1785 1785 int GPU_GetUniformLocation(Uint32 program_object, const char* uniform_name) 1786 1786 { 1787 1787 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1787 1787 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1788 1788 return 0; 1789 1789 1790 1790 - return current_renderer->impl->GetUniformLocation(current_renderer, program_object, uniform_name); 1790 1790 + return _gpu_current_renderer->impl->GetUniformLocation(_gpu_current_renderer, program_object, uniform_name); 1791 1791 } 1792 1792 1793 1793 GPU_ShaderBlock GPU_LoadShaderBlock(Uint32 program_object, const char* position_name, const char* texcoord_name, const char* color_name, const char* modelViewMatrix_name) 1794 1794 { 1795 1795 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1795 1795 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1796 1796 { 1797 1797 GPU_ShaderBlock b; 1798 1798 b.position_loc = -1; ··· 1802 1802 return b; 1803 1803 } 1804 1804 1805 1805 - return current_renderer->impl->LoadShaderBlock(current_renderer, program_object, position_name, texcoord_name, color_name, modelViewMatrix_name); 1805 1805 + return _gpu_current_renderer->impl->LoadShaderBlock(_gpu_current_renderer, program_object, position_name, texcoord_name, color_name, modelViewMatrix_name); 1806 1806 } 1807 1807 1808 1808 void GPU_SetShaderBlock(GPU_ShaderBlock block) 1809 1809 { 1810 1810 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1810 1810 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1811 1811 return; 1812 1812 1813 1813 - current_renderer->impl->SetShaderBlock(current_renderer, block); 1813 1813 + _gpu_current_renderer->impl->SetShaderBlock(_gpu_current_renderer, block); 1814 1814 } 1815 1815 1816 1816 void GPU_SetShaderImage(GPU_Image* image, int location, int image_unit) 1817 1817 { 1818 1818 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1818 1818 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1819 1819 return; 1820 1820 1821 1821 - current_renderer->impl->SetShaderImage(current_renderer, image, location, image_unit); 1821 1821 + _gpu_current_renderer->impl->SetShaderImage(_gpu_current_renderer, image, location, image_unit); 1822 1822 } 1823 1823 1824 1824 void GPU_GetUniformiv(Uint32 program_object, int location, int* values) 1825 1825 { 1826 1826 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1826 1826 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1827 1827 return; 1828 1828 1829 1829 - current_renderer->impl->GetUniformiv(current_renderer, program_object, location, values); 1829 1829 + _gpu_current_renderer->impl->GetUniformiv(_gpu_current_renderer, program_object, location, values); 1830 1830 } 1831 1831 1832 1832 void GPU_SetUniformi(int location, int value) 1833 1833 { 1834 1834 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1834 1834 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1835 1835 return; 1836 1836 1837 1837 - current_renderer->impl->SetUniformi(current_renderer, location, value); 1837 1837 + _gpu_current_renderer->impl->SetUniformi(_gpu_current_renderer, location, value); 1838 1838 } 1839 1839 1840 1840 void GPU_SetUniformiv(int location, int num_elements_per_value, int num_values, int* values) 1841 1841 { 1842 1842 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1842 1842 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1843 1843 return; 1844 1844 1845 1845 - current_renderer->impl->SetUniformiv(current_renderer, location, num_elements_per_value, num_values, values); 1845 1845 + _gpu_current_renderer->impl->SetUniformiv(_gpu_current_renderer, location, num_elements_per_value, num_values, values); 1846 1846 } 1847 1847 1848 1848 1849 1849 void GPU_GetUniformuiv(Uint32 program_object, int location, unsigned int* values) 1850 1850 { 1851 1851 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1851 1851 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1852 1852 return; 1853 1853 1854 1854 - current_renderer->impl->GetUniformuiv(current_renderer, program_object, location, values); 1854 1854 + _gpu_current_renderer->impl->GetUniformuiv(_gpu_current_renderer, program_object, location, values); 1855 1855 } 1856 1856 1857 1857 void GPU_SetUniformui(int location, unsigned int value) 1858 1858 { 1859 1859 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1859 1859 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1860 1860 return; 1861 1861 1862 1862 - current_renderer->impl->SetUniformui(current_renderer, location, value); 1862 1862 + _gpu_current_renderer->impl->SetUniformui(_gpu_current_renderer, location, value); 1863 1863 } 1864 1864 1865 1865 void GPU_SetUniformuiv(int location, int num_elements_per_value, int num_values, unsigned int* values) 1866 1866 { 1867 1867 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1867 1867 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1868 1868 return; 1869 1869 1870 1870 - current_renderer->impl->SetUniformuiv(current_renderer, location, num_elements_per_value, num_values, values); 1870 1870 + _gpu_current_renderer->impl->SetUniformuiv(_gpu_current_renderer, location, num_elements_per_value, num_values, values); 1871 1871 } 1872 1872 1873 1873 1874 1874 void GPU_GetUniformfv(Uint32 program_object, int location, float* values) 1875 1875 { 1876 1876 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1876 1876 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1877 1877 return; 1878 1878 1879 1879 - current_renderer->impl->GetUniformfv(current_renderer, program_object, location, values); 1879 1879 + _gpu_current_renderer->impl->GetUniformfv(_gpu_current_renderer, program_object, location, values); 1880 1880 } 1881 1881 1882 1882 void GPU_SetUniformf(int location, float value) 1883 1883 { 1884 1884 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1884 1884 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1885 1885 return; 1886 1886 1887 1887 - current_renderer->impl->SetUniformf(current_renderer, location, value); 1887 1887 + _gpu_current_renderer->impl->SetUniformf(_gpu_current_renderer, location, value); 1888 1888 } 1889 1889 1890 1890 void GPU_SetUniformfv(int location, int num_elements_per_value, int num_values, float* values) 1891 1891 { 1892 1892 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1892 1892 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1893 1893 return; 1894 1894 1895 1895 - current_renderer->impl->SetUniformfv(current_renderer, location, num_elements_per_value, num_values, values); 1895 1895 + _gpu_current_renderer->impl->SetUniformfv(_gpu_current_renderer, location, num_elements_per_value, num_values, values); 1896 1896 } 1897 1897 1898 1898 // Same as GPU_GetUniformfv() 1899 1899 void GPU_GetUniformMatrixfv(Uint32 program_object, int location, float* values) 1900 1900 { 1901 1901 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1901 1901 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1902 1902 return; 1903 1903 1904 1904 - current_renderer->impl->GetUniformfv(current_renderer, program_object, location, values); 1904 1904 + _gpu_current_renderer->impl->GetUniformfv(_gpu_current_renderer, program_object, location, values); 1905 1905 } 1906 1906 1907 1907 void GPU_SetUniformMatrixfv(int location, int num_matrices, int num_rows, int num_columns, Uint8 transpose, float* values) 1908 1908 { 1909 1909 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1909 1909 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1910 1910 return; 1911 1911 1912 1912 - current_renderer->impl->SetUniformMatrixfv(current_renderer, location, num_matrices, num_rows, num_columns, transpose, values); 1912 1912 + _gpu_current_renderer->impl->SetUniformMatrixfv(_gpu_current_renderer, location, num_matrices, num_rows, num_columns, transpose, values); 1913 1913 } 1914 1914 1915 1915 1916 1916 void GPU_SetAttributef(int location, float value) 1917 1917 { 1918 1918 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1918 1918 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1919 1919 return; 1920 1920 1921 1921 - current_renderer->impl->SetAttributef(current_renderer, location, value); 1921 1921 + _gpu_current_renderer->impl->SetAttributef(_gpu_current_renderer, location, value); 1922 1922 } 1923 1923 1924 1924 void GPU_SetAttributei(int location, int value) 1925 1925 { 1926 1926 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1926 1926 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1927 1927 return; 1928 1928 1929 1929 - current_renderer->impl->SetAttributei(current_renderer, location, value); 1929 1929 + _gpu_current_renderer->impl->SetAttributei(_gpu_current_renderer, location, value); 1930 1930 } 1931 1931 1932 1932 void GPU_SetAttributeui(int location, unsigned int value) 1933 1933 { 1934 1934 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1934 1934 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1935 1935 return; 1936 1936 1937 1937 - current_renderer->impl->SetAttributeui(current_renderer, location, value); 1937 1937 + _gpu_current_renderer->impl->SetAttributeui(_gpu_current_renderer, location, value); 1938 1938 } 1939 1939 1940 1940 void GPU_SetAttributefv(int location, int num_elements, float* value) 1941 1941 { 1942 1942 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1942 1942 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1943 1943 return; 1944 1944 1945 1945 - current_renderer->impl->SetAttributefv(current_renderer, location, num_elements, value); 1945 1945 + _gpu_current_renderer->impl->SetAttributefv(_gpu_current_renderer, location, num_elements, value); 1946 1946 } 1947 1947 1948 1948 void GPU_SetAttributeiv(int location, int num_elements, int* value) 1949 1949 { 1950 1950 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1950 1950 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1951 1951 return; 1952 1952 1953 1953 - current_renderer->impl->SetAttributeiv(current_renderer, location, num_elements, value); 1953 1953 + _gpu_current_renderer->impl->SetAttributeiv(_gpu_current_renderer, location, num_elements, value); 1954 1954 } 1955 1955 1956 1956 void GPU_SetAttributeuiv(int location, int num_elements, unsigned int* value) 1957 1957 { 1958 1958 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1958 1958 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1959 1959 return; 1960 1960 1961 1961 - current_renderer->impl->SetAttributeuiv(current_renderer, location, num_elements, value); 1961 1961 + _gpu_current_renderer->impl->SetAttributeuiv(_gpu_current_renderer, location, num_elements, value); 1962 1962 } 1963 1963 1964 1964 void GPU_SetAttributeSource(int num_values, GPU_Attribute source) 1965 1965 { 1966 1966 - if(current_renderer == NULL || current_renderer->current_context_target == NULL) 1966 1966 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1967 1967 return; 1968 1968 1969 1969 - current_renderer->impl->SetAttributeSource(current_renderer, num_values, source); 1969 1969 + _gpu_current_renderer->impl->SetAttributeSource(_gpu_current_renderer, num_values, source); 1970 1970 } 1971 1971 1972 1972 1973 1973 1974 1974 1975 1975 - // GPU_strcasecmp() 1975 1975 + // gpu_strcasecmp() 1976 1976 // A portable strcasecmp() from UC Berkeley 1977 1977 /* 1978 1978 * Copyright (c) 1987 Regents of the University of California. ··· 2026 2026 '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377', 2027 2027 }; 2028 2028 2029 2029 - int GPU_strcasecmp(const char* s1, const char* s2) 2029 2029 + int gpu_strcasecmp(const char* s1, const char* s2) 2030 2030 { 2031 2031 unsigned char u1, u2; 2032 2032

+66 -66

src/SDL_gpu_renderer.c

reviewed

··· 8 8 #define __func__ __FUNCTION__ 9 9 #endif 10 10 11 11 - #define MAX_ACTIVE_RENDERERS 20 12 12 - #define MAX_REGISTERED_RENDERERS 10 11 11 + #define GPU_MAX_ACTIVE_RENDERERS 20 12 12 + #define GPU_MAX_REGISTERED_RENDERERS 10 13 13 14 14 - typedef struct RendererRegistration 14 14 + typedef struct GPU_RendererRegistration 15 15 { 16 16 GPU_RendererID id; 17 17 GPU_Renderer* (*createFn)(GPU_RendererID request); 18 18 void (*freeFn)(GPU_Renderer*); 19 19 - } RendererRegistration; 19 19 + } GPU_RendererRegistration; 20 20 21 21 - static Uint8 initialized = 0; 21 21 + static Uint8 _gpu_renderer_register_is_initialized = 0; 22 22 23 23 - static GPU_Renderer* rendererMap[MAX_ACTIVE_RENDERERS]; 24 24 - static RendererRegistration rendererRegister[MAX_REGISTERED_RENDERERS]; 23 23 + static GPU_Renderer* _gpu_renderer_map[GPU_MAX_ACTIVE_RENDERERS]; 24 24 + static GPU_RendererRegistration _gpu_renderer_register[GPU_MAX_REGISTERED_RENDERERS]; 25 25 26 26 27 27 28 28 29 29 - void GPU_InitRendererRegister(void); 29 29 + void gpu_init_renderer_register(void); 30 30 31 31 32 32 GPU_RendererEnum GPU_ReserveNextRendererEnum(void) ··· 40 40 int count; 41 41 int i; 42 42 43 43 - GPU_InitRendererRegister(); 43 43 + gpu_init_renderer_register(); 44 44 45 45 count = 0; 46 46 - for(i = 0; i < MAX_ACTIVE_RENDERERS; i++) 46 46 + for(i = 0; i < GPU_MAX_ACTIVE_RENDERERS; i++) 47 47 { 48 48 - if(rendererMap[i] != NULL) 48 48 + if(_gpu_renderer_map[i] != NULL) 49 49 count++; 50 50 } 51 51 return count; ··· 56 56 int count; 57 57 int i; 58 58 59 59 - GPU_InitRendererRegister(); 59 59 + gpu_init_renderer_register(); 60 60 61 61 count = 0; 62 62 - for(i = 0; i < MAX_ACTIVE_RENDERERS; i++) 62 62 + for(i = 0; i < GPU_MAX_ACTIVE_RENDERERS; i++) 63 63 { 64 64 - if(rendererMap[i] != NULL) 64 64 + if(_gpu_renderer_map[i] != NULL) 65 65 { 66 66 - renderers_array[count] = rendererMap[i]->id; 66 66 + renderers_array[count] = _gpu_renderer_map[i]->id; 67 67 count++; 68 68 } 69 69 } ··· 75 75 int count; 76 76 int i; 77 77 78 78 - GPU_InitRendererRegister(); 78 78 + gpu_init_renderer_register(); 79 79 80 80 count = 0; 81 81 - for(i = 0; i < MAX_REGISTERED_RENDERERS; i++) 81 81 + for(i = 0; i < GPU_MAX_REGISTERED_RENDERERS; i++) 82 82 { 83 83 - if(rendererRegister[i].id.renderer != GPU_RENDERER_UNKNOWN) 83 83 + if(_gpu_renderer_register[i].id.renderer != GPU_RENDERER_UNKNOWN) 84 84 count++; 85 85 } 86 86 return count; ··· 91 91 int count; 92 92 int i; 93 93 94 94 - GPU_InitRendererRegister(); 94 94 + gpu_init_renderer_register(); 95 95 96 96 count = 0; 97 97 - for(i = 0; i < MAX_REGISTERED_RENDERERS; i++) 97 97 + for(i = 0; i < GPU_MAX_REGISTERED_RENDERERS; i++) 98 98 { 99 99 - if(rendererRegister[i].id.renderer != GPU_RENDERER_UNKNOWN) 99 99 + if(_gpu_renderer_register[i].id.renderer != GPU_RENDERER_UNKNOWN) 100 100 { 101 101 - renderers_array[count] = rendererRegister[i].id; 101 101 + renderers_array[count] = _gpu_renderer_register[i].id; 102 102 count++; 103 103 } 104 104 } ··· 109 109 { 110 110 int i; 111 111 112 112 - GPU_InitRendererRegister(); 112 112 + gpu_init_renderer_register(); 113 113 114 114 - for(i = 0; i < MAX_REGISTERED_RENDERERS; i++) 114 114 + for(i = 0; i < GPU_MAX_REGISTERED_RENDERERS; i++) 115 115 { 116 116 - if(rendererRegister[i].id.renderer == renderer) 117 117 - return rendererRegister[i].id; 116 116 + if(_gpu_renderer_register[i].id.renderer == renderer) 117 117 + return _gpu_renderer_register[i].id; 118 118 } 119 119 120 120 return GPU_MakeRendererID("Unknown", GPU_RENDERER_UNKNOWN, 0, 0); ··· 137 137 { 138 138 int i = GPU_GetNumRegisteredRenderers(); 139 139 140 140 - if(i >= MAX_REGISTERED_RENDERERS) 140 140 + if(i >= GPU_MAX_REGISTERED_RENDERERS) 141 141 return; 142 142 143 143 if(id.renderer == GPU_RENDERER_UNKNOWN) ··· 156 156 return; 157 157 } 158 158 159 159 - rendererRegister[i].id = id; 160 160 - rendererRegister[i].createFn = create_renderer; 161 161 - rendererRegister[i].freeFn = free_renderer; 159 159 + _gpu_renderer_register[i].id = id; 160 160 + _gpu_renderer_register[i].createFn = create_renderer; 161 161 + _gpu_renderer_register[i].freeFn = free_renderer; 162 162 } 163 163 164 164 - void GPU_RegisterBuiltInRenderers(void) 164 164 + void gpu_register_built_in_renderers(void) 165 165 { 166 166 #ifndef SDL_GPU_DISABLE_OPENGL 167 167 #ifndef SDL_GPU_DISABLE_OPENGL_1_BASE ··· 208 208 static int renderer_order_size = 0; 209 209 static GPU_RendererID renderer_order[GPU_RENDERER_ORDER_MAX]; 210 210 211 211 - void GPU_InitRendererRegister(void) 211 211 + void gpu_init_renderer_register(void) 212 212 { 213 213 int i; 214 214 215 215 - if(initialized) 215 215 + if(_gpu_renderer_register_is_initialized) 216 216 return; 217 217 218 218 - for(i = 0; i < MAX_REGISTERED_RENDERERS; i++) 218 218 + for(i = 0; i < GPU_MAX_REGISTERED_RENDERERS; i++) 219 219 { 220 220 - rendererRegister[i].id.name = "Unknown"; 221 221 - rendererRegister[i].id.renderer = GPU_RENDERER_UNKNOWN; 222 222 - rendererRegister[i].createFn = NULL; 223 223 - rendererRegister[i].freeFn = NULL; 220 220 + _gpu_renderer_register[i].id.name = "Unknown"; 221 221 + _gpu_renderer_register[i].id.renderer = GPU_RENDERER_UNKNOWN; 222 222 + _gpu_renderer_register[i].createFn = NULL; 223 223 + _gpu_renderer_register[i].freeFn = NULL; 224 224 } 225 225 - for(i = 0; i < MAX_ACTIVE_RENDERERS; i++) 225 225 + for(i = 0; i < GPU_MAX_ACTIVE_RENDERERS; i++) 226 226 { 227 227 - rendererMap[i] = NULL; 227 227 + _gpu_renderer_map[i] = NULL; 228 228 } 229 229 230 230 GPU_GetDefaultRendererOrder(&renderer_order_size, renderer_order); 231 231 232 232 - initialized = 1; 232 232 + _gpu_renderer_register_is_initialized = 1; 233 233 234 234 - GPU_RegisterBuiltInRenderers(); 234 234 + gpu_register_built_in_renderers(); 235 235 } 236 236 237 237 ··· 297 297 { 298 298 GPU_Renderer* result = NULL; 299 299 int i; 300 300 - for(i = 0; i < MAX_REGISTERED_RENDERERS; i++) 300 300 + for(i = 0; i < GPU_MAX_REGISTERED_RENDERERS; i++) 301 301 { 302 302 - if(rendererRegister[i].id.renderer == GPU_RENDERER_UNKNOWN) 302 302 + if(_gpu_renderer_register[i].id.renderer == GPU_RENDERER_UNKNOWN) 303 303 continue; 304 304 305 305 - if(id.renderer == rendererRegister[i].id.renderer) 305 305 + if(id.renderer == _gpu_renderer_register[i].id.renderer) 306 306 { 307 307 - if(rendererRegister[i].createFn != NULL) 307 307 + if(_gpu_renderer_register[i].createFn != NULL) 308 308 { 309 309 // Use the registered name 310 310 - id.name = rendererRegister[i].id.name; 311 311 - result = rendererRegister[i].createFn(id); 310 310 + id.name = _gpu_renderer_register[i].id.name; 311 311 + result = _gpu_renderer_register[i].createFn(id); 312 312 } 313 313 break; 314 314 } ··· 325 325 GPU_Renderer* GPU_GetRenderer(GPU_RendererID id) 326 326 { 327 327 int i; 328 328 - GPU_InitRendererRegister(); 328 328 + gpu_init_renderer_register(); 329 329 330 330 - for(i = 0; i < MAX_ACTIVE_RENDERERS; i++) 330 330 + for(i = 0; i < GPU_MAX_ACTIVE_RENDERERS; i++) 331 331 { 332 332 - if(rendererMap[i] == NULL) 332 332 + if(_gpu_renderer_map[i] == NULL) 333 333 continue; 334 334 335 335 - if(id.renderer == rendererMap[i]->id.renderer) 336 336 - return rendererMap[i]; 335 335 + if(id.renderer == _gpu_renderer_map[i]->id.renderer) 336 336 + return _gpu_renderer_map[i]; 337 337 } 338 338 339 339 return NULL; 340 340 } 341 341 342 342 // Create a new renderer based on a registered id and store it in the map. 343 343 - GPU_Renderer* GPU_CreateAndAddRenderer(GPU_RendererID id) 343 343 + GPU_Renderer* gpu_create_and_add_renderer(GPU_RendererID id) 344 344 { 345 345 int i; 346 346 - for(i = 0; i < MAX_ACTIVE_RENDERERS; i++) 346 346 + for(i = 0; i < GPU_MAX_ACTIVE_RENDERERS; i++) 347 347 { 348 348 - if(rendererMap[i] == NULL) 348 348 + if(_gpu_renderer_map[i] == NULL) 349 349 { 350 350 // Create 351 351 GPU_Renderer* renderer = GPU_CreateRenderer(id); ··· 356 356 } 357 357 358 358 // Add 359 359 - rendererMap[i] = renderer; 359 359 + _gpu_renderer_map[i] = renderer; 360 360 // Return 361 361 return renderer; 362 362 } ··· 366 366 } 367 367 368 368 // Free renderer memory according to how the registry instructs 369 369 - void GPU_FreeRendererMemory(GPU_Renderer* renderer) 369 369 + void gpu_free_renderer_memory(GPU_Renderer* renderer) 370 370 { 371 371 int i; 372 372 if(renderer == NULL) 373 373 return; 374 374 375 375 - for(i = 0; i < MAX_REGISTERED_RENDERERS; i++) 375 375 + for(i = 0; i < GPU_MAX_REGISTERED_RENDERERS; i++) 376 376 { 377 377 - if(rendererRegister[i].id.renderer == GPU_RENDERER_UNKNOWN) 377 377 + if(_gpu_renderer_register[i].id.renderer == GPU_RENDERER_UNKNOWN) 378 378 continue; 379 379 380 380 - if(renderer->id.renderer == rendererRegister[i].id.renderer) 380 380 + if(renderer->id.renderer == _gpu_renderer_register[i].id.renderer) 381 381 { 382 382 - rendererRegister[i].freeFn(renderer); 382 382 + _gpu_renderer_register[i].freeFn(renderer); 383 383 return; 384 384 } 385 385 } ··· 398 398 if(current_renderer == renderer) 399 399 current_renderer = NULL; 400 400 401 401 - for(i = 0; i < MAX_ACTIVE_RENDERERS; i++) 401 401 + for(i = 0; i < GPU_MAX_ACTIVE_RENDERERS; i++) 402 402 { 403 403 - if(renderer == rendererMap[i]) 403 403 + if(renderer == _gpu_renderer_map[i]) 404 404 { 405 405 - GPU_FreeRendererMemory(renderer); 406 406 - rendererMap[i] = NULL; 405 405 + gpu_free_renderer_memory(renderer); 406 406 + _gpu_renderer_map[i] = NULL; 407 407 return; 408 408 } 409 409 }

+4 -4

src/renderer_GL_common.inl

reviewed

··· 40 40 } 41 41 #endif 42 42 43 43 - int GPU_strcasecmp(const char* s1, const char* s2); 43 43 + int gpu_strcasecmp(const char* s1, const char* s2); 44 44 45 45 #include "SDL_platform.h" 46 46 ··· 2241 2241 if(format == GPU_FILE_AUTO) 2242 2242 { 2243 2243 const char* extension = get_filename_ext(filename); 2244 2244 - if(GPU_strcasecmp(extension, "png") == 0) 2244 2244 + if(gpu_strcasecmp(extension, "png") == 0) 2245 2245 format = GPU_FILE_PNG; 2246 2246 - else if(GPU_strcasecmp(extension, "bmp") == 0) 2246 2246 + else if(gpu_strcasecmp(extension, "bmp") == 0) 2247 2247 format = GPU_FILE_BMP; 2248 2248 - else if(GPU_strcasecmp(extension, "tga") == 0) 2248 2248 + else if(gpu_strcasecmp(extension, "tga") == 0) 2249 2249 format = GPU_FILE_TGA; 2250 2250 else 2251 2251 {