This brings the d3dcompiler tests more in line with existing d3d9 tests, and
allows potentially running the tests in parallel.
Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com>
---
dlls/d3dcompiler_43/tests/hlsl.c | 801 +++++++++++++++----------------
1 file changed, 384 insertions(+), 417 deletions(-)
diff --git a/dlls/d3dcompiler_43/tests/hlsl.c b/dlls/d3dcompiler_43/tests/hlsl.c
index 868693838cc..9114ec98e1d 100644
--- a/dlls/d3dcompiler_43/tests/hlsl.c
+++ b/dlls/d3dcompiler_43/tests/hlsl.c
@@ -1,5 +1,6 @@
/*
* Copyright (C) 2010 Travis Athougies
+ * Copyright (C) 2020 Zebediah Figura
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@@ -25,290 +26,265 @@
static pD3DCompile ppD3DCompile;
static HRESULT (WINAPI *pD3DXGetShaderConstantTable)(const DWORD *byte_code, ID3DXConstantTable **constant_table);
-static D3DMATRIX *(WINAPI *pD3DXMatrixOrthoLH)(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf);
-struct vertex
+struct vec2
{
- float x, y, z;
- float tx, ty;
+ float x, y;
};
-/* Tells compute_shader_probe* which pixels should be what colors */
-struct hlsl_probe_info
+struct vec4
{
- unsigned int x, y;
- /* The expected values in this region */
- D3DXCOLOR c;
- /* The max error for any value */
- float epsilon;
- /* An error message to print if this test fails */
- const char *message;
+ float x, y, z, w;
};
-static HWND create_window(void)
+#define compile_shader(a, b) compile_shader_(__LINE__, a, b)
+static ID3D10Blob *compile_shader_(unsigned int line, const char *source, const char *target)
{
- WNDCLASSA wc = {0};
- wc.lpfnWndProc = DefWindowProcA;
- wc.lpszClassName = "d3d9_test_wc";
- RegisterClassA(&wc);
+ ID3D10Blob *blob = NULL, *errors = NULL;
+ HRESULT hr;
- return CreateWindowA("d3d9_test_wc", "d3d9_test", 0, 0, 0, 0, 0, 0, 0, 0, 0);
+ hr = ppD3DCompile(source, strlen(source), NULL, NULL, NULL, "main", target, 0, 0, &blob, &errors);
+ ok_(__FILE__, line)(hr == D3D_OK, "Failed to compile shader, hr %#x.\n", hr);
+ if (errors)
+ {
+ if (winetest_debug > 1)
+ trace_(__FILE__, line)("%s\n", (char *)ID3D10Blob_GetBufferPointer(errors));
+ ID3D10Blob_Release(errors);
+ }
+ return blob;
}
-static IDirect3DDevice9 *init_d3d9(IDirect3DVertexDeclaration9 **vdeclaration,
- IDirect3DVertexBuffer9 **quad_geometry, IDirect3DVertexShader9 **vshader_passthru)
+static IDirect3DDevice9 *create_d3d9_device(HWND window)
{
- static const struct vertex quad_vertices[4] =
+ D3DPRESENT_PARAMETERS present_parameters =
{
- {-1.0f, -1.0f, 0.0f, 0.0f, 1.0f},
- {-1.0f, 1.0f, 0.0f, 0.0f, 0.0f},
- { 1.0f, -1.0f, 0.0f, 1.0f, 1.0f},
- { 1.0f, 1.0f, 0.0f, 1.0f, 0.0f}
+ .Windowed = TRUE,
+ .hDeviceWindow = window,
+ .SwapEffect = D3DSWAPEFFECT_DISCARD,
+ .BackBufferWidth = 640,
+ .BackBufferHeight = 480,
+ .BackBufferFormat = D3DFMT_A8R8G8B8,
};
-
- static const D3DVERTEXELEMENT9 vdeclelements[] =
- {
- {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
- {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
- D3DDECL_END()
- };
-
- static const char *vshader_passthru_hlsl =
- "float4 vshader(float4 pos: POSITION, inout float2 texcoord: TEXCOORD0): POSITION\n"
- "{\n"
- " return pos;\n"
- "}";
-
- IDirect3D9 *d3d9_ptr;
- IDirect3DDevice9 *device_ptr = NULL;
- D3DPRESENT_PARAMETERS present_parameters;
-
- void *temp_geometry_vertices;
-
- ID3D10Blob *compiled = NULL;
- ID3D10Blob *errors = NULL;
-
+ IDirect3DDevice9 *device;
+ IDirect3DSurface9 *rt;
+ IDirect3D9 *d3d;
+ D3DCAPS9 caps;
HRESULT hr;
- d3d9_ptr = Direct3DCreate9(D3D_SDK_VERSION);
- if (!d3d9_ptr)
+ d3d = Direct3DCreate9(D3D_SDK_VERSION);
+ ok(!!d3d, "Failed to create a D3D object.\n");
+
+ hr = IDirect3D9_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, window,
+ D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device);
+ IDirect3D9_Release(d3d);
+ if (FAILED(hr))
{
- skip("could not create D3D9\n");
+ skip("Failed to create a 3D device, hr %#x.\n", hr);
return NULL;
}
- hr = IDirect3D9_CheckDeviceFormat(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
- 0, D3DRTYPE_SURFACE, D3DFMT_A32B32G32R32F);
- if (FAILED(hr))
+ hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
+ ok(hr == D3D_OK, "Failed to get device caps, hr %#x.\n", hr);
+ if (caps.PixelShaderVersion < D3DPS_VERSION(2, 0) || caps.VertexShaderVersion < D3DVS_VERSION(2, 0))
{
- skip("A32B32G32R32F format not available on this device\n");
- IDirect3D9_Release(d3d9_ptr);
+ skip("No shader model 2 support.\n");
+ IDirect3DDevice9_Release(device);
return NULL;
}
- ZeroMemory(&present_parameters, sizeof(present_parameters));
- present_parameters.Windowed = TRUE;
- present_parameters.hDeviceWindow = create_window();
- present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
-
- hr = IDirect3D9_CreateDevice(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, NULL,
- D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device_ptr);
- IDirect3D9_Release(d3d9_ptr);
- if (FAILED(hr))
+ if (FAILED(hr = IDirect3DDevice9_CreateRenderTarget(device, 640, 480, D3DFMT_A32B32G32R32F,
+ D3DMULTISAMPLE_NONE, 0, FALSE, &rt, NULL)))
{
- skip("could not create Direct3D9 device\n");
+ skip("Failed to create an A32B32G32R32F surface, hr %#x.\n", hr);
+ IDirect3DDevice9_Release(device);
return NULL;
}
+ ok(hr == D3D_OK, "Failed to create render target, hr %#x.\n", hr);
+ hr = IDirect3DDevice9_SetRenderTarget(device, 0, rt);
+ ok(hr == D3D_OK, "Failed to set render target, hr %#x.\n", hr);
+ IDirect3DSurface9_Release(rt);
- /* Create the quad geometry */
- hr = IDirect3DDevice9_CreateVertexBuffer(device_ptr, 4 * sizeof(struct vertex),
- D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, quad_geometry, NULL);
- ok(SUCCEEDED(hr),
- "Could not create vertex buffer, IDirect3DDevice9_CreateVertexBuffer returned: %08x\n", hr);
-
- hr = IDirect3DVertexBuffer9_Lock(*quad_geometry, 0, sizeof(quad_vertices), &temp_geometry_vertices, 0);
- ok(SUCCEEDED(hr), "IDirect3DVertexBuffer9_Lock returned: %08x\n", hr);
- memcpy(temp_geometry_vertices, quad_vertices, sizeof(quad_vertices));
- IDirect3DVertexBuffer9_Unlock(*quad_geometry);
+ return device;
+}
- hr = IDirect3DDevice9_CreateVertexDeclaration(device_ptr, vdeclelements, vdeclaration);
- ok(SUCCEEDED(hr), "Could not create vertex declaration: "
- "IDirect3DDevice9_CreateVertexDeclaration returned: %08x\n", hr);
+#define draw_quad(device, ps_code) draw_quad_(__LINE__, device, ps_code)
+static void draw_quad_(unsigned int line, IDirect3DDevice9 *device, ID3D10Blob *ps_code)
+{
+ IDirect3DVertexDeclaration9 *vertex_declaration;
+ IDirect3DVertexShader9 *vs;
+ IDirect3DPixelShader9 *ps;
+ ID3D10Blob *vs_code;
+ HRESULT hr;
- hr = IDirect3DDevice9_SetVertexDeclaration(device_ptr, *vdeclaration);
- ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned: %08x\n", hr);
+ static const D3DVERTEXELEMENT9 decl_elements[] =
+ {
+ {0, 0, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
+ {0, 8, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
+ D3DDECL_END()
+ };
- /* Create a simple vertex shader to just pass through the values */
- hr = ppD3DCompile(vshader_passthru_hlsl, strlen(vshader_passthru_hlsl), NULL,
- NULL, NULL, "vshader", "vs_1_1", 0, 0, &compiled, &errors);
- if (FAILED(hr))
+ static const struct
{
- skip("not compiling vertex shader due to lacking wine HLSL support!\n");
- if (errors)
- ID3D10Blob_Release(errors);
- return NULL;
+ struct vec2 position;
+ struct vec2 t0;
}
+ quad[] =
+ {
+ {{-1.0f, -1.0f}, {0.0f, 1.0f}},
+ {{-1.0f, 1.0f}, {0.0f, 0.0f}},
+ {{ 1.0f, -1.0f}, {1.0f, 1.0f}},
+ {{ 1.0f, 1.0f}, {1.0f, 0.0f}},
+ };
- hr = IDirect3DDevice9_CreateVertexShader(device_ptr, ID3D10Blob_GetBufferPointer(compiled),
- vshader_passthru);
- ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateVertexShader returned: %08x\n", hr);
- ID3D10Blob_Release(compiled);
+ static const char vs_source[] =
+ "float4 main(float4 pos : POSITION, inout float2 texcoord : TEXCOORD0) : POSITION\n"
+ "{\n"
+ " return pos;\n"
+ "}";
- return device_ptr;
-}
+ hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
+ ok_(__FILE__, line)(hr == D3D_OK, "Failed to create vertex declaration, hr %#x.\n", hr);
-/* Convenience functions */
-static void set_float4_d3d9(IDirect3DDevice9 *device, ID3DXConstantTable *constants, const char *name,
- float x, float y, float z, float w)
-{
- D3DXVECTOR4 vector;
- vector.x = x;
- vector.y = y;
- vector.z = z;
- vector.w = w;
- ID3DXConstantTable_SetVector(constants, device, name, &vector);
-}
+ hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
+ ok_(__FILE__, line)(hr == D3D_OK, "Failed to set vertex declaration, hr %#x.\n", hr);
-/* Compile our pixel shader and get back the compiled version and a constant table */
-static IDirect3DPixelShader9 *compile_pixel_shader9(IDirect3DDevice9 *device, const char *shader,
- const char *profile, ID3DXConstantTable **constants)
-{
- ID3D10Blob *compiled = NULL;
- ID3D10Blob *errors = NULL;
- IDirect3DPixelShader9 *pshader;
- HRESULT hr;
+ vs_code = compile_shader(vs_source, "vs_2_0");
+
+ hr = IDirect3DDevice9_CreateVertexShader(device, ID3D10Blob_GetBufferPointer(vs_code), &vs);
+ ok_(__FILE__, line)(hr == D3D_OK, "Failed to create vertex shader, hr %#x.\n", hr);
+
+ hr = IDirect3DDevice9_SetVertexShader(device, vs);
+ ok_(__FILE__, line)(hr == D3D_OK, "Failed to set vertex shader, hr %#x.\n", hr);
+
+ hr = IDirect3DDevice9_CreatePixelShader(device, ID3D10Blob_GetBufferPointer(ps_code), &ps);
+ ok_(__FILE__, line)(hr == D3D_OK, "Failed to create pixel shader, hr %#x.\n", hr);
+
+ hr = IDirect3DDevice9_SetPixelShader(device, ps);
+ ok_(__FILE__, line)(hr == D3D_OK, "Failed to set pixel shader, hr %#x.\n", hr);
+
+ hr = IDirect3DDevice9_BeginScene(device);
+ ok_(__FILE__, line)(hr == D3D_OK, "Failed to draw, hr %#x.\n", hr);
- hr = ppD3DCompile(shader, strlen(shader), NULL, NULL,
- NULL, "test", profile, /* test is the name of the entry point of our shader */
- 0, 0, &compiled, &errors);
- ok(hr == D3D_OK, "Pixel shader %s compilation failed: %s\n", shader,
- errors ? (char *)ID3D10Blob_GetBufferPointer(errors) : "");
- if (FAILED(hr)) return NULL;
+ hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(*quad));
+ ok_(__FILE__, line)(hr == D3D_OK, "Failed to draw, hr %#x.\n", hr);
- hr = pD3DXGetShaderConstantTable(ID3D10Blob_GetBufferPointer(compiled), constants);
- ok(hr == D3D_OK, "Could not get constant table from compiled pixel shader\n");
+ hr = IDirect3DDevice9_EndScene(device);
+ ok_(__FILE__, line)(hr == D3D_OK, "Failed to draw, hr %#x.\n", hr);
- hr = IDirect3DDevice9_CreatePixelShader(device, ID3D10Blob_GetBufferPointer(compiled), &pshader);
- ok(SUCCEEDED(hr), "IDirect3DDevice9_CreatePixelShader returned: %08x\n", hr);
- ID3D10Blob_Release(compiled);
- return pshader;
+ IDirect3DVertexShader9_Release(vs);
+ IDirect3DPixelShader9_Release(ps);
+ ID3D10Blob_Release(vs_code);
}
-/* Draw a full screen quad */
-static void draw_quad_with_shader9(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_geometry)
+static struct vec4 get_readback_vec4_d3d9(IDirect3DDevice9 *device, unsigned int x, unsigned int y)
{
+ IDirect3DSurface9 *surface = NULL, *target = NULL;
+ RECT rect = {x, y, x + 1, y + 1};
+ D3DLOCKED_RECT locked_rect;
+ D3DSURFACE_DESC desc;
+ struct vec4 ret;
HRESULT hr;
- D3DXMATRIX projection_matrix;
- pD3DXMatrixOrthoLH(&projection_matrix, 2.0f, 2.0f, 0.0f, 1.0f);
- IDirect3DDevice9_SetTransform(device, D3DTS_PROJECTION, &projection_matrix);
+ hr = IDirect3DDevice9Ex_GetRenderTarget(device, 0, &target);
+ ok(hr == D3D_OK, "Failed to get render target, hr %#x.\n", hr);
- hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);
- ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned: %08x\n", hr);
+ hr = IDirect3DSurface9_GetDesc(target, &desc);
+ ok(hr == D3D_OK, "Failed to get surface desc, hr %#x.\n", hr);
+ hr = IDirect3DDevice9Ex_CreateOffscreenPlainSurface(device, desc.Width, desc.Height,
+ desc.Format, D3DPOOL_SYSTEMMEM, &surface, NULL);
+ ok(hr == D3D_OK, "Failed to create surface, hr %#x.\n", hr);
- hr = IDirect3DDevice9_BeginScene(device);
- ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned: %08x\n", hr);
+ hr = IDirect3DDevice9Ex_GetRenderTargetData(device, target, surface);
+ ok(hr == D3D_OK, "Failed to get render target data, hr %#x.\n", hr);
- hr = IDirect3DDevice9_SetStreamSource(device, 0, quad_geometry, 0, sizeof(struct vertex));
- ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource returned: %08x\n", hr);
- hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
- ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive returned: %08x\n", hr);
+ hr = IDirect3DSurface9_LockRect(surface, &locked_rect, &rect, D3DLOCK_READONLY);
+ ok(hr == D3D_OK, "Failed to lock surface, hr %#x.\n", hr);
- hr = IDirect3DDevice9_EndScene(device);
- ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned: %08x\n", hr);
+ ret = ((struct vec4 *)locked_rect.pBits)[0];
+
+ IDirect3DSurface9_UnlockRect(surface);
+
+ IDirect3DSurface9_Release(target);
+ IDirect3DSurface9_Release(surface);
+ return ret;
}
-static void setup_device9(IDirect3DDevice9 *device, IDirect3DSurface9 **render_target,
- IDirect3DSurface9 **readback, D3DFORMAT format, unsigned int width, unsigned int height,
- IDirect3DVertexShader9 *vshader, IDirect3DPixelShader9 *pshader)
+#define set_float_d3d9(a, b, c, d) set_float_d3d9_(__LINE__, a, b, c, d)
+static void set_float_d3d9_(unsigned int line, IDirect3DDevice9 *device, ID3D10Blob *blob, const char *name, float f)
{
+ ID3DXConstantTable *constants;
HRESULT hr;
- hr = IDirect3DDevice9_CreateRenderTarget(device, width, height, format,
- D3DMULTISAMPLE_NONE, 0, FALSE, render_target, NULL);
- ok(hr == D3D_OK, "IDirect3DDevice9_CreateRenderTarget returned: %08x\n", hr);
-
- /* The Direct3D 9 docs state that we cannot lock a render target surface,
- instead we must copy the render target onto this surface to lock it */
- hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, width, height, format,
- D3DPOOL_SYSTEMMEM, readback, NULL);
- ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface returned: %08x\n", hr);
-
- hr = IDirect3DDevice9_SetRenderTarget(device, 0, *render_target);
- ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget returned: %08x\n", hr);
-
- hr = IDirect3DDevice9_SetVertexShader(device, vshader);
- ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned: %08x\n", hr);
- hr = IDirect3DDevice9_SetPixelShader(device, pshader);
- ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned: %08x\n", hr);
+
+ hr = pD3DXGetShaderConstantTable(ID3D10Blob_GetBufferPointer(blob), &constants);
+ ok_(__FILE__, line)(hr == D3D_OK, "Failed to get constant table, hr %#x.\n", hr);
+
+ hr = ID3DXConstantTable_SetFloat(constants, device, name, f);
+ ok_(__FILE__, line)(hr == D3D_OK, "Failed to set constant, hr %#x.\n", hr);
+
+ ID3DXConstantTable_Release(constants);
}
-static BOOL colors_match(D3DXCOLOR a, D3DXCOLOR b, float epsilon)
+#define set_float4_d3d9(a, b, c, d, e, f, g) set_float4_d3d9_(__LINE__, a, b, c, d, e, f, g)
+static void set_float4_d3d9_(unsigned int line, IDirect3DDevice9 *device, ID3D10Blob *blob,
+ const char *name, float x, float y, float z, float w)
{
- return (fabs(a.r - b.r) < epsilon && fabs(a.g - b.g) < epsilon && fabs(a.b - b.b) < epsilon &&
- fabs(a.a - b.a) < epsilon);
+ ID3DXConstantTable *constants;
+ D3DXVECTOR4 v = {x, y, z, w};
+ HRESULT hr;
+
+ hr = pD3DXGetShaderConstantTable(ID3D10Blob_GetBufferPointer(blob), &constants);
+ ok_(__FILE__, line)(hr == D3D_OK, "Failed to get constant table, hr %#x.\n", hr);
+
+ hr = ID3DXConstantTable_SetVector(constants, device, name, &v);
+ ok_(__FILE__, line)(hr == D3D_OK, "Failed to set constant, hr %#x.\n", hr);
+
+ ID3DXConstantTable_Release(constants);
}
-/* Compute a shader on a width by height buffer and probes certain locations
- to see if they are as expected. */
-static void compute_shader_probe9(IDirect3DDevice9 *device, IDirect3DVertexShader9 *vshader,
- IDirect3DPixelShader9 *pshader, IDirect3DVertexBuffer9 *quad_geometry,
- const struct hlsl_probe_info *probes, unsigned int count,
- unsigned int width, unsigned int height, unsigned int line_number)
+static BOOL compare_float(float f, float g, unsigned int ulps)
{
- IDirect3DSurface9 *render_target;
- IDirect3DSurface9 *readback;
+ int x = *(int *)&f;
+ int y = *(int *)&g;
- HRESULT hr;
- D3DLOCKED_RECT lr;
- D3DXCOLOR *pbits_data;
- unsigned int i;
+ if (x < 0)
+ x = INT_MIN - x;
+ if (y < 0)
+ y = INT_MIN - y;
- setup_device9(device, &render_target, &readback, D3DFMT_A32B32G32R32F,
- width, height, vshader, pshader);
-
- /* Draw the quad with the shader and read back the data */
- draw_quad_with_shader9(device, quad_geometry);
- IDirect3DDevice9_GetRenderTargetData(device, render_target, readback);
- hr = IDirect3DSurface9_LockRect(readback, &lr, NULL, D3DLOCK_READONLY);
- ok(hr == D3D_OK, "IDirect3DSurface9_LockRect returned: %08x\n", hr);
- pbits_data = lr.pBits;
-
- /* Now go through the probes and check each one */
- for (i = 0; i < count; i++, probes++) {
- int index = probes->x + (probes->y * lr.Pitch / sizeof(D3DXCOLOR));
- ok(colors_match(probes->c, pbits_data[index], probes->epsilon),
- "Line %d: At (%d, %d): %s: Expected (%.04f,%.04f,%.04f, %.04f), got "
- "(%.04f,%.04f,%.04f,%.04f)\n", line_number, probes->x, probes->y, probes->message,
- probes->c.r, probes->c.g, probes->c.b, probes->c.a, pbits_data[index].r,
- pbits_data[index].g, pbits_data[index].b, pbits_data[index].a);
- }
+ if (abs(x - y) > ulps)
+ return FALSE;
- hr = IDirect3DSurface9_UnlockRect(readback);
- ok(hr == D3D_OK, "IDirect3DSurface9_UnlockRect returned: %08x\n", hr);
+ return TRUE;
+}
+
+static BOOL compare_vec4(const struct vec4 *vec, float x, float y, float z, float w, unsigned int ulps)
+{
+ return compare_float(vec->x, x, ulps)
+ && compare_float(vec->y, y, ulps)
+ && compare_float(vec->z, z, ulps)
+ && compare_float(vec->w, w, ulps);
+}
- /* We now present the scene. This is mostly for debugging purposes, since GetRenderTargetData
- also waits for drawing commands to complete. The reason this call is here and not in a
- draw function is because the contents of the render target surface are invalidated after
- this call. */
- hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
- ok(hr == D3D_OK, "IDirect3DDevice9_Present returned: %08x\n", hr);
+static HWND create_window(void)
+{
+ WNDCLASSA wc = {0};
+ wc.lpfnWndProc = DefWindowProcA;
+ wc.lpszClassName = "d3d9_test_wc";
+ RegisterClassA(&wc);
- IDirect3DSurface9_Release(render_target);
- IDirect3DSurface9_Release(readback);
+ return CreateWindowA("d3d9_test_wc", "d3d9_test", 0, 0, 0, 0, 0, 0, 0, 0, 0);
}
-/* Now the actual test functions */
-static void test_swizzle(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_geometry,
- IDirect3DVertexShader9 *vshader_passthru)
+static void test_swizzle(void)
{
- static const struct hlsl_probe_info probes[] =
- {
- {0, 0, {0.0101f, 0.0303f, 0.0202f, 0.0404f}, 0.0001f, "swizzle_test"}
- };
+ IDirect3DDevice9 *device;
+ ID3D10Blob *ps_code;
+ struct vec4 v;
+ HWND window;
- static const char *swizzle_test_shader =
+ static const char ps_source[] =
"uniform float4 color;\n"
- "float4 test(): COLOR\n"
+ "float4 main() : COLOR\n"
"{\n"
" float4 ret = color;\n"
" ret.gb = ret.ra;\n"
@@ -316,36 +292,40 @@ static void test_swizzle(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_
" return ret;\n"
"}";
- ID3DXConstantTable *constants;
- IDirect3DPixelShader9 *pshader;
+ window = create_window();
+ ok(!!window, "Failed to create a window.\n");
- pshader = compile_pixel_shader9(device, swizzle_test_shader, "ps_2_0", &constants);
- if (pshader != NULL)
+ if (!(device = create_d3d9_device(window)))
{
- set_float4_d3d9(device, constants, "color", 0.0303f, 0.0f, 0.0f, 0.0202f);
+ DestroyWindow(window);
+ return;
+ }
+
+ todo_wine ps_code = compile_shader(ps_source, "ps_2_0");
+ if (ps_code)
+ {
+ set_float4_d3d9(device, ps_code, "color", 0.0303f, 0.0f, 0.0f, 0.0202f);
+ draw_quad(device, ps_code);
- compute_shader_probe9(device, vshader_passthru, pshader, quad_geometry,
- probes, ARRAY_SIZE(probes), 1, 1, __LINE__);
+ v = get_readback_vec4_d3d9(device, 0, 0);
+ ok(compare_vec4(&v, 0.0101f, 0.0303f, 0.0202f, 0.0404f, 0),
+ "Got unexpected value {%.8e, %.8e, %.8e, %.8e}.\n", v.x, v.y, v.z, v.w);
- ID3DXConstantTable_Release(constants);
- IDirect3DPixelShader9_Release(pshader);
+ ID3D10Blob_Release(ps_code);
}
+ IDirect3DDevice9_Release(device);
+ DestroyWindow(window);
}
-static void test_math(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_geometry,
- IDirect3DVertexShader9 *vshader_passthru)
+static void test_math(void)
{
- /* Tests order of operations */
- static const float u = 2.5f, v = 0.3f, w = 0.2f, x = 0.7f, y = 0.1f, z = 1.5f;
-
- static const struct hlsl_probe_info probes[] =
- {
- {0, 0, {-12.4300f, 9.8333f, 1.6000f, 34.9999f}, 0.0001f,
- "order of operations test"}
- };
+ IDirect3DDevice9 *device;
+ ID3D10Blob *ps_code;
+ struct vec4 v;
+ HWND window;
- static const char *order_of_operations_shader =
- "float4 test(uniform float u, uniform float v, uniform float w, uniform float x,\n"
+ static const char ps_source[] =
+ "float4 main(uniform float u, uniform float v, uniform float w, uniform float x,\n"
" uniform float y, uniform float z): COLOR\n"
"{\n"
" return float4(x * y - z / w + --u / -v,\n"
@@ -354,101 +334,127 @@ static void test_math(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_geo
" x / y / w);\n"
"}";
- ID3DXConstantTable *constants;
- IDirect3DPixelShader9 *pshader;
+ window = create_window();
+ ok(!!window, "Failed to create a window.\n");
- pshader = compile_pixel_shader9(device, order_of_operations_shader, "ps_2_0", &constants);
- if (pshader != NULL)
+ if (!(device = create_d3d9_device(window)))
{
- ID3DXConstantTable_SetFloat(constants, device, "$u", u);
- ID3DXConstantTable_SetFloat(constants, device, "$v", v);
- ID3DXConstantTable_SetFloat(constants, device, "$w", w);
- ID3DXConstantTable_SetFloat(constants, device, "$x", x);
- ID3DXConstantTable_SetFloat(constants, device, "$y", y);
- ID3DXConstantTable_SetFloat(constants, device, "$z", z);
-
- compute_shader_probe9(device, vshader_passthru, pshader, quad_geometry,
- probes, ARRAY_SIZE(probes), 1, 1, __LINE__);
+ DestroyWindow(window);
+ return;
+ }
- ID3DXConstantTable_Release(constants);
- IDirect3DPixelShader9_Release(pshader);
+ todo_wine ps_code = compile_shader(ps_source, "ps_2_0");
+ if (ps_code)
+ {
+ set_float_d3d9(device, ps_code, "$u", 2.5f);
+ set_float_d3d9(device, ps_code, "$v", 0.3f);
+ set_float_d3d9(device, ps_code, "$w", 0.2f);
+ set_float_d3d9(device, ps_code, "$x", 0.7f);
+ set_float_d3d9(device, ps_code, "$y", 0.1f);
+ set_float_d3d9(device, ps_code, "$z", 1.5f);
+ draw_quad(device, ps_code);
+
+ v = get_readback_vec4_d3d9(device, 0, 0);
+ ok(compare_vec4(&v, -12.43f, 9.833333f, 1.6f, 35.0f, 1),
+ "Got unexpected value {%.8e, %.8e, %.8e, %.8e}.\n", v.x, v.y, v.z, v.w);
+
+ ID3D10Blob_Release(ps_code);
}
+ IDirect3DDevice9_Release(device);
+ DestroyWindow(window);
}
-static void test_conditionals(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_geometry,
- IDirect3DVertexShader9 *vshader_passthru)
+static void test_conditionals(void)
{
- static const struct hlsl_probe_info if_greater_probes[] =
- {
- { 0, 0, {0.9f, 0.8f, 0.7f, 0.6f}, 0.0001f, "if greater test"},
- { 5, 0, {0.9f, 0.8f, 0.7f, 0.6f}, 0.0001f, "if greater test"},
- {10, 0, {0.9f, 0.8f, 0.7f, 0.6f}, 0.0001f, "if greater test"},
- {15, 0, {0.9f, 0.8f, 0.7f, 0.6f}, 0.0001f, "if greater test"},
- {25, 0, {0.1f, 0.2f, 0.3f, 0.4f}, 0.0001f, "if greater test"},
- {30, 0, {0.1f, 0.2f, 0.3f, 0.4f}, 0.0001f, "if greater test"}
- };
+ IDirect3DDevice9 *device;
+ ID3D10Blob *ps_code;
+ unsigned int i;
+ struct vec4 v;
+ HWND window;
- static const char *if_greater_shader =
- "float4 test(float2 pos: TEXCOORD0): COLOR\n"
+ static const char ps_if_source[] =
+ "float4 main(float2 pos : TEXCOORD0) : COLOR\n"
"{\n"
- " if((pos.x * 32.0) > 20.0)\n"
+ " if((pos.x * 640.0) > 200.0)\n"
" return float4(0.1, 0.2, 0.3, 0.4);\n"
" else\n"
" return float4(0.9, 0.8, 0.7, 0.6);\n"
"}";
- static const struct hlsl_probe_info ternary_operator_probes[] =
- {
- {0, 0, {0.50f, 0.25f, 0.50f, 0.75f}, 0.00001f, "ternary operator test"},
- {1, 0, {0.50f, 0.25f, 0.50f, 0.75f}, 0.00001f, "ternary operator test"},
- {2, 0, {0.50f, 0.25f, 0.50f, 0.75f}, 0.00001f, "ternary operator test"},
- {3, 0, {0.50f, 0.25f, 0.50f, 0.75f}, 0.00001f, "ternary operator test"},
- {4, 0, {0.60f, 0.80f, 0.10f, 0.20f}, 0.00001f, "ternary operator test"},
- {5, 0, {0.60f, 0.80f, 0.10f, 0.20f}, 0.00001f, "ternary operator test"},
- {6, 0, {0.60f, 0.80f, 0.10f, 0.20f}, 0.00001f, "ternary operator test"},
- {7, 0, {0.60f, 0.80f, 0.10f, 0.20f}, 0.00001f, "ternary operator test"}
- };
-
- static const char *ternary_operator_shader =
- "float4 test(float2 pos: TEXCOORD0): COLOR\n"
+ static const char ps_ternary_source[] =
+ "float4 main(float2 pos : TEXCOORD0) : COLOR\n"
"{\n"
" return (pos.x < 0.5?float4(0.5, 0.25, 0.5, 0.75):float4(0.6, 0.8, 0.1, 0.2));\n"
"}";
- ID3DXConstantTable *constants;
- IDirect3DPixelShader9 *pshader;
+ window = create_window();
+ ok(!!window, "Failed to create a window.\n");
+
+ if (!(device = create_d3d9_device(window)))
+ {
+ DestroyWindow(window);
+ return;
+ }
- pshader = compile_pixel_shader9(device, if_greater_shader, "ps_2_0", &constants);
- if (pshader != NULL)
+ todo_wine ps_code = compile_shader(ps_if_source, "ps_2_0");
+ if (ps_code)
{
- compute_shader_probe9(device, vshader_passthru, pshader, quad_geometry, if_greater_probes,
- ARRAY_SIZE(if_greater_probes), 32, 1, __LINE__);
+ draw_quad(device, ps_code);
- ID3DXConstantTable_Release(constants);
- IDirect3DPixelShader9_Release(pshader);
+ for (i = 0; i < 200; i += 40)
+ {
+ v = get_readback_vec4_d3d9(device, i, 0);
+ ok(compare_vec4(&v, 0.9f, 0.8f, 0.7f, 0.6f, 0),
+ "Got unexpected value {%.8e, %.8e, %.8e, %.8e}.\n", v.x, v.y, v.z, v.w);
+ }
+
+ for (i = 240; i < 640; i += 40)
+ {
+ v = get_readback_vec4_d3d9(device, i, 0);
+ ok(compare_vec4(&v, 0.1f, 0.2f, 0.3f, 0.4f, 0),
+ "Got unexpected value {%.8e, %.8e, %.8e, %.8e}.\n", v.x, v.y, v.z, v.w);
+ }
+
+ ID3D10Blob_Release(ps_code);
}
- pshader = compile_pixel_shader9(device, ternary_operator_shader, "ps_2_0", &constants);
- if (pshader != NULL)
+ todo_wine ps_code = compile_shader(ps_ternary_source, "ps_2_0");
+ if (ps_code)
{
- compute_shader_probe9(device, vshader_passthru, pshader, quad_geometry, ternary_operator_probes,
- ARRAY_SIZE(ternary_operator_probes), 8, 1, __LINE__);
+ draw_quad(device, ps_code);
- ID3DXConstantTable_Release(constants);
- IDirect3DPixelShader9_Release(pshader);
+ for (i = 0; i < 320; i += 40)
+ {
+ v = get_readback_vec4_d3d9(device, i, 0);
+ ok(compare_vec4(&v, 0.5f, 0.25f, 0.5f, 0.75f, 0),
+ "Got unexpected value {%.8e, %.8e, %.8e, %.8e}.\n", v.x, v.y, v.z, v.w);
+ }
+
+ for (i = 360; i < 640; i += 40)
+ {
+ v = get_readback_vec4_d3d9(device, i, 0);
+ ok(compare_vec4(&v, 0.6f, 0.8f, 0.1f, 0.2f, 0),
+ "Got unexpected value {%.8e, %.8e, %.8e, %.8e}.\n", v.x, v.y, v.z, v.w);
+ }
+
+ ID3D10Blob_Release(ps_code);
}
+
+ IDirect3DDevice9_Release(device);
+ DestroyWindow(window);
}
-static void test_float_vectors(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_geometry,
- IDirect3DVertexShader9 *vshader_passthru)
+static void test_float_vectors(void)
{
- static const struct hlsl_probe_info vec4_indexing_test1_probes[] =
- {
- {0, 0, {0.020f, 0.245f, 0.351f, 1.000f}, 0.0001f, "vec4 indexing test 1"}
- };
+ ID3DXConstantTable *constants;
+ IDirect3DDevice9 *device;
+ ID3D10Blob *ps_code;
+ struct vec4 v;
+ HWND window;
+ HRESULT hr;
- static const char *vec4_indexing_test1_shader =
- "float4 test(): COLOR\n"
+ static const char ps_indexing_source[] =
+ "float4 main() : COLOR\n"
"{\n"
" float4 color;\n"
" color[0] = 0.020;\n"
@@ -458,15 +464,10 @@ static void test_float_vectors(IDirect3DDevice9 *device, IDirect3DVertexBuffer9
" return color;\n"
"}";
- static const struct hlsl_probe_info vec4_indexing_test2_probes[] =
- {
- {0, 0, {0.5f, 0.3f, 0.8f, 0.2f}, 0.0001f, "vec4 indexing test 2"}
- };
-
- /* We have this uniform i here so the compiler can't optimize */
- static const char *vec4_indexing_test2_shader =
+ /* A uniform index is used so that the compiler can't optimize. */
+ static const char ps_uniform_indexing_source[] =
"uniform int i;\n"
- "float4 test(): COLOR\n"
+ "float4 main() : COLOR\n"
"{\n"
" float4 color = float4(0.5, 0.4, 0.3, 0.2);\n"
" color.g = color[i];\n"
@@ -474,73 +475,58 @@ static void test_float_vectors(IDirect3DDevice9 *device, IDirect3DVertexBuffer9
" return color;\n"
"}";
- ID3DXConstantTable *constants;
- IDirect3DPixelShader9 *pshader;
+ window = create_window();
+ ok(!!window, "Failed to create a window.\n");
- pshader = compile_pixel_shader9(device, vec4_indexing_test1_shader, "ps_2_0", &constants);
- if (pshader != NULL)
+ if (!(device = create_d3d9_device(window)))
{
- compute_shader_probe9(device, vshader_passthru, pshader, quad_geometry, vec4_indexing_test1_probes,
- ARRAY_SIZE(vec4_indexing_test1_probes), 1, 1, __LINE__);
-
- ID3DXConstantTable_Release(constants);
- IDirect3DPixelShader9_Release(pshader);
+ DestroyWindow(window);
+ return;
}
- pshader = compile_pixel_shader9(device, vec4_indexing_test2_shader, "ps_2_0", &constants);
- if (pshader != NULL)
+ todo_wine ps_code = compile_shader(ps_indexing_source, "ps_2_0");
+ if (ps_code)
{
- ID3DXConstantTable_SetInt(constants, device, "i", 2);
+ draw_quad(device, ps_code);
+
+ v = get_readback_vec4_d3d9(device, 0, 0);
+ ok(compare_vec4(&v, 0.02f, 0.245f, 0.351f, 1.0f, 0),
+ "Got unexpected value {%.8e, %.8e, %.8e, %.8e}.\n", v.x, v.y, v.z, v.w);
- compute_shader_probe9(device, vshader_passthru, pshader, quad_geometry, vec4_indexing_test2_probes,
- ARRAY_SIZE(vec4_indexing_test2_probes), 32, 1, __LINE__);
+ ID3D10Blob_Release(ps_code);
+ }
+ todo_wine ps_code = compile_shader(ps_uniform_indexing_source, "ps_2_0");
+ if (ps_code)
+ {
+ hr = pD3DXGetShaderConstantTable(ID3D10Blob_GetBufferPointer(ps_code), &constants);
+ ok(hr == D3D_OK, "Failed to get constants, hr %#x.\n", hr);
+ hr = ID3DXConstantTable_SetInt(constants, device, "i", 2);
+ ok(hr == D3D_OK, "Failed to set constant, hr %#x.\n", hr);
ID3DXConstantTable_Release(constants);
- IDirect3DPixelShader9_Release(pshader);
+ draw_quad(device, ps_code);
+
+ v = get_readback_vec4_d3d9(device, 0, 0);
+ ok(compare_vec4(&v, 0.5f, 0.3f, 0.8f, 0.2f, 0),
+ "Got unexpected value {%.8e, %.8e, %.8e, %.8e}.\n", v.x, v.y, v.z, v.w);
+
+ ID3D10Blob_Release(ps_code);
}
+
+ IDirect3DDevice9_Release(device);
+ DestroyWindow(window);
}
-static void test_trig(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_geometry,
- IDirect3DVertexShader9 *vshader_passthru)
+static void test_trig(void)
{
- static const struct hlsl_probe_info sincos_probes[] =
- {
- {0, 0, {0.5000f, 1.0000f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {1, 0, {0.5975f, 0.9904f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {2, 0, {0.6913f, 0.9620f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {3, 0, {0.7778f, 0.9160f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {4, 0, {0.8536f, 0.8536f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {5, 0, {0.9157f, 0.7778f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {6, 0, {0.9620f, 0.6913f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {7, 0, {0.9904f, 0.5975f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {8, 0, {1.0000f, 0.5000f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {9, 0, {0.9904f, 0.4025f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {10, 0, {0.9619f, 0.3087f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {11, 0, {0.9157f, 0.2222f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {12, 0, {0.8536f, 0.1464f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {13, 0, {0.7778f, 0.0843f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {14, 0, {0.6913f, 0.0381f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {15, 0, {0.5975f, 0.0096f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {16, 0, {0.5000f, 0.0000f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {17, 0, {0.4025f, 0.0096f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {18, 0, {0.3087f, 0.0381f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {19, 0, {0.2222f, 0.0843f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {20, 0, {0.1464f, 0.1464f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {21, 0, {0.0843f, 0.2222f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {22, 0, {0.0381f, 0.3087f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {23, 0, {0.0096f, 0.4025f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {24, 0, {0.0000f, 0.5000f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {25, 0, {0.0096f, 0.5975f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {26, 0, {0.0381f, 0.6913f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {27, 0, {0.0843f, 0.7778f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {28, 0, {0.1464f, 0.8536f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {29, 0, {0.2222f, 0.9157f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {30, 0, {0.3087f, 0.9619f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- {31, 0, {0.4025f, 0.9904f, 0.0f, 0.0f}, 0.001f, "sin/cos test"},
- };
+ IDirect3DDevice9 *device;
+ ID3D10Blob *ps_code;
+ unsigned int i;
+ struct vec4 v;
+ HWND window;
- static const char *sincos_shader =
- "float4 test(float x: TEXCOORD0): COLOR\n"
+ static const char ps_source[] =
+ "float4 main(float x : TEXCOORD0) : COLOR\n"
"{\n"
" const float pi2 = 6.2831853;\n"
" float calcd_sin = (sin(x * pi2) + 1)/2;\n"
@@ -548,22 +534,37 @@ static void test_trig(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *quad_geo
" return float4(calcd_sin, calcd_cos, 0, 0);\n"
"}";
- ID3DXConstantTable *constants;
- IDirect3DPixelShader9 *pshader;
+ window = create_window();
+ ok(!!window, "Failed to create a window.\n");
+
+ if (!(device = create_d3d9_device(window)))
+ {
+ DestroyWindow(window);
+ return;
+ }
- pshader = compile_pixel_shader9(device, sincos_shader, "ps_2_0", &constants);
- if (pshader != NULL)
+ todo_wine ps_code = compile_shader(ps_source, "ps_2_0");
+ if (ps_code)
{
- compute_shader_probe9(device, vshader_passthru, pshader, quad_geometry, sincos_probes,
- ARRAY_SIZE(sincos_probes), 32, 1, __LINE__);
+ draw_quad(device, ps_code);
- ID3DXConstantTable_Release(constants);
- IDirect3DPixelShader9_Release(pshader);
+ for (i = 0; i < 32; ++i)
+ {
+ float expect_x = (sinf(i * 2 * M_PI / 32) + 1.0f) / 2.0f;
+ float expect_y = (cosf(i * 2 * M_PI / 32) + 1.0f) / 2.0f;
+ v = get_readback_vec4_d3d9(device, i * 640 / 32, 0);
+ ok(compare_vec4(&v, expect_x, expect_y, 0.0f, 0.0f, 4096),
+ "Test %u: Got {%.8e, %.8e, %.8e, %.8e}, expected {%.8e, %.8e, %.8e, %.8e}.\n",
+ i, v.x, v.y, v.z, v.w, expect_x, expect_y, 0.0f, 0.0f);
+ }
+
+ ID3D10Blob_Release(ps_code);
}
+ IDirect3DDevice9_Release(device);
+ DestroyWindow(window);
}
-static void test_fail(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *qquad_geometry,
- IDirect3DVertexShader9 *vshader_passthru)
+static void test_fail(void)
{
static const char *tests[] =
{
@@ -619,10 +620,11 @@ static void test_fail(IDirect3DDevice9 *device, IDirect3DVertexBuffer9 *qquad_ge
{
compiled = errors = NULL;
hr = ppD3DCompile(tests[i], strlen(tests[i]), NULL, NULL, NULL, "test", "ps_2_0", 0, 0, &compiled, &errors);
- ok(hr == E_FAIL, "Test %u, got unexpected hr %#x.\n", i, hr);
- ok(!!errors, "Test %u, expected non-NULL error blob.\n", i);
+ todo_wine ok(hr == E_FAIL, "Test %u, got unexpected hr %#x.\n", i, hr);
+ todo_wine_if (i == 1) ok(!!errors, "Test %u, expected non-NULL error blob.\n", i);
ok(!compiled, "Test %u, expected no compiled shader blob.\n", i);
- ID3D10Blob_Release(errors);
+ if (errors)
+ ID3D10Blob_Release(errors);
}
}
@@ -642,12 +644,6 @@ static BOOL load_d3dcompiler(void)
START_TEST(hlsl)
{
- D3DCAPS9 caps;
- ULONG refcount;
- IDirect3DDevice9 *device;
- IDirect3DVertexDeclaration9 *vdeclaration;
- IDirect3DVertexBuffer9 *quad_geometry;
- IDirect3DVertexShader9 *vshader_passthru;
HMODULE mod;
if (!load_d3dcompiler())
@@ -662,40 +658,11 @@ START_TEST(hlsl)
return;
}
pD3DXGetShaderConstantTable = (void *)GetProcAddress(mod, "D3DXGetShaderConstantTable");
- pD3DXMatrixOrthoLH = (void *)GetProcAddress(mod, "D3DXMatrixOrthoLH");
-
- device = init_d3d9(&vdeclaration, &quad_geometry, &vshader_passthru);
- if (!device) return;
-
- /* Make sure we support pixel shaders, before trying to compile them! */
- /* Direct3D 9 (Shader model 1-3 tests) */
- IDirect3DDevice9_GetDeviceCaps(device, &caps);
- if (caps.PixelShaderVersion >= D3DPS_VERSION(2, 0))
- {
- todo_wine
- {
- test_swizzle(device, quad_geometry, vshader_passthru);
- test_math(device, quad_geometry, vshader_passthru);
- test_conditionals(device, quad_geometry, vshader_passthru);
- test_float_vectors(device, quad_geometry, vshader_passthru);
- test_trig(device, quad_geometry, vshader_passthru);
- test_fail(device, quad_geometry, vshader_passthru);
- }
- } else skip("no pixel shader support\n");
-
- /* Reference counting sanity checks */
- if (vshader_passthru)
- {
- refcount = IDirect3DVertexShader9_Release(vshader_passthru);
- ok(!refcount, "Pass-through vertex shader has %u references left\n", refcount);
- }
-
- refcount = IDirect3DVertexBuffer9_Release(quad_geometry);
- ok(!refcount, "Vertex buffer has %u references left\n", refcount);
-
- refcount = IDirect3DVertexDeclaration9_Release(vdeclaration);
- ok(!refcount, "Vertex declaration has %u references left\n", refcount);
- refcount = IDirect3DDevice9_Release(device);
- ok(!refcount, "Device has %u references left\n", refcount);
+ test_swizzle();
+ test_math();
+ test_conditionals();
+ test_float_vectors();
+ test_trig();
+ test_fail();
}
--
2.25.0
