QSurfaceFormat q_glFormatFromConfig(EGLDisplay display, const EGLConfig config, const QSurfaceFormat &referenceFormat)
{
QSurfaceFormat format;
EGLint redSize = 0;
EGLint greenSize = 0;
EGLint blueSize = 0;
EGLint alphaSize = 0;
EGLint depthSize = 0;
EGLint stencilSize = 0;
EGLint sampleCount = 0;
EGLint renderableType = 0;
eglGetConfigAttrib(display, config, EGL_RED_SIZE, &redSize);
eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &greenSize);
eglGetConfigAttrib(display, config, EGL_BLUE_SIZE, &blueSize);
eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &alphaSize);
eglGetConfigAttrib(display, config, EGL_DEPTH_SIZE, &depthSize);
eglGetConfigAttrib(display, config, EGL_STENCIL_SIZE, &stencilSize);
eglGetConfigAttrib(display, config, EGL_SAMPLES, &sampleCount);
eglGetConfigAttrib(display, config, EGL_RENDERABLE_TYPE, &renderableType);
if (referenceFormat.renderableType() == QSurfaceFormat::OpenVG && (renderableType & EGL_OPENVG_BIT))
format.setRenderableType(QSurfaceFormat::OpenVG);
#ifdef EGL_VERSION_1_4
else if (referenceFormat.renderableType() == QSurfaceFormat::OpenGL
&& (renderableType & EGL_OPENGL_BIT))
format.setRenderableType(QSurfaceFormat::OpenGL);
else if (referenceFormat.renderableType() == QSurfaceFormat::DefaultRenderableType
#ifndef QT_NO_OPENGL
&& QOpenGLContext::openGLModuleType() == QOpenGLContext::LibGL
#endif
&& (renderableType & EGL_OPENGL_BIT))
format.setRenderableType(QSurfaceFormat::OpenGL);
#endif
else
format.setRenderableType(QSurfaceFormat::OpenGLES);
format.setRedBufferSize(redSize);
format.setGreenBufferSize(greenSize);
format.setBlueBufferSize(blueSize);
format.setAlphaBufferSize(alphaSize);
format.setDepthBufferSize(depthSize);
format.setStencilBufferSize(stencilSize);
format.setSamples(sampleCount);
format.setStereo(false); // EGL doesn't support stereo buffers
format.setSwapInterval(referenceFormat.swapInterval());
// Clear the EGL error state because some of the above may
// have errored out because the attribute is not applicable
// to the surface type. Such errors don't matter.
eglGetError();
return format;
}
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();
}
static QSurfaceFormat
qSurfaceFormatFromPixelFormat(const PIXELFORMATDESCRIPTOR &pfd,
QWindowsOpenGLAdditionalFormat *additionalIn = 0)
{
QSurfaceFormat format;
format.setRenderableType(QSurfaceFormat::OpenGL);
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;
}
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);
}
static QSurfaceFormat formatFromConfig(EGLDisplay dpy, EGLConfig config)
{
QSurfaceFormat format;
EGLint value = 0;
#define HELPER(__egl__, __qt__) \
eglGetConfigAttrib(dpy, config, EGL_##__egl__, &value); \
format.set##__qt__(value); \
value = 0;
#define BUFFER_HELPER(__eglColor__, __color__) \
HELPER(__eglColor__##_SIZE, __color__##BufferSize)
BUFFER_HELPER(RED, Red)
BUFFER_HELPER(GREEN, Green)
BUFFER_HELPER(BLUE, Blue)
BUFFER_HELPER(ALPHA, Alpha)
BUFFER_HELPER(STENCIL, Stencil)
BUFFER_HELPER(DEPTH, Depth)
#undef BUFFER_HELPER
HELPER(SAMPLES, Samples)
#undef HELPER
format.setRenderableType(isOpenGLES() ? QSurfaceFormat::OpenGLES : QSurfaceFormat::OpenGL);
format.setStereo(false);
return format;
}
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());
}
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;
}
ContextPoolContext::ContextPoolContext(QOpenGLContext* share_context, bool reserved)
: reserved(reserved), count(0), surface(NULL), context(NULL)
{
QSurfaceFormat format;
format.setMajorVersion(3);
format.setMinorVersion(2);
format.setSwapInterval(0);
format.setSwapBehavior(QSurfaceFormat::SingleBuffer);
format.setRenderableType(QSurfaceFormat::OpenGL);
format.setProfile(QSurfaceFormat::CoreProfile);
format.setOption(QSurfaceFormat::DebugContext);
surface = new QOffscreenSurface();
surface->setFormat(format);
surface->create();
if (!surface->isValid()) {
throw;
}
context = new QOpenGLContext();
context->setShareContext(share_context);
context->setFormat(surface->requestedFormat());
if (!context->create()) {
throw;
}
context->makeCurrent(surface);
gl = context->versionFunctions<QOpenGLFunctions_3_2_Core>();
if (gl == nullptr || !gl->initializeOpenGLFunctions()) {
throw;
}
indirect = new QOpenGLExtension_ARB_multi_draw_indirect();
if (!indirect->initializeOpenGLFunctions()) {
throw;
}
vab = new QOpenGLExtension_ARB_vertex_attrib_binding();
if (!vab->initializeOpenGLFunctions()) {
throw;
}
sso = new QOpenGLExtension_ARB_separate_shader_objects();
if (!sso->initializeOpenGLFunctions()) {
throw;
}
tex = new QOpenGLExtension_ARB_texture_buffer_object();
if (!tex->initializeOpenGLFunctions()) {
throw;
}
buffer = (QOpenGLExtension_ARB_buffer_storage)context->getProcAddress("glBufferStorage");
debug = new QOpenGLExtension_ARB_debug_output();
if (!debug->initializeOpenGLFunctions()) {
throw;
}
debug->glDebugMessageCallbackARB(debug_callback, nullptr);
debug->glDebugMessageControlARB(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, 0, GL_FALSE);
debug->glDebugMessageControlARB(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_MEDIUM, 0, 0, GL_TRUE);
context->doneCurrent();
context->moveToThread(nullptr);
}
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();
}
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();
}
void HsQMLContextControl::controlContext()
{
// Do nothing if no window
if (!mWindow) {
return;
}
// Do nothing if changes are being deferred
if (mDefer || !mWhen) {
mPending = true;
return;
}
mPending = false;
QSurfaceFormat fmt = mOriginal;
if (mMajorVersion >= 0) {
fmt.setMajorVersion(mMajorVersion);
}
if (mMinorVersion >= 0) {
fmt.setMinorVersion(mMinorVersion);
}
if (mContextType >= 0) {
fmt.setRenderableType(static_cast<QSurfaceFormat::RenderableType>(
mContextType));
}
if (mContextProfile >= 0) {
fmt.setProfile(static_cast<QSurfaceFormat::OpenGLContextProfile>(
mContextProfile));
}
if (mDeprecatedFunctionsSet) {
#if QT_VERSION >= 0x050300
fmt.setOption(QSurfaceFormat::DeprecatedFunctions,
mDeprecatedFunctions);
#else
if (mDeprecatedFunctions) {
fmt.setOption(QSurfaceFormat::DeprecatedFunctions);
}
#endif
}
fmt.setDepthBufferSize(qMax(fmt.depthBufferSize(), mDepthBufferSize));
fmt.setStencilBufferSize(qMax(fmt.stencilBufferSize(), mStencilBufferSize));
if (fmt == mWindow->requestedFormat()) {
return;
}
mWindow->setFormat(fmt);
// Recreate OpenGL context
mWindow->setPersistentOpenGLContext(false);
mWindow->setPersistentSceneGraph(false);
bool visible = mWindow->isVisible();
mWindow->destroy();
mWindow->releaseResources();
mWindow->setVisible(visible);
mWindow->setPersistentOpenGLContext(true);
mWindow->setPersistentSceneGraph(true);
}
int main(int argc, char** argv) {
QSurfaceFormat format;
#if defined(Q_OS_IOS) || defined(Q_OS_ANDROID)
format.setRenderableType(QSurfaceFormat::OpenGLES);
format.setVersion(3, 0);
#else
format.setRenderableType(QSurfaceFormat::OpenGL);
format.setProfile(QSurfaceFormat::CoreProfile);
format.setVersion(3, 3);
#endif
format.setDepthBufferSize(16);
format.setStencilBufferSize(8);
QSurfaceFormat::setDefaultFormat(format);
QApplication a(argc, argv);
ncMainWindow w;
w.show();
return a.exec();
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QSurfaceFormat format;
format.setDepthBufferSize( 4 );
format.setSamples(24);
format.setRenderableType(QSurfaceFormat::OpenGL);
a.setStyle(QStyleFactory::create("Android"));
MainWindow w;
w.showMaximized();
return a.exec();
}
int main(int argc, char* argv[])
{
QSurfaceFormat format;
format.setRenderableType(QSurfaceFormat::OpenGL);
format.setProfile(QSurfaceFormat::CoreProfile);
format.setVersion(3,3);
Magick::InitializeMagick(*argv);
QApplication a(argc, argv);
MainWindow w;
w.show();
return a.exec();
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QSurfaceFormat format;
format.setRenderableType(QSurfaceFormat::OpenGL);
format.setProfile(QSurfaceFormat::CoreProfile);
format.setOption(QSurfaceFormat::DebugContext);
format.setVersion(4,1);
QSurfaceFormat::setDefaultFormat(format);
MGLWidgetUniformBlock widget(NULL,"UniformBlock",false);
widget.show();
return a.exec();
}
int main(int argc, char *argv[])
{
QApplication application(argc, argv);
// Specify an OpenGL 3.3 format using the Core profile.
// That is, no old-school fixed pipeline functionality
QSurfaceFormat glFormat;
glFormat.setVersion( 3, 3 );
glFormat.setProfile(QSurfaceFormat::OpenGLContextProfile::CoreProfile);
glFormat.setRenderableType(QSurfaceFormat::RenderableType::OpenGL);
QSurfaceFormat::setDefaultFormat(glFormat);
// MainWindow is a singleton class
MainWindow::getInstance().showNormal();
//main_window.showMaximized();
return application.exec();
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QSurfaceFormat format;
format.setRenderableType(QSurfaceFormat::OpenGL);
format.setProfile(QSurfaceFormat::CoreProfile);
format.setOption(QSurfaceFormat::DebugContext);
format.setVersion(4,1);
QSurfaceFormat::setDefaultFormat(format);
MGLWidgetDrawInstanced widget(NULL,"DrawCMD",false);
//GInstanceArray widget(NULL,"GInstanceArray",false);
//TestVBObject widget(NULL,"TestVBObject",false);
widget.show();
return a.exec();
}
OpenGLWindow::OpenGLWindow( QWindow *parent )
: QWindow( parent ), d( new Private(this) )
{
setSurfaceType( QWindow::OpenGLSurface );
QSurfaceFormat format;
//format.setDepthBufferSize( 24 );
//format.setSamples( 4 );
//format.setMajorVersion( 3 );
//format.setMinorVersion( 3 );
format.setSwapBehavior( QSurfaceFormat::DoubleBuffer );
format.setRenderableType( QSurfaceFormat::OpenGL );
format.setProfile( QSurfaceFormat::CompatibilityProfile );
setFormat( format );
create();
d->thread = OpenGLRenderThread::instance();
d->renderId = d->thread->registerSurface( this );
d->thread->update( d->renderId );
}
int main(int argc, char *argv[]) {
QGuiApplication app(argc, argv);
// Set OpenGL Version information
// Note: This format must be set before show() is called.
QSurfaceFormat format;
format.setRenderableType(QSurfaceFormat::OpenGL);
format.setProfile(QSurfaceFormat::CoreProfile);
format.setSamples(8);
//If no format is specified it uses the highest available possible
//In my case 4.5
//format.setVersion(3, 3);
Window window;
window.setTitle("Qt and OpenGL Simple Window");
window.setFormat(format);
window.resize(QSize(800, 600));
window.show();
return app.exec();
}
OpenGLWindow::OpenGLWindow(QWindow *parent)
: QWindow(parent)
, m_update_pending(false)
, m_animating(false)
, m_context(0)
, m_device(0)
, m_frames(0)
, m_fps(0)
{
setSurfaceType(QWindow::OpenGLSurface);
QSurfaceFormat format;
format.setSamples(4); // multi-sampling
format.setRenderableType(QSurfaceFormat::OpenGL); // change to opengles on mobile
format.setProfile(QSurfaceFormat::CompatibilityProfile);
format.setMajorVersion(3);
format.setMinorVersion(2);
format.setDepthBufferSize(24);
setFormat(format);
// Hide the cursor since this is a fullscreen app
setCursor(Qt::BlankCursor);
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QSurfaceFormat format;
format.setMajorVersion(4);
format.setMinorVersion(1);
format.setProfile(QSurfaceFormat::CoreProfile);
format.setRenderableType(QSurfaceFormat::OpenGL);
format.setSwapBehavior(QSurfaceFormat::DoubleBuffer);
format.setSamples(2);
format.setDepthBufferSize(24);
format.setRedBufferSize(8);
format.setGreenBufferSize(8);
format.setBlueBufferSize(8);
format.setAlphaBufferSize(0);
format.setStencilBufferSize(8);
QSurfaceFormat::setDefaultFormat(format);
DemoGLWindow window;
window.show();
return a.exec();
}
int main(int argc, char** argv)
{
QApplication app(argc, argv);
QMainWindow* mw{new QMainWindow()};
mw->setWindowTitle("scroll event compression test case");
QToolBar* toolbar{mw->addToolBar("toolbar")};
QAction* sleep_a_lot_action{new QAction("Sleep A Lot", mw)};
sleep_a_lot_action->setCheckable(true);
sleep_a_lot_action->setChecked(false);
sleep_a_lot_action->setToolTip("When activated, the main thread will attempt to sleep for 999ms intervals with 1ms gaps between naps.\n"
"Shortcut: spacebar");
sleep_a_lot_action->setShortcut(QKeySequence(Qt::Key_Space));
sleep_a_lot_action->setShortcutContext(Qt::WindowShortcut);
QTimer* sleep_a_lot_timer{new QTimer(mw)};
QObject::connect(sleep_a_lot_action, &QAction::toggled, [&](const bool& is_on){
if(is_on) sleep_a_lot_timer->start();
else sleep_a_lot_timer->stop();});
sleep_a_lot_timer->setSingleShot(false);
sleep_a_lot_timer->setInterval(1);
QObject::connect(sleep_a_lot_timer, &QTimer::timeout, [&](){
std::this_thread::sleep_for(std::chrono::milliseconds(999));
if(sleep_a_lot_action->isChecked()) sleep_a_lot_timer->start();
});
toolbar->addAction(sleep_a_lot_action);
toolbar->addSeparator();
QGraphicsScene* gs{new QGraphicsScene(mw)};
QGraphicsSimpleTextItem* sti{gs->addSimpleText("Move the mouse wheel a few clicks up or down with various combinations of:\n"
"* \"Sleep A Lot\" enabled/disabled (shortcut to toggle: spacebar).\n"
"* Mouse held still/mouse moved about.\n\n"
"Questions whose answers differ for the same version of Qt on various\n"
"platforms (eg, Win32, X11, Aqua):\n"
"* With \"Sleep A Lot\" active, are mouse wheel events compressed?\n"
"* With \"Sleep A Lot\" active, does moving the mouse and the mouse wheel\n"
" cause scroll wheel events to be thrown away by compression that are not\n"
" thrown away when just the mouse wheel is manipulated?\n"
"* With \"Sleep A Lot\" active, is it necessary to move the mouse in order\n"
" to provoke processing of buffered mouse wheel events?")};
sti->setBrush(QBrush(Qt::black));
sti->setPen(QPen(Qt::white));
{
QFont f(sti->font());
f.setBold(true);
f.setPointSize(36);
sti->setFont(f);
}
gs->setSceneRect(sti->boundingRect());
QGraphicsEllipseItem* mc{gs->addEllipse(0, 0, 25, 25, QPen(QColor(0, 255, 0, 200)), QBrush(QColor(0, 0, 0, 100)))};
mc->setFlag(QGraphicsItem::ItemIgnoresTransformations);
QGraphicsSimpleTextItem* mcsti{gs->addSimpleText("0\n0")};
mcsti->setBrush(QBrush(Qt::white));
mcsti->setParentItem(mc);
mcsti->moveBy(23, 22);
QGraphicsDropShadowEffect* mcstige{new QGraphicsDropShadowEffect(gs)};
mcstige->setBlurRadius(10);
mcstige->setOffset(0, 0);
mcstige->setColor(Qt::black);
mcsti->setGraphicsEffect(mcstige);
TestView* gv{new TestView(gs, mw)};
QOpenGLWidget* gl_widget = new QOpenGLWidget;
{
QSurfaceFormat fmt;
fmt.setRenderableType(QSurfaceFormat::OpenGL);
fmt.setProfile(QSurfaceFormat::CompatibilityProfile);
fmt.setVersion(2, 1);
fmt.setSamples(4);
gl_widget->setFormat(fmt);
}
gv->setViewport(gl_widget);
QObject::connect(gv, &TestView::mouse_moved, [&](const QPointF& scene_pos){
mcsti->setText(QString("%1\n%2").arg(scene_pos.x()).arg(scene_pos.y()));
qreal zoom{gv->transform().m22()};
qreal delta{12.5 / zoom};
mc->setPos(scene_pos.x() - delta, scene_pos.y() - delta);
});
gv->setDragMode(QGraphicsView::ScrollHandDrag);
{
QLinearGradient g;
g.setSpread(QGradient::ReflectSpread);
QGradientStops grad_stops;
grad_stops.push_back(QGradientStop(0, QColor(Qt::red)));
grad_stops.push_back(QGradientStop(0.5, QColor(Qt::green)));
grad_stops.push_back(QGradientStop(1, QColor(Qt::blue)));
g.setStops(grad_stops);
QBrush b(g);
gs->setBackgroundBrush(b);
}
mw->setCentralWidget(gv);
mw->resize(2045, 838);
mw->show();
return app.exec();
}
void WebApplicationWindow::createAndSetup()
{
if (mTrustScope == TrustScopeSystem) {
mUserScripts.append(QUrl("qrc:///qml/webos-api.js"));
createDefaultExtensions();
}
if (mWindowType == "dashboard")
mLoadingAnimationDisabled = true;
if (mHeadless) {
qDebug() << __PRETTY_FUNCTION__ << "Creating application container for headless ...";
mEngine = new QQmlEngine;
configureQmlEngine();
QQmlComponent component(mEngine, QUrl(QString("qrc:///qml/ApplicationContainer.qml")));
mRootItem = qobject_cast<QQuickItem*>(component.create());
}
else {
QQuickWebViewExperimental::setFlickableViewportEnabled(mApplication->desc().flickable());
mWindow = new QQuickView;
mWindow->installEventFilter(this);
mEngine = mWindow->engine();
configureQmlEngine();
connect(mWindow, &QObject::destroyed, [=](QObject *obj) {
qDebug() << "Window destroyed";
});
mWindow->setColor(Qt::transparent);
mWindow->reportContentOrientationChange(QGuiApplication::primaryScreen()->primaryOrientation());
mWindow->setSurfaceType(QSurface::OpenGLSurface);
QSurfaceFormat surfaceFormat = mWindow->format();
surfaceFormat.setAlphaBufferSize(8);
surfaceFormat.setRenderableType(QSurfaceFormat::OpenGLES);
mWindow->setFormat(surfaceFormat);
// make sure the platform window gets created to be able to set it's
// window properties
mWindow->create();
// set different information bits for our window
setWindowProperty(QString("_LUNE_WINDOW_TYPE"), QVariant(mWindowType));
setWindowProperty(QString("_LUNE_WINDOW_PARENT_ID"), QVariant(mParentWindowId));
setWindowProperty(QString("_LUNE_WINDOW_LOADING_ANIMATION_DISABLED"), QVariant(mApplication->loadingAnimationDisabled()));
setWindowProperty(QString("_LUNE_APP_ICON"), QVariant(mApplication->icon()));
setWindowProperty(QString("_LUNE_APP_ID"), QVariant(mApplication->id()));
connect(mWindow, SIGNAL(visibleChanged(bool)), this, SLOT(onVisibleChanged(bool)));
QPlatformNativeInterface *nativeInterface = QGuiApplication::platformNativeInterface();
connect(nativeInterface, SIGNAL(windowPropertyChanged(QPlatformWindow*, const QString&)),
this, SLOT(onWindowPropertyChanged(QPlatformWindow*, const QString&)));
mWindow->setSource(QUrl(QString("qrc:///qml/ApplicationContainer.qml")));
mRootItem = mWindow->rootObject();
mWindow->resize(mSize);
}
}
//----------------------------------------------------------------------------
GLWidget::GLWidget(int& argc, char *argv[]):
Configurable("QGLWidget"),
_cur_fbo(0),
_do_drag(false),
_flags(0),
_server(&_mutex_slot_links, &_cond_render, this)
{
QApplication::setOrganizationDomain("icg.tugraz.at");
QApplication::setOrganizationName("icg.tugraz.at");
QApplication::setApplicationName("VisLinks");
const QDir config_dir =
QStandardPaths::writableLocation(QStandardPaths::DataLocation);
const QString user_config = config_dir.filePath("config.xml");
{
// Ensure config path and user config file exist
QDir().mkpath(config_dir.path());
QFile file( user_config );
if( !file.open(QIODevice::ReadWrite | QIODevice::Text) )
LOG_ERROR("Failed to open user config!");
else if( !file.size() )
{
LOG_INFO("Creating empty user config in '" << user_config << "'");
file.write(
"<!-- VisLinks user config (overrides config file) -->\n"
"<config/>"
);
}
}
//--------------------------------
// Setup opengl and window
//--------------------------------
// fullscreen
setGeometry( QGuiApplication::primaryScreen()->availableVirtualGeometry() );
// don't allow user to change the window size
setFixedSize( size() );
// transparent, always on top window without any decoration
setWindowFlags( Qt::WindowStaysOnTopHint
| Qt::FramelessWindowHint
| Qt::MSWindowsOwnDC
| Qt::WindowTransparentForInput
//| Qt::X11BypassWindowManagerHint
);
setAttribute(Qt::WA_ShowWithoutActivating);
setAttribute(Qt::WA_TranslucentBackground);
#ifdef USE_DESKTOP_BLEND1
//setAttribute(Qt::WA_TranslucentBackground);
#else
//setWindowOpacity(0.5);
#endif
#if 0
#if defined(WIN32) || defined(_WIN32)
setMask(QRegion(size().width() - 2, size().height() - 2, 1, 1));
#else
setMask(QRegion(-1, -1, 1, 1));
#endif
#endif
setMouseTracking(true);
//--------------------------------
// Setup component system
//--------------------------------
if( argc != 2 )
qFatal("Usage: %s <config>", argv[0]);
assert(argc == 2 && argv && argv[1]);
publishSlots(_core.getSlotCollector());
if( !_config.initFrom(argv[1]) )
qFatal("Failed to read config");
_user_config.initFrom( to_string(user_config) );
_core.startup();
_core.attachComponent(&_config);
_core.attachComponent(&_user_config);
_core.attachComponent(&_server);
#ifdef USE_GPU_ROUTING
_core.attachComponent(&_cost_analysis);
#endif
_core.attachComponent(&_routing_cpu);
_core.attachComponent(&_routing_cpu_dijkstra);
_core.attachComponent(&_routing_dummy);
#ifdef USE_GPU_ROUTING
_core.attachComponent(&_routing_gpu);
#endif
_core.attachComponent(&_renderer);
_core.attachComponent(this);
registerArg("DebugDesktopImage", _debug_desktop_image);
registerArg("DumpScreenshot", _dump_screenshot = 0);
_core.init();
LinksRouting::SlotSubscriber subscriber = _core.getSlotSubscriber();
subscribeSlots(subscriber);
QSurfaceFormat fmt;
fmt.setRenderableType(QSurfaceFormat::RenderableType::OpenGL);
fmt.setProfile(QSurfaceFormat::OpenGLContextProfile::CoreProfile);
fmt.setAlphaBufferSize(8);
_offscreen_surface.setFormat(fmt);
_offscreen_surface.setScreen( QGuiApplication::primaryScreen() );
_offscreen_surface.create();
_gl_ctx.setFormat(fmt);
if( !_gl_ctx.create() )
qFatal("Failed to create OpenGL context.");
if( !_gl_ctx.format().hasAlpha() )
qFatal("Failed to enable alpha blending.");
if( !_gl_ctx.makeCurrent(&_offscreen_surface) )
qFatal("Could not activate OpenGL context.");
// _render_thread =
// QSharedPointer<RenderThread>(new RenderThread(this, width(), height()));
// _gl_ctx->moveToThread(_render_thread.data());
//std::cout << "Is virtual desktop: "
// << QApplication::desktop()->isVirtualDesktop()
// << std::endl;
}
int main(int argc, char *argv[])
{
QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts);
QSurfaceFormat format;
format.setMajorVersion(4);
format.setMinorVersion(1);
format.setProfile(QSurfaceFormat::CoreProfile);
format.setRenderableType(QSurfaceFormat::OpenGL);
format.setSwapBehavior(QSurfaceFormat::DoubleBuffer);
format.setSamples(2);
// Today I learned: the surface itself doesn't need an alpha channel.
// When we blend colours in OpenGL, the alpha value passed in with the colour
// is only used internally by OpenGL in order to calculate the physical RGB
// to write back into the colour buffer. We don't need to set any alpha on the
// surface itself, since the RGB values will already have been blended by the
// time they're written back to the colour buffer. If we do set the alpha, that
// means we'll actually be able to see through the surface and whatever is behind
// will be visible. This isn't what we want for the application main window!
// If we want to create a frame buffer later on where the actual colour buffer
// output should be translucent, override the default alpha buffer size to 8 bits.
format.setDepthBufferSize(24);
format.setRedBufferSize(8);
format.setGreenBufferSize(8);
format.setBlueBufferSize(8);
format.setAlphaBufferSize(0);
format.setStencilBufferSize(8);
QSurfaceFormat::setDefaultFormat(format);
qDebug() << "Set default OpenGL format:" << format;
QApplication a(argc, argv);
a.setApplicationName("Calliper");
a.setApplicationDisplayName("Calliper");
a.setOrganizationName("Infra");
a.setOrganizationName("Infra");
// Initialise the resource manager.
ResourceManager::initialise();
// Initialise the renderer.
OpenGLRenderer::initialise();
// Initialise the over-arching application.
Application::initialise(new MainWindow());
// Set up resources.
resourceManager()->makeCurrent();
resourceManager()->setUpOpenGLResources();
renderer()->setUpOpenGLResources();
resourceManager()->doneCurrent();
application()->mainWindow()->show();
int ret = a.exec();
// Shut down the application.
Application::shutdown();
// Shut down the renderer.
OpenGLRenderer::shutdown();
// Shut down the resource manager.
ResourceManager::shutdown();
return ret;
return a.exec();
}
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
ThreadGetData threadGetData; //thread to get data
threadGetData.start();
threadGetData.inputFromSMF("./smf/man.smf");
/* faces import */
// vec4 p1 = vec4(-0.5, 0.0, 0.0, 1.0);
// vec4 p2 = vec4(0.5, 0.0, 0.0, 1.0);
// vec4 p3 = vec4(0.0, 1.0, 0.0, 1.0);
// vec4 p4 = vec4(-0.5, 0.5, 0.0, 1.0);
// list<Triangle> triList;
// Triangle a1(p1,p2,p3);
// Triangle a2(p1,p2,p4);
// triList.push_back(a1);
// triList.push_back(a2);
// threadGetData.inputFaces(triList);
/*points import*/
Vertex point1 = Vertex( QVector3D( 0.50f, 0.50f, 0.00f), QVector3D(1.0f, 0.0f, 0.0f), QVector3D(0.0f, 0.0f, 0.0f));
Vertex point2 = Vertex( QVector3D( 0.00f, 0.50f, 0.00f), QVector3D(0.0f, 1.0f, 0.0f), QVector3D(0.0f, 0.0f, 0.0f));
Vertex point3 = Vertex( QVector3D( 0.50f, 0.00f, 0.00f), QVector3D(1.0f, 0.0f, 0.0f), QVector3D(0.0f, 0.0f, 0.0f));
Vertex point4 = Vertex( QVector3D( 0.25f, 0.25f, 0.50f), QVector3D(1.0f, 1.0f, 0.0f), QVector3D(0.0f, 0.0f, 0.0f));
list<Vertex> pointsListTemp;
pointsListTemp.push_back(point1);
pointsListTemp.push_back(point2);
pointsListTemp.push_back(point3);
pointsListTemp.push_back(point4);
threadGetData.inputPoints(pointsListTemp);
/*lines import*/
Vertex l1 = Vertex( QVector3D( 0.00f, 0.00f, 0.00f), QVector3D(0.0f, 0.0f, 0.0f), QVector3D(0.0f, 0.0f, 0.0f) );
Vertex l2 = Vertex( QVector3D( 0.50f, 0.70f, 0.50f), QVector3D(0.0f, 0.0f, 0.0f), QVector3D(0.0f, 0.0f, 0.0f) );
Vertex l3 = Vertex( QVector3D( 0.50f, 0.70f, -0.50f), QVector3D(0.0f, 0.0f, 0.0f), QVector3D(0.0f, 0.0f, 0.0f) );
Vertex l4 = Vertex( QVector3D( 0.00f, 0.00f, 0.00f), QVector3D(0.0f, 0.0f, 0.0f), QVector3D(0.0f, 0.0f, 0.0f) );
list<Vertex> linesListTemp;
linesListTemp.push_back(l1);
linesListTemp.push_back(l2);
linesListTemp.push_back(l3);
linesListTemp.push_back(l4);
threadGetData.inputLines(linesListTemp);
QSurfaceFormat format;
format.setRenderableType(QSurfaceFormat::OpenGL);
format.setProfile(QSurfaceFormat::CoreProfile);
format.setDepthBufferSize(100);
format.setVersion(3, 3);
// Set the window up
ObjectWindow objectwindow;
objectwindow.setFormat(format);
objectwindow.resize(QSize(800, 600));
objectwindow.show();
objectwindow.setAnimating(true);
return app.exec();
}
