[PATCH] d3dx9_36/tests: Added HLSL test suite. (Try 2)

Travis Athougies iammisc at gmail.com
Fri Jul 30 14:02:30 CDT 2010


---
 dlls/d3dx9_36/tests/Makefile.in |    1 +
 dlls/d3dx9_36/tests/hlsl.c      |  609 +++++++++++++++++++++++++++++++++++++++
 include/d3dx9shader.h           |   11 +
 3 files changed, 621 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..06bc624
--- /dev/null
+++ b/dlls/d3dx9_36/tests/hlsl.c
@@ -0,0 +1,609 @@
+/*
+ * 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 <d3dx9shader.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;                                                     \
+    }                                                                   \
+    ";
+
+/* Global variables, etc */
+static LPDIRECT3DVERTEXBUFFER9 quad_geometry = 0;
+static LPDIRECT3DVERTEXSHADER9 vshader_passthru = 0;
+static LPDIRECT3DVERTEXDECLARATION9 vdeclaration = 0;
+static LPDIRECT3DDEVICE9 device = 0;
+
+/* 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(HMODULE d3d9_handle)
+{
+    IDirect3D9 * (__stdcall * d3d9_create)(UINT SDKVersion) = 0;
+    IDirect3D9 *d3d9_ptr = 0;
+    IDirect3DDevice9 *device_ptr = 0;
+    D3DPRESENT_PARAMETERS present_parameters;
+
+    void* temp_geometry_vertices;
+
+    LPD3DXBUFFER compiled = NULL;
+    LPD3DXBUFFER errors = NULL;
+
+    HRESULT hres;
+
+    d3d9_create = (void *)GetProcAddress(d3d9_handle, "Direct3DCreate9");
+    ok(d3d9_create != NULL, "Failed to get address of Direct3DCreate9\n");
+    if (!d3d9_create) return NULL;
+
+    d3d9_ptr = d3d9_create(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_SOFTWARE_VERTEXPROCESSING, &present_parameters, &device_ptr);
+    ok(SUCCEEDED(hres), "Could not create device, IDirect3D9_CreateDevice returned: %08x\n", hres);
+
+    /* 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 thru the values (used in some tests) */
+    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;
+    }
+    ok(SUCCEEDED(hres), "Vertex shader compilation failed: %s\n", (char*) (errors?errors->lpVtbl->GetBufferPointer(errors):"(nil)"));
+
+    hres = IDirect3DDevice9_CreateVertexShader(device_ptr, (DWORD*) compiled->lpVtbl->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(LPD3DXCONSTANTTABLE 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;
+    constants->lpVtbl->SetVector(constants, device, name, &vector);
+}
+
+/* Compare floating point arrays using units in the last place (ULPS)
+   keeping a count of how many erroneous values we have found */
+static int cmp_results_linear(int samples, float epsilon, float* expected, float* actual)
+{
+    int result = 0;
+    int i = 0;
+    for(i = 0;i < samples;i++)
+        if(abs(expected[i] - actual[i]) > epsilon)
+            result ++;
+    return result;
+}
+
+/* Compile our pixel shader and get back the compiled version and a constant
+   table */
+LPDIRECT3DPIXELSHADER9 compile_pixel_shader(const char* shader, const char* profile, LPD3DXCONSTANTTABLE* constants)
+{
+    LPD3DXBUFFER compiled = NULL;
+    LPD3DXBUFFER errors = NULL;
+    LPDIRECT3DPIXELSHADER9 pshader;
+    HRESULT hr;
+
+    /* Compile the pixel shader for this particular test and create the pixel
+       shader object */
+    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?errors->lpVtbl->GetBufferPointer(errors):""));
+    if(FAILED(hr)) return NULL;
+
+    hr = IDirect3DDevice9_CreatePixelShader(device, (DWORD*) compiled->lpVtbl->GetBufferPointer(compiled), &pshader);
+    ok(SUCCEEDED(hr), "IDirect3DDevice9_CreatePixelShader returned: %08x\n", hr);
+    IUnknown_Release(compiled);
+    return pshader;
+}
+
+/* Draw a full screen quad */
+void draw_quad_with_shader(void)
+{
+    HRESULT hr;
+    D3DXMATRIX projection_matrix;
+
+    /* Set up projection */
+    D3DXMatrixOrthoLH(&projection_matrix, 2.0, 2.0, 0, 1.0);
+    IDirect3DDevice9_SetTransform(device, D3DTS_PROJECTION, &projection_matrix);
+
+    /* Clear the backbuffer */
+    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);
+
+    /* Start drawing the geometry which will fill the entire screen */
+    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;
+}
+
+void setup_device(LPDIRECT3DSURFACE9* render_target, LPDIRECT3DSURFACE9* readback, D3DFORMAT format, int width, int height, LPDIRECT3DVERTEXSHADER9 vshader, LPDIRECT3DPIXELSHADER9 pshader)
+{
+    HRESULT hr;
+    /* Create the render target surface*/
+    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);
+}
+
+/* Repeatedly call a shader with linearly varying values and collect the results */
+LPVOID compute_shader_linear(LPDIRECT3DPIXELSHADER9 pshader, LPD3DXCONSTANTTABLE constants, D3DFORMAT format, int samples)
+{
+    LPDIRECT3DSURFACE9 render_target;
+    LPDIRECT3DSURFACE9 readback;
+    int i = 0;
+
+    HRESULT hr;
+    LPVOID ret = NULL;
+    D3DLOCKED_RECT lr;
+
+    setup_device(&render_target, &readback, format, samples, 1, vshader_passthru, pshader);
+
+    ret = HeapAlloc(GetProcessHeap(), 0, 4 * samples);
+    for(;i < 32;i++) {
+        ID3DXConstantTable_SetFloat(constants, device, "$x", ((float) i)/((float) samples));
+        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);
+        memcpy((void*) (((DWORD) ret) + (4 * i)), lr.pBits, 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;
+}
+
+/* Compute a shader on a fullscreen quad and get the results back */
+LPVOID compute_shader_fullscreen(LPDIRECT3DPIXELSHADER9 pshader, D3DFORMAT format, int width, int height)
+{
+
+    LPDIRECT3DSURFACE9 render_target;
+    LPDIRECT3DSURFACE9 readback;
+
+    HRESULT hr;
+    LPVOID ret = NULL;
+    D3DLOCKED_RECT lr;
+
+    setup_device(&render_target, &readback, format, width, height, vshader_passthru, pshader);
+
+    /* Here we just draw the entire shader and read back the entire buffer */
+    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 texture is 1 pixel high. The ps->samples variable is the width */
+    ret = HeapAlloc(GetProcessHeap(), 0, 4 * width * height);
+    memcpy(ret, lr.pBits, 4 * width * height);
+    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_trig(IDirect3DDevice9* device)
+{
+    static float sin_expected[] = {
+        0.50000000000000000000f, 0.59754514694213867000f, 0.69134163856506348000f, 0.77778506278991699000f,
+        0.85355341434478760000f, 0.91573476791381836000f, 0.96193975210189819000f, 0.99039268493652344000f,
+        1.00000000000000000000f, 0.99039268493652344000f, 0.96193975210189819000f, 0.91573476791381836000f,
+        0.85355335474014282000f, 0.77778506278991699000f, 0.69134163856506348000f, 0.59754508733749390000f,
+        0.50000000000000000000f, 0.40245491266250610000f, 0.30865836143493652000f, 0.22221493721008301000f,
+        0.14644664525985718000f, 0.08426526188850402800f, 0.03806024789810180700f, 0.00960734486579895020f,
+        0.00000000000000000000f, 0.00960734486579895020f, 0.03806024789810180700f, 0.08426523208618164100f,
+        0.14644661545753479000f, 0.22221490740776062000f, 0.30865836143493652000f, 0.40245485305786133000f,
+    };
+
+    static float cos_expected[] = {
+        1.00000000000000000000f, 0.99039268493652344000f, 0.96193975210189819000f, 0.91573476791381836000f,
+        0.85355335474014282000f, 0.77778506278991699000f, 0.69134169816970825000f, 0.59754514694213867000f,
+        0.50000000000000000000f, 0.40245485305786133000f, 0.30865830183029175000f, 0.22221493721008301000f,
+        0.14644661545753479000f, 0.08426526188850402800f, 0.03806024789810180700f, 0.00960737466812133790f,
+        0.00000000000000000000f, 0.00960737466812133790f, 0.03806024789810180700f, 0.08426526188850402800f,
+        0.14644661545753479000f, 0.22221493721008301000f, 0.30865830183029175000f, 0.40245485305786133000f,
+        0.50000000000000000000f, 0.59754514694213867000f, 0.69134169816970825000f, 0.77778506278991699000f,
+        0.85355335474014282000f, 0.91573476791381836000f, 0.96193975210189819000f, 0.99039268493652344000f,
+    };
+
+    static const char* sin_shader =
+      "float4 test(uniform float x): COLOR\n"
+      "{\n"
+      "    const float pi2 = 6.2831853; //071795862;\n"
+      "    float calcd = (sin(x * pi2) + 1)/2;"
+      "    return calcd;\n"
+      "}\n";
+
+    static const char* cos_shader =
+        "float4 test(uniform float x): COLOR\n"
+        "{\n"
+        "    const float pi2 = 6.2831853; //071795862;\n"
+        "    float calcd = (cos(x * pi2) + 1)/2;"
+        "    return calcd;\n"
+        "}\n";
+
+    LPD3DXCONSTANTTABLE constants;
+    LPDIRECT3DPIXELSHADER9 pshader;
+    void* data;
+    int errors = 0;
+
+    pshader = compile_pixel_shader(sin_shader, "ps_2_0", &constants);
+    if(pshader != NULL) {
+
+        data = compute_shader_linear(pshader, constants, D3DFMT_R32F, 32);
+
+        errors = cmp_results_linear(32, 0.00001, sin_expected, data);
+        ok(errors == 0, "sin: Got %d unexpected values\n", errors);
+
+        HeapFree(GetProcessHeap(), 0, data);
+
+        IUnknown_Release(constants);
+        IUnknown_Release(pshader);
+    }
+
+    pshader = compile_pixel_shader(cos_shader, "ps_2_0", &constants);
+    if(pshader != NULL) {
+        data = compute_shader_linear(pshader, constants, D3DFMT_R32F, 32);
+
+        errors = cmp_results_linear(32, 0.00001, cos_expected, data);
+        ok(errors == 0, "cos: Got %d unexpected values\n", errors);
+
+        HeapFree(GetProcessHeap(), 0, data);
+
+        IUnknown_Release(constants);
+        IUnknown_Release(pshader);
+    }
+}
+
+static void test_swizzle(IDirect3DDevice9* device)
+{
+    static const char* swizzle_test_shader =
+        "uniform float4 color;\n" /* Once again this is to prevent compiler optimization. */
+        "float4 test(): COLOR\n"
+        "{\n"
+        "    float4 ret = color;\n"
+        "    ret.gb = ret.ra;\n"
+        "    ret.ra = float2(0, 0);\n"
+        "    return ret;\n"
+        "}\n";
+
+    LPD3DXCONSTANTTABLE constants;
+    LPDIRECT3DPIXELSHADER9 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);
+    }
+}
+
+static void test_conditionals(IDirect3DDevice9* device)
+{
+    static const char* if_greater_shader =
+        "float4 test(float2 pos: TEXCOORD0): COLOR\n"
+        "{\n"
+        "    if((pos.x * 32.0) > 20.0)\n"
+        "        return float4(0, 0, 1, 0);\n"
+        "    else\n"
+        "        return float4(0, 1, 0, 0);\n"
+        "}\n";
+
+    LPD3DXCONSTANTTABLE constants;
+    LPDIRECT3DPIXELSHADER9 pshader;
+    DWORD* data;
+
+    pshader = compile_pixel_shader(if_greater_shader, "ps_2_0", &constants);
+    if(pshader != NULL) {
+        data = (DWORD*) compute_shader_fullscreen(pshader, D3DFMT_A8R8G8B8, 32, 1);
+
+        ok(data[15] == D3DCOLOR_ARGB(0, 0, 255, 0), "if_greater_test: Got color %08x (should be 0x0000ff00)\n", data[15]);
+        ok(data[25] == D3DCOLOR_ARGB(0, 0, 0, 255), "if_greater_test: Got color %08x (should be 0x000000ff)\n", data[25]);
+
+        IUnknown_Release(constants);
+        IUnknown_Release(pshader);
+    }
+}
+
+static void test_float(IDirect3DDevice9* device)
+{
+    static const char* vec4_indexing_test1_shader =
+        "float4 test(): COLOR\n"
+        "{\n"
+        "    float4 color;\n"
+        "    color[0] = 0.0;\n"
+        "    color[1] = 1.0;\n"
+        "    color[2] = 0.0;\n"
+        "    color[3] = 1.0;\n"
+        "    return color;\n"
+        "}\n";
+
+    static const char* vec4_indexing_test2_shader =
+        "uniform int i;\n" /* We have this uniform here so the compiler can't optimize */
+        "float4 test(): COLOR\n"
+        "{\n"
+        "    float4 color = float4(0, 0, 1, 1);\n"
+        "    color.g = color[i];\n"
+        "    color.b = 0;\n"
+        "    return color;\n"
+        "}\n";
+
+    LPD3DXCONSTANTTABLE constants;
+    LPDIRECT3DPIXELSHADER9 pshader;
+    DWORD* data;
+
+    pshader = compile_pixel_shader(vec4_indexing_test1_shader, "ps_2_0", &constants);
+    if(pshader != NULL) {
+        data = (DWORD*) compute_shader_fullscreen(pshader, D3DFMT_A8R8G8B8, 32, 1);
+
+        ok(data[10] == D3DCOLOR_ARGB(255, 0, 255, 0), "vec4_indexing_test1: Got color %08x (should be 0xff00ff00)\n", data[10]);
+        ok(data[16] == D3DCOLOR_ARGB(255, 0, 255, 0), "vec4_indexing_test1: Got color %08x (should be 0xff00ff00)\n", data[16]);
+        ok(data[22] == D3DCOLOR_ARGB(255, 0, 255, 0), "vec4_indexing_test1: Got color %08x (should be 0xff00ff00)\n", data[22]);
+
+        IUnknown_Release(constants);
+        IUnknown_Release(pshader);
+    }
+
+    pshader = compile_pixel_shader(vec4_indexing_test2_shader, "ps_2_0", &constants);
+    if(pshader != NULL) {
+        constants->lpVtbl->SetInt(constants, device, "i", 2);
+
+        data = (DWORD*) compute_shader_fullscreen(pshader, D3DFMT_A8R8G8B8, 32, 1);
+
+        ok(data[10] == D3DCOLOR_ARGB(255, 0, 255, 0), "vec4_indexing_test2: Got color %08x (should be 0xff00ff00)\n", data[10]);
+        ok(data[16] == D3DCOLOR_ARGB(255, 0, 255, 0), "vec4_indexing_test2: Got color %08x (should be 0xff00ff00)\n", data[16]);
+        ok(data[22] == D3DCOLOR_ARGB(255, 0, 255, 0), "vec4_indexing_test2: Got color %08x (should be 0xff00ff00)\n", data[22]);
+
+        IUnknown_Release(constants);
+        IUnknown_Release(pshader);
+    }
+}
+
+static void test_constant_tables(IDirect3DDevice9* device)
+{
+    static const char* vector_array_staticindex_test_shader =
+        "uniform float4 colors[4];\n"
+        "float4 test(float2 wpos: TEXCOORD0):COLOR\n"
+        "{\n"
+        "    return colors[0] + colors[1] + colors[2] + colors[3];\n"
+        "}\n";
+
+    static const char* integer_constant_test_shader =
+        "uniform int brk;\n"
+        "float4 test(float2 wpos: TEXCOORD0):COLOR\n"
+        "{\n"
+        "    if((wpos.x * 8) > brk)\n"
+        "        return float4(1, 0, 1, 0);\n"
+        "    else\n"
+        "        return float4(1, 1, 1, 1);\n"
+        "}\n";
+
+    static const char* uniform_array_test_shader =
+        "uniform float4 colors[4];\n"
+        "float4 test(float2 wpos: VPOS):COLOR\n"
+        "{\n"
+        "     return colors[wpos.x];\n"
+        "}\n";
+        
+    static D3DXVECTOR4 test_colors[] = {
+        {1, 0, 0, 0},
+        {0, 0, 1, 0},
+        {0, 0, 0, 1},
+        {0, 1, 0, 0}
+    };
+
+    LPD3DXCONSTANTTABLE constants;
+    LPDIRECT3DPIXELSHADER9 pshader;
+    DWORD* data;
+
+    pshader = compile_pixel_shader(vector_array_staticindex_test_shader, "ps_2_0", &constants);
+    if(pshader != NULL) {
+        constants->lpVtbl->SetVectorArray(constants, device, "colors", test_colors, 4);
+        data = (DWORD*) compute_shader_fullscreen(pshader, D3DFMT_A8R8G8B8, 1, 1);
+
+        ok(data[0] == D3DCOLOR_ARGB(255, 255, 255, 255), "vector_array_staticindex_test: Got color %08x (should be 0xffffffff)\n", data[0]);
+
+        IUnknown_Release(constants);
+        IUnknown_Release(pshader);
+    }
+
+    pshader = compile_pixel_shader(integer_constant_test_shader, "ps_2_0", &constants);
+    if(pshader != NULL) {
+        constants->lpVtbl->SetInt(constants, device, "brk", 5);
+        data = (DWORD*) compute_shader_fullscreen(pshader, D3DFMT_A8R8G8B8, 8, 1);
+
+        ok(data[0] == D3DCOLOR_ARGB(255, 255, 255, 255), "integer_constant_test: Got color %08x (should be 0xffffffff)\n", data[0]);
+        ok(data[6] == D3DCOLOR_ARGB(0, 255, 0, 255), "integer_constant_test: Got color %08x (should be 0x00ff00ff\n", data[6]);
+
+        IUnknown_Release(constants);
+        IUnknown_Release(pshader);
+    }
+
+    pshader = compile_pixel_shader(uniform_array_test_shader, "ps_3_0", &constants);
+    if(pshader != NULL) {
+      constants->lpVtbl->SetVectorArray(constants, device, "colors", test_colors, 4);
+
+      data = (DWORD*) compute_shader_fullscreen(pshader, D3DFMT_A8R8G8B8, 4, 1);
+
+      ok(data[0] == D3DCOLOR_ARGB(0, 255, 0, 0), "uniform_array_test: Got color %08x (should be 0x00ff0000)\n", data[0]);
+      ok(data[1] == D3DCOLOR_ARGB(0, 0, 0, 255), "uniform_array_test: Got color %08x (should be 0x000000ff)\n", data[1]);
+      ok(data[2] == D3DCOLOR_ARGB(255, 0, 0, 0), "uniform_array_test: Got color %08x (should be 0xff000000)\n", data[2]);
+      ok(data[3] == D3DCOLOR_ARGB(0, 0, 255, 0), "uniform_array_test: Got color %08x (should be 0x0000ff00)\n", data[3]);
+
+      IUnknown_Release(constants);
+      IUnknown_Release(pshader);
+    }
+}
+
+/* The heart of our little testing framework */
+START_TEST(hlsl)
+{
+    HMODULE d3d9_handle;
+    D3DCAPS9 caps;
+    ULONG refcount;
+
+    d3d9_handle = LoadLibraryA("d3d9.dll");
+    if (!d3d9_handle) {
+        skip("Could not read d3d9.dll\n");
+        return;
+    }
+
+    device = init_d3d9(d3d9_handle);
+    if (!device) return;
+
+    /* Make sure we support pixel shaders, before trying to compile them! */
+    IDirect3DDevice9_GetDeviceCaps(device, &caps);
+    if(caps.PixelShaderVersion & 0xffff) {
+        todo_wine {
+            test_constant_tables(device);
+            test_conditionals(device);
+            test_float(device);
+            test_trig(device);
+            test_swizzle(device);
+        }
+    } else skip("No pixel shader support\n");
+
+    /* Reference counting sanity checks */
+    if(vshader_passthru) {
+        refcount = IDirect3DVertexShader9_Release(vshader_passthru);
+        ok(!refcount, "Pssthru 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