[C#][DX9] Conversion de Fixed Pipeline vers Programmable Pipeline

Dev
1

Actuellement, j’ai ce bout de code là:

[code]RenderingDevice.RenderState.AlphaBlendEnable = true;

RenderingDevice.SetTexture(0, TextureUsed.GetTexture(0).Data);

RenderingDevice.TextureState[0].ColorOperation = TextureOperation.SelectArg1;
RenderingDevice.TextureState[0].ColorArgument1 = TextureArgument.TextureColor;
RenderingDevice.TextureState[0].ColorArgument2 = TextureArgument.Diffuse;

RenderingDevice.TextureState[0].AlphaOperation = TextureOperation.Modulate;
RenderingDevice.TextureState[0].AlphaArgument1 = TextureArgument.TextureColor;
RenderingDevice.TextureState[0].AlphaArgument2 = TextureArgument.Diffuse;

RenderingDevice.RenderState.SourceBlend = Blend.SourceAlpha;
RenderingDevice.RenderState.DestinationBlend = Blend.InvSourceAlpha;
RenderingDevice.RenderState.BlendOperation = BlendOperation.Add;

RenderingDevice.RenderState.ZBufferEnable = false;[/code]

Vous vous doutez bien que RenderingDevice est un D3DDevice. Bon, on me fait signe que les fixed pipeline, c’est le mal. Je veux bien. J’aimerais donc m’en débarasser, j’ai jeté un coup d’oeil sur les HLSL, le truc qui va bien de Krosoft.

Question 1: Si ma carte graphique ne supporte pas les pixels shaders, vertex shaders, est ce que DirectX est capable de retransformer des HLSL simples en fixed pipe? Genre le bout de code ci dessus tourne sur une Ati 7200. La transformation en HLSL va pas rendre ma carte graphique incompatible? (je me dis que faut que je m’y mettes, DX10 abandonne complètement le modèle de fixed pipeline…, et oui j’ai 3 générations de Direct3D de retard)

Question 2: Comment je transforme ca en HLSL?

/me entames l’invocation de c0unt0 et assimilés.

2

Je sais pas comment ça se passe en DirectX mais en OpenGL c’est à toi de vérifier à la mimine si la carte graphique gère les shaders. Si elle ne les gère pas, aucun moyen de lui en filer un à becter :stuck_out_tongue: .
Donc fonction en double si tu veux absolument laisser l’accès à ton prog aux vieilles cartes graphiques.

Q2 : http://www2.ati.com/misc/samples/dx9/FixedFuncShader.pdf :stuck_out_tongue:

3

[quote=« TwinSidE, post:2, topic: 26849 »]Je sais pas comment ça se passe en DirectX mais en OpenGL c’est à toi de vérifier à la mimine si la carte graphique gère les shaders. Si elle ne les gère pas, aucun moyen de lui en filer un à becter :stuck_out_tongue: .
Donc fonction en double si tu veux absolument laisser l’accès à ton prog aux vieilles cartes graphiques.

Q2 : http://www2.ati.com/misc/samples/dx9/FixedFuncShader.pdf :P[/quote]

Ben en fait si t’as pas de support hardware des shaders, tu peux pas les utiliser. Logique. Sauf pour les vertex shaders, qui peuvent être émulés en software (parce que la puissance nécessaire reste encore a la portée du CPU). A mon avis, de nos jours, inutile de vouloir supporter les vieilles cartes sans shaders :stuck_out_tongue: Surtout si tu peux te contenter de shaders 1.1… cela dit, les shaders 1.1 sont super limités quand même. On ne peut faire de dév un peu sérieux qu’à partir des 2.0 (tout en flottant, tout ça tout ça). Avant, c’est pratique, mais on tape très vite les limites quand même.

4

Ca reponds pas exactement a ta questions (je connais pas le d3d9 moi, en fait…), mais un petit truc qui va aider : 3DLab a sortie une ptite app qui genere du hlsl equivalent au pipe fix

sinon il me semble avoir vue passer un article sur microsoft.com, faudra chercher!

Bon en fait, c’est de l’openGL, mais tu devrais pouvoir adapter sans trops de problemes !

5g4r 3d1t : avec le lien, c’est mieux !
5g4r 3d1t 2: le meme, sans la pipe a crack

5

Déjà, tu peux conserver tout ce qui concerne le blending. Même en utilisant les pixel shaders, ça a encore son utilité.

[code]RenderingDevice.RenderState.AlphaBlendEnable = true;

RenderingDevice.SetTexture(0, TextureUsed.GetTexture(0).Data);

RenderingDevice.RenderState.SourceBlend = Blend.SourceAlpha;
RenderingDevice.RenderState.DestinationBlend = Blend.InvSourceAlpha;
RenderingDevice.RenderState.BlendOperation = BlendOperation.Add;

RenderingDevice.RenderState.ZBufferEnable = false;[/code]

Par contre, le reste peut être remplacé par un programme HLSL de ce genre:

[code]Texture Texture0;

sampler2D colorMap : register (s0) = sampler_state
{
Texture = ;
};

struct PS_INPUT
{
float2 texcoord0 : TEXCOORD0;
float4 diffuse : COLOR0;
};

struct PS_OUTPUT
{
float4 color : COLOR;
};

////////////////////////////////////////

PS_OUTPUT psMain(PS_INPUT In)
{
PS_OUTPUT Out = (PS_OUTPUT)0;

float4 texColor = tex2D(colorMap, In.texcoord0);

Out.color.rgb = texColor.rgb;  // selectArg1 texture color
Out.color.a = texColor.a * diffuse.a;  // modulate texture alpha & diffuse alpha

return Out;

}[/code]

Par contre, si tu n’as aucun support des pixel shaders, tu devras te contenter du fixed pipeline.

6

C’est bien ce que je craignais; et pour les gens du fond qui rigolent, je m’entraines à programmer des petits jeux à la con, donc j’aimerais qu’ils marchent partout et pas seulement sur une config de roxor.

Déjà que moi j’ai pas une config de roxor sur la bécanne de dev (Duron 900, 512 SDRam, Ati 7200, ouais je sais ca déchire).

Déjà, l’essentiel c’est que j’ai compris (à peu près) le bout de code de sébastien. Merci à tous pour vos précisions :P.