static void createPlatformGraphicsContext3DFromWidget(QWidget* widget, PlatformGraphicsContext3D* context,
PlatformGraphicsSurface3D* surface)
{
*context = 0;
*surface = 0;
QAbstractScrollArea* scrollArea = qobject_cast<QAbstractScrollArea*>(widget);
if (!scrollArea)
return;
QGLWidget* glViewport = qobject_cast<QGLWidget*>(scrollArea->viewport());
if (!glViewport)
return;
QGLWidget* glWidget = new QGLWidget(0, glViewport);
if (glWidget->isValid()) {
// Geometry can be set to zero because m_glWidget is used only for its QGLContext.
glWidget->setGeometry(0, 0, 0, 0);
#if HAVE(QT5)
*surface = glWidget->windowHandle();
*context = glWidget->context()->contextHandle();
#else
*surface = glWidget;
*context = const_cast<QGLContext*>(glWidget->context());
#endif
} else {
delete glWidget;
glWidget = 0;
}
}
void setSwapInterval(QGLWidget const &glWidget, int *interval)
{
typedef int (WINAPI * PFNWGLGETSWAPINTERVALEXTPROC)(void);
typedef BOOL (WINAPI * PFNWGLSWAPINTERVALEXTPROC)(int);
PFNWGLGETSWAPINTERVALEXTPROC wglGetSwapIntervalEXT;
PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT;
QGLContext const &context = *glWidget.context();
wglGetSwapIntervalEXT = (PFNWGLGETSWAPINTERVALEXTPROC) context.getProcAddress("wglGetSwapIntervalEXT");
wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC) context.getProcAddress("wglSwapIntervalEXT");
if (wglGetSwapIntervalEXT && wglSwapIntervalEXT)
{
if (*interval < 0)
{
*interval = 0;
}
wglSwapIntervalEXT(*interval);
*interval = wglGetSwapIntervalEXT();
}
else
{
*interval = -1;
}
}
bool checkOpenGL(){
QGLWidget *glWidget = new QGLWidget;
QGLContext* glContext = (QGLContext *) glWidget->context();
GLCHK( glContext->makeCurrent() );
qDebug() << "Running the " + QString(AWESOME_BUMP_VERSION);
qDebug() << "Checking OpenGL version...";
qDebug() << "Widget OpenGL: " << glContext->format().majorVersion() << "." << glContext->format().minorVersion() ;
qDebug() << "Context valid: " << glContext->isValid() ;
qDebug() << "OpenGL information: " ;
qDebug() << "VENDOR: " << (const char*)glGetString(GL_VENDOR) ;
qDebug() << "RENDERER: " << (const char*)glGetString(GL_RENDERER) ;
qDebug() << "VERSION: " << (const char*)glGetString(GL_VERSION) ;
qDebug() << "GLSL VERSION: " << (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION) ;
float version = glContext->format().majorVersion() + 0.1 * glContext->format().minorVersion();
delete glWidget;
qDebug() << "Version:" << version;
// check openGL version
if( version < 4.0 )
{
qDebug() << "Error: AwesomeBump does not support openGL versions lower than 4.0 :(" ;
return false;
}
return true;
}
QEglGLPixmapData::~QEglGLPixmapData()
{
TRACE();
QGLWidget *shareWidget = qt_gl_share_widget();
if (!shareWidget)
return;
delete m_engine;
if (m_fbo) {
QGLShareContextScope ctx(shareWidget->context());
glDeleteFramebuffers(1, &m_fbo);
}
if (m_texture.id) {
QGLShareContextScope ctx(shareWidget->context());
glDeleteTextures(1, &m_texture.id);
}
}
void QGLTexturePool::releaseTexture(QGLPixmapData *data, GLuint texture)
{
// Very simple strategy at the moment: just destroy the texture.
if (data)
removeFromLRU(data);
QGLWidget *shareWidget = qt_gl_share_widget();
if (shareWidget) {
QGLShareContextScope ctx(shareWidget->context());
glDeleteTextures(1, &texture);
}
}
QGLPixmapData::~QGLPixmapData()
{
QGLWidget *shareWidget = qt_gl_share_widget();
if (!shareWidget)
return;
delete m_engine;
if (m_texture.id) {
QGLShareContextScope ctx(shareWidget->context());
glDeleteTextures(1, &m_texture.id);
}
}
int main(int argc, char **argv)
{
QApplication app(argc, argv);
if ((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_5) == 0) {
QMessageBox::critical(0, "OpenGL features missing",
"OpenGL version 1.5 or higher is required to run this demo.\n"
"The program will now exit.");
return -1;
}
int maxTextureSize = 1024;
QGLWidget *widget = new QGLWidget(QGLFormat(QGL::SampleBuffers));
widget->makeCurrent();
if (!necessaryExtensionsSupported()) {
QMessageBox::critical(0, "OpenGL features missing",
"The OpenGL extensions required to run this demo are missing.\n"
"The program will now exit.");
delete widget;
return -2;
}
// Check if all the necessary functions are resolved.
if (!getGLExtensionFunctions().resolve(widget->context())) {
QMessageBox::critical(0, "OpenGL features missing",
"Failed to resolve OpenGL functions required to run this demo.\n"
"The program will now exit.");
delete widget;
return -3;
}
// TODO: Make conditional for final release
QMessageBox::information(0, "For your information",
"This demo can be GPU and CPU intensive and may\n"
"work poorly or not at all on your system.");
widget->makeCurrent(); // The current context must be set before calling Scene's constructor
Scene scene(1024, 768, maxTextureSize);
GraphicsView view;
view.setViewport(widget);
view.setViewportUpdateMode(QGraphicsView::FullViewportUpdate);
view.setScene(&scene);
view.show();
return app.exec();
}
bool checkOpenGL(){
QGLWidget *glWidget = new QGLWidget;
QGLContext* glContext = (QGLContext *) glWidget->context();
GLCHK( glContext->makeCurrent() );
qDebug() << "Running the " + QString(AWESOME_BUMP_VERSION);
qDebug() << "Checking OpenGL version...";
qDebug() << "Widget OpenGL:" << QString("%1.%2").arg(glContext->format().majorVersion()).arg(glContext->format().minorVersion());
qDebug() << "Context valid:" << glContext->isValid() ;
qDebug() << "OpenGL information:" ;
qDebug() << "VENDOR:" << (const char*)glGetString(GL_VENDOR) ;
qDebug() << "RENDERER:" << (const char*)glGetString(GL_RENDERER) ;
qDebug() << "VERSION:" << (const char*)glGetString(GL_VERSION) ;
qDebug() << "GLSL VERSION:" << (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION) ;
float version = glContext->format().majorVersion() + 0.1 * glContext->format().minorVersion();
Performance3DSettings::openGLVersion = version;
#ifdef USE_OPENGL_330
Performance3DSettings::openGLVersion = 3.3;
#endif
delete glWidget;
qDebug() << "Version:" << version;
#ifdef USE_OPENGL_330
// check openGL version
if( version < 3.3 )
{
qDebug() << "Error: This version of AwesomeBump does not support openGL versions lower than 3.3 :(" ;
return false;
}
#else
// check openGL version
if( version < 4.0 )
{
qDebug() << "Error: AwesomeBump does not support openGL versions lower than 4.0 :(" ;
return false;
}
#endif
return true;
}
void QGLPixmapData::destroyTexture()
{
if (inTexturePool) {
QGLTexturePool *pool = QGLTexturePool::instance();
if (m_texture.id)
pool->releaseTexture(this, m_texture.id);
} else {
if (m_texture.id) {
QGLWidget *shareWidget = qt_gl_share_widget();
if (shareWidget) {
QGLShareContextScope ctx(shareWidget->context());
glDeleteTextures(1, &m_texture.id);
}
}
}
m_texture.id = 0;
inTexturePool = false;
releaseNativeImageHandle();
}
void MythOpenGLPainter::Begin(QPaintDevice *parent)
{
MythPainter::Begin(parent);
if (!realRender)
{
QGLWidget *glw = dynamic_cast<QGLWidget *>(realParent);
if (!glw)
glw = dynamic_cast<QGLWidget *>(parent);
if (!glw)
{
LOG(VB_GENERAL, LOG_ERR,
"FATAL ERROR: Failed to cast parent to QGLWidget");
return;
}
realRender = (MythRenderOpenGL*)(glw->context());
if (!realRender)
{
LOG(VB_GENERAL, LOG_ERR,
"FATAL ERROR: Failed to get MythRenderOpenGL");
return;
}
}
DeleteTextures();
realRender->makeCurrent();
if (target || swapControl)
{
realRender->BindFramebuffer(target);
realRender->SetViewPort(QRect(0, 0, realParent->width(), realParent->height()));
realRender->SetColor(255, 255, 255, 255);
realRender->SetBackground(0, 0, 0, 0);
realRender->ClearFramebuffer();
}
}
bool checkOpenGL(){
QGLWidget *glWidget = new QGLWidget;
QGLContext* glContext = (QGLContext *) glWidget->context();
GLCHK( glContext->makeCurrent() );
int glMajorVersion, glMinorVersion;
glMajorVersion = glContext->format().majorVersion();
glMinorVersion = glContext->format().minorVersion();
qDebug() << "Running the " + QString(AWESOME_BUMP_VERSION);
qDebug() << "Checking OpenGL version...";
qDebug() << "Widget OpenGL:" << QString("%1.%2").arg(glMajorVersion).arg(glMinorVersion);
qDebug() << "Context valid:" << glContext->isValid() ;
qDebug() << "OpenGL information:" ;
qDebug() << "VENDOR:" << (const char*)glGetString(GL_VENDOR) ;
qDebug() << "RENDERER:" << (const char*)glGetString(GL_RENDERER) ;
qDebug() << "VERSION:" << (const char*)glGetString(GL_VERSION) ;
qDebug() << "GLSL VERSION:" << (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION) ;
Display3DSettings::openGLVersion = GL_MAJOR + (GL_MINOR * 0.1);
delete glWidget;
qDebug() << QString("Version: %1.%2").arg(glMajorVersion).arg(glMinorVersion);
// check openGL version
if( glMajorVersion < GL_MAJOR || (glMajorVersion == GL_MAJOR && glMinorVersion < GL_MINOR))
{
qDebug() << QString("Error: This version of AwesomeBump does not support openGL versions lower than %1.%2 :(").arg(GL_MAJOR).arg(GL_MINOR) ;
return false;
}
return true;
}
//! Set the default painter to use when not drawing to FBO.
//!
//! This is the only place where we might be getting a painter from outside world,
//! so we require that it uses a GL or GL2 paint engine.
//!
//! @param painter Painter to set.
//! @param context GL context used by the renderer, for error checking.
void setDefaultPainter(QPainter* const painter, const QGLContext* const context)
{
invariant();
#ifndef NDEBUG
if(NULL != painter)
{
Q_ASSERT_X(painter->paintEngine()->type() == QPaintEngine::OpenGL ||
painter->paintEngine()->type() == QPaintEngine::OpenGL2,
Q_FUNC_INFO,
"QGL StelRenderer backends need a QGLWidget to be set as the "
"viewport on the graphics view");
QGLWidget* widget = dynamic_cast<QGLWidget*>(painter->device());
Q_ASSERT_X(NULL != widget && widget->context() == context, Q_FUNC_INFO,
"Painter used with QGL StelRenderer backends needs to paint on a QGLWidget "
"with the same GL context as the one used by the renderer");
}
#else
Q_UNUSED(context);
#endif
defaultPainter = painter;
invariant();
}
WaveformWidgetFactory::WaveformWidgetFactory() :
m_type(WaveformWidgetType::Count_WaveformwidgetType),
m_config(0),
m_skipRender(false),
m_frameRate(30),
m_defaultZoom(3),
m_zoomSync(false),
m_overviewNormalized(false),
m_openGLAvailable(false),
m_openGLShaderAvailable(false),
m_vsyncThread(NULL),
m_frameCnt(0),
m_actualFrameRate(0) {
m_visualGain[All] = 1.5;
m_visualGain[Low] = 1.0;
m_visualGain[Mid] = 1.0;
m_visualGain[High] = 1.0;
if (QGLFormat::hasOpenGL()) {
QGLFormat glFormat;
glFormat.setDirectRendering(true);
glFormat.setDoubleBuffer(true);
glFormat.setDepth(false);
// Disable waiting for vertical Sync
// This can be enabled when using a single Threads for each QGLContext
// Setting 1 causes QGLContext::swapBuffer to sleep until the next VSync
#if defined(__APPLE__)
// On OS X, syncing to vsync has good performance FPS-wise and
// eliminates tearing.
glFormat.setSwapInterval(1);
#else
// Otherwise, turn VSync off because it could cause horrible FPS on
// Linux.
// TODO(XXX): Make this configurable.
// TOOD(XXX): What should we do on Windows?
glFormat.setSwapInterval(0);
#endif
glFormat.setRgba(true);
QGLFormat::setDefaultFormat(glFormat);
QGLFormat::OpenGLVersionFlags version = QGLFormat::openGLVersionFlags();
int majorVersion = 0;
int minorVersion = 0;
if (version == QGLFormat::OpenGL_Version_None) {
m_openGLVersion = "None";
} else if (version & QGLFormat::OpenGL_Version_3_0) {
majorVersion = 3;
} else if (version & QGLFormat::OpenGL_Version_2_1) {
majorVersion = 2;
minorVersion = 1;
} else if (version & QGLFormat::OpenGL_Version_2_0) {
majorVersion = 2;
minorVersion = 0;
} else if (version & QGLFormat::OpenGL_Version_1_5) {
majorVersion = 1;
minorVersion = 5;
} else if (version & QGLFormat::OpenGL_Version_1_4) {
majorVersion = 1;
minorVersion = 4;
} else if (version & QGLFormat::OpenGL_Version_1_3) {
majorVersion = 1;
minorVersion = 3;
} else if (version & QGLFormat::OpenGL_Version_1_2) {
majorVersion = 1;
minorVersion = 2;
} else if (version & QGLFormat::OpenGL_Version_1_1) {
majorVersion = 1;
minorVersion = 1;
}
if (majorVersion != 0) {
m_openGLVersion = QString::number(majorVersion) + "." +
QString::number(minorVersion);
}
m_openGLAvailable = true;
QGLWidget* glWidget = new QGLWidget(); // create paint device
// QGLShaderProgram::hasOpenGLShaderPrograms(); valgind error
m_openGLShaderAvailable = QGLShaderProgram::hasOpenGLShaderPrograms(glWidget->context());
delete glWidget;
}
evaluateWidgets();
m_time.start();
}
void setSwapInterval(QGLWidget const &glWidget, int *interval)
{
typedef void (* PFNGLXQUERYDRAWABLEPROC)(Display *, GLXDrawable, int, unsigned int *);
typedef void (* PFNGLXSWAPINTERVALEXTPROC)(Display *, GLXDrawable, int);
typedef int (* PFNGLXGETSWAPINTERVALMESAPROC)(void);
typedef int (* PFNGLXSWAPINTERVALMESAPROC)(unsigned);
typedef int (* PFNGLXSWAPINTERVALSGIPROC)(int);
PFNGLXSWAPINTERVALEXTPROC glXSwapIntervalEXT;
PFNGLXQUERYDRAWABLEPROC glXQueryDrawable;
PFNGLXGETSWAPINTERVALMESAPROC glXGetSwapIntervalMESA;
PFNGLXSWAPINTERVALMESAPROC glXSwapIntervalMESA;
PFNGLXSWAPINTERVALSGIPROC glXSwapIntervalSGI;
QGLContext const &context = *glWidget.context();
QX11Info const &xinfo = glWidget.x11Info();
glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC) context.getProcAddress("glXSwapIntervalEXT");
glXQueryDrawable = (PFNGLXQUERYDRAWABLEPROC) context.getProcAddress("glXQueryDrawable");
if (glXSwapIntervalEXT && glXQueryDrawable)
{
unsigned clampedInterval;
if (*interval < 0)
{
*interval = 0;
}
glXSwapIntervalEXT(xinfo.display(), glWidget.winId(), *interval);
glXQueryDrawable(xinfo.display(), glWidget.winId(), GLX_SWAP_INTERVAL_EXT, &clampedInterval);
*interval = clampedInterval;
return;
}
glXSwapIntervalMESA = (PFNGLXSWAPINTERVALMESAPROC) context.getProcAddress("glXSwapIntervalMESA");
glXGetSwapIntervalMESA = (PFNGLXGETSWAPINTERVALMESAPROC) context.getProcAddress("glXGetSwapIntervalMESA");
if (glXSwapIntervalMESA && glXGetSwapIntervalMESA)
{
if (*interval < 0)
{
*interval = 0;
}
glXSwapIntervalMESA(*interval);
*interval = glXGetSwapIntervalMESA();
return;
}
glXSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC) context.getProcAddress("glXSwapIntervalSGI");
if (glXSwapIntervalSGI)
{
if (*interval < 1)
{
*interval = 1;
}
if (glXSwapIntervalSGI(*interval))
{
// Error, revert to default
*interval = 1;
glXSwapIntervalSGI(1);
}
return;
}
*interval = -1;
}
static void createGLSurface (QString qmlName, QDeclarativeView * view) {
QmlPainterVideoSurface * timelineSurface = new QmlPainterVideoSurface;
QGLWidget * g = (QGLWidget *) view->viewport();
timelineSurface->setGLContext((QGLContext *) g->context());
view->rootContext()->setContextProperty(qmlName, timelineSurface);
}
void Layer::paint(QPainter *painter, const QStyleOptionGraphicsItem *option,
QWidget *widget)
{
QtPainter *qvpainter = NULL;
#ifdef QT_OPENGL_LIB
QPainter *fboPainter;
QGLFramebufferObject *fbo = NULL;
QGLWidget *qglWidget = qobject_cast<QGLWidget *>(widget);
if (qglWidget) { // on-screen OpenGL
QGLContext *context = const_cast<QGLContext *>(qglWidget->context());
qvpainter = new OpenGLPainter(painter, context);
} else if (cacheMode() != QGraphicsItem::NoCache &&
QGLFramebufferObject::hasOpenGLFramebufferObjects()) {
// caching, try FBO
// if we have direct rendering and FBO support, make use of
// FBO, but this could still just be in software
// NOTE: In Qt 4.6, 'painter' would already target an FBO, if we
// were using the 'OpenGL2' paint engine. We have decided to stick
// with the original engine for now, as the OpenGL2 engine relies
// heavily on shaders, which is slow for our use case.
// Apparently, we must use the QGLContext associated with
// the view being painted. Thus, PlotView tracks whether it is
// inside a paintEvent, so we can get the current QGLWidget.
OverlayScene *overlayScene = qobject_cast<OverlayScene *>(scene());
if (overlayScene)
qglWidget = qobject_cast<QGLWidget *>(overlayScene->view()->viewport());
else {
QList<QGraphicsView *> views = scene()->views();
for (int i = 0; i < views.size() && !qglWidget; i++) {
PlotView *view = qobject_cast<PlotView *>(views[i]);
if (view && view->isPainting())
qglWidget = qobject_cast<QGLWidget *>(view->viewport());
}
}
if (qglWidget) {
QSize size(painter->device()->width(), painter->device()->height());
QGLContext *context = const_cast<QGLContext *>(qglWidget->context());
// GC during paint callback may have reset this
if (qglWidget->context() != QGLContext::currentContext())
qglWidget->makeCurrent();
// NOTE: need Qt 4.6 for antialiasing to work with FBOs
#if QT_VERSION >= 0x40600
if (!fboMultisamplingFailed) {
QGLFramebufferObjectFormat fboFormat;
fboFormat.setAttachment(QGLFramebufferObject::CombinedDepthStencil);
fboFormat.setSamples(4); // 4X antialiasing should be enough?
qInstallMsgHandler(fboDebugMsgCatcher);
fbo = new QGLFramebufferObject(size, fboFormat);
qInstallMsgHandler(0);
if (fboMultisamplingFailed) {
delete fbo;
fbo = NULL;
}
}
#endif
if (!fbo)
fbo = new QGLFramebufferObject(size);
// clear the FBO
fboPainter = new QPainter(fbo);
fboPainter->setCompositionMode(QPainter::CompositionMode_Source);
fboPainter->fillRect(0, 0, size.width(), size.height(), Qt::transparent);
fboPainter->setCompositionMode(QPainter::CompositionMode_SourceOver);
qvpainter = new OpenGLPainter(fboPainter, context);
qvpainter->setTransform(painter->worldTransform());
}
}
#endif
if (!qvpainter) // fallback to Qt renderer
qvpainter = new QtPainter(painter);
// NOTE: in QT 4.6 exposedRect will just be the bounding rect, by default
paintPlot(qvpainter, option->exposedRect);
delete qvpainter;
#ifdef QT_OPENGL_LIB
if (fbo) { // silliness: download to image, only to upload to texture
painter->setWorldMatrixEnabled(false);
qglWidget->makeCurrent(); // gc during callback may have cleared this
// need to tell Qt that 'fboImage' is actually premultiplied
QImage fboImage = fbo->toImage();
const uchar *data = fboImage.bits(); // no deep copy
QImage premultImage = QImage(data,
fboImage.width(),
fboImage.height(),
QImage::Format_ARGB32_Premultiplied);
// Not sure why this can't be (0, 0)...
painter->drawImage(QPointF(1, -1), premultImage);
delete fboPainter;
delete fbo;
}
#endif
}
