Salut à tous, je voulais savoir si il était possible de combiner la SDL et GLUT?

Par exemple, utiliser SDL pour amorcer OpenGL et donc s´en servir comme gestionnaire de fenètre, et utiliser des fonctions de GLUT tel que par exemple glutWireSphere.

merci par avance.

@bientôt.

Bonne question. A essayer...
Mais Glut risque de faire conflit avec SDL.
Si tu veux juste utiliser les fonctions de sphere, il existe plein de librairies qui t´offrent des fonctions pour les modeles 3D de base.
Au pire, tu peux les refaire toi meme : c´est rigolo a faire

Merci, pour la fonction que j´ai donné, c´était juste au hasard, car pour les sphères, il suffit d´utiliser les quadriques avec GLU.

Seulement, c´est juste parceque certaines fonctions de GLUT sont interressantes, c´est pour cela que je posais la question. Profiter de fonctions pratiques de GLUT avec l´amorçage SDL, je trouvais l´idée interressante.

Ah si, pour glutWireSphere, j´ai une question, il semblerai que cette routine calcule elle même les normales des vertex, ce qui est fort pratique pour l´éclairage alors que pour les fonctions de GLU, je crois qu´il faut tout se taper sois-même. C´est vrai?

Oui, mais c´est intéressant de se taper ça sois meme

Et puis, une normale un point P sur une sphere, c´est le vecteur OP normalisé (O le centre)
Pas bien dur quand meme ?

Tu as tout à fait raison, ce n´est pas bien compliqué, c´est juste histoire de gagner du temps.

Sinon, en parlant de creer soit même sa fonction de création de sphère, il y a plusieurs façons de procéder:

Soit comme GlU avec les slices et stacks, soit construire sa sphere plutôt avec pleins de triangles. Et pour ´lisser´ la sphere, il suffit de diviser chaque triangle (equilateral) en trois triangles ´poussés´ un peu vers l´extérieur. Et plus on découpe nos triangle, plus la sphere ressemble à une sphere bien ronde.
On peut faire ça récursivement.

En terme de complexité, quelle est la meilleur solution?

Pour la seconde, ça m´a tout l´air d´être exponentiel :p
Donc, sans connaître la première méthode (mon domaine n´est pas la 3D), je pencherai plutôt pour celle-ci (En plus, l´aspect récursif de la seconde me fait fuir, à moins qu´on puisse facilement dérécursiver).

hitman, pourquoi ca serait exponentiel ?
Tu peux controler le nombre de degré de point a afficher.
de plus exponentiel en quoi ? en le nombre de point que tu veux afficher ?

Par contre ca me fait dire qu´avec cette méthode la tu ne dois pas pouvoir générer de sphere en n point avec n quelconque. je penses qu´il y a une forme au n générable.

Finalement ca reviens presque au probleme de TIPE qu´a posé dnob700

j´ai déja implémenter la 2e méthode, je la trouve puissante.

J´ai trouvé qu´un lien vers des pages google, regardez les spheres bleues au milieu (ça marque recursive process)
y´en a 2. la premiere est en récursivité d´un seul niveau, la 2e en 2 niveaux a peine

http://images.google.fr/images?svnum=10&hl=fr&lr=&q=sphere+recursive

Avec une récursivité de niveau 2 et 3, on obtiens un résultat tres tres joli.

hitman_alias_47 > la 1e méthode, la plus connue, c´est la façon de modéliser méridionnale (un peu comme la terre avec les méridiens dessinés), son inconvénient est la non homogénéité des triangles (les poles sont plus triangulés que le reste) :
http://upload.wikimedia.org/wikipedia/commons/thumb/f/f2/WireSphereStdTass.MaxDZ8.jpg/300px-WireSphereStdTass.MaxDZ8.jpg

Moi j´aime bien la méthode récursive

A propos hitman_alias_47, je lis tes topics depuis quelques temps, tu as l´air bien baleze

Dans quoi travailles tu ?

comme le dit godrik, ça revient tout a fait à mon TIPE.

Le problème de la construction à base de triangle, c´est qu´il faut partir avec une triangulation avec déjà pas mal de point, sinon ça dégénère très vite en quelque chose de pas du tout homogène.

pour ceux qui ne veulent pas utiliser la méthode GLU de latitude/longitude (qui se fait en temps linéaire, mais au pole, on gaspille des faces), il y a une autre solution qui consiste à placer d´abords les sommets de la sphère en spirale (temps linéaire) sur la sphère, puis à calculer les arêtes de l´enveloppe convexe (en O(n²) du nombre de faces ou de sommets). pour obtenir les faces triangulaire de la sphère.

Oui, par exemple partir au minimum avec un icosaèdre.

Sinon, ta méthode est intéressante, mais je vois pas bien comment tu t´y prend pour la construction de ta sphere.

pour des info sur cette méthode, tu peut te reporter à mon site (
http://particules.sectionpc.info ) et dans la bibliographie regarde le dernier lien (vers la fin du documents) et l´avant dernier pour une explication des deux étapes que j´ai décrites ci-dessus.

Personnellement, je pars d´un octaedre

http://www.mathsaharry.com/fig/octaedre.jpg

8 faces, 6 points
(0,0,1), (0,0,-1), (1,0,0), (-1,0,0), (0,1,0), (0,-1,0)

dernier et avant avant dernier liens depuis la mise à jour (Cf mon message précédant).

j´ai généré avec mon programme des images d´une sphère avec la méthode de jyy :
http://www.sectionpc.info/divers/sphere/
on voit qu´effectivement en partant de seulement 8 faces, on peut atteindre 216 ou 648 faces (ce qui est plus que largement suffisant la plupart du temps je pense pour une simple sphère) sans trop de défaut.

Voila le lien que je cherchais je parlais de la méthode octaedre (mais comme tu vois, y´en a d´autres.

http://student.ulb.ac.be/be/~claugero/sphere/index.html

dnob700 >

void recursSphere(Vecteur a,Vecteur b,Vecteur c,int precision)
{
if (precision==0)
{
Normalize(a);
Normalize(b);
Normalize(c);
glBegin(GL_TRIANGLES);
glNormalV(a);glVertexV(a);
glNormalV(b);glVertexV(b);
glNormalV(c);glVertexV(c);
glEnd();
return;
}
recursSphere(a,(a+b)/2,(a+c)/2,precision-1);
recursSphere((a+b)/2,b,(b+c)/2,precision-1);
recursSphere((a+c)/2,(b+c)/2,c,precision-1);

recursSphere((a+c)/2,(a+b)/2,(b+c)/2,precision-1)
;
}

void Sphere(int precision)
{

recursSphere(Vecteur(1,0,0),Vecteur(0,1,0),Vecteu
r(0,0,1),precision);

recursSphere(Vecteur(0,1,0),Vecteur(-1,0,0),Vecte
ur(0,0,1),precision);

recursSphere(Vecteur(-1,0,0),Vecteur(0,-1,0),Vect
eur(0,0,1),precision);

recursSphere(Vecteur(0,-1,0),Vecteur(1,0,0),Vecte
ur(0,0,1),precision);

recursSphere(Vecteur(0,1,0),Vecteur(1,0,0),Vecteu
r(0,0,-1),precision);

recursSphere(Vecteur(-1,0,0),Vecteur(0,1,0),Vecte
ur(0,0,-1),precision);

recursSphere(Vecteur(0,-1,0),Vecteur(-1,0,0),Vect
eur(0,0,-1),precision);

recursSphere(Vecteur(1,0,0),Vecteur(0,-1,0),Vecte
ur(0,0,-1),precision);
}

je vous laisse adapter ça a votre sauce, sachant que j´utilise une classe "Vecteur" ou j´ai redéfini l´arithmétique vectorielle, et que j´ai surchargé glVertex et glNormal avec "V" pour que ça prenne un vecteur.

Pour ceux qui me diront "et le rayon et le centre ?"
--> gltranslate et glscale sont nos amis

Intéressant tout cela. Merci à vous deux.