Comment dessiner une enveloppe remplie comme un cône dans OpenGL (avec GLUT)?
https://stackoverflow.com/questions/237899
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
J'utilise freeglut pour le rendu opengl ...
Je dois dessiner une enveloppe ressemblant à un cône (2D) à remplir avec de la couleur et de la transparence.
La boîte à outils de freeglut est-elle équipée de cette fonctionnalité intégrée pour dessiner des géométries pleines (ou une astuce)? ou existe-t-il une autre api dotée d’un support intégré pour les géométries pleines?
Modifier1: Juste pour clarifier la chose du cône 2D ... l'enveloppe est l'interprétation graphique de la zone de couverture d'un avion lors de l'interception (d'un avion ennemi) ... qui ressemble à un secteur de cercle ... j'aurais dû plutôt mentionner un secteur. .
et glutSolidCone ne m'aident pas car je veux dessiner un secteur rempli d'un cercle ... ce que j'ai déjà fait ... ce qu'il reste à faire est de le remplir avec de la couleur ... comment remplir les géométries avec de la couleur en opengl?
Modifier2: Toutes les réponses postées à cette question peuvent résoudre mon problème d'une certaine manière. Mais j'aimerais certainement savoir comment remplir une géométrie avec une couleur. Dites si je veux dessiner une enveloppe qui est une parabole ... dans ce cas, il n'y aurait pas de fonction de saturation par défaut pour dessiner une parabole remplie (ou y en a-t-il?) .. Donc, pour généraliser cette question ... comment dessiner une géométrie personnalisée dans une couleur unie?
Modifier3: La réponse publiée par mstrobl fonctionne pour GL_TRIANGLES mais pour un tel code:
glBegin(GL_LINE_STRIP);
glColor3f(0.0, 0.0, 1.0);
glVertex3f(0.0, 0.0, 0.0);
glColor3f(0.0, 0.0, 1.0);
glVertex3f(200.0, 0.0, 0.0);
glColor3f(0.0, 0.0, 1.0);
glVertex3f(200.0, 200.0, 0.0);
glColor3f(0.0, 0.0, 1.0);
glVertex3f(0.0, 200.0, 0.0);
glColor3f(0.0, 0.0, 1.0);
glVertex3f(0.0, 0.0, 0.0);
glEnd();
qui dessine un carré ... seul un carré câblé est dessiné ... je dois le remplir de couleur bleue.
quand même le faire?
si je mets des commandes de dessin pour une courbe fermée..comme une tarte..et j'ai besoin de la remplir avec une couleur, y a-t-il un moyen de le rendre possible ...
Je ne sais pas comment c'est possible pour GL_TRIANGLES ... mais comment le faire pour toute courbe fermée?
La solution
Sur Edit3: Si je comprends bien votre question, vous voulez que OpenGL trace des frontières et que tout ce qui les sépare soit rempli de couleurs.
L’idée que vous avez eue était juste, mais une bande de lignes n’est que cela - une bande de lignes, et elle n’a pas de zone.
Vous pouvez cependant avoir les lignes connectées les unes aux autres pour définir un polygone. Cela remplira la surface du polygone sur une base par sommet. Adapter votre code:
glBegin(GL_POLYGON);
glColor3f(0.0, 0.0, 1.0);
glVertex3f(0.0, 0.0, 0.0);
glColor3f(0.0, 0.0, 1.0);
glVertex3f(200.0, 0.0, 0.0);
glColor3f(0.0, 0.0, 1.0);
glVertex3f(200.0, 200.0, 0.0);
glColor3f(0.0, 0.0, 1.0);
glVertex3f(0.0, 200.0, 0.0);
glColor3f(0.0, 0.0, 1.0);
glVertex3f(0.0, 0.0, 0.0);
glEnd();
Notez cependant que dessiner un polygone de cette façon a deux limitations:
- Le polygone doit être convexe.
- Ceci est une opération lente.
Mais je suppose que vous voulez juste faire le travail, et cela le fera. Pour l’avenir, vous pourriez envisager de trianguler votre polygone.
Autres conseils
Je ne suis pas sûr de ce que vous entendez par "une enveloppe", mais un cône est un primitif que glut a:
glutSolidCone(radius, height, number_of_slices, number_of_stacks)
Le moyen le plus simple de le remplir avec de la couleur est de le dessiner avec de la couleur. Puisque vous voulez le rendre quelque peu transparent, vous avez également besoin d’une valeur alpha:
glColor4f(float red, float green, float blue, float alpha)
// rgb and alpha run from 0.0f to 1.0f; in the example here alpha of 1.0 will
// mean no transparency, 0.0 total transparency. Call before drawing.
Pour que le rendu soit transparent, le fondu doit être activé. Et vous devez définir la fonction de fusion à utiliser. Ce que vous voulez faire sera probablement réalisé avec ce qui suit. Si vous voulez en savoir plus, laissez-moi un commentaire et je chercherai de bons indicateurs. Mais voici votre configuration:
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
Appelez-le avant d’effectuer toute opération de dessin, éventuellement lors de l’initialisation du programme. :)
Depuis que vous avez reformulé votre question en demandant une tarte: il existe un moyen simple de dessiner cela à l'aide de primitives opengl:
Vous dessinez une sphère solide en utilisant gluSolidSphere (). Cependant, comme vous ne voulez en dessiner qu’une partie, il vous suffit de couper les parties non désirées:
void glClipPlane(GLenum plane, const GLdouble * equation);
Le plan étant GL_CLIPPLANE0 à GL_CLIPPLANEn et l’équation étant une équation plane sous forme normale (a x + b y + c * z + d = 0 signifierait que l’équation conserverait les valeurs { a, b, c, d} .Veuillez noter que ce sont des doubles et non des flottants.
Je me souviens qu'il y avait un sous-programme pour cela. Mais ce n’est ni trop difficile à faire par vous-même.
Mais je ne comprends pas le 2D-chose. Cône en 2D? N'est-ce pas juste un triangle?
En tout cas, voici un algorithme pour dessiner un cône en opengl
Prenez d’abord un cercle, subdivisez-le uniformément pour obtenir une bonne quantité d’arêtes. Maintenant, choisissez le centre du cercle, faites des triangles des bords au centre du cercle. Sélectionnez ensuite un point sur le cercle et créez des triangles allant des arêtes à ce point.
La forme et l’orientation de la taille dépendent des valeurs que vous utilisez pour générer le cercle et les deux points. Chaque étape est assez simple et ne devrait pas vous causer de problèmes.
Commencez par subdiviser une valeur scalaire. Commencez à partir de [0-2]. Prenez le point milieu ((début + fin) / 2) et divisez la plage avec celui-ci. Stockez les valeurs par paires. Par exemple, la subdivision une fois devrait vous donner: [(0,1), (1,2)] Faites ceci de manière récursive plusieurs fois, puis calculez quels sont ces points sur le cercle. Trigonométrie simple, rappelez-vous simplement de multiplier les valeurs avec & # 960; avant de procéder. Après cela, vous avez un certain nombre d'arêtes. 2 ^ n où n est le nombre de subdivisions. Ensuite, vous pouvez simplement les transformer en triangles en leur attribuant un point de sommet supplémentaire. La quantité de triangles finit donc par être: 2 ^ (n + 1). (Les montants sont utiles pour savoir si vous le faites avec des tableaux de taille fixe.
Modifier: Ce que vous voulez vraiment, c'est un gâteau. (Désolé le jeu de mots)
Le rendu est également simple. Vous pouvez encore utiliser seulement des triangles. Il suffit de sélectionner la plage scalaire [-0,25 - 0,25], de subdiviser, de projeter en cercle et de générer un ensemble de triangles.
La projection scalaire - circulaire est simple comme suit: x = cos (v * pi) r, y = sin (v pi) * r où (x, y) est le sommet résultant, r est un rayon, et les fonctions trigonométriques fonctionnent sur les radiances, pas sur les degrés. (s’ils travaillent avec des degrés, remplacez pi par 180)
Utilisez des tampons de vertex ou des listes pour le rendre vous-même.
Modifier: à propos de la question de coloration. glColor4f, si vous souhaitez que certaines parties de la géométrie soient différentes par leur couleur, vous pouvez attribuer une couleur à chaque sommet dans le tampon de vertex lui-même. Je ne connais pas actuellement tous les appels d'API pour le faire, mais la référence d'API dans opengl est tout à fait compréhensible.
Sur l'édition des couleurs:
OpenGL est en fait une machine à états. Cela signifie que la position actuelle du matériau et / ou de la couleur est utilisée lors du dessin. Puisque vous n'utiliserez probablement pas de matériaux, ignorez-le pour l'instant. Vous voulez des couleurs.
glColor3f(float r, float g, float b) // draw with r/g/b color and alpha of 1
glColor4f(float r, float g, float b, float alpha)
Ceci affectera les couleurs des sommets que vous dessinez, de toute géométrie que vous rendez, que ce soit de la glu ou de la vôtre, une fois que l'appel de glColorXX a été exécuté. Si vous dessinez une face avec des sommets et modifiez la couleur entre les appels glVertex3f / glVertex2f, les couleurs sont interpolées.
Essayez ceci:
glBegin(GL_TRIANGLES);
glColor3f(0.0, 0.0, 1.0);
glVertex3f(-3.0, 0.0, 0.0);
glColor3f(0.0, 1.0, 0.0);
glVertex3f(0.0, 3.0, 0.0);
glColor3f(1.0, 0.0, 0.0);
glVertex3f(3.0, 0.0, 0.0);
glEnd();
Mais j’ai déjà souligné glColor4f. Je suppose donc que vous souhaitez définir les couleurs par sommet. Et vous voulez utiliser des listes d’affichage.
Tout comme vous pouvez afficher des listes de sommets, vous pouvez également leur donner une liste de couleurs: il vous suffit d’activer les listes de couleurs et d’indiquer à opengl où se trouve la liste. Bien sûr, ils doivent avoir le même équipement que la liste des sommets (même ordre).
Si vous aviez
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, vertices_);
glDisableClientState(GL_VERTEX_ARRAY);
vous devriez ajouter des couleurs de cette façon. Ils n'ont pas besoin d'être flottants; en fait, vous lui dites quel format il devrait être. Pour une liste de couleurs avec 1 octet par canal et 4 canaux (R, V, B et A), utilisez ceci:
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, vertices_);
glColorPointer(4, GL_UNSIGNED_BYTE, 0, colors_);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
EDIT: vous avez oublié d'ajouter que vous devez ensuite indiquer à OpenGL quels éléments dessiner en appelant glDrawElements .
