Discussion :

[Clad3]

Bonjour à tous.

Pour résumé, j'ai récupérer le code d'un collège de classe pour ntore projet, il était chargé d'implémenter le ShadowMapping. Il m'a fait un beua copier/coller d'un site web et là je suis en train de voir comment me débrouiller avec la chose. J'ai compris le principe, a peu près suivit les diverse phases mais j'ai encore quelques imcompréhensions.

1. J'utilise des outlinedFOnt chargé avec wglUseFontOutlines() ; en mode fil de fer pas de problème ; par contre en mode polygone, ca fait foirer le rendu de ma scène ( je supose un manque de normals) Y a til moyen de remédier à ce problème? Dois-je me passer des OutlinedFont crée de cette façons ?

2. J'ai constaté que le code que mon ami m'a passé change beaucoup d'états d'opengl sans forcément les remettres comme ils étaient avant... je suis en train d'y remédier et je cherche à organiser mes phases de rendus au mieux.
Est-ce une bonne idée de faire 2 fonctions de Draw() pour chaqun de mes objets .... 1 pour les rendus de calculs d'ombre et une pour les rendus sans ombres ?
Y-a-til des choses dont je peux me passer (si je procède ainsi) lors des phases de rendus d'ombres (textures par exemple ?)

Je suis preneur de tout conseils pour organiser mes programmes autour de ce calculs d'ombres ;o) (qui par ailleurs ; marche à peu près correctement )

Merci d'avance .

[LeGreg]

1. J'utilise des outlinedFOnt chargé avec wglUseFontOutlines() ; en mode fil de fer pas de problème ; par contre en mode polygone, ca fait foirer le rendu de ma scène ( je supose un manque de normals) Y a til moyen de remédier à ce problème? Dois-je me passer des OutlinedFont crée de cette façons ?

Help us help you.

Ce que tu racontes n'a pas le moindre détail qui permettrait d'avoir la moindre idée de ce qu'est ton problème. On imagine que ça implique des outlined fonts, mais c'est tout. C'est quoi "foirer le rendu de ma scène" ?

2. J'ai constaté que le code que mon ami m'a passé change beaucoup d'états d'opengl sans forcément les remettres comme ils étaient avant... je suis en train d'y remédier et je cherche à organiser mes phases de rendus au mieux.

un code de rendu n'a pas obligation à "remettre les états comme ils étaient", et c'est le plus souvent contre productif.

En fait la seule obligation c'est de mettre les états qui sont nécessaires pour le prochain draw call.
Bien entendu il faut un "système" pour éviter
1- d'oublier de mettre la machine à état OpenGL dans une configuration particulière (par exemple oublier que l'on a activé le blending avant de rendre des objets qui sont sensé être opaques et qui donc n'ont pas besoin de blending).
2- de changer les états trop souvent et de manière redondantes (par exemple activer le blending, puis le désactiver avant d'avoir tracé quoi que ce soit) ce qui aura au final un impact sur les performances.

Bien entendu c'est 1 qui est à mettre en place en priorité et 2 qui est nécessaire pour avoir un jeu jouable dans les meilleures conditions.

Exemple de système possible : un système où chaque état fait partie d'un "matériel"/"transform"/"paramètres par objet"/"contexte de rendu". Si un matériel partage une partie de la configuration avec l'objet tracé précédemment il n'y a alors pas besoin de remettre à jour les états correspondant.
Par exemple, toujours sur le blending. Si on trace tous les objets opaques en premier il n'est pas nécessaire de désactiver le blending entre chaque nouvel objet tracé. Il suffit de le désactiver une seule fois au début du tracé des objets opaques puis le remettre lorsque tu auras à tracer un lot d'objets transparents.

Est-ce une bonne idée de faire 2 fonctions de Draw() pour chaqun de mes objets .... 1 pour les rendus de calculs d'ombre et une pour les rendus sans ombres ?
Y-a-til des choses dont je peux me passer (si je procède ainsi) lors des phases de rendus d'ombres (textures par exemple ?)

Si tu utilises les shadow depth maps, ce n'est pas seulement une bonne idée, c'est la seule solution.
Tu fais une première passe pour remplir la depth map, et une deuxième passe où tu utilises la depth map comme texture pour faire l'éclairage et l'ombrage de la scène "normale". Pour la phase d'ombre, tu n'as besoin que des infos de profondeur. La couleur n'a aucune importance donc oui la texture peut être ignoré.. dans la mesure où elle n'affecte pas la visibilité de l'objet (exemple si tu as des feuilles avec un masque de visibilité alpha qui utilise une texture). Si il y a des objets dont la visibilité partielle est déterminée par une texture alors tu dois utiliser cette texture lors du rendu pour avoir une depth map précise. De même si tu fais du displacement mapping ou tout autre méthode qui modifie la géométrie/profondeur/visibilité.

LeGreg

[Clad3]

Merci des réponses :

1. J'utilise des outlinedFOnt chargé avec wglUseFontOutlines() ; en mode fil de fer pas de problème ; par contre en mode polygone, ca fait foirer le rendu de ma scène ( je supose un manque de normals) Y a til moyen de remédier à ce problème? Dois-je me passer des OutlinedFont crée de cette façons ?

En fait, l'éclairage de ma scène n'est plus bon, je ne saurais pas dire pourquoi ni comment ca l'impact exactement . A première vue, il y a beaucoup trop d'ombres au final sur ma sène ; mais selon les modification que je fais dans mon code, je peux simplement avoir un résultat avec de multiple artefact de couleur blanches parmis les ombres). A priori, je dirai que ca vient d'un manque de "Normales" mais je n'en suis pas certain . Le problème est uniquement l'appel à ma calllist de rendu des fonts. J'ai utilisé le mode WGL_FONT_POLYGONS en tant que format pour mes données ; ce qui d'après le web , semble la bonne solution pour obtenir des normales.


Concernant mon problème d'état openGL, en réfléchissant hier soir, j'en suis arrivé à l'idée suivante : finalement ne pas faire plusieur fonction de rendu mais une seule, et laisser la gestion des état openGL non pas à mes objets ( sauf cas particulier) mais à mes moteurs (gestionnaire) de rendu, que j'apellerai entre chaque phase de rendu. Ca se tient ? En opossition à : Chaque objet met à X les état dont il a beosin en début de sa fonction de Rendu et les remet à "normal" en fin de son rendu.
( J'élimine pour l'instant l'optimisation que tu mentionne, de regrouper les objets à rendre par état de rendu par grand manque de temps, mais je garde l'idée sous le coude )

Si tu utilises les shadow depth maps, ce n'est pas seulement une bonne idée, c'est la seule solution.

En fait, je me suis mal exprimé (ou j'ai du mal comprendre ta réponse).
Ce que je disait c'est que , de toutes façons j'apelle 3 fois une fonction Render() mais que j'avais envisagé de faire des fonction spécifique de rendu par objet en fonction du type de rendu souhaité. Mais le problème de cela, c'est que ca ne me permet plus du tout de faire ce que j'énonce plus haut dans ce même post : c-a-d de gérer mes états avec mes moteurs de rendus et non l'inverse.

[TanEk]

Pourrais-t-on avoir une image de ton rendu pour voir les artefacts ? A mon avis le problème vient du z-fighting et il faut peut-être rajouter de l'offset (glPolygonOffset).

[Clad3]

Je suis en trin de régler un autre problème sur mes fonts, dés que c'est fait, je repasse au shadowmapping et je fais un screen du problème ! Stay tuned

[Clad3]

Voila ce que cela donne , sans outlined font à l'écran et avec (en pièce attachées). Les résultat sont les même sans l'affichage du quad texturé, donc n'en tenez pas compte .