Mais comme le projet que je dois faire pour les cours peut être intéressant, je ferais peut-être quelques annonces sur ce blog, donc Stay tuned !

Sous ces noms étranges se cachent des librairies permettant à du code C# de communiquer avec DirectX (et donc la carte graphique). La précédente (MDX) était la librairie officielle développée par Microsoft, mais ce dernier ayant choisi d’en arrêter le développement j’ai préféré passer sur une librairie maintenue à jour : SlimDX.

Concrètement pour l’utilisateur final, cela permet d’utiliser les applications utilisant le Tromoz Engine sur n’importe quel PC en installant simplement le runtime de SlimDX (7.9Mo).

Donc pour essayer cette démo, installez le runtime de SlimDX ICI et vous pourrez ensuite lancer la démo ICI. N’hésitez pas à essayer et à poster un petit commentaire pour me dire comment ça s’est passé (problème pour le lancer, fps, etc…).

[Edit] Petite précision, il faut avoir le Framework .net 3.5 installé pour faire marcher tout ça, et ça se trouve ICI.

Avant :

Après :

Techniquement j’ai utilisé une publication de nVidia pour arriver à ce résultat : les Variances shadow maps (lien). Pour faire simple, cette variation des Shadow maps consiste à ne plus considérer la distance entre la lumière et un objet (habituellement utilisée pour savoir si un objet est éclairé) comme une donnée connue mais comme une variable aléatoire discrète, et d’ensuite étudier la probabilité que l’objet soit éclairé. Cette difference de conception permet d’appliquer des traitements à la shadow map comme par exemple un flou.

Pour vous récompenser d’avoir lu la partie technique, une petite image de ce que ca peut donner :

Voila ce que ça donne en image, avec un modèle un peu plus festif que le vaisseau habituel :

J’ai du au passage modifier le rendu pour supporter les modèles 3D qui ont des matériaux à la place des textures.

L’étape suivante concerne les ombres, car je voudrais implémenter des Soft Shadows, c’est à dire des ombres dont les bords sont plus réalistes, grâce aux Variance shadow maps.

Malheureusement je vais devoir prendre un peu de recul sur le projet car je dois avancer d’avantage sur un projet scolaire, mais je tiendrais à jour le blog pour donner des informations sur l’avancement.

Il s’agit d’un mode de rendu qui permet d’afficher facilement des particules, simplement en envoyant à la carte graphique des coordonnées pour chaque particule, et une texture à afficher. Direct3D s’occupe alors de créer des quads texturés (une sorte de panneau carré) et de les orienter pour qu’ils soient toujours face à la caméra. Dans la théorie c’est super, mais dans la pratique c’est très limité quand on l’utilise avec des techniques de rendu un peu avancées comme le Deferred rendering, car il est impossible de passer des informations depuis le vertex shader vers le pixel shader. Il m’était donc impossible de gérer la profondeur, et les particules étaient visibles à travers les objets solides.

Avec les point sprites, les particules pourtant situées sous les vaisseaux sont visibles à travers :

J’ai donc du abandonner cette technique et utiliser le Billboarding, qui consiste à générer les quads à la main et les orienter (à la main aussi, mais dans le vertex shader). Le problème est que je passe beaucoup plus d’informations à la carte graphique, ce qui est moins performant, mais au moins ça fonctionne.

Le rendu avec le Billboarding, les particules sont correctement masquées par les vaisseaux :

La partie graphique étant au point, il ne reste plus qu’à gérer la dynamique des particules, mais ça devrait être beaucoup plus rapide.

Le problème était que certaines zones étaient illuminées alors qu’elles étaient hors champs, le souci venait d’une mauvaise lecture du ShadowMap par le texture sampler, qui était en mode AddressU = clamp. Ce mode utilise la couleur du bord de la texture pour les coordonnées qui sont au delà des limites de la texture, causant mes problèmes d’éclairage. J’ai pu découvrir en fouillant sur le net un mode de sampling très pratique pour ces utilisations : AddressU = border (à utiliser conjointement avec BorderColor = 0x000000;) qui utilise une couleur donnée pour les coordonnées à l’extérieur de la texture.

La projection des spots est maintenant correcte, prochaine étape : les particules.

Vous pourrez trouver les sources ici : svn://svn.alprema.com/tromoz/trunk, pas besoin d’identifiants pour les accès en lecture.

Je rappelle juste qu’il faut le SDK SlimDX pour compiler, have fun !

J’en profite pour mettre un disposition une petite démo, dans le but de voir combien elle obtient de FPS sur différentes machines et si elle passe correctement.

Il s’agit juste d’une démo technique, je suis au courant de quelques bugs (comme le redimensionnement qui plante) mais n’hésitez pas à me transmettre ceux que vous constatez via un petit commentaire (appuyez sur “Echap” pour quitter la démo).

[Edit le 14/11/2008 à 10:06] Il semble que le SDK de DirectX soit nécessaire pour faire tourner la démo, je remédierais au problème ce week-end.

[Edit le 15/11/2008 à 04:19] Le problème venait des dépendances vers Managed DirectX, j’ai pu trouver un package complet qui résout le problème ici ! Il suffit de le télécharger, de l’installer, et la démo devrait fonctionner, merci de me faire parvenir vos feedbacks.

Autre petite joyeuseté, suite à un gros problème de performances j’ai fouillé un peu et activé le HardwareVertexProcessing ce qui m’a permis de passer de 40fps à 240 sur mon PC de développement (GeForce 8800GTX) par contre aucune amélioration du coté de mon portable (GeForce Go 6600), qui reste bloqué à 8fps . Je pense que le problème vient des appels fréquents au DrawIndexedPrimitives, à confirmer !

[Edit le 31 octobre à 00:51] Le problème venait bien du HardwareVertexProcessing, il s’agissait d’une erreur due à la fatigue hier soir :/ J’atteins maintenant les 22 fps sur le portable, ce qui n’est pas mauvais pour 140K polygones avec deux lumières.

Il suffisait en fait de garder une référence vers le BackBuffer tout au long de l’exécution et de l’utiliser pour rétablir la bonne RenderTarget avant l’affichage sur écran.