static int OnRelativeFileHelp(HWND hDlg) { TFileTestData * pData = GetDialogData(hDlg); LPTSTR szBuffer; TCHAR szDesiredAccess[0x100]; TCHAR szShareAccess[0x100]; TCHAR szOpenOptions[0x100]; TCHAR szMsgFormat[512]; size_t cchBuffer = 0x1000; int nLength = 0; // Load both parts of the message nLength = LoadString(g_hInst, IDS_RELATIVE_FILE_HELP, szMsgFormat, _maxchars(szMsgFormat)); if(nLength > 0) { // Allocate big buffer for the entire text szBuffer = new TCHAR[cchBuffer]; if(szBuffer != NULL) { // Format the result string StringCchPrintf(szBuffer, cchBuffer, szMsgFormat, pData->dwDesiredAccessRF, FlagsToString(DesiredAccessValues, szDesiredAccess, _countof(szDesiredAccess), pData->dwDesiredAccessRF, false), pData->dwShareAccessRF, FlagsToString(ShareAccessValues, szShareAccess, _countof(szShareAccess), pData->dwShareAccessRF, false), pData->dwOpenOptionsRF, FlagsToString(CreateOptionsValues, szOpenOptions, _countof(szOpenOptions), pData->dwOpenOptionsRF, false)); // Display the message box MessageBoxRc(hDlg, IDS_INFO, (UINT_PTR)szBuffer); delete [] szBuffer; } } return TRUE; }
// Not really a test, but a useful debugging tool. TEST(ifaddrs, dump) { ifaddrs* addrs; ASSERT_EQ(0, getifaddrs(&addrs)); for (ifaddrs* ifa = addrs; ifa != nullptr; ifa = ifa->ifa_next) { int family = ifa->ifa_addr ? ifa->ifa_addr->sa_family : ifa->ifa_broadaddr ? ifa->ifa_broadaddr->sa_family : AF_UNSPEC; printf("\t%s\n" "\t\t%s (%d) flags=%#x%s\n", ifa->ifa_name, FamilyToName(family), family, ifa->ifa_flags, FlagsToString(ifa->ifa_flags).c_str()); if (family == AF_PACKET) { if (ifa->ifa_addr) print_sockaddr_ll("hwaddr", ifa->ifa_addr); if (ifa->ifa_broadaddr) print_sockaddr_ll("hwbroad", ifa->ifa_addr); } else if (family == AF_INET || family == AF_INET6) { if (ifa->ifa_addr) print_sockaddr_inet("address", ifa->ifa_addr); if (ifa->ifa_broadaddr && (ifa->ifa_flags & (IFF_BROADCAST | IFF_POINTOPOINT)) != 0) { print_sockaddr_inet((ifa->ifa_flags & IFF_BROADCAST) ? "broadcast" : "destination", ifa->ifa_broadaddr); } } fflush(stdout); } freeifaddrs(addrs); }
//@Override String DisplayDeviceInfo::ToString() { StringBuilder sb("DisplayDeviceInfo{\""); sb += mName; sb += "\": "; sb += mWidth; sb += " x "; sb += mHeight; sb += ", "; sb += mRefreshRate; sb += " fps, "; sb += "density "; sb += mDensityDpi; sb += ", "; sb += mXDpi; sb += " x "; sb += mYDpi; sb += " dpi, touch "; sb += TouchToString(mTouch); sb += FlagsToString(mFlags); sb += ", rotation "; sb += mRotation; sb += ", type "; sb += mType;//Display.typeToString(type) sb += ", address "; sb += mAddress; sb += "}"; return sb.ToString(); }
const good::string& CTypeToString::EntityClassFlagsToString( TEntityFlags iItemFlags ) { if ( iItemFlags == 0 ) return sNone; else return FlagsToString( iItemFlags, FEntityTotal, aEntityClassFlags ); }
HRESULT __stdcall DDRAW4_HOOK_CreateSurface(LPVOID *ppvOut, LPDDSURFACEDESC2 lpDDSurfaceDesc, LPDIRECTDRAWSURFACE4 FAR *lplpDDSurface4, IUnknown FAR *pUnkOuter) { const unsigned int hpos = 6; DDRAW4_CreateSurface_Type ofn = (DDRAW4_CreateSurface_Type)ddraw4_hooks[hpos].oldFunc; HRESULT ret = ofn(ppvOut, lpDDSurfaceDesc, lplpDDSurface4, pUnkOuter); LogDXError(ret); Log("IDirectDraw4::%s(this=%#010lx, lpDDSurfaceDesc=%#010lx, lplpDDSurface=%#010lx *[%#010lx], pUnkOuter=%#010lx)\n", ddraw4_hooks[hpos].name, ppvOut, lpDDSurfaceDesc, lplpDDSurface4, (lplpDDSurface4 != NULL ? *lplpDDSurface4 : NULL), pUnkOuter); if(lpDDSurfaceDesc != NULL) { char dwFlags_buffer[LOGBUFFER_MAX], ddscaps1_buffer[LOGBUFFER_MAX], ddpf_buffer[LOGBUFFER_MAX]; FlagsToString(FLAGS_DDSD, CFLAGS_DDSD, lpDDSurfaceDesc->dwFlags, (char *)&dwFlags_buffer, LOGBUFFER_MAX); FlagsToString(FLAGS_DDSCAPS1, CFLAGS_DDSCAPS1, lpDDSurfaceDesc->ddsCaps.dwCaps, (char *)&ddscaps1_buffer, LOGBUFFER_MAX); FlagsToString(FLAGS_DDPF, CFLAGS_DDPF, lpDDSurfaceDesc->ddpfPixelFormat.dwFlags, (char *)&ddpf_buffer, LOGBUFFER_MAX); Log("->lpDDSurfaceDesc { dwSize=%#010lx, dwFlags=%#010lx (%s), dwWidth=%#010lx (%d), dwHeight=%#010lx (%d), lPitch=%#010lx , dwLinearSize=%#010lx, dwBackBufferCount=%#010lx, dwMipMapCount=%#010lx, dwRefreshRate=%#010lx, dwAlphaBitDepth=%#010lx, dwReserved=%#010lx,\n" " lpSurface=%#010lx, ddckCKDestOverlay={ %#010lx, %#010lx }, ddckCKDestBlt={ %#010lx, %#010lx }, ddckCKSrcOverlay={ %#010lx, %#010lx }, ddckCKSrcBlt={ %#010lx, %#010lx },\n" " ddpfPixelFormat={ dwSize=%#010lx, dwFlags=%#010lx (%s), dwFourCC=%#010lx, dwRGBBitCount=%#010lx, dwYUVBitCount=%#010lx, dwZBufferBitDepth=%#010lx, dwAlphaBitDepth=%#010lx, dwLuminanceBitCount=%#010lx, dwBumpBitCount=%#010lx, dwRBitMask=%#010lx,\n" " dwYBitMask=%#010lx, dwStencilBitDepth=%#010lx, dwLuminanceBitMask=%#010lx, dwBumpDuBitMask=%#010lx, dwGBitMask=%#010lx, dwUBitMask=%#010lx, dwZBitMask=%#010lx, dwBumpDvBitMask=%#010lx, dwBBitMask=%#010lx, dwVBitMask=%#010lx, dwStencilBitMask=%#010lx,\n" " dwBumpLuminanceBitMask=%#010lx, dwRGBAlphaBitMask=%#010lx, dwYUVAlphaBitMask=%#010lx, dwLuminanceAlphaBitMask=%#010lx, dwRGBZBitMask=%#010lx, dwYUVZBitMask=%#010lx },\n" " ddsCaps={ %#010lx (%s), %#010lx, %#010lx, %#010lx }, dwTextureStage=%#010lx }\n", lpDDSurfaceDesc->dwSize, lpDDSurfaceDesc->dwFlags, dwFlags_buffer, lpDDSurfaceDesc->dwWidth, (unsigned int)lpDDSurfaceDesc->dwWidth, lpDDSurfaceDesc->dwHeight, (unsigned int)lpDDSurfaceDesc->dwHeight, lpDDSurfaceDesc->lPitch, lpDDSurfaceDesc->dwLinearSize, lpDDSurfaceDesc->dwBackBufferCount, lpDDSurfaceDesc->dwMipMapCount, lpDDSurfaceDesc->dwRefreshRate, lpDDSurfaceDesc->dwAlphaBitDepth, lpDDSurfaceDesc->dwReserved, lpDDSurfaceDesc->lpSurface, lpDDSurfaceDesc->ddckCKDestOverlay.dwColorSpaceLowValue, lpDDSurfaceDesc->ddckCKDestOverlay.dwColorSpaceHighValue, lpDDSurfaceDesc->ddckCKDestBlt.dwColorSpaceLowValue, lpDDSurfaceDesc->ddckCKDestBlt.dwColorSpaceHighValue, lpDDSurfaceDesc->ddckCKSrcOverlay.dwColorSpaceLowValue, lpDDSurfaceDesc->ddckCKSrcOverlay.dwColorSpaceHighValue, lpDDSurfaceDesc->ddckCKSrcBlt.dwColorSpaceLowValue, lpDDSurfaceDesc->ddckCKSrcBlt.dwColorSpaceHighValue, lpDDSurfaceDesc->ddpfPixelFormat.dwSize, lpDDSurfaceDesc->ddpfPixelFormat.dwFlags, ddpf_buffer, lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC, lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount, lpDDSurfaceDesc->ddpfPixelFormat.dwYUVBitCount, lpDDSurfaceDesc->ddpfPixelFormat.dwZBufferBitDepth, lpDDSurfaceDesc->ddpfPixelFormat.dwAlphaBitDepth, lpDDSurfaceDesc->ddpfPixelFormat.dwLuminanceBitCount, lpDDSurfaceDesc->ddpfPixelFormat.dwBumpBitCount, lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwYBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwStencilBitDepth, lpDDSurfaceDesc->ddpfPixelFormat.dwLuminanceBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwBumpDuBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwUBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwZBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwBumpDvBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwVBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwStencilBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwBumpLuminanceBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwRGBAlphaBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwYUVAlphaBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwLuminanceAlphaBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwRGBZBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwYUVZBitMask, lpDDSurfaceDesc->ddsCaps.dwCaps, ddscaps1_buffer, lpDDSurfaceDesc->ddsCaps.dwCaps2, lpDDSurfaceDesc->ddsCaps.dwCaps3, lpDDSurfaceDesc->ddsCaps.dwCaps4, lpDDSurfaceDesc->dwTextureStage ); } if(ret == S_OK && ishooked_ddrawsurface4_hooks == false) { HookVTBLCalls((LPVOID *)lplpDDSurface4, ddrawsurface4_hooks, count_ddrawsurface4_hooks, "IDirectDrawSurface4"); ishooked_ddrawsurface4_hooks = true; } return ret; }
HRESULT __stdcall DDRAWPALETTE_HOOK_GetCaps(LPVOID *ppvOut, LPDWORD lpdwCaps) { const unsigned int hpos = 3; DDRAWPALETTE_GetCaps_Type ofn = (DDRAWPALETTE_GetCaps_Type)ddrawpalette_hooks[hpos].oldFunc; HRESULT ret = ofn(ppvOut, lpdwCaps); LogDXError(ret); char dwCaps_buffer[LOGBUFFER_MAX]; if(lpdwCaps != NULL) FlagsToString(FLAGS_DDPCAPS, CFLAGS_DDPCAPS, *lpdwCaps, (char *)&dwCaps_buffer, LOGBUFFER_MAX); Log("IDirectDrawPalette::%s(this=%#010lx, lpdwCaps=%#010lx *[%#010lx]%s%s%s)\n", ddrawpalette_hooks[hpos].name, ppvOut, lpdwCaps, (lpdwCaps != NULL ? *lpdwCaps : NULL), (lpdwCaps != NULL ? " (" : ""), dwCaps_buffer, (lpdwCaps != NULL ? ")" : "")); return ret; }
HRESULT __stdcall DDRAW4_HOOK_GetAvailableVidMem(LPVOID *ppvOut, LPDDSCAPS2 lpDDSCaps2, LPDWORD lpdwTotal, LPDWORD lpdwFree) { const unsigned int hpos = 23; DDRAW4_GetAvailableVidMem_Type ofn = (DDRAW4_GetAvailableVidMem_Type)ddraw4_hooks[hpos].oldFunc; HRESULT ret = ofn(ppvOut, lpDDSCaps2, lpdwTotal, lpdwFree); LogDXError(ret); Log("IDirectDraw4::%s(this=%#010lx, lpDDSCaps=%#010lx, lpdwTotal=%#010lx (%d), lpdwFree=%#010lx (%d))\n", ddraw4_hooks[hpos].name, ppvOut, lpDDSCaps2, lpdwTotal, lpdwTotal, lpdwFree, lpdwFree); if(lpDDSCaps2 != NULL) { char ddscaps1_buffer[LOGBUFFER_MAX]; FlagsToString(FLAGS_DDSCAPS1, CFLAGS_DDSCAPS1, lpDDSCaps2->dwCaps, (char *)&ddscaps1_buffer, LOGBUFFER_MAX); Log("->lpDDSCaps2 { %#010lx (%s), %#010lx, %#010lx, %#010lx }\n", lpDDSCaps2->dwCaps, ddscaps1_buffer, lpDDSCaps2->dwCaps2, lpDDSCaps2->dwCaps3, lpDDSCaps2->dwCaps4 ); } return ret; }
const good::string& CTypeToString::WaypointFlagsToString(TWaypointFlags iFlags) { return FlagsToString( iFlags, FWaypointTotal, aWaypointFlags ); }
HRESULT __stdcall DDRAW4_HOOK_CreateSurface(LPVOID *ppvOut, LPDDSURFACEDESC2 lpDDSurfaceDesc, LPDIRECTDRAWSURFACE4 FAR *lplpDDSurface4, IUnknown FAR *pUnkOuter) { const unsigned int hpos = 6; if(g_config.displaymode != 0) { /*if((void *)lpDDSurfaceDesc == (void *)0x00134518) { lpDDSurfaceDesc->dwWidth = displaymode_options[g_config.displaymode].resX; lpDDSurfaceDesc->dwHeight = displaymode_options[g_config.displaymode].resY; }*/ if(lpDDSurfaceDesc != NULL && lpDDSurfaceDesc->dwWidth == 640 && lpDDSurfaceDesc->dwHeight == 480) { lpDDSurfaceDesc->dwWidth = displaymode_options[g_config.displaymode].resX; lpDDSurfaceDesc->dwHeight = displaymode_options[g_config.displaymode].resY; } } // 8-bit Paletted Textures Fix (VISTA Compatible) if(g_config.b8_paletted_textures_fix >= 1) { if(lpDDSurfaceDesc != NULL && (lpDDSurfaceDesc->ddsCaps.dwCaps & (DDSCAPS_ALLOCONLOAD | DDSCAPS_TEXTURE)) == (DDSCAPS_ALLOCONLOAD | DDSCAPS_TEXTURE)) { lpDDSurfaceDesc->dwFlags |= DDSD_CKSRCBLT; lpDDSurfaceDesc->ddckCKSrcBlt.dwColorSpaceLowValue = 0x000000; lpDDSurfaceDesc->ddckCKSrcBlt.dwColorSpaceHighValue = 0x000000; } } #ifdef FF8_WINDOWED if((void *)lpDDSurfaceDesc == (void *)0x00134658) { Log("IF[lpDDSurfaceDesc == 0x00134658] THEN\n"); lpDDSurfaceDesc->dwFlags &= ~(DDSD_BACKBUFFERCOUNT); //lpDDSurfaceDesc->dwFlags |= (DDSD_WIDTH | DDSD_HEIGHT); lpDDSurfaceDesc->dwWidth = 0; lpDDSurfaceDesc->dwHeight = 0; lpDDSurfaceDesc->dwBackBufferCount = 0; lpDDSurfaceDesc->ddsCaps.dwCaps &= ~(DDSCAPS_COMPLEX | DDSCAPS_FLIP | DDSCAPS_PRIMARYSURFACE ); lpDDSurfaceDesc->ddsCaps.dwCaps |= (DDSCAPS_PRIMARYSURFACE); } /*else if((lpDDSurfaceDesc->ddsCaps.dwCaps & (DDSCAPS_ALLOCONLOAD | DDSCAPS_TEXTURE)) && (lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT) && (lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_ALPHAPIXELS) && lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask == 0x7c00 && lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask == 0x3e0 && lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask == 0x1f) { lpDDSurfaceDesc->ddpfPixelFormat.dwFlags &= ~(DDPF_ALPHAPIXELS); lpDDSurfaceDesc->ddpfPixelFormat.dwRGBAlphaBitMask = lpDDSurfaceDesc->ddpfPixelFormat.dwYUVAlphaBitMask = lpDDSurfaceDesc->ddpfPixelFormat.dwLuminanceAlphaBitMask = lpDDSurfaceDesc->ddpfPixelFormat.dwRGBZBitMask = lpDDSurfaceDesc->ddpfPixelFormat.dwYUVZBitMask = 0x00; //Does not work: Crash in battle swirl }*/ /*else if((lpDDSurfaceDesc->ddsCaps.dwCaps & (DDSCAPS_SYSTEMMEMORY | DDSCAPS_TEXTURE)) && (lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT) && (lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_ALPHAPIXELS) && lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount == 0x020) { lpDDSurfaceDesc->ddpfPixelFormat.dwFlags &= ~(DDPF_ALPHAPIXELS); lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount = lpDDSurfaceDesc->ddpfPixelFormat.dwYUVBitCount = lpDDSurfaceDesc->ddpfPixelFormat.dwZBufferBitDepth = lpDDSurfaceDesc->ddpfPixelFormat.dwAlphaBitDepth = lpDDSurfaceDesc->ddpfPixelFormat.dwLuminanceBitCount = lpDDSurfaceDesc->ddpfPixelFormat.dwBumpBitCount = 0x10; lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = lpDDSurfaceDesc->ddpfPixelFormat.dwYBitMask = lpDDSurfaceDesc->ddpfPixelFormat.dwStencilBitDepth = lpDDSurfaceDesc->ddpfPixelFormat.dwLuminanceBitMask = lpDDSurfaceDesc->ddpfPixelFormat.dwBumpDuBitMask = 0xf800; lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = lpDDSurfaceDesc->ddpfPixelFormat.dwUBitMask = lpDDSurfaceDesc->ddpfPixelFormat.dwZBitMask = lpDDSurfaceDesc->ddpfPixelFormat.dwBumpDvBitMask = 0x7e0; lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = lpDDSurfaceDesc->ddpfPixelFormat.dwVBitMask = lpDDSurfaceDesc->ddpfPixelFormat.dwStencilBitMask = lpDDSurfaceDesc->ddpfPixelFormat.dwBumpLuminanceBitMask = 0x1f; lpDDSurfaceDesc->ddpfPixelFormat.dwRGBAlphaBitMask = lpDDSurfaceDesc->ddpfPixelFormat.dwYUVAlphaBitMask = lpDDSurfaceDesc->ddpfPixelFormat.dwLuminanceAlphaBitMask = lpDDSurfaceDesc->ddpfPixelFormat.dwRGBZBitMask = lpDDSurfaceDesc->ddpfPixelFormat.dwYUVZBitMask = 0x00; }*/ /* 16BIT ->lpDDSurfaceDesc { dwSize=0x0000007c, dwFlags=0x00001007 (DDSD_CAPS | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_WIDTH), dwWidth=0x00000100 (256), dwHeight=0x00000100 (256), lPitch=0000000000 , dwLinearSize=0000000000, dwBackBufferCount=0000000000, dwMipMapCount=0000000000, dwRefreshRate=0000000000, dwAlphaBitDepth=0000000000, dwReserved=0000000000, lpSurface=0000000000, ddckCKDestOverlay={ 0000000000, 0000000000 }, ddckCKDestBlt={ 0000000000, 0000000000 }, ddckCKSrcOverlay={ 0000000000, 0000000000 }, ddckCKSrcBlt={ 0000000000, 0000000000 }, ddpfPixelFormat={ dwSize=0x00000020, dwFlags=0x00000040 (DDPF_RGB), dwFourCC=0000000000, dwRGBBitCount=0x00000010, dwYUVBitCount=0x00000010, dwZBufferBitDepth=0x00000010, dwAlphaBitDepth=0x00000010, dwLuminanceBitCount=0x00000010, dwBumpBitCount=0x00000010, dwRBitMask=0x0000f800, dwYBitMask=0x0000f800, dwStencilBitDepth=0x0000f800, dwLuminanceBitMask=0x0000f800, dwBumpDuBitMask=0x0000f800, dwGBitMask=0x000007e0, dwUBitMask=0x000007e0, dwZBitMask=0x000007e0, dwBumpDvBitMask=0x000007e0, dwBBitMask=0x0000001f, dwVBitMask=0x0000001f, dwStencilBitMask=0x0000001f, dwBumpLuminanceBitMask=0x0000001f, dwRGBAlphaBitMask=0000000000, dwYUVAlphaBitMask=0000000000, dwLuminanceAlphaBitMask=0000000000, dwRGBZBitMask=0000000000, dwYUVZBitMask=0000000000 }, ddsCaps={ 0x00001800 (DDSCAPS_SYSTEMMEMORY | DDSCAPS_TEXTURE), 0000000000, 0000000000, 0000000000 }, dwTextureStage=0000000000 } 32BIT ->lpDDSurfaceDesc { dwSize=0x0000007c, dwFlags=0x00001007 (DDSD_CAPS | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_WIDTH), dwWidth=0x00000100 (256), dwHeight=0x00000100 (256), lPitch=0000000000 , dwLinearSize=0000000000, dwBackBufferCount=0000000000, dwMipMapCount=0000000000, dwRefreshRate=0000000000, dwAlphaBitDepth=0000000000, dwReserved=0000000000, lpSurface=0000000000, ddckCKDestOverlay={ 0000000000, 0000000000 }, ddckCKDestBlt={ 0000000000, 0000000000 }, ddckCKSrcOverlay={ 0000000000, 0000000000 }, ddckCKSrcBlt={ 0000000000, 0000000000 }, ddpfPixelFormat={ dwSize=0x00000020, dwFlags=0x00000041 (DDPF_ALPHAPIXELS | DDPF_RGB), dwFourCC=0000000000, dwRGBBitCount=0x00000020, dwYUVBitCount=0x00000020, dwZBufferBitDepth=0x00000020, dwAlphaBitDepth=0x00000020, dwLuminanceBitCount=0x00000020, dwBumpBitCount=0x00000020, dwRBitMask=0x00ff0000, dwYBitMask=0x00ff0000, dwStencilBitDepth=0x00ff0000, dwLuminanceBitMask=0x00ff0000, dwBumpDuBitMask=0x00ff0000, dwGBitMask=0x0000ff00, dwUBitMask=0x0000ff00, dwZBitMask=0x0000ff00, dwBumpDvBitMask=0x0000ff00, dwBBitMask=0x000000ff, dwVBitMask=0x000000ff, dwStencilBitMask=0x000000ff, dwBumpLuminanceBitMask=0x000000ff, dwRGBAlphaBitMask=0xff000000, dwYUVAlphaBitMask=0xff000000, dwLuminanceAlphaBitMask=0xff000000, dwRGBZBitMask=0xff000000, dwYUVZBitMask=0xff000000 }, ddsCaps={ 0x00001800 (DDSCAPS_SYSTEMMEMORY | DDSCAPS_TEXTURE), 0000000000, 0000000000, 0000000000 }, dwTextureStage=0000000000 } */ #endif DDRAW4_CreateSurface_Type ofn = (DDRAW4_CreateSurface_Type)ddraw4_hooks[hpos].oldFunc; HRESULT ret = ofn(ppvOut, lpDDSurfaceDesc, lplpDDSurface4, pUnkOuter); LogDXError(ret); Log("IDirectDraw4::%s(this=%#010lx, lpDDSurfaceDesc=%#010lx, lplpDDSurface=%#010lx *[%#010lx], pUnkOuter=%#010lx)\n", ddraw4_hooks[hpos].name, ppvOut, lpDDSurfaceDesc, lplpDDSurface4, (lplpDDSurface4 != NULL ? *lplpDDSurface4 : NULL), pUnkOuter); if(lpDDSurfaceDesc != NULL) { char dwFlags_buffer[LOGBUFFER_MAX], ddscaps1_buffer[LOGBUFFER_MAX], ddpf_buffer[LOGBUFFER_MAX]; FlagsToString(FLAGS_DDSD, CFLAGS_DDSD, lpDDSurfaceDesc->dwFlags, (char *)&dwFlags_buffer, LOGBUFFER_MAX); FlagsToString(FLAGS_DDSCAPS1, CFLAGS_DDSCAPS1, lpDDSurfaceDesc->ddsCaps.dwCaps, (char *)&ddscaps1_buffer, LOGBUFFER_MAX); FlagsToString(FLAGS_DDPF, CFLAGS_DDPF, lpDDSurfaceDesc->ddpfPixelFormat.dwFlags, (char *)&ddpf_buffer, LOGBUFFER_MAX); Log("->lpDDSurfaceDesc { dwSize=%#010lx, dwFlags=%#010lx (%s), dwWidth=%#010lx (%d), dwHeight=%#010lx (%d), lPitch=%#010lx , dwLinearSize=%#010lx, dwBackBufferCount=%#010lx, dwMipMapCount=%#010lx, dwRefreshRate=%#010lx, dwAlphaBitDepth=%#010lx, dwReserved=%#010lx,\n" " lpSurface=%#010lx, ddckCKDestOverlay={ %#010lx, %#010lx }, ddckCKDestBlt={ %#010lx, %#010lx }, ddckCKSrcOverlay={ %#010lx, %#010lx }, ddckCKSrcBlt={ %#010lx, %#010lx },\n" " ddpfPixelFormat={ dwSize=%#010lx, dwFlags=%#010lx (%s), dwFourCC=%#010lx, dwRGBBitCount=%#010lx, dwYUVBitCount=%#010lx, dwZBufferBitDepth=%#010lx, dwAlphaBitDepth=%#010lx, dwLuminanceBitCount=%#010lx, dwBumpBitCount=%#010lx, dwRBitMask=%#010lx,\n" " dwYBitMask=%#010lx, dwStencilBitDepth=%#010lx, dwLuminanceBitMask=%#010lx, dwBumpDuBitMask=%#010lx, dwGBitMask=%#010lx, dwUBitMask=%#010lx, dwZBitMask=%#010lx, dwBumpDvBitMask=%#010lx, dwBBitMask=%#010lx, dwVBitMask=%#010lx, dwStencilBitMask=%#010lx,\n" " dwBumpLuminanceBitMask=%#010lx, dwRGBAlphaBitMask=%#010lx, dwYUVAlphaBitMask=%#010lx, dwLuminanceAlphaBitMask=%#010lx, dwRGBZBitMask=%#010lx, dwYUVZBitMask=%#010lx },\n" " ddsCaps={ %#010lx (%s), %#010lx, %#010lx, %#010lx }, dwTextureStage=%#010lx }\n", lpDDSurfaceDesc->dwSize, lpDDSurfaceDesc->dwFlags, dwFlags_buffer, lpDDSurfaceDesc->dwWidth, (unsigned int)lpDDSurfaceDesc->dwWidth, lpDDSurfaceDesc->dwHeight, (unsigned int)lpDDSurfaceDesc->dwHeight, lpDDSurfaceDesc->lPitch, lpDDSurfaceDesc->dwLinearSize, lpDDSurfaceDesc->dwBackBufferCount, lpDDSurfaceDesc->dwMipMapCount, lpDDSurfaceDesc->dwRefreshRate, lpDDSurfaceDesc->dwAlphaBitDepth, lpDDSurfaceDesc->dwReserved, lpDDSurfaceDesc->lpSurface, lpDDSurfaceDesc->ddckCKDestOverlay.dwColorSpaceLowValue, lpDDSurfaceDesc->ddckCKDestOverlay.dwColorSpaceHighValue, lpDDSurfaceDesc->ddckCKDestBlt.dwColorSpaceLowValue, lpDDSurfaceDesc->ddckCKDestBlt.dwColorSpaceHighValue, lpDDSurfaceDesc->ddckCKSrcOverlay.dwColorSpaceLowValue, lpDDSurfaceDesc->ddckCKSrcOverlay.dwColorSpaceHighValue, lpDDSurfaceDesc->ddckCKSrcBlt.dwColorSpaceLowValue, lpDDSurfaceDesc->ddckCKSrcBlt.dwColorSpaceHighValue, lpDDSurfaceDesc->ddpfPixelFormat.dwSize, lpDDSurfaceDesc->ddpfPixelFormat.dwFlags, ddpf_buffer, lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC, lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount, lpDDSurfaceDesc->ddpfPixelFormat.dwYUVBitCount, lpDDSurfaceDesc->ddpfPixelFormat.dwZBufferBitDepth, lpDDSurfaceDesc->ddpfPixelFormat.dwAlphaBitDepth, lpDDSurfaceDesc->ddpfPixelFormat.dwLuminanceBitCount, lpDDSurfaceDesc->ddpfPixelFormat.dwBumpBitCount, lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwYBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwStencilBitDepth, lpDDSurfaceDesc->ddpfPixelFormat.dwLuminanceBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwBumpDuBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwUBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwZBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwBumpDvBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwVBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwStencilBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwBumpLuminanceBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwRGBAlphaBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwYUVAlphaBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwLuminanceAlphaBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwRGBZBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwYUVZBitMask, lpDDSurfaceDesc->ddsCaps.dwCaps, ddscaps1_buffer, lpDDSurfaceDesc->ddsCaps.dwCaps2, lpDDSurfaceDesc->ddsCaps.dwCaps3, lpDDSurfaceDesc->ddsCaps.dwCaps4, lpDDSurfaceDesc->dwTextureStage ); } if(ishooked_ddrawsurface4_hooks == false) { HookVTBLCalls((LPVOID *)lplpDDSurface4, ddrawsurface4_hooks, count_ddrawsurface4_hooks, "IDirectDrawSurface4"); ishooked_ddrawsurface4_hooks = true; } // ------------------------------------------------------------------ // Create a DirectX window // ---------------------------- #ifdef FF8_WINDOWED if((void *)lpDDSurfaceDesc == (void *)0x00134658) { Log("IF[lpDDSurfaceDesc == 0x00134658] THEN\n"); if(SUCCEEDED(ret)) { LPDIRECTDRAWCLIPPER pcClipper; if(FAILED(((LPDIRECTDRAW4)ppvOut)->CreateClipper(0, &pcClipper, NULL))) { Log("ERROR: Couldn't create clipper\n"); } // Associate the clipper with the window Log("g_hwnd=%#01lx\n", g_hwnd); pcClipper->SetHWnd(0, g_hwnd); (*lplpDDSurface4)->SetClipper(pcClipper); //SAFE_RELEASE(pcClipper); HRESULT hr = 0; LPDIRECTDRAWSURFACE4 lpddsB = NULL; LPDIRECTDRAWSURFACE4 lpddsZ = NULL; DDSURFACEDESC2 ddsd; ZeroMemory(&ddsd, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = (DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT); ddsd.ddsCaps.dwCaps = (lpDDSurfaceDesc->ddsCaps.dwCaps); ddsd.ddsCaps.dwCaps &= ~(DDSCAPS_PRIMARYSURFACE); ddsd.ddsCaps.dwCaps |= (DDSCAPS_OFFSCREENPLAIN); ddsd.dwWidth = 640; ddsd.dwHeight = 480; //hRes = lpdd->lpVtbl->CreateSurface(lpdd, &ddsd, &lpddZBuffer,NULL); hr = ((LPDIRECTDRAW4)ppvOut)->CreateSurface(&ddsd, &lpddsB, NULL); if(FAILED(hr)) { Log("ERROR: Failed to create WINDOWED backbuffer!"); } else { //hr = (*lplpDDSurface4)->AddAttachedSurface(lpddsB); //if(FAILED(hr)) { // Log("ERROR: Failed to attach WINDOWED backbuffer to frontbuffer!"); //} else { g_frontbuffer = (*lplpDDSurface4); g_backbuffer = lpddsB; /*hr = ((LPDIRECTDRAW4)ppvOut)->CreateSurface(&ddsd, &lpddsZ, NULL); if(FAILED(hr)) { Log("ERROR: Failed to create WINDOWED z-buffer!"); } else { hr = lpddsB->AddAttachedSurface(lpddsZ); if(FAILED(hr)) { Log("ERROR: Failed to attach WINDOWED z-buffer to backbuffer!"); } else { } }*/ //} } } } #endif // ---------------------------------- return ret; }
const good::string& CTypeToString::PathFlagsToString( TPathFlags iFlags ) { return FlagsToString( iFlags, FPathTotal, aPathFlags ); }
VOID NTAPI DotNetEventCallback( _In_ PEVENT_RECORD EventRecord ) { PASMPAGE_QUERY_CONTEXT context = EventRecord->UserContext; PEVENT_HEADER eventHeader = &EventRecord->EventHeader; PEVENT_DESCRIPTOR eventDescriptor = &eventHeader->EventDescriptor; if (UlongToHandle(eventHeader->ProcessId) == context->ProcessId) { // .NET 4.0+ switch (eventDescriptor->Id) { case RuntimeInformationDCStart: { PRuntimeInformationRundown data = EventRecord->UserData; PDNA_NODE node; PPH_STRING startupFlagsString; PPH_STRING startupModeString; // Check for duplicates. if (FindClrNode(context, data->ClrInstanceID)) break; node = AddNode(context); node->Type = DNA_TYPE_CLR; node->u.Clr.ClrInstanceID = data->ClrInstanceID; node->u.Clr.DisplayName = PhFormatString(L"CLR v%u.%u.%u.%u", data->VMMajorVersion, data->VMMinorVersion, data->VMBuildNumber, data->VMQfeNumber); node->StructureText = node->u.Clr.DisplayName->sr; node->IdText = PhFormatString(L"%u", data->ClrInstanceID); startupFlagsString = FlagsToString(data->StartupFlags, StartupFlagsMap, sizeof(StartupFlagsMap)); startupModeString = FlagsToString(data->StartupMode, StartupModeMap, sizeof(StartupModeMap)); if (startupFlagsString->Length != 0 && startupModeString->Length != 0) { node->FlagsText = PhConcatStrings(3, startupFlagsString->Buffer, L", ", startupModeString->Buffer); PhDereferenceObject(startupFlagsString); PhDereferenceObject(startupModeString); } else if (startupFlagsString->Length != 0) { node->FlagsText = startupFlagsString; PhDereferenceObject(startupModeString); } else if (startupModeString->Length != 0) { node->FlagsText = startupModeString; PhDereferenceObject(startupFlagsString); } if (data->CommandLine[0]) node->PathText = PhCreateString(data->CommandLine); PhAddItemList(context->NodeRootList, node); } break; case AppDomainDCStart_V1: { PAppDomainLoadUnloadRundown_V1 data = EventRecord->UserData; SIZE_T appDomainNameLength; USHORT clrInstanceID; PDNA_NODE parentNode; PDNA_NODE node; appDomainNameLength = PhCountStringZ(data->AppDomainName) * sizeof(WCHAR); clrInstanceID = *(PUSHORT)((PCHAR)data + FIELD_OFFSET(AppDomainLoadUnloadRundown_V1, AppDomainName) + appDomainNameLength + sizeof(WCHAR) + sizeof(ULONG)); // Find the CLR node to add the AppDomain node to. parentNode = FindClrNode(context, clrInstanceID); if (parentNode) { // Check for duplicates. if (FindAppDomainNode(parentNode, data->AppDomainID)) break; node = AddNode(context); node->Type = DNA_TYPE_APPDOMAIN; node->u.AppDomain.AppDomainID = data->AppDomainID; node->u.AppDomain.DisplayName = PhConcatStrings2(L"AppDomain: ", data->AppDomainName); node->StructureText = node->u.AppDomain.DisplayName->sr; node->IdText = PhFormatString(L"%I64u", data->AppDomainID); node->FlagsText = FlagsToString(data->AppDomainFlags, AppDomainFlagsMap, sizeof(AppDomainFlagsMap)); PhAddItemList(parentNode->Children, node); } } break; case AssemblyDCStart_V1: { PAssemblyLoadUnloadRundown_V1 data = EventRecord->UserData; SIZE_T fullyQualifiedAssemblyNameLength; USHORT clrInstanceID; PDNA_NODE parentNode; PDNA_NODE node; PH_STRINGREF remainingPart; fullyQualifiedAssemblyNameLength = PhCountStringZ(data->FullyQualifiedAssemblyName) * sizeof(WCHAR); clrInstanceID = *(PUSHORT)((PCHAR)data + FIELD_OFFSET(AssemblyLoadUnloadRundown_V1, FullyQualifiedAssemblyName) + fullyQualifiedAssemblyNameLength + sizeof(WCHAR)); // Find the AppDomain node to add the Assembly node to. parentNode = FindClrNode(context, clrInstanceID); if (parentNode) parentNode = FindAppDomainNode(parentNode, data->AppDomainID); if (parentNode) { // Check for duplicates. if (FindAssemblyNode(parentNode, data->AssemblyID)) break; node = AddNode(context); node->Type = DNA_TYPE_ASSEMBLY; node->u.Assembly.AssemblyID = data->AssemblyID; node->u.Assembly.FullyQualifiedAssemblyName = PhCreateStringEx(data->FullyQualifiedAssemblyName, fullyQualifiedAssemblyNameLength); // Display only the assembly name, not the whole fully qualified name. if (!PhSplitStringRefAtChar(&node->u.Assembly.FullyQualifiedAssemblyName->sr, ',', &node->StructureText, &remainingPart)) node->StructureText = node->u.Assembly.FullyQualifiedAssemblyName->sr; node->IdText = PhFormatString(L"%I64u", data->AssemblyID); node->FlagsText = FlagsToString(data->AssemblyFlags, AssemblyFlagsMap, sizeof(AssemblyFlagsMap)); PhAddItemList(parentNode->Children, node); } } break; case ModuleDCStart_V1: { PModuleLoadUnloadRundown_V1 data = EventRecord->UserData; PWSTR moduleILPath; SIZE_T moduleILPathLength; PWSTR moduleNativePath; SIZE_T moduleNativePathLength; USHORT clrInstanceID; PDNA_NODE node; moduleILPath = data->ModuleILPath; moduleILPathLength = PhCountStringZ(moduleILPath) * sizeof(WCHAR); moduleNativePath = (PWSTR)((PCHAR)moduleILPath + moduleILPathLength + sizeof(WCHAR)); moduleNativePathLength = PhCountStringZ(moduleNativePath) * sizeof(WCHAR); clrInstanceID = *(PUSHORT)((PCHAR)moduleNativePath + moduleNativePathLength + sizeof(WCHAR)); // Find the Assembly node to set the path on. node = FindClrNode(context, clrInstanceID); if (node) node = FindAssemblyNode2(node, data->AssemblyID); if (node) { PhMoveReference(&node->PathText, PhCreateStringEx(moduleILPath, moduleILPathLength)); if (moduleNativePathLength != 0) PhMoveReference(&node->NativePathText, PhCreateStringEx(moduleNativePath, moduleNativePathLength)); } } break; case DCStartComplete_V1: { if (_InterlockedExchange(&context->TraceHandleActive, 0) == 1) { CloseTrace(context->TraceHandle); } } break; } // .NET 2.0 if (eventDescriptor->Id == 0) { switch (eventDescriptor->Opcode) { case CLR_MODULEDCSTART_OPCODE: { PModuleLoadUnloadRundown_V1 data = EventRecord->UserData; PWSTR moduleILPath; SIZE_T moduleILPathLength; PWSTR moduleNativePath; SIZE_T moduleNativePathLength; PDNA_NODE node; ULONG_PTR indexOfBackslash; ULONG_PTR indexOfLastDot; moduleILPath = data->ModuleILPath; moduleILPathLength = PhCountStringZ(moduleILPath) * sizeof(WCHAR); moduleNativePath = (PWSTR)((PCHAR)moduleILPath + moduleILPathLength + sizeof(WCHAR)); moduleNativePathLength = PhCountStringZ(moduleNativePath) * sizeof(WCHAR); if (context->ClrV2Node && (moduleILPathLength != 0 || moduleNativePathLength != 0)) { node = AddNode(context); node->Type = DNA_TYPE_ASSEMBLY; node->FlagsText = FlagsToString(data->ModuleFlags, ModuleFlagsMap, sizeof(ModuleFlagsMap)); node->PathText = PhCreateStringEx(moduleILPath, moduleILPathLength); if (moduleNativePathLength != 0) node->NativePathText = PhCreateStringEx(moduleNativePath, moduleNativePathLength); // Use the name between the last backslash and the last dot for the structure column text. // (E.g. C:\...\AcmeSoft.BigLib.dll -> AcmeSoft.BigLib) indexOfBackslash = PhFindLastCharInString(node->PathText, 0, '\\'); indexOfLastDot = PhFindLastCharInString(node->PathText, 0, '.'); if (indexOfBackslash != -1) { node->StructureText.Buffer = node->PathText->Buffer + indexOfBackslash + 1; if (indexOfLastDot != -1 && indexOfLastDot > indexOfBackslash) { node->StructureText.Length = (indexOfLastDot - indexOfBackslash - 1) * sizeof(WCHAR); } else { node->StructureText.Length = node->PathText->Length - indexOfBackslash * sizeof(WCHAR) - sizeof(WCHAR); } } else { node->StructureText = node->PathText->sr; } PhAddItemList(context->ClrV2Node->Children, node); } } break; case CLR_METHODDC_DCSTARTCOMPLETE_OPCODE: { if (_InterlockedExchange(&context->TraceHandleActive, 0) == 1) { CloseTrace(context->TraceHandle); } } break; } } } }
const good::string& CTypeToString::WaypointDrawFlagsToString( TWaypointDrawFlags iFlags ) { return FlagsToString( iFlags, FWaypointDrawTotal, aDrawTypeFlags ); }
ZED_UINT32 XboxRenderer::Create( GraphicsAdapter *p_Adapter, const CanvasDescription &p_Canvas ) { ZED_UINT32 ReturnStatus = ZED_FAIL; if( NULL ==( m_pD3D = Direct3DCreate8( D3D_SDK_VERSION ) ) ) { return ZED_FAIL; } m_Canvas = p_Canvas; m_PresentParams.BackBufferWidth = m_Canvas.GetWidth( ); m_PresentParams.BackBufferHeight = m_Canvas.GetHeight( ); m_PresentParams.BackBufferCount = m_Canvas.GetBackBufferCount( ); m_PresentParams.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE; // Get the colour switch( m_Canvas.GetBPP( ) ) { case ZED_FORMAT_ARGB8: { m_PresentParams.BackBufferFormat = D3DFMT_A8R8G8B8; ReturnStatus = ZED_OK; break; } default: { zedTrace( "Failed to set the back buffer format" ); return ZED_FAIL; } } // Get the Depth/Stencil switch( m_Canvas.GetDepthStencil( ) ) { case ZED_FORMAT_D24S8: { m_PresentParams.EnableAutoDepthStencil = ZED_TRUE; m_PresentParams.AutoDepthStencilFormat = D3DFMT_D24S8; ReturnStatus = ZED_OK; break; } default: { zedTrace( "Failed to set the depth/stencil format" ); return ZED_FAIL; } } // This needs to be exposed, but how? m_PresentParams.SwapEffect = D3DSWAPEFFECT_DISCARD; if( FAILED( m_pD3D->CreateDevice( 0, D3DDEVTYPE_HAL, NULL, D3DCREATE_HARDWARE_VERTEXPROCESSING, &m_PresentParams, &m_pDevice ) ) ) { zedTrace( "Failed to create device" ); return ZED_FAIL; } #ifdef ZED_BUILD_DEBUG ZED_UINT32 ModeCount = m_pD3D->GetAdapterModeCount( D3DADAPTER_DEFAULT ); D3DDISPLAYMODE *pModes = new D3DDISPLAYMODE[ ModeCount ]; for( ZED_MEMSIZE i = 0; i < ModeCount; i++ ) { if( FAILED( m_pD3D->EnumAdapterModes( D3DADAPTER_DEFAULT, i, &pModes[ i ] ) ) ) { delete pModes; return ZED_FAIL; } ZED_MEMSIZE Len = strlen( FlagsToString( pModes[ i ].Flags ) ); char *pFlags; if( Len > 0 ) { pFlags = new char[ Len ]; strncpy( pFlags, FlagsToString( pModes[ i ].Flags ), Len-1 ); pFlags[ Len-1 ] = '\0'; } if( Len == 0 ) { // Add one for null-termination Len = strlen( "NO FLAGS" )+1; pFlags = new char[ Len ]; strncpy( pFlags, "NO FLAGS", Len ); } // Print out the adapter's capabilities zedTrace( "Mode %d:\n" "\tWidth: %d | Height: %d | Refresh Rate: %d | Flags: %s \n", i, pModes[ i ].Width, pModes[ i ].Height, pModes[ i ].RefreshRate, pFlags ); delete pFlags; } #endif return ReturnStatus; }
const good::string& CTypeToString::PathDrawFlagsToString( TPathDrawFlags iFlags ) { return FlagsToString( iFlags, FPathDrawTotal, aDrawTypeFlags ); }
const good::string& CTypeToString::AccessFlagsToString( TCommandAccessFlags iFlags ) { return FlagsToString( iFlags, FCommandAccessTotal, aAccessFlags ); }
HRESULT __stdcall DDRAWSURFACE4_HOOK_GetSurfaceDesc(LPVOID *ppvOut, LPDDSURFACEDESC2 lpDDSurfaceDesc) { const unsigned int hpos = 22; DDRAWSURFACE4_GetSurfaceDesc_Type ofn = (DDRAWSURFACE4_GetSurfaceDesc_Type)ddrawsurface4_hooks[hpos].oldFunc; HRESULT ret = ofn(ppvOut, lpDDSurfaceDesc); LogDXError(ret); DDSURFACEDESC2 & sd = *lpDDSurfaceDesc; if((!g_config.fullscreen && (LPDIRECTDRAWSURFACE4)ppvOut == g_backbuffer) || (sd.dwWidth == displaymode_options[g_config.displaymode].resX && sd.dwHeight == displaymode_options[g_config.displaymode].resY && (sd.ddsCaps.dwCaps & DDSCAPS_BACKBUFFER))) { sd.ddpfPixelFormat.dwFlags = DDPF_RGB; sd.ddpfPixelFormat.dwFourCC = 0; sd.ddpfPixelFormat.dwRGBBitCount = 16; sd.ddpfPixelFormat.dwRBitMask = 0xf800; sd.ddpfPixelFormat.dwGBitMask = 0x07e0; sd.ddpfPixelFormat.dwBBitMask = 0x001f; sd.dwWidth = 640; sd.dwHeight = 480; Log("Backbuffer info adjustment\n"); } // Similarily, the frontbuffer is read for special effects which also depend on the fixed size. if((!g_config.fullscreen && (LPDIRECTDRAWSURFACE4)ppvOut == g_frontbuffer) || (sd.dwWidth == displaymode_options[g_config.displaymode].resX && sd.dwHeight == displaymode_options[g_config.displaymode].resY && (sd.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))) { sd.ddpfPixelFormat.dwFlags = DDPF_RGB; sd.ddpfPixelFormat.dwFourCC = 0; sd.ddpfPixelFormat.dwRGBBitCount = 16; sd.ddpfPixelFormat.dwRBitMask = 0xf800; sd.ddpfPixelFormat.dwGBitMask = 0x07e0; sd.ddpfPixelFormat.dwBBitMask = 0x001f; sd.dwWidth = 640; sd.dwHeight = 480; Log("Frontbuffer info adjustment\n"); } Log("IDirectDrawSurface4::%s(this=%#010lx, lpDDSurfaceDesc=%#010lx)\n", ddrawsurface4_hooks[hpos].name, ppvOut, lpDDSurfaceDesc); if(lpDDSurfaceDesc != NULL) { char dwFlags_buffer[LOGBUFFER_MAX], ddscaps1_buffer[LOGBUFFER_MAX], ddpf_buffer[LOGBUFFER_MAX]; FlagsToString(FLAGS_DDSD, CFLAGS_DDSD, lpDDSurfaceDesc->dwFlags, (char *)&dwFlags_buffer, LOGBUFFER_MAX); FlagsToString(FLAGS_DDSCAPS1, CFLAGS_DDSCAPS1, lpDDSurfaceDesc->ddsCaps.dwCaps, (char *)&ddscaps1_buffer, LOGBUFFER_MAX); FlagsToString(FLAGS_DDPF, CFLAGS_DDPF, lpDDSurfaceDesc->ddpfPixelFormat.dwFlags, (char *)&ddpf_buffer, LOGBUFFER_MAX); Log("->lpDDSurfaceDesc { dwSize=%#010lx, dwFlags=%#010lx (%s), dwWidth=%#010lx (%d), dwHeight=%#010lx (%d), lPitch=%#010lx , dwLinearSize=%#010lx, dwBackBufferCount=%#010lx, dwMipMapCount=%#010lx, dwRefreshRate=%#010lx, dwAlphaBitDepth=%#010lx, dwReserved=%#010lx,\n" " lpSurface=%#010lx, ddckCKDestOverlay={ %#010lx, %#010lx }, ddckCKDestBlt={ %#010lx, %#010lx }, ddckCKSrcOverlay={ %#010lx, %#010lx }, ddckCKSrcBlt={ %#010lx, %#010lx },\n" " ddpfPixelFormat={ dwSize=%#010lx, dwFlags=%#010lx (%s), dwFourCC=%#010lx, dwRGBBitCount=%#010lx, dwYUVBitCount=%#010lx, dwZBufferBitDepth=%#010lx, dwAlphaBitDepth=%#010lx, dwLuminanceBitCount=%#010lx, dwBumpBitCount=%#010lx, dwRBitMask=%#010lx,\n" " dwYBitMask=%#010lx, dwStencilBitDepth=%#010lx, dwLuminanceBitMask=%#010lx, dwBumpDuBitMask=%#010lx, dwGBitMask=%#010lx, dwUBitMask=%#010lx, dwZBitMask=%#010lx, dwBumpDvBitMask=%#010lx, dwBBitMask=%#010lx, dwVBitMask=%#010lx, dwStencilBitMask=%#010lx,\n" " dwBumpLuminanceBitMask=%#010lx, dwRGBAlphaBitMask=%#010lx, dwYUVAlphaBitMask=%#010lx, dwLuminanceAlphaBitMask=%#010lx, dwRGBZBitMask=%#010lx, dwYUVZBitMask=%#010lx },\n" " ddsCaps={ %#010lx (%s), %#010lx, %#010lx, %#010lx }, dwTextureStage=%#010lx }\n", lpDDSurfaceDesc->dwSize, lpDDSurfaceDesc->dwFlags, dwFlags_buffer, lpDDSurfaceDesc->dwWidth, (unsigned int)lpDDSurfaceDesc->dwWidth, lpDDSurfaceDesc->dwHeight, (unsigned int)lpDDSurfaceDesc->dwHeight, lpDDSurfaceDesc->lPitch, lpDDSurfaceDesc->dwLinearSize, lpDDSurfaceDesc->dwBackBufferCount, lpDDSurfaceDesc->dwMipMapCount, lpDDSurfaceDesc->dwRefreshRate, lpDDSurfaceDesc->dwAlphaBitDepth, lpDDSurfaceDesc->dwReserved, lpDDSurfaceDesc->lpSurface, lpDDSurfaceDesc->ddckCKDestOverlay.dwColorSpaceLowValue, lpDDSurfaceDesc->ddckCKDestOverlay.dwColorSpaceHighValue, lpDDSurfaceDesc->ddckCKDestBlt.dwColorSpaceLowValue, lpDDSurfaceDesc->ddckCKDestBlt.dwColorSpaceHighValue, lpDDSurfaceDesc->ddckCKSrcOverlay.dwColorSpaceLowValue, lpDDSurfaceDesc->ddckCKSrcOverlay.dwColorSpaceHighValue, lpDDSurfaceDesc->ddckCKSrcBlt.dwColorSpaceLowValue, lpDDSurfaceDesc->ddckCKSrcBlt.dwColorSpaceHighValue, lpDDSurfaceDesc->ddpfPixelFormat.dwSize, lpDDSurfaceDesc->ddpfPixelFormat.dwFlags, ddpf_buffer, lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC, lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount, lpDDSurfaceDesc->ddpfPixelFormat.dwYUVBitCount, lpDDSurfaceDesc->ddpfPixelFormat.dwZBufferBitDepth, lpDDSurfaceDesc->ddpfPixelFormat.dwAlphaBitDepth, lpDDSurfaceDesc->ddpfPixelFormat.dwLuminanceBitCount, lpDDSurfaceDesc->ddpfPixelFormat.dwBumpBitCount, lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwYBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwStencilBitDepth, lpDDSurfaceDesc->ddpfPixelFormat.dwLuminanceBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwBumpDuBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwUBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwZBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwBumpDvBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwVBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwStencilBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwBumpLuminanceBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwRGBAlphaBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwYUVAlphaBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwLuminanceAlphaBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwRGBZBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwYUVZBitMask, lpDDSurfaceDesc->ddsCaps.dwCaps, ddscaps1_buffer, lpDDSurfaceDesc->ddsCaps.dwCaps2, lpDDSurfaceDesc->ddsCaps.dwCaps3, lpDDSurfaceDesc->ddsCaps.dwCaps4, lpDDSurfaceDesc->dwTextureStage ); } return ret; }
const good::string& CTypeToString::ItemDrawFlagsToString( TItemDrawFlags iFlags ) { return FlagsToString( iFlags, EItemDrawTotal, aItemDrawFlags ); }
const good::string& CTypeToString::EntityTypeFlagsToString( TEntityTypeFlags iItemTypeFlags ) { return FlagsToString( iItemTypeFlags, EEntityTypeTotal+1, aItemTypes ); }
HRESULT __stdcall DDRAWSURFACE4_HOOK_Lock(LPVOID *ppvOut, LPRECT lpDestRect, LPDDSURFACEDESC2 lpDDSurfaceDesc, DWORD dwFlags, HANDLE hEvent) { const unsigned int hpos = 25; char dwFlags_buffer[LOGBUFFER_MAX]; FlagsToString(FLAGS_DDLOCK, CFLAGS_DDLOCK, dwFlags, dwFlags_buffer, LOGBUFFER_MAX); Log("IDirectDrawSurface4::%s(this=%#010lx, lpDestRect=%#010lx { left=%d, right=%d, top=%d, bottom=%d }, lpDDSurfaceDesc=%#010lx, dwFlags=%#010lx (%s), hEvent=%#010lx)", ddrawsurface4_hooks[hpos].name, ppvOut, lpDestRect, (lpDestRect != NULL ? lpDestRect->left : NULL), (lpDestRect != NULL ? lpDestRect->right : NULL), (lpDestRect != NULL ? lpDestRect->top : NULL), (lpDestRect != NULL ? lpDestRect->bottom : NULL), lpDDSurfaceDesc, dwFlags, dwFlags_buffer, hEvent); //dwFlags |= DDLOCK_NOSYSLOCK; if (g_config.displaymode && lpDDSurfaceDesc) { DDSURFACEDESC2 sd; memset(&sd, 0, sizeof(DDSURFACEDESC2)); sd.dwSize = sizeof(sd); ((IDirectDrawSurface4 *)ppvOut)->GetSurfaceDesc(&sd); LPDIRECTDRAWSURFACE4 * ppDecoySurface = 0; // If the game is locking the backbuffer, it can do arbitrary stuff in there, // which this wrapper has no chance of making scaled properly. // So the game is given a surface with the dimension it expects, and the wrapper will // scale it up in the UnLock function. // Luckily, this appears to be only used for videos, where simple upscaling is the only option anyway. if((!g_config.fullscreen && (LPDIRECTDRAWSURFACE4)ppvOut == g_backbuffer) || (sd.dwWidth == 640 && sd.dwHeight == 480 && (sd.ddsCaps.dwCaps & DDSCAPS_BACKBUFFER))) { ppDecoySurface = &g_decoyBackBuffer; g_decoyBackLockFlags = dwFlags; Log("Backbuffer locking: substitute decoy surface\n"); } // Similarily, the frontbuffer is read for special effects which also depend on the fixed size. if((!g_config.fullscreen && (LPDIRECTDRAWSURFACE4)ppvOut == g_frontbuffer) || (sd.dwWidth == 640 && sd.dwHeight == 480 && (sd.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))) { ppDecoySurface = &g_decoyFrontBuffer; g_decoyFrontLockFlags = dwFlags; Log("Frontbuffer locking: substitute decoy surface\n"); } if(ppDecoySurface) { DDSURFACEDESC2 ddsd; memset(&ddsd, 0, sizeof(DDSURFACEDESC2)); ddsd.dwSize = sizeof(ddsd); if((*ppDecoySurface) == NULL) { LPDIRECTDRAW4 lpDD = NULL; ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT; ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat); ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB; ddsd.ddpfPixelFormat.dwFourCC = 0; ddsd.ddpfPixelFormat.dwRGBBitCount = 16; ddsd.ddpfPixelFormat.dwRBitMask = 0xf800; ddsd.ddpfPixelFormat.dwGBitMask = 0x07e0; ddsd.ddpfPixelFormat.dwBBitMask = 0x001f; ddsd.dwWidth = 640; ddsd.dwHeight = 480; ddsd.ddsCaps.dwCaps = DDSCAPS_3DDEVICE | DDSCAPS_OFFSCREENPLAIN; ((IDirectDrawSurface4 *)ppvOut)->GetDDInterface((LPVOID *)&lpDD); lpDD->CreateSurface(&ddsd, ppDecoySurface, NULL); SAFE_RELEASE(lpDD); } if((*ppDecoySurface)->IsLost()) (*ppDecoySurface)->Restore(); RECT rcDest, rcSource; sd.dwHeight = displaymode_options[g_config.displaymode].resY; sd.dwWidth = displaymode_options[g_config.displaymode].resX; // FIXME: In windowed mode, the front buffer probably contains the whole screen or something if(sd.dwHeight >= g_game.height) { rcSource.top = (sd.dwHeight - g_game.height)/2; rcSource.bottom = sd.dwHeight - rcSource.top; rcDest.top = 0; rcDest.bottom = 480; } else { rcSource.top = 0; rcSource.bottom = sd.dwHeight; rcDest.top = (LONG)((g_game.height - sd.dwHeight) / (2 * g_game.modY)); rcDest.bottom = 480 - rcDest.top; } if(sd.dwWidth >= g_game.width) { rcSource.left = (sd.dwWidth - g_game.width)/2; rcSource.right = sd.dwWidth - rcSource.left; rcDest.left = 0; rcDest.right = 640; } else { rcSource.left = 0; rcSource.right = sd.dwWidth; rcDest.left = (LONG)((g_game.width - sd.dwWidth) / (2 * g_game.modX)); rcDest.bottom = 640 - rcDest.left; } if(~dwFlags & DDLOCK_WRITEONLY) (*ppDecoySurface)->Blt(&rcDest, (IDirectDrawSurface4 *)ppvOut, &rcSource, DDBLT_WAIT, NULL); HRESULT ret = (*ppDecoySurface)->Lock(lpDestRect, lpDDSurfaceDesc, dwFlags | DDLOCK_WAIT, 0); return ret; } } DDRAWSURFACE4_Lock_Type ofn = (DDRAWSURFACE4_Lock_Type)ddrawsurface4_hooks[hpos].oldFunc; HRESULT ret = ofn(ppvOut, lpDestRect, lpDDSurfaceDesc, dwFlags, hEvent); LogDXError(ret); Log("\n"); if(lpDDSurfaceDesc != NULL) { char dwFlags_buffer[LOGBUFFER_MAX], ddscaps1_buffer[LOGBUFFER_MAX], ddpf_buffer[LOGBUFFER_MAX]; FlagsToString(FLAGS_DDSD, CFLAGS_DDSD, lpDDSurfaceDesc->dwFlags, (char *)&dwFlags_buffer, LOGBUFFER_MAX); FlagsToString(FLAGS_DDSCAPS1, CFLAGS_DDSCAPS1, lpDDSurfaceDesc->ddsCaps.dwCaps, (char *)&ddscaps1_buffer, LOGBUFFER_MAX); FlagsToString(FLAGS_DDPF, CFLAGS_DDPF, lpDDSurfaceDesc->ddpfPixelFormat.dwFlags, (char *)&ddpf_buffer, LOGBUFFER_MAX); Log("->lpDDSurfaceDesc { dwSize=%#010lx, dwFlags=%#010lx (%s), dwWidth=%#010lx (%d), dwHeight=%#010lx (%d), lPitch=%#010lx , dwLinearSize=%#010lx, dwBackBufferCount=%#010lx, dwMipMapCount=%#010lx, dwRefreshRate=%#010lx, dwAlphaBitDepth=%#010lx, dwReserved=%#010lx,\n" " lpSurface=%#010lx, ddckCKDestOverlay={ %#010lx, %#010lx }, ddckCKDestBlt={ %#010lx, %#010lx }, ddckCKSrcOverlay={ %#010lx, %#010lx }, ddckCKSrcBlt={ %#010lx, %#010lx },\n" " ddpfPixelFormat={ dwSize=%#010lx, dwFlags=%#010lx (%s), dwFourCC=%#010lx, dwRGBBitCount=%#010lx, dwYUVBitCount=%#010lx, dwZBufferBitDepth=%#010lx, dwAlphaBitDepth=%#010lx, dwLuminanceBitCount=%#010lx, dwBumpBitCount=%#010lx, dwRBitMask=%#010lx,\n" " dwYBitMask=%#010lx, dwStencilBitDepth=%#010lx, dwLuminanceBitMask=%#010lx, dwBumpDuBitMask=%#010lx, dwGBitMask=%#010lx, dwUBitMask=%#010lx, dwZBitMask=%#010lx, dwBumpDvBitMask=%#010lx, dwBBitMask=%#010lx, dwVBitMask=%#010lx, dwStencilBitMask=%#010lx,\n" " dwBumpLuminanceBitMask=%#010lx, dwRGBAlphaBitMask=%#010lx, dwYUVAlphaBitMask=%#010lx, dwLuminanceAlphaBitMask=%#010lx, dwRGBZBitMask=%#010lx, dwYUVZBitMask=%#010lx },\n" " ddsCaps={ %#010lx (%s), %#010lx, %#010lx, %#010lx }, dwTextureStage=%#010lx }\n", lpDDSurfaceDesc->dwSize, lpDDSurfaceDesc->dwFlags, dwFlags_buffer, lpDDSurfaceDesc->dwWidth, (unsigned int)lpDDSurfaceDesc->dwWidth, lpDDSurfaceDesc->dwHeight, (unsigned int)lpDDSurfaceDesc->dwHeight, lpDDSurfaceDesc->lPitch, lpDDSurfaceDesc->dwLinearSize, lpDDSurfaceDesc->dwBackBufferCount, lpDDSurfaceDesc->dwMipMapCount, lpDDSurfaceDesc->dwRefreshRate, lpDDSurfaceDesc->dwAlphaBitDepth, lpDDSurfaceDesc->dwReserved, lpDDSurfaceDesc->lpSurface, lpDDSurfaceDesc->ddckCKDestOverlay.dwColorSpaceLowValue, lpDDSurfaceDesc->ddckCKDestOverlay.dwColorSpaceHighValue, lpDDSurfaceDesc->ddckCKDestBlt.dwColorSpaceLowValue, lpDDSurfaceDesc->ddckCKDestBlt.dwColorSpaceHighValue, lpDDSurfaceDesc->ddckCKSrcOverlay.dwColorSpaceLowValue, lpDDSurfaceDesc->ddckCKSrcOverlay.dwColorSpaceHighValue, lpDDSurfaceDesc->ddckCKSrcBlt.dwColorSpaceLowValue, lpDDSurfaceDesc->ddckCKSrcBlt.dwColorSpaceHighValue, lpDDSurfaceDesc->ddpfPixelFormat.dwSize, lpDDSurfaceDesc->ddpfPixelFormat.dwFlags, ddpf_buffer, lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC, lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount, lpDDSurfaceDesc->ddpfPixelFormat.dwYUVBitCount, lpDDSurfaceDesc->ddpfPixelFormat.dwZBufferBitDepth, lpDDSurfaceDesc->ddpfPixelFormat.dwAlphaBitDepth, lpDDSurfaceDesc->ddpfPixelFormat.dwLuminanceBitCount, lpDDSurfaceDesc->ddpfPixelFormat.dwBumpBitCount, lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwYBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwStencilBitDepth, lpDDSurfaceDesc->ddpfPixelFormat.dwLuminanceBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwBumpDuBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwUBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwZBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwBumpDvBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwVBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwStencilBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwBumpLuminanceBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwRGBAlphaBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwYUVAlphaBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwLuminanceAlphaBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwRGBZBitMask, lpDDSurfaceDesc->ddpfPixelFormat.dwYUVZBitMask, lpDDSurfaceDesc->ddsCaps.dwCaps, ddscaps1_buffer, lpDDSurfaceDesc->ddsCaps.dwCaps2, lpDDSurfaceDesc->ddsCaps.dwCaps3, lpDDSurfaceDesc->ddsCaps.dwCaps4, lpDDSurfaceDesc->dwTextureStage ); g_lockedSurface = (LPDIRECTDRAWSURFACE4)ppvOut; g_lpSurface = lpDDSurfaceDesc->lpSurface; } return ret; }
void HK_CALL DumpHavokClassImpl(hkClass* hclass) { char fbuffer[260], buffer[1024]; const char *ptr = hclass->getName(); int ver = hclass->getDescribedVersion(); sprintf_s(fbuffer, 256, "%s\\%s_%d.cpp", s_rootPath, ptr, ver); char outdir[MAX_PATH]; strcpy(outdir, fbuffer); PathRemoveFileSpec(outdir); CreateDirectories(outdir); hkClass* pParent = hclass->getParent(); FILE *hFile = NULL; fopen_s(&hFile, fbuffer, "wt" ); if ( hFile != NULL ) { PrintLine(hFile, "#include \"StdAfx.h\""); PrintLine(hFile, "#include \"%s_%d.h\"", ptr, ver); PrintLine(hFile, ""); PrintLine(hFile, "#include <Common/Serialize/hkSerialize.h>"); PrintLine(hFile, "#include <Common/Serialize/Util/hkSerializeUtil.h>"); PrintLine(hFile, "#include <Common/Serialize/Version/hkVersionPatchManager.h>"); PrintLine(hFile, "#include <Common/Serialize/Data/Dict/hkDataObjectDict.h>"); PrintLine(hFile, "#include <Common/Serialize/Data/Native/hkDataObjectNative.h>"); PrintLine(hFile, "#include <Common/Serialize/Data/Util/hkDataObjectUtil.h>"); PrintLine(hFile, "#include <Common/Base/Reflection/Registry/hkDynamicClassNameRegistry.h>"); PrintLine(hFile, "#include <Common/Base/Reflection/Registry/hkVtableClassRegistry.h>"); PrintLine(hFile, "#include <Common/Base/Reflection/hkClass.h>"); PrintLine(hFile, "#include <Common/Base/Reflection/hkInternalClassMember.h>"); PrintLine(hFile, "#include <Common/Serialize/Util/hkSerializationCheckingUtils.h>"); PrintLine(hFile, "#include <Common/Serialize/Util/hkVersionCheckingUtils.h>"); PrintLine(hFile, ""); PrintLine(hFile, ""); if ( 0 < hclass->getNumDeclaredEnums()) { for (int i=0,n=hclass->getNumDeclaredEnums();i<n;++i) { const hkClassEnum &hEnum = hclass->getDeclaredEnum(i); PrintLine(hFile, "static const hkInternalClassEnumItem %sEnumItems[] =", hEnum.getName()); PrintLine(hFile, "{"); for (int j=0,m=hEnum.getNumItems();j<m;++j) { const hkClassEnum::Item& item = hEnum.getItem(j); PrintLine(hFile, " {%d, \"%s\"},", item.getValue(), item.getName()); } PrintLine(hFile, "};"); PrintLine(hFile, ""); } PrintLine(hFile, "static const hkInternalClassEnum %sClass_Enums[] = {", ptr); for (int i=0,n=hclass->getNumDeclaredEnums();i<n;++i) { const hkClassEnum &hEnum = hclass->getDeclaredEnum(i); PrintLine(hFile, " {\"%s\", %sEnumItems, _countof(%sEnumItems), HK_NULL, %d },", hEnum.getName(),hEnum.getName(),hEnum.getName(), hEnum.getFlags()); } PrintLine(hFile, "};"); for (int i=0,n=hclass->getNumDeclaredEnums();i<n;++i) { const hkClassEnum &hEnum = hclass->getDeclaredEnum(i); PrintLine(hFile, "const hkClassEnum* %sEnum = reinterpret_cast<const hkClassEnum*>(&%sClass_Enums[%d]);", hEnum.getName(), ptr, i); } PrintLine(hFile, ""); } if ( hclass->getNumDeclaredMembers() > 0) { PrintLine(hFile, "static const hkInternalClassMember %sClass_Members[] =", ptr); PrintLine(hFile, "{"); for (int i=0,n=hclass->getNumDeclaredMembers();i<n;++i) { const hkClassMember &mem = hclass->getDeclaredMember(i); mem.getTypeName(buffer, 1024); fprintf(hFile, " { \"%s\"", mem.getName()); if ( !mem.hasClass() ) fprintf(hFile, ",HK_NULL"); else if (const hkClass* mclass = mem.getClass()) fprintf(hFile, ",&%sClass", mclass->getName()); else fprintf(hFile, ",HK_NULL"); if ( !mem.hasEnumClass() ) fprintf(hFile, ",HK_NULL"); else fprintf(hFile, ",%sEnum", mem.getEnumClass().getName()); string typeStr = EnumToString(mem.getType(), TypeEnums); fprintf(hFile, ",%s", typeStr.c_str()); string subTypeStr = EnumToString(mem.getSubType(), TypeEnums); fprintf(hFile, ",%s", subTypeStr.c_str()); fprintf(hFile, ",%d", mem.getCstyleArraySize()); string flagsStr = FlagsToString((int)*(short*)&mem.getFlags(), TypeFlags); fprintf(hFile, ",%s", flagsStr.c_str()); fprintf(hFile, ",HK_OFFSET_OF(%s,m_%s) /*%d*/", ptr, mem.getName(), mem.getOffset()); if ( hclass->hasDeclaredDefault(i) ) { //hkTypedUnion value; //if (HK_SUCCESS == hclass->getDeclaredDefault(i, value)) // fprintf(hFile, ",%08lx", value.getStorage().m_int32); //else fprintf(hFile, ",HK_NULL"); } else fprintf(hFile, ",HK_NULL"); fprintf(hFile, "},\n"); } PrintLine(hFile, "};"); PrintLine(hFile, ""); } PrintLine(hFile, "// Signature: %08lx", hclass->getSignature()); if (pParent != NULL) PrintLine(hFile, "extern const hkClass %sClass;", pParent->getName()); PrintLine(hFile, "extern const hkClass %sClass;", ptr); PrintLine(hFile, "const hkClass %sClass(", ptr); PrintLine(hFile, " \"%s\",", ptr); if (pParent == NULL) PrintLine(hFile, " HK_NULL, // parent"); else PrintLine(hFile, " &%sClass, // parent", pParent->getName()); PrintLine(hFile, " sizeof(%s),", ptr); if (hclass->getNumDeclaredInterfaces() > 0) PrintLine(hFile, " reinterpret_cast<const hkClassMember*>(%sClass_IFaces), HK_COUNT_OF(%sClass_IFaces),", ptr, ptr); else PrintLine(hFile, " HK_NULL, 0, // interfaces"); if (hclass->getNumDeclaredEnums() > 0) PrintLine(hFile, " reinterpret_cast<const hkClassEnum*>(%sClass_Enums), HK_COUNT_OF(%sClass_Enums),", ptr, ptr); else PrintLine(hFile, " HK_NULL, 0, // enums"); if (hclass->getNumDeclaredMembers() > 0) PrintLine(hFile, " reinterpret_cast<const hkClassMember*>(%sClass_Members), HK_COUNT_OF(%sClass_Members),", ptr, ptr); else PrintLine(hFile, " HK_NULL, 0, // members"); PrintLine(hFile, " HK_NULL, // defaults"); PrintLine(hFile, " HK_NULL, // attributes"); PrintLine(hFile, " %d, // flags", hclass->getFlags()); PrintLine(hFile, " %d // version", ver); PrintLine(hFile, " );"); if (hclass->hasVtable()) PrintLine(hFile, "HK_REFLECTION_DEFINE_VIRTUAL(%s, %s);", ptr, ptr); else PrintLine(hFile, "HK_REFLECTION_DEFINE_SIMPLE(%s, %s);", ptr, ptr); PrintLine(hFile, ""); fflush(hFile); fclose(hFile); } }