Getting the Image element's textureProvider at the time of
QQuickFrameBufferObject::synchronize should give you a QSGTextureProvider for
that image, assuming that the Image.status == Ready. This is the same mechanism
that ShaderEffect uses internally as well. You are not supposed to use the item
on the render thread. That is unsafe and will lead to crashes. The texture
provider is the right thing.
cheers,
Gunnar
________________________________
Fra: interest-bounces+gunnar.sletta=digia....@qt-project.org
[interest-bounces+gunnar.sletta=digia....@qt-project.org] på vegne av Ola Røer
Thorsen [o...@silentwings.no]
Sendt: 12. desember 2013 15:34
To: interest@qt-project.org
Emne: [Interest] QOpenGLFramebufferObject, render to FBO using texture from
another Image item?
I recently discovered the new way of doing render-to-FBO in Qt 5.2.0. It's a
major improvement compared with what had to be done previously, I think! :-)
However I have run into something tricky as I want to do something more
advanced:
I need to render some textured geometry into an FBO. The use-case is something
similar to correcting for lens artifacts in a photograph, and the geometry is
too advanced for using the Shadereffect items (can't use a regular mesh grid).
The texture is loaded from a .jpg file on disk. The image is rather large, so I
want to use similar mechanisms as used by the Quick2 Image item (cache,
asynchronous loading, etc).
It's not a good idea to use the internals from qquickimage, so I thought of
doing something similar to what the Shadereffectsource item does, by using the
texture created by an Image item. This way, I can re-use all the advanced
things the Image item does internally for loading an image.
I have now got a class inheriting QQuickFramebufferObject. It has a sourceItem
property, which holds a QQuickItem*. In my QML code, i set this to be a Image
item.
Image {
id: rawImage
source: "picture.jpg"
visible: false
asynchronous: true
onStatusChanged: {
(status === Image.Ready) {
fboRender.updateTexture(); // this calls "update();" on the item in c++
}
}
}
MyFboRenderer {
id: fboRender
sourceItem: rawImage
}
In c++, I now need to safely pass the texture eventually found in the
sourceItem to my QQuickFramebufferObject::Renderer. This has to be thread-safe
in every way. As the Image and FBO render items in QML are to be used in model
view delegates, they are created and deleted runtime.
Any hints on how to accomplish this would be very welcome!
Things I've found so far are:
- calling "sourceItem()->textureProvider()->texture()" from the renderer's
"synchronize" function returns "0" even if synchronize was triggered as result
of an update called when the image has completed loading.
- calling the same from the render-function gives a texture valid texture, and
this sortof works, but there is no obvious safe way of accessing "sourceItem"
at this point. I've tried to store a pointer to either the source item or the
QQuickFramebufferObject, but both of these might be deleted/invalid when
render() is called and crashes do happen.
Cheers
Ola
_______________________________________________
Interest mailing list
Interest@qt-project.org
http://lists.qt-project.org/mailman/listinfo/interest
