2 * Copyright (C) 2008 Stefan Dösinger
3 * Copyright (C) 2009 Matteo Bruni
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 #include "wine/test.h"
24 #include "resources.h"
28 const DWORD bytes
[128];
31 static HRESULT
create_file(const char *filename
, const char *data
, const unsigned int size
)
36 hfile
= CreateFileA(filename
, GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, 0);
37 if(hfile
== INVALID_HANDLE_VALUE
) return HRESULT_FROM_WIN32(GetLastError());
39 if(WriteFile(hfile
, data
, size
, &received
, NULL
))
46 return D3DERR_INVALIDCALL
;
49 static void dump_shader(DWORD
*shader
) {
50 unsigned int i
= 0, j
= 0;
52 trace("0x%08x ", shader
[i
]);
55 if(j
== 6) trace("\n");
56 } while(shader
[i
- 1] != D3DSIO_END
);
57 if(j
!= 6) trace("\n");
60 static void exec_tests(const char *name
, struct shader_test tests
[], unsigned int count
) {
65 LPD3DXBUFFER shader
, messages
;
67 for(i
= 0; i
< count
; i
++) {
68 /* D3DXAssembleShader sets messages to 0 if there aren't error messages */
70 hr
= D3DXAssembleShader(tests
[i
].text
, strlen(tests
[i
].text
),
71 NULL
, NULL
, D3DXSHADER_SKIPVALIDATION
,
73 ok(hr
== D3D_OK
, "Test %s, shader %d: D3DXAssembleShader failed with error 0x%x - %d\n", name
, i
, hr
, hr
& 0x0000FFFF);
75 trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages
));
76 ID3DXBuffer_Release(messages
);
78 if(FAILED(hr
)) continue;
82 res
= ID3DXBuffer_GetBufferPointer(shader
);
83 while(res
[j
] != D3DSIO_END
&& tests
[i
].bytes
[j
] != D3DSIO_END
) {
84 if(res
[j
] != tests
[i
].bytes
[j
]) diff
= TRUE
;
87 /* Both must have an end token */
88 if(res
[j
] != tests
[i
].bytes
[j
]) diff
= TRUE
;
91 ok(FALSE
, "Test %s, shader %d: Generated code differs\n", name
, i
);
94 ID3DXBuffer_Release(shader
);
98 static void preproc_test(void) {
99 struct shader_test tests
[] = {
102 "//some comments\r\n"
104 "; yet another comment\r\n"
106 {0xfffe0101, 0x00000002, 0x800f0000, 0x80e40000, 0x80e40001, 0x0000ffff}
109 "#line 1 \"vertex.vsh\"\n"
111 {0xfffe0101, 0x0000ffff}
114 "#define REG 1 + 2 +\\\n"
117 "mov r0, c0[ REG ]\n",
118 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e4000a, 0x0000ffff}
122 exec_tests("preproc", tests
, sizeof(tests
) / sizeof(tests
[0]));
125 static void ps_1_1_test(void) {
126 struct shader_test tests
[] = {
130 "add r0.rgb, r0, r1\r\n"
132 {0xffff0101, 0x00000042, 0xb00f0000, 0x00000002, 0x80070000, 0x80e40000,
133 0x80e40001, 0x40000001, 0x80080000, 0xb0e40000, 0x0000ffff}
138 {0xffff0101, 0x00000001, 0x8e0f0000, 0x80e40001, 0x0000ffff}
142 exec_tests("ps_1_1", tests
, sizeof(tests
) / sizeof(tests
[0]));
145 static void vs_1_1_test(void) {
146 struct shader_test tests
[] = {
147 /* Basic instruction tests */
151 {0xfffe0101, 0x00000002, 0x800f0000, 0x80e40001, 0x80e40002, 0x0000ffff}
156 {0xfffe0101, 0x00000000, 0x0000ffff}
158 /* Output register tests */
162 {0xfffe0101, 0x00000001, 0xc00f0000, 0xa0e40000, 0x0000ffff}
167 {0xfffe0101, 0x00000001, 0xe00f0000, 0xa0e40000, 0x0000ffff}
172 {0xfffe0101, 0x00000001, 0xe00f0005, 0xa0e40000, 0x0000ffff}
177 {0xfffe0101, 0x00000001, 0xd00f0000, 0xa0e40000, 0x0000ffff}
182 {0xfffe0101, 0x00000001, 0xd00f0001, 0xa0e40000, 0x0000ffff}
187 {0xfffe0101, 0x00000001, 0xc00f0001, 0xa0000000, 0x0000ffff}
192 {0xfffe0101, 0x00000001, 0xc00f0002, 0xa0000000, 0x0000ffff}
194 /* A bunch of tests for declarations */
198 {0xfffe0101, 0x0000001f, 0x80000000, 0x900f0000, 0x0000ffff}
203 {0xfffe0101, 0x0000001f, 0x80000000, 0x900f0001, 0x0000ffff}
208 {0xfffe0101, 0x0000001f, 0x800c0003, 0x900f000f, 0x0000ffff}
213 {0xfffe0101, 0x00000002, 0x800f0000, 0x90e40000, 0x90e40001, 0x0000ffff}
217 "def c12, 0, -1, -0.5, 1024\n",
218 {0xfffe0101, 0x00000051, 0xa00f000c, 0x00000000, 0xbf800000, 0xbf000000,
219 0x44800000, 0x0000ffff}
221 { /* shader 14: writemasks, swizzles */
223 "dp4 r0.xw, r1.wzyx, r2.xxww\n",
224 {0xfffe0101, 0x00000009, 0x80090000, 0x801b0001, 0x80f00002, 0x0000ffff}
226 { /* shader 15: negation input modifier. Other modifiers not supprted in vs_1_1 */
228 "add r0, -r0.x, -r1\n",
229 {0xfffe0101, 0x00000002, 0x800f0000, 0x81000000, 0x81e40001, 0x0000ffff}
231 { /* shader 16: relative addressing */
233 "mov r0, c0[a0.x]\n",
234 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e42000, 0x0000ffff}
236 { /* shader 17: relative addressing */
238 "mov r0, c1[a0.x + 2]\n",
239 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e42003, 0x0000ffff}
243 "def c0, 1.0f, 1.0f, 1.0f, 0.5f\n",
244 {0xfffe0101, 0x00000051, 0xa00f0000, 0x3f800000, 0x3f800000, 0x3f800000,
245 0x3f000000, 0x0000ffff}
247 /* Other relative addressing tests */
250 "mov r0, c[ a0.x + 12 ]\n",
251 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e4200c, 0x0000ffff}
255 "mov r0, c[ 2 + a0.x ]\n",
256 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e42002, 0x0000ffff}
260 "mov r0, c[ 2 + a0.x + 12 ]\n",
261 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e4200e, 0x0000ffff}
265 "mov r0, c[ 2 + 10 + 12 ]\n",
266 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e40018, 0x0000ffff}
271 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e40006, 0x0000ffff}
276 {0xfffe0101, 0x00000006, 0x800f0000, 0x90000000, 0x0000ffff}
281 {0xfffe0101, 0x00000007, 0x800f0000, 0x90000000, 0x0000ffff}
285 exec_tests("vs_1_1", tests
, sizeof(tests
) / sizeof(tests
[0]));
288 static void ps_1_3_test(void) {
289 struct shader_test tests
[] = {
290 /* Basic instruction tests */
294 {0xffff0103, 0x00000001, 0x800f0000, 0x80e40001, 0x0000ffff}
299 {0xffff0103, 0x00000002, 0x800f0000, 0x80e40001, 0x80e40000, 0x0000ffff}
301 /* Color interpolator tests */
305 {0xffff0103, 0x00000001, 0x800f0000, 0x90e40000, 0x0000ffff}
310 {0xffff0103, 0x00000001, 0x800f0000, 0x90e40001, 0x0000ffff}
312 /* Texture sampling instructions */
316 {0xffff0103, 0x00000042, 0xb00f0000, 0x0000ffff}
321 "texreg2ar t1, t0\n",
322 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000045, 0xb00f0001, 0xb0e40000,
328 "texreg2gb t1, t0\n",
329 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000046, 0xb00f0001, 0xb0e40000,
335 "texreg2rgb t1, t0\n",
336 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000052, 0xb00f0001, 0xb0e40000,
341 "cnd r0, r1, r0, v0\n",
342 {0xffff0103, 0x00000050, 0x800f0000, 0x80e40001, 0x80e40000, 0x90e40000,
347 "cmp r0, r1, r0, v0\n",
348 {0xffff0103, 0x00000058, 0x800f0000, 0x80e40001, 0x80e40000, 0x90e40000,
354 {0xffff0103, 0x00000041, 0xb00f0000, 0x0000ffff}
359 "texm3x2pad t1, t0\n"
360 "texm3x2tex t2, t0\n",
361 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000047, 0xb00f0001, 0xb0e40000,
362 0x00000048, 0xb00f0002, 0xb0e40000, 0x0000ffff}
367 "texm3x2pad t1, t0\n"
368 "texm3x2depth t2, t0\n",
369 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000047, 0xb00f0001, 0xb0e40000,
370 0x00000054, 0xb00f0002, 0xb0e40000, 0x0000ffff}
376 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000043, 0xb00f0001, 0xb0e40000,
383 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000044, 0xb00f0001, 0xb0e40000,
389 "texdp3tex t1, t0\n",
390 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000053, 0xb00f0001, 0xb0e40000,
397 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000055, 0xb00f0001, 0xb0e40000,
403 "texm3x3pad t1, t0\n"
404 "texm3x3pad t2, t0\n"
405 "texm3x3tex t3, t0\n",
406 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb00f0001, 0xb0e40000,
407 0x00000049, 0xb00f0002, 0xb0e40000, 0x0000004a, 0xb00f0003, 0xb0e40000,
413 "texm3x3pad t1, t0\n"
414 "texm3x3pad t2, t0\n"
416 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb00f0001, 0xb0e40000,
417 0x00000049, 0xb00f0002, 0xb0e40000, 0x00000056, 0xb00f0003, 0xb0e40000,
423 "texm3x3pad t1, t0\n"
424 "texm3x3pad t2, t0\n"
425 "texm3x3spec t3, t0, c0\n",
426 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb00f0001, 0xb0e40000,
427 0x00000049, 0xb00f0002, 0xb0e40000, 0x0000004c, 0xb00f0003, 0xb0e40000,
428 0xa0e40000, 0x0000ffff}
433 "texm3x3pad t1, t0\n"
434 "texm3x3pad t2, t0\n"
435 "texm3x3vspec t3, t0\n",
436 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb00f0001, 0xb0e40000,
437 0x00000049, 0xb00f0002, 0xb0e40000, 0x0000004d, 0xb00f0003, 0xb0e40000,
443 {0xffff0103, 0x00000040, 0xb00f0000, 0x0000ffff}
445 /* Modifiers, shifts */
448 "mov_x2_sat r0, 1 - r1\n",
449 {0xffff0103, 0x00000001, 0x811f0000, 0x86e40001, 0x0000ffff}
454 {0xffff0103, 0x00000001, 0x8d0f0000, 0x81e40001, 0x0000ffff}
458 "mov_sat r0, r1_bx2\n",
459 {0xffff0103, 0x00000001, 0x801f0000, 0x84e40001, 0x0000ffff}
463 "mov_sat r0, r1_bias\n",
464 {0xffff0103, 0x00000001, 0x801f0000, 0x82e40001, 0x0000ffff}
468 "mov_sat r0, -r1_bias\n",
469 {0xffff0103, 0x00000001, 0x801f0000, 0x83e40001, 0x0000ffff}
473 "mov_sat r0, -r1_bx2\n",
474 {0xffff0103, 0x00000001, 0x801f0000, 0x85e40001, 0x0000ffff}
478 "mov_sat r0, -r1_x2\n",
479 {0xffff0103, 0x00000001, 0x801f0000, 0x88e40001, 0x0000ffff}
483 "mov_x4_sat r0.a, -r1_bx2.a\n",
484 {0xffff0103, 0x00000001, 0x82180000, 0x85ff0001, 0x0000ffff}
489 {0xffff0103, 0x00000040, 0xb10f0000, 0x0000ffff}
494 {0xffff0103, 0x00000042, 0xb10f0000, 0x0000ffff}
498 "texreg2ar_x4 t0, t1\n",
499 {0xffff0103, 0x00000045, 0xb20f0000, 0xb0e40001, 0x0000ffff}
503 "texbem_d4 t1, t0\n",
504 {0xffff0103, 0x00000043, 0xbe0f0001, 0xb0e40000, 0x0000ffff}
509 "texm3x3pad_x2 t1, t0\n"
510 "texm3x3pad_x2 t2, t0\n"
511 "texm3x3tex_x2 t3, t0\n",
512 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb10f0001, 0xb0e40000,
513 0x00000049, 0xb10f0002, 0xb0e40000, 0x0000004a, 0xb10f0003, 0xb0e40000,
519 "texdp3tex_x8 t1, t0\n",
520 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000053, 0xb30f0001, 0xb0e40000,
525 exec_tests("ps_1_3", tests
, sizeof(tests
) / sizeof(tests
[0]));
528 static void ps_1_4_test(void) {
529 struct shader_test tests
[] = {
530 /* Basic instruction tests */
534 {0xffff0104, 0x00000001, 0x800f0000, 0x80e40001, 0x0000ffff}
539 {0xffff0104, 0x00000001, 0x800f0000, 0x80e40005, 0x0000ffff}
544 {0xffff0104, 0x00000001, 0x800f0000, 0xa0e40007, 0x0000ffff}
549 {0xffff0104, 0x00000001, 0x800f0000, 0x90e40001, 0x0000ffff}
554 {0xffff0104, 0x0000fffd, 0x0000ffff}
559 {0xffff0104, 0x00000040, 0x800f0000, 0xb0e40000, 0x0000ffff}
564 {0xffff0104, 0x00000040, 0x800f0004, 0xb0e40003, 0x0000ffff}
568 "texcrd_sat r4, t3\n",
569 {0xffff0104, 0x00000040, 0x801f0004, 0xb0e40003, 0x0000ffff}
574 {0xffff0104, 0x00000042, 0x800f0000, 0xb0e40000, 0x0000ffff}
579 {0xffff0104, 0x00000042, 0x800f0001, 0xb0e40004, 0x0000ffff}
584 {0xffff0104, 0x00000042, 0x800f0005, 0x80e40000, 0x0000ffff}
588 "texld r5, c0\n", /* Assembly succeeds, validation fails */
589 {0xffff0104, 0x00000042, 0x800f0005, 0xa0e40000, 0x0000ffff}
594 {0xffff0104, 0x00000042, 0x800f0005, 0x89e40002, 0x0000ffff}
598 "bem r1.rg, c0, r0\n",
599 {0xffff0104, 0x00000059, 0x80030001, 0xa0e40000, 0x80e40000, 0x0000ffff}
604 {0xffff0104, 0x00000057, 0x800f0005, 0x0000ffff}
608 "add r0, r1, r2_bx2\n",
609 {0xffff0104, 0x00000002, 0x800f0000, 0x80e40001, 0x84e40002, 0x0000ffff}
613 "add_x4 r0, r1, r2\n",
614 {0xffff0104, 0x00000002, 0x820f0000, 0x80e40001, 0x80e40002, 0x0000ffff}
618 "add r0.rgb, r1, r2\n"
619 "+add r0.a, r1, r2\n",
620 {0xffff0104, 0x00000002, 0x80070000, 0x80e40001, 0x80e40002, 0x40000002,
621 0x80080000, 0x80e40001, 0x80e40002, 0x0000ffff}
626 {0xffff0104, 0x00000057, 0x810f0005, 0x0000ffff}
630 "bem_d2 r1, c0, r0\n",
631 {0xffff0104, 0x00000059, 0x8f0f0001, 0xa0e40000, 0x80e40000, 0x0000ffff}
636 {0xffff0104, 0x00000041, 0xb00f0000, 0x0000ffff}
641 {0xffff0104, 0x00000041, 0x800f0000, 0x0000ffff}
645 exec_tests("ps_1_4", tests
, sizeof(tests
) / sizeof(tests
[0]));
648 static void vs_2_0_test(void) {
649 struct shader_test tests
[] = {
650 /* Basic instruction tests */
654 {0xfffe0200, 0x02000001, 0x800f0000, 0x80e40001, 0x0000ffff}
658 "lrp r0, v0, c0, r1\n",
659 {0xfffe0200, 0x04000012, 0x800f0000, 0x90e40000, 0xa0e40000, 0x80e40001,
664 "dp4 oPos, v0, c0\n",
665 {0xfffe0200, 0x03000009, 0xc00f0000, 0x90e40000, 0xa0e40000, 0x0000ffff}
669 "mov r0, c0[a0.x]\n",
670 {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0000000, 0x0000ffff}
674 "mov r0, c0[a0.y]\n",
675 {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0550000, 0x0000ffff}
679 "mov r0, c0[a0.z]\n",
680 {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0aa0000, 0x0000ffff}
684 "mov r0, c0[a0.w]\n",
685 {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0ff0000, 0x0000ffff}
689 "mov r0, c0[a0.w].x\n",
690 {0xfffe0200, 0x03000001, 0x800f0000, 0xa0002000, 0xb0ff0000, 0x0000ffff}
694 "mov r0, -c0[a0.w+5].x\n",
695 {0xfffe0200, 0x03000001, 0x800f0000, 0xa1002005, 0xb0ff0000, 0x0000ffff}
700 {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0e40000, 0x0000ffff}
704 "mov r0, c0[a0.xyww]\n",
705 {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0f40000, 0x0000ffff}
709 "add r0, c0[a0.x], c1[a0.y]\n", /* validation would fail on this line */
710 {0xfffe0200, 0x05000002, 0x800f0000, 0xa0e42000, 0xb0000000, 0xa0e42001,
711 0xb0550000, 0x0000ffff}
717 {0xfffe0200, 0x01000026, 0xf0e40000, 0x00000027, 0x0000ffff}
724 {0xfffe0200, 0x01000028, 0xe0e40800, 0x0000002a, 0x0000002b, 0x0000ffff}
730 {0xfffe0200, 0x0200001b, 0xf0e40800, 0xf0e40000, 0x0000001d, 0x0000ffff}
735 {0xfffe0200, 0x02000024, 0x800f0000, 0xa0e40000, 0x0000ffff}
740 {0xfffe0200, 0x03000021, 0x800f0000, 0x80e40001, 0x80e40002, 0x0000ffff}
744 "sgn r0, r1, r2, r3\n",
745 {0xfffe0200, 0x04000022, 0x800f0000, 0x80e40001, 0x80e40002, 0x80e40003,
750 "sincos r0, r1, r2, r3\n",
751 {0xfffe0200, 0x04000025, 0x800f0000, 0x80e40001, 0x80e40002, 0x80e40003,
757 {0xfffe0200, 0x03000020, 0x800f0000, 0x80e40001, 0x80e40002, 0x0000ffff}
762 {0xfffe0200, 0x0200002e, 0xb0020000, 0xa0aa0000, 0x0000ffff}
768 {0xfffe0200, 0x0200002f, 0xe00f0800, 0x00000001, 0x0200002f, 0xe00f0801,
769 0x00000000, 0x0000ffff}
773 "defi i0, -1, 1, 10, 0\n"
774 "defi i1, 0, 40, 30, 10\n",
775 {0xfffe0200, 0x05000030, 0xf00f0000, 0xffffffff, 0x00000001, 0x0000000a,
776 0x00000000, 0x05000030, 0xf00f0001, 0x00000000, 0x00000028, 0x0000001e,
777 0x0000000a, 0x0000ffff}
784 {0xfffe0200, 0x0200001b, 0xf0e40800, 0xf0e40000, 0x03000001, 0x800f0000,
785 0xa0e42000, 0xf0e40800, 0x0000001d, 0x0000ffff}
793 {0xfffe0200, 0x01000019, 0xa0e41000, 0x0000001c, 0x0100001e, 0xa0e41000,
794 0x0000001c, 0x0000ffff}
802 {0xfffe0200, 0x0200001a, 0xa0e41000, 0xe0e40800, 0x0000001c, 0x0100001e,
803 0xa0e41000, 0x0000001c, 0x0000ffff}
811 {0xfffe0200, 0x0200001a, 0xa0e41000, 0xede40800, 0x0000001c, 0x0100001e,
812 0xa0e41000, 0x0000001c, 0x0000ffff}
819 {0xfffe0200, 0x01000028, 0xede40800, 0x0000002a, 0x0000002b, 0x0000ffff}
827 {0xfffe0200, 0x01000019, 0xa0e41003, 0x0000001c, 0x0100001e, 0xa0e41003, 0x0000001c, 0x0000ffff}
829 { /* shader 29: labels up to 2047 are accepted even in vs_2_0 */
832 {0xfffe0200, 0x01000019, 0xa0e417ff, 0x0000ffff}
836 exec_tests("vs_2_0", tests
, sizeof(tests
) / sizeof(tests
[0]));
839 static void vs_2_x_test(void) {
840 struct shader_test tests
[] = {
846 {0xfffe0201, 0x01000026, 0xf0e40000, 0x0000002c, 0x00000027, 0x0000ffff}
852 {0xfffe0201, 0x02030029, 0x80e40000, 0x80e40001, 0x0000002b, 0x0000ffff}
859 {0xfffe0201, 0x01000026, 0xf0e40000, 0x0205002d, 0x80e40000, 0x80e40001,
860 0x00000027, 0x0000ffff}
866 "setp_gt p0, r0, r1\n"
867 "(!p0) add r2, r2, r3\n",
868 {0xfffe0201, 0x0301005e, 0xb00f1000, 0x80e40000, 0x80e40001, 0x14000002,
869 0x800f0002, 0xbde41000, 0x80e40002, 0x80e40003, 0x0000ffff}
876 {0xfffe0201, 0x01000028, 0xb0001000, 0x0000002a, 0x0000002b, 0x0000ffff}
884 {0xfffe0201, 0x0200001a, 0xa0e41000, 0xbdaa1000, 0x0000001c,
885 0x0100001e, 0xa0e41000, 0x0000001c, 0x0000ffff}
892 {0xfffe0201, 0x01000026, 0xf0e40000, 0x01000060, 0xb0ff1000,
893 0x00000027, 0x0000ffff}
897 exec_tests("vs_2_x", tests
, sizeof(tests
) / sizeof(tests
[0]));
900 static void ps_2_0_test(void) {
901 struct shader_test tests
[] = {
905 {0xffff0200, 0x0200001f, 0x90000000, 0xa00f0800, 0x0000ffff}
910 {0xffff0200, 0x0200001f, 0x98000000, 0xa00f0800, 0x0000ffff}
915 {0xffff0200, 0x0200001f, 0xa0000000, 0xa00f0800, 0x0000ffff}
922 {0xffff0200, 0x0200001f, 0xa0000000, 0xa00f0800, 0x0200001f, 0x98000000,
923 0xa00f0801, 0x0200001f, 0x90000000, 0xa00f0802, 0x0000ffff}
928 {0xffff0200, 0x02000001, 0x800f0000, 0xb0e40000, 0x0000ffff}
933 "texld r0, t1, s2\n",
934 {0xffff0200, 0x0200001f, 0x90000000, 0xa00f0802, 0x03000042, 0x800f0000,
935 0xb0e40001, 0xa0e40802, 0x0000ffff}
940 {0xffff0200, 0x01000041, 0xb00f0000, 0x0000ffff}
946 {0xffff0200, 0x02000001, 0x800f0800, 0xa0e40000, 0x02000001, 0x800f0801,
947 0xa0e40001, 0x0000ffff}
951 "mov oDepth, c0.x\n",
952 {0xffff0200, 0x02000001, 0x900f0800, 0xa0000000, 0x0000ffff}
957 "texldp r0, t1, s2\n",
958 {0xffff0200, 0x0200001f, 0x90000000, 0xa00f0802, 0x03010042, 0x800f0000,
959 0xb0e40001, 0xa0e40802, 0x0000ffff}
964 "texldb r0, t1, s2\n",
965 {0xffff0200, 0x0200001f, 0x90000000, 0xa00f0802, 0x03020042, 0x800f0000,
966 0xb0e40001, 0xa0e40802, 0x0000ffff}
971 {0xffff0200, 0x0200001f, 0x80000000, 0x900f0000, 0x0000ffff}
977 {0xffff0200, 0x0200001f, 0x80000000, 0xb0070000, 0x0200001f, 0x80000000, 0xb00f0001, 0x0000ffff}
982 {0xffff0200, 0x0200001f, 0x80000000, 0xb02f0000, 0x0000ffff}
986 exec_tests("ps_2_0", tests
, sizeof(tests
) / sizeof(tests
[0]));
989 static void ps_2_x_test(void) {
990 struct shader_test tests
[] = {
991 /* defb and defi are not supposed to work in ps_2_0 (even if defb actually works in ps_2_0 with native) */
996 {0xffff0201, 0x0200002f, 0xe00f0800, 0x00000001, 0x0200002f, 0xe00f0801,
997 0x00000000, 0x0000ffff}
1001 "defi i0, -1, 1, 10, 0\n"
1002 "defi i1, 0, 40, 30, 10\n",
1003 {0xffff0201, 0x05000030, 0xf00f0000, 0xffffffff, 0x00000001, 0x0000000a,
1004 0x00000000, 0x05000030, 0xf00f0001, 0x00000000, 0x00000028, 0x0000001e,
1005 0x0000000a, 0x0000ffff}
1010 {0xffff0201, 0x0200005b, 0x800f0000, 0x80e40000, 0x0000ffff}
1015 {0xffff0201, 0x0200005c, 0x800f0000, 0x80e40000, 0x0000ffff}
1020 "texldd r0, v1, s2, r3, r4\n",
1021 {0xffff0201, 0x0200001f, 0x90000000, 0xa00f0802, 0x0500005d, 0x800f0000,
1022 0x90e40001, 0xa0e40802, 0x80e40003, 0x80e40004, 0x0000ffff}
1024 /* Static flow control tests */
1031 {0xffff0201, 0x01000019, 0xa0e41000, 0x0000001c, 0x0100001e, 0xa0e41000,
1032 0x0000001c, 0x0000ffff}
1040 {0xffff0201, 0x0200001a, 0xa0e41000, 0xe0e40800, 0x0000001c, 0x0100001e,
1041 0xa0e41000, 0x0000001c, 0x0000ffff}
1049 {0xffff0201, 0x0200001a, 0xa0e41000, 0xede40800, 0x0000001c, 0x0100001e,
1050 0xa0e41000, 0x0000001c, 0x0000ffff}
1057 {0xffff0201, 0x01000028, 0xede40800, 0x0000002a, 0x0000002b, 0x0000ffff}
1059 /* Dynamic flow control tests */
1065 {0xffff0201, 0x01000026, 0xf0e40000, 0x0000002c, 0x00000027, 0x0000ffff}
1071 {0xffff0201, 0x02030029, 0x80e40000, 0x80e40001, 0x0000002b, 0x0000ffff}
1078 {0xffff0201, 0x01000026, 0xf0e40000, 0x0205002d, 0x80e40000, 0x80e40001,
1079 0x00000027, 0x0000ffff}
1084 "setp_gt p0, r0, r1\n"
1085 "(!p0) add r2, r2, r3\n",
1086 {0xffff0201, 0x0301005e, 0xb00f1000, 0x80e40000, 0x80e40001, 0x14000002,
1087 0x800f0002, 0xbde41000, 0x80e40002, 0x80e40003, 0x0000ffff}
1094 {0xffff0201, 0x01000028, 0xb0001000, 0x0000002a, 0x0000002b, 0x0000ffff}
1098 "callnz l0, !p0.z\n"
1102 {0xffff0201, 0x0200001a, 0xa0e41000, 0xbdaa1000, 0x0000001c,
1103 0x0100001e, 0xa0e41000, 0x0000001c, 0x0000ffff}
1110 {0xffff0201, 0x01000026, 0xf0e40000, 0x01000060, 0xb0ff1000,
1111 0x00000027, 0x0000ffff}
1119 {0xffff0201, 0x01000019, 0xa0e417ff, 0x0000001c, 0x0100001e, 0xa0e417ff,
1120 0x0000001c, 0x0000ffff}
1124 exec_tests("ps_2_x", tests
, sizeof(tests
) / sizeof(tests
[0]));
1127 static void vs_3_0_test(void) {
1128 struct shader_test tests
[] = {
1132 {0xfffe0300, 0x02000001, 0x800f0000, 0xa0e40000, 0x0000ffff}
1137 {0xfffe0300, 0x0200001f, 0x90000000, 0xa00f0800, 0x0000ffff}
1141 "dcl_position o0\n",
1142 {0xfffe0300, 0x0200001f, 0x80000000, 0xe00f0000, 0x0000ffff}
1146 "dcl_texcoord12 o11\n",
1147 {0xfffe0300, 0x0200001f, 0x800c0005, 0xe00f000b, 0x0000ffff}
1151 "texldl r0, v0, s0\n",
1152 {0xfffe0300, 0x0300005f, 0x800f0000, 0x90e40000, 0xa0e40800, 0x0000ffff}
1157 {0xfffe0300, 0x03000001, 0x800f0000, 0xa0e42000, 0xf0e40800, 0x0000ffff}
1161 "mov o[ a0.x + 12 ], r0\n",
1162 {0xfffe0300, 0x03000001, 0xe00f200c, 0xb0000000, 0x80e40000, 0x0000ffff}
1166 "add_sat r0, r0, r1\n",
1167 {0xfffe0300, 0x03000002, 0x801f0000, 0x80e40000, 0x80e40001, 0x0000ffff}
1172 {0xfffe0300, 0x02000001, 0x800f0002, 0x8be40001, 0x0000ffff}
1176 "mov r2, r1.xygb\n",
1177 {0xfffe0300, 0x02000001, 0x800f0002, 0x80940001, 0x0000ffff}
1182 {0xfffe0300, 0x02000001, 0x80070002, 0x80e40001, 0x0000ffff}
1186 "mova_sat a0.x, r1\n",
1187 {0xfffe0300, 0x0200002e, 0xb0110000, 0x80e40001, 0x0000ffff}
1192 {0xfffe0300, 0x02000025, 0x800f0000, 0x80e40001, 0x0000ffff}
1196 "def c0, 1.0f, 1.0f, 1.0f, 0.5f\n",
1197 {0xfffe0300, 0x05000051, 0xa00f0000, 0x3f800000, 0x3f800000, 0x3f800000,
1198 0x3f000000, 0x0000ffff}
1200 { /* shader 14: no register number checks with relative addressing */
1202 "add r0, v20[aL], r2\n",
1203 {0xfffe0300, 0x04000002, 0x800f0000, 0x90e42014, 0xf0e40800, 0x80e40002,
1209 exec_tests("vs_3_0", tests
, sizeof(tests
) / sizeof(tests
[0]));
1212 static void ps_3_0_test(void) {
1213 struct shader_test tests
[] = {
1217 {0xffff0300, 0x02000001, 0x800f0000, 0xa0e40000, 0x0000ffff}
1222 {0xffff0300, 0x0200001f, 0x80050003, 0x900f0000, 0x0000ffff}
1227 {0xffff0300, 0x02000001, 0x800f0000, 0x90e41000, 0x0000ffff}
1232 {0xffff0300, 0x02000001, 0x800f0000, 0x90e41001, 0x0000ffff}
1236 "mov r0, v[ aL + 12 ]\n",
1237 {0xffff0300, 0x03000001, 0x800f0000, 0x90e4200c, 0xf0e40800, 0x0000ffff}
1244 {0xffff0300, 0x0200001b, 0xf0e40800, 0xf0e40000, 0x03000001, 0x800f0000,
1245 0x90e42000, 0xf0e40800, 0x0000001d, 0x0000ffff}
1249 "texldl r0, v0, s0\n",
1250 {0xffff0300, 0x0300005f, 0x800f0000, 0x90e40000, 0xa0e40800, 0x0000ffff}
1254 "add_pp r0, r0, r1\n",
1255 {0xffff0300, 0x03000002, 0x802f0000, 0x80e40000, 0x80e40001, 0x0000ffff}
1260 {0xffff0300, 0x0200005b, 0x801f0000, 0x80e40001, 0x0000ffff}
1264 "texldd_pp r0, r1, r2, r3, r4\n",
1265 {0xffff0300, 0x0500005d, 0x802f0000, 0x80e40001, 0x80e40002, 0x80e40003,
1266 0x80e40004, 0x0000ffff}
1271 {0xffff0300, 0x01000041, 0x900f0000, 0x0000ffff}
1275 "add oC3, r0, r1\n",
1276 {0xffff0300, 0x03000002, 0x800f0803, 0x80e40000, 0x80e40001, 0x0000ffff}
1280 "dcl_texcoord0_centroid v0\n",
1281 {0xffff0300, 0x0200001f, 0x80000005, 0x904f0000, 0x0000ffff}
1285 "dcl_2d_centroid s0\n",
1286 {0xffff0300, 0x0200001f, 0x90000000, 0xa04f0800, 0x0000ffff}
1291 {0xffff0300, 0x0200001f, 0x90000000, 0xa02f0800, 0x0000ffff}
1296 {0xffff0300, 0x0200001f, 0x80000000, 0x900f0000, 0x0000ffff}
1301 {0xffff0300, 0x0200001f, 0x80000000, 0xa00f0802, 0x0000ffff}
1305 exec_tests("ps_3_0", tests
, sizeof(tests
) / sizeof(tests
[0]));
1308 static void failure_test(void) {
1309 const char * tests
[] = {
1310 /* shader 0: instruction modifier not allowed */
1313 "texldd_x2 r0, v1, s2, v3, v4\n",
1314 /* shader 1: coissue not supported in vertex shaders */
1316 "add r0.rgb, r0, r1\n"
1317 "+add r0.a, r0, r2\n",
1318 /* shader 2: coissue not supported in pixel shader version >= 2.0 */
1320 "texld r0, t0, s0\n"
1321 "add r0.rgb, r0, r1\n"
1322 "+add r0.a, r0, v1\n",
1323 /* shader 3: predicates not supported in vertex shader < 2.0 */
1325 "(p0) add r0, r0, v0\n",
1326 /* shader 4: register a0 doesn't exist in pixel shaders */
1328 "mov r0, v[ a0 + 12 ]\n",
1329 /* shader 5: s0 doesn't exist in vs_1_1 */
1332 /* shader 6: aL is a scalar register, no swizzles allowed */
1334 "mov r0, v[ aL.x + 12 ]\n",
1335 /* shader 7: tn doesn't exist in ps_3_0 */
1338 "texldd r0, t1, s2, v3, v4\n",
1339 /* shader 8: two shift modifiers */
1341 "mov_x2_x2 r0, r1\n",
1342 /* shader 9: too many source registers for mov instruction */
1345 /* shader 10: invalid combination of negate and divide modifiers */
1347 "texld r5, -r2_dz\n",
1348 /* shader 11: complement modifier not allowed in >= PS 2 */
1351 /* shader 12: invalid modifier */
1354 /* shader 13: float value in relative addressing */
1356 "mov r2, c[ aL + 3.4 ]\n",
1357 /* shader 14: complement modifier not available in VS */
1360 /* shader 15: _x2 modifier not available in VS */
1363 /* shader 16: _abs modifier not available in < VS 3.0 */
1366 /* shader 17: _x2 modifier not available in >= PS 2.0 */
1369 /* shader 18: wrong swizzle */
1371 "mov r0, r1.abcd\n",
1372 /* shader 19: wrong swizzle */
1374 "mov r0, r1.xyzwx\n",
1375 /* shader 20: wrong swizzle */
1378 /* shader 21: invalid writemask */
1380 "mov r0.xxyz, r1\n",
1381 /* shader 22: register r5 doesn't exist in PS < 1.4 */
1384 /* shader 23: can't declare output registers in a pixel shader */
1386 "dcl_positiont o0\n",
1387 /* shader 24: _pp instruction modifier not allowed in vertex shaders */
1389 "add_pp r0, r0, r1\n",
1390 /* shader 25: _x4 instruction modified not allowed in > ps_1_x */
1392 "add_x4 r0, r0, r1\n",
1393 /* shader 26: there aren't oCx registers in ps_1_x */
1395 "add oC0, r0, r1\n",
1396 /* shader 27: oC3 is the max in >= ps_2_0 */
1398 "add oC4, r0, r1\n",
1399 /* shader 28: register v17 doesn't exist */
1401 "add r0, r0, v17\n",
1402 /* shader 29: register o13 doesn't exist */
1404 "add o13, r0, r1\n",
1405 /* shader 30: label > 2047 not allowed */
1408 /* shader 31: s20 register does not exist */
1410 "texld r0, r1, s20\n",
1411 /* shader 32: t5 not allowed in ps_1_3 */
1414 /* shader 33: no temporary registers relative addressing */
1416 "add r0, r0[ a0.x ], r1\n",
1417 /* shader 34: no input registers relative addressing in vs_2_0 */
1419 "add r0, v[ a0.x ], r1\n",
1420 /* shader 35: no aL register in ps_2_0 */
1422 "add r0, v[ aL ], r1\n",
1423 /* shader 36: no relative addressing in ps_2_0 */
1425 "add r0, v[ r0 ], r1\n",
1426 /* shader 37: no a0 register in ps_3_0 */
1428 "add r0, v[ a0.x ], r1\n",
1429 /* shader 38: only a0.x accepted in vs_1_1 */
1431 "mov r0, c0[ a0 ]\n",
1432 /* shader 39: invalid modifier for dcl instruction */
1434 "dcl_texcoord0_sat v0\n",
1435 /* shader 40: shift not allowed */
1437 "dcl_texcoord0_x2 v0\n",
1438 /* shader 41: no modifier allowed with dcl instruction in vs */
1440 "dcl_texcoord0_centroid v0\n",
1441 /* shader 42: no modifiers with vs dcl sampler instruction */
1444 /* shader 43: can't explicitly declare input registers in ps_2_0 */
1446 "dcl_texcoord0 t0\n",
1447 /* shader 44: can't implicitly declare registers in vs */
1450 /* shader 45: can't implicitly declare samplers in vs */
1453 /* shader 46: no tx registers in ps_3_0 */
1456 /* shader 47: no samplers in vs_2_0 */
1459 /* shader 48: semantic required in vs dcl input instruction */
1462 /* shader 49: semantic not allowed in ps dcl input instruction*/
1464 "dcl_position0 v0\n",
1465 /* shader 50: dcl instruction not in ps_1_x */
1467 "dcl_position0 v0\n",
1468 /* shader 51: no dcl output instruction in < vs 3.0 */
1470 "dcl_positiont0 o0\n",
1474 LPD3DXBUFFER shader
,messages
;
1476 for(i
= 0; i
< (sizeof(tests
) / sizeof(tests
[0])); i
++) {
1479 hr
= D3DXAssembleShader(tests
[i
], strlen(tests
[i
]),
1480 NULL
, NULL
, D3DXSHADER_SKIPVALIDATION
,
1481 &shader
, &messages
);
1482 ok(hr
== D3DXERR_INVALIDDATA
, "Failure test, shader %d: "
1483 "expected D3DXAssembleShader failure with D3DXERR_INVALIDDATA, "
1484 "got 0x%x - %d\n", i
, hr
, hr
& 0x0000FFFF);
1486 trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages
));
1487 ID3DXBuffer_Release(messages
);
1490 DWORD
*res
= ID3DXBuffer_GetBufferPointer(shader
);
1492 ID3DXBuffer_Release(shader
);
1498 static HRESULT WINAPI
testD3DXInclude_open(ID3DXInclude
*iface
,
1499 D3DXINCLUDE_TYPE include_type
,
1500 LPCSTR filename
, LPCVOID parent_data
,
1501 LPCVOID
*data
, UINT
*bytes
) {
1503 const char include
[] = "#define REGISTER r0\nvs.1.1\n";
1504 const char include2
[] = "#include \"incl3.vsh\"\n";
1505 const char include3
[] = "vs.1.1\n";
1507 trace("filename = %s\n", filename
);
1508 trace("parent_data = (%p) -> %s\n", parent_data
, (char *)parent_data
);
1510 if(!strcmp(filename
,"incl.vsh")) {
1511 buffer
= HeapAlloc(GetProcessHeap(), 0, sizeof(include
));
1512 CopyMemory(buffer
, include
, sizeof(include
));
1513 *bytes
= sizeof(include
);
1514 /* Also check for the correct parent_data content */
1515 ok(parent_data
== NULL
, "wrong parent_data value\n");
1517 else if(!strcmp(filename
,"incl3.vsh")) {
1518 buffer
= HeapAlloc(GetProcessHeap(), 0, sizeof(include3
));
1519 CopyMemory(buffer
, include3
, sizeof(include3
));
1520 *bytes
= sizeof(include3
);
1521 /* Also check for the correct parent_data content */
1522 ok(parent_data
!= NULL
&& !strncmp(include2
, parent_data
, strlen(include2
)), "wrong parent_data value\n");
1525 buffer
= HeapAlloc(GetProcessHeap(), 0, sizeof(include2
));
1526 CopyMemory(buffer
, include2
, sizeof(include2
));
1527 *bytes
= sizeof(include2
);
1533 static HRESULT WINAPI
testD3DXInclude_close(ID3DXInclude
*iface
, LPCVOID data
) {
1534 HeapFree(GetProcessHeap(), 0, (LPVOID
)data
);
1538 static const struct ID3DXIncludeVtbl D3DXInclude_Vtbl
= {
1539 testD3DXInclude_open
,
1540 testD3DXInclude_close
1543 struct D3DXIncludeImpl
{
1544 const ID3DXIncludeVtbl
*lpVtbl
;
1547 static void assembleshader_test(void) {
1548 const char test1
[] = {
1552 const char testincl
[] = {
1553 "#define REGISTER r0\n"
1556 const char testshader
[] = {
1557 "#include \"incl.vsh\"\n"
1558 "mov REGISTER, v0\n"
1560 const char testshader2
[] = {
1561 "#include \"incl2.vsh\"\n"
1562 "mov REGISTER, v0\n"
1565 LPD3DXBUFFER shader
, messages
;
1566 D3DXMACRO defines
[] = {
1577 struct D3DXIncludeImpl include
;
1578 HRESULT shader_vsh_res
, incl_vsh_res
;
1583 hr
= D3DXAssembleShader(test1
, strlen(test1
),
1584 defines
, NULL
, D3DXSHADER_SKIPVALIDATION
,
1585 &shader
, &messages
);
1586 ok(hr
== D3D_OK
, "pDefines test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1588 trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages
));
1589 ID3DXBuffer_Release(messages
);
1591 if(shader
) ID3DXBuffer_Release(shader
);
1593 /* NULL messages test */
1595 hr
= D3DXAssembleShader(test1
, strlen(test1
),
1596 defines
, NULL
, D3DXSHADER_SKIPVALIDATION
,
1598 ok(hr
== D3D_OK
, "NULL messages test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1599 if(shader
) ID3DXBuffer_Release(shader
);
1601 /* NULL shader test */
1603 hr
= D3DXAssembleShader(test1
, strlen(test1
),
1604 defines
, NULL
, D3DXSHADER_SKIPVALIDATION
,
1606 ok(hr
== D3D_OK
, "NULL shader test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1608 trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages
));
1609 ID3DXBuffer_Release(messages
);
1615 include
.lpVtbl
= &D3DXInclude_Vtbl
;
1616 hr
= D3DXAssembleShader(testshader
, strlen(testshader
),
1617 NULL
, (LPD3DXINCLUDE
)&include
, D3DXSHADER_SKIPVALIDATION
,
1618 &shader
, &messages
);
1619 ok(hr
== D3D_OK
, "pInclude test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1621 trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages
));
1622 ID3DXBuffer_Release(messages
);
1624 if(shader
) ID3DXBuffer_Release(shader
);
1626 /* "unexpected #include file from memory" test */
1629 hr
= D3DXAssembleShader(testshader
, strlen(testshader
),
1630 NULL
, NULL
, D3DXSHADER_SKIPVALIDATION
,
1631 &shader
, &messages
);
1632 ok(hr
== D3DXERR_INVALIDDATA
, "D3DXAssembleShader test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1634 trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages
));
1635 ID3DXBuffer_Release(messages
);
1637 if(shader
) ID3DXBuffer_Release(shader
);
1639 /* recursive #include test */
1642 hr
= D3DXAssembleShader(testshader2
, strlen(testshader2
),
1643 NULL
, (LPD3DXINCLUDE
)&include
, D3DXSHADER_SKIPVALIDATION
,
1644 &shader
, &messages
);
1645 ok(hr
== D3D_OK
, "D3DXAssembleShader test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1647 trace("recursive D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages
));
1648 ID3DXBuffer_Release(messages
);
1650 if(shader
) ID3DXBuffer_Release(shader
);
1654 shader_vsh_res
= create_file("shader.vsh", testshader
, sizeof(testshader
));
1655 if(SUCCEEDED(shader_vsh_res
)) {
1656 incl_vsh_res
= create_file("incl.vsh", testincl
, sizeof(testincl
));
1657 if(SUCCEEDED(incl_vsh_res
)) {
1658 /* D3DXAssembleShaderFromFile + #include test */
1661 hr
= D3DXAssembleShaderFromFileA("shader.vsh",
1662 NULL
, NULL
, D3DXSHADER_SKIPVALIDATION
,
1663 &shader
, &messages
);
1664 ok(hr
== D3D_OK
, "D3DXAssembleShaderFromFile test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1666 trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages
));
1667 ID3DXBuffer_Release(messages
);
1669 if(shader
) ID3DXBuffer_Release(shader
);
1670 } else skip("Couldn't create \"incl.vsh\"\n");
1672 /* D3DXAssembleShaderFromFile + pInclude test */
1675 hr
= D3DXAssembleShaderFromFileA("shader.vsh",
1676 NULL
, (LPD3DXINCLUDE
)&include
, D3DXSHADER_SKIPVALIDATION
,
1677 &shader
, &messages
);
1678 ok(hr
== D3D_OK
, "D3DXAssembleShaderFromFile + pInclude test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1680 trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages
));
1681 ID3DXBuffer_Release(messages
);
1683 if(shader
) ID3DXBuffer_Release(shader
);
1684 } else skip("Couldn't create \"shader.vsh\"\n");
1688 /* NULL shader tests */
1691 hr
= D3DXAssembleShader(NULL
, 0,
1692 NULL
, NULL
, D3DXSHADER_SKIPVALIDATION
,
1693 &shader
, &messages
);
1694 ok(hr
== D3DXERR_INVALIDDATA
, "NULL shader test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1696 trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages
));
1697 ID3DXBuffer_Release(messages
);
1699 if(shader
) ID3DXBuffer_Release(shader
);
1705 hr
= D3DXAssembleShaderFromFileA("nonexistent.vsh",
1706 NULL
, NULL
, D3DXSHADER_SKIPVALIDATION
,
1707 &shader
, &messages
);
1708 ok(hr
== D3DXERR_INVALIDDATA
|| hr
== E_FAIL
, /* I get this on WinXP */
1709 "D3DXAssembleShaderFromFile nonexistent file test failed with error 0x%x - %d\n",
1710 hr
, hr
& 0x0000FFFF);
1712 trace("D3DXAssembleShaderFromFile messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages
));
1713 ID3DXBuffer_Release(messages
);
1715 if(shader
) ID3DXBuffer_Release(shader
);
1717 } /* end of todo_wine */
1719 /* D3DXAssembleShaderFromResource test */
1722 hr
= D3DXAssembleShaderFromResourceA(NULL
, MAKEINTRESOURCEA(IDB_ASMSHADER
),
1723 NULL
, NULL
, D3DXSHADER_SKIPVALIDATION
,
1724 &shader
, &messages
);
1725 ok(hr
== D3D_OK
, "D3DXAssembleShaderFromResource test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1727 trace("D3DXAssembleShaderFromResource messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages
));
1728 ID3DXBuffer_Release(messages
);
1730 if(shader
) ID3DXBuffer_Release(shader
);
1732 /* D3DXAssembleShaderFromResource with missing shader resource test */
1735 hr
= D3DXAssembleShaderFromResourceA(NULL
, "notexisting",
1736 NULL
, NULL
, D3DXSHADER_SKIPVALIDATION
,
1737 &shader
, &messages
);
1738 ok(hr
== D3DXERR_INVALIDDATA
, "D3DXAssembleShaderFromResource NULL shader test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1740 trace("D3DXAssembleShaderFromResource messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages
));
1741 ID3DXBuffer_Release(messages
);
1743 if(shader
) ID3DXBuffer_Release(shader
);
1746 if(SUCCEEDED(shader_vsh_res
)) {
1747 DeleteFileA("shader.vsh");
1748 if(SUCCEEDED(incl_vsh_res
)) DeleteFileA("incl.vsh");
1768 assembleshader_test();