Discussion :

[Vin789]

Bonjour,

Je cherche à implémenter un jeu d'échec en 3D avec DirectX 9. Mon problème est le suivant, j'ai un screenshot plutôt sympathique d'un rendu graphique que j'aimerai obtenir pour mon jeu. Cependant ce rendu graphique semble utiliser pas mal de techniques et du coup je suis un peu perdu .

En d'autres termes j'aimerai obtenir ça:



Mais pour le moment je n'ai que ça:



Je n'ai pas de textures et les pièces ne possèdent pas de matière (material).

Mes questions sont les suivantes:
- Dois je rajouter les matières via un logiciel ou utiliser un shader pour les générer ?
- Quels sont les techniques à utiliser ? HDR ? DIM ? Ambient Occlusion ? Shadow map ? Reflection ? Depth map ?
- Quel est l'ordre de difficulté d'implémentation pour les techniques ?
- Par exemple est ce que je dois commencer par créer un shader pour le damier ? (transparence + réflexion)

Voilà en gros il me faudrait surtout des indices pour le nom des techniques. Après je me débrouillerai pour trouver des exemples et implémenter les shaders.

Merci d'avance pour l'aide .

[LittleWhite]

Bonjour,

Pour l'image de base, nous avons de la chance, je n'ai pas vu d'ombre, ni de normal mapping (ou autre). Juste des lumières / matérials.
Même si je trouve que l'emplacement des lumières est étrange, et qu'il me manque le specular (reflets de lampes) à plusieurs endroits.

Donc, ce que vous devez faire maintenant:

- Mettre le jeu sous forme solide (et non en fil de fer)
- Faire une gestion simple des lampe (Ambient + diffuse + specular)
- Rajouter des matériaux si besoin

Et après, je pense que l'on aura déjà un résultat assez proche de celui de l'image de base.
On pourra rajouter les ombres

Sur tout ce que j'ai dit, je ne vois pas de difficultés (en même temps, je commence à avoir l'habitude de faire ce genre de trucs )

Note: Il n'y a pas de transparence ni de reflection dans l'image de base. Mais si vous deviez en faire, la solution shader est pas mal (aussi pour les lampes) car cela permet une grand liberté de techniques, et aussi que c'est un truc de plus en plus utliser :p

[Vin789]

Merci LittleWhite pour cette réponse .

Il me semblait pourtant que les pièces blanches se reflétaient légèrement sur le damier mais bon je cherche la petite bête là . Suite à votre conseil j'ai commencé par l'éclairage.

Contrairement à ce que je pensais les pièces semblent avoir des matériaux. J'ai voulu réutiliser un vieux shader OpenGL d'un livre pour éclairer les pièces mais je n'obtiens que des pièces blanches quand je l'applique. Étant débutant avec les shaders je pense que ma conversion GLSL vers HLSL n'a pas fonctionné .

Le code OpenGL:

Vertex:

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
 
#version 120
 
uniform mat4 projection_matrix;
uniform mat4 modelview_matrix;
uniform mat3 normal_matrix;
 
uniform vec4 material_ambient;
uniform vec4 material_diffuse;
uniform vec4 material_specular;
uniform vec4 material_emissive;
uniform float material_shininess;
 
struct light 
{
	vec4 position;
	vec4 diffuse;
	vec4 specular;
	vec4 ambient;
};
 
uniform light light0;
 
attribute vec3 a_Vertex;
attribute vec3 a_Normal;
 
varying vec4 color;
 
void main(void) 
{
	vec3 N = normalize(normal_matrix * a_Normal);	
	vec3 L = normalize(modelview_matrix * light0.position).xyz;
	float NdotL = max(dot(N, L.xyz), 0.0);
 
	vec4 finalColor = material_ambient * light0.ambient;
	vec4 pos = modelview_matrix * vec4(a_Vertex, 1.0);	
	vec3 E = -pos.xyz;
 
	if (NdotL > 0.0) 
	{
		vec3 HV = normalize(L + E);
		finalColor += material_diffuse * light0.diffuse * NdotL;
	}
 
	color = finalColor;
 
	gl_Position = projection_matrix * pos;		
}

Pixel:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
 
#version 120
 
varying vec4 color;
 
void main(void) 
{
	gl_FragColor = color;
}

Et la conversion que j'en ai faite en HLSL:

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
 
struct VS_INPUT
{
    float4 Position : POSITION;
    float3 Normal : NORMAL;
};
 
struct VS_OUTPUT
{
    float4 Position : POSITION;
    float4 Color : COLOR0;
};
 
// Views
float4x4 ModelViewMatrix;
float4x4 ProjectionMatrix;
float3x3 NormalMatrix;
 
//Material values
float4 MaterialAmbient;
float4 MaterialDiffuse;
float4 MaterialSpecular;
float4 MaterialEmissive;
float MaterialShininess;
 
//Light values
float4 LightPosition;
float4 LightDiffuse;
float4 LightSpecular;
float4 LightAmbient;
 
VS_OUTPUT vs_main( in VS_INPUT In )
{
    VS_OUTPUT Out;
 
	float3 N = normalize(mul(In.Normal,NormalMatrix));
	float3 L = normalize(mul(LightPosition,ModelViewMatrix)).xyz;
	float NdotL = max(dot(N, L.xyz), 0.0);
 
	float4 finalColor = mul(LightAmbient,MaterialAmbient);
	float4 pos = mul(In.Position,ModelViewMatrix);
	float3 E = -pos.xyz;
 
	if (NdotL > 0.0) 
	{
		float3 HV = normalize(L + E);
		finalColor += MaterialDiffuse * LightDiffuse * NdotL;
	}
 
	Out.Position = mul(pos,ProjectionMatrix);
	Out.Color = finalColor;
    return Out; 
}
 
/*****************************************************/
/*****************************************************/
/*****************************************************/
 
// Pixel shader input structure
struct PS_INPUT
{
    float4 Color : COLOR0;
};
 
// Pixel shader output structure
struct PS_OUTPUT
{
    float4 Color   : COLOR0;
};
 
PS_OUTPUT ps_main( in PS_INPUT In )
{
    PS_OUTPUT Out;
 
    Out.Color = In.Color;
 
    return Out;
}

Voilà, si quelqu'un voit des erreurs je suis preneur . Sinon c'est que c'est le code C++ qui est à remettre en cause, dans ce cas je chercherai de ce côté. Le shader GLSL fonctionne bien. Voilà le rendu de l'un des modèles de pièce que j'utilise avec un petit programme OpenGL:



Merci encore pour l'aide.

[LittleWhite]

Je ne vois pas de différence. Peut être un problème de transfert de valeurs entre le programme et le shader.

[stardeath]

je pense que ma conversion GLSL vers HLSL n'a pas fonctionné .

on peut voir le résultat avec hlsl?

et comme d'habitude, qu'est ce qui n'a pas fonctionné?

[Vin789]

on peut voir le résultat avec hlsl?

et comme d'habitude, qu'est ce qui n'a pas fonctionné?

Heu, comme je le disais plus haut je n'obtiens que des pièces blanches sans effet avec HLSL, désolé pour le manque de précision . En gros le rendu donne ça:



L'état D3DRS_LIGHTING est bien à TRUE, si je n'active pas le shader, je n'ai pas de rendu. Et si par exemple je change le contenu final du vertex shader avec une couleur rouge alors les pièces sont bien colorées en rouge.

[LittleWhite]

Comme je l'ai dit, il se peut que se soit les donnees envoyes au shaders qui sont fausses.
On peut verifier juste en affichant ces donnees avec l'attribut des couleurs.

Sinon ... je ne vois pas vraiment le probleme.

[Vin789]

Comme je l'ai dit, il se peut que se soit les donnees envoyes au shaders qui sont fausses.
On peut verifier juste en affichant ces donnees avec l'attribut des couleurs.

Sinon ... je ne vois pas vraiment le probleme.

Oups je n'avais pas vu votre deuxième message . Je vais regarder du côté des valeurs envoyées au shader dans ce cas.

[stardeath]

L'état D3DRS_LIGHTING est bien à TRUE, si je n'active pas le shader, je n'ai pas de rendu. Et si par exemple je change le contenu final du vertex shader avec une couleur rouge alors les pièces sont bien colorées en rouge.

si tu utilises le pipeline programmable (shader) beaucoup de render states sont inopérants comme justement D3DRS_LIGHTING.

[Vin789]

si tu utilises le pipeline programmable (shader) beaucoup de render states sont inopérants comme justement D3DRS_LIGHTING.

D'accord, je pensais qu'il fallait quand même désactiver l'état D3DRS_LIGHTING (le mettre à TRUE pour laisser l'utilisateur gérer la luminosité) pour être sûr qu'il n’y est pas de conflit entre les deux pipelines.

[Vin789]

J'ai regardé rapidement les valeurs envoyés au shader pour les couleurs. Elles sont identiques dans les deux programmes (OGL et DX).Tant qu'à y aller carrément j'ai codé les valeurs en dur dans le shader pour tester son comportement. La aussi je l'ait fait pour les deux programmes. J'ai aussi modifié un peu le shader, il y avait des variables en trop (specular et emissive ne sont pas utilisés). Toujours un rendu correct pour le GLSL mais tout blanc pour HLSL.

Le code des shaders modifiés:

GLSL:

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
 
#version 120
 
uniform mat4 projection_matrix;
uniform mat4 modelview_matrix;
uniform mat3 normal_matrix;
 
struct light {
	vec4 position;
	vec4 diffuse;
	vec4 ambient;
};
 
attribute vec3 a_Vertex;
attribute vec3 a_Normal;
 
varying vec4 color;
 
void main(void) 
{
	//Variables en dure
	light light0;
	light0.position = vec4(360, 430, 242, 1.0f);
	light0.diffuse = vec4(1.0f, 1.0f, 1.0f, 1.0f);
	light0.ambient = vec4(0.5f, 0.5f, 0.5f, 1.0f);
 
	vec4 material_ambient = vec4(1.0f,1.0f,1.0f,1.0f);
	vec4 material_diffuse = vec4(1.0f,1.0f,1.0f,1.0f);
 
	//Shader
 
	vec3 N = normalize(normal_matrix * a_Normal);	
	vec3 L = normalize(modelview_matrix * light0.position).xyz;
	float NdotL = max(dot(N, L.xyz), 0.0);
 
	vec4 finalColor = material_ambient * light0.ambient;
	vec4 pos = modelview_matrix * vec4(a_Vertex, 1.0);	
 
	if (NdotL > 0.0) 
	{
		finalColor += material_diffuse * light0.diffuse * NdotL;
	}
 
	color = finalColor;
 
	gl_Position = projection_matrix * pos;		
}

HLSL:

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
 
struct VS_INPUT
{
    float4 Position : POSITION;
    float3 Normal : NORMAL;
};
 
struct VS_OUTPUT
{
    float4 Position : POSITION;
    float4 Color : COLOR0;
};
 
// Views
float4x4 ModelViewMatrix;
float4x4 ProjectionMatrix;
float3x3 NormalMatrix;
 
VS_OUTPUT vs_main( in VS_INPUT In )
{
	//Material values
	float4 MaterialAmbient = float4(1.0,1.0,1.0,1.0);
	float4 MaterialDiffuse = float4(1.0,1.0,1.0,1.0);
 
	//Light values
	float4 LightPosition = float4(360, 430, 242, 1.0f);
	float4 LightDiffuse = float4(1.0f, 1.0f, 1.0f, 1.0f);
	float4 LightAmbient = float4(0.5f, 0.5f, 0.5f, 1.0f);
 
    VS_OUTPUT Out;
 
	float3 N = normalize(mul(In.Normal,NormalMatrix));
	float3 L = normalize(mul(LightPosition,ModelViewMatrix)).xyz;
	float NdotL = max(dot(N,L.xyz), 0.0);
 
	float4 finalColor = mul(LightAmbient,MaterialAmbient);
	float4 pos = mul(In.Position,ModelViewMatrix);
 
	if (NdotL > 0.0) 
	{
		finalColor += (mul(LightDiffuse,MaterialDiffuse) * NdotL);
	}
 
	Out.Position = mul(pos,ProjectionMatrix);
	Out.Color = finalColor;
    return Out; 
}

Il ne reste que 3 paramètres dans le shader. Est ce que le problème pourrait provenir des normals ?

Merci encore pour l'aide et vos réponses.

[LittleWhite]

J'etais exactement entrain de penser aux normals.
Encore une fois, pour debugguer du shader, la methode la plus simple est d'afficher les normals comme si c'etait des couleurs.
Notez aussi, que les normals doivent etre passe au shader comme des vertex / couleurs ... et que aussi, votre objet 3D doit en avoir.

[_MAID]

Ta transcription est un peu tordu. De plus je ne suis pas sur que ton pixel shader soit complet pour ce que tu souhaites faire.

Effectivement, il te faut aussi bien vérifier que tes modèles ont été bien 'normalisés', sinon point de restitution de light convenable.

Et (si je puis me permettre) plutôt que de chercher à transcrire un GLSL vers du HLSL, essais plutôt de partir sur ton propre code,
et en comprenant parfaitement ce que tu fais. Cela te permettra par la suite de beaucoup mieux le faire évoluer et d'arriver en final
à l'effet recherché. De très bon tuto sont la pour t'aider, comme par exemple:
xnameetingpoint.web.officelive.com/FrenchShader1 très bonne serie, en français,
Basic HLSL Lighting Techniques en anglais.

[Vin789]

Ta transcription est un peu tordu. De plus je ne suis pas sur que ton pixel shader soit complet pour ce que tu souhaites faire.

Effectivement, il te faut aussi bien vérifier que tes modèles ont été bien 'normalisés', sinon point de restitution de light convenable.

Et (si je puis me permettre) plutôt que de chercher à transcrire un GLSL vers du HLSL, essais plutôt de partir sur ton propre code,
et en comprenant parfaitement ce que tu fais. Cela te permettra par la suite de beaucoup mieux le faire évoluer et d'arriver en final
à l'effet recherché.

Je me doutais bien que ma retranscription tenait plus du bidouillage qu'autre chose . Va pour les tutos alors. Je reviendrais demander de l'aide si je n'arrive toujours pas à obtenir ce que je veux.

Merci pour les liens

[stardeath]

je ne sais pas si tu utilises les shaders en brut ou si tu passes par un fichier effet, mais dans le cas des shaders bruts, il ne faut pas oublier de passer les matrices transposées à la carte graphique.

[Vin789]

J'utilisai les shaders en brut mais je vais regarder du côté de la classe ID3DXEffect.