[PATCH v2] ddraw/tests: Test lighting with _ProcessVertices() for ddraw7.
Paul Gofman
gofmanp at gmail.com
Tue Jun 4 16:58:18 CDT 2019
Signed-off-by: Paul Gofman <gofmanp at gmail.com>
---
v2 changes:
- make process_vertices_todo last parameter in test structure;
- fix IDirectDraw7 interface leak in test_lighting().
dlls/ddraw/tests/ddraw7.c | 378 ++++++++++++++++++++++++++++----------
1 file changed, 282 insertions(+), 96 deletions(-)
diff --git a/dlls/ddraw/tests/ddraw7.c b/dlls/ddraw/tests/ddraw7.c
index 9ba6a06ecc..ce741253ae 100644
--- a/dlls/ddraw/tests/ddraw7.c
+++ b/dlls/ddraw/tests/ddraw7.c
@@ -20,6 +20,7 @@
#define COBJMACROS
#include "wine/test.h"
+#include "wine/heap.h"
#include <limits.h>
#include <math.h>
#include "d3d.h"
@@ -3644,7 +3645,7 @@ static void test_lighting(void)
0.0f, 0.0f, 1.0f, -1.0f,
10.f, 10.0f, 10.0f, 0.0f,
};
- static struct
+ static struct vertex
{
struct vec3 position;
DWORD diffuse;
@@ -3663,7 +3664,7 @@ static void test_lighting(void)
{{ 0.0f, 1.0f, 0.1f}, 0xff00ff00},
{{ 0.0f, 0.0f, 0.1f}, 0xff00ff00},
};
- static struct
+ static struct vertex_normal
{
struct vec3 position;
struct vec3 normal;
@@ -3709,26 +3710,41 @@ static void test_lighting(void)
{
D3DMATRIX *world_matrix;
void *quad;
- DWORD expected;
+ DWORD expected, expected_process_vertices;
const char *message;
+ BOOL process_vertices_todo;
}
tests[] =
{
- {&mat, nquad, 0x000000ff, "Lit quad with light"},
- {&mat_singular, nquad, 0x000000ff, "Lit quad with singular world matrix"},
- {&mat_transf, rotatedquad, 0x000000ff, "Lit quad with transformation matrix"},
- {&mat_nonaffine, translatedquad, 0x00000000, "Lit quad with non-affine matrix"},
+ {&mat, nquad, 0x000000ff, 0xff0000ff, "Lit quad with light"},
+ {&mat_singular, nquad, 0x000000ff, 0xff000000, "Lit quad with singular world matrix", TRUE},
+ {&mat_transf, rotatedquad, 0x000000ff, 0xff0000ff, "Lit quad with transformation matrix"},
+ {&mat_nonaffine, translatedquad, 0x00000000, 0xff000000, "Lit quad with non-affine matrix"},
};
- HWND window;
+ DWORD nfvf = D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_NORMAL;
+ IDirect3DVertexBuffer7 *src_vb1, *src_vb2, *dst_vb;
+ DWORD fvf = D3DFVF_XYZ | D3DFVF_DIFFUSE;
+ struct vertex_normal *src_data2;
+ D3DVERTEXBUFFERDESC vb_desc;
+ struct vertex *src_data1;
IDirect3DDevice7 *device;
IDirectDrawSurface7 *rt;
- HRESULT hr;
- DWORD fvf = D3DFVF_XYZ | D3DFVF_DIFFUSE;
- DWORD nfvf = D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_NORMAL;
+ IDirectDraw7 *ddraw;
+ IDirect3D7 *d3d;
D3DCOLOR color;
ULONG refcount;
unsigned int i;
+ BOOL is_warp;
+ HWND window;
+ HRESULT hr;
+ struct
+ {
+ struct vec4 position;
+ DWORD diffuse;
+ DWORD specular;
+ }
+ *dst_data;
window = create_window();
if (!(device = create_device(window, DDSCL_NORMAL)))
@@ -3737,97 +3753,199 @@ static void test_lighting(void)
DestroyWindow(window);
return;
}
+ hr = IDirect3DDevice7_GetDirect3D(device, &d3d);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+ hr = IDirect3D7_QueryInterface(d3d, &IID_IDirectDraw7, (void **)&ddraw);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+
+ is_warp = ddraw_is_warp(ddraw);
hr = IDirect3DDevice7_GetRenderTarget(device, &rt);
- ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
- ok(SUCCEEDED(hr), "Failed to clear render target, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_SetTransform(device, D3DTRANSFORMSTATE_WORLD, &mat);
- ok(SUCCEEDED(hr), "Failed to set world transform, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_SetTransform(device, D3DTRANSFORMSTATE_VIEW, &mat);
- ok(SUCCEEDED(hr), "Failed to set view transform, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_SetTransform(device, D3DTRANSFORMSTATE_PROJECTION, &mat);
- ok(SUCCEEDED(hr), "Failed to set projection transform, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_CLIPPING, FALSE);
- ok(SUCCEEDED(hr), "Failed to disable clipping, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_ZENABLE, FALSE);
- ok(SUCCEEDED(hr), "Failed to disable z-buffering, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_FOGENABLE, FALSE);
- ok(SUCCEEDED(hr), "Failed to disable fog, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_STENCILENABLE, FALSE);
- ok(SUCCEEDED(hr), "Failed to disable stencil buffering, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_CULLMODE, D3DCULL_NONE);
- ok(SUCCEEDED(hr), "Failed to disable culling, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_BeginScene(device);
- ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+
+ memset(&vb_desc, 0, sizeof(vb_desc));
+ vb_desc.dwSize = sizeof(vb_desc);
+ vb_desc.dwFVF = fvf;
+ vb_desc.dwNumVertices = 2;
+ hr = IDirect3D7_CreateVertexBuffer(d3d, &vb_desc, &src_vb1, 0);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+ vb_desc.dwSize = sizeof(vb_desc);
+ vb_desc.dwFVF = nfvf;
+ vb_desc.dwNumVertices = 2;
+ hr = IDirect3D7_CreateVertexBuffer(d3d, &vb_desc, &src_vb2, 0);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+
+ memset(&vb_desc, 0, sizeof(vb_desc));
+ vb_desc.dwSize = sizeof(vb_desc);
+ vb_desc.dwFVF = D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR;
+ vb_desc.dwNumVertices = 4;
+ hr = IDirect3D7_CreateVertexBuffer(d3d, &vb_desc, &dst_vb, 0);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+
+ hr = IDirect3DVertexBuffer7_Lock(src_vb1, 0, (void **)&src_data1, NULL);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+ memcpy(src_data1, unlitquad, sizeof(*src_data1));
+ memcpy(&src_data1[1], litquad, sizeof(*src_data1));
+ hr = IDirect3DVertexBuffer7_Unlock(src_vb1);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+
+ hr = IDirect3DVertexBuffer7_Lock(src_vb2, 0, (void **)&src_data2, NULL);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+ memcpy(src_data2, unlitnquad, sizeof(*src_data2));
+ memcpy(&src_data2[1], litnquad, sizeof(*src_data2));
+ hr = IDirect3DVertexBuffer7_Unlock(src_vb2);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
/* No lights are defined... That means, lit vertices should be entirely black. */
hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_LIGHTING, FALSE);
- ok(SUCCEEDED(hr), "Failed to disable lighting, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+ hr = IDirect3DVertexBuffer7_ProcessVertices(dst_vb, D3DVOP_TRANSFORM, 0,
+ 1, src_vb1, 0, device, 0);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, fvf, unlitquad, 4,
indices, 6, 0);
- ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_LIGHTING, TRUE);
- ok(SUCCEEDED(hr), "Failed to enable lighting, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+ hr = IDirect3DVertexBuffer7_ProcessVertices(dst_vb, D3DVOP_TRANSFORM | D3DVOP_LIGHT, 1,
+ 1, src_vb1, 1, device, 0);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, fvf, litquad, 4,
indices, 6, 0);
- ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_LIGHTING, FALSE);
- ok(SUCCEEDED(hr), "Failed to disable lighting, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+ hr = IDirect3DVertexBuffer7_ProcessVertices(dst_vb, D3DVOP_TRANSFORM, 2,
+ 1, src_vb2, 0, device, 0);
hr = IDirect3DDevice7_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, nfvf, unlitnquad, 4,
indices, 6, 0);
- ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_LIGHTING, TRUE);
- ok(SUCCEEDED(hr), "Failed to enable lighting, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+ hr = IDirect3DVertexBuffer7_ProcessVertices(dst_vb, D3DVOP_TRANSFORM | D3DVOP_LIGHT, 3,
+ 1, src_vb2, 1, device, 0);
hr = IDirect3DDevice7_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, nfvf, litnquad, 4,
indices, 6, 0);
- ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_EndScene(device);
- ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+
+ hr = IDirect3DVertexBuffer7_Lock(dst_vb, 0, (void **)&dst_data, NULL);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
color = get_surface_color(rt, 160, 360);
ok(color == 0x00ff0000, "Unlit quad without normals has color 0x%08x, expected 0x00ff0000.\n", color);
+ ok(dst_data[0].diffuse == 0xffff0000,
+ "Unlit quad without normals has color 0x%08x, expected 0xffff0000.\n", dst_data[0].diffuse);
+ ok(!dst_data[0].specular,
+ "Unexpected specular color 0x%08x.\n", dst_data[0].specular);
color = get_surface_color(rt, 160, 120);
- ok(color == 0x00000000, "Lit quad without normals has color 0x%08x, expected 0x00000000.\n", color);
+ /* Broken on some of WARP drivers. */
+ ok(color == 0x00000000 || broken(is_warp && color == 0x000000ff),
+ "Lit quad without normals has color 0x%08x, expected 0x00000000.\n", color);
+ ok(dst_data[1].diffuse == 0xff000000,
+ "Lit quad without normals has color 0x%08x, expected 0xff000000.\n", dst_data[1].diffuse);
+ ok(!dst_data[1].specular,
+ "Unexpected specular color 0x%08x.\n", dst_data[1].specular);
color = get_surface_color(rt, 480, 360);
ok(color == 0x000000ff, "Unlit quad with normals has color 0x%08x, expected 0x000000ff.\n", color);
+ ok(dst_data[2].diffuse == 0xff0000ff,
+ "Unlit quad with normals has color 0x%08x, expected 0xff0000ff.\n", dst_data[2].diffuse);
+ ok(!dst_data[2].specular,
+ "Unexpected specular color 0x%08x.\n", dst_data[2].specular);
color = get_surface_color(rt, 480, 120);
- ok(color == 0x00000000, "Lit quad with normals has color 0x%08x, expected 0x00000000.\n", color);
+ ok(color == 0x00000000 || broken(is_warp && color == 0x000000ff),
+ "Lit quad with normals has color 0x%08x, expected 0x00000000.\n", color);
+ ok(dst_data[3].diffuse == 0xff000000,
+ "Lit quad with normals has color 0x%08x, expected 0xff000000.\n", dst_data[3].diffuse);
+ ok(!dst_data[3].specular,
+ "Unexpected specular color 0x%08x.\n", dst_data[3].specular);
+
+ hr = IDirect3DVertexBuffer7_Unlock(dst_vb);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_LightEnable(device, 0, TRUE);
- ok(SUCCEEDED(hr), "Failed to enable light 0, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
for (i = 0; i < ARRAY_SIZE(tests); ++i)
{
+ hr = IDirect3DVertexBuffer7_Lock(src_vb2, 0, (void **)&src_data2, NULL);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+ memcpy(src_data2, tests[i].quad, sizeof(*src_data2));
+ hr = IDirect3DVertexBuffer7_Unlock(src_vb2);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+
hr = IDirect3DDevice7_SetTransform(device, D3DTRANSFORMSTATE_WORLD, tests[i].world_matrix);
- ok(SUCCEEDED(hr), "Failed to set world transform, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
- ok(SUCCEEDED(hr), "Failed to clear render target, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_BeginScene(device);
- ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+
+ hr = IDirect3DVertexBuffer7_ProcessVertices(dst_vb, D3DVOP_TRANSFORM | D3DVOP_LIGHT, 0,
+ 1, src_vb2, 0, device, 0);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, nfvf, tests[i].quad,
4, indices, 6, 0);
- ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_EndScene(device);
- ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+
+ hr = IDirect3DVertexBuffer7_Lock(dst_vb, 0, (void **)&dst_data, NULL);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
color = get_surface_color(rt, 320, 240);
- ok(color == tests[i].expected, "%s has color 0x%08x.\n", tests[i].message, color);
+ ok(color == tests[i].expected || broken(is_warp && color == 0x000000ff),
+ "%s has color 0x%08x.\n", tests[i].message, color);
+ todo_wine_if(tests[i].process_vertices_todo)
+ ok(dst_data[0].diffuse == tests[i].expected_process_vertices,
+ "%s has color 0x%08x.\n", tests[i].message, dst_data[0].diffuse);
+ ok(!dst_data[0].specular,
+ "%s has specular color 0x%08x.\n", tests[i].message, dst_data[0].specular);
+
+ hr = IDirect3DVertexBuffer7_Unlock(dst_vb);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
}
+ IDirect3DVertexBuffer7_Release(src_vb1);
+ IDirect3DVertexBuffer7_Release(src_vb2);
+ IDirect3DVertexBuffer7_Release(dst_vb);
+
IDirectDrawSurface7_Release(rt);
+ IDirectDraw7_Release(ddraw);
+ IDirect3D7_Release(d3d);
refcount = IDirect3DDevice7_Release(device);
ok(!refcount, "Device has %u references left.\n", refcount);
DestroyWindow(window);
@@ -3845,6 +3963,24 @@ static void test_specular_lighting(void)
0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f,
};
+ static const struct vertex
+ {
+ struct vec3 position;
+ struct vec3 normal;
+ }
+ vertices[] =
+ {
+ {{-0.5f, -0.5f, 1.0f}, {0.0f, 0.0f, -1.0f}},
+ {{ 0.0f, -0.5f, 1.0f}, {0.0f, 0.0f, -1.0f}},
+ {{ 0.5f, -0.5f, 1.0f}, {0.0f, 0.0f, -1.0f}},
+ {{-0.5f, 0.0f, 1.0f}, {0.0f, 0.0f, -1.0f}},
+ {{ 0.0f, 0.0f, 1.0f}, {0.0f, 0.0f, -1.0f}},
+ {{ 0.5f, 0.0f, 1.0f}, {0.0f, 0.0f, -1.0f}},
+ {{-0.5f, 0.5f, 1.0f}, {0.0f, 0.0f, -1.0f}},
+ {{ 0.0f, 0.5f, 1.0f}, {0.0f, 0.0f, -1.0f}},
+ {{ 0.5f, 0.5f, 1.0f}, {0.0f, 0.0f, -1.0f}},
+ };
+
static D3DLIGHT7 directional =
{
D3DLIGHT_DIRECTIONAL,
@@ -4006,18 +4142,6 @@ static void test_specular_lighting(void)
{320, 360, 0x00000000},
{480, 360, 0x00000000},
},
- expected_directional_0[] =
- {
- {160, 120, 0x00ffffff},
- {320, 120, 0x00ffffff},
- {480, 120, 0x00ffffff},
- {160, 240, 0x00ffffff},
- {320, 240, 0x00ffffff},
- {480, 240, 0x00ffffff},
- {160, 360, 0x00ffffff},
- {320, 360, 0x00ffffff},
- {480, 360, 0x00ffffff},
- },
expected_directional_local_0[] =
{
{160, 120, 0x00ffffff},
@@ -4071,41 +4195,56 @@ static void test_specular_lighting(void)
D3DLIGHT7 *light;
BOOL local_viewer;
float specular_power;
- const struct expected_color *expected;
+ const struct expected_color *expected, *expected_process_vertices;
unsigned int expected_count;
+ BOOL todo_process_vertices;
}
tests[] =
{
- {&directional, FALSE, 30.0f, expected_directional, ARRAY_SIZE(expected_directional)},
- {&directional, TRUE, 30.0f, expected_directional_local, ARRAY_SIZE(expected_directional_local)},
- {&point, FALSE, 30.0f, expected_point, ARRAY_SIZE(expected_point)},
- {&point, TRUE, 30.0f, expected_point_local, ARRAY_SIZE(expected_point_local)},
- {&spot, FALSE, 30.0f, expected_spot, ARRAY_SIZE(expected_spot)},
- {&spot, TRUE, 30.0f, expected_spot_local, ARRAY_SIZE(expected_spot_local)},
- {&point_range, FALSE, 30.0f, expected_point_range, ARRAY_SIZE(expected_point_range)},
- {&point_side, TRUE, 0.0f, expected_point_side, ARRAY_SIZE(expected_point_side)},
- {&directional, FALSE, 0.0f, expected_directional_0, ARRAY_SIZE(expected_directional_0)},
- {&directional, TRUE, 0.0f, expected_directional_local_0, ARRAY_SIZE(expected_directional_local_0)},
- {&point, FALSE, 0.0f, expected_point_0, ARRAY_SIZE(expected_point_0)},
- {&point, TRUE, 0.0f, expected_point_0, ARRAY_SIZE(expected_point_0)},
- {&spot, FALSE, 0.0f, expected_spot_0, ARRAY_SIZE(expected_spot_0)},
- {&spot, TRUE, 0.0f, expected_spot_0, ARRAY_SIZE(expected_spot_0)},
- {&point_range, FALSE, 0.0f, expected_point_range_0, ARRAY_SIZE(expected_point_range_0)},
- };
+ {&directional, FALSE, 30.0f, expected_directional, expected_directional,
+ ARRAY_SIZE(expected_directional)},
+ {&directional, TRUE, 30.0f, expected_directional_local, expected_directional_local,
+ ARRAY_SIZE(expected_directional_local)},
+ {&point, FALSE, 30.0f, expected_point, expected_point, ARRAY_SIZE(expected_point)},
+ {&point, TRUE, 30.0f, expected_point_local, expected_point_local, ARRAY_SIZE(expected_point_local)},
+ {&spot, FALSE, 30.0f, expected_spot, expected_spot, ARRAY_SIZE(expected_spot)},
+ {&spot, TRUE, 30.0f, expected_spot_local, expected_spot_local, ARRAY_SIZE(expected_spot_local)},
+ {&point_range, FALSE, 30.0f, expected_point_range, expected_point_range,
+ ARRAY_SIZE(expected_point_range)},
+
+ /* For zero material shininess _ProcessVertices() seem to keep non-zero material shininess set previously. */
+ {&point_side, TRUE, 0.0f, expected_point_side, expected_point_side, ARRAY_SIZE(expected_point_side), TRUE},
+ {&directional, FALSE, 0.0f, expected_directional, expected_directional,
+ ARRAY_SIZE(expected_directional), TRUE},
+ {&directional, TRUE, 0.0f, expected_directional_local_0, expected_directional_local,
+ ARRAY_SIZE(expected_directional_local_0), TRUE},
+ {&point, FALSE, 0.0f, expected_point_0, expected_point, ARRAY_SIZE(expected_point_0), TRUE},
+ {&point, TRUE, 0.0f, expected_point_0, expected_point_local, ARRAY_SIZE(expected_point_0), TRUE},
+ {&spot, FALSE, 0.0f, expected_spot_0, expected_spot, ARRAY_SIZE(expected_spot_0), TRUE},
+ {&spot, TRUE, 0.0f, expected_spot_0, expected_spot_local, ARRAY_SIZE(expected_spot_0), TRUE},
+ {&point_range, FALSE, 0.0f, expected_point_range_0, expected_point_range, ARRAY_SIZE(expected_point_range_0), TRUE},
+ };
+
+ IDirect3DVertexBuffer7 *src_vb, *dst_vb;
+ D3DCOLOR color, expected_color;
+ D3DVERTEXBUFFERDESC vb_desc;
IDirect3DDevice7 *device;
+ unsigned int i, j, x, y;
IDirectDrawSurface7 *rt;
D3DMATERIAL7 material;
- D3DCOLOR color;
+ struct vec3 *src_data;
+ struct vertex *quad;
+ IDirect3D7 *d3d;
ULONG refcount;
+ WORD *indices;
HWND window;
HRESULT hr;
- unsigned int i, j, x, y;
struct
{
- struct vec3 position;
- struct vec3 normal;
- } *quad;
- WORD *indices;
+ struct vec4 position;
+ DWORD diffuse;
+ DWORD specular;
+ } *dst_data;
window = create_window();
if (!(device = create_device(window, DDSCL_NORMAL)))
@@ -4114,9 +4253,11 @@ static void test_specular_lighting(void)
DestroyWindow(window);
return;
}
+ hr = IDirect3DDevice7_GetDirect3D(device, &d3d);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
- quad = HeapAlloc(GetProcessHeap(), 0, vertices_side * vertices_side * sizeof(*quad));
- indices = HeapAlloc(GetProcessHeap(), 0, indices_count * sizeof(*indices));
+ quad = heap_alloc(vertices_side * vertices_side * sizeof(*quad));
+ indices = heap_alloc(indices_count * sizeof(*indices));
for (i = 0, y = 0; y < vertices_side; ++y)
{
for (x = 0; x < vertices_side; ++x)
@@ -4143,56 +4284,89 @@ static void test_specular_lighting(void)
}
hr = IDirect3DDevice7_GetRenderTarget(device, &rt);
- ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_SetTransform(device, D3DTRANSFORMSTATE_WORLD, &mat);
- ok(SUCCEEDED(hr), "Failed to set world transform, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_SetTransform(device, D3DTRANSFORMSTATE_VIEW, &mat);
- ok(SUCCEEDED(hr), "Failed to set view transform, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_SetTransform(device, D3DTRANSFORMSTATE_PROJECTION, &mat);
- ok(SUCCEEDED(hr), "Failed to set projection transform, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_CLIPPING, FALSE);
- ok(SUCCEEDED(hr), "Failed to disable clipping, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_ZENABLE, FALSE);
- ok(SUCCEEDED(hr), "Failed to disable z-buffering, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_FOGENABLE, FALSE);
- ok(SUCCEEDED(hr), "Failed to disable fog, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_LightEnable(device, 0, TRUE);
- ok(SUCCEEDED(hr), "Failed to enable light 0, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_SPECULARENABLE, TRUE);
- ok(SUCCEEDED(hr), "Failed to enable specular lighting, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+
+ memset(&vb_desc, 0, sizeof(vb_desc));
+ vb_desc.dwSize = sizeof(vb_desc);
+ vb_desc.dwFVF = fvf;
+ vb_desc.dwNumVertices = ARRAY_SIZE(vertices);
+ hr = IDirect3D7_CreateVertexBuffer(d3d, &vb_desc, &src_vb, 0);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+ hr = IDirect3DVertexBuffer7_Lock(src_vb, 0, (void **)&src_data, NULL);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+ memcpy(src_data, vertices, sizeof(vertices));
+ hr = IDirect3DVertexBuffer7_Unlock(src_vb);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+
+ memset(&vb_desc, 0, sizeof(vb_desc));
+ vb_desc.dwSize = sizeof(vb_desc);
+ vb_desc.dwFVF = D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR;
+ vb_desc.dwNumVertices = ARRAY_SIZE(vertices);
+ hr = IDirect3D7_CreateVertexBuffer(d3d, &vb_desc, &dst_vb, 0);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
for (i = 0; i < ARRAY_SIZE(tests); ++i)
{
hr = IDirect3DDevice7_SetLight(device, 0, tests[i].light);
- ok(SUCCEEDED(hr), "Failed to set light parameters, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_LOCALVIEWER, tests[i].local_viewer);
- ok(SUCCEEDED(hr), "Failed to set local viewer state, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
memset(&material, 0, sizeof(material));
U1(U2(material).specular).r = 1.0f;
U2(U2(material).specular).g = 1.0f;
U3(U2(material).specular).b = 1.0f;
- U4(U2(material).specular).a = 1.0f;
+ U4(U2(material).specular).a = 0.5f;
U4(material).power = tests[i].specular_power;
hr = IDirect3DDevice7_SetMaterial(device, &material);
- ok(SUCCEEDED(hr), "Failed to set material, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
- ok(SUCCEEDED(hr), "Failed to clear, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_BeginScene(device);
- ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+
+ hr = IDirect3DVertexBuffer7_Lock(dst_vb, 0, (void **)&dst_data, NULL);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+ memset(dst_data, 0, sizeof(*dst_data) * ARRAY_SIZE(vertices));
+ hr = IDirect3DVertexBuffer7_Unlock(dst_vb);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+
+ hr = IDirect3DVertexBuffer7_ProcessVertices(dst_vb, D3DVOP_TRANSFORM | D3DVOP_LIGHT, 0,
+ ARRAY_SIZE(vertices), src_vb, 0, device, 0);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, fvf, quad,
vertices_side * vertices_side, indices, indices_count, 0);
- ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice7_EndScene(device);
- ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+ hr = IDirect3DVertexBuffer7_Lock(dst_vb, 0, (void **)&dst_data, NULL);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+
+ ok(tests[i].expected_count == ARRAY_SIZE(vertices), "Array size mismatch.\n");
for (j = 0; j < tests[i].expected_count; ++j)
{
color = get_surface_color(rt, tests[i].expected[j].x, tests[i].expected[j].y);
@@ -4200,16 +4374,28 @@ static void test_specular_lighting(void)
"Expected color 0x%08x at location (%u, %u), got 0x%08x, case %u.\n",
tests[i].expected[j].color, tests[i].expected[j].x,
tests[i].expected[j].y, color, i);
+ ok(!dst_data[j].diffuse, "Expected color 0x00000000 for vertex %u, got 0x%08x, case %u.\n",
+ j, dst_data[j].diffuse, i);
+ expected_color = tests[i].expected_process_vertices[j].color | 0x80000000;
+ todo_wine_if(tests[i].todo_process_vertices && dst_data[j].specular != expected_color)
+ ok(compare_color(dst_data[j].specular, expected_color, 1),
+ "Expected color 0x%08x for vertex %u, got 0x%08x, case %u.\n",
+ expected_color, j, dst_data[j].specular, i);
}
+ hr = IDirect3DVertexBuffer7_Unlock(dst_vb);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
}
+ IDirect3DVertexBuffer7_Release(dst_vb);
+ IDirect3DVertexBuffer7_Release(src_vb);
IDirectDrawSurface7_Release(rt);
+ IDirect3D7_Release(d3d);
refcount = IDirect3DDevice7_Release(device);
ok(!refcount, "Device has %u references left.\n", refcount);
DestroyWindow(window);
- HeapFree(GetProcessHeap(), 0, indices);
- HeapFree(GetProcessHeap(), 0, quad);
+ heap_free(indices);
+ heap_free(quad);
}
static void test_clear_rect_count(void)
--
2.21.0
More information about the wine-devel
mailing list