Ouais tu as raison d'ailleurs il y a des développeurs qui utilise mumble donc je suis ok, en plus, j'ai mumble.
Bref il faut que je regarde le fonctionnement de ton framework et que l'ont fasse un tri.
Je vais juste te répondre :
J'ai dit quelque part que ton projet était brouillon (j'espère que tu l'as pas mal pris 
), ce que je voulais dire par là, c'est qu'il est très très complets et que je devrais mettre plusieurs jours afin de réellement comprendre tous tes concepts. Ensuite oui si tu utilises MinGW 4.8 tu as donc les pointeurs intelligents que tu n'utilises pas mais ça c'est pas le plus important pour le moment.
Ensuite ce code : me parait complexe aux 1er abords.
C'est sûr que pour afficher juste une tile, ce code est trop complexe, mais je l'ai juste mis histoire d'avoir juste un aperçu de l'utilisation "globale" du framework, mais pour afficher juste une tile, il y a moyen de faire plus simple sans passer par les classe World et Map.
Ce qui rend le code moins complexe, et c'est ça l'intérêt du framework.
Ce code est juste à utiliser lorsqu'on veut dessiner pleins de choses, comme par exemple, dans ce cas-ci :
Vector2f v2 (view.getCenter().x - view.getSize().x * 0.5f, view.getCenter().y - view.getSize().y * 0.5f);
//Rendu des ombres.
Sprite spriteShadows;
renderTextShadows.setView(view);
renderTextShadows.clear(Color::White);
if (day) {
RectangleShape rect;
rect.setPosition(Vector2f(v2.x, v2.y));
rect.setFillColor((Color(100, 100, 100, 128)));
rect.setSize(Vector2f (view.getSize().x, view.getSize().y));
vector<Shadow*> visibleShadows = World::getCurrentMap()->getVisibleShadows();
for (unsigned int i = 0; i < visibleShadows.size(); i++) {
renderTextShadows.draw(*visibleShadows[i]);
//draw(*visibleShadows[i]->getShadow());
}
renderTextShadows.draw(rect, RenderStates(BlendAdd));
renderTextShadows.display();
//draw(rect, RenderStates(BlendAdd));
}
//Rendu des lumières.
renderTextLights.clear(ambientColor);
if (!day) {
vector<DrawableEntity*> visibleLights = World::getCurrentMap()->getVisibleEntities("E_LIGHT");
for (unsigned int i = 0; i < visibleLights.size(); i++) {
renderTextLights.draw(*visibleLights[i], RenderStates(BlendAdd));
}
renderTextLights.display();
}
//Rendu de la map. (partie visible à l'écran.)
clear();
setView(view);
vector<DrawableEntity*> visibleTiles = World::getCurrentMap()->getVisibleEntities("E_GROUND+E_DECOR");
bool shadowRendered = false;
for (unsigned int i = 0; i < visibleTiles.size(); i++) {
if (day && !shadowRendered && visibleTiles[i]->getZOrder() >= DEFAULT_SHADOW_Z_ORDER) {
Sprite shadows (renderTextShadows.getTexture());
shadows.setPosition(v2.x, v2.y);
draw (shadows, RenderStates(BlendMultiply));
shadowRendered = true;
}
draw(*visibleTiles[i]);
}
if (!day) {
Sprite lights (renderTextLights.getTexture());
lights.setPosition(v2.x, v2.y);
draw (lights, RenderStates(BlendMultiply));
}
Mais ce code est encore un peu brouillon comme tu dis, il faudrait que je définisse une fonction draw dans la classe map et un conteneurs de tiles dans la classe tGround pour dessiner toute la map avec un seul appel à draw. (Ainsi il n'y aura même plus besoin de se soucier des rendertextures.
Et on pourra écrire directement :
currentMap->applyView(currentView);
draw(*currentMap)
Donc je pense que je vais modifier ça.
Je préfère par contre laisser le soin à l'utilisateur d'utiliser la fonction currentMap->checkVisibleEntities(viewRect) que lorsqu'il en a besoin (par exemple lorsqu'on se déplace dans le monde uniquement) car c'est celle là qui bouffe le plus de perfs.
Bref je vais m'occuper de la partie graphique je pense.
Les pointeurs intelligents pour information je n'ai pas besoin de les utiliser, car, je développe en c++ depuis bien longtemps, j'ai suivis des cours, etc..., on utilisait pas les pointeurs intelligent, on a appris à gérer nous même la mémoire en c++ donc..., je n'ai jamais eu besoin d'utiliser les pointeurs intelligent qui gère la mémoire tout seul.
Donc si on ne les utilise pas c'est moins grave, car, on peut s'en passer.
Je dois juste encore rendre certaines classes non copyable, et voir pour les const et puis bien sûr générer la doc à la fin.
Pour mumble je suis là le soir vers 18h ça me va. (Juste le temps que je regarde tout code)
PS : ha oui je dois aussi faire des classes template pour les vecteur et les matrices pour que l'on puisse aussi travailler avec des int, des double, etc... et pas que des flottants.
