VideoMode Monitor::GetCurrentVideoMode() {
#if defined(FastOSWindows)
DEVMODE dm;
memset(&dm, 0, sizeof(DEVMODE));
dm.dmSize = sizeof(DEVMODE);
EnumDisplaySettingsEx(mWin32DeviceName.GetWString().mData,
ENUM_CURRENT_SETTINGS, &dm, 0);
return VideoMode(dm.dmPelsWidth, dm.dmPelsHeight,
dm.dmBitsPerPel, dm.dmDisplayFrequency);
#elif defined(FastOSLinux)
XRRScreenResources *xrrScreenResources =
(XRRScreenResources*)mDisplay->GetXRRScreenResources();
::Display *xdisplay = (::Display*)mDisplay->GetXDisplay();
RRMode mode = ((XRRCrtcInfo*)mXRRCrtcInfo)->mode;
// Find matching mode ID
for (Int i = 0; i < xrrScreenResources->nmode; i++) {
if (mode == xrrScreenResources->modes[i].id) {
XRRModeInfo &xrrModeInfo = xrrScreenResources->modes[i];
return VideoMode(xrrModeInfo.width, xrrModeInfo.height,
XDefaultDepth(xdisplay, mID), (Int)(xrrModeInfo.dotClock /
(xrrModeInfo.hTotal * xrrModeInfo.vTotal)));
}
}
return VideoMode();
#elif defined(FastOSMacOSX)
VideoMode vm;
QZGetCurrentVideoMode(mMacMonitorID, &vm);
return vm;
#endif
}
HDC GenericSLM::CreateDeviceContext(string deviceName) {
DEVMODE dm;
ZeroMemory(&dm, sizeof(dm));
dm.dmSize = sizeof(dm);
EnumDisplaySettingsEx(deviceName.c_str(), ENUM_REGISTRY_SETTINGS, &dm, 0);
return CreateDC(deviceName.c_str(), 0, 0, &dm);
}
// ディスプレイの位置とサイズを返す
int Window::GetDisplayRect( long displaynum, int *x, int *y, int *width, int *height )
{
DISPLAY_DEVICE disdev;
DEVMODE devmode;
if ( x )
{
*x = 0;
}
if ( y )
{
*y = 0;
}
if ( width )
{
*width = 0;
}
if ( height )
{
*height = 0;
}
memset( &disdev, 0, sizeof( DISPLAY_DEVICE ) );
disdev.cb = sizeof( DISPLAY_DEVICE );
if ( EnumDisplayDevices( NULL, displaynum, &disdev, 0 ) == 0 )
{
// 不正なディスプレイ番号
return 1;
}
memset( &devmode, 0, sizeof( DEVMODE ) );
devmode.dmSize = sizeof( DEVMODE );
if ( EnumDisplaySettingsEx( disdev.DeviceName, /*ENUM_CURRENT_SETTINGS*/ENUM_REGISTRY_SETTINGS, &devmode, EDS_RAWMODE ) == 0 )
{
// 設定を取得できなかった
return 2;
}
if ( x )
{
*x = devmode.dmPosition.x;
}
if ( y )
{
*y = devmode.dmPosition.y;
}
if ( width )
{
*width = devmode.dmPelsWidth;
}
if ( height )
{
*height = devmode.dmPelsHeight;
}
return 0;
}
void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
{
DEVMODE settings;
ZeroMemory(&settings, sizeof(DEVMODE));
settings.dmSize = sizeof(DEVMODE);
EnumDisplaySettingsEx(monitor->win32.name,
ENUM_CURRENT_SETTINGS,
&settings,
EDS_ROTATEDMODE);
if (xpos)
*xpos = settings.dmPosition.x;
if (ypos)
*ypos = settings.dmPosition.y;
}
std::vector<Rectf> ScreenInfoProvider_Win32::get_screen_geometries(int &primary_screen_index) const
{
HDC dc = GetDC(0);
int ppi = GetDeviceCaps(dc, LOGPIXELSX);
ReleaseDC(0, dc);
std::vector<Rectf> monitor_positions;
primary_screen_index = 0;
int index = 0;
while (true)
{
DISPLAY_DEVICE display_device;
memset(&display_device, 0, sizeof(DISPLAY_DEVICE));
display_device.cb = sizeof(DISPLAY_DEVICE);
BOOL result = EnumDisplayDevices(0, index++, &display_device, 0);
if (result == FALSE)
break;
if ((display_device.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER) == 0 &&
(display_device.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP))
{
std::wstring device_name = display_device.DeviceName;
DEVMODE devmode;
memset(&devmode, 0, sizeof(DEVMODE));
devmode.dmSize = sizeof(DEVMODE);
result = EnumDisplaySettingsEx(device_name.c_str(), ENUM_REGISTRY_SETTINGS, &devmode, 0);
if (result)
{
if ((devmode.dmFields & DM_PELSWIDTH) && (devmode.dmFields & DM_PELSHEIGHT))
{
if (display_device.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
primary_screen_index = monitor_positions.size();
Rectf pos(
devmode.dmPosition.x * 96.0f / ppi,
devmode.dmPosition.y * 96.0f / ppi,
(devmode.dmPosition.x + devmode.dmPelsWidth) * 96.0f / ppi,
(devmode.dmPosition.y + devmode.dmPelsHeight) * 96.0f / ppi);
monitor_positions.push_back(pos);
}
}
}
}
return monitor_positions;
}
// TODO: Fix me
void CWinSystemEGL::UpdateResolutions()
{
CWinSystemBase::UpdateResolutions();
// Add desktop resolution
#ifdef _WIN32
DEVMODE dm;
ZeroMemory(&dm, sizeof(dm));
dm.dmSize = sizeof(dm);
EnumDisplaySettingsEx(NULL, ENUM_CURRENT_SETTINGS, &dm, 0);
UpdateDesktopResolution(g_settings.m_ResInfo[RES_DESKTOP], 0, dm.dmPelsWidth, dm.dmPelsHeight, 60);
#else
UpdateDesktopResolution(g_settings.m_ResInfo[RES_DESKTOP], 0, 1920, 1080, 60);
#endif
}
const Monitor::MonitorModes& Win32Monitor::GetModes()
{
if(!modesInitialized)
{
for(int i = 0; ; ++i)
{
DEVMODE modeInfo;
modeInfo.dmSize = sizeof(modeInfo);
modeInfo.dmDriverExtra = 0;
if(!EnumDisplaySettingsEx(info.DeviceName, i, &modeInfo, 0))
break;
modes.push_back(NEW(Win32MonitorMode(modeInfo)));
}
modesInitialized = true;
}
return modes;
}
std::pair<DISPLAY_DEVICE, DEVMODE> GetDisplaySettings(int monitor_index){
DISPLAY_DEVICE dd;
dd.cb = sizeof(dd);
EnumDisplayDevices(nullptr, 2, &dd, monitor_index);
DEVMODE dm;
// initialize the DEVMODE structure
ZeroMemory(&dm, sizeof(dm));
dm.dmSize = sizeof(dm);
int res = EnumDisplaySettingsEx(dd.DeviceName, ENUM_CURRENT_SETTINGS, &dm, EDS_RAWMODE);
if (res == 0){
puts("Failed to extract display settings.");
return {};
}
return { dd, dm };
}
RECT Win32Monitor::GetRect() const
{
try
{
// code below is not working for some reason
// EnumDisplaySettingsEx always return false
#if 0
DEVMODE modeInfo;
modeInfo.dmSize = sizeof(modeInfo);
modeInfo.dmDriverExtra = 0;
std::cout << deviceName << "\n";
if(!EnumDisplaySettingsEx(info.DeviceName, ENUM_CURRENT_SETTINGS, &modeInfo, 0))
THROW("Can't get current mode");
RECT rect;
rect.left = (modeInfo.dmFields & DM_POSITION) ? modeInfo.dmPosition.x : 0;
rect.top = (modeInfo.dmFields & DM_POSITION) ? modeInfo.dmPosition.y : 0;
rect.right = rect.left + ((modeInfo.dmFields & DM_PELSWIDTH) ? modeInfo.dmPelsWidth : 0);
rect.bottom = rect.top + ((modeInfo.dmFields & DM_PELSHEIGHT) ? modeInfo.dmPelsHeight : 0);
return rect;
#else
// temporary "fix"
RECT rect;
rect.left = 0;
rect.top = 0;
rect.right = GetSystemMetrics(SM_CXSCREEN);
rect.bottom = GetSystemMetrics(SM_CYSCREEN);
return rect;
#endif
}
catch(Exception* exception)
{
THROW_SECONDARY("Can't get Win32 monitor rect", exception);
}
}
bool CWinSystemWin32::UpdateResolutionsInternal()
{
DISPLAY_DEVICE ddAdapter;
ZeroMemory(&ddAdapter, sizeof(ddAdapter));
ddAdapter.cb = sizeof(ddAdapter);
DWORD adapter = 0;
while (EnumDisplayDevices(NULL, adapter, &ddAdapter, 0))
{
// Exclude displays that are not part of the windows desktop. Using them is too different: no windows,
// direct access with GDI CreateDC() or DirectDraw for example. So it may be possible to play video, but GUI?
if (!(ddAdapter.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER) && (ddAdapter.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP))
{
DISPLAY_DEVICE ddMon;
ZeroMemory(&ddMon, sizeof(ddMon));
ddMon.cb = sizeof(ddMon);
bool foundScreen = false;
DWORD screen = 0;
// Just look for the first active output, we're actually only interested in the information at the adapter level.
while (EnumDisplayDevices(ddAdapter.DeviceName, screen, &ddMon, 0))
{
if (ddMon.StateFlags & (DISPLAY_DEVICE_ACTIVE | DISPLAY_DEVICE_ATTACHED))
{
foundScreen = true;
break;
}
ZeroMemory(&ddMon, sizeof(ddMon));
ddMon.cb = sizeof(ddMon);
screen++;
}
// Remoting returns no screens. Handle with a dummy screen.
if (!foundScreen && screen == 0)
{
lstrcpy(ddMon.DeviceString, _T("Dummy Monitor")); // safe: large static array
foundScreen = true;
}
if (foundScreen)
{
CLog::Log(LOGNOTICE, "Found screen: %s on %s, adapter %d.", ddMon.DeviceString, ddAdapter.DeviceString, adapter);
// get information about the display's current position and display mode
// TODO: for Windows 7/Server 2008 and up, Microsoft recommends QueryDisplayConfig() instead, the API used by the control panel.
DEVMODE dm;
ZeroMemory(&dm, sizeof(dm));
dm.dmSize = sizeof(dm);
if (EnumDisplaySettingsEx(ddAdapter.DeviceName, ENUM_CURRENT_SETTINGS, &dm, 0) == FALSE)
EnumDisplaySettingsEx(ddAdapter.DeviceName, ENUM_REGISTRY_SETTINGS, &dm, 0);
// get the monitor handle and workspace
HMONITOR hm = 0;
POINT pt = { dm.dmPosition.x, dm.dmPosition.y };
hm = MonitorFromPoint(pt, MONITOR_DEFAULTTONULL);
MONITOR_DETAILS md;
memset(&md, 0, sizeof(MONITOR_DETAILS));
strcpy(md.MonitorName, ddMon.DeviceString);
strcpy(md.CardName, ddAdapter.DeviceString);
strcpy(md.DeviceName, ddAdapter.DeviceName);
// width x height @ x,y - bpp - refresh rate
// note that refresh rate information is not available on Win9x
md.ScreenWidth = dm.dmPelsWidth;
md.ScreenHeight = dm.dmPelsHeight;
md.hMonitor = hm;
md.RefreshRate = dm.dmDisplayFrequency;
md.Bpp = dm.dmBitsPerPel;
md.Interlaced = (dm.dmDisplayFlags & DM_INTERLACED) ? true : false;
m_MonitorsInfo.push_back(md);
// Careful, some adapters don't end up in the vector (mirroring, no active output, etc.)
if (ddAdapter.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
m_nPrimary = m_MonitorsInfo.size() -1;
}
}
ZeroMemory(&ddAdapter, sizeof(ddAdapter));
ddAdapter.cb = sizeof(ddAdapter);
adapter++;
}
return 0;
}
static PSETTINGS_ENTRY
GetPossibleSettings(IN LPCTSTR DeviceName, OUT DWORD* pSettingsCount, OUT PSETTINGS_ENTRY* CurrentSettings)
{
DEVMODE devmode;
DWORD NbSettings = 0;
DWORD iMode = 0;
DWORD dwFlags = 0;
PSETTINGS_ENTRY Settings = NULL;
HDC hDC;
PSETTINGS_ENTRY Current;
DWORD bpp, xres, yres, checkbpp;
DWORD curDispFreq;
/* Get current settings */
*CurrentSettings = NULL;
hDC = CreateIC(NULL, DeviceName, NULL, NULL);
bpp = GetDeviceCaps(hDC, PLANES);
bpp *= GetDeviceCaps(hDC, BITSPIXEL);
xres = GetDeviceCaps(hDC, HORZRES);
yres = GetDeviceCaps(hDC, VERTRES);
DeleteDC(hDC);
/* List all settings */
devmode.dmSize = (WORD)sizeof(DEVMODE);
devmode.dmDriverExtra = 0;
if (!EnumDisplaySettingsEx(DeviceName, ENUM_CURRENT_SETTINGS, &devmode, dwFlags))
return NULL;
curDispFreq = devmode.dmDisplayFrequency;
while (EnumDisplaySettingsEx(DeviceName, iMode, &devmode, dwFlags))
{
if ((devmode.dmBitsPerPel == 4 ||
devmode.dmBitsPerPel == 8 ||
devmode.dmBitsPerPel == 16 ||
devmode.dmBitsPerPel == 24 ||
devmode.dmBitsPerPel == 32) &&
devmode.dmDisplayFrequency == curDispFreq)
{
checkbpp=1;
}
else
checkbpp=0;
if (devmode.dmPelsWidth < 640 ||
devmode.dmPelsHeight < 480 || checkbpp == 0)
{
iMode++;
continue;
}
Current = HeapAlloc(GetProcessHeap(), 0, sizeof(SETTINGS_ENTRY));
if (Current != NULL)
{
/* Sort resolutions by increasing height, and BPP */
PSETTINGS_ENTRY Previous = NULL;
PSETTINGS_ENTRY Next = Settings;
Current->dmPelsWidth = devmode.dmPelsWidth;
Current->dmPelsHeight = devmode.dmPelsHeight;
Current->dmBitsPerPel = devmode.dmBitsPerPel;
Current->dmDisplayFrequency = devmode.dmDisplayFrequency;
while (Next != NULL && (
Next->dmPelsWidth < Current->dmPelsWidth ||
(Next->dmPelsWidth == Current->dmPelsWidth && Next->dmPelsHeight < Current->dmPelsHeight) ||
(Next->dmPelsHeight == Current->dmPelsHeight &&
Next->dmPelsWidth == Current->dmPelsWidth &&
Next->dmBitsPerPel < Current->dmBitsPerPel )))
{
Previous = Next;
Next = Next->Flink;
}
Current->Blink = Previous;
Current->Flink = Next;
if (Previous == NULL)
Settings = Current;
else
Previous->Flink = Current;
if (Next != NULL)
Next->Blink = Current;
if (devmode.dmPelsWidth == xres && devmode.dmPelsHeight == yres && devmode.dmBitsPerPel == bpp)
{
*CurrentSettings = Current;
}
NbSettings++;
}
iMode++;
}
*pSettingsCount = NbSettings;
return Settings;
}
int main(int argc, char *argv[]){
// TODO: This is one horribly long main(), not good! But works for now.
HDC hDC = NULL;
DISPLAY_DEVICE displayDeviceToggled;
DEVMODE defaultMode;
DEVMODE currentMode;
DEVMODE currentRegistryMode;
long int monitor_number;
long int forceState = -1;
long int apply = 1;
int i = 0;
// Initialize DISPLAY_DEVICE
FillMemory(&displayDeviceToggled, sizeof(DISPLAY_DEVICE), 0);
displayDeviceToggled.cb = sizeof(DISPLAY_DEVICE);
// Initialize DEVMODEs
ZeroMemory(&defaultMode, sizeof(DEVMODE));
defaultMode.dmSize = sizeof(DEVMODE);
ZeroMemory(¤tMode, sizeof(DEVMODE));
currentMode.dmSize = sizeof(DEVMODE);
ZeroMemory(¤tRegistryMode, sizeof(DEVMODE));
currentRegistryMode.dmSize = sizeof(DEVMODE);
if (argc <= 1) {
puts("Monitor toggler 0.3.2"
"\r\n"
"\r\nUsage: monitortoggler.exe <monitornumber> [<forceState>] [<apply>]"
"\r\n"
"\r\n Capable of attaching and deattaching monitors from command line."
"\r\n"
"\r\n Note: Resolution / display settings should be configured from Windows dialog."
"\r\n At least in Windows 7 the changes are saved to registry, and next time "
"\r\n you attach the same screen it retrieves same settings. Thus it seems"
"\r\n to be useless to define them while attaching."
"\r\n"
"\r\n monitornumber:"
"\r\n Monitor number, this may, and usually differs from monitor numbers"
"\r\n in the screen resolution dialog. So you have to try several numbers"
"\r\n until you find the right one :)"
"\r\n"
"\r\n forceState (optional):"
"\r\n -1 = Toggles. (Tries to get the current mode, and toggles.) (default)"
"\r\n 1 = Attach"
"\r\n 0 = Detach"
"\r\n"
"\r\n apply (optional):"
"\r\n 1 = Apply changes immediately (default)"
"\r\n 0 = Do not apply changes"
"\r\n You have to call second time to apply changes"
"\r\n"
"\r\n Author: Jari Pennanen (2010) <*****@*****.**>"
"\r\n License: FreeBSD License, see COPYING"
"\r\n Repository: http://github.com/Ciantic/monitortoggler"
"\r\n");
return 0;
}
// Parse monitor number
monitor_number = strtol(argv[1], NULL, 0);
// Parse forceState parameter, if given
if (argc >= 3) {
forceState = strtol(argv[2], NULL, 0);
if (forceState > 1 || forceState < -1) {
fputs(" Error: <force> can only be -1, 0, or 1.", stderr);
return 0;
}
}
// Parse apply parameter, if given
if (argc == 4) {
apply = strtol(argv[3], NULL, 0);
if (apply > 1 || apply < 0) {
fputs(" Error: <apply> can only be 0, or 1.", stderr);
return 0;
}
}
// Empty line for fun
puts("");
// Get Display Device
if (!EnumDisplayDevices(NULL, monitor_number-1, (DISPLAY_DEVICE*) &displayDeviceToggled, 0)) {
fprintf(stderr, " Error: Monitor number %d is not valid according to 'EnumDisplayDevices'.\r\n", monitor_number);
return 0;
}
// If user wants to toggle, we must get the state is it on or off.
if (forceState == -1) {
printf("Retrieving state of '%s' using 'EnumDisplaySettingsEx'...\r\n", displayDeviceToggled.DeviceName);
// Query the state
if (!EnumDisplaySettingsEx((LPSTR) displayDeviceToggled.DeviceName, ENUM_CURRENT_SETTINGS, ¤tMode, NULL)) {
// It is turned off most likely at the moment.
puts(" Monitor is currently detached.");
// Attach
forceState = 1;
} else {
puts(" Monitor is currently attached.");
// Detach
forceState = 0;
}
puts(" ^ If above statement is lie, you have to use <forceState>.");
puts("Ok.\n");
}
printf("Trying to change settings of '%s' using ChangeDisplaySettingsEx...\r\n", displayDeviceToggled.DeviceName);
// It's unwise to deal with Primary monitors
if (displayDeviceToggled.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE) {
puts("Sorry, this program does not allow to detach / reattach primary monitor.\r\n");
return 0;
}
// Detach or attach?
if (forceState == 0) {
puts(" Saving settings of monitor...");
if (!EnumDisplaySettingsEx((LPSTR) displayDeviceToggled.DeviceName, ENUM_REGISTRY_SETTINGS, ¤tRegistryMode, NULL))
return 0;
puts(" Detaching monitor...");
// Setting these, means "detaching" monitor Detaching code: http://support.microsoft.com/kb/306399
defaultMode.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_POSITION;
defaultMode.dmPelsWidth = 0;
defaultMode.dmPelsHeight = 0;
} else {
// Attaching code: http://support.microsoft.com/kb/308216
puts(" Attaching monitor...");
defaultMode.dmFields = DM_POSITION;
}
// Change the settings
if (!ChangeSettingsExResult(ChangeDisplaySettingsEx((LPSTR)displayDeviceToggled.DeviceName, &defaultMode, NULL, CDS_NORESET|CDS_UPDATEREGISTRY, NULL)))
return 0;
puts("Ok.\n");
// Second call applies the changes
if (apply == 1) {
puts("Trying to apply settings changes...");
if (!ChangeSettingsExResult(ChangeDisplaySettingsEx (NULL, NULL, NULL, 0, NULL)))
return 0;
puts("Ok.\n");
}
return 0;
}
static BOOL CALLBACK GLW_GetMonitorDisplayModes( HMONITOR mon, HDC dc, LPRECT rc, LPARAM userData )
{
int i;
DEVMODE mode;
MONITORINFOEX info;
int gl_level;
REF_PARAM( rc );
REF_PARAM( userData );
info.cbSize = sizeof( info );
GetMonitorInfo( mon, (LPMONITORINFO)&info );
gl_level = 3;//GLW_GetDisplayLevel( dc );
sql_bindtext( &com_db, 1, info.szDevice );
sql_bindint( &com_db, 2, info.rcMonitor.left );
sql_bindint( &com_db, 3, info.rcMonitor.top );
sql_bindint( &com_db, 4, info.rcMonitor.right - info.rcMonitor.left );
sql_bindint( &com_db, 5, info.rcMonitor.bottom - info.rcMonitor.top );
sql_bindint( &com_db, 6, gl_level );
sql_step( &com_db );
mode.dmSize = sizeof( mode );
mode.dmDriverExtra = 0;
for( i = 0; EnumDisplaySettingsEx( info.szDevice, i, &mode, 0 ) != 0; i++ )
{
int id;
if( mode.dmBitsPerPel < 16 )
continue;
if( mode.dmPelsWidth < 640 || mode.dmPelsHeight < 480 )
continue;
sql_prepare( &com_db, "UPDATE OR INSERT fsmodes SET id=#,w=?1,h=?2,dev_name=?3 SEARCH dev_name ?3 WHERE w=?1 AND h=?2" );
sql_bindint( &com_db, 1, (int)mode.dmPelsWidth );
sql_bindint( &com_db, 2, (int)mode.dmPelsHeight );
sql_bindtext( &com_db, 3, info.szDevice );
sql_step( &com_db );
sql_done( &com_db );
//get the id of what we just added
sql_prepare( &com_db, "SELECT id FROM fsmodes SEARCH dev_name ?3 WHERE w=?1 AND h=?2" );
sql_bindint( &com_db, 1, (int)mode.dmPelsWidth );
sql_bindint( &com_db, 2, (int)mode.dmPelsHeight );
sql_bindtext( &com_db, 3, info.szDevice );
sql_step( &com_db );
id = sql_columnasint( &com_db, 0 );
sql_done( &com_db );
//and insert the other info into the other table
sql_prepare( &com_db, "UPDATE OR INSERT fsmodes_ext SET id=?1,hz=?2,bpp=?3 SEARCH id ?1 WHERE hz=?2 AND bpp=?3" );
sql_bindint( &com_db, 1, id );
sql_bindint( &com_db, 2, (int)mode.dmDisplayFrequency );
sql_bindint( &com_db, 3, (int)mode.dmBitsPerPel );
sql_step( &com_db );
sql_done( &com_db );
}
return TRUE;
}
/**
*******************************************************************************
* @fn initializeDX11
* @brief Initialize DX11 device and object
*
* @return NOERROR on success Positive if expected and E_FAIL on failure
******************************************************************************/
int DX11Engine::initializeDX11(void)
{
int hrStatus = S_OK;
// Get all adapters
std::vector<IDXGIAdapter*> vAdapters;
unsigned int numAdapters;
IDXGIFactory* factory;
CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
IDXGIAdapter * pAdapter = 0;
UINT i = 0;
while(factory->EnumAdapters(i, &pAdapter) != DXGI_ERROR_NOT_FOUND)
{
vAdapters.push_back(pAdapter);
++i;
}
// Push NULL to vAdapters and assign zero to deviceId if adapter is not found
if(i == 0)
{
vAdapters.push_back(NULL);
}
numAdapters = i;
DISPLAY_DEVICE dispDevice;
DWORD deviceNum;
dispDevice.cb = sizeof(DISPLAY_DEVICE);
int xCoordinate = 0;
int yCoordinate = 0;
for (deviceNum = 0; EnumDisplayDevices(NULL, deviceNum, &dispDevice, 0); deviceNum++)
{
if (dispDevice.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER)
{
continue;
}
if(!(dispDevice.StateFlags & DISPLAY_DEVICE_ACTIVE))
{
continue;
}
DEVMODE deviceMode;
// initialize the DEVMODE structure
ZeroMemory(&deviceMode, sizeof(deviceMode));
deviceMode.dmSize = sizeof(deviceMode);
deviceMode.dmDriverExtra = 0;
EnumDisplaySettingsEx(dispDevice.DeviceName, ENUM_CURRENT_SETTINGS, &deviceMode, EDS_ROTATEDMODE);
xCoordinate = deviceMode.dmPosition.x;
yCoordinate = deviceMode.dmPosition.y;
// Register the window class
RegisterClassEx(&wc);
// Create the application's window
wndHandle = CreateWindow(reinterpret_cast<LPCSTR>(WINDOW_CLASS_NAME),
reinterpret_cast<LPCSTR>(CAPTION_NAME),
WS_CAPTION | WS_POPUPWINDOW,
false,
yCoordinate,
WINDOW_WIDTH,
WINDOW_HEIGHT,
NULL,
NULL,
wc.hInstance,
NULL);
D3D_FEATURE_LEVEL featureLevels[] =
{
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0
};
unsigned int totalFeatureLevels = ARRAYSIZE(featureLevels);
// Create a D3D Swap Chain and Device
DXGI_SWAP_CHAIN_DESC swapChainDesc;
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
swapChainDesc.BufferCount = 1;
swapChainDesc.BufferDesc.Width = meshWidth;
swapChainDesc.BufferDesc.Height = meshHeight;
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
swapChainDesc.BufferDesc.RefreshRate.Numerator = 60;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.OutputWindow = wndHandle;
swapChainDesc.Windowed = true;
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
unsigned int creationFlags = 0;
#ifdef _DEBUG
creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
hrStatus = D3D11CreateDeviceAndSwapChain(0,
D3D_DRIVER_TYPE_HARDWARE,
NULL,
creationFlags,
featureLevels,
totalFeatureLevels,
D3D11_SDK_VERSION,
&swapChainDesc,
&pSwapChain,
&pD3D11Device,
&featureLevel,
&pD3DContext
);
if(hrStatus != S_OK)
{
std::cout << "\nERROR : Failed to create D3D device" << std::endl;
return E_FAIL;
}
}
// Create a render target view
ID3D11Texture2D *pBackBuffer;
hrStatus = pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer);
if(FAILED(hrStatus))
{
std::cout << "GetBuffer failed." << std::endl;
return E_FAIL;
}
hrStatus = pD3D11Device->CreateRenderTargetView(pBackBuffer, NULL, &pRenderTargetView);
pBackBuffer->Release();
if(FAILED(hrStatus))
{
std::cout << "CreateRenderTargetView() failed" << std::endl;
return E_FAIL;
}
pD3DContext->OMSetRenderTargets(1, &pRenderTargetView, NULL);
// Create the viewport
D3D11_VIEWPORT vp;
vp.Width = static_cast<float>(meshWidth);
vp.Height = static_cast<float>(meshHeight);
vp.MinDepth = 0.0f;
vp.MaxDepth = 1.0f;
vp.TopLeftX = 0;
vp.TopLeftY = 0;
pD3DContext->RSSetViewports(1, &vp);
// Read vertex shader resource
BasicReader Reader;
auto vertexShaderByteCode = Reader.readBinaryFromFile("SimpleVertexShader.cso");
hrStatus = pD3D11Device->CreateVertexShader(
(void *)vertexShaderByteCode.data(),
(SIZE_T)vertexShaderByteCode.size(),
nullptr,
&pSolidColorVS
);
if(FAILED(hrStatus))
{
std::cout << "Create Vertex Shader failed" << std::endl;
return E_FAIL;
}
//Create and set IAInputLayout
D3D11_INPUT_ELEMENT_DESC vertexLayout[] =
{
{
"pos",
0,
DXGI_FORMAT_R32G32_FLOAT,
0,
0,
D3D11_INPUT_PER_VERTEX_DATA,
0
}
};
hrStatus = pD3D11Device->CreateInputLayout(
vertexLayout,
sizeof(vertexLayout) / sizeof(D3D11_INPUT_ELEMENT_DESC),
vertexShaderByteCode.data(),
vertexShaderByteCode.size(),
&pInputLayout
);
if(FAILED(hrStatus))
{
std::cout << "Create Input Layout failed" << std::endl;
return E_FAIL;
}
pD3DContext->IASetInputLayout(pInputLayout);
// Read pixel shader resource
auto pixelShaderBytecode = Reader.readBinaryFromFile("SimplePixelShader.cso");
hrStatus = pD3D11Device->CreatePixelShader(
pixelShaderBytecode.data(),
pixelShaderBytecode.size(),
NULL,
&pSolidColorPS
);
if(FAILED(hrStatus))
{
std::cout << "Create Pixel Shader failed" << std::endl;
return E_FAIL;
}
// Create Vertex buffer object
D3D11_BUFFER_DESC bufDesc;
bufDesc.ByteWidth = nVerticesNum * sizeof(XMFLOAT2);
bufDesc.CPUAccessFlags = 0;
bufDesc.Usage = D3D11_USAGE_DEFAULT;
bufDesc.MiscFlags = D3D11_RESOURCE_MISC_SHARED;
bufDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
hrStatus = pD3D11Device->CreateBuffer(&bufDesc, NULL, &pVertexBuffer);
if(FAILED(hrStatus))
{
std::cout << "CreateBuffer failed. (pVertexBuffer)" << std::endl;
return E_FAIL;
}
// Set vertex bufer
if(pVertexBuffer)
{
const UINT strides[] = {sizeof(XMFLOAT2)};
const UINT offsets[] = {0};
pD3DContext->IASetVertexBuffers(0, 1, &pVertexBuffer, strides, offsets);
}
// Set primitive topology
pD3DContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_LINELIST);
return NOERROR;
}
bool CWinSystemEGL::CreateNewWindow(const CStdString& name, bool fullScreen, RESOLUTION_INFO& res, PHANDLE_EVENT_FUNC userFunction)
{
#if defined(EMPOWER) && defined(HAS_OPENKODE)
KDboolean b;
KDDisplayModeNV mode;
KDint desktopSize[2] = { res.iWidth, res.iHeight };
#endif
#ifdef _WIN32
EGL_BASE_CLASS::CreateNewWindow(name, fullScreen, res, userFunction);
#endif
m_nWidth = res.iWidth;
m_nHeight = res.iHeight;
m_bFullScreen = fullScreen;
EGLBoolean eglStatus;
EGLint configCount;
EGLConfig* configList = NULL;
#if defined(EMPOWER) && defined(HAS_OPENKODE)
//CLog::Log(LOGDEBUG, "NV: GetDisplay");
m_kdDisplay = kdGetDisplayNV(KD_DEFAULT_DISPLAY_NV, KD_NULL);
if (!m_kdDisplay)
{
CLog::Log(LOGERROR, "Could not obtain KDDisplayNV pointer");
return false;
}
b = KD_FALSE;
//CLog::Log(LOGDEBUG, "NV: SetDisplayProperty");
kdSetDisplayPropertybvNV(m_kdDisplay, KD_DISPLAYPROPERTY_ENABLED_NV, &b);
kdReleaseDisplayNV(m_kdDisplay);
// MZL: enable HDMI display
//CLog::Log(LOGDEBUG, "NV: SetDisplayPropertybyNV");
kdSetDisplayPropertybvNV(m_kdDisplay, KD_DISPLAYPROPERTY_ENABLED_NV, &b);
m_kdDisplay = kdGetDisplayNV("Tegra:HDMI0", KD_NULL);
if (!m_kdDisplay)
{
CLog::Log(LOGERROR, "Could not obtain KDDisplayNV pointer");
return false;
}
b = KD_TRUE;
kdSetDisplayPropertybvNV(m_kdDisplay, KD_DISPLAYPROPERTY_ENABLED_NV, &b);
kdSetDisplayPropertycvNV(m_kdDisplay, KD_DISPLAYPROPERTY_DESKTOP_NAME_NV, KD_DEFAULT_DESKTOP_NV);
mode.width = res.iWidth;
mode.height = res.iHeight;
mode.refresh = 60;
//CLog::Log(LOGDEBUG, "NV: SetDisplayPropertyNV");
if (kdSetDisplayModeNV(m_kdDisplay, &mode, KD_DISPLAY_PROTOCOL_AUTOMATIC_NV))
{
CLog::Log(LOGERROR, "Could not set display mode\n");
return false;
}
//CLog::Log(LOGDEBUG, "NV: GetDesktopNV");
m_kdDesktop = kdGetDesktopNV(KD_DEFAULT_DESKTOP_NV, KD_NULL);
if (!m_kdDesktop)
{
CLog::Log(LOGERROR, "Could not obtain KDDesktopNV pointer");
return false;
}
//CLog::Log(LOGDEBUG, "NV: SetDesktopivNV");
if (kdSetDesktopPropertyivNV(m_kdDesktop, KD_DESKTOPPROPERTY_SIZE_NV, desktopSize))
{
CLog::Log(LOGERROR, "Could not set desktop size");
return false;
}
#endif
#ifdef HAS_X11
m_x11Display = XOpenDisplay(NULL);
if (!m_x11Display)
{
CLog::Log(LOGERROR, "Could not open X11");
return false;
}
XSetErrorHandler(ApplicationErrorHandler) ;
#endif
//CLog::Log(LOGDEBUG, "eglGetDisplay");
#if defined(HAS_OPENKODE) || defined(HAS_GDL)
m_display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
#elif defined(_WIN32)
m_display = eglGetDisplay(m_hDC);
#elif defined(HAS_X11)
m_display = eglGetDisplay((EGLNativeDisplayType) m_x11Display);
#endif
if (m_display == EGL_NO_DISPLAY)
{
CLog::Log(LOGERROR, "EGL failed to obtain display");
return false;
}
//CLog::Log(LOGDEBUG, "eglInitialize");
if (!eglInitialize(m_display, 0, 0))
{
CLog::Log(LOGERROR, "EGL failed to initialize");
return false;
}
EGLint configAttrs[] = {
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_DEPTH_SIZE, 16,
EGL_STENCIL_SIZE, 8,
EGL_SAMPLE_BUFFERS, 0,
EGL_SAMPLES, 0,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE
};
// Find out how many configurations suit our needs
//CLog::Log(LOGDEBUG, "eglChooseConfig");
eglStatus = eglChooseConfig(m_display, configAttrs, NULL, 0, &configCount);
if (!eglStatus || !configCount)
{
CLog::Log(LOGERROR, "EGL failed to return any matching configurations");
return false;
}
// Allocate room for the list of matching configurations
configList = (EGLConfig*)malloc(configCount * sizeof(EGLConfig));
if (!configList)
{
CLog::Log(LOGERROR, "kdMalloc failure obtaining configuration list");
return false;
}
// Obtain the configuration list from EGL
eglStatus = eglChooseConfig(m_display, configAttrs,
configList, configCount, &configCount);
if (!eglStatus || !configCount)
{
CLog::Log(LOGERROR, "EGL failed to populate configuration list");
return false;
}
// Select an EGL configuration that matches the native window
m_config = configList[0];
EGLint* attribList = NULL;
#ifdef EMPOWER
EGLint windowAttrs[3];
int windowIndex = 0;
windowAttrs[windowIndex++] = EGL_RENDER_BUFFER;
windowAttrs[windowIndex++] = EGL_BACK_BUFFER;
windowAttrs[windowIndex++] = EGL_NONE;
attribList = windowAttrs;
#endif
#ifdef HAS_OPENKODE
//CLog::Log(LOGDEBUG, "KD: kdCreateWindow");
m_kdWindow = kdCreateWindow(m_display, m_config, KD_NULL);
if (!m_kdWindow)
{
CLog::Log(LOGERROR, "Error creating native window");
return false;
}
//CLog::Log(LOGDEBUG, "KD: kdRealizeWindow");
if (kdRealizeWindow(m_kdWindow, &m_nativeWindow))
{
CLog::Log(LOGERROR, "Could not realize native window");
return false;
}
#elif defined HAS_X11
int screen = DefaultScreen(m_x11Display);
XSetWindowAttributes windowAttributes;
windowAttributes.colormap = DefaultColormap(m_x11Display, screen);
windowAttributes.border_pixel = 0;
windowAttributes.event_mask = ExposureMask |
VisibilityChangeMask |
KeyPressMask |
KeyReleaseMask |
ButtonPressMask |
ButtonReleaseMask |
PointerMotionMask |
StructureNotifyMask |
SubstructureNotifyMask |
FocusChangeMask;
m_nativeWindow = (NativeWindowType) XCreateWindow( m_x11Display,
RootWindow(m_x11Display, screen),
0, 0, // x/y position of top-left outside corner of the window
res.iWidth, res.iHeight, // Width and height of window
0, // Border width
DefaultDepth(m_x11Display, screen),
InputOutput,
DefaultVisual(m_x11Display, screen),
CWBorderPixel | CWColormap | CWEventMask,
&windowAttributes );
XSetStandardProperties(m_x11Display, (Window) m_nativeWindow, name, name, None, NULL, 0, NULL);
Atom wmDeleteMessage = XInternAtom(m_x11Display, "WM_DELETE_WINDOW", False);
XSetWMProtocols(m_x11Display, (Window) m_nativeWindow, &wmDeleteMessage, 1);
if (fullScreen && !SetFullScreen(fullScreen, res, false))
{
return false;
}
XMapRaised(m_x11Display, (Window) m_nativeWindow);
#endif
#ifdef _WIN32
m_nativeWindow = m_hWnd;
DEVMODE dm;
ZeroMemory(&dm, sizeof(dm));
dm.dmSize = sizeof(dm);
EnumDisplaySettingsEx(NULL, ENUM_CURRENT_SETTINGS, &dm, 0);
m_nLeft = (dm.dmPelsWidth / 2) - (m_nWidth / 2);
m_nTop = (dm.dmPelsHeight / 2) - (m_nHeight / 2);
RECT rc;
rc.left = m_nLeft;
rc.top = m_nTop;
rc.right = rc.left + m_nWidth;
rc.bottom = rc.top + m_nHeight;
AdjustWindowRect( &rc, WS_OVERLAPPEDWINDOW, false );
SetWindowPos(m_hWnd, 0, rc.left, rc.top, 0, 0, SWP_NOSIZE);
#endif
#if defined(HAS_GDL)
m_nativeWindow = (NativeWindowType)GDL_GRAPHICS_PLANE;
#endif
m_surface = eglCreateWindowSurface(m_display, m_config, m_nativeWindow, attribList);
if (!m_surface)
{
CLog::Log(LOGERROR, "EGL couldn't create window");
return false;
}
#ifdef CANMORE
eglStatus = eglBindAPI(EGL_OPENGL_ES_API);
if (!eglStatus)
{
CLog::Log(LOGERROR, "EGL failed to bind API");
return false;
}
#endif
EGLint contextAttrs[] =
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
// Create an EGL context
//CLog::Log(LOGDEBUG, "eglCreateContext");
m_context = eglCreateContext(m_display, m_config, NULL, contextAttrs);
if (!m_context)
{
CLog::Log(LOGERROR, "EGL couldn't create context");
return false;
}
// Make the context and surface current for rendering
eglStatus = eglMakeCurrent(m_display, m_surface, m_surface, m_context);
if (!eglStatus)
{
CLog::Log(LOGERROR, "EGL couldn't make context/surface current");
return false;
}
free(configList);
eglSwapInterval(m_display, 0);
m_bWindowCreated = true;
CLog::Log(LOGINFO, "Window creation complete");
return true;
}
HRESULT WINAPI
Main_DirectDraw_EnumDisplayModes(LPDDRAWI_DIRECTDRAW_INT This, DWORD dwFlags,
LPDDSURFACEDESC pDDSD, LPVOID pContext, LPDDENUMMODESCALLBACK pCallback)
{
HRESULT ret = DD_OK;
INT iMode = 0;
DEVMODE DevMode;
DX_WINDBG_trace();
ZeroMemory(&DevMode, sizeof(DEVMODE));
_SEH2_TRY
{
if (pDDSD != NULL)
{
if (pDDSD->dwSize != sizeof(DDSURFACEDESC))
{
ret = DDERR_INVALIDPARAMS;
}
}
if (IsBadCodePtr((LPVOID)pCallback))
{
ret = DDERR_INVALIDPARAMS;
}
else if ( ret == DD_OK)
{
DevMode.dmSize = sizeof(DEVMODE);
while (EnumDisplaySettingsEx(NULL, iMode, &DevMode, 0) == TRUE)
{
DDSURFACEDESC SurfaceDesc;
ZeroMemory(&SurfaceDesc, sizeof(DDSURFACEDESC));
iMode++;
SurfaceDesc.dwSize = sizeof (DDSURFACEDESC);
SurfaceDesc.dwFlags = DDSD_HEIGHT | DDSD_WIDTH | DDSD_REFRESHRATE | DDSD_WIDTH | DDSD_PIXELFORMAT;
SurfaceDesc.dwHeight = DevMode.dmPelsHeight;
SurfaceDesc.dwWidth = DevMode.dmPelsWidth;
SurfaceDesc.lPitch = DevMode.dmPelsWidth * DevMode.dmBitsPerPel / 8;
SurfaceDesc.dwRefreshRate = DevMode.dmDisplayFrequency;
SurfaceDesc.ddpfPixelFormat.dwSize = sizeof (DDPIXELFORMAT);
SurfaceDesc.ddpfPixelFormat.dwFlags = DDPF_RGB;
// FIXME: get these
/*
SurfaceDesc.ddpfPixelFormat.dwRBitMask =
SurfaceDesc.ddpfPixelFormat.dwGBitMask =
SurfaceDesc.ddpfPixelFormat.dwBBitMask =
SurfaceDesc.ddpfPixelFormat.dwRGBAlphaBitMask =
*/
SurfaceDesc.ddpfPixelFormat.dwRGBBitCount = DevMode.dmBitsPerPel;
// FIXME1: This->lpLcl->lpGbl->dwMonitorFrequency is not set !
if(dwFlags & DDEDM_REFRESHRATES && SurfaceDesc.dwRefreshRate != This->lpLcl->lpGbl->dwMonitorFrequency)
{
//continue; // FIXME2: what is SurfaceDesc.dwRefreshRate supposed to be set to ?
}
// FIXME: Take case when DDEDM_STANDARDVGAMODES flag is not set in account
if(pDDSD)
{
if(pDDSD->dwFlags & DDSD_HEIGHT && pDDSD->dwHeight != SurfaceDesc.dwHeight)
continue;
else if(pDDSD->dwFlags & DDSD_WIDTH && pDDSD->dwWidth != SurfaceDesc.dwWidth)
continue;
else if(pDDSD->dwFlags & DDSD_PITCH && pDDSD->lPitch != SurfaceDesc.lPitch)
continue;
else if(pDDSD->dwFlags & DDSD_REFRESHRATE && pDDSD->dwRefreshRate != SurfaceDesc.dwRefreshRate)
continue;
else if(pDDSD->dwFlags & DDSD_PIXELFORMAT && pDDSD->ddpfPixelFormat.dwRGBBitCount != SurfaceDesc.ddpfPixelFormat.dwRGBBitCount)
continue; // FIXME: test for the other members of ddpfPixelFormat as well
}
if((*pCallback)(&SurfaceDesc, pContext) == DDENUMRET_CANCEL)
break;
}
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_END;
return ret;
}