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
  21 #include "debugtools.h"
  22
  23 DEFAULT_DEBUG_CHANNEL(ddraw);
  24
  25 /******************************************************************************
  26  *              debug output functions
  27  */
  28 typedef struct
  29 {
  30     DWORD val;
  31     const char* name;
  32 } flag_info;
  33
  34 #define FE(x) { x, #x }
  35
  36 typedef struct
  37 {
  38     DWORD val;
  39     const char* name;
  40     void (*func)(const void *);
  41     ptrdiff_t offset;
  42 } member_info;
  43
  44 #define ME(x,f,e) { x, #x, (void (*)(const void *))(f), offsetof(STRUCT, e) }
  45
  46 static void DDRAW_dump_flags(DWORD flags, const flag_info* names,
  47                              size_t num_names)
  48 {
  49     int i;
  50
  51     for (i=0; i < num_names; i++)
  52         if (names[i].val & flags)
  53             DPRINTF("%s ", names[i].name);
  54
  55     DPRINTF("\n");
  56 }
  57
  58 static void DDRAW_dump_members(DWORD flags, const void* data,
  59                                const member_info* mems, size_t num_mems)
  60 {
  61     int i;
  62
  63     for (i=0; i < sizeof(mems)/sizeof(mems[0]); i++)
  64     {
  65         if (mems[i].val & flags)
  66         {
  67             DPRINTF(" - %s : ", mems[i].name);
  68             mems[i].func((const char *)data + mems[i].offset);
  69             DPRINTF("\n");
  70         }
  71     }
  72 }
  73
  74 void DDRAW_dump_DDBLTFX(DWORD flagmask)
  75 {
  76     static const flag_info flags[] =
  77         {
  78             FE(DDBLTFX_ARITHSTRETCHY),
  79             FE(DDBLTFX_MIRRORLEFTRIGHT),
  80             FE(DDBLTFX_MIRRORUPDOWN),
  81             FE(DDBLTFX_NOTEARING),
  82             FE(DDBLTFX_ROTATE180),
  83             FE(DDBLTFX_ROTATE270),
  84             FE(DDBLTFX_ROTATE90),
  85             FE(DDBLTFX_ZBUFFERRANGE),
  86             FE(DDBLTFX_ZBUFFERBASEDEST)
  87         };
  88
  89     DDRAW_dump_flags(flagmask, flags, sizeof(flags)/sizeof(flags[0]));
  90 }
  91
  92 void DDRAW_dump_DDBLTFAST(DWORD flagmask)
  93 {
  94     static const flag_info flags[] =
  95         {
  96             FE(DDBLTFAST_NOCOLORKEY),
  97             FE(DDBLTFAST_SRCCOLORKEY),
  98             FE(DDBLTFAST_DESTCOLORKEY),
  99             FE(DDBLTFAST_WAIT)
 100         };
 101
 102     DDRAW_dump_flags(flagmask, flags, sizeof(flags)/sizeof(flags[0]));
 103 }
 104
 105 void DDRAW_dump_DDBLT(DWORD flagmask)
 106 {
 107     static const flag_info flags[] =
 108         {
 109             FE(DDBLT_ALPHADEST),
 110             FE(DDBLT_ALPHADESTCONSTOVERRIDE),
 111             FE(DDBLT_ALPHADESTNEG),
 112             FE(DDBLT_ALPHADESTSURFACEOVERRIDE),
 113             FE(DDBLT_ALPHAEDGEBLEND),
 114             FE(DDBLT_ALPHASRC),
 115             FE(DDBLT_ALPHASRCCONSTOVERRIDE),
 116             FE(DDBLT_ALPHASRCNEG),
 117             FE(DDBLT_ALPHASRCSURFACEOVERRIDE),
 118             FE(DDBLT_ASYNC),
 119             FE(DDBLT_COLORFILL),
 120             FE(DDBLT_DDFX),
 121             FE(DDBLT_DDROPS),
 122             FE(DDBLT_KEYDEST),
 123             FE(DDBLT_KEYDESTOVERRIDE),
 124             FE(DDBLT_KEYSRC),
 125             FE(DDBLT_KEYSRCOVERRIDE),
 126             FE(DDBLT_ROP),
 127             FE(DDBLT_ROTATIONANGLE),
 128             FE(DDBLT_ZBUFFER),
 129             FE(DDBLT_ZBUFFERDESTCONSTOVERRIDE),
 130             FE(DDBLT_ZBUFFERDESTOVERRIDE),
 131             FE(DDBLT_ZBUFFERSRCCONSTOVERRIDE),
 132             FE(DDBLT_ZBUFFERSRCOVERRIDE),
 133             FE(DDBLT_WAIT),
 134             FE(DDBLT_DEPTHFILL)
 135     };
 136
 137     DDRAW_dump_flags(flagmask, flags, sizeof(flags)/sizeof(flags[0]));
 138 }
 139
 140 void DDRAW_dump_DDSCAPS(const DDSCAPS2 *in)
 141 {
 142     static const flag_info flags[] =
 143         {
 144             FE(DDSCAPS_RESERVED1),
 145             FE(DDSCAPS_ALPHA),
 146             FE(DDSCAPS_BACKBUFFER),
 147             FE(DDSCAPS_COMPLEX),
 148             FE(DDSCAPS_FLIP),
 149             FE(DDSCAPS_FRONTBUFFER),
 150             FE(DDSCAPS_OFFSCREENPLAIN),
 151             FE(DDSCAPS_OVERLAY),
 152             FE(DDSCAPS_PALETTE),
 153             FE(DDSCAPS_PRIMARYSURFACE),
 154             FE(DDSCAPS_PRIMARYSURFACELEFT),
 155             FE(DDSCAPS_SYSTEMMEMORY),
 156             FE(DDSCAPS_TEXTURE),
 157             FE(DDSCAPS_3DDEVICE),
 158             FE(DDSCAPS_VIDEOMEMORY),
 159             FE(DDSCAPS_VISIBLE),
 160             FE(DDSCAPS_WRITEONLY),
 161             FE(DDSCAPS_ZBUFFER),
 162             FE(DDSCAPS_OWNDC),
 163             FE(DDSCAPS_LIVEVIDEO),
 164             FE(DDSCAPS_HWCODEC),
 165             FE(DDSCAPS_MODEX),
 166             FE(DDSCAPS_MIPMAP),
 167             FE(DDSCAPS_RESERVED2),
 168             FE(DDSCAPS_ALLOCONLOAD),
 169             FE(DDSCAPS_VIDEOPORT),
 170             FE(DDSCAPS_LOCALVIDMEM),
 171             FE(DDSCAPS_NONLOCALVIDMEM),
 172             FE(DDSCAPS_STANDARDVGAMODE),
 173             FE(DDSCAPS_OPTIMIZED)
 174     };
 175
 176     DDRAW_dump_flags(in->dwCaps, flags, sizeof(flags)/sizeof(flags[0]));
 177 }
 178
 179 void DDRAW_dump_pixelformat_flag(DWORD flagmask)
 180 {
 181     static const flag_info flags[] =
 182         {
 183             FE(DDPF_ALPHAPIXELS),
 184             FE(DDPF_ALPHA),
 185             FE(DDPF_FOURCC),
 186             FE(DDPF_PALETTEINDEXED4),
 187             FE(DDPF_PALETTEINDEXEDTO8),
 188             FE(DDPF_PALETTEINDEXED8),
 189             FE(DDPF_RGB),
 190             FE(DDPF_COMPRESSED),
 191             FE(DDPF_RGBTOYUV),
 192             FE(DDPF_YUV),
 193             FE(DDPF_ZBUFFER),
 194             FE(DDPF_PALETTEINDEXED1),
 195             FE(DDPF_PALETTEINDEXED2),
 196             FE(DDPF_ZPIXELS)
 197     };
 198
 199     DDRAW_dump_flags(flagmask, flags, sizeof(flags)/sizeof(flags[0]));
 200 }
 201
 202 void DDRAW_dump_paletteformat(DWORD dwFlags)
 203 {
 204     static const flag_info flags[] =
 205         {
 206             FE(DDPCAPS_4BIT),
 207             FE(DDPCAPS_8BITENTRIES),
 208             FE(DDPCAPS_8BIT),
 209             FE(DDPCAPS_INITIALIZE),
 210             FE(DDPCAPS_PRIMARYSURFACE),
 211             FE(DDPCAPS_PRIMARYSURFACELEFT),
 212             FE(DDPCAPS_ALLOW256),
 213             FE(DDPCAPS_VSYNC),
 214             FE(DDPCAPS_1BIT),
 215             FE(DDPCAPS_2BIT),
 216             FE(DDPCAPS_ALPHA)
 217     };
 218
 219     DDRAW_dump_flags(dwFlags, flags, sizeof(flags)/sizeof(flags[0]));
 220 }
 221
 222 void DDRAW_dump_pixelformat(const DDPIXELFORMAT *pf) {
 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 DDCOLORKEY *ddck) {
 286     DPRINTF(" Low : %ld  - High : %ld", ddck->dwColorSpaceLowValue, ddck->dwColorSpaceHighValue);
 287 }
 288
 289 void DDRAW_dump_surface_desc(const DDSURFACEDESC2 *lpddsd)
 290 {
 291 #define STRUCT DDSURFACEDESC2
 292     static const member_info members[] =
 293         {
 294             ME(DDSD_CAPS, DDRAW_dump_DDSCAPS, ddsCaps),
 295             ME(DDSD_HEIGHT, DDRAW_dump_DWORD, dwHeight),
 296             ME(DDSD_WIDTH, DDRAW_dump_DWORD, dwWidth),
 297             ME(DDSD_PITCH, DDRAW_dump_DWORD, u1.lPitch),
 298             ME(DDSD_LINEARSIZE, DDRAW_dump_DWORD, u1.dwLinearSize),
 299             ME(DDSD_BACKBUFFERCOUNT, DDRAW_dump_DWORD, dwBackBufferCount),
 300             ME(DDSD_MIPMAPCOUNT, DDRAW_dump_DWORD, u2.dwMipMapCount),
 301             ME(DDSD_REFRESHRATE, DDRAW_dump_DWORD, u2.dwRefreshRate),
 302             ME(DDSD_ALPHABITDEPTH, DDRAW_dump_DWORD, dwAlphaBitDepth),
 303             ME(DDSD_LPSURFACE, DDRAW_dump_PTR, lpSurface),
 304             ME(DDSD_CKDESTOVERLAY, DDRAW_dump_DDCOLORKEY, u3.ddckCKDestOverlay),
 305             ME(DDSD_CKDESTBLT, DDRAW_dump_DDCOLORKEY, ddckCKDestBlt),
 306             ME(DDSD_CKSRCOVERLAY, DDRAW_dump_DDCOLORKEY, ddckCKSrcOverlay),
 307             ME(DDSD_CKSRCBLT, DDRAW_dump_DDCOLORKEY, ddckCKSrcBlt),
 308             ME(DDSD_PIXELFORMAT, DDRAW_dump_pixelformat, u4.ddpfPixelFormat)
 309         };
 310
 311     DDRAW_dump_members(lpddsd->dwFlags, lpddsd, members,
 312                        sizeof(members)/sizeof(members[0]));
 313 }
 314
 315 void DDRAW_dump_cooperativelevel(DWORD cooplevel)
 316 {
 317     static const flag_info flags[] =
 318         {
 319             FE(DDSCL_FULLSCREEN),
 320             FE(DDSCL_ALLOWREBOOT),
 321             FE(DDSCL_NOWINDOWCHANGES),
 322             FE(DDSCL_NORMAL),
 323             FE(DDSCL_ALLOWMODEX),
 324             FE(DDSCL_EXCLUSIVE),
 325             FE(DDSCL_SETFOCUSWINDOW),
 326             FE(DDSCL_SETDEVICEWINDOW),
 327             FE(DDSCL_CREATEDEVICEWINDOW)
 328     };
 329
 330     if (TRACE_ON(ddraw))
 331     {
 332         DPRINTF(" - ");
 333         DDRAW_dump_flags(cooplevel, flags, sizeof(flags)/sizeof(flags[0]));
 334     }
 335 }