|
|
@@ -1,3458 +0,0 @@
|
|
|
-// Filename: wdxGraphicsWindow.cxx
|
|
|
-// Created by: mike (09Jan00)
|
|
|
-//
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-//
|
|
|
-// PANDA 3D SOFTWARE
|
|
|
-// Copyright (c) 2001, Disney Enterprises, Inc. All rights reserved
|
|
|
-//
|
|
|
-// All use of this software is subject to the terms of the Panda 3d
|
|
|
-// Software license. You should have received a copy of this license
|
|
|
-// along with this source code; you will also find a current copy of
|
|
|
-// the license at http://www.panda3d.org/license.txt .
|
|
|
-//
|
|
|
-// To contact the maintainers of this program write to
|
|
|
-// [email protected] .
|
|
|
-//
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-
|
|
|
-#include <errno.h>
|
|
|
-#include <time.h>
|
|
|
-#include <math.h>
|
|
|
-#include <tchar.h>
|
|
|
-#include "wdxGraphicsWindow8.h"
|
|
|
-#include "wdxGraphicsPipe8.h"
|
|
|
-#include "config_wdxdisplay8.h"
|
|
|
-
|
|
|
-#include <keyboardButton.h>
|
|
|
-#include <mouseButton.h>
|
|
|
-#include <throw_event.h>
|
|
|
-
|
|
|
-#ifdef DO_PSTATS
|
|
|
-#include <pStatTimer.h>
|
|
|
-#endif
|
|
|
-
|
|
|
-#include <ddraw.h>
|
|
|
-#include <map>
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Static variables
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-TypeHandle wdxGraphicsWindow::_type_handle;
|
|
|
-
|
|
|
-#define LAST_ERROR 0
|
|
|
-#define ERRORBOX_TITLE "Panda3D Error"
|
|
|
-#define WDX_WINDOWCLASSNAME "wdxDisplay"
|
|
|
-#define WDX_WINDOWCLASSNAME_NOCURSOR WDX_WINDOWCLASSNAME "_NoCursor"
|
|
|
-#define DEFAULT_CURSOR IDC_ARROW
|
|
|
-
|
|
|
-// define this to enable debug testing of dinput joystick
|
|
|
-//#define DINPUT_DEBUG_POLL
|
|
|
-
|
|
|
-typedef map<HWND,wdxGraphicsWindow *> HWND_PANDAWIN_MAP;
|
|
|
-
|
|
|
-// CardIDVec is used in DX7 lowmem card-classification pass so DX8 can
|
|
|
-// establish correspondence b/w DX7 mem info & DX8 device
|
|
|
-typedef struct {
|
|
|
- HMONITOR hMon;
|
|
|
- DWORD MaxAvailVidMem;
|
|
|
- bool bIsLowVidMemCard;
|
|
|
- GUID DX7_DeviceGUID;
|
|
|
- DWORD VendorID,DeviceID;
|
|
|
-// char szDriver[MAX_DEVICE_IDENTIFIER_STRING];
|
|
|
-} CardID;
|
|
|
-
|
|
|
-typedef vector<CardID> CardIDVec;
|
|
|
-static CardIDVec *g_pCardIDVec=NULL;
|
|
|
-
|
|
|
-HWND_PANDAWIN_MAP hwnd_pandawin_map;
|
|
|
-wdxGraphicsWindow* global_wdxwinptr = NULL; // need this for temporary windproc
|
|
|
-
|
|
|
-#define MAX_DISPLAYS 20
|
|
|
-
|
|
|
-#define PAUSED_TIMER_ID 7 // completely arbitrary choice
|
|
|
-#define JOYSTICK_POLL_TIMER_ID 8
|
|
|
-#define DX_IS_READY ((_dxgsg!=NULL)&&(_dxgsg->GetDXReady()))
|
|
|
-
|
|
|
-LONG WINAPI static_window_proc(HWND hwnd, UINT msg, WPARAM wparam,LPARAM lparam);
|
|
|
-
|
|
|
-// imperfect method to ID NVid? could also scan desc str, but that isnt fullproof either
|
|
|
-#define IS_NVIDIA(DDDEVICEID) ((DDDEVICEID.VendorId==0x10DE) || (DDDEVICEID.VendorId==0x12D2))
|
|
|
-#define IS_ATI(DDDEVICEID) (DDDEVICEID.VendorId==0x1002)
|
|
|
-#define IS_MATROX(DDDEVICEID) (DDDEVICEID.VendorId==0x102B)
|
|
|
-
|
|
|
-// because we dont have access to ModifierButtons, as a hack just synchronize state of these
|
|
|
-// keys on get/lose keybd focus
|
|
|
-#define NUM_MODIFIER_KEYS 16
|
|
|
-unsigned int hardcoded_modifier_buttons[NUM_MODIFIER_KEYS]={VK_SHIFT,VK_MENU,VK_CONTROL,VK_SPACE,VK_TAB,
|
|
|
- VK_UP,VK_DOWN,VK_LEFT,VK_RIGHT,VK_PRIOR,VK_NEXT,VK_HOME,VK_END,
|
|
|
- VK_INSERT,VK_DELETE,VK_ESCAPE};
|
|
|
-
|
|
|
-#define UNKNOWN_VIDMEM_SIZE 0xFFFFFFFF
|
|
|
-/*
|
|
|
-static DWORD BitDepth_2_DDBDMask(DWORD iBitDepth) {
|
|
|
- switch(iBitDepth) {
|
|
|
- case 16: return DDBD_16;
|
|
|
- case 32: return DDBD_32;
|
|
|
- case 24: return DDBD_24;
|
|
|
- case 8: return DDBD_8;
|
|
|
- case 1: return DDBD_1;
|
|
|
- case 2: return DDBD_2;
|
|
|
- case 4: return DDBD_4;
|
|
|
- }
|
|
|
- return 0x0;
|
|
|
-}
|
|
|
-
|
|
|
-typedef enum {DBGLEV_FATAL,DBGLEV_ERROR,DBGLEV_WARNING,DBGLEV_INFO,DBGLEV_DEBUG,DBGLEV_SPAM
|
|
|
- } DebugLevels;
|
|
|
-
|
|
|
-void PrintDBGStr(DebugLevels level,HRESULT hr,const char *msgstr) {
|
|
|
- ostream *pstrm;
|
|
|
- static ostream dbg_strms[DBGLEV_SPAM+1]={wdxdisplay_cat.fatal,wdxdisplay_cat.error,
|
|
|
- wdxdisplay_cat.warning,wdxdisplay_cat.info,wdxdisplay_cat.debug,wdxdisplay_cat.spam};
|
|
|
- assert(level<=DBGLEV_SPAM);
|
|
|
-
|
|
|
- pstrm=dbg_strms[level];
|
|
|
- (*pstrm)->fatal() << "GetDisplayMode failed, hr = " << ConvD3DErrorToString(hr) << endl;
|
|
|
-}
|
|
|
-*/
|
|
|
-
|
|
|
-// pops up MsgBox w/system error msg
|
|
|
-#define LAST_ERROR 0
|
|
|
-void PrintErrorMessage(DWORD msgID) {
|
|
|
- LPTSTR pMessageBuffer;
|
|
|
-
|
|
|
- if(msgID==LAST_ERROR)
|
|
|
- msgID=GetLastError();
|
|
|
-
|
|
|
- FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
|
|
|
- NULL,msgID,
|
|
|
- MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), //The user default language
|
|
|
- (LPTSTR) &pMessageBuffer, // the weird ptrptr->ptr cast is intentional, see FORMAT_MESSAGE_ALLOCATE_BUFFER
|
|
|
- 1024, NULL);
|
|
|
- MessageBox(GetDesktopWindow(),pMessageBuffer,_T(ERRORBOX_TITLE),MB_OK);
|
|
|
- wdxdisplay_cat.fatal() << "System error msg: " << pMessageBuffer << endl;
|
|
|
- LocalFree( pMessageBuffer );
|
|
|
-}
|
|
|
-
|
|
|
-//#if defined(NOTIFY_DEBUG) || defined(DO_PSTATS)
|
|
|
-//#ifdef _DEBUG
|
|
|
-#if 0
|
|
|
-extern void dbgPrintVidMem(LPDIRECTDRAW7 pDD, LPDDSCAPS2 lpddsCaps,const char *pMsg) {
|
|
|
- DWORD dwTotal,dwFree;
|
|
|
- HRESULT hr;
|
|
|
-
|
|
|
- // These Caps bits arent allowed to be specified when calling GetAvailVidMem.
|
|
|
- // They don't affect surface allocation in a vram heap.
|
|
|
-
|
|
|
-#define AVAILVIDMEM_BADCAPS (DDSCAPS_BACKBUFFER | \
|
|
|
- DDSCAPS_FRONTBUFFER | \
|
|
|
- DDSCAPS_COMPLEX | \
|
|
|
- DDSCAPS_FLIP | \
|
|
|
- DDSCAPS_OWNDC | \
|
|
|
- DDSCAPS_PALETTE | \
|
|
|
- DDSCAPS_SYSTEMMEMORY | \
|
|
|
- DDSCAPS_VISIBLE | \
|
|
|
- DDSCAPS_WRITEONLY)
|
|
|
-
|
|
|
- DDSCAPS2 ddsCaps = *lpddsCaps;
|
|
|
- ddsCaps.dwCaps &= ~(AVAILVIDMEM_BADCAPS); // turn off the bad caps
|
|
|
-// ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY; done internally by DX anyway
|
|
|
-
|
|
|
- if(FAILED( hr = pDD->GetAvailableVidMem(&ddsCaps,&dwTotal,&dwFree))) {
|
|
|
- wdxdisplay_cat.debug() << "GetAvailableVidMem failed : hr = " << ConvD3DErrorToString(hr) << endl;
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- // Write a debug message to the console reporting the texture memory.
|
|
|
- char tmpstr[100],tmpstr2[100];
|
|
|
- sprintf(tmpstr,"%.4g",dwTotal/1000000.0);
|
|
|
- sprintf(tmpstr2,"%.4g",dwFree/1000000.0);
|
|
|
- if(wdxdisplay_cat.is_debug())
|
|
|
- wdxdisplay_cat.debug() << "AvailableVidMem before creating "<< pMsg << ",(megs) total: " << tmpstr << " free:" << tmpstr2 <<endl;
|
|
|
-}
|
|
|
-#endif
|
|
|
-
|
|
|
-void ClearToBlack(HWND hWnd,GraphicsWindow::Properties &props) {
|
|
|
- // clear to black
|
|
|
- HDC hDC=GetDC(hWnd); // GetDC is not particularly fast. if this needs to be super-quick, we should cache GetDC's hDC
|
|
|
- RECT clrRect={props._xorg,props._yorg,props._xorg+props._xsize,props._yorg+props._ysize};
|
|
|
- FillRect(hDC,&clrRect,(HBRUSH)GetStockObject(BLACK_BRUSH));
|
|
|
-// PatBlt(hDC,_props._xorg,_props._yorg,_props._xsize,_props._ysize,BLACKNESS);
|
|
|
- ReleaseDC(hWnd,hDC);
|
|
|
- GdiFlush();
|
|
|
-}
|
|
|
-
|
|
|
-// fn exists so AtExitFn can call it without refcntr blowing up since its !=0
|
|
|
-void wdxGraphicsWindow::DestroyMe(bool bAtExitFnCalled) {
|
|
|
- if(wdxdisplay_cat.is_spam())
|
|
|
- wdxdisplay_cat.spam() << "DestroyMe called, AtExitFnCalled=" << bAtExitFnCalled << endl;
|
|
|
-
|
|
|
- _exiting_window = true; // may be needed for DestroyWindow call
|
|
|
- DXScreenData scrn;
|
|
|
- memcpy(&scrn,&_dxgsg->scrn,sizeof(DXScreenData));
|
|
|
-
|
|
|
- if(_dxgsg!=NULL) {
|
|
|
- _dxgsg->dx_cleanup(_props._fullscreen, bAtExitFnCalled);
|
|
|
- _dxgsg=NULL;
|
|
|
- }
|
|
|
-
|
|
|
-/*
|
|
|
- if(scrn._hdc!=NULL) {
|
|
|
- ReleaseDC(scrn.hWnd,scrn._hdc);
|
|
|
-// _hdc = NULL;
|
|
|
- }
|
|
|
-*/
|
|
|
-
|
|
|
- if(scrn.hWnd!=NULL) {
|
|
|
- DestroyWindow(scrn.hWnd);
|
|
|
- hwnd_pandawin_map.erase(scrn.hWnd);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void wdxGraphicsWindow::do_close_window() {
|
|
|
- GraphicsWindow::do_close_window();
|
|
|
- DestroyMe(false);
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: Destructor
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-wdxGraphicsWindow::~wdxGraphicsWindow(void) {
|
|
|
- close_window();
|
|
|
-}
|
|
|
-
|
|
|
-void DestroyAllWindows(bool bAtExitFnCalled) {
|
|
|
- // need to go through all windows in map var and delete them
|
|
|
- while(!hwnd_pandawin_map.empty()) {
|
|
|
- // cant use a for loop cause DestroyMe erases things out from under us, so iterator is invalid
|
|
|
- HWND_PANDAWIN_MAP::iterator pwin = hwnd_pandawin_map.begin();
|
|
|
- if((*pwin).second != NULL)
|
|
|
- (*pwin).second->DestroyMe(bAtExitFnCalled);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void AtExitFn() {
|
|
|
-#ifdef _DEBUG
|
|
|
- wdxdisplay_cat.spam() << "AtExitFn called\n";
|
|
|
-#endif
|
|
|
-
|
|
|
- restore_global_parameters();
|
|
|
-
|
|
|
- DestroyAllWindows(true);
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: wdxGraphicsWindow::set_window_handle
|
|
|
-// Access: Public
|
|
|
-// Description: This is called on the object once the actual Window
|
|
|
-// has been created. It gives the window handle of the
|
|
|
-// created window so the wdxGraphicsWindow object can
|
|
|
-// perform any additional initialization based on this.
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-void wdxGraphicsWindow::
|
|
|
-set_window_handle(HWND hwnd) {
|
|
|
- // Tell the associated dxGSG about the window handle.
|
|
|
- _dxgsg->scrn.hWnd = hwnd;
|
|
|
-
|
|
|
- // Determine the initial open status of the IME.
|
|
|
- _ime_open = false;
|
|
|
- _ime_active = false;
|
|
|
- HIMC hIMC = ImmGetContext(hwnd);
|
|
|
- if (hIMC != 0) {
|
|
|
- _ime_open = (ImmGetOpenStatus(hIMC) != 0);
|
|
|
- ImmReleaseContext(hwnd, hIMC);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: static_window_proc
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-LONG WINAPI static_window_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) {
|
|
|
- HWND_PANDAWIN_MAP::iterator pwin;
|
|
|
- pwin=hwnd_pandawin_map.find(hwnd);
|
|
|
-
|
|
|
- if(pwin!=hwnd_pandawin_map.end()) {
|
|
|
- wdxGraphicsWindow *wdxwinptr=(*pwin).second;
|
|
|
- return wdxwinptr->window_proc(hwnd, msg, wparam, lparam);
|
|
|
- } else if(global_wdxwinptr!=NULL){
|
|
|
- // this stuff should only be used during CreateWindow()
|
|
|
- return global_wdxwinptr->window_proc(hwnd, msg, wparam, lparam);
|
|
|
- } else {
|
|
|
- // should never need this?? (maybe at shutdwn?)
|
|
|
- return DefWindowProc(hwnd, msg, wparam, lparam);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-// Note: could use _TrackMouseEvent in comctrl32.dll (part of IE 3.0+) which emulates
|
|
|
-// TrackMouseEvent on w95, but that requires another 500K of memory to hold that DLL,
|
|
|
-// which is lame just to support w95, which probably has other issues anyway
|
|
|
-INLINE void wdxGraphicsWindow::
|
|
|
-track_mouse_leaving(HWND hwnd) {
|
|
|
- TRACKMOUSEEVENT tme = {sizeof(TRACKMOUSEEVENT),TME_LEAVE,hwnd,0};
|
|
|
- BOOL bSucceeded = TrackMouseEvent(&tme); // tell win32 to post WM_MOUSELEAVE msgs
|
|
|
-
|
|
|
- if((!bSucceeded) && wdxdisplay_cat.is_debug())
|
|
|
- wdxdisplay_cat.debug() << "TrackMouseEvent failed!, LastError=" << GetLastError() << endl;
|
|
|
-
|
|
|
- _tracking_mouse_leaving=true;
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: window_proc
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-LONG wdxGraphicsWindow::
|
|
|
-window_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) {
|
|
|
- int button = -1;
|
|
|
- int x, y, width, height;
|
|
|
-
|
|
|
- switch(msg) {
|
|
|
- case WM_PAINT: {
|
|
|
- if((_WindowAdjustingType != NotAdjusting) || (!DX_IS_READY)) {
|
|
|
- // let DefWndProc do WM_ERASEBKGND & just draw black,
|
|
|
- // rather than forcing Present to stretchblt the old window contents
|
|
|
- // into the new size
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- PAINTSTRUCT ps;
|
|
|
- BeginPaint(hwnd, &ps);
|
|
|
- if(DX_IS_READY) {
|
|
|
- _dxgsg->show_frame(true); // 'true' since just want to show the last rendered backbuf, if any
|
|
|
- }
|
|
|
- EndPaint(hwnd, &ps);
|
|
|
- return 0;
|
|
|
- }
|
|
|
-
|
|
|
- case WM_MOUSEMOVE: {
|
|
|
- if(!DX_IS_READY)
|
|
|
- break;
|
|
|
-
|
|
|
- // Win32 doesn't return the same numbers as X does when the mouse
|
|
|
- // goes beyond the upper or left side of the window
|
|
|
- #define SET_MOUSE_COORD(iVal,VAL) { \
|
|
|
- iVal = VAL; \
|
|
|
- if(iVal & 0x8000) \
|
|
|
- iVal -= 0x10000; \
|
|
|
- }
|
|
|
-
|
|
|
- if(!_tracking_mouse_leaving) {
|
|
|
- // need to re-call TrackMouseEvent every time mouse re-enters window
|
|
|
- track_mouse_leaving(hwnd);
|
|
|
- }
|
|
|
-
|
|
|
- WORD newX=LOWORD(lparam);
|
|
|
- WORD newY=HIWORD(lparam);
|
|
|
-
|
|
|
- SET_MOUSE_COORD(x,newX);
|
|
|
- SET_MOUSE_COORD(y,newY);
|
|
|
-
|
|
|
- handle_mouse_motion(x, y);
|
|
|
- if(_props._fullscreen && (_dxgsg!=NULL) && (_dxgsg->scrn.pD3DDevice!=NULL))
|
|
|
- _dxgsg->scrn.pD3DDevice->SetCursorPosition(newX,newY,D3DCURSOR_IMMEDIATE_UPDATE);
|
|
|
- return 0;
|
|
|
- }
|
|
|
-
|
|
|
- // if cursor is invisible, make it visible when moving in the window bars,etc
|
|
|
- case WM_NCMOUSEMOVE: {
|
|
|
- if(!_props._bCursorIsVisible) {
|
|
|
- if(!_cursor_in_windowclientarea) {
|
|
|
-// SetCursor(_pParentWindowGroup->_hMouseCursor);
|
|
|
- ShowCursor(true);
|
|
|
- _cursor_in_windowclientarea=true;
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case WM_NCMOUSELEAVE: {
|
|
|
- if(!_props._bCursorIsVisible) {
|
|
|
- ShowCursor(false);
|
|
|
-// SetCursor(NULL);
|
|
|
- _cursor_in_windowclientarea=false;
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case WM_MOUSELEAVE: {
|
|
|
- // wdxdisplay_cat.fatal() << "XXXXX WM_MOUSELEAVE received\n";
|
|
|
-
|
|
|
- _tracking_mouse_leaving=false;
|
|
|
- handle_mouse_exit();
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case WM_CREATE: {
|
|
|
- track_mouse_leaving(hwnd);
|
|
|
- _cursor_in_windowclientarea=false;
|
|
|
- ClearToBlack(hwnd,_props);
|
|
|
- set_cursor_visibility(true);
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case WM_IME_NOTIFY:
|
|
|
- if (wparam == IMN_SETOPENSTATUS) {
|
|
|
- HIMC hIMC = ImmGetContext(hwnd);
|
|
|
- nassertr(hIMC != 0, 0);
|
|
|
- _ime_open = (ImmGetOpenStatus(hIMC) != 0);
|
|
|
- if (!_ime_open) {
|
|
|
- _ime_active = false; // Sanity enforcement.
|
|
|
- }
|
|
|
- ImmReleaseContext(hwnd, hIMC);
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_IME_STARTCOMPOSITION:
|
|
|
- // In case we're running fullscreen mode, we have to turn on
|
|
|
- // explicit DX support for overlay windows now, so we'll be able
|
|
|
- // to see the IME window.
|
|
|
- _dxgsg->support_overlay_window(true);
|
|
|
- _ime_active = true;
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_IME_ENDCOMPOSITION:
|
|
|
- // Turn off the support for overlay windows, since we're done
|
|
|
- // with the IME window for now and it just slows things down.
|
|
|
- _dxgsg->support_overlay_window(false);
|
|
|
- _ime_active = false;
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_IME_COMPOSITION:
|
|
|
- if (lparam & GCS_RESULTSTR) {
|
|
|
- if (!_input_devices.empty()) {
|
|
|
- HIMC hIMC = ImmGetContext(hwnd);
|
|
|
- nassertr(hIMC != 0, 0);
|
|
|
-
|
|
|
- static const int max_ime_result = 128;
|
|
|
- static char ime_result[max_ime_result];
|
|
|
-
|
|
|
- if (_ime_composition_w) {
|
|
|
- // Since ImmGetCompositionStringA() doesn't seem to work
|
|
|
- // for Win2000 (it always returns question mark
|
|
|
- // characters), we have to use ImmGetCompositionStringW()
|
|
|
- // on this OS. This is actually the easier of the two
|
|
|
- // functions to use.
|
|
|
-
|
|
|
- DWORD result_size =
|
|
|
- ImmGetCompositionStringW(hIMC, GCS_RESULTSTR,
|
|
|
- ime_result, max_ime_result);
|
|
|
-
|
|
|
- // Add this string into the text buffer of the application.
|
|
|
-
|
|
|
- // ImmGetCompositionStringW() returns a string, but it's
|
|
|
- // filled in with wstring data: every two characters defines a
|
|
|
- // 16-bit unicode char. The docs aren't clear on the
|
|
|
- // endianness of this. I guess it's safe to assume all Win32
|
|
|
- // machines are little-endian.
|
|
|
- for (DWORD i = 0; i < result_size; i += 2) {
|
|
|
- int result =
|
|
|
- ((int)(unsigned char)ime_result[i + 1] << 8) |
|
|
|
- (unsigned char)ime_result[i];
|
|
|
- _input_devices[0].keystroke(result);
|
|
|
- }
|
|
|
- } else {
|
|
|
- // On the other hand, ImmGetCompositionStringW() doesn't
|
|
|
- // work on Win95 or Win98; for these OS's we must use
|
|
|
- // ImmGetCompositionStringA().
|
|
|
- DWORD result_size =
|
|
|
- ImmGetCompositionStringA(hIMC, GCS_RESULTSTR,
|
|
|
- ime_result, max_ime_result);
|
|
|
-
|
|
|
- // ImmGetCompositionStringA() returns an encoded ANSI
|
|
|
- // string, which we now have to map to wide-character
|
|
|
- // Unicode.
|
|
|
- static const int max_wide_result = 128;
|
|
|
- static wchar_t wide_result[max_wide_result];
|
|
|
-
|
|
|
- int wide_size =
|
|
|
- MultiByteToWideChar(CP_ACP, 0,
|
|
|
- ime_result, result_size,
|
|
|
- wide_result, max_wide_result);
|
|
|
- if (wide_size == 0) {
|
|
|
- PrintErrorMessage(LAST_ERROR);
|
|
|
- }
|
|
|
- for (int i = 0; i < wide_size; i++) {
|
|
|
- _input_devices[0].keystroke(wide_result[i]);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- ImmReleaseContext(hwnd, hIMC);
|
|
|
- }
|
|
|
- return 0;
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_CHAR:
|
|
|
- // Ignore WM_CHAR messages if we have the IME open, since
|
|
|
- // everything will come in through WM_IME_COMPOSITION. (It's
|
|
|
- // supposed to come in through WM_CHAR, too, but there seems to
|
|
|
- // be a bug in Win2000 in that it only sends question mark
|
|
|
- // characters through here.)
|
|
|
- if (!_ime_open && !_input_devices.empty()) {
|
|
|
- _input_devices[0].keystroke(wparam);
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_SYSKEYDOWN: {
|
|
|
- // Alt and F10 are sent as WM_SYSKEYDOWN instead of WM_KEYDOWN
|
|
|
- // want to use defwindproc on Alt syskey so std windows cmd Alt-F4 works, etc
|
|
|
- POINT point;
|
|
|
- GetCursorPos(&point);
|
|
|
- ScreenToClient(hwnd, &point);
|
|
|
- handle_keypress(lookup_key(wparam), point.x, point.y);
|
|
|
- if (wparam == VK_F10) {
|
|
|
- //bypass default windproc F10 behavior (it activates the main menu, but we have none)
|
|
|
- return 0;
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_SYSCOMMAND:
|
|
|
- if(wparam==SC_KEYMENU) {
|
|
|
- // if Alt is released (alone w/o other keys), defwindproc will send
|
|
|
- // this command, which will 'activate' the title bar menu (we have none)
|
|
|
- // and give focus to it. we dont want this to happen, so kill this msg
|
|
|
- return 0;
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_KEYDOWN: {
|
|
|
- POINT point;
|
|
|
-
|
|
|
- GetCursorPos(&point);
|
|
|
- ScreenToClient(hwnd, &point);
|
|
|
- handle_keypress(lookup_key(wparam), point.x, point.y);
|
|
|
-
|
|
|
- // Handle Cntrl-V paste from clipboard. Is there a better way
|
|
|
- // to detect this hotkey?
|
|
|
- if ((wparam=='V') && (GetKeyState(VK_CONTROL) < 0) &&
|
|
|
- !_input_devices.empty()) {
|
|
|
- HGLOBAL hglb;
|
|
|
- char *lptstr;
|
|
|
-
|
|
|
- if (!IsClipboardFormatAvailable(CF_TEXT))
|
|
|
- return 0;
|
|
|
-
|
|
|
- if (!OpenClipboard(NULL))
|
|
|
- return 0;
|
|
|
-
|
|
|
- // Maybe we should support CF_UNICODETEXT if it is available
|
|
|
- // too?
|
|
|
- hglb = GetClipboardData(CF_TEXT);
|
|
|
- if (hglb!=NULL) {
|
|
|
- lptstr = (char *) GlobalLock(hglb);
|
|
|
- if (lptstr != NULL) {
|
|
|
- char *pChar;
|
|
|
- for(pChar=lptstr;*pChar!=NULL;pChar++) {
|
|
|
- _input_devices[0].keystroke((uchar)*pChar);
|
|
|
- }
|
|
|
- GlobalUnlock(hglb);
|
|
|
- }
|
|
|
- }
|
|
|
- CloseClipboard();
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case WM_SYSKEYUP:
|
|
|
- case WM_KEYUP:
|
|
|
- handle_keyrelease(lookup_key(wparam));
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_LBUTTONDOWN:
|
|
|
- button = 0;
|
|
|
- case WM_MBUTTONDOWN:
|
|
|
- if(button < 0)
|
|
|
- button = 1;
|
|
|
- case WM_RBUTTONDOWN:
|
|
|
- if(!DX_IS_READY)
|
|
|
- break;
|
|
|
-
|
|
|
- if(button < 0)
|
|
|
- button = 2;
|
|
|
- SetCapture(hwnd);
|
|
|
- SET_MOUSE_COORD(x,LOWORD(lparam));
|
|
|
- SET_MOUSE_COORD(y,HIWORD(lparam));
|
|
|
- handle_keypress(MouseButton::button(button), x, y);
|
|
|
- return 0;
|
|
|
-
|
|
|
- case WM_LBUTTONUP:
|
|
|
- button = 0;
|
|
|
- case WM_MBUTTONUP:
|
|
|
- if(button < 0)
|
|
|
- button = 1;
|
|
|
- case WM_RBUTTONUP:
|
|
|
- if(!DX_IS_READY)
|
|
|
- break;
|
|
|
-
|
|
|
- if(button < 0)
|
|
|
- button = 2;
|
|
|
- ReleaseCapture();
|
|
|
- #if 0
|
|
|
- SET_MOUSE_COORD(x,LOWORD(lparam));
|
|
|
- SET_MOUSE_COORD(y,HIWORD(lparam));
|
|
|
- #endif
|
|
|
- handle_keyrelease(MouseButton::button(button));
|
|
|
- return 0;
|
|
|
-
|
|
|
- case WM_SETCURSOR:
|
|
|
- // Turn off any GDI window cursor
|
|
|
- // dx8 cursor not working yet
|
|
|
-
|
|
|
- if(_use_dx8_cursor && _props._fullscreen) {
|
|
|
- // SetCursor( NULL );
|
|
|
- // _dxgsg->scrn.pD3DDevice->ShowCursor(true);
|
|
|
-
|
|
|
- set_cursor_visibility(true);
|
|
|
- return TRUE; // prevent Windows from setting cursor to window class cursor (see docs on WM_SETCURSOR)
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_MOVE:
|
|
|
- if(!DX_IS_READY)
|
|
|
- break;
|
|
|
- handle_window_move(LOWORD(lparam), HIWORD(lparam) );
|
|
|
- return 0;
|
|
|
-
|
|
|
-#if 0
|
|
|
- doesnt work yet
|
|
|
-
|
|
|
- case WM_GETMINMAXINFO: {
|
|
|
-
|
|
|
- // make sure window size doesnt go to zero
|
|
|
- LPMINMAXINFO pInfo=(LPMINMAXINFO) lparam;
|
|
|
- wdxdisplay_cat.spam() << "initial WM_GETMINMAXINFO: MinX:" << pInfo->ptMinTrackSize.x << " MinY:" << pInfo->ptMinTrackSize.y << endl;
|
|
|
-
|
|
|
- RECT client_rect;
|
|
|
- GetClientRect( hwnd, &client_rect );
|
|
|
-
|
|
|
- wdxdisplay_cat.spam() << "WM_GETMINMAXINFO: ClientRect: left: " << client_rect.left << " right: " << client_rect.right
|
|
|
- << " top: " << client_rect.top << " bottom: " << client_rect.bottom << endl;
|
|
|
-
|
|
|
-
|
|
|
- UINT client_ysize=RECT_YSIZE(client_rect);
|
|
|
- UINT client_xsize=RECT_XSIZE(client_rect);
|
|
|
-
|
|
|
- if(client_ysize==0) {
|
|
|
- RECT wnd_rect;
|
|
|
- GetWindowRect( hwnd, &wnd_rect );
|
|
|
- wdxdisplay_cat.spam() << "WM_GETMINMAXINFO: WndRect: left: " << wnd_rect.left << " right: " << wnd_rect.right
|
|
|
- << " top: " << wnd_rect.top << " bottom: " << wnd_rect.bottom << endl;
|
|
|
-
|
|
|
- pInfo->ptMinTrackSize.y=RECT_YSIZE(wnd_rect)-client_ysize+2;
|
|
|
- }
|
|
|
-
|
|
|
- if(client_xsize==0) {
|
|
|
- RECT wnd_rect;
|
|
|
- GetWindowRect( hwnd, &wnd_rect );
|
|
|
- pInfo->ptMinTrackSize.x=RECT_XSIZE(wnd_rect)-client_xsize+2;
|
|
|
- }
|
|
|
-
|
|
|
- if((client_ysize==0) || (client_xsize==0)) {
|
|
|
- wdxdisplay_cat.spam() << "final WM_GETMINMAXINFO: MinX:" << pInfo->ptMinTrackSize.x << " MinY:" << pInfo->ptMinTrackSize.y << endl;
|
|
|
- return 0;
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
-#endif
|
|
|
-
|
|
|
- case WM_EXITSIZEMOVE:
|
|
|
- #ifdef _DEBUG
|
|
|
- wdxdisplay_cat.spam() << "WM_EXITSIZEMOVE received" << endl;
|
|
|
- #endif
|
|
|
-
|
|
|
- if(_WindowAdjustingType==Resizing) {
|
|
|
- bool bSucceeded=handle_windowed_resize(hwnd,true);
|
|
|
-
|
|
|
- if(!bSucceeded) {
|
|
|
-#if 0
|
|
|
- bugbug need to fix this stuff
|
|
|
- SetWindowPos(hwnd,NULL,0,0,lastxsize,lastysize,
|
|
|
- SWP_NOMOVE |
|
|
|
-#endif
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- _WindowAdjustingType = NotAdjusting;
|
|
|
- _dxgsg->SetDXReady(true);
|
|
|
- return 0;
|
|
|
-
|
|
|
- case WM_ENTERSIZEMOVE: {
|
|
|
- if(_dxgsg!=NULL)
|
|
|
- _dxgsg->SetDXReady(false); // dont see pic during resize
|
|
|
- _WindowAdjustingType = MovingOrResizing;
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_SIZE: {
|
|
|
-
|
|
|
- #ifdef _DEBUG
|
|
|
- {
|
|
|
- width = LOWORD(lparam); height = HIWORD(lparam);
|
|
|
- wdxdisplay_cat.spam() << "WM_SIZE received with width:" << width << " height: " << height << " flags: " <<
|
|
|
- ((wparam == SIZE_MAXHIDE)? "SIZE_MAXHIDE " : "") << ((wparam == SIZE_MAXSHOW)? "SIZE_MAXSHOW " : "") <<
|
|
|
- ((wparam == SIZE_MINIMIZED)? "SIZE_MINIMIZED " : "") << ((wparam == SIZE_RESTORED)? "SIZE_RESTORED " : "") <<
|
|
|
- ((wparam == SIZE_MAXIMIZED)? "SIZE_MAXIMIZED " : "") << endl;
|
|
|
- }
|
|
|
- #endif
|
|
|
- // old comment -- added SIZE_RESTORED to handle 3dfx case
|
|
|
- if(_props._fullscreen || ((_dxgsg==NULL) || (_dxgsg->scrn.hWnd==NULL)) || ((wparam != SIZE_RESTORED) && (wparam != SIZE_MAXIMIZED)))
|
|
|
- break;
|
|
|
-
|
|
|
- width = LOWORD(lparam); height = HIWORD(lparam);
|
|
|
-
|
|
|
- if((_props._xsize != width) || (_props._ysize != height)) {
|
|
|
- _WindowAdjustingType = Resizing;
|
|
|
-
|
|
|
- // for maximized,unmaximize, need to call resize code artificially
|
|
|
- // since no WM_EXITSIZEMOVE is generated.
|
|
|
- if(wparam==SIZE_MAXIMIZED) {
|
|
|
- _bSizeIsMaximized=TRUE;
|
|
|
- window_proc(hwnd, WM_EXITSIZEMOVE, 0x0,0x0);
|
|
|
- } else if((wparam==SIZE_RESTORED) && _bSizeIsMaximized) {
|
|
|
- _bSizeIsMaximized=FALSE; // only want to reinit dx if restoring from maximized state
|
|
|
- window_proc(hwnd, WM_EXITSIZEMOVE, 0x0,0x0);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case WM_DISPLAYCHANGE: {
|
|
|
- #ifdef _DEBUG
|
|
|
- width = LOWORD(lparam); height = HIWORD(lparam);
|
|
|
- DWORD newbitdepth=wparam;
|
|
|
- wdxdisplay_cat.spam() <<"WM_DISPLAYCHANGE received with width:" << width << " height: " << height << " bpp: " << wparam<< endl;
|
|
|
- #endif
|
|
|
-
|
|
|
- // unfortunately this doesnt seem to work because RestoreAllSurfaces doesn't
|
|
|
- // seem to think we're back in the original displaymode even after I've received
|
|
|
- // the WM_DISPLAYCHANGE msg, and returns WRONGMODE error. So the only way I can
|
|
|
- // think of to make this work is to have the timer periodically check for restored
|
|
|
- // coop level
|
|
|
-
|
|
|
- // if(_props._fullscreen && !_window_active) {
|
|
|
- // if(_dxgsg!=NULL)
|
|
|
- // _dxgsg->CheckCooperativeLevel(DO_REACTIVATE_WINDOW);
|
|
|
- // else reactivate_window();
|
|
|
- // }
|
|
|
-
|
|
|
- // does the windowed case handle displaychange properly? no. need to recreate all devices
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_SETFOCUS: {
|
|
|
- // wdxdisplay_cat.info() << "got WM_SETFOCUS\n";
|
|
|
- if(!DX_IS_READY) {
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- POINT point;
|
|
|
- GetCursorPos(&point);
|
|
|
- ScreenToClient(hwnd, &point);
|
|
|
-
|
|
|
- // this is a hack to make sure common modifier keys have proper state
|
|
|
- // since at focus loss, app may never receive key-up event corresponding to
|
|
|
- // a key-down. it would be better to know the exact set of ModifierButtons the
|
|
|
- // user is using, since we may miss some here
|
|
|
-
|
|
|
- for(int i=0;i<NUM_MODIFIER_KEYS;i++) {
|
|
|
- if(GetKeyState(hardcoded_modifier_buttons[i]) < 0)
|
|
|
- handle_keypress(lookup_key(hardcoded_modifier_buttons[i]),point.x,point.y);
|
|
|
- }
|
|
|
- return 0;
|
|
|
- }
|
|
|
-
|
|
|
- case WM_KILLFOCUS: {
|
|
|
- // wdxdisplay_cat.info() << "got WM_KILLFOCUS\n";
|
|
|
- if(!DX_IS_READY) {
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- int i;
|
|
|
- for(i=0;i<NUM_MODIFIER_KEYS;i++) {
|
|
|
- if(GetKeyState(hardcoded_modifier_buttons[i]) < 0)
|
|
|
- handle_keyrelease(lookup_key(hardcoded_modifier_buttons[i]));
|
|
|
- }
|
|
|
-
|
|
|
- return 0;
|
|
|
- }
|
|
|
-
|
|
|
-#if 0
|
|
|
- case WM_WINDOWPOSCHANGING: {
|
|
|
- LPWINDOWPOS pWindPos = (LPWINDOWPOS) lparam;
|
|
|
- wdxdisplay_cat.spam() << "WM_WINDOWPOSCHANGING received, flags 0x" << pWindPos->flags << endl;
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case WM_GETMINMAXINFO:
|
|
|
- wdxdisplay_cat.spam() << "WM_GETMINMAXINFO received\n" << endl;
|
|
|
- break;
|
|
|
-#endif
|
|
|
-
|
|
|
- case WM_ERASEBKGND:
|
|
|
- // WM_ERASEBKGND will be ignored during resizing, because
|
|
|
- // we dont want to redraw as user is manually resizing window
|
|
|
- if(_WindowAdjustingType)
|
|
|
- break;
|
|
|
- return 0; // dont let GDI waste time redrawing the deflt background
|
|
|
-
|
|
|
- case WM_TIMER:
|
|
|
- // 2 cases of app deactivation:
|
|
|
- //
|
|
|
- // 1) user has switched out of fullscreen mode
|
|
|
- // this is first signalled when ACTIVATEAPP returns false
|
|
|
- // for this case, we dont wake up until WM_SIZE returns restore or maximize
|
|
|
- // and WM_TIMER just periodically reawakens app for idle processing
|
|
|
-
|
|
|
- // unfortunately this doesnt seem to work because RestoreAllSurfaces doesn't
|
|
|
- // seem to think we're back in the original displaymode even after I've received
|
|
|
- // the WM_DISPLAYCHANGE msg, and returns WRONGMODE error. So the only way I can
|
|
|
- // think of to make this work is to have the timer periodically check for restored
|
|
|
- // coop level, as it does in case 2)
|
|
|
-
|
|
|
- //
|
|
|
- // 2) windowed app has lost access to dx because another app has taken dx exclusive mode
|
|
|
- // here we rely on WM_TIMER to periodically check if it is ok to reawaken app.
|
|
|
- // windowed apps currently run regardless of if its window is in the foreground
|
|
|
- // so we cannot rely on window messages to reawaken app
|
|
|
-
|
|
|
- if((wparam==_PandaPausedTimer) && ((!_window_active)||_active_minimized_fullscreen)) {
|
|
|
- assert(_dxgsg!=NULL);
|
|
|
- _dxgsg->CheckCooperativeLevel(DO_REACTIVATE_WINDOW);
|
|
|
-
|
|
|
- // wdxdisplay_cat.spam() << "periodic return of control to app\n";
|
|
|
- _return_control_to_app = true;
|
|
|
- // throw_event("PandaPaused");
|
|
|
- // do we still need to do this since I return control to app periodically using timer msgs?
|
|
|
- // does app need to know to avoid major computation?
|
|
|
- }
|
|
|
-
|
|
|
- #ifdef DINPUT_DEBUG_POLL
|
|
|
- // probably want to get rid of this in favor of event-based input
|
|
|
- if(dx_use_joystick && (wparam==_pParentWindowGroup->_pDInputInfo->_JoystickPollTimer)) {
|
|
|
- DIJOYSTATE2 js;
|
|
|
- ZeroMemory(&js,sizeof(js));
|
|
|
- if(_pParentWindowGroup->_pDInputInfo->ReadJoystick(0,js)) {
|
|
|
- // for now just print stuff out to make sure it works
|
|
|
- wdxdisplay_cat.debug() << "joyPos (X: " << js.lX << ",Y: " << js.lY << ",Z: " << js.lZ << ")\n";
|
|
|
- for(int i=0;i<128;i++) {
|
|
|
- if(js.rgbButtons[i]!=0)
|
|
|
- wdxdisplay_cat.debug() << "joyButton "<< i << " pressed\n";
|
|
|
- }
|
|
|
- } else {
|
|
|
- wdxdisplay_cat.error() << "read of Joystick failed!\n";
|
|
|
- exit(1);
|
|
|
- }
|
|
|
- }
|
|
|
- #endif
|
|
|
- return 0;
|
|
|
-
|
|
|
- case WM_CLOSE:
|
|
|
- #ifdef _DEBUG
|
|
|
- wdxdisplay_cat.spam() << "WM_CLOSE received\n";
|
|
|
- #endif
|
|
|
- // close_window();
|
|
|
- delete _pParentWindowGroup;
|
|
|
-
|
|
|
- // BUGBUG: right now there is no way to tell the panda app the graphics window is invalid or
|
|
|
- // has been closed by the user, to prevent further methods from being called on the window.
|
|
|
- // this needs to be added to panda for multiple windows to work. in the meantime, just
|
|
|
- // trigger an exit here if # windows==0, since that is the expected behavior when all
|
|
|
- // windows are closed (should be done by the app though, and it assumes you only make this
|
|
|
- // type of panda gfx window)
|
|
|
-
|
|
|
- if(hwnd_pandawin_map.size()==0) {
|
|
|
- exit(0);
|
|
|
- }
|
|
|
- return 0;
|
|
|
-
|
|
|
- case WM_ACTIVATEAPP: {
|
|
|
- #ifdef _DEBUG
|
|
|
- wdxdisplay_cat.spam() << "WM_ACTIVATEAPP(" << (bool)(wparam!=0) <<") received\n";
|
|
|
- #endif
|
|
|
-
|
|
|
- if((!wparam) && _props._fullscreen) {
|
|
|
- deactivate_window();
|
|
|
- return 0;
|
|
|
- } // dont want to reactivate until window is actually un-minimized (see WM_SIZE)
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return DefWindowProc(hwnd, msg, wparam, lparam);
|
|
|
-}
|
|
|
-
|
|
|
-// should be used by both fullscrn and windowed resize
|
|
|
-bool wdxGraphicsWindow::reset_device_resize_window(UINT new_xsize, UINT new_ysize) {
|
|
|
- DXScreenData *pScrn=&_dxgsg->scrn;
|
|
|
- assert((new_xsize>0)&&(new_ysize>0));
|
|
|
- bool bRetval=true;
|
|
|
-
|
|
|
- D3DPRESENT_PARAMETERS d3dpp;
|
|
|
- memcpy(&d3dpp,&pScrn->PresParams,sizeof(D3DPRESENT_PARAMETERS));
|
|
|
- d3dpp.BackBufferWidth = new_xsize;
|
|
|
- d3dpp.BackBufferHeight = new_ysize;
|
|
|
- HRESULT hr=_dxgsg->reset_d3d_device(&d3dpp);
|
|
|
-
|
|
|
- if(FAILED(hr)) {
|
|
|
- bRetval=false;
|
|
|
- wdxdisplay_cat.error() << "reset_device_resize_window Reset() failed" << D3DERRORSTRING(hr);
|
|
|
- if(hr==D3DERR_OUTOFVIDEOMEMORY) {
|
|
|
- hr=_dxgsg->reset_d3d_device(&pScrn->PresParams);
|
|
|
- if(FAILED(hr)) {
|
|
|
- wdxdisplay_cat.error() << "reset_device_resize_window Reset() failed OutOfVidmem, then failed again doing Reset w/original params:" << D3DERRORSTRING(hr);
|
|
|
- exit(1);
|
|
|
- } else {
|
|
|
- if(wdxdisplay_cat.is_info())
|
|
|
- wdxdisplay_cat.info() << "reset of original size (" <<pScrn->PresParams.BackBufferWidth << ","
|
|
|
- << pScrn->PresParams.BackBufferHeight << ") succeeded\n";
|
|
|
- }
|
|
|
- } else {
|
|
|
- exit(1);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- init_resized_window();
|
|
|
- return bRetval;
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: handle_reshape
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-bool wdxGraphicsWindow::handle_windowed_resize(HWND hWnd,bool bDoDxReset) {
|
|
|
- // handles windowed, non-fullscreen resizing
|
|
|
- GdiFlush();
|
|
|
-
|
|
|
- assert(!_props._fullscreen);
|
|
|
-
|
|
|
- if(bDoDxReset && (_dxgsg!=NULL)) {
|
|
|
- if(_dxgsg->scrn.pD3DDevice==NULL) {
|
|
|
- //assume this is initial creation reshape, so ignore this call
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if(_dxgsg!=NULL)
|
|
|
- _dxgsg->SetDXReady(false);
|
|
|
-
|
|
|
- RECT view_rect;
|
|
|
-
|
|
|
- GetClientRect( hWnd, &view_rect );
|
|
|
- ClientToScreen( hWnd, (POINT*)&view_rect.left ); // translates top,left pnt
|
|
|
- ClientToScreen( hWnd, (POINT*)&view_rect.right ); // translates right,bottom pnt
|
|
|
-
|
|
|
- _props._xorg = view_rect.left; // _props origin should reflect upper left of view rectangle
|
|
|
- _props._yorg = view_rect.top;
|
|
|
-
|
|
|
- DWORD xsize= RECT_XSIZE(view_rect);
|
|
|
- DWORD ysize= RECT_YSIZE(view_rect);
|
|
|
-
|
|
|
- if((xsize==0)||(ysize==0)) {
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- bool bResizeSucceeded=true;
|
|
|
-
|
|
|
-/*
|
|
|
- fail if resize fails, dont adjust size
|
|
|
- do {
|
|
|
- // change _props xsize,ysize (need to do this here in case _dxgsg==NULL)
|
|
|
- resized(xsize,ysize);
|
|
|
-
|
|
|
- if((_dxgsg!=NULL)&& bDoDxReset) {
|
|
|
- bResizeSucceeded=reset_device_resize_window(xsize,ysize); // create the new resized rendertargets
|
|
|
- if(!bResizeSucceeded) {
|
|
|
- // size was too large. try a smaller size
|
|
|
- if(wdxdisplay_cat.is_debug()) {
|
|
|
- wdxdisplay_cat.debug() << "windowed_resize to size: (" << xsize << "," << ysize << ") failed due to out-of-memory, retrying w/reduced size\n";
|
|
|
- }
|
|
|
-
|
|
|
- xsize *= 0.8f;
|
|
|
- ysize *= 0.8f;
|
|
|
-
|
|
|
- view_rect.right=view_rect.left+xsize;
|
|
|
- view_rect.bottom=view_rect.top+ysize;
|
|
|
- }
|
|
|
- }
|
|
|
- } while(!bResizeSucceeded);
|
|
|
-*/
|
|
|
-
|
|
|
- // change _props xsize,ysize (need to do this here in case _dxgsg==NULL)
|
|
|
- // reset_device_resize will call it again, this is OK
|
|
|
- resized(xsize,ysize);
|
|
|
-
|
|
|
- if((_dxgsg!=NULL)&& bDoDxReset) {
|
|
|
- bResizeSucceeded=reset_device_resize_window(xsize,ysize); // create the new resized rendertargets
|
|
|
- if(!bResizeSucceeded) {
|
|
|
- if(wdxdisplay_cat.is_debug())
|
|
|
- wdxdisplay_cat.debug() << "windowed_resize to size: (" << xsize << "," << ysize << ") failed due to out-of-memory\n";
|
|
|
- } else {
|
|
|
- if(wdxdisplay_cat.is_debug())
|
|
|
- wdxdisplay_cat.debug() << "windowed_resize to origin: (" << _props._xorg << "," << _props._yorg << "), size: (" << _props._xsize << "," << _props._ysize << ")\n";
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if(_dxgsg!=NULL)
|
|
|
- _dxgsg->SetDXReady(true);
|
|
|
-
|
|
|
- return bResizeSucceeded;
|
|
|
-}
|
|
|
-
|
|
|
-void wdxGraphicsWindow::deactivate_window(void) {
|
|
|
- // current policy is to suspend minimized or deactivated fullscreen windows, but leave
|
|
|
- // regular windows running normally
|
|
|
-
|
|
|
- if((!_window_active) || _exiting_window || _active_minimized_fullscreen) {
|
|
|
- #ifdef _DEBUG
|
|
|
- if(wdxdisplay_cat.is_spam())
|
|
|
- wdxdisplay_cat.spam() << "deactivate_window called, but ignored in current mode\n";
|
|
|
- #endif
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if(bResponsive_minimized_fullscreen_window) {
|
|
|
- if(wdxdisplay_cat.is_spam())
|
|
|
- wdxdisplay_cat.spam() << "WDX fullscreen window switching to active minimized mode...\n";
|
|
|
- _active_minimized_fullscreen = true;
|
|
|
- } else {
|
|
|
-
|
|
|
- if(wdxdisplay_cat.is_spam())
|
|
|
- wdxdisplay_cat.spam() << "WDX window deactivated, waiting...\n";
|
|
|
-
|
|
|
- _window_active = false;
|
|
|
- }
|
|
|
-
|
|
|
- if(_props._fullscreen) {
|
|
|
- // make sure window is minimized
|
|
|
-
|
|
|
- WINDOWPLACEMENT wndpl;
|
|
|
- wndpl.length=sizeof(WINDOWPLACEMENT);
|
|
|
- if(!GetWindowPlacement(_dxgsg->scrn.hWnd,&wndpl)) {
|
|
|
- wdxdisplay_cat.error() << "GetWindowPlacement failed!\n";
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if((wndpl.showCmd!=SW_MINIMIZE)&&(wndpl.showCmd!=SW_SHOWMINIMIZED)) {
|
|
|
- ShowWindow(_dxgsg->scrn.hWnd, SW_MINIMIZE);
|
|
|
- }
|
|
|
-
|
|
|
- throw_event("PandaPaused"); // right now this is used to signal python event handler to disable audio
|
|
|
- }
|
|
|
-
|
|
|
-// if(!bResponsive_minimized_fullscreen_window) {
|
|
|
- // need this even in responsive-mode to trigger the dxgsg check of cooplvl, i think?
|
|
|
-
|
|
|
- _PandaPausedTimer = SetTimer(_dxgsg->scrn.hWnd,PAUSED_TIMER_ID,500,NULL);
|
|
|
- if(_PandaPausedTimer!=PAUSED_TIMER_ID) {
|
|
|
- wdxdisplay_cat.error() << "Error in SetTimer!\n";
|
|
|
- }
|
|
|
-// }
|
|
|
-
|
|
|
-
|
|
|
- // bugbug: need to handle dinput devices
|
|
|
-}
|
|
|
-
|
|
|
-// currently this should only be called from CheckCoopLvl to return from Alt-tab
|
|
|
-void wdxGraphicsWindow::reactivate_window(void) {
|
|
|
- if((!_window_active)||(_active_minimized_fullscreen)) {
|
|
|
-
|
|
|
- // first see if dx cooperative level is OK for reactivation
|
|
|
- // if(!_dxgsg->CheckCooperativeLevel())
|
|
|
- // return;
|
|
|
-
|
|
|
- if(_PandaPausedTimer!=NULL) {
|
|
|
- KillTimer(_dxgsg->scrn.hWnd,_PandaPausedTimer);
|
|
|
- _PandaPausedTimer = NULL;
|
|
|
- }
|
|
|
-
|
|
|
- if(!_window_active) {
|
|
|
- _window_active = true;
|
|
|
- if(wdxdisplay_cat.is_spam())
|
|
|
- wdxdisplay_cat.spam() << "WDX window re-activated...\n";
|
|
|
- } else {
|
|
|
- _active_minimized_fullscreen = false;
|
|
|
- if(wdxdisplay_cat.is_spam())
|
|
|
- wdxdisplay_cat.spam() << "WDX window unminimized from active-minimized state...\n";
|
|
|
- }
|
|
|
-
|
|
|
- // need to call dx_init and ResourceManagerDiscardBytes since D3D Reset() was called
|
|
|
- init_resized_window();
|
|
|
-
|
|
|
- // move window to top of zorder
|
|
|
- // if(_props._fullscreen)
|
|
|
- // SetWindowPos(_DisplayDataArray[0].hWnd, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSENDCHANGING | SWP_NOSIZE | SWP_NOOWNERZORDER);
|
|
|
- GdiFlush();
|
|
|
- }
|
|
|
-
|
|
|
- if(_props._fullscreen) {
|
|
|
- throw_event("PandaRestarted"); // right now this is used to signal python event handler to re-enable audio
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: Constructor
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-wdxGraphicsWindow::wdxGraphicsWindow(GraphicsPipe* pipe) : GraphicsWindow(pipe) {
|
|
|
- _ime_active = false;
|
|
|
- _pParentWindowGroup=NULL;
|
|
|
- _pParentWindowGroup=new wdxGraphicsWindowGroup(this);
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: Constructor
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-wdxGraphicsWindow::wdxGraphicsWindow(GraphicsPipe* pipe, const GraphicsWindow::Properties& props)
|
|
|
- : GraphicsWindow(pipe, props) {
|
|
|
- _ime_open = false;
|
|
|
- _pParentWindowGroup=NULL;
|
|
|
- _pParentWindowGroup=new wdxGraphicsWindowGroup(this);
|
|
|
-}
|
|
|
-
|
|
|
-bool supports_color_cursors(D3DADAPTER_IDENTIFIER8 &DevID) {
|
|
|
- // TODO: add more cards as more testing is done
|
|
|
- if(IS_NVIDIA(DevID)) {
|
|
|
- // all nvidia seem to support 256 color
|
|
|
- return true;
|
|
|
- } else if(IS_ATI(DevID)) {
|
|
|
- // radeons seem to be in the 5100 range and support color, assume anything in 6000 or above
|
|
|
- // is newer than radeon and supports 256 color
|
|
|
- if(((DevID.DeviceId>=0x5100) && (DevID.DeviceId<=0x5200)) ||
|
|
|
- (DevID.DeviceId>=0x6000))
|
|
|
- return true;
|
|
|
- } else if IS_MATROX(DevID) {
|
|
|
- if(DevID.DeviceId==0x0525) // G400 seems to support color cursors, havent tested other matrox
|
|
|
- return true;
|
|
|
- }
|
|
|
-
|
|
|
- return false;
|
|
|
-}
|
|
|
-
|
|
|
-HCURSOR CreateNullCursor(HINSTANCE hInst) {
|
|
|
- #define CURSORBYTESIZE (32*4)
|
|
|
-
|
|
|
- // 1-bit 32x32
|
|
|
- BYTE ANDPlane[CURSORBYTESIZE],XORPlane[CURSORBYTESIZE];
|
|
|
-
|
|
|
- ZeroMemory(XORPlane,CURSORBYTESIZE);
|
|
|
- memset(ANDPlane,0xFF,CURSORBYTESIZE);
|
|
|
-
|
|
|
- return CreateCursor(hInst,0,0,32,32,ANDPlane,XORPlane);
|
|
|
-}
|
|
|
-
|
|
|
-void wdxGraphicsWindowGroup::CreateWindows(void) {
|
|
|
- HINSTANCE hProgramInstance = GetModuleHandle(NULL);
|
|
|
- WNDCLASS wc;
|
|
|
- static bool wc_registered = false;
|
|
|
- _hParentWindow = NULL;
|
|
|
- _bLoadedCustomCursor=false;
|
|
|
-
|
|
|
- // Clear before filling in window structure!
|
|
|
- ZeroMemory(&wc, sizeof(WNDCLASS));
|
|
|
- wc.style = CS_HREDRAW | CS_VREDRAW; //CS_OWNDC;
|
|
|
- wc.lpfnWndProc = (WNDPROC) static_window_proc;
|
|
|
- wc.hInstance = hProgramInstance;
|
|
|
-
|
|
|
- // all this must be moved to dx_init, since we need to create DX surface
|
|
|
- string windows_icon_filename = get_icon_filename().to_os_specific();
|
|
|
-
|
|
|
-
|
|
|
- if(!windows_icon_filename.empty()) {
|
|
|
- // Note: LoadImage seems to cause win2k internal heap corruption (outputdbgstr warnings)
|
|
|
- // if icon is more than 8bpp
|
|
|
-
|
|
|
- // loads a .ico fmt file
|
|
|
- wc.hIcon = (HICON) LoadImage(NULL, windows_icon_filename.c_str(), IMAGE_ICON, 0, 0, LR_LOADFROMFILE );
|
|
|
-
|
|
|
- if(wc.hIcon==NULL) {
|
|
|
- wdxdisplay_cat.warning() << "windows icon filename '" << windows_icon_filename << "' not found!!\n";
|
|
|
- }
|
|
|
- } else {
|
|
|
- wc.hIcon = NULL; // use default app icon
|
|
|
- }
|
|
|
-
|
|
|
-#if 0
|
|
|
- // Note: dx_init() uses the cursor handle to create the dx cursor surface
|
|
|
- string windows_color_cursor_filename = get_color_cursor_filename().to_os_specific();
|
|
|
-
|
|
|
- if(!windows_color_cursor_filename.empty()) {
|
|
|
- // card support for full color non-black/white GDI cursors varies greatly. if the cursor is not supported,
|
|
|
- // it is rendered in software by GDI, which causes a flickering effect (because it's not synced
|
|
|
- // with flip?). GDI transparently masks the lack of HW support so there is no easy way for app to detect
|
|
|
- // if HW cursor support exists. alternatives are to tie cursor motion to frame rate using DDraw blts
|
|
|
- // or overlays (this is done automatically by DX8 runtime mouse cursor support), or to have separate thread draw cursor
|
|
|
- // (sync issues?). instead we do mono cursor unless card is known to support 256 color cursors
|
|
|
- bool bSupportsColorCursor=true;
|
|
|
-
|
|
|
- #if 0
|
|
|
- // remove this check for now, since dx8 should emulate color cursors
|
|
|
- /* if any card doesnt support color, dont load it*/
|
|
|
- for(int w=0;w<_windows.size();w++)
|
|
|
- bSupportsColorCursor &= supports_color_cursors(_windows[w]->_dxgsg->scrn.DXDeviceID);
|
|
|
- #endif
|
|
|
-
|
|
|
- if(bSupportsColorCursor) {
|
|
|
- DWORD load_flags = LR_LOADFROMFILE;
|
|
|
-
|
|
|
- if(dx_full_screen) {
|
|
|
- // I think cursors should use LR_CREATEDIBSECTION since they should not be mapped to the device palette (in the case of 256-color cursors)
|
|
|
- // since they are not going to be used on the desktop
|
|
|
- load_flags |= LR_CREATEDIBSECTION;
|
|
|
- }
|
|
|
-
|
|
|
- // Note: LoadImage seems to cause win2k internal heap corruption (outputdbgstr warnings)
|
|
|
- // if icon is more than 8bpp
|
|
|
-
|
|
|
- // loads a .cur fmt file.
|
|
|
- _hMouseCursor = (HCURSOR) LoadImage(NULL, windows_color_cursor_filename.c_str(), IMAGE_CURSOR, 0, 0, load_flags );
|
|
|
-
|
|
|
- if(_hMouseCursor==NULL) {
|
|
|
- wdxdisplay_cat.warning() << "windows color cursor filename '" << windows_color_cursor_filename << "' not found!!\n";
|
|
|
- goto try_mono_cursor;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- _bLoadedCustomCursor=true;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- try_mono_cursor:
|
|
|
-#endif
|
|
|
-
|
|
|
- if(!_bLoadedCustomCursor) {
|
|
|
- string windows_mono_cursor_filename = get_mono_cursor_filename().to_os_specific();
|
|
|
-
|
|
|
- if(!windows_mono_cursor_filename.empty()) {
|
|
|
- // Note: LoadImage seems to cause win2k internal heap corruption (outputdbgstr warnings)
|
|
|
- // if icon is more than 8bpp
|
|
|
-
|
|
|
- DWORD load_flags = LR_LOADFROMFILE;
|
|
|
-
|
|
|
- if(dx_full_screen) {
|
|
|
- // I think cursors should use LR_CREATEDIBSECTION since they should not be mapped to the device palette (in the case of 256-color cursors)
|
|
|
- // since they are not going to be used on the desktop
|
|
|
- load_flags |= LR_CREATEDIBSECTION;
|
|
|
- }
|
|
|
- // loads a .cur fmt file.
|
|
|
- _hMouseCursor = (HCURSOR) LoadImage(NULL, windows_mono_cursor_filename.c_str(), IMAGE_CURSOR, 0, 0, load_flags);
|
|
|
-
|
|
|
- if(_hMouseCursor==NULL) {
|
|
|
- wdxdisplay_cat.warning() << "windows mono cursor filename '" << windows_mono_cursor_filename << "' not found!!\n";
|
|
|
- } else _bLoadedCustomCursor=true;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if(!_bLoadedCustomCursor)
|
|
|
- _hMouseCursor = LoadCursor(NULL, DEFAULT_CURSOR);
|
|
|
-
|
|
|
- // need both a mouse and no-mouse class in case we have mixed fullscrn/windowed
|
|
|
- // windowed must use GDI mouse, fullscrn usually wont
|
|
|
- if (!wc_registered) {
|
|
|
- // We only need to register the window class once per session.
|
|
|
-
|
|
|
- wc.hCursor = _hMouseCursor; // for windowed mode use the GDI cursor.
|
|
|
- // bugbug: for fullscreen do we need to do a SetWindowLongNULL
|
|
|
- wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
|
|
|
- wc.lpszMenuName = NULL;
|
|
|
- wc.lpszClassName = WDX_WINDOWCLASSNAME;
|
|
|
-
|
|
|
- if(!RegisterClass(&wc)) {
|
|
|
- wdxdisplay_cat.error() << "could not register window class " << WDX_WINDOWCLASSNAME << endl;
|
|
|
- }
|
|
|
-
|
|
|
- if(dx_use_dx_cursor) {
|
|
|
- wc.hCursor = CreateNullCursor(hProgramInstance);
|
|
|
- if(wc.hCursor==NULL)
|
|
|
- wdxdisplay_cat.error() << "failed to create NULL cursor, error=" << GetLastError() << endl;
|
|
|
-
|
|
|
- wc.lpszClassName = WDX_WINDOWCLASSNAME_NOCURSOR;
|
|
|
-
|
|
|
- if(!RegisterClass(&wc)) {
|
|
|
- wdxdisplay_cat.error() << "could not register window class " << WDX_WINDOWCLASSNAME_NOCURSOR << endl;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- wc_registered = true;
|
|
|
- }
|
|
|
-
|
|
|
- DWORD base_window_style = WS_POPUP | WS_SYSMENU; // for CreateWindow
|
|
|
-
|
|
|
- global_wdxwinptr = _windows[0]; // for use during createwin() bugbug look at this again
|
|
|
-
|
|
|
- // rect now contains the coords for the entire window, not the client
|
|
|
- // extra windows must be parented to the first so app doesnt minimize when user selects them
|
|
|
- for(DWORD devnum=0;devnum<_windows.size();devnum++) {
|
|
|
- DWORD xleft,ytop,xsize,ysize;
|
|
|
- GraphicsWindow::Properties *props = &_windows[devnum]->_props;
|
|
|
- DWORD final_window_style;
|
|
|
-
|
|
|
- final_window_style=base_window_style;
|
|
|
- char *pWindowClassName;
|
|
|
-
|
|
|
- if(_windows[devnum]->_props._fullscreen) {
|
|
|
- MONITORINFO minfo;
|
|
|
- ZeroMemory(&minfo, sizeof(MONITORINFO));
|
|
|
- minfo.cbSize = sizeof(MONITORINFO);
|
|
|
- // since DX8 cant be installed on w95, ok to statically link to GetMonInfo
|
|
|
- // get upper-left corner coords using GetMonitorInfo
|
|
|
- GetMonitorInfo(_windows[devnum]->_dxgsg->scrn.hMon, &minfo);
|
|
|
- xleft=minfo.rcMonitor.left;
|
|
|
- ytop=minfo.rcMonitor.top;
|
|
|
- xsize=props->_xsize;
|
|
|
- ysize=props->_ysize;
|
|
|
-
|
|
|
- pWindowClassName= (dx_use_dx_cursor ? WDX_WINDOWCLASSNAME_NOCURSOR : WDX_WINDOWCLASSNAME);
|
|
|
- } else {
|
|
|
- // specify client area, use adjustwindowrect to figure out size of final window to
|
|
|
- // pass to CreateWin
|
|
|
-
|
|
|
- RECT win_rect;
|
|
|
- SetRect(&win_rect, props->_xorg, props->_yorg, props->_xorg + props->_xsize,
|
|
|
- props->_yorg + props->_ysize);
|
|
|
-
|
|
|
- if(props->_border)
|
|
|
- final_window_style |= WS_OVERLAPPEDWINDOW; // should we just use WS_THICKFRAME instead?
|
|
|
-
|
|
|
- AdjustWindowRect(&win_rect, final_window_style, false); //compute window size based on desired client area size
|
|
|
-
|
|
|
- // make sure origin is on screen
|
|
|
- if(win_rect.left < 0) {
|
|
|
- win_rect.right -= win_rect.left; win_rect.left = 0;
|
|
|
- }
|
|
|
- if(win_rect.top < 0) {
|
|
|
- win_rect.bottom -= win_rect.top; win_rect.top = 0;
|
|
|
- }
|
|
|
-
|
|
|
- xleft=win_rect.left;
|
|
|
- ytop= win_rect.top;
|
|
|
- xsize=RECT_XSIZE(win_rect);
|
|
|
- ysize=RECT_YSIZE(win_rect);
|
|
|
-
|
|
|
- pWindowClassName=WDX_WINDOWCLASSNAME;
|
|
|
- }
|
|
|
-
|
|
|
- wdxdisplay_cat.info() << "opening " << props->_xsize << "x" << props->_ysize
|
|
|
- << ((_windows[devnum]->_props._fullscreen) ? " fullscreen" : " regular") << " window\n";
|
|
|
-
|
|
|
- if((xsize==0) || (ysize==0)) {
|
|
|
- wdxdisplay_cat.fatal() << "can't create window with zero area for device " << devnum << "!\n";
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- // BUGBUG: this sets window posns based on desktop arrangement of monitors (that is what GetMonInfo is for).
|
|
|
- // need to move to chancfg stuff instead (i.e. use the properties x/yorg's) when that is ready
|
|
|
- HWND hWin = CreateWindow(pWindowClassName, props->_title.c_str(),
|
|
|
- final_window_style, xleft,ytop,xsize,ysize,
|
|
|
- _hParentWindow, NULL, hProgramInstance, 0);
|
|
|
-
|
|
|
- if(!hWin) {
|
|
|
- wdxdisplay_cat.fatal() << "CreateWindow failed for device " << devnum << "!, LastError=" << GetLastError() << endl;
|
|
|
- #ifdef _DEBUG
|
|
|
- PrintErrorMessage(LAST_ERROR);
|
|
|
- #endif
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- _windows[devnum]->set_window_handle(hWin);
|
|
|
- _windows[devnum]->_dxgsg->scrn.pProps = &_windows[devnum]->_props;
|
|
|
-
|
|
|
- if(devnum==0)
|
|
|
- _hParentWindow=hWin;
|
|
|
- }
|
|
|
-
|
|
|
-/*
|
|
|
- } else {
|
|
|
-// assert(_windows.size()==1);
|
|
|
-
|
|
|
- GraphicsWindow::Properties *props = &_windows[0]->_props;
|
|
|
-
|
|
|
- RECT win_rect;
|
|
|
- SetRect(&win_rect, props->_xorg, props->_yorg, props->_xorg + props->_xsize,
|
|
|
- props->_yorg + props->_ysize);
|
|
|
-
|
|
|
- if(props->_border)
|
|
|
- window_style |= WS_OVERLAPPEDWINDOW; // should we just use WS_THICKFRAME instead?
|
|
|
-
|
|
|
- AdjustWindowRect(&win_rect, window_style, FALSE); //compute window size based on desired client area size
|
|
|
-
|
|
|
- // make sure origin is on screen
|
|
|
- if(win_rect.left < 0) {
|
|
|
- win_rect.right -= win_rect.left; win_rect.left = 0;
|
|
|
- }
|
|
|
- if(win_rect.top < 0) {
|
|
|
- win_rect.bottom -= win_rect.top; win_rect.top = 0;
|
|
|
- }
|
|
|
-
|
|
|
- _hParentWindow =
|
|
|
- CreateWindow(WDX_WINDOWCLASSNAME, props->_title.c_str(),
|
|
|
- window_style,
|
|
|
- win_rect.left, win_rect.top, win_rect.right-win_rect.left,win_rect.bottom-win_rect.top,
|
|
|
- NULL, NULL, hProgramInstance, 0);
|
|
|
- _windows[0]->set_window_handle(_hParentWindow);
|
|
|
- }
|
|
|
-
|
|
|
- if(_hParentWindow==NULL) {
|
|
|
- wdxdisplay_cat.fatal() << "CreateWindow failed!\n";
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-*/
|
|
|
- for(DWORD devnum=0;devnum<_windows.size();devnum++) {
|
|
|
- wdxGraphicsWindow *pWDXWin = _windows[devnum];
|
|
|
- // for use by the window_proc
|
|
|
- hwnd_pandawin_map[pWDXWin->_dxgsg->scrn.hWnd] = pWDXWin;
|
|
|
-
|
|
|
-/*
|
|
|
- // DC is mostly used for writing fps meter (but also old palette code, which needs updating)
|
|
|
- // probably only need to do this for devnum 0
|
|
|
- HDC hdc = GetDC(pWDXWin->_dxgsg_>scrn.hWnd);
|
|
|
- pWDXWin->_dxgsg->Set_HDC(hdc);
|
|
|
-*/
|
|
|
- }
|
|
|
-
|
|
|
- // now we can stop using the global_wdxwinptr crutch since windows are created
|
|
|
- global_wdxwinptr = NULL; // get rid of any reference to this obj
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: config
|
|
|
-// Access:
|
|
|
-// Description: Set up win32 window.
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-void wdxGraphicsWindow::config_window(wdxGraphicsWindowGroup *pParentGroup) {
|
|
|
-// assert(_pParentWindowGroup==NULL);
|
|
|
- _pParentWindowGroup=pParentGroup;
|
|
|
-
|
|
|
- GraphicsWindow::config();
|
|
|
-
|
|
|
- _hdc = NULL;
|
|
|
- _gsg = _dxgsg = NULL;
|
|
|
- _exiting_window = false;
|
|
|
- _window_active = true;
|
|
|
- _return_control_to_app = false;
|
|
|
- _active_minimized_fullscreen = false;
|
|
|
-
|
|
|
- if(_props._fullscreen || dx_full_screen) {
|
|
|
- _props._fullscreen = dx_full_screen= true;
|
|
|
- }
|
|
|
-
|
|
|
- _use_dx8_cursor = dx_use_dx_cursor;
|
|
|
- if(!_props._fullscreen)
|
|
|
- _use_dx8_cursor = false;
|
|
|
-
|
|
|
- _WindowAdjustingType = NotAdjusting;
|
|
|
- _bSizeIsMaximized=FALSE;
|
|
|
-
|
|
|
- _gsg = _dxgsg = NULL;
|
|
|
- // Create a GSG to manage the graphics
|
|
|
- if(_gsg==NULL) {
|
|
|
- make_gsg();
|
|
|
- if(_gsg==NULL) {
|
|
|
- wdxdisplay_cat.error() << "make_gsg() failed!\n";
|
|
|
- exit(1);
|
|
|
- }
|
|
|
- }
|
|
|
- _dxgsg = DCAST(DXGraphicsStateGuardian, _gsg);
|
|
|
- _dxgsg->scrn.bIsDX81 = pParentGroup->_bIsDX81;
|
|
|
-
|
|
|
- // Check the version of the OS we are running. If we are running
|
|
|
- // win2000, we must use ImmGetCompositionStringW() to report the
|
|
|
- // characters returned by the IME, since WM_CHAR and
|
|
|
- // ImmGetCompositionStringA() both just return question marks.
|
|
|
- // However, this function doesn't work for Win98; on this OS, we
|
|
|
- // have to use ImmGetCompositionStringA() instead, which returns an
|
|
|
- // encoded string in shift-jis (which we then have to decode).
|
|
|
-
|
|
|
- // For now, this is user-configurable, to allow testing of this code
|
|
|
- // on both OS's. After we verify that truth of the above claim, we
|
|
|
- // should base this decision on GetVersionEx() or maybe
|
|
|
- // VerifyVersionInfo().
|
|
|
-
|
|
|
- _ime_composition_w = ime_composition_w;
|
|
|
-
|
|
|
- // need to re-evaluate above in light of this, it seems that
|
|
|
- // ImmGetCompositionStringW should work on both:
|
|
|
- // The Input Method Editor and Unicode Windows 98/Me, Windows
|
|
|
- // NT/2000/XP: Windows supports a Unicode interface for the
|
|
|
- // IME, in addition to the ANSI interface originally supported.
|
|
|
- // Windows 98/Me supports all the Unicode functions except
|
|
|
- // ImmIsUIMessage. Also, all the messages in Windows 98/Me are
|
|
|
- // ANSI based. Since Windows 98/Me does not support Unicode
|
|
|
- // messages, applications can use ImmGetCompositionString to
|
|
|
- // receive Unicode characters from a Unicode based IME on
|
|
|
- // Windows 98/Me. There are two issues involved with Unicode
|
|
|
- // handling and the IME. One is that the Unicode versions of
|
|
|
- // IME routines return the size of a buffer in bytes rather
|
|
|
- // than 16-bit Unicode characters,and the other is the IME
|
|
|
- // normally returns Unicode characters (rather than DBCS) in
|
|
|
- // the WM_CHAR and WM_IME_CHAR messages. Use RegisterClassW
|
|
|
- // to cause the WM_CHAR and WM_IME_CHAR messages to return
|
|
|
- // Unicode characters in the wParam parameter rather than DBCS
|
|
|
- // characters. This is only available under Windows NT; it is
|
|
|
- // stubbed out in Windows 95/98/Me.
|
|
|
-}
|
|
|
-
|
|
|
-void wdxGraphicsWindow::finish_window_setup(void) {
|
|
|
- // Now indicate that we have our keyboard/mouse device ready.
|
|
|
- GraphicsWindowInputDevice device = GraphicsWindowInputDevice::pointer_and_keyboard("keyboard/mouse");
|
|
|
- _input_devices.push_back(device);
|
|
|
-
|
|
|
- // move windows to top of zorder
|
|
|
- HWND hWin = _dxgsg->scrn.hWnd;
|
|
|
-
|
|
|
- // call twice to override STARTUPINFO value, which may be set to hidden initially (by emacs for instance)
|
|
|
- ShowWindow(hWin, SW_SHOWNORMAL);
|
|
|
- ShowWindow(hWin, SW_SHOWNORMAL);
|
|
|
- // UpdateWindow( _mwindow );
|
|
|
- SetWindowPos(hWin, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSENDCHANGING | SWP_NOSIZE);
|
|
|
-}
|
|
|
-
|
|
|
-// this handles external programmatic requests for resizing (usually fullscrn resize)
|
|
|
-bool wdxGraphicsWindow::resize(unsigned int xsize,unsigned int ysize) {
|
|
|
- bool bResizeSucceeded=false;
|
|
|
-
|
|
|
- if((xsize==_props._xsize)&&(ysize==_props._ysize)) {
|
|
|
- if(wdxdisplay_cat.is_debug())
|
|
|
- wdxdisplay_cat.debug() << "redundant resize() called, returning\n";
|
|
|
- return true;
|
|
|
- }
|
|
|
-
|
|
|
- if(!_props._fullscreen) {
|
|
|
- if(wdxdisplay_cat.is_debug())
|
|
|
- wdxdisplay_cat.debug() << "resize("<<xsize<<","<<ysize<<") called\n";
|
|
|
-
|
|
|
- // need to figure out actual window size based on props client area rect size
|
|
|
- RECT win_rect;
|
|
|
- SetRect(&win_rect, _props._xorg, _props._yorg, _props._xorg+xsize, _props._yorg+ysize);
|
|
|
-
|
|
|
- WINDOWINFO wi;
|
|
|
- GetWindowInfo(_dxgsg->scrn.hWnd,&wi);
|
|
|
- AdjustWindowRectEx(&win_rect, wi.dwStyle, false, wi.dwExStyle); //compute window size based on desired client area size
|
|
|
-
|
|
|
- // make sure origin is on screen
|
|
|
- if(win_rect.left < 0) {
|
|
|
- win_rect.right -= win_rect.left; win_rect.left = 0;
|
|
|
- _props._xorg=0;
|
|
|
- }
|
|
|
- if(win_rect.top < 0) {
|
|
|
- win_rect.bottom -= win_rect.top; win_rect.top = 0;
|
|
|
- _props._yorg=0;
|
|
|
- }
|
|
|
-
|
|
|
- SetWindowPos(_dxgsg->scrn.hWnd, NULL, win_rect.left,win_rect.top, RECT_XSIZE(win_rect), RECT_YSIZE(win_rect), SWP_NOZORDER | SWP_NOSENDCHANGING);
|
|
|
- // WM_ERASEBKGND will be ignored, because _WindowAdjustingType!=NotAdjusting because
|
|
|
- // we dont want to redraw as user is manually resizing window, so need to force explicit
|
|
|
- // background clear for the programmatic resize fn call
|
|
|
- _WindowAdjustingType=NotAdjusting;
|
|
|
-
|
|
|
- //window_proc(_mwindow, WM_ERASEBKGND,(WPARAM)_hdc,0x0); // this doesnt seem to be working in toontown resize, so I put ddraw blackblt in handle_windowed_resize instead
|
|
|
-
|
|
|
- return handle_windowed_resize(_dxgsg->scrn.hWnd,true);
|
|
|
- }
|
|
|
-
|
|
|
- assert(IS_VALID_PTR(_dxgsg));
|
|
|
-
|
|
|
- if(wdxdisplay_cat.is_info())
|
|
|
- wdxdisplay_cat.info() << "fullscrn resize("<<xsize<<","<<ysize<<") called\n";
|
|
|
-
|
|
|
- _dxgsg->SetDXReady(false);
|
|
|
-
|
|
|
- bool bCouldntFindValidZBuf;
|
|
|
- D3DFORMAT pixFmt;
|
|
|
- bool bNeedZBuffer = (_dxgsg->scrn.PresParams.EnableAutoDepthStencil!=false);
|
|
|
- bool bNeedStencilBuffer = IS_STENCIL_FORMAT(_dxgsg->scrn.PresParams.AutoDepthStencilFormat);
|
|
|
-
|
|
|
- bool bIsGoodMode=false;
|
|
|
-
|
|
|
- if(!special_check_fullscreen_resolution(xsize,ysize)) {
|
|
|
- // bypass the lowvidmem test below for certain "lowmem" cards we know have valid modes
|
|
|
-
|
|
|
- // wdxdisplay_cat.info() << "1111111 lowvidmemcard="<< _dxgsg->scrn.bIsLowVidMemCard << endl;
|
|
|
- if(_dxgsg->scrn.bIsLowVidMemCard && (!((xsize==640) && (ysize==480)))) {
|
|
|
- wdxdisplay_cat.error() << "resize() failed: will not try to resize low vidmem device #" << _dxgsg->scrn.CardIDNum << " to non-640x480!\n";
|
|
|
- goto Error_Return;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // must ALWAYS use search_for_valid_displaymode even if we know a-priori that res is valid so we can
|
|
|
- // get a valid pixfmt
|
|
|
- search_for_valid_displaymode(xsize,ysize,bNeedZBuffer,bNeedStencilBuffer,
|
|
|
- &_dxgsg->scrn.SupportedScreenDepthsMask,&bCouldntFindValidZBuf,
|
|
|
- &pixFmt);
|
|
|
- bIsGoodMode=(pixFmt!=D3DFMT_UNKNOWN);
|
|
|
-
|
|
|
- if(!bIsGoodMode) {
|
|
|
- wdxdisplay_cat.error() << "resize() failed: "
|
|
|
- << (bCouldntFindValidZBuf ? "Couldnt find valid zbuffer format to go with FullScreen mode" : "No supported FullScreen modes")
|
|
|
- << " at " << xsize << "x" << ysize << " for device #" << _dxgsg->scrn.CardIDNum <<endl;
|
|
|
- goto Error_Return;
|
|
|
- }
|
|
|
-
|
|
|
- // reset_device_resize_window handles both windowed & fullscrn,
|
|
|
- // so need to set new displaymode manually here
|
|
|
- _dxgsg->scrn.DisplayMode.Width=xsize;
|
|
|
- _dxgsg->scrn.DisplayMode.Height=ysize;
|
|
|
- _dxgsg->scrn.DisplayMode.Format = pixFmt;
|
|
|
- _dxgsg->scrn.DisplayMode.RefreshRate = D3DPRESENT_RATE_DEFAULT;
|
|
|
-
|
|
|
- _dxgsg->scrn.PresParams.BackBufferFormat = pixFmt; // make reset_device_resize use presparams or displaymode??
|
|
|
-
|
|
|
- // resized(xsize,ysize); not needed?
|
|
|
-
|
|
|
- bResizeSucceeded=reset_device_resize_window(xsize,ysize);
|
|
|
-
|
|
|
- if(!bResizeSucceeded) {
|
|
|
- wdxdisplay_cat.error() << "resize() failed with OUT-OF-MEMORY error!\n";
|
|
|
-
|
|
|
- if((!IS_16BPP_DISPLAY_FORMAT(_dxgsg->scrn.PresParams.BackBufferFormat)) &&
|
|
|
- (_dxgsg->scrn.SupportedScreenDepthsMask & (R5G6B5_FLAG|X1R5G5B5_FLAG))) {
|
|
|
- // fallback strategy, if we trying >16bpp, fallback to 16bpp buffers
|
|
|
- _dxgsg->scrn.DisplayMode.Format = ((_dxgsg->scrn.SupportedScreenDepthsMask & R5G6B5_FLAG) ? D3DFMT_R5G6B5 : D3DFMT_X1R5G5B5);
|
|
|
- dx_force_16bpp_zbuffer=true;
|
|
|
- if(wdxdisplay_cat.info())
|
|
|
- wdxdisplay_cat.info() << "CreateDevice failed with out-of-vidmem, retrying w/16bpp buffers on device #"<< _dxgsg->scrn.CardIDNum << endl;
|
|
|
-
|
|
|
- bResizeSucceeded= reset_device_resize_window(xsize,ysize); // create the new resized rendertargets
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- Error_Return:
|
|
|
-
|
|
|
- _dxgsg->SetDXReady(true);
|
|
|
-
|
|
|
- if(wdxdisplay_cat.is_debug())
|
|
|
- wdxdisplay_cat.debug() << "fullscrn resize("<<xsize<<","<<ysize<<") " << (bResizeSucceeded ? "succeeds\n" : "fails\n");
|
|
|
-
|
|
|
- return bResizeSucceeded;
|
|
|
-}
|
|
|
-
|
|
|
-// overrides of the general estimator for known working cases
|
|
|
-bool wdxGraphicsWindow::
|
|
|
-special_check_fullscreen_resolution(UINT xsize,UINT ysize) {
|
|
|
- assert(IS_VALID_PTR(_dxgsg));
|
|
|
-
|
|
|
- DWORD VendorId=_dxgsg->scrn.DXDeviceID.VendorId;
|
|
|
- DWORD DeviceId=_dxgsg->scrn.DXDeviceID.DeviceId;
|
|
|
- switch(VendorId) {
|
|
|
- case 0x8086: // Intel
|
|
|
- /*for now, just validate all the intel cards at these resolutions.
|
|
|
- I dont have a complete list of intel deviceIDs (missing 82830, 845, etc)
|
|
|
- // Intel i810,i815,82810
|
|
|
- if((DeviceId==0x7121)||(DeviceId==0x7123)||(DeviceId==0x7125)||
|
|
|
- (DeviceId==0x1132))
|
|
|
- */
|
|
|
- {
|
|
|
- if((xsize==640)&&(ysize==480))
|
|
|
- return true;
|
|
|
- if((xsize==800)&&(ysize==600))
|
|
|
- return true;
|
|
|
- if((xsize==1024)&&(ysize==768))
|
|
|
- return true;
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- return false;
|
|
|
-}
|
|
|
-
|
|
|
-UINT wdxGraphicsWindow::
|
|
|
-verify_window_sizes(UINT numsizes,UINT *dimen) {
|
|
|
- // unfortunately this only works AFTER you make the window initially,
|
|
|
- // so its really mostly useful for resizes only
|
|
|
- assert(IS_VALID_PTR(_dxgsg));
|
|
|
-
|
|
|
- UINT num_valid_modes=0;
|
|
|
-
|
|
|
- // not requesting same refresh rate since changing res might not support same refresh rate at new size
|
|
|
-
|
|
|
- UINT *pCurDim=(UINT *)dimen;
|
|
|
-
|
|
|
- for(UINT i=0;i<numsizes;i++,pCurDim+=2) {
|
|
|
- UINT xsize=pCurDim[0];
|
|
|
- UINT ysize=pCurDim[1];
|
|
|
-
|
|
|
- bool bIsGoodMode=false;
|
|
|
- bool CouldntFindAnyValidZBuf;
|
|
|
- D3DFORMAT newPixFmt=D3DFMT_UNKNOWN;
|
|
|
-
|
|
|
- if(special_check_fullscreen_resolution(xsize,ysize)) {
|
|
|
- // bypass the test below for certain cards we know have valid modes
|
|
|
- bIsGoodMode=true;
|
|
|
- } else {
|
|
|
- if(_dxgsg->scrn.bIsLowVidMemCard) {
|
|
|
- bIsGoodMode=((xsize==640) && (ysize==480));
|
|
|
- } else {
|
|
|
- search_for_valid_displaymode(xsize,ysize,_dxgsg->scrn.PresParams.EnableAutoDepthStencil!=false,
|
|
|
- IS_STENCIL_FORMAT(_dxgsg->scrn.PresParams.AutoDepthStencilFormat),
|
|
|
- &_dxgsg->scrn.SupportedScreenDepthsMask,&CouldntFindAnyValidZBuf,
|
|
|
- &newPixFmt);
|
|
|
- bIsGoodMode=(newPixFmt!=D3DFMT_UNKNOWN);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if(bIsGoodMode) {
|
|
|
- num_valid_modes++;
|
|
|
- } else {
|
|
|
- // tell caller the mode is invalid
|
|
|
- pCurDim[0] = 0;
|
|
|
- pCurDim[1] = 0;
|
|
|
- }
|
|
|
-
|
|
|
- if(wdxdisplay_cat.is_spam())
|
|
|
- wdxdisplay_cat.spam() << "Fullscrn Mode (" << xsize << "," << ysize << ")\t" << (bIsGoodMode ? "V" : "Inv") <<"alid\n";
|
|
|
- }
|
|
|
-
|
|
|
- return num_valid_modes;
|
|
|
-}
|
|
|
-
|
|
|
-BOOL WINAPI DX7_DriverEnumCallback( GUID* pGUID, TCHAR* strDesc,TCHAR* strName,VOID *argptr, HMONITOR hm) {
|
|
|
-// #define PRNT(XX) ((XX!=NULL) ? XX : "NULL")
|
|
|
-// cout << "strDesc: "<< PRNT(strDesc) << " strName: "<< PRNT(strName)<<endl;
|
|
|
-
|
|
|
- CardID CurCardID;
|
|
|
-
|
|
|
- ZeroMemory(&CurCardID,sizeof(CardID));
|
|
|
-
|
|
|
- if(hm==NULL) {
|
|
|
- CurCardID.hMon=MonitorFromWindow(GetDesktopWindow(),MONITOR_DEFAULTTOPRIMARY);
|
|
|
- } else {
|
|
|
- CurCardID.hMon=hm;
|
|
|
- }
|
|
|
-
|
|
|
- if(pGUID!=NULL)
|
|
|
- memcpy(&CurCardID.DX7_DeviceGUID,pGUID,sizeof(GUID));
|
|
|
-
|
|
|
- if(g_pCardIDVec==NULL) {
|
|
|
- g_pCardIDVec= new CardIDVec;
|
|
|
- }
|
|
|
-
|
|
|
- CurCardID.MaxAvailVidMem = UNKNOWN_VIDMEM_SIZE;
|
|
|
-
|
|
|
- g_pCardIDVec->push_back(CurCardID);
|
|
|
- return DDENUMRET_OK;
|
|
|
-}
|
|
|
-
|
|
|
-void wdxGraphicsWindowGroup::
|
|
|
-find_all_card_memavails(void) {
|
|
|
- if(g_pCardIDVec!=NULL) // we've already got the info
|
|
|
- return;
|
|
|
-
|
|
|
- #define DDRAW_NAME "ddraw.dll"
|
|
|
-
|
|
|
- HINSTANCE hDDrawDLL = LoadLibrary(DDRAW_NAME);
|
|
|
- if(hDDrawDLL == 0) {
|
|
|
- wdxdisplay_cat.fatal() << "LoadLibrary(" << DDRAW_NAME <<") failed!, error=" << GetLastError() << endl;
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- LPDIRECTDRAWCREATEEX pDDCreateEx;
|
|
|
-
|
|
|
- pDDCreateEx = (LPDIRECTDRAWCREATEEX) GetProcAddress(hDDrawDLL,"DirectDrawCreateEx");
|
|
|
- if(pDDCreateEx == NULL) {
|
|
|
- wdxdisplay_cat.fatal() << "GetProcAddr failed for DDCreateEx" << endl;
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- LPDIRECTDRAWENUMERATEEX pDDEnumEx = (LPDIRECTDRAWENUMERATEEX) GetProcAddress(hDDrawDLL,"DirectDrawEnumerateExA");
|
|
|
- if(pDDEnumEx == NULL) {
|
|
|
- wdxdisplay_cat.fatal() << "GetProcAddr failed for DirectDrawEnumerateEx! (win95 system?)\n";
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- HRESULT hr = (*pDDEnumEx)(DX7_DriverEnumCallback, NULL, DDENUM_ATTACHEDSECONDARYDEVICES | DDENUM_NONDISPLAYDEVICES);
|
|
|
- if(FAILED(hr)) {
|
|
|
- wdxdisplay_cat.fatal() << "DirectDrawEnumerateEx failed" << D3DERRORSTRING(hr);
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- if(g_pCardIDVec==NULL) {
|
|
|
- wdxdisplay_cat.error() << "DirectDrawEnumerateEx enum'ed no devices!\n";
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- GUID ZeroGUID;
|
|
|
- ZeroMemory(&ZeroGUID,sizeof(GUID));
|
|
|
-
|
|
|
- if(g_pCardIDVec->size()>1) {
|
|
|
- assert(IsEqualGUID(ZeroGUID,(*g_pCardIDVec)[0].DX7_DeviceGUID));
|
|
|
- // delete enum of primary display (always the first), since it is duplicated by explicit entry
|
|
|
- g_pCardIDVec->erase(g_pCardIDVec->begin());
|
|
|
- }
|
|
|
-
|
|
|
- for(UINT i=0;i<g_pCardIDVec->size();i++) {
|
|
|
- LPDIRECTDRAW7 pDD;
|
|
|
- BYTE ddd_space[sizeof(DDDEVICEIDENTIFIER2)+4]; //bug in DX7 requires 4 extra bytes for GetDeviceID
|
|
|
- DDDEVICEIDENTIFIER2 *pDX7DeviceID=(DDDEVICEIDENTIFIER2 *)&ddd_space[0];
|
|
|
- GUID *pGUID= &((*g_pCardIDVec)[i].DX7_DeviceGUID);
|
|
|
-
|
|
|
- if(IsEqualGUID(*pGUID,ZeroGUID))
|
|
|
- pGUID=NULL;
|
|
|
-
|
|
|
- // Create the Direct Draw Object
|
|
|
- hr = (*pDDCreateEx)(pGUID,(void **)&pDD, IID_IDirectDraw7, NULL);
|
|
|
- if(FAILED(hr)) {
|
|
|
- wdxdisplay_cat.fatal() << "DirectDrawCreateEx failed for device ("<< i << ")" << D3DERRORSTRING(hr);
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- ZeroMemory(ddd_space,sizeof(DDDEVICEIDENTIFIER2));
|
|
|
-
|
|
|
- hr = pDD->GetDeviceIdentifier(pDX7DeviceID,0x0);
|
|
|
- if(FAILED(hr)) {
|
|
|
- wdxdisplay_cat.fatal() << "GetDeviceID failed for device ("<< i << ")" << D3DERRORSTRING(hr);
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- (*g_pCardIDVec)[i].DeviceID = pDX7DeviceID->dwDeviceId;
|
|
|
- (*g_pCardIDVec)[i].VendorID = pDX7DeviceID->dwVendorId;
|
|
|
-
|
|
|
- // Get Current VidMem avail. Note this is only an estimate, when we switch to fullscreen
|
|
|
- // mode from desktop, more vidmem will be available (typically 1.2 meg). I dont want
|
|
|
- // to switch to fullscreen more than once due to the annoying monitor flicker, so try
|
|
|
- // to figure out optimal mode using this estimate
|
|
|
- DDSCAPS2 ddsGAVMCaps;
|
|
|
- DWORD dwVidMemTotal,dwVidMemFree;
|
|
|
- dwVidMemTotal=dwVidMemFree=0;
|
|
|
- {
|
|
|
- // print out total INCLUDING AGP just for information purposes and future use
|
|
|
- // The real value I'm interested in for purposes of measuring possible valid screen sizes
|
|
|
- // shouldnt include AGP
|
|
|
- ZeroMemory(&ddsGAVMCaps,sizeof(DDSCAPS2));
|
|
|
- ddsGAVMCaps.dwCaps = DDSCAPS_VIDEOMEMORY;
|
|
|
-
|
|
|
- if(FAILED(hr = pDD->GetAvailableVidMem(&ddsGAVMCaps,&dwVidMemTotal,&dwVidMemFree))) {
|
|
|
- wdxdisplay_cat.error() << "GetAvailableVidMem failed for device #"<< i << D3DERRORSTRING(hr);
|
|
|
- // goto skip_device;
|
|
|
- exit(1); // probably want to exit, since it may be my fault
|
|
|
- }
|
|
|
- }
|
|
|
- wdxdisplay_cat.info() << "GetAvailableVidMem (including AGP) returns Total: "<<dwVidMemTotal <<", Free: " << dwVidMemFree << " for device #"<<i<< endl;
|
|
|
-
|
|
|
- ZeroMemory(&ddsGAVMCaps,sizeof(DDSCAPS2));
|
|
|
- // just want to measure localvidmem, not AGP texmem
|
|
|
- ddsGAVMCaps.dwCaps = DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM;
|
|
|
- if(FAILED(hr = pDD->GetAvailableVidMem(&ddsGAVMCaps,&dwVidMemTotal,&dwVidMemFree))) {
|
|
|
- wdxdisplay_cat.error() << "GetAvailableVidMem failed for device #"<< i<< D3DERRORSTRING(hr);
|
|
|
- // goto skip_device;
|
|
|
- exit(1); // probably want to exit, since it may be my fault
|
|
|
- }
|
|
|
-
|
|
|
- wdxdisplay_cat.info() << "GetAvailableVidMem (no AGP) returns Total: "<<dwVidMemTotal <<", Free: " << dwVidMemFree << " for device #"<< i<< endl;
|
|
|
-
|
|
|
- pDD->Release(); // release DD obj, since this is all we needed it for
|
|
|
-
|
|
|
- if(!dx_do_vidmemsize_check) {
|
|
|
- // still calling the DD stuff to get deviceID, etc. is this necessary?
|
|
|
- (*g_pCardIDVec)[i].MaxAvailVidMem = UNKNOWN_VIDMEM_SIZE;
|
|
|
- (*g_pCardIDVec)[i].bIsLowVidMemCard = false;
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- if(dwVidMemTotal==0) { // unreliable driver
|
|
|
- dwVidMemTotal=UNKNOWN_VIDMEM_SIZE;
|
|
|
- } else {
|
|
|
- if(!ISPOW2(dwVidMemTotal)) {
|
|
|
- // assume they wont return a proper max value, so
|
|
|
- // round up to next pow of 2
|
|
|
- UINT count=0;
|
|
|
- while((dwVidMemTotal >> count)!=0x0)
|
|
|
- count++;
|
|
|
- dwVidMemTotal = (1 << count);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // after SetDisplayMode, GetAvailVidMem totalmem seems to go down by 1.2 meg (contradicting above
|
|
|
- // comment and what I think would be correct behavior (shouldnt FS mode release the desktop vidmem?),
|
|
|
- // so this is the true value
|
|
|
- (*g_pCardIDVec)[i].MaxAvailVidMem = dwVidMemTotal;
|
|
|
-
|
|
|
- // I can never get this stuff to work reliably, so I'm just rounding up to nearest pow2.
|
|
|
- // Could try to get HardwareInformation.MemorySize MB number from registry like video control panel,
|
|
|
- // but its not clear how to find the proper registry location for a given card
|
|
|
-
|
|
|
- // #define LOWVIDMEMTHRESHOLD 3500000
|
|
|
- // #define CRAPPY_DRIVER_IS_LYING_VIDMEMTHRESHOLD 1000000
|
|
|
-
|
|
|
- #define LOWVIDMEMTHRESHOLD 5700000 // 4MB cards should fall below this
|
|
|
- #define CRAPPY_DRIVER_IS_LYING_VIDMEMTHRESHOLD 1000000 // if # is > 1MB, card is lying and I cant tell what it is
|
|
|
-
|
|
|
- // assume buggy drivers (this means you, FireGL2) may return zero (or small amts) for dwVidMemTotal, so ignore value if its < CRAPPY_DRIVER_IS_LYING_VIDMEMTHRESHOLD
|
|
|
- bool bLowVidMemFlag = ((dwVidMemTotal>CRAPPY_DRIVER_IS_LYING_VIDMEMTHRESHOLD) && (dwVidMemTotal< LOWVIDMEMTHRESHOLD));
|
|
|
-
|
|
|
- (*g_pCardIDVec)[i].bIsLowVidMemCard = bLowVidMemFlag;
|
|
|
- wdxdisplay_cat.info() << "SetLowVidMem flag to "<< bLowVidMemFlag<< " based on adjusted VidMemTotal: " <<dwVidMemTotal << endl;
|
|
|
- }
|
|
|
-
|
|
|
- FreeLibrary(hDDrawDLL);
|
|
|
-}
|
|
|
-
|
|
|
-/*
|
|
|
-void wdxGraphicsWindow::
|
|
|
-check_for_color_cursor_support(void) {
|
|
|
- // card support for non-black/white GDI cursors varies greatly. if the cursor is not supported,
|
|
|
- // it is rendered in software by GDI, which causes a flickering effect (because it's not synced
|
|
|
- // with flip?). GDI transparently masks what's happening so there is no easy way for app to detect
|
|
|
- // if HW cursor support exists. alternatives are to tie cursor motion to frame rate using DDraw blts
|
|
|
- // or overlays, or to have separate thread draw cursor (sync issues?). instead we do mono cursor
|
|
|
- // unless card is known to support 256 color cursors
|
|
|
-
|
|
|
- string windows_color_cursor_filename = get_color_cursor_filename().to_os_specific();
|
|
|
- if(windows_color_cursor_filename.empty())
|
|
|
- return;
|
|
|
-
|
|
|
- bool bSupportsColorCursor=false;
|
|
|
-
|
|
|
- if(IS_NVIDIA(_DXDeviceID)) {
|
|
|
- // all nvidia seem to support 256 color
|
|
|
- bSupportsColorCursor=true;
|
|
|
- } else if(IS_ATI(_DXDeviceID)) {
|
|
|
- // radeons seem to be in the 5100 range and support color, assume anything in 6000 or above
|
|
|
- // is newer than radeon and supports 256 color
|
|
|
- if(((_DXDeviceID.dwDeviceId>=0x5100) && (_DXDeviceID.dwDeviceId<=0x5200)) ||
|
|
|
- (_DXDeviceID.dwDeviceId>=0x6000))
|
|
|
- bSupportsColorCursor=true;
|
|
|
- } else if IS_MATROX(_DXDeviceID) {
|
|
|
- if(_DXDeviceID.dwDeviceId==0x0525) // G400 seems to support color cursors, havent tested other matrox
|
|
|
- bSupportsColorCursor=true;
|
|
|
- }
|
|
|
-
|
|
|
- // TODO: add more cards as more testing is done
|
|
|
-
|
|
|
- if(bSupportsColorCursor) {
|
|
|
- // Note: LoadImage seems to cause win2k internal heap corruption (outputdbgstr warnings)
|
|
|
- // if icon is more than 8bpp
|
|
|
-
|
|
|
- DWORD load_flags = LR_LOADFROMFILE;
|
|
|
-
|
|
|
- if(_props._fullscreen) {
|
|
|
- // I think cursors should use LR_CREATEDIBSECTION since they should not be mapped to the device palette (in the case of 256-color cursors)
|
|
|
- // since they are not going to be used on the desktop
|
|
|
- load_flags |= LR_CREATEDIBSECTION;
|
|
|
- }
|
|
|
-
|
|
|
- // loads a .cur fmt file.
|
|
|
- HCURSOR hNewMouseCursor = (HCURSOR) LoadImage(NULL, windows_color_cursor_filename.c_str(), IMAGE_CURSOR, 0, 0, load_flags );
|
|
|
-
|
|
|
- if(hNewMouseCursor==NULL) {
|
|
|
- wdxdisplay_cat.warning() << "windows color cursor filename '" << windows_color_cursor_filename << "' not found!!\n";
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- SetClassLongPtr(_mwindow, GCLP_HCURSOR, (LONG_PTR) hNewMouseCursor);
|
|
|
- SetCursor(hNewMouseCursor);
|
|
|
-
|
|
|
- if(_bLoadedCustomCursor)
|
|
|
- DestroyCursor(_hMouseCursor);
|
|
|
- _hMouseCursor = hNewMouseCursor;
|
|
|
- }
|
|
|
-}
|
|
|
-*/
|
|
|
-
|
|
|
-int D3DFMT_to_DepthBits(D3DFORMAT fmt) {
|
|
|
- switch(fmt) {
|
|
|
- case D3DFMT_D16: return 16;
|
|
|
- case D3DFMT_D24X8:
|
|
|
- case D3DFMT_D24X4S4:
|
|
|
- case D3DFMT_D24S8: return 24;
|
|
|
- case D3DFMT_D32: return 32;
|
|
|
- case D3DFMT_D15S1: return 15;
|
|
|
- default:
|
|
|
- wdxdisplay_cat.debug() << "D3DFMT_DepthBits: unhandled D3DFMT!\n";
|
|
|
- return 0;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-bool wdxGraphicsWindow::FindBestDepthFormat(DXScreenData &Display,D3DDISPLAYMODE &TestDisplayMode,D3DFORMAT *pBestFmt,bool bWantStencil,bool bForce16bpp,bool bVerboseMode) const {
|
|
|
- // list fmts in order of preference
|
|
|
- #define NUM_TEST_ZFMTS 3
|
|
|
- static D3DFORMAT NoStencilPrefList[NUM_TEST_ZFMTS]={D3DFMT_D32,D3DFMT_D24X8,D3DFMT_D16};
|
|
|
- static D3DFORMAT StencilPrefList[NUM_TEST_ZFMTS]={D3DFMT_D24S8,D3DFMT_D24X4S4,D3DFMT_D15S1};
|
|
|
-
|
|
|
- // do not use Display.DisplayMode since that is probably not set yet, use TestDisplayMode instead
|
|
|
-
|
|
|
- // int want_color_bits = _props._want_color_bits;
|
|
|
- // int want_depth_bits = _props._want_depth_bits; should we pay attn to these so panda user can select bitdepth?
|
|
|
-
|
|
|
- *pBestFmt = D3DFMT_UNKNOWN;
|
|
|
- HRESULT hr;
|
|
|
-
|
|
|
- // nvidia likes zbuf depth to match rendertarget depth
|
|
|
- bool bOnlySelect16bpp= (dx_force_16bpp_zbuffer || bForce16bpp ||
|
|
|
- (IS_NVIDIA(Display.DXDeviceID) && IS_16BPP_DISPLAY_FORMAT(TestDisplayMode.Format)));
|
|
|
-
|
|
|
- if(bVerboseMode)
|
|
|
- wdxdisplay_cat.info() << "FindBestDepthFmt: bSelectOnly16bpp: " << bOnlySelect16bpp << endl;
|
|
|
-
|
|
|
- for(int i=0;i<NUM_TEST_ZFMTS;i++) {
|
|
|
- D3DFORMAT TestDepthFmt = (bWantStencil ? StencilPrefList[i] : NoStencilPrefList[i]);
|
|
|
-
|
|
|
- if(bOnlySelect16bpp && !IS_16BPP_ZBUFFER(TestDepthFmt))
|
|
|
- continue;
|
|
|
-
|
|
|
- hr = Display.pD3D8->CheckDeviceFormat(Display.CardIDNum,D3DDEVTYPE_HAL,TestDisplayMode.Format,
|
|
|
- D3DUSAGE_DEPTHSTENCIL,D3DRTYPE_SURFACE,TestDepthFmt);
|
|
|
-
|
|
|
- if(FAILED(hr)) {
|
|
|
- if(hr==D3DERR_NOTAVAILABLE) {
|
|
|
- if(bVerboseMode)
|
|
|
- wdxdisplay_cat.info() << "FindBestDepthFmt: ChkDevFmt returns NotAvail for " << D3DFormatStr(TestDepthFmt) << endl;
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- wdxdisplay_cat.error() << "unexpected CheckDeviceFormat failure" << D3DERRORSTRING(hr);
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- hr = Display.pD3D8->CheckDepthStencilMatch(Display.CardIDNum,D3DDEVTYPE_HAL,
|
|
|
- TestDisplayMode.Format, // adapter format
|
|
|
- TestDisplayMode.Format, // backbuffer fmt (should be the same in my apps)
|
|
|
- TestDepthFmt);
|
|
|
- if(SUCCEEDED(hr)) {
|
|
|
- *pBestFmt = TestDepthFmt;
|
|
|
- break;
|
|
|
- } else {
|
|
|
- if(hr==D3DERR_NOTAVAILABLE) {
|
|
|
- if(bVerboseMode)
|
|
|
- wdxdisplay_cat.info() << "FindBestDepthFmt: ChkDepMatch returns NotAvail for " << D3DFormatStr(TestDisplayMode.Format) << ", " << D3DFormatStr(TestDepthFmt) << endl;
|
|
|
- } else {
|
|
|
- wdxdisplay_cat.error() << "unexpected CheckDepthStencilMatch failure for " << D3DFormatStr(TestDisplayMode.Format) << ", " << D3DFormatStr(TestDepthFmt) << endl;
|
|
|
- exit(1);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if(bVerboseMode)
|
|
|
- wdxdisplay_cat.info() << "FindBestDepthFmt returns fmt " << D3DFormatStr(*pBestFmt) << endl;
|
|
|
-
|
|
|
- return (*pBestFmt != D3DFMT_UNKNOWN);
|
|
|
-}
|
|
|
-
|
|
|
-// all ptr args are output parameters
|
|
|
-// if no valid mode found, returns *pSuggestedPixFmt = D3DFMT_UNKNOWN;
|
|
|
-void wdxGraphicsWindow::search_for_valid_displaymode(UINT RequestedXsize,UINT RequestedYsize,bool bWantZBuffer,bool bWantStencil,
|
|
|
- UINT *pSupportedScreenDepthsMask,bool *pCouldntFindAnyValidZBuf,
|
|
|
- D3DFORMAT *pSuggestedPixFmt, bool bVerboseMode) {
|
|
|
- assert(IS_VALID_PTR(_dxgsg));
|
|
|
- assert(IS_VALID_PTR(_dxgsg->scrn.pD3D8));
|
|
|
- HRESULT hr;
|
|
|
-
|
|
|
- #ifndef NDEBUG
|
|
|
-// no longer true, due to special_check_fullscreen_res, where lowvidmem cards are allowed higher resolutions
|
|
|
-// if(_dxgsg->scrn.bIsLowVidMemCard)
|
|
|
-// nassertv((RequestedXsize==640)&&(RequestedYsize==480));
|
|
|
- #endif
|
|
|
-
|
|
|
- *pSuggestedPixFmt = D3DFMT_UNKNOWN;
|
|
|
- *pSupportedScreenDepthsMask = 0x0;
|
|
|
- *pCouldntFindAnyValidZBuf=false;
|
|
|
-
|
|
|
- int cNumModes=_dxgsg->scrn.pD3D8->GetAdapterModeCount(_dxgsg->scrn.CardIDNum);
|
|
|
- D3DDISPLAYMODE BestDispMode;
|
|
|
- ZeroMemory(&BestDispMode,sizeof(BestDispMode));
|
|
|
-
|
|
|
- if(bVerboseMode)
|
|
|
- wdxdisplay_cat.info() << "searching for valid display modes at res: (" << RequestedXsize << "," << RequestedYsize << "), TotalModes: " << cNumModes<< endl;
|
|
|
-
|
|
|
- // ignore memory based checks for min res 640x480. some cards just dont give accurate memavails.
|
|
|
- // (should I do the check anyway for 640x480 32bpp?)
|
|
|
- bool bDoMemBasedChecks=((!((RequestedXsize==640)&&(RequestedYsize==480))) &&
|
|
|
- (_dxgsg->scrn.MaxAvailVidMem!=UNKNOWN_VIDMEM_SIZE) &&
|
|
|
- (!special_check_fullscreen_resolution(RequestedXsize,RequestedYsize)));
|
|
|
-
|
|
|
- if(bVerboseMode || wdxdisplay_cat.is_spam()) {
|
|
|
- wdxdisplay_cat.info() << "DoMemBasedChecks = " << bDoMemBasedChecks << endl;
|
|
|
- }
|
|
|
-
|
|
|
- for(int i=0;i<cNumModes;i++) {
|
|
|
- D3DDISPLAYMODE dispmode;
|
|
|
- hr = _dxgsg->scrn.pD3D8->EnumAdapterModes(_dxgsg->scrn.CardIDNum,i,&dispmode);
|
|
|
- if(FAILED(hr)) {
|
|
|
- wdxdisplay_cat.error() << "EnumAdapterDisplayMode failed for device #"<<_dxgsg->scrn.CardIDNum<< D3DERRORSTRING(hr);
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- if((dispmode.Width!=RequestedXsize) || (dispmode.Height!=RequestedYsize))
|
|
|
- continue;
|
|
|
-
|
|
|
- if((dispmode.RefreshRate<60) && (dispmode.RefreshRate>1)) {
|
|
|
- // dont want refresh rates under 60Hz, but 0 or 1 might indicate a default refresh rate, which is usually >=60
|
|
|
- if(bVerboseMode)
|
|
|
- wdxdisplay_cat.info() << "skipping mode["<<i<<"], bad refresh rate: " << dispmode.RefreshRate << endl;
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- // Note no attempt is made to verify if format will work at requested size, so even if this call
|
|
|
- // succeeds, could still get an out-of-video-mem error
|
|
|
-
|
|
|
- hr = _dxgsg->scrn.pD3D8->CheckDeviceFormat(_dxgsg->scrn.CardIDNum,D3DDEVTYPE_HAL,dispmode.Format,
|
|
|
- D3DUSAGE_RENDERTARGET,D3DRTYPE_SURFACE,dispmode.Format);
|
|
|
- if(FAILED(hr)) {
|
|
|
- if(hr==D3DERR_NOTAVAILABLE) {
|
|
|
- if(bVerboseMode)
|
|
|
- wdxdisplay_cat.info() << "skipping mode["<<i<<"], CheckDevFmt returns NotAvail for fmt: " << D3DFormatStr(dispmode.Format) << endl;
|
|
|
- continue;
|
|
|
- } else {
|
|
|
- wdxdisplay_cat.error() << "CheckDeviceFormat failed for device #" <<_dxgsg->scrn.CardIDNum << D3DERRORSTRING(hr);
|
|
|
- exit(1);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- bool bIs16bppRenderTgt = IS_16BPP_DISPLAY_FORMAT(dispmode.Format);
|
|
|
- float RendTgtMinMemReqmt;
|
|
|
-
|
|
|
- // if we have a valid memavail value, try to determine if we have enough space
|
|
|
- if( bDoMemBasedChecks) {
|
|
|
-
|
|
|
- // assume user is testing fullscreen, not windowed, so use the dwTotal value
|
|
|
- // see if 3 scrnbufs (front/back/z)at 16bpp at xsize*ysize will fit with a few
|
|
|
- // extra megs for texmem
|
|
|
-
|
|
|
- // 8MB Rage Pro says it has 6.8 megs Total free and will run at 1024x768, so
|
|
|
- // formula makes it so that is OK
|
|
|
-
|
|
|
- #define REQD_TEXMEM 1800000
|
|
|
-
|
|
|
- float bytes_per_pixel = (bIs16bppRenderTgt ? 2 : 4);
|
|
|
- assert(_props._mask & W_DOUBLE);
|
|
|
-
|
|
|
- // *2 for double buffer
|
|
|
-
|
|
|
- RendTgtMinMemReqmt = ((float)RequestedXsize)*((float)RequestedYsize)*bytes_per_pixel*2+REQD_TEXMEM;
|
|
|
-
|
|
|
- if(bVerboseMode || wdxdisplay_cat.is_spam())
|
|
|
- wdxdisplay_cat.info() << "Testing Mode (" <<RequestedXsize<<"x" << RequestedYsize <<","
|
|
|
- << D3DFormatStr(dispmode.Format) << ")\nReqdVidMem: "<< (int)RendTgtMinMemReqmt << " AvailVidMem: " << _dxgsg->scrn.MaxAvailVidMem << endl;
|
|
|
-
|
|
|
- if(RendTgtMinMemReqmt>_dxgsg->scrn.MaxAvailVidMem) {
|
|
|
- if(bVerboseMode || wdxdisplay_cat.is_debug())
|
|
|
- wdxdisplay_cat.info() << "not enough VidMem for render tgt, skipping display fmt " << D3DFormatStr(dispmode.Format)
|
|
|
- << " (" << (int)RendTgtMinMemReqmt << " > " << _dxgsg->scrn.MaxAvailVidMem << ")\n";
|
|
|
- continue;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if(bWantZBuffer) {
|
|
|
- D3DFORMAT zformat;
|
|
|
- if(!FindBestDepthFormat(_dxgsg->scrn,dispmode,&zformat,bWantStencil,false)) {
|
|
|
- *pCouldntFindAnyValidZBuf=true;
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- float MinMemReqmt = 0.0f;
|
|
|
-
|
|
|
- if(bDoMemBasedChecks) {
|
|
|
- // test memory again, this time including zbuf size
|
|
|
- float zbytes_per_pixel = (IS_16BPP_ZBUFFER(zformat) ? 2 : 4);
|
|
|
- float MinMemReqmt = RendTgtMinMemReqmt + ((float)RequestedXsize)*((float)RequestedYsize)*zbytes_per_pixel;
|
|
|
-
|
|
|
- if(bVerboseMode || wdxdisplay_cat.is_spam())
|
|
|
- wdxdisplay_cat.info() << "Testing Mode w/Z (" << RequestedXsize << "x" << RequestedYsize << ","
|
|
|
- << D3DFormatStr(dispmode.Format) << ")\nReqdVidMem: "<< (int)MinMemReqmt << " AvailVidMem: " << _dxgsg->scrn.MaxAvailVidMem << endl;
|
|
|
-
|
|
|
- if(MinMemReqmt>_dxgsg->scrn.MaxAvailVidMem) {
|
|
|
- if(bVerboseMode || wdxdisplay_cat.is_debug())
|
|
|
- wdxdisplay_cat.info() << "not enough VidMem for RendTgt+zbuf, skipping display fmt " << D3DFormatStr(dispmode.Format)
|
|
|
- << " (" << (int)MinMemReqmt << " > " << _dxgsg->scrn.MaxAvailVidMem << ")\n";
|
|
|
- continue;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if((!bDoMemBasedChecks) || (MinMemReqmt<_dxgsg->scrn.MaxAvailVidMem)) {
|
|
|
- if(!IS_16BPP_ZBUFFER(zformat)) {
|
|
|
- // see if things fit with a 16bpp zbuffer
|
|
|
-
|
|
|
- if(!FindBestDepthFormat(_dxgsg->scrn,dispmode,&zformat,bWantStencil,true,bVerboseMode)) {
|
|
|
- if(bVerboseMode)
|
|
|
- wdxdisplay_cat.info() << "FindBestDepthFmt rejected Mode["<<i<<"] (" <<RequestedXsize<<"x" << RequestedYsize <<","<< D3DFormatStr(dispmode.Format) << endl;
|
|
|
- *pCouldntFindAnyValidZBuf=true;
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- // right now I'm not going to use these flags, just let the create fail out-of-mem and retry at 16bpp
|
|
|
- *pSupportedScreenDepthsMask |= (IS_16BPP_DISPLAY_FORMAT(dispmode.Format) ? DISPLAY_16BPP_REQUIRES_16BPP_ZBUFFER_FLAG : DISPLAY_32BPP_REQUIRES_16BPP_ZBUFFER_FLAG);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if(bVerboseMode || wdxdisplay_cat.is_spam())
|
|
|
- wdxdisplay_cat.info() << "Validated Mode (" <<RequestedXsize<<"x" << RequestedYsize <<","
|
|
|
- << D3DFormatStr(dispmode.Format) << endl;
|
|
|
-
|
|
|
- switch(dispmode.Format) {
|
|
|
- case D3DFMT_X1R5G5B5:
|
|
|
- *pSupportedScreenDepthsMask |= X1R5G5B5_FLAG;
|
|
|
- break;
|
|
|
- case D3DFMT_X8R8G8B8:
|
|
|
- *pSupportedScreenDepthsMask |= X8R8G8B8_FLAG;
|
|
|
- break;
|
|
|
- case D3DFMT_R8G8B8:
|
|
|
- *pSupportedScreenDepthsMask |= R8G8B8_FLAG;
|
|
|
- break;
|
|
|
- case D3DFMT_R5G6B5:
|
|
|
- *pSupportedScreenDepthsMask |= R5G6B5_FLAG;
|
|
|
- break;
|
|
|
- default:
|
|
|
- //Render target formats should be only D3DFMT_X1R5G5B5, D3DFMT_R5G6B5, D3DFMT_X8R8G8B8 (or R8G8B8?)
|
|
|
- wdxdisplay_cat.error() << "unrecognized supported fmt "<< D3DFormatStr(dispmode.Format)<<" returned by EnumAdapterDisplayModes!\n";
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // note: this chooses 32bpp, which may not be preferred over 16 for memory & speed reasons on some older cards in particular
|
|
|
- if(*pSupportedScreenDepthsMask & X8R8G8B8_FLAG)
|
|
|
- *pSuggestedPixFmt = D3DFMT_X8R8G8B8;
|
|
|
- else if(*pSupportedScreenDepthsMask & R8G8B8_FLAG)
|
|
|
- *pSuggestedPixFmt = D3DFMT_R8G8B8;
|
|
|
- else if(*pSupportedScreenDepthsMask & R5G6B5_FLAG)
|
|
|
- *pSuggestedPixFmt = D3DFMT_R5G6B5;
|
|
|
- else if(*pSupportedScreenDepthsMask & X1R5G5B5_FLAG)
|
|
|
- *pSuggestedPixFmt = D3DFMT_X1R5G5B5;
|
|
|
-
|
|
|
- if(bVerboseMode || wdxdisplay_cat.is_spam())
|
|
|
- wdxdisplay_cat.info() << "search_for_valid_device returns fmt: "<< D3DFormatStr(*pSuggestedPixFmt) << endl;
|
|
|
-}
|
|
|
-
|
|
|
-bool is_badvidmem_card(D3DADAPTER_IDENTIFIER8 *pDevID) {
|
|
|
- // dont trust Intel cards since they often use regular memory as vidmem
|
|
|
- if(pDevID->VendorId==0x00008086)
|
|
|
- return true;
|
|
|
-
|
|
|
- return false;
|
|
|
-}
|
|
|
-
|
|
|
-// returns true if successful
|
|
|
-bool wdxGraphicsWindow::search_for_device(LPDIRECT3D8 pD3D8,DXDeviceInfo *pDevInfo) {
|
|
|
- DWORD dwRenderWidth = _props._xsize;
|
|
|
- DWORD dwRenderHeight = _props._ysize;
|
|
|
- HRESULT hr;
|
|
|
-
|
|
|
- assert(_dxgsg!=NULL);
|
|
|
- _dxgsg->scrn.pD3D8 = pD3D8;
|
|
|
- _dxgsg->scrn.CardIDNum=pDevInfo->cardID; // could this change by end?
|
|
|
-
|
|
|
- bool bWantStencil = ((_props._mask & W_STENCIL)!=0);
|
|
|
-
|
|
|
- hr = pD3D8->GetAdapterIdentifier(pDevInfo->cardID,D3DENUM_NO_WHQL_LEVEL,&_dxgsg->scrn.DXDeviceID);
|
|
|
- if(FAILED(hr)) {
|
|
|
- wdxdisplay_cat.fatal() << "D3D GetAdapterID failed" << D3DERRORSTRING(hr);
|
|
|
- }
|
|
|
-
|
|
|
- D3DCAPS8 d3dcaps;
|
|
|
- hr = pD3D8->GetDeviceCaps(pDevInfo->cardID,D3DDEVTYPE_HAL,&d3dcaps);
|
|
|
- if(FAILED(hr)) {
|
|
|
- if((hr==D3DERR_INVALIDDEVICE)||(hr==D3DERR_NOTAVAILABLE)) {
|
|
|
- wdxdisplay_cat.fatal() << "No DirectX 8 D3D-capable 3D hardware detected for device # "<<pDevInfo->cardID<<" ("<<pDevInfo->szDescription << ")! Exiting...\n";
|
|
|
- } else {
|
|
|
- wdxdisplay_cat.fatal() << "GetDeviceCaps failed" << D3DERRORSTRING(hr);
|
|
|
- }
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- //search_for_valid_displaymode needs these to be set
|
|
|
- memcpy(&_dxgsg->scrn.d3dcaps,&d3dcaps,sizeof(D3DCAPS8));
|
|
|
- _dxgsg->scrn.CardIDNum=pDevInfo->cardID;
|
|
|
-
|
|
|
- _dxgsg->scrn.MaxAvailVidMem = UNKNOWN_VIDMEM_SIZE;
|
|
|
- _dxgsg->scrn.bIsLowVidMemCard = false;
|
|
|
-
|
|
|
- // bugbug: wouldnt we like to do GetAVailVidMem so we can do upper-limit memory computation for dx8 cards too?
|
|
|
- // otherwise verify_window_sizes cant do much
|
|
|
- if((d3dcaps.MaxStreams==0)|| dx_pick_best_screenres) {
|
|
|
- if(wdxdisplay_cat.is_debug())
|
|
|
- wdxdisplay_cat.debug() << "checking vidmem size\n";
|
|
|
- assert(IS_VALID_PTR(_pParentWindowGroup));
|
|
|
-
|
|
|
- // look for low memory video cards
|
|
|
- _pParentWindowGroup->find_all_card_memavails();
|
|
|
-
|
|
|
- UINT IDnum;
|
|
|
-
|
|
|
- // simple linear search to match DX7 card info w/DX8 card ID
|
|
|
- for(IDnum=0;IDnum<g_pCardIDVec->size();IDnum++) {
|
|
|
-// wdxdisplay_cat.info() << "comparing '" << (*g_pCardIDVec)[IDnum].Driver << "' to '" << _dxgsg->scrn.DXDeviceID.Driver << "'\n";
|
|
|
- if(//(stricmp((*g_pCardIDVec)[IDnum].szDriver,pDevInfo->szDriver)==0) &&
|
|
|
- (pDevInfo->VendorID==(*g_pCardIDVec)[IDnum].VendorID) &&
|
|
|
- (pDevInfo->DeviceID==(*g_pCardIDVec)[IDnum].DeviceID) &&
|
|
|
- (pDevInfo->hMon==(*g_pCardIDVec)[IDnum].hMon))
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- if(IDnum<g_pCardIDVec->size()) {
|
|
|
- _dxgsg->scrn.MaxAvailVidMem = (*g_pCardIDVec)[IDnum].MaxAvailVidMem;
|
|
|
- _dxgsg->scrn.bIsLowVidMemCard = (*g_pCardIDVec)[IDnum].bIsLowVidMemCard;
|
|
|
- } else wdxdisplay_cat.error() << "Error: couldnt find a CardID match in DX7 info, assuming card is not a lowmem card\n";
|
|
|
- }
|
|
|
-
|
|
|
- if((bWantStencil) && (d3dcaps.StencilCaps==0x0)) {
|
|
|
- wdxdisplay_cat.fatal() << "Stencil ability requested, but device #" << pDevInfo->cardID << " (" << _dxgsg->scrn.DXDeviceID.Description<<"), has no stencil capability!\n";
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- // just because TNL is true, it doesnt mean vtx shaders are supported in HW (see GF2)
|
|
|
- // for this case, you probably want MIXED processing to use HW for fixed-fn vertex processing
|
|
|
- // and SW for vtx shaders
|
|
|
- _dxgsg->scrn.bIsTNLDevice=((d3dcaps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT)!=0);
|
|
|
- _dxgsg->scrn.bCanUseHWVertexShaders = (d3dcaps.VertexShaderVersion >= D3DVS_VERSION(1,0));
|
|
|
- _dxgsg->scrn.bCanUsePixelShaders = (d3dcaps.PixelShaderVersion >= D3DPS_VERSION(1,0));
|
|
|
-
|
|
|
- bool bNeedZBuffer = ((!(d3dcaps.RasterCaps & D3DPRASTERCAPS_ZBUFFERLESSHSR ))
|
|
|
- && (_props._mask & W_DEPTH));
|
|
|
-
|
|
|
- _dxgsg->scrn.PresParams.EnableAutoDepthStencil=bNeedZBuffer;
|
|
|
-
|
|
|
- D3DFORMAT pixFmt=D3DFMT_UNKNOWN;
|
|
|
-
|
|
|
- if(_props._fullscreen) {
|
|
|
- _props._xorg = _props._yorg = 0;
|
|
|
-
|
|
|
- bool bCouldntFindValidZBuf;
|
|
|
- if(!_dxgsg->scrn.bIsLowVidMemCard) {
|
|
|
- bool bUseDefaultSize=dx_pick_best_screenres&&
|
|
|
- ((_dxgsg->scrn.MaxAvailVidMem == UNKNOWN_VIDMEM_SIZE) ||
|
|
|
- is_badvidmem_card(&_dxgsg->scrn.DXDeviceID));
|
|
|
-
|
|
|
- if(dx_pick_best_screenres && !bUseDefaultSize) {
|
|
|
- typedef struct {
|
|
|
- UINT memlimit;
|
|
|
- DWORD scrnX,scrnY;
|
|
|
- } Memlimres;
|
|
|
-
|
|
|
- const Memlimres MemRes[] = {
|
|
|
- { 0, 640, 480},
|
|
|
- { 8000000, 800, 600},
|
|
|
- #if 0
|
|
|
- {16000000, 1024, 768},
|
|
|
- {32000000, 1280,1024}, // 32MB+ cards will choose this
|
|
|
- #else
|
|
|
- // unfortunately the 32MB card perf varies greatly (TNT2-GF2),
|
|
|
- // so we need to be conservative since frame rate difference
|
|
|
- // can change from 15->30fps when going from 1280x1024->800x600
|
|
|
- // on low-end 32mb cards
|
|
|
- {16000000, 800, 600},
|
|
|
- {32000000, 800, 600}, // 32MB+ cards will choose this
|
|
|
- #endif
|
|
|
- // some monitors have trouble w/1600x1200, so dont pick this by deflt,
|
|
|
- // even though 64MB cards should handle it
|
|
|
- {64000000, 1280,1024} // 64MB+ cards will choose this
|
|
|
- };
|
|
|
- const NumResLims = (sizeof(MemRes)/sizeof(Memlimres));
|
|
|
-
|
|
|
- for(int i=NumResLims-1;i>=0;i--) {
|
|
|
- // find biggest slot card can handle
|
|
|
- if(_dxgsg->scrn.MaxAvailVidMem > MemRes[i].memlimit) {
|
|
|
- dwRenderWidth=MemRes[i].scrnX;
|
|
|
- dwRenderHeight=MemRes[i].scrnY;
|
|
|
-
|
|
|
- wdxdisplay_cat.info() << "pick_best_screenres: trying " << dwRenderWidth << "x" << dwRenderHeight << " based on " << _dxgsg->scrn.MaxAvailVidMem << " bytes avail\n";
|
|
|
-
|
|
|
- search_for_valid_displaymode(dwRenderWidth,dwRenderHeight,bNeedZBuffer,bWantStencil,
|
|
|
- &_dxgsg->scrn.SupportedScreenDepthsMask,
|
|
|
- &bCouldntFindValidZBuf,
|
|
|
- &pixFmt);
|
|
|
-
|
|
|
- // note I'm not saving refresh rate, will just use adapter default at given res for now
|
|
|
-
|
|
|
- if(pixFmt!=D3DFMT_UNKNOWN)
|
|
|
- break;
|
|
|
-
|
|
|
- wdxdisplay_cat.info() << "skipping scrnres; "
|
|
|
- << (bCouldntFindValidZBuf ? "Couldnt find valid zbuffer format to go with FullScreen mode" : "No supported FullScreen modes")
|
|
|
- << " at " << dwRenderWidth << "x" << dwRenderHeight << " for device #" << _dxgsg->scrn.CardIDNum << endl;
|
|
|
- }
|
|
|
- }
|
|
|
- // otherwise just go with whatever was specified (we probably shouldve marked this card as lowmem if it gets to end of loop w/o breaking
|
|
|
- }
|
|
|
-
|
|
|
- if(pixFmt==D3DFMT_UNKNOWN) {
|
|
|
-
|
|
|
- if(bUseDefaultSize) {
|
|
|
- wdxdisplay_cat.info() << "pick_best_screenres: defaulted 800x600 based on no reliable vidmem size\n";
|
|
|
- dwRenderWidth=800; dwRenderHeight=600;
|
|
|
- }
|
|
|
-
|
|
|
- search_for_valid_displaymode(dwRenderWidth,dwRenderHeight,bNeedZBuffer,bWantStencil,
|
|
|
- &_dxgsg->scrn.SupportedScreenDepthsMask,
|
|
|
- &bCouldntFindValidZBuf,
|
|
|
- &pixFmt);
|
|
|
-
|
|
|
- // note I'm not saving refresh rate, will just use adapter default at given res for now
|
|
|
-
|
|
|
- if(pixFmt==D3DFMT_UNKNOWN) {
|
|
|
- wdxdisplay_cat.fatal()
|
|
|
- << (bCouldntFindValidZBuf ? "Couldnt find valid zbuffer format to go with FullScreen mode" : "No supported FullScreen modes")
|
|
|
- << " at " << dwRenderWidth << "x" << dwRenderHeight << " for device #" << _dxgsg->scrn.CardIDNum <<endl;
|
|
|
-
|
|
|
- // run it again in verbose mode to get more dbg info to log
|
|
|
- search_for_valid_displaymode(dwRenderWidth,dwRenderHeight,bNeedZBuffer,bWantStencil,
|
|
|
- &_dxgsg->scrn.SupportedScreenDepthsMask,
|
|
|
- &bCouldntFindValidZBuf,
|
|
|
- &pixFmt,true);
|
|
|
- return false;
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- // Low Memory card
|
|
|
- dwRenderWidth=640;
|
|
|
- dwRenderHeight=480;
|
|
|
- dx_force_16bpptextures = true;
|
|
|
-
|
|
|
- // force 16bpp zbuf? or let user get extra bits if they have the mem?
|
|
|
-
|
|
|
- search_for_valid_displaymode(dwRenderWidth,dwRenderHeight,bNeedZBuffer,bWantStencil,
|
|
|
- &_dxgsg->scrn.SupportedScreenDepthsMask,
|
|
|
- &bCouldntFindValidZBuf,
|
|
|
- &pixFmt);
|
|
|
-
|
|
|
- // hack: figuring out exactly what res to use is tricky, instead I will
|
|
|
- // just use 640x480 if we have < 3 meg avail
|
|
|
-
|
|
|
- if(_dxgsg->scrn.SupportedScreenDepthsMask & R5G6B5_FLAG)
|
|
|
- pixFmt = D3DFMT_R5G6B5;
|
|
|
- else if(_dxgsg->scrn.SupportedScreenDepthsMask & X1R5G5B5_FLAG)
|
|
|
- pixFmt = D3DFMT_X1R5G5B5;
|
|
|
- else {
|
|
|
- wdxdisplay_cat.fatal() << "Low Memory VidCard has no supported FullScreen 16bpp resolutions at "<< dwRenderWidth << "x" << dwRenderHeight
|
|
|
- << " for device #" << pDevInfo->cardID << " (" << _dxgsg->scrn.DXDeviceID.Description <<"), skipping device...\n";
|
|
|
-
|
|
|
- // run it again in verbose mode to get more dbg info to log
|
|
|
- search_for_valid_displaymode(dwRenderWidth,dwRenderHeight,bNeedZBuffer,bWantStencil,
|
|
|
- &_dxgsg->scrn.SupportedScreenDepthsMask,
|
|
|
- &bCouldntFindValidZBuf,
|
|
|
- &pixFmt,true);
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- if(wdxdisplay_cat.is_info())
|
|
|
- wdxdisplay_cat.info() << "Available VidMem (" << _dxgsg->scrn.MaxAvailVidMem << ") is under " << LOWVIDMEMTHRESHOLD <<", using 640x480 16bpp rendertargets to save tex vidmem.\n";
|
|
|
- }
|
|
|
- } else {
|
|
|
- // Windowed Mode
|
|
|
-
|
|
|
- D3DDISPLAYMODE dispmode;
|
|
|
- hr=pD3D8->GetAdapterDisplayMode(pDevInfo->cardID,&dispmode);
|
|
|
- if(FAILED(hr)) {
|
|
|
- wdxdisplay_cat.fatal() << "GetAdapterDisplayMode(" << pDevInfo->cardID << ") failed" << D3DERRORSTRING(hr);
|
|
|
- exit(1);
|
|
|
- }
|
|
|
- pixFmt = dispmode.Format;
|
|
|
- }
|
|
|
-
|
|
|
- _dxgsg->scrn.DisplayMode.Width=dwRenderWidth;
|
|
|
- _dxgsg->scrn.DisplayMode.Height=dwRenderHeight;
|
|
|
- _dxgsg->scrn.DisplayMode.Format = pixFmt;
|
|
|
- _dxgsg->scrn.DisplayMode.RefreshRate = D3DPRESENT_RATE_DEFAULT;
|
|
|
- _dxgsg->scrn.hMon=pDevInfo->hMon;
|
|
|
- return true;
|
|
|
-}
|
|
|
-
|
|
|
-//return true if successful
|
|
|
-void wdxGraphicsWindow::
|
|
|
-CreateScreenBuffersAndDevice(DXScreenData &Display) {
|
|
|
-
|
|
|
- // only want this to apply to initial startup
|
|
|
- dx_pick_best_screenres=false;
|
|
|
-
|
|
|
- DWORD dwRenderWidth=Display.DisplayMode.Width;
|
|
|
- DWORD dwRenderHeight=Display.DisplayMode.Height;
|
|
|
- LPDIRECT3D8 pD3D8=Display.pD3D8;
|
|
|
- D3DCAPS8 *pD3DCaps = &Display.d3dcaps;
|
|
|
- D3DPRESENT_PARAMETERS* pPresParams = &Display.PresParams;
|
|
|
- RECT view_rect;
|
|
|
- HRESULT hr;
|
|
|
- bool bWantStencil = ((_props._mask & W_STENCIL)!=0);
|
|
|
-
|
|
|
- assert(pD3D8!=NULL);
|
|
|
- assert(pD3DCaps->DevCaps & D3DDEVCAPS_HWRASTERIZATION);
|
|
|
-
|
|
|
- #ifndef NDEBUG
|
|
|
- if(!(_props._mask & W_DEPTH)) {
|
|
|
- wdxdisplay_cat.info() << "no zbuffer requested, skipping zbuffer creation\n";
|
|
|
- }
|
|
|
- #endif
|
|
|
-
|
|
|
- pPresParams->BackBufferFormat = Display.DisplayMode.Format; // dont need dest alpha, so just use adapter format
|
|
|
-
|
|
|
- if(dx_sync_video && !(pD3DCaps->Caps & D3DCAPS_READ_SCANLINE)) {
|
|
|
- wdxdisplay_cat.info() << "HW doesnt support syncing to vertical refresh, ignoring dx_sync_video\n";
|
|
|
- dx_sync_video=false;
|
|
|
- }
|
|
|
-
|
|
|
- // verify the rendertarget fmt one last time
|
|
|
- if(FAILED(pD3D8->CheckDeviceFormat(Display.CardIDNum, D3DDEVTYPE_HAL, Display.DisplayMode.Format,D3DUSAGE_RENDERTARGET,
|
|
|
- D3DRTYPE_SURFACE, pPresParams->BackBufferFormat))) {
|
|
|
- wdxdisplay_cat.error() << "device #"<<Display.CardIDNum<< " CheckDeviceFmt failed for surface fmt "<< D3DFormatStr(pPresParams->BackBufferFormat) << endl;
|
|
|
- goto Fallback_to_16bpp_buffers;
|
|
|
- }
|
|
|
-
|
|
|
- if(FAILED(pD3D8->CheckDeviceType(Display.CardIDNum,D3DDEVTYPE_HAL, Display.DisplayMode.Format,pPresParams->BackBufferFormat,
|
|
|
- _props._fullscreen))) {
|
|
|
- wdxdisplay_cat.error() << "device #"<<Display.CardIDNum<< " CheckDeviceType failed for surface fmt "<< D3DFormatStr(pPresParams->BackBufferFormat) << endl;
|
|
|
- goto Fallback_to_16bpp_buffers;
|
|
|
- }
|
|
|
-
|
|
|
- if(Display.PresParams.EnableAutoDepthStencil) {
|
|
|
- if(!FindBestDepthFormat(Display,Display.DisplayMode,&Display.PresParams.AutoDepthStencilFormat,bWantStencil,false)) {
|
|
|
- wdxdisplay_cat.error() << "FindBestDepthFormat failed in CreateScreenBuffers for device #"<<Display.CardIDNum<< endl;
|
|
|
- goto Fallback_to_16bpp_buffers;
|
|
|
- }
|
|
|
- _depth_buffer_bpp=D3DFMT_to_DepthBits(Display.PresParams.AutoDepthStencilFormat);
|
|
|
- } else {
|
|
|
- _depth_buffer_bpp=0;
|
|
|
- }
|
|
|
-
|
|
|
- pPresParams->Windowed = !_props._fullscreen;
|
|
|
-
|
|
|
- if(dx_multisample_antialiasing_level>1) {
|
|
|
- // need to check both rendertarget and zbuffer fmts
|
|
|
- hr = pD3D8->CheckDeviceMultiSampleType(Display.CardIDNum, D3DDEVTYPE_HAL, Display.DisplayMode.Format,
|
|
|
- _props._fullscreen, D3DMULTISAMPLE_TYPE(dx_multisample_antialiasing_level));
|
|
|
- if(FAILED(hr)) {
|
|
|
- wdxdisplay_cat.fatal() << "device #"<<Display.CardIDNum<< " doesnt support multisample level "<<dx_multisample_antialiasing_level <<"surface fmt "<< D3DFormatStr(Display.DisplayMode.Format) <<endl;
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- if(Display.PresParams.EnableAutoDepthStencil) {
|
|
|
- hr = pD3D8->CheckDeviceMultiSampleType(Display.CardIDNum, D3DDEVTYPE_HAL, Display.PresParams.AutoDepthStencilFormat,
|
|
|
- _props._fullscreen, D3DMULTISAMPLE_TYPE(dx_multisample_antialiasing_level));
|
|
|
- if(FAILED(hr)) {
|
|
|
- wdxdisplay_cat.fatal() << "device #"<<Display.CardIDNum<< " doesnt support multisample level "<<dx_multisample_antialiasing_level <<"surface fmt "<< D3DFormatStr(Display.PresParams.AutoDepthStencilFormat) <<endl;
|
|
|
- exit(1);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- pPresParams->MultiSampleType = D3DMULTISAMPLE_TYPE(dx_multisample_antialiasing_level);
|
|
|
-
|
|
|
- if(wdxdisplay_cat.is_info())
|
|
|
- wdxdisplay_cat.info() << "device #"<<Display.CardIDNum<< " using multisample antialiasing level "<<dx_multisample_antialiasing_level <<endl;
|
|
|
- }
|
|
|
-
|
|
|
- pPresParams->BackBufferCount = 1;
|
|
|
- pPresParams->Flags = 0x0;
|
|
|
- pPresParams->hDeviceWindow = Display.hWnd;
|
|
|
- pPresParams->BackBufferWidth = Display.DisplayMode.Width;
|
|
|
- pPresParams->BackBufferHeight = Display.DisplayMode.Height;
|
|
|
- DWORD dwBehaviorFlags=0x0;
|
|
|
-
|
|
|
- if(_dxgsg->scrn.bIsTNLDevice) {
|
|
|
- dwBehaviorFlags|=D3DCREATE_HARDWARE_VERTEXPROCESSING;
|
|
|
- // note: we could create a pure device in this case if I eliminated the GetRenderState calls in dxgsg
|
|
|
-
|
|
|
- // also, no software vertex processing available since I specify D3DCREATE_HARDWARE_VERTEXPROCESSING
|
|
|
- // and not D3DCREATE_MIXED_VERTEXPROCESSING
|
|
|
- } else {
|
|
|
- dwBehaviorFlags|=D3DCREATE_SOFTWARE_VERTEXPROCESSING;
|
|
|
- }
|
|
|
-
|
|
|
- if(dx_preserve_fpu_state)
|
|
|
- dwBehaviorFlags|=D3DCREATE_FPU_PRESERVE;
|
|
|
-
|
|
|
- // if window is not foreground in exclusive mode, ddraw thinks you are 'not active', so
|
|
|
- // it changes your WM_ACTIVATEAPP from true to false, causing us
|
|
|
- // to go into a 'wait-for WM_ACTIVATEAPP true' loop, and the event never comes so we hang
|
|
|
- // in fullscreen wait. also doing this for windowed mode since it was requested.
|
|
|
- if(!SetForegroundWindow(Display.hWnd)) {
|
|
|
- wdxdisplay_cat.warning() << "SetForegroundWindow() failed!\n";
|
|
|
- }
|
|
|
-
|
|
|
- if(_props._fullscreen) {
|
|
|
- pPresParams->SwapEffect = D3DSWAPEFFECT_DISCARD; // we dont care about preserving contents of old frame
|
|
|
- pPresParams->FullScreen_PresentationInterval = (dx_sync_video ? D3DPRESENT_INTERVAL_ONE : D3DPRESENT_INTERVAL_IMMEDIATE);
|
|
|
- pPresParams->FullScreen_RefreshRateInHz = Display.DisplayMode.RefreshRate;
|
|
|
-
|
|
|
-#if 0
|
|
|
-/* this is incorrect, we dont need rendertarget to hold alpha to do normal alpha blending, since blending is usually just
|
|
|
- based on source alpha. so for now its OK to pick rendertargets with same format as display
|
|
|
-
|
|
|
- // assume app requires alpha-blending
|
|
|
- // will fullscrn alphablend work with DISCARD anyway even if this cap is not set? I dont see it being set by latest drivers
|
|
|
- // for any card. need to test both dx8.0 and dx8.1, it may be that dx8.1 works even if cap is not set, but 8.0 doesnt
|
|
|
- if((!Display.bIsDX81) || (!(d3dcaps.Caps3 & D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD))) {
|
|
|
- pPresParams->SwapEffect = (dx_sync_video ? D3DSWAPEFFECT_COPY_VSYNC : D3DSWAPEFFECT_COPY);
|
|
|
-
|
|
|
- if(pPresParams->MultiSampleType != D3DMULTISAMPLE_NONE) {
|
|
|
- wdxdisplay_cat.fatal() << "device #"<<Display.CardIDNum<< " cant support multisample antialiasing and fullscrn alphablending because of driver limitations and/or lack of DX8.1"<<dx_multisample_antialiasing_level <<endl;
|
|
|
- exit(1);
|
|
|
- }
|
|
|
- }
|
|
|
-*/
|
|
|
-#endif
|
|
|
- #ifdef _DEBUG
|
|
|
- if(pPresParams->MultiSampleType != D3DMULTISAMPLE_NONE)
|
|
|
- assert(pPresParams->SwapEffect == D3DSWAPEFFECT_DISCARD); // only valid effect for multisample
|
|
|
- #endif
|
|
|
-
|
|
|
- ClearToBlack(Display.hWnd,_props);
|
|
|
-
|
|
|
- hr = pD3D8->CreateDevice(Display.CardIDNum, D3DDEVTYPE_HAL, _pParentWindowGroup->_hParentWindow,
|
|
|
- dwBehaviorFlags, pPresParams, &Display.pD3DDevice);
|
|
|
-
|
|
|
- if(FAILED(hr)) {
|
|
|
- wdxdisplay_cat.fatal() << "D3D CreateDevice failed for device #" << Display.CardIDNum << ", " << D3DERRORSTRING(hr);
|
|
|
-
|
|
|
- if(hr == D3DERR_OUTOFVIDEOMEMORY)
|
|
|
- goto Fallback_to_16bpp_buffers;
|
|
|
- }
|
|
|
-
|
|
|
- SetRect(&view_rect, 0, 0, dwRenderWidth, dwRenderHeight);
|
|
|
- } // end create full screen buffers
|
|
|
-
|
|
|
- else { // CREATE WINDOWED BUFFERS
|
|
|
-
|
|
|
- if(!(pD3DCaps->Caps2 & D3DCAPS2_CANRENDERWINDOWED)) {
|
|
|
- wdxdisplay_cat.fatal() << "the 3D HW cannot render windowed, exiting..." << endl;
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- D3DDISPLAYMODE dispmode;
|
|
|
- hr = Display.pD3D8->GetAdapterDisplayMode(Display.CardIDNum, &dispmode);
|
|
|
-
|
|
|
- if(FAILED(hr)) {
|
|
|
- wdxdisplay_cat.fatal() << "GetAdapterDisplayMode failed" << D3DERRORSTRING(hr);
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- if(dispmode.Format == D3DFMT_P8) {
|
|
|
- wdxdisplay_cat.fatal() << "Can't run windowed in an 8-bit or less display mode" << endl;
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- pPresParams->FullScreen_PresentationInterval = 0;
|
|
|
-
|
|
|
- if(dx_multisample_antialiasing_level<2) {
|
|
|
- if(dx_sync_video) {
|
|
|
- pPresParams->SwapEffect = D3DSWAPEFFECT_COPY_VSYNC;
|
|
|
- } else {
|
|
|
- pPresParams->SwapEffect = D3DSWAPEFFECT_DISCARD; //D3DSWAPEFFECT_COPY; does this make any difference?
|
|
|
- }
|
|
|
- } else {
|
|
|
- pPresParams->SwapEffect = D3DSWAPEFFECT_DISCARD;
|
|
|
- }
|
|
|
-
|
|
|
- assert((dwRenderWidth==pPresParams->BackBufferWidth)&&(dwRenderHeight==pPresParams->BackBufferHeight));
|
|
|
-
|
|
|
- hr = pD3D8->CreateDevice(Display.CardIDNum, D3DDEVTYPE_HAL, _pParentWindowGroup->_hParentWindow,
|
|
|
- dwBehaviorFlags, pPresParams, &Display.pD3DDevice);
|
|
|
-
|
|
|
- if(FAILED(hr)) {
|
|
|
- wdxdisplay_cat.fatal() << "D3D CreateDevice failed for device #" << Display.CardIDNum << D3DERRORSTRING(hr);
|
|
|
- exit(1);
|
|
|
- }
|
|
|
- } // end create windowed buffers
|
|
|
-
|
|
|
-// ========================================================
|
|
|
-
|
|
|
- PRINT_REFCNT(wdxdisplay,_dxgsg->scrn.pD3DDevice);
|
|
|
-
|
|
|
- if(pPresParams->EnableAutoDepthStencil) {
|
|
|
- _dxgsg->_buffer_mask |= RenderBuffer::T_depth;
|
|
|
- if(IS_STENCIL_FORMAT(pPresParams->AutoDepthStencilFormat))
|
|
|
- _dxgsg->_buffer_mask |= RenderBuffer::T_stencil;
|
|
|
- }
|
|
|
-
|
|
|
- init_resized_window();
|
|
|
-
|
|
|
- return;
|
|
|
-
|
|
|
-Fallback_to_16bpp_buffers:
|
|
|
-
|
|
|
- if((!IS_16BPP_DISPLAY_FORMAT(pPresParams->BackBufferFormat)) &&
|
|
|
- (Display.SupportedScreenDepthsMask & (R5G6B5_FLAG|X1R5G5B5_FLAG))) {
|
|
|
- // fallback strategy, if we trying >16bpp, fallback to 16bpp buffers
|
|
|
-
|
|
|
- Display.DisplayMode.Format = ((Display.SupportedScreenDepthsMask & R5G6B5_FLAG) ? D3DFMT_R5G6B5 : D3DFMT_X1R5G5B5);
|
|
|
-
|
|
|
- dx_force_16bpp_zbuffer=true;
|
|
|
- if(wdxdisplay_cat.info())
|
|
|
- wdxdisplay_cat.info() << "CreateDevice failed with out-of-vidmem, retrying w/16bpp buffers on device #"<< Display.CardIDNum << endl;
|
|
|
- CreateScreenBuffersAndDevice(Display);
|
|
|
- return;
|
|
|
- } else if(!((dwRenderWidth==640)&&(dwRenderHeight==480))) {
|
|
|
- if(wdxdisplay_cat.info())
|
|
|
- wdxdisplay_cat.info() << "CreateDevice failed w/out-of-vidmem, retrying at 640x480 w/16bpp buffers on device #"<< Display.CardIDNum << endl;
|
|
|
- // try final fallback to 640x480x16
|
|
|
- dx_force_16bpp_zbuffer=true;
|
|
|
- Display.DisplayMode.Width=640;
|
|
|
- Display.DisplayMode.Height=480;
|
|
|
- CreateScreenBuffersAndDevice(Display);
|
|
|
- return;
|
|
|
- } else {
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-// assumes CreateDevice or Device->Reset() has just been called,
|
|
|
-// and the new size is specified in _dxgsg->scrn.PresParams
|
|
|
-void wdxGraphicsWindow::init_resized_window(void) {
|
|
|
- DXScreenData *pDisplay=&_dxgsg->scrn;
|
|
|
- HRESULT hr;
|
|
|
-
|
|
|
- DWORD newWidth = pDisplay->PresParams.BackBufferWidth;
|
|
|
- DWORD newHeight = pDisplay->PresParams.BackBufferHeight;
|
|
|
-
|
|
|
- if(pDisplay->PresParams.Windowed) {
|
|
|
- POINT ul,lr;
|
|
|
- RECT client_rect;
|
|
|
-
|
|
|
- // need to figure out x,y origin offset of window client area on screen
|
|
|
- // (we already know the client area size)
|
|
|
-
|
|
|
- GetClientRect(pDisplay->hWnd, &client_rect);
|
|
|
- ul.x=client_rect.left; ul.y=client_rect.top;
|
|
|
- lr.x=client_rect.right; lr.y=client_rect.bottom;
|
|
|
- ClientToScreen(pDisplay->hWnd, &ul);
|
|
|
- ClientToScreen(pDisplay->hWnd, &lr);
|
|
|
- client_rect.left=ul.x; client_rect.top=ul.y;
|
|
|
- client_rect.right=lr.x; client_rect.bottom=lr.y;
|
|
|
- _props._xorg = client_rect.left; // _props should reflect view rectangle
|
|
|
- _props._yorg = client_rect.top;
|
|
|
-
|
|
|
- #ifdef _DEBUG
|
|
|
- // try to make sure GDI and DX agree on window client area size
|
|
|
- // but client rect will not include any offscreen areas, so dont
|
|
|
- // do check if window was bigger than screen (there are other bad
|
|
|
- // cases too, like when window is positioned partly offscreen,
|
|
|
- // or if window trim border make size bigger than screen)
|
|
|
-
|
|
|
- RECT desktop_rect;
|
|
|
- GetClientRect(GetDesktopWindow(), &desktop_rect);
|
|
|
- if((_props._xsize<RECT_XSIZE(desktop_rect)) && (_props._ysize<RECT_YSIZE(desktop_rect)))
|
|
|
- assert((RECT_XSIZE(client_rect)==newWidth)&&(RECT_YSIZE(client_rect)==newHeight));
|
|
|
- #endif
|
|
|
- }
|
|
|
-
|
|
|
- resized(newWidth,newHeight); // update panda channel/display rgn info, _props.xsize, _props.ysize
|
|
|
-
|
|
|
- // clear window to black ASAP
|
|
|
- ClearToBlack(pDisplay->hWnd,_props);
|
|
|
-
|
|
|
- // clear textures and VB's out of video&AGP mem, so cache is reset
|
|
|
- hr = pDisplay->pD3DDevice->ResourceManagerDiscardBytes(0);
|
|
|
- if(FAILED(hr)) {
|
|
|
- wdxdisplay_cat.error() << "ResourceManagerDiscardBytes failed for device #" << pDisplay->CardIDNum << D3DERRORSTRING(hr);
|
|
|
- }
|
|
|
-
|
|
|
- // Create the viewport
|
|
|
- D3DVIEWPORT8 vp = {0,0,_props._xsize,_props._ysize,0.0f,1.0f};
|
|
|
- hr = pDisplay->pD3DDevice->SetViewport( &vp );
|
|
|
- if(FAILED(hr)) {
|
|
|
- wdxdisplay_cat.fatal() << "SetViewport failed for device #" << pDisplay->CardIDNum << D3DERRORSTRING(hr);
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- _dxgsg->dx_init(_pParentWindowGroup->_hMouseCursor);
|
|
|
- // do not SetDXReady() yet since caller may want to do more work before letting rendering proceed
|
|
|
-
|
|
|
- SetCursor(_pParentWindowGroup->_hMouseCursor);
|
|
|
- set_cursor_visibility(true);
|
|
|
-}
|
|
|
-
|
|
|
-// does NOT override _props._bCursorIsVisible
|
|
|
-INLINE void wdxGraphicsWindow::set_cursor_visibility(bool bVisible) {
|
|
|
- bool bValidDXPtrs;
|
|
|
-
|
|
|
- if(_use_dx8_cursor)
|
|
|
- bValidDXPtrs = (IS_VALID_PTR(_dxgsg) && IS_VALID_PTR(_dxgsg->scrn.pD3DDevice));
|
|
|
-
|
|
|
- if(_props._bCursorIsVisible) {
|
|
|
- if(_use_dx8_cursor) {
|
|
|
- ShowCursor(false);
|
|
|
- if(bValidDXPtrs)
|
|
|
- _dxgsg->scrn.pD3DDevice->ShowCursor(bVisible);
|
|
|
- } else {
|
|
|
- ShowCursor(bVisible);
|
|
|
- }
|
|
|
- } else {
|
|
|
- ShowCursor(false);
|
|
|
- if(_use_dx8_cursor && bValidDXPtrs)
|
|
|
- _dxgsg->scrn.pD3DDevice->ShowCursor(false);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: setup_colormap
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-void wdxGraphicsWindow::setup_colormap(void) {
|
|
|
- PIXELFORMATDESCRIPTOR pfd;
|
|
|
- LOGPALETTE *logical;
|
|
|
- int n;
|
|
|
-
|
|
|
- // should probably do this some other way than through opengl PixelFormat calls
|
|
|
-
|
|
|
- /* grab the pixel format */
|
|
|
- memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
|
|
|
- DescribePixelFormat(_hdc, GetPixelFormat(_hdc),
|
|
|
- sizeof(PIXELFORMATDESCRIPTOR), &pfd);
|
|
|
-
|
|
|
- if(!(pfd.dwFlags & PFD_NEED_PALETTE ||
|
|
|
- pfd.iPixelType == PFD_TYPE_COLORINDEX))
|
|
|
- return;
|
|
|
-
|
|
|
- n = 1 << pfd.cColorBits;
|
|
|
-
|
|
|
- /* allocate a bunch of memory for the logical palette (assume 256
|
|
|
- colors in a Win32 palette */
|
|
|
- logical = (LOGPALETTE*)malloc(sizeof(LOGPALETTE) +
|
|
|
- sizeof(PALETTEENTRY) * n);
|
|
|
- memset(logical, 0, sizeof(LOGPALETTE) + sizeof(PALETTEENTRY) * n);
|
|
|
-
|
|
|
- /* set the entries in the logical palette */
|
|
|
- logical->palVersion = 0x300;
|
|
|
- logical->palNumEntries = n;
|
|
|
-
|
|
|
- /* start with a copy of the current system palette */
|
|
|
- GetSystemPaletteEntries(_hdc, 0, 256, &logical->palPalEntry[0]);
|
|
|
-
|
|
|
- if(pfd.iPixelType == PFD_TYPE_RGBA) {
|
|
|
- int redMask = (1 << pfd.cRedBits) - 1;
|
|
|
- int greenMask = (1 << pfd.cGreenBits) - 1;
|
|
|
- int blueMask = (1 << pfd.cBlueBits) - 1;
|
|
|
- int i;
|
|
|
-
|
|
|
- /* fill in an RGBA color palette */
|
|
|
- for(i = 0; i < n; ++i) {
|
|
|
- logical->palPalEntry[i].peRed =
|
|
|
- (((i >> pfd.cRedShift) & redMask) * 255) / redMask;
|
|
|
- logical->palPalEntry[i].peGreen =
|
|
|
- (((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask;
|
|
|
- logical->palPalEntry[i].peBlue =
|
|
|
- (((i >> pfd.cBlueShift) & blueMask) * 255) / blueMask;
|
|
|
- logical->palPalEntry[i].peFlags = 0;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- _colormap = CreatePalette(logical);
|
|
|
- free(logical);
|
|
|
-
|
|
|
- SelectPalette(_hdc, _colormap, FALSE);
|
|
|
- RealizePalette(_hdc);
|
|
|
-}
|
|
|
-
|
|
|
-/* dont need to override the defaults (which just go to gsg->begin_frame())
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: begin_frame
|
|
|
-// Access:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-void wdxGraphicsWindow::begin_frame(void) {
|
|
|
- GraphicsWindow::begin_frame();
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: end_frame
|
|
|
-// Access:
|
|
|
-// Description: timer info, incs frame #
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-void wdxGraphicsWindow::end_frame(void) {
|
|
|
- GraphicsWindow::end_frame();
|
|
|
-}
|
|
|
-*/
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: handle_window_move
|
|
|
-// Access:
|
|
|
-// Description: we receive the new x and y position of the client
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-void wdxGraphicsWindow::handle_window_move(int x, int y) {
|
|
|
- _props._xorg = x;
|
|
|
- _props._yorg = y;
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: handle_mouse_motion
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-void wdxGraphicsWindow::handle_mouse_motion(int x, int y) {
|
|
|
- _input_devices[0].set_pointer_in_window(x, y);
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: handle_mouse_exit
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-void wdxGraphicsWindow::handle_mouse_exit(void) {
|
|
|
- _input_devices[0].set_pointer_out_of_window();
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: handle_keypress
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-void wdxGraphicsWindow::
|
|
|
-handle_keypress(ButtonHandle key, int x, int y) {
|
|
|
-/*
|
|
|
- if(key.has_ascii_equivalent()) {
|
|
|
- wdxdisplay_cat.spam() << key.get_ascii_equivalent() << endl;
|
|
|
-
|
|
|
- short d1 = GetKeyState(VK_CONTROL);
|
|
|
- short d2 = GetKeyState(VK_SHIFT);
|
|
|
- wdxdisplay_cat.spam().flags(ios::hex | ios::uppercase );
|
|
|
- wdxdisplay_cat.spam() << " Control: " << ((d1 < 0)? "down" : "up") << " Shift: " << ((d2 < 0)? "down" : "up") << endl;
|
|
|
- }
|
|
|
-*/
|
|
|
- _input_devices[0].set_pointer_in_window(x, y);
|
|
|
- if(key != ButtonHandle::none()) {
|
|
|
- _input_devices[0].button_down(key);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: handle_keyrelease
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-void wdxGraphicsWindow::
|
|
|
-handle_keyrelease(ButtonHandle key) {
|
|
|
- if(key != ButtonHandle::none()) {
|
|
|
- _input_devices[0].button_up(key);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void INLINE process_1_event(void) {
|
|
|
- MSG msg;
|
|
|
-
|
|
|
- if(!GetMessage(&msg, NULL, 0, 0)) {
|
|
|
- // WM_QUIT received
|
|
|
- DestroyAllWindows(false);
|
|
|
- exit(msg.wParam); // this will invoke AtExitFn
|
|
|
- }
|
|
|
-
|
|
|
- // Translate virtual key messages
|
|
|
- TranslateMessage(&msg);
|
|
|
- // Call window_proc
|
|
|
- DispatchMessage(&msg);
|
|
|
-}
|
|
|
-
|
|
|
-void INLINE wdxGraphicsWindow::process_events(void) {
|
|
|
- if(!_window_active) {
|
|
|
- // Get 1 msg at a time until no more are left and we block and sleep,
|
|
|
- // or message changes _return_control_to_app or _window_active status
|
|
|
-
|
|
|
- while((!_window_active) && (!_return_control_to_app)) {
|
|
|
- process_1_event();
|
|
|
- }
|
|
|
- _return_control_to_app = false;
|
|
|
-
|
|
|
- } else {
|
|
|
- MSG msg;
|
|
|
-
|
|
|
- // handle all msgs on queue in a row
|
|
|
- while(PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
|
|
|
- process_1_event();
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: wdxGraphicsWindow::get_gsg_type
|
|
|
-// Access: Public, Virtual
|
|
|
-// Description: Returns the TypeHandle of the kind of GSG preferred
|
|
|
-// by this kind of window.
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-TypeHandle wdxGraphicsWindow::
|
|
|
-get_gsg_type() const {
|
|
|
- return DXGraphicsStateGuardian::get_class_type();
|
|
|
-}
|
|
|
-
|
|
|
-GraphicsWindow *wdxGraphicsWindow::
|
|
|
-make_wdxGraphicsWindow(const FactoryParams ¶ms) {
|
|
|
- GraphicsWindow::WindowPipe *pipe_param;
|
|
|
- if(!get_param_into(pipe_param, params)) {
|
|
|
- wdxdisplay_cat.error()
|
|
|
- << "No pipe specified for window creation!" << endl;
|
|
|
- return NULL;
|
|
|
- }
|
|
|
-
|
|
|
- GraphicsPipe *pipe = pipe_param->get_pipe();
|
|
|
-
|
|
|
- GraphicsWindow::WindowProps *props_param;
|
|
|
- if(!get_param_into(props_param, params)) {
|
|
|
- return new wdxGraphicsWindow(pipe);
|
|
|
- } else {
|
|
|
- return new wdxGraphicsWindow(pipe, props_param->get_properties());
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-TypeHandle wdxGraphicsWindow::get_class_type(void) {
|
|
|
- return _type_handle;
|
|
|
-}
|
|
|
-
|
|
|
-void wdxGraphicsWindow::init_type(void) {
|
|
|
- GraphicsWindow::init_type();
|
|
|
- register_type(_type_handle, "wdxGraphicsWindow8",
|
|
|
- GraphicsWindow::get_class_type());
|
|
|
-}
|
|
|
-
|
|
|
-TypeHandle wdxGraphicsWindow::get_type(void) const {
|
|
|
- return get_class_type();
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: lookup_key
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-ButtonHandle wdxGraphicsWindow::
|
|
|
-lookup_key(WPARAM wparam) const {
|
|
|
- // First, check for a few buttons that we filter out when the IME
|
|
|
- // window is open.
|
|
|
- if (!_ime_active) {
|
|
|
- switch(wparam) {
|
|
|
- case VK_BACK: return KeyboardButton::backspace();
|
|
|
- case VK_DELETE: return KeyboardButton::del();
|
|
|
- case VK_ESCAPE: return KeyboardButton::escape();
|
|
|
- case VK_SPACE: return KeyboardButton::space();
|
|
|
- case VK_UP: return KeyboardButton::up();
|
|
|
- case VK_DOWN: return KeyboardButton::down();
|
|
|
- case VK_LEFT: return KeyboardButton::left();
|
|
|
- case VK_RIGHT: return KeyboardButton::right();
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Now check for the rest of the buttons, including the ones that
|
|
|
- // we allow through even when the IME window is open.
|
|
|
- switch(wparam) {
|
|
|
- case VK_TAB: return KeyboardButton::tab();
|
|
|
- case VK_PRIOR: return KeyboardButton::page_up();
|
|
|
- case VK_NEXT: return KeyboardButton::page_down();
|
|
|
- case VK_HOME: return KeyboardButton::home();
|
|
|
- case VK_END: return KeyboardButton::end();
|
|
|
- case VK_F1: return KeyboardButton::f1();
|
|
|
- case VK_F2: return KeyboardButton::f2();
|
|
|
- case VK_F3: return KeyboardButton::f3();
|
|
|
- case VK_F4: return KeyboardButton::f4();
|
|
|
- case VK_F5: return KeyboardButton::f5();
|
|
|
- case VK_F6: return KeyboardButton::f6();
|
|
|
- case VK_F7: return KeyboardButton::f7();
|
|
|
- case VK_F8: return KeyboardButton::f8();
|
|
|
- case VK_F9: return KeyboardButton::f9();
|
|
|
- case VK_F10: return KeyboardButton::f10();
|
|
|
- case VK_F11: return KeyboardButton::f11();
|
|
|
- case VK_F12: return KeyboardButton::f12();
|
|
|
- case VK_INSERT: return KeyboardButton::insert();
|
|
|
- case VK_CAPITAL: return KeyboardButton::caps_lock();
|
|
|
- case VK_NUMLOCK: return KeyboardButton::num_lock();
|
|
|
- case VK_SCROLL: return KeyboardButton::scroll_lock();
|
|
|
- case VK_SNAPSHOT: return KeyboardButton::print_screen();
|
|
|
-
|
|
|
- case VK_SHIFT:
|
|
|
- case VK_LSHIFT:
|
|
|
- case VK_RSHIFT:
|
|
|
- return KeyboardButton::shift();
|
|
|
-
|
|
|
- case VK_CONTROL:
|
|
|
- case VK_LCONTROL:
|
|
|
- case VK_RCONTROL:
|
|
|
- return KeyboardButton::control();
|
|
|
-
|
|
|
- case VK_MENU:
|
|
|
- case VK_LMENU:
|
|
|
- case VK_RMENU:
|
|
|
- return KeyboardButton::alt();
|
|
|
-
|
|
|
- default:
|
|
|
- int key = MapVirtualKey(wparam, 2);
|
|
|
- if (isascii(key) && key != 0) {
|
|
|
- // We used to try to remap lowercase to uppercase keys
|
|
|
- // here based on the state of the shift and/or caps lock
|
|
|
- // keys. But that's a mistake, and doesn't allow for
|
|
|
- // international or user-defined keyboards; let Windows
|
|
|
- // do that mapping.
|
|
|
-
|
|
|
- // Nowadays, we make a distinction between a "button"
|
|
|
- // and a "keystroke". A button corresponds to a
|
|
|
- // physical button on the keyboard and has a down and up
|
|
|
- // event associated. A keystroke may or may not
|
|
|
- // correspond to a physical button, but will be some
|
|
|
- // Unicode character and will not have a corresponding
|
|
|
- // up event.
|
|
|
- return KeyboardButton::ascii_key(tolower(key));
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- return ButtonHandle::none();
|
|
|
-}
|
|
|
-
|
|
|
-int wdxGraphicsWindow::
|
|
|
-get_depth_bitwidth(void) {
|
|
|
- assert(_dxgsg!=NULL);
|
|
|
- if(_dxgsg->scrn.PresParams.EnableAutoDepthStencil)
|
|
|
- return _dxgsg->scrn.depth_buffer_bitdepth;
|
|
|
- else return 0;
|
|
|
-
|
|
|
-// GetSurfaceDesc is not reliable, on GF2, GetSurfDesc returns 32bpp when you created a 24bpp zbuf
|
|
|
-// instead store the depth used at creation time
|
|
|
-
|
|
|
-// DX_DECLARE_CLEAN(DDSURFACEDESC2, ddsd);
|
|
|
-// _dxgsg->_zbuf->GetSurfaceDesc(&ddsd);
|
|
|
-// return ddsd.ddpfPixelFormat.dwRGBBitCount;
|
|
|
-}
|
|
|
-
|
|
|
-void wdxGraphicsWindow::
|
|
|
-get_framebuffer_format(PixelBuffer::Type &fb_type, PixelBuffer::Format &fb_format) {
|
|
|
- assert(_dxgsg!=NULL);
|
|
|
-
|
|
|
- fb_type = PixelBuffer::T_unsigned_byte;
|
|
|
- // this is sortof incorrect, since for F_rgb5 it's really 5 bits per channel
|
|
|
- //would have to change a lot of texture stuff to make this correct though
|
|
|
-
|
|
|
- if(IS_16BPP_DISPLAY_FORMAT(_dxgsg->scrn.PresParams.BackBufferFormat))
|
|
|
- fb_format = PixelBuffer::F_rgb5;
|
|
|
- else fb_format = PixelBuffer::F_rgb;
|
|
|
-}
|
|
|
-
|
|
|
-// Global system parameters we want to modify during our run
|
|
|
-static int iMouseTrails;
|
|
|
-static bool bCursorShadowOn,bMouseVanish;
|
|
|
-
|
|
|
-#ifndef SPI_GETMOUSEVANISH
|
|
|
-// get rid of this when we upgrade to winxp winuser.h in newest platform sdk
|
|
|
-#define SPI_GETMOUSEVANISH 0x1020
|
|
|
-#define SPI_SETMOUSEVANISH 0x1021
|
|
|
-#endif
|
|
|
-
|
|
|
-#ifndef SPI_GETCURSORSHADOW
|
|
|
-#error You have old windows headers, need to get latest MS Platform SDK
|
|
|
-#endif
|
|
|
-
|
|
|
-void set_global_parameters(void) {
|
|
|
- // turn off mousetrails and cursor shadow and mouse cursor vanish
|
|
|
- // cursor shadow causes cursor blink and reduced frame rate due to lack of driver support for
|
|
|
- // cursor alpha blending
|
|
|
-
|
|
|
- // this is a win2k/xp only param, could use GetVersionEx to do it just for win2k,
|
|
|
- // but since it is just a param it will just cause a silent error on other OS's
|
|
|
- // that should be ok
|
|
|
- SystemParametersInfo(SPI_GETCURSORSHADOW,NULL,&bCursorShadowOn,NULL);
|
|
|
- SystemParametersInfo(SPI_SETCURSORSHADOW,NULL,(PVOID)false,NULL);
|
|
|
-
|
|
|
- SystemParametersInfo(SPI_GETMOUSETRAILS,NULL,&iMouseTrails,NULL);
|
|
|
- SystemParametersInfo(SPI_SETMOUSETRAILS,NULL,(PVOID)0,NULL);
|
|
|
-
|
|
|
- // this is ME/XP only feature
|
|
|
- SystemParametersInfo(SPI_GETMOUSEVANISH,NULL,&bMouseVanish,NULL);
|
|
|
- SystemParametersInfo(SPI_SETMOUSEVANISH,NULL,(PVOID)false,NULL);
|
|
|
-}
|
|
|
-
|
|
|
-void restore_global_parameters(void) {
|
|
|
- SystemParametersInfo(SPI_SETCURSORSHADOW,NULL,(PVOID)bCursorShadowOn,NULL);
|
|
|
- SystemParametersInfo(SPI_SETMOUSETRAILS,NULL,(PVOID)iMouseTrails,NULL);
|
|
|
- SystemParametersInfo(SPI_SETMOUSEVANISH,NULL,(PVOID)bMouseVanish,NULL);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-// fns for exporting to python, which cant pass variable length arrays
|
|
|
-wdxGraphicsWindowGroup::wdxGraphicsWindowGroup(GraphicsPipe *pipe,const GraphicsWindow::Properties &Win1Prop) {
|
|
|
- GraphicsWindow::Properties WinPropArr[1];
|
|
|
- WinPropArr[0]=Win1Prop;
|
|
|
- make_windows(pipe,1,WinPropArr);
|
|
|
-}
|
|
|
-
|
|
|
-wdxGraphicsWindowGroup::wdxGraphicsWindowGroup(GraphicsPipe *pipe,
|
|
|
- const GraphicsWindow::Properties &Win1Prop,
|
|
|
- const GraphicsWindow::Properties &Win2Prop) {
|
|
|
- GraphicsWindow::Properties WinPropArr[2];
|
|
|
-
|
|
|
- WinPropArr[0]=Win1Prop;
|
|
|
- WinPropArr[1]=Win2Prop;
|
|
|
- make_windows(pipe,2,WinPropArr);
|
|
|
-}
|
|
|
-
|
|
|
-wdxGraphicsWindowGroup::wdxGraphicsWindowGroup(GraphicsPipe *pipe,
|
|
|
- const GraphicsWindow::Properties &Win1Prop,
|
|
|
- const GraphicsWindow::Properties &Win2Prop,
|
|
|
- const GraphicsWindow::Properties &Win3Prop) {
|
|
|
- GraphicsWindow::Properties WinPropArr[3];
|
|
|
-
|
|
|
- WinPropArr[0]=Win1Prop;
|
|
|
- WinPropArr[1]=Win2Prop;
|
|
|
- WinPropArr[2]=Win3Prop;
|
|
|
- make_windows(pipe,3,WinPropArr);
|
|
|
-}
|
|
|
-
|
|
|
-wdxGraphicsWindowGroup::wdxGraphicsWindowGroup(wdxGraphicsWindow *OneWindow) {
|
|
|
- // init a 1 window group
|
|
|
- // called from config_window
|
|
|
-
|
|
|
- _windows.reserve(1);
|
|
|
- _windows.push_back(OneWindow);
|
|
|
- initWindowGroup();
|
|
|
-}
|
|
|
-
|
|
|
-void wdxGraphicsWindowGroup::initWindowGroup(void) {
|
|
|
- HRESULT hr;
|
|
|
-
|
|
|
- assert(_windows.size()>0);
|
|
|
- _hOldForegroundWindow=GetForegroundWindow();
|
|
|
- _bClosingAllWindows= false;
|
|
|
-
|
|
|
- UINT num_windows=_windows.size();
|
|
|
-
|
|
|
- #define D3D8_NAME "d3d8.dll"
|
|
|
- #define D3DCREATE8 "Direct3DCreate8"
|
|
|
-
|
|
|
- _hD3D8_DLL = LoadLibrary(D3D8_NAME);
|
|
|
- if(_hD3D8_DLL == 0) {
|
|
|
- wdxdisplay_cat.fatal() << "PandaDX8 requires DX8, can't locate " << D3D8_NAME <<"!\n";
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- _hMouseCursor = NULL;
|
|
|
- _bLoadedCustomCursor = false;
|
|
|
-
|
|
|
- _pDInputInfo = NULL;
|
|
|
-
|
|
|
- // can only get multimon HW acceleration in fullscrn on DX7
|
|
|
-
|
|
|
- UINT numMonitors = GetSystemMetrics(SM_CMONITORS);
|
|
|
-
|
|
|
- if(numMonitors < num_windows) {
|
|
|
- if(numMonitors==0) {
|
|
|
- numMonitors=1; //win95 system will fail this call
|
|
|
- } else {
|
|
|
- wdxdisplay_cat.fatal() << "system has only "<< numMonitors << " monitors attached, couldn't find enough devices to meet multi window reqmt of " << num_windows << endl;
|
|
|
- exit(1);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Do all DX7 stuff first
|
|
|
- // find_all_card_memavails();
|
|
|
-
|
|
|
- LPDIRECT3D8 pD3D8;
|
|
|
-
|
|
|
- typedef LPDIRECT3D8 (WINAPI *Direct3DCreate8_ProcPtr)(UINT SDKVersion);
|
|
|
-
|
|
|
- // dont want to statically link to possibly non-existent d3d8 dll, so must call D3DCr8 indirectly
|
|
|
- Direct3DCreate8_ProcPtr D3DCreate8_Ptr =
|
|
|
- (Direct3DCreate8_ProcPtr) GetProcAddress(_hD3D8_DLL, D3DCREATE8);
|
|
|
-
|
|
|
- if(D3DCreate8_Ptr == NULL) {
|
|
|
- wdxdisplay_cat.fatal() << "GetProcAddress for "<< D3DCREATE8 << "failed!" << endl;
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
-// these were taken from the 8.0 and 8.1 d3d8.h SDK headers
|
|
|
-#define D3D_SDK_VERSION_8_0 120
|
|
|
-#define D3D_SDK_VERSION_8_1 220
|
|
|
-
|
|
|
- // are we using 8.0 or 8.1?
|
|
|
- WIN32_FIND_DATA TempFindData;
|
|
|
- HANDLE hFind;
|
|
|
- char tmppath[MAX_PATH];
|
|
|
- GetSystemDirectory(tmppath,MAX_PATH);
|
|
|
- strcat(tmppath,"\\dpnhpast.dll");
|
|
|
- hFind = FindFirstFile ( tmppath,&TempFindData );
|
|
|
- if(hFind != INVALID_HANDLE_VALUE) {
|
|
|
- FindClose(hFind);
|
|
|
- _bIsDX81=true;
|
|
|
- pD3D8 = (*D3DCreate8_Ptr)(D3D_SDK_VERSION_8_1);
|
|
|
- } else {
|
|
|
- _bIsDX81=false;
|
|
|
- pD3D8 = (*D3DCreate8_Ptr)(D3D_SDK_VERSION_8_0);
|
|
|
- }
|
|
|
-
|
|
|
- if(pD3D8==NULL) {
|
|
|
- wdxdisplay_cat.fatal() << D3DCREATE8 << " failed!\n";
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- _numAdapters = pD3D8->GetAdapterCount();
|
|
|
- if(_numAdapters < num_windows) {
|
|
|
- wdxdisplay_cat.fatal() << "couldn't find enough devices attached to meet multi window reqmt of " << num_windows << endl;
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- for(UINT i=0;i<_numAdapters;i++) {
|
|
|
- D3DADAPTER_IDENTIFIER8 adapter_info;
|
|
|
- ZeroMemory(&adapter_info,sizeof(D3DADAPTER_IDENTIFIER8));
|
|
|
- hr = pD3D8->GetAdapterIdentifier(i,D3DENUM_NO_WHQL_LEVEL,&adapter_info);
|
|
|
- if(FAILED(hr)) {
|
|
|
- wdxdisplay_cat.fatal() << "D3D GetAdapterID failed" << D3DERRORSTRING(hr);
|
|
|
- }
|
|
|
-
|
|
|
- LARGE_INTEGER *DrvVer=&adapter_info.DriverVersion;
|
|
|
-
|
|
|
- wdxdisplay_cat.info() << "D3D8 Adapter[" << i << "]: " << adapter_info.Description <<
|
|
|
- ", Driver: " << adapter_info.Driver << ", DriverVersion: ("
|
|
|
- << HIWORD(DrvVer->HighPart) << "." << LOWORD(DrvVer->HighPart) << "."
|
|
|
- << HIWORD(DrvVer->LowPart) << "." << LOWORD(DrvVer->LowPart) << ")\nVendorID: 0x"
|
|
|
- << (void*) adapter_info.VendorId << " DeviceID: 0x" << (void*) adapter_info.DeviceId
|
|
|
- << " SubsysID: 0x" << (void*) adapter_info.SubSysId << " Revision: 0x"
|
|
|
- << (void*) adapter_info.Revision << endl;
|
|
|
-
|
|
|
- HMONITOR hMon=pD3D8->GetAdapterMonitor(i);
|
|
|
- if(hMon==NULL) {
|
|
|
- wdxdisplay_cat.info() << "D3D8 Adapter[" << i << "]: seems to be disabled, skipping it\n";
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- DXDeviceInfo devinfo;
|
|
|
- ZeroMemory(&devinfo,sizeof(devinfo));
|
|
|
- memcpy(&devinfo.guidDeviceIdentifier,&adapter_info.DeviceIdentifier,sizeof(GUID));
|
|
|
- strncpy(devinfo.szDescription,adapter_info.Description,MAX_DEVICE_IDENTIFIER_STRING);
|
|
|
- strncpy(devinfo.szDriver,adapter_info.Driver,MAX_DEVICE_IDENTIFIER_STRING);
|
|
|
- devinfo.VendorID=adapter_info.VendorId;
|
|
|
- devinfo.DeviceID=adapter_info.DeviceId;
|
|
|
- devinfo.hMon=hMon;
|
|
|
- devinfo.cardID=i;
|
|
|
-
|
|
|
- _DeviceInfoVec.push_back(devinfo);
|
|
|
- }
|
|
|
-
|
|
|
- for(UINT i=0;i<num_windows;i++) {
|
|
|
- _windows[i]->config_window(this);
|
|
|
- }
|
|
|
-
|
|
|
- UINT good_device_count=0;
|
|
|
-
|
|
|
- if(num_windows==1) {
|
|
|
- UINT D3DAdapterNum = D3DADAPTER_DEFAULT;
|
|
|
-
|
|
|
- if(dx_preferred_deviceID!=-1) {
|
|
|
- if(dx_preferred_deviceID>=(int)_numAdapters) {
|
|
|
- wdxdisplay_cat.fatal() << "invalid 'dx-preferred-device-id', valid values are 0-" << _numAdapters-1 << ", using default adapter 0 instead\n";
|
|
|
- } else D3DAdapterNum=dx_preferred_deviceID;
|
|
|
- }
|
|
|
- if(_windows[0]->search_for_device(pD3D8,&(_DeviceInfoVec[D3DAdapterNum])))
|
|
|
- good_device_count=1;
|
|
|
- } else {
|
|
|
- for(UINT devnum=0;devnum<_DeviceInfoVec.size() && (good_device_count < num_windows);devnum++) {
|
|
|
- if(_windows[devnum]->search_for_device(pD3D8,&(_DeviceInfoVec[devnum])))
|
|
|
- good_device_count++;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if(good_device_count < num_windows) {
|
|
|
- if(good_device_count==0)
|
|
|
- wdxdisplay_cat.fatal() << "no usable display devices, exiting...\n";
|
|
|
- else wdxdisplay_cat.fatal() << "multi-device request for " << num_windows << "devices, found only "<< good_device_count << " usable ones, exiting!";
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- _DeviceInfoVec.clear(); // dont need this anymore
|
|
|
-
|
|
|
- if(wdxdisplay_cat.is_debug() && (g_pCardIDVec!=NULL)) {
|
|
|
- // print out the MaxAvailVidMems
|
|
|
- for(UINT i=0;i<_windows.size();i++) {
|
|
|
- D3DADAPTER_IDENTIFIER8 adapter_info;
|
|
|
- pD3D8->GetAdapterIdentifier(_windows[i]->_dxgsg->scrn.CardIDNum,D3DENUM_NO_WHQL_LEVEL,&adapter_info);
|
|
|
- wdxdisplay_cat.info() << "D3D8 Adapter[" << i << "]: " << adapter_info.Description
|
|
|
- << ", MaxAvailVideoMem: " << _windows[i]->_dxgsg->scrn.MaxAvailVidMem
|
|
|
- << ", IsLowVidMemCard: " << (_windows[i]->_dxgsg->scrn.bIsLowVidMemCard ? "true" : "false") << endl;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- CreateWindows(); // creates win32 windows (need to do this before Setting coopLvls and display modes,
|
|
|
- // but after we have all the monitor handles needed by CreateWindow()
|
|
|
-
|
|
|
-// SetCoopLevelsAndDisplayModes();
|
|
|
-
|
|
|
- if(dx_show_fps_meter)
|
|
|
- _windows[0]->_dxgsg->_bShowFPSMeter = true; // just show fps on 1st mon
|
|
|
-
|
|
|
- for(UINT i=0;i<num_windows;i++) {
|
|
|
- _windows[i]->CreateScreenBuffersAndDevice(_windows[i]->_dxgsg->scrn);
|
|
|
- }
|
|
|
-
|
|
|
- for(UINT i=0;i<num_windows;i++) {
|
|
|
- _windows[i]->finish_window_setup();
|
|
|
- }
|
|
|
-
|
|
|
- SAFE_DELETE(g_pCardIDVec); // dont need this anymore
|
|
|
-
|
|
|
- for(UINT i=0;i<num_windows;i++) {
|
|
|
- _windows[i]->_dxgsg->SetDXReady(true);
|
|
|
- }
|
|
|
-
|
|
|
- dx_pick_best_screenres = false; // only want to do this on startup, not resize
|
|
|
-
|
|
|
- #ifdef DINPUT_DEBUG_POLL
|
|
|
- if(dx_use_joystick) {
|
|
|
- _pDInputInfo = new DInput8Info;
|
|
|
- assert(_pDInputInfo !=NULL);
|
|
|
- if(!_pDInputInfo->InitDirectInput()) {
|
|
|
- wdxdisplay_cat.error() << "InitDirectInput failed!\n";
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- if(!_pDInputInfo->CreateJoystickOrPad(_hParentWindow)) { // associate w/parent window of group for now
|
|
|
- wdxdisplay_cat.error() << "CreateJoystickOrPad failed!\n";
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- // for now, just set up a WM_TIMER to poll the joystick.
|
|
|
- // could configure it to do event-based input, and that is default w/action mapping
|
|
|
- // which would be better, less processor intensive
|
|
|
-
|
|
|
- #define POLL_FREQUENCY_HZ 3
|
|
|
- _pDInputInfo->_JoystickPollTimer = SetTimer(_hParentWindow, JOYSTICK_POLL_TIMER_ID, 1000/POLL_FREQUENCY_HZ, NULL);
|
|
|
- if(_pDInputInfo->_JoystickPollTimer!=JOYSTICK_POLL_TIMER_ID) {
|
|
|
- wdxdisplay_cat.error() << "Error in joystick SetTimer!\n";
|
|
|
- }
|
|
|
- }
|
|
|
- #endif
|
|
|
-}
|
|
|
-
|
|
|
-wdxGraphicsWindowGroup::wdxGraphicsWindowGroup(GraphicsPipe *pipe,int num_windows,GraphicsWindow::Properties *WinPropArray) {
|
|
|
- make_windows(pipe,num_windows,WinPropArray);
|
|
|
-}
|
|
|
-
|
|
|
-void wdxGraphicsWindowGroup::
|
|
|
-make_windows(GraphicsPipe *pipe,int num_windows,GraphicsWindow::Properties *WinPropArray) {
|
|
|
- _hParentWindow=NULL;
|
|
|
- _windows.reserve(num_windows);
|
|
|
- int i;
|
|
|
-
|
|
|
- // first make all the objs without running the dx config() stuff
|
|
|
- for(i=0;i<num_windows;i++) {
|
|
|
- wdxGraphicsWindow *pWdxWinptr= new wdxGraphicsWindow(pipe,WinPropArray[i],this);
|
|
|
- assert(pWdxWinptr!=NULL);
|
|
|
- _windows.push_back(pWdxWinptr);
|
|
|
- }
|
|
|
-
|
|
|
- initWindowGroup(); // needs _windows.size() to be valid
|
|
|
-}
|
|
|
-
|
|
|
-wdxGraphicsWindow::wdxGraphicsWindow(GraphicsPipe* pipe, const GraphicsWindow::Properties &props, wdxGraphicsWindowGroup *pParentGroup)
|
|
|
- : GraphicsWindow(pipe, props) {
|
|
|
- _pParentWindowGroup=pParentGroup;
|
|
|
- _ime_open = false;
|
|
|
- // just call the GraphicsWindow constructor, have to hold off rest of init
|
|
|
-}
|
|
|
-
|
|
|
-wdxGraphicsWindowGroup::~wdxGraphicsWindowGroup() {
|
|
|
- // this fn must be called before windows are actually closed
|
|
|
- _bClosingAllWindows= true;
|
|
|
-
|
|
|
- SAFE_DELETE(_pDInputInfo);
|
|
|
-
|
|
|
- for(UINT i=0;i<_windows.size();i++) {
|
|
|
- _windows[i]->close_window();
|
|
|
- }
|
|
|
-
|
|
|
- if((_hOldForegroundWindow!=NULL) /*&& (scrn.hWnd==GetForegroundWindow())*/) {
|
|
|
- SetForegroundWindow(_hOldForegroundWindow);
|
|
|
- }
|
|
|
-
|
|
|
- if(_bLoadedCustomCursor && (_hMouseCursor!=NULL))
|
|
|
- DestroyCursor(_hMouseCursor);
|
|
|
-
|
|
|
- if(_hD3D8_DLL != NULL) {
|
|
|
- FreeLibrary(_hD3D8_DLL);
|
|
|
- _hD3D8_DLL = NULL;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
David Rose