void QMinimalEglScreen::createAndSetPlatformContext() { QSurfaceFormat platformFormat; QByteArray depthString = qgetenv("QT_QPA_EGLFS_DEPTH"); if (depthString.toInt() == 16) { platformFormat.setDepthBufferSize(16); platformFormat.setRedBufferSize(5); platformFormat.setGreenBufferSize(6); platformFormat.setBlueBufferSize(5); m_depth = 16; m_format = QImage::Format_RGB16; } else { platformFormat.setDepthBufferSize(24); platformFormat.setStencilBufferSize(8); platformFormat.setRedBufferSize(8); platformFormat.setGreenBufferSize(8); platformFormat.setBlueBufferSize(8); m_depth = 32; m_format = QImage::Format_RGB32; } if (!qEnvironmentVariableIsEmpty("QT_QPA_EGLFS_MULTISAMPLE")) platformFormat.setSamples(4); EGLConfig config = q_configFromGLFormat(m_dpy, platformFormat); EGLNativeWindowType eglWindow = 0; #ifdef Q_OPENKODE if (kdInitializeNV() == KD_ENOTINITIALIZED) { qFatal("Did not manage to initialize openkode"); } KDWindow *window = kdCreateWindow(m_dpy,config,0); kdRealizeWindow(window,&eglWindow); #endif #ifdef QEGL_EXTRA_DEBUG q_printEglConfig(m_dpy, config); #endif m_surface = eglCreateWindowSurface(m_dpy, config, eglWindow, NULL); if (m_surface == EGL_NO_SURFACE) { qWarning("Could not create the egl surface: error = 0x%x\n", eglGetError()); eglTerminate(m_dpy); qFatal("EGL error"); } // qWarning("Created surface %dx%d\n", w, h); QEGLPlatformContext *platformContext = new QMinimalEglContext(platformFormat, 0, m_dpy); m_platformContext = platformContext; EGLint w,h; // screen size detection eglQuerySurface(m_dpy, m_surface, EGL_WIDTH, &w); eglQuerySurface(m_dpy, m_surface, EGL_HEIGHT, &h); m_geometry = QRect(0,0,w,h); }
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(); }
SsvepBciScreen::SsvepBciScreen(QSharedPointer<SsvepBci> pSsvepBci, QSharedPointer<SsvepBciSetupStimulusWidget> pSsvepBciSetupStimulusWidget, QOpenGLWidget *parent) : m_pSsvepBci(pSsvepBci) , m_pSsvepBciSetupStimulusWidget(pSsvepBciSetupStimulusWidget) , m_pScreenKeyboard(QSharedPointer<ScreenKeyboard>(new ScreenKeyboard(m_pSsvepBci, m_pSsvepBciSetupStimulusWidget, QSharedPointer<SsvepBciScreen>(this)))) , m_dXPosCross(0.5) , m_dYPosCross(0.5) , m_dStep(0.01) , m_bUseScreenKeyboard(false) , m_qPainter(this) , m_qCrossColor(Qt::red) , m_bClearScreen(true) { Q_UNUSED(parent); // register Meta Type qRegisterMetaType<MyQList>("MyQList"); //set format of the QOpenGLWidget (enable vsync and setup buffers) QSurfaceFormat format; format.setDepthBufferSize(24); format.setStencilBufferSize(8); format.setSwapInterval(1); setFormat(format); // set update behaviour to preserved-swap-buffer setUpdateBehavior(UpdateBehavior::PartialUpdate); // connect classResult and frequency list signal of SsvepBci class to setClassResult slot connect(m_pSsvepBci.data(), &SsvepBci::classificationResult, this, &SsvepBciScreen::setClassResults); connect(m_pSsvepBci.data(), &SsvepBci::getFrequencyLabels, this, &SsvepBciScreen::updateFrequencyList); // initialize freqList m_lFreqList << 6.66 << 7.5 << 8.57 << 10 << 12; }
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); }
int main(int argc, char **argv) { QGuiApplication app(argc, argv); // create an OpenGL format specifier QSurfaceFormat format; // set the number of samples for multisampling // will need to enable glEnable(GL_MULTISAMPLE); once we have a context format.setSamples(4); format.setMajorVersion(3); format.setMinorVersion(2); // now we are going to set to Compat Profile OpenGL so we can use and old Immediate mode GL format.setProfile(QSurfaceFormat::CompatibilityProfile); // now set the depth buffer to 24 bits format.setDepthBufferSize(24); QSurfaceFormat::setDefaultFormat(format); // now we are going to create our scene window OpenGLWindow window; // we can now query the version to see if it worked std::cout<<"Profile is "<<format.majorVersion()<<" "<<format.minorVersion()<<"\n"; // set the window size window.resize(1024, 720); // and finally show window.show(); return app.exec(); }
GlWidget::GlWidget(QWidget *parent) : QOpenGLWidget(parent) { QSurfaceFormat format; format.setDepthBufferSize(24); format.setSamples(24); setFormat(format); this->setMouseTracking(true); qApp->setOverrideCursor(Qt::BlankCursor); soundPlayer = new soundObject(); soundPlayer->atAmbiend(); connect(&timer, SIGNAL(timeout()), this, SLOT(eventLoop())); timer.setInterval(5); timer.start(); currentTime.start(); canonFire = false; horizontalAngle = 0.0f; verticalAngle = 0.0f; walkspeed = .05f; canonElevation= 0; canonTraverse = 180; camera[0].setX(0); camera[0].setY(0.75f); camera[0].setZ(0); camera[2].setX(0); camera[2].setY(1); camera[2].setZ(0); }
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"; }
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(); }
Window::Window(QScreen *screen) : QWindow (screen), scene_ (new BasicUsageScene) { setSurfaceType(OpenGLSurface); QSurfaceFormat format; format.setDepthBufferSize(24); format.setMajorVersion(3); format.setMinorVersion(3); format.setSamples(4); format.setProfile(QSurfaceFormat::CoreProfile); resize(800, 600); setFormat(format); create(); context_ = new QOpenGLContext(); context_->setFormat(format); context_->create(); scene_->setContext(context_); initializeGl(); connect(this, SIGNAL(widthChanged(int)), this, SLOT(resizeGl())); connect(this, SIGNAL(heightChanged(int)), this, SLOT(resizeGl())); resizeGl(); QTimer* timer = new QTimer(this); connect(timer, SIGNAL(timeout()), this, SLOT(updateScene())); timer->start(16); }
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(); }
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);*/ }
int main( int argc, char* argv[] ) { QGuiApplication a( argc, argv ); QStringList args = a.arguments(); if ( args.size() != 2 ) { qDebug() << "Please specify an obj file to load"; exit( 1 ); } const QString fileName = args.last(); // Specify the format we wish to use QSurfaceFormat format; format.setMajorVersion( 3 ); #if !defined(Q_OS_MAC) format.setMinorVersion( 3 ); #else format.setMinorVersion( 2 ); #endif format.setDepthBufferSize( 24 ); format.setSamples( 4 ); format.setProfile( QSurfaceFormat::CoreProfile ); OpenGLWindow w( format ); w.setScene( new MultipleLightsScene( fileName ) ); w.show(); return a.exec(); }
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(); }
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[]) { // Enable the following to have touch events generated from mouse events. // Very handy for testing touch event delivery without a real touch device. // QGuiApplication::setAttribute(Qt::AA_SynthesizeTouchForUnhandledMouseEvents, true); QGuiApplication app(argc, argv); QScreen *screen = QGuiApplication::primaryScreen(); QRect screenGeometry = screen->availableGeometry(); QSurfaceFormat format; format.setDepthBufferSize(16); QRect geom = screenGeometry; if (QCoreApplication::arguments().contains(QLatin1String("-nofullscreen"))) geom = QRect(screenGeometry.width() / 4, screenGeometry.height() / 4, screenGeometry.width() / 2, screenGeometry.height() / 2); QOpenGLWindow window(format, geom); QWindowCompositor compositor(&window); window.show(); 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()); }
int main(int argc, char **argv) { QGuiApplication app(argc, argv); // create an OpenGL format specifier QSurfaceFormat format; // set the number of samples for multisampling // will need to enable glEnable(GL_MULTISAMPLE); once we have a context format.setSamples(4); #if defined( __APPLE__) // at present mac osx Mountain Lion only supports GL3.2 // the new mavericks will have GL 4.x so can change format.setMajorVersion(4); format.setMinorVersion(1); #else // with luck we have the latest GL version so set to this format.setMajorVersion(4); format.setMinorVersion(3); #endif // now we are going to set to CoreProfile OpenGL so we can't use and old Immediate mode GL format.setProfile(QSurfaceFormat::CoreProfile); // now set the depth buffer to 24 bits format.setDepthBufferSize(24); // now we are going to create our scene window NGLScene window; // and set the OpenGL format window.setFormat(format); // we can now query the version to see if it worked std::cout<<"Profile is "<<format.majorVersion()<<" "<<format.minorVersion()<<"\n"; // set the window size // and finally show window.show(); window.resize(1024, 720); 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(); }
void MapView::setUseOpenGL(bool useOpenGL) { #ifndef QT_NO_OPENGL if (useOpenGL) { if (!qobject_cast<QOpenGLWidget*>(viewport())) { QSurfaceFormat format = QSurfaceFormat::defaultFormat(); format.setDepthBufferSize(0); // No need for a depth buffer format.setSamples(4); // Enable anti-aliasing QOpenGLWidget *openGLWidget = new QOpenGLWidget(this); openGLWidget->setFormat(format); setViewport(openGLWidget); } } else { if (qobject_cast<QOpenGLWidget*>(viewport())) setViewport(nullptr); } QWidget *v = viewport(); if (mMode == StaticContents) v->setAttribute(Qt::WA_StaticContents); v->setMouseTracking(true); #else Q_UNUSED(useOpenGL) #endif }
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); }
static QSurfaceFormat qSurfaceFormatFromPixelFormat(const PIXELFORMATDESCRIPTOR &pfd, QWindowsOpenGLAdditionalFormat *additionalIn = 0) { QSurfaceFormat format; if (pfd.dwFlags & PFD_DOUBLEBUFFER) format.setSwapBehavior(QSurfaceFormat::DoubleBuffer); format.setDepthBufferSize(pfd.cDepthBits); if (pfd.iPixelType == PFD_TYPE_RGBA) format.setAlphaBufferSize(pfd.cAlphaBits); format.setRedBufferSize(pfd.cRedBits); format.setGreenBufferSize(pfd.cGreenBits); format.setBlueBufferSize(pfd.cBlueBits); format.setStencilBufferSize(pfd.cStencilBits); format.setStereo(pfd.dwFlags & PFD_STEREO); if (additionalIn) { QWindowsOpenGLAdditionalFormat additional; if (isDirectRendering(pfd)) additional.formatFlags |= QWindowsGLDirectRendering; if (hasGLOverlay(pfd)) additional.formatFlags |= QWindowsGLOverlay; if (pfd.cAccumRedBits) additional.formatFlags |= QWindowsGLAccumBuffer; if (testFlag(pfd.dwFlags, PFD_DRAW_TO_BITMAP)) { additional.formatFlags |= QWindowsGLRenderToPixmap; additional.pixmapDepth = pfd.cColorBits; } *additionalIn = additional; } return format; }
const QSurfaceFormat& getDefaultOpenGLSurfaceFormat() { static QSurfaceFormat format; static std::once_flag once; std::call_once(once, [] { #if defined(USE_GLES) format.setRenderableType(QSurfaceFormat::OpenGLES); format.setRedBufferSize(8); format.setGreenBufferSize(8); format.setBlueBufferSize(8); format.setAlphaBufferSize(8); #else format.setProfile(QSurfaceFormat::OpenGLContextProfile::CoreProfile); #endif if (gl::Context::enableDebugLogger()) { format.setOption(QSurfaceFormat::DebugContext); } // Qt Quick may need a depth and stencil buffer. Always make sure these are available. format.setDepthBufferSize(DEFAULT_GL_DEPTH_BUFFER_BITS); format.setStencilBufferSize(DEFAULT_GL_STENCIL_BUFFER_BITS); int major, minor; ::gl::getTargetVersion(major, minor); format.setMajorVersion(major); format.setMinorVersion(minor); }); return format; }
QSurfaceFormat qglx_reduceSurfaceFormat(const QSurfaceFormat &format, bool *reduced) { QSurfaceFormat retFormat = format; *reduced = true; if (retFormat.redBufferSize() > 1) { retFormat.setRedBufferSize(1); } else if (retFormat.greenBufferSize() > 1) { retFormat.setGreenBufferSize(1); } else if (retFormat.blueBufferSize() > 1) { retFormat.setBlueBufferSize(1); } else if (retFormat.samples() > 1) { retFormat.setSamples(qMin(retFormat.samples() / 2, 16)); } else if (retFormat.stereo()) { retFormat.setStereo(false); }else if (retFormat.stencilBufferSize() > 0) { retFormat.setStencilBufferSize(0); }else if (retFormat.hasAlpha()) { retFormat.setAlphaBufferSize(0); }else if (retFormat.depthBufferSize() > 0) { retFormat.setDepthBufferSize(0); }else if (retFormat.swapBehavior() != QSurfaceFormat::SingleBuffer) { retFormat.setSwapBehavior(QSurfaceFormat::SingleBuffer); }else{ *reduced = false; } return retFormat; }
GLWindow::GLWindow(QScreen *screen) : QWindow(screen) { QSurfaceFormat cformat; cformat.setDepthBufferSize(24); cformat.setMajorVersion(4); cformat.setMinorVersion(2); cformat.setProfile(QSurfaceFormat::CoreProfile); resize(800,600); setSurfaceType(OpenGLSurface); create(); _context = new QOpenGLContext; _context->setFormat(cformat); _context->create(); connect(this,SIGNAL(widthChanged(int)), this, SLOT(resizeGL())); connect(this,SIGNAL(heightChanged(int)), this, SLOT(resizeGL())); initializeGL(); resizeGL(); /*QTimer* timer = new QTimer(this); connect( timer, SIGNAL(timeout()), this, SLOT(update())); timer->start();*/ }
Window::Window() { QVBoxLayout *mainLayout = new QVBoxLayout; view = new QGraphicsView(this); scene = new QGraphicsScene(view); view->setRenderHints(QPainter::Antialiasing); scene->setBackgroundBrush(Qt::blue); myGLWidget = new GLWidget(this); QOpenGLWidget *oglw = qobject_cast<QOpenGLWidget *>(myGLWidget); QSurfaceFormat format; format.setSamples(4); format.setDepthBufferSize(24); //format.setMajorVersion(3); //format.setMinorVersion(0); //format.setVersion(3,1); format.setProfile(QSurfaceFormat::CompatibilityProfile); oglw->setFormat(format); view->setViewport(myGLWidget); view->setViewportUpdateMode(QGraphicsView::FullViewportUpdate); view->setScene(scene); mainLayout->addWidget(view); setLayout(mainLayout); setWindowTitle(tr("GraphicsView + OpenGL Test Unit")); }
int main(int argc, char **argv) { // create an OpenGL format specifier QSurfaceFormat format; // set the number of samples for multisampling // will need to enable glEnable(GL_MULTISAMPLE); once we have a context format.setSamples(4); #if defined( DARWIN) // at present mac osx Mountain Lion only supports GL3.2 // the new mavericks will have GL 4.x so can change format.setMajorVersion(4); format.setMinorVersion(2); #else // with luck we have the latest GL version so set to this format.setMajorVersion(4); format.setMinorVersion(3); #endif // now we are going to set to CoreProfile OpenGL so we can't use and old Immediate mode GL format.setProfile(QSurfaceFormat::CoreProfile); // now set the depth buffer to 24 bits format.setDepthBufferSize(24); // this will set the format for all widgets QSurfaceFormat::setDefaultFormat(format); // make an instance of the QApplication CebApplication a(argc, argv); // Create a new MainWindow MainWindow w; // show main window w.show(); // show start dialog w.showStartDialog(); // hand control over to Qt framework return a.exec(); }
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 }
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[]) { 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(); }
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(); }