SEMANTICS CHANGE: Added GPU_GetTarget() which acts like GPU_LoadTarget() but without incrementing the refcount. This means that every instance of GPU_LoadTarget() should be matched with a GPU_FreeTarget(). GPU_GetTarget() provides an explicit weak reference so that GPU_FreeImage() will clean it up.

+4 -1

include/SDL_gpu.h

··· 951 951 * GPU_FreeTarget() frees the alias's memory, but does not affect the original. */ 952 952 DECLSPEC GPU_Target* SDLCALL GPU_CreateAliasTarget(GPU_Target* target); 953 953 954 - /*! Creates a new render target from the given image. It can then be accessed from image->target. */ 954 + /*! Creates a new render target from the given image. It can then be accessed from image->target. This increments the internal refcount of the target, so it should be matched with a GPU_FreeTarget(). */ 955 955 DECLSPEC GPU_Target* SDLCALL GPU_LoadTarget(GPU_Image* image); 956 + 957 + /*! Creates a new render target from the given image. It can then be accessed from image->target. This does not increment the internal refcount of the target, so it will be invalidated when the image is freed. */ 958 + DECLSPEC GPU_Target* SDLCALL GPU_GetTarget(GPU_Image* image); 956 959 957 960 /*! Deletes a render target in the proper way for this renderer. */ 958 961 DECLSPEC void SDLCALL GPU_FreeTarget(GPU_Target* target);

+2 -2

include/SDL_gpu_RendererImpl.h

··· 94 94 /*! \see GPU_FreeImage() */ 95 95 void (SDLCALL *FreeImage)(GPU_Renderer* renderer, GPU_Image* image); 96 96 97 - /*! \see GPU_LoadTarget() */ 98 - GPU_Target* (SDLCALL *LoadTarget)(GPU_Renderer* renderer, GPU_Image* image); 97 + /*! \see GPU_GetTarget() */ 98 + GPU_Target* (SDLCALL *GetTarget)(GPU_Renderer* renderer, GPU_Image* image); 99 99 100 100 /*! \see GPU_FreeTarget() */ 101 101 void (SDLCALL *FreeTarget)(GPU_Renderer* renderer, GPU_Target* target);

+12 -1

src/SDL_gpu.c

··· 1301 1301 1302 1302 GPU_Target* GPU_LoadTarget(GPU_Image* image) 1303 1303 { 1304 + GPU_Target* result = GPU_GetTarget(image); 1305 + 1306 + if(result != NULL) 1307 + result->refcount++; 1308 + 1309 + return result; 1310 + } 1311 + 1312 + 1313 + GPU_Target* GPU_GetTarget(GPU_Image* image) 1314 + { 1304 1315 if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1305 1316 return NULL; 1306 1317 1307 - return _gpu_current_renderer->impl->LoadTarget(_gpu_current_renderer, image); 1318 + return _gpu_current_renderer->impl->GetTarget(_gpu_current_renderer, image); 1308 1319 } 1309 1320 1310 1321

+9 -13

src/renderer_GL_common.inl

··· 2570 2570 created_target = GPU_FALSE; 2571 2571 if(source->target == NULL) 2572 2572 { 2573 - renderer->impl->LoadTarget(renderer, source); 2573 + renderer->impl->GetTarget(renderer, source); 2574 2574 created_target = GPU_TRUE; 2575 2575 } 2576 2576 // Get the data ··· 3113 3113 return NULL; 3114 3114 } 3115 3115 3116 - target = GPU_LoadTarget(result); 3116 + // Don't free the target yet (a waste of perf), but let it be freed when the image is freed... 3117 + target = GPU_GetTarget(result); 3117 3118 if(target == NULL) 3118 3119 { 3119 3120 GPU_FreeImage(result); ··· 3152 3153 GPU_SetImageVirtualResolution(image, w, h); 3153 3154 } 3154 3155 } 3155 - 3156 - // Don't free the target yet (a waste of perf), but let it be freed next time... 3157 - target->refcount--; 3158 - ((GPU_TARGET_DATA*)target->data)->refcount--; 3159 3156 } 3160 3157 break; 3161 3158 case GPU_FORMAT_LUMINANCE: ··· 3723 3720 { 3724 3721 GPU_Target* target = image->target; 3725 3722 image->target = NULL; 3723 + 3724 + // Freeing it will decrement the refcount. If this is the only increment, it will be freed. This means GPU_LoadTarget() needs to be paired with GPU_FreeTarget(). 3725 + target->refcount++; 3726 3726 renderer->impl->FreeTarget(renderer, target); 3727 3727 } 3728 3728 ··· 3749 3749 3750 3750 3751 3751 3752 - static GPU_Target* LoadTarget(GPU_Renderer* renderer, GPU_Image* image) 3752 + static GPU_Target* GetTarget(GPU_Renderer* renderer, GPU_Image* image) 3753 3753 { 3754 3754 GLuint handle; 3755 3755 GLenum status; ··· 3760 3760 return NULL; 3761 3761 3762 3762 if(image->target != NULL) 3763 - { 3764 - image->target->refcount++; 3765 - ((GPU_TARGET_DATA*)image->target->data)->refcount++; 3766 3763 return image->target; 3767 - } 3768 3764 3769 3765 if(!(renderer->enabled_features & GPU_FEATURE_RENDER_TARGETS)) 3770 3766 return NULL; ··· 3782 3778 3783 3779 result = (GPU_Target*)SDL_malloc(sizeof(GPU_Target)); 3784 3780 memset(result, 0, sizeof(GPU_Target)); 3785 - result->refcount = 1; 3781 + result->refcount = 0; 3786 3782 data = (GPU_TARGET_DATA*)SDL_malloc(sizeof(GPU_TARGET_DATA)); 3787 3783 data->refcount = 1; 3788 3784 result->data = data; ··· 6671 6667 impl->CopySurfaceFromImage = &CopySurfaceFromImage; \ 6672 6668 impl->FreeImage = &FreeImage; \ 6673 6669 \ 6674 - impl->LoadTarget = &LoadTarget; \ 6670 + impl->GetTarget = &GetTarget; \ 6675 6671 impl->FreeTarget = &FreeTarget; \ 6676 6672 \ 6677 6673 impl->Blit = &Blit; \

+3 -6

tests/renderer/main.c

··· 607 607 } 608 608 609 609 610 - static GPU_Target* LoadTarget(GPU_Renderer* renderer, GPU_Image* image) 610 + static GPU_Target* GetTarget(GPU_Renderer* renderer, GPU_Image* image) 611 611 { 612 612 GPU_Target* result; 613 613 ··· 617 617 return NULL; 618 618 619 619 if(image->target != NULL) 620 - { 621 - image->target->refcount++; 622 620 return image->target; 623 - } 624 621 625 622 if(!(renderer->enabled_features & GPU_FEATURE_RENDER_TARGETS)) 626 623 return NULL; 627 624 628 625 result = (GPU_Target*)malloc(sizeof(GPU_Target)); 629 626 memset(result, 0, sizeof(GPU_Target)); 630 - result->refcount = 1; 627 + result->refcount = 0; 631 628 result->data = NULL; // Allocate a data structure as needed for other render target data 632 629 633 630 result->renderer = renderer; ··· 1198 1195 impl->CopySurfaceFromImage = &CopySurfaceFromImage; 1199 1196 impl->FreeImage = &FreeImage; 1200 1197 1201 - impl->LoadTarget = &LoadTarget; 1198 + impl->GetTarget = &GetTarget; 1202 1199 impl->FreeTarget = &FreeTarget; 1203 1200 1204 1201 impl->Blit = &Blit;

Configure Feed

Configure Feed