Gestion des lumières en 2D

**bourriquet_42** · 08/01/2009, 15h59

Bonjour,
J'ai un projet de jeu vidéo 2D basé sur les jeux de lumières et les couleurs. Du genre avec des lumières de couleurs qui rebondissent sur des miroirs, se mélangent...
Donc je voudrais être sûr de ne pas foncer dans le mur avant de démarrer.
Je comptais faire séparément la gestion des sources de lumières et du jeu en lui-même (collisions... les trucs classiques). Genre calculer l'image du fond à partir des sources de lumières et obstacles. La définir comme background puis mettre le reste dessus.
Pour l'instant j'ai réfléchi qu'à la gestion des lumières et je galère un peu. Est-ce qu'il y a des tutoriaux là-dessus ou même des espèces de moteurs de lumières déjà fait (même si je préférerais le faire).
Parce que là je comptais faire vraiment tout manuellement, séparer les lumières qui touchent à moitié un obstacle, fabriquer les nouvelles, réitérer... Même pour le rendu final, je vois pas d'autre solution que de prendre chaque pixel de l'écran et de calculer quelles lumières le touchent...
Voilà, si vous avez des indications qui peuvent aider.
Merci beaucoup

**TanEk** · 08/01/2009, 23h54

Je n'ai pas réfléchi en profondeur à ton problème mais déjà si tu veux faire des effets de lumière complexes il va falloir que tu t'orientes rapidement vers les shaders pour accélérer le rendu donc vers une API de shaders Cg, GLSL pour OpenGL, HLSL pour DirectX, etc. Je ne connais pas de bibliothèque toute prête pour faire des effets complexes en 2D désolé.

**bourriquet_42** · 10/01/2009, 17h38

Merci, bonne idée je vais commencer par me renseigner là-dessus. Mais est-ce que c'est possible d'utiliser un shader mais de récupérer la valeur des couleurs de chaque pixel après parce qu'elles me serviraient pour le fonctionnement du jeu aussi?

**TanEk** · 10/01/2009, 18h58

Après je suis pas un expert dans les shaders mais oui ce que tu demandes est possibles.

**bourriquet_42** · 14/01/2009, 21h17

Wouhou!!
Bon je laisse le sujet ouvert parce que je sens que je vais bientôt revenir...

**Mat.M** · 15/01/2009, 21h02

Utiliser les shaders je pense que c'est sortir un peu la grosse artillerie pour peut-être pas grand chose et puis pas dit que cela fonctionne sur toutes les cartes.
Faut-il le répêter la 3d temps réel ne fonctionne pas toujours sur toutes les machines notamment sur certains portables ou des machines anciennes.
Sinon tu ne dis pas quelle technologie de rendu ( Open GL, Direct X) tu utilises pour faire ce jeu.
Peut-être que de simples filtrages sur des zones de l'écran suffisent; peut-être qu'en prenant la composante RGB de quelques pixels cela suffit pour faire des effets..

**bourriquet_42** · 19/01/2009, 23h55

Ben justement, je partais sur l'idée de faire ça en openGL. Je ne sais pas si c'est vraiment une bonne idée puisque ce serait la 2D complète et je ne trouve pas grand chose sur openGL pour la 2D... Et encore moins sur GLSL pour la 2D.

Mon but est juste d'avoir un certain nombre de sources de lumière d'une certaine couleur, direction, angle... Un certain nombre d'obstacles, réfléchissants, filtrants... enfin avec un certain effet sur les lumières qui les touchent. Et à partir de ces données, avoir un résultat représentant les couleurs à chaque endroit de l'écran de jeu...

Est-ce que les shaders sont une bonne piste et dans ce cas est-ce que quelqu'un a des tutoriaux pour ce genre d'utilisation?

**bourriquet_42** · 22/01/2009, 19h10

Please?

**Frifron** · 22/01/2009, 20h03

openGL te permet de faire de la 2D sans problème. Tu te met en projection parrallèle et tu utilise des vertex à 2 dimensions.

Sinon pour tes lumières tu peux construire ca coté CPU avec de la géométrie. Tu n'as pas necessairement besoin de shaders.

**bourriquet_42** · 27/01/2009, 17h06

Ok et si je fais ca avec le cpu, je calcule chaque point un par un?
Parce que ca me parait beaucoup un million de points à tester si ils sont dans le champ d une dixaine de rayons...

**Frifron** · 27/01/2009, 20h23

Pour tes lumières un simple quad avec blending et alpha te permet de représenter un rayon. Pas besoin de dessiner au pixel ! L'avantage d'un rayon c'est que c'est droit, 4 points et tu as un rayon.

Après tu testes les collisions avec ces rayons avec des algos appropriés et optimisés. Tu peux partitionner l'espace également. Pourquoi parles tu de millions de points a tester par rayons ?

Pour ta géométrie de lumière tu peux la recalculer uniquement lorsque necessaire (un obstacle/un mirroir dans le champs d'un rayon bouge...)

**bourriquet_42** · 29/01/2009, 03h52

Qu'est-ce que tu entends par "blending et alpha"? Avec le paramètre alpha en fait?

Le quadrilatère est une très bonne idée! Mais un rayon n'est pas toujours droit. Les obstacles devraient pouvoir être des arcs de cercles (loupes...). Il faudrait donc des formes composées de segment et d'arcs de cercles. C'est possible à faire? Ou effacer une partie d'une forme avec une autre ça peut se faire? Ce serait l'idéal! Sinon au pire, je pourrai faire des pseudo arcs de cercles avec plein de lignes mais bon...

De plus, il faudrait que les rayons s'atténuent en s'éloignant de la source. Donc pour ça je peux donner des valeurs différentes de alpha aux sommets des polygones. Mais quand un rayon est coupé à moitié par un obstacle, je le sépare en deux rayons (partie bloquée, partie qui continue), donc est-ce que la transparence va rester continu à la frontière entre les deux nouveaux rayons? En gros est-ce que les dégradés entre les sommets d'un polynôme sont linéaires?

Je ne vois pas du tout ce que tu entends par "partitionner l'espace".
Les millions de points c'est exagéré mais 500*500 ça fait déjà 250 000 pixels...
Recalculer que quand c'est nécessaire c'est une bonne idée mais ça ne devrait pas changer grand-chose comme les sources et obstacles bougeraient un peu tout le temps (principe du jeu).

**bafman** · 02/02/2009, 10h47

en fait, ce que tu veut, c'est faire de l'illumination global mais en 2D. Et le problème, c'est que c'est tout aussi difficile en 2D qu'en 3D

**bourriquet_42** · 09/02/2009, 04h54

J'ai voulu tester les couleurs que ça fait avec le blending alpha. J'ai donc pris le code de la leçon 3 de nehe (version linux) et dessiné trois triangles l'un derrière l'autre en décalé, de couleurs différentes, à moitié transparents.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
  glTranslatef(-0.0f,0.0f,-6.0f);
  glEnable(GL_BLEND);	  
  glBlendFunc(GL_SRC_ALPHA, GL_ONE);
 
  // premier triangle
  glBegin(GL_POLYGON);
  glColor4f(1.0f,0.0f,0.0f,0.5f);
  glVertex3f( 0.0f, 1.0f, 0.0f);		// Top
  glVertex3f( 1.0f,-1.0f, 0.0f);		// Bottom Right
  glVertex3f(-1.0f,-1.0f, 0.0f);		// Bottom Left	
  glEnd();
 
  glTranslatef(-1.0f,0.0f,-1.0f);
  //deuxième triangle
  glBegin(GL_POLYGON);
  glColor4f(0.0f,1.0f,0.0f,0.5f);
  glVertex3f( 0.0f, 1.0f, 0.0f);		// Top
  glVertex3f( 1.0f,-1.0f, 0.0f);		// Bottom Right
  glVertex3f(-1.0f,-1.0f, 0.0f);		// Bottom Left	
  glEnd();
 
  glTranslatef(-1.0f,0.0f,-1.0f);
  //troisième triangle
  glBegin(GL_POLYGON);
  glColor4f(0.0f,0.0f,1.0f,0.5f);
  glVertex3f( 0.0f, 1.0f, 0.0f);		// Top
  glVertex3f( 1.0f,-1.0f, 0.0f);		// Bottom Right
  glVertex3f(-1.0f,-1.0f, 0.0f);		// Bottom Left	
  glEnd();

Le problème c'est que la valeur de alpha rend juste les couleurs plus foncés, mais les triangles qui sont derrière n'influence rien du tout.
Voilà le résultat.
Y a quelque chose que j'ai pas compris?

**bafman** · 09/02/2009, 14h05

tu affiche tes triangle dans le mauvais ordre (il faut les afficher du plus eloigné vers le plus proche) et désactiver le z test

**bourriquet_42** · 11/02/2009, 20h02

Hmm en effet dsl c'était idiot.
Par contre, ca veut dire que pour la 2D, faut se rapprocher pour chaque objet affiché si je veux utiliser la transparence??

**bafman** · 12/02/2009, 13h01

non, l'ordre d'affichage suffit si tu désactive le depth test.

**bourriquet_42** · 12/02/2009, 19h39

OK parfait, une autre petite question, est-ce que c'est possible de personnaliser les dégradés dans un polygône? Parce que ce qu'il me faudrait, c'est que l'intensité soit fonction de la distance au centre du rayon, donc quand je fais un triangle, ca marche pas...
Sinon je devrais remplacer la face opposée au centre par plein de petites faces alignées et calculer l'intensité à chaque extrémité... Galère.

**bafman** · 12/02/2009, 20h02

dans ce cas la, tu a intérêt à afficher un quad avec une texture de cercle, c'est ce qu'il y a de plus simple et de plus efficace

**Frifron** · 12/02/2009, 20h03

salut, pour faire ce que tu veux, tu peux utiliser une texture en niveau de gris que tu utilises pour moduler la composante alpha.

Sinon si ton jeu est en 2D, tu peux désactiver le zbuffer, et donc le z test et l'écriture dans le z buffer, tes objets seront alors rendus dans l'ordre de rendu. Tu peux alors utiliser la version 2D dans coordonnées de vertex openGL, le z est alors implicitement à 0.

Gestion des lumières en 2D

Physique

Discussions similaires

Partager

Partager