QtQuick.ShaderEffectSource

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

Properties

• format : enumeration
• hideSource : bool
• live : bool
• mipmap : bool
• recursive : bool
• sourceItem : Item
• sourceRect : rect
• textureSize : size
• wrapMode : enumeration

Methods

• scheduleUpdate()

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.

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.

Note: If sourceItem is a Rectangle with border, by default half the border width falls outside the texture. To get the whole border, you can extend the sourceRect.

Note: 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.

Warning: 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

This property defines the internal OpenGL format of the texture. Modifying this property makes most sense when the item is used as a source texture of a ShaderEffect. Depending on the OpenGL implementation, this property might allow you to save some texture memory.

• ShaderEffectSource.Alpha - GL_ALPHA
• ShaderEffectSource.RGB - GL_RGB
• ShaderEffectSource.RGBA - GL_RGBA

Note: Some OpenGL implementations do not support the GL_ALPHA format.

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.

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.

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

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

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.

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

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.

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.

Note: 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.

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.

• ShaderEffectSource.ClampToEdge - GL_CLAMP_TO_EDGE both horizontally and vertically
• ShaderEffectSource.RepeatHorizontally - GL_REPEAT horizontally, GL_CLAMP_TO_EDGE vertically
• ShaderEffectSource.RepeatVertically - GL_CLAMP_TO_EDGE horizontally, GL_REPEAT vertically
• ShaderEffectSource.Repeat - GL_REPEAT both horizontally and vertically

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

Method Documentation

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