[SFML 2.X] Przyśpieszyć ładowanie tekstur

void save_textures_as_packet() {
   
    std::vector < std::string > pathfiles;
    for( auto & single: singleTextures ) {
        pathfiles.push_back( single->name );
    }
   
    std::ofstream packet( "assets\\atex.assets", std::ios::binary );
   
    uint32_t filesCount = pathfiles.size();
    packet.write( reinterpret_cast < char * >( & filesCount ), sizeof( filesCount ) ); // 4 bajty
   
    for( auto & path: pathfiles ) {
        std::ifstream file( "assets\\" + path + ".png", std::ios::binary );
       
        if( !file ) {
            //std::cerr << "Nie można otworzyć pliku: " << path << "\n";
            continue;
        }
       
       
        //string filename = std::filesystem::path(path).filename().string();
        string filename = path;
        cout << filename << "\n";
       
        uint8_t nameLength = filename.size();
       
        file.seekg( 0, std::ios::end );
        uint32_t fileSize = file.tellg();
        file.seekg( 0 );
       
        std::vector < char > buffer( fileSize );
        file.read( buffer.data(), fileSize );
       
        // save the data
        packet.write( reinterpret_cast < char * >( & nameLength ), sizeof( nameLength ) ); // 1 bajt
        packet.write( filename.c_str(), nameLength ); // N bajtów
        packet.write( reinterpret_cast < char * >( & fileSize ), sizeof( fileSize ) ); // 4 bajty
        packet.write( buffer.data(), fileSize ); // X bajtów
       
    }
   
    packet.close();
}

void loadTexturesFromPacket() {
    std::ifstream packet( "assets\\atex.assets", std::ios::binary );
    if( !packet ) {
        //std::cerr << "Nie można otworzyć pliku pakiet.bin\n";
        return;
    }
   
    uint32_t fileCount;
    packet.read( reinterpret_cast < char * >( & fileCount ), sizeof( fileCount ) );
   
    std::vector < SingleTexture * > textures;
    for( uint32_t i = 0; i < fileCount; ++i ) {
       
        uint8_t nameLength;
        packet.read( reinterpret_cast < char * >( & nameLength ), sizeof( nameLength ) );
       
        std::string fileName( nameLength, '\0' );
        packet.read( & fileName[ 0 ], nameLength );
        //std::cout << "name: " << fileName << "\n";
        uint32_t fileSize;
        packet.read( reinterpret_cast < char * >( & fileSize ), sizeof( fileSize ) );
       
        std::vector < char > buffer( fileSize );
        packet.read( buffer.data(), fileSize );
       
        sf::Image img = sf::Image();
        if( !img.loadFromMemory( buffer.data(), buffer.size() ) ) {
            std::cerr << "Nie udało się załadować obrazka: " << fileName << "(" << i << ")" << "\n";
            continue; // pomiń ten plik
        }
       
        SingleTexture * t = new SingleTexture( fileName, img, 0, 0 );
        textures.push_back( t );
    }
   
   
    packet.close();
   
    std::cout << "wczytano " << textures.size() << " tekstur\n";
    singleTextures = textures;
}

if( type == 1 ) {
   
    uint16_t tile_width, tile_height, cx, cy;
   
    packet.read( reinterpret_cast < char * >( & tile_width ), sizeof( tile_width ) );
    packet.read( reinterpret_cast < char * >( & tile_height ), sizeof( tile_height ) );
    packet.read( reinterpret_cast < char * >( & cx ), sizeof( cx ) );
    packet.read( reinterpret_cast < char * >( & cy ), sizeof( cy ) );
   
    uint32_t fileSize;
    packet.read( reinterpret_cast < char * >( & fileSize ), sizeof( fileSize ) );
   
    std::vector < char > buffer( fileSize );
    packet.read( buffer.data(), fileSize );
   
    sf::Image img = sf::Image();
    if( !img.loadFromMemory( buffer.data(), buffer.size() ) ) {
        std::cerr << "Nie udało się załadować obrazka: " << "assets\\" + fileName + ".png" << "(" << i << ")" << "\n";
        continue; // pomiń ten plik
    }
   
    short image_width = img.getSize().x;
    short image_height = img.getSize().y;
   
    //cout << image_width << "x" << image_height << "\n";
   
    int counter = 0;
   
    for( short y = 0; y < image_height; y += tile_height )
    for( short x = 0; x < image_width; x += tile_width ) {
       
        // create tile - fragment of texture
        sf::Image tile;
        tile.create( tile_width, tile_height );
        tile.copy( img, 0, 0, sf::IntRect( x, y, tile_width, tile_height ) );
       
        bool isEmpty = true;
        for( short yy = 0; yy < tile_height && isEmpty; yy++ ) {
            for( short xx = 0; xx < tile_width; xx++ ) {
                if( tile.getPixel( xx, yy ) != sf::Color::Transparent ) {
                    isEmpty = false;
                    break;
                }
            }
        }
       
        if( isEmpty )
             continue;
       
       
        // searching - exist doubles or no
        bool existed = false;
       
        for( short i = 0; i < textures.size(); i++ ) {
            sf::Image img = textures[ i ]->texture->copyToImage();
           
            if( areImagesEqual( tile, img ) ) {
                existed = true;
                //cout << "exits now\n";
                break;
            }
        }
       
        // if no exist then add
        if( existed == false ) {
           
            SingleTexture * new_texture = new SingleTexture( fileName + "_" + to_string( counter ), tile, cx, cy );
            //cout << "created texture: " << pathfile + "_" + to_string(counter) << "\n";
            textures.push_back( new_texture );
           
            counter += 1;
           
        }
       
    }
   
    //std::cout << "wczytano set: " << fileName << "\n";
}