bool GameSingleStage::onEvent( int event , int id , GWidget* ui )
{
switch ( id )
{
case UI_PAUSE_GAME :
togglePause();
return false;
case UI_GAME_MENU:
if ( event == EVT_BOX_YES )
{
saveReplay( LAST_REPLAY_NAME );
getManager()->changeStage( STAGE_GAME_MENU );
return true;
}
else if ( event == EVT_BOX_NO )
{
togglePause();
return false;
}
else
{
togglePause();
::Global::getGUI().showMessageBox( UI_GAME_MENU , LAN("Back Game Menu?") );
return false;
}
break;
case UI_RESTART_GAME:
if ( event == EVT_BOX_YES )
{
restart( false );
return false;
}
else if ( event == EVT_BOX_NO )
{
}
else
{
if ( getState() != GS_END )
{
::Global::getGUI().showMessageBox(
UI_RESTART_GAME , LAN("Do you Want to Stop Current Game?") );
}
else
{
restart( false );
}
return false;
}
break;
}
return BaseClass::onEvent( event , id , ui );
}
int Playengine::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: volume((*reinterpret_cast< int(*)>(_a[1]))); break;
case 1: statusChanged((*reinterpret_cast< Playengine::STATUS(*)>(_a[1]))); break;
case 2: buffering((*reinterpret_cast< int(*)>(_a[1]))); break;
case 3: tick((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 4: togglePause(); break;
case 5: play((*reinterpret_cast< const QUrl(*)>(_a[1]))); break;
case 6: stop(); break;
case 7: setVolume((*reinterpret_cast< int(*)>(_a[1]))); break;
case 8: stateChanged((*reinterpret_cast< Phonon::State(*)>(_a[1])),(*reinterpret_cast< Phonon::State(*)>(_a[2]))); break;
case 9: tickslot((*reinterpret_cast< qint64(*)>(_a[1]))); break;
case 10: sourceChanged((*reinterpret_cast< const Phonon::MediaSource(*)>(_a[1]))); break;
case 11: metaStateChanged((*reinterpret_cast< Phonon::State(*)>(_a[1])),(*reinterpret_cast< Phonon::State(*)>(_a[2]))); break;
case 12: aboutToFinish(); break;
case 13: bufferPercent((*reinterpret_cast< int(*)>(_a[1]))); break;
case 14: volumeChanged((*reinterpret_cast< qreal(*)>(_a[1]))); break;
default: ;
}
_id -= 15;
}
return _id;
}
void HeriswapGame::tick(float dt) {
PROFILE("Game", "Tick", BeginEvent);
sceneStateMachine.update(dt);
// update state
//datas->newState = datas->state2Manager[datas->state]->Update(dt);
//update only if game has really begun (after countdown)
switch (sceneStateMachine.getCurrentState()) {
case Scene::UserInput:
case Scene::Delete:
case Scene::Fall:
case Scene::Spawn:
case Scene::LevelChanged:
//updating gamemode
datas->mode2Manager[datas->mode]->GameUpdate(dt, sceneStateMachine.getCurrentState());
break;
default:
break;
}
LOGT_EVERY_N(600, "TBD in Pause (prolly)");
#if 0
//si on est passé de pause à quelque chose different de pause, on desactive la pause
if (datas->state == Pause && datas->newState == Unpause) {
togglePause(false);
}
#endif
LOGT_EVERY_N(600, "State change action must be done in states respective onEnter/onExit methods");
#if 0
//si on a change d'etat
else if (datas->newState != datas->state) {
void MainWindow::initMenu()
{
QMenu *fileMenu = new QMenu("File", this);
QAction *saveAction = new QAction("Save", fileMenu);
QAction *loadAction = new QAction("Load", fileMenu);
QAction *playAction = new QAction("Play", fileMenu);
//QAction *logAction = new QAction("Show log", fileMenu);
saveAction->setShortcut(QKeySequence::Save);
loadAction->setShortcut(QKeySequence("Ctrl+L"));
playAction->setShortcut(QKeySequence("Space"));
fileMenu->addAction(saveAction);
fileMenu->addAction(loadAction);
fileMenu->addAction(playAction);
//fileMenu->addAction(logAction);
menuBar()->addMenu(fileMenu);
connect(saveAction, SIGNAL(triggered()), filesList, SLOT(save()));
connect(loadAction, SIGNAL(triggered()), filesList, SLOT(load()));
connect(playAction, SIGNAL(triggered()), player, SLOT(togglePause()));
//connect(logAction, SIGNAL(triggered()), SLOT(showLog()));
// add "About" item
QMenu *helpMenu = new QMenu(tr("&Help"), this);
QAction *aboutAction = helpMenu->addAction(tr("&About"));
connect(aboutAction, SIGNAL(triggered()), this, SLOT(showAbout()));
menuBar()->addMenu(helpMenu);
}
/* function to handle key press events */
void Framework::handleKeyPress(SDL_keysym *keysym)
{
switch (keysym->sym)
{
case SDLK_q:
shutdown();
break;
case SDLK_f:
SDL_WM_ToggleFullScreen(surface);
break;
case SDLK_ESCAPE:
case SDLK_p:
togglePause(false, false);
break;
case SDLK_F1:
camera.setMode((Camera::View)1);
break;
case SDLK_F2:
camera.setMode((Camera::View)2);
break;
case SDLK_F3:
camera.setMode((Camera::View)3);
break;
default:
break;
}
}
void
Tetris::endOfGame()
{
if (paused) togglePause();
gtk_action_set_sensitive (pause_action, FALSE);
gtk_action_set_sensitive (end_game_action, FALSE);
gtk_action_set_sensitive (preferences_action, TRUE);
color_next = -1;
blocknr_next = -1;
rot_next = -1;
preview->previewBlock(-1, -1, -1);
gtk_widget_queue_draw(preview->getWidget());
field->hidePauseMessage();
field->showGameOverMessage();
games_sound_play ("gameover");
inPlay = false;
if (scoreFrame->getScore() > 0)
{
int pos = high_scores->add (scoreFrame->getScore());
high_scores->show (GTK_WINDOW (w), pos);
}
field->setUseTarget (false);
}
// if playingfield loses keyboard focus, pause game
void Tron::focusOutEvent(QFocusEvent *)
{
if(!gameEnded && !gamePaused)
{
togglePause();
}
}
void BoxCar::handleEvent( SDL_Event& event )
{
switch (event.type)
{
case SDL_QUIT:
quit();
break;
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
case SDL_MOUSEMOTION:
Renderer::getInstance().handleGUIEvent(event);
break;
case SDL_KEYDOWN:
Renderer::getInstance().handleKeyboardEvent(event);
if (event.key.keysym.sym == SDLK_SPACE) {
togglePause();
}
if (Renderer::getInstance().hasKeyboardListener()) {
break;
}
if (event.key.keysym.sym == SDLK_a) {
speedUp();
}
if (event.key.keysym.sym == SDLK_d) {
speedDown();
}
break;
case SDL_VIDEORESIZE:
Renderer::getInstance().resize(event.resize.w, event.resize.h);
break;
default:
break;
}
}
VOID GamePlayKeyDown(HWND hWnd, WPARAM wParam, LPARAM lParam)
{
if (lParam & 1 << 30)
return;
gameTimePass = global.timePass();
switch (wParam)
{
case '5': case 'D':
if (!global.isGamePaused)
{
DoJump(0);
InvalidateRect(hWnd, NULL, FALSE);
}
break;
case 'T': case 'F':
if (!global.isGamePaused)
{
DoJump(1);
InvalidateRect(hWnd, NULL, FALSE);
}
break;
case 'G': case 'J':
if (!global.isGamePaused)
{
DoJump(2);
InvalidateRect(hWnd, NULL, FALSE);
}
break;
case 'B': case 'K':
if (!global.isGamePaused)
{
DoJump(3);
InvalidateRect(hWnd, NULL, FALSE);
}
break;
case VK_SPACE:
togglePause();
break;
case VK_F3:
settings.showAccuracyIndicator = !settings.showAccuracyIndicator;
break;
case VK_ESCAPE:
PreviewSong();
global.status = global.GS_SONGSELECT;
break;
default:
break;
}
}
void Logstalgia::keyPress(SDL_KeyboardEvent *e) {
if (e->type == SDL_KEYDOWN) {
if (e->keysym.sym == SDLK_ESCAPE) {
appFinished=true;
}
if(e->keysym.sym == SDLK_q) {
info = !info;
}
if(e->keysym.sym == SDLK_c) {
gSplash = 10.0f;
}
if(e->keysym.sym == SDLK_n) {
next = true;
}
if(e->keysym.sym == SDLK_SPACE) {
togglePause();
}
if(e->keysym.sym == SDLK_EQUALS || e->keysym.sym == SDLK_KP_PLUS) {
if(simu_speed<=29.0f) {
simu_speed += 1.0f;
recentre=true;
}
}
if(e->keysym.sym == SDLK_MINUS || e->keysym.sym == SDLK_KP_MINUS) {
if(simu_speed>=2.0f) {
simu_speed -= 1.0f;
recentre=true;
}
}
if(e->keysym.sym == SDLK_PERIOD) {
if(time_scale>=1.0) {
time_scale = std::min(4.0f, floorf(time_scale) + 1.0f);
} else {
time_scale = std::min(1.0f, time_scale * 2.0f);
}
}
if(e->keysym.sym == SDLK_COMMA) {
if(time_scale>1.0) {
time_scale = std::max(0.0f, floorf(time_scale) - 1.0f);
} else {
time_scale = std::max(0.25f, time_scale * 0.5f);
}
}
}
}
// Resume the paused RTMP stream
double
Handler::resumeStream(double streamid)
{
GNASH_REPORT_FUNCTION;
togglePause(streamid);
return -1;
}
//TODO: Make a method for loading a demo - restartDemo should call that method.
void DemosFramework::restartDemo()
{
delete CurrentDemo;
CurrentDemo = new Demo1();
CurrentDemo->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
GLLayout->addWidget(CurrentDemo);
QObject::connect(PauseButton, SIGNAL(clicked()), CurrentDemo, SLOT(togglePause()));
QObject::connect(CurrentDemo, SIGNAL(fpsChanged(int)), FPSNumLabel, SLOT(setNum(int)));
}
void Graphical_UI::pause(bool pause_on) {
Q_EMIT togglePause();
if(pause_on) {
QString message = tr("Processing.");
statusBar()->showMessage(message);
} else {
QString message = tr("Stopped processing.");
statusBar()->showMessage(message);
}
}
void MainWindow::createConnections()
{
connect(this, SIGNAL(windowWasShown()), this, SLOT(initUpdates()),
Qt::ConnectionType(Qt::QueuedConnection | Qt::UniqueConnection));
connect(ui->tabs, SIGNAL(currentChanged(QWidget *)), this, SLOT(currentWidget(QWidget *)));
connect(ui->tabs, SIGNAL(currentChanged(QWidget *)), _recorder, SLOT(currentWidget(QWidget *)));
connect(_playlistTab, SIGNAL(changeTo(QWidget *)), ui->tabs, SLOT(setCurrentWidget(QWidget *)));
connect(_scheduleTab, SIGNAL(changeTo(QWidget *)), ui->tabs, SLOT(setCurrentWidget(QWidget *)));
connect(_showInfoTab, SIGNAL(changeTo(QWidget *)), ui->tabs, SLOT(setCurrentWidget(QWidget *)));
connect(ui->actionSupport, SIGNAL(triggered()), this, SLOT(support()));
connect(ui->actionAbout, SIGNAL(triggered()), this, SLOT(aboutTano()));
connect(ui->actionAboutQt, SIGNAL(triggered()), qApp, SLOT(aboutQt()));
connect(ui->actionLogoutExit, SIGNAL(triggered()), this, SLOT(exitLogout()));
connect(ui->actionExit, SIGNAL(triggered()), this, SLOT(exit()));
connect(ui->actionTop, SIGNAL(triggered()), this, SLOT(top()));
connect(ui->actionLite, SIGNAL(triggered()), this, SLOT(lite()));
connect(ui->actionOpen, SIGNAL(triggered()), this, SLOT(openPlaylist()));
connect(ui->actionOpenFile, SIGNAL(triggered()), _mediaPlayer, SLOT(openFile()));
connect(ui->actionOpenUrl, SIGNAL(triggered()), _mediaPlayer, SLOT(openUrl()));
connect(ui->actionSchedule, SIGNAL(triggered()), this, SLOT(showSchedule()));
connect(ui->actionScheduleCurrent, SIGNAL(triggered()), this, SLOT(showScheduleCurrent()));
connect(ui->actionSettings, SIGNAL(triggered()), this, SLOT(showSettings()));
connect(ui->actionSettingsShortcuts, SIGNAL(triggered()), this, SLOT(showSettingsShortcuts()));
connect(ui->actionEditPlaylist, SIGNAL(triggered()), this, SLOT(showPlaylistEditor()));
connect(ui->actionPlay, SIGNAL(triggered()), _mediaPlayer, SLOT(togglePause()));
connect(ui->actionStop, SIGNAL(triggered()), this, SLOT(stop()));
connect(ui->actionPreview, SIGNAL(triggered(bool)), this, SLOT(preview(bool)));
connect(_playlistTab->playlist(), SIGNAL(itemSelected(Channel *)), this, SLOT(playChannel(Channel *)));
connect(_previewTimer, SIGNAL(timeout()), ui->actionNext, SLOT(trigger()));
if (_trayIcon) {
connect(_trayIcon, SIGNAL(restoreClick()), this, SLOT(tray()));
connect(ui->actionTray, SIGNAL(triggered()), this, SLOT(tray()));
}
connect(ui->actionFullscreen, SIGNAL(triggered(bool)), this, SLOT(toggleFullscreen(bool)));
connect(ui->actionMute, SIGNAL(toggled(bool)), _mediaPlayer->osd(), SLOT(mute(bool)));
connect(ui->actionVolumeDown, SIGNAL(triggered()), _mediaPlayer->osd(), SLOT(volumeDown()));
connect(ui->actionVolumeUp, SIGNAL(triggered()), _mediaPlayer->osd(), SLOT(volumeUp()));
#if defined(Q_OS_LINUX)
if (_mediaPlayer->teletextEnabled()) {
connect(ui->actionTeletext, SIGNAL(triggered(bool)), _mediaPlayer->osd(), SLOT(teletext(bool)));
connect(ui->actionTeletext, SIGNAL(triggered(bool)), _mediaPlayer, SLOT(teletext(bool)));
connect(_mediaPlayer->osd(), SIGNAL(teletextClicked()), ui->actionTeletext, SLOT(trigger()));
}
RTMainWindow::RTMainWindow(GameConfiguration& config, QWidget* parent) :
QMainWindow(parent), popupTimer(NULL), popupNeedsRebuilding(true)
{
setupButtons();
setupToolbar();
setupLayout(config);
setWindowIcon(QIcon(QCoreApplication::applicationDirPath() +"/../img/logo.png"));
setWindowTitle(QString("RoboTower GUI"));
QObject::connect(startBtn, SIGNAL(clicked()), this, SLOT(startOnClick()));
QObject::connect(stopBtn, SIGNAL(clicked()), this, SLOT(stopOnClick()));
QObject::connect(newGameAction, SIGNAL(triggered()), this,
SLOT(newGameClicked()));
QObject::connect(currentGame, SIGNAL(togglePause()), this,
SIGNAL(togglePause()));
QFont font(this->font());
font.setBold(true);
font.setPointSize(font.pointSize() + 2);
this->setFont(font);
}
///Connect Signals and Slots for the ui control
void ui_connections(QObject* ui, GraphManager* graph_mgr, OpenNIListener* listener)
{
Qt::ConnectionType ctype = Qt::AutoConnection;
if (ParameterServer::instance()->get<bool>("concurrent_io"))
ctype = Qt::DirectConnection;
QObject::connect(ui, SIGNAL(reset()), graph_mgr, SLOT(reset()), ctype);
QObject::connect(ui, SIGNAL(optimizeGraph()), graph_mgr, SLOT(optimizeGraph()), ctype);
QObject::connect(ui, SIGNAL(togglePause()), listener, SLOT(togglePause()), ctype);
QObject::connect(ui, SIGNAL(toggleBagRecording()), listener, SLOT(toggleBagRecording()), ctype);
QObject::connect(ui, SIGNAL(getOneFrame()), listener, SLOT(getOneFrame()), ctype);
QObject::connect(ui, SIGNAL(deleteLastFrame()), graph_mgr, SLOT(deleteLastFrame()), ctype);
QObject::connect(ui, SIGNAL(sendAllClouds()), graph_mgr, SLOT(sendAllClouds()), ctype);
QObject::connect(ui, SIGNAL(saveAllClouds(QString)), graph_mgr, SLOT(saveAllClouds(QString)), ctype);
QObject::connect(ui, SIGNAL(saveOctomapSig(QString)), graph_mgr, SLOT(saveOctomap(QString)), ctype);
QObject::connect(ui, SIGNAL(saveAllFeatures(QString)), graph_mgr, SLOT(saveAllFeatures(QString)), ctype);
QObject::connect(ui, SIGNAL(saveIndividualClouds(QString)), graph_mgr, SLOT(saveIndividualClouds(QString)), ctype);
QObject::connect(ui, SIGNAL(saveTrajectory(QString)), graph_mgr, SLOT(saveTrajectory(QString)), ctype);
QObject::connect(ui, SIGNAL(toggleMapping(bool)), graph_mgr, SLOT(toggleMapping(bool)), ctype);
QObject::connect(ui, SIGNAL(saveG2OGraph(QString)), graph_mgr, SLOT(saveG2OGraph(QString)), ctype);
}
void RosUi::pause(bool _pause_on) {
if(this->pause_on == _pause_on){
return;
}
this->pause_on = _pause_on;
Q_EMIT togglePause();
if(!_pause_on) {
ROS_INFO("Processing.");
} else {
ROS_INFO("Stopped processing.");
}
}
VOID LButtonDown(HWND hWnd, WPARAM wParam, LPARAM lParam)
{
POINT ptMouse;
ptMouse.x = LOWORD(lParam);
ptMouse.y = HIWORD(lParam);
switch (global.status)
{
case global.GS_WELCOME:
if (PtInRect(&WelcomeButtons[0].geo, ptMouse))
{
PreviewSong();
global.status = global.GS_SONGSELECT;
}
else if (PtInRect(&WelcomeButtons[2].geo, ptMouse))
DestroyWindow(hWnd);
break;
case global.GS_SONGSELECT:
if (ptMouse.y <= ToWindowY(0.33))
{
if (global.currentSong <= 1)
global.currentSong = global.totalSongCount;
else
global.currentSong--;
PreviewSong();
}
else if (ptMouse.y < ToWindowY(0.67))
GameInit();
else
{
if (global.currentSong >= global.totalSongCount)
global.currentSong = 1;
else
global.currentSong++;
PreviewSong();
}
break;
case global.GS_PLAYING:
if (ptMouse.x >= WNDWIDTH - 45 && ptMouse.y <= 31)
togglePause();
break;
case global.GS_GAMEOVER:
if (ptMouse.x >= ToWindowX(0.67) && ptMouse.y >= ToWindowY(0.67))
{
PreviewSong();
global.status = global.GS_SONGSELECT;
}
break;
}
}
void RTCurrentGameWidget::onPauseClick()
{
if (isPaused)
{
pauseBtn->setText(PAUSE_STRING);
isPaused = false;
}
else
{
pauseBtn->setText(RESUME_STRING);
isPaused = true;
}
emit togglePause();
}
void Slideshow::keyPressEvent(QKeyEvent *e)
{
switch(e->key()) {
case Qt::Key_Return:
case Qt::Key_Enter:
if(e->modifiers() & Qt::AltModifier) {
if(this->isFullScreen()) {
this->setWindowState(Qt::WindowMaximized);
this->setGeometry(QDesktopWidget().screenGeometry(this).adjusted(50,50,-50,-50));
} else
this->setWindowState(Qt::WindowFullScreen);
}
break;
case Qt::Key_Space:
togglePause();
break;
case Qt::Key_Left:
if(!m_paused)
m_slidetimer->start();
prevSlide();
break;
case Qt::Key_Right:
if(!m_paused)
m_slidetimer->start();
nextSlide();
break;
case Qt::Key_Escape:
this->close();
break;
case Qt::Key_Plus: {
int i = m_slidetimer->interval() + 500;
m_slidetimer->setInterval(i);
setTimerText();
m_timertext->show();
break;
}
case Qt::Key_Minus: {
int i = m_slidetimer->interval() - 500;
if(i>=1000) {
m_slidetimer->setInterval(i);
setTimerText();
}
m_timertext->show();
break;
}
default:
QGraphicsView::keyPressEvent(e);
}
}
Framework::Framework(void *surf, const Configuration& conf, Networkstate initial)
: field(this), output(this), surface((SDL_Surface*)surf), version(conf.version),
paused(1), timeunit(1), lasttime(SDL_GetTicks()), frames(0), state(initial), xdiff(0), camera(conf.width, conf.height)
{
/* initialize OpenGL */
resetGL();
/* set up the window */
camera.init();
if (conf.fullscreen) SDL_WM_ToggleFullScreen(surface);
/* set unpaused state (grab input) */
togglePause(false, false);
}
void EngineMain::notify(KeyboardInputAction action)
{
if (action == PAUSE)
{
togglePause();
}
if(action == QUIT)
{
stop();
}
else if(action == NOCLIP)
{
toggleNoclip();
}
}
/* Function: keyInput
* Parameters: unsigned char key, int x, int y
* Keyboard callback function to handle key presses
*/
void keyInput(unsigned char key, int x, int y) {
switch (key) {
case 'x':
camera[0] += 0.5;
break;
case 'X':
camera[0] -= 0.5;
break;
case 'y':
camera[1] += 0.5;
break;
case 'Y':
camera[1] -= 0.5;
break;
case 'z':
camera[2] += 0.5;
break;
case 'Z':
camera[2] -= 0.5;
break;
case 'l':
printf("\nX: %f\nY: %f\nZ: %f\n", camera[0], camera[1], camera[2]);
break;
case 'p': /* Pause / Un-pause */
togglePause();
break;
case 't': /* Toggle board tilt */
toggleTilt();
break;
case 'w':
glutDisplayFunc(levelUpDisplay);
break;
case 'q': /* Quit */
exit(1);
break;
}
}
void App::setupActions()
{
// Game
KStandardGameAction::gameNew(this, SIGNAL(invokeNewGame()), actionCollection());
KStandardGameAction::restart(this, SLOT(restartGame()), actionCollection());
KStandardGameAction::pause(this, SLOT(togglePause()), actionCollection());
KStandardGameAction::highscores(this, SLOT(showHighscores()), actionCollection());
KStandardGameAction::quit(this, SLOT(close()), actionCollection());
// Move
KStandardGameAction::undo(this, SLOT(undo()), actionCollection());
KStandardGameAction::redo(this, SLOT(redo()), actionCollection());
KStandardGameAction::hint(this, SLOT(hint()), actionCollection());
auto soundAction = new KToggleAction(QIcon::fromTheme(QStringLiteral("speaker")), i18n("Play Sounds"), this);
soundAction->setChecked(Prefs::sounds());
actionCollection()->addAction(QStringLiteral("sounds"), soundAction);
connect(soundAction, &KToggleAction::triggered, m_board, &Board::setSoundsEnabled);
// Settings
KStandardAction::preferences(this, SLOT(showSettingsDialog()), actionCollection());
connect(m_board, &Board::cheatStatusChanged, this, &App::updateCheatDisplay);
connect(m_board, &Board::changed, this, &App::updateItems);
connect(m_board, &Board::tilesDoNotMatch, this, &App::notifyTilesDoNotMatch);
connect(m_board, &Board::invalidMove, this, &App::notifyInvalidMove);
connect(m_board, &Board::selectATile, this, &App::notifySelectATile);
connect(m_board, &Board::selectAMatchingTile, this, &App::notifySelectAMatchingTile);
connect(m_board, &Board::selectAMove, this, &App::notifySelectAMove);
auto timer = new QTimer(this);
connect(timer, &QTimer::timeout, this, &App::updateTimeDisplay);
timer->start(1000);
connect(m_board, &Board::tileCountChanged, this, &App::updateTileDisplay);
connect(m_board, &Board::endOfGame, this, &App::slotEndOfGame);
connect(this, &App::invokeNewGame, m_board, &Board::newGame);
connect(m_board, &Board::newGameStarted, this, &App::newGame);
}
void MainWindow::setupActions()
{
// TODO
#ifndef Q_OS_QNX
// Game
KAction* abort = actionCollection()->addAction("game_abort");
abort->setText(i18n("Abort game"));
connect(abort, SIGNAL(triggered()), m_main, SLOT(abort()));
KStandardGameAction::pause(m_main, SLOT(togglePause()), actionCollection());
KStandardGameAction::highscores(this, SLOT(highscores()), actionCollection());
KStandardGameAction::quit(this, SLOT(close()), actionCollection());
KAction* action;
action = new KToggleAction(i18n("&Play Sounds"), this);
action->setChecked(KollisionConfig::enableSounds());
actionCollection()->addAction("options_sounds", action);
connect(action, SIGNAL(triggered(bool)), m_main, SLOT(enableSounds(bool)));
setupGUI(Create | Save | Keys | StatusBar);
#endif
}
/* Function: menu
* Parameters: int id
* Right-click menu callback function. Performs actions depending
* on selected menu option.
*/
void menu(int id) {
switch(id) {
case 1: /* Play game */
loadLevel(levels[level]);
flashReady = 5;
playersLeft = 3;
glutDisplayFunc(gameDisplay);
glutKeyboardFunc(keyInput);
glutSpecialFunc(specialKeyInput);
glutTimerFunc(500, disableFlashReady, 0);
glutPostRedisplay();
break;
case 2: /* Instructions */
glutDisplayFunc(instrDisplay);
glutPostRedisplay();
break;
case 3: /* End Game */
gameStarted = 0;
playerSetup(1);
level = 0;
score = 0;
glutDisplayFunc(titleScreenDisplay);
glutKeyboardFunc(NULL);
glutSpecialFunc(NULL);
glutPostRedisplay();
break;
case 5: /* Pause Game */
togglePause();
break;
case 10: /* Toggle Tilt */
toggleTilt();
break;
case 99: /* Quit */
exit(0);
break;
}
}
DemosFramework::DemosFramework()
: QObject()
{
// Create the main frame
MainFrame = new QFrame;
MainFrame->setWindowTitle("Rigid2D Examples");
MainFrame->resize(800, 800);
MainLayout = new QHBoxLayout;
MainFrame->setLayout(MainLayout);
// Create layouts for selection and demo
SelectionLayout = new QVBoxLayout;
DemoLayout = new QVBoxLayout;
DemoLayout->setAlignment(Qt::AlignLeft);
MainLayout->addLayout(SelectionLayout);
MainLayout->addLayout(DemoLayout);
// Create TreeWidget in the selection layout
SelectionTree = new QTreeWidget();
SelectionTree->setMaximumWidth(200);
SelectionTree->setColumnCount(1);
SelectionTree->setHeaderLabel(QString("Examples"));
// DemosHeader
QTreeWidgetItem *demosHeader = new QTreeWidgetItem((QTreeWidget*)0,
QStringList(QString("Demos")));
SelectionTree->addTopLevelItem(demosHeader);
SelectionTree->expandItem(demosHeader);
QTreeWidgetItem *demo1 = new QTreeWidgetItem((QTreeWidget*)0,
QStringList(QString("Demo 1")));
demosHeader->addChild(demo1);
// BenchmarksHeader
QTreeWidgetItem *benchmarksHeader = new QTreeWidgetItem((QTreeWidget*)0,
QStringList(QString("Benchmarks")));
SelectionTree->addTopLevelItem(benchmarksHeader);
SelectionLayout->addWidget(SelectionTree);
// DemoToolBar layer (top of demo layer)
QHBoxLayout *DemoToolBarLayout = new QHBoxLayout;
DemoLayout->addLayout(DemoToolBarLayout);
// Create an OGLDemo
GLLayout = new QVBoxLayout;
CurrentDemo = new Demo1;
CurrentDemo->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
GLLayout->addWidget(CurrentDemo);
DemoLayout->addLayout(GLLayout);
// DemoToolBar Buttons
StartButton = new QPushButton("&Start");
DemoToolBarLayout->addWidget(StartButton);
PauseButton = new QPushButton("&Pause");
DemoToolBarLayout->addWidget(PauseButton);
RestartButton = new QPushButton("&Restart");
DemoToolBarLayout->addWidget(RestartButton);
// Pause button
QObject::connect(PauseButton, SIGNAL(clicked()), CurrentDemo, SLOT(togglePause()));
// Restart button
QObject::connect(RestartButton, SIGNAL(clicked()), this, SLOT(restartDemo()));
// Create and connect an fps label display
FPSLayout = new QHBoxLayout;
FPSLayout->setAlignment(Qt::AlignRight);
FPSTextLabel = new QLabel("Fps: ");
FPSNumLabel = new QLabel;
QObject::connect(CurrentDemo, SIGNAL(fpsChanged(int)), FPSNumLabel, SLOT(setNum(int)));
FPSLayout->addWidget(FPSTextLabel);
FPSLayout->addWidget(FPSNumLabel);
DemoLayout->addLayout(FPSLayout);
MainFrame->show();
}
void Server::doNetworking()
{
grapple_message *message;
while (grapple_server_messages_waiting(server))
{
message = grapple_server_message_pull(server);
switch (message->type)
{
case GRAPPLE_MSG_NEW_USER:
peer[message->NEW_USER.id] = Peer(grapple_server_client_address_get(server, message->NEW_USER.id));
std::cerr << "client connected from " << peer[message->NEW_USER.id].name << std::endl;
break;
case GRAPPLE_MSG_USER_NAME:
peer[message->USER_NAME.id].name = message->USER_NAME.name;
break;
case GRAPPLE_MSG_USER_MSG:
{
grapple_user id = message->USER_MSG.id;
Buffer buf((char*)message->USER_MSG.data, message->USER_MSG.length);
switch (buf.getType())
{
case READY:
peer[id].ready = true;
if (peer.size() > 1) {
bool ready = true;
for (std::map<grapple_user, Peer>::iterator i = peer.begin(); i != peer.end(); ++i)
{
if (!(*i).second.ready)
{
ready = false;
break;
}
}
if (ready)
startGame();
}
break;
case PADDLEMOVE:
{
unsigned int time = buf.popInt();
peer[id].player->move(buf.popDouble(), buf.popDouble(), time);
Vec2f pos = peer[id].player->getPosition();
Buffer sbuf(PADDLEPOSITION);
sbuf.pushId(id);
sbuf.pushDouble(pos.y);
sbuf.pushDouble(pos.x);
sendPacket(sbuf, false);
}
break;
case SERVE_BALL:
peer[id].player->detachBall(ballspeed);
break;
case PAUSE_REQUEST:
togglePause(true, true);
std::cout << "Player " << peer[id].name << " paused the game." << std::endl;
break;
case RESUME_REQUEST:
togglePause(false, true);
std::cout << "Player " << peer[id].name << " resumed the game." << std::endl;
break;
}
break;
}
case GRAPPLE_MSG_USER_DISCONNECTED:
std::cout << "Player " << peer[message->USER_DISCONNECTED.id].name << " disconnected!" << std::endl;
shutdown();
break;
}
grapple_message_dispose(message);
}
while (grapple_client_messages_waiting(loopback))
{
message=grapple_client_message_pull(loopback);
switch (message->type)
{
case GRAPPLE_MSG_NEW_USER_ME:
{
localid = message->NEW_USER.id;
peer[localid].player = new Player(this, peer[localid].name, FRONT, field.getLength()/2.0f);
player.push_back(peer[localid].player);
peer[localid].player->attachBall(&ball[0]);
output.addMessage(Interface::YOU_SERVE);
peer[localid].ready = true;
state = WAITING;
}
break;
}
grapple_message_dispose(message);
}
}
void Logstalgia::keyPress(SDL_KeyboardEvent *e) {
if (e->type == SDL_KEYDOWN) {
if (e->keysym.sym == SDLK_ESCAPE) {
appFinished=true;
}
if(e->keysym.sym == SDLK_q) {
info = !info;
}
if(e->keysym.sym == SDLK_c) {
settings.splash = 10.0f;
}
if(e->keysym.sym == SDLK_n) {
next = true;
}
if (e->keysym.sym == SDLK_p) {
if(GLEW_VERSION_2_0) {
settings.ffp = !settings.ffp;
}
}
if(e->keysym.sym == SDLK_SPACE) {
togglePause();
}
if (e->keysym.sym == SDLK_F12) {
take_screenshot = true;
}
if(!settings.sync) {
if (e->keysym.sym == SDLK_EQUALS || e->keysym.sym == SDLK_KP_PLUS) {
if(settings.simulation_speed >= 1.0f) {
settings.simulation_speed = std::min(30.0f, glm::floor(settings.simulation_speed) + 1.0f);
} else {
settings.simulation_speed = std::min(1.0f, settings.simulation_speed * 2.0f);
}
retarget=true;
}
if (e->keysym.sym == SDLK_MINUS || e->keysym.sym == SDLK_KP_MINUS) {
if(settings.simulation_speed > 1.0f) {
settings.simulation_speed = std::max(1.0f, glm::floor(settings.simulation_speed) - 1.0f);
} else {
settings.simulation_speed = std::max(0.1f, settings.simulation_speed * 0.5f);
}
retarget=true;
}
}
if(e->keysym.sym == SDLK_PERIOD) {
settings.pitch_speed = glm::clamp(settings.pitch_speed+0.1f, 0.0f, 10.0f);
retarget=true;
}
if(e->keysym.sym == SDLK_COMMA) {
settings.pitch_speed = glm::clamp(settings.pitch_speed-0.1f, 0.1f, 10.0f);
retarget=true;
}
if(e->keysym.sym == SDLK_RETURN && e->keysym.mod & KMOD_ALT) {
toggleFullscreen();
}
}
}
Menu::Menu() {
auto dialogsManager = DependencyManager::get<DialogsManager>();
auto accountManager = DependencyManager::get<AccountManager>();
// File/Application menu ----------------------------------
MenuWrapper* fileMenu = addMenu("File");
// File > Login menu items
{
addActionToQMenuAndActionHash(fileMenu, MenuOption::Login);
// connect to the appropriate signal of the AccountManager so that we can change the Login/Logout menu item
connect(accountManager.data(), &AccountManager::profileChanged,
dialogsManager.data(), &DialogsManager::toggleLoginDialog);
connect(accountManager.data(), &AccountManager::logoutComplete,
dialogsManager.data(), &DialogsManager::toggleLoginDialog);
}
// File > Help
addActionToQMenuAndActionHash(fileMenu, MenuOption::Help, 0, qApp, SLOT(showHelp()));
// File > About
addActionToQMenuAndActionHash(fileMenu, MenuOption::AboutApp, 0, qApp, SLOT(aboutApp()), QAction::AboutRole);
// File > Quit
addActionToQMenuAndActionHash(fileMenu, MenuOption::Quit, Qt::CTRL | Qt::Key_Q, qApp, SLOT(quit()), QAction::QuitRole);
// Edit menu ----------------------------------
MenuWrapper* editMenu = addMenu("Edit");
// Edit > Undo
QUndoStack* undoStack = qApp->getUndoStack();
QAction* undoAction = undoStack->createUndoAction(editMenu);
undoAction->setShortcut(Qt::CTRL | Qt::Key_Z);
addActionToQMenuAndActionHash(editMenu, undoAction);
// Edit > Redo
QAction* redoAction = undoStack->createRedoAction(editMenu);
redoAction->setShortcut(Qt::CTRL | Qt::SHIFT | Qt::Key_Z);
addActionToQMenuAndActionHash(editMenu, redoAction);
// Edit > Running Scripts
addActionToQMenuAndActionHash(editMenu, MenuOption::RunningScripts, Qt::CTRL | Qt::Key_J,
qApp, SLOT(toggleRunningScriptsWidget()));
// Edit > Open and Run Script from File... [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::LoadScript, Qt::CTRL | Qt::Key_O,
qApp, SLOT(loadDialog()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Edit > Open and Run Script from Url... [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::LoadScriptURL,
Qt::CTRL | Qt::SHIFT | Qt::Key_O, qApp, SLOT(loadScriptURLDialog()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
auto scriptEngines = DependencyManager::get<ScriptEngines>();
// Edit > Stop All Scripts... [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::StopAllScripts, 0,
scriptEngines.data(), SLOT(stopAllScripts()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Edit > Reload All Scripts... [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::ReloadAllScripts, Qt::CTRL | Qt::Key_R,
scriptEngines.data(), SLOT(reloadAllScripts()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Edit > Scripts Editor... [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::ScriptEditor, Qt::ALT | Qt::Key_S,
dialogsManager.data(), SLOT(showScriptEditor()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Edit > Console... [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::Console, Qt::CTRL | Qt::ALT | Qt::Key_J,
DependencyManager::get<StandAloneJSConsole>().data(),
SLOT(toggleConsole()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
editMenu->addSeparator();
// Edit > My Asset Server
auto assetServerAction = addActionToQMenuAndActionHash(editMenu, MenuOption::AssetServer,
Qt::CTRL | Qt::SHIFT | Qt::Key_A,
qApp, SLOT(toggleAssetServerWidget()));
auto nodeList = DependencyManager::get<NodeList>();
QObject::connect(nodeList.data(), &NodeList::canWriteAssetsChanged, assetServerAction, &QAction::setEnabled);
assetServerAction->setEnabled(nodeList->getThisNodeCanWriteAssets());
// Edit > Package Model... [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::PackageModel, 0,
qApp, SLOT(packageModel()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Edit > Reload All Content [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::ReloadContent, 0, qApp, SLOT(reloadResourceCaches()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Audio menu ----------------------------------
MenuWrapper* audioMenu = addMenu("Audio");
auto audioIO = DependencyManager::get<AudioClient>();
// Audio > Mute
addCheckableActionToQMenuAndActionHash(audioMenu, MenuOption::MuteAudio, Qt::CTRL | Qt::Key_M, false,
audioIO.data(), SLOT(toggleMute()));
// Audio > Show Level Meter
addCheckableActionToQMenuAndActionHash(audioMenu, MenuOption::AudioTools, 0, true);
// Avatar menu ----------------------------------
MenuWrapper* avatarMenu = addMenu("Avatar");
auto avatarManager = DependencyManager::get<AvatarManager>();
QObject* avatar = avatarManager->getMyAvatar();
// Avatar > Attachments...
auto action = addActionToQMenuAndActionHash(avatarMenu, MenuOption::Attachments);
connect(action, &QAction::triggered, [] {
DependencyManager::get<OffscreenUi>()->show(QString("hifi/dialogs/AttachmentsDialog.qml"), "AttachmentsDialog");
});
// Avatar > Size
MenuWrapper* avatarSizeMenu = avatarMenu->addMenu("Size");
// Avatar > Size > Increase
addActionToQMenuAndActionHash(avatarSizeMenu,
MenuOption::IncreaseAvatarSize,
0, // QML Qt::Key_Plus,
avatar, SLOT(increaseSize()));
// Avatar > Size > Decrease
addActionToQMenuAndActionHash(avatarSizeMenu,
MenuOption::DecreaseAvatarSize,
0, // QML Qt::Key_Minus,
avatar, SLOT(decreaseSize()));
// Avatar > Size > Reset
addActionToQMenuAndActionHash(avatarSizeMenu,
MenuOption::ResetAvatarSize,
0, // QML Qt::Key_Equal,
avatar, SLOT(resetSize()));
// Avatar > Reset Sensors
addActionToQMenuAndActionHash(avatarMenu,
MenuOption::ResetSensors,
0, // QML Qt::Key_Apostrophe,
qApp, SLOT(resetSensors()));
// Display menu ----------------------------------
// FIXME - this is not yet matching Alan's spec because it doesn't have
// menus for "2D"/"3D" - we need to add support for detecting the appropriate
// default 3D display mode
addMenu(DisplayPlugin::MENU_PATH());
MenuWrapper* displayModeMenu = addMenu(MenuOption::OutputMenu);
QActionGroup* displayModeGroup = new QActionGroup(displayModeMenu);
displayModeGroup->setExclusive(true);
// View menu ----------------------------------
MenuWrapper* viewMenu = addMenu("View");
QActionGroup* cameraModeGroup = new QActionGroup(viewMenu);
// View > [camera group]
cameraModeGroup->setExclusive(true);
// View > First Person
cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash(viewMenu,
MenuOption::FirstPerson, 0, // QML Qt:: Key_P
true, qApp, SLOT(cameraMenuChanged())));
// View > Third Person
cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash(viewMenu,
MenuOption::ThirdPerson, 0,
false, qApp, SLOT(cameraMenuChanged())));
// View > Mirror
cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash(viewMenu,
MenuOption::FullscreenMirror, 0, // QML Qt::Key_H,
false, qApp, SLOT(cameraMenuChanged())));
// View > Independent [advanced]
cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash(viewMenu,
MenuOption::IndependentMode, 0,
false, qApp, SLOT(cameraMenuChanged()),
UNSPECIFIED_POSITION, "Advanced"));
// View > Entity Camera [advanced]
cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash(viewMenu,
MenuOption::CameraEntityMode, 0,
false, qApp, SLOT(cameraMenuChanged()),
UNSPECIFIED_POSITION, "Advanced"));
viewMenu->addSeparator();
// View > Mini Mirror
addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::MiniMirror, 0, false);
// View > Center Player In View
addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::CenterPlayerInView,
0, true, qApp, SLOT(rotationModeChanged()),
UNSPECIFIED_POSITION, "Advanced");
// View > Overlays
addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::Overlays, 0, true);
// Navigate menu ----------------------------------
MenuWrapper* navigateMenu = addMenu("Navigate");
// Navigate > Show Address Bar
addActionToQMenuAndActionHash(navigateMenu, MenuOption::AddressBar, Qt::CTRL | Qt::Key_L,
dialogsManager.data(), SLOT(toggleAddressBar()));
// Navigate > Bookmark related menus -- Note: the Bookmark class adds its own submenus here.
qApp->getBookmarks()->setupMenus(this, navigateMenu);
// Navigate > Copy Address [advanced]
auto addressManager = DependencyManager::get<AddressManager>();
addActionToQMenuAndActionHash(navigateMenu, MenuOption::CopyAddress, 0,
addressManager.data(), SLOT(copyAddress()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Navigate > Copy Path [advanced]
addActionToQMenuAndActionHash(navigateMenu, MenuOption::CopyPath, 0,
addressManager.data(), SLOT(copyPath()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Settings menu ----------------------------------
MenuWrapper* settingsMenu = addMenu("Settings");
// Settings > Advance Menus
addCheckableActionToQMenuAndActionHash(settingsMenu, "Advanced Menus", 0, false, this, SLOT(toggleAdvancedMenus()));
// Settings > Developer Menus
addCheckableActionToQMenuAndActionHash(settingsMenu, "Developer Menus", 0, false, this, SLOT(toggleDeveloperMenus()));
// Settings > General...
action = addActionToQMenuAndActionHash(settingsMenu, MenuOption::Preferences, Qt::CTRL | Qt::Key_Comma, nullptr, nullptr, QAction::PreferencesRole);
connect(action, &QAction::triggered, [] {
DependencyManager::get<OffscreenUi>()->toggle(QString("hifi/dialogs/GeneralPreferencesDialog.qml"), "GeneralPreferencesDialog");
});
// Settings > Avatar...
action = addActionToQMenuAndActionHash(settingsMenu, "Avatar...");
connect(action, &QAction::triggered, [] {
DependencyManager::get<OffscreenUi>()->toggle(QString("hifi/dialogs/AvatarPreferencesDialog.qml"), "AvatarPreferencesDialog");
});
// Settings > Audio...
action = addActionToQMenuAndActionHash(settingsMenu, "Audio...");
connect(action, &QAction::triggered, [] {
DependencyManager::get<OffscreenUi>()->toggle(QString("hifi/dialogs/AudioPreferencesDialog.qml"), "AudioPreferencesDialog");
});
// Settings > LOD...
action = addActionToQMenuAndActionHash(settingsMenu, "LOD...");
connect(action, &QAction::triggered, [] {
DependencyManager::get<OffscreenUi>()->toggle(QString("hifi/dialogs/LodPreferencesDialog.qml"), "LodPreferencesDialog");
});
// Settings > Control with Speech [advanced]
#if defined(Q_OS_MAC) || defined(Q_OS_WIN)
auto speechRecognizer = DependencyManager::get<SpeechRecognizer>();
QAction* speechRecognizerAction = addCheckableActionToQMenuAndActionHash(settingsMenu, MenuOption::ControlWithSpeech,
Qt::CTRL | Qt::SHIFT | Qt::Key_C,
speechRecognizer->getEnabled(),
speechRecognizer.data(),
SLOT(setEnabled(bool)),
UNSPECIFIED_POSITION, "Advanced");
connect(speechRecognizer.data(), SIGNAL(enabledUpdated(bool)), speechRecognizerAction, SLOT(setChecked(bool)));
#endif
// Developer menu ----------------------------------
MenuWrapper* developerMenu = addMenu("Developer", "Developer");
// Developer > Graphics...
action = addActionToQMenuAndActionHash(developerMenu, "Graphics...");
connect(action, &QAction::triggered, [] {
DependencyManager::get<OffscreenUi>()->toggle(QString("hifi/dialogs/GraphicsPreferencesDialog.qml"), "GraphicsPreferencesDialog");
});
// Developer > Render >>>
MenuWrapper* renderOptionsMenu = developerMenu->addMenu("Render");
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::WorldAxes);
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::DefaultSkybox, 0, true);
// Developer > Render > Throttle FPS If Not Focus
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::ThrottleFPSIfNotFocus, 0, true);
// Developer > Render > Resolution
MenuWrapper* resolutionMenu = renderOptionsMenu->addMenu(MenuOption::RenderResolution);
QActionGroup* resolutionGroup = new QActionGroup(resolutionMenu);
resolutionGroup->setExclusive(true);
resolutionGroup->addAction(addCheckableActionToQMenuAndActionHash(resolutionMenu, MenuOption::RenderResolutionOne, 0, true));
resolutionGroup->addAction(addCheckableActionToQMenuAndActionHash(resolutionMenu, MenuOption::RenderResolutionTwoThird, 0, false));
resolutionGroup->addAction(addCheckableActionToQMenuAndActionHash(resolutionMenu, MenuOption::RenderResolutionHalf, 0, false));
resolutionGroup->addAction(addCheckableActionToQMenuAndActionHash(resolutionMenu, MenuOption::RenderResolutionThird, 0, false));
resolutionGroup->addAction(addCheckableActionToQMenuAndActionHash(resolutionMenu, MenuOption::RenderResolutionQuarter, 0, false));
//const QString = "Automatic Texture Memory";
//const QString = "64 MB";
//const QString = "256 MB";
//const QString = "512 MB";
//const QString = "1024 MB";
//const QString = "2048 MB";
// Developer > Render > Resolution
MenuWrapper* textureMenu = renderOptionsMenu->addMenu(MenuOption::RenderMaxTextureMemory);
QActionGroup* textureGroup = new QActionGroup(textureMenu);
textureGroup->setExclusive(true);
textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTextureAutomatic, 0, true));
textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTexture64MB, 0, false));
textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTexture256MB, 0, false));
textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTexture512MB, 0, false));
textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTexture1024MB, 0, false));
textureGroup->addAction(addCheckableActionToQMenuAndActionHash(textureMenu, MenuOption::RenderMaxTexture2048MB, 0, false));
connect(textureGroup, &QActionGroup::triggered, [textureGroup] {
auto checked = textureGroup->checkedAction();
auto text = checked->text();
gpu::Context::Size newMaxTextureMemory { 0 };
if (MenuOption::RenderMaxTexture64MB == text) {
newMaxTextureMemory = MB_TO_BYTES(64);
} else if (MenuOption::RenderMaxTexture256MB == text) {
newMaxTextureMemory = MB_TO_BYTES(256);
} else if (MenuOption::RenderMaxTexture512MB == text) {
newMaxTextureMemory = MB_TO_BYTES(512);
} else if (MenuOption::RenderMaxTexture1024MB == text) {
newMaxTextureMemory = MB_TO_BYTES(1024);
} else if (MenuOption::RenderMaxTexture2048MB == text) {
newMaxTextureMemory = MB_TO_BYTES(2048);
}
gpu::Texture::setAllowedGPUMemoryUsage(newMaxTextureMemory);
});
// Developer > Render > LOD Tools
addActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::LodTools, 0, dialogsManager.data(), SLOT(lodTools()));
// Developer > Assets >>>
MenuWrapper* assetDeveloperMenu = developerMenu->addMenu("Assets");
auto& atpMigrator = ATPAssetMigrator::getInstance();
atpMigrator.setDialogParent(this);
addActionToQMenuAndActionHash(assetDeveloperMenu, MenuOption::AssetMigration,
0, &atpMigrator,
SLOT(loadEntityServerFile()));
// Developer > Avatar >>>
MenuWrapper* avatarDebugMenu = developerMenu->addMenu("Avatar");
// Developer > Avatar > Face Tracking
MenuWrapper* faceTrackingMenu = avatarDebugMenu->addMenu("Face Tracking");
{
QActionGroup* faceTrackerGroup = new QActionGroup(avatarDebugMenu);
bool defaultNoFaceTracking = true;
#ifdef HAVE_DDE
defaultNoFaceTracking = false;
#endif
QAction* noFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::NoFaceTracking,
0, defaultNoFaceTracking,
qApp, SLOT(setActiveFaceTracker()));
faceTrackerGroup->addAction(noFaceTracker);
#ifdef HAVE_FACESHIFT
QAction* faceshiftFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::Faceshift,
0, false,
qApp, SLOT(setActiveFaceTracker()));
faceTrackerGroup->addAction(faceshiftFaceTracker);
#endif
#ifdef HAVE_DDE
QAction* ddeFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::UseCamera,
0, true,
qApp, SLOT(setActiveFaceTracker()));
faceTrackerGroup->addAction(ddeFaceTracker);
#endif
}
#ifdef HAVE_DDE
faceTrackingMenu->addSeparator();
QAction* binaryEyelidControl = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::BinaryEyelidControl, 0, true);
binaryEyelidControl->setVisible(true); // DDE face tracking is on by default
QAction* coupleEyelids = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::CoupleEyelids, 0, true);
coupleEyelids->setVisible(true); // DDE face tracking is on by default
QAction* useAudioForMouth = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::UseAudioForMouth, 0, true);
useAudioForMouth->setVisible(true); // DDE face tracking is on by default
QAction* ddeFiltering = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::VelocityFilter, 0, true);
ddeFiltering->setVisible(true); // DDE face tracking is on by default
QAction* ddeCalibrate = addActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::CalibrateCamera, 0,
DependencyManager::get<DdeFaceTracker>().data(), SLOT(calibrate()));
ddeCalibrate->setVisible(true); // DDE face tracking is on by default
#endif
#if defined(HAVE_FACESHIFT) || defined(HAVE_DDE)
faceTrackingMenu->addSeparator();
addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::MuteFaceTracking,
Qt::CTRL | Qt::SHIFT | Qt::Key_F, true); // DDE face tracking is on by default
addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::AutoMuteAudio, 0, false);
#endif
#ifdef HAVE_IVIEWHMD
// Developer > Avatar > Eye Tracking
MenuWrapper* eyeTrackingMenu = avatarDebugMenu->addMenu("Eye Tracking");
addCheckableActionToQMenuAndActionHash(eyeTrackingMenu, MenuOption::SMIEyeTracking, 0, false,
qApp, SLOT(setActiveEyeTracker()));
{
MenuWrapper* calibrateEyeTrackingMenu = eyeTrackingMenu->addMenu("Calibrate");
addActionToQMenuAndActionHash(calibrateEyeTrackingMenu, MenuOption::OnePointCalibration, 0,
qApp, SLOT(calibrateEyeTracker1Point()));
addActionToQMenuAndActionHash(calibrateEyeTrackingMenu, MenuOption::ThreePointCalibration, 0,
qApp, SLOT(calibrateEyeTracker3Points()));
addActionToQMenuAndActionHash(calibrateEyeTrackingMenu, MenuOption::FivePointCalibration, 0,
qApp, SLOT(calibrateEyeTracker5Points()));
}
addCheckableActionToQMenuAndActionHash(eyeTrackingMenu, MenuOption::SimulateEyeTracking, 0, false,
qApp, SLOT(setActiveEyeTracker()));
#endif
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AvatarReceiveStats, 0, false,
avatarManager.data(), SLOT(setShouldShowReceiveStats(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderBoundingCollisionShapes);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderMyLookAtVectors, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderOtherLookAtVectors, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::FixGaze, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawDefaultPose, 0, false,
avatar, SLOT(setEnableDebugDrawDefaultPose(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawAnimPose, 0, false,
avatar, SLOT(setEnableDebugDrawAnimPose(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawPosition, 0, false,
avatar, SLOT(setEnableDebugDrawPosition(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::MeshVisible, 0, true,
avatar, SLOT(setEnableMeshVisible(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::DisableEyelidAdjustment, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::TurnWithHead, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::UseAnimPreAndPostRotations, 0, true,
avatar, SLOT(setUseAnimPreAndPostRotations(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::EnableInverseKinematics, 0, true,
avatar, SLOT(setEnableInverseKinematics(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderSensorToWorldMatrix, 0, false,
avatar, SLOT(setEnableDebugDrawSensorToWorldMatrix(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ActionMotorControl,
Qt::CTRL | Qt::SHIFT | Qt::Key_K, true, avatar, SLOT(updateMotionBehaviorFromMenu()),
UNSPECIFIED_POSITION, "Developer");
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ScriptedMotorControl, 0, true,
avatar, SLOT(updateMotionBehaviorFromMenu()),
UNSPECIFIED_POSITION, "Developer");
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::EnableCharacterController, 0, true,
avatar, SLOT(updateMotionBehaviorFromMenu()),
UNSPECIFIED_POSITION, "Developer");
// Developer > Hands >>>
MenuWrapper* handOptionsMenu = developerMenu->addMenu("Hands");
addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::DisplayHandTargets, 0, false,
avatar, SLOT(setEnableDebugDrawHandControllers(bool)));
addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::LowVelocityFilter, 0, true,
qApp, SLOT(setLowVelocityFilter(bool)));
MenuWrapper* leapOptionsMenu = handOptionsMenu->addMenu("Leap Motion");
addCheckableActionToQMenuAndActionHash(leapOptionsMenu, MenuOption::LeapMotionOnHMD, 0, false);
// Developer > Entities >>>
MenuWrapper* entitiesOptionsMenu = developerMenu->addMenu("Entities");
addActionToQMenuAndActionHash(entitiesOptionsMenu, MenuOption::OctreeStats, 0,
dialogsManager.data(), SLOT(octreeStatsDetails()));
addCheckableActionToQMenuAndActionHash(entitiesOptionsMenu, MenuOption::ShowRealtimeEntityStats);
// Developer > Network >>>
MenuWrapper* networkMenu = developerMenu->addMenu("Network");
addActionToQMenuAndActionHash(networkMenu, MenuOption::ReloadContent, 0, qApp, SLOT(reloadResourceCaches()));
addCheckableActionToQMenuAndActionHash(networkMenu,
MenuOption::DisableActivityLogger,
0,
false,
&UserActivityLogger::getInstance(),
SLOT(disable(bool)));
addActionToQMenuAndActionHash(networkMenu, MenuOption::CachesSize, 0,
dialogsManager.data(), SLOT(cachesSizeDialog()));
addActionToQMenuAndActionHash(networkMenu, MenuOption::DiskCacheEditor, 0,
dialogsManager.data(), SLOT(toggleDiskCacheEditor()));
addActionToQMenuAndActionHash(networkMenu, MenuOption::ShowDSConnectTable, 0,
dialogsManager.data(), SLOT(showDomainConnectionDialog()));
addActionToQMenuAndActionHash(networkMenu, MenuOption::BandwidthDetails, 0,
dialogsManager.data(), SLOT(bandwidthDetails()));
#if (PR_BUILD || DEV_BUILD)
addCheckableActionToQMenuAndActionHash(networkMenu, MenuOption::SendWrongProtocolVersion, 0, false,
qApp, SLOT(sendWrongProtocolVersionsSignature(bool)));
addCheckableActionToQMenuAndActionHash(networkMenu, MenuOption::SendWrongDSConnectVersion, 0, false,
nodeList.data(), SLOT(toggleSendNewerDSConnectVersion(bool)));
#endif
// Developer > Timing >>>
MenuWrapper* timingMenu = developerMenu->addMenu("Timing");
MenuWrapper* perfTimerMenu = timingMenu->addMenu("Performance Timer");
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::DisplayDebugTimingDetails, 0, false);
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::OnlyDisplayTopTen, 0, true);
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandUpdateTiming, 0, false);
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandMyAvatarTiming, 0, false);
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandMyAvatarSimulateTiming, 0, false);
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandOtherAvatarTiming, 0, false);
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandPaintGLTiming, 0, false);
addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::FrameTimer);
addActionToQMenuAndActionHash(timingMenu, MenuOption::RunTimingTests, 0, qApp, SLOT(runTests()));
addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::PipelineWarnings);
addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::LogExtraTimings);
addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::SuppressShortTimings);
// Developer > Audio >>>
MenuWrapper* audioDebugMenu = developerMenu->addMenu("Audio");
addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::AudioNoiseReduction, 0, true,
audioIO.data(), SLOT(toggleAudioNoiseReduction()));
addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::EchoServerAudio, 0, false,
audioIO.data(), SLOT(toggleServerEcho()));
addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::EchoLocalAudio, 0, false,
audioIO.data(), SLOT(toggleLocalEcho()));
addActionToQMenuAndActionHash(audioDebugMenu, MenuOption::MuteEnvironment, 0,
audioIO.data(), SLOT(sendMuteEnvironmentPacket()));
auto scope = DependencyManager::get<AudioScope>();
MenuWrapper* audioScopeMenu = audioDebugMenu->addMenu("Audio Scope");
addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScope, Qt::CTRL | Qt::Key_P, false,
scope.data(), SLOT(toggle()));
addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScopePause, Qt::CTRL | Qt::SHIFT | Qt::Key_P, false,
scope.data(), SLOT(togglePause()));
addDisabledActionAndSeparator(audioScopeMenu, "Display Frames");
{
QAction* fiveFrames = addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScopeFiveFrames,
0, true, scope.data(), SLOT(selectAudioScopeFiveFrames()));
QAction* twentyFrames = addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScopeTwentyFrames,
0, false, scope.data(), SLOT(selectAudioScopeTwentyFrames()));
QAction* fiftyFrames = addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScopeFiftyFrames,
0, false, scope.data(), SLOT(selectAudioScopeFiftyFrames()));
QActionGroup* audioScopeFramesGroup = new QActionGroup(audioScopeMenu);
audioScopeFramesGroup->addAction(fiveFrames);
audioScopeFramesGroup->addAction(twentyFrames);
audioScopeFramesGroup->addAction(fiftyFrames);
}
// Developer > Audio > Audio Network Stats...
addActionToQMenuAndActionHash(audioDebugMenu, MenuOption::AudioNetworkStats, 0,
dialogsManager.data(), SLOT(audioStatsDetails()));
// Developer > Physics >>>
MenuWrapper* physicsOptionsMenu = developerMenu->addMenu("Physics");
{
auto drawStatusConfig = qApp->getRenderEngine()->getConfiguration()->getConfig<render::DrawStatus>();
addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowOwned,
0, false, drawStatusConfig, SLOT(setShowNetwork(bool)));
}
addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowHulls);
// Developer > Ask to Reset Settings
addCheckableActionToQMenuAndActionHash(developerMenu, MenuOption::AskToResetSettings, 0, false);
// Developer > Display Crash Options
addCheckableActionToQMenuAndActionHash(developerMenu, MenuOption::DisplayCrashOptions, 0, true);
// Developer > Crash >>>
MenuWrapper* crashMenu = developerMenu->addMenu("Crash");
addActionToQMenuAndActionHash(crashMenu, MenuOption::DeadlockInterface, 0, qApp, SLOT(deadlockApplication()));
action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashPureVirtualFunction);
connect(action, &QAction::triggered, qApp, []() { crash::pureVirtualCall(); });
action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashPureVirtualFunctionThreaded);
connect(action, &QAction::triggered, qApp, []() { std::thread([]() { crash::pureVirtualCall(); }); });
action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashDoubleFree);
connect(action, &QAction::triggered, qApp, []() { crash::doubleFree(); });
action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashDoubleFreeThreaded);
connect(action, &QAction::triggered, qApp, []() { std::thread([]() { crash::doubleFree(); }); });
action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashAbort);
connect(action, &QAction::triggered, qApp, []() { crash::doAbort(); });
action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashAbortThreaded);
connect(action, &QAction::triggered, qApp, []() { std::thread([]() { crash::doAbort(); }); });
action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashNullDereference);
connect(action, &QAction::triggered, qApp, []() { crash::nullDeref(); });
action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashNullDereferenceThreaded);
connect(action, &QAction::triggered, qApp, []() { std::thread([]() { crash::nullDeref(); }); });
action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashOutOfBoundsVectorAccess);
connect(action, &QAction::triggered, qApp, []() { crash::outOfBoundsVectorCrash(); });
action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashOutOfBoundsVectorAccessThreaded);
connect(action, &QAction::triggered, qApp, []() { std::thread([]() { crash::outOfBoundsVectorCrash(); }); });
action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashNewFault);
connect(action, &QAction::triggered, qApp, []() { crash::newFault(); });
action = addActionToQMenuAndActionHash(crashMenu, MenuOption::CrashNewFaultThreaded);
connect(action, &QAction::triggered, qApp, []() { std::thread([]() { crash::newFault(); }); });
// Developer > Log...
addActionToQMenuAndActionHash(developerMenu, MenuOption::Log, Qt::CTRL | Qt::SHIFT | Qt::Key_L,
qApp, SLOT(toggleLogDialog()));
// Developer > Stats
addCheckableActionToQMenuAndActionHash(developerMenu, MenuOption::Stats);
#if 0 /// -------------- REMOVED FOR NOW --------------
addDisabledActionAndSeparator(navigateMenu, "History");
QAction* backAction = addActionToQMenuAndActionHash(navigateMenu, MenuOption::Back, 0, addressManager.data(), SLOT(goBack()));
QAction* forwardAction = addActionToQMenuAndActionHash(navigateMenu, MenuOption::Forward, 0, addressManager.data(), SLOT(goForward()));
// connect to the AddressManager signal to enable and disable the back and forward menu items
connect(addressManager.data(), &AddressManager::goBackPossible, backAction, &QAction::setEnabled);
connect(addressManager.data(), &AddressManager::goForwardPossible, forwardAction, &QAction::setEnabled);
// set the two actions to start disabled since the stacks are clear on startup
backAction->setDisabled(true);
forwardAction->setDisabled(true);
MenuWrapper* toolsMenu = addMenu("Tools");
addActionToQMenuAndActionHash(toolsMenu,
MenuOption::ToolWindow,
Qt::CTRL | Qt::ALT | Qt::Key_T,
dialogsManager.data(),
SLOT(toggleToolWindow()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
addCheckableActionToQMenuAndActionHash(avatarMenu, MenuOption::NamesAboveHeads, 0, true,
NULL, NULL, UNSPECIFIED_POSITION, "Advanced");
#endif
}
