// Updates "format" with the parameters of the selected configuration.
void qt_glformat_from_eglconfig(QGLFormat& format, const EGLConfig config)
{
EGLint redSize = 0;
EGLint greenSize = 0;
EGLint blueSize = 0;
EGLint alphaSize = 0;
EGLint depthSize = 0;
EGLint stencilSize = 0;
EGLint sampleCount = 0;
EGLint level = 0;
EGLDisplay display = QEgl::display();
eglGetConfigAttrib(display, config, EGL_RED_SIZE, &redSize);
eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &greenSize);
eglGetConfigAttrib(display, config, EGL_BLUE_SIZE, &blueSize);
eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &alphaSize);
eglGetConfigAttrib(display, config, EGL_DEPTH_SIZE, &depthSize);
eglGetConfigAttrib(display, config, EGL_STENCIL_SIZE, &stencilSize);
eglGetConfigAttrib(display, config, EGL_SAMPLES, &sampleCount);
eglGetConfigAttrib(display, config, EGL_LEVEL, &level);
format.setRedBufferSize(redSize);
format.setGreenBufferSize(greenSize);
format.setBlueBufferSize(blueSize);
format.setAlphaBufferSize(alphaSize);
format.setDepthBufferSize(depthSize);
format.setStencilBufferSize(stencilSize);
format.setSamples(sampleCount);
format.setPlane(level);
format.setDirectRendering(true); // All EGL contexts are direct-rendered
format.setRgba(true); // EGL doesn't support colour index rendering
format.setStereo(false); // EGL doesn't support stereo buffers
format.setAccumBufferSize(0); // EGL doesn't support accululation buffers
format.setDoubleBuffer(true); // We don't support single buffered EGL contexts
// Clear the EGL error state because some of the above may
// have errored out because the attribute is not applicable
// to the surface type. Such errors don't matter.
eglGetError();
}
QT_BEGIN_NAMESPACE
/*!
\since 4.8
Returns an OpenGL format for the platform window format specified by \a format.
*/
QGLFormat QGLFormat::fromPlatformWindowFormat(const QPlatformWindowFormat &format)
{
QGLFormat retFormat;
retFormat.setAccum(format.accum());
if (format.accumBufferSize() >= 0)
retFormat.setAccumBufferSize(format.accumBufferSize());
retFormat.setAlpha(format.alpha());
if (format.alphaBufferSize() >= 0)
retFormat.setAlphaBufferSize(format.alphaBufferSize());
if (format.blueBufferSize() >= 0)
retFormat.setBlueBufferSize(format.blueBufferSize());
retFormat.setDepth(format.depth());
if (format.depthBufferSize() >= 0)
retFormat.setDepthBufferSize(format.depthBufferSize());
retFormat.setDirectRendering(format.directRendering());
retFormat.setDoubleBuffer(format.doubleBuffer());
if (format.greenBufferSize() >= 0)
retFormat.setGreenBufferSize(format.greenBufferSize());
if (format.redBufferSize() >= 0)
retFormat.setRedBufferSize(format.redBufferSize());
retFormat.setRgba(format.rgba());
retFormat.setSampleBuffers(format.sampleBuffers());
retFormat.setSamples(format.sampleBuffers());
retFormat.setStencil(format.stencil());
if (format.stencilBufferSize() >= 0)
retFormat.setStencilBufferSize(format.stencilBufferSize());
retFormat.setStereo(format.stereo());
retFormat.setSwapInterval(format.swapInterval());
return retFormat;
}
GLView * GLView::create( NifSkope * window )
{
QGLFormat fmt;
static QList<QPointer<GLView> > views;
QGLWidget * share = nullptr;
for ( const QPointer<GLView>& v : views ) {
if ( v )
share = v;
}
// All new windows after the first window will share a format
if ( share ) {
fmt = share->format();
} else {
fmt.setSampleBuffers( Options::antialias() );
}
// OpenGL version
fmt.setVersion( 2, 1 );
// Ignored if version < 3.2
//fmt.setProfile(QGLFormat::CoreProfile);
// V-Sync
fmt.setSwapInterval( 1 );
fmt.setDoubleBuffer( true );
fmt.setSamples( Options::antialias() ? 16 : 0 );
fmt.setDirectRendering( true );
fmt.setRgba( true );
views.append( QPointer<GLView>( new GLView( fmt, window, share ) ) );
return views.last();
}
void GridsPlugin::initDockWidget()
{
// create and add doc widget
_dock_widget = new QDockWidget(QObject::tr("Grid Viewer"));
_dock_widget->setAllowedAreas(Qt::RightDockWidgetArea);
_dock_widget->setObjectName("gridViewerDock");
QGLFormat format;
format.setVersion(2, 1);
format.setDoubleBuffer(true);
format.setDepth(true);
format.setRgba(true);
format.setAlpha(false);
format.setAccum(false);
format.setStencil(false);
format.setStereo(false);
format.setDirectRendering(true);
format.setOverlay(false);
_viewer = new GridViewer(format);
_viewer->setMinimumSize(250, 0);
_viewer->setObjectName("gridViewer");
QVBoxLayout *layout = new QVBoxLayout();
layout->addWidget(_viewer);
QWidget *widget = new QWidget();
widget->setLayout(layout);
_dock_widget->setWidget(widget);
NeuroGui::MainWindow::instance()->addDockWidget(Qt::RightDockWidgetArea, _dock_widget);
// add to view menu
NeuroGui::MainWindow::instance()->toolBarsMenu()->addAction(_dock_widget->toggleViewAction());
}
WaveformWidgetFactory::WaveformWidgetFactory() :
m_type(WaveformWidgetType::Count_WaveformwidgetType),
m_config(0),
m_skipRender(false),
m_frameRate(30),
m_defaultZoom(3),
m_zoomSync(false),
m_overviewNormalized(false),
m_openGLAvailable(false),
m_openGLShaderAvailable(false),
m_vsyncThread(NULL),
m_frameCnt(0),
m_actualFrameRate(0) {
m_visualGain[All] = 1.5;
m_visualGain[Low] = 1.0;
m_visualGain[Mid] = 1.0;
m_visualGain[High] = 1.0;
if (QGLFormat::hasOpenGL()) {
QGLFormat glFormat;
glFormat.setDirectRendering(true);
glFormat.setDoubleBuffer(true);
glFormat.setDepth(false);
// Disable waiting for vertical Sync
// This can be enabled when using a single Threads for each QGLContext
// Setting 1 causes QGLContext::swapBuffer to sleep until the next VSync
#if defined(__APPLE__)
// On OS X, syncing to vsync has good performance FPS-wise and
// eliminates tearing.
glFormat.setSwapInterval(1);
#else
// Otherwise, turn VSync off because it could cause horrible FPS on
// Linux.
// TODO(XXX): Make this configurable.
// TOOD(XXX): What should we do on Windows?
glFormat.setSwapInterval(0);
#endif
glFormat.setRgba(true);
QGLFormat::setDefaultFormat(glFormat);
QGLFormat::OpenGLVersionFlags version = QGLFormat::openGLVersionFlags();
int majorVersion = 0;
int minorVersion = 0;
if (version == QGLFormat::OpenGL_Version_None) {
m_openGLVersion = "None";
} else if (version & QGLFormat::OpenGL_Version_3_0) {
majorVersion = 3;
} else if (version & QGLFormat::OpenGL_Version_2_1) {
majorVersion = 2;
minorVersion = 1;
} else if (version & QGLFormat::OpenGL_Version_2_0) {
majorVersion = 2;
minorVersion = 0;
} else if (version & QGLFormat::OpenGL_Version_1_5) {
majorVersion = 1;
minorVersion = 5;
} else if (version & QGLFormat::OpenGL_Version_1_4) {
majorVersion = 1;
minorVersion = 4;
} else if (version & QGLFormat::OpenGL_Version_1_3) {
majorVersion = 1;
minorVersion = 3;
} else if (version & QGLFormat::OpenGL_Version_1_2) {
majorVersion = 1;
minorVersion = 2;
} else if (version & QGLFormat::OpenGL_Version_1_1) {
majorVersion = 1;
minorVersion = 1;
}
if (majorVersion != 0) {
m_openGLVersion = QString::number(majorVersion) + "." +
QString::number(minorVersion);
}
m_openGLAvailable = true;
QGLWidget* glWidget = new QGLWidget(); // create paint device
// QGLShaderProgram::hasOpenGLShaderPrograms(); valgind error
m_openGLShaderAvailable = QGLShaderProgram::hasOpenGLShaderPrograms(glWidget->context());
delete glWidget;
}
evaluateWidgets();
m_time.start();
}
int main(int argc, char *argv[])
{
int i;
const char *resPath = 0;
char override_base_file[MAX_STR_LEN] = "";
int override_local_port = 0;
char override_remote_host[MAX_STR_LEN] = "";
int override_remote_port = 0;
char configfile[MAX_STR_LEN] = "mume.ini";
int default_local_port = 3000;
int default_remote_port = 4242;
int mud_emulation = 0;
#ifdef Q_OS_MACX
CFURLRef pluginRef = CFBundleCopyBundleURL(CFBundleGetMainBundle());
CFStringRef macPath = CFURLCopyFileSystemPath(pluginRef,
kCFURLPOSIXPathStyle);
const char *appPath = CFStringGetCStringPtr(macPath,
CFStringGetSystemEncoding());
resPath = (char *)malloc(strlen(appPath)+25);
strcpy(resPath, appPath);
strcat(resPath, "/Contents/Resources/");
char default_base_file[MAX_STR_LEN] = "mume.pmf";
char default_remote_host[MAX_STR_LEN] = "";
strcpy(configfile, "configs/default.conf");
CFRelease(pluginRef);
CFRelease(macPath);
#else
resPath = "";
char default_base_file[MAX_STR_LEN] = "mume.pmf";
char default_remote_host[MAX_STR_LEN] = "129.241.210.221";
#endif
QApplication::setColorSpec( QApplication::CustomColor );
QApplication app( argc, argv );
QPixmap pixmap("images/logo.png");
QSplashScreen *splash = new QSplashScreen(pixmap);
splash->show();
splash->showMessage("Loading configuration and database...");
for (i=1; i < argc; i++) {
if ((strcmp(argv[i], "--config") == 0) || ( strcmp(argv[i], "-c") == 0))
{
if (i == argc) {
printf("Too few arguments. Missing config file name.\r\n");
print_usage();
exit(1);
}
i++;
strcpy(configfile, argv[i]);
resPath = ""; // obviously the user has an own config file - including the path
}
if ((strcmp(argv[i], "--emulate") == 0) || ( strcmp(argv[i], "-e") == 0))
{
printf("Pandora: Starting in MUD emulation mode.\r\n");
mud_emulation = 1;
}
if ((strcmp(argv[i], "--base") == 0) || ( strcmp(argv[i], "-b") == 0))
{
if (i == argc) {
printf("Too few arguments. Missing database.\r\n");
print_usage();
exit(1);
}
i++;
strcpy(override_base_file, argv[i]); // overriding the database file is possible even with default config file
}
if ((strcmp(argv[i], "--hostname") == 0) || ( strcmp(argv[i], "-hn") == 0))
{
if (i == argc) {
printf("Too few arguments. Wrong hostname given.\r\n");
print_usage();
exit(1);
}
i++;
strcpy(override_remote_host, argv[i]);
}
if ((strcmp(argv[i], "--localport") == 0) || ( strcmp(argv[i], "-lp") == 0))
{
if (i == argc) {
printf("Too few arguments. Missing localport.\r\n");
print_usage();
exit(1);
}
i++;
override_local_port = atoi(argv[i]);
}
if ((strcmp(argv[i], "--remoteport") == 0) || ( strcmp(argv[i], "-rp") == 0))
{
if (i == argc) {
printf("Too few arguments. Missing targetport.\r\n");
print_usage();
exit(1);
}
i++;
override_remote_port = atoi(argv[i]);
}
if ((strcmp(argv[i], "--help") == 0) || ( strcmp(argv[i], "-h") == 0))
{
print_usage();
exit(1);
}
}
/* set analyzer engine defaults */
//engine_init();
splash->showMessage(QString("Loading the configuration ") + configfile);
conf = new Cconfigurator();
conf->loadConfig(resPath, configfile);
print_debug(DEBUG_SYSTEM, "starting up...");
if (override_base_file[0] != 0) {
conf->setBaseFile(override_base_file);
} else if ( conf->getBaseFile() == "") {
conf->setBaseFile(default_base_file);
}
print_debug(DEBUG_SYSTEM, "Using database file : %s.", (const char*) conf->getBaseFile() );
if (override_remote_host[0] != 0) {
conf->setRemoteHost(override_remote_host);
} else if ( conf->getRemoteHost().isEmpty() ) {
conf->setRemoteHost(default_remote_host);
}
print_debug(DEBUG_SYSTEM, "Using target hostname : %s.", (const char*) conf->getRemoteHost() );
if (override_local_port != 0) {
conf->setLocalPort(override_local_port);
} else if ( conf->getLocalPort() == 0) {
conf->setLocalPort(default_local_port);
}
print_debug(DEBUG_SYSTEM, "Using local port : %i.", conf->getLocalPort());
if (override_remote_port != 0) {
conf->setRemotePort(override_remote_port);
} else if (conf->getRemotePort() == 0) {
conf->setRemotePort(default_remote_port);
}
print_debug(DEBUG_SYSTEM, "Using target port : %i.", conf->getRemotePort());
conf->setConfigModified( false );
splash->showMessage("Starting Analyzer and Proxy...");
engine = new CEngine(new CRoomManager());
proxy = new Proxy();
/* special init for the mud emulation */
if (mud_emulation) {
print_debug(DEBUG_SYSTEM, "Starting in MUD emulation mode...");
engine->initEmulationMode();
}
proxy->setMudEmulation( mud_emulation );
print_debug(DEBUG_SYSTEM, "Starting renderer ...\n");
if ( !QGLFormat::hasOpenGL() ) {
qWarning( "This system has no OpenGL support. Quiting." );
return -1;
}
QRect rect = app.desktop()->availableGeometry(-1);
if (conf->getWindowRect().x() == 0 || conf->getWindowRect().x() >= rect.width() ||
conf->getWindowRect().y() >= rect.height() ) {
print_debug(DEBUG_SYSTEM && DEBUG_INTERFACE, "Autosettings for window size and position");
int x, y, height, width;
x = rect.width() / 3 * 2;
y = 0;
height = rect.height() / 3;
width = rect.width() - x;
conf->setWindowRect( x, y, width, height);
}
QGLFormat f = QGLFormat::defaultFormat();
f.setDoubleBuffer( true );
f.setDirectRendering( true );
f.setRgba( true );
f.setDepth( true );
f.setAlpha( true );
if (conf->getMultisampling())
f.setSampleBuffers( true );
//f.setSamples(4);
QGLFormat::setDefaultFormat( f );
renderer_window = new CMainWindow;
renderer_window->show();
splash->finish(renderer_window);
delete splash;
proxy->start();
QObject::connect(proxy, SIGNAL(startEngine()), engine, SLOT(slotRunEngine()), Qt::QueuedConnection );
QObject::connect(proxy, SIGNAL(startRenderer()), renderer_window->renderer, SLOT(display()), Qt::QueuedConnection);
// this will be done via mainwindow itself
//userland_parser->parse_user_input_line("mload");
return app.exec();
}
void System::initializeGL()
{
// We will destroy and rebuild it with the chosen OpenGL format in the end, but we need to have a valid current OpenGL
// context for calling some of the methods below.
//sharedWidget = new QGLWidget;
//sharedWidget->makeCurrent();
struct _GLVersion
{
unsigned int majorVer;
unsigned int minorVer;
};
// Array of all the OpenGL versions that gtatools-gui might work with. We will try to build a context with the first entry
// in this array, and if that fails, we go on trying the next one and so on.
_GLVersion glVersionsToTry[] = {
{ 4, 3 },
{ 4, 2 },
{ 4, 1 },
{ 4, 0 },
{ 3, 3 },
{ 3, 2 },
{ 3, 1 },
{ 3, 0 }
};
QGLFormat::OpenGLVersionFlags vflags = QGLFormat::openGLVersionFlags();
QGLFormat defaultGlFormat;
defaultGlFormat.setDoubleBuffer(true);
defaultGlFormat.setDirectRendering(true);
defaultGlFormat.setDepth(true);
defaultGlFormat.setAlpha(true);
// NOTE: This line is VERY important. GLEW (tested with version 1.11) does not work with OpenGL 3.2+ Core Contexts,
// apparently because it calls glGetString(GL_EXTENSIONS), which is deprecated and therefore returns an error on the
// Core profile, which makes GLEW fail at basically everything.
// This issue is described in http://www.opengl.org/wiki/OpenGL_Loading_Library. Quote:
//
// "GLEW has a problem with core contexts. It calls glGetString(GL_EXTENSIONS), which causes GL_INVALID_ENUM on GL
// 3.2+ core context as soon as glewInit() is called. It also doesn't fetch the function pointers. The solution
// is for GLEW to use glGetStringi instead. The current version of GLEW is 1.10.0 but they still haven't corrected
// it. The only fix is to use glewExperimental for now"
//
// Instead of using glewExperimental, we simply use the compatibility profile (which is probably a good idea in general,
// god knows how many "deprecated" (-> compatibility!) features I use in libgta that might fail with a core context...
defaultGlFormat.setProfile(QGLFormat::CompatibilityProfile);
int majorVer = 0;
int minorVer = 0;
bool foundMatching = false;
for (size_t i = 0 ; i < sizeof(glVersionsToTry)/sizeof(_GLVersion) ; i++) {
_GLVersion ver = glVersionsToTry[i];
defaultGlFormat.setVersion(ver.majorVer, ver.minorVer);
sharedWidget = new QGLWidget(defaultGlFormat);
sharedWidget->makeCurrent();
majorVer = sharedWidget->format().majorVersion();
minorVer = sharedWidget->format().minorVersion();
if (majorVer > ver.majorVer || (majorVer == ver.majorVer && minorVer >= ver.minorVer)) {
foundMatching = true;
break;
} else {
delete sharedWidget;
}
}
if (!foundMatching) {
fprintf(stderr, "ERROR: OpenGL >= 3.0 seems to be unsupported on the system. gtatools-gui will need at least OpenGL "
"3.0 to work correctly!\n");
}
printf("Using OpenGL version %d.%d\n", majorVer, minorVer);
QGLFormat::setDefaultFormat(defaultGlFormat);
}
int main(int argc,char* argv[]) {
qRegisterMetaType<medDataIndex>("medDataIndex");
// this needs to be done before creating the QApplication object, as per the
// Qt doc, otherwise there are some edge cases where the style is not fully applied
QApplication::setStyle("plastique");
medApplication application(argc,argv);
medSplashScreen splash(QPixmap(":/pixmaps/medInria-splash.png"));
setlocale(LC_NUMERIC, "C");
if (dtkApplicationArgumentsContain(&application, "-h") || dtkApplicationArgumentsContain(&application, "--help")) {
qDebug() << "Usage: medInria [--fullscreen|--no-fullscreen] [--stereo] "
#ifdef ACTIVATE_WALL_OPTION
"[--wall] [--tracker=URL] "
#endif
"[--view] [files]]";
return 1;
}
// Do not show the splash screen in debug builds because it hogs the
// foreground, hiding all other windows. This makes debugging the startup
// operations difficult.
#if !defined(_DEBUG)
bool show_splash = true;
#else
bool show_splash = false;
#endif
medSettingsManager* mnger = medSettingsManager::instance();
QStringList posargs;
for (int i=1;i<application.argc();++i) {
const QString arg = application.argv()[i];
if (arg.startsWith("--")) {
bool valid_option = false;
const QStringList options = (QStringList()
<< "--fullscreen"
<< "--no-fullscreen"
<< "--wall"
<< "--tracker"
<< "--stereo"
<< "--view");
for (QStringList::const_iterator opt=options.constBegin();opt!=options.constEnd();++opt)
if (arg.startsWith(*opt))
valid_option = true;
if (!valid_option) { qDebug() << "Ignoring unknown option " << arg; }
continue;
}
posargs.append(arg);
}
const bool DirectView = dtkApplicationArgumentsContain(&application,"--view") || posargs.size()!=0;
int runningMedInria = 0;
if (DirectView) {
show_splash = false;
for (QStringList::const_iterator i=posargs.constBegin();i!=posargs.constEnd();++i) {
const QString& message = QString("/open ")+*i;
runningMedInria = application.sendMessage(message);
}
} else {
runningMedInria = application.sendMessage("");
}
if (runningMedInria)
return 0;
if (show_splash) {
QObject::connect(medDatabaseController::instance().data(),
SIGNAL(copyMessage(QString,int,QColor)),
&splash,SLOT(showMessage(QString,int, QColor)));
application.setMsgColor(Qt::white);
application.setMsgAlignment(Qt::AlignLeft|Qt::AlignBottom);
QObject::connect(medPluginManager::instance(),SIGNAL(loadError(const QString&)),
&application,SLOT(redirectMessageToSplash(const QString&)) );
QObject::connect(medPluginManager::instance(),SIGNAL(loaded(QString)),
&application,SLOT(redirectMessageToSplash(QString)) );
QObject::connect(&application,SIGNAL(showMessage(const QString&, int, const QColor&)),
&splash,SLOT(showMessage(const QString&, int, const QColor&)) );
splash.show();
splash.showMessage("Loading plugins...",Qt::AlignLeft|Qt::AlignBottom,Qt::white);
}
// DATABASE INITIALISATION.
// First compare the current with the new data location
QString currentLocation = medStorage::dataLocation();
// If the user configured a new location for the database in the settings editor, we'll need to move it
QString newLocation = mnger->value("medDatabaseSettingsWidget", "new_database_location").toString();
if (!newLocation.isEmpty()) {
// If the locations are different we need to move the db to the new location
if (currentLocation.compare(newLocation)!=0) {
if (!medDatabaseController::instance()->moveDatabase(newLocation)) {
qDebug() << "Failed to move the database from " << currentLocation << " to " << newLocation;
// The new location is invalid so set it to zero
newLocation = "";
}
mnger->setValue("medDatabaseSettingsWidget", "actual_database_location",newLocation);
// We need to reset the new Location to prevent doing it all the time
mnger->setValue("medDatabaseSettingsWidget", "new_database_location","");
}
}
// END OF DATABASE INITIALISATION
medPluginManager::instance()->initialize();
medMainWindow mainwindow;
if (DirectView)
mainwindow.setStartup(medMainWindow::WorkSpace,posargs);
forceShow(mainwindow);
bool fullScreen = medSettingsManager::instance()->value("startup", "fullscreen", false).toBool();
const bool hasFullScreenArg = application.arguments().contains("--fullscreen");
const bool hasNoFullScreenArg = application.arguments().contains("--no-fullscreen");
const bool hasWallArg = application.arguments().contains("--wall");
const int conflict = static_cast<int>(hasFullScreenArg)+static_cast<int>(hasNoFullScreenArg)+ static_cast<int>(hasWallArg);
if (conflict>1)
dtkWarn() << "Conflicting command line parameters between --fullscreen, --no-fullscreen and -wall. Ignoring.";
else {
if (hasWallArg) {
mainwindow.setWallScreen(true);
fullScreen = false;
}
if (hasFullScreenArg)
fullScreen = true;
if (hasNoFullScreenArg)
fullScreen = false;
}
mainwindow.setFullScreen(fullScreen);
if(application.arguments().contains("--stereo")) {
QGLFormat format;
format.setAlpha(true);
format.setDoubleBuffer(true);
format.setStereo(true);
format.setDirectRendering(true);
QGLFormat::setDefaultFormat(format);
}
if (show_splash)
splash.finish(&mainwindow);
if (medPluginManager::instance()->plugins().isEmpty()) {
QMessageBox::warning(&mainwindow,
QObject::tr("No plugin loaded"),
QObject::tr("Warning : no plugin loaded successfully."));
}
// Handle signals for multiple medInria instances.
QObject::connect(&application,SIGNAL(messageReceived(const QString&)),
&mainwindow,SLOT(onNewInstance(const QString&)));
application.setActivationWindow(&mainwindow);
application.setMainWindow(&mainwindow);
// Start main loop.
const int status = application.exec();
medPluginManager::instance()->uninitialize();
return status;
}