// Copyright © 2015 Canonical Ltd. // // This program is free software; you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation; version 3. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with this program. If not, see . // // Author: Loïc Molinari // Static flow control (branching on a uniform value) is fast on most GPUs (including ultra-low // power ones) because it allows one to use the same shader execution path for an entire draw call. We // rely on that technique here (also known as "uber-shader" solution) to avoid the complexity of // dealing with a multiple shaders solution. // FIXME(loicm) Validate GPU behavior with regards to static flow control. #version 440 layout(location=0) in vec2 shapeCoord; layout(location=1) in vec4 sourceCoord; layout(location=2) in float yCoord; layout(location=3) in vec4 backgroundColor; layout(location = 0) out vec4 fragColor; layout(std140, binding=0) uniform buf { mat4 matrix; vec2 opacityFactors; float sourceOpacity; float distanceAA; // FIXME: Qt does not handle SPIRV-cross lower `bool` to `lowp int` instead // of `uint` in GLSL ES 100. // https://qt-project.atlassian.net/browse/QTBUG-142725 // bool textured; int textured; int aspect; } ubuf; layout(binding=1) uniform sampler2D shapeTexture; layout(binding=2) uniform sampler2D sourceTexture; const int FLAT = 0x08; // 1 << 3 const int INSET = 0x10; // 1 << 4 const int DROP_SHADOW = 0x20; // 1 << 5 void main(void) { vec4 shapeData = texture(shapeTexture, shapeCoord); vec4 color = backgroundColor; if (ubuf.textured != 0) { // Blend the source over the current color. // FIXME(loicm) sign() is far from optimal. Call texture2D() at beginning of scope. vec2 axisMask = -sign((sourceCoord.zw * sourceCoord.zw) - vec2(1.0)); float mask = clamp(axisMask.x + axisMask.y, 0.0, 1.0); vec4 source = texture(sourceTexture, sourceCoord.st) * vec4(ubuf.sourceOpacity * mask); color = vec4(1.0 - source.a) * color + source; } if (ubuf.aspect == FLAT) { // Mask the current color. color *= shapeData.b; } else if (ubuf.aspect == INSET) { // The vertex layout of the shape is made so that the derivative is negative from top to // middle and positive from middle to bottom. float shapeSide = yCoord <= 0.0 ? 0.0 : 1.0; // Blend the shape inner shadow over the current color. The shadow color is black, its // translucency is stored in the texture. float shadow = shapeData[int(shapeSide)]; color = vec4(1.0 - shadow) * color + vec4(0.0, 0.0, 0.0, shadow); // Get the shape mask. vec2 mask = shapeData.ba; // Get the bevel color. The bevel is made of the top mask masked with the bottom mask. A // gradient from the bottom (1) to the middle (0) of the shape is used to factor out values // resulting from the mask anti-aliasing. The bevel color is white with 60% opacity. float bevel = (mask.x * -mask.y) + mask.x; // -ab + a = a(1 - b) float gradient = clamp((shapeSide * -shapeCoord.t) + shapeSide, 0.0, 1.0); bevel *= gradient * 0.6; // Mask the current color then blend the bevel over the resulting color. We simply use // additive blending since the bevel has already been masked. color = (color * vec4(mask[int(shapeSide)])) + vec4(bevel); } else if (ubuf.aspect == DROP_SHADOW) { // Get the shape mask. int shapeSide = yCoord <= 0.0 ? 0 : 1; float mask = shapeData[shapeSide]; // Get the shadow color outside of the shape mask. float shadow = (shapeData.b * -mask) + shapeData.b; // -ab + a = a(1 - b) // Mask the current color then blend the shadow over the resulting color. We simply use // additive blending since the shadow has already been masked. color = (color * vec4(mask)) + vec4(0.0, 0.0, 0.0, shadow); } fragColor = color * ubuf.opacityFactors.xxxy; }