dlls/d3dcompiler_43/tests/hlsl.c

   1 /*
   2  * Copyright (C) 2010 Travis Athougies
   3  *
   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.
   8  *
   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.
  13  *
  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
  17  */
  18 #define COBJMACROS
  19 #include "wine/test.h"
  20 #include "d3dx9.h"
  21 #include "d3dcompiler.h"
  22
  23 #include <math.h>
  24
  25 struct vertex
  26 {
  27     float x, y, z;
  28     float tx, ty;
  29 };
  30
  31 /* Tells compute_shader_probe* which pixels should be what colors */
  32 struct hlsl_probe_info
  33 {
  34     unsigned int x, y;
  35     /* The expected values in this region */
  36     D3DXCOLOR c;
  37     /* The max error for any value */
  38     float epsilon;
  39     /* An error message to print if this test fails */
  40     const char *message;
  41 };
  42
  43 static HWND create_window(void)
  44 {
  45     WNDCLASSA wc = {0};
  46     wc.lpfnWndProc = DefWindowProcA;
  47     wc.lpszClassName = "d3d9_test_wc";
  48     RegisterClassA(&wc);
  49
  50     return CreateWindowA("d3d9_test_wc", "d3d9_test", 0, 0, 0, 0, 0, 0, 0, 0, 0);
  51 }
  52
  53 static IDirect3DDevice9 *init_d3d9(IDirect3DVertexDeclaration9 **vdeclaration,
  54         IDirect3DVertexBuffer9 **quad_geometry, IDirect3DVertexShader9 **vshader_passthru)
  55 {
  56     static const struct vertex quad_vertices[4] =
  57     {
  58         {-1.0f, -1.0f, 0.0f, 0.0f, 1.0f},
  59         {-1.0f,  1.0f, 0.0f, 0.0f, 0.0f},
  60         { 1.0f, -1.0f, 0.0f, 1.0f, 1.0f},
  61         { 1.0f,  1.0f, 0.0f, 1.0f, 0.0f}
  62     };
  63
  64     static const D3DVERTEXELEMENT9 vdeclelements[] =
  65     {
  66         {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
  67         {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
  68         D3DDECL_END()
  69     };
  70
  71     static const char *vshader_passthru_hlsl =
  72         "float4 vshader(float4 pos: POSITION, inout float2 texcoord: TEXCOORD0): POSITION\n"
  73         "{\n"
  74         "   return pos;\n"
  75         "}";
  76
  77     IDirect3D9 *d3d9_ptr;
  78     IDirect3DDevice9 *device_ptr = NULL;
  79     D3DPRESENT_PARAMETERS present_parameters;
  80
  81     void *temp_geometry_vertices;
  82
  83     ID3D10Blob *compiled = NULL;
  84     ID3D10Blob *errors = NULL;
  85
  86     HRESULT hr;
  87
  88     d3d9_ptr = Direct3DCreate9(D3D_SDK_VERSION);
  89     if (!d3d9_ptr)
  90     {
  91         skip("could not create D3D9\n");
  92         return NULL;
  93     }
  94
  95     hr = IDirect3D9_CheckDeviceFormat(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
  96             0, D3DRTYPE_SURFACE, D3DFMT_A32B32G32R32F);
  97     if (FAILED(hr))
  98     {
  99         skip("A32B32G32R32F format not available on this device\n");
 100         IDirect3D9_Release(d3d9_ptr);
 101         return NULL;
 102     }
 103
 104     ZeroMemory(&present_parameters, sizeof(present_parameters));
 105     present_parameters.Windowed = TRUE;
 106     present_parameters.hDeviceWindow = create_window();
 107     present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
 108
 109     hr = IDirect3D9_CreateDevice(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, NULL,
 110             D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device_ptr);
 111     IDirect3D9_Release(d3d9_ptr);
 112     if (FAILED(hr))
 113     {
 114         skip("could not create Direct3D9 device\n");
 115         return NULL;
 116     }
 117
 118     /* Create the quad geometry */
 119     hr = IDirect3DDevice9_CreateVertexBuffer(device_ptr, 4 * sizeof(struct vertex),
 120             D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, quad_geometry, NULL);
 121     ok(SUCCEEDED(hr),
 122             "Could not create vertex buffer, IDirect3DDevice9_CreateVertexBuffer returned: %08x\n", hr);
 123
 124     hr = IDirect3DVertexBuffer9_Lock(*quad_geometry, 0, sizeof(quad_vertices), &temp_geometry_vertices, 0);
 125     ok(SUCCEEDED(hr), "IDirect3DVertexBuffer9_Lock returned: %08x\n", hr);
 126     memcpy(temp_geometry_vertices, quad_vertices, sizeof(quad_vertices));
 127     IDirect3DVertexBuffer9_Unlock(*quad_geometry);
 128
 129     hr = IDirect3DDevice9_CreateVertexDeclaration(device_ptr, vdeclelements, vdeclaration);
 130     ok(SUCCEEDED(hr), "Could not create vertex declaration: "
 131             "IDirect3DDevice9_CreateVertexDeclaration returned: %08x\n", hr);
 132
 133     hr = IDirect3DDevice9_SetVertexDeclaration(device_ptr, *vdeclaration);
 134     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned: %08x\n", hr);
 135
 136     /* Create a simple vertex shader to just pass through the values */
 137     hr = D3DCompile(vshader_passthru_hlsl, strlen(vshader_passthru_hlsl), NULL,
 138             NULL, NULL, "vshader", "vs_1_1", 0, 0, &compiled, &errors);
 139     if (FAILED(hr))
 140     {
 141         skip("not compiling vertex shader due to lacking wine HLSL support!\n");
 142         if (errors)
 143             ID3D10Blob_Release(errors);
 144         return NULL;
 145     }
 146
 147     hr = IDirect3DDevice9_CreateVertexShader(device_ptr, ID3D10Blob_GetBufferPointer(compiled),
 148             vshader_passthru);
 149     ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateVertexShader returned: %08x\n", hr);
 150     ID3D10Blob_Release(compiled);
 151
 152     return device_ptr;
 153 }
 154
 155 /* Convenience functions */
 156 static void set_float4_d3d9(IDirect3DDevice9 *device, ID3DXConstantTable *constants, const char *name,
 157         float x, float y, float z, float w)
 158 {
 159     D3DXVECTOR4 vector;
 160     vector.x = x;
 161     vector.y = y;
 162     vector.z = z;
 163     vector.w = w;
 164     ID3DXConstantTable_SetVector(constants, device, name, &vector);
 165 }
 166
 167 /* Compile our pixel shader and get back the compiled version and a constant table */
 168 static IDirect3DPixelShader9 *compile_pixel_shader9(IDirect3DDevice9 *device, const char *shader,
 169         const char *profile, ID3DXConstantTable **constants)
 170 {
 171     ID3D10Blob *compiled = NULL;
 172     ID3D10Blob *errors = NULL;
 173     IDirect3DPixelShader9 *pshader;
 174     HRESULT hr;
 175
 176     hr = D3DCompile(shader, strlen(shader), NULL, NULL,
 177             NULL, "test", profile, /* test is the name of the entry point of our shader */
 178             0, 0, &compiled, &errors);
 179     ok(hr == D3D_OK, "Pixel shader %s compilation failed: %s\n", shader,
 180             errors ? (char *)ID3D10Blob_GetBufferPointer(errors) : "");
 181     if (FAILED(hr)) return NULL;
 182
 183     hr = D3DXGetShaderConstantTable(ID3D10Blob_GetBufferPointer(compiled), constants);
 184     ok(hr == D3D_OK, "Could not get constant table from compiled pixel shader\n");
 185
 186     hr = IDirect3DDevice9_CreatePixelShader(device, ID3D10Blob_GetBufferPointer(compiled), &pshader);
 187     ok(SUCCEEDED(hr), "IDirect3DDevice9_CreatePixelShader returned: %08x\n", hr);
 188     ID3D10Blob_Release(compiled);
 189     return pshader;
 190 }
 191
 192 /* Draw a full screen quad */
 193 static void draw_quad_with_shader9(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_geometry)
 194 {
 195     HRESULT hr;
 196     D3DXMATRIX projection_matrix;
 197
 198     D3DXMatrixOrthoLH(&projection_matrix, 2.0f, 2.0f, 0.0f, 1.0f);
 199     IDirect3DDevice9_SetTransform(device, D3DTS_PROJECTION, &projection_matrix);
 200
 201     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);
 202     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned: %08x\n", hr);
 203
 204     hr = IDirect3DDevice9_BeginScene(device);
 205     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned: %08x\n", hr);
 206
 207     hr = IDirect3DDevice9_SetStreamSource(device, 0, quad_geometry, 0, sizeof(struct vertex));
 208     ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource returned: %08x\n", hr);
 209     hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
 210     ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive returned: %08x\n", hr);
 211
 212     hr = IDirect3DDevice9_EndScene(device);
 213     ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned: %08x\n", hr);
 214 }
 215
 216 static void setup_device9(IDirect3DDevice9 *device, IDirect3DSurface9 **render_target,
 217         IDirect3DSurface9 **readback, D3DFORMAT format, unsigned int width, unsigned int height,
 218         IDirect3DVertexShader9 *vshader, IDirect3DPixelShader9 *pshader)
 219 {
 220     HRESULT hr;
 221     hr = IDirect3DDevice9_CreateRenderTarget(device, width, height, format,
 222             D3DMULTISAMPLE_NONE, 0, FALSE, render_target, NULL);
 223     ok(hr == D3D_OK, "IDirect3DDevice9_CreateRenderTarget returned: %08x\n", hr);
 224
 225     /* The Direct3D 9 docs state that we cannot lock a render target surface,
 226        instead we must copy the render target onto this surface to lock it */
 227     hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, width, height, format,
 228             D3DPOOL_SYSTEMMEM, readback, NULL);
 229     ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface returned: %08x\n", hr);
 230
 231     hr = IDirect3DDevice9_SetRenderTarget(device, 0, *render_target);
 232     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget returned: %08x\n", hr);
 233
 234     hr = IDirect3DDevice9_SetVertexShader(device, vshader);
 235     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned: %08x\n", hr);
 236     hr = IDirect3DDevice9_SetPixelShader(device, pshader);
 237     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned: %08x\n", hr);
 238 }
 239
 240 static BOOL colors_match(D3DXCOLOR a, D3DXCOLOR b, float epsilon)
 241 {
 242   return (fabs(a.r - b.r) < epsilon && fabs(a.g - b.g) < epsilon && fabs(a.b - b.b) < epsilon &&
 243           fabs(a.a - b.a) < epsilon);
 244 }
 245
 246 /* Compute a shader on a width by height buffer and probes certain locations
 247    to see if they are as expected. */
 248 static void compute_shader_probe9(IDirect3DDevice9 *device, IDirect3DVertexShader9 *vshader,
 249         IDirect3DPixelShader9 *pshader, IDirect3DVertexBuffer9 *quad_geometry,
 250         const struct hlsl_probe_info *probes, unsigned int count,
 251         unsigned int width, unsigned int height, unsigned int line_number)
 252 {
 253     IDirect3DSurface9 *render_target;
 254     IDirect3DSurface9 *readback;
 255
 256     HRESULT hr;
 257     D3DLOCKED_RECT lr;
 258     D3DXCOLOR *pbits_data;
 259     unsigned int i;
 260
 261     setup_device9(device, &render_target, &readback, D3DFMT_A32B32G32R32F,
 262             width, height, vshader, pshader);
 263
 264     /* Draw the quad with the shader and read back the data */
 265     draw_quad_with_shader9(device, quad_geometry);
 266     IDirect3DDevice9_GetRenderTargetData(device, render_target, readback);
 267     hr = IDirect3DSurface9_LockRect(readback, &lr, NULL, D3DLOCK_READONLY);
 268     ok(hr == D3D_OK, "IDirect3DSurface9_LockRect returned: %08x\n", hr);
 269     pbits_data = lr.pBits;
 270
 271     /* Now go through the probes and check each one */
 272     for (i = 0; i < count; i++, probes++) {
 273         int index = probes->x + (probes->y * lr.Pitch / sizeof(D3DXCOLOR));
 274         ok(colors_match(probes->c, pbits_data[index], probes->epsilon),
 275                 "Line %d: At (%d, %d): %s: Expected (%.04f,%.04f,%.04f, %.04f), got "
 276                 "(%.04f,%.04f,%.04f,%.04f)\n", line_number, probes->x, probes->y, probes->message,
 277                 probes->c.r, probes->c.g, probes->c.b, probes->c.a, pbits_data[index].r,
 278                 pbits_data[index].g, pbits_data[index].b, pbits_data[index].a);
 279     }
 280
 281     hr = IDirect3DSurface9_UnlockRect(readback);
 282     ok(hr == D3D_OK, "IDirect3DSurface9_UnlockRect returned: %08x\n", hr);
 283
 284     /* We now present the scene. This is mostly for debugging purposes, since GetRenderTargetData
 285        also waits for drawing commands to complete. The reason this call is here and not in a
 286        draw function is because the contents of the render target surface are invalidated after
 287        this call. */
 288     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
 289     ok(hr == D3D_OK, "IDirect3DDevice9_Present returned: %08x\n", hr);
 290
 291     IDirect3DSurface9_Release(render_target);
 292     IDirect3DSurface9_Release(readback);
 293 }
 294
 295 /* Now the actual test functions */
 296 static void test_swizzle(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_geometry,
 297         IDirect3DVertexShader9 *vshader_passthru)
 298 {
 299     static const struct hlsl_probe_info probes[] =
 300     {
 301        {0, 0, {0.0101f, 0.0303f, 0.0202f, 0.0404f}, 0.0001f, "swizzle_test failed"}
 302     };
 303
 304     static const char *swizzle_test_shader =
 305         "uniform float4 color;\n"
 306         "float4 test(): COLOR\n"
 307         "{\n"
 308         "    float4 ret = color;\n"
 309         "    ret.gb = ret.ra;\n"
 310         "    ret.ra = float2(0.0101, 0.0404);\n"
 311         "    return ret;\n"
 312         "}";
 313
 314     ID3DXConstantTable *constants;
 315     IDirect3DPixelShader9 *pshader;
 316
 317     pshader = compile_pixel_shader9(device, swizzle_test_shader, "ps_2_0", &constants);
 318     if (pshader != NULL)
 319     {
 320         set_float4_d3d9(device, constants, "color", 0.0303f, 0.0f, 0.0f, 0.0202f);
 321
 322         compute_shader_probe9(device, vshader_passthru, pshader, quad_geometry,
 323                 probes, sizeof(probes) / sizeof(*probes), 1, 1, __LINE__);
 324
 325         ID3DXConstantTable_Release(constants);
 326         IDirect3DPixelShader9_Release(pshader);
 327     }
 328 }
 329
 330 static void test_math(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_geometry,
 331         IDirect3DVertexShader9 *vshader_passthru)
 332 {
 333     /* Tests order of operations */
 334     static const float u = 2.5f, v = 0.3f, w = 0.2f, x = 0.7f, y = 0.1f, z = 1.5f;
 335
 336     static const struct hlsl_probe_info probes[] =
 337     {
 338         {0, 0, {-12.4300f, 9.8333f, 1.6000f, 34.9999f}, 0.0001f,
 339                 "order of operations test failed"}
 340     };
 341
 342     static const char *order_of_operations_shader =
 343         "float4 test(uniform float u, uniform float v, uniform float w, uniform float x,\n"
 344         "            uniform float y, uniform float z): COLOR\n"
 345         "{\n"
 346         "    return float4(x * y - z / w + --u / -v,\n"
 347         "            z * x / y + w / -v,\n"
 348         "            u + v - w,\n"
 349         "            x / y / w);\n"
 350         "}";
 351
 352     ID3DXConstantTable *constants;
 353     IDirect3DPixelShader9 *pshader;
 354
 355     pshader = compile_pixel_shader9(device, order_of_operations_shader, "ps_2_0", &constants);
 356     if (pshader != NULL)
 357     {
 358         ID3DXConstantTable_SetFloat(constants, device, "$u", u);
 359         ID3DXConstantTable_SetFloat(constants, device, "$v", v);
 360         ID3DXConstantTable_SetFloat(constants, device, "$w", w);
 361         ID3DXConstantTable_SetFloat(constants, device, "$x", x);
 362         ID3DXConstantTable_SetFloat(constants, device, "$y", y);
 363         ID3DXConstantTable_SetFloat(constants, device, "$z", z);
 364
 365         compute_shader_probe9(device, vshader_passthru, pshader, quad_geometry,
 366                 probes, sizeof(probes) / sizeof(*probes), 1, 1, __LINE__);
 367
 368         ID3DXConstantTable_Release(constants);
 369         IDirect3DPixelShader9_Release(pshader);
 370     }
 371 }
 372
 373 static void test_conditionals(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_geometry,
 374         IDirect3DVertexShader9 *vshader_passthru)
 375 {
 376     static const struct hlsl_probe_info if_greater_probes[] =
 377     {
 378         { 0, 0, {0.9f, 0.8f, 0.7f, 0.6f}, 0.0001f, "if greater test failed"},
 379         { 5, 0, {0.9f, 0.8f, 0.7f, 0.6f}, 0.0001f, "if greater test failed"},
 380         {10, 0, {0.9f, 0.8f, 0.7f, 0.6f}, 0.0001f, "if greater test failed"},
 381         {15, 0, {0.9f, 0.8f, 0.7f, 0.6f}, 0.0001f, "if greater test failed"},
 382         {25, 0, {0.1f, 0.2f, 0.3f, 0.4f}, 0.0001f, "if greater test failed"},
 383         {30, 0, {0.1f, 0.2f, 0.3f, 0.4f}, 0.0001f, "if greater test failed"}
 384     };
 385
 386     static const char *if_greater_shader =
 387         "float4 test(float2 pos: TEXCOORD0): COLOR\n"
 388         "{\n"
 389         "    if((pos.x * 32.0) > 20.0)\n"
 390         "        return float4(0.1, 0.2, 0.3, 0.4);\n"
 391         "    else\n"
 392         "        return float4(0.9, 0.8, 0.7, 0.6);\n"
 393         "}";
 394
 395     static const struct hlsl_probe_info ternary_operator_probes[] =
 396     {
 397         {0, 0, {0.50f, 0.25f, 0.50f, 0.75f}, 0.00001f, "ternary operator test failed"},
 398         {1, 0, {0.50f, 0.25f, 0.50f, 0.75f}, 0.00001f, "ternary operator test failed"},
 399         {2, 0, {0.50f, 0.25f, 0.50f, 0.75f}, 0.00001f, "ternary operator test failed"},
 400         {3, 0, {0.50f, 0.25f, 0.50f, 0.75f}, 0.00001f, "ternary operator test failed"},
 401         {4, 0, {0.60f, 0.80f, 0.10f, 0.20f}, 0.00001f, "ternary operator test failed"},
 402         {5, 0, {0.60f, 0.80f, 0.10f, 0.20f}, 0.00001f, "ternary operator test failed"},
 403         {6, 0, {0.60f, 0.80f, 0.10f, 0.20f}, 0.00001f, "ternary operator test failed"},
 404         {7, 0, {0.60f, 0.80f, 0.10f, 0.20f}, 0.00001f, "ternary operator test failed"}
 405     };
 406
 407     static const char *ternary_operator_shader =
 408         "float4 test(float2 pos: TEXCOORD0): COLOR\n"
 409         "{\n"
 410         "    return (pos.x < 0.5?float4(0.5, 0.25, 0.5, 0.75):float4(0.6, 0.8, 0.1, 0.2));\n"
 411         "}";
 412
 413     ID3DXConstantTable *constants;
 414     IDirect3DPixelShader9 *pshader;
 415
 416     pshader = compile_pixel_shader9(device, if_greater_shader, "ps_2_0", &constants);
 417     if (pshader != NULL)
 418     {
 419         compute_shader_probe9(device, vshader_passthru, pshader, quad_geometry, if_greater_probes,
 420                 sizeof(if_greater_probes) / sizeof(*if_greater_probes), 32, 1, __LINE__);
 421
 422         ID3DXConstantTable_Release(constants);
 423         IDirect3DPixelShader9_Release(pshader);
 424     }
 425
 426     pshader = compile_pixel_shader9(device, ternary_operator_shader, "ps_2_0", &constants);
 427     if (pshader != NULL)
 428     {
 429         compute_shader_probe9(device, vshader_passthru, pshader, quad_geometry, ternary_operator_probes,
 430                 sizeof(ternary_operator_probes) / sizeof(*ternary_operator_probes), 8, 1, __LINE__);
 431
 432         ID3DXConstantTable_Release(constants);
 433         IDirect3DPixelShader9_Release(pshader);
 434     }
 435 }
 436
 437 static void test_float_vectors(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_geometry,
 438         IDirect3DVertexShader9 *vshader_passthru)
 439 {
 440     static const struct hlsl_probe_info vec4_indexing_test1_probes[] =
 441     {
 442         {0, 0, {0.020f, 0.245f, 0.351f, 1.000f}, 0.0001f, "vec4 indexing test 1 failed"}
 443     };
 444
 445     static const char *vec4_indexing_test1_shader =
 446         "float4 test(): COLOR\n"
 447         "{\n"
 448         "    float4 color;\n"
 449         "    color[0] = 0.020;\n"
 450         "    color[1] = 0.245;\n"
 451         "    color[2] = 0.351;\n"
 452         "    color[3] = 1.0;\n"
 453         "    return color;\n"
 454         "}";
 455
 456     static const struct hlsl_probe_info vec4_indexing_test2_probes[] =
 457     {
 458         {0, 0, {0.5f, 0.3f, 0.8f, 0.2f}, 0.0001f, "vec4 indexing test 2 failed"}
 459     };
 460
 461     /* We have this uniform i here so the compiler can't optimize */
 462     static const char *vec4_indexing_test2_shader =
 463         "uniform int i;\n"
 464         "float4 test(): COLOR\n"
 465         "{\n"
 466         "    float4 color = float4(0.5, 0.4, 0.3, 0.2);\n"
 467         "    color.g = color[i];\n"
 468         "    color.b = 0.8;\n"
 469         "    return color;\n"
 470         "}";
 471
 472     ID3DXConstantTable *constants;
 473     IDirect3DPixelShader9 *pshader;
 474
 475     pshader = compile_pixel_shader9(device, vec4_indexing_test1_shader, "ps_2_0", &constants);
 476     if (pshader != NULL)
 477     {
 478         compute_shader_probe9(device, vshader_passthru, pshader, quad_geometry, vec4_indexing_test1_probes,
 479                 sizeof(vec4_indexing_test1_probes) / sizeof(*vec4_indexing_test1_probes), 1, 1, __LINE__);
 480
 481         ID3DXConstantTable_Release(constants);
 482         IDirect3DPixelShader9_Release(pshader);
 483     }
 484
 485     pshader = compile_pixel_shader9(device, vec4_indexing_test2_shader, "ps_2_0", &constants);
 486     if (pshader != NULL)
 487     {
 488         ID3DXConstantTable_SetInt(constants, device, "i", 2);
 489
 490         compute_shader_probe9(device, vshader_passthru, pshader, quad_geometry, vec4_indexing_test2_probes,
 491                 sizeof(vec4_indexing_test2_probes) / sizeof(*vec4_indexing_test2_probes), 32, 1, __LINE__);
 492
 493         ID3DXConstantTable_Release(constants);
 494         IDirect3DPixelShader9_Release(pshader);
 495     }
 496 }
 497
 498 static void test_trig(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_geometry,
 499         IDirect3DVertexShader9 *vshader_passthru)
 500 {
 501     static const struct hlsl_probe_info sincos_probes[] =
 502     {
 503         {0, 0, {0.5000f, 1.0000f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 504         {1, 0, {0.5975f, 0.9904f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 505         {2, 0, {0.6913f, 0.9620f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 506         {3, 0, {0.7778f, 0.9160f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 507         {4, 0, {0.8536f, 0.8536f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 508         {5, 0, {0.9157f, 0.7778f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 509         {6, 0, {0.9620f, 0.6913f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 510         {7, 0, {0.9904f, 0.5975f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 511         {8, 0, {1.0000f, 0.5000f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 512         {9, 0, {0.9904f, 0.4025f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 513         {10, 0, {0.9619f, 0.3087f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 514         {11, 0, {0.9157f, 0.2222f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 515         {12, 0, {0.8536f, 0.1464f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 516         {13, 0, {0.7778f, 0.0843f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 517         {14, 0, {0.6913f, 0.0381f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 518         {15, 0, {0.5975f, 0.0096f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 519         {16, 0, {0.5000f, 0.0000f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 520         {17, 0, {0.4025f, 0.0096f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 521         {18, 0, {0.3087f, 0.0381f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 522         {19, 0, {0.2222f, 0.0843f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 523         {20, 0, {0.1464f, 0.1464f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 524         {21, 0, {0.0843f, 0.2222f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 525         {22, 0, {0.0381f, 0.3087f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 526         {23, 0, {0.0096f, 0.4025f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 527         {24, 0, {0.0000f, 0.5000f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 528         {25, 0, {0.0096f, 0.5975f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 529         {26, 0, {0.0381f, 0.6913f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 530         {27, 0, {0.0843f, 0.7778f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 531         {28, 0, {0.1464f, 0.8536f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 532         {29, 0, {0.2222f, 0.9157f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 533         {30, 0, {0.3087f, 0.9619f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 534         {31, 0, {0.4025f, 0.9904f, 0.0f, 0.0f}, 0.001f, "sin/cos test failed"},
 535     };
 536
 537     static const char *sincos_shader =
 538         "float4 test(float x: TEXCOORD0): COLOR\n"
 539         "{\n"
 540         "    const float pi2 = 6.2831853;\n"
 541         "    float calcd_sin = (sin(x * pi2) + 1)/2;\n"
 542         "    float calcd_cos = (cos(x * pi2) + 1)/2;\n"
 543         "    return float4(calcd_sin, calcd_cos, 0, 0);\n"
 544         "}";
 545
 546     ID3DXConstantTable *constants;
 547     IDirect3DPixelShader9 *pshader;
 548
 549     pshader = compile_pixel_shader9(device, sincos_shader, "ps_2_0", &constants);
 550     if (pshader != NULL)
 551     {
 552         compute_shader_probe9(device, vshader_passthru, pshader, quad_geometry, sincos_probes,
 553                 sizeof(sincos_probes) / sizeof(*sincos_probes), 32, 1, __LINE__);
 554
 555         ID3DXConstantTable_Release(constants);
 556         IDirect3DPixelShader9_Release(pshader);
 557     }
 558 }
 559
 560 static void test_fail(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *qquad_geometry,
 561         IDirect3DVertexShader9 *vshader_passthru)
 562 {
 563     static const char *undefined_variable_shader =
 564         "float4 test(float2 pos: TEXCOORD0) : COLOR\n"
 565         "{\n"
 566         "   return y;\n"
 567         "}";
 568
 569     static const char *invalid_swizzle_shader =
 570         "float4 test(float2 pos: TEXCOORD0) : COLOR\n"
 571         "{\n"
 572         "  float4 x = float4(0, 0, 0, 0);\n"
 573         "  x.xzzx = float4(1, 2, 3, 4);\n"
 574         "  return x;\n"
 575         "}";
 576
 577     static const char *invalid_conversion_shader =
 578         "float4 test(float2 pos: TEXCOORD0) : COLOR\n"
 579         "{\n"
 580         "  float4 x = pos;\n"
 581         "  return x;\n"
 582         "}";
 583
 584     static const char *invalid_syntax_shader =
 585         "float4 test(float2 pos, TEXCOORD0) ; COLOR\n"
 586         "{\n"
 587         "  pos = float4 x;\n"
 588         "  mul(float4(5, 4, 3, 2), mvp) = x;\n"
 589         "  return float4;\n"
 590         "}";
 591
 592     static const char *invalid_identifiers_shader =
 593         "float4 563r(float2 45s: TEXCOORD0) : COLOR\n"
 594         "{\n"
 595         "  float2 x = 45s;\n"
 596         "  return float4(x.x, x.y, 0, 0);\n"
 597         "}";
 598
 599     ID3D10Blob *compiled = NULL, *errors = NULL;
 600     HRESULT hr;
 601
 602     hr = D3DCompile(undefined_variable_shader, strlen(undefined_variable_shader), NULL, NULL, NULL,
 603             "test", "ps_2_0", 0, 0, &compiled, &errors);
 604     ok(hr != D3D_OK, "Pixel shader compilation succeeded on shader with undefined variable\n");
 605     ok(errors != NULL, "No errors returned for a shader with undefined variables\n");
 606     ok(compiled == NULL, "A shader blob was returned for a shader with undefined variables\n");
 607
 608     ID3D10Blob_Release(errors);
 609     errors = NULL;
 610
 611     hr = D3DCompile(invalid_swizzle_shader, strlen(invalid_swizzle_shader), NULL, NULL, NULL,
 612             "test","ps_2_0", 0, 0, &compiled, &errors);
 613     ok(hr != D3D_OK, "Pixel shader compilation succeeded on shader with an invalid swizzle mask\n");
 614     ok(errors != NULL, "No errors returned for a shader with an invalid swizzle mask\n");
 615     ok(compiled == NULL, "A shader blob was returned for a shader with an invalid swizzle mask\n");
 616
 617     ID3D10Blob_Release(errors);
 618     errors = NULL;
 619
 620     hr = D3DCompile(invalid_conversion_shader, strlen(invalid_conversion_shader), NULL, NULL, NULL,
 621              "test", "ps_2_0", 0, 0, &compiled, &errors);
 622     ok(hr != D3D_OK, "Pixel shader compilation succeeded on shader with an invalid type "
 623             "conversion\n");
 624     ok(errors != NULL, "No errors returned for a shader with invalid type conversions\n");
 625     ok(compiled == NULL, "A shader blob was returned for a shader with invalid type conversions\n");
 626
 627     ID3D10Blob_Release(errors);
 628     errors = NULL;
 629
 630     hr = D3DCompile(invalid_syntax_shader, strlen(invalid_syntax_shader), NULL, NULL, NULL, "test",
 631             "ps_2_0", 0, 0, &compiled, &errors);
 632     ok(hr != D3D_OK, "Pixel shader compilation succeeded on shader with blatantly invalid "
 633             "syntax\n");
 634     ok(errors != NULL, "No errors returned for a shader with invalid syntax\n");
 635     ok(compiled == NULL, "A shader blob was returned for a shader with invalid syntax\n");
 636
 637     ID3D10Blob_Release(errors);
 638     errors = NULL;
 639
 640     hr = D3DCompile(invalid_identifiers_shader, strlen(invalid_identifiers_shader), NULL, NULL,
 641             NULL, "test", "ps_2_0", 0, 0, &compiled, &errors);
 642     ok(hr != D3D_OK, "Pixel shader compilation successful on a shader with invalid variable and "
 643             "function names\n");
 644     ok(errors != NULL, "No errors returned for a shader with invalid variable and function "
 645             "names\n");
 646     ok(compiled == NULL, "A shader blob was returned for a shader with invalid variable and "
 647             "function names\n");
 648
 649     ID3D10Blob_Release(errors);
 650 }
 651
 652 START_TEST(hlsl)
 653 {
 654     D3DCAPS9 caps;
 655     ULONG refcount;
 656     IDirect3DDevice9 *device;
 657     IDirect3DVertexDeclaration9 *vdeclaration;
 658     IDirect3DVertexBuffer9 *quad_geometry;
 659     IDirect3DVertexShader9 *vshader_passthru;
 660
 661     device = init_d3d9(&vdeclaration, &quad_geometry, &vshader_passthru);
 662     if (!device) return;
 663
 664     /* Make sure we support pixel shaders, before trying to compile them! */
 665     /* Direct3D 9 (Shader model 1-3 tests) */
 666     IDirect3DDevice9_GetDeviceCaps(device, &caps);
 667     if (caps.PixelShaderVersion >= D3DPS_VERSION(2, 0))
 668     {
 669         todo_wine
 670         {
 671             test_swizzle(device, quad_geometry, vshader_passthru);
 672             test_math(device, quad_geometry, vshader_passthru);
 673             test_conditionals(device, quad_geometry, vshader_passthru);
 674             test_float_vectors(device, quad_geometry, vshader_passthru);
 675             test_trig(device, quad_geometry, vshader_passthru);
 676             test_fail(device, quad_geometry, vshader_passthru);
 677         }
 678     } else skip("no pixel shader support\n");
 679
 680     /* Reference counting sanity checks */
 681     if (vshader_passthru)
 682     {
 683         refcount = IDirect3DVertexShader9_Release(vshader_passthru);
 684         ok(!refcount, "Pass-through vertex shader has %u references left\n", refcount);
 685     }
 686
 687     refcount = IDirect3DVertexBuffer9_Release(quad_geometry);
 688     ok(!refcount, "Vertex buffer has %u references left\n", refcount);
 689
 690     refcount = IDirect3DVertexDeclaration9_Release(vdeclaration);
 691     ok(!refcount, "Vertex declaration has %u references left\n", refcount);
 692
 693     refcount = IDirect3DDevice9_Release(device);
 694     ok(!refcount, "Device has %u references left\n", refcount);
 695 }