Discussion :

[willayclement]

Bonjour à tous !

Certains d'entre vous me connaissent un peu, je suis l'auteur de plusieurs mini-game sans prétention réalisé à l'aide du logiciel Multimédia Fusion 2. Il s'agit, pour ceux qui ne connaissent pas, d'un logiciel permettant de créer facilement ses propres jeux en "programmant" à l'aide d'une grille d'événement et ne necessite aucun savoir faire de programmeur pour obtenir des résultats sympathique et rapidement.

Le logiciel permet de faire tout type de jeux 2D (Pourquoi il poste dans la rubrique moteur 3D alors ce type O_o) d'une qualité au moins équivalente à flash et peut atteindre le XNA (mais toujours en 2D et sur PC). Par exemple mon jeu Luor est d'un qualité un peu au dessus en terme d'effets graphiques à ce qu'on peut trouver dans un jeu flash : http://www.developpez.net/forums/d65...hootemup-luor/

En effet, Multimédia Fusion 2 dispose désormais d'un moteur graphique basé entièrement sur DirectX et qui est, je pense, relativement puissant. Une fonctionnalité qui offre beaucoup de possibilité est sans aucun doute le support des shaders 2.0 (et 1.1 bien sur), et c'est pour ça que je poste ici, car je pense que vous êtes les plus enclins à m'aider.

Seulement le moteur étant uniquement en 2D (même si apparemment d'après ce que j'ai compris, les sprites serait quand même posé sur des polygones :s ) je n'arrive pas trop à comprendre comment faire des shaders utilisables.

Il ya pourtant moyen, puisque plusieurs personnes ont réussi à créer des shaders (même s'ils sont basiques, genre coloré en rouge les pixels bleus)

Ce qui est sur c'est qu'on ne peut pas utiliser les vertex shaders, mais seulement des pixels shaders.

Voici un exemple de pixels shaders qui fonctionne :

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
 
// Pixel shader input structure
struct PS_INPUT
{
    float4 Position   : POSITION;
    float2 Texture    : TEXCOORD0;
};
 
// Pixel shader output structure
struct PS_OUTPUT
{
    float4 Color   : COLOR0;
};
 
// Global variables
sampler2D Tex0;
float fCoeff;
 
PS_OUTPUT ps_main( in PS_INPUT In )
{
    // Output pixel
    PS_OUTPUT Out;
 
    PS_OUTPUT TexT;
    PS_OUTPUT TexTL;
    PS_OUTPUT TexL;
    PS_OUTPUT TexBL;
    PS_OUTPUT TexB;
    PS_OUTPUT TexBR;
    PS_OUTPUT TexR;
    PS_OUTPUT TexTR;
	TexT.Color = tex2D(Tex0, float2(In.Texture.x,In.Texture.y-fCoeff));
	TexTL.Color = tex2D(Tex0, float2(In.Texture.x-fCoeff,In.Texture.y-fCoeff));
	TexL.Color = tex2D(Tex0, float2(In.Texture.x-fCoeff,In.Texture.y));
	TexBL.Color = tex2D(Tex0, float2(In.Texture.x-fCoeff,In.Texture.y+fCoeff));
	TexB.Color = tex2D(Tex0, float2(In.Texture.x,In.Texture.y+fCoeff));
	TexBR.Color = tex2D(Tex0, float2(In.Texture.x+fCoeff,In.Texture.y+fCoeff));
	TexR.Color = tex2D(Tex0, float2(In.Texture.x+fCoeff,In.Texture.y));
	TexTR.Color = tex2D(Tex0, float2(In.Texture.x+fCoeff,In.Texture.y-fCoeff));
	Out.Color = tex2D(Tex0, float2(In.Texture.x,In.Texture.y));
 
	Out.Color = (Out.Color+TexT.Color+TexTL.Color+TexL.Color+TexBL.Color+TexB.Color+TexBR.Color+TexR.Color+TexTR.Color)/9;
 
    return Out;
}
 
// Effect technique
technique tech_main
{
    pass P0
    {
        // shaders
        VertexShader = NULL;
        PixelShader  = compile ps_2_0 ps_main();
    }  
}

Ce shaders fais un faux effets de blur en copiant l'image 9 fois à des positions différentes (l'effet est trompe l'oeil avec un petit coefficient de distance entre les clones, mais sinon c'est vraiment laid :s)

J'aimerais vraiment apprendre à créer de vrais bons shaders car il n'existe pas de vraiment bon, tel qu'un vrai effet de blur, de bloom, ou tout autre effets sympa de post prod

Le problème étant que je ne connais pas tant que ça les shaders et surtout que je ne souhaite que faire des shaders adaptables pour MMF2.

Par exemple, comment faire un bon effet de blur utilisable avec un coefficient de "floutage" ?

Quelqu'un peut-il m'aider ?

[Mikmacer]

Il existe pas mal de tutorial sur les shaders sur internet.. quand on débute, c'est pas trop évident. Mais MMF2 est un logiciel 2D, si je ne me trompe pas, donc pas besoins de faire de transformations complexes, en général.

Pour faire du blur, tu dois faire ce qu'on appel un downsampling, suivi d'un gaussian blur, c'est la technique la plus utilisé je crois.

Je te conseil de télécharger rendermonkey et de regarder les exemples de pixel shader, c'est un bon début pour commencer

[willayclement]

Ok merci, je vais essayer d'aller voir du coté de rendermonkey. MMF2 est un logiciel 2D oui, mais le moteur qui utilise directX gère quand même des polygones texturé (avec les images en fait) mais sans l'axe des Z (de ce que j'avais compris)

Sinon oui pour faire du blur, il faut que je fasse du gaussien, mais c'est justement cet algorithme que je n'arrive pas à trouver... Par contre je ne vois pas ce qu'est le downsampling :s

En tout cas, merci je vais allez voir ça