2 * Copyright (C) 2010 Matteo Bruni
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 <d3d9types.h>
22 #include <d3dcommon.h>
23 #include <d3dcompiler.h>
25 /* TODO: maybe this is defined in some header file,
26 perhaps with a different name? */
27 #define D3DXERR_INVALIDDATA 0x88760b59
29 HRESULT WINAPI
D3DAssemble(LPCVOID data
, SIZE_T datasize
, LPCSTR filename
,
30 const D3D_SHADER_MACRO
*defines
, LPD3DINCLUDE include
,
32 LPD3DBLOB
* shader
, LPD3DBLOB
* error_messages
);
36 const DWORD bytes
[128];
39 static void dump_shader(DWORD
*shader
) {
40 unsigned int i
= 0, j
= 0;
42 trace("0x%08x ", shader
[i
]);
45 if(j
== 6) trace("\n");
46 } while(shader
[i
- 1] != D3DSIO_END
);
47 if(j
!= 6) trace("\n");
50 static void exec_tests(const char *name
, struct shader_test tests
[], unsigned int count
) {
55 LPD3DBLOB shader
, messages
;
57 for(i
= 0; i
< count
; i
++) {
58 /* D3DAssemble sets messages to 0 if there aren't error messages */
60 hr
= D3DAssemble(tests
[i
].text
, strlen(tests
[i
].text
), NULL
,
61 NULL
, NULL
, D3DCOMPILE_SKIP_VALIDATION
,
63 ok(hr
== S_OK
, "Test %s, shader %d: D3DAssemble failed with error 0x%x - %d\n", name
, i
, hr
, hr
& 0x0000FFFF);
65 trace("D3DAssemble messages:\n%s", (char *)ID3D10Blob_GetBufferPointer(messages
));
66 ID3D10Blob_Release(messages
);
68 if(FAILED(hr
)) continue;
72 res
= ID3D10Blob_GetBufferPointer(shader
);
73 while(res
[j
] != D3DSIO_END
&& tests
[i
].bytes
[j
] != D3DSIO_END
) {
74 if(res
[j
] != tests
[i
].bytes
[j
]) diff
= TRUE
;
77 /* Both must have an end token */
78 if(res
[j
] != tests
[i
].bytes
[j
]) diff
= TRUE
;
81 ok(FALSE
, "Test %s, shader %d: Generated code differs\n", name
, i
);
84 ID3D10Blob_Release(shader
);
88 static void preproc_test(void) {
89 struct shader_test tests
[] = {
94 "; yet another comment\r\n"
96 {0xfffe0101, 0x00000002, 0x800f0000, 0x80e40000, 0x80e40001, 0x0000ffff}
99 "#line 1 \"vertex.vsh\"\n"
101 {0xfffe0101, 0x0000ffff}
104 "#define REG 1 + 2 +\\\n"
107 "mov r0, c0[ REG ]\n",
108 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e4000a, 0x0000ffff}
112 exec_tests("preproc", tests
, sizeof(tests
) / sizeof(tests
[0]));
115 static void ps_1_1_test(void) {
116 struct shader_test tests
[] = {
120 "add r0.rgb, r0, r1\r\n"
122 {0xffff0101, 0x00000042, 0xb00f0000, 0x00000002, 0x80070000, 0x80e40000,
123 0x80e40001, 0x40000001, 0x80080000, 0xb0e40000, 0x0000ffff}
128 {0xffff0101, 0x00000001, 0x8e0f0000, 0x80e40001, 0x0000ffff}
132 "def c2, 0, 0., 0, 0.\n",
133 {0xffff0101, 0x00000051, 0xa00f0002, 0x00000000, 0x00000000, 0x00000000,
134 0x00000000, 0x0000ffff}
138 exec_tests("ps_1_1", tests
, sizeof(tests
) / sizeof(tests
[0]));
141 static void vs_1_1_test(void) {
142 struct shader_test tests
[] = {
143 /* Basic instruction tests */
147 {0xfffe0101, 0x00000002, 0x800f0000, 0x80e40001, 0x80e40002, 0x0000ffff}
152 {0xfffe0101, 0x00000000, 0x0000ffff}
154 /* Output register tests */
158 {0xfffe0101, 0x00000001, 0xc00f0000, 0xa0e40000, 0x0000ffff}
163 {0xfffe0101, 0x00000001, 0xe00f0000, 0xa0e40000, 0x0000ffff}
168 {0xfffe0101, 0x00000001, 0xe00f0005, 0xa0e40000, 0x0000ffff}
173 {0xfffe0101, 0x00000001, 0xd00f0000, 0xa0e40000, 0x0000ffff}
178 {0xfffe0101, 0x00000001, 0xd00f0001, 0xa0e40000, 0x0000ffff}
183 {0xfffe0101, 0x00000001, 0xc00f0001, 0xa0000000, 0x0000ffff}
188 {0xfffe0101, 0x00000001, 0xc00f0002, 0xa0000000, 0x0000ffff}
190 /* A bunch of tests for declarations */
194 {0xfffe0101, 0x0000001f, 0x80000000, 0x900f0000, 0x0000ffff}
199 {0xfffe0101, 0x0000001f, 0x80000000, 0x900f0001, 0x0000ffff}
204 {0xfffe0101, 0x0000001f, 0x800c0003, 0x900f000f, 0x0000ffff}
209 {0xfffe0101, 0x00000002, 0x800f0000, 0x90e40000, 0x90e40001, 0x0000ffff}
213 "def c12, 0, -1, -0.5, 1024\n",
214 {0xfffe0101, 0x00000051, 0xa00f000c, 0x00000000, 0xbf800000, 0xbf000000,
215 0x44800000, 0x0000ffff}
217 { /* shader 14: writemasks, swizzles */
219 "dp4 r0.xw, r1.wzyx, r2.xxww\n",
220 {0xfffe0101, 0x00000009, 0x80090000, 0x801b0001, 0x80f00002, 0x0000ffff}
222 { /* shader 15: negation input modifier. Other modifiers not supprted in vs_1_1 */
224 "add r0, -r0.x, -r1\n",
225 {0xfffe0101, 0x00000002, 0x800f0000, 0x81000000, 0x81e40001, 0x0000ffff}
227 { /* shader 16: relative addressing */
229 "mov r0, c0[a0.x]\n",
230 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e42000, 0x0000ffff}
232 { /* shader 17: relative addressing */
234 "mov r0, c1[a0.x + 2]\n",
235 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e42003, 0x0000ffff}
239 "def c0, 1.0f, 1.0f, 1.0f, 0.5f\n",
240 {0xfffe0101, 0x00000051, 0xa00f0000, 0x3f800000, 0x3f800000, 0x3f800000,
241 0x3f000000, 0x0000ffff}
243 /* Other relative addressing tests */
246 "mov r0, c[ a0.x + 12 ]\n",
247 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e4200c, 0x0000ffff}
251 "mov r0, c[ 2 + a0.x ]\n",
252 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e42002, 0x0000ffff}
256 "mov r0, c[ 2 + a0.x + 12 ]\n",
257 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e4200e, 0x0000ffff}
261 "mov r0, c[ 2 + 10 + 12 ]\n",
262 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e40018, 0x0000ffff}
267 {0xfffe0101, 0x00000001, 0x800f0000, 0xa0e40006, 0x0000ffff}
272 {0xfffe0101, 0x00000006, 0x800f0000, 0x90000000, 0x0000ffff}
277 {0xfffe0101, 0x00000007, 0x800f0000, 0x90000000, 0x0000ffff}
281 exec_tests("vs_1_1", tests
, sizeof(tests
) / sizeof(tests
[0]));
284 static void ps_1_3_test(void) {
285 struct shader_test tests
[] = {
286 /* Basic instruction tests */
290 {0xffff0103, 0x00000001, 0x800f0000, 0x80e40001, 0x0000ffff}
295 {0xffff0103, 0x00000002, 0x800f0000, 0x80e40001, 0x80e40000, 0x0000ffff}
297 /* Color interpolator tests */
301 {0xffff0103, 0x00000001, 0x800f0000, 0x90e40000, 0x0000ffff}
306 {0xffff0103, 0x00000001, 0x800f0000, 0x90e40001, 0x0000ffff}
308 /* Texture sampling instructions */
312 {0xffff0103, 0x00000042, 0xb00f0000, 0x0000ffff}
317 "texreg2ar t1, t0\n",
318 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000045, 0xb00f0001, 0xb0e40000,
324 "texreg2gb t1, t0\n",
325 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000046, 0xb00f0001, 0xb0e40000,
331 "texreg2rgb t1, t0\n",
332 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000052, 0xb00f0001, 0xb0e40000,
337 "cnd r0, r1, r0, v0\n",
338 {0xffff0103, 0x00000050, 0x800f0000, 0x80e40001, 0x80e40000, 0x90e40000,
343 "cmp r0, r1, r0, v0\n",
344 {0xffff0103, 0x00000058, 0x800f0000, 0x80e40001, 0x80e40000, 0x90e40000,
350 {0xffff0103, 0x00000041, 0xb00f0000, 0x0000ffff}
355 "texm3x2pad t1, t0\n"
356 "texm3x2tex t2, t0\n",
357 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000047, 0xb00f0001, 0xb0e40000,
358 0x00000048, 0xb00f0002, 0xb0e40000, 0x0000ffff}
363 "texm3x2pad t1, t0\n"
364 "texm3x2depth t2, t0\n",
365 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000047, 0xb00f0001, 0xb0e40000,
366 0x00000054, 0xb00f0002, 0xb0e40000, 0x0000ffff}
372 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000043, 0xb00f0001, 0xb0e40000,
379 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000044, 0xb00f0001, 0xb0e40000,
385 "texdp3tex t1, t0\n",
386 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000053, 0xb00f0001, 0xb0e40000,
393 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000055, 0xb00f0001, 0xb0e40000,
399 "texm3x3pad t1, t0\n"
400 "texm3x3pad t2, t0\n"
401 "texm3x3tex t3, t0\n",
402 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb00f0001, 0xb0e40000,
403 0x00000049, 0xb00f0002, 0xb0e40000, 0x0000004a, 0xb00f0003, 0xb0e40000,
409 "texm3x3pad t1, t0\n"
410 "texm3x3pad t2, t0\n"
412 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb00f0001, 0xb0e40000,
413 0x00000049, 0xb00f0002, 0xb0e40000, 0x00000056, 0xb00f0003, 0xb0e40000,
419 "texm3x3pad t1, t0\n"
420 "texm3x3pad t2, t0\n"
421 "texm3x3spec t3, t0, c0\n",
422 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb00f0001, 0xb0e40000,
423 0x00000049, 0xb00f0002, 0xb0e40000, 0x0000004c, 0xb00f0003, 0xb0e40000,
424 0xa0e40000, 0x0000ffff}
429 "texm3x3pad t1, t0\n"
430 "texm3x3pad t2, t0\n"
431 "texm3x3vspec t3, t0\n",
432 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb00f0001, 0xb0e40000,
433 0x00000049, 0xb00f0002, 0xb0e40000, 0x0000004d, 0xb00f0003, 0xb0e40000,
439 {0xffff0103, 0x00000040, 0xb00f0000, 0x0000ffff}
441 /* Modifiers, shifts */
444 "mov_x2_sat r0, 1 - r1\n",
445 {0xffff0103, 0x00000001, 0x811f0000, 0x86e40001, 0x0000ffff}
450 {0xffff0103, 0x00000001, 0x8d0f0000, 0x81e40001, 0x0000ffff}
454 "mov_sat r0, r1_bx2\n",
455 {0xffff0103, 0x00000001, 0x801f0000, 0x84e40001, 0x0000ffff}
459 "mov_sat r0, r1_bias\n",
460 {0xffff0103, 0x00000001, 0x801f0000, 0x82e40001, 0x0000ffff}
464 "mov_sat r0, -r1_bias\n",
465 {0xffff0103, 0x00000001, 0x801f0000, 0x83e40001, 0x0000ffff}
469 "mov_sat r0, -r1_bx2\n",
470 {0xffff0103, 0x00000001, 0x801f0000, 0x85e40001, 0x0000ffff}
474 "mov_sat r0, -r1_x2\n",
475 {0xffff0103, 0x00000001, 0x801f0000, 0x88e40001, 0x0000ffff}
479 "mov_x4_sat r0.a, -r1_bx2.a\n",
480 {0xffff0103, 0x00000001, 0x82180000, 0x85ff0001, 0x0000ffff}
485 {0xffff0103, 0x00000040, 0xb10f0000, 0x0000ffff}
490 {0xffff0103, 0x00000042, 0xb10f0000, 0x0000ffff}
494 "texreg2ar_x4 t0, t1\n",
495 {0xffff0103, 0x00000045, 0xb20f0000, 0xb0e40001, 0x0000ffff}
499 "texbem_d4 t1, t0\n",
500 {0xffff0103, 0x00000043, 0xbe0f0001, 0xb0e40000, 0x0000ffff}
505 "texm3x3pad_x2 t1, t0\n"
506 "texm3x3pad_x2 t2, t0\n"
507 "texm3x3tex_x2 t3, t0\n",
508 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000049, 0xb10f0001, 0xb0e40000,
509 0x00000049, 0xb10f0002, 0xb0e40000, 0x0000004a, 0xb10f0003, 0xb0e40000,
515 "texdp3tex_x8 t1, t0\n",
516 {0xffff0103, 0x00000042, 0xb00f0000, 0x00000053, 0xb30f0001, 0xb0e40000,
521 exec_tests("ps_1_3", tests
, sizeof(tests
) / sizeof(tests
[0]));
524 static void ps_1_4_test(void) {
525 struct shader_test tests
[] = {
526 /* Basic instruction tests */
530 {0xffff0104, 0x00000001, 0x800f0000, 0x80e40001, 0x0000ffff}
535 {0xffff0104, 0x00000001, 0x800f0000, 0x80e40005, 0x0000ffff}
540 {0xffff0104, 0x00000001, 0x800f0000, 0xa0e40007, 0x0000ffff}
545 {0xffff0104, 0x00000001, 0x800f0000, 0x90e40001, 0x0000ffff}
550 {0xffff0104, 0x0000fffd, 0x0000ffff}
555 {0xffff0104, 0x00000040, 0x800f0000, 0xb0e40000, 0x0000ffff}
560 {0xffff0104, 0x00000040, 0x800f0004, 0xb0e40003, 0x0000ffff}
564 "texcrd_sat r4, t3\n",
565 {0xffff0104, 0x00000040, 0x801f0004, 0xb0e40003, 0x0000ffff}
570 {0xffff0104, 0x00000042, 0x800f0000, 0xb0e40000, 0x0000ffff}
575 {0xffff0104, 0x00000042, 0x800f0001, 0xb0e40004, 0x0000ffff}
580 {0xffff0104, 0x00000042, 0x800f0005, 0x80e40000, 0x0000ffff}
584 "texld r5, c0\n", /* Assembly succeeds, validation fails */
585 {0xffff0104, 0x00000042, 0x800f0005, 0xa0e40000, 0x0000ffff}
590 {0xffff0104, 0x00000042, 0x800f0005, 0x89e40002, 0x0000ffff}
594 "bem r1.rg, c0, r0\n",
595 {0xffff0104, 0x00000059, 0x80030001, 0xa0e40000, 0x80e40000, 0x0000ffff}
600 {0xffff0104, 0x00000057, 0x800f0005, 0x0000ffff}
604 "add r0, r1, r2_bx2\n",
605 {0xffff0104, 0x00000002, 0x800f0000, 0x80e40001, 0x84e40002, 0x0000ffff}
609 "add_x4 r0, r1, r2\n",
610 {0xffff0104, 0x00000002, 0x820f0000, 0x80e40001, 0x80e40002, 0x0000ffff}
614 "add r0.rgb, r1, r2\n"
615 "+add r0.a, r1, r2\n",
616 {0xffff0104, 0x00000002, 0x80070000, 0x80e40001, 0x80e40002, 0x40000002,
617 0x80080000, 0x80e40001, 0x80e40002, 0x0000ffff}
622 {0xffff0104, 0x00000057, 0x810f0005, 0x0000ffff}
626 "bem_d2 r1, c0, r0\n",
627 {0xffff0104, 0x00000059, 0x8f0f0001, 0xa0e40000, 0x80e40000, 0x0000ffff}
631 exec_tests("ps_1_4", tests
, sizeof(tests
) / sizeof(tests
[0]));
634 static void vs_2_0_test(void) {
635 struct shader_test tests
[] = {
636 /* Basic instruction tests */
640 {0xfffe0200, 0x02000001, 0x800f0000, 0x80e40001, 0x0000ffff}
644 "lrp r0, v0, c0, r1\n",
645 {0xfffe0200, 0x04000012, 0x800f0000, 0x90e40000, 0xa0e40000, 0x80e40001,
650 "dp4 oPos, v0, c0\n",
651 {0xfffe0200, 0x03000009, 0xc00f0000, 0x90e40000, 0xa0e40000, 0x0000ffff}
655 "mov r0, c0[a0.x]\n",
656 {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0000000, 0x0000ffff}
660 "mov r0, c0[a0.y]\n",
661 {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0550000, 0x0000ffff}
665 "mov r0, c0[a0.z]\n",
666 {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0aa0000, 0x0000ffff}
670 "mov r0, c0[a0.w]\n",
671 {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0ff0000, 0x0000ffff}
675 "mov r0, c0[a0.w].x\n",
676 {0xfffe0200, 0x03000001, 0x800f0000, 0xa0002000, 0xb0ff0000, 0x0000ffff}
680 "mov r0, -c0[a0.w+5].x\n",
681 {0xfffe0200, 0x03000001, 0x800f0000, 0xa1002005, 0xb0ff0000, 0x0000ffff}
686 {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0e40000, 0x0000ffff}
690 "mov r0, c0[a0.xyww]\n",
691 {0xfffe0200, 0x03000001, 0x800f0000, 0xa0e42000, 0xb0f40000, 0x0000ffff}
695 "add r0, c0[a0.x], c1[a0.y]\n", /* validation would fail on this line */
696 {0xfffe0200, 0x05000002, 0x800f0000, 0xa0e42000, 0xb0000000, 0xa0e42001,
697 0xb0550000, 0x0000ffff}
703 {0xfffe0200, 0x01000026, 0xf0e40000, 0x00000027, 0x0000ffff}
710 {0xfffe0200, 0x01000028, 0xe0e40800, 0x0000002a, 0x0000002b, 0x0000ffff}
716 {0xfffe0200, 0x0200001b, 0xf0e40800, 0xf0e40000, 0x0000001d, 0x0000ffff}
721 {0xfffe0200, 0x02000024, 0x800f0000, 0xa0e40000, 0x0000ffff}
726 {0xfffe0200, 0x03000021, 0x800f0000, 0x80e40001, 0x80e40002, 0x0000ffff}
730 "sgn r0, r1, r2, r3\n",
731 {0xfffe0200, 0x04000022, 0x800f0000, 0x80e40001, 0x80e40002, 0x80e40003,
736 "sincos r0, r1, r2, r3\n",
737 {0xfffe0200, 0x04000025, 0x800f0000, 0x80e40001, 0x80e40002, 0x80e40003,
743 {0xfffe0200, 0x03000020, 0x800f0000, 0x80e40001, 0x80e40002, 0x0000ffff}
748 {0xfffe0200, 0x0200002e, 0xb0020000, 0xa0aa0000, 0x0000ffff}
754 {0xfffe0200, 0x0200002f, 0xe00f0800, 0x00000001, 0x0200002f, 0xe00f0801,
755 0x00000000, 0x0000ffff}
759 "defi i0, -1, 1, 10, 0\n"
760 "defi i1, 0, 40, 30, 10\n",
761 {0xfffe0200, 0x05000030, 0xf00f0000, 0xffffffff, 0x00000001, 0x0000000a,
762 0x00000000, 0x05000030, 0xf00f0001, 0x00000000, 0x00000028, 0x0000001e,
763 0x0000000a, 0x0000ffff}
770 {0xfffe0200, 0x0200001b, 0xf0e40800, 0xf0e40000, 0x03000001, 0x800f0000,
771 0xa0e42000, 0xf0e40800, 0x0000001d, 0x0000ffff}
779 {0xfffe0200, 0x01000019, 0xa0e41000, 0x0000001c, 0x0100001e, 0xa0e41000,
780 0x0000001c, 0x0000ffff}
788 {0xfffe0200, 0x0200001a, 0xa0e41000, 0xe0e40800, 0x0000001c, 0x0100001e,
789 0xa0e41000, 0x0000001c, 0x0000ffff}
797 {0xfffe0200, 0x0200001a, 0xa0e41000, 0xede40800, 0x0000001c, 0x0100001e,
798 0xa0e41000, 0x0000001c, 0x0000ffff}
805 {0xfffe0200, 0x01000028, 0xede40800, 0x0000002a, 0x0000002b, 0x0000ffff}
813 {0xfffe0200, 0x01000019, 0xa0e41003, 0x0000001c, 0x0100001e, 0xa0e41003, 0x0000001c, 0x0000ffff}
815 { /* shader 29: labels up to 2047 are accepted even in vs_2_0 */
818 {0xfffe0200, 0x01000019, 0xa0e417ff, 0x0000ffff}
822 exec_tests("vs_2_0", tests
, sizeof(tests
) / sizeof(tests
[0]));
825 static void vs_2_x_test(void) {
826 struct shader_test tests
[] = {
832 {0xfffe0201, 0x01000026, 0xf0e40000, 0x0000002c, 0x00000027, 0x0000ffff}
838 {0xfffe0201, 0x02030029, 0x80e40000, 0x80e40001, 0x0000002b, 0x0000ffff}
845 {0xfffe0201, 0x01000026, 0xf0e40000, 0x0205002d, 0x80e40000, 0x80e40001,
846 0x00000027, 0x0000ffff}
852 "setp_gt p0, r0, r1\n"
853 "(!p0) add r2, r2, r3\n",
854 {0xfffe0201, 0x0301005e, 0xb00f1000, 0x80e40000, 0x80e40001, 0x14000002,
855 0x800f0002, 0xbde41000, 0x80e40002, 0x80e40003, 0x0000ffff}
862 {0xfffe0201, 0x01000028, 0xb0001000, 0x0000002a, 0x0000002b, 0x0000ffff}
870 {0xfffe0201, 0x0200001a, 0xa0e41000, 0xbdaa1000, 0x0000001c,
871 0x0100001e, 0xa0e41000, 0x0000001c, 0x0000ffff}
878 {0xfffe0201, 0x01000026, 0xf0e40000, 0x01000060, 0xb0ff1000,
879 0x00000027, 0x0000ffff}
883 exec_tests("vs_2_x", tests
, sizeof(tests
) / sizeof(tests
[0]));
886 static void ps_2_0_test(void) {
887 struct shader_test tests
[] = {
891 {0xffff0200, 0x0200001f, 0x90000000, 0xa00f0800, 0x0000ffff}
896 {0xffff0200, 0x0200001f, 0x98000000, 0xa00f0800, 0x0000ffff}
901 {0xffff0200, 0x0200001f, 0xa0000000, 0xa00f0800, 0x0000ffff}
908 {0xffff0200, 0x0200001f, 0xa0000000, 0xa00f0800, 0x0200001f, 0x98000000,
909 0xa00f0801, 0x0200001f, 0x90000000, 0xa00f0802, 0x0000ffff}
914 {0xffff0200, 0x02000001, 0x800f0000, 0xb0e40000, 0x0000ffff}
919 "texld r0, t1, s2\n",
920 {0xffff0200, 0x0200001f, 0x90000000, 0xa00f0802, 0x03000042, 0x800f0000,
921 0xb0e40001, 0xa0e40802, 0x0000ffff}
926 {0xffff0200, 0x01000041, 0xb00f0000, 0x0000ffff}
932 {0xffff0200, 0x02000001, 0x800f0800, 0xa0e40000, 0x02000001, 0x800f0801,
933 0xa0e40001, 0x0000ffff}
937 "mov oDepth, c0.x\n",
938 {0xffff0200, 0x02000001, 0x900f0800, 0xa0000000, 0x0000ffff}
943 "texldp r0, t1, s2\n",
944 {0xffff0200, 0x0200001f, 0x90000000, 0xa00f0802, 0x03010042, 0x800f0000,
945 0xb0e40001, 0xa0e40802, 0x0000ffff}
950 "texldb r0, t1, s2\n",
951 {0xffff0200, 0x0200001f, 0x90000000, 0xa00f0802, 0x03020042, 0x800f0000,
952 0xb0e40001, 0xa0e40802, 0x0000ffff}
956 exec_tests("ps_2_0", tests
, sizeof(tests
) / sizeof(tests
[0]));
959 static void ps_2_x_test(void) {
960 struct shader_test tests
[] = {
961 /* defb and defi are not supposed to work in ps_2_0 (even if defb actually works in ps_2_0 with native) */
966 {0xffff0201, 0x0200002f, 0xe00f0800, 0x00000001, 0x0200002f, 0xe00f0801,
967 0x00000000, 0x0000ffff}
971 "defi i0, -1, 1, 10, 0\n"
972 "defi i1, 0, 40, 30, 10\n",
973 {0xffff0201, 0x05000030, 0xf00f0000, 0xffffffff, 0x00000001, 0x0000000a,
974 0x00000000, 0x05000030, 0xf00f0001, 0x00000000, 0x00000028, 0x0000001e,
975 0x0000000a, 0x0000ffff}
980 {0xffff0201, 0x0200005b, 0x800f0000, 0x80e40000, 0x0000ffff}
985 {0xffff0201, 0x0200005c, 0x800f0000, 0x80e40000, 0x0000ffff}
990 "texldd r0, v1, s2, r3, r4\n",
991 {0xffff0201, 0x0200001f, 0x90000000, 0xa00f0802, 0x0500005d, 0x800f0000,
992 0x90e40001, 0xa0e40802, 0x80e40003, 0x80e40004, 0x0000ffff}
994 /* Static flow control tests */
1001 {0xffff0201, 0x01000019, 0xa0e41000, 0x0000001c, 0x0100001e, 0xa0e41000,
1002 0x0000001c, 0x0000ffff}
1010 {0xffff0201, 0x0200001a, 0xa0e41000, 0xe0e40800, 0x0000001c, 0x0100001e,
1011 0xa0e41000, 0x0000001c, 0x0000ffff}
1019 {0xffff0201, 0x0200001a, 0xa0e41000, 0xede40800, 0x0000001c, 0x0100001e,
1020 0xa0e41000, 0x0000001c, 0x0000ffff}
1027 {0xffff0201, 0x01000028, 0xede40800, 0x0000002a, 0x0000002b, 0x0000ffff}
1029 /* Dynamic flow control tests */
1035 {0xffff0201, 0x01000026, 0xf0e40000, 0x0000002c, 0x00000027, 0x0000ffff}
1041 {0xffff0201, 0x02030029, 0x80e40000, 0x80e40001, 0x0000002b, 0x0000ffff}
1048 {0xffff0201, 0x01000026, 0xf0e40000, 0x0205002d, 0x80e40000, 0x80e40001,
1049 0x00000027, 0x0000ffff}
1054 "setp_gt p0, r0, r1\n"
1055 "(!p0) add r2, r2, r3\n",
1056 {0xffff0201, 0x0301005e, 0xb00f1000, 0x80e40000, 0x80e40001, 0x14000002,
1057 0x800f0002, 0xbde41000, 0x80e40002, 0x80e40003, 0x0000ffff}
1064 {0xffff0201, 0x01000028, 0xb0001000, 0x0000002a, 0x0000002b, 0x0000ffff}
1068 "callnz l0, !p0.z\n"
1072 {0xffff0201, 0x0200001a, 0xa0e41000, 0xbdaa1000, 0x0000001c,
1073 0x0100001e, 0xa0e41000, 0x0000001c, 0x0000ffff}
1080 {0xffff0201, 0x01000026, 0xf0e40000, 0x01000060, 0xb0ff1000,
1081 0x00000027, 0x0000ffff}
1089 {0xffff0201, 0x01000019, 0xa0e417ff, 0x0000001c, 0x0100001e, 0xa0e417ff,
1090 0x0000001c, 0x0000ffff}
1094 exec_tests("ps_2_x", tests
, sizeof(tests
) / sizeof(tests
[0]));
1097 static void vs_3_0_test(void) {
1098 struct shader_test tests
[] = {
1102 {0xfffe0300, 0x02000001, 0x800f0000, 0xa0e40000, 0x0000ffff}
1107 {0xfffe0300, 0x0200001f, 0x90000000, 0xa00f0800, 0x0000ffff}
1111 "dcl_position o0\n",
1112 {0xfffe0300, 0x0200001f, 0x80000000, 0xe00f0000, 0x0000ffff}
1116 "dcl_texcoord12 o11\n",
1117 {0xfffe0300, 0x0200001f, 0x800c0005, 0xe00f000b, 0x0000ffff}
1121 "texldl r0, v0, s0\n",
1122 {0xfffe0300, 0x0300005f, 0x800f0000, 0x90e40000, 0xa0e40800, 0x0000ffff}
1127 {0xfffe0300, 0x03000001, 0x800f0000, 0xa0e42000, 0xf0e40800, 0x0000ffff}
1131 "mov o[ a0.x + 12 ], r0\n",
1132 {0xfffe0300, 0x03000001, 0xe00f200c, 0xb0000000, 0x80e40000, 0x0000ffff}
1136 "add_sat r0, r0, r1\n",
1137 {0xfffe0300, 0x03000002, 0x801f0000, 0x80e40000, 0x80e40001, 0x0000ffff}
1142 {0xfffe0300, 0x02000001, 0x800f0002, 0x8be40001, 0x0000ffff}
1146 "mov r2, r1.xygb\n",
1147 {0xfffe0300, 0x02000001, 0x800f0002, 0x80940001, 0x0000ffff}
1152 {0xfffe0300, 0x02000001, 0x80070002, 0x80e40001, 0x0000ffff}
1156 "mova_sat a0.x, r1\n",
1157 {0xfffe0300, 0x0200002e, 0xb0110000, 0x80e40001, 0x0000ffff}
1162 {0xfffe0300, 0x02000025, 0x800f0000, 0x80e40001, 0x0000ffff}
1166 "def c0, 1.0f, 1.0f, 1.0f, 0.5f\n",
1167 {0xfffe0300, 0x05000051, 0xa00f0000, 0x3f800000, 0x3f800000, 0x3f800000,
1168 0x3f000000, 0x0000ffff}
1170 { /* shader 14: no register number checks with relative addressing */
1172 "add r0, v20[aL], r2\n",
1173 {0xfffe0300, 0x04000002, 0x800f0000, 0x90e42014, 0xf0e40800, 0x80e40002,
1179 exec_tests("vs_3_0", tests
, sizeof(tests
) / sizeof(tests
[0]));
1182 static void ps_3_0_test(void) {
1183 struct shader_test tests
[] = {
1187 {0xffff0300, 0x02000001, 0x800f0000, 0xa0e40000, 0x0000ffff}
1192 {0xffff0300, 0x0200001f, 0x80050003, 0x900f0000, 0x0000ffff}
1197 {0xffff0300, 0x02000001, 0x800f0000, 0x90e41000, 0x0000ffff}
1202 {0xffff0300, 0x02000001, 0x800f0000, 0x90e41001, 0x0000ffff}
1206 "mov r0, v[ aL + 12 ]\n",
1207 {0xffff0300, 0x03000001, 0x800f0000, 0x90e4200c, 0xf0e40800, 0x0000ffff}
1214 {0xffff0300, 0x0200001b, 0xf0e40800, 0xf0e40000, 0x03000001, 0x800f0000,
1215 0x90e42000, 0xf0e40800, 0x0000001d, 0x0000ffff}
1219 "texldl r0, v0, s0\n",
1220 {0xffff0300, 0x0300005f, 0x800f0000, 0x90e40000, 0xa0e40800, 0x0000ffff}
1224 "add_pp r0, r0, r1\n",
1225 {0xffff0300, 0x03000002, 0x802f0000, 0x80e40000, 0x80e40001, 0x0000ffff}
1230 {0xffff0300, 0x0200005b, 0x801f0000, 0x80e40001, 0x0000ffff}
1234 "texldd_pp r0, r1, r2, r3, r4\n",
1235 {0xffff0300, 0x0500005d, 0x802f0000, 0x80e40001, 0x80e40002, 0x80e40003,
1236 0x80e40004, 0x0000ffff}
1241 {0xffff0300, 0x01000041, 0x900f0000, 0x0000ffff}
1245 "add oC3, r0, r1\n",
1246 {0xffff0300, 0x03000002, 0x800f0803, 0x80e40000, 0x80e40001, 0x0000ffff}
1250 "dcl_texcoord0_centroid v0\n",
1251 {0xffff0300, 0x0200001f, 0x80000005, 0x904f0000, 0x0000ffff}
1255 "dcl_2d_centroid s0\n",
1256 {0xffff0300, 0x0200001f, 0x90000000, 0xa04f0800, 0x0000ffff}
1261 {0xffff0300, 0x0200001f, 0x90000000, 0xa02f0800, 0x0000ffff}
1265 exec_tests("ps_3_0", tests
, sizeof(tests
) / sizeof(tests
[0]));
1268 static void failure_test(void) {
1269 const char * tests
[] = {
1270 /* shader 0: instruction modifier not allowed */
1273 "texldd_x2 r0, v1, s2, v3, v4\n",
1274 /* shader 1: coissue not supported in vertex shaders */
1276 "add r0.rgb, r0, r1\n"
1277 "+add r0.a, r0, r2\n",
1278 /* shader 2: coissue not supported in pixel shader version >= 2.0 */
1280 "texld r0, t0, s0\n"
1281 "add r0.rgb, r0, r1\n"
1282 "+add r0.a, r0, v1\n",
1283 /* shader 3: predicates not supported in vertex shader < 2.0 */
1285 "(p0) add r0, r0, v0\n",
1286 /* shader 4: register a0 doesn't exist in pixel shaders */
1288 "mov r0, v[ a0 + 12 ]\n",
1289 /* shader 5: s0 doesn't exist in vs_1_1 */
1292 /* shader 6: aL is a scalar register, no swizzles allowed */
1294 "mov r0, v[ aL.x + 12 ]\n",
1295 /* shader 7: tn doesn't exist in ps_3_0 */
1298 "texldd r0, t1, s2, v3, v4\n",
1299 /* shader 8: two shift modifiers */
1301 "mov_x2_x2 r0, r1\n",
1302 /* shader 9: too many source registers for mov instruction */
1305 /* shader 10: invalid combination of negate and divide modifiers */
1307 "texld r5, -r2_dz\n",
1308 /* shader 11: complement modifier not allowed in >= PS 2 */
1311 /* shader 12: invalid modifier */
1314 /* shader 13: float value in relative addressing */
1316 "mov r2, c[ aL + 3.4 ]\n",
1317 /* shader 14: complement modifier not available in VS */
1320 /* shader 15: _x2 modifier not available in VS */
1323 /* shader 16: _abs modifier not available in < VS 3.0 */
1326 /* shader 17: _x2 modifier not available in >= PS 2.0 */
1329 /* shader 18: wrong swizzle */
1331 "mov r0, r1.abcd\n",
1332 /* shader 19: wrong swizzle */
1334 "mov r0, r1.xyzwx\n",
1335 /* shader 20: wrong swizzle */
1338 /* shader 21: invalid writemask */
1340 "mov r0.xxyz, r1\n",
1341 /* shader 22: register r5 doesn't exist in PS < 1.4 */
1344 /* shader 23: can't declare output registers in a pixel shader */
1346 "dcl_positiont o0\n",
1347 /* shader 24: _pp instruction modifier not allowed in vertex shaders */
1349 "add_pp r0, r0, r1\n",
1350 /* shader 25: _x4 instruction modified not allowed in > ps_1_x */
1352 "add_x4 r0, r0, r1\n",
1353 /* shader 26: there aren't oCx registers in ps_1_x */
1355 "add oC0, r0, r1\n",
1356 /* shader 27: oC3 is the max in >= ps_2_0 */
1358 "add oC4, r0, r1\n",
1359 /* shader 28: register v17 doesn't exist */
1361 "add r0, r0, v17\n",
1362 /* shader 29: register o13 doesn't exist */
1364 "add o13, r0, r1\n",
1365 /* shader 30: label > 2047 not allowed */
1368 /* shader 31: s20 register does not exist */
1370 "texld r0, r1, s20\n",
1371 /* shader 32: t5 not allowed in ps_1_3 */
1374 /* shader 33: no temporary registers relative addressing */
1376 "add r0, r0[ a0.x ], r1\n",
1377 /* shader 34: no input registers relative addressing in vs_2_0 */
1379 "add r0, v[ a0.x ], r1\n",
1380 /* shader 35: no aL register in ps_2_0 */
1382 "add r0, v[ aL ], r1\n",
1383 /* shader 36: no relative addressing in ps_2_0 */
1385 "add r0, v[ r0 ], r1\n",
1386 /* shader 37: no a0 register in ps_3_0 */
1388 "add r0, v[ a0.x ], r1\n",
1389 /* shader 38: only a0.x accepted in vs_1_1 */
1391 "mov r0, c0[ a0 ]\n",
1392 /* shader 39: invalid modifier for dcl instruction */
1394 "dcl_texcoord0_sat v0\n",
1395 /* shader 40: shift not allowed */
1397 "dcl_texcoord0_x2 v0\n",
1398 /* shader 41: no modifier allowed with dcl instruction in vs */
1400 "dcl_texcoord0_centroid v0\n",
1401 /* shader 42: no modifiers with vs dcl sampler instruction */
1406 "texm3x3vspec t3, t0\n",
1410 LPD3DBLOB shader
, messages
;
1412 for(i
= 0; i
< (sizeof(tests
) / sizeof(tests
[0])); i
++) {
1415 hr
= D3DAssemble(tests
[i
], strlen(tests
[i
]), NULL
,
1416 NULL
, NULL
, D3DCOMPILE_SKIP_VALIDATION
,
1417 &shader
, &messages
);
1418 ok(hr
== D3DXERR_INVALIDDATA
, "Failure test, shader %d: "
1419 "expected D3DAssemble failure with D3DXERR_INVALIDDATA, "
1420 "got 0x%x - %d\n", i
, hr
, hr
& 0x0000FFFF);
1422 trace("D3DAssemble messages:\n%s", (char *)ID3D10Blob_GetBufferPointer(messages
));
1423 ID3D10Blob_Release(messages
);
1426 DWORD
*res
= ID3D10Blob_GetBufferPointer(shader
);
1428 ID3D10Blob_Release(shader
);
1433 static HRESULT WINAPI
testD3DInclude_open(ID3DInclude
*iface
, D3D_INCLUDE_TYPE include_type
,
1434 const char *filename
, const void *parent_data
, const void **data
, UINT
*bytes
)
1437 char include
[] = "#define REGISTER r0\nvs.1.1\n";
1438 char include2
[] = "#include \"incl3.vsh\"\n";
1439 char include3
[] = "vs.1.1\n";
1441 trace("filename %s\n", filename
);
1442 trace("parent_data (%p) -> %s\n", parent_data
, (char *)parent_data
);
1444 if (!strcmp(filename
, "incl.vsh"))
1446 buffer
= HeapAlloc(GetProcessHeap(), 0, sizeof(include
));
1447 CopyMemory(buffer
, include
, sizeof(include
));
1448 *bytes
= sizeof(include
);
1450 else if (!strcmp(filename
, "incl3.vsh"))
1452 buffer
= HeapAlloc(GetProcessHeap(), 0, sizeof(include3
));
1453 CopyMemory(buffer
, include3
, sizeof(include3
));
1454 *bytes
= sizeof(include3
);
1455 /* Also check for the correct parent_data content */
1456 ok(parent_data
!= NULL
&& !strncmp(include2
, parent_data
, strlen(include2
)), "wrong parent_data value\n");
1460 buffer
= HeapAlloc(GetProcessHeap(), 0, sizeof(include2
));
1461 CopyMemory(buffer
, include2
, sizeof(include2
));
1462 *bytes
= sizeof(include2
);
1470 static HRESULT WINAPI
testD3DInclude_close(ID3DInclude
*iface
, const void *data
)
1472 HeapFree(GetProcessHeap(), 0, (LPVOID
)data
);
1476 static const struct ID3DIncludeVtbl D3DInclude_Vtbl
=
1478 testD3DInclude_open
,
1479 testD3DInclude_close
1482 struct D3DIncludeImpl
{
1483 const ID3DIncludeVtbl
*lpVtbl
;
1486 static void assembleshader_test(void) {
1487 const char test1
[] = {
1491 const char testshader
[] = {
1492 "#include \"incl.vsh\"\n"
1493 "mov REGISTER, v0\n"
1496 LPD3DBLOB shader
, messages
;
1497 D3D_SHADER_MACRO defines
[] = {
1508 struct D3DIncludeImpl include
;
1513 hr
= D3DAssemble(test1
, strlen(test1
), NULL
,
1514 defines
, NULL
, D3DCOMPILE_SKIP_VALIDATION
,
1515 &shader
, &messages
);
1516 ok(hr
== S_OK
, "defines test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1518 trace("D3DAssemble messages:\n%s", (char *)ID3D10Blob_GetBufferPointer(messages
));
1519 ID3D10Blob_Release(messages
);
1521 if(shader
) ID3D10Blob_Release(shader
);
1523 /* NULL messages test */
1525 hr
= D3DAssemble(test1
, strlen(test1
), NULL
,
1526 defines
, NULL
, D3DCOMPILE_SKIP_VALIDATION
,
1528 ok(hr
== S_OK
, "NULL messages test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1529 if(shader
) ID3D10Blob_Release(shader
);
1531 /* NULL shader test */
1533 hr
= D3DAssemble(test1
, strlen(test1
), NULL
,
1534 defines
, NULL
, D3DCOMPILE_SKIP_VALIDATION
,
1536 ok(hr
== S_OK
, "NULL shader test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1538 trace("D3DAssemble messages:\n%s", (char *)ID3D10Blob_GetBufferPointer(messages
));
1539 ID3D10Blob_Release(messages
);
1542 /* D3DInclude test */
1545 include
.lpVtbl
= &D3DInclude_Vtbl
;
1546 hr
= D3DAssemble(testshader
, strlen(testshader
), NULL
,
1547 NULL
, (LPD3DINCLUDE
)&include
, D3DCOMPILE_SKIP_VALIDATION
,
1548 &shader
, &messages
);
1549 ok(hr
== S_OK
, "D3DInclude test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1551 trace("D3DAssemble messages:\n%s", (char *)ID3D10Blob_GetBufferPointer(messages
));
1552 ID3D10Blob_Release(messages
);
1554 if(shader
) ID3D10Blob_Release(shader
);
1556 /* NULL shader tests */
1559 hr
= D3DAssemble(NULL
, 0, NULL
,
1560 NULL
, NULL
, D3DCOMPILE_SKIP_VALIDATION
,
1561 &shader
, &messages
);
1562 ok(hr
== D3DXERR_INVALIDDATA
, "NULL shader test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1564 trace("D3DAssemble messages:\n%s", (char *)ID3D10Blob_GetBufferPointer(messages
));
1565 ID3D10Blob_Release(messages
);
1567 if(shader
) ID3D10Blob_Release(shader
);
1570 static void d3dpreprocess_test(void)
1572 const char test1
[] =
1577 const char testshader
[] =
1579 "#include \"incl.vsh\"\n"
1580 "mov REGISTER, v0\n"
1582 const char testshader2
[] =
1584 "#include \"incl2.vsh\"\n"
1585 "mov REGISTER, v0\n"
1588 ID3DBlob
*shader
, *messages
;
1589 D3D_SHADER_MACRO defines
[] =
1601 struct D3DIncludeImpl include
;
1606 hr
= D3DPreprocess(test1
, strlen(test1
), NULL
,
1607 defines
, NULL
, &shader
, &messages
);
1608 ok(hr
== S_OK
, "pDefines test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1611 trace("D3DPreprocess messages:\n%s", (char *)ID3D10Blob_GetBufferPointer(messages
));
1612 ID3D10Blob_Release(messages
);
1614 if (shader
) ID3D10Blob_Release(shader
);
1616 /* NULL messages test */
1618 hr
= D3DPreprocess(test1
, strlen(test1
), NULL
,
1619 defines
, NULL
, &shader
, NULL
);
1620 ok(hr
== S_OK
, "NULL messages test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1621 if (shader
) ID3D10Blob_Release(shader
);
1623 /* NULL shader test */
1625 hr
= D3DPreprocess(test1
, strlen(test1
), NULL
,
1626 defines
, NULL
, NULL
, &messages
);
1627 ok(hr
== E_INVALIDARG
, "NULL shader test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1630 trace("D3DPreprocess messages:\n%s", (char *)ID3D10Blob_GetBufferPointer(messages
));
1631 ID3D10Blob_Release(messages
);
1637 include
.lpVtbl
= &D3DInclude_Vtbl
;
1638 hr
= D3DPreprocess(testshader
, strlen(testshader
), NULL
,
1639 NULL
, (ID3DInclude
*)&include
, &shader
, &messages
);
1640 ok(hr
== S_OK
, "pInclude test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1643 trace("D3DPreprocess messages:\n%s", (char *)ID3D10Blob_GetBufferPointer(messages
));
1644 ID3D10Blob_Release(messages
);
1646 if (shader
) ID3D10Blob_Release(shader
);
1648 /* recursive #include test */
1651 hr
= D3DPreprocess(testshader2
, strlen(testshader2
), NULL
,
1652 NULL
, (ID3DInclude
*)&include
, &shader
, &messages
);
1653 ok(hr
== S_OK
, "D3DPreprocess test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1656 trace("recursive D3DPreprocess messages:\n%s", (char *)ID3D10Blob_GetBufferPointer(messages
));
1657 ID3D10Blob_Release(messages
);
1659 if (shader
) ID3D10Blob_Release(shader
);
1661 /* NULL shader tests */
1664 hr
= D3DPreprocess(NULL
, 0, NULL
,
1665 NULL
, NULL
, &shader
, &messages
);
1666 ok(hr
== E_INVALIDARG
, "NULL shader test failed with error 0x%x - %d\n", hr
, hr
& 0x0000FFFF);
1669 trace("D3DPreprocess messages:\n%s", (char *)ID3D10Blob_GetBufferPointer(messages
));
1670 ID3D10Blob_Release(messages
);
1672 if (shader
) ID3D10Blob_Release(shader
);
1691 assembleshader_test();
1693 d3dpreprocess_test();