?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Since SetParent now hides/shows, explicitly invalidating DCs in the
[wine.git] / graphics / ddraw.c
blobfdf2f9680022b90cc55517071b6ca593f8ab8b0f
1 /* DirectDraw using DGA or Xlib(XSHM)
2 *
3 * Copyright 1997,1998 Marcus Meissner
4 * Copyright 1998 Lionel Ulmer (most of Direct3D stuff)
5 */
6 /* XF86DGA:
7 * When DirectVideo mode is enabled you can no longer use 'normal' X
8 * applications nor can you switch to a virtual console. Also, enabling
9 * only works, if you have switched to the screen where the application
10 * is running.
11 * Some ways to debug this stuff are:
12 * - A terminal connected to the serial port. Can be bought used for cheap.
13 * (This is the method I am using.)
14 * - Another machine connected over some kind of network.
15 */
16
17 #include "config.h"
18
19 #include "ts_xlib.h"
20 #include "ts_xutil.h"
21
22 #ifdef HAVE_LIBXXSHM
23 #include <sys/types.h>
24 #include <sys/ipc.h>
25 #include <sys/shm.h>
26 #include "ts_xshm.h"
27 #endif /* defined(HAVE_LIBXXSHM) */
28
29 #ifdef HAVE_LIBXXF86DGA
30 #include "ts_xf86dga.h"
31 #endif /* defined(HAVE_LIBXXF86DGA) */
32
33 #ifdef HAVE_LIBXXF86VM
34 /* X is retarted and insists on declaring INT32, INT16 etc in Xmd.h,
35 this is a crude hack to get around it */
36 #define XMD_H
37 #include "wintypes.h"
38 #include "ts_xf86vmode.h"
39 #endif /* defined(HAVE_LIBXXF86VM) */
40
41 #include "x11drv.h"
42
43 #include <unistd.h>
44 #include <assert.h>
45 #include <sys/signal.h>
46 #include <fcntl.h>
47 #include <string.h>
48 #include <stdlib.h>
49 #include "windows.h"
50
51 #include "winerror.h"
52 #include "gdi.h"
53 #include "heap.h"
54 #include "ldt.h"
55 #include "dc.h"
56 #include "win.h"
57 #include "miscemu.h"
58 #include "ddraw.h"
59 #include "d3d.h"
60 #include "debug.h"
61 #include "spy.h"
62 #include "message.h"
63 #include "options.h"
64 #include "objbase.h"
65 #include "monitor.h"
66
67 /* This for all the enumeration and creation of D3D-related objects */
68 #include "d3d_private.h"
69
70 /* define this if you want to play Diablo using XF86DGA. (bug workaround) */
71 #undef DIABLO_HACK
72
73 /* Restore signal handlers overwritten by XF86DGA
74 */
75 #define RESTORE_SIGNALS
76
77 /* Where do these GUIDs come from? mkuuid.
78 * They exist solely to distinguish between the targets Wine support,
79 * and should be different than any other GUIDs in existence.
80 */
81 static GUID DGA_DirectDraw_GUID = { /* e2dcb020-dc60-11d1-8407-9714f5d50802 */
82 0xe2dcb020,
83 0xdc60,
84 0x11d1,
85 {0x84, 0x07, 0x97, 0x14, 0xf5, 0xd5, 0x08, 0x02}
86 };
87
88 static GUID XLIB_DirectDraw_GUID = { /* 1574a740-dc61-11d1-8407-f7875a7d1879 */
89 0x1574a740,
90 0xdc61,
91 0x11d1,
92 {0x84, 0x07, 0xf7, 0x87, 0x5a, 0x7d, 0x18, 0x79}
93 };
94
95 static struct IDirectDrawSurface4_VTable dga_dds4vt, xlib_dds4vt;
96 static struct IDirectDraw_VTable dga_ddvt, xlib_ddvt;
97 static struct IDirectDraw2_VTable dga_dd2vt, xlib_dd2vt;
98 static struct IDirectDraw4_VTable dga_dd4vt, xlib_dd4vt;
99 static struct IDirectDrawClipper_VTable ddclipvt;
100 static struct IDirectDrawPalette_VTable dga_ddpalvt, xlib_ddpalvt;
101 static struct IDirect3D_VTable d3dvt;
102 static struct IDirect3D2_VTable d3d2vt;
103
104 #ifdef HAVE_LIBXXF86VM
105 static XF86VidModeModeInfo *orig_mode = NULL;
106 #endif
107
108 #ifdef HAVE_LIBXXSHM
109 static int XShmErrorFlag = 0;
110 #endif
111
112 BOOL32
113 DDRAW_DGA_Available(void)
114 {
115 #ifdef HAVE_LIBXXF86DGA
116 int evbase, evret, fd;
117
118 if (Options.noDGA)
119 return 0;
120
121 /* You don't have to be root to use DGA extensions. Simply having access to /dev/mem will do the trick */
122 /* This can be achieved by adding the user to the "kmem" group on Debian 2.x systems, don't know about */
123 /* others. --stephenc */
124 if ((fd = open("/dev/mem", O_RDWR)) != -1)
125 close(fd);
126
127 return (fd != -1) && TSXF86DGAQueryExtension(display,&evbase,&evret);
128 #else /* defined(HAVE_LIBXXF86DGA) */
129 return 0;
130 #endif /* defined(HAVE_LIBXXF86DGA) */
131 }
132
133 HRESULT WINAPI
134 DirectDrawEnumerate32A(LPDDENUMCALLBACK32A ddenumproc,LPVOID data) {
135 if (DDRAW_DGA_Available()) {
136 TRACE(ddraw, "Enumerating DGA interface\n");
137 ddenumproc(&DGA_DirectDraw_GUID,"WINE with XFree86 DGA","display",data);
138 }
139 TRACE(ddraw, "Enumerating Xlib interface\n");
140 ddenumproc(&XLIB_DirectDraw_GUID,"WINE with Xlib","display",data);
141 TRACE(ddraw, "Enumerating Default interface\n");
142 ddenumproc(NULL,"WINE (default)","display",data);
143 return DD_OK;
144 }
145
146 /* What is this doing here? */
147 HRESULT WINAPI
148 DSoundHelp(DWORD x,DWORD y,DWORD z) {
149 FIXME(ddraw,"(0x%08lx,0x%08lx,0x%08lx),stub!\n",x,y,z);
150 return 0;
151 }
152
153
154 /******************************************************************************
155 * internal helper functions
156 */
157 static void _dump_DDBLTFX(DWORD flagmask) {
158 int i;
159 const struct {
160 DWORD mask;
161 char *name;
162 } flags[] = {
163 #define FE(x) { x, #x},
164 FE(DDBLTFX_ARITHSTRETCHY)
165 FE(DDBLTFX_MIRRORLEFTRIGHT)
166 FE(DDBLTFX_MIRRORUPDOWN)
167 FE(DDBLTFX_NOTEARING)
168 FE(DDBLTFX_ROTATE180)
169 FE(DDBLTFX_ROTATE270)
170 FE(DDBLTFX_ROTATE90)
171 FE(DDBLTFX_ZBUFFERRANGE)
172 FE(DDBLTFX_ZBUFFERBASEDEST)
173 };
174 for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
175 if (flags[i].mask & flagmask) {
176 DUMP("%s ",flags[i].name);
177
178 };
179 DUMP("\n");
180
181 }
182
183 static void _dump_DDBLTFAST(DWORD flagmask) {
184 int i;
185 const struct {
186 DWORD mask;
187 char *name;
188 } flags[] = {
189 #define FE(x) { x, #x},
190 FE(DDBLTFAST_NOCOLORKEY)
191 FE(DDBLTFAST_SRCCOLORKEY)
192 FE(DDBLTFAST_DESTCOLORKEY)
193 FE(DDBLTFAST_WAIT)
194 };
195 for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
196 if (flags[i].mask & flagmask)
197 DUMP("%s ",flags[i].name);
198 DUMP("\n");
199 }
200
201 static void _dump_DDBLT(DWORD flagmask) {
202 int i;
203 const struct {
204 DWORD mask;
205 char *name;
206 } flags[] = {
207 #define FE(x) { x, #x},
208 FE(DDBLT_ALPHADEST)
209 FE(DDBLT_ALPHADESTCONSTOVERRIDE)
210 FE(DDBLT_ALPHADESTNEG)
211 FE(DDBLT_ALPHADESTSURFACEOVERRIDE)
212 FE(DDBLT_ALPHAEDGEBLEND)
213 FE(DDBLT_ALPHASRC)
214 FE(DDBLT_ALPHASRCCONSTOVERRIDE)
215 FE(DDBLT_ALPHASRCNEG)
216 FE(DDBLT_ALPHASRCSURFACEOVERRIDE)
217 FE(DDBLT_ASYNC)
218 FE(DDBLT_COLORFILL)
219 FE(DDBLT_DDFX)
220 FE(DDBLT_DDROPS)
221 FE(DDBLT_KEYDEST)
222 FE(DDBLT_KEYDESTOVERRIDE)
223 FE(DDBLT_KEYSRC)
224 FE(DDBLT_KEYSRCOVERRIDE)
225 FE(DDBLT_ROP)
226 FE(DDBLT_ROTATIONANGLE)
227 FE(DDBLT_ZBUFFER)
228 FE(DDBLT_ZBUFFERDESTCONSTOVERRIDE)
229 FE(DDBLT_ZBUFFERDESTOVERRIDE)
230 FE(DDBLT_ZBUFFERSRCCONSTOVERRIDE)
231 FE(DDBLT_ZBUFFERSRCOVERRIDE)
232 FE(DDBLT_WAIT)
233 FE(DDBLT_DEPTHFILL)
234 };
235 for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
236 if (flags[i].mask & flagmask)
237 DUMP("%s ",flags[i].name);
238 DUMP("\n");
239 }
240
241 static void _dump_DDSCAPS(DWORD flagmask) {
242 int i;
243 const struct {
244 DWORD mask;
245 char *name;
246 } flags[] = {
247 #define FE(x) { x, #x},
248 FE(DDSCAPS_RESERVED1)
249 FE(DDSCAPS_ALPHA)
250 FE(DDSCAPS_BACKBUFFER)
251 FE(DDSCAPS_COMPLEX)
252 FE(DDSCAPS_FLIP)
253 FE(DDSCAPS_FRONTBUFFER)
254 FE(DDSCAPS_OFFSCREENPLAIN)
255 FE(DDSCAPS_OVERLAY)
256 FE(DDSCAPS_PALETTE)
257 FE(DDSCAPS_PRIMARYSURFACE)
258 FE(DDSCAPS_PRIMARYSURFACELEFT)
259 FE(DDSCAPS_SYSTEMMEMORY)
260 FE(DDSCAPS_TEXTURE)
261 FE(DDSCAPS_3DDEVICE)
262 FE(DDSCAPS_VIDEOMEMORY)
263 FE(DDSCAPS_VISIBLE)
264 FE(DDSCAPS_WRITEONLY)
265 FE(DDSCAPS_ZBUFFER)
266 FE(DDSCAPS_OWNDC)
267 FE(DDSCAPS_LIVEVIDEO)
268 FE(DDSCAPS_HWCODEC)
269 FE(DDSCAPS_MODEX)
270 FE(DDSCAPS_MIPMAP)
271 FE(DDSCAPS_RESERVED2)
272 FE(DDSCAPS_ALLOCONLOAD)
273 FE(DDSCAPS_VIDEOPORT)
274 FE(DDSCAPS_LOCALVIDMEM)
275 FE(DDSCAPS_NONLOCALVIDMEM)
276 FE(DDSCAPS_STANDARDVGAMODE)
277 FE(DDSCAPS_OPTIMIZED)
278 };
279 for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
280 if (flags[i].mask & flagmask)
281 DUMP("%s ",flags[i].name);
282 DUMP("\n");
283 }
284
285 static void _dump_DDSD(DWORD flagmask) {
286 int i;
287 const struct {
288 DWORD mask;
289 char *name;
290 } flags[] = {
291 FE(DDSD_CAPS)
292 FE(DDSD_HEIGHT)
293 FE(DDSD_WIDTH)
294 FE(DDSD_PITCH)
295 FE(DDSD_BACKBUFFERCOUNT)
296 FE(DDSD_ZBUFFERBITDEPTH)
297 FE(DDSD_ALPHABITDEPTH)
298 FE(DDSD_PIXELFORMAT)
299 FE(DDSD_CKDESTOVERLAY)
300 FE(DDSD_CKDESTBLT)
301 FE(DDSD_CKSRCOVERLAY)
302 FE(DDSD_CKSRCBLT)
303 FE(DDSD_MIPMAPCOUNT)
304 FE(DDSD_REFRESHRATE)
305 FE(DDSD_LINEARSIZE)
306 FE(DDSD_LPSURFACE)
307 };
308 for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
309 if (flags[i].mask & flagmask)
310 DUMP("%s ",flags[i].name);
311 DUMP("\n");
312 }
313
314 static void _dump_DDCOLORKEY(DWORD flagmask) {
315 int i;
316 const struct {
317 DWORD mask;
318 char *name;
319 } flags[] = {
320 #define FE(x) { x, #x},
321 FE(DDPF_ALPHAPIXELS)
322 FE(DDPF_ALPHA)
323 FE(DDPF_FOURCC)
324 FE(DDPF_PALETTEINDEXED4)
325 FE(DDPF_PALETTEINDEXEDTO8)
326 FE(DDPF_PALETTEINDEXED8)
327 FE(DDPF_RGB)
328 FE(DDPF_COMPRESSED)
329 FE(DDPF_RGBTOYUV)
330 FE(DDPF_YUV)
331 FE(DDPF_ZBUFFER)
332 FE(DDPF_PALETTEINDEXED1)
333 FE(DDPF_PALETTEINDEXED2)
334 FE(DDPF_ZPIXELS)
335 };
336 for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
337 if (flags[i].mask & flagmask)
338 DUMP("%s ",flags[i].name);
339 DUMP("\n");
340 }
341
342 static void _dump_paletteformat(DWORD dwFlags) {
343 int i;
344 const struct {
345 DWORD mask;
346 char *name;
347 } flags[] = {
348 #define FE(x) { x, #x},
349 FE(DDPCAPS_4BIT)
350 FE(DDPCAPS_8BITENTRIES)
351 FE(DDPCAPS_8BIT)
352 FE(DDPCAPS_INITIALIZE)
353 FE(DDPCAPS_PRIMARYSURFACE)
354 FE(DDPCAPS_PRIMARYSURFACELEFT)
355 FE(DDPCAPS_ALLOW256)
356 FE(DDPCAPS_VSYNC)
357 FE(DDPCAPS_1BIT)
358 FE(DDPCAPS_2BIT)
359 FE(DDPCAPS_ALPHA)
360 };
361 for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
362 if (flags[i].mask & dwFlags)
363 DUMP("%s ",flags[i].name);
364 DUMP("\n");
365 }
366
367 static void _dump_pixelformat(LPDDPIXELFORMAT pf) {
368 DUMP("Size : %ld\n", pf->dwSize);
369 if (pf->dwFlags)
370 _dump_DDCOLORKEY(pf->dwFlags);
371 DUMP("dwFourCC : %ld\n", pf->dwFourCC);
372 DUMP("RGB bit count : %ld\n", pf->x.dwRGBBitCount);
373 DUMP("Masks : R %08lx G %08lx B %08lx A %08lx\n",
374 pf->y.dwRBitMask, pf->z.dwGBitMask, pf->xx.dwBBitMask, pf->xy.dwRGBAlphaBitMask);
375 }
376
377 static int _getpixelformat(LPDIRECTDRAW2 ddraw,LPDDPIXELFORMAT pf) {
378 static XVisualInfo *vi;
379 XVisualInfo vt;
380 int nitems;
381
382 if (!vi)
383 vi = TSXGetVisualInfo(display,VisualNoMask,&vt,&nitems);
384
385 pf->dwFourCC = 0;
386 pf->dwSize = sizeof(DDPIXELFORMAT);
387 if (ddraw->d.depth==8) {
388 pf->dwFlags = DDPF_RGB|DDPF_PALETTEINDEXED8;
389 pf->x.dwRGBBitCount = 8;
390 pf->y.dwRBitMask = 0;
391 pf->z.dwGBitMask = 0;
392 pf->xx.dwBBitMask = 0;
393 pf->xy.dwRGBAlphaBitMask= 0;
394 return 0;
395 }
396 if (ddraw->d.depth==16) {
397 pf->dwFlags = DDPF_RGB;
398 pf->x.dwRGBBitCount = 16;
399 pf->y.dwRBitMask = vi[0].red_mask;
400 pf->z.dwGBitMask = vi[0].green_mask;
401 pf->xx.dwBBitMask = vi[0].blue_mask;
402 pf->xy.dwRGBAlphaBitMask= 0;
403 return 0;
404 }
405 if (ddraw->d.depth==24) {
406 pf->dwFlags = DDPF_RGB;
407 pf->x.dwRGBBitCount = 24;
408 pf->y.dwRBitMask = vi[0].red_mask;
409 pf->z.dwGBitMask = vi[0].green_mask;
410 pf->xx.dwBBitMask = vi[0].blue_mask;
411 pf->xy.dwRGBAlphaBitMask= 0;
412 return 0;
413 }
414 FIXME(ddraw,"_getpixelformat:unknown depth %ld?\n",ddraw->d.depth);
415 return DDERR_GENERIC;
416 }
417
418 /******************************************************************************
419 * IDirectDrawSurface methods
420 *
421 * Since DDS3 and DDS2 are supersets of DDS, we implement DDS3 and let
422 * DDS and DDS2 use those functions. (Function calls did not change (except
423 * using different DirectDrawSurfaceX version), just added flags and functions)
424 */
425 static HRESULT WINAPI IDirectDrawSurface4_Lock(
426 LPDIRECTDRAWSURFACE4 this,LPRECT32 lprect,LPDDSURFACEDESC lpddsd,DWORD flags, HANDLE32 hnd
427 ) {
428 TRACE(ddraw, "(%p)->Lock(%p,%p,%08lx,%08lx)\n",
429 this,lprect,lpddsd,flags,(DWORD)hnd);
430 if (flags & ~(DDLOCK_WAIT|DDLOCK_READONLY|DDLOCK_WRITEONLY))
431 WARN(ddraw, "(%p)->Lock(%p,%p,%08lx,%08lx)\n",
432 this,lprect,lpddsd,flags,(DWORD)hnd);
433
434 /* First, copy the Surface description */
435 *lpddsd = this->s.surface_desc;
436 TRACE(ddraw,"locked surface: height=%ld, width=%ld, pitch=%ld\n",
437 lpddsd->dwHeight,lpddsd->dwWidth,lpddsd->lPitch);
438
439 /* If asked only for a part, change the surface pointer */
440 if (lprect) {
441 FIXME(ddraw," lprect: %dx%d-%dx%d\n",
442 lprect->top,lprect->left,lprect->bottom,lprect->right
443 );
444 lpddsd->y.lpSurface = this->s.surface_desc.y.lpSurface +
445 (lprect->top*this->s.surface_desc.lPitch) +
446 (lprect->left*(this->s.surface_desc.ddpfPixelFormat.x.dwRGBBitCount / 8));
447 } else {
448 assert(this->s.surface_desc.y.lpSurface);
449 }
450 return DD_OK;
451 }
452
453 static HRESULT WINAPI DGA_IDirectDrawSurface4_Unlock(
454 LPDIRECTDRAWSURFACE4 this,LPVOID surface
455 ) {
456 TRACE(ddraw,"(%p)->Unlock(%p)\n",this,surface);
457 return DD_OK;
458 }
459
460 static void Xlib_copy_surface_on_screen(LPDIRECTDRAWSURFACE4 this) {
461 if (this->s.ddraw->d.depth != this->s.ddraw->d.screen_depth) {
462 /* Pixel convertion ! */
463 if ((this->s.ddraw->d.depth == 8) && (this->s.ddraw->d.screen_depth == 16)) {
464 unsigned char *src = (unsigned char *) this->s.surface_desc.y.lpSurface;
465 unsigned short *dst = (unsigned short *) this->t.xlib.image->data;
466 unsigned short *pal;
467 int x, y;
468
469 if (this->s.palette != NULL) {
470 pal = (unsigned short *) this->s.palette->screen_palents;
471 for (y = 0; y < this->s.surface_desc.dwHeight; y++) {
472 for (x = 0; x < this->s.surface_desc.dwWidth; x++) {
473 dst[x + y * this->s.surface_desc.lPitch] = pal[src[x + y * this->s.surface_desc.lPitch]];
474 }
475 }
476 } else {
477 WARN(ddraw, "No palette set...\n");
478 memset(dst, 0, this->s.surface_desc.lPitch * this->s.surface_desc.dwHeight * 2);
479 }
480 } else {
481 ERR(ddraw, "Unsupported pixel convertion...\n");
482 }
483 }
484
485 #ifdef HAVE_LIBXXSHM
486 if (this->s.ddraw->e.xlib.xshm_active)
487 TSXShmPutImage(display,
488 this->s.ddraw->d.drawable,
489 DefaultGCOfScreen(X11DRV_GetXScreen()),
490 this->t.xlib.image,
491 0, 0, 0, 0,
492 this->t.xlib.image->width,
493 this->t.xlib.image->height,
494 False);
495 else
496 #endif
497 TSXPutImage( display,
498 this->s.ddraw->d.drawable,
499 DefaultGCOfScreen(X11DRV_GetXScreen()),
500 this->t.xlib.image,
501 0, 0, 0, 0,
502 this->t.xlib.image->width,
503 this->t.xlib.image->height);
504 }
505
506 static HRESULT WINAPI Xlib_IDirectDrawSurface4_Unlock(
507 LPDIRECTDRAWSURFACE4 this,LPVOID surface)
508 {
509 TRACE(ddraw,"(%p)->Unlock(%p)\n",this,surface);
510
511 if (!this->s.ddraw->d.paintable)
512 return DD_OK;
513
514 /* Only redraw the screen when unlocking the buffer that is on screen */
515 if ((this->t.xlib.image != NULL) &&
516 (this->s.surface_desc.ddsCaps.dwCaps & DDSCAPS_VISIBLE)) {
517 Xlib_copy_surface_on_screen(this);
518
519 if (this->s.palette && this->s.palette->cm)
520 TSXSetWindowColormap(display,this->s.ddraw->d.drawable,this->s.palette->cm);
521 }
522
523 return DD_OK;
524 }
525
526 static HRESULT WINAPI DGA_IDirectDrawSurface4_Flip(
527 LPDIRECTDRAWSURFACE4 this,LPDIRECTDRAWSURFACE4 flipto,DWORD dwFlags
528 ) {
529 #ifdef HAVE_LIBXXF86DGA
530 TRACE(ddraw,"(%p)->Flip(%p,%08lx)\n",this,flipto,dwFlags);
531 if (!flipto) {
532 if (this->s.backbuffer)
533 flipto = this->s.backbuffer;
534 else
535 flipto = this;
536 }
537 TSXF86DGASetViewPort(display,DefaultScreen(display),0,flipto->t.dga.fb_height);
538
539 if (flipto->s.palette && flipto->s.palette->cm) {
540 TSXF86DGAInstallColormap(display,DefaultScreen(display),flipto->s.palette->cm);
541 }
542 while (!TSXF86DGAViewPortChanged(display,DefaultScreen(display),2)) {
543 }
544 if (flipto!=this) {
545 int tmp;
546 LPVOID ptmp;
547
548 tmp = this->t.dga.fb_height;
549 this->t.dga.fb_height = flipto->t.dga.fb_height;
550 flipto->t.dga.fb_height = tmp;
551
552 ptmp = this->s.surface_desc.y.lpSurface;
553 this->s.surface_desc.y.lpSurface = flipto->s.surface_desc.y.lpSurface;
554 flipto->s.surface_desc.y.lpSurface = ptmp;
555 }
556 return DD_OK;
557 #else /* defined(HAVE_LIBXXF86DGA) */
558 return E_UNEXPECTED;
559 #endif /* defined(HAVE_LIBXXF86DGA) */
560 }
561
562 static HRESULT WINAPI Xlib_IDirectDrawSurface4_Flip(
563 LPDIRECTDRAWSURFACE4 this,LPDIRECTDRAWSURFACE4 flipto,DWORD dwFlags
564 ) {
565 TRACE(ddraw,"(%p)->Flip(%p,%08lx)\n",this,flipto,dwFlags);
566 if (!this->s.ddraw->d.paintable)
567 return DD_OK;
568
569 if (!flipto) {
570 if (this->s.backbuffer)
571 flipto = this->s.backbuffer;
572 else
573 flipto = this;
574 }
575
576 Xlib_copy_surface_on_screen(this);
577
578 if (flipto->s.palette && flipto->s.palette->cm) {
579 TSXSetWindowColormap(display,this->s.ddraw->d.drawable,flipto->s.palette->cm);
580 }
581 if (flipto!=this) {
582 XImage *tmp;
583 LPVOID *surf;
584 tmp = this->t.xlib.image;
585 this->t.xlib.image = flipto->t.xlib.image;
586 flipto->t.xlib.image = tmp;
587 surf = this->s.surface_desc.y.lpSurface;
588 this->s.surface_desc.y.lpSurface = flipto->s.surface_desc.y.lpSurface;
589 flipto->s.surface_desc.y.lpSurface = surf;
590 }
591 return DD_OK;
592 }
593
594
595 /* The IDirectDrawSurface4::SetPalette method attaches the specified
596 * DirectDrawPalette object to a surface. The surface uses this palette for all
597 * subsequent operations. The palette change takes place immediately.
598 */
599 static HRESULT WINAPI Xlib_IDirectDrawSurface4_SetPalette(
600 LPDIRECTDRAWSURFACE4 this,LPDIRECTDRAWPALETTE pal
601 ) {
602 int i;
603 TRACE(ddraw,"(%p)->(%p)\n",this,pal);
604
605 if (pal == NULL) {
606 if( this->s.palette != NULL )
607 this->s.palette->lpvtbl->fnRelease( this->s.palette );
608 this->s.palette = pal;
609
610 return DD_OK;
611 }
612
613 if( !(pal->cm) && (this->s.ddraw->d.screen_depth<=8))
614 {
615 pal->cm = TSXCreateColormap(display,this->s.ddraw->d.drawable,
616 DefaultVisualOfScreen(X11DRV_GetXScreen()),AllocAll);
617
618 if (!Options.managed)
619 TSXInstallColormap(display,pal->cm);
620
621 for (i=0;i<256;i++) {
622 XColor xc;
623
624 xc.red = pal->palents[i].peRed<<8;
625 xc.blue = pal->palents[i].peBlue<<8;
626 xc.green = pal->palents[i].peGreen<<8;
627 xc.flags = DoRed|DoBlue|DoGreen;
628 xc.pixel = i;
629 TSXStoreColor(display,pal->cm,&xc);
630 }
631 TSXInstallColormap(display,pal->cm);
632 }
633
634 /* According to spec, we are only supposed to
635 * AddRef if this is not the same palette.
636 */
637 if( this->s.palette != pal )
638 {
639 if( pal != NULL )
640 pal->lpvtbl->fnAddRef( pal );
641 if( this->s.palette != NULL )
642 this->s.palette->lpvtbl->fnRelease( this->s.palette );
643 this->s.palette = pal;
644
645 /* I think that we need to attach it to all backbuffers...*/
646 if( this->s.backbuffer ) {
647 if( this->s.backbuffer->s.palette )
648 this->s.backbuffer->s.palette->lpvtbl->fnRelease(
649 this->s.backbuffer->s.palette );
650 this->s.backbuffer->s.palette = pal;
651 if( pal )
652 pal->lpvtbl->fnAddRef( pal );
653 }
654 /* Perform the refresh */
655 TSXSetWindowColormap(display,this->s.ddraw->d.drawable,this->s.palette->cm);
656 }
657 return DD_OK;
658 }
659
660 static HRESULT WINAPI DGA_IDirectDrawSurface4_SetPalette(
661 LPDIRECTDRAWSURFACE4 this,LPDIRECTDRAWPALETTE pal
662 ) {
663 TRACE(ddraw,"(%p)->(%p)\n",this,pal);
664 #ifdef HAVE_LIBXXF86DGA
665 /* According to spec, we are only supposed to
666 * AddRef if this is not the same palette.
667 */
668 if( this->s.palette != pal )
669 {
670 if( pal != NULL )
671 pal->lpvtbl->fnAddRef( pal );
672 if( this->s.palette != NULL )
673 this->s.palette->lpvtbl->fnRelease( this->s.palette );
674 this->s.palette = pal;
675
676 /* I think that we need to attach it to all backbuffers...*/
677 if( this->s.backbuffer ) {
678 if( this->s.backbuffer->s.palette )
679 this->s.backbuffer->s.palette->lpvtbl->fnRelease(this->s.backbuffer->s.palette );
680 this->s.backbuffer->s.palette = pal;
681 if( pal ) pal->lpvtbl->fnAddRef( pal );
682 }
683 TSXF86DGAInstallColormap(display,DefaultScreen(display),this->s.palette->cm);
684 }
685 return DD_OK;
686 #else /* defined(HAVE_LIBXXF86DGA) */
687 return E_UNEXPECTED;
688 #endif /* defined(HAVE_LIBXXF86DGA) */
689
690
691 }
692
693 static HRESULT WINAPI IDirectDrawSurface4_Blt(
694 LPDIRECTDRAWSURFACE4 this,LPRECT32 rdst,LPDIRECTDRAWSURFACE4 src,LPRECT32 rsrc,DWORD dwFlags,LPDDBLTFX lpbltfx
695 ) {
696 RECT32 xdst,xsrc;
697 DDSURFACEDESC ddesc,sdesc;
698 int i,j;
699
700 TRACE(ddraw,"(%p)->(%p,%p,%p,%08lx,%p)\n",
701 this,rdst,src,rsrc,dwFlags,lpbltfx);
702
703 if (src != NULL)
704 src ->lpvtbl->fnLock(src, NULL,&sdesc,0,0);
705 this->lpvtbl->fnLock(this,NULL,&ddesc,0,0);
706
707 if (TRACE_ON(ddraw)) {
708 if (rdst) TRACE(ddraw," destrect :%dx%d-%dx%d\n",rdst->left,rdst->top,rdst->right,rdst->bottom);
709 if (rsrc) TRACE(ddraw," srcrect :%dx%d-%dx%d\n",rsrc->left,rsrc->top,rsrc->right,rsrc->bottom);
710 TRACE(ddraw,"\tflags: ");_dump_DDBLT(dwFlags);fprintf(stderr,"\n");
711 if (dwFlags & DDBLT_DDFX) {
712 TRACE(ddraw," blitfx: \n");_dump_DDBLTFX(lpbltfx->dwDDFX);
713 }
714 }
715
716 if (rdst) {
717 memcpy(&xdst,rdst,sizeof(xdst));
718 } else {
719 xdst.top = 0;
720 xdst.bottom = ddesc.dwHeight;
721 xdst.left = 0;
722 xdst.right = ddesc.dwWidth;
723 }
724
725 if (rsrc) {
726 memcpy(&xsrc,rsrc,sizeof(xsrc));
727 } else {
728 if (src) {
729 xsrc.top = 0;
730 xsrc.bottom = sdesc.dwHeight;
731 xsrc.left = 0;
732 xsrc.right = sdesc.dwWidth;
733 } else {
734 memset(&xsrc,0,sizeof(xsrc));
735 }
736 }
737
738 dwFlags &= ~(DDBLT_WAIT|DDBLT_ASYNC);/* FIXME: can't handle right now */
739
740 /* First, all the 'source-less' blits */
741 if (dwFlags & DDBLT_COLORFILL) {
742 int bpp = ddesc.ddpfPixelFormat.x.dwRGBBitCount / 8;
743 LPBYTE xline,xpixel;
744
745 xline = (LPBYTE) ddesc.y.lpSurface + xdst.top * ddesc.lPitch;
746 for (i=xdst.top;i<xdst.bottom;i++) {
747 xpixel = xline+bpp*xdst.left;
748
749 for (j=xdst.left;j<xdst.right;j++) {
750 /* FIXME: this only works on little endian
751 * architectures, where DWORD starts with low
752 * byte first!
753 */
754 memcpy(xpixel,&(lpbltfx->b.dwFillColor),bpp);
755 xpixel += bpp;
756 }
757 xline += ddesc.lPitch;
758 }
759 dwFlags &= ~(DDBLT_COLORFILL);
760 }
761
762 if (dwFlags & DDBLT_DEPTHFILL) {
763 #ifdef HAVE_MESAGL
764 GLboolean ztest;
765
766 /* Clears the screen */
767 TRACE(ddraw, " Filling depth buffer with %ld\n", lpbltfx->b.dwFillDepth);
768 glClearDepth(lpbltfx->b.dwFillDepth / 65535.0); /* We suppose a 16 bit Z Buffer */
769 glGetBooleanv(GL_DEPTH_TEST, &ztest);
770 glDepthMask(GL_TRUE); /* Enables Z writing to be sure to delete also the Z buffer */
771 glClear(GL_DEPTH_BUFFER_BIT);
772 glDepthMask(ztest);
773
774 dwFlags &= ~(DDBLT_DEPTHFILL);
775 #endif HAVE_MESAGL
776 }
777
778 if (!src) {
779 if (dwFlags) {
780 TRACE(ddraw,"\t(src=NULL):Unsupported flags: ");_dump_DDBLT(dwFlags);fprintf(stderr,"\n");
781 }
782 this->lpvtbl->fnUnlock(this,ddesc.y.lpSurface);
783 return DD_OK;
784 }
785
786 /* Now the 'with source' blits */
787
788 /* Standard 'full-surface' blit without special effects */
789 if ( (xsrc.top ==0) && (xsrc.bottom ==ddesc.dwHeight) &&
790 (xsrc.left==0) && (xsrc.right ==ddesc.dwWidth) &&
791 (xdst.top ==0) && (xdst.bottom ==ddesc.dwHeight) &&
792 (xdst.left==0) && (xdst.right ==ddesc.dwWidth) &&
793 !dwFlags
794 ) {
795 memcpy(ddesc.y.lpSurface,
796 sdesc.y.lpSurface,
797 ddesc.dwHeight * ddesc.lPitch);
798 } else {
799 int bpp = ddesc.ddpfPixelFormat.x.dwRGBBitCount / 8;
800 int srcheight = xsrc.bottom - xsrc.top;
801 int srcwidth = xsrc.right - xsrc.left;
802 int dstheight = xdst.bottom - xdst.top;
803 int dstwidth = xdst.right - xdst.left;
804 int width = (xsrc.right - xsrc.left) * bpp;
805 int h;
806
807 /* Sanity check for rectangle sizes */
808 if ((srcheight != dstheight) || (srcwidth != dstwidth)) {
809 int x, y;
810
811 /* I think we should do a Blit with 'stretching' here....
812 Tomb Raider II uses this to display the background during the menu selection
813 when the screen resolution is != than 640x480 */
814 TRACE(ddraw, "Blt with stretching\n");
815
816 /* This is a basic stretch implementation. It is painfully slow and quite ugly. */
817 if (bpp == 1) {
818 /* In this case, we cannot do any anti-aliasing */
819 if(dwFlags & DDBLT_KEYSRC) {
820 for (y = xdst.top; y < xdst.bottom; y++) {
821 for (x = xdst.left; x < xdst.right; x++) {
822 double sx, sy;
823 unsigned char tmp;
824 unsigned char *dbuf = (unsigned char *) ddesc.y.lpSurface;
825 unsigned char *sbuf = (unsigned char *) sdesc.y.lpSurface;
826
827 sx = (((double) (x - xdst.left) / dstwidth) * srcwidth) + xsrc.left;
828 sy = (((double) (y - xdst.top) / dstheight) * srcheight) + xsrc.top;
829
830 tmp = sbuf[(((int) sy) * sdesc.lPitch) + ((int) sx)];
831
832 if ((tmp < src->s.surface_desc.ddckCKSrcBlt.dwColorSpaceLowValue) ||
833 (tmp > src->s.surface_desc.ddckCKSrcBlt.dwColorSpaceHighValue))
834 dbuf[(y * ddesc.lPitch) + x] = tmp;
835 }
836 }
837 } else {
838 for (y = xdst.top; y < xdst.bottom; y++) {
839 for (x = xdst.left; x < xdst.right; x++) {
840 double sx, sy;
841 unsigned char *dbuf = (unsigned char *) ddesc.y.lpSurface;
842 unsigned char *sbuf = (unsigned char *) sdesc.y.lpSurface;
843
844 sx = (((double) (x - xdst.left) / dstwidth) * srcwidth) + xsrc.left;
845 sy = (((double) (y - xdst.top) / dstheight) * srcheight) + xsrc.top;
846
847 dbuf[(y * ddesc.lPitch) + x] = sbuf[(((int) sy) * sdesc.lPitch) + ((int) sx)];
848 }
849 }
850 }
851 } else {
852 FIXME(ddraw, "Not done yet for depth != 8\n");
853 }
854 } else {
855 /* Same size => fast blit */
856 if (dwFlags & DDBLT_KEYSRC) {
857 switch (bpp) {
858 case 1: {
859 unsigned char tmp,*psrc,*pdst;
860 int h,i;
861
862 for (h = 0; h < srcheight; h++) {
863 psrc=sdesc.y.lpSurface +
864 ((h + xsrc.top) * sdesc.lPitch) + xsrc.left;
865 pdst=ddesc.y.lpSurface +
866 ((h + xdst.top) * ddesc.lPitch) + xdst.left;
867 for(i=0;i<srcwidth;i++) {
868 tmp=*(psrc + i);
869 if ((tmp < src->s.surface_desc.ddckCKSrcBlt.dwColorSpaceLowValue) ||
870 (tmp > src->s.surface_desc.ddckCKSrcBlt.dwColorSpaceHighValue))
871 *(pdst + i)=tmp;
872 }
873 }
874 dwFlags&=~(DDBLT_KEYSRC);
875 } break;
876
877 case 2: {
878 unsigned short tmp,*psrc,*pdst;
879 int h,i;
880
881 for (h = 0; h < srcheight; h++) {
882 psrc=sdesc.y.lpSurface +
883 ((h + xsrc.top) * sdesc.lPitch) + xsrc.left;
884 pdst=ddesc.y.lpSurface +
885 ((h + xdst.top) * ddesc.lPitch) + xdst.left;
886 for(i=0;i<srcwidth;i++) {
887 tmp=*(psrc + i);
888 if ((tmp < src->s.surface_desc.ddckCKSrcBlt.dwColorSpaceLowValue) ||
889 (tmp > src->s.surface_desc.ddckCKSrcBlt.dwColorSpaceHighValue))
890 *(pdst + i)=tmp;
891 }
892 }
893 dwFlags&=~(DDBLT_KEYSRC);
894 } break;
895
896 default:
897 FIXME(ddraw, "Bitblt, KEYSRC: Not done yet for depth > 16\n");
898 }
899 } else {
900 /* Non-stretching Blt without color keying */
901 for (h = 0; h < srcheight; h++) {
902 memcpy(ddesc.y.lpSurface + ((h + xdst.top) * ddesc.lPitch) + xdst.left * bpp,
903 sdesc.y.lpSurface + ((h + xsrc.top) * sdesc.lPitch) + xsrc.left * bpp,
904 width);
905 }
906 }
907 }
908 }
909
910 if (dwFlags && FIXME_ON(ddraw)) {
911 FIXME(ddraw,"\tUnsupported flags: ");_dump_DDBLT(dwFlags);
912 }
913
914 this->lpvtbl->fnUnlock(this,ddesc.y.lpSurface);
915 src ->lpvtbl->fnUnlock(src,sdesc.y.lpSurface);
916
917 return DD_OK;
918 }
919
920 static HRESULT WINAPI IDirectDrawSurface4_BltFast(
921 LPDIRECTDRAWSURFACE4 this,DWORD dstx,DWORD dsty,LPDIRECTDRAWSURFACE4 src,LPRECT32 rsrc,DWORD trans
922 ) {
923 int i,bpp,w,h;
924 DDSURFACEDESC ddesc,sdesc;
925
926 if (1 || TRACE_ON(ddraw)) {
927 FIXME(ddraw,"(%p)->(%ld,%ld,%p,%p,%08lx)\n",
928 this,dstx,dsty,src,rsrc,trans
929 );
930 FIXME(ddraw," trans:");
931 if (FIXME_ON(ddraw))
932 _dump_DDBLTFAST(trans);
933 FIXME(ddraw," srcrect: %dx%d-%dx%d\n",rsrc->left,rsrc->top,rsrc->right,rsrc->bottom);
934 }
935 /* We need to lock the surfaces, or we won't get refreshes when done. */
936 src ->lpvtbl->fnLock(src, NULL,&sdesc,DDLOCK_READONLY, 0);
937 this->lpvtbl->fnLock(this,NULL,&ddesc,DDLOCK_WRITEONLY,0);
938 bpp = this->s.surface_desc.ddpfPixelFormat.x.dwRGBBitCount / 8;
939 h=rsrc->bottom-rsrc->top;
940 if (h>ddesc.dwHeight-dsty) h=ddesc.dwHeight-dsty;
941 if (h>sdesc.dwHeight-rsrc->top) h=sdesc.dwHeight-rsrc->top;
942 if (h<0) h=0;
943 w=rsrc->right-rsrc->left;
944 if (w>ddesc.dwWidth-dstx) w=ddesc.dwWidth-dstx;
945 if (w>sdesc.dwWidth-rsrc->left) w=sdesc.dwWidth-rsrc->left;
946 if (w<0) w=0;
947
948 for (i=0;i<h;i++) {
949 memcpy( ddesc.y.lpSurface+(dsty +i)*ddesc.lPitch+dstx*bpp,
950 sdesc.y.lpSurface+(rsrc->top+i)*sdesc.lPitch+rsrc->left*bpp,
951 w*bpp
952 );
953 }
954 this->lpvtbl->fnUnlock(this,ddesc.y.lpSurface);
955 src ->lpvtbl->fnUnlock(src,sdesc.y.lpSurface);
956 return DD_OK;
957 }
958
959 static HRESULT WINAPI IDirectDrawSurface4_BltBatch(
960 LPDIRECTDRAWSURFACE4 this,LPDDBLTBATCH ddbltbatch,DWORD x,DWORD y
961 ) {
962 FIXME(ddraw,"(%p)->BltBatch(%p,%08lx,%08lx),stub!\n",
963 this,ddbltbatch,x,y
964 );
965 return DD_OK;
966 }
967
968 static HRESULT WINAPI IDirectDrawSurface4_GetCaps(
969 LPDIRECTDRAWSURFACE4 this,LPDDSCAPS caps
970 ) {
971 TRACE(ddraw,"(%p)->GetCaps(%p)\n",this,caps);
972 caps->dwCaps = DDSCAPS_PALETTE; /* probably more */
973 return DD_OK;
974 }
975
976 static HRESULT WINAPI IDirectDrawSurface4_GetSurfaceDesc(
977 LPDIRECTDRAWSURFACE4 this,LPDDSURFACEDESC ddsd
978 ) {
979 TRACE(ddraw, "(%p)->GetSurfaceDesc(%p)\n",
980 this,ddsd);
981
982 /* Simply copy the surface description stored in the object */
983 *ddsd = this->s.surface_desc;
984
985 if (TRACE_ON(ddraw)) {
986 fprintf(stderr," flags: ");
987 _dump_DDSD(ddsd->dwFlags);
988 if (ddsd->dwFlags & DDSD_CAPS) {
989 fprintf(stderr, " caps: ");
990 _dump_DDSCAPS(ddsd->ddsCaps.dwCaps);
991 }
992 fprintf(stderr,"\n");
993 }
994
995 return DD_OK;
996 }
997
998 static ULONG WINAPI IDirectDrawSurface4_AddRef(LPDIRECTDRAWSURFACE4 this) {
999 TRACE( ddraw, "(%p)->() incrementing from %lu.\n", this, this->ref );
1000
1001 return ++(this->ref);
1002 }
1003
1004 static ULONG WINAPI DGA_IDirectDrawSurface4_Release(LPDIRECTDRAWSURFACE4 this) {
1005 TRACE( ddraw, "(%p)->() decrementing from %lu.\n", this, this->ref );
1006
1007 #ifdef HAVE_LIBXXF86DGA
1008 if (!--(this->ref)) {
1009 this->s.ddraw->lpvtbl->fnRelease(this->s.ddraw);
1010 /* clear out of surface list */
1011 if (this->t.dga.fb_height == -1) {
1012 HeapFree(GetProcessHeap(),0,this->s.surface_desc.y.lpSurface);
1013 } else {
1014 this->s.ddraw->e.dga.vpmask &= ~(1<<(this->t.dga.fb_height/this->s.ddraw->e.dga.fb_height));
1015 }
1016
1017 /* Free the backbuffer */
1018 if (this->s.backbuffer)
1019 this->s.backbuffer->lpvtbl->fnRelease(this->s.backbuffer);
1020
1021 HeapFree(GetProcessHeap(),0,this);
1022 return 0;
1023 }
1024 #endif /* defined(HAVE_LIBXXF86DGA) */
1025 return this->ref;
1026 }
1027
1028 static ULONG WINAPI Xlib_IDirectDrawSurface4_Release(LPDIRECTDRAWSURFACE4 this) {
1029 TRACE( ddraw, "(%p)->() decrementing from %lu.\n", this, this->ref );
1030
1031 if (!--(this->ref)) {
1032 this->s.ddraw->lpvtbl->fnRelease(this->s.ddraw);
1033
1034 if( this->s.backbuffer )
1035 this->s.backbuffer->lpvtbl->fnRelease(this->s.backbuffer);
1036
1037 if (this->t.xlib.image != NULL) {
1038 if (this->s.ddraw->d.depth != this->s.ddraw->d.screen_depth) {
1039 /* In pixel conversion mode, there are two buffers to release... */
1040 HeapFree(GetProcessHeap(),0,this->s.surface_desc.y.lpSurface);
1041
1042 #ifdef HAVE_LIBXXSHM
1043 if (this->s.ddraw->e.xlib.xshm_active) {
1044 TSXShmDetach(display, &(this->t.xlib.shminfo));
1045 TSXDestroyImage(this->t.xlib.image);
1046 shmdt(this->t.xlib.shminfo.shmaddr);
1047 } else {
1048 #endif
1049 HeapFree(GetProcessHeap(),0,this->t.xlib.image->data);
1050 this->t.xlib.image->data = NULL;
1051 TSXDestroyImage(this->t.xlib.image);
1052 #ifdef HAVE_LIBXXSHM
1053 }
1054 #endif
1055
1056 } else {
1057 this->t.xlib.image->data = NULL;
1058
1059 #ifdef HAVE_LIBXXSHM
1060 if (this->s.ddraw->e.xlib.xshm_active) {
1061 TSXShmDetach(display, &(this->t.xlib.shminfo));
1062 TSXDestroyImage(this->t.xlib.image);
1063 shmdt(this->t.xlib.shminfo.shmaddr);
1064 } else {
1065 #endif
1066 HeapFree(GetProcessHeap(),0,this->s.surface_desc.y.lpSurface);
1067 TSXDestroyImage(this->t.xlib.image);
1068 #ifdef HAVE_LIBXXSHM
1069 }
1070 #endif
1071 }
1072
1073 this->t.xlib.image = 0;
1074 } else {
1075 HeapFree(GetProcessHeap(),0,this->s.surface_desc.y.lpSurface);
1076 }
1077
1078 if (this->s.palette)
1079 this->s.palette->lpvtbl->fnRelease(this->s.palette);
1080
1081 HeapFree(GetProcessHeap(),0,this);
1082 return 0;
1083 }
1084
1085 return this->ref;
1086 }
1087
1088 static HRESULT WINAPI IDirectDrawSurface4_GetAttachedSurface(
1089 LPDIRECTDRAWSURFACE4 this,LPDDSCAPS lpddsd,LPDIRECTDRAWSURFACE4 *lpdsf
1090 ) {
1091 TRACE(ddraw, "(%p)->GetAttachedSurface(%p,%p)\n",
1092 this, lpddsd, lpdsf);
1093
1094 if (TRACE_ON(ddraw)) {
1095 TRACE(ddraw," caps ");
1096 _dump_DDSCAPS(lpddsd->dwCaps);
1097 }
1098
1099 if (!(lpddsd->dwCaps & DDSCAPS_BACKBUFFER)) {
1100 FIXME(ddraw,"whoops, can only handle backbuffers for now\n");
1101 return E_FAIL;
1102 }
1103
1104 /* FIXME: should handle more than one backbuffer */
1105 *lpdsf = this->s.backbuffer;
1106
1107 if( this->s.backbuffer )
1108 this->s.backbuffer->lpvtbl->fnAddRef( this->s.backbuffer );
1109
1110 return DD_OK;
1111 }
1112
1113 static HRESULT WINAPI IDirectDrawSurface4_Initialize(
1114 LPDIRECTDRAWSURFACE4 this,LPDIRECTDRAW ddraw,LPDDSURFACEDESC lpdsfd
1115 ) {
1116 TRACE(ddraw,"(%p)->(%p, %p)\n",this,ddraw,lpdsfd);
1117
1118 return DDERR_ALREADYINITIALIZED;
1119 }
1120
1121 static HRESULT WINAPI IDirectDrawSurface4_GetPixelFormat(
1122 LPDIRECTDRAWSURFACE4 this,LPDDPIXELFORMAT pf
1123 ) {
1124 TRACE(ddraw,"(%p)->(%p)\n",this,pf);
1125
1126 *pf = this->s.surface_desc.ddpfPixelFormat;
1127
1128 return DD_OK;
1129 }
1130
1131 static HRESULT WINAPI IDirectDrawSurface4_GetBltStatus(LPDIRECTDRAWSURFACE4 this,DWORD dwFlags) {
1132 FIXME(ddraw,"(%p)->(0x%08lx),stub!\n",this,dwFlags);
1133 return DD_OK;
1134 }
1135
1136 static HRESULT WINAPI IDirectDrawSurface4_GetOverlayPosition(
1137 LPDIRECTDRAWSURFACE4 this,LPLONG x1,LPLONG x2
1138 ) {
1139 FIXME(ddraw,"(%p)->(%p,%p),stub!\n",this,x1,x2);
1140 return DD_OK;
1141 }
1142
1143 static HRESULT WINAPI IDirectDrawSurface4_SetClipper(
1144 LPDIRECTDRAWSURFACE4 this,LPDIRECTDRAWCLIPPER clipper
1145 ) {
1146 FIXME(ddraw,"(%p)->(%p),stub!\n",this,clipper);
1147 return DD_OK;
1148 }
1149
1150 static HRESULT WINAPI IDirectDrawSurface4_AddAttachedSurface(
1151 LPDIRECTDRAWSURFACE4 this,LPDIRECTDRAWSURFACE4 surf
1152 ) {
1153 FIXME(ddraw,"(%p)->(%p),stub!\n",this,surf);
1154
1155 this->lpvtbl->fnAddRef(this);
1156
1157 /* This hack will be enough for the moment */
1158 if (this->s.backbuffer == NULL)
1159 this->s.backbuffer = surf;
1160 return DD_OK;
1161 }
1162
1163 static HRESULT WINAPI IDirectDrawSurface4_GetDC(LPDIRECTDRAWSURFACE4 this,HDC32* lphdc) {
1164 FIXME(ddraw,"(%p)->GetDC(%p)\n",this,lphdc);
1165 *lphdc = BeginPaint32(this->s.ddraw->d.window,&this->s.ddraw->d.ps);
1166 return DD_OK;
1167 }
1168
1169 static HRESULT WINAPI IDirectDrawSurface4_ReleaseDC(LPDIRECTDRAWSURFACE4 this,HDC32 hdc) {
1170 DDSURFACEDESC desc;
1171 DWORD x, y;
1172
1173 FIXME(ddraw,"(%p)->(0x%08lx),stub!\n",this,(long)hdc);
1174 EndPaint32(this->s.ddraw->d.window,&this->s.ddraw->d.ps);
1175
1176 /* Well, as what the application did paint in this DC is NOT saved in the surface,
1177 I fill it with 'dummy' values to have something on the screen */
1178 this->lpvtbl->fnLock(this,NULL,&desc,0,0);
1179 for (y = 0; y < desc.dwHeight; y++) {
1180 for (x = 0; x < desc.dwWidth; x++) {
1181 ((unsigned char *) desc.y.lpSurface)[x + y * desc.dwWidth] = (unsigned int) this + x + y;
1182 }
1183 }
1184 this->lpvtbl->fnUnlock(this,NULL);
1185
1186 return DD_OK;
1187 }
1188
1189
1190 static HRESULT WINAPI IDirectDrawSurface4_QueryInterface(LPDIRECTDRAWSURFACE4 this,REFIID refiid,LPVOID *obj) {
1191 char xrefiid[50];
1192
1193 WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
1194 TRACE(ddraw,"(%p)->(%s,%p)\n",this,xrefiid,obj);
1195
1196 /* All DirectDrawSurface versions (1, 2, 3 and 4) use
1197 * the same interface. And IUnknown does that too of course.
1198 */
1199 if ( !memcmp(&IID_IDirectDrawSurface4,refiid,sizeof(IID)) ||
1200 !memcmp(&IID_IDirectDrawSurface3,refiid,sizeof(IID)) ||
1201 !memcmp(&IID_IDirectDrawSurface2,refiid,sizeof(IID)) ||
1202 !memcmp(&IID_IDirectDrawSurface,refiid,sizeof(IID)) ||
1203 !memcmp(&IID_IUnknown,refiid,sizeof(IID))
1204 ) {
1205 *obj = this;
1206 this->lpvtbl->fnAddRef(this);
1207
1208 TRACE(ddraw, " Creating IDirectDrawSurface interface (%p)\n", *obj);
1209
1210 return S_OK;
1211 }
1212 else if (!memcmp(&IID_IDirect3DTexture2,refiid,sizeof(IID)))
1213 {
1214 /* Texture interface */
1215 *obj = d3dtexture2_create(this);
1216 this->lpvtbl->fnAddRef(this);
1217
1218 TRACE(ddraw, " Creating IDirect3DTexture2 interface (%p)\n", *obj);
1219
1220 return S_OK;
1221 }
1222 else if (!memcmp(&IID_IDirect3DTexture,refiid,sizeof(IID)))
1223 {
1224 /* Texture interface */
1225 *obj = d3dtexture_create(this);
1226 this->lpvtbl->fnAddRef(this);
1227
1228 TRACE(ddraw, " Creating IDirect3DTexture interface (%p)\n", *obj);
1229
1230 return S_OK;
1231 }
1232 else if (is_OpenGL_dx3(refiid, (LPDIRECTDRAWSURFACE) this, (LPDIRECT3DDEVICE *) obj))
1233 {
1234 /* It is the OpenGL Direct3D Device */
1235 this->lpvtbl->fnAddRef(this);
1236
1237 TRACE(ddraw, " Creating IDirect3DDevice interface (%p)\n", *obj);
1238
1239 return S_OK;
1240 }
1241
1242 FIXME(ddraw,"(%p):interface for IID %s NOT found!\n",this,xrefiid);
1243 return OLE_E_ENUM_NOMORE;
1244 }
1245
1246 static HRESULT WINAPI IDirectDrawSurface4_IsLost(LPDIRECTDRAWSURFACE4 this) {
1247 TRACE(ddraw,"(%p)->(), stub!\n",this);
1248 return DD_OK; /* hmm */
1249 }
1250
1251 static HRESULT WINAPI IDirectDrawSurface4_EnumAttachedSurfaces(LPDIRECTDRAWSURFACE4 this,LPVOID context,LPDDENUMSURFACESCALLBACK esfcb) {
1252 FIXME(ddraw,"(%p)->(%p,%p),stub!\n",this,context,esfcb);
1253 return DD_OK;
1254 }
1255
1256 static HRESULT WINAPI IDirectDrawSurface4_Restore(LPDIRECTDRAWSURFACE4 this) {
1257 FIXME(ddraw,"(%p)->(),stub!\n",this);
1258 return DD_OK;
1259 }
1260
1261 static HRESULT WINAPI IDirectDrawSurface4_SetColorKey(
1262 LPDIRECTDRAWSURFACE4 this, DWORD dwFlags, LPDDCOLORKEY ckey )
1263 {
1264 TRACE(ddraw,"(%p)->(0x%08lx,%p)\n",this,dwFlags,ckey);
1265
1266 if( dwFlags & DDCKEY_SRCBLT )
1267 {
1268 dwFlags &= ~DDCKEY_SRCBLT;
1269 this->s.surface_desc.dwFlags |= DDSD_CKSRCBLT;
1270 memcpy( &(this->s.surface_desc.ddckCKSrcBlt), ckey, sizeof( *ckey ) );
1271 }
1272
1273 if( dwFlags & DDCKEY_DESTBLT )
1274 {
1275 dwFlags &= ~DDCKEY_DESTBLT;
1276 this->s.surface_desc.dwFlags |= DDSD_CKDESTBLT;
1277 memcpy( &(this->s.surface_desc.ddckCKDestBlt), ckey, sizeof( *ckey ) );
1278 }
1279
1280 if( dwFlags & DDCKEY_SRCOVERLAY )
1281 {
1282 dwFlags &= ~DDCKEY_SRCOVERLAY;
1283 this->s.surface_desc.dwFlags |= DDSD_CKSRCOVERLAY;
1284 memcpy( &(this->s.surface_desc.ddckCKSrcOverlay), ckey, sizeof( *ckey ) );
1285 }
1286
1287 if( dwFlags & DDCKEY_DESTOVERLAY )
1288 {
1289 dwFlags &= ~DDCKEY_DESTOVERLAY;
1290 this->s.surface_desc.dwFlags |= DDSD_CKDESTOVERLAY;
1291 memcpy( &(this->s.surface_desc.ddckCKDestOverlay), ckey, sizeof( *ckey ) );
1292 }
1293
1294 if( dwFlags )
1295 {
1296 FIXME( ddraw, "unhandled dwFlags: 0x%08lx\n", dwFlags );
1297 }
1298
1299 return DD_OK;
1300
1301 }
1302
1303 static HRESULT WINAPI IDirectDrawSurface4_AddOverlayDirtyRect(
1304 LPDIRECTDRAWSURFACE4 this,
1305 LPRECT32 lpRect )
1306 {
1307 FIXME(ddraw,"(%p)->(%p),stub!\n",this,lpRect);
1308
1309 return DD_OK;
1310 }
1311
1312 static HRESULT WINAPI IDirectDrawSurface4_DeleteAttachedSurface(
1313 LPDIRECTDRAWSURFACE4 this,
1314 DWORD dwFlags,
1315 LPDIRECTDRAWSURFACE4 lpDDSAttachedSurface )
1316 {
1317 FIXME(ddraw,"(%p)->(0x%08lx,%p),stub!\n",this,dwFlags,lpDDSAttachedSurface);
1318
1319 return DD_OK;
1320 }
1321
1322 static HRESULT WINAPI IDirectDrawSurface4_EnumOverlayZOrders(
1323 LPDIRECTDRAWSURFACE4 this,
1324 DWORD dwFlags,
1325 LPVOID lpContext,
1326 LPDDENUMSURFACESCALLBACK lpfnCallback )
1327 {
1328 FIXME(ddraw,"(%p)->(0x%08lx,%p,%p),stub!\n", this,dwFlags,
1329 lpContext, lpfnCallback );
1330
1331 return DD_OK;
1332 }
1333
1334 static HRESULT WINAPI IDirectDrawSurface4_GetClipper(
1335 LPDIRECTDRAWSURFACE4 this,
1336 LPDIRECTDRAWCLIPPER* lplpDDClipper )
1337 {
1338 FIXME(ddraw,"(%p)->(%p),stub!\n", this, lplpDDClipper);
1339
1340 return DD_OK;
1341 }
1342
1343 static HRESULT WINAPI IDirectDrawSurface4_GetColorKey(
1344 LPDIRECTDRAWSURFACE4 this,
1345 DWORD dwFlags,
1346 LPDDCOLORKEY lpDDColorKey )
1347 {
1348 TRACE(ddraw,"(%p)->(0x%08lx,%p)\n", this, dwFlags, lpDDColorKey);
1349
1350 if( dwFlags & DDCKEY_SRCBLT ) {
1351 dwFlags &= ~DDCKEY_SRCBLT;
1352 memcpy( lpDDColorKey, &(this->s.surface_desc.ddckCKSrcBlt), sizeof( *lpDDColorKey ) );
1353 }
1354
1355 if( dwFlags & DDCKEY_DESTBLT )
1356 {
1357 dwFlags &= ~DDCKEY_DESTBLT;
1358 memcpy( lpDDColorKey, &(this->s.surface_desc.ddckCKDestBlt), sizeof( *lpDDColorKey ) );
1359 }
1360
1361 if( dwFlags & DDCKEY_SRCOVERLAY )
1362 {
1363 dwFlags &= ~DDCKEY_SRCOVERLAY;
1364 memcpy( lpDDColorKey, &(this->s.surface_desc.ddckCKSrcOverlay), sizeof( *lpDDColorKey ) );
1365 }
1366
1367 if( dwFlags & DDCKEY_DESTOVERLAY )
1368 {
1369 dwFlags &= ~DDCKEY_DESTOVERLAY;
1370 memcpy( lpDDColorKey, &(this->s.surface_desc.ddckCKDestOverlay), sizeof( *lpDDColorKey ) );
1371 }
1372
1373 if( dwFlags )
1374 {
1375 FIXME( ddraw, "unhandled dwFlags: 0x%08lx\n", dwFlags );
1376 }
1377
1378 return DD_OK;
1379 }
1380
1381 static HRESULT WINAPI IDirectDrawSurface4_GetFlipStatus(
1382 LPDIRECTDRAWSURFACE4 this,
1383 DWORD dwFlags )
1384 {
1385 FIXME(ddraw,"(%p)->(0x%08lx),stub!\n", this, dwFlags);
1386
1387 return DD_OK;
1388 }
1389
1390 static HRESULT WINAPI IDirectDrawSurface4_GetPalette(
1391 LPDIRECTDRAWSURFACE4 this,
1392 LPDIRECTDRAWPALETTE* lplpDDPalette )
1393 {
1394 FIXME(ddraw,"(%p)->(%p),stub!\n", this, lplpDDPalette);
1395
1396 return DD_OK;
1397 }
1398
1399 static HRESULT WINAPI IDirectDrawSurface4_SetOverlayPosition(
1400 LPDIRECTDRAWSURFACE4 this,
1401 LONG lX,
1402 LONG lY)
1403 {
1404 FIXME(ddraw,"(%p)->(%ld,%ld),stub!\n", this, lX, lY);
1405
1406 return DD_OK;
1407 }
1408
1409 static HRESULT WINAPI IDirectDrawSurface4_UpdateOverlay(
1410 LPDIRECTDRAWSURFACE4 this,
1411 LPRECT32 lpSrcRect,
1412 LPDIRECTDRAWSURFACE4 lpDDDestSurface,
1413 LPRECT32 lpDestRect,
1414 DWORD dwFlags,
1415 LPDDOVERLAYFX lpDDOverlayFx )
1416 {
1417 FIXME(ddraw,"(%p)->(%p,%p,%p,0x%08lx,%p),stub!\n", this,
1418 lpSrcRect, lpDDDestSurface, lpDestRect, dwFlags, lpDDOverlayFx );
1419
1420 return DD_OK;
1421 }
1422
1423 static HRESULT WINAPI IDirectDrawSurface4_UpdateOverlayDisplay(
1424 LPDIRECTDRAWSURFACE4 this,
1425 DWORD dwFlags )
1426 {
1427 FIXME(ddraw,"(%p)->(0x%08lx),stub!\n", this, dwFlags);
1428
1429 return DD_OK;
1430 }
1431
1432 static HRESULT WINAPI IDirectDrawSurface4_UpdateOverlayZOrder(
1433 LPDIRECTDRAWSURFACE4 this,
1434 DWORD dwFlags,
1435 LPDIRECTDRAWSURFACE4 lpDDSReference )
1436 {
1437 FIXME(ddraw,"(%p)->(0x%08lx,%p),stub!\n", this, dwFlags, lpDDSReference);
1438
1439 return DD_OK;
1440 }
1441
1442 static HRESULT WINAPI IDirectDrawSurface4_GetDDInterface(
1443 LPDIRECTDRAWSURFACE4 this,
1444 LPVOID* lplpDD )
1445 {
1446 FIXME(ddraw,"(%p)->(%p),stub!\n", this, lplpDD);
1447
1448 /* Not sure about that... */
1449 *lplpDD = (void *) this->s.ddraw;
1450
1451 return DD_OK;
1452 }
1453
1454 static HRESULT WINAPI IDirectDrawSurface4_PageLock(
1455 LPDIRECTDRAWSURFACE4 this,
1456 DWORD dwFlags )
1457 {
1458 FIXME(ddraw,"(%p)->(0x%08lx),stub!\n", this, dwFlags);
1459
1460 return DD_OK;
1461 }
1462
1463 static HRESULT WINAPI IDirectDrawSurface4_PageUnlock(
1464 LPDIRECTDRAWSURFACE4 this,
1465 DWORD dwFlags )
1466 {
1467 FIXME(ddraw,"(%p)->(0x%08lx),stub!\n", this, dwFlags);
1468
1469 return DD_OK;
1470 }
1471
1472 static HRESULT WINAPI IDirectDrawSurface4_SetSurfaceDesc(
1473 LPDIRECTDRAWSURFACE4 this,
1474 LPDDSURFACEDESC lpDDSD,
1475 DWORD dwFlags )
1476 {
1477 FIXME(ddraw,"(%p)->(%p,0x%08lx),stub!\n", this, lpDDSD, dwFlags);
1478
1479 return DD_OK;
1480 }
1481
1482 static HRESULT WINAPI IDirectDrawSurface4_SetPrivateData(LPDIRECTDRAWSURFACE4 this,
1483 REFGUID guidTag,
1484 LPVOID lpData,
1485 DWORD cbSize,
1486 DWORD dwFlags) {
1487 FIXME(ddraw, "(%p)->(%p,%p,%ld,%08lx\n", this, guidTag, lpData, cbSize, dwFlags);
1488
1489 return DD_OK;
1490 }
1491
1492 static HRESULT WINAPI IDirectDrawSurface4_GetPrivateData(LPDIRECTDRAWSURFACE4 this,
1493 REFGUID guidTag,
1494 LPVOID lpBuffer,
1495 LPDWORD lpcbBufferSize) {
1496 FIXME(ddraw, "(%p)->(%p,%p,%p)\n", this, guidTag, lpBuffer, lpcbBufferSize);
1497
1498 return DD_OK;
1499 }
1500
1501 static HRESULT WINAPI IDirectDrawSurface4_FreePrivateData(LPDIRECTDRAWSURFACE4 this,
1502 REFGUID guidTag) {
1503 FIXME(ddraw, "(%p)->(%p)\n", this, guidTag);
1504
1505 return DD_OK;
1506 }
1507
1508 static HRESULT WINAPI IDirectDrawSurface4_GetUniquenessValue(LPDIRECTDRAWSURFACE4 this,
1509 LPDWORD lpValue) {
1510 FIXME(ddraw, "(%p)->(%p)\n", this, lpValue);
1511
1512 return DD_OK;
1513 }
1514
1515 static HRESULT WINAPI IDirectDrawSurface4_ChangeUniquenessValue(LPDIRECTDRAWSURFACE4 this) {
1516 FIXME(ddraw, "(%p)\n", this);
1517
1518 return DD_OK;
1519 }
1520
1521 static struct IDirectDrawSurface4_VTable dga_dds4vt = {
1522 IDirectDrawSurface4_QueryInterface,
1523 IDirectDrawSurface4_AddRef,
1524 DGA_IDirectDrawSurface4_Release,
1525 IDirectDrawSurface4_AddAttachedSurface,
1526 IDirectDrawSurface4_AddOverlayDirtyRect,
1527 IDirectDrawSurface4_Blt,
1528 IDirectDrawSurface4_BltBatch,
1529 IDirectDrawSurface4_BltFast,
1530 IDirectDrawSurface4_DeleteAttachedSurface,
1531 IDirectDrawSurface4_EnumAttachedSurfaces,
1532 IDirectDrawSurface4_EnumOverlayZOrders,
1533 DGA_IDirectDrawSurface4_Flip,
1534 IDirectDrawSurface4_GetAttachedSurface,
1535 IDirectDrawSurface4_GetBltStatus,
1536 IDirectDrawSurface4_GetCaps,
1537 IDirectDrawSurface4_GetClipper,
1538 IDirectDrawSurface4_GetColorKey,
1539 IDirectDrawSurface4_GetDC,
1540 IDirectDrawSurface4_GetFlipStatus,
1541 IDirectDrawSurface4_GetOverlayPosition,
1542 IDirectDrawSurface4_GetPalette,
1543 IDirectDrawSurface4_GetPixelFormat,
1544 IDirectDrawSurface4_GetSurfaceDesc,
1545 IDirectDrawSurface4_Initialize,
1546 IDirectDrawSurface4_IsLost,
1547 IDirectDrawSurface4_Lock,
1548 IDirectDrawSurface4_ReleaseDC,
1549 IDirectDrawSurface4_Restore,
1550 IDirectDrawSurface4_SetClipper,
1551 IDirectDrawSurface4_SetColorKey,
1552 IDirectDrawSurface4_SetOverlayPosition,
1553 DGA_IDirectDrawSurface4_SetPalette,
1554 DGA_IDirectDrawSurface4_Unlock,
1555 IDirectDrawSurface4_UpdateOverlay,
1556 IDirectDrawSurface4_UpdateOverlayDisplay,
1557 IDirectDrawSurface4_UpdateOverlayZOrder,
1558 IDirectDrawSurface4_GetDDInterface,
1559 IDirectDrawSurface4_PageLock,
1560 IDirectDrawSurface4_PageUnlock,
1561 IDirectDrawSurface4_SetSurfaceDesc,
1562 IDirectDrawSurface4_SetPrivateData,
1563 IDirectDrawSurface4_GetPrivateData,
1564 IDirectDrawSurface4_FreePrivateData,
1565 IDirectDrawSurface4_GetUniquenessValue,
1566 IDirectDrawSurface4_ChangeUniquenessValue
1567 };
1568
1569 static struct IDirectDrawSurface4_VTable xlib_dds4vt = {
1570 IDirectDrawSurface4_QueryInterface,
1571 IDirectDrawSurface4_AddRef,
1572 Xlib_IDirectDrawSurface4_Release,
1573 IDirectDrawSurface4_AddAttachedSurface,
1574 IDirectDrawSurface4_AddOverlayDirtyRect,
1575 IDirectDrawSurface4_Blt,
1576 IDirectDrawSurface4_BltBatch,
1577 IDirectDrawSurface4_BltFast,
1578 IDirectDrawSurface4_DeleteAttachedSurface,
1579 IDirectDrawSurface4_EnumAttachedSurfaces,
1580 IDirectDrawSurface4_EnumOverlayZOrders,
1581 Xlib_IDirectDrawSurface4_Flip,
1582 IDirectDrawSurface4_GetAttachedSurface,
1583 IDirectDrawSurface4_GetBltStatus,
1584 IDirectDrawSurface4_GetCaps,
1585 IDirectDrawSurface4_GetClipper,
1586 IDirectDrawSurface4_GetColorKey,
1587 IDirectDrawSurface4_GetDC,
1588 IDirectDrawSurface4_GetFlipStatus,
1589 IDirectDrawSurface4_GetOverlayPosition,
1590 IDirectDrawSurface4_GetPalette,
1591 IDirectDrawSurface4_GetPixelFormat,
1592 IDirectDrawSurface4_GetSurfaceDesc,
1593 IDirectDrawSurface4_Initialize,
1594 IDirectDrawSurface4_IsLost,
1595 IDirectDrawSurface4_Lock,
1596 IDirectDrawSurface4_ReleaseDC,
1597 IDirectDrawSurface4_Restore,
1598 IDirectDrawSurface4_SetClipper,
1599 IDirectDrawSurface4_SetColorKey,
1600 IDirectDrawSurface4_SetOverlayPosition,
1601 Xlib_IDirectDrawSurface4_SetPalette,
1602 Xlib_IDirectDrawSurface4_Unlock,
1603 IDirectDrawSurface4_UpdateOverlay,
1604 IDirectDrawSurface4_UpdateOverlayDisplay,
1605 IDirectDrawSurface4_UpdateOverlayZOrder,
1606 IDirectDrawSurface4_GetDDInterface,
1607 IDirectDrawSurface4_PageLock,
1608 IDirectDrawSurface4_PageUnlock,
1609 IDirectDrawSurface4_SetSurfaceDesc,
1610 IDirectDrawSurface4_SetPrivateData,
1611 IDirectDrawSurface4_GetPrivateData,
1612 IDirectDrawSurface4_FreePrivateData,
1613 IDirectDrawSurface4_GetUniquenessValue,
1614 IDirectDrawSurface4_ChangeUniquenessValue
1615 };
1616
1617 /******************************************************************************
1618 * DirectDrawCreateClipper (DDRAW.7)
1619 */
1620 HRESULT WINAPI DirectDrawCreateClipper( DWORD dwFlags,
1621 LPDIRECTDRAWCLIPPER *lplpDDClipper,
1622 LPUNKNOWN pUnkOuter)
1623 {
1624 TRACE(ddraw, "(%08lx,%p,%p)\n", dwFlags, lplpDDClipper, pUnkOuter);
1625
1626 *lplpDDClipper = (LPDIRECTDRAWCLIPPER)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawClipper));
1627 (*lplpDDClipper)->lpvtbl = &ddclipvt;
1628 (*lplpDDClipper)->ref = 1;
1629
1630 return DD_OK;
1631 }
1632
1633 /******************************************************************************
1634 * IDirectDrawClipper
1635 */
1636 static HRESULT WINAPI IDirectDrawClipper_SetHwnd(
1637 LPDIRECTDRAWCLIPPER this,DWORD x,HWND32 hwnd
1638 ) {
1639 FIXME(ddraw,"(%p)->SetHwnd(0x%08lx,0x%08lx),stub!\n",this,x,(DWORD)hwnd);
1640 return DD_OK;
1641 }
1642
1643 static ULONG WINAPI IDirectDrawClipper_Release(LPDIRECTDRAWCLIPPER this) {
1644 TRACE( ddraw, "(%p)->() decrementing from %lu.\n", this, this->ref );
1645
1646 this->ref--;
1647 if (this->ref)
1648 return this->ref;
1649 HeapFree(GetProcessHeap(),0,this);
1650 return 0;
1651 }
1652
1653 static HRESULT WINAPI IDirectDrawClipper_GetClipList(
1654 LPDIRECTDRAWCLIPPER this,LPRECT32 rects,LPRGNDATA lprgn,LPDWORD hmm
1655 ) {
1656 FIXME(ddraw,"(%p,%p,%p,%p),stub!\n",this,rects,lprgn,hmm);
1657 if (hmm) *hmm=0;
1658 return DD_OK;
1659 }
1660
1661 static HRESULT WINAPI IDirectDrawClipper_SetClipList(
1662 LPDIRECTDRAWCLIPPER this,LPRGNDATA lprgn,DWORD hmm
1663 ) {
1664 FIXME(ddraw,"(%p,%p,%ld),stub!\n",this,lprgn,hmm);
1665 return DD_OK;
1666 }
1667
1668 static HRESULT WINAPI IDirectDrawClipper_QueryInterface(
1669 LPDIRECTDRAWCLIPPER this,
1670 REFIID riid,
1671 LPVOID* ppvObj )
1672 {
1673 FIXME(ddraw,"(%p)->(%p,%p),stub!\n",this,riid,ppvObj);
1674 return OLE_E_ENUM_NOMORE;
1675 }
1676
1677 static ULONG WINAPI IDirectDrawClipper_AddRef( LPDIRECTDRAWCLIPPER this )
1678 {
1679 TRACE( ddraw, "(%p)->() incrementing from %lu.\n", this, this->ref );
1680 return ++(this->ref);
1681 }
1682
1683 static HRESULT WINAPI IDirectDrawClipper_GetHWnd(
1684 LPDIRECTDRAWCLIPPER this,
1685 HWND32* HWndPtr )
1686 {
1687 FIXME(ddraw,"(%p)->(%p),stub!\n",this,HWndPtr);
1688 return DD_OK;
1689 }
1690
1691 static HRESULT WINAPI IDirectDrawClipper_Initialize(
1692 LPDIRECTDRAWCLIPPER this,
1693 LPDIRECTDRAW lpDD,
1694 DWORD dwFlags )
1695 {
1696 FIXME(ddraw,"(%p)->(%p,0x%08lx),stub!\n",this,lpDD,dwFlags);
1697 return DD_OK;
1698 }
1699
1700 static HRESULT WINAPI IDirectDrawClipper_IsClipListChanged(
1701 LPDIRECTDRAWCLIPPER this,
1702 BOOL32* lpbChanged )
1703 {
1704 FIXME(ddraw,"(%p)->(%p),stub!\n",this,lpbChanged);
1705 return DD_OK;
1706 }
1707
1708 static struct IDirectDrawClipper_VTable ddclipvt = {
1709 IDirectDrawClipper_QueryInterface,
1710 IDirectDrawClipper_AddRef,
1711 IDirectDrawClipper_Release,
1712 IDirectDrawClipper_GetClipList,
1713 IDirectDrawClipper_GetHWnd,
1714 IDirectDrawClipper_Initialize,
1715 IDirectDrawClipper_IsClipListChanged,
1716 IDirectDrawClipper_SetClipList,
1717 IDirectDrawClipper_SetHwnd
1718 };
1719
1720
1721 /******************************************************************************
1722 * IDirectDrawPalette
1723 */
1724 static HRESULT WINAPI IDirectDrawPalette_GetEntries(
1725 LPDIRECTDRAWPALETTE this,DWORD x,DWORD start,DWORD count,LPPALETTEENTRY palent
1726 ) {
1727 int i;
1728
1729 TRACE(ddraw,"(%p)->GetEntries(%08lx,%ld,%ld,%p)\n",
1730 this,x,start,count,palent);
1731
1732 if (!this->cm) /* should not happen */ {
1733 FIXME(ddraw,"app tried to read colormap for non-palettized mode\n");
1734 return DDERR_GENERIC;
1735 }
1736 for (i=0;i<count;i++) {
1737 palent[i].peRed = this->palents[start+i].peRed;
1738 palent[i].peBlue = this->palents[start+i].peBlue;
1739 palent[i].peGreen = this->palents[start+i].peGreen;
1740 palent[i].peFlags = this->palents[start+i].peFlags;
1741
1742 }
1743 return DD_OK;
1744 }
1745
1746 static HRESULT WINAPI Xlib_IDirectDrawPalette_SetEntries(
1747 LPDIRECTDRAWPALETTE this,DWORD x,DWORD start,DWORD count,LPPALETTEENTRY palent
1748 ) {
1749 XColor xc;
1750 int i;
1751
1752 TRACE(ddraw,"(%p)->SetEntries(%08lx,%ld,%ld,%p)\n",
1753 this,x,start,count,palent
1754 );
1755 for (i=0;i<count;i++) {
1756 xc.red = palent[i].peRed<<8;
1757 xc.blue = palent[i].peBlue<<8;
1758 xc.green = palent[i].peGreen<<8;
1759 xc.flags = DoRed|DoBlue|DoGreen;
1760 xc.pixel = start+i;
1761
1762 if (this->cm)
1763 TSXStoreColor(display,this->cm,&xc);
1764
1765 this->palents[start+i].peRed = palent[i].peRed;
1766 this->palents[start+i].peBlue = palent[i].peBlue;
1767 this->palents[start+i].peGreen = palent[i].peGreen;
1768 this->palents[start+i].peFlags = palent[i].peFlags;
1769 }
1770
1771 /* Now, if we are in 'depth conversion mode', update the screen palette */
1772 if (this->ddraw->d.depth != this->ddraw->d.screen_depth) {
1773 int i;
1774
1775 switch (this->ddraw->d.screen_depth) {
1776 case 16: {
1777 unsigned short *screen_palette = (unsigned short *) this->screen_palents;
1778
1779 for (i = 0; i < count; i++) {
1780 screen_palette[start + i] = (((((unsigned short) palent[i].peRed) & 0xF8) << 8) |
1781 ((((unsigned short) palent[i].peBlue) & 0xF8) >> 3) |
1782 ((((unsigned short) palent[i].peGreen) & 0xFC) << 3));
1783 }
1784 } break;
1785
1786 default:
1787 ERR(ddraw, "Memory corruption !\n");
1788 break;
1789 }
1790 }
1791
1792 if (!this->cm) /* should not happen */ {
1793 }
1794 return DD_OK;
1795 }
1796
1797 static HRESULT WINAPI DGA_IDirectDrawPalette_SetEntries(
1798 LPDIRECTDRAWPALETTE this,DWORD x,DWORD start,DWORD count,LPPALETTEENTRY palent
1799 ) {
1800 #ifdef HAVE_LIBXXF86DGA
1801 XColor xc;
1802 Colormap cm;
1803 int i;
1804
1805 TRACE(ddraw,"(%p)->SetEntries(%08lx,%ld,%ld,%p)\n",
1806 this,x,start,count,palent
1807 );
1808 if (!this->cm) /* should not happen */ {
1809 FIXME(ddraw,"app tried to set colormap in non-palettized mode\n");
1810 return DDERR_GENERIC;
1811 }
1812 /* FIXME: free colorcells instead of freeing whole map */
1813 cm = this->cm;
1814 this->cm = TSXCopyColormapAndFree(display,this->cm);
1815 TSXFreeColormap(display,cm);
1816
1817 for (i=0;i<count;i++) {
1818 xc.red = palent[i].peRed<<8;
1819 xc.blue = palent[i].peBlue<<8;
1820 xc.green = palent[i].peGreen<<8;
1821 xc.flags = DoRed|DoBlue|DoGreen;
1822 xc.pixel = i+start;
1823
1824 TSXStoreColor(display,this->cm,&xc);
1825
1826 this->palents[start+i].peRed = palent[i].peRed;
1827 this->palents[start+i].peBlue = palent[i].peBlue;
1828 this->palents[start+i].peGreen = palent[i].peGreen;
1829 this->palents[start+i].peFlags = palent[i].peFlags;
1830 }
1831 TSXF86DGAInstallColormap(display,DefaultScreen(display),this->cm);
1832 return DD_OK;
1833 #else /* defined(HAVE_LIBXXF86DGA) */
1834 return E_UNEXPECTED;
1835 #endif /* defined(HAVE_LIBXXF86DGA) */
1836 }
1837
1838 static ULONG WINAPI IDirectDrawPalette_Release(LPDIRECTDRAWPALETTE this) {
1839 TRACE( ddraw, "(%p)->() decrementing from %lu.\n", this, this->ref );
1840 if (!--(this->ref)) {
1841 if (this->cm) {
1842 TSXFreeColormap(display,this->cm);
1843 this->cm = 0;
1844 }
1845 HeapFree(GetProcessHeap(),0,this);
1846 return 0;
1847 }
1848 return this->ref;
1849 }
1850
1851 static ULONG WINAPI IDirectDrawPalette_AddRef(LPDIRECTDRAWPALETTE this) {
1852
1853 TRACE( ddraw, "(%p)->() incrementing from %lu.\n", this, this->ref );
1854 return ++(this->ref);
1855 }
1856
1857 static HRESULT WINAPI IDirectDrawPalette_Initialize(
1858 LPDIRECTDRAWPALETTE this,LPDIRECTDRAW ddraw,DWORD x,LPPALETTEENTRY palent
1859 ) {
1860 TRACE(ddraw,"(%p)->(%p,%ld,%p)\n", this, ddraw, x, palent);
1861
1862 return DDERR_ALREADYINITIALIZED;
1863 }
1864
1865 static HRESULT WINAPI IDirectDrawPalette_GetCaps(
1866 LPDIRECTDRAWPALETTE this, LPDWORD lpdwCaps )
1867 {
1868 FIXME( ddraw, "(%p)->(%p) stub.\n", this, lpdwCaps );
1869 return DD_OK;
1870 }
1871
1872 static HRESULT WINAPI IDirectDrawPalette_QueryInterface(
1873 LPDIRECTDRAWPALETTE this,REFIID refiid,LPVOID *obj )
1874 {
1875 char xrefiid[50];
1876
1877 WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
1878 FIXME(ddraw,"(%p)->(%s,%p) stub.\n",this,xrefiid,obj);
1879
1880 return S_OK;
1881 }
1882
1883 static struct IDirectDrawPalette_VTable dga_ddpalvt = {
1884 IDirectDrawPalette_QueryInterface,
1885 IDirectDrawPalette_AddRef,
1886 IDirectDrawPalette_Release,
1887 IDirectDrawPalette_GetCaps,
1888 IDirectDrawPalette_GetEntries,
1889 IDirectDrawPalette_Initialize,
1890 DGA_IDirectDrawPalette_SetEntries
1891 };
1892
1893 static struct IDirectDrawPalette_VTable xlib_ddpalvt = {
1894 IDirectDrawPalette_QueryInterface,
1895 IDirectDrawPalette_AddRef,
1896 IDirectDrawPalette_Release,
1897 IDirectDrawPalette_GetCaps,
1898 IDirectDrawPalette_GetEntries,
1899 IDirectDrawPalette_Initialize,
1900 Xlib_IDirectDrawPalette_SetEntries
1901 };
1902
1903 /*******************************************************************************
1904 * IDirect3D
1905 */
1906 static HRESULT WINAPI IDirect3D_QueryInterface(
1907 LPDIRECT3D this,REFIID refiid,LPVOID *obj
1908 ) {
1909 /* FIXME: Not sure if this is correct */
1910 char xrefiid[50];
1911
1912 WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
1913 TRACE(ddraw,"(%p)->(%s,%p)\n",this,xrefiid,obj);
1914 if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
1915 *obj = this;
1916 this->lpvtbl->fnAddRef(this);
1917
1918 TRACE(ddraw, " Creating IUnknown interface (%p)\n", *obj);
1919
1920 return S_OK;
1921 }
1922 if (!memcmp(&IID_IDirect3D,refiid,sizeof(IID_IDirect3D))) {
1923 LPDIRECT3D d3d;
1924
1925 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
1926 d3d->ref = 1;
1927 d3d->ddraw = (LPDIRECTDRAW)this;
1928 this->lpvtbl->fnAddRef(this);
1929 d3d->lpvtbl = &d3dvt;
1930 *obj = d3d;
1931
1932 TRACE(ddraw, " Creating IDirect3D interface (%p)\n", *obj);
1933
1934 return S_OK;
1935 }
1936 if (!memcmp(&IID_IDirect3D2,refiid,sizeof(IID_IDirect3D2))) {
1937 LPDIRECT3D2 d3d;
1938
1939 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
1940 d3d->ref = 1;
1941 d3d->ddraw = (LPDIRECTDRAW)this;
1942 this->lpvtbl->fnAddRef(this);
1943 d3d->lpvtbl = &d3d2vt;
1944 *obj = d3d;
1945
1946 TRACE(ddraw, " Creating IDirect3D2 interface (%p)\n", *obj);
1947
1948 return S_OK;
1949 }
1950 FIXME(ddraw,"(%p):interface for IID %s NOT found!\n",this,xrefiid);
1951 return OLE_E_ENUM_NOMORE;
1952 }
1953
1954 static ULONG WINAPI IDirect3D_AddRef(LPDIRECT3D this) {
1955 TRACE( ddraw, "(%p)->() incrementing from %lu.\n", this, this->ref );
1956
1957 return ++(this->ref);
1958 }
1959
1960 static ULONG WINAPI IDirect3D_Release(LPDIRECT3D this)
1961 {
1962 TRACE( ddraw, "(%p)->() decrementing from %lu.\n", this, this->ref );
1963
1964 if (!--(this->ref)) {
1965 this->ddraw->lpvtbl->fnRelease(this->ddraw);
1966 HeapFree(GetProcessHeap(),0,this);
1967 return 0;
1968 }
1969 return this->ref;
1970 }
1971
1972 static HRESULT WINAPI IDirect3D_Initialize(
1973 LPDIRECT3D this, REFIID refiid )
1974 {
1975 /* FIXME: Not sure if this is correct */
1976 char xrefiid[50];
1977
1978 WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
1979 FIXME(ddraw,"(%p)->(%s):stub.\n",this,xrefiid);
1980
1981 return DDERR_ALREADYINITIALIZED;
1982 }
1983
1984 static HRESULT WINAPI IDirect3D_EnumDevices(LPDIRECT3D this,
1985 LPD3DENUMDEVICESCALLBACK cb,
1986 LPVOID context) {
1987 FIXME(ddraw,"(%p)->(%p,%p),stub!\n",this,cb,context);
1988
1989 /* Call functions defined in d3ddevices.c */
1990 if (d3d_OpenGL_dx3(cb, context))
1991 return DD_OK;
1992
1993 return DD_OK;
1994 }
1995
1996 static HRESULT WINAPI IDirect3D_CreateLight(LPDIRECT3D this,
1997 LPDIRECT3DLIGHT *lplight,
1998 IUnknown *lpunk)
1999 {
2000 TRACE(ddraw, "(%p)->(%p,%p): stub\n", this, lplight, lpunk);
2001
2002 /* Call the creation function that is located in d3dlight.c */
2003 *lplight = d3dlight_create_dx3(this);
2004
2005 return DD_OK;
2006 }
2007
2008 static HRESULT WINAPI IDirect3D_CreateMaterial(LPDIRECT3D this,
2009 LPDIRECT3DMATERIAL *lpmaterial,
2010 IUnknown *lpunk)
2011 {
2012 TRACE(ddraw, "(%p)->(%p,%p): stub\n", this, lpmaterial, lpunk);
2013
2014 /* Call the creation function that is located in d3dviewport.c */
2015 *lpmaterial = d3dmaterial_create(this);
2016
2017 return DD_OK;
2018 }
2019
2020 static HRESULT WINAPI IDirect3D_CreateViewport(LPDIRECT3D this,
2021 LPDIRECT3DVIEWPORT *lpviewport,
2022 IUnknown *lpunk)
2023 {
2024 TRACE(ddraw, "(%p)->(%p,%p): stub\n", this, lpviewport, lpunk);
2025
2026 /* Call the creation function that is located in d3dviewport.c */
2027 *lpviewport = d3dviewport_create(this);
2028
2029 return DD_OK;
2030 }
2031
2032 static HRESULT WINAPI IDirect3D_FindDevice(LPDIRECT3D this,
2033 LPD3DFINDDEVICESEARCH lpfinddevsrc,
2034 LPD3DFINDDEVICERESULT lpfinddevrst)
2035 {
2036 TRACE(ddraw, "(%p)->(%p,%p): stub\n", this, lpfinddevsrc, lpfinddevrst);
2037
2038 return DD_OK;
2039 }
2040
2041 static struct IDirect3D_VTable d3dvt = {
2042 IDirect3D_QueryInterface,
2043 IDirect3D_AddRef,
2044 IDirect3D_Release,
2045 IDirect3D_Initialize,
2046 IDirect3D_EnumDevices,
2047 IDirect3D_CreateLight,
2048 IDirect3D_CreateMaterial,
2049 IDirect3D_CreateViewport,
2050 IDirect3D_FindDevice
2051 };
2052
2053 /*******************************************************************************
2054 * IDirect3D2
2055 */
2056 static HRESULT WINAPI IDirect3D2_QueryInterface(
2057 LPDIRECT3D2 this,REFIID refiid,LPVOID *obj) {
2058 /* For the moment, we use the same function as in IDirect3D */
2059 TRACE(ddraw, "Calling IDirect3D enumerating function.\n");
2060
2061 return IDirect3D_QueryInterface((LPDIRECT3D) this, refiid, obj);
2062 }
2063
2064 static ULONG WINAPI IDirect3D2_AddRef(LPDIRECT3D2 this) {
2065 TRACE( ddraw, "(%p)->() incrementing from %lu.\n", this, this->ref );
2066
2067 return ++(this->ref);
2068 }
2069
2070 static ULONG WINAPI IDirect3D2_Release(LPDIRECT3D2 this) {
2071 TRACE( ddraw, "(%p)->() decrementing from %lu.\n", this, this->ref );
2072
2073 if (!--(this->ref)) {
2074 this->ddraw->lpvtbl->fnRelease(this->ddraw);
2075 HeapFree(GetProcessHeap(),0,this);
2076 return 0;
2077 }
2078 return this->ref;
2079 }
2080
2081 static HRESULT WINAPI IDirect3D2_EnumDevices(
2082 LPDIRECT3D2 this,LPD3DENUMDEVICESCALLBACK cb, LPVOID context
2083 ) {
2084 FIXME(ddraw,"(%p)->(%p,%p),stub!\n",this,cb,context);
2085
2086 /* Call functions defined in d3ddevices.c */
2087 if (d3d_OpenGL(cb, context))
2088 return DD_OK;
2089
2090 return DD_OK;
2091 }
2092
2093 static HRESULT WINAPI IDirect3D2_CreateLight(LPDIRECT3D2 this,
2094 LPDIRECT3DLIGHT *lplight,
2095 IUnknown *lpunk)
2096 {
2097 TRACE(ddraw, "(%p)->(%p,%p): stub\n", this, lplight, lpunk);
2098
2099 /* Call the creation function that is located in d3dlight.c */
2100 *lplight = d3dlight_create(this);
2101
2102 return DD_OK;
2103 }
2104
2105 static HRESULT WINAPI IDirect3D2_CreateMaterial(LPDIRECT3D2 this,
2106 LPDIRECT3DMATERIAL2 *lpmaterial,
2107 IUnknown *lpunk)
2108 {
2109 TRACE(ddraw, "(%p)->(%p,%p): stub\n", this, lpmaterial, lpunk);
2110
2111 /* Call the creation function that is located in d3dviewport.c */
2112 *lpmaterial = d3dmaterial2_create(this);
2113
2114 return DD_OK;
2115 }
2116
2117 static HRESULT WINAPI IDirect3D2_CreateViewport(LPDIRECT3D2 this,
2118 LPDIRECT3DVIEWPORT2 *lpviewport,
2119 IUnknown *lpunk)
2120 {
2121 TRACE(ddraw, "(%p)->(%p,%p): stub\n", this, lpviewport, lpunk);
2122
2123 /* Call the creation function that is located in d3dviewport.c */
2124 *lpviewport = d3dviewport2_create(this);
2125
2126 return DD_OK;
2127 }
2128
2129 static HRESULT WINAPI IDirect3D2_FindDevice(LPDIRECT3D2 this,
2130 LPD3DFINDDEVICESEARCH lpfinddevsrc,
2131 LPD3DFINDDEVICERESULT lpfinddevrst)
2132 {
2133 TRACE(ddraw, "(%p)->(%p,%p): stub\n", this, lpfinddevsrc, lpfinddevrst);
2134
2135 return DD_OK;
2136 }
2137
2138 static HRESULT WINAPI IDirect3D2_CreateDevice(LPDIRECT3D2 this,
2139 REFCLSID rguid,
2140 LPDIRECTDRAWSURFACE surface,
2141 LPDIRECT3DDEVICE2 *device)
2142 {
2143 char xbuf[50];
2144
2145 WINE_StringFromCLSID(rguid,xbuf);
2146 FIXME(ddraw,"(%p)->(%s,%p,%p): stub\n",this,xbuf,surface,device);
2147
2148 if (is_OpenGL(rguid, surface, device, this)) {
2149 this->lpvtbl->fnAddRef(this);
2150 return DD_OK;
2151 }
2152
2153 return DDERR_INVALIDPARAMS;
2154 }
2155
2156 static struct IDirect3D2_VTable d3d2vt = {
2157 IDirect3D2_QueryInterface,
2158 IDirect3D2_AddRef,
2159 IDirect3D2_Release,
2160 IDirect3D2_EnumDevices,
2161 IDirect3D2_CreateLight,
2162 IDirect3D2_CreateMaterial,
2163 IDirect3D2_CreateViewport,
2164 IDirect3D2_FindDevice,
2165 IDirect3D2_CreateDevice
2166 };
2167
2168 /*******************************************************************************
2169 * IDirectDraw
2170 */
2171
2172 /* Used in conjunction with cbWndExtra for storage of the this ptr for the window.
2173 * Please adjust allocation in Xlib_DirectDrawCreate if you store more data here.
2174 */
2175 static INT32 ddrawXlibThisOffset = 0;
2176
2177 static HRESULT common_off_screen_CreateSurface(LPDIRECTDRAW2 this,
2178 LPDDSURFACEDESC lpddsd,
2179 LPDIRECTDRAWSURFACE lpdsf)
2180 {
2181 int bpp;
2182
2183 /* The surface was already allocated when entering in this function */
2184 TRACE(ddraw,"using system memory for a surface (%p)\n", lpdsf);
2185
2186 if (lpddsd->dwFlags & DDSD_ZBUFFERBITDEPTH) {
2187 /* This is a Z Buffer */
2188 TRACE(ddraw, "Creating Z-Buffer of %ld bit depth\n", lpddsd->x.dwZBufferBitDepth);
2189 bpp = lpddsd->x.dwZBufferBitDepth / 8;
2190 } else {
2191 /* This is a standard image */
2192 if (!(lpddsd->dwFlags & DDSD_PIXELFORMAT)) {
2193 /* No pixel format => use DirectDraw's format */
2194 _getpixelformat(this,&(lpddsd->ddpfPixelFormat));
2195 lpddsd->dwFlags |= DDSD_PIXELFORMAT;
2196 } else {
2197 /* To check what the program wants */
2198 if (TRACE_ON(ddraw)) {
2199 _dump_pixelformat(&(lpddsd->ddpfPixelFormat));
2200 }
2201 }
2202
2203 if (lpddsd->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) {
2204 bpp = 1;
2205 } else {
2206 bpp = lpddsd->ddpfPixelFormat.x.dwRGBBitCount / 8;
2207 }
2208 }
2209
2210 /* Copy the surface description */
2211 lpdsf->s.surface_desc = *lpddsd;
2212
2213 lpdsf->s.surface_desc.dwFlags |= DDSD_WIDTH|DDSD_HEIGHT|DDSD_PITCH|DDSD_LPSURFACE;
2214 lpdsf->s.surface_desc.y.lpSurface = (LPBYTE)HeapAlloc(GetProcessHeap(),0,lpddsd->dwWidth * lpddsd->dwHeight * bpp);
2215 lpdsf->s.surface_desc.lPitch = lpddsd->dwWidth * bpp;
2216
2217 return DD_OK;
2218 }
2219
2220 static HRESULT WINAPI DGA_IDirectDraw2_CreateSurface(
2221 LPDIRECTDRAW2 this,LPDDSURFACEDESC lpddsd,LPDIRECTDRAWSURFACE *lpdsf,IUnknown *lpunk
2222 ) {
2223 #ifdef HAVE_LIBXXF86DGA
2224 int i;
2225
2226 TRACE(ddraw, "(%p)->(%p,%p,%p)\n",this,lpddsd,lpdsf,lpunk);
2227 if (TRACE_ON(ddraw)) {
2228 DUMP("[w=%ld,h=%ld,flags ",lpddsd->dwWidth,lpddsd->dwHeight);
2229 _dump_DDSD(lpddsd->dwFlags);
2230 fprintf(stderr,"caps ");
2231 _dump_DDSCAPS(lpddsd->ddsCaps.dwCaps);
2232 fprintf(stderr,"]\n");
2233 }
2234
2235 *lpdsf = (LPDIRECTDRAWSURFACE)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawSurface));
2236 this->lpvtbl->fnAddRef(this);
2237
2238 (*lpdsf)->ref = 1;
2239 (*lpdsf)->lpvtbl = (LPDIRECTDRAWSURFACE_VTABLE)&dga_dds4vt;
2240 (*lpdsf)->s.ddraw = this;
2241 (*lpdsf)->s.palette = NULL;
2242 (*lpdsf)->t.dga.fb_height = -1; /* This is to have non-on screen surfaces freed */
2243
2244 if (!(lpddsd->dwFlags & DDSD_WIDTH))
2245 lpddsd->dwWidth = this->d.width;
2246 if (!(lpddsd->dwFlags & DDSD_HEIGHT))
2247 lpddsd->dwHeight = this->d.height;
2248
2249 /* Check if this a 'primary surface' or not */
2250 if ((lpddsd->dwFlags & DDSD_CAPS) &&
2251 (lpddsd->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)) {
2252
2253 /* This is THE primary surface => there is DGA-specific code */
2254 /* First, store the surface description */
2255 (*lpdsf)->s.surface_desc = *lpddsd;
2256
2257 /* Find a viewport */
2258 for (i=0;i<32;i++)
2259 if (!(this->e.dga.vpmask & (1<<i)))
2260 break;
2261 TRACE(ddraw,"using viewport %d for a primary surface\n",i);
2262 /* if i == 32 or maximum ... return error */
2263 this->e.dga.vpmask|=(1<<i);
2264 (*lpdsf)->s.surface_desc.y.lpSurface =
2265 this->e.dga.fb_addr+((i*this->e.dga.fb_height)*this->e.dga.fb_width*this->d.depth/8);
2266 (*lpdsf)->t.dga.fb_height = i*this->e.dga.fb_height;
2267 (*lpdsf)->s.surface_desc.lPitch = this->e.dga.fb_width*this->d.depth/8;
2268 lpddsd->lPitch = (*lpdsf)->s.surface_desc.lPitch;
2269
2270 /* Add flags if there were not present */
2271 (*lpdsf)->s.surface_desc.dwFlags |= DDSD_WIDTH|DDSD_HEIGHT|DDSD_PITCH|DDSD_LPSURFACE;
2272 (*lpdsf)->s.surface_desc.dwWidth = this->d.width;
2273 (*lpdsf)->s.surface_desc.dwHeight = this->d.height;
2274 TRACE(ddraw,"primary surface: dwWidth=%ld, dwHeight=%ld, lPitch=%ld\n",this->d.width,this->d.height,lpddsd->lPitch);
2275 /* We put our surface always in video memory */
2276 (*lpdsf)->s.surface_desc.ddsCaps.dwCaps |= DDSCAPS_VISIBLE|DDSCAPS_VIDEOMEMORY;
2277 _getpixelformat(this,&((*lpdsf)->s.surface_desc.ddpfPixelFormat));
2278 (*lpdsf)->s.backbuffer = NULL;
2279
2280 if (lpddsd->dwFlags & DDSD_BACKBUFFERCOUNT) {
2281 LPDIRECTDRAWSURFACE4 back;
2282
2283 if (lpddsd->dwBackBufferCount>1)
2284 FIXME(ddraw,"urks, wants to have more than one backbuffer (%ld)!\n",lpddsd->dwBackBufferCount);
2285
2286 (*lpdsf)->s.backbuffer = back =
2287 (LPDIRECTDRAWSURFACE4)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawSurface4));
2288 this->lpvtbl->fnAddRef(this);
2289 back->ref = 1;
2290 back->lpvtbl = (LPDIRECTDRAWSURFACE4_VTABLE)&dga_dds4vt;
2291 for (i=0;i<32;i++)
2292 if (!(this->e.dga.vpmask & (1<<i)))
2293 break;
2294 TRACE(ddraw,"using viewport %d for backbuffer\n",i);
2295 /* if i == 32 or maximum ... return error */
2296 this->e.dga.vpmask|=(1<<i);
2297 back->t.dga.fb_height = i*this->e.dga.fb_height;
2298
2299 /* Copy the surface description from the front buffer */
2300 back->s.surface_desc = (*lpdsf)->s.surface_desc;
2301 /* Change the parameters that are not the same */
2302 back->s.surface_desc.y.lpSurface = this->e.dga.fb_addr+
2303 ((i*this->e.dga.fb_height)*this->e.dga.fb_width*this->d.depth/8);
2304 back->s.ddraw = this;
2305 back->s.backbuffer = NULL; /* does not have a backbuffer, it is
2306 * one! */
2307
2308 /* Add relevant info to front and back buffers */
2309 (*lpdsf)->s.surface_desc.ddsCaps.dwCaps |= DDSCAPS_FRONTBUFFER;
2310 back->s.surface_desc.ddsCaps.dwCaps |= DDSCAPS_BACKBUFFER;
2311 back->s.surface_desc.dwFlags &= ~DDSD_BACKBUFFERCOUNT;
2312 back->s.surface_desc.ddsCaps.dwCaps &= ~DDSCAPS_VISIBLE;
2313 back->s.surface_desc.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
2314 }
2315 } else {
2316 /* There is no DGA-specific code here...
2317 Go to the common surface creation function */
2318 return common_off_screen_CreateSurface(this, lpddsd, *lpdsf);
2319 }
2320
2321 return DD_OK;
2322 #else /* defined(HAVE_LIBXXF86DGA) */
2323 return E_UNEXPECTED;
2324 #endif /* defined(HAVE_LIBXXF86DGA) */
2325 }
2326
2327 #ifdef HAVE_LIBXXSHM
2328 /* Error handlers for Image creation */
2329 static int XShmErrorHandler(Display *dpy, XErrorEvent *event) {
2330 XShmErrorFlag = 1;
2331 return 0;
2332 }
2333
2334 static XImage *create_xshmimage(LPDIRECTDRAW2 this, LPDIRECTDRAWSURFACE4 lpdsf) {
2335 XImage *img;
2336 int (*WineXHandler)(Display *, XErrorEvent *);
2337
2338 img = TSXShmCreateImage(display,
2339 DefaultVisualOfScreen(X11DRV_GetXScreen()),
2340 this->d.screen_depth,
2341 ZPixmap,
2342 NULL,
2343 &(lpdsf->t.xlib.shminfo),
2344 lpdsf->s.surface_desc.dwWidth,
2345 lpdsf->s.surface_desc.dwHeight);
2346
2347 if (img == NULL) {
2348 ERR(ddraw, "Error creating XShm image. Reverting to standard X images !\n");
2349 this->e.xlib.xshm_active = 0;
2350 return NULL;
2351 }
2352
2353 lpdsf->t.xlib.shminfo.shmid = shmget( IPC_PRIVATE, img->bytes_per_line * img->height, IPC_CREAT|0777 );
2354 if (lpdsf->t.xlib.shminfo.shmid < 0) {
2355 ERR(ddraw, "Error creating shared memory segment. Reverting to standard X images !\n");
2356 this->e.xlib.xshm_active = 0;
2357 TSXDestroyImage(img);
2358 return NULL;
2359 }
2360
2361 lpdsf->t.xlib.shminfo.shmaddr = img->data = (char*)shmat(lpdsf->t.xlib.shminfo.shmid, 0, 0);
2362
2363 if (img->data == (char *) -1) {
2364 ERR(ddraw, "Error attaching shared memory segment. Reverting to standard X images !\n");
2365 this->e.xlib.xshm_active = 0;
2366 TSXDestroyImage(img);
2367 shmctl(lpdsf->t.xlib.shminfo.shmid, IPC_RMID, 0);
2368 return NULL;
2369 }
2370 lpdsf->t.xlib.shminfo.readOnly = False;
2371
2372 /* This is where things start to get trickier....
2373 First, we flush the current X connections to be sure to catch all non-XShm related
2374 errors */
2375 TSXSync(display, False);
2376 /* Then we enter in the non-thread safe part of the tests */
2377 EnterCriticalSection( &X11DRV_CritSection );
2378
2379 /* Reset the error flag, sets our new error handler and try to attach the surface */
2380 XShmErrorFlag = 0;
2381 WineXHandler = XSetErrorHandler(XShmErrorHandler);
2382 XShmAttach(display, &(lpdsf->t.xlib.shminfo));
2383 XSync(display, False);
2384
2385 /* Check the error flag */
2386 if (XShmErrorFlag) {
2387 /* An error occured */
2388 XFlush(display);
2389 XShmErrorFlag = 0;
2390 XDestroyImage(img);
2391 shmdt(lpdsf->t.xlib.shminfo.shmaddr);
2392 shmctl(lpdsf->t.xlib.shminfo.shmid, IPC_RMID, 0);
2393 XSetErrorHandler(WineXHandler);
2394
2395 ERR(ddraw, "Error attaching shared memory segment to X server. Reverting to standard X images !\n");
2396 this->e.xlib.xshm_active = 0;
2397
2398 /* Leave the critical section */
2399 LeaveCriticalSection( &X11DRV_CritSection );
2400
2401 return NULL;
2402 }
2403
2404 /* Here, to be REALLY sure, I should do a XShmPutImage to check if this works,
2405 but it may be a bit overkill.... */
2406 XSetErrorHandler(WineXHandler);
2407 LeaveCriticalSection( &X11DRV_CritSection );
2408
2409 shmctl(lpdsf->t.xlib.shminfo.shmid, IPC_RMID, 0);
2410
2411 if (this->d.depth != this->d.screen_depth) {
2412 lpdsf->s.surface_desc.y.lpSurface = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
2413 lpdsf->s.surface_desc.dwWidth *
2414 lpdsf->s.surface_desc.dwHeight *
2415 (this->d.depth / 8));
2416 } else {
2417 lpdsf->s.surface_desc.y.lpSurface = img->data;
2418 }
2419
2420 return img;
2421 }
2422 #endif /* HAVE_LIBXXSHM */
2423
2424 static XImage *create_ximage(LPDIRECTDRAW2 this, LPDIRECTDRAWSURFACE4 lpdsf) {
2425 XImage *img = NULL;
2426 void *img_data;
2427
2428 #ifdef HAVE_LIBXXSHM
2429 if (this->e.xlib.xshm_active) {
2430 img = create_xshmimage(this, lpdsf);
2431 }
2432
2433 if (img == NULL) {
2434 #endif
2435 /* Allocate surface memory */
2436 lpdsf->s.surface_desc.y.lpSurface = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
2437 lpdsf->s.surface_desc.dwWidth *
2438 lpdsf->s.surface_desc.dwHeight *
2439 (this->d.depth / 8));
2440
2441 if (this->d.depth != this->d.screen_depth) {
2442 img_data = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
2443 lpdsf->s.surface_desc.dwWidth *
2444 lpdsf->s.surface_desc.dwHeight *
2445 (this->d.screen_depth / 8));
2446 } else {
2447 img_data = lpdsf->s.surface_desc.y.lpSurface;
2448 }
2449
2450 /* In this case, create an XImage */
2451 img =
2452 TSXCreateImage(display,
2453 DefaultVisualOfScreen(X11DRV_GetXScreen()),
2454 this->d.screen_depth,
2455 ZPixmap,
2456 0,
2457 img_data,
2458 lpdsf->s.surface_desc.dwWidth,
2459 lpdsf->s.surface_desc.dwHeight,
2460 32,
2461 lpdsf->s.surface_desc.dwWidth * (this->d.screen_depth / 8)
2462 );
2463
2464 #ifdef HAVE_LIBXXSHM
2465 }
2466 #endif
2467 if (this->d.depth != this->d.screen_depth) {
2468 lpdsf->s.surface_desc.lPitch = (this->d.depth / 8) * lpdsf->s.surface_desc.dwWidth;
2469 } else {
2470 lpdsf->s.surface_desc.lPitch = img->bytes_per_line;
2471 }
2472
2473 return img;
2474 }
2475
2476 static HRESULT WINAPI Xlib_IDirectDraw2_CreateSurface(
2477 LPDIRECTDRAW2 this,LPDDSURFACEDESC lpddsd,LPDIRECTDRAWSURFACE *lpdsf,IUnknown *lpunk
2478 ) {
2479 TRACE(ddraw, "(%p)->CreateSurface(%p,%p,%p)\n",
2480 this,lpddsd,lpdsf,lpunk);
2481
2482 if (TRACE_ON(ddraw)) {
2483 fprintf(stderr,"[w=%ld,h=%ld,flags ",lpddsd->dwWidth,lpddsd->dwHeight);
2484 _dump_DDSD(lpddsd->dwFlags);
2485 fprintf(stderr,"caps ");
2486 _dump_DDSCAPS(lpddsd->ddsCaps.dwCaps);
2487 fprintf(stderr,"]\n");
2488 }
2489
2490 *lpdsf = (LPDIRECTDRAWSURFACE)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawSurface));
2491
2492 this->lpvtbl->fnAddRef(this);
2493 (*lpdsf)->s.ddraw = this;
2494 (*lpdsf)->ref = 1;
2495 (*lpdsf)->lpvtbl = (LPDIRECTDRAWSURFACE_VTABLE)&xlib_dds4vt;
2496 (*lpdsf)->s.palette = NULL;
2497 (*lpdsf)->t.xlib.image = NULL; /* This is for off-screen buffers */
2498
2499 if (!(lpddsd->dwFlags & DDSD_WIDTH))
2500 lpddsd->dwWidth = this->d.width;
2501 if (!(lpddsd->dwFlags & DDSD_HEIGHT))
2502 lpddsd->dwHeight = this->d.height;
2503
2504 /* Check if this a 'primary surface' or not */
2505 if ((lpddsd->dwFlags & DDSD_CAPS) &&
2506 (lpddsd->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)) {
2507 XImage *img;
2508
2509 TRACE(ddraw,"using standard XImage for a primary surface (%p)\n", *lpdsf);
2510
2511 /* First, store the surface description */
2512 (*lpdsf)->s.surface_desc = *lpddsd;
2513
2514 /* Create the XImage */
2515 img = create_ximage(this, (LPDIRECTDRAWSURFACE4) *lpdsf);
2516 if (img == NULL)
2517 return DDERR_OUTOFMEMORY;
2518 (*lpdsf)->t.xlib.image = img;
2519
2520 /* Add flags if there were not present */
2521 (*lpdsf)->s.surface_desc.dwFlags |= DDSD_WIDTH|DDSD_HEIGHT|DDSD_PITCH|DDSD_LPSURFACE;
2522 (*lpdsf)->s.surface_desc.dwWidth = this->d.width;
2523 (*lpdsf)->s.surface_desc.dwHeight = this->d.height;
2524 (*lpdsf)->s.surface_desc.ddsCaps.dwCaps |= DDSCAPS_VISIBLE|DDSCAPS_VIDEOMEMORY;
2525 _getpixelformat(this,&((*lpdsf)->s.surface_desc.ddpfPixelFormat));
2526 (*lpdsf)->s.backbuffer = NULL;
2527
2528 /* Check for backbuffers */
2529 if (lpddsd->dwFlags & DDSD_BACKBUFFERCOUNT) {
2530 LPDIRECTDRAWSURFACE4 back;
2531 XImage *img;
2532
2533 if (lpddsd->dwBackBufferCount>1)
2534 FIXME(ddraw,"urks, wants to have more than one backbuffer (%ld)!\n",lpddsd->dwBackBufferCount);
2535
2536 (*lpdsf)->s.backbuffer = back =
2537 (LPDIRECTDRAWSURFACE4)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawSurface4));
2538
2539 TRACE(ddraw,"allocated back-buffer (%p)\n", back);
2540
2541 this->lpvtbl->fnAddRef(this);
2542 back->s.ddraw = this;
2543
2544 back->ref = 1;
2545 back->lpvtbl = (LPDIRECTDRAWSURFACE4_VTABLE)&xlib_dds4vt;
2546 /* Copy the surface description from the front buffer */
2547 back->s.surface_desc = (*lpdsf)->s.surface_desc;
2548
2549 /* Create the XImage */
2550 img = create_ximage(this, back);
2551 if (img == NULL)
2552 return DDERR_OUTOFMEMORY;
2553 back->t.xlib.image = img;
2554
2555 back->s.backbuffer = NULL; /* does not have a backbuffer, it is
2556 * one! */
2557
2558 /* Add relevant info to front and back buffers */
2559 (*lpdsf)->s.surface_desc.ddsCaps.dwCaps |= DDSCAPS_FRONTBUFFER;
2560 back->s.surface_desc.ddsCaps.dwCaps |= DDSCAPS_BACKBUFFER;
2561 back->s.surface_desc.dwFlags &= ~DDSD_BACKBUFFERCOUNT;
2562 back->s.surface_desc.ddsCaps.dwCaps &= ~DDSCAPS_VISIBLE;
2563 back->s.surface_desc.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
2564 }
2565 } else {
2566 /* There is no Xlib-specific code here...
2567 Go to the common surface creation function */
2568 return common_off_screen_CreateSurface(this, lpddsd, *lpdsf);
2569 }
2570
2571 return DD_OK;
2572 }
2573
2574 static HRESULT WINAPI IDirectDraw2_DuplicateSurface(
2575 LPDIRECTDRAW2 this,LPDIRECTDRAWSURFACE src,LPDIRECTDRAWSURFACE *dst
2576 ) {
2577 FIXME(ddraw,"(%p)->(%p,%p) simply copies\n",this,src,dst);
2578 *dst = src; /* FIXME */
2579 return DD_OK;
2580 }
2581
2582 /*
2583 * The Xlib Implementation tries to use the passed hwnd as drawing window,
2584 * even when the approbiate bitmasks are not specified.
2585 */
2586 static HRESULT WINAPI IDirectDraw2_SetCooperativeLevel(
2587 LPDIRECTDRAW2 this,HWND32 hwnd,DWORD cooplevel
2588 ) {
2589 int i;
2590 const struct {
2591 int mask;
2592 char *name;
2593 } flagmap[] = {
2594 FE(DDSCL_FULLSCREEN)
2595 FE(DDSCL_ALLOWREBOOT)
2596 FE(DDSCL_NOWINDOWCHANGES)
2597 FE(DDSCL_NORMAL)
2598 FE(DDSCL_ALLOWMODEX)
2599 FE(DDSCL_EXCLUSIVE)
2600 FE(DDSCL_SETFOCUSWINDOW)
2601 FE(DDSCL_SETDEVICEWINDOW)
2602 FE(DDSCL_CREATEDEVICEWINDOW)
2603 };
2604
2605 FIXME(ddraw,"(%p)->(%08lx,%08lx)\n",this,(DWORD)hwnd,cooplevel);
2606 if(TRACE_ON(ddraw)){
2607 dbg_decl_str(ddraw, 512);
2608 for (i=0;i<sizeof(flagmap)/sizeof(flagmap[0]);i++)
2609 if (flagmap[i].mask & cooplevel)
2610 dsprintf(ddraw, "%s ", flagmap[i].name);
2611 TRACE(ddraw," cooperative level %s\n", dbg_str(ddraw));
2612 }
2613 this->d.mainWindow = hwnd;
2614
2615 /* This will be overwritten in the case of Full Screen mode.
2616 Windowed games could work with that :-) */
2617 if (hwnd)
2618 this->d.drawable = X11DRV_WND_GetXWindow(WIN_FindWndPtr(hwnd));
2619
2620 return DD_OK;
2621 }
2622
2623 /* Small helper to either use the cooperative window or create a new
2624 * one (for mouse and keyboard input) and drawing in the Xlib implementation.
2625 */
2626 static void _common_IDirectDraw_SetDisplayMode(LPDIRECTDRAW this) {
2627 RECT32 rect;
2628
2629 /* Do not destroy the application supplied cooperative window */
2630 if (this->d.window && this->d.window != this->d.mainWindow) {
2631 DestroyWindow32(this->d.window);
2632 this->d.window = 0;
2633 }
2634 /* Sanity check cooperative window before assigning it to drawing. */
2635 if ( IsWindow32(this->d.mainWindow) &&
2636 IsWindowVisible32(this->d.mainWindow)
2637 ) {
2638 GetWindowRect32(this->d.mainWindow,&rect);
2639 if (((rect.right-rect.left) >= this->d.width) &&
2640 ((rect.bottom-rect.top) >= this->d.height)
2641 )
2642 this->d.window = this->d.mainWindow;
2643 }
2644 /* ... failed, create new one. */
2645 if (!this->d.window) {
2646 this->d.window = CreateWindowEx32A(
2647 0,
2648 "WINE_DirectDraw",
2649 "WINE_DirectDraw",
2650 WS_VISIBLE|WS_SYSMENU|WS_THICKFRAME,
2651 0,0,
2652 this->d.width,
2653 this->d.height,
2654 0,
2655 0,
2656 0,
2657 NULL
2658 );
2659 /*Store THIS with the window. We'll use it in the window procedure*/
2660 SetWindowLong32A(this->d.window,ddrawXlibThisOffset,(LONG)this);
2661 ShowWindow32(this->d.window,TRUE);
2662 UpdateWindow32(this->d.window);
2663 }
2664 SetFocus32(this->d.window);
2665 }
2666
2667 static HRESULT WINAPI DGA_IDirectDraw_SetDisplayMode(
2668 LPDIRECTDRAW this,DWORD width,DWORD height,DWORD depth
2669 ) {
2670 #ifdef HAVE_LIBXXF86DGA
2671 int i,*depths,depcount,mode_count;
2672
2673 TRACE(ddraw, "(%p)->(%ld,%ld,%ld)\n", this, width, height, depth);
2674
2675 /* We hope getting the asked for depth */
2676 this->d.screen_depth = depth;
2677
2678 depths = TSXListDepths(display,DefaultScreen(display),&depcount);
2679
2680 for (i=0;i<depcount;i++)
2681 if (depths[i]==depth)
2682 break;
2683 TSXFree(depths);
2684 if (i==depcount) {/* not found */
2685 ERR(ddraw,"(w=%ld,h=%ld,d=%ld), unsupported depth!\n",width,height,depth);
2686 return DDERR_UNSUPPORTEDMODE;
2687 }
2688 if (this->d.width < width) {
2689 ERR(ddraw,"SetDisplayMode(w=%ld,h=%ld,d=%ld), width %ld exceeds framebuffer width %ld\n",width,height,depth,width,this->d.width);
2690 return DDERR_UNSUPPORTEDMODE;
2691 }
2692 this->d.width = width;
2693 this->d.height = height;
2694 this->d.depth = depth;
2695
2696 /* adjust fb_height, so we don't overlap */
2697 if (this->e.dga.fb_height < height)
2698 this->e.dga.fb_height = height;
2699 _common_IDirectDraw_SetDisplayMode(this);
2700
2701 #ifdef HAVE_LIBXXF86VM
2702 {
2703 XF86VidModeModeInfo **all_modes, *vidmode = NULL;
2704 XF86VidModeModeLine mod_tmp;
2705 /* int dotclock_tmp; */
2706
2707 /* save original video mode and set fullscreen if available*/
2708 orig_mode = (XF86VidModeModeInfo *) malloc (sizeof(XF86VidModeModeInfo));
2709 TSXF86VidModeGetModeLine(display, DefaultScreen(display), &orig_mode->dotclock, &mod_tmp);
2710 orig_mode->hdisplay = mod_tmp.hdisplay;
2711 orig_mode->hsyncstart = mod_tmp.hsyncstart;
2712 orig_mode->hsyncend = mod_tmp.hsyncend;
2713 orig_mode->htotal = mod_tmp.htotal;
2714 orig_mode->vdisplay = mod_tmp.vdisplay;
2715 orig_mode->vsyncstart = mod_tmp.vsyncstart;
2716 orig_mode->vsyncend = mod_tmp.vsyncend;
2717 orig_mode->vtotal = mod_tmp.vtotal;
2718 orig_mode->flags = mod_tmp.flags;
2719 orig_mode->private = mod_tmp.private;
2720
2721 TSXF86VidModeGetAllModeLines(display,DefaultScreen(display),&mode_count,&all_modes);
2722 for (i=0;i<mode_count;i++)
2723 {
2724 if (all_modes[i]->hdisplay == width && all_modes[i]->vdisplay == height)
2725 {
2726 vidmode = (XF86VidModeModeInfo *)malloc(sizeof(XF86VidModeModeInfo));
2727 *vidmode = *(all_modes[i]);
2728 break;
2729 } else
2730 TSXFree(all_modes[i]->private);
2731 }
2732 for (i++;i<mode_count;i++) TSXFree(all_modes[i]->private);
2733 TSXFree(all_modes);
2734
2735 if (!vidmode)
2736 WARN(ddraw, "Fullscreen mode not available!\n");
2737
2738 if (vidmode)
2739 {
2740 TRACE(ddraw,"SwitchToMode(%dx%d)\n",vidmode->hdisplay,vidmode->vdisplay);
2741 TSXF86VidModeSwitchToMode(display, DefaultScreen(display), vidmode);
2742 #if 0 /* This messes up my screen (XF86_Mach64, 3.3.2.3a) for some reason, and should now be unnecessary */
2743 TSXF86VidModeSetViewPort(display, DefaultScreen(display), 0, 0);
2744 #endif
2745 }
2746 }
2747 #endif
2748
2749 /* FIXME: this function OVERWRITES several signal handlers.
2750 * can we save them? and restore them later? In a way that
2751 * it works for the library too?
2752 */
2753 TSXF86DGADirectVideo(display,DefaultScreen(display),XF86DGADirectGraphics);
2754 #ifdef DIABLO_HACK
2755 TSXF86DGASetViewPort(display,DefaultScreen(display),0,this->e.dga.fb_height);
2756 #else
2757 TSXF86DGASetViewPort(display,DefaultScreen(display),0,0);
2758 #endif
2759
2760 #ifdef RESTORE_SIGNALS
2761 SIGNAL_InitHandlers();
2762 #endif
2763 return DD_OK;
2764 #else /* defined(HAVE_LIBXXF86DGA) */
2765 return E_UNEXPECTED;
2766 #endif /* defined(HAVE_LIBXXF86DGA) */
2767 }
2768
2769 static HRESULT WINAPI Xlib_IDirectDraw_SetDisplayMode(
2770 LPDIRECTDRAW this,DWORD width,DWORD height,DWORD depth
2771 ) {
2772 int i,*depths,depcount;
2773 char buf[200];
2774
2775 TRACE(ddraw, "(%p)->SetDisplayMode(%ld,%ld,%ld)\n",
2776 this, width, height, depth);
2777
2778 /* We hope getting the asked for depth */
2779 this->d.screen_depth = depth;
2780
2781 depths = TSXListDepths(display,DefaultScreen(display),&depcount);
2782
2783 for (i=0;i<depcount;i++)
2784 if (depths[i]==depth)
2785 break;
2786 if (i==depcount) {/* not found */
2787 for (i=0;i<depcount;i++)
2788 if (depths[i]==16)
2789 break;
2790
2791 if (i==depcount) {
2792 sprintf(buf,"SetDisplayMode(w=%ld,h=%ld,d=%ld), unsupported depth!",width,height,depth);
2793 MessageBox32A(0,buf,"WINE DirectDraw",MB_OK|MB_ICONSTOP);
2794 TSXFree(depths);
2795 return DDERR_UNSUPPORTEDMODE;
2796 } else {
2797 WARN(ddraw, "Warning : running in depth-convertion mode. Should run using a %ld depth for optimal performances.\n", depth);
2798 this->d.screen_depth = 16;
2799 }
2800 }
2801 TSXFree(depths);
2802
2803 this->d.width = width;
2804 this->d.height = height;
2805 this->d.depth = depth;
2806
2807 _common_IDirectDraw_SetDisplayMode(this);
2808
2809 this->d.paintable = 1;
2810 this->d.drawable = ((X11DRV_WND_DATA *) WIN_FindWndPtr(this->d.window)->pDriverData)->window;
2811 /* We don't have a context for this window. Host off the desktop */
2812 if( !this->d.drawable )
2813 this->d.drawable = ((X11DRV_WND_DATA *) WIN_GetDesktop()->pDriverData)->window;
2814 return DD_OK;
2815 }
2816
2817 static HRESULT WINAPI DGA_IDirectDraw2_GetCaps(
2818 LPDIRECTDRAW2 this,LPDDCAPS caps1,LPDDCAPS caps2
2819 ) {
2820 #ifdef HAVE_LIBXXF86DGA
2821 TRACE(ddraw,"(%p)->GetCaps(%p,%p)\n",this,caps1,caps2);
2822 caps1->dwVidMemTotal = this->e.dga.fb_memsize;
2823 caps1->dwCaps = 0xffffffff&~(DDCAPS_BANKSWITCHED); /* we can do anything */
2824 caps1->ddsCaps.dwCaps = 0xffffffff; /* we can do anything */
2825 if (caps2) {
2826 caps2->dwVidMemTotal = this->e.dga.fb_memsize;
2827 caps2->dwCaps = 0xffffffff&~(DDCAPS_BANKSWITCHED); /* we can do anything */
2828 caps2->ddsCaps.dwCaps = 0xffffffff; /* we can do anything */
2829 }
2830 return DD_OK;
2831 #else /* defined(HAVE_LIBXXF86DGA) */
2832 return E_UNEXPECTED;
2833 #endif /* defined(HAVE_LIBXXF86DGA) */
2834 }
2835
2836 static void fill_caps(LPDDCAPS caps) {
2837 /* This function tries to fill the capabilities of Wine's DDraw implementation.
2838 Need to be fixed, though.. */
2839 if (caps == NULL)
2840 return;
2841
2842 caps->dwSize = sizeof(*caps);
2843 caps->dwCaps = DDCAPS_3D | DDCAPS_ALPHA | DDCAPS_BLT | DDCAPS_BLTSTRETCH | DDCAPS_BLTCOLORFILL | DDCAPS_BLTDEPTHFILL |
2844 DDCAPS_CANBLTSYSMEM | DDCAPS_COLORKEY | DDCAPS_PALETTE | DDCAPS_ZBLTS;
2845 caps->dwCaps2 = DDCAPS2_CERTIFIED | DDCAPS2_NO2DDURING3DSCENE | DDCAPS2_NOPAGELOCKREQUIRED |
2846 DDCAPS2_WIDESURFACES;
2847 caps->dwCKeyCaps = 0xFFFFFFFF; /* Should put real caps here one day... */
2848 caps->dwFXCaps = 0;
2849 caps->dwFXAlphaCaps = 0;
2850 caps->dwPalCaps = DDPCAPS_8BIT | DDPCAPS_ALLOW256;
2851 caps->dwSVCaps = 0;
2852 caps->dwZBufferBitDepths = DDBD_16;
2853 /* I put here 8 Mo so that D3D applications will believe they have enough memory
2854 to put textures in video memory.
2855 BTW, is this only frame buffer memory or also texture memory (for Voodoo boards
2856 for example) ? */
2857 caps->dwVidMemTotal = 8192 * 1024;
2858 caps->dwVidMemFree = 8192 * 1024;
2859 /* These are all the supported capabilities of the surfaces */
2860 caps->ddsCaps.dwCaps = DDSCAPS_3DDEVICE | DDSCAPS_ALPHA | DDSCAPS_BACKBUFFER | DDSCAPS_COMPLEX | DDSCAPS_FLIP |
2861 DDSCAPS_FRONTBUFFER | DDSCAPS_LOCALVIDMEM | DDSCAPS_MIPMAP | DDSCAPS_NONLOCALVIDMEM | DDSCAPS_OFFSCREENPLAIN |
2862 DDSCAPS_OVERLAY | DDSCAPS_PALETTE | DDSCAPS_PRIMARYSURFACE | DDSCAPS_SYSTEMMEMORY | DDSCAPS_TEXTURE |
2863 DDSCAPS_VIDEOMEMORY | DDSCAPS_VISIBLE | DDSCAPS_ZBUFFER;
2864 }
2865
2866 static HRESULT WINAPI Xlib_IDirectDraw2_GetCaps(
2867 LPDIRECTDRAW2 this,LPDDCAPS caps1,LPDDCAPS caps2
2868 ) {
2869 TRACE(ddraw,"(%p)->GetCaps(%p,%p)\n",this,caps1,caps2);
2870
2871 /* Put the same caps for the two capabilities */
2872 fill_caps(caps1);
2873 fill_caps(caps2);
2874
2875 return DD_OK;
2876 }
2877
2878 static HRESULT WINAPI IDirectDraw2_CreateClipper(
2879 LPDIRECTDRAW2 this,DWORD x,LPDIRECTDRAWCLIPPER *lpddclip,LPUNKNOWN lpunk
2880 ) {
2881 FIXME(ddraw,"(%p)->(%08lx,%p,%p),stub!\n",
2882 this,x,lpddclip,lpunk
2883 );
2884 *lpddclip = (LPDIRECTDRAWCLIPPER)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawClipper));
2885 (*lpddclip)->ref = 1;
2886 (*lpddclip)->lpvtbl = &ddclipvt;
2887 return DD_OK;
2888 }
2889
2890 static HRESULT WINAPI common_IDirectDraw2_CreatePalette(
2891 LPDIRECTDRAW2 this,DWORD dwFlags,LPPALETTEENTRY palent,LPDIRECTDRAWPALETTE *lpddpal,LPUNKNOWN lpunk,int *psize
2892 ) {
2893 int size = 0;
2894
2895 if (TRACE_ON(ddraw))
2896 _dump_paletteformat(dwFlags);
2897
2898 *lpddpal = (LPDIRECTDRAWPALETTE)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawPalette));
2899 if (*lpddpal == NULL) return E_OUTOFMEMORY;
2900 (*lpddpal)->ref = 1;
2901 (*lpddpal)->ddraw = (LPDIRECTDRAW)this;
2902 (*lpddpal)->installed = 0;
2903
2904 if (dwFlags & DDPCAPS_1BIT)
2905 size = 2;
2906 else if (dwFlags & DDPCAPS_2BIT)
2907 size = 4;
2908 else if (dwFlags & DDPCAPS_4BIT)
2909 size = 16;
2910 else if (dwFlags & DDPCAPS_8BIT)
2911 size = 256;
2912 else
2913 ERR(ddraw, "unhandled palette format\n");
2914 *psize = size;
2915
2916 if (palent)
2917 {
2918 /* Now, if we are in 'depth conversion mode', create the screen palette */
2919 if (this->d.depth != this->d.screen_depth) {
2920 int i;
2921
2922 switch (this->d.screen_depth) {
2923 case 16: {
2924 unsigned short *screen_palette = (unsigned short *) (*lpddpal)->screen_palents;
2925
2926 for (i = 0; i < size; i++) {
2927 screen_palette[i] = (((((unsigned short) palent[i].peRed) & 0xF8) << 8) |
2928 ((((unsigned short) palent[i].peBlue) & 0xF8) >> 3) |
2929 ((((unsigned short) palent[i].peGreen) & 0xFC) << 3));
2930 }
2931 } break;
2932
2933 default:
2934 ERR(ddraw, "Memory corruption ! (depth=%ld, screen_depth=%ld)\n",this->d.depth,this->d.screen_depth);
2935 break;
2936 }
2937 }
2938
2939 memcpy((*lpddpal)->palents, palent, size * sizeof(PALETTEENTRY));
2940 } else if (this->d.depth != this->d.screen_depth) {
2941 int i;
2942
2943 switch (this->d.screen_depth) {
2944 case 16: {
2945 unsigned short *screen_palette = (unsigned short *) (*lpddpal)->screen_palents;
2946
2947 for (i = 0; i < size; i++) {
2948 screen_palette[i] = 0xFFFF;
2949 }
2950 } break;
2951
2952 default:
2953 ERR(ddraw, "Memory corruption !\n");
2954 break;
2955 }
2956 }
2957
2958 return DD_OK;
2959 }
2960
2961 static HRESULT WINAPI DGA_IDirectDraw2_CreatePalette(
2962 LPDIRECTDRAW2 this,DWORD dwFlags,LPPALETTEENTRY palent,LPDIRECTDRAWPALETTE *lpddpal,LPUNKNOWN lpunk
2963 ) {
2964 HRESULT res;
2965 int xsize = 0,i;
2966
2967 TRACE(ddraw,"(%p)->(%08lx,%p,%p,%p)\n",this,dwFlags,palent,lpddpal,lpunk);
2968 res = common_IDirectDraw2_CreatePalette(this,dwFlags,palent,lpddpal,lpunk,&xsize);
2969 if (res != 0) return res;
2970 (*lpddpal)->lpvtbl = &dga_ddpalvt;
2971 if (this->d.depth<=8) {
2972 (*lpddpal)->cm = TSXCreateColormap(display,DefaultRootWindow(display),DefaultVisualOfScreen(X11DRV_GetXScreen()),AllocAll);
2973 } else {
2974 FIXME(ddraw,"why are we doing CreatePalette in hi/truecolor?\n");
2975 (*lpddpal)->cm = 0;
2976 }
2977 if (((*lpddpal)->cm)&&xsize) {
2978 for (i=0;i<xsize;i++) {
2979 XColor xc;
2980
2981 xc.red = (*lpddpal)->palents[i].peRed<<8;
2982 xc.blue = (*lpddpal)->palents[i].peBlue<<8;
2983 xc.green = (*lpddpal)->palents[i].peGreen<<8;
2984 xc.flags = DoRed|DoBlue|DoGreen;
2985 xc.pixel = i;
2986 TSXStoreColor(display,(*lpddpal)->cm,&xc);
2987 }
2988 }
2989 return DD_OK;
2990 }
2991
2992 static HRESULT WINAPI Xlib_IDirectDraw2_CreatePalette(
2993 LPDIRECTDRAW2 this,DWORD dwFlags,LPPALETTEENTRY palent,LPDIRECTDRAWPALETTE *lpddpal,LPUNKNOWN lpunk
2994 ) {
2995 int xsize;
2996 HRESULT res;
2997
2998 TRACE(ddraw,"(%p)->(%08lx,%p,%p,%p)\n",this,dwFlags,palent,lpddpal,lpunk);
2999 res = common_IDirectDraw2_CreatePalette(this,dwFlags,palent,lpddpal,lpunk,&xsize);
3000 if (res != 0) return res;
3001 (*lpddpal)->lpvtbl = &xlib_ddpalvt;
3002 return DD_OK;
3003 }
3004
3005 static HRESULT WINAPI DGA_IDirectDraw2_RestoreDisplayMode(LPDIRECTDRAW2 this) {
3006 #ifdef HAVE_LIBXXF86DGA
3007 TRACE(ddraw, "(%p)->()\n",this);
3008 Sleep(1000);
3009 TSXF86DGADirectVideo(display,DefaultScreen(display),0);
3010 #ifdef RESTORE_SIGNALS
3011 SIGNAL_InitHandlers();
3012 #endif
3013 return DD_OK;
3014 #else /* defined(HAVE_LIBXXF86DGA) */
3015 return E_UNEXPECTED;
3016 #endif
3017 }
3018
3019 static HRESULT WINAPI Xlib_IDirectDraw2_RestoreDisplayMode(LPDIRECTDRAW2 this) {
3020 TRACE(ddraw, "(%p)->RestoreDisplayMode()\n", this);
3021 Sleep(1000);
3022 return DD_OK;
3023 }
3024
3025 static HRESULT WINAPI IDirectDraw2_WaitForVerticalBlank(
3026 LPDIRECTDRAW2 this,DWORD x,HANDLE32 h
3027 ) {
3028 TRACE(ddraw,"(%p)->(0x%08lx,0x%08x)\n",this,x,h);
3029 return DD_OK;
3030 }
3031
3032 static ULONG WINAPI IDirectDraw2_AddRef(LPDIRECTDRAW2 this) {
3033 TRACE( ddraw, "(%p)->() incrementing from %lu.\n", this, this->ref );
3034
3035 return ++(this->ref);
3036 }
3037
3038 static ULONG WINAPI DGA_IDirectDraw2_Release(LPDIRECTDRAW2 this) {
3039 TRACE( ddraw, "(%p)->() decrementing from %lu.\n", this, this->ref );
3040
3041 #ifdef HAVE_LIBXXF86DGA
3042 if (!--(this->ref)) {
3043 TSXF86DGADirectVideo(display,DefaultScreen(display),0);
3044 if (this->d.window && (this->d.mainWindow != this->d.window))
3045 DestroyWindow32(this->d.window);
3046 #ifdef HAVE_LIBXXF86VM
3047 if (orig_mode) {
3048 TSXF86VidModeSwitchToMode(
3049 display,
3050 DefaultScreen(display),
3051 orig_mode);
3052 if (orig_mode->privsize)
3053 TSXFree(orig_mode->private);
3054 free(orig_mode);
3055 orig_mode = NULL;
3056 }
3057 #endif
3058
3059 #ifdef RESTORE_SIGNALS
3060 SIGNAL_InitHandlers();
3061 #endif
3062 HeapFree(GetProcessHeap(),0,this);
3063 return 0;
3064 }
3065 #endif /* defined(HAVE_LIBXXF86DGA) */
3066 return this->ref;
3067 }
3068
3069 static ULONG WINAPI Xlib_IDirectDraw2_Release(LPDIRECTDRAW2 this) {
3070 TRACE( ddraw, "(%p)->() decrementing from %lu.\n", this, this->ref );
3071
3072 if (!--(this->ref)) {
3073 if (this->d.window && (this->d.mainWindow != this->d.window))
3074 DestroyWindow32(this->d.window);
3075 HeapFree(GetProcessHeap(),0,this);
3076 return 0;
3077 }
3078 /* FIXME: destroy window ... */
3079 return this->ref;
3080 }
3081
3082 static HRESULT WINAPI DGA_IDirectDraw2_QueryInterface(
3083 LPDIRECTDRAW2 this,REFIID refiid,LPVOID *obj
3084 ) {
3085 char xrefiid[50];
3086
3087 WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
3088 TRACE(ddraw,"(%p)->(%s,%p)\n",this,xrefiid,obj);
3089 if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
3090 *obj = this;
3091 this->lpvtbl->fnAddRef(this);
3092
3093 TRACE(ddraw, " Creating IUnknown interface (%p)\n", *obj);
3094
3095 return S_OK;
3096 }
3097 if (!memcmp(&IID_IDirectDraw,refiid,sizeof(IID_IDirectDraw))) {
3098 this->lpvtbl = (LPDIRECTDRAW2_VTABLE)&dga_ddvt;
3099 this->lpvtbl->fnAddRef(this);
3100 *obj = this;
3101
3102 TRACE(ddraw, " Creating IDirectDraw interface (%p)\n", *obj);
3103
3104 return S_OK;
3105 }
3106 if (!memcmp(&IID_IDirectDraw2,refiid,sizeof(IID_IDirectDraw2))) {
3107 this->lpvtbl = (LPDIRECTDRAW2_VTABLE)&dga_dd2vt;
3108 this->lpvtbl->fnAddRef(this);
3109 *obj = this;
3110
3111 TRACE(ddraw, " Creating IDirectDraw2 interface (%p)\n", *obj);
3112
3113 return S_OK;
3114 }
3115 if (!memcmp(&IID_IDirectDraw4,refiid,sizeof(IID_IDirectDraw4))) {
3116 this->lpvtbl = (LPDIRECTDRAW2_VTABLE)&dga_dd4vt;
3117 this->lpvtbl->fnAddRef(this);
3118 *obj = this;
3119
3120 TRACE(ddraw, " Creating IDirectDraw4 interface (%p)\n", *obj);
3121
3122 return S_OK;
3123 }
3124 if (!memcmp(&IID_IDirect3D,refiid,sizeof(IID_IDirect3D))) {
3125 LPDIRECT3D d3d;
3126
3127 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
3128 d3d->ref = 1;
3129 d3d->ddraw = (LPDIRECTDRAW)this;
3130 this->lpvtbl->fnAddRef(this);
3131 d3d->lpvtbl = &d3dvt;
3132 *obj = d3d;
3133
3134 TRACE(ddraw, " Creating IDirect3D interface (%p)\n", *obj);
3135
3136 return S_OK;
3137 }
3138 if (!memcmp(&IID_IDirect3D2,refiid,sizeof(IID_IDirect3D2))) {
3139 LPDIRECT3D2 d3d;
3140
3141 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
3142 d3d->ref = 1;
3143 d3d->ddraw = (LPDIRECTDRAW)this;
3144 this->lpvtbl->fnAddRef(this);
3145 d3d->lpvtbl = &d3d2vt;
3146 *obj = d3d;
3147
3148 TRACE(ddraw, " Creating IDirect3D2 interface (%p)\n", *obj);
3149
3150 return S_OK;
3151 }
3152 WARN(ddraw,"(%p):interface for IID %s _NOT_ found!\n",this,xrefiid);
3153 return OLE_E_ENUM_NOMORE;
3154 }
3155
3156 static HRESULT WINAPI Xlib_IDirectDraw2_QueryInterface(
3157 LPDIRECTDRAW2 this,REFIID refiid,LPVOID *obj
3158 ) {
3159 char xrefiid[50];
3160
3161 WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
3162 TRACE(ddraw,"(%p)->(%s,%p)\n",this,xrefiid,obj);
3163 if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
3164 *obj = this;
3165 this->lpvtbl->fnAddRef(this);
3166
3167 TRACE(ddraw, " Creating IUnknown interface (%p)\n", *obj);
3168
3169 return S_OK;
3170 }
3171 if (!memcmp(&IID_IDirectDraw,refiid,sizeof(IID_IDirectDraw))) {
3172 this->lpvtbl = (LPDIRECTDRAW2_VTABLE)&xlib_ddvt;
3173 this->lpvtbl->fnAddRef(this);
3174 *obj = this;
3175
3176 TRACE(ddraw, " Creating IDirectDraw interface (%p)\n", *obj);
3177
3178 return S_OK;
3179 }
3180 if (!memcmp(&IID_IDirectDraw2,refiid,sizeof(IID_IDirectDraw2))) {
3181 this->lpvtbl = (LPDIRECTDRAW2_VTABLE)&xlib_dd2vt;
3182 this->lpvtbl->fnAddRef(this);
3183 *obj = this;
3184
3185 TRACE(ddraw, " Creating IDirectDraw2 interface (%p)\n", *obj);
3186
3187 return S_OK;
3188 }
3189 if (!memcmp(&IID_IDirectDraw4,refiid,sizeof(IID_IDirectDraw4))) {
3190 this->lpvtbl = (LPDIRECTDRAW2_VTABLE)&xlib_dd4vt;
3191 this->lpvtbl->fnAddRef(this);
3192 *obj = this;
3193
3194 TRACE(ddraw, " Creating IDirectDraw4 interface (%p)\n", *obj);
3195
3196 return S_OK;
3197 }
3198 if (!memcmp(&IID_IDirect3D,refiid,sizeof(IID_IDirect3D))) {
3199 LPDIRECT3D d3d;
3200
3201 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
3202 d3d->ref = 1;
3203 d3d->ddraw = (LPDIRECTDRAW)this;
3204 this->lpvtbl->fnAddRef(this);
3205 d3d->lpvtbl = &d3dvt;
3206 *obj = d3d;
3207
3208 TRACE(ddraw, " Creating IDirect3D interface (%p)\n", *obj);
3209
3210 return S_OK;
3211 }
3212 if (!memcmp(&IID_IDirect3D2,refiid,sizeof(IID_IDirect3D))) {
3213 LPDIRECT3D2 d3d;
3214
3215 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
3216 d3d->ref = 1;
3217 d3d->ddraw = (LPDIRECTDRAW)this;
3218 this->lpvtbl->fnAddRef(this);
3219 d3d->lpvtbl = &d3d2vt;
3220 *obj = d3d;
3221
3222 TRACE(ddraw, " Creating IDirect3D2 interface (%p)\n", *obj);
3223
3224 return S_OK;
3225 }
3226 WARN(ddraw,"(%p):interface for IID %s _NOT_ found!\n",this,xrefiid);
3227 return OLE_E_ENUM_NOMORE;
3228 }
3229
3230 static HRESULT WINAPI IDirectDraw2_GetVerticalBlankStatus(
3231 LPDIRECTDRAW2 this,BOOL32 *status
3232 ) {
3233 TRACE(ddraw,"(%p)->(%p)\n",this,status);
3234 *status = TRUE;
3235 return DD_OK;
3236 }
3237
3238 static HRESULT WINAPI IDirectDraw2_EnumDisplayModes(
3239 LPDIRECTDRAW2 this,DWORD dwFlags,LPDDSURFACEDESC lpddsfd,LPVOID context,LPDDENUMMODESCALLBACK modescb
3240 ) {
3241 DDSURFACEDESC ddsfd;
3242 static struct {
3243 int w,h;
3244 } modes[5] = { /* some of the usual modes */
3245 {512,384},
3246 {640,400},
3247 {640,480},
3248 {800,600},
3249 {1024,768},
3250 };
3251 static int depths[4] = {8,16,24,32};
3252 int i,j;
3253
3254 TRACE(ddraw,"(%p)->(0x%08lx,%p,%p,%p)\n",this,dwFlags,lpddsfd,context,modescb);
3255 ddsfd.dwSize = sizeof(ddsfd);
3256 ddsfd.dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_BACKBUFFERCOUNT|DDSD_PIXELFORMAT|DDSD_CAPS;
3257 if (dwFlags & DDEDM_REFRESHRATES) {
3258 ddsfd.dwFlags |= DDSD_REFRESHRATE;
3259 ddsfd.x.dwRefreshRate = 60;
3260 }
3261
3262 for (i=0;i<sizeof(depths)/sizeof(depths[0]);i++) {
3263 ddsfd.dwBackBufferCount = 1;
3264 ddsfd.ddpfPixelFormat.dwFourCC = 0;
3265 ddsfd.ddpfPixelFormat.dwFlags = DDPF_RGB;
3266 ddsfd.ddpfPixelFormat.x.dwRGBBitCount = depths[i];
3267 /* FIXME: those masks would have to be set in depth > 8 */
3268 if (depths[i]==8) {
3269 ddsfd.ddpfPixelFormat.y.dwRBitMask = 0;
3270 ddsfd.ddpfPixelFormat.z.dwGBitMask = 0;
3271 ddsfd.ddpfPixelFormat.xx.dwBBitMask = 0;
3272 ddsfd.ddpfPixelFormat.xy.dwRGBAlphaBitMask= 0;
3273 ddsfd.ddsCaps.dwCaps=DDSCAPS_PALETTE;
3274 ddsfd.ddpfPixelFormat.dwFlags|=DDPF_PALETTEINDEXED8;
3275 } else {
3276 ddsfd.ddpfPixelFormat.xy.dwRGBAlphaBitMask= 0;
3277
3278 /* FIXME: We should query those from X itself */
3279 switch (depths[i]) {
3280 case 16:
3281 ddsfd.ddpfPixelFormat.y.dwRBitMask = 0xF800;
3282 ddsfd.ddpfPixelFormat.z.dwGBitMask = 0x07E0;
3283 ddsfd.ddpfPixelFormat.xx.dwBBitMask= 0x001F;
3284 break;
3285 case 24:
3286 ddsfd.ddpfPixelFormat.y.dwRBitMask = 0x00FF0000;
3287 ddsfd.ddpfPixelFormat.z.dwGBitMask = 0x0000FF00;
3288 ddsfd.ddpfPixelFormat.xx.dwBBitMask= 0x000000FF;
3289 break;
3290 case 32:
3291 ddsfd.ddpfPixelFormat.y.dwRBitMask = 0x00FF0000;
3292 ddsfd.ddpfPixelFormat.z.dwGBitMask = 0x0000FF00;
3293 ddsfd.ddpfPixelFormat.xx.dwBBitMask= 0x000000FF;
3294 break;
3295 }
3296 }
3297
3298 ddsfd.dwWidth = MONITOR_GetWidth(&MONITOR_PrimaryMonitor);
3299 ddsfd.dwHeight = MONITOR_GetHeight(&MONITOR_PrimaryMonitor);
3300 TRACE(ddraw," enumerating (%ldx%ldx%d)\n",ddsfd.dwWidth,ddsfd.dwHeight,depths[i]);
3301 if (!modescb(&ddsfd,context)) return DD_OK;
3302
3303 for (j=0;j<sizeof(modes)/sizeof(modes[0]);j++) {
3304 ddsfd.dwWidth = modes[j].w;
3305 ddsfd.dwHeight = modes[j].h;
3306 TRACE(ddraw," enumerating (%ldx%ldx%d)\n",ddsfd.dwWidth,ddsfd.dwHeight,depths[i]);
3307 if (!modescb(&ddsfd,context)) return DD_OK;
3308 }
3309
3310 if (!(dwFlags & DDEDM_STANDARDVGAMODES)) {
3311 /* modeX is not standard VGA */
3312
3313 ddsfd.dwHeight = 200;
3314 ddsfd.dwWidth = 320;
3315 TRACE(ddraw," enumerating (320x200x%d)\n",depths[i]);
3316 if (!modescb(&ddsfd,context)) return DD_OK;
3317 }
3318 }
3319 return DD_OK;
3320 }
3321
3322 static HRESULT WINAPI DGA_IDirectDraw2_GetDisplayMode(
3323 LPDIRECTDRAW2 this,LPDDSURFACEDESC lpddsfd
3324 ) {
3325 #ifdef HAVE_LIBXXF86DGA
3326 TRACE(ddraw,"(%p)->(%p)\n",this,lpddsfd);
3327 lpddsfd->dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_PITCH|DDSD_BACKBUFFERCOUNT|DDSD_PIXELFORMAT|DDSD_CAPS;
3328 lpddsfd->dwHeight = MONITOR_GetHeight(&MONITOR_PrimaryMonitor);
3329 lpddsfd->dwWidth = MONITOR_GetWidth(&MONITOR_PrimaryMonitor);
3330 lpddsfd->lPitch = this->e.dga.fb_width*this->d.depth/8;
3331 lpddsfd->dwBackBufferCount = 1;
3332 lpddsfd->x.dwRefreshRate = 60;
3333 lpddsfd->ddsCaps.dwCaps = DDSCAPS_PALETTE;
3334 _getpixelformat(this,&(lpddsfd->ddpfPixelFormat));
3335 return DD_OK;
3336 #else /* defined(HAVE_LIBXXF86DGA) */
3337 return E_UNEXPECTED;
3338 #endif /* defined(HAVE_LIBXXF86DGA) */
3339 }
3340
3341 static HRESULT WINAPI Xlib_IDirectDraw2_GetDisplayMode(
3342 LPDIRECTDRAW2 this,LPDDSURFACEDESC lpddsfd
3343 ) {
3344 TRACE(ddraw,"(%p)->GetDisplayMode(%p)\n",this,lpddsfd);
3345 lpddsfd->dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_PITCH|DDSD_BACKBUFFERCOUNT|DDSD_PIXELFORMAT|DDSD_CAPS;
3346 lpddsfd->dwHeight = MONITOR_GetHeight(&MONITOR_PrimaryMonitor);
3347 lpddsfd->dwWidth = MONITOR_GetWidth(&MONITOR_PrimaryMonitor);
3348 /* POOLE FIXME: Xlib */
3349 lpddsfd->lPitch = this->e.dga.fb_width*this->d.depth/8;
3350 /* END FIXME: Xlib */
3351 lpddsfd->dwBackBufferCount = 1;
3352 lpddsfd->x.dwRefreshRate = 60;
3353 lpddsfd->ddsCaps.dwCaps = DDSCAPS_PALETTE;
3354 _getpixelformat(this,&(lpddsfd->ddpfPixelFormat));
3355 return DD_OK;
3356 }
3357
3358 static HRESULT WINAPI IDirectDraw2_FlipToGDISurface(LPDIRECTDRAW2 this) {
3359 TRACE(ddraw,"(%p)->()\n",this);
3360 return DD_OK;
3361 }
3362
3363 static HRESULT WINAPI IDirectDraw2_GetMonitorFrequency(
3364 LPDIRECTDRAW2 this,LPDWORD freq
3365 ) {
3366 FIXME(ddraw,"(%p)->(%p) returns 60 Hz always\n",this,freq);
3367 *freq = 60*100; /* 60 Hz */
3368 return DD_OK;
3369 }
3370
3371 /* what can we directly decompress? */
3372 static HRESULT WINAPI IDirectDraw2_GetFourCCCodes(
3373 LPDIRECTDRAW2 this,LPDWORD x,LPDWORD y
3374 ) {
3375 FIXME(ddraw,"(%p,%p,%p), stub\n",this,x,y);
3376 return DD_OK;
3377 }
3378
3379 static HRESULT WINAPI IDirectDraw2_EnumSurfaces(
3380 LPDIRECTDRAW2 this,DWORD x,LPDDSURFACEDESC ddsfd,LPVOID context,LPDDENUMSURFACESCALLBACK ddsfcb
3381 ) {
3382 FIXME(ddraw,"(%p)->(0x%08lx,%p,%p,%p),stub!\n",this,x,ddsfd,context,ddsfcb);
3383 return DD_OK;
3384 }
3385
3386 static HRESULT WINAPI IDirectDraw2_Compact(
3387 LPDIRECTDRAW2 this )
3388 {
3389 FIXME(ddraw,"(%p)->()\n", this );
3390
3391 return DD_OK;
3392 }
3393
3394 static HRESULT WINAPI IDirectDraw2_GetGDISurface(LPDIRECTDRAW2 this,
3395 LPDIRECTDRAWSURFACE *lplpGDIDDSSurface) {
3396 FIXME(ddraw,"(%p)->(%p)\n", this, lplpGDIDDSSurface);
3397
3398 return DD_OK;
3399 }
3400
3401 static HRESULT WINAPI IDirectDraw2_GetScanLine(LPDIRECTDRAW2 this,
3402 LPDWORD lpdwScanLine) {
3403 FIXME(ddraw,"(%p)->(%p)\n", this, lpdwScanLine);
3404
3405 return DD_OK;
3406 }
3407
3408 static HRESULT WINAPI IDirectDraw2_Initialize(LPDIRECTDRAW2 this,
3409 GUID *lpGUID) {
3410 FIXME(ddraw,"(%p)->(%p)\n", this, lpGUID);
3411
3412 return DD_OK;
3413 }
3414
3415 /* Note: Hack so we can reuse the old functions without compiler warnings */
3416 #ifdef __GNUC__
3417 # define XCAST(fun) (typeof(dga_ddvt.fn##fun))
3418 #else
3419 # define XCAST(fun) (void*)
3420 #endif
3421
3422 static struct IDirectDraw_VTable dga_ddvt = {
3423 XCAST(QueryInterface)DGA_IDirectDraw2_QueryInterface,
3424 XCAST(AddRef)IDirectDraw2_AddRef,
3425 XCAST(Release)DGA_IDirectDraw2_Release,
3426 XCAST(Compact)IDirectDraw2_Compact,
3427 XCAST(CreateClipper)IDirectDraw2_CreateClipper,
3428 XCAST(CreatePalette)DGA_IDirectDraw2_CreatePalette,
3429 XCAST(CreateSurface)DGA_IDirectDraw2_CreateSurface,
3430 XCAST(DuplicateSurface)IDirectDraw2_DuplicateSurface,
3431 XCAST(EnumDisplayModes)IDirectDraw2_EnumDisplayModes,
3432 XCAST(EnumSurfaces)IDirectDraw2_EnumSurfaces,
3433 XCAST(FlipToGDISurface)IDirectDraw2_FlipToGDISurface,
3434 XCAST(GetCaps)DGA_IDirectDraw2_GetCaps,
3435 XCAST(GetDisplayMode)DGA_IDirectDraw2_GetDisplayMode,
3436 XCAST(GetFourCCCodes)IDirectDraw2_GetFourCCCodes,
3437 XCAST(GetGDISurface)IDirectDraw2_GetGDISurface,
3438 XCAST(GetMonitorFrequency)IDirectDraw2_GetMonitorFrequency,
3439 XCAST(GetScanLine)IDirectDraw2_GetScanLine,
3440 XCAST(GetVerticalBlankStatus)IDirectDraw2_GetVerticalBlankStatus,
3441 XCAST(Initialize)IDirectDraw2_Initialize,
3442 XCAST(RestoreDisplayMode)DGA_IDirectDraw2_RestoreDisplayMode,
3443 XCAST(SetCooperativeLevel)IDirectDraw2_SetCooperativeLevel,
3444 DGA_IDirectDraw_SetDisplayMode,
3445 XCAST(WaitForVerticalBlank)IDirectDraw2_WaitForVerticalBlank,
3446 };
3447
3448 static struct IDirectDraw_VTable xlib_ddvt = {
3449 XCAST(QueryInterface)Xlib_IDirectDraw2_QueryInterface,
3450 XCAST(AddRef)IDirectDraw2_AddRef,
3451 XCAST(Release)Xlib_IDirectDraw2_Release,
3452 XCAST(Compact)IDirectDraw2_Compact,
3453 XCAST(CreateClipper)IDirectDraw2_CreateClipper,
3454 XCAST(CreatePalette)Xlib_IDirectDraw2_CreatePalette,
3455 XCAST(CreateSurface)Xlib_IDirectDraw2_CreateSurface,
3456 XCAST(DuplicateSurface)IDirectDraw2_DuplicateSurface,
3457 XCAST(EnumDisplayModes)IDirectDraw2_EnumDisplayModes,
3458 XCAST(EnumSurfaces)IDirectDraw2_EnumSurfaces,
3459 XCAST(FlipToGDISurface)IDirectDraw2_FlipToGDISurface,
3460 XCAST(GetCaps)Xlib_IDirectDraw2_GetCaps,
3461 XCAST(GetDisplayMode)Xlib_IDirectDraw2_GetDisplayMode,
3462 XCAST(GetFourCCCodes)IDirectDraw2_GetFourCCCodes,
3463 XCAST(GetGDISurface)IDirectDraw2_GetGDISurface,
3464 XCAST(GetMonitorFrequency)IDirectDraw2_GetMonitorFrequency,
3465 XCAST(GetScanLine)IDirectDraw2_GetScanLine,
3466 XCAST(GetVerticalBlankStatus)IDirectDraw2_GetVerticalBlankStatus,
3467 XCAST(Initialize)IDirectDraw2_Initialize,
3468 XCAST(RestoreDisplayMode)Xlib_IDirectDraw2_RestoreDisplayMode,
3469 XCAST(SetCooperativeLevel)IDirectDraw2_SetCooperativeLevel,
3470 Xlib_IDirectDraw_SetDisplayMode,
3471 XCAST(WaitForVerticalBlank)IDirectDraw2_WaitForVerticalBlank,
3472 };
3473
3474 #undef XCAST
3475
3476 /*****************************************************************************
3477 * IDirectDraw2
3478 *
3479 */
3480
3481
3482 static HRESULT WINAPI DGA_IDirectDraw2_SetDisplayMode(
3483 LPDIRECTDRAW2 this,DWORD width,DWORD height,DWORD depth,DWORD xx,DWORD yy
3484 ) {
3485 return DGA_IDirectDraw_SetDisplayMode((LPDIRECTDRAW)this,width,height,depth);
3486 }
3487
3488 static HRESULT WINAPI Xlib_IDirectDraw2_SetDisplayMode(
3489 LPDIRECTDRAW2 this,DWORD width,DWORD height,DWORD depth,DWORD xx,DWORD yy
3490 ) {
3491 return Xlib_IDirectDraw_SetDisplayMode((LPDIRECTDRAW)this,width,height,depth);
3492 }
3493
3494 static HRESULT WINAPI DGA_IDirectDraw2_GetAvailableVidMem(
3495 LPDIRECTDRAW2 this,LPDDSCAPS ddscaps,LPDWORD total,LPDWORD free
3496 ) {
3497 TRACE(ddraw,"(%p)->(%p,%p,%p)\n",
3498 this,ddscaps,total,free
3499 );
3500 if (total) *total = this->e.dga.fb_memsize * 1024;
3501 if (free) *free = this->e.dga.fb_memsize * 1024;
3502 return DD_OK;
3503 }
3504
3505 static HRESULT WINAPI Xlib_IDirectDraw2_GetAvailableVidMem(
3506 LPDIRECTDRAW2 this,LPDDSCAPS ddscaps,LPDWORD total,LPDWORD free
3507 ) {
3508 TRACE(ddraw,"(%p)->(%p,%p,%p)\n",
3509 this,ddscaps,total,free
3510 );
3511 if (total) *total = 2048 * 1024;
3512 if (free) *free = 2048 * 1024;
3513 return DD_OK;
3514 }
3515
3516 static IDirectDraw2_VTable dga_dd2vt = {
3517 DGA_IDirectDraw2_QueryInterface,
3518 IDirectDraw2_AddRef,
3519 DGA_IDirectDraw2_Release,
3520 IDirectDraw2_Compact,
3521 IDirectDraw2_CreateClipper,
3522 DGA_IDirectDraw2_CreatePalette,
3523 DGA_IDirectDraw2_CreateSurface,
3524 IDirectDraw2_DuplicateSurface,
3525 IDirectDraw2_EnumDisplayModes,
3526 IDirectDraw2_EnumSurfaces,
3527 IDirectDraw2_FlipToGDISurface,
3528 DGA_IDirectDraw2_GetCaps,
3529 DGA_IDirectDraw2_GetDisplayMode,
3530 IDirectDraw2_GetFourCCCodes,
3531 IDirectDraw2_GetGDISurface,
3532 IDirectDraw2_GetMonitorFrequency,
3533 IDirectDraw2_GetScanLine,
3534 IDirectDraw2_GetVerticalBlankStatus,
3535 IDirectDraw2_Initialize,
3536 DGA_IDirectDraw2_RestoreDisplayMode,
3537 IDirectDraw2_SetCooperativeLevel,
3538 DGA_IDirectDraw2_SetDisplayMode,
3539 IDirectDraw2_WaitForVerticalBlank,
3540 DGA_IDirectDraw2_GetAvailableVidMem
3541 };
3542
3543 static struct IDirectDraw2_VTable xlib_dd2vt = {
3544 Xlib_IDirectDraw2_QueryInterface,
3545 IDirectDraw2_AddRef,
3546 Xlib_IDirectDraw2_Release,
3547 IDirectDraw2_Compact,
3548 IDirectDraw2_CreateClipper,
3549 Xlib_IDirectDraw2_CreatePalette,
3550 Xlib_IDirectDraw2_CreateSurface,
3551 IDirectDraw2_DuplicateSurface,
3552 IDirectDraw2_EnumDisplayModes,
3553 IDirectDraw2_EnumSurfaces,
3554 IDirectDraw2_FlipToGDISurface,
3555 Xlib_IDirectDraw2_GetCaps,
3556 Xlib_IDirectDraw2_GetDisplayMode,
3557 IDirectDraw2_GetFourCCCodes,
3558 IDirectDraw2_GetGDISurface,
3559 IDirectDraw2_GetMonitorFrequency,
3560 IDirectDraw2_GetScanLine,
3561 IDirectDraw2_GetVerticalBlankStatus,
3562 IDirectDraw2_Initialize,
3563 Xlib_IDirectDraw2_RestoreDisplayMode,
3564 IDirectDraw2_SetCooperativeLevel,
3565 Xlib_IDirectDraw2_SetDisplayMode,
3566 IDirectDraw2_WaitForVerticalBlank,
3567 Xlib_IDirectDraw2_GetAvailableVidMem
3568 };
3569
3570 /*****************************************************************************
3571 * IDirectDraw4
3572 *
3573 */
3574
3575 static HRESULT WINAPI IDirectDraw4_GetSurfaceFromDC(LPDIRECTDRAW4 this,
3576 HDC32 hdc,
3577 LPDIRECTDRAWSURFACE *lpDDS) {
3578 FIXME(ddraw, "(%p)->(%08ld,%p)\n", this, (DWORD) hdc, lpDDS);
3579
3580 return DD_OK;
3581 }
3582
3583 static HRESULT WINAPI IDirectDraw4_RestoreAllSurfaces(LPDIRECTDRAW4 this) {
3584 FIXME(ddraw, "(%p)->()\n", this);
3585
3586 return DD_OK;
3587 }
3588
3589 static HRESULT WINAPI IDirectDraw4_TestCooperativeLevel(LPDIRECTDRAW4 this) {
3590 FIXME(ddraw, "(%p)->()\n", this);
3591
3592 return DD_OK;
3593 }
3594
3595 static HRESULT WINAPI IDirectDraw4_GetDeviceIdentifier(LPDIRECTDRAW4 this,
3596 LPDDDEVICEIDENTIFIER lpdddi,
3597 DWORD dwFlags) {
3598 FIXME(ddraw, "(%p)->(%p,%08lx)\n", this, lpdddi, dwFlags);
3599
3600 return DD_OK;
3601 }
3602
3603 #ifdef __GNUC__
3604 # define XCAST(fun) (typeof(dga_dd4vt.fn##fun))
3605 #else
3606 # define XCAST(fun) (void*)
3607 #endif
3608
3609
3610 static struct IDirectDraw4_VTable dga_dd4vt = {
3611 XCAST(QueryInterface)DGA_IDirectDraw2_QueryInterface,
3612 XCAST(AddRef)IDirectDraw2_AddRef,
3613 XCAST(Release)DGA_IDirectDraw2_Release,
3614 XCAST(Compact)IDirectDraw2_Compact,
3615 XCAST(CreateClipper)IDirectDraw2_CreateClipper,
3616 XCAST(CreatePalette)DGA_IDirectDraw2_CreatePalette,
3617 XCAST(CreateSurface)DGA_IDirectDraw2_CreateSurface,
3618 XCAST(DuplicateSurface)IDirectDraw2_DuplicateSurface,
3619 XCAST(EnumDisplayModes)IDirectDraw2_EnumDisplayModes,
3620 XCAST(EnumSurfaces)IDirectDraw2_EnumSurfaces,
3621 XCAST(FlipToGDISurface)IDirectDraw2_FlipToGDISurface,
3622 XCAST(GetCaps)DGA_IDirectDraw2_GetCaps,
3623 XCAST(GetDisplayMode)DGA_IDirectDraw2_GetDisplayMode,
3624 XCAST(GetFourCCCodes)IDirectDraw2_GetFourCCCodes,
3625 XCAST(GetGDISurface)IDirectDraw2_GetGDISurface,
3626 XCAST(GetMonitorFrequency)IDirectDraw2_GetMonitorFrequency,
3627 XCAST(GetScanLine)IDirectDraw2_GetScanLine,
3628 XCAST(GetVerticalBlankStatus)IDirectDraw2_GetVerticalBlankStatus,
3629 XCAST(Initialize)IDirectDraw2_Initialize,
3630 XCAST(RestoreDisplayMode)DGA_IDirectDraw2_RestoreDisplayMode,
3631 XCAST(SetCooperativeLevel)IDirectDraw2_SetCooperativeLevel,
3632 XCAST(SetDisplayMode)DGA_IDirectDraw_SetDisplayMode,
3633 XCAST(WaitForVerticalBlank)IDirectDraw2_WaitForVerticalBlank,
3634 XCAST(GetAvailableVidMem)DGA_IDirectDraw2_GetAvailableVidMem,
3635 IDirectDraw4_GetSurfaceFromDC,
3636 IDirectDraw4_RestoreAllSurfaces,
3637 IDirectDraw4_TestCooperativeLevel,
3638 IDirectDraw4_GetDeviceIdentifier
3639 };
3640
3641 static struct IDirectDraw4_VTable xlib_dd4vt = {
3642 XCAST(QueryInterface)Xlib_IDirectDraw2_QueryInterface,
3643 XCAST(AddRef)IDirectDraw2_AddRef,
3644 XCAST(Release)Xlib_IDirectDraw2_Release,
3645 XCAST(Compact)IDirectDraw2_Compact,
3646 XCAST(CreateClipper)IDirectDraw2_CreateClipper,
3647 XCAST(CreatePalette)Xlib_IDirectDraw2_CreatePalette,
3648 XCAST(CreateSurface)Xlib_IDirectDraw2_CreateSurface,
3649 XCAST(DuplicateSurface)IDirectDraw2_DuplicateSurface,
3650 XCAST(EnumDisplayModes)IDirectDraw2_EnumDisplayModes,
3651 XCAST(EnumSurfaces)IDirectDraw2_EnumSurfaces,
3652 XCAST(FlipToGDISurface)IDirectDraw2_FlipToGDISurface,
3653 XCAST(GetCaps)Xlib_IDirectDraw2_GetCaps,
3654 XCAST(GetDisplayMode)Xlib_IDirectDraw2_GetDisplayMode,
3655 XCAST(GetFourCCCodes)IDirectDraw2_GetFourCCCodes,
3656 XCAST(GetGDISurface)IDirectDraw2_GetGDISurface,
3657 XCAST(GetMonitorFrequency)IDirectDraw2_GetMonitorFrequency,
3658 XCAST(GetScanLine)IDirectDraw2_GetScanLine,
3659 XCAST(GetVerticalBlankStatus)IDirectDraw2_GetVerticalBlankStatus,
3660 XCAST(Initialize)IDirectDraw2_Initialize,
3661 XCAST(RestoreDisplayMode)Xlib_IDirectDraw2_RestoreDisplayMode,
3662 XCAST(SetCooperativeLevel)IDirectDraw2_SetCooperativeLevel,
3663 XCAST(SetDisplayMode)Xlib_IDirectDraw_SetDisplayMode,
3664 XCAST(WaitForVerticalBlank)IDirectDraw2_WaitForVerticalBlank,
3665 XCAST(GetAvailableVidMem)Xlib_IDirectDraw2_GetAvailableVidMem,
3666 IDirectDraw4_GetSurfaceFromDC,
3667 IDirectDraw4_RestoreAllSurfaces,
3668 IDirectDraw4_TestCooperativeLevel,
3669 IDirectDraw4_GetDeviceIdentifier
3670 };
3671
3672 #undef XCAST
3673
3674 /******************************************************************************
3675 * DirectDrawCreate
3676 */
3677
3678 LRESULT WINAPI Xlib_DDWndProc(HWND32 hwnd,UINT32 msg,WPARAM32 wParam,LPARAM lParam)
3679 {
3680 LRESULT ret;
3681 LPDIRECTDRAW ddraw = NULL;
3682 DWORD lastError;
3683
3684 /* FIXME(ddraw,"(0x%04x,%s,0x%08lx,0x%08lx),stub!\n",(int)hwnd,SPY_GetMsgName(msg),(long)wParam,(long)lParam); */
3685
3686 SetLastError( ERROR_SUCCESS );
3687 ddraw = (LPDIRECTDRAW)GetWindowLong32A( hwnd, ddrawXlibThisOffset );
3688 if( (!ddraw) &&
3689 ( ( lastError = GetLastError() ) != ERROR_SUCCESS )
3690 )
3691 {
3692 ERR( ddraw, "Unable to retrieve this ptr from window. Error %08lx\n", lastError );
3693 }
3694
3695 if( ddraw )
3696 {
3697 /* Perform any special direct draw functions */
3698 if (msg==WM_PAINT)
3699 ddraw->d.paintable = 1;
3700
3701 /* Now let the application deal with the rest of this */
3702 if( ddraw->d.mainWindow )
3703 {
3704
3705 /* Don't think that we actually need to call this but...
3706 might as well be on the safe side of things... */
3707
3708 /* I changed hwnd to ddraw->d.mainWindow as I did not see why
3709 it should be the procedures of our fake window that gets called
3710 instead of those of the window provided by the application.
3711 And with this patch, mouse clicks work with Monkey Island III
3712 - Lionel */
3713 ret = DefWindowProc32A( ddraw->d.mainWindow, msg, wParam, lParam );
3714
3715 if( !ret )
3716 {
3717 /* We didn't handle the message - give it to the application */
3718 if (ddraw && ddraw->d.mainWindow && WIN_FindWndPtr(ddraw->d.mainWindow)) {
3719 ret = CallWindowProc32A( WIN_FindWndPtr( ddraw->d.mainWindow )->winproc,
3720 ddraw->d.mainWindow, msg, wParam, lParam );
3721 }
3722 }
3723
3724 } else {
3725 ret = DefWindowProc32A(hwnd, msg, wParam, lParam );
3726 }
3727
3728 }
3729 else
3730 {
3731 ret = DefWindowProc32A(hwnd,msg,wParam,lParam);
3732 }
3733
3734 return ret;
3735 }
3736
3737 HRESULT WINAPI DGA_DirectDrawCreate( LPDIRECTDRAW *lplpDD, LPUNKNOWN pUnkOuter) {
3738 #ifdef HAVE_LIBXXF86DGA
3739 int memsize,banksize,width,major,minor,flags,height;
3740 char *addr;
3741 int fd;
3742
3743 /* Must be able to access /dev/mem for DGA extensions to work, root is not neccessary. --stephenc */
3744 if ((fd = open("/dev/mem", O_RDWR)) != -1)
3745 close(fd);
3746
3747 if (fd == -1) {
3748 MSG("Must be able to access /dev/mem to use XF86DGA!\n");
3749 MessageBox32A(0,"Using the XF86DGA extension requires access to /dev/mem.","WINE DirectDraw",MB_OK|MB_ICONSTOP);
3750 return E_UNEXPECTED;
3751 }
3752 if (!DDRAW_DGA_Available()) {
3753 TRACE(ddraw,"No XF86DGA detected.\n");
3754 return DDERR_GENERIC;
3755 }
3756 *lplpDD = (LPDIRECTDRAW)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDraw));
3757 (*lplpDD)->lpvtbl = &dga_ddvt;
3758 (*lplpDD)->ref = 1;
3759 TSXF86DGAQueryVersion(display,&major,&minor);
3760 TRACE(ddraw,"XF86DGA is version %d.%d\n",major,minor);
3761 TSXF86DGAQueryDirectVideo(display,DefaultScreen(display),&flags);
3762 if (!(flags & XF86DGADirectPresent))
3763 MSG("direct video is NOT PRESENT.\n");
3764 TSXF86DGAGetVideo(display,DefaultScreen(display),&addr,&width,&banksize,&memsize);
3765 TRACE(ddraw,"video framebuffer: begin %p, width %d,banksize %d,memsize %d\n",
3766 addr,width,banksize,memsize
3767 );
3768 (*lplpDD)->e.dga.fb_width = width;
3769 (*lplpDD)->d.width = width;
3770 (*lplpDD)->e.dga.fb_addr = addr;
3771 (*lplpDD)->e.dga.fb_memsize = memsize;
3772 (*lplpDD)->e.dga.fb_banksize = banksize;
3773
3774 TSXF86DGAGetViewPortSize(display,DefaultScreen(display),&width,&height);
3775 TSXF86DGASetViewPort(display,DefaultScreen(display),0,0);
3776 (*lplpDD)->e.dga.fb_height = MONITOR_GetHeight(&MONITOR_PrimaryMonitor);
3777 #ifdef DIABLO_HACK
3778 (*lplpDD)->e.dga.vpmask = 1;
3779 #else
3780 (*lplpDD)->e.dga.vpmask = 0;
3781 #endif
3782
3783 /* just assume the default depth is the DGA depth too */
3784 (*lplpDD)->d.screen_depth = DefaultDepthOfScreen(X11DRV_GetXScreen());
3785 (*lplpDD)->d.depth = DefaultDepthOfScreen(X11DRV_GetXScreen());
3786 #ifdef RESTORE_SIGNALS
3787 SIGNAL_InitHandlers();
3788 #endif
3789
3790 return DD_OK;
3791 #else /* defined(HAVE_LIBXXF86DGA) */
3792 return DDERR_INVALIDDIRECTDRAWGUID;
3793 #endif /* defined(HAVE_LIBXXF86DGA) */
3794 }
3795
3796 BOOL32
3797 DDRAW_XSHM_Available(void)
3798 {
3799 #ifdef HAVE_LIBXXSHM
3800 if (TSXShmQueryExtension(display))
3801 {
3802 int major, minor;
3803 Bool shpix;
3804
3805 if (TSXShmQueryVersion(display, &major, &minor, &shpix))
3806 return 1;
3807 else
3808 return 0;
3809 }
3810 else
3811 return 0;
3812 #else
3813 return 0;
3814 #endif
3815 }
3816
3817 HRESULT WINAPI Xlib_DirectDrawCreate( LPDIRECTDRAW *lplpDD, LPUNKNOWN pUnkOuter) {
3818
3819 *lplpDD = (LPDIRECTDRAW)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDraw));
3820 (*lplpDD)->lpvtbl = &xlib_ddvt;
3821 (*lplpDD)->ref = 1;
3822 (*lplpDD)->d.drawable = 0; /* in SetDisplayMode */
3823
3824 /* At DirectDraw creation, the depth is the default depth */
3825 (*lplpDD)->d.depth = DefaultDepthOfScreen(X11DRV_GetXScreen());
3826 (*lplpDD)->d.screen_depth = DefaultDepthOfScreen(X11DRV_GetXScreen());
3827 (*lplpDD)->d.height = MONITOR_GetHeight(&MONITOR_PrimaryMonitor);
3828 (*lplpDD)->d.width = MONITOR_GetWidth(&MONITOR_PrimaryMonitor);
3829
3830 #ifdef HAVE_LIBXXSHM
3831 /* Test if XShm is available. */
3832 if (((*lplpDD)->e.xlib.xshm_active = DDRAW_XSHM_Available()))
3833 TRACE(ddraw, "Using XShm extension.\n");
3834 #endif
3835
3836 return DD_OK;
3837 }
3838
3839 HRESULT WINAPI DirectDrawCreate( LPGUID lpGUID, LPDIRECTDRAW *lplpDD, LPUNKNOWN pUnkOuter ) {
3840 char xclsid[50];
3841 WNDCLASS32A wc;
3842 WND* pParentWindow;
3843 HRESULT ret;
3844
3845 if (HIWORD(lpGUID))
3846 WINE_StringFromCLSID(lpGUID,xclsid);
3847 else {
3848 sprintf(xclsid,"<guid-0x%08x>",(int)lpGUID);
3849 lpGUID = NULL;
3850 }
3851
3852 TRACE(ddraw,"(%s,%p,%p)\n",xclsid,lplpDD,pUnkOuter);
3853
3854 if (!lpGUID) {
3855 /* if they didn't request a particular interface, use the best
3856 * supported one */
3857 if (DDRAW_DGA_Available())
3858 lpGUID = &DGA_DirectDraw_GUID;
3859 else
3860 lpGUID = &XLIB_DirectDraw_GUID;
3861 }
3862
3863 wc.style = CS_GLOBALCLASS;
3864 wc.lpfnWndProc = Xlib_DDWndProc;
3865 wc.cbClsExtra = 0;
3866 wc.cbWndExtra = /* Defines extra mem for window. This is used for storing this */
3867 sizeof( LPDIRECTDRAW ); /* ddrawXlibThisOffset */
3868
3869 /* We can be a child of the desktop since we're really important */
3870 pParentWindow = WIN_GetDesktop();
3871 wc.hInstance = pParentWindow ? pParentWindow->hwndSelf : 0;
3872 wc.hInstance = 0;
3873
3874 wc.hIcon = 0;
3875 wc.hCursor = (HCURSOR32)IDC_ARROW32A;
3876 wc.hbrBackground= NULL_BRUSH;
3877 wc.lpszMenuName = 0;
3878 wc.lpszClassName= "WINE_DirectDraw";
3879 RegisterClass32A(&wc);
3880
3881 if (!memcmp(lpGUID, &DGA_DirectDraw_GUID, sizeof(GUID)))
3882 ret = DGA_DirectDrawCreate(lplpDD, pUnkOuter);
3883 else if (!memcmp(lpGUID, &XLIB_DirectDraw_GUID, sizeof(GUID)))
3884 ret = Xlib_DirectDrawCreate(lplpDD, pUnkOuter);
3885 else
3886 goto err;
3887
3888
3889 (*lplpDD)->d.winclass = RegisterClass32A(&wc);
3890 return ret;
3891
3892 err:
3893 fprintf(stderr,"DirectDrawCreate(%s,%p,%p): did not recognize requested GUID\n",xclsid,lplpDD,pUnkOuter);
3894 return DDERR_INVALIDDIRECTDRAWGUID;
3895 }
Windows API implementation