Messages

1

Graphique / Re : Performance grande carte ( map - tileset )

« le: Juillet 21, 2016, 02:47:21 pm »

Ok je note je test ça se soir.

Je connaissait pas le texture rect

Merci l'ami

2

Système / Re : Rendu et logique dans des threads séparés

« le: Juillet 20, 2016, 11:52:12 pm »

Tu as trouvé tes réponses ?

3

Graphique / Performance grande carte ( map - tileset )

« le: Juillet 20, 2016, 11:26:58 pm »

Bonsoir,

Je viens demander vos points de vues.

Pour afficher une grande carte, j'ai un object Map qui herite de sf::Sprite.

Mais Tile font 128 * 128

Pour afficher les textures, c'est ok tout vas bien nikel


Mais le truc que je comprend pas c'est quand je joue avec la taille de mes cartes

25*25 => 1000FPS

50*50 => 300FPS

100*100 => 100FPS

J'utilise une sf::view avec un zoom de 4 pour faire comme du 32 * 32

class MapGame : public sf::Sprite

std::vector<std::shared_ptr<MapTile>> Tiles;

 

this->texture->create(this->width, this->height);

        for (int y = 0; y < this->nbTitleHeight; y += 1)
        {
                for (int x = 0; x < this->nbTitleWidth; x += 1)
                {
                        this->texture->update(*MonObjectImage, x * this->tileWidth, y * this->tileHeight);
                }
        }

        this->setTexture(*this->texture);
 

Quand je suis en zoom 1 les FPS sont bien meilleur


Je fais les même test avec un tile de 32 * 32 - les performance sont bien meilleure

500 * 500 => 200 FPS


Donc si je veux faire des grande map je dois travailler avec des petit tiles ?

Il y mieux que Sf:Sprite pour afficher une carte ?


Enfin voilà quoi , je sais pas si c'est normal ou si c'est moi qui m’inquiète pour rien.

Merci à tous et longue vie a SFML

4

Général / Re : Suppréssion element dans tableau de pointeur

« le: Mars 09, 2015, 06:18:50 pm »

Yesssss

trop fort mec


Milles merci , Ça marche nikel !!!!


@+ bonne soirée


ps : OK promis je reviens seulement si c'est en rapport avec SFML

5

Général / Suppréssion element dans tableau de pointeur [résolue]

« le: Mars 09, 2015, 03:23:55 pm »

Bonjour à tous.

J'ai un gros problème.

Dans mon algo, j'ai un vector de shared_prt.

vector<shared_ptr<AcmeEntity>> AcmeEntity;
 

Ras concernant l'insertion et l'itération

/* insertion */
auto acme = std::make_shared<AcmeEntity>();
AcmeEntity.push_back(acme);

/* itération */
for (auto&& acme: AcmeEntity)
{
  acme->doBlaBla();
}
 

L’objet a un attribut bool qui passe a true quand on peut le supprimer

for (auto&& acme: AcmeEntity)
{
      if(acme->deleteMe())
     {
           //comment je delete && j'ai essayé
           AcmeEntity.erase(acme); //marche pas
      }
}

 

J'ai essaye d'autre technique avec :

AcmeEntity.erase(start, end, fonction); // plantage totale quand je passe
 

Pareil

for (auto&& item = AcmeEntity.begin(); item != AcmeEntity.end();)
        {
                if((*item)->alive == false)
                {
                        AcmeEntity.erase(item);
                }
        }
//replantage de fou
 

et encore Pareil


Si quelqu'un a déjà eut se problème ou veux bien m'aider je lui en serai très très reconnaissant.


Merci d'avance



ps: Mon algo fonctionne quand même mais je trouve ça dommage de laisser des objets inactif dans mon tableau



Merci @ vous

6

Graphique / Re : Tableau de VertexArray

« le: Mars 06, 2015, 07:01:34 pm »

Bon c'est Ok !

Dur la semaine..

Finalement, j'ai tranché pour du :

Mon tableau de Wall (2011)

vector<shared_ptr<Wall>> borders;

 

Wall.h

#pragma once

#include <SFML/Graphics.hpp>
#include "Utility.h"

using namespace std ;
using namespace sf ;

class Wall
{
        public:
                Wall() ;
                Wall(Vertex point1, Vertex point2);
                VertexArray getWall();

        private:
                VertexArray* wall;
};
 

Wall.cpp

#include "Wall.h"

Wall::Wall()
{

}

Wall::Wall(Vertex _point1, Vertex _point2)
{
        Vertex point1 = _point1;
        Vertex point2 = _point2;
        wall = new VertexArray(sf::PrimitiveType::Lines, 2);
        wall->append(point1);
        wall->append(point2);

}


VertexArray Wall::getWall()
{
        return *wall;
}


/* Juste que le truc que j'avais pas compris c'était ça ! =>  *wall; */

 

Mon code dans Game.cpp si jamais.

/* je crée ici */
auto lineTop = std::make_shared<Wall>(Vertex(map->topLeft, Color::White), Vertex(map->topRight, Color::White));
/* j'insére la  */
borders.push_back(lineTop);

/* Et j'affiche :) */
for (auto&& wall : borders)
{
        window->draw(wall->getWall());
}


 

Merci quand même G.
Peut être j'aiderai quelqu'un ... qui sait ?


je pense que j'avais juste envie de parler à des gens :p


Sur ceux bon week-end a tous

@+

7

Graphique / Tableau de VertexArray

« le: Mars 06, 2015, 03:09:46 pm »

Bonjour à tous,

Tous nouveau sur le forum et dans le monde de la programmation C++.
( Je suis web dev PHP/Symfony2)

Donc my problem is:
Je ne comprend pas comment je peux faire/ je suis totalement pommé....

Je m'explique

J'ai compris le principe des shapes etc.( ca marche du feu de dieu par rapport a canvas
Je veux déporter mon traitement dans mon objet Game.
Jusqu'ici tous vas bien.
Mon problème est que je veux stocker dans cette objet Game ma bordure du jeu .
En clair 4 Object VertexArray dans un tableau de VertexArray.
Pour pouvoir créer mes bordures du jeu en init et ne faire que les dessiner dans le refresh.

Or ça fais 1 journée que j'essaye mais j'ai toujours des problème de mémoire ou de cast !

Si une bonne âme charitable peux m'aider.
Je vous joint le code qui me pose problème :
 GAME::CreateBorder()
 GAME::generateBorder()

En sachant que je veux juste comprendre le principe de comment faire un tableau de tableau de vertexArray.

D'avance Merci !


main.cpp

#include <SFML/Graphics.hpp>
#include "ItemGame.h"
#include "Game.h"
#include "Utility.h"

using namespace sf;
using namespace std;


int main()
{
        Game game;
        game.init();
        game.run();

    return 0;
}
 

Game.h

#ifndef GAME_ZIM
#define GAME_ZIM

#include <SFML\Graphics.hpp>
#include "Map.h"
#include "Utility.h"
#include "ItemGame.h"
#include "Wall.h"
#include <memory>

using namespace sf;
using namespace std;

const int screen_w = 1200, screen_h = 900, tile_w =10, tile_h = 10, nb_elements = 1, nb_barriers = 5, nb_border = 4;

class Game
{
        public:
                Game();
                ~Game();
                Map *map;
                RenderWindow* window;
                ItemGame* itemGames[nb_elements];
                vector<Wall*> wall;
                void Game::init();
                void Game::generateMap();
                void Game::createBorder();
                void Game::generateBorder();
                void Game::updateView();
                void Game::refresh();
                void Game::run();

                void addWall(Wall *_wall);
};

#endif GAME_ZIM
 

game.cpp

#include "Game.h"


using namespace sf;
using namespace std;


Game::Game()
{
        ContextSettings antialiasing;
        antialiasing.antialiasingLevel = 32;
        window = new RenderWindow(VideoMode(screen_w, screen_h), "SFML works!", Style::Default, antialiasing);
        window->setFramerateLimit(60);
}


Game::~Game()
{

}

void Game::init()
{
        this->createBorder();
}

void Game::generateMap()
{
        map = new Map(screen_w, screen_h, tile_w, tile_h);

}

void Game::addWall(Wall *_wall)
{
        wall.push_back(_wall);
}

void Game::createBorder()
{
        VertexArray *lineBottom;
        Wall *wall;
        lineBottom = new VertexArray(Lines, 2);
        lineBottom->append(Vertex(this->map->bottomLeft, Color::White));
        lineBottom->append(Vertex(this->map->bottomRight, Color::White));      

        wall = new Wall();
        wall->wall = lineBottom;

}

void Game::generateBorder()
{
        for(int i(0); i < wall.size(); i++)
        {
                window->draw(wall[i]->wall);
        }
}


void Game::run()
{
        while (window->isOpen())
    {
        sf::Event event;
        while (window->pollEvent(event))
        {
            if (event.type == Event::Closed)
                window->close();
        }

                this->refresh();
        }
}

void Game::updateView()
{
        generateBorder();
}

void Game::refresh()
{      
        window->clear();
       
        updateView();

        window->display();
}

 

Wall.h

#pragma once

#include <SFML/Graphics.hpp>
#include "Utility.h"

using namespace std ;
using namespace sf ;

class Wall
{
        public:
                Wall() ;
                Wall(VertexArray const& _wall);
                VertexArray getWall();
                VertexArray wall;
};

 

wall.cpp

#include "Wall.h"

Wall::Wall()
{

}

Wall::Wall(VertexArray const& _wall)
{
        wall = _wall;
}


VertexArray Wall::getWall()
{
        return wall;
}