2 * Copyright (C) 2010 Travis Athougies
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 #include "wine/test.h"
21 #include "d3dcompiler.h"
25 static pD3DCompile ppD3DCompile
;
33 /* Tells compute_shader_probe* which pixels should be what colors */
34 struct hlsl_probe_info
37 /* The expected values in this region */
39 /* The max error for any value */
41 /* An error message to print if this test fails */
45 static HWND
create_window(void)
48 wc
.lpfnWndProc
= DefWindowProcA
;
49 wc
.lpszClassName
= "d3d9_test_wc";
52 return CreateWindowA("d3d9_test_wc", "d3d9_test", 0, 0, 0, 0, 0, 0, 0, 0, 0);
55 static IDirect3DDevice9
*init_d3d9(IDirect3DVertexDeclaration9
**vdeclaration
,
56 IDirect3DVertexBuffer9
**quad_geometry
, IDirect3DVertexShader9
**vshader_passthru
)
58 static const struct vertex quad_vertices
[4] =
60 {-1.0f
, -1.0f
, 0.0f
, 0.0f
, 1.0f
},
61 {-1.0f
, 1.0f
, 0.0f
, 0.0f
, 0.0f
},
62 { 1.0f
, -1.0f
, 0.0f
, 1.0f
, 1.0f
},
63 { 1.0f
, 1.0f
, 0.0f
, 1.0f
, 0.0f
}
66 static const D3DVERTEXELEMENT9 vdeclelements
[] =
68 {0, 0, D3DDECLTYPE_FLOAT3
, D3DDECLMETHOD_DEFAULT
, D3DDECLUSAGE_POSITION
, 0},
69 {0, 12, D3DDECLTYPE_FLOAT2
, D3DDECLMETHOD_DEFAULT
, D3DDECLUSAGE_TEXCOORD
, 0},
73 static const char *vshader_passthru_hlsl
=
74 "float4 vshader(float4 pos: POSITION, inout float2 texcoord: TEXCOORD0): POSITION\n"
80 IDirect3DDevice9
*device_ptr
= NULL
;
81 D3DPRESENT_PARAMETERS present_parameters
;
83 void *temp_geometry_vertices
;
85 ID3D10Blob
*compiled
= NULL
;
86 ID3D10Blob
*errors
= NULL
;
90 d3d9_ptr
= Direct3DCreate9(D3D_SDK_VERSION
);
93 skip("could not create D3D9\n");
97 hr
= IDirect3D9_CheckDeviceFormat(d3d9_ptr
, D3DADAPTER_DEFAULT
, D3DDEVTYPE_HAL
, D3DFMT_X8R8G8B8
,
98 0, D3DRTYPE_SURFACE
, D3DFMT_A32B32G32R32F
);
101 skip("A32B32G32R32F format not available on this device\n");
102 IDirect3D9_Release(d3d9_ptr
);
106 ZeroMemory(&present_parameters
, sizeof(present_parameters
));
107 present_parameters
.Windowed
= TRUE
;
108 present_parameters
.hDeviceWindow
= create_window();
109 present_parameters
.SwapEffect
= D3DSWAPEFFECT_DISCARD
;
111 hr
= IDirect3D9_CreateDevice(d3d9_ptr
, D3DADAPTER_DEFAULT
, D3DDEVTYPE_HAL
, NULL
,
112 D3DCREATE_HARDWARE_VERTEXPROCESSING
, &present_parameters
, &device_ptr
);
113 IDirect3D9_Release(d3d9_ptr
);
116 skip("could not create Direct3D9 device\n");
120 /* Create the quad geometry */
121 hr
= IDirect3DDevice9_CreateVertexBuffer(device_ptr
, 4 * sizeof(struct vertex
),
122 D3DUSAGE_WRITEONLY
, 0, D3DPOOL_DEFAULT
, quad_geometry
, NULL
);
124 "Could not create vertex buffer, IDirect3DDevice9_CreateVertexBuffer returned: %08x\n", hr
);
126 hr
= IDirect3DVertexBuffer9_Lock(*quad_geometry
, 0, sizeof(quad_vertices
), &temp_geometry_vertices
, 0);
127 ok(SUCCEEDED(hr
), "IDirect3DVertexBuffer9_Lock returned: %08x\n", hr
);
128 memcpy(temp_geometry_vertices
, quad_vertices
, sizeof(quad_vertices
));
129 IDirect3DVertexBuffer9_Unlock(*quad_geometry
);
131 hr
= IDirect3DDevice9_CreateVertexDeclaration(device_ptr
, vdeclelements
, vdeclaration
);
132 ok(SUCCEEDED(hr
), "Could not create vertex declaration: "
133 "IDirect3DDevice9_CreateVertexDeclaration returned: %08x\n", hr
);
135 hr
= IDirect3DDevice9_SetVertexDeclaration(device_ptr
, *vdeclaration
);
136 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetVertexDeclaration returned: %08x\n", hr
);
138 /* Create a simple vertex shader to just pass through the values */
139 hr
= ppD3DCompile(vshader_passthru_hlsl
, strlen(vshader_passthru_hlsl
), NULL
,
140 NULL
, NULL
, "vshader", "vs_1_1", 0, 0, &compiled
, &errors
);
143 skip("not compiling vertex shader due to lacking wine HLSL support!\n");
145 ID3D10Blob_Release(errors
);
149 hr
= IDirect3DDevice9_CreateVertexShader(device_ptr
, ID3D10Blob_GetBufferPointer(compiled
),
151 ok(SUCCEEDED(hr
), "IDirect3DDevice9_CreateVertexShader returned: %08x\n", hr
);
152 ID3D10Blob_Release(compiled
);
157 /* Convenience functions */
158 static void set_float4_d3d9(IDirect3DDevice9
*device
, ID3DXConstantTable
*constants
, const char *name
,
159 float x
, float y
, float z
, float w
)
166 ID3DXConstantTable_SetVector(constants
, device
, name
, &vector
);
169 /* Compile our pixel shader and get back the compiled version and a constant table */
170 static IDirect3DPixelShader9
*compile_pixel_shader9(IDirect3DDevice9
*device
, const char *shader
,
171 const char *profile
, ID3DXConstantTable
**constants
)
173 ID3D10Blob
*compiled
= NULL
;
174 ID3D10Blob
*errors
= NULL
;
175 IDirect3DPixelShader9
*pshader
;
178 hr
= ppD3DCompile(shader
, strlen(shader
), NULL
, NULL
,
179 NULL
, "test", profile
, /* test is the name of the entry point of our shader */
180 0, 0, &compiled
, &errors
);
181 ok(hr
== D3D_OK
, "Pixel shader %s compilation failed: %s\n", shader
,
182 errors
? (char *)ID3D10Blob_GetBufferPointer(errors
) : "");
183 if (FAILED(hr
)) return NULL
;
185 hr
= D3DXGetShaderConstantTable(ID3D10Blob_GetBufferPointer(compiled
), constants
);
186 ok(hr
== D3D_OK
, "Could not get constant table from compiled pixel shader\n");
188 hr
= IDirect3DDevice9_CreatePixelShader(device
, ID3D10Blob_GetBufferPointer(compiled
), &pshader
);
189 ok(SUCCEEDED(hr
), "IDirect3DDevice9_CreatePixelShader returned: %08x\n", hr
);
190 ID3D10Blob_Release(compiled
);
194 /* Draw a full screen quad */
195 static void draw_quad_with_shader9(IDirect3DDevice9
*device
, IDirect3DVertexBuffer9
*quad_geometry
)
198 D3DXMATRIX projection_matrix
;
200 D3DXMatrixOrthoLH(&projection_matrix
, 2.0f
, 2.0f
, 0.0f
, 1.0f
);
201 IDirect3DDevice9_SetTransform(device
, D3DTS_PROJECTION
, &projection_matrix
);
203 hr
= IDirect3DDevice9_Clear(device
, 0, NULL
, D3DCLEAR_TARGET
, D3DCOLOR_XRGB(0, 0, 0), 1.0f
, 0);
204 ok(hr
== D3D_OK
, "IDirect3DDevice9_Clear returned: %08x\n", hr
);
206 hr
= IDirect3DDevice9_BeginScene(device
);
207 ok(hr
== D3D_OK
, "IDirect3DDevice9_BeginScene returned: %08x\n", hr
);
209 hr
= IDirect3DDevice9_SetStreamSource(device
, 0, quad_geometry
, 0, sizeof(struct vertex
));
210 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetStreamSource returned: %08x\n", hr
);
211 hr
= IDirect3DDevice9_DrawPrimitive(device
, D3DPT_TRIANGLESTRIP
, 0, 2);
212 ok(hr
== D3D_OK
, "IDirect3DDevice9_DrawPrimitive returned: %08x\n", hr
);
214 hr
= IDirect3DDevice9_EndScene(device
);
215 ok(hr
== D3D_OK
, "IDirect3DDevice9_EndScene returned: %08x\n", hr
);
218 static void setup_device9(IDirect3DDevice9
*device
, IDirect3DSurface9
**render_target
,
219 IDirect3DSurface9
**readback
, D3DFORMAT format
, unsigned int width
, unsigned int height
,
220 IDirect3DVertexShader9
*vshader
, IDirect3DPixelShader9
*pshader
)
223 hr
= IDirect3DDevice9_CreateRenderTarget(device
, width
, height
, format
,
224 D3DMULTISAMPLE_NONE
, 0, FALSE
, render_target
, NULL
);
225 ok(hr
== D3D_OK
, "IDirect3DDevice9_CreateRenderTarget returned: %08x\n", hr
);
227 /* The Direct3D 9 docs state that we cannot lock a render target surface,
228 instead we must copy the render target onto this surface to lock it */
229 hr
= IDirect3DDevice9_CreateOffscreenPlainSurface(device
, width
, height
, format
,
230 D3DPOOL_SYSTEMMEM
, readback
, NULL
);
231 ok(hr
== D3D_OK
, "IDirect3DDevice9_CreateOffscreenPlainSurface returned: %08x\n", hr
);
233 hr
= IDirect3DDevice9_SetRenderTarget(device
, 0, *render_target
);
234 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetRenderTarget returned: %08x\n", hr
);
236 hr
= IDirect3DDevice9_SetVertexShader(device
, vshader
);
237 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetVertexShader returned: %08x\n", hr
);
238 hr
= IDirect3DDevice9_SetPixelShader(device
, pshader
);
239 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetPixelShader returned: %08x\n", hr
);
242 static BOOL
colors_match(D3DXCOLOR a
, D3DXCOLOR b
, float epsilon
)
244 return (fabs(a
.r
- b
.r
) < epsilon
&& fabs(a
.g
- b
.g
) < epsilon
&& fabs(a
.b
- b
.b
) < epsilon
&&
245 fabs(a
.a
- b
.a
) < epsilon
);
248 /* Compute a shader on a width by height buffer and probes certain locations
249 to see if they are as expected. */
250 static void compute_shader_probe9(IDirect3DDevice9
*device
, IDirect3DVertexShader9
*vshader
,
251 IDirect3DPixelShader9
*pshader
, IDirect3DVertexBuffer9
*quad_geometry
,
252 const struct hlsl_probe_info
*probes
, unsigned int count
,
253 unsigned int width
, unsigned int height
, unsigned int line_number
)
255 IDirect3DSurface9
*render_target
;
256 IDirect3DSurface9
*readback
;
260 D3DXCOLOR
*pbits_data
;
263 setup_device9(device
, &render_target
, &readback
, D3DFMT_A32B32G32R32F
,
264 width
, height
, vshader
, pshader
);
266 /* Draw the quad with the shader and read back the data */
267 draw_quad_with_shader9(device
, quad_geometry
);
268 IDirect3DDevice9_GetRenderTargetData(device
, render_target
, readback
);
269 hr
= IDirect3DSurface9_LockRect(readback
, &lr
, NULL
, D3DLOCK_READONLY
);
270 ok(hr
== D3D_OK
, "IDirect3DSurface9_LockRect returned: %08x\n", hr
);
271 pbits_data
= lr
.pBits
;
273 /* Now go through the probes and check each one */
274 for (i
= 0; i
< count
; i
++, probes
++) {
275 int index
= probes
->x
+ (probes
->y
* lr
.Pitch
/ sizeof(D3DXCOLOR
));
276 ok(colors_match(probes
->c
, pbits_data
[index
], probes
->epsilon
),
277 "Line %d: At (%d, %d): %s: Expected (%.04f,%.04f,%.04f, %.04f), got "
278 "(%.04f,%.04f,%.04f,%.04f)\n", line_number
, probes
->x
, probes
->y
, probes
->message
,
279 probes
->c
.r
, probes
->c
.g
, probes
->c
.b
, probes
->c
.a
, pbits_data
[index
].r
,
280 pbits_data
[index
].g
, pbits_data
[index
].b
, pbits_data
[index
].a
);
283 hr
= IDirect3DSurface9_UnlockRect(readback
);
284 ok(hr
== D3D_OK
, "IDirect3DSurface9_UnlockRect returned: %08x\n", hr
);
286 /* We now present the scene. This is mostly for debugging purposes, since GetRenderTargetData
287 also waits for drawing commands to complete. The reason this call is here and not in a
288 draw function is because the contents of the render target surface are invalidated after
290 hr
= IDirect3DDevice9_Present(device
, NULL
, NULL
, NULL
, NULL
);
291 ok(hr
== D3D_OK
, "IDirect3DDevice9_Present returned: %08x\n", hr
);
293 IDirect3DSurface9_Release(render_target
);
294 IDirect3DSurface9_Release(readback
);
297 /* Now the actual test functions */
298 static void test_swizzle(IDirect3DDevice9
*device
, IDirect3DVertexBuffer9
*quad_geometry
,
299 IDirect3DVertexShader9
*vshader_passthru
)
301 static const struct hlsl_probe_info probes
[] =
303 {0, 0, {0.0101f
, 0.0303f
, 0.0202f
, 0.0404f
}, 0.0001f
, "swizzle_test"}
306 static const char *swizzle_test_shader
=
307 "uniform float4 color;\n"
308 "float4 test(): COLOR\n"
310 " float4 ret = color;\n"
311 " ret.gb = ret.ra;\n"
312 " ret.ra = float2(0.0101, 0.0404);\n"
316 ID3DXConstantTable
*constants
;
317 IDirect3DPixelShader9
*pshader
;
319 pshader
= compile_pixel_shader9(device
, swizzle_test_shader
, "ps_2_0", &constants
);
322 set_float4_d3d9(device
, constants
, "color", 0.0303f
, 0.0f
, 0.0f
, 0.0202f
);
324 compute_shader_probe9(device
, vshader_passthru
, pshader
, quad_geometry
,
325 probes
, ARRAY_SIZE(probes
), 1, 1, __LINE__
);
327 ID3DXConstantTable_Release(constants
);
328 IDirect3DPixelShader9_Release(pshader
);
332 static void test_math(IDirect3DDevice9
*device
, IDirect3DVertexBuffer9
*quad_geometry
,
333 IDirect3DVertexShader9
*vshader_passthru
)
335 /* Tests order of operations */
336 static const float u
= 2.5f
, v
= 0.3f
, w
= 0.2f
, x
= 0.7f
, y
= 0.1f
, z
= 1.5f
;
338 static const struct hlsl_probe_info probes
[] =
340 {0, 0, {-12.4300f
, 9.8333f
, 1.6000f
, 34.9999f
}, 0.0001f
,
341 "order of operations test"}
344 static const char *order_of_operations_shader
=
345 "float4 test(uniform float u, uniform float v, uniform float w, uniform float x,\n"
346 " uniform float y, uniform float z): COLOR\n"
348 " return float4(x * y - z / w + --u / -v,\n"
349 " z * x / y + w / -v,\n"
354 ID3DXConstantTable
*constants
;
355 IDirect3DPixelShader9
*pshader
;
357 pshader
= compile_pixel_shader9(device
, order_of_operations_shader
, "ps_2_0", &constants
);
360 ID3DXConstantTable_SetFloat(constants
, device
, "$u", u
);
361 ID3DXConstantTable_SetFloat(constants
, device
, "$v", v
);
362 ID3DXConstantTable_SetFloat(constants
, device
, "$w", w
);
363 ID3DXConstantTable_SetFloat(constants
, device
, "$x", x
);
364 ID3DXConstantTable_SetFloat(constants
, device
, "$y", y
);
365 ID3DXConstantTable_SetFloat(constants
, device
, "$z", z
);
367 compute_shader_probe9(device
, vshader_passthru
, pshader
, quad_geometry
,
368 probes
, ARRAY_SIZE(probes
), 1, 1, __LINE__
);
370 ID3DXConstantTable_Release(constants
);
371 IDirect3DPixelShader9_Release(pshader
);
375 static void test_conditionals(IDirect3DDevice9
*device
, IDirect3DVertexBuffer9
*quad_geometry
,
376 IDirect3DVertexShader9
*vshader_passthru
)
378 static const struct hlsl_probe_info if_greater_probes
[] =
380 { 0, 0, {0.9f
, 0.8f
, 0.7f
, 0.6f
}, 0.0001f
, "if greater test"},
381 { 5, 0, {0.9f
, 0.8f
, 0.7f
, 0.6f
}, 0.0001f
, "if greater test"},
382 {10, 0, {0.9f
, 0.8f
, 0.7f
, 0.6f
}, 0.0001f
, "if greater test"},
383 {15, 0, {0.9f
, 0.8f
, 0.7f
, 0.6f
}, 0.0001f
, "if greater test"},
384 {25, 0, {0.1f
, 0.2f
, 0.3f
, 0.4f
}, 0.0001f
, "if greater test"},
385 {30, 0, {0.1f
, 0.2f
, 0.3f
, 0.4f
}, 0.0001f
, "if greater test"}
388 static const char *if_greater_shader
=
389 "float4 test(float2 pos: TEXCOORD0): COLOR\n"
391 " if((pos.x * 32.0) > 20.0)\n"
392 " return float4(0.1, 0.2, 0.3, 0.4);\n"
394 " return float4(0.9, 0.8, 0.7, 0.6);\n"
397 static const struct hlsl_probe_info ternary_operator_probes
[] =
399 {0, 0, {0.50f
, 0.25f
, 0.50f
, 0.75f
}, 0.00001f
, "ternary operator test"},
400 {1, 0, {0.50f
, 0.25f
, 0.50f
, 0.75f
}, 0.00001f
, "ternary operator test"},
401 {2, 0, {0.50f
, 0.25f
, 0.50f
, 0.75f
}, 0.00001f
, "ternary operator test"},
402 {3, 0, {0.50f
, 0.25f
, 0.50f
, 0.75f
}, 0.00001f
, "ternary operator test"},
403 {4, 0, {0.60f
, 0.80f
, 0.10f
, 0.20f
}, 0.00001f
, "ternary operator test"},
404 {5, 0, {0.60f
, 0.80f
, 0.10f
, 0.20f
}, 0.00001f
, "ternary operator test"},
405 {6, 0, {0.60f
, 0.80f
, 0.10f
, 0.20f
}, 0.00001f
, "ternary operator test"},
406 {7, 0, {0.60f
, 0.80f
, 0.10f
, 0.20f
}, 0.00001f
, "ternary operator test"}
409 static const char *ternary_operator_shader
=
410 "float4 test(float2 pos: TEXCOORD0): COLOR\n"
412 " return (pos.x < 0.5?float4(0.5, 0.25, 0.5, 0.75):float4(0.6, 0.8, 0.1, 0.2));\n"
415 ID3DXConstantTable
*constants
;
416 IDirect3DPixelShader9
*pshader
;
418 pshader
= compile_pixel_shader9(device
, if_greater_shader
, "ps_2_0", &constants
);
421 compute_shader_probe9(device
, vshader_passthru
, pshader
, quad_geometry
, if_greater_probes
,
422 ARRAY_SIZE(if_greater_probes
), 32, 1, __LINE__
);
424 ID3DXConstantTable_Release(constants
);
425 IDirect3DPixelShader9_Release(pshader
);
428 pshader
= compile_pixel_shader9(device
, ternary_operator_shader
, "ps_2_0", &constants
);
431 compute_shader_probe9(device
, vshader_passthru
, pshader
, quad_geometry
, ternary_operator_probes
,
432 ARRAY_SIZE(ternary_operator_probes
), 8, 1, __LINE__
);
434 ID3DXConstantTable_Release(constants
);
435 IDirect3DPixelShader9_Release(pshader
);
439 static void test_float_vectors(IDirect3DDevice9
*device
, IDirect3DVertexBuffer9
*quad_geometry
,
440 IDirect3DVertexShader9
*vshader_passthru
)
442 static const struct hlsl_probe_info vec4_indexing_test1_probes
[] =
444 {0, 0, {0.020f
, 0.245f
, 0.351f
, 1.000f
}, 0.0001f
, "vec4 indexing test 1"}
447 static const char *vec4_indexing_test1_shader
=
448 "float4 test(): COLOR\n"
451 " color[0] = 0.020;\n"
452 " color[1] = 0.245;\n"
453 " color[2] = 0.351;\n"
458 static const struct hlsl_probe_info vec4_indexing_test2_probes
[] =
460 {0, 0, {0.5f
, 0.3f
, 0.8f
, 0.2f
}, 0.0001f
, "vec4 indexing test 2"}
463 /* We have this uniform i here so the compiler can't optimize */
464 static const char *vec4_indexing_test2_shader
=
466 "float4 test(): COLOR\n"
468 " float4 color = float4(0.5, 0.4, 0.3, 0.2);\n"
469 " color.g = color[i];\n"
474 ID3DXConstantTable
*constants
;
475 IDirect3DPixelShader9
*pshader
;
477 pshader
= compile_pixel_shader9(device
, vec4_indexing_test1_shader
, "ps_2_0", &constants
);
480 compute_shader_probe9(device
, vshader_passthru
, pshader
, quad_geometry
, vec4_indexing_test1_probes
,
481 ARRAY_SIZE(vec4_indexing_test1_probes
), 1, 1, __LINE__
);
483 ID3DXConstantTable_Release(constants
);
484 IDirect3DPixelShader9_Release(pshader
);
487 pshader
= compile_pixel_shader9(device
, vec4_indexing_test2_shader
, "ps_2_0", &constants
);
490 ID3DXConstantTable_SetInt(constants
, device
, "i", 2);
492 compute_shader_probe9(device
, vshader_passthru
, pshader
, quad_geometry
, vec4_indexing_test2_probes
,
493 ARRAY_SIZE(vec4_indexing_test2_probes
), 32, 1, __LINE__
);
495 ID3DXConstantTable_Release(constants
);
496 IDirect3DPixelShader9_Release(pshader
);
500 static void test_trig(IDirect3DDevice9
*device
, IDirect3DVertexBuffer9
*quad_geometry
,
501 IDirect3DVertexShader9
*vshader_passthru
)
503 static const struct hlsl_probe_info sincos_probes
[] =
505 {0, 0, {0.5000f
, 1.0000f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
506 {1, 0, {0.5975f
, 0.9904f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
507 {2, 0, {0.6913f
, 0.9620f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
508 {3, 0, {0.7778f
, 0.9160f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
509 {4, 0, {0.8536f
, 0.8536f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
510 {5, 0, {0.9157f
, 0.7778f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
511 {6, 0, {0.9620f
, 0.6913f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
512 {7, 0, {0.9904f
, 0.5975f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
513 {8, 0, {1.0000f
, 0.5000f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
514 {9, 0, {0.9904f
, 0.4025f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
515 {10, 0, {0.9619f
, 0.3087f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
516 {11, 0, {0.9157f
, 0.2222f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
517 {12, 0, {0.8536f
, 0.1464f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
518 {13, 0, {0.7778f
, 0.0843f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
519 {14, 0, {0.6913f
, 0.0381f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
520 {15, 0, {0.5975f
, 0.0096f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
521 {16, 0, {0.5000f
, 0.0000f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
522 {17, 0, {0.4025f
, 0.0096f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
523 {18, 0, {0.3087f
, 0.0381f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
524 {19, 0, {0.2222f
, 0.0843f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
525 {20, 0, {0.1464f
, 0.1464f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
526 {21, 0, {0.0843f
, 0.2222f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
527 {22, 0, {0.0381f
, 0.3087f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
528 {23, 0, {0.0096f
, 0.4025f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
529 {24, 0, {0.0000f
, 0.5000f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
530 {25, 0, {0.0096f
, 0.5975f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
531 {26, 0, {0.0381f
, 0.6913f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
532 {27, 0, {0.0843f
, 0.7778f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
533 {28, 0, {0.1464f
, 0.8536f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
534 {29, 0, {0.2222f
, 0.9157f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
535 {30, 0, {0.3087f
, 0.9619f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
536 {31, 0, {0.4025f
, 0.9904f
, 0.0f
, 0.0f
}, 0.001f
, "sin/cos test"},
539 static const char *sincos_shader
=
540 "float4 test(float x: TEXCOORD0): COLOR\n"
542 " const float pi2 = 6.2831853;\n"
543 " float calcd_sin = (sin(x * pi2) + 1)/2;\n"
544 " float calcd_cos = (cos(x * pi2) + 1)/2;\n"
545 " return float4(calcd_sin, calcd_cos, 0, 0);\n"
548 ID3DXConstantTable
*constants
;
549 IDirect3DPixelShader9
*pshader
;
551 pshader
= compile_pixel_shader9(device
, sincos_shader
, "ps_2_0", &constants
);
554 compute_shader_probe9(device
, vshader_passthru
, pshader
, quad_geometry
, sincos_probes
,
555 ARRAY_SIZE(sincos_probes
), 32, 1, __LINE__
);
557 ID3DXConstantTable_Release(constants
);
558 IDirect3DPixelShader9_Release(pshader
);
562 static void test_fail(IDirect3DDevice9
*device
, IDirect3DVertexBuffer9
*qquad_geometry
,
563 IDirect3DVertexShader9
*vshader_passthru
)
565 static const char *tests
[] =
567 "float4 test(float2 pos: TEXCOORD0) : COLOR\n"
572 "float4 test(float2 pos: TEXCOORD0) : COLOR\n"
574 " float4 x = float4(0, 0, 0, 0);\n"
575 " x.xzzx = float4(1, 2, 3, 4);\n"
579 "float4 test(float2 pos: TEXCOORD0) : COLOR\n"
585 "float4 test(float2 pos, TEXCOORD0) ; COLOR\n"
588 " mul(float4(5, 4, 3, 2), mvp) = x;\n"
592 "float4 563r(float2 45s: TEXCOORD0) : COLOR\n"
595 " return float4(x.x, x.y, 0, 0);\n"
598 "float4 test(float2 pos: TEXCOORD0) : COLOR\n"
600 " struct { int b,c; } x = {0};\n"
604 "float4 test(float2 pos: TEXCOORD0) : COLOR\n"
606 " struct {} x = {};\n"
611 ID3D10Blob
*compiled
, *errors
;
615 for (i
= 0; i
< ARRAY_SIZE(tests
); ++i
)
617 compiled
= errors
= NULL
;
618 hr
= ppD3DCompile(tests
[i
], strlen(tests
[i
]), NULL
, NULL
, NULL
, "test", "ps_2_0", 0, 0, &compiled
, &errors
);
619 ok(hr
== E_FAIL
, "Test %u, got unexpected hr %#x.\n", i
, hr
);
620 ok(!!errors
, "Test %u, expected non-NULL error blob.\n", i
);
621 ok(!compiled
, "Test %u, expected no compiled shader blob.\n", i
);
622 ID3D10Blob_Release(errors
);
626 static BOOL
load_d3dcompiler(void)
630 if (!(module
= LoadLibraryA("d3dcompiler_43.dll"))) return FALSE
;
632 ppD3DCompile
= (void*)GetProcAddress(module
, "D3DCompile");
640 IDirect3DDevice9
*device
;
641 IDirect3DVertexDeclaration9
*vdeclaration
;
642 IDirect3DVertexBuffer9
*quad_geometry
;
643 IDirect3DVertexShader9
*vshader_passthru
;
645 if (!load_d3dcompiler())
647 win_skip("Could not load d3dcompiler_43.dll\n");
651 device
= init_d3d9(&vdeclaration
, &quad_geometry
, &vshader_passthru
);
654 /* Make sure we support pixel shaders, before trying to compile them! */
655 /* Direct3D 9 (Shader model 1-3 tests) */
656 IDirect3DDevice9_GetDeviceCaps(device
, &caps
);
657 if (caps
.PixelShaderVersion
>= D3DPS_VERSION(2, 0))
661 test_swizzle(device
, quad_geometry
, vshader_passthru
);
662 test_math(device
, quad_geometry
, vshader_passthru
);
663 test_conditionals(device
, quad_geometry
, vshader_passthru
);
664 test_float_vectors(device
, quad_geometry
, vshader_passthru
);
665 test_trig(device
, quad_geometry
, vshader_passthru
);
666 test_fail(device
, quad_geometry
, vshader_passthru
);
668 } else skip("no pixel shader support\n");
670 /* Reference counting sanity checks */
671 if (vshader_passthru
)
673 refcount
= IDirect3DVertexShader9_Release(vshader_passthru
);
674 ok(!refcount
, "Pass-through vertex shader has %u references left\n", refcount
);
677 refcount
= IDirect3DVertexBuffer9_Release(quad_geometry
);
678 ok(!refcount
, "Vertex buffer has %u references left\n", refcount
);
680 refcount
= IDirect3DVertexDeclaration9_Release(vdeclaration
);
681 ok(!refcount
, "Vertex declaration has %u references left\n", refcount
);
683 refcount
= IDirect3DDevice9_Release(device
);
684 ok(!refcount
, "Device has %u references left\n", refcount
);