[PATCH 1/6] d3dx9_36/tests: Added HLSL test suite.
Travis Athougies
iammisc at gmail.com
Wed Aug 4 17:05:47 CDT 2010
Changes from last try:
- patch is now split into 6 patches
- a few cosmetic improvements
---
dlls/d3dx9_36/tests/Makefile.in | 1 +
dlls/d3dx9_36/tests/hlsl.c | 318 +++++++++++++++++++++++++++++++++++++++
include/d3dx9shader.h | 11 ++
3 files changed, 330 insertions(+), 0 deletions(-)
create mode 100644 dlls/d3dx9_36/tests/hlsl.c
diff --git a/dlls/d3dx9_36/tests/Makefile.in b/dlls/d3dx9_36/tests/Makefile.in
index 4a7aa28..63c27af 100644
--- a/dlls/d3dx9_36/tests/Makefile.in
+++ b/dlls/d3dx9_36/tests/Makefile.in
@@ -9,6 +9,7 @@ C_SRCS = \
asm.c \
core.c \
effect.c \
+ hlsl.c \
line.c \
math.c \
mesh.c \
diff --git a/dlls/d3dx9_36/tests/hlsl.c b/dlls/d3dx9_36/tests/hlsl.c
new file mode 100644
index 0000000..97ca69a
--- /dev/null
+++ b/dlls/d3dx9_36/tests/hlsl.c
@@ -0,0 +1,318 @@
+/*
+ * Copyright (C) 2010 - Travis Athougies
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+#define CINTERFACE
+#define COBJMACROS
+#include "wine/test.h"
+
+#include <d3d9.h>
+#include <d3dx9.h>
+#include <assert.h>
+#include <stdio.h>
+
+struct vertex
+{
+ float x, y, z;
+ float tx, ty;
+};
+
+const struct vertex quad_vertices[4] = {
+ {-1, -1, 0, 0, 1},
+ {-1, 1, 0, 0, 0},
+ {1, -1, 0, 1, 1},
+ {1, 1, 0, 1, 0}
+};
+
+const D3DVERTEXELEMENT9 vdeclelements[] = {
+ {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
+ {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
+ D3DDECL_END()
+};
+
+/* Simple vertex shader to just pass through everything */
+const char *vshader_passthru_hlsl =
+ "float4 vshader(float4 pos: POSITION, inout float2 texcoord: TEXCOORD0): POSITION \
+ { \
+ return pos; \
+ }";
+
+static IDirect3DVertexBuffer9 *quad_geometry;
+static IDirect3DVertexShader9 *vshader_passthru;
+static IDirect3DVertexDeclaration9 *vdeclaration;
+static IDirect3DDevice9 *device;
+
+/* Generic functions to create windows, initialize Direct3D, etc. */
+static HWND create_window(void)
+{
+ WNDCLASS wc = {0};
+ wc.lpfnWndProc = DefWindowProc;
+ wc.lpszClassName = "d3d9_test_wc";
+ RegisterClass(&wc);
+
+ return CreateWindow("d3d9_test_wc", "d3d9_test",
+ 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+
+static IDirect3DDevice9 *init_d3d9(void)
+{
+ IDirect3D9 *d3d9_ptr = 0;
+ IDirect3DDevice9 *device_ptr = 0;
+ D3DPRESENT_PARAMETERS present_parameters;
+
+ void *temp_geometry_vertices;
+
+ ID3DXBuffer *compiled = NULL;
+ ID3DXBuffer *errors = NULL;
+
+ HRESULT hres;
+
+ d3d9_ptr = Direct3DCreate9(D3D_SDK_VERSION);
+ if (!d3d9_ptr)
+ {
+ skip("could not create D3D9\n");
+ return NULL;
+ }
+
+ ZeroMemory(&present_parameters, sizeof(present_parameters));
+ present_parameters.Windowed = TRUE;
+ present_parameters.hDeviceWindow = create_window();
+ present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
+
+ hres = IDirect3D9_CreateDevice(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, NULL, D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device_ptr);
+ if(FAILED(hres)) {
+ skip("could not create Direct3D9 device\n");
+ return NULL;
+ }
+
+ /* Create the quad geometry */
+ hres = IDirect3DDevice9_CreateVertexBuffer(device_ptr, 4 * sizeof(struct vertex), D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, &quad_geometry, NULL);
+ ok(SUCCEEDED(hres), "Could not create vertex buffer, IDirect3DDevice9_CreateVertexBuffer returned: %08x\n", hres);
+
+ hres = IDirect3DVertexBuffer9_Lock(quad_geometry, 0, sizeof(quad_vertices), (void**)&temp_geometry_vertices, 0);
+ ok(SUCCEEDED(hres), "IDirect3DVertexBuffer9_Lock returned: %08x\n", hres);
+ memcpy(temp_geometry_vertices, quad_vertices, sizeof(quad_vertices));
+ IDirect3DVertexBuffer9_Unlock(quad_geometry);
+
+ hres = IDirect3DDevice9_CreateVertexDeclaration(device_ptr, vdeclelements, &vdeclaration);
+ ok(SUCCEEDED(hres), "Could not create vertex declaration: IDirect3DDevice9_CreateVertexDeclaration returned: %08x\n", hres);
+
+ /* Create a simple vertex shader to just pass through the values */
+ hres = D3DXCompileShader(vshader_passthru_hlsl, strlen(vshader_passthru_hlsl),
+ NULL, NULL, "vshader", "vs_1_1", 0,
+ &compiled, &errors, 0);
+ if(FAILED(hres))
+ {
+ vshader_passthru = NULL;
+ skip("not compiling vertex shader due to lacking wine HLSL support!\n");
+ if(errors)
+ IUnknown_Release(errors);
+ return device_ptr;
+ }
+
+ hres = IDirect3DDevice9_CreateVertexShader(device_ptr, (DWORD*) ID3DXBuffer_GetBufferPointer(compiled), &vshader_passthru);
+ ok(SUCCEEDED(hres), "IDirect3DDevice9_CreateVertexShader returned: %08x\n", hres);
+ IUnknown_Release(compiled);
+
+ return device_ptr;
+}
+
+/* Convenience functions */
+static void set_float4(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);
+}
+
+/* Compile our pixel shader and get back the compiled version and a constant
+ table */
+static IDirect3DPixelShader9* compile_pixel_shader(const char *shader, const char *profile, ID3DXConstantTable **constants)
+{
+ ID3DXBuffer *compiled = NULL;
+ ID3DXBuffer *errors = NULL;
+ IDirect3DPixelShader9 *pshader;
+ HRESULT hr;
+
+ hr = D3DXCompileShader(shader, strlen(shader),
+ NULL, NULL, "test", profile,
+ 0, &compiled, &errors, constants);
+ ok (hr == D3D_OK, "Pixel shader %s compilation failed: %s\n", shader, (char*) (errors?ID3DXBuffer_GetBufferPointer(errors):""));
+ if(FAILED(hr)) return NULL;
+
+ hr = IDirect3DDevice9_CreatePixelShader(device, (DWORD*) ID3DXBuffer_GetBufferPointer(compiled), &pshader);
+ ok(SUCCEEDED(hr), "IDirect3DDevice9_CreatePixelShader returned: %08x\n", hr);
+ IUnknown_Release(compiled);
+ return pshader;
+}
+
+/* Draw a full screen quad */
+static void draw_quad_with_shader(void)
+{
+ HRESULT hr;
+ D3DXMATRIX projection_matrix;
+
+ D3DXMatrixOrthoLH(&projection_matrix, 2.0, 2.0, 0, 1.0);
+ IDirect3DDevice9_SetTransform(device, D3DTS_PROJECTION, &projection_matrix);
+
+ 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 = IDirect3DDevice9_BeginScene(device);
+ ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned: %08x\n", hr);
+
+ hr = IDirect3DDevice9_SetVertexDeclaration(device, vdeclaration);
+ ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned: %08x\n", hr);
+ IDirect3DDevice9_SetStreamSource(device, 0, quad_geometry, 0, sizeof(struct vertex));
+ ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource returned: %08x\n", hr);
+ IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
+ ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive returned: %08x\n", hr);
+
+ hr = IDirect3DDevice9_EndScene(device);
+ ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned: %08x\n", hr);
+
+ IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
+
+ return;
+}
+
+static void setup_device(IDirect3DSurface9 **render_target, IDirect3DSurface9 **readback, D3DFORMAT format, int width, int height, IDirect3DVertexShader9 *vshader, IDirect3DPixelShader9 *pshader)
+{
+ 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);
+}
+
+/* For all compute_shader_* calls, this framework assumes that the data types are 4 bytes
+ long. The two formats used here are D3DFMT_R32F and D3DFMT_A8R8G8B8 */
+
+/* Compute a shader on a fullscreen quad and get the results back */
+static void* compute_shader_fullscreen(IDirect3DPixelShader9 *pshader, D3DFORMAT format, int width, int height)
+{
+ IDirect3DSurface9 *render_target;
+ IDirect3DSurface9 *readback;
+
+ HRESULT hr;
+ void *ret = NULL;
+ D3DLOCKED_RECT lr;
+
+ int y;
+
+ setup_device(&render_target, &readback, format, width, height, vshader_passthru, pshader);
+
+ /* Draw the quad with the shader and read back the data */
+ draw_quad_with_shader();
+ IDirect3DDevice9_GetRenderTargetData(device, render_target, readback);
+ hr = IDirect3DSurface9_LockRect(readback, &lr, NULL, D3DLOCK_READONLY);
+ ok(hr == D3D_OK, "IDirect3DSurface9_LockRect returned: %08x\n", hr);
+ /* We're dealing with types of 4 bytes here: float and DWORD. The height is in height,
+ but the width of the actual returned surface is in lr.Pitch, since the texture might
+ be padded.*/
+ ret = HeapAlloc(GetProcessHeap(), 0, 4 * width * height);
+ for(y = 0;y < height;y++)
+ memcpy((void*) (((DWORD) ret) + (y * width)), (void*) (((DWORD) lr.pBits) + (y * lr.Pitch)), width * 4);
+ hr = IDirect3DSurface9_UnlockRect(readback);
+ ok(hr == D3D_OK, "IDirect3DSurface9_UnlockRect returned: %08x\n", hr);
+
+ /* release everything */
+ IUnknown_Release(render_target);
+ IUnknown_Release(readback);
+
+ return ret;
+}
+
+/* Now the actual test functions */
+static void test_swizzle(void)
+{
+ static const char *swizzle_test_shader =
+ "uniform float4 color; \
+ float4 test(): COLOR \
+ { \
+ float4 ret = color; \
+ ret.gb = ret.ra; \
+ ret.ra = float2(0, 0); \
+ return ret; \
+ }";
+
+ ID3DXConstantTable *constants;
+ IDirect3DPixelShader9 *pshader;
+ DWORD *data;
+
+ pshader = compile_pixel_shader(swizzle_test_shader, "ps_2_0", &constants);
+ if(pshader != NULL)
+ {
+ set_float4(constants, "color", 1, 0, 0, 1);
+
+ data = (DWORD*) compute_shader_fullscreen(pshader, D3DFMT_A8R8G8B8, 1, 1);
+
+ ok(data[0] == D3DCOLOR_ARGB(0, 0, 255, 255), "swizzle_test: Got color %08x (should be 0x0000FFFF)\n", data[0]);
+
+ IUnknown_Release(constants);
+ IUnknown_Release(pshader);
+ }
+}
+
+/* The heart of our little testing framework */
+START_TEST(hlsl)
+{
+ D3DCAPS9 caps;
+ ULONG refcount;
+
+ device = init_d3d9();
+ if (!device) return;
+
+ /* Make sure we support pixel shaders, before trying to compile them! */
+ IDirect3DDevice9_GetDeviceCaps(device, &caps);
+ if(caps.PixelShaderVersion >= 0xffff0200) {
+ todo_wine {
+ test_swizzle();
+ }
+ } 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);
+ return;
+}
diff --git a/include/d3dx9shader.h b/include/d3dx9shader.h
index c8380bc..c54d27c 100644
--- a/include/d3dx9shader.h
+++ b/include/d3dx9shader.h
@@ -296,6 +296,17 @@ HRESULT WINAPI D3DXAssembleShader(LPCSTR data,
LPD3DXBUFFER* shader,
LPD3DXBUFFER* error_messages);
+HRESULT WINAPI D3DXCompileShader(LPCSTR src_data,
+ UINT data_len,
+ const D3DXMACRO* defines,
+ LPD3DXINCLUDE include,
+ LPCSTR function_name,
+ LPCSTR profile,
+ DWORD flags,
+ LPD3DXBUFFER* shader,
+ LPD3DXBUFFER* error_messages,
+ LPD3DXCONSTANTTABLE* constant_table);
+
HRESULT WINAPI D3DXGetShaderConstantTableEx(CONST DWORD* byte_code,
DWORD flags,
LPD3DXCONSTANTTABLE* constant_table);
--
1.6.4.4
More information about the wine-patches
mailing list