void KisOpenGL::initialize() { if (initialized) return; setDefaultFormat(); // we need a QSurface active to get our GL functions from the context QWindow surface; surface.setSurfaceType( QSurface::OpenGLSurface ); surface.create(); QOpenGLContext context; context.create(); context.makeCurrent( &surface ); QOpenGLFunctions *funcs = context.functions(); funcs->initializeOpenGLFunctions(); qDebug() << "OpenGL Info"; qDebug() << " Vendor: " << reinterpret_cast<const char *>(funcs->glGetString(GL_VENDOR)); qDebug() << " Renderer: " << reinterpret_cast<const char *>(funcs->glGetString(GL_RENDERER)); qDebug() << " Version: " << reinterpret_cast<const char *>(funcs->glGetString(GL_VERSION)); qDebug() << " Shading language: " << reinterpret_cast<const char *>(funcs->glGetString(GL_SHADING_LANGUAGE_VERSION)); qDebug() << " Requested format: " << QSurfaceFormat::defaultFormat(); qDebug() << " Current format: " << context.format(); glMajorVersion = context.format().majorVersion(); glMinorVersion = context.format().minorVersion(); supportsDeprecatedFunctions = (context.format().options() & QSurfaceFormat::DeprecatedFunctions); initialized = true; }
void OpenGLRendererBase::onInitializeGL() { DPTR_D(OpenGLRendererBase); //makeCurrent(); QOpenGLContext *ctx = const_cast<QOpenGLContext*>(QOpenGLContext::currentContext()); //qt4 returns const d.glv.setOpenGLContext(ctx); //const QByteArray extensions(reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS))); bool hasGLSL = QOpenGLShaderProgram::hasOpenGLShaderPrograms(); qDebug("OpenGL version: %d.%d hasGLSL: %d", ctx->format().majorVersion(), ctx->format().minorVersion(), hasGLSL); initializeOpenGLFunctions(); glEnable(GL_TEXTURE_2D); glDisable(GL_DEPTH_TEST); glClearColor(0.0, 0.0, 0.0, 0.0); }
void tst_QOpenGL::openGLPaintDevice() { #if defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(__x86_64__) QSKIP("QTBUG-22617"); #endif QFETCH(int, surfaceClass); QScopedPointer<QSurface> surface(createSurface(surfaceClass)); QOpenGLContext ctx; QVERIFY(ctx.create()); QSurfaceFormat format = ctx.format(); if (format.majorVersion() < 2) QSKIP("This test requires at least OpenGL 2.0"); QVERIFY(ctx.makeCurrent(surface.data())); const QSize size(128, 128); QImage image(size, QImage::Format_RGB32); QPainter p(&image); p.fillRect(0, 0, image.width() / 2, image.height() / 2, Qt::red); p.fillRect(image.width() / 2, 0, image.width() / 2, image.height() / 2, Qt::green); p.fillRect(image.width() / 2, image.height() / 2, image.width() / 2, image.height() / 2, Qt::blue); p.fillRect(0, image.height() / 2, image.width() / 2, image.height() / 2, Qt::white); p.end(); QOpenGLFramebufferObject fbo(size); QVERIFY(fbo.bind()); QOpenGLPaintDevice device(size); QVERIFY(p.begin(&device)); p.fillRect(0, 0, image.width() / 2, image.height() / 2, Qt::red); p.fillRect(image.width() / 2, 0, image.width() / 2, image.height() / 2, Qt::green); p.fillRect(image.width() / 2, image.height() / 2, image.width() / 2, image.height() / 2, Qt::blue); p.fillRect(0, image.height() / 2, image.width() / 2, image.height() / 2, Qt::white); p.end(); QImage actual = fbo.toImage().convertToFormat(QImage::Format_RGB32); QCOMPARE(image.size(), actual.size()); QCOMPARE(image, actual); QVERIFY(p.begin(&device)); p.fillRect(0, 0, image.width(), image.height(), Qt::black); p.drawImage(0, 0, image); p.end(); actual = fbo.toImage().convertToFormat(QImage::Format_RGB32); QCOMPARE(image.size(), actual.size()); QCOMPARE(image, actual); QVERIFY(p.begin(&device)); p.fillRect(0, 0, image.width(), image.height(), Qt::black); p.fillRect(0, 0, image.width(), image.height(), QBrush(image)); p.end(); actual = fbo.toImage().convertToFormat(QImage::Format_RGB32); QCOMPARE(image.size(), actual.size()); QCOMPARE(image, actual); }
static bool q_supportsElementIndexUint(QSGRendererInterface::GraphicsApi api) { static bool elementIndexUint = true; #if QT_CONFIG(opengl) if (api == QSGRendererInterface::OpenGL) { static bool elementIndexUintChecked = false; if (!elementIndexUintChecked) { elementIndexUintChecked = true; QOpenGLContext *context = QOpenGLContext::currentContext(); QScopedPointer<QOpenGLContext> dummyContext; QScopedPointer<QOffscreenSurface> dummySurface; bool ok = true; if (!context) { dummyContext.reset(new QOpenGLContext); dummyContext->create(); context = dummyContext.data(); dummySurface.reset(new QOffscreenSurface); dummySurface->setFormat(context->format()); dummySurface->create(); ok = context->makeCurrent(dummySurface.data()); } if (ok) { elementIndexUint = static_cast<QOpenGLExtensions *>(context->functions())->hasOpenGLExtension( QOpenGLExtensions::ElementIndexUint); } } } #else Q_UNUSED(api); #endif return elementIndexUint; }
void dumpGlInfo(QTextStream &str, bool listExtensions) { QOpenGLContext context; if (context.create()) { # ifdef QT_OPENGL_DYNAMIC str << "Dynamic GL "; # endif switch (context.openGLModuleType()) { case QOpenGLContext::LibGL: str << "LibGL"; break; case QOpenGLContext::LibGLES: str << "LibGLES"; break; } QWindow window; window.setSurfaceType(QSurface::OpenGLSurface); window.create(); context.makeCurrent(&window); QOpenGLFunctions functions(&context); str << " Vendor: " << reinterpret_cast<const char *>(functions.glGetString(GL_VENDOR)) << "\nRenderer: " << reinterpret_cast<const char *>(functions.glGetString(GL_RENDERER)) << "\nVersion: " << reinterpret_cast<const char *>(functions.glGetString(GL_VERSION)) << "\nShading language: " << reinterpret_cast<const char *>(functions.glGetString(GL_SHADING_LANGUAGE_VERSION)) << "\nFormat: " << context.format(); if (listExtensions) { QList<QByteArray> extensionList = context.extensions().toList(); std::sort(extensionList.begin(), extensionList.end()); str << " \nFound " << extensionList.size() << " extensions:\n"; foreach (const QByteArray &extension, extensionList) str << " " << extension << '\n'; } } else {
QOpenGLExtensionMatcher::QOpenGLExtensionMatcher() { QOpenGLContext *ctx = QOpenGLContext::currentContext(); QOpenGLFunctions *funcs = ctx->functions(); const char *extensionStr = 0; if (ctx->isOpenGLES() || ctx->format().majorVersion() < 3) extensionStr = reinterpret_cast<const char *>(funcs->glGetString(GL_EXTENSIONS)); if (extensionStr) { QByteArray ba(extensionStr); QList<QByteArray> extensions = ba.split(' '); m_extensions = extensions.toSet(); } else { #ifdef QT_OPENGL_3 // clear error state while (funcs->glGetError()) {} if (ctx) { qt_glGetStringi glGetStringi = (qt_glGetStringi)ctx->getProcAddress("glGetStringi"); if (!glGetStringi) return; GLint numExtensions; funcs->glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions); for (int i = 0; i < numExtensions; ++i) { const char *str = reinterpret_cast<const char *>(glGetStringi(GL_EXTENSIONS, i)); m_extensions.insert(str); } } #endif // QT_OPENGL_3 } }
int getMaxTextureSize() { int maxSize = 0; // Create a temp context - required if this is called from another thread QOpenGLContext ctx; if ( !ctx.create() ) { // TODO handle the error qDebug() << "No OpenGL context could be created, this is clearly bad..."; exit(-1); } // rather than using a QWindow - which actually dosen't seem to work in this case either! QOffscreenSurface surface; surface.setFormat( ctx.format() ); surface.create(); ctx.makeCurrent(&surface); // Now the call works QOpenGLFunctions glFuncs(QOpenGLContext::currentContext()); glFuncs.glEnable(GL_TEXTURE_2D); glFuncs.glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxSize); return maxSize; }
void MapWidget::initializeGL() { initializeOpenGLFunctions(); QString versionString(QLatin1String(reinterpret_cast<const char*>(glGetString(GL_VERSION)))); QOpenGLContext *ctx = QOpenGLContext::currentContext(); Q_UNUSED(ctx); lg = new QOpenGLDebugLogger(context()); lg->initialize(); lg->startLogging(QOpenGLDebugLogger::SynchronousLogging); lg->enableMessages(); connect(lg, SIGNAL(messageLogged(QOpenGLDebugMessage)), this, SLOT(glLog(QOpenGLDebugMessage))); qDebug() << "Driver Version String:" << versionString; qDebug() << "Current Context:" << ctx->format(); //glGetIntegerv(GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX, &gpuTotalMemory); //qDebug() << "total" << gpuTotalMemory; m_renderer = new Renderer(); m_renderer->createStaticResources(); //m_painterOverlay = new PainterOverlay(); }
QSurfaceFormat::OpenGLContextProfile QSGShaderSourceBuilder::contextProfile() const { QOpenGLContext *context = QOpenGLContext::currentContext(); QSurfaceFormat::OpenGLContextProfile profile = QSurfaceFormat::NoProfile; Q_ASSERT(context); profile = context->format().profile(); return profile; }
static bool checkVersion(QOpenGLContext &context, QSurfaceFormat &format) { QSurfaceFormat currSurface = context.format(); QPair<int,int> currVersion = currSurface.version(); QPair<int,int> reqVersion = format.version(); if (currVersion.first > reqVersion.first) return true; return (currVersion.first == reqVersion.first && currVersion.second >= reqVersion.second); }
void OpenGLRenderPrivate::initialize() { initializeOpenGLFunctions(); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); for (int i = 0; i < 5; ++i){ const char *fShaderCode = nullptr; switch (i){ case 0: case 1: fShaderCode = fShaderI420; break; case 2: fShaderCode = fShaderNV12; break; case 3: fShaderCode = fShaderNV21; break; case 4: fShaderCode = fShaderBGRP; break; } QOpenGLShaderProgram &p = program[i]; p.addShaderFromSourceCode(QOpenGLShader::Vertex, vShaderCode); p.addShaderFromSourceCode(QOpenGLShader::Fragment, fShaderCode); p.bindAttributeLocation("VtxCoord", 0); p.bindAttributeLocation("TexCoord", 1); p.bind(); switch (i){ case 0: p.setUniformValue("SamplerY", 0); p.setUniformValue("SamplerU", 1); p.setUniformValue("SamplerV", 2); break; case 1: p.setUniformValue("SamplerY", 0); p.setUniformValue("SamplerV", 1); p.setUniformValue("SamplerU", 2); break; case 2: case 3: p.setUniformValue("SamplerY", 0); p.setUniformValue("SamplerA", 1); break; case 4: p.setUniformValue("SamplerP", 0); break; } } tex[0] = 0; tex[1] = 0; tex[2] = 1; tex[3] = 0; tex[4] = 0; tex[5] = 1; tex[6] = 1; tex[7] = 1; QOpenGLContext *c = QOpenGLContext::currentContext(); timer.setInterval(c->format().swapInterval() / (double)c->screen()->refreshRate()); }
bool QOpenGLTextureBlitter::create() { QOpenGLContext *currentContext = QOpenGLContext::currentContext(); if (!currentContext) return false; Q_D(QOpenGLTextureBlitter); d->vao->create(); d->vao->bind(); if (d->program) return true; d->program.reset(new QOpenGLShaderProgram()); QSurfaceFormat format = currentContext->format(); if (format.profile() == QSurfaceFormat::CoreProfile && format.version() >= qMakePair(3,2)) { d->program->addShaderFromSourceCode(QOpenGLShader::Vertex, vertex_shader150); d->program->addShaderFromSourceCode(QOpenGLShader::Fragment, fragment_shader150); } else { d->program->addShaderFromSourceCode(QOpenGLShader::Vertex, vertex_shader); d->program->addShaderFromSourceCode(QOpenGLShader::Fragment, fragment_shader); } d->program->link(); if (!d->program->isLinked()) { qWarning() << Q_FUNC_INFO << "Could not link shader program:\n" << d->program->log(); return false; } d->program->bind(); d->vertexBuffer.create(); d->vertexBuffer.bind(); d->vertexBuffer.allocate(vertex_buffer_data, sizeof(vertex_buffer_data)); d->vertexBuffer.release(); d->textureBuffer.create(); d->textureBuffer.bind(); d->textureBuffer.allocate(texture_buffer_data, sizeof(texture_buffer_data)); d->textureBuffer.release(); d->vertexCoordAttribPos = d->program->attributeLocation("vertexCoord"); d->vertexTransformUniformPos = d->program->uniformLocation("vertexTransform"); d->textureCoordAttribPos = d->program->attributeLocation("textureCoord"); d->textureTransformUniformPos = d->program->uniformLocation("textureTransform"); d->swizzleUniformPos = d->program->uniformLocation("swizzle"); d->program->setUniformValue(d->swizzleUniformPos,false); d->vao->release(); return true; }
void OpenGLRendererBase::onInitializeGL() { DPTR_D(OpenGLRendererBase); //makeCurrent(); #if QT_VERSION >= QT_VERSION_CHECK(4, 8, 0) initializeOpenGLFunctions(); #endif QOpenGLContext *ctx = const_cast<QOpenGLContext*>(QOpenGLContext::currentContext()); //qt4 returns const d.glv.setOpenGLContext(ctx); //const QByteArray extensions(reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS))); bool hasGLSL = QOpenGLShaderProgram::hasOpenGLShaderPrograms(); qDebug("OpenGL version: %d.%d hasGLSL: %d", ctx->format().majorVersion(), ctx->format().minorVersion(), hasGLSL); static bool sInfo = true; if (sInfo) { sInfo = false; qDebug("GL_VERSION: %s", DYGL(glGetString(GL_VERSION))); qDebug("GL_VENDOR: %s", DYGL(glGetString(GL_VENDOR))); qDebug("GL_RENDERER: %s", DYGL(glGetString(GL_RENDERER))); qDebug("GL_SHADING_LANGUAGE_VERSION: %s", DYGL(glGetString(GL_SHADING_LANGUAGE_VERSION))); } }
QString openGlContext() { QString result; QTextStream str(&result); QOpenGLContext context; if (context.create()) { # ifdef QT_OPENGL_DYNAMIC str << "Dynamic GL "; # endif switch (context.openGLModuleType()) { case QOpenGLContext::LibGL: str << "LibGL"; break; case QOpenGLContext::LibGLES: str << "LibGLES"; break; } QWindow window; if (QGuiApplication::platformName() == QLatin1String("greenisland")) window.setFlags(Qt::Desktop); window.setSurfaceType(QSurface::OpenGLSurface); //window.setScreen(QGuiApplication::primaryScreen()); window.create(); if (context.makeCurrent(&window)) { QOpenGLFunctions functions(&context); str << " Vendor: " << reinterpret_cast<const char *>(functions.glGetString(GL_VENDOR)) << "\nRenderer: " << reinterpret_cast<const char *>(functions.glGetString(GL_RENDERER)) << "\nVersion: " << reinterpret_cast<const char *>(functions.glGetString(GL_VERSION)) << "\nGLSL version: " << reinterpret_cast<const char *>(functions.glGetString(GL_SHADING_LANGUAGE_VERSION)) << "\nFormat: " << context.format(); QList<QByteArray> extensionList = context.extensions().toList(); std::sort(extensionList.begin(), extensionList.end()); QByteArray extensions = extensionList.join(' '); str << " \nFound " << extensionList.size() << " extensions:\n"; str << wordWrap(extensions, 78); context.doneCurrent(); } window.destroy(); } else { str << "Unable to create an Open GL context.\n"; } return result; }
void GLWidget277::debugContextVersion() { QOpenGLContext *ctx = context(); QSurfaceFormat form = format(); QSurfaceFormat ctxform = ctx->format(); QSurfaceFormat::OpenGLContextProfile prof = ctxform.profile(); const char *profile = prof == QSurfaceFormat::CoreProfile ? "Core" : prof == QSurfaceFormat::CompatibilityProfile ? "Compatibility" : "None"; int ctxmajor = ctxform.majorVersion(); int ctxminor = ctxform.minorVersion(); bool valid = ctx->isValid(); int formmajor = form.majorVersion(); int formminor = form.minorVersion(); const char *vendor = glGS(GL_VENDOR); const char *renderer = glGS(GL_RENDERER); const char *version = glGS(GL_VERSION); const char *s_glsl = glGS(GL_SHADING_LANGUAGE_VERSION); printf("Widget version: %d.%d\n", ctxmajor, ctxminor); printf("Context valid: %s\n", valid ? "yes" : "NO"); printf("Format version: %d.%d\n", formmajor, formminor); printf("Profile: %s\n", profile); printf(" Vendor: %s\n", vendor); printf(" Renderer: %s\n", renderer); printf(" Version: %s\n", version); printf(" GLSL: %s\n", s_glsl); QString glsl = s_glsl; if (ctxmajor < 3 || glsl.startsWith("1.10") || glsl.startsWith("1.20")) { printf("ERROR: " "Unable to get an OpenGL 3.x context with GLSL 1.30 or newer. " "If your hardware should support it, update your drivers. " "If you have switchable graphics, make sure that you are using the discrete GPU.\n"); QApplication::exit(); } else if ((ctxmajor == 3 && ctxminor < 2) || glsl.startsWith("1.30") || glsl.startsWith("1.40")) { printf("WARNING: " "Unable to get an OpenGL 3.2 context with GLSL 1.50. " "If your hardware should support it, update your drivers. " "If you have switchable graphics, make sure that you are using the discrete GPU. " "If you cannot get 3.2 support, it is possible to port this project...."); // Note: doing this requires at least the following actions: // * Change the header and base class in glwidget277.h to 3.0/3.1 instead of 3.2 Core. // * Change the shaders to require GLSL 1.30 or 1.40. } }
void Widget::renderWindowReady() { QOpenGLContext *context = QOpenGLContext::currentContext(); Q_ASSERT(context); QString vendor, renderer, version, glslVersion; const GLubyte *p; QOpenGLFunctions *f = context->functions(); if ((p = f->glGetString(GL_VENDOR))) vendor = QString::fromLatin1(reinterpret_cast<const char *>(p)); if ((p = f->glGetString(GL_RENDERER))) renderer = QString::fromLatin1(reinterpret_cast<const char *>(p)); if ((p = f->glGetString(GL_VERSION))) version = QString::fromLatin1(reinterpret_cast<const char *>(p)); if ((p = f->glGetString(GL_SHADING_LANGUAGE_VERSION))) glslVersion = QString::fromLatin1(reinterpret_cast<const char *>(p)); m_output->append(tr("*** Context information ***")); m_output->append(tr("Vendor: %1").arg(vendor)); m_output->append(tr("Renderer: %1").arg(renderer)); m_output->append(tr("OpenGL version: %1").arg(version)); m_output->append(tr("GLSL version: %1").arg(glslVersion)); m_output->append(tr("\n*** QSurfaceFormat from context ***")); printFormat(context->format()); m_output->append(tr("\n*** QSurfaceFormat from window surface ***")); printFormat(m_surface->format()); m_output->append(tr("\n*** Qt build information ***")); const char *gltype[] = { "Desktop", "GLES 2", "GLES 1" }; m_output->append(tr("Qt OpenGL configuration: %1") .arg(QString::fromLatin1(gltype[QOpenGLContext::openGLModuleType()]))); m_output->append(tr("Qt OpenGL library handle: %1") .arg(QString::number(qintptr(QOpenGLContext::openGLModuleHandle()), 16))); QList<QByteArray> extensionList = context->extensions().toList(); std::sort(extensionList.begin(), extensionList.end()); m_extensions->append(tr("Found %1 extensions:").arg(extensionList.count())); Q_FOREACH (const QByteArray &ext, extensionList) m_extensions->append(QString::fromLatin1(ext)); m_output->moveCursor(QTextCursor::Start); m_extensions->moveCursor(QTextCursor::Start); }
void ResultRecorder::startResults(const QString &id) { // sub process will get all this. // safer that way, as then we keep OpenGL (and QGuiApplication) out of the host if (!Options::instance.isSubProcess) return; m_results["id"] = id; QString prettyProductName = #if QT_VERSION >= 0x050400 QSysInfo::prettyProductName(); #else # if defined(Q_OS_IOS) QStringLiteral("iOS"); # elif defined(Q_OS_OSX) QString::fromLatin1("OSX %d").arg(QSysInfo::macVersion()); # elif defined(Q_OS_WIN) QString::fromLatin1("Windows %d").arg(QSysInfo::windowsVersion()); # elif defined(Q_OS_LINUX) QStringLiteral("Linux"); # elif defined(Q_OS_ANDROID) QStringLiteral("Android"); # else QStringLiteral("unknown"); # endif #endif QVariantMap osMap; osMap["prettyProductName"] = prettyProductName; osMap["platformPlugin"] = QGuiApplication::platformName(); m_results["os"] = osMap; m_results["qt"] = QT_VERSION_STR; m_results["command-line"] = qApp->arguments().join(' '); // The following code makes the assumption that an OpenGL context the GUI // thread will get the same capabilities as the render thread's OpenGL // context. Not 100% accurate, but it works... QOpenGLContext context; context.create(); QOffscreenSurface surface; // In very odd cases, we can get incompatible configs here unless we pass the // GL context's format on to the offscreen format. surface.setFormat(context.format()); surface.create(); if (!context.makeCurrent(&surface)) { qWarning() << "failed to acquire GL context to get version info."; return; } QOpenGLFunctions *func = context.functions(); #if QT_VERSION >= 0x050300 const char *vendor = (const char *) func->glGetString(GL_VENDOR); const char *renderer = (const char *) func->glGetString(GL_RENDERER); const char *version = (const char *) func->glGetString(GL_VERSION); #else Q_UNUSED(func); const char *vendor = (const char *) glGetString(GL_VENDOR); const char *renderer = (const char *) glGetString(GL_RENDERER); const char *version = (const char *) glGetString(GL_VERSION); #endif if (!Options::instance.printJsonToStdout) { std::cout << "ID: " << id.toStdString() << std::endl; std::cout << "OS: " << prettyProductName.toStdString() << std::endl; std::cout << "QPA: " << QGuiApplication::platformName().toStdString() << std::endl; std::cout << "GL_VENDOR: " << vendor << std::endl; std::cout << "GL_RENDERER: " << renderer << std::endl; std::cout << "GL_VERSION: " << version << std::endl; } QVariantMap glInfo; glInfo["vendor"] = vendor; glInfo["renderer"] = renderer; glInfo["version"] = version; m_results["opengl"] = glInfo; context.doneCurrent(); }
void D3DPresentEngine::createOffscreenTexture() { // First, check if we have a context on this thread QOpenGLContext *currentContext = QOpenGLContext::currentContext(); if (!currentContext) { //Create OpenGL context and set share context from surface QOpenGLContext *shareContext = qobject_cast<QOpenGLContext*>(m_surface->property("GLContext").value<QObject*>()); if (!shareContext) return; m_offscreenSurface = new QWindow; m_offscreenSurface->setSurfaceType(QWindow::OpenGLSurface); //Needs geometry to be a valid surface, but size is not important m_offscreenSurface->setGeometry(-1, -1, 1, 1); m_offscreenSurface->create(); m_glContext = new QOpenGLContext; m_glContext->setFormat(m_offscreenSurface->requestedFormat()); m_glContext->setShareContext(shareContext); if (!m_glContext->create()) { delete m_glContext; delete m_offscreenSurface; m_glContext = 0; m_offscreenSurface = 0; return; } currentContext = m_glContext; } if (m_glContext) m_glContext->makeCurrent(m_offscreenSurface); if (!m_egl) m_egl = new EGLWrapper; QPlatformNativeInterface *nativeInterface = QGuiApplication::platformNativeInterface(); m_eglDisplay = static_cast<EGLDisplay*>( nativeInterface->nativeResourceForContext("eglDisplay", currentContext)); m_eglConfig = static_cast<EGLConfig*>( nativeInterface->nativeResourceForContext("eglConfig", currentContext)); currentContext->functions()->glGenTextures(1, &m_glTexture); int w = m_surfaceFormat.frameWidth(); int h = m_surfaceFormat.frameHeight(); bool hasAlpha = currentContext->format().hasAlpha(); EGLint attribs[] = { EGL_WIDTH, w, EGL_HEIGHT, h, EGL_TEXTURE_FORMAT, hasAlpha ? EGL_TEXTURE_RGBA : EGL_TEXTURE_RGB, EGL_TEXTURE_TARGET, EGL_TEXTURE_2D, EGL_NONE }; EGLSurface pbuffer = m_egl->createPbufferSurface(m_eglDisplay, m_eglConfig, attribs); HANDLE share_handle = 0; PFNEGLQUERYSURFACEPOINTERANGLEPROC eglQuerySurfacePointerANGLE = reinterpret_cast<PFNEGLQUERYSURFACEPOINTERANGLEPROC>(m_egl->getProcAddress("eglQuerySurfacePointerANGLE")); Q_ASSERT(eglQuerySurfacePointerANGLE); eglQuerySurfacePointerANGLE( m_eglDisplay, pbuffer, EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE, &share_handle); m_device->CreateTexture(w, h, 1, D3DUSAGE_RENDERTARGET, hasAlpha ? D3DFMT_A8R8G8B8 : D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &m_texture, &share_handle); m_eglSurface = pbuffer; if (m_glContext) m_glContext->doneCurrent(); }
void Thumbnail::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *widget) { QRectF parentRect = parentItem()->sceneBoundingRect(); // Skip drawing thumbnails outside their parents if (!sceneBoundingRect().intersects(parentRect)) return; prePaint(painter, widget); // Draw image if(!img.isNull()) { auto imgRect = QRectF(img.rect()); imgRect.moveCenter(rect.center()); painter->drawImage(imgRect.topLeft(), img); } // Draw 3D mesh if(mesh.points.size() || auxMeshes.size()) { if (img.isNull() || isTempImage) { auto glwidget = (Viewer*)widget; if (glwidget) { QOpenGLContext context; context.setShareContext(glwidget->context()); context.setFormat(glwidget->format()); context.create(); QOffscreenSurface m_offscreenSurface; m_offscreenSurface.setFormat(context.format()); m_offscreenSurface.create(); context.makeCurrent(&m_offscreenSurface); QOpenGLFramebufferObjectFormat fboformat; fboformat.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil); QOpenGLFramebufferObject renderFbo(rect.width() * 2, rect.height() * 2, fboformat); renderFbo.bind(); glwidget->glEnable(GL_DEPTH_TEST); glwidget->glEnable(GL_BLEND); glwidget->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glwidget->glCullFace(GL_BACK); glwidget->glClearColor(0,0,0,0); glwidget->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glwidget->glViewport(0, 0, renderFbo.size().width(), renderFbo.size().height()); if(mesh.points.size()) glwidget->drawTriangles(mesh.color, mesh.points, mesh.normals, pvm); // Draw aux meshes for (auto auxmesh : auxMeshes) glwidget->drawTriangles(auxmesh.color, auxmesh.points, auxmesh.normals, pvm); glwidget->glDisable(GL_DEPTH_TEST); glwidget->glFlush(); renderFbo.release(); this->setImage( renderFbo.toImage().scaledToWidth(rect.width(), Qt::SmoothTransformation) ); // Thanks for sharing! glwidget->makeCurrent(); } /*painter->beginNativePainting(); auto glwidget = (Viewer*)widget; if (glwidget) { // Draw mesh auto r = sceneBoundingRect(); auto v = scene()->views().first(); QPoint viewDelta = v->mapFromScene(r.topLeft()); if (viewDelta.manhattanLength() > 5) r.moveTopLeft(viewDelta); glwidget->eyePos = eye; glwidget->pvm = pvm; glwidget->glViewport(r.left(), v->height() - r.height() - r.top(), r.width(), r.height()); // Clipping OpenGL glwidget->glEnable(GL_SCISSOR_TEST); glwidget->glScissor(parentRect.x(), v->height() - parentRect.height() - parentRect.top(), parentRect.width(), parentRect.height()); glwidget->glClear(GL_DEPTH_BUFFER_BIT); glwidget->drawTriangles(mesh.color, mesh.points, mesh.normals, pvm); // Draw aux meshes for (auto auxmesh : auxMeshes) { glwidget->drawTriangles(auxmesh.color, auxmesh.points, auxmesh.normals, pvm); } glwidget->glDisable(GL_SCISSOR_TEST); } painter->endNativePainting();*/ } } // Draw the caption if(caption.size()) { painter->setPen(QPen(Qt::white,1)); auto textRect = rect; textRect.setHeight(painter->fontMetrics().height() * 1.25); textRect.moveBottom(rect.height() - textRect.height() * 0.5); painter->drawText(textRect, caption, Qt::AlignVCenter | Qt::AlignHCenter); } postPaint(painter, widget); }
void ExploreLiveView::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget * widget) { if(!isReady) return; prePaint(painter); postPaint(painter); auto glwidget = (Viewer*)widget; if (glwidget && meshes.size()) { QRectF parentRect = parentItem()->sceneBoundingRect(); if (isCacheImage && cachedImage.isNull()) { QOpenGLContext context; context.setShareContext(glwidget->context()); context.setFormat(glwidget->format()); context.create(); QOffscreenSurface m_offscreenSurface; m_offscreenSurface.setFormat(context.format()); m_offscreenSurface.create(); context.makeCurrent(&m_offscreenSurface); QOpenGLFramebufferObjectFormat fboformat; fboformat.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil); QOpenGLFramebufferObject renderFbo(cacheImageSize*1.5, cacheImageSize, fboformat); renderFbo.bind(); glwidget->glEnable(GL_DEPTH_TEST); glwidget->glEnable(GL_BLEND); glwidget->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glwidget->glCullFace(GL_BACK); glwidget->glClearColor(0,0,0,0); glwidget->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glwidget->glViewport(0, 0, cacheImageSize*1.5, cacheImageSize); // XXX Fix // glwidget->glPointSize(10); // Draw aux meshes for (auto mesh : meshes) { if (mesh.isPoints) glwidget->drawOrientedPoints(mesh.points, mesh.normals, mesh.color, glwidget->pvm); else glwidget->drawTriangles(mesh.color, mesh.points, mesh.normals, glwidget->pvm); } glwidget->glDisable(GL_DEPTH_TEST); glwidget->glFlush(); renderFbo.release(); cachedImage = renderFbo.toImage(); isReady = true; // Thanks for sharing! glwidget->makeCurrent(); } // Draw as image if(isCacheImage) { int w = shapeRect.width(); painter->drawImage(w * -0.5, w * -0.5, cachedImage.scaledToWidth(w)); } if(!isCacheImage) { auto r = shapeRect; // scale view double s = 1.5; r.setWidth(r.width() * s); r.setHeight(r.height() * s); r.moveCenter(this->mapToScene(boundingRect().center())); painter->beginNativePainting(); auto v = scene()->views().first(); QPoint viewDelta = v->mapFromScene(r.topLeft()); if (viewDelta.manhattanLength() > 5) r.moveTopLeft(viewDelta); auto camera = ExploreProcess::defaultCamera(document->extent().length()); glwidget->eyePos = camera.first; glwidget->pvm = camera.second; glwidget->glViewport(r.left(), v->height() - r.height() - r.top(), r.width(), r.height()); // Clipping OpenGL glwidget->glEnable(GL_SCISSOR_TEST); glwidget->glScissor(parentRect.x(), v->height() - parentRect.height() - parentRect.top(), parentRect.width(), parentRect.height()); glwidget->glClear(GL_DEPTH_BUFFER_BIT); // FIX XXX // glwidget->glPointSize(2); // Draw aux meshes for (auto mesh : meshes) { if (mesh.isPoints) glwidget->drawOrientedPoints(mesh.points, mesh.normals, mesh.color, glwidget->pvm); else glwidget->drawTriangles(mesh.color, mesh.points, mesh.normals, glwidget->pvm); } glwidget->glDisable(GL_SCISSOR_TEST); painter->endNativePainting(); } } }
QT_BEGIN_NAMESPACE QOpenGLTextureHelper::QOpenGLTextureHelper(QOpenGLContext *context) { // Resolve EXT_direct_state_access entry points if present. // However, disable it on some systems where DSA is known to be unreliable. bool allowDSA = true; const char *renderer = reinterpret_cast<const char *>(context->functions()->glGetString(GL_RENDERER)); // QTBUG-40653, QTBUG-44988 if (renderer && strstr(renderer, "AMD Radeon HD")) allowDSA = false; if (allowDSA && !context->isOpenGLES() && context->hasExtension(QByteArrayLiteral("GL_EXT_direct_state_access"))) { TextureParameteriEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , GLint )>(context->getProcAddress(QByteArrayLiteral("glTextureParameteriEXT"))); TextureParameterivEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , const GLint *)>(context->getProcAddress(QByteArrayLiteral("glTextureParameterivEXT"))); TextureParameterfEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , GLfloat )>(context->getProcAddress(QByteArrayLiteral("glTextureParameterfEXT"))); TextureParameterfvEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , const GLfloat *)>(context->getProcAddress(QByteArrayLiteral("glTextureParameterfvEXT"))); GenerateTextureMipmapEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum )>(context->getProcAddress(QByteArrayLiteral("glGenerateTextureMipmapEXT"))); TextureStorage3DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLsizei )>(context->getProcAddress(QByteArrayLiteral("glTextureStorage3DEXT"))); TextureStorage2DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLenum , GLsizei , GLsizei )>(context->getProcAddress(QByteArrayLiteral("glTextureStorage2DEXT"))); TextureStorage1DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLenum , GLsizei )>(context->getProcAddress(QByteArrayLiteral("glTextureStorage1DEXT"))); TextureStorage3DMultisampleEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress(QByteArrayLiteral("glTextureStorage3DMultisampleEXT"))); TextureStorage2DMultisampleEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLboolean )>(context->getProcAddress(QByteArrayLiteral("glTextureStorage2DMultisampleEXT"))); TextureImage3DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTextureImage3DEXT"))); TextureImage2DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTextureImage2DEXT"))); TextureImage1DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTextureImage1DEXT"))); TextureSubImage3DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTextureSubImage3DEXT"))); TextureSubImage2DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTextureSubImage2DEXT"))); TextureSubImage1DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTextureSubImage1DEXT"))); CompressedTextureSubImage1DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTextureSubImage1DEXT"))); CompressedTextureSubImage2DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTextureSubImage2DEXT"))); CompressedTextureSubImage3DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTextureSubImage3DEXT"))); CompressedTextureImage1DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTextureImage1DEXT"))); CompressedTextureImage2DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTextureImage2DEXT"))); CompressedTextureImage3DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTextureImage3DEXT"))); // Use the real DSA functions TextureParameteri = &QOpenGLTextureHelper::dsa_TextureParameteri; TextureParameteriv = &QOpenGLTextureHelper::dsa_TextureParameteriv; TextureParameterf = &QOpenGLTextureHelper::dsa_TextureParameterf; TextureParameterfv = &QOpenGLTextureHelper::dsa_TextureParameterfv; GenerateTextureMipmap = &QOpenGLTextureHelper::dsa_GenerateTextureMipmap; TextureStorage3D = &QOpenGLTextureHelper::dsa_TextureStorage3D; TextureStorage2D = &QOpenGLTextureHelper::dsa_TextureStorage2D; TextureStorage1D = &QOpenGLTextureHelper::dsa_TextureStorage1D; TextureStorage3DMultisample = &QOpenGLTextureHelper::dsa_TextureStorage3DMultisample; TextureStorage2DMultisample = &QOpenGLTextureHelper::dsa_TextureStorage2DMultisample; TextureImage3D = &QOpenGLTextureHelper::dsa_TextureImage3D; TextureImage2D = &QOpenGLTextureHelper::dsa_TextureImage2D; TextureImage1D = &QOpenGLTextureHelper::dsa_TextureImage1D; TextureSubImage3D = &QOpenGLTextureHelper::dsa_TextureSubImage3D; TextureSubImage2D = &QOpenGLTextureHelper::dsa_TextureSubImage2D; TextureSubImage1D = &QOpenGLTextureHelper::dsa_TextureSubImage1D; CompressedTextureSubImage1D = &QOpenGLTextureHelper::dsa_CompressedTextureSubImage1D; CompressedTextureSubImage2D = &QOpenGLTextureHelper::dsa_CompressedTextureSubImage2D; CompressedTextureSubImage3D = &QOpenGLTextureHelper::dsa_CompressedTextureSubImage3D; CompressedTextureImage1D = &QOpenGLTextureHelper::dsa_CompressedTextureImage1D; CompressedTextureImage2D = &QOpenGLTextureHelper::dsa_CompressedTextureImage2D; CompressedTextureImage3D = &QOpenGLTextureHelper::dsa_CompressedTextureImage3D; } else { // Use our own DSA emulation TextureParameteri = &QOpenGLTextureHelper::qt_TextureParameteri; TextureParameteriv = &QOpenGLTextureHelper::qt_TextureParameteriv; TextureParameterf = &QOpenGLTextureHelper::qt_TextureParameterf; TextureParameterfv = &QOpenGLTextureHelper::qt_TextureParameterfv; GenerateTextureMipmap = &QOpenGLTextureHelper::qt_GenerateTextureMipmap; TextureStorage3D = &QOpenGLTextureHelper::qt_TextureStorage3D; TextureStorage2D = &QOpenGLTextureHelper::qt_TextureStorage2D; TextureStorage1D = &QOpenGLTextureHelper::qt_TextureStorage1D; TextureStorage3DMultisample = &QOpenGLTextureHelper::qt_TextureStorage3DMultisample; TextureStorage2DMultisample = &QOpenGLTextureHelper::qt_TextureStorage2DMultisample; TextureImage3D = &QOpenGLTextureHelper::qt_TextureImage3D; TextureImage2D = &QOpenGLTextureHelper::qt_TextureImage2D; TextureImage1D = &QOpenGLTextureHelper::qt_TextureImage1D; TextureSubImage3D = &QOpenGLTextureHelper::qt_TextureSubImage3D; TextureSubImage2D = &QOpenGLTextureHelper::qt_TextureSubImage2D; TextureSubImage1D = &QOpenGLTextureHelper::qt_TextureSubImage1D; CompressedTextureSubImage1D = &QOpenGLTextureHelper::qt_CompressedTextureSubImage1D; CompressedTextureSubImage2D = &QOpenGLTextureHelper::qt_CompressedTextureSubImage2D; CompressedTextureSubImage3D = &QOpenGLTextureHelper::qt_CompressedTextureSubImage3D; CompressedTextureImage1D = &QOpenGLTextureHelper::qt_CompressedTextureImage1D; CompressedTextureImage2D = &QOpenGLTextureHelper::qt_CompressedTextureImage2D; CompressedTextureImage3D = &QOpenGLTextureHelper::qt_CompressedTextureImage3D; } // Some DSA functions are part of NV_texture_multisample instead if (!context->isOpenGLES() && context->hasExtension(QByteArrayLiteral("GL_NV_texture_multisample"))) { TextureImage3DMultisampleNV = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLint , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress(QByteArrayLiteral("glTextureImage3DMultisampleNV"))); TextureImage2DMultisampleNV = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLint , GLsizei , GLsizei , GLboolean )>(context->getProcAddress(QByteArrayLiteral("glTextureImage2DMultisampleNV"))); TextureImage3DMultisample = &QOpenGLTextureHelper::dsa_TextureImage3DMultisample; TextureImage2DMultisample = &QOpenGLTextureHelper::dsa_TextureImage2DMultisample; } else { TextureImage3DMultisample = &QOpenGLTextureHelper::qt_TextureImage3DMultisample; TextureImage2DMultisample = &QOpenGLTextureHelper::qt_TextureImage2DMultisample; } // wglGetProcAddress should not be used to (and indeed will not) load OpenGL <= 1.1 functions. // Hence, we resolve them "the hard way" #if defined(Q_OS_WIN) && !defined(QT_OPENGL_ES_2) HMODULE handle = static_cast<HMODULE>(QOpenGLContext::openGLModuleHandle()); if (!handle) handle = GetModuleHandleA("opengl32.dll"); // OpenGL 1.0 GetIntegerv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint *)>(GetProcAddress(handle, QByteArrayLiteral("glGetIntegerv"))); GetBooleanv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLboolean *)>(GetProcAddress(handle, QByteArrayLiteral("glGetBooleanv"))); PixelStorei = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint )>(GetProcAddress(handle, QByteArrayLiteral("glPixelStorei"))); GetTexLevelParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLint *)>(GetProcAddress(handle, QByteArrayLiteral("glGetTexLevelParameteriv"))); GetTexLevelParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLfloat *)>(GetProcAddress(handle, QByteArrayLiteral("glGetTexLevelParameterfv"))); GetTexParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(GetProcAddress(handle, QByteArrayLiteral("glGetTexParameteriv"))); GetTexParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat *)>(GetProcAddress(handle, QByteArrayLiteral("glGetTexParameterfv"))); GetTexImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLenum , GLvoid *)>(GetProcAddress(handle, QByteArrayLiteral("glGetTexImage"))); TexImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(GetProcAddress(handle, QByteArrayLiteral("glTexImage2D"))); TexImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(GetProcAddress(handle, QByteArrayLiteral("glTexImage1D"))); TexParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLint *)>(GetProcAddress(handle, QByteArrayLiteral("glTexParameteriv"))); TexParameteri = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint )>(GetProcAddress(handle, QByteArrayLiteral("glTexParameteri"))); TexParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLfloat *)>(GetProcAddress(handle, QByteArrayLiteral("glTexParameterfv"))); TexParameterf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat )>(GetProcAddress(handle, QByteArrayLiteral("glTexParameterf"))); // OpenGL 1.1 GenTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(GetProcAddress(handle, QByteArrayLiteral("glGenTextures"))); DeleteTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *)>(GetProcAddress(handle, QByteArrayLiteral("glDeleteTextures"))); BindTexture = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(GetProcAddress(handle, QByteArrayLiteral("glBindTexture"))); TexSubImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(GetProcAddress(handle, QByteArrayLiteral("glTexSubImage2D"))); TexSubImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid *)>(GetProcAddress(handle, QByteArrayLiteral("glTexSubImage1D"))); #elif defined(QT_OPENGL_ES_2) // Here we are targeting OpenGL ES 2.0+ only. This is likely using EGL, where, // similarly to WGL, non-extension functions (i.e. any function that is part of the // GLES spec) *may* not be queried via eglGetProcAddress. // OpenGL 1.0 GetIntegerv = ::glGetIntegerv; GetBooleanv = ::glGetBooleanv; PixelStorei = ::glPixelStorei; GetTexLevelParameteriv = 0; GetTexLevelParameterfv = 0; GetTexParameteriv = ::glGetTexParameteriv; GetTexParameterfv = ::glGetTexParameterfv; GetTexImage = 0; TexImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(::glTexImage2D); TexImage1D = 0; TexParameteriv = ::glTexParameteriv; TexParameteri = ::glTexParameteri; TexParameterfv = ::glTexParameterfv; TexParameterf = ::glTexParameterf; // OpenGL 1.1 GenTextures = ::glGenTextures; DeleteTextures = ::glDeleteTextures; BindTexture = ::glBindTexture; TexSubImage2D = ::glTexSubImage2D; TexSubImage1D = 0; // OpenGL 1.3 GetCompressedTexImage = 0; CompressedTexSubImage1D = 0; CompressedTexSubImage2D = ::glCompressedTexSubImage2D; CompressedTexImage1D = 0; CompressedTexImage2D = ::glCompressedTexImage2D; ActiveTexture = ::glActiveTexture; // OpenGL 3.0 GenerateMipmap = ::glGenerateMipmap; // OpenGL 3.2 TexImage3DMultisample = 0; TexImage2DMultisample = 0; // OpenGL 4.2 QOpenGLContext *ctx = QOpenGLContext::currentContext(); if (ctx->format().majorVersion() >= 3) { // OpenGL ES 3.0+ has immutable storage for 2D and 3D at least. QOpenGLES3Helper *es3 = static_cast<QOpenGLExtensions *>(ctx->functions())->gles3Helper(); TexStorage3D = es3->TexStorage3D; TexStorage2D = es3->TexStorage2D; } else { TexStorage3D = 0; TexStorage2D = 0; } TexStorage1D = 0; // OpenGL 4.3 TexStorage3DMultisample = 0; TexStorage2DMultisample = 0; TexBufferRange = 0; TextureView = 0; #else // OpenGL 1.0 GetIntegerv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint *)>(context->getProcAddress(QByteArrayLiteral("glGetIntegerv"))); GetBooleanv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLboolean *)>(context->getProcAddress(QByteArrayLiteral("glGetBooleanv"))); PixelStorei = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint )>(context->getProcAddress(QByteArrayLiteral("glPixelStorei"))); GetTexLevelParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLint *)>(context->getProcAddress(QByteArrayLiteral("glGetTexLevelParameteriv"))); GetTexLevelParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLfloat *)>(context->getProcAddress(QByteArrayLiteral("glGetTexLevelParameterfv"))); GetTexParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(context->getProcAddress(QByteArrayLiteral("glGetTexParameteriv"))); GetTexParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat *)>(context->getProcAddress(QByteArrayLiteral("glGetTexParameterfv"))); GetTexImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLenum , GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glGetTexImage"))); TexImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTexImage2D"))); TexImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTexImage1D"))); TexParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLint *)>(context->getProcAddress(QByteArrayLiteral("glTexParameteriv"))); TexParameteri = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint )>(context->getProcAddress(QByteArrayLiteral("glTexParameteri"))); TexParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLfloat *)>(context->getProcAddress(QByteArrayLiteral("glTexParameterfv"))); TexParameterf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat )>(context->getProcAddress(QByteArrayLiteral("glTexParameterf"))); // OpenGL 1.1 GenTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress(QByteArrayLiteral("glGenTextures"))); DeleteTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *)>(context->getProcAddress(QByteArrayLiteral("glDeleteTextures"))); BindTexture = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress(QByteArrayLiteral("glBindTexture"))); TexSubImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTexSubImage2D"))); TexSubImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTexSubImage1D"))); #endif if (context->isOpenGLES() && context->hasExtension(QByteArrayLiteral("GL_OES_texture_3D"))) { TexImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid*)>(context->getProcAddress(QByteArrayLiteral("glTexImage3DOES"))); TexSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid*)>(context->getProcAddress(QByteArrayLiteral("glTexSubImage3DOES"))); CompressedTexImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid*)>(context->getProcAddress(QByteArrayLiteral("glCompressedTexImage3DOES"))); CompressedTexSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid*)>(context->getProcAddress(QByteArrayLiteral("glCompressedTexSubImage3DOES"))); } else { QOpenGLContext *ctx = QOpenGLContext::currentContext(); if (ctx->isOpenGLES() && ctx->format().majorVersion() >= 3) { // OpenGL ES 3.0+ has glTexImage3D. QOpenGLES3Helper *es3 = static_cast<QOpenGLExtensions *>(ctx->functions())->gles3Helper(); TexImage3D = es3->TexImage3D; TexSubImage3D = es3->TexSubImage3D; CompressedTexImage3D = es3->CompressedTexImage3D; CompressedTexSubImage3D = es3->CompressedTexSubImage3D; } else { // OpenGL 1.2 TexImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTexImage3D"))); TexSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTexSubImage3D"))); // OpenGL 1.3 CompressedTexImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLsizei , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTexImage3D"))); CompressedTexSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTexSubImage3D"))); } } #ifndef QT_OPENGL_ES_2 // OpenGL 1.3 GetCompressedTexImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glGetCompressedTexImage"))); CompressedTexSubImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTexSubImage1D"))); CompressedTexSubImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTexSubImage2D"))); CompressedTexImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTexImage1D"))); CompressedTexImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTexImage2D"))); ActiveTexture = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress(QByteArrayLiteral("glActiveTexture"))); // OpenGL 3.0 GenerateMipmap = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress(QByteArrayLiteral("glGenerateMipmap"))); // OpenGL 3.2 TexImage3DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLint , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress(QByteArrayLiteral("glTexImage3DMultisample"))); TexImage2DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLint , GLsizei , GLsizei , GLboolean )>(context->getProcAddress(QByteArrayLiteral("glTexImage2DMultisample"))); // OpenGL 4.2 TexStorage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLsizei )>(context->getProcAddress(QByteArrayLiteral("glTexStorage3D"))); TexStorage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei )>(context->getProcAddress(QByteArrayLiteral("glTexStorage2D"))); TexStorage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei )>(context->getProcAddress(QByteArrayLiteral("glTexStorage1D"))); // OpenGL 4.3 TexStorage3DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress(QByteArrayLiteral("glTexStorage3DMultisample"))); TexStorage2DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLboolean )>(context->getProcAddress(QByteArrayLiteral("glTexStorage2DMultisample"))); TexBufferRange = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint , GLintptr , GLsizeiptr )>(context->getProcAddress(QByteArrayLiteral("glTexBufferRange"))); TextureView = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint , GLenum , GLuint , GLuint , GLuint , GLuint )>(context->getProcAddress(QByteArrayLiteral("glTextureView"))); #endif }