//-------------------------------------------------------------- void ofApp::draw(){ ofClear(0,0); if (doDrawCamBackground.get()) drawSource(); if (!toggleGuiDraw) { ofHideCursor(); drawComposite(); } else { ofShowCursor(); switch(drawMode.get()) { case DRAW_COMPOSITE: drawComposite(); break; case DRAW_PARTICLES: drawParticles(); break; case DRAW_FLUID_FIELDS: drawFluidFields(); break; case DRAW_FLUID_DENSITY: drawFluidDensity(); break; case DRAW_FLUID_VELOCITY: drawFluidVelocity(); break; case DRAW_FLUID_PRESSURE: drawFluidPressure(); break; case DRAW_FLUID_TEMPERATURE: drawFluidTemperature(); break; case DRAW_FLUID_DIVERGENCE: drawFluidDivergence(); break; case DRAW_FLUID_VORTICITY: drawFluidVorticity(); break; case DRAW_FLUID_BUOYANCY: drawFluidBuoyance(); break; case DRAW_FLUID_OBSTACLE: drawFluidObstacle(); break; case DRAW_FLOW_MASK: drawMask(); break; case DRAW_OPTICAL_FLOW: drawOpticalFlow(); break; case DRAW_SOURCE: drawSource(); break; case DRAW_MOUSE: drawMouseForces(); break; case DRAW_VELDOTS: drawVelocityDots(); break; } drawGui(); } }
void PHISurfaceEffect::draw( QPainter *painter ) { /* QPoint offset; QPixmap pixmap; if ( sourceIsPixmap() ) { // No point in drawing in device coordinates (pixmap will be scaled anyways). pixmap=sourcePixmap( Qt::LogicalCoordinates, &offset ); } else { // Draw pixmap in device coordinates to avoid pixmap scaling; pixmap=sourcePixmap( Qt::DeviceCoordinates, &offset ); painter->setWorldTransform( QTransform() ); } QImage img=pixmap.toImage(); img=PHI::getSurfacedImage( img, _yOff, _size ); painter->drawImage( offset, img ); */ QRectF brect=sourceBoundingRect( Qt::LogicalCoordinates ); QImage img( static_cast<int>(brect.width()+1), static_cast<int>(brect.height()+_size+_yOff), QImage::Format_ARGB32_Premultiplied ); QPainter pixPainter; pixPainter.begin( &img ); pixPainter.setRenderHints( painter->renderHints() ); pixPainter.setCompositionMode( QPainter::CompositionMode_Clear ); pixPainter.fillRect( 0., 0., brect.width()+1., brect.height()+_size+_yOff+1, Qt::transparent ); pixPainter.setCompositionMode( QPainter::CompositionMode_SourceOver ); drawSource( &pixPainter ); QTransform t; t.rotate( 180., Qt::XAxis ); t.translate( 0., (-brect.height()*2.)-_yOff+1. ); pixPainter.setTransform( t ); drawSource( &pixPainter ); pixPainter.resetTransform(); pixPainter.translate( 0., brect.height()+_yOff ); QLinearGradient gradient( 0., 0., 0., 1.0 ); gradient.setColorAt( 0., QColor( 0, 0, 0, 220 ) ); gradient.setColorAt( 0.78, QColor( 0, 0, 0, 30 ) ); gradient.setColorAt( 1., Qt::transparent ); gradient.setCoordinateMode( QGradient::ObjectBoundingMode ); pixPainter.setCompositionMode( QPainter::CompositionMode_DestinationIn ); pixPainter.fillRect( 0., 0., brect.width()+1, _size, gradient ); pixPainter.end(); painter->drawImage( 0, 0, img ); }
void ShadowEffect::draw(QPainter *painter) { if (m_blurRadius < 0 && qFuzzyIsNull(m_xOffset) && qFuzzyIsNull(m_yOffset)) { drawSource(painter); return; } PixmapPadMode mode = PadToEffectiveBoundingRect; if (painter->paintEngine()->type() == QPaintEngine::OpenGL2) { mode = NoPad; } // Draw pixmap in device coordinates to avoid pixmap scaling. QPoint offset; const QPixmap pixmap = sourcePixmap(Qt::DeviceCoordinates, &offset, mode); if (pixmap.isNull()) { return; } QTransform restoreTransform = painter->worldTransform(); painter->setWorldTransform(QTransform()); if (m_shadow.isNull()) { m_shadow = generateShadow(pixmap); } // Draw shadow (draw it twice to darken it) painter->drawImage(offset, m_shadow); painter->drawImage(offset, m_shadow); // Draw the actual pixmap painter->drawPixmap(offset, pixmap); painter->setWorldTransform(restoreTransform); }
/*! \reimp */ void QGraphicsColorizeEffect::draw(QPainter *painter) { Q_D(QGraphicsColorizeEffect); if (!d->opaque) { drawSource(painter); return; } QPoint offset; if (sourceIsPixmap()) { // No point in drawing in device coordinates (pixmap will be scaled anyways). const QPixmap pixmap = sourcePixmap(Qt::LogicalCoordinates, &offset, NoPad); if (!pixmap.isNull()) d->filter->draw(painter, offset, pixmap); return; } // Draw pixmap in deviceCoordinates to avoid pixmap scaling. const QPixmap pixmap = sourcePixmap(Qt::DeviceCoordinates, &offset); if (pixmap.isNull()) return; QTransform restoreTransform = painter->worldTransform(); painter->setWorldTransform(QTransform()); d->filter->draw(painter, offset, pixmap); painter->setWorldTransform(restoreTransform); }
void ListItemCache::draw(QPainter * painter) { QRectF irect = sourceBoundingRect(Qt::LogicalCoordinates); QRectF vrect = painter->clipPath().boundingRect(); if (vrect.intersects(irect)) { QRectF newVisibleRect = irect.intersected(vrect); QPixmap pixmap; if (!QPixmapCache::find(m_cacheKey, &pixmap) || m_visibleRect.toRect() != newVisibleRect.toRect()) { //qDebug() << "ListItemCache: caching" << m_visibleRect // << "->" << newVisibleRect; pixmap = QPixmap(sourceBoundingRect().toRect().size()); pixmap.fill(Qt::transparent); QPainter pixmapPainter(&pixmap); drawSource(&pixmapPainter); pixmapPainter.end(); m_cacheKey = QPixmapCache::insert(pixmap); m_visibleRect = newVisibleRect; } //qDebug() << "ListItemCache: blitting" << m_visibleRect; painter->drawPixmap(0, 0, pixmap); } }
void NightModeGraphicsEffect::draw(QPainter* painter) { int pixelRatio = painter->device()->devicePixelRatio(); QSize size(painter->device()->width() * pixelRatio, painter->device()->height() * pixelRatio); if (fbo && fbo->size() != size) { delete fbo; fbo = NULL; } if (!fbo) { QGLFramebufferObjectFormat format; format.setAttachment(QGLFramebufferObject::CombinedDepthStencil); format.setInternalTextureFormat(GL_RGBA); fbo = new NightModeGraphicsEffectFbo(size, format, pixelRatio); } QPainter fboPainter(fbo); drawSource(&fboPainter); painter->save(); painter->beginNativePainting(); program->bind(); const GLfloat pos[] = {-1, -1, +1, -1, -1, +1, +1, +1}; const GLfloat texCoord[] = {0, 0, 1, 0, 0, 1, 1, 1}; program->setUniformValue(vars.source, 0); program->setAttributeArray(vars.pos, pos, 2); program->setAttributeArray(vars.texCoord, texCoord, 2); program->enableAttributeArray(vars.pos); program->enableAttributeArray(vars.texCoord); glBindTexture(GL_TEXTURE_2D, fbo->texture()); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); program->release(); painter->endNativePainting(); painter->restore(); }
//-------------------------------------------------------------- void ofApp::draw(){ ofPushMatrix(); ofSetColor(255); if( !tracks.isLoaded() ){ vector< ofPtr<Track> > trackList = tracks.getTrackList(); string trackListStr = ""; for( int i=0;i<trackList.size();i++ ){ trackListStr += ofToString(i+1) + " : " + trackList[i]->getTrackName() + "\n"; } Fonts::one().fontRobotoRegular30.drawString( trackListStr, 20, 30 ); } int y = 100; drawSource(0,ofGetHeight()-300, ofGetWidth(), 104 ); // drawResult(100,y, frameWidth,frameHeight ); // y += frameHeight + 20; // drawFFT(100,y,frameWidth,frameHeight); // y += frameHeight + 20; // drawOctaves(100,y, frameWidth,frameHeight ); // y += frameHeight + 20; // drawSpectrum(100,y, frameWidth,frameHeight ); tracks.draw(); ofPopMatrix(); }
void QgsComposerEffect::draw( QPainter *painter ) { QPoint offset; QPixmap pixmap; // Set desired composition mode then draw source painter->setCompositionMode( mCompositionMode ); if ( mCompositionMode == QPainter::CompositionMode_SourceOver ) { // Normal (sourceover) blending, do faster drawSource operation drawSource( painter ); return; } // Otherwise, draw using pixmap so QPrinter output works as expected if ( sourceIsPixmap() ) { // No point in drawing in device coordinates (pixmap will be scaled anyways). pixmap = sourcePixmap( Qt::LogicalCoordinates, &offset ); } else { // Draw pixmap in device coordinates to avoid pixmap scaling; pixmap = sourcePixmap( Qt::DeviceCoordinates, &offset ); painter->setWorldTransform( QTransform() ); } painter->drawPixmap( offset, pixmap ); }
//! [0] MyGraphicsOpacityEffect::draw(QPainter *painter) { // Fully opaque; draw directly without going through a pixmap. if (qFuzzyCompare(m_opacity, 1)) { drawSource(painter); return; } ... }
void GraphicsCompositionModeEffect::draw(QPainter* painter) { painter->save(); painter->setCompositionMode(m_compositionMode); drawSource(painter); painter->restore(); }
void Shadow::draw(QPainter* painter) { // if nothing to show outside the item, just draw source if ((blurRadius() + distance()) <= 0) { drawSource(painter); return; } PixmapPadMode mode = QGraphicsEffect::PadToEffectiveBoundingRect; QPoint offset; const QPixmap px = sourcePixmap(Qt::DeviceCoordinates, &offset, mode); // return if no source if (px.isNull()) return; // save world transform QTransform restoreTransform = painter->worldTransform(); painter->setWorldTransform(QTransform()); // Calculate size for the background image QSize szi(px.size().width() + 2 * distance(), px.size().height() + 2 * distance()); QImage tmp(szi, QImage::Format_ARGB32_Premultiplied); QPixmap scaled = px.scaled(szi); tmp.fill(0); QPainter tmpPainter(&tmp); tmpPainter.setCompositionMode(QPainter::CompositionMode_Source); tmpPainter.drawPixmap(QPointF(-distance(), -distance()), scaled); tmpPainter.end(); // blur the alpha channel QImage blurred(tmp.size(), QImage::Format_ARGB32_Premultiplied); blurred.fill(0); QPainter blurPainter(&blurred); qt_blurImage(&blurPainter, tmp, blurRadius(), false, true); blurPainter.end(); tmp = blurred; // blacken the image... tmpPainter.begin(&tmp); tmpPainter.setCompositionMode(QPainter::CompositionMode_SourceIn); tmpPainter.fillRect(tmp.rect(), color()); tmpPainter.end(); // draw the blurred shadow... painter->drawImage(offset, tmp); // draw the actual pixmap... painter->drawPixmap(offset, px, QRectF()); // restore world transform painter->setWorldTransform(restoreTransform); }
void draw(QPainter *painter) { ++numRepaints; if (doNothingInDraw) return; m_source = source(); m_painter = painter; m_styleOption = source()->styleOption(); m_opacity = painter->opacity(); drawSource(painter); }
void CardDropShadowEffect::draw(QPainter *painter) { Q_ASSERT(s_shadowPixmap != 0); #if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0)) qDrawPixmaps(painter, m_drawingData.constData(), m_drawingData.size(), *s_shadowPixmap); #else // QT5_TODO #endif // paint the item, of course drawSource(painter); }
void ShaderEffect::draw (QPainter *painter) { const QGLContext *context = QGLContext::currentContext(); prepareBufferedDraw(painter); if (context) { updateRenderTargets(); } if (!context || m_renderTargets.count() == 0 || !hideOriginal()) drawSource(painter); }
void QgsTransformEffect::draw( QgsRenderContext &context ) { if ( !source() || !enabled() || !context.painter() ) return; QPainter* painter = context.painter(); //apply transformations painter->save(); QTransform t = createTransform( context ); painter->setTransform( t, true ); drawSource( *painter ); painter->restore(); }
/*! \reimp */ void QGraphicsBlurEffect::draw(QPainter *painter) { Q_D(QGraphicsBlurEffect); if (d->filter->radius() < 1) { drawSource(painter); return; } PixmapPadMode mode = PadToEffectiveBoundingRect; QPoint offset; QPixmap pixmap = sourcePixmap(Qt::LogicalCoordinates, &offset, mode); if (pixmap.isNull()) return; d->filter->draw(painter, offset, pixmap); }
//-------------------------------------------------------------- void FluidManager::draw(int _mode){ switch(_mode) { case DRAW_COMPOSITE: drawComposite(); break; case DRAW_PARTICLES: drawParticles(); break; case DRAW_FLUID_FIELDS: drawFluidFields(); break; case DRAW_FLUID_DENSITY: drawFluidDensity(); break; // case DRAW_FLUID_TEMPERATURE: drawFluidTemperature(); break; // case DRAW_FLUID_DIVERGENCE: drawFluidDivergence(); break; // case DRAW_FLUID_VORTICITY: drawFluidVorticity(); break; // case DRAW_FLUID_BUOYANCY: drawFluidBuoyance(); break; case DRAW_FLUID_OBSTACLE: drawFluidObstacle(); break; // case DRAW_OPTICAL_FLOW: drawOpticalFlow(); break; case DRAW_SOURCE: drawSource(); break; } }
QT_END_NAMESPACE void ShadowEffect::draw(QPainter* painter){ if((blurRadius() + distance()) <= 0){ drawSource(painter); return; } PixmapPadMode mode = QGraphicsEffect::PadToEffectiveBoundingRect; QPoint offset; const QPixmap px = sourcePixmap(Qt::DeviceCoordinates, &offset, mode); if(px.isNull()) return; QTransform restoreTransform = painter->worldTransform(); painter->setWorldTransform(QTransform()); QSize szi(px.size().width() + 2 * distance(), px.size().height() + 2 * distance()); QImage tmp(szi, QImage::Format_ARGB32_Premultiplied); QPixmap scaled = px.scaled(szi); tmp.fill(0); QPainter tmpPainter(&tmp); tmpPainter.setCompositionMode(QPainter::CompositionMode_Source); tmpPainter.drawPixmap(QPointF(-distance(), -distance()), scaled); tmpPainter.end(); QImage blurred(tmp.size(), QImage::Format_ARGB32_Premultiplied); blurred.fill(0); QPainter blurPainter(&blurred); qt_blurImage(&blurPainter, tmp, blurRadius(), false, true); blurPainter.end(); tmp = blurred; tmpPainter.begin(&tmp); tmpPainter.setCompositionMode(QPainter::CompositionMode_SourceIn); tmpPainter.fillRect(tmp.rect(), color()); tmpPainter.end(); painter->drawImage(offset, tmp); painter->drawPixmap(offset, px, QRectF()); painter->setWorldTransform(restoreTransform); }
/*! \reimp */ void QGraphicsOpacityEffect::draw(QPainter *painter) { Q_D(QGraphicsOpacityEffect); // Transparent; nothing to draw. if (d->isFullyTransparent) return; // Opaque; draw directly without going through a pixmap. if (d->isFullyOpaque && !d->hasOpacityMask) { drawSource(painter); return; } QPoint offset; Qt::CoordinateSystem system = sourceIsPixmap() ? Qt::LogicalCoordinates : Qt::DeviceCoordinates; QPixmap pixmap = sourcePixmap(system, &offset, QGraphicsEffect::NoPad); if (pixmap.isNull()) return; painter->save(); painter->setOpacity(d->opacity); if (d->hasOpacityMask) { QPainter pixmapPainter(&pixmap); pixmapPainter.setRenderHints(painter->renderHints()); pixmapPainter.setCompositionMode(QPainter::CompositionMode_DestinationIn); if (system == Qt::DeviceCoordinates) { QTransform worldTransform = painter->worldTransform(); worldTransform *= QTransform::fromTranslate(-offset.x(), -offset.y()); pixmapPainter.setWorldTransform(worldTransform); pixmapPainter.fillRect(sourceBoundingRect(), d->opacityMask); } else { pixmapPainter.translate(-offset); pixmapPainter.fillRect(pixmap.rect(), d->opacityMask); } } if (system == Qt::DeviceCoordinates) painter->setWorldTransform(QTransform()); painter->drawPixmap(offset, pixmap); painter->restore(); }
void QGraphicsGlowEffect::draw(QPainter* painter) { QPoint offset; QPixmap source = sourcePixmap(Qt::LogicalCoordinates, &offset); source = source.scaled(source.size().width()/source.devicePixelRatio(), source.size().height()/source.devicePixelRatio()); QPixmap glow; QGraphicsColorizeEffect *colorize = new QGraphicsColorizeEffect; colorize->setColor(_color); colorize->setStrength(1); glow = applyEffectToPixmap(source, colorize, 0); QGraphicsBlurEffect *blur = new QGraphicsBlurEffect; blur->setBlurRadius(_blurRadius); glow = applyEffectToPixmap(glow, blur, _extent); for (int i = 0; i < _strength; i++) painter->drawPixmap(offset - QPoint(_extent, _extent), glow); drawSource(painter); }
/*! \reimp */ void QGraphicsDropShadowEffect::draw(QPainter *painter) { Q_D(QGraphicsDropShadowEffect); if (d->filter->blurRadius() <= 0 && d->filter->offset().isNull()) { drawSource(painter); return; } PixmapPadMode mode = PadToEffectiveBoundingRect; // Draw pixmap in device coordinates to avoid pixmap scaling. QPoint offset; const QPixmap pixmap = sourcePixmap(Qt::DeviceCoordinates, &offset, mode); if (pixmap.isNull()) return; QTransform restoreTransform = painter->worldTransform(); painter->setWorldTransform(QTransform()); d->filter->draw(painter, offset, pixmap); painter->setWorldTransform(restoreTransform); }
void QuickMaskEffect::draw(QPainter *painter) { if (!m_mask) { drawSource(painter); return; } QPoint offset; const QPixmap pixmap = sourcePixmap(Qt::LogicalCoordinates, &offset, QGraphicsEffect::NoPad); if (pixmap.size() != m_buffer.size()) m_buffer = pixmap; QPainter p(&m_buffer); p.setCompositionMode(QPainter::CompositionMode_Source); p.fillRect(0, 0, m_buffer.width(), m_buffer.height(), Qt::transparent); m_mask->paint(&p, 0, 0); p.setCompositionMode(QPainter::CompositionMode_SourceOut); p.drawPixmap(0, 0, pixmap); painter->drawPixmap(offset, m_buffer); }
void QgsDrawSourceEffect::draw( QgsRenderContext &context ) { if ( !enabled() || !context.painter() ) return; QPainter *painter = context.painter(); if ( mBlendMode == QPainter::CompositionMode_SourceOver && qgsDoubleNear( mTransparency, 0.0 ) ) { //just draw unmodified source drawSource( *painter ); } else { //rasterize source and apply modifications QImage image = sourceAsImage( context )->copy(); QgsImageOperation::multiplyOpacity( image, 1.0 - mTransparency ); painter->save(); painter->setCompositionMode( mBlendMode ); painter->drawImage( imageOffset( context ), image ); painter->restore(); } }
void ShaderEffect::updateRenderTargets() { if (!m_changed) return; m_changed = false; int count = m_renderTargets.count(); for (int i = 0; i < count; i++) { if (m_renderTargets[i]->isLive() || m_renderTargets[i]->isDirtyTexture()) { m_renderTargets[i]->updateBackbuffer(); ShaderEffectBuffer* target = m_renderTargets[i]->fbo(); if (target && target->isValid() && target->width() > 0 && target->height() > 0) { QPainter p(target); p.setCompositionMode(QPainter::CompositionMode_Clear); p.fillRect(QRect(QPoint(0, 0), target->size()), Qt::transparent); p.setCompositionMode(QPainter::CompositionMode_SourceOver); QRectF sourceRect = m_renderTargets[i]->sourceRect(); QSize textureSize = m_renderTargets[i]->textureSize(); qreal yflip = m_renderTargets[i]->isMirrored() ? -1.0 : 1.0; // flip y to match scenegraph, it also flips texturecoordinates qreal xscale = 1.0; qreal yscale = 1.0 * yflip; qreal leftMargin = 0.0; qreal rightMargin = 0.0; qreal topMargin = 0.0; qreal bottomMargin = 0.0; qreal width = m_renderTargets[i]->sourceItem()->width(); qreal height = m_renderTargets[i]->sourceItem()->height(); if (!sourceRect.isEmpty()) { leftMargin = -sourceRect.left(); rightMargin = sourceRect.right() - width; topMargin = -sourceRect.top(); bottomMargin = sourceRect.bottom() - height; } if ((width + leftMargin + rightMargin) > 0 && (height + topMargin + bottomMargin) > 0) { if (!textureSize.isEmpty()) { qreal textureWidth = textureSize.width(); qreal textureHeight = textureSize.height(); xscale = width / (width + leftMargin + rightMargin); yscale = height / (height + topMargin + bottomMargin); p.translate(textureWidth / 2, textureHeight / 2); p.scale(xscale, yscale * yflip); p.translate(-textureWidth / 2, -textureHeight / 2); p.scale(textureWidth / width, textureHeight / height); } else { xscale = width / (width + leftMargin + rightMargin); yscale = height / (height + topMargin + bottomMargin); p.translate(width / 2, height / 2); p.scale(xscale, yscale * yflip); p.translate(-width / 2, -height / 2); } } drawSource(&p); p.end(); m_renderTargets[i]->markSceneGraphDirty(); } } } }
void draw(QPainter *painter) { drawSource(painter); }
void CompositionRenderer::paint(QPainter *painter) { #if defined(QT_OPENGL_SUPPORT) && !defined(QT_OPENGL_ES) if (usesOpenGL()) { int new_pbuf_size = m_pbuffer_size; if (size().width() > m_pbuffer_size || size().height() > m_pbuffer_size) new_pbuf_size *= 2; if (size().width() < m_pbuffer_size/2 && size().height() < m_pbuffer_size/2) new_pbuf_size /= 2; if (!m_pbuffer || new_pbuf_size != m_pbuffer_size) { if (m_pbuffer) { m_pbuffer->deleteTexture(m_base_tex); m_pbuffer->deleteTexture(m_compositing_tex); delete m_pbuffer; } m_pbuffer = new QGLPixelBuffer(QSize(new_pbuf_size, new_pbuf_size), QGLFormat::defaultFormat(), glWidget()); m_pbuffer->makeCurrent(); m_base_tex = m_pbuffer->generateDynamicTexture(); m_compositing_tex = m_pbuffer->generateDynamicTexture(); m_pbuffer_size = new_pbuf_size; } if (size() != m_previous_size) { m_previous_size = size(); QPainter p(m_pbuffer); p.setCompositionMode(QPainter::CompositionMode_Source); p.fillRect(QRect(0, 0, m_pbuffer->width(), m_pbuffer->height()), Qt::transparent); drawBase(p); p.end(); m_pbuffer->updateDynamicTexture(m_base_tex); } qreal x_fraction = width()/float(m_pbuffer->width()); qreal y_fraction = height()/float(m_pbuffer->height()); { QPainter p(m_pbuffer); p.setCompositionMode(QPainter::CompositionMode_Source); p.fillRect(QRect(0, 0, m_pbuffer->width(), m_pbuffer->height()), Qt::transparent); p.save(); // Needed when using the GL1 engine p.beginNativePainting(); // Needed when using the GL2 engine glBindTexture(GL_TEXTURE_2D, m_base_tex); glEnable(GL_TEXTURE_2D); glColor4f(1.,1.,1.,1.); glBegin(GL_QUADS); { glTexCoord2f(0, 1.0); glVertex2f(0, 0); glTexCoord2f(x_fraction, 1.0); glVertex2f(width(), 0); glTexCoord2f(x_fraction, 1.0-y_fraction); glVertex2f(width(), height()); glTexCoord2f(0, 1.0-y_fraction); glVertex2f(0, height()); } glEnd(); glDisable(GL_TEXTURE_2D); p.endNativePainting(); // Needed when using the GL2 engine p.restore(); // Needed when using the GL1 engine drawSource(p); p.end(); m_pbuffer->updateDynamicTexture(m_compositing_tex); } painter->beginNativePainting(); // Needed when using the GL2 engine glWidget()->makeCurrent(); // Needed when using the GL1 engine glBindTexture(GL_TEXTURE_2D, m_compositing_tex); glEnable(GL_TEXTURE_2D); glEnable(GL_BLEND); glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glColor4f(1.,1.,1.,1.); glBegin(GL_QUADS); { glTexCoord2f(0, 1.0); glVertex2f(0, 0); glTexCoord2f(x_fraction, 1.0); glVertex2f(width(), 0); glTexCoord2f(x_fraction, 1.0-y_fraction); glVertex2f(width(), height()); glTexCoord2f(0, 1.0-y_fraction); glVertex2f(0, height()); } glEnd(); glDisable(GL_TEXTURE_2D); painter->endNativePainting(); // Needed when using the GL2 engine } else #endif { // using a QImage if (m_buffer.size() != size()) { m_buffer = QImage(size(), QImage::Format_ARGB32_Premultiplied); m_base_buffer = QImage(size(), QImage::Format_ARGB32_Premultiplied); m_base_buffer.fill(0); QPainter p(&m_base_buffer); drawBase(p); } memcpy(m_buffer.bits(), m_base_buffer.bits(), m_buffer.byteCount()); { QPainter p(&m_buffer); drawSource(p); } painter->drawImage(0, 0, m_buffer); } }