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();
}
