1713 lines
50 KiB
C
1713 lines
50 KiB
C
/* DirectDraw IDirectDraw interface (generic)
|
|
*
|
|
* Copyright 1997-2000 Marcus Meissner
|
|
* Copyright 1998-2000 Lionel Ulmer (most of Direct3D stuff)
|
|
* Copyright 2000-2001 TransGaming Technologies Inc.
|
|
*
|
|
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
* NOTES
|
|
*
|
|
* WINE currently implements a very basic set of the DirectDraw functionality
|
|
* in graphics/ddraw.c. This implementation uses either the XFree86-DGA extension
|
|
* to get very fast access to the graphics card framebuffer and doublebuffering
|
|
* features or Xlib, which is slower.
|
|
* The implementation using XFree86-DGA is as fast as the MS equivalent for the
|
|
* stuff that is implemented.
|
|
*
|
|
* Several applications already work, see below.
|
|
* Problems of the implementation using XFree86-DGA:
|
|
*
|
|
* - XFree86 cannot switch depth on the fly.
|
|
* This is a problem with X and unavoidable.
|
|
* Current solution is to pop up a MessageBox with an error for
|
|
* mismatched parameters and advice the user to restart the X server
|
|
* with the specified depth.
|
|
* - The rest of the functionality that has to be implemented will have
|
|
* to be done in software and will be very slow.
|
|
* - This requires WINE to be run as root user so XF86DGA can mmap the
|
|
* framebuffer into the addressspace of the process.
|
|
* - Blocks all other X windowed applications.
|
|
*
|
|
* This file contains all the interface functions that are shared between
|
|
* all interfaces. Or better, it is a "common stub" library for the
|
|
* IDirectDraw* objects
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include "wine/port.h"
|
|
|
|
#include <assert.h>
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
|
|
#define NONAMELESSUNION
|
|
#define NONAMELESSSTRUCT
|
|
#include "winerror.h"
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "wingdi.h"
|
|
#include "ddraw.h"
|
|
#include "d3d.h"
|
|
#include "wine/debug.h"
|
|
|
|
#include "ddraw_private.h"
|
|
#include "mesa_private.h" /* To have the D3D creation function */
|
|
#include "ddraw/main.h"
|
|
#include "dclipper/main.h"
|
|
#include "dpalette/main.h"
|
|
#include "dsurface/main.h"
|
|
#include "dsurface/dib.h"
|
|
#include "dsurface/fakezbuffer.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
|
|
|
|
extern IDirectDrawVtbl DDRAW_IDirectDraw_VTable;
|
|
extern IDirectDraw2Vtbl DDRAW_IDirectDraw2_VTable;
|
|
extern IDirectDraw4Vtbl DDRAW_IDirectDraw4_VTable;
|
|
|
|
static void DDRAW_UnsubclassWindow(IDirectDrawImpl* This);
|
|
|
|
static void Main_DirectDraw_DeleteSurfaces(IDirectDrawImpl* This);
|
|
static void Main_DirectDraw_DeleteClippers(IDirectDrawImpl* This);
|
|
static void Main_DirectDraw_DeletePalettes(IDirectDrawImpl* This);
|
|
static void LosePrimarySurface(IDirectDrawImpl* This);
|
|
|
|
static INT32 allocate_memory(IDirectDrawImpl *This, DWORD mem) ;
|
|
static void free_memory(IDirectDrawImpl *This, DWORD mem) ;
|
|
|
|
|
|
static const char ddProp[] = "WINE_DDRAW_Property";
|
|
|
|
/* Not called from the vtable. */
|
|
HRESULT Main_DirectDraw_Construct(IDirectDrawImpl *This, BOOL ex)
|
|
{
|
|
/* NOTE: The creator must use HEAP_ZERO_MEMORY or equivalent. */
|
|
This->ref = 1;
|
|
This->ex = ex;
|
|
|
|
if (ex) This->local.dwLocalFlags |= DDRAWILCL_DIRECTDRAW7;
|
|
This->local.dwProcessId = GetCurrentProcessId();
|
|
|
|
This->final_release = Main_DirectDraw_final_release;
|
|
|
|
This->create_palette = Main_DirectDrawPalette_Create;
|
|
|
|
This->create_offscreen = Main_create_offscreen;
|
|
This->create_texture = Main_create_texture;
|
|
This->create_zbuffer = Main_create_zbuffer;
|
|
/* There are no generic versions of create_{primary,backbuffer}. */
|
|
|
|
ICOM_INIT_INTERFACE(This, IDirectDraw, DDRAW_IDirectDraw_VTable);
|
|
ICOM_INIT_INTERFACE(This, IDirectDraw2, DDRAW_IDirectDraw2_VTable);
|
|
ICOM_INIT_INTERFACE(This, IDirectDraw4, DDRAW_IDirectDraw4_VTable);
|
|
/* There is no generic implementation of IDD7 */
|
|
|
|
/* This is for the moment here... */
|
|
This->free_memory = free_memory;
|
|
This->allocate_memory = allocate_memory;
|
|
This->total_vidmem = 64 * 1024 * 1024;
|
|
This->available_vidmem = This->total_vidmem;
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
void Main_DirectDraw_final_release(IDirectDrawImpl* This)
|
|
{
|
|
if (IsWindow(This->window))
|
|
{
|
|
if (GetPropA(This->window, ddProp))
|
|
DDRAW_UnsubclassWindow(This);
|
|
else
|
|
FIXME("this shouldn't happen, right?\n");
|
|
}
|
|
|
|
Main_DirectDraw_DeleteSurfaces(This);
|
|
Main_DirectDraw_DeleteClippers(This);
|
|
Main_DirectDraw_DeletePalettes(This);
|
|
if (This->local.lpGbl && This->local.lpGbl->lpExclusiveOwner == &This->local)
|
|
{
|
|
This->local.lpGbl->lpExclusiveOwner = NULL;
|
|
if (This->set_exclusive_mode)
|
|
This->set_exclusive_mode(This, FALSE);
|
|
}
|
|
}
|
|
|
|
/* There is no Main_DirectDraw_Create. */
|
|
|
|
ULONG WINAPI Main_DirectDraw_AddRef(LPDIRECTDRAW7 iface) {
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
ULONG ref = InterlockedIncrement(&This->ref);
|
|
|
|
TRACE("(%p)->() incrementing from %lu.\n", This, ref -1);
|
|
|
|
return ref;
|
|
}
|
|
|
|
ULONG WINAPI Main_DirectDraw_Release(LPDIRECTDRAW7 iface) {
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
ULONG ref = InterlockedDecrement(&This->ref);
|
|
|
|
TRACE("(%p)->() decrementing from %lu.\n", This, ref +1);
|
|
|
|
if (ref == 0)
|
|
{
|
|
if (This->final_release != NULL)
|
|
This->final_release(This);
|
|
|
|
/* We free the private. This is an artifact of the fact that I don't
|
|
* have the destructors set up correctly. */
|
|
if (This->private != (This+1))
|
|
HeapFree(GetProcessHeap(), 0, This->private);
|
|
|
|
HeapFree(GetProcessHeap(), 0, This);
|
|
}
|
|
|
|
return ref;
|
|
}
|
|
|
|
HRESULT WINAPI Main_DirectDraw_QueryInterface(
|
|
LPDIRECTDRAW7 iface,REFIID refiid,LPVOID *obj
|
|
) {
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(refiid), obj);
|
|
|
|
/* According to COM docs, if the QueryInterface fails, obj should be set to NULL */
|
|
*obj = NULL;
|
|
|
|
if ( IsEqualGUID( &IID_IUnknown, refiid )
|
|
|| IsEqualGUID( &IID_IDirectDraw7, refiid ) )
|
|
{
|
|
*obj = ICOM_INTERFACE(This, IDirectDraw7);
|
|
}
|
|
else if ( IsEqualGUID( &IID_IDirectDraw, refiid ) )
|
|
{
|
|
*obj = ICOM_INTERFACE(This, IDirectDraw);
|
|
}
|
|
else if ( IsEqualGUID( &IID_IDirectDraw2, refiid ) )
|
|
{
|
|
*obj = ICOM_INTERFACE(This, IDirectDraw2);
|
|
}
|
|
else if ( IsEqualGUID( &IID_IDirectDraw4, refiid ) )
|
|
{
|
|
*obj = ICOM_INTERFACE(This, IDirectDraw4);
|
|
}
|
|
#ifdef HAVE_OPENGL
|
|
else if ( IsEqualGUID( &IID_IDirect3D , refiid ) ||
|
|
IsEqualGUID( &IID_IDirect3D2 , refiid ) ||
|
|
IsEqualGUID( &IID_IDirect3D3 , refiid ) ||
|
|
IsEqualGUID( &IID_IDirect3D7 , refiid ) )
|
|
{
|
|
if (opengl_initialized) {
|
|
HRESULT ret_value;
|
|
|
|
ret_value = direct3d_create(This);
|
|
if (FAILED(ret_value)) return ret_value;
|
|
|
|
if ( IsEqualGUID( &IID_IDirect3D , refiid ) ) {
|
|
*obj = ICOM_INTERFACE(This, IDirect3D);
|
|
TRACE(" returning Direct3D interface at %p.\n", *obj);
|
|
} else if ( IsEqualGUID( &IID_IDirect3D2 , refiid ) ) {
|
|
*obj = ICOM_INTERFACE(This, IDirect3D2);
|
|
TRACE(" returning Direct3D2 interface at %p.\n", *obj);
|
|
} else if ( IsEqualGUID( &IID_IDirect3D3 , refiid ) ) {
|
|
*obj = ICOM_INTERFACE(This, IDirect3D3);
|
|
TRACE(" returning Direct3D3 interface at %p.\n", *obj);
|
|
} else {
|
|
*obj = ICOM_INTERFACE(This, IDirect3D7);
|
|
TRACE(" returning Direct3D7 interface at %p.\n", *obj);
|
|
}
|
|
} else {
|
|
ERR("Application requests a Direct3D interface but dynamic OpenGL support loading failed !\n");
|
|
ERR("(%p)->(%s,%p): no interface\n",This,debugstr_guid(refiid),obj);
|
|
return E_NOINTERFACE;
|
|
}
|
|
}
|
|
#else
|
|
else if ( IsEqualGUID( &IID_IDirect3D , refiid ) ||
|
|
IsEqualGUID( &IID_IDirect3D2 , refiid ) ||
|
|
IsEqualGUID( &IID_IDirect3D3 , refiid ) ||
|
|
IsEqualGUID( &IID_IDirect3D7 , refiid ) )
|
|
{
|
|
ERR("Application requests a Direct3D interface but OpenGL support not built-in !\n");
|
|
ERR("(%p)->(%s,%p): no interface\n",This,debugstr_guid(refiid),obj);
|
|
return E_NOINTERFACE;
|
|
}
|
|
#endif
|
|
else
|
|
{
|
|
FIXME("(%p)->(%s,%p): no interface\n",This,debugstr_guid(refiid),obj);
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
IDirectDraw7_AddRef(iface);
|
|
return S_OK;
|
|
}
|
|
|
|
/* MSDN: "not currently implemented". */
|
|
HRESULT WINAPI Main_DirectDraw_Compact(LPDIRECTDRAW7 iface)
|
|
{
|
|
TRACE("(%p)\n", iface);
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI Main_DirectDraw_CreateClipper(LPDIRECTDRAW7 iface,
|
|
DWORD dwFlags,
|
|
LPDIRECTDRAWCLIPPER *ppClipper,
|
|
IUnknown *pUnkOuter)
|
|
{
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
HRESULT hr;
|
|
|
|
TRACE("(%p)->(0x%lx, %p, %p)\n", iface, dwFlags, ppClipper, pUnkOuter);
|
|
|
|
hr = DirectDrawCreateClipper(dwFlags, ppClipper, pUnkOuter);
|
|
if (FAILED(hr)) return hr;
|
|
|
|
/* dwFlags is passed twice, apparently an API wart. */
|
|
hr = IDirectDrawClipper_Initialize(*ppClipper,
|
|
ICOM_INTERFACE(This, IDirectDraw),
|
|
dwFlags);
|
|
if (FAILED(hr))
|
|
{
|
|
IDirectDrawClipper_Release(*ppClipper);
|
|
return hr;
|
|
}
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DirectDraw_CreatePalette(LPDIRECTDRAW7 iface, DWORD dwFlags,
|
|
LPPALETTEENTRY palent,
|
|
LPDIRECTDRAWPALETTE* ppPalette,
|
|
LPUNKNOWN pUnknown)
|
|
{
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
LPDIRECTDRAWPALETTE pPalette;
|
|
HRESULT hr;
|
|
|
|
TRACE("(%p)->(%08lx,%p,%p,%p)\n",This,dwFlags,palent,ppPalette,pUnknown);
|
|
|
|
if (ppPalette == NULL) return E_POINTER; /* unchecked */
|
|
if (pUnknown != NULL) return CLASS_E_NOAGGREGATION; /* unchecked */
|
|
|
|
hr = This->create_palette(This, dwFlags, &pPalette, pUnknown);
|
|
if (FAILED(hr)) return hr;
|
|
|
|
hr = IDirectDrawPalette_SetEntries(pPalette, 0, 0,
|
|
Main_DirectDrawPalette_Size(dwFlags),
|
|
palent);
|
|
if (FAILED(hr))
|
|
{
|
|
IDirectDrawPalette_Release(pPalette);
|
|
return hr;
|
|
}
|
|
else
|
|
{
|
|
*ppPalette = pPalette;
|
|
return DD_OK;
|
|
}
|
|
}
|
|
|
|
HRESULT
|
|
Main_create_offscreen(IDirectDrawImpl* This, const DDSURFACEDESC2* pDDSD,
|
|
LPDIRECTDRAWSURFACE7* ppSurf, LPUNKNOWN pOuter)
|
|
{
|
|
assert(pOuter == NULL);
|
|
|
|
return DIB_DirectDrawSurface_Create(This, pDDSD, ppSurf, pOuter);
|
|
}
|
|
|
|
HRESULT
|
|
Main_create_texture(IDirectDrawImpl* This, const DDSURFACEDESC2* pDDSD,
|
|
LPDIRECTDRAWSURFACE7* ppSurf, LPUNKNOWN pOuter,
|
|
DWORD dwMipMapLevel)
|
|
{
|
|
assert(pOuter == NULL);
|
|
|
|
return DIB_DirectDrawSurface_Create(This, pDDSD, ppSurf, pOuter);
|
|
}
|
|
|
|
HRESULT
|
|
Main_create_zbuffer(IDirectDrawImpl* This, const DDSURFACEDESC2* pDDSD,
|
|
LPDIRECTDRAWSURFACE7* ppSurf, LPUNKNOWN pOuter)
|
|
{
|
|
assert(pOuter == NULL);
|
|
|
|
return FakeZBuffer_DirectDrawSurface_Create(This, pDDSD, ppSurf, pOuter);
|
|
}
|
|
|
|
/* Does the texture surface described in pDDSD have any smaller mipmaps? */
|
|
static BOOL more_mipmaps(const DDSURFACEDESC2 *pDDSD)
|
|
{
|
|
return ((pDDSD->dwFlags & DDSD_MIPMAPCOUNT) && pDDSD->u2.dwMipMapCount > 1
|
|
&& (pDDSD->dwWidth > 1 || pDDSD->dwHeight > 1));
|
|
}
|
|
|
|
/* Create a texture surface along with any of its mipmaps. */
|
|
static HRESULT
|
|
create_texture(IDirectDrawImpl* This, const DDSURFACEDESC2 *pDDSD,
|
|
LPDIRECTDRAWSURFACE7* ppSurf, LPUNKNOWN pUnkOuter)
|
|
{
|
|
DDSURFACEDESC2 ddsd;
|
|
DWORD mipmap_level = 0;
|
|
HRESULT hr;
|
|
|
|
assert(pUnkOuter == NULL);
|
|
|
|
/* is this check right? (pixelformat can be copied from primary) */
|
|
if ((pDDSD->dwFlags&(DDSD_HEIGHT|DDSD_WIDTH)) != (DDSD_HEIGHT|DDSD_WIDTH))
|
|
return DDERR_INVALIDPARAMS;
|
|
|
|
ddsd.dwSize = sizeof(ddsd);
|
|
DD_STRUCT_COPY_BYSIZE((&ddsd),pDDSD);
|
|
|
|
if (!(ddsd.dwFlags & DDSD_PIXELFORMAT))
|
|
{
|
|
ddsd.u4.ddpfPixelFormat = This->pixelformat;
|
|
}
|
|
|
|
#ifdef HAVE_OPENGL
|
|
/* We support for now only DXT1, DXT3 & DXT5 compressed texture formats... */
|
|
if ((ddsd.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC) &&
|
|
(ddsd.u4.ddpfPixelFormat.dwFourCC != MAKE_FOURCC('D','X','T','1')) &&
|
|
(ddsd.u4.ddpfPixelFormat.dwFourCC != MAKE_FOURCC('D','X','T','3')) &&
|
|
(ddsd.u4.ddpfPixelFormat.dwFourCC != MAKE_FOURCC('D','X','T','5')) )
|
|
{
|
|
return DDERR_INVALIDPIXELFORMAT;
|
|
}
|
|
|
|
/* Check if we can really support DXT1, DXT3 & DXT5 */
|
|
if ((ddsd.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC) &&
|
|
!GL_extensions.s3tc_compressed_texture && !s3tc_initialized) {
|
|
static BOOLEAN user_warned = 0;
|
|
if (user_warned == 0) {
|
|
ERR("Trying to create DXT1, DXT3 or DXT5 texture which is not supported by the video card!!!\n");
|
|
ERR("However there is a library libtxc_dxtn.so that can be used to do the software decompression...\n");
|
|
user_warned = 1;
|
|
}
|
|
return DDERR_INVALIDPIXELFORMAT;
|
|
}
|
|
#else
|
|
if (ddsd.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC)
|
|
{
|
|
return DDERR_INVALIDPIXELFORMAT;
|
|
}
|
|
#endif
|
|
|
|
if ((ddsd.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC) && !(ddsd.dwFlags & DDSD_LINEARSIZE))
|
|
{
|
|
int size = 0;
|
|
int width = ddsd.dwWidth;
|
|
int height = ddsd.dwHeight;
|
|
switch(ddsd.u4.ddpfPixelFormat.dwFourCC) {
|
|
case MAKE_FOURCC('D','X','T','1'): size = ((width+3)&~3) * ((height+3)&~3) / 16 * 8; break;
|
|
case MAKE_FOURCC('D','X','T','3'): size = ((width+3)&~3) * ((height+3)&~3) / 16 * 16; break;
|
|
case MAKE_FOURCC('D','X','T','5'): size = ((width+3)&~3) * ((height+3)&~3) / 16 * 16; break;
|
|
default: FIXME("FOURCC not supported\n"); break;
|
|
}
|
|
ddsd.u1.dwLinearSize = size;
|
|
ddsd.dwFlags |= DDSD_LINEARSIZE;
|
|
} else if (!(ddsd.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC) && !(ddsd.dwFlags & DDSD_PITCH)) {
|
|
ddsd.u1.lPitch = DDRAW_width_bpp_to_pitch(ddsd.dwWidth, GET_BPP(ddsd)*8);
|
|
ddsd.dwFlags |= DDSD_PITCH;
|
|
}
|
|
|
|
/* Check also for the MIPMAP / MIPMAPCOUNT flags.
|
|
As checked on Windows, this is the right behaviour. No mipmaps seem to be generated. */
|
|
if (((ddsd.dwFlags & DDSD_MIPMAPCOUNT) == 0) &&
|
|
((ddsd.ddsCaps.dwCaps & DDSCAPS_MIPMAP) != 0)) {
|
|
ddsd.dwFlags |= DDSD_MIPMAPCOUNT;
|
|
ddsd.u2.dwMipMapCount = 1;
|
|
}
|
|
|
|
ddsd.dwFlags |= DDSD_PIXELFORMAT;
|
|
|
|
hr = This->create_texture(This, &ddsd, ppSurf, pUnkOuter, mipmap_level);
|
|
if (FAILED(hr)) return hr;
|
|
|
|
if (This->d3d_private) This->d3d_create_texture(This, ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, *ppSurf), TRUE,
|
|
ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, *ppSurf));
|
|
|
|
/* Create attached mipmaps if required. */
|
|
if (more_mipmaps(&ddsd))
|
|
{
|
|
LPDIRECTDRAWSURFACE7 mipmap;
|
|
LPDIRECTDRAWSURFACE7 prev_mipmap;
|
|
DDSURFACEDESC2 mipmap_surface_desc;
|
|
|
|
prev_mipmap = *ppSurf;
|
|
IDirectDrawSurface7_AddRef(prev_mipmap);
|
|
mipmap_surface_desc = ddsd;
|
|
mipmap_surface_desc.ddsCaps.dwCaps2 |= DDSCAPS2_MIPMAPSUBLEVEL;
|
|
|
|
while (more_mipmaps(&mipmap_surface_desc))
|
|
{
|
|
IDirectDrawSurfaceImpl *mipmap_impl;
|
|
|
|
mipmap_level++;
|
|
mipmap_surface_desc.u2.dwMipMapCount--;
|
|
|
|
if (mipmap_surface_desc.dwWidth > 1)
|
|
mipmap_surface_desc.dwWidth /= 2;
|
|
|
|
if (mipmap_surface_desc.dwHeight > 1)
|
|
mipmap_surface_desc.dwHeight /= 2;
|
|
|
|
if (mipmap_surface_desc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC) {
|
|
int size = 0;
|
|
int width = mipmap_surface_desc.dwWidth;
|
|
int height = mipmap_surface_desc.dwHeight;
|
|
switch(mipmap_surface_desc.u4.ddpfPixelFormat.dwFourCC) {
|
|
case MAKE_FOURCC('D','X','T','1'): size = ((width+3)&~3) * ((height+3)&~3) / 16 * 8; break;
|
|
case MAKE_FOURCC('D','X','T','3'): size = ((width+3)&~3) * ((height+3)&~3) / 16 * 16; break;
|
|
case MAKE_FOURCC('D','X','T','5'): size = ((width+3)&~3) * ((height+3)&~3) / 16 * 16; break;
|
|
default: FIXME("FOURCC not supported\n"); break;
|
|
}
|
|
mipmap_surface_desc.u1.dwLinearSize = size;
|
|
} else {
|
|
ddsd.u1.lPitch = DDRAW_width_bpp_to_pitch(ddsd.dwWidth, GET_BPP(ddsd)*8);
|
|
mipmap_surface_desc.u1.lPitch
|
|
= DDRAW_width_bpp_to_pitch(mipmap_surface_desc.dwWidth,
|
|
GET_BPP(ddsd)*8);
|
|
}
|
|
|
|
hr = This->create_texture(This, &mipmap_surface_desc, &mipmap,
|
|
pUnkOuter, mipmap_level);
|
|
if (FAILED(hr))
|
|
{
|
|
IDirectDrawSurface7_Release(prev_mipmap);
|
|
IDirectDrawSurface7_Release(*ppSurf);
|
|
return hr;
|
|
}
|
|
|
|
/* This is needed for delayed mipmap creation */
|
|
mipmap_impl = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, mipmap);
|
|
mipmap_impl->mip_main = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, *ppSurf);
|
|
mipmap_impl->mipmap_level = mipmap_level;
|
|
|
|
if (This->d3d_private) This->d3d_create_texture(This, ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, mipmap), TRUE,
|
|
ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, *ppSurf));
|
|
|
|
IDirectDrawSurface7_AddAttachedSurface(prev_mipmap, mipmap);
|
|
IDirectDrawSurface7_Release(prev_mipmap);
|
|
prev_mipmap = mipmap;
|
|
}
|
|
|
|
IDirectDrawSurface7_Release(prev_mipmap);
|
|
}
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
/* Creates a primary surface and any indicated backbuffers. */
|
|
static HRESULT
|
|
create_primary(IDirectDrawImpl* This, LPDDSURFACEDESC2 pDDSD,
|
|
LPDIRECTDRAWSURFACE7* ppSurf, LPUNKNOWN pUnkOuter)
|
|
{
|
|
DDSURFACEDESC2 ddsd;
|
|
HRESULT hr;
|
|
|
|
assert(pUnkOuter == NULL);
|
|
|
|
if (This->primary_surface != NULL)
|
|
return DDERR_PRIMARYSURFACEALREADYEXISTS;
|
|
|
|
/* as documented (what about pitch?) */
|
|
if (pDDSD->dwFlags & (DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT))
|
|
return DDERR_INVALIDPARAMS;
|
|
|
|
ddsd.dwSize = sizeof(ddsd);
|
|
DD_STRUCT_COPY_BYSIZE((&ddsd),pDDSD);
|
|
ddsd.dwFlags |= DDSD_HEIGHT | DDSD_WIDTH | DDSD_PITCH | DDSD_PIXELFORMAT;
|
|
ddsd.dwHeight = This->height;
|
|
ddsd.dwWidth = This->width;
|
|
ddsd.u1.lPitch = This->pitch;
|
|
ddsd.u4.ddpfPixelFormat = This->pixelformat;
|
|
ddsd.ddsCaps.dwCaps |= DDSCAPS_LOCALVIDMEM | DDSCAPS_VIDEOMEMORY
|
|
| DDSCAPS_VISIBLE | DDSCAPS_FRONTBUFFER;
|
|
|
|
if ((ddsd.dwFlags & DDSD_BACKBUFFERCOUNT) && ddsd.dwBackBufferCount > 0)
|
|
ddsd.ddsCaps.dwCaps |= DDSCAPS_FLIP;
|
|
|
|
hr = This->create_primary(This, &ddsd, ppSurf, pUnkOuter);
|
|
if (FAILED(hr)) return hr;
|
|
|
|
if (ddsd.dwFlags & DDSD_BACKBUFFERCOUNT)
|
|
{
|
|
IDirectDrawSurfaceImpl* primary;
|
|
LPDIRECTDRAWSURFACE7 pPrev;
|
|
DWORD i;
|
|
|
|
ddsd.dwFlags &= ~DDSD_BACKBUFFERCOUNT;
|
|
ddsd.ddsCaps.dwCaps &= ~(DDSCAPS_VISIBLE | DDSCAPS_PRIMARYSURFACE
|
|
| DDSCAPS_BACKBUFFER | DDSCAPS_FRONTBUFFER);
|
|
|
|
primary = ICOM_OBJECT(IDirectDrawSurfaceImpl,IDirectDrawSurface7,
|
|
*ppSurf);
|
|
pPrev = *ppSurf;
|
|
IDirectDrawSurface7_AddRef(pPrev);
|
|
|
|
for (i=0; i < ddsd.dwBackBufferCount; i++)
|
|
{
|
|
LPDIRECTDRAWSURFACE7 pBack;
|
|
|
|
if (i == 0)
|
|
ddsd.ddsCaps.dwCaps |= DDSCAPS_BACKBUFFER;
|
|
else
|
|
ddsd.ddsCaps.dwCaps &= ~DDSCAPS_BACKBUFFER;
|
|
|
|
hr = This->create_backbuffer(This, &ddsd, &pBack, pUnkOuter,
|
|
primary);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
IDirectDraw7_Release(pPrev);
|
|
IDirectDraw7_Release(*ppSurf);
|
|
return hr;
|
|
}
|
|
|
|
IDirectDrawSurface7_AddAttachedSurface(pPrev, pBack);
|
|
IDirectDrawSurface7_Release(pPrev);
|
|
pPrev = pBack;
|
|
}
|
|
|
|
IDirectDrawSurface7_Release(pPrev);
|
|
}
|
|
|
|
This->primary_surface = (IDirectDrawSurfaceImpl *)*ppSurf;
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
static HRESULT
|
|
create_offscreen(IDirectDrawImpl* This, LPDDSURFACEDESC2 pDDSD,
|
|
LPDIRECTDRAWSURFACE7* ppSurf, LPUNKNOWN pUnkOuter)
|
|
{
|
|
DDSURFACEDESC2 ddsd;
|
|
HRESULT hr;
|
|
|
|
/* is this check right? (pixelformat can be copied from primary) */
|
|
if ((pDDSD->dwFlags&(DDSD_HEIGHT|DDSD_WIDTH)) != (DDSD_HEIGHT|DDSD_WIDTH))
|
|
return DDERR_INVALIDPARAMS;
|
|
|
|
ddsd.dwSize = sizeof(ddsd);
|
|
DD_STRUCT_COPY_BYSIZE((&ddsd),pDDSD);
|
|
|
|
if (!(ddsd.dwFlags & DDSD_PIXELFORMAT))
|
|
{
|
|
ddsd.u4.ddpfPixelFormat = This->pixelformat;
|
|
}
|
|
|
|
if (!(ddsd.dwFlags & DDSD_PITCH))
|
|
{
|
|
ddsd.u1.lPitch = DDRAW_width_bpp_to_pitch(ddsd.dwWidth,
|
|
GET_BPP(ddsd)*8);
|
|
}
|
|
|
|
ddsd.dwFlags |= DDSD_PITCH | DDSD_PIXELFORMAT;
|
|
|
|
hr = This->create_offscreen(This, &ddsd, ppSurf, pUnkOuter);
|
|
if (FAILED(hr)) return hr;
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DirectDraw_CreateSurface(LPDIRECTDRAW7 iface, LPDDSURFACEDESC2 pDDSD,
|
|
LPDIRECTDRAWSURFACE7 *ppSurf,
|
|
IUnknown *pUnkOuter)
|
|
{
|
|
HRESULT hr;
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
|
|
TRACE("(%p)->(%p,%p,%p)\n",This,pDDSD,ppSurf,pUnkOuter);
|
|
if (TRACE_ON(ddraw)) {
|
|
TRACE("Requesting surface desc :\n");
|
|
DDRAW_dump_surface_desc(pDDSD);
|
|
}
|
|
|
|
if (pUnkOuter != NULL) {
|
|
FIXME("outer != NULL?\n");
|
|
return CLASS_E_NOAGGREGATION; /* unchecked */
|
|
}
|
|
|
|
if (!(pDDSD->dwFlags & DDSD_CAPS)) {
|
|
/* DVIDEO.DLL does forget the DDSD_CAPS flag ... *sigh* */
|
|
pDDSD->dwFlags |= DDSD_CAPS;
|
|
}
|
|
if (pDDSD->ddsCaps.dwCaps == 0) {
|
|
/* This has been checked on real Windows */
|
|
pDDSD->ddsCaps.dwCaps = DDSCAPS_LOCALVIDMEM | DDSCAPS_VIDEOMEMORY;
|
|
}
|
|
|
|
if (pDDSD->ddsCaps.dwCaps & DDSCAPS_ALLOCONLOAD) {
|
|
/* If the surface is of the 'alloconload' type, ignore the LPSURFACE field */
|
|
pDDSD->dwFlags &= ~DDSD_LPSURFACE;
|
|
}
|
|
|
|
if ((pDDSD->dwFlags & DDSD_LPSURFACE) && (pDDSD->lpSurface == NULL)) {
|
|
/* Frank Herbert's Dune specifies a null pointer for the surface, ignore the LPSURFACE field */
|
|
WARN("Null surface pointer specified, ignore it!\n");
|
|
pDDSD->dwFlags &= ~DDSD_LPSURFACE;
|
|
}
|
|
|
|
if (ppSurf == NULL) {
|
|
FIXME("You want to get back a surface? Don't give NULL ptrs!\n");
|
|
return E_POINTER; /* unchecked */
|
|
}
|
|
|
|
if (pDDSD->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
|
|
{
|
|
/* create primary surface & backbuffers */
|
|
hr = create_primary(This, pDDSD, ppSurf, pUnkOuter);
|
|
}
|
|
else if (pDDSD->ddsCaps.dwCaps & DDSCAPS_BACKBUFFER)
|
|
{
|
|
/* create backbuffer surface */
|
|
hr = This->create_backbuffer(This, pDDSD, ppSurf, pUnkOuter, NULL);
|
|
}
|
|
else if (pDDSD->ddsCaps.dwCaps & DDSCAPS_TEXTURE)
|
|
{
|
|
/* create texture */
|
|
hr = create_texture(This, pDDSD, ppSurf, pUnkOuter);
|
|
}
|
|
else if ( (pDDSD->ddsCaps.dwCaps & DDSCAPS_ZBUFFER) &&
|
|
!(pDDSD->ddsCaps.dwCaps & DDSCAPS_OFFSCREENPLAIN)) /* Support DDSCAPS_SYSTEMMEMORY */
|
|
{
|
|
/* create z-buffer */
|
|
hr = This->create_zbuffer(This, pDDSD, ppSurf, pUnkOuter);
|
|
}
|
|
else if ((pDDSD->ddsCaps.dwCaps & DDSCAPS_OFFSCREENPLAIN) ||
|
|
(pDDSD->ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY)) /* No difference in Wine right now */
|
|
{
|
|
/* create offscreenplain surface */
|
|
hr = create_offscreen(This, pDDSD, ppSurf, pUnkOuter);
|
|
}
|
|
else
|
|
{
|
|
/* Otherwise, assume offscreenplain surface */
|
|
TRACE("App didn't request a valid surface type - assuming offscreenplain\n");
|
|
hr = create_offscreen(This, pDDSD, ppSurf, pUnkOuter);
|
|
}
|
|
|
|
if (FAILED(hr)) {
|
|
FIXME("failed surface creation with code 0x%08lx\n",hr);
|
|
return hr;
|
|
}
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DirectDraw_DuplicateSurface(LPDIRECTDRAW7 iface, LPDIRECTDRAWSURFACE7 src,
|
|
LPDIRECTDRAWSURFACE7* dst)
|
|
{
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
|
|
IDirectDrawSurfaceImpl *pSrc = ICOM_OBJECT(IDirectDrawSurfaceImpl,
|
|
IDirectDrawSurface7, src);
|
|
|
|
TRACE("(%p)->(%p,%p)\n",This,src,dst);
|
|
|
|
return pSrc->duplicate_surface(pSrc, dst);
|
|
}
|
|
|
|
/* EnumDisplayModes */
|
|
|
|
BOOL Main_DirectDraw_DDPIXELFORMAT_Match(const DDPIXELFORMAT *requested,
|
|
const DDPIXELFORMAT *provided)
|
|
{
|
|
/* Some flags must be present in both or neither for a match. */
|
|
static const DWORD must_match = DDPF_PALETTEINDEXED1 | DDPF_PALETTEINDEXED2
|
|
| DDPF_PALETTEINDEXED4 | DDPF_PALETTEINDEXED8 | DDPF_FOURCC
|
|
| DDPF_ZBUFFER | DDPF_STENCILBUFFER;
|
|
|
|
if ((requested->dwFlags & provided->dwFlags) != requested->dwFlags)
|
|
return FALSE;
|
|
|
|
if ((requested->dwFlags & must_match) != (provided->dwFlags & must_match))
|
|
return FALSE;
|
|
|
|
if (requested->dwFlags & DDPF_FOURCC)
|
|
if (requested->dwFourCC != provided->dwFourCC)
|
|
return FALSE;
|
|
|
|
if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_ZBUFFER|DDPF_ALPHA
|
|
|DDPF_LUMINANCE|DDPF_BUMPDUDV))
|
|
if (requested->u1.dwRGBBitCount != provided->u1.dwRGBBitCount)
|
|
return FALSE;
|
|
|
|
if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_STENCILBUFFER
|
|
|DDPF_LUMINANCE|DDPF_BUMPDUDV))
|
|
if (requested->u2.dwRBitMask != provided->u2.dwRBitMask)
|
|
return FALSE;
|
|
|
|
if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_ZBUFFER|DDPF_BUMPDUDV))
|
|
if (requested->u3.dwGBitMask != provided->u3.dwGBitMask)
|
|
return FALSE;
|
|
|
|
/* I could be wrong about the bumpmapping. MSDN docs are vague. */
|
|
if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_STENCILBUFFER
|
|
|DDPF_BUMPDUDV))
|
|
if (requested->u4.dwBBitMask != provided->u4.dwBBitMask)
|
|
return FALSE;
|
|
|
|
if (requested->dwFlags & (DDPF_ALPHAPIXELS|DDPF_ZPIXELS))
|
|
if (requested->u5.dwRGBAlphaBitMask != provided->u5.dwRGBAlphaBitMask)
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL Main_DirectDraw_DDSD_Match(const DDSURFACEDESC2* requested,
|
|
const DDSURFACEDESC2* provided)
|
|
{
|
|
struct compare_info
|
|
{
|
|
DWORD flag;
|
|
ptrdiff_t offset;
|
|
size_t size;
|
|
};
|
|
|
|
#define CMP(FLAG, FIELD) \
|
|
{ DDSD_##FLAG, offsetof(DDSURFACEDESC2, FIELD), \
|
|
sizeof(((DDSURFACEDESC2 *)(NULL))->FIELD) }
|
|
|
|
static const struct compare_info compare[] = {
|
|
CMP(ALPHABITDEPTH, dwAlphaBitDepth),
|
|
CMP(BACKBUFFERCOUNT, dwBackBufferCount),
|
|
CMP(CAPS, ddsCaps),
|
|
CMP(CKDESTBLT, ddckCKDestBlt),
|
|
CMP(CKDESTOVERLAY, u3.ddckCKDestOverlay),
|
|
CMP(CKSRCBLT, ddckCKSrcBlt),
|
|
CMP(CKSRCOVERLAY, ddckCKSrcOverlay),
|
|
CMP(HEIGHT, dwHeight),
|
|
CMP(LINEARSIZE, u1.dwLinearSize),
|
|
CMP(LPSURFACE, lpSurface),
|
|
CMP(MIPMAPCOUNT, u2.dwMipMapCount),
|
|
CMP(PITCH, u1.lPitch),
|
|
/* PIXELFORMAT: manual */
|
|
CMP(REFRESHRATE, u2.dwRefreshRate),
|
|
CMP(TEXTURESTAGE, dwTextureStage),
|
|
CMP(WIDTH, dwWidth),
|
|
/* ZBUFFERBITDEPTH: "obsolete" */
|
|
};
|
|
|
|
#undef CMP
|
|
|
|
unsigned int i;
|
|
|
|
if ((requested->dwFlags & provided->dwFlags) != requested->dwFlags)
|
|
return FALSE;
|
|
|
|
for (i=0; i < sizeof(compare)/sizeof(compare[0]); i++)
|
|
{
|
|
if (requested->dwFlags & compare[i].flag
|
|
&& memcmp((const char *)provided + compare[i].offset,
|
|
(const char *)requested + compare[i].offset,
|
|
compare[i].size) != 0)
|
|
return FALSE;
|
|
}
|
|
|
|
if (requested->dwFlags & DDSD_PIXELFORMAT)
|
|
{
|
|
if (!Main_DirectDraw_DDPIXELFORMAT_Match(&requested->u4.ddpfPixelFormat,
|
|
&provided->u4.ddpfPixelFormat))
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#define DDENUMSURFACES_SEARCHTYPE (DDENUMSURFACES_CANBECREATED|DDENUMSURFACES_DOESEXIST)
|
|
#define DDENUMSURFACES_MATCHTYPE (DDENUMSURFACES_ALL|DDENUMSURFACES_MATCH|DDENUMSURFACES_NOMATCH)
|
|
|
|
/* This should be extended so that it can be used by
|
|
* IDirectDrawSurface7::EnumAttachedSurfaces. */
|
|
HRESULT
|
|
Main_DirectDraw_EnumExistingSurfaces(IDirectDrawImpl *This, DWORD dwFlags,
|
|
LPDDSURFACEDESC2 lpDDSD2, LPVOID context,
|
|
LPDDENUMSURFACESCALLBACK7 callback)
|
|
{
|
|
IDirectDrawSurfaceImpl *surf;
|
|
BOOL all, nomatch;
|
|
|
|
/* A NULL lpDDSD2 is permitted if we are enumerating all surfaces anyway */
|
|
if (lpDDSD2 == NULL && !(dwFlags & DDENUMSURFACES_ALL))
|
|
return DDERR_INVALIDPARAMS;
|
|
|
|
all = dwFlags & DDENUMSURFACES_ALL;
|
|
nomatch = dwFlags & DDENUMSURFACES_NOMATCH;
|
|
|
|
for (surf = This->surfaces; surf != NULL; surf = surf->next_ddraw)
|
|
{
|
|
if (all
|
|
|| (nomatch != Main_DirectDraw_DDSD_Match(lpDDSD2,
|
|
&surf->surface_desc)))
|
|
{
|
|
LPDIRECTDRAWSURFACE7 surface = ICOM_INTERFACE(surf,
|
|
IDirectDrawSurface7);
|
|
|
|
/* BOGUS! Violates COM rules, but MSDN says so. */
|
|
IDirectDrawSurface7_AddRef(surface);
|
|
|
|
if (callback(surface, &surf->surface_desc, context)
|
|
== DDENUMRET_CANCEL)
|
|
break;
|
|
}
|
|
}
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
/* I really don't understand how this is supposed to work.
|
|
* We only consider dwHeight, dwWidth and ddpfPixelFormat.dwFlags. */
|
|
HRESULT
|
|
Main_DirectDraw_EnumCreateableSurfaces(IDirectDrawImpl *This, DWORD dwFlags,
|
|
LPDDSURFACEDESC2 lpDDSD2,
|
|
LPVOID context,
|
|
LPDDENUMSURFACESCALLBACK7 callback)
|
|
{
|
|
FIXME("This isn't going to work.\n");
|
|
|
|
if ((dwFlags & DDENUMSURFACES_MATCHTYPE) != DDENUMSURFACES_MATCH)
|
|
return DDERR_INVALIDPARAMS;
|
|
|
|
/* TODO: implement this.
|
|
* Does this work before SCL is called?
|
|
* Does it only consider off-screen surfaces?
|
|
*/
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
/* For unsigned x. 0 is not a power of 2. */
|
|
#define IS_POW_2(x) (((x) & ((x) - 1)) == 0)
|
|
|
|
HRESULT WINAPI
|
|
Main_DirectDraw_EnumSurfaces(LPDIRECTDRAW7 iface, DWORD dwFlags,
|
|
LPDDSURFACEDESC2 lpDDSD2, LPVOID context,
|
|
LPDDENUMSURFACESCALLBACK7 callback)
|
|
{
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
TRACE("(%p)->(0x%lx, %p, %p, %p)\n", iface, dwFlags, lpDDSD2, context,
|
|
callback);
|
|
|
|
if (callback == NULL)
|
|
return DDERR_INVALIDPARAMS;
|
|
|
|
if (dwFlags & ~(DDENUMSURFACES_SEARCHTYPE|DDENUMSURFACES_MATCHTYPE))
|
|
return DDERR_INVALIDPARAMS;
|
|
|
|
if (!IS_POW_2(dwFlags & DDENUMSURFACES_SEARCHTYPE)
|
|
|| !IS_POW_2(dwFlags & DDENUMSURFACES_MATCHTYPE))
|
|
return DDERR_INVALIDPARAMS;
|
|
|
|
if (dwFlags & DDENUMSURFACES_DOESEXIST)
|
|
{
|
|
return Main_DirectDraw_EnumExistingSurfaces(This, dwFlags, lpDDSD2,
|
|
context, callback);
|
|
}
|
|
else
|
|
{
|
|
return Main_DirectDraw_EnumCreateableSurfaces(This, dwFlags, lpDDSD2,
|
|
context, callback);
|
|
}
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DirectDraw_EvaluateMode(LPDIRECTDRAW7 iface,DWORD a,DWORD* b)
|
|
{
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
FIXME("(%p)->() stub\n", This);
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DirectDraw_FlipToGDISurface(LPDIRECTDRAW7 iface)
|
|
{
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
TRACE("(%p)->()\n",This);
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DirectDraw_GetCaps(LPDIRECTDRAW7 iface, LPDDCAPS pDriverCaps,
|
|
LPDDCAPS pHELCaps)
|
|
{
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
TRACE("(%p,%p,%p)\n",This,pDriverCaps,pHELCaps);
|
|
if (pDriverCaps != NULL) {
|
|
DD_STRUCT_COPY_BYSIZE(pDriverCaps,&This->caps);
|
|
if (TRACE_ON(ddraw)) {
|
|
TRACE("Driver Caps : \n");
|
|
DDRAW_dump_DDCAPS(pDriverCaps);
|
|
}
|
|
}
|
|
if (pHELCaps != NULL) {
|
|
DD_STRUCT_COPY_BYSIZE(pHELCaps,&This->caps);
|
|
if (TRACE_ON(ddraw)) {
|
|
TRACE("HEL Caps : \n");
|
|
DDRAW_dump_DDCAPS(pHELCaps);
|
|
}
|
|
}
|
|
return DD_OK;
|
|
}
|
|
|
|
/* GetCaps */
|
|
/* GetDeviceIdentifier */
|
|
/* GetDIsplayMode */
|
|
|
|
HRESULT WINAPI
|
|
Main_DirectDraw_GetFourCCCodes(LPDIRECTDRAW7 iface, LPDWORD pNumCodes,
|
|
LPDWORD pCodes)
|
|
{
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
if (*pNumCodes) {
|
|
*pNumCodes=0;
|
|
}
|
|
FIXME("(%p,%p,%p), stub\n",This,pNumCodes,pCodes);
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DirectDraw_GetGDISurface(LPDIRECTDRAW7 iface,
|
|
LPDIRECTDRAWSURFACE7 *lplpGDIDDSSurface)
|
|
{
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
TRACE("(%p)->(%p)\n", This, lplpGDIDDSSurface);
|
|
TRACE("returning primary (%p)\n", This->primary_surface);
|
|
*lplpGDIDDSSurface = ICOM_INTERFACE(This->primary_surface, IDirectDrawSurface7);
|
|
if (*lplpGDIDDSSurface)
|
|
IDirectDrawSurface7_AddRef(*lplpGDIDDSSurface);
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DirectDraw_GetMonitorFrequency(LPDIRECTDRAW7 iface,LPDWORD freq)
|
|
{
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
FIXME("(%p)->(%p) returns 60 Hz always\n",This,freq);
|
|
*freq = 60*100; /* 60 Hz */
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DirectDraw_GetScanLine(LPDIRECTDRAW7 iface, LPDWORD lpdwScanLine)
|
|
{
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
static BOOL hide;
|
|
|
|
/* Since this method is called often, show the fixme only once */
|
|
if (!hide) {
|
|
FIXME("(%p)->(%p) semi-stub\n", This, lpdwScanLine);
|
|
hide = TRUE;
|
|
}
|
|
|
|
/* Fake the line sweeping of the monitor */
|
|
/* FIXME: We should synchronize with a source to keep the refresh rate */
|
|
*lpdwScanLine = This->cur_scanline++;
|
|
/* Assume 20 scan lines in the vertical blank */
|
|
if (This->cur_scanline >= This->height + 20)
|
|
This->cur_scanline = 0;
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DirectDraw_GetSurfaceFromDC(LPDIRECTDRAW7 iface, HDC hdc,
|
|
LPDIRECTDRAWSURFACE7 *lpDDS)
|
|
{
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
FIXME("(%p)->(%08ld,%p)\n", This, (DWORD) hdc, lpDDS);
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DirectDraw_GetVerticalBlankStatus(LPDIRECTDRAW7 iface, LPBOOL status)
|
|
{
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
TRACE("(%p)->(%p)\n",This,status);
|
|
*status = TRUE;
|
|
return DD_OK;
|
|
}
|
|
|
|
/* If we were not initialised then Uninit_Main_IDirectDraw7_Initialize would
|
|
* have been called instead. */
|
|
HRESULT WINAPI
|
|
Main_DirectDraw_Initialize(LPDIRECTDRAW7 iface, LPGUID lpGuid)
|
|
{
|
|
TRACE("(%p)->(%s)\n", iface, debugstr_guid(lpGuid));
|
|
|
|
return DDERR_ALREADYINITIALIZED;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DirectDraw_RestoreAllSurfaces(LPDIRECTDRAW7 iface)
|
|
{
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
IDirectDrawSurfaceImpl* surf;
|
|
|
|
TRACE("(%p)->()\n", This);
|
|
|
|
for (surf = This->surfaces; surf != NULL; surf = surf->next_ddraw)
|
|
IDirectDrawSurface7_Restore(ICOM_INTERFACE(surf, IDirectDrawSurface7));
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
static void DDRAW_SubclassWindow(IDirectDrawImpl* This)
|
|
{
|
|
/* Well we don't actually subclass the window yet. */
|
|
SetPropA(This->window, ddProp, This);
|
|
}
|
|
|
|
static void DDRAW_UnsubclassWindow(IDirectDrawImpl* This)
|
|
{
|
|
RemovePropA(This->window, ddProp);
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DirectDraw_SetCooperativeLevel(LPDIRECTDRAW7 iface, HWND hwnd,
|
|
DWORD cooplevel)
|
|
{
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
|
|
FIXME("(%p)->(%08lx,%08lx)\n",This,(DWORD)hwnd,cooplevel);
|
|
DDRAW_dump_cooperativelevel(cooplevel);
|
|
|
|
/* Makes realMYST test happy. */
|
|
if (This->cooperative_level == cooplevel
|
|
&& This->window == hwnd)
|
|
return DD_OK;
|
|
|
|
/* XXX "It cannot be reset while the process has surfaces or palettes
|
|
* created." Otherwise the window can be changed???
|
|
*
|
|
* This appears to be wrong - comment it out for now.
|
|
if (This->window)
|
|
return DDERR_HWNDALREADYSET;
|
|
*/
|
|
|
|
if (!(cooplevel & (DDSCL_EXCLUSIVE|DDSCL_NORMAL)))
|
|
return DDERR_INVALIDPARAMS;
|
|
|
|
This->window = hwnd;
|
|
This->cooperative_level = cooplevel;
|
|
|
|
This->local.hWnd = (ULONG_PTR)hwnd;
|
|
This->local.dwLocalFlags |= DDRAWILCL_SETCOOPCALLED;
|
|
/* not entirely sure about these */
|
|
if (cooplevel & DDSCL_EXCLUSIVE) This->local.dwLocalFlags |= DDRAWILCL_HASEXCLUSIVEMODE;
|
|
if (cooplevel & DDSCL_FULLSCREEN) This->local.dwLocalFlags |= DDRAWILCL_ISFULLSCREEN;
|
|
if (cooplevel & DDSCL_ALLOWMODEX) This->local.dwLocalFlags |= DDRAWILCL_ALLOWMODEX;
|
|
if (cooplevel & DDSCL_MULTITHREADED) This->local.dwLocalFlags |= DDRAWILCL_MULTITHREADED;
|
|
if (cooplevel & DDSCL_FPUSETUP) This->local.dwLocalFlags |= DDRAWILCL_FPUSETUP;
|
|
if (cooplevel & DDSCL_FPUPRESERVE) This->local.dwLocalFlags |= DDRAWILCL_FPUPRESERVE;
|
|
|
|
if (This->local.lpGbl) {
|
|
/* assume that this app is the active app (in wine, there's
|
|
* probably only one app per global ddraw object anyway) */
|
|
if (cooplevel & DDSCL_EXCLUSIVE) This->local.lpGbl->lpExclusiveOwner = &This->local;
|
|
else if (This->local.lpGbl->lpExclusiveOwner == &This->local)
|
|
This->local.lpGbl->lpExclusiveOwner = NULL;
|
|
if (This->set_exclusive_mode)
|
|
This->set_exclusive_mode(This, (cooplevel & DDSCL_EXCLUSIVE) != 0);
|
|
}
|
|
|
|
ShowWindow(hwnd, SW_SHOW);
|
|
|
|
DDRAW_SubclassWindow(This);
|
|
|
|
/* TODO Does it also get resized to the current screen size? */
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DirectDraw_SetDisplayMode(LPDIRECTDRAW7 iface, DWORD dwWidth,
|
|
DWORD dwHeight, LONG lPitch,
|
|
DWORD dwRefreshRate, DWORD dwFlags,
|
|
const DDPIXELFORMAT* pixelformat)
|
|
{
|
|
short screenX;
|
|
short screenY;
|
|
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
|
|
TRACE("(%p)->SetDisplayMode(%ld,%ld)\n",This,dwWidth,dwHeight);
|
|
|
|
if (!(This->cooperative_level & DDSCL_EXCLUSIVE))
|
|
return DDERR_NOEXCLUSIVEMODE;
|
|
|
|
if (!IsWindow(This->window))
|
|
return DDERR_GENERIC; /* unchecked */
|
|
|
|
LosePrimarySurface(This);
|
|
|
|
screenX = GetSystemMetrics(SM_CXSCREEN);
|
|
screenY = GetSystemMetrics(SM_CYSCREEN);
|
|
|
|
This->width = dwWidth;
|
|
This->height = dwHeight;
|
|
This->pitch = lPitch;
|
|
This->pixelformat = *pixelformat;
|
|
|
|
/* Position the window in the center of the screen - don't center for now */
|
|
/* MoveWindow(This->window, (screenX-dwWidth)/2, (screenY-dwHeight)/2,
|
|
dwWidth, dwHeight, TRUE);*/
|
|
MoveWindow(This->window, 0, 0, dwWidth, dwHeight, TRUE);
|
|
|
|
SetFocus(This->window);
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DirectDraw_RestoreDisplayMode(LPDIRECTDRAW7 iface)
|
|
{
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
|
|
TRACE("(%p)\n",This);
|
|
if (!(This->cooperative_level & DDSCL_EXCLUSIVE))
|
|
return DDERR_NOEXCLUSIVEMODE;
|
|
|
|
/* Lose the primary surface if the resolution changes. */
|
|
if (This->orig_width != This->width || This->orig_height != This->height
|
|
|| This->orig_pitch != This->pitch
|
|
|| This->orig_pixelformat.dwFlags != This->pixelformat.dwFlags
|
|
|| !Main_DirectDraw_DDPIXELFORMAT_Match(&This->pixelformat,
|
|
&This->orig_pixelformat))
|
|
{
|
|
LosePrimarySurface(This);
|
|
}
|
|
|
|
/* TODO Move the window back where it belongs. */
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DirectDraw_WaitForVerticalBlank(LPDIRECTDRAW7 iface, DWORD dwFlags,
|
|
HANDLE h)
|
|
{
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
FIXME("(%p)->(flags=0x%08lx,handle=%p)\n",This,dwFlags,h);
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DirectDraw_GetDisplayMode(LPDIRECTDRAW7 iface, LPDDSURFACEDESC2 pDDSD)
|
|
{
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
TRACE("(%p)->GetDisplayMode(%p)\n",This,pDDSD);
|
|
|
|
pDDSD->dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_PITCH|DDSD_PIXELFORMAT|DDSD_REFRESHRATE;
|
|
pDDSD->dwHeight = This->height;
|
|
pDDSD->dwWidth = This->width;
|
|
pDDSD->u1.lPitch = This->pitch;
|
|
pDDSD->u2.dwRefreshRate = 60;
|
|
pDDSD->u4.ddpfPixelFormat = This->pixelformat;
|
|
pDDSD->ddsCaps.dwCaps = 0;
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
static INT32 allocate_memory(IDirectDrawImpl *This, DWORD mem)
|
|
{
|
|
if (mem > This->available_vidmem) return -1;
|
|
This->available_vidmem -= mem;
|
|
return This->available_vidmem;
|
|
}
|
|
|
|
static void free_memory(IDirectDrawImpl *This, DWORD mem)
|
|
{
|
|
This->available_vidmem += mem;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DirectDraw_GetAvailableVidMem(LPDIRECTDRAW7 iface, LPDDSCAPS2 ddscaps,
|
|
LPDWORD total, LPDWORD free)
|
|
{
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
TRACE("(%p)->(%p,%p,%p)\n", This,ddscaps,total,free);
|
|
|
|
if (TRACE_ON(ddraw)) {
|
|
TRACE(" Asking for memory of type : ");
|
|
DDRAW_dump_DDSCAPS2(ddscaps); TRACE("\n");
|
|
}
|
|
|
|
/* We have 16 MB videomemory */
|
|
if (total) *total= This->total_vidmem;
|
|
if (free) *free = This->available_vidmem;
|
|
|
|
TRACE(" returning (total) %ld / (free) %ld\n",
|
|
total != NULL ? *total : 0,
|
|
free != NULL ? *free : 0);
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI Main_DirectDraw_TestCooperativeLevel(LPDIRECTDRAW7 iface) {
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
TRACE("(%p)->(): stub\n", This);
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DirectDraw_StartModeTest(LPDIRECTDRAW7 iface, LPSIZE pModes,
|
|
DWORD dwNumModes, DWORD dwFlags)
|
|
{
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
FIXME("(%p)->() stub\n", This);
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
/*** Owned object management. */
|
|
|
|
void Main_DirectDraw_AddSurface(IDirectDrawImpl* This,
|
|
IDirectDrawSurfaceImpl* surface)
|
|
{
|
|
assert(surface->ddraw_owner == NULL || surface->ddraw_owner == This);
|
|
|
|
surface->ddraw_owner = This;
|
|
|
|
/* where should it go? */
|
|
surface->next_ddraw = This->surfaces;
|
|
surface->prev_ddraw = NULL;
|
|
if (This->surfaces)
|
|
This->surfaces->prev_ddraw = surface;
|
|
This->surfaces = surface;
|
|
}
|
|
|
|
void Main_DirectDraw_RemoveSurface(IDirectDrawImpl* This,
|
|
IDirectDrawSurfaceImpl* surface)
|
|
{
|
|
assert(surface->ddraw_owner == This);
|
|
|
|
if (This->surfaces == surface)
|
|
This->surfaces = surface->next_ddraw;
|
|
|
|
if (This->primary_surface == surface)
|
|
This->primary_surface = NULL;
|
|
|
|
if (surface->next_ddraw)
|
|
surface->next_ddraw->prev_ddraw = surface->prev_ddraw;
|
|
if (surface->prev_ddraw)
|
|
surface->prev_ddraw->next_ddraw = surface->next_ddraw;
|
|
}
|
|
|
|
static void Main_DirectDraw_DeleteSurfaces(IDirectDrawImpl* This)
|
|
{
|
|
while (This->surfaces != NULL)
|
|
Main_DirectDrawSurface_ForceDestroy(This->surfaces);
|
|
}
|
|
|
|
void Main_DirectDraw_AddClipper(IDirectDrawImpl* This,
|
|
IDirectDrawClipperImpl* clipper)
|
|
{
|
|
assert(clipper->ddraw_owner == NULL || clipper->ddraw_owner == This);
|
|
|
|
clipper->ddraw_owner = This;
|
|
|
|
clipper->next_ddraw = This->clippers;
|
|
clipper->prev_ddraw = NULL;
|
|
if (This->clippers)
|
|
This->clippers->prev_ddraw = clipper;
|
|
This->clippers = clipper;
|
|
}
|
|
|
|
void Main_DirectDraw_RemoveClipper(IDirectDrawImpl* This,
|
|
IDirectDrawClipperImpl* clipper)
|
|
{
|
|
assert(clipper->ddraw_owner == This);
|
|
|
|
if (This->clippers == clipper)
|
|
This->clippers = clipper->next_ddraw;
|
|
|
|
if (clipper->next_ddraw)
|
|
clipper->next_ddraw->prev_ddraw = clipper->prev_ddraw;
|
|
if (clipper->prev_ddraw)
|
|
clipper->prev_ddraw->next_ddraw = clipper->next_ddraw;
|
|
}
|
|
|
|
static void Main_DirectDraw_DeleteClippers(IDirectDrawImpl* This)
|
|
{
|
|
while (This->clippers != NULL)
|
|
Main_DirectDrawClipper_ForceDestroy(This->clippers);
|
|
}
|
|
|
|
void Main_DirectDraw_AddPalette(IDirectDrawImpl* This,
|
|
IDirectDrawPaletteImpl* palette)
|
|
{
|
|
assert(palette->ddraw_owner == NULL || palette->ddraw_owner == This);
|
|
|
|
palette->ddraw_owner = This;
|
|
|
|
/* where should it go? */
|
|
palette->next_ddraw = This->palettes;
|
|
palette->prev_ddraw = NULL;
|
|
if (This->palettes)
|
|
This->palettes->prev_ddraw = palette;
|
|
This->palettes = palette;
|
|
}
|
|
|
|
void Main_DirectDraw_RemovePalette(IDirectDrawImpl* This,
|
|
IDirectDrawPaletteImpl* palette)
|
|
{
|
|
IDirectDrawSurfaceImpl *surf;
|
|
|
|
assert(palette->ddraw_owner == This);
|
|
|
|
if (This->palettes == palette)
|
|
This->palettes = palette->next_ddraw;
|
|
|
|
if (palette->next_ddraw)
|
|
palette->next_ddraw->prev_ddraw = palette->prev_ddraw;
|
|
if (palette->prev_ddraw)
|
|
palette->prev_ddraw->next_ddraw = palette->next_ddraw;
|
|
|
|
/* Here we need also to remove tha palette from any surface which has it as the
|
|
* current palette (checked on Windows)
|
|
*/
|
|
for (surf = This->surfaces; surf != NULL; surf = surf->next_ddraw) {
|
|
if (surf->palette == palette) {
|
|
TRACE("Palette %p attached to surface %p.\n", palette, surf);
|
|
surf->palette = NULL;
|
|
surf->set_palette(surf, NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void Main_DirectDraw_DeletePalettes(IDirectDrawImpl* This)
|
|
{
|
|
while (This->palettes != NULL)
|
|
Main_DirectDrawPalette_ForceDestroy(This->palettes);
|
|
}
|
|
|
|
/*** ??? */
|
|
|
|
static void
|
|
LoseSurface(IDirectDrawSurfaceImpl *surface)
|
|
{
|
|
if (surface != NULL) surface->lose_surface(surface);
|
|
}
|
|
|
|
static void
|
|
LosePrimarySurface(IDirectDrawImpl *This)
|
|
{
|
|
/* MSDN: "If another application changes the display mode, the primary
|
|
* surface is lost, and the method returns DDERR_SURFACELOST until the
|
|
* primary surface is recreated to match the new display mode."
|
|
*
|
|
* We mark all the primary surfaces as lost as soon as the display
|
|
* mode is changed (by any application). */
|
|
|
|
LoseSurface(This->primary_surface);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Uninitialised DirectDraw functions
|
|
*
|
|
* This vtable is used when a DirectDraw object is created with
|
|
* CoCreateInstance. The only usable method is Initialize.
|
|
*/
|
|
|
|
void Uninit_DirectDraw_final_release(IDirectDrawImpl *This)
|
|
{
|
|
Main_DirectDraw_final_release(This);
|
|
}
|
|
|
|
static IDirectDraw7Vtbl Uninit_DirectDraw_VTable;
|
|
|
|
/* Not called from the vtable. */
|
|
HRESULT Uninit_DirectDraw_Construct(IDirectDrawImpl *This, BOOL ex)
|
|
{
|
|
HRESULT hr;
|
|
|
|
hr = Main_DirectDraw_Construct(This, ex);
|
|
if (FAILED(hr)) return hr;
|
|
|
|
This->final_release = Uninit_DirectDraw_final_release;
|
|
ICOM_INIT_INTERFACE(This, IDirectDraw7, Uninit_DirectDraw_VTable);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT Uninit_DirectDraw_Create(const GUID* pGUID,
|
|
LPDIRECTDRAW7* pIface,
|
|
IUnknown* pUnkOuter, BOOL ex)
|
|
{
|
|
HRESULT hr;
|
|
IDirectDrawImpl* This;
|
|
|
|
assert(pUnkOuter == NULL); /* XXX no: we must check this */
|
|
|
|
This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
|
|
sizeof(IDirectDrawImpl));
|
|
if (This == NULL) return E_OUTOFMEMORY;
|
|
|
|
hr = Uninit_DirectDraw_Construct(This, ex);
|
|
if (FAILED(hr))
|
|
HeapFree(GetProcessHeap(), HEAP_ZERO_MEMORY, This);
|
|
else
|
|
*pIface = ICOM_INTERFACE(This, IDirectDraw7);
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_Initialize(LPDIRECTDRAW7 iface, LPGUID pDeviceGuid)
|
|
{
|
|
const ddraw_driver* driver;
|
|
IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
|
|
|
|
TRACE("(%p)->(%p)\n", iface, pDeviceGuid);
|
|
|
|
driver = DDRAW_FindDriver(pDeviceGuid);
|
|
/* XXX This return value is not documented. (Not checked.) */
|
|
if (driver == NULL) return DDERR_INVALIDDIRECTDRAWGUID;
|
|
|
|
return driver->init(This, pDeviceGuid);
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_Compact(LPDIRECTDRAW7 iface)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_CreateClipper(LPDIRECTDRAW7 iface, DWORD dwFlags,
|
|
LPDIRECTDRAWCLIPPER *lplpDDClipper,
|
|
IUnknown *pUnkOuter)
|
|
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_CreatePalette(LPDIRECTDRAW7 iface, DWORD dwFlags,
|
|
LPPALETTEENTRY lpColorTable,
|
|
LPDIRECTDRAWPALETTE *lplpDDPalette,
|
|
IUnknown *pUnkOuter)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_CreateSurface(LPDIRECTDRAW7 iface,
|
|
LPDDSURFACEDESC2 lpDDSurfaceDesc,
|
|
LPDIRECTDRAWSURFACE7 *lplpDDSurface,
|
|
IUnknown *pUnkOuter)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_DuplicateSurface(LPDIRECTDRAW7 iface,
|
|
LPDIRECTDRAWSURFACE7 pSurf,
|
|
LPDIRECTDRAWSURFACE7 *pDupSurf)
|
|
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_EnumDisplayModes(LPDIRECTDRAW7 iface, DWORD dwFlags,
|
|
LPDDSURFACEDESC2 lpDDSD,
|
|
LPVOID context,
|
|
LPDDENUMMODESCALLBACK2 cb)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_EnumSurfaces(LPDIRECTDRAW7 iface, DWORD dwFlags,
|
|
LPDDSURFACEDESC2 pDDSD, LPVOID context,
|
|
LPDDENUMSURFACESCALLBACK7 cb)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_FlipToGDISurface(LPDIRECTDRAW7 iface)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_GetCaps(LPDIRECTDRAW7 iface, LPDDCAPS pDriverCaps,
|
|
LPDDCAPS pHELCaps)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_GetDisplayMode(LPDIRECTDRAW7 iface,
|
|
LPDDSURFACEDESC2 pDDSD)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_GetFourCCCodes(LPDIRECTDRAW7 iface, LPDWORD pNumCodes,
|
|
LPDWORD pCodes)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_GetGDISurface(LPDIRECTDRAW7 iface,
|
|
LPDIRECTDRAWSURFACE7 *pGDISurf)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_GetMonitorFrequency(LPDIRECTDRAW7 iface, LPDWORD pdwFreq)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_GetScanLine(LPDIRECTDRAW7 iface, LPDWORD pdwScanLine)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_GetVerticalBlankStatus(LPDIRECTDRAW7 iface, PBOOL pbIsInVB)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_RestoreDisplayMode(LPDIRECTDRAW7 iface)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_SetCooperativeLevel(LPDIRECTDRAW7 iface, HWND hWnd,
|
|
DWORD dwFlags)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_SetDisplayMode(LPDIRECTDRAW7 iface, DWORD dwWidth,
|
|
DWORD dwHeight, DWORD dwBPP,
|
|
DWORD dwRefreshRate, DWORD dwFlags)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_WaitForVerticalBlank(LPDIRECTDRAW7 iface, DWORD dwFlags,
|
|
HANDLE hEvent)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_GetAvailableVidMem(LPDIRECTDRAW7 iface, LPDDSCAPS2 pDDCaps,
|
|
LPDWORD pdwTotal, LPDWORD pdwFree)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_GetSurfaceFromDC(LPDIRECTDRAW7 iface, HDC hDC,
|
|
LPDIRECTDRAWSURFACE7 *pSurf)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_RestoreAllSurfaces(LPDIRECTDRAW7 iface)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_TestCooperativeLevel(LPDIRECTDRAW7 iface)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_GetDeviceIdentifier(LPDIRECTDRAW7 iface,
|
|
LPDDDEVICEIDENTIFIER2 pDDDI,
|
|
DWORD dwFlags)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_StartModeTest(LPDIRECTDRAW7 iface, LPSIZE pszModes,
|
|
DWORD cModes, DWORD dwFlags)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
Uninit_DirectDraw_EvaluateMode(LPDIRECTDRAW7 iface, DWORD dwFlags,
|
|
LPDWORD pTimeout)
|
|
{
|
|
return DDERR_NOTINITIALIZED;
|
|
}
|
|
|
|
static IDirectDraw7Vtbl Uninit_DirectDraw_VTable =
|
|
{
|
|
Main_DirectDraw_QueryInterface,
|
|
Main_DirectDraw_AddRef,
|
|
Main_DirectDraw_Release,
|
|
Uninit_DirectDraw_Compact,
|
|
Uninit_DirectDraw_CreateClipper,
|
|
Uninit_DirectDraw_CreatePalette,
|
|
Uninit_DirectDraw_CreateSurface,
|
|
Uninit_DirectDraw_DuplicateSurface,
|
|
Uninit_DirectDraw_EnumDisplayModes,
|
|
Uninit_DirectDraw_EnumSurfaces,
|
|
Uninit_DirectDraw_FlipToGDISurface,
|
|
Uninit_DirectDraw_GetCaps,
|
|
Uninit_DirectDraw_GetDisplayMode,
|
|
Uninit_DirectDraw_GetFourCCCodes,
|
|
Uninit_DirectDraw_GetGDISurface,
|
|
Uninit_DirectDraw_GetMonitorFrequency,
|
|
Uninit_DirectDraw_GetScanLine,
|
|
Uninit_DirectDraw_GetVerticalBlankStatus,
|
|
Uninit_DirectDraw_Initialize,
|
|
Uninit_DirectDraw_RestoreDisplayMode,
|
|
Uninit_DirectDraw_SetCooperativeLevel,
|
|
Uninit_DirectDraw_SetDisplayMode,
|
|
Uninit_DirectDraw_WaitForVerticalBlank,
|
|
Uninit_DirectDraw_GetAvailableVidMem,
|
|
Uninit_DirectDraw_GetSurfaceFromDC,
|
|
Uninit_DirectDraw_RestoreAllSurfaces,
|
|
Uninit_DirectDraw_TestCooperativeLevel,
|
|
Uninit_DirectDraw_GetDeviceIdentifier,
|
|
Uninit_DirectDraw_StartModeTest,
|
|
Uninit_DirectDraw_EvaluateMode
|
|
};
|