git.oblomov.eu Git - wine/blob - dlls/ddraw/helper.c

   1
   2 /*              DirectDraw Base Functions
   3  *
   4  * Copyright 1997-1999 Marcus Meissner
   5  * Copyright 1998 Lionel Ulmer (most of Direct3D stuff)
   6  * Copyright 2000 TransGaming Technologies Inc.
   7  */
   8
   9 #include "config.h"
  10
  11 #include <stddef.h>
  12
  13 #include "winerror.h"
  14 #include "heap.h"
  15 #include "wine/exception.h"
  16 #include "ddraw.h"
  17 #include "d3d.h"
  18 #include "debugtools.h"
  19 #include "options.h"
  20
  21 DEFAULT_DEBUG_CHANNEL(ddraw);
  22
  23 /******************************************************************************
  24  *              debug output functions
  25  */
  26 typedef struct
  27 {
  28     DWORD val;
  29     const char* name;
  30 } flag_info;
  31
  32 #define FE(x) { x, #x }
  33
  34 typedef struct
  35 {
  36     DWORD val;
  37     const char* name;
  38     void (*func)(const void *);
  39     ptrdiff_t offset;
  40 } member_info;
  41
  42 #define ME(x,f,e) { x, #x, (void (*)(const void *))(f), offsetof(STRUCT, e) }
  43
  44 static void DDRAW_dump_flags(DWORD flags, const flag_info* names,
  45                              size_t num_names)
  46 {
  47     int i;
  48
  49     for (i=0; i < num_names; i++)
  50         if (names[i].val & flags)
  51             DPRINTF("%s ", names[i].name);
  52
  53     DPRINTF("\n");
  54 }
  55
  56 static void DDRAW_dump_members(DWORD flags, const void* data,
  57                                const member_info* mems, size_t num_mems)
  58 {
  59     int i;
  60
  61     for (i=0; i < sizeof(mems)/sizeof(mems[0]); i++)
  62     {
  63         if (mems[i].val & flags)
  64         {
  65             DPRINTF(" - %s : ", mems[i].name);
  66             mems[i].func((const char *)data + mems[i].offset);
  67             DPRINTF("\n");
  68         }
  69     }
  70 }
  71
  72 void DDRAW_dump_DDBLTFX(DWORD flagmask)
  73 {
  74     static const flag_info flags[] =
  75         {
  76             FE(DDBLTFX_ARITHSTRETCHY),
  77             FE(DDBLTFX_MIRRORLEFTRIGHT),
  78             FE(DDBLTFX_MIRRORUPDOWN),
  79             FE(DDBLTFX_NOTEARING),
  80             FE(DDBLTFX_ROTATE180),
  81             FE(DDBLTFX_ROTATE270),
  82             FE(DDBLTFX_ROTATE90),
  83             FE(DDBLTFX_ZBUFFERRANGE),
  84             FE(DDBLTFX_ZBUFFERBASEDEST)
  85         };
  86
  87     DDRAW_dump_flags(flagmask, flags, sizeof(flags)/sizeof(flags[0]));
  88 }
  89
  90 void DDRAW_dump_DDBLTFAST(DWORD flagmask)
  91 {
  92     static const flag_info flags[] =
  93         {
  94             FE(DDBLTFAST_NOCOLORKEY),
  95             FE(DDBLTFAST_SRCCOLORKEY),
  96             FE(DDBLTFAST_DESTCOLORKEY),
  97             FE(DDBLTFAST_WAIT)
  98         };
  99
 100     DDRAW_dump_flags(flagmask, flags, sizeof(flags)/sizeof(flags[0]));
 101 }
 102
 103 void DDRAW_dump_DDBLT(DWORD flagmask)
 104 {
 105     static const flag_info flags[] =
 106         {
 107             FE(DDBLT_ALPHADEST),
 108             FE(DDBLT_ALPHADESTCONSTOVERRIDE),
 109             FE(DDBLT_ALPHADESTNEG),
 110             FE(DDBLT_ALPHADESTSURFACEOVERRIDE),
 111             FE(DDBLT_ALPHAEDGEBLEND),
 112             FE(DDBLT_ALPHASRC),
 113             FE(DDBLT_ALPHASRCCONSTOVERRIDE),
 114             FE(DDBLT_ALPHASRCNEG),
 115             FE(DDBLT_ALPHASRCSURFACEOVERRIDE),
 116             FE(DDBLT_ASYNC),
 117             FE(DDBLT_COLORFILL),
 118             FE(DDBLT_DDFX),
 119             FE(DDBLT_DDROPS),
 120             FE(DDBLT_KEYDEST),
 121             FE(DDBLT_KEYDESTOVERRIDE),
 122             FE(DDBLT_KEYSRC),
 123             FE(DDBLT_KEYSRCOVERRIDE),
 124             FE(DDBLT_ROP),
 125             FE(DDBLT_ROTATIONANGLE),
 126             FE(DDBLT_ZBUFFER),
 127             FE(DDBLT_ZBUFFERDESTCONSTOVERRIDE),
 128             FE(DDBLT_ZBUFFERDESTOVERRIDE),
 129             FE(DDBLT_ZBUFFERSRCCONSTOVERRIDE),
 130             FE(DDBLT_ZBUFFERSRCOVERRIDE),
 131             FE(DDBLT_WAIT),
 132             FE(DDBLT_DEPTHFILL)
 133     };
 134
 135     DDRAW_dump_flags(flagmask, flags, sizeof(flags)/sizeof(flags[0]));
 136 }
 137
 138 void DDRAW_dump_DDSCAPS(const DDSCAPS2 *in)
 139 {
 140     static const flag_info flags[] =
 141         {
 142             FE(DDSCAPS_RESERVED1),
 143             FE(DDSCAPS_ALPHA),
 144             FE(DDSCAPS_BACKBUFFER),
 145             FE(DDSCAPS_COMPLEX),
 146             FE(DDSCAPS_FLIP),
 147             FE(DDSCAPS_FRONTBUFFER),
 148             FE(DDSCAPS_OFFSCREENPLAIN),
 149             FE(DDSCAPS_OVERLAY),
 150             FE(DDSCAPS_PALETTE),
 151             FE(DDSCAPS_PRIMARYSURFACE),
 152             FE(DDSCAPS_PRIMARYSURFACELEFT),
 153             FE(DDSCAPS_SYSTEMMEMORY),
 154             FE(DDSCAPS_TEXTURE),
 155             FE(DDSCAPS_3DDEVICE),
 156             FE(DDSCAPS_VIDEOMEMORY),
 157             FE(DDSCAPS_VISIBLE),
 158             FE(DDSCAPS_WRITEONLY),
 159             FE(DDSCAPS_ZBUFFER),
 160             FE(DDSCAPS_OWNDC),
 161             FE(DDSCAPS_LIVEVIDEO),
 162             FE(DDSCAPS_HWCODEC),
 163             FE(DDSCAPS_MODEX),
 164             FE(DDSCAPS_MIPMAP),
 165             FE(DDSCAPS_RESERVED2),
 166             FE(DDSCAPS_ALLOCONLOAD),
 167             FE(DDSCAPS_VIDEOPORT),
 168             FE(DDSCAPS_LOCALVIDMEM),
 169             FE(DDSCAPS_NONLOCALVIDMEM),
 170             FE(DDSCAPS_STANDARDVGAMODE),
 171             FE(DDSCAPS_OPTIMIZED)
 172     };
 173
 174     DDRAW_dump_flags(in->dwCaps, flags, sizeof(flags)/sizeof(flags[0]));
 175 }
 176
 177 void DDRAW_dump_pixelformat_flag(DWORD flagmask)
 178 {
 179     static const flag_info flags[] =
 180         {
 181             FE(DDPF_ALPHAPIXELS),
 182             FE(DDPF_ALPHA),
 183             FE(DDPF_FOURCC),
 184             FE(DDPF_PALETTEINDEXED4),
 185             FE(DDPF_PALETTEINDEXEDTO8),
 186             FE(DDPF_PALETTEINDEXED8),
 187             FE(DDPF_RGB),
 188             FE(DDPF_COMPRESSED),
 189             FE(DDPF_RGBTOYUV),
 190             FE(DDPF_YUV),
 191             FE(DDPF_ZBUFFER),
 192             FE(DDPF_PALETTEINDEXED1),
 193             FE(DDPF_PALETTEINDEXED2),
 194             FE(DDPF_ZPIXELS)
 195     };
 196
 197     DDRAW_dump_flags(flagmask, flags, sizeof(flags)/sizeof(flags[0]));
 198 }
 199
 200 void DDRAW_dump_paletteformat(DWORD dwFlags)
 201 {
 202     static const flag_info flags[] =
 203         {
 204             FE(DDPCAPS_4BIT),
 205             FE(DDPCAPS_8BITENTRIES),
 206             FE(DDPCAPS_8BIT),
 207             FE(DDPCAPS_INITIALIZE),
 208             FE(DDPCAPS_PRIMARYSURFACE),
 209             FE(DDPCAPS_PRIMARYSURFACELEFT),
 210             FE(DDPCAPS_ALLOW256),
 211             FE(DDPCAPS_VSYNC),
 212             FE(DDPCAPS_1BIT),
 213             FE(DDPCAPS_2BIT),
 214             FE(DDPCAPS_ALPHA)
 215     };
 216
 217     DDRAW_dump_flags(dwFlags, flags, sizeof(flags)/sizeof(flags[0]));
 218 }
 219
 220 void DDRAW_dump_pixelformat(void *in) {
 221     LPDDPIXELFORMAT pf = (LPDDPIXELFORMAT) in;
 222
 223     DPRINTF("( ");
 224     DDRAW_dump_pixelformat_flag(pf->dwFlags);
 225     if (pf->dwFlags & DDPF_FOURCC) {
 226         DPRINTF(", dwFourCC code '%c%c%c%c' (0x%08lx) - %ld bits per pixel",
 227                 (unsigned char)( pf->dwFourCC     &0xff),
 228                 (unsigned char)((pf->dwFourCC>> 8)&0xff),
 229                 (unsigned char)((pf->dwFourCC>>16)&0xff),
 230                 (unsigned char)((pf->dwFourCC>>24)&0xff),
 231                 pf->dwFourCC,
 232                 pf->u1.dwYUVBitCount
 233         );
 234     }
 235     if (pf->dwFlags & DDPF_RGB) {
 236         char *cmd;
 237         DPRINTF(", RGB bits: %ld, ", pf->u1.dwRGBBitCount);
 238         switch (pf->u1.dwRGBBitCount) {
 239         case 4: cmd = "%1lx"; break;
 240         case 8: cmd = "%02lx"; break;
 241         case 16: cmd = "%04lx"; break;
 242         case 24: cmd = "%06lx"; break;
 243         case 32: cmd = "%08lx"; break;
 244         default: ERR("Unexpected bit depth !\n"); cmd = "%d"; break;
 245         }
 246         DPRINTF(" R "); DPRINTF(cmd, pf->u2.dwRBitMask);
 247         DPRINTF(" G "); DPRINTF(cmd, pf->u3.dwGBitMask);
 248         DPRINTF(" B "); DPRINTF(cmd, pf->u4.dwBBitMask);
 249         if (pf->dwFlags & DDPF_ALPHAPIXELS) {
 250             DPRINTF(" A "); DPRINTF(cmd, pf->u5.dwRGBAlphaBitMask);
 251         }
 252         if (pf->dwFlags & DDPF_ZPIXELS) {
 253             DPRINTF(" Z "); DPRINTF(cmd, pf->u5.dwRGBZBitMask);
 254         }
 255     }
 256     if (pf->dwFlags & DDPF_ZBUFFER) {
 257         DPRINTF(", Z bits : %ld", pf->u1.dwZBufferBitDepth);
 258     }
 259     if (pf->dwFlags & DDPF_ALPHA) {
 260         DPRINTF(", Alpha bits : %ld", pf->u1.dwAlphaBitDepth);
 261     }
 262     DPRINTF(")");
 263 }
 264
 265 void DDRAW_dump_colorkeyflag(DWORD ck)
 266 {
 267     static const flag_info flags[] =
 268         {
 269             FE(DDCKEY_COLORSPACE),
 270             FE(DDCKEY_DESTBLT),
 271             FE(DDCKEY_DESTOVERLAY),
 272             FE(DDCKEY_SRCBLT),
 273             FE(DDCKEY_SRCOVERLAY)
 274     };
 275
 276     DDRAW_dump_flags(ck, flags, sizeof(flags)/sizeof(flags[0]));
 277 }
 278
 279 static void DDRAW_dump_DWORD(const void *in) {
 280     DPRINTF("%ld", *((const DWORD *) in));
 281 }
 282 static void DDRAW_dump_PTR(const void *in) {
 283     DPRINTF("%p", *((const void **) in));
 284 }
 285 void DDRAW_dump_DDCOLORKEY(const void *in) {
 286     const DDCOLORKEY *ddck = (const DDCOLORKEY *) in;
 287
 288     DPRINTF(" Low : %ld  - High : %ld", ddck->dwColorSpaceLowValue, ddck->dwColorSpaceHighValue);
 289 }
 290
 291 void DDRAW_dump_surface_desc(const DDSURFACEDESC2 *lpddsd)
 292 {
 293 #define STRUCT DDSURFACEDESC2
 294     static const member_info members[] =
 295         {
 296             ME(DDSD_CAPS, DDRAW_dump_DDSCAPS, ddsCaps),
 297             ME(DDSD_HEIGHT, DDRAW_dump_DWORD, dwHeight),
 298             ME(DDSD_WIDTH, DDRAW_dump_DWORD, dwWidth),
 299             ME(DDSD_PITCH, DDRAW_dump_DWORD, u1.lPitch),
 300             ME(DDSD_LINEARSIZE, DDRAW_dump_DWORD, u1.dwLinearSize),
 301             ME(DDSD_BACKBUFFERCOUNT, DDRAW_dump_DWORD, dwBackBufferCount),
 302             ME(DDSD_MIPMAPCOUNT, DDRAW_dump_DWORD, u2.dwMipMapCount),
 303             ME(DDSD_REFRESHRATE, DDRAW_dump_DWORD, u2.dwRefreshRate),
 304             ME(DDSD_ALPHABITDEPTH, DDRAW_dump_DWORD, dwAlphaBitDepth),
 305             ME(DDSD_LPSURFACE, DDRAW_dump_PTR, lpSurface),
 306             ME(DDSD_CKDESTOVERLAY, DDRAW_dump_DDCOLORKEY, u3.ddckCKDestOverlay),
 307             ME(DDSD_CKDESTBLT, DDRAW_dump_DDCOLORKEY, ddckCKDestBlt),
 308             ME(DDSD_CKSRCOVERLAY, DDRAW_dump_DDCOLORKEY, ddckCKSrcOverlay),
 309             ME(DDSD_CKSRCBLT, DDRAW_dump_DDCOLORKEY, ddckCKSrcBlt),
 310             ME(DDSD_PIXELFORMAT, DDRAW_dump_pixelformat, u4.ddpfPixelFormat)
 311         };
 312
 313     DDRAW_dump_members(lpddsd->dwFlags, lpddsd, members,
 314                        sizeof(members)/sizeof(members[0]));
 315 }
 316
 317 void DDRAW_dump_cooperativelevel(DWORD cooplevel)
 318 {
 319     static const flag_info flags[] =
 320         {
 321             FE(DDSCL_FULLSCREEN),
 322             FE(DDSCL_ALLOWREBOOT),
 323             FE(DDSCL_NOWINDOWCHANGES),
 324             FE(DDSCL_NORMAL),
 325             FE(DDSCL_ALLOWMODEX),
 326             FE(DDSCL_EXCLUSIVE),
 327             FE(DDSCL_SETFOCUSWINDOW),
 328             FE(DDSCL_SETDEVICEWINDOW),
 329             FE(DDSCL_CREATEDEVICEWINDOW)
 330     };
 331
 332     if (TRACE_ON(ddraw))
 333     {
 334         DPRINTF(" - ");
 335         DDRAW_dump_flags(cooplevel, flags, sizeof(flags)/sizeof(flags[0]));
 336     }
 337 }