Discussion :

[Laustralien49]

Hello,

Je vous soumet mon problème en espérant recevoir un peu d'aide pour mon premier post .
Voila, le but de mon bout de code est relativement simple, affiché une lumière sur un sprite 2D. Mais je ne suis pas convaincu par mon rendu (cf screen) car comme vous pourrez le voir le dégradé se fait par "triangle".
Si quelqu'un a une idée je suis preneur.

Merci d'avance

Voici mon bout de code:

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
void	VGL_TesslatedSprite::Draw(){
 
	if ((flags & VGL_VISIBLE)==0){
		return;
	}
 
	Vector2 elm_size = Vector2(size.x/(float)tes_x,size.y/(float)tes_y);
	Vector2 elm_pos,variable_elm_size,sprite_center;
	Vector2 base_pos = (pos + size - Vector2(0,elm_size.y));
	SubSprite sub;
	VGL_Color CurrentColor;
 
	sprite_center = pos + Vector2(size.x*0.5f,size.y*0.5f);
 
	float tex_size_x = 1.0f / (float)tes_x;
	float tex_size_y = 1.0f / (float)tes_y;
	float cx,cy;
	int k,l;
 
	BIND(texid); 
 
	for (int i=0;i<tes_x*tes_y;i++){
 
			cx = float(i%tes_x)/(float)tes_x;							
			cy = float(i/tes_y)/(float)tes_y;	
			k = i%tes_x;
			l = (int)::floor(i/(float)tes_y);
 
			elm_pos =  base_pos - Vector2((1-cx)*size.x,(cy)*size.y);
			variable_elm_size = elm_size;
 
			sub.t1.x  = cx             ;  sub.t1.y = 1.0f - cy;
			sub.t2.x  = cx+tex_size_x  ;  sub.t2.y = 1.0f - cy;
			sub.t3.x  = cx+tex_size_x  ;  sub.t3.y = 1.0f - (cy+tex_size_y);
			sub.t4.x  = cx             ;  sub.t4.y = 1.0f - (cy+tex_size_y);
 
 
			glBegin(GL_QUADS);
 
			float d = distance2d(Vector2(elm_pos.x ,elm_pos.y+variable_elm_size.y ),pLightSource->GetPos());
			float Alpha = 1 / (Kc + Kl*d + Kq*(d*d));
			Alpha = clamp<float>(Alpha,0,1);
			CDebug::GetSingleton()->Add("1- Kc = %f, Kl*d= %f, Kq*d²= %f, Alpha= %f, distance= %f",Kc, Kl*d, Kq*(d*d), Alpha, d);
			CurrentColor.Combine(pLightSource->Ambiante,pLightSource->Light, Alpha * pLightSource->GetIntensity());
 
			glColor4f(CurrentColor.r,CurrentColor.g, CurrentColor.b, CurrentColor.alpha);
			glTexCoord2f(sub.t1.x, sub.t1.y);
			glVertex2f(elm_pos.x, elm_pos.y+variable_elm_size.y );	// Vertex Coord (Bottom Left)	
 
 
 
			d = distance2d(Vector2(elm_pos.x + variable_elm_size.x , elm_pos.y+elm_size.y),pLightSource->GetPos());
			Alpha = 1 / (Kc + Kl*d + Kq*(d*d));
			Alpha = clamp<float>(Alpha,0,1);
			CDebug::GetSingleton()->Add("2- Kc = %f, Kl*d= %f, Kq*d²= %f, Alpha= %f, distance= %f",Kc, Kl*d, Kq*(d*d), Alpha, d);
			CurrentColor.Combine(pLightSource->Ambiante,pLightSource->Light, Alpha * pLightSource->GetIntensity());
 
			glColor4f(CurrentColor.r,CurrentColor.g, CurrentColor.b, CurrentColor.alpha);
			glTexCoord2f(sub.t2.x, sub.t2.y);
			glVertex2f(elm_pos.x + variable_elm_size.x, elm_pos.y+elm_size.y );	    // Vertex Coord (Bottom Right)	
 
 
 
			d = distance2d(Vector2(elm_pos.x + variable_elm_size.x ,elm_pos.y),pLightSource->GetPos());
			Alpha = 1 / (Kc + Kl*d + Kq*(d*d));
			Alpha = clamp<float>(Alpha,0,1);
			CDebug::GetSingleton()->Add("3- Kc = %f, Kl*d= %f, Kq*d²= %f, Alpha= %f, distance= %f",Kc, Kl*d, Kq*(d*d), Alpha, d);
			CurrentColor.Combine(pLightSource->Ambiante,pLightSource->Light, Alpha * pLightSource->GetIntensity());
 
			glColor4f(CurrentColor.r,CurrentColor.g, CurrentColor.b, CurrentColor.alpha);
			glTexCoord2f(sub.t3.x, sub.t3.y);
			glVertex2f(elm_pos.x + variable_elm_size.x, elm_pos.y );		    // Vertex Coord (Top Right)	
 
 
 
			d = distance2d(Vector2(elm_pos.x ,elm_pos.y),pLightSource->GetPos());
			Alpha = 1 / (Kc + Kl*d + Kq*(d*d));
			Alpha = clamp<float>(Alpha,0,1);
			CDebug::GetSingleton()->Add("4- Kc = %f, Kl*d= %f, Kq*d²= %f, Alpha= %f, distance= %f",Kc, Kl*d, Kq*(d*d), Alpha, d);
			CurrentColor.Combine(pLightSource->Ambiante,pLightSource->Light, Alpha * pLightSource->GetIntensity());
 
			glColor4f(CurrentColor.r,CurrentColor.g, CurrentColor.b, CurrentColor.alpha);
			glTexCoord2f(sub.t4.x, sub.t4.y );
			glVertex2f(elm_pos.x, elm_pos.y );	
 
			glEnd();
 
			/*glBegin(GL_LINES);
			glColor3ub(255,255,255);
 
			glVertex2f(elm_pos.x, elm_pos.y+variable_elm_size.y );		// Vertex Coord (Bottom Left)	
			glVertex2f(elm_pos.x + variable_elm_size.x, elm_pos.y+elm_size.y );	    // Vertex Coord (Bottom Right)
 
			glVertex2f(elm_pos.x, elm_pos.y );		    // Vertex Coord (Top Right)	
			glVertex2f(elm_pos.x, elm_pos.y + elm_pos.y+elm_size.y);	
			glEnd();*/
 
			glPointSize( 5 );
			glBegin(GL_POINTS);
			glVertex2f(pLightSource->GetPos().x, pLightSource->GetPos().y );		// Vertex Coord (Bottom Left)	
			glEnd();
	}
 
}

[LittleWhite]

Bonjour et bienvenue,

Avec le pipeline fixe d'OpenGL je suis pas sur que l'on puisse faire mieux en terme d'éclairage. Celui ci se basera toujours sur les sommets et non par pixels.
Pour arriver à quelque chose de mieux, il faut utiliser un shader qui fera le calcul de la lumière par pixel.

[Laustralien49]

C'est bien ce dont je crains.

Merci pour ton avis.

[ShevchenKik]

Salut,

il y a moyen d'approcher l'éclairage par pixel avec le pipeline fixe en subdivisant ton quad:

là tu utilises 4 sommets, et tout ce qui vient entre ces 4 est interpolé.
si à la place de ton quad tu utilises une grille, plus elle sera fine moins il y aura d'interpolation.

Après faut juste calculer les coordonnées de texture appropriés pour chaque vertex dans ta grille.

autre remarque: dans ta fonction d#affichage tu effectues beaucoup de calculs, en particulier entre le glBegin et le glEnd...c'est mal )

Essaie de precalculer tout ca et de n'avoir si possible que des appels à des fonctions OpenGL lors de l'affichage, surtout dans les boucles glBegin / glEnd

[Laustralien49]

Ok, j'ai corrigé ça.
Le truc c'est que je travail déjà sur un sprite divisé en plusieurs sprites, rajouter des divisions me fait perdre en perf...

En tout cas merci pour tes conseils.

[Arkham46]

Bjr,

Comment évolue la lumière, est-elle fixe? en translation?

Je pense à une LightMap, ne serait-ce pas suffisant?

[venomelektro]

hello,

le but est de pouvoir gerer une illumination 2d , j ai deja utilisé une methode similaire en precalc et ca rendait bien

le code utilise deja une grille (cf boucle for du premier post) et de toute facon opengl interpole les datas de glColor4f entre les sommets (cf lesson3 de nehe )

il doit donc y avoir un soucis, reste a trouver ou


apres d accord avec ShevchenKik, il faut précalculer ta grid et faire un rendu avec des datas precalculés
pour une grille le rendu le plus rapide sera entre triangle strip avec un tableau indéxé