I’m trying to create and render a large number of textures in a window with a SDL_WINDOW_RESIZABLE flag, but when I’m resizing it, some textures sometimes break. I haven’t noticed this issue if I’m creating a texture in some other way, for example, by rendering a glyph and converting it to a texture. Here’s full code:

#include <iostream>
#include <string>
#include <SDL.h>
#include <SDL_Image.h>
#include <SDL_ttf.h>
#include <vector>

SDL_Texture* generateColoredTexture(SDL_Renderer *renderer_, int w_, int h_, const SDL_Color &col_)
{
    auto *tex = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, w_, h_);
    SDL_SetTextureBlendMode(tex, SDL_BLENDMODE_BLEND);

    auto oldTar = SDL_GetRenderTarget(renderer_);
    SDL_SetRenderTarget(renderer_, tex);

    SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
    SDL_RenderClear(renderer_);

    SDL_SetRenderDrawColor(renderer_, col_.r, col_.g, col_.b, col_.a);
    SDL_Rect dst = {4, 4, w_ - 8, h_ - 8};
    SDL_RenderFillRect(renderer_, &dst);

    SDL_SetRenderTarget(renderer_, oldTar);
    return tex;
}

SDL_Texture* generateChar(SDL_Renderer *renderer_, TTF_Font *font_, char ch_)
{
    auto surf = TTF_RenderGlyph32_Blended(font_, ch_, {0, 0, 0, 255});
    if (surf == nullptr)
    {
        std::cout << "Cannot create surface: " << TTF_GetError() << std::endl;
        return nullptr;
    }

    auto *text = SDL_CreateTextureFromSurface(renderer_, surf);
    SDL_FreeSurface(surf);
    SDL_SetTextureBlendMode(text, SDL_BLENDMODE_BLEND);
    return text;
}

int main(int argc, char* args[])
{    
    if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
    {
        std::cout << "SDL initialization error: " << SDL_GetError() << std::endl;
        return -1;
    }

    if ((IMG_Init(IMG_INIT_PNG) & IMG_INIT_PNG) != IMG_INIT_PNG)
    {
        std::cout << "IMG initialization error: " << SDL_GetError() << std::endl;
        return -2;
    }

    if (TTF_Init() == -1)
    {
        std::cout << "TTF initialization error: " << TTF_GetError() << std::endl;
        return -5;
    }

    auto window = SDL_CreateWindow("TestWin", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 1280, 720, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
    if (window == nullptr)
    {
        std::cout << "Window creation error: " << SDL_GetError() << std::endl;
        return -3;
    }

    auto renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE);
    if (renderer == nullptr) {
        std::cout << "Renderer creation error: " << SDL_GetError() << std::endl;
        return -4;
    }

    std::vector<SDL_Texture*> texs;
    for (int i = 0; i < 53; ++i)
    {
        texs.push_back(generateColoredTexture(renderer, 50, 50, {uint8_t(rand() % 255), uint8_t(rand() % 255), uint8_t(rand() % 255), 255}));
    }

    /*std::string toGen = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.,/|?!\@#$%^&**(){}"'`~1234567890-=+_:;";
    auto *font = TTF_OpenFont("VanillaExtractRegular.ttf", 50);
    for (auto &ch : toGen)
    {
        texs.push_back(generateChar(renderer, font, ch));
    }

    TTF_CloseFont(font);*/

    std::vector<std::vector<int>> cells;
    for (int y = 0; y < 10; ++y)
    {
        cells.push_back({});
        for (int x = 0; x < 20; ++x)
        {
            cells.back().push_back(rand() % texs.size());
        }
    }

    bool running = true;
    SDL_Event e;

    while (running)
    {
        while( SDL_PollEvent( &e ) != 0 )
        {
            if( e.type == SDL_QUIT )
            {
                running = false;
            }
        }

        SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
        SDL_RenderClear(renderer);

        for (int y = 0; y < cells.size(); ++y)
        {
            for (int x = 0; x < cells[y].size(); ++x)
            {
                SDL_Rect dstrect{x * 50, y * 50, 50, 50};
                SDL_RenderCopy(renderer, texs[cells[y][x]], NULL, &dstrect);
            }
        }

        SDL_RenderPresent(renderer);
    }

    for (auto *tex : texs)
        SDL_DestroyTexture(tex);

    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);

    TTF_Quit();
    IMG_Quit();
    SDL_Quit();

    return 0;
}

Video of this issue. I haven’t found any notes about created textures or window resizing on sdl wiki. I also tried to catch SDL_WINDOWEVENT_EXPOSED event, but there was none. What causes this issue and is there any solution?