Rendu de shader invariablement noir

Bonsoir,

j'ai un souci avec un rendu de shader, que j'ai invariablement noir.
Je force le rendu à "tout les pixel en blanc" au niveau du pixel shader mais rien n'y fait. Et je n'y comprend rien du tout... Surtout qu'avec FX Composer tout est censé être ok.

Si je change l'appel vers un autre shader qui contient *exactement* le même code, j'ai un rendu correct. Le truc ce que je voudrais tout mettre dans le même, par simplicité, et surtout parce qu'une certain valeur est transmise d'une technique à l'autre, et les registres des shaders ne sont qu'en écriture, et pas en lecture, donc ce que je voudrais faire est tout simplement impossible en 2 shaders.

Le shader qui compile bien et qui est censé rendre du blanc:

Code:

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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
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 = <Meshes>;
    AddressU  = CLAMP;        
    AddressV  = CLAMP;
    AddressW  = CLAMP;
    MIPFILTER = LINEAR;
    MINFILTER = LINEAR;
    MAGFILTER = LINEAR;
};
 
 
sampler CircleOfConfusionSampler = sampler_state
{
    Texture = <CircleOfConfusion>;
    MinFilter = Linear;  
    MagFilter = Linear;
    MipFilter = None;
    AddressU  = Clamp;
    AddressV  = Clamp;
    AddressW  = Clamp;
};
 
sampler BlurTexSampler = sampler_state
{
    Texture = <BlurTex>;
    MinFilter = Linear;  
    MagFilter = Linear;
    MipFilter = Linear;
    AddressU  = Clamp;
    AddressV  = Clamp;
};
 
sampler FilteredTexSampler0 = sampler_state
{
    Texture = <FilteredTex0>;
    MinFilter = Linear;  
    MagFilter = Linear;
    MipFilter = NONE;
    AddressU  = Clamp;
    AddressV  = Clamp;
};
 
sampler FilteredTexSampler1 = sampler_state
{
    Texture = <FilteredTex1>;
    MinFilter = Linear;  
    MagFilter = Linear;
    MipFilter = NONE;
    AddressU  = Clamp;
    AddressV  = Clamp;
};
 
sampler FilteredTexSampler2 = sampler_state
{
    Texture = <FilteredTex2>;
    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] = <FilteredTexSampler0>;
        Sampler[1] = <FilteredTexSampler1>;
        Sampler[2] = <FilteredTexSampler2>;
 
        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
        };
    }
}

Le shader qui fonctionne bien et qui contient le même code: on appelle la même technique TetraDOF:

Code:

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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
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};
 
 
//-------------------------------------------------------------------
// Textures (bound to real textures by app)
//-------------------------------------------------------------------
 
texture Meshes;
//-------------------------------------------------------------------
// Vertex shader input structures
//-------------------------------------------------------------------
 
struct vertexInput {
    float3 position				: POSITION;
    float3 normal				: NORMAL;
    float4 texCoordDiffuse		: TEXCOORD0;
};
 
//-------------------------------------------------------------------
// Vertex shader output (and pixel shader input) structures
//-------------------------------------------------------------------
 
struct vertexOutput {
    float4 hPosition		: POSITION;
    float4 texCoordDiffuse	: TEXCOORD0;
    float4 diffAmbColor		: COLOR0;
    float3 oTexCoord1 : TEXCOORD1;
};
 
//-------------------------------------------------------------------
// Texture samplers
//-------------------------------------------------------------------
 
 
sampler TextureSampler = sampler_state 
{
    texture = <Meshes>;
    AddressU  = CLAMP;        
    AddressV  = CLAMP;
    AddressW  = CLAMP;
    MIPFILTER = LINEAR;
    MINFILTER = LINEAR;
    MAGFILTER = LINEAR;
};
 
//-------------------------------------------------------------------
// 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;
}
 
//-------------------------------------------------------------------
// Pixel Shaders
//-------------------------------------------------------------------
 
float4 PS_Textured( vertexOutput IN): COLOR
{
  float4 diffuseTexture = tex2D( TextureSampler, IN.texCoordDiffuse );
  return IN.diffAmbColor * diffuseTexture;
}
 
//-------------------------------------------------------------------
// TECHNIQUES
//-------------------------------------------------------------------
 
technique TetraDOF
{
    pass P0
    {
        VertexShader = compile vs_1_1 VS_TransformAndTexture();
		PixelShader  = compile ps_1_1 PS_Textured();
    }
}

La méthode d'où j'appelle tout ça:
je switch d'un Effect à l'autre en fonction de mes tests, et je configure les 2 shaders exactement de la même manière partout dans mon code.
Mais le rendu est différent ...

Code:

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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
		private static void _render()
		{
            int numpasses;
 
            while (mIsRunning)
            {
                if (mDevice == null)
                    return;
 
                try
                {
                    if (mIsWireFrame)
                        mDevice.RenderState.FillMode = FillMode.WireFrame;
                    else
                        mDevice.RenderState.FillMode = FillMode.Solid;
 
                    mDOF.SetValue("CircleOfConfusion", mCircleOfConfusionLookup);
 
                    mDevice.SetRenderTarget(0, mFilterTarget[0]);
                    mDevice.DepthStencilSurface = mDepthTarget;
                    mDevice.Clear(ClearFlags.Target | ClearFlags.ZBuffer, System.Drawing.Color.Orange, 1.0f, 0);
 
                    mFocusDistance = mFocusDistanceSAVE * 1000.0f * (float)Math.Cos(Environment.TickCount / 25.0f);
 
                    GenerateCircleOfConfusionTexture();
 
                    UpdateCameraParameters();
                    _UpdateMatrices();
 
                    mDevice.BeginScene();
 
                    SetupMatrices(mMatrixView, mWorld);
 
                    mDOF.Technique = "TetraDOF";
                    mEffectTextureAndLights.Technique = "TetraDOF";
 
                    switch (TAG_RENDER)
                    {
                        case TAG_RENDER_DOF:
                            mChoosedEffect = mDOF;
                            break;
                        case TAG_RENDER_TL:
                            mChoosedEffect = mEffectTextureAndLights;
                            break;
                        default:
                            mChoosedEffect = mEffectTextureAndLights;
                            break;
                    }
 
                    mDevice.VertexFormat = CustomVertex.PositionNormalTextured.Format;
 
                    foreach (MesheToRender lMesheToRender in mListToRender)
                    {
                        mDevice.SetStreamSource(0, lMesheToRender.getVertexBufferToDisplay(), 0);
 
                        mChoosedEffect.SetValue("Meshes", lMesheToRender.getTexture());
 
                        numpasses = mChoosedEffect.Begin(0);
 
                        for (int i = 0; i < numpasses; i++)
                        {
                            mChoosedEffect.BeginPass(i);
                            mDevice.DrawPrimitives(PrimitiveType.TriangleList, 0, lMesheToRender.getNumberOfVerticesToDisplay());
                            mChoosedEffect.EndPass();
                        }
 
                        mChoosedEffect.End();
                    }
 
                    // On prend la texture generee
                    // et on genere les blurs
                    Matrix lMatView, lMatProj, lMatViewProj, lMatWorldViewProj, lMatWorld;
                    Vector3 lEyePos, lLookAt, lUp;
 
                    lEyePos.X = 0.0f;
                    lEyePos.Y = 0.0f;
                    lEyePos.Z = -5.0f;
 
                    lLookAt.X = 0.0f;
                    lLookAt.Y = 0.0f;
                    lLookAt.Z = 0.0f;
 
                    lUp.X = 0.0f;
                    lUp.Y = 1.0f;
                    lUp.Z = 0.0f;
 
                    lMatView = Matrix.LookAtLH(lEyePos, lLookAt, lUp);
                    lMatProj = Matrix.OrthoLH(4.0f, 4.0f, 0.2f, 20.0f);
                    lMatViewProj = Matrix.Multiply(lMatView, lMatProj);
 
                    lMatWorld = Matrix.Scaling(2.0f, 2.0f, 2.0f);
                    lMatViewProj = Matrix.Multiply(lMatWorld, lMatViewProj);
 
                    mDOF.SetValue("WorldViewProj", lMatViewProj);
                    mDOF.SetValue("UvOffsetToUse", 1.0f);
 
                    mDevice.VertexFormat = CustomVertex.PositionTextured.Format;
                    mDevice.SetStreamSource(0, mQuadVertexBuffer, 0);
 
                    mDOF.Technique = "Blur";
 
                    Texture lSource;
                    Surface lDestination;
 
                    for (int i = 1; i < 3; ++i)
                    {
                        for (int j = 0; j < mNumOfFilterSteps; ++j)
                        {
                            lSource = mTempTexture[j % 2];
                            lDestination = mTempTarget[(j + 1) % 2];
 
                            if (j == 0)
                                lSource = mTextureFiltered[i - 1];
                            else if (j == mNumOfFilterSteps - 1)
                                lDestination = mFilterTarget[i];
 
                            mDevice.SetRenderTarget(0, lDestination);
                            mDevice.DepthStencilSurface = null;
 
                            mDOF.SetValue("BlurTex", lSource);
 
                            numpasses = mDOF.Begin(0);
 
                            for (int lPasse = 0; lPasse < numpasses; lPasse++)
                            {
                                mDOF.BeginPass(lPasse);
                                mDevice.DrawPrimitives(PrimitiveType.TriangleFan, 0, 2);
                                mDOF.EndPass();
                            }
 
                            mDOF.End();
                        }
                    }
 
                    mDevice.SetRenderTarget(0, mBackbufferColor);
                    mDevice.DepthStencilSurface = null;
 
                    mDevice.VertexFormat = CustomVertex.PositionTextured.Format;
 
                    mDOF.Technique = "ShowDepthOfField";
 
                    // use the original and blurred textures as inputs
                    mDOF.SetValue("FilteredTex0", mTextureFiltered[0]);
                    mDOF.SetValue("FilteredTex1", mTextureFiltered[1]);
                    mDOF.SetValue("FilteredTex2", mTextureFiltered[2]);
 
                    lMatWorld = Matrix.Scaling(1.0f, 1.0f, 1.0f);
                    lMatWorldViewProj = Matrix.Multiply(lMatWorld, lMatViewProj);
 
                    mDOF.SetValue("WorldViewProj", lMatWorldViewProj);
                    mDOF.SetValue("UvOffsetToUse", 0.0f);
 
                    numpasses = mDOF.Begin(0);
 
                    for (int lPasse = 0; lPasse < numpasses; lPasse++)
                    {
                        mDOF.BeginPass(lPasse);
                        mDevice.DrawPrimitives(PrimitiveType.TriangleFan, 0, 2);
                        mDOF.EndPass();
                    }
 
                    mDOF.End();
 
                    //
                    mDevice.EndScene();
                    mDevice.Present();
                    Application.DoEvents();
                }
                catch (Exception lException)
                {
                    MessageBox.Show(lException.StackTrace);
                }
            }
		}

Voilà, je voudrais donc comprendre pourquoi je n'ai qu'un rendu noir ...

Langage: c#
DirectX: 9

Bon alors, déjà maintenant j'utilise dbmon avec les mode debug qui (je l'espère vont bien).

Première erreur: la declaration du vertex shader ne matche pas le format du vertex buffer.

Le format du vertex buffer est declaré comme PositionNormalTextured, et le vertex shader comme suit:

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

Ce qui est censé correspondre non ?

bon j'avais bien une erreur de format quelque part.

Au niveau le plus bas d'erreurs directx je n'ai maintenant plus rien... mais mon rendu est toujours complètement noir.

Dans le niveau d'alerte le plus haut de debug directx, j'ai :

Citation:

1184: Direct3D9: (WARN) :Ignoring redundant SetRenderState 27
1184: Direct3D9: (WARN) :Ignoring redundant SetRenderState 8

Citation:

1184: Direct3D9: (WARN) :Ignoring redundant SetTextureStageState Stage: 0, State: 2
1184: Direct3D9: (WARN) :Ignoring redundant SetTextureStageState Stage: 1, State: 1

C'est grave docteur ?

Ceci évoque-t'il quelque chose à quelqu'un ?

Citation:

2656: Direct3D9: (WARN) :Can not render to a render target that is also used as a texture. A render target was detected as bound, but couldn't detect if texture was actually used in rendering.

Citation:

(WARN) :Ignoring redundant SetRenderState

Ca veut juste dire que tu envoies deux fois de suite le même état, et que le driver ignore le second (puisque c'est le même). C'est donc loin d'être grave.

Citation:

(WARN) :Can not render to a render target that is also used as a texture. A render target was detected as bound, but couldn't detect if texture was actually used in rendering.

Là ça l'est plus : il te dit que la texture sur laquelle tu essayes de rendre la scène est toujours utilisée. Il faut que tu la retire de l'unité de texture sur laquelle elle est en faisant un petit SetTexture(NULL).

Merci de répondre :)

Citation:

Envoyé par Laurent Gomila

Ca veut juste dire que tu envoies deux fois de suite le même état, et que le driver ignore le second (puisque c'est le même). C'est donc loin d'être grave.

Ok.

Citation:

Envoyé par Laurent Gomila

Là ça l'est plus : il te dit que la texture sur laquelle tu essayes de rendre la scène est toujours utilisée. Il faut que tu la retire de l'unité de texture sur laquelle elle est en faisant un petit SetTexture(NULL).

Ok ...
Cela dit c'est une erreur qui se produit quand ma fenêtre de rendu n'a pas la focus, donc c'est pas critique pour le moment.

Pas d'idée pour le problème de rendu ?
Parce que là je sèche vraiment ... je vois pas de différence entre mes shaders, je comprends vraiment pas ce qu'il se passe.

On peut mettre des points d'arrêts dans le .fx ?

Citation:

Cela dit c'est une erreur qui se produit quand ma fenêtre de rendu n'a pas la focus, donc c'est pas critique pour le moment

Donc ce warning n'apparaît pas en conditions "normales" ? Je pensais que ça donnait l'explication du rendu complétement noir.

Citation:

Envoyé par Laurent Gomila

Donc ce warning n'apparaît pas en conditions "normales" ? Je pensais que ça donnait l'explication du rendu complétement noir.

Non, voilà, si je laisse l'appli tourner tranquillement, je n'ai aucun warning, ni aucune erreur.

Citation:

Envoyé par Laurent Gomila

Donc ce warning n'apparaît pas en conditions "normales" ? Je pensais que ça donnait l'explication du rendu complétement noir.

Et en fait je dois préciser que la fenêtre de rendu n'est pas totalement noire, mais seulement les triangles que je dessine, comme si j'éclairais avec une lumière nulle.

Pour qu'on se rende mieux compte de mon souci, j'ai sauvé les surfaces dans lesquelle j'effectue mon rendu.
Ainsi, vu mon code, seul le fichier contenant le shader change, le code est censé etre exactement le même.

Dans un fichier séparé (le rendu est celui attendu):
http://monkey.grotto.free.fr/files/testTL.bmp

Dans un seul fichier .fx (le problème):
http://monkey.grotto.free.fr/files/testDOF.bmp

Au secours ... :(

Je ne lock pas mon vertexbuffer avant d'y acceder par mon shader, dans l'ou ou l'autre des cas;
c'est grave ?

personnellement quand j'ai ce genre de problème cela vient soit des textures mal envoyé au shader soit les valeurs par défaut qui fonctionne pas tout le temps (ou ça vient de moi) du coup je fait plus confiance à ça:

//[...]
> = {200.0f, 300.0f, 150.0f, 0.0f};
//[...]
> = {1.0f, 1.0f, 1.0f, 1.0f};
//etc...

et donc j'envoi moi même ces valeurs à l'effect.

Citation:

Envoyé par ShadowTzu

personnellement quand j'ai ce genre de problème cela vient soit des textures mal envoyé au shader soit les valeurs par défaut qui fonctionne pas tout le temps (ou ça vient de moi) du coup je fait plus confiance à ça:

//[...]
> = {200.0f, 300.0f, 150.0f, 0.0f};
//[...]
> = {1.0f, 1.0f, 1.0f, 1.0f};
//etc...

et donc j'envoi moi même ces valeurs à l'effect.

Ca pourrait "mal" se passer ?
Parce que j'ai ces mêmes valeurs dans les deux fichiers ...

Bon, je tente quand même de les initialiser à la main ...

Citation:

Envoyé par ShadowTzu

personnellement quand j'ai ce genre de problème cela vient soit des textures mal envoyé au shader soit les valeurs par défaut qui fonctionne pas tout le temps (ou ça vient de moi) du coup je fait plus confiance à ça:

//[...]
> = {200.0f, 300.0f, 150.0f, 0.0f};
//[...]
> = {1.0f, 1.0f, 1.0f, 1.0f};
//etc...

et donc j'envoi moi même ces valeurs à l'effect.

J'ai un souci à l'affectation de variables dans le shader (mDOF est l'effect qui a chargé le .fx):
Code:

1 2 3 4 5 6 7 8 9 10 Vector4 lLightDir = new Vector4(200.0f, 300.0f, 150.0f, 0.0f); try { mDOF.SetValue("lightDir", lLightDir); } catch (Direct3DXException lException) { MessageBox.Show(lException.Message); }
Et dans l'exception, j'ai juste une "erreur d'application". Dans DBMon, RAS:

Citation:

3328: Direct3D9: :====> ENTER: DLLMAIN(053ee6e0): Process Attach: 00000d00, tid=
00000f88
3328: Direct3D9: :====> EXIT: DLLMAIN(053ee6e0): Process Attach: 00000d00
3328: Direct3D9: (INFO) :Direct3D9 Debug Runtime selected.
3328: Direct3D9: (WARN) :driver set D3DDEVCAPS_TEXTURENONLOCALVIDMEM w/o DDCAPS2
_NONLOCALVIDMEM:turning off D3DDEVCAPS_TEXTURENONLOCALVIDMEM
3328: D3D9 Helper: Enhanced D3DDebugging disabled; Application was not compiled
with D3D_DEBUG_INFO
3328: Direct3D9: (WARN) :driver set D3DDEVCAPS_TEXTURENONLOCALVIDMEM w/o DDCAPS2
_NONLOCALVIDMEM:turning off D3DDEVCAPS_TEXTURENONLOCALVIDMEM
3328: Direct3D9: (WARN) :driver set D3DDEVCAPS_TEXTURENONLOCALVIDMEM w/o DDCAPS2
_NONLOCALVIDMEM:turning off D3DDEVCAPS_TEXTURENONLOCALVIDMEM
3328: Direct3D9: (INFO) :======================= Hal SWVP device selected
3328:
3328: Direct3D9: (INFO) :HalDevice Driver Style 6
3328:
3328: Direct3D9: :BackBufferCount not specified, considered default 1
3328: Direct3D9: :DoneExclusiveMode
3328: Direct3D9: (WARN) :Ignoring redundant SetRenderState - 22
3328:
3328: Direct3D9: (WARN) :Ignoring redundant SetRenderState - 7
3328:
3328: Direct3D9: (WARN) :Ignoring redundant SetRenderState - 23
3328:
3328: Direct3D9: (WARN) :Ignoring redundant SetRenderState - 8
3328:
3328: Direct3D9: (WARN) :Ignoring redundant SetRenderState - 7
3328:
3328: Direct3D9: (WARN) :Ignoring redundant SetRenderState - 137
3328:
3328: Direct3D9: (WARN) :Ignoring redundant SetRenderState - 7
3328:

Comment se fait-ce ?

En fait, si je change mon code d'appel au setvalue par son équivalent avec EffectHandle:
Code:

1 2 3 4 Vector4 lLightDir = new Vector4(200.0f, 300.0f, 150.0f, 0.0f); EffectHandle hLightDir = mDOF.GetParameter(null, "lightDir"); mDOF.SetValue(hLightDir , lLightDir);
J'obtiens systématiquement (pour toutes mes variables) un handle null.
J'ai beau googler, je ne trouve rien concernant ce souci.

Une idée ?

En fait, seulement certaines variables sont "inaccessibles" , les variables concernant la lumière....

C'est quoi ce bordel ?
Pourquoi certaines et pas d'autres ?

aucune idée, par contre ça t'as permis de savoir pourquoi tout est noir.
essaye, à tout hasard d'enlever tout ce qui est inutile:
de ça:
float4 lightDir : Direction
<
> = {200.0f, 300.0f, 150.0f, 0.0f};

en seulement ça:
float4 lightDir;

Citation:

Envoyé par ShadowTzu

aucune idée, par contre ça t'as permis de savoir pourquoi tout est noir.
essaye, à tout hasard d'enlever tout ce qui est inutile:
de ça:
float4 lightDir : Direction
<
> = {200.0f, 300.0f, 150.0f, 0.0f};

en seulement ça:
float4 lightDir;

j'ai essayé, sans succès.
Et ce sont toujours les mêmes variables qui sont inaccessibles, ca ne change pas d'une execution à l'autre.

hop, problème résolu.

(PS: oui, j'ai honte).

La honte :aie:

N'oublie pas de cliquer sur :resolu: ;)

Citation:

Envoyé par Laurent Gomila

La honte :aie:

:aie:
Mais bon , j'ai beaucoup appris du coup (dbmon, debug de shader, toussa) même si ça servait à rien dans mon cas :aie:

Citation:

Envoyé par Laurent Gomila

N'oublie pas de cliquer sur :resolu: ;)

done.