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(); }
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()); }
RenderWidget::RenderWidget(QWidget *parent) : QOpenGLWidget(parent), renderFunctions(nullptr), render(nullptr), quad(nullptr), quadShader(nullptr), openglDebugLogger(nullptr), captureMouse(false), onlyShowTexture(false), textureDisplayed(color) { // Widget config setUpdateBehavior(QOpenGLWidget::NoPartialUpdate); setFocusPolicy(Qt::ClickFocus); // Update Timer config connect(&updateTimer, SIGNAL(timeout()), this, SLOT(update())); startUpdateLoop(); // Open GL Context config QSurfaceFormat f; f.setRenderableType(QSurfaceFormat::OpenGL); f.setMajorVersion(4); f.setMinorVersion(5); f.setProfile(QSurfaceFormat::CoreProfile); f.setOptions(QSurfaceFormat::DebugContext | f.options()); setFormat(f); }
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(); }
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(); }
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) 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[]) { 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(); }
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(); }
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); 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(); }
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[]) { 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(); }
QGLTemporaryContext::QGLTemporaryContext(bool, QWidget *) : d(new QGLTemporaryContextPrivate) { d->oldContext = const_cast<QGLContext *>(QGLContext::currentContext()); d->window = new QWindow; d->window->setSurfaceType(QWindow::OpenGLSurface); d->window->setGeometry(QRect(0, 0, 3, 3)); d->window->create(); d->context = new QOpenGLContext; #if !defined(QT_OPENGL_ES) // On desktop, request latest released version QSurfaceFormat format; #if defined(Q_OS_MAC) // OS X is limited to OpenGL 3.2 Core Profile at present // so set that here. If we use compatibility profile it // only reports 2.x contexts. format.setMajorVersion(3); format.setMinorVersion(2); format.setProfile(QSurfaceFormat::CoreProfile); #else format.setMajorVersion(4); format.setMinorVersion(3); #endif d->context->setFormat(format); #endif d->context->create(); d->context->makeCurrent(d->window); }
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 }
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(); }
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[]) { 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();\ }
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 ); }
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 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); }
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; }
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(); }
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();*/ }
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); }