static void spritesUpdate( )
{
if (done)
{
setCurrentScreen(TITLE_SCREEN);
return;
}
if (SMS_queryPauseRequested()) {
paused = !paused;
SMS_resetPauseRequest();
}
if (!paused)
{
JOY_update();
//sprite update
}
SMS_initSprites();
//addMetaSprite(&hawk);
SMS_finalizeSprites();
SMS_copySpritestoSAT( );
}
void KRandRModule::slotScreenChanged(int screen)
{
setCurrentScreen(screen);
// Clear resolutions
m_sizeCombo->clear();
// Add new resolutions
for (int i = 0; i < currentScreen()->numSizes(); i++) {
m_sizeCombo->insertItem(i18n("%1 x %2").arg(currentScreen()->pixelSize(i).width()).arg(currentScreen()->pixelSize(i).height()));
// Aspect ratio
/* , aspect ratio %5)*/
/*.arg((double)currentScreen()->size(i).mwidth / (double)currentScreen()->size(i).mheight))*/
}
// Clear rotations
for (int i = m_rotationGroup->count() - 1; i >= 0; i--)
m_rotationGroup->remove(m_rotationGroup->find(i));
// Create rotations
for (int i = 0; i < RandRScreen::OrientationCount; i++)
addRotationButton(1 << i, i > RandRScreen::RotationCount - 1);
populateRefreshRates();
update();
setChanged();
}
void Game::resumeGame()
{
CCDirector::sharedDirector()->getScheduler()->resumeTargets(pausedTargets);
pausedTargets->release();
pausedTargets = 0;
setCurrentScreen(GAME_SCREEN);
}
void MoSyncCamController::displayMainScreen()
{
if ( !isDisplayed(*mCameraScreen) )
{
mCameraScreen->show();
setCurrentScreen(*mCameraScreen);
}
}
void Game::pauseGame(bool showLayer)
{
// TODO show pause layer
pausedTargets = CCDirector::sharedDirector()->getScheduler()->pauseAllTargetsWithMinPriority(kCCPriorityNonSystemMin);
pausedTargets->retain();
if(showLayer){
CCDirector::sharedDirector()->getRunningScene()->addChild(new PauseLayer, 100500);
}
setCurrentScreen(PAUSE_SCREEN);
}
void MoSyncCamController::imageViewingDone()
{
if ( !isDisplayed(*mCameraScreen) )
{
mCameraScreen->showWithTransition(mBackwardTransition, SCREEN_TRANSITION_DURATION);
if ( mDisplayedImageHandle > 0 )
{
maDestroyPlaceholder(mDisplayedImageHandle);
mDisplayedImageHandle = 0;
}
setCurrentScreen(*mCameraScreen);
}
}
static void
selectCurrentScreen (void) {
const SpecialScreenEntry *sse = specialScreenTable;
const SpecialScreenEntry *end = sse + specialScreenCount;
while (sse < end) {
if (sse->isActive) break;
sse += 1;
}
if (sse == end) {
logMainScreenAction("selecting");
setCurrentScreen(&mainScreen.base);
} else {
setSpecialScreen(sse);
}
}
void Game::starNewGame(Player* player1, Player* player2, bool restart)
{
CCScene *pScene = GameLayer::scene();
GameLayer* gameLayer = (GameLayer*)pScene->getChildByTag(1337);
if(!restart) {
addPlayer(player1);
addPlayer(player2);
}
gameLayer->startGame(player1, player2);
if(CCDirector::sharedDirector()->getRunningScene()){
CCDirector::sharedDirector()->replaceScene(pScene);
}else{
CCDirector::sharedDirector()->runWithScene(pScene);
}
setCurrentScreen(GAME_SCREEN);
currentGameType = player2->isAI() ? VS_AI : VS_HUMAN;
}
void MoSyncCamController::snapshotDisplayRequested()
{
if ( !isDisplayed(*mImageViewerScreen) )
{
if ( mLastSnapshotDataHandle > 0 )
{
mDisplayedImageHandle = maCreatePlaceholder();
maCreateImageFromData(
mDisplayedImageHandle,
mLastSnapshotDataHandle,
0,
maGetDataSize(mLastSnapshotDataHandle));
mImageViewerScreen->setImageWithData(mDisplayedImageHandle);
mImageViewerScreen->showWithTransition(mForwardTransition, SCREEN_TRANSITION_DURATION);
setCurrentScreen(*mImageViewerScreen);
}
}
}
void VRScreenManager::add(VRScreen* screen) {
string name = screen->getName();
screens[name] = screen;
if (screens.size()<=1)
setCurrentScreen(name);
}
RandRDisplay::RandRDisplay()
: m_valid(true)
{
//m_dpy = XOpenDisplay(NULL);
m_dpy = QX11Info::display();
// Check extension
if(XRRQueryExtension(m_dpy, &m_eventBase, &m_errorBase) == False) {
m_valid = false;
return;
}
int major_version, minor_version;
XRRQueryVersion(m_dpy, &major_version, &minor_version);
m_version = QObject::tr("X Resize and Rotate extension version %1.%2").arg(major_version).arg(minor_version);
qDebug() << major_version << minor_version << m_version;
// check if we have the new version of the XRandR extension
RandR::has_1_2 = (major_version > 1 || (major_version == 1 && minor_version >= 2));
RandR::has_1_3 = (major_version > 1 || (major_version == 1 && minor_version >= 3));
if(RandR::has_1_3)
qDebug() << "Using XRANDR extension 1.3 or greater.";
else if(RandR::has_1_2)
qDebug() << "Using XRANDR extension 1.2.";
else
qDebug() << "Using legacy XRANDR extension (1.1 or earlier).";
qDebug() << "XRANDR error base: " << m_errorBase;
qDebug() << m_dpy;
m_numScreens = ScreenCount(m_dpy);
// m_numScreens = m_dpy->nscreens;
m_currentScreenIndex = 0;
// set the timestamp to 0
RandR::timestamp = 0;
// This assumption is WRONG with Xinerama
// Q_ASSERT(QApplication::desktop()->numScreens() == ScreenCount(QX11Info::display()));
for (int i = 0; i < m_numScreens; i++)
{
#ifdef HAS_RANDR_1_2
if (RandR::has_1_2)
m_screens.append(new RandRScreen(i));
else
#endif
m_legacyScreens.append(new LegacyRandRScreen(i));
}
#if 0
//#ifdef HAS_RANDR_1_2
// check if we have more than one output, if no, revert to the legacy behavior
if (RandR::has_1_2)
{
int count = 0;
foreach(RandRScreen *screen, m_screens)
count += screen->outputs().count();
if (count < 2)
{
RandR::has_1_2 = false;
for (int i = 0; i < m_numScreens; ++i)
{
delete m_screens[i];
m_legacyScreens.append(new LegacyRandRScreen(i));
}
m_screens.clear();
}
}
#endif
setCurrentScreen(DefaultScreen(QX11Info::display()));
}
static void
setSpecialScreen (const SpecialScreenEntry *sse) {
logSpecialScreenAction(sse, "selecting");
setCurrentScreen(sse->base);
}
void Game::run() {
std::cout << "Running game " << m_gameName << std::endl;
m_isRunning = (m_currentScreen != nullptr);
if (m_currentScreen) {
m_currentScreen->onEntry();
}
// FPS / Time variables
unsigned int previousCumulatedTime = SDL_GetTicks();
unsigned int startFrameTime;
unsigned int elapseTime = 0;
unsigned int deltaTime = 0;
int delayTime;
unsigned int cumulatedElapseTime = 0;
unsigned int frameCounter = 0;
// Setting a FPS Cap higher than 400 seems to not be accurate (due to SDL_Delay)
const float capFPS = 60.0f;
const float capElapseTime = 1000.0f / capFPS;
float actualFPS = 0.0f;
// Game loop
while (m_isRunning) {
startFrameTime = SDL_GetTicks();
frameCounter++;
processEvents();
// Update callback
m_currentScreen->onUpdate(deltaTime);
// Clear buffers
glClearDepth(1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Render callback
m_currentScreen->onRender();
// Swap back and front buffers (display)
m_window->swapBuffers();
// Display FPS every 2 sec
cumulatedElapseTime = SDL_GetTicks() - previousCumulatedTime;
if (cumulatedElapseTime > 2000) {
actualFPS = frameCounter / (float)cumulatedElapseTime * 1000.0f;
frameCounter = 0;
previousCumulatedTime = SDL_GetTicks();
printf("FPS: %f\n", actualFPS);
}
// FPS and elapse time updates
elapseTime = SDL_GetTicks() - startFrameTime;
// FPS Capping
delayTime = static_cast<int>(capElapseTime - elapseTime);
// Delay only if it is for more than 2ms
if (delayTime > 2) {
SDL_Delay(delayTime);
}
deltaTime = SDL_GetTicks() - startFrameTime;
// Check current screen state
if (m_currentScreen->getState() == ScreenState::GO_NEXT) {
m_currentScreen->onExit();
m_currentScreen->setState(ScreenState::INACTIVE);
setCurrentScreen(m_currentScreen->getNext());
if (m_currentScreen) {
m_currentScreen->onEntry();
m_currentScreen->setState(ScreenState::ACTIVE);
}
else {
//TODO: Log in case the screen doesn't exist
m_isRunning = false;
}
}
}
// Screen cleanup
for (auto scr : m_screens) {
scr.second->destroy();
}
// Exit callback
onExit();
IMG_Quit();
m_window->destroy();
}
