Discussion :

[regsregs]

Bonjour,

Je commence en c++ et en OpengL, ca fait beaucoup

Voilà mon problème c'est d'affecter un nombre de vertices dans un tableau dont le nombre peut varier.

Dans ma classe et je définis comme ca :

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
 
 GLfloat* VertexArray_Get() const;
 void VertexArray_Set(GLfloat* VertexArray);
 
 private :
 GLfloat* VertexArray;
 
GLfloat* monObjet::VertexArray_Get() const
 {
    return VertexArray;
 }
  void monObjet::VertexArray_Set(GLfloat* VertexArrayN)
 {
        VertexArray=VertexArrayN;
 }

Et je souhaite par exemple ajouter un tableau de vertices par ma méthode set.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
 ObjModel.VertexArray_Set(structVertices());
 
GLfloat* structVertices()
{
 
    GLfloat CubeArray[] = {
	 1.0f, 1.0f, -1.0f,
	 -1.0f, 1.0f, -1.0f,
	 0.0f, 0.0f, 1.0f
};

Mais cette affectation doit etre fausse, si vous pouviez m'indiquer la démarche à suivre, pointeur et tableau je suis assez perdu

[gbdivers]

Bonjour et bienvenu sur le forum

Tu peux utiliser le conteneur std::vector comme tableau dynamique :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
std::vector<GLfloat> VertexArray; // créer un tableau de GLFloat
VertexArray.resize(SIZE); // redimensionne le tableau
VertexArray.push_back(1.0); // ajoute un élément dans le tableau (en augmentant la taille de 1)
 
void structVertices(std::vector<GLfloat>::iterator it)
{
   GLfloat CubeArray[] = {
       1.0f, 1.0f, -1.0f,
      -1.0f, 1.0f, -1.0f,
       0.0f, 0.0f,  1.0f };
   std::copy(CubeArray, CubeArray+9, it); // remplit le vector avec les données du tableau statique
};
 
structVertices(VertexArray.begin()); // ajoute les éléments dans le tableau dynamique

Pour envoyer les données à GL, il suffit d'utiliser &VertexArray[0]

[regsregs]

Salut,

merci, je vais regarder de plus près le conteneur std::vector.

Par contre ce que j'avais fait ci-dessus, c'était complètement idiot ?

[gbdivers]

Pas totalement. Mais tu mélangeais tableau statique et variable dynamique. Le problème est que ton tableau statique (CubeArray) est une variable locale dans la fonction structVertices() et sera donc supprimée lors de la sortie de la fonction. Il aurait fallut (au pire) créer un tableau dynamique avec new[] mais c'est une mauvaise approche pour débuter (vector est un tableau dynamique qui gère lui même sa mémoire, c'est plus simple)

[regsregs]

Je vais devoir approfondir tout cela, pas mal d'heures en perspective

[oodini]

Je commence en c++ et en OpengL, ca fait beaucoup
[...]
Je vais devoir approfondir tout cela, pas mal d'heures en perspective

Je crois déjà que tu fais une grosse erreur sur l'unité utilisée.

[regsregs]

L'unité utilisée , oui peut être en mois ... (quel mauvais esprit )

Sinon voilà mon approche maintenant. Est-ce satisfaisant et optimisé :

Je crée une classe de vecteur :

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
 
 
class StructureObjet
{
public:
  StructureObjet() {}
  StructureObjet (GLfloat def_x, GLfloat def_y, GLfloat def_z) : x(def_x), y(def_y), z(def_z) {}
 
  virtual ~StructureObjet() {}
 
  // this classes member functions
  // ...
 
  // some data (i.e. x and y)...
  GLfloat x, y, z;
};

Que j'instance :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
 vector<StructureObjet*> arMyClass;
 
    arMyClass.push_back(new StructureObjet(0.0f, 0.0f,1.0f));
    arMyClass.push_back(new StructureObjet(1.0f, 0.0f,1.0f));
    arMyClass.push_back(new StructureObjet(0.5f, 1.0f,0.5f));
    ObjModel.initVBO(arMyClass);
    arMyClass.clear();

Pour ma méthode initVBO

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
void  monObjet::initVBO(vector<StructureObjet*> VertexArray)
 {
   if (VertexArray.size()>0)
      {
         glGenBuffers(1,&bufVertex);
         glBindBuffer(target, bufVertex);
         glBufferData(target,  VertexArray.size()*3 * sizeof( GLfloat ), NULL, mode);
         glBufferSubData(target, 0,  VertexArray.size()*3*sizeof( GLfloat ),  &VertexArray);
      }
 }

Est-ce correct et viable ?

[oodini]

L'unité utilisée ?

Quand on commence du C++ et qu'on envisage d'approfondir, ça prend plutôt quelques années.

vector<StructureObjet*> arMyClass;
arMyClass.push_back(new StructureObjet(0.0f, 0.0f,1.0f));

Ouille : il faut utiliser des shared_ptr plutôt que des pointeurs.

-> exemple

[regsregs]

Ben explique la différence entre pointeur et shared_ptr, ca me fera gagner du temps

[oodini]

http://arb.developpez.com/c++/raii/shared_ptr/

[regsregs]

Bonsoir,

Bon je pensais après quelques explications et lectures que j'allais m'en sortir avec ma classe de vecteur dynamique mais non

Je dois donc afficher un tableau de float et j'ai construit une classe de vecteur :

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
 
class Vertices
{
public:
  Vertices() {}
  Vertices (GLfloat def_x, GLfloat def_y, GLfloat def_z) : x(def_x), y(def_y), z(def_z) {}
  virtual ~Vertices() {}
 
    // some data (i.e. x and y)...
  GLfloat x, y, z;
};
 
     vector<Vertices *> arMyClass;
 
     arMyClass.push_back(new Vertices(0.0f, 0.0f,1.0f));
     arMyClass.push_back(new Vertices(1.0f, 0.0f,0.0f));
     Vertices& v = *(arMyClass[0]); // Lit le tableau indice 0 en pointant l'adresse  d'ailleurs Vertices& v = *(arMyClass[0]);  ou v = *(arMyClass[0]);  ?

Mais si je veux passer en paramètres l'ensemble de mon tableau de float, je fais comment ? Ici même on m'a parlé de constructeur de copie (qui reste encore flou desolé ) aussi mais que le constructeur par defaut devrait aller.

J'en conviens que je suis un stupid monkey mais si on pouvait m'aider

[gbdivers]

FAQ : Comment passer correctement des paramètres à ma fonction ?

Et je t'ai dis de faire un vecteur de vertices et non un vecteur de pointeurs de vertices, sinon, ça passe pas sur opengl

[3DArchi]

Salut,

là j'ai besoin d'explications, sont où les contenus identiques ?

Si tu prends une position (x,y,z), c'est une sémantique de valeur car deux variables v1 et v2 ayant les mêmes valeurs (1,2,3) par exemple, peuvent être utilisées indifféremment, elles désignent la même position.
Si tu prends un mobile caractérisé par sa position (x,y,z), c'est une sémantique d'entité. Si tu prends deux mobiles m1 et m2 et que tu appliques une expression de déplacement (x+dx, y+dy, z+dz), ce n'est pas la même chose que de déplacer m1 ou m2.

Tu peux également ajouter dans ta classe StructureObjet le constructeur par copie, l'opérateur d'affectation = et les opérateurs d'égalité et de différence (== et !=)

La copie et l'affectation devrait être générée automatiquement et de façon approprié par le compilateur pour une classe comme celle-ci. Nul besoin de les redéfinir. (cf F.A.Q.)

Sinon, comme gbdivers, je ne vois pas l'intérêt de définir un vecteur par pointeur. Ici, un vecteur par valeur devrait suffire.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

virtual ~Vertices() {}

Vertices ayant une sémantique de valeur, il n'est pas destiné à être dérivé. Donc inutile de faire un constructeur virtuel. Et ensuite, inutile de définir un constructeur qui ne fait rien.

[regsregs]

Oui mais c'est quand meme pas évident, bon donc dans mon cas pas de pointeurs mais c'est tout à fait possible aussi ? et convertir mon pointeur en tableau de float ?

Donc si j'essaie de comprendre est ce ma classe est bonne la même si il le fait implicitement si je le mentionne pas; est ce que la syntaxe est bonne ?
& accolé a const ou pas :

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
 
class Vertices
{
public:
  //Vertices (GLfloat def_x, GLfloat def_y, GLfloat def_z) : x(def_x), y(def_y), z(def_z) {}
  Vertices (GLfloat const& def_x, GLfloat const& def_y, GLfloat const& def_z) : x(def_x), y(def_y), z(def_z) {}
 
    // some data (i.e. x and y)...
  GLfloat x, y, z;
};
 
       vector<Vertices> arMyClass;
 
     arMyClass.push_back(Vertices(0.0f, 0.0f,1.0f));
     arMyClass.push_back(Vertices(1.0f, 0.0f,0.0f));

[gbdivers]

Oui c'est bon. (presque : le nom est mal choisit ; vertices = ensemble de vertex ; ta classe représente un vertex et non des vertices)

Si tu connais la taille, tu peux allouer directement un tableau contenant le nombre de de vertex nécessaire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

vector<Vertices> arMyClass(Nb_Vertices); // ou avec resize()

Si tu connais pas le nombre exacte mais que tu as une idée de l'ordre de grandeur (100, 1000, 100000 des vertices...), tu peux réserver une taille pour éviter les réallocations :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
vector<Vertices> arMyClass;
arMyClass.resize(Nb_Vertices_Probable);

Pour comprendre la différence entre un tableau de GLfloat (ou de Vertex) et un tableau de pointeurs de Vertex (Vertex*) d'un point de vue de la mémoire, je t'ai fait un petit schéma.

[gbdivers]

Tu peux également ajouter dans ta classe StructureObjet le constructeur par copie, l'opérateur d'affectation = et les opérateurs d'égalité et de différence (== et !=)

La copie et l'affectation devrait être générée automatiquement et de façon approprié par le compilateur pour une classe comme celle-ci. Nul besoin de les redéfinir. (cf F.A.Q.)

En fait, je vais être encore plus critique sur ce que j'ai dit : il ne faut surtout pas avoir besoin de redéfinir le constructeur par copie ou l'opérateur d'affectation.

Pour que le tableau de Vertex vector<Vertex> soit un tableau de GLfloat, il faut absoluement que la classe Vertex ne contiennent que les GLfloat. Donc pas de pointeur ou d'autres structures. Donc si on a besoin de redéfinir le constructeur par copie, c'est qu'il y a un problème.

Donc il faut oublier ce que j'ai dit : pas de redéfinition du constructeur par copie (sauf traitement spécifique fait dans le constructeur mais je vois pas quoi à priori)

Donc d'où l'utilité d'un non pointé pour l'utilisation de la méthode VBO :

glBufferData(target, v.size() *3* sizeof( GLfloat ), NULL, mode);

Block de memoire contigüe c'est ca ?

Oui, les buffers copy prennent l'adresse d'un bloc mémoire et la taille du bloc mémoire et le copie en une seule fois dans la mémoire gpu. Donc il faut que les données forment un seul bloc en mémoire (données contiguës).

Par contre, petit détail, ton code ne copie pas les données vers le gpu. Il faut également donner le pointeur vers tes données (ou appeler la copie explicitement) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

glBufferData(target,  v.size() *3* sizeof( GLfloat ), &VertexArray[0], mode);

[regsregs]

Il me reste quand même des interrogations, quand vous dites pas besoin de redéfinir le constructeur par copie, là il y'a bien un constructeur de copie là :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
class Vertices
{
public:
     Vertices (GLfloat const& def_x, GLfloat const& def_y, GLfloat const& def_z) : x(def_x), y(def_y), z(def_z) {} // constructeur de copie
       GLfloat x, y, z;
};

Si j'en met pas ? comment envoyer mes valeurs ? Je sens que je dis des bétises

Et pour le VBO, en fait je fais ensuite un glBufferSubData, c'est pas utile ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
         void  monObjet::initVBO(Vertex& v)
     {
         glGenBuffers(1,&bufVertex);
         glBindBuffer(target, bufVertex);
         glBufferData(target,  v.size()*3 * sizeof( GLfloat ), NULL, mode);
         glBufferSubData(target, 0,  v.size()*3*sizeof( GLfloat ),  v);
    }