fastuidraw_restricted_rays.glsl.hpp

Go to the documentation of this file.

/*!
 * \file fastuidraw_restricted_rays.glsl.hpp
 * \brief file fastuidraw_restricted_rays.glsl.hpp
 *
 * Copyright 2018 by Intel.
 *
 * Contact: kevin.rogovin@gmail.com
 *
 * 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/.
 *
 * \author Kevin Rogovin <kevin.rogovin@gmail.com>
 *
 */

/*!\addtogroup GLSLFragCode
 * @{
 */

///@cond

/* must have the macro/function
 *
 *  fastuidraw_fetch_glyph_data(X)
 *
 * that returns a single 32-bit uint value at index X of
 * a large array of 32-bit uint values storing the data
 *
 * and optionally define the macro/function
 *
 *  fastuidraw_fetch_glyph_data_fp16x2(X)
 *
 * the reads a single 32-bit uint value that is bit-casted
 * to a (fp16, fp16) pair realized as a vec2. For example
 * it can be defined as
 * unpackHalf2x16(fastuidraw_fetch_glyph_data(X))
 */

struct fastuidraw_restricted_rays_transformation
{
  vec2 translation;
  vec2 t_vector, jq_vector;
  float reference_location, orientation;
};

struct fastuidraw_restricted_rays_curve_type
{
  vec2 p1, p2, p3;
  bool is_quadratic;
};

struct fastuidraw_restricted_rays_box_type
{
  vec2 min_point, max_point, center_point, size;
};

struct fastuidraw_restricted_rays_distance_type
{
  float distance_increment;
  float distance_decrement;
};

struct fastuidraw_restricted_rays_winding_sample_type
{
  int reference_winding;
  vec2 reference_position;
};

void
fastuidraw_restricted_rays_init_distance(out fastuidraw_restricted_rays_distance_type nv)
{
  /* Just initialize to some value that is large (strictly speaking
   * we only need a value greater than 0.5, but make it larger
   * for debug renders to be useful).
   */
  nv.distance_increment = nv.distance_decrement = 120.0;
}

void
fastuidraw_restricted_rays_update_distance(in float dist, in bool is_increment,
                                           inout fastuidraw_restricted_rays_distance_type nv)
{
  /* We are assuming that there are no cancelling curves in the glyph data.
   * The class GlyphRenderDataRestrictedRays has code to detect most forms
   * of cancelling curves (it detects partially overlapping vertical and
   * horizontal curves along with perfectly overlapping general curves).
   */
  if (is_increment)
    {
      nv.distance_increment = min(nv.distance_increment, dist);
    }
  else
    {
      nv.distance_decrement = min(nv.distance_decrement, dist);
    }
}

void
fastuidraw_restricted_rays_update_distance(in vec2 p, in bool is_increment,
                                           inout fastuidraw_restricted_rays_distance_type nv)
{
  float d;

  d = abs(p.x) + abs(p.y);
  fastuidraw_restricted_rays_update_distance(d, is_increment, nv);
}

bool
fastuidraw_restricted_rays_is_increment(in vec2 p, in vec2 dp)
{
  float det;

  /* The vector from the origin to the point is given by the point value, p.
   * the direction of the curve is given by dp. When crossing the curve in the
   * direction from the origin to p, the winding is incremented if the pair
   * (p, dp) forms a 2x2 matrix that has positive determinant and decrements
   * otherwise.
   */
  det = p.x * dp.y - p.y * dp.x;
  return det > 0.0;
}

void
fastuidraw_restricted_rays_update_distance(in vec2 p, in vec2 dp,
                                           inout fastuidraw_restricted_rays_distance_type nv)
{
  fastuidraw_restricted_rays_update_distance(p, fastuidraw_restricted_rays_is_increment(p, dp), nv);
}

uint
fastuidaw_restricted_rays_compute_box(in vec2 p,
                                      in uint data_location,
                                      out fastuidraw_restricted_rays_box_type box,
                                      out uint curve_list,
                                      out uint num_curves)
{
  uint v, offset;

  box.min_point = vec2(-fastuidraw_restricted_rays_glyph_coord_value, -fastuidraw_restricted_rays_glyph_coord_value);
  box.max_point = vec2(fastuidraw_restricted_rays_glyph_coord_value, fastuidraw_restricted_rays_glyph_coord_value);

  offset = data_location;
  v = fastuidraw_fetch_glyph_data(offset);

  while((v & fastuidraw_restricted_rays_hierarchy_node_mask) != 0u)
    {
      uint c, bit0;
      float split_pt;
      bool take_max_choice;

      c = FASTUIDRAW_EXTRACT_BITS(fastuidraw_restricted_rays_hierarchy_split_coord_bit, 1u, v);
      if (c == 0u)
        {
          split_pt = 0.5 * (box.min_point.x + box.max_point.x);
          take_max_choice = (p.x > split_pt);
          box.min_point.x = (take_max_choice) ? split_pt : box.min_point.x;
          box.max_point.x = (take_max_choice) ? box.max_point.x : split_pt;
        }
      else
        {
          split_pt = 0.5 * (box.min_point.y + box.max_point.y);
          take_max_choice = (p.y > split_pt);
          box.min_point.y = (take_max_choice) ? split_pt : box.min_point.y;
          box.max_point.y = (take_max_choice) ? box.max_point.y : split_pt;
        }

      bit0 = (take_max_choice) ?
        fastuidraw_restricted_rays_hierarchy_child1_bit:
        fastuidraw_restricted_rays_hierarchy_child0_bit;
      offset = FASTUIDRAW_EXTRACT_BITS(bit0,
                                       fastuidraw_restricted_rays_hierarchy_child_num_bits,
                                       v);
      offset += data_location;
      v = fastuidraw_fetch_glyph_data(offset);
    }

  box.size = box.max_point - box.min_point;
  box.center_point = 0.5 * (box.min_point + box.max_point);
  curve_list = FASTUIDRAW_EXTRACT_BITS(fastuidraw_restricted_rays_hierarchy_curve_list_bit0,
                                       fastuidraw_restricted_rays_hierarchy_curve_list_num_bits,
                                       v);
  num_curves = FASTUIDRAW_EXTRACT_BITS(fastuidraw_restricted_rays_hierarchy_curve_list_size_bit0,
                                       fastuidraw_restricted_rays_hierarchy_curve_list_size_num_bits,
                                       v);

  return offset + 1u;
}

vec2
fastuidraw_restricted_rays_unpack_point(in uint ptr)
{
  return fastuidraw_fetch_glyph_data_fp16x2(ptr);
}

void
fastuidraw_restricted_rays_compute_transformation(in vec2 frag_point,
                                                  in vec2 frag_point_dx,
                                                  in vec2 frag_point_dy,
                                                  in vec2 reference_point,
                                                  out fastuidraw_restricted_rays_transformation tr)
{
  /* We need to create a matrix M that has the following properties:
   *   1. M(q) = (V, 0) where q = reference_point - frag_point
   *                    and V can be any non-negative value
   *   2. M * F is a rotation where F is the 2x2 matrix giving the
   *            the local transformation from window coordinates to
   *            glyph coordinates.
   *
   *
   * The computation for M is as follows:
   *   Let Q be st F(Q) = q.
   *   Let T be st <T, Q> = 0, i.e. T = J(Q) where J(x, y) = (-y, x)
   *   Let t = J(F(T))
   *
   * thus,
   *
   *   t = (J * F * J * Finverse)(q)
   *
   * The matrix F is given by
   *
   *   | frag_point_dx.x frag_point_dy.x |
   *   | frag_point_dx.y frag_point_dy.y |
   *
   * For any matrix K
   *
   *  | a b |
   *  | c d |
   *
   * the matrix J * K * J * Kinverse is given by
   *
   * | -(cc + dd) / R   (ac + bd) / R |
   * |  (ac + bd) / R  -(aa + bb) / R |
   *
   * where R is det(K). Since we are only needing the
   * direction of the vector t, we can skip the divide
   * by R. Letting L be the above matrix, we set N to
   * be the matrix
   *
   *  |  t.x  t.y |
   *  | jq.x jq.y |
   *
   * where jq = (-q.y, q.x) and t = L * q. Finally,
   * M is given by N scaled so that F*jq and F*t have
   * unit L1-length, M*jq = (V, 0) with V > 0 and
   * M is orientation preserving (this is required
   * because if M reverses orientation the winding
   * changes to the refernece point would then need
   * to be negated).
   */

  vec2 q, top_row, bottom_row, em;
  float a, b, c, d;

  tr.translation = frag_point;
  q = reference_point - frag_point;
  tr.jq_vector.x = -q.y;
  tr.jq_vector.y = q.x;

  a = frag_point_dx.x;
  b = frag_point_dy.x;
  c = frag_point_dx.y;
  d = frag_point_dy.y;

  top_row.x = -(c * c + d * d);
  top_row.y = bottom_row.x = (a * c + b * d);
  bottom_row.y = -(a * a + b * b);

  tr.t_vector.x = dot(top_row, q);
  tr.t_vector.y = dot(bottom_row, q);

  /* em represents the normalization so that the pre-image of t_vector
   * and jq_vector in screen coordinates has length 1.
   */
  em.x = abs(dot(tr.t_vector, frag_point_dx)) + abs(dot(tr.t_vector, frag_point_dy));
  em.y = abs(dot(tr.jq_vector, frag_point_dx)) + abs(dot(tr.jq_vector, frag_point_dy));

  /* Prevent divide by zero. if em.x or em.y is very small, that means
   * that on screen the x (repsectively y) local coordinate axis is
   * severely stretched. Since the sample point is to be reasonably
   * far from any curve, clamping em.x and em.y away from zero will
   * not have effect on coverage computation.
   */
  const float min_em = 1e-7;
  em.x = max(em.x, min_em);
  em.y = max(em.y, min_em);

  tr.t_vector /= em.x;
  tr.jq_vector /= em.y;
  tr.reference_location = dot(tr.t_vector, q);

  if (tr.reference_location < 0.0)
    {
      /* we need to send q to (V, 0) where
       * V is positive.
       */
      tr.t_vector = -tr.t_vector;
      tr.reference_location = -tr.reference_location;
    }

  float det;

  det = (tr.t_vector.x * tr.jq_vector.y - tr.t_vector.y * tr.jq_vector.x);
  /* we need the transformation to be orientation preserving.
   * The only requirement we have on jq_vector is that
   * dot(jq_vector, q) is zero, so negate jq_vector to get the
   * transformation matrix to be orientation preserving.
   */
  if (det < 0.0)
    {
      tr.jq_vector = -tr.jq_vector;
    }
}

vec2
fastuidraw_restricted_rays_apply_transformation(in vec2 p,
                                                in fastuidraw_restricted_rays_transformation tr)
{
  p -= tr.translation;
  return vec2(dot(tr.t_vector, p),
              dot(tr.jq_vector, p));
}

int
fastuidraw_restricted_rays_compute_winding_contribution(in fastuidraw_restricted_rays_curve_type curve,
                                                        in fastuidraw_restricted_rays_transformation tr,
                                                        inout fastuidraw_restricted_rays_distance_type dst)
{
  vec2 A, B, C;
  int R = 0;
  bool use_t1, use_t2;
  float t1, t2, x1, x2, y1, y2;
  const float quad_tol = 0.0001;

  curve.p1 = fastuidraw_restricted_rays_apply_transformation(curve.p1, tr);
  curve.p2 = fastuidraw_restricted_rays_apply_transformation(curve.p2, tr);
  curve.p3 = fastuidraw_restricted_rays_apply_transformation(curve.p3, tr);

  A = curve.p1 - 2.0 * curve.p2 + curve.p3;
  B = curve.p1 - curve.p2;
  C = curve.p1;

  /*
   * Let
   *
   *  f(t) = [p1, p2, p3](t) = At^2 - 2Bt + C
   *
   * where
   *
   *  A = p1 - 2p2 + p3
   *  B = p1 - p2
   *  C = p1
   *
   * we wish to solve for t so that f_y(t) = 0 but enforce that
   * 0 < t < 1. Dropping the .y suffixes, the quadratic formula
   * gives us the two roots:
   *
   *  t1 = (B - sqrt(B^2 - AC)) / A
   *  t2 = (B + sqrt(B^2 - AC)) / A
   *
   * using 0 < t < 1 directly is numerically unstable, instead
   * we will use algebra to enforce that condition from p1, p2, p3.
   * When A > 0, high school algebra yields
   *
   *  0 < t1 < 1 if and only if (p1 > p2 && p1 > 0 && (p3 > p2 || p3 < 0))
   *  0 < t2 < 1 if and only if (p3 > p2 && p3 > 0 && (p1 > p2 || p1 < 0))
   *
   * which, again via high school algebra (under the condition A > 0),
   * becomes
   *
   *  0 < t1 < 1 if and only if (p1 > 0 && (p2 < 0 || p3 < 0))
   *  0 < t2 < 1 if and only if (p3 > 0 && (p2 < 0 || p1 < 0))
   *
   * These inequalities are incorrect if A < 0. For the case where
   * A < 0, the same high school algebra techniques give
   *
   *  0 < t1 < 1 if and only if (p3 < 0 && (p2 > 0 || p1 > 0))
   *  0 < t2 < 1 if and only if (p1 < 0 && (p2 > 0 || p3 > 0))
   *
   * Putting together gives
   *
   *  0 < t1 < 1 if and only if (p3 < 0 && (p2 > 0 || p1 > 0) && A < 0) || (p1 > 0 && (p2 < 0 || p3 < 0) && A > 0)
   *  0 < t2 < 1 if and only if (p1 < 0 && (p2 > 0 || p3 > 0) && A < 0) || (p3 > 0 && (p2 < 0 || p1 < 0) && A > 0)
   *
   * We can still simplify more. Indeed, the value of
   *
   *  (p3 < 0 && (p2 > 0 || p1 > 0) && A < 0) | (p1 > 0 && (p2 < 0 || p3 < 0) && A > 0)
   *
   * is equivalent to via algebra (by examining the three cases (p1 <= 0),
   * (p3 >= 0) and (p1 > 0 && p3 < 0) to:
   *
   *  (p3 < 0 && (p2 > 0 || p1 > 0)) || (p1 > 0 && (p2 < 0 || p3 < 0))
   *
   * Similair logic gives that
   *
   *  (p1 < 0 && (p2 > 0 || p3 > 0) && A < 0) || (p3 > 0 && (p2 < 0 || p1 < 0) && A > 0)
   *
   * is equivalent to
   *
   *  (p1 < 0 && (p2 > 0 || p3 > 0)) || (p3 > 0 && (p2 < 0 || p1 < 0))
   *
   * Which implies that instead of having a conditional branch on A < 0,
   * we can just put a logical of them together. Therefore,
   *
   *  T1 = (p3 < 0 && (p2 > 0 || p1 > 0)) || (p1 > 0 && (p2 < 0 || p3 < 0))
   *     = (p3 < 0 && p1 > 0) || (p3 < 0 && p2 > 0) || (p1 > 0 && p2 < 0) || (p1 > 0 && p3 < 0)
   *     = (p3 < 0 && p1 > 0) || (p3 < 0 && p2 > 0) || (p1 > 0 && p2 < 0)
   *
   *  T2 = (p1 < 0 && (p2 > 0 || p3 > 0)) || (p3 > 0 && (p2 < 0 || p1 < 0))
   *     = (p1 < 0 && p2 > 0) || (p1 < 0 && p3 > 0) || (p3 > 0 && p1 < 0) || (p3 > 0 && p2 < 0)
   *     = (p1 < 0 && p2 > 0) || (p1 < 0 && p3 > 0) || (p3 > 0 && p2 < 0)
   *
   * The last issue is to handle the end-points of the curve correctly.
   * We use the rules:
   *
   *  (a) use 0 if and only if f(0) = 0 && f'(0) < 0
   *  (b) use 1 if and only if f(1) = 1 && f'(1) > 0
   *
   * Which become
   *
   *  (a) use 0 if and only if p1 == 0 && p2 < p1
   *  (b) use 1 if and only if p3 == 0 && p2 < p3
   *
   * If p1.y is zero, then
   *
   *     t1 = (B - |B|) / A
   *     t2 = (B + |B|) / A
   *
   * If p2 < 0 = p1, then B > 0 and thus t1 = 0, i.e.
   * use t1 whenever (a) is true.
   *
   * If p3.y is zero, then algebra will give that
   *
   *   t1 = ((p1 - p2) - |p2|) / (p1 - 2p2)
   *   t2 = ((p1 - p2) + |p2|) / (p1 - 2p2)
   *
   * thus on condition (b) gives
   *
   *  t1 = p1 / (p1 - 2p2)
   *  t2 = 1
   *
   * which means use t2 when (b) is true.
   *
   * Thus,
   *
   *   use_t1 = T1 || (p1 == 0 && p2 < 0)
   *          = (p3 < 0 && p1 > 0) || (p3 < 0 && p2 > 0) || (p1 >= 0 && p2 < 0)
   *
   *   use_t2 = T2 || (p3 == 0 && p2 < 0)
   *          = (p1 < 0 && p2 > 0) || (p1 < 0 && p3 > 0) || (p3 >= 0 && p2 < 0)
   */
  use_t1 = (curve.p3.y < 0.0 && curve.p1.y > 0.0)
    || (curve.p3.y < 0.0 && curve.p2.y > 0.0)
    || (curve.p1.y >= 0.0 && curve.p2.y < 0.0);

  use_t2 = (curve.p1.y < 0 && curve.p2.y > 0.0)
    || (curve.p1.y < 0.0 && curve.p3.y > 0.0)
    || (curve.p3.y >= 0.0 && curve.p2.y < 0.0);

  if (curve.is_quadratic && abs(A.y) > quad_tol)
    {
      float D, rA;

      D = B.y * B.y - A.y * C.y;
      if (D < 0.0)
        {
          /* the parobola does not go through y = 0, thus it does
           * not contribute to the winding number.
           */
          t1 = t2 = 2.0;
          use_t1 = use_t2 = false;
        }
      else
        {
          rA = 1.0 / A.y;
          D = sqrt(D);

          t1 = (B.y - D) * rA;
          t2 = (B.y + D) * rA;
        }
    }
  else
    {
      t1 = t2 = 0.5 * C.y / B.y;
    }

  /* We know that t1 always increments and t2 always decerements
   * the winding number via
   *
   * f_y(t)  = Ay * (t - t1) * (t - t2)
   * f_y'(t) = Ay * (t - t1) + Ay * (t - t2)
   *
   * then
   *   if Ay < 0, then t1 > t2 and thus f_y'(t1) < 0 and f_y'(t2) > 0
   *   if Ay > 0, then t1 < t2 and thus f_y'(t1) < 0 and f_y'(t2) > 0
   */
  if (use_t1)
    {
      x1 = (A.x * t1 - B.x * 2.0) * t1 + C.x;
      if (x1 <= tr.reference_location && x1 >= 0.0)
        {
          R += 1;
        }
      fastuidraw_restricted_rays_update_distance(abs(x1), x1 < 0.0, dst);
    }

  if (use_t2)
    {
      x2 = (A.x * t2 - B.x * 2.0) * t2 + C.x;
      if (x2 <= tr.reference_location && x2 >= 0.0)
        {
          R -= 1;
        }
      fastuidraw_restricted_rays_update_distance(abs(x2), x2 > 0.0, dst);
    }

  /* we do the x-solve just for the distance function,
   * since we are just aiming for a distance, we can
   * use the numerically unstable 0 <= t <= 1 instead
   * of the nasty condition from the control points
   * directly.
   */
  if (curve.is_quadratic && abs(A.x) > quad_tol)
    {
      float D;

      D = B.x * B.x - A.x * C.x;
      if (D < 0.0)
        {
          use_t1 = use_t2 = false;
        }
      else
        {
          float rA = 1.0 / A.x;

          D = sqrt(D);
          t1 = (B.x - D) * rA;
          t2 = (B.x + D) * rA;

          use_t1 = (t1 >= 0.0 && t1 <= 1.0);
          use_t2 = (t2 >= 0.0 && t2 <= 1.0);
        }
    }
  else
    {
      t1 = t2 = 0.5 * C.x / B.x;
      use_t1 = (curve.p1.x > 0.0 && curve.p3.x < 0.0);
      use_t2 = (curve.p1.x < 0.0 && curve.p3.x > 0.0);
    }

  /* For the same resason that t1 always increments the winding
   * and t2 always decrements the winding, we know that only
   * the sign of y1 and y2 effect which distance they should
   * update.
   */
  if (use_t1)
    {
      y1 = (A.y * t1 - B.y * 2.0) * t1 + C.y;
      fastuidraw_restricted_rays_update_distance(abs(y1), y1 > 0.0, dst);
    }

  if (use_t2)
    {
      y2 = (A.y * t2 - B.y * 2.0) * t2 + C.y;
      fastuidraw_restricted_rays_update_distance(abs(y2), y2 < 0.0, dst);
    }

  /* We are just computing a distance-like value to perform anti-aliasing;
   * as such we can skip computing the other critical points for the L1-distance
   * function f(t) = |x(t) - x| + |y(t) - y| which are the end points and the
   * points p(t) = (x(t), y(t)) where |x'(t)| = |y'(t)|. The points correspond
   * to
   *
   *    t1 = (A.x - A.y) / (B.x - B.y)
   *    t2 = (A.x + A.y) / (B.x + B.y)
   *
   * If we are to check the end-points, we would need to only check t = 0.
   * This is because if t = 1 is within the cell, then the curve that starts
   * at t = 1 would also be within the cell. Checking the end point t = 0
   * is the code:
   *
   *   fastuidraw_restricted_rays_update_distance(curve.p1, -B, dst);
   *
   * this is because the curve is p(t) = At^2 -2Bt + C, thus its
   * derivative is p'(t) = -2At - 2B which at p'(0) = -2B. We only need
   * the direction of the derivative in the 2nd argument, so -B is
   * sufficient and the curve at 0 is curve.p1.
   *
   * TODO: decide if doing the proper L1-distance is necessary.
   */
  return R;
}

void
fastuidraw_restricted_rays_load_curve(in uint raw,
                                      in uint glyph_data_location,
                                      out fastuidraw_restricted_rays_curve_type curve)
{
  uint curve_src;

  curve_src = glyph_data_location + FASTUIDRAW_EXTRACT_BITS(fastuidraw_restricted_rays_curve_bit0,
                                                            fastuidraw_restricted_rays_curve_num_bits,
                                                            raw);
  curve.is_quadratic = (raw & fastuidraw_restricted_rays_curve_is_quadratic_mask) != 0u;

  curve.p1 = fastuidraw_restricted_rays_unpack_point(curve_src);
  curve.p2 = fastuidraw_restricted_rays_unpack_point(curve_src + 1u);

  if (curve.is_quadratic)
    {
      curve.p3 = fastuidraw_restricted_rays_unpack_point(curve_src + 2u);
    }
  else
    {
      curve.p3 = curve.p2;
      curve.p2 = 0.5 * (curve.p1 + curve.p3);
    }
}

int
fastuidraw_restricted_rays_load_and_process_curve(in uint raw,
                                                  in uint glyph_data_location,
                                                  in fastuidraw_restricted_rays_transformation tr,
                                                  inout fastuidraw_restricted_rays_distance_type nv)
{
  fastuidraw_restricted_rays_curve_type curve_data;
  int return_value;

  fastuidraw_restricted_rays_load_curve(raw,
                                        glyph_data_location,
                                        curve_data);


  return_value =
    fastuidraw_restricted_rays_compute_winding_contribution(curve_data, tr, nv);
  return return_value;
}

void
fastuidraw_restricted_rays_load_winding_reference(in uint location,
                                                  in fastuidraw_restricted_rays_box_type box,
                                                  out fastuidraw_restricted_rays_winding_sample_type s)
{
  uint texel, biased_winding;
  uvec2 uint_delta;
  vec2 position, delta;

  position = box.min_point;
  texel = fastuidraw_fetch_glyph_data(location);

  biased_winding = FASTUIDRAW_EXTRACT_BITS(fastuidraw_restricted_rays_winding_value_bit0,
                                           fastuidraw_restricted_rays_winding_value_num_bits, texel);
  uint_delta.x = FASTUIDRAW_EXTRACT_BITS(fastuidraw_restricted_rays_position_delta_x_bit0,
                                         fastuidraw_restricted_rays_position_delta_num_bits, texel);
  uint_delta.y = FASTUIDRAW_EXTRACT_BITS(fastuidraw_restricted_rays_position_delta_y_bit0,
                                         fastuidraw_restricted_rays_position_delta_num_bits, texel);

  delta = vec2(uint_delta) * box.size;
  delta /= float(fastuidraw_restricted_rays_position_delta_divide);
  position += delta;

  s.reference_position = position;
  s.reference_winding = int(biased_winding) - int(fastuidraw_restricted_rays_winding_value_bias);
}

float
fastuidraw_restricted_rays_compute_coverage(in uint glyph_data_location,
                                            in vec2 glyph_coord,
                                            in vec2 glyph_coord_dx,
                                            in vec2 glyph_coord_dy,
                                            in bool use_odd_even_rule
                                            #ifdef FASTUIDRAW_DEBUG
                                            ,out fastuidraw_restricted_rays_box_type out_texel_box,
                                            out fastuidraw_restricted_rays_winding_sample_type out_S,
                                            out int out_winding_number, out uint out_num_curves,
                                            out fastuidraw_restricted_rays_distance_type out_nv
                                            #endif
                                            )
{
  uint src, c, curve_list, winding_sample_data_location;
  fastuidraw_restricted_rays_transformation tr;
  fastuidraw_restricted_rays_box_type texel_box;
  fastuidraw_restricted_rays_winding_sample_type S;
  int winding_number;
  uint num_curves;
  fastuidraw_restricted_rays_distance_type nv;

  winding_sample_data_location =
    fastuidaw_restricted_rays_compute_box(glyph_coord,
                                          glyph_data_location,
                                          texel_box, curve_list, num_curves);
  fastuidraw_restricted_rays_init_distance(nv);
  fastuidraw_restricted_rays_load_winding_reference(winding_sample_data_location,
                                                    texel_box, S);

  fastuidraw_restricted_rays_compute_transformation(glyph_coord,
                                                    glyph_coord_dx, glyph_coord_dy,
                                                    S.reference_position, tr);
  winding_number = S.reference_winding;

  src = curve_list + glyph_data_location;
  for (c = 0u; c < num_curves; c += 2u)
    {
      uint cA, cB, curve_pair;

      curve_pair = fastuidraw_fetch_glyph_data(src);
      ++src;

      cA = FASTUIDRAW_EXTRACT_BITS(fastuidraw_restricted_rays_curve_entry0_bit0,
                                   fastuidraw_restricted_rays_curve_entry_num_bits,
                                   curve_pair);
      winding_number += fastuidraw_restricted_rays_load_and_process_curve(cA, glyph_data_location, tr, nv);

      if (c + 1u < num_curves)
        {
          cB = FASTUIDRAW_EXTRACT_BITS(fastuidraw_restricted_rays_curve_entry1_bit0,
                                       fastuidraw_restricted_rays_curve_entry_num_bits,
                                       curve_pair);
          winding_number += fastuidraw_restricted_rays_load_and_process_curve(cB, glyph_data_location, tr, nv);
        }
    }

  float cvg, distance;

  /* If using the odd-even fill rule of if the winding number at
   * the fragment is 0, use the minimum of those two; if the
   * winding value is 1 use the decrement value and if the winding
   * is -1 use the increment winding number; if the absolute value
   * of the winding value is greater than two, we will fallback
   * and simply view the fragment as fully covered.
   */
  if (winding_number == 0 || use_odd_even_rule)
    {
      distance = min(nv.distance_increment,
                     nv.distance_decrement);
    }
  else if (winding_number == -1)
    {
      distance = nv.distance_increment;
    }
  else if (winding_number == 1)
    {
      distance = nv.distance_decrement;
    }
  else
    {
      distance = 0.5;
    }

  distance = min(distance, 0.5);
  winding_number = (use_odd_even_rule && (winding_number & 1) == 0) ? 0 : winding_number;
  cvg = (winding_number != 0) ?
    (0.5 + distance) :
    (0.5 - distance);

  #ifdef FASTUIDRAW_DEBUG
    {
      out_texel_box = texel_box;
      out_S = S;
      out_winding_number = winding_number;
      out_num_curves = num_curves;
      out_nv = nv;
    }
  #endif

  return cvg;
}

#ifdef FASTUIDRAW_DEBUG
float
fastuidraw_restricted_rays_compute_coverage(in uint glyph_data_location,
                                            in vec2 glyph_coord,
                                            in vec2 glyph_coord_dx,
                                            in vec2 glyph_coord_dy,
                                            in bool use_odd_even_rule)
{
  fastuidraw_restricted_rays_box_type texel_box;
  fastuidraw_restricted_rays_winding_sample_type S;
  fastuidraw_restricted_rays_distance_type nv;
  int winding_number;
  uint num_curves;

  return fastuidraw_restricted_rays_compute_coverage(glyph_data_location,
                                                     glyph_coord,
                                                     glyph_coord_dx, glyph_coord_dy,
                                                     use_odd_even_rule,
                                                     texel_box, S, winding_number,
                                                     num_curves, nv);
}
#endif
///@endcond

/*!
 * Compute the coverage of a fragment within a \ref fastuidraw::GlyphRenderDataRestrictedRays glyph.
 * \param glyph_data_location location of the glyph data (see \ref
 *                            fastuidraw::GlyphRenderDataRestrictedRays::glyph_offset)
 * \param glyph_coord the coordinate of the fragment in glyph coordinates
 * \param glyph_coord_dx the value of dFdx(glyph_coord)
 * \param glyph_coord_dy the value of dFdy(glyph_coord)
 * \param use_odd_even_rule if true, use the odd-even fill rule, otherwise use the non-zero fill rule.
 */
float
fastuidraw_restricted_rays_compute_coverage(in uint glyph_data_location,
                                            in vec2 glyph_coord,
                                            in vec2 glyph_coord_dx,
                                            in vec2 glyph_coord_dy,
                                            in bool use_odd_even_rule);
/*! @} */