+9 -3

demos/CMakeLists.txt

reviewed

··· 1 1 include_directories (${SDL_gpu_SOURCE_DIR}) 2 2 3 3 + set(DEMO_LIBS SDL_gpu) 4 4 + 5 5 + if(MINGW) 6 6 + set(DEMO_LIBS ${DEMO_LIBS} mingw32) 7 7 + endif(MINGW) 8 8 + 3 9 add_executable(init-demo init/main.c) 4 4 - target_link_libraries (init-demo SDL_gpu) 10 10 + target_link_libraries (init-demo ${DEMO_LIBS}) 5 11 6 12 add_executable(3d-demo 3d/main.c ../src/externals/glew/glew.c) 7 7 - target_link_libraries (3d-demo SDL_gpu) 13 13 + target_link_libraries (3d-demo ${DEMO_LIBS}) 8 14 9 15 add_executable(tutorial-space-demo tutorial-space/main.c) 10 10 - target_link_libraries (tutorial-space-demo SDL_gpu) 16 16 + target_link_libraries (tutorial-space-demo ${DEMO_LIBS})

+827 -813

src/SDL_gpu.c

reviewed

··· 80 80 81 81 void GPU_SetCurrentRenderer(GPU_RendererID id) 82 82 { 83 83 - _gpu_current_renderer = GPU_GetRenderer(id); 84 84 - 85 85 - if(_gpu_current_renderer != NULL) 86 86 - _gpu_current_renderer->impl->SetAsCurrent(_gpu_current_renderer); 83 83 + _gpu_current_renderer = GPU_GetRenderer(id); 84 84 + 85 85 + if(_gpu_current_renderer != NULL) 86 86 + _gpu_current_renderer->impl->SetAsCurrent(_gpu_current_renderer); 87 87 } 88 88 89 89 void GPU_ResetRendererState(void) 90 90 { 91 91 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 92 92 - return; 93 93 - 94 94 - _gpu_current_renderer->impl->ResetRendererState(_gpu_current_renderer); 91 91 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 92 92 + return; 93 93 + 94 94 + _gpu_current_renderer->impl->ResetRendererState(_gpu_current_renderer); 95 95 } 96 96 97 97 void GPU_SetCoordinateMode(Uint8 use_math_coords) 98 98 { 99 99 - if(_gpu_current_renderer == NULL) 100 100 - return; 101 101 - 102 102 - _gpu_current_renderer->coordinate_mode = use_math_coords; 99 99 + if(_gpu_current_renderer == NULL) 100 100 + return; 101 101 + 102 102 + _gpu_current_renderer->coordinate_mode = use_math_coords; 103 103 } 104 104 105 105 Uint8 GPU_GetCoordinateMode(void) 106 106 { 107 107 - if(_gpu_current_renderer == NULL) 108 108 - return 0; 109 109 - 110 110 - return _gpu_current_renderer->coordinate_mode; 107 107 + if(_gpu_current_renderer == NULL) 108 108 + return 0; 109 109 + 110 110 + return _gpu_current_renderer->coordinate_mode; 111 111 } 112 112 113 113 GPU_Renderer* GPU_GetCurrentRenderer(void) 114 114 { 115 115 - return _gpu_current_renderer; 115 115 + return _gpu_current_renderer; 116 116 } 117 117 118 118 Uint32 GPU_GetCurrentShaderProgram(void) ··· 128 128 { 129 129 switch(log_level) 130 130 { 131 131 - #ifdef __ANDROID__ 132 132 - case GPU_LOG_INFO: 133 133 - return __android_log_vprint((GPU_GetDebugLevel() >= GPU_DEBUG_LEVEL_3? ANDROID_LOG_ERROR : ANDROID_LOG_INFO), "APPLICATION", format, args); 134 134 - case GPU_LOG_WARNING: 135 135 - return __android_log_vprint((GPU_GetDebugLevel() >= GPU_DEBUG_LEVEL_2? ANDROID_LOG_ERROR : ANDROID_LOG_WARN), "APPLICATION", format, args); 136 136 - case GPU_LOG_ERROR: 137 137 - return __android_log_vprint(ANDROID_LOG_ERROR, "APPLICATION", format, args); 138 138 - #else 139 139 - case GPU_LOG_INFO: 140 140 - return vfprintf((GPU_GetDebugLevel() >= GPU_DEBUG_LEVEL_3? stderr : stdout), format, args); 141 141 - case GPU_LOG_WARNING: 142 142 - return vfprintf((GPU_GetDebugLevel() >= GPU_DEBUG_LEVEL_2? stderr : stdout), format, args); 143 143 - case GPU_LOG_ERROR: 144 144 - return vfprintf(stderr, format, args); 145 145 - #endif 131 131 + #ifdef __ANDROID__ 132 132 + case GPU_LOG_INFO: 133 133 + return __android_log_vprint((GPU_GetDebugLevel() >= GPU_DEBUG_LEVEL_3? ANDROID_LOG_ERROR : ANDROID_LOG_INFO), "APPLICATION", format, args); 134 134 + case GPU_LOG_WARNING: 135 135 + return __android_log_vprint((GPU_GetDebugLevel() >= GPU_DEBUG_LEVEL_2? ANDROID_LOG_ERROR : ANDROID_LOG_WARN), "APPLICATION", format, args); 136 136 + case GPU_LOG_ERROR: 137 137 + return __android_log_vprint(ANDROID_LOG_ERROR, "APPLICATION", format, args); 138 138 + #else 139 139 + case GPU_LOG_INFO: 140 140 + return vfprintf((GPU_GetDebugLevel() >= GPU_DEBUG_LEVEL_3? stderr : stdout), format, args); 141 141 + case GPU_LOG_WARNING: 142 142 + return vfprintf((GPU_GetDebugLevel() >= GPU_DEBUG_LEVEL_2? stderr : stdout), format, args); 143 143 + case GPU_LOG_ERROR: 144 144 + return vfprintf(stderr, format, args); 145 145 + #endif 146 146 default: 147 147 return 0; 148 148 } ··· 158 158 159 159 void GPU_LogInfo(const char* format, ...) 160 160 { 161 161 - va_list args; 162 162 - va_start(args, format); 161 161 + va_list args; 162 162 + va_start(args, format); 163 163 _gpu_print(GPU_LOG_INFO, format, args); 164 164 - va_end(args); 164 164 + va_end(args); 165 165 } 166 166 167 167 void GPU_LogWarning(const char* format, ...) 168 168 { 169 169 - va_list args; 170 170 - va_start(args, format); 169 169 + va_list args; 170 170 + va_start(args, format); 171 171 _gpu_print(GPU_LOG_WARNING, format, args); 172 172 - va_end(args); 172 172 + va_end(args); 173 173 } 174 174 175 175 void GPU_LogError(const char* format, ...) 176 176 { 177 177 - va_list args; 178 178 - va_start(args, format); 177 177 + va_list args; 178 178 + va_start(args, format); 179 179 _gpu_print(GPU_LOG_ERROR, format, args); 180 180 - va_end(args); 180 180 + va_end(args); 181 181 } 182 182 183 183 184 184 static Uint8 gpu_init_SDL(void) 185 185 { 186 186 - if(!_gpu_initialized_SDL) 187 187 - { 188 188 - if(!_gpu_initialized_SDL_core && !SDL_WasInit(SDL_INIT_EVERYTHING)) 186 186 + if(!_gpu_initialized_SDL) 187 187 + { 188 188 + if(!_gpu_initialized_SDL_core && !SDL_WasInit(SDL_INIT_EVERYTHING)) 189 189 { 190 190 // Nothing has been set up, so init SDL and the video subsystem. 191 191 if(SDL_Init(SDL_INIT_VIDEO) < 0) ··· 195 195 } 196 196 _gpu_initialized_SDL_core = 1; 197 197 } 198 198 - 198 198 + 199 199 // SDL is definitely ready now, but we're going to init the video subsystem to be sure that SDL_gpu keeps it available until GPU_Quit(). 200 200 if(SDL_InitSubSystem(SDL_INIT_VIDEO) < 0) 201 201 { ··· 203 203 return 0; 204 204 } 205 205 _gpu_initialized_SDL = 1; 206 206 - } 207 207 - return 1; 206 206 + } 207 207 + return 1; 208 208 } 209 209 210 210 void GPU_SetInitWindow(Uint32 windowID) ··· 243 243 { 244 244 unsigned int i; 245 245 _gpu_error_code_queue = (GPU_ErrorObject*)SDL_malloc(sizeof(GPU_ErrorObject)*_gpu_error_code_queue_size); 246 246 - 246 246 + 247 247 for(i = 0; i < _gpu_error_code_queue_size; i++) 248 248 { 249 249 _gpu_error_code_queue[i].function = (char*)SDL_malloc(GPU_ERROR_FUNCTION_STRING_MAX+1); ··· 251 251 _gpu_error_code_queue[i].details = (char*)SDL_malloc(GPU_ERROR_DETAILS_STRING_MAX+1); 252 252 } 253 253 _gpu_num_error_codes = 0; 254 254 - 254 254 + 255 255 _gpu_error_code_result.function = (char*)SDL_malloc(GPU_ERROR_FUNCTION_STRING_MAX+1); 256 256 _gpu_error_code_result.error = GPU_ERROR_NONE; 257 257 _gpu_error_code_result.details = (char*)SDL_malloc(GPU_ERROR_DETAILS_STRING_MAX+1); ··· 270 270 271 271 void GPU_AddWindowMapping(GPU_Target* target) 272 272 { 273 273 - Uint32 windowID; 274 274 - int i; 273 273 + Uint32 windowID; 274 274 + int i; 275 275 276 276 - if(_gpu_window_mappings == NULL) 276 276 + if(_gpu_window_mappings == NULL) 277 277 gpu_init_window_mappings(); 278 278 - 278 278 + 279 279 if(target == NULL || target->context == NULL) 280 280 return; 281 281 - 281 281 + 282 282 windowID = target->context->windowID; 283 283 if(windowID == 0) // Invalid window ID 284 284 return; 285 285 - 285 285 + 286 286 // Check for duplicates 287 287 for(i = 0; i < _gpu_num_window_mappings; i++) 288 288 { ··· 294 294 } 295 295 // Don't check the target because it's okay for a single target to be used with multiple windows 296 296 } 297 297 - 297 297 + 298 298 // Check if list is big enough to hold another 299 299 if(_gpu_num_window_mappings >= _gpu_window_mappings_size) 300 300 { 301 301 - GPU_WindowMapping* new_array; 301 301 + GPU_WindowMapping* new_array; 302 302 _gpu_window_mappings_size *= 2; 303 303 new_array = (GPU_WindowMapping*)SDL_malloc(_gpu_window_mappings_size * sizeof(GPU_WindowMapping)); 304 304 memcpy(new_array, _gpu_window_mappings, _gpu_num_window_mappings * sizeof(GPU_WindowMapping)); 305 305 SDL_free(_gpu_window_mappings); 306 306 _gpu_window_mappings = new_array; 307 307 } 308 308 - 308 308 + 309 309 // Add to end of list 310 310 - { 311 311 - GPU_WindowMapping m; 312 312 - m.windowID = windowID; 313 313 - m.target = target; 314 314 - _gpu_window_mappings[_gpu_num_window_mappings] = m; 315 315 - } 310 310 + { 311 311 + GPU_WindowMapping m; 312 312 + m.windowID = windowID; 313 313 + m.target = target; 314 314 + _gpu_window_mappings[_gpu_num_window_mappings] = m; 315 315 + } 316 316 _gpu_num_window_mappings++; 317 317 } 318 318 319 319 void GPU_RemoveWindowMapping(Uint32 windowID) 320 320 { 321 321 - int i; 321 321 + int i; 322 322 323 323 if(_gpu_window_mappings == NULL) 324 324 gpu_init_window_mappings(); 325 325 - 325 325 + 326 326 if(windowID == 0) // Invalid window ID 327 327 return; 328 328 - 328 328 + 329 329 // Find the occurrence 330 330 for(i = 0; i < _gpu_num_window_mappings; i++) 331 331 { 332 332 if(_gpu_window_mappings[i].windowID == windowID) 333 333 { 334 334 - int num_to_move; 334 334 + int num_to_move; 335 335 336 336 // Unset the target's window 337 337 _gpu_window_mappings[i].target->context->windowID = 0; 338 338 - 338 338 + 339 339 // Move the remaining entries to replace the removed one 340 340 _gpu_num_window_mappings--; 341 341 num_to_move = _gpu_num_window_mappings - i; ··· 344 344 return; 345 345 } 346 346 } 347 347 - 347 347 + 348 348 } 349 349 350 350 void GPU_RemoveWindowMappingByTarget(GPU_Target* target) 351 351 { 352 352 - Uint32 windowID; 353 353 - int i; 352 352 + Uint32 windowID; 353 353 + int i; 354 354 355 355 if(_gpu_window_mappings == NULL) 356 356 gpu_init_window_mappings(); 357 357 - 357 357 + 358 358 if(target == NULL || target->context == NULL) 359 359 return; 360 360 - 360 360 + 361 361 windowID = target->context->windowID; 362 362 if(windowID == 0) // Invalid window ID 363 363 return; 364 364 - 364 364 + 365 365 // Unset the target's window 366 366 target->context->windowID = 0; 367 367 - 367 367 + 368 368 // Find the occurrences 369 369 for(i = 0; i < _gpu_num_window_mappings; ) 370 370 { 371 371 if(_gpu_window_mappings[i].target == target) 372 372 { 373 373 // Move the remaining entries to replace the removed one 374 374 - int num_to_move; 374 374 + int num_to_move; 375 375 _gpu_num_window_mappings--; 376 376 num_to_move = _gpu_num_window_mappings - i; 377 377 if(num_to_move > 0) ··· 381 381 else 382 382 i++; 383 383 } 384 384 - 384 384 + 385 385 } 386 386 387 387 GPU_Target* GPU_GetWindowTarget(Uint32 windowID) ··· 390 390 391 391 if(_gpu_window_mappings == NULL) 392 392 gpu_init_window_mappings(); 393 393 - 393 393 + 394 394 if(windowID == 0) // Invalid window ID 395 395 return NULL; 396 396 - 396 396 + 397 397 // Find the occurrence 398 398 for(i = 0; i < _gpu_num_window_mappings; i++) 399 399 { 400 400 if(_gpu_window_mappings[i].windowID == windowID) 401 401 return _gpu_window_mappings[i].target; 402 402 } 403 403 - 403 403 + 404 404 return NULL; 405 405 } 406 406 407 407 GPU_Target* GPU_Init(Uint16 w, Uint16 h, GPU_WindowFlagEnum SDL_flags) 408 408 { 409 409 - int renderer_order_size; 410 410 - int i; 409 409 + int renderer_order_size; 410 410 + int i; 411 411 GPU_RendererID renderer_order[GPU_RENDERER_ORDER_MAX]; 412 412 413 413 gpu_init_error_queue(); 414 414 - 415 415 - gpu_init_renderer_register(); 416 416 - 417 417 - if(!gpu_init_SDL()) 414 414 + 415 415 + gpu_init_renderer_register(); 416 416 + 417 417 + if(!gpu_init_SDL()) 418 418 return NULL; 419 419 - 419 419 + 420 420 renderer_order_size = 0; 421 421 GPU_GetRendererOrder(&renderer_order_size, renderer_order); 422 422 - 422 422 + 423 423 // Init the renderers in order 424 424 for(i = 0; i < renderer_order_size; i++) 425 425 { ··· 427 427 if(screen != NULL) 428 428 return screen; 429 429 } 430 430 - 430 430 + 431 431 GPU_PushErrorCode("GPU_Init", GPU_ERROR_BACKEND_ERROR, "No renderer out of %d was able to initialize properly", renderer_order_size); 432 432 return NULL; 433 433 } ··· 440 440 441 441 GPU_Target* GPU_InitRendererByID(GPU_RendererID renderer_request, Uint16 w, Uint16 h, GPU_WindowFlagEnum SDL_flags) 442 442 { 443 443 - GPU_Renderer* renderer; 444 444 - GPU_Target* screen; 443 443 + GPU_Renderer* renderer; 444 444 + GPU_Target* screen; 445 445 446 446 gpu_init_error_queue(); 447 447 - gpu_init_renderer_register(); 448 448 - 449 449 - if(!gpu_init_SDL()) 447 447 + gpu_init_renderer_register(); 448 448 + 449 449 + if(!gpu_init_SDL()) 450 450 + return NULL; 451 451 + 452 452 + renderer = gpu_create_and_add_renderer(renderer_request); 453 453 + if(renderer == NULL) 450 454 return NULL; 451 451 - 452 452 - renderer = gpu_create_and_add_renderer(renderer_request); 453 453 - if(renderer == NULL) 454 454 - return NULL; 455 455 - 456 456 - GPU_SetCurrentRenderer(renderer->id); 457 457 - 458 458 - screen = renderer->impl->Init(renderer, renderer_request, w, h, SDL_flags); 459 459 - if(screen == NULL) 455 455 + 456 456 + GPU_SetCurrentRenderer(renderer->id); 457 457 + 458 458 + screen = renderer->impl->Init(renderer, renderer_request, w, h, SDL_flags); 459 459 + if(screen == NULL) 460 460 { 461 461 GPU_PushErrorCode("GPU_InitRendererByID", GPU_ERROR_BACKEND_ERROR, "Renderer %s failed to initialize properly", renderer->id.name); 462 462 // Init failed, destroy the renderer... ··· 471 471 472 472 Uint8 GPU_IsFeatureEnabled(GPU_FeatureEnum feature) 473 473 { 474 474 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 475 475 - return 0; 476 476 - 477 477 - return ((_gpu_current_renderer->enabled_features & feature) == feature); 474 474 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 475 475 + return 0; 476 476 + 477 477 + return ((_gpu_current_renderer->enabled_features & feature) == feature); 478 478 } 479 479 480 480 GPU_Target* GPU_CreateTargetFromWindow(Uint32 windowID) 481 481 { 482 482 - if(_gpu_current_renderer == NULL) 483 483 - return NULL; 484 484 - 485 485 - return _gpu_current_renderer->impl->CreateTargetFromWindow(_gpu_current_renderer, windowID, NULL); 482 482 + if(_gpu_current_renderer == NULL) 483 483 + return NULL; 484 484 + 485 485 + return _gpu_current_renderer->impl->CreateTargetFromWindow(_gpu_current_renderer, windowID, NULL); 486 486 } 487 487 488 488 GPU_Target* GPU_CreateAliasTarget(GPU_Target* target) ··· 492 492 MAKE_CURRENT_IF_NONE(target); 493 493 if(!CHECK_CONTEXT) 494 494 return NULL; 495 495 - 496 496 - return _gpu_current_renderer->impl->CreateAliasTarget(_gpu_current_renderer, target); 495 495 + 496 496 + return _gpu_current_renderer->impl->CreateAliasTarget(_gpu_current_renderer, target); 497 497 } 498 498 499 499 void GPU_MakeCurrent(GPU_Target* target, Uint32 windowID) 500 500 { 501 501 - if(_gpu_current_renderer == NULL) 502 502 - return; 503 503 - 504 504 - _gpu_current_renderer->impl->MakeCurrent(_gpu_current_renderer, target, windowID); 501 501 + if(_gpu_current_renderer == NULL) 502 502 + return; 503 503 + 504 504 + _gpu_current_renderer->impl->MakeCurrent(_gpu_current_renderer, target, windowID); 505 505 } 506 506 507 507 Uint8 GPU_SetFullscreen(Uint8 enable_fullscreen, Uint8 use_desktop_resolution) 508 508 { 509 509 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 510 510 - return 0; 511 511 - 512 512 - return _gpu_current_renderer->impl->SetFullscreen(_gpu_current_renderer, enable_fullscreen, use_desktop_resolution); 509 509 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 510 510 + return 0; 511 511 + 512 512 + return _gpu_current_renderer->impl->SetFullscreen(_gpu_current_renderer, enable_fullscreen, use_desktop_resolution); 513 513 } 514 514 515 515 Uint8 GPU_GetFullscreen(void) ··· 519 519 if(target == NULL) 520 520 return 0; 521 521 return (Uint8)(SDL_GetWindowFlags(SDL_GetWindowFromID(target->context->windowID)) 522 522 - & (SDL_WINDOW_FULLSCREEN | SDL_WINDOW_FULLSCREEN_DESKTOP)); 522 522 + & (SDL_WINDOW_FULLSCREEN | SDL_WINDOW_FULLSCREEN_DESKTOP)); 523 523 #else 524 524 SDL_Surface* surf = SDL_GetVideoSurface(); 525 525 if(surf == NULL) ··· 530 530 531 531 Uint8 GPU_SetWindowResolution(Uint16 w, Uint16 h) 532 532 { 533 533 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL || w == 0 || h == 0) 534 534 - return 0; 535 535 - 536 536 - return _gpu_current_renderer->impl->SetWindowResolution(_gpu_current_renderer, w, h); 533 533 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL || w == 0 || h == 0) 534 534 + return 0; 535 535 + 536 536 + return _gpu_current_renderer->impl->SetWindowResolution(_gpu_current_renderer, w, h); 537 537 } 538 538 539 539 ··· 544 544 MAKE_CURRENT_IF_NONE(target); 545 545 if(!CHECK_CONTEXT) 546 546 RETURN_ERROR(GPU_ERROR_USER_ERROR, "NULL context"); 547 547 - if(w == 0 || h == 0) 548 548 - return; 549 549 - 550 550 - _gpu_current_renderer->impl->SetVirtualResolution(_gpu_current_renderer, target, w, h); 547 547 + if(w == 0 || h == 0) 548 548 + return; 549 549 + 550 550 + _gpu_current_renderer->impl->SetVirtualResolution(_gpu_current_renderer, target, w, h); 551 551 } 552 552 553 553 void GPU_UnsetVirtualResolution(GPU_Target* target) ··· 557 557 MAKE_CURRENT_IF_NONE(target); 558 558 if(!CHECK_CONTEXT) 559 559 RETURN_ERROR(GPU_ERROR_USER_ERROR, "NULL context"); 560 560 - 561 561 - _gpu_current_renderer->impl->UnsetVirtualResolution(_gpu_current_renderer, target); 560 560 + 561 561 + _gpu_current_renderer->impl->UnsetVirtualResolution(_gpu_current_renderer, target); 562 562 } 563 563 564 564 void GPU_SetImageVirtualResolution(GPU_Image* image, Uint16 w, Uint16 h) 565 565 { 566 566 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL || w == 0 || h == 0) 567 567 - return; 568 568 - 569 569 - if(image == NULL) 566 566 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL || w == 0 || h == 0) 570 567 return; 571 571 - 568 568 + 569 569 + if(image == NULL) 570 570 + return; 571 571 + 572 572 image->w = w; 573 573 image->h = h; 574 574 image->using_virtual_resolution = 1; ··· 576 576 577 577 void GPU_UnsetImageVirtualResolution(GPU_Image* image) 578 578 { 579 579 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 580 580 - return; 581 581 - 582 582 - if(image == NULL) 579 579 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 580 580 + return; 581 581 + 582 582 + if(image == NULL) 583 583 return; 584 584 - 584 584 + 585 585 image->w = image->base_w; 586 586 image->h = image->base_h; 587 587 image->using_virtual_resolution = 0; ··· 601 601 SDL_free(_gpu_error_code_queue); 602 602 _gpu_error_code_queue = NULL; 603 603 _gpu_num_error_codes = 0; 604 604 - 604 604 + 605 605 SDL_free(_gpu_error_code_result.function); 606 606 _gpu_error_code_result.function = NULL; 607 607 SDL_free(_gpu_error_code_result.details); ··· 612 612 void GPU_SetErrorQueueMax(unsigned int max) 613 613 { 614 614 gpu_free_error_queue(); 615 615 - 615 615 + 616 616 // Reallocate with new size 617 617 _gpu_error_code_queue_size = max; 618 618 gpu_init_error_queue(); ··· 620 620 621 621 void GPU_CloseCurrentRenderer(void) 622 622 { 623 623 - if(_gpu_current_renderer == NULL) 624 624 - return; 625 625 - 626 626 - _gpu_current_renderer->impl->Quit(_gpu_current_renderer); 627 627 - GPU_FreeRenderer(_gpu_current_renderer); 623 623 + if(_gpu_current_renderer == NULL) 624 624 + return; 625 625 + 626 626 + _gpu_current_renderer->impl->Quit(_gpu_current_renderer); 627 627 + GPU_FreeRenderer(_gpu_current_renderer); 628 628 } 629 629 630 630 void GPU_Quit(void) 631 631 { 632 632 if(_gpu_num_error_codes > 0 && GPU_GetDebugLevel() >= GPU_DEBUG_LEVEL_1) 633 633 GPU_LogError("GPU_Quit: %d uncleared error%s.\n", _gpu_num_error_codes, (_gpu_num_error_codes > 1? "s" : "")); 634 634 - 634 634 + 635 635 gpu_free_error_queue(); 636 636 - 637 637 - if(_gpu_current_renderer == NULL) 638 638 - return; 639 639 - 640 640 - _gpu_current_renderer->impl->Quit(_gpu_current_renderer); 641 641 - GPU_FreeRenderer(_gpu_current_renderer); 642 642 - // FIXME: Free all renderers 643 643 - _gpu_current_renderer = NULL; 644 644 - 645 645 - _gpu_init_windowID = 0; 646 646 - 647 647 - // Free window mappings 648 648 - SDL_free(_gpu_window_mappings); 649 649 - _gpu_window_mappings = NULL; 650 650 - _gpu_window_mappings_size = 0; 651 651 - _gpu_num_window_mappings = 0; 652 652 - 636 636 + 637 637 + if(_gpu_current_renderer == NULL) 638 638 + return; 639 639 + 640 640 + _gpu_current_renderer->impl->Quit(_gpu_current_renderer); 641 641 + GPU_FreeRenderer(_gpu_current_renderer); 642 642 + // FIXME: Free all renderers 643 643 + _gpu_current_renderer = NULL; 644 644 + 645 645 + _gpu_init_windowID = 0; 646 646 + 647 647 + // Free window mappings 648 648 + SDL_free(_gpu_window_mappings); 649 649 + _gpu_window_mappings = NULL; 650 650 + _gpu_window_mappings_size = 0; 651 651 + _gpu_num_window_mappings = 0; 652 652 + 653 653 gpu_free_renderer_register(); 654 654 - 654 654 + 655 655 if(_gpu_initialized_SDL) 656 656 { 657 657 SDL_QuitSubSystem(SDL_INIT_VIDEO); 658 658 _gpu_initialized_SDL = 0; 659 659 - 659 659 + 660 660 if(_gpu_initialized_SDL_core) 661 661 { 662 662 SDL_Quit(); ··· 680 680 void GPU_PushErrorCode(const char* function, GPU_ErrorEnum error, const char* details, ...) 681 681 { 682 682 gpu_init_error_queue(); 683 683 - 683 683 + 684 684 if(GPU_GetDebugLevel() >= GPU_DEBUG_LEVEL_1) 685 685 { 686 686 // Print the message ··· 691 691 va_start(lst, details); 692 692 vsnprintf(buf, GPU_ERROR_DETAILS_STRING_MAX, details, lst); 693 693 va_end(lst); 694 694 - 694 694 + 695 695 GPU_LogError("%s: %s - %s\n", (function == NULL? "NULL" : function), GPU_GetErrorString(error), buf); 696 696 } 697 697 else 698 698 GPU_LogError("%s: %s\n", (function == NULL? "NULL" : function), GPU_GetErrorString(error)); 699 699 } 700 700 - 700 700 + 701 701 if(_gpu_num_error_codes < _gpu_error_code_queue_size) 702 702 { 703 703 if(function == NULL) ··· 725 725 { 726 726 unsigned int i; 727 727 GPU_ErrorObject result = {NULL, GPU_ERROR_NONE, NULL}; 728 728 - 728 728 + 729 729 gpu_init_error_queue(); 730 730 - 730 730 + 731 731 if(_gpu_num_error_codes <= 0) 732 732 return result; 733 733 - 733 733 + 734 734 // Pop the oldest 735 735 strcpy(_gpu_error_code_result.function, _gpu_error_code_queue[0].function); 736 736 _gpu_error_code_result.error = _gpu_error_code_queue[0].error; 737 737 strcpy(_gpu_error_code_result.details, _gpu_error_code_queue[0].details); 738 738 - 738 738 + 739 739 // We'll be returning that one 740 740 result = _gpu_error_code_result; 741 741 - 741 741 + 742 742 // Move the rest down 743 743 _gpu_num_error_codes--; 744 744 for(i = 0; i < _gpu_num_error_codes; i++) ··· 754 754 { 755 755 switch(error) 756 756 { 757 757 - case GPU_ERROR_NONE: 758 758 - return "NO ERROR"; 759 759 - case GPU_ERROR_BACKEND_ERROR: 760 760 - return "BACKEND ERROR"; 761 761 - case GPU_ERROR_DATA_ERROR: 762 762 - return "DATA ERROR"; 763 763 - case GPU_ERROR_USER_ERROR: 764 764 - return "USER ERROR"; 765 765 - case GPU_ERROR_UNSUPPORTED_FUNCTION: 766 766 - return "UNSUPPORTED FUNCTION"; 767 767 - case GPU_ERROR_NULL_ARGUMENT: 768 768 - return "NULL ARGUMENT"; 769 769 - case GPU_ERROR_FILE_NOT_FOUND: 770 770 - return "FILE NOT FOUND"; 757 757 + case GPU_ERROR_NONE: 758 758 + return "NO ERROR"; 759 759 + case GPU_ERROR_BACKEND_ERROR: 760 760 + return "BACKEND ERROR"; 761 761 + case GPU_ERROR_DATA_ERROR: 762 762 + return "DATA ERROR"; 763 763 + case GPU_ERROR_USER_ERROR: 764 764 + return "USER ERROR"; 765 765 + case GPU_ERROR_UNSUPPORTED_FUNCTION: 766 766 + return "UNSUPPORTED FUNCTION"; 767 767 + case GPU_ERROR_NULL_ARGUMENT: 768 768 + return "NULL ARGUMENT"; 769 769 + case GPU_ERROR_FILE_NOT_FOUND: 770 770 + return "FILE NOT FOUND"; 771 771 } 772 772 return "UNKNOWN ERROR"; 773 773 } ··· 775 775 776 776 void GPU_GetVirtualCoords(GPU_Target* target, float* x, float* y, float displayX, float displayY) 777 777 { 778 778 - if(target == NULL) 779 779 - return; 780 780 - 781 781 - if(target->context != NULL) 778 778 + if(target == NULL) 779 779 + return; 780 780 + 781 781 + if(target->context != NULL) 782 782 { 783 783 if(x != NULL) 784 784 *x = (displayX*target->w)/target->context->window_w; 785 785 if(y != NULL) 786 786 *y = (displayY*target->h)/target->context->window_h; 787 787 } 788 788 - else if(target->image != NULL) 788 788 + else if(target->image != NULL) 789 789 { 790 790 if(x != NULL) 791 791 *x = (displayX*target->w)/target->image->w; ··· 803 803 804 804 GPU_Rect GPU_MakeRect(float x, float y, float w, float h) 805 805 { 806 806 - GPU_Rect r; 807 807 - r.x = x; 808 808 - r.y = y; 809 809 - r.w = w; 810 810 - r.h = h; 806 806 + GPU_Rect r; 807 807 + r.x = x; 808 808 + r.y = y; 809 809 + r.w = w; 810 810 + r.h = h; 811 811 812 812 return r; 813 813 } 814 814 815 815 SDL_Color GPU_MakeColor(Uint8 r, Uint8 g, Uint8 b, Uint8 a) 816 816 { 817 817 - SDL_Color c; 818 818 - c.r = r; 819 819 - c.g = g; 820 820 - c.b = b; 821 821 - GET_ALPHA(c) = a; 817 817 + SDL_Color c; 818 818 + c.r = r; 819 819 + c.g = g; 820 820 + c.b = b; 821 821 + GET_ALPHA(c) = a; 822 822 823 823 return c; 824 824 } 825 825 826 826 GPU_RendererID GPU_MakeRendererID(const char* name, GPU_RendererEnum renderer, int major_version, int minor_version) 827 827 { 828 828 - GPU_RendererID r; 829 829 - r.name = name; 830 830 - r.renderer = renderer; 831 831 - r.major_version = major_version; 832 832 - r.minor_version = minor_version; 833 833 - 828 828 + GPU_RendererID r; 829 829 + r.name = name; 830 830 + r.renderer = renderer; 831 831 + r.major_version = major_version; 832 832 + r.minor_version = minor_version; 833 833 + 834 834 return r; 835 835 } 836 836 ··· 848 848 849 849 GPU_Camera GPU_GetDefaultCamera(void) 850 850 { 851 851 - GPU_Camera cam = {0.0f, 0.0f, -10.0f, 0.0f, 1.0f}; 852 852 - return cam; 851 851 + GPU_Camera cam = {0.0f, 0.0f, -10.0f, 0.0f, 1.0f}; 852 852 + return cam; 853 853 } 854 854 855 855 GPU_Camera GPU_GetCamera(GPU_Target* target) 856 856 { 857 857 - if(target == NULL) 858 858 - return GPU_GetDefaultCamera(); 859 859 - return target->camera; 857 857 + if(target == NULL) 858 858 + return GPU_GetDefaultCamera(); 859 859 + return target->camera; 860 860 } 861 861 862 862 GPU_Camera GPU_SetCamera(GPU_Target* target, GPU_Camera* cam) 863 863 { 864 864 - if(_gpu_current_renderer == NULL) 865 865 - return GPU_GetDefaultCamera(); 864 864 + if(_gpu_current_renderer == NULL) 865 865 + return GPU_GetDefaultCamera(); 866 866 MAKE_CURRENT_IF_NONE(target); 867 867 - if(_gpu_current_renderer->current_context_target == NULL) 868 868 - return GPU_GetDefaultCamera(); 869 869 - 870 870 - return _gpu_current_renderer->impl->SetCamera(_gpu_current_renderer, target, cam); 867 867 + if(_gpu_current_renderer->current_context_target == NULL) 868 868 + return GPU_GetDefaultCamera(); 869 869 + 870 870 + return _gpu_current_renderer->impl->SetCamera(_gpu_current_renderer, target, cam); 871 871 } 872 872 873 873 GPU_Image* GPU_CreateImage(Uint16 w, Uint16 h, GPU_FormatEnum format) 874 874 { 875 875 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 876 876 - return NULL; 877 877 - 878 878 - return _gpu_current_renderer->impl->CreateImage(_gpu_current_renderer, w, h, format); 875 875 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 876 876 + return NULL; 877 877 + 878 878 + return _gpu_current_renderer->impl->CreateImage(_gpu_current_renderer, w, h, format); 879 879 } 880 880 881 881 GPU_Image* GPU_CreateImageUsingTexture(Uint32 handle, Uint8 take_ownership) 882 882 { 883 883 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 884 884 - return NULL; 885 885 - 886 886 - return _gpu_current_renderer->impl->CreateImageUsingTexture(_gpu_current_renderer, handle, take_ownership); 883 883 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 884 884 + return NULL; 885 885 + 886 886 + return _gpu_current_renderer->impl->CreateImageUsingTexture(_gpu_current_renderer, handle, take_ownership); 887 887 } 888 888 889 889 GPU_Image* GPU_LoadImage(const char* filename) 890 890 { 891 891 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 892 892 - return NULL; 893 893 - 894 894 - return _gpu_current_renderer->impl->LoadImage(_gpu_current_renderer, filename); 891 891 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 892 892 + return NULL; 893 893 + 894 894 + return _gpu_current_renderer->impl->LoadImage(_gpu_current_renderer, filename); 895 895 } 896 896 897 897 GPU_Image* GPU_CreateAliasImage(GPU_Image* image) 898 898 { 899 899 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 900 900 - return NULL; 901 901 - 902 902 - return _gpu_current_renderer->impl->CreateAliasImage(_gpu_current_renderer, image); 899 899 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 900 900 + return NULL; 901 901 + 902 902 + return _gpu_current_renderer->impl->CreateAliasImage(_gpu_current_renderer, image); 903 903 } 904 904 905 905 Uint8 GPU_SaveImage(GPU_Image* image, const char* filename, GPU_FileFormatEnum format) 906 906 { 907 907 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 908 908 - return 0; 909 909 - 910 910 - return _gpu_current_renderer->impl->SaveImage(_gpu_current_renderer, image, filename, format); 907 907 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 908 908 + return 0; 909 909 + 910 910 + return _gpu_current_renderer->impl->SaveImage(_gpu_current_renderer, image, filename, format); 911 911 } 912 912 913 913 GPU_Image* GPU_CopyImage(GPU_Image* image) 914 914 { 915 915 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 916 916 - return NULL; 917 917 - 918 918 - return _gpu_current_renderer->impl->CopyImage(_gpu_current_renderer, image); 915 915 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 916 916 + return NULL; 917 917 + 918 918 + return _gpu_current_renderer->impl->CopyImage(_gpu_current_renderer, image); 919 919 } 920 920 921 921 void GPU_UpdateImage(GPU_Image* image, const GPU_Rect* image_rect, SDL_Surface* surface, const GPU_Rect* surface_rect) 922 922 { 923 923 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 924 924 - return; 925 925 - 926 926 - _gpu_current_renderer->impl->UpdateImage(_gpu_current_renderer, image, image_rect, surface, surface_rect); 923 923 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 924 924 + return; 925 925 + 926 926 + _gpu_current_renderer->impl->UpdateImage(_gpu_current_renderer, image, image_rect, surface, surface_rect); 927 927 } 928 928 929 929 void GPU_UpdateImageBytes(GPU_Image* image, const GPU_Rect* image_rect, const unsigned char* bytes, int bytes_per_row) 930 930 { 931 931 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 932 932 - return; 933 933 - 934 934 - _gpu_current_renderer->impl->UpdateImageBytes(_gpu_current_renderer, image, image_rect, bytes, bytes_per_row); 931 931 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 932 932 + return; 933 933 + 934 934 + _gpu_current_renderer->impl->UpdateImageBytes(_gpu_current_renderer, image, image_rect, bytes, bytes_per_row); 935 935 } 936 936 937 937 Uint8 GPU_ReplaceImage(GPU_Image* image, SDL_Surface* surface, const GPU_Rect* surface_rect) 938 938 { 939 939 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 940 940 - return 0; 941 941 - 942 942 - return _gpu_current_renderer->impl->ReplaceImage(_gpu_current_renderer, image, surface, surface_rect); 939 939 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 940 940 + return 0; 941 941 + 942 942 + return _gpu_current_renderer->impl->ReplaceImage(_gpu_current_renderer, image, surface, surface_rect); 943 943 } 944 944 945 945 SDL_Surface* GPU_LoadSurface(const char* filename) 946 946 { 947 947 - int width, height, channels; 948 948 - Uint32 Rmask, Gmask, Bmask, Amask = 0; 949 949 - unsigned char* data; 950 950 - SDL_Surface* result; 951 951 - 952 952 - if(filename == NULL) 947 947 + int i; 948 948 + int width, height, channels; 949 949 + Uint32 Rmask, Gmask, Bmask, Amask = 0; 950 950 + unsigned char* data; 951 951 + SDL_Surface* result; 952 952 + 953 953 + if(filename == NULL) 953 954 { 954 955 GPU_PushErrorCode("GPU_LoadSurface", GPU_ERROR_NULL_ARGUMENT, "filename"); 955 956 return NULL; 956 957 } 957 957 - 958 958 - #ifdef __ANDROID__ 959 959 - if(strlen(filename) > 0 && filename[0] != '/') 960 960 - { 958 958 + 959 959 + #ifdef __ANDROID__ 960 960 + if(strlen(filename) > 0 && filename[0] != '/') 961 961 + { 961 962 // Must use SDL_RWops to access the assets directory automatically 962 963 SDL_RWops* rwops = SDL_RWFromFile(filename, "r"); 963 964 if(rwops == NULL) ··· 969 970 data = stbi_load_from_memory(c_data, data_bytes, &width, &height, &channels, 0); 970 971 SDL_free(c_data); 971 972 SDL_FreeRW(rwops); 972 972 - } 973 973 - else 973 973 + } 974 974 + else 974 975 { 975 976 // Absolute filename 976 977 data = stbi_load(filename, &width, &height, &channels, 0); 977 978 } 978 978 - #else 979 979 - data = stbi_load(filename, &width, &height, &channels, 0); 980 980 - #endif 981 981 - 982 982 - if(data == NULL) 983 983 - { 984 984 - GPU_PushErrorCode(__func__, GPU_ERROR_DATA_ERROR, "Failed to load \"%s\": %s", filename, stbi_failure_reason()); 985 985 - return NULL; 986 986 - } 987 987 - if(channels < 1 || channels > 4) 988 988 - { 989 989 - GPU_PushErrorCode(__func__, GPU_ERROR_DATA_ERROR, "Failed to load \"%s\": Unsupported pixel format", filename); 990 990 - stbi_image_free(data); 991 991 - return NULL; 992 992 - } 993 993 - 994 994 - switch(channels) 995 995 - { 996 996 - case 1: 997 997 - Rmask = Gmask = Bmask = 0; // Use default RGB masks for 8-bit 998 998 - break; 999 999 - case 2: 1000 1000 - Rmask = Gmask = Bmask = 0; // Use default RGB masks for 16-bit 1001 1001 - break; 1002 1002 - case 3: 1003 1003 - // These are reversed from what SDL_image uses... That is bad. :( Needs testing. 1004 1004 - #if SDL_BYTEORDER == SDL_BIG_ENDIAN 1005 1005 - Rmask = 0xff0000; 1006 1006 - Gmask = 0x00ff00; 1007 1007 - Bmask = 0x0000ff; 1008 1008 - #else 1009 1009 - Rmask = 0x0000ff; 1010 1010 - Gmask = 0x00ff00; 1011 1011 - Bmask = 0xff0000; 1012 1012 - #endif 1013 1013 - break; 1014 1014 - case 4: 1015 1015 - Rmask = 0x000000ff; 1016 1016 - Gmask = 0x0000ff00; 1017 1017 - Bmask = 0x00ff0000; 1018 1018 - Amask = 0xff000000; 1019 1019 - break; 1020 1020 - default: 1021 1021 - Rmask = Gmask = Bmask = 0; 1022 1022 - break; 1023 1023 - } 1024 1024 - 1025 1025 - result = SDL_CreateRGBSurfaceFrom(data, width, height, channels*8, width*channels, Rmask, Gmask, Bmask, Amask); 1026 1026 - if(result != NULL) 1027 1027 - result->flags &= ~SDL_PREALLOC; // Make SDL take ownership of the data memory 1028 1028 - 1029 1029 - if(result != NULL && result->format->palette != NULL) 979 979 + #else 980 980 + data = stbi_load(filename, &width, &height, &channels, 0); 981 981 + #endif 982 982 + 983 983 + if(data == NULL) 984 984 + { 985 985 + GPU_PushErrorCode(__func__, GPU_ERROR_DATA_ERROR, "Failed to load \"%s\": %s", filename, stbi_failure_reason()); 986 986 + return NULL; 987 987 + } 988 988 + if(channels < 1 || channels > 4) 989 989 + { 990 990 + GPU_PushErrorCode(__func__, GPU_ERROR_DATA_ERROR, "Failed to load \"%s\": Unsupported pixel format", filename); 991 991 + stbi_image_free(data); 992 992 + return NULL; 993 993 + } 994 994 + 995 995 + switch(channels) 996 996 + { 997 997 + case 1: 998 998 + Rmask = Gmask = Bmask = 0; // Use default RGB masks for 8-bit 999 999 + break; 1000 1000 + case 2: 1001 1001 + Rmask = Gmask = Bmask = 0; // Use default RGB masks for 16-bit 1002 1002 + break; 1003 1003 + case 3: 1004 1004 + // These are reversed from what SDL_image uses... That is bad. :( Needs testing. 1005 1005 + #if SDL_BYTEORDER == SDL_BIG_ENDIAN 1006 1006 + Rmask = 0xff0000; 1007 1007 + Gmask = 0x00ff00; 1008 1008 + Bmask = 0x0000ff; 1009 1009 + #else 1010 1010 + Rmask = 0x0000ff; 1011 1011 + Gmask = 0x00ff00; 1012 1012 + Bmask = 0xff0000; 1013 1013 + #endif 1014 1014 + break; 1015 1015 + case 4: 1016 1016 + Rmask = 0x000000ff; 1017 1017 + Gmask = 0x0000ff00; 1018 1018 + Bmask = 0x00ff0000; 1019 1019 + Amask = 0xff000000; 1020 1020 + break; 1021 1021 + default: 1022 1022 + Rmask = Gmask = Bmask = 0; 1023 1023 + break; 1024 1024 + } 1025 1025 + 1026 1026 + result = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, channels*8, Rmask, Gmask, Bmask, Amask); 1027 1027 + if(result == NULL) 1028 1028 + { 1029 1029 + GPU_PushErrorCode(__func__, GPU_ERROR_DATA_ERROR, "Failed to create new %dx%d surface", width, height); 1030 1030 + stbi_image_free(data); 1031 1031 + return NULL; 1032 1032 + } 1033 1033 + 1034 1034 + // Copy row-by-row in case the pitch doesn't match 1035 1035 + for(i = 0; i < height; ++i) 1036 1036 + { 1037 1037 + memcpy((Uint8*)result->pixels + i*result->pitch, data + channels*width*i, channels*width); 1038 1038 + } 1039 1039 + 1040 1040 + stbi_image_free(data); 1041 1041 + 1042 1042 + if(result != NULL && result->format->palette != NULL) 1030 1043 { 1031 1044 // SDL_CreateRGBSurface has no idea what palette to use, so it uses a blank one. 1032 1045 // We'll at least create a grayscale one, but it's not ideal... 1033 1046 // Better would be to get the palette from stbi, but stbi doesn't do that! 1034 1047 SDL_Color colors[256]; 1035 1048 int i; 1036 1036 - 1049 1049 + 1037 1050 for(i = 0; i < 256; i++) 1038 1051 { 1039 1052 colors[i].r = colors[i].g = colors[i].b = (Uint8)i; 1040 1053 } 1041 1054 1042 1055 /* Set palette */ 1043 1043 - #ifdef SDL_GPU_USE_SDL2 1056 1056 + #ifdef SDL_GPU_USE_SDL2 1044 1057 SDL_SetPaletteColors(result->format->palette, colors, 0, 256); 1045 1045 - #else 1058 1058 + #else 1046 1059 SDL_SetPalette(result, SDL_LOGPAL, colors, 0, 256); 1047 1047 - #endif 1060 1060 + #endif 1048 1061 } 1049 1049 - 1050 1050 - return result; 1062 1062 + 1063 1063 + return result; 1051 1064 } 1052 1065 1053 1066 // From http://stackoverflow.com/questions/5309471/getting-file-extension-in-c ··· 1072 1085 1073 1086 1074 1087 data = surface->pixels; 1075 1075 - 1088 1088 + 1076 1089 if(format == GPU_FILE_AUTO) 1077 1090 { 1078 1091 const char* extension = get_filename_ext(filename); ··· 1088 1101 return 0; 1089 1102 } 1090 1103 } 1091 1091 - 1104 1104 + 1092 1105 switch(format) 1093 1106 { 1094 1094 - case GPU_FILE_PNG: 1095 1095 - result = (stbi_write_png(filename, surface->w, surface->h, surface->format->BytesPerPixel, (const unsigned char *const)data, 0) > 0); 1096 1096 - break; 1097 1097 - case GPU_FILE_BMP: 1098 1098 - result = (stbi_write_bmp(filename, surface->w, surface->h, surface->format->BytesPerPixel, (void*)data) > 0); 1099 1099 - break; 1100 1100 - case GPU_FILE_TGA: 1101 1101 - result = (stbi_write_tga(filename, surface->w, surface->h, surface->format->BytesPerPixel, (void*)data) > 0); 1102 1102 - break; 1103 1103 - default: 1104 1104 - GPU_PushErrorCode(__func__, GPU_ERROR_DATA_ERROR, "Unsupported output file format"); 1105 1105 - result = 0; 1106 1106 - break; 1107 1107 + case GPU_FILE_PNG: 1108 1108 + result = (stbi_write_png(filename, surface->w, surface->h, surface->format->BytesPerPixel, (const unsigned char *const)data, 0) > 0); 1109 1109 + break; 1110 1110 + case GPU_FILE_BMP: 1111 1111 + result = (stbi_write_bmp(filename, surface->w, surface->h, surface->format->BytesPerPixel, (void*)data) > 0); 1112 1112 + break; 1113 1113 + case GPU_FILE_TGA: 1114 1114 + result = (stbi_write_tga(filename, surface->w, surface->h, surface->format->BytesPerPixel, (void*)data) > 0); 1115 1115 + break; 1116 1116 + default: 1117 1117 + GPU_PushErrorCode(__func__, GPU_ERROR_DATA_ERROR, "Unsupported output file format"); 1118 1118 + result = 0; 1119 1119 + break; 1107 1120 } 1108 1121 1109 1122 return result; ··· 1111 1124 1112 1125 GPU_Image* GPU_CopyImageFromSurface(SDL_Surface* surface) 1113 1126 { 1114 1114 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1115 1115 - return NULL; 1116 1116 - 1117 1117 - return _gpu_current_renderer->impl->CopyImageFromSurface(_gpu_current_renderer, surface); 1127 1127 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1128 1128 + return NULL; 1129 1129 + 1130 1130 + return _gpu_current_renderer->impl->CopyImageFromSurface(_gpu_current_renderer, surface); 1118 1131 } 1119 1132 1120 1133 GPU_Image* GPU_CopyImageFromTarget(GPU_Target* target) 1121 1134 { 1122 1122 - if(_gpu_current_renderer == NULL) 1123 1123 - return NULL; 1135 1135 + if(_gpu_current_renderer == NULL) 1136 1136 + return NULL; 1124 1137 MAKE_CURRENT_IF_NONE(target); 1125 1125 - if(_gpu_current_renderer->current_context_target == NULL) 1126 1126 - return NULL; 1127 1127 - 1128 1128 - return _gpu_current_renderer->impl->CopyImageFromTarget(_gpu_current_renderer, target); 1138 1138 + if(_gpu_current_renderer->current_context_target == NULL) 1139 1139 + return NULL; 1140 1140 + 1141 1141 + return _gpu_current_renderer->impl->CopyImageFromTarget(_gpu_current_renderer, target); 1129 1142 } 1130 1143 1131 1144 SDL_Surface* GPU_CopySurfaceFromTarget(GPU_Target* target) 1132 1145 { 1133 1133 - if(_gpu_current_renderer == NULL) 1134 1134 - return NULL; 1146 1146 + if(_gpu_current_renderer == NULL) 1147 1147 + return NULL; 1135 1148 MAKE_CURRENT_IF_NONE(target); 1136 1136 - if(_gpu_current_renderer->current_context_target == NULL) 1137 1137 - return NULL; 1138 1138 - 1139 1139 - return _gpu_current_renderer->impl->CopySurfaceFromTarget(_gpu_current_renderer, target); 1149 1149 + if(_gpu_current_renderer->current_context_target == NULL) 1150 1150 + return NULL; 1151 1151 + 1152 1152 + return _gpu_current_renderer->impl->CopySurfaceFromTarget(_gpu_current_renderer, target); 1140 1153 } 1141 1154 1142 1155 SDL_Surface* GPU_CopySurfaceFromImage(GPU_Image* image) 1143 1156 { 1144 1144 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1145 1145 - return NULL; 1146 1146 - 1147 1147 - return _gpu_current_renderer->impl->CopySurfaceFromImage(_gpu_current_renderer, image); 1157 1157 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1158 1158 + return NULL; 1159 1159 + 1160 1160 + return _gpu_current_renderer->impl->CopySurfaceFromImage(_gpu_current_renderer, image); 1148 1161 } 1149 1162 1150 1163 void GPU_FreeImage(GPU_Image* image) 1151 1164 { 1152 1152 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1153 1153 - return; 1154 1154 - 1155 1155 - _gpu_current_renderer->impl->FreeImage(_gpu_current_renderer, image); 1165 1165 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1166 1166 + return; 1167 1167 + 1168 1168 + _gpu_current_renderer->impl->FreeImage(_gpu_current_renderer, image); 1156 1169 } 1157 1170 1158 1171 1159 1172 GPU_Target* GPU_GetContextTarget(void) 1160 1173 { 1161 1161 - if(_gpu_current_renderer == NULL) 1162 1162 - return NULL; 1163 1163 - 1164 1164 - return _gpu_current_renderer->current_context_target; 1174 1174 + if(_gpu_current_renderer == NULL) 1175 1175 + return NULL; 1176 1176 + 1177 1177 + return _gpu_current_renderer->current_context_target; 1165 1178 } 1166 1179 1167 1180 1168 1181 GPU_Target* GPU_LoadTarget(GPU_Image* image) 1169 1182 { 1170 1170 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1171 1171 - return NULL; 1172 1172 - 1173 1173 - return _gpu_current_renderer->impl->LoadTarget(_gpu_current_renderer, image); 1183 1183 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1184 1184 + return NULL; 1185 1185 + 1186 1186 + return _gpu_current_renderer->impl->LoadTarget(_gpu_current_renderer, image); 1174 1187 } 1175 1188 1176 1189 1177 1190 1178 1191 void GPU_FreeTarget(GPU_Target* target) 1179 1192 { 1180 1180 - if(_gpu_current_renderer == NULL) 1181 1181 - return; 1182 1182 - 1183 1183 - _gpu_current_renderer->impl->FreeTarget(_gpu_current_renderer, target); 1193 1193 + if(_gpu_current_renderer == NULL) 1194 1194 + return; 1195 1195 + 1196 1196 + _gpu_current_renderer->impl->FreeTarget(_gpu_current_renderer, target); 1184 1197 } 1185 1198 1186 1199 ··· 1192 1205 MAKE_CURRENT_IF_NONE(target); 1193 1206 if(!CHECK_CONTEXT) 1194 1207 RETURN_ERROR(GPU_ERROR_USER_ERROR, "NULL context"); 1195 1195 - 1196 1196 - if(image == NULL) 1208 1208 + 1209 1209 + if(image == NULL) 1197 1210 RETURN_ERROR(GPU_ERROR_NULL_ARGUMENT, "image"); 1198 1198 - if(target == NULL) 1211 1211 + if(target == NULL) 1199 1212 RETURN_ERROR(GPU_ERROR_NULL_ARGUMENT, "target"); 1200 1200 - 1201 1201 - _gpu_current_renderer->impl->Blit(_gpu_current_renderer, image, src_rect, target, x, y); 1213 1213 + 1214 1214 + _gpu_current_renderer->impl->Blit(_gpu_current_renderer, image, src_rect, target, x, y); 1202 1215 } 1203 1216 1204 1217 ··· 1209 1222 MAKE_CURRENT_IF_NONE(target); 1210 1223 if(!CHECK_CONTEXT) 1211 1224 RETURN_ERROR(GPU_ERROR_USER_ERROR, "NULL context"); 1212 1212 - 1213 1213 - if(image == NULL) 1225 1225 + 1226 1226 + if(image == NULL) 1214 1227 RETURN_ERROR(GPU_ERROR_NULL_ARGUMENT, "image"); 1215 1215 - if(target == NULL) 1228 1228 + if(target == NULL) 1216 1229 RETURN_ERROR(GPU_ERROR_NULL_ARGUMENT, "target"); 1217 1217 - 1218 1218 - _gpu_current_renderer->impl->BlitRotate(_gpu_current_renderer, image, src_rect, target, x, y, angle); 1230 1230 + 1231 1231 + _gpu_current_renderer->impl->BlitRotate(_gpu_current_renderer, image, src_rect, target, x, y, angle); 1219 1232 } 1220 1233 1221 1234 void GPU_BlitScale(GPU_Image* image, GPU_Rect* src_rect, GPU_Target* target, float x, float y, float scaleX, float scaleY) ··· 1225 1238 MAKE_CURRENT_IF_NONE(target); 1226 1239 if(!CHECK_CONTEXT) 1227 1240 RETURN_ERROR(GPU_ERROR_USER_ERROR, "NULL context"); 1228 1228 - 1229 1229 - if(image == NULL) 1241 1241 + 1242 1242 + if(image == NULL) 1230 1243 RETURN_ERROR(GPU_ERROR_NULL_ARGUMENT, "image"); 1231 1231 - if(target == NULL) 1244 1244 + if(target == NULL) 1232 1245 RETURN_ERROR(GPU_ERROR_NULL_ARGUMENT, "target"); 1233 1233 - 1234 1234 - _gpu_current_renderer->impl->BlitScale(_gpu_current_renderer, image, src_rect, target, x, y, scaleX, scaleY); 1246 1246 + 1247 1247 + _gpu_current_renderer->impl->BlitScale(_gpu_current_renderer, image, src_rect, target, x, y, scaleX, scaleY); 1235 1248 } 1236 1249 1237 1250 void GPU_BlitTransform(GPU_Image* image, GPU_Rect* src_rect, GPU_Target* target, float x, float y, float angle, float scaleX, float scaleY) ··· 1241 1254 MAKE_CURRENT_IF_NONE(target); 1242 1255 if(!CHECK_CONTEXT) 1243 1256 RETURN_ERROR(GPU_ERROR_USER_ERROR, "NULL context"); 1244 1244 - 1245 1245 - if(image == NULL) 1257 1257 + 1258 1258 + if(image == NULL) 1246 1259 RETURN_ERROR(GPU_ERROR_NULL_ARGUMENT, "image"); 1247 1247 - if(target == NULL) 1260 1260 + if(target == NULL) 1248 1261 RETURN_ERROR(GPU_ERROR_NULL_ARGUMENT, "target"); 1249 1249 - 1250 1250 - _gpu_current_renderer->impl->BlitTransform(_gpu_current_renderer, image, src_rect, target, x, y, angle, scaleX, scaleY); 1262 1262 + 1263 1263 + _gpu_current_renderer->impl->BlitTransform(_gpu_current_renderer, image, src_rect, target, x, y, angle, scaleX, scaleY); 1251 1264 } 1252 1265 1253 1266 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) ··· 1257 1270 MAKE_CURRENT_IF_NONE(target); 1258 1271 if(!CHECK_CONTEXT) 1259 1272 RETURN_ERROR(GPU_ERROR_USER_ERROR, "NULL context"); 1260 1260 - 1261 1261 - if(image == NULL) 1273 1273 + 1274 1274 + if(image == NULL) 1262 1275 RETURN_ERROR(GPU_ERROR_NULL_ARGUMENT, "image"); 1263 1263 - if(target == NULL) 1276 1276 + if(target == NULL) 1264 1277 RETURN_ERROR(GPU_ERROR_NULL_ARGUMENT, "target"); 1265 1265 - 1266 1266 - _gpu_current_renderer->impl->BlitTransformX(_gpu_current_renderer, image, src_rect, target, x, y, pivot_x, pivot_y, angle, scaleX, scaleY); 1278 1278 + 1279 1279 + _gpu_current_renderer->impl->BlitTransformX(_gpu_current_renderer, image, src_rect, target, x, y, pivot_x, pivot_y, angle, scaleX, scaleY); 1267 1280 } 1268 1281 1269 1282 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) ··· 1273 1286 MAKE_CURRENT_IF_NONE(target); 1274 1287 if(!CHECK_CONTEXT) 1275 1288 RETURN_ERROR(GPU_ERROR_USER_ERROR, "NULL context"); 1276 1276 - 1277 1277 - if(target == NULL) 1289 1289 + 1290 1290 + if(target == NULL) 1278 1291 RETURN_ERROR(GPU_ERROR_NULL_ARGUMENT, "target"); 1279 1279 - 1292 1292 + 1280 1293 if(num_vertices == 0) 1281 1294 return; 1282 1282 - 1283 1283 - 1295 1295 + 1296 1296 + 1284 1297 _gpu_current_renderer->impl->TriangleBatch(_gpu_current_renderer, image, target, num_vertices, values, num_indices, indices, flags); 1285 1298 } 1286 1299 ··· 1289 1302 1290 1303 void GPU_GenerateMipmaps(GPU_Image* image) 1291 1304 { 1292 1292 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1293 1293 - return; 1294 1294 - 1295 1295 - _gpu_current_renderer->impl->GenerateMipmaps(_gpu_current_renderer, image); 1305 1305 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1306 1306 + return; 1307 1307 + 1308 1308 + _gpu_current_renderer->impl->GenerateMipmaps(_gpu_current_renderer, image); 1296 1309 } 1297 1310 1298 1311 ··· 1300 1313 1301 1314 GPU_Rect GPU_SetClipRect(GPU_Target* target, GPU_Rect rect) 1302 1315 { 1303 1303 - if(target == NULL || _gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1304 1304 - { 1305 1305 - GPU_Rect r = {0,0,0,0}; 1306 1306 - return r; 1307 1307 - } 1308 1308 - 1309 1309 - return _gpu_current_renderer->impl->SetClip(_gpu_current_renderer, target, (Sint16)rect.x, (Sint16)rect.y, (Uint16)rect.w, (Uint16)rect.h); 1316 1316 + if(target == NULL || _gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1317 1317 + { 1318 1318 + GPU_Rect r = {0,0,0,0}; 1319 1319 + return r; 1320 1320 + } 1321 1321 + 1322 1322 + return _gpu_current_renderer->impl->SetClip(_gpu_current_renderer, target, (Sint16)rect.x, (Sint16)rect.y, (Uint16)rect.w, (Uint16)rect.h); 1310 1323 } 1311 1324 1312 1325 GPU_Rect GPU_SetClip(GPU_Target* target, Sint16 x, Sint16 y, Uint16 w, Uint16 h) 1313 1326 { 1314 1314 - if(target == NULL || _gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1315 1315 - { 1316 1316 - GPU_Rect r = {0,0,0,0}; 1317 1317 - return r; 1318 1318 - } 1319 1319 - 1320 1320 - return _gpu_current_renderer->impl->SetClip(_gpu_current_renderer, target, x, y, w, h); 1327 1327 + if(target == NULL || _gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1328 1328 + { 1329 1329 + GPU_Rect r = {0,0,0,0}; 1330 1330 + return r; 1331 1331 + } 1332 1332 + 1333 1333 + return _gpu_current_renderer->impl->SetClip(_gpu_current_renderer, target, x, y, w, h); 1321 1334 } 1322 1335 1323 1336 void GPU_UnsetClip(GPU_Target* target) 1324 1337 { 1325 1325 - if(target == NULL || _gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1338 1338 + if(target == NULL || _gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1326 1339 return; 1327 1327 - 1328 1328 - _gpu_current_renderer->impl->UnsetClip(_gpu_current_renderer, target); 1340 1340 + 1341 1341 + _gpu_current_renderer->impl->UnsetClip(_gpu_current_renderer, target); 1329 1342 } 1330 1343 1331 1344 ··· 1333 1346 1334 1347 void GPU_SetColor(GPU_Image* image, SDL_Color color) 1335 1348 { 1336 1336 - if(image == NULL) 1337 1337 - return; 1338 1338 - 1339 1339 - image->color = color; 1349 1349 + if(image == NULL) 1350 1350 + return; 1351 1351 + 1352 1352 + image->color = color; 1340 1353 } 1341 1354 1342 1355 void GPU_SetRGB(GPU_Image* image, Uint8 r, Uint8 g, Uint8 b) 1343 1356 { 1344 1344 - SDL_Color c; 1345 1345 - c.r = r; 1346 1346 - c.g = g; 1347 1347 - c.b = b; 1348 1348 - GET_ALPHA(c) = 255; 1357 1357 + SDL_Color c; 1358 1358 + c.r = r; 1359 1359 + c.g = g; 1360 1360 + c.b = b; 1361 1361 + GET_ALPHA(c) = 255; 1362 1362 + 1363 1363 + if(image == NULL) 1364 1364 + return; 1349 1365 1350 1350 - if(image == NULL) 1351 1351 - return; 1352 1352 - 1353 1353 - image->color = c; 1366 1366 + image->color = c; 1354 1367 } 1355 1368 1356 1369 void GPU_SetRGBA(GPU_Image* image, Uint8 r, Uint8 g, Uint8 b, Uint8 a) 1357 1370 { 1358 1358 - SDL_Color c; 1359 1359 - c.r = r; 1360 1360 - c.g = g; 1361 1361 - c.b = b; 1362 1362 - GET_ALPHA(c) = a; 1371 1371 + SDL_Color c; 1372 1372 + c.r = r; 1373 1373 + c.g = g; 1374 1374 + c.b = b; 1375 1375 + GET_ALPHA(c) = a; 1376 1376 + 1377 1377 + if(image == NULL) 1378 1378 + return; 1363 1379 1364 1364 - if(image == NULL) 1365 1365 - return; 1366 1366 - 1367 1367 - image->color = c; 1380 1380 + image->color = c; 1368 1381 } 1369 1382 1370 1383 void GPU_UnsetColor(GPU_Image* image) 1371 1384 { 1372 1385 SDL_Color c = {255, 255, 255, 255}; 1373 1373 - if(image == NULL) 1374 1374 - return; 1375 1375 - 1386 1386 + if(image == NULL) 1387 1387 + return; 1388 1388 + 1376 1389 image->color = c; 1377 1390 } 1378 1391 1379 1392 void GPU_SetTargetColor(GPU_Target* target, SDL_Color color) 1380 1393 { 1381 1381 - if(target == NULL) 1382 1382 - return; 1383 1383 - 1394 1394 + if(target == NULL) 1395 1395 + return; 1396 1396 + 1384 1397 target->use_color = 1; 1385 1398 target->color = color; 1386 1399 } 1387 1400 1388 1401 void GPU_SetTargetRGB(GPU_Target* target, Uint8 r, Uint8 g, Uint8 b) 1389 1402 { 1390 1390 - SDL_Color c; 1391 1391 - c.r = r; 1392 1392 - c.g = g; 1393 1393 - c.b = b; 1394 1394 - GET_ALPHA(c) = 255; 1403 1403 + SDL_Color c; 1404 1404 + c.r = r; 1405 1405 + c.g = g; 1406 1406 + c.b = b; 1407 1407 + GET_ALPHA(c) = 255; 1408 1408 + 1409 1409 + if(target == NULL) 1410 1410 + return; 1395 1411 1396 1396 - if(target == NULL) 1397 1397 - return; 1398 1398 - 1399 1412 target->use_color = !(r == 255 && g == 255 && b == 255); 1400 1413 target->color = c; 1401 1414 } 1402 1415 1403 1416 void GPU_SetTargetRGBA(GPU_Target* target, Uint8 r, Uint8 g, Uint8 b, Uint8 a) 1404 1417 { 1405 1405 - SDL_Color c; 1406 1406 - c.r = r; 1407 1407 - c.g = g; 1408 1408 - c.b = b; 1409 1409 - GET_ALPHA(c) = a; 1418 1418 + SDL_Color c; 1419 1419 + c.r = r; 1420 1420 + c.g = g; 1421 1421 + c.b = b; 1422 1422 + GET_ALPHA(c) = a; 1423 1423 + 1424 1424 + if(target == NULL) 1425 1425 + return; 1410 1426 1411 1411 - if(target == NULL) 1412 1412 - return; 1413 1413 - 1414 1427 target->use_color = !(r == 255 && g == 255 && b == 255 && a == 255); 1415 1428 target->color = c; 1416 1429 } ··· 1418 1431 void GPU_UnsetTargetColor(GPU_Target* target) 1419 1432 { 1420 1433 SDL_Color c = {255, 255, 255, 255}; 1421 1421 - if(target == NULL) 1422 1422 - return; 1423 1423 - 1434 1434 + if(target == NULL) 1435 1435 + return; 1436 1436 + 1424 1437 target->use_color = 0; 1425 1438 target->color = c; 1426 1439 } 1427 1440 1428 1441 Uint8 GPU_GetBlending(GPU_Image* image) 1429 1442 { 1430 1430 - if(image == NULL) 1431 1431 - return 0; 1432 1432 - 1433 1433 - return image->use_blending; 1443 1443 + if(image == NULL) 1444 1444 + return 0; 1445 1445 + 1446 1446 + return image->use_blending; 1434 1447 } 1435 1448 1436 1449 1437 1450 void GPU_SetBlending(GPU_Image* image, Uint8 enable) 1438 1451 { 1439 1439 - if(image == NULL) 1440 1440 - return; 1441 1441 - 1442 1442 - image->use_blending = enable; 1452 1452 + if(image == NULL) 1453 1453 + return; 1454 1454 + 1455 1455 + image->use_blending = enable; 1443 1456 } 1444 1457 1445 1458 void GPU_SetShapeBlending(Uint8 enable) 1446 1459 { 1447 1447 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1448 1448 - return; 1449 1449 - 1450 1450 - _gpu_current_renderer->current_context_target->context->shapes_use_blending = enable; 1460 1460 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1461 1461 + return; 1462 1462 + 1463 1463 + _gpu_current_renderer->current_context_target->context->shapes_use_blending = enable; 1451 1464 } 1452 1465 1453 1466 1454 1467 GPU_BlendMode GPU_GetBlendModeFromPreset(GPU_BlendPresetEnum preset) 1455 1468 { 1456 1456 - switch(preset) 1457 1457 - { 1469 1469 + switch(preset) 1470 1470 + { 1458 1471 case GPU_BLEND_NORMAL: 1459 1459 - { 1460 1460 - GPU_BlendMode b = {GPU_FUNC_SRC_ALPHA, GPU_FUNC_ONE_MINUS_SRC_ALPHA, GPU_FUNC_SRC_ALPHA, GPU_FUNC_ONE_MINUS_SRC_ALPHA, GPU_EQ_ADD, GPU_EQ_ADD}; 1461 1461 - return b; 1462 1462 - } 1463 1463 - break; 1472 1472 + { 1473 1473 + GPU_BlendMode b = {GPU_FUNC_SRC_ALPHA, GPU_FUNC_ONE_MINUS_SRC_ALPHA, GPU_FUNC_SRC_ALPHA, GPU_FUNC_ONE_MINUS_SRC_ALPHA, GPU_EQ_ADD, GPU_EQ_ADD}; 1474 1474 + return b; 1475 1475 + } 1476 1476 + break; 1464 1477 case GPU_BLEND_PREMULTIPLIED_ALPHA: 1465 1465 - { 1466 1466 - GPU_BlendMode b = {GPU_FUNC_ONE, GPU_FUNC_ONE_MINUS_SRC_ALPHA, GPU_FUNC_ONE, GPU_FUNC_ONE_MINUS_SRC_ALPHA, GPU_EQ_ADD, GPU_EQ_ADD}; 1467 1467 - return b; 1468 1468 - } 1469 1469 - break; 1478 1478 + { 1479 1479 + GPU_BlendMode b = {GPU_FUNC_ONE, GPU_FUNC_ONE_MINUS_SRC_ALPHA, GPU_FUNC_ONE, GPU_FUNC_ONE_MINUS_SRC_ALPHA, GPU_EQ_ADD, GPU_EQ_ADD}; 1480 1480 + return b; 1481 1481 + } 1482 1482 + break; 1470 1483 case GPU_BLEND_MULTIPLY: 1471 1471 - { 1472 1472 - GPU_BlendMode b = {GPU_FUNC_DST_COLOR, GPU_FUNC_ZERO, GPU_FUNC_SRC_ALPHA, GPU_FUNC_ONE_MINUS_SRC_ALPHA, GPU_EQ_ADD, GPU_EQ_ADD}; 1473 1473 - return b; 1474 1474 - } 1475 1475 - break; 1484 1484 + { 1485 1485 + GPU_BlendMode b = {GPU_FUNC_DST_COLOR, GPU_FUNC_ZERO, GPU_FUNC_SRC_ALPHA, GPU_FUNC_ONE_MINUS_SRC_ALPHA, GPU_EQ_ADD, GPU_EQ_ADD}; 1486 1486 + return b; 1487 1487 + } 1488 1488 + break; 1476 1489 case GPU_BLEND_ADD: 1477 1477 - { 1478 1478 - GPU_BlendMode b = {GPU_FUNC_SRC_ALPHA, GPU_FUNC_ONE, GPU_FUNC_SRC_ALPHA, GPU_FUNC_ONE, GPU_EQ_ADD, GPU_EQ_ADD}; 1479 1479 - return b; 1480 1480 - } 1481 1481 - break; 1490 1490 + { 1491 1491 + GPU_BlendMode b = {GPU_FUNC_SRC_ALPHA, GPU_FUNC_ONE, GPU_FUNC_SRC_ALPHA, GPU_FUNC_ONE, GPU_EQ_ADD, GPU_EQ_ADD}; 1492 1492 + return b; 1493 1493 + } 1494 1494 + break; 1482 1495 case GPU_BLEND_SUBTRACT: 1483 1496 // FIXME: Use src alpha for source components? 1484 1484 - { 1485 1485 - GPU_BlendMode b = {GPU_FUNC_ONE, GPU_FUNC_ONE, GPU_FUNC_ONE, GPU_FUNC_ONE, GPU_EQ_SUBTRACT, GPU_EQ_SUBTRACT}; 1486 1486 - return b; 1487 1487 - } 1488 1488 - break; 1497 1497 + { 1498 1498 + GPU_BlendMode b = {GPU_FUNC_ONE, GPU_FUNC_ONE, GPU_FUNC_ONE, GPU_FUNC_ONE, GPU_EQ_SUBTRACT, GPU_EQ_SUBTRACT}; 1499 1499 + return b; 1500 1500 + } 1501 1501 + break; 1489 1502 case GPU_BLEND_MOD_ALPHA: 1490 1503 // Don't disturb the colors, but multiply the dest alpha by the src alpha 1491 1491 - { 1492 1492 - GPU_BlendMode b = {GPU_FUNC_ZERO, GPU_FUNC_ONE, GPU_FUNC_ZERO, GPU_FUNC_SRC_ALPHA, GPU_EQ_ADD, GPU_EQ_ADD}; 1493 1493 - return b; 1494 1494 - } 1495 1495 - break; 1504 1504 + { 1505 1505 + GPU_BlendMode b = {GPU_FUNC_ZERO, GPU_FUNC_ONE, GPU_FUNC_ZERO, GPU_FUNC_SRC_ALPHA, GPU_EQ_ADD, GPU_EQ_ADD}; 1506 1506 + return b; 1507 1507 + } 1508 1508 + break; 1496 1509 case GPU_BLEND_SET_ALPHA: 1497 1510 // Don't disturb the colors, but set the alpha to the src alpha 1498 1498 - { 1499 1499 - GPU_BlendMode b = {GPU_FUNC_ZERO, GPU_FUNC_ONE, GPU_FUNC_ONE, GPU_FUNC_ZERO, GPU_EQ_ADD, GPU_EQ_ADD}; 1500 1500 - return b; 1501 1501 - } 1502 1502 - break; 1511 1511 + { 1512 1512 + GPU_BlendMode b = {GPU_FUNC_ZERO, GPU_FUNC_ONE, GPU_FUNC_ONE, GPU_FUNC_ZERO, GPU_EQ_ADD, GPU_EQ_ADD}; 1513 1513 + return b; 1514 1514 + } 1515 1515 + break; 1503 1516 case GPU_BLEND_SET: 1504 1504 - { 1505 1505 - GPU_BlendMode b = {GPU_FUNC_ONE, GPU_FUNC_ZERO, GPU_FUNC_ONE, GPU_FUNC_ZERO, GPU_EQ_ADD, GPU_EQ_ADD}; 1506 1506 - return b; 1507 1507 - } 1508 1508 - break; 1517 1517 + { 1518 1518 + GPU_BlendMode b = {GPU_FUNC_ONE, GPU_FUNC_ZERO, GPU_FUNC_ONE, GPU_FUNC_ZERO, GPU_EQ_ADD, GPU_EQ_ADD}; 1519 1519 + return b; 1520 1520 + } 1521 1521 + break; 1509 1522 case GPU_BLEND_NORMAL_KEEP_ALPHA: 1510 1510 - { 1511 1511 - GPU_BlendMode b = {GPU_FUNC_SRC_ALPHA, GPU_FUNC_ONE_MINUS_SRC_ALPHA, GPU_FUNC_ZERO, GPU_FUNC_ONE, GPU_EQ_ADD, GPU_EQ_ADD}; 1512 1512 - return b; 1513 1513 - } 1514 1514 - break; 1523 1523 + { 1524 1524 + GPU_BlendMode b = {GPU_FUNC_SRC_ALPHA, GPU_FUNC_ONE_MINUS_SRC_ALPHA, GPU_FUNC_ZERO, GPU_FUNC_ONE, GPU_EQ_ADD, GPU_EQ_ADD}; 1525 1525 + return b; 1526 1526 + } 1527 1527 + break; 1515 1528 case GPU_BLEND_NORMAL_ADD_ALPHA: 1516 1516 - { 1517 1517 - GPU_BlendMode b = {GPU_FUNC_SRC_ALPHA, GPU_FUNC_ONE_MINUS_SRC_ALPHA, GPU_FUNC_ONE, GPU_FUNC_ONE, GPU_EQ_ADD, GPU_EQ_ADD}; 1518 1518 - return b; 1519 1519 - } 1520 1520 - break; 1529 1529 + { 1530 1530 + GPU_BlendMode b = {GPU_FUNC_SRC_ALPHA, GPU_FUNC_ONE_MINUS_SRC_ALPHA, GPU_FUNC_ONE, GPU_FUNC_ONE, GPU_EQ_ADD, GPU_EQ_ADD}; 1531 1531 + return b; 1532 1532 + } 1533 1533 + break; 1521 1534 default: 1522 1535 GPU_PushErrorCode(__func__, GPU_ERROR_USER_ERROR, "Blend preset not supported: %d", preset); 1523 1536 { ··· 1525 1538 return b; 1526 1539 } 1527 1540 break; 1528 1528 - } 1541 1541 + } 1529 1542 } 1530 1543 1531 1544 1532 1545 void GPU_SetBlendFunction(GPU_Image* image, GPU_BlendFuncEnum source_color, GPU_BlendFuncEnum dest_color, GPU_BlendFuncEnum source_alpha, GPU_BlendFuncEnum dest_alpha) 1533 1546 { 1534 1534 - if(image == NULL) 1535 1535 - return; 1536 1536 - 1537 1537 - image->blend_mode.source_color = source_color; 1538 1538 - image->blend_mode.dest_color = dest_color; 1539 1539 - image->blend_mode.source_alpha = source_alpha; 1540 1540 - image->blend_mode.dest_alpha = dest_alpha; 1547 1547 + if(image == NULL) 1548 1548 + return; 1549 1549 + 1550 1550 + image->blend_mode.source_color = source_color; 1551 1551 + image->blend_mode.dest_color = dest_color; 1552 1552 + image->blend_mode.source_alpha = source_alpha; 1553 1553 + image->blend_mode.dest_alpha = dest_alpha; 1541 1554 } 1542 1555 1543 1556 void GPU_SetBlendEquation(GPU_Image* image, GPU_BlendEqEnum color_equation, GPU_BlendEqEnum alpha_equation) 1544 1557 { 1545 1545 - if(image == NULL) 1546 1546 - return; 1547 1547 - 1558 1558 + if(image == NULL) 1559 1559 + return; 1560 1560 + 1548 1561 image->blend_mode.color_equation = color_equation; 1549 1562 image->blend_mode.alpha_equation = alpha_equation; 1550 1563 } ··· 1552 1565 void GPU_SetBlendMode(GPU_Image* image, GPU_BlendPresetEnum preset) 1553 1566 { 1554 1567 GPU_BlendMode b; 1555 1555 - if(image == NULL) 1556 1556 - return; 1557 1557 - 1558 1558 - b = GPU_GetBlendModeFromPreset(preset); 1568 1568 + if(image == NULL) 1569 1569 + return; 1570 1570 + 1571 1571 + b = GPU_GetBlendModeFromPreset(preset); 1559 1572 GPU_SetBlendFunction(image, b.source_color, b.dest_color, b.source_alpha, b.dest_alpha); 1560 1573 GPU_SetBlendEquation(image, b.color_equation, b.alpha_equation); 1561 1574 } ··· 1563 1576 void GPU_SetShapeBlendFunction(GPU_BlendFuncEnum source_color, GPU_BlendFuncEnum dest_color, GPU_BlendFuncEnum source_alpha, GPU_BlendFuncEnum dest_alpha) 1564 1577 { 1565 1578 GPU_Context* context; 1566 1566 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1567 1567 - return; 1568 1568 - 1569 1569 - context = _gpu_current_renderer->current_context_target->context; 1570 1570 - 1571 1571 - context->shapes_blend_mode.source_color = source_color; 1572 1572 - context->shapes_blend_mode.dest_color = dest_color; 1573 1573 - context->shapes_blend_mode.source_alpha = source_alpha; 1574 1574 - context->shapes_blend_mode.dest_alpha = dest_alpha; 1579 1579 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1580 1580 + return; 1581 1581 + 1582 1582 + context = _gpu_current_renderer->current_context_target->context; 1583 1583 + 1584 1584 + context->shapes_blend_mode.source_color = source_color; 1585 1585 + context->shapes_blend_mode.dest_color = dest_color; 1586 1586 + context->shapes_blend_mode.source_alpha = source_alpha; 1587 1587 + context->shapes_blend_mode.dest_alpha = dest_alpha; 1575 1588 } 1576 1589 1577 1590 void GPU_SetShapeBlendEquation(GPU_BlendEqEnum color_equation, GPU_BlendEqEnum alpha_equation) 1578 1591 { 1579 1592 GPU_Context* context; 1580 1580 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1581 1581 - return; 1582 1582 - 1583 1583 - context = _gpu_current_renderer->current_context_target->context; 1584 1584 - 1593 1593 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1594 1594 + return; 1595 1595 + 1596 1596 + context = _gpu_current_renderer->current_context_target->context; 1597 1597 + 1585 1598 context->shapes_blend_mode.color_equation = color_equation; 1586 1599 context->shapes_blend_mode.alpha_equation = alpha_equation; 1587 1600 } ··· 1589 1602 void GPU_SetShapeBlendMode(GPU_BlendPresetEnum preset) 1590 1603 { 1591 1604 GPU_BlendMode b; 1592 1592 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1593 1593 - return; 1594 1594 - 1595 1595 - b = GPU_GetBlendModeFromPreset(preset); 1605 1605 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1606 1606 + return; 1607 1607 + 1608 1608 + b = GPU_GetBlendModeFromPreset(preset); 1596 1609 GPU_SetShapeBlendFunction(b.source_color, b.dest_color, b.source_alpha, b.dest_alpha); 1597 1610 GPU_SetShapeBlendEquation(b.color_equation, b.alpha_equation); 1598 1611 } 1599 1612 1600 1613 void GPU_SetImageFilter(GPU_Image* image, GPU_FilterEnum filter) 1601 1614 { 1602 1602 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1603 1603 - return; 1604 1604 - if(image == NULL) 1605 1605 - return; 1606 1606 - 1607 1607 - _gpu_current_renderer->impl->SetImageFilter(_gpu_current_renderer, image, filter); 1615 1615 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1616 1616 + return; 1617 1617 + if(image == NULL) 1618 1618 + return; 1619 1619 + 1620 1620 + _gpu_current_renderer->impl->SetImageFilter(_gpu_current_renderer, image, filter); 1608 1621 } 1609 1622 1610 1623 GPU_SnapEnum GPU_GetSnapMode(GPU_Image* image) 1611 1624 { 1612 1612 - if(image == NULL) 1613 1613 - return 0; 1614 1614 - 1615 1615 - return image->snap_mode; 1625 1625 + if(image == NULL) 1626 1626 + return 0; 1627 1627 + 1628 1628 + return image->snap_mode; 1616 1629 } 1617 1630 1618 1631 void GPU_SetSnapMode(GPU_Image* image, GPU_SnapEnum mode) 1619 1632 { 1620 1620 - if(image == NULL) 1621 1621 - return; 1622 1622 - 1623 1623 - image->snap_mode = mode; 1633 1633 + if(image == NULL) 1634 1634 + return; 1635 1635 + 1636 1636 + image->snap_mode = mode; 1624 1637 } 1625 1638 1626 1639 void GPU_SetWrapMode(GPU_Image* image, GPU_WrapEnum wrap_mode_x, GPU_WrapEnum wrap_mode_y) 1627 1640 { 1628 1628 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1629 1629 - return; 1630 1630 - if(image == NULL) 1631 1631 - return; 1632 1632 - 1633 1633 - _gpu_current_renderer->impl->SetWrapMode(_gpu_current_renderer, image, wrap_mode_x, wrap_mode_y); 1641 1641 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1642 1642 + return; 1643 1643 + if(image == NULL) 1644 1644 + return; 1645 1645 + 1646 1646 + _gpu_current_renderer->impl->SetWrapMode(_gpu_current_renderer, image, wrap_mode_x, wrap_mode_y); 1634 1647 } 1635 1648 1636 1649 1637 1650 SDL_Color GPU_GetPixel(GPU_Target* target, Sint16 x, Sint16 y) 1638 1651 { 1639 1639 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1640 1640 - { 1641 1641 - SDL_Color c = {0,0,0,0}; 1642 1642 - return c; 1643 1643 - } 1644 1644 - 1645 1645 - return _gpu_current_renderer->impl->GetPixel(_gpu_current_renderer, target, x, y); 1652 1652 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1653 1653 + { 1654 1654 + SDL_Color c = {0,0,0,0}; 1655 1655 + return c; 1656 1656 + } 1657 1657 + 1658 1658 + return _gpu_current_renderer->impl->GetPixel(_gpu_current_renderer, target, x, y); 1646 1659 } 1647 1660 1648 1661 ··· 1658 1671 MAKE_CURRENT_IF_NONE(target); 1659 1672 if(!CHECK_CONTEXT) 1660 1673 RETURN_ERROR(GPU_ERROR_USER_ERROR, "NULL context"); 1661 1661 - 1662 1662 - _gpu_current_renderer->impl->ClearRGBA(_gpu_current_renderer, target, 0, 0, 0, 0); 1674 1674 + 1675 1675 + _gpu_current_renderer->impl->ClearRGBA(_gpu_current_renderer, target, 0, 0, 0, 0); 1663 1676 } 1664 1677 1665 1678 void GPU_ClearColor(GPU_Target* target, SDL_Color color) ··· 1669 1682 MAKE_CURRENT_IF_NONE(target); 1670 1683 if(!CHECK_CONTEXT) 1671 1684 RETURN_ERROR(GPU_ERROR_USER_ERROR, "NULL context"); 1672 1672 - 1685 1685 + 1673 1686 _gpu_current_renderer->impl->ClearRGBA(_gpu_current_renderer, target, color.r, color.g, color.b, GET_ALPHA(color)); 1674 1687 } 1675 1688 ··· 1680 1693 MAKE_CURRENT_IF_NONE(target); 1681 1694 if(!CHECK_CONTEXT) 1682 1695 RETURN_ERROR(GPU_ERROR_USER_ERROR, "NULL context"); 1683 1683 - 1684 1684 - _gpu_current_renderer->impl->ClearRGBA(_gpu_current_renderer, target, r, g, b, 255); 1696 1696 + 1697 1697 + _gpu_current_renderer->impl->ClearRGBA(_gpu_current_renderer, target, r, g, b, 255); 1685 1698 } 1686 1699 1687 1700 void GPU_ClearRGBA(GPU_Target* target, Uint8 r, Uint8 g, Uint8 b, Uint8 a) ··· 1691 1704 MAKE_CURRENT_IF_NONE(target); 1692 1705 if(!CHECK_CONTEXT) 1693 1706 RETURN_ERROR(GPU_ERROR_USER_ERROR, "NULL context"); 1694 1694 - 1695 1695 - _gpu_current_renderer->impl->ClearRGBA(_gpu_current_renderer, target, r, g, b, a); 1707 1707 + 1708 1708 + _gpu_current_renderer->impl->ClearRGBA(_gpu_current_renderer, target, r, g, b, a); 1696 1709 } 1697 1710 1698 1711 void GPU_FlushBlitBuffer(void) 1699 1712 { 1700 1700 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1701 1701 - return; 1702 1702 - 1703 1703 - _gpu_current_renderer->impl->FlushBlitBuffer(_gpu_current_renderer); 1713 1713 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1714 1714 + return; 1715 1715 + 1716 1716 + _gpu_current_renderer->impl->FlushBlitBuffer(_gpu_current_renderer); 1704 1717 } 1705 1718 1706 1719 void GPU_Flip(GPU_Target* target) ··· 1710 1723 MAKE_CURRENT_IF_NONE(target); 1711 1724 if(!CHECK_CONTEXT) 1712 1725 RETURN_ERROR(GPU_ERROR_USER_ERROR, "NULL context"); 1713 1713 - 1714 1714 - _gpu_current_renderer->impl->Flip(_gpu_current_renderer, target); 1726 1726 + 1727 1727 + _gpu_current_renderer->impl->Flip(_gpu_current_renderer, target); 1715 1728 } 1716 1729 1717 1730 ··· 1723 1736 1724 1737 Uint32 GPU_CompileShader_RW(GPU_ShaderEnum shader_type, SDL_RWops* shader_source) 1725 1738 { 1726 1726 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1727 1727 - return 0; 1728 1728 - 1729 1729 - return _gpu_current_renderer->impl->CompileShader_RW(_gpu_current_renderer, shader_type, shader_source); 1739 1739 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1740 1740 + return 0; 1741 1741 + 1742 1742 + return _gpu_current_renderer->impl->CompileShader_RW(_gpu_current_renderer, shader_type, shader_source); 1730 1743 } 1731 1744 1732 1745 Uint32 GPU_LoadShader(GPU_ShaderEnum shader_type, const char* filename) 1733 1746 { 1734 1734 - SDL_RWops* rwops; 1735 1735 - Uint32 result; 1747 1747 + SDL_RWops* rwops; 1748 1748 + Uint32 result; 1736 1749 1737 1750 if(filename == NULL) 1738 1751 { ··· 1752 1765 1753 1766 Uint32 GPU_CompileShader(GPU_ShaderEnum shader_type, const char* shader_source) 1754 1767 { 1755 1755 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1756 1756 - return 0; 1757 1757 - 1758 1758 - return _gpu_current_renderer->impl->CompileShader(_gpu_current_renderer, shader_type, shader_source); 1768 1768 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1769 1769 + return 0; 1770 1770 + 1771 1771 + return _gpu_current_renderer->impl->CompileShader(_gpu_current_renderer, shader_type, shader_source); 1759 1772 } 1760 1773 1761 1774 Uint8 GPU_LinkShaderProgram(Uint32 program_object) 1762 1775 { 1763 1763 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1764 1764 - return 0; 1765 1765 - 1766 1766 - return _gpu_current_renderer->impl->LinkShaderProgram(_gpu_current_renderer, program_object); 1776 1776 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1777 1777 + return 0; 1778 1778 + 1779 1779 + return _gpu_current_renderer->impl->LinkShaderProgram(_gpu_current_renderer, program_object); 1767 1780 } 1768 1781 1769 1782 Uint32 GPU_CreateShaderProgram(void) 1770 1783 { 1771 1771 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1772 1772 - return 0; 1773 1773 - 1774 1774 - return _gpu_current_renderer->impl->CreateShaderProgram(_gpu_current_renderer); 1784 1784 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1785 1785 + return 0; 1786 1786 + 1787 1787 + return _gpu_current_renderer->impl->CreateShaderProgram(_gpu_current_renderer); 1775 1788 } 1776 1789 1777 1790 Uint32 GPU_LinkShaders(Uint32 shader_object1, Uint32 shader_object2) 1778 1791 { 1779 1792 Uint32 p; 1780 1780 - 1781 1781 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1782 1782 - return 0; 1783 1783 - 1793 1793 + 1794 1794 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1795 1795 + return 0; 1796 1796 + 1784 1797 if((_gpu_current_renderer->enabled_features & GPU_FEATURE_BASIC_SHADERS) != GPU_FEATURE_BASIC_SHADERS) 1785 1798 return 0; 1786 1786 - 1799 1799 + 1787 1800 p = _gpu_current_renderer->impl->CreateShaderProgram(_gpu_current_renderer); 1788 1801 1789 1789 - _gpu_current_renderer->impl->AttachShader(_gpu_current_renderer, p, shader_object1); 1790 1790 - _gpu_current_renderer->impl->AttachShader(_gpu_current_renderer, p, shader_object2); 1791 1791 - 1792 1792 - if(_gpu_current_renderer->impl->LinkShaderProgram(_gpu_current_renderer, p)) 1802 1802 + _gpu_current_renderer->impl->AttachShader(_gpu_current_renderer, p, shader_object1); 1803 1803 + _gpu_current_renderer->impl->AttachShader(_gpu_current_renderer, p, shader_object2); 1804 1804 + 1805 1805 + if(_gpu_current_renderer->impl->LinkShaderProgram(_gpu_current_renderer, p)) 1793 1806 return p; 1794 1794 - 1807 1807 + 1795 1808 _gpu_current_renderer->impl->FreeShaderProgram(_gpu_current_renderer, p); 1796 1809 return 0; 1797 1810 } 1798 1811 1799 1812 void GPU_FreeShader(Uint32 shader_object) 1800 1813 { 1801 1801 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1802 1802 - return; 1803 1803 - 1804 1804 - _gpu_current_renderer->impl->FreeShader(_gpu_current_renderer, shader_object); 1814 1814 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1815 1815 + return; 1816 1816 + 1817 1817 + _gpu_current_renderer->impl->FreeShader(_gpu_current_renderer, shader_object); 1805 1818 } 1806 1819 1807 1820 void GPU_FreeShaderProgram(Uint32 program_object) 1808 1821 { 1809 1809 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1810 1810 - return; 1811 1811 - 1812 1812 - _gpu_current_renderer->impl->FreeShaderProgram(_gpu_current_renderer, program_object); 1822 1822 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1823 1823 + return; 1824 1824 + 1825 1825 + _gpu_current_renderer->impl->FreeShaderProgram(_gpu_current_renderer, program_object); 1813 1826 } 1814 1827 1815 1828 void GPU_AttachShader(Uint32 program_object, Uint32 shader_object) 1816 1829 { 1817 1817 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1818 1818 - return; 1819 1819 - 1820 1820 - _gpu_current_renderer->impl->AttachShader(_gpu_current_renderer, program_object, shader_object); 1830 1830 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1831 1831 + return; 1832 1832 + 1833 1833 + _gpu_current_renderer->impl->AttachShader(_gpu_current_renderer, program_object, shader_object); 1821 1834 } 1822 1835 1823 1836 void GPU_DetachShader(Uint32 program_object, Uint32 shader_object) 1824 1837 { 1825 1825 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1826 1826 - return; 1827 1827 - 1828 1828 - _gpu_current_renderer->impl->DetachShader(_gpu_current_renderer, program_object, shader_object); 1838 1838 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1839 1839 + return; 1840 1840 + 1841 1841 + _gpu_current_renderer->impl->DetachShader(_gpu_current_renderer, program_object, shader_object); 1829 1842 } 1830 1843 1831 1844 Uint8 GPU_IsDefaultShaderProgram(Uint32 program_object) 1832 1845 { 1833 1846 GPU_Context* context; 1834 1834 - 1835 1835 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1836 1836 - return 0; 1837 1837 - 1847 1847 + 1848 1848 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1849 1849 + return 0; 1850 1850 + 1838 1851 context = _gpu_current_renderer->current_context_target->context; 1839 1852 return (program_object == context->default_textured_shader_program || program_object == context->default_untextured_shader_program); 1840 1853 } 1841 1854 1842 1855 void GPU_ActivateShaderProgram(Uint32 program_object, GPU_ShaderBlock* block) 1843 1856 { 1844 1844 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1845 1845 - return; 1846 1846 - 1847 1847 - _gpu_current_renderer->impl->ActivateShaderProgram(_gpu_current_renderer, program_object, block); 1857 1857 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1858 1858 + return; 1859 1859 + 1860 1860 + _gpu_current_renderer->impl->ActivateShaderProgram(_gpu_current_renderer, program_object, block); 1848 1861 } 1849 1862 1850 1863 void GPU_DeactivateShaderProgram(void) 1851 1864 { 1852 1852 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1853 1853 - return; 1854 1854 - 1855 1855 - _gpu_current_renderer->impl->DeactivateShaderProgram(_gpu_current_renderer); 1865 1865 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1866 1866 + return; 1867 1867 + 1868 1868 + _gpu_current_renderer->impl->DeactivateShaderProgram(_gpu_current_renderer); 1856 1869 } 1857 1870 1858 1871 const char* GPU_GetShaderMessage(void) 1859 1872 { 1860 1860 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1861 1861 - return NULL; 1862 1862 - 1863 1863 - return _gpu_current_renderer->impl->GetShaderMessage(_gpu_current_renderer); 1873 1873 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1874 1874 + return NULL; 1875 1875 + 1876 1876 + return _gpu_current_renderer->impl->GetShaderMessage(_gpu_current_renderer); 1864 1877 } 1865 1878 1866 1879 int GPU_GetAttributeLocation(Uint32 program_object, const char* attrib_name) 1867 1880 { 1868 1868 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1869 1869 - return 0; 1870 1870 - 1871 1871 - return _gpu_current_renderer->impl->GetAttributeLocation(_gpu_current_renderer, program_object, attrib_name); 1881 1881 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1882 1882 + return 0; 1883 1883 + 1884 1884 + return _gpu_current_renderer->impl->GetAttributeLocation(_gpu_current_renderer, program_object, attrib_name); 1872 1885 } 1873 1886 1874 1887 GPU_AttributeFormat GPU_MakeAttributeFormat(int num_elems_per_vertex, GPU_TypeEnum type, Uint8 normalize, int stride_bytes, int offset_bytes) 1875 1888 { 1876 1876 - GPU_AttributeFormat f; 1877 1877 - f.is_per_sprite = 0; 1878 1878 - f.num_elems_per_value = num_elems_per_vertex; 1879 1879 - f.type = type; 1880 1880 - f.normalize = normalize; 1881 1881 - f.stride_bytes = stride_bytes; 1882 1882 - f.offset_bytes = offset_bytes; 1889 1889 + GPU_AttributeFormat f; 1890 1890 + f.is_per_sprite = 0; 1891 1891 + f.num_elems_per_value = num_elems_per_vertex; 1892 1892 + f.type = type; 1893 1893 + f.normalize = normalize; 1894 1894 + f.stride_bytes = stride_bytes; 1895 1895 + f.offset_bytes = offset_bytes; 1883 1896 return f; 1884 1897 } 1885 1898 1886 1899 GPU_Attribute GPU_MakeAttribute(int location, void* values, GPU_AttributeFormat format) 1887 1900 { 1888 1888 - GPU_Attribute a; 1889 1889 - a.location = location; 1890 1890 - a.values = values; 1891 1891 - a.format = format; 1901 1901 + GPU_Attribute a; 1902 1902 + a.location = location; 1903 1903 + a.values = values; 1904 1904 + a.format = format; 1892 1905 return a; 1893 1906 } 1894 1907 1895 1908 int GPU_GetUniformLocation(Uint32 program_object, const char* uniform_name) 1896 1909 { 1897 1897 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1898 1898 - return 0; 1899 1899 - 1900 1900 - return _gpu_current_renderer->impl->GetUniformLocation(_gpu_current_renderer, program_object, uniform_name); 1910 1910 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1911 1911 + return 0; 1912 1912 + 1913 1913 + return _gpu_current_renderer->impl->GetUniformLocation(_gpu_current_renderer, program_object, uniform_name); 1901 1914 } 1902 1915 1903 1916 GPU_ShaderBlock GPU_LoadShaderBlock(Uint32 program_object, const char* position_name, const char* texcoord_name, const char* color_name, const char* modelViewMatrix_name) 1904 1917 { 1905 1905 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1918 1918 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1906 1919 { 1907 1920 GPU_ShaderBlock b; 1908 1921 b.position_loc = -1; 1909 1922 b.texcoord_loc = -1; 1910 1923 b.color_loc = -1; 1911 1924 b.modelViewProjection_loc = -1; 1912 1912 - return b; 1925 1925 + return b; 1913 1926 } 1914 1914 - 1915 1915 - return _gpu_current_renderer->impl->LoadShaderBlock(_gpu_current_renderer, program_object, position_name, texcoord_name, color_name, modelViewMatrix_name); 1927 1927 + 1928 1928 + return _gpu_current_renderer->impl->LoadShaderBlock(_gpu_current_renderer, program_object, position_name, texcoord_name, color_name, modelViewMatrix_name); 1916 1929 } 1917 1930 1918 1931 void GPU_SetShaderBlock(GPU_ShaderBlock block) 1919 1932 { 1920 1920 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1921 1921 - return; 1922 1922 - 1923 1923 - _gpu_current_renderer->impl->SetShaderBlock(_gpu_current_renderer, block); 1933 1933 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1934 1934 + return; 1935 1935 + 1936 1936 + _gpu_current_renderer->impl->SetShaderBlock(_gpu_current_renderer, block); 1924 1937 } 1925 1938 1926 1939 void GPU_SetShaderImage(GPU_Image* image, int location, int image_unit) 1927 1940 { 1928 1928 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1929 1929 - return; 1930 1930 - 1931 1931 - _gpu_current_renderer->impl->SetShaderImage(_gpu_current_renderer, image, location, image_unit); 1941 1941 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1942 1942 + return; 1943 1943 + 1944 1944 + _gpu_current_renderer->impl->SetShaderImage(_gpu_current_renderer, image, location, image_unit); 1932 1945 } 1933 1946 1934 1947 void GPU_GetUniformiv(Uint32 program_object, int location, int* values) 1935 1948 { 1936 1936 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1937 1937 - return; 1938 1938 - 1939 1939 - _gpu_current_renderer->impl->GetUniformiv(_gpu_current_renderer, program_object, location, values); 1949 1949 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1950 1950 + return; 1951 1951 + 1952 1952 + _gpu_current_renderer->impl->GetUniformiv(_gpu_current_renderer, program_object, location, values); 1940 1953 } 1941 1954 1942 1955 void GPU_SetUniformi(int location, int value) 1943 1956 { 1944 1944 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1945 1945 - return; 1946 1946 - 1947 1947 - _gpu_current_renderer->impl->SetUniformi(_gpu_current_renderer, location, value); 1957 1957 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1958 1958 + return; 1959 1959 + 1960 1960 + _gpu_current_renderer->impl->SetUniformi(_gpu_current_renderer, location, value); 1948 1961 } 1949 1962 1950 1963 void GPU_SetUniformiv(int location, int num_elements_per_value, int num_values, int* values) 1951 1964 { 1952 1952 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1953 1953 - return; 1954 1954 - 1955 1955 - _gpu_current_renderer->impl->SetUniformiv(_gpu_current_renderer, location, num_elements_per_value, num_values, values); 1965 1965 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1966 1966 + return; 1967 1967 + 1968 1968 + _gpu_current_renderer->impl->SetUniformiv(_gpu_current_renderer, location, num_elements_per_value, num_values, values); 1956 1969 } 1957 1970 1958 1971 1959 1972 void GPU_GetUniformuiv(Uint32 program_object, int location, unsigned int* values) 1960 1973 { 1961 1961 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1962 1962 - return; 1963 1963 - 1964 1964 - _gpu_current_renderer->impl->GetUniformuiv(_gpu_current_renderer, program_object, location, values); 1974 1974 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1975 1975 + return; 1976 1976 + 1977 1977 + _gpu_current_renderer->impl->GetUniformuiv(_gpu_current_renderer, program_object, location, values); 1965 1978 } 1966 1979 1967 1980 void GPU_SetUniformui(int location, unsigned int value) 1968 1981 { 1969 1969 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1970 1970 - return; 1971 1971 - 1972 1972 - _gpu_current_renderer->impl->SetUniformui(_gpu_current_renderer, location, value); 1982 1982 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1983 1983 + return; 1984 1984 + 1985 1985 + _gpu_current_renderer->impl->SetUniformui(_gpu_current_renderer, location, value); 1973 1986 } 1974 1987 1975 1988 void GPU_SetUniformuiv(int location, int num_elements_per_value, int num_values, unsigned int* values) 1976 1989 { 1977 1977 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1978 1978 - return; 1979 1979 - 1980 1980 - _gpu_current_renderer->impl->SetUniformuiv(_gpu_current_renderer, location, num_elements_per_value, num_values, values); 1990 1990 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1991 1991 + return; 1992 1992 + 1993 1993 + _gpu_current_renderer->impl->SetUniformuiv(_gpu_current_renderer, location, num_elements_per_value, num_values, values); 1981 1994 } 1982 1995 1983 1996 1984 1997 void GPU_GetUniformfv(Uint32 program_object, int location, float* values) 1985 1998 { 1986 1986 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1987 1987 - return; 1988 1988 - 1989 1989 - _gpu_current_renderer->impl->GetUniformfv(_gpu_current_renderer, program_object, location, values); 1999 1999 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2000 2000 + return; 2001 2001 + 2002 2002 + _gpu_current_renderer->impl->GetUniformfv(_gpu_current_renderer, program_object, location, values); 1990 2003 } 1991 2004 1992 2005 void GPU_SetUniformf(int location, float value) 1993 2006 { 1994 1994 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1995 1995 - return; 1996 1996 - 1997 1997 - _gpu_current_renderer->impl->SetUniformf(_gpu_current_renderer, location, value); 2007 2007 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2008 2008 + return; 2009 2009 + 2010 2010 + _gpu_current_renderer->impl->SetUniformf(_gpu_current_renderer, location, value); 1998 2011 } 1999 2012 2000 2013 void GPU_SetUniformfv(int location, int num_elements_per_value, int num_values, float* values) 2001 2014 { 2002 2002 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2003 2003 - return; 2004 2004 - 2005 2005 - _gpu_current_renderer->impl->SetUniformfv(_gpu_current_renderer, location, num_elements_per_value, num_values, values); 2015 2015 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2016 2016 + return; 2017 2017 + 2018 2018 + _gpu_current_renderer->impl->SetUniformfv(_gpu_current_renderer, location, num_elements_per_value, num_values, values); 2006 2019 } 2007 2020 2008 2021 // Same as GPU_GetUniformfv() 2009 2022 void GPU_GetUniformMatrixfv(Uint32 program_object, int location, float* values) 2010 2023 { 2011 2011 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2012 2012 - return; 2013 2013 - 2014 2014 - _gpu_current_renderer->impl->GetUniformfv(_gpu_current_renderer, program_object, location, values); 2024 2024 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2025 2025 + return; 2026 2026 + 2027 2027 + _gpu_current_renderer->impl->GetUniformfv(_gpu_current_renderer, program_object, location, values); 2015 2028 } 2016 2029 2017 2030 void GPU_SetUniformMatrixfv(int location, int num_matrices, int num_rows, int num_columns, Uint8 transpose, float* values) 2018 2031 { 2019 2019 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2020 2020 - return; 2021 2021 - 2022 2022 - _gpu_current_renderer->impl->SetUniformMatrixfv(_gpu_current_renderer, location, num_matrices, num_rows, num_columns, transpose, values); 2032 2032 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2033 2033 + return; 2034 2034 + 2035 2035 + _gpu_current_renderer->impl->SetUniformMatrixfv(_gpu_current_renderer, location, num_matrices, num_rows, num_columns, transpose, values); 2023 2036 } 2024 2037 2025 2038 2026 2039 void GPU_SetAttributef(int location, float value) 2027 2040 { 2028 2028 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2029 2029 - return; 2030 2030 - 2031 2031 - _gpu_current_renderer->impl->SetAttributef(_gpu_current_renderer, location, value); 2041 2041 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2042 2042 + return; 2043 2043 + 2044 2044 + _gpu_current_renderer->impl->SetAttributef(_gpu_current_renderer, location, value); 2032 2045 } 2033 2046 2034 2047 void GPU_SetAttributei(int location, int value) 2035 2048 { 2036 2036 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2037 2037 - return; 2038 2038 - 2039 2039 - _gpu_current_renderer->impl->SetAttributei(_gpu_current_renderer, location, value); 2049 2049 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2050 2050 + return; 2051 2051 + 2052 2052 + _gpu_current_renderer->impl->SetAttributei(_gpu_current_renderer, location, value); 2040 2053 } 2041 2054 2042 2055 void GPU_SetAttributeui(int location, unsigned int value) 2043 2056 { 2044 2044 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2045 2045 - return; 2046 2046 - 2047 2047 - _gpu_current_renderer->impl->SetAttributeui(_gpu_current_renderer, location, value); 2057 2057 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2058 2058 + return; 2059 2059 + 2060 2060 + _gpu_current_renderer->impl->SetAttributeui(_gpu_current_renderer, location, value); 2048 2061 } 2049 2062 2050 2063 void GPU_SetAttributefv(int location, int num_elements, float* value) 2051 2064 { 2052 2052 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2053 2053 - return; 2054 2054 - 2055 2055 - _gpu_current_renderer->impl->SetAttributefv(_gpu_current_renderer, location, num_elements, value); 2065 2065 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2066 2066 + return; 2067 2067 + 2068 2068 + _gpu_current_renderer->impl->SetAttributefv(_gpu_current_renderer, location, num_elements, value); 2056 2069 } 2057 2070 2058 2071 void GPU_SetAttributeiv(int location, int num_elements, int* value) 2059 2072 { 2060 2060 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2061 2061 - return; 2062 2062 - 2063 2063 - _gpu_current_renderer->impl->SetAttributeiv(_gpu_current_renderer, location, num_elements, value); 2073 2073 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2074 2074 + return; 2075 2075 + 2076 2076 + _gpu_current_renderer->impl->SetAttributeiv(_gpu_current_renderer, location, num_elements, value); 2064 2077 } 2065 2078 2066 2079 void GPU_SetAttributeuiv(int location, int num_elements, unsigned int* value) 2067 2080 { 2068 2068 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2069 2069 - return; 2070 2070 - 2071 2071 - _gpu_current_renderer->impl->SetAttributeuiv(_gpu_current_renderer, location, num_elements, value); 2081 2081 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2082 2082 + return; 2083 2083 + 2084 2084 + _gpu_current_renderer->impl->SetAttributeuiv(_gpu_current_renderer, location, num_elements, value); 2072 2085 } 2073 2086 2074 2087 void GPU_SetAttributeSource(int num_values, GPU_Attribute source) 2075 2088 { 2076 2076 - if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2077 2077 - return; 2078 2078 - 2079 2079 - _gpu_current_renderer->impl->SetAttributeSource(_gpu_current_renderer, num_values, source); 2089 2089 + if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2090 2090 + return; 2091 2091 + 2092 2092 + _gpu_current_renderer->impl->SetAttributeSource(_gpu_current_renderer, num_values, source); 2080 2093 } 2081 2094 2082 2095 ··· 2101 2114 * together for a case independent comparison. The mappings are 2102 2115 * based upon ascii character sequences. 2103 2116 */ 2104 2104 - static const unsigned char caseless_charmap[] = { 2105 2105 - '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007', 2106 2106 - '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017', 2107 2107 - '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027', 2108 2108 - '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037', 2109 2109 - '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047', 2110 2110 - '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057', 2111 2111 - '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067', 2112 2112 - '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077', 2113 2113 - '\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147', 2114 2114 - '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157', 2115 2115 - '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167', 2116 2116 - '\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137', 2117 2117 - '\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147', 2118 2118 - '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157', 2119 2119 - '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167', 2120 2120 - '\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177', 2121 2121 - '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207', 2122 2122 - '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217', 2123 2123 - '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227', 2124 2124 - '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237', 2125 2125 - '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247', 2126 2126 - '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257', 2127 2127 - '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267', 2128 2128 - '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277', 2129 2129 - '\300', '\341', '\342', '\343', '\344', '\345', '\346', '\347', 2130 2130 - '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357', 2131 2131 - '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367', 2132 2132 - '\370', '\371', '\372', '\333', '\334', '\335', '\336', '\337', 2133 2133 - '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347', 2134 2134 - '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357', 2135 2135 - '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367', 2136 2136 - '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377', 2117 2117 + static const unsigned char caseless_charmap[] = 2118 2118 + { 2119 2119 + '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007', 2120 2120 + '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017', 2121 2121 + '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027', 2122 2122 + '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037', 2123 2123 + '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047', 2124 2124 + '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057', 2125 2125 + '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067', 2126 2126 + '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077', 2127 2127 + '\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147', 2128 2128 + '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157', 2129 2129 + '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167', 2130 2130 + '\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137', 2131 2131 + '\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147', 2132 2132 + '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157', 2133 2133 + '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167', 2134 2134 + '\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177', 2135 2135 + '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207', 2136 2136 + '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217', 2137 2137 + '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227', 2138 2138 + '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237', 2139 2139 + '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247', 2140 2140 + '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257', 2141 2141 + '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267', 2142 2142 + '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277', 2143 2143 + '\300', '\341', '\342', '\343', '\344', '\345', '\346', '\347', 2144 2144 + '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357', 2145 2145 + '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367', 2146 2146 + '\370', '\371', '\372', '\333', '\334', '\335', '\336', '\337', 2147 2147 + '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347', 2148 2148 + '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357', 2149 2149 + '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367', 2150 2150 + '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377', 2137 2151 }; 2138 2152 2139 2153 int gpu_strcasecmp(const char* s1, const char* s2) ··· 2154 2168 2155 2169 2156 2170 #ifdef _MSC_VER 2157 2157 - #pragma warning(pop) 2171 2171 + #pragma warning(pop) 2158 2172 #endif 2159 2173

-9

src/externals/stb_image/stb_image.c

reviewed

··· 1 1 2 2 #define STB_IMAGE_IMPLEMENTATION 3 3 4 4 - // Make stb-image use SDL's allocator so we can let SDL handle the memory that stb allocates. 5 5 - // To do this, we'll redefine malloc and free. 6 6 - #include "SDL.h" 7 7 - #include <stdlib.h> 8 8 - #undef malloc 9 9 - #undef free 10 10 - #define malloc SDL_malloc 11 11 - #define free SDL_free 12 12 - 13 4 #include "stb_image.h"

+3 -8

src/externals/stb_image/stb_image_write.c

reviewed

··· 1 1 2 2 #define STB_IMAGE_WRITE_IMPLEMENTATION 3 3 4 4 - // stbi_write_png_to_mem() returns a malloc'ed array, 5 5 - // so let's do the same thing as done with stb_image.c so it is more compatible with SDL's allocator. 6 6 - #include "SDL.h" 7 7 - #include <stdlib.h> 8 8 - #undef malloc 9 9 - #undef free 10 10 - #define malloc SDL_malloc 11 11 - #define free SDL_free 4 4 + // NOTE: stbi_write_png_to_mem() returns a malloc'ed array, 5 5 + // This might be bad for making sure the allocator and deallocator match 6 6 + // and for crossing DLL boundaries with incompatible C runtimes. 12 7 13 8 14 9 #include "stb_image_write.h"

+603 -581

src/renderer_GL_common.inl

reviewed

··· 136 136 unsigned long n = strcspn(p, " "); 137 137 if((extNameLen == n) && (strncmp(extension_str, p, n) == 0)) 138 138 return 1; 139 139 - 139 139 + 140 140 p += (n + 1); 141 141 } 142 142 return 0; ··· 147 147 { 148 148 // Reset supported features 149 149 renderer->enabled_features = 0; 150 150 - 150 150 + 151 151 // NPOT textures 152 152 #ifdef SDL_GPU_USE_OPENGL 153 153 if(isExtensionSupported("GL_ARB_texture_non_power_of_two")) ··· 183 183 #ifdef SDL_GPU_USE_OPENGL 184 184 renderer->enabled_features |= GPU_FEATURE_BLEND_EQUATIONS; 185 185 renderer->enabled_features |= GPU_FEATURE_BLEND_FUNC_SEPARATE; 186 186 - 186 186 + 187 187 #if SDL_GPU_GL_MAJOR_VERSION > 1 188 188 // Core in GL 2+ 189 189 renderer->enabled_features |= GPU_FEATURE_BLEND_EQUATIONS_SEPARATE; ··· 193 193 else 194 194 renderer->enabled_features &= ~GPU_FEATURE_BLEND_EQUATIONS_SEPARATE; 195 195 #endif 196 196 - 196 196 + 197 197 #elif defined(SDL_GPU_USE_GLES) 198 198 199 199 #if SDL_GPU_GLES_MAJOR_VERSION > 1 ··· 206 206 renderer->enabled_features |= GPU_FEATURE_BLEND_EQUATIONS; 207 207 else 208 208 renderer->enabled_features &= ~GPU_FEATURE_BLEND_EQUATIONS; 209 209 - 209 209 + 210 210 if(isExtensionSupported("GL_OES_blend_func_separate")) 211 211 renderer->enabled_features |= GPU_FEATURE_BLEND_FUNC_SEPARATE; 212 212 else 213 213 renderer->enabled_features &= ~GPU_FEATURE_BLEND_FUNC_SEPARATE; 214 214 - 214 214 + 215 215 if(isExtensionSupported("GL_OES_blend_equation_separate")) 216 216 renderer->enabled_features |= GPU_FEATURE_BLEND_EQUATIONS_SEPARATE; 217 217 else ··· 247 247 renderer->enabled_features |= GPU_FEATURE_GL_BGRA; 248 248 if(isExtensionSupported("GL_EXT_abgr")) 249 249 renderer->enabled_features |= GPU_FEATURE_GL_ABGR; 250 250 - 250 250 + 251 251 // Disable other texture formats for GLES. 252 252 // TODO: Add better (static) checking for format support. Some GL versions do not report previously non-core features as extensions. 253 253 #ifdef SDL_GPU_USE_GLES ··· 401 401 new_max_num_vertices = ((unsigned int)cdata->blit_buffer_max_num_vertices) * 2; 402 402 while(new_max_num_vertices <= minimum_vertices_needed) 403 403 new_max_num_vertices *= 2; 404 404 - 404 404 + 405 405 if(new_max_num_vertices > GPU_BLIT_BUFFER_ABSOLUTE_MAX_VERTICES) 406 406 new_max_num_vertices = GPU_BLIT_BUFFER_ABSOLUTE_MAX_VERTICES; 407 407 - 407 407 + 408 408 //GPU_LogError("Growing to %d vertices\n", new_max_num_vertices); 409 409 // Resize the blit buffer 410 410 new_buffer = (float*)SDL_malloc(new_max_num_vertices * GPU_BLIT_BUFFER_STRIDE); ··· 412 412 SDL_free(cdata->blit_buffer); 413 413 cdata->blit_buffer = new_buffer; 414 414 cdata->blit_buffer_max_num_vertices = new_max_num_vertices; 415 415 - 415 415 + 416 416 #ifdef SDL_GPU_USE_BUFFER_PIPELINE 417 417 // Resize the VBOs 418 418 #if !defined(SDL_GPU_NO_VAO) 419 419 glBindVertexArray(cdata->blit_VAO); 420 420 #endif 421 421 - 421 421 + 422 422 glBindBuffer(GL_ARRAY_BUFFER, cdata->blit_VBO[0]); 423 423 glBufferData(GL_ARRAY_BUFFER, GPU_BLIT_BUFFER_STRIDE * cdata->blit_buffer_max_num_vertices, NULL, GL_STREAM_DRAW); 424 424 glBindBuffer(GL_ARRAY_BUFFER, cdata->blit_VBO[1]); 425 425 glBufferData(GL_ARRAY_BUFFER, GPU_BLIT_BUFFER_STRIDE * cdata->blit_buffer_max_num_vertices, NULL, GL_STREAM_DRAW); 426 426 - 426 426 + 427 427 #if !defined(SDL_GPU_NO_VAO) 428 428 glBindVertexArray(0); 429 429 #endif 430 430 #endif 431 431 - 431 431 + 432 432 return 1; 433 433 } 434 434 ··· 441 441 return 1; 442 442 if(cdata->index_buffer_max_num_vertices == GPU_INDEX_BUFFER_ABSOLUTE_MAX_VERTICES) 443 443 return 0; 444 444 - 444 444 + 445 445 // Calculate new size (in vertices) 446 446 new_max_num_vertices = cdata->index_buffer_max_num_vertices * 2; 447 447 while(new_max_num_vertices <= minimum_vertices_needed) 448 448 new_max_num_vertices *= 2; 449 449 - 449 449 + 450 450 if(new_max_num_vertices > GPU_INDEX_BUFFER_ABSOLUTE_MAX_VERTICES) 451 451 new_max_num_vertices = GPU_INDEX_BUFFER_ABSOLUTE_MAX_VERTICES; 452 452 - 452 452 + 453 453 //GPU_LogError("Growing to %d indices\n", new_max_num_vertices); 454 454 // Resize the index buffer 455 455 new_indices = (unsigned short*)SDL_malloc(new_max_num_vertices * sizeof(unsigned short)); ··· 457 457 SDL_free(cdata->index_buffer); 458 458 cdata->index_buffer = new_indices; 459 459 cdata->index_buffer_max_num_vertices = new_max_num_vertices; 460 460 - 460 460 + 461 461 #ifdef SDL_GPU_USE_BUFFER_PIPELINE 462 462 // Resize the IBO 463 463 #if !defined(SDL_GPU_NO_VAO) 464 464 glBindVertexArray(cdata->blit_VAO); 465 465 #endif 466 466 - 466 466 + 467 467 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cdata->blit_IBO); 468 468 glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned short) * cdata->index_buffer_max_num_vertices, NULL, GL_DYNAMIC_DRAW); 469 469 - 469 469 + 470 470 #if !defined(SDL_GPU_NO_VAO) 471 471 glBindVertexArray(0); 472 472 #endif 473 473 #endif 474 474 - 474 474 + 475 475 return 1; 476 476 } 477 477 ··· 481 481 { 482 482 if(target == NULL || target->context == NULL || renderer->current_context_target == target) 483 483 return; 484 484 - 484 484 + 485 485 renderer->impl->FlushBlitBuffer(renderer); 486 486 - 486 486 + 487 487 #ifdef SDL_GPU_USE_SDL2 488 488 SDL_GL_MakeCurrent(SDL_GetWindowFromID(target->context->windowID), target->context->context); 489 489 #endif ··· 552 552 GPU_CONTEXT_DATA* cdata = (GPU_CONTEXT_DATA*)renderer->current_context_target->context->data; 553 553 if(cdata->last_use_blending == enable) 554 554 return; 555 555 - 555 555 + 556 556 renderer->impl->FlushBlitBuffer(renderer); 557 557 558 558 if(enable) ··· 566 566 static void forceChangeBlendMode(GPU_Renderer* renderer, GPU_BlendMode mode) 567 567 { 568 568 GPU_CONTEXT_DATA* cdata = (GPU_CONTEXT_DATA*)renderer->current_context_target->context->data; 569 569 - 569 569 + 570 570 renderer->impl->FlushBlitBuffer(renderer); 571 571 572 572 cdata->last_blend_mode = mode; 573 573 - 573 573 + 574 574 if(mode.source_color == mode.source_alpha && mode.dest_color == mode.dest_alpha) 575 575 { 576 576 glBlendFunc(mode.source_color, mode.dest_color); ··· 583 583 { 584 584 GPU_PushErrorCode("(SDL_gpu internal)", GPU_ERROR_BACKEND_ERROR, "Could not set blend function because GPU_FEATURE_BLEND_FUNC_SEPARATE is not supported."); 585 585 } 586 586 - 586 586 + 587 587 if(renderer->enabled_features & GPU_FEATURE_BLEND_EQUATIONS) 588 588 { 589 589 if(mode.color_equation == mode.alpha_equation) ··· 611 611 && cdata->last_blend_mode.color_equation == mode.color_equation 612 612 && cdata->last_blend_mode.alpha_equation == mode.alpha_equation) 613 613 return; 614 614 - 614 614 + 615 615 forceChangeBlendMode(renderer, mode); 616 616 } 617 617 ··· 622 622 GPU_Context* context = renderer->current_context_target->context; 623 623 if(context->default_textured_shader_program == 0) // No shaders loaded! 624 624 return 0; 625 625 - 625 625 + 626 626 if(program_object == 0) 627 627 return context->default_textured_shader_program; 628 628 - 628 628 + 629 629 return program_object; 630 630 } 631 631 ··· 652 652 if(enable != ((GPU_CONTEXT_DATA*)context->data)->last_use_texturing) 653 653 { 654 654 renderer->impl->FlushBlitBuffer(renderer); 655 655 - 655 655 + 656 656 ((GPU_CONTEXT_DATA*)context->data)->last_use_texturing = enable; 657 657 #ifndef SDL_GPU_SKIP_ENABLE_TEXTURE_2D 658 658 if(enable) ··· 687 687 static void prepareToRenderImage(GPU_Renderer* renderer, GPU_Target* target, GPU_Image* image) 688 688 { 689 689 GPU_Context* context = renderer->current_context_target->context; 690 690 - 690 690 + 691 691 enableTexturing(renderer); 692 692 if(GL_TRIANGLES != ((GPU_CONTEXT_DATA*)context->data)->last_shape) 693 693 { 694 694 renderer->impl->FlushBlitBuffer(renderer); 695 695 ((GPU_CONTEXT_DATA*)context->data)->last_shape = GL_TRIANGLES; 696 696 } 697 697 - 697 697 + 698 698 // Blitting 699 699 if(target->use_color) 700 700 { ··· 703 703 color.g = MIX_COLOR_COMPONENT(target->color.g, image->color.g); 704 704 color.b = MIX_COLOR_COMPONENT(target->color.b, image->color.b); 705 705 GET_ALPHA(color) = MIX_COLOR_COMPONENT(GET_ALPHA(target->color), GET_ALPHA(image->color)); 706 706 - 706 706 + 707 707 changeColor(renderer, color); 708 708 } 709 709 else 710 710 changeColor(renderer, image->color); 711 711 changeBlending(renderer, image->use_blending); 712 712 changeBlendMode(renderer, image->blend_mode); 713 713 - 713 713 + 714 714 // If we're using the untextured shader, switch it. 715 715 if(context->current_shader_program == context->default_untextured_shader_program) 716 716 renderer->impl->ActivateShaderProgram(renderer, context->default_textured_shader_program, NULL); ··· 719 719 static void prepareToRenderShapes(GPU_Renderer* renderer, unsigned int shape) 720 720 { 721 721 GPU_Context* context = renderer->current_context_target->context; 722 722 - 722 722 + 723 723 disableTexturing(renderer); 724 724 if(shape != ((GPU_CONTEXT_DATA*)context->data)->last_shape) 725 725 { 726 726 renderer->impl->FlushBlitBuffer(renderer); 727 727 ((GPU_CONTEXT_DATA*)context->data)->last_shape = shape; 728 728 } 729 729 - 729 729 + 730 730 // Shape rendering 731 731 // Color is set elsewhere for shapes 732 732 changeBlending(renderer, context->shapes_use_blending); 733 733 changeBlendMode(renderer, context->shapes_blend_mode); 734 734 - 734 734 + 735 735 // If we're using the textured shader, switch it. 736 736 if(context->current_shader_program == context->default_textured_shader_program) 737 737 renderer->impl->ActivateShaderProgram(renderer, context->default_untextured_shader_program, NULL); ··· 743 743 { 744 744 float y; 745 745 GPU_CONTEXT_DATA* cdata = (GPU_CONTEXT_DATA*)(GPU_GetContextTarget()->context->data); 746 746 - 746 746 + 747 747 cdata->last_viewport = viewport; 748 748 - 748 748 + 749 749 y = viewport.y; 750 750 if(GPU_GetCoordinateMode() == 0) 751 751 { ··· 755 755 else if(target->context != NULL) 756 756 y = target->context->drawable_h - viewport.h - viewport.y; 757 757 } 758 758 - 758 758 + 759 759 glViewport(viewport.x, y, viewport.w, viewport.h); 760 760 } 761 761 ··· 765 765 766 766 if(cdata->last_viewport.x == target->viewport.x && cdata->last_viewport.y == target->viewport.y && cdata->last_viewport.w == target->viewport.w && cdata->last_viewport.h == target->viewport.h) 767 767 return; 768 768 - 768 768 + 769 769 forceChangeViewport(target, target->viewport); 770 770 } 771 771 ··· 776 776 float offsetX, offsetY; 777 777 778 778 cdata->last_camera = target->camera; 779 779 - 779 779 + 780 780 cdata->last_camera_inverted = invert; 781 781 - 781 781 + 782 782 GPU_MatrixMode( GPU_PROJECTION ); 783 783 GPU_LoadIdentity(); 784 784 - 784 784 + 785 785 if((!invert ^ GPU_GetCoordinateMode())) 786 786 GPU_Ortho(target->camera.x, target->w + target->camera.x, target->h + target->camera.y, target->camera.y, -1.0f, 1.0f); 787 787 else 788 788 GPU_Ortho(target->camera.x, target->w + target->camera.x, target->camera.y, target->h + target->camera.y, -1.0f, 1.0f); // Special inverted orthographic projection because tex coords are inverted already for render-to-texture 789 789 - 789 789 + 790 790 GPU_MatrixMode( GPU_MODELVIEW ); 791 791 GPU_LoadIdentity(); 792 792 ··· 810 810 static void changeCamera(GPU_Target* target) 811 811 { 812 812 //GPU_CONTEXT_DATA* cdata = (GPU_CONTEXT_DATA*)GPU_GetContextTarget()->context->data; 813 813 - 813 813 + 814 814 //if(cdata->last_camera_target != target || !equal_cameras(cdata->last_camera, target->camera)) 815 815 { 816 816 applyTargetCamera(target); ··· 848 848 renderer_request.major_version = 1; 849 849 renderer_request.minor_version = 1; 850 850 } 851 851 - 851 851 + 852 852 // Tell SDL what we require for the GL context. 853 853 GPU_flags = GPU_GetPreInitFlags(); 854 854 - 854 854 + 855 855 renderer->GPU_init_flags = GPU_flags; 856 856 if(GPU_flags & GPU_INIT_DISABLE_DOUBLE_BUFFER) 857 857 SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 0); ··· 873 873 SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_COMPATIBILITY); 874 874 else 875 875 SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE); 876 876 - 876 876 + 877 877 // Set newer default shader version for core-capable contexts 878 878 renderer->shader_version = SDL_GPU_GLSL_VERSION_CORE; 879 879 } 880 880 #endif 881 881 - 881 881 + 882 882 // GL version 883 883 SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, renderer_request.major_version); 884 884 SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, renderer_request.minor_version); ··· 894 894 SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8); 895 895 SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8); 896 896 SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8); 897 897 - 897 897 + 898 898 renderer->requested_id = renderer_request; 899 899 900 900 #ifdef SDL_GPU_USE_SDL2 901 901 - 901 901 + 902 902 window = NULL; 903 903 // Is there a window already set up that we are supposed to use? 904 904 if(renderer->current_context_target != NULL) 905 905 window = SDL_GetWindowFromID(renderer->current_context_target->context->windowID); 906 906 else 907 907 window = SDL_GetWindowFromID(GPU_GetInitWindow()); 908 908 - 908 908 + 909 909 if(window == NULL) 910 910 { 911 911 int win_w, win_h; ··· 915 915 win_w = w; 916 916 win_h = h; 917 917 #endif 918 918 - 918 918 + 919 919 // Set up window flags 920 920 SDL_flags |= SDL_WINDOW_OPENGL; 921 921 if(!(SDL_flags & SDL_WINDOW_HIDDEN)) 922 922 SDL_flags |= SDL_WINDOW_SHOWN; 923 923 - 923 923 + 924 924 renderer->SDL_init_flags = SDL_flags; 925 925 window = SDL_CreateWindow("", 926 926 SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, ··· 932 932 GPU_PushErrorCode("GPU_Init", GPU_ERROR_BACKEND_ERROR, "Window creation failed."); 933 933 return NULL; 934 934 } 935 935 - 935 935 + 936 936 GPU_SetInitWindow(SDL_GetWindowID(window)); 937 937 } 938 938 else ··· 949 949 return NULL; 950 950 } 951 951 #endif 952 952 - 952 952 + 953 953 renderer->enabled_features = 0xFFFFFFFF; // Pretend to support them all if using incompatible headers 954 954 - 955 955 - 954 954 + 955 955 + 956 956 // Create or re-init the current target. This also creates the GL context and initializes enabled_features. 957 957 #ifdef SDL_GPU_USE_SDL2 958 958 if(renderer->impl->CreateTargetFromWindow(renderer, SDL_GetWindowID(window), renderer->current_context_target) == NULL) ··· 961 961 if(renderer->impl->CreateTargetFromWindow(renderer, 0, renderer->current_context_target) == NULL) 962 962 return NULL; 963 963 #endif 964 964 - 964 964 + 965 965 // If the dimensions of the window don't match what we asked for, then set up a virtual resolution to pretend like they are. 966 966 if(!(GPU_flags & GPU_INIT_DISABLE_AUTO_VIRTUAL_RESOLUTION) && w != 0 && h != 0 && (w != renderer->current_context_target->w || h != renderer->current_context_target->h)) 967 967 renderer->impl->SetVirtualResolution(renderer, renderer->current_context_target, w, h); 968 968 - 968 968 + 969 969 // Init glVertexAttrib workaround 970 970 #ifdef SDL_GPU_USE_OPENGL 971 971 vendor_string = (const char*)glGetString(GL_VENDOR); ··· 975 975 apply_Intel_attrib_workaround = 1; 976 976 } 977 977 #endif 978 978 - 978 978 + 979 979 return renderer->current_context_target; 980 980 } 981 981 ··· 1023 1023 memset(cdata, 0, sizeof(GPU_CONTEXT_DATA)); 1024 1024 target->context->data = cdata; 1025 1025 target->context->context = NULL; 1026 1026 - 1026 1026 + 1027 1027 cdata->last_image = NULL; 1028 1028 cdata->last_target = NULL; 1029 1029 // Initialize the blit buffer ··· 1041 1041 GPU_RemoveWindowMapping(target->context->windowID); 1042 1042 cdata = (GPU_CONTEXT_DATA*)target->context->data; 1043 1043 } 1044 1044 - 1044 1044 + 1045 1045 #ifdef SDL_GPU_USE_SDL2 1046 1046 - 1046 1046 + 1047 1047 window = SDL_GetWindowFromID(windowID); 1048 1048 if(window == NULL) 1049 1049 { ··· 1059 1059 } 1060 1060 return NULL; 1061 1061 } 1062 1062 - 1062 1062 + 1063 1063 // Store the window info 1064 1064 target->context->windowID = SDL_GetWindowID(window); 1065 1065 - 1065 1065 + 1066 1066 // Make a new context if needed and make it current 1067 1067 if(created || target->context->context == NULL) 1068 1068 { 1069 1069 target->context->context = SDL_GL_CreateContext(window); 1070 1070 GPU_AddWindowMapping(target); 1071 1071 } 1072 1072 - 1072 1072 + 1073 1073 // Get window dimensions 1074 1074 SDL_GetWindowSize(window, &target->context->window_w, &target->context->window_h); 1075 1075 target->context->stored_window_w = target->context->window_w; 1076 1076 target->context->stored_window_h = target->context->window_h; 1077 1077 // We need a GL context before we can get the drawable size. 1078 1078 SDL_GL_GetDrawableSize(window, &target->context->drawable_w, &target->context->drawable_h); 1079 1079 - 1079 1079 + 1080 1080 #else 1081 1081 - 1081 1081 + 1082 1082 screen = SDL_GetVideoSurface(); 1083 1083 if(screen == NULL) 1084 1084 { ··· 1094 1094 } 1095 1095 return NULL; 1096 1096 } 1097 1097 - 1097 1097 + 1098 1098 target->context->windowID = 1; 1099 1099 target->context->window_w = target->context->drawable_w = screen->w; 1100 1100 target->context->window_h = target->context->drawable_h = screen->h; 1101 1101 target->context->stored_window_w = target->context->window_w; 1102 1102 target->context->stored_window_h = target->context->window_h; 1103 1103 - 1103 1103 + 1104 1104 #endif 1105 1105 - 1105 1105 + 1106 1106 ((GPU_TARGET_DATA*)target->data)->handle = 0; 1107 1107 ((GPU_TARGET_DATA*)target->data)->format = GL_RGBA; 1108 1108 ··· 1118 1118 target->clip_rect.w = target->w; 1119 1119 target->clip_rect.h = target->h; 1120 1120 target->use_color = 0; 1121 1121 - 1121 1121 + 1122 1122 target->viewport = GPU_MakeRect(0, 0, target->context->drawable_w, target->context->drawable_h); 1123 1123 target->camera = GPU_GetDefaultCamera(); 1124 1124 - 1124 1124 + 1125 1125 target->context->line_thickness = 1.0f; 1126 1126 target->context->use_texturing = 1; 1127 1127 target->context->shapes_use_blending = 1; 1128 1128 target->context->shapes_blend_mode = GPU_GetBlendModeFromPreset(GPU_BLEND_NORMAL); 1129 1129 - 1129 1129 + 1130 1130 cdata->last_color = white; 1131 1131 - 1131 1131 + 1132 1132 cdata->last_use_texturing = 1; 1133 1133 cdata->last_shape = GL_TRIANGLES; 1134 1134 - 1134 1134 + 1135 1135 cdata->last_use_blending = 0; 1136 1136 cdata->last_blend_mode = GPU_GetBlendModeFromPreset(GPU_BLEND_NORMAL); 1137 1137 - 1137 1137 + 1138 1138 cdata->last_viewport = target->viewport; 1139 1139 cdata->last_camera = target->camera; // Redundant due to applyTargetCamera(), below 1140 1140 cdata->last_camera_inverted = 0; ··· 1150 1150 return NULL; 1151 1151 } 1152 1152 #endif 1153 1153 - 1153 1153 + 1154 1154 renderer->impl->MakeCurrent(renderer, target, target->context->windowID); 1155 1155 - 1155 1155 + 1156 1156 framebuffer_handle = 0; 1157 1157 glGetIntegerv(GL_FRAMEBUFFER_BINDING, &framebuffer_handle); 1158 1158 ((GPU_TARGET_DATA*)target->data)->handle = framebuffer_handle; 1159 1159 - 1159 1159 + 1160 1160 // Update our renderer info from the current GL context. 1161 1161 #ifdef SDL_GPU_USE_OPENGL 1162 1162 // OpenGL < 3.0 doesn't have GL_MAJOR_VERSION. Check via version string instead. ··· 1169 1169 #else 1170 1170 renderer->id.minor_version = 0; 1171 1171 #endif 1172 1172 - 1172 1172 + 1173 1173 GPU_PushErrorCode("GPU_CreateTargetFromWindow", GPU_ERROR_BACKEND_ERROR, "Failed to parse OpenGL version string: \"%s\"", version_string); 1174 1174 } 1175 1175 #else ··· 1187 1187 #else 1188 1188 renderer->id.minor_version = 0; 1189 1189 #endif 1190 1190 - 1190 1190 + 1191 1191 GPU_PushErrorCode("GPU_CreateTargetFromWindow", GPU_ERROR_BACKEND_ERROR, "Failed to parse OpenGL version string: \"%s\"", version_string); 1192 1192 } 1193 1193 } 1194 1194 #endif 1195 1195 - 1195 1195 + 1196 1196 // Did the wrong runtime library try to use a later versioned renderer? 1197 1197 if(renderer->id.major_version < renderer->requested_id.major_version) 1198 1198 { ··· 1202 1202 } 1203 1203 1204 1204 init_features(renderer); 1205 1205 - 1205 1205 + 1206 1206 if(!IsFeatureEnabled(renderer, required_features)) 1207 1207 { 1208 1208 GPU_PushErrorCode("GPU_CreateTargetFromWindow", GPU_ERROR_BACKEND_ERROR, "Renderer does not support required features."); 1209 1209 target->context->failed = 1; 1210 1210 return NULL; 1211 1211 } 1212 1212 - 1212 1212 + 1213 1213 #ifdef SDL_GPU_USE_SDL2 1214 1214 // No preference for vsync? 1215 1215 if(!(renderer->GPU_init_flags & (GPU_INIT_DISABLE_VSYNC | GPU_INIT_ENABLE_VSYNC))) ··· 1223 1223 else if(renderer->GPU_init_flags & GPU_INIT_DISABLE_VSYNC) 1224 1224 SDL_GL_SetSwapInterval(0); 1225 1225 #endif 1226 1226 - 1226 1226 + 1227 1227 // Set up GL state 1228 1228 - 1228 1228 + 1229 1229 target->context->projection_matrix.size = 1; 1230 1230 GPU_MatrixIdentity(target->context->projection_matrix.matrix[0]); 1231 1231 - 1231 1231 + 1232 1232 target->context->modelview_matrix.size = 1; 1233 1233 GPU_MatrixIdentity(target->context->modelview_matrix.matrix[0]); 1234 1234 - 1234 1234 + 1235 1235 target->context->matrix_mode = GPU_MODELVIEW; 1236 1236 - 1236 1236 + 1237 1237 // Modes 1238 1238 #ifndef SDL_GPU_SKIP_ENABLE_TEXTURE_2D 1239 1239 glEnable(GL_TEXTURE_2D); ··· 1250 1250 #if SDL_GPU_GL_TIER < 3 1251 1251 glColor4f(1.0f, 1.0f, 1.0f, 1.0f); 1252 1252 #endif 1253 1253 - 1253 1253 + 1254 1254 // Set up camera 1255 1255 applyTargetCamera(target); 1256 1256 - 1256 1256 + 1257 1257 renderer->impl->SetLineThickness(renderer, 1.0f); 1258 1258 - 1259 1259 - 1258 1258 + 1259 1259 + 1260 1260 #ifdef SDL_GPU_USE_BUFFER_PIPELINE 1261 1261 // Create vertex array container and buffer 1262 1262 #if !defined(SDL_GPU_NO_VAO) ··· 1264 1264 glBindVertexArray(cdata->blit_VAO); 1265 1265 #endif 1266 1266 #endif 1267 1267 - 1267 1267 + 1268 1268 target->context->default_textured_shader_program = 0; 1269 1269 target->context->default_untextured_shader_program = 0; 1270 1270 target->context->current_shader_program = 0; 1271 1271 - 1271 1271 + 1272 1272 #ifndef SDL_GPU_DISABLE_SHADERS 1273 1273 // Load default shaders 1274 1274 - 1274 1274 + 1275 1275 if(IsFeatureEnabled(renderer, GPU_FEATURE_BASIC_SHADERS)) 1276 1276 { 1277 1277 Uint32 v, f, p; ··· 1279 1279 const char* textured_fragment_shader_source = GPU_DEFAULT_TEXTURED_FRAGMENT_SHADER_SOURCE; 1280 1280 const char* untextured_vertex_shader_source = GPU_DEFAULT_UNTEXTURED_VERTEX_SHADER_SOURCE; 1281 1281 const char* untextured_fragment_shader_source = GPU_DEFAULT_UNTEXTURED_FRAGMENT_SHADER_SOURCE; 1282 1282 - 1282 1282 + 1283 1283 #ifdef SDL_GPU_ENABLE_CORE_SHADERS 1284 1284 // Use core shaders only when supported by the actual context we got 1285 1285 if(renderer->id.major_version > 3 || (renderer->id.major_version == 3 && renderer->id.minor_version >= 2)) ··· 1290 1290 untextured_fragment_shader_source = GPU_DEFAULT_UNTEXTURED_FRAGMENT_SHADER_SOURCE_CORE; 1291 1291 } 1292 1292 #endif 1293 1293 - 1293 1293 + 1294 1294 // Textured shader 1295 1295 v = renderer->impl->CompileShader(renderer, GPU_VERTEX_SHADER, textured_vertex_shader_source); 1296 1296 - 1296 1296 + 1297 1297 if(!v) 1298 1298 { 1299 1299 GPU_PushErrorCode("GPU_CreateTargetFromWindow", GPU_ERROR_BACKEND_ERROR, "Failed to load default textured vertex shader: %s.", GPU_GetShaderMessage()); 1300 1300 target->context->failed = 1; 1301 1301 return NULL; 1302 1302 } 1303 1303 - 1303 1303 + 1304 1304 f = renderer->impl->CompileShader(renderer, GPU_FRAGMENT_SHADER, textured_fragment_shader_source); 1305 1305 - 1305 1305 + 1306 1306 if(!f) 1307 1307 { 1308 1308 GPU_PushErrorCode("GPU_CreateTargetFromWindow", GPU_ERROR_BACKEND_ERROR, "Failed to load default textured fragment shader: %s.", GPU_GetShaderMessage()); 1309 1309 target->context->failed = 1; 1310 1310 return NULL; 1311 1311 } 1312 1312 - 1312 1312 + 1313 1313 p = renderer->impl->CreateShaderProgram(renderer); 1314 1314 renderer->impl->AttachShader(renderer, p, v); 1315 1315 renderer->impl->AttachShader(renderer, p, f); 1316 1316 renderer->impl->LinkShaderProgram(renderer, p); 1317 1317 - 1317 1317 + 1318 1318 if(!p) 1319 1319 { 1320 1320 GPU_PushErrorCode("GPU_CreateTargetFromWindow", GPU_ERROR_BACKEND_ERROR, "Failed to link default textured shader program: %s.", GPU_GetShaderMessage()); 1321 1321 target->context->failed = 1; 1322 1322 return NULL; 1323 1323 } 1324 1324 - 1324 1324 + 1325 1325 target->context->default_textured_shader_program = p; 1326 1326 - 1326 1326 + 1327 1327 // Get locations of the attributes in the shader 1328 1328 cdata->shader_block[0] = GPU_LoadShaderBlock(p, "gpu_Vertex", "gpu_TexCoord", "gpu_Color", "gpu_ModelViewProjectionMatrix"); 1329 1329 - 1330 1330 - 1329 1329 + 1330 1330 + 1331 1331 // Untextured shader 1332 1332 v = renderer->impl->CompileShader(renderer, GPU_VERTEX_SHADER, untextured_vertex_shader_source); 1333 1333 - 1333 1333 + 1334 1334 if(!v) 1335 1335 { 1336 1336 GPU_PushErrorCode("GPU_CreateTargetFromWindow", GPU_ERROR_BACKEND_ERROR, "Failed to load default untextured vertex shader: %s.", GPU_GetShaderMessage()); 1337 1337 target->context->failed = 1; 1338 1338 return NULL; 1339 1339 } 1340 1340 - 1340 1340 + 1341 1341 f = renderer->impl->CompileShader(renderer, GPU_FRAGMENT_SHADER, untextured_fragment_shader_source); 1342 1342 - 1342 1342 + 1343 1343 if(!f) 1344 1344 { 1345 1345 GPU_PushErrorCode("GPU_CreateTargetFromWindow", GPU_ERROR_BACKEND_ERROR, "Failed to load default untextured fragment shader: %s.", GPU_GetShaderMessage()); 1346 1346 target->context->failed = 1; 1347 1347 return NULL; 1348 1348 } 1349 1349 - 1349 1349 + 1350 1350 p = renderer->impl->CreateShaderProgram(renderer); 1351 1351 renderer->impl->AttachShader(renderer, p, v); 1352 1352 renderer->impl->AttachShader(renderer, p, f); 1353 1353 renderer->impl->LinkShaderProgram(renderer, p); 1354 1354 - 1354 1354 + 1355 1355 if(!p) 1356 1356 { 1357 1357 GPU_PushErrorCode("GPU_CreateTargetFromWindow", GPU_ERROR_BACKEND_ERROR, "Failed to link default untextured shader program: %s.", GPU_GetShaderMessage()); 1358 1358 target->context->failed = 1; 1359 1359 return NULL; 1360 1360 } 1361 1361 - 1361 1361 + 1362 1362 glUseProgram(p); 1363 1363 - 1363 1363 + 1364 1364 target->context->default_untextured_shader_program = target->context->current_shader_program = p; 1365 1365 - 1365 1365 + 1366 1366 // Get locations of the attributes in the shader 1367 1367 cdata->shader_block[1] = GPU_LoadShaderBlock(p, "gpu_Vertex", NULL, "gpu_Color", "gpu_ModelViewProjectionMatrix"); 1368 1368 GPU_SetShaderBlock(cdata->shader_block[1]); 1369 1369 - 1369 1369 + 1370 1370 } 1371 1371 else 1372 1372 { 1373 1373 snprintf(shader_message, 256, "Shaders not supported by this hardware. Default shaders are disabled.\n"); 1374 1374 target->context->default_untextured_shader_program = target->context->current_shader_program = 0; 1375 1375 } 1376 1376 - 1376 1376 + 1377 1377 #ifdef SDL_GPU_USE_BUFFER_PIPELINE 1378 1378 // Create vertex array container and buffer 1379 1379 - 1379 1379 + 1380 1380 glGenBuffers(2, cdata->blit_VBO); 1381 1381 // Create space on the GPU 1382 1382 glBindBuffer(GL_ARRAY_BUFFER, cdata->blit_VBO[0]); ··· 1384 1384 glBindBuffer(GL_ARRAY_BUFFER, cdata->blit_VBO[1]); 1385 1385 glBufferData(GL_ARRAY_BUFFER, GPU_BLIT_BUFFER_STRIDE * cdata->blit_buffer_max_num_vertices, NULL, GL_STREAM_DRAW); 1386 1386 cdata->blit_VBO_flop = 0; 1387 1387 - 1387 1387 + 1388 1388 glGenBuffers(1, &cdata->blit_IBO); 1389 1389 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cdata->blit_IBO); 1390 1390 glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned short) * cdata->blit_buffer_max_num_vertices, NULL, GL_DYNAMIC_DRAW); 1391 1391 - 1391 1391 + 1392 1392 glGenBuffers(16, cdata->attribute_VBO); 1393 1393 - 1393 1393 + 1394 1394 // Init 16 attributes to 0 / NULL. 1395 1395 memset(cdata->shader_attributes, 0, 16*sizeof(GPU_AttributeSource)); 1396 1396 #endif 1397 1397 #endif 1398 1398 - 1398 1398 + 1399 1399 return target; 1400 1400 } 1401 1401 ··· 1407 1407 1408 1408 if(target == NULL) 1409 1409 return NULL; 1410 1410 - 1410 1410 + 1411 1411 result = (GPU_Target*)SDL_malloc(sizeof(GPU_Target)); 1412 1412 - 1412 1412 + 1413 1413 // Copy the members 1414 1414 *result = *target; 1415 1415 - 1415 1415 + 1416 1416 // Alias info 1417 1417 if(target->image != NULL) 1418 1418 target->image->refcount++; ··· 1436 1436 #ifdef SDL_GPU_USE_SDL2 1437 1437 if(target->image != NULL) 1438 1438 return; 1439 1439 - 1439 1439 + 1440 1440 c = target->context->context; 1441 1441 if(c != NULL) 1442 1442 { ··· 1448 1448 SDL_Window* window; 1449 1449 1450 1450 renderer->impl->FlushBlitBuffer(renderer); 1451 1451 - 1451 1451 + 1452 1452 // Update the window mappings 1453 1453 GPU_RemoveWindowMapping(windowID); 1454 1454 // Don't remove the target's current mapping. That lets other windows refer to it. 1455 1455 target->context->windowID = windowID; 1456 1456 GPU_AddWindowMapping(target); 1457 1457 - 1457 1457 + 1458 1458 // Update target's window size 1459 1459 window = SDL_GetWindowFromID(windowID); 1460 1460 if(window != NULL) ··· 1464 1464 target->base_w = target->context->drawable_w; 1465 1465 target->base_h = target->context->drawable_h; 1466 1466 } 1467 1467 - 1467 1467 + 1468 1468 // Reset the camera for this window 1469 1469 applyTargetCamera(((GPU_CONTEXT_DATA*)renderer->current_context_target->context->data)->last_target); 1470 1470 } ··· 1475 1475 GPU_RemoveWindowMapping(1); 1476 1476 target->context->windowID = 1; 1477 1477 GPU_AddWindowMapping(target); 1478 1478 - 1478 1478 + 1479 1479 // Update target's window size 1480 1480 screen = SDL_GetVideoSurface(); 1481 1481 if(screen != NULL) ··· 1493 1493 { 1494 1494 if(renderer->current_context_target == NULL) 1495 1495 return; 1496 1496 - 1496 1496 + 1497 1497 renderer->impl->MakeCurrent(renderer, renderer->current_context_target, renderer->current_context_target->context->windowID); 1498 1498 } 1499 1499 ··· 1501 1501 { 1502 1502 GPU_Target* target; 1503 1503 GPU_CONTEXT_DATA* cdata; 1504 1504 - 1504 1504 + 1505 1505 if(renderer->current_context_target == NULL) 1506 1506 return; 1507 1507 - 1507 1507 + 1508 1508 target = renderer->current_context_target; 1509 1509 cdata = (GPU_CONTEXT_DATA*)target->context->data; 1510 1510 - 1511 1511 - 1510 1510 + 1511 1511 + 1512 1512 #ifndef SDL_GPU_DISABLE_SHADERS 1513 1513 if(IsFeatureEnabled(renderer, GPU_FEATURE_BASIC_SHADERS)) 1514 1514 glUseProgram(target->context->current_shader_program); 1515 1515 #endif 1516 1516 - 1516 1516 + 1517 1517 #ifdef SDL_GPU_USE_SDL2 1518 1518 SDL_GL_MakeCurrent(SDL_GetWindowFromID(target->context->windowID), target->context->context); 1519 1519 #endif 1520 1520 - 1521 1521 - 1520 1520 + 1521 1521 + 1522 1522 #ifndef SDL_GPU_USE_BUFFER_PIPELINE 1523 1523 glColor4f(cdata->last_color.r/255.01f, cdata->last_color.g/255.01f, cdata->last_color.b/255.01f, GET_ALPHA(cdata->last_color)/255.01f); 1524 1524 #endif ··· 1528 1528 else 1529 1529 glDisable(GL_TEXTURE_2D); 1530 1530 #endif 1531 1531 - 1531 1531 + 1532 1532 if(cdata->last_use_blending) 1533 1533 glEnable(GL_BLEND); 1534 1534 else 1535 1535 glDisable(GL_BLEND); 1536 1536 - 1536 1536 + 1537 1537 forceChangeBlendMode(renderer, cdata->last_blend_mode); 1538 1538 - 1538 1538 + 1539 1539 forceChangeViewport(target, target->viewport); 1540 1540 - 1540 1540 + 1541 1541 if(cdata->last_image != NULL) 1542 1542 glBindTexture(GL_TEXTURE_2D, ((GPU_IMAGE_DATA*)(cdata->last_image)->data)->handle); 1543 1543 - 1543 1543 + 1544 1544 if(cdata->last_target != NULL) 1545 1545 extBindFramebuffer(renderer, ((GPU_TARGET_DATA*)cdata->last_target->data)->handle); 1546 1546 else ··· 1550 1550 static Uint8 SetWindowResolution(GPU_Renderer* renderer, Uint16 w, Uint16 h) 1551 1551 { 1552 1552 GPU_Target* target = renderer->current_context_target; 1553 1553 - 1553 1553 + 1554 1554 Uint8 isCurrent = isCurrentTarget(renderer, target); 1555 1555 if(isCurrent) 1556 1556 renderer->impl->FlushBlitBuffer(renderer); 1557 1557 - 1557 1557 + 1558 1558 #ifdef SDL_GPU_USE_SDL2 1559 1559 - 1559 1559 + 1560 1560 { 1561 1561 SDL_Window* window = SDL_GetWindowFromID(target->context->windowID); 1562 1562 - 1562 1562 + 1563 1563 // Don't need to resize (only update internals) when resolution isn't changing. 1564 1564 SDL_GetWindowSize(window, &target->context->window_w, &target->context->window_h); 1565 1565 SDL_GL_GetDrawableSize(window, &target->context->drawable_w, &target->context->drawable_h); ··· 1570 1570 SDL_GL_GetDrawableSize(window, &target->context->drawable_w, &target->context->drawable_h); 1571 1571 } 1572 1572 } 1573 1573 - 1573 1573 + 1574 1574 #else 1575 1575 SDL_Surface* screen = SDL_GetVideoSurface(); 1576 1576 Uint32 flags = screen->flags; ··· 1589 1589 1590 1590 target->context->window_w = target->context->drawable_w = screen->w; 1591 1591 target->context->window_h = target->context->drawable_h = screen->h; 1592 1592 - 1592 1592 + 1593 1593 // FIXME: Does the entire GL state need to be reset because the screen was recreated? 1594 1594 - 1594 1594 + 1595 1595 // Reset texturing state 1596 1596 context = renderer->current_context_target->context; 1597 1597 context->use_texturing = 1; 1598 1598 ((GPU_CONTEXT_DATA*)context->data)->last_use_texturing = 0; 1599 1599 - 1599 1599 + 1600 1600 // Clear target (no state change) 1601 1601 glClearColor( 0.0f, 0.0f, 0.0f, 0.0f ); 1602 1602 glClear( GL_COLOR_BUFFER_BIT ); 1603 1603 #endif 1604 1604 - 1604 1604 + 1605 1605 // Store the resolution for fullscreen_desktop changes 1606 1606 target->context->stored_window_w = target->context->window_w; 1607 1607 target->context->stored_window_h = target->context->window_h; 1608 1608 - 1608 1608 + 1609 1609 // Update base dimensions 1610 1610 target->base_w = target->context->drawable_w; 1611 1611 target->base_h = target->context->drawable_h; 1612 1612 - 1612 1612 + 1613 1613 // Resets virtual resolution 1614 1614 target->w = target->base_w; 1615 1615 target->h = target->base_h; ··· 1620 1620 changeViewport(target); 1621 1621 1622 1622 GPU_UnsetClip(target); 1623 1623 - 1623 1623 + 1624 1624 if(isCurrent) 1625 1625 applyTargetCamera(target); 1626 1626 ··· 1633 1633 1634 1634 if(target == NULL) 1635 1635 return; 1636 1636 - 1636 1636 + 1637 1637 isCurrent = isCurrentTarget(renderer, target); 1638 1638 if(isCurrent) 1639 1639 renderer->impl->FlushBlitBuffer(renderer); ··· 1641 1641 target->w = w; 1642 1642 target->h = h; 1643 1643 target->using_virtual_resolution = 1; 1644 1644 - 1644 1644 + 1645 1645 if(isCurrent) 1646 1646 applyTargetCamera(target); 1647 1647 } ··· 1652 1652 1653 1653 if(target == NULL) 1654 1654 return; 1655 1655 - 1655 1655 + 1656 1656 isCurrent = isCurrentTarget(renderer, target); 1657 1657 if(isCurrent) 1658 1658 renderer->impl->FlushBlitBuffer(renderer); 1659 1659 - 1659 1659 + 1660 1660 target->w = target->base_w; 1661 1661 target->h = target->base_h; 1662 1662 - 1662 1662 + 1663 1663 target->using_virtual_resolution = 0; 1664 1664 - 1664 1664 + 1665 1665 if(isCurrent) 1666 1666 applyTargetCamera(target); 1667 1667 } ··· 1677 1677 static Uint8 SetFullscreen(GPU_Renderer* renderer, Uint8 enable_fullscreen, Uint8 use_desktop_resolution) 1678 1678 { 1679 1679 GPU_Target* target = renderer->current_context_target; 1680 1680 - 1680 1680 + 1681 1681 #ifdef SDL_GPU_USE_SDL2 1682 1682 SDL_Window* window = SDL_GetWindowFromID(target->context->windowID); 1683 1683 Uint32 old_flags = SDL_GetWindowFlags(window); 1684 1684 Uint8 was_fullscreen = (old_flags & SDL_WINDOW_FULLSCREEN); 1685 1685 Uint8 is_fullscreen = was_fullscreen; 1686 1686 - 1686 1686 + 1687 1687 Uint32 flags = 0; 1688 1688 1689 1689 if(enable_fullscreen) ··· 1693 1693 else 1694 1694 flags = SDL_WINDOW_FULLSCREEN; 1695 1695 } 1696 1696 - 1696 1696 + 1697 1697 if(SDL_SetWindowFullscreen(window, flags) >= 0) 1698 1698 { 1699 1699 flags = SDL_GetWindowFlags(window); 1700 1700 is_fullscreen = (flags & SDL_WINDOW_FULLSCREEN); 1701 1701 - 1701 1701 + 1702 1702 // If we just went fullscreen, save the original resolution 1703 1703 // We do this because you can't depend on the resolution to be preserved by SDL 1704 1704 // SDL_WINDOW_FULLSCREEN_DESKTOP changes the resolution and SDL_WINDOW_FULLSCREEN can change it when a given mode is not available ··· 1707 1707 target->context->stored_window_w = target->context->window_w; 1708 1708 target->context->stored_window_h = target->context->window_h; 1709 1709 } 1710 1710 - 1710 1710 + 1711 1711 // If we're in windowed mode now and a resolution was stored, restore the original window resolution 1712 1712 if(was_fullscreen && !is_fullscreen && (target->context->stored_window_w != 0 && target->context->stored_window_h != 0)) 1713 1713 SDL_SetWindowSize(window, target->context->stored_window_w, target->context->stored_window_h); 1714 1714 - 1714 1714 + 1715 1715 // Update window dims 1716 1716 SDL_GetWindowSize(window, &target->context->window_w, &target->context->window_h); 1717 1717 SDL_GL_GetDrawableSize(window, &target->context->drawable_w, &target->context->drawable_h); 1718 1718 } 1719 1719 - 1719 1719 + 1720 1720 #else 1721 1721 SDL_Surface* surf = SDL_GetVideoSurface(); 1722 1722 Uint8 was_fullscreen = (surf->flags & SDL_FULLSCREEN); 1723 1723 Uint8 is_fullscreen = was_fullscreen; 1724 1724 - 1724 1724 + 1725 1725 if(was_fullscreen ^ enable_fullscreen) 1726 1726 { 1727 1727 SDL_WM_ToggleFullScreen(surf); 1728 1728 is_fullscreen = (surf->flags & SDL_FULLSCREEN); 1729 1729 - 1729 1729 + 1730 1730 // Update window dims 1731 1731 target->context->window_w = target->context->drawable_w = surf->w; 1732 1732 target->context->window_h = target->context->drawable_h = surf->h; 1733 1733 } 1734 1734 - 1734 1734 + 1735 1735 #endif 1736 1736 1737 1737 if(is_fullscreen != was_fullscreen) ··· 1747 1747 // Reset viewport 1748 1748 target->viewport = GPU_MakeRect(0, 0, target->context->drawable_w, target->context->drawable_h); 1749 1749 changeViewport(target); 1750 1750 - 1750 1750 + 1751 1751 // Reset clip 1752 1752 GPU_UnsetClip(target); 1753 1753 - 1753 1753 + 1754 1754 // Update camera 1755 1755 if(isCurrentTarget(renderer, target)) 1756 1756 applyTargetCamera(target); 1757 1757 } 1758 1758 - 1758 1758 + 1759 1759 target->base_w = target->context->drawable_w; 1760 1760 target->base_h = target->context->drawable_h; 1761 1761 - 1761 1761 + 1762 1762 return is_fullscreen; 1763 1763 } 1764 1764 ··· 1773 1773 GPU_PushErrorCode("GPU_SetCamera", GPU_ERROR_NULL_ARGUMENT, "target"); 1774 1774 return GPU_GetDefaultCamera(); 1775 1775 } 1776 1776 - 1776 1776 + 1777 1777 if(cam == NULL) 1778 1778 new_camera = GPU_GetDefaultCamera(); 1779 1779 else 1780 1780 new_camera = *cam; 1781 1781 - 1781 1781 + 1782 1782 old_camera = target->camera; 1783 1783 - 1783 1783 + 1784 1784 if(!equal_cameras(new_camera, old_camera)) 1785 1785 { 1786 1786 if(isCurrentTarget(renderer, target)) 1787 1787 renderer->impl->FlushBlitBuffer(renderer); 1788 1788 - 1788 1788 + 1789 1789 target->camera = new_camera; 1790 1790 } 1791 1791 ··· 1795 1795 static GLuint CreateUninitializedTexture(GPU_Renderer* renderer) 1796 1796 { 1797 1797 GLuint handle; 1798 1798 - 1798 1798 + 1799 1799 glGenTextures(1, &handle); 1800 1800 if(handle == 0) 1801 1801 return 0; ··· 1812 1812 1813 1813 glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); 1814 1814 #endif 1815 1815 - 1815 1815 + 1816 1816 return handle; 1817 1817 } 1818 1818 ··· 1872 1872 GPU_PushErrorCode("GPU_CreateUninitializedImage", GPU_ERROR_DATA_ERROR, "Unsupported image format (0x%x)", format); 1873 1873 return NULL; 1874 1874 } 1875 1875 - 1875 1875 + 1876 1876 if(bytes_per_pixel < 1 || bytes_per_pixel > 4) 1877 1877 { 1878 1878 GPU_PushErrorCode("GPU_CreateUninitializedImage", GPU_ERROR_DATA_ERROR, "Unsupported number of bytes per pixel (%d)", bytes_per_pixel); 1879 1879 return NULL; 1880 1880 } 1881 1881 - 1881 1881 + 1882 1882 // Create the underlying texture 1883 1883 handle = CreateUninitializedTexture(renderer); 1884 1884 if(handle == 0) ··· 1886 1886 GPU_PushErrorCode("GPU_CreateUninitializedImage", GPU_ERROR_BACKEND_ERROR, "Failed to generate a texture handle."); 1887 1887 return NULL; 1888 1888 } 1889 1889 - 1889 1889 + 1890 1890 // Create the GPU_Image 1891 1891 result = (GPU_Image*)SDL_malloc(sizeof(GPU_Image)); 1892 1892 result->refcount = 1; ··· 1898 1898 result->num_layers = num_layers; 1899 1899 result->bytes_per_pixel = bytes_per_pixel; 1900 1900 result->has_mipmaps = 0; 1901 1901 - 1901 1901 + 1902 1902 result->color = white; 1903 1903 result->use_blending = 1; 1904 1904 result->blend_mode = GPU_GetBlendModeFromPreset(GPU_BLEND_NORMAL); ··· 1906 1906 result->snap_mode = GPU_SNAP_POSITION_AND_DIMENSIONS; 1907 1907 result->wrap_mode_x = GPU_WRAP_NONE; 1908 1908 result->wrap_mode_y = GPU_WRAP_NONE; 1909 1909 - 1909 1909 + 1910 1910 result->data = data; 1911 1911 result->is_alias = 0; 1912 1912 data->handle = handle; ··· 1969 1969 zero_buffer = (unsigned char*)SDL_malloc(zero_buffer_size); 1970 1970 memset(zero_buffer, 0, zero_buffer_size); 1971 1971 } 1972 1972 - 1972 1972 + 1973 1973 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 1974 1974 #ifdef SDL_GPU_USE_OPENGL 1975 1975 glPixelStorei(GL_UNPACK_ROW_LENGTH, w); 1976 1976 #endif 1977 1977 - 1977 1977 + 1978 1978 glTexImage2D(GL_TEXTURE_2D, 0, internal_format, w, h, 0, 1979 1979 internal_format, GL_UNSIGNED_BYTE, zero_buffer); 1980 1980 // Tell SDL_gpu what we got (power-of-two requirements have made this change) 1981 1981 result->texture_w = w; 1982 1982 result->texture_h = h; 1983 1983 - 1983 1983 + 1984 1984 // Restore GL defaults 1985 1985 glPixelStorei(GL_UNPACK_ALIGNMENT, 4); 1986 1986 #ifdef SDL_GPU_USE_OPENGL ··· 1997 1997 GPU_PushErrorCode("GPU_CreateImageUsingTexture", GPU_ERROR_UNSUPPORTED_FUNCTION, "Renderer %s does not support this function", renderer->id.name); 1998 1998 return NULL; 1999 1999 #else 2000 2000 - 2000 2000 + 2001 2001 GLint w, h; 2002 2002 GLuint num_layers, bytes_per_pixel; 2003 2003 GLint gl_format; 2004 2004 GLint wrap_s, wrap_t; 2005 2005 GLint min_filter; 2006 2006 - 2006 2006 + 2007 2007 GPU_FormatEnum format; 2008 2008 GPU_WrapEnum wrap_x, wrap_y; 2009 2009 GPU_FilterEnum filter_mode; 2010 2010 SDL_Color white = { 255, 255, 255, 255 }; 2011 2011 - 2011 2011 + 2012 2012 GPU_Image* result; 2013 2013 GPU_IMAGE_DATA* data; 2014 2014 2015 2015 flushAndBindTexture(renderer, handle); 2016 2016 - 2016 2016 + 2017 2017 glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &gl_format); 2018 2018 2019 2019 switch(gl_format) ··· 2054 2054 GPU_PushErrorCode("GPU_CreateImageUsingTexture", GPU_ERROR_DATA_ERROR, "Unsupported GL image format (0x%x)", gl_format); 2055 2055 return NULL; 2056 2056 } 2057 2057 - 2057 2057 + 2058 2058 glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &w); 2059 2059 glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &h); 2060 2060 - 2061 2061 - 2060 2060 + 2061 2061 + 2062 2062 glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, &min_filter); 2063 2063 // Ignore mag filter... Maybe the wrong thing to do? 2064 2064 - 2064 2064 + 2065 2065 // Let the user use one that we don't support and pretend that we're okay with that. 2066 2066 switch(min_filter) 2067 2067 { ··· 2080 2080 filter_mode = GPU_FILTER_LINEAR; 2081 2081 break; 2082 2082 } 2083 2083 - 2084 2084 - 2083 2083 + 2084 2084 + 2085 2085 glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, &wrap_s); 2086 2086 glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, &wrap_t); 2087 2087 - 2087 2087 + 2088 2088 // Let the user use one that we don't support and pretend that we're okay with that. 2089 2089 switch(wrap_s) 2090 2090 { ··· 2102 2102 wrap_x = GPU_WRAP_NONE; 2103 2103 break; 2104 2104 } 2105 2105 - 2105 2105 + 2106 2106 switch(wrap_t) 2107 2107 { 2108 2108 case GL_CLAMP_TO_EDGE: ··· 2119 2119 wrap_y = GPU_WRAP_NONE; 2120 2120 break; 2121 2121 } 2122 2122 - 2122 2122 + 2123 2123 // Finally create the image 2124 2124 - 2124 2124 + 2125 2125 data = (GPU_IMAGE_DATA*)SDL_malloc(sizeof(GPU_IMAGE_DATA)); 2126 2126 data->refcount = 1; 2127 2127 data->handle = handle; 2128 2128 data->owns_handle = take_ownership; 2129 2129 data->format = gl_format; 2130 2130 - 2130 2130 + 2131 2131 2132 2132 result = (GPU_Image*)SDL_malloc(sizeof(GPU_Image)); 2133 2133 result->refcount = 1; ··· 2137 2137 result->num_layers = num_layers; 2138 2138 result->bytes_per_pixel = bytes_per_pixel; 2139 2139 result->has_mipmaps = 0; 2140 2140 - 2140 2140 + 2141 2141 result->color = white; 2142 2142 result->use_blending = 1; 2143 2143 result->blend_mode = GPU_GetBlendModeFromPreset(GPU_BLEND_NORMAL); ··· 2145 2145 result->filter_mode = filter_mode; 2146 2146 result->wrap_mode_x = wrap_x; 2147 2147 result->wrap_mode_y = wrap_y; 2148 2148 - 2148 2148 + 2149 2149 result->data = data; 2150 2150 result->is_alias = 0; 2151 2151 2152 2152 result->using_virtual_resolution = 0; 2153 2153 result->w = w; 2154 2154 result->h = h; 2155 2155 - 2155 2155 + 2156 2156 result->base_w = w; 2157 2157 result->base_h = h; 2158 2158 result->texture_w = w; ··· 2190 2190 result = (GPU_Image*)SDL_malloc(sizeof(GPU_Image)); 2191 2191 // Copy the members 2192 2192 *result = *image; 2193 2193 - 2193 2193 + 2194 2194 // Alias info 2195 2195 ((GPU_IMAGE_DATA*)image->data)->refcount++; 2196 2196 result->refcount = 1; ··· 2204 2204 { 2205 2205 if(source == NULL) 2206 2206 return 0; 2207 2207 - 2207 2207 + 2208 2208 if(isCurrentTarget(renderer, source)) 2209 2209 renderer->impl->FlushBlitBuffer(renderer); 2210 2210 - 2210 2210 + 2211 2211 if(bindFramebuffer(renderer, source)) 2212 2212 { 2213 2213 glReadPixels(0, 0, source->base_w, source->base_h, format, GL_UNSIGNED_BYTE, pixels); ··· 2225 2225 2226 2226 if(source == NULL) 2227 2227 return 0; 2228 2228 - 2228 2228 + 2229 2229 // No glGetTexImage() in OpenGLES 2230 2230 #ifdef SDL_GPU_USE_GLES 2231 2231 // Load up the target ··· 2265 2265 2266 2266 if(isCurrentTarget(renderer, target)) 2267 2267 renderer->impl->FlushBlitBuffer(renderer); 2268 2268 - 2268 2268 + 2269 2269 bytes_per_pixel = 4; 2270 2270 if(target->image != NULL) 2271 2271 bytes_per_pixel = target->image->bytes_per_pixel; 2272 2272 data = (unsigned char*)SDL_malloc(target->base_w * target->base_h * bytes_per_pixel); 2273 2273 - 2273 2273 + 2274 2274 // This can take regions of pixels, so using base_w and base_h with an image target should be fine. 2275 2275 if(!readTargetPixels(renderer, target, ((GPU_TARGET_DATA*)target->data)->format, data)) 2276 2276 { 2277 2277 SDL_free(data); 2278 2278 return NULL; 2279 2279 } 2280 2280 - 2280 2280 + 2281 2281 // Flip the data vertically (OpenGL framebuffer is read upside down) 2282 2282 pitch = target->base_w * bytes_per_pixel; 2283 2283 copy = (unsigned char*)SDL_malloc(pitch); 2284 2284 - 2284 2284 + 2285 2285 for(y = 0; y < target->base_h/2; y++) 2286 2286 { 2287 2287 unsigned char* top = &data[target->base_w * y * bytes_per_pixel]; ··· 2301 2301 2302 2302 if(image->target != NULL && isCurrentTarget(renderer, image->target)) 2303 2303 renderer->impl->FlushBlitBuffer(renderer); 2304 2304 - 2304 2304 + 2305 2305 data = (unsigned char*)SDL_malloc(image->texture_w * image->texture_h * image->bytes_per_pixel); 2306 2306 - 2306 2306 + 2307 2307 // FIXME: Sometimes the texture is stored and read in RGBA even when I specify RGB. getRawImageData() might need to return the stored format or Bpp. 2308 2308 if(!readImagePixels(renderer, image, ((GPU_IMAGE_DATA*)image->data)->format, data)) 2309 2309 { ··· 2358 2358 return 0; 2359 2359 } 2360 2360 } 2361 2361 - 2361 2361 + 2362 2362 switch(format) 2363 2363 { 2364 2364 case GPU_FILE_PNG: ··· 2404 2404 GPU_PushErrorCode("GPU_CopySurfaceFromTarget", GPU_ERROR_BACKEND_ERROR, "Could not retrieve target data."); 2405 2405 return NULL; 2406 2406 } 2407 2407 - 2407 2407 + 2408 2408 format = AllocFormat(((GPU_TARGET_DATA*)target->data)->format); 2409 2409 - 2410 2410 - result = SDL_CreateRGBSurfaceFrom(data, target->base_w, target->base_h, format->BitsPerPixel, target->base_w*format->BytesPerPixel, format->Rmask, format->Gmask, format->Bmask, format->Amask); 2411 2411 - if(result != NULL) 2412 2412 - result->flags &= ~SDL_PREALLOC; // Make SDL take ownership of the data memory 2413 2413 - 2409 2409 + 2410 2410 + result = SDL_CreateRGBSurface(SDL_SWSURFACE, target->base_w, target->base_h, format->BitsPerPixel, format->Rmask, format->Gmask, format->Bmask, format->Amask); 2411 2411 + 2412 2412 + if(result == NULL) 2413 2413 + { 2414 2414 + GPU_PushErrorCode("GPU_CopySurfaceFromTarget", GPU_ERROR_DATA_ERROR, "Failed to create new %dx%d surface", target->base_w, target->base_h); 2415 2415 + SDL_free(data); 2416 2416 + return NULL; 2417 2417 + } 2418 2418 + 2419 2419 + // Copy row-by-row in case the pitch doesn't match 2420 2420 + { 2421 2421 + int i; 2422 2422 + int source_pitch = target->base_w*format->BytesPerPixel; 2423 2423 + for(i = 0; i < target->base_h; ++i) 2424 2424 + { 2425 2425 + memcpy((Uint8*)result->pixels + i*result->pitch, data + source_pitch*i, source_pitch); 2426 2426 + } 2427 2427 + } 2428 2428 + 2429 2429 + SDL_free(data); 2430 2430 + 2414 2431 FreeFormat(format); 2415 2432 return result; 2416 2433 } ··· 2439 2456 GPU_PushErrorCode("GPU_CopySurfaceFromImage", GPU_ERROR_BACKEND_ERROR, "Could not retrieve target data."); 2440 2457 return NULL; 2441 2458 } 2442 2442 - 2459 2459 + 2443 2460 format = AllocFormat(((GPU_IMAGE_DATA*)image->data)->format); 2444 2444 - 2445 2445 - result = SDL_CreateRGBSurfaceFrom(data, image->texture_w, image->texture_h, format->BitsPerPixel, image->base_w*format->BytesPerPixel, format->Rmask, format->Gmask, format->Bmask, format->Amask); 2446 2446 - if(result != NULL) 2447 2447 - result->flags &= ~SDL_PREALLOC; // Make SDL take ownership of the data memory 2448 2448 - 2461 2461 + 2462 2462 + result = SDL_CreateRGBSurface(SDL_SWSURFACE, image->texture_w, image->texture_h, format->BitsPerPixel, format->Rmask, format->Gmask, format->Bmask, format->Amask); 2463 2463 + 2464 2464 + if(result == NULL) 2465 2465 + { 2466 2466 + GPU_PushErrorCode("GPU_CopySurfaceFromImage", GPU_ERROR_DATA_ERROR, "Failed to create new %dx%d surface", image->texture_w, image->texture_h); 2467 2467 + SDL_free(data); 2468 2468 + return NULL; 2469 2469 + } 2470 2470 + 2471 2471 + // Copy row-by-row in case the pitch doesn't match 2472 2472 + { 2473 2473 + int i; 2474 2474 + int source_pitch = image->texture_w*format->BytesPerPixel; 2475 2475 + for(i = 0; i < image->texture_h; ++i) 2476 2476 + { 2477 2477 + memcpy((Uint8*)result->pixels + i*result->pitch, data + source_pitch*i, source_pitch); 2478 2478 + } 2479 2479 + } 2480 2480 + 2481 2481 + SDL_free(data); 2482 2482 + 2449 2483 FreeFormat(format); 2450 2484 return result; 2451 2485 } ··· 2733 2767 SDL_free(format); 2734 2768 } 2735 2769 2736 2736 - // Returns NULL on failure. Returns the original surface if no copy is needed. Returns a new surface converted to the right format otherwise. 2737 2737 - static SDL_Surface* copySurfaceIfNeeded(GPU_Renderer* renderer, GLenum glFormat, SDL_Surface* surface, GLenum* surfaceFormatResult) 2738 2738 - { 2739 2770 #ifdef SDL_GPU_USE_GLES 2740 2740 - SDL_Surface* newSurface; 2741 2741 - Uint8 *blob; 2742 2742 - SDL_Rect rect; 2743 2743 - int srcPitch; 2771 2771 + // Based on SDL_UpdateTexture() 2772 2772 + static SDL_Surface* pack_surface_if_needed(SDL_Surface* surface) 2773 2773 + { 2774 2774 + SDL_Surface* result; 2775 2775 + int width, height; 2776 2776 + int packed_pitch; 2744 2777 int pitch; 2745 2745 - #endif 2746 2778 2747 2747 - // If format doesn't match, we need to do a copy 2748 2748 - int format_compare = compareFormats(renderer, glFormat, surface, surfaceFormatResult); 2779 2779 + // NULL or already packed? 2780 2780 + if(surface == NULL || surface->pitch == surface->w * surface->format->BytesPerPixel) 2781 2781 + return surface; 2749 2782 2750 2750 - // There's a problem 2751 2751 - if(format_compare < 0) 2752 2752 - return NULL; 2753 2753 - 2754 2754 - #ifdef SDL_GPU_USE_GLES 2755 2755 - // GLES needs a tightly-packed pixel array 2756 2756 - // Based on SDL_UpdateTexture() 2757 2757 - newSurface = NULL; 2758 2758 - blob = NULL; 2759 2759 - rect.x = 0; 2760 2760 - rect.y = 0; 2761 2761 - rect.w = surface->w; 2762 2762 - rect.h = surface->h; 2763 2763 - srcPitch = rect.w * surface->format->BytesPerPixel; 2783 2783 + width = surface->w; 2784 2784 + height = surface->h; 2785 2785 + packed_pitch = width * surface->format->BytesPerPixel; 2764 2786 pitch = surface->pitch; 2765 2765 - if(srcPitch != pitch) 2787 2787 + 2788 2788 + // Bail out if we're supposed to update an empty rectangle 2789 2789 + if(width <= 0 || height <= 0) 2790 2790 + return NULL; 2791 2791 + 2792 2792 + // Reformat the data into a tightly packed array 2793 2793 + result = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, surface->format->BytesPerPixel, surface->format->Rmask, surface->format->Gmask, surface->format->Bmask, surface->format->Amask); 2794 2794 + 2795 2795 + if(result == NULL) 2766 2796 { 2767 2767 - Uint8 *src; 2768 2768 - Uint8 *pixels = (Uint8*)surface->pixels; 2769 2769 - int y; 2770 2770 - 2771 2771 - /* Bail out if we're supposed to update an empty rectangle */ 2772 2772 - if(rect.w <= 0 || rect.h <= 0) 2773 2773 - return NULL; 2774 2774 - 2775 2775 - /* Reformat the texture data into a tightly packed array */ 2776 2776 - src = pixels; 2777 2777 - if(pitch != srcPitch) 2778 2778 - { 2779 2779 - blob = (Uint8*)SDL_malloc(srcPitch * rect.h); 2780 2780 - if(blob == NULL) 2781 2781 - { 2782 2782 - // Out of memory 2783 2783 - return NULL; 2784 2784 - } 2785 2785 - src = blob; 2786 2786 - for(y = 0; y < rect.h; ++y) 2787 2787 - { 2788 2788 - memcpy(src, pixels, srcPitch); 2789 2789 - src += srcPitch; 2790 2790 - pixels += pitch; 2791 2791 - } 2792 2792 - src = blob; 2793 2793 - } 2794 2794 - 2795 2795 - newSurface = SDL_CreateRGBSurfaceFrom(src, rect.w, rect.h, surface->format->BytesPerPixel, srcPitch, surface->format->Rmask, surface->format->Gmask, surface->format->Bmask, surface->format->Amask); 2796 2796 - if(newSurface != NULL) 2797 2797 - newSurface->flags &= ~SDL_PREALLOC; // Make SDL take ownership of the src memory 2797 2797 + GPU_PushErrorCode(__func__, GPU_ERROR_DATA_ERROR, "Failed to create new %dx%d surface", width, height); 2798 2798 + return NULL; 2798 2799 } 2799 2799 - 2800 2800 - // Copy it to a different format 2801 2801 - if(format_compare > 0) 2800 2800 + 2801 2801 + // Force a new pitch in spite of SDL's alignment calculations 2802 2802 + result->pitch = packed_pitch; 2803 2803 + 2804 2804 + // Copy to the new surface 2802 2805 { 2803 2803 - // Convert to the right format 2804 2804 - SDL_PixelFormat* dst_fmt = AllocFormat(glFormat); 2805 2805 - if(newSurface != NULL) 2806 2806 + int i; 2807 2807 + for(i = 0; i < width; ++i) 2806 2808 { 2807 2807 - surface = SDL_ConvertSurface(newSurface, dst_fmt, 0); 2808 2808 - SDL_FreeSurface(newSurface); 2809 2809 - SDL_free(blob); 2809 2809 + memcpy((Uint8*)result->pixels + i*packed_pitch, surface->pixels + surface->pitch*i, packed_pitch); 2810 2810 } 2811 2811 - else 2812 2812 - surface = SDL_ConvertSurface(surface, dst_fmt, 0); 2813 2813 - FreeFormat(dst_fmt); 2814 2814 - if(surfaceFormatResult != NULL && surface != NULL) 2815 2815 - *surfaceFormatResult = glFormat; 2816 2811 } 2817 2817 - 2818 2818 - #else 2812 2812 + 2813 2813 + return result; 2814 2814 + } 2815 2815 + #endif 2816 2816 + 2817 2817 + // Returns NULL on failure. Returns the original surface if no copy is needed. Returns a new surface converted to the right format otherwise. 2818 2818 + static SDL_Surface* copySurfaceIfNeeded(GPU_Renderer* renderer, GLenum glFormat, SDL_Surface* surface, GLenum* surfaceFormatResult) 2819 2819 + { 2820 2820 + SDL_Surface* original = surface; 2821 2821 + 2822 2822 + // If format doesn't match, we need to do a copy 2823 2823 + int format_compare = compareFormats(renderer, glFormat, surface, surfaceFormatResult); 2824 2824 + 2825 2825 + // There's a problem, logged in compareFormats() 2826 2826 + if(format_compare < 0) 2827 2827 + return NULL; 2828 2828 + 2829 2829 + 2819 2830 // Copy it to a different format 2820 2831 if(format_compare > 0) 2821 2832 { ··· 2826 2837 if(surfaceFormatResult != NULL && surface != NULL) 2827 2838 *surfaceFormatResult = glFormat; 2828 2839 } 2840 2840 + 2841 2841 + #ifdef SDL_GPU_USE_GLES 2842 2842 + // GLES needs a tightly-packed pixel array 2843 2843 + { 2844 2844 + SDL_Surface* intermediate_surface = surface; 2845 2845 + surface = pack_surface_if_needed(intermediate_surface); 2846 2846 + 2847 2847 + // Delete the intermediate surface since it won't be used. 2848 2848 + if(intermediate_surface != surface && intermediate_surface != original) 2849 2849 + SDL_FreeSurface(intermediate_surface); 2850 2850 + } 2829 2851 #endif 2830 2852 2831 2853 // No copy needed ··· 2838 2860 2839 2861 if(image == NULL) 2840 2862 return NULL; 2841 2841 - 2863 2863 + 2842 2864 switch(image->format) 2843 2865 { 2844 2866 case GPU_FORMAT_RGB: ··· 2846 2868 // Copy via framebuffer blitting (fast) 2847 2869 { 2848 2870 GPU_Target* target; 2849 2849 - 2871 2871 + 2850 2872 result = renderer->impl->CreateImage(renderer, image->texture_w, image->texture_h, image->format); 2851 2873 if(result == NULL) 2852 2874 { 2853 2875 GPU_PushErrorCode("GPU_CopyImage", GPU_ERROR_BACKEND_ERROR, "Failed to create new image."); 2854 2876 return NULL; 2855 2877 } 2856 2856 - 2878 2878 + 2857 2879 target = GPU_LoadTarget(result); 2858 2880 if(target == NULL) 2859 2881 { ··· 2861 2883 GPU_PushErrorCode("GPU_CopyImage", GPU_ERROR_BACKEND_ERROR, "Failed to load target."); 2862 2884 return NULL; 2863 2885 } 2864 2864 - 2886 2886 + 2865 2887 // For some reason, I wasn't able to get glCopyTexImage2D() or glCopyTexSubImage2D() working without getting GL_INVALID_ENUM (0x500). 2866 2888 // It seemed to only work for the default framebuffer... 2867 2867 - 2889 2889 + 2868 2890 { 2869 2891 // Clear the color, blending, and filter mode 2870 2892 SDL_Color color = image->color; ··· 2893 2915 GPU_SetImageVirtualResolution(image, w, h); 2894 2916 } 2895 2917 } 2896 2896 - 2918 2918 + 2897 2919 // Don't free the target yet (a waste of perf), but let it be freed next time... 2898 2920 target->refcount--; 2899 2921 } ··· 2913 2935 GPU_PushErrorCode("GPU_CopyImage", GPU_ERROR_BACKEND_ERROR, "Failed to get raw texture data."); 2914 2936 return NULL; 2915 2937 } 2916 2916 - 2938 2938 + 2917 2939 result = CreateUninitializedImage(renderer, image->texture_w, image->texture_h, image->format); 2918 2940 if(result == NULL) 2919 2941 { ··· 2921 2943 GPU_PushErrorCode("GPU_CopyImage", GPU_ERROR_BACKEND_ERROR, "Failed to create new image."); 2922 2944 return NULL; 2923 2945 } 2924 2924 - 2946 2946 + 2925 2947 changeTexturing(renderer, 1); 2926 2948 bindTexture(renderer, result); 2927 2949 ··· 2935 2957 if(!isPowerOfTwo(h)) 2936 2958 h = getNearestPowerOf2(h); 2937 2959 } 2938 2938 - 2960 2960 + 2939 2961 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 2940 2962 #ifdef SDL_GPU_USE_OPENGL 2941 2963 glPixelStorei(GL_UNPACK_ROW_LENGTH, w); 2942 2964 #endif 2943 2943 - 2965 2965 + 2944 2966 glTexImage2D(GL_TEXTURE_2D, 0, internal_format, w, h, 0, 2945 2967 internal_format, GL_UNSIGNED_BYTE, texture_data); 2946 2968 // Tell SDL_gpu what we got. 2947 2969 result->texture_w = w; 2948 2970 result->texture_h = h; 2949 2949 - 2971 2971 + 2950 2972 // Restore GL defaults 2951 2973 glPixelStorei(GL_UNPACK_ALIGNMENT, 4); 2952 2974 #ifdef SDL_GPU_USE_OPENGL 2953 2975 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); 2954 2976 #endif 2955 2955 - 2977 2977 + 2956 2978 SDL_free(texture_data); 2957 2979 } 2958 2980 break; ··· 2960 2982 GPU_PushErrorCode("GPU_CopyImage", GPU_ERROR_BACKEND_ERROR, "Could not copy the given image format."); 2961 2983 break; 2962 2984 } 2963 2963 - 2985 2985 + 2964 2986 if(result != NULL) 2965 2987 { 2966 2988 // Copy the image settings ··· 2975 2997 if(image->using_virtual_resolution) 2976 2998 GPU_SetImageVirtualResolution(result, image->w, image->h); 2977 2999 } 2978 2978 - 3000 3000 + 2979 3001 return result; 2980 3002 } 2981 3003 ··· 3022 3044 updateRect.w += image->base_w - (updateRect.x + updateRect.w); 3023 3045 if(updateRect.y + updateRect.h > image->base_h) 3024 3046 updateRect.h += image->base_h - (updateRect.y + updateRect.h); 3025 3025 - 3047 3047 + 3026 3048 if(updateRect.w <= 0) 3027 3049 updateRect.w = 0; 3028 3050 if(updateRect.h <= 0) ··· 3040 3062 return; 3041 3063 } 3042 3064 } 3043 3043 - 3065 3065 + 3044 3066 if(surface_rect != NULL) 3045 3067 { 3046 3068 sourceRect = *surface_rect; ··· 3058 3080 sourceRect.w += newSurface->w - (sourceRect.x + sourceRect.w); 3059 3081 if(sourceRect.y + sourceRect.h > newSurface->h) 3060 3082 sourceRect.h += newSurface->h - (sourceRect.y + sourceRect.h); 3061 3061 - 3083 3083 + 3062 3084 if(sourceRect.w <= 0) 3063 3085 sourceRect.w = 0; 3064 3086 if(sourceRect.h <= 0) ··· 3084 3106 #ifdef SDL_GPU_USE_OPENGL 3085 3107 glPixelStorei(GL_UNPACK_ROW_LENGTH, (newSurface->pitch / newSurface->format->BytesPerPixel)); 3086 3108 #endif 3087 3087 - 3109 3109 + 3088 3110 // Use the smaller of the image and surface rect dimensions 3089 3111 if(sourceRect.w < updateRect.w) 3090 3112 updateRect.w = sourceRect.w; 3091 3113 if(sourceRect.h < updateRect.h) 3092 3114 updateRect.h = sourceRect.h; 3093 3093 - 3115 3115 + 3094 3116 pixels = (Uint8*)newSurface->pixels; 3095 3117 // Shift the pixels pointer to the proper source position 3096 3118 pixels += (int)(newSurface->pitch * sourceRect.y + (newSurface->format->BytesPerPixel)*sourceRect.x); 3097 3097 - 3119 3119 + 3098 3120 glTexSubImage2D(GL_TEXTURE_2D, 0, 3099 3121 updateRect.x, updateRect.y, updateRect.w, updateRect.h, 3100 3122 original_format, GL_UNSIGNED_BYTE, pixels); ··· 3102 3124 // Delete temporary surface 3103 3125 if(surface != newSurface) 3104 3126 SDL_FreeSurface(newSurface); 3105 3105 - 3127 3127 + 3106 3128 // Restore GL defaults 3107 3129 glPixelStorei(GL_UNPACK_ALIGNMENT, 4); 3108 3130 #ifdef SDL_GPU_USE_OPENGL ··· 3142 3164 updateRect.w += image->base_w - (updateRect.x + updateRect.w); 3143 3165 if(updateRect.y + updateRect.h > image->base_h) 3144 3166 updateRect.h += image->base_h - (updateRect.y + updateRect.h); 3145 3145 - 3167 3167 + 3146 3168 if(updateRect.w <= 0) 3147 3169 updateRect.w = 0; 3148 3170 if(updateRect.h <= 0) ··· 3173 3195 #ifdef SDL_GPU_USE_OPENGL 3174 3196 glPixelStorei(GL_UNPACK_ROW_LENGTH, (bytes_per_row / image->bytes_per_pixel)); 3175 3197 #endif 3176 3176 - 3198 3198 + 3177 3199 glTexSubImage2D(GL_TEXTURE_2D, 0, 3178 3200 updateRect.x, updateRect.y, updateRect.w, updateRect.h, 3179 3201 original_format, GL_UNSIGNED_BYTE, bytes); 3180 3180 - 3202 3202 + 3181 3203 // Restore GL defaults 3182 3204 glPixelStorei(GL_UNPACK_ALIGNMENT, 4); 3183 3205 #ifdef SDL_GPU_USE_OPENGL ··· 3202 3224 GPU_PushErrorCode("GPU_ReplaceImage", GPU_ERROR_NULL_ARGUMENT, "image"); 3203 3225 return 0; 3204 3226 } 3205 3205 - 3227 3227 + 3206 3228 if(surface == NULL) 3207 3229 { 3208 3230 GPU_PushErrorCode("GPU_ReplaceImage", GPU_ERROR_NULL_ARGUMENT, "surface"); 3209 3231 return 0; 3210 3232 } 3211 3211 - 3233 3233 + 3212 3234 data = (GPU_IMAGE_DATA*)image->data; 3213 3235 internal_format = data->format; 3214 3236 ··· 3218 3240 GPU_PushErrorCode("GPU_ReplaceImage", GPU_ERROR_BACKEND_ERROR, "Failed to convert surface to proper pixel format."); 3219 3241 return 0; 3220 3242 } 3221 3221 - 3243 3243 + 3222 3244 // Free the attached framebuffer 3223 3245 if((renderer->enabled_features & GPU_FEATURE_RENDER_TARGETS) && image->target != NULL) 3224 3246 { ··· 3229 3251 glDeleteFramebuffers(1, &tdata->handle); 3230 3252 tdata->handle = 0; 3231 3253 } 3232 3232 - 3254 3254 + 3233 3255 // Free the old texture 3234 3256 if(data->owns_handle) 3235 3257 glDeleteTextures( 1, &data->handle); 3236 3258 data->handle = 0; 3237 3237 - 3259 3259 + 3238 3260 // Get the area of the surface we'll use 3239 3261 if(surface_rect == NULL) 3240 3262 { ··· 3245 3267 } 3246 3268 else 3247 3269 sourceRect = *surface_rect; 3248 3248 - 3270 3270 + 3249 3271 // Clip the source rect to the surface 3250 3272 if(sourceRect.x < 0) 3251 3273 { ··· 3261 3283 sourceRect.x = surface->w - 1; 3262 3284 if(sourceRect.y >= surface->h) 3263 3285 sourceRect.y = surface->h - 1; 3264 3264 - 3286 3286 + 3265 3287 if(sourceRect.x + sourceRect.w > surface->w) 3266 3288 sourceRect.w = surface->w - sourceRect.x; 3267 3289 if(sourceRect.y + sourceRect.h > surface->h) 3268 3290 sourceRect.h = surface->h - sourceRect.y; 3269 3269 - 3291 3291 + 3270 3292 if(sourceRect.w <= 0 || sourceRect.h <= 0) 3271 3293 { 3272 3294 GPU_PushErrorCode("GPU_ReplaceImage", GPU_ERROR_DATA_ERROR, "Clipped source rect has zero size."); 3273 3295 return 0; 3274 3296 } 3275 3275 - 3297 3297 + 3276 3298 // Allocate new texture 3277 3299 data->handle = CreateUninitializedTexture(renderer); 3278 3300 data->owns_handle = 1; ··· 3281 3303 GPU_PushErrorCode("GPU_ReplaceImage", GPU_ERROR_BACKEND_ERROR, "Failed to create a new texture handle."); 3282 3304 return 0; 3283 3305 } 3284 3284 - 3306 3306 + 3285 3307 // Update image members 3286 3308 w = sourceRect.w; 3287 3309 h = sourceRect.h; 3288 3288 - 3310 3310 + 3289 3311 if(!image->using_virtual_resolution) 3290 3312 { 3291 3313 image->w = w; ··· 3293 3315 } 3294 3316 image->base_w = w; 3295 3317 image->base_h = h; 3296 3296 - 3318 3318 + 3297 3319 if(!(renderer->enabled_features & GPU_FEATURE_NON_POWER_OF_TWO)) 3298 3320 { 3299 3321 if(!isPowerOfTwo(w)) ··· 3303 3325 } 3304 3326 image->texture_w = w; 3305 3327 image->texture_h = h; 3306 3306 - 3328 3328 + 3307 3329 image->has_mipmaps = 0; 3308 3308 - 3309 3309 - 3330 3330 + 3331 3331 + 3310 3332 // Upload surface pixel data 3311 3333 alignment = 8; 3312 3334 while(newSurface->pitch % alignment) ··· 3315 3337 #ifdef SDL_GPU_USE_OPENGL 3316 3338 glPixelStorei(GL_UNPACK_ROW_LENGTH, (newSurface->pitch / newSurface->format->BytesPerPixel)); 3317 3339 #endif 3318 3318 - 3340 3340 + 3319 3341 pixels = (Uint8*)newSurface->pixels; 3320 3342 // Shift the pixels pointer to the proper source position 3321 3343 pixels += (int)(newSurface->pitch * sourceRect.y + (newSurface->format->BytesPerPixel)*sourceRect.x); 3322 3322 - 3344 3344 + 3323 3345 glTexImage2D(GL_TEXTURE_2D, 0, internal_format, w, h, 0, 3324 3346 internal_format, GL_UNSIGNED_BYTE, pixels); 3325 3347 3326 3348 // Delete temporary surface 3327 3349 if(surface != newSurface) 3328 3350 SDL_FreeSurface(newSurface); 3329 3329 - 3351 3351 + 3330 3352 // Restore GL defaults 3331 3353 glPixelStorei(GL_UNPACK_ALIGNMENT, 4); 3332 3354 #ifdef SDL_GPU_USE_OPENGL 3333 3355 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); 3334 3356 #endif 3335 3335 - 3336 3336 - 3337 3337 - 3357 3357 + 3358 3358 + 3359 3359 + 3338 3360 // Update target members 3339 3361 if((renderer->enabled_features & GPU_FEATURE_RENDER_TARGETS) && image->target != NULL) 3340 3362 { 3341 3363 GLenum status; 3342 3364 GPU_Target* target = image->target; 3343 3365 GPU_TARGET_DATA* tdata = (GPU_TARGET_DATA*)target->data; 3344 3344 - 3366 3366 + 3345 3367 // Create framebuffer object 3346 3368 glGenFramebuffers(1, &tdata->handle); 3347 3369 if(tdata->handle == 0) ··· 3349 3371 GPU_PushErrorCode("GPU_ReplaceImage", GPU_ERROR_BACKEND_ERROR, "Failed to create new framebuffer target."); 3350 3372 return 0; 3351 3373 } 3352 3352 - 3374 3374 + 3353 3375 flushAndBindFramebuffer(renderer, tdata->handle); 3354 3376 3355 3377 // Attach the texture to it ··· 3361 3383 GPU_PushErrorCode("GPU_ReplaceImage", GPU_ERROR_BACKEND_ERROR, "Failed to recreate framebuffer target."); 3362 3384 return 0; 3363 3385 } 3364 3364 - 3386 3386 + 3365 3387 if(!target->using_virtual_resolution) 3366 3388 { 3367 3389 target->w = image->base_w; ··· 3369 3391 } 3370 3392 target->base_w = image->texture_w; 3371 3393 target->base_h = image->texture_h; 3372 3372 - 3394 3394 + 3373 3395 // Reset viewport? 3374 3396 target->viewport = GPU_MakeRect(0, 0, target->w, target->h); 3375 3397 } ··· 3442 3464 } 3443 3465 else 3444 3466 format = GPU_FORMAT_RGBA; 3445 3445 - 3467 3467 + 3446 3468 image = renderer->impl->CreateImage(renderer, surface->w, surface->h, format); 3447 3469 if(image == NULL) 3448 3470 return NULL; ··· 3460 3482 3461 3483 if(target == NULL) 3462 3484 return NULL; 3463 3463 - 3485 3485 + 3464 3486 surface = renderer->impl->CopySurfaceFromTarget(renderer, target); 3465 3487 image = renderer->impl->CopyImageFromSurface(renderer, surface); 3466 3488 SDL_FreeSurface(surface); 3467 3467 - 3489 3489 + 3468 3490 return image; 3469 3491 } 3470 3492 ··· 3475 3497 3476 3498 if(image == NULL) 3477 3499 return; 3478 3478 - 3500 3500 + 3479 3501 if(image->refcount > 1) 3480 3502 { 3481 3503 image->refcount--; ··· 3491 3513 } 3492 3514 3493 3515 flushAndClearBlitBufferIfCurrentTexture(renderer, image); 3494 3494 - 3516 3516 + 3495 3517 // Does the renderer data need to be freed too? 3496 3518 data = (GPU_IMAGE_DATA*)image->data; 3497 3519 if(data->refcount > 1) ··· 3504 3526 glDeleteTextures( 1, &data->handle); 3505 3527 SDL_free(data); 3506 3528 } 3507 3507 - 3529 3529 + 3508 3530 SDL_free(image); 3509 3531 } 3510 3532 ··· 3549 3571 result->data = data; 3550 3572 data->handle = handle; 3551 3573 data->format = ((GPU_IMAGE_DATA*)image->data)->format; 3552 3552 - 3574 3574 + 3553 3575 result->renderer = renderer; 3554 3576 result->context = NULL; 3555 3577 result->image = image; ··· 3558 3580 result->base_w = image->texture_w; 3559 3581 result->base_h = image->texture_h; 3560 3582 result->using_virtual_resolution = image->using_virtual_resolution; 3561 3561 - 3583 3583 + 3562 3584 result->viewport = GPU_MakeRect(0, 0, result->w, result->h); 3563 3563 - 3585 3585 + 3564 3586 result->camera = GPU_GetDefaultCamera(); 3565 3565 - 3587 3587 + 3566 3588 result->use_clip_rect = 0; 3567 3589 result->clip_rect.x = 0; 3568 3590 result->clip_rect.y = 0; ··· 3582 3604 3583 3605 if(target == NULL) 3584 3606 return; 3585 3585 - 3607 3607 + 3586 3608 if(target->refcount > 1) 3587 3609 { 3588 3610 target->refcount--; 3589 3611 return; 3590 3612 } 3591 3591 - 3613 3613 + 3592 3614 if(target->context != NULL && target->context->failed) 3593 3615 { 3594 3616 GPU_CONTEXT_DATA* cdata = (GPU_CONTEXT_DATA*)target->context->data; 3595 3595 - 3617 3617 + 3596 3618 if(target == renderer->current_context_target) 3597 3619 renderer->current_context_target = NULL; 3598 3598 - 3620 3620 + 3599 3621 SDL_free(cdata->blit_buffer); 3600 3622 SDL_free(cdata->index_buffer); 3601 3601 - 3623 3623 + 3602 3624 #ifdef SDL_GPU_USE_SDL2 3603 3625 if(target->context->context != 0) 3604 3626 SDL_GL_DeleteContext(target->context->context); 3605 3627 #endif 3606 3606 - 3628 3628 + 3607 3629 // Remove all of the window mappings that refer to this target 3608 3630 GPU_RemoveWindowMappingByTarget(target); 3609 3609 - 3631 3631 + 3610 3632 SDL_free(target->context->data); 3611 3633 SDL_free(target->context); 3612 3612 - 3634 3634 + 3613 3635 // Does the renderer data need to be freed too? 3614 3636 data = ((GPU_TARGET_DATA*)target->data); 3615 3615 - 3637 3637 + 3616 3638 SDL_free(data); 3617 3639 SDL_free(target); 3618 3618 - 3640 3640 + 3619 3641 return; 3620 3642 } 3621 3621 - 3643 3643 + 3622 3644 if(target == renderer->current_context_target) 3623 3645 { 3624 3646 renderer->impl->FlushBlitBuffer(renderer); 3625 3647 renderer->current_context_target = NULL; 3626 3648 } 3627 3627 - 3649 3649 + 3628 3650 if(!target->is_alias && target->image != NULL) 3629 3651 target->image->target = NULL; // Remove reference to this object 3630 3630 - 3652 3652 + 3631 3653 3632 3654 // Does the renderer data need to be freed too? 3633 3655 data = ((GPU_TARGET_DATA*)target->data); ··· 3637 3659 SDL_free(target); 3638 3660 return; 3639 3661 } 3640 3640 - 3662 3662 + 3641 3663 if(renderer->enabled_features & GPU_FEATURE_RENDER_TARGETS) 3642 3664 { 3643 3665 if(renderer->current_context_target != NULL) ··· 3645 3667 if(data->handle != 0) 3646 3668 glDeleteFramebuffers(1, &data->handle); 3647 3669 } 3648 3648 - 3670 3670 + 3649 3671 if(target->context != NULL) 3650 3672 { 3651 3673 GPU_CONTEXT_DATA* cdata = (GPU_CONTEXT_DATA*)target->context->data; 3652 3652 - 3674 3674 + 3653 3675 SDL_free(cdata->blit_buffer); 3654 3676 SDL_free(cdata->index_buffer); 3655 3655 - 3677 3677 + 3656 3678 #ifdef SDL_GPU_USE_BUFFER_PIPELINE 3657 3679 glDeleteBuffers(2, cdata->blit_VBO); 3658 3680 glDeleteBuffers(1, &cdata->blit_IBO); ··· 3661 3683 glDeleteVertexArrays(1, &cdata->blit_VAO); 3662 3684 #endif 3663 3685 #endif 3664 3664 - 3686 3686 + 3665 3687 #ifdef SDL_GPU_USE_SDL2 3666 3688 if(target->context->context != 0) 3667 3689 SDL_GL_DeleteContext(target->context->context); 3668 3690 #endif 3669 3669 - 3691 3691 + 3670 3692 // Remove all of the window mappings that refer to this target 3671 3693 GPU_RemoveWindowMappingByTarget(target); 3672 3672 - 3694 3694 + 3673 3695 SDL_free(target->context->data); 3674 3696 SDL_free(target->context); 3675 3697 target->context = NULL; 3676 3698 } 3677 3677 - 3699 3699 + 3678 3700 SDL_free(data); 3679 3701 SDL_free(target); 3680 3702 } ··· 3709 3731 vert_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX; \ 3710 3732 tex_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX; \ 3711 3733 color_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX; 3712 3712 - 3734 3734 + 3713 3735 #define SET_UNTEXTURED_VERTEX(x, y, r, g, b, a) \ 3714 3736 blit_buffer[vert_index] = x; \ 3715 3737 blit_buffer[vert_index+1] = y; \ ··· 3720 3742 index_buffer[cdata->index_buffer_num_vertices++] = cdata->blit_buffer_num_vertices++; \ 3721 3743 vert_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX; \ 3722 3744 color_index += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX; 3723 3723 - 3745 3745 + 3724 3746 #define SET_UNTEXTURED_VERTEX_UNINDEXED(x, y, r, g, b, a) \ 3725 3747 blit_buffer[vert_index] = x; \ 3726 3748 blit_buffer[vert_index+1] = y; \ ··· 3736 3758 3737 3759 #define SET_RELATIVE_INDEXED_VERTEX(offset) \ 3738 3760 index_buffer[cdata->index_buffer_num_vertices++] = cdata->blit_buffer_num_vertices + (offset); 3739 3739 - 3761 3761 + 3740 3762 3741 3763 3742 3764 #define BEGIN_UNTEXTURED_SEGMENTS(x1, y1, x2, y2, r, g, b, a) \ ··· 3798 3820 GPU_PushErrorCode("GPU_Blit", GPU_ERROR_USER_ERROR, "Mismatched renderer"); 3799 3821 return; 3800 3822 } 3801 3801 - 3823 3823 + 3802 3824 makeContextCurrent(renderer, target); 3803 3825 if(renderer->current_context_target == NULL) 3804 3826 { 3805 3827 GPU_PushErrorCode("GPU_Blit", GPU_ERROR_USER_ERROR, "NULL context"); 3806 3828 return; 3807 3829 } 3808 3808 - 3830 3830 + 3809 3831 prepareToRenderToTarget(renderer, target); 3810 3832 prepareToRenderImage(renderer, target, image); 3811 3833 ··· 3818 3840 GPU_PushErrorCode("GPU_Blit", GPU_ERROR_BACKEND_ERROR, "Failed to bind framebuffer."); 3819 3841 return; 3820 3842 } 3821 3821 - 3843 3843 + 3822 3844 tex_w = image->texture_w; 3823 3845 tex_h = image->texture_h; 3824 3824 - 3846 3846 + 3825 3847 if(image->snap_mode == GPU_SNAP_POSITION || image->snap_mode == GPU_SNAP_POSITION_AND_DIMENSIONS) 3826 3848 { 3827 3849 // Avoid rounding errors in texture sampling by insisting on integral pixel positions 3828 3850 x = floorf(x); 3829 3851 y = floorf(y); 3830 3852 } 3831 3831 - 3853 3853 + 3832 3854 if(src_rect == NULL) 3833 3855 { 3834 3856 // Scale tex coords according to actual texture dims ··· 3849 3871 w = src_rect->w; 3850 3872 h = src_rect->h; 3851 3873 } 3852 3852 - 3874 3874 + 3853 3875 if(image->using_virtual_resolution) 3854 3876 { 3855 3877 // Scale texture coords to fit the original dims ··· 3858 3880 x2 *= image->base_w/(float)image->w; 3859 3881 y2 *= image->base_h/(float)image->h; 3860 3882 } 3861 3861 - 3883 3883 + 3862 3884 // Center the image on the given coords 3863 3885 dx1 = x - w/2.0f; 3864 3886 dy1 = y - h/2.0f; 3865 3887 dx2 = x + w/2.0f; 3866 3888 dy2 = y + h/2.0f; 3867 3867 - 3889 3889 + 3868 3890 if(image->snap_mode == GPU_SNAP_DIMENSIONS || image->snap_mode == GPU_SNAP_POSITION_AND_DIMENSIONS) 3869 3891 { 3870 3892 float fractional; ··· 3875 3897 dy1 += fractional; 3876 3898 dy2 += fractional; 3877 3899 } 3878 3878 - 3900 3900 + 3879 3901 if(renderer->coordinate_mode == 1) 3880 3902 { 3881 3903 float temp = dy1; ··· 3895 3917 if(!growIndexBuffer(cdata, cdata->index_buffer_num_vertices + 6)) 3896 3918 renderer->impl->FlushBlitBuffer(renderer); 3897 3919 } 3898 3898 - 3920 3920 + 3899 3921 blit_buffer = cdata->blit_buffer; 3900 3922 index_buffer = cdata->index_buffer; 3901 3923 3902 3924 blit_buffer_starting_index = cdata->blit_buffer_num_vertices; 3903 3903 - 3925 3925 + 3904 3926 vert_index = GPU_BLIT_BUFFER_VERTEX_OFFSET + cdata->blit_buffer_num_vertices*GPU_BLIT_BUFFER_FLOATS_PER_VERTEX; 3905 3927 tex_index = GPU_BLIT_BUFFER_TEX_COORD_OFFSET + cdata->blit_buffer_num_vertices*GPU_BLIT_BUFFER_FLOATS_PER_VERTEX; 3906 3928 color_index = GPU_BLIT_BUFFER_COLOR_OFFSET + cdata->blit_buffer_num_vertices*GPU_BLIT_BUFFER_FLOATS_PER_VERTEX; ··· 3918 3940 b = image->color.b/255.0f; 3919 3941 a = GET_ALPHA(image->color)/255.0f; 3920 3942 } 3921 3921 - 3943 3943 + 3922 3944 // 4 Quad vertices 3923 3945 SET_TEXTURED_VERTEX_UNINDEXED(dx1, dy1, x1, y1, r, g, b, a); 3924 3946 SET_TEXTURED_VERTEX_UNINDEXED(dx2, dy1, x2, y1, r, g, b, a); ··· 3951 3973 GPU_PushErrorCode("GPU_BlitRotate", GPU_ERROR_NULL_ARGUMENT, "target"); 3952 3974 return; 3953 3975 } 3954 3954 - 3976 3976 + 3955 3977 w = (src_rect == NULL? image->w : src_rect->w); 3956 3978 h = (src_rect == NULL? image->h : src_rect->h); 3957 3979 renderer->impl->BlitTransformX(renderer, image, src_rect, target, x, y, w/2.0f, h/2.0f, degrees, 1.0f, 1.0f); ··· 4028 4050 4029 4051 4030 4052 makeContextCurrent(renderer, target); 4031 4031 - 4053 4053 + 4032 4054 prepareToRenderToTarget(renderer, target); 4033 4055 prepareToRenderImage(renderer, target, image); 4034 4034 - 4056 4056 + 4035 4057 // Bind the texture to which subsequent calls refer 4036 4058 bindTexture(renderer, image); 4037 4059 ··· 4041 4063 GPU_PushErrorCode("GPU_BlitTransformX", GPU_ERROR_BACKEND_ERROR, "Failed to bind framebuffer."); 4042 4064 return; 4043 4065 } 4044 4044 - 4066 4066 + 4045 4067 tex_w = image->texture_w; 4046 4068 tex_h = image->texture_h; 4047 4047 - 4069 4069 + 4048 4070 if(image->snap_mode == GPU_SNAP_POSITION || image->snap_mode == GPU_SNAP_POSITION_AND_DIMENSIONS) 4049 4071 { 4050 4072 // Avoid rounding errors in texture sampling by insisting on integral pixel positions ··· 4078 4100 w = src_rect->w; 4079 4101 h = src_rect->h; 4080 4102 } 4081 4081 - 4103 4103 + 4082 4104 if(image->using_virtual_resolution) 4083 4105 { 4084 4106 // Scale texture coords to fit the original dims ··· 4087 4109 x2 *= image->base_w/(float)image->w; 4088 4110 y2 *= image->base_h/(float)image->h; 4089 4111 } 4090 4090 - 4112 4112 + 4091 4113 // Center the image on the given coords (offset later) 4092 4114 dx1 = -w/2.0f; 4093 4115 dy1 = -h/2.0f; 4094 4116 dx2 = w/2.0f; 4095 4117 dy2 = h/2.0f; 4096 4096 - 4118 4118 + 4097 4119 if(image->snap_mode == GPU_SNAP_DIMENSIONS || image->snap_mode == GPU_SNAP_POSITION_AND_DIMENSIONS) 4098 4120 { 4099 4121 // This is a little weird for rotating sprites, but oh well. ··· 4105 4127 dy1 += fractional; 4106 4128 dy2 += fractional; 4107 4129 } 4108 4108 - 4130 4130 + 4109 4131 if(renderer->coordinate_mode == 1) 4110 4132 { 4111 4133 float temp = dy1; ··· 4183 4205 if(!growIndexBuffer(cdata, cdata->index_buffer_num_vertices + 6)) 4184 4206 renderer->impl->FlushBlitBuffer(renderer); 4185 4207 } 4186 4186 - 4208 4208 + 4187 4209 blit_buffer = cdata->blit_buffer; 4188 4210 index_buffer = cdata->index_buffer; 4189 4211 4190 4212 blit_buffer_starting_index = cdata->blit_buffer_num_vertices; 4191 4191 - 4213 4213 + 4192 4214 vert_index = GPU_BLIT_BUFFER_VERTEX_OFFSET + cdata->blit_buffer_num_vertices*GPU_BLIT_BUFFER_FLOATS_PER_VERTEX; 4193 4215 tex_index = GPU_BLIT_BUFFER_TEX_COORD_OFFSET + cdata->blit_buffer_num_vertices*GPU_BLIT_BUFFER_FLOATS_PER_VERTEX; 4194 4216 color_index = GPU_BLIT_BUFFER_COLOR_OFFSET + cdata->blit_buffer_num_vertices*GPU_BLIT_BUFFER_FLOATS_PER_VERTEX; 4195 4195 - 4217 4217 + 4196 4218 if(target->use_color) 4197 4219 { 4198 4220 r = MIX_COLOR_COMPONENT_NORMALIZED_RESULT(target->color.r, image->color.r); ··· 4207 4229 b = image->color.b/255.0f; 4208 4230 a = GET_ALPHA(image->color)/255.0f; 4209 4231 } 4210 4210 - 4232 4232 + 4211 4233 // 4 Quad vertices 4212 4234 SET_TEXTURED_VERTEX_UNINDEXED(dx1, dy1, x1, y1, r, g, b, a); 4213 4235 SET_TEXTURED_VERTEX_UNINDEXED(dx3, dy3, x2, y1, r, g, b, a); ··· 4267 4289 storage_ptr = (void*)((char*)storage_ptr + a->per_vertex_storage_stride_bytes); 4268 4290 memcpy(storage_ptr, values_ptr, value_size_bytes); 4269 4291 storage_ptr = (void*)((char*)storage_ptr + a->per_vertex_storage_stride_bytes); 4270 4270 - 4292 4292 + 4271 4293 values_ptr = (void*)((char*)values_ptr + a->attribute.format.stride_bytes); 4272 4294 } 4273 4295 } ··· 4287 4309 4288 4310 if(a->num_values < num_values_used) 4289 4311 num_values_used = a->num_values; 4290 4290 - 4312 4312 + 4291 4313 glBindBuffer(GL_ARRAY_BUFFER, cdata->attribute_VBO[i]); 4292 4292 - 4314 4314 + 4293 4315 bytes_used = a->per_vertex_storage_stride_bytes * num_values_used; 4294 4316 glBufferData(GL_ARRAY_BUFFER, bytes_used, a->next_value, GL_STREAM_DRAW); 4295 4295 - 4317 4317 + 4296 4318 glEnableVertexAttribArray(a->attribute.location); 4297 4319 glVertexAttribPointer(a->attribute.location, a->attribute.format.num_elems_per_value, a->attribute.format.type, a->attribute.format.normalize, a->per_vertex_storage_stride_bytes, (void*)(intptr_t)a->per_vertex_storage_offset_bytes); 4298 4298 - 4320 4320 + 4299 4321 a->enabled = 1; 4300 4322 // Move the data along so we use the next values for the next flush 4301 4323 a->num_values -= num_values_used; ··· 4326 4348 static int get_lowest_attribute_num_values(GPU_CONTEXT_DATA* cdata, int cap) 4327 4349 { 4328 4350 int lowest = cap; 4329 4329 - 4351 4351 + 4330 4352 #ifdef SDL_GPU_USE_BUFFER_PIPELINE 4331 4353 int i; 4332 4354 for(i = 0; i < 16; i++) ··· 4339 4361 } 4340 4362 } 4341 4363 #endif 4342 4342 - 4364 4364 + 4343 4365 return lowest; 4344 4366 } 4345 4367 ··· 4375 4397 GPU_CONTEXT_DATA* cdata; 4376 4398 int stride, offset_texcoords, offset_colors; 4377 4399 int size_vertices, size_texcoords, size_colors; 4378 4378 - 4400 4400 + 4379 4401 Uint8 using_texture = (image != NULL); 4380 4402 Uint8 use_vertices = (flags & (GPU_BATCH_XY | GPU_BATCH_XYZ)); 4381 4403 Uint8 use_texcoords = (flags & GPU_BATCH_ST); 4382 4404 Uint8 use_colors = (flags & (GPU_BATCH_RGB | GPU_BATCH_RGBA)); 4383 4405 Uint8 use_z = (flags & GPU_BATCH_XYZ); 4384 4406 Uint8 use_a = (flags & GPU_BATCH_RGBA); 4385 4385 - 4407 4407 + 4386 4408 if(num_vertices == 0) 4387 4409 return; 4388 4388 - 4410 4410 + 4389 4411 if(target == NULL) 4390 4412 { 4391 4413 GPU_PushErrorCode("GPU_TriangleBatch", GPU_ERROR_NULL_ARGUMENT, "target"); ··· 4396 4418 GPU_PushErrorCode("GPU_TriangleBatch", GPU_ERROR_USER_ERROR, "Mismatched renderer"); 4397 4419 return; 4398 4420 } 4399 4399 - 4421 4421 + 4400 4422 makeContextCurrent(renderer, target); 4401 4423 4402 4424 // Bind the texture to which subsequent calls refer ··· 4409 4431 GPU_PushErrorCode("GPU_TriangleBatch", GPU_ERROR_BACKEND_ERROR, "Failed to bind framebuffer."); 4410 4432 return; 4411 4433 } 4412 4412 - 4434 4434 + 4413 4435 prepareToRenderToTarget(renderer, target); 4414 4436 if(using_texture) 4415 4437 prepareToRenderImage(renderer, target, image); ··· 4417 4439 prepareToRenderShapes(renderer, GL_TRIANGLES); 4418 4440 changeViewport(target); 4419 4441 changeCamera(target); 4420 4420 - 4442 4442 + 4421 4443 if(using_texture) 4422 4444 changeTexturing(renderer, 1); 4423 4445 4424 4446 setClipRect(renderer, target); 4425 4425 - 4447 4447 + 4426 4448 #ifdef SDL_GPU_APPLY_TRANSFORMS_TO_GL_STACK 4427 4449 if(!IsFeatureEnabled(renderer, GPU_FEATURE_VERTEX_SHADER)) 4428 4450 applyTransforms(); 4429 4451 #endif 4430 4430 - 4452 4452 + 4431 4453 4432 4454 cdata = (GPU_CONTEXT_DATA*)renderer->current_context_target->context->data; 4433 4455 ··· 4441 4463 { 4442 4464 growBlitBuffer(cdata, cdata->blit_buffer_num_vertices + num_vertices); 4443 4465 } 4444 4444 - 4466 4466 + 4445 4467 // Only need to check the blit buffer because of the VBO storage 4446 4468 if(cdata->blit_buffer_num_vertices + num_vertices >= cdata->blit_buffer_max_num_vertices) 4447 4469 { ··· 4459 4481 num_indices = (cdata->index_buffer_max_num_vertices - cdata->index_buffer_num_vertices); 4460 4482 } 4461 4483 } 4462 4462 - 4484 4484 + 4463 4485 #ifdef SDL_GPU_USE_BUFFER_PIPELINE 4464 4486 refresh_attribute_data(cdata); 4465 4487 #endif 4466 4466 - 4488 4488 + 4467 4489 if(indices == NULL) 4468 4490 num_indices = num_vertices; 4469 4469 - 4491 4491 + 4470 4492 (void)stride; 4471 4493 (void)offset_texcoords; 4472 4494 (void)offset_colors; 4473 4495 (void)size_vertices; 4474 4496 (void)size_texcoords; 4475 4497 (void)size_colors; 4476 4476 - 4498 4498 + 4477 4499 stride = 0; 4478 4500 offset_texcoords = offset_colors = 0; 4479 4501 size_vertices = size_texcoords = size_colors = 0; 4480 4480 - 4502 4502 + 4481 4503 // Determine stride, size, and offsets 4482 4504 if(use_vertices) 4483 4505 { ··· 4485 4507 size_vertices = 3; 4486 4508 else 4487 4509 size_vertices = 2; 4488 4488 - 4510 4510 + 4489 4511 stride += size_vertices; 4490 4490 - 4512 4512 + 4491 4513 offset_texcoords = stride; 4492 4514 offset_colors = stride; 4493 4515 } 4494 4494 - 4516 4516 + 4495 4517 if(use_texcoords) 4496 4518 { 4497 4519 size_texcoords = 2; 4498 4498 - 4520 4520 + 4499 4521 stride += size_texcoords; 4500 4500 - 4522 4522 + 4501 4523 offset_colors = stride; 4502 4524 } 4503 4503 - 4525 4525 + 4504 4526 if(use_colors) 4505 4527 { 4506 4528 if(use_a) 4507 4529 size_colors = 4; 4508 4530 else 4509 4531 size_colors = 3; 4510 4510 - 4532 4532 + 4511 4533 stride += size_colors; 4512 4534 } 4513 4513 - 4535 4535 + 4514 4536 // Convert to a number of bytes 4515 4537 stride *= sizeof(float); 4516 4516 - 4517 4517 - 4538 4538 + 4539 4539 + 4518 4540 #ifdef SDL_GPU_USE_ARRAY_PIPELINE 4519 4519 - 4541 4541 + 4520 4542 { 4521 4543 // Enable 4522 4544 if(use_vertices) ··· 4525 4547 glEnableClientState(GL_TEXTURE_COORD_ARRAY); 4526 4548 if(use_colors) 4527 4549 glEnableClientState(GL_COLOR_ARRAY); 4528 4528 - 4550 4550 + 4529 4551 // Set pointers 4530 4552 if(use_vertices) 4531 4553 glVertexPointer(size_vertices, GL_FLOAT, stride, values); ··· 4564 4586 float* vertex_pointer = values; 4565 4587 float* texcoord_pointer = values + offset_texcoords; 4566 4588 float* color_pointer = values + offset_colors; 4567 4567 - 4589 4589 + 4568 4590 glBegin(GL_TRIANGLES); 4569 4591 for(i = 0; i < num_indices; i++) 4570 4592 { ··· 4603 4625 #if !defined(SDL_GPU_NO_VAO) 4604 4626 glBindVertexArray(cdata->blit_VAO); 4605 4627 #endif 4606 4606 - 4628 4628 + 4607 4629 // Upload our modelviewprojection matrix 4608 4630 if(cdata->current_shader_block.modelViewProjection_loc >= 0) 4609 4631 { ··· 4611 4633 GPU_GetModelViewProjection(mvp); 4612 4634 glUniformMatrix4fv(cdata->current_shader_block.modelViewProjection_loc, 1, 0, mvp); 4613 4635 } 4614 4614 - 4636 4636 + 4615 4637 if(values != NULL) 4616 4638 { 4617 4639 // Upload blit buffer to a single buffer object 4618 4640 glBindBuffer(GL_ARRAY_BUFFER, cdata->blit_VBO[cdata->blit_VBO_flop]); 4619 4641 cdata->blit_VBO_flop = !cdata->blit_VBO_flop; 4620 4642 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cdata->blit_IBO); 4621 4621 - 4643 4643 + 4622 4644 // Copy the whole blit buffer to the GPU 4623 4645 submit_buffer_data(stride * num_vertices, values, sizeof(unsigned short)*num_indices, indices); // Fills GPU buffer with data. 4624 4624 - 4646 4646 + 4625 4647 // Specify the formatting of the blit buffer 4626 4648 if(use_vertices) 4627 4649 { ··· 4639 4661 glVertexAttribPointer(cdata->current_shader_block.color_loc, size_colors, GL_FLOAT, GL_FALSE, stride, (void*)(offset_colors * sizeof(float))); 4640 4662 } 4641 4663 } 4642 4642 - 4664 4664 + 4643 4665 upload_attribute_data(cdata, num_indices); 4644 4644 - 4666 4666 + 4645 4667 if(indices == NULL) 4646 4668 glDrawArrays(GL_TRIANGLES, 0, num_indices); 4647 4669 else 4648 4670 glDrawElements(GL_TRIANGLES, num_indices, GL_UNSIGNED_SHORT, (void*)0); 4649 4649 - 4671 4671 + 4650 4672 // Disable the vertex arrays again 4651 4673 if(use_vertices) 4652 4674 glDisableVertexAttribArray(cdata->current_shader_block.position_loc); ··· 4654 4676 glDisableVertexAttribArray(cdata->current_shader_block.texcoord_loc); 4655 4677 if(use_colors) 4656 4678 glDisableVertexAttribArray(cdata->current_shader_block.color_loc); 4657 4657 - 4679 4679 + 4658 4680 disable_attribute_data(cdata); 4659 4659 - 4681 4681 + 4660 4682 #if !defined(SDL_GPU_NO_VAO) 4661 4683 glBindVertexArray(0); 4662 4684 #endif 4663 4685 } 4664 4686 #endif 4665 4665 - 4666 4666 - 4687 4687 + 4688 4688 + 4667 4689 cdata->blit_buffer_num_vertices = 0; 4668 4690 cdata->index_buffer_num_vertices = 0; 4669 4691 ··· 4676 4698 GLint filter; 4677 4699 if(image == NULL) 4678 4700 return; 4679 4679 - 4701 4701 + 4680 4702 if(image->target != NULL && isCurrentTarget(renderer, image->target)) 4681 4703 renderer->impl->FlushBlitBuffer(renderer); 4682 4704 bindTexture(renderer, image); ··· 4721 4743 return; 4722 4744 4723 4745 makeContextCurrent(renderer, target); 4724 4724 - 4746 4746 + 4725 4747 if(isCurrentTarget(renderer, target)) 4726 4748 renderer->impl->FlushBlitBuffer(renderer); 4727 4749 // Leave the clip rect values intact so they can still be useful as storage ··· 4803 4825 4804 4826 flushBlitBufferIfCurrentTexture(renderer, image); 4805 4827 bindTexture(renderer, image); 4806 4806 - 4828 4828 + 4807 4829 image->filter_mode = filter; 4808 4830 4809 4831 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter); ··· 4813 4835 static void SetWrapMode(GPU_Renderer* renderer, GPU_Image* image, GPU_WrapEnum wrap_mode_x, GPU_WrapEnum wrap_mode_y) 4814 4836 { 4815 4837 GLenum wrap_x, wrap_y; 4816 4816 - 4838 4838 + 4817 4839 if(image == NULL) 4818 4840 { 4819 4841 GPU_PushErrorCode("GPU_SetWrapMode", GPU_ERROR_NULL_ARGUMENT, "image"); ··· 4824 4846 GPU_PushErrorCode("GPU_SetWrapMode", GPU_ERROR_USER_ERROR, "Mismatched renderer"); 4825 4847 return; 4826 4848 } 4827 4827 - 4849 4849 + 4828 4850 switch(wrap_mode_x) 4829 4851 { 4830 4852 case GPU_WRAP_NONE: ··· 4846 4868 GPU_PushErrorCode("GPU_SetWrapMode", GPU_ERROR_USER_ERROR, "Unsupported value for wrap_mode_x (0x%x)", wrap_mode_x); 4847 4869 return; 4848 4870 } 4849 4849 - 4871 4871 + 4850 4872 switch(wrap_mode_y) 4851 4873 { 4852 4874 case GPU_WRAP_NONE: ··· 4868 4890 GPU_PushErrorCode("GPU_SetWrapMode", GPU_ERROR_USER_ERROR, "Unsupported value for wrap_mode_y (0x%x)", wrap_mode_y); 4869 4891 return; 4870 4892 } 4871 4871 - 4893 4893 + 4872 4894 flushBlitBufferIfCurrentTexture(renderer, image); 4873 4895 bindTexture(renderer, image); 4874 4874 - 4896 4896 + 4875 4897 image->wrap_mode_x = wrap_mode_x; 4876 4898 image->wrap_mode_y = wrap_mode_y; 4877 4877 - 4899 4899 + 4878 4900 glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap_x ); 4879 4901 glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap_y ); 4880 4902 } ··· 4891 4913 return; 4892 4914 4893 4915 makeContextCurrent(renderer, target); 4894 4894 - 4916 4916 + 4895 4917 if(isCurrentTarget(renderer, target)) 4896 4918 renderer->impl->FlushBlitBuffer(renderer); 4897 4919 if(bindFramebuffer(renderer, target)) ··· 4912 4934 glEnableClientState(GL_VERTEX_ARRAY); 4913 4935 glEnableClientState(GL_TEXTURE_COORD_ARRAY); 4914 4936 glEnableClientState(GL_COLOR_ARRAY); 4915 4915 - 4937 4937 + 4916 4938 glVertexPointer(2, GL_FLOAT, GPU_BLIT_BUFFER_STRIDE, blit_buffer + GPU_BLIT_BUFFER_VERTEX_OFFSET); 4917 4939 glTexCoordPointer(2, GL_FLOAT, GPU_BLIT_BUFFER_STRIDE, blit_buffer + GPU_BLIT_BUFFER_TEX_COORD_OFFSET); 4918 4940 glColorPointer(4, GL_FLOAT, GPU_BLIT_BUFFER_STRIDE, blit_buffer + GPU_BLIT_BUFFER_COLOR_OFFSET); ··· 4937 4959 float* vertex_pointer = blit_buffer + GPU_BLIT_BUFFER_VERTEX_OFFSET; 4938 4960 float* texcoord_pointer = blit_buffer + GPU_BLIT_BUFFER_TEX_COORD_OFFSET; 4939 4961 float* color_pointer = blit_buffer + GPU_BLIT_BUFFER_COLOR_OFFSET; 4940 4940 - 4962 4962 + 4941 4963 glBegin(cdata->last_shape); 4942 4964 for(i = 0; i < num_indices; i++) 4943 4965 { ··· 4947 4969 glVertex3f( vertex_pointer[index], vertex_pointer[index+1], 0.0f ); 4948 4970 } 4949 4971 glEnd(); 4950 4950 - 4972 4972 + 4951 4973 return; 4952 4974 } 4953 4975 #endif ··· 4961 4983 #if !defined(SDL_GPU_NO_VAO) 4962 4984 glBindVertexArray(cdata->blit_VAO); 4963 4985 #endif 4964 4964 - 4986 4986 + 4965 4987 // Upload our modelviewprojection matrix 4966 4988 if(cdata->current_shader_block.modelViewProjection_loc >= 0) 4967 4989 { ··· 4969 4991 GPU_GetModelViewProjection(mvp); 4970 4992 glUniformMatrix4fv(cdata->current_shader_block.modelViewProjection_loc, 1, 0, mvp); 4971 4993 } 4972 4972 - 4994 4994 + 4973 4995 // Upload blit buffer to a single buffer object 4974 4996 glBindBuffer(GL_ARRAY_BUFFER, cdata->blit_VBO[cdata->blit_VBO_flop]); 4975 4997 cdata->blit_VBO_flop = !cdata->blit_VBO_flop; 4976 4998 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cdata->blit_IBO); 4977 4977 - 4999 4999 + 4978 5000 // Copy the whole blit buffer to the GPU 4979 5001 submit_buffer_data(GPU_BLIT_BUFFER_STRIDE * num_vertices, blit_buffer, sizeof(unsigned short)*num_indices, index_buffer); // Fills GPU buffer with data. 4980 4980 - 5002 5002 + 4981 5003 // Specify the formatting of the blit buffer 4982 5004 if(cdata->current_shader_block.position_loc >= 0) 4983 5005 { ··· 4994 5016 glEnableVertexAttribArray(cdata->current_shader_block.color_loc); 4995 5017 glVertexAttribPointer(cdata->current_shader_block.color_loc, 4, GL_FLOAT, GL_FALSE, GPU_BLIT_BUFFER_STRIDE, (void*)(GPU_BLIT_BUFFER_COLOR_OFFSET * sizeof(float))); 4996 5018 } 4997 4997 - 5019 5019 + 4998 5020 upload_attribute_data(cdata, num_vertices); 4999 4999 - 5021 5021 + 5000 5022 glDrawElements(cdata->last_shape, num_indices, GL_UNSIGNED_SHORT, (void*)0); 5001 5001 - 5023 5023 + 5002 5024 // Disable the vertex arrays again 5003 5025 if(cdata->current_shader_block.position_loc >= 0) 5004 5026 glDisableVertexAttribArray(cdata->current_shader_block.position_loc); ··· 5006 5028 glDisableVertexAttribArray(cdata->current_shader_block.texcoord_loc); 5007 5029 if(cdata->current_shader_block.color_loc >= 0) 5008 5030 glDisableVertexAttribArray(cdata->current_shader_block.color_loc); 5009 5009 - 5031 5031 + 5010 5032 disable_attribute_data(cdata); 5011 5011 - 5033 5033 + 5012 5034 #if !defined(SDL_GPU_NO_VAO) 5013 5035 glBindVertexArray(0); 5014 5036 #endif ··· 5023 5045 #ifdef SDL_GPU_USE_ARRAY_PIPELINE 5024 5046 glEnableClientState(GL_VERTEX_ARRAY); 5025 5047 glEnableClientState(GL_COLOR_ARRAY); 5026 5026 - 5048 5048 + 5027 5049 glVertexPointer(2, GL_FLOAT, GPU_BLIT_BUFFER_STRIDE, blit_buffer + GPU_BLIT_BUFFER_VERTEX_OFFSET); 5028 5050 glColorPointer(4, GL_FLOAT, GPU_BLIT_BUFFER_STRIDE, blit_buffer + GPU_BLIT_BUFFER_COLOR_OFFSET); 5029 5051 ··· 5043 5065 unsigned int index; 5044 5066 float* vertex_pointer = blit_buffer + GPU_BLIT_BUFFER_VERTEX_OFFSET; 5045 5067 float* color_pointer = blit_buffer + GPU_BLIT_BUFFER_COLOR_OFFSET; 5046 5046 - 5068 5068 + 5047 5069 glBegin(cdata->last_shape); 5048 5070 for(i = 0; i < num_indices; i++) 5049 5071 { ··· 5052 5074 glVertex3f( vertex_pointer[index], vertex_pointer[index+1], 0.0f ); 5053 5075 } 5054 5076 glEnd(); 5055 5055 - 5077 5077 + 5056 5078 return; 5057 5079 } 5058 5080 #endif ··· 5063 5085 #if !defined(SDL_GPU_NO_VAO) 5064 5086 glBindVertexArray(cdata->blit_VAO); 5065 5087 #endif 5066 5066 - 5088 5088 + 5067 5089 // Upload our modelviewprojection matrix 5068 5090 if(cdata->current_shader_block.modelViewProjection_loc >= 0) 5069 5091 { ··· 5071 5093 GPU_GetModelViewProjection(mvp); 5072 5094 glUniformMatrix4fv(cdata->current_shader_block.modelViewProjection_loc, 1, 0, mvp); 5073 5095 } 5074 5074 - 5096 5096 + 5075 5097 // Upload blit buffer to a single buffer object 5076 5098 glBindBuffer(GL_ARRAY_BUFFER, cdata->blit_VBO[cdata->blit_VBO_flop]); 5077 5099 cdata->blit_VBO_flop = !cdata->blit_VBO_flop; 5078 5100 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cdata->blit_IBO); 5079 5079 - 5101 5101 + 5080 5102 // Copy the whole blit buffer to the GPU 5081 5103 submit_buffer_data(GPU_BLIT_BUFFER_STRIDE * num_vertices, blit_buffer, sizeof(unsigned short)*num_indices, index_buffer); // Fills GPU buffer with data. 5082 5082 - 5104 5104 + 5083 5105 // Specify the formatting of the blit buffer 5084 5106 if(cdata->current_shader_block.position_loc >= 0) 5085 5107 { ··· 5091 5113 glEnableVertexAttribArray(cdata->current_shader_block.color_loc); 5092 5114 glVertexAttribPointer(cdata->current_shader_block.color_loc, 4, GL_FLOAT, GL_FALSE, GPU_BLIT_BUFFER_STRIDE, (void*)(GPU_BLIT_BUFFER_COLOR_OFFSET * sizeof(float))); 5093 5115 } 5094 5094 - 5116 5116 + 5095 5117 upload_attribute_data(cdata, num_vertices); 5096 5096 - 5118 5118 + 5097 5119 glDrawElements(cdata->last_shape, num_indices, GL_UNSIGNED_SHORT, (void*)0); 5098 5098 - 5120 5120 + 5099 5121 // Disable the vertex arrays again 5100 5122 if(cdata->current_shader_block.position_loc >= 0) 5101 5123 glDisableVertexAttribArray(cdata->current_shader_block.position_loc); 5102 5124 if(cdata->current_shader_block.color_loc >= 0) 5103 5125 glDisableVertexAttribArray(cdata->current_shader_block.color_loc); 5104 5104 - 5126 5126 + 5105 5127 disable_attribute_data(cdata); 5106 5106 - 5128 5128 + 5107 5129 #if !defined(SDL_GPU_NO_VAO) 5108 5130 glBindVertexArray(0); 5109 5131 #endif ··· 5118 5140 GPU_CONTEXT_DATA* cdata; 5119 5141 if(renderer->current_context_target == NULL) 5120 5142 return; 5121 5121 - 5143 5143 + 5122 5144 cdata = (GPU_CONTEXT_DATA*)renderer->current_context_target->context->data; 5123 5145 if(cdata->blit_buffer_num_vertices > 0 && cdata->last_target != NULL) 5124 5146 { ··· 5127 5149 int num_indices; 5128 5150 float* blit_buffer; 5129 5151 unsigned short* index_buffer; 5130 5130 - 5152 5152 + 5131 5153 changeViewport(dest); 5132 5154 changeCamera(dest); 5133 5133 - 5155 5155 + 5134 5156 applyTexturing(renderer); 5135 5135 - 5157 5157 + 5136 5158 #ifdef SDL_GPU_APPLY_TRANSFORMS_TO_GL_STACK 5137 5159 if(!IsFeatureEnabled(renderer, GPU_FEATURE_VERTEX_SHADER)) 5138 5160 applyTransforms(); 5139 5161 #endif 5140 5140 - 5162 5162 + 5141 5163 setClipRect(renderer, dest); 5142 5142 - 5164 5164 + 5143 5165 #ifdef SDL_GPU_USE_BUFFER_PIPELINE 5144 5166 refresh_attribute_data(cdata); 5145 5167 #endif 5146 5146 - 5168 5168 + 5147 5169 blit_buffer = cdata->blit_buffer; 5148 5170 index_buffer = cdata->index_buffer; 5149 5149 - 5171 5171 + 5150 5172 if(cdata->last_use_texturing) 5151 5173 { 5152 5174 while(cdata->blit_buffer_num_vertices > 0) 5153 5175 { 5154 5176 num_vertices = MAX(cdata->blit_buffer_num_vertices, get_lowest_attribute_num_values(cdata, cdata->blit_buffer_num_vertices)); 5155 5177 num_indices = num_vertices * 3 / 2; // 6 indices per sprite / 4 vertices per sprite = 3/2 5156 5156 - 5178 5178 + 5157 5179 DoPartialFlush(renderer, cdata, num_vertices, blit_buffer, num_indices, index_buffer); 5158 5158 - 5180 5180 + 5159 5181 cdata->blit_buffer_num_vertices -= num_vertices; 5160 5182 // Move our pointers ahead 5161 5183 blit_buffer += GPU_BLIT_BUFFER_FLOATS_PER_VERTEX*num_vertices; ··· 5177 5199 static void Flip(GPU_Renderer* renderer, GPU_Target* target) 5178 5200 { 5179 5201 renderer->impl->FlushBlitBuffer(renderer); 5180 5180 - 5202 5202 + 5181 5203 makeContextCurrent(renderer, target); 5182 5204 5183 5205 #ifdef SDL_GPU_USE_SDL2 ··· 5237 5259 5238 5260 if(shader_source == NULL) 5239 5261 return 0; 5240 5240 - 5262 5262 + 5241 5263 size = 0; 5242 5242 - 5264 5264 + 5243 5265 // Read 1 byte at a time until we reach the end 5244 5266 last_char = ' '; 5245 5267 len = 0; ··· 5259 5281 break; 5260 5282 } 5261 5283 buffer[line_size] = '\0'; 5262 5262 - 5284 5284 + 5263 5285 // Is there "include" after '#'? 5264 5286 token = strtok(buffer, "# \t"); 5265 5265 - 5287 5287 + 5266 5288 if(token != NULL && strcmp(token, "include") == 0) 5267 5289 { 5268 5290 // Get filename token ··· 5278 5300 last_char = ' '; 5279 5301 continue; 5280 5302 } 5281 5281 - 5303 5303 + 5282 5304 size += len; 5283 5283 - 5305 5305 + 5284 5306 if(last_char == '/') 5285 5307 { 5286 5308 if(buffer[0] == '/') ··· 5298 5320 else 5299 5321 last_char = buffer[0]; 5300 5322 } 5301 5301 - 5323 5323 + 5302 5324 // Go back to the beginning of the stream 5303 5325 SDL_RWseek(shader_source, 0, SEEK_SET); 5304 5326 return size; ··· 5317 5339 result[0] = '\0'; 5318 5340 return 0; 5319 5341 } 5320 5320 - 5342 5342 + 5321 5343 size = 0; 5322 5322 - 5344 5344 + 5323 5345 // Read 1 byte at a time until we reach the end 5324 5346 last_char = ' '; 5325 5347 len = 0; ··· 5339 5361 if(buffer[line_size - line_len] == '\n') 5340 5362 break; 5341 5363 } 5342 5342 - 5364 5364 + 5343 5365 // Is there "include" after '#'? 5344 5366 memcpy(token_buffer, buffer, line_size+1); 5345 5367 token_buffer[line_size] = '\0'; 5346 5368 token = strtok(token_buffer, "# \t"); 5347 5347 - 5369 5369 + 5348 5370 if(token != NULL && strcmp(token, "include") == 0) 5349 5371 { 5350 5372 // Get filename token ··· 5365 5387 last_char = ' '; 5366 5388 continue; 5367 5389 } 5368 5368 - 5390 5390 + 5369 5391 memcpy(result + size, buffer, len); 5370 5392 size += len; 5371 5371 - 5393 5393 + 5372 5394 if(last_char == '/') 5373 5395 { 5374 5396 if(buffer[0] == '/') ··· 5389 5411 last_char = buffer[0]; 5390 5412 } 5391 5413 result[size] = '\0'; 5392 5392 - 5414 5414 + 5393 5415 // Go back to the beginning of the stream 5394 5416 SDL_RWseek(shader_source, 0, SEEK_SET); 5395 5417 return size; ··· 5403 5425 if(filename == NULL) 5404 5426 return 0; 5405 5427 rwops = SDL_RWFromFile(filename, "r"); 5406 5406 - 5428 5428 + 5407 5429 size = GetShaderSource_RW(rwops, result); 5408 5408 - 5430 5430 + 5409 5431 SDL_RWclose(rwops); 5410 5432 return size; 5411 5433 } ··· 5418 5440 if(filename == NULL) 5419 5441 return 0; 5420 5442 rwops = SDL_RWFromFile(filename, "r"); 5421 5421 - 5443 5443 + 5422 5444 result = GetShaderSourceSize_RW(rwops); 5423 5423 - 5445 5445 + 5424 5446 SDL_RWclose(rwops); 5425 5447 return result; 5426 5448 } ··· 5432 5454 GLuint shader_object = 0; 5433 5455 (void)shader_type; 5434 5456 (void)shader_source; 5435 5435 - 5457 5457 + 5436 5458 #ifndef SDL_GPU_DISABLE_SHADERS 5437 5459 GLint compiled; 5438 5438 - 5460 5460 + 5439 5461 switch(shader_type) 5440 5462 { 5441 5463 case GPU_VERTEX_SHADER: ··· 5454 5476 #endif 5455 5477 break; 5456 5478 } 5457 5457 - 5479 5479 + 5458 5480 if(shader_object == 0) 5459 5481 { 5460 5482 GPU_PushErrorCode("GPU_CompileShader", GPU_ERROR_BACKEND_ERROR, "Failed to create new shader object"); 5461 5483 snprintf(shader_message, 256, "Failed to create new shader object.\n"); 5462 5484 return 0; 5463 5485 } 5464 5464 - 5486 5486 + 5465 5487 glShaderSource(shader_object, 1, &shader_source, NULL); 5466 5466 - 5488 5488 + 5467 5489 // Compile the shader source 5468 5468 - 5490 5490 + 5469 5491 glCompileShader(shader_object); 5470 5470 - 5492 5492 + 5471 5493 glGetShaderiv(shader_object, GL_COMPILE_STATUS, &compiled); 5472 5494 if(!compiled) 5473 5495 { ··· 5476 5498 glDeleteShader(shader_object); 5477 5499 return 0; 5478 5500 } 5479 5479 - 5501 5501 + 5480 5502 #endif 5481 5481 - 5503 5503 + 5482 5504 return shader_object; 5483 5505 } 5484 5506 ··· 5499 5521 SDL_free(source_string); 5500 5522 return 0; 5501 5523 } 5502 5502 - 5524 5524 + 5503 5525 result2 = compile_shader_source(shader_type, source_string); 5504 5526 SDL_free(source_string); 5505 5505 - 5527 5527 + 5506 5528 return result2; 5507 5529 } 5508 5530 ··· 5522 5544 { 5523 5545 #ifndef SDL_GPU_DISABLE_SHADERS 5524 5546 GLuint p; 5525 5525 - 5547 5547 + 5526 5548 if(!IsFeatureEnabled(renderer, GPU_FEATURE_BASIC_SHADERS)) 5527 5549 return 0; 5528 5528 - 5550 5550 + 5529 5551 p = glCreateProgram(); 5530 5530 - 5552 5552 + 5531 5553 return p; 5532 5554 #else 5533 5555 (void)renderer; ··· 5539 5561 { 5540 5562 #ifndef SDL_GPU_DISABLE_SHADERS 5541 5563 int linked; 5542 5542 - 5564 5564 + 5543 5565 if(!IsFeatureEnabled(renderer, GPU_FEATURE_BASIC_SHADERS)) 5544 5566 return 0; 5545 5545 - 5567 5567 + 5546 5568 glLinkProgram(program_object); 5547 5547 - 5569 5569 + 5548 5570 glGetProgramiv(program_object, GL_LINK_STATUS, &linked); 5549 5549 - 5571 5571 + 5550 5572 if(!linked) 5551 5573 { 5552 5574 GPU_PushErrorCode("GPU_LinkShaderProgram", GPU_ERROR_BACKEND_ERROR, "Failed to link shader program"); ··· 5554 5576 glDeleteProgram(program_object); 5555 5577 return 0; 5556 5578 } 5557 5557 - 5579 5579 + 5558 5580 return 1; 5559 5559 - 5581 5581 + 5560 5582 #else 5561 5583 (void)renderer; 5562 5584 (void)program_object; 5563 5585 return 0; 5564 5564 - 5586 5586 + 5565 5587 #endif 5566 5588 } 5567 5589 ··· 5620 5642 if(target->context->current_shader_program == target->context->default_textured_shader_program 5621 5643 || target->context->current_shader_program == target->context->default_untextured_shader_program) 5622 5644 return; 5623 5623 - 5645 5645 + 5624 5646 program_object = target->context->default_untextured_shader_program; 5625 5647 } 5626 5626 - 5648 5648 + 5627 5649 renderer->impl->FlushBlitBuffer(renderer); 5628 5650 glUseProgram(program_object); 5629 5629 - 5651 5651 + 5630 5652 { 5631 5653 // Set up our shader attribute and uniform locations 5632 5654 GPU_CONTEXT_DATA* cdata = ((GPU_CONTEXT_DATA*)target->context->data); ··· 5651 5673 } 5652 5674 } 5653 5675 #endif 5654 5654 - 5676 5676 + 5655 5677 target->context->current_shader_program = program_object; 5656 5678 } 5657 5679 ··· 5712 5734 b.modelViewProjection_loc = -1; 5713 5735 return b; 5714 5736 } 5715 5715 - 5737 5737 + 5716 5738 if(position_name == NULL) 5717 5739 b.position_loc = -1; 5718 5740 else 5719 5741 b.position_loc = renderer->impl->GetAttributeLocation(renderer, program_object, position_name); 5720 5720 - 5742 5742 + 5721 5743 if(texcoord_name == NULL) 5722 5744 b.texcoord_loc = -1; 5723 5745 else 5724 5746 b.texcoord_loc = renderer->impl->GetAttributeLocation(renderer, program_object, texcoord_name); 5725 5725 - 5747 5747 + 5726 5748 if(color_name == NULL) 5727 5749 b.color_loc = -1; 5728 5750 else 5729 5751 b.color_loc = renderer->impl->GetAttributeLocation(renderer, program_object, color_name); 5730 5730 - 5752 5752 + 5731 5753 if(modelViewMatrix_name == NULL) 5732 5754 b.modelViewProjection_loc = -1; 5733 5755 else 5734 5756 b.modelViewProjection_loc = renderer->impl->GetUniformLocation(renderer, program_object, modelViewMatrix_name); 5735 5735 - 5757 5757 + 5736 5758 return b; 5737 5759 } 5738 5760 ··· 5750 5772 // TODO: OpenGL 1 needs to check for ARB_multitexture to use glActiveTexture(). 5751 5773 #ifndef SDL_GPU_DISABLE_SHADERS 5752 5774 Uint32 new_texture; 5753 5753 - 5775 5775 + 5754 5776 if(!IsFeatureEnabled(renderer, GPU_FEATURE_BASIC_SHADERS)) 5755 5777 return; 5756 5756 - 5778 5778 + 5757 5779 renderer->impl->FlushBlitBuffer(renderer); 5758 5780 if(renderer->current_context_target->context->current_shader_program == 0 || image_unit < 0) 5759 5781 return; 5760 5760 - 5782 5782 + 5761 5783 new_texture = 0; 5762 5784 if(image != NULL) 5763 5785 new_texture = ((GPU_IMAGE_DATA*)image->data)->handle; 5764 5764 - 5786 5786 + 5765 5787 // Set the new image unit 5766 5788 glUniform1i(location, image_unit); 5767 5789 glActiveTexture(GL_TEXTURE0 + image_unit); 5768 5790 glBindTexture(GL_TEXTURE_2D, new_texture); 5769 5769 - 5791 5791 + 5770 5792 if(image_unit != 0) 5771 5793 glActiveTexture(GL_TEXTURE0); 5772 5772 - 5794 5794 + 5773 5795 #endif 5774 5796 5775 5797 (void)renderer; ··· 6034 6056 return; 6035 6057 } 6036 6058 #endif 6037 6037 - 6059 6059 + 6038 6060 switch(num_rows) 6039 6061 { 6040 6062 case 2: ··· 6078 6100 renderer->impl->FlushBlitBuffer(renderer); 6079 6101 if(renderer->current_context_target->context->current_shader_program == 0) 6080 6102 return; 6081 6081 - 6103 6103 + 6082 6104 #ifdef SDL_GPU_USE_OPENGL 6083 6105 if(apply_Intel_attrib_workaround && location == 0) 6084 6106 { ··· 6087 6109 glEnd(); 6088 6110 } 6089 6111 #endif 6090 6090 - 6112 6112 + 6091 6113 glVertexAttrib1f(location, value); 6092 6092 - 6114 6114 + 6093 6115 #endif 6094 6116 } 6095 6117 ··· 6105 6127 renderer->impl->FlushBlitBuffer(renderer); 6106 6128 if(renderer->current_context_target->context->current_shader_program == 0) 6107 6129 return; 6108 6108 - 6130 6130 + 6109 6131 #ifdef SDL_GPU_USE_OPENGL 6110 6132 if(apply_Intel_attrib_workaround && location == 0) 6111 6133 { ··· 6114 6136 glEnd(); 6115 6137 } 6116 6138 #endif 6117 6117 - 6139 6139 + 6118 6140 glVertexAttribI1i(location, value); 6119 6119 - 6141 6141 + 6120 6142 #endif 6121 6143 } 6122 6144 ··· 6132 6154 renderer->impl->FlushBlitBuffer(renderer); 6133 6155 if(renderer->current_context_target->context->current_shader_program == 0) 6134 6156 return; 6135 6135 - 6157 6157 + 6136 6158 #ifdef SDL_GPU_USE_OPENGL 6137 6159 if(apply_Intel_attrib_workaround && location == 0) 6138 6160 { ··· 6141 6163 glEnd(); 6142 6164 } 6143 6165 #endif 6144 6144 - 6166 6166 + 6145 6167 glVertexAttribI1ui(location, value); 6146 6146 - 6168 6168 + 6147 6169 #endif 6148 6170 } 6149 6171 ··· 6161 6183 renderer->impl->FlushBlitBuffer(renderer); 6162 6184 if(renderer->current_context_target->context->current_shader_program == 0) 6163 6185 return; 6164 6164 - 6186 6186 + 6165 6187 #ifdef SDL_GPU_USE_OPENGL 6166 6188 if(apply_Intel_attrib_workaround && location == 0) 6167 6189 { ··· 6170 6192 glEnd(); 6171 6193 } 6172 6194 #endif 6173 6173 - 6195 6195 + 6174 6196 switch(num_elements) 6175 6197 { 6176 6198 case 1: ··· 6186 6208 glVertexAttrib4f(location, value[0], value[1], value[2], value[3]); 6187 6209 break; 6188 6210 } 6189 6189 - 6211 6211 + 6190 6212 #endif 6191 6213 } 6192 6214 ··· 6202 6224 renderer->impl->FlushBlitBuffer(renderer); 6203 6225 if(renderer->current_context_target->context->current_shader_program == 0) 6204 6226 return; 6205 6205 - 6227 6227 + 6206 6228 #ifdef SDL_GPU_USE_OPENGL 6207 6229 if(apply_Intel_attrib_workaround && location == 0) 6208 6230 { ··· 6211 6233 glEnd(); 6212 6234 } 6213 6235 #endif 6214 6214 - 6236 6236 + 6215 6237 switch(num_elements) 6216 6238 { 6217 6239 case 1: ··· 6227 6249 glVertexAttribI4i(location, value[0], value[1], value[2], value[3]); 6228 6250 break; 6229 6251 } 6230 6230 - 6252 6252 + 6231 6253 #endif 6232 6254 } 6233 6255 ··· 6244 6266 renderer->impl->FlushBlitBuffer(renderer); 6245 6267 if(renderer->current_context_target->context->current_shader_program == 0) 6246 6268 return; 6247 6247 - 6269 6269 + 6248 6270 #ifdef SDL_GPU_USE_OPENGL 6249 6271 if(apply_Intel_attrib_workaround && location == 0) 6250 6272 { ··· 6253 6275 glEnd(); 6254 6276 } 6255 6277 #endif 6256 6256 - 6278 6278 + 6257 6279 switch(num_elements) 6258 6280 { 6259 6281 case 1: ··· 6269 6291 glVertexAttribI4ui(location, value[0], value[1], value[2], value[3]); 6270 6292 break; 6271 6293 } 6272 6272 - 6294 6294 + 6273 6295 #endif 6274 6296 } 6275 6297 ··· 6293 6315 a->per_vertex_storage_stride_bytes = source.format.num_elems_per_value * sizeof_GPU_type(source.format.type); 6294 6316 a->num_values = 4 * num_values; // 4 vertices now 6295 6317 needed_size = a->num_values * a->per_vertex_storage_stride_bytes; 6296 6296 - 6318 6318 + 6297 6319 // Make sure we have enough room for converted per-vertex data 6298 6320 if(a->per_vertex_storage_size < needed_size) 6299 6321 { ··· 6308 6330 a->per_vertex_storage = NULL; 6309 6331 a->per_vertex_storage_size = 0; 6310 6332 } 6311 6311 - 6333 6333 + 6312 6334 a->enabled = 0; 6313 6335 a->attribute = source; 6314 6314 - 6336 6336 + 6315 6337 if(!source.format.is_per_sprite) 6316 6338 { 6317 6339 a->per_vertex_storage = source.values; ··· 6319 6341 a->per_vertex_storage_stride_bytes = source.format.stride_bytes; 6320 6342 a->per_vertex_storage_offset_bytes = source.format.offset_bytes; 6321 6343 } 6322 6322 - 6344 6344 + 6323 6345 a->next_value = a->per_vertex_storage; 6324 6324 - 6346 6346 + 6325 6347 #endif 6326 6348 6327 6349 (void)renderer;

+4

tests/CMakeLists.txt

reviewed

··· 3 3 4 4 set(TEST_LIBS test-common SDL_gpu) 5 5 6 6 + if(MINGW) 7 7 + set(TEST_LIBS ${TEST_LIBS} mingw32) 8 8 + endif(MINGW) 9 9 + 6 10 add_executable(create-test create/main.c) 7 11 target_link_libraries (create-test ${TEST_LIBS}) 8 12

+10 -5

tests/render-target/main.c

reviewed

··· 12 12 13 13 screen = initialize_demo(argc, argv, 800, 600); 14 14 if(screen == NULL) 15 15 - return -1; 15 15 + return 1; 16 16 17 17 { 18 18 GPU_Image* image2; ··· 34 34 35 35 image2 = GPU_LoadImage("data/test2.bmp"); 36 36 if (image2 == NULL) 37 37 - return -1; 37 37 + return 2; 38 38 39 39 image3 = GPU_LoadImage("data/test.bmp"); 40 40 if (image3 == NULL) 41 41 - return -1; 41 41 + return 3; 42 42 43 43 font_surface = GPU_LoadSurface("data/comic14.png"); 44 44 font = FONT_Alloc(font_surface); 45 45 + if(font == NULL) 46 46 + { 47 47 + GPU_LogError("Failed to load font.\n"); 48 48 + return 4; 49 49 + } 45 50 GPU_SetRGB(font->image, 255, 0, 0); 46 51 SDL_FreeSurface(font_surface); 47 52 48 53 mode1image = GPU_CreateImage(300, 300, GPU_FORMAT_RGBA); 49 54 if (mode1image == NULL) 50 50 - return -1; 55 55 + return 5; 51 56 52 57 mode2image = GPU_CreateImage(400, 400, GPU_FORMAT_RGBA); 53 58 if (mode2image == NULL) 54 54 - return -1; 59 59 + return 6; 55 60 56 61 GPU_LoadTarget(mode1image); 57 62 GPU_LoadTarget(mode2image);