[SFML 2.1] Spadek wydajności przy dużej liczbie kafelków
Logowanie
Panel użytkownika
Nazwa użytkownika:
Hasło:
Nie masz jeszcze konta?
Zapomniałem hasła
» Forum » Programowanie » [C++] Wytwarzanie gier 2D

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

Ostatnio zmodyfikowano 2014-09-09 16:48
Autor Wiadomość
informatykos
Temat założony przez niniejszego użytkownika
» 2014-09-08 14:30:18
Zauważyłem coś nowego, kiedy zmniejszę wielkość kafli z 40x40 na 20x20 to praktycznie nie tnie. Czyli to zależy od wielkości kafli rysowanych na scenie a nie ich ilości O_o. Wziąłem kod ze strony domowej SFML'a z Tile map i dorobiłem tylko poruszającą się postać. przy takich ustawieniach jak podam to mi tnie. Czy mógłby ktoś przekompilować i sprawdzić czy jemu też? Bo już nie wiem co robić... Parametry mojego laptopa to: intel i3 2x2.50, radeon 7600M, 6GB RAM, wg. mnie nie powinno ciąć :(

Jak ktoś to odpali i mu nie będzie cięło na słabszym komputerze to normalnie czarodziej jest :)

Jako tekstury używałem:
http://opengameart.org/sites/default/files/player-move.png
http://opengameart.org/content/ground-bush-and-stone-tiles

W tym drugim linku jest paczka a w paczce prev_all.png


Podaje cały kod:

Main:
C/C++
#include <SFML/Graphics.hpp>
#include "TileMap.h"



int main()
{
   
    // create the window
    sf::RenderWindow window( sf::VideoMode( 1280, 760 ), "Tilemap" );
   
   
    sf::Texture texture;
    sf::Sprite sprite;
    texture.loadFromFile( "player.png" );
   
   
    sprite.setTexture( texture );
   
    sprite.setPosition( sf::Vector2f( 100, 100 ) );
   
   
    sprite.setTextureRect( sf::IntRect( 0, 0, 64, 64 ) );
   
   
   
    // define the level with an array of tile indices
    const int level[] =
    {
        0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        0, 1, 0, 0, 2, 0, 3, 3, 3, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        0, 1, 1, 0, 3, 3, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 0, 0, 1, 0, 3, 0, 2, 2, 0, 0, 1, 1, 1, 1, 2, 0,
        0, 0, 1, 0, 3, 0, 2, 2, 0, 0, 1, 1, 1, 1, 2, 0, 0, 0, 1, 0, 3, 0, 2, 2, 0, 0, 1, 1, 1, 1, 2, 0,
        2, 0, 1, 0, 3, 0, 2, 2, 2, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 3, 0, 2, 2, 0, 0, 1, 1, 1, 1, 2, 0,
        0, 0, 1, 0, 3, 2, 2, 2, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 3, 0, 2, 2, 0, 0, 1, 1, 1, 1, 2, 0,
        0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0,
        0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0,
        1, 1, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 1, 0, 3, 0, 2, 2, 0, 0, 1, 1, 1, 1, 2, 0,
        0, 1, 0, 0, 2, 0, 3, 3, 3, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 3, 0, 2, 2, 0, 0, 1, 1, 1, 1, 2, 0,
        0, 1, 1, 0, 3, 3, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 0, 0, 1, 0, 3, 0, 2, 2, 0, 0, 1, 1, 1, 1, 2, 0,
        0, 0, 1, 0, 3, 0, 2, 2, 0, 0, 1, 1, 1, 1, 2, 0, 0, 0, 1, 0, 3, 0, 2, 2, 0, 0, 1, 1, 1, 1, 2, 0,
        2, 0, 1, 0, 3, 0, 2, 2, 2, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 3, 0, 2, 2, 0, 0, 1, 1, 1, 1, 2, 0,
        0, 0, 1, 0, 3, 2, 2, 2, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 3, 0, 2, 2, 0, 0, 1, 1, 1, 1, 2, 0,
        2, 0, 1, 0, 3, 0, 2, 2, 2, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 3, 0, 2, 2, 0, 0, 1, 1, 1, 1, 2, 0,
        0, 0, 1, 0, 3, 2, 2, 2, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 3, 0, 2, 2, 0, 0, 1, 1, 1, 1, 2, 0,
    };
   
    // create the tilemap from the level definition
    TileMap map;
    if( !map.load( "tileset.png", sf::Vector2u( 40, 40 ), level, 32, 18 ) )
         return - 1;
   
    sf::Clock clock;
    sf::Time time;
    float delta_t = 0.0f;
   
    // run the main loop
    while( window.isOpen() )
    {
       
       
        if( sf::Keyboard::isKeyPressed( sf::Keyboard::W ) )
        {
            sprite.move( 0, - 50 * delta_t );
        }
        if( sf::Keyboard::isKeyPressed( sf::Keyboard::D ) )
        {
            sprite.move( 50 * delta_t, 0 );
        }
        if( sf::Keyboard::isKeyPressed( sf::Keyboard::S ) )
        {
            sprite.move( 0, 50 * delta_t );
        }
        if( sf::Keyboard::isKeyPressed( sf::Keyboard::A ) )
        {
            sprite.move( - 50 * delta_t, 0 );
        }
       
       
        // handle events
        sf::Event event;
        while( window.pollEvent( event ) )
        {
            if( event.type == sf::Event::Closed )
                 window.close();
           
        }
       
        // draw the map
        window.clear();
        window.draw( map );
        window.draw( sprite );
        window.display();
       
        time = clock.getElapsedTime();
        delta_t = time.asSeconds();
        clock.restart();
    }
   
    return 0;
}

TileMap.h :

C/C++
#pragma once
#include <SFML/Graphics.hpp>
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 );
   
   
private:
   
    virtual void draw( sf::RenderTarget & target, sf::RenderStates states ) const;
   
   
    sf::VertexArray m_vertices;
    sf::Texture m_tileset;
};

TileMap.cpp :

C/C++
#include "TileMap.h"
#include <SFML/Graphics.hpp>


bool TileMap::load( const std::string & tileset, sf::Vector2u tileSize, const int * tiles, unsigned int width, unsigned int height )
{
    // load the tileset texture
    if( !m_tileset.loadFromFile( tileset ) )
         return false;
   
    // resize the vertex array to fit the level size
    m_vertices.setPrimitiveType( sf::Quads );
    m_vertices.resize( width * height * 4 );
   
    // populate the vertex array, with one quad per tile
    for( unsigned int i = 0; i < width; ++i )
    for( unsigned int j = 0; j < height; ++j )
    {
        // get the current tile number
        int tileNumber = tiles[ i + j * width ];
       
        // find its position in the tileset texture
        int tu = tileNumber %( m_tileset.getSize().x / tileSize.x );
        int tv = tileNumber /( m_tileset.getSize().x / tileSize.x );
       
        // get a pointer to the current tile's quad
        sf::Vertex * quad = & m_vertices[( i + j * width ) * 4 ];
       
        // define its 4 corners
        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 );
       
        // define its 4 texture coordinates
        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;
}
void TileMap::draw( sf::RenderTarget & target, sf::RenderStates states ) const
{
    // apply the transform
    states.transform *= getTransform();
   
    // apply the tileset texture
    states.texture = & m_tileset;
   
    // draw the vertex array
    target.draw( m_vertices, states );
}
P-116750
informatykos
Temat założony przez niniejszego użytkownika
» 2014-09-09 16:48:47
Ok, problem rozwiązany. Dotyczył on zepsutych plików na moim laptopie, jakich - nie wiem ale dzisiaj posprawdzam :P Także jeżeli komuś tnie gra to nich spróbuje na innym komputerze ją skompilować. Tym, którzy próbowali pomóc - dzięki :)
P-116808
1 2 « 3 »
Poprzednia strona Strona 3 z 3  
» Forum » Programowanie » [C++] Wytwarzanie gier 2D
© Wszelkie prawa zastrzeżone 2005-2024