/*virtual*/ void Framework3D::RefreshDisplay( const bool Fullscreen, const uint DisplayWidth, const uint DisplayHeight )
{
XTRACE_FUNCTION;
PRINTF( "Framework3D::RefreshDisplay %s %d %d\n", Fullscreen ? "true" : "false", DisplayWidth, DisplayHeight );
ASSERT( m_Display );
m_Display->SetFullScreen( Fullscreen );
m_Display->SetResolution( DisplayWidth, DisplayHeight );
m_Display->UpdateDisplay();
// HACKHACK: SDL
m_Window->SetFullscreen( false );
RefreshWindowSize();
// HACKHACK: SDL
m_Window->SetFullscreen( Fullscreen );
ASSERT( m_Renderer );
m_Renderer->SetFullScreen( m_Display->m_Fullscreen );
m_Renderer->Reset();
if( m_TargetManager )
{
m_TargetManager->ReleaseTargets();
m_TargetManager->CreateTargets( m_Display->m_Width, m_Display->m_Height );
}
ASSERT( m_UIManager );
m_UIManager->Reinitialize();
}
/*virtual*/ void Framework3D::ToggleFullscreen()
{
bool NewFullScreen = !m_Display->m_Fullscreen;
// HACKHACK: At least for now, Linux doesn't do fullscreen at non desktop resolutions well.
// So switch to desktop res when going fullscreen.
#if BUILD_LINUX
if( NewFullScreen )
{
SetResolution( m_Display->m_ScreenWidth, m_Display->m_ScreenHeight );
}
#endif
PRINTF( "Framework3D::ToggleFullscreen %s\n", NewFullScreen ? "true" : "false" );
if( !NewFullScreen &&
( m_Display->m_Width > m_Display->m_ScreenWidth ||
m_Display->m_Height > m_Display->m_ScreenHeight ) )
{
PRINTF( "Automatically setting resolution to screen size.\n" );
SetResolution( m_Display->m_ScreenWidth, m_Display->m_ScreenHeight );
}
m_Display->SetFullScreen( NewFullScreen );
m_Display->UpdateDisplay();
m_Window->SetFullscreen( NewFullScreen );
m_Renderer->SetFullScreen( NewFullScreen );
m_Renderer->Reset();
// Set size after resetting renderer to be sure screen-to-client transform is correct
RefreshWindowSize();
}
void ILConsoleGetBufferSize(ILInt32 *width, ILInt32 *height)
{
if(windowSizeChanged)
{
RefreshWindowSize();
}
*width = screenWidth;
*height = screenHeight;
}
void ILConsoleGetWindowSize(ILInt32 *left, ILInt32 *top,
ILInt32 *width, ILInt32 *height)
{
if(windowSizeChanged)
{
RefreshWindowSize();
}
*left = 0;
*top = 0;
*width = screenWidth;
*height = screenHeight;
}
/*virtual*/ void Framework3D::SetResolution( const uint DisplayWidth, const uint DisplayHeight )
{
// HACKHACK: At least for now, Linux doesn't do fullscreen at non desktop resolutions well.
// So if we're in fullscreen mode, promote all resolution changes to desktop resolution.
#if BUILD_LINUX
if( m_Display->m_Fullscreen &&
( DisplayWidth != m_Display->m_ScreenWidth || DisplayHeight != m_Display->m_ScreenHeight ) )
{
SetResolution( m_Display->m_ScreenWidth, m_Display->m_ScreenHeight );
return;
}
#endif
PRINTF( "Framework3D::SetResolution %d %d\n", DisplayWidth, DisplayHeight );
ASSERT( DisplayWidth <= m_Display->m_ScreenWidth || m_Display->m_Fullscreen );
ASSERT( DisplayHeight <= m_Display->m_ScreenHeight || m_Display->m_Fullscreen );
m_Display->SetResolution( DisplayWidth, DisplayHeight );
m_Display->UpdateDisplay();
// HACKHACK: SDL
m_Window->SetFullscreen( false );
RefreshWindowSize();
// HACKHACK: SDL
m_Window->SetFullscreen( m_Display->m_Fullscreen );
m_Renderer->Reset();
if( m_TargetManager )
{
m_TargetManager->ReleaseTargets();
m_TargetManager->CreateTargets( m_Display->m_Width, m_Display->m_Height );
}
m_UIManager->Reinitialize();
}
void ILConsoleReadKey(ILUInt16 *ch, ILInt32 *key, ILInt32 *modifiers)
{
fd_set readSet;
struct timeval tv;
struct timeval *tvp;
int result, c, posn;
int len, prefixMatch;
for(;;)
{
/* Turn pending signals into special key codes */
if(processResumed)
{
processResumed = 0;
*ch = 0;
*key = Key_Resumed;
*modifiers = 0;
return;
}
if(windowSizeChanged)
{
RefreshWindowSize();
windowSizeChanged = 0;
*ch = 0;
*key = Key_SizeChanged;
*modifiers = 0;
return;
}
if(interruptSeen)
{
interruptSeen = 0;
*ch = 0;
*key = Key_Interrupt;
*modifiers = 0;
return;
}
/* Wait for an incoming character */
FD_ZERO(&readSet);
FD_SET(0, &readSet);
if(keyBufferLen > 0)
{
tv.tv_sec = 0;
tv.tv_usec = 300000;
tvp = &tv;
}
else
{
tvp = (struct timeval *)0;
}
result = select(1, &readSet, (fd_set *)0, (fd_set *)0, tvp);
if(result > 0)
{
/* There is something waiting in the stdin input buffer */
if(read(0, keyBuffer + keyBufferLen, 1) == 1)
{
++keyBufferLen;
prefixMatch = 0;
for(posn = 0; posn < NumSpecialKeys; ++posn)
{
if(SpecialKeyStrings[posn] &&
SpecialKeyStrings[posn][0] == keyBuffer[0])
{
/* We have a potential prefix match */
len = strlen(SpecialKeyStrings[posn]);
if(len <= keyBufferLen &&
!ILMemCmp(keyBuffer, SpecialKeyStrings[posn], len))
{
/* Found a special key */
if(len == 1)
{
/* Return the underlying character if the
key only has one associated with it */
*ch = (ILUInt16)(keyBuffer[0] & 0xFF);
}
else
{
*ch = 0;
}
if(keyBufferLen > len)
{
ILMemMove(keyBuffer, keyBuffer + len,
keyBufferLen - len);
}
keyBufferLen -= len;
*key = SpecialKeys[posn].key;
*modifiers = SpecialKeys[posn].modifiers;
return;
}
else if(len > keyBufferLen &&
!ILMemCmp(keyBuffer,
SpecialKeyStrings[posn],
keyBufferLen))
{
/* The buffer contains an entire key prefix */
prefixMatch = 1;
}
}
}
if(!prefixMatch && keyBufferLen >= 2 && keyBuffer[0] == '\033')
{
/* This is probably a meta-character indication */
goto meta;
}
if(!prefixMatch || keyBufferLen >= KEY_BUFFER_SIZE)
{
/* No prefix match, so we have a normal character */
goto normalChar;
}
}
}
else if(result < 0 && errno == EINTR)
{
/* The system call was interrupted by a signal, so retry */
continue;
}
else if(result < 0)
{
/* Some kind of error occurred */
break;
}
else if(keyBufferLen >= 2 && keyBuffer[0] == '\033')
{
/* We got a timeout with at least two characters in the
lookahead buffer where the first is an Escape character.
This is probably a metacharacter indication. e.g. ESC-A
is the same as ALT-A */
meta:
c = (((int)(keyBuffer[1])) & 0xFF);
keyBufferLen -= 2;
if(keyBufferLen > 0)
{
ILMemMove(keyBuffer, keyBuffer + 2, keyBufferLen);
}
*ch = 0;
MapCharToKey(c, key, modifiers);
*modifiers |= Mod_Alt;
return;
}
else if(keyBufferLen > 0)
{
/* We got a timeout while processing lookahead characters.
Extract the first character from the buffer and return it.
It will normally be an Escape character, indicating the
actual Escape key rather than the start of a special key */
normalChar:
c = (((int)(keyBuffer[0])) & 0xFF);
--keyBufferLen;
if(keyBufferLen > 0)
{
ILMemMove(keyBuffer, keyBuffer + 1, keyBufferLen);
}
*ch = (ILUInt16)c;
MapCharToKey(c, key, modifiers);
return;
}
}
*ch = 0;
*key = 0;
*modifiers = 0;
}
