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/

[gbdivers]

Le problème est que là, que transmet à OpenGL un tableau de GLfloat* et non un tableau de GLfloat.
Ton StructureObjet (le nom n'est pas bien choisit je pense) à une sémantique de valeur donc tu dois créer un tableau de vector<StructureObjet>.
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 !=)

[regsregs]

Voilà je suis paumé

On dit d'une classe qu'elle a une sémantique de valeur si deux objets situés à des adresses différentes, mais au contenu identique, sont considérés égaux.

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

[gbdivers]

Code :

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

1
2
3
StructureObjet A (0, 0, 0);
StructureObjet B (0, 0, 0);
assert(A == B);

Tu as bien 2 objets différents (donc situés à des adresses différentes en mémoire) mais qui représente le même point (l'origine).

[gbdivers]

De toute façon, peut importe (pour le moment) la définition de la sémantique associée à ta classe. Le plus important est qu'il faut passer un tableau de GLfloat et non de GLFloat*, ce qui implique que ta classe doit avoir un constructeur par copie, ce qui implique obligatoirement une sémantique de valeur.

[regsregs]

Exact donc faudrait utiliser un constructeur par copie,

Dans les faits ca donnerait quoi ?

[gbdivers]

Pour le moment, tu as une structure qui ne contient pas de pointeur donc le constructeur par copie par défaut est suffisant. Un petit tour sur la FAQ : Qu'est-ce qu'un constructeur de copie ?
En pratique, ça donne ça (je suis gentil aujourd'hui, je donne du code ):

Code :

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

StructureObjet(StructureObjet const& o) : x(o.x), y(o.y), z(o.z) {}

[regsregs]

Ok merci pour ta gentillesse

[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.