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

C++ Discussion :

Créer des classes d'objets OpenGl et manipuler leurs tableaux


Sujet :

C++

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre averti
    Profil pro
    Inscrit en
    Septembre 2008
    Messages
    56
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2008
    Messages : 56
    Par défaut Créer des classes d'objets OpenGl et manipuler leurs tableaux
    Bonjour !

    je me mets tout doucement au C++ et aux classes.
    Le franchissement du C au C++ n'est pas encore vraiment acquis...
    et je m y attelles pour un projet concret...

    Je voudrais créer une classe d'objets Open GL pour créer plusieurs surfaces avec des images dedans.

    J'ai besoin de laisser à l utilisateur sa définition de chaque surface (triangle, carré, cercle, ou bien grille de n coordonnées), qu'il puisse éditer à la souris ou au clavier chaque point.

    J'utilises pour l'OpenGL la facon de faire de ce livre (vao, vbo), car à terme, il y aura besoin pour l utilisateur de manipuler aussi ses shaders.

    Actuellement je buttes sur 2 choses:
    - le passage et l'écriture de tableaux multidiemensionnels ( GLdouble Points[128][3] pour x y et z)
    - l'utilisation dans une fonction d'une donnée de la classe ( par ex NbPoints pour travailler sur des boucles de traitement).

    J'en suis là, et je crois que j'ai besoin d'un coup de main pour comprendre comment manipuler les tableaux avec les classes...

    voilà


    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
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
     
    class  Surface
    {
    public:
        string Name;
        int ID;
        int NbPoints=3;//nbre points of the geometry, minima 3
        GLdouble Point[128][3];//3d vector
        GLuint VAO;
        GLuint VBO;
        GLdouble  Color[3];
     
        Surface();
        Surface(double * Points);
     
        GLdouble getPoints() const;
        void setPoints(GLdouble * Points);
     
     
        //geometry
        /* GL shader objects for vertex and fragment shader [components] */
    	GLuint vs, fs;
    	/* GL shader programme object [combined, to link] */
    	GLuint shader_programme;
     
    	/* these are the strings of code for the shaders
    	the vertex shader positions each vertex point */
    	const char* vertex_shader =
    	"#version 410\n"
    	"in vec3 vp;"
    	"void main () {"
    	"	gl_Position = vec4 (vp, 1.0);"
    	"}";
    	/* the fragment shader colours each fragment (pixel-sized area of the
    	triangle) */
    	const char* fragment_shader =
    	"#version 410\n"
    	"out vec4 frag_colour;"
    	"void main () {"
    	"	frag_colour = vec4 (0.5, 0.0, 0.5, 1.0);"
    	"}";
     
     
    /* a vertex buffer object (VBO) is created here. this stores an array of data
    	on the graphics adapter's memory. in our case - the vertex points */
        void init_VBO()
        {
        glGenBuffers (1, &VBO);
    	glBindBuffer (GL_ARRAY_BUFFER, VBO);
    	glBufferData (GL_ARRAY_BUFFER, 9 * sizeof (GLfloat), Points, GL_STATIC_DRAW);
        }
    /* the vertex array object (VAO) is a little descriptor that defines which
    	data from vertex buffer objects should be used as input variables to vertex
    	shaders. in our case - use our only VBO, and say 'every three floats is a
    	variable' */
        void init_VAO()
        {
    	glGenVertexArrays (1, &VAO);
    	glBindVertexArray (VAO);
    	glEnableVertexAttribArray (0);
    	glBindBuffer (GL_ARRAY_BUFFER, VBO);
    	glVertexAttribPointer (0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
        }
    	/* here we copy the shader strings into GL shaders, and compile them. we then
    	create an executable shader 'program' and attach both of the compiled shaders.
    	we link this, which matches the outputs of the vertex shader to the inputs of
    	the fragment shader, etc. and it is then ready to use */
    	void init_Shader()
    	{
    	vs = glCreateShader (GL_VERTEX_SHADER);
    	glShaderSource (vs, 1, &vertex_shader, NULL);
    	glCompileShader (vs);
    	fs = glCreateShader (GL_FRAGMENT_SHADER);
    	glShaderSource (fs, 1, &fragment_shader, NULL);
    	glCompileShader (fs);
    	shader_programme = glCreateProgram ();
    	glAttachShader (shader_programme, fs);
    	glAttachShader (shader_programme, vs);
    	glLinkProgram (shader_programme);
    	}
     
    	void Use_Program()
    	{
            glUseProgram (shader_programme);
    	glBindVertexArray (VAO);
    	/* draw points 0-3 from the currently bound VAO with current in-use shader*/
    	glColor4f(1.0, 1.0, 1.0,0.5);
            glDrawArrays (GL_TRIANGLES, 0, NbPoints);
    	}
     
    };
     
     
    Surface::Surface()
    {
     
    }
     
    Surface::Surface(double *points)
    {
     
     
    }
     
     
    void Surface::setPoints( double  * Points_)
    {
     
    }

  2. #2
    Expert confirmé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 502
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 502
    Par défaut
    En OpenGL, Les coordonnées ne ce balade pas dans des tableaux multi-dimensionnelles, jamais.
    C'est soit des tableaux mono-dimensionnels de structures bien défini, soit plusieurs tableaux de données simples mis les un derrière les autres.
    Si vous utilisez des conteneurs C++ et pas de tableaux à la C, vous n'auriez pas besoin de NbPoints.
    C'est quoi précisément une "fonction d'une donnée de la classe" ???

  3. #3
    Membre averti
    Profil pro
    Inscrit en
    Septembre 2008
    Messages
    56
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2008
    Messages : 56
    Par défaut
    bonjour bacelar et merci !

    je me suis mal exprimé pour la fonction d'une classe.
    en fait je ne comprends pas la logique de déclaration dans la classe. Et ce à quoi je m'attelle pose certainement plusieurs questions qui n' ont rien à voir.



    Je prends l'exemple ci dessous, qui me renvoie comme erreur: error: invalid types 'double[int]' for array subscript

    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
     
        GLdouble Points[128][3];//3d vector
        GLuint VAO;
        GLuint VBO;
     
     
        Surface();
        Surface(double * Points);
        void Draw_Points(double * Points);
     
     
    (...)
     
    //Concernant le tableau unidimensionnel, ce que je pensais faire:
     
    void Surface::Draw_Points(double * Points)
    {
    glBegin(GL_POLYGON);
    for(int i=0;i<NbPoints;i++)
    {
    glVertex2d(Points[i][0],Points[i][1]);
    }
    glEnd;
    }

    j'ai un peu de mal pour définir la structure dont j'ai besoin et l'approche tableaux est un peu complexe.

    J'ai besoin d'aide pour débroussailler l'approche et comprendre comment utiliser les classes de manière correcte.

    je suis parti sur un NbPoints pour pouvoir utiliser par ex.:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    glBufferData (GL_ARRAY_BUFFER, (NbPoints*typeVertex) * sizeof (GLfloat), Points, GL_STATIC_DRAW); //typeVertex= 2d ou 3d
    naivement, mon approche pour l'édition des points à la souris serait :
    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
     
        int detect_mouse_over_point(Surface *Surf, double mousex, double mousey)
        {
        int num_point=-1;
        int maxi=Surf.NbPoints;
        for(int i=0;i<maxi;i++)
        {
        if(mousex>Surf.Points[i][0]-0.02 && mousex<Surf.Points[i][0]+0.02 && mousey>Surf.Points[i][1]-0.02 && mousey<Surf.Points[i][1]+0.02  )
        {
        num_point=i;
        break;
        }
        }
        return(num_point);
        }

    pour moi il s'agit essentiellement d'EDITER un tableau compris dans la classe, et pas d'envoyer un tableau de coordonnées à ma classe.

    l'utilisateur doit définir à la souris les coordonnées.


    Bref, comment aborder celà concrètement ?
    Voilà ! merci

  4. #4
    Expert confirmé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 502
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 502
    Par défaut
    Pourquoi ne pas utiliser de "Vector3f" ???

    http://ogldev.atspace.co.uk/index.html

  5. #5
    Membre averti
    Profil pro
    Inscrit en
    Septembre 2008
    Messages
    56
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2008
    Messages : 56
    Par défaut
    bonjour et bonne année !
    ok pour les vector3f ! ces exemples me semblent plus accessibles

    hum... je suis parti sur une autre base, mais qui ne permet (a priori) pas la cohabitation de l'ancien et du modern opengl, en tout cas, tout ce qui est de l'ordre de GL_Begin n 'est plus mixable avec ce code (http://www.tomdalling.com/blog/category/modern-opengl/)
    du coup, j'ai fais un petit détour et un peu mieux compris VAO et VBO et passer des tableaux à une fonction.

    je replonges la dedans et reviens...

  6. #6
    Expert éminent

    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2007
    Messages
    5 202
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2007
    Messages : 5 202
    Par défaut
    Si tu veux vraiment faire des classes pour openGL, je t'invite à regarder le code source d'un de mes vieux projets, autoscene.

    Il y a par exemple quelques caméras préfabriquées.
    Le code date de mes études, il faudrait certainement l'améliorer, c'est plus à regarder comme une source d'idées.

Discussions similaires

  1. [POO] Emuler / créer des classes partielles ?
    Par le_chomeur dans le forum Langage
    Réponses: 2
    Dernier message: 28/05/2008, 16h06
  2. Tetris:dois je créer des class filles
    Par guitariste dans le forum C++
    Réponses: 2
    Dernier message: 24/12/2007, 21h49
  3. Réponses: 5
    Dernier message: 06/09/2006, 13h15
  4. Réponses: 4
    Dernier message: 16/08/2006, 09h19
  5. Réponses: 4
    Dernier message: 15/03/2006, 11h22

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