[résolu] Accès impossible à des variables dans le .fx

Salut,

je viens ici avec un souci qui me bloque complètement depuis quelques temps; j’avais pu faire sans mais là …
Il se trouve que je n’arrive pas à accéder à certaines variables de mon fichier .fx, alors que d’autres sont accessibles…

Sachant que:

  • mon fichier .fx compile sans erreurs ou warnings dans FXComposer;
  • je n’ai pas d’erreurs dans ma console de debug (dbmon), avec le mode debug directx réglé au level maximum;
  • quand j’utilise MonEffect.GetParameter(null, « monNomDeVariable »), je reçois NULL sur (toujours les mêmes) quelques variables.

Au secours, je vois pas du tout d’où ça peut venir … et c’est bloquant :confused:

Euh, elles sont initialisé quelque part tes variables ? et le principe du shader c’est de les definir, pas de les recuperer.

Mais sans le shader, ni le bout de code incriminé, ca va etre dur de voir plus avant. (Et mdx est plus supporté maintenant, c’est xna la releve)

Merci de répondre B)

Oui, mes variables sont initialisées et utilisées dans le code.

J’utilise la récupération du handle parce que MonEffet.SetValue(unvaleur, “mavariable”) donc une erreur d’application (sans plus de détail); donc j’ai utilisé la méthode qui consiste à faire un get sur le handle, puis un set d’une valeur sur ce handle pour m’apercevoir que mon handle était toujours nul.

Le code du shader en question:

[code]float4x4 WorldViewProj : WorldViewProjection;
float4x4 WorldViewIT : WorldInverseTranspose;
float4x4 WorldView : ViewInverse;
float4 MinMaxDist;
float4 FocusConst;

float4 lightDir : Direction
<

= {200.0f, 300.0f, 150.0f, 0.0f};

float4 lightColor : Diffuse
<

= {1.0f, 1.0f, 1.0f, 1.0f};

float4 lightAmbient : Ambient
<

= {1.0f, 1.0f, 1.0f, 1.0f};

float4 materialDiffuse : Diffuse
<

= {1.0f, 1.0f, 1.0f, 1.0f};

float UvOffsetToUse;
float4 UvBase[8];

//-------------------------------------------------------------------
// Textures (bound to real textures by app)
//-------------------------------------------------------------------

texture Meshes;
texture CircleOfConfusion;
texture WorldTex;
texture BlurTex;
texture FilteredTex0;
texture FilteredTex1;
texture FilteredTex2;

//-------------------------------------------------------------------
// Vertex shader input structures
//-------------------------------------------------------------------

struct vertexInput {
float3 position : POSITION;
float3 normal : NORMAL;
float4 texCoordDiffuse : TEXCOORD0;
};

struct VS_INPUT_PT {
float4 Position : POSITION;
float2 TexCoord : TEXCOORD0;
};

//-------------------------------------------------------------------
// Vertex shader output (and pixel shader input) structures
//-------------------------------------------------------------------

struct VS_OUTPUT_PT4 {
float4 oPosition : POSITION;
float2 oTexCoord0 : TEXCOORD0;
float2 oTexCoord1 : TEXCOORD1;
float2 oTexCoord2 : TEXCOORD2;
float2 oTexCoord3 : TEXCOORD3;
};

struct vertexOutput {
float4 hPosition : POSITION;
float4 texCoordDiffuse : TEXCOORD0;
float4 diffAmbColor : COLOR0;
float3 oTexCoord1 : TEXCOORD1;
};

//-------------------------------------------------------------------
// Texture samplers
//-------------------------------------------------------------------

sampler TextureSampler = sampler_state
{
texture = ;
AddressU = CLAMP;
AddressV = CLAMP;
AddressW = CLAMP;
MIPFILTER = LINEAR;
MINFILTER = LINEAR;
MAGFILTER = LINEAR;
};

sampler CircleOfConfusionSampler = sampler_state
{
Texture = ;
MinFilter = Linear;
MagFilter = Linear;
MipFilter = None;
AddressU = Clamp;
AddressV = Clamp;
AddressW = Clamp;
};

sampler BlurTexSampler = sampler_state
{
Texture = ;
MinFilter = Linear;
MagFilter = Linear;
MipFilter = Linear;
AddressU = Clamp;
AddressV = Clamp;
};

sampler FilteredTexSampler0 = sampler_state
{
Texture = ;
MinFilter = Linear;
MagFilter = Linear;
MipFilter = NONE;
AddressU = Clamp;
AddressV = Clamp;
};

sampler FilteredTexSampler1 = sampler_state
{
Texture = ;
MinFilter = Linear;
MagFilter = Linear;
MipFilter = NONE;
AddressU = Clamp;
AddressV = Clamp;
};

sampler FilteredTexSampler2 = sampler_state
{
Texture = ;
MinFilter = Linear;
MagFilter = Linear;
MipFilter = NONE;
AddressU = Clamp;
AddressV = Clamp;
};

//-------------------------------------------------------------------
// Vertex Shaders (and subroutines)
//-------------------------------------------------------------------

float ComputeDistance(float4 position)
{
float dist = dot(position, float4(WorldView[0][2], WorldView[1][2], WorldView[2][2], WorldView[3][2]));
//dist = dist / dot(position, float4(WorldView[0][3], WorldView[1][3], WorldView[2][3], WorldView[3][3]));
return dist;
}

vertexOutput VS_TransformAndTexture(vertexInput IN)
{
vertexOutput OUT;
OUT.hPosition = mul( float4(IN.position.xyz , 1.0) , WorldViewProj);
OUT.texCoordDiffuse = IN.texCoordDiffuse;

float3 worldEyePos = WorldView[3].xyz;
float3 worldVertPos = (IN.position).xyz;

float4 N = mul(IN.normal, WorldViewIT); //normal vector
float3 E = normalize(worldEyePos - worldVertPos); //eye vector
float3 L = normalize( -lightDir.xyz); //light vector
float3 H = normalize(E + L); //half angle vector

float  diff = max(0 , dot(N,L));

float4 ambColor = materialDiffuse * lightAmbient;
float4 diffColor = materialDiffuse * diff * lightColor;
OUT.diffAmbColor = diffColor + ambColor;

float4 lPosition = float4(IN.position, 1.0);
float dist = ComputeDistance(lPosition);		
OUT.oTexCoord1.x = dist*MinMaxDist.y - MinMaxDist.x;
OUT.oTexCoord1.yz = FocusConst.xy;

return OUT;

}

VS_OUTPUT_PT4 BlurVS(const VS_INPUT_PT IN)
{
VS_OUTPUT_PT4 OUT;

// Transform vertex position to clip space
OUT.oPosition = mul(IN.Position, WorldViewProj);	

int a = (int)UvOffsetToUse * 4;	

OUT.oTexCoord0 = IN.TexCoord + UvBase[a	].xy;
OUT.oTexCoord1 = IN.TexCoord + UvBase[a + 1].xy;
OUT.oTexCoord2 = IN.TexCoord + UvBase[a + 2].xy;
OUT.oTexCoord3 = IN.TexCoord + UvBase[a + 3].xy;

return OUT;

}

//-------------------------------------------------------------------
// Pixel Shaders
//-------------------------------------------------------------------

float4 BlurPS(VS_OUTPUT_PT4 IN) : COLOR
{
// This is a simple blur-shader: we simply average all alpha and color
// values together.

// get colors and alphas from all 4 texture stages
float4 color0 = tex2D(BlurTexSampler, IN.oTexCoord0);
float4 color1 = tex2D(BlurTexSampler, IN.oTexCoord1);
float4 color2 = tex2D(BlurTexSampler, IN.oTexCoord2);
float4 color3 = tex2D(BlurTexSampler, IN.oTexCoord3);

// return the average (keeping within the [-2..2] range)
return 0.5*( 0.5*(color0 + color1) + 0.5*(color2 + color3) );

}

float4 PS_Textured( vertexOutput IN): COLOR
{
float4 diffuseTexture = tex2D( TextureSampler, IN.texCoordDiffuse );
// return IN.diffAmbColor * diffuseTexture;

return float4(1.0f,1.0f,1.0f,1.0f);

}

//-------------------------------------------------------------------
// TECHNIQUES
//-------------------------------------------------------------------

technique TetraDOF
{
pass P0
{
VertexShader = compile vs_1_1 VS_TransformAndTexture();
PixelShader = compile ps_1_1 PS_Textured();
}
}

technique Blur
{
pass P0
{
VertexShader = compile vs_1_1 BlurVS();
PixelShader = compile ps_1_1 BlurPS();

	// note that these render-state changes are reverted once the effect is complete.
	AlphaBlendEnable = False;
	ZEnable		  = False;
	CullMode		 = None;
	FillMode		 = Solid;  // (even if wireframe is turned on)
	
	ColorOp[0]   = SelectArg1;
	ColorArg1[0] = Texture;
	ColorArg2[0] = Diffuse;
	ColorOp[1]   = Disable;
	AlphaOp[0]   = Disable;
}

}

technique ShowDepthOfField
{
pass P0
{
Sampler[0] = ;
Sampler[1] = ;
Sampler[2] = ;

	AlphaBlendEnable = False;
	ZEnable		  = False;
	CullMode		 = None;
	FillMode		 = Solid;  // (even if wireframe is turned on)

	VertexShader = compile vs_1_1 BlurVS();
	PixelShader  = 
	asm
	{
	   ; NOTE: This shader exists in HLSL above (see ShowDepthOfFieldPS),
	   ; but is commented out; the assembly version is used here because 
	   ; it's the only way to fit this shader in ps1.1.  The HLSL-compiled 
	   ; version will work if you compile it using ps_2_0; but since the 
	   ; assembly version will fit in ps_1_1, it is used here instead.
		
	   ; Declare pixel shader version 
		ps_1_1
		
		def c0, 0.0f, 0.0f, 0.0f, 0.5f
		def c1, 0.0f, 0.0f, 0.0f, 0.333333f
		
	   ; sample all the texture stages
		tex t0
		tex t1
		tex t2
		
	   ; first interpolate the interpolator: using t0 straight produces ghosting 
	   ; since the DoF selection is always hi-res (ie, t0) even for the blurred parts.
	   ; playing with various combinations of t0, t1, t2 shows that the following
	   ; is reasonable (depth-changing edges never get really unblurred)
	   ; and yet only takes a single instruction.
		lrp r0.a, c0, t2.a, t0.a
		
	   ; although the following also produces good results (but with a bit of ghosting
	   ; and two instructions)
	   ; r0.a = 0.666*(.5*t2.a + .5*t1.a) + 0.333 * t0.a)
	   ;	  = 0.333*(t0.a+t1.a+t2.a)
	   ; lrp r0.a, c0, t2.a, t1.a
	   ; lrp r0.a, c1, r0.a, t0.a	
		
		mov_x2_sat r1.a,   r0.a				// pretend 0 <= r0.a <= 0.5 
		lrp		   r1.rgb, r1.a, t1, t0		// correctly interpolate t0, t1 and store 
		mov_sat	r1.a,   r0_bx2.a		 // pretend 0.5 <= r0.a <= 1
		lrp		r0.rgb, r1.a, t2, t1	 // correctly interpolate t1, t2 and store 
		
		cnd		   r0.rgb, r0.a, r0, r1		// figure out which case is the true one and select it
		
	   ; mov r0.rgb, t0.a
	};
}

}[/code]

Et ça foire pour les variables lightDir, lightColor, lightAmbient et materialDiffuse.

Le bout de code incriminé est parfaitement trivial:

Vector4 lLightDir = new Vector4(200.0f, 300.0f, 150.0f, 0.0f); EffectHandle hLightDir = mDOF.GetParameter(null, "lightDir"); mDOF.SetValue(hLightDir , lLightDir);

mDOF est l’Effect en question qui charge le .fx.

Bon, je suis pas un pro en shaders, mais je constate que c’est les 4 variables qui sont declarées de la meme maniere qui ne fonctionnnent pas comme tu voudrais B)
Donc, soit ca vient de ton shader, et de la declaration de tes variables, ou alors ca vient de ton code, qui meme si il est trivial me parait tordu (et je suis pas un pro en mdx non plus, alors ca aide pa trop).

Ok, donc apres une petite recherche sur la msdn, mdx est pas top documenté. Si tu es motivé, tentes de migrer vers xna, la plus de monde devrait pouvoir t’aider.

Ouais, mais j’ai déjà tenté de les déclarer plus simplement, genre

Mais ça ne marche pas mieux.

Comment ça tordu ?

Ca c’est clair !

Ben oui mais là je suis surtout motivé pour que mon code fonctionne (y’a pas de raisons quoi).
C’est qu’une variable, à laquelle je veux assigner une valeur, ce doit être bête comme chou, mais ca ne fonctionne juste pas.

!summon GloP

Huhu desole je suis tres loin d’etre un pro du shader, je peux pas t’aider la, poste sur http://creators.xna.com tu auras une reponse super plus rapide et detaillee (au pire si t’en as pas je demanderais a un collegue de venir te repondre).

Merci beaucoup, j’y vais de ce pas B)

Hop, problème résolu.

Merci infiniment donc GloP pour ce magnifique lien !

(PS à ceux qui liront la réponse: oui, j’ai honte.)

Tout ca pour dire que tu t’es monstrueusement planté sur des noms de fichiers ! bouuh ! Sinon, ouais, cool que ce soit resolu, t’as eu de la chance qu’un gars pense a ca B)

C’est vraiment des forums avec plein de gens sympa qui ont un super niveau B) faut pas hesiter!

Ouais, d’ailleurs, on t’y voit pas beaucoup B)

Carrément !
J’ai trop les boules, ca fait longtemps que je bloque là dessus, j’ai passé 2/3 semaines (bon, pas à 100% hein) sur ce même f*****g fichier et je suis complètement passé à côté !

M’enfin bon, ca prouve une fois de plus que quand ça semble vraiment un problème hors norme et que quasi personne ne comprends ce qui se passe, la réponse est toujours la plus débile possible !

Je crois que je vais garder précieusement l’adresse en bookmark B)

Hehe, vrai, vrai mais j’ai un nouveau projet qui prend tout mon temps et je suis pas une machine comme Shawn B)