IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

OpenGL Discussion :

Simuler un flux


Sujet :

OpenGL

  1. #1
    Membre régulier
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Août 2013
    Messages
    309
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : Août 2013
    Messages : 309
    Points : 105
    Points
    105
    Par défaut Simuler un flux
    Bonsoir, je suis entrain de coder un petit simulateur, j'utilise les Vertex Array pour le rendu, j'ai créé une structure "Map" qui contient :

    - Un tableau de float pour les vertices (De la forme [X1, Y1, Z1, X2, Y2, Z2, ...])
    - Un tableau de float pour les coordonnées de texture (De la forme [U1, V1, U2, V2, ...])
    - Un tableau de float pour les couleurs (De la forme [R1, V1, B1, R2, V2, B2, ...])
    - Un tableau d'entiers pour la liste des faces pour lesquelles il y a changement de texture
    - Un tableau d'entiers pour la liste des faces pour lesquelles il y a changement de mesh
    - Un tableau de GLint pour les textures
    - Des entiers pour le nombre de vertices, de faces ...

    Le rendu se fait ensuite en dessinant les vertices de toutes les faces (Qui sont en fait des triangles) avec glDrawArrays() jusqu'au prochain changement de texture, et ainsi de suite jusqu'à la derniers face.
    Les donneurs sont stockées dans des fichiers
    obj et .mtl exportés sous Blender. Les noms des objets sont également chargés et si l'un d'entre eux commence par "#", alors c'est un objet à animer comme un fluide.

    Voici le code de la fonction dessinDecor() :

    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
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
     
    void dessinDecor(Principale *ptr)
    {
        int compteurFaces=0,compteurFacesChangeTex=0,compteurTex=0,compteurFacesChangeObj=0,compteurNomsObj=0;
        int compteurVerticesFlux;
        int numFaceChangeTex1,numFaceChangeTex2,numFaceChangeObj1,numFaceChangeObj2,numFaceEnCours;
        int first=0;
        GLint texture;
        const int nbFaces=ptr->Souv.scene.decor.Map.nbTotalFaces;
     
        glEnableClientState(GL_VERTEX_ARRAY);
        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
        glEnableClientState(GL_COLOR_ARRAY);
     
        glVertexPointer(3,GL_FLOAT,3*sizeof(float),ptr->Souv.scene.decor.Map.vertices);
        glTexCoordPointer(2,GL_FLOAT,2*sizeof(float),ptr->Souv.scene.decor.Map.coord_tex);
        glColorPointer(3,GL_FLOAT,3*sizeof(float),ptr->Souv.scene.decor.Map.couleurs);
     
        while(1)
        {
            numFaceEnCours=compteurFaces;
     
            numFaceChangeTex1=ptr->Souv.scene.decor.Map.listeFacesChangeTex[compteurFacesChangeTex];
            numFaceChangeTex2=ptr->Souv.scene.decor.Map.listeFacesChangeTex[compteurFacesChangeTex+1];
            if(numFaceChangeTex2==-1)
                numFaceChangeTex2=nbFaces;      //Calcul du nombre de faces jusqu'au prochain changement de texture
     
            if(numFaceEnCours==numFaceChangeTex1)
            {
                texture=ptr->Souv.scene.decor.Map.textures[compteurTex];
                if(texture==-1)
                    glDisable(GL_TEXTURE_2D);
                if(texture!=-1)
                {
                    glEnable(GL_TEXTURE_2D);
                    glBindTexture(GL_TEXTURE_2D,(GLuint)texture);
                }       //Texturing
     
                glDrawArrays(GL_TRIANGLES,first,3*(numFaceChangeTex2-numFaceChangeTex1));
                //Dessin de tous les vertices jusqu'au prochain changement de texture
     
                first+=3*(numFaceChangeTex2-numFaceChangeTex1);
     
                compteurTex++;
                compteurFacesChangeTex++;
     
                compteurFaces+=(numFaceChangeTex2-numFaceChangeTex1)-1;
            }
     
            compteurFaces++;
            if(compteurFaces==nbFaces)
                break;
        }
     
        glEnable(GL_TEXTURE_2D);
     
        compteurFaces=0;
        while(1)
        {
            numFaceEnCours=compteurFaces;
     
            numFaceChangeObj1=ptr->Souv.scene.decor.Map.listeFacesChangeObj[compteurFacesChangeObj];
            numFaceChangeObj2=ptr->Souv.scene.decor.Map.listeFacesChangeObj[compteurFacesChangeObj+1];
            if(numFaceChangeObj2==-1)
                numFaceChangeObj2=nbFaces;
     
            if(numFaceEnCours==numFaceChangeObj1)
            {
                //Si le nom de l'objet commence par "#" => Animation fluide
                if(ptr->Souv.scene.decor.Map.listeNomsObj[compteurNomsObj][0]=='#')
                {
                    compteurVerticesFlux=9*numFaceChangeObj1+2;
                    while(1)
                    {
                        ptr->Souv.scene.decor.Map.vertices[compteurVerticesFlux]=rand()%2-1;
                        //Variation pseudo-aléatoire de la hauteur des vertices
     
                        compteurVerticesFlux+=3;
                        if(compteurVerticesFlux==9*numFaceChangeObj2+2)
                            break;
                    }       //Listing de tous les vertices de l'objet
                }
     
                compteurFacesChangeObj++;
                compteurNomsObj++;
            }
     
            compteurFaces++;
            if(compteurFaces==nbFaces)
                break;
        }
    }
    Mais le résultat n'est pas vraiment celui espéré :

    Nom : Rivière.jpg
Affichages : 301
Taille : 154,0 Ko

    Pour le moment, je cherche simplement à créer des creux et des bosses, mais je constate que les polygones se "décollent" au lieu de rester soudés.

    Auriez-vous des idées pour simuler un fluide avec OpenGL ?

  2. #2
    Rédacteur/Modérateur


    Homme Profil pro
    Network game programmer
    Inscrit en
    Juin 2010
    Messages
    7 113
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : Canada

    Informations professionnelles :
    Activité : Network game programmer

    Informations forums :
    Inscription : Juin 2010
    Messages : 7 113
    Points : 32 958
    Points
    32 958
    Billets dans le blog
    4
    Par défaut
    Salut,

    pour le décollage de tes triangles, peut-être devrais-tu changer le type de triangles que tu dessines : GL_TRIANGLE est le plus simple, mais d'autres options permettraient de les assembler entre eux à moindre prise de tête, mais il va surement falloir modifier leur représentation en mémoire.
    Nom : primitives.png
Affichages : 294
Taille : 22,7 Ko

    Tu devrais sinon pouvoir utiliser le geometry shader pour la déformation. Voire une combinaison des 2 : changer le type de triangles et ajouter un geometry shader.

    Edit: je viens de voir que tu es en GL1.x : seul la première option sera possible.
    Ou bien il est temps de passer à un eversion supérieure
    Pensez à consulter la FAQ ou les cours et tutoriels de la section C++.
    Un peu de programmation réseau ?
    Aucune aide via MP ne sera dispensée. Merci d'utiliser les forums prévus à cet effet.

  3. #3
    Membre régulier
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Août 2013
    Messages
    309
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : Août 2013
    Messages : 309
    Points : 105
    Points
    105
    Par défaut
    Bonjour, merci pour ta réponse. La solution du type de triangles semble intéressante, à tester (Je ne pourrai pas avant ce soir). Mais je me pose la question de savoir s'il n'y a pas de meilleure solution pour représenter un fluide. La méthode que j'emploie serait idéale pour représenter la mer (Avec une fonction sinusoïdale pour les vagues), mais une rivière là je sèche ...

  4. #4
    Expert éminent sénior
    Avatar de Kannagi
    Homme Profil pro
    cyber-paléontologue
    Inscrit en
    Mai 2010
    Messages
    3 215
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : cyber-paléontologue

    Informations forums :
    Inscription : Mai 2010
    Messages : 3 215
    Points : 10 140
    Points
    10 140
    Par défaut
    Je dirai pour ma part qu'il faudrait modifier que l'axe des Y (si Y est bien la hauteur).

  5. #5
    Expert éminent sénior

    Avatar de dragonjoker59
    Homme Profil pro
    Software Developer
    Inscrit en
    Juin 2005
    Messages
    2 045
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Software Developer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2005
    Messages : 2 045
    Points : 11 368
    Points
    11 368
    Billets dans le blog
    10
    Par défaut
    Pour simuler un fluide, on peut passer par un geometry shader.
    Tu peux voir le travail d'Eric Bruneton à ce sujet : http://www-evasion.imag.fr/people/Eric.Bruneton/ (section Ocean, tu peux télécharger le source)
    Si vous ne trouvez plus rien, cherchez autre chose...

    Vous trouverez ici des tutoriels OpenGL moderne.
    Mon moteur 3D: Castor 3D, presque utilisable (venez participer, il y a de la place)!
    Un projet qui ne sert à rien, mais qu'il est joli (des fois) : ProceduralGenerator (Génération procédurale d'images, et post-processing).

  6. #6
    Membre régulier
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Août 2013
    Messages
    309
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : Août 2013
    Messages : 309
    Points : 105
    Points
    105
    Par défaut
    Bon la solution du GL_TRIANGLE_STRIP n'a rien donné, ça n'a fait que déformer la map.
    dragonjoker59, peux-tu m'expliquer brièvement ce qu'est un Geometry Shader. D'après Bousk, ça n'est pas compatible avec la version 1 d'OpenGL.

  7. #7
    Expert éminent sénior
    Avatar de Kannagi
    Homme Profil pro
    cyber-paléontologue
    Inscrit en
    Mai 2010
    Messages
    3 215
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : cyber-paléontologue

    Informations forums :
    Inscription : Mai 2010
    Messages : 3 215
    Points : 10 140
    Points
    10 140
    Par défaut
    C'est simple , c'est un bout de code qui s’exécute sur ta Carte Graphique , et le geometry shader permet de créer ben de nouvel géométrie :p
    OpenGL 1 est une norme qui se base sur un vieux model de CG (pour les CG entre 1992 - 2004 , quand les CG était non programmable et se basé sur un modèle FIFO (first in, first out) ).
    Sur les Carte Graphique moderne tu peux stocker tout tes vertex dans la CG et faire des opérations dessus , et aussi donc modifier les pixels rendu (pour les effets , lumière autre ! ).

    Sinon ce que dit Bousk peut marcher mais il faut que c'est tout ton fluide qui soit en GL_TRIANGLE_STRIP ! :p

  8. #8
    Rédacteur/Modérateur


    Homme Profil pro
    Network game programmer
    Inscrit en
    Juin 2010
    Messages
    7 113
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : Canada

    Informations professionnelles :
    Activité : Network game programmer

    Informations forums :
    Inscription : Juin 2010
    Messages : 7 113
    Points : 32 958
    Points
    32 958
    Billets dans le blog
    4
    Par défaut
    Citation Envoyé par KevinduC Voir le message
    Bon la solution du GL_TRIANGLE_STRIP n'a rien donné, ça n'a fait que déformer la map.
    As-tu remanié les points correctement ? Comme tu peux le voir sur le graphique, les points n'ont plus rien à voir pour dessiner une même forme.
    Si tu parviens à rafficher la map en utilisant GL_TRIANGLE_STRIP, tu pourras par la suite faire un effet vague en modifiant la hauteur de certains points, et gl s'assurera qu'ils seront toujours bien dessinés sans les cassures de ton résultat actuel.
    Le geometry shader semble être apparu avec opengl 3.2. Cela dit, pourquoi te limiter à gl1.x ?
    Pensez à consulter la FAQ ou les cours et tutoriels de la section C++.
    Un peu de programmation réseau ?
    Aucune aide via MP ne sera dispensée. Merci d'utiliser les forums prévus à cet effet.

  9. #9
    Membre régulier
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Août 2013
    Messages
    309
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : Août 2013
    Messages : 309
    Points : 105
    Points
    105
    Par défaut
    Citation Envoyé par Bousk
    As-tu remanié les points correctement ?
    De quelle façon ? C'est Blender qui triangularise les meshs.

    Citation Envoyé par Bousk
    Cela dit, pourquoi te limiter à gl1.x ?
    Parce que dans le tuto sur SDL dans Open ClassRoom, la version d'OpenGL utilisée dans les cours est tout simplement la version 1. Résultat : Cela fait des années que je code avec cette version sans me douter que c'était la toute première. Il paraît que pour les versions ultérieures il faut refaire le pipeline, ça m'a l'air bien compliqué. Et puis j'ai beaucoup de projets en cours, je me vois mal tout réapprendre sous une version plus moderne.

  10. #10
    Expert éminent sénior

    Avatar de dragonjoker59
    Homme Profil pro
    Software Developer
    Inscrit en
    Juin 2005
    Messages
    2 045
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Software Developer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2005
    Messages : 2 045
    Points : 11 368
    Points
    11 368
    Billets dans le blog
    10
    Par défaut
    Euh... Sur Open Classroom, il y a au moins un tutoriel OpenGL 3, mais je le déconseille.
    Par contre, ici il y a des tutoriels OpenGL "moderne", dont un que tu trouveras dans ma signature, qui est une traduction partielle d'OGLdev, qui est un excellent tutoriel OpenGL 3.x.

    Il faut savoir qu'OpenGL n'évolue plus vraiment depuis 2 ans, date de la sortie de Vulkan. Loin de moi l'idée de te conseiller d'apprendre Vulkan (c'est déjà un autre monde comparé à OpenGL 4.5, alors par rapport à OpenGL 1...) mais il serait temps de travailler avec quelque chose d'utilisable... OpenGL 3.x me semble bien, surtout qu'avec une bibliothèque comme glm, tout ce qui est lié au pipeline (en gros, les matrices) est déjà écrit, je ne peux que te conseiller de te mettre à jour
    Si vous ne trouvez plus rien, cherchez autre chose...

    Vous trouverez ici des tutoriels OpenGL moderne.
    Mon moteur 3D: Castor 3D, presque utilisable (venez participer, il y a de la place)!
    Un projet qui ne sert à rien, mais qu'il est joli (des fois) : ProceduralGenerator (Génération procédurale d'images, et post-processing).

  11. #11
    Membre régulier
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Août 2013
    Messages
    309
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : Août 2013
    Messages : 309
    Points : 105
    Points
    105
    Par défaut
    Oui, mais j'ai commencé par le tuto sur SDL, qui aboutit ensuite sur ce tuto OpenGL, et c'est visiblement la version 1. Si cette version n'est plus d'actualité, pourquoi ont-ils laissé ce tuto sur le site ? Ils auraient dû le supprimer dès l'apparition de la version 2.

    Bref j'ai trouvé un début de solution : Jouer sur les coordonnées de texture au lieu des vertices, de sorte à faire défiler la texture, ça donne un effet de mouvement, certes la surface reste plate mais bon ... Il faut juste faire attention d'orienter les polygones dans le sens de la rivière. Mais ça n'est pas encore au point : Ça n'agit pas sur tous les triangles.

    J'ai également ajouté du reflet :

    Nom : Prades_OpenGL.jpg
Affichages : 231
Taille : 222,7 Ko

  12. #12
    Expert éminent sénior
    Avatar de Kannagi
    Homme Profil pro
    cyber-paléontologue
    Inscrit en
    Mai 2010
    Messages
    3 215
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : cyber-paléontologue

    Informations forums :
    Inscription : Mai 2010
    Messages : 3 215
    Points : 10 140
    Points
    10 140
    Par défaut
    Sinon tu peux rester sur OpenGL 1.x mais faudra te dire que niveau rendu tu sera toujours très limité , dit toi que c'est un peu équivalent a un rendu qu'on peut avoir sur une PS1 ou voir au mieux une PS2 x)

    Citation Envoyé par KevinduC Voir le message
    De quelle façon ? C'est Blender qui triangularise les meshs.
    Il faut le faire manuellement je dirait ! :p
    (enfin tu peux faire un algo qui le génère automatiquement )

  13. #13
    Expert éminent sénior

    Avatar de dragonjoker59
    Homme Profil pro
    Software Developer
    Inscrit en
    Juin 2005
    Messages
    2 045
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Software Developer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2005
    Messages : 2 045
    Points : 11 368
    Points
    11 368
    Billets dans le blog
    10
    Par défaut
    Avec OpenGL 1.X, tu ne pourras jamais obtenir ce genre de rendus :

    Nom : Sponza-SMAA-T2X-small.png
Affichages : 223
Taille : 440,4 Ko

    Nom : SsaoOn-small.png
Affichages : 263
Taille : 590,5 Ko

    Nom : Fountain-small.png
Affichages : 224
Taille : 608,9 Ko

    Ce n'est probablement pas ton objectif, mais bon.

    EDIT:

    Tiens d'ailleurs, pour les feuilles de ton arbre, je te conseille de désactiver les depth writes, et de les dessiner après les autres objets opaques de ta scène
    Si vous ne trouvez plus rien, cherchez autre chose...

    Vous trouverez ici des tutoriels OpenGL moderne.
    Mon moteur 3D: Castor 3D, presque utilisable (venez participer, il y a de la place)!
    Un projet qui ne sert à rien, mais qu'il est joli (des fois) : ProceduralGenerator (Génération procédurale d'images, et post-processing).

  14. #14
    Membre régulier
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Août 2013
    Messages
    309
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : Août 2013
    Messages : 309
    Points : 105
    Points
    105
    Par défaut
    Citation Envoyé par dragonjoker59
    Avec OpenGL 1.X, tu ne pourras jamais obtenir ce genre de rendus
    Ça ne va pas jusque là non ^^, quoi que le reflet réfracté et les jets d'eau c'est vraiment pas mal.

    Citation Envoyé par dragonjoker59
    Tiens d'ailleurs, pour les feuilles de ton arbre, je te conseille de désactiver les depth writes, et de les dessiner après les autres objets opaques de ta scène
    Je joue sur le test alpha pour ce genre de problème. Le problème est que c'est Blender qui ordonne les meshs. C'est d'ailleurs ce que j'ai fait pour le reflet : Je dessine la surface réfléchissante en dernier dans un Vertex Array à part.

  15. #15
    Membre régulier
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Août 2013
    Messages
    309
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : Août 2013
    Messages : 309
    Points : 105
    Points
    105
    Par défaut
    Dernières nouvelles : Je suis parvenu à donner un effet de courant d'eau en faisant défiler la texture :

    Nom : Riviere1.jpg
Affichages : 229
Taille : 114,9 Ko
    Nom : Riviere2.jpg
Affichages : 239
Taille : 115,2 Ko

    Il y avait une erreur dans mon raisonnement, il fallait que je travaille face par face et non vertex par vertex.

    En positionnant les polygones dans le sens du lit de la rivière, on a vraiment l'impression que le courant suit la forme du lit.

  16. #16
    Expert éminent sénior

    Avatar de dragonjoker59
    Homme Profil pro
    Software Developer
    Inscrit en
    Juin 2005
    Messages
    2 045
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Software Developer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2005
    Messages : 2 045
    Points : 11 368
    Points
    11 368
    Billets dans le blog
    10
    Par défaut
    Non, Blender ordonne le meshes pour lui.
    Mais ton loader va charger les meshes, et toi tu vas les ordonner comme TU le souhaites, en fonction de tes besoins.
    Pour avoir un début de rendu de transparence potable, tu n'as pas le choix, il faut d'abord dessiner tous les objets opaques, puis les objets transparents, et de préférence du plus loin de la caméra au plus proche, pour les objets transparents.

    Une boucle de rendu non optimisée, mais qui représente un bon départ, ressemble à ça :
    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
     
    foreach( opaque_material )
    {
      setup_gl_material()
      foreach( mesh_using_that_material )
      {
        draw_mesh()
      }
    }
     
    foreach( transparent_material )
    {
      setup_gl_material()
      foreach( mesh_using_that_material )
      {
        draw_mesh()
      }
    }
    Si vous ne trouvez plus rien, cherchez autre chose...

    Vous trouverez ici des tutoriels OpenGL moderne.
    Mon moteur 3D: Castor 3D, presque utilisable (venez participer, il y a de la place)!
    Un projet qui ne sert à rien, mais qu'il est joli (des fois) : ProceduralGenerator (Génération procédurale d'images, et post-processing).

  17. #17
    Membre régulier
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Août 2013
    Messages
    309
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : Août 2013
    Messages : 309
    Points : 105
    Points
    105
    Par défaut
    Citation Envoyé par dragonjoker59
    Non, Blender ordonne le meshes pour lui.
    Mais ton loader va charger les meshes, et toi tu vas les ordonner comme TU le souhaites, en fonction de tes besoins.
    C'est vrai, j'y ai pensé d'ailleurs.

Discussions similaires

  1. Simuler un std::istream à partir d'un flux d'octets
    Par Captain'Flam dans le forum Débuter
    Réponses: 2
    Dernier message: 26/02/2018, 12h13
  2. Réponses: 19
    Dernier message: 26/04/2011, 16h00
  3. Simuler un flux sur un pipe
    Par ph0nk dans le forum OpenGL
    Réponses: 1
    Dernier message: 16/03/2009, 18h51
  4. Simuler un clignotement OPENGL/c++
    Par javel_man dans le forum OpenGL
    Réponses: 9
    Dernier message: 13/03/2009, 22h55
  5. Réponses: 6
    Dernier message: 05/12/2007, 19h28

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo