?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ddraw: Clear DDSD_LPSURFACE after surface creation.
[wine/multimedia.git] / dlls / ddraw / surface.c
blobbf49e153c99f77317820ef38e9b9a15aa8a211b2
1 /* DirectDraw Surface Implementation
2 *
3 * Copyright (c) 1997-2000 Marcus Meissner
4 * Copyright (c) 1998-2000 Lionel Ulmer
5 * Copyright (c) 2000-2001 TransGaming Technologies Inc.
6 * Copyright (c) 2006 Stefan Dösinger
7 * Copyright (c) 2011 Ričardas Barkauskas for CodeWeavers
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 #include "config.h"
25 #include "wine/port.h"
26
27 #include "ddraw_private.h"
28
29 WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
30
31 static struct ddraw_surface *unsafe_impl_from_IDirectDrawSurface2(IDirectDrawSurface2 *iface);
32 static struct ddraw_surface *unsafe_impl_from_IDirectDrawSurface3(IDirectDrawSurface3 *iface);
33
34 static inline struct ddraw_surface *impl_from_IDirectDrawGammaControl(IDirectDrawGammaControl *iface)
35 {
36 return CONTAINING_RECORD(iface, struct ddraw_surface, IDirectDrawGammaControl_iface);
37 }
38
39 /* This is slow, of course. Also, in case of locks, we can't prevent other
40 * applications from drawing to the screen while we've locked the frontbuffer.
41 * We'd like to do this in wined3d instead, but for that to work wined3d needs
42 * to support windowless rendering first. */
43 static HRESULT ddraw_surface_update_frontbuffer(struct ddraw_surface *surface, const RECT *rect, BOOL read)
44 {
45 HDC surface_dc, screen_dc;
46 int x, y, w, h;
47 HRESULT hr;
48 BOOL ret;
49
50 if (!rect)
51 {
52 x = 0;
53 y = 0;
54 w = surface->surface_desc.dwWidth;
55 h = surface->surface_desc.dwHeight;
56 }
57 else
58 {
59 x = rect->left;
60 y = rect->top;
61 w = rect->right - rect->left;
62 h = rect->bottom - rect->top;
63 }
64
65 if (w <= 0 || h <= 0)
66 return DD_OK;
67
68 if (surface->ddraw->swapchain_window)
69 {
70 /* Nothing to do, we control the frontbuffer, or at least the parts we
71 * care about. */
72 if (read)
73 return DD_OK;
74
75 return wined3d_surface_blt(surface->ddraw->wined3d_frontbuffer, rect,
76 surface->wined3d_surface, rect, 0, NULL, WINED3D_TEXF_POINT);
77 }
78
79 if (FAILED(hr = wined3d_surface_getdc(surface->wined3d_surface, &surface_dc)))
80 {
81 ERR("Failed to get surface DC, hr %#x.\n", hr);
82 return hr;
83 }
84
85 if (!(screen_dc = GetDC(NULL)))
86 {
87 wined3d_surface_releasedc(surface->wined3d_surface, surface_dc);
88 ERR("Failed to get screen DC.\n");
89 return E_FAIL;
90 }
91
92 if (read)
93 ret = BitBlt(surface_dc, x, y, w, h,
94 screen_dc, x, y, SRCCOPY);
95 else
96 ret = BitBlt(screen_dc, x, y, w, h,
97 surface_dc, x, y, SRCCOPY);
98
99 ReleaseDC(NULL, screen_dc);
100 wined3d_surface_releasedc(surface->wined3d_surface, surface_dc);
101
102 if (!ret)
103 {
104 ERR("Failed to blit to/from screen.\n");
105 return E_FAIL;
106 }
107
108 return DD_OK;
109 }
110
111 /*****************************************************************************
112 * IUnknown parts follow
113 *****************************************************************************/
114
115 /*****************************************************************************
116 * IDirectDrawSurface7::QueryInterface
117 *
118 * A normal QueryInterface implementation. For QueryInterface rules
119 * see ddraw.c, IDirectDraw7::QueryInterface. This method
120 * can Query IDirectDrawSurface interfaces in all version, IDirect3DTexture
121 * in all versions, the IDirectDrawGammaControl interface and it can
122 * create an IDirect3DDevice. (Uses IDirect3D7::CreateDevice)
123 *
124 * Params:
125 * riid: The interface id queried for
126 * obj: Address to write the pointer to
127 *
128 * Returns:
129 * S_OK on success
130 * E_NOINTERFACE if the requested interface wasn't found
131 *
132 *****************************************************************************/
133 static HRESULT WINAPI ddraw_surface7_QueryInterface(IDirectDrawSurface7 *iface, REFIID riid, void **obj)
134 {
135 struct ddraw_surface *This = impl_from_IDirectDrawSurface7(iface);
136
137 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), obj);
138
139 /* According to COM docs, if the QueryInterface fails, obj should be set to NULL */
140 *obj = NULL;
141
142 if(!riid)
143 return DDERR_INVALIDPARAMS;
144
145 if (IsEqualGUID(riid, &IID_IDirectDrawSurface7))
146 {
147 IDirectDrawSurface7_AddRef(iface);
148 *obj = iface;
149 TRACE("(%p) returning IDirectDrawSurface7 interface at %p\n", This, *obj);
150 return S_OK;
151 }
152
153 if (IsEqualGUID(riid, &IID_IDirectDrawSurface4))
154 {
155 IDirectDrawSurface4_AddRef(&This->IDirectDrawSurface4_iface);
156 *obj = &This->IDirectDrawSurface4_iface;
157 TRACE("(%p) returning IDirectDrawSurface4 interface at %p\n", This, *obj);
158 return S_OK;
159 }
160
161 if (IsEqualGUID(riid, &IID_IDirectDrawSurface3))
162 {
163 IDirectDrawSurface3_AddRef(&This->IDirectDrawSurface3_iface);
164 *obj = &This->IDirectDrawSurface3_iface;
165 TRACE("(%p) returning IDirectDrawSurface3 interface at %p\n", This, *obj);
166 return S_OK;
167 }
168
169 if (IsEqualGUID(riid, &IID_IDirectDrawSurface2))
170 {
171 IDirectDrawSurface2_AddRef(&This->IDirectDrawSurface2_iface);
172 *obj = &This->IDirectDrawSurface2_iface;
173 TRACE("(%p) returning IDirectDrawSurface2 interface at %p\n", This, *obj);
174 return S_OK;
175 }
176
177 if (IsEqualGUID(riid, &IID_IDirectDrawSurface)
178 || IsEqualGUID(riid, &IID_IUnknown))
179 {
180 IDirectDrawSurface_AddRef(&This->IDirectDrawSurface_iface);
181 *obj = &This->IDirectDrawSurface_iface;
182 TRACE("(%p) returning IDirectDrawSurface interface at %p\n", This, *obj);
183 return S_OK;
184 }
185
186 if (IsEqualGUID(riid, &IID_IDirectDrawGammaControl))
187 {
188 IDirectDrawGammaControl_AddRef(&This->IDirectDrawGammaControl_iface);
189 *obj = &This->IDirectDrawGammaControl_iface;
190 TRACE("(%p) returning IDirectDrawGammaControl interface at %p\n", This, *obj);
191 return S_OK;
192 }
193
194 if (IsEqualGUID(riid, &IID_IDirectDrawColorControl))
195 {
196 WARN("Color control not implemented.\n");
197 *obj = NULL;
198 return E_NOINTERFACE;
199 }
200
201 if (This->version != 7)
202 {
203 if (IsEqualGUID(riid, &IID_D3DDEVICE_WineD3D)
204 || IsEqualGUID(riid, &IID_IDirect3DHALDevice)
205 || IsEqualGUID(riid, &IID_IDirect3DRGBDevice))
206 {
207 wined3d_mutex_lock();
208 if (!This->device1)
209 {
210 HRESULT hr;
211
212 if (FAILED(hr = d3d_device_create(This->ddraw, This, (IUnknown *)&This->IDirectDrawSurface_iface,
213 1, &This->device1, (IUnknown *)&This->IDirectDrawSurface_iface)))
214 {
215 This->device1 = NULL;
216 wined3d_mutex_unlock();
217 WARN("Failed to create device, hr %#x.\n", hr);
218 return hr;
219 }
220 }
221 wined3d_mutex_unlock();
222
223 IDirect3DDevice_AddRef(&This->device1->IDirect3DDevice_iface);
224 *obj = &This->device1->IDirect3DDevice_iface;
225 return S_OK;
226 }
227
228 if (IsEqualGUID(&IID_IDirect3DTexture2, riid))
229 {
230 IDirect3DTexture2_AddRef(&This->IDirect3DTexture2_iface);
231 *obj = &This->IDirect3DTexture2_iface;
232 return S_OK;
233 }
234
235 if (IsEqualGUID( &IID_IDirect3DTexture, riid ))
236 {
237 IDirect3DTexture2_AddRef(&This->IDirect3DTexture_iface);
238 *obj = &This->IDirect3DTexture_iface;
239 return S_OK;
240 }
241 }
242
243 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
244
245 if (This->version != 7)
246 return E_INVALIDARG;
247
248 return E_NOINTERFACE;
249 }
250
251 static HRESULT WINAPI ddraw_surface4_QueryInterface(IDirectDrawSurface4 *iface, REFIID riid, void **object)
252 {
253 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
254
255 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
256
257 return ddraw_surface7_QueryInterface(&surface->IDirectDrawSurface7_iface, riid, object);
258 }
259
260 static HRESULT WINAPI ddraw_surface3_QueryInterface(IDirectDrawSurface3 *iface, REFIID riid, void **object)
261 {
262 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
263
264 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
265
266 return ddraw_surface7_QueryInterface(&surface->IDirectDrawSurface7_iface, riid, object);
267 }
268
269 static HRESULT WINAPI ddraw_surface2_QueryInterface(IDirectDrawSurface2 *iface, REFIID riid, void **object)
270 {
271 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
272
273 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
274
275 return ddraw_surface7_QueryInterface(&surface->IDirectDrawSurface7_iface, riid, object);
276 }
277
278 static HRESULT WINAPI ddraw_surface1_QueryInterface(IDirectDrawSurface *iface, REFIID riid, void **object)
279 {
280 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
281
282 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
283
284 return ddraw_surface7_QueryInterface(&surface->IDirectDrawSurface7_iface, riid, object);
285 }
286
287 static HRESULT WINAPI ddraw_gamma_control_QueryInterface(IDirectDrawGammaControl *iface,
288 REFIID riid, void **object)
289 {
290 struct ddraw_surface *surface = impl_from_IDirectDrawGammaControl(iface);
291
292 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
293
294 return ddraw_surface7_QueryInterface(&surface->IDirectDrawSurface7_iface, riid, object);
295 }
296
297 static HRESULT WINAPI d3d_texture2_QueryInterface(IDirect3DTexture2 *iface, REFIID riid, void **object)
298 {
299 struct ddraw_surface *surface = impl_from_IDirect3DTexture2(iface);
300
301 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
302
303 return ddraw_surface7_QueryInterface(&surface->IDirectDrawSurface7_iface, riid, object);
304 }
305
306 static HRESULT WINAPI d3d_texture1_QueryInterface(IDirect3DTexture *iface, REFIID riid, void **object)
307 {
308 struct ddraw_surface *surface = impl_from_IDirect3DTexture(iface);
309
310 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
311
312 return ddraw_surface7_QueryInterface(&surface->IDirectDrawSurface7_iface, riid, object);
313 }
314
315 static void ddraw_surface_add_iface(struct ddraw_surface *surface)
316 {
317 ULONG iface_count = InterlockedIncrement(&surface->iface_count);
318 TRACE("%p increasing iface count to %u.\n", surface, iface_count);
319
320 if (iface_count == 1)
321 {
322 if (surface->ifaceToRelease)
323 IUnknown_AddRef(surface->ifaceToRelease);
324 wined3d_mutex_lock();
325 if (surface->wined3d_surface)
326 wined3d_surface_incref(surface->wined3d_surface);
327 if (surface->wined3d_texture)
328 wined3d_texture_incref(surface->wined3d_texture);
329 wined3d_mutex_unlock();
330 }
331 }
332
333 /*****************************************************************************
334 * IDirectDrawSurface7::AddRef
335 *
336 * A normal addref implementation
337 *
338 * Returns:
339 * The new refcount
340 *
341 *****************************************************************************/
342 static ULONG WINAPI ddraw_surface7_AddRef(IDirectDrawSurface7 *iface)
343 {
344 struct ddraw_surface *This = impl_from_IDirectDrawSurface7(iface);
345 ULONG refcount = InterlockedIncrement(&This->ref7);
346
347 TRACE("iface %p increasing refcount to %u.\n", iface, refcount);
348
349 if (refcount == 1)
350 {
351 ddraw_surface_add_iface(This);
352 }
353
354 return refcount;
355 }
356
357 static ULONG WINAPI ddraw_surface4_AddRef(IDirectDrawSurface4 *iface)
358 {
359 struct ddraw_surface *This = impl_from_IDirectDrawSurface4(iface);
360 ULONG refcount = InterlockedIncrement(&This->ref4);
361
362 TRACE("iface %p increasing refcount to %u.\n", iface, refcount);
363
364 if (refcount == 1)
365 {
366 ddraw_surface_add_iface(This);
367 }
368
369 return refcount;
370 }
371
372 static ULONG WINAPI ddraw_surface3_AddRef(IDirectDrawSurface3 *iface)
373 {
374 struct ddraw_surface *This = impl_from_IDirectDrawSurface3(iface);
375 ULONG refcount = InterlockedIncrement(&This->ref3);
376
377 TRACE("iface %p increasing refcount to %u.\n", iface, refcount);
378
379 if (refcount == 1)
380 {
381 ddraw_surface_add_iface(This);
382 }
383
384 return refcount;
385 }
386
387 static ULONG WINAPI ddraw_surface2_AddRef(IDirectDrawSurface2 *iface)
388 {
389 struct ddraw_surface *This = impl_from_IDirectDrawSurface2(iface);
390 ULONG refcount = InterlockedIncrement(&This->ref2);
391
392 TRACE("iface %p increasing refcount to %u.\n", iface, refcount);
393
394 if (refcount == 1)
395 {
396 ddraw_surface_add_iface(This);
397 }
398
399 return refcount;
400 }
401
402 static ULONG WINAPI ddraw_surface1_AddRef(IDirectDrawSurface *iface)
403 {
404 struct ddraw_surface *This = impl_from_IDirectDrawSurface(iface);
405 ULONG refcount = InterlockedIncrement(&This->ref1);
406
407 TRACE("iface %p increasing refcount to %u.\n", iface, refcount);
408
409 if (refcount == 1)
410 {
411 ddraw_surface_add_iface(This);
412 }
413
414 return refcount;
415 }
416
417 static ULONG WINAPI ddraw_gamma_control_AddRef(IDirectDrawGammaControl *iface)
418 {
419 struct ddraw_surface *This = impl_from_IDirectDrawGammaControl(iface);
420 ULONG refcount = InterlockedIncrement(&This->gamma_count);
421
422 TRACE("iface %p increasing refcount to %u.\n", iface, refcount);
423
424 if (refcount == 1)
425 {
426 ddraw_surface_add_iface(This);
427 }
428
429 return refcount;
430 }
431
432 static ULONG WINAPI d3d_texture2_AddRef(IDirect3DTexture2 *iface)
433 {
434 struct ddraw_surface *surface = impl_from_IDirect3DTexture2(iface);
435
436 TRACE("iface %p.\n", iface);
437
438 return IUnknown_AddRef(surface->texture_outer);
439 }
440
441 static ULONG WINAPI d3d_texture1_AddRef(IDirect3DTexture *iface)
442 {
443 struct ddraw_surface *surface = impl_from_IDirect3DTexture(iface);
444
445 TRACE("iface %p.\n", iface);
446
447 return IUnknown_AddRef(surface->texture_outer);
448 }
449
450 static void ddraw_surface_cleanup(struct ddraw_surface *surface)
451 {
452 struct ddraw_surface *surf;
453 UINT i;
454
455 TRACE("surface %p.\n", surface);
456
457 /* The refcount test shows that the palette is detached when the surface
458 * is destroyed. */
459 IDirectDrawSurface7_SetPalette(&surface->IDirectDrawSurface7_iface, NULL);
460
461 /* Loop through all complex attached surfaces and destroy them.
462 *
463 * Yet again, only the root can have more than one complexly attached
464 * surface, all the others have a total of one. */
465 for (i = 0; i < MAX_COMPLEX_ATTACHED; ++i)
466 {
467 if (!surface->complex_array[i])
468 break;
469
470 surf = surface->complex_array[i];
471 surface->complex_array[i] = NULL;
472 if (!surf->is_complex_root)
473 ddraw_surface_cleanup(surf);
474 }
475
476 if (surface->device1)
477 IUnknown_Release(&surface->device1->IUnknown_inner);
478
479 if (surface->iface_count > 1)
480 {
481 /* This can happen when a complex surface is destroyed, because the
482 * 2nd surface was addref()ed when the app called
483 * GetAttachedSurface(). */
484 WARN("Destroying surface %p with refcounts 7: %u 4: %u 3: %u 2: %u 1: %u.\n",
485 surface, surface->ref7, surface->ref4, surface->ref3, surface->ref2, surface->ref1);
486 }
487
488 if (surface->wined3d_texture)
489 wined3d_texture_decref(surface->wined3d_texture);
490 if (surface->wined3d_surface)
491 wined3d_surface_decref(surface->wined3d_surface);
492 }
493
494 ULONG ddraw_surface_release_iface(struct ddraw_surface *This)
495 {
496 ULONG iface_count = InterlockedDecrement(&This->iface_count);
497 TRACE("%p decreasing iface count to %u.\n", This, iface_count);
498
499 if (iface_count == 0)
500 {
501 IUnknown *release_iface = This->ifaceToRelease;
502
503 /* Complex attached surfaces are destroyed implicitly when the root is released */
504 wined3d_mutex_lock();
505 if(!This->is_complex_root)
506 {
507 WARN("(%p) Attempt to destroy a surface that is not a complex root\n", This);
508 wined3d_mutex_unlock();
509 return iface_count;
510 }
511 ddraw_surface_cleanup(This);
512 wined3d_mutex_unlock();
513
514 if (release_iface)
515 IUnknown_Release(release_iface);
516 }
517
518 return iface_count;
519 }
520
521 /*****************************************************************************
522 * IDirectDrawSurface7::Release
523 *
524 * Reduces the surface's refcount by 1. If the refcount falls to 0, the
525 * surface is destroyed.
526 *
527 * Destroying the surface is a bit tricky. For the connection between
528 * WineD3DSurfaces and DirectDrawSurfaces see IDirectDraw7::CreateSurface
529 * It has a nice graph explaining the connection.
530 *
531 * What happens here is basically this:
532 * When a surface is destroyed, its WineD3DSurface is released,
533 * and the refcount of the DirectDraw interface is reduced by 1. If it has
534 * complex surfaces attached to it, then these surfaces are destroyed too,
535 * regardless of their refcount. If any surface being destroyed has another
536 * surface attached to it (with a "soft" attachment, not complex), then
537 * this surface is detached with DeleteAttachedSurface.
538 *
539 * When the surface is a texture, the WineD3DTexture is released.
540 * If the surface is the Direct3D render target, then the D3D
541 * capabilities of the WineD3DDevice are uninitialized, which causes the
542 * swapchain to be released.
543 *
544 * When a complex sublevel falls to ref zero, then this is ignored.
545 *
546 * Returns:
547 * The new refcount
548 *
549 *****************************************************************************/
550 static ULONG WINAPI ddraw_surface7_Release(IDirectDrawSurface7 *iface)
551 {
552 struct ddraw_surface *This = impl_from_IDirectDrawSurface7(iface);
553 ULONG refcount = InterlockedDecrement(&This->ref7);
554
555 TRACE("iface %p decreasing refcount to %u.\n", iface, refcount);
556
557 if (refcount == 0)
558 {
559 ddraw_surface_release_iface(This);
560 }
561
562 return refcount;
563 }
564
565 static ULONG WINAPI ddraw_surface4_Release(IDirectDrawSurface4 *iface)
566 {
567 struct ddraw_surface *This = impl_from_IDirectDrawSurface4(iface);
568 ULONG refcount = InterlockedDecrement(&This->ref4);
569
570 TRACE("iface %p decreasing refcount to %u.\n", iface, refcount);
571
572 if (refcount == 0)
573 {
574 ddraw_surface_release_iface(This);
575 }
576
577 return refcount;
578 }
579
580 static ULONG WINAPI ddraw_surface3_Release(IDirectDrawSurface3 *iface)
581 {
582 struct ddraw_surface *This = impl_from_IDirectDrawSurface3(iface);
583 ULONG refcount = InterlockedDecrement(&This->ref3);
584
585 TRACE("iface %p decreasing refcount to %u.\n", iface, refcount);
586
587 if (refcount == 0)
588 {
589 ddraw_surface_release_iface(This);
590 }
591
592 return refcount;
593 }
594
595 static ULONG WINAPI ddraw_surface2_Release(IDirectDrawSurface2 *iface)
596 {
597 struct ddraw_surface *This = impl_from_IDirectDrawSurface2(iface);
598 ULONG refcount = InterlockedDecrement(&This->ref2);
599
600 TRACE("iface %p decreasing refcount to %u.\n", iface, refcount);
601
602 if (refcount == 0)
603 {
604 ddraw_surface_release_iface(This);
605 }
606
607 return refcount;
608 }
609
610 static ULONG WINAPI ddraw_surface1_Release(IDirectDrawSurface *iface)
611 {
612 struct ddraw_surface *This = impl_from_IDirectDrawSurface(iface);
613 ULONG refcount = InterlockedDecrement(&This->ref1);
614
615 TRACE("iface %p decreasing refcount to %u.\n", iface, refcount);
616
617 if (refcount == 0)
618 {
619 ddraw_surface_release_iface(This);
620 }
621
622 return refcount;
623 }
624
625 static ULONG WINAPI ddraw_gamma_control_Release(IDirectDrawGammaControl *iface)
626 {
627 struct ddraw_surface *This = impl_from_IDirectDrawGammaControl(iface);
628 ULONG refcount = InterlockedDecrement(&This->gamma_count);
629
630 TRACE("iface %p decreasing refcount to %u.\n", iface, refcount);
631
632 if (refcount == 0)
633 {
634 ddraw_surface_release_iface(This);
635 }
636
637 return refcount;
638 }
639
640 static ULONG WINAPI d3d_texture2_Release(IDirect3DTexture2 *iface)
641 {
642 struct ddraw_surface *surface = impl_from_IDirect3DTexture2(iface);
643
644 TRACE("iface %p.\n", iface);
645
646 return IUnknown_Release(surface->texture_outer);
647 }
648
649 static ULONG WINAPI d3d_texture1_Release(IDirect3DTexture *iface)
650 {
651 struct ddraw_surface *surface = impl_from_IDirect3DTexture(iface);
652
653 TRACE("iface %p.\n", iface);
654
655 return IUnknown_Release(surface->texture_outer);
656 }
657
658 /*****************************************************************************
659 * IDirectDrawSurface7::GetAttachedSurface
660 *
661 * Returns an attached surface with the requested caps. Surface attachment
662 * and complex surfaces are not clearly described by the MSDN or sdk,
663 * so this method is tricky and likely to contain problems.
664 * This implementation searches the complex list first, then the
665 * attachment chain.
666 *
667 * The chains are searched from This down to the last surface in the chain,
668 * not from the first element in the chain. The first surface found is
669 * returned. The MSDN says that this method fails if more than one surface
670 * matches the caps, but it is not sure if that is right. The attachment
671 * structure may not even allow two matching surfaces.
672 *
673 * The found surface is AddRef-ed before it is returned.
674 *
675 * Params:
676 * Caps: Pointer to a DDCAPS2 structure describing the caps asked for
677 * Surface: Address to store the found surface
678 *
679 * Returns:
680 * DD_OK on success
681 * DDERR_INVALIDPARAMS if Caps or Surface is NULL
682 * DDERR_NOTFOUND if no surface was found
683 *
684 *****************************************************************************/
685 static HRESULT WINAPI ddraw_surface7_GetAttachedSurface(IDirectDrawSurface7 *iface,
686 DDSCAPS2 *Caps, IDirectDrawSurface7 **Surface)
687 {
688 struct ddraw_surface *This = impl_from_IDirectDrawSurface7(iface);
689 struct ddraw_surface *surf;
690 DDSCAPS2 our_caps;
691 int i;
692
693 TRACE("iface %p, caps %p, attachment %p.\n", iface, Caps, Surface);
694
695 wined3d_mutex_lock();
696
697 if(This->version < 7)
698 {
699 /* Earlier dx apps put garbage into these members, clear them */
700 our_caps.dwCaps = Caps->dwCaps;
701 our_caps.dwCaps2 = 0;
702 our_caps.dwCaps3 = 0;
703 our_caps.dwCaps4 = 0;
704 }
705 else
706 {
707 our_caps = *Caps;
708 }
709
710 TRACE("(%p): Looking for caps: %x,%x,%x,%x\n", This, our_caps.dwCaps, our_caps.dwCaps2, our_caps.dwCaps3, our_caps.dwCaps4); /* FIXME: Better debugging */
711
712 for(i = 0; i < MAX_COMPLEX_ATTACHED; i++)
713 {
714 surf = This->complex_array[i];
715 if(!surf) break;
716
717 TRACE("Surface: (%p) caps: %#x, %#x, %#x, %#x.\n", surf,
718 surf->surface_desc.ddsCaps.dwCaps,
719 surf->surface_desc.ddsCaps.dwCaps2,
720 surf->surface_desc.ddsCaps.dwCaps3,
721 surf->surface_desc.ddsCaps.dwCaps4);
722
723 if (((surf->surface_desc.ddsCaps.dwCaps & our_caps.dwCaps) == our_caps.dwCaps) &&
724 ((surf->surface_desc.ddsCaps.dwCaps2 & our_caps.dwCaps2) == our_caps.dwCaps2)) {
725
726 /* MSDN: "This method fails if more than one surface is attached
727 * that matches the capabilities requested."
728 *
729 * Not sure how to test this.
730 */
731
732 TRACE("(%p): Returning surface %p\n", This, surf);
733 TRACE("(%p): mipmapcount=%d\n", This, surf->mipmap_level);
734 *Surface = &surf->IDirectDrawSurface7_iface;
735 ddraw_surface7_AddRef(*Surface);
736 wined3d_mutex_unlock();
737
738 return DD_OK;
739 }
740 }
741
742 /* Next, look at the attachment chain */
743 surf = This;
744
745 while( (surf = surf->next_attached) )
746 {
747 TRACE("Surface: (%p) caps: %#x, %#x, %#x, %#x.\n", surf,
748 surf->surface_desc.ddsCaps.dwCaps,
749 surf->surface_desc.ddsCaps.dwCaps2,
750 surf->surface_desc.ddsCaps.dwCaps3,
751 surf->surface_desc.ddsCaps.dwCaps4);
752
753 if (((surf->surface_desc.ddsCaps.dwCaps & our_caps.dwCaps) == our_caps.dwCaps) &&
754 ((surf->surface_desc.ddsCaps.dwCaps2 & our_caps.dwCaps2) == our_caps.dwCaps2)) {
755
756 TRACE("(%p): Returning surface %p\n", This, surf);
757 *Surface = &surf->IDirectDrawSurface7_iface;
758 ddraw_surface7_AddRef(*Surface);
759 wined3d_mutex_unlock();
760 return DD_OK;
761 }
762 }
763
764 TRACE("(%p) Didn't find a valid surface\n", This);
765
766 wined3d_mutex_unlock();
767
768 *Surface = NULL;
769 return DDERR_NOTFOUND;
770 }
771
772 static HRESULT WINAPI ddraw_surface4_GetAttachedSurface(IDirectDrawSurface4 *iface,
773 DDSCAPS2 *caps, IDirectDrawSurface4 **attachment)
774 {
775 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
776 struct ddraw_surface *attachment_impl;
777 IDirectDrawSurface7 *attachment7;
778 HRESULT hr;
779
780 TRACE("iface %p, caps %p, attachment %p.\n", iface, caps, attachment);
781
782 hr = ddraw_surface7_GetAttachedSurface(&surface->IDirectDrawSurface7_iface,
783 caps, &attachment7);
784 if (FAILED(hr))
785 {
786 *attachment = NULL;
787 return hr;
788 }
789 attachment_impl = impl_from_IDirectDrawSurface7(attachment7);
790 *attachment = &attachment_impl->IDirectDrawSurface4_iface;
791 ddraw_surface4_AddRef(*attachment);
792 ddraw_surface7_Release(attachment7);
793
794 return hr;
795 }
796
797 static HRESULT WINAPI ddraw_surface3_GetAttachedSurface(IDirectDrawSurface3 *iface,
798 DDSCAPS *caps, IDirectDrawSurface3 **attachment)
799 {
800 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
801 struct ddraw_surface *attachment_impl;
802 IDirectDrawSurface7 *attachment7;
803 DDSCAPS2 caps2;
804 HRESULT hr;
805
806 TRACE("iface %p, caps %p, attachment %p.\n", iface, caps, attachment);
807
808 caps2.dwCaps = caps->dwCaps;
809 caps2.dwCaps2 = 0;
810 caps2.dwCaps3 = 0;
811 caps2.dwCaps4 = 0;
812
813 hr = ddraw_surface7_GetAttachedSurface(&surface->IDirectDrawSurface7_iface,
814 &caps2, &attachment7);
815 if (FAILED(hr))
816 {
817 *attachment = NULL;
818 return hr;
819 }
820 attachment_impl = impl_from_IDirectDrawSurface7(attachment7);
821 *attachment = &attachment_impl->IDirectDrawSurface3_iface;
822 ddraw_surface3_AddRef(*attachment);
823 ddraw_surface7_Release(attachment7);
824
825 return hr;
826 }
827
828 static HRESULT WINAPI ddraw_surface2_GetAttachedSurface(IDirectDrawSurface2 *iface,
829 DDSCAPS *caps, IDirectDrawSurface2 **attachment)
830 {
831 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
832 struct ddraw_surface *attachment_impl;
833 IDirectDrawSurface7 *attachment7;
834 DDSCAPS2 caps2;
835 HRESULT hr;
836
837 TRACE("iface %p, caps %p, attachment %p.\n", iface, caps, attachment);
838
839 caps2.dwCaps = caps->dwCaps;
840 caps2.dwCaps2 = 0;
841 caps2.dwCaps3 = 0;
842 caps2.dwCaps4 = 0;
843
844 hr = ddraw_surface7_GetAttachedSurface(&surface->IDirectDrawSurface7_iface,
845 &caps2, &attachment7);
846 if (FAILED(hr))
847 {
848 *attachment = NULL;
849 return hr;
850 }
851 attachment_impl = impl_from_IDirectDrawSurface7(attachment7);
852 *attachment = &attachment_impl->IDirectDrawSurface2_iface;
853 ddraw_surface2_AddRef(*attachment);
854 ddraw_surface7_Release(attachment7);
855
856 return hr;
857 }
858
859 static HRESULT WINAPI ddraw_surface1_GetAttachedSurface(IDirectDrawSurface *iface,
860 DDSCAPS *caps, IDirectDrawSurface **attachment)
861 {
862 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
863 struct ddraw_surface *attachment_impl;
864 IDirectDrawSurface7 *attachment7;
865 DDSCAPS2 caps2;
866 HRESULT hr;
867
868 TRACE("iface %p, caps %p, attachment %p.\n", iface, caps, attachment);
869
870 caps2.dwCaps = caps->dwCaps;
871 caps2.dwCaps2 = 0;
872 caps2.dwCaps3 = 0;
873 caps2.dwCaps4 = 0;
874
875 hr = ddraw_surface7_GetAttachedSurface(&surface->IDirectDrawSurface7_iface,
876 &caps2, &attachment7);
877 if (FAILED(hr))
878 {
879 *attachment = NULL;
880 return hr;
881 }
882 attachment_impl = impl_from_IDirectDrawSurface7(attachment7);
883 *attachment = &attachment_impl->IDirectDrawSurface_iface;
884 ddraw_surface1_AddRef(*attachment);
885 ddraw_surface7_Release(attachment7);
886
887 return hr;
888 }
889
890 /*****************************************************************************
891 * IDirectDrawSurface7::Lock
892 *
893 * Locks the surface and returns a pointer to the surface's memory
894 *
895 * Params:
896 * Rect: Rectangle to lock. If NULL, the whole surface is locked
897 * DDSD: Pointer to a DDSURFACEDESC2 which shall receive the surface's desc.
898 * Flags: Locking flags, e.g Read only or write only
899 * h: An event handle that's not used and must be NULL
900 *
901 * Returns:
902 * DD_OK on success
903 * DDERR_INVALIDPARAMS if DDSD is NULL
904 * For more details, see IWineD3DSurface::LockRect
905 *
906 *****************************************************************************/
907 static HRESULT surface_lock(struct ddraw_surface *This,
908 RECT *Rect, DDSURFACEDESC2 *DDSD, DWORD Flags, HANDLE h)
909 {
910 struct wined3d_map_desc map_desc;
911 HRESULT hr = DD_OK;
912
913 TRACE("This %p, rect %s, surface_desc %p, flags %#x, h %p.\n",
914 This, wine_dbgstr_rect(Rect), DDSD, Flags, h);
915
916 /* This->surface_desc.dwWidth and dwHeight are changeable, thus lock */
917 wined3d_mutex_lock();
918
919 /* Should I check for the handle to be NULL?
920 *
921 * The DDLOCK flags and the D3DLOCK flags are equal
922 * for the supported values. The others are ignored by WineD3D
923 */
924
925 /* Windows zeroes this if the rect is invalid */
926 DDSD->lpSurface = 0;
927
928 if (Rect)
929 {
930 if ((Rect->left < 0)
931 || (Rect->top < 0)
932 || (Rect->left > Rect->right)
933 || (Rect->top > Rect->bottom)
934 || (Rect->right > This->surface_desc.dwWidth)
935 || (Rect->bottom > This->surface_desc.dwHeight))
936 {
937 WARN("Trying to lock an invalid rectangle, returning DDERR_INVALIDPARAMS\n");
938 wined3d_mutex_unlock();
939 return DDERR_INVALIDPARAMS;
940 }
941 }
942
943 if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
944 hr = ddraw_surface_update_frontbuffer(This, Rect, TRUE);
945 if (SUCCEEDED(hr))
946 hr = wined3d_surface_map(This->wined3d_surface, &map_desc, Rect, Flags);
947 if (FAILED(hr))
948 {
949 wined3d_mutex_unlock();
950 switch(hr)
951 {
952 /* D3D8 and D3D9 return the general D3DERR_INVALIDCALL error, but ddraw has a more
953 * specific error. But since IWineD3DSurface::LockRect returns that error in this
954 * only occasion, keep d3d8 and d3d9 free from the return value override. There are
955 * many different places where d3d8/9 would have to catch the DDERR_SURFACEBUSY, it
956 * is much easier to do it in one place in ddraw
957 */
958 case WINED3DERR_INVALIDCALL: return DDERR_SURFACEBUSY;
959 default: return hr;
960 }
961 }
962
963 if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
964 {
965 if (Flags & DDLOCK_READONLY)
966 memset(&This->ddraw->primary_lock, 0, sizeof(This->ddraw->primary_lock));
967 else if (Rect)
968 This->ddraw->primary_lock = *Rect;
969 else
970 SetRect(&This->ddraw->primary_lock, 0, 0, This->surface_desc.dwWidth, This->surface_desc.dwHeight);
971 }
972
973 /* Override the memory area. The pitch should be set already. Strangely windows
974 * does not set the LPSURFACE flag on locked surfaces !?!.
975 * DDSD->dwFlags |= DDSD_LPSURFACE;
976 */
977 This->surface_desc.lpSurface = map_desc.data;
978 DD_STRUCT_COPY_BYSIZE(DDSD,&(This->surface_desc));
979
980 TRACE("locked surface returning description :\n");
981 if (TRACE_ON(ddraw)) DDRAW_dump_surface_desc(DDSD);
982
983 wined3d_mutex_unlock();
984
985 return DD_OK;
986 }
987
988 static HRESULT WINAPI ddraw_surface7_Lock(IDirectDrawSurface7 *iface,
989 RECT *rect, DDSURFACEDESC2 *surface_desc, DWORD flags, HANDLE h)
990 {
991 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
992
993 TRACE("iface %p, rect %s, surface_desc %p, flags %#x, h %p.\n",
994 iface, wine_dbgstr_rect(rect), surface_desc, flags, h);
995
996 if (!surface_desc) return DDERR_INVALIDPARAMS;
997 if (surface_desc->dwSize != sizeof(DDSURFACEDESC) &&
998 surface_desc->dwSize != sizeof(DDSURFACEDESC2))
999 {
1000 WARN("Invalid structure size %d, returning DDERR_INVALIDPARAMS\n", surface_desc->dwSize);
1001 return DDERR_INVALIDPARAMS;
1002 }
1003 return surface_lock(surface, rect, surface_desc, flags, h);
1004 }
1005
1006 static HRESULT WINAPI ddraw_surface4_Lock(IDirectDrawSurface4 *iface, RECT *rect,
1007 DDSURFACEDESC2 *surface_desc, DWORD flags, HANDLE h)
1008 {
1009 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
1010
1011 TRACE("iface %p, rect %s, surface_desc %p, flags %#x, h %p.\n",
1012 iface, wine_dbgstr_rect(rect), surface_desc, flags, h);
1013
1014 if (!surface_desc) return DDERR_INVALIDPARAMS;
1015 if (surface_desc->dwSize != sizeof(DDSURFACEDESC) &&
1016 surface_desc->dwSize != sizeof(DDSURFACEDESC2))
1017 {
1018 WARN("Invalid structure size %d, returning DDERR_INVALIDPARAMS\n", surface_desc->dwSize);
1019 return DDERR_INVALIDPARAMS;
1020 }
1021 return surface_lock(surface, rect, surface_desc, flags, h);
1022 }
1023
1024 static HRESULT WINAPI ddraw_surface3_Lock(IDirectDrawSurface3 *iface, RECT *rect,
1025 DDSURFACEDESC *surface_desc, DWORD flags, HANDLE h)
1026 {
1027 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
1028 DDSURFACEDESC2 surface_desc2;
1029 HRESULT hr;
1030
1031 TRACE("iface %p, rect %s, surface_desc %p, flags %#x, h %p.\n",
1032 iface, wine_dbgstr_rect(rect), surface_desc, flags, h);
1033
1034 if (!surface_desc) return DDERR_INVALIDPARAMS;
1035 if (surface_desc->dwSize != sizeof(DDSURFACEDESC) &&
1036 surface_desc->dwSize != sizeof(DDSURFACEDESC2))
1037 {
1038 WARN("Invalid structure size %d, returning DDERR_INVALIDPARAMS\n", surface_desc->dwSize);
1039 return DDERR_INVALIDPARAMS;
1040 }
1041
1042 surface_desc2.dwSize = surface_desc->dwSize;
1043 surface_desc2.dwFlags = 0;
1044 hr = surface_lock(surface, rect, &surface_desc2, flags, h);
1045 DDSD2_to_DDSD(&surface_desc2, surface_desc);
1046 surface_desc->dwSize = surface_desc2.dwSize;
1047 return hr;
1048 }
1049
1050 static HRESULT WINAPI ddraw_surface2_Lock(IDirectDrawSurface2 *iface, RECT *rect,
1051 DDSURFACEDESC *surface_desc, DWORD flags, HANDLE h)
1052 {
1053 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
1054 DDSURFACEDESC2 surface_desc2;
1055 HRESULT hr;
1056
1057 TRACE("iface %p, rect %s, surface_desc %p, flags %#x, h %p.\n",
1058 iface, wine_dbgstr_rect(rect), surface_desc, flags, h);
1059
1060 if (!surface_desc) return DDERR_INVALIDPARAMS;
1061 if (surface_desc->dwSize != sizeof(DDSURFACEDESC) &&
1062 surface_desc->dwSize != sizeof(DDSURFACEDESC2))
1063 {
1064 WARN("Invalid structure size %d, returning DDERR_INVALIDPARAMS\n", surface_desc->dwSize);
1065 return DDERR_INVALIDPARAMS;
1066 }
1067
1068 surface_desc2.dwSize = surface_desc->dwSize;
1069 surface_desc2.dwFlags = 0;
1070 hr = surface_lock(surface, rect, &surface_desc2, flags, h);
1071 DDSD2_to_DDSD(&surface_desc2, surface_desc);
1072 surface_desc->dwSize = surface_desc2.dwSize;
1073 return hr;
1074 }
1075
1076 static HRESULT WINAPI ddraw_surface1_Lock(IDirectDrawSurface *iface, RECT *rect,
1077 DDSURFACEDESC *surface_desc, DWORD flags, HANDLE h)
1078 {
1079 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
1080 DDSURFACEDESC2 surface_desc2;
1081 HRESULT hr;
1082 TRACE("iface %p, rect %s, surface_desc %p, flags %#x, h %p.\n",
1083 iface, wine_dbgstr_rect(rect), surface_desc, flags, h);
1084
1085 if (!surface_desc) return DDERR_INVALIDPARAMS;
1086 if (surface_desc->dwSize != sizeof(DDSURFACEDESC) &&
1087 surface_desc->dwSize != sizeof(DDSURFACEDESC2))
1088 {
1089 WARN("Invalid structure size %d, returning DDERR_INVALIDPARAMS\n", surface_desc->dwSize);
1090 return DDERR_INVALIDPARAMS;
1091 }
1092
1093 surface_desc2.dwSize = surface_desc->dwSize;
1094 surface_desc2.dwFlags = 0;
1095 hr = surface_lock(surface, rect, &surface_desc2, flags, h);
1096 DDSD2_to_DDSD(&surface_desc2, surface_desc);
1097 surface_desc->dwSize = surface_desc2.dwSize;
1098 return hr;
1099 }
1100
1101 /*****************************************************************************
1102 * IDirectDrawSurface7::Unlock
1103 *
1104 * Unlocks an locked surface
1105 *
1106 * Params:
1107 * Rect: Not used by this implementation
1108 *
1109 * Returns:
1110 * D3D_OK on success
1111 * For more details, see IWineD3DSurface::UnlockRect
1112 *
1113 *****************************************************************************/
1114 static HRESULT WINAPI ddraw_surface7_Unlock(IDirectDrawSurface7 *iface, RECT *pRect)
1115 {
1116 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
1117 HRESULT hr;
1118
1119 TRACE("iface %p, rect %s.\n", iface, wine_dbgstr_rect(pRect));
1120
1121 wined3d_mutex_lock();
1122 hr = wined3d_surface_unmap(surface->wined3d_surface);
1123 if (SUCCEEDED(hr))
1124 {
1125 if (surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
1126 hr = ddraw_surface_update_frontbuffer(surface, &surface->ddraw->primary_lock, FALSE);
1127 surface->surface_desc.lpSurface = NULL;
1128 }
1129 wined3d_mutex_unlock();
1130
1131 return hr;
1132 }
1133
1134 static HRESULT WINAPI ddraw_surface4_Unlock(IDirectDrawSurface4 *iface, RECT *pRect)
1135 {
1136 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
1137
1138 TRACE("iface %p, rect %p.\n", iface, pRect);
1139
1140 return ddraw_surface7_Unlock(&surface->IDirectDrawSurface7_iface, pRect);
1141 }
1142
1143 static HRESULT WINAPI ddraw_surface3_Unlock(IDirectDrawSurface3 *iface, void *data)
1144 {
1145 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
1146
1147 TRACE("iface %p, data %p.\n", iface, data);
1148
1149 /* data might not be the LPRECT of later versions, so drop it. */
1150 return ddraw_surface7_Unlock(&surface->IDirectDrawSurface7_iface, NULL);
1151 }
1152
1153 static HRESULT WINAPI ddraw_surface2_Unlock(IDirectDrawSurface2 *iface, void *data)
1154 {
1155 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
1156
1157 TRACE("iface %p, data %p.\n", iface, data);
1158
1159 /* data might not be the LPRECT of later versions, so drop it. */
1160 return ddraw_surface7_Unlock(&surface->IDirectDrawSurface7_iface, NULL);
1161 }
1162
1163 static HRESULT WINAPI ddraw_surface1_Unlock(IDirectDrawSurface *iface, void *data)
1164 {
1165 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
1166
1167 TRACE("iface %p, data %p.\n", iface, data);
1168
1169 /* data might not be the LPRECT of later versions, so drop it. */
1170 return ddraw_surface7_Unlock(&surface->IDirectDrawSurface7_iface, NULL);
1171 }
1172
1173 static HRESULT WINAPI ddraw_surface7_Flip(IDirectDrawSurface7 *iface, IDirectDrawSurface7 *src, DWORD flags)
1174 {
1175 struct ddraw_surface *dst_impl = impl_from_IDirectDrawSurface7(iface);
1176 struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface7(src);
1177 struct ddraw_texture *ddraw_texture, *prev_ddraw_texture;
1178 DDSCAPS2 caps = {DDSCAPS_FLIP, 0, 0, 0};
1179 struct wined3d_surface *tmp, *rt;
1180 struct wined3d_texture *texture;
1181 IDirectDrawSurface7 *current;
1182 HRESULT hr;
1183
1184 TRACE("iface %p, src %p, flags %#x.\n", iface, src, flags);
1185
1186 if (src == iface || !(dst_impl->surface_desc.ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER | DDSCAPS_OVERLAY)))
1187 return DDERR_NOTFLIPPABLE;
1188
1189 wined3d_mutex_lock();
1190
1191 tmp = dst_impl->wined3d_surface;
1192 texture = dst_impl->wined3d_texture;
1193 rt = wined3d_device_get_render_target(dst_impl->ddraw->wined3d_device, 0);
1194 ddraw_texture = wined3d_texture_get_parent(dst_impl->wined3d_texture);
1195
1196 if (src_impl)
1197 {
1198 for (current = iface; current != src;)
1199 {
1200 if (FAILED(hr = ddraw_surface7_GetAttachedSurface(current, &caps, &current)))
1201 {
1202 WARN("Surface %p is not on the same flip chain as surface %p.\n", src, iface);
1203 wined3d_mutex_unlock();
1204 return DDERR_NOTFLIPPABLE;
1205 }
1206 ddraw_surface7_Release(current);
1207 if (current == iface)
1208 {
1209 WARN("Surface %p is not on the same flip chain as surface %p.\n", src, iface);
1210 wined3d_mutex_unlock();
1211 return DDERR_NOTFLIPPABLE;
1212 }
1213 }
1214
1215 if (rt == dst_impl->wined3d_surface)
1216 wined3d_device_set_render_target(dst_impl->ddraw->wined3d_device, 0, src_impl->wined3d_surface, FALSE);
1217 wined3d_resource_set_parent(wined3d_surface_get_resource(src_impl->wined3d_surface), dst_impl);
1218 dst_impl->wined3d_surface = src_impl->wined3d_surface;
1219 prev_ddraw_texture = wined3d_texture_get_parent(src_impl->wined3d_texture);
1220 wined3d_resource_set_parent(wined3d_texture_get_resource(src_impl->wined3d_texture), ddraw_texture);
1221 dst_impl->wined3d_texture = src_impl->wined3d_texture;
1222 ddraw_texture = prev_ddraw_texture;
1223 }
1224 else
1225 {
1226 for (current = iface;;)
1227 {
1228 if (FAILED(hr = ddraw_surface7_GetAttachedSurface(current, &caps, &current)))
1229 {
1230 ERR("Can't find a flip target\n");
1231 wined3d_mutex_unlock();
1232 return DDERR_NOTFLIPPABLE; /* Unchecked */
1233 }
1234 ddraw_surface7_Release(current);
1235 if (current == iface)
1236 {
1237 dst_impl = impl_from_IDirectDrawSurface7(iface);
1238 break;
1239 }
1240
1241 src_impl = impl_from_IDirectDrawSurface7(current);
1242 if (rt == dst_impl->wined3d_surface)
1243 wined3d_device_set_render_target(dst_impl->ddraw->wined3d_device, 0, src_impl->wined3d_surface, FALSE);
1244 wined3d_resource_set_parent(wined3d_surface_get_resource(src_impl->wined3d_surface), dst_impl);
1245 dst_impl->wined3d_surface = src_impl->wined3d_surface;
1246 prev_ddraw_texture = wined3d_texture_get_parent(src_impl->wined3d_texture);
1247 wined3d_resource_set_parent(wined3d_texture_get_resource(src_impl->wined3d_texture), ddraw_texture);
1248 ddraw_texture = prev_ddraw_texture;
1249 dst_impl->wined3d_texture = src_impl->wined3d_texture;
1250 dst_impl = src_impl;
1251 }
1252 }
1253
1254 /* We don't have to worry about potential texture bindings, since
1255 * flippable surfaces can never be textures. */
1256 if (rt == src_impl->wined3d_surface)
1257 wined3d_device_set_render_target(dst_impl->ddraw->wined3d_device, 0, tmp, FALSE);
1258 wined3d_resource_set_parent(wined3d_surface_get_resource(tmp), src_impl);
1259 src_impl->wined3d_surface = tmp;
1260 wined3d_resource_set_parent(wined3d_texture_get_resource(texture), ddraw_texture);
1261 src_impl->wined3d_texture = texture;
1262
1263 if (flags)
1264 {
1265 static UINT once;
1266 if (!once++)
1267 FIXME("Ignoring flags %#x.\n", flags);
1268 else
1269 WARN("Ignoring flags %#x.\n", flags);
1270 }
1271
1272 if (dst_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
1273 hr = ddraw_surface_update_frontbuffer(dst_impl, NULL, FALSE);
1274 else
1275 hr = DD_OK;
1276
1277 wined3d_mutex_unlock();
1278
1279 return hr;
1280 }
1281
1282 static HRESULT WINAPI ddraw_surface4_Flip(IDirectDrawSurface4 *iface, IDirectDrawSurface4 *dst, DWORD flags)
1283 {
1284 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
1285 struct ddraw_surface *dst_impl = unsafe_impl_from_IDirectDrawSurface4(dst);
1286
1287 TRACE("iface %p, dst %p, flags %#x.\n", iface, dst, flags);
1288
1289 return ddraw_surface7_Flip(&surface->IDirectDrawSurface7_iface,
1290 dst_impl ? &dst_impl->IDirectDrawSurface7_iface : NULL, flags);
1291 }
1292
1293 static HRESULT WINAPI ddraw_surface3_Flip(IDirectDrawSurface3 *iface, IDirectDrawSurface3 *dst, DWORD flags)
1294 {
1295 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
1296 struct ddraw_surface *dst_impl = unsafe_impl_from_IDirectDrawSurface3(dst);
1297
1298 TRACE("iface %p, dst %p, flags %#x.\n", iface, dst, flags);
1299
1300 return ddraw_surface7_Flip(&surface->IDirectDrawSurface7_iface,
1301 dst_impl ? &dst_impl->IDirectDrawSurface7_iface : NULL, flags);
1302 }
1303
1304 static HRESULT WINAPI ddraw_surface2_Flip(IDirectDrawSurface2 *iface, IDirectDrawSurface2 *dst, DWORD flags)
1305 {
1306 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
1307 struct ddraw_surface *dst_impl = unsafe_impl_from_IDirectDrawSurface2(dst);
1308
1309 TRACE("iface %p, dst %p, flags %#x.\n", iface, dst, flags);
1310
1311 return ddraw_surface7_Flip(&surface->IDirectDrawSurface7_iface,
1312 dst_impl ? &dst_impl->IDirectDrawSurface7_iface : NULL, flags);
1313 }
1314
1315 static HRESULT WINAPI ddraw_surface1_Flip(IDirectDrawSurface *iface, IDirectDrawSurface *dst, DWORD flags)
1316 {
1317 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
1318 struct ddraw_surface *dst_impl = unsafe_impl_from_IDirectDrawSurface(dst);
1319
1320 TRACE("iface %p, dst %p, flags %#x.\n", iface, dst, flags);
1321
1322 return ddraw_surface7_Flip(&surface->IDirectDrawSurface7_iface,
1323 dst_impl ? &dst_impl->IDirectDrawSurface7_iface : NULL, flags);
1324 }
1325
1326 static HRESULT ddraw_surface_blt_clipped(struct ddraw_surface *dst_surface, const RECT *dst_rect_in,
1327 struct ddraw_surface *src_surface, const RECT *src_rect_in, DWORD flags,
1328 const WINEDDBLTFX *fx, enum wined3d_texture_filter_type filter)
1329 {
1330 struct wined3d_surface *wined3d_src_surface = src_surface ? src_surface->wined3d_surface : NULL;
1331 RECT src_rect, dst_rect;
1332 float scale_x, scale_y;
1333 const RECT *clip_rect;
1334 UINT clip_list_size;
1335 RGNDATA *clip_list;
1336 HRESULT hr = DD_OK;
1337 UINT i;
1338
1339 if (!dst_surface->clipper)
1340 {
1341 if (src_surface && src_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
1342 hr = ddraw_surface_update_frontbuffer(src_surface, src_rect_in, TRUE);
1343 if (SUCCEEDED(hr))
1344 hr = wined3d_surface_blt(dst_surface->wined3d_surface, dst_rect_in,
1345 wined3d_src_surface, src_rect_in, flags, fx, filter);
1346 if (SUCCEEDED(hr) && (dst_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))
1347 hr = ddraw_surface_update_frontbuffer(dst_surface, dst_rect_in, FALSE);
1348
1349 return hr;
1350 }
1351
1352 if (!dst_rect_in)
1353 {
1354 dst_rect.left = 0;
1355 dst_rect.top = 0;
1356 dst_rect.right = dst_surface->surface_desc.dwWidth;
1357 dst_rect.bottom = dst_surface->surface_desc.dwHeight;
1358 }
1359 else
1360 {
1361 dst_rect = *dst_rect_in;
1362 }
1363
1364 if (IsRectEmpty(&dst_rect))
1365 return DDERR_INVALIDRECT;
1366
1367 if (src_surface)
1368 {
1369 if (!src_rect_in)
1370 {
1371 src_rect.left = 0;
1372 src_rect.top = 0;
1373 src_rect.right = src_surface->surface_desc.dwWidth;
1374 src_rect.bottom = src_surface->surface_desc.dwHeight;
1375 }
1376 else
1377 {
1378 src_rect = *src_rect_in;
1379 }
1380
1381 if (IsRectEmpty(&src_rect))
1382 return DDERR_INVALIDRECT;
1383 }
1384 else
1385 {
1386 SetRect(&src_rect, 0, 0, 0, 0);
1387 }
1388
1389 scale_x = (float)(src_rect.right - src_rect.left) / (float)(dst_rect.right - dst_rect.left);
1390 scale_y = (float)(src_rect.bottom - src_rect.top) / (float)(dst_rect.bottom - dst_rect.top);
1391
1392 if (FAILED(hr = IDirectDrawClipper_GetClipList(&dst_surface->clipper->IDirectDrawClipper_iface,
1393 &dst_rect, NULL, &clip_list_size)))
1394 {
1395 WARN("Failed to get clip list size, hr %#x.\n", hr);
1396 return hr;
1397 }
1398
1399 if (!(clip_list = HeapAlloc(GetProcessHeap(), 0, clip_list_size)))
1400 {
1401 WARN("Failed to allocate clip list.\n");
1402 return E_OUTOFMEMORY;
1403 }
1404
1405 if (FAILED(hr = IDirectDrawClipper_GetClipList(&dst_surface->clipper->IDirectDrawClipper_iface,
1406 &dst_rect, clip_list, &clip_list_size)))
1407 {
1408 WARN("Failed to get clip list, hr %#x.\n", hr);
1409 HeapFree(GetProcessHeap(), 0, clip_list);
1410 return hr;
1411 }
1412
1413 clip_rect = (RECT *)clip_list->Buffer;
1414 for (i = 0; i < clip_list->rdh.nCount; ++i)
1415 {
1416 RECT src_rect_clipped = src_rect;
1417
1418 if (src_surface)
1419 {
1420 src_rect_clipped.left += (LONG)((clip_rect[i].left - dst_rect.left) * scale_x);
1421 src_rect_clipped.top += (LONG)((clip_rect[i].top - dst_rect.top) * scale_y);
1422 src_rect_clipped.right -= (LONG)((dst_rect.right - clip_rect[i].right) * scale_x);
1423 src_rect_clipped.bottom -= (LONG)((dst_rect.bottom - clip_rect[i].bottom) * scale_y);
1424
1425 if (src_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
1426 {
1427 if (FAILED(hr = ddraw_surface_update_frontbuffer(src_surface, &src_rect_clipped, TRUE)))
1428 break;
1429 }
1430 }
1431
1432 if (FAILED(hr = wined3d_surface_blt(dst_surface->wined3d_surface, &clip_rect[i],
1433 wined3d_src_surface, &src_rect_clipped, flags, fx, filter)))
1434 break;
1435
1436 if (dst_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
1437 {
1438 if (FAILED(hr = ddraw_surface_update_frontbuffer(dst_surface, &clip_rect[i], FALSE)))
1439 break;
1440 }
1441 }
1442
1443 HeapFree(GetProcessHeap(), 0, clip_list);
1444 return hr;
1445 }
1446
1447 /*****************************************************************************
1448 * IDirectDrawSurface7::Blt
1449 *
1450 * Performs a blit on the surface
1451 *
1452 * Params:
1453 * DestRect: Destination rectangle, can be NULL
1454 * SrcSurface: Source surface, can be NULL
1455 * SrcRect: Source rectangle, can be NULL
1456 * Flags: Blt flags
1457 * DDBltFx: Some extended blt parameters, connected to the flags
1458 *
1459 * Returns:
1460 * D3D_OK on success
1461 * See IWineD3DSurface::Blt for more details
1462 *
1463 *****************************************************************************/
1464 static HRESULT WINAPI ddraw_surface7_Blt(IDirectDrawSurface7 *iface, RECT *DestRect,
1465 IDirectDrawSurface7 *SrcSurface, RECT *SrcRect, DWORD Flags, DDBLTFX *DDBltFx)
1466 {
1467 struct ddraw_surface *dst_surface = impl_from_IDirectDrawSurface7(iface);
1468 struct ddraw_surface *src_surface = unsafe_impl_from_IDirectDrawSurface7(SrcSurface);
1469 HRESULT hr = DD_OK;
1470
1471 TRACE("iface %p, dst_rect %s, src_surface %p, src_rect %s, flags %#x, fx %p.\n",
1472 iface, wine_dbgstr_rect(DestRect), SrcSurface, wine_dbgstr_rect(SrcRect), Flags, DDBltFx);
1473
1474 /* Check for validity of the flags here. WineD3D Has the software-opengl selection path and would have
1475 * to check at 2 places, and sometimes do double checks. This also saves the call to wined3d :-)
1476 */
1477 if((Flags & DDBLT_KEYSRCOVERRIDE) && (!DDBltFx || Flags & DDBLT_KEYSRC)) {
1478 WARN("Invalid source color key parameters, returning DDERR_INVALIDPARAMS\n");
1479 return DDERR_INVALIDPARAMS;
1480 }
1481
1482 if((Flags & DDBLT_KEYDESTOVERRIDE) && (!DDBltFx || Flags & DDBLT_KEYDEST)) {
1483 WARN("Invalid destination color key parameters, returning DDERR_INVALIDPARAMS\n");
1484 return DDERR_INVALIDPARAMS;
1485 }
1486
1487 wined3d_mutex_lock();
1488
1489 if (Flags & DDBLT_KEYSRC && (!src_surface || !(src_surface->surface_desc.dwFlags & DDSD_CKSRCBLT)))
1490 {
1491 WARN("DDBLT_KEYDEST blit without color key in surface, returning DDERR_INVALIDPARAMS\n");
1492 wined3d_mutex_unlock();
1493 return DDERR_INVALIDPARAMS;
1494 }
1495
1496 /* TODO: Check if the DDBltFx contains any ddraw surface pointers. If it
1497 * does, copy the struct, and replace the ddraw surfaces with the wined3d
1498 * surfaces. So far no blitting operations using surfaces in the bltfx
1499 * struct are supported anyway. */
1500 hr = ddraw_surface_blt_clipped(dst_surface, DestRect, src_surface, SrcRect,
1501 Flags, (WINEDDBLTFX *)DDBltFx, WINED3D_TEXF_LINEAR);
1502
1503 wined3d_mutex_unlock();
1504 switch(hr)
1505 {
1506 case WINED3DERR_NOTAVAILABLE: return DDERR_UNSUPPORTED;
1507 case WINED3DERR_WRONGTEXTUREFORMAT: return DDERR_INVALIDPIXELFORMAT;
1508 default: return hr;
1509 }
1510 }
1511
1512 static HRESULT WINAPI ddraw_surface4_Blt(IDirectDrawSurface4 *iface, RECT *dst_rect,
1513 IDirectDrawSurface4 *src_surface, RECT *src_rect, DWORD flags, DDBLTFX *fx)
1514 {
1515 struct ddraw_surface *dst = impl_from_IDirectDrawSurface4(iface);
1516 struct ddraw_surface *src = unsafe_impl_from_IDirectDrawSurface4(src_surface);
1517
1518 TRACE("iface %p, dst_rect %s, src_surface %p, src_rect %s, flags %#x, fx %p.\n",
1519 iface, wine_dbgstr_rect(dst_rect), src_surface, wine_dbgstr_rect(src_rect), flags, fx);
1520
1521 return ddraw_surface7_Blt(&dst->IDirectDrawSurface7_iface, dst_rect,
1522 src ? &src->IDirectDrawSurface7_iface : NULL, src_rect, flags, fx);
1523 }
1524
1525 static HRESULT WINAPI ddraw_surface3_Blt(IDirectDrawSurface3 *iface, RECT *dst_rect,
1526 IDirectDrawSurface3 *src_surface, RECT *src_rect, DWORD flags, DDBLTFX *fx)
1527 {
1528 struct ddraw_surface *dst = impl_from_IDirectDrawSurface3(iface);
1529 struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface3(src_surface);
1530
1531 TRACE("iface %p, dst_rect %s, src_surface %p, src_rect %s, flags %#x, fx %p.\n",
1532 iface, wine_dbgstr_rect(dst_rect), src_surface, wine_dbgstr_rect(src_rect), flags, fx);
1533
1534 return ddraw_surface7_Blt(&dst->IDirectDrawSurface7_iface, dst_rect,
1535 src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, src_rect, flags, fx);
1536 }
1537
1538 static HRESULT WINAPI ddraw_surface2_Blt(IDirectDrawSurface2 *iface, RECT *dst_rect,
1539 IDirectDrawSurface2 *src_surface, RECT *src_rect, DWORD flags, DDBLTFX *fx)
1540 {
1541 struct ddraw_surface *dst = impl_from_IDirectDrawSurface2(iface);
1542 struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface2(src_surface);
1543
1544 TRACE("iface %p, dst_rect %s, src_surface %p, src_rect %s, flags %#x, fx %p.\n",
1545 iface, wine_dbgstr_rect(dst_rect), src_surface, wine_dbgstr_rect(src_rect), flags, fx);
1546
1547 return ddraw_surface7_Blt(&dst->IDirectDrawSurface7_iface, dst_rect,
1548 src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, src_rect, flags, fx);
1549 }
1550
1551 static HRESULT WINAPI ddraw_surface1_Blt(IDirectDrawSurface *iface, RECT *dst_rect,
1552 IDirectDrawSurface *src_surface, RECT *src_rect, DWORD flags, DDBLTFX *fx)
1553 {
1554 struct ddraw_surface *dst = impl_from_IDirectDrawSurface(iface);
1555 struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface(src_surface);
1556
1557 TRACE("iface %p, dst_rect %s, src_surface %p, src_rect %s, flags %#x, fx %p.\n",
1558 iface, wine_dbgstr_rect(dst_rect), src_surface, wine_dbgstr_rect(src_rect), flags, fx);
1559
1560 return ddraw_surface7_Blt(&dst->IDirectDrawSurface7_iface, dst_rect,
1561 src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, src_rect, flags, fx);
1562 }
1563
1564 /*****************************************************************************
1565 * IDirectDrawSurface7::AddAttachedSurface
1566 *
1567 * Attaches a surface to another surface. How the surface attachments work
1568 * is not totally understood yet, and this method is prone to problems.
1569 * The surface that is attached is AddRef-ed.
1570 *
1571 * Tests with complex surfaces suggest that the surface attachments form a
1572 * tree, but no method to test this has been found yet.
1573 *
1574 * The attachment list consists of a first surface (first_attached) and
1575 * for each surface a pointer to the next attached surface (next_attached).
1576 * For the first surface, and a surface that has no attachments
1577 * first_attached points to the surface itself. A surface that has
1578 * no successors in the chain has next_attached set to NULL.
1579 *
1580 * Newly attached surfaces are attached right after the root surface.
1581 * If a surface is attached to a complex surface compound, it's attached to
1582 * the surface that the app requested, not the complex root. See
1583 * GetAttachedSurface for a description how surfaces are found.
1584 *
1585 * This is how the current implementation works, and it was coded by looking
1586 * at the needs of the applications.
1587 *
1588 * So far only Z-Buffer attachments are tested, and they are activated in
1589 * WineD3D. Mipmaps could be tricky to activate in WineD3D.
1590 * Back buffers should work in 2D mode, but they are not tested(They can be
1591 * attached in older iface versions). Rendering to the front buffer and
1592 * switching between that and double buffering is not yet implemented in
1593 * WineD3D, so for 3D it might have unexpected results.
1594 *
1595 * ddraw_surface_attach_surface is the real thing,
1596 * ddraw_surface7_AddAttachedSurface is a wrapper around it that
1597 * performs additional checks. Version 7 of this interface is much more restrictive
1598 * than its predecessors.
1599 *
1600 * Params:
1601 * Attach: Surface to attach to iface
1602 *
1603 * Returns:
1604 * DD_OK on success
1605 * DDERR_CANNOTATTACHSURFACE if the surface can't be attached for some reason
1606 *
1607 *****************************************************************************/
1608 static HRESULT ddraw_surface_attach_surface(struct ddraw_surface *This, struct ddraw_surface *Surf)
1609 {
1610 TRACE("surface %p, attachment %p.\n", This, Surf);
1611
1612 if(Surf == This)
1613 return DDERR_CANNOTATTACHSURFACE; /* unchecked */
1614
1615 wined3d_mutex_lock();
1616
1617 /* Check if the surface is already attached somewhere */
1618 if (Surf->next_attached || Surf->first_attached != Surf)
1619 {
1620 /* TODO: Test for the structure of the manual attachment. Is it a
1621 * chain or a list? What happens if one surface is attached to 2
1622 * different surfaces? */
1623 WARN("Surface %p is already attached somewhere. next_attached %p, first_attached %p.\n",
1624 Surf, Surf->next_attached, Surf->first_attached);
1625
1626 wined3d_mutex_unlock();
1627 return DDERR_SURFACEALREADYATTACHED;
1628 }
1629
1630 /* This inserts the new surface at the 2nd position in the chain, right after the root surface */
1631 Surf->next_attached = This->next_attached;
1632 Surf->first_attached = This->first_attached;
1633 This->next_attached = Surf;
1634
1635 /* Check if the WineD3D depth stencil needs updating */
1636 if (This->ddraw->d3ddevice)
1637 d3d_device_update_depth_stencil(This->ddraw->d3ddevice);
1638
1639 wined3d_mutex_unlock();
1640
1641 return DD_OK;
1642 }
1643
1644 static HRESULT WINAPI ddraw_surface7_AddAttachedSurface(IDirectDrawSurface7 *iface, IDirectDrawSurface7 *attachment)
1645 {
1646 struct ddraw_surface *This = impl_from_IDirectDrawSurface7(iface);
1647 struct ddraw_surface *attachment_impl = unsafe_impl_from_IDirectDrawSurface7(attachment);
1648 HRESULT hr;
1649
1650 TRACE("iface %p, attachment %p.\n", iface, attachment);
1651
1652 /* Version 7 of this interface seems to refuse everything except z buffers, as per msdn */
1653 if(!(attachment_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_ZBUFFER))
1654 {
1655
1656 WARN("Application tries to attach a non Z buffer surface. caps %08x\n",
1657 attachment_impl->surface_desc.ddsCaps.dwCaps);
1658 return DDERR_CANNOTATTACHSURFACE;
1659 }
1660
1661 hr = ddraw_surface_attach_surface(This, attachment_impl);
1662 if (FAILED(hr))
1663 {
1664 return hr;
1665 }
1666 attachment_impl->attached_iface = (IUnknown *)attachment;
1667 IUnknown_AddRef(attachment_impl->attached_iface);
1668 return hr;
1669 }
1670
1671 static HRESULT WINAPI ddraw_surface4_AddAttachedSurface(IDirectDrawSurface4 *iface, IDirectDrawSurface4 *attachment)
1672 {
1673 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
1674 struct ddraw_surface *attachment_impl = unsafe_impl_from_IDirectDrawSurface4(attachment);
1675 HRESULT hr;
1676
1677 TRACE("iface %p, attachment %p.\n", iface, attachment);
1678
1679 /* Tests suggest that
1680 * -> offscreen plain surfaces can be attached to other offscreen plain surfaces
1681 * -> offscreen plain surfaces can be attached to primaries
1682 * -> primaries can be attached to offscreen plain surfaces
1683 * -> z buffers can be attached to primaries */
1684 if (surface->surface_desc.ddsCaps.dwCaps & (DDSCAPS_PRIMARYSURFACE | DDSCAPS_OFFSCREENPLAIN)
1685 && attachment_impl->surface_desc.ddsCaps.dwCaps & (DDSCAPS_PRIMARYSURFACE | DDSCAPS_OFFSCREENPLAIN))
1686 {
1687 /* Sizes have to match */
1688 if (attachment_impl->surface_desc.dwWidth != surface->surface_desc.dwWidth
1689 || attachment_impl->surface_desc.dwHeight != surface->surface_desc.dwHeight)
1690 {
1691 WARN("Surface sizes do not match.\n");
1692 return DDERR_CANNOTATTACHSURFACE;
1693 }
1694 }
1695 else if (!(surface->surface_desc.ddsCaps.dwCaps & (DDSCAPS_PRIMARYSURFACE | DDSCAPS_3DDEVICE))
1696 || !(attachment_impl->surface_desc.ddsCaps.dwCaps & (DDSCAPS_ZBUFFER)))
1697 {
1698 WARN("Invalid attachment combination.\n");
1699 return DDERR_CANNOTATTACHSURFACE;
1700 }
1701
1702 if (FAILED(hr = ddraw_surface_attach_surface(surface, attachment_impl)))
1703 return hr;
1704
1705 attachment_impl->attached_iface = (IUnknown *)attachment;
1706 IUnknown_AddRef(attachment_impl->attached_iface);
1707 return hr;
1708 }
1709
1710 static HRESULT WINAPI ddraw_surface3_AddAttachedSurface(IDirectDrawSurface3 *iface, IDirectDrawSurface3 *attachment)
1711 {
1712 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
1713 struct ddraw_surface *attachment_impl = unsafe_impl_from_IDirectDrawSurface3(attachment);
1714 HRESULT hr;
1715
1716 TRACE("iface %p, attachment %p.\n", iface, attachment);
1717
1718 if (FAILED(hr = ddraw_surface4_AddAttachedSurface(&surface->IDirectDrawSurface4_iface,
1719 attachment_impl ? &attachment_impl->IDirectDrawSurface4_iface : NULL)))
1720 return hr;
1721
1722 attachment_impl->attached_iface = (IUnknown *)attachment;
1723 IUnknown_AddRef(attachment_impl->attached_iface);
1724 ddraw_surface4_Release(&attachment_impl->IDirectDrawSurface4_iface);
1725 return hr;
1726 }
1727
1728 static HRESULT WINAPI ddraw_surface2_AddAttachedSurface(IDirectDrawSurface2 *iface, IDirectDrawSurface2 *attachment)
1729 {
1730 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
1731 struct ddraw_surface *attachment_impl = unsafe_impl_from_IDirectDrawSurface2(attachment);
1732 HRESULT hr;
1733
1734 TRACE("iface %p, attachment %p.\n", iface, attachment);
1735
1736 if (FAILED(hr = ddraw_surface4_AddAttachedSurface(&surface->IDirectDrawSurface4_iface,
1737 attachment_impl ? &attachment_impl->IDirectDrawSurface4_iface : NULL)))
1738 return hr;
1739
1740 attachment_impl->attached_iface = (IUnknown *)attachment;
1741 IUnknown_AddRef(attachment_impl->attached_iface);
1742 ddraw_surface4_Release(&attachment_impl->IDirectDrawSurface4_iface);
1743 return hr;
1744 }
1745
1746 static HRESULT WINAPI ddraw_surface1_AddAttachedSurface(IDirectDrawSurface *iface, IDirectDrawSurface *attachment)
1747 {
1748 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
1749 struct ddraw_surface *attachment_impl = unsafe_impl_from_IDirectDrawSurface(attachment);
1750 HRESULT hr;
1751
1752 TRACE("iface %p, attachment %p.\n", iface, attachment);
1753
1754 if (FAILED(hr = ddraw_surface4_AddAttachedSurface(&surface->IDirectDrawSurface4_iface,
1755 attachment_impl ? &attachment_impl->IDirectDrawSurface4_iface : NULL)))
1756 return hr;
1757
1758 attachment_impl->attached_iface = (IUnknown *)attachment;
1759 IUnknown_AddRef(attachment_impl->attached_iface);
1760 ddraw_surface4_Release(&attachment_impl->IDirectDrawSurface4_iface);
1761 return hr;
1762 }
1763
1764 /*****************************************************************************
1765 * IDirectDrawSurface7::DeleteAttachedSurface
1766 *
1767 * Removes a surface from the attachment chain. The surface's refcount
1768 * is decreased by one after it has been removed
1769 *
1770 * Params:
1771 * Flags: Some flags, not used by this implementation
1772 * Attach: Surface to detach
1773 *
1774 * Returns:
1775 * DD_OK on success
1776 * DDERR_SURFACENOTATTACHED if the surface isn't attached to
1777 *
1778 *****************************************************************************/
1779 static HRESULT ddraw_surface_delete_attached_surface(struct ddraw_surface *surface,
1780 struct ddraw_surface *attachment, IUnknown *detach_iface)
1781 {
1782 struct ddraw_surface *prev = surface;
1783
1784 TRACE("surface %p, attachment %p, detach_iface %p.\n", surface, attachment, detach_iface);
1785
1786 wined3d_mutex_lock();
1787 if (!attachment || (attachment->first_attached != surface) || (attachment == surface) )
1788 {
1789 wined3d_mutex_unlock();
1790 return DDERR_CANNOTDETACHSURFACE;
1791 }
1792
1793 if (attachment->attached_iface != detach_iface)
1794 {
1795 WARN("attachment->attach_iface %p != detach_iface %p.\n", attachment->attached_iface, detach_iface);
1796 wined3d_mutex_unlock();
1797 return DDERR_SURFACENOTATTACHED;
1798 }
1799
1800 /* Remove MIPMAPSUBLEVEL if this seemed to be one */
1801 if (surface->surface_desc.ddsCaps.dwCaps & attachment->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP)
1802 {
1803 attachment->surface_desc.ddsCaps.dwCaps2 &= ~DDSCAPS2_MIPMAPSUBLEVEL;
1804 /* FIXME: we should probably also subtract from dwMipMapCount of this
1805 * and all parent surfaces */
1806 }
1807
1808 /* Find the predecessor of the detached surface */
1809 while (prev)
1810 {
1811 if (prev->next_attached == attachment)
1812 break;
1813 prev = prev->next_attached;
1814 }
1815
1816 /* There must be a surface, otherwise there's a bug */
1817 assert(prev);
1818
1819 /* Unchain the surface */
1820 prev->next_attached = attachment->next_attached;
1821 attachment->next_attached = NULL;
1822 attachment->first_attached = attachment;
1823
1824 /* Check if the wined3d depth stencil needs updating. */
1825 if (surface->ddraw->d3ddevice)
1826 d3d_device_update_depth_stencil(surface->ddraw->d3ddevice);
1827 wined3d_mutex_unlock();
1828
1829 /* Set attached_iface to NULL before releasing it, the surface may go
1830 * away. */
1831 attachment->attached_iface = NULL;
1832 IUnknown_Release(detach_iface);
1833
1834 return DD_OK;
1835 }
1836
1837 static HRESULT WINAPI ddraw_surface7_DeleteAttachedSurface(IDirectDrawSurface7 *iface,
1838 DWORD flags, IDirectDrawSurface7 *attachment)
1839 {
1840 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
1841 struct ddraw_surface *attachment_impl = unsafe_impl_from_IDirectDrawSurface7(attachment);
1842
1843 TRACE("iface %p, flags %#x, attachment %p.\n", iface, flags, attachment);
1844
1845 return ddraw_surface_delete_attached_surface(surface, attachment_impl, (IUnknown *)attachment);
1846 }
1847
1848 static HRESULT WINAPI ddraw_surface4_DeleteAttachedSurface(IDirectDrawSurface4 *iface,
1849 DWORD flags, IDirectDrawSurface4 *attachment)
1850 {
1851 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
1852 struct ddraw_surface *attachment_impl = unsafe_impl_from_IDirectDrawSurface4(attachment);
1853
1854 TRACE("iface %p, flags %#x, attachment %p.\n", iface, flags, attachment);
1855
1856 return ddraw_surface_delete_attached_surface(surface, attachment_impl, (IUnknown *)attachment);
1857 }
1858
1859 static HRESULT WINAPI ddraw_surface3_DeleteAttachedSurface(IDirectDrawSurface3 *iface,
1860 DWORD flags, IDirectDrawSurface3 *attachment)
1861 {
1862 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
1863 struct ddraw_surface *attachment_impl = unsafe_impl_from_IDirectDrawSurface3(attachment);
1864
1865 TRACE("iface %p, flags %#x, attachment %p.\n", iface, flags, attachment);
1866
1867 return ddraw_surface_delete_attached_surface(surface, attachment_impl, (IUnknown *)attachment);
1868 }
1869
1870 static HRESULT WINAPI ddraw_surface2_DeleteAttachedSurface(IDirectDrawSurface2 *iface,
1871 DWORD flags, IDirectDrawSurface2 *attachment)
1872 {
1873 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
1874 struct ddraw_surface *attachment_impl = unsafe_impl_from_IDirectDrawSurface2(attachment);
1875
1876 TRACE("iface %p, flags %#x, attachment %p.\n", iface, flags, attachment);
1877
1878 return ddraw_surface_delete_attached_surface(surface, attachment_impl, (IUnknown *)attachment);
1879 }
1880
1881 static HRESULT WINAPI ddraw_surface1_DeleteAttachedSurface(IDirectDrawSurface *iface,
1882 DWORD flags, IDirectDrawSurface *attachment)
1883 {
1884 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
1885 struct ddraw_surface *attachment_impl = unsafe_impl_from_IDirectDrawSurface(attachment);
1886
1887 TRACE("iface %p, flags %#x, attachment %p.\n", iface, flags, attachment);
1888
1889 return ddraw_surface_delete_attached_surface(surface, attachment_impl, (IUnknown *)attachment);
1890 }
1891
1892 /*****************************************************************************
1893 * IDirectDrawSurface7::AddOverlayDirtyRect
1894 *
1895 * "This method is not currently implemented"
1896 *
1897 * Params:
1898 * Rect: ?
1899 *
1900 * Returns:
1901 * DDERR_UNSUPPORTED
1902 *
1903 *****************************************************************************/
1904 static HRESULT WINAPI ddraw_surface7_AddOverlayDirtyRect(IDirectDrawSurface7 *iface, RECT *Rect)
1905 {
1906 TRACE("iface %p, rect %s.\n", iface, wine_dbgstr_rect(Rect));
1907
1908 return DDERR_UNSUPPORTED; /* unchecked */
1909 }
1910
1911 static HRESULT WINAPI ddraw_surface4_AddOverlayDirtyRect(IDirectDrawSurface4 *iface, RECT *rect)
1912 {
1913 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
1914
1915 TRACE("iface %p, rect %s.\n", iface, wine_dbgstr_rect(rect));
1916
1917 return ddraw_surface7_AddOverlayDirtyRect(&surface->IDirectDrawSurface7_iface, rect);
1918 }
1919
1920 static HRESULT WINAPI ddraw_surface3_AddOverlayDirtyRect(IDirectDrawSurface3 *iface, RECT *rect)
1921 {
1922 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
1923
1924 TRACE("iface %p, rect %s.\n", iface, wine_dbgstr_rect(rect));
1925
1926 return ddraw_surface7_AddOverlayDirtyRect(&surface->IDirectDrawSurface7_iface, rect);
1927 }
1928
1929 static HRESULT WINAPI ddraw_surface2_AddOverlayDirtyRect(IDirectDrawSurface2 *iface, RECT *rect)
1930 {
1931 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
1932
1933 TRACE("iface %p, rect %s.\n", iface, wine_dbgstr_rect(rect));
1934
1935 return ddraw_surface7_AddOverlayDirtyRect(&surface->IDirectDrawSurface7_iface, rect);
1936 }
1937
1938 static HRESULT WINAPI ddraw_surface1_AddOverlayDirtyRect(IDirectDrawSurface *iface, RECT *rect)
1939 {
1940 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
1941
1942 TRACE("iface %p, rect %s.\n", iface, wine_dbgstr_rect(rect));
1943
1944 return ddraw_surface7_AddOverlayDirtyRect(&surface->IDirectDrawSurface7_iface, rect);
1945 }
1946
1947 /*****************************************************************************
1948 * IDirectDrawSurface7::GetDC
1949 *
1950 * Returns a GDI device context for the surface
1951 *
1952 * Params:
1953 * hdc: Address of a HDC variable to store the dc to
1954 *
1955 * Returns:
1956 * DD_OK on success
1957 * DDERR_INVALIDPARAMS if hdc is NULL
1958 * For details, see IWineD3DSurface::GetDC
1959 *
1960 *****************************************************************************/
1961 static HRESULT WINAPI ddraw_surface7_GetDC(IDirectDrawSurface7 *iface, HDC *hdc)
1962 {
1963 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
1964 HRESULT hr = DD_OK;
1965
1966 TRACE("iface %p, dc %p.\n", iface, hdc);
1967
1968 if(!hdc)
1969 return DDERR_INVALIDPARAMS;
1970
1971 wined3d_mutex_lock();
1972 if (surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
1973 hr = ddraw_surface_update_frontbuffer(surface, NULL, TRUE);
1974 if (SUCCEEDED(hr))
1975 hr = wined3d_surface_getdc(surface->wined3d_surface, hdc);
1976 wined3d_mutex_unlock();
1977 switch(hr)
1978 {
1979 /* Some, but not all errors set *hdc to NULL. E.g. DCALREADYCREATED does not
1980 * touch *hdc
1981 */
1982 case WINED3DERR_INVALIDCALL:
1983 if(hdc) *hdc = NULL;
1984 return DDERR_INVALIDPARAMS;
1985
1986 default: return hr;
1987 }
1988 }
1989
1990 static HRESULT WINAPI ddraw_surface4_GetDC(IDirectDrawSurface4 *iface, HDC *dc)
1991 {
1992 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
1993
1994 TRACE("iface %p, dc %p.\n", iface, dc);
1995
1996 return ddraw_surface7_GetDC(&surface->IDirectDrawSurface7_iface, dc);
1997 }
1998
1999 static HRESULT WINAPI ddraw_surface3_GetDC(IDirectDrawSurface3 *iface, HDC *dc)
2000 {
2001 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
2002
2003 TRACE("iface %p, dc %p.\n", iface, dc);
2004
2005 return ddraw_surface7_GetDC(&surface->IDirectDrawSurface7_iface, dc);
2006 }
2007
2008 static HRESULT WINAPI ddraw_surface2_GetDC(IDirectDrawSurface2 *iface, HDC *dc)
2009 {
2010 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
2011
2012 TRACE("iface %p, dc %p.\n", iface, dc);
2013
2014 return ddraw_surface7_GetDC(&surface->IDirectDrawSurface7_iface, dc);
2015 }
2016
2017 static HRESULT WINAPI ddraw_surface1_GetDC(IDirectDrawSurface *iface, HDC *dc)
2018 {
2019 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
2020
2021 TRACE("iface %p, dc %p.\n", iface, dc);
2022
2023 return ddraw_surface7_GetDC(&surface->IDirectDrawSurface7_iface, dc);
2024 }
2025
2026 /*****************************************************************************
2027 * IDirectDrawSurface7::ReleaseDC
2028 *
2029 * Releases the DC that was constructed with GetDC
2030 *
2031 * Params:
2032 * hdc: HDC to release
2033 *
2034 * Returns:
2035 * DD_OK on success
2036 * For more details, see IWineD3DSurface::ReleaseDC
2037 *
2038 *****************************************************************************/
2039 static HRESULT WINAPI ddraw_surface7_ReleaseDC(IDirectDrawSurface7 *iface, HDC hdc)
2040 {
2041 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
2042 HRESULT hr;
2043
2044 TRACE("iface %p, dc %p.\n", iface, hdc);
2045
2046 wined3d_mutex_lock();
2047 hr = wined3d_surface_releasedc(surface->wined3d_surface, hdc);
2048 if (SUCCEEDED(hr) && (surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))
2049 hr = ddraw_surface_update_frontbuffer(surface, NULL, FALSE);
2050 wined3d_mutex_unlock();
2051
2052 return hr;
2053 }
2054
2055 static HRESULT WINAPI ddraw_surface4_ReleaseDC(IDirectDrawSurface4 *iface, HDC dc)
2056 {
2057 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2058
2059 TRACE("iface %p, dc %p.\n", iface, dc);
2060
2061 return ddraw_surface7_ReleaseDC(&surface->IDirectDrawSurface7_iface, dc);
2062 }
2063
2064 static HRESULT WINAPI ddraw_surface3_ReleaseDC(IDirectDrawSurface3 *iface, HDC dc)
2065 {
2066 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
2067
2068 TRACE("iface %p, dc %p.\n", iface, dc);
2069
2070 return ddraw_surface7_ReleaseDC(&surface->IDirectDrawSurface7_iface, dc);
2071 }
2072
2073 static HRESULT WINAPI ddraw_surface2_ReleaseDC(IDirectDrawSurface2 *iface, HDC dc)
2074 {
2075 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
2076
2077 TRACE("iface %p, dc %p.\n", iface, dc);
2078
2079 return ddraw_surface7_ReleaseDC(&surface->IDirectDrawSurface7_iface, dc);
2080 }
2081
2082 static HRESULT WINAPI ddraw_surface1_ReleaseDC(IDirectDrawSurface *iface, HDC dc)
2083 {
2084 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
2085
2086 TRACE("iface %p, dc %p.\n", iface, dc);
2087
2088 return ddraw_surface7_ReleaseDC(&surface->IDirectDrawSurface7_iface, dc);
2089 }
2090
2091 /*****************************************************************************
2092 * IDirectDrawSurface7::GetCaps
2093 *
2094 * Returns the surface's caps
2095 *
2096 * Params:
2097 * Caps: Address to write the caps to
2098 *
2099 * Returns:
2100 * DD_OK on success
2101 * DDERR_INVALIDPARAMS if Caps is NULL
2102 *
2103 *****************************************************************************/
2104 static HRESULT WINAPI ddraw_surface7_GetCaps(IDirectDrawSurface7 *iface, DDSCAPS2 *Caps)
2105 {
2106 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
2107
2108 TRACE("iface %p, caps %p.\n", iface, Caps);
2109
2110 if(!Caps)
2111 return DDERR_INVALIDPARAMS;
2112
2113 *Caps = surface->surface_desc.ddsCaps;
2114
2115 return DD_OK;
2116 }
2117
2118 static HRESULT WINAPI ddraw_surface4_GetCaps(IDirectDrawSurface4 *iface, DDSCAPS2 *caps)
2119 {
2120 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2121
2122 TRACE("iface %p, caps %p.\n", iface, caps);
2123
2124 return ddraw_surface7_GetCaps(&surface->IDirectDrawSurface7_iface, caps);
2125 }
2126
2127 static HRESULT WINAPI ddraw_surface3_GetCaps(IDirectDrawSurface3 *iface, DDSCAPS *caps)
2128 {
2129 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
2130 DDSCAPS2 caps2;
2131 HRESULT hr;
2132
2133 TRACE("iface %p, caps %p.\n", iface, caps);
2134
2135 hr = ddraw_surface7_GetCaps(&surface->IDirectDrawSurface7_iface, &caps2);
2136 if (FAILED(hr)) return hr;
2137
2138 caps->dwCaps = caps2.dwCaps;
2139 return hr;
2140 }
2141
2142 static HRESULT WINAPI ddraw_surface2_GetCaps(IDirectDrawSurface2 *iface, DDSCAPS *caps)
2143 {
2144 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
2145 DDSCAPS2 caps2;
2146 HRESULT hr;
2147
2148 TRACE("iface %p, caps %p.\n", iface, caps);
2149
2150 hr = ddraw_surface7_GetCaps(&surface->IDirectDrawSurface7_iface, &caps2);
2151 if (FAILED(hr)) return hr;
2152
2153 caps->dwCaps = caps2.dwCaps;
2154 return hr;
2155 }
2156
2157 static HRESULT WINAPI ddraw_surface1_GetCaps(IDirectDrawSurface *iface, DDSCAPS *caps)
2158 {
2159 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
2160 DDSCAPS2 caps2;
2161 HRESULT hr;
2162
2163 TRACE("iface %p, caps %p.\n", iface, caps);
2164
2165 hr = ddraw_surface7_GetCaps(&surface->IDirectDrawSurface7_iface, &caps2);
2166 if (FAILED(hr)) return hr;
2167
2168 caps->dwCaps = caps2.dwCaps;
2169 return hr;
2170 }
2171
2172 /*****************************************************************************
2173 * IDirectDrawSurface7::SetPriority
2174 *
2175 * Sets a texture priority for managed textures.
2176 *
2177 * Params:
2178 * Priority: The new priority
2179 *
2180 * Returns:
2181 * DD_OK on success
2182 * For more details, see IWineD3DSurface::SetPriority
2183 *
2184 *****************************************************************************/
2185 static HRESULT WINAPI ddraw_surface7_SetPriority(IDirectDrawSurface7 *iface, DWORD Priority)
2186 {
2187 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
2188 HRESULT hr;
2189
2190 TRACE("iface %p, priority %u.\n", iface, Priority);
2191
2192 wined3d_mutex_lock();
2193 hr = wined3d_surface_set_priority(surface->wined3d_surface, Priority);
2194 wined3d_mutex_unlock();
2195
2196 return hr;
2197 }
2198
2199 /*****************************************************************************
2200 * IDirectDrawSurface7::GetPriority
2201 *
2202 * Returns the surface's priority
2203 *
2204 * Params:
2205 * Priority: Address of a variable to write the priority to
2206 *
2207 * Returns:
2208 * D3D_OK on success
2209 * DDERR_INVALIDPARAMS if Priority == NULL
2210 * For more details, see IWineD3DSurface::GetPriority
2211 *
2212 *****************************************************************************/
2213 static HRESULT WINAPI ddraw_surface7_GetPriority(IDirectDrawSurface7 *iface, DWORD *Priority)
2214 {
2215 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
2216
2217 TRACE("iface %p, priority %p.\n", iface, Priority);
2218
2219 if(!Priority)
2220 {
2221 return DDERR_INVALIDPARAMS;
2222 }
2223
2224 wined3d_mutex_lock();
2225 *Priority = wined3d_surface_get_priority(surface->wined3d_surface);
2226 wined3d_mutex_unlock();
2227
2228 return DD_OK;
2229 }
2230
2231 /*****************************************************************************
2232 * IDirectDrawSurface7::SetPrivateData
2233 *
2234 * Stores some data in the surface that is intended for the application's
2235 * use.
2236 *
2237 * Params:
2238 * tag: GUID that identifies the data
2239 * Data: Pointer to the private data
2240 * Size: Size of the private data
2241 * Flags: Some flags
2242 *
2243 * Returns:
2244 * D3D_OK on success
2245 * For more details, see IWineD3DSurface::SetPrivateData
2246 *
2247 *****************************************************************************/
2248 static HRESULT WINAPI ddraw_surface7_SetPrivateData(IDirectDrawSurface7 *iface,
2249 REFGUID tag, void *Data, DWORD Size, DWORD Flags)
2250 {
2251 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
2252 struct wined3d_resource *resource;
2253 HRESULT hr;
2254
2255 TRACE("iface %p, tag %s, data %p, data_size %u, flags %#x.\n",
2256 iface, debugstr_guid(tag), Data, Size, Flags);
2257
2258 wined3d_mutex_lock();
2259 resource = wined3d_surface_get_resource(surface->wined3d_surface);
2260 hr = wined3d_resource_set_private_data(resource, tag, Data, Size, Flags);
2261 wined3d_mutex_unlock();
2262
2263 switch(hr)
2264 {
2265 case WINED3DERR_INVALIDCALL: return DDERR_INVALIDPARAMS;
2266 default: return hr;
2267 }
2268 }
2269
2270 static HRESULT WINAPI ddraw_surface4_SetPrivateData(IDirectDrawSurface4 *iface,
2271 REFGUID tag, void *data, DWORD size, DWORD flags)
2272 {
2273 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2274
2275 TRACE("iface %p, tag %s, data %p, data_size %u, flags %#x.\n",
2276 iface, debugstr_guid(tag), data, size, flags);
2277
2278 return ddraw_surface7_SetPrivateData(&surface->IDirectDrawSurface7_iface, tag, data, size, flags);
2279 }
2280
2281 /*****************************************************************************
2282 * IDirectDrawSurface7::GetPrivateData
2283 *
2284 * Returns the private data set with IDirectDrawSurface7::SetPrivateData
2285 *
2286 * Params:
2287 * tag: GUID of the data to return
2288 * Data: Address where to write the data to
2289 * Size: Size of the buffer at Data
2290 *
2291 * Returns:
2292 * DD_OK on success
2293 * DDERR_INVALIDPARAMS if Data is NULL
2294 * For more details, see IWineD3DSurface::GetPrivateData
2295 *
2296 *****************************************************************************/
2297 static HRESULT WINAPI ddraw_surface7_GetPrivateData(IDirectDrawSurface7 *iface, REFGUID tag, void *Data, DWORD *Size)
2298 {
2299 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
2300 struct wined3d_resource *resource;
2301 HRESULT hr;
2302
2303 TRACE("iface %p, tag %s, data %p, data_size %p.\n",
2304 iface, debugstr_guid(tag), Data, Size);
2305
2306 if(!Data)
2307 return DDERR_INVALIDPARAMS;
2308
2309 wined3d_mutex_lock();
2310 resource = wined3d_surface_get_resource(surface->wined3d_surface);
2311 hr = wined3d_resource_get_private_data(resource, tag, Data, Size);
2312 wined3d_mutex_unlock();
2313
2314 return hr;
2315 }
2316
2317 static HRESULT WINAPI ddraw_surface4_GetPrivateData(IDirectDrawSurface4 *iface, REFGUID tag, void *data, DWORD *size)
2318 {
2319 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2320
2321 TRACE("iface %p, tag %s, data %p, data_size %p.\n",
2322 iface, debugstr_guid(tag), data, size);
2323
2324 return ddraw_surface7_GetPrivateData(&surface->IDirectDrawSurface7_iface, tag, data, size);
2325 }
2326
2327 /*****************************************************************************
2328 * IDirectDrawSurface7::FreePrivateData
2329 *
2330 * Frees private data stored in the surface
2331 *
2332 * Params:
2333 * tag: Tag of the data to free
2334 *
2335 * Returns:
2336 * D3D_OK on success
2337 * For more details, see IWineD3DSurface::FreePrivateData
2338 *
2339 *****************************************************************************/
2340 static HRESULT WINAPI ddraw_surface7_FreePrivateData(IDirectDrawSurface7 *iface, REFGUID tag)
2341 {
2342 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
2343 struct wined3d_resource *resource;
2344 HRESULT hr;
2345
2346 TRACE("iface %p, tag %s.\n", iface, debugstr_guid(tag));
2347
2348 wined3d_mutex_lock();
2349 resource = wined3d_surface_get_resource(surface->wined3d_surface);
2350 hr = wined3d_resource_free_private_data(resource, tag);
2351 wined3d_mutex_unlock();
2352
2353 return hr;
2354 }
2355
2356 static HRESULT WINAPI ddraw_surface4_FreePrivateData(IDirectDrawSurface4 *iface, REFGUID tag)
2357 {
2358 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2359
2360 TRACE("iface %p, tag %s.\n", iface, debugstr_guid(tag));
2361
2362 return ddraw_surface7_FreePrivateData(&surface->IDirectDrawSurface7_iface, tag);
2363 }
2364
2365 /*****************************************************************************
2366 * IDirectDrawSurface7::PageLock
2367 *
2368 * Prevents a sysmem surface from being paged out
2369 *
2370 * Params:
2371 * Flags: Not used, must be 0(unchecked)
2372 *
2373 * Returns:
2374 * DD_OK, because it's a stub
2375 *
2376 *****************************************************************************/
2377 static HRESULT WINAPI ddraw_surface7_PageLock(IDirectDrawSurface7 *iface, DWORD Flags)
2378 {
2379 TRACE("iface %p, flags %#x.\n", iface, Flags);
2380
2381 /* This is Windows memory management related - we don't need this */
2382 return DD_OK;
2383 }
2384
2385 static HRESULT WINAPI ddraw_surface4_PageLock(IDirectDrawSurface4 *iface, DWORD flags)
2386 {
2387 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2388
2389 TRACE("iface %p, flags %#x.\n", iface, flags);
2390
2391 return ddraw_surface7_PageLock(&surface->IDirectDrawSurface7_iface, flags);
2392 }
2393
2394 static HRESULT WINAPI ddraw_surface3_PageLock(IDirectDrawSurface3 *iface, DWORD flags)
2395 {
2396 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
2397
2398 TRACE("iface %p, flags %#x.\n", iface, flags);
2399
2400 return ddraw_surface7_PageLock(&surface->IDirectDrawSurface7_iface, flags);
2401 }
2402
2403 static HRESULT WINAPI ddraw_surface2_PageLock(IDirectDrawSurface2 *iface, DWORD flags)
2404 {
2405 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
2406
2407 TRACE("iface %p, flags %#x.\n", iface, flags);
2408
2409 return ddraw_surface7_PageLock(&surface->IDirectDrawSurface7_iface, flags);
2410 }
2411
2412 /*****************************************************************************
2413 * IDirectDrawSurface7::PageUnlock
2414 *
2415 * Allows a sysmem surface to be paged out
2416 *
2417 * Params:
2418 * Flags: Not used, must be 0(unchecked)
2419 *
2420 * Returns:
2421 * DD_OK, because it's a stub
2422 *
2423 *****************************************************************************/
2424 static HRESULT WINAPI ddraw_surface7_PageUnlock(IDirectDrawSurface7 *iface, DWORD Flags)
2425 {
2426 TRACE("iface %p, flags %#x.\n", iface, Flags);
2427
2428 return DD_OK;
2429 }
2430
2431 static HRESULT WINAPI ddraw_surface4_PageUnlock(IDirectDrawSurface4 *iface, DWORD flags)
2432 {
2433 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2434
2435 TRACE("iface %p, flags %#x.\n", iface, flags);
2436
2437 return ddraw_surface7_PageUnlock(&surface->IDirectDrawSurface7_iface, flags);
2438 }
2439
2440 static HRESULT WINAPI ddraw_surface3_PageUnlock(IDirectDrawSurface3 *iface, DWORD flags)
2441 {
2442 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
2443
2444 TRACE("iface %p, flags %#x.\n", iface, flags);
2445
2446 return ddraw_surface7_PageUnlock(&surface->IDirectDrawSurface7_iface, flags);
2447 }
2448
2449 static HRESULT WINAPI ddraw_surface2_PageUnlock(IDirectDrawSurface2 *iface, DWORD flags)
2450 {
2451 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
2452
2453 TRACE("iface %p, flags %#x.\n", iface, flags);
2454
2455 return ddraw_surface7_PageUnlock(&surface->IDirectDrawSurface7_iface, flags);
2456 }
2457
2458 /*****************************************************************************
2459 * IDirectDrawSurface7::BltBatch
2460 *
2461 * An unimplemented function
2462 *
2463 * Params:
2464 * ?
2465 *
2466 * Returns:
2467 * DDERR_UNSUPPORTED
2468 *
2469 *****************************************************************************/
2470 static HRESULT WINAPI ddraw_surface7_BltBatch(IDirectDrawSurface7 *iface, DDBLTBATCH *Batch, DWORD Count, DWORD Flags)
2471 {
2472 TRACE("iface %p, batch %p, count %u, flags %#x.\n", iface, Batch, Count, Flags);
2473
2474 /* MSDN: "not currently implemented" */
2475 return DDERR_UNSUPPORTED;
2476 }
2477
2478 static HRESULT WINAPI ddraw_surface4_BltBatch(IDirectDrawSurface4 *iface, DDBLTBATCH *batch, DWORD count, DWORD flags)
2479 {
2480 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2481
2482 TRACE("iface %p, batch %p, count %u, flags %#x.\n", iface, batch, count, flags);
2483
2484 return ddraw_surface7_BltBatch(&surface->IDirectDrawSurface7_iface, batch, count, flags);
2485 }
2486
2487 static HRESULT WINAPI ddraw_surface3_BltBatch(IDirectDrawSurface3 *iface, DDBLTBATCH *batch, DWORD count, DWORD flags)
2488 {
2489 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
2490
2491 TRACE("iface %p, batch %p, count %u, flags %#x.\n", iface, batch, count, flags);
2492
2493 return ddraw_surface7_BltBatch(&surface->IDirectDrawSurface7_iface, batch, count, flags);
2494 }
2495
2496 static HRESULT WINAPI ddraw_surface2_BltBatch(IDirectDrawSurface2 *iface, DDBLTBATCH *batch, DWORD count, DWORD flags)
2497 {
2498 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
2499
2500 TRACE("iface %p, batch %p, count %u, flags %#x.\n", iface, batch, count, flags);
2501
2502 return ddraw_surface7_BltBatch(&surface->IDirectDrawSurface7_iface, batch, count, flags);
2503 }
2504
2505 static HRESULT WINAPI ddraw_surface1_BltBatch(IDirectDrawSurface *iface, DDBLTBATCH *batch, DWORD count, DWORD flags)
2506 {
2507 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
2508
2509 TRACE("iface %p, batch %p, count %u, flags %#x.\n", iface, batch, count, flags);
2510
2511 return ddraw_surface7_BltBatch(&surface->IDirectDrawSurface7_iface, batch, count, flags);
2512 }
2513
2514 /*****************************************************************************
2515 * IDirectDrawSurface7::EnumAttachedSurfaces
2516 *
2517 * Enumerates all surfaces attached to this surface
2518 *
2519 * Params:
2520 * context: Pointer to pass unmodified to the callback
2521 * cb: Callback function to call for each surface
2522 *
2523 * Returns:
2524 * DD_OK on success
2525 * DDERR_INVALIDPARAMS if cb is NULL
2526 *
2527 *****************************************************************************/
2528 static HRESULT WINAPI ddraw_surface7_EnumAttachedSurfaces(IDirectDrawSurface7 *iface,
2529 void *context, LPDDENUMSURFACESCALLBACK7 cb)
2530 {
2531 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
2532 struct ddraw_surface *surf;
2533 DDSURFACEDESC2 desc;
2534 int i;
2535
2536 /* Attached surfaces aren't handled in WineD3D */
2537 TRACE("iface %p, context %p, callback %p.\n", iface, context, cb);
2538
2539 if(!cb)
2540 return DDERR_INVALIDPARAMS;
2541
2542 wined3d_mutex_lock();
2543
2544 for(i = 0; i < MAX_COMPLEX_ATTACHED; i++)
2545 {
2546 surf = surface->complex_array[i];
2547 if(!surf) break;
2548
2549 ddraw_surface7_AddRef(&surf->IDirectDrawSurface7_iface);
2550 desc = surf->surface_desc;
2551 /* check: != DDENUMRET_OK or == DDENUMRET_CANCEL? */
2552 if (cb(&surf->IDirectDrawSurface7_iface, &desc, context) == DDENUMRET_CANCEL)
2553 {
2554 wined3d_mutex_unlock();
2555 return DD_OK;
2556 }
2557 }
2558
2559 for (surf = surface->next_attached; surf != NULL; surf = surf->next_attached)
2560 {
2561 ddraw_surface7_AddRef(&surf->IDirectDrawSurface7_iface);
2562 desc = surf->surface_desc;
2563 /* check: != DDENUMRET_OK or == DDENUMRET_CANCEL? */
2564 if (cb(&surf->IDirectDrawSurface7_iface, &desc, context) == DDENUMRET_CANCEL)
2565 {
2566 wined3d_mutex_unlock();
2567 return DD_OK;
2568 }
2569 }
2570
2571 TRACE(" end of enumeration.\n");
2572
2573 wined3d_mutex_unlock();
2574
2575 return DD_OK;
2576 }
2577
2578 struct callback_info2
2579 {
2580 LPDDENUMSURFACESCALLBACK2 callback;
2581 void *context;
2582 };
2583
2584 struct callback_info
2585 {
2586 LPDDENUMSURFACESCALLBACK callback;
2587 void *context;
2588 };
2589
2590 static HRESULT CALLBACK EnumCallback2(IDirectDrawSurface7 *surface, DDSURFACEDESC2 *surface_desc, void *context)
2591 {
2592 struct ddraw_surface *surface_impl = impl_from_IDirectDrawSurface7(surface);
2593 const struct callback_info2 *info = context;
2594
2595 ddraw_surface4_AddRef(&surface_impl->IDirectDrawSurface4_iface);
2596 ddraw_surface7_Release(surface);
2597
2598 return info->callback(&surface_impl->IDirectDrawSurface4_iface, surface_desc, info->context);
2599 }
2600
2601 static HRESULT CALLBACK EnumCallback(IDirectDrawSurface7 *surface, DDSURFACEDESC2 *surface_desc, void *context)
2602 {
2603 struct ddraw_surface *surface_impl = impl_from_IDirectDrawSurface7(surface);
2604 const struct callback_info *info = context;
2605
2606 ddraw_surface1_AddRef(&surface_impl->IDirectDrawSurface_iface);
2607 ddraw_surface7_Release(surface);
2608
2609 /* FIXME: Check surface_test.dwSize */
2610 return info->callback(&surface_impl->IDirectDrawSurface_iface,
2611 (DDSURFACEDESC *)surface_desc, info->context);
2612 }
2613
2614 static HRESULT WINAPI ddraw_surface4_EnumAttachedSurfaces(IDirectDrawSurface4 *iface,
2615 void *context, LPDDENUMSURFACESCALLBACK2 callback)
2616 {
2617 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2618 struct callback_info2 info;
2619
2620 TRACE("iface %p, context %p, callback %p.\n", iface, context, callback);
2621
2622 info.callback = callback;
2623 info.context = context;
2624
2625 return ddraw_surface7_EnumAttachedSurfaces(&surface->IDirectDrawSurface7_iface,
2626 &info, EnumCallback2);
2627 }
2628
2629 static HRESULT WINAPI ddraw_surface3_EnumAttachedSurfaces(IDirectDrawSurface3 *iface,
2630 void *context, LPDDENUMSURFACESCALLBACK callback)
2631 {
2632 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
2633 struct callback_info info;
2634
2635 TRACE("iface %p, context %p, callback %p.\n", iface, context, callback);
2636
2637 info.callback = callback;
2638 info.context = context;
2639
2640 return ddraw_surface7_EnumAttachedSurfaces(&surface->IDirectDrawSurface7_iface,
2641 &info, EnumCallback);
2642 }
2643
2644 static HRESULT WINAPI ddraw_surface2_EnumAttachedSurfaces(IDirectDrawSurface2 *iface,
2645 void *context, LPDDENUMSURFACESCALLBACK callback)
2646 {
2647 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
2648 struct callback_info info;
2649
2650 TRACE("iface %p, context %p, callback %p.\n", iface, context, callback);
2651
2652 info.callback = callback;
2653 info.context = context;
2654
2655 return ddraw_surface7_EnumAttachedSurfaces(&surface->IDirectDrawSurface7_iface,
2656 &info, EnumCallback);
2657 }
2658
2659 static HRESULT WINAPI ddraw_surface1_EnumAttachedSurfaces(IDirectDrawSurface *iface,
2660 void *context, LPDDENUMSURFACESCALLBACK callback)
2661 {
2662 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
2663 struct callback_info info;
2664
2665 TRACE("iface %p, context %p, callback %p.\n", iface, context, callback);
2666
2667 info.callback = callback;
2668 info.context = context;
2669
2670 return ddraw_surface7_EnumAttachedSurfaces(&surface->IDirectDrawSurface7_iface,
2671 &info, EnumCallback);
2672 }
2673
2674 /*****************************************************************************
2675 * IDirectDrawSurface7::EnumOverlayZOrders
2676 *
2677 * "Enumerates the overlay surfaces on the specified destination"
2678 *
2679 * Params:
2680 * Flags: DDENUMOVERLAYZ_BACKTOFRONT or DDENUMOVERLAYZ_FRONTTOBACK
2681 * context: context to pass back to the callback
2682 * cb: callback function to call for each enumerated surface
2683 *
2684 * Returns:
2685 * DD_OK, because it's a stub
2686 *
2687 *****************************************************************************/
2688 static HRESULT WINAPI ddraw_surface7_EnumOverlayZOrders(IDirectDrawSurface7 *iface,
2689 DWORD Flags, void *context, LPDDENUMSURFACESCALLBACK7 cb)
2690 {
2691 FIXME("iface %p, flags %#x, context %p, callback %p stub!\n", iface, Flags, context, cb);
2692
2693 return DD_OK;
2694 }
2695
2696 static HRESULT WINAPI ddraw_surface4_EnumOverlayZOrders(IDirectDrawSurface4 *iface,
2697 DWORD flags, void *context, LPDDENUMSURFACESCALLBACK2 callback)
2698 {
2699 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2700 struct callback_info2 info;
2701
2702 TRACE("iface %p, flags %#x, context %p, callback %p.\n", iface, flags, context, callback);
2703
2704 info.callback = callback;
2705 info.context = context;
2706
2707 return ddraw_surface7_EnumOverlayZOrders(&surface->IDirectDrawSurface7_iface,
2708 flags, &info, EnumCallback2);
2709 }
2710
2711 static HRESULT WINAPI ddraw_surface3_EnumOverlayZOrders(IDirectDrawSurface3 *iface,
2712 DWORD flags, void *context, LPDDENUMSURFACESCALLBACK callback)
2713 {
2714 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
2715 struct callback_info info;
2716
2717 TRACE("iface %p, flags %#x, context %p, callback %p.\n", iface, flags, context, callback);
2718
2719 info.callback = callback;
2720 info.context = context;
2721
2722 return ddraw_surface7_EnumOverlayZOrders(&surface->IDirectDrawSurface7_iface,
2723 flags, &info, EnumCallback);
2724 }
2725
2726 static HRESULT WINAPI ddraw_surface2_EnumOverlayZOrders(IDirectDrawSurface2 *iface,
2727 DWORD flags, void *context, LPDDENUMSURFACESCALLBACK callback)
2728 {
2729 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
2730 struct callback_info info;
2731
2732 TRACE("iface %p, flags %#x, context %p, callback %p.\n", iface, flags, context, callback);
2733
2734 info.callback = callback;
2735 info.context = context;
2736
2737 return ddraw_surface7_EnumOverlayZOrders(&surface->IDirectDrawSurface7_iface,
2738 flags, &info, EnumCallback);
2739 }
2740
2741 static HRESULT WINAPI ddraw_surface1_EnumOverlayZOrders(IDirectDrawSurface *iface,
2742 DWORD flags, void *context, LPDDENUMSURFACESCALLBACK callback)
2743 {
2744 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
2745 struct callback_info info;
2746
2747 TRACE("iface %p, flags %#x, context %p, callback %p.\n", iface, flags, context, callback);
2748
2749 info.callback = callback;
2750 info.context = context;
2751
2752 return ddraw_surface7_EnumOverlayZOrders(&surface->IDirectDrawSurface7_iface,
2753 flags, &info, EnumCallback);
2754 }
2755
2756 /*****************************************************************************
2757 * IDirectDrawSurface7::GetBltStatus
2758 *
2759 * Returns the blitting status
2760 *
2761 * Params:
2762 * Flags: DDGBS_CANBLT or DDGBS_ISBLTDONE
2763 *
2764 * Returns:
2765 * See IWineD3DSurface::Blt
2766 *
2767 *****************************************************************************/
2768 static HRESULT WINAPI ddraw_surface7_GetBltStatus(IDirectDrawSurface7 *iface, DWORD Flags)
2769 {
2770 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
2771 HRESULT hr;
2772
2773 TRACE("iface %p, flags %#x.\n", iface, Flags);
2774
2775 wined3d_mutex_lock();
2776 hr = wined3d_surface_get_blt_status(surface->wined3d_surface, Flags);
2777 wined3d_mutex_unlock();
2778 switch(hr)
2779 {
2780 case WINED3DERR_INVALIDCALL: return DDERR_INVALIDPARAMS;
2781 default: return hr;
2782 }
2783 }
2784
2785 static HRESULT WINAPI ddraw_surface4_GetBltStatus(IDirectDrawSurface4 *iface, DWORD flags)
2786 {
2787 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2788
2789 TRACE("iface %p, flags %#x.\n", iface, flags);
2790
2791 return ddraw_surface7_GetBltStatus(&surface->IDirectDrawSurface7_iface, flags);
2792 }
2793
2794 static HRESULT WINAPI ddraw_surface3_GetBltStatus(IDirectDrawSurface3 *iface, DWORD flags)
2795 {
2796 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
2797
2798 TRACE("iface %p, flags %#x.\n", iface, flags);
2799
2800 return ddraw_surface7_GetBltStatus(&surface->IDirectDrawSurface7_iface, flags);
2801 }
2802
2803 static HRESULT WINAPI ddraw_surface2_GetBltStatus(IDirectDrawSurface2 *iface, DWORD flags)
2804 {
2805 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
2806
2807 TRACE("iface %p, flags %#x.\n", iface, flags);
2808
2809 return ddraw_surface7_GetBltStatus(&surface->IDirectDrawSurface7_iface, flags);
2810 }
2811
2812 static HRESULT WINAPI ddraw_surface1_GetBltStatus(IDirectDrawSurface *iface, DWORD flags)
2813 {
2814 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
2815
2816 TRACE("iface %p, flags %#x.\n", iface, flags);
2817
2818 return ddraw_surface7_GetBltStatus(&surface->IDirectDrawSurface7_iface, flags);
2819 }
2820
2821 /*****************************************************************************
2822 * IDirectDrawSurface7::GetColorKey
2823 *
2824 * Returns the color key assigned to the surface
2825 *
2826 * Params:
2827 * Flags: Some flags
2828 * CKey: Address to store the key to
2829 *
2830 * Returns:
2831 * DD_OK on success
2832 * DDERR_INVALIDPARAMS if CKey is NULL
2833 *
2834 *****************************************************************************/
2835 static HRESULT WINAPI ddraw_surface7_GetColorKey(IDirectDrawSurface7 *iface, DWORD Flags, DDCOLORKEY *CKey)
2836 {
2837 struct ddraw_surface *This = impl_from_IDirectDrawSurface7(iface);
2838
2839 TRACE("iface %p, flags %#x, color_key %p.\n", iface, Flags, CKey);
2840
2841 if(!CKey)
2842 return DDERR_INVALIDPARAMS;
2843
2844 wined3d_mutex_lock();
2845
2846 switch (Flags)
2847 {
2848 case DDCKEY_DESTBLT:
2849 if (!(This->surface_desc.dwFlags & DDSD_CKDESTBLT))
2850 {
2851 wined3d_mutex_unlock();
2852 return DDERR_NOCOLORKEY;
2853 }
2854 *CKey = This->surface_desc.ddckCKDestBlt;
2855 break;
2856
2857 case DDCKEY_DESTOVERLAY:
2858 if (!(This->surface_desc.dwFlags & DDSD_CKDESTOVERLAY))
2859 {
2860 wined3d_mutex_unlock();
2861 return DDERR_NOCOLORKEY;
2862 }
2863 *CKey = This->surface_desc.u3.ddckCKDestOverlay;
2864 break;
2865
2866 case DDCKEY_SRCBLT:
2867 if (!(This->surface_desc.dwFlags & DDSD_CKSRCBLT))
2868 {
2869 wined3d_mutex_unlock();
2870 return DDERR_NOCOLORKEY;
2871 }
2872 *CKey = This->surface_desc.ddckCKSrcBlt;
2873 break;
2874
2875 case DDCKEY_SRCOVERLAY:
2876 if (!(This->surface_desc.dwFlags & DDSD_CKSRCOVERLAY))
2877 {
2878 wined3d_mutex_unlock();
2879 return DDERR_NOCOLORKEY;
2880 }
2881 *CKey = This->surface_desc.ddckCKSrcOverlay;
2882 break;
2883
2884 default:
2885 wined3d_mutex_unlock();
2886 return DDERR_INVALIDPARAMS;
2887 }
2888
2889 wined3d_mutex_unlock();
2890
2891 return DD_OK;
2892 }
2893
2894 static HRESULT WINAPI ddraw_surface4_GetColorKey(IDirectDrawSurface4 *iface, DWORD flags, DDCOLORKEY *color_key)
2895 {
2896 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2897
2898 TRACE("iface %p, flags %#x, color_key %p.\n", iface, flags, color_key);
2899
2900 return ddraw_surface7_GetColorKey(&surface->IDirectDrawSurface7_iface, flags, color_key);
2901 }
2902
2903 static HRESULT WINAPI ddraw_surface3_GetColorKey(IDirectDrawSurface3 *iface, DWORD flags, DDCOLORKEY *color_key)
2904 {
2905 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
2906
2907 TRACE("iface %p, flags %#x, color_key %p.\n", iface, flags, color_key);
2908
2909 return ddraw_surface7_GetColorKey(&surface->IDirectDrawSurface7_iface, flags, color_key);
2910 }
2911
2912 static HRESULT WINAPI ddraw_surface2_GetColorKey(IDirectDrawSurface2 *iface, DWORD flags, DDCOLORKEY *color_key)
2913 {
2914 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
2915
2916 TRACE("iface %p, flags %#x, color_key %p.\n", iface, flags, color_key);
2917
2918 return ddraw_surface7_GetColorKey(&surface->IDirectDrawSurface7_iface, flags, color_key);
2919 }
2920
2921 static HRESULT WINAPI ddraw_surface1_GetColorKey(IDirectDrawSurface *iface, DWORD flags, DDCOLORKEY *color_key)
2922 {
2923 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
2924
2925 TRACE("iface %p, flags %#x, color_key %p.\n", iface, flags, color_key);
2926
2927 return ddraw_surface7_GetColorKey(&surface->IDirectDrawSurface7_iface, flags, color_key);
2928 }
2929
2930 /*****************************************************************************
2931 * IDirectDrawSurface7::GetFlipStatus
2932 *
2933 * Returns the flipping status of the surface
2934 *
2935 * Params:
2936 * Flags: DDGFS_CANFLIP of DDGFS_ISFLIPDONE
2937 *
2938 * Returns:
2939 * See IWineD3DSurface::GetFlipStatus
2940 *
2941 *****************************************************************************/
2942 static HRESULT WINAPI ddraw_surface7_GetFlipStatus(IDirectDrawSurface7 *iface, DWORD Flags)
2943 {
2944 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
2945 HRESULT hr;
2946
2947 TRACE("iface %p, flags %#x.\n", iface, Flags);
2948
2949 wined3d_mutex_lock();
2950 hr = wined3d_surface_get_flip_status(surface->wined3d_surface, Flags);
2951 wined3d_mutex_unlock();
2952
2953 switch(hr)
2954 {
2955 case WINED3DERR_INVALIDCALL: return DDERR_INVALIDPARAMS;
2956 default: return hr;
2957 }
2958 }
2959
2960 static HRESULT WINAPI ddraw_surface4_GetFlipStatus(IDirectDrawSurface4 *iface, DWORD flags)
2961 {
2962 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
2963
2964 TRACE("iface %p, flags %#x.\n", iface, flags);
2965
2966 return ddraw_surface7_GetFlipStatus(&surface->IDirectDrawSurface7_iface, flags);
2967 }
2968
2969 static HRESULT WINAPI ddraw_surface3_GetFlipStatus(IDirectDrawSurface3 *iface, DWORD flags)
2970 {
2971 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
2972
2973 TRACE("iface %p, flags %#x.\n", iface, flags);
2974
2975 return ddraw_surface7_GetFlipStatus(&surface->IDirectDrawSurface7_iface, flags);
2976 }
2977
2978 static HRESULT WINAPI ddraw_surface2_GetFlipStatus(IDirectDrawSurface2 *iface, DWORD flags)
2979 {
2980 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
2981
2982 TRACE("iface %p, flags %#x.\n", iface, flags);
2983
2984 return ddraw_surface7_GetFlipStatus(&surface->IDirectDrawSurface7_iface, flags);
2985 }
2986
2987 static HRESULT WINAPI ddraw_surface1_GetFlipStatus(IDirectDrawSurface *iface, DWORD flags)
2988 {
2989 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
2990
2991 TRACE("iface %p, flags %#x.\n", iface, flags);
2992
2993 return ddraw_surface7_GetFlipStatus(&surface->IDirectDrawSurface7_iface, flags);
2994 }
2995
2996 /*****************************************************************************
2997 * IDirectDrawSurface7::GetOverlayPosition
2998 *
2999 * Returns the display coordinates of a visible and active overlay surface
3000 *
3001 * Params:
3002 * X
3003 * Y
3004 *
3005 * Returns:
3006 * DDERR_NOTAOVERLAYSURFACE, because it's a stub
3007 *****************************************************************************/
3008 static HRESULT WINAPI ddraw_surface7_GetOverlayPosition(IDirectDrawSurface7 *iface, LONG *X, LONG *Y)
3009 {
3010 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
3011 HRESULT hr;
3012
3013 TRACE("iface %p, x %p, y %p.\n", iface, X, Y);
3014
3015 wined3d_mutex_lock();
3016 hr = wined3d_surface_get_overlay_position(surface->wined3d_surface, X, Y);
3017 wined3d_mutex_unlock();
3018
3019 return hr;
3020 }
3021
3022 static HRESULT WINAPI ddraw_surface4_GetOverlayPosition(IDirectDrawSurface4 *iface, LONG *x, LONG *y)
3023 {
3024 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3025
3026 TRACE("iface %p, x %p, y %p.\n", iface, x, y);
3027
3028 return ddraw_surface7_GetOverlayPosition(&surface->IDirectDrawSurface7_iface, x, y);
3029 }
3030
3031 static HRESULT WINAPI ddraw_surface3_GetOverlayPosition(IDirectDrawSurface3 *iface, LONG *x, LONG *y)
3032 {
3033 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
3034
3035 TRACE("iface %p, x %p, y %p.\n", iface, x, y);
3036
3037 return ddraw_surface7_GetOverlayPosition(&surface->IDirectDrawSurface7_iface, x, y);
3038 }
3039
3040 static HRESULT WINAPI ddraw_surface2_GetOverlayPosition(IDirectDrawSurface2 *iface, LONG *x, LONG *y)
3041 {
3042 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
3043
3044 TRACE("iface %p, x %p, y %p.\n", iface, x, y);
3045
3046 return ddraw_surface7_GetOverlayPosition(&surface->IDirectDrawSurface7_iface, x, y);
3047 }
3048
3049 static HRESULT WINAPI ddraw_surface1_GetOverlayPosition(IDirectDrawSurface *iface, LONG *x, LONG *y)
3050 {
3051 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
3052
3053 TRACE("iface %p, x %p, y %p.\n", iface, x, y);
3054
3055 return ddraw_surface7_GetOverlayPosition(&surface->IDirectDrawSurface7_iface, x, y);
3056 }
3057
3058 /*****************************************************************************
3059 * IDirectDrawSurface7::GetPixelFormat
3060 *
3061 * Returns the pixel format of the Surface
3062 *
3063 * Params:
3064 * PixelFormat: Pointer to a DDPIXELFORMAT structure to which the pixel
3065 * format should be written
3066 *
3067 * Returns:
3068 * DD_OK on success
3069 * DDERR_INVALIDPARAMS if PixelFormat is NULL
3070 *
3071 *****************************************************************************/
3072 static HRESULT WINAPI ddraw_surface7_GetPixelFormat(IDirectDrawSurface7 *iface, DDPIXELFORMAT *PixelFormat)
3073 {
3074 /* What is DDERR_INVALIDSURFACETYPE for here? */
3075 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
3076
3077 TRACE("iface %p, pixel_format %p.\n", iface, PixelFormat);
3078
3079 if(!PixelFormat)
3080 return DDERR_INVALIDPARAMS;
3081
3082 wined3d_mutex_lock();
3083 DD_STRUCT_COPY_BYSIZE(PixelFormat, &surface->surface_desc.u4.ddpfPixelFormat);
3084 wined3d_mutex_unlock();
3085
3086 return DD_OK;
3087 }
3088
3089 static HRESULT WINAPI ddraw_surface4_GetPixelFormat(IDirectDrawSurface4 *iface, DDPIXELFORMAT *pixel_format)
3090 {
3091 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3092
3093 TRACE("iface %p, pixel_format %p.\n", iface, pixel_format);
3094
3095 return ddraw_surface7_GetPixelFormat(&surface->IDirectDrawSurface7_iface, pixel_format);
3096 }
3097
3098 static HRESULT WINAPI ddraw_surface3_GetPixelFormat(IDirectDrawSurface3 *iface, DDPIXELFORMAT *pixel_format)
3099 {
3100 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
3101
3102 TRACE("iface %p, pixel_format %p.\n", iface, pixel_format);
3103
3104 return ddraw_surface7_GetPixelFormat(&surface->IDirectDrawSurface7_iface, pixel_format);
3105 }
3106
3107 static HRESULT WINAPI ddraw_surface2_GetPixelFormat(IDirectDrawSurface2 *iface, DDPIXELFORMAT *pixel_format)
3108 {
3109 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
3110
3111 TRACE("iface %p, pixel_format %p.\n", iface, pixel_format);
3112
3113 return ddraw_surface7_GetPixelFormat(&surface->IDirectDrawSurface7_iface, pixel_format);
3114 }
3115
3116 static HRESULT WINAPI ddraw_surface1_GetPixelFormat(IDirectDrawSurface *iface, DDPIXELFORMAT *pixel_format)
3117 {
3118 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
3119
3120 TRACE("iface %p, pixel_format %p.\n", iface, pixel_format);
3121
3122 return ddraw_surface7_GetPixelFormat(&surface->IDirectDrawSurface7_iface, pixel_format);
3123 }
3124
3125 /*****************************************************************************
3126 * IDirectDrawSurface7::GetSurfaceDesc
3127 *
3128 * Returns the description of this surface
3129 *
3130 * Params:
3131 * DDSD: Address of a DDSURFACEDESC2 structure that is to be filled with the
3132 * surface desc
3133 *
3134 * Returns:
3135 * DD_OK on success
3136 * DDERR_INVALIDPARAMS if DDSD is NULL
3137 *
3138 *****************************************************************************/
3139 static HRESULT WINAPI ddraw_surface7_GetSurfaceDesc(IDirectDrawSurface7 *iface, DDSURFACEDESC2 *DDSD)
3140 {
3141 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
3142
3143 TRACE("iface %p, surface_desc %p.\n", iface, DDSD);
3144
3145 if(!DDSD)
3146 return DDERR_INVALIDPARAMS;
3147
3148 if (DDSD->dwSize != sizeof(DDSURFACEDESC2))
3149 {
3150 WARN("Incorrect struct size %d, returning DDERR_INVALIDPARAMS\n",DDSD->dwSize);
3151 return DDERR_INVALIDPARAMS;
3152 }
3153
3154 wined3d_mutex_lock();
3155 DD_STRUCT_COPY_BYSIZE(DDSD, &surface->surface_desc);
3156 TRACE("Returning surface desc:\n");
3157 if (TRACE_ON(ddraw)) DDRAW_dump_surface_desc(DDSD);
3158 wined3d_mutex_unlock();
3159
3160 return DD_OK;
3161 }
3162
3163 static HRESULT WINAPI ddraw_surface4_GetSurfaceDesc(IDirectDrawSurface4 *iface, DDSURFACEDESC2 *DDSD)
3164 {
3165 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3166
3167 TRACE("iface %p, surface_desc %p.\n", iface, DDSD);
3168
3169 return ddraw_surface7_GetSurfaceDesc(&surface->IDirectDrawSurface7_iface, DDSD);
3170 }
3171
3172 static HRESULT WINAPI ddraw_surface3_GetSurfaceDesc(IDirectDrawSurface3 *iface, DDSURFACEDESC *surface_desc)
3173 {
3174 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
3175
3176 TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
3177
3178 if (!surface_desc) return DDERR_INVALIDPARAMS;
3179
3180 if (surface_desc->dwSize != sizeof(DDSURFACEDESC))
3181 {
3182 WARN("Incorrect structure size %u, returning DDERR_INVALIDPARAMS.\n", surface_desc->dwSize);
3183 return DDERR_INVALIDPARAMS;
3184 }
3185
3186 wined3d_mutex_lock();
3187 DDSD2_to_DDSD(&surface->surface_desc, surface_desc);
3188 TRACE("Returning surface desc:\n");
3189 if (TRACE_ON(ddraw))
3190 {
3191 /* DDRAW_dump_surface_desc handles the smaller size */
3192 DDRAW_dump_surface_desc((DDSURFACEDESC2 *)surface_desc);
3193 }
3194 wined3d_mutex_unlock();
3195
3196 return DD_OK;
3197 }
3198
3199 static HRESULT WINAPI ddraw_surface2_GetSurfaceDesc(IDirectDrawSurface2 *iface, DDSURFACEDESC *DDSD)
3200 {
3201 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
3202
3203 TRACE("iface %p, surface_desc %p.\n", iface, DDSD);
3204
3205 return ddraw_surface3_GetSurfaceDesc(&surface->IDirectDrawSurface3_iface, DDSD);
3206 }
3207
3208 static HRESULT WINAPI ddraw_surface1_GetSurfaceDesc(IDirectDrawSurface *iface, DDSURFACEDESC *DDSD)
3209 {
3210 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
3211
3212 TRACE("iface %p, surface_desc %p.\n", iface, DDSD);
3213
3214 return ddraw_surface3_GetSurfaceDesc(&surface->IDirectDrawSurface3_iface, DDSD);
3215 }
3216
3217 /*****************************************************************************
3218 * IDirectDrawSurface7::Initialize
3219 *
3220 * Initializes the surface. This is a no-op in Wine
3221 *
3222 * Params:
3223 * DD: Pointer to an DirectDraw interface
3224 * DDSD: Surface description for initialization
3225 *
3226 * Returns:
3227 * DDERR_ALREADYINITIALIZED
3228 *
3229 *****************************************************************************/
3230 static HRESULT WINAPI ddraw_surface7_Initialize(IDirectDrawSurface7 *iface,
3231 IDirectDraw *ddraw, DDSURFACEDESC2 *surface_desc)
3232 {
3233 TRACE("iface %p, ddraw %p, surface_desc %p.\n", iface, ddraw, surface_desc);
3234
3235 return DDERR_ALREADYINITIALIZED;
3236 }
3237
3238 static HRESULT WINAPI ddraw_surface4_Initialize(IDirectDrawSurface4 *iface,
3239 IDirectDraw *ddraw, DDSURFACEDESC2 *surface_desc)
3240 {
3241 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3242
3243 TRACE("iface %p, ddraw %p, surface_desc %p.\n", iface, ddraw, surface_desc);
3244
3245 return ddraw_surface7_Initialize(&surface->IDirectDrawSurface7_iface,
3246 ddraw, surface_desc);
3247 }
3248
3249 static HRESULT WINAPI ddraw_surface3_Initialize(IDirectDrawSurface3 *iface,
3250 IDirectDraw *ddraw, DDSURFACEDESC *surface_desc)
3251 {
3252 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
3253 DDSURFACEDESC2 surface_desc2;
3254
3255 TRACE("iface %p, ddraw %p, surface_desc %p.\n", iface, ddraw, surface_desc);
3256
3257 if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
3258 return ddraw_surface7_Initialize(&surface->IDirectDrawSurface7_iface,
3259 ddraw, surface_desc ? &surface_desc2 : NULL);
3260 }
3261
3262 static HRESULT WINAPI ddraw_surface2_Initialize(IDirectDrawSurface2 *iface,
3263 IDirectDraw *ddraw, DDSURFACEDESC *surface_desc)
3264 {
3265 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
3266 DDSURFACEDESC2 surface_desc2;
3267
3268 TRACE("iface %p, ddraw %p, surface_desc %p.\n", iface, ddraw, surface_desc);
3269
3270 if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
3271 return ddraw_surface7_Initialize(&surface->IDirectDrawSurface7_iface,
3272 ddraw, surface_desc ? &surface_desc2 : NULL);
3273 }
3274
3275 static HRESULT WINAPI ddraw_surface1_Initialize(IDirectDrawSurface *iface,
3276 IDirectDraw *ddraw, DDSURFACEDESC *surface_desc)
3277 {
3278 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
3279 DDSURFACEDESC2 surface_desc2;
3280
3281 TRACE("iface %p, ddraw %p, surface_desc %p.\n", iface, ddraw, surface_desc);
3282
3283 if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
3284 return ddraw_surface7_Initialize(&surface->IDirectDrawSurface7_iface,
3285 ddraw, surface_desc ? &surface_desc2 : NULL);
3286 }
3287
3288 /*****************************************************************************
3289 * IDirect3DTexture1::Initialize
3290 *
3291 * The sdk says it's not implemented
3292 *
3293 * Params:
3294 * ?
3295 *
3296 * Returns
3297 * DDERR_UNSUPPORTED
3298 *
3299 *****************************************************************************/
3300 static HRESULT WINAPI d3d_texture1_Initialize(IDirect3DTexture *iface,
3301 IDirect3DDevice *device, IDirectDrawSurface *surface)
3302 {
3303 TRACE("iface %p, device %p, surface %p.\n", iface, device, surface);
3304
3305 return DDERR_UNSUPPORTED; /* Unchecked */
3306 }
3307
3308 /*****************************************************************************
3309 * IDirectDrawSurface7::IsLost
3310 *
3311 * Checks if the surface is lost
3312 *
3313 * Returns:
3314 * DD_OK, if the surface is usable
3315 * DDERR_ISLOST if the surface is lost
3316 * See IWineD3DSurface::IsLost for more details
3317 *
3318 *****************************************************************************/
3319 static HRESULT WINAPI ddraw_surface7_IsLost(IDirectDrawSurface7 *iface)
3320 {
3321 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
3322 HRESULT hr;
3323
3324 TRACE("iface %p.\n", iface);
3325
3326 wined3d_mutex_lock();
3327 hr = wined3d_surface_is_lost(surface->wined3d_surface);
3328 wined3d_mutex_unlock();
3329
3330 switch(hr)
3331 {
3332 /* D3D8 and 9 loose full devices, thus there's only a DEVICELOST error.
3333 * WineD3D uses the same error for surfaces
3334 */
3335 case WINED3DERR_DEVICELOST: return DDERR_SURFACELOST;
3336 default: return hr;
3337 }
3338 }
3339
3340 static HRESULT WINAPI ddraw_surface4_IsLost(IDirectDrawSurface4 *iface)
3341 {
3342 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3343
3344 TRACE("iface %p.\n", iface);
3345
3346 return ddraw_surface7_IsLost(&surface->IDirectDrawSurface7_iface);
3347 }
3348
3349 static HRESULT WINAPI ddraw_surface3_IsLost(IDirectDrawSurface3 *iface)
3350 {
3351 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
3352
3353 TRACE("iface %p.\n", iface);
3354
3355 return ddraw_surface7_IsLost(&surface->IDirectDrawSurface7_iface);
3356 }
3357
3358 static HRESULT WINAPI ddraw_surface2_IsLost(IDirectDrawSurface2 *iface)
3359 {
3360 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
3361
3362 TRACE("iface %p.\n", iface);
3363
3364 return ddraw_surface7_IsLost(&surface->IDirectDrawSurface7_iface);
3365 }
3366
3367 static HRESULT WINAPI ddraw_surface1_IsLost(IDirectDrawSurface *iface)
3368 {
3369 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
3370
3371 TRACE("iface %p.\n", iface);
3372
3373 return ddraw_surface7_IsLost(&surface->IDirectDrawSurface7_iface);
3374 }
3375
3376 /*****************************************************************************
3377 * IDirectDrawSurface7::Restore
3378 *
3379 * Restores a lost surface. This makes the surface usable again, but
3380 * doesn't reload its old contents
3381 *
3382 * Returns:
3383 * DD_OK on success
3384 * See IWineD3DSurface::Restore for more details
3385 *
3386 *****************************************************************************/
3387 static HRESULT WINAPI ddraw_surface7_Restore(IDirectDrawSurface7 *iface)
3388 {
3389 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
3390 HRESULT hr;
3391
3392 TRACE("iface %p.\n", iface);
3393
3394 wined3d_mutex_lock();
3395 hr = wined3d_surface_restore(surface->wined3d_surface);
3396 wined3d_mutex_unlock();
3397
3398 return hr;
3399 }
3400
3401 static HRESULT WINAPI ddraw_surface4_Restore(IDirectDrawSurface4 *iface)
3402 {
3403 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3404
3405 TRACE("iface %p.\n", iface);
3406
3407 return ddraw_surface7_Restore(&surface->IDirectDrawSurface7_iface);
3408 }
3409
3410 static HRESULT WINAPI ddraw_surface3_Restore(IDirectDrawSurface3 *iface)
3411 {
3412 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
3413
3414 TRACE("iface %p.\n", iface);
3415
3416 return ddraw_surface7_Restore(&surface->IDirectDrawSurface7_iface);
3417 }
3418
3419 static HRESULT WINAPI ddraw_surface2_Restore(IDirectDrawSurface2 *iface)
3420 {
3421 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
3422
3423 TRACE("iface %p.\n", iface);
3424
3425 return ddraw_surface7_Restore(&surface->IDirectDrawSurface7_iface);
3426 }
3427
3428 static HRESULT WINAPI ddraw_surface1_Restore(IDirectDrawSurface *iface)
3429 {
3430 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
3431
3432 TRACE("iface %p.\n", iface);
3433
3434 return ddraw_surface7_Restore(&surface->IDirectDrawSurface7_iface);
3435 }
3436
3437 /*****************************************************************************
3438 * IDirectDrawSurface7::SetOverlayPosition
3439 *
3440 * Changes the display coordinates of an overlay surface
3441 *
3442 * Params:
3443 * X:
3444 * Y:
3445 *
3446 * Returns:
3447 * DDERR_NOTAOVERLAYSURFACE, because we don't support overlays right now
3448 *****************************************************************************/
3449 static HRESULT WINAPI ddraw_surface7_SetOverlayPosition(IDirectDrawSurface7 *iface, LONG X, LONG Y)
3450 {
3451 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
3452 HRESULT hr;
3453
3454 TRACE("iface %p, x %d, y %d.\n", iface, X, Y);
3455
3456 wined3d_mutex_lock();
3457 hr = wined3d_surface_set_overlay_position(surface->wined3d_surface, X, Y);
3458 wined3d_mutex_unlock();
3459
3460 return hr;
3461 }
3462
3463 static HRESULT WINAPI ddraw_surface4_SetOverlayPosition(IDirectDrawSurface4 *iface, LONG x, LONG y)
3464 {
3465 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3466
3467 TRACE("iface %p, x %d, y %d.\n", iface, x, y);
3468
3469 return ddraw_surface7_SetOverlayPosition(&surface->IDirectDrawSurface7_iface, x, y);
3470 }
3471
3472 static HRESULT WINAPI ddraw_surface3_SetOverlayPosition(IDirectDrawSurface3 *iface, LONG x, LONG y)
3473 {
3474 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
3475
3476 TRACE("iface %p, x %d, y %d.\n", iface, x, y);
3477
3478 return ddraw_surface7_SetOverlayPosition(&surface->IDirectDrawSurface7_iface, x, y);
3479 }
3480
3481 static HRESULT WINAPI ddraw_surface2_SetOverlayPosition(IDirectDrawSurface2 *iface, LONG x, LONG y)
3482 {
3483 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
3484
3485 TRACE("iface %p, x %d, y %d.\n", iface, x, y);
3486
3487 return ddraw_surface7_SetOverlayPosition(&surface->IDirectDrawSurface7_iface, x, y);
3488 }
3489
3490 static HRESULT WINAPI ddraw_surface1_SetOverlayPosition(IDirectDrawSurface *iface, LONG x, LONG y)
3491 {
3492 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
3493
3494 TRACE("iface %p, x %d, y %d.\n", iface, x, y);
3495
3496 return ddraw_surface7_SetOverlayPosition(&surface->IDirectDrawSurface7_iface, x, y);
3497 }
3498
3499 /*****************************************************************************
3500 * IDirectDrawSurface7::UpdateOverlay
3501 *
3502 * Modifies the attributes of an overlay surface.
3503 *
3504 * Params:
3505 * SrcRect: The section of the source being used for the overlay
3506 * DstSurface: Address of the surface that is overlaid
3507 * DstRect: Place of the overlay
3508 * Flags: some DDOVER_* flags
3509 *
3510 * Returns:
3511 * DDERR_UNSUPPORTED, because we don't support overlays
3512 *
3513 *****************************************************************************/
3514 static HRESULT WINAPI ddraw_surface7_UpdateOverlay(IDirectDrawSurface7 *iface, RECT *SrcRect,
3515 IDirectDrawSurface7 *DstSurface, RECT *DstRect, DWORD Flags, DDOVERLAYFX *FX)
3516 {
3517 struct ddraw_surface *src_impl = impl_from_IDirectDrawSurface7(iface);
3518 struct ddraw_surface *dst_impl = unsafe_impl_from_IDirectDrawSurface7(DstSurface);
3519 HRESULT hr;
3520
3521 TRACE("iface %p, src_rect %s, dst_surface %p, dst_rect %s, flags %#x, fx %p.\n",
3522 iface, wine_dbgstr_rect(SrcRect), DstSurface, wine_dbgstr_rect(DstRect), Flags, FX);
3523
3524 wined3d_mutex_lock();
3525 hr = wined3d_surface_update_overlay(src_impl->wined3d_surface, SrcRect,
3526 dst_impl ? dst_impl->wined3d_surface : NULL, DstRect, Flags, (WINEDDOVERLAYFX *)FX);
3527 wined3d_mutex_unlock();
3528
3529 switch(hr) {
3530 case WINED3DERR_INVALIDCALL: return DDERR_INVALIDPARAMS;
3531 case WINEDDERR_NOTAOVERLAYSURFACE: return DDERR_NOTAOVERLAYSURFACE;
3532 case WINEDDERR_OVERLAYNOTVISIBLE: return DDERR_OVERLAYNOTVISIBLE;
3533 default:
3534 return hr;
3535 }
3536 }
3537
3538 static HRESULT WINAPI ddraw_surface4_UpdateOverlay(IDirectDrawSurface4 *iface, RECT *src_rect,
3539 IDirectDrawSurface4 *dst_surface, RECT *dst_rect, DWORD flags, DDOVERLAYFX *fx)
3540 {
3541 struct ddraw_surface *src_impl = impl_from_IDirectDrawSurface4(iface);
3542 struct ddraw_surface *dst_impl = unsafe_impl_from_IDirectDrawSurface4(dst_surface);
3543
3544 TRACE("iface %p, src_rect %s, dst_surface %p, dst_rect %s, flags %#x, fx %p.\n",
3545 iface, wine_dbgstr_rect(src_rect), dst_surface, wine_dbgstr_rect(dst_rect), flags, fx);
3546
3547 return ddraw_surface7_UpdateOverlay(&src_impl->IDirectDrawSurface7_iface, src_rect,
3548 dst_impl ? &dst_impl->IDirectDrawSurface7_iface : NULL, dst_rect, flags, fx);
3549 }
3550
3551 static HRESULT WINAPI ddraw_surface3_UpdateOverlay(IDirectDrawSurface3 *iface, RECT *src_rect,
3552 IDirectDrawSurface3 *dst_surface, RECT *dst_rect, DWORD flags, DDOVERLAYFX *fx)
3553 {
3554 struct ddraw_surface *src_impl = impl_from_IDirectDrawSurface3(iface);
3555 struct ddraw_surface *dst_impl = unsafe_impl_from_IDirectDrawSurface3(dst_surface);
3556
3557 TRACE("iface %p, src_rect %s, dst_surface %p, dst_rect %s, flags %#x, fx %p.\n",
3558 iface, wine_dbgstr_rect(src_rect), dst_surface, wine_dbgstr_rect(dst_rect), flags, fx);
3559
3560 return ddraw_surface7_UpdateOverlay(&src_impl->IDirectDrawSurface7_iface, src_rect,
3561 dst_impl ? &dst_impl->IDirectDrawSurface7_iface : NULL, dst_rect, flags, fx);
3562 }
3563
3564 static HRESULT WINAPI ddraw_surface2_UpdateOverlay(IDirectDrawSurface2 *iface, RECT *src_rect,
3565 IDirectDrawSurface2 *dst_surface, RECT *dst_rect, DWORD flags, DDOVERLAYFX *fx)
3566 {
3567 struct ddraw_surface *src_impl = impl_from_IDirectDrawSurface2(iface);
3568 struct ddraw_surface *dst_impl = unsafe_impl_from_IDirectDrawSurface2(dst_surface);
3569
3570 TRACE("iface %p, src_rect %s, dst_surface %p, dst_rect %s, flags %#x, fx %p.\n",
3571 iface, wine_dbgstr_rect(src_rect), dst_surface, wine_dbgstr_rect(dst_rect), flags, fx);
3572
3573 return ddraw_surface7_UpdateOverlay(&src_impl->IDirectDrawSurface7_iface, src_rect,
3574 dst_impl ? &dst_impl->IDirectDrawSurface7_iface : NULL, dst_rect, flags, fx);
3575 }
3576
3577 static HRESULT WINAPI ddraw_surface1_UpdateOverlay(IDirectDrawSurface *iface, RECT *src_rect,
3578 IDirectDrawSurface *dst_surface, RECT *dst_rect, DWORD flags, DDOVERLAYFX *fx)
3579 {
3580 struct ddraw_surface *src_impl = impl_from_IDirectDrawSurface(iface);
3581 struct ddraw_surface *dst_impl = unsafe_impl_from_IDirectDrawSurface(dst_surface);
3582
3583 TRACE("iface %p, src_rect %s, dst_surface %p, dst_rect %s, flags %#x, fx %p.\n",
3584 iface, wine_dbgstr_rect(src_rect), dst_surface, wine_dbgstr_rect(dst_rect), flags, fx);
3585
3586 return ddraw_surface7_UpdateOverlay(&src_impl->IDirectDrawSurface7_iface, src_rect,
3587 dst_impl ? &dst_impl->IDirectDrawSurface7_iface : NULL, dst_rect, flags, fx);
3588 }
3589
3590 /*****************************************************************************
3591 * IDirectDrawSurface7::UpdateOverlayDisplay
3592 *
3593 * The DX7 sdk says that it's not implemented
3594 *
3595 * Params:
3596 * Flags: ?
3597 *
3598 * Returns: DDERR_UNSUPPORTED, because we don't support overlays
3599 *
3600 *****************************************************************************/
3601 static HRESULT WINAPI ddraw_surface7_UpdateOverlayDisplay(IDirectDrawSurface7 *iface, DWORD Flags)
3602 {
3603 TRACE("iface %p, flags %#x.\n", iface, Flags);
3604
3605 return DDERR_UNSUPPORTED;
3606 }
3607
3608 static HRESULT WINAPI ddraw_surface4_UpdateOverlayDisplay(IDirectDrawSurface4 *iface, DWORD flags)
3609 {
3610 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3611
3612 TRACE("iface %p, flags %#x.\n", iface, flags);
3613
3614 return ddraw_surface7_UpdateOverlayDisplay(&surface->IDirectDrawSurface7_iface, flags);
3615 }
3616
3617 static HRESULT WINAPI ddraw_surface3_UpdateOverlayDisplay(IDirectDrawSurface3 *iface, DWORD flags)
3618 {
3619 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
3620
3621 TRACE("iface %p, flags %#x.\n", iface, flags);
3622
3623 return ddraw_surface7_UpdateOverlayDisplay(&surface->IDirectDrawSurface7_iface, flags);
3624 }
3625
3626 static HRESULT WINAPI ddraw_surface2_UpdateOverlayDisplay(IDirectDrawSurface2 *iface, DWORD flags)
3627 {
3628 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
3629
3630 TRACE("iface %p, flags %#x.\n", iface, flags);
3631
3632 return ddraw_surface7_UpdateOverlayDisplay(&surface->IDirectDrawSurface7_iface, flags);
3633 }
3634
3635 static HRESULT WINAPI ddraw_surface1_UpdateOverlayDisplay(IDirectDrawSurface *iface, DWORD flags)
3636 {
3637 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
3638
3639 TRACE("iface %p, flags %#x.\n", iface, flags);
3640
3641 return ddraw_surface7_UpdateOverlayDisplay(&surface->IDirectDrawSurface7_iface, flags);
3642 }
3643
3644 /*****************************************************************************
3645 * IDirectDrawSurface7::UpdateOverlayZOrder
3646 *
3647 * Sets an overlay's Z order
3648 *
3649 * Params:
3650 * Flags: DDOVERZ_* flags
3651 * DDSRef: Defines the relative position in the overlay chain
3652 *
3653 * Returns:
3654 * DDERR_NOTOVERLAYSURFACE, because we don't support overlays
3655 *
3656 *****************************************************************************/
3657 static HRESULT WINAPI ddraw_surface7_UpdateOverlayZOrder(IDirectDrawSurface7 *iface,
3658 DWORD Flags, IDirectDrawSurface7 *DDSRef)
3659 {
3660 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
3661 struct ddraw_surface *reference_impl = unsafe_impl_from_IDirectDrawSurface7(DDSRef);
3662 HRESULT hr;
3663
3664 TRACE("iface %p, flags %#x, reference %p.\n", iface, Flags, DDSRef);
3665
3666 wined3d_mutex_lock();
3667 hr = wined3d_surface_update_overlay_z_order(surface->wined3d_surface,
3668 Flags, reference_impl ? reference_impl->wined3d_surface : NULL);
3669 wined3d_mutex_unlock();
3670
3671 return hr;
3672 }
3673
3674 static HRESULT WINAPI ddraw_surface4_UpdateOverlayZOrder(IDirectDrawSurface4 *iface,
3675 DWORD flags, IDirectDrawSurface4 *reference)
3676 {
3677 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3678 struct ddraw_surface *reference_impl = unsafe_impl_from_IDirectDrawSurface4(reference);
3679
3680 TRACE("iface %p, flags %#x, reference %p.\n", iface, flags, reference);
3681
3682 return ddraw_surface7_UpdateOverlayZOrder(&surface->IDirectDrawSurface7_iface, flags,
3683 reference_impl ? &reference_impl->IDirectDrawSurface7_iface : NULL);
3684 }
3685
3686 static HRESULT WINAPI ddraw_surface3_UpdateOverlayZOrder(IDirectDrawSurface3 *iface,
3687 DWORD flags, IDirectDrawSurface3 *reference)
3688 {
3689 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
3690 struct ddraw_surface *reference_impl = unsafe_impl_from_IDirectDrawSurface3(reference);
3691
3692 TRACE("iface %p, flags %#x, reference %p.\n", iface, flags, reference);
3693
3694 return ddraw_surface7_UpdateOverlayZOrder(&surface->IDirectDrawSurface7_iface, flags,
3695 reference_impl ? &reference_impl->IDirectDrawSurface7_iface : NULL);
3696 }
3697
3698 static HRESULT WINAPI ddraw_surface2_UpdateOverlayZOrder(IDirectDrawSurface2 *iface,
3699 DWORD flags, IDirectDrawSurface2 *reference)
3700 {
3701 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
3702 struct ddraw_surface *reference_impl = unsafe_impl_from_IDirectDrawSurface2(reference);
3703
3704 TRACE("iface %p, flags %#x, reference %p.\n", iface, flags, reference);
3705
3706 return ddraw_surface7_UpdateOverlayZOrder(&surface->IDirectDrawSurface7_iface, flags,
3707 reference_impl ? &reference_impl->IDirectDrawSurface7_iface : NULL);
3708 }
3709
3710 static HRESULT WINAPI ddraw_surface1_UpdateOverlayZOrder(IDirectDrawSurface *iface,
3711 DWORD flags, IDirectDrawSurface *reference)
3712 {
3713 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
3714 struct ddraw_surface *reference_impl = unsafe_impl_from_IDirectDrawSurface(reference);
3715
3716 TRACE("iface %p, flags %#x, reference %p.\n", iface, flags, reference);
3717
3718 return ddraw_surface7_UpdateOverlayZOrder(&surface->IDirectDrawSurface7_iface, flags,
3719 reference_impl ? &reference_impl->IDirectDrawSurface7_iface : NULL);
3720 }
3721
3722 /*****************************************************************************
3723 * IDirectDrawSurface7::GetDDInterface
3724 *
3725 * Returns the IDirectDraw7 interface pointer of the DirectDraw object this
3726 * surface belongs to
3727 *
3728 * Params:
3729 * DD: Address to write the interface pointer to
3730 *
3731 * Returns:
3732 * DD_OK on success
3733 * DDERR_INVALIDPARAMS if DD is NULL
3734 *
3735 *****************************************************************************/
3736 static HRESULT WINAPI ddraw_surface7_GetDDInterface(IDirectDrawSurface7 *iface, void **DD)
3737 {
3738 struct ddraw_surface *This = impl_from_IDirectDrawSurface7(iface);
3739
3740 TRACE("iface %p, ddraw %p.\n", iface, DD);
3741
3742 if(!DD)
3743 return DDERR_INVALIDPARAMS;
3744
3745 switch(This->version)
3746 {
3747 case 7:
3748 *DD = &This->ddraw->IDirectDraw7_iface;
3749 break;
3750
3751 case 4:
3752 *DD = &This->ddraw->IDirectDraw4_iface;
3753 break;
3754
3755 case 2:
3756 *DD = &This->ddraw->IDirectDraw2_iface;
3757 break;
3758
3759 case 1:
3760 *DD = &This->ddraw->IDirectDraw_iface;
3761 break;
3762
3763 }
3764 IUnknown_AddRef((IUnknown *)*DD);
3765
3766 return DD_OK;
3767 }
3768
3769 static HRESULT WINAPI ddraw_surface4_GetDDInterface(IDirectDrawSurface4 *iface, void **ddraw)
3770 {
3771 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3772
3773 TRACE("iface %p, ddraw %p.\n", iface, ddraw);
3774
3775 return ddraw_surface7_GetDDInterface(&surface->IDirectDrawSurface7_iface, ddraw);
3776 }
3777
3778 static HRESULT WINAPI ddraw_surface3_GetDDInterface(IDirectDrawSurface3 *iface, void **ddraw)
3779 {
3780 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
3781
3782 TRACE("iface %p, ddraw %p.\n", iface, ddraw);
3783
3784 return ddraw_surface7_GetDDInterface(&surface->IDirectDrawSurface7_iface, ddraw);
3785 }
3786
3787 static HRESULT WINAPI ddraw_surface2_GetDDInterface(IDirectDrawSurface2 *iface, void **ddraw)
3788 {
3789 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
3790
3791 TRACE("iface %p, ddraw %p.\n", iface, ddraw);
3792
3793 return ddraw_surface7_GetDDInterface(&surface->IDirectDrawSurface7_iface, ddraw);
3794 }
3795
3796 /* This seems also windows implementation specific - I don't think WineD3D needs this */
3797 static HRESULT WINAPI ddraw_surface7_ChangeUniquenessValue(IDirectDrawSurface7 *iface)
3798 {
3799 struct ddraw_surface *This = impl_from_IDirectDrawSurface7(iface);
3800 volatile struct ddraw_surface* vThis = This;
3801
3802 TRACE("iface %p.\n", iface);
3803
3804 wined3d_mutex_lock();
3805 /* A uniqueness value of 0 is apparently special.
3806 * This needs to be checked.
3807 * TODO: Write tests for this code and check if the volatile, interlocked stuff is really needed
3808 */
3809 while (1) {
3810 DWORD old_uniqueness_value = vThis->uniqueness_value;
3811 DWORD new_uniqueness_value = old_uniqueness_value+1;
3812
3813 if (old_uniqueness_value == 0) break;
3814 if (new_uniqueness_value == 0) new_uniqueness_value = 1;
3815
3816 if (InterlockedCompareExchange((LONG*)&vThis->uniqueness_value,
3817 old_uniqueness_value,
3818 new_uniqueness_value)
3819 == old_uniqueness_value)
3820 break;
3821 }
3822
3823 wined3d_mutex_unlock();
3824
3825 return DD_OK;
3826 }
3827
3828 static HRESULT WINAPI ddraw_surface4_ChangeUniquenessValue(IDirectDrawSurface4 *iface)
3829 {
3830 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3831
3832 TRACE("iface %p.\n", iface);
3833
3834 return ddraw_surface7_ChangeUniquenessValue(&surface->IDirectDrawSurface7_iface);
3835 }
3836
3837 static HRESULT WINAPI ddraw_surface7_GetUniquenessValue(IDirectDrawSurface7 *iface, DWORD *pValue)
3838 {
3839 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
3840
3841 TRACE("iface %p, value %p.\n", iface, pValue);
3842
3843 wined3d_mutex_lock();
3844 *pValue = surface->uniqueness_value;
3845 wined3d_mutex_unlock();
3846
3847 return DD_OK;
3848 }
3849
3850 static HRESULT WINAPI ddraw_surface4_GetUniquenessValue(IDirectDrawSurface4 *iface, DWORD *pValue)
3851 {
3852 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
3853
3854 TRACE("iface %p, value %p.\n", iface, pValue);
3855
3856 return ddraw_surface7_GetUniquenessValue(&surface->IDirectDrawSurface7_iface, pValue);
3857 }
3858
3859 /*****************************************************************************
3860 * IDirectDrawSurface7::SetLOD
3861 *
3862 * Sets the level of detail of a texture
3863 *
3864 * Params:
3865 * MaxLOD: LOD to set
3866 *
3867 * Returns:
3868 * DD_OK on success
3869 * DDERR_INVALIDOBJECT if the surface is invalid for this method
3870 *
3871 *****************************************************************************/
3872 static HRESULT WINAPI ddraw_surface7_SetLOD(IDirectDrawSurface7 *iface, DWORD MaxLOD)
3873 {
3874 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
3875 HRESULT hr;
3876
3877 TRACE("iface %p, lod %u.\n", iface, MaxLOD);
3878
3879 wined3d_mutex_lock();
3880 if (!(surface->surface_desc.ddsCaps.dwCaps2 & DDSCAPS2_TEXTUREMANAGE))
3881 {
3882 wined3d_mutex_unlock();
3883 return DDERR_INVALIDOBJECT;
3884 }
3885
3886 if (!surface->wined3d_texture)
3887 {
3888 ERR("The ddraw surface has no wined3d texture.\n");
3889 wined3d_mutex_unlock();
3890 return DDERR_INVALIDOBJECT;
3891 }
3892
3893 hr = wined3d_texture_set_lod(surface->wined3d_texture, MaxLOD);
3894 wined3d_mutex_unlock();
3895
3896 return hr;
3897 }
3898
3899 /*****************************************************************************
3900 * IDirectDrawSurface7::GetLOD
3901 *
3902 * Returns the level of detail of a Direct3D texture
3903 *
3904 * Params:
3905 * MaxLOD: Address to write the LOD to
3906 *
3907 * Returns:
3908 * DD_OK on success
3909 * DDERR_INVALIDPARAMS if MaxLOD is NULL
3910 * DDERR_INVALIDOBJECT if the surface is invalid for this method
3911 *
3912 *****************************************************************************/
3913 static HRESULT WINAPI ddraw_surface7_GetLOD(IDirectDrawSurface7 *iface, DWORD *MaxLOD)
3914 {
3915 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
3916
3917 TRACE("iface %p, lod %p.\n", iface, MaxLOD);
3918
3919 if(!MaxLOD)
3920 return DDERR_INVALIDPARAMS;
3921
3922 wined3d_mutex_lock();
3923 if (!(surface->surface_desc.ddsCaps.dwCaps2 & DDSCAPS2_TEXTUREMANAGE))
3924 {
3925 wined3d_mutex_unlock();
3926 return DDERR_INVALIDOBJECT;
3927 }
3928
3929 *MaxLOD = wined3d_texture_get_lod(surface->wined3d_texture);
3930 wined3d_mutex_unlock();
3931
3932 return DD_OK;
3933 }
3934
3935 /*****************************************************************************
3936 * IDirectDrawSurface7::BltFast
3937 *
3938 * Performs a fast Blit.
3939 *
3940 * Params:
3941 * dstx: The x coordinate to blit to on the destination
3942 * dsty: The y coordinate to blit to on the destination
3943 * Source: The source surface
3944 * rsrc: The source rectangle
3945 * trans: Type of transfer. Some DDBLTFAST_* flags
3946 *
3947 * Returns:
3948 * DD_OK on success
3949 * For more details, see IWineD3DSurface::BltFast
3950 *
3951 *****************************************************************************/
3952 static HRESULT WINAPI ddraw_surface7_BltFast(IDirectDrawSurface7 *iface, DWORD dstx, DWORD dsty,
3953 IDirectDrawSurface7 *Source, RECT *rsrc, DWORD trans)
3954 {
3955 struct ddraw_surface *This = impl_from_IDirectDrawSurface7(iface);
3956 struct ddraw_surface *src = unsafe_impl_from_IDirectDrawSurface7(Source);
3957 DWORD src_w, src_h, dst_w, dst_h;
3958 HRESULT hr = DD_OK;
3959 DWORD flags = 0;
3960 RECT dst_rect;
3961
3962 TRACE("iface %p, dst_x %u, dst_y %u, src_surface %p, src_rect %s, flags %#x.\n",
3963 iface, dstx, dsty, Source, wine_dbgstr_rect(rsrc), trans);
3964
3965 dst_w = This->surface_desc.dwWidth;
3966 dst_h = This->surface_desc.dwHeight;
3967
3968 /* Source must be != NULL, This is not checked by windows. Windows happily throws a 0xc0000005
3969 * in that case
3970 */
3971 if(rsrc)
3972 {
3973 src_w = rsrc->right - rsrc->left;
3974 src_h = rsrc->bottom - rsrc->top;
3975 }
3976 else
3977 {
3978 src_w = src->surface_desc.dwWidth;
3979 src_h = src->surface_desc.dwHeight;
3980 }
3981
3982 if (src_w > dst_w || dstx > dst_w - src_w
3983 || src_h > dst_h || dsty > dst_h - src_h)
3984 {
3985 WARN("Destination area out of bounds, returning DDERR_INVALIDRECT.\n");
3986 return DDERR_INVALIDRECT;
3987 }
3988
3989 SetRect(&dst_rect, dstx, dsty, dstx + src_w, dsty + src_h);
3990 if (trans & DDBLTFAST_SRCCOLORKEY)
3991 flags |= WINEDDBLT_KEYSRC;
3992 if (trans & DDBLTFAST_DESTCOLORKEY)
3993 flags |= WINEDDBLT_KEYDEST;
3994 if (trans & DDBLTFAST_WAIT)
3995 flags |= WINEDDBLT_WAIT;
3996 if (trans & DDBLTFAST_DONOTWAIT)
3997 flags |= WINEDDBLT_DONOTWAIT;
3998
3999 wined3d_mutex_lock();
4000 if (This->clipper)
4001 {
4002 wined3d_mutex_unlock();
4003 WARN("Destination surface has a clipper set, returning DDERR_BLTFASTCANTCLIP.\n");
4004 return DDERR_BLTFASTCANTCLIP;
4005 }
4006
4007 if (src->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
4008 hr = ddraw_surface_update_frontbuffer(src, rsrc, TRUE);
4009 if (SUCCEEDED(hr))
4010 hr = wined3d_surface_blt(This->wined3d_surface, &dst_rect,
4011 src->wined3d_surface, rsrc, flags, NULL, WINED3D_TEXF_POINT);
4012 if (SUCCEEDED(hr) && (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))
4013 hr = ddraw_surface_update_frontbuffer(This, &dst_rect, FALSE);
4014 wined3d_mutex_unlock();
4015
4016 switch(hr)
4017 {
4018 case WINED3DERR_NOTAVAILABLE: return DDERR_UNSUPPORTED;
4019 case WINED3DERR_WRONGTEXTUREFORMAT: return DDERR_INVALIDPIXELFORMAT;
4020 default: return hr;
4021 }
4022 }
4023
4024 static HRESULT WINAPI ddraw_surface4_BltFast(IDirectDrawSurface4 *iface, DWORD dst_x, DWORD dst_y,
4025 IDirectDrawSurface4 *src_surface, RECT *src_rect, DWORD flags)
4026 {
4027 struct ddraw_surface *dst_impl = impl_from_IDirectDrawSurface4(iface);
4028 struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface4(src_surface);
4029
4030 TRACE("iface %p, dst_x %u, dst_y %u, src_surface %p, src_rect %s, flags %#x.\n",
4031 iface, dst_x, dst_y, src_surface, wine_dbgstr_rect(src_rect), flags);
4032
4033 return ddraw_surface7_BltFast(&dst_impl->IDirectDrawSurface7_iface, dst_x, dst_y,
4034 src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, src_rect, flags);
4035 }
4036
4037 static HRESULT WINAPI ddraw_surface3_BltFast(IDirectDrawSurface3 *iface, DWORD dst_x, DWORD dst_y,
4038 IDirectDrawSurface3 *src_surface, RECT *src_rect, DWORD flags)
4039 {
4040 struct ddraw_surface *dst_impl = impl_from_IDirectDrawSurface3(iface);
4041 struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface3(src_surface);
4042
4043 TRACE("iface %p, dst_x %u, dst_y %u, src_surface %p, src_rect %s, flags %#x.\n",
4044 iface, dst_x, dst_y, src_surface, wine_dbgstr_rect(src_rect), flags);
4045
4046 return ddraw_surface7_BltFast(&dst_impl->IDirectDrawSurface7_iface, dst_x, dst_y,
4047 src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, src_rect, flags);
4048 }
4049
4050 static HRESULT WINAPI ddraw_surface2_BltFast(IDirectDrawSurface2 *iface, DWORD dst_x, DWORD dst_y,
4051 IDirectDrawSurface2 *src_surface, RECT *src_rect, DWORD flags)
4052 {
4053 struct ddraw_surface *dst_impl = impl_from_IDirectDrawSurface2(iface);
4054 struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface2(src_surface);
4055
4056 TRACE("iface %p, dst_x %u, dst_y %u, src_surface %p, src_rect %s, flags %#x.\n",
4057 iface, dst_x, dst_y, src_surface, wine_dbgstr_rect(src_rect), flags);
4058
4059 return ddraw_surface7_BltFast(&dst_impl->IDirectDrawSurface7_iface, dst_x, dst_y,
4060 src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, src_rect, flags);
4061 }
4062
4063 static HRESULT WINAPI ddraw_surface1_BltFast(IDirectDrawSurface *iface, DWORD dst_x, DWORD dst_y,
4064 IDirectDrawSurface *src_surface, RECT *src_rect, DWORD flags)
4065 {
4066 struct ddraw_surface *dst_impl = impl_from_IDirectDrawSurface(iface);
4067 struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface(src_surface);
4068
4069 TRACE("iface %p, dst_x %u, dst_y %u, src_surface %p, src_rect %s, flags %#x.\n",
4070 iface, dst_x, dst_y, src_surface, wine_dbgstr_rect(src_rect), flags);
4071
4072 return ddraw_surface7_BltFast(&dst_impl->IDirectDrawSurface7_iface, dst_x, dst_y,
4073 src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, src_rect, flags);
4074 }
4075
4076 /*****************************************************************************
4077 * IDirectDrawSurface7::GetClipper
4078 *
4079 * Returns the IDirectDrawClipper interface of the clipper assigned to this
4080 * surface
4081 *
4082 * Params:
4083 * Clipper: Address to store the interface pointer at
4084 *
4085 * Returns:
4086 * DD_OK on success
4087 * DDERR_INVALIDPARAMS if Clipper is NULL
4088 * DDERR_NOCLIPPERATTACHED if there's no clipper attached
4089 *
4090 *****************************************************************************/
4091 static HRESULT WINAPI ddraw_surface7_GetClipper(IDirectDrawSurface7 *iface, IDirectDrawClipper **Clipper)
4092 {
4093 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
4094
4095 TRACE("iface %p, clipper %p.\n", iface, Clipper);
4096
4097 if (!Clipper)
4098 return DDERR_INVALIDPARAMS;
4099
4100 wined3d_mutex_lock();
4101 if (!surface->clipper)
4102 {
4103 wined3d_mutex_unlock();
4104 return DDERR_NOCLIPPERATTACHED;
4105 }
4106
4107 *Clipper = (IDirectDrawClipper *)surface->clipper;
4108 IDirectDrawClipper_AddRef(*Clipper);
4109 wined3d_mutex_unlock();
4110
4111 return DD_OK;
4112 }
4113
4114 static HRESULT WINAPI ddraw_surface4_GetClipper(IDirectDrawSurface4 *iface, IDirectDrawClipper **clipper)
4115 {
4116 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
4117
4118 TRACE("iface %p, clipper %p.\n", iface, clipper);
4119
4120 return ddraw_surface7_GetClipper(&surface->IDirectDrawSurface7_iface, clipper);
4121 }
4122
4123 static HRESULT WINAPI ddraw_surface3_GetClipper(IDirectDrawSurface3 *iface, IDirectDrawClipper **clipper)
4124 {
4125 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
4126
4127 TRACE("iface %p, clipper %p.\n", iface, clipper);
4128
4129 return ddraw_surface7_GetClipper(&surface->IDirectDrawSurface7_iface, clipper);
4130 }
4131
4132 static HRESULT WINAPI ddraw_surface2_GetClipper(IDirectDrawSurface2 *iface, IDirectDrawClipper **clipper)
4133 {
4134 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
4135
4136 TRACE("iface %p, clipper %p.\n", iface, clipper);
4137
4138 return ddraw_surface7_GetClipper(&surface->IDirectDrawSurface7_iface, clipper);
4139 }
4140
4141 static HRESULT WINAPI ddraw_surface1_GetClipper(IDirectDrawSurface *iface, IDirectDrawClipper **clipper)
4142 {
4143 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
4144
4145 TRACE("iface %p, clipper %p.\n", iface, clipper);
4146
4147 return ddraw_surface7_GetClipper(&surface->IDirectDrawSurface7_iface, clipper);
4148 }
4149
4150 /*****************************************************************************
4151 * IDirectDrawSurface7::SetClipper
4152 *
4153 * Sets a clipper for the surface
4154 *
4155 * Params:
4156 * Clipper: IDirectDrawClipper interface of the clipper to set
4157 *
4158 * Returns:
4159 * DD_OK on success
4160 *
4161 *****************************************************************************/
4162 static HRESULT WINAPI ddraw_surface7_SetClipper(IDirectDrawSurface7 *iface,
4163 IDirectDrawClipper *iclipper)
4164 {
4165 struct ddraw_surface *This = impl_from_IDirectDrawSurface7(iface);
4166 struct ddraw_clipper *clipper = unsafe_impl_from_IDirectDrawClipper(iclipper);
4167 struct ddraw_clipper *old_clipper = This->clipper;
4168 HWND clipWindow;
4169
4170 TRACE("iface %p, clipper %p.\n", iface, iclipper);
4171
4172 wined3d_mutex_lock();
4173 if (clipper == This->clipper)
4174 {
4175 wined3d_mutex_unlock();
4176 return DD_OK;
4177 }
4178
4179 This->clipper = clipper;
4180
4181 if (clipper != NULL)
4182 IDirectDrawClipper_AddRef(iclipper);
4183 if (old_clipper)
4184 IDirectDrawClipper_Release(&old_clipper->IDirectDrawClipper_iface);
4185
4186 if ((This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) && This->ddraw->wined3d_swapchain)
4187 {
4188 clipWindow = NULL;
4189 if(clipper) {
4190 IDirectDrawClipper_GetHWnd(iclipper, &clipWindow);
4191 }
4192
4193 if (clipWindow)
4194 {
4195 wined3d_swapchain_set_window(This->ddraw->wined3d_swapchain, clipWindow);
4196 ddraw_set_swapchain_window(This->ddraw, clipWindow);
4197 }
4198 else
4199 {
4200 wined3d_swapchain_set_window(This->ddraw->wined3d_swapchain, This->ddraw->d3d_window);
4201 ddraw_set_swapchain_window(This->ddraw, This->ddraw->dest_window);
4202 }
4203 }
4204
4205 wined3d_mutex_unlock();
4206
4207 return DD_OK;
4208 }
4209
4210 static HRESULT WINAPI ddraw_surface4_SetClipper(IDirectDrawSurface4 *iface, IDirectDrawClipper *clipper)
4211 {
4212 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
4213
4214 TRACE("iface %p, clipper %p.\n", iface, clipper);
4215
4216 return ddraw_surface7_SetClipper(&surface->IDirectDrawSurface7_iface, clipper);
4217 }
4218
4219 static HRESULT WINAPI ddraw_surface3_SetClipper(IDirectDrawSurface3 *iface, IDirectDrawClipper *clipper)
4220 {
4221 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
4222
4223 TRACE("iface %p, clipper %p.\n", iface, clipper);
4224
4225 return ddraw_surface7_SetClipper(&surface->IDirectDrawSurface7_iface, clipper);
4226 }
4227
4228 static HRESULT WINAPI ddraw_surface2_SetClipper(IDirectDrawSurface2 *iface, IDirectDrawClipper *clipper)
4229 {
4230 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
4231
4232 TRACE("iface %p, clipper %p.\n", iface, clipper);
4233
4234 return ddraw_surface7_SetClipper(&surface->IDirectDrawSurface7_iface, clipper);
4235 }
4236
4237 static HRESULT WINAPI ddraw_surface1_SetClipper(IDirectDrawSurface *iface, IDirectDrawClipper *clipper)
4238 {
4239 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
4240
4241 TRACE("iface %p, clipper %p.\n", iface, clipper);
4242
4243 return ddraw_surface7_SetClipper(&surface->IDirectDrawSurface7_iface, clipper);
4244 }
4245
4246 /*****************************************************************************
4247 * IDirectDrawSurface7::SetSurfaceDesc
4248 *
4249 * Sets the surface description. It can override the pixel format, the surface
4250 * memory, ...
4251 * It's not really tested.
4252 *
4253 * Params:
4254 * DDSD: Pointer to the new surface description to set
4255 * Flags: Some flags
4256 *
4257 * Returns:
4258 * DD_OK on success
4259 * DDERR_INVALIDPARAMS if DDSD is NULL
4260 *
4261 *****************************************************************************/
4262 static HRESULT WINAPI ddraw_surface7_SetSurfaceDesc(IDirectDrawSurface7 *iface, DDSURFACEDESC2 *DDSD, DWORD Flags)
4263 {
4264 struct ddraw_surface *This = impl_from_IDirectDrawSurface7(iface);
4265 HRESULT hr;
4266 const DWORD allowed_flags = DDSD_LPSURFACE | DDSD_PIXELFORMAT | DDSD_WIDTH
4267 | DDSD_HEIGHT | DDSD_PITCH | DDSD_CAPS;
4268 enum wined3d_format_id format_id;
4269 UINT pitch, width, height;
4270
4271 TRACE("iface %p, surface_desc %p, flags %#x.\n", iface, DDSD, Flags);
4272
4273 if (!DDSD)
4274 {
4275 WARN("DDSD is NULL, returning DDERR_INVALIDPARAMS\n");
4276 return DDERR_INVALIDPARAMS;
4277 }
4278 if (Flags)
4279 {
4280 WARN("Flags is %x, returning DDERR_INVALIDPARAMS\n", Flags);
4281 return DDERR_INVALIDPARAMS;
4282 }
4283 if (!(This->surface_desc.ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY)
4284 || This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE
4285 || This->surface_desc.ddsCaps.dwCaps2 & (DDSCAPS2_TEXTUREMANAGE | DDSCAPS2_D3DTEXTUREMANAGE))
4286 {
4287 WARN("Surface is not in system memory, returning DDERR_INVALIDSURFACETYPE.\n");
4288 return DDERR_INVALIDSURFACETYPE;
4289 }
4290
4291 /* Tests show that only LPSURFACE and PIXELFORMAT can be set, and LPSURFACE is required
4292 * for PIXELFORMAT to work */
4293 if (DDSD->dwFlags & ~allowed_flags)
4294 {
4295 WARN("Invalid flags (0x%08x) set, returning DDERR_INVALIDPARAMS\n", DDSD->dwFlags);
4296 return DDERR_INVALIDPARAMS;
4297 }
4298 if (!(DDSD->dwFlags & DDSD_LPSURFACE) || !DDSD->lpSurface)
4299 {
4300 WARN("DDSD_LPSURFACE is not set or lpSurface is NULL, returning DDERR_INVALIDPARAMS\n");
4301 return DDERR_INVALIDPARAMS;
4302 }
4303 if ((DDSD->dwFlags & DDSD_CAPS) && DDSD->ddsCaps.dwCaps)
4304 {
4305 WARN("DDSD_CAPS is set, returning DDERR_INVALIDCAPS.\n");
4306 return DDERR_INVALIDCAPS;
4307 }
4308 if (DDSD->dwFlags & DDSD_WIDTH)
4309 {
4310 if (!(DDSD->dwFlags & DDSD_PITCH))
4311 {
4312 WARN("DDSD_WIDTH is set, but DDSD_PITCH is not, returning DDERR_INVALIDPARAMS.\n");
4313 return DDERR_INVALIDPARAMS;
4314 }
4315 if (!DDSD->dwWidth || DDSD->u1.lPitch <= 0 || DDSD->u1.lPitch & 0x3)
4316 {
4317 WARN("Pitch is %d, width is %u, returning DDERR_INVALIDPARAMS.\n",
4318 DDSD->u1.lPitch, DDSD->dwWidth);
4319 return DDERR_INVALIDPARAMS;
4320 }
4321 if (DDSD->dwWidth != This->surface_desc.dwWidth)
4322 TRACE("Surface width changed from %u to %u.\n", This->surface_desc.dwWidth, DDSD->dwWidth);
4323 if (DDSD->u1.lPitch != This->surface_desc.u1.lPitch)
4324 TRACE("Surface pitch changed from %u to %u.\n", This->surface_desc.u1.lPitch, DDSD->u1.lPitch);
4325 pitch = DDSD->u1.lPitch;
4326 width = DDSD->dwWidth;
4327 }
4328 else if (DDSD->dwFlags & DDSD_PITCH)
4329 {
4330 WARN("DDSD_PITCH is set, but DDSD_WIDTH is not, returning DDERR_INVALIDPARAMS.\n");
4331 return DDERR_INVALIDPARAMS;
4332 }
4333 else
4334 {
4335 pitch = This->surface_desc.u1.lPitch;
4336 width = This->surface_desc.dwWidth;
4337 }
4338
4339 if (DDSD->dwFlags & DDSD_HEIGHT)
4340 {
4341 if (!DDSD->dwHeight)
4342 {
4343 WARN("Height is 0, returning DDERR_INVALIDPARAMS.\n");
4344 return DDERR_INVALIDPARAMS;
4345 }
4346 if (DDSD->dwHeight != This->surface_desc.dwHeight)
4347 TRACE("Surface height changed from %u to %u.\n", This->surface_desc.dwHeight, DDSD->dwHeight);
4348 height = DDSD->dwHeight;
4349 }
4350 else
4351 {
4352 height = This->surface_desc.dwHeight;
4353 }
4354
4355 wined3d_mutex_lock();
4356 if (DDSD->dwFlags & DDSD_PIXELFORMAT)
4357 {
4358 enum wined3d_format_id current_format_id;
4359 format_id = wined3dformat_from_ddrawformat(&DDSD->u4.ddpfPixelFormat);
4360
4361 if (format_id == WINED3DFMT_UNKNOWN)
4362 {
4363 ERR("Requested to set an unknown pixelformat\n");
4364 wined3d_mutex_unlock();
4365 return DDERR_INVALIDPARAMS;
4366 }
4367 current_format_id = wined3dformat_from_ddrawformat(&This->surface_desc.u4.ddpfPixelFormat);
4368 if (format_id != current_format_id)
4369 TRACE("Surface format changed from %#x to %#x.\n", current_format_id, format_id);
4370 }
4371 else
4372 {
4373 format_id = wined3dformat_from_ddrawformat(&This->surface_desc.u4.ddpfPixelFormat);
4374 }
4375
4376 if (FAILED(hr = wined3d_surface_update_desc(This->wined3d_surface, width, height,
4377 format_id, WINED3D_MULTISAMPLE_NONE, 0, DDSD->lpSurface, pitch)))
4378 {
4379 WARN("Failed to update surface desc, hr %#x.\n", hr);
4380 wined3d_mutex_unlock();
4381 return hr_ddraw_from_wined3d(hr);
4382 }
4383
4384 if (DDSD->dwFlags & DDSD_WIDTH)
4385 This->surface_desc.dwWidth = width;
4386 if (DDSD->dwFlags & DDSD_PITCH)
4387 This->surface_desc.u1.lPitch = DDSD->u1.lPitch;
4388 if (DDSD->dwFlags & DDSD_HEIGHT)
4389 This->surface_desc.dwHeight = height;
4390 if (DDSD->dwFlags & DDSD_PIXELFORMAT)
4391 This->surface_desc.u4.ddpfPixelFormat = DDSD->u4.ddpfPixelFormat;
4392
4393 wined3d_mutex_unlock();
4394
4395 return DD_OK;
4396 }
4397
4398 static HRESULT WINAPI ddraw_surface4_SetSurfaceDesc(IDirectDrawSurface4 *iface,
4399 DDSURFACEDESC2 *surface_desc, DWORD flags)
4400 {
4401 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
4402
4403 TRACE("iface %p, surface_desc %p, flags %#x.\n", iface, surface_desc, flags);
4404
4405 return ddraw_surface7_SetSurfaceDesc(&surface->IDirectDrawSurface7_iface,
4406 surface_desc, flags);
4407 }
4408
4409 static HRESULT WINAPI ddraw_surface3_SetSurfaceDesc(IDirectDrawSurface3 *iface,
4410 DDSURFACEDESC *surface_desc, DWORD flags)
4411 {
4412 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
4413 DDSURFACEDESC2 surface_desc2;
4414
4415 TRACE("iface %p, surface_desc %p, flags %#x.\n", iface, surface_desc, flags);
4416
4417 if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
4418 return ddraw_surface7_SetSurfaceDesc(&surface->IDirectDrawSurface7_iface,
4419 surface_desc ? &surface_desc2 : NULL, flags);
4420 }
4421
4422 static HRESULT WINAPI ddraw_surface7_GetPalette(IDirectDrawSurface7 *iface, IDirectDrawPalette **palette)
4423 {
4424 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
4425 struct ddraw_palette *palette_impl;
4426 HRESULT hr = DD_OK;
4427
4428 TRACE("iface %p, palette %p.\n", iface, palette);
4429
4430 if (!palette)
4431 return DDERR_INVALIDPARAMS;
4432
4433 wined3d_mutex_lock();
4434 if ((palette_impl = surface->palette))
4435 {
4436 *palette = &palette_impl->IDirectDrawPalette_iface;
4437 IDirectDrawPalette_AddRef(*palette);
4438 }
4439 else
4440 {
4441 *palette = NULL;
4442 hr = DDERR_NOPALETTEATTACHED;
4443 }
4444 wined3d_mutex_unlock();
4445
4446 return hr;
4447 }
4448
4449 static HRESULT WINAPI ddraw_surface4_GetPalette(IDirectDrawSurface4 *iface, IDirectDrawPalette **palette)
4450 {
4451 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
4452
4453 TRACE("iface %p, palette %p.\n", iface, palette);
4454
4455 return ddraw_surface7_GetPalette(&surface->IDirectDrawSurface7_iface, palette);
4456 }
4457
4458 static HRESULT WINAPI ddraw_surface3_GetPalette(IDirectDrawSurface3 *iface, IDirectDrawPalette **palette)
4459 {
4460 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
4461
4462 TRACE("iface %p, palette %p.\n", iface, palette);
4463
4464 return ddraw_surface7_GetPalette(&surface->IDirectDrawSurface7_iface, palette);
4465 }
4466
4467 static HRESULT WINAPI ddraw_surface2_GetPalette(IDirectDrawSurface2 *iface, IDirectDrawPalette **palette)
4468 {
4469 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
4470
4471 TRACE("iface %p, palette %p.\n", iface, palette);
4472
4473 return ddraw_surface7_GetPalette(&surface->IDirectDrawSurface7_iface, palette);
4474 }
4475
4476 static HRESULT WINAPI ddraw_surface1_GetPalette(IDirectDrawSurface *iface, IDirectDrawPalette **palette)
4477 {
4478 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
4479
4480 TRACE("iface %p, palette %p.\n", iface, palette);
4481
4482 return ddraw_surface7_GetPalette(&surface->IDirectDrawSurface7_iface, palette);
4483 }
4484
4485 static HRESULT ddraw_surface_set_color_key(struct ddraw_surface *surface, DWORD flags, DDCOLORKEY *color_key)
4486 {
4487 DDCOLORKEY fixed_color_key;
4488 HRESULT hr = WINED3D_OK;
4489
4490 wined3d_mutex_lock();
4491
4492 if (color_key)
4493 {
4494 fixed_color_key = *color_key;
4495 /* Handle case where dwColorSpaceHighValue < dwColorSpaceLowValue */
4496 if (fixed_color_key.dwColorSpaceHighValue < fixed_color_key.dwColorSpaceLowValue)
4497 fixed_color_key.dwColorSpaceHighValue = fixed_color_key.dwColorSpaceLowValue;
4498
4499 switch (flags & ~DDCKEY_COLORSPACE)
4500 {
4501 case DDCKEY_DESTBLT:
4502 surface->surface_desc.ddckCKDestBlt = fixed_color_key;
4503 surface->surface_desc.dwFlags |= DDSD_CKDESTBLT;
4504 break;
4505
4506 case DDCKEY_DESTOVERLAY:
4507 surface->surface_desc.u3.ddckCKDestOverlay = fixed_color_key;
4508 surface->surface_desc.dwFlags |= DDSD_CKDESTOVERLAY;
4509 break;
4510
4511 case DDCKEY_SRCOVERLAY:
4512 surface->surface_desc.ddckCKSrcOverlay = fixed_color_key;
4513 surface->surface_desc.dwFlags |= DDSD_CKSRCOVERLAY;
4514 break;
4515
4516 case DDCKEY_SRCBLT:
4517 surface->surface_desc.ddckCKSrcBlt = fixed_color_key;
4518 surface->surface_desc.dwFlags |= DDSD_CKSRCBLT;
4519 break;
4520
4521 default:
4522 wined3d_mutex_unlock();
4523 return DDERR_INVALIDPARAMS;
4524 }
4525 }
4526 else
4527 {
4528 switch (flags & ~DDCKEY_COLORSPACE)
4529 {
4530 case DDCKEY_DESTBLT:
4531 surface->surface_desc.dwFlags &= ~DDSD_CKDESTBLT;
4532 break;
4533
4534 case DDCKEY_DESTOVERLAY:
4535 surface->surface_desc.dwFlags &= ~DDSD_CKDESTOVERLAY;
4536 break;
4537
4538 case DDCKEY_SRCOVERLAY:
4539 surface->surface_desc.dwFlags &= ~DDSD_CKSRCOVERLAY;
4540 break;
4541
4542 case DDCKEY_SRCBLT:
4543 surface->surface_desc.dwFlags &= ~DDSD_CKSRCBLT;
4544 break;
4545
4546 default:
4547 wined3d_mutex_unlock();
4548 return DDERR_INVALIDPARAMS;
4549 }
4550 }
4551
4552 if (surface->wined3d_texture)
4553 hr = wined3d_texture_set_color_key(surface->wined3d_texture, flags,
4554 color_key ? (struct wined3d_color_key *)&fixed_color_key : NULL);
4555
4556 wined3d_mutex_unlock();
4557
4558 return hr_ddraw_from_wined3d(hr);
4559 }
4560
4561 static HRESULT WINAPI ddraw_surface7_SetColorKey(IDirectDrawSurface7 *iface, DWORD flags, DDCOLORKEY *color_key)
4562 {
4563 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
4564
4565 TRACE("iface %p, flags %#x, color_key %p.\n", iface, flags, color_key);
4566
4567 wined3d_mutex_lock();
4568 if (!surface->wined3d_texture)
4569 {
4570 wined3d_mutex_unlock();
4571 return DDERR_NOTONMIPMAPSUBLEVEL;
4572 }
4573 wined3d_mutex_unlock();
4574
4575 return ddraw_surface_set_color_key(surface, flags, color_key);
4576 }
4577
4578 static HRESULT WINAPI ddraw_surface4_SetColorKey(IDirectDrawSurface4 *iface, DWORD flags, DDCOLORKEY *color_key)
4579 {
4580 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
4581
4582 TRACE("iface %p, flags %#x, color_key %p.\n", iface, flags, color_key);
4583
4584 return ddraw_surface_set_color_key(surface, flags, color_key);
4585 }
4586
4587 static HRESULT WINAPI ddraw_surface3_SetColorKey(IDirectDrawSurface3 *iface, DWORD flags, DDCOLORKEY *color_key)
4588 {
4589 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
4590
4591 TRACE("iface %p, flags %#x, color_key %p.\n", iface, flags, color_key);
4592
4593 return ddraw_surface_set_color_key(surface, flags, color_key);
4594 }
4595
4596 static HRESULT WINAPI ddraw_surface2_SetColorKey(IDirectDrawSurface2 *iface, DWORD flags, DDCOLORKEY *color_key)
4597 {
4598 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
4599
4600 TRACE("iface %p, flags %#x, color_key %p.\n", iface, flags, color_key);
4601
4602 return ddraw_surface_set_color_key(surface, flags, color_key);
4603 }
4604
4605 static HRESULT WINAPI ddraw_surface1_SetColorKey(IDirectDrawSurface *iface, DWORD flags, DDCOLORKEY *color_key)
4606 {
4607 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
4608
4609 TRACE("iface %p, flags %#x, color_key %p.\n", iface, flags, color_key);
4610
4611 return ddraw_surface_set_color_key(surface, flags, color_key);
4612 }
4613
4614 static HRESULT WINAPI ddraw_surface7_SetPalette(IDirectDrawSurface7 *iface, IDirectDrawPalette *palette)
4615 {
4616 struct ddraw_surface *surface = impl_from_IDirectDrawSurface7(iface);
4617 struct ddraw_palette *palette_impl = unsafe_impl_from_IDirectDrawPalette(palette);
4618 struct ddraw_palette *prev;
4619
4620 TRACE("iface %p, palette %p.\n", iface, palette);
4621
4622 if (!(surface->surface_desc.u4.ddpfPixelFormat.dwFlags & (DDPF_PALETTEINDEXED1 | DDPF_PALETTEINDEXED2
4623 | DDPF_PALETTEINDEXED4 | DDPF_PALETTEINDEXED8 | DDPF_PALETTEINDEXEDTO8)))
4624 return DDERR_INVALIDPIXELFORMAT;
4625
4626 if (surface->surface_desc.ddsCaps.dwCaps2 & DDSCAPS2_MIPMAPSUBLEVEL)
4627 return DDERR_NOTONMIPMAPSUBLEVEL;
4628
4629 wined3d_mutex_lock();
4630
4631 prev = surface->palette;
4632 if (surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
4633 {
4634 if (prev)
4635 prev->flags &= ~DDPCAPS_PRIMARYSURFACE;
4636 if (palette_impl)
4637 palette_impl->flags |= DDPCAPS_PRIMARYSURFACE;
4638 /* Update the wined3d frontbuffer if this is the primary. */
4639 if (surface->ddraw->wined3d_frontbuffer)
4640 wined3d_surface_set_palette(surface->ddraw->wined3d_frontbuffer,
4641 palette_impl ? palette_impl->wineD3DPalette : NULL);
4642 }
4643 if (palette_impl)
4644 IDirectDrawPalette_AddRef(&palette_impl->IDirectDrawPalette_iface);
4645 if (prev)
4646 IDirectDrawPalette_Release(&prev->IDirectDrawPalette_iface);
4647 surface->palette = palette_impl;
4648 wined3d_surface_set_palette(surface->wined3d_surface, palette_impl ? palette_impl->wineD3DPalette : NULL);
4649
4650 wined3d_mutex_unlock();
4651
4652 return DD_OK;
4653 }
4654
4655 static HRESULT WINAPI ddraw_surface4_SetPalette(IDirectDrawSurface4 *iface, IDirectDrawPalette *palette)
4656 {
4657 struct ddraw_surface *surface = impl_from_IDirectDrawSurface4(iface);
4658
4659 TRACE("iface %p, palette %p.\n", iface, palette);
4660
4661 return ddraw_surface7_SetPalette(&surface->IDirectDrawSurface7_iface, palette);
4662 }
4663
4664 static HRESULT WINAPI ddraw_surface3_SetPalette(IDirectDrawSurface3 *iface, IDirectDrawPalette *palette)
4665 {
4666 struct ddraw_surface *surface = impl_from_IDirectDrawSurface3(iface);
4667
4668 TRACE("iface %p, palette %p.\n", iface, palette);
4669
4670 return ddraw_surface7_SetPalette(&surface->IDirectDrawSurface7_iface, palette);
4671 }
4672
4673 static HRESULT WINAPI ddraw_surface2_SetPalette(IDirectDrawSurface2 *iface, IDirectDrawPalette *palette)
4674 {
4675 struct ddraw_surface *surface = impl_from_IDirectDrawSurface2(iface);
4676
4677 TRACE("iface %p, palette %p.\n", iface, palette);
4678
4679 return ddraw_surface7_SetPalette(&surface->IDirectDrawSurface7_iface, palette);
4680 }
4681
4682 static HRESULT WINAPI ddraw_surface1_SetPalette(IDirectDrawSurface *iface, IDirectDrawPalette *palette)
4683 {
4684 struct ddraw_surface *surface = impl_from_IDirectDrawSurface(iface);
4685
4686 TRACE("iface %p, palette %p.\n", iface, palette);
4687
4688 return ddraw_surface7_SetPalette(&surface->IDirectDrawSurface7_iface, palette);
4689 }
4690
4691 /**********************************************************
4692 * IDirectDrawGammaControl::GetGammaRamp
4693 *
4694 * Returns the current gamma ramp for a surface
4695 *
4696 * Params:
4697 * flags: Ignored
4698 * gamma_ramp: Address to write the ramp to
4699 *
4700 * Returns:
4701 * DD_OK on success
4702 * DDERR_INVALIDPARAMS if gamma_ramp is NULL
4703 *
4704 **********************************************************/
4705 static HRESULT WINAPI ddraw_gamma_control_GetGammaRamp(IDirectDrawGammaControl *iface,
4706 DWORD flags, DDGAMMARAMP *gamma_ramp)
4707 {
4708 struct ddraw_surface *surface = impl_from_IDirectDrawGammaControl(iface);
4709
4710 TRACE("iface %p, flags %#x, gamma_ramp %p.\n", iface, flags, gamma_ramp);
4711
4712 if (!gamma_ramp)
4713 {
4714 WARN("Invalid gamma_ramp passed.\n");
4715 return DDERR_INVALIDPARAMS;
4716 }
4717
4718 wined3d_mutex_lock();
4719 if (surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
4720 {
4721 /* Note: DDGAMMARAMP is compatible with struct wined3d_gamma_ramp. */
4722 wined3d_device_get_gamma_ramp(surface->ddraw->wined3d_device, 0, (struct wined3d_gamma_ramp *)gamma_ramp);
4723 }
4724 else
4725 {
4726 ERR("Not implemented for non-primary surfaces.\n");
4727 }
4728 wined3d_mutex_unlock();
4729
4730 return DD_OK;
4731 }
4732
4733 /**********************************************************
4734 * IDirectDrawGammaControl::SetGammaRamp
4735 *
4736 * Sets the red, green and blue gamma ramps for
4737 *
4738 * Params:
4739 * flags: Can be DDSGR_CALIBRATE to request calibration
4740 * gamma_ramp: Structure containing the new gamma ramp
4741 *
4742 * Returns:
4743 * DD_OK on success
4744 * DDERR_INVALIDPARAMS if gamma_ramp is NULL
4745 *
4746 **********************************************************/
4747 static HRESULT WINAPI ddraw_gamma_control_SetGammaRamp(IDirectDrawGammaControl *iface,
4748 DWORD flags, DDGAMMARAMP *gamma_ramp)
4749 {
4750 struct ddraw_surface *surface = impl_from_IDirectDrawGammaControl(iface);
4751
4752 TRACE("iface %p, flags %#x, gamma_ramp %p.\n", iface, flags, gamma_ramp);
4753
4754 if (!gamma_ramp)
4755 {
4756 WARN("Invalid gamma_ramp passed.\n");
4757 return DDERR_INVALIDPARAMS;
4758 }
4759
4760 wined3d_mutex_lock();
4761 if (surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
4762 {
4763 /* Note: DDGAMMARAMP is compatible with struct wined3d_gamma_ramp. */
4764 wined3d_device_set_gamma_ramp(surface->ddraw->wined3d_device,
4765 0, flags, (struct wined3d_gamma_ramp *)gamma_ramp);
4766 }
4767 else
4768 {
4769 ERR("Not implemented for non-primary surfaces.\n");
4770 }
4771 wined3d_mutex_unlock();
4772
4773 return DD_OK;
4774 }
4775
4776 /*****************************************************************************
4777 * IDirect3DTexture2::PaletteChanged
4778 *
4779 * Informs the texture about a palette change
4780 *
4781 * Params:
4782 * start: Start index of the change
4783 * count: The number of changed entries
4784 *
4785 * Returns
4786 * D3D_OK, because it's a stub
4787 *
4788 *****************************************************************************/
4789 static HRESULT WINAPI d3d_texture2_PaletteChanged(IDirect3DTexture2 *iface, DWORD start, DWORD count)
4790 {
4791 FIXME("iface %p, start %u, count %u stub!\n", iface, start, count);
4792
4793 return D3D_OK;
4794 }
4795
4796 static HRESULT WINAPI d3d_texture1_PaletteChanged(IDirect3DTexture *iface, DWORD start, DWORD count)
4797 {
4798 struct ddraw_surface *surface = impl_from_IDirect3DTexture(iface);
4799
4800 TRACE("iface %p, start %u, count %u.\n", iface, start, count);
4801
4802 return d3d_texture2_PaletteChanged(&surface->IDirect3DTexture2_iface, start, count);
4803 }
4804
4805 /*****************************************************************************
4806 * IDirect3DTexture::Unload
4807 *
4808 * DX5 SDK: "The IDirect3DTexture2::Unload method is not implemented
4809 *
4810 *
4811 * Returns:
4812 * DDERR_UNSUPPORTED
4813 *
4814 *****************************************************************************/
4815 static HRESULT WINAPI d3d_texture1_Unload(IDirect3DTexture *iface)
4816 {
4817 WARN("iface %p. Not implemented.\n", iface);
4818
4819 return DDERR_UNSUPPORTED;
4820 }
4821
4822 /*****************************************************************************
4823 * IDirect3DTexture2::GetHandle
4824 *
4825 * Returns handle for the texture. At the moment, the interface
4826 * to the IWineD3DTexture is used.
4827 *
4828 * Params:
4829 * device: Device this handle is assigned to
4830 * handle: Address to store the handle at.
4831 *
4832 * Returns:
4833 * D3D_OK
4834 *
4835 *****************************************************************************/
4836 static HRESULT WINAPI d3d_texture2_GetHandle(IDirect3DTexture2 *iface,
4837 IDirect3DDevice2 *device, D3DTEXTUREHANDLE *handle)
4838 {
4839 struct ddraw_surface *surface = impl_from_IDirect3DTexture2(iface);
4840 struct d3d_device *device_impl = unsafe_impl_from_IDirect3DDevice2(device);
4841
4842 TRACE("iface %p, device %p, handle %p.\n", iface, device, handle);
4843
4844 wined3d_mutex_lock();
4845
4846 if (!surface->Handle)
4847 {
4848 DWORD h = ddraw_allocate_handle(&device_impl->handle_table, surface, DDRAW_HANDLE_SURFACE);
4849 if (h == DDRAW_INVALID_HANDLE)
4850 {
4851 ERR("Failed to allocate a texture handle.\n");
4852 wined3d_mutex_unlock();
4853 return DDERR_OUTOFMEMORY;
4854 }
4855
4856 surface->Handle = h + 1;
4857 }
4858
4859 TRACE("Returning handle %08x.\n", surface->Handle);
4860 *handle = surface->Handle;
4861
4862 wined3d_mutex_unlock();
4863
4864 return D3D_OK;
4865 }
4866
4867 static HRESULT WINAPI d3d_texture1_GetHandle(IDirect3DTexture *iface,
4868 IDirect3DDevice *device, D3DTEXTUREHANDLE *handle)
4869 {
4870 struct ddraw_surface *surface = impl_from_IDirect3DTexture(iface);
4871 struct d3d_device *device_impl = unsafe_impl_from_IDirect3DDevice(device);
4872
4873 TRACE("iface %p, device %p, handle %p.\n", iface, device, handle);
4874
4875 return d3d_texture2_GetHandle(&surface->IDirect3DTexture2_iface,
4876 device_impl ? &device_impl->IDirect3DDevice2_iface : NULL, handle);
4877 }
4878
4879 /*****************************************************************************
4880 * get_sub_mimaplevel
4881 *
4882 * Helper function that returns the next mipmap level
4883 *
4884 * tex_ptr: Surface of which to return the next level
4885 *
4886 *****************************************************************************/
4887 static struct ddraw_surface *get_sub_mimaplevel(struct ddraw_surface *surface)
4888 {
4889 /* Now go down the mipmap chain to the next surface */
4890 static DDSCAPS2 mipmap_caps = { DDSCAPS_MIPMAP | DDSCAPS_TEXTURE, 0, 0, 0 };
4891 IDirectDrawSurface7 *next_level;
4892 HRESULT hr;
4893
4894 hr = ddraw_surface7_GetAttachedSurface(&surface->IDirectDrawSurface7_iface, &mipmap_caps, &next_level);
4895 if (FAILED(hr)) return NULL;
4896
4897 ddraw_surface7_Release(next_level);
4898
4899 return impl_from_IDirectDrawSurface7(next_level);
4900 }
4901
4902 /*****************************************************************************
4903 * IDirect3DTexture2::Load
4904 *
4905 * Loads a texture created with the DDSCAPS_ALLOCONLOAD
4906 *
4907 * This function isn't relayed to WineD3D because the whole interface is
4908 * implemented in DDraw only. For speed improvements an implementation which
4909 * takes OpenGL more into account could be placed into WineD3D.
4910 *
4911 * Params:
4912 * src_texture: Address of the texture to load
4913 *
4914 * Returns:
4915 * D3D_OK on success
4916 * D3DERR_TEXTURE_LOAD_FAILED.
4917 *
4918 *****************************************************************************/
4919 static HRESULT WINAPI d3d_texture2_Load(IDirect3DTexture2 *iface, IDirect3DTexture2 *src_texture)
4920 {
4921 struct ddraw_surface *dst_surface = impl_from_IDirect3DTexture2(iface);
4922 struct ddraw_surface *src_surface = unsafe_impl_from_IDirect3DTexture2(src_texture);
4923 HRESULT hr;
4924
4925 TRACE("iface %p, src_texture %p.\n", iface, src_texture);
4926
4927 if (src_surface == dst_surface)
4928 {
4929 TRACE("copying surface %p to surface %p, why?\n", src_surface, dst_surface);
4930 return D3D_OK;
4931 }
4932
4933 wined3d_mutex_lock();
4934
4935 if (((src_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP)
4936 != (dst_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP))
4937 || (src_surface->surface_desc.u2.dwMipMapCount != dst_surface->surface_desc.u2.dwMipMapCount))
4938 {
4939 ERR("Trying to load surfaces with different mip-map counts.\n");
4940 }
4941
4942 for (;;)
4943 {
4944 struct wined3d_palette *wined3d_dst_pal, *wined3d_src_pal;
4945 DDSURFACEDESC *src_desc, *dst_desc;
4946
4947 TRACE("Copying surface %p to surface %p (mipmap level %d).\n",
4948 src_surface, dst_surface, src_surface->mipmap_level);
4949
4950 /* Suppress the ALLOCONLOAD flag */
4951 dst_surface->surface_desc.ddsCaps.dwCaps &= ~DDSCAPS_ALLOCONLOAD;
4952
4953 /* Get the palettes */
4954 wined3d_dst_pal = wined3d_surface_get_palette(dst_surface->wined3d_surface);
4955 wined3d_src_pal = wined3d_surface_get_palette(src_surface->wined3d_surface);
4956
4957 if (wined3d_src_pal)
4958 {
4959 PALETTEENTRY palent[256];
4960
4961 if (!wined3d_dst_pal)
4962 {
4963 wined3d_mutex_unlock();
4964 return DDERR_NOPALETTEATTACHED;
4965 }
4966 wined3d_palette_get_entries(wined3d_src_pal, 0, 0, 256, palent);
4967 wined3d_palette_set_entries(wined3d_dst_pal, 0, 0, 256, palent);
4968 }
4969
4970 /* Copy one surface on the other */
4971 dst_desc = (DDSURFACEDESC *)&(dst_surface->surface_desc);
4972 src_desc = (DDSURFACEDESC *)&(src_surface->surface_desc);
4973
4974 if ((src_desc->dwWidth != dst_desc->dwWidth) || (src_desc->dwHeight != dst_desc->dwHeight))
4975 {
4976 /* Should also check for same pixel format, u1.lPitch, ... */
4977 ERR("Error in surface sizes.\n");
4978 wined3d_mutex_unlock();
4979 return D3DERR_TEXTURE_LOAD_FAILED;
4980 }
4981 else
4982 {
4983 struct wined3d_map_desc src_map_desc, dst_map_desc;
4984
4985 /* Copy the src blit color key if the source has one, don't erase
4986 * the destination's ckey if the source has none */
4987 if (src_desc->dwFlags & DDSD_CKSRCBLT)
4988 {
4989 IDirectDrawSurface7_SetColorKey(&dst_surface->IDirectDrawSurface7_iface,
4990 DDCKEY_SRCBLT, &src_desc->ddckCKSrcBlt);
4991 }
4992
4993 /* Copy the main memory texture into the surface that corresponds
4994 * to the OpenGL texture object. */
4995
4996 hr = wined3d_surface_map(src_surface->wined3d_surface, &src_map_desc, NULL, 0);
4997 if (FAILED(hr))
4998 {
4999 ERR("Failed to lock source surface, hr %#x.\n", hr);
5000 wined3d_mutex_unlock();
5001 return D3DERR_TEXTURE_LOAD_FAILED;
5002 }
5003
5004 hr = wined3d_surface_map(dst_surface->wined3d_surface, &dst_map_desc, NULL, 0);
5005 if (FAILED(hr))
5006 {
5007 ERR("Failed to lock destination surface, hr %#x.\n", hr);
5008 wined3d_surface_unmap(src_surface->wined3d_surface);
5009 wined3d_mutex_unlock();
5010 return D3DERR_TEXTURE_LOAD_FAILED;
5011 }
5012
5013 if (dst_surface->surface_desc.u4.ddpfPixelFormat.dwFlags & DDPF_FOURCC)
5014 memcpy(dst_map_desc.data, src_map_desc.data, src_surface->surface_desc.u1.dwLinearSize);
5015 else
5016 memcpy(dst_map_desc.data, src_map_desc.data, src_map_desc.row_pitch * src_desc->dwHeight);
5017
5018 wined3d_surface_unmap(src_surface->wined3d_surface);
5019 wined3d_surface_unmap(dst_surface->wined3d_surface);
5020 }
5021
5022 if (src_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP)
5023 src_surface = get_sub_mimaplevel(src_surface);
5024 else
5025 src_surface = NULL;
5026
5027 if (dst_surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP)
5028 dst_surface = get_sub_mimaplevel(dst_surface);
5029 else
5030 dst_surface = NULL;
5031
5032 if (!src_surface || !dst_surface)
5033 {
5034 if (src_surface != dst_surface)
5035 ERR("Loading surface with different mipmap structure.\n");
5036 break;
5037 }
5038 }
5039
5040 wined3d_mutex_unlock();
5041
5042 return hr;
5043 }
5044
5045 static HRESULT WINAPI d3d_texture1_Load(IDirect3DTexture *iface, IDirect3DTexture *src_texture)
5046 {
5047 struct ddraw_surface *dst_surface = impl_from_IDirect3DTexture(iface);
5048 struct ddraw_surface *src_surface = unsafe_impl_from_IDirect3DTexture(src_texture);
5049
5050 TRACE("iface %p, src_texture %p.\n", iface, src_texture);
5051
5052 return d3d_texture2_Load(&dst_surface->IDirect3DTexture2_iface,
5053 src_surface ? &src_surface->IDirect3DTexture2_iface : NULL);
5054 }
5055
5056 /*****************************************************************************
5057 * The VTable
5058 *****************************************************************************/
5059
5060 static const struct IDirectDrawSurface7Vtbl ddraw_surface7_vtbl =
5061 {
5062 /* IUnknown */
5063 ddraw_surface7_QueryInterface,
5064 ddraw_surface7_AddRef,
5065 ddraw_surface7_Release,
5066 /* IDirectDrawSurface */
5067 ddraw_surface7_AddAttachedSurface,
5068 ddraw_surface7_AddOverlayDirtyRect,
5069 ddraw_surface7_Blt,
5070 ddraw_surface7_BltBatch,
5071 ddraw_surface7_BltFast,
5072 ddraw_surface7_DeleteAttachedSurface,
5073 ddraw_surface7_EnumAttachedSurfaces,
5074 ddraw_surface7_EnumOverlayZOrders,
5075 ddraw_surface7_Flip,
5076 ddraw_surface7_GetAttachedSurface,
5077 ddraw_surface7_GetBltStatus,
5078 ddraw_surface7_GetCaps,
5079 ddraw_surface7_GetClipper,
5080 ddraw_surface7_GetColorKey,
5081 ddraw_surface7_GetDC,
5082 ddraw_surface7_GetFlipStatus,
5083 ddraw_surface7_GetOverlayPosition,
5084 ddraw_surface7_GetPalette,
5085 ddraw_surface7_GetPixelFormat,
5086 ddraw_surface7_GetSurfaceDesc,
5087 ddraw_surface7_Initialize,
5088 ddraw_surface7_IsLost,
5089 ddraw_surface7_Lock,
5090 ddraw_surface7_ReleaseDC,
5091 ddraw_surface7_Restore,
5092 ddraw_surface7_SetClipper,
5093 ddraw_surface7_SetColorKey,
5094 ddraw_surface7_SetOverlayPosition,
5095 ddraw_surface7_SetPalette,
5096 ddraw_surface7_Unlock,
5097 ddraw_surface7_UpdateOverlay,
5098 ddraw_surface7_UpdateOverlayDisplay,
5099 ddraw_surface7_UpdateOverlayZOrder,
5100 /* IDirectDrawSurface2 */
5101 ddraw_surface7_GetDDInterface,
5102 ddraw_surface7_PageLock,
5103 ddraw_surface7_PageUnlock,
5104 /* IDirectDrawSurface3 */
5105 ddraw_surface7_SetSurfaceDesc,
5106 /* IDirectDrawSurface4 */
5107 ddraw_surface7_SetPrivateData,
5108 ddraw_surface7_GetPrivateData,
5109 ddraw_surface7_FreePrivateData,
5110 ddraw_surface7_GetUniquenessValue,
5111 ddraw_surface7_ChangeUniquenessValue,
5112 /* IDirectDrawSurface7 */
5113 ddraw_surface7_SetPriority,
5114 ddraw_surface7_GetPriority,
5115 ddraw_surface7_SetLOD,
5116 ddraw_surface7_GetLOD,
5117 };
5118
5119 static const struct IDirectDrawSurface4Vtbl ddraw_surface4_vtbl =
5120 {
5121 /* IUnknown */
5122 ddraw_surface4_QueryInterface,
5123 ddraw_surface4_AddRef,
5124 ddraw_surface4_Release,
5125 /* IDirectDrawSurface */
5126 ddraw_surface4_AddAttachedSurface,
5127 ddraw_surface4_AddOverlayDirtyRect,
5128 ddraw_surface4_Blt,
5129 ddraw_surface4_BltBatch,
5130 ddraw_surface4_BltFast,
5131 ddraw_surface4_DeleteAttachedSurface,
5132 ddraw_surface4_EnumAttachedSurfaces,
5133 ddraw_surface4_EnumOverlayZOrders,
5134 ddraw_surface4_Flip,
5135 ddraw_surface4_GetAttachedSurface,
5136 ddraw_surface4_GetBltStatus,
5137 ddraw_surface4_GetCaps,
5138 ddraw_surface4_GetClipper,
5139 ddraw_surface4_GetColorKey,
5140 ddraw_surface4_GetDC,
5141 ddraw_surface4_GetFlipStatus,
5142 ddraw_surface4_GetOverlayPosition,
5143 ddraw_surface4_GetPalette,
5144 ddraw_surface4_GetPixelFormat,
5145 ddraw_surface4_GetSurfaceDesc,
5146 ddraw_surface4_Initialize,
5147 ddraw_surface4_IsLost,
5148 ddraw_surface4_Lock,
5149 ddraw_surface4_ReleaseDC,
5150 ddraw_surface4_Restore,
5151 ddraw_surface4_SetClipper,
5152 ddraw_surface4_SetColorKey,
5153 ddraw_surface4_SetOverlayPosition,
5154 ddraw_surface4_SetPalette,
5155 ddraw_surface4_Unlock,
5156 ddraw_surface4_UpdateOverlay,
5157 ddraw_surface4_UpdateOverlayDisplay,
5158 ddraw_surface4_UpdateOverlayZOrder,
5159 /* IDirectDrawSurface2 */
5160 ddraw_surface4_GetDDInterface,
5161 ddraw_surface4_PageLock,
5162 ddraw_surface4_PageUnlock,
5163 /* IDirectDrawSurface3 */
5164 ddraw_surface4_SetSurfaceDesc,
5165 /* IDirectDrawSurface4 */
5166 ddraw_surface4_SetPrivateData,
5167 ddraw_surface4_GetPrivateData,
5168 ddraw_surface4_FreePrivateData,
5169 ddraw_surface4_GetUniquenessValue,
5170 ddraw_surface4_ChangeUniquenessValue,
5171 };
5172
5173 static const struct IDirectDrawSurface3Vtbl ddraw_surface3_vtbl =
5174 {
5175 /* IUnknown */
5176 ddraw_surface3_QueryInterface,
5177 ddraw_surface3_AddRef,
5178 ddraw_surface3_Release,
5179 /* IDirectDrawSurface */
5180 ddraw_surface3_AddAttachedSurface,
5181 ddraw_surface3_AddOverlayDirtyRect,
5182 ddraw_surface3_Blt,
5183 ddraw_surface3_BltBatch,
5184 ddraw_surface3_BltFast,
5185 ddraw_surface3_DeleteAttachedSurface,
5186 ddraw_surface3_EnumAttachedSurfaces,
5187 ddraw_surface3_EnumOverlayZOrders,
5188 ddraw_surface3_Flip,
5189 ddraw_surface3_GetAttachedSurface,
5190 ddraw_surface3_GetBltStatus,
5191 ddraw_surface3_GetCaps,
5192 ddraw_surface3_GetClipper,
5193 ddraw_surface3_GetColorKey,
5194 ddraw_surface3_GetDC,
5195 ddraw_surface3_GetFlipStatus,
5196 ddraw_surface3_GetOverlayPosition,
5197 ddraw_surface3_GetPalette,
5198 ddraw_surface3_GetPixelFormat,
5199 ddraw_surface3_GetSurfaceDesc,
5200 ddraw_surface3_Initialize,
5201 ddraw_surface3_IsLost,
5202 ddraw_surface3_Lock,
5203 ddraw_surface3_ReleaseDC,
5204 ddraw_surface3_Restore,
5205 ddraw_surface3_SetClipper,
5206 ddraw_surface3_SetColorKey,
5207 ddraw_surface3_SetOverlayPosition,
5208 ddraw_surface3_SetPalette,
5209 ddraw_surface3_Unlock,
5210 ddraw_surface3_UpdateOverlay,
5211 ddraw_surface3_UpdateOverlayDisplay,
5212 ddraw_surface3_UpdateOverlayZOrder,
5213 /* IDirectDrawSurface2 */
5214 ddraw_surface3_GetDDInterface,
5215 ddraw_surface3_PageLock,
5216 ddraw_surface3_PageUnlock,
5217 /* IDirectDrawSurface3 */
5218 ddraw_surface3_SetSurfaceDesc,
5219 };
5220
5221 static const struct IDirectDrawSurface2Vtbl ddraw_surface2_vtbl =
5222 {
5223 /* IUnknown */
5224 ddraw_surface2_QueryInterface,
5225 ddraw_surface2_AddRef,
5226 ddraw_surface2_Release,
5227 /* IDirectDrawSurface */
5228 ddraw_surface2_AddAttachedSurface,
5229 ddraw_surface2_AddOverlayDirtyRect,
5230 ddraw_surface2_Blt,
5231 ddraw_surface2_BltBatch,
5232 ddraw_surface2_BltFast,
5233 ddraw_surface2_DeleteAttachedSurface,
5234 ddraw_surface2_EnumAttachedSurfaces,
5235 ddraw_surface2_EnumOverlayZOrders,
5236 ddraw_surface2_Flip,
5237 ddraw_surface2_GetAttachedSurface,
5238 ddraw_surface2_GetBltStatus,
5239 ddraw_surface2_GetCaps,
5240 ddraw_surface2_GetClipper,
5241 ddraw_surface2_GetColorKey,
5242 ddraw_surface2_GetDC,
5243 ddraw_surface2_GetFlipStatus,
5244 ddraw_surface2_GetOverlayPosition,
5245 ddraw_surface2_GetPalette,
5246 ddraw_surface2_GetPixelFormat,
5247 ddraw_surface2_GetSurfaceDesc,
5248 ddraw_surface2_Initialize,
5249 ddraw_surface2_IsLost,
5250 ddraw_surface2_Lock,
5251 ddraw_surface2_ReleaseDC,
5252 ddraw_surface2_Restore,
5253 ddraw_surface2_SetClipper,
5254 ddraw_surface2_SetColorKey,
5255 ddraw_surface2_SetOverlayPosition,
5256 ddraw_surface2_SetPalette,
5257 ddraw_surface2_Unlock,
5258 ddraw_surface2_UpdateOverlay,
5259 ddraw_surface2_UpdateOverlayDisplay,
5260 ddraw_surface2_UpdateOverlayZOrder,
5261 /* IDirectDrawSurface2 */
5262 ddraw_surface2_GetDDInterface,
5263 ddraw_surface2_PageLock,
5264 ddraw_surface2_PageUnlock,
5265 };
5266
5267 static const struct IDirectDrawSurfaceVtbl ddraw_surface1_vtbl =
5268 {
5269 /* IUnknown */
5270 ddraw_surface1_QueryInterface,
5271 ddraw_surface1_AddRef,
5272 ddraw_surface1_Release,
5273 /* IDirectDrawSurface */
5274 ddraw_surface1_AddAttachedSurface,
5275 ddraw_surface1_AddOverlayDirtyRect,
5276 ddraw_surface1_Blt,
5277 ddraw_surface1_BltBatch,
5278 ddraw_surface1_BltFast,
5279 ddraw_surface1_DeleteAttachedSurface,
5280 ddraw_surface1_EnumAttachedSurfaces,
5281 ddraw_surface1_EnumOverlayZOrders,
5282 ddraw_surface1_Flip,
5283 ddraw_surface1_GetAttachedSurface,
5284 ddraw_surface1_GetBltStatus,
5285 ddraw_surface1_GetCaps,
5286 ddraw_surface1_GetClipper,
5287 ddraw_surface1_GetColorKey,
5288 ddraw_surface1_GetDC,
5289 ddraw_surface1_GetFlipStatus,
5290 ddraw_surface1_GetOverlayPosition,
5291 ddraw_surface1_GetPalette,
5292 ddraw_surface1_GetPixelFormat,
5293 ddraw_surface1_GetSurfaceDesc,
5294 ddraw_surface1_Initialize,
5295 ddraw_surface1_IsLost,
5296 ddraw_surface1_Lock,
5297 ddraw_surface1_ReleaseDC,
5298 ddraw_surface1_Restore,
5299 ddraw_surface1_SetClipper,
5300 ddraw_surface1_SetColorKey,
5301 ddraw_surface1_SetOverlayPosition,
5302 ddraw_surface1_SetPalette,
5303 ddraw_surface1_Unlock,
5304 ddraw_surface1_UpdateOverlay,
5305 ddraw_surface1_UpdateOverlayDisplay,
5306 ddraw_surface1_UpdateOverlayZOrder,
5307 };
5308
5309 static const struct IDirectDrawGammaControlVtbl ddraw_gamma_control_vtbl =
5310 {
5311 ddraw_gamma_control_QueryInterface,
5312 ddraw_gamma_control_AddRef,
5313 ddraw_gamma_control_Release,
5314 ddraw_gamma_control_GetGammaRamp,
5315 ddraw_gamma_control_SetGammaRamp,
5316 };
5317
5318 static const struct IDirect3DTexture2Vtbl d3d_texture2_vtbl =
5319 {
5320 d3d_texture2_QueryInterface,
5321 d3d_texture2_AddRef,
5322 d3d_texture2_Release,
5323 d3d_texture2_GetHandle,
5324 d3d_texture2_PaletteChanged,
5325 d3d_texture2_Load,
5326 };
5327
5328 static const struct IDirect3DTextureVtbl d3d_texture1_vtbl =
5329 {
5330 d3d_texture1_QueryInterface,
5331 d3d_texture1_AddRef,
5332 d3d_texture1_Release,
5333 d3d_texture1_Initialize,
5334 d3d_texture1_GetHandle,
5335 d3d_texture1_PaletteChanged,
5336 d3d_texture1_Load,
5337 d3d_texture1_Unload,
5338 };
5339
5340 /* Some games (e.g. Tomb Raider 3) pass the wrong version of the
5341 * IDirectDrawSurface interface to ddraw methods. */
5342 struct ddraw_surface *unsafe_impl_from_IDirectDrawSurface7(IDirectDrawSurface7 *iface)
5343 {
5344 if (!iface) return NULL;
5345 if (iface->lpVtbl != &ddraw_surface7_vtbl)
5346 {
5347 HRESULT hr = IDirectDrawSurface7_QueryInterface(iface, &IID_IDirectDrawSurface7, (void **)&iface);
5348 if (FAILED(hr))
5349 {
5350 WARN("Object %p doesn't expose interface IDirectDrawSurface7.\n", iface);
5351 return NULL;
5352 }
5353 IDirectDrawSurface7_Release(iface);
5354 }
5355 return CONTAINING_RECORD(iface, struct ddraw_surface, IDirectDrawSurface7_iface);
5356 }
5357
5358 struct ddraw_surface *unsafe_impl_from_IDirectDrawSurface4(IDirectDrawSurface4 *iface)
5359 {
5360 if (!iface) return NULL;
5361 if (iface->lpVtbl != &ddraw_surface4_vtbl)
5362 {
5363 HRESULT hr = IDirectDrawSurface4_QueryInterface(iface, &IID_IDirectDrawSurface4, (void **)&iface);
5364 if (FAILED(hr))
5365 {
5366 WARN("Object %p doesn't expose interface IDirectDrawSurface4.\n", iface);
5367 return NULL;
5368 }
5369 IDirectDrawSurface4_Release(iface);
5370 }
5371 return CONTAINING_RECORD(iface, struct ddraw_surface, IDirectDrawSurface4_iface);
5372 }
5373
5374 static struct ddraw_surface *unsafe_impl_from_IDirectDrawSurface3(IDirectDrawSurface3 *iface)
5375 {
5376 if (!iface) return NULL;
5377 if (iface->lpVtbl != &ddraw_surface3_vtbl)
5378 {
5379 HRESULT hr = IDirectDrawSurface3_QueryInterface(iface, &IID_IDirectDrawSurface3, (void **)&iface);
5380 if (FAILED(hr))
5381 {
5382 WARN("Object %p doesn't expose interface IDirectDrawSurface3.\n", iface);
5383 return NULL;
5384 }
5385 IDirectDrawSurface3_Release(iface);
5386 }
5387 return CONTAINING_RECORD(iface, struct ddraw_surface, IDirectDrawSurface3_iface);
5388 }
5389
5390 static struct ddraw_surface *unsafe_impl_from_IDirectDrawSurface2(IDirectDrawSurface2 *iface)
5391 {
5392 if (!iface) return NULL;
5393 if (iface->lpVtbl != &ddraw_surface2_vtbl)
5394 {
5395 HRESULT hr = IDirectDrawSurface2_QueryInterface(iface, &IID_IDirectDrawSurface2, (void **)&iface);
5396 if (FAILED(hr))
5397 {
5398 WARN("Object %p doesn't expose interface IDirectDrawSurface2.\n", iface);
5399 return NULL;
5400 }
5401 IDirectDrawSurface2_Release(iface);
5402 }
5403 return CONTAINING_RECORD(iface, struct ddraw_surface, IDirectDrawSurface2_iface);
5404 }
5405
5406 struct ddraw_surface *unsafe_impl_from_IDirectDrawSurface(IDirectDrawSurface *iface)
5407 {
5408 if (!iface) return NULL;
5409 if (iface->lpVtbl != &ddraw_surface1_vtbl)
5410 {
5411 HRESULT hr = IDirectDrawSurface_QueryInterface(iface, &IID_IDirectDrawSurface, (void **)&iface);
5412 if (FAILED(hr))
5413 {
5414 WARN("Object %p doesn't expose interface IDirectDrawSurface.\n", iface);
5415 return NULL;
5416 }
5417 IDirectDrawSurface_Release(iface);
5418 }
5419 return CONTAINING_RECORD(iface, struct ddraw_surface, IDirectDrawSurface_iface);
5420 }
5421
5422 struct ddraw_surface *unsafe_impl_from_IDirect3DTexture2(IDirect3DTexture2 *iface)
5423 {
5424 if (!iface) return NULL;
5425 assert(iface->lpVtbl == &d3d_texture2_vtbl);
5426 return CONTAINING_RECORD(iface, struct ddraw_surface, IDirect3DTexture2_iface);
5427 }
5428
5429 struct ddraw_surface *unsafe_impl_from_IDirect3DTexture(IDirect3DTexture *iface)
5430 {
5431 if (!iface) return NULL;
5432 assert(iface->lpVtbl == &d3d_texture1_vtbl);
5433 return CONTAINING_RECORD(iface, struct ddraw_surface, IDirect3DTexture_iface);
5434 }
5435
5436 static void STDMETHODCALLTYPE ddraw_surface_wined3d_object_destroyed(void *parent)
5437 {
5438 struct ddraw_surface *surface = parent;
5439
5440 TRACE("surface %p.\n", surface);
5441
5442 /* Check for attached surfaces and detach them. */
5443 if (surface->first_attached != surface)
5444 {
5445 /* Well, this shouldn't happen: The surface being attached is
5446 * referenced in AddAttachedSurface(), so it shouldn't be released
5447 * until DeleteAttachedSurface() is called, because the refcount is
5448 * held. It looks like the application released it often enough to
5449 * force this. */
5450 WARN("Surface is still attached to surface %p.\n", surface->first_attached);
5451
5452 /* The refcount will drop to -1 here */
5453 if (FAILED(ddraw_surface_delete_attached_surface(surface->first_attached, surface, surface->attached_iface)))
5454 ERR("DeleteAttachedSurface failed.\n");
5455 }
5456
5457 while (surface->next_attached)
5458 if (FAILED(ddraw_surface_delete_attached_surface(surface,
5459 surface->next_attached, surface->next_attached->attached_iface)))
5460 ERR("DeleteAttachedSurface failed.\n");
5461
5462 /* Having a texture handle set implies that the device still exists. */
5463 if (surface->Handle)
5464 ddraw_free_handle(&surface->ddraw->d3ddevice->handle_table, surface->Handle - 1, DDRAW_HANDLE_SURFACE);
5465
5466 /* Reduce the ddraw surface count. */
5467 list_remove(&surface->surface_list_entry);
5468
5469 if (surface == surface->ddraw->primary)
5470 surface->ddraw->primary = NULL;
5471
5472 HeapFree(GetProcessHeap(), 0, surface);
5473 }
5474
5475 static const struct wined3d_parent_ops ddraw_surface_wined3d_parent_ops =
5476 {
5477 ddraw_surface_wined3d_object_destroyed,
5478 };
5479
5480 static void STDMETHODCALLTYPE ddraw_texture_wined3d_object_destroyed(void *parent)
5481 {
5482 TRACE("parent %p.\n", parent);
5483
5484 HeapFree(GetProcessHeap(), 0, parent);
5485 }
5486
5487 static const struct wined3d_parent_ops ddraw_texture_wined3d_parent_ops =
5488 {
5489 ddraw_texture_wined3d_object_destroyed,
5490 };
5491
5492 static HRESULT CDECL ddraw_reset_enum_callback(struct wined3d_resource *resource)
5493 {
5494 return DD_OK;
5495 }
5496
5497 HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_desc,
5498 struct ddraw_surface **surface, IUnknown *outer_unknown, unsigned int version)
5499 {
5500 struct ddraw_surface *root, *mip, **attach;
5501 struct wined3d_resource_desc wined3d_desc;
5502 struct wined3d_texture *wined3d_texture;
5503 struct wined3d_resource *resource;
5504 struct wined3d_display_mode mode;
5505 DDSURFACEDESC2 *desc, *mip_desc;
5506 struct ddraw_texture *texture;
5507 UINT layers, levels, i, j;
5508 HRESULT hr;
5509
5510 TRACE("ddraw %p, surface_desc %p, surface %p, outer_unknown %p, version %u.\n",
5511 ddraw, surface_desc, surface, outer_unknown, version);
5512 if (TRACE_ON(ddraw))
5513 {
5514 TRACE("Requesting surface desc:\n");
5515 DDRAW_dump_surface_desc(surface_desc);
5516 }
5517
5518 if (outer_unknown)
5519 return CLASS_E_NOAGGREGATION;
5520
5521 if (!surface)
5522 return E_POINTER;
5523
5524 if (!(texture = HeapAlloc(GetProcessHeap(), 0, sizeof(*texture))))
5525 return E_OUTOFMEMORY;
5526
5527 texture->version = version;
5528 texture->surface_desc = *surface_desc;
5529 desc = &texture->surface_desc;
5530
5531 /* Ensure DDSD_CAPS is always set. */
5532 desc->dwFlags |= DDSD_CAPS;
5533
5534 if (desc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
5535 {
5536 DWORD flippable = desc->ddsCaps.dwCaps & (DDSCAPS_FLIP | DDSCAPS_COMPLEX);
5537
5538 if (desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE)
5539 {
5540 WARN("Tried to create a primary surface with DDSCAPS_TEXTURE.\n");
5541 HeapFree(GetProcessHeap(), 0, texture);
5542 return DDERR_INVALIDCAPS;
5543 }
5544
5545 if (flippable)
5546 {
5547 if (flippable != (DDSCAPS_FLIP | DDSCAPS_COMPLEX))
5548 {
5549 WARN("Tried to create a flippable primary surface without both DDSCAPS_FLIP and DDSCAPS_COMPLEX.\n");
5550 HeapFree(GetProcessHeap(), 0, texture);
5551 return DDERR_INVALIDCAPS;
5552 }
5553
5554 if (!(desc->dwFlags & DDSD_BACKBUFFERCOUNT) || !desc->dwBackBufferCount)
5555 {
5556 WARN("Tried to create a flippable primary surface without any back buffers.\n");
5557 HeapFree(GetProcessHeap(), 0, texture);
5558 return DDERR_INVALIDCAPS;
5559 }
5560
5561 if (!(ddraw->cooperative_level & DDSCL_EXCLUSIVE))
5562 {
5563 WARN("Tried to create a flippable primary surface without DDSCL_EXCLUSIVE.\n");
5564 HeapFree(GetProcessHeap(), 0, texture);
5565 return DDERR_NOEXCLUSIVEMODE;
5566 }
5567 }
5568 }
5569
5570 /* This is a special case in ddrawex, but not allowed in ddraw. */
5571 if ((desc->ddsCaps.dwCaps & (DDSCAPS_VIDEOMEMORY | DDSCAPS_SYSTEMMEMORY))
5572 == (DDSCAPS_VIDEOMEMORY | DDSCAPS_SYSTEMMEMORY))
5573 {
5574 WARN("Tried to create a surface in both system and video memory.\n");
5575 HeapFree(GetProcessHeap(), 0, texture);
5576 return DDERR_INVALIDCAPS;
5577 }
5578
5579 if ((desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES)
5580 && !(desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP))
5581 {
5582 WARN("Cube map faces requested without cube map flag.\n");
5583 HeapFree(GetProcessHeap(), 0, texture);
5584 return DDERR_INVALIDCAPS;
5585 }
5586
5587 if ((desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
5588 && !(desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES))
5589 {
5590 WARN("Cube map without faces requested.\n");
5591 HeapFree(GetProcessHeap(), 0, texture);
5592 return DDERR_INVALIDPARAMS;
5593 }
5594
5595 if ((desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
5596 && (desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES) != DDSCAPS2_CUBEMAP_ALLFACES)
5597 FIXME("Partial cube maps not implemented.\n");
5598
5599 if (desc->ddsCaps.dwCaps2 & (DDSCAPS2_TEXTUREMANAGE | DDSCAPS2_D3DTEXTUREMANAGE))
5600 {
5601 if (!(desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE))
5602 {
5603 WARN("DDSCAPS2_TEXTUREMANAGE used without DDSCAPS_TEXTURE, returning DDERR_INVALIDCAPS.\n");
5604 HeapFree(GetProcessHeap(), 0, texture);
5605 return DDERR_INVALIDCAPS;
5606 }
5607 if (desc->ddsCaps.dwCaps & (DDSCAPS_VIDEOMEMORY | DDSCAPS_SYSTEMMEMORY))
5608 {
5609 WARN("DDSCAPS2_TEXTUREMANAGE used width DDSCAPS_VIDEOMEMORY "
5610 "or DDSCAPS_SYSTEMMEMORY, returning DDERR_INVALIDCAPS.\n");
5611 HeapFree(GetProcessHeap(), 0, texture);
5612 return DDERR_INVALIDCAPS;
5613 }
5614 }
5615
5616 if (FAILED(hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode, NULL)))
5617 {
5618 ERR("Failed to get display mode, hr %#x.\n", hr);
5619 HeapFree(GetProcessHeap(), 0, texture);
5620 return hr_ddraw_from_wined3d(hr);
5621 }
5622
5623 /* No pixelformat given? Use the current screen format. */
5624 if (!(desc->dwFlags & DDSD_PIXELFORMAT))
5625 {
5626 desc->dwFlags |= DDSD_PIXELFORMAT;
5627 desc->u4.ddpfPixelFormat.dwSize = sizeof(desc->u4.ddpfPixelFormat);
5628 ddrawformat_from_wined3dformat(&desc->u4.ddpfPixelFormat, mode.format_id);
5629 }
5630
5631 wined3d_desc.format = wined3dformat_from_ddrawformat(&desc->u4.ddpfPixelFormat);
5632 if (wined3d_desc.format == WINED3DFMT_UNKNOWN)
5633 {
5634 WARN("Unsupported / unknown pixelformat.\n");
5635 HeapFree(GetProcessHeap(), 0, texture);
5636 return DDERR_INVALIDPIXELFORMAT;
5637 }
5638
5639 /* No width or no height? Use the screen size. */
5640 if (!(desc->dwFlags & DDSD_WIDTH) || !(desc->dwFlags & DDSD_HEIGHT))
5641 {
5642 if (!(desc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))
5643 {
5644 WARN("No width / height specified.\n");
5645 HeapFree(GetProcessHeap(), 0, texture);
5646 return DDERR_INVALIDPARAMS;
5647 }
5648
5649 desc->dwFlags |= DDSD_WIDTH | DDSD_HEIGHT;
5650 desc->dwWidth = mode.width;
5651 desc->dwHeight = mode.height;
5652 }
5653
5654 if (!desc->dwWidth || !desc->dwHeight)
5655 {
5656 HeapFree(GetProcessHeap(), 0, texture);
5657 return DDERR_INVALIDPARAMS;
5658 }
5659
5660 if (desc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
5661 {
5662 /* The first surface is a front buffer, the back buffers are created
5663 * afterwards. */
5664 if (desc->ddsCaps.dwCaps & DDSCAPS_FLIP)
5665 desc->ddsCaps.dwCaps |= DDSCAPS_FRONTBUFFER;
5666 desc->ddsCaps.dwCaps |= DDSCAPS_VISIBLE;
5667 if (ddraw->cooperative_level & DDSCL_EXCLUSIVE)
5668 {
5669 struct wined3d_swapchain_desc swapchain_desc;
5670
5671 wined3d_swapchain_get_desc(ddraw->wined3d_swapchain, &swapchain_desc);
5672 swapchain_desc.backbuffer_width = mode.width;
5673 swapchain_desc.backbuffer_height = mode.height;
5674 swapchain_desc.backbuffer_format = mode.format_id;
5675
5676 if (FAILED(hr = wined3d_device_reset(ddraw->wined3d_device,
5677 &swapchain_desc, NULL, ddraw_reset_enum_callback, TRUE)))
5678 {
5679 ERR("Failed to reset device.\n");
5680 HeapFree(GetProcessHeap(), 0, texture);
5681 return hr_ddraw_from_wined3d(hr);
5682 }
5683 }
5684 }
5685
5686 wined3d_desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
5687 wined3d_desc.multisample_quality = 0;
5688 wined3d_desc.usage = 0;
5689 wined3d_desc.pool = WINED3D_POOL_DEFAULT;
5690 wined3d_desc.width = desc->dwWidth;
5691 wined3d_desc.height = desc->dwHeight;
5692 wined3d_desc.depth = 1;
5693 wined3d_desc.size = 0;
5694
5695 if ((desc->ddsCaps.dwCaps & DDSCAPS_3DDEVICE) && (ddraw->flags & DDRAW_NO3D))
5696 {
5697 WARN("The application requests a 3D capable surface, but the ddraw object was created without 3D support.\n");
5698 /* Do not fail surface creation, only fail 3D device creation. */
5699 }
5700
5701 /* Mipmap count fixes */
5702 if (desc->ddsCaps.dwCaps & DDSCAPS_MIPMAP)
5703 {
5704 if (desc->ddsCaps.dwCaps & DDSCAPS_COMPLEX)
5705 {
5706 if (desc->dwFlags & DDSD_MIPMAPCOUNT)
5707 {
5708 /* Mipmap count is given, should not be 0. */
5709 if (!desc->u2.dwMipMapCount)
5710 {
5711 HeapFree(GetProcessHeap(), 0, texture);
5712 return DDERR_INVALIDPARAMS;
5713 }
5714 }
5715 else
5716 {
5717 /* Undocumented feature: Create sublevels until either the
5718 * width or the height is 1. */
5719 DWORD min = desc->dwWidth < desc->dwHeight ? desc->dwWidth : desc->dwHeight;
5720
5721 desc->u2.dwMipMapCount = 0;
5722 while (min)
5723 {
5724 ++desc->u2.dwMipMapCount;
5725 min >>= 1;
5726 }
5727 }
5728 }
5729 else
5730 {
5731 desc->u2.dwMipMapCount = 1;
5732 }
5733
5734 desc->dwFlags |= DDSD_MIPMAPCOUNT;
5735 levels = desc->u2.dwMipMapCount;
5736 }
5737 else
5738 {
5739 levels = 1;
5740 }
5741
5742 if (!(desc->ddsCaps.dwCaps & (DDSCAPS_VIDEOMEMORY | DDSCAPS_SYSTEMMEMORY)))
5743 {
5744 if (!(desc->ddsCaps.dwCaps2 & (DDSCAPS2_TEXTUREMANAGE | DDSCAPS2_D3DTEXTUREMANAGE)))
5745 {
5746 enum wined3d_resource_type rtype;
5747 DWORD usage = 0;
5748
5749 if (desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
5750 rtype = WINED3D_RTYPE_CUBE_TEXTURE;
5751 else if (desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE)
5752 rtype = WINED3D_RTYPE_TEXTURE;
5753 else
5754 rtype = WINED3D_RTYPE_SURFACE;
5755
5756 if (desc->ddsCaps.dwCaps & DDSCAPS_ZBUFFER)
5757 usage = WINED3DUSAGE_DEPTHSTENCIL;
5758 else if (desc->ddsCaps.dwCaps & DDSCAPS_3DDEVICE)
5759 usage = WINED3DUSAGE_RENDERTARGET;
5760
5761 if (SUCCEEDED(hr = wined3d_check_device_format(ddraw->wined3d, WINED3DADAPTER_DEFAULT,
5762 WINED3D_DEVICE_TYPE_HAL, mode.format_id, usage, rtype, wined3d_desc.format)))
5763 desc->ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
5764 else
5765 desc->ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
5766 }
5767 else if (!(desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE))
5768 {
5769 /* Tests show surfaces without memory flags get these flags added
5770 * right after creation. */
5771 desc->ddsCaps.dwCaps |= DDSCAPS_LOCALVIDMEM | DDSCAPS_VIDEOMEMORY;
5772 }
5773 }
5774
5775 if ((desc->ddsCaps.dwCaps & (DDSCAPS_OVERLAY | DDSCAPS_SYSTEMMEMORY))
5776 == (DDSCAPS_OVERLAY | DDSCAPS_SYSTEMMEMORY))
5777 {
5778 WARN("System memory overlays are not allowed.\n");
5779 HeapFree(GetProcessHeap(), 0, texture);
5780 return DDERR_NOOVERLAYHW;
5781 }
5782
5783 if (desc->ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY)
5784 {
5785 wined3d_desc.pool = WINED3D_POOL_SYSTEM_MEM;
5786 }
5787 else
5788 {
5789 if (desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE)
5790 wined3d_desc.usage |= WINED3DUSAGE_TEXTURE;
5791 if (desc->ddsCaps.dwCaps & DDSCAPS_ZBUFFER)
5792 wined3d_desc.usage |= WINED3DUSAGE_DEPTHSTENCIL;
5793 else if (desc->ddsCaps.dwCaps & DDSCAPS_3DDEVICE)
5794 wined3d_desc.usage |= WINED3DUSAGE_RENDERTARGET;
5795
5796 if (desc->ddsCaps.dwCaps2 & (DDSCAPS2_TEXTUREMANAGE | DDSCAPS2_D3DTEXTUREMANAGE))
5797 {
5798 wined3d_desc.pool = WINED3D_POOL_MANAGED;
5799 /* Managed textures have the system memory flag set. */
5800 desc->ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
5801 }
5802 else if (desc->ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY)
5803 {
5804 /* Videomemory adds localvidmem. This is mutually exclusive with
5805 * systemmemory and texturemanage. */
5806 desc->ddsCaps.dwCaps |= DDSCAPS_LOCALVIDMEM;
5807 wined3d_desc.usage |= WINED3DUSAGE_DYNAMIC;
5808 }
5809 }
5810
5811 /* If the surface is of the 'ALLOCONLOAD' type, ignore the LPSURFACE
5812 * field. Frank Herbert's Dune specifies a NULL pointer for lpSurface. */
5813 if ((desc->ddsCaps.dwCaps & DDSCAPS_ALLOCONLOAD) || !desc->lpSurface)
5814 desc->dwFlags &= ~DDSD_LPSURFACE;
5815 if (desc->dwFlags & DDSD_LPSURFACE)
5816 {
5817 if (wined3d_desc.pool != WINED3D_POOL_SYSTEM_MEM)
5818 {
5819 WARN("User memory surfaces should be in the system memory pool.\n");
5820 HeapFree(GetProcessHeap(), 0, texture);
5821 return DDERR_INVALIDCAPS;
5822 }
5823
5824 if (!(desc->dwFlags & DDSD_PITCH))
5825 {
5826 WARN("User memory surfaces should explicitly specify the pitch.\n");
5827 HeapFree(GetProcessHeap(), 0, texture);
5828 return DDERR_INVALIDPARAMS;
5829 }
5830 }
5831
5832 if (desc->ddsCaps.dwCaps & (DDSCAPS_OVERLAY))
5833 wined3d_desc.usage |= WINED3DUSAGE_OVERLAY;
5834
5835 if (desc->ddsCaps.dwCaps & DDSCAPS_OWNDC)
5836 wined3d_desc.usage |= WINED3DUSAGE_OWNDC;
5837
5838 if (desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
5839 {
5840 wined3d_desc.resource_type = WINED3D_RTYPE_CUBE_TEXTURE;
5841 layers = 6;
5842 }
5843 else
5844 {
5845 wined3d_desc.resource_type = WINED3D_RTYPE_TEXTURE;
5846 layers = 1;
5847 }
5848
5849 /* Some applications assume surfaces will always be mapped at the same
5850 * address. Some of those also assume that this address is valid even when
5851 * the surface isn't mapped, and that updates done this way will be
5852 * visible on the screen. The game Nox is such an application,
5853 * Commandos: Behind Enemy Lines is another. We set
5854 * WINED3D_SURFACE_PIN_SYSMEM because of this. */
5855 if (FAILED(hr = wined3d_texture_create(ddraw->wined3d_device, &wined3d_desc, levels,
5856 WINED3D_SURFACE_PIN_SYSMEM, texture, &ddraw_texture_wined3d_parent_ops, &wined3d_texture)))
5857 {
5858 WARN("Failed to create wined3d texture, hr %#x.\n", hr);
5859 HeapFree(GetProcessHeap(), 0, texture);
5860 return hr_ddraw_from_wined3d(hr);
5861 }
5862
5863 resource = wined3d_texture_get_sub_resource(wined3d_texture, 0);
5864 root = wined3d_resource_get_parent(resource);
5865 root->wined3d_texture = wined3d_texture;
5866 root->is_complex_root = TRUE;
5867 texture->root = root;
5868
5869 if (desc->dwFlags & DDSD_CKDESTOVERLAY)
5870 wined3d_texture_set_color_key(wined3d_texture, DDCKEY_DESTOVERLAY,
5871 (struct wined3d_color_key *)&desc->u3.ddckCKDestOverlay);
5872 if (desc->dwFlags & DDSD_CKDESTBLT)
5873 wined3d_texture_set_color_key(wined3d_texture, DDCKEY_DESTBLT,
5874 (struct wined3d_color_key *)&desc->ddckCKDestBlt);
5875 if (desc->dwFlags & DDSD_CKSRCOVERLAY)
5876 wined3d_texture_set_color_key(wined3d_texture, DDCKEY_SRCOVERLAY,
5877 (struct wined3d_color_key *)&desc->ddckCKSrcOverlay);
5878 if (desc->dwFlags & DDSD_CKSRCBLT)
5879 wined3d_texture_set_color_key(wined3d_texture, DDCKEY_SRCBLT,
5880 (struct wined3d_color_key *)&desc->ddckCKSrcBlt);
5881
5882 for (i = 0; i < layers; ++i)
5883 {
5884 attach = &root->complex_array[layers - 1 - i];
5885
5886 for (j = 0; j < levels; ++j)
5887 {
5888 resource = wined3d_texture_get_sub_resource(wined3d_texture, i * levels + j);
5889 mip = wined3d_resource_get_parent(resource);
5890 mip_desc = &mip->surface_desc;
5891
5892 if (j)
5893 mip_desc->ddsCaps.dwCaps2 |= DDSCAPS2_MIPMAPSUBLEVEL;
5894 else
5895 mip_desc->ddsCaps.dwCaps2 &= ~DDSCAPS2_MIPMAPSUBLEVEL;
5896
5897 if (mip_desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
5898 {
5899 mip_desc->ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_ALLFACES;
5900
5901 switch (i)
5902 {
5903 case WINED3D_CUBEMAP_FACE_POSITIVE_X:
5904 mip_desc->ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEX;
5905 break;
5906 case WINED3D_CUBEMAP_FACE_NEGATIVE_X:
5907 mip_desc->ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEX;
5908 break;
5909 case WINED3D_CUBEMAP_FACE_POSITIVE_Y:
5910 mip_desc->ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEY;
5911 break;
5912 case WINED3D_CUBEMAP_FACE_NEGATIVE_Y:
5913 mip_desc->ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEY;
5914 break;
5915 case WINED3D_CUBEMAP_FACE_POSITIVE_Z:
5916 mip_desc->ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEZ;
5917 break;
5918 case WINED3D_CUBEMAP_FACE_NEGATIVE_Z:
5919 mip_desc->ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEZ;
5920 break;
5921 }
5922
5923 }
5924
5925 if (mip == root)
5926 continue;
5927
5928 *attach = mip;
5929 attach = &mip->complex_array[0];
5930 }
5931 }
5932
5933 if (desc->dwFlags & DDSD_BACKBUFFERCOUNT)
5934 {
5935 unsigned int count = desc->dwBackBufferCount;
5936 struct ddraw_surface *last = root;
5937
5938 attach = &last->complex_array[0];
5939 for (i = 0; i < count; ++i)
5940 {
5941 if (!(texture = HeapAlloc(GetProcessHeap(), 0, sizeof(*texture))))
5942 {
5943 hr = E_OUTOFMEMORY;
5944 goto fail;
5945 }
5946
5947 texture->version = version;
5948 texture->surface_desc = root->surface_desc;
5949 desc = &texture->surface_desc;
5950
5951 /* Only one surface in the flipping chain is a back buffer, one is
5952 * a front buffer, the others are just flippable surfaces. */
5953 desc->ddsCaps.dwCaps &= ~(DDSCAPS_VISIBLE | DDSCAPS_PRIMARYSURFACE | DDSCAPS_FRONTBUFFER
5954 | DDSCAPS_BACKBUFFER);
5955 if (!i)
5956 desc->ddsCaps.dwCaps |= DDSCAPS_BACKBUFFER;
5957 desc->dwBackBufferCount = 0;
5958
5959 if (FAILED(hr = wined3d_texture_create(ddraw->wined3d_device, &wined3d_desc, 1,
5960 WINED3D_SURFACE_PIN_SYSMEM, texture, &ddraw_texture_wined3d_parent_ops, &wined3d_texture)))
5961 {
5962 HeapFree(GetProcessHeap(), 0, texture);
5963 hr = hr_ddraw_from_wined3d(hr);
5964 goto fail;
5965 }
5966
5967 resource = wined3d_texture_get_sub_resource(wined3d_texture, 0);
5968 last = wined3d_resource_get_parent(resource);
5969 last->wined3d_texture = wined3d_texture;
5970 texture->root = last;
5971
5972 if (desc->dwFlags & DDSD_CKDESTOVERLAY)
5973 wined3d_texture_set_color_key(wined3d_texture, DDCKEY_DESTOVERLAY,
5974 (struct wined3d_color_key *)&desc->u3.ddckCKDestOverlay);
5975 if (desc->dwFlags & DDSD_CKDESTBLT)
5976 wined3d_texture_set_color_key(wined3d_texture, DDCKEY_DESTBLT,
5977 (struct wined3d_color_key *)&desc->ddckCKDestBlt);
5978 if (desc->dwFlags & DDSD_CKSRCOVERLAY)
5979 wined3d_texture_set_color_key(wined3d_texture, DDCKEY_SRCOVERLAY,
5980 (struct wined3d_color_key *)&desc->ddckCKSrcOverlay);
5981 if (desc->dwFlags & DDSD_CKSRCBLT)
5982 wined3d_texture_set_color_key(wined3d_texture, DDCKEY_SRCBLT,
5983 (struct wined3d_color_key *)&desc->ddckCKSrcBlt);
5984
5985 *attach = last;
5986 attach = &last->complex_array[0];
5987 }
5988 *attach = root;
5989 }
5990
5991 if (surface_desc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
5992 ddraw->primary = root;
5993 *surface = root;
5994
5995 return DD_OK;
5996
5997 fail:
5998 if (version == 7)
5999 IDirectDrawSurface7_Release(&root->IDirectDrawSurface7_iface);
6000 else if (version == 4)
6001 IDirectDrawSurface4_Release(&root->IDirectDrawSurface4_iface);
6002 else
6003 IDirectDrawSurface_Release(&root->IDirectDrawSurface_iface);
6004
6005 return hr;
6006 }
6007
6008 HRESULT ddraw_surface_init(struct ddraw_surface *surface, struct ddraw *ddraw, struct ddraw_texture *texture,
6009 struct wined3d_surface *wined3d_surface, const struct wined3d_parent_ops **parent_ops)
6010 {
6011 DDSURFACEDESC2 *desc = &surface->surface_desc;
6012 struct wined3d_resource_desc wined3d_desc;
6013 unsigned int version = texture->version;
6014 HRESULT hr;
6015
6016 surface->IDirectDrawSurface7_iface.lpVtbl = &ddraw_surface7_vtbl;
6017 surface->IDirectDrawSurface4_iface.lpVtbl = &ddraw_surface4_vtbl;
6018 surface->IDirectDrawSurface3_iface.lpVtbl = &ddraw_surface3_vtbl;
6019 surface->IDirectDrawSurface2_iface.lpVtbl = &ddraw_surface2_vtbl;
6020 surface->IDirectDrawSurface_iface.lpVtbl = &ddraw_surface1_vtbl;
6021 surface->IDirectDrawGammaControl_iface.lpVtbl = &ddraw_gamma_control_vtbl;
6022 surface->IDirect3DTexture2_iface.lpVtbl = &d3d_texture2_vtbl;
6023 surface->IDirect3DTexture_iface.lpVtbl = &d3d_texture1_vtbl;
6024 surface->iface_count = 1;
6025 surface->version = version;
6026 surface->ddraw = ddraw;
6027
6028 if (version == 7)
6029 {
6030 surface->ref7 = 1;
6031 surface->texture_outer = (IUnknown *)&surface->IDirectDrawSurface7_iface;
6032 }
6033 else if (version == 4)
6034 {
6035 surface->ref4 = 1;
6036 surface->texture_outer = (IUnknown *)&surface->IDirectDrawSurface4_iface;
6037 }
6038 else
6039 {
6040 surface->ref1 = 1;
6041 surface->texture_outer = (IUnknown *)&surface->IDirectDrawSurface_iface;
6042 }
6043
6044 *desc = texture->surface_desc;
6045 wined3d_resource_get_desc(wined3d_surface_get_resource(wined3d_surface), &wined3d_desc);
6046 desc->dwWidth = wined3d_desc.width;
6047 desc->dwHeight = wined3d_desc.height;
6048 surface->first_attached = surface;
6049
6050 /* Anno 1602 stores the pitch right after surface creation, so make sure
6051 * it's there. TODO: Test other fourcc formats. */
6052 if (wined3d_desc.format == WINED3DFMT_DXT1 || wined3d_desc.format == WINED3DFMT_DXT2
6053 || wined3d_desc.format == WINED3DFMT_DXT3 || wined3d_desc.format == WINED3DFMT_DXT4
6054 || wined3d_desc.format == WINED3DFMT_DXT5)
6055 {
6056 surface->surface_desc.dwFlags |= DDSD_LINEARSIZE;
6057 if (wined3d_desc.format == WINED3DFMT_DXT1)
6058 surface->surface_desc.u1.dwLinearSize = max(4, desc->dwWidth) * max(4, desc->dwHeight) / 2;
6059 else
6060 surface->surface_desc.u1.dwLinearSize = max(4, desc->dwWidth) * max(4, desc->dwHeight);
6061 }
6062 else if (!(desc->dwFlags & DDSD_LPSURFACE))
6063 {
6064 desc->dwFlags |= DDSD_PITCH;
6065 desc->u1.lPitch = wined3d_surface_get_pitch(wined3d_surface);
6066 }
6067
6068 if (desc->dwFlags & DDSD_LPSURFACE)
6069 {
6070 if (desc->u1.lPitch < wined3d_surface_get_pitch(wined3d_surface) || desc->u1.lPitch & 3)
6071 {
6072 WARN("Invalid pitch %u specified.\n", desc->u1.lPitch);
6073 return DDERR_INVALIDPARAMS;
6074 }
6075
6076 if (FAILED(hr = wined3d_surface_update_desc(wined3d_surface, wined3d_desc.width,
6077 wined3d_desc.height, wined3d_desc.format, WINED3D_MULTISAMPLE_NONE, 0,
6078 desc->lpSurface, desc->u1.lPitch)))
6079 {
6080 ERR("Failed to set surface memory, hr %#x.\n", hr);
6081 return hr;
6082 }
6083
6084 desc->dwFlags &= ~DDSD_LPSURFACE;
6085 }
6086
6087 wined3d_surface_incref(wined3d_surface);
6088 surface->wined3d_surface = wined3d_surface;
6089 *parent_ops = &ddraw_surface_wined3d_parent_ops;
6090
6091 return DD_OK;
6092 }
Maarten's multimedia branch