ps_quad_box_shadow.glsl

/* 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

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/// Box-shadow blur rendering via the quad infrastructure.

///

/// GPU buffer layout at pattern_input.x (5 blocks):

///   [0] alloc_size.x, alloc_size.y, dest_rect_size.x, dest_rect_size.y

///   [1] dest_rect_offset.x, dest_rect_offset.y, clip_mode (0=outset, 1=inset), 0

///   [2] element_offset_rel_prim.x, element_offset_rel_prim.y, element_size.x, element_size.y

///   [3] element_radius.tl.w, element_radius.tl.h, element_radius.tr.w, element_radius.tr.h

///   [4] element_radius.br.w, element_radius.br.h, element_radius.bl.w, element_radius.bl.h

///

/// For outset: prim_rect == dest_rect, element_offset_rel_prim is typically negative

///             (element sits inside the inflated shadow rect).

/// For inset:  prim_rect is the element rect; dest_rect is the shadow area

///             (offset and potentially smaller), and blur alpha is inverted.

///

/// Element clipping (clip-out for outset, clip-in for inset) is handled analytically

/// in this shader via a rounded-rect SDF, enabling Direct rendering for the common case.

#include ps_quad,ellipse,shared

// xy: position relative to dest_rect.p0, for nine-patch UV sampling.

// zw: position in local (primitive) space, for element clip SDF evaluation.

varying highp vec4 v_shadow_pos_local_pos;

// xy: 1 / alloc_size — UV denominator.

// z: 1.0 for inset (blur alpha inverted, element clip-in), 0.0 for outset (clip-out).

//    Packed in to a vector to work around bug 1630356.

// w: unused.

flat varying highp vec4 v_uv_scale_inset;

// Nine-patch edges: .xy = 0.5 (near), .zw = dest_rect_size/alloc_size - 0.5 (far).

flat varying highp vec4 v_edge;

// Atlas UV rect (normalized) and sample bounds.

flat varying highp vec4 v_uv_rect;

flat varying highp vec4 v_uv_bounds;

// Element clip SDF data: corner ellipse centers (xy) and radii (zw).

// Plane normals are reconstructed from radii in the fragment shader;

// only the plane constants are passed separately (see vElemPlaneConstants).

flat varying highp vec4 vElemCenter_Radius_TL;

flat varying highp vec4 vElemCenter_Radius_TR;

flat varying highp vec4 vElemCenter_Radius_BR;

flat varying highp vec4 vElemCenter_Radius_BL;

// Corner half-space plane constants (one per corner, xyzw = TL TR BR BL).

// Normals are derived from the corner radii stored in vElemCenter_Radius_*.zw.

flat varying highp vec4 vElemPlaneConstants;

// Element rect bounds in local space (for signed_distance_rect fallback).

flat varying highp vec4 vElemBounds;

#ifdef WR_VERTEX_SHADER

void pattern_vertex(PrimitiveInfo info) {

    vec4 data0 = fetch_from_gpu_buffer_1f(info.pattern_input.x);

    vec4 data1 = fetch_from_gpu_buffer_1f(info.pattern_input.x + 1);

    vec4 data2 = fetch_from_gpu_buffer_1f(info.pattern_input.x + 2);

    vec4 data3 = fetch_from_gpu_buffer_1f(info.pattern_input.x + 3);

    vec4 data4 = fetch_from_gpu_buffer_1f(info.pattern_input.x + 4);

    vec2 alloc_size     = data0.xy;

    vec2 dest_rect_size = data0.zw;

    vec2 dest_rect_off  = data1.xy;

    v_uv_scale_inset    = vec4(vec2(1.0) / alloc_size, data1.z, 0.0);

    v_shadow_pos_local_pos = vec4(

        info.local_pos - info.local_prim_rect.p0 - dest_rect_off,

        info.local_pos

);

    v_edge = vec4(

        0.5,

        0.5,

        dest_rect_size.x / alloc_size.x - 0.5,

        dest_rect_size.y / alloc_size.y - 0.5

);

    vec2 texture_size = vec2(TEX_SIZE(sColor0));

    v_uv_rect = vec4(info.segment.uv_rect.p0, info.segment.uv_rect.p1) / texture_size.xyxy;

    v_uv_bounds = vec4(

        info.segment.uv_rect.p0 + vec2(0.5),

        info.segment.uv_rect.p1 - vec2(0.5)

    ) / texture_size.xyxy;

    // Element clip: compute corner centers, radii, and half-space plane constants.

    vec2 elem_p0 = info.local_prim_rect.p0 + data2.xy;

    vec2 elem_p1 = elem_p0 + data2.zw;

    vElemBounds = vec4(elem_p0, elem_p1);

    vec2 r_tl = data3.xy;

    vec2 r_tr = data3.zw;

    vec2 r_br = data4.xy;

    vec2 r_bl = data4.zw;

    vElemCenter_Radius_TL = vec4(elem_p0 + r_tl, r_tl);

    vElemCenter_Radius_TR = vec4(elem_p1.x - r_tr.x, elem_p0.y + r_tr.y, r_tr);

    vElemCenter_Radius_BR = vec4(elem_p1 - r_br, r_br);

    vElemCenter_Radius_BL = vec4(elem_p0.x + r_bl.x, elem_p1.y - r_bl.y, r_bl);

    // Plane normals are n = ±radius.yx (reconstructed in the fragment shader from the

    // stored radii). Only the plane constants are needed as varyings.

    vec2 n_tl = -r_tl.yx;

    vec2 n_tr = vec2(r_tr.y, -r_tr.x);

    vec2 n_br = r_br.yx;

    vec2 n_bl = vec2(-r_bl.y, r_bl.x);

    vElemPlaneConstants = vec4(

        dot(n_tl, vec2(elem_p0.x,            elem_p0.y + r_tl.y)),

        dot(n_tr, vec2(elem_p1.x - r_tr.x,   elem_p0.y)),

        dot(n_br, vec2(elem_p1.x,             elem_p1.y - r_br.y)),

        dot(n_bl, vec2(elem_p0.x + r_bl.x,   elem_p1.y))

);

#endif

#ifdef WR_FRAGMENT_SHADER

vec4 pattern_fragment(vec4 base_color) {

    vec2 shadow_pos = v_shadow_pos_local_pos.xy;

    vec2 local_pos  = v_shadow_pos_local_pos.zw;

    vec2 uv_scale   = v_uv_scale_inset.xy;

    float inset     = v_uv_scale_inset.z;

    vec2 uv_linear = shadow_pos * uv_scale;

    vec2 uv = clamp(uv_linear, vec2(0.0), v_edge.xy);

    uv += max(vec2(0.0), uv_linear - v_edge.zw);

    uv = mix(v_uv_rect.xy, v_uv_rect.zw, uv);

    uv = clamp(uv, v_uv_bounds.xy, v_uv_bounds.zw);

    float alpha = TEX_SAMPLE(sColor0, uv).r;

    // Inset shadows: the blur texture encodes the shadow shape interior

    // (alpha=1 inside shadow_rect). We invert to get alpha=1 at the element

    // boundary fading toward zero at the shadow_rect center.

    alpha = mix(alpha, 1.0 - alpha, inset);

    // Element clip: clip-out for outset (inset=0), clip-in for inset (inset=1).

    // distance_to_rounded_rect returns negative inside the element rect, positive outside.

    // distance_aa returns 1 when dist < 0 (inside) and 0 when dist > 0 (outside).

    float aa_range = compute_aa_range(local_pos);

    vec2 r_tl = vElemCenter_Radius_TL.zw;

    vec2 r_tr = vElemCenter_Radius_TR.zw;

    vec2 r_br = vElemCenter_Radius_BR.zw;

    vec2 r_bl = vElemCenter_Radius_BL.zw;

    // Reconstruct plane normals from the stored radii.

    vec2 n_tl = -r_tl.yx;

    vec2 n_tr = vec2(r_tr.y, -r_tr.x);

    vec2 n_br = r_br.yx;

    vec2 n_bl = vec2(-r_bl.y, r_bl.x);

    vec3 elem_plane_tl = vec3(n_tl, vElemPlaneConstants.x);

    vec3 elem_plane_tr = vec3(n_tr, vElemPlaneConstants.y);

    vec3 elem_plane_br = vec3(n_br, vElemPlaneConstants.z);

    vec3 elem_plane_bl = vec3(n_bl, vElemPlaneConstants.w);

    float elem_dist = distance_to_rounded_rect(

        local_pos,

        elem_plane_tl, vec4(vElemCenter_Radius_TL.xy, inverse_radii_squared(r_tl)),

        elem_plane_tr, vec4(vElemCenter_Radius_TR.xy, inverse_radii_squared(r_tr)),

        elem_plane_br, vec4(vElemCenter_Radius_BR.xy, inverse_radii_squared(r_br)),

        elem_plane_bl, vec4(vElemCenter_Radius_BL.xy, inverse_radii_squared(r_bl)),

        vElemBounds

);

    // Outset (inset=0): dist < 0 = inside element → should be clipped out → use -elem_dist.

    // Inset (inset=1): dist < 0 = inside element → should be kept → use elem_dist.

    float element_clip = distance_aa(aa_range, mix(-elem_dist, elem_dist, inset));

    return base_color * alpha * element_clip;

#endif