int main(int argc, char *argv[]) { qInstallMessageHandler(&handleMessageOutput); QApplication app(argc, argv); std::vector<QSurfaceFormat> formats; #if !defined(QT_OPENGL_ES) { QSurfaceFormat glFormat; glFormat.setRenderableType(QSurfaceFormat::OpenGL); glFormat.setProfile(QSurfaceFormat::CoreProfile); glFormat.setVersion(4,3); formats.push_back(glFormat); } #endif #if defined(QT_OPENGL_ES) { QSurfaceFormat glesFormat; glesFormat.setRenderableType(QSurfaceFormat::OpenGLES); glesFormat.setProfile(QSurfaceFormat::CoreProfile); glesFormat.setVersion(3,0); formats.push_back(glesFormat); } #endif // Find out which version we support QSurfaceFormat *format = getFirstSupported(formats); if (format == NULL) { QMessageBox::critical(0, "Critical Error", "No valid supported version of OpenGL found on device!"); exit(-1); } #ifdef GL_DEBUG format->setOption(QSurfaceFormat::DebugContext); #endif // GL_DEBUG format->setDepthBufferSize(0); // Set the widget up MainWidget *widget = new MainWidget; widget->setFormat(*format); // Set the window up MainWindow *window = new MainWindow; window->show(); return app.exec(); }
void RunTestInOpenGLOffscreenEnvironment(char const * testName, bool apiOpenGLES3, TestFunction const & fn) { std::vector<char> buf(strlen(testName) + 1); strcpy(buf.data(), testName); char * raw = buf.data(); int argc = 1; QApplication app(argc, &raw); QSurfaceFormat fmt; fmt.setAlphaBufferSize(8); fmt.setBlueBufferSize(8); fmt.setGreenBufferSize(8); fmt.setRedBufferSize(8); fmt.setStencilBufferSize(0); fmt.setSamples(0); fmt.setSwapBehavior(QSurfaceFormat::DoubleBuffer); fmt.setSwapInterval(1); fmt.setDepthBufferSize(16); if (apiOpenGLES3) { fmt.setProfile(QSurfaceFormat::CoreProfile); fmt.setVersion(3, 2); } else { fmt.setProfile(QSurfaceFormat::CompatibilityProfile); fmt.setVersion(2, 1); } auto surface = std::make_unique<QOffscreenSurface>(); surface->setFormat(fmt); surface->create(); auto context = std::make_unique<QOpenGLContext>(); context->setFormat(fmt); context->create(); context->makeCurrent(surface.get()); if (fn) fn(apiOpenGLES3); context->doneCurrent(); surface->destroy(); QTimer::singleShot(0, &app, SLOT(quit())); app.exec(); }
OpenGLWidget::OpenGLWidget(MainWindow* mainWindow) : QOpenGLWidget{mainWindow} , m_axisLegendScene{mainWindow->app()} , m_width{0} , m_height{0} , m_currentLocation{} , m_previousLocation{} { this->setFocusPolicy(Qt::StrongFocus); m_contextMenu = new QMenu(this); QMenu* createMenu = m_contextMenu->addMenu("Create"); createMenu->addAction(tr("Box"), this, SLOT(createBox())); createMenu->addAction(tr("Cylinder"), this, SLOT(createCylinder())); createMenu->addAction(tr("Cone"), this, SLOT(createCone())); createMenu->addAction(tr("Sphere"), this, SLOT(createSphere())); m_contextMenu->addAction(tr("Import Mesh"), this, SLOT(importMesh())); QSurfaceFormat format = this->format(); format.setVersion(kOpenGLMajorVersion, kOpenGLMinorVersion); format.setProfile(QSurfaceFormat::CoreProfile); format.setDepthBufferSize(32); format.setSwapBehavior(QSurfaceFormat::DoubleBuffer); LOG(INFO) << fmt::format("Setting format with OpenGL version {}.{}", kOpenGLMajorVersion, kOpenGLMinorVersion); this->setFormat(format); }
MainWindow::MainWindow ( QWidget * parent ): QMainWindow(parent), m_ui(new Ui::MainWindow) { m_ui->setupUi(this); // Setup OpenGL context format QSurfaceFormat format; #ifdef __APPLE__ // Get OpenGL 3.2/4.1 core context format.setVersion(3, 2); format.setProfile(QSurfaceFormat::CoreProfile); #else // Get newest available compatibility context #endif format.setDepthBufferSize(16); // Create OpenGL context and window m_canvas.reset(new gloperate_qt::QtOpenGLWindowBase(format)); // Create widget container setCentralWidget(QWidget::createWindowContainer(m_canvas.get())); centralWidget()->setFocusPolicy(Qt::StrongFocus); }
int main(int argc, char *argv[]) { QApplication app(argc, argv); QApplication::setApplicationName("Editor"); QApplication::setApplicationVersion("1.0"); #if C3_OS == C3_OS_WINDOWS_NT //Windows native theme looks so ugly app.setStyle("fusion"); #endif QCommandLineParser parser; parser.setApplicationDescription("The Editor"); parser.addHelpOption(); parser.addVersionOption(); QCommandLineOption dataDirOption("root", "Root directory location.\nThis will override ENGINE_ROOT.", "path"); parser.addOption(dataDirOption); parser.process(app); QProcessEnvironment env = QProcessEnvironment::systemEnvironment(); QString absPath; if(!parser.value(dataDirOption).isEmpty()) { absPath = parser.value(dataDirOption); } else if(env.contains("ENGINE_ROOT")) absPath = env.value("ENGINE_ROOT"); else absPath = "."; QFileInfo dirInfo(absPath); if(!dirInfo.exists() || !dirInfo.isDir() || !QFileInfo::exists(absPath + "/Data")) { const char* msg = "Invalid root directory!"; QMessageBox::critical(nullptr, app.applicationName(), msg); throw msg; } absPath = dirInfo.canonicalFilePath(); EngineLoader.SetRootDirectory(absPath.toUtf8().constData()); c3::RC.Loader = &EngineLoader; c3::RC.Loader->InitEngine(); c3::FEditor EditorController; c3::RC.Editor = &EditorController; QSurfaceFormat format; format.setVersion(4, 5); format.setProfile(QSurfaceFormat::CoreProfile); format.setDepthBufferSize(24); format.setStencilBufferSize(8); QSurfaceFormat::setDefaultFormat(format); MainWindow mainWindow; c3::FLogDisplay* LogDisplay = static_cast<c3::FLogDisplay*>(EditorController.GetLogDisplay()); QObject::connect(LogDisplay, &c3::FLogDisplay::LogRefreshed, &mainWindow, &MainWindow::OnLogChanged); mainWindow.showMaximized(); app.exec(); }
int main(int argc, char *argv[]) { qputenv("PATH", qgetenv("PATH") + ":/usr/local/bin:/usr/bin"); QApplication a(argc, argv); QSplashScreen s(QPixmap(":/application/splash"), Qt::WindowStaysOnTopHint); s.show(); QApplication::setOrganizationName("Regulomics"); QApplication::setApplicationName("QChromosome 4D Studio"); QApplication::setWindowIcon(QIcon(":/application/icon")); QSurfaceFormat format; format.setDepthBufferSize(24); format.setVersion(4, 1); format.setProfile(QSurfaceFormat::CoreProfile); QSurfaceFormat::setDefaultFormat(format); QFontDatabase::addApplicationFont(":/fonts/Roboto-Regular"); QFontDatabase::addApplicationFont(":/fonts/Roboto-Bold"); QFontDatabase::addApplicationFont(":/fonts/RobotoMono-Regular"); MainWindow w(a.arguments().mid(1)); a.installEventFilter(&w); w.showMaximized(); s.finish(&w); return a.exec(); }
int main(int argc, char* argv[]) { QGuiApplication app(argc,argv); qmlRegisterType<Connector>("Connector", 1, 0, "Connector"); app.setOrganizationName("QtProject");\ app.setOrganizationDomain("qt-project.org");\ app.setApplicationName(QFileInfo(app.applicationFilePath()).baseName());\ QQuickView view;\ if (qgetenv("QT_QUICK_CORE_PROFILE").toInt()) {\ QSurfaceFormat f = view.format();\ f.setProfile(QSurfaceFormat::CoreProfile);\ f.setVersion(4, 4);\ view.setFormat(f);\ }\ view.connect(view.engine(), SIGNAL(quit()), &app, SLOT(quit()));\ new QQmlFileSelector(view.engine(), &view);\ view.setSource(QUrl("qrc:///demos/tweetsearch/tweetsearch.qml")); \ view.setResizeMode(QQuickView::SizeRootObjectToView);\ if (QGuiApplication::platformName() == QLatin1String("qnx") || \ QGuiApplication::platformName() == QLatin1String("eglfs")) {\ view.showFullScreen();\ } else {\ view.show();\ }\ return app.exec();\ }
int main(int argc, char** argv) try { QApplication app(argc, argv); app.setApplicationDisplayName("Interactive OpenBC sim. interface"); QSurfaceFormat fmt; fmt.setDepthBufferSize(24); //if (QCoreApplication::arguments().contains(QStringLiteral("--multisample"))) { std::cout << "Using multisample" << std::endl;; fmt.setSamples(4); //} // Hard-coded to use the core profile. fmt.setVersion(3, 2); fmt.setProfile(QSurfaceFormat::CoreProfile); QSurfaceFormat::setDefaultFormat(fmt); MainWindow mainWindow; mainWindow.resize(mainWindow.sizeHint()); int desktopArea = QApplication::desktop()->width()*QApplication::desktop()->height(); int widgetArea = mainWindow.width()*mainWindow.height(); if (((float)widgetArea / (float)desktopArea) < 0.75f) { mainWindow.show(); } else { mainWindow.showMaximized(); } return app.exec(); } catch (std::exception& e) { std::cout << "Caught exception: " << e.what() << std::endl; } catch (...) { std::cout << "Caught unknown exception.\n"; }
EffectsManager::EffectsManager(QObject *parent) : QObject(parent), QQuickImageProvider(QQuickImageProvider::Image) { if (qgetenv("QT_QUICK_CORE_PROFILE").toInt()) {\ QSurfaceFormat f = view.format();\ f.setProfile(QSurfaceFormat::CoreProfile);\ f.setVersion(4, 4);\ view.setFormat(f);\ }\ // view.connect(view.engine(), SIGNAL(quit()), &app, SLOT(quit())); new QQmlFileSelector(view.engine(), &view); view.engine()->rootContext()->setContextProperty("effectsControll", this); //view.engine()->addImageProvider("loader", cloneImg); view.setSource(QUrl("qrc:/mainEffectWindow.qml")); \ view.setResizeMode(QQuickView::SizeRootObjectToView); // view.setPersistentOpenGLContext(true); view.setColor("transparent"); //addEffect("first",100,100); /* QStringList dataList; dataList.append("Item 1"); QQmlContext *ctxt = view.rootContext(); ctxt->setContextProperty("myModel", QVariant::fromValue(dataList));*/ //viewsetFont(QFont("Segoe Script")); /* QSize t_size(300,300); view.setMaximumSize(t_size); view.setMinimumSize(t_size); */ }
int main(int argc, char *argv[]) { QApplication a(argc, argv); // Set OpenGL 3.2 and, optionally, 4-sample multisampling QSurfaceFormat format; format.setVersion(3, 2); format.setOption(QSurfaceFormat::DeprecatedFunctions, false); format.setProfile(QSurfaceFormat::CoreProfile); //format.setSamples(4); // Uncomment for nice antialiasing. Not always supported. /*** AUTOMATIC TESTING: DO NOT MODIFY ***/ /*** Check whether automatic testing is enabled */ /***/ if (qgetenv("CIS277_AUTOTESTING") != nullptr) format.setSamples(0); QSurfaceFormat::setDefaultFormat(format); debugFormatVersion(); MainWindow w; w.show(); w.sendItems(); return a.exec(); }
int main(int argc, char *argv[]) { QApplication app(argc, argv); QSurfaceFormat fmt; fmt.setDepthBufferSize(24); if (QCoreApplication::arguments().contains(QStringLiteral("--multisample"))) fmt.setSamples(4); if (QCoreApplication::arguments().contains(QStringLiteral("--coreprofile"))) { fmt.setVersion(3, 2); fmt.setProfile(QSurfaceFormat::CoreProfile); } QSurfaceFormat::setDefaultFormat(fmt); MainWindow mainWindow; mainWindow.resize(mainWindow.sizeHint()); int desktopArea = QApplication::desktop()->width() * QApplication::desktop()->height(); int widgetArea = mainWindow.width() * mainWindow.height(); if (((float)widgetArea / (float)desktopArea) < 0.75f) mainWindow.show(); else mainWindow.showMaximized(); return app.exec(); }
int main(int argc, char *argv[]) { QApplication app(argc, argv); Q_INIT_RESOURCE(ARehab_vTerapeuta); QSurfaceFormat format; format.setVersion(4, 3); format.setProfile(QSurfaceFormat::CoreProfile); format.setOption(QSurfaceFormat::DebugContext); format.setRenderableType(QSurfaceFormat::OpenGL); format.setDepthBufferSize(24); format.setStencilBufferSize(8); format.setSamples(4); format.setSwapInterval(0); //Disable VSync QSurfaceFormat::setDefaultFormat(format); ARehabGUIDesigner::ARehabMainWindow w; QFile styleFile(":/styles/main.qss"); styleFile.open(QFile::ReadOnly); app.setStyleSheet(QLatin1String(styleFile.readAll())); styleFile.close(); w.show(); return (app.exec()); }
void Viewer::setupCanvas() { QSurfaceFormat format; format.setVersion(3, 2); format.setProfile(QSurfaceFormat::CoreProfile); format.setDepthBufferSize(16); // Create OpenGL context and window m_canvas.reset(new gloperate_qt::QtOpenGLWindow(*m_resourceManager, format)); // Create widget container setCentralWidget(QWidget::createWindowContainer(m_canvas.get())); centralWidget()->setFocusPolicy(Qt::StrongFocus); // Setup event provider to translate Qt messages into gloperate events gloperate_qt::QtKeyEventProvider * keyProvider = new gloperate_qt::QtKeyEventProvider(); keyProvider->setParent(m_canvas.get()); gloperate_qt::QtMouseEventProvider * mouseProvider = new gloperate_qt::QtMouseEventProvider(); mouseProvider->setParent(m_canvas.get()); gloperate_qt::QtWheelEventProvider * wheelProvider = new gloperate_qt::QtWheelEventProvider(); wheelProvider->setParent(m_canvas.get()); m_canvas->installEventFilter(keyProvider); m_canvas->installEventFilter(mouseProvider); m_canvas->installEventFilter(wheelProvider); // Create input mapping for gloperate interaction techniques m_mapping.reset(new QtViewerMapping(m_canvas.get())); m_mapping->addProvider(keyProvider); m_mapping->addProvider(mouseProvider); m_mapping->addProvider(wheelProvider); }
int main(int argc, char* argv[]) { QApplication app(argc, argv); QVRManager manager(argc, argv); /* Load the model file */ if (argc != 2) { std::cerr << argv[0] << ": requires model filename argument." << std::endl; return 1; } osg::ref_ptr<osgDB::ReaderWriter::Options> options = new osgDB::ReaderWriter::Options(); options->setOptionString("noRotation"); osg::ref_ptr<osg::Node> model = osgDB::readNodeFile(argv[1], options); if (!model) { std::cerr << argv[0] << ": no data loaded." << std::endl; return 1; } /* First set the default surface format that all windows will use */ QSurfaceFormat format; format.setProfile(QSurfaceFormat::CompatibilityProfile); // OSG cannot handle core profiles format.setVersion(3, 3); QSurfaceFormat::setDefaultFormat(format); /* Then start QVR with your app */ QVROSGViewer qvrapp(model); if (!manager.init(&qvrapp)) { std::cerr << "Cannot initialize QVR manager" << std::endl; return 1; } /* Enter the standard Qt loop */ return app.exec(); }
void GLViewer::setup() { QSurfaceFormat format; format.setVersion(3, 2); format.setProfile(QSurfaceFormat::CoreProfile); format.setDepthBufferSize(16); m_canvas = new Canvas(format); m_canvas->setContinuousRepaint(true, 0); m_canvas->setSwapInterval(Canvas::VerticalSyncronization); m_canvas->setPainter(m_painter); QWidget *widget = QWidget::createWindowContainer(m_canvas); widget->setMinimumSize(1, 1); widget->setAutoFillBackground(false); // Important for overdraw, not occluding the scene. widget->setFocusPolicy(Qt::TabFocus); widget->setParent(this); QHBoxLayout *layout = new QHBoxLayout; layout->setContentsMargins(0, 0, 0, 0); layout->addWidget(widget); setLayout(layout); show(); }
OGLViewer::OGLViewer(QWidget *parent) : QOpenGLWidget(parent), mTimeCount(0), mFps(30) , mSelectMode(OBJECT_SELECT) , mViewCamera(new PerspectiveCamera(Point3f(10, 6, 11), Point3f(0, 0, 0), Vector3f(0, 1, 0), width() / float(height()))) , box_mesh(new TriangleMesh("../../scene/obj/cube_large.obj")) , model_mesh(new TriangleMesh("../../scene/obj/monkey.obj")) { // Set surface format for current widget QSurfaceFormat format; format.setDepthBufferSize(32); format.setStencilBufferSize(8); format.setSamples(4); format.setVersion(4, 5); format.setProfile(QSurfaceFormat::CoreProfile); this->setFormat(format); // Link timer trigger /*process_time.start(); QTimer *timer = new QTimer(this); //timer->setSingleShot(false); connect(timer, SIGNAL(timeout()), this, SLOT(update())); timer->start(0);*/ }
OGLViewer::OGLViewer(QWidget *parent) : QOpenGLWidget(parent), tcount(0), fps(30) , simp_lv(1) , m_selectMode(OBJECT_SELECT) { // Set surface format for current widget QSurfaceFormat format; format.setDepthBufferSize(32); format.setStencilBufferSize(8); format.setVersion(4, 5); format.setProfile(QSurfaceFormat::CoreProfile); this->setFormat(format); // Read obj file //box_mesh = new Mesh("../../scene/obj/cube_large.obj"); //model_mesh = new Mesh("../../scene/obj/monkey.obj"); #ifdef _DEBUG hds_box = new HDS_Mesh("../../scene/obj/frog.obj"); #else hds_box = new HDS_Mesh("quad_cube.obj"); #endif //hds_box->reIndexing(); //hds_box->validate(); simp_mesh = new Simplification(simp_lv, hds_box); resetCamera(); }
void KisOpenGL::initialize() { #ifdef HAVE_OPENGL dbgUI << "OpenGL: initializing"; KisConfig cfg; QSurfaceFormat format; format.setProfile(QSurfaceFormat::CompatibilityProfile); format.setOptions(QSurfaceFormat::DeprecatedFunctions); format.setDepthBufferSize(24); format.setStencilBufferSize(8); format.setVersion(3, 2); // if (cfg.disableDoubleBuffering()) { if (false) { format.setSwapBehavior(QSurfaceFormat::SingleBuffer); } else { format.setSwapBehavior(QSurfaceFormat::DoubleBuffer); } format.setSwapInterval(0); // Disable vertical refresh syncing QSurfaceFormat::setDefaultFormat(format); #endif }
void ccApplication::init() { //See http://doc.qt.io/qt-5/qopenglwidget.html#opengl-function-calls-headers-and-qopenglfunctions /** Calling QSurfaceFormat::setDefaultFormat() before constructing the QApplication instance is mandatory on some platforms (for example, OS X) when an OpenGL core profile context is requested. This is to ensure that resource sharing between contexts stays functional as all internal contexts are created using the correct version and profile. **/ { QSurfaceFormat format = QSurfaceFormat::defaultFormat(); format.setSwapBehavior( QSurfaceFormat::DoubleBuffer ); format.setStencilBufferSize( 0 ); #ifdef CC_GL_WINDOW_USE_QWINDOW format.setStereo( true ); #endif #ifdef Q_OS_MAC format.setVersion( 2, 1 ); // must be 2.1 - see ccGLWindow::functions() format.setProfile( QSurfaceFormat::CoreProfile ); #endif #ifdef QT_DEBUG format.setOption( QSurfaceFormat::DebugContext, true ); #endif QSurfaceFormat::setDefaultFormat( format ); } // The 'AA_ShareOpenGLContexts' attribute must be defined BEFORE the creation of the Q(Gui)Application // DGM: this is mandatory to enable exclusive full screen for ccGLWidget (at least on Windows) QCoreApplication::setAttribute( Qt::AA_ShareOpenGLContexts ); }
OGLViewer::OGLViewer(QWidget *parent) : QOpenGLWidget(parent), tcount(0) , fps(30), timestep(1.0 / fps), isSim(false) { // Set surface format for current widget QSurfaceFormat format; format.setDepthBufferSize(32); format.setStencilBufferSize(8); format.setVersion(4, 5); format.setProfile(QSurfaceFormat::CoreProfile); this->setFormat(format); // Link timer trigger process_time.start(); QTimer *timer = new QTimer(this); /*timer->setSingleShot(false);*/ connect(timer, SIGNAL(timeout()), this, SLOT(update())); timer->start(0); // Read obj file #ifdef _DEBUG box_mesh = new Mesh("../../scene/obj/cube_huge.obj"); poly_mesh = new Mesh("../../scene/obj/bunny_simple.obj"); poly_bound = new Mesh("../../scene/obj/bunny_bound.obj"); #else box_mesh = new Mesh("cube_large.obj"); poly_mesh = new Mesh("bunny_simple.obj"); poly_bound = new Mesh("bunny_bound.obj"); #endif // _DEBUG poly_bound->refine(triangleList); mytree = new KdTreeAccel(triangleList); texW = sparkTex.getWidth(); texH = sparkTex.getHeight(); sparkTex.getPixelsRGBA(tex_pixels); // Initialize particle generators //Point3D newpos(0.0, 0.0, 0.0), vel(0.3, 1.0, 1.0), vel_var(0.3, 0.3, 0.3); ParticleGenerator* pg = new ParticleGenerator( 3500, 1000, 20, timestep, 3, 0.6, 2.0, 1.2, Point3D(0.0, 5.0, 0.0), Vector3D(0, -10, 0), Vector3D(1, 0, 0), ParticleGenerator::CONCENTRIC_DISK, 0.5); Vector3D* gravity = new Vector3D(0.0, -9.8, 0.0); Vector3D* wind = new Vector3D(0, 0.0, 0.0); pg->addForce(gravity); pg->addForce(wind); pgs.push_back(pg); pg->exportVBO(ptc_size, ptc_verts, ptc_vels, ptc_life, ptc_alive, true); pg->addCollision(mytree); resetCamera(); // Initialize transform matrix matrix.setIdentity();// setRotation(20, 0, 0); matrix.exportVBO(model_mat); }
int main(int argc, char* argv[]) { // read the header const auto header = sepia::read_header(sepia::filename_to_ifstream(filename)); // create the Qt Application QGuiApplication app(argc, argv); // register Chameleon types qmlRegisterType<chameleon::background_cleaner>("Chameleon", 1, 0, "BackgroundCleaner"); qmlRegisterType<chameleon::dvs_display>("Chameleon", 1, 0, "DvsDisplay"); qmlRegisterType<chameleon::flow_display>("Chameleon", 1, 0, "FlowDisplay"); // pass the header properties to qml QQmlApplicationEngine application_engine; application_engine.rootContext()->setContextProperty("header_width", header.width); application_engine.rootContext()->setContextProperty("header_height", header.height); // load the view and setup the window properties for OpenGL renderring application_engine.loadData( #include "optical_flow.qml" ); auto window = qobject_cast<QQuickWindow*>(application_engine.rootObjects().first()); { QSurfaceFormat format; format.setDepthBufferSize(24); format.setStencilBufferSize(8); format.setVersion(3, 3); format.setProfile(QSurfaceFormat::CoreProfile); window->setFormat(format); } // retrieve pointers to the displays generated by qml auto dvs_display = window->findChild<chameleon::dvs_display*>("dvs_display"); auto flow_display = window->findChild<chameleon::flow_display*>("flow_display"); // create the event handling pipeline auto observable = sepia::make_observable<sepia::type::dvs>( sepia::filename_to_ifstream(filename), tarsier::make_replicate<sepia::dvs_event>( [&](sepia::dvs_event dvs_event) { dvs_display->push(dvs_event); }, sepia::make_split<sepia::type::dvs>( tarsier::make_compute_flow<sepia::simple_event, flow_event>( header.width, header.height, 3, // spatial window's radius 10000, // temporal window 8, // minimum number of events in the spatio-temporal window required to trigger a flow event [&](sepia::simple_event simple_event, float vx, float vy) -> flow_event { return {simple_event.t, simple_event.x, simple_event.y, vx, vy}; }, [&](flow_event flow_event) { flow_display->push(flow_event); }), [](sepia::simple_event) {})), [](std::exception_ptr) {}, []() { return true; }); // run the Qt Application return app.exec(); }
int main(int argc, char * argv[]) { QApplication app(argc, argv); ResourceManager resourceManager; resourceManager.addLoader(new QtTextureLoader()); resourceManager.addStorer(new QtTextureStorer()); // Initialize plugin manager PluginManager::init(QCoreApplication::applicationFilePath().toStdString()); // Load example plugins PluginManager pluginManager; #ifdef NDEBUG pluginManager.addPath("plugins"); #else pluginManager.addPath("plugins/debug"); #endif pluginManager.scan("painters"); // Choose a painter std::string name = (argc > 1) ? argv[1] : "CubeScape"; std::cout << "Trying to create painter '" << name << "'\n"; gloperate::Painter * painter = nullptr; Plugin * plugin = pluginManager.plugin(name); if (!plugin) { globjects::fatal() << "Plugin '" << name << "' not found. Listing plugins found:"; pluginManager.printPlugins(); return 1; } painter = plugin->createPainter(resourceManager); // Create OpenGL window QSurfaceFormat format; format.setVersion(3, 2); format.setProfile(QSurfaceFormat::CoreProfile); format.setDepthBufferSize(24); QtOpenGLWindow * window = new QtOpenGLWindow(resourceManager, format); window->setPainter(painter); QRect rect = QApplication::desktop()->screenGeometry(); // used to center the mainwindow on desktop // Create main window QMainWindow mainWindow; mainWindow.setGeometry((rect.width() - 1280) / 2, (rect.height() - 720) / 2, 1280, 720); mainWindow.setCentralWidget(QWidget::createWindowContainer(window)); mainWindow.centralWidget()->setFocusPolicy(Qt::StrongFocus); mainWindow.show(); return app.exec(); }
void Widget::start() { QSurfaceFormat fmt; int idx = m_version->currentIndex(); if (idx < 0) return; fmt.setVersion(versions[idx].major, versions[idx].minor); for (size_t i = 0; i < sizeof(profiles) / sizeof(Profile); ++i) if (static_cast<QRadioButton *>(m_profiles->itemAt(int(i))->widget())->isChecked()) { fmt.setProfile(profiles[i].profile); break; } bool forceGLSL110 = false; for (size_t i = 0; i < sizeof(options) / sizeof(Option); ++i) if (static_cast<QCheckBox *>(m_options->itemAt(int(i))->widget())->isChecked()) { if (options[i].option) fmt.setOption(options[i].option); else if (i == 3) forceGLSL110 = true; } for (size_t i = 0; i < sizeof(renderables) / sizeof(Renderable); ++i) if (static_cast<QRadioButton *>(m_renderables->itemAt(int(i))->widget())->isChecked()) { fmt.setRenderableType(renderables[i].renderable); break; } // The example rendering will need a depth buffer. fmt.setDepthBufferSize(16); m_output->clear(); m_extensions->clear(); qDebug() << "Requesting surface format" << fmt; m_renderWindowLayout->removeWidget(m_renderWindowContainer); delete m_renderWindowContainer; RenderWindow *renderWindow = new RenderWindow(fmt); if (!renderWindow->context()) { m_output->append(tr("Failed to create context")); delete renderWindow; m_renderWindowContainer = new QWidget; addRenderWindow(); return; } m_surface = renderWindow; renderWindow->setForceGLSL110(forceGLSL110); connect(renderWindow, &RenderWindow::ready, this, &Widget::renderWindowReady); connect(renderWindow, &RenderWindow::error, this, &Widget::renderWindowError); m_renderWindowContainer = QWidget::createWindowContainer(renderWindow); addRenderWindow(); }
int main(int argc, char ** argv) { ShowWindow(GetConsoleWindow(), SW_HIDE); QApplication app(argc, argv); QSurfaceFormat format; format.setDepthBufferSize(4); format.setSamples(24); format.setVersion(4, 4); format.setRenderableType(QSurfaceFormat::OpenGL); OpenGLWidget window; window.setFormat(format); window.resize(WINDOW_WIDTH, WINDOW_HEIGHT); selector = new ShaderFinder(); pane = new CollapsiblePanelWidget(&window); pane->setStyleSheet("background-color:white"); pane->setWidgetResizable(true); pane->setGeometry(0, 0, WINDOW_WIDTH / 5, WINDOW_HEIGHT); pane->duration = 500; pane->config(QRect(0, 0, WINDOW_WIDTH / 5, WINDOW_HEIGHT), QRect(-WINDOW_WIDTH / 5, 0, WINDOW_WIDTH / 5, WINDOW_HEIGHT)); paneBox = new QGroupBox(); pane->setWidget(paneBox); paneLayout = new QVBoxLayout(); paneLayout->setSpacing(10); paneLayout->setAlignment(Qt::AlignTop); paneLayout->addWidget(selector); pane->widget()->setLayout(paneLayout); pane->show(); anim = new CollapsiblePanelWidget(&window); anim->setStyleSheet("background-color:white"); anim->setWidgetResizable(true); anim->setGeometry(WINDOW_WIDTH * 0.8, 0, WINDOW_WIDTH / 5, WINDOW_HEIGHT); anim->duration = 500; anim->config(QRect(WINDOW_WIDTH * 0.8, 0, WINDOW_WIDTH / 5, WINDOW_HEIGHT), QRect(WINDOW_WIDTH, 0, WINDOW_WIDTH / 5, WINDOW_HEIGHT)); animBox = new QGroupBox(); anim->setWidget(animBox); animLayout = new QVBoxLayout(); animLayout->setSpacing(10); animLayout->setAlignment(Qt::AlignTop); anim->widget()->setLayout(animLayout); anim->show(); window.show(); return app.exec(); }
ReplayRenderWidget::ReplayRenderWidget(QWidget *parent) : QOpenGLWidget(parent) { QSurfaceFormat format; format.setDepthBufferSize(24); format.setStencilBufferSize(8); format.setVersion(4, 5); format.setProfile(QSurfaceFormat::CompatibilityProfile); setFormat(format); }
Quiddiards::Quiddiards(QWidget* parent) : QOpenGLWidget(parent) { /* init parameters */ QSurfaceFormat format; format.setDepthBufferSize(24); format.setStencilBufferSize(8); format.setVersion(3, 2); QSurfaceFormat::setDefaultFormat(format); initUI(); }
PreviewPane::PreviewPane(QWidget *parent) : QOpenGLWidget(parent), _initialized(false) { setMouseTracking(true); QSurfaceFormat format; format.setDepthBufferSize(24); format.setVersion(3, 3); format.setProfile(QSurfaceFormat::CoreProfile); setFormat(format); }
int main(int argc, char* argv[]) { std::vector<std::string> filenames; if(argc >= 2) { for(int i = 1; i < argc; ++i) { filenames.emplace_back(argv[1]); } } else { throw std::runtime_error("This program expects 1 argument to an audio file"); } std::vector<boost::filesystem::path> paths; std::copy(filenames.begin(), filenames.end(), std::back_inserter(paths)); for(auto&& path : paths) { if(!boost::filesystem::exists(path) || !boost::filesystem::is_regular_file(path)) { throw std::runtime_error(path.string() + "Does not exists or isn't a file"); } } std::vector<std::vector<Real>> samples; std::transform(paths.begin(), paths.end(), std::back_inserter(samples), get_audio_data); std::vector<EnergyChunks> chunks; std::transform(paths.begin(), paths.end(), std::back_inserter(chunks), get_energy_chunks); int retval = 0; { int x = 0; QSurfaceFormat fmt; fmt.setVersion(3, 3); fmt.setProfile(QSurfaceFormat::CoreProfile); QSurfaceFormat::setDefaultFormat(fmt); QApplication qapp(x, nullptr); auto gui = std::make_shared<VisualizerWindow>(); gui->show(); std::vector<WaveformData> data; for(auto&& tuple : zip_range(samples, chunks)) { data.emplace_back(boost::get<0>(tuple), boost::get<1>(tuple)); } gui->visualize(data); retval = qapp.exec(); } return retval; }
void KisOpenGL::setDefaultFormat() { QSurfaceFormat format; #ifdef Q_OS_MAC // format.setProfile(QSurfaceFormat::CoreProfile); // format.setOptions(QSurfaceFormat::DeprecatedFunctions); format.setVersion(2, 1); #else format.setProfile(QSurfaceFormat::CompatibilityProfile); format.setOptions(QSurfaceFormat::DeprecatedFunctions); format.setVersion(3, 0); #endif format.setDepthBufferSize(24); format.setStencilBufferSize(8); format.setSwapBehavior(QSurfaceFormat::DoubleBuffer); KisConfig cfg; if (cfg.disableVSync()) { format.setSwapInterval(0); // Disable vertical refresh syncing } QSurfaceFormat::setDefaultFormat(format); }
int main(int argc, char * argv[]) { int result = -1; Application app(argc, argv); QSurfaceFormat format; #ifdef NO_OPENGL_320 format.setVersion(3, 0); #else format.setVersion(3, 2); format.setProfile(QSurfaceFormat::CoreProfile); #endif format.setDepthBufferSize(24); QScopedPointer<Viewer> viewer(new Viewer(format)); result = app.exec(); return result; // ToDo: QWidget seems to take double ownership of canvas and frees it doubled }