Bonjour,

Avant tout, ma question est pourquoi je n'est pas le triangle qui s'affiche, comme dans le cours de Boouh (Merlin) `Développez vos applications 3D avec OpenGL 3.3` onglet (page) `Première affichage`

Sachez que c'est la première fois que je poste une question sur un forum, car je suis plus du style à chercher pour ne pas perdre mon temps, mais là j'ai plus trop le choix et l'étape d’après, c'est l'abandon pour un temps et continué mes bon vieux, PHP, JavaScript, HTML et CSS

Je suis en train de fondre de l'intérieur est pourtant je suis patient

Donc dans le cours, il est question d'afficher un triangle, mais sans succès.

1- j'ai Ubuntu 18.04 LTS

1- J'utilise gcc/g++

g++ main.cpp SceneOpenGL.cpp Shader.cpp -Werror -lSDL2 -lGL -o main
#Faites pas attention à `SceneOpenGL.cpp` et `Shader.cpp` ce sont ceux de l'onglet(page) d'après (c'était un test, pour voir si ça fonctionnai pas)

2- La commande suivante me dit que j'ai openGl 3.0

glxinfo | grep -i openGL

#Ce qui donne ceci :

OpenGL vendor string: nouveau
OpenGL renderer string: NV136
OpenGL core profile version string: 4.3 (Core Profile) Mesa 18.0.5
OpenGL core profile shading language version string: 4.30
OpenGL core profile context flags: (none)
OpenGL core profile profile mask: core profile
OpenGL core profile extensions:
OpenGL version string: 3.0 Mesa 18.0.5
OpenGL shading language version string: 1.30
OpenGL context flags: (none)
OpenGL extensions:
OpenGL ES profile version string: OpenGL ES 3.1 Mesa 18.0.5
OpenGL ES profile shading language version string: OpenGL ES GLSL ES 3.10
OpenGL ES profile extensions:

3- J'ai installé les drivers de ma Nvidia GeForce GTX 1060 6GO pour avoir une version plus récente de OpenGL, sans succès

4- J'ai essayé sous Windose avec Code::Block (Qui a était extrêmement difficile à paramétrer, à ce tirer une balle), cela a fonctionné, mais j'adore mon petit Linux est son shell (ligne de commande)

5- Pour être précis j'ai la fenêtre SDL2 qui s'ouvre bien sans faute, mais qui a un écrans noir

6- J'ai modifier cette ligne pour avoir OpenGL 3.0 et pas 3.1, c'est pas mieux

SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
//Changé le 1 de la fin en 0, pour je suppose 3.1 en 3.0
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);

7- Au dernière nouvelle la Fonction glClear() me renvoyai une erreur :

glClear(GL_COLOR_BUFFER_BIT);

glGetError() == GL_NO_ERROR//Renvoie false
glGetError() == GL_INVALID_OPERATION//Renvoie true

//GL_INVALID_OPERATION => 1282, Positionné si l’état d’une commande est illégal compte tenu des paramètres passés.

J'ai essayé de trouver une façon de la réglé, mais impossible

Donc en gros,

j'en peu plus,

pour installer SDL2, le parcours du combattant,

comprendre comment inclure OpenGL avec GCC, pareil (et encore je n'en suis même pas sûr),

mettre à jour OpenGL pour la version 3.3, une véritable torture et au finale aucun résultat,

j'ai toujours pas compris comment fonctionne l'inclusion de librairie, franchement il font ch**** avec les .a et je ne sais trop quoi d'autres,

les .c, .cpp et les .h me vont très bien.

Si quelqu'un aurait 2-3 tutos ou infos pour tout ce qui est GCC, SDL2 et OpenGL3, le tout sur Linux.

Et bien, voila, en espérant ne pas avoir était trop long et assez précis.

Je suis pas truc(je me rappelle plus du mot), je sais qu'il y aura difficilement une réponse positive, mais cela n'est pas grave

Désoler pour le petit coup de bouche, mais là j'en peu plus de cette informatique complètement bancale à cause du privateur et de toutes c'est versions différentes.

Bonne chance, mdr, enfin merci d'avance.

Salut !

Au niveau tutos, il y a LearnOpenGL, OGLDev qui sont bien.

Après, as-tu, par hasard, activé les extensions de débogage d'OpenGL, pour avoir des messages d'erreur ou de warning au cas où ?
C'est la première étape, pour pouvoir debugger correctement un code OpenGL.

Franchement, j'en ai aucune idée pour les extensions de débogage d'OpenGL, mais je suppose que si, vu que j'ai une erreur au niveau de glClear().

Je pense que le problème vient sois de g++ qui manque un paramètre, sois du fait que j'ai que OpenGL 3.0 que je n'arrive pas à mettre à jour.

Désoler mais aujourd'hui je suis en formation, je regarderai les tuto proposé plus tard

Bonne journée.

Accraugaming a écrit:

pour installer SDL2, le parcours du combattant,

Rassures moi, c'est une blague ?

Sous Ubuntu

$ apt-get install libsdl2-dev
$ g++ test.cpp $(pkg-config --libs --cflags sdl2)

Non ce n'est pas une blague, je n'ai que l'équivalant de 1 jour de langage C et j'ai trouvé "facilement" pour le apt install, mais je ne savais pas pour

G++ avec l'option -lSDL2.

Puis dans un autre tuto il nous faisait installer une autre version qui n'a pas fonctionné et d'autres truc enfin bon, un vraie débutant.

Et puis tu connais, donc forcément pour toi c'est plus facile, comme pour moi c'est facile de faire un site de A à Z et si il faut, avec le bloc-note

Moi pouvoir aller jusqu'à OpenGl 4.3, je savais pas, mais est il pour autant disponible à l'utilisation, je ne sais pas.

Si oui dans ce cas c'est plus dans les options de G++, où je suis nul comme la fait remarquer markand

Bonne soirée, moi je suis fatigué je vais aller manger et dormir, bonne nuit hooooha (baillement).

Les tutos c'est mal. Enfin, en grande partie.

Beaucoup font ou indiquent de choses à ne pas faire.

Ne le prends pas mal mais si tu ne sais pas encore lier correctement les bibliothèques alors tu devrais encore continuer à apprendre le C++ de manière générale. -lSDL2 c'est juste une option qui permet au compilateur de se lier à SDL2 en suivant un certain nommage, par exemple sous Linux gcc/clang va chercher libSDL2.(so|a) dans un nombre prédéfinis de répertoires.

Évidemment ce ne sont pas des choses qu'on peut deviner mais ce sont des choses qu'on doit maîtriser avant de commencer à utiliser des bibliothèques externes.

Cela dit, c'est assez chiant de maintenir un nombre de bibliothèques externes car elles sont souvent à des endroits différents et parfois même nommées différemment. Et c'est grâce à des outils comme CMake, pkg-config qu'on peut se lier à des bibliothèques externes de manière plus simple et plus portable. Mais c'est encore une autre ressource à apprendre. Oui le C++ c'est pas facile.

Pour OpenGL c'est un peu différent. C'est une norme pas une « bibliothèque » tel quel. Ce sont des implémentations qui te fournissent une certaine version sur ta machine (un peu comme le C++). Par exemple sous Linux l'implémentation d'OpenGL est principalement mesa. Ainsi on peut pas vraiment dire « j'installe OpenGL ». Enfin, le driver nvidia est propriétaire et intrusif. Il modifie l'implémentation d'OpenGL sur Linux et c'est particulièrement crade. Malheureusement le driver libre nouveau ne fait pas encore de miracle non plus.

-
Edité par markand 18 décembre 2018 à 9:32:23

Je connais CMake, mais si je n'utilise pas code::block, c'est un peu pour la même raison que pour CMake, apprendre les base et pas suivre bêtement des connerie que je ne comprend pas.

Je pense qu'il faut faire ce qu'on te dit, puis après réfléchir et apprendre, si tu n'as pas une base alors il est impossible de construire quoi que ce soit et si cette base est pourri tu t'en rendra vite compte, avec un peu de patience

Oui cela est un peu contradictoire, mais en les assemblant on peut aller loin.

Il me faudrait donc comprendre encore beaucoup de choses au niveau de GCC et G++, mais OÙ ?

Le plus dur dans un langage c'est pas de l'apprendre, c'est de trouver ce qu'il y a à apprendre (ça fait bizarre les deux "a à" ?)

Il serait donc fort aimable d'avoir des documentation concernant GCC, autre que le MAN, qui reste assez tordu et long.

Sois-dit en passant le sujet principale ne sont pas mes connaissances, mais bien le problème concernant l'affichage du triangle avec OpenGL.

J'ai omis de dire, que j'ai dû mettre un dossier appeler "GL3" contenant "gl3.h", dans le dossier "/usr/local/include/".

Je viens de remarquer que le dossier "/usr/include/GLES3/" contient aussi le fichier "gl3.h" et d'autre fichier.

Serait-il une solution à mon problème ?

Trop de mystère, c'est exitant

J'adore les Smiley

-

-

Bon vue que MEUUUUSIEU veux que je n'écrive qu'un message toutes les 24H, voici le fameux message

 ----------------

NAN MAIS C'EST DINGUE !!!

Je viens de tester une nouvelle fois mon TRUC avec GCC et là, BAM, nan mais c'est fous quand même.

J'ai tester avec mon ordinateur portable qui n'a pas de carte graphique et c'est lui que j'utilisais à la base, mais j'ai vite abandonné par rapport à OpenGL.

C'est pourquoi j'ai par la suite utilisé mon ordinateur fixe et sa carte graphique pensant avoir plus de chance.

Donc voici deux Screenshot :

http://image.noelshack.com/fichiers/2018/51/2/1545126753-capture-d-ecran-de-2018-12-18-10-45-20.png

http://image.noelshack.com/fichiers/2018/51/2/1545126753-capture-d-ecran-de-2018-12-18-10-47-02.png

En gros ça montre la fenêtre avec le triangle au milieu.

Voici le code : (Faites pas attention au bazar, j'ai pas eu le temps de ranger Pour dire, même moi je redécouvre mon code !

fichier "main.c"

#include <stdio.h>
#include <stdlib.h>
#include <SDL2/SDL.h>

#ifdef WIN32
    #include <GL/glew.h>
#else
    #define GL3_PROTOTYPES 1
    #include <GL3/gl3.h>
#endif


#include "main.h"

#define TITLE_MAIN "Test de la SDL2.0"
#define FLAG_FENETRE_DEFAUT SDL_WINDOW_SHOWN|SDL_WINDOW_OPENGL/*SDL_WINDOW_FULLSCREEN_DESKTOP SDL_WINDOW_OPENGL|SDL_WINDOW_FULLSCREEN_DESKTOP*/
#define COULEUR_ARRIERE_PLAN 0,0,0,255

int main(int argc, char const *argv[])
{
//Variable
    //FLOAT

//Pointeur
//Structure
    // SDL_Window *fenetre=NULL;
    // SDL_Renderer *rendu=NULL;
    // SDL_GLContext contexteOpenGL=NULL;
    //
    //
    //
    // initialise(&fenetre,&rendu,&contexteOpenGL);
    //
    // pause();
    //
    // SDL_GL_DeleteContext(contexteOpenGL);
    // SDL_DestroyWindow(fenetre);
    // SDL_Quit();
    SDL_Window* fenetre=0;
    SDL_GLContext contexteOpenGL=0;
    SDL_Event evenements;
    int terminer=0;
    if(SDL_Init(SDL_INIT_VIDEO) < 0)
    {
        SDL_Quit();
        return -1;
    }
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
    fenetre = SDL_CreateWindow("Test SDL 2.0", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL);
    if(fenetre == 0)
    {
        SDL_Quit();
        return -1;
    }
    contexteOpenGL = SDL_GL_CreateContext(fenetre);
    if(contexteOpenGL == 0)
    {
        SDL_DestroyWindow(fenetre);
        SDL_Quit();
        return -1;
    }
    #ifdef WIN32
        GLenum initialisationGLEW( glewInit() );
        if(initialisationGLEW != GLEW_OK)
        {
            SDL_GL_DeleteContext(contexteOpenGL);
            SDL_DestroyWindow(fenetre);
            SDL_Quit();
            return -1;
        }
    #endif
    GLfloat vertices[] = {-0.1, -0.1,   0.0, 0.1,   0.1, -0.1};
        while(!terminer)
        {
        SDL_WaitEvent(&evenements);
        if(evenements.window.event == SDL_WINDOWEVENT_CLOSE){terminer = 1;}
        glClear(GL_COLOR_BUFFER_BIT);
        glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, vertices);
        glEnableVertexAttribArray(0);
        glDrawArrays(GL_TRIANGLES, 0, 3);
        glDisableVertexAttribArray(0);
        SDL_GL_SwapWindow(fenetre);
        if(glGetError() == GL_NO_ERROR){fprintf(stdout,"tout va bien ;)\n");}
        else{fprintf(stdout,"NULLLLLLLLLLLLLE!!!!!! ;(\n");}
    }
    SDL_GL_DeleteContext(contexteOpenGL);
    SDL_DestroyWindow(fenetre);
    SDL_Quit();
    return 0;
    //return EXIT_SUCCESS;
}






void initialise(SDL_Window **fenetre,SDL_Renderer **rendu,SDL_GLContext *contexteOpenGL)
{
    if(SDL_Init(SDL_INIT_VIDEO)!=0){
        fprintf(stdout,"Échec de l'initialisation de la SDL (%s)\n",SDL_GetError());
        fprintf(stderr,"Échec de l'initialisation de la SDL (%s)\n",SDL_GetError());
        SDL_Quit();
        exit(EXIT_FAILURE);}


    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);


    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);


    *fenetre=SDL_CreateWindow(TITLE_MAIN,
        SDL_WINDOWPOS_CENTERED,// horizontale
        SDL_WINDOWPOS_UNDEFINED,// verticale
        640,480,// Pixel x et y
        FLAG_FENETRE_DEFAUT);
    if(*fenetre==NULL){
        fprintf(stdout,"Impossible d'ouvrir la *fenetre Principale (%s)\n",SDL_GetError());
        fprintf(stderr,"Impossible d'ouvrir la *fenetre Principale (%s)\n",SDL_GetError());
        SDL_Quit();
        exit(EXIT_FAILURE);}



    *rendu=SDL_CreateRenderer(*fenetre, -1, 0);
    if(*rendu==NULL){
        fprintf(stdout,"Impossible d'avoir le rendu de la *fenetre Principale (%s)\n",SDL_GetError());
        fprintf(stderr,"Impossible d'avoir le rendu de la *fenetre Principale (%s)\n",SDL_GetError());
        SDL_DestroyWindow(*fenetre);
        SDL_Quit();
        exit(EXIT_FAILURE);}



    // SDL_SetRenderDrawColor(*rendu,COULEUR_ARRIERE_PLAN);
    // SDL_RenderClear(*rendu);
    // SDL_RenderPresent(*rendu);

    // SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");  // permet d'obtenir les redimensionnements plus doux.
    // SDL_RenderSetLogicalSize(rendu,640,480);

    //SDL_SetWindowFullscreen(*fenetre,0);// SDL_WINDOW_FULLSCREEN ou SDL_WINDOW_FULLSCREEN_DESKTOP

    *contexteOpenGL=SDL_GL_CreateContext(*fenetre);
    if(*contexteOpenGL==NULL){
        fprintf(stdout,"Impossible d'avoir le contexte OpenGL (%s)\n",SDL_GetError());
        fprintf(stderr,"Impossible d'avoir le contexte OpenGL (%s)\n",SDL_GetError());
        SDL_DestroyWindow(*fenetre);
        SDL_Quit();
        exit(EXIT_FAILURE);}


    #ifdef WIN32
        GLenum initialisationGLEW=glewInit();

        if(*initialisationGLEW!=GLEW_OK){
            fprintf(stdout,"Impossible d'avoir le contexte OpenGL (%s)\n",glewGetErrorString(initialisationGLEW));
            fprintf(stderr,"Impossible d'avoir le contexte OpenGL (%s)\n",glewGetErrorString(initialisationGLEW));

            SDL_GL_DeleteContext(*contexteOpenGL);
            SDL_DestroyWindow(*fenetre);
            SDL_Quit();

            exit(EXIT_FAILURE);}
    #endif
}





void pause()
{
    float vertices[]={-0.5,-0.5, 0.0,0.5, 0.5,-0.5};
    int continuer=1;
    SDL_Event event;

    while(continuer){
        glVertexAttribPointer(0,2,GL_FLOAT,GL_FALSE,0,vertices);
        glEnableVertexAttribArray(0);
        glDrawArrays(GL_TRIANGLES,0,3);
        glDisableVertexAttribArray(0);

        SDL_WaitEvent(&event);

        switch(event.window.event){
            case SDL_WINDOWEVENT_CLOSE:
                continuer=0;
        }}
}

Et le fichier "main.h"

#ifndef DEF_MAIN
#define  DEF_MAIN

    void initialise(SDL_Window **fenetre,SDL_Renderer **rendu,SDL_GLContext *contexteOpenGL);
    void pause();

#endif

Et VOILÀ, c'est quand même dingue ! Reste plus qu'à comprendre

Enfin, c'est pas vraiment ce que j'appelle une résolution de problème sur un Forum, mais c'est déjà mieux que rien.

J'ai beau chercher je ne vois pas ce qui aurait put changer, à part ... suspens, le fait d'avoir ouvert et sauvegardé le fichier "main.c" avec l'éditeur NANO ?!

Est-ce normale qu'il n'y ai pas de couleur sur les balises codes "C++" ? C'est bon j'ai ma réponse, suffisait de recharger la page.

C'est complètement illisible, la honte.

N'hésitez pas à le copier dans un éditeur de texte.

J'ai aussi changé ça

SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 0);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);

En ça

SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);

Mais avant, cela y était déjà. (le fait d'avoir de la version 3.0 à 3.3)

Je viens de voir qu'il y avait 2 fois le code

DANS MAIN

SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);

ET DANS INITIALISE

SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);


SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);

Je suis un vraie malade

Wouah, je suis trop fatigué, j'arrive plus à réfléchir, apparemment j'ai copié ce qui avait dans la fonction initialise pour essayer sans elle, laisse tomber.

-
Edité par Accraugaming 18 décembre 2018 à 11:40:06

Jette le tutoriel que tu suis, il utilise des features obsoletes d'OpenGL: vertex arrays notamment, et surtout le manque d'un VAO, qui est nécessaire en OpenGL moderne, sans parler du fait qu'il n'utilise pas les extensions de debug pour ... debugger.

-
Edité par dragonjoker 20 décembre 2018 à 13:43:09

Ok, je suis pas encore assez chaud pour ça, j'ai trop de bouleau, j'y reviendrais plus tard.

Sinon, je suis pas sûr que je peu mettre le sujet en résolu, étant donné qu'il n'y a pas vraiment d'explication ?

Dans ce cas que faire ?

En tout cas, merci bien, j'ai gagné du temps sur un sujet qui m'était complètement inconnu