Messages

1

Graphique / Re : Dessiner un grand nombre de tiles grâce à un VertexArray

« le: Juin 03, 2015, 03:46:04 pm »

Un moyen de faire pourrait être de fusionner les tuiles qui sont cotes à cotes, et hormis le cas extrême où l'utilisateur place une tuile une fois sur deux, je pense que ça peut grandement améliorer les performances et en plus tu auras moins de mémoire utilisée.

En gros quand tu as par exemple 2 tuiles cotes à cotes (ça peut être plus) tu crées à la place une tuile de 32*64 px.
Par contre il faudra aussi faire une répétition de la texture pour garder le même aspect, et si tu mets toutes tes textures dans un seul fichier image ça risque d'être problématique par contre (à moins qu'on puisse quand même répéter une partie de la texture ? ).

2

Graphique / Re : [Résolu] Transparence "uniforme" pour deux images transparentes

« le: Février 18, 2014, 11:35:12 pm »

Désolé pour le retard, j'étais plus trop sur mon projet ces derniers temps.

Je suis désolé mais j'ai un peu de mal à comprendre ta méthode.
Et à un moment tu parles de modifier la transparence sur une partie du sprite seulement. Le problème c'est que modifier la transparence d'un sprite entier est possible, mais pas un groupe précis de pixel sur ce sprite.

3

Graphique / Re : Erreur C2228 Visual Studio 2013

« le: Janvier 19, 2014, 11:15:27 pm »

A la place de

switch (event.type.code == Keyboard::Z)

essaye

switch (event.key.code == Keyboard::Z)

4

Graphique / Re : Transparence "uniforme" pour deux images transparentes

« le: Janvier 16, 2014, 11:01:46 pm »

Merci pour vos réponses

G. : le problème c'est que je dois afficher les cubes dans un ordre précis, sinon il risque d'y avoir des problèmes d'affichage.

kimci86 : je pensais en cubes, et pas en face. Effectivement afficher par face rendra la transparence plus jolie normalement. Et je n'ai qu'à modifier une petite portion de code avec cette méthode en plus ^^

5

Graphique / [Résolu] Transparence "uniforme" pour deux images transparentes

« le: Janvier 16, 2014, 10:21:37 pm »

Bonjour à tous.

Je me trouve face à un petit problème.
Je développe actuellement un jeu en 2D isométrique où le terrain est composé de cubes. Un personnage peut se déplacer sur ce terrain, mais se retrouve parfois caché par certains cubes.

La chose que je voudrais donc mettre en place, c'est d'afficher les cubes devant le personnage avec une certaine transparence. Utilisant les VertexArray, je n'ai qu'à faire :

vertex.color = sf::Color(255, 255, 255 , 100);

Ca fonctionne bien, les cubes sont bien transparents, mais voilà ce que j'ai :
http://img15.hostingpics.net/pics/870103Capture.png

Bien que ce rendu ne m'étonne pas, j'aimerais avoir une transparence générale plus "uniforme", que la superposition d'images ne "détériore" pas le niveau de transparence (car sur l'image il n'y a qu'une épaisseur de cubes, mais parfois il y en a tellement que le rendu n'est pas très propre à mon gout).

Ma question est donc de savoir si c'est possible, sachant que j'affiche le terrain cube par cube. Autrement quels astuces me donneriez vous pour ce type de problème (personnage caché par des éléments du décor) ?
Merci d'avance.

6

Graphique / Re : Limite de la taille des textures avec les VertexArray

« le: Août 23, 2013, 05:57:42 pm »

Ok merci

7

Graphique / Re : Limite de la taille des textures avec les VertexArray

« le: Août 23, 2013, 05:31:10 pm »

Ah je n'avais pas vu ce topic. Si jamais je tombe sur une solution je n'hésiterais pas à la poster Mais là j'ai vraiment pas d'idée.
Je vais donc suivre de prêt ton topic

8

Graphique / Limite de la taille des textures avec les VertexArray

« le: Août 23, 2013, 04:26:54 pm »

Bonjour.

Je viens poster ici car je risque d'avoir un petit souci dans la suite du développement de mon petit jeu.
Le jeu est une sorte de jeu sandbox (comme Minecraft/Terraria...) en 2D isométrique. Il y a différents types de blocs disponibles avec chacun une texture différente.

Pour augmenter les performances de mon jeu j'ai adopté des VertexArray et laissé de coté les sf::Sprite. Mon souci est le suivant : j'ai entendu dire que la taille limite d'une texture était généralement 1024*1024. Cela signifie que mon jeu ne pourrait supporter qu'une trentaine de types de blocs différents. Or j'ai prévu d'en supporter beaucoup plus.

Je voudrais donc savoir si pour un VertexArray donné, il y a moyen de lui "associer" plusieurs textures, ou sinon quel solution alternative me proposez vous (sachant que je souhaite un maximum de fluidité et que j'affiche beaucoup de blocs à l'écran) ?

Merci d'avance

9

Système / Re : [SFML 2] sf::Thread - Arrêt temporaire du thread principal

« le: Mai 11, 2013, 08:05:57 pm »

Ah oui effectivement. Merci ^^
J'ai donc sortit le launch de la boucle, et j'ai mis une boucle while dans la méthode pour l'exécuter en continu. A la fin de chaque tour de boucle je mets un sf::sleep(sf::seconds(1)); pour soulager le processeur.

La méthode est bien exécuté, le sleep fonctionne, mais le jeu est complètement bloqué, comme si le thread principal était en pause. Et ce problème ne survient pas quand les opérations lourdes sont effectuées.
D'où pourrait donc venir le problème ?

EDIT : j'ai juste mis un sf::sleep(sf::seconds(1)); dans la méthode genererNouvellesRegions, et là l'affichage se met à jour toutes les secondes (donc ça fait un peut comme si le jeu ramait), alors que l'affichage s'effectue normalement dans le premier thread. C'est comme si le sleep s'effectuait dans le thread principal.
Je précise que je n'appelle pas genererNouvellesRegions autrement que par le sf::Thread.

EDIT 2 : Désolé pour le EDIT du dessus c'est bon j'ai corrigé le problème (pas placé le launch au bon endroit enfaite  ). Autrement plus de problème

10

Système / [Résolu] [SFML 2] sf::Thread - Arrêt temporaire du thread principal

« le: Mai 11, 2013, 06:19:29 pm »

Bonjour à tous.
Dans mon jeu, quand par exemple le personnage est proche de la fin du terrain, je dois charger le terrain devant lui et supprimer le terrain qu'il y a derrière. L'opération en question doit enregistrer dans plusieurs fichiers environ 800000 entiers et accéder à plus de 6 millions de variables, ce qui fait que lors de ce chargement le rafraichissement de l'affichage s'arrête pendant une ou deux secondes.

Pour éviter cet arrêt assez gênant j'ai donc commencé à mettre en place un thread secondaire permettant de faire ce chargement en fond.
Mais il y a un problème : le moment d'arrêt est toujours présent quand le jeu doit charger le nouveau morceau de terrain. Pourtant je crée bien un sf::Thread avant le while (fenetre.isOpen()) dans le main.
Autre information : le thread secondaire exécute la méthode d'un objet (créé lui aussi au début du main).

Je voudrais donc savoir si il est normal que le thread principal est affecté quand le thread secondaire effectue de lourdes opérations ?
Merci d'avance.

PS : voilà comment j'utilise les sf::Thread :

int main()
{
        // initialisations

        Monde monde(fenetre, vue, std::round(nombreBlocsCotes + 10));
        sf::Thread thread(&Monde::genererNouvellesRegions, &monde);

        // initialisations

        while (fenetre.isOpen())
        {
                // gestion des évenements
               
                thread.launch();

                // affichage et autres opérations
        }

        return EXIT_SUCCESS;
}

11

Graphique / Re : [SFML 2] Surconsommation anormale du processeur

« le: Mars 31, 2013, 11:53:18 am »

D'abord merci pour ta réponse.
J'ai oublié de le préciser, mais en effet je limite les FPS de mon jeu, avec setFramerateLimit(60).

12

Graphique / Re : [SFML 2] Surconsommation anormale du processeur

« le: Mars 30, 2013, 08:31:48 pm »

Si jamais vous voulez plus d'information sur quoi que ce soit, demandez.

Autrement si vous ne voyez pas d'où vient le problème, pourriez vous me dire comment gérer au mieux un VertexArray contenant beaucoup de Vertex ?
Pour le moment, ce que je fais c'est, à chaque tour de boucle, de vider le VertexArray, puis de recréer tous les Vertex à afficher. Je fais ça car il y a très souvent des changements dans l'affichage. Par exemple des éléments sont à placer avant d'autres dans certains cas, des objets (des personnages pour mon jeu) peuvent arriver à tout moment, et être placer entre certaines autres textures en fonction de leur position.

Donc recréer tout à chaque fois puis effacer, ça doit surement demander beaucoup. Y aurait-il donc un moyen plus efficace pour gérer l'affichage de mes sprites ?

Merci d'avance.

13

Graphique / [SFML 2] Surconsommation anormale du processeur

« le: Mars 24, 2013, 04:06:53 pm »

Bonjour à tous.

Je viens encore vous voir car j'ai un petit souci de performance avec les sf::VertexArray.
Je tiens d'abord à préciser que j'utilise la SFML 2, et que le problème est présent quelque soit le PC.
Voici tout d'abord le code qui ne fonctionne pas :

for (int x = m_nombreBlocsCotes - 1; x >= 0; --x)
        for (int y = 0; y < m_nombreBlocsCotes; ++y)
                for (int z = 0; z < m_nombreBlocsHauteur; ++z)
                        if (x + y < m_nombreBlocsCotes && x + y >= 0 && !blocsAffiches[z][x][y + x])
                                m_blocsAffiches[z][x + y][y]->afficher(m_blocsAffiches, m_rendu, coordonneesPixelsBords);
for (int y = 0; y < m_nombreBlocsCotes; ++y)
        for (int x = 0; x < m_nombreBlocsCotes - y; ++x)
                for (int z = 0; z < m_nombreBlocsHauteur; ++z)
                        if (x + y < m_nombreBlocsCotes && x + y >= 0 && !blocsAffiches[z][x][y + x])
                                m_blocsAffiches[z][x][x + y]->afficher(m_blocsAffiches, m_rendu, coordonneesPixelsBords);
 

Après quelques tests j'ai trouvé que le problème venait des lignes "m_blocsAffiches[z][x + y]->afficher(m_blocsAffiches, m_rendu, coordonneesPixelsBords);" et "m_blocsAffiches[z][x + y][y]->afficher(m_blocsAffiches, m_rendu, coordonneesPixelsBords);", très souvent appelés. Si j'enlève ces lignes, plus de problème de performance.
Mais le plus étrange est que avec le code suivant, il n'y a pas de problème de performance alors que j'appelle la fonction afficher(m_blocsAffiches, m_rendu, coordonneesPixelsBords)  autant de fois que le code du dessus :

for (int z = 0; z < m_nombreBlocsHauteur; ++z)
      for (int x = 0; x < m_nombreBlocsCotes; ++x)
         for (int y = 0; y < m_nombreBlocsCotes; ++y)
            m_blocsAffiches[z][x][y]->afficher(m_blocsAffiches, m_rendu, coordonneesPixelsBords);

Voici le code de la fonction afficher() :

void Bloc::afficher(const std::vector<std::vector<std::vector<Bloc*>>>& blocs, sf::VertexArray& rendu, float coordonneesPixelsBords[4])
{
        // tests pour savoir si il faut afficher le bloc
        int nombreBlocsCotes = blocs[0].size();
        if (m_identifiant < 1 || m_coordonneesPixels.x <= coordonneesPixelsBords[0] || m_coordonneesPixels.x >= coordonneesPixelsBords[1] || m_coordonneesPixels.y <= coordonneesPixelsBords[2] || m_coordonneesPixels.y >= coordonneesPixelsBords[3])
                return;
        else
        {
                int coordonnneesOrigine[2] = {blocs[0][0][0]->m_coordonnees.x, blocs[0][0][0]->m_coordonnees.y};

                int nombreBlocsHauteur = blocs.size();
                bool blocsAffichesDevant[7];
                blocsAffichesDevant[0] = m_coordonnees.x != coordonnneesOrigine[0] && blocs[m_coordonnees.z][m_coordonnees.x - coordonnneesOrigine[0] - 1][m_coordonnees.y - coordonnneesOrigine[1]]->m_identifiant != 0;       // entité gauche (couche de l'entité)
                blocsAffichesDevant[1] = m_coordonnees.x != coordonnneesOrigine[0] && m_coordonnees.y != nombreBlocsCotes + coordonnneesOrigine[1] - 1 && blocs[m_coordonnees.z][m_coordonnees.x - coordonnneesOrigine[0] - 1][m_coordonnees.y - coordonnneesOrigine[1] + 1]->m_identifiant != 0;       // entité devant (couche de l'entité)
                blocsAffichesDevant[2] = m_coordonnees.y != nombreBlocsCotes + coordonnneesOrigine[1] - 1 && blocs[m_coordonnees.z][m_coordonnees.x - coordonnneesOrigine[0]][m_coordonnees.y - coordonnneesOrigine[1] + 1]->m_identifiant != 0;        // entité droite (couche de l'entité)
                blocsAffichesDevant[3] = m_coordonnees.z < nombreBlocsHauteur - 1 && m_coordonnees.x != coordonnneesOrigine[0] && blocs[m_coordonnees.z + 1][m_coordonnees.x - coordonnneesOrigine[0] - 1][m_coordonnees.y - coordonnneesOrigine[1]]->m_identifiant != 0;       // entité gauche (couche au dessus de l'entité)
                blocsAffichesDevant[4] = m_coordonnees.z < nombreBlocsHauteur - 1 && m_coordonnees.y != nombreBlocsCotes + coordonnneesOrigine[1] - 1 && blocs[m_coordonnees.z + 1][m_coordonnees.x - coordonnneesOrigine[0]][m_coordonnees.y - coordonnneesOrigine[1] + 1]->m_identifiant != 0;        // entité droite (couche au dessus de l'entité)
                blocsAffichesDevant[5] = m_coordonnees.z < nombreBlocsHauteur - 1 && blocs[m_coordonnees.z + 1][m_coordonnees.x - coordonnneesOrigine[0]][m_coordonnees.y - coordonnneesOrigine[1]]->m_identifiant != 0;        // entité dessus (couche au dessus de l'entité)
                blocsAffichesDevant[6] = m_coordonnees.z < nombreBlocsHauteur - 2 && blocs[m_coordonnees.z + 2][m_coordonnees.x - coordonnneesOrigine[0]][m_coordonnees.y - coordonnneesOrigine[1]]->m_identifiant != 0;        // entité dessus (couche encore au dessus de l'entité)
                if (((blocsAffichesDevant[0] && blocsAffichesDevant[2]) || blocsAffichesDevant[1]) && blocsAffichesDevant[3] && blocsAffichesDevant[4] && (blocsAffichesDevant[5] || blocsAffichesDevant[6]))
                        return;
        }

        // affichage du bloc
        for (int i = 0; i < 4; i++)
                rendu.append(m_textures.sommetTextureBloc(m_identifiant, i, m_coordonneesPixels));

        //affichage des lignes de séparation de blocs
        int coordonnneesOrigine[2] = {blocs[0][0][0]->m_coordonnees.x, blocs[0][0][0]->m_coordonnees.y};
        int nombreBlocsHauteur = blocs.size();
        bool blocsAfficheesACote[9];
        blocsAfficheesACote[0] = m_coordonnees.y == coordonnneesOrigine[1] || blocs[m_coordonnees.z][m_coordonnees.x - coordonnneesOrigine[0]][m_coordonnees.y - coordonnneesOrigine[1] - 1]->m_identifiant != 0;       // bloc à gauche (derrière)
        blocsAfficheesACote[1] = m_coordonnees.x == nombreBlocsCotes + coordonnneesOrigine[0] - 1 || blocs[m_coordonnees.z][m_coordonnees.x - coordonnneesOrigine[0] + 1][m_coordonnees.y - coordonnneesOrigine[1]]->m_identifiant != 0;        // bloc à droite (derrière)
        blocsAfficheesACote[2] = m_coordonnees.z > 0 && blocs[m_coordonnees.z - 1][m_coordonnees.x - coordonnneesOrigine[0]][m_coordonnees.y - coordonnneesOrigine[1]]->m_identifiant != 0;     // bloc en bas
        blocsAfficheesACote[3] = m_coordonnees.z > 0 && m_coordonnees.x != coordonnneesOrigine[0] && blocs[m_coordonnees.z - 1][m_coordonnees.x - coordonnneesOrigine[0] - 1][m_coordonnees.y - coordonnneesOrigine[1]]->m_identifiant != 0;    // bloc en bas à gauche
        blocsAfficheesACote[4] = m_coordonnees.z > 0 && m_coordonnees.y != nombreBlocsCotes + coordonnneesOrigine[1] - 1 && blocs[m_coordonnees.z - 1][m_coordonnees.x - coordonnneesOrigine[0]][m_coordonnees.y - coordonnneesOrigine[1] + 1]->m_identifiant != 0;     // bloc en bas à droite
        blocsAfficheesACote[5] = m_coordonnees.x == coordonnneesOrigine[0] || m_coordonnees.y == coordonnneesOrigine[1] || blocs[m_coordonnees.z][m_coordonnees.x - coordonnneesOrigine[0] - 1][m_coordonnees.y - coordonnneesOrigine[1] - 1]->m_identifiant != 0;      // bloc à gauche
        blocsAfficheesACote[6] = m_coordonnees.x == nombreBlocsCotes + coordonnneesOrigine[0] - 1 || m_coordonnees.y == nombreBlocsCotes + coordonnneesOrigine[1] - 1 || blocs[m_coordonnees.z][m_coordonnees.x - coordonnneesOrigine[0] + 1][m_coordonnees.y - coordonnneesOrigine[1] + 1]->m_identifiant != 0;        // bloc à droite
        blocsAfficheesACote[7] = m_coordonnees.z < nombreBlocsHauteur - 1 && m_coordonnees.y != coordonnneesOrigine[1] && blocs[m_coordonnees.z + 1][m_coordonnees.x - coordonnneesOrigine[0]][m_coordonnees.y - coordonnneesOrigine[1] - 1]->m_identifiant != 0;       // bloc en bas à gauche
        blocsAfficheesACote[8] = m_coordonnees.z < nombreBlocsHauteur - 1 && m_coordonnees.x != nombreBlocsCotes + coordonnneesOrigine[0] - 1 && blocs[m_coordonnees.z + 1][m_coordonnees.x - coordonnneesOrigine[0] + 1][m_coordonnees.y - coordonnneesOrigine[1]]->m_identifiant != 0;        // bloc en bas à droite
        bool afficherLigne[6] = {!blocsAfficheesACote[0] && !blocsAfficheesACote[7], !blocsAfficheesACote[1] && !blocsAfficheesACote[8], !blocsAfficheesACote[0] && !blocsAfficheesACote[5], !blocsAfficheesACote[1] && !blocsAfficheesACote[6], !blocsAfficheesACote[2] && !blocsAfficheesACote[3], !blocsAfficheesACote[2] && !blocsAfficheesACote[4]};

        if (afficherLigne[0] || afficherLigne[1] || afficherLigne[2] || afficherLigne[3] || afficherLigne[4] || afficherLigne[5])
                for (int i = 0; i < 6; i++)
                        if (afficherLigne[i])
                                for (int j = 0; j < (i == 2 || i == 3 ? 4 : 12); ++j)
                                        rendu.append(m_textures.sommetTextureLimitesBloc(m_identifiant, i, j, m_coordonneesPixels));
}

Après quelques tests j'ai vu que le problème venait de la fonction rendu.append() appelée deux fois dans cette fonction. Le problème ne semble pas venir des fonctions sommetTextureLimitesBloc et sommetTextureBloc car j'ai envoyé un sf::VErtex vide à la place et y a toujours le même souci de performance.

Voyez-vous d'où pourrait venir ce problème assez étrange ?
Merci d'avance.

14

Graphique / Re : Problème de vertex entre carte graphique ATI et NVidia

« le: Février 28, 2013, 06:39:55 pm »

Je vais voir ça de plus près. Merci pour ton aide

15

Graphique / Re : Problème de vertex entre carte graphique ATI et NVidia

« le: Février 28, 2013, 04:07:47 pm »

Personne n'a de solution, ou n'a eu un problème du même type ?

Autrement j'ai bien une solution : détecter la marque de la carte graphique.
Mais dans ce cas savez-vous comment récupérer la marque de la carte graphique ?
Si jamais cet dernière solution n'est pas faisable, il faudra que l'utilisateur l'indique manuellement (ce qui n'est pas super pratique).
Merci d'avance.