Discussion :

[maxia]

Salut,

J'ai lu le tutoriel de fvirtman sur le tilemapping et j'ai essayé de le reproduire sur la SFML 2.1 seulement voila quand je compile le programme cesse de fonctionné avec l'erreur windows et tous .

Voila le code:

main.cpp:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#include <SFML/Audio.hpp>
#include <SFML/Graphics.hpp>
#include <SFML/Window.hpp>
#include "Map.h"
 
#define LARGEUR_TILE 64
#define HAUTEUR_TILE 60
#define NOMBRE_BLOCS_LARGEUR 10
#define NOMBRE_BLOCS_HAUTEUR 10
 
void deplacement();
void vue();
void load_perso();
 
//variables
sf::Event event;
float speed = 4.0;
sf::RenderWindow window;
sf::RectangleShape rectangle(sf::Vector2f(40,40));
sf::RectangleShape rec2(sf::Vector2f(50,100));
sf::View view;
int screenH = 600;
int screenW = 800;
int blockSize = 45;
sf::Texture perso;
sf::Sprite sprite_perso;
char* table[] = {
"0000000000",
"0000000000",
"0000000000",
"0000000000",
"1000000001",
"0000000000",
"0000000000",
"0000000000",
"0034000222",
"0056000000"
};
//end variables
 
int main()
{
    sf::RenderWindow window(sf::VideoMode(LARGEUR_TILE * NOMBRE_BLOCS_LARGEUR, HAUTEUR_TILE * NOMBRE_BLOCS_HAUTEUR, 32), "Titre");
    rectangle.setFillColor(sf::Color::Black);
    rec2.setFillColor(sf::Color::Red);
    rec2.setPosition(900,900);
    sf::Music music;
 
    Map map1("tileset.png");
    map1.drawTuiles(window, table);
 
    load_perso();
    while(window.isOpen())
    {
        while(window.pollEvent(event))
        {
            if(event.type == sf::Event::Closed)
            {
                window.close();
            }
            else if (event.type == sf::Event::KeyPressed)
            {
                deplacement();
            }
        }
 
        vue();
 
        window.clear(sf::Color::Green);
        window.setView(view);
        window.draw(rec2);
        window.draw(sprite_perso);
        window.display();
 
        //window.setPosition(sf::Vector2i(rand()%1000,rand()%1000));
        }
    return EXIT_SUCCESS;
}

Map.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#ifndef MAP_H_INCLUDED
#define MAP_H_INCLUDED
 
#include <SFML/Graphics.hpp>
#include <iostream>
 
class Map
{
    public:
        Map(std::string tileCharge);
        void drawTuiles(sf::RenderWindow &window, char** table);
    private:
        sf::Sprite m_spriteTile;
        sf::Image m_imageTile;
        sf::Texture m_textureTile;
};
 
#endif // MAP_H_INCLUDED

Map.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include "Map.h"
#include <SFML/Graphics.hpp>
 
#define LARGEUR_TILE 24
#define HAUTEUR_TILE 16
 
#define NOMBRE_BLOCS_LARGEUR 15
#define NOMBRE_BLOCS_HAUTEUR 13
 
Map::Map(std::string tileCharge)
{
    if(m_imageTile.loadFromFile(tileCharge))
    {
        m_textureTile.loadFromImage(m_imageTile);
        m_spriteTile.setTexture(m_textureTile);
    }
    else { std::cout << "Erreur chargement tuiles"<<std::endl; }
}
void Map::drawTuiles(sf::RenderWindow &window, char** table)
{
    m_spriteTile.setTexture(m_textureTile);
    for(int i(0); i < NOMBRE_BLOCS_LARGEUR; i++)
    {
        for(int j(0); i < NOMBRE_BLOCS_HAUTEUR; j++)
        {
            m_spriteTile.setTextureRect(sf::IntRect(sf::IntRect((table[i][j] - '0') * LARGEUR_TILE, 0, (table[j][i] - '0') * LARGEUR_TILE + LARGEUR_TILE, HAUTEUR_TILE)));
            m_spriteTile.setPosition(i * LARGEUR_TILE, j * HAUTEUR_TILE);
            window.draw(m_spriteTile);
        }
 
    }
}

Et enfin le tileset:


Merci d'avance de votre aide,

Cordialement,

[LittleWhite]

Bonjour,

Vu que vous avez un plantage, pourquoi ne pas utiliser un débogueur, l'outil le plus approprié dans le monde pour trouver la ligne et la raison du bogue ?
J'imagine que cela plante dès le début ?
Vous avez beaucoup de variables globales qui me font froid dans le dos ... surtout la RenderWindow.

[Cirrus Minor]

Pour le bug -> Debug comme conseillé par LittleWhite.
Mais bon, ta "table" fait 10 x 10, et dans ton double for, tu testes 15 x 13, c'est déjà mal parti !
Je te conseille de passer par une matrice d'entiers plutôt que par ces chaines de caractères.

Et un truc qui ne marche pas dans ton programme: la map est créée, mais sa méthode de rendu n'est pas appelée dans la boucle de jeu, elle ne sera jamais visible comme ça !

[jean_kevin_musclor]

Je vois plein de lacunes dans ton code... il faudrait un de ces 4 que je vous fasse un tutoriel mais j'ai vraiment la flemme, parce qu'en fait le tilemapping c'est sacrément plus compliqué qu'il n'y parait.

1/ les tuiles sont trop grosses pour un écran 800*600, avec ça tu vas être coincé pour afficher du texte par exemple, je dirais maximum 32*32 pixels et encore 16*16 serait mieux.

2/ Vérifie que sfml ne trace pas des sprites hardware. Si tel est le cas, il faut surtout pas tracer en temps réel des tuiles avec un sprite par tuile, car tu vas dépasser la limitation d'instructions de tracé gpu qui doit être limitée à environ 64/128 objets et tu vas gaspiller un max de cpu. A la place il faut pré-blitter les tuiles sur une grosse image d'arrière-plan.

3/ Les dimensions des tuiles doivent être égale à une puissance de deux, c'est indispensable pour faire toutes les opérations binaires (le tilemapping est entièrement basé là dessus), pas seulement pour optimiser, mais par exemple parce que tu vas avoir tôt ou tard besoin de l'opération bitmask (&) et tu n'auras pas l'équivalent avec le modulo (%). Les dimensions de la tilemap c'est pareil, elles doivent être égales à une puissance de deux, pour les mêmes raisons. De toutes façons la plupart des cartes vidéo ne savent rendre une texture proprement et rapidement que si celle-ci a des dimensions puissance deux.

4/ Le tilesheet doit faire 16*16 tuiles... explication: le tilemapping est une technique basée sur l'affichage ascii, donc 255 caractères (tu gardes juste par exemple les majuscules et les nombres, et pour le reste des caractères tu mets tes dessins). Coder l'index d'un caractère devient enfantin il suffit de taper directement le char ascii, et pour coder l'index des dessins on fait ça en hexadécimal afin d'avoir un truc lisible (le premier caractère hexa = la rangée, le second caractère = la colonne).

5/ La table de tuiles doit être codée sur un seul tableau, ensuite tu accèdes une tuile comme ça, par exemple pour une table de 32*32 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

table[colon+row*32];

et en version optimisée avec le binaire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

table[colon+(row<<5)];

Voilà. En appliquant ces dimensions standard ça devrait t'aider à débugger ton algo.

[Cirrus Minor]

2/ Vérifie que sfml ne trace pas des sprites hardware.

Avec SFML, on peut utiliser les tableaux de vertex, et il y a un exemple d'application aux tilemaps ici:
http://www.sfml-dev.org/tutorials/2....emple-tile-map
Donc un seul "draw" pour toute la map.

[jean_kevin_musclor]

Très bien le tableau de vertex, c'est la technique que j'utilise pour rendre les tiles en hardware.

Sinon le plus facile c'est de programmer directement le tilemapping dans le shader mais je ne sais pas si sfml le permet.