[PATCH 2/5] d3d8/tests: Use create_device() in more tests.
Henri Verbeet
hverbeet at codeweavers.com
Fri Mar 7 04:17:12 CST 2014
---
dlls/d3d8/tests/device.c | 837 ++++++++++++++++++----------------------------
1 file changed, 334 insertions(+), 503 deletions(-)
diff --git a/dlls/d3d8/tests/device.c b/dlls/d3d8/tests/device.c
index 324160b..fa370b0 100644
--- a/dlls/d3d8/tests/device.c
+++ b/dlls/d3d8/tests/device.c
@@ -180,94 +180,75 @@ static void check_mipmap_levels(IDirect3DDevice8 *device, UINT width, UINT heigh
static void test_mipmap_levels(void)
{
- HRESULT hr;
- IDirect3DDevice8 *pDevice = NULL;
- D3DPRESENT_PARAMETERS d3dpp;
- D3DDISPLAYMODE d3ddm;
+ IDirect3DDevice8 *device;
IDirect3D8 *d3d;
- HWND hwnd;
+ ULONG refcount;
+ HWND window;
- hwnd = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
- 100, 100, 160, 160, NULL, NULL, NULL, NULL);
- ok(!!hwnd, "Failed to create a window.\n");
+ window = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
+ 0, 0, 640, 480, NULL, NULL, NULL, NULL);
+ ok(!!window, "Failed to create a window.\n");
d3d = Direct3DCreate8(D3D_SDK_VERSION);
ok(!!d3d, "Failed to create a D3D object.\n");
-
- IDirect3D8_GetAdapterDisplayMode(d3d, D3DADAPTER_DEFAULT, &d3ddm);
- ZeroMemory( &d3dpp, sizeof(d3dpp) );
- d3dpp.Windowed = TRUE;
- d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
- d3dpp.BackBufferFormat = d3ddm.Format;
- if (FAILED(hr = IDirect3D8_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
- hwnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice)))
+ if (!(device = create_device(d3d, window, window, TRUE)))
{
- skip("could not create device, IDirect3D8_CreateDevice returned %#08x\n", hr);
+ skip("Failed to create a 3D device, skipping test.\n");
goto cleanup;
}
- check_mipmap_levels(pDevice, 32, 32, 6);
- check_mipmap_levels(pDevice, 256, 1, 9);
- check_mipmap_levels(pDevice, 1, 256, 9);
- check_mipmap_levels(pDevice, 1, 1, 1);
+ check_mipmap_levels(device, 32, 32, 6);
+ check_mipmap_levels(device, 256, 1, 9);
+ check_mipmap_levels(device, 1, 256, 9);
+ check_mipmap_levels(device, 1, 1, 1);
+ refcount = IDirect3DDevice8_Release(device);
+ ok(!refcount, "Device has %u references left.\n", refcount);
cleanup:
- if (pDevice)
- {
- UINT refcount = IDirect3DDevice8_Release( pDevice );
- ok(!refcount, "Device has %u references left.\n", refcount);
- }
IDirect3D8_Release(d3d);
- DestroyWindow(hwnd);
+ DestroyWindow(window);
}
static void test_swapchain(void)
{
- HRESULT hr;
- IDirect3DDevice8 *pDevice = NULL;
- IDirect3DSwapChain8 *swapchain1 = NULL;
- IDirect3DSwapChain8 *swapchain2 = NULL;
- IDirect3DSwapChain8 *swapchain3 = NULL;
- IDirect3DSurface8 *backbuffer = NULL;
- D3DPRESENT_PARAMETERS d3dpp;
- D3DDISPLAYMODE d3ddm;
+ IDirect3DSwapChain8 *swapchain1;
+ IDirect3DSwapChain8 *swapchain2;
+ IDirect3DSwapChain8 *swapchain3;
+ IDirect3DSurface8 *backbuffer;
+ D3DPRESENT_PARAMETERS d3dpp;
+ IDirect3DDevice8 *device;
IDirect3D8 *d3d;
- HWND hwnd;
+ ULONG refcount;
+ HWND window;
+ HRESULT hr;
- hwnd = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
- 100, 100, 160, 160, NULL, NULL, NULL, NULL);
- ok(!!hwnd, "Failed to create a window.\n");
+ window = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
+ 0, 0, 640, 480, NULL, NULL, NULL, NULL);
+ ok(!!window, "Failed to create a window.\n");
d3d = Direct3DCreate8(D3D_SDK_VERSION);
ok(!!d3d, "Failed to create a D3D object.\n");
-
- IDirect3D8_GetAdapterDisplayMode(d3d, D3DADAPTER_DEFAULT, &d3ddm);
- ZeroMemory( &d3dpp, sizeof(d3dpp) );
- d3dpp.Windowed = TRUE;
- d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
- d3dpp.BackBufferFormat = d3ddm.Format;
- d3dpp.BackBufferCount = 0;
-
- if (FAILED(hr = IDirect3D8_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
- hwnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice)))
+ if (!(device = create_device(d3d, window, window, TRUE)))
{
- skip("could not create device, IDirect3D8_CreateDevice returned %#08x\n", hr);
+ skip("Failed to create a 3D device, skipping test.\n");
goto cleanup;
}
- /* Check if the back buffer count was modified */
- ok(d3dpp.BackBufferCount == 1, "The back buffer count in the presentparams struct is %d\n", d3dpp.BackBufferCount);
+ memset(&d3dpp, 0, sizeof(d3dpp));
+ d3dpp.Windowed = TRUE;
+ d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
+ d3dpp.BackBufferFormat = D3DFMT_A8R8G8B8;
/* Create a bunch of swapchains */
d3dpp.BackBufferCount = 0;
- hr = IDirect3DDevice8_CreateAdditionalSwapChain(pDevice, &d3dpp, &swapchain1);
+ hr = IDirect3DDevice8_CreateAdditionalSwapChain(device, &d3dpp, &swapchain1);
ok(SUCCEEDED(hr), "Failed to create a swapchain (%#08x)\n", hr);
ok(d3dpp.BackBufferCount == 1, "The back buffer count in the presentparams struct is %d\n", d3dpp.BackBufferCount);
d3dpp.BackBufferCount = 1;
- hr = IDirect3DDevice8_CreateAdditionalSwapChain(pDevice, &d3dpp, &swapchain2);
+ hr = IDirect3DDevice8_CreateAdditionalSwapChain(device, &d3dpp, &swapchain2);
ok(SUCCEEDED(hr), "Failed to create a swapchain (%#08x)\n", hr);
d3dpp.BackBufferCount = 2;
- hr = IDirect3DDevice8_CreateAdditionalSwapChain(pDevice, &d3dpp, &swapchain3);
+ hr = IDirect3DDevice8_CreateAdditionalSwapChain(device, &d3dpp, &swapchain3);
ok(SUCCEEDED(hr), "Failed to create a swapchain (%#08x)\n", hr);
if(SUCCEEDED(hr)) {
/* Swapchain 3, created with backbuffercount 2 */
@@ -328,23 +309,18 @@ static void test_swapchain(void)
ok(backbuffer == (void *) 0xdeadbeef, "The back buffer pointer was modified (%p)\n", backbuffer);
if(backbuffer && backbuffer != (void *) 0xdeadbeef) IDirect3DSurface8_Release(backbuffer);
+ IDirect3DSwapChain8_Release(swapchain3);
+ IDirect3DSwapChain8_Release(swapchain2);
+ IDirect3DSwapChain8_Release(swapchain1);
+ refcount = IDirect3DDevice8_Release(device);
+ ok(!refcount, "Device has %u references left.\n", refcount);
cleanup:
- if(swapchain1) IDirect3DSwapChain8_Release(swapchain1);
- if(swapchain2) IDirect3DSwapChain8_Release(swapchain2);
- if(swapchain3) IDirect3DSwapChain8_Release(swapchain3);
- if (pDevice)
- {
- UINT refcount = IDirect3DDevice8_Release(pDevice);
- ok(!refcount, "Device has %u references left.\n", refcount);
- }
IDirect3D8_Release(d3d);
- DestroyWindow(hwnd);
+ DestroyWindow(window);
}
static void test_refcount(void)
{
- HRESULT hr;
- IDirect3DDevice8 *pDevice = NULL;
IDirect3DVertexBuffer8 *pVertexBuffer = NULL;
IDirect3DIndexBuffer8 *pIndexBuffer = NULL;
DWORD dVertexShader = -1;
@@ -364,10 +340,11 @@ static void test_refcount(void)
IDirect3DSwapChain8 *pSwapChain = NULL;
D3DCAPS8 caps;
D3DPRESENT_PARAMETERS d3dpp;
- D3DDISPLAYMODE d3ddm;
- int refcount = 0, tmp;
+ IDirect3DDevice8 *device = NULL;
+ ULONG refcount = 0, tmp;
IDirect3D8 *d3d, *d3d2;
- HWND hwnd;
+ HWND window;
+ HRESULT hr;
DWORD decl[] =
{
@@ -377,37 +354,29 @@ static void test_refcount(void)
D3DVSD_END()
};
- hwnd = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
- 100, 100, 160, 160, NULL, NULL, NULL, NULL);
- ok(!!hwnd, "Failed to create a window.\n");
+ window = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
+ 0, 0, 640, 480, NULL, NULL, NULL, NULL);
+ ok(!!window, "Failed to create a window.\n");
d3d = Direct3DCreate8(D3D_SDK_VERSION);
ok(!!d3d, "Failed to create a D3D object.\n");
CHECK_REFCOUNT(d3d, 1);
- IDirect3D8_GetAdapterDisplayMode(d3d, D3DADAPTER_DEFAULT, &d3ddm);
- ZeroMemory( &d3dpp, sizeof(d3dpp) );
- d3dpp.Windowed = TRUE;
- d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
- d3dpp.BackBufferFormat = d3ddm.Format;
- d3dpp.EnableAutoDepthStencil = TRUE;
- d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
-
- if (FAILED(hr = IDirect3D8_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
- hwnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice)))
+ if (!(device = create_device(d3d, window, window, TRUE)))
{
- skip("could not create device, IDirect3D8_CreateDevice returned %#08x\n", hr);
+ skip("Failed to create a 3D device, skipping test.\n");
goto cleanup;
}
- IDirect3DDevice8_GetDeviceCaps(pDevice, &caps);
- refcount = get_refcount( (IUnknown *)pDevice );
+ IDirect3DDevice8_GetDeviceCaps(device, &caps);
+
+ refcount = get_refcount((IUnknown *)device);
ok(refcount == 1, "Invalid device RefCount %d\n", refcount);
CHECK_REFCOUNT(d3d, 2);
- hr = IDirect3DDevice8_GetDirect3D(pDevice, &d3d2);
- CHECK_CALL( hr, "GetDirect3D", pDevice, refcount );
+ hr = IDirect3DDevice8_GetDirect3D(device, &d3d2);
+ CHECK_CALL(hr, "GetDirect3D", device, refcount);
ok(d3d2 == d3d, "Expected IDirect3D8 pointers to be equal.\n");
CHECK_REFCOUNT(d3d, 3);
@@ -421,35 +390,35 @@ static void test_refcount(void)
* - they are not freed if refcount reaches 0.
* - the refcount is not forwarded to the container.
*/
- hr = IDirect3DDevice8_GetRenderTarget(pDevice, &pRenderTarget);
- CHECK_CALL( hr, "GetRenderTarget", pDevice, ++refcount);
+ hr = IDirect3DDevice8_GetRenderTarget(device, &pRenderTarget);
+ CHECK_CALL(hr, "GetRenderTarget", device, ++refcount);
if(pRenderTarget)
{
- CHECK_SURFACE_CONTAINER( pRenderTarget, IID_IDirect3DDevice8, pDevice);
+ CHECK_SURFACE_CONTAINER(pRenderTarget, IID_IDirect3DDevice8, device);
CHECK_REFCOUNT( pRenderTarget, 1);
CHECK_ADDREF_REFCOUNT(pRenderTarget, 2);
- CHECK_REFCOUNT(pDevice, refcount);
+ CHECK_REFCOUNT(device, refcount);
CHECK_RELEASE_REFCOUNT(pRenderTarget, 1);
- CHECK_REFCOUNT(pDevice, refcount);
+ CHECK_REFCOUNT(device, refcount);
- hr = IDirect3DDevice8_GetRenderTarget(pDevice, &pRenderTarget);
- CHECK_CALL( hr, "GetRenderTarget", pDevice, refcount);
+ hr = IDirect3DDevice8_GetRenderTarget(device, &pRenderTarget);
+ CHECK_CALL(hr, "GetRenderTarget", device, refcount);
CHECK_REFCOUNT( pRenderTarget, 2);
CHECK_RELEASE_REFCOUNT( pRenderTarget, 1);
CHECK_RELEASE_REFCOUNT( pRenderTarget, 0);
- CHECK_REFCOUNT( pDevice, --refcount);
+ CHECK_REFCOUNT(device, --refcount);
/* The render target is released with the device, so AddRef with refcount=0 is fine here. */
CHECK_ADDREF_REFCOUNT(pRenderTarget, 1);
- CHECK_REFCOUNT(pDevice, ++refcount);
+ CHECK_REFCOUNT(device, ++refcount);
CHECK_RELEASE_REFCOUNT(pRenderTarget, 0);
- CHECK_REFCOUNT(pDevice, --refcount);
+ CHECK_REFCOUNT(device, --refcount);
}
/* Render target and back buffer are identical. */
- hr = IDirect3DDevice8_GetBackBuffer(pDevice, 0, 0, &pBackBuffer);
- CHECK_CALL( hr, "GetBackBuffer", pDevice, ++refcount);
+ hr = IDirect3DDevice8_GetBackBuffer(device, 0, 0, &pBackBuffer);
+ CHECK_CALL(hr, "GetBackBuffer", device, ++refcount);
if(pBackBuffer)
{
CHECK_RELEASE_REFCOUNT(pBackBuffer, 0);
@@ -457,46 +426,46 @@ static void test_refcount(void)
pRenderTarget, pBackBuffer);
pBackBuffer = NULL;
}
- CHECK_REFCOUNT( pDevice, --refcount);
+ CHECK_REFCOUNT(device, --refcount);
- hr = IDirect3DDevice8_GetDepthStencilSurface(pDevice, &pStencilSurface);
- CHECK_CALL( hr, "GetDepthStencilSurface", pDevice, ++refcount);
+ hr = IDirect3DDevice8_GetDepthStencilSurface(device, &pStencilSurface);
+ CHECK_CALL(hr, "GetDepthStencilSurface", device, ++refcount);
if(pStencilSurface)
{
- CHECK_SURFACE_CONTAINER( pStencilSurface, IID_IDirect3DDevice8, pDevice);
+ CHECK_SURFACE_CONTAINER(pStencilSurface, IID_IDirect3DDevice8, device);
CHECK_REFCOUNT( pStencilSurface, 1);
CHECK_ADDREF_REFCOUNT(pStencilSurface, 2);
- CHECK_REFCOUNT(pDevice, refcount);
+ CHECK_REFCOUNT(device, refcount);
CHECK_RELEASE_REFCOUNT(pStencilSurface, 1);
- CHECK_REFCOUNT(pDevice, refcount);
+ CHECK_REFCOUNT(device, refcount);
CHECK_RELEASE_REFCOUNT( pStencilSurface, 0);
- CHECK_REFCOUNT( pDevice, --refcount);
+ CHECK_REFCOUNT(device, --refcount);
/* The stencil surface is released with the device, so AddRef with refcount=0 is fine here. */
CHECK_ADDREF_REFCOUNT(pStencilSurface, 1);
- CHECK_REFCOUNT(pDevice, ++refcount);
+ CHECK_REFCOUNT(device, ++refcount);
CHECK_RELEASE_REFCOUNT(pStencilSurface, 0);
- CHECK_REFCOUNT(pDevice, --refcount);
+ CHECK_REFCOUNT(device, --refcount);
pStencilSurface = NULL;
}
/* Buffers */
- hr = IDirect3DDevice8_CreateIndexBuffer( pDevice, 16, 0, D3DFMT_INDEX32, D3DPOOL_DEFAULT, &pIndexBuffer );
- CHECK_CALL( hr, "CreateIndexBuffer", pDevice, ++refcount );
+ hr = IDirect3DDevice8_CreateIndexBuffer(device, 16, 0, D3DFMT_INDEX32, D3DPOOL_DEFAULT, &pIndexBuffer);
+ CHECK_CALL(hr, "CreateIndexBuffer", device, ++refcount);
if(pIndexBuffer)
{
tmp = get_refcount( (IUnknown *)pIndexBuffer );
- hr = IDirect3DDevice8_SetIndices(pDevice, pIndexBuffer, 0);
+ hr = IDirect3DDevice8_SetIndices(device, pIndexBuffer, 0);
CHECK_CALL( hr, "SetIndices", pIndexBuffer, tmp);
- hr = IDirect3DDevice8_SetIndices(pDevice, NULL, 0);
+ hr = IDirect3DDevice8_SetIndices(device, NULL, 0);
CHECK_CALL( hr, "SetIndices", pIndexBuffer, tmp);
}
- hr = IDirect3DDevice8_CreateVertexBuffer( pDevice, 16, 0, D3DFVF_XYZ, D3DPOOL_DEFAULT, &pVertexBuffer );
- CHECK_CALL( hr, "CreateVertexBuffer", pDevice, ++refcount );
+ hr = IDirect3DDevice8_CreateVertexBuffer(device, 16, 0, D3DFVF_XYZ, D3DPOOL_DEFAULT, &pVertexBuffer);
+ CHECK_CALL(hr, "CreateVertexBuffer", device, ++refcount);
if(pVertexBuffer)
{
IDirect3DVertexBuffer8 *pVBuf = (void*)~0;
@@ -504,41 +473,41 @@ static void test_refcount(void)
tmp = get_refcount( (IUnknown *)pVertexBuffer );
- hr = IDirect3DDevice8_SetStreamSource(pDevice, 0, pVertexBuffer, 3 * sizeof(float));
+ hr = IDirect3DDevice8_SetStreamSource(device, 0, pVertexBuffer, 3 * sizeof(float));
CHECK_CALL( hr, "SetStreamSource", pVertexBuffer, tmp);
- hr = IDirect3DDevice8_SetStreamSource(pDevice, 0, NULL, 0);
+ hr = IDirect3DDevice8_SetStreamSource(device, 0, NULL, 0);
CHECK_CALL( hr, "SetStreamSource", pVertexBuffer, tmp);
- hr = IDirect3DDevice8_GetStreamSource(pDevice, 0, &pVBuf, &stride);
+ hr = IDirect3DDevice8_GetStreamSource(device, 0, &pVBuf, &stride);
ok(SUCCEEDED(hr), "GetStreamSource did not succeed with NULL stream!\n");
ok(pVBuf==NULL, "pVBuf not NULL (%p)!\n", pVBuf);
ok(stride==3*sizeof(float), "stride not 3 floats (got %u)!\n", stride);
}
/* Shaders */
- hr = IDirect3DDevice8_CreateVertexShader( pDevice, decl, simple_vs, &dVertexShader, 0 );
- CHECK_CALL( hr, "CreateVertexShader", pDevice, refcount );
+ hr = IDirect3DDevice8_CreateVertexShader(device, decl, simple_vs, &dVertexShader, 0);
+ CHECK_CALL(hr, "CreateVertexShader", device, refcount);
if (caps.PixelShaderVersion >= D3DPS_VERSION(1, 0))
{
- hr = IDirect3DDevice8_CreatePixelShader( pDevice, simple_ps, &dPixelShader );
- CHECK_CALL( hr, "CreatePixelShader", pDevice, refcount );
+ hr = IDirect3DDevice8_CreatePixelShader(device, simple_ps, &dPixelShader);
+ CHECK_CALL(hr, "CreatePixelShader", device, refcount);
}
/* Textures */
- hr = IDirect3DDevice8_CreateTexture( pDevice, 32, 32, 3, 0, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &pTexture );
- CHECK_CALL( hr, "CreateTexture", pDevice, ++refcount );
+ hr = IDirect3DDevice8_CreateTexture(device, 32, 32, 3, 0, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &pTexture);
+ CHECK_CALL(hr, "CreateTexture", device, ++refcount);
if (pTexture)
{
tmp = get_refcount( (IUnknown *)pTexture );
/* SetTexture should not increase refcounts */
- hr = IDirect3DDevice8_SetTexture(pDevice, 0, (IDirect3DBaseTexture8 *) pTexture);
+ hr = IDirect3DDevice8_SetTexture(device, 0, (IDirect3DBaseTexture8 *) pTexture);
CHECK_CALL( hr, "SetTexture", pTexture, tmp);
- hr = IDirect3DDevice8_SetTexture(pDevice, 0, NULL);
+ hr = IDirect3DDevice8_SetTexture(device, 0, NULL);
CHECK_CALL( hr, "SetTexture", pTexture, tmp);
/* This should not increment device refcount */
hr = IDirect3DTexture8_GetSurfaceLevel( pTexture, 1, &pTextureLevel );
- CHECK_CALL( hr, "GetSurfaceLevel", pDevice, refcount );
+ CHECK_CALL(hr, "GetSurfaceLevel", device, refcount);
/* But should increment texture's refcount */
CHECK_REFCOUNT( pTexture, tmp+1 );
/* Because the texture and surface refcount are identical */
@@ -555,8 +524,8 @@ static void test_refcount(void)
}
if(caps.TextureCaps & D3DPTEXTURECAPS_CUBEMAP)
{
- hr = IDirect3DDevice8_CreateCubeTexture( pDevice, 32, 0, 0, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &pCubeTexture );
- CHECK_CALL( hr, "CreateCubeTexture", pDevice, ++refcount );
+ hr = IDirect3DDevice8_CreateCubeTexture(device, 32, 0, 0, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &pCubeTexture);
+ CHECK_CALL(hr, "CreateCubeTexture", device, ++refcount);
}
else
{
@@ -564,8 +533,9 @@ static void test_refcount(void)
}
if(caps.TextureCaps & D3DPTEXTURECAPS_VOLUMEMAP)
{
- hr = IDirect3DDevice8_CreateVolumeTexture( pDevice, 32, 32, 2, 0, 0, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &pVolumeTexture );
- CHECK_CALL( hr, "CreateVolumeTexture", pDevice, ++refcount );
+ hr = IDirect3DDevice8_CreateVolumeTexture(device, 32, 32, 2, 0, 0,
+ D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &pVolumeTexture);
+ CHECK_CALL(hr, "CreateVolumeTexture", device, ++refcount);
}
else
{
@@ -578,7 +548,7 @@ static void test_refcount(void)
/* This should not increment device refcount */
hr = IDirect3DVolumeTexture8_GetVolumeLevel(pVolumeTexture, 0, &pVolumeLevel);
- CHECK_CALL( hr, "GetVolumeLevel", pDevice, refcount );
+ CHECK_CALL(hr, "GetVolumeLevel", device, refcount);
/* But should increment volume texture's refcount */
CHECK_REFCOUNT( pVolumeTexture, tmp+1 );
/* Because the volume texture and volume refcount are identical */
@@ -594,38 +564,48 @@ static void test_refcount(void)
}
}
/* Surfaces */
- hr = IDirect3DDevice8_CreateDepthStencilSurface( pDevice, 32, 32, D3DFMT_D16, D3DMULTISAMPLE_NONE, &pStencilSurface );
- CHECK_CALL( hr, "CreateDepthStencilSurface", pDevice, ++refcount );
+ hr = IDirect3DDevice8_CreateDepthStencilSurface(device, 32, 32,
+ D3DFMT_D16, D3DMULTISAMPLE_NONE, &pStencilSurface);
+ CHECK_CALL(hr, "CreateDepthStencilSurface", device, ++refcount);
CHECK_REFCOUNT( pStencilSurface, 1);
- hr = IDirect3DDevice8_CreateImageSurface( pDevice, 32, 32, D3DFMT_X8R8G8B8, &pImageSurface );
- CHECK_CALL( hr, "CreateImageSurface", pDevice, ++refcount );
+ hr = IDirect3DDevice8_CreateImageSurface(device, 32, 32,
+ D3DFMT_X8R8G8B8, &pImageSurface);
+ CHECK_CALL(hr, "CreateImageSurface", device, ++refcount);
CHECK_REFCOUNT( pImageSurface, 1);
- hr = IDirect3DDevice8_CreateRenderTarget( pDevice, 32, 32, D3DFMT_X8R8G8B8, D3DMULTISAMPLE_NONE, TRUE, &pRenderTarget3 );
- CHECK_CALL( hr, "CreateRenderTarget", pDevice, ++refcount );
+ hr = IDirect3DDevice8_CreateRenderTarget(device, 32, 32,
+ D3DFMT_X8R8G8B8, D3DMULTISAMPLE_NONE, TRUE, &pRenderTarget3);
+ CHECK_CALL(hr, "CreateRenderTarget", device, ++refcount);
CHECK_REFCOUNT( pRenderTarget3, 1);
/* Misc */
- hr = IDirect3DDevice8_CreateStateBlock( pDevice, D3DSBT_ALL, &dStateBlock );
- CHECK_CALL( hr, "CreateStateBlock", pDevice, refcount );
- hr = IDirect3DDevice8_CreateAdditionalSwapChain( pDevice, &d3dpp, &pSwapChain );
- CHECK_CALL( hr, "CreateAdditionalSwapChain", pDevice, ++refcount );
+ hr = IDirect3DDevice8_CreateStateBlock(device, D3DSBT_ALL, &dStateBlock);
+ CHECK_CALL(hr, "CreateStateBlock", device, refcount);
+
+ memset(&d3dpp, 0, sizeof(d3dpp));
+ d3dpp.Windowed = TRUE;
+ d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
+ d3dpp.BackBufferFormat = D3DFMT_A8R8G8B8;
+ d3dpp.EnableAutoDepthStencil = TRUE;
+ d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
+ hr = IDirect3DDevice8_CreateAdditionalSwapChain(device, &d3dpp, &pSwapChain);
+ CHECK_CALL(hr, "CreateAdditionalSwapChain", device, ++refcount);
if(pSwapChain)
{
/* check implicit back buffer */
hr = IDirect3DSwapChain8_GetBackBuffer(pSwapChain, 0, 0, &pBackBuffer);
- CHECK_CALL( hr, "GetBackBuffer", pDevice, ++refcount);
+ CHECK_CALL(hr, "GetBackBuffer", device, ++refcount);
CHECK_REFCOUNT( pSwapChain, 1);
if(pBackBuffer)
{
- CHECK_SURFACE_CONTAINER( pBackBuffer, IID_IDirect3DDevice8, pDevice);
+ CHECK_SURFACE_CONTAINER(pBackBuffer, IID_IDirect3DDevice8, device);
CHECK_REFCOUNT( pBackBuffer, 1);
CHECK_RELEASE_REFCOUNT( pBackBuffer, 0);
- CHECK_REFCOUNT( pDevice, --refcount);
+ CHECK_REFCOUNT(device, --refcount);
/* The back buffer is released with the swapchain, so AddRef with refcount=0 is fine here. */
CHECK_ADDREF_REFCOUNT(pBackBuffer, 1);
- CHECK_REFCOUNT(pDevice, ++refcount);
+ CHECK_REFCOUNT(device, ++refcount);
CHECK_RELEASE_REFCOUNT(pBackBuffer, 0);
- CHECK_REFCOUNT(pDevice, --refcount);
+ CHECK_REFCOUNT(device, --refcount);
pBackBuffer = NULL;
}
CHECK_REFCOUNT( pSwapChain, 1);
@@ -647,55 +627,58 @@ static void test_refcount(void)
/* The implicit render target is not freed if refcount reaches 0.
* Otherwise GetRenderTarget would re-allocate it and the pointer would change.*/
- hr = IDirect3DDevice8_GetRenderTarget(pDevice, &pRenderTarget2);
- CHECK_CALL( hr, "GetRenderTarget", pDevice, ++refcount);
+ hr = IDirect3DDevice8_GetRenderTarget(device, &pRenderTarget2);
+ CHECK_CALL(hr, "GetRenderTarget", device, ++refcount);
if(pRenderTarget2)
{
CHECK_RELEASE_REFCOUNT(pRenderTarget2, 0);
ok(pRenderTarget == pRenderTarget2, "RenderTarget=%p and RenderTarget2=%p should be the same.\n",
pRenderTarget, pRenderTarget2);
- CHECK_REFCOUNT( pDevice, --refcount);
+ CHECK_REFCOUNT(device, --refcount);
pRenderTarget2 = NULL;
}
pRenderTarget = NULL;
cleanup:
- CHECK_RELEASE(pDevice, pDevice, --refcount);
+ CHECK_RELEASE(device, device, --refcount);
/* Buffers */
- CHECK_RELEASE(pVertexBuffer, pDevice, --refcount);
- CHECK_RELEASE(pIndexBuffer, pDevice, --refcount);
+ CHECK_RELEASE(pVertexBuffer, device, --refcount);
+ CHECK_RELEASE(pIndexBuffer, device, --refcount);
/* Shaders */
- if (dVertexShader != ~0U) IDirect3DDevice8_DeleteVertexShader( pDevice, dVertexShader );
- if (dPixelShader != ~0U) IDirect3DDevice8_DeletePixelShader( pDevice, dPixelShader );
+ if (dVertexShader != ~0u)
+ IDirect3DDevice8_DeleteVertexShader(device, dVertexShader);
+ if (dPixelShader != ~0u)
+ IDirect3DDevice8_DeletePixelShader(device, dPixelShader);
/* Textures */
- CHECK_RELEASE(pTexture, pDevice, --refcount);
- CHECK_RELEASE(pCubeTexture, pDevice, --refcount);
- CHECK_RELEASE(pVolumeTexture, pDevice, --refcount);
+ CHECK_RELEASE(pTexture, device, --refcount);
+ CHECK_RELEASE(pCubeTexture, device, --refcount);
+ CHECK_RELEASE(pVolumeTexture, device, --refcount);
/* Surfaces */
- CHECK_RELEASE(pStencilSurface, pDevice, --refcount);
- CHECK_RELEASE(pImageSurface, pDevice, --refcount);
- CHECK_RELEASE(pRenderTarget3, pDevice, --refcount);
+ CHECK_RELEASE(pStencilSurface, device, --refcount);
+ CHECK_RELEASE(pImageSurface, device, --refcount);
+ CHECK_RELEASE(pRenderTarget3, device, --refcount);
/* Misc */
- if (dStateBlock != ~0U) IDirect3DDevice8_DeleteStateBlock( pDevice, dStateBlock );
+ if (dStateBlock != ~0u)
+ IDirect3DDevice8_DeleteStateBlock(device, dStateBlock);
/* This will destroy device - cannot check the refcount here */
- if (pSwapChain) CHECK_RELEASE_REFCOUNT( pSwapChain, 0);
+ if (pSwapChain)
+ CHECK_RELEASE_REFCOUNT(pSwapChain, 0);
CHECK_RELEASE_REFCOUNT(d3d, 0);
- DestroyWindow( hwnd );
+ DestroyWindow(window);
}
static void test_cursor(void)
{
- HRESULT hr;
- IDirect3DDevice8 *pDevice = NULL;
- D3DPRESENT_PARAMETERS d3dpp;
- D3DDISPLAYMODE d3ddm;
- CURSORINFO info;
- IDirect3DSurface8 *cursor = NULL;
- HCURSOR cur;
HMODULE user32_handle = GetModuleHandleA("user32.dll");
+ IDirect3DSurface8 *cursor = NULL;
+ IDirect3DDevice8 *device;
+ CURSORINFO info;
IDirect3D8 *d3d;
- HWND hwnd;
+ ULONG refcount;
+ HCURSOR cur;
+ HWND window;
+ HRESULT hr;
pGetCursorInfo = (void *)GetProcAddress(user32_handle, "GetCursorInfo");
if (!pGetCursorInfo)
@@ -709,41 +692,33 @@ static void test_cursor(void)
ok(pGetCursorInfo(&info), "GetCursorInfo failed\n");
cur = info.hCursor;
- hwnd = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
- 100, 100, 160, 160, NULL, NULL, NULL, NULL);
- ok(!!hwnd, "Failed to create a window.\n");
+ window = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
+ 0, 0, 640, 480, NULL, NULL, NULL, NULL);
+ ok(!!window, "Failed to create a window.\n");
d3d = Direct3DCreate8(D3D_SDK_VERSION);
ok(!!d3d, "Failed to create a D3D object.\n");
-
- IDirect3D8_GetAdapterDisplayMode(d3d, D3DADAPTER_DEFAULT, &d3ddm);
- ZeroMemory( &d3dpp, sizeof(d3dpp) );
- d3dpp.Windowed = TRUE;
- d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
- d3dpp.BackBufferFormat = d3ddm.Format;
-
- if (FAILED(hr = IDirect3D8_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
- hwnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice)))
+ if (!(device = create_device(d3d, window, window, TRUE)))
{
- skip("could not create device, IDirect3D8_CreateDevice returned %#08x\n", hr);
+ skip("Failed to create a 3D device, skipping test.\n");
goto cleanup;
}
- IDirect3DDevice8_CreateImageSurface(pDevice, 32, 32, D3DFMT_A8R8G8B8, &cursor);
- ok(cursor != NULL, "IDirect3DDevice8_CreateOffscreenPlainSurface failed with %#08x\n", hr);
+ hr = IDirect3DDevice8_CreateImageSurface(device, 32, 32, D3DFMT_A8R8G8B8, &cursor);
+ ok(SUCCEEDED(hr), "Failed to create cursor surface, hr %#x.\n", hr);
/* Initially hidden */
- hr = IDirect3DDevice8_ShowCursor(pDevice, TRUE);
+ hr = IDirect3DDevice8_ShowCursor(device, TRUE);
ok(hr == FALSE, "IDirect3DDevice8_ShowCursor returned %#08x\n", hr);
/* Not enabled without a surface*/
- hr = IDirect3DDevice8_ShowCursor(pDevice, TRUE);
+ hr = IDirect3DDevice8_ShowCursor(device, TRUE);
ok(hr == FALSE, "IDirect3DDevice8_ShowCursor returned %#08x\n", hr);
/* Fails */
- hr = IDirect3DDevice8_SetCursorProperties(pDevice, 0, 0, NULL);
+ hr = IDirect3DDevice8_SetCursorProperties(device, 0, 0, NULL);
ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_SetCursorProperties returned %#08x\n", hr);
- hr = IDirect3DDevice8_SetCursorProperties(pDevice, 0, 0, cursor);
+ hr = IDirect3DDevice8_SetCursorProperties(device, 0, 0, cursor);
ok(hr == D3D_OK, "IDirect3DDevice8_SetCursorProperties returned %#08x\n", hr);
IDirect3DSurface8_Release(cursor);
@@ -755,11 +730,11 @@ static void test_cursor(void)
ok(info.hCursor == cur, "The cursor handle is %p\n", info.hCursor); /* unchanged */
/* Still hidden */
- hr = IDirect3DDevice8_ShowCursor(pDevice, TRUE);
+ hr = IDirect3DDevice8_ShowCursor(device, TRUE);
ok(hr == FALSE, "IDirect3DDevice8_ShowCursor returned %#08x\n", hr);
/* Enabled now*/
- hr = IDirect3DDevice8_ShowCursor(pDevice, TRUE);
+ hr = IDirect3DDevice8_ShowCursor(device, TRUE);
ok(hr == TRUE, "IDirect3DDevice8_ShowCursor returned %#08x\n", hr);
/* GDI cursor unchanged */
@@ -769,14 +744,11 @@ static void test_cursor(void)
ok(info.flags & CURSOR_SHOWING, "The gdi cursor is hidden (%08x)\n", info.flags);
ok(info.hCursor == cur, "The cursor handle is %p\n", info.hCursor); /* unchanged */
+ refcount = IDirect3DDevice8_Release(device);
+ ok(!refcount, "Device has %u references left.\n", refcount);
cleanup:
- if (pDevice)
- {
- UINT refcount = IDirect3DDevice8_Release(pDevice);
- ok(!refcount, "Device has %u references left.\n", refcount);
- }
IDirect3D8_Release(d3d);
- DestroyWindow(hwnd);
+ DestroyWindow(window);
}
static const POINT *expect_pos;
@@ -897,47 +869,33 @@ done:
static void test_states(void)
{
- HRESULT hr;
- IDirect3DDevice8 *pDevice = NULL;
- D3DPRESENT_PARAMETERS d3dpp;
- D3DDISPLAYMODE d3ddm;
+ IDirect3DDevice8 *device;
IDirect3D8 *d3d;
- HWND hwnd;
+ ULONG refcount;
+ HWND window;
+ HRESULT hr;
- hwnd = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
- 100, 100, 160, 160, NULL, NULL, NULL, NULL);
- ok(!!hwnd, "Failed to create a window.\n");
+ window = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
+ 0, 0, 640, 480, NULL, NULL, NULL, NULL);
+ ok(!!window, "Failed to create a window.\n");
d3d = Direct3DCreate8(D3D_SDK_VERSION);
ok(!!d3d, "Failed to create a D3D object.\n");
-
- IDirect3D8_GetAdapterDisplayMode(d3d, D3DADAPTER_DEFAULT, &d3ddm);
- ZeroMemory( &d3dpp, sizeof(d3dpp) );
- d3dpp.Windowed = TRUE;
- d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
- d3dpp.BackBufferWidth = screen_width;
- d3dpp.BackBufferHeight = screen_height;
- d3dpp.BackBufferFormat = d3ddm.Format;
-
- if (FAILED(hr = IDirect3D8_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL /* no NULLREF here */,
- hwnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice)))
+ if (!(device = create_device(d3d, window, window, TRUE)))
{
- skip("could not create device, IDirect3D8_CreateDevice returned %#08x\n", hr);
+ skip("Failed to create a 3D device, skipping test.\n");
goto cleanup;
}
- hr = IDirect3DDevice8_SetRenderState(pDevice, D3DRS_ZVISIBLE, TRUE);
+ hr = IDirect3DDevice8_SetRenderState(device, D3DRS_ZVISIBLE, TRUE);
ok(hr == D3D_OK, "IDirect3DDevice8_SetRenderState(D3DRS_ZVISIBLE, TRUE) returned %#08x\n", hr);
- hr = IDirect3DDevice8_SetRenderState(pDevice, D3DRS_ZVISIBLE, FALSE);
+ hr = IDirect3DDevice8_SetRenderState(device, D3DRS_ZVISIBLE, FALSE);
ok(hr == D3D_OK, "IDirect3DDevice8_SetRenderState(D3DRS_ZVISIBLE, FALSE) returned %#08x\n", hr);
+ refcount = IDirect3DDevice8_Release(device);
+ ok(!refcount, "Device has %u references left.\n", refcount);
cleanup:
- if (pDevice)
- {
- UINT refcount = IDirect3DDevice8_Release(pDevice);
- ok(!refcount, "Device has %u references left.\n", refcount);
- }
IDirect3D8_Release(d3d);
- DestroyWindow(hwnd);
+ DestroyWindow(window);
}
static void test_shader_versions(void)
@@ -1565,90 +1523,70 @@ cleanup:
static void test_scene(void)
{
- HRESULT hr;
- IDirect3DDevice8 *pDevice = NULL;
- D3DPRESENT_PARAMETERS d3dpp;
- D3DDISPLAYMODE d3ddm;
+ IDirect3DDevice8 *device;
IDirect3D8 *d3d;
- HWND hwnd;
+ ULONG refcount;
+ HWND window;
+ HRESULT hr;
- hwnd = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
- 100, 100, 160, 160, NULL, NULL, NULL, NULL);
- ok(!!hwnd, "Failed to create a window.\n");
+ window = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
+ 0, 0, 640, 480, NULL, NULL, NULL, NULL);
+ ok(!!window, "Failed to create a window.\n");
d3d = Direct3DCreate8(D3D_SDK_VERSION);
ok(!!d3d, "Failed to create a D3D object.\n");
-
- IDirect3D8_GetAdapterDisplayMode(d3d, D3DADAPTER_DEFAULT, &d3ddm);
- ZeroMemory( &d3dpp, sizeof(d3dpp) );
- d3dpp.Windowed = TRUE;
- d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
- d3dpp.BackBufferWidth = 800;
- d3dpp.BackBufferHeight = 600;
- d3dpp.BackBufferFormat = d3ddm.Format;
-
- hr = IDirect3D8_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL /* no NULLREF here */,
- hwnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice);
- ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL || broken(hr == D3DERR_NOTAVAILABLE), "IDirect3D8_CreateDevice failed with %#08x\n", hr);
- if(!pDevice)
+ if (!(device = create_device(d3d, window, window, TRUE)))
{
- skip("could not create device, IDirect3D8_CreateDevice returned %#08x\n", hr);
+ skip("Failed to create a 3D device, skipping test.\n");
goto cleanup;
}
/* Test an EndScene without BeginScene. Should return an error */
- hr = IDirect3DDevice8_EndScene(pDevice);
+ hr = IDirect3DDevice8_EndScene(device);
ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_EndScene returned %#08x\n", hr);
/* Test a normal BeginScene / EndScene pair, this should work */
- hr = IDirect3DDevice8_BeginScene(pDevice);
+ hr = IDirect3DDevice8_BeginScene(device);
ok(hr == D3D_OK, "IDirect3DDevice8_BeginScene failed with %#08x\n", hr);
- if(SUCCEEDED(hr))
- {
- hr = IDirect3DDevice8_EndScene(pDevice);
- ok(hr == D3D_OK, "IDirect3DDevice8_EndScene failed with %#08x\n", hr);
- }
+ hr = IDirect3DDevice8_EndScene(device);
+ ok(hr == D3D_OK, "IDirect3DDevice8_EndScene failed with %#08x\n", hr);
/* Test another EndScene without having begun a new scene. Should return an error */
- hr = IDirect3DDevice8_EndScene(pDevice);
+ hr = IDirect3DDevice8_EndScene(device);
ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_EndScene returned %#08x\n", hr);
/* Two nested BeginScene and EndScene calls */
- hr = IDirect3DDevice8_BeginScene(pDevice);
+ hr = IDirect3DDevice8_BeginScene(device);
ok(hr == D3D_OK, "IDirect3DDevice8_BeginScene failed with %#08x\n", hr);
- hr = IDirect3DDevice8_BeginScene(pDevice);
+ hr = IDirect3DDevice8_BeginScene(device);
ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_BeginScene returned %#08x\n", hr);
- hr = IDirect3DDevice8_EndScene(pDevice);
+ hr = IDirect3DDevice8_EndScene(device);
ok(hr == D3D_OK, "IDirect3DDevice8_EndScene failed with %#08x\n", hr);
- hr = IDirect3DDevice8_EndScene(pDevice);
+ hr = IDirect3DDevice8_EndScene(device);
ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_EndScene returned %#08x\n", hr);
/* StretchRect does not exit in Direct3D8, so no equivalent to the d3d9 stretchrect tests */
+ refcount = IDirect3DDevice8_Release(device);
+ ok(!refcount, "Device has %u references left.\n", refcount);
cleanup:
- if (pDevice)
- {
- UINT refcount = IDirect3DDevice8_Release(pDevice);
- ok(!refcount, "Device has %u references left.\n", refcount);
- }
IDirect3D8_Release(d3d);
- DestroyWindow(hwnd);
+ DestroyWindow(window);
}
static void test_shader(void)
{
- HRESULT hr;
- IDirect3DDevice8 *pDevice = NULL;
- D3DPRESENT_PARAMETERS d3dpp;
- D3DDISPLAYMODE d3ddm;
DWORD hPixelShader = 0, hVertexShader = 0;
DWORD hPixelShader2 = 0, hVertexShader2 = 0;
DWORD hTempHandle;
D3DCAPS8 caps;
DWORD fvf = D3DFVF_XYZ | D3DFVF_DIFFUSE;
+ IDirect3DDevice8 *device;
IDirect3D8 *d3d;
DWORD data_size;
+ ULONG refcount;
+ HWND window;
+ HRESULT hr;
void *data;
- HWND hwnd;
static DWORD dwVertexDecl[] =
{
@@ -1681,169 +1619,154 @@ static void test_shader(void)
const DWORD simple_vs_size = sizeof(simple_vs);
const DWORD simple_ps_size = sizeof(simple_ps);
- hwnd = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
- 100, 100, 160, 160, NULL, NULL, NULL, NULL);
- ok(!!hwnd, "Failed to create a window.\n");
+ window = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
+ 0, 0, 640, 480, NULL, NULL, NULL, NULL);
+ ok(!!window, "Failed to create a window.\n");
d3d = Direct3DCreate8(D3D_SDK_VERSION);
ok(!!d3d, "Failed to create a D3D object.\n");
-
- IDirect3D8_GetAdapterDisplayMode(d3d, D3DADAPTER_DEFAULT, &d3ddm);
- ZeroMemory( &d3dpp, sizeof(d3dpp) );
- d3dpp.Windowed = TRUE;
- d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
- d3dpp.BackBufferWidth = 800;
- d3dpp.BackBufferHeight = 600;
- d3dpp.BackBufferFormat = d3ddm.Format;
-
-
- hr = IDirect3D8_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL /* no NULLREF here */,
- hwnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice );
- ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL || broken(hr == D3DERR_NOTAVAILABLE), "IDirect3D8_CreateDevice failed with %#08x\n", hr);
- if(!pDevice)
+ if (!(device = create_device(d3d, window, window, TRUE)))
{
- skip("could not create device, IDirect3D8_CreateDevice returned %#08x\n", hr);
+ skip("Failed to create a 3D device, skipping test.\n");
goto cleanup;
}
- IDirect3DDevice8_GetDeviceCaps(pDevice, &caps);
+
+ IDirect3DDevice8_GetDeviceCaps(device, &caps);
/* Test setting and retrieving a FVF */
- hr = IDirect3DDevice8_SetVertexShader(pDevice, fvf);
+ hr = IDirect3DDevice8_SetVertexShader(device, fvf);
ok(SUCCEEDED(hr), "IDirect3DDevice8_SetVertexShader returned %#08x\n", hr);
- hr = IDirect3DDevice8_GetVertexShader(pDevice, &hTempHandle);
+ hr = IDirect3DDevice8_GetVertexShader(device, &hTempHandle);
ok(SUCCEEDED(hr), "IDirect3DDevice8_GetVertexShader returned %#08x\n", hr);
ok(hTempHandle == fvf, "Vertex shader %#08x is set, expected %#08x\n", hTempHandle, fvf);
/* First create a vertex shader */
- hr = IDirect3DDevice8_SetVertexShader(pDevice, 0);
+ hr = IDirect3DDevice8_SetVertexShader(device, 0);
ok(SUCCEEDED(hr), "IDirect3DDevice8_SetVertexShader returned %#08x\n", hr);
- hr = IDirect3DDevice8_CreateVertexShader(pDevice, dwVertexDecl, simple_vs, &hVertexShader, 0);
+ hr = IDirect3DDevice8_CreateVertexShader(device, dwVertexDecl, simple_vs, &hVertexShader, 0);
ok(hr == D3D_OK, "IDirect3DDevice8_CreateVertexShader returned %#08x\n", hr);
/* Msdn says that the new vertex shader is set immediately. This is wrong, apparently */
- hr = IDirect3DDevice8_GetVertexShader(pDevice, &hTempHandle);
+ hr = IDirect3DDevice8_GetVertexShader(device, &hTempHandle);
ok(hr == D3D_OK, "IDirect3DDevice8_GetVertexShader returned %#08x\n", hr);
ok(hTempHandle == 0, "Vertex Shader %d is set, expected shader %d\n", hTempHandle, 0);
/* Assign the shader, then verify that GetVertexShader works */
- hr = IDirect3DDevice8_SetVertexShader(pDevice, hVertexShader);
+ hr = IDirect3DDevice8_SetVertexShader(device, hVertexShader);
ok(hr == D3D_OK, "IDirect3DDevice8_SetVertexShader returned %#08x\n", hr);
- hr = IDirect3DDevice8_GetVertexShader(pDevice, &hTempHandle);
+ hr = IDirect3DDevice8_GetVertexShader(device, &hTempHandle);
ok(hr == D3D_OK, "IDirect3DDevice8_GetVertexShader returned %#08x\n", hr);
ok(hTempHandle == hVertexShader, "Vertex Shader %d is set, expected shader %d\n", hTempHandle, hVertexShader);
/* Verify that we can retrieve the declaration */
- hr = IDirect3DDevice8_GetVertexShaderDeclaration(pDevice, hVertexShader, NULL, &data_size);
+ hr = IDirect3DDevice8_GetVertexShaderDeclaration(device, hVertexShader, NULL, &data_size);
ok(hr == D3D_OK, "IDirect3DDevice8_GetVertexShaderDeclaration returned %#08x\n", hr);
ok(data_size == vertex_decl_size, "Got data_size %u, expected %u\n", data_size, vertex_decl_size);
data = HeapAlloc(GetProcessHeap(), 0, vertex_decl_size);
data_size = 1;
- hr = IDirect3DDevice8_GetVertexShaderDeclaration(pDevice, hVertexShader, data, &data_size);
+ hr = IDirect3DDevice8_GetVertexShaderDeclaration(device, hVertexShader, data, &data_size);
ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_GetVertexShaderDeclaration returned (%#08x), "
"expected D3DERR_INVALIDCALL\n", hr);
ok(data_size == 1, "Got data_size %u, expected 1\n", data_size);
data_size = vertex_decl_size;
- hr = IDirect3DDevice8_GetVertexShaderDeclaration(pDevice, hVertexShader, data, &data_size);
+ hr = IDirect3DDevice8_GetVertexShaderDeclaration(device, hVertexShader, data, &data_size);
ok(hr == D3D_OK, "IDirect3DDevice8_GetVertexShaderDeclaration returned %#08x\n", hr);
ok(data_size == vertex_decl_size, "Got data_size %u, expected %u\n", data_size, vertex_decl_size);
ok(!memcmp(data, dwVertexDecl, vertex_decl_size), "data not equal to shader declaration\n");
HeapFree(GetProcessHeap(), 0, data);
/* Verify that we can retrieve the shader function */
- hr = IDirect3DDevice8_GetVertexShaderFunction(pDevice, hVertexShader, NULL, &data_size);
+ hr = IDirect3DDevice8_GetVertexShaderFunction(device, hVertexShader, NULL, &data_size);
ok(hr == D3D_OK, "IDirect3DDevice8_GetVertexShaderFunction returned %#08x\n", hr);
ok(data_size == simple_vs_size, "Got data_size %u, expected %u\n", data_size, simple_vs_size);
data = HeapAlloc(GetProcessHeap(), 0, simple_vs_size);
data_size = 1;
- hr = IDirect3DDevice8_GetVertexShaderFunction(pDevice, hVertexShader, data, &data_size);
+ hr = IDirect3DDevice8_GetVertexShaderFunction(device, hVertexShader, data, &data_size);
ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_GetVertexShaderFunction returned (%#08x), "
"expected D3DERR_INVALIDCALL\n", hr);
ok(data_size == 1, "Got data_size %u, expected 1\n", data_size);
data_size = simple_vs_size;
- hr = IDirect3DDevice8_GetVertexShaderFunction(pDevice, hVertexShader, data, &data_size);
+ hr = IDirect3DDevice8_GetVertexShaderFunction(device, hVertexShader, data, &data_size);
ok(hr == D3D_OK, "IDirect3DDevice8_GetVertexShaderFunction returned %#08x\n", hr);
ok(data_size == simple_vs_size, "Got data_size %u, expected %u\n", data_size, simple_vs_size);
ok(!memcmp(data, simple_vs, simple_vs_size), "data not equal to shader function\n");
HeapFree(GetProcessHeap(), 0, data);
/* Delete the assigned shader. This is supposed to work */
- hr = IDirect3DDevice8_DeleteVertexShader(pDevice, hVertexShader);
+ hr = IDirect3DDevice8_DeleteVertexShader(device, hVertexShader);
ok(hr == D3D_OK, "IDirect3DDevice8_DeleteVertexShader returned %#08x\n", hr);
/* The shader should be unset now */
- hr = IDirect3DDevice8_GetVertexShader(pDevice, &hTempHandle);
+ hr = IDirect3DDevice8_GetVertexShader(device, &hTempHandle);
ok(hr == D3D_OK, "IDirect3DDevice8_GetVertexShader returned %#08x\n", hr);
ok(hTempHandle == 0, "Vertex Shader %d is set, expected shader %d\n", hTempHandle, 0);
/* Test a broken declaration. 3DMark2001 tries to use normals with 2 components
* First try the fixed function shader function, then a custom one
*/
- hr = IDirect3DDevice8_CreateVertexShader(pDevice, decl_normal_float2, 0, &hVertexShader, 0);
+ hr = IDirect3DDevice8_CreateVertexShader(device, decl_normal_float2, 0, &hVertexShader, 0);
ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_CreateVertexShader returned %#08x\n", hr);
- if(SUCCEEDED(hr)) IDirect3DDevice8_DeleteVertexShader(pDevice, hVertexShader);
- hr = IDirect3DDevice8_CreateVertexShader(pDevice, decl_normal_float4, 0, &hVertexShader, 0);
+ hr = IDirect3DDevice8_CreateVertexShader(device, decl_normal_float4, 0, &hVertexShader, 0);
ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_CreateVertexShader returned %#08x\n", hr);
- if(SUCCEEDED(hr)) IDirect3DDevice8_DeleteVertexShader(pDevice, hVertexShader);
- hr = IDirect3DDevice8_CreateVertexShader(pDevice, decl_normal_d3dcolor, 0, &hVertexShader, 0);
+ hr = IDirect3DDevice8_CreateVertexShader(device, decl_normal_d3dcolor, 0, &hVertexShader, 0);
ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_CreateVertexShader returned %#08x\n", hr);
- if(SUCCEEDED(hr)) IDirect3DDevice8_DeleteVertexShader(pDevice, hVertexShader);
- hr = IDirect3DDevice8_CreateVertexShader(pDevice, decl_normal_float2, simple_vs, &hVertexShader, 0);
+ hr = IDirect3DDevice8_CreateVertexShader(device, decl_normal_float2, simple_vs, &hVertexShader, 0);
ok(hr == D3D_OK, "IDirect3DDevice8_CreateVertexShader returned %#08x\n", hr);
- if(SUCCEEDED(hr)) IDirect3DDevice8_DeleteVertexShader(pDevice, hVertexShader);
+ IDirect3DDevice8_DeleteVertexShader(device, hVertexShader);
if (caps.PixelShaderVersion >= D3DPS_VERSION(1, 0))
{
/* The same with a pixel shader */
- hr = IDirect3DDevice8_CreatePixelShader(pDevice, simple_ps, &hPixelShader);
+ hr = IDirect3DDevice8_CreatePixelShader(device, simple_ps, &hPixelShader);
ok(hr == D3D_OK, "IDirect3DDevice8_CreatePixelShader returned %#08x\n", hr);
/* Msdn says that the new pixel shader is set immediately. This is wrong, apparently */
- hr = IDirect3DDevice8_GetPixelShader(pDevice, &hTempHandle);
+ hr = IDirect3DDevice8_GetPixelShader(device, &hTempHandle);
ok(hr == D3D_OK, "IDirect3DDevice8_GetPixelShader returned %#08x\n", hr);
ok(hTempHandle == 0, "Pixel Shader %d is set, expected shader %d\n", hTempHandle, 0);
/* Assign the shader, then verify that GetPixelShader works */
- hr = IDirect3DDevice8_SetPixelShader(pDevice, hPixelShader);
+ hr = IDirect3DDevice8_SetPixelShader(device, hPixelShader);
ok(hr == D3D_OK, "IDirect3DDevice8_SetPixelShader returned %#08x\n", hr);
- hr = IDirect3DDevice8_GetPixelShader(pDevice, &hTempHandle);
+ hr = IDirect3DDevice8_GetPixelShader(device, &hTempHandle);
ok(hr == D3D_OK, "IDirect3DDevice8_GetPixelShader returned %#08x\n", hr);
ok(hTempHandle == hPixelShader, "Pixel Shader %d is set, expected shader %d\n", hTempHandle, hPixelShader);
/* Verify that we can retrieve the shader function */
- hr = IDirect3DDevice8_GetPixelShaderFunction(pDevice, hPixelShader, NULL, &data_size);
+ hr = IDirect3DDevice8_GetPixelShaderFunction(device, hPixelShader, NULL, &data_size);
ok(hr == D3D_OK, "IDirect3DDevice8_GetPixelShaderFunction returned %#08x\n", hr);
ok(data_size == simple_ps_size, "Got data_size %u, expected %u\n", data_size, simple_ps_size);
data = HeapAlloc(GetProcessHeap(), 0, simple_ps_size);
data_size = 1;
- hr = IDirect3DDevice8_GetPixelShaderFunction(pDevice, hPixelShader, data, &data_size);
+ hr = IDirect3DDevice8_GetPixelShaderFunction(device, hPixelShader, data, &data_size);
ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_GetPixelShaderFunction returned (%#08x), "
"expected D3DERR_INVALIDCALL\n", hr);
ok(data_size == 1, "Got data_size %u, expected 1\n", data_size);
data_size = simple_ps_size;
- hr = IDirect3DDevice8_GetPixelShaderFunction(pDevice, hPixelShader, data, &data_size);
+ hr = IDirect3DDevice8_GetPixelShaderFunction(device, hPixelShader, data, &data_size);
ok(hr == D3D_OK, "IDirect3DDevice8_GetPixelShaderFunction returned %#08x\n", hr);
ok(data_size == simple_ps_size, "Got data_size %u, expected %u\n", data_size, simple_ps_size);
ok(!memcmp(data, simple_ps, simple_ps_size), "data not equal to shader function\n");
HeapFree(GetProcessHeap(), 0, data);
/* Delete the assigned shader. This is supposed to work */
- hr = IDirect3DDevice8_DeletePixelShader(pDevice, hPixelShader);
+ hr = IDirect3DDevice8_DeletePixelShader(device, hPixelShader);
ok(hr == D3D_OK, "IDirect3DDevice8_DeletePixelShader returned %#08x\n", hr);
/* The shader should be unset now */
- hr = IDirect3DDevice8_GetPixelShader(pDevice, &hTempHandle);
+ hr = IDirect3DDevice8_GetPixelShader(device, &hTempHandle);
ok(hr == D3D_OK, "IDirect3DDevice8_GetPixelShader returned %#08x\n", hr);
ok(hTempHandle == 0, "Pixel Shader %d is set, expected shader %d\n", hTempHandle, 0);
/* What happens if a non-bound shader is deleted? */
- hr = IDirect3DDevice8_CreatePixelShader(pDevice, simple_ps, &hPixelShader);
+ hr = IDirect3DDevice8_CreatePixelShader(device, simple_ps, &hPixelShader);
ok(hr == D3D_OK, "IDirect3DDevice8_CreatePixelShader returned %#08x\n", hr);
- hr = IDirect3DDevice8_CreatePixelShader(pDevice, simple_ps, &hPixelShader2);
+ hr = IDirect3DDevice8_CreatePixelShader(device, simple_ps, &hPixelShader2);
ok(hr == D3D_OK, "IDirect3DDevice8_CreatePixelShader returned %#08x\n", hr);
- hr = IDirect3DDevice8_SetPixelShader(pDevice, hPixelShader);
+ hr = IDirect3DDevice8_SetPixelShader(device, hPixelShader);
ok(hr == D3D_OK, "IDirect3DDevice8_SetPixelShader returned %#08x\n", hr);
- hr = IDirect3DDevice8_DeletePixelShader(pDevice, hPixelShader2);
+ hr = IDirect3DDevice8_DeletePixelShader(device, hPixelShader2);
ok(hr == D3D_OK, "IDirect3DDevice8_DeletePixelShader returned %#08x\n", hr);
- hr = IDirect3DDevice8_GetPixelShader(pDevice, &hTempHandle);
+ hr = IDirect3DDevice8_GetPixelShader(device, &hTempHandle);
ok(hr == D3D_OK, "IDirect3DDevice8_GetPixelShader returned %#08x\n", hr);
ok(hTempHandle == hPixelShader, "Pixel Shader %d is set, expected shader %d\n", hTempHandle, hPixelShader);
- hr = IDirect3DDevice8_DeletePixelShader(pDevice, hPixelShader);
+ hr = IDirect3DDevice8_DeletePixelShader(device, hPixelShader);
ok(hr == D3D_OK, "IDirect3DDevice8_DeletePixelShader returned %#08x\n", hr);
/* Check for double delete. */
- hr = IDirect3DDevice8_DeletePixelShader(pDevice, hPixelShader2);
+ hr = IDirect3DDevice8_DeletePixelShader(device, hPixelShader2);
ok(hr == D3DERR_INVALIDCALL || broken(hr == D3D_OK), "IDirect3DDevice8_DeletePixelShader returned %#08x\n", hr);
- hr = IDirect3DDevice8_DeletePixelShader(pDevice, hPixelShader);
+ hr = IDirect3DDevice8_DeletePixelShader(device, hPixelShader);
ok(hr == D3DERR_INVALIDCALL || broken(hr == D3D_OK), "IDirect3DDevice8_DeletePixelShader returned %#08x\n", hr);
}
else
@@ -1852,138 +1775,100 @@ static void test_shader(void)
}
/* What happens if a non-bound shader is deleted? */
- hr = IDirect3DDevice8_CreateVertexShader(pDevice, dwVertexDecl, NULL, &hVertexShader, 0);
+ hr = IDirect3DDevice8_CreateVertexShader(device, dwVertexDecl, NULL, &hVertexShader, 0);
ok(hr == D3D_OK, "IDirect3DDevice8_CreateVertexShader returned %#08x\n", hr);
- hr = IDirect3DDevice8_CreateVertexShader(pDevice, dwVertexDecl, NULL, &hVertexShader2, 0);
+ hr = IDirect3DDevice8_CreateVertexShader(device, dwVertexDecl, NULL, &hVertexShader2, 0);
ok(hr == D3D_OK, "IDirect3DDevice8_CreateVertexShader returned %#08x\n", hr);
- hr = IDirect3DDevice8_SetVertexShader(pDevice, hVertexShader);
+ hr = IDirect3DDevice8_SetVertexShader(device, hVertexShader);
ok(hr == D3D_OK, "IDirect3DDevice8_SetVertexShader returned %#08x\n", hr);
- hr = IDirect3DDevice8_DeleteVertexShader(pDevice, hVertexShader2);
+ hr = IDirect3DDevice8_DeleteVertexShader(device, hVertexShader2);
ok(hr == D3D_OK, "IDirect3DDevice8_DeleteVertexShader returned %#08x\n", hr);
- hr = IDirect3DDevice8_GetVertexShader(pDevice, &hTempHandle);
+ hr = IDirect3DDevice8_GetVertexShader(device, &hTempHandle);
ok(hr == D3D_OK, "IDirect3DDevice8_GetVertexShader returned %#08x\n", hr);
ok(hTempHandle == hVertexShader, "Vertex Shader %d is set, expected shader %d\n", hTempHandle, hVertexShader);
- hr = IDirect3DDevice8_DeleteVertexShader(pDevice, hVertexShader);
+ hr = IDirect3DDevice8_DeleteVertexShader(device, hVertexShader);
ok(hr == D3D_OK, "IDirect3DDevice8_DeleteVertexShader returned %#08x\n", hr);
/* Check for double delete. */
- hr = IDirect3DDevice8_DeleteVertexShader(pDevice, hVertexShader2);
+ hr = IDirect3DDevice8_DeleteVertexShader(device, hVertexShader2);
ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_DeleteVertexShader returned %#08x\n", hr);
- hr = IDirect3DDevice8_DeleteVertexShader(pDevice, hVertexShader);
+ hr = IDirect3DDevice8_DeleteVertexShader(device, hVertexShader);
ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_DeleteVertexShader returned %#08x\n", hr);
+ refcount = IDirect3DDevice8_Release(device);
+ ok(!refcount, "Device has %u references left.\n", refcount);
cleanup:
- if (pDevice)
- {
- UINT refcount = IDirect3DDevice8_Release(pDevice);
- ok(!refcount, "Device has %u references left.\n", refcount);
- }
IDirect3D8_Release(d3d);
- DestroyWindow(hwnd);
+ DestroyWindow(window);
}
static void test_limits(void)
{
- HRESULT hr;
- IDirect3DDevice8 *pDevice = NULL;
- D3DPRESENT_PARAMETERS d3dpp;
- D3DDISPLAYMODE d3ddm;
- IDirect3DTexture8 *pTexture = NULL;
+ IDirect3DTexture8 *texture;
+ IDirect3DDevice8 *device;
IDirect3D8 *d3d;
- HWND hwnd;
- int i;
+ unsigned int i;
+ ULONG refcount;
+ HWND window;
+ HRESULT hr;
- hwnd = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
- 100, 100, 160, 160, NULL, NULL, NULL, NULL);
- ok(!!hwnd, "Failed to create a window.\n");
+ window = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
+ 0, 0, 640, 480, NULL, NULL, NULL, NULL);
+ ok(!!window, "Failed to create a window.\n");
d3d = Direct3DCreate8(D3D_SDK_VERSION);
ok(!!d3d, "Failed to create a D3D object.\n");
-
- IDirect3D8_GetAdapterDisplayMode(d3d, D3DADAPTER_DEFAULT, &d3ddm);
- ZeroMemory( &d3dpp, sizeof(d3dpp) );
- d3dpp.Windowed = TRUE;
- d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
- d3dpp.BackBufferWidth = 800;
- d3dpp.BackBufferHeight = 600;
- d3dpp.BackBufferFormat = d3ddm.Format;
- d3dpp.EnableAutoDepthStencil = TRUE;
- d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
-
- hr = IDirect3D8_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL /* no NULLREF here */,
- hwnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice);
- ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL || broken(hr == D3DERR_NOTAVAILABLE), "IDirect3D8_CreateDevice failed with %#08x\n", hr);
- if(!pDevice)
+ if (!(device = create_device(d3d, window, window, TRUE)))
{
- skip("could not create device, IDirect3D8_CreateDevice returned %#08x\n", hr);
+ skip("Failed to create a 3D device, skipping test.\n");
goto cleanup;
}
- hr = IDirect3DDevice8_CreateTexture(pDevice, 16, 16, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &pTexture);
+ hr = IDirect3DDevice8_CreateTexture(device, 16, 16, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &texture);
ok(hr == D3D_OK, "IDirect3DDevice8_CreateTexture failed with %#08x\n", hr);
- if(!pTexture) goto cleanup;
/* There are 8 texture stages. We should be able to access all of them */
- for(i = 0; i < 8; i++) {
- hr = IDirect3DDevice8_SetTexture(pDevice, i, (IDirect3DBaseTexture8 *) pTexture);
+ for (i = 0; i < 8; ++i)
+ {
+ hr = IDirect3DDevice8_SetTexture(device, i, (IDirect3DBaseTexture8 *)texture);
ok(hr == D3D_OK, "IDirect3DDevice8_SetTexture for sampler %d failed with %#08x\n", i, hr);
- hr = IDirect3DDevice8_SetTexture(pDevice, i, NULL);
+ hr = IDirect3DDevice8_SetTexture(device, i, NULL);
ok(hr == D3D_OK, "IDirect3DDevice8_SetTexture for sampler %d failed with %#08x\n", i, hr);
- hr = IDirect3DDevice8_SetTextureStageState(pDevice, i, D3DTSS_COLOROP, D3DTOP_ADD);
+ hr = IDirect3DDevice8_SetTextureStageState(device, i, D3DTSS_COLOROP, D3DTOP_ADD);
ok(hr == D3D_OK, "IDirect3DDevice8_SetTextureStageState for texture %d failed with %#08x\n", i, hr);
}
- /* Investigations show that accessing higher textures stage states does not return an error either. Writing
- * to too high texture stages(approximately texture 40) causes memory corruption in windows, so there is no
- * bounds checking but how do I test that?
- */
-
+ /* Investigations show that accessing higher textures stage states does
+ * not return an error either. Writing to too high texture stages
+ * (approximately texture 40) causes memory corruption in windows, so
+ * there is no bounds checking. */
+ IDirect3DTexture8_Release(texture);
+ refcount = IDirect3DDevice8_Release(device);
+ ok(!refcount, "Device has %u references left.\n", refcount);
cleanup:
- if(pTexture) IDirect3DTexture8_Release(pTexture);
- if (pDevice)
- {
- UINT refcount = IDirect3DDevice8_Release(pDevice);
- ok(!refcount, "Device has %u references left.\n", refcount);
- }
IDirect3D8_Release(d3d);
- DestroyWindow(hwnd);
+ DestroyWindow(window);
}
static void test_lights(void)
{
- D3DPRESENT_PARAMETERS d3dpp;
- IDirect3DDevice8 *device = NULL;
+ IDirect3DDevice8 *device;
IDirect3D8 *d3d8;
- HWND hwnd;
+ ULONG refcount;
+ HWND window;
HRESULT hr;
unsigned int i;
BOOL enabled;
D3DCAPS8 caps;
- D3DDISPLAYMODE d3ddm;
- hwnd = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
- 100, 100, 160, 160, NULL, NULL, NULL, NULL);
- ok(!!hwnd, "Failed to create a window.\n");
+ window = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
+ 0, 0, 640, 480, NULL, NULL, NULL, NULL);
+ ok(!!window, "Failed to create a window.\n");
d3d8 = Direct3DCreate8(D3D_SDK_VERSION);
ok(!!d3d8, "Failed to create a D3D object.\n");
-
- IDirect3D8_GetAdapterDisplayMode( d3d8, D3DADAPTER_DEFAULT, &d3ddm );
- ZeroMemory( &d3dpp, sizeof(d3dpp) );
- d3dpp.Windowed = TRUE;
- d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
- d3dpp.BackBufferWidth = 800;
- d3dpp.BackBufferHeight = 600;
- d3dpp.BackBufferFormat = d3ddm.Format;
- d3dpp.EnableAutoDepthStencil = TRUE;
- d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
-
- hr = IDirect3D8_CreateDevice( d3d8, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL /* no NULLREF here */, hwnd,
- D3DCREATE_HARDWARE_VERTEXPROCESSING, &d3dpp, &device );
- ok(hr == D3D_OK || hr == D3DERR_NOTAVAILABLE || hr == D3DERR_INVALIDCALL,
- "IDirect3D8_CreateDevice failed with %08x\n", hr);
- if(!device)
+ if (!(device = create_device(d3d8, window, window, TRUE)))
{
- skip("Failed to create a d3d device\n");
+ skip("Failed to create a 3D device, skipping test.\n");
goto cleanup;
}
@@ -2014,24 +1899,20 @@ static void test_lights(void)
ok(hr == D3D_OK, "Disabling light %u failed with %08x\n", i, hr);
}
+ refcount = IDirect3DDevice8_Release(device);
+ ok(!refcount, "Device has %u references left.\n", refcount);
cleanup:
- if (device)
- {
- UINT refcount = IDirect3DDevice8_Release(device);
- ok(!refcount, "Device has %u references left.\n", refcount);
- }
IDirect3D8_Release(d3d8);
- DestroyWindow(hwnd);
+ DestroyWindow(window);
}
static void test_render_zero_triangles(void)
{
- D3DPRESENT_PARAMETERS d3dpp;
- IDirect3DDevice8 *device = NULL;
+ IDirect3DDevice8 *device;
IDirect3D8 *d3d8;
- HWND hwnd;
+ ULONG refcount;
+ HWND window;
HRESULT hr;
- D3DDISPLAYMODE d3ddm;
struct nvertex
{
@@ -2046,29 +1927,14 @@ static void test_render_zero_triangles(void)
{ 1.0f, -1.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xff0000ff},
};
- hwnd = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
- 100, 100, 160, 160, NULL, NULL, NULL, NULL);
- ok(!!hwnd, "Failed to create a window.\n");
+ window = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
+ 0, 0, 640, 480, NULL, NULL, NULL, NULL);
+ ok(!!window, "Failed to create a window.\n");
d3d8 = Direct3DCreate8(D3D_SDK_VERSION);
ok(!!d3d8, "Failed to create a D3D object.\n");
-
- IDirect3D8_GetAdapterDisplayMode( d3d8, D3DADAPTER_DEFAULT, &d3ddm );
- ZeroMemory( &d3dpp, sizeof(d3dpp) );
- d3dpp.Windowed = TRUE;
- d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
- d3dpp.BackBufferWidth = 800;
- d3dpp.BackBufferHeight = 600;
- d3dpp.BackBufferFormat = d3ddm.Format;
- d3dpp.EnableAutoDepthStencil = TRUE;
- d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
-
- hr = IDirect3D8_CreateDevice( d3d8, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL /* no NULLREF here */, hwnd,
- D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE, &d3dpp, &device );
- ok(hr == D3D_OK || hr == D3DERR_NOTAVAILABLE || hr == D3DERR_INVALIDCALL,
- "IDirect3D8_CreateDevice failed with %08x\n", hr);
- if(!device)
+ if (!(device = create_device(d3d8, window, window, TRUE)))
{
- skip("Failed to create a d3d device\n");
+ skip("Failed to create a 3D device, skipping test.\n");
goto cleanup;
}
@@ -2089,14 +1955,11 @@ static void test_render_zero_triangles(void)
IDirect3DDevice8_Present(device, NULL, NULL, NULL, NULL);
+ refcount = IDirect3DDevice8_Release(device);
+ ok(!refcount, "Device has %u references left.\n", refcount);
cleanup:
- if (device)
- {
- UINT refcount = IDirect3DDevice8_Release(device);
- ok(!refcount, "Device has %u references left.\n", refcount);
- }
IDirect3D8_Release(d3d8);
- DestroyWindow(hwnd);
+ DestroyWindow(window);
}
static void test_depth_stencil_reset(void)
@@ -2752,37 +2615,20 @@ done:
static void test_ApplyStateBlock(void)
{
- D3DPRESENT_PARAMETERS d3dpp;
- IDirect3DDevice8 *device = NULL;
+ IDirect3DDevice8 *device;
IDirect3D8 *d3d8;
- HWND hwnd;
+ HWND window;
HRESULT hr;
- D3DDISPLAYMODE d3ddm;
DWORD received, token;
- hwnd = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
- 100, 100, 160, 160, NULL, NULL, NULL, NULL);
- ok(!!hwnd, "Failed to create a window.\n");
+ window = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
+ 0, 0, 640, 480, NULL, NULL, NULL, NULL);
+ ok(!!window, "Failed to create a window.\n");
d3d8 = Direct3DCreate8(D3D_SDK_VERSION);
ok(!!d3d8, "Failed to create a D3D object.\n");
-
- IDirect3D8_GetAdapterDisplayMode( d3d8, D3DADAPTER_DEFAULT, &d3ddm );
- ZeroMemory( &d3dpp, sizeof(d3dpp) );
- d3dpp.Windowed = TRUE;
- d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
- d3dpp.BackBufferWidth = 800;
- d3dpp.BackBufferHeight = 600;
- d3dpp.BackBufferFormat = d3ddm.Format;
- d3dpp.EnableAutoDepthStencil = TRUE;
- d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
-
- hr = IDirect3D8_CreateDevice( d3d8, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
- D3DCREATE_HARDWARE_VERTEXPROCESSING, &d3dpp, &device );
- ok(hr == D3D_OK || hr == D3DERR_NOTAVAILABLE || hr == D3DERR_INVALIDCALL,
- "IDirect3D8_CreateDevice failed with %#x\n", hr);
- if(!device)
+ if (!(device = create_device(d3d8, window, window, TRUE)))
{
- skip("Failed to create a d3d device\n");
+ skip("Failed to create a 3D device, skipping test.\n");
goto cleanup;
}
@@ -2812,7 +2658,7 @@ static void test_ApplyStateBlock(void)
IDirect3DDevice8_Release(device);
cleanup:
IDirect3D8_Release(d3d8);
- DestroyWindow(hwnd);
+ DestroyWindow(window);
}
static void test_depth_stencil_size(void)
@@ -2971,13 +2817,12 @@ done:
static void test_wrong_shader(void)
{
- HRESULT hr;
- IDirect3DDevice8 *device = NULL;
- D3DPRESENT_PARAMETERS d3dpp;
- D3DDISPLAYMODE d3ddm;
+ IDirect3DDevice8 *device;
IDirect3D8 *d3d;
+ ULONG refcount;
DWORD vs, ps;
- HWND hwnd;
+ HWND window;
+ HRESULT hr;
static const DWORD vs_2_0[] =
{
@@ -3004,27 +2849,17 @@ static void test_wrong_shader(void)
D3DVSD_END()
};
- hwnd = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
- 100, 100, 160, 160, NULL, NULL, NULL, NULL);
- ok(!!hwnd, "Failed to create a window.\n");
+ window = CreateWindowA("d3d8_test_wc", "d3d8_test", WS_OVERLAPPEDWINDOW,
+ 0, 0, 640, 480, NULL, NULL, NULL, NULL);
+ ok(!!window, "Failed to create a window.\n");
d3d = Direct3DCreate8(D3D_SDK_VERSION);
ok(!!d3d, "Failed to create a D3D object.\n");
-
- IDirect3D8_GetAdapterDisplayMode(d3d, D3DADAPTER_DEFAULT, &d3ddm);
- ZeroMemory(&d3dpp, sizeof(d3dpp));
- d3dpp.Windowed = TRUE;
- d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
- d3dpp.BackBufferWidth = 800;
- d3dpp.BackBufferHeight = 600;
- d3dpp.BackBufferFormat = d3ddm.Format;
-
- hr = IDirect3D8_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
- D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &device);
- ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL || broken(hr == D3DERR_NOTAVAILABLE), "IDirect3D8_CreateDevice failed with %#08x\n", hr);
- if (!device)
+ if (!(device = create_device(d3d, window, window, TRUE)))
{
- skip("could not create device, IDirect3D8_CreateDevice returned %#08x\n", hr);
- goto cleanup;
+ skip("Failed to create a D3D device, skipping tests.\n");
+ IDirect3D8_Release(d3d);
+ DestroyWindow(window);
+ return;
}
hr = IDirect3DDevice8_CreateVertexShader(device, decl, simple_ps, &vs, 0);
@@ -3039,14 +2874,10 @@ static void test_wrong_shader(void)
hr = IDirect3DDevice8_CreatePixelShader(device, ps_2_0, &ps);
ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice8_CreatePixelShader returned %#08x\n", hr);
-cleanup:
- if (device)
- {
- UINT refcount = IDirect3DDevice8_Release(device);
- ok(!refcount, "Device has %u references left.\n", refcount);
- }
+ refcount = IDirect3DDevice8_Release(device);
+ ok(!refcount, "Device has %u references left.\n", refcount);
IDirect3D8_Release(d3d);
- DestroyWindow(hwnd);
+ DestroyWindow(window);
}
static void test_mode_change(void)
--
1.7.10.4
More information about the wine-patches
mailing list