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