Source code
Revision control
Copy as Markdown
Other Tools
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
#define WR_FEATURE_TEXTURE_2D
#include shared,prim_shared
varying highp vec2 vUv;
flat varying highp vec4 vUvRect;
flat varying highp vec4 vUvClampRect;
flat varying mediump vec2 vOffsetScale;
// The number of pixels on each end that we apply the blur filter over.
flat varying mediump ivec2 vSupport;
flat varying mediump vec2 vGaussCoefficients;
#define EDGE_MODE_DUPLICATE 0
#define EDGE_MODE_MIRROR 1
#ifdef WR_VERTEX_SHADER
// Applies a separable gaussian blur in one direction, as specified
// by the dir field in the blur command.
#define DIR_HORIZONTAL 0
#define DIR_VERTICAL 1
PER_INSTANCE in int aBlurRenderTaskAddress;
PER_INSTANCE in int aBlurSourceTaskAddress;
PER_INSTANCE in int aBlurDirection;
PER_INSTANCE in int aBlurEdgeMode;
PER_INSTANCE in vec3 aBlurParams;
struct BlurTask {
RectWithEndpoint task_rect;
float blur_radius;
vec2 blur_region;
};
BlurTask fetch_blur_task(int address) {
RectWithEndpoint task_rect = fetch_render_task_rect(address);
BlurTask task = BlurTask(
task_rect,
aBlurParams.x,
aBlurParams.yz
);
return task;
}
void calculate_gauss_coefficients(float sigma) {
// Incremental Gaussian Coefficent Calculation (See GPU Gems 3 pp. 877 - 889)
vGaussCoefficients = vec2(1.0 / (sqrt(2.0 * 3.14159265) * sigma),
exp(-0.5 / (sigma * sigma)));
// Pre-calculate the coefficient total in the vertex shader so that
// we can avoid having to do it per-fragment and also avoid division
// by zero in the degenerate case.
vec3 gauss_coefficient = vec3(vGaussCoefficients,
vGaussCoefficients.y * vGaussCoefficients.y);
float gauss_coefficient_total = gauss_coefficient.x;
for (int i = 1; i <= vSupport.x; i += 2) {
gauss_coefficient.xy *= gauss_coefficient.yz;
float gauss_coefficient_subtotal = gauss_coefficient.x;
gauss_coefficient.xy *= gauss_coefficient.yz;
gauss_coefficient_subtotal += gauss_coefficient.x;
gauss_coefficient_total += 2.0 * gauss_coefficient_subtotal;
}
// Scale initial coefficient by total to avoid passing the total separately
// to the fragment shader.
vGaussCoefficients.x /= gauss_coefficient_total;
}
void main(void) {
BlurTask blur_task = fetch_blur_task(aBlurRenderTaskAddress);
RectWithEndpoint src_rect = fetch_render_task_rect(aBlurSourceTaskAddress);
RectWithEndpoint target_rect = blur_task.task_rect;
vec2 texture_size = vec2(TEX_SIZE(sColor0).xy);
// Ensure that the support is an even number of pixels to simplify the
// fragment shader logic.
//
// TODO(pcwalton): Actually make use of this fact and use the texture
// hardware for linear filtering.
vSupport.x = int(ceil(1.5 * blur_task.blur_radius)) * 2;
vSupport.y = aBlurEdgeMode;
if (vSupport.x > 0) {
calculate_gauss_coefficients(blur_task.blur_radius);
} else {
// The gauss function gets NaNs when blur radius is zero.
vGaussCoefficients = vec2(1.0, 1.0);
}
switch (aBlurDirection) {
case DIR_HORIZONTAL:
vOffsetScale = vec2(
1.0 / (src_rect.p1.x - src_rect.p0.x),
0.0
);
break;
case DIR_VERTICAL:
vOffsetScale = vec2(
0.0,
1.0 / (src_rect.p1.y - src_rect.p0.y)
);
break;
default:
vOffsetScale = vec2(0.0);
}
vUvRect = vec4(src_rect.p0, src_rect.p1);
vUvRect /= texture_size.xyxy;
vUvClampRect = vec4(src_rect.p0 + vec2(0.5),
src_rect.p0 + blur_task.blur_region - vec2(0.5));
vUvClampRect /= texture_size.xyxy;
vec2 pos = mix(target_rect.p0, target_rect.p1, aPosition.xy);
vUv = aPosition.xy;
gl_Position = uTransform * vec4(pos, 0.0, 1.0);
}
#endif
#ifdef WR_FRAGMENT_SHADER
#if defined WR_FEATURE_COLOR_TARGET
#define SAMPLE_TYPE vec4
#define SAMPLE_TEXTURE(uv) texture(sColor0, uv)
#else
#define SAMPLE_TYPE float
#define SAMPLE_TEXTURE(uv) texture(sColor0, uv).r
#endif
// TODO(gw): Write a fast path blur that handles smaller blur radii
// with a offset / weight uniform table and a constant
// loop iteration count!
// GLSL implementation of GL_MIRRORED_REPEAT
vec2 mirrored_repeat(vec2 uv) {
vec2 abs_uv = abs(uv);
vec2 uv_int = floor(abs_uv);
vec2 uv_frac = abs_uv - uv_int;
vec2 f = mod(uv_int, vec2(2.0));
return mix(uv_frac, vec2(1.0) - uv_frac, f);
}
void main(void) {
vec2 uv = mix(vUvRect.xy, vUvRect.zw, vUv);
SAMPLE_TYPE original_color = SAMPLE_TEXTURE(uv);
// Incremental Gaussian Coefficent Calculation (See GPU Gems 3 pp. 877 - 889)
vec3 gauss_coefficient = vec3(vGaussCoefficients,
vGaussCoefficients.y * vGaussCoefficients.y);
SAMPLE_TYPE avg_color = original_color * gauss_coefficient.x;
// Evaluate two adjacent texels at a time. We can do this because, if c0
// and c1 are colors of adjacent texels and k0 and k1 are arbitrary
// factors, this formula:
//
// k0 * c0 + k1 * c1 (Equation 1)
//
// is equivalent to:
//
// k1
// (k0 + k1) * lerp(c0, c1, -------)
// k0 + k1
//
// A texture lookup of adjacent texels evaluates this formula:
//
// lerp(c0, c1, t)
//
// for some t. So we can let `t = k1/(k0 + k1)` and effectively evaluate
// Equation 1 with a single texture lookup.
//
// Clamp loop condition variable to a statically known value to workaround
// driver bug on Adreno 3xx. vSupport should not exceed 300 anyway, due to
int support = min(vSupport.x, 300);
for (int i = 1; i <= support; i += 2) {
gauss_coefficient.xy *= gauss_coefficient.yz;
float gauss_coefficient_subtotal = gauss_coefficient.x;
gauss_coefficient.xy *= gauss_coefficient.yz;
gauss_coefficient_subtotal += gauss_coefficient.x;
float gauss_ratio = gauss_coefficient.x / gauss_coefficient_subtotal;
vec2 offset = vOffsetScale * (float(i) + gauss_ratio);
vec2 uv0 = vUv - offset;
vec2 uv1 = vUv + offset;
if (vSupport.y == EDGE_MODE_MIRROR) {
uv0 = mirrored_repeat(uv0);
uv1 = mirrored_repeat(uv1);
}
uv0 = mix(vUvRect.xy, vUvRect.zw, uv0);
uv1 = mix(vUvRect.xy, vUvRect.zw, uv1);
uv0 = max(uv0, vUvClampRect.xy);
uv1 = min(uv1, vUvClampRect.zw);
avg_color += (SAMPLE_TEXTURE(uv0) + SAMPLE_TEXTURE(uv1)) *
gauss_coefficient_subtotal;
}
oFragColor = vec4(avg_color);
}
#ifdef SWGL_DRAW_SPAN
#ifdef WR_FEATURE_COLOR_TARGET
void swgl_drawSpanRGBA8() {
vec2 uv = mix(vUvRect.xy, vUvRect.zw, vUv);
swgl_commitGaussianBlurRGBA8(sColor0, uv, vUvClampRect, vOffsetScale.x != 0.0,
vSupport.x, vGaussCoefficients);
}
#else
void swgl_drawSpanR8() {
vec2 uv = mix(vUvRect.xy, vUvRect.zw, vUv);
swgl_commitGaussianBlurR8(sColor0, uv, vUvClampRect, vOffsetScale.x != 0.0,
vSupport.x, vGaussCoefficients);
}
#endif
#endif
#endif