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}
137 exec_tests("ps_1_1", tests
, sizeof(tests
) / sizeof(tests
[0]));
140 static void vs_1_1_test(void) {
141 struct shader_test tests
[] = {
142 /* Basic instruction tests */
146 {0xfffe0101, 0x00000002, 0x800f0000, 0x80e40001, 0x80e40002, 0x0000ffff}
151 {0xfffe0101, 0x00000000, 0x0000ffff}
153 /* Output register tests */
157 {0xfffe0101, 0x00000001, 0xc00f0000, 0xa0e40000, 0x0000ffff}
162 {0xfffe0101, 0x00000001, 0xe00f0000, 0xa0e40000, 0x0000ffff}
167 {0xfffe0101, 0x00000001, 0xe00f0005, 0xa0e40000, 0x0000ffff}
172 {0xfffe0101, 0x00000001, 0xd00f0000, 0xa0e40000, 0x0000ffff}
177 {0xfffe0101, 0x00000001, 0xd00f0001, 0xa0e40000, 0x0000ffff}
182 {0xfffe0101, 0x00000001, 0xc00f0001, 0xa0000000, 0x0000ffff}
187 {0xfffe0101, 0x00000001, 0xc00f0002, 0xa0000000, 0x0000ffff}
189 /* A bunch of tests for declarations */
193 {0xfffe0101, 0x0000001f, 0x80000000, 0x900f0000, 0x0000ffff}
198 {0xfffe0101, 0x0000001f, 0x80000000, 0x900f0001, 0x0000ffff}
203 {0xfffe0101, 0x0000001f, 0x800c0003, 0x900f000f, 0x0000ffff}
208 {0xfffe0101, 0x00000002, 0x800f0000, 0x90e40000, 0x90e40001, 0x0000ffff}
212 "def c12, 0, -1, -0.5, 1024\n",
213 {0xfffe0101, 0x00000051, 0xa00f000c, 0x00000000, 0xbf800000, 0xbf000000,
214 0x44800000, 0x0000ffff}
216 { /* shader 14: writemasks, swizzles */
218 "dp4 r0.xw, r1.wzyx, r2.xxww\n",
219 {0xfffe0101, 0x00000009, 0x80090000, 0x801b0001, 0x80f00002, 0x0000ffff}
221 { /* shader 15: negation input modifier. Other modifiers not supprted in vs_1_1 */
223 "add r0, -r0.x, -r1\n",
224 {0xfffe0101, 0x00000002, 0x800f0000, 0x81000000, 0x81e40001, 0x0000ffff}
226 { /* shader 16: relative addressing */
228 "mov r0, c0[a0.x]\n",
229 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e42000, 0x0000ffff}
231 { /* shader 17: relative addressing */
233 "mov r0, c1[a0.x + 2]\n",
234 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e42003, 0x0000ffff}
238 "def c0, 1.0f, 1.0f, 1.0f, 0.5f\n",
239 {0xfffe0101, 0x00000051, 0xa00f0000, 0x3f800000, 0x3f800000, 0x3f800000,
240 0x3f000000, 0x0000ffff}
242 /* Other relative addressing tests */
245 "mov r0, c[ a0.x + 12 ]\n",
246 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e4200c, 0x0000ffff}
250 "mov r0, c[ 2 + a0.x ]\n",
251 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e42002, 0x0000ffff}
255 "mov r0, c[ 2 + a0.x + 12 ]\n",
256 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e4200e, 0x0000ffff}
260 "mov r0, c[ 2 + 10 + 12 ]\n",
261 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e40018, 0x0000ffff}
266 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e40006, 0x0000ffff}
271 {0xfffe0101, 0x00000006, 0x800f0000, 0x90000000, 0x0000ffff}
276 {0xfffe0101, 0x00000007, 0x800f0000, 0x90000000, 0x0000ffff}
280 exec_tests("vs_1_1", tests
, sizeof(tests
) / sizeof(tests
[0]));
283 static void ps_1_3_test(void) {
284 struct shader_test tests
[] = {
285 /* Basic instruction tests */
289 {0xffff0103, 0x00000001, 0x800f0000, 0x80e40001, 0x0000ffff}
294 {0xffff0103, 0x00000002, 0x800f0000, 0x80e40001, 0x80e40000, 0x0000ffff}
296 /* Color interpolator tests */
300 {0xffff0103, 0x00000001, 0x800f0000, 0x90e40000, 0x0000ffff}
305 {0xffff0103, 0x00000001, 0x800f0000, 0x90e40001, 0x0000ffff}
307 /* Texture sampling instructions */
311 {0xffff0103, 0x00000042, 0xb00f0000, 0x0000ffff}
316 "texreg2ar t1, t0\n",
317 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000045, 0xb00f0001, 0xb0e40000,
323 "texreg2gb t1, t0\n",
324 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000046, 0xb00f0001, 0xb0e40000,
330 "texreg2rgb t1, t0\n",
331 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000052, 0xb00f0001, 0xb0e40000,
336 "cnd r0, r1, r0, v0\n",
337 {0xffff0103, 0x00000050, 0x800f0000, 0x80e40001, 0x80e40000, 0x90e40000,
342 "cmp r0, r1, r0, v0\n",
343 {0xffff0103, 0x00000058, 0x800f0000, 0x80e40001, 0x80e40000, 0x90e40000,
349 {0xffff0103, 0x00000041, 0xb00f0000, 0x0000ffff}
354 "texm3x2pad t1, t0\n"
355 "texm3x2tex t2, t0\n",
356 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000047, 0xb00f0001, 0xb0e40000,
357 0x00000048, 0xb00f0002, 0xb0e40000, 0x0000ffff}
362 "texm3x2pad t1, t0\n"
363 "texm3x2depth t2, t0\n",
364 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000047, 0xb00f0001, 0xb0e40000,
365 0x00000054, 0xb00f0002, 0xb0e40000, 0x0000ffff}
371 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000043, 0xb00f0001, 0xb0e40000,
378 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000044, 0xb00f0001, 0xb0e40000,
384 "texdp3tex t1, t0\n",
385 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000053, 0xb00f0001, 0xb0e40000,
392 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000055, 0xb00f0001, 0xb0e40000,
398 "texm3x3pad t1, t0\n"
399 "texm3x3pad t2, t0\n"
400 "texm3x3tex t3, t0\n",
401 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb00f0001, 0xb0e40000,
402 0x00000049, 0xb00f0002, 0xb0e40000, 0x0000004a, 0xb00f0003, 0xb0e40000,
408 "texm3x3pad t1, t0\n"
409 "texm3x3pad t2, t0\n"
411 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb00f0001, 0xb0e40000,
412 0x00000049, 0xb00f0002, 0xb0e40000, 0x00000056, 0xb00f0003, 0xb0e40000,
418 "texm3x3pad t1, t0\n"
419 "texm3x3pad t2, t0\n"
420 "texm3x3spec t3, t0, c0\n",
421 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb00f0001, 0xb0e40000,
422 0x00000049, 0xb00f0002, 0xb0e40000, 0x0000004c, 0xb00f0003, 0xb0e40000,
423 0xa0e40000, 0x0000ffff}
428 "texm3x3pad t1, t0\n"
429 "texm3x3pad t2, t0\n"
430 "texm3x3vspec t3, t0\n",
431 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb00f0001, 0xb0e40000,
432 0x00000049, 0xb00f0002, 0xb0e40000, 0x0000004d, 0xb00f0003, 0xb0e40000,
438 {0xffff0103, 0x00000040, 0xb00f0000, 0x0000ffff}
440 /* Modifiers, shifts */
443 "mov_x2_sat r0, 1 - r1\n",
444 {0xffff0103, 0x00000001, 0x811f0000, 0x86e40001, 0x0000ffff}
449 {0xffff0103, 0x00000001, 0x8d0f0000, 0x81e40001, 0x0000ffff}
453 "mov_sat r0, r1_bx2\n",
454 {0xffff0103, 0x00000001, 0x801f0000, 0x84e40001, 0x0000ffff}
458 "mov_sat r0, r1_bias\n",
459 {0xffff0103, 0x00000001, 0x801f0000, 0x82e40001, 0x0000ffff}
463 "mov_sat r0, -r1_bias\n",
464 {0xffff0103, 0x00000001, 0x801f0000, 0x83e40001, 0x0000ffff}
468 "mov_sat r0, -r1_bx2\n",
469 {0xffff0103, 0x00000001, 0x801f0000, 0x85e40001, 0x0000ffff}
473 "mov_sat r0, -r1_x2\n",
474 {0xffff0103, 0x00000001, 0x801f0000, 0x88e40001, 0x0000ffff}
478 "mov_x4_sat r0.a, -r1_bx2.a\n",
479 {0xffff0103, 0x00000001, 0x82180000, 0x85ff0001, 0x0000ffff}
483 exec_tests("ps_1_3", tests
, sizeof(tests
) / sizeof(tests
[0]));
486 static void ps_1_4_test(void) {
487 struct shader_test tests
[] = {
488 /* Basic instruction tests */
492 {0xffff0104, 0x00000001, 0x800f0000, 0x80e40001, 0x0000ffff}
497 {0xffff0104, 0x00000001, 0x800f0000, 0x80e40005, 0x0000ffff}
502 {0xffff0104, 0x00000001, 0x800f0000, 0xa0e40007, 0x0000ffff}
507 {0xffff0104, 0x00000001, 0x800f0000, 0x90e40001, 0x0000ffff}
512 {0xffff0104, 0x0000fffd, 0x0000ffff}
517 {0xffff0104, 0x00000040, 0x800f0000, 0xb0e40000, 0x0000ffff}
522 {0xffff0104, 0x00000040, 0x800f0004, 0xb0e40003, 0x0000ffff}
526 "texcrd_sat r4, t3\n",
527 {0xffff0104, 0x00000040, 0x801f0004, 0xb0e40003, 0x0000ffff}
532 {0xffff0104, 0x00000042, 0x800f0000, 0xb0e40000, 0x0000ffff}
537 {0xffff0104, 0x00000042, 0x800f0001, 0xb0e40004, 0x0000ffff}
542 {0xffff0104, 0x00000042, 0x800f0005, 0x80e40000, 0x0000ffff}
546 "texld r5, c0\n", /* Assembly succeeds, validation fails */
547 {0xffff0104, 0x00000042, 0x800f0005, 0xa0e40000, 0x0000ffff}
552 {0xffff0104, 0x00000042, 0x800f0005, 0x89e40002, 0x0000ffff}
556 "bem r1.rg, c0, r0\n",
557 {0xffff0104, 0x00000059, 0x80030001, 0xa0e40000, 0x80e40000, 0x0000ffff}
562 {0xffff0104, 0x00000057, 0x800f0005, 0x0000ffff}
566 exec_tests("ps_1_4", tests
, sizeof(tests
) / sizeof(tests
[0]));
569 static void vs_2_0_test(void) {
570 struct shader_test tests
[] = {
571 /* Basic instruction tests */
575 {0xfffe0200, 0x02000001, 0x800f0000, 0x80e40001, 0x0000ffff}
579 "lrp r0, v0, c0, r1\n",
580 {0xfffe0200, 0x04000012, 0x800f0000, 0x90e40000, 0xa0e40000, 0x80e40001,
585 "dp4 oPos, v0, c0\n",
586 {0xfffe0200, 0x03000009, 0xc00f0000, 0x90e40000, 0xa0e40000, 0x0000ffff}
590 "mov r0, c0[a0.x]\n",
591 {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0000000, 0x0000ffff}
595 "mov r0, c0[a0.y]\n",
596 {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0550000, 0x0000ffff}
600 "mov r0, c0[a0.z]\n",
601 {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0aa0000, 0x0000ffff}
605 "mov r0, c0[a0.w]\n",
606 {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0ff0000, 0x0000ffff}
610 "mov r0, c0[a0.w].x\n",
611 {0xfffe0200, 0x03000001, 0x800f0000, 0xa0002000, 0xb0ff0000, 0x0000ffff}
615 "mov r0, -c0[a0.w+5].x\n",
616 {0xfffe0200, 0x03000001, 0x800f0000, 0xa1002005, 0xb0ff0000, 0x0000ffff}
621 {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0e40000, 0x0000ffff}
625 "mov r0, c0[a0.xyww]\n",
626 {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0f40000, 0x0000ffff}
630 "add r0, c0[a0.x], c1[a0.y]\n", /* validation would fail on this line */
631 {0xfffe0200, 0x05000002, 0x800f0000, 0xa0e42000, 0xb0000000, 0xa0e42001,
632 0xb0550000, 0x0000ffff}
638 {0xfffe0200, 0x01000026, 0xf0e40000, 0x00000027, 0x0000ffff}
645 {0xfffe0200, 0x01000028, 0xe0e40800, 0x0000002a, 0x0000002b, 0x0000ffff}
651 {0xfffe0200, 0x0200001b, 0xf0e40800, 0xf0e40000, 0x0000001d, 0x0000ffff}
656 {0xfffe0200, 0x02000024, 0x800f0000, 0xa0e40000, 0x0000ffff}
661 {0xfffe0200, 0x03000021, 0x800f0000, 0x80e40001, 0x80e40002, 0x0000ffff}
665 "sgn r0, r1, r2, r3\n",
666 {0xfffe0200, 0x04000022, 0x800f0000, 0x80e40001, 0x80e40002, 0x80e40003,
671 "sincos r0, r1, r2, r3\n",
672 {0xfffe0200, 0x04000025, 0x800f0000, 0x80e40001, 0x80e40002, 0x80e40003,
678 {0xfffe0200, 0x03000020, 0x800f0000, 0x80e40001, 0x80e40002, 0x0000ffff}
683 {0xfffe0200, 0x0200002e, 0xb0020000, 0xa0aa0000, 0x0000ffff}
689 {0xfffe0200, 0x0200002f, 0xe00f0800, 0x00000001, 0x0200002f, 0xe00f0801,
690 0x00000000, 0x0000ffff}
694 "defi i0, -1, 1, 10, 0\n"
695 "defi i1, 0, 40, 30, 10\n",
696 {0xfffe0200, 0x05000030, 0xf00f0000, 0xffffffff, 0x00000001, 0x0000000a,
697 0x00000000, 0x05000030, 0xf00f0001, 0x00000000, 0x00000028, 0x0000001e,
698 0x0000000a, 0x0000ffff}
705 {0xfffe0200, 0x0200001b, 0xf0e40800, 0xf0e40000, 0x03000001, 0x800f0000,
706 0xa0e42000, 0xf0e40800, 0x0000001d, 0x0000ffff}
714 {0xfffe0200, 0x01000019, 0xa0e41000, 0x0000001c, 0x0100001e, 0xa0e41000,
715 0x0000001c, 0x0000ffff}
723 {0xfffe0200, 0x0200001a, 0xa0e41000, 0xe0e40800, 0x0000001c, 0x0100001e,
724 0xa0e41000, 0x0000001c, 0x0000ffff}
732 {0xfffe0200, 0x0200001a, 0xa0e41000, 0xede40800, 0x0000001c, 0x0100001e,
733 0xa0e41000, 0x0000001c, 0x0000ffff}
740 {0xfffe0200, 0x01000028, 0xede40800, 0x0000002a, 0x0000002b, 0x0000ffff}
748 {0xfffe0200, 0x01000019, 0xa0e41003, 0x0000001c, 0x0100001e, 0xa0e41003, 0x0000001c, 0x0000ffff}
750 { /* shader 29: labels up to 2047 are accepted even in vs_2_0 */
753 {0xfffe0200, 0x01000019, 0xa0e417ff, 0x0000ffff}
757 exec_tests("vs_2_0", tests
, sizeof(tests
) / sizeof(tests
[0]));
760 static void vs_2_x_test(void) {
761 struct shader_test tests
[] = {
767 {0xfffe0201, 0x01000026, 0xf0e40000, 0x0000002c, 0x00000027, 0x0000ffff}
773 {0xfffe0201, 0x02030029, 0x80e40000, 0x80e40001, 0x0000002b, 0x0000ffff}
780 {0xfffe0201, 0x01000026, 0xf0e40000, 0x0205002d, 0x80e40000, 0x80e40001,
781 0x00000027, 0x0000ffff}
787 "setp_gt p0, r0, r1\n"
788 "(!p0) add r2, r2, r3\n",
789 {0xfffe0201, 0x0301005e, 0xb00f1000, 0x80e40000, 0x80e40001, 0x14000002,
790 0x800f0002, 0xbde41000, 0x80e40002, 0x80e40003, 0x0000ffff}
797 {0xfffe0201, 0x01000028, 0xb0001000, 0x0000002a, 0x0000002b, 0x0000ffff}
805 {0xfffe0201, 0x0200001a, 0xa0e41000, 0xbdaa1000, 0x0000001c,
806 0x0100001e, 0xa0e41000, 0x0000001c, 0x0000ffff}
813 {0xfffe0201, 0x01000026, 0xf0e40000, 0x01000060, 0xb0ff1000,
814 0x00000027, 0x0000ffff}
818 exec_tests("vs_2_x", tests
, sizeof(tests
) / sizeof(tests
[0]));
821 static void ps_2_0_test(void) {
822 struct shader_test tests
[] = {
826 {0xffff0200, 0x0200001f, 0x90000000, 0xa00f0800, 0x0000ffff}
831 {0xffff0200, 0x0200001f, 0x98000000, 0xa00f0800, 0x0000ffff}
836 {0xffff0200, 0x0200001f, 0xa0000000, 0xa00f0800, 0x0000ffff}
843 {0xffff0200, 0x0200001f, 0xa0000000, 0xa00f0800, 0x0200001f, 0x98000000,
844 0xa00f0801, 0x0200001f, 0x90000000, 0xa00f0802, 0x0000ffff}
849 {0xffff0200, 0x02000001, 0x800f0000, 0xb0e40000, 0x0000ffff}
854 "texld r0, t1, s2\n",
855 {0xffff0200, 0x0200001f, 0x90000000, 0xa00f0802, 0x03000042, 0x800f0000,
856 0xb0e40001, 0xa0e40802, 0x0000ffff}
861 {0xffff0200, 0x01000041, 0xb00f0000, 0x0000ffff}
867 {0xffff0200, 0x02000001, 0x800f0800, 0xa0e40000, 0x02000001, 0x800f0801,
868 0xa0e40001, 0x0000ffff}
872 "mov oDepth, c0.x\n",
873 {0xffff0200, 0x02000001, 0x900f0800, 0xa0000000, 0x0000ffff}
878 "texldp r0, t1, s2\n",
879 {0xffff0200, 0x0200001f, 0x90000000, 0xa00f0802, 0x03010042, 0x800f0000,
880 0xb0e40001, 0xa0e40802, 0x0000ffff}
885 "texldb r0, t1, s2\n",
886 {0xffff0200, 0x0200001f, 0x90000000, 0xa00f0802, 0x03020042, 0x800f0000,
887 0xb0e40001, 0xa0e40802, 0x0000ffff}
891 exec_tests("ps_2_0", tests
, sizeof(tests
) / sizeof(tests
[0]));
894 static void ps_2_x_test(void) {
895 struct shader_test tests
[] = {
896 /* defb and defi are not supposed to work in ps_2_0 (even if defb actually works in ps_2_0 with native) */
901 {0xffff0201, 0x0200002f, 0xe00f0800, 0x00000001, 0x0200002f, 0xe00f0801,
902 0x00000000, 0x0000ffff}
906 "defi i0, -1, 1, 10, 0\n"
907 "defi i1, 0, 40, 30, 10\n",
908 {0xffff0201, 0x05000030, 0xf00f0000, 0xffffffff, 0x00000001, 0x0000000a,
909 0x00000000, 0x05000030, 0xf00f0001, 0x00000000, 0x00000028, 0x0000001e,
910 0x0000000a, 0x0000ffff}
915 {0xffff0201, 0x0200005b, 0x800f0000, 0x80e40000, 0x0000ffff}
920 {0xffff0201, 0x0200005c, 0x800f0000, 0x80e40000, 0x0000ffff}
925 "texldd r0, v1, s2, r3, r4\n",
926 {0xffff0201, 0x0200001f, 0x90000000, 0xa00f0802, 0x0500005d, 0x800f0000,
927 0x90e40001, 0xa0e40802, 0x80e40003, 0x80e40004, 0x0000ffff}
929 /* Static flow control tests */
936 {0xffff0201, 0x01000019, 0xa0e41000, 0x0000001c, 0x0100001e, 0xa0e41000,
937 0x0000001c, 0x0000ffff}
945 {0xffff0201, 0x0200001a, 0xa0e41000, 0xe0e40800, 0x0000001c, 0x0100001e,
946 0xa0e41000, 0x0000001c, 0x0000ffff}
954 {0xffff0201, 0x0200001a, 0xa0e41000, 0xede40800, 0x0000001c, 0x0100001e,
955 0xa0e41000, 0x0000001c, 0x0000ffff}
962 {0xffff0201, 0x01000028, 0xede40800, 0x0000002a, 0x0000002b, 0x0000ffff}
964 /* Dynamic flow control tests */
970 {0xffff0201, 0x01000026, 0xf0e40000, 0x0000002c, 0x00000027, 0x0000ffff}
976 {0xffff0201, 0x02030029, 0x80e40000, 0x80e40001, 0x0000002b, 0x0000ffff}
983 {0xffff0201, 0x01000026, 0xf0e40000, 0x0205002d, 0x80e40000, 0x80e40001,
984 0x00000027, 0x0000ffff}
989 "setp_gt p0, r0, r1\n"
990 "(!p0) add r2, r2, r3\n",
991 {0xffff0201, 0x0301005e, 0xb00f1000, 0x80e40000, 0x80e40001, 0x14000002,
992 0x800f0002, 0xbde41000, 0x80e40002, 0x80e40003, 0x0000ffff}
999 {0xffff0201, 0x01000028, 0xb0001000, 0x0000002a, 0x0000002b, 0x0000ffff}
1003 "callnz l0, !p0.z\n"
1007 {0xffff0201, 0x0200001a, 0xa0e41000, 0xbdaa1000, 0x0000001c,
1008 0x0100001e, 0xa0e41000, 0x0000001c, 0x0000ffff}
1015 {0xffff0201, 0x01000026, 0xf0e40000, 0x01000060, 0xb0ff1000,
1016 0x00000027, 0x0000ffff}
1024 {0xffff0201, 0x01000019, 0xa0e417ff, 0x0000001c, 0x0100001e, 0xa0e417ff,
1025 0x0000001c, 0x0000ffff}
1029 exec_tests("ps_2_x", tests
, sizeof(tests
) / sizeof(tests
[0]));
1032 static void vs_3_0_test(void) {
1033 struct shader_test tests
[] = {
1037 {0xfffe0300, 0x02000001, 0x800f0000, 0xa0e40000, 0x0000ffff}
1042 {0xfffe0300, 0x0200001f, 0x90000000, 0xa00f0800, 0x0000ffff}
1046 "dcl_position o0\n",
1047 {0xfffe0300, 0x0200001f, 0x80000000, 0xe00f0000, 0x0000ffff}
1051 "dcl_texcoord12 o11\n",
1052 {0xfffe0300, 0x0200001f, 0x800c0005, 0xe00f000b, 0x0000ffff}
1056 "texldl r0, v0, s0\n",
1057 {0xfffe0300, 0x0300005f, 0x800f0000, 0x90e40000, 0xa0e40800, 0x0000ffff}
1062 {0xfffe0300, 0x03000001, 0x800f0000, 0xa0e42000, 0xf0e40800, 0x0000ffff}
1066 "mov o[ a0.x + 12 ], r0\n",
1067 {0xfffe0300, 0x03000001, 0xe00f200c, 0xb0000000, 0x80e40000, 0x0000ffff}
1071 "add_sat r0, r0, r1\n",
1072 {0xfffe0300, 0x03000002, 0x801f0000, 0x80e40000, 0x80e40001, 0x0000ffff}
1077 {0xfffe0300, 0x02000001, 0x800f0002, 0x8be40001, 0x0000ffff}
1081 "mov r2, r1.xygb\n",
1082 {0xfffe0300, 0x02000001, 0x800f0002, 0x80940001, 0x0000ffff}
1087 {0xfffe0300, 0x02000001, 0x80070002, 0x80e40001, 0x0000ffff}
1091 "mova_sat a0.x, r1\n",
1092 {0xfffe0300, 0x0200002e, 0xb0110000, 0x80e40001, 0x0000ffff}
1097 {0xfffe0300, 0x02000025, 0x800f0000, 0x80e40001, 0x0000ffff}
1101 "def c0, 1.0f, 1.0f, 1.0f, 0.5f\n",
1102 {0xfffe0300, 0x05000051, 0xa00f0000, 0x3f800000, 0x3f800000, 0x3f800000,
1103 0x3f000000, 0x0000ffff}
1105 { /* shader 14: no register number checks with relative addressing */
1107 "add r0, v20[aL], r2\n",
1108 {0xfffe0300, 0x04000002, 0x800f0000, 0x90e42014, 0xf0e40800, 0x80e40002,
1114 exec_tests("vs_3_0", tests
, sizeof(tests
) / sizeof(tests
[0]));
1117 static void ps_3_0_test(void) {
1118 struct shader_test tests
[] = {
1122 {0xffff0300, 0x02000001, 0x800f0000, 0xa0e40000, 0x0000ffff}
1127 {0xffff0300, 0x0200001f, 0x80050003, 0x900f0000, 0x0000ffff}
1132 {0xffff0300, 0x02000001, 0x800f0000, 0x90e41000, 0x0000ffff}
1137 {0xffff0300, 0x02000001, 0x800f0000, 0x90e41001, 0x0000ffff}
1141 "mov r0, v[ aL + 12 ]\n",
1142 {0xffff0300, 0x03000001, 0x800f0000, 0x90e4200c, 0xf0e40800, 0x0000ffff}
1149 {0xffff0300, 0x0200001b, 0xf0e40800, 0xf0e40000, 0x03000001, 0x800f0000,
1150 0x90e42000, 0xf0e40800, 0x0000001d, 0x0000ffff}
1154 "texldl r0, v0, s0\n",
1155 {0xffff0300, 0x0300005f, 0x800f0000, 0x90e40000, 0xa0e40800, 0x0000ffff}
1159 "add_pp r0, r0, r1\n",
1160 {0xffff0300, 0x03000002, 0x802f0000, 0x80e40000, 0x80e40001, 0x0000ffff}
1165 {0xffff0300, 0x0200005b, 0x801f0000, 0x80e40001, 0x0000ffff}
1169 "texldd_pp r0, r1, r2, r3, r4\n",
1170 {0xffff0300, 0x0500005d, 0x802f0000, 0x80e40001, 0x80e40002, 0x80e40003,
1171 0x80e40004, 0x0000ffff}
1176 {0xffff0300, 0x01000041, 0x900f0000, 0x0000ffff}
1180 "add oC3, r0, r1\n",
1181 {0xffff0300, 0x03000002, 0x800f0803, 0x80e40000, 0x80e40001, 0x0000ffff}
1185 "dcl_texcoord0_centroid v0\n",
1186 {0xffff0300, 0x0200001f, 0x80000005, 0x904f0000, 0x0000ffff}
1190 "dcl_2d_centroid s0\n",
1191 {0xffff0300, 0x0200001f, 0x90000000, 0xa04f0800, 0x0000ffff}
1196 {0xffff0300, 0x0200001f, 0x90000000, 0xa02f0800, 0x0000ffff}
1200 exec_tests("ps_3_0", tests
, sizeof(tests
) / sizeof(tests
[0]));
1203 static void failure_test(void) {
1204 const char * tests
[] = {
1205 /* shader 0: instruction modifier not allowed */
1208 "texldd_x2 r0, v1, s2, v3, v4\n",
1209 /* shader 1: coissue not supported in vertex shaders */
1211 "add r0.rgb, r0, r1\n"
1212 "+add r0.a, r0, r2\n",
1213 /* shader 2: coissue not supported in pixel shader version >= 2.0 */
1215 "texld r0, t0, s0\n"
1216 "add r0.rgb, r0, r1\n"
1217 "+add r0.a, r0, v1\n",
1218 /* shader 3: predicates not supported in vertex shader < 2.0 */
1220 "(p0) add r0, r0, v0\n",
1221 /* shader 4: register a0 doesn't exist in pixel shaders */
1223 "mov r0, v[ a0 + 12 ]\n",
1224 /* shader 5: s0 doesn't exist in vs_1_1 */
1227 /* shader 6: aL is a scalar register, no swizzles allowed */
1229 "mov r0, v[ aL.x + 12 ]\n",
1230 /* shader 7: tn doesn't exist in ps_3_0 */
1233 "texldd r0, t1, s2, v3, v4\n",
1234 /* shader 8: two shift modifiers */
1236 "mov_x2_x2 r0, r1\n",
1237 /* shader 9: too many source registers for mov instruction */
1240 /* shader 10: invalid combination of negate and divide modifiers */
1242 "texld r5, -r2_dz\n",
1243 /* shader 11: complement modifier not allowed in >= PS 2 */
1246 /* shader 12: invalid modifier */
1249 /* shader 13: float value in relative addressing */
1251 "mov r2, c[ aL + 3.4 ]\n",
1252 /* shader 14: complement modifier not available in VS */
1255 /* shader 15: _x2 modifier not available in VS */
1258 /* shader 16: _abs modifier not available in < VS 3.0 */
1261 /* shader 17: _x2 modifier not available in >= PS 2.0 */
1264 /* shader 18: wrong swizzle */
1266 "mov r0, r1.abcd\n",
1267 /* shader 19: wrong swizzle */
1269 "mov r0, r1.xyzwx\n",
1270 /* shader 20: wrong swizzle */
1273 /* shader 21: invalid writemask */
1275 "mov r0.xxyz, r1\n",
1276 /* shader 22: register r5 doesn't exist in PS < 1.4 */
1279 /* shader 23: can't declare output registers in a pixel shader */
1281 "dcl_positiont o0\n",
1282 /* shader 24: _pp instruction modifier not allowed in vertex shaders */
1284 "add_pp r0, r0, r1\n",
1285 /* shader 25: _x4 instruction modified not allowed in > ps_1_x */
1287 "add_x4 r0, r0, r1\n",
1288 /* shader 26: there aren't oCx registers in ps_1_x */
1290 "add oC0, r0, r1\n",
1291 /* shader 27: oC3 is the max in >= ps_2_0 */
1293 "add oC4, r0, r1\n",
1294 /* shader 28: register v17 doesn't exist */
1296 "add r0, r0, v17\n",
1297 /* shader 29: register o13 doesn't exist */
1299 "add o13, r0, r1\n",
1300 /* shader 30: label > 2047 not allowed */
1303 /* shader 31: s20 register does not exist */
1305 "texld r0, r1, s20\n",
1306 /* shader 32: t5 not allowed in ps_1_3 */
1309 /* shader 33: no temporary registers relative addressing */
1311 "add r0, r0[ a0.x ], r1\n",
1312 /* shader 34: no input registers relative addressing in vs_2_0 */
1314 "add r0, v[ a0.x ], r1\n",
1315 /* shader 35: no aL register in ps_2_0 */
1317 "add r0, v[ aL ], r1\n",
1318 /* shader 36: no relative addressing in ps_2_0 */
1320 "add r0, v[ r0 ], r1\n",
1321 /* shader 37: no a0 register in ps_3_0 */
1323 "add r0, v[ a0.x ], r1\n",
1324 /* shader 38: only a0.x accepted in vs_1_1 */
1326 "mov r0, c0[ a0 ]\n",
1327 /* shader 39: invalid modifier for dcl instruction */
1329 "dcl_texcoord0_sat v0\n",
1330 /* shader 40: shift not allowed */
1332 "dcl_texcoord0_x2 v0\n",
1333 /* shader 41: no modifier allowed with dcl instruction in vs */
1335 "dcl_texcoord0_centroid v0\n",
1336 /* shader 42: no modifiers with vs dcl sampler instruction */
1342 LPD3DXBUFFER shader
,messages
;
1344 for(i
= 0; i
< (sizeof(tests
) / sizeof(tests
[0])); i
++) {
1347 hr
= D3DXAssembleShader(tests
[i
], strlen(tests
[i
]),
1348 NULL
, NULL
, D3DXSHADER_SKIPVALIDATION
,
1349 &shader
, &messages
);
1350 ok(hr
== D3DXERR_INVALIDDATA
, "Failure test, shader %d: "
1351 "expected D3DXAssembleShader failure with D3DXERR_INVALIDDATA, "
1352 "got 0x%x - %d\n", i
, hr
, hr
& 0x0000FFFF);
1354 trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages
));
1355 ID3DXBuffer_Release(messages
);
1358 DWORD
*res
= ID3DXBuffer_GetBufferPointer(shader
);
1360 ID3DXBuffer_Release(shader
);
1366 static HRESULT WINAPI
testD3DXInclude_open(ID3DXInclude
*iface
,
1367 D3DXINCLUDE_TYPE include_type
,
1368 LPCSTR filename
, LPCVOID parent_data
,
1369 LPCVOID
*data
, UINT
*bytes
) {
1371 char include
[] = "#define REGISTER r0\nvs.1.1\n";
1373 trace("filename = %s\n",filename
);
1375 buffer
= HeapAlloc(GetProcessHeap(), 0, sizeof(include
));
1376 CopyMemory(buffer
, include
, sizeof(include
));
1378 *bytes
= sizeof(include
);
1382 static HRESULT WINAPI
testD3DXInclude_close(ID3DXInclude
*iface
, LPCVOID data
) {
1383 HeapFree(GetProcessHeap(), 0, (LPVOID
)data
);
1387 static const struct ID3DXIncludeVtbl D3DXInclude_Vtbl
= {
1388 testD3DXInclude_open
,
1389 testD3DXInclude_close
1392 struct D3DXIncludeImpl
{
1393 const ID3DXIncludeVtbl
*lpVtbl
;
1396 static void assembleshader_test(void) {
1397 const char test1
[] = {
1401 const char testincl
[] = {
1402 "#define REGISTER r0\n"
1405 const char testshader
[] = {
1406 "#include \"incl.vsh\"\n"
1407 "mov REGISTER, v0\n"
1410 LPD3DXBUFFER shader
, messages
;
1411 D3DXMACRO defines
[] = {
1422 struct D3DXIncludeImpl include
;
1423 HRESULT shader_vsh_res
, incl_vsh_res
;
1428 hr
= D3DXAssembleShader(test1
, strlen(test1
),
1429 defines
, NULL
, D3DXSHADER_SKIPVALIDATION
,
1430 &shader
, &messages
);
1431 ok(hr
== D3D_OK
, "pDefines test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1433 trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages
));
1434 ID3DXBuffer_Release(messages
);
1436 if(shader
) ID3DXBuffer_Release(shader
);
1441 include
.lpVtbl
= &D3DXInclude_Vtbl
;
1442 hr
= D3DXAssembleShader(testshader
, strlen(testshader
),
1443 NULL
, (LPD3DXINCLUDE
)&include
, D3DXSHADER_SKIPVALIDATION
,
1444 &shader
, &messages
);
1445 ok(hr
== D3D_OK
, "pInclude test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1447 trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages
));
1448 ID3DXBuffer_Release(messages
);
1450 if(shader
) ID3DXBuffer_Release(shader
);
1454 shader_vsh_res
= create_file("shader.vsh", testshader
, sizeof(testshader
));
1455 if(SUCCEEDED(shader_vsh_res
)) {
1456 incl_vsh_res
= create_file("incl.vsh", testincl
, sizeof(testincl
));
1457 if(SUCCEEDED(incl_vsh_res
)) {
1458 /* D3DXAssembleShaderFromFile + #include test */
1461 hr
= D3DXAssembleShaderFromFileA("shader.vsh",
1462 NULL
, NULL
, D3DXSHADER_SKIPVALIDATION
,
1463 &shader
, &messages
);
1464 ok(hr
== D3D_OK
, "D3DXAssembleShaderFromFile test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1466 trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages
));
1467 ID3DXBuffer_Release(messages
);
1469 if(shader
) ID3DXBuffer_Release(shader
);
1470 } else skip("Couldn't create \"incl.vsh\"\n");
1472 /* D3DXAssembleShaderFromFile + pInclude test */
1475 hr
= D3DXAssembleShaderFromFileA("shader.vsh",
1476 NULL
, (LPD3DXINCLUDE
)&include
, D3DXSHADER_SKIPVALIDATION
,
1477 &shader
, &messages
);
1478 ok(hr
== D3D_OK
, "D3DXAssembleShaderFromFile + pInclude test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1480 trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages
));
1481 ID3DXBuffer_Release(messages
);
1483 if(shader
) ID3DXBuffer_Release(shader
);
1484 } else skip("Couldn't create \"shader.vsh\"\n");
1488 /* NULL shader tests */
1491 hr
= D3DXAssembleShader(NULL
, 0,
1492 NULL
, NULL
, D3DXSHADER_SKIPVALIDATION
,
1493 &shader
, &messages
);
1494 ok(hr
== D3DXERR_INVALIDDATA
, "NULL shader test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1496 trace("D3DXAssembleShader messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages
));
1497 ID3DXBuffer_Release(messages
);
1499 if(shader
) ID3DXBuffer_Release(shader
);
1505 hr
= D3DXAssembleShaderFromFileA("nonexistent.vsh",
1506 NULL
, NULL
, D3DXSHADER_SKIPVALIDATION
,
1507 &shader
, &messages
);
1508 ok(hr
== D3DXERR_INVALIDDATA
|| hr
== E_FAIL
, /* I get this on WinXP */
1509 "D3DXAssembleShaderFromFile nonexistent file test failed with error 0x%x - %d\n",
1510 hr
, hr
& 0x0000FFFF);
1512 trace("D3DXAssembleShaderFromFile messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages
));
1513 ID3DXBuffer_Release(messages
);
1515 if(shader
) ID3DXBuffer_Release(shader
);
1517 } /* end of todo_wine */
1519 /* D3DXAssembleShaderFromResource test */
1522 hr
= D3DXAssembleShaderFromResourceA(NULL
, MAKEINTRESOURCEA(IDB_ASMSHADER
),
1523 NULL
, NULL
, D3DXSHADER_SKIPVALIDATION
,
1524 &shader
, &messages
);
1525 ok(hr
== D3D_OK
, "D3DXAssembleShaderFromResource test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1527 trace("D3DXAssembleShaderFromResource messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages
));
1528 ID3DXBuffer_Release(messages
);
1530 if(shader
) ID3DXBuffer_Release(shader
);
1532 /* D3DXAssembleShaderFromResource with missing shader resource test */
1535 hr
= D3DXAssembleShaderFromResourceA(NULL
, "notexisting",
1536 NULL
, NULL
, D3DXSHADER_SKIPVALIDATION
,
1537 &shader
, &messages
);
1538 ok(hr
== D3DXERR_INVALIDDATA
, "D3DXAssembleShaderFromResource NULL shader test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1540 trace("D3DXAssembleShaderFromResource messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages
));
1541 ID3DXBuffer_Release(messages
);
1543 if(shader
) ID3DXBuffer_Release(shader
);
1546 if(SUCCEEDED(shader_vsh_res
)) {
1547 DeleteFileA("shader.vsh");
1548 if(SUCCEEDED(incl_vsh_res
)) DeleteFileA("incl.vsh");
1555 todo_wine
ps_1_1_test();
1557 todo_wine
ps_1_3_test();
1558 todo_wine
ps_1_4_test();
1568 assembleshader_test();