Discussion :

[corbane]

Bonjour,

Je viens vous demander de l’aide car après des pages de lecture je n’arrive toujours pas à comprendre certaine procédures pour effectuer les rendus opengl.

Voici ma mise en situation :

• Je souhaite effectuez des rendus dans l’esprit des webgl de www.shadertoy.com.
• L’utilisation de ces rendus doivent me permettre de les utiliser pour du vjing.
  (Le vjing étant la discipline de mixer des images en temps réel, un bon exemple de logiciel est www.resolume.com, mais sans gestion 3d, inadapté pour moi)
• Pour l’initialisation et paramétrages des vertex et shaders, j’utilise Rhino et Grasshopper.
  (Rhino est un modeleur surfacique et Grassopper son éditeur de script visuel)

Voici la ou ma compréhension bloque :

• Ma carte graphique possédant plusieurs sortis d’écran (dans mon cas, des projecteurs). J’aurais parfois besoin d’afficher 3 images jointent (tel 3 écrans cote à cote). Parfois il me faudra avoir 3 images de scènes totalement différentes et certaine autre fois la même scène vu de camera différentes.
• Comment arrive ton grâce au code à satisfaire cette contrainte ? Des kilomètres de texte anglais, français et même espagnol, mon embrouillé je crois. Me voilà perdu avec les Contexte OpenGL, les Contexte de Rendu, et les Threads.

Et pour finir voici ce que j’ai compris :

• La règle de base serait de toujours avoir 1 contexte opengl pour 1 thread.
• Aussi il semblerait que partager ces ressources grâce à wglShareList soit rarement une bonne idée ?
• Pour l’affichage de la même scène cote à cote ou d’angle de vues différents (là, je commence à bloquer). Il me semble qu’il faut 1 contexte et 1 thread avec plusieurs viewport ?
• Pour l’affichage de scènes différentes il me faudrait 1 contexte, 1 thread et 1 viewport pour chacune d’elle ?
• Pour finir de me perdre, certain raconte qu’il faut coder des fonctions de rendus dans un thread principale sans contexte. Puis dans la boucle de rendu des threads possédant un contexte opengl, appelé l’une des fonctions de rendu.

Vous l’aurez compris, je n’arrive pas à structurer mes contextes, viewports, threads et boucles de rendu dès l’instant ou je dois produire plus d’une image. Actuellement, j’ai tout dans ma classe window état dans un thread avec son contexte opengl.
Si vous avez l’âme pédagogue, je serais ravis d’être guider ! : ) Merci à vous.

[dragonjoker59]

Pour faire du rendu multifenêtre, je ferais ainsi:

• 1 seul contexte (autant faire simple pour commencer), qui sert au chqrgement des ressources, et à l'affichage
• 1 seul thread pour le chargement et le rendu (lié au contexte), pas forcément le thread principal de l'application
• Faire mes rendus dans des textures distinctes (via des FBO)
• Pour chaque fenêtre recevant un rendu
  
  • Activer le contexte en lui donnant les informations de la fenêtre où on va dessiner (le HDC, sous Windows, le Drawable sous X11, si je me souviens bien)
  • Dessiner ma texture dans le backbuffer de la fenêtre
  • Désactiver le contexte

L'important là-dedans est de savoir que tu n'as pas besoin d'un contexte par fenêtre, mais d'un contexte par thread.
Donc en travaillant avec un unique thread, tu élimines une source de confusion.
Pour le multithread, c'est une autre paire de manches, je n'ai pas encore réellement essayé, et la seule fois où j'ai tenté, ça n'a pas été concluant... Je ne suis donc pas le mieux placé pour en parler.

[corbane]

Merci pour ta réponse dragonjoker59 ! (autant faire simple pour commencer), çà j’aime bien ! )
En suivant donc tes conseilles, je me suis réalisé un « boilerplate » très épuré que voici :



Il y a cependant des points encore flou pour moi. Au sujet des Threads, je ne comprends pas pourquoi certaine personne font plusieurs threads pour l’affichage. A part ne pas bloquer l’interface utilisateur je ne vois pas quel peut être l’intérêt ? Les cartes graphiques exécute une pile de commandes au plus rapidement possible et nous permet aucune gestion de thread ? Si ?

OpenGL étant basé sur une machine d’état, je dois pouvoir considéré que les « wglMakeCurrent (NULL, NULL) » sont inutile ?

Merci en tout cas, je vais déjas coder tout ça et voir… enfin j’espère quelque chose : )

[LittleWhite]

Bonjour,

Moi, je ferai au plus simple. Mais peut être je me trompe de méthode.
un seul thread, un seul contexte, une seule fenêtre.

En général, OpenGL, c'est un contexte par fenêtre. Du coup, je simplifierai vraiment au plus simple. Pour moi, votre cas, c'est une résolution globale, additionnant les trois écrans. Après, si vous voulez trois images différentes par écran, oui, il faudra plusieurs viewport (qui permettent de dessiner sur telle ou telle partie, indépendamment des autres (voir tutoriel de splitscreen, c'est la même méthode)).
Donc oui, j'ouvre une fenêtre (et son contexte associé) de la taille cumulée des trois écrans et je fais mes rendus grâce aux viewports.