QSGNode *FilteredImage::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
{
QSGSimpleTextureNode *node = static_cast<QSGSimpleTextureNode*>(oldNode);
QImage *image = !m_filteredImage.isNull() ? &m_filteredImage : &m_image;
if(image->isNull())
{
delete node;
return 0;
}
if (!node)
{
node = new QSGSimpleTextureNode();
}
if (m_imageChanged || !node->texture())
{
m_imageChanged = false;
delete node->texture();
node->setTexture(window()->createTextureFromImage(*image));
node->setRect(0,0,implicitWidth(),implicitHeight());
node->markDirty(QSGNode::DirtyMaterial | QSGNode::DirtyGeometry);
}
return node;
}
QSGNode *CustomItem::updatePaintNode(QSGNode *node, QQuickItem::UpdatePaintNodeData *updateData)
{
Q_UNUSED(updateData);
QSGSimpleTextureNode *textureNode = static_cast<QSGSimpleTextureNode *>(node);
if (!textureNode) {
textureNode = new QSGSimpleTextureNode();
QImage image(":/images/lady.png");
m_texture = window()->createTextureFromImage(image);
textureNode->setTexture(m_texture);}
textureNode->setRect(0, 0, width(), height());
textureNode->setFiltering(QSGTexture::Linear);
return textureNode;
}
QSGNode *ServerBufferItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
{
updateTexture();
QSGSimpleTextureNode *node = static_cast<QSGSimpleTextureNode *>(oldNode);
if (!node) {
node = new QSGSimpleTextureNode();
}
node->setTexture(m_provider->texture());
if (isYInverted()) {
node->setRect(0, height(), width(), -height());
} else {
node->setRect(0, 0, width(), height());
}
return node;
}
QSGNode* Texture::updateNode(QSGNode* node, QQuickItem* item, QPoint region)
{
QSGSimpleTextureNode* n;
// First update
if (!node) {
n = new QSGSimpleTextureNode;
n->setRect(item->boundingRect());
} else {
n = static_cast<QSGSimpleTextureNode*>(node);
}
// Update the texture
n->setTexture(
// Ask the cache for the texture
m_cacheIterator.value().get(item->window(),
// Add the offset to the x axis
{region.x() + 3*static_cast<int>(offset()), region.y()}) );
return n;
}
QSGNode *EmulatorItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *updatePaintNodeData)
{
QSGSimpleTextureNode *n = static_cast<QSGSimpleTextureNode *>(oldNode);
if (!n) {
m_gl = window()->openglContext()->functions();
connect(window(), SIGNAL(frameFinished()), this, SLOT(onFrameFinished()));
n = new QSGSimpleTextureNode();
QImage img(GFX_WIDTH, GFX_HEIGHT, QImage::Format_RGBA8888);
m_screen = new GLuint[GFX_WIDTH * GFX_HEIGHT];
img.fill(Qt::green);
m_texture = window()->createTextureFromImage(img);
m_texture->setFiltering(QSGTexture::Linear);
n->setTexture(m_texture);
n->setRect(boundingRect());
}
m_texture->bind();
m_gl->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, GFX_WIDTH - 16, GFX_HEIGHT - 32, 0, GL_RGB, GL_UNSIGNED_BYTE, m_screen);
return n;
}
static PyObject *meth_QSGSimpleTextureNode_setTexture(PyObject *sipSelf, PyObject *sipArgs)
{
PyObject *sipParseErr = NULL;
{
QSGTexture* a0;
QSGSimpleTextureNode *sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "BJ8", &sipSelf, sipType_QSGSimpleTextureNode, &sipCpp, sipType_QSGTexture, &a0))
{
sipCpp->setTexture(a0);
Py_INCREF(Py_None);
return Py_None;
}
}
/* Raise an exception if the arguments couldn't be parsed. */
sipNoMethod(sipParseErr, sipName_QSGSimpleTextureNode, sipName_setTexture, doc_QSGSimpleTextureNode_setTexture);
return NULL;
}
QSGNode *VideoDisplay::updatePaintNode(QSGNode *oldNode,
QQuickItem::UpdatePaintNodeData *updatePaintNodeData)
{
Q_UNUSED(updatePaintNodeData)
this->m_mutex.lock();
this->m_videoFrame = this->m_packet;
this->m_mutex.unlock();
if (this->m_videoFrame.textureSize().isEmpty()) {
if (oldNode)
delete oldNode;
return NULL;
}
QSGSimpleTextureNode *node = NULL;
if (oldNode)
node = dynamic_cast<QSGSimpleTextureNode *>(oldNode);
else
node = new QSGSimpleTextureNode();
if (this->m_fillDisplay)
node->setRect(this->boundingRect());
else {
QSizeF size(this->m_videoFrame.textureSize());
size.scale(this->boundingRect().size(), Qt::KeepAspectRatio);
QRectF rect(QPointF(), size);
rect.moveCenter(this->boundingRect().center());
node->setRect(rect);
}
node->setTexture(&this->m_videoFrame);
return node;
}
QSGNode *Renderer::paintNode(const QRectF& viewport) const {
if (m_tiles.isEmpty()) {
return 0;
}
QSGNode *parentNode = new QSGNode;
for (const Tile& tile : m_tiles) {
if (tile.visible) {
QRectF rect = m_view->tileRect(tile);
QSGSimpleTextureNode *node = new SimpleTextureNode;
node->setFlag(QSGNode::OwnedByParent, true);
node->setTexture(m_view->window()->createTextureFromImage(tile.image));
node->setRect(rect);
node->setFiltering(QSGTexture::Nearest);
// node->setOwnsTexture(true); // TODO: Qt 5.4
qreal dx1 = rect.left() < viewport.left() ? viewport.left() - rect.left() : 0.0f;
qreal dy1 = 0.0f;
qreal dx2 = rect.right() > viewport.right() ? viewport.right() - rect.right() : 0.0f;
qreal dy2 = rect.bottom() > viewport.bottom() ? viewport.bottom() - rect.bottom() : 0.0f;
if (dx1 != 0.0f || dx2 != 0.0f || dy2 != 0.0f) {
QSGClipNode *clip = new QSGClipNode;
clip->setIsRectangular(true);
clip->setClipRect(rect.adjusted(dx1, dy1, dx2, dy2));
parentNode->appendChildNode(clip);
clip->appendChildNode(node);
// qDebug() << "Clipping";
} else {
parentNode->appendChildNode(node);
}
}
}
return parentNode;
}
QSGNode* QuickSubtitleItem::updatePaintNode(QSGNode *node, UpdatePaintNodeData *data)
{
Q_UNUSED(data);
if (m_w_sub == 0 || m_h_sub == 0) {
return node;
}
QSGSimpleTextureNode *stn = static_cast<QSGSimpleTextureNode*>(node);
if (!node) {
node = new QSGSimpleTextureNode();
stn = static_cast<QSGSimpleTextureNode*>(node);
stn->setFiltering(QSGTexture::Linear);
}
stn->setRect(mapSubRect(m_rect, m_w_sub, m_h_sub));
if (m_texture)
delete m_texture;
{
QMutexLocker lock(&m_mutex);
Q_UNUSED(lock);
m_texture = window()->createTextureFromImage(m_image);
}
stn->setTexture(m_texture);
node->markDirty(QSGNode::DirtyGeometry);
return node;
}
QSGNode* HsQMLCanvas::updatePaintNode(
QSGNode* oldNode, UpdatePaintNodeData* paintData)
{
// Window always needs repainting
mWindow->update();
// Lazily create new callbacks
if (!mGLCallbacks) {
mGLCallbacks = mDelegate.value<HsQMLGLDelegate>().makeCallbacks();
mLoadModel = true;
mValidModel = false;
// Display nothing without a valid delegate
if (!mGLCallbacks) {
setStatus(BadDelegate);
delete oldNode;
return NULL;
}
}
// Process model update
if (mLoadModel) {
mValidModel = mGLCallbacks->mSyncCb(
reinterpret_cast<HsQMLJValHandle*>(&mModel));
mLoadModel = false;
}
// Display nothing if there's no valid model
if (!mValidModel) {
setStatus(BadModel);
detachBackEnd();
delete oldNode;
return NULL;
}
// Create back-end on the rendering thread
if (!mBackEnd) {
mBackEnd = new HsQMLCanvasBackEnd(mWindow, mGLCallbacks, mDisplayMode);
// Monitor back-end's status
QObject::connect(
mBackEnd, SIGNAL(statusChanged(HsQMLCanvas::Status)),
this, SLOT(doBackEndStatusChanged(HsQMLCanvas::Status)));
setStatus(mBackEnd->status(), true);
}
setStatus(Okay);
// Save pointer to transform node
mBackEnd->setTransformNode(
Inline != mDisplayMode ? paintData->transformNode : NULL,
width(), height());
// Produce texture node if needed
if (QSGTexture* texture =
mBackEnd->updateFBO(mCanvasWidth, mCanvasHeight)) {
QSGSimpleTextureNode* n = static_cast<QSGSimpleTextureNode*>(oldNode);
if (!n) {
n = new QSGSimpleTextureNode();
}
n->setTexture(texture);
n->setRect(0, 0, width(), height());
return n;
}
delete oldNode;
return NULL;
}