Discussion :

[yan]

Ceci est un fork de la présentation de khayyam90 pour le défi Qt.
http://www.developpez.net/forums/d85...participation/

J'irais même à dire : ouf, il n'en a pas fait. Ça ressemble un peu plus à des horreurs...

Cela semble pas aussi compliqué. Il explique comment faire ici
http://images.math.cnrs.fr/Mandelbulb.html

Beau Buddha, je sais pas ce qu'il a de spécial, mais il me plaît bien !

je le trouve aussi très jolie.

[khayyam90]

C'est quand même tentant de faire un rendu 3D, je vais peut-être essayer ...

[yan]

C'est quand même tentant de faire un rendu 3D, je vais peut-être essayer ...

La méthode étant au pixel, il semble que tu peut (presque?) faire du temps réelle avec les shaders.

[wax78]

Juste pour le fun car j'ai vu que vous vouliez de la 3D (mandelbulb donc) Je suis sure que ca va motiver certains (je l'espere du moins).

Une image de 132 Megapixels d'un mandelulb : http://renaud.warnotte.be/index.php/...132-megapixels (il faut cliquer sur l'image pour qu'une nouvelle page s'ouvre avec un truc a la google earth pour visualiser l'image (openLayers en fait pour etre précis)

Des videos (precalcul de 12 heure sur GPU) :

(Temps réel) : [video=youtube;bsz0WMSTJaE]http://www.youtube.com/watch?v=XlCCmWpVLJs"]YouTube- Another experiment with mandelbulb. Realtime footage[/url], [url="http://www.youtube.com/watch?v=bsz0WMSTJaE[/video] et il y'en a d'autres faites main.

Le truc (avec l'environment reflection, ambient occlusion et de l'ombrage a 1 sample) arrive a tourner a > 20 FPS en 512*512 juste pour s'imaginer.

[yan]

Le truc (avec l'environment reflection, ambient occlusion et de l'ombrage a 1 sample) arrive a tourner a > 20 FPS en 512*512 juste pour s'imaginer.

Tu la trouvé ou?

[wax78]

Tu la trouvé ou?

Quoi l'algorithme d'un mandelbulb ou le programme qui l'affiche ?

L'algo je l'ai trouvé a gauche a droite (subblue.com notament pour la fct DE et skytopia.com et la http://images.math.cnrs.fr/Mandelbulb.html).

Le programme c'est fait main en java avec jogl, le shader du mandelbulb et ce qu'il faut pour se promener dedans, faire des animations et autres joyeuseté visuelle (avec keyframe et interpolation des valeurs histoire d'avoir un truc smooth).
Je travaille toujours dessus actuelement, mon idée serait d'arriver a générer un image de 500 megapixel puis 1 giga pixels (soyons fou).

[yan]

Quoi l'algorithme d'un mandelbulb ou le programme qui l'affiche ?

L'algo je l'ai trouvé a gauche a droite (subblue.com notament pour la fct DE et skytopia.com).

Le programme c'est fait main en java avec jogl, le shader du mandelbulb et ce qu'il faut pour se promener dedans, faire des animations et autres joyeuseté visuelle (avec keyframe et interpolation des valeurs histoire d'avoir un truc smooth).
Je travaille toujours dessus actuelement, mon idée serait d'arriver a générer un image de 500 megapixel puis 1 giga pixels (soyons fou).

ha ok. C'est toi qui l'as fait.
Très jolie.
500Mpix et 1Gpix, ca fait quel taille (mal au crâne pour calculer )
Ca me paraît gros pour le faire en OpenGl.

[wax78]

ha ok. C'est toi qui l'as fait.
Très jolie.
500Mpix et 1Gpix, ca fait quel taille (mal au crâne pour calculer )
Ca me paraît gros pour le faire en OpenGl.

Merci,

Une image de 625 Megapixel aurait une resolution si je la calcul correctement de 25000*25000 pixels. (si on garde un carré).

Ca te parait gros et tu as raison mais c'est tout a fait réalisable.

Il y'a 2 probleme a resoudre pour faire de tres grosse images :

1) La taille de memoiré video ou meme ram qui limite forcement -> solution, diviser l'image en petites image et les calculer l'une a la suite de l'autre pour ensuite les combiner par apres. Ce que je fais pour des images > 1024 par exemple.

2) Il semblerait (je ne sais pas pourquoi) mais si tu utilise un shader extremement lent, et que tu ton image mets trop de temps a etre rendue dans la boucle "display()" d'opengl alors le driver (nvidia dans mon cas) provoque un bel ecran bleu, suivi d'un joli warning (la tu px couper l'applic t'as tout perdu ^^). -> solution, ne pas dessiner dans l'appel de display(); un gros carré faisant toute la taille de l'ecran (ce que l'on désire au final) mais a chaque fois un petit carré de ce gros carré (en ne vidant pas le frame buffer)
cela evite le super plantage mais ralentit considerablement le processus et obligé a une horrible magouille dans le code. Si quelqu'un sait pourquoi et/ou comment eviter ce probleme je suis preneur.

[yan]

1) La taille de memoiré video ou meme ram qui limite forcement -> solution, diviser l'image en petites image et les calculer l'une a la suite de l'autre pour ensuite les combiner par apres. Ce que je fais pour des images > 1024 par exemple.

On peut faire un rendu que d'une partie de l'image final en OpenGl? ou il faut faire plusieurs points de vue(en projection ortho par exemple)?

2) Il semblerait (je ne sais pas pourquoi) mais si tu utilise un shader extremement lent, et que tu ton image mets trop de temps a etre rendue dans la boucle "display()" d'opengl alors le driver (nvidia dans mon cas) provoque un bel ecran bleu, suivi d'un joli warning (la tu px couper l'applic t'as tout perdu ^^). -> solution, ne pas dessiner dans l'appel de display(); un gros carré faisant toute la taille de l'ecran (ce que l'on désire au final) mais a chaque fois un petit carré de ce gros carré (en ne vidant pas le frame buffer)
cela evite le super plantage mais ralentit considerablement le processus et obligé a une horrible magouille dans le code. Si quelqu'un sait pourquoi et/ou comment eviter ce probleme je suis preneur.

passer à du cuda? faire un rendu en background (au cas où tu fait le rendu directement dans une fenêtre Windows)?
Je ne serais pas étonné que pour de l'affichage, y as un timeout (ou un composant qui attend, ou truc du style) où le drivers pense qu'il est planté.

[wax78]

On peut faire un rendu que d'une partie de l'image final en OpenGl? ou il faut faire plusieurs points de vue(en projection ortho par exemple)?


passer à du cuda? faire un rendu en background (au cas où tu fait le rendu directement dans une fenêtre Windows)?
Je ne serais pas étonné que pour de l'affichage, y as un timeout (ou un composant qui attend, ou truc du style) où le drivers pense qu'il est planté.

Je me suis mal exprimé. C'est un fragment shader qui fait tout, pas vraiment OPENGL. Je ne fait que me mettre en mode ORTHOGRAPHIQUE et afficher un carré de la taille de l'ecran. Ensuite c'est le shader qui prends le relais. Et oui il va de toute facon falloir faire plusieurs "prise" (logique a moins d'avoir un framebuffer de 90000*90000 ce qui n'existe pas je pense).
Dans ce cas je change les coordonée de texture en opengl pour "deplacer" l'image et donc avoir les bouts correcte qui vont composé la grosse image finale. (Donc cette magouille se situe au niveau opengl et pas dans le shader qui n'y voit que du feu).

Passer a du cuda ?! non j'aime bien mes petit shader pour le moments (Cuda il faut une geforce 8 mini non ? j'ai c'est pas ca le probleme). Mais a mon avis j'essayerai quand meme un jour de m'y mettre pour de bon a cuda.

Par contre ce que tu me dis m'interpelle au niveau affichage. En effet pour le moment j'affiche dans une fenêtre...

Si j'utilisais un pixel buffer sans affichage tu penses que je n'aurai le probleme du timeout ? (J'ai un autre programme qui utilise le meme principe mais j'ai utilisé un pixel buffer et je crois me souvenir avoir eu aussi le probleme mais je n'en suis pas certains)

[yan]

Si j'utilisais un pixel buffer sans affichage tu penses que je n'aurai le probleme du timeout ? (J'ai un autre programme qui utilise le meme principe mais j'ai utilisé un pixel buffer et je crois me souvenir avoir eu aussi le probleme mais je n'en suis pas certains)

Ca vaut le coup de tester. Au pire cela plante
Après la raison du plantage, je ne fait que supposer. Peut être que suivant le drivers ça plante pas.

Pour une image de cette taille est plus, je serais partie sur un pseudo lancer de rayon. Ça évite de faire des projections orthogonale et tu n'as pas besoin d'allouer autant de mémoire dans la RAM, tu peut exploiter un fichier.

[wax78]

Ca vaut le coup de tester. Au pire cela plante
Après la raison du plantage, je ne fait que supposer. Peut être que suivant le drivers ça plante pas.

Pour une image de cette taille est plus, je serais partie sur un pseudo lancer de rayon. Ça évite de faire des projections orthogonale et tu n'as pas besoin d'allouer autant de mémoire dans la RAM, tu peut exploiter un fichier.

Oui je peux toujours tester ca se soir histoire de voire ca serait bien que ca règle le probleme mais j'ai qlq doutes

C'est un lanceur de rayons que j'ai fait dans le shader. La projection orthogonal ne me sert qu'a dessiner un carré sur l'ecran. Ce carré est ensuite remplis pixel par pixel par le fragment shader qui lui contient "le raytracer".

(Désolé si je parrais un peu lourd je m'exprime comme un pieds souvent, ou alors je n'ai pas compris tout ^^)

Je comprends ce que tu vx dire par ecrire dans un fichier, mais quoiqu'il arrive si tu dois dessiner une image geante, tu es obligé de la decouper en petit morceau pour le rendu sinon ca ne tiendra pas en mémoire (ni graphique, ni RAM).
Donc je sauve chaque petit morceau dans un fichier PNG (il suffit de rassembler les morceau par apres pour avoir l'image geante).

Sinon j'aimes bien certains de tes rendus aussi

[yan]

C'est un lanceur de rayons que j'ai fait dans le shader. La projection orthogonal ne me sert qu'a dessiner un carré sur l'ecran. Ce carré est ensuite remplis pixel par pixel par le fragment shader qui lui contient "le raytracer".

Tu calcul l'ombre en tirant un rayon vers la sources? Je sais pas jusqu'où on peut aller avec les shaders.

Je comprends ce que tu vx dire par ecrire dans un fichier, mais quoiqu'il arrive si tu dois dessiner une image geante, tu es obligé de la decouper en petit morceau pour le rendu sinon ca ne tiendra pas en mémoire (ni graphique, ni RAM).

Rien n'empêche de ne pas faire d'image intermédiaire et d'écrire directement chaque pixels dans un fichier. En gros c'est utiliser le fichier comme une mémoire alloué sur la RAM.

Donc je sauve chaque petit morceau dans un fichier PNG (il suffit de rassembler les morceau par apres pour avoir l'image geante).

dans ton cas, comme c'est sur la carte graphique , tu n'as pas trop le choix. Je ne pense pas que tu peut manipuler un fichier à partir des shaders.

Sinon j'aimes bien certains de tes rendus aussi

merci

[yan]

Question comment cela marche pour faire ceci avec les shader?
un truc comme ?

1- on créé un carré
2- le vertex shader ne fait rien
3- tous est calculés sur le pixel shader

[wax78]

Tu calcul l'ombre en tirant un rayon vers la sources? Je sais pas jusqu'où on peut aller avec les shaders.

Rien n'empêche de ne pas faire d'image intermédiaire et d'écrire directement chaque pixels dans un fichier. En gros c'est utiliser le fichier comme une mémoire alloué sur la RAM.

dans ton cas, comme c'est sur la carte graphique , tu n'as pas trop le choix. Je ne pense pas que tu peut manipuler un fichier à partir des shaders.

- Oui je calcule l'ombre de cette maniere, je regarde si le rayon intersect avec l'objet ou va directement sur la lampe et j'obtient la valeur d'eclairage.

- Oui mais il faut que je recupere les pixels fraichement calculé de la carte graphique vers la ram, et ensuite je px ecrire dans un fichier si je désire. En theorie j'ai fait mon systeme pour n'etre bloqué par rien niveau taille. Le dernier truc qui m'a bloqué etait d'avoir un programme pour visualiser le resultat d'une image genre 20000x20000 facilement et le partage. D'ou j'ai trouvé OpenLayer qui fait ca impeccable.

1- on créé un carré
2- le vertex shader ne fait rien
3- tous est calculés sur le pixel shader

1) en gros je fais ceci pour me dessiner un carré qui fait la surface de l'ecran (de 0,0 a 1,1 en fait) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
gl.glBegin(GL.GL_QUADS);
gl.glMultiTexCoord2f(GL.GL_TEXTURE0, sox + (ox + 0) * tex_size, (oy + 0) * tex_size);
gl.glVertex2f((ox + 0) * vertex_size - vertex_uni / 2, (oy + 0) * vertex_size - vertex_uni / 2);
 
gl.glMultiTexCoord2f(GL.GL_TEXTURE0, sox + (ox + tex_uni) * tex_size, (oy + 0) * tex_size);
gl.glVertex2f((ox + 1) * vertex_size - vertex_uni / 2, (oy + 0) * vertex_size - vertex_uni / 2);
gl.glMultiTexCoord2f(GL.GL_TEXTURE0, sox + (ox + tex_uni) * tex_size, (oy + tex_uni) * tex_size);
gl.glVertex2f((ox + 1) * vertex_size - vertex_uni / 2, (oy + 1) * vertex_size - vertex_uni / 2);
gl.glMultiTexCoord2f(GL.GL_TEXTURE0, sox + (ox + 0) * tex_size, (oy + tex_uni) * tex_size);
gl.glVertex2f((ox + 0) * vertex_size - vertex_uni / 2, (oy + 1) * vertex_size - vertex_uni / 2);
gl.glEnd();

2) Le vertex shader fait "rien", il reste assez classique :

Code :

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

1
2
3
4
5
6
7
8
9
varying vec3 Position;
 
void main() 
{
   gl_Position = ftransform();
   gl_FrontColor = gl_Color;
   gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
   Position = vec3(gl_MultiTexCoord0);
}

3) Tout est calculé sur le pixel shader.

Position de la camera est calculé au debut plus 2 3 autres babioles,
qlq fonctions genre estimation de la distance, intersection ray<->sphere, calcul de la normal.

Ensuite le main du fragment shader ressemble a celui d'un raytracer habituelle :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
 
...
...
 
// The main loop
void main()
{
   vec2 p = vec2(Position); // position du pixel sur le carré
   vec4 c = renderPixel(p); // Calcule la trajectoire du rayon et tout le reste pour obtenir la couleur a cet endroit la.
   gl_FragColor = c;
}

[yan]

D'ou j'ai trouvé OpenLayer qui fait ca impeccable.

je te conseil zoomify. Cela marche carrément mieux et c'est plus adapté
http://ftp-developpez.com/yan-verdavaine/fractale/
ici il affiche une image de 20000x20000

Cool, j'ai à peu prés compris comment marche les shaders . Va bien falloir que j'essaie un de ces jours.

merci pour les explications.

[wax78]

je te conseil zoomify. Cela marche carrément mieux et c'est plus adapté
http://ftp-developpez.com/yan-verdavaine/fractale/
ici il affiche une image de 20000x20000

Cool, j'ai à peu prés compris comment marche les shaders . Va bien falloir que j'essaie un de ces jours.

merci pour les explications.

Ha oui c'a n'as effectivement pas l'air mal. Il fait meme les transition pdt les chargements des tiles. Je testerai pour la prochaine image si j'en sort encore une.

Et bien bonne amusement avec les shaders en tout cas. Et bonne continuation dans les rendus de jolies fractales.

EDIT : utiliser un Pbuffer n'as pas resolu mon probleme d'ecran noir et du plantage du driver avec le message 'Display driver stopped responding'

[Z3vil]

extra, & dur
est ce que si possible de le creer avec Qt (QPixmap/Image,QPainter) ? bah moi je vois pas comment

ou il y a quelque chose dans Qt pour faire un dessin 3D sans OpenGL?

[yan]

extra, & dur
est ce que si possible de le creer avec Qt (QPixmap/Image,QPainter) ? bah moi je vois pas comment

ou il y a quelque chose dans Qt pour faire un dessin 3D sans OpenGL?

OpenGl n'est pas obligatoire pour faire de la 3D, tu peut le faire à la main

Qt fournie un module pour de l'opengl et du GLSL
http://qt.developpez.com/doc/latest/qtopengl.html

Mais aussi des classes (peut être depuis 4.6) pour faire des math en 3D
QVector3D
QVector2D
QQuaternion
QMatrix4x4

Pour rassurer les participants , réussir à faire un mandelbulb permettra uniquement d'avoir un tous petit bonus au même tire que d'avoir proposé des fractale qui n'était pas dans le générateur. Ce n'est pas le theme du défis et cela permettra pas d'être le vainqueur

[wax78]

Dommage que QT
n'est pas ma tasse de T
sinon j'aurais participer