static void enumerateDecks(void)
{
uint8_t nDecks = 0;
bool noError = true;
owInit();
if (owScan(&nDecks))
{
DECK_INFO_DBG_PRINT("Found %d deck memor%s.\n", nDecks, nDecks>1?"ies":"y");
} else {
DEBUG_PRINT("Error scanning for deck memories, "
"no deck drivers will be initialised\n");
nDecks = 0;
}
#ifndef IGNORE_OW_DECKS
for (int i = 0; i < nDecks; i++)
{
DECK_INFO_DBG_PRINT("Enumerating deck %i\n", i);
if (owRead(i, 0, sizeof(deckInfos[0].raw), (uint8_t *)&deckInfos[i]))
{
if (infoDecode(&deckInfos[i]))
{
deckInfos[i].driver = findDriver(&deckInfos[i]);
printDeckInfo(&deckInfos[i]);
} else {
#ifdef DEBUG
DEBUG_PRINT("Deck %i has corrupt OW memory. "
"Ignoring the deck in DEBUG mode.\n", i);
deckInfos[i].driver = &dummyDriver;
#else
DEBUG_PRINT("Deck %i has corrupt OW memory. "
"No driver will be initialized!\n", i);
noError = false;
#endif
}
}
else
{
DEBUG_PRINT("Reading deck nr:%d [FAILED]. "
"No driver will be initialized!\n", i);
noError = false;
}
}
#else
DEBUG_PRINT("Ignoring all OW decks because of compile flag.\n");
nDecks = 0;
#endif
// Add build-forced driver
if (strlen(deck_force) > 0) {
DEBUG_PRINT("DECK_FORCE=%s found\n", deck_force);
//split deck_force into multiple, separated by colons, if available
char delim[] = ":";
char temp_deck_force[strlen(deck_force)];
strcpy(temp_deck_force, deck_force);
char * token = strtok(temp_deck_force, delim);
while (token) {
deck_force = token;
const DeckDriver *driver = deckFindDriverByName(deck_force);
if (!driver) {
DEBUG_PRINT("WARNING: compile-time forced driver %s not found\n", deck_force);
} else if (driver->init || driver->test) {
if (nDecks <= DECK_MAX_COUNT)
{
nDecks++;
deckInfos[nDecks - 1].driver = driver;
DEBUG_PRINT("compile-time forced driver %s added\n", deck_force);
} else {
DEBUG_PRINT("WARNING: No room for compile-time forced driver\n");
}
}
token = strtok(NULL, delim);
}
}
if (noError) {
count = nDecks;
}
return;
}
//---------------------------------------------------------------------
D3D9Device* D3D9DeviceManager::selectDevice(D3D9RenderWindow* renderWindow, D3D9RenderWindowList& renderWindowsGroup)
{
D3D9RenderSystem* renderSystem = static_cast<D3D9RenderSystem*>(Root::getSingleton().getRenderSystem());
D3D9Device* renderDevice = NULL;
IDirect3D9* direct3D9 = D3D9RenderSystem::getDirect3D9();
UINT nAdapterOrdinal = D3DADAPTER_DEFAULT;
D3DDEVTYPE devType = D3DDEVTYPE_HAL;
DWORD extraFlags = 0;
D3D9DriverList* driverList = renderSystem->getDirect3DDrivers();
bool nvAdapterFound = false;
// Default group includes at least the given render window.
renderWindowsGroup.push_back(renderWindow);
// Case we use nvidia performance HUD, override the device settings.
if (renderWindow->isNvPerfHUDEnable())
{
// Look for 'NVIDIA NVPerfHUD' adapter (<= v4)
// or 'NVIDIA PerfHUD' (v5)
// If it is present, override default settings
for (UINT adapter=0; adapter < direct3D9->GetAdapterCount(); ++adapter)
{
D3D9Driver* currDriver = driverList->item(adapter);
const D3DADAPTER_IDENTIFIER9& currAdapterIdentifier = currDriver->getAdapterIdentifier();
if(strstr(currAdapterIdentifier.Description, "PerfHUD") != NULL)
{
renderDevice = NULL;
nAdapterOrdinal = adapter;
renderSystem->mActiveD3DDriver = currDriver;
devType = D3DDEVTYPE_REF;
nvAdapterFound = true;
break;
}
}
}
// No special adapter should be used.
if (nvAdapterFound == false)
{
renderSystem->mActiveD3DDriver = findDriver(renderWindow);
nAdapterOrdinal = renderSystem->mActiveD3DDriver->getAdapterNumber();
bool bTryUsingMultiheadDevice = false;
if (renderWindow->isFullScreen())
{
bTryUsingMultiheadDevice = true;
if (renderSystem->getMultiheadUse() == D3D9RenderSystem::mutAuto)
{
OSVERSIONINFO osVersionInfo;
osVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
// Case version info failed -> assume we run on XP.
if (FALSE == GetVersionEx(&osVersionInfo))
{
osVersionInfo.dwMajorVersion = 5;
}
// XP and below - multi-head will cause artifacts when vsync is on.
if (osVersionInfo.dwMajorVersion <= 5 && renderWindow->isVSync())
{
bTryUsingMultiheadDevice = false;
LogManager::getSingleton().logMessage("D3D9 : Multi head disabled. It causes horizontal line when used in XP + VSync combination");
}
// Vista and SP1 or SP2 - multi-head device can not be reset - it causes memory corruption.
if (osVersionInfo.dwMajorVersion == 6 &&
(_stricmp(osVersionInfo.szCSDVersion, "Service Pack 1") == 0 ||
_stricmp(osVersionInfo.szCSDVersion, "Service Pack 2") == 0))
{
bTryUsingMultiheadDevice = false;
LogManager::getSingleton().logMessage("D3D9 : Multi head disabled. It causes application run time crashes when used in Vista + SP 1 or 2 combination");
}
}
else
{
bTryUsingMultiheadDevice = renderSystem->getMultiheadUse() == D3D9RenderSystem::mutYes ? true : false;
}
}
// Check if we can create a group of render windows
// on the same device using the multi-head feature.
if (bTryUsingMultiheadDevice)
{
const D3DCAPS9& targetAdapterCaps = renderSystem->mActiveD3DDriver->getD3D9DeviceCaps();
D3DCAPS9 masterAdapterCaps;
// Find the master device caps.
if (targetAdapterCaps.MasterAdapterOrdinal == targetAdapterCaps.AdapterOrdinal)
{
masterAdapterCaps = targetAdapterCaps;
}
else
{
for (uint i = 0; i < driverList->count(); ++i)
{
D3D9Driver* currDriver = driverList->item(i);
const D3DCAPS9& currDeviceCaps = currDriver->getD3D9DeviceCaps();
if (currDeviceCaps.AdapterOrdinal == targetAdapterCaps.MasterAdapterOrdinal)
{
masterAdapterCaps = currDeviceCaps;
break;
}
}
}
// Case the master adapter can handle multiple adapters.
if (masterAdapterCaps.NumberOfAdaptersInGroup > 1)
{
// Create empty list of render windows composing this group.
renderWindowsGroup.resize(masterAdapterCaps.NumberOfAdaptersInGroup);
for (uint i = 0; i < renderWindowsGroup.size(); ++i)
renderWindowsGroup[i] = NULL;
// Assign the current render window to it's place in the group.
renderWindowsGroup[targetAdapterCaps.AdapterOrdinalInGroup] = renderWindow;
// For each existing window - check if it belongs to the group.
for (uint i = 0; i < renderSystem->mRenderWindows.size(); ++i)
{
D3D9RenderWindow* currRenderWindow = renderSystem->mRenderWindows[i];
if (currRenderWindow->isFullScreen())
{
D3D9Driver* currDriver = findDriver(currRenderWindow);
const D3DCAPS9& currDeviceCaps = currDriver->getD3D9DeviceCaps();
if (currDeviceCaps.MasterAdapterOrdinal == masterAdapterCaps.AdapterOrdinal)
{
renderWindowsGroup[currDeviceCaps.AdapterOrdinalInGroup] = currRenderWindow;
break;
}
}
}
bool bDeviceGroupFull = true;
// Check if render windows group is full and ready to be driven by
// the master device.
for (uint i = 0; i < renderWindowsGroup.size(); ++i)
{
// This group misses required window -> go back to default.
if (renderWindowsGroup[i] == NULL)
{
bDeviceGroupFull = false;
renderWindowsGroup.clear();
renderWindowsGroup.push_back(renderWindow);
break;
}
}
// Case device group is full -> we can use multi head device.
if (bDeviceGroupFull)
{
bool validateAllDevices = false;
for (uint i = 0; i < renderWindowsGroup.size(); ++i)
{
D3D9RenderWindow* currRenderWindow = renderWindowsGroup[i];
D3D9Device* currDevice = currRenderWindow->getDevice();
// This is the master window
if (i == 0)
{
// If master device exists - just release it.
if (currDevice != NULL)
{
renderDevice = currDevice;
renderDevice->release();
}
}
// This is subordinate window.
else
{
// If subordinate device exists - destroy it.
if (currDevice != NULL)
{
currDevice->destroy();
validateAllDevices = true;
}
}
}
// In case some device was destroyed - make sure all other devices are valid.
// A possible scenario is that full screen window has been destroyed and it's handle
// was used and the shared focus handle. All other devices used this handle and must be
// recreated using other handles otherwise create device will fail.
if (validateAllDevices)
{
for (uint i = 0; i < mRenderDevices.size(); ++i)
mRenderDevices[i]->validateFocusWindow();
}
}
}
}
}
// Do we want to preserve the FPU mode? Might be useful for scientific apps
ConfigOptionMap& options = renderSystem->getConfigOptions();
ConfigOptionMap::iterator opti = options.find("Floating-point mode");
if (opti != options.end() && opti->second.currentValue == "Consistent")
extraFlags |= D3DCREATE_FPU_PRESERVE;
#if OGRE_THREAD_SUPPORT == 1
extraFlags |= D3DCREATE_MULTITHREADED;
#endif
// Try to find a matching device from current device list.
if (renderDevice == NULL)
{
for (uint i = 0; i < mRenderDevices.size(); ++i)
{
D3D9Device* currDevice = mRenderDevices[i];
if (currDevice->getAdapterNumber() == nAdapterOrdinal &&
currDevice->getDeviceType() == devType &&
currDevice->isFullScreen() == renderWindow->isFullScreen())
{
renderDevice = currDevice;
break;
}
}
}
// No matching device found -> try reference device type (might have been
// previously created as a fallback, but don't change devType because HAL
// should be preferred on creation)
if (renderDevice == NULL)
{
for (uint i = 0; i < mRenderDevices.size(); ++i)
{
D3D9Device* currDevice = mRenderDevices[i];
if (currDevice->getAdapterNumber() == nAdapterOrdinal &&
currDevice->getDeviceType() == D3DDEVTYPE_REF)
{
renderDevice = currDevice;
break;
}
}
}
// No matching device found -> create new one.
if (renderDevice == NULL)
{
renderDevice = OGRE_NEW D3D9Device(this, nAdapterOrdinal, direct3D9->GetAdapterMonitor(nAdapterOrdinal), devType, extraFlags);
mRenderDevices.push_back(renderDevice);
if (mActiveDevice == NULL)
setActiveDevice(renderDevice);
}
return renderDevice;
}
int install_cxmb( void )
{
int fd = sceIoOpen( CXMB_CONF_FILE, PSP_O_RDONLY, 0644 );
if ( fd < 0 )
{
log( "no conf file found!\n" );
fd = sceIoOpen( CXMB_CONF_FILE, PSP_O_RDWR | PSP_O_CREAT | PSP_O_TRUNC, 0777 );
if ( fd < 0 )
{
log( "failed in creating conf file!\n" );
return -1;
}
strcpy( theme_file, CXMB_DEFAULT_THEME );
sceIoWrite( fd, theme_file, strlen( theme_file ) + 1 );
}
readLine( fd, theme_file, 64 );
if ( truncpath( theme_file, ".ctf" ) < 0 )
{
if ( truncpath( theme_file, ".CTF" ) < 0 )
{
strcpy( theme_file, CXMB_DEFAULT_THEME );
}
}
sceIoClose( fd );
if ( endwithistr( theme_file, "random.ctf" ) )
{
log( "random\n" );
randomCtf( theme_file );
}
sprintf( cxmb_theme_file, "ms0:%s", theme_file );
log( "Theme file: %s\n", theme_file );
#if _CXMB_LITE == 0
makeCxmbThemeFile( cxmb_magic, cxmb_theme_file );
#endif
lflash_drv = findDriver( "flashfat" );
fatms_drv = findDriver( "fatms" );
if ( !lflash_drv || !fatms_drv )
return -1;
msIoOpen = fatms_drv->funcs->IoOpen;
msIoGetstat = fatms_drv->funcs->IoGetstat;
IoOpen = lflash_drv->funcs->IoOpen;
IoRead = lflash_drv->funcs->IoRead;
IoLseek = lflash_drv->funcs->IoLseek;
IoIoctl = lflash_drv->funcs->IoIoctl;
IoClose = lflash_drv->funcs->IoClose;
IoGetstat = lflash_drv->funcs->IoGetstat;
int intr = sceKernelCpuSuspendIntr();
fatms_drv->funcs->IoOpen = msIoOpen_new;
fatms_drv->funcs->IoGetstat = msIoGetstat_new;
lflash_drv->funcs->IoOpen = IoOpen_new;
lflash_drv->funcs->IoRead = IoRead_new;
lflash_drv->funcs->IoLseek = IoLseek_new;
lflash_drv->funcs->IoIoctl = IoIoctl_new;
lflash_drv->funcs->IoClose = IoClose_new;
lflash_drv->funcs->IoGetstat= IoGetstat_new;
sceKernelCpuResumeIntr( intr );
sceKernelIcacheInvalidateAll();
sceKernelDcacheWritebackInvalidateAll();
sceIoOpen( "ms0:/dummy.prx", PSP_O_RDONLY, 0644 );
log( "redirected io_driver!\n" );
log( "ms_drv_arg: %08x\n", ( unsigned int )ms_drv );
previous = setStartModuleHandler( OnModuleStart );
log("startModuleHandler setup!\n");
fd = sceIoOpen( cxmb_theme_file, PSP_O_RDONLY, 0644 );
if ( fd < 0 )
{
log( "no ctf file found!\n" );
return 0;
}
mem_id = sceKernelCreateHeap( 2, 1024 * 5 , 1, "cxmb_heap");
if ( mem_id < 0 )
{
log( "failed in creating cxmb_heap!\n" );
sceIoClose( fd );
return -1;
}
unsigned int magic;
sceIoLseek( fd, 0x10, PSP_SEEK_SET );
sceIoRead( fd, &magic, 4 );
if ( magic != cxmb_magic )
{
log( "magic not match!\n" );
sceIoClose( fd );
return -1;
}
sceIoRead( fd, &ctf_sig, 4 );
sceIoRead( fd, &header_size, 4 );
log( "header size: %d\n", header_size );
ctf_header = sceKernelAllocHeapMemory( mem_id, sizeof( CtfHeader ) * header_size );
int offset = - sizeof( CtfHeader ) * header_size;
sceIoLseek( fd, offset, PSP_SEEK_END );
sceIoRead( fd, ctf_header, sizeof( CtfHeader ) * header_size );
sceIoClose( fd );
log( "read ctf_header!\n" );
ctf_handler = sceKernelAllocHeapMemory( mem_id, sizeof( CtfHandler ) * 32 );
memset( ctf_handler, 0, sizeof( CtfHandler ) * 32 );
return 0;
}
