Isométrique & gestion d'objets de map (entités)

[AnselmeSfml]

Bonjour à tous! 

Comme certains le savent peut-être, je travaille depuis 5 mois sur la conception d'un simple moteur isométrique, et beaucoup de fonctionnalités sont déjà prêtes, vous pouvez y jeter un oeil ici:  https://github.com/AnselmeClergeot/Fiso-Engine

J'ai commencé à développer la dernière fonctionnalité primordiale: la gestion d'entités (des objets du monde à cacher derrière les tuiles situées devant eux).

La carte peut être composée de plusieurs étages, chacune étant composée du même nombre de sf::VertexArray (chunks).

Sachant que mes cartes sont composés de sf::VertexArray, il m'est impossible de dessiner directement entre deux tuiles l'objet en question (étant un sf::Sprite). J'ai réfléchis à une méthode : chaque objet redessine les 3 tuiles étant devant lui par-dessus les tuiles d'origine. Ainsi, il se retrouve caché derrière les tuiles qui sont sensés le cacher...

Seulement, cette solution à un gros inconvénient puisque les tuiles redessinées pour cacher l'objet devraient logiquement être cachés derrière les tuiles plus proches... Or ce n'est pas le cas puisque les tuiles de "cachement" sont redessinées par dessus toutes les autres tuiles et se retrouvent ainsi devant les plus proches... Vous avez compris le problème que cela pose? 

Je fais donc appel à la communauté pour savoir quels techniques je pourrait utiliser pour gérer cette fonctionnalité, ou comment palier le problème en question, bien que j'ai comme l'impression que ma méthode sois un peu "ingérable" 

Merci d'avance! 

[Laurent]

A froid, le truc le plus simple auquel je puisse penser c'est d'afficher ton vertex array ligne par ligne. Ce qui te permet d'intercaler des entités entre deux lignes (a priori une même ligne aura une seule profondeur non ?), tout en gardant un nombre relativement faible d'appels à draw().

Sinon il faut aller dans des trucs plus compliqués, avec gestion (hard ou soft) d'une composante Z pour chaque entité, y compris les tuiles du niveau.

[AnselmeSfml]

Merci de ta réponse rapide Laurent, 

Afficher le vertexArray ligne par ligne est une bonne idée, mais il resterait également à cacher l'objet derrière la tuile située à "notre" droite... Tu comprends ? 

Peux-tu m'en dire un peu plus sur la méthode hard? Histoire que ça m'ouvre un peu l'esprit

Merci encore.

[AnselmeSfml]

Pour dessiner le vertexArray ligne par ligne, tu parles en fait de créer des chunks en ligne, de 1 tuile de large?
Ou existe-t-il un moyen de dessiner que certaines parties du vertexArray?

Merci. 

[Laurent]

Afficher le vertexArray ligne par ligne est une bonne idée, mais il resterait également à cacher l'objet derrière la tuile située à "notre" droite... Tu comprends ?

Oui je vois, effectivement la tuile de droite pose problème avec cette méthode.

Peux-tu m'en dire un peu plus sur la méthode hard? Histoire que ça m'ouvre un peu l'esprit

Il s'agit de gérer de la 3D, et de profiter du depth buffer d'OpenGL pour trier les primitives selon leur profondeur. Mais là on est bien entendu largement en dehors des clous de SFML

Pour dessiner le vertexArray ligne par ligne, tu parles en fait de créer des chunks en ligne, de 1 tuile de large?
Ou existe-t-il un moyen de dessiner que certaines parties du vertexArray?

Tu peux dessiner n'importe quelle sous-partie d'un tableau de vertex, pourvue qu'elle soit contigüe en mémoire, avec la fonction draw() qui prend un const sf::Vertex* + une taille.

[AnselmeSfml]

Merci de ta réponse.
Pour la 3D on rentre dans quelque chose de trop compliqué pour ce que j'essaie de réaliser... En revanche je vais me pencher sur le dessin de chunks de manière linéaire, et je me débrouillerai bien pour la tuile de droite. Mais si j'ai une grande carte, ça fera beaucoup d'appel à draw(), non?

[Laurent]

Avec cette méthode, l'avantage c'est que tu peux très facilement ne dessiner que les tuiles visibles à l'écran. Du coup quelque soit la taille de la carte, tu auras toujours le même nombre d'appels à draw() (genre une vingtaine -- largement gérable pour ta carte graphique).

[AnselmeSfml]

Merci encore. 

Donc si j'ai bien compris, je n'ai pas besoin de m'embêter avec plusieurs chunks par couche: un sf::VertexArray par couche suffira puisque je ne dessinerai que les vertex de celui-ci visibles à l'écran. C'est bien ça?
Concernant cette fonction:

void draw (const Vertex *vertices, unsigned int vertexCount, PrimitiveType type, const RenderStates &states=RenderStates::Default)

vertexCount est le nombre de vertex qui suivent *vertices dans le tableau à prendre en compte... C'est bien ça?

Mais au fait, je peux donc grâce à cette méthode dessiner un sf::Sprite entre 4 vertex! Avec une petite algo qui déterminerai à quelle tuile appartient tel ou tel vertex! Ce serait ainsi encore plus simple! Où peut-être m'égarerais-je ? 

Merci encore Laurent.

[Laurent]

vertexCount est le nombre de vertex qui suivent *vertices dans le tableau à prendre en compte... C'est bien ça?

Oui.

Mais au fait, je peux donc grâce à cette méthode dessiner un sf::Sprite entre 4 vertex! Avec une petite algo qui déterminerai à quelle tuile appartient tel ou tel vertex! Ce serait ainsi encore plus simple! Où peut-être m'égarerais-je ?

Je ne suis pas sûr de comprendre ce que tu voudrais faire, ni en quoi ça pourrait être "plus simple". Peux-tu développer ?

[AnselmeSfml]

Partant du principe qu'on peux dessiner quand on veux la partie du vertexArray qu'on veux, je pourrais (pour faire court) dessiner (d'un coup) les vertex ne cachant pas mon sprite, mon sprite, et ensuite les vertex le cachant... (Ce à l'aide d'une petite algo de rien du tout).

En gros, cette technique + culling des vertex invisibles à l'écran = plus besoin de plusieurs vertexArray par couches, si?

[Laurent]

Oui en effet, comme ça tu n'aurais que 3 appels à draw(), mais... tu n'as toujours qu'un seul sprite en plus du niveau ?? Parce qu'avec plusieurs dizaines de sprites ça commence à devenir compliqué (quoique...).

[AnselmeSfml]

Bien sûr, comme tu as dis, plusieurs objets pourront faire partie du monde, mais je ne craint pas une éventuelle baisse de perfos avec cette méthode. Je vais donc tester cette technique premièrement, et si je me rend compte que c'est finalement trop vorace en CPU, je ferais la technique du dessin du vertexArray par lignes et me débrouillerait pour la "tuile de droite".

En tout cas merci énormément de ton aide, grâce à toi je vais pouvoir continuer le développement de mon chouchou.   

Dernière petite question : 
Le dessin d'un gros vertexArray peut-il s'avérer plus vorace que le dessin de plein petits éléments?  Ou ce qui compte c'est juste d'avoir le nombre d'appel à draw() le plus faible possible?

Encore merci pour tout. 

[Laurent]

En gros, le nombre d'appels à draw() est un bon cran au-dessus de tout le reste. Si tu ne dois avoir qu'une seule préoccupation, ça doit être ça.

Mais bon évidemment chaque configuration est différente, donc n'hésite pas à faire des tests quoiqu'il arrive.

[AnselmeSfml]

D'accord, je m'en souviendrais.

Merci encore pour tout.