char interface_name[100];
char device_name[100];
const GUID *device_guid;
- DWORD remove_caps;
} device_list7[] =
{
/* T&L HAL device */
"WINE Direct3D7 Hardware Transform and Lighting acceleration using WineD3D",
"Wine D3D7 T&L HAL",
&IID_IDirect3DTnLHalDevice,
- 0,
},
/* HAL device */
"WINE Direct3D7 Hardware acceleration using WineD3D",
"Direct3D HAL",
&IID_IDirect3DHALDevice,
- 0,
},
/* RGB device */
"WINE Direct3D7 RGB Software Emulation using WineD3D",
"Wine D3D7 RGB",
&IID_IDirect3DRGBDevice,
- D3DDEVCAPS_HWTRANSFORMANDLIGHT,
},
};
caps->dwMinTextureHeight = 1;
/* Convert DWORDs safely to WORDs */
- if (wined3d_caps.MaxTextureBlendStages > 0xffff)
- caps->wMaxTextureBlendStages = 0xffff;
- else
- caps->wMaxTextureBlendStages = (WORD)wined3d_caps.MaxTextureBlendStages;
- if (wined3d_caps.MaxSimultaneousTextures > 0xffff)
- caps->wMaxSimultaneousTextures = 0xffff;
- else
- caps->wMaxSimultaneousTextures = (WORD)wined3d_caps.MaxSimultaneousTextures;
-
- if (wined3d_caps.MaxUserClipPlanes > 0xffff)
- caps->wMaxUserClipPlanes = 0xffff;
- else
- caps->wMaxUserClipPlanes = (WORD)wined3d_caps.MaxUserClipPlanes;
- if (wined3d_caps.MaxVertexBlendMatrices > 0xffff)
- caps->wMaxVertexBlendMatrices = 0xffff;
- else
- caps->wMaxVertexBlendMatrices = (WORD)wined3d_caps.MaxVertexBlendMatrices;
+ caps->wMaxTextureBlendStages = min(wined3d_caps.MaxTextureBlendStages, 0xffff);
+ caps->wMaxSimultaneousTextures = min(wined3d_caps.MaxSimultaneousTextures, 0xffff);
+ caps->wMaxUserClipPlanes = min(wined3d_caps.MaxUserClipPlanes, D3DMAXUSERCLIPPLANES);
+ caps->wMaxVertexBlendMatrices = min(wined3d_caps.MaxVertexBlendMatrices, 0xffff);
caps->deviceGUID = IID_IDirect3DTnLHalDevice;
return DD_OK;
}
-HRESULT CALLBACK enum_zbuffer(DDPIXELFORMAT *format, void *ctx)
-{
- DDCAPS *caps = ctx;
-
- switch (format->u1.dwZBufferBitDepth)
- {
- case 8:
- caps->dwZBufferBitDepths |= DDBD_8;
- break;
- case 16:
- caps->dwZBufferBitDepths |= DDBD_16;
- break;
- case 24:
- caps->dwZBufferBitDepths |= DDBD_24;
- break;
- case 32:
- caps->dwZBufferBitDepths |= DDBD_32;
- break;
- }
- return D3DENUMRET_OK;
-}
-
/*****************************************************************************
* IDirectDraw7::GetCaps
*
caps.dwCaps |= DDCAPS_ALIGNSTRIDE;
caps.dwAlignStrideAlign = DDRAW_STRIDE_ALIGNMENT;
- caps.ddsOldCaps.dwCaps = caps.ddsCaps.dwCaps;
-
- IDirect3D7_EnumZBufferFormats(&ddraw->IDirect3D7_iface, &IID_IDirect3DHALDevice, enum_zbuffer, &caps);
-
if(DriverCaps)
{
DD_STRUCT_COPY_BYSIZE(DriverCaps, &caps);
struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
struct wined3d_display_mode mode;
HRESULT hr;
- DWORD Size;
TRACE("iface %p, surface_desc %p.\n", iface, DDSD);
- wined3d_mutex_lock();
/* This seems sane */
- if (!DDSD)
- {
- wined3d_mutex_unlock();
+ if (!DDSD || (DDSD->dwSize != sizeof(DDSURFACEDESC) && DDSD->dwSize != sizeof(DDSURFACEDESC2)))
return DDERR_INVALIDPARAMS;
- }
+
+ wined3d_mutex_lock();
if (FAILED(hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode, NULL)))
{
return hr;
}
- Size = DDSD->dwSize;
- memset(DDSD, 0, Size);
-
- DDSD->dwSize = Size;
+ memset(DDSD, 0, DDSD->dwSize);
+ DDSD->dwSize = sizeof(*DDSD);
DDSD->dwFlags |= DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_PITCH | DDSD_REFRESHRATE;
DDSD->dwWidth = mode.width;
DDSD->dwHeight = mode.height;
static HRESULT WINAPI ddraw2_GetDisplayMode(IDirectDraw2 *iface, DDSURFACEDESC *surface_desc)
{
struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
+ HRESULT hr;
TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
- /* FIXME: Test sizes, properly convert surface_desc */
- return ddraw7_GetDisplayMode(&ddraw->IDirectDraw7_iface, (DDSURFACEDESC2 *)surface_desc);
+ hr = ddraw7_GetDisplayMode(&ddraw->IDirectDraw7_iface, (DDSURFACEDESC2 *)surface_desc);
+ if (SUCCEEDED(hr)) surface_desc->dwSize = sizeof(*surface_desc);
+ return hr;
}
static HRESULT WINAPI ddraw1_GetDisplayMode(IDirectDraw *iface, DDSURFACEDESC *surface_desc)
{
struct ddraw *ddraw = impl_from_IDirectDraw(iface);
+ HRESULT hr;
TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
- /* FIXME: Test sizes, properly convert surface_desc */
- return ddraw7_GetDisplayMode(&ddraw->IDirectDraw7_iface, (DDSURFACEDESC2 *)surface_desc);
+ hr = ddraw7_GetDisplayMode(&ddraw->IDirectDraw7_iface, (DDSURFACEDESC2 *)surface_desc);
+ if (SUCCEEDED(hr)) surface_desc->dwSize = sizeof(*surface_desc);
+ return hr;
}
/*****************************************************************************
*****************************************************************************/
static HRESULT WINAPI ddraw7_FlipToGDISurface(IDirectDraw7 *iface)
{
- struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
-
- TRACE("iface %p.\n", iface);
-
- ddraw->flags |= DDRAW_GDI_FLIP;
-
- if (ddraw->primary)
- ddraw_surface_update_frontbuffer(ddraw->primary, NULL, FALSE);
+ FIXME("iface %p stub!\n", iface);
return DD_OK;
}
{
struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
struct ddraw_surface *surf;
- DWORD match_flags = Flags & (DDENUMSURFACES_ALL | DDENUMSURFACES_NOMATCH | DDENUMSURFACES_MATCH);
+ BOOL all, nomatch;
+ DDSURFACEDESC2 desc;
+ struct list *entry, *entry2;
TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
iface, Flags, DDSD, Context, Callback);
+ all = Flags & DDENUMSURFACES_ALL;
+ nomatch = Flags & DDENUMSURFACES_NOMATCH;
+
if (!Callback)
return DDERR_INVALIDPARAMS;
- if (Flags & DDENUMSURFACES_CANBECREATED)
- {
- IDirectDrawSurface7 *surface;
- DDSURFACEDESC2 testdesc;
- HRESULT hr;
-
- if (match_flags != DDENUMSURFACES_MATCH)
- return DDERR_INVALIDPARAMS;
-
- if (!DDSD)
- return DDERR_INVALIDPARAMS;
+ wined3d_mutex_lock();
- memcpy(&testdesc, DDSD, sizeof(testdesc));
- if (!(testdesc.dwFlags & DDSD_WIDTH))
- {
- testdesc.dwFlags |= DDSD_WIDTH;
- testdesc.dwWidth = 512;
- }
- if (!(testdesc.dwFlags & DDSD_HEIGHT))
- {
- testdesc.dwFlags |= DDSD_HEIGHT;
- testdesc.dwHeight = 512;
- }
+ /* Use the _SAFE enumeration, the app may destroy enumerated surfaces */
+ LIST_FOR_EACH_SAFE(entry, entry2, &ddraw->surface_list)
+ {
+ surf = LIST_ENTRY(entry, struct ddraw_surface, surface_list_entry);
- hr = IDirectDraw7_CreateSurface(iface, &testdesc, &surface, NULL);
- if (SUCCEEDED(hr))
+ if (!surf->iface_count)
{
- surf = unsafe_impl_from_IDirectDrawSurface7(surface);
- Callback(NULL, &surf->surface_desc, Context);
- IDirectDrawSurface7_Release(surface);
+ WARN("Not enumerating surface %p because it doesn't have any references.\n", surf);
+ continue;
}
- else
- ERR("Failed to create surface, hr %#x.\n", hr);
- }
- else if (Flags & DDENUMSURFACES_DOESEXIST)
- {
- BOOL all, nomatch;
- DDSURFACEDESC2 desc;
- struct list *entry, *entry2;
-
- /* a combination of match flags is not allowed */
- if (match_flags != 0 &&
- match_flags != DDENUMSURFACES_ALL &&
- match_flags != DDENUMSURFACES_MATCH &&
- match_flags != DDENUMSURFACES_NOMATCH)
- return DDERR_INVALIDPARAMS;
-
- all = (Flags & DDENUMSURFACES_ALL) != 0;
- nomatch = (Flags & DDENUMSURFACES_NOMATCH) != 0;
- if (!all && !DDSD)
- return DDERR_INVALIDPARAMS;
-
- wined3d_mutex_lock();
-
- /* Use the _SAFE enumeration, the app may destroy enumerated surfaces */
- LIST_FOR_EACH_SAFE(entry, entry2, &ddraw->surface_list)
+ if (all || (nomatch != ddraw_match_surface_desc(DDSD, &surf->surface_desc)))
{
- surf = LIST_ENTRY(entry, struct ddraw_surface, surface_list_entry);
-
- if (!surf->iface_count)
+ TRACE("Enumerating surface %p.\n", surf);
+ desc = surf->surface_desc;
+ IDirectDrawSurface7_AddRef(&surf->IDirectDrawSurface7_iface);
+ if (Callback(&surf->IDirectDrawSurface7_iface, &desc, Context) != DDENUMRET_OK)
{
- WARN("Not enumerating surface %p because it doesn't have any references.\n", surf);
- continue;
- }
-
- if (all || (nomatch != ddraw_match_surface_desc(DDSD, &surf->surface_desc)))
- {
- TRACE("Enumerating surface %p.\n", surf);
- desc = surf->surface_desc;
- IDirectDrawSurface7_AddRef(&surf->IDirectDrawSurface7_iface);
- if (Callback(&surf->IDirectDrawSurface7_iface, &desc, Context) != DDENUMRET_OK)
- {
- wined3d_mutex_unlock();
- return DD_OK;
- }
+ wined3d_mutex_unlock();
+ return DD_OK;
}
}
-
- wined3d_mutex_unlock();
}
- else
- return DDERR_INVALIDPARAMS;
+
+ wined3d_mutex_unlock();
return DD_OK;
}
{
struct ddraw *ddraw = impl_from_IDirect3D7(iface);
D3DDEVICEDESC7 device_desc7;
- DWORD dev_caps;
HRESULT hr;
size_t i;
return hr;
}
- dev_caps = device_desc7.dwDevCaps;
-
for (i = 0; i < sizeof(device_list7)/sizeof(device_list7[0]); i++)
{
HRESULT ret;
device_desc7.deviceGUID = *device_list7[i].device_guid;
- device_desc7.dwDevCaps = dev_caps & ~device_list7[i].remove_caps;
-
ret = callback(device_list7[i].interface_name, device_list7[i].device_name, &device_desc7, context);
if (ret != DDENUMRET_OK)
{
if (!fds || !fdr) return DDERR_INVALIDPARAMS;
- if (fds->dwSize != sizeof(D3DFINDDEVICESEARCH) || (fdr->dwSize != sizeof(D3DFINDDEVICERESULT1) &&
- fdr->dwSize != sizeof(D3DFINDDEVICERESULT2) && fdr->dwSize != sizeof(D3DFINDDEVICERESULT)))
+ if (fds->dwSize != sizeof(D3DFINDDEVICESEARCH)
+ || fdr->dwSize != sizeof(D3DFINDDEVICERESULT))
return DDERR_INVALIDPARAMS;
if ((fds->dwFlags & D3DFDS_COLORMODEL)
/* Now return our own GUID */
ddraw_d3dcaps1_from_7(&desc1, &desc7);
fdr->guid = IID_D3DDEVICE_WineD3D;
-
- if (fdr->dwSize == sizeof(D3DFINDDEVICERESULT1))
- {
- D3DFINDDEVICERESULT1 *fdr1 = (D3DFINDDEVICERESULT1 *)fdr;
- memcpy(&fdr1->ddHwDesc, &desc1, sizeof(fdr1->ddHwDesc));
- memcpy(&fdr1->ddSwDesc, &desc1, sizeof(fdr1->ddSwDesc));
- }
- else if (fdr->dwSize == sizeof(D3DFINDDEVICERESULT2))
- {
- D3DFINDDEVICERESULT2 *fdr2 = (D3DFINDDEVICERESULT2 *)fdr;
- memcpy(&fdr2->ddHwDesc, &desc1, sizeof(fdr2->ddHwDesc));
- memcpy(&fdr2->ddSwDesc, &desc1, sizeof(fdr2->ddSwDesc));
- }
- else
- {
- fdr->ddHwDesc = desc1;
- fdr->ddSwDesc = desc1;
- }
+ fdr->ddHwDesc = desc1;
+ fdr->ddSwDesc = desc1;
TRACE("Returning Wine's wined3d device with (undumped) capabilities.\n");
TRACE("iface %p, riid %s, surface %p, device %p.\n", iface, debugstr_guid(riid), surface, device);
wined3d_mutex_lock();
- if (SUCCEEDED(hr = d3d_device_create(ddraw, riid, target, (IUnknown *)surface, 7, &object, NULL)))
+ if (SUCCEEDED(hr = d3d_device_create(ddraw, target, (IUnknown *)surface, 7, &object, NULL)))
{
*device = &object->IDirect3DDevice7_iface;
}
return CLASS_E_NOAGGREGATION;
wined3d_mutex_lock();
- if (SUCCEEDED(hr = d3d_device_create(ddraw, riid, surface_impl, (IUnknown *)surface, 3, &device_impl, NULL)))
+ if (SUCCEEDED(hr = d3d_device_create(ddraw, surface_impl, (IUnknown *)surface, 3, &device_impl, NULL)))
{
*device = &device_impl->IDirect3DDevice3_iface;
}
iface, debugstr_guid(riid), surface, device);
wined3d_mutex_lock();
- if (SUCCEEDED(hr = d3d_device_create(ddraw, riid, surface_impl, (IUnknown *)surface, 2, &device_impl, NULL)))
+ if (SUCCEEDED(hr = d3d_device_create(ddraw, surface_impl, (IUnknown *)surface, 2, &device_impl, NULL)))
{
*device = &device_impl->IDirect3DDevice2_iface;
}
ddraw2_GetAvailableVidMem,
};
-static struct IDirectDrawVtbl ddraw1_vtbl =
+static const struct IDirectDrawVtbl ddraw1_vtbl =
{
/* IUnknown */
ddraw1_QueryInterface,
WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
+#define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
+
extern const struct wined3d_parent_ops ddraw_null_wined3d_parent_ops DECLSPEC_HIDDEN;
extern DWORD force_refresh_rate DECLSPEC_HIDDEN;
#define DDRAW_NO3D 0x00000008
#define DDRAW_SCL_DDRAW1 0x00000010
#define DDRAW_SCL_RECURSIVE 0x00000020
-#define DDRAW_GDI_FLIP 0x00000040
#define DDRAW_STRIDE_ALIGNMENT 8
#define DDRAW_WINED3D_FLAGS (WINED3D_LEGACY_DEPTH_BIAS | WINED3D_VIDMEM_ACCOUNTING \
| WINED3D_RESTORE_MODE_ON_ACTIVATE | WINED3D_FOCUS_MESSAGES | WINED3D_PIXEL_CENTER_INTEGER \
| WINED3D_LEGACY_UNBOUND_RESOURCE_COLOR | WINED3D_NO_PRIMITIVE_RESTART \
- | WINED3D_LEGACY_CUBEMAP_FILTERING | WINED3D_LIMIT_VIEWPORT)
+ | WINED3D_LEGACY_CUBEMAP_FILTERING)
enum ddraw_device_state
{
IUnknown IUnknown_inner;
LONG ref;
UINT version;
- BOOL hw;
IUnknown *outer_unknown;
struct wined3d_device *wined3d_device;
/* Handle management */
struct ddraw_handle_table handle_table;
D3DMATRIXHANDLE world, proj, view;
+
+ struct wined3d_vec4 user_clip_planes[D3DMAXUSERCLIPPLANES];
};
-HRESULT d3d_device_create(struct ddraw *ddraw, const GUID *guid, struct ddraw_surface *target, IUnknown *rt_iface,
+HRESULT d3d_device_create(struct ddraw *ddraw, struct ddraw_surface *target, IUnknown *rt_iface,
UINT version, struct d3d_device **device, IUnknown *outer_unknown) DECLSPEC_HIDDEN;
enum wined3d_depth_buffer_type d3d_device_update_depth_stencil(struct d3d_device *device) DECLSPEC_HIDDEN;
* IDirect3DDevice2::EnumTextureformats
*
* EnumTextureFormats for Version 1 and 2, see
- * IDirect3DDevice7::EnumTexureFormats for a more detailed description.
+ * IDirect3DDevice7::EnumTextureFormats for a more detailed description.
*
* This version has a different callback and does not enumerate FourCC
* formats
return DDERR_INVALIDCAPS;
}
- if (device->hw && !(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY))
+ if (!(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY))
{
WARN("Surface %p is not in video memory.\n", target_impl);
wined3d_mutex_unlock();
return DDERR_INVALIDPIXELFORMAT;
}
- if (device->hw && !(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY))
+ if (!(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY))
{
WARN("Surface %p is not in video memory.\n", target_impl);
IDirectDrawSurface4_AddRef(target);
return DDERR_INVALIDPIXELFORMAT;
}
- if (device->hw && !(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY))
+ if (!(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY))
{
WARN("Surface %p is not in video memory.\n", target_impl);
IDirectDrawSurface_AddRef(target);
static HRESULT d3d_device7_SetClipPlane(IDirect3DDevice7 *iface, DWORD idx, D3DVALUE *plane)
{
struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
+ const struct wined3d_vec4 *wined3d_plane;
HRESULT hr;
TRACE("iface %p, idx %u, plane %p.\n", iface, idx, plane);
if (!plane)
return DDERR_INVALIDPARAMS;
+ wined3d_plane = (struct wined3d_vec4 *)plane;
+
wined3d_mutex_lock();
- hr = wined3d_device_set_clip_plane(device->wined3d_device, idx, (struct wined3d_vec4 *)plane);
+ hr = wined3d_device_set_clip_plane(device->wined3d_device, idx, wined3d_plane);
+ if (idx < ARRAY_SIZE(device->user_clip_planes))
+ {
+ device->user_clip_planes[idx] = *wined3d_plane;
+ if (hr == WINED3DERR_INVALIDCALL)
+ {
+ WARN("Clip plane %u is not supported.\n", idx);
+ hr = D3D_OK;
+ }
+ }
wined3d_mutex_unlock();
return hr;
static HRESULT d3d_device7_GetClipPlane(IDirect3DDevice7 *iface, DWORD idx, D3DVALUE *plane)
{
struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
+ struct wined3d_vec4 *wined3d_plane;
HRESULT hr;
TRACE("iface %p, idx %u, plane %p.\n", iface, idx, plane);
if (!plane)
return DDERR_INVALIDPARAMS;
+ wined3d_plane = (struct wined3d_vec4 *)plane;
+
wined3d_mutex_lock();
- hr = wined3d_device_get_clip_plane(device->wined3d_device, idx, (struct wined3d_vec4 *)plane);
+ hr = wined3d_device_get_clip_plane(device->wined3d_device, idx, wined3d_plane);
+ if (hr == WINED3DERR_INVALIDCALL && idx < ARRAY_SIZE(device->user_clip_planes))
+ {
+ WARN("Clip plane %u is not supported.\n", idx);
+ *wined3d_plane = device->user_clip_planes[idx];
+ hr = D3D_OK;
+ }
wined3d_mutex_unlock();
return hr;
return WINED3D_ZB_TRUE;
}
-static HRESULT d3d_device_init(struct d3d_device *device, struct ddraw *ddraw, BOOL hw,
+static HRESULT d3d_device_init(struct d3d_device *device, struct ddraw *ddraw,
struct ddraw_surface *target, IUnknown *rt_iface, UINT version, IUnknown *outer_unknown)
{
static const D3DMATRIX ident =
device->IUnknown_inner.lpVtbl = &d3d_device_inner_vtbl;
device->ref = 1;
device->version = version;
- device->hw = hw;
if (outer_unknown)
device->outer_unknown = outer_unknown;
return D3D_OK;
}
-HRESULT d3d_device_create(struct ddraw *ddraw, const GUID *guid, struct ddraw_surface *target, IUnknown *rt_iface,
+HRESULT d3d_device_create(struct ddraw *ddraw, struct ddraw_surface *target, IUnknown *rt_iface,
UINT version, struct d3d_device **device, IUnknown *outer_unknown)
{
struct d3d_device *object;
- BOOL hw = TRUE;
HRESULT hr;
- TRACE("ddraw %p, guid %s, target %p, version %u, device %p, outer_unknown %p.\n",
- ddraw, debugstr_guid(guid), target, version, device, outer_unknown);
-
- if (IsEqualGUID(guid, &IID_IDirect3DRGBDevice))
- hw = FALSE;
+ TRACE("ddraw %p, target %p, version %u, device %p, outer_unknown %p.\n",
+ ddraw, target, version, device, outer_unknown);
if (!(target->surface_desc.ddsCaps.dwCaps & DDSCAPS_3DDEVICE)
|| (target->surface_desc.ddsCaps.dwCaps & DDSCAPS_ZBUFFER))
return DDERR_NOPALETTEATTACHED;
}
- if (hw && !(target->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY))
+ if (!(target->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY))
{
WARN("Surface %p is not in video memory.\n", target);
return D3DERR_SURFACENOTINVIDMEM;
return DDERR_OUTOFMEMORY;
}
- if (FAILED(hr = d3d_device_init(object, ddraw, hw, target, rt_iface, version, outer_unknown)))
+ if (FAILED(hr = d3d_device_init(object, ddraw, target, rt_iface, version, outer_unknown)))
{
WARN("Failed to initialize device, hr %#x.\n", hr);
HeapFree(GetProcessHeap(), 0, object);
ci->wStart, ci->wDest, ci->dwCount, ci->dwFlags);
if (ci->dwFlags & D3DPROCESSVERTICES_UPDATEEXTENTS)
- {
- static int once;
- if (!once++) FIXME("D3DPROCESSVERTICES_UPDATEEXTENTS not implemented.\n");
- }
+ FIXME("D3DPROCESSVERTICES_UPDATEEXTENTS not implemented.\n");
if (ci->dwFlags & D3DPROCESSVERTICES_NOCOLOR)
FIXME("D3DPROCESSVERTICES_NOCOLOR not implemented.\n");
* to support windowless rendering first. */
HRESULT ddraw_surface_update_frontbuffer(struct ddraw_surface *surface, const RECT *rect, BOOL read)
{
- struct ddraw *ddraw = surface->ddraw;
HDC surface_dc, screen_dc;
int x, y, w, h;
HRESULT hr;
if (w <= 0 || h <= 0)
return DD_OK;
- if (ddraw->swapchain_window && !(ddraw->flags & DDRAW_GDI_FLIP))
+ if (surface->ddraw->swapchain_window)
{
/* Nothing to do, we control the frontbuffer, or at least the parts we
* care about. */
if (read)
return DD_OK;
- return wined3d_texture_blt(ddraw->wined3d_frontbuffer, 0, rect,
+ return wined3d_texture_blt(surface->ddraw->wined3d_frontbuffer, 0, rect,
surface->wined3d_texture, surface->sub_resource_idx, rect, 0, NULL, WINED3D_TEXF_POINT);
}
{
HRESULT hr;
- if (FAILED(hr = d3d_device_create(This->ddraw, riid, This, (IUnknown *)&This->IDirectDrawSurface_iface,
+ if (FAILED(hr = d3d_device_create(This->ddraw, This, (IUnknown *)&This->IDirectDrawSurface_iface,
1, &This->device1, (IUnknown *)&This->IDirectDrawSurface_iface)))
{
This->device1 = NULL;
return impl_from_IDirectDrawSurface7(next_level);
}
-static BOOL compare_format(DDPIXELFORMAT *format1, DDPIXELFORMAT *format2)
-{
- if ((format1->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_FOURCC)) !=
- (format2->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_FOURCC)))
- return FALSE;
-
- if (format1->dwFlags & (DDPF_RGB|DDPF_YUV))
- {
- if (!(format1->dwFlags & DDPF_ALPHA))
- {
- /* The RGB and YUV bits are stored in the same fields */
- if (format1->u1.dwRGBBitCount != format2->u1.dwRGBBitCount)
- return FALSE;
-
- if (format1->u2.dwRBitMask != format2->u2.dwRBitMask)
- return FALSE;
-
- if (format1->u3.dwGBitMask != format2->u3.dwGBitMask)
- return FALSE;
-
- if (format1->u4.dwBBitMask != format2->u4.dwBBitMask)
- return FALSE;
- }
-
- if (format1->dwFlags & (DDPF_ALPHAPIXELS | DDPF_ALPHA))
- {
- if (format1->u5.dwRGBAlphaBitMask != format2->u5.dwRGBAlphaBitMask)
- return FALSE;
- }
- }
-
- if (format1->dwFlags & DDPF_FOURCC)
- {
- if (format1->dwFourCC != format2->dwFourCC)
- return FALSE;
- }
-
- return TRUE;
-}
-
/*****************************************************************************
* IDirect3DTexture2::Load
*
{
struct ddraw_surface *dst_surface = impl_from_IDirect3DTexture2(iface);
struct ddraw_surface *src_surface = unsafe_impl_from_IDirect3DTexture2(src_texture);
- RECT src_rect, dst_rect;
+ struct wined3d_resource *dst_resource, *src_resource;
HRESULT hr;
TRACE("iface %p, src_texture %p.\n", iface, src_texture);
wined3d_mutex_lock();
+ dst_resource = wined3d_texture_get_resource(dst_surface->wined3d_texture);
+ src_resource = wined3d_texture_get_resource(src_surface->wined3d_texture);
+
+ if (((src_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP)
+ != (dst_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP))
+ || (src_surface->surface_desc.u2.dwMipMapCount != dst_surface->surface_desc.u2.dwMipMapCount))
+ {
+ ERR("Trying to load surfaces with different mip-map counts.\n");
+ }
+
for (;;)
{
- DDSURFACEDESC *src_desc = (DDSURFACEDESC *)&src_surface->surface_desc;
+ struct ddraw_palette *dst_pal, *src_pal;
+ DDSURFACEDESC *src_desc, *dst_desc;
TRACE("Copying surface %p to surface %p.\n", src_surface, dst_surface);
- if (compare_format(&src_surface->surface_desc.u4.ddpfPixelFormat,
- &dst_surface->surface_desc.u4.ddpfPixelFormat))
- {
- struct ddraw_palette *dst_pal, *src_pal;
+ /* Suppress the ALLOCONLOAD flag */
+ dst_surface->surface_desc.ddsCaps.dwCaps &= ~DDSCAPS_ALLOCONLOAD;
- /* Get the palettes */
- dst_pal = dst_surface->palette;
- src_pal = src_surface->palette;
+ /* Get the palettes */
+ dst_pal = dst_surface->palette;
+ src_pal = src_surface->palette;
- if (src_pal)
- {
- PALETTEENTRY palent[256];
+ if (src_pal)
+ {
+ PALETTEENTRY palent[256];
- if (!dst_pal)
- {
- wined3d_mutex_unlock();
- return DDERR_NOPALETTEATTACHED;
- }
- IDirectDrawPalette_GetEntries(&src_pal->IDirectDrawPalette_iface, 0, 0, 256, palent);
- IDirectDrawPalette_SetEntries(&dst_pal->IDirectDrawPalette_iface, 0, 0, 256, palent);
+ if (!dst_pal)
+ {
+ wined3d_mutex_unlock();
+ return DDERR_NOPALETTEATTACHED;
}
+ IDirectDrawPalette_GetEntries(&src_pal->IDirectDrawPalette_iface, 0, 0, 256, palent);
+ IDirectDrawPalette_SetEntries(&dst_pal->IDirectDrawPalette_iface, 0, 0, 256, palent);
+ }
+ /* Copy one surface on the other */
+ dst_desc = (DDSURFACEDESC *)&(dst_surface->surface_desc);
+ src_desc = (DDSURFACEDESC *)&(src_surface->surface_desc);
+
+ if ((src_desc->dwWidth != dst_desc->dwWidth) || (src_desc->dwHeight != dst_desc->dwHeight))
+ {
+ /* Should also check for same pixel format, u1.lPitch, ... */
+ ERR("Error in surface sizes.\n");
+ wined3d_mutex_unlock();
+ return D3DERR_TEXTURE_LOAD_FAILED;
+ }
+ else
+ {
+ struct wined3d_map_desc src_map_desc, dst_map_desc;
+
+ /* Copy the src blit color key if the source has one, don't erase
+ * the destination's ckey if the source has none */
if (src_desc->dwFlags & DDSD_CKSRCBLT)
{
IDirectDrawSurface7_SetColorKey(&dst_surface->IDirectDrawSurface7_iface,
DDCKEY_SRCBLT, &src_desc->ddckCKSrcBlt);
}
- }
- else
- {
- if (src_desc->dwFlags & DDSD_CKSRCBLT)
- return E_FAIL;
- }
- /* Suppress the ALLOCONLOAD flag */
- dst_surface->surface_desc.ddsCaps.dwCaps &= ~DDSCAPS_ALLOCONLOAD;
+ if (FAILED(hr = wined3d_resource_map(src_resource,
+ src_surface->sub_resource_idx, &src_map_desc, NULL, 0)))
+ {
+ ERR("Failed to lock source surface, hr %#x.\n", hr);
+ wined3d_mutex_unlock();
+ return D3DERR_TEXTURE_LOAD_FAILED;
+ }
- SetRect(&src_rect, 0, 0, src_surface->surface_desc.dwWidth, src_surface->surface_desc.dwHeight);
- SetRect(&dst_rect, 0, 0, dst_surface->surface_desc.dwWidth, dst_surface->surface_desc.dwHeight);
+ if (FAILED(hr = wined3d_resource_map(dst_resource,
+ dst_surface->sub_resource_idx, &dst_map_desc, NULL, 0)))
+ {
+ ERR("Failed to lock destination surface, hr %#x.\n", hr);
+ wined3d_resource_unmap(src_resource, src_surface->sub_resource_idx);
+ wined3d_mutex_unlock();
+ return D3DERR_TEXTURE_LOAD_FAILED;
+ }
- hr = wined3d_texture_blt(dst_surface->wined3d_texture, dst_surface->sub_resource_idx, &dst_rect,
- src_surface->wined3d_texture, src_surface->sub_resource_idx, &src_rect,
- 0, NULL, WINED3D_TEXF_LINEAR);
- if (FAILED(hr))
- {
- ERR("Failed to blit surface, hr %#x.\n", hr);
- wined3d_mutex_unlock();
- return hr;
+ if (dst_surface->surface_desc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC)
+ memcpy(dst_map_desc.data, src_map_desc.data, src_surface->surface_desc.u1.dwLinearSize);
+ else
+ memcpy(dst_map_desc.data, src_map_desc.data, src_map_desc.row_pitch * src_desc->dwHeight);
+
+ wined3d_resource_unmap(dst_resource, dst_surface->sub_resource_idx);
+ wined3d_resource_unmap(src_resource, src_surface->sub_resource_idx);
}
if (src_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP)
else
dst_surface = NULL;
- if (src_surface && !dst_surface)
- return DDERR_NOTFOUND;
-
if (!src_surface || !dst_surface)
+ {
+ if (src_surface != dst_surface)
+ ERR("Loading surface with different mipmap structure.\n");
break;
+ }
}
wined3d_mutex_unlock();
ddraw_surface2_PageUnlock,
};
-static struct IDirectDrawSurfaceVtbl ddraw_surface1_vtbl =
+static const struct IDirectDrawSurfaceVtbl ddraw_surface1_vtbl =
{
/* IUnknown */
ddraw_surface1_QueryInterface,
HeapFree(GetProcessHeap(), 0, texture);
return hr_ddraw_from_wined3d(hr);
}
+
+ wined3d_device_set_render_state(ddraw->wined3d_device, WINED3D_RS_ZENABLE,
+ !!swapchain_desc.enable_auto_depth_stencil);
}
}
if (desc->ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY)
{
- /*
- * The ddraw RGB device allows to use system memory surfaces as rendering target.
- * This does not cause problems because the RGB device does software rasterization
- * though it will fail with hardware accelerated ddraw. In order to be partially
- * compatible with games requesting explicitly the RGB device, we ignore the
- * specified location and try to create rendering targets in video memory if
- * possible.
- */
- if ((desc->ddsCaps.dwCaps & DDSCAPS_3DDEVICE) &&
- SUCCEEDED(hr = wined3d_check_device_format(ddraw->wined3d, WINED3DADAPTER_DEFAULT,
- WINED3D_DEVICE_TYPE_HAL, mode.format_id, WINED3DUSAGE_RENDERTARGET,
- WINED3D_RTYPE_TEXTURE_2D, wined3d_desc.format)))
- {
- FIXME("Application wants to create rendering target in system memory, using video memory instead\n");
- wined3d_desc.usage |= WINED3DUSAGE_RENDERTARGET;
- }
- else
- wined3d_desc.pool = WINED3D_POOL_SYSTEM_MEM;
+ wined3d_desc.pool = WINED3D_POOL_SYSTEM_MEM;
}
else
{
TRACE("iface %p, flags %#x, data %p, data_size %p.\n", iface, flags, data, data_size);
+ if (buffer->version != 7)
+ flags &= ~(DDLOCK_NOOVERWRITE | DDLOCK_DISCARDCONTENTS);
+
/* Writeonly: Pointless. Event: Unsupported by native according to the sdk
* nosyslock: Not applicable
*/
* SrcIndex: Index of the first vertex in the src buffer to process
* D3DDevice: Device to use for transformation
* Flags: 0 for default, D3DPV_DONOTCOPYDATA to prevent copying
- * unchaned vertices
+ * unchanged vertices
*
* Returns:
* D3D_OK on success
/* IDirect3DViewport and IDirect3DViewport3 use the same iface. */
if (!iface) return NULL;
assert(iface->lpVtbl == (IDirect3DViewport2Vtbl *)&d3d_viewport_vtbl);
- return CONTAINING_RECORD((IDirect3DViewport3 *)iface, struct d3d_viewport, IDirect3DViewport3_iface);
+ return CONTAINING_RECORD(iface, struct d3d_viewport, IDirect3DViewport3_iface);
}
struct d3d_viewport *unsafe_impl_from_IDirect3DViewport(IDirect3DViewport *iface)
/* IDirect3DViewport and IDirect3DViewport3 use the same iface. */
if (!iface) return NULL;
assert(iface->lpVtbl == (IDirect3DViewportVtbl *)&d3d_viewport_vtbl);
- return CONTAINING_RECORD((IDirect3DViewport3 *)iface, struct d3d_viewport, IDirect3DViewport3_iface);
+ return CONTAINING_RECORD(iface, struct d3d_viewport, IDirect3DViewport3_iface);
}
void d3d_viewport_init(struct d3d_viewport *viewport, struct ddraw *ddraw)
reactos/dll/directx/wine/d3drm # Synced to WineStaging-2.16
reactos/dll/directx/wine/d3dx9_24 => 43 # Synced to WineStaging-2.16
reactos/dll/directx/wine/d3dxof # Synced to WineStaging-2.9
-reactos/dll/directx/wine/ddraw # Synced to WineStaging-2.16
+reactos/dll/directx/wine/ddraw # Synced to Wine-3.0
reactos/dll/directx/wine/devenum # Synced to WineStaging-2.9
reactos/dll/directx/wine/dinput # Synced to WineStaging-2.16
reactos/dll/directx/wine/dinput8 # Synced to WineStaging-2.9
projects / reactos.git / commitdiff