[DirectX - C# - HLSL] Les problèmes d'Ingham

Salut à tous, encore moi (décidement...)

J'ai un soucis aussi simple qu'incompréhensible, en ce moment au bout d'un certain temps que mon jeu tourne (généralement 30 secondes), il plante (même si je le lance et que je m'en vais pisser, quand je reviens il a planté :aie: )...
Mais plantage bizarre attention, il plante avec une Erreur de l'application sur des Effect.SetValue (n'importe lesquels, c'est jamais le même... Des fois c'est même juste un SetValue("FogFar", 100.0f)... Autant dire rien de compliqué quoi 8O

Une idée ? (Pas encore eu le temps de tester sur un autre PC, je vais le faire en rentrant des courses ^^)

Trucs habituels :
http://jeux.developpez.com/faq/direc...LEMES_probleme

Juste pour être sûr : 30 secondes c'est pas le moment où ton écran de veille s'active ? :aie:

1) J'ai tout essayé de voir, rien à faire :(
En fait ca plante aux alentours de 45 secondes voir 1 minute...
Et non ce n'est pas l'écran de veille ;) (Ca le fait meme quand je "joue" avec)

2) J'attends quelqu'un pour tester avec lui (Oui au fait, c'est sûrement un truc débile mais pourquoi sur le deuxième PC, l'application ne se lance pas ? Rien ne se passe quand je lance l'EXE ? Pourtant le PC a DX et .NET2.0, aucune erreur ne s'affiche :mrgreen: Jamais été doué pour distribuer mes applis DX)

3) 3ème question qui n'a rien à voir :mrgreen: Il existe un moyen simple de faire un dégradé sur plusieurs couleurs en HLSL ? un dégradé entre 2 couleurs OK (avec un lerp()) mais en l'occurance là j'ai un tableau de 7 couleurs (avec en plus une valeur entre 0 et 1 a chacune pour "placer" la couleur :aie:)


Merci à toi pour tes réponses ;)

3) resultat = c0 * f0 + c1 * f1 + ... + c6 * f6

Avec c_ les couleurs et f_ les poids associés. Il faut bien sûr que la somme des f soit égale à 1 pour que ce soit cohérent.

Ah ben ui suis-je bête :D
Merci (pas bien frais en ce moment moi)

Edit: Ah mais zut j'avais mal lu...
En fait je me suis mal exprimé, ce que je voulais dire c'est que j'ai une liste avec des positions genre

1 : rouge, 0.0
2 : bleu, 0.2
3 : vert, 0.6
4 : orange, 0.7
5 : violet; 1

0 > 1 est une valeur que je peux connaitre dans mon pixel shader (c'est la valeur Y de la normale de mes faces ^^)
Donc comment obtenir les Facteurs a partir de la :p

Je renomme ce topic il me servira de stockage de questions a la con :p

--
PS: Le problème des plantages aléatoire est reglé, il venait en fait d'un float incrémenté à chaque frame par l'elapsedTime, qui devait arriver beaucoup trop haut au bout d'une petite minute d'exécution, ce qui faisait tout foirer :mouarf:

Ah... Tu ne veux pas mixer plusieurs couleurs, mais faire un dégradé avec, c'est ça ?
Bon oublie ce que j'ai dit alors, tu n'auras toujours que deux couleurs à interpoler (celles qui encadrent l'intervalle dans laquelle ta valeur se trouve).

Le mieux serait encore de créer une texture 1D avec tes couleurs et d'aller faire un simple lookup dedans avec ta valeur comme coordonnée de texture, non ?

Edit: En fait non je peux pas vraiment faire ça, les couleurs que je donne au shaders sont calculées a la volée (mise à jour toutes les 5 secondes), je me vois mal recréer une texture toutes les 5 secondes :mrgreen:
Non je vais essayer avec des if pour identifier les 2 couleurs à interpoler, et des lerp apres :roll:
Je posterai pour donner le résultalt si c'est convaincant 8-)
Je sais pas pourquoi j'aime pas utiliser les IF en HLSL, une partie de moi est persuadée que ca plombe les perfs, c'est inconscient:oops:

Bon bah j'ai résolu en fait, en faisant une texture (bien vu ;)), en Y j'ai mes dégradés et en X l'heure de la journée (oui c'est pour colorer un dôme :))
Ca marche parfaitement et j'ai bien plus de contrôle qu'en voulant calculer à la main :aie: (Enfin pour l'instant... ;))

Sinon y'a pas des "astuces" d'habitués pour distribuer correctement mes applications DirectX ? J'ai souvent eu des problèmes pour ça, ça marche sur mon PC (avec le SDK) mais chez ceux qui l'ont pas ça merdouille :mrgreen:

En tout cas merci à toi de prendre sur ton temps pour répondre à mes interrogations de débutant ;)

Si tu codes en C++ il n'y a que deux précautions à prendre :

- Vérifier que l'utilisateur a la bonne version de DirectX installée
- Livrer (la bonne version de) la DLL de D3DX si tu l'utilises

Si tu codes en .Net, j'imagine qu'il suffit d'avoir la bonne version du framework .Net installée.

Si ça ne marche toujours pas tu peux toujours nous préciser quelles sont les erreurs rencontrées ;)

Merci c'est bon ;) J'ai juste joint les DLL DirectX Managed et installé le dernier Runtime (Feb 2007) c'est bon ça marche :)

Bon, pour continuer dans la série des questions à la con :mrgreen:...
J'aimerais créer une texture de "nuages" dynamiquement, donc en créant un Noise par shader, j'ai vu qu'il y a une fonction "noise" mais msdn et google me disent qu'il est utilisable qu'avec les "texture shader"......
Kezako ?:oops:

La dernière fois que j'ai voulu utiliser un noise() c'était avec GLSL et le truc n'était implémenté nulle part. A mon avis tu devrais éviter de l'utiliser, génère ton noise toi-même avec le CPU.

Salut c'est re-moi :)
Générer le noise sur le CPU certes...

En fait je veux faire des nuages simplement, un texture en niveau de gris qui sera rendue par shaders ensuite, donc j'ai essayé de jeter un oeil du côté de GDI (en ne rendant une nouvelle "frame nuage" que toutes les 5 secondes par exemple poru pas baisser les perfs), mais impossible de "scaler" une image en la smoothant, en résumé.... Même avec le CPU j'arrive pas à faire un début de nuage :mrgreen:

Même comme ça je garde des gros pixels bien nets:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

Matrix mtx = new Matrix(); mtx.Scale(25, 25); g.Transform = mtx; g.InterpolationMode = InterpolationMode.Bicubic;   for(y = 0; y < h; y++) { for(x = 0; x < w; x++) { n = rand.Next(256); b = new SolidBrush(Color.FromArgb(n, n, n)); g.FillRectangle(b,x,y,1,1); } }

---

En même temps je part peut-être sur la mauvaise voie avec mon GDI+ là :mrgreen:...
J'ai cherché partout sur le net, ils expliquent bien comment faire des nuages (combiner plusieurs noise de taille différentes, le principe est simple, mais en pratique j'ai trouvé aucun code me mettant sur la voix pour agrandir et smoother une image bruitée :()

Enfin bref, je galere encore et toujours quoi ^^

Je te conseille fortement d'utiliser une texture volume précalculée (ou calculer pendant le demarrage ou le load de ta scène) pour ce genre d'effet. La technique devient alors beaucoup plus simple à mettre en place.
Donc tu créés ta texture volume (un format L8 est suffisant puisque seul une channel est requise). Ensuite, dans un shader tu fais varier les coordonnées xyz du sampler de ta texture volume en fonction d'un "Time" que tu passeras en paramètres.
En l'occurence faire varier le xy de tes coordonnées de texture en fonction de la vitesse d'animation de tes nuages et le z (profondeur de la texture volume) par rapport à la vitesse de transition entre les différentes couches de ta texture.
En tout cas cette technique donne des résultats assez convainquant et trés simplement.

Tu peux avoir un apercu de ce que ca donne sur cette vidéo.

EDIT : Ceci dit utiliser la GDI+ dans ton runtime ne me semble pas du tout approprié :aie:

C'est pas bête en théorie ça :D
En pratique je ne sais rien des textures-volume (a part qu'on les rend, en HLSL, avec tex3D ^^), donc encore moins comment les créer (et accesoirement les faire boucler, c'est mieux ^^) :cry:
(La lente entrée dans le monde du temps réel est douloureuse pour moi, ça se voit ? :mouarf: )

Une texture volume pour faire simple c'est plusieurs textures les unes sur les autres. Tu différencies et donc tu accédes aux différentes "couches" de textures composant ta texture volume grâce à la composante z de tes coordonnées de texture. Pour en créer une tu peux utiliser l'outil de texture du sdk de directx... mais aprés tout dépand des logiciels à ta disposition.
Ce genre de textures est trés utile pour rendre les effets volumétriques (brouillard, lumières...) mais aussi les animations (nuages, explosions...). Enfin bref un mode stockage assez pratique 8-)
Voilà si tu as besoin de précision supplémentaires... demande :mrgreen:

Ok ;)
Je viens de regarder l'outil en question effectivement :)
Niveau interpolation, entre chaque "couche" il fait du linéaire ? (S'il y a une interp ;))

Et comment on créé une Volume Texture par code ?

Merci pour les infos :)

Citation:

---

Envoyé par Ingham

Niveau interpolation, entre chaque "couche" il fait du linéaire ? (S'il y a une interp ;))

---

Je comprends pas trop la question :? L'interpolation se fait lors du plaquage de la texture et non au sein de la texture elle même. Une texture c'est des données ni plus ni moins. Aprés c'est toi qui décide l'interpolation.

Citation:

---

Envoyé par Ingham

Et comment on créé une Volume Texture par code ?

---

Regarde la classe VolumeTexture. Normalement tu devrait pouvoir t'en sortir avec l'intellisense sinon la doc du sdk t'expliqueras comment la créer ou l'utiliser.

Merci ;)

J'ai pu regarder mais je n'ai rien vu pour créer un VolumeTexture direct depuis plusieures Texture (par exemple, ou plusieurs Bitmap)
Bref, moi y'en a pas tout pigé pour les VolumeTexture ( en plus google n'offre que peu d'informations sur cette facette de DirectX qui me semble assez peu exploitée et/ou connue malgré les super utilisations qu'on pourrait en faire :mrgreen: )



Bon sinon j'ai une autre question, enfin plus une interrogation générale sur ce coup, c'est au sujet des ombres...

Mon jeu est éclairé par un soleil global, en directionnel, qui éclaire tout et de loin j'aimerais lui mettre des ombres mais je ne sais pas trop vers quelle méthode me tourner...
J'ai essayé les ShadowMap... Problème: Il faut des maps gigantesques pour avoir un résultat correct (et oui vu la zone énorme que la lumière éclaire, et que le champs de vision est souvent assez conséquent...), même 4096 c'est juste (!!!)
Pour avoir un résultat correct je dois limiter la "zone ombrée" a environ une 10aine de metre autour de mon perso, ce qui est vraiment pas suffisant dans mon cas (voir les ombres apparaitre devant le perso et disparaitre derriere ca casse un peu tout)

J'ai pensé aux Shadow Volume mais, c'est faisable en pur HLSL ? Et au final la scène aura sûrement pas mal de polygones, ca risque de plomber un peu les perfs :aie:

Donc j'ai essayé de réfléchir aux Perspective Shadow Map, mais Google ne m'a pas donné d'informations suffisantes à mon petit cerveau pour mettre ça en pratique :mrgreen:

J'avais pensé faire comme ca mais évidement, après réfléxion ca semble logique que le résultat n'a pas celui espéré: Il me sort la "bonne" distance pour tous les points, aucun n'est "occluded" donc impossible de calculer ou sera l'ombre (Dur a expliquer ca bordel :mrgreen:)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

VSOutput ShadowMapVS(float4 inPos : POSITION) { VSOutput result = (VSOutput)0;   result.Position = mul(inPos, CamWVP); result.PositionLightView = mul(inPos, LightWVP); result.PositionCamView = mul(inPos, CamWVP); result.Position3D = inPos;   return result; } float4 ShadowMapPS(VSOutput IN) : COLOR0 { float4 result = (IN.PositionLightView.z - NearPlane) / (FarPlane-NearPlane);   return result; }

---

Donc me voilà tout chose: je suis bloqué de tous les côtés :yaisse2:

Citation:

---

J'ai essayé les ShadowMap... Problème: Il faut des maps gigantesques pour avoir un résultat correct

---

Il existe des techniques (ou plutôt des hacks) pour réduire la taille nécessaire tout en gardant une précision suffisant. Je me rappelle jamais les significations, mais il y a des trucs du genre PPSM, TSM, ...
Mais bon ça requiert vraiment beaucoup d'effort et pour moi ce sont plus des bidouilles que réellement des méthodes robustes. Par exemple tu auras toujours un problème lorsque la caméra fera face à la source lumineuse, quelque soit la technique.

Si tu veux un peu de lecture, on dirait que ce topic à l'air intéressant :
http://www.gamedev.net/community/for...opic_id=405955

Citation:

---

J'ai pensé aux Shadow Volume mais, c'est faisable en pur HLSL ? Et au final la scène aura sûrement pas mal de polygones, ca risque de plomber un peu les perfs

---

Tu peux utiliser les shaders pour faire l'extrusion, ce qui est déjà pas mal. Après tu as tout un tas de techniques pour optimiser (je suis en train d'écrire un tuto sur le sujet, peut-être vais-je le finir un jour ? ...).
Ca va certes vite se voir sur les perfs avec beaucoup de géometrie (et de pixels), mais ce qui me plaît c'est que l'algo de base est robuste et que tout ce qu'on ajoute ensuite n'est qu'optimisation, on n'a pas à bidouiller pour avoir quelque chose de correct.

Merci Laurent pour le temps que tu prends à répondre à mes questions parfois, il faut l'avouer, assez débiles ;)

Pour les ombres j'ai finalement opté pour la technique de Shadow Map qui me semble un peu plus légère surtout quand il y a besoin de recalculer à chaque frame ou presque les ombres...

Donc pour les SM je calcule les ombres à un rayon défini autour du personnages (pour la matrice View de la light je défini donc le lookAt sur le perso)
Ca marche, c'est bien c'est beau (c'est Bosh).... de loin :D
De près c'est cradingue, malgré l'utilisation d'une map en 2048*2048 (ah oui quand même :aie: )
Je sais pas comment faire poru améliorer ça... Pour rendre le tout plus "doux" à l'oeil j'aimerais flouter le résultat mais je ne sais pas comment m'y prendre...
J'ai vu des exemples de Soft Shadow Map avec une Difference Map... Mais trop compliqué pour ce que je veux faire je trouve, je cherche juste à flouter le bazarre pour que ca nique moins les yeux c'est tout :mrgreen:

En images ca donne ca, de loin:
http://img472.imageshack.us/img472/5...ourri01gn2.jpg
Et de près:
http://img472.imageshack.us/img472/3...ourri02jv4.jpg
Si ca peut aider, on voit une version réduite de la shadowMap en haut a gauche

Des idées ?
Merci d'avance ;)