Wave Effect

In this more complex example, we will create a wave effect with the fragment shader. The waveform is based on the sinus curve and it influences the texture coordinates used for the color.

The qml file defines the properties and animation.

  1. import QtQuick 2.5
  3. Rectangle {
  4.     width: 480; height: 240
  5.     color: '#1e1e1e'
  7.     Row {
  8.         anchors.centerIn: parent
  9.         spacing: 20
  10.         Image {
  11.             id: sourceImage
  12.             width: 160; height: width
  13.             source: "../assets/coastline.jpg"
  14.         }
  15.         ShaderEffect {
  16.             width: 160; height: width
  17.             property variant source: sourceImage
  18.             property real frequency: 8
  19.             property real amplitude: 0.1
  20.             property real time: 0.0
  21.             NumberAnimation on time {
  22.                 from: 0; to: Math.PI*2; duration: 1000; loops: Animation.Infinite
  23.             }
  25.             fragmentShader: "wave.frag.qsb"
  26.         }
  27.     }
  28. }

The fragment shader takes the properties and calculates the color of each pixel based on the properties.

  1. #version 440
  3. layout(location=0) in vec2 qt_TexCoord0;
  5. layout(location=0) out vec4 fragColor;
  7. layout(std140, binding=0) uniform buf {
  8.     mat4 qt_Matrix;
  9.     float qt_Opacity;
  11.     float frequency;
  12.     float amplitude;
  13.     float time;
  14. } ubuf;
  16. layout(binding=1) uniform sampler2D source;
  18. void main() {
  19.     vec2 pulse = sin(ubuf.time - ubuf.frequency * qt_TexCoord0);
  20.     vec2 coord = qt_TexCoord0 + ubuf.amplitude * vec2(pulse.x, -pulse.x);
  21.     fragColor = texture(source, coord) * ubuf.qt_Opacity;
  22. }

The wave calculation is based on a pulse and the texture coordinate manipulation. The pulse equation gives us a sine wave depending on the current time and the used texture coordinate:

  1. vec2 pulse = sin(ubuf.time - ubuf.frequency * qt_TexCoord0);

Without the time factor, we would just have a distortion but not a traveling distortion like waves are.

For the color we use the color at a different texture coordinate:

  1. vec2 coord = qt_TexCoord0 + ubuf.amplitude * vec2(pulse.x, -pulse.x);

The texture coordinate is influenced by our pulse x-value. The result of this is a moving wave.

image

In this example we use a fragment shader, meaning that we move the pixels inside the texture of the rectangular item. If we wanted the entire item to move as a wave we would have to use a vertex shader.