IdentifiantMot de passe
Mot de passe oublié ?Je m'inscris ! (gratuit)

ShaderEffectSource QML Type

Renders a Qt Quick item into a texture and displays it.

This type was introduced in Qt 5.0.

Article lu   fois.

L'auteur

L'article

Publié le - Mis à jour le 26 janvier 2024 

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

ShaderEffectSource QML Type▲

  • Import Statement: import QtQuick

  • Since:: Qt 5.0

  • Inherits:: Item

  • Group: ShaderEffectSource is part of qtquick-effects

Detailed Description▲

The ShaderEffectSource type renders sourceItem into a texture and displays it in the scene. sourceItem is drawn into the texture as though it was a fully opaque root item. Thus sourceItem itself can be invisible, but still appear in the texture.

ShaderEffectSource can be used as:

  • a texture source in a ShaderEffect. This allows you to apply custom shader effects to any Qt Quick item.

  • a cache for a complex item. The complex item can be rendered once into the texture, which can then be animated freely without the need to render the complex item again every frame.

  • an opacity layer. ShaderEffectSource allows you to apply an opacity to items as a group rather than each item individually.

Image non disponible
 
Sélectionnez
import QtQuick 2.0

Rectangle {
    width: 200
    height: 100
    gradient: Gradient {
        GradientStop { position: 0; color: "white" }
        GradientStop { position: 1; color: "black" }
    }
    Row {
        opacity: 0.5
        Item {
            id: foo
            width: 100; height: 100
            Rectangle { x: 5; y: 5; width: 60; height: 60; color: "red" }
            Rectangle { x: 20; y: 20; width: 60; height: 60; color: "orange" }
            Rectangle { x: 35; y: 35; width: 60; height: 60; color: "yellow" }
        }
        ShaderEffectSource {
            width: 100; height: 100
            sourceItem: foo
        }
    }
}

The ShaderEffectSource type does not redirect any mouse or keyboard input to sourceItem. If you hide the sourceItem by setting visible to false or opacity to zero, it will no longer react to input. In cases where the ShaderEffectSource is meant to replace the sourceItem, you typically want to hide the sourceItem while still handling input. For this, you can use the hideSource property.

The ShaderEffectSource relies on FBO multisampling support to antialias edges. If the underlying hardware does not support this, which is the case for most embedded graphics chips, edges rendered inside a ShaderEffectSource will not be antialiased. One way to remedy this is to double the size of the effect source and render it with smooth: true (this is the default value of smooth). This will be equivalent to 4x multisampling, at the cost of lower performance and higher memory use.

In most cases, using a ShaderEffectSource will decrease performance, and in all cases, it will increase video memory usage. Rendering through a ShaderEffectSource might also lead to lower quality since some OpenGL implementations support multisampled backbuffer, but not multisampled framebuffer objects.

Property Documentation▲

 

format : enumeration▲

This property defines the format of the backing texture. Modifying this property makes most sense when the item is used as a source texture of a ShaderEffect.

hideSource : bool▲

If this property is true, the sourceItem is hidden, though it will still be rendered into the texture. As opposed to hiding the sourceItem by setting visible to false, setting this property to true will not prevent mouse or keyboard input from reaching sourceItem. The property is useful when the ShaderEffectSource is anchored on top of, and meant to replace the sourceItem.

live : bool▲

If this property is true, the texture is updated whenever the sourceItem updates. Otherwise, it will be a frozen image, even if sourceItem is assigned a new item. The property is true by default.

mipmap : bool▲

If this property is true, mipmaps are generated for the texture.

Some OpenGL ES 2 implementations do not support mipmapping of non-power-of-two textures.

recursive : bool▲

Set this property to true if the ShaderEffectSource has a dependency on itself. ShaderEffectSources form a dependency chain, where one ShaderEffectSource can be part of the sourceItem of another. If there is a loop in this chain, a ShaderEffectSource could end up trying to render into the same texture it is using as source, which is not allowed by OpenGL. When this property is set to true, an extra texture is allocated so that ShaderEffectSource can keep a copy of the texture from the previous frame. It can then render into one texture and use the texture from the previous frame as source.

Setting both this property and live to true will cause the scene graph to render continuously. Since the ShaderEffectSource depends on itself, updating it means that it immediately becomes dirty again.

[since 5.10] samples : int▲

This property allows requesting multisampled rendering.

By default multisampling is enabled whenever multisampling is enabled for the entire window, assuming the scenegraph renderer in use and the underlying graphics API supports this.

By setting the value to 2, 4, etc. multisampled rendering can be requested for a part of the scene without enabling multisampling for the entire scene. This way multisampling is applied only to a given subtree, which can lead to significant performance gains since multisampling is not applied to other parts of the scene.

Enabling multisampling can be potentially expensive regardless of the layer's size, as it incurs a hardware and driver dependent performance and memory cost.

This property is only functional when support for multisample renderbuffers and framebuffer blits is available. Otherwise the value is silently ignored.

This property was introduced in Qt 5.10.

sourceItem : Item▲

This property holds the item to be rendered into the texture. Setting this to null while live is true, will release the texture resources.

sourceRect : rect▲

This property defines which rectangular area of the sourceItem to render into the texture. The source rectangle can be larger than sourceItem itself. If the rectangle is null, which is the default, the whole sourceItem is rendered to texture.

[since 5.6] textureMirroring : enumeration▲

This property defines how the generated OpenGL texture should be mirrored. The default value is ShaderEffectSource.MirrorVertically. Custom mirroring can be useful if the generated texture is directly accessed by custom shaders, such as those specified by ShaderEffect. Mirroring has no effect on the UI representation of the ShaderEffectSource item itself.

This property was introduced in Qt 5.6.

textureSize : size▲

This property holds the requested size of the texture. If it is empty, which is the default, the size of the source rectangle is used.

Some platforms have a limit on how small framebuffer objects can be, which means the actual texture size might be larger than the requested size.

wrapMode : enumeration▲

This property defines the OpenGL wrap modes associated with the texture. Modifying this property makes most sense when the item is used as a source texture of a ShaderEffect.

The default value is ShaderEffectSource.ClampToEdge.

Some OpenGL ES 2 implementations do not support the GL_REPEAT wrap mode with non-power-of-two textures.

Method Documentation▲

 

scheduleUpdate()▲

Schedules a re-rendering of the texture for the next frame. Use this to update the texture when live is false.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+