[SFML 2.1] Spadek wydajności przy dużej liczbie kafelków

#pragma once
#include <SFML\Graphics.hpp>
#include <string>
#include <vector>



class TileMap
    : public sf::Drawable
     , public sf::Transformable
{
public:
   
    bool load( const std::string & tileset, sf::Vector2u tileSize, const int * tiles, unsigned int width, unsigned int height )
    {
        // wczytanie atlasu tekstur
        if( !m_tileset.loadFromFile( tileset ) )
             return false;
       
        // zmiana rozmiaru tablicy, tak aby pasowała do wielkości mapy
        m_vertices.setPrimitiveType( sf::Quads );
        m_vertices.resize( width * height * 4 );
       
        // zapełnianie vertex array, po jednym na kafel
        for( unsigned int i = 0; i < width; ++i )
        for( unsigned int j = 0; j < height; ++j )
        {
            // pobranie obecnego numeru kafla
            int tileNumber = tiles[ i + j * width ];
           
            // znalezienie jego pozycji na tileset
            int tu = tileNumber %( m_tileset.getSize().x / tileSize.x );
            int tv = tileNumber /( m_tileset.getSize().x / tileSize.x );
           
            // pobranie wskaźnika do bieżącego kafla czworokąta
            sf::Vertex * quad = & m_vertices[( i + j * width ) * 4 ];
           
            // ustawienie 4 rogów
            quad[ 0 ].position = sf::Vector2f( i * tileSize.x, j * tileSize.y );
            quad[ 1 ].position = sf::Vector2f(( i + 1 ) * tileSize.x, j * tileSize.y );
            quad[ 2 ].position = sf::Vector2f(( i + 1 ) * tileSize.x,( j + 1 ) * tileSize.y );
            quad[ 3 ].position = sf::Vector2f( i * tileSize.x,( j + 1 ) * tileSize.y );
           
            // ustawienie 4 współrzędnych tekstury
            quad[ 0 ].texCoords = sf::Vector2f( tu * tileSize.x, tv * tileSize.y );
            quad[ 1 ].texCoords = sf::Vector2f(( tu + 1 ) * tileSize.x, tv * tileSize.y );
            quad[ 2 ].texCoords = sf::Vector2f(( tu + 1 ) * tileSize.x,( tv + 1 ) * tileSize.y );
            quad[ 3 ].texCoords = sf::Vector2f( tu * tileSize.x,( tv + 1 ) * tileSize.y );
        }
       
        return true;
    }
   
private:
   
    virtual void draw( sf::RenderTarget & target, sf::RenderStates states ) const
    {
        // ustawienie przekształceń
        states.transform *= getTransform();
       
        // ustawienie tekstury
        states.texture = & m_tileset;
       
        // narysowanie
        target.draw( m_vertices, states );
    }
   
    sf::VertexArray m_vertices;
    sf::Texture m_tileset;
};

#pragma once
#include <SFML\Graphics.hpp>
#include <vector>

class Player
    : public sf::Drawable
     , public sf::Transformable
{
   
public:
    sf::Sprite sprite;
    sf::Texture texture;
   
    Player( void );
   
    enum Status {
        IDZ,
        STOJ
    };
   
   
    Status getStatus();
   
   
    int x;
    int y;
    float pos_x;
    float pos_y;
    int zycie;
    int sila;
   
   
    void idz( float a, float b );
   
   
    void update();
   
    void stop();
   
   
protected:
    int klatka_animacji;
   
   
private:
    virtual void draw( sf::RenderTarget & target, sf::RenderStates states ) const
    {
        //rysowanie obiektow, które składają się na narysowanie naszej postaci
        target.draw( sprite );
    }
   
    Status status;
   
    sf::Clock anim_clock;
   
    float speed;
    size_t frame;
   
};

#include "Player.h"
#include <Windows.h>
#include "Engine.h"
#include <math.h>
#include <iostream>

#define M_PI 3.14159265358979323846

Player::Player( void )
{
    //Wczytanie tekstury do sprajta i ustawienie sprajta
    texture.loadFromFile( "player.png" );
   
    pos_x = 0;
    pos_y = 500;
   
    sprite.setTexture( texture );
    sprite.setPosition( sf::Vector2f( pos_x, pos_y ) );
   
   
    sprite.setTextureRect( sf::IntRect( 0, 0, 64, 64 ) );
   
    status = STOJ;
   
    frame = 0;
    speed = 1.5;
}

void Player::idz( float a, float b )
{
    status = IDZ;
    sprite.move( a, b );
   
    pos_x += a;
    pos_y += b;
}

void Player::update()
{
    if( anim_clock.getElapsedTime() > sf::seconds( 0.09f ) )
    {
        if( status == STOJ ) return;
       
        if( frame < 7 /*liczba klatek animacji*/ )
             frame++;
        else
             frame = 0; //zapetlanie animacji
       
        sprite.setTextureRect( sf::IntRect( frame * 64, 0, 64, 64 ) );
        //x, y, szerokosc, wysokosc
       
        anim_clock.restart();
    }
}

void Player::stop()
{
    status = STOJ;
    frame = 0;
}